1 //===--- SemaDecl.cpp - Semantic Analysis for Declarations ----------------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 // 9 // This file implements semantic analysis for declarations. 10 // 11 //===----------------------------------------------------------------------===// 12 13 #include "TypeLocBuilder.h" 14 #include "clang/AST/ASTConsumer.h" 15 #include "clang/AST/ASTContext.h" 16 #include "clang/AST/ASTLambda.h" 17 #include "clang/AST/CXXInheritance.h" 18 #include "clang/AST/CharUnits.h" 19 #include "clang/AST/CommentDiagnostic.h" 20 #include "clang/AST/DeclCXX.h" 21 #include "clang/AST/DeclObjC.h" 22 #include "clang/AST/DeclTemplate.h" 23 #include "clang/AST/EvaluatedExprVisitor.h" 24 #include "clang/AST/Expr.h" 25 #include "clang/AST/ExprCXX.h" 26 #include "clang/AST/NonTrivialTypeVisitor.h" 27 #include "clang/AST/StmtCXX.h" 28 #include "clang/Basic/Builtins.h" 29 #include "clang/Basic/PartialDiagnostic.h" 30 #include "clang/Basic/SourceManager.h" 31 #include "clang/Basic/TargetInfo.h" 32 #include "clang/Lex/HeaderSearch.h" // TODO: Sema shouldn't depend on Lex 33 #include "clang/Lex/Lexer.h" // TODO: Extract static functions to fix layering. 34 #include "clang/Lex/ModuleLoader.h" // TODO: Sema shouldn't depend on Lex 35 #include "clang/Lex/Preprocessor.h" // Included for isCodeCompletionEnabled() 36 #include "clang/Sema/CXXFieldCollector.h" 37 #include "clang/Sema/DeclSpec.h" 38 #include "clang/Sema/DelayedDiagnostic.h" 39 #include "clang/Sema/Initialization.h" 40 #include "clang/Sema/Lookup.h" 41 #include "clang/Sema/ParsedTemplate.h" 42 #include "clang/Sema/Scope.h" 43 #include "clang/Sema/ScopeInfo.h" 44 #include "clang/Sema/SemaInternal.h" 45 #include "clang/Sema/Template.h" 46 #include "llvm/ADT/SmallString.h" 47 #include "llvm/ADT/Triple.h" 48 #include <algorithm> 49 #include <cstring> 50 #include <functional> 51 #include <unordered_map> 52 53 using namespace clang; 54 using namespace sema; 55 56 Sema::DeclGroupPtrTy Sema::ConvertDeclToDeclGroup(Decl *Ptr, Decl *OwnedType) { 57 if (OwnedType) { 58 Decl *Group[2] = { OwnedType, Ptr }; 59 return DeclGroupPtrTy::make(DeclGroupRef::Create(Context, Group, 2)); 60 } 61 62 return DeclGroupPtrTy::make(DeclGroupRef(Ptr)); 63 } 64 65 namespace { 66 67 class TypeNameValidatorCCC final : public CorrectionCandidateCallback { 68 public: 69 TypeNameValidatorCCC(bool AllowInvalid, bool WantClass = false, 70 bool AllowTemplates = false, 71 bool AllowNonTemplates = true) 72 : AllowInvalidDecl(AllowInvalid), WantClassName(WantClass), 73 AllowTemplates(AllowTemplates), AllowNonTemplates(AllowNonTemplates) { 74 WantExpressionKeywords = false; 75 WantCXXNamedCasts = false; 76 WantRemainingKeywords = false; 77 } 78 79 bool ValidateCandidate(const TypoCorrection &candidate) override { 80 if (NamedDecl *ND = candidate.getCorrectionDecl()) { 81 if (!AllowInvalidDecl && ND->isInvalidDecl()) 82 return false; 83 84 if (getAsTypeTemplateDecl(ND)) 85 return AllowTemplates; 86 87 bool IsType = isa<TypeDecl>(ND) || isa<ObjCInterfaceDecl>(ND); 88 if (!IsType) 89 return false; 90 91 if (AllowNonTemplates) 92 return true; 93 94 // An injected-class-name of a class template (specialization) is valid 95 // as a template or as a non-template. 96 if (AllowTemplates) { 97 auto *RD = dyn_cast<CXXRecordDecl>(ND); 98 if (!RD || !RD->isInjectedClassName()) 99 return false; 100 RD = cast<CXXRecordDecl>(RD->getDeclContext()); 101 return RD->getDescribedClassTemplate() || 102 isa<ClassTemplateSpecializationDecl>(RD); 103 } 104 105 return false; 106 } 107 108 return !WantClassName && candidate.isKeyword(); 109 } 110 111 std::unique_ptr<CorrectionCandidateCallback> clone() override { 112 return std::make_unique<TypeNameValidatorCCC>(*this); 113 } 114 115 private: 116 bool AllowInvalidDecl; 117 bool WantClassName; 118 bool AllowTemplates; 119 bool AllowNonTemplates; 120 }; 121 122 } // end anonymous namespace 123 124 /// Determine whether the token kind starts a simple-type-specifier. 125 bool Sema::isSimpleTypeSpecifier(tok::TokenKind Kind) const { 126 switch (Kind) { 127 // FIXME: Take into account the current language when deciding whether a 128 // token kind is a valid type specifier 129 case tok::kw_short: 130 case tok::kw_long: 131 case tok::kw___int64: 132 case tok::kw___int128: 133 case tok::kw_signed: 134 case tok::kw_unsigned: 135 case tok::kw_void: 136 case tok::kw_char: 137 case tok::kw_int: 138 case tok::kw_half: 139 case tok::kw_float: 140 case tok::kw_double: 141 case tok::kw___bf16: 142 case tok::kw__Float16: 143 case tok::kw___float128: 144 case tok::kw_wchar_t: 145 case tok::kw_bool: 146 case tok::kw___underlying_type: 147 case tok::kw___auto_type: 148 return true; 149 150 case tok::annot_typename: 151 case tok::kw_char16_t: 152 case tok::kw_char32_t: 153 case tok::kw_typeof: 154 case tok::annot_decltype: 155 case tok::kw_decltype: 156 return getLangOpts().CPlusPlus; 157 158 case tok::kw_char8_t: 159 return getLangOpts().Char8; 160 161 default: 162 break; 163 } 164 165 return false; 166 } 167 168 namespace { 169 enum class UnqualifiedTypeNameLookupResult { 170 NotFound, 171 FoundNonType, 172 FoundType 173 }; 174 } // end anonymous namespace 175 176 /// Tries to perform unqualified lookup of the type decls in bases for 177 /// dependent class. 178 /// \return \a NotFound if no any decls is found, \a FoundNotType if found not a 179 /// type decl, \a FoundType if only type decls are found. 180 static UnqualifiedTypeNameLookupResult 181 lookupUnqualifiedTypeNameInBase(Sema &S, const IdentifierInfo &II, 182 SourceLocation NameLoc, 183 const CXXRecordDecl *RD) { 184 if (!RD->hasDefinition()) 185 return UnqualifiedTypeNameLookupResult::NotFound; 186 // Look for type decls in base classes. 187 UnqualifiedTypeNameLookupResult FoundTypeDecl = 188 UnqualifiedTypeNameLookupResult::NotFound; 189 for (const auto &Base : RD->bases()) { 190 const CXXRecordDecl *BaseRD = nullptr; 191 if (auto *BaseTT = Base.getType()->getAs<TagType>()) 192 BaseRD = BaseTT->getAsCXXRecordDecl(); 193 else if (auto *TST = Base.getType()->getAs<TemplateSpecializationType>()) { 194 // Look for type decls in dependent base classes that have known primary 195 // templates. 196 if (!TST || !TST->isDependentType()) 197 continue; 198 auto *TD = TST->getTemplateName().getAsTemplateDecl(); 199 if (!TD) 200 continue; 201 if (auto *BasePrimaryTemplate = 202 dyn_cast_or_null<CXXRecordDecl>(TD->getTemplatedDecl())) { 203 if (BasePrimaryTemplate->getCanonicalDecl() != RD->getCanonicalDecl()) 204 BaseRD = BasePrimaryTemplate; 205 else if (auto *CTD = dyn_cast<ClassTemplateDecl>(TD)) { 206 if (const ClassTemplatePartialSpecializationDecl *PS = 207 CTD->findPartialSpecialization(Base.getType())) 208 if (PS->getCanonicalDecl() != RD->getCanonicalDecl()) 209 BaseRD = PS; 210 } 211 } 212 } 213 if (BaseRD) { 214 for (NamedDecl *ND : BaseRD->lookup(&II)) { 215 if (!isa<TypeDecl>(ND)) 216 return UnqualifiedTypeNameLookupResult::FoundNonType; 217 FoundTypeDecl = UnqualifiedTypeNameLookupResult::FoundType; 218 } 219 if (FoundTypeDecl == UnqualifiedTypeNameLookupResult::NotFound) { 220 switch (lookupUnqualifiedTypeNameInBase(S, II, NameLoc, BaseRD)) { 221 case UnqualifiedTypeNameLookupResult::FoundNonType: 222 return UnqualifiedTypeNameLookupResult::FoundNonType; 223 case UnqualifiedTypeNameLookupResult::FoundType: 224 FoundTypeDecl = UnqualifiedTypeNameLookupResult::FoundType; 225 break; 226 case UnqualifiedTypeNameLookupResult::NotFound: 227 break; 228 } 229 } 230 } 231 } 232 233 return FoundTypeDecl; 234 } 235 236 static ParsedType recoverFromTypeInKnownDependentBase(Sema &S, 237 const IdentifierInfo &II, 238 SourceLocation NameLoc) { 239 // Lookup in the parent class template context, if any. 240 const CXXRecordDecl *RD = nullptr; 241 UnqualifiedTypeNameLookupResult FoundTypeDecl = 242 UnqualifiedTypeNameLookupResult::NotFound; 243 for (DeclContext *DC = S.CurContext; 244 DC && FoundTypeDecl == UnqualifiedTypeNameLookupResult::NotFound; 245 DC = DC->getParent()) { 246 // Look for type decls in dependent base classes that have known primary 247 // templates. 248 RD = dyn_cast<CXXRecordDecl>(DC); 249 if (RD && RD->getDescribedClassTemplate()) 250 FoundTypeDecl = lookupUnqualifiedTypeNameInBase(S, II, NameLoc, RD); 251 } 252 if (FoundTypeDecl != UnqualifiedTypeNameLookupResult::FoundType) 253 return nullptr; 254 255 // We found some types in dependent base classes. Recover as if the user 256 // wrote 'typename MyClass::II' instead of 'II'. We'll fully resolve the 257 // lookup during template instantiation. 258 S.Diag(NameLoc, diag::ext_found_in_dependent_base) << &II; 259 260 ASTContext &Context = S.Context; 261 auto *NNS = NestedNameSpecifier::Create(Context, nullptr, false, 262 cast<Type>(Context.getRecordType(RD))); 263 QualType T = Context.getDependentNameType(ETK_Typename, NNS, &II); 264 265 CXXScopeSpec SS; 266 SS.MakeTrivial(Context, NNS, SourceRange(NameLoc)); 267 268 TypeLocBuilder Builder; 269 DependentNameTypeLoc DepTL = Builder.push<DependentNameTypeLoc>(T); 270 DepTL.setNameLoc(NameLoc); 271 DepTL.setElaboratedKeywordLoc(SourceLocation()); 272 DepTL.setQualifierLoc(SS.getWithLocInContext(Context)); 273 return S.CreateParsedType(T, Builder.getTypeSourceInfo(Context, T)); 274 } 275 276 /// If the identifier refers to a type name within this scope, 277 /// return the declaration of that type. 278 /// 279 /// This routine performs ordinary name lookup of the identifier II 280 /// within the given scope, with optional C++ scope specifier SS, to 281 /// determine whether the name refers to a type. If so, returns an 282 /// opaque pointer (actually a QualType) corresponding to that 283 /// type. Otherwise, returns NULL. 284 ParsedType Sema::getTypeName(const IdentifierInfo &II, SourceLocation NameLoc, 285 Scope *S, CXXScopeSpec *SS, 286 bool isClassName, bool HasTrailingDot, 287 ParsedType ObjectTypePtr, 288 bool IsCtorOrDtorName, 289 bool WantNontrivialTypeSourceInfo, 290 bool IsClassTemplateDeductionContext, 291 IdentifierInfo **CorrectedII) { 292 // FIXME: Consider allowing this outside C++1z mode as an extension. 293 bool AllowDeducedTemplate = IsClassTemplateDeductionContext && 294 getLangOpts().CPlusPlus17 && !IsCtorOrDtorName && 295 !isClassName && !HasTrailingDot; 296 297 // Determine where we will perform name lookup. 298 DeclContext *LookupCtx = nullptr; 299 if (ObjectTypePtr) { 300 QualType ObjectType = ObjectTypePtr.get(); 301 if (ObjectType->isRecordType()) 302 LookupCtx = computeDeclContext(ObjectType); 303 } else if (SS && SS->isNotEmpty()) { 304 LookupCtx = computeDeclContext(*SS, false); 305 306 if (!LookupCtx) { 307 if (isDependentScopeSpecifier(*SS)) { 308 // C++ [temp.res]p3: 309 // A qualified-id that refers to a type and in which the 310 // nested-name-specifier depends on a template-parameter (14.6.2) 311 // shall be prefixed by the keyword typename to indicate that the 312 // qualified-id denotes a type, forming an 313 // elaborated-type-specifier (7.1.5.3). 314 // 315 // We therefore do not perform any name lookup if the result would 316 // refer to a member of an unknown specialization. 317 if (!isClassName && !IsCtorOrDtorName) 318 return nullptr; 319 320 // We know from the grammar that this name refers to a type, 321 // so build a dependent node to describe the type. 322 if (WantNontrivialTypeSourceInfo) 323 return ActOnTypenameType(S, SourceLocation(), *SS, II, NameLoc).get(); 324 325 NestedNameSpecifierLoc QualifierLoc = SS->getWithLocInContext(Context); 326 QualType T = CheckTypenameType(ETK_None, SourceLocation(), QualifierLoc, 327 II, NameLoc); 328 return ParsedType::make(T); 329 } 330 331 return nullptr; 332 } 333 334 if (!LookupCtx->isDependentContext() && 335 RequireCompleteDeclContext(*SS, LookupCtx)) 336 return nullptr; 337 } 338 339 // FIXME: LookupNestedNameSpecifierName isn't the right kind of 340 // lookup for class-names. 341 LookupNameKind Kind = isClassName ? LookupNestedNameSpecifierName : 342 LookupOrdinaryName; 343 LookupResult Result(*this, &II, NameLoc, Kind); 344 if (LookupCtx) { 345 // Perform "qualified" name lookup into the declaration context we 346 // computed, which is either the type of the base of a member access 347 // expression or the declaration context associated with a prior 348 // nested-name-specifier. 349 LookupQualifiedName(Result, LookupCtx); 350 351 if (ObjectTypePtr && Result.empty()) { 352 // C++ [basic.lookup.classref]p3: 353 // If the unqualified-id is ~type-name, the type-name is looked up 354 // in the context of the entire postfix-expression. If the type T of 355 // the object expression is of a class type C, the type-name is also 356 // looked up in the scope of class C. At least one of the lookups shall 357 // find a name that refers to (possibly cv-qualified) T. 358 LookupName(Result, S); 359 } 360 } else { 361 // Perform unqualified name lookup. 362 LookupName(Result, S); 363 364 // For unqualified lookup in a class template in MSVC mode, look into 365 // dependent base classes where the primary class template is known. 366 if (Result.empty() && getLangOpts().MSVCCompat && (!SS || SS->isEmpty())) { 367 if (ParsedType TypeInBase = 368 recoverFromTypeInKnownDependentBase(*this, II, NameLoc)) 369 return TypeInBase; 370 } 371 } 372 373 NamedDecl *IIDecl = nullptr; 374 switch (Result.getResultKind()) { 375 case LookupResult::NotFound: 376 case LookupResult::NotFoundInCurrentInstantiation: 377 if (CorrectedII) { 378 TypeNameValidatorCCC CCC(/*AllowInvalid=*/true, isClassName, 379 AllowDeducedTemplate); 380 TypoCorrection Correction = CorrectTypo(Result.getLookupNameInfo(), Kind, 381 S, SS, CCC, CTK_ErrorRecovery); 382 IdentifierInfo *NewII = Correction.getCorrectionAsIdentifierInfo(); 383 TemplateTy Template; 384 bool MemberOfUnknownSpecialization; 385 UnqualifiedId TemplateName; 386 TemplateName.setIdentifier(NewII, NameLoc); 387 NestedNameSpecifier *NNS = Correction.getCorrectionSpecifier(); 388 CXXScopeSpec NewSS, *NewSSPtr = SS; 389 if (SS && NNS) { 390 NewSS.MakeTrivial(Context, NNS, SourceRange(NameLoc)); 391 NewSSPtr = &NewSS; 392 } 393 if (Correction && (NNS || NewII != &II) && 394 // Ignore a correction to a template type as the to-be-corrected 395 // identifier is not a template (typo correction for template names 396 // is handled elsewhere). 397 !(getLangOpts().CPlusPlus && NewSSPtr && 398 isTemplateName(S, *NewSSPtr, false, TemplateName, nullptr, false, 399 Template, MemberOfUnknownSpecialization))) { 400 ParsedType Ty = getTypeName(*NewII, NameLoc, S, NewSSPtr, 401 isClassName, HasTrailingDot, ObjectTypePtr, 402 IsCtorOrDtorName, 403 WantNontrivialTypeSourceInfo, 404 IsClassTemplateDeductionContext); 405 if (Ty) { 406 diagnoseTypo(Correction, 407 PDiag(diag::err_unknown_type_or_class_name_suggest) 408 << Result.getLookupName() << isClassName); 409 if (SS && NNS) 410 SS->MakeTrivial(Context, NNS, SourceRange(NameLoc)); 411 *CorrectedII = NewII; 412 return Ty; 413 } 414 } 415 } 416 // If typo correction failed or was not performed, fall through 417 LLVM_FALLTHROUGH; 418 case LookupResult::FoundOverloaded: 419 case LookupResult::FoundUnresolvedValue: 420 Result.suppressDiagnostics(); 421 return nullptr; 422 423 case LookupResult::Ambiguous: 424 // Recover from type-hiding ambiguities by hiding the type. We'll 425 // do the lookup again when looking for an object, and we can 426 // diagnose the error then. If we don't do this, then the error 427 // about hiding the type will be immediately followed by an error 428 // that only makes sense if the identifier was treated like a type. 429 if (Result.getAmbiguityKind() == LookupResult::AmbiguousTagHiding) { 430 Result.suppressDiagnostics(); 431 return nullptr; 432 } 433 434 // Look to see if we have a type anywhere in the list of results. 435 for (LookupResult::iterator Res = Result.begin(), ResEnd = Result.end(); 436 Res != ResEnd; ++Res) { 437 if (isa<TypeDecl>(*Res) || isa<ObjCInterfaceDecl>(*Res) || 438 (AllowDeducedTemplate && getAsTypeTemplateDecl(*Res))) { 439 if (!IIDecl || (*Res)->getLocation() < IIDecl->getLocation()) 440 IIDecl = *Res; 441 } 442 } 443 444 if (!IIDecl) { 445 // None of the entities we found is a type, so there is no way 446 // to even assume that the result is a type. In this case, don't 447 // complain about the ambiguity. The parser will either try to 448 // perform this lookup again (e.g., as an object name), which 449 // will produce the ambiguity, or will complain that it expected 450 // a type name. 451 Result.suppressDiagnostics(); 452 return nullptr; 453 } 454 455 // We found a type within the ambiguous lookup; diagnose the 456 // ambiguity and then return that type. This might be the right 457 // answer, or it might not be, but it suppresses any attempt to 458 // perform the name lookup again. 459 break; 460 461 case LookupResult::Found: 462 IIDecl = Result.getFoundDecl(); 463 break; 464 } 465 466 assert(IIDecl && "Didn't find decl"); 467 468 QualType T; 469 if (TypeDecl *TD = dyn_cast<TypeDecl>(IIDecl)) { 470 // C++ [class.qual]p2: A lookup that would find the injected-class-name 471 // instead names the constructors of the class, except when naming a class. 472 // This is ill-formed when we're not actually forming a ctor or dtor name. 473 auto *LookupRD = dyn_cast_or_null<CXXRecordDecl>(LookupCtx); 474 auto *FoundRD = dyn_cast<CXXRecordDecl>(TD); 475 if (!isClassName && !IsCtorOrDtorName && LookupRD && FoundRD && 476 FoundRD->isInjectedClassName() && 477 declaresSameEntity(LookupRD, cast<Decl>(FoundRD->getParent()))) 478 Diag(NameLoc, diag::err_out_of_line_qualified_id_type_names_constructor) 479 << &II << /*Type*/1; 480 481 DiagnoseUseOfDecl(IIDecl, NameLoc); 482 483 T = Context.getTypeDeclType(TD); 484 MarkAnyDeclReferenced(TD->getLocation(), TD, /*OdrUse=*/false); 485 } else if (ObjCInterfaceDecl *IDecl = dyn_cast<ObjCInterfaceDecl>(IIDecl)) { 486 (void)DiagnoseUseOfDecl(IDecl, NameLoc); 487 if (!HasTrailingDot) 488 T = Context.getObjCInterfaceType(IDecl); 489 } else if (AllowDeducedTemplate) { 490 if (auto *TD = getAsTypeTemplateDecl(IIDecl)) 491 T = Context.getDeducedTemplateSpecializationType(TemplateName(TD), 492 QualType(), false); 493 } 494 495 if (T.isNull()) { 496 // If it's not plausibly a type, suppress diagnostics. 497 Result.suppressDiagnostics(); 498 return nullptr; 499 } 500 501 // NOTE: avoid constructing an ElaboratedType(Loc) if this is a 502 // constructor or destructor name (in such a case, the scope specifier 503 // will be attached to the enclosing Expr or Decl node). 504 if (SS && SS->isNotEmpty() && !IsCtorOrDtorName && 505 !isa<ObjCInterfaceDecl>(IIDecl)) { 506 if (WantNontrivialTypeSourceInfo) { 507 // Construct a type with type-source information. 508 TypeLocBuilder Builder; 509 Builder.pushTypeSpec(T).setNameLoc(NameLoc); 510 511 T = getElaboratedType(ETK_None, *SS, T); 512 ElaboratedTypeLoc ElabTL = Builder.push<ElaboratedTypeLoc>(T); 513 ElabTL.setElaboratedKeywordLoc(SourceLocation()); 514 ElabTL.setQualifierLoc(SS->getWithLocInContext(Context)); 515 return CreateParsedType(T, Builder.getTypeSourceInfo(Context, T)); 516 } else { 517 T = getElaboratedType(ETK_None, *SS, T); 518 } 519 } 520 521 return ParsedType::make(T); 522 } 523 524 // Builds a fake NNS for the given decl context. 525 static NestedNameSpecifier * 526 synthesizeCurrentNestedNameSpecifier(ASTContext &Context, DeclContext *DC) { 527 for (;; DC = DC->getLookupParent()) { 528 DC = DC->getPrimaryContext(); 529 auto *ND = dyn_cast<NamespaceDecl>(DC); 530 if (ND && !ND->isInline() && !ND->isAnonymousNamespace()) 531 return NestedNameSpecifier::Create(Context, nullptr, ND); 532 else if (auto *RD = dyn_cast<CXXRecordDecl>(DC)) 533 return NestedNameSpecifier::Create(Context, nullptr, RD->isTemplateDecl(), 534 RD->getTypeForDecl()); 535 else if (isa<TranslationUnitDecl>(DC)) 536 return NestedNameSpecifier::GlobalSpecifier(Context); 537 } 538 llvm_unreachable("something isn't in TU scope?"); 539 } 540 541 /// Find the parent class with dependent bases of the innermost enclosing method 542 /// context. Do not look for enclosing CXXRecordDecls directly, or we will end 543 /// up allowing unqualified dependent type names at class-level, which MSVC 544 /// correctly rejects. 545 static const CXXRecordDecl * 546 findRecordWithDependentBasesOfEnclosingMethod(const DeclContext *DC) { 547 for (; DC && DC->isDependentContext(); DC = DC->getLookupParent()) { 548 DC = DC->getPrimaryContext(); 549 if (const auto *MD = dyn_cast<CXXMethodDecl>(DC)) 550 if (MD->getParent()->hasAnyDependentBases()) 551 return MD->getParent(); 552 } 553 return nullptr; 554 } 555 556 ParsedType Sema::ActOnMSVCUnknownTypeName(const IdentifierInfo &II, 557 SourceLocation NameLoc, 558 bool IsTemplateTypeArg) { 559 assert(getLangOpts().MSVCCompat && "shouldn't be called in non-MSVC mode"); 560 561 NestedNameSpecifier *NNS = nullptr; 562 if (IsTemplateTypeArg && getCurScope()->isTemplateParamScope()) { 563 // If we weren't able to parse a default template argument, delay lookup 564 // until instantiation time by making a non-dependent DependentTypeName. We 565 // pretend we saw a NestedNameSpecifier referring to the current scope, and 566 // lookup is retried. 567 // FIXME: This hurts our diagnostic quality, since we get errors like "no 568 // type named 'Foo' in 'current_namespace'" when the user didn't write any 569 // name specifiers. 570 NNS = synthesizeCurrentNestedNameSpecifier(Context, CurContext); 571 Diag(NameLoc, diag::ext_ms_delayed_template_argument) << &II; 572 } else if (const CXXRecordDecl *RD = 573 findRecordWithDependentBasesOfEnclosingMethod(CurContext)) { 574 // Build a DependentNameType that will perform lookup into RD at 575 // instantiation time. 576 NNS = NestedNameSpecifier::Create(Context, nullptr, RD->isTemplateDecl(), 577 RD->getTypeForDecl()); 578 579 // Diagnose that this identifier was undeclared, and retry the lookup during 580 // template instantiation. 581 Diag(NameLoc, diag::ext_undeclared_unqual_id_with_dependent_base) << &II 582 << RD; 583 } else { 584 // This is not a situation that we should recover from. 585 return ParsedType(); 586 } 587 588 QualType T = Context.getDependentNameType(ETK_None, NNS, &II); 589 590 // Build type location information. We synthesized the qualifier, so we have 591 // to build a fake NestedNameSpecifierLoc. 592 NestedNameSpecifierLocBuilder NNSLocBuilder; 593 NNSLocBuilder.MakeTrivial(Context, NNS, SourceRange(NameLoc)); 594 NestedNameSpecifierLoc QualifierLoc = NNSLocBuilder.getWithLocInContext(Context); 595 596 TypeLocBuilder Builder; 597 DependentNameTypeLoc DepTL = Builder.push<DependentNameTypeLoc>(T); 598 DepTL.setNameLoc(NameLoc); 599 DepTL.setElaboratedKeywordLoc(SourceLocation()); 600 DepTL.setQualifierLoc(QualifierLoc); 601 return CreateParsedType(T, Builder.getTypeSourceInfo(Context, T)); 602 } 603 604 /// isTagName() - This method is called *for error recovery purposes only* 605 /// to determine if the specified name is a valid tag name ("struct foo"). If 606 /// so, this returns the TST for the tag corresponding to it (TST_enum, 607 /// TST_union, TST_struct, TST_interface, TST_class). This is used to diagnose 608 /// cases in C where the user forgot to specify the tag. 609 DeclSpec::TST Sema::isTagName(IdentifierInfo &II, Scope *S) { 610 // Do a tag name lookup in this scope. 611 LookupResult R(*this, &II, SourceLocation(), LookupTagName); 612 LookupName(R, S, false); 613 R.suppressDiagnostics(); 614 if (R.getResultKind() == LookupResult::Found) 615 if (const TagDecl *TD = R.getAsSingle<TagDecl>()) { 616 switch (TD->getTagKind()) { 617 case TTK_Struct: return DeclSpec::TST_struct; 618 case TTK_Interface: return DeclSpec::TST_interface; 619 case TTK_Union: return DeclSpec::TST_union; 620 case TTK_Class: return DeclSpec::TST_class; 621 case TTK_Enum: return DeclSpec::TST_enum; 622 } 623 } 624 625 return DeclSpec::TST_unspecified; 626 } 627 628 /// isMicrosoftMissingTypename - In Microsoft mode, within class scope, 629 /// if a CXXScopeSpec's type is equal to the type of one of the base classes 630 /// then downgrade the missing typename error to a warning. 631 /// This is needed for MSVC compatibility; Example: 632 /// @code 633 /// template<class T> class A { 634 /// public: 635 /// typedef int TYPE; 636 /// }; 637 /// template<class T> class B : public A<T> { 638 /// public: 639 /// A<T>::TYPE a; // no typename required because A<T> is a base class. 640 /// }; 641 /// @endcode 642 bool Sema::isMicrosoftMissingTypename(const CXXScopeSpec *SS, Scope *S) { 643 if (CurContext->isRecord()) { 644 if (SS->getScopeRep()->getKind() == NestedNameSpecifier::Super) 645 return true; 646 647 const Type *Ty = SS->getScopeRep()->getAsType(); 648 649 CXXRecordDecl *RD = cast<CXXRecordDecl>(CurContext); 650 for (const auto &Base : RD->bases()) 651 if (Ty && Context.hasSameUnqualifiedType(QualType(Ty, 1), Base.getType())) 652 return true; 653 return S->isFunctionPrototypeScope(); 654 } 655 return CurContext->isFunctionOrMethod() || S->isFunctionPrototypeScope(); 656 } 657 658 void Sema::DiagnoseUnknownTypeName(IdentifierInfo *&II, 659 SourceLocation IILoc, 660 Scope *S, 661 CXXScopeSpec *SS, 662 ParsedType &SuggestedType, 663 bool IsTemplateName) { 664 // Don't report typename errors for editor placeholders. 665 if (II->isEditorPlaceholder()) 666 return; 667 // We don't have anything to suggest (yet). 668 SuggestedType = nullptr; 669 670 // There may have been a typo in the name of the type. Look up typo 671 // results, in case we have something that we can suggest. 672 TypeNameValidatorCCC CCC(/*AllowInvalid=*/false, /*WantClass=*/false, 673 /*AllowTemplates=*/IsTemplateName, 674 /*AllowNonTemplates=*/!IsTemplateName); 675 if (TypoCorrection Corrected = 676 CorrectTypo(DeclarationNameInfo(II, IILoc), LookupOrdinaryName, S, SS, 677 CCC, CTK_ErrorRecovery)) { 678 // FIXME: Support error recovery for the template-name case. 679 bool CanRecover = !IsTemplateName; 680 if (Corrected.isKeyword()) { 681 // We corrected to a keyword. 682 diagnoseTypo(Corrected, 683 PDiag(IsTemplateName ? diag::err_no_template_suggest 684 : diag::err_unknown_typename_suggest) 685 << II); 686 II = Corrected.getCorrectionAsIdentifierInfo(); 687 } else { 688 // We found a similarly-named type or interface; suggest that. 689 if (!SS || !SS->isSet()) { 690 diagnoseTypo(Corrected, 691 PDiag(IsTemplateName ? diag::err_no_template_suggest 692 : diag::err_unknown_typename_suggest) 693 << II, CanRecover); 694 } else if (DeclContext *DC = computeDeclContext(*SS, false)) { 695 std::string CorrectedStr(Corrected.getAsString(getLangOpts())); 696 bool DroppedSpecifier = Corrected.WillReplaceSpecifier() && 697 II->getName().equals(CorrectedStr); 698 diagnoseTypo(Corrected, 699 PDiag(IsTemplateName 700 ? diag::err_no_member_template_suggest 701 : diag::err_unknown_nested_typename_suggest) 702 << II << DC << DroppedSpecifier << SS->getRange(), 703 CanRecover); 704 } else { 705 llvm_unreachable("could not have corrected a typo here"); 706 } 707 708 if (!CanRecover) 709 return; 710 711 CXXScopeSpec tmpSS; 712 if (Corrected.getCorrectionSpecifier()) 713 tmpSS.MakeTrivial(Context, Corrected.getCorrectionSpecifier(), 714 SourceRange(IILoc)); 715 // FIXME: Support class template argument deduction here. 716 SuggestedType = 717 getTypeName(*Corrected.getCorrectionAsIdentifierInfo(), IILoc, S, 718 tmpSS.isSet() ? &tmpSS : SS, false, false, nullptr, 719 /*IsCtorOrDtorName=*/false, 720 /*WantNontrivialTypeSourceInfo=*/true); 721 } 722 return; 723 } 724 725 if (getLangOpts().CPlusPlus && !IsTemplateName) { 726 // See if II is a class template that the user forgot to pass arguments to. 727 UnqualifiedId Name; 728 Name.setIdentifier(II, IILoc); 729 CXXScopeSpec EmptySS; 730 TemplateTy TemplateResult; 731 bool MemberOfUnknownSpecialization; 732 if (isTemplateName(S, SS ? *SS : EmptySS, /*hasTemplateKeyword=*/false, 733 Name, nullptr, true, TemplateResult, 734 MemberOfUnknownSpecialization) == TNK_Type_template) { 735 diagnoseMissingTemplateArguments(TemplateResult.get(), IILoc); 736 return; 737 } 738 } 739 740 // FIXME: Should we move the logic that tries to recover from a missing tag 741 // (struct, union, enum) from Parser::ParseImplicitInt here, instead? 742 743 if (!SS || (!SS->isSet() && !SS->isInvalid())) 744 Diag(IILoc, IsTemplateName ? diag::err_no_template 745 : diag::err_unknown_typename) 746 << II; 747 else if (DeclContext *DC = computeDeclContext(*SS, false)) 748 Diag(IILoc, IsTemplateName ? diag::err_no_member_template 749 : diag::err_typename_nested_not_found) 750 << II << DC << SS->getRange(); 751 else if (SS->isValid() && SS->getScopeRep()->containsErrors()) { 752 SuggestedType = 753 ActOnTypenameType(S, SourceLocation(), *SS, *II, IILoc).get(); 754 } else if (isDependentScopeSpecifier(*SS)) { 755 unsigned DiagID = diag::err_typename_missing; 756 if (getLangOpts().MSVCCompat && isMicrosoftMissingTypename(SS, S)) 757 DiagID = diag::ext_typename_missing; 758 759 Diag(SS->getRange().getBegin(), DiagID) 760 << SS->getScopeRep() << II->getName() 761 << SourceRange(SS->getRange().getBegin(), IILoc) 762 << FixItHint::CreateInsertion(SS->getRange().getBegin(), "typename "); 763 SuggestedType = ActOnTypenameType(S, SourceLocation(), 764 *SS, *II, IILoc).get(); 765 } else { 766 assert(SS && SS->isInvalid() && 767 "Invalid scope specifier has already been diagnosed"); 768 } 769 } 770 771 /// Determine whether the given result set contains either a type name 772 /// or 773 static bool isResultTypeOrTemplate(LookupResult &R, const Token &NextToken) { 774 bool CheckTemplate = R.getSema().getLangOpts().CPlusPlus && 775 NextToken.is(tok::less); 776 777 for (LookupResult::iterator I = R.begin(), IEnd = R.end(); I != IEnd; ++I) { 778 if (isa<TypeDecl>(*I) || isa<ObjCInterfaceDecl>(*I)) 779 return true; 780 781 if (CheckTemplate && isa<TemplateDecl>(*I)) 782 return true; 783 } 784 785 return false; 786 } 787 788 static bool isTagTypeWithMissingTag(Sema &SemaRef, LookupResult &Result, 789 Scope *S, CXXScopeSpec &SS, 790 IdentifierInfo *&Name, 791 SourceLocation NameLoc) { 792 LookupResult R(SemaRef, Name, NameLoc, Sema::LookupTagName); 793 SemaRef.LookupParsedName(R, S, &SS); 794 if (TagDecl *Tag = R.getAsSingle<TagDecl>()) { 795 StringRef FixItTagName; 796 switch (Tag->getTagKind()) { 797 case TTK_Class: 798 FixItTagName = "class "; 799 break; 800 801 case TTK_Enum: 802 FixItTagName = "enum "; 803 break; 804 805 case TTK_Struct: 806 FixItTagName = "struct "; 807 break; 808 809 case TTK_Interface: 810 FixItTagName = "__interface "; 811 break; 812 813 case TTK_Union: 814 FixItTagName = "union "; 815 break; 816 } 817 818 StringRef TagName = FixItTagName.drop_back(); 819 SemaRef.Diag(NameLoc, diag::err_use_of_tag_name_without_tag) 820 << Name << TagName << SemaRef.getLangOpts().CPlusPlus 821 << FixItHint::CreateInsertion(NameLoc, FixItTagName); 822 823 for (LookupResult::iterator I = Result.begin(), IEnd = Result.end(); 824 I != IEnd; ++I) 825 SemaRef.Diag((*I)->getLocation(), diag::note_decl_hiding_tag_type) 826 << Name << TagName; 827 828 // Replace lookup results with just the tag decl. 829 Result.clear(Sema::LookupTagName); 830 SemaRef.LookupParsedName(Result, S, &SS); 831 return true; 832 } 833 834 return false; 835 } 836 837 /// Build a ParsedType for a simple-type-specifier with a nested-name-specifier. 838 static ParsedType buildNestedType(Sema &S, CXXScopeSpec &SS, 839 QualType T, SourceLocation NameLoc) { 840 ASTContext &Context = S.Context; 841 842 TypeLocBuilder Builder; 843 Builder.pushTypeSpec(T).setNameLoc(NameLoc); 844 845 T = S.getElaboratedType(ETK_None, SS, T); 846 ElaboratedTypeLoc ElabTL = Builder.push<ElaboratedTypeLoc>(T); 847 ElabTL.setElaboratedKeywordLoc(SourceLocation()); 848 ElabTL.setQualifierLoc(SS.getWithLocInContext(Context)); 849 return S.CreateParsedType(T, Builder.getTypeSourceInfo(Context, T)); 850 } 851 852 Sema::NameClassification Sema::ClassifyName(Scope *S, CXXScopeSpec &SS, 853 IdentifierInfo *&Name, 854 SourceLocation NameLoc, 855 const Token &NextToken, 856 CorrectionCandidateCallback *CCC) { 857 DeclarationNameInfo NameInfo(Name, NameLoc); 858 ObjCMethodDecl *CurMethod = getCurMethodDecl(); 859 860 assert(NextToken.isNot(tok::coloncolon) && 861 "parse nested name specifiers before calling ClassifyName"); 862 if (getLangOpts().CPlusPlus && SS.isSet() && 863 isCurrentClassName(*Name, S, &SS)) { 864 // Per [class.qual]p2, this names the constructors of SS, not the 865 // injected-class-name. We don't have a classification for that. 866 // There's not much point caching this result, since the parser 867 // will reject it later. 868 return NameClassification::Unknown(); 869 } 870 871 LookupResult Result(*this, Name, NameLoc, LookupOrdinaryName); 872 LookupParsedName(Result, S, &SS, !CurMethod); 873 874 if (SS.isInvalid()) 875 return NameClassification::Error(); 876 877 // For unqualified lookup in a class template in MSVC mode, look into 878 // dependent base classes where the primary class template is known. 879 if (Result.empty() && SS.isEmpty() && getLangOpts().MSVCCompat) { 880 if (ParsedType TypeInBase = 881 recoverFromTypeInKnownDependentBase(*this, *Name, NameLoc)) 882 return TypeInBase; 883 } 884 885 // Perform lookup for Objective-C instance variables (including automatically 886 // synthesized instance variables), if we're in an Objective-C method. 887 // FIXME: This lookup really, really needs to be folded in to the normal 888 // unqualified lookup mechanism. 889 if (SS.isEmpty() && CurMethod && !isResultTypeOrTemplate(Result, NextToken)) { 890 DeclResult Ivar = LookupIvarInObjCMethod(Result, S, Name); 891 if (Ivar.isInvalid()) 892 return NameClassification::Error(); 893 if (Ivar.isUsable()) 894 return NameClassification::NonType(cast<NamedDecl>(Ivar.get())); 895 896 // We defer builtin creation until after ivar lookup inside ObjC methods. 897 if (Result.empty()) 898 LookupBuiltin(Result); 899 } 900 901 bool SecondTry = false; 902 bool IsFilteredTemplateName = false; 903 904 Corrected: 905 switch (Result.getResultKind()) { 906 case LookupResult::NotFound: 907 // If an unqualified-id is followed by a '(', then we have a function 908 // call. 909 if (SS.isEmpty() && NextToken.is(tok::l_paren)) { 910 // In C++, this is an ADL-only call. 911 // FIXME: Reference? 912 if (getLangOpts().CPlusPlus) 913 return NameClassification::UndeclaredNonType(); 914 915 // C90 6.3.2.2: 916 // If the expression that precedes the parenthesized argument list in a 917 // function call consists solely of an identifier, and if no 918 // declaration is visible for this identifier, the identifier is 919 // implicitly declared exactly as if, in the innermost block containing 920 // the function call, the declaration 921 // 922 // extern int identifier (); 923 // 924 // appeared. 925 // 926 // We also allow this in C99 as an extension. 927 if (NamedDecl *D = ImplicitlyDefineFunction(NameLoc, *Name, S)) 928 return NameClassification::NonType(D); 929 } 930 931 if (getLangOpts().CPlusPlus20 && SS.isEmpty() && NextToken.is(tok::less)) { 932 // In C++20 onwards, this could be an ADL-only call to a function 933 // template, and we're required to assume that this is a template name. 934 // 935 // FIXME: Find a way to still do typo correction in this case. 936 TemplateName Template = 937 Context.getAssumedTemplateName(NameInfo.getName()); 938 return NameClassification::UndeclaredTemplate(Template); 939 } 940 941 // In C, we first see whether there is a tag type by the same name, in 942 // which case it's likely that the user just forgot to write "enum", 943 // "struct", or "union". 944 if (!getLangOpts().CPlusPlus && !SecondTry && 945 isTagTypeWithMissingTag(*this, Result, S, SS, Name, NameLoc)) { 946 break; 947 } 948 949 // Perform typo correction to determine if there is another name that is 950 // close to this name. 951 if (!SecondTry && CCC) { 952 SecondTry = true; 953 if (TypoCorrection Corrected = 954 CorrectTypo(Result.getLookupNameInfo(), Result.getLookupKind(), S, 955 &SS, *CCC, CTK_ErrorRecovery)) { 956 unsigned UnqualifiedDiag = diag::err_undeclared_var_use_suggest; 957 unsigned QualifiedDiag = diag::err_no_member_suggest; 958 959 NamedDecl *FirstDecl = Corrected.getFoundDecl(); 960 NamedDecl *UnderlyingFirstDecl = Corrected.getCorrectionDecl(); 961 if (getLangOpts().CPlusPlus && NextToken.is(tok::less) && 962 UnderlyingFirstDecl && isa<TemplateDecl>(UnderlyingFirstDecl)) { 963 UnqualifiedDiag = diag::err_no_template_suggest; 964 QualifiedDiag = diag::err_no_member_template_suggest; 965 } else if (UnderlyingFirstDecl && 966 (isa<TypeDecl>(UnderlyingFirstDecl) || 967 isa<ObjCInterfaceDecl>(UnderlyingFirstDecl) || 968 isa<ObjCCompatibleAliasDecl>(UnderlyingFirstDecl))) { 969 UnqualifiedDiag = diag::err_unknown_typename_suggest; 970 QualifiedDiag = diag::err_unknown_nested_typename_suggest; 971 } 972 973 if (SS.isEmpty()) { 974 diagnoseTypo(Corrected, PDiag(UnqualifiedDiag) << Name); 975 } else {// FIXME: is this even reachable? Test it. 976 std::string CorrectedStr(Corrected.getAsString(getLangOpts())); 977 bool DroppedSpecifier = Corrected.WillReplaceSpecifier() && 978 Name->getName().equals(CorrectedStr); 979 diagnoseTypo(Corrected, PDiag(QualifiedDiag) 980 << Name << computeDeclContext(SS, false) 981 << DroppedSpecifier << SS.getRange()); 982 } 983 984 // Update the name, so that the caller has the new name. 985 Name = Corrected.getCorrectionAsIdentifierInfo(); 986 987 // Typo correction corrected to a keyword. 988 if (Corrected.isKeyword()) 989 return Name; 990 991 // Also update the LookupResult... 992 // FIXME: This should probably go away at some point 993 Result.clear(); 994 Result.setLookupName(Corrected.getCorrection()); 995 if (FirstDecl) 996 Result.addDecl(FirstDecl); 997 998 // If we found an Objective-C instance variable, let 999 // LookupInObjCMethod build the appropriate expression to 1000 // reference the ivar. 1001 // FIXME: This is a gross hack. 1002 if (ObjCIvarDecl *Ivar = Result.getAsSingle<ObjCIvarDecl>()) { 1003 DeclResult R = 1004 LookupIvarInObjCMethod(Result, S, Ivar->getIdentifier()); 1005 if (R.isInvalid()) 1006 return NameClassification::Error(); 1007 if (R.isUsable()) 1008 return NameClassification::NonType(Ivar); 1009 } 1010 1011 goto Corrected; 1012 } 1013 } 1014 1015 // We failed to correct; just fall through and let the parser deal with it. 1016 Result.suppressDiagnostics(); 1017 return NameClassification::Unknown(); 1018 1019 case LookupResult::NotFoundInCurrentInstantiation: { 1020 // We performed name lookup into the current instantiation, and there were 1021 // dependent bases, so we treat this result the same way as any other 1022 // dependent nested-name-specifier. 1023 1024 // C++ [temp.res]p2: 1025 // A name used in a template declaration or definition and that is 1026 // dependent on a template-parameter is assumed not to name a type 1027 // unless the applicable name lookup finds a type name or the name is 1028 // qualified by the keyword typename. 1029 // 1030 // FIXME: If the next token is '<', we might want to ask the parser to 1031 // perform some heroics to see if we actually have a 1032 // template-argument-list, which would indicate a missing 'template' 1033 // keyword here. 1034 return NameClassification::DependentNonType(); 1035 } 1036 1037 case LookupResult::Found: 1038 case LookupResult::FoundOverloaded: 1039 case LookupResult::FoundUnresolvedValue: 1040 break; 1041 1042 case LookupResult::Ambiguous: 1043 if (getLangOpts().CPlusPlus && NextToken.is(tok::less) && 1044 hasAnyAcceptableTemplateNames(Result, /*AllowFunctionTemplates=*/true, 1045 /*AllowDependent=*/false)) { 1046 // C++ [temp.local]p3: 1047 // A lookup that finds an injected-class-name (10.2) can result in an 1048 // ambiguity in certain cases (for example, if it is found in more than 1049 // one base class). If all of the injected-class-names that are found 1050 // refer to specializations of the same class template, and if the name 1051 // is followed by a template-argument-list, the reference refers to the 1052 // class template itself and not a specialization thereof, and is not 1053 // ambiguous. 1054 // 1055 // This filtering can make an ambiguous result into an unambiguous one, 1056 // so try again after filtering out template names. 1057 FilterAcceptableTemplateNames(Result); 1058 if (!Result.isAmbiguous()) { 1059 IsFilteredTemplateName = true; 1060 break; 1061 } 1062 } 1063 1064 // Diagnose the ambiguity and return an error. 1065 return NameClassification::Error(); 1066 } 1067 1068 if (getLangOpts().CPlusPlus && NextToken.is(tok::less) && 1069 (IsFilteredTemplateName || 1070 hasAnyAcceptableTemplateNames( 1071 Result, /*AllowFunctionTemplates=*/true, 1072 /*AllowDependent=*/false, 1073 /*AllowNonTemplateFunctions*/ SS.isEmpty() && 1074 getLangOpts().CPlusPlus20))) { 1075 // C++ [temp.names]p3: 1076 // After name lookup (3.4) finds that a name is a template-name or that 1077 // an operator-function-id or a literal- operator-id refers to a set of 1078 // overloaded functions any member of which is a function template if 1079 // this is followed by a <, the < is always taken as the delimiter of a 1080 // template-argument-list and never as the less-than operator. 1081 // C++2a [temp.names]p2: 1082 // A name is also considered to refer to a template if it is an 1083 // unqualified-id followed by a < and name lookup finds either one 1084 // or more functions or finds nothing. 1085 if (!IsFilteredTemplateName) 1086 FilterAcceptableTemplateNames(Result); 1087 1088 bool IsFunctionTemplate; 1089 bool IsVarTemplate; 1090 TemplateName Template; 1091 if (Result.end() - Result.begin() > 1) { 1092 IsFunctionTemplate = true; 1093 Template = Context.getOverloadedTemplateName(Result.begin(), 1094 Result.end()); 1095 } else if (!Result.empty()) { 1096 auto *TD = cast<TemplateDecl>(getAsTemplateNameDecl( 1097 *Result.begin(), /*AllowFunctionTemplates=*/true, 1098 /*AllowDependent=*/false)); 1099 IsFunctionTemplate = isa<FunctionTemplateDecl>(TD); 1100 IsVarTemplate = isa<VarTemplateDecl>(TD); 1101 1102 if (SS.isNotEmpty()) 1103 Template = 1104 Context.getQualifiedTemplateName(SS.getScopeRep(), 1105 /*TemplateKeyword=*/false, TD); 1106 else 1107 Template = TemplateName(TD); 1108 } else { 1109 // All results were non-template functions. This is a function template 1110 // name. 1111 IsFunctionTemplate = true; 1112 Template = Context.getAssumedTemplateName(NameInfo.getName()); 1113 } 1114 1115 if (IsFunctionTemplate) { 1116 // Function templates always go through overload resolution, at which 1117 // point we'll perform the various checks (e.g., accessibility) we need 1118 // to based on which function we selected. 1119 Result.suppressDiagnostics(); 1120 1121 return NameClassification::FunctionTemplate(Template); 1122 } 1123 1124 return IsVarTemplate ? NameClassification::VarTemplate(Template) 1125 : NameClassification::TypeTemplate(Template); 1126 } 1127 1128 NamedDecl *FirstDecl = (*Result.begin())->getUnderlyingDecl(); 1129 if (TypeDecl *Type = dyn_cast<TypeDecl>(FirstDecl)) { 1130 DiagnoseUseOfDecl(Type, NameLoc); 1131 MarkAnyDeclReferenced(Type->getLocation(), Type, /*OdrUse=*/false); 1132 QualType T = Context.getTypeDeclType(Type); 1133 if (SS.isNotEmpty()) 1134 return buildNestedType(*this, SS, T, NameLoc); 1135 return ParsedType::make(T); 1136 } 1137 1138 ObjCInterfaceDecl *Class = dyn_cast<ObjCInterfaceDecl>(FirstDecl); 1139 if (!Class) { 1140 // FIXME: It's unfortunate that we don't have a Type node for handling this. 1141 if (ObjCCompatibleAliasDecl *Alias = 1142 dyn_cast<ObjCCompatibleAliasDecl>(FirstDecl)) 1143 Class = Alias->getClassInterface(); 1144 } 1145 1146 if (Class) { 1147 DiagnoseUseOfDecl(Class, NameLoc); 1148 1149 if (NextToken.is(tok::period)) { 1150 // Interface. <something> is parsed as a property reference expression. 1151 // Just return "unknown" as a fall-through for now. 1152 Result.suppressDiagnostics(); 1153 return NameClassification::Unknown(); 1154 } 1155 1156 QualType T = Context.getObjCInterfaceType(Class); 1157 return ParsedType::make(T); 1158 } 1159 1160 if (isa<ConceptDecl>(FirstDecl)) 1161 return NameClassification::Concept( 1162 TemplateName(cast<TemplateDecl>(FirstDecl))); 1163 1164 // We can have a type template here if we're classifying a template argument. 1165 if (isa<TemplateDecl>(FirstDecl) && !isa<FunctionTemplateDecl>(FirstDecl) && 1166 !isa<VarTemplateDecl>(FirstDecl)) 1167 return NameClassification::TypeTemplate( 1168 TemplateName(cast<TemplateDecl>(FirstDecl))); 1169 1170 // Check for a tag type hidden by a non-type decl in a few cases where it 1171 // seems likely a type is wanted instead of the non-type that was found. 1172 bool NextIsOp = NextToken.isOneOf(tok::amp, tok::star); 1173 if ((NextToken.is(tok::identifier) || 1174 (NextIsOp && 1175 FirstDecl->getUnderlyingDecl()->isFunctionOrFunctionTemplate())) && 1176 isTagTypeWithMissingTag(*this, Result, S, SS, Name, NameLoc)) { 1177 TypeDecl *Type = Result.getAsSingle<TypeDecl>(); 1178 DiagnoseUseOfDecl(Type, NameLoc); 1179 QualType T = Context.getTypeDeclType(Type); 1180 if (SS.isNotEmpty()) 1181 return buildNestedType(*this, SS, T, NameLoc); 1182 return ParsedType::make(T); 1183 } 1184 1185 // If we already know which single declaration is referenced, just annotate 1186 // that declaration directly. Defer resolving even non-overloaded class 1187 // member accesses, as we need to defer certain access checks until we know 1188 // the context. 1189 bool ADL = UseArgumentDependentLookup(SS, Result, NextToken.is(tok::l_paren)); 1190 if (Result.isSingleResult() && !ADL && !FirstDecl->isCXXClassMember()) 1191 return NameClassification::NonType(Result.getRepresentativeDecl()); 1192 1193 // Otherwise, this is an overload set that we will need to resolve later. 1194 Result.suppressDiagnostics(); 1195 return NameClassification::OverloadSet(UnresolvedLookupExpr::Create( 1196 Context, Result.getNamingClass(), SS.getWithLocInContext(Context), 1197 Result.getLookupNameInfo(), ADL, Result.isOverloadedResult(), 1198 Result.begin(), Result.end())); 1199 } 1200 1201 ExprResult 1202 Sema::ActOnNameClassifiedAsUndeclaredNonType(IdentifierInfo *Name, 1203 SourceLocation NameLoc) { 1204 assert(getLangOpts().CPlusPlus && "ADL-only call in C?"); 1205 CXXScopeSpec SS; 1206 LookupResult Result(*this, Name, NameLoc, LookupOrdinaryName); 1207 return BuildDeclarationNameExpr(SS, Result, /*ADL=*/true); 1208 } 1209 1210 ExprResult 1211 Sema::ActOnNameClassifiedAsDependentNonType(const CXXScopeSpec &SS, 1212 IdentifierInfo *Name, 1213 SourceLocation NameLoc, 1214 bool IsAddressOfOperand) { 1215 DeclarationNameInfo NameInfo(Name, NameLoc); 1216 return ActOnDependentIdExpression(SS, /*TemplateKWLoc=*/SourceLocation(), 1217 NameInfo, IsAddressOfOperand, 1218 /*TemplateArgs=*/nullptr); 1219 } 1220 1221 ExprResult Sema::ActOnNameClassifiedAsNonType(Scope *S, const CXXScopeSpec &SS, 1222 NamedDecl *Found, 1223 SourceLocation NameLoc, 1224 const Token &NextToken) { 1225 if (getCurMethodDecl() && SS.isEmpty()) 1226 if (auto *Ivar = dyn_cast<ObjCIvarDecl>(Found->getUnderlyingDecl())) 1227 return BuildIvarRefExpr(S, NameLoc, Ivar); 1228 1229 // Reconstruct the lookup result. 1230 LookupResult Result(*this, Found->getDeclName(), NameLoc, LookupOrdinaryName); 1231 Result.addDecl(Found); 1232 Result.resolveKind(); 1233 1234 bool ADL = UseArgumentDependentLookup(SS, Result, NextToken.is(tok::l_paren)); 1235 return BuildDeclarationNameExpr(SS, Result, ADL); 1236 } 1237 1238 ExprResult Sema::ActOnNameClassifiedAsOverloadSet(Scope *S, Expr *E) { 1239 // For an implicit class member access, transform the result into a member 1240 // access expression if necessary. 1241 auto *ULE = cast<UnresolvedLookupExpr>(E); 1242 if ((*ULE->decls_begin())->isCXXClassMember()) { 1243 CXXScopeSpec SS; 1244 SS.Adopt(ULE->getQualifierLoc()); 1245 1246 // Reconstruct the lookup result. 1247 LookupResult Result(*this, ULE->getName(), ULE->getNameLoc(), 1248 LookupOrdinaryName); 1249 Result.setNamingClass(ULE->getNamingClass()); 1250 for (auto I = ULE->decls_begin(), E = ULE->decls_end(); I != E; ++I) 1251 Result.addDecl(*I, I.getAccess()); 1252 Result.resolveKind(); 1253 return BuildPossibleImplicitMemberExpr(SS, SourceLocation(), Result, 1254 nullptr, S); 1255 } 1256 1257 // Otherwise, this is already in the form we needed, and no further checks 1258 // are necessary. 1259 return ULE; 1260 } 1261 1262 Sema::TemplateNameKindForDiagnostics 1263 Sema::getTemplateNameKindForDiagnostics(TemplateName Name) { 1264 auto *TD = Name.getAsTemplateDecl(); 1265 if (!TD) 1266 return TemplateNameKindForDiagnostics::DependentTemplate; 1267 if (isa<ClassTemplateDecl>(TD)) 1268 return TemplateNameKindForDiagnostics::ClassTemplate; 1269 if (isa<FunctionTemplateDecl>(TD)) 1270 return TemplateNameKindForDiagnostics::FunctionTemplate; 1271 if (isa<VarTemplateDecl>(TD)) 1272 return TemplateNameKindForDiagnostics::VarTemplate; 1273 if (isa<TypeAliasTemplateDecl>(TD)) 1274 return TemplateNameKindForDiagnostics::AliasTemplate; 1275 if (isa<TemplateTemplateParmDecl>(TD)) 1276 return TemplateNameKindForDiagnostics::TemplateTemplateParam; 1277 if (isa<ConceptDecl>(TD)) 1278 return TemplateNameKindForDiagnostics::Concept; 1279 return TemplateNameKindForDiagnostics::DependentTemplate; 1280 } 1281 1282 void Sema::PushDeclContext(Scope *S, DeclContext *DC) { 1283 assert(DC->getLexicalParent() == CurContext && 1284 "The next DeclContext should be lexically contained in the current one."); 1285 CurContext = DC; 1286 S->setEntity(DC); 1287 } 1288 1289 void Sema::PopDeclContext() { 1290 assert(CurContext && "DeclContext imbalance!"); 1291 1292 CurContext = CurContext->getLexicalParent(); 1293 assert(CurContext && "Popped translation unit!"); 1294 } 1295 1296 Sema::SkippedDefinitionContext Sema::ActOnTagStartSkippedDefinition(Scope *S, 1297 Decl *D) { 1298 // Unlike PushDeclContext, the context to which we return is not necessarily 1299 // the containing DC of TD, because the new context will be some pre-existing 1300 // TagDecl definition instead of a fresh one. 1301 auto Result = static_cast<SkippedDefinitionContext>(CurContext); 1302 CurContext = cast<TagDecl>(D)->getDefinition(); 1303 assert(CurContext && "skipping definition of undefined tag"); 1304 // Start lookups from the parent of the current context; we don't want to look 1305 // into the pre-existing complete definition. 1306 S->setEntity(CurContext->getLookupParent()); 1307 return Result; 1308 } 1309 1310 void Sema::ActOnTagFinishSkippedDefinition(SkippedDefinitionContext Context) { 1311 CurContext = static_cast<decltype(CurContext)>(Context); 1312 } 1313 1314 /// EnterDeclaratorContext - Used when we must lookup names in the context 1315 /// of a declarator's nested name specifier. 1316 /// 1317 void Sema::EnterDeclaratorContext(Scope *S, DeclContext *DC) { 1318 // C++0x [basic.lookup.unqual]p13: 1319 // A name used in the definition of a static data member of class 1320 // X (after the qualified-id of the static member) is looked up as 1321 // if the name was used in a member function of X. 1322 // C++0x [basic.lookup.unqual]p14: 1323 // If a variable member of a namespace is defined outside of the 1324 // scope of its namespace then any name used in the definition of 1325 // the variable member (after the declarator-id) is looked up as 1326 // if the definition of the variable member occurred in its 1327 // namespace. 1328 // Both of these imply that we should push a scope whose context 1329 // is the semantic context of the declaration. We can't use 1330 // PushDeclContext here because that context is not necessarily 1331 // lexically contained in the current context. Fortunately, 1332 // the containing scope should have the appropriate information. 1333 1334 assert(!S->getEntity() && "scope already has entity"); 1335 1336 #ifndef NDEBUG 1337 Scope *Ancestor = S->getParent(); 1338 while (!Ancestor->getEntity()) Ancestor = Ancestor->getParent(); 1339 assert(Ancestor->getEntity() == CurContext && "ancestor context mismatch"); 1340 #endif 1341 1342 CurContext = DC; 1343 S->setEntity(DC); 1344 1345 if (S->getParent()->isTemplateParamScope()) { 1346 // Also set the corresponding entities for all immediately-enclosing 1347 // template parameter scopes. 1348 EnterTemplatedContext(S->getParent(), DC); 1349 } 1350 } 1351 1352 void Sema::ExitDeclaratorContext(Scope *S) { 1353 assert(S->getEntity() == CurContext && "Context imbalance!"); 1354 1355 // Switch back to the lexical context. The safety of this is 1356 // enforced by an assert in EnterDeclaratorContext. 1357 Scope *Ancestor = S->getParent(); 1358 while (!Ancestor->getEntity()) Ancestor = Ancestor->getParent(); 1359 CurContext = Ancestor->getEntity(); 1360 1361 // We don't need to do anything with the scope, which is going to 1362 // disappear. 1363 } 1364 1365 void Sema::EnterTemplatedContext(Scope *S, DeclContext *DC) { 1366 assert(S->isTemplateParamScope() && 1367 "expected to be initializing a template parameter scope"); 1368 1369 // C++20 [temp.local]p7: 1370 // In the definition of a member of a class template that appears outside 1371 // of the class template definition, the name of a member of the class 1372 // template hides the name of a template-parameter of any enclosing class 1373 // templates (but not a template-parameter of the member if the member is a 1374 // class or function template). 1375 // C++20 [temp.local]p9: 1376 // In the definition of a class template or in the definition of a member 1377 // of such a template that appears outside of the template definition, for 1378 // each non-dependent base class (13.8.2.1), if the name of the base class 1379 // or the name of a member of the base class is the same as the name of a 1380 // template-parameter, the base class name or member name hides the 1381 // template-parameter name (6.4.10). 1382 // 1383 // This means that a template parameter scope should be searched immediately 1384 // after searching the DeclContext for which it is a template parameter 1385 // scope. For example, for 1386 // template<typename T> template<typename U> template<typename V> 1387 // void N::A<T>::B<U>::f(...) 1388 // we search V then B<U> (and base classes) then U then A<T> (and base 1389 // classes) then T then N then ::. 1390 unsigned ScopeDepth = getTemplateDepth(S); 1391 for (; S && S->isTemplateParamScope(); S = S->getParent(), --ScopeDepth) { 1392 DeclContext *SearchDCAfterScope = DC; 1393 for (; DC; DC = DC->getLookupParent()) { 1394 if (const TemplateParameterList *TPL = 1395 cast<Decl>(DC)->getDescribedTemplateParams()) { 1396 unsigned DCDepth = TPL->getDepth() + 1; 1397 if (DCDepth > ScopeDepth) 1398 continue; 1399 if (ScopeDepth == DCDepth) 1400 SearchDCAfterScope = DC = DC->getLookupParent(); 1401 break; 1402 } 1403 } 1404 S->setLookupEntity(SearchDCAfterScope); 1405 } 1406 } 1407 1408 void Sema::ActOnReenterFunctionContext(Scope* S, Decl *D) { 1409 // We assume that the caller has already called 1410 // ActOnReenterTemplateScope so getTemplatedDecl() works. 1411 FunctionDecl *FD = D->getAsFunction(); 1412 if (!FD) 1413 return; 1414 1415 // Same implementation as PushDeclContext, but enters the context 1416 // from the lexical parent, rather than the top-level class. 1417 assert(CurContext == FD->getLexicalParent() && 1418 "The next DeclContext should be lexically contained in the current one."); 1419 CurContext = FD; 1420 S->setEntity(CurContext); 1421 1422 for (unsigned P = 0, NumParams = FD->getNumParams(); P < NumParams; ++P) { 1423 ParmVarDecl *Param = FD->getParamDecl(P); 1424 // If the parameter has an identifier, then add it to the scope 1425 if (Param->getIdentifier()) { 1426 S->AddDecl(Param); 1427 IdResolver.AddDecl(Param); 1428 } 1429 } 1430 } 1431 1432 void Sema::ActOnExitFunctionContext() { 1433 // Same implementation as PopDeclContext, but returns to the lexical parent, 1434 // rather than the top-level class. 1435 assert(CurContext && "DeclContext imbalance!"); 1436 CurContext = CurContext->getLexicalParent(); 1437 assert(CurContext && "Popped translation unit!"); 1438 } 1439 1440 /// Determine whether we allow overloading of the function 1441 /// PrevDecl with another declaration. 1442 /// 1443 /// This routine determines whether overloading is possible, not 1444 /// whether some new function is actually an overload. It will return 1445 /// true in C++ (where we can always provide overloads) or, as an 1446 /// extension, in C when the previous function is already an 1447 /// overloaded function declaration or has the "overloadable" 1448 /// attribute. 1449 static bool AllowOverloadingOfFunction(LookupResult &Previous, 1450 ASTContext &Context, 1451 const FunctionDecl *New) { 1452 if (Context.getLangOpts().CPlusPlus) 1453 return true; 1454 1455 if (Previous.getResultKind() == LookupResult::FoundOverloaded) 1456 return true; 1457 1458 return Previous.getResultKind() == LookupResult::Found && 1459 (Previous.getFoundDecl()->hasAttr<OverloadableAttr>() || 1460 New->hasAttr<OverloadableAttr>()); 1461 } 1462 1463 /// Add this decl to the scope shadowed decl chains. 1464 void Sema::PushOnScopeChains(NamedDecl *D, Scope *S, bool AddToContext) { 1465 // Move up the scope chain until we find the nearest enclosing 1466 // non-transparent context. The declaration will be introduced into this 1467 // scope. 1468 while (S->getEntity() && S->getEntity()->isTransparentContext()) 1469 S = S->getParent(); 1470 1471 // Add scoped declarations into their context, so that they can be 1472 // found later. Declarations without a context won't be inserted 1473 // into any context. 1474 if (AddToContext) 1475 CurContext->addDecl(D); 1476 1477 // Out-of-line definitions shouldn't be pushed into scope in C++, unless they 1478 // are function-local declarations. 1479 if (getLangOpts().CPlusPlus && D->isOutOfLine() && !S->getFnParent()) 1480 return; 1481 1482 // Template instantiations should also not be pushed into scope. 1483 if (isa<FunctionDecl>(D) && 1484 cast<FunctionDecl>(D)->isFunctionTemplateSpecialization()) 1485 return; 1486 1487 // If this replaces anything in the current scope, 1488 IdentifierResolver::iterator I = IdResolver.begin(D->getDeclName()), 1489 IEnd = IdResolver.end(); 1490 for (; I != IEnd; ++I) { 1491 if (S->isDeclScope(*I) && D->declarationReplaces(*I)) { 1492 S->RemoveDecl(*I); 1493 IdResolver.RemoveDecl(*I); 1494 1495 // Should only need to replace one decl. 1496 break; 1497 } 1498 } 1499 1500 S->AddDecl(D); 1501 1502 if (isa<LabelDecl>(D) && !cast<LabelDecl>(D)->isGnuLocal()) { 1503 // Implicitly-generated labels may end up getting generated in an order that 1504 // isn't strictly lexical, which breaks name lookup. Be careful to insert 1505 // the label at the appropriate place in the identifier chain. 1506 for (I = IdResolver.begin(D->getDeclName()); I != IEnd; ++I) { 1507 DeclContext *IDC = (*I)->getLexicalDeclContext()->getRedeclContext(); 1508 if (IDC == CurContext) { 1509 if (!S->isDeclScope(*I)) 1510 continue; 1511 } else if (IDC->Encloses(CurContext)) 1512 break; 1513 } 1514 1515 IdResolver.InsertDeclAfter(I, D); 1516 } else { 1517 IdResolver.AddDecl(D); 1518 } 1519 } 1520 1521 bool Sema::isDeclInScope(NamedDecl *D, DeclContext *Ctx, Scope *S, 1522 bool AllowInlineNamespace) { 1523 return IdResolver.isDeclInScope(D, Ctx, S, AllowInlineNamespace); 1524 } 1525 1526 Scope *Sema::getScopeForDeclContext(Scope *S, DeclContext *DC) { 1527 DeclContext *TargetDC = DC->getPrimaryContext(); 1528 do { 1529 if (DeclContext *ScopeDC = S->getEntity()) 1530 if (ScopeDC->getPrimaryContext() == TargetDC) 1531 return S; 1532 } while ((S = S->getParent())); 1533 1534 return nullptr; 1535 } 1536 1537 static bool isOutOfScopePreviousDeclaration(NamedDecl *, 1538 DeclContext*, 1539 ASTContext&); 1540 1541 /// Filters out lookup results that don't fall within the given scope 1542 /// as determined by isDeclInScope. 1543 void Sema::FilterLookupForScope(LookupResult &R, DeclContext *Ctx, Scope *S, 1544 bool ConsiderLinkage, 1545 bool AllowInlineNamespace) { 1546 LookupResult::Filter F = R.makeFilter(); 1547 while (F.hasNext()) { 1548 NamedDecl *D = F.next(); 1549 1550 if (isDeclInScope(D, Ctx, S, AllowInlineNamespace)) 1551 continue; 1552 1553 if (ConsiderLinkage && isOutOfScopePreviousDeclaration(D, Ctx, Context)) 1554 continue; 1555 1556 F.erase(); 1557 } 1558 1559 F.done(); 1560 } 1561 1562 /// We've determined that \p New is a redeclaration of \p Old. Check that they 1563 /// have compatible owning modules. 1564 bool Sema::CheckRedeclarationModuleOwnership(NamedDecl *New, NamedDecl *Old) { 1565 // FIXME: The Modules TS is not clear about how friend declarations are 1566 // to be treated. It's not meaningful to have different owning modules for 1567 // linkage in redeclarations of the same entity, so for now allow the 1568 // redeclaration and change the owning modules to match. 1569 if (New->getFriendObjectKind() && 1570 Old->getOwningModuleForLinkage() != New->getOwningModuleForLinkage()) { 1571 New->setLocalOwningModule(Old->getOwningModule()); 1572 makeMergedDefinitionVisible(New); 1573 return false; 1574 } 1575 1576 Module *NewM = New->getOwningModule(); 1577 Module *OldM = Old->getOwningModule(); 1578 1579 if (NewM && NewM->Kind == Module::PrivateModuleFragment) 1580 NewM = NewM->Parent; 1581 if (OldM && OldM->Kind == Module::PrivateModuleFragment) 1582 OldM = OldM->Parent; 1583 1584 if (NewM == OldM) 1585 return false; 1586 1587 bool NewIsModuleInterface = NewM && NewM->isModulePurview(); 1588 bool OldIsModuleInterface = OldM && OldM->isModulePurview(); 1589 if (NewIsModuleInterface || OldIsModuleInterface) { 1590 // C++ Modules TS [basic.def.odr] 6.2/6.7 [sic]: 1591 // if a declaration of D [...] appears in the purview of a module, all 1592 // other such declarations shall appear in the purview of the same module 1593 Diag(New->getLocation(), diag::err_mismatched_owning_module) 1594 << New 1595 << NewIsModuleInterface 1596 << (NewIsModuleInterface ? NewM->getFullModuleName() : "") 1597 << OldIsModuleInterface 1598 << (OldIsModuleInterface ? OldM->getFullModuleName() : ""); 1599 Diag(Old->getLocation(), diag::note_previous_declaration); 1600 New->setInvalidDecl(); 1601 return true; 1602 } 1603 1604 return false; 1605 } 1606 1607 static bool isUsingDecl(NamedDecl *D) { 1608 return isa<UsingShadowDecl>(D) || 1609 isa<UnresolvedUsingTypenameDecl>(D) || 1610 isa<UnresolvedUsingValueDecl>(D); 1611 } 1612 1613 /// Removes using shadow declarations from the lookup results. 1614 static void RemoveUsingDecls(LookupResult &R) { 1615 LookupResult::Filter F = R.makeFilter(); 1616 while (F.hasNext()) 1617 if (isUsingDecl(F.next())) 1618 F.erase(); 1619 1620 F.done(); 1621 } 1622 1623 /// Check for this common pattern: 1624 /// @code 1625 /// class S { 1626 /// S(const S&); // DO NOT IMPLEMENT 1627 /// void operator=(const S&); // DO NOT IMPLEMENT 1628 /// }; 1629 /// @endcode 1630 static bool IsDisallowedCopyOrAssign(const CXXMethodDecl *D) { 1631 // FIXME: Should check for private access too but access is set after we get 1632 // the decl here. 1633 if (D->doesThisDeclarationHaveABody()) 1634 return false; 1635 1636 if (const CXXConstructorDecl *CD = dyn_cast<CXXConstructorDecl>(D)) 1637 return CD->isCopyConstructor(); 1638 return D->isCopyAssignmentOperator(); 1639 } 1640 1641 // We need this to handle 1642 // 1643 // typedef struct { 1644 // void *foo() { return 0; } 1645 // } A; 1646 // 1647 // When we see foo we don't know if after the typedef we will get 'A' or '*A' 1648 // for example. If 'A', foo will have external linkage. If we have '*A', 1649 // foo will have no linkage. Since we can't know until we get to the end 1650 // of the typedef, this function finds out if D might have non-external linkage. 1651 // Callers should verify at the end of the TU if it D has external linkage or 1652 // not. 1653 bool Sema::mightHaveNonExternalLinkage(const DeclaratorDecl *D) { 1654 const DeclContext *DC = D->getDeclContext(); 1655 while (!DC->isTranslationUnit()) { 1656 if (const RecordDecl *RD = dyn_cast<RecordDecl>(DC)){ 1657 if (!RD->hasNameForLinkage()) 1658 return true; 1659 } 1660 DC = DC->getParent(); 1661 } 1662 1663 return !D->isExternallyVisible(); 1664 } 1665 1666 // FIXME: This needs to be refactored; some other isInMainFile users want 1667 // these semantics. 1668 static bool isMainFileLoc(const Sema &S, SourceLocation Loc) { 1669 if (S.TUKind != TU_Complete) 1670 return false; 1671 return S.SourceMgr.isInMainFile(Loc); 1672 } 1673 1674 bool Sema::ShouldWarnIfUnusedFileScopedDecl(const DeclaratorDecl *D) const { 1675 assert(D); 1676 1677 if (D->isInvalidDecl() || D->isUsed() || D->hasAttr<UnusedAttr>()) 1678 return false; 1679 1680 // Ignore all entities declared within templates, and out-of-line definitions 1681 // of members of class templates. 1682 if (D->getDeclContext()->isDependentContext() || 1683 D->getLexicalDeclContext()->isDependentContext()) 1684 return false; 1685 1686 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) { 1687 if (FD->getTemplateSpecializationKind() == TSK_ImplicitInstantiation) 1688 return false; 1689 // A non-out-of-line declaration of a member specialization was implicitly 1690 // instantiated; it's the out-of-line declaration that we're interested in. 1691 if (FD->getTemplateSpecializationKind() == TSK_ExplicitSpecialization && 1692 FD->getMemberSpecializationInfo() && !FD->isOutOfLine()) 1693 return false; 1694 1695 if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) { 1696 if (MD->isVirtual() || IsDisallowedCopyOrAssign(MD)) 1697 return false; 1698 } else { 1699 // 'static inline' functions are defined in headers; don't warn. 1700 if (FD->isInlined() && !isMainFileLoc(*this, FD->getLocation())) 1701 return false; 1702 } 1703 1704 if (FD->doesThisDeclarationHaveABody() && 1705 Context.DeclMustBeEmitted(FD)) 1706 return false; 1707 } else if (const VarDecl *VD = dyn_cast<VarDecl>(D)) { 1708 // Constants and utility variables are defined in headers with internal 1709 // linkage; don't warn. (Unlike functions, there isn't a convenient marker 1710 // like "inline".) 1711 if (!isMainFileLoc(*this, VD->getLocation())) 1712 return false; 1713 1714 if (Context.DeclMustBeEmitted(VD)) 1715 return false; 1716 1717 if (VD->isStaticDataMember() && 1718 VD->getTemplateSpecializationKind() == TSK_ImplicitInstantiation) 1719 return false; 1720 if (VD->isStaticDataMember() && 1721 VD->getTemplateSpecializationKind() == TSK_ExplicitSpecialization && 1722 VD->getMemberSpecializationInfo() && !VD->isOutOfLine()) 1723 return false; 1724 1725 if (VD->isInline() && !isMainFileLoc(*this, VD->getLocation())) 1726 return false; 1727 } else { 1728 return false; 1729 } 1730 1731 // Only warn for unused decls internal to the translation unit. 1732 // FIXME: This seems like a bogus check; it suppresses -Wunused-function 1733 // for inline functions defined in the main source file, for instance. 1734 return mightHaveNonExternalLinkage(D); 1735 } 1736 1737 void Sema::MarkUnusedFileScopedDecl(const DeclaratorDecl *D) { 1738 if (!D) 1739 return; 1740 1741 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) { 1742 const FunctionDecl *First = FD->getFirstDecl(); 1743 if (FD != First && ShouldWarnIfUnusedFileScopedDecl(First)) 1744 return; // First should already be in the vector. 1745 } 1746 1747 if (const VarDecl *VD = dyn_cast<VarDecl>(D)) { 1748 const VarDecl *First = VD->getFirstDecl(); 1749 if (VD != First && ShouldWarnIfUnusedFileScopedDecl(First)) 1750 return; // First should already be in the vector. 1751 } 1752 1753 if (ShouldWarnIfUnusedFileScopedDecl(D)) 1754 UnusedFileScopedDecls.push_back(D); 1755 } 1756 1757 static bool ShouldDiagnoseUnusedDecl(const NamedDecl *D) { 1758 if (D->isInvalidDecl()) 1759 return false; 1760 1761 if (auto *DD = dyn_cast<DecompositionDecl>(D)) { 1762 // For a decomposition declaration, warn if none of the bindings are 1763 // referenced, instead of if the variable itself is referenced (which 1764 // it is, by the bindings' expressions). 1765 for (auto *BD : DD->bindings()) 1766 if (BD->isReferenced()) 1767 return false; 1768 } else if (!D->getDeclName()) { 1769 return false; 1770 } else if (D->isReferenced() || D->isUsed()) { 1771 return false; 1772 } 1773 1774 if (D->hasAttr<UnusedAttr>() || D->hasAttr<ObjCPreciseLifetimeAttr>()) 1775 return false; 1776 1777 if (isa<LabelDecl>(D)) 1778 return true; 1779 1780 // Except for labels, we only care about unused decls that are local to 1781 // functions. 1782 bool WithinFunction = D->getDeclContext()->isFunctionOrMethod(); 1783 if (const auto *R = dyn_cast<CXXRecordDecl>(D->getDeclContext())) 1784 // For dependent types, the diagnostic is deferred. 1785 WithinFunction = 1786 WithinFunction || (R->isLocalClass() && !R->isDependentType()); 1787 if (!WithinFunction) 1788 return false; 1789 1790 if (isa<TypedefNameDecl>(D)) 1791 return true; 1792 1793 // White-list anything that isn't a local variable. 1794 if (!isa<VarDecl>(D) || isa<ParmVarDecl>(D) || isa<ImplicitParamDecl>(D)) 1795 return false; 1796 1797 // Types of valid local variables should be complete, so this should succeed. 1798 if (const VarDecl *VD = dyn_cast<VarDecl>(D)) { 1799 1800 // White-list anything with an __attribute__((unused)) type. 1801 const auto *Ty = VD->getType().getTypePtr(); 1802 1803 // Only look at the outermost level of typedef. 1804 if (const TypedefType *TT = Ty->getAs<TypedefType>()) { 1805 if (TT->getDecl()->hasAttr<UnusedAttr>()) 1806 return false; 1807 } 1808 1809 // If we failed to complete the type for some reason, or if the type is 1810 // dependent, don't diagnose the variable. 1811 if (Ty->isIncompleteType() || Ty->isDependentType()) 1812 return false; 1813 1814 // Look at the element type to ensure that the warning behaviour is 1815 // consistent for both scalars and arrays. 1816 Ty = Ty->getBaseElementTypeUnsafe(); 1817 1818 if (const TagType *TT = Ty->getAs<TagType>()) { 1819 const TagDecl *Tag = TT->getDecl(); 1820 if (Tag->hasAttr<UnusedAttr>()) 1821 return false; 1822 1823 if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(Tag)) { 1824 if (!RD->hasTrivialDestructor() && !RD->hasAttr<WarnUnusedAttr>()) 1825 return false; 1826 1827 if (const Expr *Init = VD->getInit()) { 1828 if (const ExprWithCleanups *Cleanups = 1829 dyn_cast<ExprWithCleanups>(Init)) 1830 Init = Cleanups->getSubExpr(); 1831 const CXXConstructExpr *Construct = 1832 dyn_cast<CXXConstructExpr>(Init); 1833 if (Construct && !Construct->isElidable()) { 1834 CXXConstructorDecl *CD = Construct->getConstructor(); 1835 if (!CD->isTrivial() && !RD->hasAttr<WarnUnusedAttr>() && 1836 (VD->getInit()->isValueDependent() || !VD->evaluateValue())) 1837 return false; 1838 } 1839 1840 // Suppress the warning if we don't know how this is constructed, and 1841 // it could possibly be non-trivial constructor. 1842 if (Init->isTypeDependent()) 1843 for (const CXXConstructorDecl *Ctor : RD->ctors()) 1844 if (!Ctor->isTrivial()) 1845 return false; 1846 } 1847 } 1848 } 1849 1850 // TODO: __attribute__((unused)) templates? 1851 } 1852 1853 return true; 1854 } 1855 1856 static void GenerateFixForUnusedDecl(const NamedDecl *D, ASTContext &Ctx, 1857 FixItHint &Hint) { 1858 if (isa<LabelDecl>(D)) { 1859 SourceLocation AfterColon = Lexer::findLocationAfterToken( 1860 D->getEndLoc(), tok::colon, Ctx.getSourceManager(), Ctx.getLangOpts(), 1861 true); 1862 if (AfterColon.isInvalid()) 1863 return; 1864 Hint = FixItHint::CreateRemoval( 1865 CharSourceRange::getCharRange(D->getBeginLoc(), AfterColon)); 1866 } 1867 } 1868 1869 void Sema::DiagnoseUnusedNestedTypedefs(const RecordDecl *D) { 1870 if (D->getTypeForDecl()->isDependentType()) 1871 return; 1872 1873 for (auto *TmpD : D->decls()) { 1874 if (const auto *T = dyn_cast<TypedefNameDecl>(TmpD)) 1875 DiagnoseUnusedDecl(T); 1876 else if(const auto *R = dyn_cast<RecordDecl>(TmpD)) 1877 DiagnoseUnusedNestedTypedefs(R); 1878 } 1879 } 1880 1881 /// DiagnoseUnusedDecl - Emit warnings about declarations that are not used 1882 /// unless they are marked attr(unused). 1883 void Sema::DiagnoseUnusedDecl(const NamedDecl *D) { 1884 if (!ShouldDiagnoseUnusedDecl(D)) 1885 return; 1886 1887 if (auto *TD = dyn_cast<TypedefNameDecl>(D)) { 1888 // typedefs can be referenced later on, so the diagnostics are emitted 1889 // at end-of-translation-unit. 1890 UnusedLocalTypedefNameCandidates.insert(TD); 1891 return; 1892 } 1893 1894 FixItHint Hint; 1895 GenerateFixForUnusedDecl(D, Context, Hint); 1896 1897 unsigned DiagID; 1898 if (isa<VarDecl>(D) && cast<VarDecl>(D)->isExceptionVariable()) 1899 DiagID = diag::warn_unused_exception_param; 1900 else if (isa<LabelDecl>(D)) 1901 DiagID = diag::warn_unused_label; 1902 else 1903 DiagID = diag::warn_unused_variable; 1904 1905 Diag(D->getLocation(), DiagID) << D << Hint; 1906 } 1907 1908 static void CheckPoppedLabel(LabelDecl *L, Sema &S) { 1909 // Verify that we have no forward references left. If so, there was a goto 1910 // or address of a label taken, but no definition of it. Label fwd 1911 // definitions are indicated with a null substmt which is also not a resolved 1912 // MS inline assembly label name. 1913 bool Diagnose = false; 1914 if (L->isMSAsmLabel()) 1915 Diagnose = !L->isResolvedMSAsmLabel(); 1916 else 1917 Diagnose = L->getStmt() == nullptr; 1918 if (Diagnose) 1919 S.Diag(L->getLocation(), diag::err_undeclared_label_use) << L; 1920 } 1921 1922 void Sema::ActOnPopScope(SourceLocation Loc, Scope *S) { 1923 S->mergeNRVOIntoParent(); 1924 1925 if (S->decl_empty()) return; 1926 assert((S->getFlags() & (Scope::DeclScope | Scope::TemplateParamScope)) && 1927 "Scope shouldn't contain decls!"); 1928 1929 for (auto *TmpD : S->decls()) { 1930 assert(TmpD && "This decl didn't get pushed??"); 1931 1932 assert(isa<NamedDecl>(TmpD) && "Decl isn't NamedDecl?"); 1933 NamedDecl *D = cast<NamedDecl>(TmpD); 1934 1935 // Diagnose unused variables in this scope. 1936 if (!S->hasUnrecoverableErrorOccurred()) { 1937 DiagnoseUnusedDecl(D); 1938 if (const auto *RD = dyn_cast<RecordDecl>(D)) 1939 DiagnoseUnusedNestedTypedefs(RD); 1940 } 1941 1942 if (!D->getDeclName()) continue; 1943 1944 // If this was a forward reference to a label, verify it was defined. 1945 if (LabelDecl *LD = dyn_cast<LabelDecl>(D)) 1946 CheckPoppedLabel(LD, *this); 1947 1948 // Remove this name from our lexical scope, and warn on it if we haven't 1949 // already. 1950 IdResolver.RemoveDecl(D); 1951 auto ShadowI = ShadowingDecls.find(D); 1952 if (ShadowI != ShadowingDecls.end()) { 1953 if (const auto *FD = dyn_cast<FieldDecl>(ShadowI->second)) { 1954 Diag(D->getLocation(), diag::warn_ctor_parm_shadows_field) 1955 << D << FD << FD->getParent(); 1956 Diag(FD->getLocation(), diag::note_previous_declaration); 1957 } 1958 ShadowingDecls.erase(ShadowI); 1959 } 1960 } 1961 } 1962 1963 /// Look for an Objective-C class in the translation unit. 1964 /// 1965 /// \param Id The name of the Objective-C class we're looking for. If 1966 /// typo-correction fixes this name, the Id will be updated 1967 /// to the fixed name. 1968 /// 1969 /// \param IdLoc The location of the name in the translation unit. 1970 /// 1971 /// \param DoTypoCorrection If true, this routine will attempt typo correction 1972 /// if there is no class with the given name. 1973 /// 1974 /// \returns The declaration of the named Objective-C class, or NULL if the 1975 /// class could not be found. 1976 ObjCInterfaceDecl *Sema::getObjCInterfaceDecl(IdentifierInfo *&Id, 1977 SourceLocation IdLoc, 1978 bool DoTypoCorrection) { 1979 // The third "scope" argument is 0 since we aren't enabling lazy built-in 1980 // creation from this context. 1981 NamedDecl *IDecl = LookupSingleName(TUScope, Id, IdLoc, LookupOrdinaryName); 1982 1983 if (!IDecl && DoTypoCorrection) { 1984 // Perform typo correction at the given location, but only if we 1985 // find an Objective-C class name. 1986 DeclFilterCCC<ObjCInterfaceDecl> CCC{}; 1987 if (TypoCorrection C = 1988 CorrectTypo(DeclarationNameInfo(Id, IdLoc), LookupOrdinaryName, 1989 TUScope, nullptr, CCC, CTK_ErrorRecovery)) { 1990 diagnoseTypo(C, PDiag(diag::err_undef_interface_suggest) << Id); 1991 IDecl = C.getCorrectionDeclAs<ObjCInterfaceDecl>(); 1992 Id = IDecl->getIdentifier(); 1993 } 1994 } 1995 ObjCInterfaceDecl *Def = dyn_cast_or_null<ObjCInterfaceDecl>(IDecl); 1996 // This routine must always return a class definition, if any. 1997 if (Def && Def->getDefinition()) 1998 Def = Def->getDefinition(); 1999 return Def; 2000 } 2001 2002 /// getNonFieldDeclScope - Retrieves the innermost scope, starting 2003 /// from S, where a non-field would be declared. This routine copes 2004 /// with the difference between C and C++ scoping rules in structs and 2005 /// unions. For example, the following code is well-formed in C but 2006 /// ill-formed in C++: 2007 /// @code 2008 /// struct S6 { 2009 /// enum { BAR } e; 2010 /// }; 2011 /// 2012 /// void test_S6() { 2013 /// struct S6 a; 2014 /// a.e = BAR; 2015 /// } 2016 /// @endcode 2017 /// For the declaration of BAR, this routine will return a different 2018 /// scope. The scope S will be the scope of the unnamed enumeration 2019 /// within S6. In C++, this routine will return the scope associated 2020 /// with S6, because the enumeration's scope is a transparent 2021 /// context but structures can contain non-field names. In C, this 2022 /// routine will return the translation unit scope, since the 2023 /// enumeration's scope is a transparent context and structures cannot 2024 /// contain non-field names. 2025 Scope *Sema::getNonFieldDeclScope(Scope *S) { 2026 while (((S->getFlags() & Scope::DeclScope) == 0) || 2027 (S->getEntity() && S->getEntity()->isTransparentContext()) || 2028 (S->isClassScope() && !getLangOpts().CPlusPlus)) 2029 S = S->getParent(); 2030 return S; 2031 } 2032 2033 static StringRef getHeaderName(Builtin::Context &BuiltinInfo, unsigned ID, 2034 ASTContext::GetBuiltinTypeError Error) { 2035 switch (Error) { 2036 case ASTContext::GE_None: 2037 return ""; 2038 case ASTContext::GE_Missing_type: 2039 return BuiltinInfo.getHeaderName(ID); 2040 case ASTContext::GE_Missing_stdio: 2041 return "stdio.h"; 2042 case ASTContext::GE_Missing_setjmp: 2043 return "setjmp.h"; 2044 case ASTContext::GE_Missing_ucontext: 2045 return "ucontext.h"; 2046 } 2047 llvm_unreachable("unhandled error kind"); 2048 } 2049 2050 FunctionDecl *Sema::CreateBuiltin(IdentifierInfo *II, QualType Type, 2051 unsigned ID, SourceLocation Loc) { 2052 DeclContext *Parent = Context.getTranslationUnitDecl(); 2053 2054 if (getLangOpts().CPlusPlus) { 2055 LinkageSpecDecl *CLinkageDecl = LinkageSpecDecl::Create( 2056 Context, Parent, Loc, Loc, LinkageSpecDecl::lang_c, false); 2057 CLinkageDecl->setImplicit(); 2058 Parent->addDecl(CLinkageDecl); 2059 Parent = CLinkageDecl; 2060 } 2061 2062 FunctionDecl *New = FunctionDecl::Create(Context, Parent, Loc, Loc, II, Type, 2063 /*TInfo=*/nullptr, SC_Extern, false, 2064 Type->isFunctionProtoType()); 2065 New->setImplicit(); 2066 New->addAttr(BuiltinAttr::CreateImplicit(Context, ID)); 2067 2068 // Create Decl objects for each parameter, adding them to the 2069 // FunctionDecl. 2070 if (const FunctionProtoType *FT = dyn_cast<FunctionProtoType>(Type)) { 2071 SmallVector<ParmVarDecl *, 16> Params; 2072 for (unsigned i = 0, e = FT->getNumParams(); i != e; ++i) { 2073 ParmVarDecl *parm = ParmVarDecl::Create( 2074 Context, New, SourceLocation(), SourceLocation(), nullptr, 2075 FT->getParamType(i), /*TInfo=*/nullptr, SC_None, nullptr); 2076 parm->setScopeInfo(0, i); 2077 Params.push_back(parm); 2078 } 2079 New->setParams(Params); 2080 } 2081 2082 AddKnownFunctionAttributes(New); 2083 return New; 2084 } 2085 2086 /// LazilyCreateBuiltin - The specified Builtin-ID was first used at 2087 /// file scope. lazily create a decl for it. ForRedeclaration is true 2088 /// if we're creating this built-in in anticipation of redeclaring the 2089 /// built-in. 2090 NamedDecl *Sema::LazilyCreateBuiltin(IdentifierInfo *II, unsigned ID, 2091 Scope *S, bool ForRedeclaration, 2092 SourceLocation Loc) { 2093 LookupNecessaryTypesForBuiltin(S, ID); 2094 2095 ASTContext::GetBuiltinTypeError Error; 2096 QualType R = Context.GetBuiltinType(ID, Error); 2097 if (Error) { 2098 if (!ForRedeclaration) 2099 return nullptr; 2100 2101 // If we have a builtin without an associated type we should not emit a 2102 // warning when we were not able to find a type for it. 2103 if (Error == ASTContext::GE_Missing_type || 2104 Context.BuiltinInfo.allowTypeMismatch(ID)) 2105 return nullptr; 2106 2107 // If we could not find a type for setjmp it is because the jmp_buf type was 2108 // not defined prior to the setjmp declaration. 2109 if (Error == ASTContext::GE_Missing_setjmp) { 2110 Diag(Loc, diag::warn_implicit_decl_no_jmp_buf) 2111 << Context.BuiltinInfo.getName(ID); 2112 return nullptr; 2113 } 2114 2115 // Generally, we emit a warning that the declaration requires the 2116 // appropriate header. 2117 Diag(Loc, diag::warn_implicit_decl_requires_sysheader) 2118 << getHeaderName(Context.BuiltinInfo, ID, Error) 2119 << Context.BuiltinInfo.getName(ID); 2120 return nullptr; 2121 } 2122 2123 if (!ForRedeclaration && 2124 (Context.BuiltinInfo.isPredefinedLibFunction(ID) || 2125 Context.BuiltinInfo.isHeaderDependentFunction(ID))) { 2126 Diag(Loc, diag::ext_implicit_lib_function_decl) 2127 << Context.BuiltinInfo.getName(ID) << R; 2128 if (const char *Header = Context.BuiltinInfo.getHeaderName(ID)) 2129 Diag(Loc, diag::note_include_header_or_declare) 2130 << Header << Context.BuiltinInfo.getName(ID); 2131 } 2132 2133 if (R.isNull()) 2134 return nullptr; 2135 2136 FunctionDecl *New = CreateBuiltin(II, R, ID, Loc); 2137 RegisterLocallyScopedExternCDecl(New, S); 2138 2139 // TUScope is the translation-unit scope to insert this function into. 2140 // FIXME: This is hideous. We need to teach PushOnScopeChains to 2141 // relate Scopes to DeclContexts, and probably eliminate CurContext 2142 // entirely, but we're not there yet. 2143 DeclContext *SavedContext = CurContext; 2144 CurContext = New->getDeclContext(); 2145 PushOnScopeChains(New, TUScope); 2146 CurContext = SavedContext; 2147 return New; 2148 } 2149 2150 /// Typedef declarations don't have linkage, but they still denote the same 2151 /// entity if their types are the same. 2152 /// FIXME: This is notionally doing the same thing as ASTReaderDecl's 2153 /// isSameEntity. 2154 static void filterNonConflictingPreviousTypedefDecls(Sema &S, 2155 TypedefNameDecl *Decl, 2156 LookupResult &Previous) { 2157 // This is only interesting when modules are enabled. 2158 if (!S.getLangOpts().Modules && !S.getLangOpts().ModulesLocalVisibility) 2159 return; 2160 2161 // Empty sets are uninteresting. 2162 if (Previous.empty()) 2163 return; 2164 2165 LookupResult::Filter Filter = Previous.makeFilter(); 2166 while (Filter.hasNext()) { 2167 NamedDecl *Old = Filter.next(); 2168 2169 // Non-hidden declarations are never ignored. 2170 if (S.isVisible(Old)) 2171 continue; 2172 2173 // Declarations of the same entity are not ignored, even if they have 2174 // different linkages. 2175 if (auto *OldTD = dyn_cast<TypedefNameDecl>(Old)) { 2176 if (S.Context.hasSameType(OldTD->getUnderlyingType(), 2177 Decl->getUnderlyingType())) 2178 continue; 2179 2180 // If both declarations give a tag declaration a typedef name for linkage 2181 // purposes, then they declare the same entity. 2182 if (OldTD->getAnonDeclWithTypedefName(/*AnyRedecl*/true) && 2183 Decl->getAnonDeclWithTypedefName()) 2184 continue; 2185 } 2186 2187 Filter.erase(); 2188 } 2189 2190 Filter.done(); 2191 } 2192 2193 bool Sema::isIncompatibleTypedef(TypeDecl *Old, TypedefNameDecl *New) { 2194 QualType OldType; 2195 if (TypedefNameDecl *OldTypedef = dyn_cast<TypedefNameDecl>(Old)) 2196 OldType = OldTypedef->getUnderlyingType(); 2197 else 2198 OldType = Context.getTypeDeclType(Old); 2199 QualType NewType = New->getUnderlyingType(); 2200 2201 if (NewType->isVariablyModifiedType()) { 2202 // Must not redefine a typedef with a variably-modified type. 2203 int Kind = isa<TypeAliasDecl>(Old) ? 1 : 0; 2204 Diag(New->getLocation(), diag::err_redefinition_variably_modified_typedef) 2205 << Kind << NewType; 2206 if (Old->getLocation().isValid()) 2207 notePreviousDefinition(Old, New->getLocation()); 2208 New->setInvalidDecl(); 2209 return true; 2210 } 2211 2212 if (OldType != NewType && 2213 !OldType->isDependentType() && 2214 !NewType->isDependentType() && 2215 !Context.hasSameType(OldType, NewType)) { 2216 int Kind = isa<TypeAliasDecl>(Old) ? 1 : 0; 2217 Diag(New->getLocation(), diag::err_redefinition_different_typedef) 2218 << Kind << NewType << OldType; 2219 if (Old->getLocation().isValid()) 2220 notePreviousDefinition(Old, New->getLocation()); 2221 New->setInvalidDecl(); 2222 return true; 2223 } 2224 return false; 2225 } 2226 2227 /// MergeTypedefNameDecl - We just parsed a typedef 'New' which has the 2228 /// same name and scope as a previous declaration 'Old'. Figure out 2229 /// how to resolve this situation, merging decls or emitting 2230 /// diagnostics as appropriate. If there was an error, set New to be invalid. 2231 /// 2232 void Sema::MergeTypedefNameDecl(Scope *S, TypedefNameDecl *New, 2233 LookupResult &OldDecls) { 2234 // If the new decl is known invalid already, don't bother doing any 2235 // merging checks. 2236 if (New->isInvalidDecl()) return; 2237 2238 // Allow multiple definitions for ObjC built-in typedefs. 2239 // FIXME: Verify the underlying types are equivalent! 2240 if (getLangOpts().ObjC) { 2241 const IdentifierInfo *TypeID = New->getIdentifier(); 2242 switch (TypeID->getLength()) { 2243 default: break; 2244 case 2: 2245 { 2246 if (!TypeID->isStr("id")) 2247 break; 2248 QualType T = New->getUnderlyingType(); 2249 if (!T->isPointerType()) 2250 break; 2251 if (!T->isVoidPointerType()) { 2252 QualType PT = T->castAs<PointerType>()->getPointeeType(); 2253 if (!PT->isStructureType()) 2254 break; 2255 } 2256 Context.setObjCIdRedefinitionType(T); 2257 // Install the built-in type for 'id', ignoring the current definition. 2258 New->setTypeForDecl(Context.getObjCIdType().getTypePtr()); 2259 return; 2260 } 2261 case 5: 2262 if (!TypeID->isStr("Class")) 2263 break; 2264 Context.setObjCClassRedefinitionType(New->getUnderlyingType()); 2265 // Install the built-in type for 'Class', ignoring the current definition. 2266 New->setTypeForDecl(Context.getObjCClassType().getTypePtr()); 2267 return; 2268 case 3: 2269 if (!TypeID->isStr("SEL")) 2270 break; 2271 Context.setObjCSelRedefinitionType(New->getUnderlyingType()); 2272 // Install the built-in type for 'SEL', ignoring the current definition. 2273 New->setTypeForDecl(Context.getObjCSelType().getTypePtr()); 2274 return; 2275 } 2276 // Fall through - the typedef name was not a builtin type. 2277 } 2278 2279 // Verify the old decl was also a type. 2280 TypeDecl *Old = OldDecls.getAsSingle<TypeDecl>(); 2281 if (!Old) { 2282 Diag(New->getLocation(), diag::err_redefinition_different_kind) 2283 << New->getDeclName(); 2284 2285 NamedDecl *OldD = OldDecls.getRepresentativeDecl(); 2286 if (OldD->getLocation().isValid()) 2287 notePreviousDefinition(OldD, New->getLocation()); 2288 2289 return New->setInvalidDecl(); 2290 } 2291 2292 // If the old declaration is invalid, just give up here. 2293 if (Old->isInvalidDecl()) 2294 return New->setInvalidDecl(); 2295 2296 if (auto *OldTD = dyn_cast<TypedefNameDecl>(Old)) { 2297 auto *OldTag = OldTD->getAnonDeclWithTypedefName(/*AnyRedecl*/true); 2298 auto *NewTag = New->getAnonDeclWithTypedefName(); 2299 NamedDecl *Hidden = nullptr; 2300 if (OldTag && NewTag && 2301 OldTag->getCanonicalDecl() != NewTag->getCanonicalDecl() && 2302 !hasVisibleDefinition(OldTag, &Hidden)) { 2303 // There is a definition of this tag, but it is not visible. Use it 2304 // instead of our tag. 2305 New->setTypeForDecl(OldTD->getTypeForDecl()); 2306 if (OldTD->isModed()) 2307 New->setModedTypeSourceInfo(OldTD->getTypeSourceInfo(), 2308 OldTD->getUnderlyingType()); 2309 else 2310 New->setTypeSourceInfo(OldTD->getTypeSourceInfo()); 2311 2312 // Make the old tag definition visible. 2313 makeMergedDefinitionVisible(Hidden); 2314 2315 // If this was an unscoped enumeration, yank all of its enumerators 2316 // out of the scope. 2317 if (isa<EnumDecl>(NewTag)) { 2318 Scope *EnumScope = getNonFieldDeclScope(S); 2319 for (auto *D : NewTag->decls()) { 2320 auto *ED = cast<EnumConstantDecl>(D); 2321 assert(EnumScope->isDeclScope(ED)); 2322 EnumScope->RemoveDecl(ED); 2323 IdResolver.RemoveDecl(ED); 2324 ED->getLexicalDeclContext()->removeDecl(ED); 2325 } 2326 } 2327 } 2328 } 2329 2330 // If the typedef types are not identical, reject them in all languages and 2331 // with any extensions enabled. 2332 if (isIncompatibleTypedef(Old, New)) 2333 return; 2334 2335 // The types match. Link up the redeclaration chain and merge attributes if 2336 // the old declaration was a typedef. 2337 if (TypedefNameDecl *Typedef = dyn_cast<TypedefNameDecl>(Old)) { 2338 New->setPreviousDecl(Typedef); 2339 mergeDeclAttributes(New, Old); 2340 } 2341 2342 if (getLangOpts().MicrosoftExt) 2343 return; 2344 2345 if (getLangOpts().CPlusPlus) { 2346 // C++ [dcl.typedef]p2: 2347 // In a given non-class scope, a typedef specifier can be used to 2348 // redefine the name of any type declared in that scope to refer 2349 // to the type to which it already refers. 2350 if (!isa<CXXRecordDecl>(CurContext)) 2351 return; 2352 2353 // C++0x [dcl.typedef]p4: 2354 // In a given class scope, a typedef specifier can be used to redefine 2355 // any class-name declared in that scope that is not also a typedef-name 2356 // to refer to the type to which it already refers. 2357 // 2358 // This wording came in via DR424, which was a correction to the 2359 // wording in DR56, which accidentally banned code like: 2360 // 2361 // struct S { 2362 // typedef struct A { } A; 2363 // }; 2364 // 2365 // in the C++03 standard. We implement the C++0x semantics, which 2366 // allow the above but disallow 2367 // 2368 // struct S { 2369 // typedef int I; 2370 // typedef int I; 2371 // }; 2372 // 2373 // since that was the intent of DR56. 2374 if (!isa<TypedefNameDecl>(Old)) 2375 return; 2376 2377 Diag(New->getLocation(), diag::err_redefinition) 2378 << New->getDeclName(); 2379 notePreviousDefinition(Old, New->getLocation()); 2380 return New->setInvalidDecl(); 2381 } 2382 2383 // Modules always permit redefinition of typedefs, as does C11. 2384 if (getLangOpts().Modules || getLangOpts().C11) 2385 return; 2386 2387 // If we have a redefinition of a typedef in C, emit a warning. This warning 2388 // is normally mapped to an error, but can be controlled with 2389 // -Wtypedef-redefinition. If either the original or the redefinition is 2390 // in a system header, don't emit this for compatibility with GCC. 2391 if (getDiagnostics().getSuppressSystemWarnings() && 2392 // Some standard types are defined implicitly in Clang (e.g. OpenCL). 2393 (Old->isImplicit() || 2394 Context.getSourceManager().isInSystemHeader(Old->getLocation()) || 2395 Context.getSourceManager().isInSystemHeader(New->getLocation()))) 2396 return; 2397 2398 Diag(New->getLocation(), diag::ext_redefinition_of_typedef) 2399 << New->getDeclName(); 2400 notePreviousDefinition(Old, New->getLocation()); 2401 } 2402 2403 /// DeclhasAttr - returns true if decl Declaration already has the target 2404 /// attribute. 2405 static bool DeclHasAttr(const Decl *D, const Attr *A) { 2406 const OwnershipAttr *OA = dyn_cast<OwnershipAttr>(A); 2407 const AnnotateAttr *Ann = dyn_cast<AnnotateAttr>(A); 2408 for (const auto *i : D->attrs()) 2409 if (i->getKind() == A->getKind()) { 2410 if (Ann) { 2411 if (Ann->getAnnotation() == cast<AnnotateAttr>(i)->getAnnotation()) 2412 return true; 2413 continue; 2414 } 2415 // FIXME: Don't hardcode this check 2416 if (OA && isa<OwnershipAttr>(i)) 2417 return OA->getOwnKind() == cast<OwnershipAttr>(i)->getOwnKind(); 2418 return true; 2419 } 2420 2421 return false; 2422 } 2423 2424 static bool isAttributeTargetADefinition(Decl *D) { 2425 if (VarDecl *VD = dyn_cast<VarDecl>(D)) 2426 return VD->isThisDeclarationADefinition(); 2427 if (TagDecl *TD = dyn_cast<TagDecl>(D)) 2428 return TD->isCompleteDefinition() || TD->isBeingDefined(); 2429 return true; 2430 } 2431 2432 /// Merge alignment attributes from \p Old to \p New, taking into account the 2433 /// special semantics of C11's _Alignas specifier and C++11's alignas attribute. 2434 /// 2435 /// \return \c true if any attributes were added to \p New. 2436 static bool mergeAlignedAttrs(Sema &S, NamedDecl *New, Decl *Old) { 2437 // Look for alignas attributes on Old, and pick out whichever attribute 2438 // specifies the strictest alignment requirement. 2439 AlignedAttr *OldAlignasAttr = nullptr; 2440 AlignedAttr *OldStrictestAlignAttr = nullptr; 2441 unsigned OldAlign = 0; 2442 for (auto *I : Old->specific_attrs<AlignedAttr>()) { 2443 // FIXME: We have no way of representing inherited dependent alignments 2444 // in a case like: 2445 // template<int A, int B> struct alignas(A) X; 2446 // template<int A, int B> struct alignas(B) X {}; 2447 // For now, we just ignore any alignas attributes which are not on the 2448 // definition in such a case. 2449 if (I->isAlignmentDependent()) 2450 return false; 2451 2452 if (I->isAlignas()) 2453 OldAlignasAttr = I; 2454 2455 unsigned Align = I->getAlignment(S.Context); 2456 if (Align > OldAlign) { 2457 OldAlign = Align; 2458 OldStrictestAlignAttr = I; 2459 } 2460 } 2461 2462 // Look for alignas attributes on New. 2463 AlignedAttr *NewAlignasAttr = nullptr; 2464 unsigned NewAlign = 0; 2465 for (auto *I : New->specific_attrs<AlignedAttr>()) { 2466 if (I->isAlignmentDependent()) 2467 return false; 2468 2469 if (I->isAlignas()) 2470 NewAlignasAttr = I; 2471 2472 unsigned Align = I->getAlignment(S.Context); 2473 if (Align > NewAlign) 2474 NewAlign = Align; 2475 } 2476 2477 if (OldAlignasAttr && NewAlignasAttr && OldAlign != NewAlign) { 2478 // Both declarations have 'alignas' attributes. We require them to match. 2479 // C++11 [dcl.align]p6 and C11 6.7.5/7 both come close to saying this, but 2480 // fall short. (If two declarations both have alignas, they must both match 2481 // every definition, and so must match each other if there is a definition.) 2482 2483 // If either declaration only contains 'alignas(0)' specifiers, then it 2484 // specifies the natural alignment for the type. 2485 if (OldAlign == 0 || NewAlign == 0) { 2486 QualType Ty; 2487 if (ValueDecl *VD = dyn_cast<ValueDecl>(New)) 2488 Ty = VD->getType(); 2489 else 2490 Ty = S.Context.getTagDeclType(cast<TagDecl>(New)); 2491 2492 if (OldAlign == 0) 2493 OldAlign = S.Context.getTypeAlign(Ty); 2494 if (NewAlign == 0) 2495 NewAlign = S.Context.getTypeAlign(Ty); 2496 } 2497 2498 if (OldAlign != NewAlign) { 2499 S.Diag(NewAlignasAttr->getLocation(), diag::err_alignas_mismatch) 2500 << (unsigned)S.Context.toCharUnitsFromBits(OldAlign).getQuantity() 2501 << (unsigned)S.Context.toCharUnitsFromBits(NewAlign).getQuantity(); 2502 S.Diag(OldAlignasAttr->getLocation(), diag::note_previous_declaration); 2503 } 2504 } 2505 2506 if (OldAlignasAttr && !NewAlignasAttr && isAttributeTargetADefinition(New)) { 2507 // C++11 [dcl.align]p6: 2508 // if any declaration of an entity has an alignment-specifier, 2509 // every defining declaration of that entity shall specify an 2510 // equivalent alignment. 2511 // C11 6.7.5/7: 2512 // If the definition of an object does not have an alignment 2513 // specifier, any other declaration of that object shall also 2514 // have no alignment specifier. 2515 S.Diag(New->getLocation(), diag::err_alignas_missing_on_definition) 2516 << OldAlignasAttr; 2517 S.Diag(OldAlignasAttr->getLocation(), diag::note_alignas_on_declaration) 2518 << OldAlignasAttr; 2519 } 2520 2521 bool AnyAdded = false; 2522 2523 // Ensure we have an attribute representing the strictest alignment. 2524 if (OldAlign > NewAlign) { 2525 AlignedAttr *Clone = OldStrictestAlignAttr->clone(S.Context); 2526 Clone->setInherited(true); 2527 New->addAttr(Clone); 2528 AnyAdded = true; 2529 } 2530 2531 // Ensure we have an alignas attribute if the old declaration had one. 2532 if (OldAlignasAttr && !NewAlignasAttr && 2533 !(AnyAdded && OldStrictestAlignAttr->isAlignas())) { 2534 AlignedAttr *Clone = OldAlignasAttr->clone(S.Context); 2535 Clone->setInherited(true); 2536 New->addAttr(Clone); 2537 AnyAdded = true; 2538 } 2539 2540 return AnyAdded; 2541 } 2542 2543 static bool mergeDeclAttribute(Sema &S, NamedDecl *D, 2544 const InheritableAttr *Attr, 2545 Sema::AvailabilityMergeKind AMK) { 2546 // This function copies an attribute Attr from a previous declaration to the 2547 // new declaration D if the new declaration doesn't itself have that attribute 2548 // yet or if that attribute allows duplicates. 2549 // If you're adding a new attribute that requires logic different from 2550 // "use explicit attribute on decl if present, else use attribute from 2551 // previous decl", for example if the attribute needs to be consistent 2552 // between redeclarations, you need to call a custom merge function here. 2553 InheritableAttr *NewAttr = nullptr; 2554 if (const auto *AA = dyn_cast<AvailabilityAttr>(Attr)) 2555 NewAttr = S.mergeAvailabilityAttr( 2556 D, *AA, AA->getPlatform(), AA->isImplicit(), AA->getIntroduced(), 2557 AA->getDeprecated(), AA->getObsoleted(), AA->getUnavailable(), 2558 AA->getMessage(), AA->getStrict(), AA->getReplacement(), AMK, 2559 AA->getPriority()); 2560 else if (const auto *VA = dyn_cast<VisibilityAttr>(Attr)) 2561 NewAttr = S.mergeVisibilityAttr(D, *VA, VA->getVisibility()); 2562 else if (const auto *VA = dyn_cast<TypeVisibilityAttr>(Attr)) 2563 NewAttr = S.mergeTypeVisibilityAttr(D, *VA, VA->getVisibility()); 2564 else if (const auto *ImportA = dyn_cast<DLLImportAttr>(Attr)) 2565 NewAttr = S.mergeDLLImportAttr(D, *ImportA); 2566 else if (const auto *ExportA = dyn_cast<DLLExportAttr>(Attr)) 2567 NewAttr = S.mergeDLLExportAttr(D, *ExportA); 2568 else if (const auto *FA = dyn_cast<FormatAttr>(Attr)) 2569 NewAttr = S.mergeFormatAttr(D, *FA, FA->getType(), FA->getFormatIdx(), 2570 FA->getFirstArg()); 2571 else if (const auto *SA = dyn_cast<SectionAttr>(Attr)) 2572 NewAttr = S.mergeSectionAttr(D, *SA, SA->getName()); 2573 else if (const auto *CSA = dyn_cast<CodeSegAttr>(Attr)) 2574 NewAttr = S.mergeCodeSegAttr(D, *CSA, CSA->getName()); 2575 else if (const auto *IA = dyn_cast<MSInheritanceAttr>(Attr)) 2576 NewAttr = S.mergeMSInheritanceAttr(D, *IA, IA->getBestCase(), 2577 IA->getInheritanceModel()); 2578 else if (const auto *AA = dyn_cast<AlwaysInlineAttr>(Attr)) 2579 NewAttr = S.mergeAlwaysInlineAttr(D, *AA, 2580 &S.Context.Idents.get(AA->getSpelling())); 2581 else if (S.getLangOpts().CUDA && isa<FunctionDecl>(D) && 2582 (isa<CUDAHostAttr>(Attr) || isa<CUDADeviceAttr>(Attr) || 2583 isa<CUDAGlobalAttr>(Attr))) { 2584 // CUDA target attributes are part of function signature for 2585 // overloading purposes and must not be merged. 2586 return false; 2587 } else if (const auto *MA = dyn_cast<MinSizeAttr>(Attr)) 2588 NewAttr = S.mergeMinSizeAttr(D, *MA); 2589 else if (const auto *SNA = dyn_cast<SwiftNameAttr>(Attr)) 2590 NewAttr = S.mergeSwiftNameAttr(D, *SNA, SNA->getName()); 2591 else if (const auto *OA = dyn_cast<OptimizeNoneAttr>(Attr)) 2592 NewAttr = S.mergeOptimizeNoneAttr(D, *OA); 2593 else if (const auto *InternalLinkageA = dyn_cast<InternalLinkageAttr>(Attr)) 2594 NewAttr = S.mergeInternalLinkageAttr(D, *InternalLinkageA); 2595 else if (const auto *CommonA = dyn_cast<CommonAttr>(Attr)) 2596 NewAttr = S.mergeCommonAttr(D, *CommonA); 2597 else if (isa<AlignedAttr>(Attr)) 2598 // AlignedAttrs are handled separately, because we need to handle all 2599 // such attributes on a declaration at the same time. 2600 NewAttr = nullptr; 2601 else if ((isa<DeprecatedAttr>(Attr) || isa<UnavailableAttr>(Attr)) && 2602 (AMK == Sema::AMK_Override || 2603 AMK == Sema::AMK_ProtocolImplementation)) 2604 NewAttr = nullptr; 2605 else if (const auto *UA = dyn_cast<UuidAttr>(Attr)) 2606 NewAttr = S.mergeUuidAttr(D, *UA, UA->getGuid(), UA->getGuidDecl()); 2607 else if (const auto *SLHA = dyn_cast<SpeculativeLoadHardeningAttr>(Attr)) 2608 NewAttr = S.mergeSpeculativeLoadHardeningAttr(D, *SLHA); 2609 else if (const auto *SLHA = dyn_cast<NoSpeculativeLoadHardeningAttr>(Attr)) 2610 NewAttr = S.mergeNoSpeculativeLoadHardeningAttr(D, *SLHA); 2611 else if (const auto *IMA = dyn_cast<WebAssemblyImportModuleAttr>(Attr)) 2612 NewAttr = S.mergeImportModuleAttr(D, *IMA); 2613 else if (const auto *INA = dyn_cast<WebAssemblyImportNameAttr>(Attr)) 2614 NewAttr = S.mergeImportNameAttr(D, *INA); 2615 else if (const auto *TCBA = dyn_cast<EnforceTCBAttr>(Attr)) 2616 NewAttr = S.mergeEnforceTCBAttr(D, *TCBA); 2617 else if (const auto *TCBLA = dyn_cast<EnforceTCBLeafAttr>(Attr)) 2618 NewAttr = S.mergeEnforceTCBLeafAttr(D, *TCBLA); 2619 else if (Attr->shouldInheritEvenIfAlreadyPresent() || !DeclHasAttr(D, Attr)) 2620 NewAttr = cast<InheritableAttr>(Attr->clone(S.Context)); 2621 2622 if (NewAttr) { 2623 NewAttr->setInherited(true); 2624 D->addAttr(NewAttr); 2625 if (isa<MSInheritanceAttr>(NewAttr)) 2626 S.Consumer.AssignInheritanceModel(cast<CXXRecordDecl>(D)); 2627 return true; 2628 } 2629 2630 return false; 2631 } 2632 2633 static const NamedDecl *getDefinition(const Decl *D) { 2634 if (const TagDecl *TD = dyn_cast<TagDecl>(D)) 2635 return TD->getDefinition(); 2636 if (const VarDecl *VD = dyn_cast<VarDecl>(D)) { 2637 const VarDecl *Def = VD->getDefinition(); 2638 if (Def) 2639 return Def; 2640 return VD->getActingDefinition(); 2641 } 2642 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) { 2643 const FunctionDecl *Def = nullptr; 2644 if (FD->isDefined(Def, true)) 2645 return Def; 2646 } 2647 return nullptr; 2648 } 2649 2650 static bool hasAttribute(const Decl *D, attr::Kind Kind) { 2651 for (const auto *Attribute : D->attrs()) 2652 if (Attribute->getKind() == Kind) 2653 return true; 2654 return false; 2655 } 2656 2657 /// checkNewAttributesAfterDef - If we already have a definition, check that 2658 /// there are no new attributes in this declaration. 2659 static void checkNewAttributesAfterDef(Sema &S, Decl *New, const Decl *Old) { 2660 if (!New->hasAttrs()) 2661 return; 2662 2663 const NamedDecl *Def = getDefinition(Old); 2664 if (!Def || Def == New) 2665 return; 2666 2667 AttrVec &NewAttributes = New->getAttrs(); 2668 for (unsigned I = 0, E = NewAttributes.size(); I != E;) { 2669 const Attr *NewAttribute = NewAttributes[I]; 2670 2671 if (isa<AliasAttr>(NewAttribute) || isa<IFuncAttr>(NewAttribute)) { 2672 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(New)) { 2673 Sema::SkipBodyInfo SkipBody; 2674 S.CheckForFunctionRedefinition(FD, cast<FunctionDecl>(Def), &SkipBody); 2675 2676 // If we're skipping this definition, drop the "alias" attribute. 2677 if (SkipBody.ShouldSkip) { 2678 NewAttributes.erase(NewAttributes.begin() + I); 2679 --E; 2680 continue; 2681 } 2682 } else { 2683 VarDecl *VD = cast<VarDecl>(New); 2684 unsigned Diag = cast<VarDecl>(Def)->isThisDeclarationADefinition() == 2685 VarDecl::TentativeDefinition 2686 ? diag::err_alias_after_tentative 2687 : diag::err_redefinition; 2688 S.Diag(VD->getLocation(), Diag) << VD->getDeclName(); 2689 if (Diag == diag::err_redefinition) 2690 S.notePreviousDefinition(Def, VD->getLocation()); 2691 else 2692 S.Diag(Def->getLocation(), diag::note_previous_definition); 2693 VD->setInvalidDecl(); 2694 } 2695 ++I; 2696 continue; 2697 } 2698 2699 if (const VarDecl *VD = dyn_cast<VarDecl>(Def)) { 2700 // Tentative definitions are only interesting for the alias check above. 2701 if (VD->isThisDeclarationADefinition() != VarDecl::Definition) { 2702 ++I; 2703 continue; 2704 } 2705 } 2706 2707 if (hasAttribute(Def, NewAttribute->getKind())) { 2708 ++I; 2709 continue; // regular attr merging will take care of validating this. 2710 } 2711 2712 if (isa<C11NoReturnAttr>(NewAttribute)) { 2713 // C's _Noreturn is allowed to be added to a function after it is defined. 2714 ++I; 2715 continue; 2716 } else if (isa<UuidAttr>(NewAttribute)) { 2717 // msvc will allow a subsequent definition to add an uuid to a class 2718 ++I; 2719 continue; 2720 } else if (const AlignedAttr *AA = dyn_cast<AlignedAttr>(NewAttribute)) { 2721 if (AA->isAlignas()) { 2722 // C++11 [dcl.align]p6: 2723 // if any declaration of an entity has an alignment-specifier, 2724 // every defining declaration of that entity shall specify an 2725 // equivalent alignment. 2726 // C11 6.7.5/7: 2727 // If the definition of an object does not have an alignment 2728 // specifier, any other declaration of that object shall also 2729 // have no alignment specifier. 2730 S.Diag(Def->getLocation(), diag::err_alignas_missing_on_definition) 2731 << AA; 2732 S.Diag(NewAttribute->getLocation(), diag::note_alignas_on_declaration) 2733 << AA; 2734 NewAttributes.erase(NewAttributes.begin() + I); 2735 --E; 2736 continue; 2737 } 2738 } else if (isa<LoaderUninitializedAttr>(NewAttribute)) { 2739 // If there is a C definition followed by a redeclaration with this 2740 // attribute then there are two different definitions. In C++, prefer the 2741 // standard diagnostics. 2742 if (!S.getLangOpts().CPlusPlus) { 2743 S.Diag(NewAttribute->getLocation(), 2744 diag::err_loader_uninitialized_redeclaration); 2745 S.Diag(Def->getLocation(), diag::note_previous_definition); 2746 NewAttributes.erase(NewAttributes.begin() + I); 2747 --E; 2748 continue; 2749 } 2750 } else if (isa<SelectAnyAttr>(NewAttribute) && 2751 cast<VarDecl>(New)->isInline() && 2752 !cast<VarDecl>(New)->isInlineSpecified()) { 2753 // Don't warn about applying selectany to implicitly inline variables. 2754 // Older compilers and language modes would require the use of selectany 2755 // to make such variables inline, and it would have no effect if we 2756 // honored it. 2757 ++I; 2758 continue; 2759 } else if (isa<OMPDeclareVariantAttr>(NewAttribute)) { 2760 // We allow to add OMP[Begin]DeclareVariantAttr to be added to 2761 // declarations after defintions. 2762 ++I; 2763 continue; 2764 } 2765 2766 S.Diag(NewAttribute->getLocation(), 2767 diag::warn_attribute_precede_definition); 2768 S.Diag(Def->getLocation(), diag::note_previous_definition); 2769 NewAttributes.erase(NewAttributes.begin() + I); 2770 --E; 2771 } 2772 } 2773 2774 static void diagnoseMissingConstinit(Sema &S, const VarDecl *InitDecl, 2775 const ConstInitAttr *CIAttr, 2776 bool AttrBeforeInit) { 2777 SourceLocation InsertLoc = InitDecl->getInnerLocStart(); 2778 2779 // Figure out a good way to write this specifier on the old declaration. 2780 // FIXME: We should just use the spelling of CIAttr, but we don't preserve 2781 // enough of the attribute list spelling information to extract that without 2782 // heroics. 2783 std::string SuitableSpelling; 2784 if (S.getLangOpts().CPlusPlus20) 2785 SuitableSpelling = std::string( 2786 S.PP.getLastMacroWithSpelling(InsertLoc, {tok::kw_constinit})); 2787 if (SuitableSpelling.empty() && S.getLangOpts().CPlusPlus11) 2788 SuitableSpelling = std::string(S.PP.getLastMacroWithSpelling( 2789 InsertLoc, {tok::l_square, tok::l_square, 2790 S.PP.getIdentifierInfo("clang"), tok::coloncolon, 2791 S.PP.getIdentifierInfo("require_constant_initialization"), 2792 tok::r_square, tok::r_square})); 2793 if (SuitableSpelling.empty()) 2794 SuitableSpelling = std::string(S.PP.getLastMacroWithSpelling( 2795 InsertLoc, {tok::kw___attribute, tok::l_paren, tok::r_paren, 2796 S.PP.getIdentifierInfo("require_constant_initialization"), 2797 tok::r_paren, tok::r_paren})); 2798 if (SuitableSpelling.empty() && S.getLangOpts().CPlusPlus20) 2799 SuitableSpelling = "constinit"; 2800 if (SuitableSpelling.empty() && S.getLangOpts().CPlusPlus11) 2801 SuitableSpelling = "[[clang::require_constant_initialization]]"; 2802 if (SuitableSpelling.empty()) 2803 SuitableSpelling = "__attribute__((require_constant_initialization))"; 2804 SuitableSpelling += " "; 2805 2806 if (AttrBeforeInit) { 2807 // extern constinit int a; 2808 // int a = 0; // error (missing 'constinit'), accepted as extension 2809 assert(CIAttr->isConstinit() && "should not diagnose this for attribute"); 2810 S.Diag(InitDecl->getLocation(), diag::ext_constinit_missing) 2811 << InitDecl << FixItHint::CreateInsertion(InsertLoc, SuitableSpelling); 2812 S.Diag(CIAttr->getLocation(), diag::note_constinit_specified_here); 2813 } else { 2814 // int a = 0; 2815 // constinit extern int a; // error (missing 'constinit') 2816 S.Diag(CIAttr->getLocation(), 2817 CIAttr->isConstinit() ? diag::err_constinit_added_too_late 2818 : diag::warn_require_const_init_added_too_late) 2819 << FixItHint::CreateRemoval(SourceRange(CIAttr->getLocation())); 2820 S.Diag(InitDecl->getLocation(), diag::note_constinit_missing_here) 2821 << CIAttr->isConstinit() 2822 << FixItHint::CreateInsertion(InsertLoc, SuitableSpelling); 2823 } 2824 } 2825 2826 /// mergeDeclAttributes - Copy attributes from the Old decl to the New one. 2827 void Sema::mergeDeclAttributes(NamedDecl *New, Decl *Old, 2828 AvailabilityMergeKind AMK) { 2829 if (UsedAttr *OldAttr = Old->getMostRecentDecl()->getAttr<UsedAttr>()) { 2830 UsedAttr *NewAttr = OldAttr->clone(Context); 2831 NewAttr->setInherited(true); 2832 New->addAttr(NewAttr); 2833 } 2834 2835 if (!Old->hasAttrs() && !New->hasAttrs()) 2836 return; 2837 2838 // [dcl.constinit]p1: 2839 // If the [constinit] specifier is applied to any declaration of a 2840 // variable, it shall be applied to the initializing declaration. 2841 const auto *OldConstInit = Old->getAttr<ConstInitAttr>(); 2842 const auto *NewConstInit = New->getAttr<ConstInitAttr>(); 2843 if (bool(OldConstInit) != bool(NewConstInit)) { 2844 const auto *OldVD = cast<VarDecl>(Old); 2845 auto *NewVD = cast<VarDecl>(New); 2846 2847 // Find the initializing declaration. Note that we might not have linked 2848 // the new declaration into the redeclaration chain yet. 2849 const VarDecl *InitDecl = OldVD->getInitializingDeclaration(); 2850 if (!InitDecl && 2851 (NewVD->hasInit() || NewVD->isThisDeclarationADefinition())) 2852 InitDecl = NewVD; 2853 2854 if (InitDecl == NewVD) { 2855 // This is the initializing declaration. If it would inherit 'constinit', 2856 // that's ill-formed. (Note that we do not apply this to the attribute 2857 // form). 2858 if (OldConstInit && OldConstInit->isConstinit()) 2859 diagnoseMissingConstinit(*this, NewVD, OldConstInit, 2860 /*AttrBeforeInit=*/true); 2861 } else if (NewConstInit) { 2862 // This is the first time we've been told that this declaration should 2863 // have a constant initializer. If we already saw the initializing 2864 // declaration, this is too late. 2865 if (InitDecl && InitDecl != NewVD) { 2866 diagnoseMissingConstinit(*this, InitDecl, NewConstInit, 2867 /*AttrBeforeInit=*/false); 2868 NewVD->dropAttr<ConstInitAttr>(); 2869 } 2870 } 2871 } 2872 2873 // Attributes declared post-definition are currently ignored. 2874 checkNewAttributesAfterDef(*this, New, Old); 2875 2876 if (AsmLabelAttr *NewA = New->getAttr<AsmLabelAttr>()) { 2877 if (AsmLabelAttr *OldA = Old->getAttr<AsmLabelAttr>()) { 2878 if (!OldA->isEquivalent(NewA)) { 2879 // This redeclaration changes __asm__ label. 2880 Diag(New->getLocation(), diag::err_different_asm_label); 2881 Diag(OldA->getLocation(), diag::note_previous_declaration); 2882 } 2883 } else if (Old->isUsed()) { 2884 // This redeclaration adds an __asm__ label to a declaration that has 2885 // already been ODR-used. 2886 Diag(New->getLocation(), diag::err_late_asm_label_name) 2887 << isa<FunctionDecl>(Old) << New->getAttr<AsmLabelAttr>()->getRange(); 2888 } 2889 } 2890 2891 // Re-declaration cannot add abi_tag's. 2892 if (const auto *NewAbiTagAttr = New->getAttr<AbiTagAttr>()) { 2893 if (const auto *OldAbiTagAttr = Old->getAttr<AbiTagAttr>()) { 2894 for (const auto &NewTag : NewAbiTagAttr->tags()) { 2895 if (std::find(OldAbiTagAttr->tags_begin(), OldAbiTagAttr->tags_end(), 2896 NewTag) == OldAbiTagAttr->tags_end()) { 2897 Diag(NewAbiTagAttr->getLocation(), 2898 diag::err_new_abi_tag_on_redeclaration) 2899 << NewTag; 2900 Diag(OldAbiTagAttr->getLocation(), diag::note_previous_declaration); 2901 } 2902 } 2903 } else { 2904 Diag(NewAbiTagAttr->getLocation(), diag::err_abi_tag_on_redeclaration); 2905 Diag(Old->getLocation(), diag::note_previous_declaration); 2906 } 2907 } 2908 2909 // This redeclaration adds a section attribute. 2910 if (New->hasAttr<SectionAttr>() && !Old->hasAttr<SectionAttr>()) { 2911 if (auto *VD = dyn_cast<VarDecl>(New)) { 2912 if (VD->isThisDeclarationADefinition() == VarDecl::DeclarationOnly) { 2913 Diag(New->getLocation(), diag::warn_attribute_section_on_redeclaration); 2914 Diag(Old->getLocation(), diag::note_previous_declaration); 2915 } 2916 } 2917 } 2918 2919 // Redeclaration adds code-seg attribute. 2920 const auto *NewCSA = New->getAttr<CodeSegAttr>(); 2921 if (NewCSA && !Old->hasAttr<CodeSegAttr>() && 2922 !NewCSA->isImplicit() && isa<CXXMethodDecl>(New)) { 2923 Diag(New->getLocation(), diag::warn_mismatched_section) 2924 << 0 /*codeseg*/; 2925 Diag(Old->getLocation(), diag::note_previous_declaration); 2926 } 2927 2928 if (!Old->hasAttrs()) 2929 return; 2930 2931 bool foundAny = New->hasAttrs(); 2932 2933 // Ensure that any moving of objects within the allocated map is done before 2934 // we process them. 2935 if (!foundAny) New->setAttrs(AttrVec()); 2936 2937 for (auto *I : Old->specific_attrs<InheritableAttr>()) { 2938 // Ignore deprecated/unavailable/availability attributes if requested. 2939 AvailabilityMergeKind LocalAMK = AMK_None; 2940 if (isa<DeprecatedAttr>(I) || 2941 isa<UnavailableAttr>(I) || 2942 isa<AvailabilityAttr>(I)) { 2943 switch (AMK) { 2944 case AMK_None: 2945 continue; 2946 2947 case AMK_Redeclaration: 2948 case AMK_Override: 2949 case AMK_ProtocolImplementation: 2950 LocalAMK = AMK; 2951 break; 2952 } 2953 } 2954 2955 // Already handled. 2956 if (isa<UsedAttr>(I)) 2957 continue; 2958 2959 if (mergeDeclAttribute(*this, New, I, LocalAMK)) 2960 foundAny = true; 2961 } 2962 2963 if (mergeAlignedAttrs(*this, New, Old)) 2964 foundAny = true; 2965 2966 if (!foundAny) New->dropAttrs(); 2967 } 2968 2969 /// mergeParamDeclAttributes - Copy attributes from the old parameter 2970 /// to the new one. 2971 static void mergeParamDeclAttributes(ParmVarDecl *newDecl, 2972 const ParmVarDecl *oldDecl, 2973 Sema &S) { 2974 // C++11 [dcl.attr.depend]p2: 2975 // The first declaration of a function shall specify the 2976 // carries_dependency attribute for its declarator-id if any declaration 2977 // of the function specifies the carries_dependency attribute. 2978 const CarriesDependencyAttr *CDA = newDecl->getAttr<CarriesDependencyAttr>(); 2979 if (CDA && !oldDecl->hasAttr<CarriesDependencyAttr>()) { 2980 S.Diag(CDA->getLocation(), 2981 diag::err_carries_dependency_missing_on_first_decl) << 1/*Param*/; 2982 // Find the first declaration of the parameter. 2983 // FIXME: Should we build redeclaration chains for function parameters? 2984 const FunctionDecl *FirstFD = 2985 cast<FunctionDecl>(oldDecl->getDeclContext())->getFirstDecl(); 2986 const ParmVarDecl *FirstVD = 2987 FirstFD->getParamDecl(oldDecl->getFunctionScopeIndex()); 2988 S.Diag(FirstVD->getLocation(), 2989 diag::note_carries_dependency_missing_first_decl) << 1/*Param*/; 2990 } 2991 2992 if (!oldDecl->hasAttrs()) 2993 return; 2994 2995 bool foundAny = newDecl->hasAttrs(); 2996 2997 // Ensure that any moving of objects within the allocated map is 2998 // done before we process them. 2999 if (!foundAny) newDecl->setAttrs(AttrVec()); 3000 3001 for (const auto *I : oldDecl->specific_attrs<InheritableParamAttr>()) { 3002 if (!DeclHasAttr(newDecl, I)) { 3003 InheritableAttr *newAttr = 3004 cast<InheritableParamAttr>(I->clone(S.Context)); 3005 newAttr->setInherited(true); 3006 newDecl->addAttr(newAttr); 3007 foundAny = true; 3008 } 3009 } 3010 3011 if (!foundAny) newDecl->dropAttrs(); 3012 } 3013 3014 static void mergeParamDeclTypes(ParmVarDecl *NewParam, 3015 const ParmVarDecl *OldParam, 3016 Sema &S) { 3017 if (auto Oldnullability = OldParam->getType()->getNullability(S.Context)) { 3018 if (auto Newnullability = NewParam->getType()->getNullability(S.Context)) { 3019 if (*Oldnullability != *Newnullability) { 3020 S.Diag(NewParam->getLocation(), diag::warn_mismatched_nullability_attr) 3021 << DiagNullabilityKind( 3022 *Newnullability, 3023 ((NewParam->getObjCDeclQualifier() & Decl::OBJC_TQ_CSNullability) 3024 != 0)) 3025 << DiagNullabilityKind( 3026 *Oldnullability, 3027 ((OldParam->getObjCDeclQualifier() & Decl::OBJC_TQ_CSNullability) 3028 != 0)); 3029 S.Diag(OldParam->getLocation(), diag::note_previous_declaration); 3030 } 3031 } else { 3032 QualType NewT = NewParam->getType(); 3033 NewT = S.Context.getAttributedType( 3034 AttributedType::getNullabilityAttrKind(*Oldnullability), 3035 NewT, NewT); 3036 NewParam->setType(NewT); 3037 } 3038 } 3039 } 3040 3041 namespace { 3042 3043 /// Used in MergeFunctionDecl to keep track of function parameters in 3044 /// C. 3045 struct GNUCompatibleParamWarning { 3046 ParmVarDecl *OldParm; 3047 ParmVarDecl *NewParm; 3048 QualType PromotedType; 3049 }; 3050 3051 } // end anonymous namespace 3052 3053 // Determine whether the previous declaration was a definition, implicit 3054 // declaration, or a declaration. 3055 template <typename T> 3056 static std::pair<diag::kind, SourceLocation> 3057 getNoteDiagForInvalidRedeclaration(const T *Old, const T *New) { 3058 diag::kind PrevDiag; 3059 SourceLocation OldLocation = Old->getLocation(); 3060 if (Old->isThisDeclarationADefinition()) 3061 PrevDiag = diag::note_previous_definition; 3062 else if (Old->isImplicit()) { 3063 PrevDiag = diag::note_previous_implicit_declaration; 3064 if (OldLocation.isInvalid()) 3065 OldLocation = New->getLocation(); 3066 } else 3067 PrevDiag = diag::note_previous_declaration; 3068 return std::make_pair(PrevDiag, OldLocation); 3069 } 3070 3071 /// canRedefineFunction - checks if a function can be redefined. Currently, 3072 /// only extern inline functions can be redefined, and even then only in 3073 /// GNU89 mode. 3074 static bool canRedefineFunction(const FunctionDecl *FD, 3075 const LangOptions& LangOpts) { 3076 return ((FD->hasAttr<GNUInlineAttr>() || LangOpts.GNUInline) && 3077 !LangOpts.CPlusPlus && 3078 FD->isInlineSpecified() && 3079 FD->getStorageClass() == SC_Extern); 3080 } 3081 3082 const AttributedType *Sema::getCallingConvAttributedType(QualType T) const { 3083 const AttributedType *AT = T->getAs<AttributedType>(); 3084 while (AT && !AT->isCallingConv()) 3085 AT = AT->getModifiedType()->getAs<AttributedType>(); 3086 return AT; 3087 } 3088 3089 template <typename T> 3090 static bool haveIncompatibleLanguageLinkages(const T *Old, const T *New) { 3091 const DeclContext *DC = Old->getDeclContext(); 3092 if (DC->isRecord()) 3093 return false; 3094 3095 LanguageLinkage OldLinkage = Old->getLanguageLinkage(); 3096 if (OldLinkage == CXXLanguageLinkage && New->isInExternCContext()) 3097 return true; 3098 if (OldLinkage == CLanguageLinkage && New->isInExternCXXContext()) 3099 return true; 3100 return false; 3101 } 3102 3103 template<typename T> static bool isExternC(T *D) { return D->isExternC(); } 3104 static bool isExternC(VarTemplateDecl *) { return false; } 3105 3106 /// Check whether a redeclaration of an entity introduced by a 3107 /// using-declaration is valid, given that we know it's not an overload 3108 /// (nor a hidden tag declaration). 3109 template<typename ExpectedDecl> 3110 static bool checkUsingShadowRedecl(Sema &S, UsingShadowDecl *OldS, 3111 ExpectedDecl *New) { 3112 // C++11 [basic.scope.declarative]p4: 3113 // Given a set of declarations in a single declarative region, each of 3114 // which specifies the same unqualified name, 3115 // -- they shall all refer to the same entity, or all refer to functions 3116 // and function templates; or 3117 // -- exactly one declaration shall declare a class name or enumeration 3118 // name that is not a typedef name and the other declarations shall all 3119 // refer to the same variable or enumerator, or all refer to functions 3120 // and function templates; in this case the class name or enumeration 3121 // name is hidden (3.3.10). 3122 3123 // C++11 [namespace.udecl]p14: 3124 // If a function declaration in namespace scope or block scope has the 3125 // same name and the same parameter-type-list as a function introduced 3126 // by a using-declaration, and the declarations do not declare the same 3127 // function, the program is ill-formed. 3128 3129 auto *Old = dyn_cast<ExpectedDecl>(OldS->getTargetDecl()); 3130 if (Old && 3131 !Old->getDeclContext()->getRedeclContext()->Equals( 3132 New->getDeclContext()->getRedeclContext()) && 3133 !(isExternC(Old) && isExternC(New))) 3134 Old = nullptr; 3135 3136 if (!Old) { 3137 S.Diag(New->getLocation(), diag::err_using_decl_conflict_reverse); 3138 S.Diag(OldS->getTargetDecl()->getLocation(), diag::note_using_decl_target); 3139 S.Diag(OldS->getUsingDecl()->getLocation(), diag::note_using_decl) << 0; 3140 return true; 3141 } 3142 return false; 3143 } 3144 3145 static bool hasIdenticalPassObjectSizeAttrs(const FunctionDecl *A, 3146 const FunctionDecl *B) { 3147 assert(A->getNumParams() == B->getNumParams()); 3148 3149 auto AttrEq = [](const ParmVarDecl *A, const ParmVarDecl *B) { 3150 const auto *AttrA = A->getAttr<PassObjectSizeAttr>(); 3151 const auto *AttrB = B->getAttr<PassObjectSizeAttr>(); 3152 if (AttrA == AttrB) 3153 return true; 3154 return AttrA && AttrB && AttrA->getType() == AttrB->getType() && 3155 AttrA->isDynamic() == AttrB->isDynamic(); 3156 }; 3157 3158 return std::equal(A->param_begin(), A->param_end(), B->param_begin(), AttrEq); 3159 } 3160 3161 /// If necessary, adjust the semantic declaration context for a qualified 3162 /// declaration to name the correct inline namespace within the qualifier. 3163 static void adjustDeclContextForDeclaratorDecl(DeclaratorDecl *NewD, 3164 DeclaratorDecl *OldD) { 3165 // The only case where we need to update the DeclContext is when 3166 // redeclaration lookup for a qualified name finds a declaration 3167 // in an inline namespace within the context named by the qualifier: 3168 // 3169 // inline namespace N { int f(); } 3170 // int ::f(); // Sema DC needs adjusting from :: to N::. 3171 // 3172 // For unqualified declarations, the semantic context *can* change 3173 // along the redeclaration chain (for local extern declarations, 3174 // extern "C" declarations, and friend declarations in particular). 3175 if (!NewD->getQualifier()) 3176 return; 3177 3178 // NewD is probably already in the right context. 3179 auto *NamedDC = NewD->getDeclContext()->getRedeclContext(); 3180 auto *SemaDC = OldD->getDeclContext()->getRedeclContext(); 3181 if (NamedDC->Equals(SemaDC)) 3182 return; 3183 3184 assert((NamedDC->InEnclosingNamespaceSetOf(SemaDC) || 3185 NewD->isInvalidDecl() || OldD->isInvalidDecl()) && 3186 "unexpected context for redeclaration"); 3187 3188 auto *LexDC = NewD->getLexicalDeclContext(); 3189 auto FixSemaDC = [=](NamedDecl *D) { 3190 if (!D) 3191 return; 3192 D->setDeclContext(SemaDC); 3193 D->setLexicalDeclContext(LexDC); 3194 }; 3195 3196 FixSemaDC(NewD); 3197 if (auto *FD = dyn_cast<FunctionDecl>(NewD)) 3198 FixSemaDC(FD->getDescribedFunctionTemplate()); 3199 else if (auto *VD = dyn_cast<VarDecl>(NewD)) 3200 FixSemaDC(VD->getDescribedVarTemplate()); 3201 } 3202 3203 /// MergeFunctionDecl - We just parsed a function 'New' from 3204 /// declarator D which has the same name and scope as a previous 3205 /// declaration 'Old'. Figure out how to resolve this situation, 3206 /// merging decls or emitting diagnostics as appropriate. 3207 /// 3208 /// In C++, New and Old must be declarations that are not 3209 /// overloaded. Use IsOverload to determine whether New and Old are 3210 /// overloaded, and to select the Old declaration that New should be 3211 /// merged with. 3212 /// 3213 /// Returns true if there was an error, false otherwise. 3214 bool Sema::MergeFunctionDecl(FunctionDecl *New, NamedDecl *&OldD, 3215 Scope *S, bool MergeTypeWithOld) { 3216 // Verify the old decl was also a function. 3217 FunctionDecl *Old = OldD->getAsFunction(); 3218 if (!Old) { 3219 if (UsingShadowDecl *Shadow = dyn_cast<UsingShadowDecl>(OldD)) { 3220 if (New->getFriendObjectKind()) { 3221 Diag(New->getLocation(), diag::err_using_decl_friend); 3222 Diag(Shadow->getTargetDecl()->getLocation(), 3223 diag::note_using_decl_target); 3224 Diag(Shadow->getUsingDecl()->getLocation(), 3225 diag::note_using_decl) << 0; 3226 return true; 3227 } 3228 3229 // Check whether the two declarations might declare the same function. 3230 if (checkUsingShadowRedecl<FunctionDecl>(*this, Shadow, New)) 3231 return true; 3232 OldD = Old = cast<FunctionDecl>(Shadow->getTargetDecl()); 3233 } else { 3234 Diag(New->getLocation(), diag::err_redefinition_different_kind) 3235 << New->getDeclName(); 3236 notePreviousDefinition(OldD, New->getLocation()); 3237 return true; 3238 } 3239 } 3240 3241 // If the old declaration was found in an inline namespace and the new 3242 // declaration was qualified, update the DeclContext to match. 3243 adjustDeclContextForDeclaratorDecl(New, Old); 3244 3245 // If the old declaration is invalid, just give up here. 3246 if (Old->isInvalidDecl()) 3247 return true; 3248 3249 // Disallow redeclaration of some builtins. 3250 if (!getASTContext().canBuiltinBeRedeclared(Old)) { 3251 Diag(New->getLocation(), diag::err_builtin_redeclare) << Old->getDeclName(); 3252 Diag(Old->getLocation(), diag::note_previous_builtin_declaration) 3253 << Old << Old->getType(); 3254 return true; 3255 } 3256 3257 diag::kind PrevDiag; 3258 SourceLocation OldLocation; 3259 std::tie(PrevDiag, OldLocation) = 3260 getNoteDiagForInvalidRedeclaration(Old, New); 3261 3262 // Don't complain about this if we're in GNU89 mode and the old function 3263 // is an extern inline function. 3264 // Don't complain about specializations. They are not supposed to have 3265 // storage classes. 3266 if (!isa<CXXMethodDecl>(New) && !isa<CXXMethodDecl>(Old) && 3267 New->getStorageClass() == SC_Static && 3268 Old->hasExternalFormalLinkage() && 3269 !New->getTemplateSpecializationInfo() && 3270 !canRedefineFunction(Old, getLangOpts())) { 3271 if (getLangOpts().MicrosoftExt) { 3272 Diag(New->getLocation(), diag::ext_static_non_static) << New; 3273 Diag(OldLocation, PrevDiag); 3274 } else { 3275 Diag(New->getLocation(), diag::err_static_non_static) << New; 3276 Diag(OldLocation, PrevDiag); 3277 return true; 3278 } 3279 } 3280 3281 if (New->hasAttr<InternalLinkageAttr>() && 3282 !Old->hasAttr<InternalLinkageAttr>()) { 3283 Diag(New->getLocation(), diag::err_internal_linkage_redeclaration) 3284 << New->getDeclName(); 3285 notePreviousDefinition(Old, New->getLocation()); 3286 New->dropAttr<InternalLinkageAttr>(); 3287 } 3288 3289 if (CheckRedeclarationModuleOwnership(New, Old)) 3290 return true; 3291 3292 if (!getLangOpts().CPlusPlus) { 3293 bool OldOvl = Old->hasAttr<OverloadableAttr>(); 3294 if (OldOvl != New->hasAttr<OverloadableAttr>() && !Old->isImplicit()) { 3295 Diag(New->getLocation(), diag::err_attribute_overloadable_mismatch) 3296 << New << OldOvl; 3297 3298 // Try our best to find a decl that actually has the overloadable 3299 // attribute for the note. In most cases (e.g. programs with only one 3300 // broken declaration/definition), this won't matter. 3301 // 3302 // FIXME: We could do this if we juggled some extra state in 3303 // OverloadableAttr, rather than just removing it. 3304 const Decl *DiagOld = Old; 3305 if (OldOvl) { 3306 auto OldIter = llvm::find_if(Old->redecls(), [](const Decl *D) { 3307 const auto *A = D->getAttr<OverloadableAttr>(); 3308 return A && !A->isImplicit(); 3309 }); 3310 // If we've implicitly added *all* of the overloadable attrs to this 3311 // chain, emitting a "previous redecl" note is pointless. 3312 DiagOld = OldIter == Old->redecls_end() ? nullptr : *OldIter; 3313 } 3314 3315 if (DiagOld) 3316 Diag(DiagOld->getLocation(), 3317 diag::note_attribute_overloadable_prev_overload) 3318 << OldOvl; 3319 3320 if (OldOvl) 3321 New->addAttr(OverloadableAttr::CreateImplicit(Context)); 3322 else 3323 New->dropAttr<OverloadableAttr>(); 3324 } 3325 } 3326 3327 // If a function is first declared with a calling convention, but is later 3328 // declared or defined without one, all following decls assume the calling 3329 // convention of the first. 3330 // 3331 // It's OK if a function is first declared without a calling convention, 3332 // but is later declared or defined with the default calling convention. 3333 // 3334 // To test if either decl has an explicit calling convention, we look for 3335 // AttributedType sugar nodes on the type as written. If they are missing or 3336 // were canonicalized away, we assume the calling convention was implicit. 3337 // 3338 // Note also that we DO NOT return at this point, because we still have 3339 // other tests to run. 3340 QualType OldQType = Context.getCanonicalType(Old->getType()); 3341 QualType NewQType = Context.getCanonicalType(New->getType()); 3342 const FunctionType *OldType = cast<FunctionType>(OldQType); 3343 const FunctionType *NewType = cast<FunctionType>(NewQType); 3344 FunctionType::ExtInfo OldTypeInfo = OldType->getExtInfo(); 3345 FunctionType::ExtInfo NewTypeInfo = NewType->getExtInfo(); 3346 bool RequiresAdjustment = false; 3347 3348 if (OldTypeInfo.getCC() != NewTypeInfo.getCC()) { 3349 FunctionDecl *First = Old->getFirstDecl(); 3350 const FunctionType *FT = 3351 First->getType().getCanonicalType()->castAs<FunctionType>(); 3352 FunctionType::ExtInfo FI = FT->getExtInfo(); 3353 bool NewCCExplicit = getCallingConvAttributedType(New->getType()); 3354 if (!NewCCExplicit) { 3355 // Inherit the CC from the previous declaration if it was specified 3356 // there but not here. 3357 NewTypeInfo = NewTypeInfo.withCallingConv(OldTypeInfo.getCC()); 3358 RequiresAdjustment = true; 3359 } else if (Old->getBuiltinID()) { 3360 // Builtin attribute isn't propagated to the new one yet at this point, 3361 // so we check if the old one is a builtin. 3362 3363 // Calling Conventions on a Builtin aren't really useful and setting a 3364 // default calling convention and cdecl'ing some builtin redeclarations is 3365 // common, so warn and ignore the calling convention on the redeclaration. 3366 Diag(New->getLocation(), diag::warn_cconv_unsupported) 3367 << FunctionType::getNameForCallConv(NewTypeInfo.getCC()) 3368 << (int)CallingConventionIgnoredReason::BuiltinFunction; 3369 NewTypeInfo = NewTypeInfo.withCallingConv(OldTypeInfo.getCC()); 3370 RequiresAdjustment = true; 3371 } else { 3372 // Calling conventions aren't compatible, so complain. 3373 bool FirstCCExplicit = getCallingConvAttributedType(First->getType()); 3374 Diag(New->getLocation(), diag::err_cconv_change) 3375 << FunctionType::getNameForCallConv(NewTypeInfo.getCC()) 3376 << !FirstCCExplicit 3377 << (!FirstCCExplicit ? "" : 3378 FunctionType::getNameForCallConv(FI.getCC())); 3379 3380 // Put the note on the first decl, since it is the one that matters. 3381 Diag(First->getLocation(), diag::note_previous_declaration); 3382 return true; 3383 } 3384 } 3385 3386 // FIXME: diagnose the other way around? 3387 if (OldTypeInfo.getNoReturn() && !NewTypeInfo.getNoReturn()) { 3388 NewTypeInfo = NewTypeInfo.withNoReturn(true); 3389 RequiresAdjustment = true; 3390 } 3391 3392 // Merge regparm attribute. 3393 if (OldTypeInfo.getHasRegParm() != NewTypeInfo.getHasRegParm() || 3394 OldTypeInfo.getRegParm() != NewTypeInfo.getRegParm()) { 3395 if (NewTypeInfo.getHasRegParm()) { 3396 Diag(New->getLocation(), diag::err_regparm_mismatch) 3397 << NewType->getRegParmType() 3398 << OldType->getRegParmType(); 3399 Diag(OldLocation, diag::note_previous_declaration); 3400 return true; 3401 } 3402 3403 NewTypeInfo = NewTypeInfo.withRegParm(OldTypeInfo.getRegParm()); 3404 RequiresAdjustment = true; 3405 } 3406 3407 // Merge ns_returns_retained attribute. 3408 if (OldTypeInfo.getProducesResult() != NewTypeInfo.getProducesResult()) { 3409 if (NewTypeInfo.getProducesResult()) { 3410 Diag(New->getLocation(), diag::err_function_attribute_mismatch) 3411 << "'ns_returns_retained'"; 3412 Diag(OldLocation, diag::note_previous_declaration); 3413 return true; 3414 } 3415 3416 NewTypeInfo = NewTypeInfo.withProducesResult(true); 3417 RequiresAdjustment = true; 3418 } 3419 3420 if (OldTypeInfo.getNoCallerSavedRegs() != 3421 NewTypeInfo.getNoCallerSavedRegs()) { 3422 if (NewTypeInfo.getNoCallerSavedRegs()) { 3423 AnyX86NoCallerSavedRegistersAttr *Attr = 3424 New->getAttr<AnyX86NoCallerSavedRegistersAttr>(); 3425 Diag(New->getLocation(), diag::err_function_attribute_mismatch) << Attr; 3426 Diag(OldLocation, diag::note_previous_declaration); 3427 return true; 3428 } 3429 3430 NewTypeInfo = NewTypeInfo.withNoCallerSavedRegs(true); 3431 RequiresAdjustment = true; 3432 } 3433 3434 if (RequiresAdjustment) { 3435 const FunctionType *AdjustedType = New->getType()->getAs<FunctionType>(); 3436 AdjustedType = Context.adjustFunctionType(AdjustedType, NewTypeInfo); 3437 New->setType(QualType(AdjustedType, 0)); 3438 NewQType = Context.getCanonicalType(New->getType()); 3439 } 3440 3441 // If this redeclaration makes the function inline, we may need to add it to 3442 // UndefinedButUsed. 3443 if (!Old->isInlined() && New->isInlined() && 3444 !New->hasAttr<GNUInlineAttr>() && 3445 !getLangOpts().GNUInline && 3446 Old->isUsed(false) && 3447 !Old->isDefined() && !New->isThisDeclarationADefinition()) 3448 UndefinedButUsed.insert(std::make_pair(Old->getCanonicalDecl(), 3449 SourceLocation())); 3450 3451 // If this redeclaration makes it newly gnu_inline, we don't want to warn 3452 // about it. 3453 if (New->hasAttr<GNUInlineAttr>() && 3454 Old->isInlined() && !Old->hasAttr<GNUInlineAttr>()) { 3455 UndefinedButUsed.erase(Old->getCanonicalDecl()); 3456 } 3457 3458 // If pass_object_size params don't match up perfectly, this isn't a valid 3459 // redeclaration. 3460 if (Old->getNumParams() > 0 && Old->getNumParams() == New->getNumParams() && 3461 !hasIdenticalPassObjectSizeAttrs(Old, New)) { 3462 Diag(New->getLocation(), diag::err_different_pass_object_size_params) 3463 << New->getDeclName(); 3464 Diag(OldLocation, PrevDiag) << Old << Old->getType(); 3465 return true; 3466 } 3467 3468 if (getLangOpts().CPlusPlus) { 3469 // C++1z [over.load]p2 3470 // Certain function declarations cannot be overloaded: 3471 // -- Function declarations that differ only in the return type, 3472 // the exception specification, or both cannot be overloaded. 3473 3474 // Check the exception specifications match. This may recompute the type of 3475 // both Old and New if it resolved exception specifications, so grab the 3476 // types again after this. Because this updates the type, we do this before 3477 // any of the other checks below, which may update the "de facto" NewQType 3478 // but do not necessarily update the type of New. 3479 if (CheckEquivalentExceptionSpec(Old, New)) 3480 return true; 3481 OldQType = Context.getCanonicalType(Old->getType()); 3482 NewQType = Context.getCanonicalType(New->getType()); 3483 3484 // Go back to the type source info to compare the declared return types, 3485 // per C++1y [dcl.type.auto]p13: 3486 // Redeclarations or specializations of a function or function template 3487 // with a declared return type that uses a placeholder type shall also 3488 // use that placeholder, not a deduced type. 3489 QualType OldDeclaredReturnType = Old->getDeclaredReturnType(); 3490 QualType NewDeclaredReturnType = New->getDeclaredReturnType(); 3491 if (!Context.hasSameType(OldDeclaredReturnType, NewDeclaredReturnType) && 3492 canFullyTypeCheckRedeclaration(New, Old, NewDeclaredReturnType, 3493 OldDeclaredReturnType)) { 3494 QualType ResQT; 3495 if (NewDeclaredReturnType->isObjCObjectPointerType() && 3496 OldDeclaredReturnType->isObjCObjectPointerType()) 3497 // FIXME: This does the wrong thing for a deduced return type. 3498 ResQT = Context.mergeObjCGCQualifiers(NewQType, OldQType); 3499 if (ResQT.isNull()) { 3500 if (New->isCXXClassMember() && New->isOutOfLine()) 3501 Diag(New->getLocation(), diag::err_member_def_does_not_match_ret_type) 3502 << New << New->getReturnTypeSourceRange(); 3503 else 3504 Diag(New->getLocation(), diag::err_ovl_diff_return_type) 3505 << New->getReturnTypeSourceRange(); 3506 Diag(OldLocation, PrevDiag) << Old << Old->getType() 3507 << Old->getReturnTypeSourceRange(); 3508 return true; 3509 } 3510 else 3511 NewQType = ResQT; 3512 } 3513 3514 QualType OldReturnType = OldType->getReturnType(); 3515 QualType NewReturnType = cast<FunctionType>(NewQType)->getReturnType(); 3516 if (OldReturnType != NewReturnType) { 3517 // If this function has a deduced return type and has already been 3518 // defined, copy the deduced value from the old declaration. 3519 AutoType *OldAT = Old->getReturnType()->getContainedAutoType(); 3520 if (OldAT && OldAT->isDeduced()) { 3521 New->setType( 3522 SubstAutoType(New->getType(), 3523 OldAT->isDependentType() ? Context.DependentTy 3524 : OldAT->getDeducedType())); 3525 NewQType = Context.getCanonicalType( 3526 SubstAutoType(NewQType, 3527 OldAT->isDependentType() ? Context.DependentTy 3528 : OldAT->getDeducedType())); 3529 } 3530 } 3531 3532 const CXXMethodDecl *OldMethod = dyn_cast<CXXMethodDecl>(Old); 3533 CXXMethodDecl *NewMethod = dyn_cast<CXXMethodDecl>(New); 3534 if (OldMethod && NewMethod) { 3535 // Preserve triviality. 3536 NewMethod->setTrivial(OldMethod->isTrivial()); 3537 3538 // MSVC allows explicit template specialization at class scope: 3539 // 2 CXXMethodDecls referring to the same function will be injected. 3540 // We don't want a redeclaration error. 3541 bool IsClassScopeExplicitSpecialization = 3542 OldMethod->isFunctionTemplateSpecialization() && 3543 NewMethod->isFunctionTemplateSpecialization(); 3544 bool isFriend = NewMethod->getFriendObjectKind(); 3545 3546 if (!isFriend && NewMethod->getLexicalDeclContext()->isRecord() && 3547 !IsClassScopeExplicitSpecialization) { 3548 // -- Member function declarations with the same name and the 3549 // same parameter types cannot be overloaded if any of them 3550 // is a static member function declaration. 3551 if (OldMethod->isStatic() != NewMethod->isStatic()) { 3552 Diag(New->getLocation(), diag::err_ovl_static_nonstatic_member); 3553 Diag(OldLocation, PrevDiag) << Old << Old->getType(); 3554 return true; 3555 } 3556 3557 // C++ [class.mem]p1: 3558 // [...] A member shall not be declared twice in the 3559 // member-specification, except that a nested class or member 3560 // class template can be declared and then later defined. 3561 if (!inTemplateInstantiation()) { 3562 unsigned NewDiag; 3563 if (isa<CXXConstructorDecl>(OldMethod)) 3564 NewDiag = diag::err_constructor_redeclared; 3565 else if (isa<CXXDestructorDecl>(NewMethod)) 3566 NewDiag = diag::err_destructor_redeclared; 3567 else if (isa<CXXConversionDecl>(NewMethod)) 3568 NewDiag = diag::err_conv_function_redeclared; 3569 else 3570 NewDiag = diag::err_member_redeclared; 3571 3572 Diag(New->getLocation(), NewDiag); 3573 } else { 3574 Diag(New->getLocation(), diag::err_member_redeclared_in_instantiation) 3575 << New << New->getType(); 3576 } 3577 Diag(OldLocation, PrevDiag) << Old << Old->getType(); 3578 return true; 3579 3580 // Complain if this is an explicit declaration of a special 3581 // member that was initially declared implicitly. 3582 // 3583 // As an exception, it's okay to befriend such methods in order 3584 // to permit the implicit constructor/destructor/operator calls. 3585 } else if (OldMethod->isImplicit()) { 3586 if (isFriend) { 3587 NewMethod->setImplicit(); 3588 } else { 3589 Diag(NewMethod->getLocation(), 3590 diag::err_definition_of_implicitly_declared_member) 3591 << New << getSpecialMember(OldMethod); 3592 return true; 3593 } 3594 } else if (OldMethod->getFirstDecl()->isExplicitlyDefaulted() && !isFriend) { 3595 Diag(NewMethod->getLocation(), 3596 diag::err_definition_of_explicitly_defaulted_member) 3597 << getSpecialMember(OldMethod); 3598 return true; 3599 } 3600 } 3601 3602 // C++11 [dcl.attr.noreturn]p1: 3603 // The first declaration of a function shall specify the noreturn 3604 // attribute if any declaration of that function specifies the noreturn 3605 // attribute. 3606 const CXX11NoReturnAttr *NRA = New->getAttr<CXX11NoReturnAttr>(); 3607 if (NRA && !Old->hasAttr<CXX11NoReturnAttr>()) { 3608 Diag(NRA->getLocation(), diag::err_noreturn_missing_on_first_decl); 3609 Diag(Old->getFirstDecl()->getLocation(), 3610 diag::note_noreturn_missing_first_decl); 3611 } 3612 3613 // C++11 [dcl.attr.depend]p2: 3614 // The first declaration of a function shall specify the 3615 // carries_dependency attribute for its declarator-id if any declaration 3616 // of the function specifies the carries_dependency attribute. 3617 const CarriesDependencyAttr *CDA = New->getAttr<CarriesDependencyAttr>(); 3618 if (CDA && !Old->hasAttr<CarriesDependencyAttr>()) { 3619 Diag(CDA->getLocation(), 3620 diag::err_carries_dependency_missing_on_first_decl) << 0/*Function*/; 3621 Diag(Old->getFirstDecl()->getLocation(), 3622 diag::note_carries_dependency_missing_first_decl) << 0/*Function*/; 3623 } 3624 3625 // (C++98 8.3.5p3): 3626 // All declarations for a function shall agree exactly in both the 3627 // return type and the parameter-type-list. 3628 // We also want to respect all the extended bits except noreturn. 3629 3630 // noreturn should now match unless the old type info didn't have it. 3631 QualType OldQTypeForComparison = OldQType; 3632 if (!OldTypeInfo.getNoReturn() && NewTypeInfo.getNoReturn()) { 3633 auto *OldType = OldQType->castAs<FunctionProtoType>(); 3634 const FunctionType *OldTypeForComparison 3635 = Context.adjustFunctionType(OldType, OldTypeInfo.withNoReturn(true)); 3636 OldQTypeForComparison = QualType(OldTypeForComparison, 0); 3637 assert(OldQTypeForComparison.isCanonical()); 3638 } 3639 3640 if (haveIncompatibleLanguageLinkages(Old, New)) { 3641 // As a special case, retain the language linkage from previous 3642 // declarations of a friend function as an extension. 3643 // 3644 // This liberal interpretation of C++ [class.friend]p3 matches GCC/MSVC 3645 // and is useful because there's otherwise no way to specify language 3646 // linkage within class scope. 3647 // 3648 // Check cautiously as the friend object kind isn't yet complete. 3649 if (New->getFriendObjectKind() != Decl::FOK_None) { 3650 Diag(New->getLocation(), diag::ext_retained_language_linkage) << New; 3651 Diag(OldLocation, PrevDiag); 3652 } else { 3653 Diag(New->getLocation(), diag::err_different_language_linkage) << New; 3654 Diag(OldLocation, PrevDiag); 3655 return true; 3656 } 3657 } 3658 3659 // If the function types are compatible, merge the declarations. Ignore the 3660 // exception specifier because it was already checked above in 3661 // CheckEquivalentExceptionSpec, and we don't want follow-on diagnostics 3662 // about incompatible types under -fms-compatibility. 3663 if (Context.hasSameFunctionTypeIgnoringExceptionSpec(OldQTypeForComparison, 3664 NewQType)) 3665 return MergeCompatibleFunctionDecls(New, Old, S, MergeTypeWithOld); 3666 3667 // If the types are imprecise (due to dependent constructs in friends or 3668 // local extern declarations), it's OK if they differ. We'll check again 3669 // during instantiation. 3670 if (!canFullyTypeCheckRedeclaration(New, Old, NewQType, OldQType)) 3671 return false; 3672 3673 // Fall through for conflicting redeclarations and redefinitions. 3674 } 3675 3676 // C: Function types need to be compatible, not identical. This handles 3677 // duplicate function decls like "void f(int); void f(enum X);" properly. 3678 if (!getLangOpts().CPlusPlus && 3679 Context.typesAreCompatible(OldQType, NewQType)) { 3680 const FunctionType *OldFuncType = OldQType->getAs<FunctionType>(); 3681 const FunctionType *NewFuncType = NewQType->getAs<FunctionType>(); 3682 const FunctionProtoType *OldProto = nullptr; 3683 if (MergeTypeWithOld && isa<FunctionNoProtoType>(NewFuncType) && 3684 (OldProto = dyn_cast<FunctionProtoType>(OldFuncType))) { 3685 // The old declaration provided a function prototype, but the 3686 // new declaration does not. Merge in the prototype. 3687 assert(!OldProto->hasExceptionSpec() && "Exception spec in C"); 3688 SmallVector<QualType, 16> ParamTypes(OldProto->param_types()); 3689 NewQType = 3690 Context.getFunctionType(NewFuncType->getReturnType(), ParamTypes, 3691 OldProto->getExtProtoInfo()); 3692 New->setType(NewQType); 3693 New->setHasInheritedPrototype(); 3694 3695 // Synthesize parameters with the same types. 3696 SmallVector<ParmVarDecl*, 16> Params; 3697 for (const auto &ParamType : OldProto->param_types()) { 3698 ParmVarDecl *Param = ParmVarDecl::Create(Context, New, SourceLocation(), 3699 SourceLocation(), nullptr, 3700 ParamType, /*TInfo=*/nullptr, 3701 SC_None, nullptr); 3702 Param->setScopeInfo(0, Params.size()); 3703 Param->setImplicit(); 3704 Params.push_back(Param); 3705 } 3706 3707 New->setParams(Params); 3708 } 3709 3710 return MergeCompatibleFunctionDecls(New, Old, S, MergeTypeWithOld); 3711 } 3712 3713 // Check if the function types are compatible when pointer size address 3714 // spaces are ignored. 3715 if (Context.hasSameFunctionTypeIgnoringPtrSizes(OldQType, NewQType)) 3716 return false; 3717 3718 // GNU C permits a K&R definition to follow a prototype declaration 3719 // if the declared types of the parameters in the K&R definition 3720 // match the types in the prototype declaration, even when the 3721 // promoted types of the parameters from the K&R definition differ 3722 // from the types in the prototype. GCC then keeps the types from 3723 // the prototype. 3724 // 3725 // If a variadic prototype is followed by a non-variadic K&R definition, 3726 // the K&R definition becomes variadic. This is sort of an edge case, but 3727 // it's legal per the standard depending on how you read C99 6.7.5.3p15 and 3728 // C99 6.9.1p8. 3729 if (!getLangOpts().CPlusPlus && 3730 Old->hasPrototype() && !New->hasPrototype() && 3731 New->getType()->getAs<FunctionProtoType>() && 3732 Old->getNumParams() == New->getNumParams()) { 3733 SmallVector<QualType, 16> ArgTypes; 3734 SmallVector<GNUCompatibleParamWarning, 16> Warnings; 3735 const FunctionProtoType *OldProto 3736 = Old->getType()->getAs<FunctionProtoType>(); 3737 const FunctionProtoType *NewProto 3738 = New->getType()->getAs<FunctionProtoType>(); 3739 3740 // Determine whether this is the GNU C extension. 3741 QualType MergedReturn = Context.mergeTypes(OldProto->getReturnType(), 3742 NewProto->getReturnType()); 3743 bool LooseCompatible = !MergedReturn.isNull(); 3744 for (unsigned Idx = 0, End = Old->getNumParams(); 3745 LooseCompatible && Idx != End; ++Idx) { 3746 ParmVarDecl *OldParm = Old->getParamDecl(Idx); 3747 ParmVarDecl *NewParm = New->getParamDecl(Idx); 3748 if (Context.typesAreCompatible(OldParm->getType(), 3749 NewProto->getParamType(Idx))) { 3750 ArgTypes.push_back(NewParm->getType()); 3751 } else if (Context.typesAreCompatible(OldParm->getType(), 3752 NewParm->getType(), 3753 /*CompareUnqualified=*/true)) { 3754 GNUCompatibleParamWarning Warn = { OldParm, NewParm, 3755 NewProto->getParamType(Idx) }; 3756 Warnings.push_back(Warn); 3757 ArgTypes.push_back(NewParm->getType()); 3758 } else 3759 LooseCompatible = false; 3760 } 3761 3762 if (LooseCompatible) { 3763 for (unsigned Warn = 0; Warn < Warnings.size(); ++Warn) { 3764 Diag(Warnings[Warn].NewParm->getLocation(), 3765 diag::ext_param_promoted_not_compatible_with_prototype) 3766 << Warnings[Warn].PromotedType 3767 << Warnings[Warn].OldParm->getType(); 3768 if (Warnings[Warn].OldParm->getLocation().isValid()) 3769 Diag(Warnings[Warn].OldParm->getLocation(), 3770 diag::note_previous_declaration); 3771 } 3772 3773 if (MergeTypeWithOld) 3774 New->setType(Context.getFunctionType(MergedReturn, ArgTypes, 3775 OldProto->getExtProtoInfo())); 3776 return MergeCompatibleFunctionDecls(New, Old, S, MergeTypeWithOld); 3777 } 3778 3779 // Fall through to diagnose conflicting types. 3780 } 3781 3782 // A function that has already been declared has been redeclared or 3783 // defined with a different type; show an appropriate diagnostic. 3784 3785 // If the previous declaration was an implicitly-generated builtin 3786 // declaration, then at the very least we should use a specialized note. 3787 unsigned BuiltinID; 3788 if (Old->isImplicit() && (BuiltinID = Old->getBuiltinID())) { 3789 // If it's actually a library-defined builtin function like 'malloc' 3790 // or 'printf', just warn about the incompatible redeclaration. 3791 if (Context.BuiltinInfo.isPredefinedLibFunction(BuiltinID)) { 3792 Diag(New->getLocation(), diag::warn_redecl_library_builtin) << New; 3793 Diag(OldLocation, diag::note_previous_builtin_declaration) 3794 << Old << Old->getType(); 3795 return false; 3796 } 3797 3798 PrevDiag = diag::note_previous_builtin_declaration; 3799 } 3800 3801 Diag(New->getLocation(), diag::err_conflicting_types) << New->getDeclName(); 3802 Diag(OldLocation, PrevDiag) << Old << Old->getType(); 3803 return true; 3804 } 3805 3806 /// Completes the merge of two function declarations that are 3807 /// known to be compatible. 3808 /// 3809 /// This routine handles the merging of attributes and other 3810 /// properties of function declarations from the old declaration to 3811 /// the new declaration, once we know that New is in fact a 3812 /// redeclaration of Old. 3813 /// 3814 /// \returns false 3815 bool Sema::MergeCompatibleFunctionDecls(FunctionDecl *New, FunctionDecl *Old, 3816 Scope *S, bool MergeTypeWithOld) { 3817 // Merge the attributes 3818 mergeDeclAttributes(New, Old); 3819 3820 // Merge "pure" flag. 3821 if (Old->isPure()) 3822 New->setPure(); 3823 3824 // Merge "used" flag. 3825 if (Old->getMostRecentDecl()->isUsed(false)) 3826 New->setIsUsed(); 3827 3828 // Merge attributes from the parameters. These can mismatch with K&R 3829 // declarations. 3830 if (New->getNumParams() == Old->getNumParams()) 3831 for (unsigned i = 0, e = New->getNumParams(); i != e; ++i) { 3832 ParmVarDecl *NewParam = New->getParamDecl(i); 3833 ParmVarDecl *OldParam = Old->getParamDecl(i); 3834 mergeParamDeclAttributes(NewParam, OldParam, *this); 3835 mergeParamDeclTypes(NewParam, OldParam, *this); 3836 } 3837 3838 if (getLangOpts().CPlusPlus) 3839 return MergeCXXFunctionDecl(New, Old, S); 3840 3841 // Merge the function types so the we get the composite types for the return 3842 // and argument types. Per C11 6.2.7/4, only update the type if the old decl 3843 // was visible. 3844 QualType Merged = Context.mergeTypes(Old->getType(), New->getType()); 3845 if (!Merged.isNull() && MergeTypeWithOld) 3846 New->setType(Merged); 3847 3848 return false; 3849 } 3850 3851 void Sema::mergeObjCMethodDecls(ObjCMethodDecl *newMethod, 3852 ObjCMethodDecl *oldMethod) { 3853 // Merge the attributes, including deprecated/unavailable 3854 AvailabilityMergeKind MergeKind = 3855 isa<ObjCProtocolDecl>(oldMethod->getDeclContext()) 3856 ? AMK_ProtocolImplementation 3857 : isa<ObjCImplDecl>(newMethod->getDeclContext()) ? AMK_Redeclaration 3858 : AMK_Override; 3859 3860 mergeDeclAttributes(newMethod, oldMethod, MergeKind); 3861 3862 // Merge attributes from the parameters. 3863 ObjCMethodDecl::param_const_iterator oi = oldMethod->param_begin(), 3864 oe = oldMethod->param_end(); 3865 for (ObjCMethodDecl::param_iterator 3866 ni = newMethod->param_begin(), ne = newMethod->param_end(); 3867 ni != ne && oi != oe; ++ni, ++oi) 3868 mergeParamDeclAttributes(*ni, *oi, *this); 3869 3870 CheckObjCMethodOverride(newMethod, oldMethod); 3871 } 3872 3873 static void diagnoseVarDeclTypeMismatch(Sema &S, VarDecl *New, VarDecl* Old) { 3874 assert(!S.Context.hasSameType(New->getType(), Old->getType())); 3875 3876 S.Diag(New->getLocation(), New->isThisDeclarationADefinition() 3877 ? diag::err_redefinition_different_type 3878 : diag::err_redeclaration_different_type) 3879 << New->getDeclName() << New->getType() << Old->getType(); 3880 3881 diag::kind PrevDiag; 3882 SourceLocation OldLocation; 3883 std::tie(PrevDiag, OldLocation) 3884 = getNoteDiagForInvalidRedeclaration(Old, New); 3885 S.Diag(OldLocation, PrevDiag); 3886 New->setInvalidDecl(); 3887 } 3888 3889 /// MergeVarDeclTypes - We parsed a variable 'New' which has the same name and 3890 /// scope as a previous declaration 'Old'. Figure out how to merge their types, 3891 /// emitting diagnostics as appropriate. 3892 /// 3893 /// Declarations using the auto type specifier (C++ [decl.spec.auto]) call back 3894 /// to here in AddInitializerToDecl. We can't check them before the initializer 3895 /// is attached. 3896 void Sema::MergeVarDeclTypes(VarDecl *New, VarDecl *Old, 3897 bool MergeTypeWithOld) { 3898 if (New->isInvalidDecl() || Old->isInvalidDecl()) 3899 return; 3900 3901 QualType MergedT; 3902 if (getLangOpts().CPlusPlus) { 3903 if (New->getType()->isUndeducedType()) { 3904 // We don't know what the new type is until the initializer is attached. 3905 return; 3906 } else if (Context.hasSameType(New->getType(), Old->getType())) { 3907 // These could still be something that needs exception specs checked. 3908 return MergeVarDeclExceptionSpecs(New, Old); 3909 } 3910 // C++ [basic.link]p10: 3911 // [...] the types specified by all declarations referring to a given 3912 // object or function shall be identical, except that declarations for an 3913 // array object can specify array types that differ by the presence or 3914 // absence of a major array bound (8.3.4). 3915 else if (Old->getType()->isArrayType() && New->getType()->isArrayType()) { 3916 const ArrayType *OldArray = Context.getAsArrayType(Old->getType()); 3917 const ArrayType *NewArray = Context.getAsArrayType(New->getType()); 3918 3919 // We are merging a variable declaration New into Old. If it has an array 3920 // bound, and that bound differs from Old's bound, we should diagnose the 3921 // mismatch. 3922 if (!NewArray->isIncompleteArrayType() && !NewArray->isDependentType()) { 3923 for (VarDecl *PrevVD = Old->getMostRecentDecl(); PrevVD; 3924 PrevVD = PrevVD->getPreviousDecl()) { 3925 QualType PrevVDTy = PrevVD->getType(); 3926 if (PrevVDTy->isIncompleteArrayType() || PrevVDTy->isDependentType()) 3927 continue; 3928 3929 if (!Context.hasSameType(New->getType(), PrevVDTy)) 3930 return diagnoseVarDeclTypeMismatch(*this, New, PrevVD); 3931 } 3932 } 3933 3934 if (OldArray->isIncompleteArrayType() && NewArray->isArrayType()) { 3935 if (Context.hasSameType(OldArray->getElementType(), 3936 NewArray->getElementType())) 3937 MergedT = New->getType(); 3938 } 3939 // FIXME: Check visibility. New is hidden but has a complete type. If New 3940 // has no array bound, it should not inherit one from Old, if Old is not 3941 // visible. 3942 else if (OldArray->isArrayType() && NewArray->isIncompleteArrayType()) { 3943 if (Context.hasSameType(OldArray->getElementType(), 3944 NewArray->getElementType())) 3945 MergedT = Old->getType(); 3946 } 3947 } 3948 else if (New->getType()->isObjCObjectPointerType() && 3949 Old->getType()->isObjCObjectPointerType()) { 3950 MergedT = Context.mergeObjCGCQualifiers(New->getType(), 3951 Old->getType()); 3952 } 3953 } else { 3954 // C 6.2.7p2: 3955 // All declarations that refer to the same object or function shall have 3956 // compatible type. 3957 MergedT = Context.mergeTypes(New->getType(), Old->getType()); 3958 } 3959 if (MergedT.isNull()) { 3960 // It's OK if we couldn't merge types if either type is dependent, for a 3961 // block-scope variable. In other cases (static data members of class 3962 // templates, variable templates, ...), we require the types to be 3963 // equivalent. 3964 // FIXME: The C++ standard doesn't say anything about this. 3965 if ((New->getType()->isDependentType() || 3966 Old->getType()->isDependentType()) && New->isLocalVarDecl()) { 3967 // If the old type was dependent, we can't merge with it, so the new type 3968 // becomes dependent for now. We'll reproduce the original type when we 3969 // instantiate the TypeSourceInfo for the variable. 3970 if (!New->getType()->isDependentType() && MergeTypeWithOld) 3971 New->setType(Context.DependentTy); 3972 return; 3973 } 3974 return diagnoseVarDeclTypeMismatch(*this, New, Old); 3975 } 3976 3977 // Don't actually update the type on the new declaration if the old 3978 // declaration was an extern declaration in a different scope. 3979 if (MergeTypeWithOld) 3980 New->setType(MergedT); 3981 } 3982 3983 static bool mergeTypeWithPrevious(Sema &S, VarDecl *NewVD, VarDecl *OldVD, 3984 LookupResult &Previous) { 3985 // C11 6.2.7p4: 3986 // For an identifier with internal or external linkage declared 3987 // in a scope in which a prior declaration of that identifier is 3988 // visible, if the prior declaration specifies internal or 3989 // external linkage, the type of the identifier at the later 3990 // declaration becomes the composite type. 3991 // 3992 // If the variable isn't visible, we do not merge with its type. 3993 if (Previous.isShadowed()) 3994 return false; 3995 3996 if (S.getLangOpts().CPlusPlus) { 3997 // C++11 [dcl.array]p3: 3998 // If there is a preceding declaration of the entity in the same 3999 // scope in which the bound was specified, an omitted array bound 4000 // is taken to be the same as in that earlier declaration. 4001 return NewVD->isPreviousDeclInSameBlockScope() || 4002 (!OldVD->getLexicalDeclContext()->isFunctionOrMethod() && 4003 !NewVD->getLexicalDeclContext()->isFunctionOrMethod()); 4004 } else { 4005 // If the old declaration was function-local, don't merge with its 4006 // type unless we're in the same function. 4007 return !OldVD->getLexicalDeclContext()->isFunctionOrMethod() || 4008 OldVD->getLexicalDeclContext() == NewVD->getLexicalDeclContext(); 4009 } 4010 } 4011 4012 /// MergeVarDecl - We just parsed a variable 'New' which has the same name 4013 /// and scope as a previous declaration 'Old'. Figure out how to resolve this 4014 /// situation, merging decls or emitting diagnostics as appropriate. 4015 /// 4016 /// Tentative definition rules (C99 6.9.2p2) are checked by 4017 /// FinalizeDeclaratorGroup. Unfortunately, we can't analyze tentative 4018 /// definitions here, since the initializer hasn't been attached. 4019 /// 4020 void Sema::MergeVarDecl(VarDecl *New, LookupResult &Previous) { 4021 // If the new decl is already invalid, don't do any other checking. 4022 if (New->isInvalidDecl()) 4023 return; 4024 4025 if (!shouldLinkPossiblyHiddenDecl(Previous, New)) 4026 return; 4027 4028 VarTemplateDecl *NewTemplate = New->getDescribedVarTemplate(); 4029 4030 // Verify the old decl was also a variable or variable template. 4031 VarDecl *Old = nullptr; 4032 VarTemplateDecl *OldTemplate = nullptr; 4033 if (Previous.isSingleResult()) { 4034 if (NewTemplate) { 4035 OldTemplate = dyn_cast<VarTemplateDecl>(Previous.getFoundDecl()); 4036 Old = OldTemplate ? OldTemplate->getTemplatedDecl() : nullptr; 4037 4038 if (auto *Shadow = 4039 dyn_cast<UsingShadowDecl>(Previous.getRepresentativeDecl())) 4040 if (checkUsingShadowRedecl<VarTemplateDecl>(*this, Shadow, NewTemplate)) 4041 return New->setInvalidDecl(); 4042 } else { 4043 Old = dyn_cast<VarDecl>(Previous.getFoundDecl()); 4044 4045 if (auto *Shadow = 4046 dyn_cast<UsingShadowDecl>(Previous.getRepresentativeDecl())) 4047 if (checkUsingShadowRedecl<VarDecl>(*this, Shadow, New)) 4048 return New->setInvalidDecl(); 4049 } 4050 } 4051 if (!Old) { 4052 Diag(New->getLocation(), diag::err_redefinition_different_kind) 4053 << New->getDeclName(); 4054 notePreviousDefinition(Previous.getRepresentativeDecl(), 4055 New->getLocation()); 4056 return New->setInvalidDecl(); 4057 } 4058 4059 // If the old declaration was found in an inline namespace and the new 4060 // declaration was qualified, update the DeclContext to match. 4061 adjustDeclContextForDeclaratorDecl(New, Old); 4062 4063 // Ensure the template parameters are compatible. 4064 if (NewTemplate && 4065 !TemplateParameterListsAreEqual(NewTemplate->getTemplateParameters(), 4066 OldTemplate->getTemplateParameters(), 4067 /*Complain=*/true, TPL_TemplateMatch)) 4068 return New->setInvalidDecl(); 4069 4070 // C++ [class.mem]p1: 4071 // A member shall not be declared twice in the member-specification [...] 4072 // 4073 // Here, we need only consider static data members. 4074 if (Old->isStaticDataMember() && !New->isOutOfLine()) { 4075 Diag(New->getLocation(), diag::err_duplicate_member) 4076 << New->getIdentifier(); 4077 Diag(Old->getLocation(), diag::note_previous_declaration); 4078 New->setInvalidDecl(); 4079 } 4080 4081 mergeDeclAttributes(New, Old); 4082 // Warn if an already-declared variable is made a weak_import in a subsequent 4083 // declaration 4084 if (New->hasAttr<WeakImportAttr>() && 4085 Old->getStorageClass() == SC_None && 4086 !Old->hasAttr<WeakImportAttr>()) { 4087 Diag(New->getLocation(), diag::warn_weak_import) << New->getDeclName(); 4088 notePreviousDefinition(Old, New->getLocation()); 4089 // Remove weak_import attribute on new declaration. 4090 New->dropAttr<WeakImportAttr>(); 4091 } 4092 4093 if (New->hasAttr<InternalLinkageAttr>() && 4094 !Old->hasAttr<InternalLinkageAttr>()) { 4095 Diag(New->getLocation(), diag::err_internal_linkage_redeclaration) 4096 << New->getDeclName(); 4097 notePreviousDefinition(Old, New->getLocation()); 4098 New->dropAttr<InternalLinkageAttr>(); 4099 } 4100 4101 // Merge the types. 4102 VarDecl *MostRecent = Old->getMostRecentDecl(); 4103 if (MostRecent != Old) { 4104 MergeVarDeclTypes(New, MostRecent, 4105 mergeTypeWithPrevious(*this, New, MostRecent, Previous)); 4106 if (New->isInvalidDecl()) 4107 return; 4108 } 4109 4110 MergeVarDeclTypes(New, Old, mergeTypeWithPrevious(*this, New, Old, Previous)); 4111 if (New->isInvalidDecl()) 4112 return; 4113 4114 diag::kind PrevDiag; 4115 SourceLocation OldLocation; 4116 std::tie(PrevDiag, OldLocation) = 4117 getNoteDiagForInvalidRedeclaration(Old, New); 4118 4119 // [dcl.stc]p8: Check if we have a non-static decl followed by a static. 4120 if (New->getStorageClass() == SC_Static && 4121 !New->isStaticDataMember() && 4122 Old->hasExternalFormalLinkage()) { 4123 if (getLangOpts().MicrosoftExt) { 4124 Diag(New->getLocation(), diag::ext_static_non_static) 4125 << New->getDeclName(); 4126 Diag(OldLocation, PrevDiag); 4127 } else { 4128 Diag(New->getLocation(), diag::err_static_non_static) 4129 << New->getDeclName(); 4130 Diag(OldLocation, PrevDiag); 4131 return New->setInvalidDecl(); 4132 } 4133 } 4134 // C99 6.2.2p4: 4135 // For an identifier declared with the storage-class specifier 4136 // extern in a scope in which a prior declaration of that 4137 // identifier is visible,23) if the prior declaration specifies 4138 // internal or external linkage, the linkage of the identifier at 4139 // the later declaration is the same as the linkage specified at 4140 // the prior declaration. If no prior declaration is visible, or 4141 // if the prior declaration specifies no linkage, then the 4142 // identifier has external linkage. 4143 if (New->hasExternalStorage() && Old->hasLinkage()) 4144 /* Okay */; 4145 else if (New->getCanonicalDecl()->getStorageClass() != SC_Static && 4146 !New->isStaticDataMember() && 4147 Old->getCanonicalDecl()->getStorageClass() == SC_Static) { 4148 Diag(New->getLocation(), diag::err_non_static_static) << New->getDeclName(); 4149 Diag(OldLocation, PrevDiag); 4150 return New->setInvalidDecl(); 4151 } 4152 4153 // Check if extern is followed by non-extern and vice-versa. 4154 if (New->hasExternalStorage() && 4155 !Old->hasLinkage() && Old->isLocalVarDeclOrParm()) { 4156 Diag(New->getLocation(), diag::err_extern_non_extern) << New->getDeclName(); 4157 Diag(OldLocation, PrevDiag); 4158 return New->setInvalidDecl(); 4159 } 4160 if (Old->hasLinkage() && New->isLocalVarDeclOrParm() && 4161 !New->hasExternalStorage()) { 4162 Diag(New->getLocation(), diag::err_non_extern_extern) << New->getDeclName(); 4163 Diag(OldLocation, PrevDiag); 4164 return New->setInvalidDecl(); 4165 } 4166 4167 if (CheckRedeclarationModuleOwnership(New, Old)) 4168 return; 4169 4170 // Variables with external linkage are analyzed in FinalizeDeclaratorGroup. 4171 4172 // FIXME: The test for external storage here seems wrong? We still 4173 // need to check for mismatches. 4174 if (!New->hasExternalStorage() && !New->isFileVarDecl() && 4175 // Don't complain about out-of-line definitions of static members. 4176 !(Old->getLexicalDeclContext()->isRecord() && 4177 !New->getLexicalDeclContext()->isRecord())) { 4178 Diag(New->getLocation(), diag::err_redefinition) << New->getDeclName(); 4179 Diag(OldLocation, PrevDiag); 4180 return New->setInvalidDecl(); 4181 } 4182 4183 if (New->isInline() && !Old->getMostRecentDecl()->isInline()) { 4184 if (VarDecl *Def = Old->getDefinition()) { 4185 // C++1z [dcl.fcn.spec]p4: 4186 // If the definition of a variable appears in a translation unit before 4187 // its first declaration as inline, the program is ill-formed. 4188 Diag(New->getLocation(), diag::err_inline_decl_follows_def) << New; 4189 Diag(Def->getLocation(), diag::note_previous_definition); 4190 } 4191 } 4192 4193 // If this redeclaration makes the variable inline, we may need to add it to 4194 // UndefinedButUsed. 4195 if (!Old->isInline() && New->isInline() && Old->isUsed(false) && 4196 !Old->getDefinition() && !New->isThisDeclarationADefinition()) 4197 UndefinedButUsed.insert(std::make_pair(Old->getCanonicalDecl(), 4198 SourceLocation())); 4199 4200 if (New->getTLSKind() != Old->getTLSKind()) { 4201 if (!Old->getTLSKind()) { 4202 Diag(New->getLocation(), diag::err_thread_non_thread) << New->getDeclName(); 4203 Diag(OldLocation, PrevDiag); 4204 } else if (!New->getTLSKind()) { 4205 Diag(New->getLocation(), diag::err_non_thread_thread) << New->getDeclName(); 4206 Diag(OldLocation, PrevDiag); 4207 } else { 4208 // Do not allow redeclaration to change the variable between requiring 4209 // static and dynamic initialization. 4210 // FIXME: GCC allows this, but uses the TLS keyword on the first 4211 // declaration to determine the kind. Do we need to be compatible here? 4212 Diag(New->getLocation(), diag::err_thread_thread_different_kind) 4213 << New->getDeclName() << (New->getTLSKind() == VarDecl::TLS_Dynamic); 4214 Diag(OldLocation, PrevDiag); 4215 } 4216 } 4217 4218 // C++ doesn't have tentative definitions, so go right ahead and check here. 4219 if (getLangOpts().CPlusPlus && 4220 New->isThisDeclarationADefinition() == VarDecl::Definition) { 4221 if (Old->isStaticDataMember() && Old->getCanonicalDecl()->isInline() && 4222 Old->getCanonicalDecl()->isConstexpr()) { 4223 // This definition won't be a definition any more once it's been merged. 4224 Diag(New->getLocation(), 4225 diag::warn_deprecated_redundant_constexpr_static_def); 4226 } else if (VarDecl *Def = Old->getDefinition()) { 4227 if (checkVarDeclRedefinition(Def, New)) 4228 return; 4229 } 4230 } 4231 4232 if (haveIncompatibleLanguageLinkages(Old, New)) { 4233 Diag(New->getLocation(), diag::err_different_language_linkage) << New; 4234 Diag(OldLocation, PrevDiag); 4235 New->setInvalidDecl(); 4236 return; 4237 } 4238 4239 // Merge "used" flag. 4240 if (Old->getMostRecentDecl()->isUsed(false)) 4241 New->setIsUsed(); 4242 4243 // Keep a chain of previous declarations. 4244 New->setPreviousDecl(Old); 4245 if (NewTemplate) 4246 NewTemplate->setPreviousDecl(OldTemplate); 4247 4248 // Inherit access appropriately. 4249 New->setAccess(Old->getAccess()); 4250 if (NewTemplate) 4251 NewTemplate->setAccess(New->getAccess()); 4252 4253 if (Old->isInline()) 4254 New->setImplicitlyInline(); 4255 } 4256 4257 void Sema::notePreviousDefinition(const NamedDecl *Old, SourceLocation New) { 4258 SourceManager &SrcMgr = getSourceManager(); 4259 auto FNewDecLoc = SrcMgr.getDecomposedLoc(New); 4260 auto FOldDecLoc = SrcMgr.getDecomposedLoc(Old->getLocation()); 4261 auto *FNew = SrcMgr.getFileEntryForID(FNewDecLoc.first); 4262 auto *FOld = SrcMgr.getFileEntryForID(FOldDecLoc.first); 4263 auto &HSI = PP.getHeaderSearchInfo(); 4264 StringRef HdrFilename = 4265 SrcMgr.getFilename(SrcMgr.getSpellingLoc(Old->getLocation())); 4266 4267 auto noteFromModuleOrInclude = [&](Module *Mod, 4268 SourceLocation IncLoc) -> bool { 4269 // Redefinition errors with modules are common with non modular mapped 4270 // headers, example: a non-modular header H in module A that also gets 4271 // included directly in a TU. Pointing twice to the same header/definition 4272 // is confusing, try to get better diagnostics when modules is on. 4273 if (IncLoc.isValid()) { 4274 if (Mod) { 4275 Diag(IncLoc, diag::note_redefinition_modules_same_file) 4276 << HdrFilename.str() << Mod->getFullModuleName(); 4277 if (!Mod->DefinitionLoc.isInvalid()) 4278 Diag(Mod->DefinitionLoc, diag::note_defined_here) 4279 << Mod->getFullModuleName(); 4280 } else { 4281 Diag(IncLoc, diag::note_redefinition_include_same_file) 4282 << HdrFilename.str(); 4283 } 4284 return true; 4285 } 4286 4287 return false; 4288 }; 4289 4290 // Is it the same file and same offset? Provide more information on why 4291 // this leads to a redefinition error. 4292 if (FNew == FOld && FNewDecLoc.second == FOldDecLoc.second) { 4293 SourceLocation OldIncLoc = SrcMgr.getIncludeLoc(FOldDecLoc.first); 4294 SourceLocation NewIncLoc = SrcMgr.getIncludeLoc(FNewDecLoc.first); 4295 bool EmittedDiag = 4296 noteFromModuleOrInclude(Old->getOwningModule(), OldIncLoc); 4297 EmittedDiag |= noteFromModuleOrInclude(getCurrentModule(), NewIncLoc); 4298 4299 // If the header has no guards, emit a note suggesting one. 4300 if (FOld && !HSI.isFileMultipleIncludeGuarded(FOld)) 4301 Diag(Old->getLocation(), diag::note_use_ifdef_guards); 4302 4303 if (EmittedDiag) 4304 return; 4305 } 4306 4307 // Redefinition coming from different files or couldn't do better above. 4308 if (Old->getLocation().isValid()) 4309 Diag(Old->getLocation(), diag::note_previous_definition); 4310 } 4311 4312 /// We've just determined that \p Old and \p New both appear to be definitions 4313 /// of the same variable. Either diagnose or fix the problem. 4314 bool Sema::checkVarDeclRedefinition(VarDecl *Old, VarDecl *New) { 4315 if (!hasVisibleDefinition(Old) && 4316 (New->getFormalLinkage() == InternalLinkage || 4317 New->isInline() || 4318 New->getDescribedVarTemplate() || 4319 New->getNumTemplateParameterLists() || 4320 New->getDeclContext()->isDependentContext())) { 4321 // The previous definition is hidden, and multiple definitions are 4322 // permitted (in separate TUs). Demote this to a declaration. 4323 New->demoteThisDefinitionToDeclaration(); 4324 4325 // Make the canonical definition visible. 4326 if (auto *OldTD = Old->getDescribedVarTemplate()) 4327 makeMergedDefinitionVisible(OldTD); 4328 makeMergedDefinitionVisible(Old); 4329 return false; 4330 } else { 4331 Diag(New->getLocation(), diag::err_redefinition) << New; 4332 notePreviousDefinition(Old, New->getLocation()); 4333 New->setInvalidDecl(); 4334 return true; 4335 } 4336 } 4337 4338 /// ParsedFreeStandingDeclSpec - This method is invoked when a declspec with 4339 /// no declarator (e.g. "struct foo;") is parsed. 4340 Decl * 4341 Sema::ParsedFreeStandingDeclSpec(Scope *S, AccessSpecifier AS, DeclSpec &DS, 4342 RecordDecl *&AnonRecord) { 4343 return ParsedFreeStandingDeclSpec(S, AS, DS, MultiTemplateParamsArg(), false, 4344 AnonRecord); 4345 } 4346 4347 // The MS ABI changed between VS2013 and VS2015 with regard to numbers used to 4348 // disambiguate entities defined in different scopes. 4349 // While the VS2015 ABI fixes potential miscompiles, it is also breaks 4350 // compatibility. 4351 // We will pick our mangling number depending on which version of MSVC is being 4352 // targeted. 4353 static unsigned getMSManglingNumber(const LangOptions &LO, Scope *S) { 4354 return LO.isCompatibleWithMSVC(LangOptions::MSVC2015) 4355 ? S->getMSCurManglingNumber() 4356 : S->getMSLastManglingNumber(); 4357 } 4358 4359 void Sema::handleTagNumbering(const TagDecl *Tag, Scope *TagScope) { 4360 if (!Context.getLangOpts().CPlusPlus) 4361 return; 4362 4363 if (isa<CXXRecordDecl>(Tag->getParent())) { 4364 // If this tag is the direct child of a class, number it if 4365 // it is anonymous. 4366 if (!Tag->getName().empty() || Tag->getTypedefNameForAnonDecl()) 4367 return; 4368 MangleNumberingContext &MCtx = 4369 Context.getManglingNumberContext(Tag->getParent()); 4370 Context.setManglingNumber( 4371 Tag, MCtx.getManglingNumber( 4372 Tag, getMSManglingNumber(getLangOpts(), TagScope))); 4373 return; 4374 } 4375 4376 // If this tag isn't a direct child of a class, number it if it is local. 4377 MangleNumberingContext *MCtx; 4378 Decl *ManglingContextDecl; 4379 std::tie(MCtx, ManglingContextDecl) = 4380 getCurrentMangleNumberContext(Tag->getDeclContext()); 4381 if (MCtx) { 4382 Context.setManglingNumber( 4383 Tag, MCtx->getManglingNumber( 4384 Tag, getMSManglingNumber(getLangOpts(), TagScope))); 4385 } 4386 } 4387 4388 namespace { 4389 struct NonCLikeKind { 4390 enum { 4391 None, 4392 BaseClass, 4393 DefaultMemberInit, 4394 Lambda, 4395 Friend, 4396 OtherMember, 4397 Invalid, 4398 } Kind = None; 4399 SourceRange Range; 4400 4401 explicit operator bool() { return Kind != None; } 4402 }; 4403 } 4404 4405 /// Determine whether a class is C-like, according to the rules of C++ 4406 /// [dcl.typedef] for anonymous classes with typedef names for linkage. 4407 static NonCLikeKind getNonCLikeKindForAnonymousStruct(const CXXRecordDecl *RD) { 4408 if (RD->isInvalidDecl()) 4409 return {NonCLikeKind::Invalid, {}}; 4410 4411 // C++ [dcl.typedef]p9: [P1766R1] 4412 // An unnamed class with a typedef name for linkage purposes shall not 4413 // 4414 // -- have any base classes 4415 if (RD->getNumBases()) 4416 return {NonCLikeKind::BaseClass, 4417 SourceRange(RD->bases_begin()->getBeginLoc(), 4418 RD->bases_end()[-1].getEndLoc())}; 4419 bool Invalid = false; 4420 for (Decl *D : RD->decls()) { 4421 // Don't complain about things we already diagnosed. 4422 if (D->isInvalidDecl()) { 4423 Invalid = true; 4424 continue; 4425 } 4426 4427 // -- have any [...] default member initializers 4428 if (auto *FD = dyn_cast<FieldDecl>(D)) { 4429 if (FD->hasInClassInitializer()) { 4430 auto *Init = FD->getInClassInitializer(); 4431 return {NonCLikeKind::DefaultMemberInit, 4432 Init ? Init->getSourceRange() : D->getSourceRange()}; 4433 } 4434 continue; 4435 } 4436 4437 // FIXME: We don't allow friend declarations. This violates the wording of 4438 // P1766, but not the intent. 4439 if (isa<FriendDecl>(D)) 4440 return {NonCLikeKind::Friend, D->getSourceRange()}; 4441 4442 // -- declare any members other than non-static data members, member 4443 // enumerations, or member classes, 4444 if (isa<StaticAssertDecl>(D) || isa<IndirectFieldDecl>(D) || 4445 isa<EnumDecl>(D)) 4446 continue; 4447 auto *MemberRD = dyn_cast<CXXRecordDecl>(D); 4448 if (!MemberRD) { 4449 if (D->isImplicit()) 4450 continue; 4451 return {NonCLikeKind::OtherMember, D->getSourceRange()}; 4452 } 4453 4454 // -- contain a lambda-expression, 4455 if (MemberRD->isLambda()) 4456 return {NonCLikeKind::Lambda, MemberRD->getSourceRange()}; 4457 4458 // and all member classes shall also satisfy these requirements 4459 // (recursively). 4460 if (MemberRD->isThisDeclarationADefinition()) { 4461 if (auto Kind = getNonCLikeKindForAnonymousStruct(MemberRD)) 4462 return Kind; 4463 } 4464 } 4465 4466 return {Invalid ? NonCLikeKind::Invalid : NonCLikeKind::None, {}}; 4467 } 4468 4469 void Sema::setTagNameForLinkagePurposes(TagDecl *TagFromDeclSpec, 4470 TypedefNameDecl *NewTD) { 4471 if (TagFromDeclSpec->isInvalidDecl()) 4472 return; 4473 4474 // Do nothing if the tag already has a name for linkage purposes. 4475 if (TagFromDeclSpec->hasNameForLinkage()) 4476 return; 4477 4478 // A well-formed anonymous tag must always be a TUK_Definition. 4479 assert(TagFromDeclSpec->isThisDeclarationADefinition()); 4480 4481 // The type must match the tag exactly; no qualifiers allowed. 4482 if (!Context.hasSameType(NewTD->getUnderlyingType(), 4483 Context.getTagDeclType(TagFromDeclSpec))) { 4484 if (getLangOpts().CPlusPlus) 4485 Context.addTypedefNameForUnnamedTagDecl(TagFromDeclSpec, NewTD); 4486 return; 4487 } 4488 4489 // C++ [dcl.typedef]p9: [P1766R1, applied as DR] 4490 // An unnamed class with a typedef name for linkage purposes shall [be 4491 // C-like]. 4492 // 4493 // FIXME: Also diagnose if we've already computed the linkage. That ideally 4494 // shouldn't happen, but there are constructs that the language rule doesn't 4495 // disallow for which we can't reasonably avoid computing linkage early. 4496 const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(TagFromDeclSpec); 4497 NonCLikeKind NonCLike = RD ? getNonCLikeKindForAnonymousStruct(RD) 4498 : NonCLikeKind(); 4499 bool ChangesLinkage = TagFromDeclSpec->hasLinkageBeenComputed(); 4500 if (NonCLike || ChangesLinkage) { 4501 if (NonCLike.Kind == NonCLikeKind::Invalid) 4502 return; 4503 4504 unsigned DiagID = diag::ext_non_c_like_anon_struct_in_typedef; 4505 if (ChangesLinkage) { 4506 // If the linkage changes, we can't accept this as an extension. 4507 if (NonCLike.Kind == NonCLikeKind::None) 4508 DiagID = diag::err_typedef_changes_linkage; 4509 else 4510 DiagID = diag::err_non_c_like_anon_struct_in_typedef; 4511 } 4512 4513 SourceLocation FixitLoc = 4514 getLocForEndOfToken(TagFromDeclSpec->getInnerLocStart()); 4515 llvm::SmallString<40> TextToInsert; 4516 TextToInsert += ' '; 4517 TextToInsert += NewTD->getIdentifier()->getName(); 4518 4519 Diag(FixitLoc, DiagID) 4520 << isa<TypeAliasDecl>(NewTD) 4521 << FixItHint::CreateInsertion(FixitLoc, TextToInsert); 4522 if (NonCLike.Kind != NonCLikeKind::None) { 4523 Diag(NonCLike.Range.getBegin(), diag::note_non_c_like_anon_struct) 4524 << NonCLike.Kind - 1 << NonCLike.Range; 4525 } 4526 Diag(NewTD->getLocation(), diag::note_typedef_for_linkage_here) 4527 << NewTD << isa<TypeAliasDecl>(NewTD); 4528 4529 if (ChangesLinkage) 4530 return; 4531 } 4532 4533 // Otherwise, set this as the anon-decl typedef for the tag. 4534 TagFromDeclSpec->setTypedefNameForAnonDecl(NewTD); 4535 } 4536 4537 static unsigned GetDiagnosticTypeSpecifierID(DeclSpec::TST T) { 4538 switch (T) { 4539 case DeclSpec::TST_class: 4540 return 0; 4541 case DeclSpec::TST_struct: 4542 return 1; 4543 case DeclSpec::TST_interface: 4544 return 2; 4545 case DeclSpec::TST_union: 4546 return 3; 4547 case DeclSpec::TST_enum: 4548 return 4; 4549 default: 4550 llvm_unreachable("unexpected type specifier"); 4551 } 4552 } 4553 4554 /// ParsedFreeStandingDeclSpec - This method is invoked when a declspec with 4555 /// no declarator (e.g. "struct foo;") is parsed. It also accepts template 4556 /// parameters to cope with template friend declarations. 4557 Decl * 4558 Sema::ParsedFreeStandingDeclSpec(Scope *S, AccessSpecifier AS, DeclSpec &DS, 4559 MultiTemplateParamsArg TemplateParams, 4560 bool IsExplicitInstantiation, 4561 RecordDecl *&AnonRecord) { 4562 Decl *TagD = nullptr; 4563 TagDecl *Tag = nullptr; 4564 if (DS.getTypeSpecType() == DeclSpec::TST_class || 4565 DS.getTypeSpecType() == DeclSpec::TST_struct || 4566 DS.getTypeSpecType() == DeclSpec::TST_interface || 4567 DS.getTypeSpecType() == DeclSpec::TST_union || 4568 DS.getTypeSpecType() == DeclSpec::TST_enum) { 4569 TagD = DS.getRepAsDecl(); 4570 4571 if (!TagD) // We probably had an error 4572 return nullptr; 4573 4574 // Note that the above type specs guarantee that the 4575 // type rep is a Decl, whereas in many of the others 4576 // it's a Type. 4577 if (isa<TagDecl>(TagD)) 4578 Tag = cast<TagDecl>(TagD); 4579 else if (ClassTemplateDecl *CTD = dyn_cast<ClassTemplateDecl>(TagD)) 4580 Tag = CTD->getTemplatedDecl(); 4581 } 4582 4583 if (Tag) { 4584 handleTagNumbering(Tag, S); 4585 Tag->setFreeStanding(); 4586 if (Tag->isInvalidDecl()) 4587 return Tag; 4588 } 4589 4590 if (unsigned TypeQuals = DS.getTypeQualifiers()) { 4591 // Enforce C99 6.7.3p2: "Types other than pointer types derived from object 4592 // or incomplete types shall not be restrict-qualified." 4593 if (TypeQuals & DeclSpec::TQ_restrict) 4594 Diag(DS.getRestrictSpecLoc(), 4595 diag::err_typecheck_invalid_restrict_not_pointer_noarg) 4596 << DS.getSourceRange(); 4597 } 4598 4599 if (DS.isInlineSpecified()) 4600 Diag(DS.getInlineSpecLoc(), diag::err_inline_non_function) 4601 << getLangOpts().CPlusPlus17; 4602 4603 if (DS.hasConstexprSpecifier()) { 4604 // C++0x [dcl.constexpr]p1: constexpr can only be applied to declarations 4605 // and definitions of functions and variables. 4606 // C++2a [dcl.constexpr]p1: The consteval specifier shall be applied only to 4607 // the declaration of a function or function template 4608 if (Tag) 4609 Diag(DS.getConstexprSpecLoc(), diag::err_constexpr_tag) 4610 << GetDiagnosticTypeSpecifierID(DS.getTypeSpecType()) 4611 << static_cast<int>(DS.getConstexprSpecifier()); 4612 else 4613 Diag(DS.getConstexprSpecLoc(), diag::err_constexpr_wrong_decl_kind) 4614 << static_cast<int>(DS.getConstexprSpecifier()); 4615 // Don't emit warnings after this error. 4616 return TagD; 4617 } 4618 4619 DiagnoseFunctionSpecifiers(DS); 4620 4621 if (DS.isFriendSpecified()) { 4622 // If we're dealing with a decl but not a TagDecl, assume that 4623 // whatever routines created it handled the friendship aspect. 4624 if (TagD && !Tag) 4625 return nullptr; 4626 return ActOnFriendTypeDecl(S, DS, TemplateParams); 4627 } 4628 4629 const CXXScopeSpec &SS = DS.getTypeSpecScope(); 4630 bool IsExplicitSpecialization = 4631 !TemplateParams.empty() && TemplateParams.back()->size() == 0; 4632 if (Tag && SS.isNotEmpty() && !Tag->isCompleteDefinition() && 4633 !IsExplicitInstantiation && !IsExplicitSpecialization && 4634 !isa<ClassTemplatePartialSpecializationDecl>(Tag)) { 4635 // Per C++ [dcl.type.elab]p1, a class declaration cannot have a 4636 // nested-name-specifier unless it is an explicit instantiation 4637 // or an explicit specialization. 4638 // 4639 // FIXME: We allow class template partial specializations here too, per the 4640 // obvious intent of DR1819. 4641 // 4642 // Per C++ [dcl.enum]p1, an opaque-enum-declaration can't either. 4643 Diag(SS.getBeginLoc(), diag::err_standalone_class_nested_name_specifier) 4644 << GetDiagnosticTypeSpecifierID(DS.getTypeSpecType()) << SS.getRange(); 4645 return nullptr; 4646 } 4647 4648 // Track whether this decl-specifier declares anything. 4649 bool DeclaresAnything = true; 4650 4651 // Handle anonymous struct definitions. 4652 if (RecordDecl *Record = dyn_cast_or_null<RecordDecl>(Tag)) { 4653 if (!Record->getDeclName() && Record->isCompleteDefinition() && 4654 DS.getStorageClassSpec() != DeclSpec::SCS_typedef) { 4655 if (getLangOpts().CPlusPlus || 4656 Record->getDeclContext()->isRecord()) { 4657 // If CurContext is a DeclContext that can contain statements, 4658 // RecursiveASTVisitor won't visit the decls that 4659 // BuildAnonymousStructOrUnion() will put into CurContext. 4660 // Also store them here so that they can be part of the 4661 // DeclStmt that gets created in this case. 4662 // FIXME: Also return the IndirectFieldDecls created by 4663 // BuildAnonymousStructOr union, for the same reason? 4664 if (CurContext->isFunctionOrMethod()) 4665 AnonRecord = Record; 4666 return BuildAnonymousStructOrUnion(S, DS, AS, Record, 4667 Context.getPrintingPolicy()); 4668 } 4669 4670 DeclaresAnything = false; 4671 } 4672 } 4673 4674 // C11 6.7.2.1p2: 4675 // A struct-declaration that does not declare an anonymous structure or 4676 // anonymous union shall contain a struct-declarator-list. 4677 // 4678 // This rule also existed in C89 and C99; the grammar for struct-declaration 4679 // did not permit a struct-declaration without a struct-declarator-list. 4680 if (!getLangOpts().CPlusPlus && CurContext->isRecord() && 4681 DS.getStorageClassSpec() == DeclSpec::SCS_unspecified) { 4682 // Check for Microsoft C extension: anonymous struct/union member. 4683 // Handle 2 kinds of anonymous struct/union: 4684 // struct STRUCT; 4685 // union UNION; 4686 // and 4687 // STRUCT_TYPE; <- where STRUCT_TYPE is a typedef struct. 4688 // UNION_TYPE; <- where UNION_TYPE is a typedef union. 4689 if ((Tag && Tag->getDeclName()) || 4690 DS.getTypeSpecType() == DeclSpec::TST_typename) { 4691 RecordDecl *Record = nullptr; 4692 if (Tag) 4693 Record = dyn_cast<RecordDecl>(Tag); 4694 else if (const RecordType *RT = 4695 DS.getRepAsType().get()->getAsStructureType()) 4696 Record = RT->getDecl(); 4697 else if (const RecordType *UT = DS.getRepAsType().get()->getAsUnionType()) 4698 Record = UT->getDecl(); 4699 4700 if (Record && getLangOpts().MicrosoftExt) { 4701 Diag(DS.getBeginLoc(), diag::ext_ms_anonymous_record) 4702 << Record->isUnion() << DS.getSourceRange(); 4703 return BuildMicrosoftCAnonymousStruct(S, DS, Record); 4704 } 4705 4706 DeclaresAnything = false; 4707 } 4708 } 4709 4710 // Skip all the checks below if we have a type error. 4711 if (DS.getTypeSpecType() == DeclSpec::TST_error || 4712 (TagD && TagD->isInvalidDecl())) 4713 return TagD; 4714 4715 if (getLangOpts().CPlusPlus && 4716 DS.getStorageClassSpec() != DeclSpec::SCS_typedef) 4717 if (EnumDecl *Enum = dyn_cast_or_null<EnumDecl>(Tag)) 4718 if (Enum->enumerator_begin() == Enum->enumerator_end() && 4719 !Enum->getIdentifier() && !Enum->isInvalidDecl()) 4720 DeclaresAnything = false; 4721 4722 if (!DS.isMissingDeclaratorOk()) { 4723 // Customize diagnostic for a typedef missing a name. 4724 if (DS.getStorageClassSpec() == DeclSpec::SCS_typedef) 4725 Diag(DS.getBeginLoc(), diag::ext_typedef_without_a_name) 4726 << DS.getSourceRange(); 4727 else 4728 DeclaresAnything = false; 4729 } 4730 4731 if (DS.isModulePrivateSpecified() && 4732 Tag && Tag->getDeclContext()->isFunctionOrMethod()) 4733 Diag(DS.getModulePrivateSpecLoc(), diag::err_module_private_local_class) 4734 << Tag->getTagKind() 4735 << FixItHint::CreateRemoval(DS.getModulePrivateSpecLoc()); 4736 4737 ActOnDocumentableDecl(TagD); 4738 4739 // C 6.7/2: 4740 // A declaration [...] shall declare at least a declarator [...], a tag, 4741 // or the members of an enumeration. 4742 // C++ [dcl.dcl]p3: 4743 // [If there are no declarators], and except for the declaration of an 4744 // unnamed bit-field, the decl-specifier-seq shall introduce one or more 4745 // names into the program, or shall redeclare a name introduced by a 4746 // previous declaration. 4747 if (!DeclaresAnything) { 4748 // In C, we allow this as a (popular) extension / bug. Don't bother 4749 // producing further diagnostics for redundant qualifiers after this. 4750 Diag(DS.getBeginLoc(), (IsExplicitInstantiation || !TemplateParams.empty()) 4751 ? diag::err_no_declarators 4752 : diag::ext_no_declarators) 4753 << DS.getSourceRange(); 4754 return TagD; 4755 } 4756 4757 // C++ [dcl.stc]p1: 4758 // If a storage-class-specifier appears in a decl-specifier-seq, [...] the 4759 // init-declarator-list of the declaration shall not be empty. 4760 // C++ [dcl.fct.spec]p1: 4761 // If a cv-qualifier appears in a decl-specifier-seq, the 4762 // init-declarator-list of the declaration shall not be empty. 4763 // 4764 // Spurious qualifiers here appear to be valid in C. 4765 unsigned DiagID = diag::warn_standalone_specifier; 4766 if (getLangOpts().CPlusPlus) 4767 DiagID = diag::ext_standalone_specifier; 4768 4769 // Note that a linkage-specification sets a storage class, but 4770 // 'extern "C" struct foo;' is actually valid and not theoretically 4771 // useless. 4772 if (DeclSpec::SCS SCS = DS.getStorageClassSpec()) { 4773 if (SCS == DeclSpec::SCS_mutable) 4774 // Since mutable is not a viable storage class specifier in C, there is 4775 // no reason to treat it as an extension. Instead, diagnose as an error. 4776 Diag(DS.getStorageClassSpecLoc(), diag::err_mutable_nonmember); 4777 else if (!DS.isExternInLinkageSpec() && SCS != DeclSpec::SCS_typedef) 4778 Diag(DS.getStorageClassSpecLoc(), DiagID) 4779 << DeclSpec::getSpecifierName(SCS); 4780 } 4781 4782 if (DeclSpec::TSCS TSCS = DS.getThreadStorageClassSpec()) 4783 Diag(DS.getThreadStorageClassSpecLoc(), DiagID) 4784 << DeclSpec::getSpecifierName(TSCS); 4785 if (DS.getTypeQualifiers()) { 4786 if (DS.getTypeQualifiers() & DeclSpec::TQ_const) 4787 Diag(DS.getConstSpecLoc(), DiagID) << "const"; 4788 if (DS.getTypeQualifiers() & DeclSpec::TQ_volatile) 4789 Diag(DS.getConstSpecLoc(), DiagID) << "volatile"; 4790 // Restrict is covered above. 4791 if (DS.getTypeQualifiers() & DeclSpec::TQ_atomic) 4792 Diag(DS.getAtomicSpecLoc(), DiagID) << "_Atomic"; 4793 if (DS.getTypeQualifiers() & DeclSpec::TQ_unaligned) 4794 Diag(DS.getUnalignedSpecLoc(), DiagID) << "__unaligned"; 4795 } 4796 4797 // Warn about ignored type attributes, for example: 4798 // __attribute__((aligned)) struct A; 4799 // Attributes should be placed after tag to apply to type declaration. 4800 if (!DS.getAttributes().empty()) { 4801 DeclSpec::TST TypeSpecType = DS.getTypeSpecType(); 4802 if (TypeSpecType == DeclSpec::TST_class || 4803 TypeSpecType == DeclSpec::TST_struct || 4804 TypeSpecType == DeclSpec::TST_interface || 4805 TypeSpecType == DeclSpec::TST_union || 4806 TypeSpecType == DeclSpec::TST_enum) { 4807 for (const ParsedAttr &AL : DS.getAttributes()) 4808 Diag(AL.getLoc(), diag::warn_declspec_attribute_ignored) 4809 << AL << GetDiagnosticTypeSpecifierID(TypeSpecType); 4810 } 4811 } 4812 4813 return TagD; 4814 } 4815 4816 /// We are trying to inject an anonymous member into the given scope; 4817 /// check if there's an existing declaration that can't be overloaded. 4818 /// 4819 /// \return true if this is a forbidden redeclaration 4820 static bool CheckAnonMemberRedeclaration(Sema &SemaRef, 4821 Scope *S, 4822 DeclContext *Owner, 4823 DeclarationName Name, 4824 SourceLocation NameLoc, 4825 bool IsUnion) { 4826 LookupResult R(SemaRef, Name, NameLoc, Sema::LookupMemberName, 4827 Sema::ForVisibleRedeclaration); 4828 if (!SemaRef.LookupName(R, S)) return false; 4829 4830 // Pick a representative declaration. 4831 NamedDecl *PrevDecl = R.getRepresentativeDecl()->getUnderlyingDecl(); 4832 assert(PrevDecl && "Expected a non-null Decl"); 4833 4834 if (!SemaRef.isDeclInScope(PrevDecl, Owner, S)) 4835 return false; 4836 4837 SemaRef.Diag(NameLoc, diag::err_anonymous_record_member_redecl) 4838 << IsUnion << Name; 4839 SemaRef.Diag(PrevDecl->getLocation(), diag::note_previous_declaration); 4840 4841 return true; 4842 } 4843 4844 /// InjectAnonymousStructOrUnionMembers - Inject the members of the 4845 /// anonymous struct or union AnonRecord into the owning context Owner 4846 /// and scope S. This routine will be invoked just after we realize 4847 /// that an unnamed union or struct is actually an anonymous union or 4848 /// struct, e.g., 4849 /// 4850 /// @code 4851 /// union { 4852 /// int i; 4853 /// float f; 4854 /// }; // InjectAnonymousStructOrUnionMembers called here to inject i and 4855 /// // f into the surrounding scope.x 4856 /// @endcode 4857 /// 4858 /// This routine is recursive, injecting the names of nested anonymous 4859 /// structs/unions into the owning context and scope as well. 4860 static bool 4861 InjectAnonymousStructOrUnionMembers(Sema &SemaRef, Scope *S, DeclContext *Owner, 4862 RecordDecl *AnonRecord, AccessSpecifier AS, 4863 SmallVectorImpl<NamedDecl *> &Chaining) { 4864 bool Invalid = false; 4865 4866 // Look every FieldDecl and IndirectFieldDecl with a name. 4867 for (auto *D : AnonRecord->decls()) { 4868 if ((isa<FieldDecl>(D) || isa<IndirectFieldDecl>(D)) && 4869 cast<NamedDecl>(D)->getDeclName()) { 4870 ValueDecl *VD = cast<ValueDecl>(D); 4871 if (CheckAnonMemberRedeclaration(SemaRef, S, Owner, VD->getDeclName(), 4872 VD->getLocation(), 4873 AnonRecord->isUnion())) { 4874 // C++ [class.union]p2: 4875 // The names of the members of an anonymous union shall be 4876 // distinct from the names of any other entity in the 4877 // scope in which the anonymous union is declared. 4878 Invalid = true; 4879 } else { 4880 // C++ [class.union]p2: 4881 // For the purpose of name lookup, after the anonymous union 4882 // definition, the members of the anonymous union are 4883 // considered to have been defined in the scope in which the 4884 // anonymous union is declared. 4885 unsigned OldChainingSize = Chaining.size(); 4886 if (IndirectFieldDecl *IF = dyn_cast<IndirectFieldDecl>(VD)) 4887 Chaining.append(IF->chain_begin(), IF->chain_end()); 4888 else 4889 Chaining.push_back(VD); 4890 4891 assert(Chaining.size() >= 2); 4892 NamedDecl **NamedChain = 4893 new (SemaRef.Context)NamedDecl*[Chaining.size()]; 4894 for (unsigned i = 0; i < Chaining.size(); i++) 4895 NamedChain[i] = Chaining[i]; 4896 4897 IndirectFieldDecl *IndirectField = IndirectFieldDecl::Create( 4898 SemaRef.Context, Owner, VD->getLocation(), VD->getIdentifier(), 4899 VD->getType(), {NamedChain, Chaining.size()}); 4900 4901 for (const auto *Attr : VD->attrs()) 4902 IndirectField->addAttr(Attr->clone(SemaRef.Context)); 4903 4904 IndirectField->setAccess(AS); 4905 IndirectField->setImplicit(); 4906 SemaRef.PushOnScopeChains(IndirectField, S); 4907 4908 // That includes picking up the appropriate access specifier. 4909 if (AS != AS_none) IndirectField->setAccess(AS); 4910 4911 Chaining.resize(OldChainingSize); 4912 } 4913 } 4914 } 4915 4916 return Invalid; 4917 } 4918 4919 /// StorageClassSpecToVarDeclStorageClass - Maps a DeclSpec::SCS to 4920 /// a VarDecl::StorageClass. Any error reporting is up to the caller: 4921 /// illegal input values are mapped to SC_None. 4922 static StorageClass 4923 StorageClassSpecToVarDeclStorageClass(const DeclSpec &DS) { 4924 DeclSpec::SCS StorageClassSpec = DS.getStorageClassSpec(); 4925 assert(StorageClassSpec != DeclSpec::SCS_typedef && 4926 "Parser allowed 'typedef' as storage class VarDecl."); 4927 switch (StorageClassSpec) { 4928 case DeclSpec::SCS_unspecified: return SC_None; 4929 case DeclSpec::SCS_extern: 4930 if (DS.isExternInLinkageSpec()) 4931 return SC_None; 4932 return SC_Extern; 4933 case DeclSpec::SCS_static: return SC_Static; 4934 case DeclSpec::SCS_auto: return SC_Auto; 4935 case DeclSpec::SCS_register: return SC_Register; 4936 case DeclSpec::SCS_private_extern: return SC_PrivateExtern; 4937 // Illegal SCSs map to None: error reporting is up to the caller. 4938 case DeclSpec::SCS_mutable: // Fall through. 4939 case DeclSpec::SCS_typedef: return SC_None; 4940 } 4941 llvm_unreachable("unknown storage class specifier"); 4942 } 4943 4944 static SourceLocation findDefaultInitializer(const CXXRecordDecl *Record) { 4945 assert(Record->hasInClassInitializer()); 4946 4947 for (const auto *I : Record->decls()) { 4948 const auto *FD = dyn_cast<FieldDecl>(I); 4949 if (const auto *IFD = dyn_cast<IndirectFieldDecl>(I)) 4950 FD = IFD->getAnonField(); 4951 if (FD && FD->hasInClassInitializer()) 4952 return FD->getLocation(); 4953 } 4954 4955 llvm_unreachable("couldn't find in-class initializer"); 4956 } 4957 4958 static void checkDuplicateDefaultInit(Sema &S, CXXRecordDecl *Parent, 4959 SourceLocation DefaultInitLoc) { 4960 if (!Parent->isUnion() || !Parent->hasInClassInitializer()) 4961 return; 4962 4963 S.Diag(DefaultInitLoc, diag::err_multiple_mem_union_initialization); 4964 S.Diag(findDefaultInitializer(Parent), diag::note_previous_initializer) << 0; 4965 } 4966 4967 static void checkDuplicateDefaultInit(Sema &S, CXXRecordDecl *Parent, 4968 CXXRecordDecl *AnonUnion) { 4969 if (!Parent->isUnion() || !Parent->hasInClassInitializer()) 4970 return; 4971 4972 checkDuplicateDefaultInit(S, Parent, findDefaultInitializer(AnonUnion)); 4973 } 4974 4975 /// BuildAnonymousStructOrUnion - Handle the declaration of an 4976 /// anonymous structure or union. Anonymous unions are a C++ feature 4977 /// (C++ [class.union]) and a C11 feature; anonymous structures 4978 /// are a C11 feature and GNU C++ extension. 4979 Decl *Sema::BuildAnonymousStructOrUnion(Scope *S, DeclSpec &DS, 4980 AccessSpecifier AS, 4981 RecordDecl *Record, 4982 const PrintingPolicy &Policy) { 4983 DeclContext *Owner = Record->getDeclContext(); 4984 4985 // Diagnose whether this anonymous struct/union is an extension. 4986 if (Record->isUnion() && !getLangOpts().CPlusPlus && !getLangOpts().C11) 4987 Diag(Record->getLocation(), diag::ext_anonymous_union); 4988 else if (!Record->isUnion() && getLangOpts().CPlusPlus) 4989 Diag(Record->getLocation(), diag::ext_gnu_anonymous_struct); 4990 else if (!Record->isUnion() && !getLangOpts().C11) 4991 Diag(Record->getLocation(), diag::ext_c11_anonymous_struct); 4992 4993 // C and C++ require different kinds of checks for anonymous 4994 // structs/unions. 4995 bool Invalid = false; 4996 if (getLangOpts().CPlusPlus) { 4997 const char *PrevSpec = nullptr; 4998 if (Record->isUnion()) { 4999 // C++ [class.union]p6: 5000 // C++17 [class.union.anon]p2: 5001 // Anonymous unions declared in a named namespace or in the 5002 // global namespace shall be declared static. 5003 unsigned DiagID; 5004 DeclContext *OwnerScope = Owner->getRedeclContext(); 5005 if (DS.getStorageClassSpec() != DeclSpec::SCS_static && 5006 (OwnerScope->isTranslationUnit() || 5007 (OwnerScope->isNamespace() && 5008 !cast<NamespaceDecl>(OwnerScope)->isAnonymousNamespace()))) { 5009 Diag(Record->getLocation(), diag::err_anonymous_union_not_static) 5010 << FixItHint::CreateInsertion(Record->getLocation(), "static "); 5011 5012 // Recover by adding 'static'. 5013 DS.SetStorageClassSpec(*this, DeclSpec::SCS_static, SourceLocation(), 5014 PrevSpec, DiagID, Policy); 5015 } 5016 // C++ [class.union]p6: 5017 // A storage class is not allowed in a declaration of an 5018 // anonymous union in a class scope. 5019 else if (DS.getStorageClassSpec() != DeclSpec::SCS_unspecified && 5020 isa<RecordDecl>(Owner)) { 5021 Diag(DS.getStorageClassSpecLoc(), 5022 diag::err_anonymous_union_with_storage_spec) 5023 << FixItHint::CreateRemoval(DS.getStorageClassSpecLoc()); 5024 5025 // Recover by removing the storage specifier. 5026 DS.SetStorageClassSpec(*this, DeclSpec::SCS_unspecified, 5027 SourceLocation(), 5028 PrevSpec, DiagID, Context.getPrintingPolicy()); 5029 } 5030 } 5031 5032 // Ignore const/volatile/restrict qualifiers. 5033 if (DS.getTypeQualifiers()) { 5034 if (DS.getTypeQualifiers() & DeclSpec::TQ_const) 5035 Diag(DS.getConstSpecLoc(), diag::ext_anonymous_struct_union_qualified) 5036 << Record->isUnion() << "const" 5037 << FixItHint::CreateRemoval(DS.getConstSpecLoc()); 5038 if (DS.getTypeQualifiers() & DeclSpec::TQ_volatile) 5039 Diag(DS.getVolatileSpecLoc(), 5040 diag::ext_anonymous_struct_union_qualified) 5041 << Record->isUnion() << "volatile" 5042 << FixItHint::CreateRemoval(DS.getVolatileSpecLoc()); 5043 if (DS.getTypeQualifiers() & DeclSpec::TQ_restrict) 5044 Diag(DS.getRestrictSpecLoc(), 5045 diag::ext_anonymous_struct_union_qualified) 5046 << Record->isUnion() << "restrict" 5047 << FixItHint::CreateRemoval(DS.getRestrictSpecLoc()); 5048 if (DS.getTypeQualifiers() & DeclSpec::TQ_atomic) 5049 Diag(DS.getAtomicSpecLoc(), 5050 diag::ext_anonymous_struct_union_qualified) 5051 << Record->isUnion() << "_Atomic" 5052 << FixItHint::CreateRemoval(DS.getAtomicSpecLoc()); 5053 if (DS.getTypeQualifiers() & DeclSpec::TQ_unaligned) 5054 Diag(DS.getUnalignedSpecLoc(), 5055 diag::ext_anonymous_struct_union_qualified) 5056 << Record->isUnion() << "__unaligned" 5057 << FixItHint::CreateRemoval(DS.getUnalignedSpecLoc()); 5058 5059 DS.ClearTypeQualifiers(); 5060 } 5061 5062 // C++ [class.union]p2: 5063 // The member-specification of an anonymous union shall only 5064 // define non-static data members. [Note: nested types and 5065 // functions cannot be declared within an anonymous union. ] 5066 for (auto *Mem : Record->decls()) { 5067 // Ignore invalid declarations; we already diagnosed them. 5068 if (Mem->isInvalidDecl()) 5069 continue; 5070 5071 if (auto *FD = dyn_cast<FieldDecl>(Mem)) { 5072 // C++ [class.union]p3: 5073 // An anonymous union shall not have private or protected 5074 // members (clause 11). 5075 assert(FD->getAccess() != AS_none); 5076 if (FD->getAccess() != AS_public) { 5077 Diag(FD->getLocation(), diag::err_anonymous_record_nonpublic_member) 5078 << Record->isUnion() << (FD->getAccess() == AS_protected); 5079 Invalid = true; 5080 } 5081 5082 // C++ [class.union]p1 5083 // An object of a class with a non-trivial constructor, a non-trivial 5084 // copy constructor, a non-trivial destructor, or a non-trivial copy 5085 // assignment operator cannot be a member of a union, nor can an 5086 // array of such objects. 5087 if (CheckNontrivialField(FD)) 5088 Invalid = true; 5089 } else if (Mem->isImplicit()) { 5090 // Any implicit members are fine. 5091 } else if (isa<TagDecl>(Mem) && Mem->getDeclContext() != Record) { 5092 // This is a type that showed up in an 5093 // elaborated-type-specifier inside the anonymous struct or 5094 // union, but which actually declares a type outside of the 5095 // anonymous struct or union. It's okay. 5096 } else if (auto *MemRecord = dyn_cast<RecordDecl>(Mem)) { 5097 if (!MemRecord->isAnonymousStructOrUnion() && 5098 MemRecord->getDeclName()) { 5099 // Visual C++ allows type definition in anonymous struct or union. 5100 if (getLangOpts().MicrosoftExt) 5101 Diag(MemRecord->getLocation(), diag::ext_anonymous_record_with_type) 5102 << Record->isUnion(); 5103 else { 5104 // This is a nested type declaration. 5105 Diag(MemRecord->getLocation(), diag::err_anonymous_record_with_type) 5106 << Record->isUnion(); 5107 Invalid = true; 5108 } 5109 } else { 5110 // This is an anonymous type definition within another anonymous type. 5111 // This is a popular extension, provided by Plan9, MSVC and GCC, but 5112 // not part of standard C++. 5113 Diag(MemRecord->getLocation(), 5114 diag::ext_anonymous_record_with_anonymous_type) 5115 << Record->isUnion(); 5116 } 5117 } else if (isa<AccessSpecDecl>(Mem)) { 5118 // Any access specifier is fine. 5119 } else if (isa<StaticAssertDecl>(Mem)) { 5120 // In C++1z, static_assert declarations are also fine. 5121 } else { 5122 // We have something that isn't a non-static data 5123 // member. Complain about it. 5124 unsigned DK = diag::err_anonymous_record_bad_member; 5125 if (isa<TypeDecl>(Mem)) 5126 DK = diag::err_anonymous_record_with_type; 5127 else if (isa<FunctionDecl>(Mem)) 5128 DK = diag::err_anonymous_record_with_function; 5129 else if (isa<VarDecl>(Mem)) 5130 DK = diag::err_anonymous_record_with_static; 5131 5132 // Visual C++ allows type definition in anonymous struct or union. 5133 if (getLangOpts().MicrosoftExt && 5134 DK == diag::err_anonymous_record_with_type) 5135 Diag(Mem->getLocation(), diag::ext_anonymous_record_with_type) 5136 << Record->isUnion(); 5137 else { 5138 Diag(Mem->getLocation(), DK) << Record->isUnion(); 5139 Invalid = true; 5140 } 5141 } 5142 } 5143 5144 // C++11 [class.union]p8 (DR1460): 5145 // At most one variant member of a union may have a 5146 // brace-or-equal-initializer. 5147 if (cast<CXXRecordDecl>(Record)->hasInClassInitializer() && 5148 Owner->isRecord()) 5149 checkDuplicateDefaultInit(*this, cast<CXXRecordDecl>(Owner), 5150 cast<CXXRecordDecl>(Record)); 5151 } 5152 5153 if (!Record->isUnion() && !Owner->isRecord()) { 5154 Diag(Record->getLocation(), diag::err_anonymous_struct_not_member) 5155 << getLangOpts().CPlusPlus; 5156 Invalid = true; 5157 } 5158 5159 // C++ [dcl.dcl]p3: 5160 // [If there are no declarators], and except for the declaration of an 5161 // unnamed bit-field, the decl-specifier-seq shall introduce one or more 5162 // names into the program 5163 // C++ [class.mem]p2: 5164 // each such member-declaration shall either declare at least one member 5165 // name of the class or declare at least one unnamed bit-field 5166 // 5167 // For C this is an error even for a named struct, and is diagnosed elsewhere. 5168 if (getLangOpts().CPlusPlus && Record->field_empty()) 5169 Diag(DS.getBeginLoc(), diag::ext_no_declarators) << DS.getSourceRange(); 5170 5171 // Mock up a declarator. 5172 Declarator Dc(DS, DeclaratorContext::Member); 5173 TypeSourceInfo *TInfo = GetTypeForDeclarator(Dc, S); 5174 assert(TInfo && "couldn't build declarator info for anonymous struct/union"); 5175 5176 // Create a declaration for this anonymous struct/union. 5177 NamedDecl *Anon = nullptr; 5178 if (RecordDecl *OwningClass = dyn_cast<RecordDecl>(Owner)) { 5179 Anon = FieldDecl::Create( 5180 Context, OwningClass, DS.getBeginLoc(), Record->getLocation(), 5181 /*IdentifierInfo=*/nullptr, Context.getTypeDeclType(Record), TInfo, 5182 /*BitWidth=*/nullptr, /*Mutable=*/false, 5183 /*InitStyle=*/ICIS_NoInit); 5184 Anon->setAccess(AS); 5185 ProcessDeclAttributes(S, Anon, Dc); 5186 5187 if (getLangOpts().CPlusPlus) 5188 FieldCollector->Add(cast<FieldDecl>(Anon)); 5189 } else { 5190 DeclSpec::SCS SCSpec = DS.getStorageClassSpec(); 5191 StorageClass SC = StorageClassSpecToVarDeclStorageClass(DS); 5192 if (SCSpec == DeclSpec::SCS_mutable) { 5193 // mutable can only appear on non-static class members, so it's always 5194 // an error here 5195 Diag(Record->getLocation(), diag::err_mutable_nonmember); 5196 Invalid = true; 5197 SC = SC_None; 5198 } 5199 5200 assert(DS.getAttributes().empty() && "No attribute expected"); 5201 Anon = VarDecl::Create(Context, Owner, DS.getBeginLoc(), 5202 Record->getLocation(), /*IdentifierInfo=*/nullptr, 5203 Context.getTypeDeclType(Record), TInfo, SC); 5204 5205 // Default-initialize the implicit variable. This initialization will be 5206 // trivial in almost all cases, except if a union member has an in-class 5207 // initializer: 5208 // union { int n = 0; }; 5209 ActOnUninitializedDecl(Anon); 5210 } 5211 Anon->setImplicit(); 5212 5213 // Mark this as an anonymous struct/union type. 5214 Record->setAnonymousStructOrUnion(true); 5215 5216 // Add the anonymous struct/union object to the current 5217 // context. We'll be referencing this object when we refer to one of 5218 // its members. 5219 Owner->addDecl(Anon); 5220 5221 // Inject the members of the anonymous struct/union into the owning 5222 // context and into the identifier resolver chain for name lookup 5223 // purposes. 5224 SmallVector<NamedDecl*, 2> Chain; 5225 Chain.push_back(Anon); 5226 5227 if (InjectAnonymousStructOrUnionMembers(*this, S, Owner, Record, AS, Chain)) 5228 Invalid = true; 5229 5230 if (VarDecl *NewVD = dyn_cast<VarDecl>(Anon)) { 5231 if (getLangOpts().CPlusPlus && NewVD->isStaticLocal()) { 5232 MangleNumberingContext *MCtx; 5233 Decl *ManglingContextDecl; 5234 std::tie(MCtx, ManglingContextDecl) = 5235 getCurrentMangleNumberContext(NewVD->getDeclContext()); 5236 if (MCtx) { 5237 Context.setManglingNumber( 5238 NewVD, MCtx->getManglingNumber( 5239 NewVD, getMSManglingNumber(getLangOpts(), S))); 5240 Context.setStaticLocalNumber(NewVD, MCtx->getStaticLocalNumber(NewVD)); 5241 } 5242 } 5243 } 5244 5245 if (Invalid) 5246 Anon->setInvalidDecl(); 5247 5248 return Anon; 5249 } 5250 5251 /// BuildMicrosoftCAnonymousStruct - Handle the declaration of an 5252 /// Microsoft C anonymous structure. 5253 /// Ref: http://msdn.microsoft.com/en-us/library/z2cx9y4f.aspx 5254 /// Example: 5255 /// 5256 /// struct A { int a; }; 5257 /// struct B { struct A; int b; }; 5258 /// 5259 /// void foo() { 5260 /// B var; 5261 /// var.a = 3; 5262 /// } 5263 /// 5264 Decl *Sema::BuildMicrosoftCAnonymousStruct(Scope *S, DeclSpec &DS, 5265 RecordDecl *Record) { 5266 assert(Record && "expected a record!"); 5267 5268 // Mock up a declarator. 5269 Declarator Dc(DS, DeclaratorContext::TypeName); 5270 TypeSourceInfo *TInfo = GetTypeForDeclarator(Dc, S); 5271 assert(TInfo && "couldn't build declarator info for anonymous struct"); 5272 5273 auto *ParentDecl = cast<RecordDecl>(CurContext); 5274 QualType RecTy = Context.getTypeDeclType(Record); 5275 5276 // Create a declaration for this anonymous struct. 5277 NamedDecl *Anon = 5278 FieldDecl::Create(Context, ParentDecl, DS.getBeginLoc(), DS.getBeginLoc(), 5279 /*IdentifierInfo=*/nullptr, RecTy, TInfo, 5280 /*BitWidth=*/nullptr, /*Mutable=*/false, 5281 /*InitStyle=*/ICIS_NoInit); 5282 Anon->setImplicit(); 5283 5284 // Add the anonymous struct object to the current context. 5285 CurContext->addDecl(Anon); 5286 5287 // Inject the members of the anonymous struct into the current 5288 // context and into the identifier resolver chain for name lookup 5289 // purposes. 5290 SmallVector<NamedDecl*, 2> Chain; 5291 Chain.push_back(Anon); 5292 5293 RecordDecl *RecordDef = Record->getDefinition(); 5294 if (RequireCompleteSizedType(Anon->getLocation(), RecTy, 5295 diag::err_field_incomplete_or_sizeless) || 5296 InjectAnonymousStructOrUnionMembers(*this, S, CurContext, RecordDef, 5297 AS_none, Chain)) { 5298 Anon->setInvalidDecl(); 5299 ParentDecl->setInvalidDecl(); 5300 } 5301 5302 return Anon; 5303 } 5304 5305 /// GetNameForDeclarator - Determine the full declaration name for the 5306 /// given Declarator. 5307 DeclarationNameInfo Sema::GetNameForDeclarator(Declarator &D) { 5308 return GetNameFromUnqualifiedId(D.getName()); 5309 } 5310 5311 /// Retrieves the declaration name from a parsed unqualified-id. 5312 DeclarationNameInfo 5313 Sema::GetNameFromUnqualifiedId(const UnqualifiedId &Name) { 5314 DeclarationNameInfo NameInfo; 5315 NameInfo.setLoc(Name.StartLocation); 5316 5317 switch (Name.getKind()) { 5318 5319 case UnqualifiedIdKind::IK_ImplicitSelfParam: 5320 case UnqualifiedIdKind::IK_Identifier: 5321 NameInfo.setName(Name.Identifier); 5322 return NameInfo; 5323 5324 case UnqualifiedIdKind::IK_DeductionGuideName: { 5325 // C++ [temp.deduct.guide]p3: 5326 // The simple-template-id shall name a class template specialization. 5327 // The template-name shall be the same identifier as the template-name 5328 // of the simple-template-id. 5329 // These together intend to imply that the template-name shall name a 5330 // class template. 5331 // FIXME: template<typename T> struct X {}; 5332 // template<typename T> using Y = X<T>; 5333 // Y(int) -> Y<int>; 5334 // satisfies these rules but does not name a class template. 5335 TemplateName TN = Name.TemplateName.get().get(); 5336 auto *Template = TN.getAsTemplateDecl(); 5337 if (!Template || !isa<ClassTemplateDecl>(Template)) { 5338 Diag(Name.StartLocation, 5339 diag::err_deduction_guide_name_not_class_template) 5340 << (int)getTemplateNameKindForDiagnostics(TN) << TN; 5341 if (Template) 5342 Diag(Template->getLocation(), diag::note_template_decl_here); 5343 return DeclarationNameInfo(); 5344 } 5345 5346 NameInfo.setName( 5347 Context.DeclarationNames.getCXXDeductionGuideName(Template)); 5348 return NameInfo; 5349 } 5350 5351 case UnqualifiedIdKind::IK_OperatorFunctionId: 5352 NameInfo.setName(Context.DeclarationNames.getCXXOperatorName( 5353 Name.OperatorFunctionId.Operator)); 5354 NameInfo.getInfo().CXXOperatorName.BeginOpNameLoc = 5355 Name.OperatorFunctionId.SymbolLocations[0].getRawEncoding(); 5356 NameInfo.getInfo().CXXOperatorName.EndOpNameLoc 5357 = Name.EndLocation.getRawEncoding(); 5358 return NameInfo; 5359 5360 case UnqualifiedIdKind::IK_LiteralOperatorId: 5361 NameInfo.setName(Context.DeclarationNames.getCXXLiteralOperatorName( 5362 Name.Identifier)); 5363 NameInfo.setCXXLiteralOperatorNameLoc(Name.EndLocation); 5364 return NameInfo; 5365 5366 case UnqualifiedIdKind::IK_ConversionFunctionId: { 5367 TypeSourceInfo *TInfo; 5368 QualType Ty = GetTypeFromParser(Name.ConversionFunctionId, &TInfo); 5369 if (Ty.isNull()) 5370 return DeclarationNameInfo(); 5371 NameInfo.setName(Context.DeclarationNames.getCXXConversionFunctionName( 5372 Context.getCanonicalType(Ty))); 5373 NameInfo.setNamedTypeInfo(TInfo); 5374 return NameInfo; 5375 } 5376 5377 case UnqualifiedIdKind::IK_ConstructorName: { 5378 TypeSourceInfo *TInfo; 5379 QualType Ty = GetTypeFromParser(Name.ConstructorName, &TInfo); 5380 if (Ty.isNull()) 5381 return DeclarationNameInfo(); 5382 NameInfo.setName(Context.DeclarationNames.getCXXConstructorName( 5383 Context.getCanonicalType(Ty))); 5384 NameInfo.setNamedTypeInfo(TInfo); 5385 return NameInfo; 5386 } 5387 5388 case UnqualifiedIdKind::IK_ConstructorTemplateId: { 5389 // In well-formed code, we can only have a constructor 5390 // template-id that refers to the current context, so go there 5391 // to find the actual type being constructed. 5392 CXXRecordDecl *CurClass = dyn_cast<CXXRecordDecl>(CurContext); 5393 if (!CurClass || CurClass->getIdentifier() != Name.TemplateId->Name) 5394 return DeclarationNameInfo(); 5395 5396 // Determine the type of the class being constructed. 5397 QualType CurClassType = Context.getTypeDeclType(CurClass); 5398 5399 // FIXME: Check two things: that the template-id names the same type as 5400 // CurClassType, and that the template-id does not occur when the name 5401 // was qualified. 5402 5403 NameInfo.setName(Context.DeclarationNames.getCXXConstructorName( 5404 Context.getCanonicalType(CurClassType))); 5405 // FIXME: should we retrieve TypeSourceInfo? 5406 NameInfo.setNamedTypeInfo(nullptr); 5407 return NameInfo; 5408 } 5409 5410 case UnqualifiedIdKind::IK_DestructorName: { 5411 TypeSourceInfo *TInfo; 5412 QualType Ty = GetTypeFromParser(Name.DestructorName, &TInfo); 5413 if (Ty.isNull()) 5414 return DeclarationNameInfo(); 5415 NameInfo.setName(Context.DeclarationNames.getCXXDestructorName( 5416 Context.getCanonicalType(Ty))); 5417 NameInfo.setNamedTypeInfo(TInfo); 5418 return NameInfo; 5419 } 5420 5421 case UnqualifiedIdKind::IK_TemplateId: { 5422 TemplateName TName = Name.TemplateId->Template.get(); 5423 SourceLocation TNameLoc = Name.TemplateId->TemplateNameLoc; 5424 return Context.getNameForTemplate(TName, TNameLoc); 5425 } 5426 5427 } // switch (Name.getKind()) 5428 5429 llvm_unreachable("Unknown name kind"); 5430 } 5431 5432 static QualType getCoreType(QualType Ty) { 5433 do { 5434 if (Ty->isPointerType() || Ty->isReferenceType()) 5435 Ty = Ty->getPointeeType(); 5436 else if (Ty->isArrayType()) 5437 Ty = Ty->castAsArrayTypeUnsafe()->getElementType(); 5438 else 5439 return Ty.withoutLocalFastQualifiers(); 5440 } while (true); 5441 } 5442 5443 /// hasSimilarParameters - Determine whether the C++ functions Declaration 5444 /// and Definition have "nearly" matching parameters. This heuristic is 5445 /// used to improve diagnostics in the case where an out-of-line function 5446 /// definition doesn't match any declaration within the class or namespace. 5447 /// Also sets Params to the list of indices to the parameters that differ 5448 /// between the declaration and the definition. If hasSimilarParameters 5449 /// returns true and Params is empty, then all of the parameters match. 5450 static bool hasSimilarParameters(ASTContext &Context, 5451 FunctionDecl *Declaration, 5452 FunctionDecl *Definition, 5453 SmallVectorImpl<unsigned> &Params) { 5454 Params.clear(); 5455 if (Declaration->param_size() != Definition->param_size()) 5456 return false; 5457 for (unsigned Idx = 0; Idx < Declaration->param_size(); ++Idx) { 5458 QualType DeclParamTy = Declaration->getParamDecl(Idx)->getType(); 5459 QualType DefParamTy = Definition->getParamDecl(Idx)->getType(); 5460 5461 // The parameter types are identical 5462 if (Context.hasSameUnqualifiedType(DefParamTy, DeclParamTy)) 5463 continue; 5464 5465 QualType DeclParamBaseTy = getCoreType(DeclParamTy); 5466 QualType DefParamBaseTy = getCoreType(DefParamTy); 5467 const IdentifierInfo *DeclTyName = DeclParamBaseTy.getBaseTypeIdentifier(); 5468 const IdentifierInfo *DefTyName = DefParamBaseTy.getBaseTypeIdentifier(); 5469 5470 if (Context.hasSameUnqualifiedType(DeclParamBaseTy, DefParamBaseTy) || 5471 (DeclTyName && DeclTyName == DefTyName)) 5472 Params.push_back(Idx); 5473 else // The two parameters aren't even close 5474 return false; 5475 } 5476 5477 return true; 5478 } 5479 5480 /// NeedsRebuildingInCurrentInstantiation - Checks whether the given 5481 /// declarator needs to be rebuilt in the current instantiation. 5482 /// Any bits of declarator which appear before the name are valid for 5483 /// consideration here. That's specifically the type in the decl spec 5484 /// and the base type in any member-pointer chunks. 5485 static bool RebuildDeclaratorInCurrentInstantiation(Sema &S, Declarator &D, 5486 DeclarationName Name) { 5487 // The types we specifically need to rebuild are: 5488 // - typenames, typeofs, and decltypes 5489 // - types which will become injected class names 5490 // Of course, we also need to rebuild any type referencing such a 5491 // type. It's safest to just say "dependent", but we call out a 5492 // few cases here. 5493 5494 DeclSpec &DS = D.getMutableDeclSpec(); 5495 switch (DS.getTypeSpecType()) { 5496 case DeclSpec::TST_typename: 5497 case DeclSpec::TST_typeofType: 5498 case DeclSpec::TST_underlyingType: 5499 case DeclSpec::TST_atomic: { 5500 // Grab the type from the parser. 5501 TypeSourceInfo *TSI = nullptr; 5502 QualType T = S.GetTypeFromParser(DS.getRepAsType(), &TSI); 5503 if (T.isNull() || !T->isInstantiationDependentType()) break; 5504 5505 // Make sure there's a type source info. This isn't really much 5506 // of a waste; most dependent types should have type source info 5507 // attached already. 5508 if (!TSI) 5509 TSI = S.Context.getTrivialTypeSourceInfo(T, DS.getTypeSpecTypeLoc()); 5510 5511 // Rebuild the type in the current instantiation. 5512 TSI = S.RebuildTypeInCurrentInstantiation(TSI, D.getIdentifierLoc(), Name); 5513 if (!TSI) return true; 5514 5515 // Store the new type back in the decl spec. 5516 ParsedType LocType = S.CreateParsedType(TSI->getType(), TSI); 5517 DS.UpdateTypeRep(LocType); 5518 break; 5519 } 5520 5521 case DeclSpec::TST_decltype: 5522 case DeclSpec::TST_typeofExpr: { 5523 Expr *E = DS.getRepAsExpr(); 5524 ExprResult Result = S.RebuildExprInCurrentInstantiation(E); 5525 if (Result.isInvalid()) return true; 5526 DS.UpdateExprRep(Result.get()); 5527 break; 5528 } 5529 5530 default: 5531 // Nothing to do for these decl specs. 5532 break; 5533 } 5534 5535 // It doesn't matter what order we do this in. 5536 for (unsigned I = 0, E = D.getNumTypeObjects(); I != E; ++I) { 5537 DeclaratorChunk &Chunk = D.getTypeObject(I); 5538 5539 // The only type information in the declarator which can come 5540 // before the declaration name is the base type of a member 5541 // pointer. 5542 if (Chunk.Kind != DeclaratorChunk::MemberPointer) 5543 continue; 5544 5545 // Rebuild the scope specifier in-place. 5546 CXXScopeSpec &SS = Chunk.Mem.Scope(); 5547 if (S.RebuildNestedNameSpecifierInCurrentInstantiation(SS)) 5548 return true; 5549 } 5550 5551 return false; 5552 } 5553 5554 Decl *Sema::ActOnDeclarator(Scope *S, Declarator &D) { 5555 D.setFunctionDefinitionKind(FunctionDefinitionKind::Declaration); 5556 Decl *Dcl = HandleDeclarator(S, D, MultiTemplateParamsArg()); 5557 5558 if (OriginalLexicalContext && OriginalLexicalContext->isObjCContainer() && 5559 Dcl && Dcl->getDeclContext()->isFileContext()) 5560 Dcl->setTopLevelDeclInObjCContainer(); 5561 5562 if (getLangOpts().OpenCL) 5563 setCurrentOpenCLExtensionForDecl(Dcl); 5564 5565 return Dcl; 5566 } 5567 5568 /// DiagnoseClassNameShadow - Implement C++ [class.mem]p13: 5569 /// If T is the name of a class, then each of the following shall have a 5570 /// name different from T: 5571 /// - every static data member of class T; 5572 /// - every member function of class T 5573 /// - every member of class T that is itself a type; 5574 /// \returns true if the declaration name violates these rules. 5575 bool Sema::DiagnoseClassNameShadow(DeclContext *DC, 5576 DeclarationNameInfo NameInfo) { 5577 DeclarationName Name = NameInfo.getName(); 5578 5579 CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(DC); 5580 while (Record && Record->isAnonymousStructOrUnion()) 5581 Record = dyn_cast<CXXRecordDecl>(Record->getParent()); 5582 if (Record && Record->getIdentifier() && Record->getDeclName() == Name) { 5583 Diag(NameInfo.getLoc(), diag::err_member_name_of_class) << Name; 5584 return true; 5585 } 5586 5587 return false; 5588 } 5589 5590 /// Diagnose a declaration whose declarator-id has the given 5591 /// nested-name-specifier. 5592 /// 5593 /// \param SS The nested-name-specifier of the declarator-id. 5594 /// 5595 /// \param DC The declaration context to which the nested-name-specifier 5596 /// resolves. 5597 /// 5598 /// \param Name The name of the entity being declared. 5599 /// 5600 /// \param Loc The location of the name of the entity being declared. 5601 /// 5602 /// \param IsTemplateId Whether the name is a (simple-)template-id, and thus 5603 /// we're declaring an explicit / partial specialization / instantiation. 5604 /// 5605 /// \returns true if we cannot safely recover from this error, false otherwise. 5606 bool Sema::diagnoseQualifiedDeclaration(CXXScopeSpec &SS, DeclContext *DC, 5607 DeclarationName Name, 5608 SourceLocation Loc, bool IsTemplateId) { 5609 DeclContext *Cur = CurContext; 5610 while (isa<LinkageSpecDecl>(Cur) || isa<CapturedDecl>(Cur)) 5611 Cur = Cur->getParent(); 5612 5613 // If the user provided a superfluous scope specifier that refers back to the 5614 // class in which the entity is already declared, diagnose and ignore it. 5615 // 5616 // class X { 5617 // void X::f(); 5618 // }; 5619 // 5620 // Note, it was once ill-formed to give redundant qualification in all 5621 // contexts, but that rule was removed by DR482. 5622 if (Cur->Equals(DC)) { 5623 if (Cur->isRecord()) { 5624 Diag(Loc, LangOpts.MicrosoftExt ? diag::warn_member_extra_qualification 5625 : diag::err_member_extra_qualification) 5626 << Name << FixItHint::CreateRemoval(SS.getRange()); 5627 SS.clear(); 5628 } else { 5629 Diag(Loc, diag::warn_namespace_member_extra_qualification) << Name; 5630 } 5631 return false; 5632 } 5633 5634 // Check whether the qualifying scope encloses the scope of the original 5635 // declaration. For a template-id, we perform the checks in 5636 // CheckTemplateSpecializationScope. 5637 if (!Cur->Encloses(DC) && !IsTemplateId) { 5638 if (Cur->isRecord()) 5639 Diag(Loc, diag::err_member_qualification) 5640 << Name << SS.getRange(); 5641 else if (isa<TranslationUnitDecl>(DC)) 5642 Diag(Loc, diag::err_invalid_declarator_global_scope) 5643 << Name << SS.getRange(); 5644 else if (isa<FunctionDecl>(Cur)) 5645 Diag(Loc, diag::err_invalid_declarator_in_function) 5646 << Name << SS.getRange(); 5647 else if (isa<BlockDecl>(Cur)) 5648 Diag(Loc, diag::err_invalid_declarator_in_block) 5649 << Name << SS.getRange(); 5650 else 5651 Diag(Loc, diag::err_invalid_declarator_scope) 5652 << Name << cast<NamedDecl>(Cur) << cast<NamedDecl>(DC) << SS.getRange(); 5653 5654 return true; 5655 } 5656 5657 if (Cur->isRecord()) { 5658 // Cannot qualify members within a class. 5659 Diag(Loc, diag::err_member_qualification) 5660 << Name << SS.getRange(); 5661 SS.clear(); 5662 5663 // C++ constructors and destructors with incorrect scopes can break 5664 // our AST invariants by having the wrong underlying types. If 5665 // that's the case, then drop this declaration entirely. 5666 if ((Name.getNameKind() == DeclarationName::CXXConstructorName || 5667 Name.getNameKind() == DeclarationName::CXXDestructorName) && 5668 !Context.hasSameType(Name.getCXXNameType(), 5669 Context.getTypeDeclType(cast<CXXRecordDecl>(Cur)))) 5670 return true; 5671 5672 return false; 5673 } 5674 5675 // C++11 [dcl.meaning]p1: 5676 // [...] "The nested-name-specifier of the qualified declarator-id shall 5677 // not begin with a decltype-specifer" 5678 NestedNameSpecifierLoc SpecLoc(SS.getScopeRep(), SS.location_data()); 5679 while (SpecLoc.getPrefix()) 5680 SpecLoc = SpecLoc.getPrefix(); 5681 if (dyn_cast_or_null<DecltypeType>( 5682 SpecLoc.getNestedNameSpecifier()->getAsType())) 5683 Diag(Loc, diag::err_decltype_in_declarator) 5684 << SpecLoc.getTypeLoc().getSourceRange(); 5685 5686 return false; 5687 } 5688 5689 NamedDecl *Sema::HandleDeclarator(Scope *S, Declarator &D, 5690 MultiTemplateParamsArg TemplateParamLists) { 5691 // TODO: consider using NameInfo for diagnostic. 5692 DeclarationNameInfo NameInfo = GetNameForDeclarator(D); 5693 DeclarationName Name = NameInfo.getName(); 5694 5695 // All of these full declarators require an identifier. If it doesn't have 5696 // one, the ParsedFreeStandingDeclSpec action should be used. 5697 if (D.isDecompositionDeclarator()) { 5698 return ActOnDecompositionDeclarator(S, D, TemplateParamLists); 5699 } else if (!Name) { 5700 if (!D.isInvalidType()) // Reject this if we think it is valid. 5701 Diag(D.getDeclSpec().getBeginLoc(), diag::err_declarator_need_ident) 5702 << D.getDeclSpec().getSourceRange() << D.getSourceRange(); 5703 return nullptr; 5704 } else if (DiagnoseUnexpandedParameterPack(NameInfo, UPPC_DeclarationType)) 5705 return nullptr; 5706 5707 // The scope passed in may not be a decl scope. Zip up the scope tree until 5708 // we find one that is. 5709 while ((S->getFlags() & Scope::DeclScope) == 0 || 5710 (S->getFlags() & Scope::TemplateParamScope) != 0) 5711 S = S->getParent(); 5712 5713 DeclContext *DC = CurContext; 5714 if (D.getCXXScopeSpec().isInvalid()) 5715 D.setInvalidType(); 5716 else if (D.getCXXScopeSpec().isSet()) { 5717 if (DiagnoseUnexpandedParameterPack(D.getCXXScopeSpec(), 5718 UPPC_DeclarationQualifier)) 5719 return nullptr; 5720 5721 bool EnteringContext = !D.getDeclSpec().isFriendSpecified(); 5722 DC = computeDeclContext(D.getCXXScopeSpec(), EnteringContext); 5723 if (!DC || isa<EnumDecl>(DC)) { 5724 // If we could not compute the declaration context, it's because the 5725 // declaration context is dependent but does not refer to a class, 5726 // class template, or class template partial specialization. Complain 5727 // and return early, to avoid the coming semantic disaster. 5728 Diag(D.getIdentifierLoc(), 5729 diag::err_template_qualified_declarator_no_match) 5730 << D.getCXXScopeSpec().getScopeRep() 5731 << D.getCXXScopeSpec().getRange(); 5732 return nullptr; 5733 } 5734 bool IsDependentContext = DC->isDependentContext(); 5735 5736 if (!IsDependentContext && 5737 RequireCompleteDeclContext(D.getCXXScopeSpec(), DC)) 5738 return nullptr; 5739 5740 // If a class is incomplete, do not parse entities inside it. 5741 if (isa<CXXRecordDecl>(DC) && !cast<CXXRecordDecl>(DC)->hasDefinition()) { 5742 Diag(D.getIdentifierLoc(), 5743 diag::err_member_def_undefined_record) 5744 << Name << DC << D.getCXXScopeSpec().getRange(); 5745 return nullptr; 5746 } 5747 if (!D.getDeclSpec().isFriendSpecified()) { 5748 if (diagnoseQualifiedDeclaration( 5749 D.getCXXScopeSpec(), DC, Name, D.getIdentifierLoc(), 5750 D.getName().getKind() == UnqualifiedIdKind::IK_TemplateId)) { 5751 if (DC->isRecord()) 5752 return nullptr; 5753 5754 D.setInvalidType(); 5755 } 5756 } 5757 5758 // Check whether we need to rebuild the type of the given 5759 // declaration in the current instantiation. 5760 if (EnteringContext && IsDependentContext && 5761 TemplateParamLists.size() != 0) { 5762 ContextRAII SavedContext(*this, DC); 5763 if (RebuildDeclaratorInCurrentInstantiation(*this, D, Name)) 5764 D.setInvalidType(); 5765 } 5766 } 5767 5768 TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S); 5769 QualType R = TInfo->getType(); 5770 5771 if (DiagnoseUnexpandedParameterPack(D.getIdentifierLoc(), TInfo, 5772 UPPC_DeclarationType)) 5773 D.setInvalidType(); 5774 5775 LookupResult Previous(*this, NameInfo, LookupOrdinaryName, 5776 forRedeclarationInCurContext()); 5777 5778 // See if this is a redefinition of a variable in the same scope. 5779 if (!D.getCXXScopeSpec().isSet()) { 5780 bool IsLinkageLookup = false; 5781 bool CreateBuiltins = false; 5782 5783 // If the declaration we're planning to build will be a function 5784 // or object with linkage, then look for another declaration with 5785 // linkage (C99 6.2.2p4-5 and C++ [basic.link]p6). 5786 // 5787 // If the declaration we're planning to build will be declared with 5788 // external linkage in the translation unit, create any builtin with 5789 // the same name. 5790 if (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_typedef) 5791 /* Do nothing*/; 5792 else if (CurContext->isFunctionOrMethod() && 5793 (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_extern || 5794 R->isFunctionType())) { 5795 IsLinkageLookup = true; 5796 CreateBuiltins = 5797 CurContext->getEnclosingNamespaceContext()->isTranslationUnit(); 5798 } else if (CurContext->getRedeclContext()->isTranslationUnit() && 5799 D.getDeclSpec().getStorageClassSpec() != DeclSpec::SCS_static) 5800 CreateBuiltins = true; 5801 5802 if (IsLinkageLookup) { 5803 Previous.clear(LookupRedeclarationWithLinkage); 5804 Previous.setRedeclarationKind(ForExternalRedeclaration); 5805 } 5806 5807 LookupName(Previous, S, CreateBuiltins); 5808 } else { // Something like "int foo::x;" 5809 LookupQualifiedName(Previous, DC); 5810 5811 // C++ [dcl.meaning]p1: 5812 // When the declarator-id is qualified, the declaration shall refer to a 5813 // previously declared member of the class or namespace to which the 5814 // qualifier refers (or, in the case of a namespace, of an element of the 5815 // inline namespace set of that namespace (7.3.1)) or to a specialization 5816 // thereof; [...] 5817 // 5818 // Note that we already checked the context above, and that we do not have 5819 // enough information to make sure that Previous contains the declaration 5820 // we want to match. For example, given: 5821 // 5822 // class X { 5823 // void f(); 5824 // void f(float); 5825 // }; 5826 // 5827 // void X::f(int) { } // ill-formed 5828 // 5829 // In this case, Previous will point to the overload set 5830 // containing the two f's declared in X, but neither of them 5831 // matches. 5832 5833 // C++ [dcl.meaning]p1: 5834 // [...] the member shall not merely have been introduced by a 5835 // using-declaration in the scope of the class or namespace nominated by 5836 // the nested-name-specifier of the declarator-id. 5837 RemoveUsingDecls(Previous); 5838 } 5839 5840 if (Previous.isSingleResult() && 5841 Previous.getFoundDecl()->isTemplateParameter()) { 5842 // Maybe we will complain about the shadowed template parameter. 5843 if (!D.isInvalidType()) 5844 DiagnoseTemplateParameterShadow(D.getIdentifierLoc(), 5845 Previous.getFoundDecl()); 5846 5847 // Just pretend that we didn't see the previous declaration. 5848 Previous.clear(); 5849 } 5850 5851 if (!R->isFunctionType() && DiagnoseClassNameShadow(DC, NameInfo)) 5852 // Forget that the previous declaration is the injected-class-name. 5853 Previous.clear(); 5854 5855 // In C++, the previous declaration we find might be a tag type 5856 // (class or enum). In this case, the new declaration will hide the 5857 // tag type. Note that this applies to functions, function templates, and 5858 // variables, but not to typedefs (C++ [dcl.typedef]p4) or variable templates. 5859 if (Previous.isSingleTagDecl() && 5860 D.getDeclSpec().getStorageClassSpec() != DeclSpec::SCS_typedef && 5861 (TemplateParamLists.size() == 0 || R->isFunctionType())) 5862 Previous.clear(); 5863 5864 // Check that there are no default arguments other than in the parameters 5865 // of a function declaration (C++ only). 5866 if (getLangOpts().CPlusPlus) 5867 CheckExtraCXXDefaultArguments(D); 5868 5869 NamedDecl *New; 5870 5871 bool AddToScope = true; 5872 if (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_typedef) { 5873 if (TemplateParamLists.size()) { 5874 Diag(D.getIdentifierLoc(), diag::err_template_typedef); 5875 return nullptr; 5876 } 5877 5878 New = ActOnTypedefDeclarator(S, D, DC, TInfo, Previous); 5879 } else if (R->isFunctionType()) { 5880 New = ActOnFunctionDeclarator(S, D, DC, TInfo, Previous, 5881 TemplateParamLists, 5882 AddToScope); 5883 } else { 5884 New = ActOnVariableDeclarator(S, D, DC, TInfo, Previous, TemplateParamLists, 5885 AddToScope); 5886 } 5887 5888 if (!New) 5889 return nullptr; 5890 5891 // If this has an identifier and is not a function template specialization, 5892 // add it to the scope stack. 5893 if (New->getDeclName() && AddToScope) 5894 PushOnScopeChains(New, S); 5895 5896 if (isInOpenMPDeclareTargetContext()) 5897 checkDeclIsAllowedInOpenMPTarget(nullptr, New); 5898 5899 return New; 5900 } 5901 5902 /// Helper method to turn variable array types into constant array 5903 /// types in certain situations which would otherwise be errors (for 5904 /// GCC compatibility). 5905 static QualType TryToFixInvalidVariablyModifiedType(QualType T, 5906 ASTContext &Context, 5907 bool &SizeIsNegative, 5908 llvm::APSInt &Oversized) { 5909 // This method tries to turn a variable array into a constant 5910 // array even when the size isn't an ICE. This is necessary 5911 // for compatibility with code that depends on gcc's buggy 5912 // constant expression folding, like struct {char x[(int)(char*)2];} 5913 SizeIsNegative = false; 5914 Oversized = 0; 5915 5916 if (T->isDependentType()) 5917 return QualType(); 5918 5919 QualifierCollector Qs; 5920 const Type *Ty = Qs.strip(T); 5921 5922 if (const PointerType* PTy = dyn_cast<PointerType>(Ty)) { 5923 QualType Pointee = PTy->getPointeeType(); 5924 QualType FixedType = 5925 TryToFixInvalidVariablyModifiedType(Pointee, Context, SizeIsNegative, 5926 Oversized); 5927 if (FixedType.isNull()) return FixedType; 5928 FixedType = Context.getPointerType(FixedType); 5929 return Qs.apply(Context, FixedType); 5930 } 5931 if (const ParenType* PTy = dyn_cast<ParenType>(Ty)) { 5932 QualType Inner = PTy->getInnerType(); 5933 QualType FixedType = 5934 TryToFixInvalidVariablyModifiedType(Inner, Context, SizeIsNegative, 5935 Oversized); 5936 if (FixedType.isNull()) return FixedType; 5937 FixedType = Context.getParenType(FixedType); 5938 return Qs.apply(Context, FixedType); 5939 } 5940 5941 const VariableArrayType* VLATy = dyn_cast<VariableArrayType>(T); 5942 if (!VLATy) 5943 return QualType(); 5944 5945 QualType ElemTy = VLATy->getElementType(); 5946 if (ElemTy->isVariablyModifiedType()) { 5947 ElemTy = TryToFixInvalidVariablyModifiedType(ElemTy, Context, 5948 SizeIsNegative, Oversized); 5949 if (ElemTy.isNull()) 5950 return QualType(); 5951 } 5952 5953 Expr::EvalResult Result; 5954 if (!VLATy->getSizeExpr() || 5955 !VLATy->getSizeExpr()->EvaluateAsInt(Result, Context)) 5956 return QualType(); 5957 5958 llvm::APSInt Res = Result.Val.getInt(); 5959 5960 // Check whether the array size is negative. 5961 if (Res.isSigned() && Res.isNegative()) { 5962 SizeIsNegative = true; 5963 return QualType(); 5964 } 5965 5966 // Check whether the array is too large to be addressed. 5967 unsigned ActiveSizeBits = 5968 (!ElemTy->isDependentType() && !ElemTy->isVariablyModifiedType() && 5969 !ElemTy->isIncompleteType() && !ElemTy->isUndeducedType()) 5970 ? ConstantArrayType::getNumAddressingBits(Context, ElemTy, Res) 5971 : Res.getActiveBits(); 5972 if (ActiveSizeBits > ConstantArrayType::getMaxSizeBits(Context)) { 5973 Oversized = Res; 5974 return QualType(); 5975 } 5976 5977 QualType FoldedArrayType = Context.getConstantArrayType( 5978 ElemTy, Res, VLATy->getSizeExpr(), ArrayType::Normal, 0); 5979 return Qs.apply(Context, FoldedArrayType); 5980 } 5981 5982 static void 5983 FixInvalidVariablyModifiedTypeLoc(TypeLoc SrcTL, TypeLoc DstTL) { 5984 SrcTL = SrcTL.getUnqualifiedLoc(); 5985 DstTL = DstTL.getUnqualifiedLoc(); 5986 if (PointerTypeLoc SrcPTL = SrcTL.getAs<PointerTypeLoc>()) { 5987 PointerTypeLoc DstPTL = DstTL.castAs<PointerTypeLoc>(); 5988 FixInvalidVariablyModifiedTypeLoc(SrcPTL.getPointeeLoc(), 5989 DstPTL.getPointeeLoc()); 5990 DstPTL.setStarLoc(SrcPTL.getStarLoc()); 5991 return; 5992 } 5993 if (ParenTypeLoc SrcPTL = SrcTL.getAs<ParenTypeLoc>()) { 5994 ParenTypeLoc DstPTL = DstTL.castAs<ParenTypeLoc>(); 5995 FixInvalidVariablyModifiedTypeLoc(SrcPTL.getInnerLoc(), 5996 DstPTL.getInnerLoc()); 5997 DstPTL.setLParenLoc(SrcPTL.getLParenLoc()); 5998 DstPTL.setRParenLoc(SrcPTL.getRParenLoc()); 5999 return; 6000 } 6001 ArrayTypeLoc SrcATL = SrcTL.castAs<ArrayTypeLoc>(); 6002 ArrayTypeLoc DstATL = DstTL.castAs<ArrayTypeLoc>(); 6003 TypeLoc SrcElemTL = SrcATL.getElementLoc(); 6004 TypeLoc DstElemTL = DstATL.getElementLoc(); 6005 if (VariableArrayTypeLoc SrcElemATL = 6006 SrcElemTL.getAs<VariableArrayTypeLoc>()) { 6007 ConstantArrayTypeLoc DstElemATL = DstElemTL.castAs<ConstantArrayTypeLoc>(); 6008 FixInvalidVariablyModifiedTypeLoc(SrcElemATL, DstElemATL); 6009 } else { 6010 DstElemTL.initializeFullCopy(SrcElemTL); 6011 } 6012 DstATL.setLBracketLoc(SrcATL.getLBracketLoc()); 6013 DstATL.setSizeExpr(SrcATL.getSizeExpr()); 6014 DstATL.setRBracketLoc(SrcATL.getRBracketLoc()); 6015 } 6016 6017 /// Helper method to turn variable array types into constant array 6018 /// types in certain situations which would otherwise be errors (for 6019 /// GCC compatibility). 6020 static TypeSourceInfo* 6021 TryToFixInvalidVariablyModifiedTypeSourceInfo(TypeSourceInfo *TInfo, 6022 ASTContext &Context, 6023 bool &SizeIsNegative, 6024 llvm::APSInt &Oversized) { 6025 QualType FixedTy 6026 = TryToFixInvalidVariablyModifiedType(TInfo->getType(), Context, 6027 SizeIsNegative, Oversized); 6028 if (FixedTy.isNull()) 6029 return nullptr; 6030 TypeSourceInfo *FixedTInfo = Context.getTrivialTypeSourceInfo(FixedTy); 6031 FixInvalidVariablyModifiedTypeLoc(TInfo->getTypeLoc(), 6032 FixedTInfo->getTypeLoc()); 6033 return FixedTInfo; 6034 } 6035 6036 /// Attempt to fold a variable-sized type to a constant-sized type, returning 6037 /// true if we were successful. 6038 static bool tryToFixVariablyModifiedVarType(Sema &S, TypeSourceInfo *&TInfo, 6039 QualType &T, SourceLocation Loc, 6040 unsigned FailedFoldDiagID) { 6041 bool SizeIsNegative; 6042 llvm::APSInt Oversized; 6043 TypeSourceInfo *FixedTInfo = TryToFixInvalidVariablyModifiedTypeSourceInfo( 6044 TInfo, S.Context, SizeIsNegative, Oversized); 6045 if (FixedTInfo) { 6046 S.Diag(Loc, diag::ext_vla_folded_to_constant); 6047 TInfo = FixedTInfo; 6048 T = FixedTInfo->getType(); 6049 return true; 6050 } 6051 6052 if (SizeIsNegative) 6053 S.Diag(Loc, diag::err_typecheck_negative_array_size); 6054 else if (Oversized.getBoolValue()) 6055 S.Diag(Loc, diag::err_array_too_large) << Oversized.toString(10); 6056 else if (FailedFoldDiagID) 6057 S.Diag(Loc, FailedFoldDiagID); 6058 return false; 6059 } 6060 6061 /// Register the given locally-scoped extern "C" declaration so 6062 /// that it can be found later for redeclarations. We include any extern "C" 6063 /// declaration that is not visible in the translation unit here, not just 6064 /// function-scope declarations. 6065 void 6066 Sema::RegisterLocallyScopedExternCDecl(NamedDecl *ND, Scope *S) { 6067 if (!getLangOpts().CPlusPlus && 6068 ND->getLexicalDeclContext()->getRedeclContext()->isTranslationUnit()) 6069 // Don't need to track declarations in the TU in C. 6070 return; 6071 6072 // Note that we have a locally-scoped external with this name. 6073 Context.getExternCContextDecl()->makeDeclVisibleInContext(ND); 6074 } 6075 6076 NamedDecl *Sema::findLocallyScopedExternCDecl(DeclarationName Name) { 6077 // FIXME: We can have multiple results via __attribute__((overloadable)). 6078 auto Result = Context.getExternCContextDecl()->lookup(Name); 6079 return Result.empty() ? nullptr : *Result.begin(); 6080 } 6081 6082 /// Diagnose function specifiers on a declaration of an identifier that 6083 /// does not identify a function. 6084 void Sema::DiagnoseFunctionSpecifiers(const DeclSpec &DS) { 6085 // FIXME: We should probably indicate the identifier in question to avoid 6086 // confusion for constructs like "virtual int a(), b;" 6087 if (DS.isVirtualSpecified()) 6088 Diag(DS.getVirtualSpecLoc(), 6089 diag::err_virtual_non_function); 6090 6091 if (DS.hasExplicitSpecifier()) 6092 Diag(DS.getExplicitSpecLoc(), 6093 diag::err_explicit_non_function); 6094 6095 if (DS.isNoreturnSpecified()) 6096 Diag(DS.getNoreturnSpecLoc(), 6097 diag::err_noreturn_non_function); 6098 } 6099 6100 NamedDecl* 6101 Sema::ActOnTypedefDeclarator(Scope* S, Declarator& D, DeclContext* DC, 6102 TypeSourceInfo *TInfo, LookupResult &Previous) { 6103 // Typedef declarators cannot be qualified (C++ [dcl.meaning]p1). 6104 if (D.getCXXScopeSpec().isSet()) { 6105 Diag(D.getIdentifierLoc(), diag::err_qualified_typedef_declarator) 6106 << D.getCXXScopeSpec().getRange(); 6107 D.setInvalidType(); 6108 // Pretend we didn't see the scope specifier. 6109 DC = CurContext; 6110 Previous.clear(); 6111 } 6112 6113 DiagnoseFunctionSpecifiers(D.getDeclSpec()); 6114 6115 if (D.getDeclSpec().isInlineSpecified()) 6116 Diag(D.getDeclSpec().getInlineSpecLoc(), diag::err_inline_non_function) 6117 << getLangOpts().CPlusPlus17; 6118 if (D.getDeclSpec().hasConstexprSpecifier()) 6119 Diag(D.getDeclSpec().getConstexprSpecLoc(), diag::err_invalid_constexpr) 6120 << 1 << static_cast<int>(D.getDeclSpec().getConstexprSpecifier()); 6121 6122 if (D.getName().Kind != UnqualifiedIdKind::IK_Identifier) { 6123 if (D.getName().Kind == UnqualifiedIdKind::IK_DeductionGuideName) 6124 Diag(D.getName().StartLocation, 6125 diag::err_deduction_guide_invalid_specifier) 6126 << "typedef"; 6127 else 6128 Diag(D.getName().StartLocation, diag::err_typedef_not_identifier) 6129 << D.getName().getSourceRange(); 6130 return nullptr; 6131 } 6132 6133 TypedefDecl *NewTD = ParseTypedefDecl(S, D, TInfo->getType(), TInfo); 6134 if (!NewTD) return nullptr; 6135 6136 // Handle attributes prior to checking for duplicates in MergeVarDecl 6137 ProcessDeclAttributes(S, NewTD, D); 6138 6139 CheckTypedefForVariablyModifiedType(S, NewTD); 6140 6141 bool Redeclaration = D.isRedeclaration(); 6142 NamedDecl *ND = ActOnTypedefNameDecl(S, DC, NewTD, Previous, Redeclaration); 6143 D.setRedeclaration(Redeclaration); 6144 return ND; 6145 } 6146 6147 void 6148 Sema::CheckTypedefForVariablyModifiedType(Scope *S, TypedefNameDecl *NewTD) { 6149 // C99 6.7.7p2: If a typedef name specifies a variably modified type 6150 // then it shall have block scope. 6151 // Note that variably modified types must be fixed before merging the decl so 6152 // that redeclarations will match. 6153 TypeSourceInfo *TInfo = NewTD->getTypeSourceInfo(); 6154 QualType T = TInfo->getType(); 6155 if (T->isVariablyModifiedType()) { 6156 setFunctionHasBranchProtectedScope(); 6157 6158 if (S->getFnParent() == nullptr) { 6159 bool SizeIsNegative; 6160 llvm::APSInt Oversized; 6161 TypeSourceInfo *FixedTInfo = 6162 TryToFixInvalidVariablyModifiedTypeSourceInfo(TInfo, Context, 6163 SizeIsNegative, 6164 Oversized); 6165 if (FixedTInfo) { 6166 Diag(NewTD->getLocation(), diag::ext_vla_folded_to_constant); 6167 NewTD->setTypeSourceInfo(FixedTInfo); 6168 } else { 6169 if (SizeIsNegative) 6170 Diag(NewTD->getLocation(), diag::err_typecheck_negative_array_size); 6171 else if (T->isVariableArrayType()) 6172 Diag(NewTD->getLocation(), diag::err_vla_decl_in_file_scope); 6173 else if (Oversized.getBoolValue()) 6174 Diag(NewTD->getLocation(), diag::err_array_too_large) 6175 << Oversized.toString(10); 6176 else 6177 Diag(NewTD->getLocation(), diag::err_vm_decl_in_file_scope); 6178 NewTD->setInvalidDecl(); 6179 } 6180 } 6181 } 6182 } 6183 6184 /// ActOnTypedefNameDecl - Perform semantic checking for a declaration which 6185 /// declares a typedef-name, either using the 'typedef' type specifier or via 6186 /// a C++0x [dcl.typedef]p2 alias-declaration: 'using T = A;'. 6187 NamedDecl* 6188 Sema::ActOnTypedefNameDecl(Scope *S, DeclContext *DC, TypedefNameDecl *NewTD, 6189 LookupResult &Previous, bool &Redeclaration) { 6190 6191 // Find the shadowed declaration before filtering for scope. 6192 NamedDecl *ShadowedDecl = getShadowedDeclaration(NewTD, Previous); 6193 6194 // Merge the decl with the existing one if appropriate. If the decl is 6195 // in an outer scope, it isn't the same thing. 6196 FilterLookupForScope(Previous, DC, S, /*ConsiderLinkage*/false, 6197 /*AllowInlineNamespace*/false); 6198 filterNonConflictingPreviousTypedefDecls(*this, NewTD, Previous); 6199 if (!Previous.empty()) { 6200 Redeclaration = true; 6201 MergeTypedefNameDecl(S, NewTD, Previous); 6202 } else { 6203 inferGslPointerAttribute(NewTD); 6204 } 6205 6206 if (ShadowedDecl && !Redeclaration) 6207 CheckShadow(NewTD, ShadowedDecl, Previous); 6208 6209 // If this is the C FILE type, notify the AST context. 6210 if (IdentifierInfo *II = NewTD->getIdentifier()) 6211 if (!NewTD->isInvalidDecl() && 6212 NewTD->getDeclContext()->getRedeclContext()->isTranslationUnit()) { 6213 if (II->isStr("FILE")) 6214 Context.setFILEDecl(NewTD); 6215 else if (II->isStr("jmp_buf")) 6216 Context.setjmp_bufDecl(NewTD); 6217 else if (II->isStr("sigjmp_buf")) 6218 Context.setsigjmp_bufDecl(NewTD); 6219 else if (II->isStr("ucontext_t")) 6220 Context.setucontext_tDecl(NewTD); 6221 } 6222 6223 return NewTD; 6224 } 6225 6226 /// Determines whether the given declaration is an out-of-scope 6227 /// previous declaration. 6228 /// 6229 /// This routine should be invoked when name lookup has found a 6230 /// previous declaration (PrevDecl) that is not in the scope where a 6231 /// new declaration by the same name is being introduced. If the new 6232 /// declaration occurs in a local scope, previous declarations with 6233 /// linkage may still be considered previous declarations (C99 6234 /// 6.2.2p4-5, C++ [basic.link]p6). 6235 /// 6236 /// \param PrevDecl the previous declaration found by name 6237 /// lookup 6238 /// 6239 /// \param DC the context in which the new declaration is being 6240 /// declared. 6241 /// 6242 /// \returns true if PrevDecl is an out-of-scope previous declaration 6243 /// for a new delcaration with the same name. 6244 static bool 6245 isOutOfScopePreviousDeclaration(NamedDecl *PrevDecl, DeclContext *DC, 6246 ASTContext &Context) { 6247 if (!PrevDecl) 6248 return false; 6249 6250 if (!PrevDecl->hasLinkage()) 6251 return false; 6252 6253 if (Context.getLangOpts().CPlusPlus) { 6254 // C++ [basic.link]p6: 6255 // If there is a visible declaration of an entity with linkage 6256 // having the same name and type, ignoring entities declared 6257 // outside the innermost enclosing namespace scope, the block 6258 // scope declaration declares that same entity and receives the 6259 // linkage of the previous declaration. 6260 DeclContext *OuterContext = DC->getRedeclContext(); 6261 if (!OuterContext->isFunctionOrMethod()) 6262 // This rule only applies to block-scope declarations. 6263 return false; 6264 6265 DeclContext *PrevOuterContext = PrevDecl->getDeclContext(); 6266 if (PrevOuterContext->isRecord()) 6267 // We found a member function: ignore it. 6268 return false; 6269 6270 // Find the innermost enclosing namespace for the new and 6271 // previous declarations. 6272 OuterContext = OuterContext->getEnclosingNamespaceContext(); 6273 PrevOuterContext = PrevOuterContext->getEnclosingNamespaceContext(); 6274 6275 // The previous declaration is in a different namespace, so it 6276 // isn't the same function. 6277 if (!OuterContext->Equals(PrevOuterContext)) 6278 return false; 6279 } 6280 6281 return true; 6282 } 6283 6284 static void SetNestedNameSpecifier(Sema &S, DeclaratorDecl *DD, Declarator &D) { 6285 CXXScopeSpec &SS = D.getCXXScopeSpec(); 6286 if (!SS.isSet()) return; 6287 DD->setQualifierInfo(SS.getWithLocInContext(S.Context)); 6288 } 6289 6290 bool Sema::inferObjCARCLifetime(ValueDecl *decl) { 6291 QualType type = decl->getType(); 6292 Qualifiers::ObjCLifetime lifetime = type.getObjCLifetime(); 6293 if (lifetime == Qualifiers::OCL_Autoreleasing) { 6294 // Various kinds of declaration aren't allowed to be __autoreleasing. 6295 unsigned kind = -1U; 6296 if (VarDecl *var = dyn_cast<VarDecl>(decl)) { 6297 if (var->hasAttr<BlocksAttr>()) 6298 kind = 0; // __block 6299 else if (!var->hasLocalStorage()) 6300 kind = 1; // global 6301 } else if (isa<ObjCIvarDecl>(decl)) { 6302 kind = 3; // ivar 6303 } else if (isa<FieldDecl>(decl)) { 6304 kind = 2; // field 6305 } 6306 6307 if (kind != -1U) { 6308 Diag(decl->getLocation(), diag::err_arc_autoreleasing_var) 6309 << kind; 6310 } 6311 } else if (lifetime == Qualifiers::OCL_None) { 6312 // Try to infer lifetime. 6313 if (!type->isObjCLifetimeType()) 6314 return false; 6315 6316 lifetime = type->getObjCARCImplicitLifetime(); 6317 type = Context.getLifetimeQualifiedType(type, lifetime); 6318 decl->setType(type); 6319 } 6320 6321 if (VarDecl *var = dyn_cast<VarDecl>(decl)) { 6322 // Thread-local variables cannot have lifetime. 6323 if (lifetime && lifetime != Qualifiers::OCL_ExplicitNone && 6324 var->getTLSKind()) { 6325 Diag(var->getLocation(), diag::err_arc_thread_ownership) 6326 << var->getType(); 6327 return true; 6328 } 6329 } 6330 6331 return false; 6332 } 6333 6334 void Sema::deduceOpenCLAddressSpace(ValueDecl *Decl) { 6335 if (Decl->getType().hasAddressSpace()) 6336 return; 6337 if (Decl->getType()->isDependentType()) 6338 return; 6339 if (VarDecl *Var = dyn_cast<VarDecl>(Decl)) { 6340 QualType Type = Var->getType(); 6341 if (Type->isSamplerT() || Type->isVoidType()) 6342 return; 6343 LangAS ImplAS = LangAS::opencl_private; 6344 if ((getLangOpts().OpenCLCPlusPlus || getLangOpts().OpenCLVersion >= 200) && 6345 Var->hasGlobalStorage()) 6346 ImplAS = LangAS::opencl_global; 6347 // If the original type from a decayed type is an array type and that array 6348 // type has no address space yet, deduce it now. 6349 if (auto DT = dyn_cast<DecayedType>(Type)) { 6350 auto OrigTy = DT->getOriginalType(); 6351 if (!OrigTy.hasAddressSpace() && OrigTy->isArrayType()) { 6352 // Add the address space to the original array type and then propagate 6353 // that to the element type through `getAsArrayType`. 6354 OrigTy = Context.getAddrSpaceQualType(OrigTy, ImplAS); 6355 OrigTy = QualType(Context.getAsArrayType(OrigTy), 0); 6356 // Re-generate the decayed type. 6357 Type = Context.getDecayedType(OrigTy); 6358 } 6359 } 6360 Type = Context.getAddrSpaceQualType(Type, ImplAS); 6361 // Apply any qualifiers (including address space) from the array type to 6362 // the element type. This implements C99 6.7.3p8: "If the specification of 6363 // an array type includes any type qualifiers, the element type is so 6364 // qualified, not the array type." 6365 if (Type->isArrayType()) 6366 Type = QualType(Context.getAsArrayType(Type), 0); 6367 Decl->setType(Type); 6368 } 6369 } 6370 6371 static void checkAttributesAfterMerging(Sema &S, NamedDecl &ND) { 6372 // Ensure that an auto decl is deduced otherwise the checks below might cache 6373 // the wrong linkage. 6374 assert(S.ParsingInitForAutoVars.count(&ND) == 0); 6375 6376 // 'weak' only applies to declarations with external linkage. 6377 if (WeakAttr *Attr = ND.getAttr<WeakAttr>()) { 6378 if (!ND.isExternallyVisible()) { 6379 S.Diag(Attr->getLocation(), diag::err_attribute_weak_static); 6380 ND.dropAttr<WeakAttr>(); 6381 } 6382 } 6383 if (WeakRefAttr *Attr = ND.getAttr<WeakRefAttr>()) { 6384 if (ND.isExternallyVisible()) { 6385 S.Diag(Attr->getLocation(), diag::err_attribute_weakref_not_static); 6386 ND.dropAttr<WeakRefAttr>(); 6387 ND.dropAttr<AliasAttr>(); 6388 } 6389 } 6390 6391 if (auto *VD = dyn_cast<VarDecl>(&ND)) { 6392 if (VD->hasInit()) { 6393 if (const auto *Attr = VD->getAttr<AliasAttr>()) { 6394 assert(VD->isThisDeclarationADefinition() && 6395 !VD->isExternallyVisible() && "Broken AliasAttr handled late!"); 6396 S.Diag(Attr->getLocation(), diag::err_alias_is_definition) << VD << 0; 6397 VD->dropAttr<AliasAttr>(); 6398 } 6399 } 6400 } 6401 6402 // 'selectany' only applies to externally visible variable declarations. 6403 // It does not apply to functions. 6404 if (SelectAnyAttr *Attr = ND.getAttr<SelectAnyAttr>()) { 6405 if (isa<FunctionDecl>(ND) || !ND.isExternallyVisible()) { 6406 S.Diag(Attr->getLocation(), 6407 diag::err_attribute_selectany_non_extern_data); 6408 ND.dropAttr<SelectAnyAttr>(); 6409 } 6410 } 6411 6412 if (const InheritableAttr *Attr = getDLLAttr(&ND)) { 6413 auto *VD = dyn_cast<VarDecl>(&ND); 6414 bool IsAnonymousNS = false; 6415 bool IsMicrosoft = S.Context.getTargetInfo().getCXXABI().isMicrosoft(); 6416 if (VD) { 6417 const NamespaceDecl *NS = dyn_cast<NamespaceDecl>(VD->getDeclContext()); 6418 while (NS && !IsAnonymousNS) { 6419 IsAnonymousNS = NS->isAnonymousNamespace(); 6420 NS = dyn_cast<NamespaceDecl>(NS->getParent()); 6421 } 6422 } 6423 // dll attributes require external linkage. Static locals may have external 6424 // linkage but still cannot be explicitly imported or exported. 6425 // In Microsoft mode, a variable defined in anonymous namespace must have 6426 // external linkage in order to be exported. 6427 bool AnonNSInMicrosoftMode = IsAnonymousNS && IsMicrosoft; 6428 if ((ND.isExternallyVisible() && AnonNSInMicrosoftMode) || 6429 (!AnonNSInMicrosoftMode && 6430 (!ND.isExternallyVisible() || (VD && VD->isStaticLocal())))) { 6431 S.Diag(ND.getLocation(), diag::err_attribute_dll_not_extern) 6432 << &ND << Attr; 6433 ND.setInvalidDecl(); 6434 } 6435 } 6436 6437 // Virtual functions cannot be marked as 'notail'. 6438 if (auto *Attr = ND.getAttr<NotTailCalledAttr>()) 6439 if (auto *MD = dyn_cast<CXXMethodDecl>(&ND)) 6440 if (MD->isVirtual()) { 6441 S.Diag(ND.getLocation(), 6442 diag::err_invalid_attribute_on_virtual_function) 6443 << Attr; 6444 ND.dropAttr<NotTailCalledAttr>(); 6445 } 6446 6447 // Check the attributes on the function type, if any. 6448 if (const auto *FD = dyn_cast<FunctionDecl>(&ND)) { 6449 // Don't declare this variable in the second operand of the for-statement; 6450 // GCC miscompiles that by ending its lifetime before evaluating the 6451 // third operand. See gcc.gnu.org/PR86769. 6452 AttributedTypeLoc ATL; 6453 for (TypeLoc TL = FD->getTypeSourceInfo()->getTypeLoc(); 6454 (ATL = TL.getAsAdjusted<AttributedTypeLoc>()); 6455 TL = ATL.getModifiedLoc()) { 6456 // The [[lifetimebound]] attribute can be applied to the implicit object 6457 // parameter of a non-static member function (other than a ctor or dtor) 6458 // by applying it to the function type. 6459 if (const auto *A = ATL.getAttrAs<LifetimeBoundAttr>()) { 6460 const auto *MD = dyn_cast<CXXMethodDecl>(FD); 6461 if (!MD || MD->isStatic()) { 6462 S.Diag(A->getLocation(), diag::err_lifetimebound_no_object_param) 6463 << !MD << A->getRange(); 6464 } else if (isa<CXXConstructorDecl>(MD) || isa<CXXDestructorDecl>(MD)) { 6465 S.Diag(A->getLocation(), diag::err_lifetimebound_ctor_dtor) 6466 << isa<CXXDestructorDecl>(MD) << A->getRange(); 6467 } 6468 } 6469 } 6470 } 6471 } 6472 6473 static void checkDLLAttributeRedeclaration(Sema &S, NamedDecl *OldDecl, 6474 NamedDecl *NewDecl, 6475 bool IsSpecialization, 6476 bool IsDefinition) { 6477 if (OldDecl->isInvalidDecl() || NewDecl->isInvalidDecl()) 6478 return; 6479 6480 bool IsTemplate = false; 6481 if (TemplateDecl *OldTD = dyn_cast<TemplateDecl>(OldDecl)) { 6482 OldDecl = OldTD->getTemplatedDecl(); 6483 IsTemplate = true; 6484 if (!IsSpecialization) 6485 IsDefinition = false; 6486 } 6487 if (TemplateDecl *NewTD = dyn_cast<TemplateDecl>(NewDecl)) { 6488 NewDecl = NewTD->getTemplatedDecl(); 6489 IsTemplate = true; 6490 } 6491 6492 if (!OldDecl || !NewDecl) 6493 return; 6494 6495 const DLLImportAttr *OldImportAttr = OldDecl->getAttr<DLLImportAttr>(); 6496 const DLLExportAttr *OldExportAttr = OldDecl->getAttr<DLLExportAttr>(); 6497 const DLLImportAttr *NewImportAttr = NewDecl->getAttr<DLLImportAttr>(); 6498 const DLLExportAttr *NewExportAttr = NewDecl->getAttr<DLLExportAttr>(); 6499 6500 // dllimport and dllexport are inheritable attributes so we have to exclude 6501 // inherited attribute instances. 6502 bool HasNewAttr = (NewImportAttr && !NewImportAttr->isInherited()) || 6503 (NewExportAttr && !NewExportAttr->isInherited()); 6504 6505 // A redeclaration is not allowed to add a dllimport or dllexport attribute, 6506 // the only exception being explicit specializations. 6507 // Implicitly generated declarations are also excluded for now because there 6508 // is no other way to switch these to use dllimport or dllexport. 6509 bool AddsAttr = !(OldImportAttr || OldExportAttr) && HasNewAttr; 6510 6511 if (AddsAttr && !IsSpecialization && !OldDecl->isImplicit()) { 6512 // Allow with a warning for free functions and global variables. 6513 bool JustWarn = false; 6514 if (!OldDecl->isCXXClassMember()) { 6515 auto *VD = dyn_cast<VarDecl>(OldDecl); 6516 if (VD && !VD->getDescribedVarTemplate()) 6517 JustWarn = true; 6518 auto *FD = dyn_cast<FunctionDecl>(OldDecl); 6519 if (FD && FD->getTemplatedKind() == FunctionDecl::TK_NonTemplate) 6520 JustWarn = true; 6521 } 6522 6523 // We cannot change a declaration that's been used because IR has already 6524 // been emitted. Dllimported functions will still work though (modulo 6525 // address equality) as they can use the thunk. 6526 if (OldDecl->isUsed()) 6527 if (!isa<FunctionDecl>(OldDecl) || !NewImportAttr) 6528 JustWarn = false; 6529 6530 unsigned DiagID = JustWarn ? diag::warn_attribute_dll_redeclaration 6531 : diag::err_attribute_dll_redeclaration; 6532 S.Diag(NewDecl->getLocation(), DiagID) 6533 << NewDecl 6534 << (NewImportAttr ? (const Attr *)NewImportAttr : NewExportAttr); 6535 S.Diag(OldDecl->getLocation(), diag::note_previous_declaration); 6536 if (!JustWarn) { 6537 NewDecl->setInvalidDecl(); 6538 return; 6539 } 6540 } 6541 6542 // A redeclaration is not allowed to drop a dllimport attribute, the only 6543 // exceptions being inline function definitions (except for function 6544 // templates), local extern declarations, qualified friend declarations or 6545 // special MSVC extension: in the last case, the declaration is treated as if 6546 // it were marked dllexport. 6547 bool IsInline = false, IsStaticDataMember = false, IsQualifiedFriend = false; 6548 bool IsMicrosoftABI = S.Context.getTargetInfo().shouldDLLImportComdatSymbols(); 6549 if (const auto *VD = dyn_cast<VarDecl>(NewDecl)) { 6550 // Ignore static data because out-of-line definitions are diagnosed 6551 // separately. 6552 IsStaticDataMember = VD->isStaticDataMember(); 6553 IsDefinition = VD->isThisDeclarationADefinition(S.Context) != 6554 VarDecl::DeclarationOnly; 6555 } else if (const auto *FD = dyn_cast<FunctionDecl>(NewDecl)) { 6556 IsInline = FD->isInlined(); 6557 IsQualifiedFriend = FD->getQualifier() && 6558 FD->getFriendObjectKind() == Decl::FOK_Declared; 6559 } 6560 6561 if (OldImportAttr && !HasNewAttr && 6562 (!IsInline || (IsMicrosoftABI && IsTemplate)) && !IsStaticDataMember && 6563 !NewDecl->isLocalExternDecl() && !IsQualifiedFriend) { 6564 if (IsMicrosoftABI && IsDefinition) { 6565 S.Diag(NewDecl->getLocation(), 6566 diag::warn_redeclaration_without_import_attribute) 6567 << NewDecl; 6568 S.Diag(OldDecl->getLocation(), diag::note_previous_declaration); 6569 NewDecl->dropAttr<DLLImportAttr>(); 6570 NewDecl->addAttr( 6571 DLLExportAttr::CreateImplicit(S.Context, NewImportAttr->getRange())); 6572 } else { 6573 S.Diag(NewDecl->getLocation(), 6574 diag::warn_redeclaration_without_attribute_prev_attribute_ignored) 6575 << NewDecl << OldImportAttr; 6576 S.Diag(OldDecl->getLocation(), diag::note_previous_declaration); 6577 S.Diag(OldImportAttr->getLocation(), diag::note_previous_attribute); 6578 OldDecl->dropAttr<DLLImportAttr>(); 6579 NewDecl->dropAttr<DLLImportAttr>(); 6580 } 6581 } else if (IsInline && OldImportAttr && !IsMicrosoftABI) { 6582 // In MinGW, seeing a function declared inline drops the dllimport 6583 // attribute. 6584 OldDecl->dropAttr<DLLImportAttr>(); 6585 NewDecl->dropAttr<DLLImportAttr>(); 6586 S.Diag(NewDecl->getLocation(), 6587 diag::warn_dllimport_dropped_from_inline_function) 6588 << NewDecl << OldImportAttr; 6589 } 6590 6591 // A specialization of a class template member function is processed here 6592 // since it's a redeclaration. If the parent class is dllexport, the 6593 // specialization inherits that attribute. This doesn't happen automatically 6594 // since the parent class isn't instantiated until later. 6595 if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(NewDecl)) { 6596 if (MD->getTemplatedKind() == FunctionDecl::TK_MemberSpecialization && 6597 !NewImportAttr && !NewExportAttr) { 6598 if (const DLLExportAttr *ParentExportAttr = 6599 MD->getParent()->getAttr<DLLExportAttr>()) { 6600 DLLExportAttr *NewAttr = ParentExportAttr->clone(S.Context); 6601 NewAttr->setInherited(true); 6602 NewDecl->addAttr(NewAttr); 6603 } 6604 } 6605 } 6606 } 6607 6608 /// Given that we are within the definition of the given function, 6609 /// will that definition behave like C99's 'inline', where the 6610 /// definition is discarded except for optimization purposes? 6611 static bool isFunctionDefinitionDiscarded(Sema &S, FunctionDecl *FD) { 6612 // Try to avoid calling GetGVALinkageForFunction. 6613 6614 // All cases of this require the 'inline' keyword. 6615 if (!FD->isInlined()) return false; 6616 6617 // This is only possible in C++ with the gnu_inline attribute. 6618 if (S.getLangOpts().CPlusPlus && !FD->hasAttr<GNUInlineAttr>()) 6619 return false; 6620 6621 // Okay, go ahead and call the relatively-more-expensive function. 6622 return S.Context.GetGVALinkageForFunction(FD) == GVA_AvailableExternally; 6623 } 6624 6625 /// Determine whether a variable is extern "C" prior to attaching 6626 /// an initializer. We can't just call isExternC() here, because that 6627 /// will also compute and cache whether the declaration is externally 6628 /// visible, which might change when we attach the initializer. 6629 /// 6630 /// This can only be used if the declaration is known to not be a 6631 /// redeclaration of an internal linkage declaration. 6632 /// 6633 /// For instance: 6634 /// 6635 /// auto x = []{}; 6636 /// 6637 /// Attaching the initializer here makes this declaration not externally 6638 /// visible, because its type has internal linkage. 6639 /// 6640 /// FIXME: This is a hack. 6641 template<typename T> 6642 static bool isIncompleteDeclExternC(Sema &S, const T *D) { 6643 if (S.getLangOpts().CPlusPlus) { 6644 // In C++, the overloadable attribute negates the effects of extern "C". 6645 if (!D->isInExternCContext() || D->template hasAttr<OverloadableAttr>()) 6646 return false; 6647 6648 // So do CUDA's host/device attributes. 6649 if (S.getLangOpts().CUDA && (D->template hasAttr<CUDADeviceAttr>() || 6650 D->template hasAttr<CUDAHostAttr>())) 6651 return false; 6652 } 6653 return D->isExternC(); 6654 } 6655 6656 static bool shouldConsiderLinkage(const VarDecl *VD) { 6657 const DeclContext *DC = VD->getDeclContext()->getRedeclContext(); 6658 if (DC->isFunctionOrMethod() || isa<OMPDeclareReductionDecl>(DC) || 6659 isa<OMPDeclareMapperDecl>(DC)) 6660 return VD->hasExternalStorage(); 6661 if (DC->isFileContext()) 6662 return true; 6663 if (DC->isRecord()) 6664 return false; 6665 if (isa<RequiresExprBodyDecl>(DC)) 6666 return false; 6667 llvm_unreachable("Unexpected context"); 6668 } 6669 6670 static bool shouldConsiderLinkage(const FunctionDecl *FD) { 6671 const DeclContext *DC = FD->getDeclContext()->getRedeclContext(); 6672 if (DC->isFileContext() || DC->isFunctionOrMethod() || 6673 isa<OMPDeclareReductionDecl>(DC) || isa<OMPDeclareMapperDecl>(DC)) 6674 return true; 6675 if (DC->isRecord()) 6676 return false; 6677 llvm_unreachable("Unexpected context"); 6678 } 6679 6680 static bool hasParsedAttr(Scope *S, const Declarator &PD, 6681 ParsedAttr::Kind Kind) { 6682 // Check decl attributes on the DeclSpec. 6683 if (PD.getDeclSpec().getAttributes().hasAttribute(Kind)) 6684 return true; 6685 6686 // Walk the declarator structure, checking decl attributes that were in a type 6687 // position to the decl itself. 6688 for (unsigned I = 0, E = PD.getNumTypeObjects(); I != E; ++I) { 6689 if (PD.getTypeObject(I).getAttrs().hasAttribute(Kind)) 6690 return true; 6691 } 6692 6693 // Finally, check attributes on the decl itself. 6694 return PD.getAttributes().hasAttribute(Kind); 6695 } 6696 6697 /// Adjust the \c DeclContext for a function or variable that might be a 6698 /// function-local external declaration. 6699 bool Sema::adjustContextForLocalExternDecl(DeclContext *&DC) { 6700 if (!DC->isFunctionOrMethod()) 6701 return false; 6702 6703 // If this is a local extern function or variable declared within a function 6704 // template, don't add it into the enclosing namespace scope until it is 6705 // instantiated; it might have a dependent type right now. 6706 if (DC->isDependentContext()) 6707 return true; 6708 6709 // C++11 [basic.link]p7: 6710 // When a block scope declaration of an entity with linkage is not found to 6711 // refer to some other declaration, then that entity is a member of the 6712 // innermost enclosing namespace. 6713 // 6714 // Per C++11 [namespace.def]p6, the innermost enclosing namespace is a 6715 // semantically-enclosing namespace, not a lexically-enclosing one. 6716 while (!DC->isFileContext() && !isa<LinkageSpecDecl>(DC)) 6717 DC = DC->getParent(); 6718 return true; 6719 } 6720 6721 /// Returns true if given declaration has external C language linkage. 6722 static bool isDeclExternC(const Decl *D) { 6723 if (const auto *FD = dyn_cast<FunctionDecl>(D)) 6724 return FD->isExternC(); 6725 if (const auto *VD = dyn_cast<VarDecl>(D)) 6726 return VD->isExternC(); 6727 6728 llvm_unreachable("Unknown type of decl!"); 6729 } 6730 /// Returns true if there hasn't been any invalid type diagnosed. 6731 static bool diagnoseOpenCLTypes(Scope *S, Sema &Se, Declarator &D, 6732 DeclContext *DC, QualType R) { 6733 // OpenCL v2.0 s6.9.b - Image type can only be used as a function argument. 6734 // OpenCL v2.0 s6.13.16.1 - Pipe type can only be used as a function 6735 // argument. 6736 if (R->isImageType() || R->isPipeType()) { 6737 Se.Diag(D.getIdentifierLoc(), 6738 diag::err_opencl_type_can_only_be_used_as_function_parameter) 6739 << R; 6740 D.setInvalidType(); 6741 return false; 6742 } 6743 6744 // OpenCL v1.2 s6.9.r: 6745 // The event type cannot be used to declare a program scope variable. 6746 // OpenCL v2.0 s6.9.q: 6747 // The clk_event_t and reserve_id_t types cannot be declared in program 6748 // scope. 6749 if (NULL == S->getParent()) { 6750 if (R->isReserveIDT() || R->isClkEventT() || R->isEventT()) { 6751 Se.Diag(D.getIdentifierLoc(), 6752 diag::err_invalid_type_for_program_scope_var) 6753 << R; 6754 D.setInvalidType(); 6755 return false; 6756 } 6757 } 6758 6759 // OpenCL v1.0 s6.8.a.3: Pointers to functions are not allowed. 6760 if (!Se.getOpenCLOptions().isEnabled("__cl_clang_function_pointers")) { 6761 QualType NR = R; 6762 while (NR->isPointerType() || NR->isMemberFunctionPointerType()) { 6763 if (NR->isFunctionPointerType() || NR->isMemberFunctionPointerType()) { 6764 Se.Diag(D.getIdentifierLoc(), diag::err_opencl_function_pointer); 6765 D.setInvalidType(); 6766 return false; 6767 } 6768 NR = NR->getPointeeType(); 6769 } 6770 } 6771 6772 if (!Se.getOpenCLOptions().isEnabled("cl_khr_fp16")) { 6773 // OpenCL v1.2 s6.1.1.1: reject declaring variables of the half and 6774 // half array type (unless the cl_khr_fp16 extension is enabled). 6775 if (Se.Context.getBaseElementType(R)->isHalfType()) { 6776 Se.Diag(D.getIdentifierLoc(), diag::err_opencl_half_declaration) << R; 6777 D.setInvalidType(); 6778 return false; 6779 } 6780 } 6781 6782 // OpenCL v1.2 s6.9.r: 6783 // The event type cannot be used with the __local, __constant and __global 6784 // address space qualifiers. 6785 if (R->isEventT()) { 6786 if (R.getAddressSpace() != LangAS::opencl_private) { 6787 Se.Diag(D.getBeginLoc(), diag::err_event_t_addr_space_qual); 6788 D.setInvalidType(); 6789 return false; 6790 } 6791 } 6792 6793 // C++ for OpenCL does not allow the thread_local storage qualifier. 6794 // OpenCL C does not support thread_local either, and 6795 // also reject all other thread storage class specifiers. 6796 DeclSpec::TSCS TSC = D.getDeclSpec().getThreadStorageClassSpec(); 6797 if (TSC != TSCS_unspecified) { 6798 bool IsCXX = Se.getLangOpts().OpenCLCPlusPlus; 6799 Se.Diag(D.getDeclSpec().getThreadStorageClassSpecLoc(), 6800 diag::err_opencl_unknown_type_specifier) 6801 << IsCXX << Se.getLangOpts().getOpenCLVersionTuple().getAsString() 6802 << DeclSpec::getSpecifierName(TSC) << 1; 6803 D.setInvalidType(); 6804 return false; 6805 } 6806 6807 if (R->isSamplerT()) { 6808 // OpenCL v1.2 s6.9.b p4: 6809 // The sampler type cannot be used with the __local and __global address 6810 // space qualifiers. 6811 if (R.getAddressSpace() == LangAS::opencl_local || 6812 R.getAddressSpace() == LangAS::opencl_global) { 6813 Se.Diag(D.getIdentifierLoc(), diag::err_wrong_sampler_addressspace); 6814 D.setInvalidType(); 6815 } 6816 6817 // OpenCL v1.2 s6.12.14.1: 6818 // A global sampler must be declared with either the constant address 6819 // space qualifier or with the const qualifier. 6820 if (DC->isTranslationUnit() && 6821 !(R.getAddressSpace() == LangAS::opencl_constant || 6822 R.isConstQualified())) { 6823 Se.Diag(D.getIdentifierLoc(), diag::err_opencl_nonconst_global_sampler); 6824 D.setInvalidType(); 6825 } 6826 if (D.isInvalidType()) 6827 return false; 6828 } 6829 return true; 6830 } 6831 6832 NamedDecl *Sema::ActOnVariableDeclarator( 6833 Scope *S, Declarator &D, DeclContext *DC, TypeSourceInfo *TInfo, 6834 LookupResult &Previous, MultiTemplateParamsArg TemplateParamLists, 6835 bool &AddToScope, ArrayRef<BindingDecl *> Bindings) { 6836 QualType R = TInfo->getType(); 6837 DeclarationName Name = GetNameForDeclarator(D).getName(); 6838 6839 IdentifierInfo *II = Name.getAsIdentifierInfo(); 6840 6841 if (D.isDecompositionDeclarator()) { 6842 // Take the name of the first declarator as our name for diagnostic 6843 // purposes. 6844 auto &Decomp = D.getDecompositionDeclarator(); 6845 if (!Decomp.bindings().empty()) { 6846 II = Decomp.bindings()[0].Name; 6847 Name = II; 6848 } 6849 } else if (!II) { 6850 Diag(D.getIdentifierLoc(), diag::err_bad_variable_name) << Name; 6851 return nullptr; 6852 } 6853 6854 6855 DeclSpec::SCS SCSpec = D.getDeclSpec().getStorageClassSpec(); 6856 StorageClass SC = StorageClassSpecToVarDeclStorageClass(D.getDeclSpec()); 6857 6858 // dllimport globals without explicit storage class are treated as extern. We 6859 // have to change the storage class this early to get the right DeclContext. 6860 if (SC == SC_None && !DC->isRecord() && 6861 hasParsedAttr(S, D, ParsedAttr::AT_DLLImport) && 6862 !hasParsedAttr(S, D, ParsedAttr::AT_DLLExport)) 6863 SC = SC_Extern; 6864 6865 DeclContext *OriginalDC = DC; 6866 bool IsLocalExternDecl = SC == SC_Extern && 6867 adjustContextForLocalExternDecl(DC); 6868 6869 if (SCSpec == DeclSpec::SCS_mutable) { 6870 // mutable can only appear on non-static class members, so it's always 6871 // an error here 6872 Diag(D.getIdentifierLoc(), diag::err_mutable_nonmember); 6873 D.setInvalidType(); 6874 SC = SC_None; 6875 } 6876 6877 if (getLangOpts().CPlusPlus11 && SCSpec == DeclSpec::SCS_register && 6878 !D.getAsmLabel() && !getSourceManager().isInSystemMacro( 6879 D.getDeclSpec().getStorageClassSpecLoc())) { 6880 // In C++11, the 'register' storage class specifier is deprecated. 6881 // Suppress the warning in system macros, it's used in macros in some 6882 // popular C system headers, such as in glibc's htonl() macro. 6883 Diag(D.getDeclSpec().getStorageClassSpecLoc(), 6884 getLangOpts().CPlusPlus17 ? diag::ext_register_storage_class 6885 : diag::warn_deprecated_register) 6886 << FixItHint::CreateRemoval(D.getDeclSpec().getStorageClassSpecLoc()); 6887 } 6888 6889 DiagnoseFunctionSpecifiers(D.getDeclSpec()); 6890 6891 if (!DC->isRecord() && S->getFnParent() == nullptr) { 6892 // C99 6.9p2: The storage-class specifiers auto and register shall not 6893 // appear in the declaration specifiers in an external declaration. 6894 // Global Register+Asm is a GNU extension we support. 6895 if (SC == SC_Auto || (SC == SC_Register && !D.getAsmLabel())) { 6896 Diag(D.getIdentifierLoc(), diag::err_typecheck_sclass_fscope); 6897 D.setInvalidType(); 6898 } 6899 } 6900 6901 // If this variable has a variable-modified type and an initializer, try to 6902 // fold to a constant-sized type. This is otherwise invalid. 6903 if (D.hasInitializer() && R->isVariablyModifiedType()) 6904 tryToFixVariablyModifiedVarType(*this, TInfo, R, D.getIdentifierLoc(), 6905 /*DiagID=*/0); 6906 6907 bool IsMemberSpecialization = false; 6908 bool IsVariableTemplateSpecialization = false; 6909 bool IsPartialSpecialization = false; 6910 bool IsVariableTemplate = false; 6911 VarDecl *NewVD = nullptr; 6912 VarTemplateDecl *NewTemplate = nullptr; 6913 TemplateParameterList *TemplateParams = nullptr; 6914 if (!getLangOpts().CPlusPlus) { 6915 NewVD = VarDecl::Create(Context, DC, D.getBeginLoc(), D.getIdentifierLoc(), 6916 II, R, TInfo, SC); 6917 6918 if (R->getContainedDeducedType()) 6919 ParsingInitForAutoVars.insert(NewVD); 6920 6921 if (D.isInvalidType()) 6922 NewVD->setInvalidDecl(); 6923 6924 if (NewVD->getType().hasNonTrivialToPrimitiveDestructCUnion() && 6925 NewVD->hasLocalStorage()) 6926 checkNonTrivialCUnion(NewVD->getType(), NewVD->getLocation(), 6927 NTCUC_AutoVar, NTCUK_Destruct); 6928 } else { 6929 bool Invalid = false; 6930 6931 if (DC->isRecord() && !CurContext->isRecord()) { 6932 // This is an out-of-line definition of a static data member. 6933 switch (SC) { 6934 case SC_None: 6935 break; 6936 case SC_Static: 6937 Diag(D.getDeclSpec().getStorageClassSpecLoc(), 6938 diag::err_static_out_of_line) 6939 << FixItHint::CreateRemoval(D.getDeclSpec().getStorageClassSpecLoc()); 6940 break; 6941 case SC_Auto: 6942 case SC_Register: 6943 case SC_Extern: 6944 // [dcl.stc] p2: The auto or register specifiers shall be applied only 6945 // to names of variables declared in a block or to function parameters. 6946 // [dcl.stc] p6: The extern specifier cannot be used in the declaration 6947 // of class members 6948 6949 Diag(D.getDeclSpec().getStorageClassSpecLoc(), 6950 diag::err_storage_class_for_static_member) 6951 << FixItHint::CreateRemoval(D.getDeclSpec().getStorageClassSpecLoc()); 6952 break; 6953 case SC_PrivateExtern: 6954 llvm_unreachable("C storage class in c++!"); 6955 } 6956 } 6957 6958 if (SC == SC_Static && CurContext->isRecord()) { 6959 if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(DC)) { 6960 // Walk up the enclosing DeclContexts to check for any that are 6961 // incompatible with static data members. 6962 const DeclContext *FunctionOrMethod = nullptr; 6963 const CXXRecordDecl *AnonStruct = nullptr; 6964 for (DeclContext *Ctxt = DC; Ctxt; Ctxt = Ctxt->getParent()) { 6965 if (Ctxt->isFunctionOrMethod()) { 6966 FunctionOrMethod = Ctxt; 6967 break; 6968 } 6969 const CXXRecordDecl *ParentDecl = dyn_cast<CXXRecordDecl>(Ctxt); 6970 if (ParentDecl && !ParentDecl->getDeclName()) { 6971 AnonStruct = ParentDecl; 6972 break; 6973 } 6974 } 6975 if (FunctionOrMethod) { 6976 // C++ [class.static.data]p5: A local class shall not have static data 6977 // members. 6978 Diag(D.getIdentifierLoc(), 6979 diag::err_static_data_member_not_allowed_in_local_class) 6980 << Name << RD->getDeclName() << RD->getTagKind(); 6981 } else if (AnonStruct) { 6982 // C++ [class.static.data]p4: Unnamed classes and classes contained 6983 // directly or indirectly within unnamed classes shall not contain 6984 // static data members. 6985 Diag(D.getIdentifierLoc(), 6986 diag::err_static_data_member_not_allowed_in_anon_struct) 6987 << Name << AnonStruct->getTagKind(); 6988 Invalid = true; 6989 } else if (RD->isUnion()) { 6990 // C++98 [class.union]p1: If a union contains a static data member, 6991 // the program is ill-formed. C++11 drops this restriction. 6992 Diag(D.getIdentifierLoc(), 6993 getLangOpts().CPlusPlus11 6994 ? diag::warn_cxx98_compat_static_data_member_in_union 6995 : diag::ext_static_data_member_in_union) << Name; 6996 } 6997 } 6998 } 6999 7000 // Match up the template parameter lists with the scope specifier, then 7001 // determine whether we have a template or a template specialization. 7002 bool InvalidScope = false; 7003 TemplateParams = MatchTemplateParametersToScopeSpecifier( 7004 D.getDeclSpec().getBeginLoc(), D.getIdentifierLoc(), 7005 D.getCXXScopeSpec(), 7006 D.getName().getKind() == UnqualifiedIdKind::IK_TemplateId 7007 ? D.getName().TemplateId 7008 : nullptr, 7009 TemplateParamLists, 7010 /*never a friend*/ false, IsMemberSpecialization, InvalidScope); 7011 Invalid |= InvalidScope; 7012 7013 if (TemplateParams) { 7014 if (!TemplateParams->size() && 7015 D.getName().getKind() != UnqualifiedIdKind::IK_TemplateId) { 7016 // There is an extraneous 'template<>' for this variable. Complain 7017 // about it, but allow the declaration of the variable. 7018 Diag(TemplateParams->getTemplateLoc(), 7019 diag::err_template_variable_noparams) 7020 << II 7021 << SourceRange(TemplateParams->getTemplateLoc(), 7022 TemplateParams->getRAngleLoc()); 7023 TemplateParams = nullptr; 7024 } else { 7025 // Check that we can declare a template here. 7026 if (CheckTemplateDeclScope(S, TemplateParams)) 7027 return nullptr; 7028 7029 if (D.getName().getKind() == UnqualifiedIdKind::IK_TemplateId) { 7030 // This is an explicit specialization or a partial specialization. 7031 IsVariableTemplateSpecialization = true; 7032 IsPartialSpecialization = TemplateParams->size() > 0; 7033 } else { // if (TemplateParams->size() > 0) 7034 // This is a template declaration. 7035 IsVariableTemplate = true; 7036 7037 // Only C++1y supports variable templates (N3651). 7038 Diag(D.getIdentifierLoc(), 7039 getLangOpts().CPlusPlus14 7040 ? diag::warn_cxx11_compat_variable_template 7041 : diag::ext_variable_template); 7042 } 7043 } 7044 } else { 7045 // Check that we can declare a member specialization here. 7046 if (!TemplateParamLists.empty() && IsMemberSpecialization && 7047 CheckTemplateDeclScope(S, TemplateParamLists.back())) 7048 return nullptr; 7049 assert((Invalid || 7050 D.getName().getKind() != UnqualifiedIdKind::IK_TemplateId) && 7051 "should have a 'template<>' for this decl"); 7052 } 7053 7054 if (IsVariableTemplateSpecialization) { 7055 SourceLocation TemplateKWLoc = 7056 TemplateParamLists.size() > 0 7057 ? TemplateParamLists[0]->getTemplateLoc() 7058 : SourceLocation(); 7059 DeclResult Res = ActOnVarTemplateSpecialization( 7060 S, D, TInfo, TemplateKWLoc, TemplateParams, SC, 7061 IsPartialSpecialization); 7062 if (Res.isInvalid()) 7063 return nullptr; 7064 NewVD = cast<VarDecl>(Res.get()); 7065 AddToScope = false; 7066 } else if (D.isDecompositionDeclarator()) { 7067 NewVD = DecompositionDecl::Create(Context, DC, D.getBeginLoc(), 7068 D.getIdentifierLoc(), R, TInfo, SC, 7069 Bindings); 7070 } else 7071 NewVD = VarDecl::Create(Context, DC, D.getBeginLoc(), 7072 D.getIdentifierLoc(), II, R, TInfo, SC); 7073 7074 // If this is supposed to be a variable template, create it as such. 7075 if (IsVariableTemplate) { 7076 NewTemplate = 7077 VarTemplateDecl::Create(Context, DC, D.getIdentifierLoc(), Name, 7078 TemplateParams, NewVD); 7079 NewVD->setDescribedVarTemplate(NewTemplate); 7080 } 7081 7082 // If this decl has an auto type in need of deduction, make a note of the 7083 // Decl so we can diagnose uses of it in its own initializer. 7084 if (R->getContainedDeducedType()) 7085 ParsingInitForAutoVars.insert(NewVD); 7086 7087 if (D.isInvalidType() || Invalid) { 7088 NewVD->setInvalidDecl(); 7089 if (NewTemplate) 7090 NewTemplate->setInvalidDecl(); 7091 } 7092 7093 SetNestedNameSpecifier(*this, NewVD, D); 7094 7095 // If we have any template parameter lists that don't directly belong to 7096 // the variable (matching the scope specifier), store them. 7097 unsigned VDTemplateParamLists = TemplateParams ? 1 : 0; 7098 if (TemplateParamLists.size() > VDTemplateParamLists) 7099 NewVD->setTemplateParameterListsInfo( 7100 Context, TemplateParamLists.drop_back(VDTemplateParamLists)); 7101 } 7102 7103 if (D.getDeclSpec().isInlineSpecified()) { 7104 if (!getLangOpts().CPlusPlus) { 7105 Diag(D.getDeclSpec().getInlineSpecLoc(), diag::err_inline_non_function) 7106 << 0; 7107 } else if (CurContext->isFunctionOrMethod()) { 7108 // 'inline' is not allowed on block scope variable declaration. 7109 Diag(D.getDeclSpec().getInlineSpecLoc(), 7110 diag::err_inline_declaration_block_scope) << Name 7111 << FixItHint::CreateRemoval(D.getDeclSpec().getInlineSpecLoc()); 7112 } else { 7113 Diag(D.getDeclSpec().getInlineSpecLoc(), 7114 getLangOpts().CPlusPlus17 ? diag::warn_cxx14_compat_inline_variable 7115 : diag::ext_inline_variable); 7116 NewVD->setInlineSpecified(); 7117 } 7118 } 7119 7120 // Set the lexical context. If the declarator has a C++ scope specifier, the 7121 // lexical context will be different from the semantic context. 7122 NewVD->setLexicalDeclContext(CurContext); 7123 if (NewTemplate) 7124 NewTemplate->setLexicalDeclContext(CurContext); 7125 7126 if (IsLocalExternDecl) { 7127 if (D.isDecompositionDeclarator()) 7128 for (auto *B : Bindings) 7129 B->setLocalExternDecl(); 7130 else 7131 NewVD->setLocalExternDecl(); 7132 } 7133 7134 bool EmitTLSUnsupportedError = false; 7135 if (DeclSpec::TSCS TSCS = D.getDeclSpec().getThreadStorageClassSpec()) { 7136 // C++11 [dcl.stc]p4: 7137 // When thread_local is applied to a variable of block scope the 7138 // storage-class-specifier static is implied if it does not appear 7139 // explicitly. 7140 // Core issue: 'static' is not implied if the variable is declared 7141 // 'extern'. 7142 if (NewVD->hasLocalStorage() && 7143 (SCSpec != DeclSpec::SCS_unspecified || 7144 TSCS != DeclSpec::TSCS_thread_local || 7145 !DC->isFunctionOrMethod())) 7146 Diag(D.getDeclSpec().getThreadStorageClassSpecLoc(), 7147 diag::err_thread_non_global) 7148 << DeclSpec::getSpecifierName(TSCS); 7149 else if (!Context.getTargetInfo().isTLSSupported()) { 7150 if (getLangOpts().CUDA || getLangOpts().OpenMPIsDevice || 7151 getLangOpts().SYCLIsDevice) { 7152 // Postpone error emission until we've collected attributes required to 7153 // figure out whether it's a host or device variable and whether the 7154 // error should be ignored. 7155 EmitTLSUnsupportedError = true; 7156 // We still need to mark the variable as TLS so it shows up in AST with 7157 // proper storage class for other tools to use even if we're not going 7158 // to emit any code for it. 7159 NewVD->setTSCSpec(TSCS); 7160 } else 7161 Diag(D.getDeclSpec().getThreadStorageClassSpecLoc(), 7162 diag::err_thread_unsupported); 7163 } else 7164 NewVD->setTSCSpec(TSCS); 7165 } 7166 7167 switch (D.getDeclSpec().getConstexprSpecifier()) { 7168 case ConstexprSpecKind::Unspecified: 7169 break; 7170 7171 case ConstexprSpecKind::Consteval: 7172 Diag(D.getDeclSpec().getConstexprSpecLoc(), 7173 diag::err_constexpr_wrong_decl_kind) 7174 << static_cast<int>(D.getDeclSpec().getConstexprSpecifier()); 7175 LLVM_FALLTHROUGH; 7176 7177 case ConstexprSpecKind::Constexpr: 7178 NewVD->setConstexpr(true); 7179 MaybeAddCUDAConstantAttr(NewVD); 7180 // C++1z [dcl.spec.constexpr]p1: 7181 // A static data member declared with the constexpr specifier is 7182 // implicitly an inline variable. 7183 if (NewVD->isStaticDataMember() && 7184 (getLangOpts().CPlusPlus17 || 7185 Context.getTargetInfo().getCXXABI().isMicrosoft())) 7186 NewVD->setImplicitlyInline(); 7187 break; 7188 7189 case ConstexprSpecKind::Constinit: 7190 if (!NewVD->hasGlobalStorage()) 7191 Diag(D.getDeclSpec().getConstexprSpecLoc(), 7192 diag::err_constinit_local_variable); 7193 else 7194 NewVD->addAttr(ConstInitAttr::Create( 7195 Context, D.getDeclSpec().getConstexprSpecLoc(), 7196 AttributeCommonInfo::AS_Keyword, ConstInitAttr::Keyword_constinit)); 7197 break; 7198 } 7199 7200 // C99 6.7.4p3 7201 // An inline definition of a function with external linkage shall 7202 // not contain a definition of a modifiable object with static or 7203 // thread storage duration... 7204 // We only apply this when the function is required to be defined 7205 // elsewhere, i.e. when the function is not 'extern inline'. Note 7206 // that a local variable with thread storage duration still has to 7207 // be marked 'static'. Also note that it's possible to get these 7208 // semantics in C++ using __attribute__((gnu_inline)). 7209 if (SC == SC_Static && S->getFnParent() != nullptr && 7210 !NewVD->getType().isConstQualified()) { 7211 FunctionDecl *CurFD = getCurFunctionDecl(); 7212 if (CurFD && isFunctionDefinitionDiscarded(*this, CurFD)) { 7213 Diag(D.getDeclSpec().getStorageClassSpecLoc(), 7214 diag::warn_static_local_in_extern_inline); 7215 MaybeSuggestAddingStaticToDecl(CurFD); 7216 } 7217 } 7218 7219 if (D.getDeclSpec().isModulePrivateSpecified()) { 7220 if (IsVariableTemplateSpecialization) 7221 Diag(NewVD->getLocation(), diag::err_module_private_specialization) 7222 << (IsPartialSpecialization ? 1 : 0) 7223 << FixItHint::CreateRemoval( 7224 D.getDeclSpec().getModulePrivateSpecLoc()); 7225 else if (IsMemberSpecialization) 7226 Diag(NewVD->getLocation(), diag::err_module_private_specialization) 7227 << 2 7228 << FixItHint::CreateRemoval(D.getDeclSpec().getModulePrivateSpecLoc()); 7229 else if (NewVD->hasLocalStorage()) 7230 Diag(NewVD->getLocation(), diag::err_module_private_local) 7231 << 0 << NewVD 7232 << SourceRange(D.getDeclSpec().getModulePrivateSpecLoc()) 7233 << FixItHint::CreateRemoval( 7234 D.getDeclSpec().getModulePrivateSpecLoc()); 7235 else { 7236 NewVD->setModulePrivate(); 7237 if (NewTemplate) 7238 NewTemplate->setModulePrivate(); 7239 for (auto *B : Bindings) 7240 B->setModulePrivate(); 7241 } 7242 } 7243 7244 if (getLangOpts().OpenCL) { 7245 7246 deduceOpenCLAddressSpace(NewVD); 7247 7248 diagnoseOpenCLTypes(S, *this, D, DC, NewVD->getType()); 7249 } 7250 7251 // Handle attributes prior to checking for duplicates in MergeVarDecl 7252 ProcessDeclAttributes(S, NewVD, D); 7253 7254 if (getLangOpts().CUDA || getLangOpts().OpenMPIsDevice || 7255 getLangOpts().SYCLIsDevice) { 7256 if (EmitTLSUnsupportedError && 7257 ((getLangOpts().CUDA && DeclAttrsMatchCUDAMode(getLangOpts(), NewVD)) || 7258 (getLangOpts().OpenMPIsDevice && 7259 OMPDeclareTargetDeclAttr::isDeclareTargetDeclaration(NewVD)))) 7260 Diag(D.getDeclSpec().getThreadStorageClassSpecLoc(), 7261 diag::err_thread_unsupported); 7262 7263 if (EmitTLSUnsupportedError && 7264 (LangOpts.SYCLIsDevice || (LangOpts.OpenMP && LangOpts.OpenMPIsDevice))) 7265 targetDiag(D.getIdentifierLoc(), diag::err_thread_unsupported); 7266 // CUDA B.2.5: "__shared__ and __constant__ variables have implied static 7267 // storage [duration]." 7268 if (SC == SC_None && S->getFnParent() != nullptr && 7269 (NewVD->hasAttr<CUDASharedAttr>() || 7270 NewVD->hasAttr<CUDAConstantAttr>())) { 7271 NewVD->setStorageClass(SC_Static); 7272 } 7273 } 7274 7275 // Ensure that dllimport globals without explicit storage class are treated as 7276 // extern. The storage class is set above using parsed attributes. Now we can 7277 // check the VarDecl itself. 7278 assert(!NewVD->hasAttr<DLLImportAttr>() || 7279 NewVD->getAttr<DLLImportAttr>()->isInherited() || 7280 NewVD->isStaticDataMember() || NewVD->getStorageClass() != SC_None); 7281 7282 // In auto-retain/release, infer strong retension for variables of 7283 // retainable type. 7284 if (getLangOpts().ObjCAutoRefCount && inferObjCARCLifetime(NewVD)) 7285 NewVD->setInvalidDecl(); 7286 7287 // Handle GNU asm-label extension (encoded as an attribute). 7288 if (Expr *E = (Expr*)D.getAsmLabel()) { 7289 // The parser guarantees this is a string. 7290 StringLiteral *SE = cast<StringLiteral>(E); 7291 StringRef Label = SE->getString(); 7292 if (S->getFnParent() != nullptr) { 7293 switch (SC) { 7294 case SC_None: 7295 case SC_Auto: 7296 Diag(E->getExprLoc(), diag::warn_asm_label_on_auto_decl) << Label; 7297 break; 7298 case SC_Register: 7299 // Local Named register 7300 if (!Context.getTargetInfo().isValidGCCRegisterName(Label) && 7301 DeclAttrsMatchCUDAMode(getLangOpts(), getCurFunctionDecl())) 7302 Diag(E->getExprLoc(), diag::err_asm_unknown_register_name) << Label; 7303 break; 7304 case SC_Static: 7305 case SC_Extern: 7306 case SC_PrivateExtern: 7307 break; 7308 } 7309 } else if (SC == SC_Register) { 7310 // Global Named register 7311 if (DeclAttrsMatchCUDAMode(getLangOpts(), NewVD)) { 7312 const auto &TI = Context.getTargetInfo(); 7313 bool HasSizeMismatch; 7314 7315 if (!TI.isValidGCCRegisterName(Label)) 7316 Diag(E->getExprLoc(), diag::err_asm_unknown_register_name) << Label; 7317 else if (!TI.validateGlobalRegisterVariable(Label, 7318 Context.getTypeSize(R), 7319 HasSizeMismatch)) 7320 Diag(E->getExprLoc(), diag::err_asm_invalid_global_var_reg) << Label; 7321 else if (HasSizeMismatch) 7322 Diag(E->getExprLoc(), diag::err_asm_register_size_mismatch) << Label; 7323 } 7324 7325 if (!R->isIntegralType(Context) && !R->isPointerType()) { 7326 Diag(D.getBeginLoc(), diag::err_asm_bad_register_type); 7327 NewVD->setInvalidDecl(true); 7328 } 7329 } 7330 7331 NewVD->addAttr(AsmLabelAttr::Create(Context, Label, 7332 /*IsLiteralLabel=*/true, 7333 SE->getStrTokenLoc(0))); 7334 } else if (!ExtnameUndeclaredIdentifiers.empty()) { 7335 llvm::DenseMap<IdentifierInfo*,AsmLabelAttr*>::iterator I = 7336 ExtnameUndeclaredIdentifiers.find(NewVD->getIdentifier()); 7337 if (I != ExtnameUndeclaredIdentifiers.end()) { 7338 if (isDeclExternC(NewVD)) { 7339 NewVD->addAttr(I->second); 7340 ExtnameUndeclaredIdentifiers.erase(I); 7341 } else 7342 Diag(NewVD->getLocation(), diag::warn_redefine_extname_not_applied) 7343 << /*Variable*/1 << NewVD; 7344 } 7345 } 7346 7347 // Find the shadowed declaration before filtering for scope. 7348 NamedDecl *ShadowedDecl = D.getCXXScopeSpec().isEmpty() 7349 ? getShadowedDeclaration(NewVD, Previous) 7350 : nullptr; 7351 7352 // Don't consider existing declarations that are in a different 7353 // scope and are out-of-semantic-context declarations (if the new 7354 // declaration has linkage). 7355 FilterLookupForScope(Previous, OriginalDC, S, shouldConsiderLinkage(NewVD), 7356 D.getCXXScopeSpec().isNotEmpty() || 7357 IsMemberSpecialization || 7358 IsVariableTemplateSpecialization); 7359 7360 // Check whether the previous declaration is in the same block scope. This 7361 // affects whether we merge types with it, per C++11 [dcl.array]p3. 7362 if (getLangOpts().CPlusPlus && 7363 NewVD->isLocalVarDecl() && NewVD->hasExternalStorage()) 7364 NewVD->setPreviousDeclInSameBlockScope( 7365 Previous.isSingleResult() && !Previous.isShadowed() && 7366 isDeclInScope(Previous.getFoundDecl(), OriginalDC, S, false)); 7367 7368 if (!getLangOpts().CPlusPlus) { 7369 D.setRedeclaration(CheckVariableDeclaration(NewVD, Previous)); 7370 } else { 7371 // If this is an explicit specialization of a static data member, check it. 7372 if (IsMemberSpecialization && !NewVD->isInvalidDecl() && 7373 CheckMemberSpecialization(NewVD, Previous)) 7374 NewVD->setInvalidDecl(); 7375 7376 // Merge the decl with the existing one if appropriate. 7377 if (!Previous.empty()) { 7378 if (Previous.isSingleResult() && 7379 isa<FieldDecl>(Previous.getFoundDecl()) && 7380 D.getCXXScopeSpec().isSet()) { 7381 // The user tried to define a non-static data member 7382 // out-of-line (C++ [dcl.meaning]p1). 7383 Diag(NewVD->getLocation(), diag::err_nonstatic_member_out_of_line) 7384 << D.getCXXScopeSpec().getRange(); 7385 Previous.clear(); 7386 NewVD->setInvalidDecl(); 7387 } 7388 } else if (D.getCXXScopeSpec().isSet()) { 7389 // No previous declaration in the qualifying scope. 7390 Diag(D.getIdentifierLoc(), diag::err_no_member) 7391 << Name << computeDeclContext(D.getCXXScopeSpec(), true) 7392 << D.getCXXScopeSpec().getRange(); 7393 NewVD->setInvalidDecl(); 7394 } 7395 7396 if (!IsVariableTemplateSpecialization) 7397 D.setRedeclaration(CheckVariableDeclaration(NewVD, Previous)); 7398 7399 if (NewTemplate) { 7400 VarTemplateDecl *PrevVarTemplate = 7401 NewVD->getPreviousDecl() 7402 ? NewVD->getPreviousDecl()->getDescribedVarTemplate() 7403 : nullptr; 7404 7405 // Check the template parameter list of this declaration, possibly 7406 // merging in the template parameter list from the previous variable 7407 // template declaration. 7408 if (CheckTemplateParameterList( 7409 TemplateParams, 7410 PrevVarTemplate ? PrevVarTemplate->getTemplateParameters() 7411 : nullptr, 7412 (D.getCXXScopeSpec().isSet() && DC && DC->isRecord() && 7413 DC->isDependentContext()) 7414 ? TPC_ClassTemplateMember 7415 : TPC_VarTemplate)) 7416 NewVD->setInvalidDecl(); 7417 7418 // If we are providing an explicit specialization of a static variable 7419 // template, make a note of that. 7420 if (PrevVarTemplate && 7421 PrevVarTemplate->getInstantiatedFromMemberTemplate()) 7422 PrevVarTemplate->setMemberSpecialization(); 7423 } 7424 } 7425 7426 // Diagnose shadowed variables iff this isn't a redeclaration. 7427 if (ShadowedDecl && !D.isRedeclaration()) 7428 CheckShadow(NewVD, ShadowedDecl, Previous); 7429 7430 ProcessPragmaWeak(S, NewVD); 7431 7432 // If this is the first declaration of an extern C variable, update 7433 // the map of such variables. 7434 if (NewVD->isFirstDecl() && !NewVD->isInvalidDecl() && 7435 isIncompleteDeclExternC(*this, NewVD)) 7436 RegisterLocallyScopedExternCDecl(NewVD, S); 7437 7438 if (getLangOpts().CPlusPlus && NewVD->isStaticLocal()) { 7439 MangleNumberingContext *MCtx; 7440 Decl *ManglingContextDecl; 7441 std::tie(MCtx, ManglingContextDecl) = 7442 getCurrentMangleNumberContext(NewVD->getDeclContext()); 7443 if (MCtx) { 7444 Context.setManglingNumber( 7445 NewVD, MCtx->getManglingNumber( 7446 NewVD, getMSManglingNumber(getLangOpts(), S))); 7447 Context.setStaticLocalNumber(NewVD, MCtx->getStaticLocalNumber(NewVD)); 7448 } 7449 } 7450 7451 // Special handling of variable named 'main'. 7452 if (Name.getAsIdentifierInfo() && Name.getAsIdentifierInfo()->isStr("main") && 7453 NewVD->getDeclContext()->getRedeclContext()->isTranslationUnit() && 7454 !getLangOpts().Freestanding && !NewVD->getDescribedVarTemplate()) { 7455 7456 // C++ [basic.start.main]p3 7457 // A program that declares a variable main at global scope is ill-formed. 7458 if (getLangOpts().CPlusPlus) 7459 Diag(D.getBeginLoc(), diag::err_main_global_variable); 7460 7461 // In C, and external-linkage variable named main results in undefined 7462 // behavior. 7463 else if (NewVD->hasExternalFormalLinkage()) 7464 Diag(D.getBeginLoc(), diag::warn_main_redefined); 7465 } 7466 7467 if (D.isRedeclaration() && !Previous.empty()) { 7468 NamedDecl *Prev = Previous.getRepresentativeDecl(); 7469 checkDLLAttributeRedeclaration(*this, Prev, NewVD, IsMemberSpecialization, 7470 D.isFunctionDefinition()); 7471 } 7472 7473 if (NewTemplate) { 7474 if (NewVD->isInvalidDecl()) 7475 NewTemplate->setInvalidDecl(); 7476 ActOnDocumentableDecl(NewTemplate); 7477 return NewTemplate; 7478 } 7479 7480 if (IsMemberSpecialization && !NewVD->isInvalidDecl()) 7481 CompleteMemberSpecialization(NewVD, Previous); 7482 7483 return NewVD; 7484 } 7485 7486 /// Enum describing the %select options in diag::warn_decl_shadow. 7487 enum ShadowedDeclKind { 7488 SDK_Local, 7489 SDK_Global, 7490 SDK_StaticMember, 7491 SDK_Field, 7492 SDK_Typedef, 7493 SDK_Using 7494 }; 7495 7496 /// Determine what kind of declaration we're shadowing. 7497 static ShadowedDeclKind computeShadowedDeclKind(const NamedDecl *ShadowedDecl, 7498 const DeclContext *OldDC) { 7499 if (isa<TypeAliasDecl>(ShadowedDecl)) 7500 return SDK_Using; 7501 else if (isa<TypedefDecl>(ShadowedDecl)) 7502 return SDK_Typedef; 7503 else if (isa<RecordDecl>(OldDC)) 7504 return isa<FieldDecl>(ShadowedDecl) ? SDK_Field : SDK_StaticMember; 7505 7506 return OldDC->isFileContext() ? SDK_Global : SDK_Local; 7507 } 7508 7509 /// Return the location of the capture if the given lambda captures the given 7510 /// variable \p VD, or an invalid source location otherwise. 7511 static SourceLocation getCaptureLocation(const LambdaScopeInfo *LSI, 7512 const VarDecl *VD) { 7513 for (const Capture &Capture : LSI->Captures) { 7514 if (Capture.isVariableCapture() && Capture.getVariable() == VD) 7515 return Capture.getLocation(); 7516 } 7517 return SourceLocation(); 7518 } 7519 7520 static bool shouldWarnIfShadowedDecl(const DiagnosticsEngine &Diags, 7521 const LookupResult &R) { 7522 // Only diagnose if we're shadowing an unambiguous field or variable. 7523 if (R.getResultKind() != LookupResult::Found) 7524 return false; 7525 7526 // Return false if warning is ignored. 7527 return !Diags.isIgnored(diag::warn_decl_shadow, R.getNameLoc()); 7528 } 7529 7530 /// Return the declaration shadowed by the given variable \p D, or null 7531 /// if it doesn't shadow any declaration or shadowing warnings are disabled. 7532 NamedDecl *Sema::getShadowedDeclaration(const VarDecl *D, 7533 const LookupResult &R) { 7534 if (!shouldWarnIfShadowedDecl(Diags, R)) 7535 return nullptr; 7536 7537 // Don't diagnose declarations at file scope. 7538 if (D->hasGlobalStorage()) 7539 return nullptr; 7540 7541 NamedDecl *ShadowedDecl = R.getFoundDecl(); 7542 return isa<VarDecl>(ShadowedDecl) || isa<FieldDecl>(ShadowedDecl) 7543 ? ShadowedDecl 7544 : nullptr; 7545 } 7546 7547 /// Return the declaration shadowed by the given typedef \p D, or null 7548 /// if it doesn't shadow any declaration or shadowing warnings are disabled. 7549 NamedDecl *Sema::getShadowedDeclaration(const TypedefNameDecl *D, 7550 const LookupResult &R) { 7551 // Don't warn if typedef declaration is part of a class 7552 if (D->getDeclContext()->isRecord()) 7553 return nullptr; 7554 7555 if (!shouldWarnIfShadowedDecl(Diags, R)) 7556 return nullptr; 7557 7558 NamedDecl *ShadowedDecl = R.getFoundDecl(); 7559 return isa<TypedefNameDecl>(ShadowedDecl) ? ShadowedDecl : nullptr; 7560 } 7561 7562 /// Diagnose variable or built-in function shadowing. Implements 7563 /// -Wshadow. 7564 /// 7565 /// This method is called whenever a VarDecl is added to a "useful" 7566 /// scope. 7567 /// 7568 /// \param ShadowedDecl the declaration that is shadowed by the given variable 7569 /// \param R the lookup of the name 7570 /// 7571 void Sema::CheckShadow(NamedDecl *D, NamedDecl *ShadowedDecl, 7572 const LookupResult &R) { 7573 DeclContext *NewDC = D->getDeclContext(); 7574 7575 if (FieldDecl *FD = dyn_cast<FieldDecl>(ShadowedDecl)) { 7576 // Fields are not shadowed by variables in C++ static methods. 7577 if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(NewDC)) 7578 if (MD->isStatic()) 7579 return; 7580 7581 // Fields shadowed by constructor parameters are a special case. Usually 7582 // the constructor initializes the field with the parameter. 7583 if (isa<CXXConstructorDecl>(NewDC)) 7584 if (const auto PVD = dyn_cast<ParmVarDecl>(D)) { 7585 // Remember that this was shadowed so we can either warn about its 7586 // modification or its existence depending on warning settings. 7587 ShadowingDecls.insert({PVD->getCanonicalDecl(), FD}); 7588 return; 7589 } 7590 } 7591 7592 if (VarDecl *shadowedVar = dyn_cast<VarDecl>(ShadowedDecl)) 7593 if (shadowedVar->isExternC()) { 7594 // For shadowing external vars, make sure that we point to the global 7595 // declaration, not a locally scoped extern declaration. 7596 for (auto I : shadowedVar->redecls()) 7597 if (I->isFileVarDecl()) { 7598 ShadowedDecl = I; 7599 break; 7600 } 7601 } 7602 7603 DeclContext *OldDC = ShadowedDecl->getDeclContext()->getRedeclContext(); 7604 7605 unsigned WarningDiag = diag::warn_decl_shadow; 7606 SourceLocation CaptureLoc; 7607 if (isa<VarDecl>(D) && isa<VarDecl>(ShadowedDecl) && NewDC && 7608 isa<CXXMethodDecl>(NewDC)) { 7609 if (const auto *RD = dyn_cast<CXXRecordDecl>(NewDC->getParent())) { 7610 if (RD->isLambda() && OldDC->Encloses(NewDC->getLexicalParent())) { 7611 if (RD->getLambdaCaptureDefault() == LCD_None) { 7612 // Try to avoid warnings for lambdas with an explicit capture list. 7613 const auto *LSI = cast<LambdaScopeInfo>(getCurFunction()); 7614 // Warn only when the lambda captures the shadowed decl explicitly. 7615 CaptureLoc = getCaptureLocation(LSI, cast<VarDecl>(ShadowedDecl)); 7616 if (CaptureLoc.isInvalid()) 7617 WarningDiag = diag::warn_decl_shadow_uncaptured_local; 7618 } else { 7619 // Remember that this was shadowed so we can avoid the warning if the 7620 // shadowed decl isn't captured and the warning settings allow it. 7621 cast<LambdaScopeInfo>(getCurFunction()) 7622 ->ShadowingDecls.push_back( 7623 {cast<VarDecl>(D), cast<VarDecl>(ShadowedDecl)}); 7624 return; 7625 } 7626 } 7627 7628 if (cast<VarDecl>(ShadowedDecl)->hasLocalStorage()) { 7629 // A variable can't shadow a local variable in an enclosing scope, if 7630 // they are separated by a non-capturing declaration context. 7631 for (DeclContext *ParentDC = NewDC; 7632 ParentDC && !ParentDC->Equals(OldDC); 7633 ParentDC = getLambdaAwareParentOfDeclContext(ParentDC)) { 7634 // Only block literals, captured statements, and lambda expressions 7635 // can capture; other scopes don't. 7636 if (!isa<BlockDecl>(ParentDC) && !isa<CapturedDecl>(ParentDC) && 7637 !isLambdaCallOperator(ParentDC)) { 7638 return; 7639 } 7640 } 7641 } 7642 } 7643 } 7644 7645 // Only warn about certain kinds of shadowing for class members. 7646 if (NewDC && NewDC->isRecord()) { 7647 // In particular, don't warn about shadowing non-class members. 7648 if (!OldDC->isRecord()) 7649 return; 7650 7651 // TODO: should we warn about static data members shadowing 7652 // static data members from base classes? 7653 7654 // TODO: don't diagnose for inaccessible shadowed members. 7655 // This is hard to do perfectly because we might friend the 7656 // shadowing context, but that's just a false negative. 7657 } 7658 7659 7660 DeclarationName Name = R.getLookupName(); 7661 7662 // Emit warning and note. 7663 if (getSourceManager().isInSystemMacro(R.getNameLoc())) 7664 return; 7665 ShadowedDeclKind Kind = computeShadowedDeclKind(ShadowedDecl, OldDC); 7666 Diag(R.getNameLoc(), WarningDiag) << Name << Kind << OldDC; 7667 if (!CaptureLoc.isInvalid()) 7668 Diag(CaptureLoc, diag::note_var_explicitly_captured_here) 7669 << Name << /*explicitly*/ 1; 7670 Diag(ShadowedDecl->getLocation(), diag::note_previous_declaration); 7671 } 7672 7673 /// Diagnose shadowing for variables shadowed in the lambda record \p LambdaRD 7674 /// when these variables are captured by the lambda. 7675 void Sema::DiagnoseShadowingLambdaDecls(const LambdaScopeInfo *LSI) { 7676 for (const auto &Shadow : LSI->ShadowingDecls) { 7677 const VarDecl *ShadowedDecl = Shadow.ShadowedDecl; 7678 // Try to avoid the warning when the shadowed decl isn't captured. 7679 SourceLocation CaptureLoc = getCaptureLocation(LSI, ShadowedDecl); 7680 const DeclContext *OldDC = ShadowedDecl->getDeclContext(); 7681 Diag(Shadow.VD->getLocation(), CaptureLoc.isInvalid() 7682 ? diag::warn_decl_shadow_uncaptured_local 7683 : diag::warn_decl_shadow) 7684 << Shadow.VD->getDeclName() 7685 << computeShadowedDeclKind(ShadowedDecl, OldDC) << OldDC; 7686 if (!CaptureLoc.isInvalid()) 7687 Diag(CaptureLoc, diag::note_var_explicitly_captured_here) 7688 << Shadow.VD->getDeclName() << /*explicitly*/ 0; 7689 Diag(ShadowedDecl->getLocation(), diag::note_previous_declaration); 7690 } 7691 } 7692 7693 /// Check -Wshadow without the advantage of a previous lookup. 7694 void Sema::CheckShadow(Scope *S, VarDecl *D) { 7695 if (Diags.isIgnored(diag::warn_decl_shadow, D->getLocation())) 7696 return; 7697 7698 LookupResult R(*this, D->getDeclName(), D->getLocation(), 7699 Sema::LookupOrdinaryName, Sema::ForVisibleRedeclaration); 7700 LookupName(R, S); 7701 if (NamedDecl *ShadowedDecl = getShadowedDeclaration(D, R)) 7702 CheckShadow(D, ShadowedDecl, R); 7703 } 7704 7705 /// Check if 'E', which is an expression that is about to be modified, refers 7706 /// to a constructor parameter that shadows a field. 7707 void Sema::CheckShadowingDeclModification(Expr *E, SourceLocation Loc) { 7708 // Quickly ignore expressions that can't be shadowing ctor parameters. 7709 if (!getLangOpts().CPlusPlus || ShadowingDecls.empty()) 7710 return; 7711 E = E->IgnoreParenImpCasts(); 7712 auto *DRE = dyn_cast<DeclRefExpr>(E); 7713 if (!DRE) 7714 return; 7715 const NamedDecl *D = cast<NamedDecl>(DRE->getDecl()->getCanonicalDecl()); 7716 auto I = ShadowingDecls.find(D); 7717 if (I == ShadowingDecls.end()) 7718 return; 7719 const NamedDecl *ShadowedDecl = I->second; 7720 const DeclContext *OldDC = ShadowedDecl->getDeclContext(); 7721 Diag(Loc, diag::warn_modifying_shadowing_decl) << D << OldDC; 7722 Diag(D->getLocation(), diag::note_var_declared_here) << D; 7723 Diag(ShadowedDecl->getLocation(), diag::note_previous_declaration); 7724 7725 // Avoid issuing multiple warnings about the same decl. 7726 ShadowingDecls.erase(I); 7727 } 7728 7729 /// Check for conflict between this global or extern "C" declaration and 7730 /// previous global or extern "C" declarations. This is only used in C++. 7731 template<typename T> 7732 static bool checkGlobalOrExternCConflict( 7733 Sema &S, const T *ND, bool IsGlobal, LookupResult &Previous) { 7734 assert(S.getLangOpts().CPlusPlus && "only C++ has extern \"C\""); 7735 NamedDecl *Prev = S.findLocallyScopedExternCDecl(ND->getDeclName()); 7736 7737 if (!Prev && IsGlobal && !isIncompleteDeclExternC(S, ND)) { 7738 // The common case: this global doesn't conflict with any extern "C" 7739 // declaration. 7740 return false; 7741 } 7742 7743 if (Prev) { 7744 if (!IsGlobal || isIncompleteDeclExternC(S, ND)) { 7745 // Both the old and new declarations have C language linkage. This is a 7746 // redeclaration. 7747 Previous.clear(); 7748 Previous.addDecl(Prev); 7749 return true; 7750 } 7751 7752 // This is a global, non-extern "C" declaration, and there is a previous 7753 // non-global extern "C" declaration. Diagnose if this is a variable 7754 // declaration. 7755 if (!isa<VarDecl>(ND)) 7756 return false; 7757 } else { 7758 // The declaration is extern "C". Check for any declaration in the 7759 // translation unit which might conflict. 7760 if (IsGlobal) { 7761 // We have already performed the lookup into the translation unit. 7762 IsGlobal = false; 7763 for (LookupResult::iterator I = Previous.begin(), E = Previous.end(); 7764 I != E; ++I) { 7765 if (isa<VarDecl>(*I)) { 7766 Prev = *I; 7767 break; 7768 } 7769 } 7770 } else { 7771 DeclContext::lookup_result R = 7772 S.Context.getTranslationUnitDecl()->lookup(ND->getDeclName()); 7773 for (DeclContext::lookup_result::iterator I = R.begin(), E = R.end(); 7774 I != E; ++I) { 7775 if (isa<VarDecl>(*I)) { 7776 Prev = *I; 7777 break; 7778 } 7779 // FIXME: If we have any other entity with this name in global scope, 7780 // the declaration is ill-formed, but that is a defect: it breaks the 7781 // 'stat' hack, for instance. Only variables can have mangled name 7782 // clashes with extern "C" declarations, so only they deserve a 7783 // diagnostic. 7784 } 7785 } 7786 7787 if (!Prev) 7788 return false; 7789 } 7790 7791 // Use the first declaration's location to ensure we point at something which 7792 // is lexically inside an extern "C" linkage-spec. 7793 assert(Prev && "should have found a previous declaration to diagnose"); 7794 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(Prev)) 7795 Prev = FD->getFirstDecl(); 7796 else 7797 Prev = cast<VarDecl>(Prev)->getFirstDecl(); 7798 7799 S.Diag(ND->getLocation(), diag::err_extern_c_global_conflict) 7800 << IsGlobal << ND; 7801 S.Diag(Prev->getLocation(), diag::note_extern_c_global_conflict) 7802 << IsGlobal; 7803 return false; 7804 } 7805 7806 /// Apply special rules for handling extern "C" declarations. Returns \c true 7807 /// if we have found that this is a redeclaration of some prior entity. 7808 /// 7809 /// Per C++ [dcl.link]p6: 7810 /// Two declarations [for a function or variable] with C language linkage 7811 /// with the same name that appear in different scopes refer to the same 7812 /// [entity]. An entity with C language linkage shall not be declared with 7813 /// the same name as an entity in global scope. 7814 template<typename T> 7815 static bool checkForConflictWithNonVisibleExternC(Sema &S, const T *ND, 7816 LookupResult &Previous) { 7817 if (!S.getLangOpts().CPlusPlus) { 7818 // In C, when declaring a global variable, look for a corresponding 'extern' 7819 // variable declared in function scope. We don't need this in C++, because 7820 // we find local extern decls in the surrounding file-scope DeclContext. 7821 if (ND->getDeclContext()->getRedeclContext()->isTranslationUnit()) { 7822 if (NamedDecl *Prev = S.findLocallyScopedExternCDecl(ND->getDeclName())) { 7823 Previous.clear(); 7824 Previous.addDecl(Prev); 7825 return true; 7826 } 7827 } 7828 return false; 7829 } 7830 7831 // A declaration in the translation unit can conflict with an extern "C" 7832 // declaration. 7833 if (ND->getDeclContext()->getRedeclContext()->isTranslationUnit()) 7834 return checkGlobalOrExternCConflict(S, ND, /*IsGlobal*/true, Previous); 7835 7836 // An extern "C" declaration can conflict with a declaration in the 7837 // translation unit or can be a redeclaration of an extern "C" declaration 7838 // in another scope. 7839 if (isIncompleteDeclExternC(S,ND)) 7840 return checkGlobalOrExternCConflict(S, ND, /*IsGlobal*/false, Previous); 7841 7842 // Neither global nor extern "C": nothing to do. 7843 return false; 7844 } 7845 7846 void Sema::CheckVariableDeclarationType(VarDecl *NewVD) { 7847 // If the decl is already known invalid, don't check it. 7848 if (NewVD->isInvalidDecl()) 7849 return; 7850 7851 QualType T = NewVD->getType(); 7852 7853 // Defer checking an 'auto' type until its initializer is attached. 7854 if (T->isUndeducedType()) 7855 return; 7856 7857 if (NewVD->hasAttrs()) 7858 CheckAlignasUnderalignment(NewVD); 7859 7860 if (T->isObjCObjectType()) { 7861 Diag(NewVD->getLocation(), diag::err_statically_allocated_object) 7862 << FixItHint::CreateInsertion(NewVD->getLocation(), "*"); 7863 T = Context.getObjCObjectPointerType(T); 7864 NewVD->setType(T); 7865 } 7866 7867 // Emit an error if an address space was applied to decl with local storage. 7868 // This includes arrays of objects with address space qualifiers, but not 7869 // automatic variables that point to other address spaces. 7870 // ISO/IEC TR 18037 S5.1.2 7871 if (!getLangOpts().OpenCL && NewVD->hasLocalStorage() && 7872 T.getAddressSpace() != LangAS::Default) { 7873 Diag(NewVD->getLocation(), diag::err_as_qualified_auto_decl) << 0; 7874 NewVD->setInvalidDecl(); 7875 return; 7876 } 7877 7878 // OpenCL v1.2 s6.8 - The static qualifier is valid only in program 7879 // scope. 7880 if (getLangOpts().OpenCLVersion == 120 && 7881 !getOpenCLOptions().isEnabled("cl_clang_storage_class_specifiers") && 7882 NewVD->isStaticLocal()) { 7883 Diag(NewVD->getLocation(), diag::err_static_function_scope); 7884 NewVD->setInvalidDecl(); 7885 return; 7886 } 7887 7888 if (getLangOpts().OpenCL) { 7889 // OpenCL v2.0 s6.12.5 - The __block storage type is not supported. 7890 if (NewVD->hasAttr<BlocksAttr>()) { 7891 Diag(NewVD->getLocation(), diag::err_opencl_block_storage_type); 7892 return; 7893 } 7894 7895 if (T->isBlockPointerType()) { 7896 // OpenCL v2.0 s6.12.5 - Any block declaration must be const qualified and 7897 // can't use 'extern' storage class. 7898 if (!T.isConstQualified()) { 7899 Diag(NewVD->getLocation(), diag::err_opencl_invalid_block_declaration) 7900 << 0 /*const*/; 7901 NewVD->setInvalidDecl(); 7902 return; 7903 } 7904 if (NewVD->hasExternalStorage()) { 7905 Diag(NewVD->getLocation(), diag::err_opencl_extern_block_declaration); 7906 NewVD->setInvalidDecl(); 7907 return; 7908 } 7909 } 7910 // OpenCL C v1.2 s6.5 - All program scope variables must be declared in the 7911 // __constant address space. 7912 // OpenCL C v2.0 s6.5.1 - Variables defined at program scope and static 7913 // variables inside a function can also be declared in the global 7914 // address space. 7915 // C++ for OpenCL inherits rule from OpenCL C v2.0. 7916 // FIXME: Adding local AS in C++ for OpenCL might make sense. 7917 if (NewVD->isFileVarDecl() || NewVD->isStaticLocal() || 7918 NewVD->hasExternalStorage()) { 7919 if (!T->isSamplerT() && 7920 !T->isDependentType() && 7921 !(T.getAddressSpace() == LangAS::opencl_constant || 7922 (T.getAddressSpace() == LangAS::opencl_global && 7923 (getLangOpts().OpenCLVersion == 200 || 7924 getLangOpts().OpenCLCPlusPlus)))) { 7925 int Scope = NewVD->isStaticLocal() | NewVD->hasExternalStorage() << 1; 7926 if (getLangOpts().OpenCLVersion == 200 || getLangOpts().OpenCLCPlusPlus) 7927 Diag(NewVD->getLocation(), diag::err_opencl_global_invalid_addr_space) 7928 << Scope << "global or constant"; 7929 else 7930 Diag(NewVD->getLocation(), diag::err_opencl_global_invalid_addr_space) 7931 << Scope << "constant"; 7932 NewVD->setInvalidDecl(); 7933 return; 7934 } 7935 } else { 7936 if (T.getAddressSpace() == LangAS::opencl_global) { 7937 Diag(NewVD->getLocation(), diag::err_opencl_function_variable) 7938 << 1 /*is any function*/ << "global"; 7939 NewVD->setInvalidDecl(); 7940 return; 7941 } 7942 if (T.getAddressSpace() == LangAS::opencl_constant || 7943 T.getAddressSpace() == LangAS::opencl_local) { 7944 FunctionDecl *FD = getCurFunctionDecl(); 7945 // OpenCL v1.1 s6.5.2 and s6.5.3: no local or constant variables 7946 // in functions. 7947 if (FD && !FD->hasAttr<OpenCLKernelAttr>()) { 7948 if (T.getAddressSpace() == LangAS::opencl_constant) 7949 Diag(NewVD->getLocation(), diag::err_opencl_function_variable) 7950 << 0 /*non-kernel only*/ << "constant"; 7951 else 7952 Diag(NewVD->getLocation(), diag::err_opencl_function_variable) 7953 << 0 /*non-kernel only*/ << "local"; 7954 NewVD->setInvalidDecl(); 7955 return; 7956 } 7957 // OpenCL v2.0 s6.5.2 and s6.5.3: local and constant variables must be 7958 // in the outermost scope of a kernel function. 7959 if (FD && FD->hasAttr<OpenCLKernelAttr>()) { 7960 if (!getCurScope()->isFunctionScope()) { 7961 if (T.getAddressSpace() == LangAS::opencl_constant) 7962 Diag(NewVD->getLocation(), diag::err_opencl_addrspace_scope) 7963 << "constant"; 7964 else 7965 Diag(NewVD->getLocation(), diag::err_opencl_addrspace_scope) 7966 << "local"; 7967 NewVD->setInvalidDecl(); 7968 return; 7969 } 7970 } 7971 } else if (T.getAddressSpace() != LangAS::opencl_private && 7972 // If we are parsing a template we didn't deduce an addr 7973 // space yet. 7974 T.getAddressSpace() != LangAS::Default) { 7975 // Do not allow other address spaces on automatic variable. 7976 Diag(NewVD->getLocation(), diag::err_as_qualified_auto_decl) << 1; 7977 NewVD->setInvalidDecl(); 7978 return; 7979 } 7980 } 7981 } 7982 7983 if (NewVD->hasLocalStorage() && T.isObjCGCWeak() 7984 && !NewVD->hasAttr<BlocksAttr>()) { 7985 if (getLangOpts().getGC() != LangOptions::NonGC) 7986 Diag(NewVD->getLocation(), diag::warn_gc_attribute_weak_on_local); 7987 else { 7988 assert(!getLangOpts().ObjCAutoRefCount); 7989 Diag(NewVD->getLocation(), diag::warn_attribute_weak_on_local); 7990 } 7991 } 7992 7993 bool isVM = T->isVariablyModifiedType(); 7994 if (isVM || NewVD->hasAttr<CleanupAttr>() || 7995 NewVD->hasAttr<BlocksAttr>()) 7996 setFunctionHasBranchProtectedScope(); 7997 7998 if ((isVM && NewVD->hasLinkage()) || 7999 (T->isVariableArrayType() && NewVD->hasGlobalStorage())) { 8000 bool SizeIsNegative; 8001 llvm::APSInt Oversized; 8002 TypeSourceInfo *FixedTInfo = TryToFixInvalidVariablyModifiedTypeSourceInfo( 8003 NewVD->getTypeSourceInfo(), Context, SizeIsNegative, Oversized); 8004 QualType FixedT; 8005 if (FixedTInfo && T == NewVD->getTypeSourceInfo()->getType()) 8006 FixedT = FixedTInfo->getType(); 8007 else if (FixedTInfo) { 8008 // Type and type-as-written are canonically different. We need to fix up 8009 // both types separately. 8010 FixedT = TryToFixInvalidVariablyModifiedType(T, Context, SizeIsNegative, 8011 Oversized); 8012 } 8013 if ((!FixedTInfo || FixedT.isNull()) && T->isVariableArrayType()) { 8014 const VariableArrayType *VAT = Context.getAsVariableArrayType(T); 8015 // FIXME: This won't give the correct result for 8016 // int a[10][n]; 8017 SourceRange SizeRange = VAT->getSizeExpr()->getSourceRange(); 8018 8019 if (NewVD->isFileVarDecl()) 8020 Diag(NewVD->getLocation(), diag::err_vla_decl_in_file_scope) 8021 << SizeRange; 8022 else if (NewVD->isStaticLocal()) 8023 Diag(NewVD->getLocation(), diag::err_vla_decl_has_static_storage) 8024 << SizeRange; 8025 else 8026 Diag(NewVD->getLocation(), diag::err_vla_decl_has_extern_linkage) 8027 << SizeRange; 8028 NewVD->setInvalidDecl(); 8029 return; 8030 } 8031 8032 if (!FixedTInfo) { 8033 if (NewVD->isFileVarDecl()) 8034 Diag(NewVD->getLocation(), diag::err_vm_decl_in_file_scope); 8035 else 8036 Diag(NewVD->getLocation(), diag::err_vm_decl_has_extern_linkage); 8037 NewVD->setInvalidDecl(); 8038 return; 8039 } 8040 8041 Diag(NewVD->getLocation(), diag::ext_vla_folded_to_constant); 8042 NewVD->setType(FixedT); 8043 NewVD->setTypeSourceInfo(FixedTInfo); 8044 } 8045 8046 if (T->isVoidType()) { 8047 // C++98 [dcl.stc]p5: The extern specifier can be applied only to the names 8048 // of objects and functions. 8049 if (NewVD->isThisDeclarationADefinition() || getLangOpts().CPlusPlus) { 8050 Diag(NewVD->getLocation(), diag::err_typecheck_decl_incomplete_type) 8051 << T; 8052 NewVD->setInvalidDecl(); 8053 return; 8054 } 8055 } 8056 8057 if (!NewVD->hasLocalStorage() && NewVD->hasAttr<BlocksAttr>()) { 8058 Diag(NewVD->getLocation(), diag::err_block_on_nonlocal); 8059 NewVD->setInvalidDecl(); 8060 return; 8061 } 8062 8063 if (!NewVD->hasLocalStorage() && T->isSizelessType()) { 8064 Diag(NewVD->getLocation(), diag::err_sizeless_nonlocal) << T; 8065 NewVD->setInvalidDecl(); 8066 return; 8067 } 8068 8069 if (isVM && NewVD->hasAttr<BlocksAttr>()) { 8070 Diag(NewVD->getLocation(), diag::err_block_on_vm); 8071 NewVD->setInvalidDecl(); 8072 return; 8073 } 8074 8075 if (NewVD->isConstexpr() && !T->isDependentType() && 8076 RequireLiteralType(NewVD->getLocation(), T, 8077 diag::err_constexpr_var_non_literal)) { 8078 NewVD->setInvalidDecl(); 8079 return; 8080 } 8081 8082 // PPC MMA non-pointer types are not allowed as non-local variable types. 8083 if (Context.getTargetInfo().getTriple().isPPC64() && 8084 !NewVD->isLocalVarDecl() && 8085 CheckPPCMMAType(T, NewVD->getLocation())) { 8086 NewVD->setInvalidDecl(); 8087 return; 8088 } 8089 } 8090 8091 /// Perform semantic checking on a newly-created variable 8092 /// declaration. 8093 /// 8094 /// This routine performs all of the type-checking required for a 8095 /// variable declaration once it has been built. It is used both to 8096 /// check variables after they have been parsed and their declarators 8097 /// have been translated into a declaration, and to check variables 8098 /// that have been instantiated from a template. 8099 /// 8100 /// Sets NewVD->isInvalidDecl() if an error was encountered. 8101 /// 8102 /// Returns true if the variable declaration is a redeclaration. 8103 bool Sema::CheckVariableDeclaration(VarDecl *NewVD, LookupResult &Previous) { 8104 CheckVariableDeclarationType(NewVD); 8105 8106 // If the decl is already known invalid, don't check it. 8107 if (NewVD->isInvalidDecl()) 8108 return false; 8109 8110 // If we did not find anything by this name, look for a non-visible 8111 // extern "C" declaration with the same name. 8112 if (Previous.empty() && 8113 checkForConflictWithNonVisibleExternC(*this, NewVD, Previous)) 8114 Previous.setShadowed(); 8115 8116 if (!Previous.empty()) { 8117 MergeVarDecl(NewVD, Previous); 8118 return true; 8119 } 8120 return false; 8121 } 8122 8123 /// AddOverriddenMethods - See if a method overrides any in the base classes, 8124 /// and if so, check that it's a valid override and remember it. 8125 bool Sema::AddOverriddenMethods(CXXRecordDecl *DC, CXXMethodDecl *MD) { 8126 llvm::SmallPtrSet<const CXXMethodDecl*, 4> Overridden; 8127 8128 // Look for methods in base classes that this method might override. 8129 CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/false, 8130 /*DetectVirtual=*/false); 8131 auto VisitBase = [&] (const CXXBaseSpecifier *Specifier, CXXBasePath &Path) { 8132 CXXRecordDecl *BaseRecord = Specifier->getType()->getAsCXXRecordDecl(); 8133 DeclarationName Name = MD->getDeclName(); 8134 8135 if (Name.getNameKind() == DeclarationName::CXXDestructorName) { 8136 // We really want to find the base class destructor here. 8137 QualType T = Context.getTypeDeclType(BaseRecord); 8138 CanQualType CT = Context.getCanonicalType(T); 8139 Name = Context.DeclarationNames.getCXXDestructorName(CT); 8140 } 8141 8142 for (NamedDecl *BaseND : BaseRecord->lookup(Name)) { 8143 CXXMethodDecl *BaseMD = 8144 dyn_cast<CXXMethodDecl>(BaseND->getCanonicalDecl()); 8145 if (!BaseMD || !BaseMD->isVirtual() || 8146 IsOverload(MD, BaseMD, /*UseMemberUsingDeclRules=*/false, 8147 /*ConsiderCudaAttrs=*/true, 8148 // C++2a [class.virtual]p2 does not consider requires 8149 // clauses when overriding. 8150 /*ConsiderRequiresClauses=*/false)) 8151 continue; 8152 8153 if (Overridden.insert(BaseMD).second) { 8154 MD->addOverriddenMethod(BaseMD); 8155 CheckOverridingFunctionReturnType(MD, BaseMD); 8156 CheckOverridingFunctionAttributes(MD, BaseMD); 8157 CheckOverridingFunctionExceptionSpec(MD, BaseMD); 8158 CheckIfOverriddenFunctionIsMarkedFinal(MD, BaseMD); 8159 } 8160 8161 // A method can only override one function from each base class. We 8162 // don't track indirectly overridden methods from bases of bases. 8163 return true; 8164 } 8165 8166 return false; 8167 }; 8168 8169 DC->lookupInBases(VisitBase, Paths); 8170 return !Overridden.empty(); 8171 } 8172 8173 namespace { 8174 // Struct for holding all of the extra arguments needed by 8175 // DiagnoseInvalidRedeclaration to call Sema::ActOnFunctionDeclarator. 8176 struct ActOnFDArgs { 8177 Scope *S; 8178 Declarator &D; 8179 MultiTemplateParamsArg TemplateParamLists; 8180 bool AddToScope; 8181 }; 8182 } // end anonymous namespace 8183 8184 namespace { 8185 8186 // Callback to only accept typo corrections that have a non-zero edit distance. 8187 // Also only accept corrections that have the same parent decl. 8188 class DifferentNameValidatorCCC final : public CorrectionCandidateCallback { 8189 public: 8190 DifferentNameValidatorCCC(ASTContext &Context, FunctionDecl *TypoFD, 8191 CXXRecordDecl *Parent) 8192 : Context(Context), OriginalFD(TypoFD), 8193 ExpectedParent(Parent ? Parent->getCanonicalDecl() : nullptr) {} 8194 8195 bool ValidateCandidate(const TypoCorrection &candidate) override { 8196 if (candidate.getEditDistance() == 0) 8197 return false; 8198 8199 SmallVector<unsigned, 1> MismatchedParams; 8200 for (TypoCorrection::const_decl_iterator CDecl = candidate.begin(), 8201 CDeclEnd = candidate.end(); 8202 CDecl != CDeclEnd; ++CDecl) { 8203 FunctionDecl *FD = dyn_cast<FunctionDecl>(*CDecl); 8204 8205 if (FD && !FD->hasBody() && 8206 hasSimilarParameters(Context, FD, OriginalFD, MismatchedParams)) { 8207 if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) { 8208 CXXRecordDecl *Parent = MD->getParent(); 8209 if (Parent && Parent->getCanonicalDecl() == ExpectedParent) 8210 return true; 8211 } else if (!ExpectedParent) { 8212 return true; 8213 } 8214 } 8215 } 8216 8217 return false; 8218 } 8219 8220 std::unique_ptr<CorrectionCandidateCallback> clone() override { 8221 return std::make_unique<DifferentNameValidatorCCC>(*this); 8222 } 8223 8224 private: 8225 ASTContext &Context; 8226 FunctionDecl *OriginalFD; 8227 CXXRecordDecl *ExpectedParent; 8228 }; 8229 8230 } // end anonymous namespace 8231 8232 void Sema::MarkTypoCorrectedFunctionDefinition(const NamedDecl *F) { 8233 TypoCorrectedFunctionDefinitions.insert(F); 8234 } 8235 8236 /// Generate diagnostics for an invalid function redeclaration. 8237 /// 8238 /// This routine handles generating the diagnostic messages for an invalid 8239 /// function redeclaration, including finding possible similar declarations 8240 /// or performing typo correction if there are no previous declarations with 8241 /// the same name. 8242 /// 8243 /// Returns a NamedDecl iff typo correction was performed and substituting in 8244 /// the new declaration name does not cause new errors. 8245 static NamedDecl *DiagnoseInvalidRedeclaration( 8246 Sema &SemaRef, LookupResult &Previous, FunctionDecl *NewFD, 8247 ActOnFDArgs &ExtraArgs, bool IsLocalFriend, Scope *S) { 8248 DeclarationName Name = NewFD->getDeclName(); 8249 DeclContext *NewDC = NewFD->getDeclContext(); 8250 SmallVector<unsigned, 1> MismatchedParams; 8251 SmallVector<std::pair<FunctionDecl *, unsigned>, 1> NearMatches; 8252 TypoCorrection Correction; 8253 bool IsDefinition = ExtraArgs.D.isFunctionDefinition(); 8254 unsigned DiagMsg = 8255 IsLocalFriend ? diag::err_no_matching_local_friend : 8256 NewFD->getFriendObjectKind() ? diag::err_qualified_friend_no_match : 8257 diag::err_member_decl_does_not_match; 8258 LookupResult Prev(SemaRef, Name, NewFD->getLocation(), 8259 IsLocalFriend ? Sema::LookupLocalFriendName 8260 : Sema::LookupOrdinaryName, 8261 Sema::ForVisibleRedeclaration); 8262 8263 NewFD->setInvalidDecl(); 8264 if (IsLocalFriend) 8265 SemaRef.LookupName(Prev, S); 8266 else 8267 SemaRef.LookupQualifiedName(Prev, NewDC); 8268 assert(!Prev.isAmbiguous() && 8269 "Cannot have an ambiguity in previous-declaration lookup"); 8270 CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(NewFD); 8271 DifferentNameValidatorCCC CCC(SemaRef.Context, NewFD, 8272 MD ? MD->getParent() : nullptr); 8273 if (!Prev.empty()) { 8274 for (LookupResult::iterator Func = Prev.begin(), FuncEnd = Prev.end(); 8275 Func != FuncEnd; ++Func) { 8276 FunctionDecl *FD = dyn_cast<FunctionDecl>(*Func); 8277 if (FD && 8278 hasSimilarParameters(SemaRef.Context, FD, NewFD, MismatchedParams)) { 8279 // Add 1 to the index so that 0 can mean the mismatch didn't 8280 // involve a parameter 8281 unsigned ParamNum = 8282 MismatchedParams.empty() ? 0 : MismatchedParams.front() + 1; 8283 NearMatches.push_back(std::make_pair(FD, ParamNum)); 8284 } 8285 } 8286 // If the qualified name lookup yielded nothing, try typo correction 8287 } else if ((Correction = SemaRef.CorrectTypo( 8288 Prev.getLookupNameInfo(), Prev.getLookupKind(), S, 8289 &ExtraArgs.D.getCXXScopeSpec(), CCC, Sema::CTK_ErrorRecovery, 8290 IsLocalFriend ? nullptr : NewDC))) { 8291 // Set up everything for the call to ActOnFunctionDeclarator 8292 ExtraArgs.D.SetIdentifier(Correction.getCorrectionAsIdentifierInfo(), 8293 ExtraArgs.D.getIdentifierLoc()); 8294 Previous.clear(); 8295 Previous.setLookupName(Correction.getCorrection()); 8296 for (TypoCorrection::decl_iterator CDecl = Correction.begin(), 8297 CDeclEnd = Correction.end(); 8298 CDecl != CDeclEnd; ++CDecl) { 8299 FunctionDecl *FD = dyn_cast<FunctionDecl>(*CDecl); 8300 if (FD && !FD->hasBody() && 8301 hasSimilarParameters(SemaRef.Context, FD, NewFD, MismatchedParams)) { 8302 Previous.addDecl(FD); 8303 } 8304 } 8305 bool wasRedeclaration = ExtraArgs.D.isRedeclaration(); 8306 8307 NamedDecl *Result; 8308 // Retry building the function declaration with the new previous 8309 // declarations, and with errors suppressed. 8310 { 8311 // Trap errors. 8312 Sema::SFINAETrap Trap(SemaRef); 8313 8314 // TODO: Refactor ActOnFunctionDeclarator so that we can call only the 8315 // pieces need to verify the typo-corrected C++ declaration and hopefully 8316 // eliminate the need for the parameter pack ExtraArgs. 8317 Result = SemaRef.ActOnFunctionDeclarator( 8318 ExtraArgs.S, ExtraArgs.D, 8319 Correction.getCorrectionDecl()->getDeclContext(), 8320 NewFD->getTypeSourceInfo(), Previous, ExtraArgs.TemplateParamLists, 8321 ExtraArgs.AddToScope); 8322 8323 if (Trap.hasErrorOccurred()) 8324 Result = nullptr; 8325 } 8326 8327 if (Result) { 8328 // Determine which correction we picked. 8329 Decl *Canonical = Result->getCanonicalDecl(); 8330 for (LookupResult::iterator I = Previous.begin(), E = Previous.end(); 8331 I != E; ++I) 8332 if ((*I)->getCanonicalDecl() == Canonical) 8333 Correction.setCorrectionDecl(*I); 8334 8335 // Let Sema know about the correction. 8336 SemaRef.MarkTypoCorrectedFunctionDefinition(Result); 8337 SemaRef.diagnoseTypo( 8338 Correction, 8339 SemaRef.PDiag(IsLocalFriend 8340 ? diag::err_no_matching_local_friend_suggest 8341 : diag::err_member_decl_does_not_match_suggest) 8342 << Name << NewDC << IsDefinition); 8343 return Result; 8344 } 8345 8346 // Pretend the typo correction never occurred 8347 ExtraArgs.D.SetIdentifier(Name.getAsIdentifierInfo(), 8348 ExtraArgs.D.getIdentifierLoc()); 8349 ExtraArgs.D.setRedeclaration(wasRedeclaration); 8350 Previous.clear(); 8351 Previous.setLookupName(Name); 8352 } 8353 8354 SemaRef.Diag(NewFD->getLocation(), DiagMsg) 8355 << Name << NewDC << IsDefinition << NewFD->getLocation(); 8356 8357 bool NewFDisConst = false; 8358 if (CXXMethodDecl *NewMD = dyn_cast<CXXMethodDecl>(NewFD)) 8359 NewFDisConst = NewMD->isConst(); 8360 8361 for (SmallVectorImpl<std::pair<FunctionDecl *, unsigned> >::iterator 8362 NearMatch = NearMatches.begin(), NearMatchEnd = NearMatches.end(); 8363 NearMatch != NearMatchEnd; ++NearMatch) { 8364 FunctionDecl *FD = NearMatch->first; 8365 CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD); 8366 bool FDisConst = MD && MD->isConst(); 8367 bool IsMember = MD || !IsLocalFriend; 8368 8369 // FIXME: These notes are poorly worded for the local friend case. 8370 if (unsigned Idx = NearMatch->second) { 8371 ParmVarDecl *FDParam = FD->getParamDecl(Idx-1); 8372 SourceLocation Loc = FDParam->getTypeSpecStartLoc(); 8373 if (Loc.isInvalid()) Loc = FD->getLocation(); 8374 SemaRef.Diag(Loc, IsMember ? diag::note_member_def_close_param_match 8375 : diag::note_local_decl_close_param_match) 8376 << Idx << FDParam->getType() 8377 << NewFD->getParamDecl(Idx - 1)->getType(); 8378 } else if (FDisConst != NewFDisConst) { 8379 SemaRef.Diag(FD->getLocation(), diag::note_member_def_close_const_match) 8380 << NewFDisConst << FD->getSourceRange().getEnd(); 8381 } else 8382 SemaRef.Diag(FD->getLocation(), 8383 IsMember ? diag::note_member_def_close_match 8384 : diag::note_local_decl_close_match); 8385 } 8386 return nullptr; 8387 } 8388 8389 static StorageClass getFunctionStorageClass(Sema &SemaRef, Declarator &D) { 8390 switch (D.getDeclSpec().getStorageClassSpec()) { 8391 default: llvm_unreachable("Unknown storage class!"); 8392 case DeclSpec::SCS_auto: 8393 case DeclSpec::SCS_register: 8394 case DeclSpec::SCS_mutable: 8395 SemaRef.Diag(D.getDeclSpec().getStorageClassSpecLoc(), 8396 diag::err_typecheck_sclass_func); 8397 D.getMutableDeclSpec().ClearStorageClassSpecs(); 8398 D.setInvalidType(); 8399 break; 8400 case DeclSpec::SCS_unspecified: break; 8401 case DeclSpec::SCS_extern: 8402 if (D.getDeclSpec().isExternInLinkageSpec()) 8403 return SC_None; 8404 return SC_Extern; 8405 case DeclSpec::SCS_static: { 8406 if (SemaRef.CurContext->getRedeclContext()->isFunctionOrMethod()) { 8407 // C99 6.7.1p5: 8408 // The declaration of an identifier for a function that has 8409 // block scope shall have no explicit storage-class specifier 8410 // other than extern 8411 // See also (C++ [dcl.stc]p4). 8412 SemaRef.Diag(D.getDeclSpec().getStorageClassSpecLoc(), 8413 diag::err_static_block_func); 8414 break; 8415 } else 8416 return SC_Static; 8417 } 8418 case DeclSpec::SCS_private_extern: return SC_PrivateExtern; 8419 } 8420 8421 // No explicit storage class has already been returned 8422 return SC_None; 8423 } 8424 8425 static FunctionDecl *CreateNewFunctionDecl(Sema &SemaRef, Declarator &D, 8426 DeclContext *DC, QualType &R, 8427 TypeSourceInfo *TInfo, 8428 StorageClass SC, 8429 bool &IsVirtualOkay) { 8430 DeclarationNameInfo NameInfo = SemaRef.GetNameForDeclarator(D); 8431 DeclarationName Name = NameInfo.getName(); 8432 8433 FunctionDecl *NewFD = nullptr; 8434 bool isInline = D.getDeclSpec().isInlineSpecified(); 8435 8436 if (!SemaRef.getLangOpts().CPlusPlus) { 8437 // Determine whether the function was written with a 8438 // prototype. This true when: 8439 // - there is a prototype in the declarator, or 8440 // - the type R of the function is some kind of typedef or other non- 8441 // attributed reference to a type name (which eventually refers to a 8442 // function type). 8443 bool HasPrototype = 8444 (D.isFunctionDeclarator() && D.getFunctionTypeInfo().hasPrototype) || 8445 (!R->getAsAdjusted<FunctionType>() && R->isFunctionProtoType()); 8446 8447 NewFD = FunctionDecl::Create(SemaRef.Context, DC, D.getBeginLoc(), NameInfo, 8448 R, TInfo, SC, isInline, HasPrototype, 8449 ConstexprSpecKind::Unspecified, 8450 /*TrailingRequiresClause=*/nullptr); 8451 if (D.isInvalidType()) 8452 NewFD->setInvalidDecl(); 8453 8454 return NewFD; 8455 } 8456 8457 ExplicitSpecifier ExplicitSpecifier = D.getDeclSpec().getExplicitSpecifier(); 8458 8459 ConstexprSpecKind ConstexprKind = D.getDeclSpec().getConstexprSpecifier(); 8460 if (ConstexprKind == ConstexprSpecKind::Constinit) { 8461 SemaRef.Diag(D.getDeclSpec().getConstexprSpecLoc(), 8462 diag::err_constexpr_wrong_decl_kind) 8463 << static_cast<int>(ConstexprKind); 8464 ConstexprKind = ConstexprSpecKind::Unspecified; 8465 D.getMutableDeclSpec().ClearConstexprSpec(); 8466 } 8467 Expr *TrailingRequiresClause = D.getTrailingRequiresClause(); 8468 8469 // Check that the return type is not an abstract class type. 8470 // For record types, this is done by the AbstractClassUsageDiagnoser once 8471 // the class has been completely parsed. 8472 if (!DC->isRecord() && 8473 SemaRef.RequireNonAbstractType( 8474 D.getIdentifierLoc(), R->castAs<FunctionType>()->getReturnType(), 8475 diag::err_abstract_type_in_decl, SemaRef.AbstractReturnType)) 8476 D.setInvalidType(); 8477 8478 if (Name.getNameKind() == DeclarationName::CXXConstructorName) { 8479 // This is a C++ constructor declaration. 8480 assert(DC->isRecord() && 8481 "Constructors can only be declared in a member context"); 8482 8483 R = SemaRef.CheckConstructorDeclarator(D, R, SC); 8484 return CXXConstructorDecl::Create( 8485 SemaRef.Context, cast<CXXRecordDecl>(DC), D.getBeginLoc(), NameInfo, R, 8486 TInfo, ExplicitSpecifier, isInline, 8487 /*isImplicitlyDeclared=*/false, ConstexprKind, InheritedConstructor(), 8488 TrailingRequiresClause); 8489 8490 } else if (Name.getNameKind() == DeclarationName::CXXDestructorName) { 8491 // This is a C++ destructor declaration. 8492 if (DC->isRecord()) { 8493 R = SemaRef.CheckDestructorDeclarator(D, R, SC); 8494 CXXRecordDecl *Record = cast<CXXRecordDecl>(DC); 8495 CXXDestructorDecl *NewDD = CXXDestructorDecl::Create( 8496 SemaRef.Context, Record, D.getBeginLoc(), NameInfo, R, TInfo, 8497 isInline, /*isImplicitlyDeclared=*/false, ConstexprKind, 8498 TrailingRequiresClause); 8499 8500 // If the destructor needs an implicit exception specification, set it 8501 // now. FIXME: It'd be nice to be able to create the right type to start 8502 // with, but the type needs to reference the destructor declaration. 8503 if (SemaRef.getLangOpts().CPlusPlus11) 8504 SemaRef.AdjustDestructorExceptionSpec(NewDD); 8505 8506 IsVirtualOkay = true; 8507 return NewDD; 8508 8509 } else { 8510 SemaRef.Diag(D.getIdentifierLoc(), diag::err_destructor_not_member); 8511 D.setInvalidType(); 8512 8513 // Create a FunctionDecl to satisfy the function definition parsing 8514 // code path. 8515 return FunctionDecl::Create(SemaRef.Context, DC, D.getBeginLoc(), 8516 D.getIdentifierLoc(), Name, R, TInfo, SC, 8517 isInline, 8518 /*hasPrototype=*/true, ConstexprKind, 8519 TrailingRequiresClause); 8520 } 8521 8522 } else if (Name.getNameKind() == DeclarationName::CXXConversionFunctionName) { 8523 if (!DC->isRecord()) { 8524 SemaRef.Diag(D.getIdentifierLoc(), 8525 diag::err_conv_function_not_member); 8526 return nullptr; 8527 } 8528 8529 SemaRef.CheckConversionDeclarator(D, R, SC); 8530 if (D.isInvalidType()) 8531 return nullptr; 8532 8533 IsVirtualOkay = true; 8534 return CXXConversionDecl::Create( 8535 SemaRef.Context, cast<CXXRecordDecl>(DC), D.getBeginLoc(), NameInfo, R, 8536 TInfo, isInline, ExplicitSpecifier, ConstexprKind, SourceLocation(), 8537 TrailingRequiresClause); 8538 8539 } else if (Name.getNameKind() == DeclarationName::CXXDeductionGuideName) { 8540 if (TrailingRequiresClause) 8541 SemaRef.Diag(TrailingRequiresClause->getBeginLoc(), 8542 diag::err_trailing_requires_clause_on_deduction_guide) 8543 << TrailingRequiresClause->getSourceRange(); 8544 SemaRef.CheckDeductionGuideDeclarator(D, R, SC); 8545 8546 return CXXDeductionGuideDecl::Create(SemaRef.Context, DC, D.getBeginLoc(), 8547 ExplicitSpecifier, NameInfo, R, TInfo, 8548 D.getEndLoc()); 8549 } else if (DC->isRecord()) { 8550 // If the name of the function is the same as the name of the record, 8551 // then this must be an invalid constructor that has a return type. 8552 // (The parser checks for a return type and makes the declarator a 8553 // constructor if it has no return type). 8554 if (Name.getAsIdentifierInfo() && 8555 Name.getAsIdentifierInfo() == cast<CXXRecordDecl>(DC)->getIdentifier()){ 8556 SemaRef.Diag(D.getIdentifierLoc(), diag::err_constructor_return_type) 8557 << SourceRange(D.getDeclSpec().getTypeSpecTypeLoc()) 8558 << SourceRange(D.getIdentifierLoc()); 8559 return nullptr; 8560 } 8561 8562 // This is a C++ method declaration. 8563 CXXMethodDecl *Ret = CXXMethodDecl::Create( 8564 SemaRef.Context, cast<CXXRecordDecl>(DC), D.getBeginLoc(), NameInfo, R, 8565 TInfo, SC, isInline, ConstexprKind, SourceLocation(), 8566 TrailingRequiresClause); 8567 IsVirtualOkay = !Ret->isStatic(); 8568 return Ret; 8569 } else { 8570 bool isFriend = 8571 SemaRef.getLangOpts().CPlusPlus && D.getDeclSpec().isFriendSpecified(); 8572 if (!isFriend && SemaRef.CurContext->isRecord()) 8573 return nullptr; 8574 8575 // Determine whether the function was written with a 8576 // prototype. This true when: 8577 // - we're in C++ (where every function has a prototype), 8578 return FunctionDecl::Create(SemaRef.Context, DC, D.getBeginLoc(), NameInfo, 8579 R, TInfo, SC, isInline, true /*HasPrototype*/, 8580 ConstexprKind, TrailingRequiresClause); 8581 } 8582 } 8583 8584 enum OpenCLParamType { 8585 ValidKernelParam, 8586 PtrPtrKernelParam, 8587 PtrKernelParam, 8588 InvalidAddrSpacePtrKernelParam, 8589 InvalidKernelParam, 8590 RecordKernelParam 8591 }; 8592 8593 static bool isOpenCLSizeDependentType(ASTContext &C, QualType Ty) { 8594 // Size dependent types are just typedefs to normal integer types 8595 // (e.g. unsigned long), so we cannot distinguish them from other typedefs to 8596 // integers other than by their names. 8597 StringRef SizeTypeNames[] = {"size_t", "intptr_t", "uintptr_t", "ptrdiff_t"}; 8598 8599 // Remove typedefs one by one until we reach a typedef 8600 // for a size dependent type. 8601 QualType DesugaredTy = Ty; 8602 do { 8603 ArrayRef<StringRef> Names(SizeTypeNames); 8604 auto Match = llvm::find(Names, DesugaredTy.getUnqualifiedType().getAsString()); 8605 if (Names.end() != Match) 8606 return true; 8607 8608 Ty = DesugaredTy; 8609 DesugaredTy = Ty.getSingleStepDesugaredType(C); 8610 } while (DesugaredTy != Ty); 8611 8612 return false; 8613 } 8614 8615 static OpenCLParamType getOpenCLKernelParameterType(Sema &S, QualType PT) { 8616 if (PT->isPointerType()) { 8617 QualType PointeeType = PT->getPointeeType(); 8618 if (PointeeType.getAddressSpace() == LangAS::opencl_generic || 8619 PointeeType.getAddressSpace() == LangAS::opencl_private || 8620 PointeeType.getAddressSpace() == LangAS::Default) 8621 return InvalidAddrSpacePtrKernelParam; 8622 8623 if (PointeeType->isPointerType()) { 8624 // This is a pointer to pointer parameter. 8625 // Recursively check inner type. 8626 OpenCLParamType ParamKind = getOpenCLKernelParameterType(S, PointeeType); 8627 if (ParamKind == InvalidAddrSpacePtrKernelParam || 8628 ParamKind == InvalidKernelParam) 8629 return ParamKind; 8630 8631 return PtrPtrKernelParam; 8632 } 8633 return PtrKernelParam; 8634 } 8635 8636 // OpenCL v1.2 s6.9.k: 8637 // Arguments to kernel functions in a program cannot be declared with the 8638 // built-in scalar types bool, half, size_t, ptrdiff_t, intptr_t, and 8639 // uintptr_t or a struct and/or union that contain fields declared to be one 8640 // of these built-in scalar types. 8641 if (isOpenCLSizeDependentType(S.getASTContext(), PT)) 8642 return InvalidKernelParam; 8643 8644 if (PT->isImageType()) 8645 return PtrKernelParam; 8646 8647 if (PT->isBooleanType() || PT->isEventT() || PT->isReserveIDT()) 8648 return InvalidKernelParam; 8649 8650 // OpenCL extension spec v1.2 s9.5: 8651 // This extension adds support for half scalar and vector types as built-in 8652 // types that can be used for arithmetic operations, conversions etc. 8653 if (!S.getOpenCLOptions().isEnabled("cl_khr_fp16") && PT->isHalfType()) 8654 return InvalidKernelParam; 8655 8656 if (PT->isRecordType()) 8657 return RecordKernelParam; 8658 8659 // Look into an array argument to check if it has a forbidden type. 8660 if (PT->isArrayType()) { 8661 const Type *UnderlyingTy = PT->getPointeeOrArrayElementType(); 8662 // Call ourself to check an underlying type of an array. Since the 8663 // getPointeeOrArrayElementType returns an innermost type which is not an 8664 // array, this recursive call only happens once. 8665 return getOpenCLKernelParameterType(S, QualType(UnderlyingTy, 0)); 8666 } 8667 8668 return ValidKernelParam; 8669 } 8670 8671 static void checkIsValidOpenCLKernelParameter( 8672 Sema &S, 8673 Declarator &D, 8674 ParmVarDecl *Param, 8675 llvm::SmallPtrSetImpl<const Type *> &ValidTypes) { 8676 QualType PT = Param->getType(); 8677 8678 // Cache the valid types we encounter to avoid rechecking structs that are 8679 // used again 8680 if (ValidTypes.count(PT.getTypePtr())) 8681 return; 8682 8683 switch (getOpenCLKernelParameterType(S, PT)) { 8684 case PtrPtrKernelParam: 8685 // OpenCL v3.0 s6.11.a: 8686 // A kernel function argument cannot be declared as a pointer to a pointer 8687 // type. [...] This restriction only applies to OpenCL C 1.2 or below. 8688 if (S.getLangOpts().OpenCLVersion < 120 && 8689 !S.getLangOpts().OpenCLCPlusPlus) { 8690 S.Diag(Param->getLocation(), diag::err_opencl_ptrptr_kernel_param); 8691 D.setInvalidType(); 8692 return; 8693 } 8694 8695 ValidTypes.insert(PT.getTypePtr()); 8696 return; 8697 8698 case InvalidAddrSpacePtrKernelParam: 8699 // OpenCL v1.0 s6.5: 8700 // __kernel function arguments declared to be a pointer of a type can point 8701 // to one of the following address spaces only : __global, __local or 8702 // __constant. 8703 S.Diag(Param->getLocation(), diag::err_kernel_arg_address_space); 8704 D.setInvalidType(); 8705 return; 8706 8707 // OpenCL v1.2 s6.9.k: 8708 // Arguments to kernel functions in a program cannot be declared with the 8709 // built-in scalar types bool, half, size_t, ptrdiff_t, intptr_t, and 8710 // uintptr_t or a struct and/or union that contain fields declared to be 8711 // one of these built-in scalar types. 8712 8713 case InvalidKernelParam: 8714 // OpenCL v1.2 s6.8 n: 8715 // A kernel function argument cannot be declared 8716 // of event_t type. 8717 // Do not diagnose half type since it is diagnosed as invalid argument 8718 // type for any function elsewhere. 8719 if (!PT->isHalfType()) { 8720 S.Diag(Param->getLocation(), diag::err_bad_kernel_param_type) << PT; 8721 8722 // Explain what typedefs are involved. 8723 const TypedefType *Typedef = nullptr; 8724 while ((Typedef = PT->getAs<TypedefType>())) { 8725 SourceLocation Loc = Typedef->getDecl()->getLocation(); 8726 // SourceLocation may be invalid for a built-in type. 8727 if (Loc.isValid()) 8728 S.Diag(Loc, diag::note_entity_declared_at) << PT; 8729 PT = Typedef->desugar(); 8730 } 8731 } 8732 8733 D.setInvalidType(); 8734 return; 8735 8736 case PtrKernelParam: 8737 case ValidKernelParam: 8738 ValidTypes.insert(PT.getTypePtr()); 8739 return; 8740 8741 case RecordKernelParam: 8742 break; 8743 } 8744 8745 // Track nested structs we will inspect 8746 SmallVector<const Decl *, 4> VisitStack; 8747 8748 // Track where we are in the nested structs. Items will migrate from 8749 // VisitStack to HistoryStack as we do the DFS for bad field. 8750 SmallVector<const FieldDecl *, 4> HistoryStack; 8751 HistoryStack.push_back(nullptr); 8752 8753 // At this point we already handled everything except of a RecordType or 8754 // an ArrayType of a RecordType. 8755 assert((PT->isArrayType() || PT->isRecordType()) && "Unexpected type."); 8756 const RecordType *RecTy = 8757 PT->getPointeeOrArrayElementType()->getAs<RecordType>(); 8758 const RecordDecl *OrigRecDecl = RecTy->getDecl(); 8759 8760 VisitStack.push_back(RecTy->getDecl()); 8761 assert(VisitStack.back() && "First decl null?"); 8762 8763 do { 8764 const Decl *Next = VisitStack.pop_back_val(); 8765 if (!Next) { 8766 assert(!HistoryStack.empty()); 8767 // Found a marker, we have gone up a level 8768 if (const FieldDecl *Hist = HistoryStack.pop_back_val()) 8769 ValidTypes.insert(Hist->getType().getTypePtr()); 8770 8771 continue; 8772 } 8773 8774 // Adds everything except the original parameter declaration (which is not a 8775 // field itself) to the history stack. 8776 const RecordDecl *RD; 8777 if (const FieldDecl *Field = dyn_cast<FieldDecl>(Next)) { 8778 HistoryStack.push_back(Field); 8779 8780 QualType FieldTy = Field->getType(); 8781 // Other field types (known to be valid or invalid) are handled while we 8782 // walk around RecordDecl::fields(). 8783 assert((FieldTy->isArrayType() || FieldTy->isRecordType()) && 8784 "Unexpected type."); 8785 const Type *FieldRecTy = FieldTy->getPointeeOrArrayElementType(); 8786 8787 RD = FieldRecTy->castAs<RecordType>()->getDecl(); 8788 } else { 8789 RD = cast<RecordDecl>(Next); 8790 } 8791 8792 // Add a null marker so we know when we've gone back up a level 8793 VisitStack.push_back(nullptr); 8794 8795 for (const auto *FD : RD->fields()) { 8796 QualType QT = FD->getType(); 8797 8798 if (ValidTypes.count(QT.getTypePtr())) 8799 continue; 8800 8801 OpenCLParamType ParamType = getOpenCLKernelParameterType(S, QT); 8802 if (ParamType == ValidKernelParam) 8803 continue; 8804 8805 if (ParamType == RecordKernelParam) { 8806 VisitStack.push_back(FD); 8807 continue; 8808 } 8809 8810 // OpenCL v1.2 s6.9.p: 8811 // Arguments to kernel functions that are declared to be a struct or union 8812 // do not allow OpenCL objects to be passed as elements of the struct or 8813 // union. 8814 if (ParamType == PtrKernelParam || ParamType == PtrPtrKernelParam || 8815 ParamType == InvalidAddrSpacePtrKernelParam) { 8816 S.Diag(Param->getLocation(), 8817 diag::err_record_with_pointers_kernel_param) 8818 << PT->isUnionType() 8819 << PT; 8820 } else { 8821 S.Diag(Param->getLocation(), diag::err_bad_kernel_param_type) << PT; 8822 } 8823 8824 S.Diag(OrigRecDecl->getLocation(), diag::note_within_field_of_type) 8825 << OrigRecDecl->getDeclName(); 8826 8827 // We have an error, now let's go back up through history and show where 8828 // the offending field came from 8829 for (ArrayRef<const FieldDecl *>::const_iterator 8830 I = HistoryStack.begin() + 1, 8831 E = HistoryStack.end(); 8832 I != E; ++I) { 8833 const FieldDecl *OuterField = *I; 8834 S.Diag(OuterField->getLocation(), diag::note_within_field_of_type) 8835 << OuterField->getType(); 8836 } 8837 8838 S.Diag(FD->getLocation(), diag::note_illegal_field_declared_here) 8839 << QT->isPointerType() 8840 << QT; 8841 D.setInvalidType(); 8842 return; 8843 } 8844 } while (!VisitStack.empty()); 8845 } 8846 8847 /// Find the DeclContext in which a tag is implicitly declared if we see an 8848 /// elaborated type specifier in the specified context, and lookup finds 8849 /// nothing. 8850 static DeclContext *getTagInjectionContext(DeclContext *DC) { 8851 while (!DC->isFileContext() && !DC->isFunctionOrMethod()) 8852 DC = DC->getParent(); 8853 return DC; 8854 } 8855 8856 /// Find the Scope in which a tag is implicitly declared if we see an 8857 /// elaborated type specifier in the specified context, and lookup finds 8858 /// nothing. 8859 static Scope *getTagInjectionScope(Scope *S, const LangOptions &LangOpts) { 8860 while (S->isClassScope() || 8861 (LangOpts.CPlusPlus && 8862 S->isFunctionPrototypeScope()) || 8863 ((S->getFlags() & Scope::DeclScope) == 0) || 8864 (S->getEntity() && S->getEntity()->isTransparentContext())) 8865 S = S->getParent(); 8866 return S; 8867 } 8868 8869 NamedDecl* 8870 Sema::ActOnFunctionDeclarator(Scope *S, Declarator &D, DeclContext *DC, 8871 TypeSourceInfo *TInfo, LookupResult &Previous, 8872 MultiTemplateParamsArg TemplateParamListsRef, 8873 bool &AddToScope) { 8874 QualType R = TInfo->getType(); 8875 8876 assert(R->isFunctionType()); 8877 if (R.getCanonicalType()->castAs<FunctionType>()->getCmseNSCallAttr()) 8878 Diag(D.getIdentifierLoc(), diag::err_function_decl_cmse_ns_call); 8879 8880 SmallVector<TemplateParameterList *, 4> TemplateParamLists; 8881 for (TemplateParameterList *TPL : TemplateParamListsRef) 8882 TemplateParamLists.push_back(TPL); 8883 if (TemplateParameterList *Invented = D.getInventedTemplateParameterList()) { 8884 if (!TemplateParamLists.empty() && 8885 Invented->getDepth() == TemplateParamLists.back()->getDepth()) 8886 TemplateParamLists.back() = Invented; 8887 else 8888 TemplateParamLists.push_back(Invented); 8889 } 8890 8891 // TODO: consider using NameInfo for diagnostic. 8892 DeclarationNameInfo NameInfo = GetNameForDeclarator(D); 8893 DeclarationName Name = NameInfo.getName(); 8894 StorageClass SC = getFunctionStorageClass(*this, D); 8895 8896 if (DeclSpec::TSCS TSCS = D.getDeclSpec().getThreadStorageClassSpec()) 8897 Diag(D.getDeclSpec().getThreadStorageClassSpecLoc(), 8898 diag::err_invalid_thread) 8899 << DeclSpec::getSpecifierName(TSCS); 8900 8901 if (D.isFirstDeclarationOfMember()) 8902 adjustMemberFunctionCC(R, D.isStaticMember(), D.isCtorOrDtor(), 8903 D.getIdentifierLoc()); 8904 8905 bool isFriend = false; 8906 FunctionTemplateDecl *FunctionTemplate = nullptr; 8907 bool isMemberSpecialization = false; 8908 bool isFunctionTemplateSpecialization = false; 8909 8910 bool isDependentClassScopeExplicitSpecialization = false; 8911 bool HasExplicitTemplateArgs = false; 8912 TemplateArgumentListInfo TemplateArgs; 8913 8914 bool isVirtualOkay = false; 8915 8916 DeclContext *OriginalDC = DC; 8917 bool IsLocalExternDecl = adjustContextForLocalExternDecl(DC); 8918 8919 FunctionDecl *NewFD = CreateNewFunctionDecl(*this, D, DC, R, TInfo, SC, 8920 isVirtualOkay); 8921 if (!NewFD) return nullptr; 8922 8923 if (OriginalLexicalContext && OriginalLexicalContext->isObjCContainer()) 8924 NewFD->setTopLevelDeclInObjCContainer(); 8925 8926 // Set the lexical context. If this is a function-scope declaration, or has a 8927 // C++ scope specifier, or is the object of a friend declaration, the lexical 8928 // context will be different from the semantic context. 8929 NewFD->setLexicalDeclContext(CurContext); 8930 8931 if (IsLocalExternDecl) 8932 NewFD->setLocalExternDecl(); 8933 8934 if (getLangOpts().CPlusPlus) { 8935 bool isInline = D.getDeclSpec().isInlineSpecified(); 8936 bool isVirtual = D.getDeclSpec().isVirtualSpecified(); 8937 bool hasExplicit = D.getDeclSpec().hasExplicitSpecifier(); 8938 isFriend = D.getDeclSpec().isFriendSpecified(); 8939 if (isFriend && !isInline && D.isFunctionDefinition()) { 8940 // C++ [class.friend]p5 8941 // A function can be defined in a friend declaration of a 8942 // class . . . . Such a function is implicitly inline. 8943 NewFD->setImplicitlyInline(); 8944 } 8945 8946 // If this is a method defined in an __interface, and is not a constructor 8947 // or an overloaded operator, then set the pure flag (isVirtual will already 8948 // return true). 8949 if (const CXXRecordDecl *Parent = 8950 dyn_cast<CXXRecordDecl>(NewFD->getDeclContext())) { 8951 if (Parent->isInterface() && cast<CXXMethodDecl>(NewFD)->isUserProvided()) 8952 NewFD->setPure(true); 8953 8954 // C++ [class.union]p2 8955 // A union can have member functions, but not virtual functions. 8956 if (isVirtual && Parent->isUnion()) 8957 Diag(D.getDeclSpec().getVirtualSpecLoc(), diag::err_virtual_in_union); 8958 } 8959 8960 SetNestedNameSpecifier(*this, NewFD, D); 8961 isMemberSpecialization = false; 8962 isFunctionTemplateSpecialization = false; 8963 if (D.isInvalidType()) 8964 NewFD->setInvalidDecl(); 8965 8966 // Match up the template parameter lists with the scope specifier, then 8967 // determine whether we have a template or a template specialization. 8968 bool Invalid = false; 8969 TemplateParameterList *TemplateParams = 8970 MatchTemplateParametersToScopeSpecifier( 8971 D.getDeclSpec().getBeginLoc(), D.getIdentifierLoc(), 8972 D.getCXXScopeSpec(), 8973 D.getName().getKind() == UnqualifiedIdKind::IK_TemplateId 8974 ? D.getName().TemplateId 8975 : nullptr, 8976 TemplateParamLists, isFriend, isMemberSpecialization, 8977 Invalid); 8978 if (TemplateParams) { 8979 // Check that we can declare a template here. 8980 if (CheckTemplateDeclScope(S, TemplateParams)) 8981 NewFD->setInvalidDecl(); 8982 8983 if (TemplateParams->size() > 0) { 8984 // This is a function template 8985 8986 // A destructor cannot be a template. 8987 if (Name.getNameKind() == DeclarationName::CXXDestructorName) { 8988 Diag(NewFD->getLocation(), diag::err_destructor_template); 8989 NewFD->setInvalidDecl(); 8990 } 8991 8992 // If we're adding a template to a dependent context, we may need to 8993 // rebuilding some of the types used within the template parameter list, 8994 // now that we know what the current instantiation is. 8995 if (DC->isDependentContext()) { 8996 ContextRAII SavedContext(*this, DC); 8997 if (RebuildTemplateParamsInCurrentInstantiation(TemplateParams)) 8998 Invalid = true; 8999 } 9000 9001 FunctionTemplate = FunctionTemplateDecl::Create(Context, DC, 9002 NewFD->getLocation(), 9003 Name, TemplateParams, 9004 NewFD); 9005 FunctionTemplate->setLexicalDeclContext(CurContext); 9006 NewFD->setDescribedFunctionTemplate(FunctionTemplate); 9007 9008 // For source fidelity, store the other template param lists. 9009 if (TemplateParamLists.size() > 1) { 9010 NewFD->setTemplateParameterListsInfo(Context, 9011 ArrayRef<TemplateParameterList *>(TemplateParamLists) 9012 .drop_back(1)); 9013 } 9014 } else { 9015 // This is a function template specialization. 9016 isFunctionTemplateSpecialization = true; 9017 // For source fidelity, store all the template param lists. 9018 if (TemplateParamLists.size() > 0) 9019 NewFD->setTemplateParameterListsInfo(Context, TemplateParamLists); 9020 9021 // C++0x [temp.expl.spec]p20 forbids "template<> friend void foo(int);". 9022 if (isFriend) { 9023 // We want to remove the "template<>", found here. 9024 SourceRange RemoveRange = TemplateParams->getSourceRange(); 9025 9026 // If we remove the template<> and the name is not a 9027 // template-id, we're actually silently creating a problem: 9028 // the friend declaration will refer to an untemplated decl, 9029 // and clearly the user wants a template specialization. So 9030 // we need to insert '<>' after the name. 9031 SourceLocation InsertLoc; 9032 if (D.getName().getKind() != UnqualifiedIdKind::IK_TemplateId) { 9033 InsertLoc = D.getName().getSourceRange().getEnd(); 9034 InsertLoc = getLocForEndOfToken(InsertLoc); 9035 } 9036 9037 Diag(D.getIdentifierLoc(), diag::err_template_spec_decl_friend) 9038 << Name << RemoveRange 9039 << FixItHint::CreateRemoval(RemoveRange) 9040 << FixItHint::CreateInsertion(InsertLoc, "<>"); 9041 } 9042 } 9043 } else { 9044 // Check that we can declare a template here. 9045 if (!TemplateParamLists.empty() && isMemberSpecialization && 9046 CheckTemplateDeclScope(S, TemplateParamLists.back())) 9047 NewFD->setInvalidDecl(); 9048 9049 // All template param lists were matched against the scope specifier: 9050 // this is NOT (an explicit specialization of) a template. 9051 if (TemplateParamLists.size() > 0) 9052 // For source fidelity, store all the template param lists. 9053 NewFD->setTemplateParameterListsInfo(Context, TemplateParamLists); 9054 } 9055 9056 if (Invalid) { 9057 NewFD->setInvalidDecl(); 9058 if (FunctionTemplate) 9059 FunctionTemplate->setInvalidDecl(); 9060 } 9061 9062 // C++ [dcl.fct.spec]p5: 9063 // The virtual specifier shall only be used in declarations of 9064 // nonstatic class member functions that appear within a 9065 // member-specification of a class declaration; see 10.3. 9066 // 9067 if (isVirtual && !NewFD->isInvalidDecl()) { 9068 if (!isVirtualOkay) { 9069 Diag(D.getDeclSpec().getVirtualSpecLoc(), 9070 diag::err_virtual_non_function); 9071 } else if (!CurContext->isRecord()) { 9072 // 'virtual' was specified outside of the class. 9073 Diag(D.getDeclSpec().getVirtualSpecLoc(), 9074 diag::err_virtual_out_of_class) 9075 << FixItHint::CreateRemoval(D.getDeclSpec().getVirtualSpecLoc()); 9076 } else if (NewFD->getDescribedFunctionTemplate()) { 9077 // C++ [temp.mem]p3: 9078 // A member function template shall not be virtual. 9079 Diag(D.getDeclSpec().getVirtualSpecLoc(), 9080 diag::err_virtual_member_function_template) 9081 << FixItHint::CreateRemoval(D.getDeclSpec().getVirtualSpecLoc()); 9082 } else { 9083 // Okay: Add virtual to the method. 9084 NewFD->setVirtualAsWritten(true); 9085 } 9086 9087 if (getLangOpts().CPlusPlus14 && 9088 NewFD->getReturnType()->isUndeducedType()) 9089 Diag(D.getDeclSpec().getVirtualSpecLoc(), diag::err_auto_fn_virtual); 9090 } 9091 9092 if (getLangOpts().CPlusPlus14 && 9093 (NewFD->isDependentContext() || 9094 (isFriend && CurContext->isDependentContext())) && 9095 NewFD->getReturnType()->isUndeducedType()) { 9096 // If the function template is referenced directly (for instance, as a 9097 // member of the current instantiation), pretend it has a dependent type. 9098 // This is not really justified by the standard, but is the only sane 9099 // thing to do. 9100 // FIXME: For a friend function, we have not marked the function as being 9101 // a friend yet, so 'isDependentContext' on the FD doesn't work. 9102 const FunctionProtoType *FPT = 9103 NewFD->getType()->castAs<FunctionProtoType>(); 9104 QualType Result = 9105 SubstAutoType(FPT->getReturnType(), Context.DependentTy); 9106 NewFD->setType(Context.getFunctionType(Result, FPT->getParamTypes(), 9107 FPT->getExtProtoInfo())); 9108 } 9109 9110 // C++ [dcl.fct.spec]p3: 9111 // The inline specifier shall not appear on a block scope function 9112 // declaration. 9113 if (isInline && !NewFD->isInvalidDecl()) { 9114 if (CurContext->isFunctionOrMethod()) { 9115 // 'inline' is not allowed on block scope function declaration. 9116 Diag(D.getDeclSpec().getInlineSpecLoc(), 9117 diag::err_inline_declaration_block_scope) << Name 9118 << FixItHint::CreateRemoval(D.getDeclSpec().getInlineSpecLoc()); 9119 } 9120 } 9121 9122 // C++ [dcl.fct.spec]p6: 9123 // The explicit specifier shall be used only in the declaration of a 9124 // constructor or conversion function within its class definition; 9125 // see 12.3.1 and 12.3.2. 9126 if (hasExplicit && !NewFD->isInvalidDecl() && 9127 !isa<CXXDeductionGuideDecl>(NewFD)) { 9128 if (!CurContext->isRecord()) { 9129 // 'explicit' was specified outside of the class. 9130 Diag(D.getDeclSpec().getExplicitSpecLoc(), 9131 diag::err_explicit_out_of_class) 9132 << FixItHint::CreateRemoval(D.getDeclSpec().getExplicitSpecRange()); 9133 } else if (!isa<CXXConstructorDecl>(NewFD) && 9134 !isa<CXXConversionDecl>(NewFD)) { 9135 // 'explicit' was specified on a function that wasn't a constructor 9136 // or conversion function. 9137 Diag(D.getDeclSpec().getExplicitSpecLoc(), 9138 diag::err_explicit_non_ctor_or_conv_function) 9139 << FixItHint::CreateRemoval(D.getDeclSpec().getExplicitSpecRange()); 9140 } 9141 } 9142 9143 ConstexprSpecKind ConstexprKind = D.getDeclSpec().getConstexprSpecifier(); 9144 if (ConstexprKind != ConstexprSpecKind::Unspecified) { 9145 // C++11 [dcl.constexpr]p2: constexpr functions and constexpr constructors 9146 // are implicitly inline. 9147 NewFD->setImplicitlyInline(); 9148 9149 // C++11 [dcl.constexpr]p3: functions declared constexpr are required to 9150 // be either constructors or to return a literal type. Therefore, 9151 // destructors cannot be declared constexpr. 9152 if (isa<CXXDestructorDecl>(NewFD) && 9153 (!getLangOpts().CPlusPlus20 || 9154 ConstexprKind == ConstexprSpecKind::Consteval)) { 9155 Diag(D.getDeclSpec().getConstexprSpecLoc(), diag::err_constexpr_dtor) 9156 << static_cast<int>(ConstexprKind); 9157 NewFD->setConstexprKind(getLangOpts().CPlusPlus20 9158 ? ConstexprSpecKind::Unspecified 9159 : ConstexprSpecKind::Constexpr); 9160 } 9161 // C++20 [dcl.constexpr]p2: An allocation function, or a 9162 // deallocation function shall not be declared with the consteval 9163 // specifier. 9164 if (ConstexprKind == ConstexprSpecKind::Consteval && 9165 (NewFD->getOverloadedOperator() == OO_New || 9166 NewFD->getOverloadedOperator() == OO_Array_New || 9167 NewFD->getOverloadedOperator() == OO_Delete || 9168 NewFD->getOverloadedOperator() == OO_Array_Delete)) { 9169 Diag(D.getDeclSpec().getConstexprSpecLoc(), 9170 diag::err_invalid_consteval_decl_kind) 9171 << NewFD; 9172 NewFD->setConstexprKind(ConstexprSpecKind::Constexpr); 9173 } 9174 } 9175 9176 // If __module_private__ was specified, mark the function accordingly. 9177 if (D.getDeclSpec().isModulePrivateSpecified()) { 9178 if (isFunctionTemplateSpecialization) { 9179 SourceLocation ModulePrivateLoc 9180 = D.getDeclSpec().getModulePrivateSpecLoc(); 9181 Diag(ModulePrivateLoc, diag::err_module_private_specialization) 9182 << 0 9183 << FixItHint::CreateRemoval(ModulePrivateLoc); 9184 } else { 9185 NewFD->setModulePrivate(); 9186 if (FunctionTemplate) 9187 FunctionTemplate->setModulePrivate(); 9188 } 9189 } 9190 9191 if (isFriend) { 9192 if (FunctionTemplate) { 9193 FunctionTemplate->setObjectOfFriendDecl(); 9194 FunctionTemplate->setAccess(AS_public); 9195 } 9196 NewFD->setObjectOfFriendDecl(); 9197 NewFD->setAccess(AS_public); 9198 } 9199 9200 // If a function is defined as defaulted or deleted, mark it as such now. 9201 // We'll do the relevant checks on defaulted / deleted functions later. 9202 switch (D.getFunctionDefinitionKind()) { 9203 case FunctionDefinitionKind::Declaration: 9204 case FunctionDefinitionKind::Definition: 9205 break; 9206 9207 case FunctionDefinitionKind::Defaulted: 9208 NewFD->setDefaulted(); 9209 break; 9210 9211 case FunctionDefinitionKind::Deleted: 9212 NewFD->setDeletedAsWritten(); 9213 break; 9214 } 9215 9216 if (isa<CXXMethodDecl>(NewFD) && DC == CurContext && 9217 D.isFunctionDefinition()) { 9218 // C++ [class.mfct]p2: 9219 // A member function may be defined (8.4) in its class definition, in 9220 // which case it is an inline member function (7.1.2) 9221 NewFD->setImplicitlyInline(); 9222 } 9223 9224 if (SC == SC_Static && isa<CXXMethodDecl>(NewFD) && 9225 !CurContext->isRecord()) { 9226 // C++ [class.static]p1: 9227 // A data or function member of a class may be declared static 9228 // in a class definition, in which case it is a static member of 9229 // the class. 9230 9231 // Complain about the 'static' specifier if it's on an out-of-line 9232 // member function definition. 9233 9234 // MSVC permits the use of a 'static' storage specifier on an out-of-line 9235 // member function template declaration and class member template 9236 // declaration (MSVC versions before 2015), warn about this. 9237 Diag(D.getDeclSpec().getStorageClassSpecLoc(), 9238 ((!getLangOpts().isCompatibleWithMSVC(LangOptions::MSVC2015) && 9239 cast<CXXRecordDecl>(DC)->getDescribedClassTemplate()) || 9240 (getLangOpts().MSVCCompat && NewFD->getDescribedFunctionTemplate())) 9241 ? diag::ext_static_out_of_line : diag::err_static_out_of_line) 9242 << FixItHint::CreateRemoval(D.getDeclSpec().getStorageClassSpecLoc()); 9243 } 9244 9245 // C++11 [except.spec]p15: 9246 // A deallocation function with no exception-specification is treated 9247 // as if it were specified with noexcept(true). 9248 const FunctionProtoType *FPT = R->getAs<FunctionProtoType>(); 9249 if ((Name.getCXXOverloadedOperator() == OO_Delete || 9250 Name.getCXXOverloadedOperator() == OO_Array_Delete) && 9251 getLangOpts().CPlusPlus11 && FPT && !FPT->hasExceptionSpec()) 9252 NewFD->setType(Context.getFunctionType( 9253 FPT->getReturnType(), FPT->getParamTypes(), 9254 FPT->getExtProtoInfo().withExceptionSpec(EST_BasicNoexcept))); 9255 } 9256 9257 // Filter out previous declarations that don't match the scope. 9258 FilterLookupForScope(Previous, OriginalDC, S, shouldConsiderLinkage(NewFD), 9259 D.getCXXScopeSpec().isNotEmpty() || 9260 isMemberSpecialization || 9261 isFunctionTemplateSpecialization); 9262 9263 // Handle GNU asm-label extension (encoded as an attribute). 9264 if (Expr *E = (Expr*) D.getAsmLabel()) { 9265 // The parser guarantees this is a string. 9266 StringLiteral *SE = cast<StringLiteral>(E); 9267 NewFD->addAttr(AsmLabelAttr::Create(Context, SE->getString(), 9268 /*IsLiteralLabel=*/true, 9269 SE->getStrTokenLoc(0))); 9270 } else if (!ExtnameUndeclaredIdentifiers.empty()) { 9271 llvm::DenseMap<IdentifierInfo*,AsmLabelAttr*>::iterator I = 9272 ExtnameUndeclaredIdentifiers.find(NewFD->getIdentifier()); 9273 if (I != ExtnameUndeclaredIdentifiers.end()) { 9274 if (isDeclExternC(NewFD)) { 9275 NewFD->addAttr(I->second); 9276 ExtnameUndeclaredIdentifiers.erase(I); 9277 } else 9278 Diag(NewFD->getLocation(), diag::warn_redefine_extname_not_applied) 9279 << /*Variable*/0 << NewFD; 9280 } 9281 } 9282 9283 // Copy the parameter declarations from the declarator D to the function 9284 // declaration NewFD, if they are available. First scavenge them into Params. 9285 SmallVector<ParmVarDecl*, 16> Params; 9286 unsigned FTIIdx; 9287 if (D.isFunctionDeclarator(FTIIdx)) { 9288 DeclaratorChunk::FunctionTypeInfo &FTI = D.getTypeObject(FTIIdx).Fun; 9289 9290 // Check for C99 6.7.5.3p10 - foo(void) is a non-varargs 9291 // function that takes no arguments, not a function that takes a 9292 // single void argument. 9293 // We let through "const void" here because Sema::GetTypeForDeclarator 9294 // already checks for that case. 9295 if (FTIHasNonVoidParameters(FTI) && FTI.Params[0].Param) { 9296 for (unsigned i = 0, e = FTI.NumParams; i != e; ++i) { 9297 ParmVarDecl *Param = cast<ParmVarDecl>(FTI.Params[i].Param); 9298 assert(Param->getDeclContext() != NewFD && "Was set before ?"); 9299 Param->setDeclContext(NewFD); 9300 Params.push_back(Param); 9301 9302 if (Param->isInvalidDecl()) 9303 NewFD->setInvalidDecl(); 9304 } 9305 } 9306 9307 if (!getLangOpts().CPlusPlus) { 9308 // In C, find all the tag declarations from the prototype and move them 9309 // into the function DeclContext. Remove them from the surrounding tag 9310 // injection context of the function, which is typically but not always 9311 // the TU. 9312 DeclContext *PrototypeTagContext = 9313 getTagInjectionContext(NewFD->getLexicalDeclContext()); 9314 for (NamedDecl *NonParmDecl : FTI.getDeclsInPrototype()) { 9315 auto *TD = dyn_cast<TagDecl>(NonParmDecl); 9316 9317 // We don't want to reparent enumerators. Look at their parent enum 9318 // instead. 9319 if (!TD) { 9320 if (auto *ECD = dyn_cast<EnumConstantDecl>(NonParmDecl)) 9321 TD = cast<EnumDecl>(ECD->getDeclContext()); 9322 } 9323 if (!TD) 9324 continue; 9325 DeclContext *TagDC = TD->getLexicalDeclContext(); 9326 if (!TagDC->containsDecl(TD)) 9327 continue; 9328 TagDC->removeDecl(TD); 9329 TD->setDeclContext(NewFD); 9330 NewFD->addDecl(TD); 9331 9332 // Preserve the lexical DeclContext if it is not the surrounding tag 9333 // injection context of the FD. In this example, the semantic context of 9334 // E will be f and the lexical context will be S, while both the 9335 // semantic and lexical contexts of S will be f: 9336 // void f(struct S { enum E { a } f; } s); 9337 if (TagDC != PrototypeTagContext) 9338 TD->setLexicalDeclContext(TagDC); 9339 } 9340 } 9341 } else if (const FunctionProtoType *FT = R->getAs<FunctionProtoType>()) { 9342 // When we're declaring a function with a typedef, typeof, etc as in the 9343 // following example, we'll need to synthesize (unnamed) 9344 // parameters for use in the declaration. 9345 // 9346 // @code 9347 // typedef void fn(int); 9348 // fn f; 9349 // @endcode 9350 9351 // Synthesize a parameter for each argument type. 9352 for (const auto &AI : FT->param_types()) { 9353 ParmVarDecl *Param = 9354 BuildParmVarDeclForTypedef(NewFD, D.getIdentifierLoc(), AI); 9355 Param->setScopeInfo(0, Params.size()); 9356 Params.push_back(Param); 9357 } 9358 } else { 9359 assert(R->isFunctionNoProtoType() && NewFD->getNumParams() == 0 && 9360 "Should not need args for typedef of non-prototype fn"); 9361 } 9362 9363 // Finally, we know we have the right number of parameters, install them. 9364 NewFD->setParams(Params); 9365 9366 if (D.getDeclSpec().isNoreturnSpecified()) 9367 NewFD->addAttr(C11NoReturnAttr::Create(Context, 9368 D.getDeclSpec().getNoreturnSpecLoc(), 9369 AttributeCommonInfo::AS_Keyword)); 9370 9371 // Functions returning a variably modified type violate C99 6.7.5.2p2 9372 // because all functions have linkage. 9373 if (!NewFD->isInvalidDecl() && 9374 NewFD->getReturnType()->isVariablyModifiedType()) { 9375 Diag(NewFD->getLocation(), diag::err_vm_func_decl); 9376 NewFD->setInvalidDecl(); 9377 } 9378 9379 // Apply an implicit SectionAttr if '#pragma clang section text' is active 9380 if (PragmaClangTextSection.Valid && D.isFunctionDefinition() && 9381 !NewFD->hasAttr<SectionAttr>()) 9382 NewFD->addAttr(PragmaClangTextSectionAttr::CreateImplicit( 9383 Context, PragmaClangTextSection.SectionName, 9384 PragmaClangTextSection.PragmaLocation, AttributeCommonInfo::AS_Pragma)); 9385 9386 // Apply an implicit SectionAttr if #pragma code_seg is active. 9387 if (CodeSegStack.CurrentValue && D.isFunctionDefinition() && 9388 !NewFD->hasAttr<SectionAttr>()) { 9389 NewFD->addAttr(SectionAttr::CreateImplicit( 9390 Context, CodeSegStack.CurrentValue->getString(), 9391 CodeSegStack.CurrentPragmaLocation, AttributeCommonInfo::AS_Pragma, 9392 SectionAttr::Declspec_allocate)); 9393 if (UnifySection(CodeSegStack.CurrentValue->getString(), 9394 ASTContext::PSF_Implicit | ASTContext::PSF_Execute | 9395 ASTContext::PSF_Read, 9396 NewFD)) 9397 NewFD->dropAttr<SectionAttr>(); 9398 } 9399 9400 // Apply an implicit CodeSegAttr from class declspec or 9401 // apply an implicit SectionAttr from #pragma code_seg if active. 9402 if (!NewFD->hasAttr<CodeSegAttr>()) { 9403 if (Attr *SAttr = getImplicitCodeSegOrSectionAttrForFunction(NewFD, 9404 D.isFunctionDefinition())) { 9405 NewFD->addAttr(SAttr); 9406 } 9407 } 9408 9409 // Handle attributes. 9410 ProcessDeclAttributes(S, NewFD, D); 9411 9412 if (getLangOpts().OpenCL) { 9413 // OpenCL v1.1 s6.5: Using an address space qualifier in a function return 9414 // type declaration will generate a compilation error. 9415 LangAS AddressSpace = NewFD->getReturnType().getAddressSpace(); 9416 if (AddressSpace != LangAS::Default) { 9417 Diag(NewFD->getLocation(), 9418 diag::err_opencl_return_value_with_address_space); 9419 NewFD->setInvalidDecl(); 9420 } 9421 } 9422 9423 if (LangOpts.SYCLIsDevice || (LangOpts.OpenMP && LangOpts.OpenMPIsDevice)) 9424 checkDeviceDecl(NewFD, D.getBeginLoc()); 9425 9426 if (!getLangOpts().CPlusPlus) { 9427 // Perform semantic checking on the function declaration. 9428 if (!NewFD->isInvalidDecl() && NewFD->isMain()) 9429 CheckMain(NewFD, D.getDeclSpec()); 9430 9431 if (!NewFD->isInvalidDecl() && NewFD->isMSVCRTEntryPoint()) 9432 CheckMSVCRTEntryPoint(NewFD); 9433 9434 if (!NewFD->isInvalidDecl()) 9435 D.setRedeclaration(CheckFunctionDeclaration(S, NewFD, Previous, 9436 isMemberSpecialization)); 9437 else if (!Previous.empty()) 9438 // Recover gracefully from an invalid redeclaration. 9439 D.setRedeclaration(true); 9440 assert((NewFD->isInvalidDecl() || !D.isRedeclaration() || 9441 Previous.getResultKind() != LookupResult::FoundOverloaded) && 9442 "previous declaration set still overloaded"); 9443 9444 // Diagnose no-prototype function declarations with calling conventions that 9445 // don't support variadic calls. Only do this in C and do it after merging 9446 // possibly prototyped redeclarations. 9447 const FunctionType *FT = NewFD->getType()->castAs<FunctionType>(); 9448 if (isa<FunctionNoProtoType>(FT) && !D.isFunctionDefinition()) { 9449 CallingConv CC = FT->getExtInfo().getCC(); 9450 if (!supportsVariadicCall(CC)) { 9451 // Windows system headers sometimes accidentally use stdcall without 9452 // (void) parameters, so we relax this to a warning. 9453 int DiagID = 9454 CC == CC_X86StdCall ? diag::warn_cconv_knr : diag::err_cconv_knr; 9455 Diag(NewFD->getLocation(), DiagID) 9456 << FunctionType::getNameForCallConv(CC); 9457 } 9458 } 9459 9460 if (NewFD->getReturnType().hasNonTrivialToPrimitiveDestructCUnion() || 9461 NewFD->getReturnType().hasNonTrivialToPrimitiveCopyCUnion()) 9462 checkNonTrivialCUnion(NewFD->getReturnType(), 9463 NewFD->getReturnTypeSourceRange().getBegin(), 9464 NTCUC_FunctionReturn, NTCUK_Destruct|NTCUK_Copy); 9465 } else { 9466 // C++11 [replacement.functions]p3: 9467 // The program's definitions shall not be specified as inline. 9468 // 9469 // N.B. We diagnose declarations instead of definitions per LWG issue 2340. 9470 // 9471 // Suppress the diagnostic if the function is __attribute__((used)), since 9472 // that forces an external definition to be emitted. 9473 if (D.getDeclSpec().isInlineSpecified() && 9474 NewFD->isReplaceableGlobalAllocationFunction() && 9475 !NewFD->hasAttr<UsedAttr>()) 9476 Diag(D.getDeclSpec().getInlineSpecLoc(), 9477 diag::ext_operator_new_delete_declared_inline) 9478 << NewFD->getDeclName(); 9479 9480 // If the declarator is a template-id, translate the parser's template 9481 // argument list into our AST format. 9482 if (D.getName().getKind() == UnqualifiedIdKind::IK_TemplateId) { 9483 TemplateIdAnnotation *TemplateId = D.getName().TemplateId; 9484 TemplateArgs.setLAngleLoc(TemplateId->LAngleLoc); 9485 TemplateArgs.setRAngleLoc(TemplateId->RAngleLoc); 9486 ASTTemplateArgsPtr TemplateArgsPtr(TemplateId->getTemplateArgs(), 9487 TemplateId->NumArgs); 9488 translateTemplateArguments(TemplateArgsPtr, 9489 TemplateArgs); 9490 9491 HasExplicitTemplateArgs = true; 9492 9493 if (NewFD->isInvalidDecl()) { 9494 HasExplicitTemplateArgs = false; 9495 } else if (FunctionTemplate) { 9496 // Function template with explicit template arguments. 9497 Diag(D.getIdentifierLoc(), diag::err_function_template_partial_spec) 9498 << SourceRange(TemplateId->LAngleLoc, TemplateId->RAngleLoc); 9499 9500 HasExplicitTemplateArgs = false; 9501 } else { 9502 assert((isFunctionTemplateSpecialization || 9503 D.getDeclSpec().isFriendSpecified()) && 9504 "should have a 'template<>' for this decl"); 9505 // "friend void foo<>(int);" is an implicit specialization decl. 9506 isFunctionTemplateSpecialization = true; 9507 } 9508 } else if (isFriend && isFunctionTemplateSpecialization) { 9509 // This combination is only possible in a recovery case; the user 9510 // wrote something like: 9511 // template <> friend void foo(int); 9512 // which we're recovering from as if the user had written: 9513 // friend void foo<>(int); 9514 // Go ahead and fake up a template id. 9515 HasExplicitTemplateArgs = true; 9516 TemplateArgs.setLAngleLoc(D.getIdentifierLoc()); 9517 TemplateArgs.setRAngleLoc(D.getIdentifierLoc()); 9518 } 9519 9520 // We do not add HD attributes to specializations here because 9521 // they may have different constexpr-ness compared to their 9522 // templates and, after maybeAddCUDAHostDeviceAttrs() is applied, 9523 // may end up with different effective targets. Instead, a 9524 // specialization inherits its target attributes from its template 9525 // in the CheckFunctionTemplateSpecialization() call below. 9526 if (getLangOpts().CUDA && !isFunctionTemplateSpecialization) 9527 maybeAddCUDAHostDeviceAttrs(NewFD, Previous); 9528 9529 // If it's a friend (and only if it's a friend), it's possible 9530 // that either the specialized function type or the specialized 9531 // template is dependent, and therefore matching will fail. In 9532 // this case, don't check the specialization yet. 9533 if (isFunctionTemplateSpecialization && isFriend && 9534 (NewFD->getType()->isDependentType() || DC->isDependentContext() || 9535 TemplateSpecializationType::anyInstantiationDependentTemplateArguments( 9536 TemplateArgs.arguments()))) { 9537 assert(HasExplicitTemplateArgs && 9538 "friend function specialization without template args"); 9539 if (CheckDependentFunctionTemplateSpecialization(NewFD, TemplateArgs, 9540 Previous)) 9541 NewFD->setInvalidDecl(); 9542 } else if (isFunctionTemplateSpecialization) { 9543 if (CurContext->isDependentContext() && CurContext->isRecord() 9544 && !isFriend) { 9545 isDependentClassScopeExplicitSpecialization = true; 9546 } else if (!NewFD->isInvalidDecl() && 9547 CheckFunctionTemplateSpecialization( 9548 NewFD, (HasExplicitTemplateArgs ? &TemplateArgs : nullptr), 9549 Previous)) 9550 NewFD->setInvalidDecl(); 9551 9552 // C++ [dcl.stc]p1: 9553 // A storage-class-specifier shall not be specified in an explicit 9554 // specialization (14.7.3) 9555 FunctionTemplateSpecializationInfo *Info = 9556 NewFD->getTemplateSpecializationInfo(); 9557 if (Info && SC != SC_None) { 9558 if (SC != Info->getTemplate()->getTemplatedDecl()->getStorageClass()) 9559 Diag(NewFD->getLocation(), 9560 diag::err_explicit_specialization_inconsistent_storage_class) 9561 << SC 9562 << FixItHint::CreateRemoval( 9563 D.getDeclSpec().getStorageClassSpecLoc()); 9564 9565 else 9566 Diag(NewFD->getLocation(), 9567 diag::ext_explicit_specialization_storage_class) 9568 << FixItHint::CreateRemoval( 9569 D.getDeclSpec().getStorageClassSpecLoc()); 9570 } 9571 } else if (isMemberSpecialization && isa<CXXMethodDecl>(NewFD)) { 9572 if (CheckMemberSpecialization(NewFD, Previous)) 9573 NewFD->setInvalidDecl(); 9574 } 9575 9576 // Perform semantic checking on the function declaration. 9577 if (!isDependentClassScopeExplicitSpecialization) { 9578 if (!NewFD->isInvalidDecl() && NewFD->isMain()) 9579 CheckMain(NewFD, D.getDeclSpec()); 9580 9581 if (!NewFD->isInvalidDecl() && NewFD->isMSVCRTEntryPoint()) 9582 CheckMSVCRTEntryPoint(NewFD); 9583 9584 if (!NewFD->isInvalidDecl()) 9585 D.setRedeclaration(CheckFunctionDeclaration(S, NewFD, Previous, 9586 isMemberSpecialization)); 9587 else if (!Previous.empty()) 9588 // Recover gracefully from an invalid redeclaration. 9589 D.setRedeclaration(true); 9590 } 9591 9592 assert((NewFD->isInvalidDecl() || !D.isRedeclaration() || 9593 Previous.getResultKind() != LookupResult::FoundOverloaded) && 9594 "previous declaration set still overloaded"); 9595 9596 NamedDecl *PrincipalDecl = (FunctionTemplate 9597 ? cast<NamedDecl>(FunctionTemplate) 9598 : NewFD); 9599 9600 if (isFriend && NewFD->getPreviousDecl()) { 9601 AccessSpecifier Access = AS_public; 9602 if (!NewFD->isInvalidDecl()) 9603 Access = NewFD->getPreviousDecl()->getAccess(); 9604 9605 NewFD->setAccess(Access); 9606 if (FunctionTemplate) FunctionTemplate->setAccess(Access); 9607 } 9608 9609 if (NewFD->isOverloadedOperator() && !DC->isRecord() && 9610 PrincipalDecl->isInIdentifierNamespace(Decl::IDNS_Ordinary)) 9611 PrincipalDecl->setNonMemberOperator(); 9612 9613 // If we have a function template, check the template parameter 9614 // list. This will check and merge default template arguments. 9615 if (FunctionTemplate) { 9616 FunctionTemplateDecl *PrevTemplate = 9617 FunctionTemplate->getPreviousDecl(); 9618 CheckTemplateParameterList(FunctionTemplate->getTemplateParameters(), 9619 PrevTemplate ? PrevTemplate->getTemplateParameters() 9620 : nullptr, 9621 D.getDeclSpec().isFriendSpecified() 9622 ? (D.isFunctionDefinition() 9623 ? TPC_FriendFunctionTemplateDefinition 9624 : TPC_FriendFunctionTemplate) 9625 : (D.getCXXScopeSpec().isSet() && 9626 DC && DC->isRecord() && 9627 DC->isDependentContext()) 9628 ? TPC_ClassTemplateMember 9629 : TPC_FunctionTemplate); 9630 } 9631 9632 if (NewFD->isInvalidDecl()) { 9633 // Ignore all the rest of this. 9634 } else if (!D.isRedeclaration()) { 9635 struct ActOnFDArgs ExtraArgs = { S, D, TemplateParamLists, 9636 AddToScope }; 9637 // Fake up an access specifier if it's supposed to be a class member. 9638 if (isa<CXXRecordDecl>(NewFD->getDeclContext())) 9639 NewFD->setAccess(AS_public); 9640 9641 // Qualified decls generally require a previous declaration. 9642 if (D.getCXXScopeSpec().isSet()) { 9643 // ...with the major exception of templated-scope or 9644 // dependent-scope friend declarations. 9645 9646 // TODO: we currently also suppress this check in dependent 9647 // contexts because (1) the parameter depth will be off when 9648 // matching friend templates and (2) we might actually be 9649 // selecting a friend based on a dependent factor. But there 9650 // are situations where these conditions don't apply and we 9651 // can actually do this check immediately. 9652 // 9653 // Unless the scope is dependent, it's always an error if qualified 9654 // redeclaration lookup found nothing at all. Diagnose that now; 9655 // nothing will diagnose that error later. 9656 if (isFriend && 9657 (D.getCXXScopeSpec().getScopeRep()->isDependent() || 9658 (!Previous.empty() && CurContext->isDependentContext()))) { 9659 // ignore these 9660 } else { 9661 // The user tried to provide an out-of-line definition for a 9662 // function that is a member of a class or namespace, but there 9663 // was no such member function declared (C++ [class.mfct]p2, 9664 // C++ [namespace.memdef]p2). For example: 9665 // 9666 // class X { 9667 // void f() const; 9668 // }; 9669 // 9670 // void X::f() { } // ill-formed 9671 // 9672 // Complain about this problem, and attempt to suggest close 9673 // matches (e.g., those that differ only in cv-qualifiers and 9674 // whether the parameter types are references). 9675 9676 if (NamedDecl *Result = DiagnoseInvalidRedeclaration( 9677 *this, Previous, NewFD, ExtraArgs, false, nullptr)) { 9678 AddToScope = ExtraArgs.AddToScope; 9679 return Result; 9680 } 9681 } 9682 9683 // Unqualified local friend declarations are required to resolve 9684 // to something. 9685 } else if (isFriend && cast<CXXRecordDecl>(CurContext)->isLocalClass()) { 9686 if (NamedDecl *Result = DiagnoseInvalidRedeclaration( 9687 *this, Previous, NewFD, ExtraArgs, true, S)) { 9688 AddToScope = ExtraArgs.AddToScope; 9689 return Result; 9690 } 9691 } 9692 } else if (!D.isFunctionDefinition() && 9693 isa<CXXMethodDecl>(NewFD) && NewFD->isOutOfLine() && 9694 !isFriend && !isFunctionTemplateSpecialization && 9695 !isMemberSpecialization) { 9696 // An out-of-line member function declaration must also be a 9697 // definition (C++ [class.mfct]p2). 9698 // Note that this is not the case for explicit specializations of 9699 // function templates or member functions of class templates, per 9700 // C++ [temp.expl.spec]p2. We also allow these declarations as an 9701 // extension for compatibility with old SWIG code which likes to 9702 // generate them. 9703 Diag(NewFD->getLocation(), diag::ext_out_of_line_declaration) 9704 << D.getCXXScopeSpec().getRange(); 9705 } 9706 } 9707 9708 // If this is the first declaration of a library builtin function, add 9709 // attributes as appropriate. 9710 if (!D.isRedeclaration() && 9711 NewFD->getDeclContext()->getRedeclContext()->isFileContext()) { 9712 if (IdentifierInfo *II = Previous.getLookupName().getAsIdentifierInfo()) { 9713 if (unsigned BuiltinID = II->getBuiltinID()) { 9714 if (NewFD->getLanguageLinkage() == CLanguageLinkage) { 9715 // Validate the type matches unless this builtin is specified as 9716 // matching regardless of its declared type. 9717 if (Context.BuiltinInfo.allowTypeMismatch(BuiltinID)) { 9718 NewFD->addAttr(BuiltinAttr::CreateImplicit(Context, BuiltinID)); 9719 } else { 9720 ASTContext::GetBuiltinTypeError Error; 9721 LookupNecessaryTypesForBuiltin(S, BuiltinID); 9722 QualType BuiltinType = Context.GetBuiltinType(BuiltinID, Error); 9723 9724 if (!Error && !BuiltinType.isNull() && 9725 Context.hasSameFunctionTypeIgnoringExceptionSpec( 9726 NewFD->getType(), BuiltinType)) 9727 NewFD->addAttr(BuiltinAttr::CreateImplicit(Context, BuiltinID)); 9728 } 9729 } else if (BuiltinID == Builtin::BI__GetExceptionInfo && 9730 Context.getTargetInfo().getCXXABI().isMicrosoft()) { 9731 // FIXME: We should consider this a builtin only in the std namespace. 9732 NewFD->addAttr(BuiltinAttr::CreateImplicit(Context, BuiltinID)); 9733 } 9734 } 9735 } 9736 } 9737 9738 ProcessPragmaWeak(S, NewFD); 9739 checkAttributesAfterMerging(*this, *NewFD); 9740 9741 AddKnownFunctionAttributes(NewFD); 9742 9743 if (NewFD->hasAttr<OverloadableAttr>() && 9744 !NewFD->getType()->getAs<FunctionProtoType>()) { 9745 Diag(NewFD->getLocation(), 9746 diag::err_attribute_overloadable_no_prototype) 9747 << NewFD; 9748 9749 // Turn this into a variadic function with no parameters. 9750 const FunctionType *FT = NewFD->getType()->getAs<FunctionType>(); 9751 FunctionProtoType::ExtProtoInfo EPI( 9752 Context.getDefaultCallingConvention(true, false)); 9753 EPI.Variadic = true; 9754 EPI.ExtInfo = FT->getExtInfo(); 9755 9756 QualType R = Context.getFunctionType(FT->getReturnType(), None, EPI); 9757 NewFD->setType(R); 9758 } 9759 9760 // If there's a #pragma GCC visibility in scope, and this isn't a class 9761 // member, set the visibility of this function. 9762 if (!DC->isRecord() && NewFD->isExternallyVisible()) 9763 AddPushedVisibilityAttribute(NewFD); 9764 9765 // If there's a #pragma clang arc_cf_code_audited in scope, consider 9766 // marking the function. 9767 AddCFAuditedAttribute(NewFD); 9768 9769 // If this is a function definition, check if we have to apply optnone due to 9770 // a pragma. 9771 if(D.isFunctionDefinition()) 9772 AddRangeBasedOptnone(NewFD); 9773 9774 // If this is the first declaration of an extern C variable, update 9775 // the map of such variables. 9776 if (NewFD->isFirstDecl() && !NewFD->isInvalidDecl() && 9777 isIncompleteDeclExternC(*this, NewFD)) 9778 RegisterLocallyScopedExternCDecl(NewFD, S); 9779 9780 // Set this FunctionDecl's range up to the right paren. 9781 NewFD->setRangeEnd(D.getSourceRange().getEnd()); 9782 9783 if (D.isRedeclaration() && !Previous.empty()) { 9784 NamedDecl *Prev = Previous.getRepresentativeDecl(); 9785 checkDLLAttributeRedeclaration(*this, Prev, NewFD, 9786 isMemberSpecialization || 9787 isFunctionTemplateSpecialization, 9788 D.isFunctionDefinition()); 9789 } 9790 9791 if (getLangOpts().CUDA) { 9792 IdentifierInfo *II = NewFD->getIdentifier(); 9793 if (II && II->isStr(getCudaConfigureFuncName()) && 9794 !NewFD->isInvalidDecl() && 9795 NewFD->getDeclContext()->getRedeclContext()->isTranslationUnit()) { 9796 if (!R->getAs<FunctionType>()->getReturnType()->isScalarType()) 9797 Diag(NewFD->getLocation(), diag::err_config_scalar_return) 9798 << getCudaConfigureFuncName(); 9799 Context.setcudaConfigureCallDecl(NewFD); 9800 } 9801 9802 // Variadic functions, other than a *declaration* of printf, are not allowed 9803 // in device-side CUDA code, unless someone passed 9804 // -fcuda-allow-variadic-functions. 9805 if (!getLangOpts().CUDAAllowVariadicFunctions && NewFD->isVariadic() && 9806 (NewFD->hasAttr<CUDADeviceAttr>() || 9807 NewFD->hasAttr<CUDAGlobalAttr>()) && 9808 !(II && II->isStr("printf") && NewFD->isExternC() && 9809 !D.isFunctionDefinition())) { 9810 Diag(NewFD->getLocation(), diag::err_variadic_device_fn); 9811 } 9812 } 9813 9814 MarkUnusedFileScopedDecl(NewFD); 9815 9816 9817 9818 if (getLangOpts().OpenCL && NewFD->hasAttr<OpenCLKernelAttr>()) { 9819 // OpenCL v1.2 s6.8 static is invalid for kernel functions. 9820 if ((getLangOpts().OpenCLVersion >= 120) 9821 && (SC == SC_Static)) { 9822 Diag(D.getIdentifierLoc(), diag::err_static_kernel); 9823 D.setInvalidType(); 9824 } 9825 9826 // OpenCL v1.2, s6.9 -- Kernels can only have return type void. 9827 if (!NewFD->getReturnType()->isVoidType()) { 9828 SourceRange RTRange = NewFD->getReturnTypeSourceRange(); 9829 Diag(D.getIdentifierLoc(), diag::err_expected_kernel_void_return_type) 9830 << (RTRange.isValid() ? FixItHint::CreateReplacement(RTRange, "void") 9831 : FixItHint()); 9832 D.setInvalidType(); 9833 } 9834 9835 llvm::SmallPtrSet<const Type *, 16> ValidTypes; 9836 for (auto Param : NewFD->parameters()) 9837 checkIsValidOpenCLKernelParameter(*this, D, Param, ValidTypes); 9838 9839 if (getLangOpts().OpenCLCPlusPlus) { 9840 if (DC->isRecord()) { 9841 Diag(D.getIdentifierLoc(), diag::err_method_kernel); 9842 D.setInvalidType(); 9843 } 9844 if (FunctionTemplate) { 9845 Diag(D.getIdentifierLoc(), diag::err_template_kernel); 9846 D.setInvalidType(); 9847 } 9848 } 9849 } 9850 9851 if (getLangOpts().CPlusPlus) { 9852 if (FunctionTemplate) { 9853 if (NewFD->isInvalidDecl()) 9854 FunctionTemplate->setInvalidDecl(); 9855 return FunctionTemplate; 9856 } 9857 9858 if (isMemberSpecialization && !NewFD->isInvalidDecl()) 9859 CompleteMemberSpecialization(NewFD, Previous); 9860 } 9861 9862 for (const ParmVarDecl *Param : NewFD->parameters()) { 9863 QualType PT = Param->getType(); 9864 9865 // OpenCL 2.0 pipe restrictions forbids pipe packet types to be non-value 9866 // types. 9867 if (getLangOpts().OpenCLVersion >= 200 || getLangOpts().OpenCLCPlusPlus) { 9868 if(const PipeType *PipeTy = PT->getAs<PipeType>()) { 9869 QualType ElemTy = PipeTy->getElementType(); 9870 if (ElemTy->isReferenceType() || ElemTy->isPointerType()) { 9871 Diag(Param->getTypeSpecStartLoc(), diag::err_reference_pipe_type ); 9872 D.setInvalidType(); 9873 } 9874 } 9875 } 9876 } 9877 9878 // Here we have an function template explicit specialization at class scope. 9879 // The actual specialization will be postponed to template instatiation 9880 // time via the ClassScopeFunctionSpecializationDecl node. 9881 if (isDependentClassScopeExplicitSpecialization) { 9882 ClassScopeFunctionSpecializationDecl *NewSpec = 9883 ClassScopeFunctionSpecializationDecl::Create( 9884 Context, CurContext, NewFD->getLocation(), 9885 cast<CXXMethodDecl>(NewFD), 9886 HasExplicitTemplateArgs, TemplateArgs); 9887 CurContext->addDecl(NewSpec); 9888 AddToScope = false; 9889 } 9890 9891 // Diagnose availability attributes. Availability cannot be used on functions 9892 // that are run during load/unload. 9893 if (const auto *attr = NewFD->getAttr<AvailabilityAttr>()) { 9894 if (NewFD->hasAttr<ConstructorAttr>()) { 9895 Diag(attr->getLocation(), diag::warn_availability_on_static_initializer) 9896 << 1; 9897 NewFD->dropAttr<AvailabilityAttr>(); 9898 } 9899 if (NewFD->hasAttr<DestructorAttr>()) { 9900 Diag(attr->getLocation(), diag::warn_availability_on_static_initializer) 9901 << 2; 9902 NewFD->dropAttr<AvailabilityAttr>(); 9903 } 9904 } 9905 9906 // Diagnose no_builtin attribute on function declaration that are not a 9907 // definition. 9908 // FIXME: We should really be doing this in 9909 // SemaDeclAttr.cpp::handleNoBuiltinAttr, unfortunately we only have access to 9910 // the FunctionDecl and at this point of the code 9911 // FunctionDecl::isThisDeclarationADefinition() which always returns `false` 9912 // because Sema::ActOnStartOfFunctionDef has not been called yet. 9913 if (const auto *NBA = NewFD->getAttr<NoBuiltinAttr>()) 9914 switch (D.getFunctionDefinitionKind()) { 9915 case FunctionDefinitionKind::Defaulted: 9916 case FunctionDefinitionKind::Deleted: 9917 Diag(NBA->getLocation(), 9918 diag::err_attribute_no_builtin_on_defaulted_deleted_function) 9919 << NBA->getSpelling(); 9920 break; 9921 case FunctionDefinitionKind::Declaration: 9922 Diag(NBA->getLocation(), diag::err_attribute_no_builtin_on_non_definition) 9923 << NBA->getSpelling(); 9924 break; 9925 case FunctionDefinitionKind::Definition: 9926 break; 9927 } 9928 9929 return NewFD; 9930 } 9931 9932 /// Return a CodeSegAttr from a containing class. The Microsoft docs say 9933 /// when __declspec(code_seg) "is applied to a class, all member functions of 9934 /// the class and nested classes -- this includes compiler-generated special 9935 /// member functions -- are put in the specified segment." 9936 /// The actual behavior is a little more complicated. The Microsoft compiler 9937 /// won't check outer classes if there is an active value from #pragma code_seg. 9938 /// The CodeSeg is always applied from the direct parent but only from outer 9939 /// classes when the #pragma code_seg stack is empty. See: 9940 /// https://reviews.llvm.org/D22931, the Microsoft feedback page is no longer 9941 /// available since MS has removed the page. 9942 static Attr *getImplicitCodeSegAttrFromClass(Sema &S, const FunctionDecl *FD) { 9943 const auto *Method = dyn_cast<CXXMethodDecl>(FD); 9944 if (!Method) 9945 return nullptr; 9946 const CXXRecordDecl *Parent = Method->getParent(); 9947 if (const auto *SAttr = Parent->getAttr<CodeSegAttr>()) { 9948 Attr *NewAttr = SAttr->clone(S.getASTContext()); 9949 NewAttr->setImplicit(true); 9950 return NewAttr; 9951 } 9952 9953 // The Microsoft compiler won't check outer classes for the CodeSeg 9954 // when the #pragma code_seg stack is active. 9955 if (S.CodeSegStack.CurrentValue) 9956 return nullptr; 9957 9958 while ((Parent = dyn_cast<CXXRecordDecl>(Parent->getParent()))) { 9959 if (const auto *SAttr = Parent->getAttr<CodeSegAttr>()) { 9960 Attr *NewAttr = SAttr->clone(S.getASTContext()); 9961 NewAttr->setImplicit(true); 9962 return NewAttr; 9963 } 9964 } 9965 return nullptr; 9966 } 9967 9968 /// Returns an implicit CodeSegAttr if a __declspec(code_seg) is found on a 9969 /// containing class. Otherwise it will return implicit SectionAttr if the 9970 /// function is a definition and there is an active value on CodeSegStack 9971 /// (from the current #pragma code-seg value). 9972 /// 9973 /// \param FD Function being declared. 9974 /// \param IsDefinition Whether it is a definition or just a declarartion. 9975 /// \returns A CodeSegAttr or SectionAttr to apply to the function or 9976 /// nullptr if no attribute should be added. 9977 Attr *Sema::getImplicitCodeSegOrSectionAttrForFunction(const FunctionDecl *FD, 9978 bool IsDefinition) { 9979 if (Attr *A = getImplicitCodeSegAttrFromClass(*this, FD)) 9980 return A; 9981 if (!FD->hasAttr<SectionAttr>() && IsDefinition && 9982 CodeSegStack.CurrentValue) 9983 return SectionAttr::CreateImplicit( 9984 getASTContext(), CodeSegStack.CurrentValue->getString(), 9985 CodeSegStack.CurrentPragmaLocation, AttributeCommonInfo::AS_Pragma, 9986 SectionAttr::Declspec_allocate); 9987 return nullptr; 9988 } 9989 9990 /// Determines if we can perform a correct type check for \p D as a 9991 /// redeclaration of \p PrevDecl. If not, we can generally still perform a 9992 /// best-effort check. 9993 /// 9994 /// \param NewD The new declaration. 9995 /// \param OldD The old declaration. 9996 /// \param NewT The portion of the type of the new declaration to check. 9997 /// \param OldT The portion of the type of the old declaration to check. 9998 bool Sema::canFullyTypeCheckRedeclaration(ValueDecl *NewD, ValueDecl *OldD, 9999 QualType NewT, QualType OldT) { 10000 if (!NewD->getLexicalDeclContext()->isDependentContext()) 10001 return true; 10002 10003 // For dependently-typed local extern declarations and friends, we can't 10004 // perform a correct type check in general until instantiation: 10005 // 10006 // int f(); 10007 // template<typename T> void g() { T f(); } 10008 // 10009 // (valid if g() is only instantiated with T = int). 10010 if (NewT->isDependentType() && 10011 (NewD->isLocalExternDecl() || NewD->getFriendObjectKind())) 10012 return false; 10013 10014 // Similarly, if the previous declaration was a dependent local extern 10015 // declaration, we don't really know its type yet. 10016 if (OldT->isDependentType() && OldD->isLocalExternDecl()) 10017 return false; 10018 10019 return true; 10020 } 10021 10022 /// Checks if the new declaration declared in dependent context must be 10023 /// put in the same redeclaration chain as the specified declaration. 10024 /// 10025 /// \param D Declaration that is checked. 10026 /// \param PrevDecl Previous declaration found with proper lookup method for the 10027 /// same declaration name. 10028 /// \returns True if D must be added to the redeclaration chain which PrevDecl 10029 /// belongs to. 10030 /// 10031 bool Sema::shouldLinkDependentDeclWithPrevious(Decl *D, Decl *PrevDecl) { 10032 if (!D->getLexicalDeclContext()->isDependentContext()) 10033 return true; 10034 10035 // Don't chain dependent friend function definitions until instantiation, to 10036 // permit cases like 10037 // 10038 // void func(); 10039 // template<typename T> class C1 { friend void func() {} }; 10040 // template<typename T> class C2 { friend void func() {} }; 10041 // 10042 // ... which is valid if only one of C1 and C2 is ever instantiated. 10043 // 10044 // FIXME: This need only apply to function definitions. For now, we proxy 10045 // this by checking for a file-scope function. We do not want this to apply 10046 // to friend declarations nominating member functions, because that gets in 10047 // the way of access checks. 10048 if (D->getFriendObjectKind() && D->getDeclContext()->isFileContext()) 10049 return false; 10050 10051 auto *VD = dyn_cast<ValueDecl>(D); 10052 auto *PrevVD = dyn_cast<ValueDecl>(PrevDecl); 10053 return !VD || !PrevVD || 10054 canFullyTypeCheckRedeclaration(VD, PrevVD, VD->getType(), 10055 PrevVD->getType()); 10056 } 10057 10058 /// Check the target attribute of the function for MultiVersion 10059 /// validity. 10060 /// 10061 /// Returns true if there was an error, false otherwise. 10062 static bool CheckMultiVersionValue(Sema &S, const FunctionDecl *FD) { 10063 const auto *TA = FD->getAttr<TargetAttr>(); 10064 assert(TA && "MultiVersion Candidate requires a target attribute"); 10065 ParsedTargetAttr ParseInfo = TA->parse(); 10066 const TargetInfo &TargetInfo = S.Context.getTargetInfo(); 10067 enum ErrType { Feature = 0, Architecture = 1 }; 10068 10069 if (!ParseInfo.Architecture.empty() && 10070 !TargetInfo.validateCpuIs(ParseInfo.Architecture)) { 10071 S.Diag(FD->getLocation(), diag::err_bad_multiversion_option) 10072 << Architecture << ParseInfo.Architecture; 10073 return true; 10074 } 10075 10076 for (const auto &Feat : ParseInfo.Features) { 10077 auto BareFeat = StringRef{Feat}.substr(1); 10078 if (Feat[0] == '-') { 10079 S.Diag(FD->getLocation(), diag::err_bad_multiversion_option) 10080 << Feature << ("no-" + BareFeat).str(); 10081 return true; 10082 } 10083 10084 if (!TargetInfo.validateCpuSupports(BareFeat) || 10085 !TargetInfo.isValidFeatureName(BareFeat)) { 10086 S.Diag(FD->getLocation(), diag::err_bad_multiversion_option) 10087 << Feature << BareFeat; 10088 return true; 10089 } 10090 } 10091 return false; 10092 } 10093 10094 // Provide a white-list of attributes that are allowed to be combined with 10095 // multiversion functions. 10096 static bool AttrCompatibleWithMultiVersion(attr::Kind Kind, 10097 MultiVersionKind MVType) { 10098 // Note: this list/diagnosis must match the list in 10099 // checkMultiversionAttributesAllSame. 10100 switch (Kind) { 10101 default: 10102 return false; 10103 case attr::Used: 10104 return MVType == MultiVersionKind::Target; 10105 case attr::NonNull: 10106 case attr::NoThrow: 10107 return true; 10108 } 10109 } 10110 10111 static bool checkNonMultiVersionCompatAttributes(Sema &S, 10112 const FunctionDecl *FD, 10113 const FunctionDecl *CausedFD, 10114 MultiVersionKind MVType) { 10115 bool IsCPUSpecificCPUDispatchMVType = 10116 MVType == MultiVersionKind::CPUDispatch || 10117 MVType == MultiVersionKind::CPUSpecific; 10118 const auto Diagnose = [FD, CausedFD, IsCPUSpecificCPUDispatchMVType]( 10119 Sema &S, const Attr *A) { 10120 S.Diag(FD->getLocation(), diag::err_multiversion_disallowed_other_attr) 10121 << IsCPUSpecificCPUDispatchMVType << A; 10122 if (CausedFD) 10123 S.Diag(CausedFD->getLocation(), diag::note_multiversioning_caused_here); 10124 return true; 10125 }; 10126 10127 for (const Attr *A : FD->attrs()) { 10128 switch (A->getKind()) { 10129 case attr::CPUDispatch: 10130 case attr::CPUSpecific: 10131 if (MVType != MultiVersionKind::CPUDispatch && 10132 MVType != MultiVersionKind::CPUSpecific) 10133 return Diagnose(S, A); 10134 break; 10135 case attr::Target: 10136 if (MVType != MultiVersionKind::Target) 10137 return Diagnose(S, A); 10138 break; 10139 default: 10140 if (!AttrCompatibleWithMultiVersion(A->getKind(), MVType)) 10141 return Diagnose(S, A); 10142 break; 10143 } 10144 } 10145 return false; 10146 } 10147 10148 bool Sema::areMultiversionVariantFunctionsCompatible( 10149 const FunctionDecl *OldFD, const FunctionDecl *NewFD, 10150 const PartialDiagnostic &NoProtoDiagID, 10151 const PartialDiagnosticAt &NoteCausedDiagIDAt, 10152 const PartialDiagnosticAt &NoSupportDiagIDAt, 10153 const PartialDiagnosticAt &DiffDiagIDAt, bool TemplatesSupported, 10154 bool ConstexprSupported, bool CLinkageMayDiffer) { 10155 enum DoesntSupport { 10156 FuncTemplates = 0, 10157 VirtFuncs = 1, 10158 DeducedReturn = 2, 10159 Constructors = 3, 10160 Destructors = 4, 10161 DeletedFuncs = 5, 10162 DefaultedFuncs = 6, 10163 ConstexprFuncs = 7, 10164 ConstevalFuncs = 8, 10165 }; 10166 enum Different { 10167 CallingConv = 0, 10168 ReturnType = 1, 10169 ConstexprSpec = 2, 10170 InlineSpec = 3, 10171 StorageClass = 4, 10172 Linkage = 5, 10173 }; 10174 10175 if (NoProtoDiagID.getDiagID() != 0 && OldFD && 10176 !OldFD->getType()->getAs<FunctionProtoType>()) { 10177 Diag(OldFD->getLocation(), NoProtoDiagID); 10178 Diag(NoteCausedDiagIDAt.first, NoteCausedDiagIDAt.second); 10179 return true; 10180 } 10181 10182 if (NoProtoDiagID.getDiagID() != 0 && 10183 !NewFD->getType()->getAs<FunctionProtoType>()) 10184 return Diag(NewFD->getLocation(), NoProtoDiagID); 10185 10186 if (!TemplatesSupported && 10187 NewFD->getTemplatedKind() == FunctionDecl::TK_FunctionTemplate) 10188 return Diag(NoSupportDiagIDAt.first, NoSupportDiagIDAt.second) 10189 << FuncTemplates; 10190 10191 if (const auto *NewCXXFD = dyn_cast<CXXMethodDecl>(NewFD)) { 10192 if (NewCXXFD->isVirtual()) 10193 return Diag(NoSupportDiagIDAt.first, NoSupportDiagIDAt.second) 10194 << VirtFuncs; 10195 10196 if (isa<CXXConstructorDecl>(NewCXXFD)) 10197 return Diag(NoSupportDiagIDAt.first, NoSupportDiagIDAt.second) 10198 << Constructors; 10199 10200 if (isa<CXXDestructorDecl>(NewCXXFD)) 10201 return Diag(NoSupportDiagIDAt.first, NoSupportDiagIDAt.second) 10202 << Destructors; 10203 } 10204 10205 if (NewFD->isDeleted()) 10206 return Diag(NoSupportDiagIDAt.first, NoSupportDiagIDAt.second) 10207 << DeletedFuncs; 10208 10209 if (NewFD->isDefaulted()) 10210 return Diag(NoSupportDiagIDAt.first, NoSupportDiagIDAt.second) 10211 << DefaultedFuncs; 10212 10213 if (!ConstexprSupported && NewFD->isConstexpr()) 10214 return Diag(NoSupportDiagIDAt.first, NoSupportDiagIDAt.second) 10215 << (NewFD->isConsteval() ? ConstevalFuncs : ConstexprFuncs); 10216 10217 QualType NewQType = Context.getCanonicalType(NewFD->getType()); 10218 const auto *NewType = cast<FunctionType>(NewQType); 10219 QualType NewReturnType = NewType->getReturnType(); 10220 10221 if (NewReturnType->isUndeducedType()) 10222 return Diag(NoSupportDiagIDAt.first, NoSupportDiagIDAt.second) 10223 << DeducedReturn; 10224 10225 // Ensure the return type is identical. 10226 if (OldFD) { 10227 QualType OldQType = Context.getCanonicalType(OldFD->getType()); 10228 const auto *OldType = cast<FunctionType>(OldQType); 10229 FunctionType::ExtInfo OldTypeInfo = OldType->getExtInfo(); 10230 FunctionType::ExtInfo NewTypeInfo = NewType->getExtInfo(); 10231 10232 if (OldTypeInfo.getCC() != NewTypeInfo.getCC()) 10233 return Diag(DiffDiagIDAt.first, DiffDiagIDAt.second) << CallingConv; 10234 10235 QualType OldReturnType = OldType->getReturnType(); 10236 10237 if (OldReturnType != NewReturnType) 10238 return Diag(DiffDiagIDAt.first, DiffDiagIDAt.second) << ReturnType; 10239 10240 if (OldFD->getConstexprKind() != NewFD->getConstexprKind()) 10241 return Diag(DiffDiagIDAt.first, DiffDiagIDAt.second) << ConstexprSpec; 10242 10243 if (OldFD->isInlineSpecified() != NewFD->isInlineSpecified()) 10244 return Diag(DiffDiagIDAt.first, DiffDiagIDAt.second) << InlineSpec; 10245 10246 if (OldFD->getStorageClass() != NewFD->getStorageClass()) 10247 return Diag(DiffDiagIDAt.first, DiffDiagIDAt.second) << StorageClass; 10248 10249 if (!CLinkageMayDiffer && OldFD->isExternC() != NewFD->isExternC()) 10250 return Diag(DiffDiagIDAt.first, DiffDiagIDAt.second) << Linkage; 10251 10252 if (CheckEquivalentExceptionSpec( 10253 OldFD->getType()->getAs<FunctionProtoType>(), OldFD->getLocation(), 10254 NewFD->getType()->getAs<FunctionProtoType>(), NewFD->getLocation())) 10255 return true; 10256 } 10257 return false; 10258 } 10259 10260 static bool CheckMultiVersionAdditionalRules(Sema &S, const FunctionDecl *OldFD, 10261 const FunctionDecl *NewFD, 10262 bool CausesMV, 10263 MultiVersionKind MVType) { 10264 if (!S.getASTContext().getTargetInfo().supportsMultiVersioning()) { 10265 S.Diag(NewFD->getLocation(), diag::err_multiversion_not_supported); 10266 if (OldFD) 10267 S.Diag(OldFD->getLocation(), diag::note_previous_declaration); 10268 return true; 10269 } 10270 10271 bool IsCPUSpecificCPUDispatchMVType = 10272 MVType == MultiVersionKind::CPUDispatch || 10273 MVType == MultiVersionKind::CPUSpecific; 10274 10275 if (CausesMV && OldFD && 10276 checkNonMultiVersionCompatAttributes(S, OldFD, NewFD, MVType)) 10277 return true; 10278 10279 if (checkNonMultiVersionCompatAttributes(S, NewFD, nullptr, MVType)) 10280 return true; 10281 10282 // Only allow transition to MultiVersion if it hasn't been used. 10283 if (OldFD && CausesMV && OldFD->isUsed(false)) 10284 return S.Diag(NewFD->getLocation(), diag::err_multiversion_after_used); 10285 10286 return S.areMultiversionVariantFunctionsCompatible( 10287 OldFD, NewFD, S.PDiag(diag::err_multiversion_noproto), 10288 PartialDiagnosticAt(NewFD->getLocation(), 10289 S.PDiag(diag::note_multiversioning_caused_here)), 10290 PartialDiagnosticAt(NewFD->getLocation(), 10291 S.PDiag(diag::err_multiversion_doesnt_support) 10292 << IsCPUSpecificCPUDispatchMVType), 10293 PartialDiagnosticAt(NewFD->getLocation(), 10294 S.PDiag(diag::err_multiversion_diff)), 10295 /*TemplatesSupported=*/false, 10296 /*ConstexprSupported=*/!IsCPUSpecificCPUDispatchMVType, 10297 /*CLinkageMayDiffer=*/false); 10298 } 10299 10300 /// Check the validity of a multiversion function declaration that is the 10301 /// first of its kind. Also sets the multiversion'ness' of the function itself. 10302 /// 10303 /// This sets NewFD->isInvalidDecl() to true if there was an error. 10304 /// 10305 /// Returns true if there was an error, false otherwise. 10306 static bool CheckMultiVersionFirstFunction(Sema &S, FunctionDecl *FD, 10307 MultiVersionKind MVType, 10308 const TargetAttr *TA) { 10309 assert(MVType != MultiVersionKind::None && 10310 "Function lacks multiversion attribute"); 10311 10312 // Target only causes MV if it is default, otherwise this is a normal 10313 // function. 10314 if (MVType == MultiVersionKind::Target && !TA->isDefaultVersion()) 10315 return false; 10316 10317 if (MVType == MultiVersionKind::Target && CheckMultiVersionValue(S, FD)) { 10318 FD->setInvalidDecl(); 10319 return true; 10320 } 10321 10322 if (CheckMultiVersionAdditionalRules(S, nullptr, FD, true, MVType)) { 10323 FD->setInvalidDecl(); 10324 return true; 10325 } 10326 10327 FD->setIsMultiVersion(); 10328 return false; 10329 } 10330 10331 static bool PreviousDeclsHaveMultiVersionAttribute(const FunctionDecl *FD) { 10332 for (const Decl *D = FD->getPreviousDecl(); D; D = D->getPreviousDecl()) { 10333 if (D->getAsFunction()->getMultiVersionKind() != MultiVersionKind::None) 10334 return true; 10335 } 10336 10337 return false; 10338 } 10339 10340 static bool CheckTargetCausesMultiVersioning( 10341 Sema &S, FunctionDecl *OldFD, FunctionDecl *NewFD, const TargetAttr *NewTA, 10342 bool &Redeclaration, NamedDecl *&OldDecl, bool &MergeTypeWithPrevious, 10343 LookupResult &Previous) { 10344 const auto *OldTA = OldFD->getAttr<TargetAttr>(); 10345 ParsedTargetAttr NewParsed = NewTA->parse(); 10346 // Sort order doesn't matter, it just needs to be consistent. 10347 llvm::sort(NewParsed.Features); 10348 10349 // If the old decl is NOT MultiVersioned yet, and we don't cause that 10350 // to change, this is a simple redeclaration. 10351 if (!NewTA->isDefaultVersion() && 10352 (!OldTA || OldTA->getFeaturesStr() == NewTA->getFeaturesStr())) 10353 return false; 10354 10355 // Otherwise, this decl causes MultiVersioning. 10356 if (!S.getASTContext().getTargetInfo().supportsMultiVersioning()) { 10357 S.Diag(NewFD->getLocation(), diag::err_multiversion_not_supported); 10358 S.Diag(OldFD->getLocation(), diag::note_previous_declaration); 10359 NewFD->setInvalidDecl(); 10360 return true; 10361 } 10362 10363 if (CheckMultiVersionAdditionalRules(S, OldFD, NewFD, true, 10364 MultiVersionKind::Target)) { 10365 NewFD->setInvalidDecl(); 10366 return true; 10367 } 10368 10369 if (CheckMultiVersionValue(S, NewFD)) { 10370 NewFD->setInvalidDecl(); 10371 return true; 10372 } 10373 10374 // If this is 'default', permit the forward declaration. 10375 if (!OldFD->isMultiVersion() && !OldTA && NewTA->isDefaultVersion()) { 10376 Redeclaration = true; 10377 OldDecl = OldFD; 10378 OldFD->setIsMultiVersion(); 10379 NewFD->setIsMultiVersion(); 10380 return false; 10381 } 10382 10383 if (CheckMultiVersionValue(S, OldFD)) { 10384 S.Diag(NewFD->getLocation(), diag::note_multiversioning_caused_here); 10385 NewFD->setInvalidDecl(); 10386 return true; 10387 } 10388 10389 ParsedTargetAttr OldParsed = OldTA->parse(std::less<std::string>()); 10390 10391 if (OldParsed == NewParsed) { 10392 S.Diag(NewFD->getLocation(), diag::err_multiversion_duplicate); 10393 S.Diag(OldFD->getLocation(), diag::note_previous_declaration); 10394 NewFD->setInvalidDecl(); 10395 return true; 10396 } 10397 10398 for (const auto *FD : OldFD->redecls()) { 10399 const auto *CurTA = FD->getAttr<TargetAttr>(); 10400 // We allow forward declarations before ANY multiversioning attributes, but 10401 // nothing after the fact. 10402 if (PreviousDeclsHaveMultiVersionAttribute(FD) && 10403 (!CurTA || CurTA->isInherited())) { 10404 S.Diag(FD->getLocation(), diag::err_multiversion_required_in_redecl) 10405 << 0; 10406 S.Diag(NewFD->getLocation(), diag::note_multiversioning_caused_here); 10407 NewFD->setInvalidDecl(); 10408 return true; 10409 } 10410 } 10411 10412 OldFD->setIsMultiVersion(); 10413 NewFD->setIsMultiVersion(); 10414 Redeclaration = false; 10415 MergeTypeWithPrevious = false; 10416 OldDecl = nullptr; 10417 Previous.clear(); 10418 return false; 10419 } 10420 10421 /// Check the validity of a new function declaration being added to an existing 10422 /// multiversioned declaration collection. 10423 static bool CheckMultiVersionAdditionalDecl( 10424 Sema &S, FunctionDecl *OldFD, FunctionDecl *NewFD, 10425 MultiVersionKind NewMVType, const TargetAttr *NewTA, 10426 const CPUDispatchAttr *NewCPUDisp, const CPUSpecificAttr *NewCPUSpec, 10427 bool &Redeclaration, NamedDecl *&OldDecl, bool &MergeTypeWithPrevious, 10428 LookupResult &Previous) { 10429 10430 MultiVersionKind OldMVType = OldFD->getMultiVersionKind(); 10431 // Disallow mixing of multiversioning types. 10432 if ((OldMVType == MultiVersionKind::Target && 10433 NewMVType != MultiVersionKind::Target) || 10434 (NewMVType == MultiVersionKind::Target && 10435 OldMVType != MultiVersionKind::Target)) { 10436 S.Diag(NewFD->getLocation(), diag::err_multiversion_types_mixed); 10437 S.Diag(OldFD->getLocation(), diag::note_previous_declaration); 10438 NewFD->setInvalidDecl(); 10439 return true; 10440 } 10441 10442 ParsedTargetAttr NewParsed; 10443 if (NewTA) { 10444 NewParsed = NewTA->parse(); 10445 llvm::sort(NewParsed.Features); 10446 } 10447 10448 bool UseMemberUsingDeclRules = 10449 S.CurContext->isRecord() && !NewFD->getFriendObjectKind(); 10450 10451 // Next, check ALL non-overloads to see if this is a redeclaration of a 10452 // previous member of the MultiVersion set. 10453 for (NamedDecl *ND : Previous) { 10454 FunctionDecl *CurFD = ND->getAsFunction(); 10455 if (!CurFD) 10456 continue; 10457 if (S.IsOverload(NewFD, CurFD, UseMemberUsingDeclRules)) 10458 continue; 10459 10460 if (NewMVType == MultiVersionKind::Target) { 10461 const auto *CurTA = CurFD->getAttr<TargetAttr>(); 10462 if (CurTA->getFeaturesStr() == NewTA->getFeaturesStr()) { 10463 NewFD->setIsMultiVersion(); 10464 Redeclaration = true; 10465 OldDecl = ND; 10466 return false; 10467 } 10468 10469 ParsedTargetAttr CurParsed = CurTA->parse(std::less<std::string>()); 10470 if (CurParsed == NewParsed) { 10471 S.Diag(NewFD->getLocation(), diag::err_multiversion_duplicate); 10472 S.Diag(CurFD->getLocation(), diag::note_previous_declaration); 10473 NewFD->setInvalidDecl(); 10474 return true; 10475 } 10476 } else { 10477 const auto *CurCPUSpec = CurFD->getAttr<CPUSpecificAttr>(); 10478 const auto *CurCPUDisp = CurFD->getAttr<CPUDispatchAttr>(); 10479 // Handle CPUDispatch/CPUSpecific versions. 10480 // Only 1 CPUDispatch function is allowed, this will make it go through 10481 // the redeclaration errors. 10482 if (NewMVType == MultiVersionKind::CPUDispatch && 10483 CurFD->hasAttr<CPUDispatchAttr>()) { 10484 if (CurCPUDisp->cpus_size() == NewCPUDisp->cpus_size() && 10485 std::equal( 10486 CurCPUDisp->cpus_begin(), CurCPUDisp->cpus_end(), 10487 NewCPUDisp->cpus_begin(), 10488 [](const IdentifierInfo *Cur, const IdentifierInfo *New) { 10489 return Cur->getName() == New->getName(); 10490 })) { 10491 NewFD->setIsMultiVersion(); 10492 Redeclaration = true; 10493 OldDecl = ND; 10494 return false; 10495 } 10496 10497 // If the declarations don't match, this is an error condition. 10498 S.Diag(NewFD->getLocation(), diag::err_cpu_dispatch_mismatch); 10499 S.Diag(CurFD->getLocation(), diag::note_previous_declaration); 10500 NewFD->setInvalidDecl(); 10501 return true; 10502 } 10503 if (NewMVType == MultiVersionKind::CPUSpecific && CurCPUSpec) { 10504 10505 if (CurCPUSpec->cpus_size() == NewCPUSpec->cpus_size() && 10506 std::equal( 10507 CurCPUSpec->cpus_begin(), CurCPUSpec->cpus_end(), 10508 NewCPUSpec->cpus_begin(), 10509 [](const IdentifierInfo *Cur, const IdentifierInfo *New) { 10510 return Cur->getName() == New->getName(); 10511 })) { 10512 NewFD->setIsMultiVersion(); 10513 Redeclaration = true; 10514 OldDecl = ND; 10515 return false; 10516 } 10517 10518 // Only 1 version of CPUSpecific is allowed for each CPU. 10519 for (const IdentifierInfo *CurII : CurCPUSpec->cpus()) { 10520 for (const IdentifierInfo *NewII : NewCPUSpec->cpus()) { 10521 if (CurII == NewII) { 10522 S.Diag(NewFD->getLocation(), diag::err_cpu_specific_multiple_defs) 10523 << NewII; 10524 S.Diag(CurFD->getLocation(), diag::note_previous_declaration); 10525 NewFD->setInvalidDecl(); 10526 return true; 10527 } 10528 } 10529 } 10530 } 10531 // If the two decls aren't the same MVType, there is no possible error 10532 // condition. 10533 } 10534 } 10535 10536 // Else, this is simply a non-redecl case. Checking the 'value' is only 10537 // necessary in the Target case, since The CPUSpecific/Dispatch cases are 10538 // handled in the attribute adding step. 10539 if (NewMVType == MultiVersionKind::Target && 10540 CheckMultiVersionValue(S, NewFD)) { 10541 NewFD->setInvalidDecl(); 10542 return true; 10543 } 10544 10545 if (CheckMultiVersionAdditionalRules(S, OldFD, NewFD, 10546 !OldFD->isMultiVersion(), NewMVType)) { 10547 NewFD->setInvalidDecl(); 10548 return true; 10549 } 10550 10551 // Permit forward declarations in the case where these two are compatible. 10552 if (!OldFD->isMultiVersion()) { 10553 OldFD->setIsMultiVersion(); 10554 NewFD->setIsMultiVersion(); 10555 Redeclaration = true; 10556 OldDecl = OldFD; 10557 return false; 10558 } 10559 10560 NewFD->setIsMultiVersion(); 10561 Redeclaration = false; 10562 MergeTypeWithPrevious = false; 10563 OldDecl = nullptr; 10564 Previous.clear(); 10565 return false; 10566 } 10567 10568 10569 /// Check the validity of a mulitversion function declaration. 10570 /// Also sets the multiversion'ness' of the function itself. 10571 /// 10572 /// This sets NewFD->isInvalidDecl() to true if there was an error. 10573 /// 10574 /// Returns true if there was an error, false otherwise. 10575 static bool CheckMultiVersionFunction(Sema &S, FunctionDecl *NewFD, 10576 bool &Redeclaration, NamedDecl *&OldDecl, 10577 bool &MergeTypeWithPrevious, 10578 LookupResult &Previous) { 10579 const auto *NewTA = NewFD->getAttr<TargetAttr>(); 10580 const auto *NewCPUDisp = NewFD->getAttr<CPUDispatchAttr>(); 10581 const auto *NewCPUSpec = NewFD->getAttr<CPUSpecificAttr>(); 10582 10583 // Mixing Multiversioning types is prohibited. 10584 if ((NewTA && NewCPUDisp) || (NewTA && NewCPUSpec) || 10585 (NewCPUDisp && NewCPUSpec)) { 10586 S.Diag(NewFD->getLocation(), diag::err_multiversion_types_mixed); 10587 NewFD->setInvalidDecl(); 10588 return true; 10589 } 10590 10591 MultiVersionKind MVType = NewFD->getMultiVersionKind(); 10592 10593 // Main isn't allowed to become a multiversion function, however it IS 10594 // permitted to have 'main' be marked with the 'target' optimization hint. 10595 if (NewFD->isMain()) { 10596 if ((MVType == MultiVersionKind::Target && NewTA->isDefaultVersion()) || 10597 MVType == MultiVersionKind::CPUDispatch || 10598 MVType == MultiVersionKind::CPUSpecific) { 10599 S.Diag(NewFD->getLocation(), diag::err_multiversion_not_allowed_on_main); 10600 NewFD->setInvalidDecl(); 10601 return true; 10602 } 10603 return false; 10604 } 10605 10606 if (!OldDecl || !OldDecl->getAsFunction() || 10607 OldDecl->getDeclContext()->getRedeclContext() != 10608 NewFD->getDeclContext()->getRedeclContext()) { 10609 // If there's no previous declaration, AND this isn't attempting to cause 10610 // multiversioning, this isn't an error condition. 10611 if (MVType == MultiVersionKind::None) 10612 return false; 10613 return CheckMultiVersionFirstFunction(S, NewFD, MVType, NewTA); 10614 } 10615 10616 FunctionDecl *OldFD = OldDecl->getAsFunction(); 10617 10618 if (!OldFD->isMultiVersion() && MVType == MultiVersionKind::None) 10619 return false; 10620 10621 if (OldFD->isMultiVersion() && MVType == MultiVersionKind::None) { 10622 S.Diag(NewFD->getLocation(), diag::err_multiversion_required_in_redecl) 10623 << (OldFD->getMultiVersionKind() != MultiVersionKind::Target); 10624 NewFD->setInvalidDecl(); 10625 return true; 10626 } 10627 10628 // Handle the target potentially causes multiversioning case. 10629 if (!OldFD->isMultiVersion() && MVType == MultiVersionKind::Target) 10630 return CheckTargetCausesMultiVersioning(S, OldFD, NewFD, NewTA, 10631 Redeclaration, OldDecl, 10632 MergeTypeWithPrevious, Previous); 10633 10634 // At this point, we have a multiversion function decl (in OldFD) AND an 10635 // appropriate attribute in the current function decl. Resolve that these are 10636 // still compatible with previous declarations. 10637 return CheckMultiVersionAdditionalDecl( 10638 S, OldFD, NewFD, MVType, NewTA, NewCPUDisp, NewCPUSpec, Redeclaration, 10639 OldDecl, MergeTypeWithPrevious, Previous); 10640 } 10641 10642 /// Perform semantic checking of a new function declaration. 10643 /// 10644 /// Performs semantic analysis of the new function declaration 10645 /// NewFD. This routine performs all semantic checking that does not 10646 /// require the actual declarator involved in the declaration, and is 10647 /// used both for the declaration of functions as they are parsed 10648 /// (called via ActOnDeclarator) and for the declaration of functions 10649 /// that have been instantiated via C++ template instantiation (called 10650 /// via InstantiateDecl). 10651 /// 10652 /// \param IsMemberSpecialization whether this new function declaration is 10653 /// a member specialization (that replaces any definition provided by the 10654 /// previous declaration). 10655 /// 10656 /// This sets NewFD->isInvalidDecl() to true if there was an error. 10657 /// 10658 /// \returns true if the function declaration is a redeclaration. 10659 bool Sema::CheckFunctionDeclaration(Scope *S, FunctionDecl *NewFD, 10660 LookupResult &Previous, 10661 bool IsMemberSpecialization) { 10662 assert(!NewFD->getReturnType()->isVariablyModifiedType() && 10663 "Variably modified return types are not handled here"); 10664 10665 // Determine whether the type of this function should be merged with 10666 // a previous visible declaration. This never happens for functions in C++, 10667 // and always happens in C if the previous declaration was visible. 10668 bool MergeTypeWithPrevious = !getLangOpts().CPlusPlus && 10669 !Previous.isShadowed(); 10670 10671 bool Redeclaration = false; 10672 NamedDecl *OldDecl = nullptr; 10673 bool MayNeedOverloadableChecks = false; 10674 10675 // Merge or overload the declaration with an existing declaration of 10676 // the same name, if appropriate. 10677 if (!Previous.empty()) { 10678 // Determine whether NewFD is an overload of PrevDecl or 10679 // a declaration that requires merging. If it's an overload, 10680 // there's no more work to do here; we'll just add the new 10681 // function to the scope. 10682 if (!AllowOverloadingOfFunction(Previous, Context, NewFD)) { 10683 NamedDecl *Candidate = Previous.getRepresentativeDecl(); 10684 if (shouldLinkPossiblyHiddenDecl(Candidate, NewFD)) { 10685 Redeclaration = true; 10686 OldDecl = Candidate; 10687 } 10688 } else { 10689 MayNeedOverloadableChecks = true; 10690 switch (CheckOverload(S, NewFD, Previous, OldDecl, 10691 /*NewIsUsingDecl*/ false)) { 10692 case Ovl_Match: 10693 Redeclaration = true; 10694 break; 10695 10696 case Ovl_NonFunction: 10697 Redeclaration = true; 10698 break; 10699 10700 case Ovl_Overload: 10701 Redeclaration = false; 10702 break; 10703 } 10704 } 10705 } 10706 10707 // Check for a previous extern "C" declaration with this name. 10708 if (!Redeclaration && 10709 checkForConflictWithNonVisibleExternC(*this, NewFD, Previous)) { 10710 if (!Previous.empty()) { 10711 // This is an extern "C" declaration with the same name as a previous 10712 // declaration, and thus redeclares that entity... 10713 Redeclaration = true; 10714 OldDecl = Previous.getFoundDecl(); 10715 MergeTypeWithPrevious = false; 10716 10717 // ... except in the presence of __attribute__((overloadable)). 10718 if (OldDecl->hasAttr<OverloadableAttr>() || 10719 NewFD->hasAttr<OverloadableAttr>()) { 10720 if (IsOverload(NewFD, cast<FunctionDecl>(OldDecl), false)) { 10721 MayNeedOverloadableChecks = true; 10722 Redeclaration = false; 10723 OldDecl = nullptr; 10724 } 10725 } 10726 } 10727 } 10728 10729 if (CheckMultiVersionFunction(*this, NewFD, Redeclaration, OldDecl, 10730 MergeTypeWithPrevious, Previous)) 10731 return Redeclaration; 10732 10733 // PPC MMA non-pointer types are not allowed as function return types. 10734 if (Context.getTargetInfo().getTriple().isPPC64() && 10735 CheckPPCMMAType(NewFD->getReturnType(), NewFD->getLocation())) { 10736 NewFD->setInvalidDecl(); 10737 } 10738 10739 // C++11 [dcl.constexpr]p8: 10740 // A constexpr specifier for a non-static member function that is not 10741 // a constructor declares that member function to be const. 10742 // 10743 // This needs to be delayed until we know whether this is an out-of-line 10744 // definition of a static member function. 10745 // 10746 // This rule is not present in C++1y, so we produce a backwards 10747 // compatibility warning whenever it happens in C++11. 10748 CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(NewFD); 10749 if (!getLangOpts().CPlusPlus14 && MD && MD->isConstexpr() && 10750 !MD->isStatic() && !isa<CXXConstructorDecl>(MD) && 10751 !isa<CXXDestructorDecl>(MD) && !MD->getMethodQualifiers().hasConst()) { 10752 CXXMethodDecl *OldMD = nullptr; 10753 if (OldDecl) 10754 OldMD = dyn_cast_or_null<CXXMethodDecl>(OldDecl->getAsFunction()); 10755 if (!OldMD || !OldMD->isStatic()) { 10756 const FunctionProtoType *FPT = 10757 MD->getType()->castAs<FunctionProtoType>(); 10758 FunctionProtoType::ExtProtoInfo EPI = FPT->getExtProtoInfo(); 10759 EPI.TypeQuals.addConst(); 10760 MD->setType(Context.getFunctionType(FPT->getReturnType(), 10761 FPT->getParamTypes(), EPI)); 10762 10763 // Warn that we did this, if we're not performing template instantiation. 10764 // In that case, we'll have warned already when the template was defined. 10765 if (!inTemplateInstantiation()) { 10766 SourceLocation AddConstLoc; 10767 if (FunctionTypeLoc FTL = MD->getTypeSourceInfo()->getTypeLoc() 10768 .IgnoreParens().getAs<FunctionTypeLoc>()) 10769 AddConstLoc = getLocForEndOfToken(FTL.getRParenLoc()); 10770 10771 Diag(MD->getLocation(), diag::warn_cxx14_compat_constexpr_not_const) 10772 << FixItHint::CreateInsertion(AddConstLoc, " const"); 10773 } 10774 } 10775 } 10776 10777 if (Redeclaration) { 10778 // NewFD and OldDecl represent declarations that need to be 10779 // merged. 10780 if (MergeFunctionDecl(NewFD, OldDecl, S, MergeTypeWithPrevious)) { 10781 NewFD->setInvalidDecl(); 10782 return Redeclaration; 10783 } 10784 10785 Previous.clear(); 10786 Previous.addDecl(OldDecl); 10787 10788 if (FunctionTemplateDecl *OldTemplateDecl = 10789 dyn_cast<FunctionTemplateDecl>(OldDecl)) { 10790 auto *OldFD = OldTemplateDecl->getTemplatedDecl(); 10791 FunctionTemplateDecl *NewTemplateDecl 10792 = NewFD->getDescribedFunctionTemplate(); 10793 assert(NewTemplateDecl && "Template/non-template mismatch"); 10794 10795 // The call to MergeFunctionDecl above may have created some state in 10796 // NewTemplateDecl that needs to be merged with OldTemplateDecl before we 10797 // can add it as a redeclaration. 10798 NewTemplateDecl->mergePrevDecl(OldTemplateDecl); 10799 10800 NewFD->setPreviousDeclaration(OldFD); 10801 if (NewFD->isCXXClassMember()) { 10802 NewFD->setAccess(OldTemplateDecl->getAccess()); 10803 NewTemplateDecl->setAccess(OldTemplateDecl->getAccess()); 10804 } 10805 10806 // If this is an explicit specialization of a member that is a function 10807 // template, mark it as a member specialization. 10808 if (IsMemberSpecialization && 10809 NewTemplateDecl->getInstantiatedFromMemberTemplate()) { 10810 NewTemplateDecl->setMemberSpecialization(); 10811 assert(OldTemplateDecl->isMemberSpecialization()); 10812 // Explicit specializations of a member template do not inherit deleted 10813 // status from the parent member template that they are specializing. 10814 if (OldFD->isDeleted()) { 10815 // FIXME: This assert will not hold in the presence of modules. 10816 assert(OldFD->getCanonicalDecl() == OldFD); 10817 // FIXME: We need an update record for this AST mutation. 10818 OldFD->setDeletedAsWritten(false); 10819 } 10820 } 10821 10822 } else { 10823 if (shouldLinkDependentDeclWithPrevious(NewFD, OldDecl)) { 10824 auto *OldFD = cast<FunctionDecl>(OldDecl); 10825 // This needs to happen first so that 'inline' propagates. 10826 NewFD->setPreviousDeclaration(OldFD); 10827 if (NewFD->isCXXClassMember()) 10828 NewFD->setAccess(OldFD->getAccess()); 10829 } 10830 } 10831 } else if (!getLangOpts().CPlusPlus && MayNeedOverloadableChecks && 10832 !NewFD->getAttr<OverloadableAttr>()) { 10833 assert((Previous.empty() || 10834 llvm::any_of(Previous, 10835 [](const NamedDecl *ND) { 10836 return ND->hasAttr<OverloadableAttr>(); 10837 })) && 10838 "Non-redecls shouldn't happen without overloadable present"); 10839 10840 auto OtherUnmarkedIter = llvm::find_if(Previous, [](const NamedDecl *ND) { 10841 const auto *FD = dyn_cast<FunctionDecl>(ND); 10842 return FD && !FD->hasAttr<OverloadableAttr>(); 10843 }); 10844 10845 if (OtherUnmarkedIter != Previous.end()) { 10846 Diag(NewFD->getLocation(), 10847 diag::err_attribute_overloadable_multiple_unmarked_overloads); 10848 Diag((*OtherUnmarkedIter)->getLocation(), 10849 diag::note_attribute_overloadable_prev_overload) 10850 << false; 10851 10852 NewFD->addAttr(OverloadableAttr::CreateImplicit(Context)); 10853 } 10854 } 10855 10856 if (LangOpts.OpenMP) 10857 ActOnFinishedFunctionDefinitionInOpenMPAssumeScope(NewFD); 10858 10859 // Semantic checking for this function declaration (in isolation). 10860 10861 if (getLangOpts().CPlusPlus) { 10862 // C++-specific checks. 10863 if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(NewFD)) { 10864 CheckConstructor(Constructor); 10865 } else if (CXXDestructorDecl *Destructor = 10866 dyn_cast<CXXDestructorDecl>(NewFD)) { 10867 CXXRecordDecl *Record = Destructor->getParent(); 10868 QualType ClassType = Context.getTypeDeclType(Record); 10869 10870 // FIXME: Shouldn't we be able to perform this check even when the class 10871 // type is dependent? Both gcc and edg can handle that. 10872 if (!ClassType->isDependentType()) { 10873 DeclarationName Name 10874 = Context.DeclarationNames.getCXXDestructorName( 10875 Context.getCanonicalType(ClassType)); 10876 if (NewFD->getDeclName() != Name) { 10877 Diag(NewFD->getLocation(), diag::err_destructor_name); 10878 NewFD->setInvalidDecl(); 10879 return Redeclaration; 10880 } 10881 } 10882 } else if (auto *Guide = dyn_cast<CXXDeductionGuideDecl>(NewFD)) { 10883 if (auto *TD = Guide->getDescribedFunctionTemplate()) 10884 CheckDeductionGuideTemplate(TD); 10885 10886 // A deduction guide is not on the list of entities that can be 10887 // explicitly specialized. 10888 if (Guide->getTemplateSpecializationKind() == TSK_ExplicitSpecialization) 10889 Diag(Guide->getBeginLoc(), diag::err_deduction_guide_specialized) 10890 << /*explicit specialization*/ 1; 10891 } 10892 10893 // Find any virtual functions that this function overrides. 10894 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(NewFD)) { 10895 if (!Method->isFunctionTemplateSpecialization() && 10896 !Method->getDescribedFunctionTemplate() && 10897 Method->isCanonicalDecl()) { 10898 AddOverriddenMethods(Method->getParent(), Method); 10899 } 10900 if (Method->isVirtual() && NewFD->getTrailingRequiresClause()) 10901 // C++2a [class.virtual]p6 10902 // A virtual method shall not have a requires-clause. 10903 Diag(NewFD->getTrailingRequiresClause()->getBeginLoc(), 10904 diag::err_constrained_virtual_method); 10905 10906 if (Method->isStatic()) 10907 checkThisInStaticMemberFunctionType(Method); 10908 } 10909 10910 if (CXXConversionDecl *Conversion = dyn_cast<CXXConversionDecl>(NewFD)) 10911 ActOnConversionDeclarator(Conversion); 10912 10913 // Extra checking for C++ overloaded operators (C++ [over.oper]). 10914 if (NewFD->isOverloadedOperator() && 10915 CheckOverloadedOperatorDeclaration(NewFD)) { 10916 NewFD->setInvalidDecl(); 10917 return Redeclaration; 10918 } 10919 10920 // Extra checking for C++0x literal operators (C++0x [over.literal]). 10921 if (NewFD->getLiteralIdentifier() && 10922 CheckLiteralOperatorDeclaration(NewFD)) { 10923 NewFD->setInvalidDecl(); 10924 return Redeclaration; 10925 } 10926 10927 // In C++, check default arguments now that we have merged decls. Unless 10928 // the lexical context is the class, because in this case this is done 10929 // during delayed parsing anyway. 10930 if (!CurContext->isRecord()) 10931 CheckCXXDefaultArguments(NewFD); 10932 10933 // If this function declares a builtin function, check the type of this 10934 // declaration against the expected type for the builtin. 10935 if (unsigned BuiltinID = NewFD->getBuiltinID()) { 10936 ASTContext::GetBuiltinTypeError Error; 10937 LookupNecessaryTypesForBuiltin(S, BuiltinID); 10938 QualType T = Context.GetBuiltinType(BuiltinID, Error); 10939 // If the type of the builtin differs only in its exception 10940 // specification, that's OK. 10941 // FIXME: If the types do differ in this way, it would be better to 10942 // retain the 'noexcept' form of the type. 10943 if (!T.isNull() && 10944 !Context.hasSameFunctionTypeIgnoringExceptionSpec(T, 10945 NewFD->getType())) 10946 // The type of this function differs from the type of the builtin, 10947 // so forget about the builtin entirely. 10948 Context.BuiltinInfo.forgetBuiltin(BuiltinID, Context.Idents); 10949 } 10950 10951 // If this function is declared as being extern "C", then check to see if 10952 // the function returns a UDT (class, struct, or union type) that is not C 10953 // compatible, and if it does, warn the user. 10954 // But, issue any diagnostic on the first declaration only. 10955 if (Previous.empty() && NewFD->isExternC()) { 10956 QualType R = NewFD->getReturnType(); 10957 if (R->isIncompleteType() && !R->isVoidType()) 10958 Diag(NewFD->getLocation(), diag::warn_return_value_udt_incomplete) 10959 << NewFD << R; 10960 else if (!R.isPODType(Context) && !R->isVoidType() && 10961 !R->isObjCObjectPointerType()) 10962 Diag(NewFD->getLocation(), diag::warn_return_value_udt) << NewFD << R; 10963 } 10964 10965 // C++1z [dcl.fct]p6: 10966 // [...] whether the function has a non-throwing exception-specification 10967 // [is] part of the function type 10968 // 10969 // This results in an ABI break between C++14 and C++17 for functions whose 10970 // declared type includes an exception-specification in a parameter or 10971 // return type. (Exception specifications on the function itself are OK in 10972 // most cases, and exception specifications are not permitted in most other 10973 // contexts where they could make it into a mangling.) 10974 if (!getLangOpts().CPlusPlus17 && !NewFD->getPrimaryTemplate()) { 10975 auto HasNoexcept = [&](QualType T) -> bool { 10976 // Strip off declarator chunks that could be between us and a function 10977 // type. We don't need to look far, exception specifications are very 10978 // restricted prior to C++17. 10979 if (auto *RT = T->getAs<ReferenceType>()) 10980 T = RT->getPointeeType(); 10981 else if (T->isAnyPointerType()) 10982 T = T->getPointeeType(); 10983 else if (auto *MPT = T->getAs<MemberPointerType>()) 10984 T = MPT->getPointeeType(); 10985 if (auto *FPT = T->getAs<FunctionProtoType>()) 10986 if (FPT->isNothrow()) 10987 return true; 10988 return false; 10989 }; 10990 10991 auto *FPT = NewFD->getType()->castAs<FunctionProtoType>(); 10992 bool AnyNoexcept = HasNoexcept(FPT->getReturnType()); 10993 for (QualType T : FPT->param_types()) 10994 AnyNoexcept |= HasNoexcept(T); 10995 if (AnyNoexcept) 10996 Diag(NewFD->getLocation(), 10997 diag::warn_cxx17_compat_exception_spec_in_signature) 10998 << NewFD; 10999 } 11000 11001 if (!Redeclaration && LangOpts.CUDA) 11002 checkCUDATargetOverload(NewFD, Previous); 11003 } 11004 return Redeclaration; 11005 } 11006 11007 void Sema::CheckMain(FunctionDecl* FD, const DeclSpec& DS) { 11008 // C++11 [basic.start.main]p3: 11009 // A program that [...] declares main to be inline, static or 11010 // constexpr is ill-formed. 11011 // C11 6.7.4p4: In a hosted environment, no function specifier(s) shall 11012 // appear in a declaration of main. 11013 // static main is not an error under C99, but we should warn about it. 11014 // We accept _Noreturn main as an extension. 11015 if (FD->getStorageClass() == SC_Static) 11016 Diag(DS.getStorageClassSpecLoc(), getLangOpts().CPlusPlus 11017 ? diag::err_static_main : diag::warn_static_main) 11018 << FixItHint::CreateRemoval(DS.getStorageClassSpecLoc()); 11019 if (FD->isInlineSpecified()) 11020 Diag(DS.getInlineSpecLoc(), diag::err_inline_main) 11021 << FixItHint::CreateRemoval(DS.getInlineSpecLoc()); 11022 if (DS.isNoreturnSpecified()) { 11023 SourceLocation NoreturnLoc = DS.getNoreturnSpecLoc(); 11024 SourceRange NoreturnRange(NoreturnLoc, getLocForEndOfToken(NoreturnLoc)); 11025 Diag(NoreturnLoc, diag::ext_noreturn_main); 11026 Diag(NoreturnLoc, diag::note_main_remove_noreturn) 11027 << FixItHint::CreateRemoval(NoreturnRange); 11028 } 11029 if (FD->isConstexpr()) { 11030 Diag(DS.getConstexprSpecLoc(), diag::err_constexpr_main) 11031 << FD->isConsteval() 11032 << FixItHint::CreateRemoval(DS.getConstexprSpecLoc()); 11033 FD->setConstexprKind(ConstexprSpecKind::Unspecified); 11034 } 11035 11036 if (getLangOpts().OpenCL) { 11037 Diag(FD->getLocation(), diag::err_opencl_no_main) 11038 << FD->hasAttr<OpenCLKernelAttr>(); 11039 FD->setInvalidDecl(); 11040 return; 11041 } 11042 11043 QualType T = FD->getType(); 11044 assert(T->isFunctionType() && "function decl is not of function type"); 11045 const FunctionType* FT = T->castAs<FunctionType>(); 11046 11047 // Set default calling convention for main() 11048 if (FT->getCallConv() != CC_C) { 11049 FT = Context.adjustFunctionType(FT, FT->getExtInfo().withCallingConv(CC_C)); 11050 FD->setType(QualType(FT, 0)); 11051 T = Context.getCanonicalType(FD->getType()); 11052 } 11053 11054 if (getLangOpts().GNUMode && !getLangOpts().CPlusPlus) { 11055 // In C with GNU extensions we allow main() to have non-integer return 11056 // type, but we should warn about the extension, and we disable the 11057 // implicit-return-zero rule. 11058 11059 // GCC in C mode accepts qualified 'int'. 11060 if (Context.hasSameUnqualifiedType(FT->getReturnType(), Context.IntTy)) 11061 FD->setHasImplicitReturnZero(true); 11062 else { 11063 Diag(FD->getTypeSpecStartLoc(), diag::ext_main_returns_nonint); 11064 SourceRange RTRange = FD->getReturnTypeSourceRange(); 11065 if (RTRange.isValid()) 11066 Diag(RTRange.getBegin(), diag::note_main_change_return_type) 11067 << FixItHint::CreateReplacement(RTRange, "int"); 11068 } 11069 } else { 11070 // In C and C++, main magically returns 0 if you fall off the end; 11071 // set the flag which tells us that. 11072 // This is C++ [basic.start.main]p5 and C99 5.1.2.2.3. 11073 11074 // All the standards say that main() should return 'int'. 11075 if (Context.hasSameType(FT->getReturnType(), Context.IntTy)) 11076 FD->setHasImplicitReturnZero(true); 11077 else { 11078 // Otherwise, this is just a flat-out error. 11079 SourceRange RTRange = FD->getReturnTypeSourceRange(); 11080 Diag(FD->getTypeSpecStartLoc(), diag::err_main_returns_nonint) 11081 << (RTRange.isValid() ? FixItHint::CreateReplacement(RTRange, "int") 11082 : FixItHint()); 11083 FD->setInvalidDecl(true); 11084 } 11085 } 11086 11087 // Treat protoless main() as nullary. 11088 if (isa<FunctionNoProtoType>(FT)) return; 11089 11090 const FunctionProtoType* FTP = cast<const FunctionProtoType>(FT); 11091 unsigned nparams = FTP->getNumParams(); 11092 assert(FD->getNumParams() == nparams); 11093 11094 bool HasExtraParameters = (nparams > 3); 11095 11096 if (FTP->isVariadic()) { 11097 Diag(FD->getLocation(), diag::ext_variadic_main); 11098 // FIXME: if we had information about the location of the ellipsis, we 11099 // could add a FixIt hint to remove it as a parameter. 11100 } 11101 11102 // Darwin passes an undocumented fourth argument of type char**. If 11103 // other platforms start sprouting these, the logic below will start 11104 // getting shifty. 11105 if (nparams == 4 && Context.getTargetInfo().getTriple().isOSDarwin()) 11106 HasExtraParameters = false; 11107 11108 if (HasExtraParameters) { 11109 Diag(FD->getLocation(), diag::err_main_surplus_args) << nparams; 11110 FD->setInvalidDecl(true); 11111 nparams = 3; 11112 } 11113 11114 // FIXME: a lot of the following diagnostics would be improved 11115 // if we had some location information about types. 11116 11117 QualType CharPP = 11118 Context.getPointerType(Context.getPointerType(Context.CharTy)); 11119 QualType Expected[] = { Context.IntTy, CharPP, CharPP, CharPP }; 11120 11121 for (unsigned i = 0; i < nparams; ++i) { 11122 QualType AT = FTP->getParamType(i); 11123 11124 bool mismatch = true; 11125 11126 if (Context.hasSameUnqualifiedType(AT, Expected[i])) 11127 mismatch = false; 11128 else if (Expected[i] == CharPP) { 11129 // As an extension, the following forms are okay: 11130 // char const ** 11131 // char const * const * 11132 // char * const * 11133 11134 QualifierCollector qs; 11135 const PointerType* PT; 11136 if ((PT = qs.strip(AT)->getAs<PointerType>()) && 11137 (PT = qs.strip(PT->getPointeeType())->getAs<PointerType>()) && 11138 Context.hasSameType(QualType(qs.strip(PT->getPointeeType()), 0), 11139 Context.CharTy)) { 11140 qs.removeConst(); 11141 mismatch = !qs.empty(); 11142 } 11143 } 11144 11145 if (mismatch) { 11146 Diag(FD->getLocation(), diag::err_main_arg_wrong) << i << Expected[i]; 11147 // TODO: suggest replacing given type with expected type 11148 FD->setInvalidDecl(true); 11149 } 11150 } 11151 11152 if (nparams == 1 && !FD->isInvalidDecl()) { 11153 Diag(FD->getLocation(), diag::warn_main_one_arg); 11154 } 11155 11156 if (!FD->isInvalidDecl() && FD->getDescribedFunctionTemplate()) { 11157 Diag(FD->getLocation(), diag::err_mainlike_template_decl) << FD; 11158 FD->setInvalidDecl(); 11159 } 11160 } 11161 11162 void Sema::CheckMSVCRTEntryPoint(FunctionDecl *FD) { 11163 QualType T = FD->getType(); 11164 assert(T->isFunctionType() && "function decl is not of function type"); 11165 const FunctionType *FT = T->castAs<FunctionType>(); 11166 11167 // Set an implicit return of 'zero' if the function can return some integral, 11168 // enumeration, pointer or nullptr type. 11169 if (FT->getReturnType()->isIntegralOrEnumerationType() || 11170 FT->getReturnType()->isAnyPointerType() || 11171 FT->getReturnType()->isNullPtrType()) 11172 // DllMain is exempt because a return value of zero means it failed. 11173 if (FD->getName() != "DllMain") 11174 FD->setHasImplicitReturnZero(true); 11175 11176 if (!FD->isInvalidDecl() && FD->getDescribedFunctionTemplate()) { 11177 Diag(FD->getLocation(), diag::err_mainlike_template_decl) << FD; 11178 FD->setInvalidDecl(); 11179 } 11180 } 11181 11182 bool Sema::CheckForConstantInitializer(Expr *Init, QualType DclT) { 11183 // FIXME: Need strict checking. In C89, we need to check for 11184 // any assignment, increment, decrement, function-calls, or 11185 // commas outside of a sizeof. In C99, it's the same list, 11186 // except that the aforementioned are allowed in unevaluated 11187 // expressions. Everything else falls under the 11188 // "may accept other forms of constant expressions" exception. 11189 // 11190 // Regular C++ code will not end up here (exceptions: language extensions, 11191 // OpenCL C++ etc), so the constant expression rules there don't matter. 11192 if (Init->isValueDependent()) { 11193 assert(Init->containsErrors() && 11194 "Dependent code should only occur in error-recovery path."); 11195 return true; 11196 } 11197 const Expr *Culprit; 11198 if (Init->isConstantInitializer(Context, false, &Culprit)) 11199 return false; 11200 Diag(Culprit->getExprLoc(), diag::err_init_element_not_constant) 11201 << Culprit->getSourceRange(); 11202 return true; 11203 } 11204 11205 namespace { 11206 // Visits an initialization expression to see if OrigDecl is evaluated in 11207 // its own initialization and throws a warning if it does. 11208 class SelfReferenceChecker 11209 : public EvaluatedExprVisitor<SelfReferenceChecker> { 11210 Sema &S; 11211 Decl *OrigDecl; 11212 bool isRecordType; 11213 bool isPODType; 11214 bool isReferenceType; 11215 11216 bool isInitList; 11217 llvm::SmallVector<unsigned, 4> InitFieldIndex; 11218 11219 public: 11220 typedef EvaluatedExprVisitor<SelfReferenceChecker> Inherited; 11221 11222 SelfReferenceChecker(Sema &S, Decl *OrigDecl) : Inherited(S.Context), 11223 S(S), OrigDecl(OrigDecl) { 11224 isPODType = false; 11225 isRecordType = false; 11226 isReferenceType = false; 11227 isInitList = false; 11228 if (ValueDecl *VD = dyn_cast<ValueDecl>(OrigDecl)) { 11229 isPODType = VD->getType().isPODType(S.Context); 11230 isRecordType = VD->getType()->isRecordType(); 11231 isReferenceType = VD->getType()->isReferenceType(); 11232 } 11233 } 11234 11235 // For most expressions, just call the visitor. For initializer lists, 11236 // track the index of the field being initialized since fields are 11237 // initialized in order allowing use of previously initialized fields. 11238 void CheckExpr(Expr *E) { 11239 InitListExpr *InitList = dyn_cast<InitListExpr>(E); 11240 if (!InitList) { 11241 Visit(E); 11242 return; 11243 } 11244 11245 // Track and increment the index here. 11246 isInitList = true; 11247 InitFieldIndex.push_back(0); 11248 for (auto Child : InitList->children()) { 11249 CheckExpr(cast<Expr>(Child)); 11250 ++InitFieldIndex.back(); 11251 } 11252 InitFieldIndex.pop_back(); 11253 } 11254 11255 // Returns true if MemberExpr is checked and no further checking is needed. 11256 // Returns false if additional checking is required. 11257 bool CheckInitListMemberExpr(MemberExpr *E, bool CheckReference) { 11258 llvm::SmallVector<FieldDecl*, 4> Fields; 11259 Expr *Base = E; 11260 bool ReferenceField = false; 11261 11262 // Get the field members used. 11263 while (MemberExpr *ME = dyn_cast<MemberExpr>(Base)) { 11264 FieldDecl *FD = dyn_cast<FieldDecl>(ME->getMemberDecl()); 11265 if (!FD) 11266 return false; 11267 Fields.push_back(FD); 11268 if (FD->getType()->isReferenceType()) 11269 ReferenceField = true; 11270 Base = ME->getBase()->IgnoreParenImpCasts(); 11271 } 11272 11273 // Keep checking only if the base Decl is the same. 11274 DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Base); 11275 if (!DRE || DRE->getDecl() != OrigDecl) 11276 return false; 11277 11278 // A reference field can be bound to an unininitialized field. 11279 if (CheckReference && !ReferenceField) 11280 return true; 11281 11282 // Convert FieldDecls to their index number. 11283 llvm::SmallVector<unsigned, 4> UsedFieldIndex; 11284 for (const FieldDecl *I : llvm::reverse(Fields)) 11285 UsedFieldIndex.push_back(I->getFieldIndex()); 11286 11287 // See if a warning is needed by checking the first difference in index 11288 // numbers. If field being used has index less than the field being 11289 // initialized, then the use is safe. 11290 for (auto UsedIter = UsedFieldIndex.begin(), 11291 UsedEnd = UsedFieldIndex.end(), 11292 OrigIter = InitFieldIndex.begin(), 11293 OrigEnd = InitFieldIndex.end(); 11294 UsedIter != UsedEnd && OrigIter != OrigEnd; ++UsedIter, ++OrigIter) { 11295 if (*UsedIter < *OrigIter) 11296 return true; 11297 if (*UsedIter > *OrigIter) 11298 break; 11299 } 11300 11301 // TODO: Add a different warning which will print the field names. 11302 HandleDeclRefExpr(DRE); 11303 return true; 11304 } 11305 11306 // For most expressions, the cast is directly above the DeclRefExpr. 11307 // For conditional operators, the cast can be outside the conditional 11308 // operator if both expressions are DeclRefExpr's. 11309 void HandleValue(Expr *E) { 11310 E = E->IgnoreParens(); 11311 if (DeclRefExpr* DRE = dyn_cast<DeclRefExpr>(E)) { 11312 HandleDeclRefExpr(DRE); 11313 return; 11314 } 11315 11316 if (ConditionalOperator *CO = dyn_cast<ConditionalOperator>(E)) { 11317 Visit(CO->getCond()); 11318 HandleValue(CO->getTrueExpr()); 11319 HandleValue(CO->getFalseExpr()); 11320 return; 11321 } 11322 11323 if (BinaryConditionalOperator *BCO = 11324 dyn_cast<BinaryConditionalOperator>(E)) { 11325 Visit(BCO->getCond()); 11326 HandleValue(BCO->getFalseExpr()); 11327 return; 11328 } 11329 11330 if (OpaqueValueExpr *OVE = dyn_cast<OpaqueValueExpr>(E)) { 11331 HandleValue(OVE->getSourceExpr()); 11332 return; 11333 } 11334 11335 if (BinaryOperator *BO = dyn_cast<BinaryOperator>(E)) { 11336 if (BO->getOpcode() == BO_Comma) { 11337 Visit(BO->getLHS()); 11338 HandleValue(BO->getRHS()); 11339 return; 11340 } 11341 } 11342 11343 if (isa<MemberExpr>(E)) { 11344 if (isInitList) { 11345 if (CheckInitListMemberExpr(cast<MemberExpr>(E), 11346 false /*CheckReference*/)) 11347 return; 11348 } 11349 11350 Expr *Base = E->IgnoreParenImpCasts(); 11351 while (MemberExpr *ME = dyn_cast<MemberExpr>(Base)) { 11352 // Check for static member variables and don't warn on them. 11353 if (!isa<FieldDecl>(ME->getMemberDecl())) 11354 return; 11355 Base = ME->getBase()->IgnoreParenImpCasts(); 11356 } 11357 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Base)) 11358 HandleDeclRefExpr(DRE); 11359 return; 11360 } 11361 11362 Visit(E); 11363 } 11364 11365 // Reference types not handled in HandleValue are handled here since all 11366 // uses of references are bad, not just r-value uses. 11367 void VisitDeclRefExpr(DeclRefExpr *E) { 11368 if (isReferenceType) 11369 HandleDeclRefExpr(E); 11370 } 11371 11372 void VisitImplicitCastExpr(ImplicitCastExpr *E) { 11373 if (E->getCastKind() == CK_LValueToRValue) { 11374 HandleValue(E->getSubExpr()); 11375 return; 11376 } 11377 11378 Inherited::VisitImplicitCastExpr(E); 11379 } 11380 11381 void VisitMemberExpr(MemberExpr *E) { 11382 if (isInitList) { 11383 if (CheckInitListMemberExpr(E, true /*CheckReference*/)) 11384 return; 11385 } 11386 11387 // Don't warn on arrays since they can be treated as pointers. 11388 if (E->getType()->canDecayToPointerType()) return; 11389 11390 // Warn when a non-static method call is followed by non-static member 11391 // field accesses, which is followed by a DeclRefExpr. 11392 CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(E->getMemberDecl()); 11393 bool Warn = (MD && !MD->isStatic()); 11394 Expr *Base = E->getBase()->IgnoreParenImpCasts(); 11395 while (MemberExpr *ME = dyn_cast<MemberExpr>(Base)) { 11396 if (!isa<FieldDecl>(ME->getMemberDecl())) 11397 Warn = false; 11398 Base = ME->getBase()->IgnoreParenImpCasts(); 11399 } 11400 11401 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Base)) { 11402 if (Warn) 11403 HandleDeclRefExpr(DRE); 11404 return; 11405 } 11406 11407 // The base of a MemberExpr is not a MemberExpr or a DeclRefExpr. 11408 // Visit that expression. 11409 Visit(Base); 11410 } 11411 11412 void VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E) { 11413 Expr *Callee = E->getCallee(); 11414 11415 if (isa<UnresolvedLookupExpr>(Callee)) 11416 return Inherited::VisitCXXOperatorCallExpr(E); 11417 11418 Visit(Callee); 11419 for (auto Arg: E->arguments()) 11420 HandleValue(Arg->IgnoreParenImpCasts()); 11421 } 11422 11423 void VisitUnaryOperator(UnaryOperator *E) { 11424 // For POD record types, addresses of its own members are well-defined. 11425 if (E->getOpcode() == UO_AddrOf && isRecordType && 11426 isa<MemberExpr>(E->getSubExpr()->IgnoreParens())) { 11427 if (!isPODType) 11428 HandleValue(E->getSubExpr()); 11429 return; 11430 } 11431 11432 if (E->isIncrementDecrementOp()) { 11433 HandleValue(E->getSubExpr()); 11434 return; 11435 } 11436 11437 Inherited::VisitUnaryOperator(E); 11438 } 11439 11440 void VisitObjCMessageExpr(ObjCMessageExpr *E) {} 11441 11442 void VisitCXXConstructExpr(CXXConstructExpr *E) { 11443 if (E->getConstructor()->isCopyConstructor()) { 11444 Expr *ArgExpr = E->getArg(0); 11445 if (InitListExpr *ILE = dyn_cast<InitListExpr>(ArgExpr)) 11446 if (ILE->getNumInits() == 1) 11447 ArgExpr = ILE->getInit(0); 11448 if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(ArgExpr)) 11449 if (ICE->getCastKind() == CK_NoOp) 11450 ArgExpr = ICE->getSubExpr(); 11451 HandleValue(ArgExpr); 11452 return; 11453 } 11454 Inherited::VisitCXXConstructExpr(E); 11455 } 11456 11457 void VisitCallExpr(CallExpr *E) { 11458 // Treat std::move as a use. 11459 if (E->isCallToStdMove()) { 11460 HandleValue(E->getArg(0)); 11461 return; 11462 } 11463 11464 Inherited::VisitCallExpr(E); 11465 } 11466 11467 void VisitBinaryOperator(BinaryOperator *E) { 11468 if (E->isCompoundAssignmentOp()) { 11469 HandleValue(E->getLHS()); 11470 Visit(E->getRHS()); 11471 return; 11472 } 11473 11474 Inherited::VisitBinaryOperator(E); 11475 } 11476 11477 // A custom visitor for BinaryConditionalOperator is needed because the 11478 // regular visitor would check the condition and true expression separately 11479 // but both point to the same place giving duplicate diagnostics. 11480 void VisitBinaryConditionalOperator(BinaryConditionalOperator *E) { 11481 Visit(E->getCond()); 11482 Visit(E->getFalseExpr()); 11483 } 11484 11485 void HandleDeclRefExpr(DeclRefExpr *DRE) { 11486 Decl* ReferenceDecl = DRE->getDecl(); 11487 if (OrigDecl != ReferenceDecl) return; 11488 unsigned diag; 11489 if (isReferenceType) { 11490 diag = diag::warn_uninit_self_reference_in_reference_init; 11491 } else if (cast<VarDecl>(OrigDecl)->isStaticLocal()) { 11492 diag = diag::warn_static_self_reference_in_init; 11493 } else if (isa<TranslationUnitDecl>(OrigDecl->getDeclContext()) || 11494 isa<NamespaceDecl>(OrigDecl->getDeclContext()) || 11495 DRE->getDecl()->getType()->isRecordType()) { 11496 diag = diag::warn_uninit_self_reference_in_init; 11497 } else { 11498 // Local variables will be handled by the CFG analysis. 11499 return; 11500 } 11501 11502 S.DiagRuntimeBehavior(DRE->getBeginLoc(), DRE, 11503 S.PDiag(diag) 11504 << DRE->getDecl() << OrigDecl->getLocation() 11505 << DRE->getSourceRange()); 11506 } 11507 }; 11508 11509 /// CheckSelfReference - Warns if OrigDecl is used in expression E. 11510 static void CheckSelfReference(Sema &S, Decl* OrigDecl, Expr *E, 11511 bool DirectInit) { 11512 // Parameters arguments are occassionially constructed with itself, 11513 // for instance, in recursive functions. Skip them. 11514 if (isa<ParmVarDecl>(OrigDecl)) 11515 return; 11516 11517 E = E->IgnoreParens(); 11518 11519 // Skip checking T a = a where T is not a record or reference type. 11520 // Doing so is a way to silence uninitialized warnings. 11521 if (!DirectInit && !cast<VarDecl>(OrigDecl)->getType()->isRecordType()) 11522 if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E)) 11523 if (ICE->getCastKind() == CK_LValueToRValue) 11524 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(ICE->getSubExpr())) 11525 if (DRE->getDecl() == OrigDecl) 11526 return; 11527 11528 SelfReferenceChecker(S, OrigDecl).CheckExpr(E); 11529 } 11530 } // end anonymous namespace 11531 11532 namespace { 11533 // Simple wrapper to add the name of a variable or (if no variable is 11534 // available) a DeclarationName into a diagnostic. 11535 struct VarDeclOrName { 11536 VarDecl *VDecl; 11537 DeclarationName Name; 11538 11539 friend const Sema::SemaDiagnosticBuilder & 11540 operator<<(const Sema::SemaDiagnosticBuilder &Diag, VarDeclOrName VN) { 11541 return VN.VDecl ? Diag << VN.VDecl : Diag << VN.Name; 11542 } 11543 }; 11544 } // end anonymous namespace 11545 11546 QualType Sema::deduceVarTypeFromInitializer(VarDecl *VDecl, 11547 DeclarationName Name, QualType Type, 11548 TypeSourceInfo *TSI, 11549 SourceRange Range, bool DirectInit, 11550 Expr *Init) { 11551 bool IsInitCapture = !VDecl; 11552 assert((!VDecl || !VDecl->isInitCapture()) && 11553 "init captures are expected to be deduced prior to initialization"); 11554 11555 VarDeclOrName VN{VDecl, Name}; 11556 11557 DeducedType *Deduced = Type->getContainedDeducedType(); 11558 assert(Deduced && "deduceVarTypeFromInitializer for non-deduced type"); 11559 11560 // C++11 [dcl.spec.auto]p3 11561 if (!Init) { 11562 assert(VDecl && "no init for init capture deduction?"); 11563 11564 // Except for class argument deduction, and then for an initializing 11565 // declaration only, i.e. no static at class scope or extern. 11566 if (!isa<DeducedTemplateSpecializationType>(Deduced) || 11567 VDecl->hasExternalStorage() || 11568 VDecl->isStaticDataMember()) { 11569 Diag(VDecl->getLocation(), diag::err_auto_var_requires_init) 11570 << VDecl->getDeclName() << Type; 11571 return QualType(); 11572 } 11573 } 11574 11575 ArrayRef<Expr*> DeduceInits; 11576 if (Init) 11577 DeduceInits = Init; 11578 11579 if (DirectInit) { 11580 if (auto *PL = dyn_cast_or_null<ParenListExpr>(Init)) 11581 DeduceInits = PL->exprs(); 11582 } 11583 11584 if (isa<DeducedTemplateSpecializationType>(Deduced)) { 11585 assert(VDecl && "non-auto type for init capture deduction?"); 11586 InitializedEntity Entity = InitializedEntity::InitializeVariable(VDecl); 11587 InitializationKind Kind = InitializationKind::CreateForInit( 11588 VDecl->getLocation(), DirectInit, Init); 11589 // FIXME: Initialization should not be taking a mutable list of inits. 11590 SmallVector<Expr*, 8> InitsCopy(DeduceInits.begin(), DeduceInits.end()); 11591 return DeduceTemplateSpecializationFromInitializer(TSI, Entity, Kind, 11592 InitsCopy); 11593 } 11594 11595 if (DirectInit) { 11596 if (auto *IL = dyn_cast<InitListExpr>(Init)) 11597 DeduceInits = IL->inits(); 11598 } 11599 11600 // Deduction only works if we have exactly one source expression. 11601 if (DeduceInits.empty()) { 11602 // It isn't possible to write this directly, but it is possible to 11603 // end up in this situation with "auto x(some_pack...);" 11604 Diag(Init->getBeginLoc(), IsInitCapture 11605 ? diag::err_init_capture_no_expression 11606 : diag::err_auto_var_init_no_expression) 11607 << VN << Type << Range; 11608 return QualType(); 11609 } 11610 11611 if (DeduceInits.size() > 1) { 11612 Diag(DeduceInits[1]->getBeginLoc(), 11613 IsInitCapture ? diag::err_init_capture_multiple_expressions 11614 : diag::err_auto_var_init_multiple_expressions) 11615 << VN << Type << Range; 11616 return QualType(); 11617 } 11618 11619 Expr *DeduceInit = DeduceInits[0]; 11620 if (DirectInit && isa<InitListExpr>(DeduceInit)) { 11621 Diag(Init->getBeginLoc(), IsInitCapture 11622 ? diag::err_init_capture_paren_braces 11623 : diag::err_auto_var_init_paren_braces) 11624 << isa<InitListExpr>(Init) << VN << Type << Range; 11625 return QualType(); 11626 } 11627 11628 // Expressions default to 'id' when we're in a debugger. 11629 bool DefaultedAnyToId = false; 11630 if (getLangOpts().DebuggerCastResultToId && 11631 Init->getType() == Context.UnknownAnyTy && !IsInitCapture) { 11632 ExprResult Result = forceUnknownAnyToType(Init, Context.getObjCIdType()); 11633 if (Result.isInvalid()) { 11634 return QualType(); 11635 } 11636 Init = Result.get(); 11637 DefaultedAnyToId = true; 11638 } 11639 11640 // C++ [dcl.decomp]p1: 11641 // If the assignment-expression [...] has array type A and no ref-qualifier 11642 // is present, e has type cv A 11643 if (VDecl && isa<DecompositionDecl>(VDecl) && 11644 Context.hasSameUnqualifiedType(Type, Context.getAutoDeductType()) && 11645 DeduceInit->getType()->isConstantArrayType()) 11646 return Context.getQualifiedType(DeduceInit->getType(), 11647 Type.getQualifiers()); 11648 11649 QualType DeducedType; 11650 if (DeduceAutoType(TSI, DeduceInit, DeducedType) == DAR_Failed) { 11651 if (!IsInitCapture) 11652 DiagnoseAutoDeductionFailure(VDecl, DeduceInit); 11653 else if (isa<InitListExpr>(Init)) 11654 Diag(Range.getBegin(), 11655 diag::err_init_capture_deduction_failure_from_init_list) 11656 << VN 11657 << (DeduceInit->getType().isNull() ? TSI->getType() 11658 : DeduceInit->getType()) 11659 << DeduceInit->getSourceRange(); 11660 else 11661 Diag(Range.getBegin(), diag::err_init_capture_deduction_failure) 11662 << VN << TSI->getType() 11663 << (DeduceInit->getType().isNull() ? TSI->getType() 11664 : DeduceInit->getType()) 11665 << DeduceInit->getSourceRange(); 11666 } 11667 11668 // Warn if we deduced 'id'. 'auto' usually implies type-safety, but using 11669 // 'id' instead of a specific object type prevents most of our usual 11670 // checks. 11671 // We only want to warn outside of template instantiations, though: 11672 // inside a template, the 'id' could have come from a parameter. 11673 if (!inTemplateInstantiation() && !DefaultedAnyToId && !IsInitCapture && 11674 !DeducedType.isNull() && DeducedType->isObjCIdType()) { 11675 SourceLocation Loc = TSI->getTypeLoc().getBeginLoc(); 11676 Diag(Loc, diag::warn_auto_var_is_id) << VN << Range; 11677 } 11678 11679 return DeducedType; 11680 } 11681 11682 bool Sema::DeduceVariableDeclarationType(VarDecl *VDecl, bool DirectInit, 11683 Expr *Init) { 11684 assert(!Init || !Init->containsErrors()); 11685 QualType DeducedType = deduceVarTypeFromInitializer( 11686 VDecl, VDecl->getDeclName(), VDecl->getType(), VDecl->getTypeSourceInfo(), 11687 VDecl->getSourceRange(), DirectInit, Init); 11688 if (DeducedType.isNull()) { 11689 VDecl->setInvalidDecl(); 11690 return true; 11691 } 11692 11693 VDecl->setType(DeducedType); 11694 assert(VDecl->isLinkageValid()); 11695 11696 // In ARC, infer lifetime. 11697 if (getLangOpts().ObjCAutoRefCount && inferObjCARCLifetime(VDecl)) 11698 VDecl->setInvalidDecl(); 11699 11700 if (getLangOpts().OpenCL) 11701 deduceOpenCLAddressSpace(VDecl); 11702 11703 // If this is a redeclaration, check that the type we just deduced matches 11704 // the previously declared type. 11705 if (VarDecl *Old = VDecl->getPreviousDecl()) { 11706 // We never need to merge the type, because we cannot form an incomplete 11707 // array of auto, nor deduce such a type. 11708 MergeVarDeclTypes(VDecl, Old, /*MergeTypeWithPrevious*/ false); 11709 } 11710 11711 // Check the deduced type is valid for a variable declaration. 11712 CheckVariableDeclarationType(VDecl); 11713 return VDecl->isInvalidDecl(); 11714 } 11715 11716 void Sema::checkNonTrivialCUnionInInitializer(const Expr *Init, 11717 SourceLocation Loc) { 11718 if (auto *EWC = dyn_cast<ExprWithCleanups>(Init)) 11719 Init = EWC->getSubExpr(); 11720 11721 if (auto *CE = dyn_cast<ConstantExpr>(Init)) 11722 Init = CE->getSubExpr(); 11723 11724 QualType InitType = Init->getType(); 11725 assert((InitType.hasNonTrivialToPrimitiveDefaultInitializeCUnion() || 11726 InitType.hasNonTrivialToPrimitiveCopyCUnion()) && 11727 "shouldn't be called if type doesn't have a non-trivial C struct"); 11728 if (auto *ILE = dyn_cast<InitListExpr>(Init)) { 11729 for (auto I : ILE->inits()) { 11730 if (!I->getType().hasNonTrivialToPrimitiveDefaultInitializeCUnion() && 11731 !I->getType().hasNonTrivialToPrimitiveCopyCUnion()) 11732 continue; 11733 SourceLocation SL = I->getExprLoc(); 11734 checkNonTrivialCUnionInInitializer(I, SL.isValid() ? SL : Loc); 11735 } 11736 return; 11737 } 11738 11739 if (isa<ImplicitValueInitExpr>(Init)) { 11740 if (InitType.hasNonTrivialToPrimitiveDefaultInitializeCUnion()) 11741 checkNonTrivialCUnion(InitType, Loc, NTCUC_DefaultInitializedObject, 11742 NTCUK_Init); 11743 } else { 11744 // Assume all other explicit initializers involving copying some existing 11745 // object. 11746 // TODO: ignore any explicit initializers where we can guarantee 11747 // copy-elision. 11748 if (InitType.hasNonTrivialToPrimitiveCopyCUnion()) 11749 checkNonTrivialCUnion(InitType, Loc, NTCUC_CopyInit, NTCUK_Copy); 11750 } 11751 } 11752 11753 namespace { 11754 11755 bool shouldIgnoreForRecordTriviality(const FieldDecl *FD) { 11756 // Ignore unavailable fields. A field can be marked as unavailable explicitly 11757 // in the source code or implicitly by the compiler if it is in a union 11758 // defined in a system header and has non-trivial ObjC ownership 11759 // qualifications. We don't want those fields to participate in determining 11760 // whether the containing union is non-trivial. 11761 return FD->hasAttr<UnavailableAttr>(); 11762 } 11763 11764 struct DiagNonTrivalCUnionDefaultInitializeVisitor 11765 : DefaultInitializedTypeVisitor<DiagNonTrivalCUnionDefaultInitializeVisitor, 11766 void> { 11767 using Super = 11768 DefaultInitializedTypeVisitor<DiagNonTrivalCUnionDefaultInitializeVisitor, 11769 void>; 11770 11771 DiagNonTrivalCUnionDefaultInitializeVisitor( 11772 QualType OrigTy, SourceLocation OrigLoc, 11773 Sema::NonTrivialCUnionContext UseContext, Sema &S) 11774 : OrigTy(OrigTy), OrigLoc(OrigLoc), UseContext(UseContext), S(S) {} 11775 11776 void visitWithKind(QualType::PrimitiveDefaultInitializeKind PDIK, QualType QT, 11777 const FieldDecl *FD, bool InNonTrivialUnion) { 11778 if (const auto *AT = S.Context.getAsArrayType(QT)) 11779 return this->asDerived().visit(S.Context.getBaseElementType(AT), FD, 11780 InNonTrivialUnion); 11781 return Super::visitWithKind(PDIK, QT, FD, InNonTrivialUnion); 11782 } 11783 11784 void visitARCStrong(QualType QT, const FieldDecl *FD, 11785 bool InNonTrivialUnion) { 11786 if (InNonTrivialUnion) 11787 S.Diag(FD->getLocation(), diag::note_non_trivial_c_union) 11788 << 1 << 0 << QT << FD->getName(); 11789 } 11790 11791 void visitARCWeak(QualType QT, const FieldDecl *FD, bool InNonTrivialUnion) { 11792 if (InNonTrivialUnion) 11793 S.Diag(FD->getLocation(), diag::note_non_trivial_c_union) 11794 << 1 << 0 << QT << FD->getName(); 11795 } 11796 11797 void visitStruct(QualType QT, const FieldDecl *FD, bool InNonTrivialUnion) { 11798 const RecordDecl *RD = QT->castAs<RecordType>()->getDecl(); 11799 if (RD->isUnion()) { 11800 if (OrigLoc.isValid()) { 11801 bool IsUnion = false; 11802 if (auto *OrigRD = OrigTy->getAsRecordDecl()) 11803 IsUnion = OrigRD->isUnion(); 11804 S.Diag(OrigLoc, diag::err_non_trivial_c_union_in_invalid_context) 11805 << 0 << OrigTy << IsUnion << UseContext; 11806 // Reset OrigLoc so that this diagnostic is emitted only once. 11807 OrigLoc = SourceLocation(); 11808 } 11809 InNonTrivialUnion = true; 11810 } 11811 11812 if (InNonTrivialUnion) 11813 S.Diag(RD->getLocation(), diag::note_non_trivial_c_union) 11814 << 0 << 0 << QT.getUnqualifiedType() << ""; 11815 11816 for (const FieldDecl *FD : RD->fields()) 11817 if (!shouldIgnoreForRecordTriviality(FD)) 11818 asDerived().visit(FD->getType(), FD, InNonTrivialUnion); 11819 } 11820 11821 void visitTrivial(QualType QT, const FieldDecl *FD, bool InNonTrivialUnion) {} 11822 11823 // The non-trivial C union type or the struct/union type that contains a 11824 // non-trivial C union. 11825 QualType OrigTy; 11826 SourceLocation OrigLoc; 11827 Sema::NonTrivialCUnionContext UseContext; 11828 Sema &S; 11829 }; 11830 11831 struct DiagNonTrivalCUnionDestructedTypeVisitor 11832 : DestructedTypeVisitor<DiagNonTrivalCUnionDestructedTypeVisitor, void> { 11833 using Super = 11834 DestructedTypeVisitor<DiagNonTrivalCUnionDestructedTypeVisitor, void>; 11835 11836 DiagNonTrivalCUnionDestructedTypeVisitor( 11837 QualType OrigTy, SourceLocation OrigLoc, 11838 Sema::NonTrivialCUnionContext UseContext, Sema &S) 11839 : OrigTy(OrigTy), OrigLoc(OrigLoc), UseContext(UseContext), S(S) {} 11840 11841 void visitWithKind(QualType::DestructionKind DK, QualType QT, 11842 const FieldDecl *FD, bool InNonTrivialUnion) { 11843 if (const auto *AT = S.Context.getAsArrayType(QT)) 11844 return this->asDerived().visit(S.Context.getBaseElementType(AT), FD, 11845 InNonTrivialUnion); 11846 return Super::visitWithKind(DK, QT, FD, InNonTrivialUnion); 11847 } 11848 11849 void visitARCStrong(QualType QT, const FieldDecl *FD, 11850 bool InNonTrivialUnion) { 11851 if (InNonTrivialUnion) 11852 S.Diag(FD->getLocation(), diag::note_non_trivial_c_union) 11853 << 1 << 1 << QT << FD->getName(); 11854 } 11855 11856 void visitARCWeak(QualType QT, const FieldDecl *FD, bool InNonTrivialUnion) { 11857 if (InNonTrivialUnion) 11858 S.Diag(FD->getLocation(), diag::note_non_trivial_c_union) 11859 << 1 << 1 << QT << FD->getName(); 11860 } 11861 11862 void visitStruct(QualType QT, const FieldDecl *FD, bool InNonTrivialUnion) { 11863 const RecordDecl *RD = QT->castAs<RecordType>()->getDecl(); 11864 if (RD->isUnion()) { 11865 if (OrigLoc.isValid()) { 11866 bool IsUnion = false; 11867 if (auto *OrigRD = OrigTy->getAsRecordDecl()) 11868 IsUnion = OrigRD->isUnion(); 11869 S.Diag(OrigLoc, diag::err_non_trivial_c_union_in_invalid_context) 11870 << 1 << OrigTy << IsUnion << UseContext; 11871 // Reset OrigLoc so that this diagnostic is emitted only once. 11872 OrigLoc = SourceLocation(); 11873 } 11874 InNonTrivialUnion = true; 11875 } 11876 11877 if (InNonTrivialUnion) 11878 S.Diag(RD->getLocation(), diag::note_non_trivial_c_union) 11879 << 0 << 1 << QT.getUnqualifiedType() << ""; 11880 11881 for (const FieldDecl *FD : RD->fields()) 11882 if (!shouldIgnoreForRecordTriviality(FD)) 11883 asDerived().visit(FD->getType(), FD, InNonTrivialUnion); 11884 } 11885 11886 void visitTrivial(QualType QT, const FieldDecl *FD, bool InNonTrivialUnion) {} 11887 void visitCXXDestructor(QualType QT, const FieldDecl *FD, 11888 bool InNonTrivialUnion) {} 11889 11890 // The non-trivial C union type or the struct/union type that contains a 11891 // non-trivial C union. 11892 QualType OrigTy; 11893 SourceLocation OrigLoc; 11894 Sema::NonTrivialCUnionContext UseContext; 11895 Sema &S; 11896 }; 11897 11898 struct DiagNonTrivalCUnionCopyVisitor 11899 : CopiedTypeVisitor<DiagNonTrivalCUnionCopyVisitor, false, void> { 11900 using Super = CopiedTypeVisitor<DiagNonTrivalCUnionCopyVisitor, false, void>; 11901 11902 DiagNonTrivalCUnionCopyVisitor(QualType OrigTy, SourceLocation OrigLoc, 11903 Sema::NonTrivialCUnionContext UseContext, 11904 Sema &S) 11905 : OrigTy(OrigTy), OrigLoc(OrigLoc), UseContext(UseContext), S(S) {} 11906 11907 void visitWithKind(QualType::PrimitiveCopyKind PCK, QualType QT, 11908 const FieldDecl *FD, bool InNonTrivialUnion) { 11909 if (const auto *AT = S.Context.getAsArrayType(QT)) 11910 return this->asDerived().visit(S.Context.getBaseElementType(AT), FD, 11911 InNonTrivialUnion); 11912 return Super::visitWithKind(PCK, QT, FD, InNonTrivialUnion); 11913 } 11914 11915 void visitARCStrong(QualType QT, const FieldDecl *FD, 11916 bool InNonTrivialUnion) { 11917 if (InNonTrivialUnion) 11918 S.Diag(FD->getLocation(), diag::note_non_trivial_c_union) 11919 << 1 << 2 << QT << FD->getName(); 11920 } 11921 11922 void visitARCWeak(QualType QT, const FieldDecl *FD, bool InNonTrivialUnion) { 11923 if (InNonTrivialUnion) 11924 S.Diag(FD->getLocation(), diag::note_non_trivial_c_union) 11925 << 1 << 2 << QT << FD->getName(); 11926 } 11927 11928 void visitStruct(QualType QT, const FieldDecl *FD, bool InNonTrivialUnion) { 11929 const RecordDecl *RD = QT->castAs<RecordType>()->getDecl(); 11930 if (RD->isUnion()) { 11931 if (OrigLoc.isValid()) { 11932 bool IsUnion = false; 11933 if (auto *OrigRD = OrigTy->getAsRecordDecl()) 11934 IsUnion = OrigRD->isUnion(); 11935 S.Diag(OrigLoc, diag::err_non_trivial_c_union_in_invalid_context) 11936 << 2 << OrigTy << IsUnion << UseContext; 11937 // Reset OrigLoc so that this diagnostic is emitted only once. 11938 OrigLoc = SourceLocation(); 11939 } 11940 InNonTrivialUnion = true; 11941 } 11942 11943 if (InNonTrivialUnion) 11944 S.Diag(RD->getLocation(), diag::note_non_trivial_c_union) 11945 << 0 << 2 << QT.getUnqualifiedType() << ""; 11946 11947 for (const FieldDecl *FD : RD->fields()) 11948 if (!shouldIgnoreForRecordTriviality(FD)) 11949 asDerived().visit(FD->getType(), FD, InNonTrivialUnion); 11950 } 11951 11952 void preVisit(QualType::PrimitiveCopyKind PCK, QualType QT, 11953 const FieldDecl *FD, bool InNonTrivialUnion) {} 11954 void visitTrivial(QualType QT, const FieldDecl *FD, bool InNonTrivialUnion) {} 11955 void visitVolatileTrivial(QualType QT, const FieldDecl *FD, 11956 bool InNonTrivialUnion) {} 11957 11958 // The non-trivial C union type or the struct/union type that contains a 11959 // non-trivial C union. 11960 QualType OrigTy; 11961 SourceLocation OrigLoc; 11962 Sema::NonTrivialCUnionContext UseContext; 11963 Sema &S; 11964 }; 11965 11966 } // namespace 11967 11968 void Sema::checkNonTrivialCUnion(QualType QT, SourceLocation Loc, 11969 NonTrivialCUnionContext UseContext, 11970 unsigned NonTrivialKind) { 11971 assert((QT.hasNonTrivialToPrimitiveDefaultInitializeCUnion() || 11972 QT.hasNonTrivialToPrimitiveDestructCUnion() || 11973 QT.hasNonTrivialToPrimitiveCopyCUnion()) && 11974 "shouldn't be called if type doesn't have a non-trivial C union"); 11975 11976 if ((NonTrivialKind & NTCUK_Init) && 11977 QT.hasNonTrivialToPrimitiveDefaultInitializeCUnion()) 11978 DiagNonTrivalCUnionDefaultInitializeVisitor(QT, Loc, UseContext, *this) 11979 .visit(QT, nullptr, false); 11980 if ((NonTrivialKind & NTCUK_Destruct) && 11981 QT.hasNonTrivialToPrimitiveDestructCUnion()) 11982 DiagNonTrivalCUnionDestructedTypeVisitor(QT, Loc, UseContext, *this) 11983 .visit(QT, nullptr, false); 11984 if ((NonTrivialKind & NTCUK_Copy) && QT.hasNonTrivialToPrimitiveCopyCUnion()) 11985 DiagNonTrivalCUnionCopyVisitor(QT, Loc, UseContext, *this) 11986 .visit(QT, nullptr, false); 11987 } 11988 11989 /// AddInitializerToDecl - Adds the initializer Init to the 11990 /// declaration dcl. If DirectInit is true, this is C++ direct 11991 /// initialization rather than copy initialization. 11992 void Sema::AddInitializerToDecl(Decl *RealDecl, Expr *Init, bool DirectInit) { 11993 // If there is no declaration, there was an error parsing it. Just ignore 11994 // the initializer. 11995 if (!RealDecl || RealDecl->isInvalidDecl()) { 11996 CorrectDelayedTyposInExpr(Init, dyn_cast_or_null<VarDecl>(RealDecl)); 11997 return; 11998 } 11999 12000 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(RealDecl)) { 12001 // Pure-specifiers are handled in ActOnPureSpecifier. 12002 Diag(Method->getLocation(), diag::err_member_function_initialization) 12003 << Method->getDeclName() << Init->getSourceRange(); 12004 Method->setInvalidDecl(); 12005 return; 12006 } 12007 12008 VarDecl *VDecl = dyn_cast<VarDecl>(RealDecl); 12009 if (!VDecl) { 12010 assert(!isa<FieldDecl>(RealDecl) && "field init shouldn't get here"); 12011 Diag(RealDecl->getLocation(), diag::err_illegal_initializer); 12012 RealDecl->setInvalidDecl(); 12013 return; 12014 } 12015 12016 // C++11 [decl.spec.auto]p6. Deduce the type which 'auto' stands in for. 12017 if (VDecl->getType()->isUndeducedType()) { 12018 // Attempt typo correction early so that the type of the init expression can 12019 // be deduced based on the chosen correction if the original init contains a 12020 // TypoExpr. 12021 ExprResult Res = CorrectDelayedTyposInExpr(Init, VDecl); 12022 if (!Res.isUsable()) { 12023 // There are unresolved typos in Init, just drop them. 12024 // FIXME: improve the recovery strategy to preserve the Init. 12025 RealDecl->setInvalidDecl(); 12026 return; 12027 } 12028 if (Res.get()->containsErrors()) { 12029 // Invalidate the decl as we don't know the type for recovery-expr yet. 12030 RealDecl->setInvalidDecl(); 12031 VDecl->setInit(Res.get()); 12032 return; 12033 } 12034 Init = Res.get(); 12035 12036 if (DeduceVariableDeclarationType(VDecl, DirectInit, Init)) 12037 return; 12038 } 12039 12040 // dllimport cannot be used on variable definitions. 12041 if (VDecl->hasAttr<DLLImportAttr>() && !VDecl->isStaticDataMember()) { 12042 Diag(VDecl->getLocation(), diag::err_attribute_dllimport_data_definition); 12043 VDecl->setInvalidDecl(); 12044 return; 12045 } 12046 12047 if (VDecl->isLocalVarDecl() && VDecl->hasExternalStorage()) { 12048 // C99 6.7.8p5. C++ has no such restriction, but that is a defect. 12049 Diag(VDecl->getLocation(), diag::err_block_extern_cant_init); 12050 VDecl->setInvalidDecl(); 12051 return; 12052 } 12053 12054 if (!VDecl->getType()->isDependentType()) { 12055 // A definition must end up with a complete type, which means it must be 12056 // complete with the restriction that an array type might be completed by 12057 // the initializer; note that later code assumes this restriction. 12058 QualType BaseDeclType = VDecl->getType(); 12059 if (const ArrayType *Array = Context.getAsIncompleteArrayType(BaseDeclType)) 12060 BaseDeclType = Array->getElementType(); 12061 if (RequireCompleteType(VDecl->getLocation(), BaseDeclType, 12062 diag::err_typecheck_decl_incomplete_type)) { 12063 RealDecl->setInvalidDecl(); 12064 return; 12065 } 12066 12067 // The variable can not have an abstract class type. 12068 if (RequireNonAbstractType(VDecl->getLocation(), VDecl->getType(), 12069 diag::err_abstract_type_in_decl, 12070 AbstractVariableType)) 12071 VDecl->setInvalidDecl(); 12072 } 12073 12074 // If adding the initializer will turn this declaration into a definition, 12075 // and we already have a definition for this variable, diagnose or otherwise 12076 // handle the situation. 12077 VarDecl *Def; 12078 if ((Def = VDecl->getDefinition()) && Def != VDecl && 12079 (!VDecl->isStaticDataMember() || VDecl->isOutOfLine()) && 12080 !VDecl->isThisDeclarationADemotedDefinition() && 12081 checkVarDeclRedefinition(Def, VDecl)) 12082 return; 12083 12084 if (getLangOpts().CPlusPlus) { 12085 // C++ [class.static.data]p4 12086 // If a static data member is of const integral or const 12087 // enumeration type, its declaration in the class definition can 12088 // specify a constant-initializer which shall be an integral 12089 // constant expression (5.19). In that case, the member can appear 12090 // in integral constant expressions. The member shall still be 12091 // defined in a namespace scope if it is used in the program and the 12092 // namespace scope definition shall not contain an initializer. 12093 // 12094 // We already performed a redefinition check above, but for static 12095 // data members we also need to check whether there was an in-class 12096 // declaration with an initializer. 12097 if (VDecl->isStaticDataMember() && VDecl->getCanonicalDecl()->hasInit()) { 12098 Diag(Init->getExprLoc(), diag::err_static_data_member_reinitialization) 12099 << VDecl->getDeclName(); 12100 Diag(VDecl->getCanonicalDecl()->getInit()->getExprLoc(), 12101 diag::note_previous_initializer) 12102 << 0; 12103 return; 12104 } 12105 12106 if (VDecl->hasLocalStorage()) 12107 setFunctionHasBranchProtectedScope(); 12108 12109 if (DiagnoseUnexpandedParameterPack(Init, UPPC_Initializer)) { 12110 VDecl->setInvalidDecl(); 12111 return; 12112 } 12113 } 12114 12115 // OpenCL 1.1 6.5.2: "Variables allocated in the __local address space inside 12116 // a kernel function cannot be initialized." 12117 if (VDecl->getType().getAddressSpace() == LangAS::opencl_local) { 12118 Diag(VDecl->getLocation(), diag::err_local_cant_init); 12119 VDecl->setInvalidDecl(); 12120 return; 12121 } 12122 12123 // The LoaderUninitialized attribute acts as a definition (of undef). 12124 if (VDecl->hasAttr<LoaderUninitializedAttr>()) { 12125 Diag(VDecl->getLocation(), diag::err_loader_uninitialized_cant_init); 12126 VDecl->setInvalidDecl(); 12127 return; 12128 } 12129 12130 // Get the decls type and save a reference for later, since 12131 // CheckInitializerTypes may change it. 12132 QualType DclT = VDecl->getType(), SavT = DclT; 12133 12134 // Expressions default to 'id' when we're in a debugger 12135 // and we are assigning it to a variable of Objective-C pointer type. 12136 if (getLangOpts().DebuggerCastResultToId && DclT->isObjCObjectPointerType() && 12137 Init->getType() == Context.UnknownAnyTy) { 12138 ExprResult Result = forceUnknownAnyToType(Init, Context.getObjCIdType()); 12139 if (Result.isInvalid()) { 12140 VDecl->setInvalidDecl(); 12141 return; 12142 } 12143 Init = Result.get(); 12144 } 12145 12146 // Perform the initialization. 12147 ParenListExpr *CXXDirectInit = dyn_cast<ParenListExpr>(Init); 12148 if (!VDecl->isInvalidDecl()) { 12149 InitializedEntity Entity = InitializedEntity::InitializeVariable(VDecl); 12150 InitializationKind Kind = InitializationKind::CreateForInit( 12151 VDecl->getLocation(), DirectInit, Init); 12152 12153 MultiExprArg Args = Init; 12154 if (CXXDirectInit) 12155 Args = MultiExprArg(CXXDirectInit->getExprs(), 12156 CXXDirectInit->getNumExprs()); 12157 12158 // Try to correct any TypoExprs in the initialization arguments. 12159 for (size_t Idx = 0; Idx < Args.size(); ++Idx) { 12160 ExprResult Res = CorrectDelayedTyposInExpr( 12161 Args[Idx], VDecl, /*RecoverUncorrectedTypos=*/true, 12162 [this, Entity, Kind](Expr *E) { 12163 InitializationSequence Init(*this, Entity, Kind, MultiExprArg(E)); 12164 return Init.Failed() ? ExprError() : E; 12165 }); 12166 if (Res.isInvalid()) { 12167 VDecl->setInvalidDecl(); 12168 } else if (Res.get() != Args[Idx]) { 12169 Args[Idx] = Res.get(); 12170 } 12171 } 12172 if (VDecl->isInvalidDecl()) 12173 return; 12174 12175 InitializationSequence InitSeq(*this, Entity, Kind, Args, 12176 /*TopLevelOfInitList=*/false, 12177 /*TreatUnavailableAsInvalid=*/false); 12178 ExprResult Result = InitSeq.Perform(*this, Entity, Kind, Args, &DclT); 12179 if (Result.isInvalid()) { 12180 // If the provied initializer fails to initialize the var decl, 12181 // we attach a recovery expr for better recovery. 12182 auto RecoveryExpr = 12183 CreateRecoveryExpr(Init->getBeginLoc(), Init->getEndLoc(), Args); 12184 if (RecoveryExpr.get()) 12185 VDecl->setInit(RecoveryExpr.get()); 12186 return; 12187 } 12188 12189 Init = Result.getAs<Expr>(); 12190 } 12191 12192 // Check for self-references within variable initializers. 12193 // Variables declared within a function/method body (except for references) 12194 // are handled by a dataflow analysis. 12195 // This is undefined behavior in C++, but valid in C. 12196 if (getLangOpts().CPlusPlus) { 12197 if (!VDecl->hasLocalStorage() || VDecl->getType()->isRecordType() || 12198 VDecl->getType()->isReferenceType()) { 12199 CheckSelfReference(*this, RealDecl, Init, DirectInit); 12200 } 12201 } 12202 12203 // If the type changed, it means we had an incomplete type that was 12204 // completed by the initializer. For example: 12205 // int ary[] = { 1, 3, 5 }; 12206 // "ary" transitions from an IncompleteArrayType to a ConstantArrayType. 12207 if (!VDecl->isInvalidDecl() && (DclT != SavT)) 12208 VDecl->setType(DclT); 12209 12210 if (!VDecl->isInvalidDecl()) { 12211 checkUnsafeAssigns(VDecl->getLocation(), VDecl->getType(), Init); 12212 12213 if (VDecl->hasAttr<BlocksAttr>()) 12214 checkRetainCycles(VDecl, Init); 12215 12216 // It is safe to assign a weak reference into a strong variable. 12217 // Although this code can still have problems: 12218 // id x = self.weakProp; 12219 // id y = self.weakProp; 12220 // we do not warn to warn spuriously when 'x' and 'y' are on separate 12221 // paths through the function. This should be revisited if 12222 // -Wrepeated-use-of-weak is made flow-sensitive. 12223 if (FunctionScopeInfo *FSI = getCurFunction()) 12224 if ((VDecl->getType().getObjCLifetime() == Qualifiers::OCL_Strong || 12225 VDecl->getType().isNonWeakInMRRWithObjCWeak(Context)) && 12226 !Diags.isIgnored(diag::warn_arc_repeated_use_of_weak, 12227 Init->getBeginLoc())) 12228 FSI->markSafeWeakUse(Init); 12229 } 12230 12231 // The initialization is usually a full-expression. 12232 // 12233 // FIXME: If this is a braced initialization of an aggregate, it is not 12234 // an expression, and each individual field initializer is a separate 12235 // full-expression. For instance, in: 12236 // 12237 // struct Temp { ~Temp(); }; 12238 // struct S { S(Temp); }; 12239 // struct T { S a, b; } t = { Temp(), Temp() } 12240 // 12241 // we should destroy the first Temp before constructing the second. 12242 ExprResult Result = 12243 ActOnFinishFullExpr(Init, VDecl->getLocation(), 12244 /*DiscardedValue*/ false, VDecl->isConstexpr()); 12245 if (Result.isInvalid()) { 12246 VDecl->setInvalidDecl(); 12247 return; 12248 } 12249 Init = Result.get(); 12250 12251 // Attach the initializer to the decl. 12252 VDecl->setInit(Init); 12253 12254 if (VDecl->isLocalVarDecl()) { 12255 // Don't check the initializer if the declaration is malformed. 12256 if (VDecl->isInvalidDecl()) { 12257 // do nothing 12258 12259 // OpenCL v1.2 s6.5.3: __constant locals must be constant-initialized. 12260 // This is true even in C++ for OpenCL. 12261 } else if (VDecl->getType().getAddressSpace() == LangAS::opencl_constant) { 12262 CheckForConstantInitializer(Init, DclT); 12263 12264 // Otherwise, C++ does not restrict the initializer. 12265 } else if (getLangOpts().CPlusPlus) { 12266 // do nothing 12267 12268 // C99 6.7.8p4: All the expressions in an initializer for an object that has 12269 // static storage duration shall be constant expressions or string literals. 12270 } else if (VDecl->getStorageClass() == SC_Static) { 12271 CheckForConstantInitializer(Init, DclT); 12272 12273 // C89 is stricter than C99 for aggregate initializers. 12274 // C89 6.5.7p3: All the expressions [...] in an initializer list 12275 // for an object that has aggregate or union type shall be 12276 // constant expressions. 12277 } else if (!getLangOpts().C99 && VDecl->getType()->isAggregateType() && 12278 isa<InitListExpr>(Init)) { 12279 const Expr *Culprit; 12280 if (!Init->isConstantInitializer(Context, false, &Culprit)) { 12281 Diag(Culprit->getExprLoc(), 12282 diag::ext_aggregate_init_not_constant) 12283 << Culprit->getSourceRange(); 12284 } 12285 } 12286 12287 if (auto *E = dyn_cast<ExprWithCleanups>(Init)) 12288 if (auto *BE = dyn_cast<BlockExpr>(E->getSubExpr()->IgnoreParens())) 12289 if (VDecl->hasLocalStorage()) 12290 BE->getBlockDecl()->setCanAvoidCopyToHeap(); 12291 } else if (VDecl->isStaticDataMember() && !VDecl->isInline() && 12292 VDecl->getLexicalDeclContext()->isRecord()) { 12293 // This is an in-class initialization for a static data member, e.g., 12294 // 12295 // struct S { 12296 // static const int value = 17; 12297 // }; 12298 12299 // C++ [class.mem]p4: 12300 // A member-declarator can contain a constant-initializer only 12301 // if it declares a static member (9.4) of const integral or 12302 // const enumeration type, see 9.4.2. 12303 // 12304 // C++11 [class.static.data]p3: 12305 // If a non-volatile non-inline const static data member is of integral 12306 // or enumeration type, its declaration in the class definition can 12307 // specify a brace-or-equal-initializer in which every initializer-clause 12308 // that is an assignment-expression is a constant expression. A static 12309 // data member of literal type can be declared in the class definition 12310 // with the constexpr specifier; if so, its declaration shall specify a 12311 // brace-or-equal-initializer in which every initializer-clause that is 12312 // an assignment-expression is a constant expression. 12313 12314 // Do nothing on dependent types. 12315 if (DclT->isDependentType()) { 12316 12317 // Allow any 'static constexpr' members, whether or not they are of literal 12318 // type. We separately check that every constexpr variable is of literal 12319 // type. 12320 } else if (VDecl->isConstexpr()) { 12321 12322 // Require constness. 12323 } else if (!DclT.isConstQualified()) { 12324 Diag(VDecl->getLocation(), diag::err_in_class_initializer_non_const) 12325 << Init->getSourceRange(); 12326 VDecl->setInvalidDecl(); 12327 12328 // We allow integer constant expressions in all cases. 12329 } else if (DclT->isIntegralOrEnumerationType()) { 12330 // Check whether the expression is a constant expression. 12331 SourceLocation Loc; 12332 if (getLangOpts().CPlusPlus11 && DclT.isVolatileQualified()) 12333 // In C++11, a non-constexpr const static data member with an 12334 // in-class initializer cannot be volatile. 12335 Diag(VDecl->getLocation(), diag::err_in_class_initializer_volatile); 12336 else if (Init->isValueDependent()) 12337 ; // Nothing to check. 12338 else if (Init->isIntegerConstantExpr(Context, &Loc)) 12339 ; // Ok, it's an ICE! 12340 else if (Init->getType()->isScopedEnumeralType() && 12341 Init->isCXX11ConstantExpr(Context)) 12342 ; // Ok, it is a scoped-enum constant expression. 12343 else if (Init->isEvaluatable(Context)) { 12344 // If we can constant fold the initializer through heroics, accept it, 12345 // but report this as a use of an extension for -pedantic. 12346 Diag(Loc, diag::ext_in_class_initializer_non_constant) 12347 << Init->getSourceRange(); 12348 } else { 12349 // Otherwise, this is some crazy unknown case. Report the issue at the 12350 // location provided by the isIntegerConstantExpr failed check. 12351 Diag(Loc, diag::err_in_class_initializer_non_constant) 12352 << Init->getSourceRange(); 12353 VDecl->setInvalidDecl(); 12354 } 12355 12356 // We allow foldable floating-point constants as an extension. 12357 } else if (DclT->isFloatingType()) { // also permits complex, which is ok 12358 // In C++98, this is a GNU extension. In C++11, it is not, but we support 12359 // it anyway and provide a fixit to add the 'constexpr'. 12360 if (getLangOpts().CPlusPlus11) { 12361 Diag(VDecl->getLocation(), 12362 diag::ext_in_class_initializer_float_type_cxx11) 12363 << DclT << Init->getSourceRange(); 12364 Diag(VDecl->getBeginLoc(), 12365 diag::note_in_class_initializer_float_type_cxx11) 12366 << FixItHint::CreateInsertion(VDecl->getBeginLoc(), "constexpr "); 12367 } else { 12368 Diag(VDecl->getLocation(), diag::ext_in_class_initializer_float_type) 12369 << DclT << Init->getSourceRange(); 12370 12371 if (!Init->isValueDependent() && !Init->isEvaluatable(Context)) { 12372 Diag(Init->getExprLoc(), diag::err_in_class_initializer_non_constant) 12373 << Init->getSourceRange(); 12374 VDecl->setInvalidDecl(); 12375 } 12376 } 12377 12378 // Suggest adding 'constexpr' in C++11 for literal types. 12379 } else if (getLangOpts().CPlusPlus11 && DclT->isLiteralType(Context)) { 12380 Diag(VDecl->getLocation(), diag::err_in_class_initializer_literal_type) 12381 << DclT << Init->getSourceRange() 12382 << FixItHint::CreateInsertion(VDecl->getBeginLoc(), "constexpr "); 12383 VDecl->setConstexpr(true); 12384 12385 } else { 12386 Diag(VDecl->getLocation(), diag::err_in_class_initializer_bad_type) 12387 << DclT << Init->getSourceRange(); 12388 VDecl->setInvalidDecl(); 12389 } 12390 } else if (VDecl->isFileVarDecl()) { 12391 // In C, extern is typically used to avoid tentative definitions when 12392 // declaring variables in headers, but adding an intializer makes it a 12393 // definition. This is somewhat confusing, so GCC and Clang both warn on it. 12394 // In C++, extern is often used to give implictly static const variables 12395 // external linkage, so don't warn in that case. If selectany is present, 12396 // this might be header code intended for C and C++ inclusion, so apply the 12397 // C++ rules. 12398 if (VDecl->getStorageClass() == SC_Extern && 12399 ((!getLangOpts().CPlusPlus && !VDecl->hasAttr<SelectAnyAttr>()) || 12400 !Context.getBaseElementType(VDecl->getType()).isConstQualified()) && 12401 !(getLangOpts().CPlusPlus && VDecl->isExternC()) && 12402 !isTemplateInstantiation(VDecl->getTemplateSpecializationKind())) 12403 Diag(VDecl->getLocation(), diag::warn_extern_init); 12404 12405 // In Microsoft C++ mode, a const variable defined in namespace scope has 12406 // external linkage by default if the variable is declared with 12407 // __declspec(dllexport). 12408 if (Context.getTargetInfo().getCXXABI().isMicrosoft() && 12409 getLangOpts().CPlusPlus && VDecl->getType().isConstQualified() && 12410 VDecl->hasAttr<DLLExportAttr>() && VDecl->getDefinition()) 12411 VDecl->setStorageClass(SC_Extern); 12412 12413 // C99 6.7.8p4. All file scoped initializers need to be constant. 12414 if (!getLangOpts().CPlusPlus && !VDecl->isInvalidDecl()) 12415 CheckForConstantInitializer(Init, DclT); 12416 } 12417 12418 QualType InitType = Init->getType(); 12419 if (!InitType.isNull() && 12420 (InitType.hasNonTrivialToPrimitiveDefaultInitializeCUnion() || 12421 InitType.hasNonTrivialToPrimitiveCopyCUnion())) 12422 checkNonTrivialCUnionInInitializer(Init, Init->getExprLoc()); 12423 12424 // We will represent direct-initialization similarly to copy-initialization: 12425 // int x(1); -as-> int x = 1; 12426 // ClassType x(a,b,c); -as-> ClassType x = ClassType(a,b,c); 12427 // 12428 // Clients that want to distinguish between the two forms, can check for 12429 // direct initializer using VarDecl::getInitStyle(). 12430 // A major benefit is that clients that don't particularly care about which 12431 // exactly form was it (like the CodeGen) can handle both cases without 12432 // special case code. 12433 12434 // C++ 8.5p11: 12435 // The form of initialization (using parentheses or '=') is generally 12436 // insignificant, but does matter when the entity being initialized has a 12437 // class type. 12438 if (CXXDirectInit) { 12439 assert(DirectInit && "Call-style initializer must be direct init."); 12440 VDecl->setInitStyle(VarDecl::CallInit); 12441 } else if (DirectInit) { 12442 // This must be list-initialization. No other way is direct-initialization. 12443 VDecl->setInitStyle(VarDecl::ListInit); 12444 } 12445 12446 if (LangOpts.OpenMP && VDecl->isFileVarDecl()) 12447 DeclsToCheckForDeferredDiags.push_back(VDecl); 12448 CheckCompleteVariableDeclaration(VDecl); 12449 } 12450 12451 /// ActOnInitializerError - Given that there was an error parsing an 12452 /// initializer for the given declaration, try to return to some form 12453 /// of sanity. 12454 void Sema::ActOnInitializerError(Decl *D) { 12455 // Our main concern here is re-establishing invariants like "a 12456 // variable's type is either dependent or complete". 12457 if (!D || D->isInvalidDecl()) return; 12458 12459 VarDecl *VD = dyn_cast<VarDecl>(D); 12460 if (!VD) return; 12461 12462 // Bindings are not usable if we can't make sense of the initializer. 12463 if (auto *DD = dyn_cast<DecompositionDecl>(D)) 12464 for (auto *BD : DD->bindings()) 12465 BD->setInvalidDecl(); 12466 12467 // Auto types are meaningless if we can't make sense of the initializer. 12468 if (VD->getType()->isUndeducedType()) { 12469 D->setInvalidDecl(); 12470 return; 12471 } 12472 12473 QualType Ty = VD->getType(); 12474 if (Ty->isDependentType()) return; 12475 12476 // Require a complete type. 12477 if (RequireCompleteType(VD->getLocation(), 12478 Context.getBaseElementType(Ty), 12479 diag::err_typecheck_decl_incomplete_type)) { 12480 VD->setInvalidDecl(); 12481 return; 12482 } 12483 12484 // Require a non-abstract type. 12485 if (RequireNonAbstractType(VD->getLocation(), Ty, 12486 diag::err_abstract_type_in_decl, 12487 AbstractVariableType)) { 12488 VD->setInvalidDecl(); 12489 return; 12490 } 12491 12492 // Don't bother complaining about constructors or destructors, 12493 // though. 12494 } 12495 12496 void Sema::ActOnUninitializedDecl(Decl *RealDecl) { 12497 // If there is no declaration, there was an error parsing it. Just ignore it. 12498 if (!RealDecl) 12499 return; 12500 12501 if (VarDecl *Var = dyn_cast<VarDecl>(RealDecl)) { 12502 QualType Type = Var->getType(); 12503 12504 // C++1z [dcl.dcl]p1 grammar implies that an initializer is mandatory. 12505 if (isa<DecompositionDecl>(RealDecl)) { 12506 Diag(Var->getLocation(), diag::err_decomp_decl_requires_init) << Var; 12507 Var->setInvalidDecl(); 12508 return; 12509 } 12510 12511 if (Type->isUndeducedType() && 12512 DeduceVariableDeclarationType(Var, false, nullptr)) 12513 return; 12514 12515 // C++11 [class.static.data]p3: A static data member can be declared with 12516 // the constexpr specifier; if so, its declaration shall specify 12517 // a brace-or-equal-initializer. 12518 // C++11 [dcl.constexpr]p1: The constexpr specifier shall be applied only to 12519 // the definition of a variable [...] or the declaration of a static data 12520 // member. 12521 if (Var->isConstexpr() && !Var->isThisDeclarationADefinition() && 12522 !Var->isThisDeclarationADemotedDefinition()) { 12523 if (Var->isStaticDataMember()) { 12524 // C++1z removes the relevant rule; the in-class declaration is always 12525 // a definition there. 12526 if (!getLangOpts().CPlusPlus17 && 12527 !Context.getTargetInfo().getCXXABI().isMicrosoft()) { 12528 Diag(Var->getLocation(), 12529 diag::err_constexpr_static_mem_var_requires_init) 12530 << Var; 12531 Var->setInvalidDecl(); 12532 return; 12533 } 12534 } else { 12535 Diag(Var->getLocation(), diag::err_invalid_constexpr_var_decl); 12536 Var->setInvalidDecl(); 12537 return; 12538 } 12539 } 12540 12541 // OpenCL v1.1 s6.5.3: variables declared in the constant address space must 12542 // be initialized. 12543 if (!Var->isInvalidDecl() && 12544 Var->getType().getAddressSpace() == LangAS::opencl_constant && 12545 Var->getStorageClass() != SC_Extern && !Var->getInit()) { 12546 Diag(Var->getLocation(), diag::err_opencl_constant_no_init); 12547 Var->setInvalidDecl(); 12548 return; 12549 } 12550 12551 if (!Var->isInvalidDecl() && RealDecl->hasAttr<LoaderUninitializedAttr>()) { 12552 if (Var->getStorageClass() == SC_Extern) { 12553 Diag(Var->getLocation(), diag::err_loader_uninitialized_extern_decl) 12554 << Var; 12555 Var->setInvalidDecl(); 12556 return; 12557 } 12558 if (RequireCompleteType(Var->getLocation(), Var->getType(), 12559 diag::err_typecheck_decl_incomplete_type)) { 12560 Var->setInvalidDecl(); 12561 return; 12562 } 12563 if (CXXRecordDecl *RD = Var->getType()->getAsCXXRecordDecl()) { 12564 if (!RD->hasTrivialDefaultConstructor()) { 12565 Diag(Var->getLocation(), diag::err_loader_uninitialized_trivial_ctor); 12566 Var->setInvalidDecl(); 12567 return; 12568 } 12569 } 12570 } 12571 12572 VarDecl::DefinitionKind DefKind = Var->isThisDeclarationADefinition(); 12573 if (!Var->isInvalidDecl() && DefKind != VarDecl::DeclarationOnly && 12574 Var->getType().hasNonTrivialToPrimitiveDefaultInitializeCUnion()) 12575 checkNonTrivialCUnion(Var->getType(), Var->getLocation(), 12576 NTCUC_DefaultInitializedObject, NTCUK_Init); 12577 12578 12579 switch (DefKind) { 12580 case VarDecl::Definition: 12581 if (!Var->isStaticDataMember() || !Var->getAnyInitializer()) 12582 break; 12583 12584 // We have an out-of-line definition of a static data member 12585 // that has an in-class initializer, so we type-check this like 12586 // a declaration. 12587 // 12588 LLVM_FALLTHROUGH; 12589 12590 case VarDecl::DeclarationOnly: 12591 // It's only a declaration. 12592 12593 // Block scope. C99 6.7p7: If an identifier for an object is 12594 // declared with no linkage (C99 6.2.2p6), the type for the 12595 // object shall be complete. 12596 if (!Type->isDependentType() && Var->isLocalVarDecl() && 12597 !Var->hasLinkage() && !Var->isInvalidDecl() && 12598 RequireCompleteType(Var->getLocation(), Type, 12599 diag::err_typecheck_decl_incomplete_type)) 12600 Var->setInvalidDecl(); 12601 12602 // Make sure that the type is not abstract. 12603 if (!Type->isDependentType() && !Var->isInvalidDecl() && 12604 RequireNonAbstractType(Var->getLocation(), Type, 12605 diag::err_abstract_type_in_decl, 12606 AbstractVariableType)) 12607 Var->setInvalidDecl(); 12608 if (!Type->isDependentType() && !Var->isInvalidDecl() && 12609 Var->getStorageClass() == SC_PrivateExtern) { 12610 Diag(Var->getLocation(), diag::warn_private_extern); 12611 Diag(Var->getLocation(), diag::note_private_extern); 12612 } 12613 12614 if (Context.getTargetInfo().allowDebugInfoForExternalVar() && 12615 !Var->isInvalidDecl() && !getLangOpts().CPlusPlus) 12616 ExternalDeclarations.push_back(Var); 12617 12618 return; 12619 12620 case VarDecl::TentativeDefinition: 12621 // File scope. C99 6.9.2p2: A declaration of an identifier for an 12622 // object that has file scope without an initializer, and without a 12623 // storage-class specifier or with the storage-class specifier "static", 12624 // constitutes a tentative definition. Note: A tentative definition with 12625 // external linkage is valid (C99 6.2.2p5). 12626 if (!Var->isInvalidDecl()) { 12627 if (const IncompleteArrayType *ArrayT 12628 = Context.getAsIncompleteArrayType(Type)) { 12629 if (RequireCompleteSizedType( 12630 Var->getLocation(), ArrayT->getElementType(), 12631 diag::err_array_incomplete_or_sizeless_type)) 12632 Var->setInvalidDecl(); 12633 } else if (Var->getStorageClass() == SC_Static) { 12634 // C99 6.9.2p3: If the declaration of an identifier for an object is 12635 // a tentative definition and has internal linkage (C99 6.2.2p3), the 12636 // declared type shall not be an incomplete type. 12637 // NOTE: code such as the following 12638 // static struct s; 12639 // struct s { int a; }; 12640 // is accepted by gcc. Hence here we issue a warning instead of 12641 // an error and we do not invalidate the static declaration. 12642 // NOTE: to avoid multiple warnings, only check the first declaration. 12643 if (Var->isFirstDecl()) 12644 RequireCompleteType(Var->getLocation(), Type, 12645 diag::ext_typecheck_decl_incomplete_type); 12646 } 12647 } 12648 12649 // Record the tentative definition; we're done. 12650 if (!Var->isInvalidDecl()) 12651 TentativeDefinitions.push_back(Var); 12652 return; 12653 } 12654 12655 // Provide a specific diagnostic for uninitialized variable 12656 // definitions with incomplete array type. 12657 if (Type->isIncompleteArrayType()) { 12658 Diag(Var->getLocation(), 12659 diag::err_typecheck_incomplete_array_needs_initializer); 12660 Var->setInvalidDecl(); 12661 return; 12662 } 12663 12664 // Provide a specific diagnostic for uninitialized variable 12665 // definitions with reference type. 12666 if (Type->isReferenceType()) { 12667 Diag(Var->getLocation(), diag::err_reference_var_requires_init) 12668 << Var << SourceRange(Var->getLocation(), Var->getLocation()); 12669 Var->setInvalidDecl(); 12670 return; 12671 } 12672 12673 // Do not attempt to type-check the default initializer for a 12674 // variable with dependent type. 12675 if (Type->isDependentType()) 12676 return; 12677 12678 if (Var->isInvalidDecl()) 12679 return; 12680 12681 if (!Var->hasAttr<AliasAttr>()) { 12682 if (RequireCompleteType(Var->getLocation(), 12683 Context.getBaseElementType(Type), 12684 diag::err_typecheck_decl_incomplete_type)) { 12685 Var->setInvalidDecl(); 12686 return; 12687 } 12688 } else { 12689 return; 12690 } 12691 12692 // The variable can not have an abstract class type. 12693 if (RequireNonAbstractType(Var->getLocation(), Type, 12694 diag::err_abstract_type_in_decl, 12695 AbstractVariableType)) { 12696 Var->setInvalidDecl(); 12697 return; 12698 } 12699 12700 // Check for jumps past the implicit initializer. C++0x 12701 // clarifies that this applies to a "variable with automatic 12702 // storage duration", not a "local variable". 12703 // C++11 [stmt.dcl]p3 12704 // A program that jumps from a point where a variable with automatic 12705 // storage duration is not in scope to a point where it is in scope is 12706 // ill-formed unless the variable has scalar type, class type with a 12707 // trivial default constructor and a trivial destructor, a cv-qualified 12708 // version of one of these types, or an array of one of the preceding 12709 // types and is declared without an initializer. 12710 if (getLangOpts().CPlusPlus && Var->hasLocalStorage()) { 12711 if (const RecordType *Record 12712 = Context.getBaseElementType(Type)->getAs<RecordType>()) { 12713 CXXRecordDecl *CXXRecord = cast<CXXRecordDecl>(Record->getDecl()); 12714 // Mark the function (if we're in one) for further checking even if the 12715 // looser rules of C++11 do not require such checks, so that we can 12716 // diagnose incompatibilities with C++98. 12717 if (!CXXRecord->isPOD()) 12718 setFunctionHasBranchProtectedScope(); 12719 } 12720 } 12721 // In OpenCL, we can't initialize objects in the __local address space, 12722 // even implicitly, so don't synthesize an implicit initializer. 12723 if (getLangOpts().OpenCL && 12724 Var->getType().getAddressSpace() == LangAS::opencl_local) 12725 return; 12726 // C++03 [dcl.init]p9: 12727 // If no initializer is specified for an object, and the 12728 // object is of (possibly cv-qualified) non-POD class type (or 12729 // array thereof), the object shall be default-initialized; if 12730 // the object is of const-qualified type, the underlying class 12731 // type shall have a user-declared default 12732 // constructor. Otherwise, if no initializer is specified for 12733 // a non- static object, the object and its subobjects, if 12734 // any, have an indeterminate initial value); if the object 12735 // or any of its subobjects are of const-qualified type, the 12736 // program is ill-formed. 12737 // C++0x [dcl.init]p11: 12738 // If no initializer is specified for an object, the object is 12739 // default-initialized; [...]. 12740 InitializedEntity Entity = InitializedEntity::InitializeVariable(Var); 12741 InitializationKind Kind 12742 = InitializationKind::CreateDefault(Var->getLocation()); 12743 12744 InitializationSequence InitSeq(*this, Entity, Kind, None); 12745 ExprResult Init = InitSeq.Perform(*this, Entity, Kind, None); 12746 12747 if (Init.get()) { 12748 Var->setInit(MaybeCreateExprWithCleanups(Init.get())); 12749 // This is important for template substitution. 12750 Var->setInitStyle(VarDecl::CallInit); 12751 } else if (Init.isInvalid()) { 12752 // If default-init fails, attach a recovery-expr initializer to track 12753 // that initialization was attempted and failed. 12754 auto RecoveryExpr = 12755 CreateRecoveryExpr(Var->getLocation(), Var->getLocation(), {}); 12756 if (RecoveryExpr.get()) 12757 Var->setInit(RecoveryExpr.get()); 12758 } 12759 12760 CheckCompleteVariableDeclaration(Var); 12761 } 12762 } 12763 12764 void Sema::ActOnCXXForRangeDecl(Decl *D) { 12765 // If there is no declaration, there was an error parsing it. Ignore it. 12766 if (!D) 12767 return; 12768 12769 VarDecl *VD = dyn_cast<VarDecl>(D); 12770 if (!VD) { 12771 Diag(D->getLocation(), diag::err_for_range_decl_must_be_var); 12772 D->setInvalidDecl(); 12773 return; 12774 } 12775 12776 VD->setCXXForRangeDecl(true); 12777 12778 // for-range-declaration cannot be given a storage class specifier. 12779 int Error = -1; 12780 switch (VD->getStorageClass()) { 12781 case SC_None: 12782 break; 12783 case SC_Extern: 12784 Error = 0; 12785 break; 12786 case SC_Static: 12787 Error = 1; 12788 break; 12789 case SC_PrivateExtern: 12790 Error = 2; 12791 break; 12792 case SC_Auto: 12793 Error = 3; 12794 break; 12795 case SC_Register: 12796 Error = 4; 12797 break; 12798 } 12799 12800 // for-range-declaration cannot be given a storage class specifier con't. 12801 switch (VD->getTSCSpec()) { 12802 case TSCS_thread_local: 12803 Error = 6; 12804 break; 12805 case TSCS___thread: 12806 case TSCS__Thread_local: 12807 case TSCS_unspecified: 12808 break; 12809 } 12810 12811 if (Error != -1) { 12812 Diag(VD->getOuterLocStart(), diag::err_for_range_storage_class) 12813 << VD << Error; 12814 D->setInvalidDecl(); 12815 } 12816 } 12817 12818 StmtResult 12819 Sema::ActOnCXXForRangeIdentifier(Scope *S, SourceLocation IdentLoc, 12820 IdentifierInfo *Ident, 12821 ParsedAttributes &Attrs, 12822 SourceLocation AttrEnd) { 12823 // C++1y [stmt.iter]p1: 12824 // A range-based for statement of the form 12825 // for ( for-range-identifier : for-range-initializer ) statement 12826 // is equivalent to 12827 // for ( auto&& for-range-identifier : for-range-initializer ) statement 12828 DeclSpec DS(Attrs.getPool().getFactory()); 12829 12830 const char *PrevSpec; 12831 unsigned DiagID; 12832 DS.SetTypeSpecType(DeclSpec::TST_auto, IdentLoc, PrevSpec, DiagID, 12833 getPrintingPolicy()); 12834 12835 Declarator D(DS, DeclaratorContext::ForInit); 12836 D.SetIdentifier(Ident, IdentLoc); 12837 D.takeAttributes(Attrs, AttrEnd); 12838 12839 D.AddTypeInfo(DeclaratorChunk::getReference(0, IdentLoc, /*lvalue*/ false), 12840 IdentLoc); 12841 Decl *Var = ActOnDeclarator(S, D); 12842 cast<VarDecl>(Var)->setCXXForRangeDecl(true); 12843 FinalizeDeclaration(Var); 12844 return ActOnDeclStmt(FinalizeDeclaratorGroup(S, DS, Var), IdentLoc, 12845 AttrEnd.isValid() ? AttrEnd : IdentLoc); 12846 } 12847 12848 void Sema::CheckCompleteVariableDeclaration(VarDecl *var) { 12849 if (var->isInvalidDecl()) return; 12850 12851 if (getLangOpts().OpenCL) { 12852 // OpenCL v2.0 s6.12.5 - Every block variable declaration must have an 12853 // initialiser 12854 if (var->getTypeSourceInfo()->getType()->isBlockPointerType() && 12855 !var->hasInit()) { 12856 Diag(var->getLocation(), diag::err_opencl_invalid_block_declaration) 12857 << 1 /*Init*/; 12858 var->setInvalidDecl(); 12859 return; 12860 } 12861 } 12862 12863 // In Objective-C, don't allow jumps past the implicit initialization of a 12864 // local retaining variable. 12865 if (getLangOpts().ObjC && 12866 var->hasLocalStorage()) { 12867 switch (var->getType().getObjCLifetime()) { 12868 case Qualifiers::OCL_None: 12869 case Qualifiers::OCL_ExplicitNone: 12870 case Qualifiers::OCL_Autoreleasing: 12871 break; 12872 12873 case Qualifiers::OCL_Weak: 12874 case Qualifiers::OCL_Strong: 12875 setFunctionHasBranchProtectedScope(); 12876 break; 12877 } 12878 } 12879 12880 if (var->hasLocalStorage() && 12881 var->getType().isDestructedType() == QualType::DK_nontrivial_c_struct) 12882 setFunctionHasBranchProtectedScope(); 12883 12884 // Warn about externally-visible variables being defined without a 12885 // prior declaration. We only want to do this for global 12886 // declarations, but we also specifically need to avoid doing it for 12887 // class members because the linkage of an anonymous class can 12888 // change if it's later given a typedef name. 12889 if (var->isThisDeclarationADefinition() && 12890 var->getDeclContext()->getRedeclContext()->isFileContext() && 12891 var->isExternallyVisible() && var->hasLinkage() && 12892 !var->isInline() && !var->getDescribedVarTemplate() && 12893 !isa<VarTemplatePartialSpecializationDecl>(var) && 12894 !isTemplateInstantiation(var->getTemplateSpecializationKind()) && 12895 !getDiagnostics().isIgnored(diag::warn_missing_variable_declarations, 12896 var->getLocation())) { 12897 // Find a previous declaration that's not a definition. 12898 VarDecl *prev = var->getPreviousDecl(); 12899 while (prev && prev->isThisDeclarationADefinition()) 12900 prev = prev->getPreviousDecl(); 12901 12902 if (!prev) { 12903 Diag(var->getLocation(), diag::warn_missing_variable_declarations) << var; 12904 Diag(var->getTypeSpecStartLoc(), diag::note_static_for_internal_linkage) 12905 << /* variable */ 0; 12906 } 12907 } 12908 12909 // Cache the result of checking for constant initialization. 12910 Optional<bool> CacheHasConstInit; 12911 const Expr *CacheCulprit = nullptr; 12912 auto checkConstInit = [&]() mutable { 12913 if (!CacheHasConstInit) 12914 CacheHasConstInit = var->getInit()->isConstantInitializer( 12915 Context, var->getType()->isReferenceType(), &CacheCulprit); 12916 return *CacheHasConstInit; 12917 }; 12918 12919 if (var->getTLSKind() == VarDecl::TLS_Static) { 12920 if (var->getType().isDestructedType()) { 12921 // GNU C++98 edits for __thread, [basic.start.term]p3: 12922 // The type of an object with thread storage duration shall not 12923 // have a non-trivial destructor. 12924 Diag(var->getLocation(), diag::err_thread_nontrivial_dtor); 12925 if (getLangOpts().CPlusPlus11) 12926 Diag(var->getLocation(), diag::note_use_thread_local); 12927 } else if (getLangOpts().CPlusPlus && var->hasInit()) { 12928 if (!checkConstInit()) { 12929 // GNU C++98 edits for __thread, [basic.start.init]p4: 12930 // An object of thread storage duration shall not require dynamic 12931 // initialization. 12932 // FIXME: Need strict checking here. 12933 Diag(CacheCulprit->getExprLoc(), diag::err_thread_dynamic_init) 12934 << CacheCulprit->getSourceRange(); 12935 if (getLangOpts().CPlusPlus11) 12936 Diag(var->getLocation(), diag::note_use_thread_local); 12937 } 12938 } 12939 } 12940 12941 // Apply section attributes and pragmas to global variables. 12942 bool GlobalStorage = var->hasGlobalStorage(); 12943 if (GlobalStorage && var->isThisDeclarationADefinition() && 12944 !inTemplateInstantiation()) { 12945 PragmaStack<StringLiteral *> *Stack = nullptr; 12946 int SectionFlags = ASTContext::PSF_Read; 12947 if (var->getType().isConstQualified()) 12948 Stack = &ConstSegStack; 12949 else if (!var->getInit()) { 12950 Stack = &BSSSegStack; 12951 SectionFlags |= ASTContext::PSF_Write; 12952 } else { 12953 Stack = &DataSegStack; 12954 SectionFlags |= ASTContext::PSF_Write; 12955 } 12956 if (const SectionAttr *SA = var->getAttr<SectionAttr>()) { 12957 if (SA->getSyntax() == AttributeCommonInfo::AS_Declspec) 12958 SectionFlags |= ASTContext::PSF_Implicit; 12959 UnifySection(SA->getName(), SectionFlags, var); 12960 } else if (Stack->CurrentValue) { 12961 SectionFlags |= ASTContext::PSF_Implicit; 12962 auto SectionName = Stack->CurrentValue->getString(); 12963 var->addAttr(SectionAttr::CreateImplicit( 12964 Context, SectionName, Stack->CurrentPragmaLocation, 12965 AttributeCommonInfo::AS_Pragma, SectionAttr::Declspec_allocate)); 12966 if (UnifySection(SectionName, SectionFlags, var)) 12967 var->dropAttr<SectionAttr>(); 12968 } 12969 12970 // Apply the init_seg attribute if this has an initializer. If the 12971 // initializer turns out to not be dynamic, we'll end up ignoring this 12972 // attribute. 12973 if (CurInitSeg && var->getInit()) 12974 var->addAttr(InitSegAttr::CreateImplicit(Context, CurInitSeg->getString(), 12975 CurInitSegLoc, 12976 AttributeCommonInfo::AS_Pragma)); 12977 } 12978 12979 if (!var->getType()->isStructureType() && var->hasInit() && 12980 isa<InitListExpr>(var->getInit())) { 12981 const auto *ILE = cast<InitListExpr>(var->getInit()); 12982 unsigned NumInits = ILE->getNumInits(); 12983 if (NumInits > 2) 12984 for (unsigned I = 0; I < NumInits; ++I) { 12985 const auto *Init = ILE->getInit(I); 12986 if (!Init) 12987 break; 12988 const auto *SL = dyn_cast<StringLiteral>(Init->IgnoreImpCasts()); 12989 if (!SL) 12990 break; 12991 12992 unsigned NumConcat = SL->getNumConcatenated(); 12993 // Diagnose missing comma in string array initialization. 12994 // Do not warn when all the elements in the initializer are concatenated 12995 // together. Do not warn for macros too. 12996 if (NumConcat == 2 && !SL->getBeginLoc().isMacroID()) { 12997 bool OnlyOneMissingComma = true; 12998 for (unsigned J = I + 1; J < NumInits; ++J) { 12999 const auto *Init = ILE->getInit(J); 13000 if (!Init) 13001 break; 13002 const auto *SLJ = dyn_cast<StringLiteral>(Init->IgnoreImpCasts()); 13003 if (!SLJ || SLJ->getNumConcatenated() > 1) { 13004 OnlyOneMissingComma = false; 13005 break; 13006 } 13007 } 13008 13009 if (OnlyOneMissingComma) { 13010 SmallVector<FixItHint, 1> Hints; 13011 for (unsigned i = 0; i < NumConcat - 1; ++i) 13012 Hints.push_back(FixItHint::CreateInsertion( 13013 PP.getLocForEndOfToken(SL->getStrTokenLoc(i)), ",")); 13014 13015 Diag(SL->getStrTokenLoc(1), 13016 diag::warn_concatenated_literal_array_init) 13017 << Hints; 13018 Diag(SL->getBeginLoc(), 13019 diag::note_concatenated_string_literal_silence); 13020 } 13021 // In any case, stop now. 13022 break; 13023 } 13024 } 13025 } 13026 13027 // All the following checks are C++ only. 13028 if (!getLangOpts().CPlusPlus) { 13029 // If this variable must be emitted, add it as an initializer for the 13030 // current module. 13031 if (Context.DeclMustBeEmitted(var) && !ModuleScopes.empty()) 13032 Context.addModuleInitializer(ModuleScopes.back().Module, var); 13033 return; 13034 } 13035 13036 QualType type = var->getType(); 13037 13038 if (var->hasAttr<BlocksAttr>()) 13039 getCurFunction()->addByrefBlockVar(var); 13040 13041 Expr *Init = var->getInit(); 13042 bool IsGlobal = GlobalStorage && !var->isStaticLocal(); 13043 QualType baseType = Context.getBaseElementType(type); 13044 13045 // Check whether the initializer is sufficiently constant. 13046 if (!type->isDependentType() && Init && !Init->isValueDependent() && 13047 (GlobalStorage || var->isConstexpr() || 13048 var->mightBeUsableInConstantExpressions(Context))) { 13049 // If this variable might have a constant initializer or might be usable in 13050 // constant expressions, check whether or not it actually is now. We can't 13051 // do this lazily, because the result might depend on things that change 13052 // later, such as which constexpr functions happen to be defined. 13053 SmallVector<PartialDiagnosticAt, 8> Notes; 13054 bool HasConstInit; 13055 if (!getLangOpts().CPlusPlus11) { 13056 // Prior to C++11, in contexts where a constant initializer is required, 13057 // the set of valid constant initializers is described by syntactic rules 13058 // in [expr.const]p2-6. 13059 // FIXME: Stricter checking for these rules would be useful for constinit / 13060 // -Wglobal-constructors. 13061 HasConstInit = checkConstInit(); 13062 13063 // Compute and cache the constant value, and remember that we have a 13064 // constant initializer. 13065 if (HasConstInit) { 13066 (void)var->checkForConstantInitialization(Notes); 13067 Notes.clear(); 13068 } else if (CacheCulprit) { 13069 Notes.emplace_back(CacheCulprit->getExprLoc(), 13070 PDiag(diag::note_invalid_subexpr_in_const_expr)); 13071 Notes.back().second << CacheCulprit->getSourceRange(); 13072 } 13073 } else { 13074 // Evaluate the initializer to see if it's a constant initializer. 13075 HasConstInit = var->checkForConstantInitialization(Notes); 13076 } 13077 13078 if (HasConstInit) { 13079 // FIXME: Consider replacing the initializer with a ConstantExpr. 13080 } else if (var->isConstexpr()) { 13081 SourceLocation DiagLoc = var->getLocation(); 13082 // If the note doesn't add any useful information other than a source 13083 // location, fold it into the primary diagnostic. 13084 if (Notes.size() == 1 && Notes[0].second.getDiagID() == 13085 diag::note_invalid_subexpr_in_const_expr) { 13086 DiagLoc = Notes[0].first; 13087 Notes.clear(); 13088 } 13089 Diag(DiagLoc, diag::err_constexpr_var_requires_const_init) 13090 << var << Init->getSourceRange(); 13091 for (unsigned I = 0, N = Notes.size(); I != N; ++I) 13092 Diag(Notes[I].first, Notes[I].second); 13093 } else if (GlobalStorage && var->hasAttr<ConstInitAttr>()) { 13094 auto *Attr = var->getAttr<ConstInitAttr>(); 13095 Diag(var->getLocation(), diag::err_require_constant_init_failed) 13096 << Init->getSourceRange(); 13097 Diag(Attr->getLocation(), diag::note_declared_required_constant_init_here) 13098 << Attr->getRange() << Attr->isConstinit(); 13099 for (auto &it : Notes) 13100 Diag(it.first, it.second); 13101 } else if (IsGlobal && 13102 !getDiagnostics().isIgnored(diag::warn_global_constructor, 13103 var->getLocation())) { 13104 // Warn about globals which don't have a constant initializer. Don't 13105 // warn about globals with a non-trivial destructor because we already 13106 // warned about them. 13107 CXXRecordDecl *RD = baseType->getAsCXXRecordDecl(); 13108 if (!(RD && !RD->hasTrivialDestructor())) { 13109 // checkConstInit() here permits trivial default initialization even in 13110 // C++11 onwards, where such an initializer is not a constant initializer 13111 // but nonetheless doesn't require a global constructor. 13112 if (!checkConstInit()) 13113 Diag(var->getLocation(), diag::warn_global_constructor) 13114 << Init->getSourceRange(); 13115 } 13116 } 13117 } 13118 13119 // Require the destructor. 13120 if (!type->isDependentType()) 13121 if (const RecordType *recordType = baseType->getAs<RecordType>()) 13122 FinalizeVarWithDestructor(var, recordType); 13123 13124 // If this variable must be emitted, add it as an initializer for the current 13125 // module. 13126 if (Context.DeclMustBeEmitted(var) && !ModuleScopes.empty()) 13127 Context.addModuleInitializer(ModuleScopes.back().Module, var); 13128 13129 // Build the bindings if this is a structured binding declaration. 13130 if (auto *DD = dyn_cast<DecompositionDecl>(var)) 13131 CheckCompleteDecompositionDeclaration(DD); 13132 } 13133 13134 /// Determines if a variable's alignment is dependent. 13135 static bool hasDependentAlignment(VarDecl *VD) { 13136 if (VD->getType()->isDependentType()) 13137 return true; 13138 for (auto *I : VD->specific_attrs<AlignedAttr>()) 13139 if (I->isAlignmentDependent()) 13140 return true; 13141 return false; 13142 } 13143 13144 /// Check if VD needs to be dllexport/dllimport due to being in a 13145 /// dllexport/import function. 13146 void Sema::CheckStaticLocalForDllExport(VarDecl *VD) { 13147 assert(VD->isStaticLocal()); 13148 13149 auto *FD = dyn_cast_or_null<FunctionDecl>(VD->getParentFunctionOrMethod()); 13150 13151 // Find outermost function when VD is in lambda function. 13152 while (FD && !getDLLAttr(FD) && 13153 !FD->hasAttr<DLLExportStaticLocalAttr>() && 13154 !FD->hasAttr<DLLImportStaticLocalAttr>()) { 13155 FD = dyn_cast_or_null<FunctionDecl>(FD->getParentFunctionOrMethod()); 13156 } 13157 13158 if (!FD) 13159 return; 13160 13161 // Static locals inherit dll attributes from their function. 13162 if (Attr *A = getDLLAttr(FD)) { 13163 auto *NewAttr = cast<InheritableAttr>(A->clone(getASTContext())); 13164 NewAttr->setInherited(true); 13165 VD->addAttr(NewAttr); 13166 } else if (Attr *A = FD->getAttr<DLLExportStaticLocalAttr>()) { 13167 auto *NewAttr = DLLExportAttr::CreateImplicit(getASTContext(), *A); 13168 NewAttr->setInherited(true); 13169 VD->addAttr(NewAttr); 13170 13171 // Export this function to enforce exporting this static variable even 13172 // if it is not used in this compilation unit. 13173 if (!FD->hasAttr<DLLExportAttr>()) 13174 FD->addAttr(NewAttr); 13175 13176 } else if (Attr *A = FD->getAttr<DLLImportStaticLocalAttr>()) { 13177 auto *NewAttr = DLLImportAttr::CreateImplicit(getASTContext(), *A); 13178 NewAttr->setInherited(true); 13179 VD->addAttr(NewAttr); 13180 } 13181 } 13182 13183 /// FinalizeDeclaration - called by ParseDeclarationAfterDeclarator to perform 13184 /// any semantic actions necessary after any initializer has been attached. 13185 void Sema::FinalizeDeclaration(Decl *ThisDecl) { 13186 // Note that we are no longer parsing the initializer for this declaration. 13187 ParsingInitForAutoVars.erase(ThisDecl); 13188 13189 VarDecl *VD = dyn_cast_or_null<VarDecl>(ThisDecl); 13190 if (!VD) 13191 return; 13192 13193 // Apply an implicit SectionAttr if '#pragma clang section bss|data|rodata' is active 13194 if (VD->hasGlobalStorage() && VD->isThisDeclarationADefinition() && 13195 !inTemplateInstantiation() && !VD->hasAttr<SectionAttr>()) { 13196 if (PragmaClangBSSSection.Valid) 13197 VD->addAttr(PragmaClangBSSSectionAttr::CreateImplicit( 13198 Context, PragmaClangBSSSection.SectionName, 13199 PragmaClangBSSSection.PragmaLocation, 13200 AttributeCommonInfo::AS_Pragma)); 13201 if (PragmaClangDataSection.Valid) 13202 VD->addAttr(PragmaClangDataSectionAttr::CreateImplicit( 13203 Context, PragmaClangDataSection.SectionName, 13204 PragmaClangDataSection.PragmaLocation, 13205 AttributeCommonInfo::AS_Pragma)); 13206 if (PragmaClangRodataSection.Valid) 13207 VD->addAttr(PragmaClangRodataSectionAttr::CreateImplicit( 13208 Context, PragmaClangRodataSection.SectionName, 13209 PragmaClangRodataSection.PragmaLocation, 13210 AttributeCommonInfo::AS_Pragma)); 13211 if (PragmaClangRelroSection.Valid) 13212 VD->addAttr(PragmaClangRelroSectionAttr::CreateImplicit( 13213 Context, PragmaClangRelroSection.SectionName, 13214 PragmaClangRelroSection.PragmaLocation, 13215 AttributeCommonInfo::AS_Pragma)); 13216 } 13217 13218 if (auto *DD = dyn_cast<DecompositionDecl>(ThisDecl)) { 13219 for (auto *BD : DD->bindings()) { 13220 FinalizeDeclaration(BD); 13221 } 13222 } 13223 13224 checkAttributesAfterMerging(*this, *VD); 13225 13226 // Perform TLS alignment check here after attributes attached to the variable 13227 // which may affect the alignment have been processed. Only perform the check 13228 // if the target has a maximum TLS alignment (zero means no constraints). 13229 if (unsigned MaxAlign = Context.getTargetInfo().getMaxTLSAlign()) { 13230 // Protect the check so that it's not performed on dependent types and 13231 // dependent alignments (we can't determine the alignment in that case). 13232 if (VD->getTLSKind() && !hasDependentAlignment(VD) && 13233 !VD->isInvalidDecl()) { 13234 CharUnits MaxAlignChars = Context.toCharUnitsFromBits(MaxAlign); 13235 if (Context.getDeclAlign(VD) > MaxAlignChars) { 13236 Diag(VD->getLocation(), diag::err_tls_var_aligned_over_maximum) 13237 << (unsigned)Context.getDeclAlign(VD).getQuantity() << VD 13238 << (unsigned)MaxAlignChars.getQuantity(); 13239 } 13240 } 13241 } 13242 13243 if (VD->isStaticLocal()) 13244 CheckStaticLocalForDllExport(VD); 13245 13246 // Perform check for initializers of device-side global variables. 13247 // CUDA allows empty constructors as initializers (see E.2.3.1, CUDA 13248 // 7.5). We must also apply the same checks to all __shared__ 13249 // variables whether they are local or not. CUDA also allows 13250 // constant initializers for __constant__ and __device__ variables. 13251 if (getLangOpts().CUDA) 13252 checkAllowedCUDAInitializer(VD); 13253 13254 // Grab the dllimport or dllexport attribute off of the VarDecl. 13255 const InheritableAttr *DLLAttr = getDLLAttr(VD); 13256 13257 // Imported static data members cannot be defined out-of-line. 13258 if (const auto *IA = dyn_cast_or_null<DLLImportAttr>(DLLAttr)) { 13259 if (VD->isStaticDataMember() && VD->isOutOfLine() && 13260 VD->isThisDeclarationADefinition()) { 13261 // We allow definitions of dllimport class template static data members 13262 // with a warning. 13263 CXXRecordDecl *Context = 13264 cast<CXXRecordDecl>(VD->getFirstDecl()->getDeclContext()); 13265 bool IsClassTemplateMember = 13266 isa<ClassTemplatePartialSpecializationDecl>(Context) || 13267 Context->getDescribedClassTemplate(); 13268 13269 Diag(VD->getLocation(), 13270 IsClassTemplateMember 13271 ? diag::warn_attribute_dllimport_static_field_definition 13272 : diag::err_attribute_dllimport_static_field_definition); 13273 Diag(IA->getLocation(), diag::note_attribute); 13274 if (!IsClassTemplateMember) 13275 VD->setInvalidDecl(); 13276 } 13277 } 13278 13279 // dllimport/dllexport variables cannot be thread local, their TLS index 13280 // isn't exported with the variable. 13281 if (DLLAttr && VD->getTLSKind()) { 13282 auto *F = dyn_cast_or_null<FunctionDecl>(VD->getParentFunctionOrMethod()); 13283 if (F && getDLLAttr(F)) { 13284 assert(VD->isStaticLocal()); 13285 // But if this is a static local in a dlimport/dllexport function, the 13286 // function will never be inlined, which means the var would never be 13287 // imported, so having it marked import/export is safe. 13288 } else { 13289 Diag(VD->getLocation(), diag::err_attribute_dll_thread_local) << VD 13290 << DLLAttr; 13291 VD->setInvalidDecl(); 13292 } 13293 } 13294 13295 if (UsedAttr *Attr = VD->getAttr<UsedAttr>()) { 13296 if (!Attr->isInherited() && !VD->isThisDeclarationADefinition()) { 13297 Diag(Attr->getLocation(), diag::warn_attribute_ignored) << Attr; 13298 VD->dropAttr<UsedAttr>(); 13299 } 13300 } 13301 13302 const DeclContext *DC = VD->getDeclContext(); 13303 // If there's a #pragma GCC visibility in scope, and this isn't a class 13304 // member, set the visibility of this variable. 13305 if (DC->getRedeclContext()->isFileContext() && VD->isExternallyVisible()) 13306 AddPushedVisibilityAttribute(VD); 13307 13308 // FIXME: Warn on unused var template partial specializations. 13309 if (VD->isFileVarDecl() && !isa<VarTemplatePartialSpecializationDecl>(VD)) 13310 MarkUnusedFileScopedDecl(VD); 13311 13312 // Now we have parsed the initializer and can update the table of magic 13313 // tag values. 13314 if (!VD->hasAttr<TypeTagForDatatypeAttr>() || 13315 !VD->getType()->isIntegralOrEnumerationType()) 13316 return; 13317 13318 for (const auto *I : ThisDecl->specific_attrs<TypeTagForDatatypeAttr>()) { 13319 const Expr *MagicValueExpr = VD->getInit(); 13320 if (!MagicValueExpr) { 13321 continue; 13322 } 13323 Optional<llvm::APSInt> MagicValueInt; 13324 if (!(MagicValueInt = MagicValueExpr->getIntegerConstantExpr(Context))) { 13325 Diag(I->getRange().getBegin(), 13326 diag::err_type_tag_for_datatype_not_ice) 13327 << LangOpts.CPlusPlus << MagicValueExpr->getSourceRange(); 13328 continue; 13329 } 13330 if (MagicValueInt->getActiveBits() > 64) { 13331 Diag(I->getRange().getBegin(), 13332 diag::err_type_tag_for_datatype_too_large) 13333 << LangOpts.CPlusPlus << MagicValueExpr->getSourceRange(); 13334 continue; 13335 } 13336 uint64_t MagicValue = MagicValueInt->getZExtValue(); 13337 RegisterTypeTagForDatatype(I->getArgumentKind(), 13338 MagicValue, 13339 I->getMatchingCType(), 13340 I->getLayoutCompatible(), 13341 I->getMustBeNull()); 13342 } 13343 } 13344 13345 static bool hasDeducedAuto(DeclaratorDecl *DD) { 13346 auto *VD = dyn_cast<VarDecl>(DD); 13347 return VD && !VD->getType()->hasAutoForTrailingReturnType(); 13348 } 13349 13350 Sema::DeclGroupPtrTy Sema::FinalizeDeclaratorGroup(Scope *S, const DeclSpec &DS, 13351 ArrayRef<Decl *> Group) { 13352 SmallVector<Decl*, 8> Decls; 13353 13354 if (DS.isTypeSpecOwned()) 13355 Decls.push_back(DS.getRepAsDecl()); 13356 13357 DeclaratorDecl *FirstDeclaratorInGroup = nullptr; 13358 DecompositionDecl *FirstDecompDeclaratorInGroup = nullptr; 13359 bool DiagnosedMultipleDecomps = false; 13360 DeclaratorDecl *FirstNonDeducedAutoInGroup = nullptr; 13361 bool DiagnosedNonDeducedAuto = false; 13362 13363 for (unsigned i = 0, e = Group.size(); i != e; ++i) { 13364 if (Decl *D = Group[i]) { 13365 // For declarators, there are some additional syntactic-ish checks we need 13366 // to perform. 13367 if (auto *DD = dyn_cast<DeclaratorDecl>(D)) { 13368 if (!FirstDeclaratorInGroup) 13369 FirstDeclaratorInGroup = DD; 13370 if (!FirstDecompDeclaratorInGroup) 13371 FirstDecompDeclaratorInGroup = dyn_cast<DecompositionDecl>(D); 13372 if (!FirstNonDeducedAutoInGroup && DS.hasAutoTypeSpec() && 13373 !hasDeducedAuto(DD)) 13374 FirstNonDeducedAutoInGroup = DD; 13375 13376 if (FirstDeclaratorInGroup != DD) { 13377 // A decomposition declaration cannot be combined with any other 13378 // declaration in the same group. 13379 if (FirstDecompDeclaratorInGroup && !DiagnosedMultipleDecomps) { 13380 Diag(FirstDecompDeclaratorInGroup->getLocation(), 13381 diag::err_decomp_decl_not_alone) 13382 << FirstDeclaratorInGroup->getSourceRange() 13383 << DD->getSourceRange(); 13384 DiagnosedMultipleDecomps = true; 13385 } 13386 13387 // A declarator that uses 'auto' in any way other than to declare a 13388 // variable with a deduced type cannot be combined with any other 13389 // declarator in the same group. 13390 if (FirstNonDeducedAutoInGroup && !DiagnosedNonDeducedAuto) { 13391 Diag(FirstNonDeducedAutoInGroup->getLocation(), 13392 diag::err_auto_non_deduced_not_alone) 13393 << FirstNonDeducedAutoInGroup->getType() 13394 ->hasAutoForTrailingReturnType() 13395 << FirstDeclaratorInGroup->getSourceRange() 13396 << DD->getSourceRange(); 13397 DiagnosedNonDeducedAuto = true; 13398 } 13399 } 13400 } 13401 13402 Decls.push_back(D); 13403 } 13404 } 13405 13406 if (DeclSpec::isDeclRep(DS.getTypeSpecType())) { 13407 if (TagDecl *Tag = dyn_cast_or_null<TagDecl>(DS.getRepAsDecl())) { 13408 handleTagNumbering(Tag, S); 13409 if (FirstDeclaratorInGroup && !Tag->hasNameForLinkage() && 13410 getLangOpts().CPlusPlus) 13411 Context.addDeclaratorForUnnamedTagDecl(Tag, FirstDeclaratorInGroup); 13412 } 13413 } 13414 13415 return BuildDeclaratorGroup(Decls); 13416 } 13417 13418 /// BuildDeclaratorGroup - convert a list of declarations into a declaration 13419 /// group, performing any necessary semantic checking. 13420 Sema::DeclGroupPtrTy 13421 Sema::BuildDeclaratorGroup(MutableArrayRef<Decl *> Group) { 13422 // C++14 [dcl.spec.auto]p7: (DR1347) 13423 // If the type that replaces the placeholder type is not the same in each 13424 // deduction, the program is ill-formed. 13425 if (Group.size() > 1) { 13426 QualType Deduced; 13427 VarDecl *DeducedDecl = nullptr; 13428 for (unsigned i = 0, e = Group.size(); i != e; ++i) { 13429 VarDecl *D = dyn_cast<VarDecl>(Group[i]); 13430 if (!D || D->isInvalidDecl()) 13431 break; 13432 DeducedType *DT = D->getType()->getContainedDeducedType(); 13433 if (!DT || DT->getDeducedType().isNull()) 13434 continue; 13435 if (Deduced.isNull()) { 13436 Deduced = DT->getDeducedType(); 13437 DeducedDecl = D; 13438 } else if (!Context.hasSameType(DT->getDeducedType(), Deduced)) { 13439 auto *AT = dyn_cast<AutoType>(DT); 13440 auto Dia = Diag(D->getTypeSourceInfo()->getTypeLoc().getBeginLoc(), 13441 diag::err_auto_different_deductions) 13442 << (AT ? (unsigned)AT->getKeyword() : 3) << Deduced 13443 << DeducedDecl->getDeclName() << DT->getDeducedType() 13444 << D->getDeclName(); 13445 if (DeducedDecl->hasInit()) 13446 Dia << DeducedDecl->getInit()->getSourceRange(); 13447 if (D->getInit()) 13448 Dia << D->getInit()->getSourceRange(); 13449 D->setInvalidDecl(); 13450 break; 13451 } 13452 } 13453 } 13454 13455 ActOnDocumentableDecls(Group); 13456 13457 return DeclGroupPtrTy::make( 13458 DeclGroupRef::Create(Context, Group.data(), Group.size())); 13459 } 13460 13461 void Sema::ActOnDocumentableDecl(Decl *D) { 13462 ActOnDocumentableDecls(D); 13463 } 13464 13465 void Sema::ActOnDocumentableDecls(ArrayRef<Decl *> Group) { 13466 // Don't parse the comment if Doxygen diagnostics are ignored. 13467 if (Group.empty() || !Group[0]) 13468 return; 13469 13470 if (Diags.isIgnored(diag::warn_doc_param_not_found, 13471 Group[0]->getLocation()) && 13472 Diags.isIgnored(diag::warn_unknown_comment_command_name, 13473 Group[0]->getLocation())) 13474 return; 13475 13476 if (Group.size() >= 2) { 13477 // This is a decl group. Normally it will contain only declarations 13478 // produced from declarator list. But in case we have any definitions or 13479 // additional declaration references: 13480 // 'typedef struct S {} S;' 13481 // 'typedef struct S *S;' 13482 // 'struct S *pS;' 13483 // FinalizeDeclaratorGroup adds these as separate declarations. 13484 Decl *MaybeTagDecl = Group[0]; 13485 if (MaybeTagDecl && isa<TagDecl>(MaybeTagDecl)) { 13486 Group = Group.slice(1); 13487 } 13488 } 13489 13490 // FIMXE: We assume every Decl in the group is in the same file. 13491 // This is false when preprocessor constructs the group from decls in 13492 // different files (e. g. macros or #include). 13493 Context.attachCommentsToJustParsedDecls(Group, &getPreprocessor()); 13494 } 13495 13496 /// Common checks for a parameter-declaration that should apply to both function 13497 /// parameters and non-type template parameters. 13498 void Sema::CheckFunctionOrTemplateParamDeclarator(Scope *S, Declarator &D) { 13499 // Check that there are no default arguments inside the type of this 13500 // parameter. 13501 if (getLangOpts().CPlusPlus) 13502 CheckExtraCXXDefaultArguments(D); 13503 13504 // Parameter declarators cannot be qualified (C++ [dcl.meaning]p1). 13505 if (D.getCXXScopeSpec().isSet()) { 13506 Diag(D.getIdentifierLoc(), diag::err_qualified_param_declarator) 13507 << D.getCXXScopeSpec().getRange(); 13508 } 13509 13510 // [dcl.meaning]p1: An unqualified-id occurring in a declarator-id shall be a 13511 // simple identifier except [...irrelevant cases...]. 13512 switch (D.getName().getKind()) { 13513 case UnqualifiedIdKind::IK_Identifier: 13514 break; 13515 13516 case UnqualifiedIdKind::IK_OperatorFunctionId: 13517 case UnqualifiedIdKind::IK_ConversionFunctionId: 13518 case UnqualifiedIdKind::IK_LiteralOperatorId: 13519 case UnqualifiedIdKind::IK_ConstructorName: 13520 case UnqualifiedIdKind::IK_DestructorName: 13521 case UnqualifiedIdKind::IK_ImplicitSelfParam: 13522 case UnqualifiedIdKind::IK_DeductionGuideName: 13523 Diag(D.getIdentifierLoc(), diag::err_bad_parameter_name) 13524 << GetNameForDeclarator(D).getName(); 13525 break; 13526 13527 case UnqualifiedIdKind::IK_TemplateId: 13528 case UnqualifiedIdKind::IK_ConstructorTemplateId: 13529 // GetNameForDeclarator would not produce a useful name in this case. 13530 Diag(D.getIdentifierLoc(), diag::err_bad_parameter_name_template_id); 13531 break; 13532 } 13533 } 13534 13535 /// ActOnParamDeclarator - Called from Parser::ParseFunctionDeclarator() 13536 /// to introduce parameters into function prototype scope. 13537 Decl *Sema::ActOnParamDeclarator(Scope *S, Declarator &D) { 13538 const DeclSpec &DS = D.getDeclSpec(); 13539 13540 // Verify C99 6.7.5.3p2: The only SCS allowed is 'register'. 13541 13542 // C++03 [dcl.stc]p2 also permits 'auto'. 13543 StorageClass SC = SC_None; 13544 if (DS.getStorageClassSpec() == DeclSpec::SCS_register) { 13545 SC = SC_Register; 13546 // In C++11, the 'register' storage class specifier is deprecated. 13547 // In C++17, it is not allowed, but we tolerate it as an extension. 13548 if (getLangOpts().CPlusPlus11) { 13549 Diag(DS.getStorageClassSpecLoc(), 13550 getLangOpts().CPlusPlus17 ? diag::ext_register_storage_class 13551 : diag::warn_deprecated_register) 13552 << FixItHint::CreateRemoval(DS.getStorageClassSpecLoc()); 13553 } 13554 } else if (getLangOpts().CPlusPlus && 13555 DS.getStorageClassSpec() == DeclSpec::SCS_auto) { 13556 SC = SC_Auto; 13557 } else if (DS.getStorageClassSpec() != DeclSpec::SCS_unspecified) { 13558 Diag(DS.getStorageClassSpecLoc(), 13559 diag::err_invalid_storage_class_in_func_decl); 13560 D.getMutableDeclSpec().ClearStorageClassSpecs(); 13561 } 13562 13563 if (DeclSpec::TSCS TSCS = DS.getThreadStorageClassSpec()) 13564 Diag(DS.getThreadStorageClassSpecLoc(), diag::err_invalid_thread) 13565 << DeclSpec::getSpecifierName(TSCS); 13566 if (DS.isInlineSpecified()) 13567 Diag(DS.getInlineSpecLoc(), diag::err_inline_non_function) 13568 << getLangOpts().CPlusPlus17; 13569 if (DS.hasConstexprSpecifier()) 13570 Diag(DS.getConstexprSpecLoc(), diag::err_invalid_constexpr) 13571 << 0 << static_cast<int>(D.getDeclSpec().getConstexprSpecifier()); 13572 13573 DiagnoseFunctionSpecifiers(DS); 13574 13575 CheckFunctionOrTemplateParamDeclarator(S, D); 13576 13577 TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S); 13578 QualType parmDeclType = TInfo->getType(); 13579 13580 // Check for redeclaration of parameters, e.g. int foo(int x, int x); 13581 IdentifierInfo *II = D.getIdentifier(); 13582 if (II) { 13583 LookupResult R(*this, II, D.getIdentifierLoc(), LookupOrdinaryName, 13584 ForVisibleRedeclaration); 13585 LookupName(R, S); 13586 if (R.isSingleResult()) { 13587 NamedDecl *PrevDecl = R.getFoundDecl(); 13588 if (PrevDecl->isTemplateParameter()) { 13589 // Maybe we will complain about the shadowed template parameter. 13590 DiagnoseTemplateParameterShadow(D.getIdentifierLoc(), PrevDecl); 13591 // Just pretend that we didn't see the previous declaration. 13592 PrevDecl = nullptr; 13593 } else if (S->isDeclScope(PrevDecl)) { 13594 Diag(D.getIdentifierLoc(), diag::err_param_redefinition) << II; 13595 Diag(PrevDecl->getLocation(), diag::note_previous_declaration); 13596 13597 // Recover by removing the name 13598 II = nullptr; 13599 D.SetIdentifier(nullptr, D.getIdentifierLoc()); 13600 D.setInvalidType(true); 13601 } 13602 } 13603 } 13604 13605 // Temporarily put parameter variables in the translation unit, not 13606 // the enclosing context. This prevents them from accidentally 13607 // looking like class members in C++. 13608 ParmVarDecl *New = 13609 CheckParameter(Context.getTranslationUnitDecl(), D.getBeginLoc(), 13610 D.getIdentifierLoc(), II, parmDeclType, TInfo, SC); 13611 13612 if (D.isInvalidType()) 13613 New->setInvalidDecl(); 13614 13615 assert(S->isFunctionPrototypeScope()); 13616 assert(S->getFunctionPrototypeDepth() >= 1); 13617 New->setScopeInfo(S->getFunctionPrototypeDepth() - 1, 13618 S->getNextFunctionPrototypeIndex()); 13619 13620 // Add the parameter declaration into this scope. 13621 S->AddDecl(New); 13622 if (II) 13623 IdResolver.AddDecl(New); 13624 13625 ProcessDeclAttributes(S, New, D); 13626 13627 if (D.getDeclSpec().isModulePrivateSpecified()) 13628 Diag(New->getLocation(), diag::err_module_private_local) 13629 << 1 << New << SourceRange(D.getDeclSpec().getModulePrivateSpecLoc()) 13630 << FixItHint::CreateRemoval(D.getDeclSpec().getModulePrivateSpecLoc()); 13631 13632 if (New->hasAttr<BlocksAttr>()) { 13633 Diag(New->getLocation(), diag::err_block_on_nonlocal); 13634 } 13635 13636 if (getLangOpts().OpenCL) 13637 deduceOpenCLAddressSpace(New); 13638 13639 return New; 13640 } 13641 13642 /// Synthesizes a variable for a parameter arising from a 13643 /// typedef. 13644 ParmVarDecl *Sema::BuildParmVarDeclForTypedef(DeclContext *DC, 13645 SourceLocation Loc, 13646 QualType T) { 13647 /* FIXME: setting StartLoc == Loc. 13648 Would it be worth to modify callers so as to provide proper source 13649 location for the unnamed parameters, embedding the parameter's type? */ 13650 ParmVarDecl *Param = ParmVarDecl::Create(Context, DC, Loc, Loc, nullptr, 13651 T, Context.getTrivialTypeSourceInfo(T, Loc), 13652 SC_None, nullptr); 13653 Param->setImplicit(); 13654 return Param; 13655 } 13656 13657 void Sema::DiagnoseUnusedParameters(ArrayRef<ParmVarDecl *> Parameters) { 13658 // Don't diagnose unused-parameter errors in template instantiations; we 13659 // will already have done so in the template itself. 13660 if (inTemplateInstantiation()) 13661 return; 13662 13663 for (const ParmVarDecl *Parameter : Parameters) { 13664 if (!Parameter->isReferenced() && Parameter->getDeclName() && 13665 !Parameter->hasAttr<UnusedAttr>()) { 13666 Diag(Parameter->getLocation(), diag::warn_unused_parameter) 13667 << Parameter->getDeclName(); 13668 } 13669 } 13670 } 13671 13672 void Sema::DiagnoseSizeOfParametersAndReturnValue( 13673 ArrayRef<ParmVarDecl *> Parameters, QualType ReturnTy, NamedDecl *D) { 13674 if (LangOpts.NumLargeByValueCopy == 0) // No check. 13675 return; 13676 13677 // Warn if the return value is pass-by-value and larger than the specified 13678 // threshold. 13679 if (!ReturnTy->isDependentType() && ReturnTy.isPODType(Context)) { 13680 unsigned Size = Context.getTypeSizeInChars(ReturnTy).getQuantity(); 13681 if (Size > LangOpts.NumLargeByValueCopy) 13682 Diag(D->getLocation(), diag::warn_return_value_size) << D << Size; 13683 } 13684 13685 // Warn if any parameter is pass-by-value and larger than the specified 13686 // threshold. 13687 for (const ParmVarDecl *Parameter : Parameters) { 13688 QualType T = Parameter->getType(); 13689 if (T->isDependentType() || !T.isPODType(Context)) 13690 continue; 13691 unsigned Size = Context.getTypeSizeInChars(T).getQuantity(); 13692 if (Size > LangOpts.NumLargeByValueCopy) 13693 Diag(Parameter->getLocation(), diag::warn_parameter_size) 13694 << Parameter << Size; 13695 } 13696 } 13697 13698 ParmVarDecl *Sema::CheckParameter(DeclContext *DC, SourceLocation StartLoc, 13699 SourceLocation NameLoc, IdentifierInfo *Name, 13700 QualType T, TypeSourceInfo *TSInfo, 13701 StorageClass SC) { 13702 // In ARC, infer a lifetime qualifier for appropriate parameter types. 13703 if (getLangOpts().ObjCAutoRefCount && 13704 T.getObjCLifetime() == Qualifiers::OCL_None && 13705 T->isObjCLifetimeType()) { 13706 13707 Qualifiers::ObjCLifetime lifetime; 13708 13709 // Special cases for arrays: 13710 // - if it's const, use __unsafe_unretained 13711 // - otherwise, it's an error 13712 if (T->isArrayType()) { 13713 if (!T.isConstQualified()) { 13714 if (DelayedDiagnostics.shouldDelayDiagnostics()) 13715 DelayedDiagnostics.add( 13716 sema::DelayedDiagnostic::makeForbiddenType( 13717 NameLoc, diag::err_arc_array_param_no_ownership, T, false)); 13718 else 13719 Diag(NameLoc, diag::err_arc_array_param_no_ownership) 13720 << TSInfo->getTypeLoc().getSourceRange(); 13721 } 13722 lifetime = Qualifiers::OCL_ExplicitNone; 13723 } else { 13724 lifetime = T->getObjCARCImplicitLifetime(); 13725 } 13726 T = Context.getLifetimeQualifiedType(T, lifetime); 13727 } 13728 13729 ParmVarDecl *New = ParmVarDecl::Create(Context, DC, StartLoc, NameLoc, Name, 13730 Context.getAdjustedParameterType(T), 13731 TSInfo, SC, nullptr); 13732 13733 // Make a note if we created a new pack in the scope of a lambda, so that 13734 // we know that references to that pack must also be expanded within the 13735 // lambda scope. 13736 if (New->isParameterPack()) 13737 if (auto *LSI = getEnclosingLambda()) 13738 LSI->LocalPacks.push_back(New); 13739 13740 if (New->getType().hasNonTrivialToPrimitiveDestructCUnion() || 13741 New->getType().hasNonTrivialToPrimitiveCopyCUnion()) 13742 checkNonTrivialCUnion(New->getType(), New->getLocation(), 13743 NTCUC_FunctionParam, NTCUK_Destruct|NTCUK_Copy); 13744 13745 // Parameters can not be abstract class types. 13746 // For record types, this is done by the AbstractClassUsageDiagnoser once 13747 // the class has been completely parsed. 13748 if (!CurContext->isRecord() && 13749 RequireNonAbstractType(NameLoc, T, diag::err_abstract_type_in_decl, 13750 AbstractParamType)) 13751 New->setInvalidDecl(); 13752 13753 // Parameter declarators cannot be interface types. All ObjC objects are 13754 // passed by reference. 13755 if (T->isObjCObjectType()) { 13756 SourceLocation TypeEndLoc = 13757 getLocForEndOfToken(TSInfo->getTypeLoc().getEndLoc()); 13758 Diag(NameLoc, 13759 diag::err_object_cannot_be_passed_returned_by_value) << 1 << T 13760 << FixItHint::CreateInsertion(TypeEndLoc, "*"); 13761 T = Context.getObjCObjectPointerType(T); 13762 New->setType(T); 13763 } 13764 13765 // ISO/IEC TR 18037 S6.7.3: "The type of an object with automatic storage 13766 // duration shall not be qualified by an address-space qualifier." 13767 // Since all parameters have automatic store duration, they can not have 13768 // an address space. 13769 if (T.getAddressSpace() != LangAS::Default && 13770 // OpenCL allows function arguments declared to be an array of a type 13771 // to be qualified with an address space. 13772 !(getLangOpts().OpenCL && 13773 (T->isArrayType() || T.getAddressSpace() == LangAS::opencl_private))) { 13774 Diag(NameLoc, diag::err_arg_with_address_space); 13775 New->setInvalidDecl(); 13776 } 13777 13778 // PPC MMA non-pointer types are not allowed as function argument types. 13779 if (Context.getTargetInfo().getTriple().isPPC64() && 13780 CheckPPCMMAType(New->getOriginalType(), New->getLocation())) { 13781 New->setInvalidDecl(); 13782 } 13783 13784 return New; 13785 } 13786 13787 void Sema::ActOnFinishKNRParamDeclarations(Scope *S, Declarator &D, 13788 SourceLocation LocAfterDecls) { 13789 DeclaratorChunk::FunctionTypeInfo &FTI = D.getFunctionTypeInfo(); 13790 13791 // Verify 6.9.1p6: 'every identifier in the identifier list shall be declared' 13792 // for a K&R function. 13793 if (!FTI.hasPrototype) { 13794 for (int i = FTI.NumParams; i != 0; /* decrement in loop */) { 13795 --i; 13796 if (FTI.Params[i].Param == nullptr) { 13797 SmallString<256> Code; 13798 llvm::raw_svector_ostream(Code) 13799 << " int " << FTI.Params[i].Ident->getName() << ";\n"; 13800 Diag(FTI.Params[i].IdentLoc, diag::ext_param_not_declared) 13801 << FTI.Params[i].Ident 13802 << FixItHint::CreateInsertion(LocAfterDecls, Code); 13803 13804 // Implicitly declare the argument as type 'int' for lack of a better 13805 // type. 13806 AttributeFactory attrs; 13807 DeclSpec DS(attrs); 13808 const char* PrevSpec; // unused 13809 unsigned DiagID; // unused 13810 DS.SetTypeSpecType(DeclSpec::TST_int, FTI.Params[i].IdentLoc, PrevSpec, 13811 DiagID, Context.getPrintingPolicy()); 13812 // Use the identifier location for the type source range. 13813 DS.SetRangeStart(FTI.Params[i].IdentLoc); 13814 DS.SetRangeEnd(FTI.Params[i].IdentLoc); 13815 Declarator ParamD(DS, DeclaratorContext::KNRTypeList); 13816 ParamD.SetIdentifier(FTI.Params[i].Ident, FTI.Params[i].IdentLoc); 13817 FTI.Params[i].Param = ActOnParamDeclarator(S, ParamD); 13818 } 13819 } 13820 } 13821 } 13822 13823 Decl * 13824 Sema::ActOnStartOfFunctionDef(Scope *FnBodyScope, Declarator &D, 13825 MultiTemplateParamsArg TemplateParameterLists, 13826 SkipBodyInfo *SkipBody) { 13827 assert(getCurFunctionDecl() == nullptr && "Function parsing confused"); 13828 assert(D.isFunctionDeclarator() && "Not a function declarator!"); 13829 Scope *ParentScope = FnBodyScope->getParent(); 13830 13831 // Check if we are in an `omp begin/end declare variant` scope. If we are, and 13832 // we define a non-templated function definition, we will create a declaration 13833 // instead (=BaseFD), and emit the definition with a mangled name afterwards. 13834 // The base function declaration will have the equivalent of an `omp declare 13835 // variant` annotation which specifies the mangled definition as a 13836 // specialization function under the OpenMP context defined as part of the 13837 // `omp begin declare variant`. 13838 SmallVector<FunctionDecl *, 4> Bases; 13839 if (LangOpts.OpenMP && isInOpenMPDeclareVariantScope()) 13840 ActOnStartOfFunctionDefinitionInOpenMPDeclareVariantScope( 13841 ParentScope, D, TemplateParameterLists, Bases); 13842 13843 D.setFunctionDefinitionKind(FunctionDefinitionKind::Definition); 13844 Decl *DP = HandleDeclarator(ParentScope, D, TemplateParameterLists); 13845 Decl *Dcl = ActOnStartOfFunctionDef(FnBodyScope, DP, SkipBody); 13846 13847 if (!Bases.empty()) 13848 ActOnFinishedFunctionDefinitionInOpenMPDeclareVariantScope(Dcl, Bases); 13849 13850 return Dcl; 13851 } 13852 13853 void Sema::ActOnFinishInlineFunctionDef(FunctionDecl *D) { 13854 Consumer.HandleInlineFunctionDefinition(D); 13855 } 13856 13857 static bool 13858 ShouldWarnAboutMissingPrototype(const FunctionDecl *FD, 13859 const FunctionDecl *&PossiblePrototype) { 13860 // Don't warn about invalid declarations. 13861 if (FD->isInvalidDecl()) 13862 return false; 13863 13864 // Or declarations that aren't global. 13865 if (!FD->isGlobal()) 13866 return false; 13867 13868 // Don't warn about C++ member functions. 13869 if (isa<CXXMethodDecl>(FD)) 13870 return false; 13871 13872 // Don't warn about 'main'. 13873 if (isa<TranslationUnitDecl>(FD->getDeclContext()->getRedeclContext())) 13874 if (IdentifierInfo *II = FD->getIdentifier()) 13875 if (II->isStr("main")) 13876 return false; 13877 13878 // Don't warn about inline functions. 13879 if (FD->isInlined()) 13880 return false; 13881 13882 // Don't warn about function templates. 13883 if (FD->getDescribedFunctionTemplate()) 13884 return false; 13885 13886 // Don't warn about function template specializations. 13887 if (FD->isFunctionTemplateSpecialization()) 13888 return false; 13889 13890 // Don't warn for OpenCL kernels. 13891 if (FD->hasAttr<OpenCLKernelAttr>()) 13892 return false; 13893 13894 // Don't warn on explicitly deleted functions. 13895 if (FD->isDeleted()) 13896 return false; 13897 13898 for (const FunctionDecl *Prev = FD->getPreviousDecl(); 13899 Prev; Prev = Prev->getPreviousDecl()) { 13900 // Ignore any declarations that occur in function or method 13901 // scope, because they aren't visible from the header. 13902 if (Prev->getLexicalDeclContext()->isFunctionOrMethod()) 13903 continue; 13904 13905 PossiblePrototype = Prev; 13906 return Prev->getType()->isFunctionNoProtoType(); 13907 } 13908 13909 return true; 13910 } 13911 13912 void 13913 Sema::CheckForFunctionRedefinition(FunctionDecl *FD, 13914 const FunctionDecl *EffectiveDefinition, 13915 SkipBodyInfo *SkipBody) { 13916 const FunctionDecl *Definition = EffectiveDefinition; 13917 if (!Definition && 13918 !FD->isDefined(Definition, /*CheckForPendingFriendDefinition*/ true)) 13919 return; 13920 13921 if (Definition->getFriendObjectKind() != Decl::FOK_None) { 13922 if (FunctionDecl *OrigDef = Definition->getInstantiatedFromMemberFunction()) { 13923 if (FunctionDecl *OrigFD = FD->getInstantiatedFromMemberFunction()) { 13924 // A merged copy of the same function, instantiated as a member of 13925 // the same class, is OK. 13926 if (declaresSameEntity(OrigFD, OrigDef) && 13927 declaresSameEntity(cast<Decl>(Definition->getLexicalDeclContext()), 13928 cast<Decl>(FD->getLexicalDeclContext()))) 13929 return; 13930 } 13931 } 13932 } 13933 13934 if (canRedefineFunction(Definition, getLangOpts())) 13935 return; 13936 13937 // Don't emit an error when this is redefinition of a typo-corrected 13938 // definition. 13939 if (TypoCorrectedFunctionDefinitions.count(Definition)) 13940 return; 13941 13942 // If we don't have a visible definition of the function, and it's inline or 13943 // a template, skip the new definition. 13944 if (SkipBody && !hasVisibleDefinition(Definition) && 13945 (Definition->getFormalLinkage() == InternalLinkage || 13946 Definition->isInlined() || 13947 Definition->getDescribedFunctionTemplate() || 13948 Definition->getNumTemplateParameterLists())) { 13949 SkipBody->ShouldSkip = true; 13950 SkipBody->Previous = const_cast<FunctionDecl*>(Definition); 13951 if (auto *TD = Definition->getDescribedFunctionTemplate()) 13952 makeMergedDefinitionVisible(TD); 13953 makeMergedDefinitionVisible(const_cast<FunctionDecl*>(Definition)); 13954 return; 13955 } 13956 13957 if (getLangOpts().GNUMode && Definition->isInlineSpecified() && 13958 Definition->getStorageClass() == SC_Extern) 13959 Diag(FD->getLocation(), diag::err_redefinition_extern_inline) 13960 << FD << getLangOpts().CPlusPlus; 13961 else 13962 Diag(FD->getLocation(), diag::err_redefinition) << FD; 13963 13964 Diag(Definition->getLocation(), diag::note_previous_definition); 13965 FD->setInvalidDecl(); 13966 } 13967 13968 static void RebuildLambdaScopeInfo(CXXMethodDecl *CallOperator, 13969 Sema &S) { 13970 CXXRecordDecl *const LambdaClass = CallOperator->getParent(); 13971 13972 LambdaScopeInfo *LSI = S.PushLambdaScope(); 13973 LSI->CallOperator = CallOperator; 13974 LSI->Lambda = LambdaClass; 13975 LSI->ReturnType = CallOperator->getReturnType(); 13976 const LambdaCaptureDefault LCD = LambdaClass->getLambdaCaptureDefault(); 13977 13978 if (LCD == LCD_None) 13979 LSI->ImpCaptureStyle = CapturingScopeInfo::ImpCap_None; 13980 else if (LCD == LCD_ByCopy) 13981 LSI->ImpCaptureStyle = CapturingScopeInfo::ImpCap_LambdaByval; 13982 else if (LCD == LCD_ByRef) 13983 LSI->ImpCaptureStyle = CapturingScopeInfo::ImpCap_LambdaByref; 13984 DeclarationNameInfo DNI = CallOperator->getNameInfo(); 13985 13986 LSI->IntroducerRange = DNI.getCXXOperatorNameRange(); 13987 LSI->Mutable = !CallOperator->isConst(); 13988 13989 // Add the captures to the LSI so they can be noted as already 13990 // captured within tryCaptureVar. 13991 auto I = LambdaClass->field_begin(); 13992 for (const auto &C : LambdaClass->captures()) { 13993 if (C.capturesVariable()) { 13994 VarDecl *VD = C.getCapturedVar(); 13995 if (VD->isInitCapture()) 13996 S.CurrentInstantiationScope->InstantiatedLocal(VD, VD); 13997 const bool ByRef = C.getCaptureKind() == LCK_ByRef; 13998 LSI->addCapture(VD, /*IsBlock*/false, ByRef, 13999 /*RefersToEnclosingVariableOrCapture*/true, C.getLocation(), 14000 /*EllipsisLoc*/C.isPackExpansion() 14001 ? C.getEllipsisLoc() : SourceLocation(), 14002 I->getType(), /*Invalid*/false); 14003 14004 } else if (C.capturesThis()) { 14005 LSI->addThisCapture(/*Nested*/ false, C.getLocation(), I->getType(), 14006 C.getCaptureKind() == LCK_StarThis); 14007 } else { 14008 LSI->addVLATypeCapture(C.getLocation(), I->getCapturedVLAType(), 14009 I->getType()); 14010 } 14011 ++I; 14012 } 14013 } 14014 14015 Decl *Sema::ActOnStartOfFunctionDef(Scope *FnBodyScope, Decl *D, 14016 SkipBodyInfo *SkipBody) { 14017 if (!D) { 14018 // Parsing the function declaration failed in some way. Push on a fake scope 14019 // anyway so we can try to parse the function body. 14020 PushFunctionScope(); 14021 PushExpressionEvaluationContext(ExprEvalContexts.back().Context); 14022 return D; 14023 } 14024 14025 FunctionDecl *FD = nullptr; 14026 14027 if (FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(D)) 14028 FD = FunTmpl->getTemplatedDecl(); 14029 else 14030 FD = cast<FunctionDecl>(D); 14031 14032 // Do not push if it is a lambda because one is already pushed when building 14033 // the lambda in ActOnStartOfLambdaDefinition(). 14034 if (!isLambdaCallOperator(FD)) 14035 PushExpressionEvaluationContext( 14036 FD->isConsteval() ? ExpressionEvaluationContext::ConstantEvaluated 14037 : ExprEvalContexts.back().Context); 14038 14039 // Check for defining attributes before the check for redefinition. 14040 if (const auto *Attr = FD->getAttr<AliasAttr>()) { 14041 Diag(Attr->getLocation(), diag::err_alias_is_definition) << FD << 0; 14042 FD->dropAttr<AliasAttr>(); 14043 FD->setInvalidDecl(); 14044 } 14045 if (const auto *Attr = FD->getAttr<IFuncAttr>()) { 14046 Diag(Attr->getLocation(), diag::err_alias_is_definition) << FD << 1; 14047 FD->dropAttr<IFuncAttr>(); 14048 FD->setInvalidDecl(); 14049 } 14050 14051 if (auto *Ctor = dyn_cast<CXXConstructorDecl>(FD)) { 14052 if (Ctor->getTemplateSpecializationKind() == TSK_ExplicitSpecialization && 14053 Ctor->isDefaultConstructor() && 14054 Context.getTargetInfo().getCXXABI().isMicrosoft()) { 14055 // If this is an MS ABI dllexport default constructor, instantiate any 14056 // default arguments. 14057 InstantiateDefaultCtorDefaultArgs(Ctor); 14058 } 14059 } 14060 14061 // See if this is a redefinition. If 'will have body' (or similar) is already 14062 // set, then these checks were already performed when it was set. 14063 if (!FD->willHaveBody() && !FD->isLateTemplateParsed() && 14064 !FD->isThisDeclarationInstantiatedFromAFriendDefinition()) { 14065 CheckForFunctionRedefinition(FD, nullptr, SkipBody); 14066 14067 // If we're skipping the body, we're done. Don't enter the scope. 14068 if (SkipBody && SkipBody->ShouldSkip) 14069 return D; 14070 } 14071 14072 // Mark this function as "will have a body eventually". This lets users to 14073 // call e.g. isInlineDefinitionExternallyVisible while we're still parsing 14074 // this function. 14075 FD->setWillHaveBody(); 14076 14077 // If we are instantiating a generic lambda call operator, push 14078 // a LambdaScopeInfo onto the function stack. But use the information 14079 // that's already been calculated (ActOnLambdaExpr) to prime the current 14080 // LambdaScopeInfo. 14081 // When the template operator is being specialized, the LambdaScopeInfo, 14082 // has to be properly restored so that tryCaptureVariable doesn't try 14083 // and capture any new variables. In addition when calculating potential 14084 // captures during transformation of nested lambdas, it is necessary to 14085 // have the LSI properly restored. 14086 if (isGenericLambdaCallOperatorSpecialization(FD)) { 14087 assert(inTemplateInstantiation() && 14088 "There should be an active template instantiation on the stack " 14089 "when instantiating a generic lambda!"); 14090 RebuildLambdaScopeInfo(cast<CXXMethodDecl>(D), *this); 14091 } else { 14092 // Enter a new function scope 14093 PushFunctionScope(); 14094 } 14095 14096 // Builtin functions cannot be defined. 14097 if (unsigned BuiltinID = FD->getBuiltinID()) { 14098 if (!Context.BuiltinInfo.isPredefinedLibFunction(BuiltinID) && 14099 !Context.BuiltinInfo.isPredefinedRuntimeFunction(BuiltinID)) { 14100 Diag(FD->getLocation(), diag::err_builtin_definition) << FD; 14101 FD->setInvalidDecl(); 14102 } 14103 } 14104 14105 // The return type of a function definition must be complete 14106 // (C99 6.9.1p3, C++ [dcl.fct]p6). 14107 QualType ResultType = FD->getReturnType(); 14108 if (!ResultType->isDependentType() && !ResultType->isVoidType() && 14109 !FD->isInvalidDecl() && 14110 RequireCompleteType(FD->getLocation(), ResultType, 14111 diag::err_func_def_incomplete_result)) 14112 FD->setInvalidDecl(); 14113 14114 if (FnBodyScope) 14115 PushDeclContext(FnBodyScope, FD); 14116 14117 // Check the validity of our function parameters 14118 CheckParmsForFunctionDef(FD->parameters(), 14119 /*CheckParameterNames=*/true); 14120 14121 // Add non-parameter declarations already in the function to the current 14122 // scope. 14123 if (FnBodyScope) { 14124 for (Decl *NPD : FD->decls()) { 14125 auto *NonParmDecl = dyn_cast<NamedDecl>(NPD); 14126 if (!NonParmDecl) 14127 continue; 14128 assert(!isa<ParmVarDecl>(NonParmDecl) && 14129 "parameters should not be in newly created FD yet"); 14130 14131 // If the decl has a name, make it accessible in the current scope. 14132 if (NonParmDecl->getDeclName()) 14133 PushOnScopeChains(NonParmDecl, FnBodyScope, /*AddToContext=*/false); 14134 14135 // Similarly, dive into enums and fish their constants out, making them 14136 // accessible in this scope. 14137 if (auto *ED = dyn_cast<EnumDecl>(NonParmDecl)) { 14138 for (auto *EI : ED->enumerators()) 14139 PushOnScopeChains(EI, FnBodyScope, /*AddToContext=*/false); 14140 } 14141 } 14142 } 14143 14144 // Introduce our parameters into the function scope 14145 for (auto Param : FD->parameters()) { 14146 Param->setOwningFunction(FD); 14147 14148 // If this has an identifier, add it to the scope stack. 14149 if (Param->getIdentifier() && FnBodyScope) { 14150 CheckShadow(FnBodyScope, Param); 14151 14152 PushOnScopeChains(Param, FnBodyScope); 14153 } 14154 } 14155 14156 // Ensure that the function's exception specification is instantiated. 14157 if (const FunctionProtoType *FPT = FD->getType()->getAs<FunctionProtoType>()) 14158 ResolveExceptionSpec(D->getLocation(), FPT); 14159 14160 // dllimport cannot be applied to non-inline function definitions. 14161 if (FD->hasAttr<DLLImportAttr>() && !FD->isInlined() && 14162 !FD->isTemplateInstantiation()) { 14163 assert(!FD->hasAttr<DLLExportAttr>()); 14164 Diag(FD->getLocation(), diag::err_attribute_dllimport_function_definition); 14165 FD->setInvalidDecl(); 14166 return D; 14167 } 14168 // We want to attach documentation to original Decl (which might be 14169 // a function template). 14170 ActOnDocumentableDecl(D); 14171 if (getCurLexicalContext()->isObjCContainer() && 14172 getCurLexicalContext()->getDeclKind() != Decl::ObjCCategoryImpl && 14173 getCurLexicalContext()->getDeclKind() != Decl::ObjCImplementation) 14174 Diag(FD->getLocation(), diag::warn_function_def_in_objc_container); 14175 14176 return D; 14177 } 14178 14179 /// Given the set of return statements within a function body, 14180 /// compute the variables that are subject to the named return value 14181 /// optimization. 14182 /// 14183 /// Each of the variables that is subject to the named return value 14184 /// optimization will be marked as NRVO variables in the AST, and any 14185 /// return statement that has a marked NRVO variable as its NRVO candidate can 14186 /// use the named return value optimization. 14187 /// 14188 /// This function applies a very simplistic algorithm for NRVO: if every return 14189 /// statement in the scope of a variable has the same NRVO candidate, that 14190 /// candidate is an NRVO variable. 14191 void Sema::computeNRVO(Stmt *Body, FunctionScopeInfo *Scope) { 14192 ReturnStmt **Returns = Scope->Returns.data(); 14193 14194 for (unsigned I = 0, E = Scope->Returns.size(); I != E; ++I) { 14195 if (const VarDecl *NRVOCandidate = Returns[I]->getNRVOCandidate()) { 14196 if (!NRVOCandidate->isNRVOVariable()) 14197 Returns[I]->setNRVOCandidate(nullptr); 14198 } 14199 } 14200 } 14201 14202 bool Sema::canDelayFunctionBody(const Declarator &D) { 14203 // We can't delay parsing the body of a constexpr function template (yet). 14204 if (D.getDeclSpec().hasConstexprSpecifier()) 14205 return false; 14206 14207 // We can't delay parsing the body of a function template with a deduced 14208 // return type (yet). 14209 if (D.getDeclSpec().hasAutoTypeSpec()) { 14210 // If the placeholder introduces a non-deduced trailing return type, 14211 // we can still delay parsing it. 14212 if (D.getNumTypeObjects()) { 14213 const auto &Outer = D.getTypeObject(D.getNumTypeObjects() - 1); 14214 if (Outer.Kind == DeclaratorChunk::Function && 14215 Outer.Fun.hasTrailingReturnType()) { 14216 QualType Ty = GetTypeFromParser(Outer.Fun.getTrailingReturnType()); 14217 return Ty.isNull() || !Ty->isUndeducedType(); 14218 } 14219 } 14220 return false; 14221 } 14222 14223 return true; 14224 } 14225 14226 bool Sema::canSkipFunctionBody(Decl *D) { 14227 // We cannot skip the body of a function (or function template) which is 14228 // constexpr, since we may need to evaluate its body in order to parse the 14229 // rest of the file. 14230 // We cannot skip the body of a function with an undeduced return type, 14231 // because any callers of that function need to know the type. 14232 if (const FunctionDecl *FD = D->getAsFunction()) { 14233 if (FD->isConstexpr()) 14234 return false; 14235 // We can't simply call Type::isUndeducedType here, because inside template 14236 // auto can be deduced to a dependent type, which is not considered 14237 // "undeduced". 14238 if (FD->getReturnType()->getContainedDeducedType()) 14239 return false; 14240 } 14241 return Consumer.shouldSkipFunctionBody(D); 14242 } 14243 14244 Decl *Sema::ActOnSkippedFunctionBody(Decl *Decl) { 14245 if (!Decl) 14246 return nullptr; 14247 if (FunctionDecl *FD = Decl->getAsFunction()) 14248 FD->setHasSkippedBody(); 14249 else if (ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(Decl)) 14250 MD->setHasSkippedBody(); 14251 return Decl; 14252 } 14253 14254 Decl *Sema::ActOnFinishFunctionBody(Decl *D, Stmt *BodyArg) { 14255 return ActOnFinishFunctionBody(D, BodyArg, false); 14256 } 14257 14258 /// RAII object that pops an ExpressionEvaluationContext when exiting a function 14259 /// body. 14260 class ExitFunctionBodyRAII { 14261 public: 14262 ExitFunctionBodyRAII(Sema &S, bool IsLambda) : S(S), IsLambda(IsLambda) {} 14263 ~ExitFunctionBodyRAII() { 14264 if (!IsLambda) 14265 S.PopExpressionEvaluationContext(); 14266 } 14267 14268 private: 14269 Sema &S; 14270 bool IsLambda = false; 14271 }; 14272 14273 static void diagnoseImplicitlyRetainedSelf(Sema &S) { 14274 llvm::DenseMap<const BlockDecl *, bool> EscapeInfo; 14275 14276 auto IsOrNestedInEscapingBlock = [&](const BlockDecl *BD) { 14277 if (EscapeInfo.count(BD)) 14278 return EscapeInfo[BD]; 14279 14280 bool R = false; 14281 const BlockDecl *CurBD = BD; 14282 14283 do { 14284 R = !CurBD->doesNotEscape(); 14285 if (R) 14286 break; 14287 CurBD = CurBD->getParent()->getInnermostBlockDecl(); 14288 } while (CurBD); 14289 14290 return EscapeInfo[BD] = R; 14291 }; 14292 14293 // If the location where 'self' is implicitly retained is inside a escaping 14294 // block, emit a diagnostic. 14295 for (const std::pair<SourceLocation, const BlockDecl *> &P : 14296 S.ImplicitlyRetainedSelfLocs) 14297 if (IsOrNestedInEscapingBlock(P.second)) 14298 S.Diag(P.first, diag::warn_implicitly_retains_self) 14299 << FixItHint::CreateInsertion(P.first, "self->"); 14300 } 14301 14302 Decl *Sema::ActOnFinishFunctionBody(Decl *dcl, Stmt *Body, 14303 bool IsInstantiation) { 14304 FunctionScopeInfo *FSI = getCurFunction(); 14305 FunctionDecl *FD = dcl ? dcl->getAsFunction() : nullptr; 14306 14307 if (FSI->UsesFPIntrin && !FD->hasAttr<StrictFPAttr>()) 14308 FD->addAttr(StrictFPAttr::CreateImplicit(Context)); 14309 14310 sema::AnalysisBasedWarnings::Policy WP = AnalysisWarnings.getDefaultPolicy(); 14311 sema::AnalysisBasedWarnings::Policy *ActivePolicy = nullptr; 14312 14313 if (getLangOpts().Coroutines && FSI->isCoroutine()) 14314 CheckCompletedCoroutineBody(FD, Body); 14315 14316 // Do not call PopExpressionEvaluationContext() if it is a lambda because one 14317 // is already popped when finishing the lambda in BuildLambdaExpr(). This is 14318 // meant to pop the context added in ActOnStartOfFunctionDef(). 14319 ExitFunctionBodyRAII ExitRAII(*this, isLambdaCallOperator(FD)); 14320 14321 if (FD) { 14322 FD->setBody(Body); 14323 FD->setWillHaveBody(false); 14324 14325 if (getLangOpts().CPlusPlus14) { 14326 if (!FD->isInvalidDecl() && Body && !FD->isDependentContext() && 14327 FD->getReturnType()->isUndeducedType()) { 14328 // If the function has a deduced result type but contains no 'return' 14329 // statements, the result type as written must be exactly 'auto', and 14330 // the deduced result type is 'void'. 14331 if (!FD->getReturnType()->getAs<AutoType>()) { 14332 Diag(dcl->getLocation(), diag::err_auto_fn_no_return_but_not_auto) 14333 << FD->getReturnType(); 14334 FD->setInvalidDecl(); 14335 } else { 14336 // Substitute 'void' for the 'auto' in the type. 14337 TypeLoc ResultType = getReturnTypeLoc(FD); 14338 Context.adjustDeducedFunctionResultType( 14339 FD, SubstAutoType(ResultType.getType(), Context.VoidTy)); 14340 } 14341 } 14342 } else if (getLangOpts().CPlusPlus11 && isLambdaCallOperator(FD)) { 14343 // In C++11, we don't use 'auto' deduction rules for lambda call 14344 // operators because we don't support return type deduction. 14345 auto *LSI = getCurLambda(); 14346 if (LSI->HasImplicitReturnType) { 14347 deduceClosureReturnType(*LSI); 14348 14349 // C++11 [expr.prim.lambda]p4: 14350 // [...] if there are no return statements in the compound-statement 14351 // [the deduced type is] the type void 14352 QualType RetType = 14353 LSI->ReturnType.isNull() ? Context.VoidTy : LSI->ReturnType; 14354 14355 // Update the return type to the deduced type. 14356 const auto *Proto = FD->getType()->castAs<FunctionProtoType>(); 14357 FD->setType(Context.getFunctionType(RetType, Proto->getParamTypes(), 14358 Proto->getExtProtoInfo())); 14359 } 14360 } 14361 14362 // If the function implicitly returns zero (like 'main') or is naked, 14363 // don't complain about missing return statements. 14364 if (FD->hasImplicitReturnZero() || FD->hasAttr<NakedAttr>()) 14365 WP.disableCheckFallThrough(); 14366 14367 // MSVC permits the use of pure specifier (=0) on function definition, 14368 // defined at class scope, warn about this non-standard construct. 14369 if (getLangOpts().MicrosoftExt && FD->isPure() && !FD->isOutOfLine()) 14370 Diag(FD->getLocation(), diag::ext_pure_function_definition); 14371 14372 if (!FD->isInvalidDecl()) { 14373 // Don't diagnose unused parameters of defaulted or deleted functions. 14374 if (!FD->isDeleted() && !FD->isDefaulted() && !FD->hasSkippedBody()) 14375 DiagnoseUnusedParameters(FD->parameters()); 14376 DiagnoseSizeOfParametersAndReturnValue(FD->parameters(), 14377 FD->getReturnType(), FD); 14378 14379 // If this is a structor, we need a vtable. 14380 if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(FD)) 14381 MarkVTableUsed(FD->getLocation(), Constructor->getParent()); 14382 else if (CXXDestructorDecl *Destructor = dyn_cast<CXXDestructorDecl>(FD)) 14383 MarkVTableUsed(FD->getLocation(), Destructor->getParent()); 14384 14385 // Try to apply the named return value optimization. We have to check 14386 // if we can do this here because lambdas keep return statements around 14387 // to deduce an implicit return type. 14388 if (FD->getReturnType()->isRecordType() && 14389 (!getLangOpts().CPlusPlus || !FD->isDependentContext())) 14390 computeNRVO(Body, FSI); 14391 } 14392 14393 // GNU warning -Wmissing-prototypes: 14394 // Warn if a global function is defined without a previous 14395 // prototype declaration. This warning is issued even if the 14396 // definition itself provides a prototype. The aim is to detect 14397 // global functions that fail to be declared in header files. 14398 const FunctionDecl *PossiblePrototype = nullptr; 14399 if (ShouldWarnAboutMissingPrototype(FD, PossiblePrototype)) { 14400 Diag(FD->getLocation(), diag::warn_missing_prototype) << FD; 14401 14402 if (PossiblePrototype) { 14403 // We found a declaration that is not a prototype, 14404 // but that could be a zero-parameter prototype 14405 if (TypeSourceInfo *TI = PossiblePrototype->getTypeSourceInfo()) { 14406 TypeLoc TL = TI->getTypeLoc(); 14407 if (FunctionNoProtoTypeLoc FTL = TL.getAs<FunctionNoProtoTypeLoc>()) 14408 Diag(PossiblePrototype->getLocation(), 14409 diag::note_declaration_not_a_prototype) 14410 << (FD->getNumParams() != 0) 14411 << (FD->getNumParams() == 0 14412 ? FixItHint::CreateInsertion(FTL.getRParenLoc(), "void") 14413 : FixItHint{}); 14414 } 14415 } else { 14416 // Returns true if the token beginning at this Loc is `const`. 14417 auto isLocAtConst = [&](SourceLocation Loc, const SourceManager &SM, 14418 const LangOptions &LangOpts) { 14419 std::pair<FileID, unsigned> LocInfo = SM.getDecomposedLoc(Loc); 14420 if (LocInfo.first.isInvalid()) 14421 return false; 14422 14423 bool Invalid = false; 14424 StringRef Buffer = SM.getBufferData(LocInfo.first, &Invalid); 14425 if (Invalid) 14426 return false; 14427 14428 if (LocInfo.second > Buffer.size()) 14429 return false; 14430 14431 const char *LexStart = Buffer.data() + LocInfo.second; 14432 StringRef StartTok(LexStart, Buffer.size() - LocInfo.second); 14433 14434 return StartTok.consume_front("const") && 14435 (StartTok.empty() || isWhitespace(StartTok[0]) || 14436 StartTok.startswith("/*") || StartTok.startswith("//")); 14437 }; 14438 14439 auto findBeginLoc = [&]() { 14440 // If the return type has `const` qualifier, we want to insert 14441 // `static` before `const` (and not before the typename). 14442 if ((FD->getReturnType()->isAnyPointerType() && 14443 FD->getReturnType()->getPointeeType().isConstQualified()) || 14444 FD->getReturnType().isConstQualified()) { 14445 // But only do this if we can determine where the `const` is. 14446 14447 if (isLocAtConst(FD->getBeginLoc(), getSourceManager(), 14448 getLangOpts())) 14449 14450 return FD->getBeginLoc(); 14451 } 14452 return FD->getTypeSpecStartLoc(); 14453 }; 14454 Diag(FD->getTypeSpecStartLoc(), diag::note_static_for_internal_linkage) 14455 << /* function */ 1 14456 << (FD->getStorageClass() == SC_None 14457 ? FixItHint::CreateInsertion(findBeginLoc(), "static ") 14458 : FixItHint{}); 14459 } 14460 14461 // GNU warning -Wstrict-prototypes 14462 // Warn if K&R function is defined without a previous declaration. 14463 // This warning is issued only if the definition itself does not provide 14464 // a prototype. Only K&R definitions do not provide a prototype. 14465 if (!FD->hasWrittenPrototype()) { 14466 TypeSourceInfo *TI = FD->getTypeSourceInfo(); 14467 TypeLoc TL = TI->getTypeLoc(); 14468 FunctionTypeLoc FTL = TL.getAsAdjusted<FunctionTypeLoc>(); 14469 Diag(FTL.getLParenLoc(), diag::warn_strict_prototypes) << 2; 14470 } 14471 } 14472 14473 // Warn on CPUDispatch with an actual body. 14474 if (FD->isMultiVersion() && FD->hasAttr<CPUDispatchAttr>() && Body) 14475 if (const auto *CmpndBody = dyn_cast<CompoundStmt>(Body)) 14476 if (!CmpndBody->body_empty()) 14477 Diag(CmpndBody->body_front()->getBeginLoc(), 14478 diag::warn_dispatch_body_ignored); 14479 14480 if (auto *MD = dyn_cast<CXXMethodDecl>(FD)) { 14481 const CXXMethodDecl *KeyFunction; 14482 if (MD->isOutOfLine() && (MD = MD->getCanonicalDecl()) && 14483 MD->isVirtual() && 14484 (KeyFunction = Context.getCurrentKeyFunction(MD->getParent())) && 14485 MD == KeyFunction->getCanonicalDecl()) { 14486 // Update the key-function state if necessary for this ABI. 14487 if (FD->isInlined() && 14488 !Context.getTargetInfo().getCXXABI().canKeyFunctionBeInline()) { 14489 Context.setNonKeyFunction(MD); 14490 14491 // If the newly-chosen key function is already defined, then we 14492 // need to mark the vtable as used retroactively. 14493 KeyFunction = Context.getCurrentKeyFunction(MD->getParent()); 14494 const FunctionDecl *Definition; 14495 if (KeyFunction && KeyFunction->isDefined(Definition)) 14496 MarkVTableUsed(Definition->getLocation(), MD->getParent(), true); 14497 } else { 14498 // We just defined they key function; mark the vtable as used. 14499 MarkVTableUsed(FD->getLocation(), MD->getParent(), true); 14500 } 14501 } 14502 } 14503 14504 assert((FD == getCurFunctionDecl() || getCurLambda()->CallOperator == FD) && 14505 "Function parsing confused"); 14506 } else if (ObjCMethodDecl *MD = dyn_cast_or_null<ObjCMethodDecl>(dcl)) { 14507 assert(MD == getCurMethodDecl() && "Method parsing confused"); 14508 MD->setBody(Body); 14509 if (!MD->isInvalidDecl()) { 14510 DiagnoseSizeOfParametersAndReturnValue(MD->parameters(), 14511 MD->getReturnType(), MD); 14512 14513 if (Body) 14514 computeNRVO(Body, FSI); 14515 } 14516 if (FSI->ObjCShouldCallSuper) { 14517 Diag(MD->getEndLoc(), diag::warn_objc_missing_super_call) 14518 << MD->getSelector().getAsString(); 14519 FSI->ObjCShouldCallSuper = false; 14520 } 14521 if (FSI->ObjCWarnForNoDesignatedInitChain) { 14522 const ObjCMethodDecl *InitMethod = nullptr; 14523 bool isDesignated = 14524 MD->isDesignatedInitializerForTheInterface(&InitMethod); 14525 assert(isDesignated && InitMethod); 14526 (void)isDesignated; 14527 14528 auto superIsNSObject = [&](const ObjCMethodDecl *MD) { 14529 auto IFace = MD->getClassInterface(); 14530 if (!IFace) 14531 return false; 14532 auto SuperD = IFace->getSuperClass(); 14533 if (!SuperD) 14534 return false; 14535 return SuperD->getIdentifier() == 14536 NSAPIObj->getNSClassId(NSAPI::ClassId_NSObject); 14537 }; 14538 // Don't issue this warning for unavailable inits or direct subclasses 14539 // of NSObject. 14540 if (!MD->isUnavailable() && !superIsNSObject(MD)) { 14541 Diag(MD->getLocation(), 14542 diag::warn_objc_designated_init_missing_super_call); 14543 Diag(InitMethod->getLocation(), 14544 diag::note_objc_designated_init_marked_here); 14545 } 14546 FSI->ObjCWarnForNoDesignatedInitChain = false; 14547 } 14548 if (FSI->ObjCWarnForNoInitDelegation) { 14549 // Don't issue this warning for unavaialable inits. 14550 if (!MD->isUnavailable()) 14551 Diag(MD->getLocation(), 14552 diag::warn_objc_secondary_init_missing_init_call); 14553 FSI->ObjCWarnForNoInitDelegation = false; 14554 } 14555 14556 diagnoseImplicitlyRetainedSelf(*this); 14557 } else { 14558 // Parsing the function declaration failed in some way. Pop the fake scope 14559 // we pushed on. 14560 PopFunctionScopeInfo(ActivePolicy, dcl); 14561 return nullptr; 14562 } 14563 14564 if (Body && FSI->HasPotentialAvailabilityViolations) 14565 DiagnoseUnguardedAvailabilityViolations(dcl); 14566 14567 assert(!FSI->ObjCShouldCallSuper && 14568 "This should only be set for ObjC methods, which should have been " 14569 "handled in the block above."); 14570 14571 // Verify and clean out per-function state. 14572 if (Body && (!FD || !FD->isDefaulted())) { 14573 // C++ constructors that have function-try-blocks can't have return 14574 // statements in the handlers of that block. (C++ [except.handle]p14) 14575 // Verify this. 14576 if (FD && isa<CXXConstructorDecl>(FD) && isa<CXXTryStmt>(Body)) 14577 DiagnoseReturnInConstructorExceptionHandler(cast<CXXTryStmt>(Body)); 14578 14579 // Verify that gotos and switch cases don't jump into scopes illegally. 14580 if (FSI->NeedsScopeChecking() && 14581 !PP.isCodeCompletionEnabled()) 14582 DiagnoseInvalidJumps(Body); 14583 14584 if (CXXDestructorDecl *Destructor = dyn_cast<CXXDestructorDecl>(dcl)) { 14585 if (!Destructor->getParent()->isDependentType()) 14586 CheckDestructor(Destructor); 14587 14588 MarkBaseAndMemberDestructorsReferenced(Destructor->getLocation(), 14589 Destructor->getParent()); 14590 } 14591 14592 // If any errors have occurred, clear out any temporaries that may have 14593 // been leftover. This ensures that these temporaries won't be picked up for 14594 // deletion in some later function. 14595 if (hasUncompilableErrorOccurred() || 14596 getDiagnostics().getSuppressAllDiagnostics()) { 14597 DiscardCleanupsInEvaluationContext(); 14598 } 14599 if (!hasUncompilableErrorOccurred() && 14600 !isa<FunctionTemplateDecl>(dcl)) { 14601 // Since the body is valid, issue any analysis-based warnings that are 14602 // enabled. 14603 ActivePolicy = &WP; 14604 } 14605 14606 if (!IsInstantiation && FD && FD->isConstexpr() && !FD->isInvalidDecl() && 14607 !CheckConstexprFunctionDefinition(FD, CheckConstexprKind::Diagnose)) 14608 FD->setInvalidDecl(); 14609 14610 if (FD && FD->hasAttr<NakedAttr>()) { 14611 for (const Stmt *S : Body->children()) { 14612 // Allow local register variables without initializer as they don't 14613 // require prologue. 14614 bool RegisterVariables = false; 14615 if (auto *DS = dyn_cast<DeclStmt>(S)) { 14616 for (const auto *Decl : DS->decls()) { 14617 if (const auto *Var = dyn_cast<VarDecl>(Decl)) { 14618 RegisterVariables = 14619 Var->hasAttr<AsmLabelAttr>() && !Var->hasInit(); 14620 if (!RegisterVariables) 14621 break; 14622 } 14623 } 14624 } 14625 if (RegisterVariables) 14626 continue; 14627 if (!isa<AsmStmt>(S) && !isa<NullStmt>(S)) { 14628 Diag(S->getBeginLoc(), diag::err_non_asm_stmt_in_naked_function); 14629 Diag(FD->getAttr<NakedAttr>()->getLocation(), diag::note_attribute); 14630 FD->setInvalidDecl(); 14631 break; 14632 } 14633 } 14634 } 14635 14636 assert(ExprCleanupObjects.size() == 14637 ExprEvalContexts.back().NumCleanupObjects && 14638 "Leftover temporaries in function"); 14639 assert(!Cleanup.exprNeedsCleanups() && "Unaccounted cleanups in function"); 14640 assert(MaybeODRUseExprs.empty() && 14641 "Leftover expressions for odr-use checking"); 14642 } 14643 14644 if (!IsInstantiation) 14645 PopDeclContext(); 14646 14647 PopFunctionScopeInfo(ActivePolicy, dcl); 14648 // If any errors have occurred, clear out any temporaries that may have 14649 // been leftover. This ensures that these temporaries won't be picked up for 14650 // deletion in some later function. 14651 if (hasUncompilableErrorOccurred()) { 14652 DiscardCleanupsInEvaluationContext(); 14653 } 14654 14655 if (FD && (LangOpts.OpenMP || LangOpts.CUDA || LangOpts.SYCLIsDevice)) { 14656 auto ES = getEmissionStatus(FD); 14657 if (ES == Sema::FunctionEmissionStatus::Emitted || 14658 ES == Sema::FunctionEmissionStatus::Unknown) 14659 DeclsToCheckForDeferredDiags.push_back(FD); 14660 } 14661 14662 return dcl; 14663 } 14664 14665 /// When we finish delayed parsing of an attribute, we must attach it to the 14666 /// relevant Decl. 14667 void Sema::ActOnFinishDelayedAttribute(Scope *S, Decl *D, 14668 ParsedAttributes &Attrs) { 14669 // Always attach attributes to the underlying decl. 14670 if (TemplateDecl *TD = dyn_cast<TemplateDecl>(D)) 14671 D = TD->getTemplatedDecl(); 14672 ProcessDeclAttributeList(S, D, Attrs); 14673 14674 if (CXXMethodDecl *Method = dyn_cast_or_null<CXXMethodDecl>(D)) 14675 if (Method->isStatic()) 14676 checkThisInStaticMemberFunctionAttributes(Method); 14677 } 14678 14679 /// ImplicitlyDefineFunction - An undeclared identifier was used in a function 14680 /// call, forming a call to an implicitly defined function (per C99 6.5.1p2). 14681 NamedDecl *Sema::ImplicitlyDefineFunction(SourceLocation Loc, 14682 IdentifierInfo &II, Scope *S) { 14683 // Find the scope in which the identifier is injected and the corresponding 14684 // DeclContext. 14685 // FIXME: C89 does not say what happens if there is no enclosing block scope. 14686 // In that case, we inject the declaration into the translation unit scope 14687 // instead. 14688 Scope *BlockScope = S; 14689 while (!BlockScope->isCompoundStmtScope() && BlockScope->getParent()) 14690 BlockScope = BlockScope->getParent(); 14691 14692 Scope *ContextScope = BlockScope; 14693 while (!ContextScope->getEntity()) 14694 ContextScope = ContextScope->getParent(); 14695 ContextRAII SavedContext(*this, ContextScope->getEntity()); 14696 14697 // Before we produce a declaration for an implicitly defined 14698 // function, see whether there was a locally-scoped declaration of 14699 // this name as a function or variable. If so, use that 14700 // (non-visible) declaration, and complain about it. 14701 NamedDecl *ExternCPrev = findLocallyScopedExternCDecl(&II); 14702 if (ExternCPrev) { 14703 // We still need to inject the function into the enclosing block scope so 14704 // that later (non-call) uses can see it. 14705 PushOnScopeChains(ExternCPrev, BlockScope, /*AddToContext*/false); 14706 14707 // C89 footnote 38: 14708 // If in fact it is not defined as having type "function returning int", 14709 // the behavior is undefined. 14710 if (!isa<FunctionDecl>(ExternCPrev) || 14711 !Context.typesAreCompatible( 14712 cast<FunctionDecl>(ExternCPrev)->getType(), 14713 Context.getFunctionNoProtoType(Context.IntTy))) { 14714 Diag(Loc, diag::ext_use_out_of_scope_declaration) 14715 << ExternCPrev << !getLangOpts().C99; 14716 Diag(ExternCPrev->getLocation(), diag::note_previous_declaration); 14717 return ExternCPrev; 14718 } 14719 } 14720 14721 // Extension in C99. Legal in C90, but warn about it. 14722 unsigned diag_id; 14723 if (II.getName().startswith("__builtin_")) 14724 diag_id = diag::warn_builtin_unknown; 14725 // OpenCL v2.0 s6.9.u - Implicit function declaration is not supported. 14726 else if (getLangOpts().OpenCL) 14727 diag_id = diag::err_opencl_implicit_function_decl; 14728 else if (getLangOpts().C99) 14729 diag_id = diag::ext_implicit_function_decl; 14730 else 14731 diag_id = diag::warn_implicit_function_decl; 14732 Diag(Loc, diag_id) << &II; 14733 14734 // If we found a prior declaration of this function, don't bother building 14735 // another one. We've already pushed that one into scope, so there's nothing 14736 // more to do. 14737 if (ExternCPrev) 14738 return ExternCPrev; 14739 14740 // Because typo correction is expensive, only do it if the implicit 14741 // function declaration is going to be treated as an error. 14742 if (Diags.getDiagnosticLevel(diag_id, Loc) >= DiagnosticsEngine::Error) { 14743 TypoCorrection Corrected; 14744 DeclFilterCCC<FunctionDecl> CCC{}; 14745 if (S && (Corrected = 14746 CorrectTypo(DeclarationNameInfo(&II, Loc), LookupOrdinaryName, 14747 S, nullptr, CCC, CTK_NonError))) 14748 diagnoseTypo(Corrected, PDiag(diag::note_function_suggestion), 14749 /*ErrorRecovery*/false); 14750 } 14751 14752 // Set a Declarator for the implicit definition: int foo(); 14753 const char *Dummy; 14754 AttributeFactory attrFactory; 14755 DeclSpec DS(attrFactory); 14756 unsigned DiagID; 14757 bool Error = DS.SetTypeSpecType(DeclSpec::TST_int, Loc, Dummy, DiagID, 14758 Context.getPrintingPolicy()); 14759 (void)Error; // Silence warning. 14760 assert(!Error && "Error setting up implicit decl!"); 14761 SourceLocation NoLoc; 14762 Declarator D(DS, DeclaratorContext::Block); 14763 D.AddTypeInfo(DeclaratorChunk::getFunction(/*HasProto=*/false, 14764 /*IsAmbiguous=*/false, 14765 /*LParenLoc=*/NoLoc, 14766 /*Params=*/nullptr, 14767 /*NumParams=*/0, 14768 /*EllipsisLoc=*/NoLoc, 14769 /*RParenLoc=*/NoLoc, 14770 /*RefQualifierIsLvalueRef=*/true, 14771 /*RefQualifierLoc=*/NoLoc, 14772 /*MutableLoc=*/NoLoc, EST_None, 14773 /*ESpecRange=*/SourceRange(), 14774 /*Exceptions=*/nullptr, 14775 /*ExceptionRanges=*/nullptr, 14776 /*NumExceptions=*/0, 14777 /*NoexceptExpr=*/nullptr, 14778 /*ExceptionSpecTokens=*/nullptr, 14779 /*DeclsInPrototype=*/None, Loc, 14780 Loc, D), 14781 std::move(DS.getAttributes()), SourceLocation()); 14782 D.SetIdentifier(&II, Loc); 14783 14784 // Insert this function into the enclosing block scope. 14785 FunctionDecl *FD = cast<FunctionDecl>(ActOnDeclarator(BlockScope, D)); 14786 FD->setImplicit(); 14787 14788 AddKnownFunctionAttributes(FD); 14789 14790 return FD; 14791 } 14792 14793 /// If this function is a C++ replaceable global allocation function 14794 /// (C++2a [basic.stc.dynamic.allocation], C++2a [new.delete]), 14795 /// adds any function attributes that we know a priori based on the standard. 14796 /// 14797 /// We need to check for duplicate attributes both here and where user-written 14798 /// attributes are applied to declarations. 14799 void Sema::AddKnownFunctionAttributesForReplaceableGlobalAllocationFunction( 14800 FunctionDecl *FD) { 14801 if (FD->isInvalidDecl()) 14802 return; 14803 14804 if (FD->getDeclName().getCXXOverloadedOperator() != OO_New && 14805 FD->getDeclName().getCXXOverloadedOperator() != OO_Array_New) 14806 return; 14807 14808 Optional<unsigned> AlignmentParam; 14809 bool IsNothrow = false; 14810 if (!FD->isReplaceableGlobalAllocationFunction(&AlignmentParam, &IsNothrow)) 14811 return; 14812 14813 // C++2a [basic.stc.dynamic.allocation]p4: 14814 // An allocation function that has a non-throwing exception specification 14815 // indicates failure by returning a null pointer value. Any other allocation 14816 // function never returns a null pointer value and indicates failure only by 14817 // throwing an exception [...] 14818 if (!IsNothrow && !FD->hasAttr<ReturnsNonNullAttr>()) 14819 FD->addAttr(ReturnsNonNullAttr::CreateImplicit(Context, FD->getLocation())); 14820 14821 // C++2a [basic.stc.dynamic.allocation]p2: 14822 // An allocation function attempts to allocate the requested amount of 14823 // storage. [...] If the request succeeds, the value returned by a 14824 // replaceable allocation function is a [...] pointer value p0 different 14825 // from any previously returned value p1 [...] 14826 // 14827 // However, this particular information is being added in codegen, 14828 // because there is an opt-out switch for it (-fno-assume-sane-operator-new) 14829 14830 // C++2a [basic.stc.dynamic.allocation]p2: 14831 // An allocation function attempts to allocate the requested amount of 14832 // storage. If it is successful, it returns the address of the start of a 14833 // block of storage whose length in bytes is at least as large as the 14834 // requested size. 14835 if (!FD->hasAttr<AllocSizeAttr>()) { 14836 FD->addAttr(AllocSizeAttr::CreateImplicit( 14837 Context, /*ElemSizeParam=*/ParamIdx(1, FD), 14838 /*NumElemsParam=*/ParamIdx(), FD->getLocation())); 14839 } 14840 14841 // C++2a [basic.stc.dynamic.allocation]p3: 14842 // For an allocation function [...], the pointer returned on a successful 14843 // call shall represent the address of storage that is aligned as follows: 14844 // (3.1) If the allocation function takes an argument of type 14845 // std::align_val_t, the storage will have the alignment 14846 // specified by the value of this argument. 14847 if (AlignmentParam.hasValue() && !FD->hasAttr<AllocAlignAttr>()) { 14848 FD->addAttr(AllocAlignAttr::CreateImplicit( 14849 Context, ParamIdx(AlignmentParam.getValue(), FD), FD->getLocation())); 14850 } 14851 14852 // FIXME: 14853 // C++2a [basic.stc.dynamic.allocation]p3: 14854 // For an allocation function [...], the pointer returned on a successful 14855 // call shall represent the address of storage that is aligned as follows: 14856 // (3.2) Otherwise, if the allocation function is named operator new[], 14857 // the storage is aligned for any object that does not have 14858 // new-extended alignment ([basic.align]) and is no larger than the 14859 // requested size. 14860 // (3.3) Otherwise, the storage is aligned for any object that does not 14861 // have new-extended alignment and is of the requested size. 14862 } 14863 14864 /// Adds any function attributes that we know a priori based on 14865 /// the declaration of this function. 14866 /// 14867 /// These attributes can apply both to implicitly-declared builtins 14868 /// (like __builtin___printf_chk) or to library-declared functions 14869 /// like NSLog or printf. 14870 /// 14871 /// We need to check for duplicate attributes both here and where user-written 14872 /// attributes are applied to declarations. 14873 void Sema::AddKnownFunctionAttributes(FunctionDecl *FD) { 14874 if (FD->isInvalidDecl()) 14875 return; 14876 14877 // If this is a built-in function, map its builtin attributes to 14878 // actual attributes. 14879 if (unsigned BuiltinID = FD->getBuiltinID()) { 14880 // Handle printf-formatting attributes. 14881 unsigned FormatIdx; 14882 bool HasVAListArg; 14883 if (Context.BuiltinInfo.isPrintfLike(BuiltinID, FormatIdx, HasVAListArg)) { 14884 if (!FD->hasAttr<FormatAttr>()) { 14885 const char *fmt = "printf"; 14886 unsigned int NumParams = FD->getNumParams(); 14887 if (FormatIdx < NumParams && // NumParams may be 0 (e.g. vfprintf) 14888 FD->getParamDecl(FormatIdx)->getType()->isObjCObjectPointerType()) 14889 fmt = "NSString"; 14890 FD->addAttr(FormatAttr::CreateImplicit(Context, 14891 &Context.Idents.get(fmt), 14892 FormatIdx+1, 14893 HasVAListArg ? 0 : FormatIdx+2, 14894 FD->getLocation())); 14895 } 14896 } 14897 if (Context.BuiltinInfo.isScanfLike(BuiltinID, FormatIdx, 14898 HasVAListArg)) { 14899 if (!FD->hasAttr<FormatAttr>()) 14900 FD->addAttr(FormatAttr::CreateImplicit(Context, 14901 &Context.Idents.get("scanf"), 14902 FormatIdx+1, 14903 HasVAListArg ? 0 : FormatIdx+2, 14904 FD->getLocation())); 14905 } 14906 14907 // Handle automatically recognized callbacks. 14908 SmallVector<int, 4> Encoding; 14909 if (!FD->hasAttr<CallbackAttr>() && 14910 Context.BuiltinInfo.performsCallback(BuiltinID, Encoding)) 14911 FD->addAttr(CallbackAttr::CreateImplicit( 14912 Context, Encoding.data(), Encoding.size(), FD->getLocation())); 14913 14914 // Mark const if we don't care about errno and that is the only thing 14915 // preventing the function from being const. This allows IRgen to use LLVM 14916 // intrinsics for such functions. 14917 if (!getLangOpts().MathErrno && !FD->hasAttr<ConstAttr>() && 14918 Context.BuiltinInfo.isConstWithoutErrno(BuiltinID)) 14919 FD->addAttr(ConstAttr::CreateImplicit(Context, FD->getLocation())); 14920 14921 // We make "fma" on some platforms const because we know it does not set 14922 // errno in those environments even though it could set errno based on the 14923 // C standard. 14924 const llvm::Triple &Trip = Context.getTargetInfo().getTriple(); 14925 if ((Trip.isGNUEnvironment() || Trip.isAndroid() || Trip.isOSMSVCRT()) && 14926 !FD->hasAttr<ConstAttr>()) { 14927 switch (BuiltinID) { 14928 case Builtin::BI__builtin_fma: 14929 case Builtin::BI__builtin_fmaf: 14930 case Builtin::BI__builtin_fmal: 14931 case Builtin::BIfma: 14932 case Builtin::BIfmaf: 14933 case Builtin::BIfmal: 14934 FD->addAttr(ConstAttr::CreateImplicit(Context, FD->getLocation())); 14935 break; 14936 default: 14937 break; 14938 } 14939 } 14940 14941 if (Context.BuiltinInfo.isReturnsTwice(BuiltinID) && 14942 !FD->hasAttr<ReturnsTwiceAttr>()) 14943 FD->addAttr(ReturnsTwiceAttr::CreateImplicit(Context, 14944 FD->getLocation())); 14945 if (Context.BuiltinInfo.isNoThrow(BuiltinID) && !FD->hasAttr<NoThrowAttr>()) 14946 FD->addAttr(NoThrowAttr::CreateImplicit(Context, FD->getLocation())); 14947 if (Context.BuiltinInfo.isPure(BuiltinID) && !FD->hasAttr<PureAttr>()) 14948 FD->addAttr(PureAttr::CreateImplicit(Context, FD->getLocation())); 14949 if (Context.BuiltinInfo.isConst(BuiltinID) && !FD->hasAttr<ConstAttr>()) 14950 FD->addAttr(ConstAttr::CreateImplicit(Context, FD->getLocation())); 14951 if (getLangOpts().CUDA && Context.BuiltinInfo.isTSBuiltin(BuiltinID) && 14952 !FD->hasAttr<CUDADeviceAttr>() && !FD->hasAttr<CUDAHostAttr>()) { 14953 // Add the appropriate attribute, depending on the CUDA compilation mode 14954 // and which target the builtin belongs to. For example, during host 14955 // compilation, aux builtins are __device__, while the rest are __host__. 14956 if (getLangOpts().CUDAIsDevice != 14957 Context.BuiltinInfo.isAuxBuiltinID(BuiltinID)) 14958 FD->addAttr(CUDADeviceAttr::CreateImplicit(Context, FD->getLocation())); 14959 else 14960 FD->addAttr(CUDAHostAttr::CreateImplicit(Context, FD->getLocation())); 14961 } 14962 } 14963 14964 AddKnownFunctionAttributesForReplaceableGlobalAllocationFunction(FD); 14965 14966 // If C++ exceptions are enabled but we are told extern "C" functions cannot 14967 // throw, add an implicit nothrow attribute to any extern "C" function we come 14968 // across. 14969 if (getLangOpts().CXXExceptions && getLangOpts().ExternCNoUnwind && 14970 FD->isExternC() && !FD->hasAttr<NoThrowAttr>()) { 14971 const auto *FPT = FD->getType()->getAs<FunctionProtoType>(); 14972 if (!FPT || FPT->getExceptionSpecType() == EST_None) 14973 FD->addAttr(NoThrowAttr::CreateImplicit(Context, FD->getLocation())); 14974 } 14975 14976 IdentifierInfo *Name = FD->getIdentifier(); 14977 if (!Name) 14978 return; 14979 if ((!getLangOpts().CPlusPlus && 14980 FD->getDeclContext()->isTranslationUnit()) || 14981 (isa<LinkageSpecDecl>(FD->getDeclContext()) && 14982 cast<LinkageSpecDecl>(FD->getDeclContext())->getLanguage() == 14983 LinkageSpecDecl::lang_c)) { 14984 // Okay: this could be a libc/libm/Objective-C function we know 14985 // about. 14986 } else 14987 return; 14988 14989 if (Name->isStr("asprintf") || Name->isStr("vasprintf")) { 14990 // FIXME: asprintf and vasprintf aren't C99 functions. Should they be 14991 // target-specific builtins, perhaps? 14992 if (!FD->hasAttr<FormatAttr>()) 14993 FD->addAttr(FormatAttr::CreateImplicit(Context, 14994 &Context.Idents.get("printf"), 2, 14995 Name->isStr("vasprintf") ? 0 : 3, 14996 FD->getLocation())); 14997 } 14998 14999 if (Name->isStr("__CFStringMakeConstantString")) { 15000 // We already have a __builtin___CFStringMakeConstantString, 15001 // but builds that use -fno-constant-cfstrings don't go through that. 15002 if (!FD->hasAttr<FormatArgAttr>()) 15003 FD->addAttr(FormatArgAttr::CreateImplicit(Context, ParamIdx(1, FD), 15004 FD->getLocation())); 15005 } 15006 } 15007 15008 TypedefDecl *Sema::ParseTypedefDecl(Scope *S, Declarator &D, QualType T, 15009 TypeSourceInfo *TInfo) { 15010 assert(D.getIdentifier() && "Wrong callback for declspec without declarator"); 15011 assert(!T.isNull() && "GetTypeForDeclarator() returned null type"); 15012 15013 if (!TInfo) { 15014 assert(D.isInvalidType() && "no declarator info for valid type"); 15015 TInfo = Context.getTrivialTypeSourceInfo(T); 15016 } 15017 15018 // Scope manipulation handled by caller. 15019 TypedefDecl *NewTD = 15020 TypedefDecl::Create(Context, CurContext, D.getBeginLoc(), 15021 D.getIdentifierLoc(), D.getIdentifier(), TInfo); 15022 15023 // Bail out immediately if we have an invalid declaration. 15024 if (D.isInvalidType()) { 15025 NewTD->setInvalidDecl(); 15026 return NewTD; 15027 } 15028 15029 if (D.getDeclSpec().isModulePrivateSpecified()) { 15030 if (CurContext->isFunctionOrMethod()) 15031 Diag(NewTD->getLocation(), diag::err_module_private_local) 15032 << 2 << NewTD 15033 << SourceRange(D.getDeclSpec().getModulePrivateSpecLoc()) 15034 << FixItHint::CreateRemoval( 15035 D.getDeclSpec().getModulePrivateSpecLoc()); 15036 else 15037 NewTD->setModulePrivate(); 15038 } 15039 15040 // C++ [dcl.typedef]p8: 15041 // If the typedef declaration defines an unnamed class (or 15042 // enum), the first typedef-name declared by the declaration 15043 // to be that class type (or enum type) is used to denote the 15044 // class type (or enum type) for linkage purposes only. 15045 // We need to check whether the type was declared in the declaration. 15046 switch (D.getDeclSpec().getTypeSpecType()) { 15047 case TST_enum: 15048 case TST_struct: 15049 case TST_interface: 15050 case TST_union: 15051 case TST_class: { 15052 TagDecl *tagFromDeclSpec = cast<TagDecl>(D.getDeclSpec().getRepAsDecl()); 15053 setTagNameForLinkagePurposes(tagFromDeclSpec, NewTD); 15054 break; 15055 } 15056 15057 default: 15058 break; 15059 } 15060 15061 return NewTD; 15062 } 15063 15064 /// Check that this is a valid underlying type for an enum declaration. 15065 bool Sema::CheckEnumUnderlyingType(TypeSourceInfo *TI) { 15066 SourceLocation UnderlyingLoc = TI->getTypeLoc().getBeginLoc(); 15067 QualType T = TI->getType(); 15068 15069 if (T->isDependentType()) 15070 return false; 15071 15072 // This doesn't use 'isIntegralType' despite the error message mentioning 15073 // integral type because isIntegralType would also allow enum types in C. 15074 if (const BuiltinType *BT = T->getAs<BuiltinType>()) 15075 if (BT->isInteger()) 15076 return false; 15077 15078 if (T->isExtIntType()) 15079 return false; 15080 15081 return Diag(UnderlyingLoc, diag::err_enum_invalid_underlying) << T; 15082 } 15083 15084 /// Check whether this is a valid redeclaration of a previous enumeration. 15085 /// \return true if the redeclaration was invalid. 15086 bool Sema::CheckEnumRedeclaration(SourceLocation EnumLoc, bool IsScoped, 15087 QualType EnumUnderlyingTy, bool IsFixed, 15088 const EnumDecl *Prev) { 15089 if (IsScoped != Prev->isScoped()) { 15090 Diag(EnumLoc, diag::err_enum_redeclare_scoped_mismatch) 15091 << Prev->isScoped(); 15092 Diag(Prev->getLocation(), diag::note_previous_declaration); 15093 return true; 15094 } 15095 15096 if (IsFixed && Prev->isFixed()) { 15097 if (!EnumUnderlyingTy->isDependentType() && 15098 !Prev->getIntegerType()->isDependentType() && 15099 !Context.hasSameUnqualifiedType(EnumUnderlyingTy, 15100 Prev->getIntegerType())) { 15101 // TODO: Highlight the underlying type of the redeclaration. 15102 Diag(EnumLoc, diag::err_enum_redeclare_type_mismatch) 15103 << EnumUnderlyingTy << Prev->getIntegerType(); 15104 Diag(Prev->getLocation(), diag::note_previous_declaration) 15105 << Prev->getIntegerTypeRange(); 15106 return true; 15107 } 15108 } else if (IsFixed != Prev->isFixed()) { 15109 Diag(EnumLoc, diag::err_enum_redeclare_fixed_mismatch) 15110 << Prev->isFixed(); 15111 Diag(Prev->getLocation(), diag::note_previous_declaration); 15112 return true; 15113 } 15114 15115 return false; 15116 } 15117 15118 /// Get diagnostic %select index for tag kind for 15119 /// redeclaration diagnostic message. 15120 /// WARNING: Indexes apply to particular diagnostics only! 15121 /// 15122 /// \returns diagnostic %select index. 15123 static unsigned getRedeclDiagFromTagKind(TagTypeKind Tag) { 15124 switch (Tag) { 15125 case TTK_Struct: return 0; 15126 case TTK_Interface: return 1; 15127 case TTK_Class: return 2; 15128 default: llvm_unreachable("Invalid tag kind for redecl diagnostic!"); 15129 } 15130 } 15131 15132 /// Determine if tag kind is a class-key compatible with 15133 /// class for redeclaration (class, struct, or __interface). 15134 /// 15135 /// \returns true iff the tag kind is compatible. 15136 static bool isClassCompatTagKind(TagTypeKind Tag) 15137 { 15138 return Tag == TTK_Struct || Tag == TTK_Class || Tag == TTK_Interface; 15139 } 15140 15141 Sema::NonTagKind Sema::getNonTagTypeDeclKind(const Decl *PrevDecl, 15142 TagTypeKind TTK) { 15143 if (isa<TypedefDecl>(PrevDecl)) 15144 return NTK_Typedef; 15145 else if (isa<TypeAliasDecl>(PrevDecl)) 15146 return NTK_TypeAlias; 15147 else if (isa<ClassTemplateDecl>(PrevDecl)) 15148 return NTK_Template; 15149 else if (isa<TypeAliasTemplateDecl>(PrevDecl)) 15150 return NTK_TypeAliasTemplate; 15151 else if (isa<TemplateTemplateParmDecl>(PrevDecl)) 15152 return NTK_TemplateTemplateArgument; 15153 switch (TTK) { 15154 case TTK_Struct: 15155 case TTK_Interface: 15156 case TTK_Class: 15157 return getLangOpts().CPlusPlus ? NTK_NonClass : NTK_NonStruct; 15158 case TTK_Union: 15159 return NTK_NonUnion; 15160 case TTK_Enum: 15161 return NTK_NonEnum; 15162 } 15163 llvm_unreachable("invalid TTK"); 15164 } 15165 15166 /// Determine whether a tag with a given kind is acceptable 15167 /// as a redeclaration of the given tag declaration. 15168 /// 15169 /// \returns true if the new tag kind is acceptable, false otherwise. 15170 bool Sema::isAcceptableTagRedeclaration(const TagDecl *Previous, 15171 TagTypeKind NewTag, bool isDefinition, 15172 SourceLocation NewTagLoc, 15173 const IdentifierInfo *Name) { 15174 // C++ [dcl.type.elab]p3: 15175 // The class-key or enum keyword present in the 15176 // elaborated-type-specifier shall agree in kind with the 15177 // declaration to which the name in the elaborated-type-specifier 15178 // refers. This rule also applies to the form of 15179 // elaborated-type-specifier that declares a class-name or 15180 // friend class since it can be construed as referring to the 15181 // definition of the class. Thus, in any 15182 // elaborated-type-specifier, the enum keyword shall be used to 15183 // refer to an enumeration (7.2), the union class-key shall be 15184 // used to refer to a union (clause 9), and either the class or 15185 // struct class-key shall be used to refer to a class (clause 9) 15186 // declared using the class or struct class-key. 15187 TagTypeKind OldTag = Previous->getTagKind(); 15188 if (OldTag != NewTag && 15189 !(isClassCompatTagKind(OldTag) && isClassCompatTagKind(NewTag))) 15190 return false; 15191 15192 // Tags are compatible, but we might still want to warn on mismatched tags. 15193 // Non-class tags can't be mismatched at this point. 15194 if (!isClassCompatTagKind(NewTag)) 15195 return true; 15196 15197 // Declarations for which -Wmismatched-tags is disabled are entirely ignored 15198 // by our warning analysis. We don't want to warn about mismatches with (eg) 15199 // declarations in system headers that are designed to be specialized, but if 15200 // a user asks us to warn, we should warn if their code contains mismatched 15201 // declarations. 15202 auto IsIgnoredLoc = [&](SourceLocation Loc) { 15203 return getDiagnostics().isIgnored(diag::warn_struct_class_tag_mismatch, 15204 Loc); 15205 }; 15206 if (IsIgnoredLoc(NewTagLoc)) 15207 return true; 15208 15209 auto IsIgnored = [&](const TagDecl *Tag) { 15210 return IsIgnoredLoc(Tag->getLocation()); 15211 }; 15212 while (IsIgnored(Previous)) { 15213 Previous = Previous->getPreviousDecl(); 15214 if (!Previous) 15215 return true; 15216 OldTag = Previous->getTagKind(); 15217 } 15218 15219 bool isTemplate = false; 15220 if (const CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(Previous)) 15221 isTemplate = Record->getDescribedClassTemplate(); 15222 15223 if (inTemplateInstantiation()) { 15224 if (OldTag != NewTag) { 15225 // In a template instantiation, do not offer fix-its for tag mismatches 15226 // since they usually mess up the template instead of fixing the problem. 15227 Diag(NewTagLoc, diag::warn_struct_class_tag_mismatch) 15228 << getRedeclDiagFromTagKind(NewTag) << isTemplate << Name 15229 << getRedeclDiagFromTagKind(OldTag); 15230 // FIXME: Note previous location? 15231 } 15232 return true; 15233 } 15234 15235 if (isDefinition) { 15236 // On definitions, check all previous tags and issue a fix-it for each 15237 // one that doesn't match the current tag. 15238 if (Previous->getDefinition()) { 15239 // Don't suggest fix-its for redefinitions. 15240 return true; 15241 } 15242 15243 bool previousMismatch = false; 15244 for (const TagDecl *I : Previous->redecls()) { 15245 if (I->getTagKind() != NewTag) { 15246 // Ignore previous declarations for which the warning was disabled. 15247 if (IsIgnored(I)) 15248 continue; 15249 15250 if (!previousMismatch) { 15251 previousMismatch = true; 15252 Diag(NewTagLoc, diag::warn_struct_class_previous_tag_mismatch) 15253 << getRedeclDiagFromTagKind(NewTag) << isTemplate << Name 15254 << getRedeclDiagFromTagKind(I->getTagKind()); 15255 } 15256 Diag(I->getInnerLocStart(), diag::note_struct_class_suggestion) 15257 << getRedeclDiagFromTagKind(NewTag) 15258 << FixItHint::CreateReplacement(I->getInnerLocStart(), 15259 TypeWithKeyword::getTagTypeKindName(NewTag)); 15260 } 15261 } 15262 return true; 15263 } 15264 15265 // Identify the prevailing tag kind: this is the kind of the definition (if 15266 // there is a non-ignored definition), or otherwise the kind of the prior 15267 // (non-ignored) declaration. 15268 const TagDecl *PrevDef = Previous->getDefinition(); 15269 if (PrevDef && IsIgnored(PrevDef)) 15270 PrevDef = nullptr; 15271 const TagDecl *Redecl = PrevDef ? PrevDef : Previous; 15272 if (Redecl->getTagKind() != NewTag) { 15273 Diag(NewTagLoc, diag::warn_struct_class_tag_mismatch) 15274 << getRedeclDiagFromTagKind(NewTag) << isTemplate << Name 15275 << getRedeclDiagFromTagKind(OldTag); 15276 Diag(Redecl->getLocation(), diag::note_previous_use); 15277 15278 // If there is a previous definition, suggest a fix-it. 15279 if (PrevDef) { 15280 Diag(NewTagLoc, diag::note_struct_class_suggestion) 15281 << getRedeclDiagFromTagKind(Redecl->getTagKind()) 15282 << FixItHint::CreateReplacement(SourceRange(NewTagLoc), 15283 TypeWithKeyword::getTagTypeKindName(Redecl->getTagKind())); 15284 } 15285 } 15286 15287 return true; 15288 } 15289 15290 /// Add a minimal nested name specifier fixit hint to allow lookup of a tag name 15291 /// from an outer enclosing namespace or file scope inside a friend declaration. 15292 /// This should provide the commented out code in the following snippet: 15293 /// namespace N { 15294 /// struct X; 15295 /// namespace M { 15296 /// struct Y { friend struct /*N::*/ X; }; 15297 /// } 15298 /// } 15299 static FixItHint createFriendTagNNSFixIt(Sema &SemaRef, NamedDecl *ND, Scope *S, 15300 SourceLocation NameLoc) { 15301 // While the decl is in a namespace, do repeated lookup of that name and see 15302 // if we get the same namespace back. If we do not, continue until 15303 // translation unit scope, at which point we have a fully qualified NNS. 15304 SmallVector<IdentifierInfo *, 4> Namespaces; 15305 DeclContext *DC = ND->getDeclContext()->getRedeclContext(); 15306 for (; !DC->isTranslationUnit(); DC = DC->getParent()) { 15307 // This tag should be declared in a namespace, which can only be enclosed by 15308 // other namespaces. Bail if there's an anonymous namespace in the chain. 15309 NamespaceDecl *Namespace = dyn_cast<NamespaceDecl>(DC); 15310 if (!Namespace || Namespace->isAnonymousNamespace()) 15311 return FixItHint(); 15312 IdentifierInfo *II = Namespace->getIdentifier(); 15313 Namespaces.push_back(II); 15314 NamedDecl *Lookup = SemaRef.LookupSingleName( 15315 S, II, NameLoc, Sema::LookupNestedNameSpecifierName); 15316 if (Lookup == Namespace) 15317 break; 15318 } 15319 15320 // Once we have all the namespaces, reverse them to go outermost first, and 15321 // build an NNS. 15322 SmallString<64> Insertion; 15323 llvm::raw_svector_ostream OS(Insertion); 15324 if (DC->isTranslationUnit()) 15325 OS << "::"; 15326 std::reverse(Namespaces.begin(), Namespaces.end()); 15327 for (auto *II : Namespaces) 15328 OS << II->getName() << "::"; 15329 return FixItHint::CreateInsertion(NameLoc, Insertion); 15330 } 15331 15332 /// Determine whether a tag originally declared in context \p OldDC can 15333 /// be redeclared with an unqualified name in \p NewDC (assuming name lookup 15334 /// found a declaration in \p OldDC as a previous decl, perhaps through a 15335 /// using-declaration). 15336 static bool isAcceptableTagRedeclContext(Sema &S, DeclContext *OldDC, 15337 DeclContext *NewDC) { 15338 OldDC = OldDC->getRedeclContext(); 15339 NewDC = NewDC->getRedeclContext(); 15340 15341 if (OldDC->Equals(NewDC)) 15342 return true; 15343 15344 // In MSVC mode, we allow a redeclaration if the contexts are related (either 15345 // encloses the other). 15346 if (S.getLangOpts().MSVCCompat && 15347 (OldDC->Encloses(NewDC) || NewDC->Encloses(OldDC))) 15348 return true; 15349 15350 return false; 15351 } 15352 15353 /// This is invoked when we see 'struct foo' or 'struct {'. In the 15354 /// former case, Name will be non-null. In the later case, Name will be null. 15355 /// TagSpec indicates what kind of tag this is. TUK indicates whether this is a 15356 /// reference/declaration/definition of a tag. 15357 /// 15358 /// \param IsTypeSpecifier \c true if this is a type-specifier (or 15359 /// trailing-type-specifier) other than one in an alias-declaration. 15360 /// 15361 /// \param SkipBody If non-null, will be set to indicate if the caller should 15362 /// skip the definition of this tag and treat it as if it were a declaration. 15363 Decl *Sema::ActOnTag(Scope *S, unsigned TagSpec, TagUseKind TUK, 15364 SourceLocation KWLoc, CXXScopeSpec &SS, 15365 IdentifierInfo *Name, SourceLocation NameLoc, 15366 const ParsedAttributesView &Attrs, AccessSpecifier AS, 15367 SourceLocation ModulePrivateLoc, 15368 MultiTemplateParamsArg TemplateParameterLists, 15369 bool &OwnedDecl, bool &IsDependent, 15370 SourceLocation ScopedEnumKWLoc, 15371 bool ScopedEnumUsesClassTag, TypeResult UnderlyingType, 15372 bool IsTypeSpecifier, bool IsTemplateParamOrArg, 15373 SkipBodyInfo *SkipBody) { 15374 // If this is not a definition, it must have a name. 15375 IdentifierInfo *OrigName = Name; 15376 assert((Name != nullptr || TUK == TUK_Definition) && 15377 "Nameless record must be a definition!"); 15378 assert(TemplateParameterLists.size() == 0 || TUK != TUK_Reference); 15379 15380 OwnedDecl = false; 15381 TagTypeKind Kind = TypeWithKeyword::getTagTypeKindForTypeSpec(TagSpec); 15382 bool ScopedEnum = ScopedEnumKWLoc.isValid(); 15383 15384 // FIXME: Check member specializations more carefully. 15385 bool isMemberSpecialization = false; 15386 bool Invalid = false; 15387 15388 // We only need to do this matching if we have template parameters 15389 // or a scope specifier, which also conveniently avoids this work 15390 // for non-C++ cases. 15391 if (TemplateParameterLists.size() > 0 || 15392 (SS.isNotEmpty() && TUK != TUK_Reference)) { 15393 if (TemplateParameterList *TemplateParams = 15394 MatchTemplateParametersToScopeSpecifier( 15395 KWLoc, NameLoc, SS, nullptr, TemplateParameterLists, 15396 TUK == TUK_Friend, isMemberSpecialization, Invalid)) { 15397 if (Kind == TTK_Enum) { 15398 Diag(KWLoc, diag::err_enum_template); 15399 return nullptr; 15400 } 15401 15402 if (TemplateParams->size() > 0) { 15403 // This is a declaration or definition of a class template (which may 15404 // be a member of another template). 15405 15406 if (Invalid) 15407 return nullptr; 15408 15409 OwnedDecl = false; 15410 DeclResult Result = CheckClassTemplate( 15411 S, TagSpec, TUK, KWLoc, SS, Name, NameLoc, Attrs, TemplateParams, 15412 AS, ModulePrivateLoc, 15413 /*FriendLoc*/ SourceLocation(), TemplateParameterLists.size() - 1, 15414 TemplateParameterLists.data(), SkipBody); 15415 return Result.get(); 15416 } else { 15417 // The "template<>" header is extraneous. 15418 Diag(TemplateParams->getTemplateLoc(), diag::err_template_tag_noparams) 15419 << TypeWithKeyword::getTagTypeKindName(Kind) << Name; 15420 isMemberSpecialization = true; 15421 } 15422 } 15423 15424 if (!TemplateParameterLists.empty() && isMemberSpecialization && 15425 CheckTemplateDeclScope(S, TemplateParameterLists.back())) 15426 return nullptr; 15427 } 15428 15429 // Figure out the underlying type if this a enum declaration. We need to do 15430 // this early, because it's needed to detect if this is an incompatible 15431 // redeclaration. 15432 llvm::PointerUnion<const Type*, TypeSourceInfo*> EnumUnderlying; 15433 bool IsFixed = !UnderlyingType.isUnset() || ScopedEnum; 15434 15435 if (Kind == TTK_Enum) { 15436 if (UnderlyingType.isInvalid() || (!UnderlyingType.get() && ScopedEnum)) { 15437 // No underlying type explicitly specified, or we failed to parse the 15438 // type, default to int. 15439 EnumUnderlying = Context.IntTy.getTypePtr(); 15440 } else if (UnderlyingType.get()) { 15441 // C++0x 7.2p2: The type-specifier-seq of an enum-base shall name an 15442 // integral type; any cv-qualification is ignored. 15443 TypeSourceInfo *TI = nullptr; 15444 GetTypeFromParser(UnderlyingType.get(), &TI); 15445 EnumUnderlying = TI; 15446 15447 if (CheckEnumUnderlyingType(TI)) 15448 // Recover by falling back to int. 15449 EnumUnderlying = Context.IntTy.getTypePtr(); 15450 15451 if (DiagnoseUnexpandedParameterPack(TI->getTypeLoc().getBeginLoc(), TI, 15452 UPPC_FixedUnderlyingType)) 15453 EnumUnderlying = Context.IntTy.getTypePtr(); 15454 15455 } else if (Context.getTargetInfo().getTriple().isWindowsMSVCEnvironment()) { 15456 // For MSVC ABI compatibility, unfixed enums must use an underlying type 15457 // of 'int'. However, if this is an unfixed forward declaration, don't set 15458 // the underlying type unless the user enables -fms-compatibility. This 15459 // makes unfixed forward declared enums incomplete and is more conforming. 15460 if (TUK == TUK_Definition || getLangOpts().MSVCCompat) 15461 EnumUnderlying = Context.IntTy.getTypePtr(); 15462 } 15463 } 15464 15465 DeclContext *SearchDC = CurContext; 15466 DeclContext *DC = CurContext; 15467 bool isStdBadAlloc = false; 15468 bool isStdAlignValT = false; 15469 15470 RedeclarationKind Redecl = forRedeclarationInCurContext(); 15471 if (TUK == TUK_Friend || TUK == TUK_Reference) 15472 Redecl = NotForRedeclaration; 15473 15474 /// Create a new tag decl in C/ObjC. Since the ODR-like semantics for ObjC/C 15475 /// implemented asks for structural equivalence checking, the returned decl 15476 /// here is passed back to the parser, allowing the tag body to be parsed. 15477 auto createTagFromNewDecl = [&]() -> TagDecl * { 15478 assert(!getLangOpts().CPlusPlus && "not meant for C++ usage"); 15479 // If there is an identifier, use the location of the identifier as the 15480 // location of the decl, otherwise use the location of the struct/union 15481 // keyword. 15482 SourceLocation Loc = NameLoc.isValid() ? NameLoc : KWLoc; 15483 TagDecl *New = nullptr; 15484 15485 if (Kind == TTK_Enum) { 15486 New = EnumDecl::Create(Context, SearchDC, KWLoc, Loc, Name, nullptr, 15487 ScopedEnum, ScopedEnumUsesClassTag, IsFixed); 15488 // If this is an undefined enum, bail. 15489 if (TUK != TUK_Definition && !Invalid) 15490 return nullptr; 15491 if (EnumUnderlying) { 15492 EnumDecl *ED = cast<EnumDecl>(New); 15493 if (TypeSourceInfo *TI = EnumUnderlying.dyn_cast<TypeSourceInfo *>()) 15494 ED->setIntegerTypeSourceInfo(TI); 15495 else 15496 ED->setIntegerType(QualType(EnumUnderlying.get<const Type *>(), 0)); 15497 ED->setPromotionType(ED->getIntegerType()); 15498 } 15499 } else { // struct/union 15500 New = RecordDecl::Create(Context, Kind, SearchDC, KWLoc, Loc, Name, 15501 nullptr); 15502 } 15503 15504 if (RecordDecl *RD = dyn_cast<RecordDecl>(New)) { 15505 // Add alignment attributes if necessary; these attributes are checked 15506 // when the ASTContext lays out the structure. 15507 // 15508 // It is important for implementing the correct semantics that this 15509 // happen here (in ActOnTag). The #pragma pack stack is 15510 // maintained as a result of parser callbacks which can occur at 15511 // many points during the parsing of a struct declaration (because 15512 // the #pragma tokens are effectively skipped over during the 15513 // parsing of the struct). 15514 if (TUK == TUK_Definition && (!SkipBody || !SkipBody->ShouldSkip)) { 15515 AddAlignmentAttributesForRecord(RD); 15516 AddMsStructLayoutForRecord(RD); 15517 } 15518 } 15519 New->setLexicalDeclContext(CurContext); 15520 return New; 15521 }; 15522 15523 LookupResult Previous(*this, Name, NameLoc, LookupTagName, Redecl); 15524 if (Name && SS.isNotEmpty()) { 15525 // We have a nested-name tag ('struct foo::bar'). 15526 15527 // Check for invalid 'foo::'. 15528 if (SS.isInvalid()) { 15529 Name = nullptr; 15530 goto CreateNewDecl; 15531 } 15532 15533 // If this is a friend or a reference to a class in a dependent 15534 // context, don't try to make a decl for it. 15535 if (TUK == TUK_Friend || TUK == TUK_Reference) { 15536 DC = computeDeclContext(SS, false); 15537 if (!DC) { 15538 IsDependent = true; 15539 return nullptr; 15540 } 15541 } else { 15542 DC = computeDeclContext(SS, true); 15543 if (!DC) { 15544 Diag(SS.getRange().getBegin(), diag::err_dependent_nested_name_spec) 15545 << SS.getRange(); 15546 return nullptr; 15547 } 15548 } 15549 15550 if (RequireCompleteDeclContext(SS, DC)) 15551 return nullptr; 15552 15553 SearchDC = DC; 15554 // Look-up name inside 'foo::'. 15555 LookupQualifiedName(Previous, DC); 15556 15557 if (Previous.isAmbiguous()) 15558 return nullptr; 15559 15560 if (Previous.empty()) { 15561 // Name lookup did not find anything. However, if the 15562 // nested-name-specifier refers to the current instantiation, 15563 // and that current instantiation has any dependent base 15564 // classes, we might find something at instantiation time: treat 15565 // this as a dependent elaborated-type-specifier. 15566 // But this only makes any sense for reference-like lookups. 15567 if (Previous.wasNotFoundInCurrentInstantiation() && 15568 (TUK == TUK_Reference || TUK == TUK_Friend)) { 15569 IsDependent = true; 15570 return nullptr; 15571 } 15572 15573 // A tag 'foo::bar' must already exist. 15574 Diag(NameLoc, diag::err_not_tag_in_scope) 15575 << Kind << Name << DC << SS.getRange(); 15576 Name = nullptr; 15577 Invalid = true; 15578 goto CreateNewDecl; 15579 } 15580 } else if (Name) { 15581 // C++14 [class.mem]p14: 15582 // If T is the name of a class, then each of the following shall have a 15583 // name different from T: 15584 // -- every member of class T that is itself a type 15585 if (TUK != TUK_Reference && TUK != TUK_Friend && 15586 DiagnoseClassNameShadow(SearchDC, DeclarationNameInfo(Name, NameLoc))) 15587 return nullptr; 15588 15589 // If this is a named struct, check to see if there was a previous forward 15590 // declaration or definition. 15591 // FIXME: We're looking into outer scopes here, even when we 15592 // shouldn't be. Doing so can result in ambiguities that we 15593 // shouldn't be diagnosing. 15594 LookupName(Previous, S); 15595 15596 // When declaring or defining a tag, ignore ambiguities introduced 15597 // by types using'ed into this scope. 15598 if (Previous.isAmbiguous() && 15599 (TUK == TUK_Definition || TUK == TUK_Declaration)) { 15600 LookupResult::Filter F = Previous.makeFilter(); 15601 while (F.hasNext()) { 15602 NamedDecl *ND = F.next(); 15603 if (!ND->getDeclContext()->getRedeclContext()->Equals( 15604 SearchDC->getRedeclContext())) 15605 F.erase(); 15606 } 15607 F.done(); 15608 } 15609 15610 // C++11 [namespace.memdef]p3: 15611 // If the name in a friend declaration is neither qualified nor 15612 // a template-id and the declaration is a function or an 15613 // elaborated-type-specifier, the lookup to determine whether 15614 // the entity has been previously declared shall not consider 15615 // any scopes outside the innermost enclosing namespace. 15616 // 15617 // MSVC doesn't implement the above rule for types, so a friend tag 15618 // declaration may be a redeclaration of a type declared in an enclosing 15619 // scope. They do implement this rule for friend functions. 15620 // 15621 // Does it matter that this should be by scope instead of by 15622 // semantic context? 15623 if (!Previous.empty() && TUK == TUK_Friend) { 15624 DeclContext *EnclosingNS = SearchDC->getEnclosingNamespaceContext(); 15625 LookupResult::Filter F = Previous.makeFilter(); 15626 bool FriendSawTagOutsideEnclosingNamespace = false; 15627 while (F.hasNext()) { 15628 NamedDecl *ND = F.next(); 15629 DeclContext *DC = ND->getDeclContext()->getRedeclContext(); 15630 if (DC->isFileContext() && 15631 !EnclosingNS->Encloses(ND->getDeclContext())) { 15632 if (getLangOpts().MSVCCompat) 15633 FriendSawTagOutsideEnclosingNamespace = true; 15634 else 15635 F.erase(); 15636 } 15637 } 15638 F.done(); 15639 15640 // Diagnose this MSVC extension in the easy case where lookup would have 15641 // unambiguously found something outside the enclosing namespace. 15642 if (Previous.isSingleResult() && FriendSawTagOutsideEnclosingNamespace) { 15643 NamedDecl *ND = Previous.getFoundDecl(); 15644 Diag(NameLoc, diag::ext_friend_tag_redecl_outside_namespace) 15645 << createFriendTagNNSFixIt(*this, ND, S, NameLoc); 15646 } 15647 } 15648 15649 // Note: there used to be some attempt at recovery here. 15650 if (Previous.isAmbiguous()) 15651 return nullptr; 15652 15653 if (!getLangOpts().CPlusPlus && TUK != TUK_Reference) { 15654 // FIXME: This makes sure that we ignore the contexts associated 15655 // with C structs, unions, and enums when looking for a matching 15656 // tag declaration or definition. See the similar lookup tweak 15657 // in Sema::LookupName; is there a better way to deal with this? 15658 while (isa<RecordDecl>(SearchDC) || isa<EnumDecl>(SearchDC)) 15659 SearchDC = SearchDC->getParent(); 15660 } 15661 } 15662 15663 if (Previous.isSingleResult() && 15664 Previous.getFoundDecl()->isTemplateParameter()) { 15665 // Maybe we will complain about the shadowed template parameter. 15666 DiagnoseTemplateParameterShadow(NameLoc, Previous.getFoundDecl()); 15667 // Just pretend that we didn't see the previous declaration. 15668 Previous.clear(); 15669 } 15670 15671 if (getLangOpts().CPlusPlus && Name && DC && StdNamespace && 15672 DC->Equals(getStdNamespace())) { 15673 if (Name->isStr("bad_alloc")) { 15674 // This is a declaration of or a reference to "std::bad_alloc". 15675 isStdBadAlloc = true; 15676 15677 // If std::bad_alloc has been implicitly declared (but made invisible to 15678 // name lookup), fill in this implicit declaration as the previous 15679 // declaration, so that the declarations get chained appropriately. 15680 if (Previous.empty() && StdBadAlloc) 15681 Previous.addDecl(getStdBadAlloc()); 15682 } else if (Name->isStr("align_val_t")) { 15683 isStdAlignValT = true; 15684 if (Previous.empty() && StdAlignValT) 15685 Previous.addDecl(getStdAlignValT()); 15686 } 15687 } 15688 15689 // If we didn't find a previous declaration, and this is a reference 15690 // (or friend reference), move to the correct scope. In C++, we 15691 // also need to do a redeclaration lookup there, just in case 15692 // there's a shadow friend decl. 15693 if (Name && Previous.empty() && 15694 (TUK == TUK_Reference || TUK == TUK_Friend || IsTemplateParamOrArg)) { 15695 if (Invalid) goto CreateNewDecl; 15696 assert(SS.isEmpty()); 15697 15698 if (TUK == TUK_Reference || IsTemplateParamOrArg) { 15699 // C++ [basic.scope.pdecl]p5: 15700 // -- for an elaborated-type-specifier of the form 15701 // 15702 // class-key identifier 15703 // 15704 // if the elaborated-type-specifier is used in the 15705 // decl-specifier-seq or parameter-declaration-clause of a 15706 // function defined in namespace scope, the identifier is 15707 // declared as a class-name in the namespace that contains 15708 // the declaration; otherwise, except as a friend 15709 // declaration, the identifier is declared in the smallest 15710 // non-class, non-function-prototype scope that contains the 15711 // declaration. 15712 // 15713 // C99 6.7.2.3p8 has a similar (but not identical!) provision for 15714 // C structs and unions. 15715 // 15716 // It is an error in C++ to declare (rather than define) an enum 15717 // type, including via an elaborated type specifier. We'll 15718 // diagnose that later; for now, declare the enum in the same 15719 // scope as we would have picked for any other tag type. 15720 // 15721 // GNU C also supports this behavior as part of its incomplete 15722 // enum types extension, while GNU C++ does not. 15723 // 15724 // Find the context where we'll be declaring the tag. 15725 // FIXME: We would like to maintain the current DeclContext as the 15726 // lexical context, 15727 SearchDC = getTagInjectionContext(SearchDC); 15728 15729 // Find the scope where we'll be declaring the tag. 15730 S = getTagInjectionScope(S, getLangOpts()); 15731 } else { 15732 assert(TUK == TUK_Friend); 15733 // C++ [namespace.memdef]p3: 15734 // If a friend declaration in a non-local class first declares a 15735 // class or function, the friend class or function is a member of 15736 // the innermost enclosing namespace. 15737 SearchDC = SearchDC->getEnclosingNamespaceContext(); 15738 } 15739 15740 // In C++, we need to do a redeclaration lookup to properly 15741 // diagnose some problems. 15742 // FIXME: redeclaration lookup is also used (with and without C++) to find a 15743 // hidden declaration so that we don't get ambiguity errors when using a 15744 // type declared by an elaborated-type-specifier. In C that is not correct 15745 // and we should instead merge compatible types found by lookup. 15746 if (getLangOpts().CPlusPlus) { 15747 // FIXME: This can perform qualified lookups into function contexts, 15748 // which are meaningless. 15749 Previous.setRedeclarationKind(forRedeclarationInCurContext()); 15750 LookupQualifiedName(Previous, SearchDC); 15751 } else { 15752 Previous.setRedeclarationKind(forRedeclarationInCurContext()); 15753 LookupName(Previous, S); 15754 } 15755 } 15756 15757 // If we have a known previous declaration to use, then use it. 15758 if (Previous.empty() && SkipBody && SkipBody->Previous) 15759 Previous.addDecl(SkipBody->Previous); 15760 15761 if (!Previous.empty()) { 15762 NamedDecl *PrevDecl = Previous.getFoundDecl(); 15763 NamedDecl *DirectPrevDecl = Previous.getRepresentativeDecl(); 15764 15765 // It's okay to have a tag decl in the same scope as a typedef 15766 // which hides a tag decl in the same scope. Finding this 15767 // insanity with a redeclaration lookup can only actually happen 15768 // in C++. 15769 // 15770 // This is also okay for elaborated-type-specifiers, which is 15771 // technically forbidden by the current standard but which is 15772 // okay according to the likely resolution of an open issue; 15773 // see http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#407 15774 if (getLangOpts().CPlusPlus) { 15775 if (TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(PrevDecl)) { 15776 if (const TagType *TT = TD->getUnderlyingType()->getAs<TagType>()) { 15777 TagDecl *Tag = TT->getDecl(); 15778 if (Tag->getDeclName() == Name && 15779 Tag->getDeclContext()->getRedeclContext() 15780 ->Equals(TD->getDeclContext()->getRedeclContext())) { 15781 PrevDecl = Tag; 15782 Previous.clear(); 15783 Previous.addDecl(Tag); 15784 Previous.resolveKind(); 15785 } 15786 } 15787 } 15788 } 15789 15790 // If this is a redeclaration of a using shadow declaration, it must 15791 // declare a tag in the same context. In MSVC mode, we allow a 15792 // redefinition if either context is within the other. 15793 if (auto *Shadow = dyn_cast<UsingShadowDecl>(DirectPrevDecl)) { 15794 auto *OldTag = dyn_cast<TagDecl>(PrevDecl); 15795 if (SS.isEmpty() && TUK != TUK_Reference && TUK != TUK_Friend && 15796 isDeclInScope(Shadow, SearchDC, S, isMemberSpecialization) && 15797 !(OldTag && isAcceptableTagRedeclContext( 15798 *this, OldTag->getDeclContext(), SearchDC))) { 15799 Diag(KWLoc, diag::err_using_decl_conflict_reverse); 15800 Diag(Shadow->getTargetDecl()->getLocation(), 15801 diag::note_using_decl_target); 15802 Diag(Shadow->getUsingDecl()->getLocation(), diag::note_using_decl) 15803 << 0; 15804 // Recover by ignoring the old declaration. 15805 Previous.clear(); 15806 goto CreateNewDecl; 15807 } 15808 } 15809 15810 if (TagDecl *PrevTagDecl = dyn_cast<TagDecl>(PrevDecl)) { 15811 // If this is a use of a previous tag, or if the tag is already declared 15812 // in the same scope (so that the definition/declaration completes or 15813 // rementions the tag), reuse the decl. 15814 if (TUK == TUK_Reference || TUK == TUK_Friend || 15815 isDeclInScope(DirectPrevDecl, SearchDC, S, 15816 SS.isNotEmpty() || isMemberSpecialization)) { 15817 // Make sure that this wasn't declared as an enum and now used as a 15818 // struct or something similar. 15819 if (!isAcceptableTagRedeclaration(PrevTagDecl, Kind, 15820 TUK == TUK_Definition, KWLoc, 15821 Name)) { 15822 bool SafeToContinue 15823 = (PrevTagDecl->getTagKind() != TTK_Enum && 15824 Kind != TTK_Enum); 15825 if (SafeToContinue) 15826 Diag(KWLoc, diag::err_use_with_wrong_tag) 15827 << Name 15828 << FixItHint::CreateReplacement(SourceRange(KWLoc), 15829 PrevTagDecl->getKindName()); 15830 else 15831 Diag(KWLoc, diag::err_use_with_wrong_tag) << Name; 15832 Diag(PrevTagDecl->getLocation(), diag::note_previous_use); 15833 15834 if (SafeToContinue) 15835 Kind = PrevTagDecl->getTagKind(); 15836 else { 15837 // Recover by making this an anonymous redefinition. 15838 Name = nullptr; 15839 Previous.clear(); 15840 Invalid = true; 15841 } 15842 } 15843 15844 if (Kind == TTK_Enum && PrevTagDecl->getTagKind() == TTK_Enum) { 15845 const EnumDecl *PrevEnum = cast<EnumDecl>(PrevTagDecl); 15846 if (TUK == TUK_Reference || TUK == TUK_Friend) 15847 return PrevTagDecl; 15848 15849 QualType EnumUnderlyingTy; 15850 if (TypeSourceInfo *TI = EnumUnderlying.dyn_cast<TypeSourceInfo*>()) 15851 EnumUnderlyingTy = TI->getType().getUnqualifiedType(); 15852 else if (const Type *T = EnumUnderlying.dyn_cast<const Type*>()) 15853 EnumUnderlyingTy = QualType(T, 0); 15854 15855 // All conflicts with previous declarations are recovered by 15856 // returning the previous declaration, unless this is a definition, 15857 // in which case we want the caller to bail out. 15858 if (CheckEnumRedeclaration(NameLoc.isValid() ? NameLoc : KWLoc, 15859 ScopedEnum, EnumUnderlyingTy, 15860 IsFixed, PrevEnum)) 15861 return TUK == TUK_Declaration ? PrevTagDecl : nullptr; 15862 } 15863 15864 // C++11 [class.mem]p1: 15865 // A member shall not be declared twice in the member-specification, 15866 // except that a nested class or member class template can be declared 15867 // and then later defined. 15868 if (TUK == TUK_Declaration && PrevDecl->isCXXClassMember() && 15869 S->isDeclScope(PrevDecl)) { 15870 Diag(NameLoc, diag::ext_member_redeclared); 15871 Diag(PrevTagDecl->getLocation(), diag::note_previous_declaration); 15872 } 15873 15874 if (!Invalid) { 15875 // If this is a use, just return the declaration we found, unless 15876 // we have attributes. 15877 if (TUK == TUK_Reference || TUK == TUK_Friend) { 15878 if (!Attrs.empty()) { 15879 // FIXME: Diagnose these attributes. For now, we create a new 15880 // declaration to hold them. 15881 } else if (TUK == TUK_Reference && 15882 (PrevTagDecl->getFriendObjectKind() == 15883 Decl::FOK_Undeclared || 15884 PrevDecl->getOwningModule() != getCurrentModule()) && 15885 SS.isEmpty()) { 15886 // This declaration is a reference to an existing entity, but 15887 // has different visibility from that entity: it either makes 15888 // a friend visible or it makes a type visible in a new module. 15889 // In either case, create a new declaration. We only do this if 15890 // the declaration would have meant the same thing if no prior 15891 // declaration were found, that is, if it was found in the same 15892 // scope where we would have injected a declaration. 15893 if (!getTagInjectionContext(CurContext)->getRedeclContext() 15894 ->Equals(PrevDecl->getDeclContext()->getRedeclContext())) 15895 return PrevTagDecl; 15896 // This is in the injected scope, create a new declaration in 15897 // that scope. 15898 S = getTagInjectionScope(S, getLangOpts()); 15899 } else { 15900 return PrevTagDecl; 15901 } 15902 } 15903 15904 // Diagnose attempts to redefine a tag. 15905 if (TUK == TUK_Definition) { 15906 if (NamedDecl *Def = PrevTagDecl->getDefinition()) { 15907 // If we're defining a specialization and the previous definition 15908 // is from an implicit instantiation, don't emit an error 15909 // here; we'll catch this in the general case below. 15910 bool IsExplicitSpecializationAfterInstantiation = false; 15911 if (isMemberSpecialization) { 15912 if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(Def)) 15913 IsExplicitSpecializationAfterInstantiation = 15914 RD->getTemplateSpecializationKind() != 15915 TSK_ExplicitSpecialization; 15916 else if (EnumDecl *ED = dyn_cast<EnumDecl>(Def)) 15917 IsExplicitSpecializationAfterInstantiation = 15918 ED->getTemplateSpecializationKind() != 15919 TSK_ExplicitSpecialization; 15920 } 15921 15922 // Note that clang allows ODR-like semantics for ObjC/C, i.e., do 15923 // not keep more that one definition around (merge them). However, 15924 // ensure the decl passes the structural compatibility check in 15925 // C11 6.2.7/1 (or 6.1.2.6/1 in C89). 15926 NamedDecl *Hidden = nullptr; 15927 if (SkipBody && !hasVisibleDefinition(Def, &Hidden)) { 15928 // There is a definition of this tag, but it is not visible. We 15929 // explicitly make use of C++'s one definition rule here, and 15930 // assume that this definition is identical to the hidden one 15931 // we already have. Make the existing definition visible and 15932 // use it in place of this one. 15933 if (!getLangOpts().CPlusPlus) { 15934 // Postpone making the old definition visible until after we 15935 // complete parsing the new one and do the structural 15936 // comparison. 15937 SkipBody->CheckSameAsPrevious = true; 15938 SkipBody->New = createTagFromNewDecl(); 15939 SkipBody->Previous = Def; 15940 return Def; 15941 } else { 15942 SkipBody->ShouldSkip = true; 15943 SkipBody->Previous = Def; 15944 makeMergedDefinitionVisible(Hidden); 15945 // Carry on and handle it like a normal definition. We'll 15946 // skip starting the definitiion later. 15947 } 15948 } else if (!IsExplicitSpecializationAfterInstantiation) { 15949 // A redeclaration in function prototype scope in C isn't 15950 // visible elsewhere, so merely issue a warning. 15951 if (!getLangOpts().CPlusPlus && S->containedInPrototypeScope()) 15952 Diag(NameLoc, diag::warn_redefinition_in_param_list) << Name; 15953 else 15954 Diag(NameLoc, diag::err_redefinition) << Name; 15955 notePreviousDefinition(Def, 15956 NameLoc.isValid() ? NameLoc : KWLoc); 15957 // If this is a redefinition, recover by making this 15958 // struct be anonymous, which will make any later 15959 // references get the previous definition. 15960 Name = nullptr; 15961 Previous.clear(); 15962 Invalid = true; 15963 } 15964 } else { 15965 // If the type is currently being defined, complain 15966 // about a nested redefinition. 15967 auto *TD = Context.getTagDeclType(PrevTagDecl)->getAsTagDecl(); 15968 if (TD->isBeingDefined()) { 15969 Diag(NameLoc, diag::err_nested_redefinition) << Name; 15970 Diag(PrevTagDecl->getLocation(), 15971 diag::note_previous_definition); 15972 Name = nullptr; 15973 Previous.clear(); 15974 Invalid = true; 15975 } 15976 } 15977 15978 // Okay, this is definition of a previously declared or referenced 15979 // tag. We're going to create a new Decl for it. 15980 } 15981 15982 // Okay, we're going to make a redeclaration. If this is some kind 15983 // of reference, make sure we build the redeclaration in the same DC 15984 // as the original, and ignore the current access specifier. 15985 if (TUK == TUK_Friend || TUK == TUK_Reference) { 15986 SearchDC = PrevTagDecl->getDeclContext(); 15987 AS = AS_none; 15988 } 15989 } 15990 // If we get here we have (another) forward declaration or we 15991 // have a definition. Just create a new decl. 15992 15993 } else { 15994 // If we get here, this is a definition of a new tag type in a nested 15995 // scope, e.g. "struct foo; void bar() { struct foo; }", just create a 15996 // new decl/type. We set PrevDecl to NULL so that the entities 15997 // have distinct types. 15998 Previous.clear(); 15999 } 16000 // If we get here, we're going to create a new Decl. If PrevDecl 16001 // is non-NULL, it's a definition of the tag declared by 16002 // PrevDecl. If it's NULL, we have a new definition. 16003 16004 // Otherwise, PrevDecl is not a tag, but was found with tag 16005 // lookup. This is only actually possible in C++, where a few 16006 // things like templates still live in the tag namespace. 16007 } else { 16008 // Use a better diagnostic if an elaborated-type-specifier 16009 // found the wrong kind of type on the first 16010 // (non-redeclaration) lookup. 16011 if ((TUK == TUK_Reference || TUK == TUK_Friend) && 16012 !Previous.isForRedeclaration()) { 16013 NonTagKind NTK = getNonTagTypeDeclKind(PrevDecl, Kind); 16014 Diag(NameLoc, diag::err_tag_reference_non_tag) << PrevDecl << NTK 16015 << Kind; 16016 Diag(PrevDecl->getLocation(), diag::note_declared_at); 16017 Invalid = true; 16018 16019 // Otherwise, only diagnose if the declaration is in scope. 16020 } else if (!isDeclInScope(DirectPrevDecl, SearchDC, S, 16021 SS.isNotEmpty() || isMemberSpecialization)) { 16022 // do nothing 16023 16024 // Diagnose implicit declarations introduced by elaborated types. 16025 } else if (TUK == TUK_Reference || TUK == TUK_Friend) { 16026 NonTagKind NTK = getNonTagTypeDeclKind(PrevDecl, Kind); 16027 Diag(NameLoc, diag::err_tag_reference_conflict) << NTK; 16028 Diag(PrevDecl->getLocation(), diag::note_previous_decl) << PrevDecl; 16029 Invalid = true; 16030 16031 // Otherwise it's a declaration. Call out a particularly common 16032 // case here. 16033 } else if (TypedefNameDecl *TND = dyn_cast<TypedefNameDecl>(PrevDecl)) { 16034 unsigned Kind = 0; 16035 if (isa<TypeAliasDecl>(PrevDecl)) Kind = 1; 16036 Diag(NameLoc, diag::err_tag_definition_of_typedef) 16037 << Name << Kind << TND->getUnderlyingType(); 16038 Diag(PrevDecl->getLocation(), diag::note_previous_decl) << PrevDecl; 16039 Invalid = true; 16040 16041 // Otherwise, diagnose. 16042 } else { 16043 // The tag name clashes with something else in the target scope, 16044 // issue an error and recover by making this tag be anonymous. 16045 Diag(NameLoc, diag::err_redefinition_different_kind) << Name; 16046 notePreviousDefinition(PrevDecl, NameLoc); 16047 Name = nullptr; 16048 Invalid = true; 16049 } 16050 16051 // The existing declaration isn't relevant to us; we're in a 16052 // new scope, so clear out the previous declaration. 16053 Previous.clear(); 16054 } 16055 } 16056 16057 CreateNewDecl: 16058 16059 TagDecl *PrevDecl = nullptr; 16060 if (Previous.isSingleResult()) 16061 PrevDecl = cast<TagDecl>(Previous.getFoundDecl()); 16062 16063 // If there is an identifier, use the location of the identifier as the 16064 // location of the decl, otherwise use the location of the struct/union 16065 // keyword. 16066 SourceLocation Loc = NameLoc.isValid() ? NameLoc : KWLoc; 16067 16068 // Otherwise, create a new declaration. If there is a previous 16069 // declaration of the same entity, the two will be linked via 16070 // PrevDecl. 16071 TagDecl *New; 16072 16073 if (Kind == TTK_Enum) { 16074 // FIXME: Tag decls should be chained to any simultaneous vardecls, e.g.: 16075 // enum X { A, B, C } D; D should chain to X. 16076 New = EnumDecl::Create(Context, SearchDC, KWLoc, Loc, Name, 16077 cast_or_null<EnumDecl>(PrevDecl), ScopedEnum, 16078 ScopedEnumUsesClassTag, IsFixed); 16079 16080 if (isStdAlignValT && (!StdAlignValT || getStdAlignValT()->isImplicit())) 16081 StdAlignValT = cast<EnumDecl>(New); 16082 16083 // If this is an undefined enum, warn. 16084 if (TUK != TUK_Definition && !Invalid) { 16085 TagDecl *Def; 16086 if (IsFixed && cast<EnumDecl>(New)->isFixed()) { 16087 // C++0x: 7.2p2: opaque-enum-declaration. 16088 // Conflicts are diagnosed above. Do nothing. 16089 } 16090 else if (PrevDecl && (Def = cast<EnumDecl>(PrevDecl)->getDefinition())) { 16091 Diag(Loc, diag::ext_forward_ref_enum_def) 16092 << New; 16093 Diag(Def->getLocation(), diag::note_previous_definition); 16094 } else { 16095 unsigned DiagID = diag::ext_forward_ref_enum; 16096 if (getLangOpts().MSVCCompat) 16097 DiagID = diag::ext_ms_forward_ref_enum; 16098 else if (getLangOpts().CPlusPlus) 16099 DiagID = diag::err_forward_ref_enum; 16100 Diag(Loc, DiagID); 16101 } 16102 } 16103 16104 if (EnumUnderlying) { 16105 EnumDecl *ED = cast<EnumDecl>(New); 16106 if (TypeSourceInfo *TI = EnumUnderlying.dyn_cast<TypeSourceInfo*>()) 16107 ED->setIntegerTypeSourceInfo(TI); 16108 else 16109 ED->setIntegerType(QualType(EnumUnderlying.get<const Type*>(), 0)); 16110 ED->setPromotionType(ED->getIntegerType()); 16111 assert(ED->isComplete() && "enum with type should be complete"); 16112 } 16113 } else { 16114 // struct/union/class 16115 16116 // FIXME: Tag decls should be chained to any simultaneous vardecls, e.g.: 16117 // struct X { int A; } D; D should chain to X. 16118 if (getLangOpts().CPlusPlus) { 16119 // FIXME: Look for a way to use RecordDecl for simple structs. 16120 New = CXXRecordDecl::Create(Context, Kind, SearchDC, KWLoc, Loc, Name, 16121 cast_or_null<CXXRecordDecl>(PrevDecl)); 16122 16123 if (isStdBadAlloc && (!StdBadAlloc || getStdBadAlloc()->isImplicit())) 16124 StdBadAlloc = cast<CXXRecordDecl>(New); 16125 } else 16126 New = RecordDecl::Create(Context, Kind, SearchDC, KWLoc, Loc, Name, 16127 cast_or_null<RecordDecl>(PrevDecl)); 16128 } 16129 16130 // C++11 [dcl.type]p3: 16131 // A type-specifier-seq shall not define a class or enumeration [...]. 16132 if (getLangOpts().CPlusPlus && (IsTypeSpecifier || IsTemplateParamOrArg) && 16133 TUK == TUK_Definition) { 16134 Diag(New->getLocation(), diag::err_type_defined_in_type_specifier) 16135 << Context.getTagDeclType(New); 16136 Invalid = true; 16137 } 16138 16139 if (!Invalid && getLangOpts().CPlusPlus && TUK == TUK_Definition && 16140 DC->getDeclKind() == Decl::Enum) { 16141 Diag(New->getLocation(), diag::err_type_defined_in_enum) 16142 << Context.getTagDeclType(New); 16143 Invalid = true; 16144 } 16145 16146 // Maybe add qualifier info. 16147 if (SS.isNotEmpty()) { 16148 if (SS.isSet()) { 16149 // If this is either a declaration or a definition, check the 16150 // nested-name-specifier against the current context. 16151 if ((TUK == TUK_Definition || TUK == TUK_Declaration) && 16152 diagnoseQualifiedDeclaration(SS, DC, OrigName, Loc, 16153 isMemberSpecialization)) 16154 Invalid = true; 16155 16156 New->setQualifierInfo(SS.getWithLocInContext(Context)); 16157 if (TemplateParameterLists.size() > 0) { 16158 New->setTemplateParameterListsInfo(Context, TemplateParameterLists); 16159 } 16160 } 16161 else 16162 Invalid = true; 16163 } 16164 16165 if (RecordDecl *RD = dyn_cast<RecordDecl>(New)) { 16166 // Add alignment attributes if necessary; these attributes are checked when 16167 // the ASTContext lays out the structure. 16168 // 16169 // It is important for implementing the correct semantics that this 16170 // happen here (in ActOnTag). The #pragma pack stack is 16171 // maintained as a result of parser callbacks which can occur at 16172 // many points during the parsing of a struct declaration (because 16173 // the #pragma tokens are effectively skipped over during the 16174 // parsing of the struct). 16175 if (TUK == TUK_Definition && (!SkipBody || !SkipBody->ShouldSkip)) { 16176 AddAlignmentAttributesForRecord(RD); 16177 AddMsStructLayoutForRecord(RD); 16178 } 16179 } 16180 16181 if (ModulePrivateLoc.isValid()) { 16182 if (isMemberSpecialization) 16183 Diag(New->getLocation(), diag::err_module_private_specialization) 16184 << 2 16185 << FixItHint::CreateRemoval(ModulePrivateLoc); 16186 // __module_private__ does not apply to local classes. However, we only 16187 // diagnose this as an error when the declaration specifiers are 16188 // freestanding. Here, we just ignore the __module_private__. 16189 else if (!SearchDC->isFunctionOrMethod()) 16190 New->setModulePrivate(); 16191 } 16192 16193 // If this is a specialization of a member class (of a class template), 16194 // check the specialization. 16195 if (isMemberSpecialization && CheckMemberSpecialization(New, Previous)) 16196 Invalid = true; 16197 16198 // If we're declaring or defining a tag in function prototype scope in C, 16199 // note that this type can only be used within the function and add it to 16200 // the list of decls to inject into the function definition scope. 16201 if ((Name || Kind == TTK_Enum) && 16202 getNonFieldDeclScope(S)->isFunctionPrototypeScope()) { 16203 if (getLangOpts().CPlusPlus) { 16204 // C++ [dcl.fct]p6: 16205 // Types shall not be defined in return or parameter types. 16206 if (TUK == TUK_Definition && !IsTypeSpecifier) { 16207 Diag(Loc, diag::err_type_defined_in_param_type) 16208 << Name; 16209 Invalid = true; 16210 } 16211 } else if (!PrevDecl) { 16212 Diag(Loc, diag::warn_decl_in_param_list) << Context.getTagDeclType(New); 16213 } 16214 } 16215 16216 if (Invalid) 16217 New->setInvalidDecl(); 16218 16219 // Set the lexical context. If the tag has a C++ scope specifier, the 16220 // lexical context will be different from the semantic context. 16221 New->setLexicalDeclContext(CurContext); 16222 16223 // Mark this as a friend decl if applicable. 16224 // In Microsoft mode, a friend declaration also acts as a forward 16225 // declaration so we always pass true to setObjectOfFriendDecl to make 16226 // the tag name visible. 16227 if (TUK == TUK_Friend) 16228 New->setObjectOfFriendDecl(getLangOpts().MSVCCompat); 16229 16230 // Set the access specifier. 16231 if (!Invalid && SearchDC->isRecord()) 16232 SetMemberAccessSpecifier(New, PrevDecl, AS); 16233 16234 if (PrevDecl) 16235 CheckRedeclarationModuleOwnership(New, PrevDecl); 16236 16237 if (TUK == TUK_Definition && (!SkipBody || !SkipBody->ShouldSkip)) 16238 New->startDefinition(); 16239 16240 ProcessDeclAttributeList(S, New, Attrs); 16241 AddPragmaAttributes(S, New); 16242 16243 // If this has an identifier, add it to the scope stack. 16244 if (TUK == TUK_Friend) { 16245 // We might be replacing an existing declaration in the lookup tables; 16246 // if so, borrow its access specifier. 16247 if (PrevDecl) 16248 New->setAccess(PrevDecl->getAccess()); 16249 16250 DeclContext *DC = New->getDeclContext()->getRedeclContext(); 16251 DC->makeDeclVisibleInContext(New); 16252 if (Name) // can be null along some error paths 16253 if (Scope *EnclosingScope = getScopeForDeclContext(S, DC)) 16254 PushOnScopeChains(New, EnclosingScope, /* AddToContext = */ false); 16255 } else if (Name) { 16256 S = getNonFieldDeclScope(S); 16257 PushOnScopeChains(New, S, true); 16258 } else { 16259 CurContext->addDecl(New); 16260 } 16261 16262 // If this is the C FILE type, notify the AST context. 16263 if (IdentifierInfo *II = New->getIdentifier()) 16264 if (!New->isInvalidDecl() && 16265 New->getDeclContext()->getRedeclContext()->isTranslationUnit() && 16266 II->isStr("FILE")) 16267 Context.setFILEDecl(New); 16268 16269 if (PrevDecl) 16270 mergeDeclAttributes(New, PrevDecl); 16271 16272 if (auto *CXXRD = dyn_cast<CXXRecordDecl>(New)) 16273 inferGslOwnerPointerAttribute(CXXRD); 16274 16275 // If there's a #pragma GCC visibility in scope, set the visibility of this 16276 // record. 16277 AddPushedVisibilityAttribute(New); 16278 16279 if (isMemberSpecialization && !New->isInvalidDecl()) 16280 CompleteMemberSpecialization(New, Previous); 16281 16282 OwnedDecl = true; 16283 // In C++, don't return an invalid declaration. We can't recover well from 16284 // the cases where we make the type anonymous. 16285 if (Invalid && getLangOpts().CPlusPlus) { 16286 if (New->isBeingDefined()) 16287 if (auto RD = dyn_cast<RecordDecl>(New)) 16288 RD->completeDefinition(); 16289 return nullptr; 16290 } else if (SkipBody && SkipBody->ShouldSkip) { 16291 return SkipBody->Previous; 16292 } else { 16293 return New; 16294 } 16295 } 16296 16297 void Sema::ActOnTagStartDefinition(Scope *S, Decl *TagD) { 16298 AdjustDeclIfTemplate(TagD); 16299 TagDecl *Tag = cast<TagDecl>(TagD); 16300 16301 // Enter the tag context. 16302 PushDeclContext(S, Tag); 16303 16304 ActOnDocumentableDecl(TagD); 16305 16306 // If there's a #pragma GCC visibility in scope, set the visibility of this 16307 // record. 16308 AddPushedVisibilityAttribute(Tag); 16309 } 16310 16311 bool Sema::ActOnDuplicateDefinition(DeclSpec &DS, Decl *Prev, 16312 SkipBodyInfo &SkipBody) { 16313 if (!hasStructuralCompatLayout(Prev, SkipBody.New)) 16314 return false; 16315 16316 // Make the previous decl visible. 16317 makeMergedDefinitionVisible(SkipBody.Previous); 16318 return true; 16319 } 16320 16321 Decl *Sema::ActOnObjCContainerStartDefinition(Decl *IDecl) { 16322 assert(isa<ObjCContainerDecl>(IDecl) && 16323 "ActOnObjCContainerStartDefinition - Not ObjCContainerDecl"); 16324 DeclContext *OCD = cast<DeclContext>(IDecl); 16325 assert(OCD->getLexicalParent() == CurContext && 16326 "The next DeclContext should be lexically contained in the current one."); 16327 CurContext = OCD; 16328 return IDecl; 16329 } 16330 16331 void Sema::ActOnStartCXXMemberDeclarations(Scope *S, Decl *TagD, 16332 SourceLocation FinalLoc, 16333 bool IsFinalSpelledSealed, 16334 SourceLocation LBraceLoc) { 16335 AdjustDeclIfTemplate(TagD); 16336 CXXRecordDecl *Record = cast<CXXRecordDecl>(TagD); 16337 16338 FieldCollector->StartClass(); 16339 16340 if (!Record->getIdentifier()) 16341 return; 16342 16343 if (FinalLoc.isValid()) 16344 Record->addAttr(FinalAttr::Create( 16345 Context, FinalLoc, AttributeCommonInfo::AS_Keyword, 16346 static_cast<FinalAttr::Spelling>(IsFinalSpelledSealed))); 16347 16348 // C++ [class]p2: 16349 // [...] The class-name is also inserted into the scope of the 16350 // class itself; this is known as the injected-class-name. For 16351 // purposes of access checking, the injected-class-name is treated 16352 // as if it were a public member name. 16353 CXXRecordDecl *InjectedClassName = CXXRecordDecl::Create( 16354 Context, Record->getTagKind(), CurContext, Record->getBeginLoc(), 16355 Record->getLocation(), Record->getIdentifier(), 16356 /*PrevDecl=*/nullptr, 16357 /*DelayTypeCreation=*/true); 16358 Context.getTypeDeclType(InjectedClassName, Record); 16359 InjectedClassName->setImplicit(); 16360 InjectedClassName->setAccess(AS_public); 16361 if (ClassTemplateDecl *Template = Record->getDescribedClassTemplate()) 16362 InjectedClassName->setDescribedClassTemplate(Template); 16363 PushOnScopeChains(InjectedClassName, S); 16364 assert(InjectedClassName->isInjectedClassName() && 16365 "Broken injected-class-name"); 16366 } 16367 16368 void Sema::ActOnTagFinishDefinition(Scope *S, Decl *TagD, 16369 SourceRange BraceRange) { 16370 AdjustDeclIfTemplate(TagD); 16371 TagDecl *Tag = cast<TagDecl>(TagD); 16372 Tag->setBraceRange(BraceRange); 16373 16374 // Make sure we "complete" the definition even it is invalid. 16375 if (Tag->isBeingDefined()) { 16376 assert(Tag->isInvalidDecl() && "We should already have completed it"); 16377 if (RecordDecl *RD = dyn_cast<RecordDecl>(Tag)) 16378 RD->completeDefinition(); 16379 } 16380 16381 if (isa<CXXRecordDecl>(Tag)) { 16382 FieldCollector->FinishClass(); 16383 } 16384 16385 // Exit this scope of this tag's definition. 16386 PopDeclContext(); 16387 16388 if (getCurLexicalContext()->isObjCContainer() && 16389 Tag->getDeclContext()->isFileContext()) 16390 Tag->setTopLevelDeclInObjCContainer(); 16391 16392 // Notify the consumer that we've defined a tag. 16393 if (!Tag->isInvalidDecl()) 16394 Consumer.HandleTagDeclDefinition(Tag); 16395 } 16396 16397 void Sema::ActOnObjCContainerFinishDefinition() { 16398 // Exit this scope of this interface definition. 16399 PopDeclContext(); 16400 } 16401 16402 void Sema::ActOnObjCTemporaryExitContainerContext(DeclContext *DC) { 16403 assert(DC == CurContext && "Mismatch of container contexts"); 16404 OriginalLexicalContext = DC; 16405 ActOnObjCContainerFinishDefinition(); 16406 } 16407 16408 void Sema::ActOnObjCReenterContainerContext(DeclContext *DC) { 16409 ActOnObjCContainerStartDefinition(cast<Decl>(DC)); 16410 OriginalLexicalContext = nullptr; 16411 } 16412 16413 void Sema::ActOnTagDefinitionError(Scope *S, Decl *TagD) { 16414 AdjustDeclIfTemplate(TagD); 16415 TagDecl *Tag = cast<TagDecl>(TagD); 16416 Tag->setInvalidDecl(); 16417 16418 // Make sure we "complete" the definition even it is invalid. 16419 if (Tag->isBeingDefined()) { 16420 if (RecordDecl *RD = dyn_cast<RecordDecl>(Tag)) 16421 RD->completeDefinition(); 16422 } 16423 16424 // We're undoing ActOnTagStartDefinition here, not 16425 // ActOnStartCXXMemberDeclarations, so we don't have to mess with 16426 // the FieldCollector. 16427 16428 PopDeclContext(); 16429 } 16430 16431 // Note that FieldName may be null for anonymous bitfields. 16432 ExprResult Sema::VerifyBitField(SourceLocation FieldLoc, 16433 IdentifierInfo *FieldName, 16434 QualType FieldTy, bool IsMsStruct, 16435 Expr *BitWidth, bool *ZeroWidth) { 16436 assert(BitWidth); 16437 if (BitWidth->containsErrors()) 16438 return ExprError(); 16439 16440 // Default to true; that shouldn't confuse checks for emptiness 16441 if (ZeroWidth) 16442 *ZeroWidth = true; 16443 16444 // C99 6.7.2.1p4 - verify the field type. 16445 // C++ 9.6p3: A bit-field shall have integral or enumeration type. 16446 if (!FieldTy->isDependentType() && !FieldTy->isIntegralOrEnumerationType()) { 16447 // Handle incomplete and sizeless types with a specific error. 16448 if (RequireCompleteSizedType(FieldLoc, FieldTy, 16449 diag::err_field_incomplete_or_sizeless)) 16450 return ExprError(); 16451 if (FieldName) 16452 return Diag(FieldLoc, diag::err_not_integral_type_bitfield) 16453 << FieldName << FieldTy << BitWidth->getSourceRange(); 16454 return Diag(FieldLoc, diag::err_not_integral_type_anon_bitfield) 16455 << FieldTy << BitWidth->getSourceRange(); 16456 } else if (DiagnoseUnexpandedParameterPack(const_cast<Expr *>(BitWidth), 16457 UPPC_BitFieldWidth)) 16458 return ExprError(); 16459 16460 // If the bit-width is type- or value-dependent, don't try to check 16461 // it now. 16462 if (BitWidth->isValueDependent() || BitWidth->isTypeDependent()) 16463 return BitWidth; 16464 16465 llvm::APSInt Value; 16466 ExprResult ICE = VerifyIntegerConstantExpression(BitWidth, &Value, AllowFold); 16467 if (ICE.isInvalid()) 16468 return ICE; 16469 BitWidth = ICE.get(); 16470 16471 if (Value != 0 && ZeroWidth) 16472 *ZeroWidth = false; 16473 16474 // Zero-width bitfield is ok for anonymous field. 16475 if (Value == 0 && FieldName) 16476 return Diag(FieldLoc, diag::err_bitfield_has_zero_width) << FieldName; 16477 16478 if (Value.isSigned() && Value.isNegative()) { 16479 if (FieldName) 16480 return Diag(FieldLoc, diag::err_bitfield_has_negative_width) 16481 << FieldName << Value.toString(10); 16482 return Diag(FieldLoc, diag::err_anon_bitfield_has_negative_width) 16483 << Value.toString(10); 16484 } 16485 16486 // The size of the bit-field must not exceed our maximum permitted object 16487 // size. 16488 if (Value.getActiveBits() > ConstantArrayType::getMaxSizeBits(Context)) { 16489 return Diag(FieldLoc, diag::err_bitfield_too_wide) 16490 << !FieldName << FieldName << Value.toString(10); 16491 } 16492 16493 if (!FieldTy->isDependentType()) { 16494 uint64_t TypeStorageSize = Context.getTypeSize(FieldTy); 16495 uint64_t TypeWidth = Context.getIntWidth(FieldTy); 16496 bool BitfieldIsOverwide = Value.ugt(TypeWidth); 16497 16498 // Over-wide bitfields are an error in C or when using the MSVC bitfield 16499 // ABI. 16500 bool CStdConstraintViolation = 16501 BitfieldIsOverwide && !getLangOpts().CPlusPlus; 16502 bool MSBitfieldViolation = 16503 Value.ugt(TypeStorageSize) && 16504 (IsMsStruct || Context.getTargetInfo().getCXXABI().isMicrosoft()); 16505 if (CStdConstraintViolation || MSBitfieldViolation) { 16506 unsigned DiagWidth = 16507 CStdConstraintViolation ? TypeWidth : TypeStorageSize; 16508 if (FieldName) 16509 return Diag(FieldLoc, diag::err_bitfield_width_exceeds_type_width) 16510 << FieldName << Value.toString(10) 16511 << !CStdConstraintViolation << DiagWidth; 16512 16513 return Diag(FieldLoc, diag::err_anon_bitfield_width_exceeds_type_width) 16514 << Value.toString(10) << !CStdConstraintViolation 16515 << DiagWidth; 16516 } 16517 16518 // Warn on types where the user might conceivably expect to get all 16519 // specified bits as value bits: that's all integral types other than 16520 // 'bool'. 16521 if (BitfieldIsOverwide && !FieldTy->isBooleanType() && FieldName) { 16522 Diag(FieldLoc, diag::warn_bitfield_width_exceeds_type_width) 16523 << FieldName << Value.toString(10) 16524 << (unsigned)TypeWidth; 16525 } 16526 } 16527 16528 return BitWidth; 16529 } 16530 16531 /// ActOnField - Each field of a C struct/union is passed into this in order 16532 /// to create a FieldDecl object for it. 16533 Decl *Sema::ActOnField(Scope *S, Decl *TagD, SourceLocation DeclStart, 16534 Declarator &D, Expr *BitfieldWidth) { 16535 FieldDecl *Res = HandleField(S, cast_or_null<RecordDecl>(TagD), 16536 DeclStart, D, static_cast<Expr*>(BitfieldWidth), 16537 /*InitStyle=*/ICIS_NoInit, AS_public); 16538 return Res; 16539 } 16540 16541 /// HandleField - Analyze a field of a C struct or a C++ data member. 16542 /// 16543 FieldDecl *Sema::HandleField(Scope *S, RecordDecl *Record, 16544 SourceLocation DeclStart, 16545 Declarator &D, Expr *BitWidth, 16546 InClassInitStyle InitStyle, 16547 AccessSpecifier AS) { 16548 if (D.isDecompositionDeclarator()) { 16549 const DecompositionDeclarator &Decomp = D.getDecompositionDeclarator(); 16550 Diag(Decomp.getLSquareLoc(), diag::err_decomp_decl_context) 16551 << Decomp.getSourceRange(); 16552 return nullptr; 16553 } 16554 16555 IdentifierInfo *II = D.getIdentifier(); 16556 SourceLocation Loc = DeclStart; 16557 if (II) Loc = D.getIdentifierLoc(); 16558 16559 TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S); 16560 QualType T = TInfo->getType(); 16561 if (getLangOpts().CPlusPlus) { 16562 CheckExtraCXXDefaultArguments(D); 16563 16564 if (DiagnoseUnexpandedParameterPack(D.getIdentifierLoc(), TInfo, 16565 UPPC_DataMemberType)) { 16566 D.setInvalidType(); 16567 T = Context.IntTy; 16568 TInfo = Context.getTrivialTypeSourceInfo(T, Loc); 16569 } 16570 } 16571 16572 DiagnoseFunctionSpecifiers(D.getDeclSpec()); 16573 16574 if (D.getDeclSpec().isInlineSpecified()) 16575 Diag(D.getDeclSpec().getInlineSpecLoc(), diag::err_inline_non_function) 16576 << getLangOpts().CPlusPlus17; 16577 if (DeclSpec::TSCS TSCS = D.getDeclSpec().getThreadStorageClassSpec()) 16578 Diag(D.getDeclSpec().getThreadStorageClassSpecLoc(), 16579 diag::err_invalid_thread) 16580 << DeclSpec::getSpecifierName(TSCS); 16581 16582 // Check to see if this name was declared as a member previously 16583 NamedDecl *PrevDecl = nullptr; 16584 LookupResult Previous(*this, II, Loc, LookupMemberName, 16585 ForVisibleRedeclaration); 16586 LookupName(Previous, S); 16587 switch (Previous.getResultKind()) { 16588 case LookupResult::Found: 16589 case LookupResult::FoundUnresolvedValue: 16590 PrevDecl = Previous.getAsSingle<NamedDecl>(); 16591 break; 16592 16593 case LookupResult::FoundOverloaded: 16594 PrevDecl = Previous.getRepresentativeDecl(); 16595 break; 16596 16597 case LookupResult::NotFound: 16598 case LookupResult::NotFoundInCurrentInstantiation: 16599 case LookupResult::Ambiguous: 16600 break; 16601 } 16602 Previous.suppressDiagnostics(); 16603 16604 if (PrevDecl && PrevDecl->isTemplateParameter()) { 16605 // Maybe we will complain about the shadowed template parameter. 16606 DiagnoseTemplateParameterShadow(D.getIdentifierLoc(), PrevDecl); 16607 // Just pretend that we didn't see the previous declaration. 16608 PrevDecl = nullptr; 16609 } 16610 16611 if (PrevDecl && !isDeclInScope(PrevDecl, Record, S)) 16612 PrevDecl = nullptr; 16613 16614 bool Mutable 16615 = (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_mutable); 16616 SourceLocation TSSL = D.getBeginLoc(); 16617 FieldDecl *NewFD 16618 = CheckFieldDecl(II, T, TInfo, Record, Loc, Mutable, BitWidth, InitStyle, 16619 TSSL, AS, PrevDecl, &D); 16620 16621 if (NewFD->isInvalidDecl()) 16622 Record->setInvalidDecl(); 16623 16624 if (D.getDeclSpec().isModulePrivateSpecified()) 16625 NewFD->setModulePrivate(); 16626 16627 if (NewFD->isInvalidDecl() && PrevDecl) { 16628 // Don't introduce NewFD into scope; there's already something 16629 // with the same name in the same scope. 16630 } else if (II) { 16631 PushOnScopeChains(NewFD, S); 16632 } else 16633 Record->addDecl(NewFD); 16634 16635 return NewFD; 16636 } 16637 16638 /// Build a new FieldDecl and check its well-formedness. 16639 /// 16640 /// This routine builds a new FieldDecl given the fields name, type, 16641 /// record, etc. \p PrevDecl should refer to any previous declaration 16642 /// with the same name and in the same scope as the field to be 16643 /// created. 16644 /// 16645 /// \returns a new FieldDecl. 16646 /// 16647 /// \todo The Declarator argument is a hack. It will be removed once 16648 FieldDecl *Sema::CheckFieldDecl(DeclarationName Name, QualType T, 16649 TypeSourceInfo *TInfo, 16650 RecordDecl *Record, SourceLocation Loc, 16651 bool Mutable, Expr *BitWidth, 16652 InClassInitStyle InitStyle, 16653 SourceLocation TSSL, 16654 AccessSpecifier AS, NamedDecl *PrevDecl, 16655 Declarator *D) { 16656 IdentifierInfo *II = Name.getAsIdentifierInfo(); 16657 bool InvalidDecl = false; 16658 if (D) InvalidDecl = D->isInvalidType(); 16659 16660 // If we receive a broken type, recover by assuming 'int' and 16661 // marking this declaration as invalid. 16662 if (T.isNull() || T->containsErrors()) { 16663 InvalidDecl = true; 16664 T = Context.IntTy; 16665 } 16666 16667 QualType EltTy = Context.getBaseElementType(T); 16668 if (!EltTy->isDependentType() && !EltTy->containsErrors()) { 16669 if (RequireCompleteSizedType(Loc, EltTy, 16670 diag::err_field_incomplete_or_sizeless)) { 16671 // Fields of incomplete type force their record to be invalid. 16672 Record->setInvalidDecl(); 16673 InvalidDecl = true; 16674 } else { 16675 NamedDecl *Def; 16676 EltTy->isIncompleteType(&Def); 16677 if (Def && Def->isInvalidDecl()) { 16678 Record->setInvalidDecl(); 16679 InvalidDecl = true; 16680 } 16681 } 16682 } 16683 16684 // TR 18037 does not allow fields to be declared with address space 16685 if (T.hasAddressSpace() || T->isDependentAddressSpaceType() || 16686 T->getBaseElementTypeUnsafe()->isDependentAddressSpaceType()) { 16687 Diag(Loc, diag::err_field_with_address_space); 16688 Record->setInvalidDecl(); 16689 InvalidDecl = true; 16690 } 16691 16692 if (LangOpts.OpenCL) { 16693 // OpenCL v1.2 s6.9b,r & OpenCL v2.0 s6.12.5 - The following types cannot be 16694 // used as structure or union field: image, sampler, event or block types. 16695 if (T->isEventT() || T->isImageType() || T->isSamplerT() || 16696 T->isBlockPointerType()) { 16697 Diag(Loc, diag::err_opencl_type_struct_or_union_field) << T; 16698 Record->setInvalidDecl(); 16699 InvalidDecl = true; 16700 } 16701 // OpenCL v1.2 s6.9.c: bitfields are not supported. 16702 if (BitWidth) { 16703 Diag(Loc, diag::err_opencl_bitfields); 16704 InvalidDecl = true; 16705 } 16706 } 16707 16708 // Anonymous bit-fields cannot be cv-qualified (CWG 2229). 16709 if (!InvalidDecl && getLangOpts().CPlusPlus && !II && BitWidth && 16710 T.hasQualifiers()) { 16711 InvalidDecl = true; 16712 Diag(Loc, diag::err_anon_bitfield_qualifiers); 16713 } 16714 16715 // C99 6.7.2.1p8: A member of a structure or union may have any type other 16716 // than a variably modified type. 16717 if (!InvalidDecl && T->isVariablyModifiedType()) { 16718 if (!tryToFixVariablyModifiedVarType( 16719 *this, TInfo, T, Loc, diag::err_typecheck_field_variable_size)) 16720 InvalidDecl = true; 16721 } 16722 16723 // Fields can not have abstract class types 16724 if (!InvalidDecl && RequireNonAbstractType(Loc, T, 16725 diag::err_abstract_type_in_decl, 16726 AbstractFieldType)) 16727 InvalidDecl = true; 16728 16729 bool ZeroWidth = false; 16730 if (InvalidDecl) 16731 BitWidth = nullptr; 16732 // If this is declared as a bit-field, check the bit-field. 16733 if (BitWidth) { 16734 BitWidth = VerifyBitField(Loc, II, T, Record->isMsStruct(Context), BitWidth, 16735 &ZeroWidth).get(); 16736 if (!BitWidth) { 16737 InvalidDecl = true; 16738 BitWidth = nullptr; 16739 ZeroWidth = false; 16740 } 16741 } 16742 16743 // Check that 'mutable' is consistent with the type of the declaration. 16744 if (!InvalidDecl && Mutable) { 16745 unsigned DiagID = 0; 16746 if (T->isReferenceType()) 16747 DiagID = getLangOpts().MSVCCompat ? diag::ext_mutable_reference 16748 : diag::err_mutable_reference; 16749 else if (T.isConstQualified()) 16750 DiagID = diag::err_mutable_const; 16751 16752 if (DiagID) { 16753 SourceLocation ErrLoc = Loc; 16754 if (D && D->getDeclSpec().getStorageClassSpecLoc().isValid()) 16755 ErrLoc = D->getDeclSpec().getStorageClassSpecLoc(); 16756 Diag(ErrLoc, DiagID); 16757 if (DiagID != diag::ext_mutable_reference) { 16758 Mutable = false; 16759 InvalidDecl = true; 16760 } 16761 } 16762 } 16763 16764 // C++11 [class.union]p8 (DR1460): 16765 // At most one variant member of a union may have a 16766 // brace-or-equal-initializer. 16767 if (InitStyle != ICIS_NoInit) 16768 checkDuplicateDefaultInit(*this, cast<CXXRecordDecl>(Record), Loc); 16769 16770 FieldDecl *NewFD = FieldDecl::Create(Context, Record, TSSL, Loc, II, T, TInfo, 16771 BitWidth, Mutable, InitStyle); 16772 if (InvalidDecl) 16773 NewFD->setInvalidDecl(); 16774 16775 if (PrevDecl && !isa<TagDecl>(PrevDecl)) { 16776 Diag(Loc, diag::err_duplicate_member) << II; 16777 Diag(PrevDecl->getLocation(), diag::note_previous_declaration); 16778 NewFD->setInvalidDecl(); 16779 } 16780 16781 if (!InvalidDecl && getLangOpts().CPlusPlus) { 16782 if (Record->isUnion()) { 16783 if (const RecordType *RT = EltTy->getAs<RecordType>()) { 16784 CXXRecordDecl* RDecl = cast<CXXRecordDecl>(RT->getDecl()); 16785 if (RDecl->getDefinition()) { 16786 // C++ [class.union]p1: An object of a class with a non-trivial 16787 // constructor, a non-trivial copy constructor, a non-trivial 16788 // destructor, or a non-trivial copy assignment operator 16789 // cannot be a member of a union, nor can an array of such 16790 // objects. 16791 if (CheckNontrivialField(NewFD)) 16792 NewFD->setInvalidDecl(); 16793 } 16794 } 16795 16796 // C++ [class.union]p1: If a union contains a member of reference type, 16797 // the program is ill-formed, except when compiling with MSVC extensions 16798 // enabled. 16799 if (EltTy->isReferenceType()) { 16800 Diag(NewFD->getLocation(), getLangOpts().MicrosoftExt ? 16801 diag::ext_union_member_of_reference_type : 16802 diag::err_union_member_of_reference_type) 16803 << NewFD->getDeclName() << EltTy; 16804 if (!getLangOpts().MicrosoftExt) 16805 NewFD->setInvalidDecl(); 16806 } 16807 } 16808 } 16809 16810 // FIXME: We need to pass in the attributes given an AST 16811 // representation, not a parser representation. 16812 if (D) { 16813 // FIXME: The current scope is almost... but not entirely... correct here. 16814 ProcessDeclAttributes(getCurScope(), NewFD, *D); 16815 16816 if (NewFD->hasAttrs()) 16817 CheckAlignasUnderalignment(NewFD); 16818 } 16819 16820 // In auto-retain/release, infer strong retension for fields of 16821 // retainable type. 16822 if (getLangOpts().ObjCAutoRefCount && inferObjCARCLifetime(NewFD)) 16823 NewFD->setInvalidDecl(); 16824 16825 if (T.isObjCGCWeak()) 16826 Diag(Loc, diag::warn_attribute_weak_on_field); 16827 16828 // PPC MMA non-pointer types are not allowed as field types. 16829 if (Context.getTargetInfo().getTriple().isPPC64() && 16830 CheckPPCMMAType(T, NewFD->getLocation())) 16831 NewFD->setInvalidDecl(); 16832 16833 NewFD->setAccess(AS); 16834 return NewFD; 16835 } 16836 16837 bool Sema::CheckNontrivialField(FieldDecl *FD) { 16838 assert(FD); 16839 assert(getLangOpts().CPlusPlus && "valid check only for C++"); 16840 16841 if (FD->isInvalidDecl() || FD->getType()->isDependentType()) 16842 return false; 16843 16844 QualType EltTy = Context.getBaseElementType(FD->getType()); 16845 if (const RecordType *RT = EltTy->getAs<RecordType>()) { 16846 CXXRecordDecl *RDecl = cast<CXXRecordDecl>(RT->getDecl()); 16847 if (RDecl->getDefinition()) { 16848 // We check for copy constructors before constructors 16849 // because otherwise we'll never get complaints about 16850 // copy constructors. 16851 16852 CXXSpecialMember member = CXXInvalid; 16853 // We're required to check for any non-trivial constructors. Since the 16854 // implicit default constructor is suppressed if there are any 16855 // user-declared constructors, we just need to check that there is a 16856 // trivial default constructor and a trivial copy constructor. (We don't 16857 // worry about move constructors here, since this is a C++98 check.) 16858 if (RDecl->hasNonTrivialCopyConstructor()) 16859 member = CXXCopyConstructor; 16860 else if (!RDecl->hasTrivialDefaultConstructor()) 16861 member = CXXDefaultConstructor; 16862 else if (RDecl->hasNonTrivialCopyAssignment()) 16863 member = CXXCopyAssignment; 16864 else if (RDecl->hasNonTrivialDestructor()) 16865 member = CXXDestructor; 16866 16867 if (member != CXXInvalid) { 16868 if (!getLangOpts().CPlusPlus11 && 16869 getLangOpts().ObjCAutoRefCount && RDecl->hasObjectMember()) { 16870 // Objective-C++ ARC: it is an error to have a non-trivial field of 16871 // a union. However, system headers in Objective-C programs 16872 // occasionally have Objective-C lifetime objects within unions, 16873 // and rather than cause the program to fail, we make those 16874 // members unavailable. 16875 SourceLocation Loc = FD->getLocation(); 16876 if (getSourceManager().isInSystemHeader(Loc)) { 16877 if (!FD->hasAttr<UnavailableAttr>()) 16878 FD->addAttr(UnavailableAttr::CreateImplicit(Context, "", 16879 UnavailableAttr::IR_ARCFieldWithOwnership, Loc)); 16880 return false; 16881 } 16882 } 16883 16884 Diag(FD->getLocation(), getLangOpts().CPlusPlus11 ? 16885 diag::warn_cxx98_compat_nontrivial_union_or_anon_struct_member : 16886 diag::err_illegal_union_or_anon_struct_member) 16887 << FD->getParent()->isUnion() << FD->getDeclName() << member; 16888 DiagnoseNontrivial(RDecl, member); 16889 return !getLangOpts().CPlusPlus11; 16890 } 16891 } 16892 } 16893 16894 return false; 16895 } 16896 16897 /// TranslateIvarVisibility - Translate visibility from a token ID to an 16898 /// AST enum value. 16899 static ObjCIvarDecl::AccessControl 16900 TranslateIvarVisibility(tok::ObjCKeywordKind ivarVisibility) { 16901 switch (ivarVisibility) { 16902 default: llvm_unreachable("Unknown visitibility kind"); 16903 case tok::objc_private: return ObjCIvarDecl::Private; 16904 case tok::objc_public: return ObjCIvarDecl::Public; 16905 case tok::objc_protected: return ObjCIvarDecl::Protected; 16906 case tok::objc_package: return ObjCIvarDecl::Package; 16907 } 16908 } 16909 16910 /// ActOnIvar - Each ivar field of an objective-c class is passed into this 16911 /// in order to create an IvarDecl object for it. 16912 Decl *Sema::ActOnIvar(Scope *S, 16913 SourceLocation DeclStart, 16914 Declarator &D, Expr *BitfieldWidth, 16915 tok::ObjCKeywordKind Visibility) { 16916 16917 IdentifierInfo *II = D.getIdentifier(); 16918 Expr *BitWidth = (Expr*)BitfieldWidth; 16919 SourceLocation Loc = DeclStart; 16920 if (II) Loc = D.getIdentifierLoc(); 16921 16922 // FIXME: Unnamed fields can be handled in various different ways, for 16923 // example, unnamed unions inject all members into the struct namespace! 16924 16925 TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S); 16926 QualType T = TInfo->getType(); 16927 16928 if (BitWidth) { 16929 // 6.7.2.1p3, 6.7.2.1p4 16930 BitWidth = VerifyBitField(Loc, II, T, /*IsMsStruct*/false, BitWidth).get(); 16931 if (!BitWidth) 16932 D.setInvalidType(); 16933 } else { 16934 // Not a bitfield. 16935 16936 // validate II. 16937 16938 } 16939 if (T->isReferenceType()) { 16940 Diag(Loc, diag::err_ivar_reference_type); 16941 D.setInvalidType(); 16942 } 16943 // C99 6.7.2.1p8: A member of a structure or union may have any type other 16944 // than a variably modified type. 16945 else if (T->isVariablyModifiedType()) { 16946 if (!tryToFixVariablyModifiedVarType( 16947 *this, TInfo, T, Loc, diag::err_typecheck_ivar_variable_size)) 16948 D.setInvalidType(); 16949 } 16950 16951 // Get the visibility (access control) for this ivar. 16952 ObjCIvarDecl::AccessControl ac = 16953 Visibility != tok::objc_not_keyword ? TranslateIvarVisibility(Visibility) 16954 : ObjCIvarDecl::None; 16955 // Must set ivar's DeclContext to its enclosing interface. 16956 ObjCContainerDecl *EnclosingDecl = cast<ObjCContainerDecl>(CurContext); 16957 if (!EnclosingDecl || EnclosingDecl->isInvalidDecl()) 16958 return nullptr; 16959 ObjCContainerDecl *EnclosingContext; 16960 if (ObjCImplementationDecl *IMPDecl = 16961 dyn_cast<ObjCImplementationDecl>(EnclosingDecl)) { 16962 if (LangOpts.ObjCRuntime.isFragile()) { 16963 // Case of ivar declared in an implementation. Context is that of its class. 16964 EnclosingContext = IMPDecl->getClassInterface(); 16965 assert(EnclosingContext && "Implementation has no class interface!"); 16966 } 16967 else 16968 EnclosingContext = EnclosingDecl; 16969 } else { 16970 if (ObjCCategoryDecl *CDecl = 16971 dyn_cast<ObjCCategoryDecl>(EnclosingDecl)) { 16972 if (LangOpts.ObjCRuntime.isFragile() || !CDecl->IsClassExtension()) { 16973 Diag(Loc, diag::err_misplaced_ivar) << CDecl->IsClassExtension(); 16974 return nullptr; 16975 } 16976 } 16977 EnclosingContext = EnclosingDecl; 16978 } 16979 16980 // Construct the decl. 16981 ObjCIvarDecl *NewID = ObjCIvarDecl::Create(Context, EnclosingContext, 16982 DeclStart, Loc, II, T, 16983 TInfo, ac, (Expr *)BitfieldWidth); 16984 16985 if (II) { 16986 NamedDecl *PrevDecl = LookupSingleName(S, II, Loc, LookupMemberName, 16987 ForVisibleRedeclaration); 16988 if (PrevDecl && isDeclInScope(PrevDecl, EnclosingContext, S) 16989 && !isa<TagDecl>(PrevDecl)) { 16990 Diag(Loc, diag::err_duplicate_member) << II; 16991 Diag(PrevDecl->getLocation(), diag::note_previous_declaration); 16992 NewID->setInvalidDecl(); 16993 } 16994 } 16995 16996 // Process attributes attached to the ivar. 16997 ProcessDeclAttributes(S, NewID, D); 16998 16999 if (D.isInvalidType()) 17000 NewID->setInvalidDecl(); 17001 17002 // In ARC, infer 'retaining' for ivars of retainable type. 17003 if (getLangOpts().ObjCAutoRefCount && inferObjCARCLifetime(NewID)) 17004 NewID->setInvalidDecl(); 17005 17006 if (D.getDeclSpec().isModulePrivateSpecified()) 17007 NewID->setModulePrivate(); 17008 17009 if (II) { 17010 // FIXME: When interfaces are DeclContexts, we'll need to add 17011 // these to the interface. 17012 S->AddDecl(NewID); 17013 IdResolver.AddDecl(NewID); 17014 } 17015 17016 if (LangOpts.ObjCRuntime.isNonFragile() && 17017 !NewID->isInvalidDecl() && isa<ObjCInterfaceDecl>(EnclosingDecl)) 17018 Diag(Loc, diag::warn_ivars_in_interface); 17019 17020 return NewID; 17021 } 17022 17023 /// ActOnLastBitfield - This routine handles synthesized bitfields rules for 17024 /// class and class extensions. For every class \@interface and class 17025 /// extension \@interface, if the last ivar is a bitfield of any type, 17026 /// then add an implicit `char :0` ivar to the end of that interface. 17027 void Sema::ActOnLastBitfield(SourceLocation DeclLoc, 17028 SmallVectorImpl<Decl *> &AllIvarDecls) { 17029 if (LangOpts.ObjCRuntime.isFragile() || AllIvarDecls.empty()) 17030 return; 17031 17032 Decl *ivarDecl = AllIvarDecls[AllIvarDecls.size()-1]; 17033 ObjCIvarDecl *Ivar = cast<ObjCIvarDecl>(ivarDecl); 17034 17035 if (!Ivar->isBitField() || Ivar->isZeroLengthBitField(Context)) 17036 return; 17037 ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(CurContext); 17038 if (!ID) { 17039 if (ObjCCategoryDecl *CD = dyn_cast<ObjCCategoryDecl>(CurContext)) { 17040 if (!CD->IsClassExtension()) 17041 return; 17042 } 17043 // No need to add this to end of @implementation. 17044 else 17045 return; 17046 } 17047 // All conditions are met. Add a new bitfield to the tail end of ivars. 17048 llvm::APInt Zero(Context.getTypeSize(Context.IntTy), 0); 17049 Expr * BW = IntegerLiteral::Create(Context, Zero, Context.IntTy, DeclLoc); 17050 17051 Ivar = ObjCIvarDecl::Create(Context, cast<ObjCContainerDecl>(CurContext), 17052 DeclLoc, DeclLoc, nullptr, 17053 Context.CharTy, 17054 Context.getTrivialTypeSourceInfo(Context.CharTy, 17055 DeclLoc), 17056 ObjCIvarDecl::Private, BW, 17057 true); 17058 AllIvarDecls.push_back(Ivar); 17059 } 17060 17061 void Sema::ActOnFields(Scope *S, SourceLocation RecLoc, Decl *EnclosingDecl, 17062 ArrayRef<Decl *> Fields, SourceLocation LBrac, 17063 SourceLocation RBrac, 17064 const ParsedAttributesView &Attrs) { 17065 assert(EnclosingDecl && "missing record or interface decl"); 17066 17067 // If this is an Objective-C @implementation or category and we have 17068 // new fields here we should reset the layout of the interface since 17069 // it will now change. 17070 if (!Fields.empty() && isa<ObjCContainerDecl>(EnclosingDecl)) { 17071 ObjCContainerDecl *DC = cast<ObjCContainerDecl>(EnclosingDecl); 17072 switch (DC->getKind()) { 17073 default: break; 17074 case Decl::ObjCCategory: 17075 Context.ResetObjCLayout(cast<ObjCCategoryDecl>(DC)->getClassInterface()); 17076 break; 17077 case Decl::ObjCImplementation: 17078 Context. 17079 ResetObjCLayout(cast<ObjCImplementationDecl>(DC)->getClassInterface()); 17080 break; 17081 } 17082 } 17083 17084 RecordDecl *Record = dyn_cast<RecordDecl>(EnclosingDecl); 17085 CXXRecordDecl *CXXRecord = dyn_cast<CXXRecordDecl>(EnclosingDecl); 17086 17087 // Start counting up the number of named members; make sure to include 17088 // members of anonymous structs and unions in the total. 17089 unsigned NumNamedMembers = 0; 17090 if (Record) { 17091 for (const auto *I : Record->decls()) { 17092 if (const auto *IFD = dyn_cast<IndirectFieldDecl>(I)) 17093 if (IFD->getDeclName()) 17094 ++NumNamedMembers; 17095 } 17096 } 17097 17098 // Verify that all the fields are okay. 17099 SmallVector<FieldDecl*, 32> RecFields; 17100 17101 for (ArrayRef<Decl *>::iterator i = Fields.begin(), end = Fields.end(); 17102 i != end; ++i) { 17103 FieldDecl *FD = cast<FieldDecl>(*i); 17104 17105 // Get the type for the field. 17106 const Type *FDTy = FD->getType().getTypePtr(); 17107 17108 if (!FD->isAnonymousStructOrUnion()) { 17109 // Remember all fields written by the user. 17110 RecFields.push_back(FD); 17111 } 17112 17113 // If the field is already invalid for some reason, don't emit more 17114 // diagnostics about it. 17115 if (FD->isInvalidDecl()) { 17116 EnclosingDecl->setInvalidDecl(); 17117 continue; 17118 } 17119 17120 // C99 6.7.2.1p2: 17121 // A structure or union shall not contain a member with 17122 // incomplete or function type (hence, a structure shall not 17123 // contain an instance of itself, but may contain a pointer to 17124 // an instance of itself), except that the last member of a 17125 // structure with more than one named member may have incomplete 17126 // array type; such a structure (and any union containing, 17127 // possibly recursively, a member that is such a structure) 17128 // shall not be a member of a structure or an element of an 17129 // array. 17130 bool IsLastField = (i + 1 == Fields.end()); 17131 if (FDTy->isFunctionType()) { 17132 // Field declared as a function. 17133 Diag(FD->getLocation(), diag::err_field_declared_as_function) 17134 << FD->getDeclName(); 17135 FD->setInvalidDecl(); 17136 EnclosingDecl->setInvalidDecl(); 17137 continue; 17138 } else if (FDTy->isIncompleteArrayType() && 17139 (Record || isa<ObjCContainerDecl>(EnclosingDecl))) { 17140 if (Record) { 17141 // Flexible array member. 17142 // Microsoft and g++ is more permissive regarding flexible array. 17143 // It will accept flexible array in union and also 17144 // as the sole element of a struct/class. 17145 unsigned DiagID = 0; 17146 if (!Record->isUnion() && !IsLastField) { 17147 Diag(FD->getLocation(), diag::err_flexible_array_not_at_end) 17148 << FD->getDeclName() << FD->getType() << Record->getTagKind(); 17149 Diag((*(i + 1))->getLocation(), diag::note_next_field_declaration); 17150 FD->setInvalidDecl(); 17151 EnclosingDecl->setInvalidDecl(); 17152 continue; 17153 } else if (Record->isUnion()) 17154 DiagID = getLangOpts().MicrosoftExt 17155 ? diag::ext_flexible_array_union_ms 17156 : getLangOpts().CPlusPlus 17157 ? diag::ext_flexible_array_union_gnu 17158 : diag::err_flexible_array_union; 17159 else if (NumNamedMembers < 1) 17160 DiagID = getLangOpts().MicrosoftExt 17161 ? diag::ext_flexible_array_empty_aggregate_ms 17162 : getLangOpts().CPlusPlus 17163 ? diag::ext_flexible_array_empty_aggregate_gnu 17164 : diag::err_flexible_array_empty_aggregate; 17165 17166 if (DiagID) 17167 Diag(FD->getLocation(), DiagID) << FD->getDeclName() 17168 << Record->getTagKind(); 17169 // While the layout of types that contain virtual bases is not specified 17170 // by the C++ standard, both the Itanium and Microsoft C++ ABIs place 17171 // virtual bases after the derived members. This would make a flexible 17172 // array member declared at the end of an object not adjacent to the end 17173 // of the type. 17174 if (CXXRecord && CXXRecord->getNumVBases() != 0) 17175 Diag(FD->getLocation(), diag::err_flexible_array_virtual_base) 17176 << FD->getDeclName() << Record->getTagKind(); 17177 if (!getLangOpts().C99) 17178 Diag(FD->getLocation(), diag::ext_c99_flexible_array_member) 17179 << FD->getDeclName() << Record->getTagKind(); 17180 17181 // If the element type has a non-trivial destructor, we would not 17182 // implicitly destroy the elements, so disallow it for now. 17183 // 17184 // FIXME: GCC allows this. We should probably either implicitly delete 17185 // the destructor of the containing class, or just allow this. 17186 QualType BaseElem = Context.getBaseElementType(FD->getType()); 17187 if (!BaseElem->isDependentType() && BaseElem.isDestructedType()) { 17188 Diag(FD->getLocation(), diag::err_flexible_array_has_nontrivial_dtor) 17189 << FD->getDeclName() << FD->getType(); 17190 FD->setInvalidDecl(); 17191 EnclosingDecl->setInvalidDecl(); 17192 continue; 17193 } 17194 // Okay, we have a legal flexible array member at the end of the struct. 17195 Record->setHasFlexibleArrayMember(true); 17196 } else { 17197 // In ObjCContainerDecl ivars with incomplete array type are accepted, 17198 // unless they are followed by another ivar. That check is done 17199 // elsewhere, after synthesized ivars are known. 17200 } 17201 } else if (!FDTy->isDependentType() && 17202 RequireCompleteSizedType( 17203 FD->getLocation(), FD->getType(), 17204 diag::err_field_incomplete_or_sizeless)) { 17205 // Incomplete type 17206 FD->setInvalidDecl(); 17207 EnclosingDecl->setInvalidDecl(); 17208 continue; 17209 } else if (const RecordType *FDTTy = FDTy->getAs<RecordType>()) { 17210 if (Record && FDTTy->getDecl()->hasFlexibleArrayMember()) { 17211 // A type which contains a flexible array member is considered to be a 17212 // flexible array member. 17213 Record->setHasFlexibleArrayMember(true); 17214 if (!Record->isUnion()) { 17215 // If this is a struct/class and this is not the last element, reject 17216 // it. Note that GCC supports variable sized arrays in the middle of 17217 // structures. 17218 if (!IsLastField) 17219 Diag(FD->getLocation(), diag::ext_variable_sized_type_in_struct) 17220 << FD->getDeclName() << FD->getType(); 17221 else { 17222 // We support flexible arrays at the end of structs in 17223 // other structs as an extension. 17224 Diag(FD->getLocation(), diag::ext_flexible_array_in_struct) 17225 << FD->getDeclName(); 17226 } 17227 } 17228 } 17229 if (isa<ObjCContainerDecl>(EnclosingDecl) && 17230 RequireNonAbstractType(FD->getLocation(), FD->getType(), 17231 diag::err_abstract_type_in_decl, 17232 AbstractIvarType)) { 17233 // Ivars can not have abstract class types 17234 FD->setInvalidDecl(); 17235 } 17236 if (Record && FDTTy->getDecl()->hasObjectMember()) 17237 Record->setHasObjectMember(true); 17238 if (Record && FDTTy->getDecl()->hasVolatileMember()) 17239 Record->setHasVolatileMember(true); 17240 } else if (FDTy->isObjCObjectType()) { 17241 /// A field cannot be an Objective-c object 17242 Diag(FD->getLocation(), diag::err_statically_allocated_object) 17243 << FixItHint::CreateInsertion(FD->getLocation(), "*"); 17244 QualType T = Context.getObjCObjectPointerType(FD->getType()); 17245 FD->setType(T); 17246 } else if (Record && Record->isUnion() && 17247 FD->getType().hasNonTrivialObjCLifetime() && 17248 getSourceManager().isInSystemHeader(FD->getLocation()) && 17249 !getLangOpts().CPlusPlus && !FD->hasAttr<UnavailableAttr>() && 17250 (FD->getType().getObjCLifetime() != Qualifiers::OCL_Strong || 17251 !Context.hasDirectOwnershipQualifier(FD->getType()))) { 17252 // For backward compatibility, fields of C unions declared in system 17253 // headers that have non-trivial ObjC ownership qualifications are marked 17254 // as unavailable unless the qualifier is explicit and __strong. This can 17255 // break ABI compatibility between programs compiled with ARC and MRR, but 17256 // is a better option than rejecting programs using those unions under 17257 // ARC. 17258 FD->addAttr(UnavailableAttr::CreateImplicit( 17259 Context, "", UnavailableAttr::IR_ARCFieldWithOwnership, 17260 FD->getLocation())); 17261 } else if (getLangOpts().ObjC && 17262 getLangOpts().getGC() != LangOptions::NonGC && Record && 17263 !Record->hasObjectMember()) { 17264 if (FD->getType()->isObjCObjectPointerType() || 17265 FD->getType().isObjCGCStrong()) 17266 Record->setHasObjectMember(true); 17267 else if (Context.getAsArrayType(FD->getType())) { 17268 QualType BaseType = Context.getBaseElementType(FD->getType()); 17269 if (BaseType->isRecordType() && 17270 BaseType->castAs<RecordType>()->getDecl()->hasObjectMember()) 17271 Record->setHasObjectMember(true); 17272 else if (BaseType->isObjCObjectPointerType() || 17273 BaseType.isObjCGCStrong()) 17274 Record->setHasObjectMember(true); 17275 } 17276 } 17277 17278 if (Record && !getLangOpts().CPlusPlus && 17279 !shouldIgnoreForRecordTriviality(FD)) { 17280 QualType FT = FD->getType(); 17281 if (FT.isNonTrivialToPrimitiveDefaultInitialize()) { 17282 Record->setNonTrivialToPrimitiveDefaultInitialize(true); 17283 if (FT.hasNonTrivialToPrimitiveDefaultInitializeCUnion() || 17284 Record->isUnion()) 17285 Record->setHasNonTrivialToPrimitiveDefaultInitializeCUnion(true); 17286 } 17287 QualType::PrimitiveCopyKind PCK = FT.isNonTrivialToPrimitiveCopy(); 17288 if (PCK != QualType::PCK_Trivial && PCK != QualType::PCK_VolatileTrivial) { 17289 Record->setNonTrivialToPrimitiveCopy(true); 17290 if (FT.hasNonTrivialToPrimitiveCopyCUnion() || Record->isUnion()) 17291 Record->setHasNonTrivialToPrimitiveCopyCUnion(true); 17292 } 17293 if (FT.isDestructedType()) { 17294 Record->setNonTrivialToPrimitiveDestroy(true); 17295 Record->setParamDestroyedInCallee(true); 17296 if (FT.hasNonTrivialToPrimitiveDestructCUnion() || Record->isUnion()) 17297 Record->setHasNonTrivialToPrimitiveDestructCUnion(true); 17298 } 17299 17300 if (const auto *RT = FT->getAs<RecordType>()) { 17301 if (RT->getDecl()->getArgPassingRestrictions() == 17302 RecordDecl::APK_CanNeverPassInRegs) 17303 Record->setArgPassingRestrictions(RecordDecl::APK_CanNeverPassInRegs); 17304 } else if (FT.getQualifiers().getObjCLifetime() == Qualifiers::OCL_Weak) 17305 Record->setArgPassingRestrictions(RecordDecl::APK_CanNeverPassInRegs); 17306 } 17307 17308 if (Record && FD->getType().isVolatileQualified()) 17309 Record->setHasVolatileMember(true); 17310 // Keep track of the number of named members. 17311 if (FD->getIdentifier()) 17312 ++NumNamedMembers; 17313 } 17314 17315 // Okay, we successfully defined 'Record'. 17316 if (Record) { 17317 bool Completed = false; 17318 if (CXXRecord) { 17319 if (!CXXRecord->isInvalidDecl()) { 17320 // Set access bits correctly on the directly-declared conversions. 17321 for (CXXRecordDecl::conversion_iterator 17322 I = CXXRecord->conversion_begin(), 17323 E = CXXRecord->conversion_end(); I != E; ++I) 17324 I.setAccess((*I)->getAccess()); 17325 } 17326 17327 // Add any implicitly-declared members to this class. 17328 AddImplicitlyDeclaredMembersToClass(CXXRecord); 17329 17330 if (!CXXRecord->isDependentType()) { 17331 if (!CXXRecord->isInvalidDecl()) { 17332 // If we have virtual base classes, we may end up finding multiple 17333 // final overriders for a given virtual function. Check for this 17334 // problem now. 17335 if (CXXRecord->getNumVBases()) { 17336 CXXFinalOverriderMap FinalOverriders; 17337 CXXRecord->getFinalOverriders(FinalOverriders); 17338 17339 for (CXXFinalOverriderMap::iterator M = FinalOverriders.begin(), 17340 MEnd = FinalOverriders.end(); 17341 M != MEnd; ++M) { 17342 for (OverridingMethods::iterator SO = M->second.begin(), 17343 SOEnd = M->second.end(); 17344 SO != SOEnd; ++SO) { 17345 assert(SO->second.size() > 0 && 17346 "Virtual function without overriding functions?"); 17347 if (SO->second.size() == 1) 17348 continue; 17349 17350 // C++ [class.virtual]p2: 17351 // In a derived class, if a virtual member function of a base 17352 // class subobject has more than one final overrider the 17353 // program is ill-formed. 17354 Diag(Record->getLocation(), diag::err_multiple_final_overriders) 17355 << (const NamedDecl *)M->first << Record; 17356 Diag(M->first->getLocation(), 17357 diag::note_overridden_virtual_function); 17358 for (OverridingMethods::overriding_iterator 17359 OM = SO->second.begin(), 17360 OMEnd = SO->second.end(); 17361 OM != OMEnd; ++OM) 17362 Diag(OM->Method->getLocation(), diag::note_final_overrider) 17363 << (const NamedDecl *)M->first << OM->Method->getParent(); 17364 17365 Record->setInvalidDecl(); 17366 } 17367 } 17368 CXXRecord->completeDefinition(&FinalOverriders); 17369 Completed = true; 17370 } 17371 } 17372 } 17373 } 17374 17375 if (!Completed) 17376 Record->completeDefinition(); 17377 17378 // Handle attributes before checking the layout. 17379 ProcessDeclAttributeList(S, Record, Attrs); 17380 17381 // We may have deferred checking for a deleted destructor. Check now. 17382 if (CXXRecord) { 17383 auto *Dtor = CXXRecord->getDestructor(); 17384 if (Dtor && Dtor->isImplicit() && 17385 ShouldDeleteSpecialMember(Dtor, CXXDestructor)) { 17386 CXXRecord->setImplicitDestructorIsDeleted(); 17387 SetDeclDeleted(Dtor, CXXRecord->getLocation()); 17388 } 17389 } 17390 17391 if (Record->hasAttrs()) { 17392 CheckAlignasUnderalignment(Record); 17393 17394 if (const MSInheritanceAttr *IA = Record->getAttr<MSInheritanceAttr>()) 17395 checkMSInheritanceAttrOnDefinition(cast<CXXRecordDecl>(Record), 17396 IA->getRange(), IA->getBestCase(), 17397 IA->getInheritanceModel()); 17398 } 17399 17400 // Check if the structure/union declaration is a type that can have zero 17401 // size in C. For C this is a language extension, for C++ it may cause 17402 // compatibility problems. 17403 bool CheckForZeroSize; 17404 if (!getLangOpts().CPlusPlus) { 17405 CheckForZeroSize = true; 17406 } else { 17407 // For C++ filter out types that cannot be referenced in C code. 17408 CXXRecordDecl *CXXRecord = cast<CXXRecordDecl>(Record); 17409 CheckForZeroSize = 17410 CXXRecord->getLexicalDeclContext()->isExternCContext() && 17411 !CXXRecord->isDependentType() && !inTemplateInstantiation() && 17412 CXXRecord->isCLike(); 17413 } 17414 if (CheckForZeroSize) { 17415 bool ZeroSize = true; 17416 bool IsEmpty = true; 17417 unsigned NonBitFields = 0; 17418 for (RecordDecl::field_iterator I = Record->field_begin(), 17419 E = Record->field_end(); 17420 (NonBitFields == 0 || ZeroSize) && I != E; ++I) { 17421 IsEmpty = false; 17422 if (I->isUnnamedBitfield()) { 17423 if (!I->isZeroLengthBitField(Context)) 17424 ZeroSize = false; 17425 } else { 17426 ++NonBitFields; 17427 QualType FieldType = I->getType(); 17428 if (FieldType->isIncompleteType() || 17429 !Context.getTypeSizeInChars(FieldType).isZero()) 17430 ZeroSize = false; 17431 } 17432 } 17433 17434 // Empty structs are an extension in C (C99 6.7.2.1p7). They are 17435 // allowed in C++, but warn if its declaration is inside 17436 // extern "C" block. 17437 if (ZeroSize) { 17438 Diag(RecLoc, getLangOpts().CPlusPlus ? 17439 diag::warn_zero_size_struct_union_in_extern_c : 17440 diag::warn_zero_size_struct_union_compat) 17441 << IsEmpty << Record->isUnion() << (NonBitFields > 1); 17442 } 17443 17444 // Structs without named members are extension in C (C99 6.7.2.1p7), 17445 // but are accepted by GCC. 17446 if (NonBitFields == 0 && !getLangOpts().CPlusPlus) { 17447 Diag(RecLoc, IsEmpty ? diag::ext_empty_struct_union : 17448 diag::ext_no_named_members_in_struct_union) 17449 << Record->isUnion(); 17450 } 17451 } 17452 } else { 17453 ObjCIvarDecl **ClsFields = 17454 reinterpret_cast<ObjCIvarDecl**>(RecFields.data()); 17455 if (ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(EnclosingDecl)) { 17456 ID->setEndOfDefinitionLoc(RBrac); 17457 // Add ivar's to class's DeclContext. 17458 for (unsigned i = 0, e = RecFields.size(); i != e; ++i) { 17459 ClsFields[i]->setLexicalDeclContext(ID); 17460 ID->addDecl(ClsFields[i]); 17461 } 17462 // Must enforce the rule that ivars in the base classes may not be 17463 // duplicates. 17464 if (ID->getSuperClass()) 17465 DiagnoseDuplicateIvars(ID, ID->getSuperClass()); 17466 } else if (ObjCImplementationDecl *IMPDecl = 17467 dyn_cast<ObjCImplementationDecl>(EnclosingDecl)) { 17468 assert(IMPDecl && "ActOnFields - missing ObjCImplementationDecl"); 17469 for (unsigned I = 0, N = RecFields.size(); I != N; ++I) 17470 // Ivar declared in @implementation never belongs to the implementation. 17471 // Only it is in implementation's lexical context. 17472 ClsFields[I]->setLexicalDeclContext(IMPDecl); 17473 CheckImplementationIvars(IMPDecl, ClsFields, RecFields.size(), RBrac); 17474 IMPDecl->setIvarLBraceLoc(LBrac); 17475 IMPDecl->setIvarRBraceLoc(RBrac); 17476 } else if (ObjCCategoryDecl *CDecl = 17477 dyn_cast<ObjCCategoryDecl>(EnclosingDecl)) { 17478 // case of ivars in class extension; all other cases have been 17479 // reported as errors elsewhere. 17480 // FIXME. Class extension does not have a LocEnd field. 17481 // CDecl->setLocEnd(RBrac); 17482 // Add ivar's to class extension's DeclContext. 17483 // Diagnose redeclaration of private ivars. 17484 ObjCInterfaceDecl *IDecl = CDecl->getClassInterface(); 17485 for (unsigned i = 0, e = RecFields.size(); i != e; ++i) { 17486 if (IDecl) { 17487 if (const ObjCIvarDecl *ClsIvar = 17488 IDecl->getIvarDecl(ClsFields[i]->getIdentifier())) { 17489 Diag(ClsFields[i]->getLocation(), 17490 diag::err_duplicate_ivar_declaration); 17491 Diag(ClsIvar->getLocation(), diag::note_previous_definition); 17492 continue; 17493 } 17494 for (const auto *Ext : IDecl->known_extensions()) { 17495 if (const ObjCIvarDecl *ClsExtIvar 17496 = Ext->getIvarDecl(ClsFields[i]->getIdentifier())) { 17497 Diag(ClsFields[i]->getLocation(), 17498 diag::err_duplicate_ivar_declaration); 17499 Diag(ClsExtIvar->getLocation(), diag::note_previous_definition); 17500 continue; 17501 } 17502 } 17503 } 17504 ClsFields[i]->setLexicalDeclContext(CDecl); 17505 CDecl->addDecl(ClsFields[i]); 17506 } 17507 CDecl->setIvarLBraceLoc(LBrac); 17508 CDecl->setIvarRBraceLoc(RBrac); 17509 } 17510 } 17511 } 17512 17513 /// Determine whether the given integral value is representable within 17514 /// the given type T. 17515 static bool isRepresentableIntegerValue(ASTContext &Context, 17516 llvm::APSInt &Value, 17517 QualType T) { 17518 assert((T->isIntegralType(Context) || T->isEnumeralType()) && 17519 "Integral type required!"); 17520 unsigned BitWidth = Context.getIntWidth(T); 17521 17522 if (Value.isUnsigned() || Value.isNonNegative()) { 17523 if (T->isSignedIntegerOrEnumerationType()) 17524 --BitWidth; 17525 return Value.getActiveBits() <= BitWidth; 17526 } 17527 return Value.getMinSignedBits() <= BitWidth; 17528 } 17529 17530 // Given an integral type, return the next larger integral type 17531 // (or a NULL type of no such type exists). 17532 static QualType getNextLargerIntegralType(ASTContext &Context, QualType T) { 17533 // FIXME: Int128/UInt128 support, which also needs to be introduced into 17534 // enum checking below. 17535 assert((T->isIntegralType(Context) || 17536 T->isEnumeralType()) && "Integral type required!"); 17537 const unsigned NumTypes = 4; 17538 QualType SignedIntegralTypes[NumTypes] = { 17539 Context.ShortTy, Context.IntTy, Context.LongTy, Context.LongLongTy 17540 }; 17541 QualType UnsignedIntegralTypes[NumTypes] = { 17542 Context.UnsignedShortTy, Context.UnsignedIntTy, Context.UnsignedLongTy, 17543 Context.UnsignedLongLongTy 17544 }; 17545 17546 unsigned BitWidth = Context.getTypeSize(T); 17547 QualType *Types = T->isSignedIntegerOrEnumerationType()? SignedIntegralTypes 17548 : UnsignedIntegralTypes; 17549 for (unsigned I = 0; I != NumTypes; ++I) 17550 if (Context.getTypeSize(Types[I]) > BitWidth) 17551 return Types[I]; 17552 17553 return QualType(); 17554 } 17555 17556 EnumConstantDecl *Sema::CheckEnumConstant(EnumDecl *Enum, 17557 EnumConstantDecl *LastEnumConst, 17558 SourceLocation IdLoc, 17559 IdentifierInfo *Id, 17560 Expr *Val) { 17561 unsigned IntWidth = Context.getTargetInfo().getIntWidth(); 17562 llvm::APSInt EnumVal(IntWidth); 17563 QualType EltTy; 17564 17565 if (Val && DiagnoseUnexpandedParameterPack(Val, UPPC_EnumeratorValue)) 17566 Val = nullptr; 17567 17568 if (Val) 17569 Val = DefaultLvalueConversion(Val).get(); 17570 17571 if (Val) { 17572 if (Enum->isDependentType() || Val->isTypeDependent()) 17573 EltTy = Context.DependentTy; 17574 else { 17575 // FIXME: We don't allow folding in C++11 mode for an enum with a fixed 17576 // underlying type, but do allow it in all other contexts. 17577 if (getLangOpts().CPlusPlus11 && Enum->isFixed()) { 17578 // C++11 [dcl.enum]p5: If the underlying type is fixed, [...] the 17579 // constant-expression in the enumerator-definition shall be a converted 17580 // constant expression of the underlying type. 17581 EltTy = Enum->getIntegerType(); 17582 ExprResult Converted = 17583 CheckConvertedConstantExpression(Val, EltTy, EnumVal, 17584 CCEK_Enumerator); 17585 if (Converted.isInvalid()) 17586 Val = nullptr; 17587 else 17588 Val = Converted.get(); 17589 } else if (!Val->isValueDependent() && 17590 !(Val = 17591 VerifyIntegerConstantExpression(Val, &EnumVal, AllowFold) 17592 .get())) { 17593 // C99 6.7.2.2p2: Make sure we have an integer constant expression. 17594 } else { 17595 if (Enum->isComplete()) { 17596 EltTy = Enum->getIntegerType(); 17597 17598 // In Obj-C and Microsoft mode, require the enumeration value to be 17599 // representable in the underlying type of the enumeration. In C++11, 17600 // we perform a non-narrowing conversion as part of converted constant 17601 // expression checking. 17602 if (!isRepresentableIntegerValue(Context, EnumVal, EltTy)) { 17603 if (Context.getTargetInfo() 17604 .getTriple() 17605 .isWindowsMSVCEnvironment()) { 17606 Diag(IdLoc, diag::ext_enumerator_too_large) << EltTy; 17607 } else { 17608 Diag(IdLoc, diag::err_enumerator_too_large) << EltTy; 17609 } 17610 } 17611 17612 // Cast to the underlying type. 17613 Val = ImpCastExprToType(Val, EltTy, 17614 EltTy->isBooleanType() ? CK_IntegralToBoolean 17615 : CK_IntegralCast) 17616 .get(); 17617 } else if (getLangOpts().CPlusPlus) { 17618 // C++11 [dcl.enum]p5: 17619 // If the underlying type is not fixed, the type of each enumerator 17620 // is the type of its initializing value: 17621 // - If an initializer is specified for an enumerator, the 17622 // initializing value has the same type as the expression. 17623 EltTy = Val->getType(); 17624 } else { 17625 // C99 6.7.2.2p2: 17626 // The expression that defines the value of an enumeration constant 17627 // shall be an integer constant expression that has a value 17628 // representable as an int. 17629 17630 // Complain if the value is not representable in an int. 17631 if (!isRepresentableIntegerValue(Context, EnumVal, Context.IntTy)) 17632 Diag(IdLoc, diag::ext_enum_value_not_int) 17633 << EnumVal.toString(10) << Val->getSourceRange() 17634 << (EnumVal.isUnsigned() || EnumVal.isNonNegative()); 17635 else if (!Context.hasSameType(Val->getType(), Context.IntTy)) { 17636 // Force the type of the expression to 'int'. 17637 Val = ImpCastExprToType(Val, Context.IntTy, CK_IntegralCast).get(); 17638 } 17639 EltTy = Val->getType(); 17640 } 17641 } 17642 } 17643 } 17644 17645 if (!Val) { 17646 if (Enum->isDependentType()) 17647 EltTy = Context.DependentTy; 17648 else if (!LastEnumConst) { 17649 // C++0x [dcl.enum]p5: 17650 // If the underlying type is not fixed, the type of each enumerator 17651 // is the type of its initializing value: 17652 // - If no initializer is specified for the first enumerator, the 17653 // initializing value has an unspecified integral type. 17654 // 17655 // GCC uses 'int' for its unspecified integral type, as does 17656 // C99 6.7.2.2p3. 17657 if (Enum->isFixed()) { 17658 EltTy = Enum->getIntegerType(); 17659 } 17660 else { 17661 EltTy = Context.IntTy; 17662 } 17663 } else { 17664 // Assign the last value + 1. 17665 EnumVal = LastEnumConst->getInitVal(); 17666 ++EnumVal; 17667 EltTy = LastEnumConst->getType(); 17668 17669 // Check for overflow on increment. 17670 if (EnumVal < LastEnumConst->getInitVal()) { 17671 // C++0x [dcl.enum]p5: 17672 // If the underlying type is not fixed, the type of each enumerator 17673 // is the type of its initializing value: 17674 // 17675 // - Otherwise the type of the initializing value is the same as 17676 // the type of the initializing value of the preceding enumerator 17677 // unless the incremented value is not representable in that type, 17678 // in which case the type is an unspecified integral type 17679 // sufficient to contain the incremented value. If no such type 17680 // exists, the program is ill-formed. 17681 QualType T = getNextLargerIntegralType(Context, EltTy); 17682 if (T.isNull() || Enum->isFixed()) { 17683 // There is no integral type larger enough to represent this 17684 // value. Complain, then allow the value to wrap around. 17685 EnumVal = LastEnumConst->getInitVal(); 17686 EnumVal = EnumVal.zext(EnumVal.getBitWidth() * 2); 17687 ++EnumVal; 17688 if (Enum->isFixed()) 17689 // When the underlying type is fixed, this is ill-formed. 17690 Diag(IdLoc, diag::err_enumerator_wrapped) 17691 << EnumVal.toString(10) 17692 << EltTy; 17693 else 17694 Diag(IdLoc, diag::ext_enumerator_increment_too_large) 17695 << EnumVal.toString(10); 17696 } else { 17697 EltTy = T; 17698 } 17699 17700 // Retrieve the last enumerator's value, extent that type to the 17701 // type that is supposed to be large enough to represent the incremented 17702 // value, then increment. 17703 EnumVal = LastEnumConst->getInitVal(); 17704 EnumVal.setIsSigned(EltTy->isSignedIntegerOrEnumerationType()); 17705 EnumVal = EnumVal.zextOrTrunc(Context.getIntWidth(EltTy)); 17706 ++EnumVal; 17707 17708 // If we're not in C++, diagnose the overflow of enumerator values, 17709 // which in C99 means that the enumerator value is not representable in 17710 // an int (C99 6.7.2.2p2). However, we support GCC's extension that 17711 // permits enumerator values that are representable in some larger 17712 // integral type. 17713 if (!getLangOpts().CPlusPlus && !T.isNull()) 17714 Diag(IdLoc, diag::warn_enum_value_overflow); 17715 } else if (!getLangOpts().CPlusPlus && 17716 !isRepresentableIntegerValue(Context, EnumVal, EltTy)) { 17717 // Enforce C99 6.7.2.2p2 even when we compute the next value. 17718 Diag(IdLoc, diag::ext_enum_value_not_int) 17719 << EnumVal.toString(10) << 1; 17720 } 17721 } 17722 } 17723 17724 if (!EltTy->isDependentType()) { 17725 // Make the enumerator value match the signedness and size of the 17726 // enumerator's type. 17727 EnumVal = EnumVal.extOrTrunc(Context.getIntWidth(EltTy)); 17728 EnumVal.setIsSigned(EltTy->isSignedIntegerOrEnumerationType()); 17729 } 17730 17731 return EnumConstantDecl::Create(Context, Enum, IdLoc, Id, EltTy, 17732 Val, EnumVal); 17733 } 17734 17735 Sema::SkipBodyInfo Sema::shouldSkipAnonEnumBody(Scope *S, IdentifierInfo *II, 17736 SourceLocation IILoc) { 17737 if (!(getLangOpts().Modules || getLangOpts().ModulesLocalVisibility) || 17738 !getLangOpts().CPlusPlus) 17739 return SkipBodyInfo(); 17740 17741 // We have an anonymous enum definition. Look up the first enumerator to 17742 // determine if we should merge the definition with an existing one and 17743 // skip the body. 17744 NamedDecl *PrevDecl = LookupSingleName(S, II, IILoc, LookupOrdinaryName, 17745 forRedeclarationInCurContext()); 17746 auto *PrevECD = dyn_cast_or_null<EnumConstantDecl>(PrevDecl); 17747 if (!PrevECD) 17748 return SkipBodyInfo(); 17749 17750 EnumDecl *PrevED = cast<EnumDecl>(PrevECD->getDeclContext()); 17751 NamedDecl *Hidden; 17752 if (!PrevED->getDeclName() && !hasVisibleDefinition(PrevED, &Hidden)) { 17753 SkipBodyInfo Skip; 17754 Skip.Previous = Hidden; 17755 return Skip; 17756 } 17757 17758 return SkipBodyInfo(); 17759 } 17760 17761 Decl *Sema::ActOnEnumConstant(Scope *S, Decl *theEnumDecl, Decl *lastEnumConst, 17762 SourceLocation IdLoc, IdentifierInfo *Id, 17763 const ParsedAttributesView &Attrs, 17764 SourceLocation EqualLoc, Expr *Val) { 17765 EnumDecl *TheEnumDecl = cast<EnumDecl>(theEnumDecl); 17766 EnumConstantDecl *LastEnumConst = 17767 cast_or_null<EnumConstantDecl>(lastEnumConst); 17768 17769 // The scope passed in may not be a decl scope. Zip up the scope tree until 17770 // we find one that is. 17771 S = getNonFieldDeclScope(S); 17772 17773 // Verify that there isn't already something declared with this name in this 17774 // scope. 17775 LookupResult R(*this, Id, IdLoc, LookupOrdinaryName, ForVisibleRedeclaration); 17776 LookupName(R, S); 17777 NamedDecl *PrevDecl = R.getAsSingle<NamedDecl>(); 17778 17779 if (PrevDecl && PrevDecl->isTemplateParameter()) { 17780 // Maybe we will complain about the shadowed template parameter. 17781 DiagnoseTemplateParameterShadow(IdLoc, PrevDecl); 17782 // Just pretend that we didn't see the previous declaration. 17783 PrevDecl = nullptr; 17784 } 17785 17786 // C++ [class.mem]p15: 17787 // If T is the name of a class, then each of the following shall have a name 17788 // different from T: 17789 // - every enumerator of every member of class T that is an unscoped 17790 // enumerated type 17791 if (getLangOpts().CPlusPlus && !TheEnumDecl->isScoped()) 17792 DiagnoseClassNameShadow(TheEnumDecl->getDeclContext(), 17793 DeclarationNameInfo(Id, IdLoc)); 17794 17795 EnumConstantDecl *New = 17796 CheckEnumConstant(TheEnumDecl, LastEnumConst, IdLoc, Id, Val); 17797 if (!New) 17798 return nullptr; 17799 17800 if (PrevDecl) { 17801 if (!TheEnumDecl->isScoped() && isa<ValueDecl>(PrevDecl)) { 17802 // Check for other kinds of shadowing not already handled. 17803 CheckShadow(New, PrevDecl, R); 17804 } 17805 17806 // When in C++, we may get a TagDecl with the same name; in this case the 17807 // enum constant will 'hide' the tag. 17808 assert((getLangOpts().CPlusPlus || !isa<TagDecl>(PrevDecl)) && 17809 "Received TagDecl when not in C++!"); 17810 if (!isa<TagDecl>(PrevDecl) && isDeclInScope(PrevDecl, CurContext, S)) { 17811 if (isa<EnumConstantDecl>(PrevDecl)) 17812 Diag(IdLoc, diag::err_redefinition_of_enumerator) << Id; 17813 else 17814 Diag(IdLoc, diag::err_redefinition) << Id; 17815 notePreviousDefinition(PrevDecl, IdLoc); 17816 return nullptr; 17817 } 17818 } 17819 17820 // Process attributes. 17821 ProcessDeclAttributeList(S, New, Attrs); 17822 AddPragmaAttributes(S, New); 17823 17824 // Register this decl in the current scope stack. 17825 New->setAccess(TheEnumDecl->getAccess()); 17826 PushOnScopeChains(New, S); 17827 17828 ActOnDocumentableDecl(New); 17829 17830 return New; 17831 } 17832 17833 // Returns true when the enum initial expression does not trigger the 17834 // duplicate enum warning. A few common cases are exempted as follows: 17835 // Element2 = Element1 17836 // Element2 = Element1 + 1 17837 // Element2 = Element1 - 1 17838 // Where Element2 and Element1 are from the same enum. 17839 static bool ValidDuplicateEnum(EnumConstantDecl *ECD, EnumDecl *Enum) { 17840 Expr *InitExpr = ECD->getInitExpr(); 17841 if (!InitExpr) 17842 return true; 17843 InitExpr = InitExpr->IgnoreImpCasts(); 17844 17845 if (BinaryOperator *BO = dyn_cast<BinaryOperator>(InitExpr)) { 17846 if (!BO->isAdditiveOp()) 17847 return true; 17848 IntegerLiteral *IL = dyn_cast<IntegerLiteral>(BO->getRHS()); 17849 if (!IL) 17850 return true; 17851 if (IL->getValue() != 1) 17852 return true; 17853 17854 InitExpr = BO->getLHS(); 17855 } 17856 17857 // This checks if the elements are from the same enum. 17858 DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(InitExpr); 17859 if (!DRE) 17860 return true; 17861 17862 EnumConstantDecl *EnumConstant = dyn_cast<EnumConstantDecl>(DRE->getDecl()); 17863 if (!EnumConstant) 17864 return true; 17865 17866 if (cast<EnumDecl>(TagDecl::castFromDeclContext(ECD->getDeclContext())) != 17867 Enum) 17868 return true; 17869 17870 return false; 17871 } 17872 17873 // Emits a warning when an element is implicitly set a value that 17874 // a previous element has already been set to. 17875 static void CheckForDuplicateEnumValues(Sema &S, ArrayRef<Decl *> Elements, 17876 EnumDecl *Enum, QualType EnumType) { 17877 // Avoid anonymous enums 17878 if (!Enum->getIdentifier()) 17879 return; 17880 17881 // Only check for small enums. 17882 if (Enum->getNumPositiveBits() > 63 || Enum->getNumNegativeBits() > 64) 17883 return; 17884 17885 if (S.Diags.isIgnored(diag::warn_duplicate_enum_values, Enum->getLocation())) 17886 return; 17887 17888 typedef SmallVector<EnumConstantDecl *, 3> ECDVector; 17889 typedef SmallVector<std::unique_ptr<ECDVector>, 3> DuplicatesVector; 17890 17891 typedef llvm::PointerUnion<EnumConstantDecl*, ECDVector*> DeclOrVector; 17892 17893 // DenseMaps cannot contain the all ones int64_t value, so use unordered_map. 17894 typedef std::unordered_map<int64_t, DeclOrVector> ValueToVectorMap; 17895 17896 // Use int64_t as a key to avoid needing special handling for map keys. 17897 auto EnumConstantToKey = [](const EnumConstantDecl *D) { 17898 llvm::APSInt Val = D->getInitVal(); 17899 return Val.isSigned() ? Val.getSExtValue() : Val.getZExtValue(); 17900 }; 17901 17902 DuplicatesVector DupVector; 17903 ValueToVectorMap EnumMap; 17904 17905 // Populate the EnumMap with all values represented by enum constants without 17906 // an initializer. 17907 for (auto *Element : Elements) { 17908 EnumConstantDecl *ECD = cast_or_null<EnumConstantDecl>(Element); 17909 17910 // Null EnumConstantDecl means a previous diagnostic has been emitted for 17911 // this constant. Skip this enum since it may be ill-formed. 17912 if (!ECD) { 17913 return; 17914 } 17915 17916 // Constants with initalizers are handled in the next loop. 17917 if (ECD->getInitExpr()) 17918 continue; 17919 17920 // Duplicate values are handled in the next loop. 17921 EnumMap.insert({EnumConstantToKey(ECD), ECD}); 17922 } 17923 17924 if (EnumMap.size() == 0) 17925 return; 17926 17927 // Create vectors for any values that has duplicates. 17928 for (auto *Element : Elements) { 17929 // The last loop returned if any constant was null. 17930 EnumConstantDecl *ECD = cast<EnumConstantDecl>(Element); 17931 if (!ValidDuplicateEnum(ECD, Enum)) 17932 continue; 17933 17934 auto Iter = EnumMap.find(EnumConstantToKey(ECD)); 17935 if (Iter == EnumMap.end()) 17936 continue; 17937 17938 DeclOrVector& Entry = Iter->second; 17939 if (EnumConstantDecl *D = Entry.dyn_cast<EnumConstantDecl*>()) { 17940 // Ensure constants are different. 17941 if (D == ECD) 17942 continue; 17943 17944 // Create new vector and push values onto it. 17945 auto Vec = std::make_unique<ECDVector>(); 17946 Vec->push_back(D); 17947 Vec->push_back(ECD); 17948 17949 // Update entry to point to the duplicates vector. 17950 Entry = Vec.get(); 17951 17952 // Store the vector somewhere we can consult later for quick emission of 17953 // diagnostics. 17954 DupVector.emplace_back(std::move(Vec)); 17955 continue; 17956 } 17957 17958 ECDVector *Vec = Entry.get<ECDVector*>(); 17959 // Make sure constants are not added more than once. 17960 if (*Vec->begin() == ECD) 17961 continue; 17962 17963 Vec->push_back(ECD); 17964 } 17965 17966 // Emit diagnostics. 17967 for (const auto &Vec : DupVector) { 17968 assert(Vec->size() > 1 && "ECDVector should have at least 2 elements."); 17969 17970 // Emit warning for one enum constant. 17971 auto *FirstECD = Vec->front(); 17972 S.Diag(FirstECD->getLocation(), diag::warn_duplicate_enum_values) 17973 << FirstECD << FirstECD->getInitVal().toString(10) 17974 << FirstECD->getSourceRange(); 17975 17976 // Emit one note for each of the remaining enum constants with 17977 // the same value. 17978 for (auto *ECD : llvm::make_range(Vec->begin() + 1, Vec->end())) 17979 S.Diag(ECD->getLocation(), diag::note_duplicate_element) 17980 << ECD << ECD->getInitVal().toString(10) 17981 << ECD->getSourceRange(); 17982 } 17983 } 17984 17985 bool Sema::IsValueInFlagEnum(const EnumDecl *ED, const llvm::APInt &Val, 17986 bool AllowMask) const { 17987 assert(ED->isClosedFlag() && "looking for value in non-flag or open enum"); 17988 assert(ED->isCompleteDefinition() && "expected enum definition"); 17989 17990 auto R = FlagBitsCache.insert(std::make_pair(ED, llvm::APInt())); 17991 llvm::APInt &FlagBits = R.first->second; 17992 17993 if (R.second) { 17994 for (auto *E : ED->enumerators()) { 17995 const auto &EVal = E->getInitVal(); 17996 // Only single-bit enumerators introduce new flag values. 17997 if (EVal.isPowerOf2()) 17998 FlagBits = FlagBits.zextOrSelf(EVal.getBitWidth()) | EVal; 17999 } 18000 } 18001 18002 // A value is in a flag enum if either its bits are a subset of the enum's 18003 // flag bits (the first condition) or we are allowing masks and the same is 18004 // true of its complement (the second condition). When masks are allowed, we 18005 // allow the common idiom of ~(enum1 | enum2) to be a valid enum value. 18006 // 18007 // While it's true that any value could be used as a mask, the assumption is 18008 // that a mask will have all of the insignificant bits set. Anything else is 18009 // likely a logic error. 18010 llvm::APInt FlagMask = ~FlagBits.zextOrTrunc(Val.getBitWidth()); 18011 return !(FlagMask & Val) || (AllowMask && !(FlagMask & ~Val)); 18012 } 18013 18014 void Sema::ActOnEnumBody(SourceLocation EnumLoc, SourceRange BraceRange, 18015 Decl *EnumDeclX, ArrayRef<Decl *> Elements, Scope *S, 18016 const ParsedAttributesView &Attrs) { 18017 EnumDecl *Enum = cast<EnumDecl>(EnumDeclX); 18018 QualType EnumType = Context.getTypeDeclType(Enum); 18019 18020 ProcessDeclAttributeList(S, Enum, Attrs); 18021 18022 if (Enum->isDependentType()) { 18023 for (unsigned i = 0, e = Elements.size(); i != e; ++i) { 18024 EnumConstantDecl *ECD = 18025 cast_or_null<EnumConstantDecl>(Elements[i]); 18026 if (!ECD) continue; 18027 18028 ECD->setType(EnumType); 18029 } 18030 18031 Enum->completeDefinition(Context.DependentTy, Context.DependentTy, 0, 0); 18032 return; 18033 } 18034 18035 // TODO: If the result value doesn't fit in an int, it must be a long or long 18036 // long value. ISO C does not support this, but GCC does as an extension, 18037 // emit a warning. 18038 unsigned IntWidth = Context.getTargetInfo().getIntWidth(); 18039 unsigned CharWidth = Context.getTargetInfo().getCharWidth(); 18040 unsigned ShortWidth = Context.getTargetInfo().getShortWidth(); 18041 18042 // Verify that all the values are okay, compute the size of the values, and 18043 // reverse the list. 18044 unsigned NumNegativeBits = 0; 18045 unsigned NumPositiveBits = 0; 18046 18047 // Keep track of whether all elements have type int. 18048 bool AllElementsInt = true; 18049 18050 for (unsigned i = 0, e = Elements.size(); i != e; ++i) { 18051 EnumConstantDecl *ECD = 18052 cast_or_null<EnumConstantDecl>(Elements[i]); 18053 if (!ECD) continue; // Already issued a diagnostic. 18054 18055 const llvm::APSInt &InitVal = ECD->getInitVal(); 18056 18057 // Keep track of the size of positive and negative values. 18058 if (InitVal.isUnsigned() || InitVal.isNonNegative()) 18059 NumPositiveBits = std::max(NumPositiveBits, 18060 (unsigned)InitVal.getActiveBits()); 18061 else 18062 NumNegativeBits = std::max(NumNegativeBits, 18063 (unsigned)InitVal.getMinSignedBits()); 18064 18065 // Keep track of whether every enum element has type int (very common). 18066 if (AllElementsInt) 18067 AllElementsInt = ECD->getType() == Context.IntTy; 18068 } 18069 18070 // Figure out the type that should be used for this enum. 18071 QualType BestType; 18072 unsigned BestWidth; 18073 18074 // C++0x N3000 [conv.prom]p3: 18075 // An rvalue of an unscoped enumeration type whose underlying 18076 // type is not fixed can be converted to an rvalue of the first 18077 // of the following types that can represent all the values of 18078 // the enumeration: int, unsigned int, long int, unsigned long 18079 // int, long long int, or unsigned long long int. 18080 // C99 6.4.4.3p2: 18081 // An identifier declared as an enumeration constant has type int. 18082 // The C99 rule is modified by a gcc extension 18083 QualType BestPromotionType; 18084 18085 bool Packed = Enum->hasAttr<PackedAttr>(); 18086 // -fshort-enums is the equivalent to specifying the packed attribute on all 18087 // enum definitions. 18088 if (LangOpts.ShortEnums) 18089 Packed = true; 18090 18091 // If the enum already has a type because it is fixed or dictated by the 18092 // target, promote that type instead of analyzing the enumerators. 18093 if (Enum->isComplete()) { 18094 BestType = Enum->getIntegerType(); 18095 if (BestType->isPromotableIntegerType()) 18096 BestPromotionType = Context.getPromotedIntegerType(BestType); 18097 else 18098 BestPromotionType = BestType; 18099 18100 BestWidth = Context.getIntWidth(BestType); 18101 } 18102 else if (NumNegativeBits) { 18103 // If there is a negative value, figure out the smallest integer type (of 18104 // int/long/longlong) that fits. 18105 // If it's packed, check also if it fits a char or a short. 18106 if (Packed && NumNegativeBits <= CharWidth && NumPositiveBits < CharWidth) { 18107 BestType = Context.SignedCharTy; 18108 BestWidth = CharWidth; 18109 } else if (Packed && NumNegativeBits <= ShortWidth && 18110 NumPositiveBits < ShortWidth) { 18111 BestType = Context.ShortTy; 18112 BestWidth = ShortWidth; 18113 } else if (NumNegativeBits <= IntWidth && NumPositiveBits < IntWidth) { 18114 BestType = Context.IntTy; 18115 BestWidth = IntWidth; 18116 } else { 18117 BestWidth = Context.getTargetInfo().getLongWidth(); 18118 18119 if (NumNegativeBits <= BestWidth && NumPositiveBits < BestWidth) { 18120 BestType = Context.LongTy; 18121 } else { 18122 BestWidth = Context.getTargetInfo().getLongLongWidth(); 18123 18124 if (NumNegativeBits > BestWidth || NumPositiveBits >= BestWidth) 18125 Diag(Enum->getLocation(), diag::ext_enum_too_large); 18126 BestType = Context.LongLongTy; 18127 } 18128 } 18129 BestPromotionType = (BestWidth <= IntWidth ? Context.IntTy : BestType); 18130 } else { 18131 // If there is no negative value, figure out the smallest type that fits 18132 // all of the enumerator values. 18133 // If it's packed, check also if it fits a char or a short. 18134 if (Packed && NumPositiveBits <= CharWidth) { 18135 BestType = Context.UnsignedCharTy; 18136 BestPromotionType = Context.IntTy; 18137 BestWidth = CharWidth; 18138 } else if (Packed && NumPositiveBits <= ShortWidth) { 18139 BestType = Context.UnsignedShortTy; 18140 BestPromotionType = Context.IntTy; 18141 BestWidth = ShortWidth; 18142 } else if (NumPositiveBits <= IntWidth) { 18143 BestType = Context.UnsignedIntTy; 18144 BestWidth = IntWidth; 18145 BestPromotionType 18146 = (NumPositiveBits == BestWidth || !getLangOpts().CPlusPlus) 18147 ? Context.UnsignedIntTy : Context.IntTy; 18148 } else if (NumPositiveBits <= 18149 (BestWidth = Context.getTargetInfo().getLongWidth())) { 18150 BestType = Context.UnsignedLongTy; 18151 BestPromotionType 18152 = (NumPositiveBits == BestWidth || !getLangOpts().CPlusPlus) 18153 ? Context.UnsignedLongTy : Context.LongTy; 18154 } else { 18155 BestWidth = Context.getTargetInfo().getLongLongWidth(); 18156 assert(NumPositiveBits <= BestWidth && 18157 "How could an initializer get larger than ULL?"); 18158 BestType = Context.UnsignedLongLongTy; 18159 BestPromotionType 18160 = (NumPositiveBits == BestWidth || !getLangOpts().CPlusPlus) 18161 ? Context.UnsignedLongLongTy : Context.LongLongTy; 18162 } 18163 } 18164 18165 // Loop over all of the enumerator constants, changing their types to match 18166 // the type of the enum if needed. 18167 for (auto *D : Elements) { 18168 auto *ECD = cast_or_null<EnumConstantDecl>(D); 18169 if (!ECD) continue; // Already issued a diagnostic. 18170 18171 // Standard C says the enumerators have int type, but we allow, as an 18172 // extension, the enumerators to be larger than int size. If each 18173 // enumerator value fits in an int, type it as an int, otherwise type it the 18174 // same as the enumerator decl itself. This means that in "enum { X = 1U }" 18175 // that X has type 'int', not 'unsigned'. 18176 18177 // Determine whether the value fits into an int. 18178 llvm::APSInt InitVal = ECD->getInitVal(); 18179 18180 // If it fits into an integer type, force it. Otherwise force it to match 18181 // the enum decl type. 18182 QualType NewTy; 18183 unsigned NewWidth; 18184 bool NewSign; 18185 if (!getLangOpts().CPlusPlus && 18186 !Enum->isFixed() && 18187 isRepresentableIntegerValue(Context, InitVal, Context.IntTy)) { 18188 NewTy = Context.IntTy; 18189 NewWidth = IntWidth; 18190 NewSign = true; 18191 } else if (ECD->getType() == BestType) { 18192 // Already the right type! 18193 if (getLangOpts().CPlusPlus) 18194 // C++ [dcl.enum]p4: Following the closing brace of an 18195 // enum-specifier, each enumerator has the type of its 18196 // enumeration. 18197 ECD->setType(EnumType); 18198 continue; 18199 } else { 18200 NewTy = BestType; 18201 NewWidth = BestWidth; 18202 NewSign = BestType->isSignedIntegerOrEnumerationType(); 18203 } 18204 18205 // Adjust the APSInt value. 18206 InitVal = InitVal.extOrTrunc(NewWidth); 18207 InitVal.setIsSigned(NewSign); 18208 ECD->setInitVal(InitVal); 18209 18210 // Adjust the Expr initializer and type. 18211 if (ECD->getInitExpr() && 18212 !Context.hasSameType(NewTy, ECD->getInitExpr()->getType())) 18213 ECD->setInitExpr(ImplicitCastExpr::Create( 18214 Context, NewTy, CK_IntegralCast, ECD->getInitExpr(), 18215 /*base paths*/ nullptr, VK_RValue, FPOptionsOverride())); 18216 if (getLangOpts().CPlusPlus) 18217 // C++ [dcl.enum]p4: Following the closing brace of an 18218 // enum-specifier, each enumerator has the type of its 18219 // enumeration. 18220 ECD->setType(EnumType); 18221 else 18222 ECD->setType(NewTy); 18223 } 18224 18225 Enum->completeDefinition(BestType, BestPromotionType, 18226 NumPositiveBits, NumNegativeBits); 18227 18228 CheckForDuplicateEnumValues(*this, Elements, Enum, EnumType); 18229 18230 if (Enum->isClosedFlag()) { 18231 for (Decl *D : Elements) { 18232 EnumConstantDecl *ECD = cast_or_null<EnumConstantDecl>(D); 18233 if (!ECD) continue; // Already issued a diagnostic. 18234 18235 llvm::APSInt InitVal = ECD->getInitVal(); 18236 if (InitVal != 0 && !InitVal.isPowerOf2() && 18237 !IsValueInFlagEnum(Enum, InitVal, true)) 18238 Diag(ECD->getLocation(), diag::warn_flag_enum_constant_out_of_range) 18239 << ECD << Enum; 18240 } 18241 } 18242 18243 // Now that the enum type is defined, ensure it's not been underaligned. 18244 if (Enum->hasAttrs()) 18245 CheckAlignasUnderalignment(Enum); 18246 } 18247 18248 Decl *Sema::ActOnFileScopeAsmDecl(Expr *expr, 18249 SourceLocation StartLoc, 18250 SourceLocation EndLoc) { 18251 StringLiteral *AsmString = cast<StringLiteral>(expr); 18252 18253 FileScopeAsmDecl *New = FileScopeAsmDecl::Create(Context, CurContext, 18254 AsmString, StartLoc, 18255 EndLoc); 18256 CurContext->addDecl(New); 18257 return New; 18258 } 18259 18260 void Sema::ActOnPragmaRedefineExtname(IdentifierInfo* Name, 18261 IdentifierInfo* AliasName, 18262 SourceLocation PragmaLoc, 18263 SourceLocation NameLoc, 18264 SourceLocation AliasNameLoc) { 18265 NamedDecl *PrevDecl = LookupSingleName(TUScope, Name, NameLoc, 18266 LookupOrdinaryName); 18267 AttributeCommonInfo Info(AliasName, SourceRange(AliasNameLoc), 18268 AttributeCommonInfo::AS_Pragma); 18269 AsmLabelAttr *Attr = AsmLabelAttr::CreateImplicit( 18270 Context, AliasName->getName(), /*LiteralLabel=*/true, Info); 18271 18272 // If a declaration that: 18273 // 1) declares a function or a variable 18274 // 2) has external linkage 18275 // already exists, add a label attribute to it. 18276 if (PrevDecl && (isa<FunctionDecl>(PrevDecl) || isa<VarDecl>(PrevDecl))) { 18277 if (isDeclExternC(PrevDecl)) 18278 PrevDecl->addAttr(Attr); 18279 else 18280 Diag(PrevDecl->getLocation(), diag::warn_redefine_extname_not_applied) 18281 << /*Variable*/(isa<FunctionDecl>(PrevDecl) ? 0 : 1) << PrevDecl; 18282 // Otherwise, add a label atttibute to ExtnameUndeclaredIdentifiers. 18283 } else 18284 (void)ExtnameUndeclaredIdentifiers.insert(std::make_pair(Name, Attr)); 18285 } 18286 18287 void Sema::ActOnPragmaWeakID(IdentifierInfo* Name, 18288 SourceLocation PragmaLoc, 18289 SourceLocation NameLoc) { 18290 Decl *PrevDecl = LookupSingleName(TUScope, Name, NameLoc, LookupOrdinaryName); 18291 18292 if (PrevDecl) { 18293 PrevDecl->addAttr(WeakAttr::CreateImplicit(Context, PragmaLoc, AttributeCommonInfo::AS_Pragma)); 18294 } else { 18295 (void)WeakUndeclaredIdentifiers.insert( 18296 std::pair<IdentifierInfo*,WeakInfo> 18297 (Name, WeakInfo((IdentifierInfo*)nullptr, NameLoc))); 18298 } 18299 } 18300 18301 void Sema::ActOnPragmaWeakAlias(IdentifierInfo* Name, 18302 IdentifierInfo* AliasName, 18303 SourceLocation PragmaLoc, 18304 SourceLocation NameLoc, 18305 SourceLocation AliasNameLoc) { 18306 Decl *PrevDecl = LookupSingleName(TUScope, AliasName, AliasNameLoc, 18307 LookupOrdinaryName); 18308 WeakInfo W = WeakInfo(Name, NameLoc); 18309 18310 if (PrevDecl && (isa<FunctionDecl>(PrevDecl) || isa<VarDecl>(PrevDecl))) { 18311 if (!PrevDecl->hasAttr<AliasAttr>()) 18312 if (NamedDecl *ND = dyn_cast<NamedDecl>(PrevDecl)) 18313 DeclApplyPragmaWeak(TUScope, ND, W); 18314 } else { 18315 (void)WeakUndeclaredIdentifiers.insert( 18316 std::pair<IdentifierInfo*,WeakInfo>(AliasName, W)); 18317 } 18318 } 18319 18320 Decl *Sema::getObjCDeclContext() const { 18321 return (dyn_cast_or_null<ObjCContainerDecl>(CurContext)); 18322 } 18323 18324 Sema::FunctionEmissionStatus Sema::getEmissionStatus(FunctionDecl *FD, 18325 bool Final) { 18326 // SYCL functions can be template, so we check if they have appropriate 18327 // attribute prior to checking if it is a template. 18328 if (LangOpts.SYCLIsDevice && FD->hasAttr<SYCLKernelAttr>()) 18329 return FunctionEmissionStatus::Emitted; 18330 18331 // Templates are emitted when they're instantiated. 18332 if (FD->isDependentContext()) 18333 return FunctionEmissionStatus::TemplateDiscarded; 18334 18335 // Check whether this function is an externally visible definition. 18336 auto IsEmittedForExternalSymbol = [this, FD]() { 18337 // We have to check the GVA linkage of the function's *definition* -- if we 18338 // only have a declaration, we don't know whether or not the function will 18339 // be emitted, because (say) the definition could include "inline". 18340 FunctionDecl *Def = FD->getDefinition(); 18341 18342 return Def && !isDiscardableGVALinkage( 18343 getASTContext().GetGVALinkageForFunction(Def)); 18344 }; 18345 18346 if (LangOpts.OpenMPIsDevice) { 18347 // In OpenMP device mode we will not emit host only functions, or functions 18348 // we don't need due to their linkage. 18349 Optional<OMPDeclareTargetDeclAttr::DevTypeTy> DevTy = 18350 OMPDeclareTargetDeclAttr::getDeviceType(FD->getCanonicalDecl()); 18351 // DevTy may be changed later by 18352 // #pragma omp declare target to(*) device_type(*). 18353 // Therefore DevTyhaving no value does not imply host. The emission status 18354 // will be checked again at the end of compilation unit with Final = true. 18355 if (DevTy.hasValue()) 18356 if (*DevTy == OMPDeclareTargetDeclAttr::DT_Host) 18357 return FunctionEmissionStatus::OMPDiscarded; 18358 // If we have an explicit value for the device type, or we are in a target 18359 // declare context, we need to emit all extern and used symbols. 18360 if (isInOpenMPDeclareTargetContext() || DevTy.hasValue()) 18361 if (IsEmittedForExternalSymbol()) 18362 return FunctionEmissionStatus::Emitted; 18363 // Device mode only emits what it must, if it wasn't tagged yet and needed, 18364 // we'll omit it. 18365 if (Final) 18366 return FunctionEmissionStatus::OMPDiscarded; 18367 } else if (LangOpts.OpenMP > 45) { 18368 // In OpenMP host compilation prior to 5.0 everything was an emitted host 18369 // function. In 5.0, no_host was introduced which might cause a function to 18370 // be ommitted. 18371 Optional<OMPDeclareTargetDeclAttr::DevTypeTy> DevTy = 18372 OMPDeclareTargetDeclAttr::getDeviceType(FD->getCanonicalDecl()); 18373 if (DevTy.hasValue()) 18374 if (*DevTy == OMPDeclareTargetDeclAttr::DT_NoHost) 18375 return FunctionEmissionStatus::OMPDiscarded; 18376 } 18377 18378 if (Final && LangOpts.OpenMP && !LangOpts.CUDA) 18379 return FunctionEmissionStatus::Emitted; 18380 18381 if (LangOpts.CUDA) { 18382 // When compiling for device, host functions are never emitted. Similarly, 18383 // when compiling for host, device and global functions are never emitted. 18384 // (Technically, we do emit a host-side stub for global functions, but this 18385 // doesn't count for our purposes here.) 18386 Sema::CUDAFunctionTarget T = IdentifyCUDATarget(FD); 18387 if (LangOpts.CUDAIsDevice && T == Sema::CFT_Host) 18388 return FunctionEmissionStatus::CUDADiscarded; 18389 if (!LangOpts.CUDAIsDevice && 18390 (T == Sema::CFT_Device || T == Sema::CFT_Global)) 18391 return FunctionEmissionStatus::CUDADiscarded; 18392 18393 if (IsEmittedForExternalSymbol()) 18394 return FunctionEmissionStatus::Emitted; 18395 } 18396 18397 // Otherwise, the function is known-emitted if it's in our set of 18398 // known-emitted functions. 18399 return FunctionEmissionStatus::Unknown; 18400 } 18401 18402 bool Sema::shouldIgnoreInHostDeviceCheck(FunctionDecl *Callee) { 18403 // Host-side references to a __global__ function refer to the stub, so the 18404 // function itself is never emitted and therefore should not be marked. 18405 // If we have host fn calls kernel fn calls host+device, the HD function 18406 // does not get instantiated on the host. We model this by omitting at the 18407 // call to the kernel from the callgraph. This ensures that, when compiling 18408 // for host, only HD functions actually called from the host get marked as 18409 // known-emitted. 18410 return LangOpts.CUDA && !LangOpts.CUDAIsDevice && 18411 IdentifyCUDATarget(Callee) == CFT_Global; 18412 } 18413