1 //===--- SemaDecl.cpp - Semantic Analysis for Declarations ----------------===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 // 10 // This file implements semantic analysis for declarations. 11 // 12 //===----------------------------------------------------------------------===// 13 14 #include "clang/Sema/SemaInternal.h" 15 #include "TypeLocBuilder.h" 16 #include "clang/AST/ASTConsumer.h" 17 #include "clang/AST/ASTContext.h" 18 #include "clang/AST/ASTLambda.h" 19 #include "clang/AST/CXXInheritance.h" 20 #include "clang/AST/CharUnits.h" 21 #include "clang/AST/CommentDiagnostic.h" 22 #include "clang/AST/DeclCXX.h" 23 #include "clang/AST/DeclObjC.h" 24 #include "clang/AST/DeclTemplate.h" 25 #include "clang/AST/EvaluatedExprVisitor.h" 26 #include "clang/AST/ExprCXX.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/Parse/ParseDiagnostic.h" 37 #include "clang/Sema/CXXFieldCollector.h" 38 #include "clang/Sema/DeclSpec.h" 39 #include "clang/Sema/DelayedDiagnostic.h" 40 #include "clang/Sema/Initialization.h" 41 #include "clang/Sema/Lookup.h" 42 #include "clang/Sema/ParsedTemplate.h" 43 #include "clang/Sema/Scope.h" 44 #include "clang/Sema/ScopeInfo.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 using namespace clang; 52 using namespace sema; 53 54 Sema::DeclGroupPtrTy Sema::ConvertDeclToDeclGroup(Decl *Ptr, Decl *OwnedType) { 55 if (OwnedType) { 56 Decl *Group[2] = { OwnedType, Ptr }; 57 return DeclGroupPtrTy::make(DeclGroupRef::Create(Context, Group, 2)); 58 } 59 60 return DeclGroupPtrTy::make(DeclGroupRef(Ptr)); 61 } 62 63 namespace { 64 65 class TypeNameValidatorCCC : public CorrectionCandidateCallback { 66 public: 67 TypeNameValidatorCCC(bool AllowInvalid, bool WantClass=false, 68 bool AllowTemplates=false) 69 : AllowInvalidDecl(AllowInvalid), WantClassName(WantClass), 70 AllowClassTemplates(AllowTemplates) { 71 WantExpressionKeywords = false; 72 WantCXXNamedCasts = false; 73 WantRemainingKeywords = false; 74 } 75 76 bool ValidateCandidate(const TypoCorrection &candidate) override { 77 if (NamedDecl *ND = candidate.getCorrectionDecl()) { 78 bool IsType = isa<TypeDecl>(ND) || isa<ObjCInterfaceDecl>(ND); 79 bool AllowedTemplate = AllowClassTemplates && isa<ClassTemplateDecl>(ND); 80 return (IsType || AllowedTemplate) && 81 (AllowInvalidDecl || !ND->isInvalidDecl()); 82 } 83 return !WantClassName && candidate.isKeyword(); 84 } 85 86 private: 87 bool AllowInvalidDecl; 88 bool WantClassName; 89 bool AllowClassTemplates; 90 }; 91 92 } 93 94 /// \brief Determine whether the token kind starts a simple-type-specifier. 95 bool Sema::isSimpleTypeSpecifier(tok::TokenKind Kind) const { 96 switch (Kind) { 97 // FIXME: Take into account the current language when deciding whether a 98 // token kind is a valid type specifier 99 case tok::kw_short: 100 case tok::kw_long: 101 case tok::kw___int64: 102 case tok::kw___int128: 103 case tok::kw_signed: 104 case tok::kw_unsigned: 105 case tok::kw_void: 106 case tok::kw_char: 107 case tok::kw_int: 108 case tok::kw_half: 109 case tok::kw_float: 110 case tok::kw_double: 111 case tok::kw_wchar_t: 112 case tok::kw_bool: 113 case tok::kw___underlying_type: 114 return true; 115 116 case tok::annot_typename: 117 case tok::kw_char16_t: 118 case tok::kw_char32_t: 119 case tok::kw_typeof: 120 case tok::annot_decltype: 121 case tok::kw_decltype: 122 return getLangOpts().CPlusPlus; 123 124 default: 125 break; 126 } 127 128 return false; 129 } 130 131 static ParsedType recoverFromTypeInKnownDependentBase(Sema &S, 132 const IdentifierInfo &II, 133 SourceLocation NameLoc) { 134 // Find the first parent class template context, if any. 135 // FIXME: Perform the lookup in all enclosing class templates. 136 const CXXRecordDecl *RD = nullptr; 137 for (DeclContext *DC = S.CurContext; DC; DC = DC->getParent()) { 138 RD = dyn_cast<CXXRecordDecl>(DC); 139 if (RD && RD->getDescribedClassTemplate()) 140 break; 141 } 142 if (!RD) 143 return ParsedType(); 144 145 // Look for type decls in dependent base classes that have known primary 146 // templates. 147 bool FoundTypeDecl = false; 148 for (const auto &Base : RD->bases()) { 149 auto *TST = Base.getType()->getAs<TemplateSpecializationType>(); 150 if (!TST || !TST->isDependentType()) 151 continue; 152 auto *TD = TST->getTemplateName().getAsTemplateDecl(); 153 if (!TD) 154 continue; 155 auto *BasePrimaryTemplate = 156 dyn_cast_or_null<CXXRecordDecl>(TD->getTemplatedDecl()); 157 if (!BasePrimaryTemplate) 158 continue; 159 // FIXME: Allow lookup into non-dependent bases of dependent bases, possibly 160 // by calling or integrating with the main LookupQualifiedName mechanism. 161 for (NamedDecl *ND : BasePrimaryTemplate->lookup(&II)) { 162 if (FoundTypeDecl) 163 return ParsedType(); 164 FoundTypeDecl = isa<TypeDecl>(ND); 165 if (!FoundTypeDecl) 166 return ParsedType(); 167 } 168 } 169 if (!FoundTypeDecl) 170 return ParsedType(); 171 172 // We found some types in dependent base classes. Recover as if the user 173 // wrote 'typename MyClass::II' instead of 'II'. We'll fully resolve the 174 // lookup during template instantiation. 175 S.Diag(NameLoc, diag::ext_found_via_dependent_bases_lookup) << &II; 176 177 ASTContext &Context = S.Context; 178 auto *NNS = NestedNameSpecifier::Create(Context, nullptr, false, 179 cast<Type>(Context.getRecordType(RD))); 180 QualType T = Context.getDependentNameType(ETK_Typename, NNS, &II); 181 182 CXXScopeSpec SS; 183 SS.MakeTrivial(Context, NNS, SourceRange(NameLoc)); 184 185 TypeLocBuilder Builder; 186 DependentNameTypeLoc DepTL = Builder.push<DependentNameTypeLoc>(T); 187 DepTL.setNameLoc(NameLoc); 188 DepTL.setElaboratedKeywordLoc(SourceLocation()); 189 DepTL.setQualifierLoc(SS.getWithLocInContext(Context)); 190 return S.CreateParsedType(T, Builder.getTypeSourceInfo(Context, T)); 191 } 192 193 /// \brief If the identifier refers to a type name within this scope, 194 /// return the declaration of that type. 195 /// 196 /// This routine performs ordinary name lookup of the identifier II 197 /// within the given scope, with optional C++ scope specifier SS, to 198 /// determine whether the name refers to a type. If so, returns an 199 /// opaque pointer (actually a QualType) corresponding to that 200 /// type. Otherwise, returns NULL. 201 ParsedType Sema::getTypeName(const IdentifierInfo &II, SourceLocation NameLoc, 202 Scope *S, CXXScopeSpec *SS, 203 bool isClassName, bool HasTrailingDot, 204 ParsedType ObjectTypePtr, 205 bool IsCtorOrDtorName, 206 bool WantNontrivialTypeSourceInfo, 207 IdentifierInfo **CorrectedII) { 208 // Determine where we will perform name lookup. 209 DeclContext *LookupCtx = nullptr; 210 if (ObjectTypePtr) { 211 QualType ObjectType = ObjectTypePtr.get(); 212 if (ObjectType->isRecordType()) 213 LookupCtx = computeDeclContext(ObjectType); 214 } else if (SS && SS->isNotEmpty()) { 215 LookupCtx = computeDeclContext(*SS, false); 216 217 if (!LookupCtx) { 218 if (isDependentScopeSpecifier(*SS)) { 219 // C++ [temp.res]p3: 220 // A qualified-id that refers to a type and in which the 221 // nested-name-specifier depends on a template-parameter (14.6.2) 222 // shall be prefixed by the keyword typename to indicate that the 223 // qualified-id denotes a type, forming an 224 // elaborated-type-specifier (7.1.5.3). 225 // 226 // We therefore do not perform any name lookup if the result would 227 // refer to a member of an unknown specialization. 228 if (!isClassName && !IsCtorOrDtorName) 229 return ParsedType(); 230 231 // We know from the grammar that this name refers to a type, 232 // so build a dependent node to describe the type. 233 if (WantNontrivialTypeSourceInfo) 234 return ActOnTypenameType(S, SourceLocation(), *SS, II, NameLoc).get(); 235 236 NestedNameSpecifierLoc QualifierLoc = SS->getWithLocInContext(Context); 237 QualType T = CheckTypenameType(ETK_None, SourceLocation(), QualifierLoc, 238 II, NameLoc); 239 return ParsedType::make(T); 240 } 241 242 return ParsedType(); 243 } 244 245 if (!LookupCtx->isDependentContext() && 246 RequireCompleteDeclContext(*SS, LookupCtx)) 247 return ParsedType(); 248 } 249 250 // FIXME: LookupNestedNameSpecifierName isn't the right kind of 251 // lookup for class-names. 252 LookupNameKind Kind = isClassName ? LookupNestedNameSpecifierName : 253 LookupOrdinaryName; 254 LookupResult Result(*this, &II, NameLoc, Kind); 255 if (LookupCtx) { 256 // Perform "qualified" name lookup into the declaration context we 257 // computed, which is either the type of the base of a member access 258 // expression or the declaration context associated with a prior 259 // nested-name-specifier. 260 LookupQualifiedName(Result, LookupCtx); 261 262 if (ObjectTypePtr && Result.empty()) { 263 // C++ [basic.lookup.classref]p3: 264 // If the unqualified-id is ~type-name, the type-name is looked up 265 // in the context of the entire postfix-expression. If the type T of 266 // the object expression is of a class type C, the type-name is also 267 // looked up in the scope of class C. At least one of the lookups shall 268 // find a name that refers to (possibly cv-qualified) T. 269 LookupName(Result, S); 270 } 271 } else { 272 // Perform unqualified name lookup. 273 LookupName(Result, S); 274 275 // For unqualified lookup in a class template in MSVC mode, look into 276 // dependent base classes where the primary class template is known. 277 if (Result.empty() && getLangOpts().MSVCCompat && (!SS || SS->isEmpty())) { 278 if (ParsedType TypeInBase = 279 recoverFromTypeInKnownDependentBase(*this, II, NameLoc)) 280 return TypeInBase; 281 } 282 } 283 284 NamedDecl *IIDecl = nullptr; 285 switch (Result.getResultKind()) { 286 case LookupResult::NotFound: 287 case LookupResult::NotFoundInCurrentInstantiation: 288 if (CorrectedII) { 289 TypeNameValidatorCCC Validator(true, isClassName); 290 TypoCorrection Correction = CorrectTypo(Result.getLookupNameInfo(), 291 Kind, S, SS, Validator, 292 CTK_ErrorRecovery); 293 IdentifierInfo *NewII = Correction.getCorrectionAsIdentifierInfo(); 294 TemplateTy Template; 295 bool MemberOfUnknownSpecialization; 296 UnqualifiedId TemplateName; 297 TemplateName.setIdentifier(NewII, NameLoc); 298 NestedNameSpecifier *NNS = Correction.getCorrectionSpecifier(); 299 CXXScopeSpec NewSS, *NewSSPtr = SS; 300 if (SS && NNS) { 301 NewSS.MakeTrivial(Context, NNS, SourceRange(NameLoc)); 302 NewSSPtr = &NewSS; 303 } 304 if (Correction && (NNS || NewII != &II) && 305 // Ignore a correction to a template type as the to-be-corrected 306 // identifier is not a template (typo correction for template names 307 // is handled elsewhere). 308 !(getLangOpts().CPlusPlus && NewSSPtr && 309 isTemplateName(S, *NewSSPtr, false, TemplateName, ParsedType(), 310 false, Template, MemberOfUnknownSpecialization))) { 311 ParsedType Ty = getTypeName(*NewII, NameLoc, S, NewSSPtr, 312 isClassName, HasTrailingDot, ObjectTypePtr, 313 IsCtorOrDtorName, 314 WantNontrivialTypeSourceInfo); 315 if (Ty) { 316 diagnoseTypo(Correction, 317 PDiag(diag::err_unknown_type_or_class_name_suggest) 318 << Result.getLookupName() << isClassName); 319 if (SS && NNS) 320 SS->MakeTrivial(Context, NNS, SourceRange(NameLoc)); 321 *CorrectedII = NewII; 322 return Ty; 323 } 324 } 325 } 326 // If typo correction failed or was not performed, fall through 327 case LookupResult::FoundOverloaded: 328 case LookupResult::FoundUnresolvedValue: 329 Result.suppressDiagnostics(); 330 return ParsedType(); 331 332 case LookupResult::Ambiguous: 333 // Recover from type-hiding ambiguities by hiding the type. We'll 334 // do the lookup again when looking for an object, and we can 335 // diagnose the error then. If we don't do this, then the error 336 // about hiding the type will be immediately followed by an error 337 // that only makes sense if the identifier was treated like a type. 338 if (Result.getAmbiguityKind() == LookupResult::AmbiguousTagHiding) { 339 Result.suppressDiagnostics(); 340 return ParsedType(); 341 } 342 343 // Look to see if we have a type anywhere in the list of results. 344 for (LookupResult::iterator Res = Result.begin(), ResEnd = Result.end(); 345 Res != ResEnd; ++Res) { 346 if (isa<TypeDecl>(*Res) || isa<ObjCInterfaceDecl>(*Res)) { 347 if (!IIDecl || 348 (*Res)->getLocation().getRawEncoding() < 349 IIDecl->getLocation().getRawEncoding()) 350 IIDecl = *Res; 351 } 352 } 353 354 if (!IIDecl) { 355 // None of the entities we found is a type, so there is no way 356 // to even assume that the result is a type. In this case, don't 357 // complain about the ambiguity. The parser will either try to 358 // perform this lookup again (e.g., as an object name), which 359 // will produce the ambiguity, or will complain that it expected 360 // a type name. 361 Result.suppressDiagnostics(); 362 return ParsedType(); 363 } 364 365 // We found a type within the ambiguous lookup; diagnose the 366 // ambiguity and then return that type. This might be the right 367 // answer, or it might not be, but it suppresses any attempt to 368 // perform the name lookup again. 369 break; 370 371 case LookupResult::Found: 372 IIDecl = Result.getFoundDecl(); 373 break; 374 } 375 376 assert(IIDecl && "Didn't find decl"); 377 378 QualType T; 379 if (TypeDecl *TD = dyn_cast<TypeDecl>(IIDecl)) { 380 DiagnoseUseOfDecl(IIDecl, NameLoc); 381 382 T = Context.getTypeDeclType(TD); 383 384 // NOTE: avoid constructing an ElaboratedType(Loc) if this is a 385 // constructor or destructor name (in such a case, the scope specifier 386 // will be attached to the enclosing Expr or Decl node). 387 if (SS && SS->isNotEmpty() && !IsCtorOrDtorName) { 388 if (WantNontrivialTypeSourceInfo) { 389 // Construct a type with type-source information. 390 TypeLocBuilder Builder; 391 Builder.pushTypeSpec(T).setNameLoc(NameLoc); 392 393 T = getElaboratedType(ETK_None, *SS, T); 394 ElaboratedTypeLoc ElabTL = Builder.push<ElaboratedTypeLoc>(T); 395 ElabTL.setElaboratedKeywordLoc(SourceLocation()); 396 ElabTL.setQualifierLoc(SS->getWithLocInContext(Context)); 397 return CreateParsedType(T, Builder.getTypeSourceInfo(Context, T)); 398 } else { 399 T = getElaboratedType(ETK_None, *SS, T); 400 } 401 } 402 } else if (ObjCInterfaceDecl *IDecl = dyn_cast<ObjCInterfaceDecl>(IIDecl)) { 403 (void)DiagnoseUseOfDecl(IDecl, NameLoc); 404 if (!HasTrailingDot) 405 T = Context.getObjCInterfaceType(IDecl); 406 } 407 408 if (T.isNull()) { 409 // If it's not plausibly a type, suppress diagnostics. 410 Result.suppressDiagnostics(); 411 return ParsedType(); 412 } 413 return ParsedType::make(T); 414 } 415 416 // Builds a fake NNS for the given decl context. 417 static NestedNameSpecifier * 418 synthesizeCurrentNestedNameSpecifier(ASTContext &Context, DeclContext *DC) { 419 for (;; DC = DC->getLookupParent()) { 420 DC = DC->getPrimaryContext(); 421 auto *ND = dyn_cast<NamespaceDecl>(DC); 422 if (ND && !ND->isInline() && !ND->isAnonymousNamespace()) 423 return NestedNameSpecifier::Create(Context, nullptr, ND); 424 else if (auto *RD = dyn_cast<CXXRecordDecl>(DC)) 425 return NestedNameSpecifier::Create(Context, nullptr, RD->isTemplateDecl(), 426 RD->getTypeForDecl()); 427 else if (isa<TranslationUnitDecl>(DC)) 428 return NestedNameSpecifier::GlobalSpecifier(Context); 429 } 430 llvm_unreachable("something isn't in TU scope?"); 431 } 432 433 ParsedType Sema::ActOnDelayedDefaultTemplateArg(const IdentifierInfo &II, 434 SourceLocation NameLoc) { 435 // Accepting an undeclared identifier as a default argument for a template 436 // type parameter is a Microsoft extension. 437 Diag(NameLoc, diag::ext_ms_delayed_template_argument) << &II; 438 439 // Build a fake DependentNameType that will perform lookup into CurContext at 440 // instantiation time. The name specifier isn't dependent, so template 441 // instantiation won't transform it. It will retry the lookup, however. 442 NestedNameSpecifier *NNS = 443 synthesizeCurrentNestedNameSpecifier(Context, CurContext); 444 QualType T = Context.getDependentNameType(ETK_None, NNS, &II); 445 446 // Build type location information. We synthesized the qualifier, so we have 447 // to build a fake NestedNameSpecifierLoc. 448 NestedNameSpecifierLocBuilder NNSLocBuilder; 449 NNSLocBuilder.MakeTrivial(Context, NNS, SourceRange(NameLoc)); 450 NestedNameSpecifierLoc QualifierLoc = NNSLocBuilder.getWithLocInContext(Context); 451 452 TypeLocBuilder Builder; 453 DependentNameTypeLoc DepTL = Builder.push<DependentNameTypeLoc>(T); 454 DepTL.setNameLoc(NameLoc); 455 DepTL.setElaboratedKeywordLoc(SourceLocation()); 456 DepTL.setQualifierLoc(QualifierLoc); 457 return CreateParsedType(T, Builder.getTypeSourceInfo(Context, T)); 458 } 459 460 /// isTagName() - This method is called *for error recovery purposes only* 461 /// to determine if the specified name is a valid tag name ("struct foo"). If 462 /// so, this returns the TST for the tag corresponding to it (TST_enum, 463 /// TST_union, TST_struct, TST_interface, TST_class). This is used to diagnose 464 /// cases in C where the user forgot to specify the tag. 465 DeclSpec::TST Sema::isTagName(IdentifierInfo &II, Scope *S) { 466 // Do a tag name lookup in this scope. 467 LookupResult R(*this, &II, SourceLocation(), LookupTagName); 468 LookupName(R, S, false); 469 R.suppressDiagnostics(); 470 if (R.getResultKind() == LookupResult::Found) 471 if (const TagDecl *TD = R.getAsSingle<TagDecl>()) { 472 switch (TD->getTagKind()) { 473 case TTK_Struct: return DeclSpec::TST_struct; 474 case TTK_Interface: return DeclSpec::TST_interface; 475 case TTK_Union: return DeclSpec::TST_union; 476 case TTK_Class: return DeclSpec::TST_class; 477 case TTK_Enum: return DeclSpec::TST_enum; 478 } 479 } 480 481 return DeclSpec::TST_unspecified; 482 } 483 484 /// isMicrosoftMissingTypename - In Microsoft mode, within class scope, 485 /// if a CXXScopeSpec's type is equal to the type of one of the base classes 486 /// then downgrade the missing typename error to a warning. 487 /// This is needed for MSVC compatibility; Example: 488 /// @code 489 /// template<class T> class A { 490 /// public: 491 /// typedef int TYPE; 492 /// }; 493 /// template<class T> class B : public A<T> { 494 /// public: 495 /// A<T>::TYPE a; // no typename required because A<T> is a base class. 496 /// }; 497 /// @endcode 498 bool Sema::isMicrosoftMissingTypename(const CXXScopeSpec *SS, Scope *S) { 499 if (CurContext->isRecord()) { 500 const Type *Ty = SS->getScopeRep()->getAsType(); 501 502 CXXRecordDecl *RD = cast<CXXRecordDecl>(CurContext); 503 for (const auto &Base : RD->bases()) 504 if (Context.hasSameUnqualifiedType(QualType(Ty, 1), Base.getType())) 505 return true; 506 return S->isFunctionPrototypeScope(); 507 } 508 return CurContext->isFunctionOrMethod() || S->isFunctionPrototypeScope(); 509 } 510 511 void Sema::DiagnoseUnknownTypeName(IdentifierInfo *&II, 512 SourceLocation IILoc, 513 Scope *S, 514 CXXScopeSpec *SS, 515 ParsedType &SuggestedType, 516 bool AllowClassTemplates) { 517 // We don't have anything to suggest (yet). 518 SuggestedType = ParsedType(); 519 520 // There may have been a typo in the name of the type. Look up typo 521 // results, in case we have something that we can suggest. 522 TypeNameValidatorCCC Validator(false, false, AllowClassTemplates); 523 if (TypoCorrection Corrected = CorrectTypo(DeclarationNameInfo(II, IILoc), 524 LookupOrdinaryName, S, SS, 525 Validator, CTK_ErrorRecovery)) { 526 if (Corrected.isKeyword()) { 527 // We corrected to a keyword. 528 diagnoseTypo(Corrected, PDiag(diag::err_unknown_typename_suggest) << II); 529 II = Corrected.getCorrectionAsIdentifierInfo(); 530 } else { 531 // We found a similarly-named type or interface; suggest that. 532 if (!SS || !SS->isSet()) { 533 diagnoseTypo(Corrected, 534 PDiag(diag::err_unknown_typename_suggest) << II); 535 } else if (DeclContext *DC = computeDeclContext(*SS, false)) { 536 std::string CorrectedStr(Corrected.getAsString(getLangOpts())); 537 bool DroppedSpecifier = Corrected.WillReplaceSpecifier() && 538 II->getName().equals(CorrectedStr); 539 diagnoseTypo(Corrected, 540 PDiag(diag::err_unknown_nested_typename_suggest) 541 << II << DC << DroppedSpecifier << SS->getRange()); 542 } else { 543 llvm_unreachable("could not have corrected a typo here"); 544 } 545 546 CXXScopeSpec tmpSS; 547 if (Corrected.getCorrectionSpecifier()) 548 tmpSS.MakeTrivial(Context, Corrected.getCorrectionSpecifier(), 549 SourceRange(IILoc)); 550 SuggestedType = getTypeName(*Corrected.getCorrectionAsIdentifierInfo(), 551 IILoc, S, tmpSS.isSet() ? &tmpSS : SS, false, 552 false, ParsedType(), 553 /*IsCtorOrDtorName=*/false, 554 /*NonTrivialTypeSourceInfo=*/true); 555 } 556 return; 557 } 558 559 if (getLangOpts().CPlusPlus) { 560 // See if II is a class template that the user forgot to pass arguments to. 561 UnqualifiedId Name; 562 Name.setIdentifier(II, IILoc); 563 CXXScopeSpec EmptySS; 564 TemplateTy TemplateResult; 565 bool MemberOfUnknownSpecialization; 566 if (isTemplateName(S, SS ? *SS : EmptySS, /*hasTemplateKeyword=*/false, 567 Name, ParsedType(), true, TemplateResult, 568 MemberOfUnknownSpecialization) == TNK_Type_template) { 569 TemplateName TplName = TemplateResult.get(); 570 Diag(IILoc, diag::err_template_missing_args) << TplName; 571 if (TemplateDecl *TplDecl = TplName.getAsTemplateDecl()) { 572 Diag(TplDecl->getLocation(), diag::note_template_decl_here) 573 << TplDecl->getTemplateParameters()->getSourceRange(); 574 } 575 return; 576 } 577 } 578 579 // FIXME: Should we move the logic that tries to recover from a missing tag 580 // (struct, union, enum) from Parser::ParseImplicitInt here, instead? 581 582 if (!SS || (!SS->isSet() && !SS->isInvalid())) 583 Diag(IILoc, diag::err_unknown_typename) << II; 584 else if (DeclContext *DC = computeDeclContext(*SS, false)) 585 Diag(IILoc, diag::err_typename_nested_not_found) 586 << II << DC << SS->getRange(); 587 else if (isDependentScopeSpecifier(*SS)) { 588 unsigned DiagID = diag::err_typename_missing; 589 if (getLangOpts().MSVCCompat && isMicrosoftMissingTypename(SS, S)) 590 DiagID = diag::ext_typename_missing; 591 592 Diag(SS->getRange().getBegin(), DiagID) 593 << SS->getScopeRep() << II->getName() 594 << SourceRange(SS->getRange().getBegin(), IILoc) 595 << FixItHint::CreateInsertion(SS->getRange().getBegin(), "typename "); 596 SuggestedType = ActOnTypenameType(S, SourceLocation(), 597 *SS, *II, IILoc).get(); 598 } else { 599 assert(SS && SS->isInvalid() && 600 "Invalid scope specifier has already been diagnosed"); 601 } 602 } 603 604 /// \brief Determine whether the given result set contains either a type name 605 /// or 606 static bool isResultTypeOrTemplate(LookupResult &R, const Token &NextToken) { 607 bool CheckTemplate = R.getSema().getLangOpts().CPlusPlus && 608 NextToken.is(tok::less); 609 610 for (LookupResult::iterator I = R.begin(), IEnd = R.end(); I != IEnd; ++I) { 611 if (isa<TypeDecl>(*I) || isa<ObjCInterfaceDecl>(*I)) 612 return true; 613 614 if (CheckTemplate && isa<TemplateDecl>(*I)) 615 return true; 616 } 617 618 return false; 619 } 620 621 static bool isTagTypeWithMissingTag(Sema &SemaRef, LookupResult &Result, 622 Scope *S, CXXScopeSpec &SS, 623 IdentifierInfo *&Name, 624 SourceLocation NameLoc) { 625 LookupResult R(SemaRef, Name, NameLoc, Sema::LookupTagName); 626 SemaRef.LookupParsedName(R, S, &SS); 627 if (TagDecl *Tag = R.getAsSingle<TagDecl>()) { 628 StringRef FixItTagName; 629 switch (Tag->getTagKind()) { 630 case TTK_Class: 631 FixItTagName = "class "; 632 break; 633 634 case TTK_Enum: 635 FixItTagName = "enum "; 636 break; 637 638 case TTK_Struct: 639 FixItTagName = "struct "; 640 break; 641 642 case TTK_Interface: 643 FixItTagName = "__interface "; 644 break; 645 646 case TTK_Union: 647 FixItTagName = "union "; 648 break; 649 } 650 651 StringRef TagName = FixItTagName.drop_back(); 652 SemaRef.Diag(NameLoc, diag::err_use_of_tag_name_without_tag) 653 << Name << TagName << SemaRef.getLangOpts().CPlusPlus 654 << FixItHint::CreateInsertion(NameLoc, FixItTagName); 655 656 for (LookupResult::iterator I = Result.begin(), IEnd = Result.end(); 657 I != IEnd; ++I) 658 SemaRef.Diag((*I)->getLocation(), diag::note_decl_hiding_tag_type) 659 << Name << TagName; 660 661 // Replace lookup results with just the tag decl. 662 Result.clear(Sema::LookupTagName); 663 SemaRef.LookupParsedName(Result, S, &SS); 664 return true; 665 } 666 667 return false; 668 } 669 670 /// Build a ParsedType for a simple-type-specifier with a nested-name-specifier. 671 static ParsedType buildNestedType(Sema &S, CXXScopeSpec &SS, 672 QualType T, SourceLocation NameLoc) { 673 ASTContext &Context = S.Context; 674 675 TypeLocBuilder Builder; 676 Builder.pushTypeSpec(T).setNameLoc(NameLoc); 677 678 T = S.getElaboratedType(ETK_None, SS, T); 679 ElaboratedTypeLoc ElabTL = Builder.push<ElaboratedTypeLoc>(T); 680 ElabTL.setElaboratedKeywordLoc(SourceLocation()); 681 ElabTL.setQualifierLoc(SS.getWithLocInContext(Context)); 682 return S.CreateParsedType(T, Builder.getTypeSourceInfo(Context, T)); 683 } 684 685 Sema::NameClassification Sema::ClassifyName(Scope *S, 686 CXXScopeSpec &SS, 687 IdentifierInfo *&Name, 688 SourceLocation NameLoc, 689 const Token &NextToken, 690 bool IsAddressOfOperand, 691 CorrectionCandidateCallback *CCC) { 692 DeclarationNameInfo NameInfo(Name, NameLoc); 693 ObjCMethodDecl *CurMethod = getCurMethodDecl(); 694 695 if (NextToken.is(tok::coloncolon)) { 696 BuildCXXNestedNameSpecifier(S, *Name, NameLoc, NextToken.getLocation(), 697 QualType(), false, SS, nullptr, false); 698 } 699 700 LookupResult Result(*this, Name, NameLoc, LookupOrdinaryName); 701 LookupParsedName(Result, S, &SS, !CurMethod); 702 703 // For unqualified lookup in a class template in MSVC mode, look into 704 // dependent base classes where the primary class template is known. 705 if (Result.empty() && SS.isEmpty() && getLangOpts().MSVCCompat) { 706 if (ParsedType TypeInBase = 707 recoverFromTypeInKnownDependentBase(*this, *Name, NameLoc)) 708 return TypeInBase; 709 } 710 711 // Perform lookup for Objective-C instance variables (including automatically 712 // synthesized instance variables), if we're in an Objective-C method. 713 // FIXME: This lookup really, really needs to be folded in to the normal 714 // unqualified lookup mechanism. 715 if (!SS.isSet() && CurMethod && !isResultTypeOrTemplate(Result, NextToken)) { 716 ExprResult E = LookupInObjCMethod(Result, S, Name, true); 717 if (E.get() || E.isInvalid()) 718 return E; 719 } 720 721 bool SecondTry = false; 722 bool IsFilteredTemplateName = false; 723 724 Corrected: 725 switch (Result.getResultKind()) { 726 case LookupResult::NotFound: 727 // If an unqualified-id is followed by a '(', then we have a function 728 // call. 729 if (!SS.isSet() && NextToken.is(tok::l_paren)) { 730 // In C++, this is an ADL-only call. 731 // FIXME: Reference? 732 if (getLangOpts().CPlusPlus) 733 return BuildDeclarationNameExpr(SS, Result, /*ADL=*/true); 734 735 // C90 6.3.2.2: 736 // If the expression that precedes the parenthesized argument list in a 737 // function call consists solely of an identifier, and if no 738 // declaration is visible for this identifier, the identifier is 739 // implicitly declared exactly as if, in the innermost block containing 740 // the function call, the declaration 741 // 742 // extern int identifier (); 743 // 744 // appeared. 745 // 746 // We also allow this in C99 as an extension. 747 if (NamedDecl *D = ImplicitlyDefineFunction(NameLoc, *Name, S)) { 748 Result.addDecl(D); 749 Result.resolveKind(); 750 return BuildDeclarationNameExpr(SS, Result, /*ADL=*/false); 751 } 752 } 753 754 // In C, we first see whether there is a tag type by the same name, in 755 // which case it's likely that the user just forget to write "enum", 756 // "struct", or "union". 757 if (!getLangOpts().CPlusPlus && !SecondTry && 758 isTagTypeWithMissingTag(*this, Result, S, SS, Name, NameLoc)) { 759 break; 760 } 761 762 // Perform typo correction to determine if there is another name that is 763 // close to this name. 764 if (!SecondTry && CCC) { 765 SecondTry = true; 766 if (TypoCorrection Corrected = CorrectTypo(Result.getLookupNameInfo(), 767 Result.getLookupKind(), S, 768 &SS, *CCC, 769 CTK_ErrorRecovery)) { 770 unsigned UnqualifiedDiag = diag::err_undeclared_var_use_suggest; 771 unsigned QualifiedDiag = diag::err_no_member_suggest; 772 773 NamedDecl *FirstDecl = Corrected.getCorrectionDecl(); 774 NamedDecl *UnderlyingFirstDecl 775 = FirstDecl? FirstDecl->getUnderlyingDecl() : nullptr; 776 if (getLangOpts().CPlusPlus && NextToken.is(tok::less) && 777 UnderlyingFirstDecl && isa<TemplateDecl>(UnderlyingFirstDecl)) { 778 UnqualifiedDiag = diag::err_no_template_suggest; 779 QualifiedDiag = diag::err_no_member_template_suggest; 780 } else if (UnderlyingFirstDecl && 781 (isa<TypeDecl>(UnderlyingFirstDecl) || 782 isa<ObjCInterfaceDecl>(UnderlyingFirstDecl) || 783 isa<ObjCCompatibleAliasDecl>(UnderlyingFirstDecl))) { 784 UnqualifiedDiag = diag::err_unknown_typename_suggest; 785 QualifiedDiag = diag::err_unknown_nested_typename_suggest; 786 } 787 788 if (SS.isEmpty()) { 789 diagnoseTypo(Corrected, PDiag(UnqualifiedDiag) << Name); 790 } else {// FIXME: is this even reachable? Test it. 791 std::string CorrectedStr(Corrected.getAsString(getLangOpts())); 792 bool DroppedSpecifier = Corrected.WillReplaceSpecifier() && 793 Name->getName().equals(CorrectedStr); 794 diagnoseTypo(Corrected, PDiag(QualifiedDiag) 795 << Name << computeDeclContext(SS, false) 796 << DroppedSpecifier << SS.getRange()); 797 } 798 799 // Update the name, so that the caller has the new name. 800 Name = Corrected.getCorrectionAsIdentifierInfo(); 801 802 // Typo correction corrected to a keyword. 803 if (Corrected.isKeyword()) 804 return Name; 805 806 // Also update the LookupResult... 807 // FIXME: This should probably go away at some point 808 Result.clear(); 809 Result.setLookupName(Corrected.getCorrection()); 810 if (FirstDecl) 811 Result.addDecl(FirstDecl); 812 813 // If we found an Objective-C instance variable, let 814 // LookupInObjCMethod build the appropriate expression to 815 // reference the ivar. 816 // FIXME: This is a gross hack. 817 if (ObjCIvarDecl *Ivar = Result.getAsSingle<ObjCIvarDecl>()) { 818 Result.clear(); 819 ExprResult E(LookupInObjCMethod(Result, S, Ivar->getIdentifier())); 820 return E; 821 } 822 823 goto Corrected; 824 } 825 } 826 827 // We failed to correct; just fall through and let the parser deal with it. 828 Result.suppressDiagnostics(); 829 return NameClassification::Unknown(); 830 831 case LookupResult::NotFoundInCurrentInstantiation: { 832 // We performed name lookup into the current instantiation, and there were 833 // dependent bases, so we treat this result the same way as any other 834 // dependent nested-name-specifier. 835 836 // C++ [temp.res]p2: 837 // A name used in a template declaration or definition and that is 838 // dependent on a template-parameter is assumed not to name a type 839 // unless the applicable name lookup finds a type name or the name is 840 // qualified by the keyword typename. 841 // 842 // FIXME: If the next token is '<', we might want to ask the parser to 843 // perform some heroics to see if we actually have a 844 // template-argument-list, which would indicate a missing 'template' 845 // keyword here. 846 return ActOnDependentIdExpression(SS, /*TemplateKWLoc=*/SourceLocation(), 847 NameInfo, IsAddressOfOperand, 848 /*TemplateArgs=*/nullptr); 849 } 850 851 case LookupResult::Found: 852 case LookupResult::FoundOverloaded: 853 case LookupResult::FoundUnresolvedValue: 854 break; 855 856 case LookupResult::Ambiguous: 857 if (getLangOpts().CPlusPlus && NextToken.is(tok::less) && 858 hasAnyAcceptableTemplateNames(Result)) { 859 // C++ [temp.local]p3: 860 // A lookup that finds an injected-class-name (10.2) can result in an 861 // ambiguity in certain cases (for example, if it is found in more than 862 // one base class). If all of the injected-class-names that are found 863 // refer to specializations of the same class template, and if the name 864 // is followed by a template-argument-list, the reference refers to the 865 // class template itself and not a specialization thereof, and is not 866 // ambiguous. 867 // 868 // This filtering can make an ambiguous result into an unambiguous one, 869 // so try again after filtering out template names. 870 FilterAcceptableTemplateNames(Result); 871 if (!Result.isAmbiguous()) { 872 IsFilteredTemplateName = true; 873 break; 874 } 875 } 876 877 // Diagnose the ambiguity and return an error. 878 return NameClassification::Error(); 879 } 880 881 if (getLangOpts().CPlusPlus && NextToken.is(tok::less) && 882 (IsFilteredTemplateName || hasAnyAcceptableTemplateNames(Result))) { 883 // C++ [temp.names]p3: 884 // After name lookup (3.4) finds that a name is a template-name or that 885 // an operator-function-id or a literal- operator-id refers to a set of 886 // overloaded functions any member of which is a function template if 887 // this is followed by a <, the < is always taken as the delimiter of a 888 // template-argument-list and never as the less-than operator. 889 if (!IsFilteredTemplateName) 890 FilterAcceptableTemplateNames(Result); 891 892 if (!Result.empty()) { 893 bool IsFunctionTemplate; 894 bool IsVarTemplate; 895 TemplateName Template; 896 if (Result.end() - Result.begin() > 1) { 897 IsFunctionTemplate = true; 898 Template = Context.getOverloadedTemplateName(Result.begin(), 899 Result.end()); 900 } else { 901 TemplateDecl *TD 902 = cast<TemplateDecl>((*Result.begin())->getUnderlyingDecl()); 903 IsFunctionTemplate = isa<FunctionTemplateDecl>(TD); 904 IsVarTemplate = isa<VarTemplateDecl>(TD); 905 906 if (SS.isSet() && !SS.isInvalid()) 907 Template = Context.getQualifiedTemplateName(SS.getScopeRep(), 908 /*TemplateKeyword=*/false, 909 TD); 910 else 911 Template = TemplateName(TD); 912 } 913 914 if (IsFunctionTemplate) { 915 // Function templates always go through overload resolution, at which 916 // point we'll perform the various checks (e.g., accessibility) we need 917 // to based on which function we selected. 918 Result.suppressDiagnostics(); 919 920 return NameClassification::FunctionTemplate(Template); 921 } 922 923 return IsVarTemplate ? NameClassification::VarTemplate(Template) 924 : NameClassification::TypeTemplate(Template); 925 } 926 } 927 928 NamedDecl *FirstDecl = (*Result.begin())->getUnderlyingDecl(); 929 if (TypeDecl *Type = dyn_cast<TypeDecl>(FirstDecl)) { 930 DiagnoseUseOfDecl(Type, NameLoc); 931 QualType T = Context.getTypeDeclType(Type); 932 if (SS.isNotEmpty()) 933 return buildNestedType(*this, SS, T, NameLoc); 934 return ParsedType::make(T); 935 } 936 937 ObjCInterfaceDecl *Class = dyn_cast<ObjCInterfaceDecl>(FirstDecl); 938 if (!Class) { 939 // FIXME: It's unfortunate that we don't have a Type node for handling this. 940 if (ObjCCompatibleAliasDecl *Alias = 941 dyn_cast<ObjCCompatibleAliasDecl>(FirstDecl)) 942 Class = Alias->getClassInterface(); 943 } 944 945 if (Class) { 946 DiagnoseUseOfDecl(Class, NameLoc); 947 948 if (NextToken.is(tok::period)) { 949 // Interface. <something> is parsed as a property reference expression. 950 // Just return "unknown" as a fall-through for now. 951 Result.suppressDiagnostics(); 952 return NameClassification::Unknown(); 953 } 954 955 QualType T = Context.getObjCInterfaceType(Class); 956 return ParsedType::make(T); 957 } 958 959 // We can have a type template here if we're classifying a template argument. 960 if (isa<TemplateDecl>(FirstDecl) && !isa<FunctionTemplateDecl>(FirstDecl)) 961 return NameClassification::TypeTemplate( 962 TemplateName(cast<TemplateDecl>(FirstDecl))); 963 964 // Check for a tag type hidden by a non-type decl in a few cases where it 965 // seems likely a type is wanted instead of the non-type that was found. 966 bool NextIsOp = NextToken.is(tok::amp) || NextToken.is(tok::star); 967 if ((NextToken.is(tok::identifier) || 968 (NextIsOp && 969 FirstDecl->getUnderlyingDecl()->isFunctionOrFunctionTemplate())) && 970 isTagTypeWithMissingTag(*this, Result, S, SS, Name, NameLoc)) { 971 TypeDecl *Type = Result.getAsSingle<TypeDecl>(); 972 DiagnoseUseOfDecl(Type, NameLoc); 973 QualType T = Context.getTypeDeclType(Type); 974 if (SS.isNotEmpty()) 975 return buildNestedType(*this, SS, T, NameLoc); 976 return ParsedType::make(T); 977 } 978 979 if (FirstDecl->isCXXClassMember()) 980 return BuildPossibleImplicitMemberExpr(SS, SourceLocation(), Result, 981 nullptr); 982 983 bool ADL = UseArgumentDependentLookup(SS, Result, NextToken.is(tok::l_paren)); 984 return BuildDeclarationNameExpr(SS, Result, ADL); 985 } 986 987 // Determines the context to return to after temporarily entering a 988 // context. This depends in an unnecessarily complicated way on the 989 // exact ordering of callbacks from the parser. 990 DeclContext *Sema::getContainingDC(DeclContext *DC) { 991 992 // Functions defined inline within classes aren't parsed until we've 993 // finished parsing the top-level class, so the top-level class is 994 // the context we'll need to return to. 995 // A Lambda call operator whose parent is a class must not be treated 996 // as an inline member function. A Lambda can be used legally 997 // either as an in-class member initializer or a default argument. These 998 // are parsed once the class has been marked complete and so the containing 999 // context would be the nested class (when the lambda is defined in one); 1000 // If the class is not complete, then the lambda is being used in an 1001 // ill-formed fashion (such as to specify the width of a bit-field, or 1002 // in an array-bound) - in which case we still want to return the 1003 // lexically containing DC (which could be a nested class). 1004 if (isa<FunctionDecl>(DC) && !isLambdaCallOperator(DC)) { 1005 DC = DC->getLexicalParent(); 1006 1007 // A function not defined within a class will always return to its 1008 // lexical context. 1009 if (!isa<CXXRecordDecl>(DC)) 1010 return DC; 1011 1012 // A C++ inline method/friend is parsed *after* the topmost class 1013 // it was declared in is fully parsed ("complete"); the topmost 1014 // class is the context we need to return to. 1015 while (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(DC->getLexicalParent())) 1016 DC = RD; 1017 1018 // Return the declaration context of the topmost class the inline method is 1019 // declared in. 1020 return DC; 1021 } 1022 1023 return DC->getLexicalParent(); 1024 } 1025 1026 void Sema::PushDeclContext(Scope *S, DeclContext *DC) { 1027 assert(getContainingDC(DC) == CurContext && 1028 "The next DeclContext should be lexically contained in the current one."); 1029 CurContext = DC; 1030 S->setEntity(DC); 1031 } 1032 1033 void Sema::PopDeclContext() { 1034 assert(CurContext && "DeclContext imbalance!"); 1035 1036 CurContext = getContainingDC(CurContext); 1037 assert(CurContext && "Popped translation unit!"); 1038 } 1039 1040 /// EnterDeclaratorContext - Used when we must lookup names in the context 1041 /// of a declarator's nested name specifier. 1042 /// 1043 void Sema::EnterDeclaratorContext(Scope *S, DeclContext *DC) { 1044 // C++0x [basic.lookup.unqual]p13: 1045 // A name used in the definition of a static data member of class 1046 // X (after the qualified-id of the static member) is looked up as 1047 // if the name was used in a member function of X. 1048 // C++0x [basic.lookup.unqual]p14: 1049 // If a variable member of a namespace is defined outside of the 1050 // scope of its namespace then any name used in the definition of 1051 // the variable member (after the declarator-id) is looked up as 1052 // if the definition of the variable member occurred in its 1053 // namespace. 1054 // Both of these imply that we should push a scope whose context 1055 // is the semantic context of the declaration. We can't use 1056 // PushDeclContext here because that context is not necessarily 1057 // lexically contained in the current context. Fortunately, 1058 // the containing scope should have the appropriate information. 1059 1060 assert(!S->getEntity() && "scope already has entity"); 1061 1062 #ifndef NDEBUG 1063 Scope *Ancestor = S->getParent(); 1064 while (!Ancestor->getEntity()) Ancestor = Ancestor->getParent(); 1065 assert(Ancestor->getEntity() == CurContext && "ancestor context mismatch"); 1066 #endif 1067 1068 CurContext = DC; 1069 S->setEntity(DC); 1070 } 1071 1072 void Sema::ExitDeclaratorContext(Scope *S) { 1073 assert(S->getEntity() == CurContext && "Context imbalance!"); 1074 1075 // Switch back to the lexical context. The safety of this is 1076 // enforced by an assert in EnterDeclaratorContext. 1077 Scope *Ancestor = S->getParent(); 1078 while (!Ancestor->getEntity()) Ancestor = Ancestor->getParent(); 1079 CurContext = Ancestor->getEntity(); 1080 1081 // We don't need to do anything with the scope, which is going to 1082 // disappear. 1083 } 1084 1085 1086 void Sema::ActOnReenterFunctionContext(Scope* S, Decl *D) { 1087 // We assume that the caller has already called 1088 // ActOnReenterTemplateScope so getTemplatedDecl() works. 1089 FunctionDecl *FD = D->getAsFunction(); 1090 if (!FD) 1091 return; 1092 1093 // Same implementation as PushDeclContext, but enters the context 1094 // from the lexical parent, rather than the top-level class. 1095 assert(CurContext == FD->getLexicalParent() && 1096 "The next DeclContext should be lexically contained in the current one."); 1097 CurContext = FD; 1098 S->setEntity(CurContext); 1099 1100 for (unsigned P = 0, NumParams = FD->getNumParams(); P < NumParams; ++P) { 1101 ParmVarDecl *Param = FD->getParamDecl(P); 1102 // If the parameter has an identifier, then add it to the scope 1103 if (Param->getIdentifier()) { 1104 S->AddDecl(Param); 1105 IdResolver.AddDecl(Param); 1106 } 1107 } 1108 } 1109 1110 1111 void Sema::ActOnExitFunctionContext() { 1112 // Same implementation as PopDeclContext, but returns to the lexical parent, 1113 // rather than the top-level class. 1114 assert(CurContext && "DeclContext imbalance!"); 1115 CurContext = CurContext->getLexicalParent(); 1116 assert(CurContext && "Popped translation unit!"); 1117 } 1118 1119 1120 /// \brief Determine whether we allow overloading of the function 1121 /// PrevDecl with another declaration. 1122 /// 1123 /// This routine determines whether overloading is possible, not 1124 /// whether some new function is actually an overload. It will return 1125 /// true in C++ (where we can always provide overloads) or, as an 1126 /// extension, in C when the previous function is already an 1127 /// overloaded function declaration or has the "overloadable" 1128 /// attribute. 1129 static bool AllowOverloadingOfFunction(LookupResult &Previous, 1130 ASTContext &Context) { 1131 if (Context.getLangOpts().CPlusPlus) 1132 return true; 1133 1134 if (Previous.getResultKind() == LookupResult::FoundOverloaded) 1135 return true; 1136 1137 return (Previous.getResultKind() == LookupResult::Found 1138 && Previous.getFoundDecl()->hasAttr<OverloadableAttr>()); 1139 } 1140 1141 /// Add this decl to the scope shadowed decl chains. 1142 void Sema::PushOnScopeChains(NamedDecl *D, Scope *S, bool AddToContext) { 1143 // Move up the scope chain until we find the nearest enclosing 1144 // non-transparent context. The declaration will be introduced into this 1145 // scope. 1146 while (S->getEntity() && S->getEntity()->isTransparentContext()) 1147 S = S->getParent(); 1148 1149 // Add scoped declarations into their context, so that they can be 1150 // found later. Declarations without a context won't be inserted 1151 // into any context. 1152 if (AddToContext) 1153 CurContext->addDecl(D); 1154 1155 // Out-of-line definitions shouldn't be pushed into scope in C++, unless they 1156 // are function-local declarations. 1157 if (getLangOpts().CPlusPlus && D->isOutOfLine() && 1158 !D->getDeclContext()->getRedeclContext()->Equals( 1159 D->getLexicalDeclContext()->getRedeclContext()) && 1160 !D->getLexicalDeclContext()->isFunctionOrMethod()) 1161 return; 1162 1163 // Template instantiations should also not be pushed into scope. 1164 if (isa<FunctionDecl>(D) && 1165 cast<FunctionDecl>(D)->isFunctionTemplateSpecialization()) 1166 return; 1167 1168 // If this replaces anything in the current scope, 1169 IdentifierResolver::iterator I = IdResolver.begin(D->getDeclName()), 1170 IEnd = IdResolver.end(); 1171 for (; I != IEnd; ++I) { 1172 if (S->isDeclScope(*I) && D->declarationReplaces(*I)) { 1173 S->RemoveDecl(*I); 1174 IdResolver.RemoveDecl(*I); 1175 1176 // Should only need to replace one decl. 1177 break; 1178 } 1179 } 1180 1181 S->AddDecl(D); 1182 1183 if (isa<LabelDecl>(D) && !cast<LabelDecl>(D)->isGnuLocal()) { 1184 // Implicitly-generated labels may end up getting generated in an order that 1185 // isn't strictly lexical, which breaks name lookup. Be careful to insert 1186 // the label at the appropriate place in the identifier chain. 1187 for (I = IdResolver.begin(D->getDeclName()); I != IEnd; ++I) { 1188 DeclContext *IDC = (*I)->getLexicalDeclContext()->getRedeclContext(); 1189 if (IDC == CurContext) { 1190 if (!S->isDeclScope(*I)) 1191 continue; 1192 } else if (IDC->Encloses(CurContext)) 1193 break; 1194 } 1195 1196 IdResolver.InsertDeclAfter(I, D); 1197 } else { 1198 IdResolver.AddDecl(D); 1199 } 1200 } 1201 1202 void Sema::pushExternalDeclIntoScope(NamedDecl *D, DeclarationName Name) { 1203 if (IdResolver.tryAddTopLevelDecl(D, Name) && TUScope) 1204 TUScope->AddDecl(D); 1205 } 1206 1207 bool Sema::isDeclInScope(NamedDecl *D, DeclContext *Ctx, Scope *S, 1208 bool AllowInlineNamespace) { 1209 return IdResolver.isDeclInScope(D, Ctx, S, AllowInlineNamespace); 1210 } 1211 1212 Scope *Sema::getScopeForDeclContext(Scope *S, DeclContext *DC) { 1213 DeclContext *TargetDC = DC->getPrimaryContext(); 1214 do { 1215 if (DeclContext *ScopeDC = S->getEntity()) 1216 if (ScopeDC->getPrimaryContext() == TargetDC) 1217 return S; 1218 } while ((S = S->getParent())); 1219 1220 return nullptr; 1221 } 1222 1223 static bool isOutOfScopePreviousDeclaration(NamedDecl *, 1224 DeclContext*, 1225 ASTContext&); 1226 1227 /// Filters out lookup results that don't fall within the given scope 1228 /// as determined by isDeclInScope. 1229 void Sema::FilterLookupForScope(LookupResult &R, DeclContext *Ctx, Scope *S, 1230 bool ConsiderLinkage, 1231 bool AllowInlineNamespace) { 1232 LookupResult::Filter F = R.makeFilter(); 1233 while (F.hasNext()) { 1234 NamedDecl *D = F.next(); 1235 1236 if (isDeclInScope(D, Ctx, S, AllowInlineNamespace)) 1237 continue; 1238 1239 if (ConsiderLinkage && isOutOfScopePreviousDeclaration(D, Ctx, Context)) 1240 continue; 1241 1242 F.erase(); 1243 } 1244 1245 F.done(); 1246 } 1247 1248 static bool isUsingDecl(NamedDecl *D) { 1249 return isa<UsingShadowDecl>(D) || 1250 isa<UnresolvedUsingTypenameDecl>(D) || 1251 isa<UnresolvedUsingValueDecl>(D); 1252 } 1253 1254 /// Removes using shadow declarations from the lookup results. 1255 static void RemoveUsingDecls(LookupResult &R) { 1256 LookupResult::Filter F = R.makeFilter(); 1257 while (F.hasNext()) 1258 if (isUsingDecl(F.next())) 1259 F.erase(); 1260 1261 F.done(); 1262 } 1263 1264 /// \brief Check for this common pattern: 1265 /// @code 1266 /// class S { 1267 /// S(const S&); // DO NOT IMPLEMENT 1268 /// void operator=(const S&); // DO NOT IMPLEMENT 1269 /// }; 1270 /// @endcode 1271 static bool IsDisallowedCopyOrAssign(const CXXMethodDecl *D) { 1272 // FIXME: Should check for private access too but access is set after we get 1273 // the decl here. 1274 if (D->doesThisDeclarationHaveABody()) 1275 return false; 1276 1277 if (const CXXConstructorDecl *CD = dyn_cast<CXXConstructorDecl>(D)) 1278 return CD->isCopyConstructor(); 1279 if (const CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D)) 1280 return Method->isCopyAssignmentOperator(); 1281 return false; 1282 } 1283 1284 // We need this to handle 1285 // 1286 // typedef struct { 1287 // void *foo() { return 0; } 1288 // } A; 1289 // 1290 // When we see foo we don't know if after the typedef we will get 'A' or '*A' 1291 // for example. If 'A', foo will have external linkage. If we have '*A', 1292 // foo will have no linkage. Since we can't know until we get to the end 1293 // of the typedef, this function finds out if D might have non-external linkage. 1294 // Callers should verify at the end of the TU if it D has external linkage or 1295 // not. 1296 bool Sema::mightHaveNonExternalLinkage(const DeclaratorDecl *D) { 1297 const DeclContext *DC = D->getDeclContext(); 1298 while (!DC->isTranslationUnit()) { 1299 if (const RecordDecl *RD = dyn_cast<RecordDecl>(DC)){ 1300 if (!RD->hasNameForLinkage()) 1301 return true; 1302 } 1303 DC = DC->getParent(); 1304 } 1305 1306 return !D->isExternallyVisible(); 1307 } 1308 1309 // FIXME: This needs to be refactored; some other isInMainFile users want 1310 // these semantics. 1311 static bool isMainFileLoc(const Sema &S, SourceLocation Loc) { 1312 if (S.TUKind != TU_Complete) 1313 return false; 1314 return S.SourceMgr.isInMainFile(Loc); 1315 } 1316 1317 bool Sema::ShouldWarnIfUnusedFileScopedDecl(const DeclaratorDecl *D) const { 1318 assert(D); 1319 1320 if (D->isInvalidDecl() || D->isUsed() || D->hasAttr<UnusedAttr>()) 1321 return false; 1322 1323 // Ignore all entities declared within templates, and out-of-line definitions 1324 // of members of class templates. 1325 if (D->getDeclContext()->isDependentContext() || 1326 D->getLexicalDeclContext()->isDependentContext()) 1327 return false; 1328 1329 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) { 1330 if (FD->getTemplateSpecializationKind() == TSK_ImplicitInstantiation) 1331 return false; 1332 1333 if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) { 1334 if (MD->isVirtual() || IsDisallowedCopyOrAssign(MD)) 1335 return false; 1336 } else { 1337 // 'static inline' functions are defined in headers; don't warn. 1338 if (FD->isInlined() && !isMainFileLoc(*this, FD->getLocation())) 1339 return false; 1340 } 1341 1342 if (FD->doesThisDeclarationHaveABody() && 1343 Context.DeclMustBeEmitted(FD)) 1344 return false; 1345 } else if (const VarDecl *VD = dyn_cast<VarDecl>(D)) { 1346 // Constants and utility variables are defined in headers with internal 1347 // linkage; don't warn. (Unlike functions, there isn't a convenient marker 1348 // like "inline".) 1349 if (!isMainFileLoc(*this, VD->getLocation())) 1350 return false; 1351 1352 if (Context.DeclMustBeEmitted(VD)) 1353 return false; 1354 1355 if (VD->isStaticDataMember() && 1356 VD->getTemplateSpecializationKind() == TSK_ImplicitInstantiation) 1357 return false; 1358 } else { 1359 return false; 1360 } 1361 1362 // Only warn for unused decls internal to the translation unit. 1363 // FIXME: This seems like a bogus check; it suppresses -Wunused-function 1364 // for inline functions defined in the main source file, for instance. 1365 return mightHaveNonExternalLinkage(D); 1366 } 1367 1368 void Sema::MarkUnusedFileScopedDecl(const DeclaratorDecl *D) { 1369 if (!D) 1370 return; 1371 1372 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) { 1373 const FunctionDecl *First = FD->getFirstDecl(); 1374 if (FD != First && ShouldWarnIfUnusedFileScopedDecl(First)) 1375 return; // First should already be in the vector. 1376 } 1377 1378 if (const VarDecl *VD = dyn_cast<VarDecl>(D)) { 1379 const VarDecl *First = VD->getFirstDecl(); 1380 if (VD != First && ShouldWarnIfUnusedFileScopedDecl(First)) 1381 return; // First should already be in the vector. 1382 } 1383 1384 if (ShouldWarnIfUnusedFileScopedDecl(D)) 1385 UnusedFileScopedDecls.push_back(D); 1386 } 1387 1388 static bool ShouldDiagnoseUnusedDecl(const NamedDecl *D) { 1389 if (D->isInvalidDecl()) 1390 return false; 1391 1392 if (D->isReferenced() || D->isUsed() || D->hasAttr<UnusedAttr>() || 1393 D->hasAttr<ObjCPreciseLifetimeAttr>()) 1394 return false; 1395 1396 if (isa<LabelDecl>(D)) 1397 return true; 1398 1399 // White-list anything that isn't a local variable. 1400 if (!isa<VarDecl>(D) || isa<ParmVarDecl>(D) || isa<ImplicitParamDecl>(D) || 1401 !D->getDeclContext()->isFunctionOrMethod()) 1402 return false; 1403 1404 // Types of valid local variables should be complete, so this should succeed. 1405 if (const VarDecl *VD = dyn_cast<VarDecl>(D)) { 1406 1407 // White-list anything with an __attribute__((unused)) type. 1408 QualType Ty = VD->getType(); 1409 1410 // Only look at the outermost level of typedef. 1411 if (const TypedefType *TT = Ty->getAs<TypedefType>()) { 1412 if (TT->getDecl()->hasAttr<UnusedAttr>()) 1413 return false; 1414 } 1415 1416 // If we failed to complete the type for some reason, or if the type is 1417 // dependent, don't diagnose the variable. 1418 if (Ty->isIncompleteType() || Ty->isDependentType()) 1419 return false; 1420 1421 if (const TagType *TT = Ty->getAs<TagType>()) { 1422 const TagDecl *Tag = TT->getDecl(); 1423 if (Tag->hasAttr<UnusedAttr>()) 1424 return false; 1425 1426 if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(Tag)) { 1427 if (!RD->hasTrivialDestructor() && !RD->hasAttr<WarnUnusedAttr>()) 1428 return false; 1429 1430 if (const Expr *Init = VD->getInit()) { 1431 if (const ExprWithCleanups *Cleanups = 1432 dyn_cast<ExprWithCleanups>(Init)) 1433 Init = Cleanups->getSubExpr(); 1434 const CXXConstructExpr *Construct = 1435 dyn_cast<CXXConstructExpr>(Init); 1436 if (Construct && !Construct->isElidable()) { 1437 CXXConstructorDecl *CD = Construct->getConstructor(); 1438 if (!CD->isTrivial() && !RD->hasAttr<WarnUnusedAttr>()) 1439 return false; 1440 } 1441 } 1442 } 1443 } 1444 1445 // TODO: __attribute__((unused)) templates? 1446 } 1447 1448 return true; 1449 } 1450 1451 static void GenerateFixForUnusedDecl(const NamedDecl *D, ASTContext &Ctx, 1452 FixItHint &Hint) { 1453 if (isa<LabelDecl>(D)) { 1454 SourceLocation AfterColon = Lexer::findLocationAfterToken(D->getLocEnd(), 1455 tok::colon, Ctx.getSourceManager(), Ctx.getLangOpts(), true); 1456 if (AfterColon.isInvalid()) 1457 return; 1458 Hint = FixItHint::CreateRemoval(CharSourceRange:: 1459 getCharRange(D->getLocStart(), AfterColon)); 1460 } 1461 return; 1462 } 1463 1464 /// DiagnoseUnusedDecl - Emit warnings about declarations that are not used 1465 /// unless they are marked attr(unused). 1466 void Sema::DiagnoseUnusedDecl(const NamedDecl *D) { 1467 if (!ShouldDiagnoseUnusedDecl(D)) 1468 return; 1469 1470 FixItHint Hint; 1471 GenerateFixForUnusedDecl(D, Context, Hint); 1472 1473 unsigned DiagID; 1474 if (isa<VarDecl>(D) && cast<VarDecl>(D)->isExceptionVariable()) 1475 DiagID = diag::warn_unused_exception_param; 1476 else if (isa<LabelDecl>(D)) 1477 DiagID = diag::warn_unused_label; 1478 else 1479 DiagID = diag::warn_unused_variable; 1480 1481 Diag(D->getLocation(), DiagID) << D->getDeclName() << Hint; 1482 } 1483 1484 static void CheckPoppedLabel(LabelDecl *L, Sema &S) { 1485 // Verify that we have no forward references left. If so, there was a goto 1486 // or address of a label taken, but no definition of it. Label fwd 1487 // definitions are indicated with a null substmt. 1488 if (L->getStmt() == nullptr) 1489 S.Diag(L->getLocation(), diag::err_undeclared_label_use) <<L->getDeclName(); 1490 } 1491 1492 void Sema::ActOnPopScope(SourceLocation Loc, Scope *S) { 1493 S->mergeNRVOIntoParent(); 1494 1495 if (S->decl_empty()) return; 1496 assert((S->getFlags() & (Scope::DeclScope | Scope::TemplateParamScope)) && 1497 "Scope shouldn't contain decls!"); 1498 1499 for (auto *TmpD : S->decls()) { 1500 assert(TmpD && "This decl didn't get pushed??"); 1501 1502 assert(isa<NamedDecl>(TmpD) && "Decl isn't NamedDecl?"); 1503 NamedDecl *D = cast<NamedDecl>(TmpD); 1504 1505 if (!D->getDeclName()) continue; 1506 1507 // Diagnose unused variables in this scope. 1508 if (!S->hasUnrecoverableErrorOccurred()) 1509 DiagnoseUnusedDecl(D); 1510 1511 // If this was a forward reference to a label, verify it was defined. 1512 if (LabelDecl *LD = dyn_cast<LabelDecl>(D)) 1513 CheckPoppedLabel(LD, *this); 1514 1515 // Remove this name from our lexical scope. 1516 IdResolver.RemoveDecl(D); 1517 } 1518 } 1519 1520 /// \brief Look for an Objective-C class in the translation unit. 1521 /// 1522 /// \param Id The name of the Objective-C class we're looking for. If 1523 /// typo-correction fixes this name, the Id will be updated 1524 /// to the fixed name. 1525 /// 1526 /// \param IdLoc The location of the name in the translation unit. 1527 /// 1528 /// \param DoTypoCorrection If true, this routine will attempt typo correction 1529 /// if there is no class with the given name. 1530 /// 1531 /// \returns The declaration of the named Objective-C class, or NULL if the 1532 /// class could not be found. 1533 ObjCInterfaceDecl *Sema::getObjCInterfaceDecl(IdentifierInfo *&Id, 1534 SourceLocation IdLoc, 1535 bool DoTypoCorrection) { 1536 // The third "scope" argument is 0 since we aren't enabling lazy built-in 1537 // creation from this context. 1538 NamedDecl *IDecl = LookupSingleName(TUScope, Id, IdLoc, LookupOrdinaryName); 1539 1540 if (!IDecl && DoTypoCorrection) { 1541 // Perform typo correction at the given location, but only if we 1542 // find an Objective-C class name. 1543 DeclFilterCCC<ObjCInterfaceDecl> Validator; 1544 if (TypoCorrection C = CorrectTypo(DeclarationNameInfo(Id, IdLoc), 1545 LookupOrdinaryName, TUScope, nullptr, 1546 Validator, CTK_ErrorRecovery)) { 1547 diagnoseTypo(C, PDiag(diag::err_undef_interface_suggest) << Id); 1548 IDecl = C.getCorrectionDeclAs<ObjCInterfaceDecl>(); 1549 Id = IDecl->getIdentifier(); 1550 } 1551 } 1552 ObjCInterfaceDecl *Def = dyn_cast_or_null<ObjCInterfaceDecl>(IDecl); 1553 // This routine must always return a class definition, if any. 1554 if (Def && Def->getDefinition()) 1555 Def = Def->getDefinition(); 1556 return Def; 1557 } 1558 1559 /// getNonFieldDeclScope - Retrieves the innermost scope, starting 1560 /// from S, where a non-field would be declared. This routine copes 1561 /// with the difference between C and C++ scoping rules in structs and 1562 /// unions. For example, the following code is well-formed in C but 1563 /// ill-formed in C++: 1564 /// @code 1565 /// struct S6 { 1566 /// enum { BAR } e; 1567 /// }; 1568 /// 1569 /// void test_S6() { 1570 /// struct S6 a; 1571 /// a.e = BAR; 1572 /// } 1573 /// @endcode 1574 /// For the declaration of BAR, this routine will return a different 1575 /// scope. The scope S will be the scope of the unnamed enumeration 1576 /// within S6. In C++, this routine will return the scope associated 1577 /// with S6, because the enumeration's scope is a transparent 1578 /// context but structures can contain non-field names. In C, this 1579 /// routine will return the translation unit scope, since the 1580 /// enumeration's scope is a transparent context and structures cannot 1581 /// contain non-field names. 1582 Scope *Sema::getNonFieldDeclScope(Scope *S) { 1583 while (((S->getFlags() & Scope::DeclScope) == 0) || 1584 (S->getEntity() && S->getEntity()->isTransparentContext()) || 1585 (S->isClassScope() && !getLangOpts().CPlusPlus)) 1586 S = S->getParent(); 1587 return S; 1588 } 1589 1590 /// \brief Looks up the declaration of "struct objc_super" and 1591 /// saves it for later use in building builtin declaration of 1592 /// objc_msgSendSuper and objc_msgSendSuper_stret. If no such 1593 /// pre-existing declaration exists no action takes place. 1594 static void LookupPredefedObjCSuperType(Sema &ThisSema, Scope *S, 1595 IdentifierInfo *II) { 1596 if (!II->isStr("objc_msgSendSuper")) 1597 return; 1598 ASTContext &Context = ThisSema.Context; 1599 1600 LookupResult Result(ThisSema, &Context.Idents.get("objc_super"), 1601 SourceLocation(), Sema::LookupTagName); 1602 ThisSema.LookupName(Result, S); 1603 if (Result.getResultKind() == LookupResult::Found) 1604 if (const TagDecl *TD = Result.getAsSingle<TagDecl>()) 1605 Context.setObjCSuperType(Context.getTagDeclType(TD)); 1606 } 1607 1608 static StringRef getHeaderName(ASTContext::GetBuiltinTypeError Error) { 1609 switch (Error) { 1610 case ASTContext::GE_None: 1611 return ""; 1612 case ASTContext::GE_Missing_stdio: 1613 return "stdio.h"; 1614 case ASTContext::GE_Missing_setjmp: 1615 return "setjmp.h"; 1616 case ASTContext::GE_Missing_ucontext: 1617 return "ucontext.h"; 1618 } 1619 llvm_unreachable("unhandled error kind"); 1620 } 1621 1622 /// LazilyCreateBuiltin - The specified Builtin-ID was first used at 1623 /// file scope. lazily create a decl for it. ForRedeclaration is true 1624 /// if we're creating this built-in in anticipation of redeclaring the 1625 /// built-in. 1626 NamedDecl *Sema::LazilyCreateBuiltin(IdentifierInfo *II, unsigned bid, 1627 Scope *S, bool ForRedeclaration, 1628 SourceLocation Loc) { 1629 LookupPredefedObjCSuperType(*this, S, II); 1630 1631 Builtin::ID BID = (Builtin::ID)bid; 1632 1633 ASTContext::GetBuiltinTypeError Error; 1634 QualType R = Context.GetBuiltinType(BID, Error); 1635 if (Error) { 1636 if (ForRedeclaration) 1637 Diag(Loc, diag::warn_implicit_decl_requires_sysheader) 1638 << getHeaderName(Error) 1639 << Context.BuiltinInfo.GetName(BID); 1640 return nullptr; 1641 } 1642 1643 if (!ForRedeclaration && Context.BuiltinInfo.isPredefinedLibFunction(BID)) { 1644 Diag(Loc, diag::ext_implicit_lib_function_decl) 1645 << Context.BuiltinInfo.GetName(BID) 1646 << R; 1647 if (Context.BuiltinInfo.getHeaderName(BID) && 1648 !Diags.isIgnored(diag::ext_implicit_lib_function_decl, Loc)) 1649 Diag(Loc, diag::note_include_header_or_declare) 1650 << Context.BuiltinInfo.getHeaderName(BID) 1651 << Context.BuiltinInfo.GetName(BID); 1652 } 1653 1654 DeclContext *Parent = Context.getTranslationUnitDecl(); 1655 if (getLangOpts().CPlusPlus) { 1656 LinkageSpecDecl *CLinkageDecl = 1657 LinkageSpecDecl::Create(Context, Parent, Loc, Loc, 1658 LinkageSpecDecl::lang_c, false); 1659 CLinkageDecl->setImplicit(); 1660 Parent->addDecl(CLinkageDecl); 1661 Parent = CLinkageDecl; 1662 } 1663 1664 FunctionDecl *New = FunctionDecl::Create(Context, 1665 Parent, 1666 Loc, Loc, II, R, /*TInfo=*/nullptr, 1667 SC_Extern, 1668 false, 1669 /*hasPrototype=*/true); 1670 New->setImplicit(); 1671 1672 // Create Decl objects for each parameter, adding them to the 1673 // FunctionDecl. 1674 if (const FunctionProtoType *FT = dyn_cast<FunctionProtoType>(R)) { 1675 SmallVector<ParmVarDecl*, 16> Params; 1676 for (unsigned i = 0, e = FT->getNumParams(); i != e; ++i) { 1677 ParmVarDecl *parm = 1678 ParmVarDecl::Create(Context, New, SourceLocation(), SourceLocation(), 1679 nullptr, FT->getParamType(i), /*TInfo=*/nullptr, 1680 SC_None, nullptr); 1681 parm->setScopeInfo(0, i); 1682 Params.push_back(parm); 1683 } 1684 New->setParams(Params); 1685 } 1686 1687 AddKnownFunctionAttributes(New); 1688 RegisterLocallyScopedExternCDecl(New, S); 1689 1690 // TUScope is the translation-unit scope to insert this function into. 1691 // FIXME: This is hideous. We need to teach PushOnScopeChains to 1692 // relate Scopes to DeclContexts, and probably eliminate CurContext 1693 // entirely, but we're not there yet. 1694 DeclContext *SavedContext = CurContext; 1695 CurContext = Parent; 1696 PushOnScopeChains(New, TUScope); 1697 CurContext = SavedContext; 1698 return New; 1699 } 1700 1701 /// \brief Filter out any previous declarations that the given declaration 1702 /// should not consider because they are not permitted to conflict, e.g., 1703 /// because they come from hidden sub-modules and do not refer to the same 1704 /// entity. 1705 static void filterNonConflictingPreviousDecls(ASTContext &context, 1706 NamedDecl *decl, 1707 LookupResult &previous){ 1708 // This is only interesting when modules are enabled. 1709 if (!context.getLangOpts().Modules) 1710 return; 1711 1712 // Empty sets are uninteresting. 1713 if (previous.empty()) 1714 return; 1715 1716 LookupResult::Filter filter = previous.makeFilter(); 1717 while (filter.hasNext()) { 1718 NamedDecl *old = filter.next(); 1719 1720 // Non-hidden declarations are never ignored. 1721 if (!old->isHidden()) 1722 continue; 1723 1724 if (!old->isExternallyVisible()) 1725 filter.erase(); 1726 } 1727 1728 filter.done(); 1729 } 1730 1731 /// Typedef declarations don't have linkage, but they still denote the same 1732 /// entity if their types are the same. 1733 /// FIXME: This is notionally doing the same thing as ASTReaderDecl's 1734 /// isSameEntity. 1735 static void filterNonConflictingPreviousTypedefDecls(ASTContext &Context, 1736 TypedefNameDecl *Decl, 1737 LookupResult &Previous) { 1738 // This is only interesting when modules are enabled. 1739 if (!Context.getLangOpts().Modules) 1740 return; 1741 1742 // Empty sets are uninteresting. 1743 if (Previous.empty()) 1744 return; 1745 1746 LookupResult::Filter Filter = Previous.makeFilter(); 1747 while (Filter.hasNext()) { 1748 NamedDecl *Old = Filter.next(); 1749 1750 // Non-hidden declarations are never ignored. 1751 if (!Old->isHidden()) 1752 continue; 1753 1754 // Declarations of the same entity are not ignored, even if they have 1755 // different linkages. 1756 if (auto *OldTD = dyn_cast<TypedefNameDecl>(Old)) 1757 if (Context.hasSameType(OldTD->getUnderlyingType(), 1758 Decl->getUnderlyingType())) 1759 continue; 1760 1761 if (!Old->isExternallyVisible()) 1762 Filter.erase(); 1763 } 1764 1765 Filter.done(); 1766 } 1767 1768 bool Sema::isIncompatibleTypedef(TypeDecl *Old, TypedefNameDecl *New) { 1769 QualType OldType; 1770 if (TypedefNameDecl *OldTypedef = dyn_cast<TypedefNameDecl>(Old)) 1771 OldType = OldTypedef->getUnderlyingType(); 1772 else 1773 OldType = Context.getTypeDeclType(Old); 1774 QualType NewType = New->getUnderlyingType(); 1775 1776 if (NewType->isVariablyModifiedType()) { 1777 // Must not redefine a typedef with a variably-modified type. 1778 int Kind = isa<TypeAliasDecl>(Old) ? 1 : 0; 1779 Diag(New->getLocation(), diag::err_redefinition_variably_modified_typedef) 1780 << Kind << NewType; 1781 if (Old->getLocation().isValid()) 1782 Diag(Old->getLocation(), diag::note_previous_definition); 1783 New->setInvalidDecl(); 1784 return true; 1785 } 1786 1787 if (OldType != NewType && 1788 !OldType->isDependentType() && 1789 !NewType->isDependentType() && 1790 !Context.hasSameType(OldType, NewType)) { 1791 int Kind = isa<TypeAliasDecl>(Old) ? 1 : 0; 1792 Diag(New->getLocation(), diag::err_redefinition_different_typedef) 1793 << Kind << NewType << OldType; 1794 if (Old->getLocation().isValid()) 1795 Diag(Old->getLocation(), diag::note_previous_definition); 1796 New->setInvalidDecl(); 1797 return true; 1798 } 1799 return false; 1800 } 1801 1802 /// MergeTypedefNameDecl - We just parsed a typedef 'New' which has the 1803 /// same name and scope as a previous declaration 'Old'. Figure out 1804 /// how to resolve this situation, merging decls or emitting 1805 /// diagnostics as appropriate. If there was an error, set New to be invalid. 1806 /// 1807 void Sema::MergeTypedefNameDecl(TypedefNameDecl *New, LookupResult &OldDecls) { 1808 // If the new decl is known invalid already, don't bother doing any 1809 // merging checks. 1810 if (New->isInvalidDecl()) return; 1811 1812 // Allow multiple definitions for ObjC built-in typedefs. 1813 // FIXME: Verify the underlying types are equivalent! 1814 if (getLangOpts().ObjC1) { 1815 const IdentifierInfo *TypeID = New->getIdentifier(); 1816 switch (TypeID->getLength()) { 1817 default: break; 1818 case 2: 1819 { 1820 if (!TypeID->isStr("id")) 1821 break; 1822 QualType T = New->getUnderlyingType(); 1823 if (!T->isPointerType()) 1824 break; 1825 if (!T->isVoidPointerType()) { 1826 QualType PT = T->getAs<PointerType>()->getPointeeType(); 1827 if (!PT->isStructureType()) 1828 break; 1829 } 1830 Context.setObjCIdRedefinitionType(T); 1831 // Install the built-in type for 'id', ignoring the current definition. 1832 New->setTypeForDecl(Context.getObjCIdType().getTypePtr()); 1833 return; 1834 } 1835 case 5: 1836 if (!TypeID->isStr("Class")) 1837 break; 1838 Context.setObjCClassRedefinitionType(New->getUnderlyingType()); 1839 // Install the built-in type for 'Class', ignoring the current definition. 1840 New->setTypeForDecl(Context.getObjCClassType().getTypePtr()); 1841 return; 1842 case 3: 1843 if (!TypeID->isStr("SEL")) 1844 break; 1845 Context.setObjCSelRedefinitionType(New->getUnderlyingType()); 1846 // Install the built-in type for 'SEL', ignoring the current definition. 1847 New->setTypeForDecl(Context.getObjCSelType().getTypePtr()); 1848 return; 1849 } 1850 // Fall through - the typedef name was not a builtin type. 1851 } 1852 1853 // Verify the old decl was also a type. 1854 TypeDecl *Old = OldDecls.getAsSingle<TypeDecl>(); 1855 if (!Old) { 1856 Diag(New->getLocation(), diag::err_redefinition_different_kind) 1857 << New->getDeclName(); 1858 1859 NamedDecl *OldD = OldDecls.getRepresentativeDecl(); 1860 if (OldD->getLocation().isValid()) 1861 Diag(OldD->getLocation(), diag::note_previous_definition); 1862 1863 return New->setInvalidDecl(); 1864 } 1865 1866 // If the old declaration is invalid, just give up here. 1867 if (Old->isInvalidDecl()) 1868 return New->setInvalidDecl(); 1869 1870 // If the typedef types are not identical, reject them in all languages and 1871 // with any extensions enabled. 1872 if (isIncompatibleTypedef(Old, New)) 1873 return; 1874 1875 // The types match. Link up the redeclaration chain and merge attributes if 1876 // the old declaration was a typedef. 1877 if (TypedefNameDecl *Typedef = dyn_cast<TypedefNameDecl>(Old)) { 1878 New->setPreviousDecl(Typedef); 1879 mergeDeclAttributes(New, Old); 1880 } 1881 1882 if (getLangOpts().MicrosoftExt) 1883 return; 1884 1885 if (getLangOpts().CPlusPlus) { 1886 // C++ [dcl.typedef]p2: 1887 // In a given non-class scope, a typedef specifier can be used to 1888 // redefine the name of any type declared in that scope to refer 1889 // to the type to which it already refers. 1890 if (!isa<CXXRecordDecl>(CurContext)) 1891 return; 1892 1893 // C++0x [dcl.typedef]p4: 1894 // In a given class scope, a typedef specifier can be used to redefine 1895 // any class-name declared in that scope that is not also a typedef-name 1896 // to refer to the type to which it already refers. 1897 // 1898 // This wording came in via DR424, which was a correction to the 1899 // wording in DR56, which accidentally banned code like: 1900 // 1901 // struct S { 1902 // typedef struct A { } A; 1903 // }; 1904 // 1905 // in the C++03 standard. We implement the C++0x semantics, which 1906 // allow the above but disallow 1907 // 1908 // struct S { 1909 // typedef int I; 1910 // typedef int I; 1911 // }; 1912 // 1913 // since that was the intent of DR56. 1914 if (!isa<TypedefNameDecl>(Old)) 1915 return; 1916 1917 Diag(New->getLocation(), diag::err_redefinition) 1918 << New->getDeclName(); 1919 Diag(Old->getLocation(), diag::note_previous_definition); 1920 return New->setInvalidDecl(); 1921 } 1922 1923 // Modules always permit redefinition of typedefs, as does C11. 1924 if (getLangOpts().Modules || getLangOpts().C11) 1925 return; 1926 1927 // If we have a redefinition of a typedef in C, emit a warning. This warning 1928 // is normally mapped to an error, but can be controlled with 1929 // -Wtypedef-redefinition. If either the original or the redefinition is 1930 // in a system header, don't emit this for compatibility with GCC. 1931 if (getDiagnostics().getSuppressSystemWarnings() && 1932 (Context.getSourceManager().isInSystemHeader(Old->getLocation()) || 1933 Context.getSourceManager().isInSystemHeader(New->getLocation()))) 1934 return; 1935 1936 Diag(New->getLocation(), diag::ext_redefinition_of_typedef) 1937 << New->getDeclName(); 1938 Diag(Old->getLocation(), diag::note_previous_definition); 1939 return; 1940 } 1941 1942 /// DeclhasAttr - returns true if decl Declaration already has the target 1943 /// attribute. 1944 static bool DeclHasAttr(const Decl *D, const Attr *A) { 1945 const OwnershipAttr *OA = dyn_cast<OwnershipAttr>(A); 1946 const AnnotateAttr *Ann = dyn_cast<AnnotateAttr>(A); 1947 for (const auto *i : D->attrs()) 1948 if (i->getKind() == A->getKind()) { 1949 if (Ann) { 1950 if (Ann->getAnnotation() == cast<AnnotateAttr>(i)->getAnnotation()) 1951 return true; 1952 continue; 1953 } 1954 // FIXME: Don't hardcode this check 1955 if (OA && isa<OwnershipAttr>(i)) 1956 return OA->getOwnKind() == cast<OwnershipAttr>(i)->getOwnKind(); 1957 return true; 1958 } 1959 1960 return false; 1961 } 1962 1963 static bool isAttributeTargetADefinition(Decl *D) { 1964 if (VarDecl *VD = dyn_cast<VarDecl>(D)) 1965 return VD->isThisDeclarationADefinition(); 1966 if (TagDecl *TD = dyn_cast<TagDecl>(D)) 1967 return TD->isCompleteDefinition() || TD->isBeingDefined(); 1968 return true; 1969 } 1970 1971 /// Merge alignment attributes from \p Old to \p New, taking into account the 1972 /// special semantics of C11's _Alignas specifier and C++11's alignas attribute. 1973 /// 1974 /// \return \c true if any attributes were added to \p New. 1975 static bool mergeAlignedAttrs(Sema &S, NamedDecl *New, Decl *Old) { 1976 // Look for alignas attributes on Old, and pick out whichever attribute 1977 // specifies the strictest alignment requirement. 1978 AlignedAttr *OldAlignasAttr = nullptr; 1979 AlignedAttr *OldStrictestAlignAttr = nullptr; 1980 unsigned OldAlign = 0; 1981 for (auto *I : Old->specific_attrs<AlignedAttr>()) { 1982 // FIXME: We have no way of representing inherited dependent alignments 1983 // in a case like: 1984 // template<int A, int B> struct alignas(A) X; 1985 // template<int A, int B> struct alignas(B) X {}; 1986 // For now, we just ignore any alignas attributes which are not on the 1987 // definition in such a case. 1988 if (I->isAlignmentDependent()) 1989 return false; 1990 1991 if (I->isAlignas()) 1992 OldAlignasAttr = I; 1993 1994 unsigned Align = I->getAlignment(S.Context); 1995 if (Align > OldAlign) { 1996 OldAlign = Align; 1997 OldStrictestAlignAttr = I; 1998 } 1999 } 2000 2001 // Look for alignas attributes on New. 2002 AlignedAttr *NewAlignasAttr = nullptr; 2003 unsigned NewAlign = 0; 2004 for (auto *I : New->specific_attrs<AlignedAttr>()) { 2005 if (I->isAlignmentDependent()) 2006 return false; 2007 2008 if (I->isAlignas()) 2009 NewAlignasAttr = I; 2010 2011 unsigned Align = I->getAlignment(S.Context); 2012 if (Align > NewAlign) 2013 NewAlign = Align; 2014 } 2015 2016 if (OldAlignasAttr && NewAlignasAttr && OldAlign != NewAlign) { 2017 // Both declarations have 'alignas' attributes. We require them to match. 2018 // C++11 [dcl.align]p6 and C11 6.7.5/7 both come close to saying this, but 2019 // fall short. (If two declarations both have alignas, they must both match 2020 // every definition, and so must match each other if there is a definition.) 2021 2022 // If either declaration only contains 'alignas(0)' specifiers, then it 2023 // specifies the natural alignment for the type. 2024 if (OldAlign == 0 || NewAlign == 0) { 2025 QualType Ty; 2026 if (ValueDecl *VD = dyn_cast<ValueDecl>(New)) 2027 Ty = VD->getType(); 2028 else 2029 Ty = S.Context.getTagDeclType(cast<TagDecl>(New)); 2030 2031 if (OldAlign == 0) 2032 OldAlign = S.Context.getTypeAlign(Ty); 2033 if (NewAlign == 0) 2034 NewAlign = S.Context.getTypeAlign(Ty); 2035 } 2036 2037 if (OldAlign != NewAlign) { 2038 S.Diag(NewAlignasAttr->getLocation(), diag::err_alignas_mismatch) 2039 << (unsigned)S.Context.toCharUnitsFromBits(OldAlign).getQuantity() 2040 << (unsigned)S.Context.toCharUnitsFromBits(NewAlign).getQuantity(); 2041 S.Diag(OldAlignasAttr->getLocation(), diag::note_previous_declaration); 2042 } 2043 } 2044 2045 if (OldAlignasAttr && !NewAlignasAttr && isAttributeTargetADefinition(New)) { 2046 // C++11 [dcl.align]p6: 2047 // if any declaration of an entity has an alignment-specifier, 2048 // every defining declaration of that entity shall specify an 2049 // equivalent alignment. 2050 // C11 6.7.5/7: 2051 // If the definition of an object does not have an alignment 2052 // specifier, any other declaration of that object shall also 2053 // have no alignment specifier. 2054 S.Diag(New->getLocation(), diag::err_alignas_missing_on_definition) 2055 << OldAlignasAttr; 2056 S.Diag(OldAlignasAttr->getLocation(), diag::note_alignas_on_declaration) 2057 << OldAlignasAttr; 2058 } 2059 2060 bool AnyAdded = false; 2061 2062 // Ensure we have an attribute representing the strictest alignment. 2063 if (OldAlign > NewAlign) { 2064 AlignedAttr *Clone = OldStrictestAlignAttr->clone(S.Context); 2065 Clone->setInherited(true); 2066 New->addAttr(Clone); 2067 AnyAdded = true; 2068 } 2069 2070 // Ensure we have an alignas attribute if the old declaration had one. 2071 if (OldAlignasAttr && !NewAlignasAttr && 2072 !(AnyAdded && OldStrictestAlignAttr->isAlignas())) { 2073 AlignedAttr *Clone = OldAlignasAttr->clone(S.Context); 2074 Clone->setInherited(true); 2075 New->addAttr(Clone); 2076 AnyAdded = true; 2077 } 2078 2079 return AnyAdded; 2080 } 2081 2082 static bool mergeDeclAttribute(Sema &S, NamedDecl *D, 2083 const InheritableAttr *Attr, bool Override) { 2084 InheritableAttr *NewAttr = nullptr; 2085 unsigned AttrSpellingListIndex = Attr->getSpellingListIndex(); 2086 if (const auto *AA = dyn_cast<AvailabilityAttr>(Attr)) 2087 NewAttr = S.mergeAvailabilityAttr(D, AA->getRange(), AA->getPlatform(), 2088 AA->getIntroduced(), AA->getDeprecated(), 2089 AA->getObsoleted(), AA->getUnavailable(), 2090 AA->getMessage(), Override, 2091 AttrSpellingListIndex); 2092 else if (const auto *VA = dyn_cast<VisibilityAttr>(Attr)) 2093 NewAttr = S.mergeVisibilityAttr(D, VA->getRange(), VA->getVisibility(), 2094 AttrSpellingListIndex); 2095 else if (const auto *VA = dyn_cast<TypeVisibilityAttr>(Attr)) 2096 NewAttr = S.mergeTypeVisibilityAttr(D, VA->getRange(), VA->getVisibility(), 2097 AttrSpellingListIndex); 2098 else if (const auto *ImportA = dyn_cast<DLLImportAttr>(Attr)) 2099 NewAttr = S.mergeDLLImportAttr(D, ImportA->getRange(), 2100 AttrSpellingListIndex); 2101 else if (const auto *ExportA = dyn_cast<DLLExportAttr>(Attr)) 2102 NewAttr = S.mergeDLLExportAttr(D, ExportA->getRange(), 2103 AttrSpellingListIndex); 2104 else if (const auto *FA = dyn_cast<FormatAttr>(Attr)) 2105 NewAttr = S.mergeFormatAttr(D, FA->getRange(), FA->getType(), 2106 FA->getFormatIdx(), FA->getFirstArg(), 2107 AttrSpellingListIndex); 2108 else if (const auto *SA = dyn_cast<SectionAttr>(Attr)) 2109 NewAttr = S.mergeSectionAttr(D, SA->getRange(), SA->getName(), 2110 AttrSpellingListIndex); 2111 else if (const auto *IA = dyn_cast<MSInheritanceAttr>(Attr)) 2112 NewAttr = S.mergeMSInheritanceAttr(D, IA->getRange(), IA->getBestCase(), 2113 AttrSpellingListIndex, 2114 IA->getSemanticSpelling()); 2115 else if (isa<AlignedAttr>(Attr)) 2116 // AlignedAttrs are handled separately, because we need to handle all 2117 // such attributes on a declaration at the same time. 2118 NewAttr = nullptr; 2119 else if (isa<DeprecatedAttr>(Attr) && Override) 2120 NewAttr = nullptr; 2121 else if (Attr->duplicatesAllowed() || !DeclHasAttr(D, Attr)) 2122 NewAttr = cast<InheritableAttr>(Attr->clone(S.Context)); 2123 2124 if (NewAttr) { 2125 NewAttr->setInherited(true); 2126 D->addAttr(NewAttr); 2127 return true; 2128 } 2129 2130 return false; 2131 } 2132 2133 static const Decl *getDefinition(const Decl *D) { 2134 if (const TagDecl *TD = dyn_cast<TagDecl>(D)) 2135 return TD->getDefinition(); 2136 if (const VarDecl *VD = dyn_cast<VarDecl>(D)) { 2137 const VarDecl *Def = VD->getDefinition(); 2138 if (Def) 2139 return Def; 2140 return VD->getActingDefinition(); 2141 } 2142 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) { 2143 const FunctionDecl* Def; 2144 if (FD->isDefined(Def)) 2145 return Def; 2146 } 2147 return nullptr; 2148 } 2149 2150 static bool hasAttribute(const Decl *D, attr::Kind Kind) { 2151 for (const auto *Attribute : D->attrs()) 2152 if (Attribute->getKind() == Kind) 2153 return true; 2154 return false; 2155 } 2156 2157 /// checkNewAttributesAfterDef - If we already have a definition, check that 2158 /// there are no new attributes in this declaration. 2159 static void checkNewAttributesAfterDef(Sema &S, Decl *New, const Decl *Old) { 2160 if (!New->hasAttrs()) 2161 return; 2162 2163 const Decl *Def = getDefinition(Old); 2164 if (!Def || Def == New) 2165 return; 2166 2167 AttrVec &NewAttributes = New->getAttrs(); 2168 for (unsigned I = 0, E = NewAttributes.size(); I != E;) { 2169 const Attr *NewAttribute = NewAttributes[I]; 2170 2171 if (isa<AliasAttr>(NewAttribute)) { 2172 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(New)) 2173 S.CheckForFunctionRedefinition(FD, cast<FunctionDecl>(Def)); 2174 else { 2175 VarDecl *VD = cast<VarDecl>(New); 2176 unsigned Diag = cast<VarDecl>(Def)->isThisDeclarationADefinition() == 2177 VarDecl::TentativeDefinition 2178 ? diag::err_alias_after_tentative 2179 : diag::err_redefinition; 2180 S.Diag(VD->getLocation(), Diag) << VD->getDeclName(); 2181 S.Diag(Def->getLocation(), diag::note_previous_definition); 2182 VD->setInvalidDecl(); 2183 } 2184 ++I; 2185 continue; 2186 } 2187 2188 if (const VarDecl *VD = dyn_cast<VarDecl>(Def)) { 2189 // Tentative definitions are only interesting for the alias check above. 2190 if (VD->isThisDeclarationADefinition() != VarDecl::Definition) { 2191 ++I; 2192 continue; 2193 } 2194 } 2195 2196 if (hasAttribute(Def, NewAttribute->getKind())) { 2197 ++I; 2198 continue; // regular attr merging will take care of validating this. 2199 } 2200 2201 if (isa<C11NoReturnAttr>(NewAttribute)) { 2202 // C's _Noreturn is allowed to be added to a function after it is defined. 2203 ++I; 2204 continue; 2205 } else if (const AlignedAttr *AA = dyn_cast<AlignedAttr>(NewAttribute)) { 2206 if (AA->isAlignas()) { 2207 // C++11 [dcl.align]p6: 2208 // if any declaration of an entity has an alignment-specifier, 2209 // every defining declaration of that entity shall specify an 2210 // equivalent alignment. 2211 // C11 6.7.5/7: 2212 // If the definition of an object does not have an alignment 2213 // specifier, any other declaration of that object shall also 2214 // have no alignment specifier. 2215 S.Diag(Def->getLocation(), diag::err_alignas_missing_on_definition) 2216 << AA; 2217 S.Diag(NewAttribute->getLocation(), diag::note_alignas_on_declaration) 2218 << AA; 2219 NewAttributes.erase(NewAttributes.begin() + I); 2220 --E; 2221 continue; 2222 } 2223 } 2224 2225 S.Diag(NewAttribute->getLocation(), 2226 diag::warn_attribute_precede_definition); 2227 S.Diag(Def->getLocation(), diag::note_previous_definition); 2228 NewAttributes.erase(NewAttributes.begin() + I); 2229 --E; 2230 } 2231 } 2232 2233 /// mergeDeclAttributes - Copy attributes from the Old decl to the New one. 2234 void Sema::mergeDeclAttributes(NamedDecl *New, Decl *Old, 2235 AvailabilityMergeKind AMK) { 2236 if (UsedAttr *OldAttr = Old->getMostRecentDecl()->getAttr<UsedAttr>()) { 2237 UsedAttr *NewAttr = OldAttr->clone(Context); 2238 NewAttr->setInherited(true); 2239 New->addAttr(NewAttr); 2240 } 2241 2242 if (!Old->hasAttrs() && !New->hasAttrs()) 2243 return; 2244 2245 // attributes declared post-definition are currently ignored 2246 checkNewAttributesAfterDef(*this, New, Old); 2247 2248 if (!Old->hasAttrs()) 2249 return; 2250 2251 bool foundAny = New->hasAttrs(); 2252 2253 // Ensure that any moving of objects within the allocated map is done before 2254 // we process them. 2255 if (!foundAny) New->setAttrs(AttrVec()); 2256 2257 for (auto *I : Old->specific_attrs<InheritableAttr>()) { 2258 bool Override = false; 2259 // Ignore deprecated/unavailable/availability attributes if requested. 2260 if (isa<DeprecatedAttr>(I) || 2261 isa<UnavailableAttr>(I) || 2262 isa<AvailabilityAttr>(I)) { 2263 switch (AMK) { 2264 case AMK_None: 2265 continue; 2266 2267 case AMK_Redeclaration: 2268 break; 2269 2270 case AMK_Override: 2271 Override = true; 2272 break; 2273 } 2274 } 2275 2276 // Already handled. 2277 if (isa<UsedAttr>(I)) 2278 continue; 2279 2280 if (mergeDeclAttribute(*this, New, I, Override)) 2281 foundAny = true; 2282 } 2283 2284 if (mergeAlignedAttrs(*this, New, Old)) 2285 foundAny = true; 2286 2287 if (!foundAny) New->dropAttrs(); 2288 } 2289 2290 /// mergeParamDeclAttributes - Copy attributes from the old parameter 2291 /// to the new one. 2292 static void mergeParamDeclAttributes(ParmVarDecl *newDecl, 2293 const ParmVarDecl *oldDecl, 2294 Sema &S) { 2295 // C++11 [dcl.attr.depend]p2: 2296 // The first declaration of a function shall specify the 2297 // carries_dependency attribute for its declarator-id if any declaration 2298 // of the function specifies the carries_dependency attribute. 2299 const CarriesDependencyAttr *CDA = newDecl->getAttr<CarriesDependencyAttr>(); 2300 if (CDA && !oldDecl->hasAttr<CarriesDependencyAttr>()) { 2301 S.Diag(CDA->getLocation(), 2302 diag::err_carries_dependency_missing_on_first_decl) << 1/*Param*/; 2303 // Find the first declaration of the parameter. 2304 // FIXME: Should we build redeclaration chains for function parameters? 2305 const FunctionDecl *FirstFD = 2306 cast<FunctionDecl>(oldDecl->getDeclContext())->getFirstDecl(); 2307 const ParmVarDecl *FirstVD = 2308 FirstFD->getParamDecl(oldDecl->getFunctionScopeIndex()); 2309 S.Diag(FirstVD->getLocation(), 2310 diag::note_carries_dependency_missing_first_decl) << 1/*Param*/; 2311 } 2312 2313 if (!oldDecl->hasAttrs()) 2314 return; 2315 2316 bool foundAny = newDecl->hasAttrs(); 2317 2318 // Ensure that any moving of objects within the allocated map is 2319 // done before we process them. 2320 if (!foundAny) newDecl->setAttrs(AttrVec()); 2321 2322 for (const auto *I : oldDecl->specific_attrs<InheritableParamAttr>()) { 2323 if (!DeclHasAttr(newDecl, I)) { 2324 InheritableAttr *newAttr = 2325 cast<InheritableParamAttr>(I->clone(S.Context)); 2326 newAttr->setInherited(true); 2327 newDecl->addAttr(newAttr); 2328 foundAny = true; 2329 } 2330 } 2331 2332 if (!foundAny) newDecl->dropAttrs(); 2333 } 2334 2335 namespace { 2336 2337 /// Used in MergeFunctionDecl to keep track of function parameters in 2338 /// C. 2339 struct GNUCompatibleParamWarning { 2340 ParmVarDecl *OldParm; 2341 ParmVarDecl *NewParm; 2342 QualType PromotedType; 2343 }; 2344 2345 } 2346 2347 /// getSpecialMember - get the special member enum for a method. 2348 Sema::CXXSpecialMember Sema::getSpecialMember(const CXXMethodDecl *MD) { 2349 if (const CXXConstructorDecl *Ctor = dyn_cast<CXXConstructorDecl>(MD)) { 2350 if (Ctor->isDefaultConstructor()) 2351 return Sema::CXXDefaultConstructor; 2352 2353 if (Ctor->isCopyConstructor()) 2354 return Sema::CXXCopyConstructor; 2355 2356 if (Ctor->isMoveConstructor()) 2357 return Sema::CXXMoveConstructor; 2358 } else if (isa<CXXDestructorDecl>(MD)) { 2359 return Sema::CXXDestructor; 2360 } else if (MD->isCopyAssignmentOperator()) { 2361 return Sema::CXXCopyAssignment; 2362 } else if (MD->isMoveAssignmentOperator()) { 2363 return Sema::CXXMoveAssignment; 2364 } 2365 2366 return Sema::CXXInvalid; 2367 } 2368 2369 // Determine whether the previous declaration was a definition, implicit 2370 // declaration, or a declaration. 2371 template <typename T> 2372 static std::pair<diag::kind, SourceLocation> 2373 getNoteDiagForInvalidRedeclaration(const T *Old, const T *New) { 2374 diag::kind PrevDiag; 2375 SourceLocation OldLocation = Old->getLocation(); 2376 if (Old->isThisDeclarationADefinition()) 2377 PrevDiag = diag::note_previous_definition; 2378 else if (Old->isImplicit()) { 2379 PrevDiag = diag::note_previous_implicit_declaration; 2380 if (OldLocation.isInvalid()) 2381 OldLocation = New->getLocation(); 2382 } else 2383 PrevDiag = diag::note_previous_declaration; 2384 return std::make_pair(PrevDiag, OldLocation); 2385 } 2386 2387 /// canRedefineFunction - checks if a function can be redefined. Currently, 2388 /// only extern inline functions can be redefined, and even then only in 2389 /// GNU89 mode. 2390 static bool canRedefineFunction(const FunctionDecl *FD, 2391 const LangOptions& LangOpts) { 2392 return ((FD->hasAttr<GNUInlineAttr>() || LangOpts.GNUInline) && 2393 !LangOpts.CPlusPlus && 2394 FD->isInlineSpecified() && 2395 FD->getStorageClass() == SC_Extern); 2396 } 2397 2398 const AttributedType *Sema::getCallingConvAttributedType(QualType T) const { 2399 const AttributedType *AT = T->getAs<AttributedType>(); 2400 while (AT && !AT->isCallingConv()) 2401 AT = AT->getModifiedType()->getAs<AttributedType>(); 2402 return AT; 2403 } 2404 2405 template <typename T> 2406 static bool haveIncompatibleLanguageLinkages(const T *Old, const T *New) { 2407 const DeclContext *DC = Old->getDeclContext(); 2408 if (DC->isRecord()) 2409 return false; 2410 2411 LanguageLinkage OldLinkage = Old->getLanguageLinkage(); 2412 if (OldLinkage == CXXLanguageLinkage && New->isInExternCContext()) 2413 return true; 2414 if (OldLinkage == CLanguageLinkage && New->isInExternCXXContext()) 2415 return true; 2416 return false; 2417 } 2418 2419 /// MergeFunctionDecl - We just parsed a function 'New' from 2420 /// declarator D which has the same name and scope as a previous 2421 /// declaration 'Old'. Figure out how to resolve this situation, 2422 /// merging decls or emitting diagnostics as appropriate. 2423 /// 2424 /// In C++, New and Old must be declarations that are not 2425 /// overloaded. Use IsOverload to determine whether New and Old are 2426 /// overloaded, and to select the Old declaration that New should be 2427 /// merged with. 2428 /// 2429 /// Returns true if there was an error, false otherwise. 2430 bool Sema::MergeFunctionDecl(FunctionDecl *New, NamedDecl *&OldD, 2431 Scope *S, bool MergeTypeWithOld) { 2432 // Verify the old decl was also a function. 2433 FunctionDecl *Old = OldD->getAsFunction(); 2434 if (!Old) { 2435 if (UsingShadowDecl *Shadow = dyn_cast<UsingShadowDecl>(OldD)) { 2436 if (New->getFriendObjectKind()) { 2437 Diag(New->getLocation(), diag::err_using_decl_friend); 2438 Diag(Shadow->getTargetDecl()->getLocation(), 2439 diag::note_using_decl_target); 2440 Diag(Shadow->getUsingDecl()->getLocation(), 2441 diag::note_using_decl) << 0; 2442 return true; 2443 } 2444 2445 // C++11 [namespace.udecl]p14: 2446 // If a function declaration in namespace scope or block scope has the 2447 // same name and the same parameter-type-list as a function introduced 2448 // by a using-declaration, and the declarations do not declare the same 2449 // function, the program is ill-formed. 2450 2451 // Check whether the two declarations might declare the same function. 2452 Old = dyn_cast<FunctionDecl>(Shadow->getTargetDecl()); 2453 if (Old && 2454 !Old->getDeclContext()->getRedeclContext()->Equals( 2455 New->getDeclContext()->getRedeclContext()) && 2456 !(Old->isExternC() && New->isExternC())) 2457 Old = nullptr; 2458 2459 if (!Old) { 2460 Diag(New->getLocation(), diag::err_using_decl_conflict_reverse); 2461 Diag(Shadow->getTargetDecl()->getLocation(), 2462 diag::note_using_decl_target); 2463 Diag(Shadow->getUsingDecl()->getLocation(), diag::note_using_decl) << 0; 2464 return true; 2465 } 2466 OldD = Old; 2467 } else { 2468 Diag(New->getLocation(), diag::err_redefinition_different_kind) 2469 << New->getDeclName(); 2470 Diag(OldD->getLocation(), diag::note_previous_definition); 2471 return true; 2472 } 2473 } 2474 2475 // If the old declaration is invalid, just give up here. 2476 if (Old->isInvalidDecl()) 2477 return true; 2478 2479 diag::kind PrevDiag; 2480 SourceLocation OldLocation; 2481 std::tie(PrevDiag, OldLocation) = 2482 getNoteDiagForInvalidRedeclaration(Old, New); 2483 2484 // Don't complain about this if we're in GNU89 mode and the old function 2485 // is an extern inline function. 2486 // Don't complain about specializations. They are not supposed to have 2487 // storage classes. 2488 if (!isa<CXXMethodDecl>(New) && !isa<CXXMethodDecl>(Old) && 2489 New->getStorageClass() == SC_Static && 2490 Old->hasExternalFormalLinkage() && 2491 !New->getTemplateSpecializationInfo() && 2492 !canRedefineFunction(Old, getLangOpts())) { 2493 if (getLangOpts().MicrosoftExt) { 2494 Diag(New->getLocation(), diag::ext_static_non_static) << New; 2495 Diag(OldLocation, PrevDiag); 2496 } else { 2497 Diag(New->getLocation(), diag::err_static_non_static) << New; 2498 Diag(OldLocation, PrevDiag); 2499 return true; 2500 } 2501 } 2502 2503 2504 // If a function is first declared with a calling convention, but is later 2505 // declared or defined without one, all following decls assume the calling 2506 // convention of the first. 2507 // 2508 // It's OK if a function is first declared without a calling convention, 2509 // but is later declared or defined with the default calling convention. 2510 // 2511 // To test if either decl has an explicit calling convention, we look for 2512 // AttributedType sugar nodes on the type as written. If they are missing or 2513 // were canonicalized away, we assume the calling convention was implicit. 2514 // 2515 // Note also that we DO NOT return at this point, because we still have 2516 // other tests to run. 2517 QualType OldQType = Context.getCanonicalType(Old->getType()); 2518 QualType NewQType = Context.getCanonicalType(New->getType()); 2519 const FunctionType *OldType = cast<FunctionType>(OldQType); 2520 const FunctionType *NewType = cast<FunctionType>(NewQType); 2521 FunctionType::ExtInfo OldTypeInfo = OldType->getExtInfo(); 2522 FunctionType::ExtInfo NewTypeInfo = NewType->getExtInfo(); 2523 bool RequiresAdjustment = false; 2524 2525 if (OldTypeInfo.getCC() != NewTypeInfo.getCC()) { 2526 FunctionDecl *First = Old->getFirstDecl(); 2527 const FunctionType *FT = 2528 First->getType().getCanonicalType()->castAs<FunctionType>(); 2529 FunctionType::ExtInfo FI = FT->getExtInfo(); 2530 bool NewCCExplicit = getCallingConvAttributedType(New->getType()); 2531 if (!NewCCExplicit) { 2532 // Inherit the CC from the previous declaration if it was specified 2533 // there but not here. 2534 NewTypeInfo = NewTypeInfo.withCallingConv(OldTypeInfo.getCC()); 2535 RequiresAdjustment = true; 2536 } else { 2537 // Calling conventions aren't compatible, so complain. 2538 bool FirstCCExplicit = getCallingConvAttributedType(First->getType()); 2539 Diag(New->getLocation(), diag::err_cconv_change) 2540 << FunctionType::getNameForCallConv(NewTypeInfo.getCC()) 2541 << !FirstCCExplicit 2542 << (!FirstCCExplicit ? "" : 2543 FunctionType::getNameForCallConv(FI.getCC())); 2544 2545 // Put the note on the first decl, since it is the one that matters. 2546 Diag(First->getLocation(), diag::note_previous_declaration); 2547 return true; 2548 } 2549 } 2550 2551 // FIXME: diagnose the other way around? 2552 if (OldTypeInfo.getNoReturn() && !NewTypeInfo.getNoReturn()) { 2553 NewTypeInfo = NewTypeInfo.withNoReturn(true); 2554 RequiresAdjustment = true; 2555 } 2556 2557 // Merge regparm attribute. 2558 if (OldTypeInfo.getHasRegParm() != NewTypeInfo.getHasRegParm() || 2559 OldTypeInfo.getRegParm() != NewTypeInfo.getRegParm()) { 2560 if (NewTypeInfo.getHasRegParm()) { 2561 Diag(New->getLocation(), diag::err_regparm_mismatch) 2562 << NewType->getRegParmType() 2563 << OldType->getRegParmType(); 2564 Diag(OldLocation, diag::note_previous_declaration); 2565 return true; 2566 } 2567 2568 NewTypeInfo = NewTypeInfo.withRegParm(OldTypeInfo.getRegParm()); 2569 RequiresAdjustment = true; 2570 } 2571 2572 // Merge ns_returns_retained attribute. 2573 if (OldTypeInfo.getProducesResult() != NewTypeInfo.getProducesResult()) { 2574 if (NewTypeInfo.getProducesResult()) { 2575 Diag(New->getLocation(), diag::err_returns_retained_mismatch); 2576 Diag(OldLocation, diag::note_previous_declaration); 2577 return true; 2578 } 2579 2580 NewTypeInfo = NewTypeInfo.withProducesResult(true); 2581 RequiresAdjustment = true; 2582 } 2583 2584 if (RequiresAdjustment) { 2585 const FunctionType *AdjustedType = New->getType()->getAs<FunctionType>(); 2586 AdjustedType = Context.adjustFunctionType(AdjustedType, NewTypeInfo); 2587 New->setType(QualType(AdjustedType, 0)); 2588 NewQType = Context.getCanonicalType(New->getType()); 2589 NewType = cast<FunctionType>(NewQType); 2590 } 2591 2592 // If this redeclaration makes the function inline, we may need to add it to 2593 // UndefinedButUsed. 2594 if (!Old->isInlined() && New->isInlined() && 2595 !New->hasAttr<GNUInlineAttr>() && 2596 (getLangOpts().CPlusPlus || !getLangOpts().GNUInline) && 2597 Old->isUsed(false) && 2598 !Old->isDefined() && !New->isThisDeclarationADefinition()) 2599 UndefinedButUsed.insert(std::make_pair(Old->getCanonicalDecl(), 2600 SourceLocation())); 2601 2602 // If this redeclaration makes it newly gnu_inline, we don't want to warn 2603 // about it. 2604 if (New->hasAttr<GNUInlineAttr>() && 2605 Old->isInlined() && !Old->hasAttr<GNUInlineAttr>()) { 2606 UndefinedButUsed.erase(Old->getCanonicalDecl()); 2607 } 2608 2609 if (getLangOpts().CPlusPlus) { 2610 // (C++98 13.1p2): 2611 // Certain function declarations cannot be overloaded: 2612 // -- Function declarations that differ only in the return type 2613 // cannot be overloaded. 2614 2615 // Go back to the type source info to compare the declared return types, 2616 // per C++1y [dcl.type.auto]p13: 2617 // Redeclarations or specializations of a function or function template 2618 // with a declared return type that uses a placeholder type shall also 2619 // use that placeholder, not a deduced type. 2620 QualType OldDeclaredReturnType = 2621 (Old->getTypeSourceInfo() 2622 ? Old->getTypeSourceInfo()->getType()->castAs<FunctionType>() 2623 : OldType)->getReturnType(); 2624 QualType NewDeclaredReturnType = 2625 (New->getTypeSourceInfo() 2626 ? New->getTypeSourceInfo()->getType()->castAs<FunctionType>() 2627 : NewType)->getReturnType(); 2628 QualType ResQT; 2629 if (!Context.hasSameType(OldDeclaredReturnType, NewDeclaredReturnType) && 2630 !((NewQType->isDependentType() || OldQType->isDependentType()) && 2631 New->isLocalExternDecl())) { 2632 if (NewDeclaredReturnType->isObjCObjectPointerType() && 2633 OldDeclaredReturnType->isObjCObjectPointerType()) 2634 ResQT = Context.mergeObjCGCQualifiers(NewQType, OldQType); 2635 if (ResQT.isNull()) { 2636 if (New->isCXXClassMember() && New->isOutOfLine()) 2637 Diag(New->getLocation(), diag::err_member_def_does_not_match_ret_type) 2638 << New << New->getReturnTypeSourceRange(); 2639 else 2640 Diag(New->getLocation(), diag::err_ovl_diff_return_type) 2641 << New->getReturnTypeSourceRange(); 2642 Diag(OldLocation, PrevDiag) << Old << Old->getType() 2643 << Old->getReturnTypeSourceRange(); 2644 return true; 2645 } 2646 else 2647 NewQType = ResQT; 2648 } 2649 2650 QualType OldReturnType = OldType->getReturnType(); 2651 QualType NewReturnType = cast<FunctionType>(NewQType)->getReturnType(); 2652 if (OldReturnType != NewReturnType) { 2653 // If this function has a deduced return type and has already been 2654 // defined, copy the deduced value from the old declaration. 2655 AutoType *OldAT = Old->getReturnType()->getContainedAutoType(); 2656 if (OldAT && OldAT->isDeduced()) { 2657 New->setType( 2658 SubstAutoType(New->getType(), 2659 OldAT->isDependentType() ? Context.DependentTy 2660 : OldAT->getDeducedType())); 2661 NewQType = Context.getCanonicalType( 2662 SubstAutoType(NewQType, 2663 OldAT->isDependentType() ? Context.DependentTy 2664 : OldAT->getDeducedType())); 2665 } 2666 } 2667 2668 const CXXMethodDecl *OldMethod = dyn_cast<CXXMethodDecl>(Old); 2669 CXXMethodDecl *NewMethod = dyn_cast<CXXMethodDecl>(New); 2670 if (OldMethod && NewMethod) { 2671 // Preserve triviality. 2672 NewMethod->setTrivial(OldMethod->isTrivial()); 2673 2674 // MSVC allows explicit template specialization at class scope: 2675 // 2 CXXMethodDecls referring to the same function will be injected. 2676 // We don't want a redeclaration error. 2677 bool IsClassScopeExplicitSpecialization = 2678 OldMethod->isFunctionTemplateSpecialization() && 2679 NewMethod->isFunctionTemplateSpecialization(); 2680 bool isFriend = NewMethod->getFriendObjectKind(); 2681 2682 if (!isFriend && NewMethod->getLexicalDeclContext()->isRecord() && 2683 !IsClassScopeExplicitSpecialization) { 2684 // -- Member function declarations with the same name and the 2685 // same parameter types cannot be overloaded if any of them 2686 // is a static member function declaration. 2687 if (OldMethod->isStatic() != NewMethod->isStatic()) { 2688 Diag(New->getLocation(), diag::err_ovl_static_nonstatic_member); 2689 Diag(OldLocation, PrevDiag) << Old << Old->getType(); 2690 return true; 2691 } 2692 2693 // C++ [class.mem]p1: 2694 // [...] A member shall not be declared twice in the 2695 // member-specification, except that a nested class or member 2696 // class template can be declared and then later defined. 2697 if (ActiveTemplateInstantiations.empty()) { 2698 unsigned NewDiag; 2699 if (isa<CXXConstructorDecl>(OldMethod)) 2700 NewDiag = diag::err_constructor_redeclared; 2701 else if (isa<CXXDestructorDecl>(NewMethod)) 2702 NewDiag = diag::err_destructor_redeclared; 2703 else if (isa<CXXConversionDecl>(NewMethod)) 2704 NewDiag = diag::err_conv_function_redeclared; 2705 else 2706 NewDiag = diag::err_member_redeclared; 2707 2708 Diag(New->getLocation(), NewDiag); 2709 } else { 2710 Diag(New->getLocation(), diag::err_member_redeclared_in_instantiation) 2711 << New << New->getType(); 2712 } 2713 Diag(OldLocation, PrevDiag) << Old << Old->getType(); 2714 2715 // Complain if this is an explicit declaration of a special 2716 // member that was initially declared implicitly. 2717 // 2718 // As an exception, it's okay to befriend such methods in order 2719 // to permit the implicit constructor/destructor/operator calls. 2720 } else if (OldMethod->isImplicit()) { 2721 if (isFriend) { 2722 NewMethod->setImplicit(); 2723 } else { 2724 Diag(NewMethod->getLocation(), 2725 diag::err_definition_of_implicitly_declared_member) 2726 << New << getSpecialMember(OldMethod); 2727 return true; 2728 } 2729 } else if (OldMethod->isExplicitlyDefaulted() && !isFriend) { 2730 Diag(NewMethod->getLocation(), 2731 diag::err_definition_of_explicitly_defaulted_member) 2732 << getSpecialMember(OldMethod); 2733 return true; 2734 } 2735 } 2736 2737 // C++11 [dcl.attr.noreturn]p1: 2738 // The first declaration of a function shall specify the noreturn 2739 // attribute if any declaration of that function specifies the noreturn 2740 // attribute. 2741 const CXX11NoReturnAttr *NRA = New->getAttr<CXX11NoReturnAttr>(); 2742 if (NRA && !Old->hasAttr<CXX11NoReturnAttr>()) { 2743 Diag(NRA->getLocation(), diag::err_noreturn_missing_on_first_decl); 2744 Diag(Old->getFirstDecl()->getLocation(), 2745 diag::note_noreturn_missing_first_decl); 2746 } 2747 2748 // C++11 [dcl.attr.depend]p2: 2749 // The first declaration of a function shall specify the 2750 // carries_dependency attribute for its declarator-id if any declaration 2751 // of the function specifies the carries_dependency attribute. 2752 const CarriesDependencyAttr *CDA = New->getAttr<CarriesDependencyAttr>(); 2753 if (CDA && !Old->hasAttr<CarriesDependencyAttr>()) { 2754 Diag(CDA->getLocation(), 2755 diag::err_carries_dependency_missing_on_first_decl) << 0/*Function*/; 2756 Diag(Old->getFirstDecl()->getLocation(), 2757 diag::note_carries_dependency_missing_first_decl) << 0/*Function*/; 2758 } 2759 2760 // (C++98 8.3.5p3): 2761 // All declarations for a function shall agree exactly in both the 2762 // return type and the parameter-type-list. 2763 // We also want to respect all the extended bits except noreturn. 2764 2765 // noreturn should now match unless the old type info didn't have it. 2766 QualType OldQTypeForComparison = OldQType; 2767 if (!OldTypeInfo.getNoReturn() && NewTypeInfo.getNoReturn()) { 2768 assert(OldQType == QualType(OldType, 0)); 2769 const FunctionType *OldTypeForComparison 2770 = Context.adjustFunctionType(OldType, OldTypeInfo.withNoReturn(true)); 2771 OldQTypeForComparison = QualType(OldTypeForComparison, 0); 2772 assert(OldQTypeForComparison.isCanonical()); 2773 } 2774 2775 if (haveIncompatibleLanguageLinkages(Old, New)) { 2776 // As a special case, retain the language linkage from previous 2777 // declarations of a friend function as an extension. 2778 // 2779 // This liberal interpretation of C++ [class.friend]p3 matches GCC/MSVC 2780 // and is useful because there's otherwise no way to specify language 2781 // linkage within class scope. 2782 // 2783 // Check cautiously as the friend object kind isn't yet complete. 2784 if (New->getFriendObjectKind() != Decl::FOK_None) { 2785 Diag(New->getLocation(), diag::ext_retained_language_linkage) << New; 2786 Diag(OldLocation, PrevDiag); 2787 } else { 2788 Diag(New->getLocation(), diag::err_different_language_linkage) << New; 2789 Diag(OldLocation, PrevDiag); 2790 return true; 2791 } 2792 } 2793 2794 if (OldQTypeForComparison == NewQType) 2795 return MergeCompatibleFunctionDecls(New, Old, S, MergeTypeWithOld); 2796 2797 if ((NewQType->isDependentType() || OldQType->isDependentType()) && 2798 New->isLocalExternDecl()) { 2799 // It's OK if we couldn't merge types for a local function declaraton 2800 // if either the old or new type is dependent. We'll merge the types 2801 // when we instantiate the function. 2802 return false; 2803 } 2804 2805 // Fall through for conflicting redeclarations and redefinitions. 2806 } 2807 2808 // C: Function types need to be compatible, not identical. This handles 2809 // duplicate function decls like "void f(int); void f(enum X);" properly. 2810 if (!getLangOpts().CPlusPlus && 2811 Context.typesAreCompatible(OldQType, NewQType)) { 2812 const FunctionType *OldFuncType = OldQType->getAs<FunctionType>(); 2813 const FunctionType *NewFuncType = NewQType->getAs<FunctionType>(); 2814 const FunctionProtoType *OldProto = nullptr; 2815 if (MergeTypeWithOld && isa<FunctionNoProtoType>(NewFuncType) && 2816 (OldProto = dyn_cast<FunctionProtoType>(OldFuncType))) { 2817 // The old declaration provided a function prototype, but the 2818 // new declaration does not. Merge in the prototype. 2819 assert(!OldProto->hasExceptionSpec() && "Exception spec in C"); 2820 SmallVector<QualType, 16> ParamTypes(OldProto->param_types()); 2821 NewQType = 2822 Context.getFunctionType(NewFuncType->getReturnType(), ParamTypes, 2823 OldProto->getExtProtoInfo()); 2824 New->setType(NewQType); 2825 New->setHasInheritedPrototype(); 2826 2827 // Synthesize parameters with the same types. 2828 SmallVector<ParmVarDecl*, 16> Params; 2829 for (const auto &ParamType : OldProto->param_types()) { 2830 ParmVarDecl *Param = ParmVarDecl::Create(Context, New, SourceLocation(), 2831 SourceLocation(), nullptr, 2832 ParamType, /*TInfo=*/nullptr, 2833 SC_None, nullptr); 2834 Param->setScopeInfo(0, Params.size()); 2835 Param->setImplicit(); 2836 Params.push_back(Param); 2837 } 2838 2839 New->setParams(Params); 2840 } 2841 2842 return MergeCompatibleFunctionDecls(New, Old, S, MergeTypeWithOld); 2843 } 2844 2845 // GNU C permits a K&R definition to follow a prototype declaration 2846 // if the declared types of the parameters in the K&R definition 2847 // match the types in the prototype declaration, even when the 2848 // promoted types of the parameters from the K&R definition differ 2849 // from the types in the prototype. GCC then keeps the types from 2850 // the prototype. 2851 // 2852 // If a variadic prototype is followed by a non-variadic K&R definition, 2853 // the K&R definition becomes variadic. This is sort of an edge case, but 2854 // it's legal per the standard depending on how you read C99 6.7.5.3p15 and 2855 // C99 6.9.1p8. 2856 if (!getLangOpts().CPlusPlus && 2857 Old->hasPrototype() && !New->hasPrototype() && 2858 New->getType()->getAs<FunctionProtoType>() && 2859 Old->getNumParams() == New->getNumParams()) { 2860 SmallVector<QualType, 16> ArgTypes; 2861 SmallVector<GNUCompatibleParamWarning, 16> Warnings; 2862 const FunctionProtoType *OldProto 2863 = Old->getType()->getAs<FunctionProtoType>(); 2864 const FunctionProtoType *NewProto 2865 = New->getType()->getAs<FunctionProtoType>(); 2866 2867 // Determine whether this is the GNU C extension. 2868 QualType MergedReturn = Context.mergeTypes(OldProto->getReturnType(), 2869 NewProto->getReturnType()); 2870 bool LooseCompatible = !MergedReturn.isNull(); 2871 for (unsigned Idx = 0, End = Old->getNumParams(); 2872 LooseCompatible && Idx != End; ++Idx) { 2873 ParmVarDecl *OldParm = Old->getParamDecl(Idx); 2874 ParmVarDecl *NewParm = New->getParamDecl(Idx); 2875 if (Context.typesAreCompatible(OldParm->getType(), 2876 NewProto->getParamType(Idx))) { 2877 ArgTypes.push_back(NewParm->getType()); 2878 } else if (Context.typesAreCompatible(OldParm->getType(), 2879 NewParm->getType(), 2880 /*CompareUnqualified=*/true)) { 2881 GNUCompatibleParamWarning Warn = { OldParm, NewParm, 2882 NewProto->getParamType(Idx) }; 2883 Warnings.push_back(Warn); 2884 ArgTypes.push_back(NewParm->getType()); 2885 } else 2886 LooseCompatible = false; 2887 } 2888 2889 if (LooseCompatible) { 2890 for (unsigned Warn = 0; Warn < Warnings.size(); ++Warn) { 2891 Diag(Warnings[Warn].NewParm->getLocation(), 2892 diag::ext_param_promoted_not_compatible_with_prototype) 2893 << Warnings[Warn].PromotedType 2894 << Warnings[Warn].OldParm->getType(); 2895 if (Warnings[Warn].OldParm->getLocation().isValid()) 2896 Diag(Warnings[Warn].OldParm->getLocation(), 2897 diag::note_previous_declaration); 2898 } 2899 2900 if (MergeTypeWithOld) 2901 New->setType(Context.getFunctionType(MergedReturn, ArgTypes, 2902 OldProto->getExtProtoInfo())); 2903 return MergeCompatibleFunctionDecls(New, Old, S, MergeTypeWithOld); 2904 } 2905 2906 // Fall through to diagnose conflicting types. 2907 } 2908 2909 // A function that has already been declared has been redeclared or 2910 // defined with a different type; show an appropriate diagnostic. 2911 2912 // If the previous declaration was an implicitly-generated builtin 2913 // declaration, then at the very least we should use a specialized note. 2914 unsigned BuiltinID; 2915 if (Old->isImplicit() && (BuiltinID = Old->getBuiltinID())) { 2916 // If it's actually a library-defined builtin function like 'malloc' 2917 // or 'printf', just warn about the incompatible redeclaration. 2918 if (Context.BuiltinInfo.isPredefinedLibFunction(BuiltinID)) { 2919 Diag(New->getLocation(), diag::warn_redecl_library_builtin) << New; 2920 Diag(OldLocation, diag::note_previous_builtin_declaration) 2921 << Old << Old->getType(); 2922 2923 // If this is a global redeclaration, just forget hereafter 2924 // about the "builtin-ness" of the function. 2925 // 2926 // Doing this for local extern declarations is problematic. If 2927 // the builtin declaration remains visible, a second invalid 2928 // local declaration will produce a hard error; if it doesn't 2929 // remain visible, a single bogus local redeclaration (which is 2930 // actually only a warning) could break all the downstream code. 2931 if (!New->getLexicalDeclContext()->isFunctionOrMethod()) 2932 New->getIdentifier()->setBuiltinID(Builtin::NotBuiltin); 2933 2934 return false; 2935 } 2936 2937 PrevDiag = diag::note_previous_builtin_declaration; 2938 } 2939 2940 Diag(New->getLocation(), diag::err_conflicting_types) << New->getDeclName(); 2941 Diag(OldLocation, PrevDiag) << Old << Old->getType(); 2942 return true; 2943 } 2944 2945 /// \brief Completes the merge of two function declarations that are 2946 /// known to be compatible. 2947 /// 2948 /// This routine handles the merging of attributes and other 2949 /// properties of function declarations from the old declaration to 2950 /// the new declaration, once we know that New is in fact a 2951 /// redeclaration of Old. 2952 /// 2953 /// \returns false 2954 bool Sema::MergeCompatibleFunctionDecls(FunctionDecl *New, FunctionDecl *Old, 2955 Scope *S, bool MergeTypeWithOld) { 2956 // Merge the attributes 2957 mergeDeclAttributes(New, Old); 2958 2959 // Merge "pure" flag. 2960 if (Old->isPure()) 2961 New->setPure(); 2962 2963 // Merge "used" flag. 2964 if (Old->getMostRecentDecl()->isUsed(false)) 2965 New->setIsUsed(); 2966 2967 // Merge attributes from the parameters. These can mismatch with K&R 2968 // declarations. 2969 if (New->getNumParams() == Old->getNumParams()) 2970 for (unsigned i = 0, e = New->getNumParams(); i != e; ++i) 2971 mergeParamDeclAttributes(New->getParamDecl(i), Old->getParamDecl(i), 2972 *this); 2973 2974 if (getLangOpts().CPlusPlus) 2975 return MergeCXXFunctionDecl(New, Old, S); 2976 2977 // Merge the function types so the we get the composite types for the return 2978 // and argument types. Per C11 6.2.7/4, only update the type if the old decl 2979 // was visible. 2980 QualType Merged = Context.mergeTypes(Old->getType(), New->getType()); 2981 if (!Merged.isNull() && MergeTypeWithOld) 2982 New->setType(Merged); 2983 2984 return false; 2985 } 2986 2987 2988 void Sema::mergeObjCMethodDecls(ObjCMethodDecl *newMethod, 2989 ObjCMethodDecl *oldMethod) { 2990 2991 // Merge the attributes, including deprecated/unavailable 2992 AvailabilityMergeKind MergeKind = 2993 isa<ObjCImplDecl>(newMethod->getDeclContext()) ? AMK_Redeclaration 2994 : AMK_Override; 2995 mergeDeclAttributes(newMethod, oldMethod, MergeKind); 2996 2997 // Merge attributes from the parameters. 2998 ObjCMethodDecl::param_const_iterator oi = oldMethod->param_begin(), 2999 oe = oldMethod->param_end(); 3000 for (ObjCMethodDecl::param_iterator 3001 ni = newMethod->param_begin(), ne = newMethod->param_end(); 3002 ni != ne && oi != oe; ++ni, ++oi) 3003 mergeParamDeclAttributes(*ni, *oi, *this); 3004 3005 CheckObjCMethodOverride(newMethod, oldMethod); 3006 } 3007 3008 /// MergeVarDeclTypes - We parsed a variable 'New' which has the same name and 3009 /// scope as a previous declaration 'Old'. Figure out how to merge their types, 3010 /// emitting diagnostics as appropriate. 3011 /// 3012 /// Declarations using the auto type specifier (C++ [decl.spec.auto]) call back 3013 /// to here in AddInitializerToDecl. We can't check them before the initializer 3014 /// is attached. 3015 void Sema::MergeVarDeclTypes(VarDecl *New, VarDecl *Old, 3016 bool MergeTypeWithOld) { 3017 if (New->isInvalidDecl() || Old->isInvalidDecl()) 3018 return; 3019 3020 QualType MergedT; 3021 if (getLangOpts().CPlusPlus) { 3022 if (New->getType()->isUndeducedType()) { 3023 // We don't know what the new type is until the initializer is attached. 3024 return; 3025 } else if (Context.hasSameType(New->getType(), Old->getType())) { 3026 // These could still be something that needs exception specs checked. 3027 return MergeVarDeclExceptionSpecs(New, Old); 3028 } 3029 // C++ [basic.link]p10: 3030 // [...] the types specified by all declarations referring to a given 3031 // object or function shall be identical, except that declarations for an 3032 // array object can specify array types that differ by the presence or 3033 // absence of a major array bound (8.3.4). 3034 else if (Old->getType()->isIncompleteArrayType() && 3035 New->getType()->isArrayType()) { 3036 const ArrayType *OldArray = Context.getAsArrayType(Old->getType()); 3037 const ArrayType *NewArray = Context.getAsArrayType(New->getType()); 3038 if (Context.hasSameType(OldArray->getElementType(), 3039 NewArray->getElementType())) 3040 MergedT = New->getType(); 3041 } else if (Old->getType()->isArrayType() && 3042 New->getType()->isIncompleteArrayType()) { 3043 const ArrayType *OldArray = Context.getAsArrayType(Old->getType()); 3044 const ArrayType *NewArray = Context.getAsArrayType(New->getType()); 3045 if (Context.hasSameType(OldArray->getElementType(), 3046 NewArray->getElementType())) 3047 MergedT = Old->getType(); 3048 } else if (New->getType()->isObjCObjectPointerType() && 3049 Old->getType()->isObjCObjectPointerType()) { 3050 MergedT = Context.mergeObjCGCQualifiers(New->getType(), 3051 Old->getType()); 3052 } 3053 } else { 3054 // C 6.2.7p2: 3055 // All declarations that refer to the same object or function shall have 3056 // compatible type. 3057 MergedT = Context.mergeTypes(New->getType(), Old->getType()); 3058 } 3059 if (MergedT.isNull()) { 3060 // It's OK if we couldn't merge types if either type is dependent, for a 3061 // block-scope variable. In other cases (static data members of class 3062 // templates, variable templates, ...), we require the types to be 3063 // equivalent. 3064 // FIXME: The C++ standard doesn't say anything about this. 3065 if ((New->getType()->isDependentType() || 3066 Old->getType()->isDependentType()) && New->isLocalVarDecl()) { 3067 // If the old type was dependent, we can't merge with it, so the new type 3068 // becomes dependent for now. We'll reproduce the original type when we 3069 // instantiate the TypeSourceInfo for the variable. 3070 if (!New->getType()->isDependentType() && MergeTypeWithOld) 3071 New->setType(Context.DependentTy); 3072 return; 3073 } 3074 3075 // FIXME: Even if this merging succeeds, some other non-visible declaration 3076 // of this variable might have an incompatible type. For instance: 3077 // 3078 // extern int arr[]; 3079 // void f() { extern int arr[2]; } 3080 // void g() { extern int arr[3]; } 3081 // 3082 // Neither C nor C++ requires a diagnostic for this, but we should still try 3083 // to diagnose it. 3084 Diag(New->getLocation(), diag::err_redefinition_different_type) 3085 << New->getDeclName() << New->getType() << Old->getType(); 3086 Diag(Old->getLocation(), diag::note_previous_definition); 3087 return New->setInvalidDecl(); 3088 } 3089 3090 // Don't actually update the type on the new declaration if the old 3091 // declaration was an extern declaration in a different scope. 3092 if (MergeTypeWithOld) 3093 New->setType(MergedT); 3094 } 3095 3096 static bool mergeTypeWithPrevious(Sema &S, VarDecl *NewVD, VarDecl *OldVD, 3097 LookupResult &Previous) { 3098 // C11 6.2.7p4: 3099 // For an identifier with internal or external linkage declared 3100 // in a scope in which a prior declaration of that identifier is 3101 // visible, if the prior declaration specifies internal or 3102 // external linkage, the type of the identifier at the later 3103 // declaration becomes the composite type. 3104 // 3105 // If the variable isn't visible, we do not merge with its type. 3106 if (Previous.isShadowed()) 3107 return false; 3108 3109 if (S.getLangOpts().CPlusPlus) { 3110 // C++11 [dcl.array]p3: 3111 // If there is a preceding declaration of the entity in the same 3112 // scope in which the bound was specified, an omitted array bound 3113 // is taken to be the same as in that earlier declaration. 3114 return NewVD->isPreviousDeclInSameBlockScope() || 3115 (!OldVD->getLexicalDeclContext()->isFunctionOrMethod() && 3116 !NewVD->getLexicalDeclContext()->isFunctionOrMethod()); 3117 } else { 3118 // If the old declaration was function-local, don't merge with its 3119 // type unless we're in the same function. 3120 return !OldVD->getLexicalDeclContext()->isFunctionOrMethod() || 3121 OldVD->getLexicalDeclContext() == NewVD->getLexicalDeclContext(); 3122 } 3123 } 3124 3125 /// MergeVarDecl - We just parsed a variable 'New' which has the same name 3126 /// and scope as a previous declaration 'Old'. Figure out how to resolve this 3127 /// situation, merging decls or emitting diagnostics as appropriate. 3128 /// 3129 /// Tentative definition rules (C99 6.9.2p2) are checked by 3130 /// FinalizeDeclaratorGroup. Unfortunately, we can't analyze tentative 3131 /// definitions here, since the initializer hasn't been attached. 3132 /// 3133 void Sema::MergeVarDecl(VarDecl *New, LookupResult &Previous) { 3134 // If the new decl is already invalid, don't do any other checking. 3135 if (New->isInvalidDecl()) 3136 return; 3137 3138 VarTemplateDecl *NewTemplate = New->getDescribedVarTemplate(); 3139 3140 // Verify the old decl was also a variable or variable template. 3141 VarDecl *Old = nullptr; 3142 VarTemplateDecl *OldTemplate = nullptr; 3143 if (Previous.isSingleResult()) { 3144 if (NewTemplate) { 3145 OldTemplate = dyn_cast<VarTemplateDecl>(Previous.getFoundDecl()); 3146 Old = OldTemplate ? OldTemplate->getTemplatedDecl() : nullptr; 3147 } else 3148 Old = dyn_cast<VarDecl>(Previous.getFoundDecl()); 3149 } 3150 if (!Old) { 3151 Diag(New->getLocation(), diag::err_redefinition_different_kind) 3152 << New->getDeclName(); 3153 Diag(Previous.getRepresentativeDecl()->getLocation(), 3154 diag::note_previous_definition); 3155 return New->setInvalidDecl(); 3156 } 3157 3158 if (!shouldLinkPossiblyHiddenDecl(Old, New)) 3159 return; 3160 3161 // Ensure the template parameters are compatible. 3162 if (NewTemplate && 3163 !TemplateParameterListsAreEqual(NewTemplate->getTemplateParameters(), 3164 OldTemplate->getTemplateParameters(), 3165 /*Complain=*/true, TPL_TemplateMatch)) 3166 return; 3167 3168 // C++ [class.mem]p1: 3169 // A member shall not be declared twice in the member-specification [...] 3170 // 3171 // Here, we need only consider static data members. 3172 if (Old->isStaticDataMember() && !New->isOutOfLine()) { 3173 Diag(New->getLocation(), diag::err_duplicate_member) 3174 << New->getIdentifier(); 3175 Diag(Old->getLocation(), diag::note_previous_declaration); 3176 New->setInvalidDecl(); 3177 } 3178 3179 mergeDeclAttributes(New, Old); 3180 // Warn if an already-declared variable is made a weak_import in a subsequent 3181 // declaration 3182 if (New->hasAttr<WeakImportAttr>() && 3183 Old->getStorageClass() == SC_None && 3184 !Old->hasAttr<WeakImportAttr>()) { 3185 Diag(New->getLocation(), diag::warn_weak_import) << New->getDeclName(); 3186 Diag(Old->getLocation(), diag::note_previous_definition); 3187 // Remove weak_import attribute on new declaration. 3188 New->dropAttr<WeakImportAttr>(); 3189 } 3190 3191 // Merge the types. 3192 MergeVarDeclTypes(New, Old, mergeTypeWithPrevious(*this, New, Old, Previous)); 3193 3194 if (New->isInvalidDecl()) 3195 return; 3196 3197 diag::kind PrevDiag; 3198 SourceLocation OldLocation; 3199 std::tie(PrevDiag, OldLocation) = 3200 getNoteDiagForInvalidRedeclaration(Old, New); 3201 3202 // [dcl.stc]p8: Check if we have a non-static decl followed by a static. 3203 if (New->getStorageClass() == SC_Static && 3204 !New->isStaticDataMember() && 3205 Old->hasExternalFormalLinkage()) { 3206 if (getLangOpts().MicrosoftExt) { 3207 Diag(New->getLocation(), diag::ext_static_non_static) 3208 << New->getDeclName(); 3209 Diag(OldLocation, PrevDiag); 3210 } else { 3211 Diag(New->getLocation(), diag::err_static_non_static) 3212 << New->getDeclName(); 3213 Diag(OldLocation, PrevDiag); 3214 return New->setInvalidDecl(); 3215 } 3216 } 3217 // C99 6.2.2p4: 3218 // For an identifier declared with the storage-class specifier 3219 // extern in a scope in which a prior declaration of that 3220 // identifier is visible,23) if the prior declaration specifies 3221 // internal or external linkage, the linkage of the identifier at 3222 // the later declaration is the same as the linkage specified at 3223 // the prior declaration. If no prior declaration is visible, or 3224 // if the prior declaration specifies no linkage, then the 3225 // identifier has external linkage. 3226 if (New->hasExternalStorage() && Old->hasLinkage()) 3227 /* Okay */; 3228 else if (New->getCanonicalDecl()->getStorageClass() != SC_Static && 3229 !New->isStaticDataMember() && 3230 Old->getCanonicalDecl()->getStorageClass() == SC_Static) { 3231 Diag(New->getLocation(), diag::err_non_static_static) << New->getDeclName(); 3232 Diag(OldLocation, PrevDiag); 3233 return New->setInvalidDecl(); 3234 } 3235 3236 // Check if extern is followed by non-extern and vice-versa. 3237 if (New->hasExternalStorage() && 3238 !Old->hasLinkage() && Old->isLocalVarDecl()) { 3239 Diag(New->getLocation(), diag::err_extern_non_extern) << New->getDeclName(); 3240 Diag(OldLocation, PrevDiag); 3241 return New->setInvalidDecl(); 3242 } 3243 if (Old->hasLinkage() && New->isLocalVarDecl() && 3244 !New->hasExternalStorage()) { 3245 Diag(New->getLocation(), diag::err_non_extern_extern) << New->getDeclName(); 3246 Diag(OldLocation, PrevDiag); 3247 return New->setInvalidDecl(); 3248 } 3249 3250 // Variables with external linkage are analyzed in FinalizeDeclaratorGroup. 3251 3252 // FIXME: The test for external storage here seems wrong? We still 3253 // need to check for mismatches. 3254 if (!New->hasExternalStorage() && !New->isFileVarDecl() && 3255 // Don't complain about out-of-line definitions of static members. 3256 !(Old->getLexicalDeclContext()->isRecord() && 3257 !New->getLexicalDeclContext()->isRecord())) { 3258 Diag(New->getLocation(), diag::err_redefinition) << New->getDeclName(); 3259 Diag(OldLocation, PrevDiag); 3260 return New->setInvalidDecl(); 3261 } 3262 3263 if (New->getTLSKind() != Old->getTLSKind()) { 3264 if (!Old->getTLSKind()) { 3265 Diag(New->getLocation(), diag::err_thread_non_thread) << New->getDeclName(); 3266 Diag(OldLocation, PrevDiag); 3267 } else if (!New->getTLSKind()) { 3268 Diag(New->getLocation(), diag::err_non_thread_thread) << New->getDeclName(); 3269 Diag(OldLocation, PrevDiag); 3270 } else { 3271 // Do not allow redeclaration to change the variable between requiring 3272 // static and dynamic initialization. 3273 // FIXME: GCC allows this, but uses the TLS keyword on the first 3274 // declaration to determine the kind. Do we need to be compatible here? 3275 Diag(New->getLocation(), diag::err_thread_thread_different_kind) 3276 << New->getDeclName() << (New->getTLSKind() == VarDecl::TLS_Dynamic); 3277 Diag(OldLocation, PrevDiag); 3278 } 3279 } 3280 3281 // C++ doesn't have tentative definitions, so go right ahead and check here. 3282 const VarDecl *Def; 3283 if (getLangOpts().CPlusPlus && 3284 New->isThisDeclarationADefinition() == VarDecl::Definition && 3285 (Def = Old->getDefinition())) { 3286 Diag(New->getLocation(), diag::err_redefinition) << New; 3287 Diag(Def->getLocation(), diag::note_previous_definition); 3288 New->setInvalidDecl(); 3289 return; 3290 } 3291 3292 if (haveIncompatibleLanguageLinkages(Old, New)) { 3293 Diag(New->getLocation(), diag::err_different_language_linkage) << New; 3294 Diag(OldLocation, PrevDiag); 3295 New->setInvalidDecl(); 3296 return; 3297 } 3298 3299 // Merge "used" flag. 3300 if (Old->getMostRecentDecl()->isUsed(false)) 3301 New->setIsUsed(); 3302 3303 // Keep a chain of previous declarations. 3304 New->setPreviousDecl(Old); 3305 if (NewTemplate) 3306 NewTemplate->setPreviousDecl(OldTemplate); 3307 3308 // Inherit access appropriately. 3309 New->setAccess(Old->getAccess()); 3310 if (NewTemplate) 3311 NewTemplate->setAccess(New->getAccess()); 3312 } 3313 3314 /// ParsedFreeStandingDeclSpec - This method is invoked when a declspec with 3315 /// no declarator (e.g. "struct foo;") is parsed. 3316 Decl *Sema::ParsedFreeStandingDeclSpec(Scope *S, AccessSpecifier AS, 3317 DeclSpec &DS) { 3318 return ParsedFreeStandingDeclSpec(S, AS, DS, MultiTemplateParamsArg()); 3319 } 3320 3321 static void HandleTagNumbering(Sema &S, const TagDecl *Tag, Scope *TagScope) { 3322 if (!S.Context.getLangOpts().CPlusPlus) 3323 return; 3324 3325 if (isa<CXXRecordDecl>(Tag->getParent())) { 3326 // If this tag is the direct child of a class, number it if 3327 // it is anonymous. 3328 if (!Tag->getName().empty() || Tag->getTypedefNameForAnonDecl()) 3329 return; 3330 MangleNumberingContext &MCtx = 3331 S.Context.getManglingNumberContext(Tag->getParent()); 3332 S.Context.setManglingNumber( 3333 Tag, MCtx.getManglingNumber(Tag, TagScope->getMSLocalManglingNumber())); 3334 return; 3335 } 3336 3337 // If this tag isn't a direct child of a class, number it if it is local. 3338 Decl *ManglingContextDecl; 3339 if (MangleNumberingContext *MCtx = 3340 S.getCurrentMangleNumberContext(Tag->getDeclContext(), 3341 ManglingContextDecl)) { 3342 S.Context.setManglingNumber( 3343 Tag, 3344 MCtx->getManglingNumber(Tag, TagScope->getMSLocalManglingNumber())); 3345 } 3346 } 3347 3348 /// ParsedFreeStandingDeclSpec - This method is invoked when a declspec with 3349 /// no declarator (e.g. "struct foo;") is parsed. It also accepts template 3350 /// parameters to cope with template friend declarations. 3351 Decl *Sema::ParsedFreeStandingDeclSpec(Scope *S, AccessSpecifier AS, 3352 DeclSpec &DS, 3353 MultiTemplateParamsArg TemplateParams, 3354 bool IsExplicitInstantiation) { 3355 Decl *TagD = nullptr; 3356 TagDecl *Tag = nullptr; 3357 if (DS.getTypeSpecType() == DeclSpec::TST_class || 3358 DS.getTypeSpecType() == DeclSpec::TST_struct || 3359 DS.getTypeSpecType() == DeclSpec::TST_interface || 3360 DS.getTypeSpecType() == DeclSpec::TST_union || 3361 DS.getTypeSpecType() == DeclSpec::TST_enum) { 3362 TagD = DS.getRepAsDecl(); 3363 3364 if (!TagD) // We probably had an error 3365 return nullptr; 3366 3367 // Note that the above type specs guarantee that the 3368 // type rep is a Decl, whereas in many of the others 3369 // it's a Type. 3370 if (isa<TagDecl>(TagD)) 3371 Tag = cast<TagDecl>(TagD); 3372 else if (ClassTemplateDecl *CTD = dyn_cast<ClassTemplateDecl>(TagD)) 3373 Tag = CTD->getTemplatedDecl(); 3374 } 3375 3376 if (Tag) { 3377 HandleTagNumbering(*this, Tag, S); 3378 Tag->setFreeStanding(); 3379 if (Tag->isInvalidDecl()) 3380 return Tag; 3381 } 3382 3383 if (unsigned TypeQuals = DS.getTypeQualifiers()) { 3384 // Enforce C99 6.7.3p2: "Types other than pointer types derived from object 3385 // or incomplete types shall not be restrict-qualified." 3386 if (TypeQuals & DeclSpec::TQ_restrict) 3387 Diag(DS.getRestrictSpecLoc(), 3388 diag::err_typecheck_invalid_restrict_not_pointer_noarg) 3389 << DS.getSourceRange(); 3390 } 3391 3392 if (DS.isConstexprSpecified()) { 3393 // C++0x [dcl.constexpr]p1: constexpr can only be applied to declarations 3394 // and definitions of functions and variables. 3395 if (Tag) 3396 Diag(DS.getConstexprSpecLoc(), diag::err_constexpr_tag) 3397 << (DS.getTypeSpecType() == DeclSpec::TST_class ? 0 : 3398 DS.getTypeSpecType() == DeclSpec::TST_struct ? 1 : 3399 DS.getTypeSpecType() == DeclSpec::TST_interface ? 2 : 3400 DS.getTypeSpecType() == DeclSpec::TST_union ? 3 : 4); 3401 else 3402 Diag(DS.getConstexprSpecLoc(), diag::err_constexpr_no_declarators); 3403 // Don't emit warnings after this error. 3404 return TagD; 3405 } 3406 3407 DiagnoseFunctionSpecifiers(DS); 3408 3409 if (DS.isFriendSpecified()) { 3410 // If we're dealing with a decl but not a TagDecl, assume that 3411 // whatever routines created it handled the friendship aspect. 3412 if (TagD && !Tag) 3413 return nullptr; 3414 return ActOnFriendTypeDecl(S, DS, TemplateParams); 3415 } 3416 3417 CXXScopeSpec &SS = DS.getTypeSpecScope(); 3418 bool IsExplicitSpecialization = 3419 !TemplateParams.empty() && TemplateParams.back()->size() == 0; 3420 if (Tag && SS.isNotEmpty() && !Tag->isCompleteDefinition() && 3421 !IsExplicitInstantiation && !IsExplicitSpecialization) { 3422 // Per C++ [dcl.type.elab]p1, a class declaration cannot have a 3423 // nested-name-specifier unless it is an explicit instantiation 3424 // or an explicit specialization. 3425 // Per C++ [dcl.enum]p1, an opaque-enum-declaration can't either. 3426 Diag(SS.getBeginLoc(), diag::err_standalone_class_nested_name_specifier) 3427 << (DS.getTypeSpecType() == DeclSpec::TST_class ? 0 : 3428 DS.getTypeSpecType() == DeclSpec::TST_struct ? 1 : 3429 DS.getTypeSpecType() == DeclSpec::TST_interface ? 2 : 3430 DS.getTypeSpecType() == DeclSpec::TST_union ? 3 : 4) 3431 << SS.getRange(); 3432 return nullptr; 3433 } 3434 3435 // Track whether this decl-specifier declares anything. 3436 bool DeclaresAnything = true; 3437 3438 // Handle anonymous struct definitions. 3439 if (RecordDecl *Record = dyn_cast_or_null<RecordDecl>(Tag)) { 3440 if (!Record->getDeclName() && Record->isCompleteDefinition() && 3441 DS.getStorageClassSpec() != DeclSpec::SCS_typedef) { 3442 if (getLangOpts().CPlusPlus || 3443 Record->getDeclContext()->isRecord()) 3444 return BuildAnonymousStructOrUnion(S, DS, AS, Record, Context.getPrintingPolicy()); 3445 3446 DeclaresAnything = false; 3447 } 3448 } 3449 3450 // C11 6.7.2.1p2: 3451 // A struct-declaration that does not declare an anonymous structure or 3452 // anonymous union shall contain a struct-declarator-list. 3453 // 3454 // This rule also existed in C89 and C99; the grammar for struct-declaration 3455 // did not permit a struct-declaration without a struct-declarator-list. 3456 if (!getLangOpts().CPlusPlus && CurContext->isRecord() && 3457 DS.getStorageClassSpec() == DeclSpec::SCS_unspecified) { 3458 // Check for Microsoft C extension: anonymous struct/union member. 3459 // Handle 2 kinds of anonymous struct/union: 3460 // struct STRUCT; 3461 // union UNION; 3462 // and 3463 // STRUCT_TYPE; <- where STRUCT_TYPE is a typedef struct. 3464 // UNION_TYPE; <- where UNION_TYPE is a typedef union. 3465 if ((Tag && Tag->getDeclName()) || 3466 DS.getTypeSpecType() == DeclSpec::TST_typename) { 3467 RecordDecl *Record = nullptr; 3468 if (Tag) 3469 Record = dyn_cast<RecordDecl>(Tag); 3470 else if (const RecordType *RT = 3471 DS.getRepAsType().get()->getAsStructureType()) 3472 Record = RT->getDecl(); 3473 else if (const RecordType *UT = DS.getRepAsType().get()->getAsUnionType()) 3474 Record = UT->getDecl(); 3475 3476 if (Record && getLangOpts().MicrosoftExt) { 3477 Diag(DS.getLocStart(), diag::ext_ms_anonymous_record) 3478 << Record->isUnion() << DS.getSourceRange(); 3479 return BuildMicrosoftCAnonymousStruct(S, DS, Record); 3480 } 3481 3482 DeclaresAnything = false; 3483 } 3484 } 3485 3486 // Skip all the checks below if we have a type error. 3487 if (DS.getTypeSpecType() == DeclSpec::TST_error || 3488 (TagD && TagD->isInvalidDecl())) 3489 return TagD; 3490 3491 if (getLangOpts().CPlusPlus && 3492 DS.getStorageClassSpec() != DeclSpec::SCS_typedef) 3493 if (EnumDecl *Enum = dyn_cast_or_null<EnumDecl>(Tag)) 3494 if (Enum->enumerator_begin() == Enum->enumerator_end() && 3495 !Enum->getIdentifier() && !Enum->isInvalidDecl()) 3496 DeclaresAnything = false; 3497 3498 if (!DS.isMissingDeclaratorOk()) { 3499 // Customize diagnostic for a typedef missing a name. 3500 if (DS.getStorageClassSpec() == DeclSpec::SCS_typedef) 3501 Diag(DS.getLocStart(), diag::ext_typedef_without_a_name) 3502 << DS.getSourceRange(); 3503 else 3504 DeclaresAnything = false; 3505 } 3506 3507 if (DS.isModulePrivateSpecified() && 3508 Tag && Tag->getDeclContext()->isFunctionOrMethod()) 3509 Diag(DS.getModulePrivateSpecLoc(), diag::err_module_private_local_class) 3510 << Tag->getTagKind() 3511 << FixItHint::CreateRemoval(DS.getModulePrivateSpecLoc()); 3512 3513 ActOnDocumentableDecl(TagD); 3514 3515 // C 6.7/2: 3516 // A declaration [...] shall declare at least a declarator [...], a tag, 3517 // or the members of an enumeration. 3518 // C++ [dcl.dcl]p3: 3519 // [If there are no declarators], and except for the declaration of an 3520 // unnamed bit-field, the decl-specifier-seq shall introduce one or more 3521 // names into the program, or shall redeclare a name introduced by a 3522 // previous declaration. 3523 if (!DeclaresAnything) { 3524 // In C, we allow this as a (popular) extension / bug. Don't bother 3525 // producing further diagnostics for redundant qualifiers after this. 3526 Diag(DS.getLocStart(), diag::ext_no_declarators) << DS.getSourceRange(); 3527 return TagD; 3528 } 3529 3530 // C++ [dcl.stc]p1: 3531 // If a storage-class-specifier appears in a decl-specifier-seq, [...] the 3532 // init-declarator-list of the declaration shall not be empty. 3533 // C++ [dcl.fct.spec]p1: 3534 // If a cv-qualifier appears in a decl-specifier-seq, the 3535 // init-declarator-list of the declaration shall not be empty. 3536 // 3537 // Spurious qualifiers here appear to be valid in C. 3538 unsigned DiagID = diag::warn_standalone_specifier; 3539 if (getLangOpts().CPlusPlus) 3540 DiagID = diag::ext_standalone_specifier; 3541 3542 // Note that a linkage-specification sets a storage class, but 3543 // 'extern "C" struct foo;' is actually valid and not theoretically 3544 // useless. 3545 if (DeclSpec::SCS SCS = DS.getStorageClassSpec()) { 3546 if (SCS == DeclSpec::SCS_mutable) 3547 // Since mutable is not a viable storage class specifier in C, there is 3548 // no reason to treat it as an extension. Instead, diagnose as an error. 3549 Diag(DS.getStorageClassSpecLoc(), diag::err_mutable_nonmember); 3550 else if (!DS.isExternInLinkageSpec() && SCS != DeclSpec::SCS_typedef) 3551 Diag(DS.getStorageClassSpecLoc(), DiagID) 3552 << DeclSpec::getSpecifierName(SCS); 3553 } 3554 3555 if (DeclSpec::TSCS TSCS = DS.getThreadStorageClassSpec()) 3556 Diag(DS.getThreadStorageClassSpecLoc(), DiagID) 3557 << DeclSpec::getSpecifierName(TSCS); 3558 if (DS.getTypeQualifiers()) { 3559 if (DS.getTypeQualifiers() & DeclSpec::TQ_const) 3560 Diag(DS.getConstSpecLoc(), DiagID) << "const"; 3561 if (DS.getTypeQualifiers() & DeclSpec::TQ_volatile) 3562 Diag(DS.getConstSpecLoc(), DiagID) << "volatile"; 3563 // Restrict is covered above. 3564 if (DS.getTypeQualifiers() & DeclSpec::TQ_atomic) 3565 Diag(DS.getAtomicSpecLoc(), DiagID) << "_Atomic"; 3566 } 3567 3568 // Warn about ignored type attributes, for example: 3569 // __attribute__((aligned)) struct A; 3570 // Attributes should be placed after tag to apply to type declaration. 3571 if (!DS.getAttributes().empty()) { 3572 DeclSpec::TST TypeSpecType = DS.getTypeSpecType(); 3573 if (TypeSpecType == DeclSpec::TST_class || 3574 TypeSpecType == DeclSpec::TST_struct || 3575 TypeSpecType == DeclSpec::TST_interface || 3576 TypeSpecType == DeclSpec::TST_union || 3577 TypeSpecType == DeclSpec::TST_enum) { 3578 AttributeList* attrs = DS.getAttributes().getList(); 3579 while (attrs) { 3580 Diag(attrs->getLoc(), diag::warn_declspec_attribute_ignored) 3581 << attrs->getName() 3582 << (TypeSpecType == DeclSpec::TST_class ? 0 : 3583 TypeSpecType == DeclSpec::TST_struct ? 1 : 3584 TypeSpecType == DeclSpec::TST_union ? 2 : 3585 TypeSpecType == DeclSpec::TST_interface ? 3 : 4); 3586 attrs = attrs->getNext(); 3587 } 3588 } 3589 } 3590 3591 return TagD; 3592 } 3593 3594 /// We are trying to inject an anonymous member into the given scope; 3595 /// check if there's an existing declaration that can't be overloaded. 3596 /// 3597 /// \return true if this is a forbidden redeclaration 3598 static bool CheckAnonMemberRedeclaration(Sema &SemaRef, 3599 Scope *S, 3600 DeclContext *Owner, 3601 DeclarationName Name, 3602 SourceLocation NameLoc, 3603 unsigned diagnostic) { 3604 LookupResult R(SemaRef, Name, NameLoc, Sema::LookupMemberName, 3605 Sema::ForRedeclaration); 3606 if (!SemaRef.LookupName(R, S)) return false; 3607 3608 if (R.getAsSingle<TagDecl>()) 3609 return false; 3610 3611 // Pick a representative declaration. 3612 NamedDecl *PrevDecl = R.getRepresentativeDecl()->getUnderlyingDecl(); 3613 assert(PrevDecl && "Expected a non-null Decl"); 3614 3615 if (!SemaRef.isDeclInScope(PrevDecl, Owner, S)) 3616 return false; 3617 3618 SemaRef.Diag(NameLoc, diagnostic) << Name; 3619 SemaRef.Diag(PrevDecl->getLocation(), diag::note_previous_declaration); 3620 3621 return true; 3622 } 3623 3624 /// InjectAnonymousStructOrUnionMembers - Inject the members of the 3625 /// anonymous struct or union AnonRecord into the owning context Owner 3626 /// and scope S. This routine will be invoked just after we realize 3627 /// that an unnamed union or struct is actually an anonymous union or 3628 /// struct, e.g., 3629 /// 3630 /// @code 3631 /// union { 3632 /// int i; 3633 /// float f; 3634 /// }; // InjectAnonymousStructOrUnionMembers called here to inject i and 3635 /// // f into the surrounding scope.x 3636 /// @endcode 3637 /// 3638 /// This routine is recursive, injecting the names of nested anonymous 3639 /// structs/unions into the owning context and scope as well. 3640 static bool InjectAnonymousStructOrUnionMembers(Sema &SemaRef, Scope *S, 3641 DeclContext *Owner, 3642 RecordDecl *AnonRecord, 3643 AccessSpecifier AS, 3644 SmallVectorImpl<NamedDecl *> &Chaining, 3645 bool MSAnonStruct) { 3646 unsigned diagKind 3647 = AnonRecord->isUnion() ? diag::err_anonymous_union_member_redecl 3648 : diag::err_anonymous_struct_member_redecl; 3649 3650 bool Invalid = false; 3651 3652 // Look every FieldDecl and IndirectFieldDecl with a name. 3653 for (auto *D : AnonRecord->decls()) { 3654 if ((isa<FieldDecl>(D) || isa<IndirectFieldDecl>(D)) && 3655 cast<NamedDecl>(D)->getDeclName()) { 3656 ValueDecl *VD = cast<ValueDecl>(D); 3657 if (CheckAnonMemberRedeclaration(SemaRef, S, Owner, VD->getDeclName(), 3658 VD->getLocation(), diagKind)) { 3659 // C++ [class.union]p2: 3660 // The names of the members of an anonymous union shall be 3661 // distinct from the names of any other entity in the 3662 // scope in which the anonymous union is declared. 3663 Invalid = true; 3664 } else { 3665 // C++ [class.union]p2: 3666 // For the purpose of name lookup, after the anonymous union 3667 // definition, the members of the anonymous union are 3668 // considered to have been defined in the scope in which the 3669 // anonymous union is declared. 3670 unsigned OldChainingSize = Chaining.size(); 3671 if (IndirectFieldDecl *IF = dyn_cast<IndirectFieldDecl>(VD)) 3672 for (auto *PI : IF->chain()) 3673 Chaining.push_back(PI); 3674 else 3675 Chaining.push_back(VD); 3676 3677 assert(Chaining.size() >= 2); 3678 NamedDecl **NamedChain = 3679 new (SemaRef.Context)NamedDecl*[Chaining.size()]; 3680 for (unsigned i = 0; i < Chaining.size(); i++) 3681 NamedChain[i] = Chaining[i]; 3682 3683 IndirectFieldDecl* IndirectField = 3684 IndirectFieldDecl::Create(SemaRef.Context, Owner, VD->getLocation(), 3685 VD->getIdentifier(), VD->getType(), 3686 NamedChain, Chaining.size()); 3687 3688 IndirectField->setAccess(AS); 3689 IndirectField->setImplicit(); 3690 SemaRef.PushOnScopeChains(IndirectField, S); 3691 3692 // That includes picking up the appropriate access specifier. 3693 if (AS != AS_none) IndirectField->setAccess(AS); 3694 3695 Chaining.resize(OldChainingSize); 3696 } 3697 } 3698 } 3699 3700 return Invalid; 3701 } 3702 3703 /// StorageClassSpecToVarDeclStorageClass - Maps a DeclSpec::SCS to 3704 /// a VarDecl::StorageClass. Any error reporting is up to the caller: 3705 /// illegal input values are mapped to SC_None. 3706 static StorageClass 3707 StorageClassSpecToVarDeclStorageClass(const DeclSpec &DS) { 3708 DeclSpec::SCS StorageClassSpec = DS.getStorageClassSpec(); 3709 assert(StorageClassSpec != DeclSpec::SCS_typedef && 3710 "Parser allowed 'typedef' as storage class VarDecl."); 3711 switch (StorageClassSpec) { 3712 case DeclSpec::SCS_unspecified: return SC_None; 3713 case DeclSpec::SCS_extern: 3714 if (DS.isExternInLinkageSpec()) 3715 return SC_None; 3716 return SC_Extern; 3717 case DeclSpec::SCS_static: return SC_Static; 3718 case DeclSpec::SCS_auto: return SC_Auto; 3719 case DeclSpec::SCS_register: return SC_Register; 3720 case DeclSpec::SCS_private_extern: return SC_PrivateExtern; 3721 // Illegal SCSs map to None: error reporting is up to the caller. 3722 case DeclSpec::SCS_mutable: // Fall through. 3723 case DeclSpec::SCS_typedef: return SC_None; 3724 } 3725 llvm_unreachable("unknown storage class specifier"); 3726 } 3727 3728 static SourceLocation findDefaultInitializer(const CXXRecordDecl *Record) { 3729 assert(Record->hasInClassInitializer()); 3730 3731 for (const auto *I : Record->decls()) { 3732 const auto *FD = dyn_cast<FieldDecl>(I); 3733 if (const auto *IFD = dyn_cast<IndirectFieldDecl>(I)) 3734 FD = IFD->getAnonField(); 3735 if (FD && FD->hasInClassInitializer()) 3736 return FD->getLocation(); 3737 } 3738 3739 llvm_unreachable("couldn't find in-class initializer"); 3740 } 3741 3742 static void checkDuplicateDefaultInit(Sema &S, CXXRecordDecl *Parent, 3743 SourceLocation DefaultInitLoc) { 3744 if (!Parent->isUnion() || !Parent->hasInClassInitializer()) 3745 return; 3746 3747 S.Diag(DefaultInitLoc, diag::err_multiple_mem_union_initialization); 3748 S.Diag(findDefaultInitializer(Parent), diag::note_previous_initializer) << 0; 3749 } 3750 3751 static void checkDuplicateDefaultInit(Sema &S, CXXRecordDecl *Parent, 3752 CXXRecordDecl *AnonUnion) { 3753 if (!Parent->isUnion() || !Parent->hasInClassInitializer()) 3754 return; 3755 3756 checkDuplicateDefaultInit(S, Parent, findDefaultInitializer(AnonUnion)); 3757 } 3758 3759 /// BuildAnonymousStructOrUnion - Handle the declaration of an 3760 /// anonymous structure or union. Anonymous unions are a C++ feature 3761 /// (C++ [class.union]) and a C11 feature; anonymous structures 3762 /// are a C11 feature and GNU C++ extension. 3763 Decl *Sema::BuildAnonymousStructOrUnion(Scope *S, DeclSpec &DS, 3764 AccessSpecifier AS, 3765 RecordDecl *Record, 3766 const PrintingPolicy &Policy) { 3767 DeclContext *Owner = Record->getDeclContext(); 3768 3769 // Diagnose whether this anonymous struct/union is an extension. 3770 if (Record->isUnion() && !getLangOpts().CPlusPlus && !getLangOpts().C11) 3771 Diag(Record->getLocation(), diag::ext_anonymous_union); 3772 else if (!Record->isUnion() && getLangOpts().CPlusPlus) 3773 Diag(Record->getLocation(), diag::ext_gnu_anonymous_struct); 3774 else if (!Record->isUnion() && !getLangOpts().C11) 3775 Diag(Record->getLocation(), diag::ext_c11_anonymous_struct); 3776 3777 // C and C++ require different kinds of checks for anonymous 3778 // structs/unions. 3779 bool Invalid = false; 3780 if (getLangOpts().CPlusPlus) { 3781 const char *PrevSpec = nullptr; 3782 unsigned DiagID; 3783 if (Record->isUnion()) { 3784 // C++ [class.union]p6: 3785 // Anonymous unions declared in a named namespace or in the 3786 // global namespace shall be declared static. 3787 if (DS.getStorageClassSpec() != DeclSpec::SCS_static && 3788 (isa<TranslationUnitDecl>(Owner) || 3789 (isa<NamespaceDecl>(Owner) && 3790 cast<NamespaceDecl>(Owner)->getDeclName()))) { 3791 Diag(Record->getLocation(), diag::err_anonymous_union_not_static) 3792 << FixItHint::CreateInsertion(Record->getLocation(), "static "); 3793 3794 // Recover by adding 'static'. 3795 DS.SetStorageClassSpec(*this, DeclSpec::SCS_static, SourceLocation(), 3796 PrevSpec, DiagID, Policy); 3797 } 3798 // C++ [class.union]p6: 3799 // A storage class is not allowed in a declaration of an 3800 // anonymous union in a class scope. 3801 else if (DS.getStorageClassSpec() != DeclSpec::SCS_unspecified && 3802 isa<RecordDecl>(Owner)) { 3803 Diag(DS.getStorageClassSpecLoc(), 3804 diag::err_anonymous_union_with_storage_spec) 3805 << FixItHint::CreateRemoval(DS.getStorageClassSpecLoc()); 3806 3807 // Recover by removing the storage specifier. 3808 DS.SetStorageClassSpec(*this, DeclSpec::SCS_unspecified, 3809 SourceLocation(), 3810 PrevSpec, DiagID, Context.getPrintingPolicy()); 3811 } 3812 } 3813 3814 // Ignore const/volatile/restrict qualifiers. 3815 if (DS.getTypeQualifiers()) { 3816 if (DS.getTypeQualifiers() & DeclSpec::TQ_const) 3817 Diag(DS.getConstSpecLoc(), diag::ext_anonymous_struct_union_qualified) 3818 << Record->isUnion() << "const" 3819 << FixItHint::CreateRemoval(DS.getConstSpecLoc()); 3820 if (DS.getTypeQualifiers() & DeclSpec::TQ_volatile) 3821 Diag(DS.getVolatileSpecLoc(), 3822 diag::ext_anonymous_struct_union_qualified) 3823 << Record->isUnion() << "volatile" 3824 << FixItHint::CreateRemoval(DS.getVolatileSpecLoc()); 3825 if (DS.getTypeQualifiers() & DeclSpec::TQ_restrict) 3826 Diag(DS.getRestrictSpecLoc(), 3827 diag::ext_anonymous_struct_union_qualified) 3828 << Record->isUnion() << "restrict" 3829 << FixItHint::CreateRemoval(DS.getRestrictSpecLoc()); 3830 if (DS.getTypeQualifiers() & DeclSpec::TQ_atomic) 3831 Diag(DS.getAtomicSpecLoc(), 3832 diag::ext_anonymous_struct_union_qualified) 3833 << Record->isUnion() << "_Atomic" 3834 << FixItHint::CreateRemoval(DS.getAtomicSpecLoc()); 3835 3836 DS.ClearTypeQualifiers(); 3837 } 3838 3839 // C++ [class.union]p2: 3840 // The member-specification of an anonymous union shall only 3841 // define non-static data members. [Note: nested types and 3842 // functions cannot be declared within an anonymous union. ] 3843 for (auto *Mem : Record->decls()) { 3844 if (auto *FD = dyn_cast<FieldDecl>(Mem)) { 3845 // C++ [class.union]p3: 3846 // An anonymous union shall not have private or protected 3847 // members (clause 11). 3848 assert(FD->getAccess() != AS_none); 3849 if (FD->getAccess() != AS_public) { 3850 Diag(FD->getLocation(), diag::err_anonymous_record_nonpublic_member) 3851 << (int)Record->isUnion() << (int)(FD->getAccess() == AS_protected); 3852 Invalid = true; 3853 } 3854 3855 // C++ [class.union]p1 3856 // An object of a class with a non-trivial constructor, a non-trivial 3857 // copy constructor, a non-trivial destructor, or a non-trivial copy 3858 // assignment operator cannot be a member of a union, nor can an 3859 // array of such objects. 3860 if (CheckNontrivialField(FD)) 3861 Invalid = true; 3862 } else if (Mem->isImplicit()) { 3863 // Any implicit members are fine. 3864 } else if (isa<TagDecl>(Mem) && Mem->getDeclContext() != Record) { 3865 // This is a type that showed up in an 3866 // elaborated-type-specifier inside the anonymous struct or 3867 // union, but which actually declares a type outside of the 3868 // anonymous struct or union. It's okay. 3869 } else if (auto *MemRecord = dyn_cast<RecordDecl>(Mem)) { 3870 if (!MemRecord->isAnonymousStructOrUnion() && 3871 MemRecord->getDeclName()) { 3872 // Visual C++ allows type definition in anonymous struct or union. 3873 if (getLangOpts().MicrosoftExt) 3874 Diag(MemRecord->getLocation(), diag::ext_anonymous_record_with_type) 3875 << (int)Record->isUnion(); 3876 else { 3877 // This is a nested type declaration. 3878 Diag(MemRecord->getLocation(), diag::err_anonymous_record_with_type) 3879 << (int)Record->isUnion(); 3880 Invalid = true; 3881 } 3882 } else { 3883 // This is an anonymous type definition within another anonymous type. 3884 // This is a popular extension, provided by Plan9, MSVC and GCC, but 3885 // not part of standard C++. 3886 Diag(MemRecord->getLocation(), 3887 diag::ext_anonymous_record_with_anonymous_type) 3888 << (int)Record->isUnion(); 3889 } 3890 } else if (isa<AccessSpecDecl>(Mem)) { 3891 // Any access specifier is fine. 3892 } else if (isa<StaticAssertDecl>(Mem)) { 3893 // In C++1z, static_assert declarations are also fine. 3894 } else { 3895 // We have something that isn't a non-static data 3896 // member. Complain about it. 3897 unsigned DK = diag::err_anonymous_record_bad_member; 3898 if (isa<TypeDecl>(Mem)) 3899 DK = diag::err_anonymous_record_with_type; 3900 else if (isa<FunctionDecl>(Mem)) 3901 DK = diag::err_anonymous_record_with_function; 3902 else if (isa<VarDecl>(Mem)) 3903 DK = diag::err_anonymous_record_with_static; 3904 3905 // Visual C++ allows type definition in anonymous struct or union. 3906 if (getLangOpts().MicrosoftExt && 3907 DK == diag::err_anonymous_record_with_type) 3908 Diag(Mem->getLocation(), diag::ext_anonymous_record_with_type) 3909 << (int)Record->isUnion(); 3910 else { 3911 Diag(Mem->getLocation(), DK) 3912 << (int)Record->isUnion(); 3913 Invalid = true; 3914 } 3915 } 3916 } 3917 3918 // C++11 [class.union]p8 (DR1460): 3919 // At most one variant member of a union may have a 3920 // brace-or-equal-initializer. 3921 if (cast<CXXRecordDecl>(Record)->hasInClassInitializer() && 3922 Owner->isRecord()) 3923 checkDuplicateDefaultInit(*this, cast<CXXRecordDecl>(Owner), 3924 cast<CXXRecordDecl>(Record)); 3925 } 3926 3927 if (!Record->isUnion() && !Owner->isRecord()) { 3928 Diag(Record->getLocation(), diag::err_anonymous_struct_not_member) 3929 << (int)getLangOpts().CPlusPlus; 3930 Invalid = true; 3931 } 3932 3933 // Mock up a declarator. 3934 Declarator Dc(DS, Declarator::MemberContext); 3935 TypeSourceInfo *TInfo = GetTypeForDeclarator(Dc, S); 3936 assert(TInfo && "couldn't build declarator info for anonymous struct/union"); 3937 3938 // Create a declaration for this anonymous struct/union. 3939 NamedDecl *Anon = nullptr; 3940 if (RecordDecl *OwningClass = dyn_cast<RecordDecl>(Owner)) { 3941 Anon = FieldDecl::Create(Context, OwningClass, 3942 DS.getLocStart(), 3943 Record->getLocation(), 3944 /*IdentifierInfo=*/nullptr, 3945 Context.getTypeDeclType(Record), 3946 TInfo, 3947 /*BitWidth=*/nullptr, /*Mutable=*/false, 3948 /*InitStyle=*/ICIS_NoInit); 3949 Anon->setAccess(AS); 3950 if (getLangOpts().CPlusPlus) 3951 FieldCollector->Add(cast<FieldDecl>(Anon)); 3952 } else { 3953 DeclSpec::SCS SCSpec = DS.getStorageClassSpec(); 3954 VarDecl::StorageClass SC = StorageClassSpecToVarDeclStorageClass(DS); 3955 if (SCSpec == DeclSpec::SCS_mutable) { 3956 // mutable can only appear on non-static class members, so it's always 3957 // an error here 3958 Diag(Record->getLocation(), diag::err_mutable_nonmember); 3959 Invalid = true; 3960 SC = SC_None; 3961 } 3962 3963 Anon = VarDecl::Create(Context, Owner, 3964 DS.getLocStart(), 3965 Record->getLocation(), /*IdentifierInfo=*/nullptr, 3966 Context.getTypeDeclType(Record), 3967 TInfo, SC); 3968 3969 // Default-initialize the implicit variable. This initialization will be 3970 // trivial in almost all cases, except if a union member has an in-class 3971 // initializer: 3972 // union { int n = 0; }; 3973 ActOnUninitializedDecl(Anon, /*TypeMayContainAuto=*/false); 3974 } 3975 Anon->setImplicit(); 3976 3977 // Mark this as an anonymous struct/union type. 3978 Record->setAnonymousStructOrUnion(true); 3979 3980 // Add the anonymous struct/union object to the current 3981 // context. We'll be referencing this object when we refer to one of 3982 // its members. 3983 Owner->addDecl(Anon); 3984 3985 // Inject the members of the anonymous struct/union into the owning 3986 // context and into the identifier resolver chain for name lookup 3987 // purposes. 3988 SmallVector<NamedDecl*, 2> Chain; 3989 Chain.push_back(Anon); 3990 3991 if (InjectAnonymousStructOrUnionMembers(*this, S, Owner, Record, AS, 3992 Chain, false)) 3993 Invalid = true; 3994 3995 if (VarDecl *NewVD = dyn_cast<VarDecl>(Anon)) { 3996 if (getLangOpts().CPlusPlus && NewVD->isStaticLocal()) { 3997 Decl *ManglingContextDecl; 3998 if (MangleNumberingContext *MCtx = 3999 getCurrentMangleNumberContext(NewVD->getDeclContext(), 4000 ManglingContextDecl)) { 4001 Context.setManglingNumber(NewVD, MCtx->getManglingNumber(NewVD, S->getMSLocalManglingNumber())); 4002 Context.setStaticLocalNumber(NewVD, MCtx->getStaticLocalNumber(NewVD)); 4003 } 4004 } 4005 } 4006 4007 if (Invalid) 4008 Anon->setInvalidDecl(); 4009 4010 return Anon; 4011 } 4012 4013 /// BuildMicrosoftCAnonymousStruct - Handle the declaration of an 4014 /// Microsoft C anonymous structure. 4015 /// Ref: http://msdn.microsoft.com/en-us/library/z2cx9y4f.aspx 4016 /// Example: 4017 /// 4018 /// struct A { int a; }; 4019 /// struct B { struct A; int b; }; 4020 /// 4021 /// void foo() { 4022 /// B var; 4023 /// var.a = 3; 4024 /// } 4025 /// 4026 Decl *Sema::BuildMicrosoftCAnonymousStruct(Scope *S, DeclSpec &DS, 4027 RecordDecl *Record) { 4028 assert(Record && "expected a record!"); 4029 4030 // Mock up a declarator. 4031 Declarator Dc(DS, Declarator::TypeNameContext); 4032 TypeSourceInfo *TInfo = GetTypeForDeclarator(Dc, S); 4033 assert(TInfo && "couldn't build declarator info for anonymous struct"); 4034 4035 // Create a declaration for this anonymous struct. 4036 NamedDecl *Anon = FieldDecl::Create(Context, 4037 cast<RecordDecl>(CurContext), 4038 DS.getLocStart(), 4039 DS.getLocStart(), 4040 /*IdentifierInfo=*/nullptr, 4041 Context.getTypeDeclType(Record), 4042 TInfo, 4043 /*BitWidth=*/nullptr, /*Mutable=*/false, 4044 /*InitStyle=*/ICIS_NoInit); 4045 Anon->setImplicit(); 4046 4047 // Add the anonymous struct object to the current context. 4048 CurContext->addDecl(Anon); 4049 4050 // Inject the members of the anonymous struct into the current 4051 // context and into the identifier resolver chain for name lookup 4052 // purposes. 4053 SmallVector<NamedDecl*, 2> Chain; 4054 Chain.push_back(Anon); 4055 4056 RecordDecl *RecordDef = Record->getDefinition(); 4057 if (!RecordDef || InjectAnonymousStructOrUnionMembers(*this, S, CurContext, 4058 RecordDef, AS_none, 4059 Chain, true)) 4060 Anon->setInvalidDecl(); 4061 4062 return Anon; 4063 } 4064 4065 /// GetNameForDeclarator - Determine the full declaration name for the 4066 /// given Declarator. 4067 DeclarationNameInfo Sema::GetNameForDeclarator(Declarator &D) { 4068 return GetNameFromUnqualifiedId(D.getName()); 4069 } 4070 4071 /// \brief Retrieves the declaration name from a parsed unqualified-id. 4072 DeclarationNameInfo 4073 Sema::GetNameFromUnqualifiedId(const UnqualifiedId &Name) { 4074 DeclarationNameInfo NameInfo; 4075 NameInfo.setLoc(Name.StartLocation); 4076 4077 switch (Name.getKind()) { 4078 4079 case UnqualifiedId::IK_ImplicitSelfParam: 4080 case UnqualifiedId::IK_Identifier: 4081 NameInfo.setName(Name.Identifier); 4082 NameInfo.setLoc(Name.StartLocation); 4083 return NameInfo; 4084 4085 case UnqualifiedId::IK_OperatorFunctionId: 4086 NameInfo.setName(Context.DeclarationNames.getCXXOperatorName( 4087 Name.OperatorFunctionId.Operator)); 4088 NameInfo.setLoc(Name.StartLocation); 4089 NameInfo.getInfo().CXXOperatorName.BeginOpNameLoc 4090 = Name.OperatorFunctionId.SymbolLocations[0]; 4091 NameInfo.getInfo().CXXOperatorName.EndOpNameLoc 4092 = Name.EndLocation.getRawEncoding(); 4093 return NameInfo; 4094 4095 case UnqualifiedId::IK_LiteralOperatorId: 4096 NameInfo.setName(Context.DeclarationNames.getCXXLiteralOperatorName( 4097 Name.Identifier)); 4098 NameInfo.setLoc(Name.StartLocation); 4099 NameInfo.setCXXLiteralOperatorNameLoc(Name.EndLocation); 4100 return NameInfo; 4101 4102 case UnqualifiedId::IK_ConversionFunctionId: { 4103 TypeSourceInfo *TInfo; 4104 QualType Ty = GetTypeFromParser(Name.ConversionFunctionId, &TInfo); 4105 if (Ty.isNull()) 4106 return DeclarationNameInfo(); 4107 NameInfo.setName(Context.DeclarationNames.getCXXConversionFunctionName( 4108 Context.getCanonicalType(Ty))); 4109 NameInfo.setLoc(Name.StartLocation); 4110 NameInfo.setNamedTypeInfo(TInfo); 4111 return NameInfo; 4112 } 4113 4114 case UnqualifiedId::IK_ConstructorName: { 4115 TypeSourceInfo *TInfo; 4116 QualType Ty = GetTypeFromParser(Name.ConstructorName, &TInfo); 4117 if (Ty.isNull()) 4118 return DeclarationNameInfo(); 4119 NameInfo.setName(Context.DeclarationNames.getCXXConstructorName( 4120 Context.getCanonicalType(Ty))); 4121 NameInfo.setLoc(Name.StartLocation); 4122 NameInfo.setNamedTypeInfo(TInfo); 4123 return NameInfo; 4124 } 4125 4126 case UnqualifiedId::IK_ConstructorTemplateId: { 4127 // In well-formed code, we can only have a constructor 4128 // template-id that refers to the current context, so go there 4129 // to find the actual type being constructed. 4130 CXXRecordDecl *CurClass = dyn_cast<CXXRecordDecl>(CurContext); 4131 if (!CurClass || CurClass->getIdentifier() != Name.TemplateId->Name) 4132 return DeclarationNameInfo(); 4133 4134 // Determine the type of the class being constructed. 4135 QualType CurClassType = Context.getTypeDeclType(CurClass); 4136 4137 // FIXME: Check two things: that the template-id names the same type as 4138 // CurClassType, and that the template-id does not occur when the name 4139 // was qualified. 4140 4141 NameInfo.setName(Context.DeclarationNames.getCXXConstructorName( 4142 Context.getCanonicalType(CurClassType))); 4143 NameInfo.setLoc(Name.StartLocation); 4144 // FIXME: should we retrieve TypeSourceInfo? 4145 NameInfo.setNamedTypeInfo(nullptr); 4146 return NameInfo; 4147 } 4148 4149 case UnqualifiedId::IK_DestructorName: { 4150 TypeSourceInfo *TInfo; 4151 QualType Ty = GetTypeFromParser(Name.DestructorName, &TInfo); 4152 if (Ty.isNull()) 4153 return DeclarationNameInfo(); 4154 NameInfo.setName(Context.DeclarationNames.getCXXDestructorName( 4155 Context.getCanonicalType(Ty))); 4156 NameInfo.setLoc(Name.StartLocation); 4157 NameInfo.setNamedTypeInfo(TInfo); 4158 return NameInfo; 4159 } 4160 4161 case UnqualifiedId::IK_TemplateId: { 4162 TemplateName TName = Name.TemplateId->Template.get(); 4163 SourceLocation TNameLoc = Name.TemplateId->TemplateNameLoc; 4164 return Context.getNameForTemplate(TName, TNameLoc); 4165 } 4166 4167 } // switch (Name.getKind()) 4168 4169 llvm_unreachable("Unknown name kind"); 4170 } 4171 4172 static QualType getCoreType(QualType Ty) { 4173 do { 4174 if (Ty->isPointerType() || Ty->isReferenceType()) 4175 Ty = Ty->getPointeeType(); 4176 else if (Ty->isArrayType()) 4177 Ty = Ty->castAsArrayTypeUnsafe()->getElementType(); 4178 else 4179 return Ty.withoutLocalFastQualifiers(); 4180 } while (true); 4181 } 4182 4183 /// hasSimilarParameters - Determine whether the C++ functions Declaration 4184 /// and Definition have "nearly" matching parameters. This heuristic is 4185 /// used to improve diagnostics in the case where an out-of-line function 4186 /// definition doesn't match any declaration within the class or namespace. 4187 /// Also sets Params to the list of indices to the parameters that differ 4188 /// between the declaration and the definition. If hasSimilarParameters 4189 /// returns true and Params is empty, then all of the parameters match. 4190 static bool hasSimilarParameters(ASTContext &Context, 4191 FunctionDecl *Declaration, 4192 FunctionDecl *Definition, 4193 SmallVectorImpl<unsigned> &Params) { 4194 Params.clear(); 4195 if (Declaration->param_size() != Definition->param_size()) 4196 return false; 4197 for (unsigned Idx = 0; Idx < Declaration->param_size(); ++Idx) { 4198 QualType DeclParamTy = Declaration->getParamDecl(Idx)->getType(); 4199 QualType DefParamTy = Definition->getParamDecl(Idx)->getType(); 4200 4201 // The parameter types are identical 4202 if (Context.hasSameType(DefParamTy, DeclParamTy)) 4203 continue; 4204 4205 QualType DeclParamBaseTy = getCoreType(DeclParamTy); 4206 QualType DefParamBaseTy = getCoreType(DefParamTy); 4207 const IdentifierInfo *DeclTyName = DeclParamBaseTy.getBaseTypeIdentifier(); 4208 const IdentifierInfo *DefTyName = DefParamBaseTy.getBaseTypeIdentifier(); 4209 4210 if (Context.hasSameUnqualifiedType(DeclParamBaseTy, DefParamBaseTy) || 4211 (DeclTyName && DeclTyName == DefTyName)) 4212 Params.push_back(Idx); 4213 else // The two parameters aren't even close 4214 return false; 4215 } 4216 4217 return true; 4218 } 4219 4220 /// NeedsRebuildingInCurrentInstantiation - Checks whether the given 4221 /// declarator needs to be rebuilt in the current instantiation. 4222 /// Any bits of declarator which appear before the name are valid for 4223 /// consideration here. That's specifically the type in the decl spec 4224 /// and the base type in any member-pointer chunks. 4225 static bool RebuildDeclaratorInCurrentInstantiation(Sema &S, Declarator &D, 4226 DeclarationName Name) { 4227 // The types we specifically need to rebuild are: 4228 // - typenames, typeofs, and decltypes 4229 // - types which will become injected class names 4230 // Of course, we also need to rebuild any type referencing such a 4231 // type. It's safest to just say "dependent", but we call out a 4232 // few cases here. 4233 4234 DeclSpec &DS = D.getMutableDeclSpec(); 4235 switch (DS.getTypeSpecType()) { 4236 case DeclSpec::TST_typename: 4237 case DeclSpec::TST_typeofType: 4238 case DeclSpec::TST_underlyingType: 4239 case DeclSpec::TST_atomic: { 4240 // Grab the type from the parser. 4241 TypeSourceInfo *TSI = nullptr; 4242 QualType T = S.GetTypeFromParser(DS.getRepAsType(), &TSI); 4243 if (T.isNull() || !T->isDependentType()) break; 4244 4245 // Make sure there's a type source info. This isn't really much 4246 // of a waste; most dependent types should have type source info 4247 // attached already. 4248 if (!TSI) 4249 TSI = S.Context.getTrivialTypeSourceInfo(T, DS.getTypeSpecTypeLoc()); 4250 4251 // Rebuild the type in the current instantiation. 4252 TSI = S.RebuildTypeInCurrentInstantiation(TSI, D.getIdentifierLoc(), Name); 4253 if (!TSI) return true; 4254 4255 // Store the new type back in the decl spec. 4256 ParsedType LocType = S.CreateParsedType(TSI->getType(), TSI); 4257 DS.UpdateTypeRep(LocType); 4258 break; 4259 } 4260 4261 case DeclSpec::TST_decltype: 4262 case DeclSpec::TST_typeofExpr: { 4263 Expr *E = DS.getRepAsExpr(); 4264 ExprResult Result = S.RebuildExprInCurrentInstantiation(E); 4265 if (Result.isInvalid()) return true; 4266 DS.UpdateExprRep(Result.get()); 4267 break; 4268 } 4269 4270 default: 4271 // Nothing to do for these decl specs. 4272 break; 4273 } 4274 4275 // It doesn't matter what order we do this in. 4276 for (unsigned I = 0, E = D.getNumTypeObjects(); I != E; ++I) { 4277 DeclaratorChunk &Chunk = D.getTypeObject(I); 4278 4279 // The only type information in the declarator which can come 4280 // before the declaration name is the base type of a member 4281 // pointer. 4282 if (Chunk.Kind != DeclaratorChunk::MemberPointer) 4283 continue; 4284 4285 // Rebuild the scope specifier in-place. 4286 CXXScopeSpec &SS = Chunk.Mem.Scope(); 4287 if (S.RebuildNestedNameSpecifierInCurrentInstantiation(SS)) 4288 return true; 4289 } 4290 4291 return false; 4292 } 4293 4294 Decl *Sema::ActOnDeclarator(Scope *S, Declarator &D) { 4295 D.setFunctionDefinitionKind(FDK_Declaration); 4296 Decl *Dcl = HandleDeclarator(S, D, MultiTemplateParamsArg()); 4297 4298 if (OriginalLexicalContext && OriginalLexicalContext->isObjCContainer() && 4299 Dcl && Dcl->getDeclContext()->isFileContext()) 4300 Dcl->setTopLevelDeclInObjCContainer(); 4301 4302 return Dcl; 4303 } 4304 4305 /// DiagnoseClassNameShadow - Implement C++ [class.mem]p13: 4306 /// If T is the name of a class, then each of the following shall have a 4307 /// name different from T: 4308 /// - every static data member of class T; 4309 /// - every member function of class T 4310 /// - every member of class T that is itself a type; 4311 /// \returns true if the declaration name violates these rules. 4312 bool Sema::DiagnoseClassNameShadow(DeclContext *DC, 4313 DeclarationNameInfo NameInfo) { 4314 DeclarationName Name = NameInfo.getName(); 4315 4316 if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(DC)) 4317 if (Record->getIdentifier() && Record->getDeclName() == Name) { 4318 Diag(NameInfo.getLoc(), diag::err_member_name_of_class) << Name; 4319 return true; 4320 } 4321 4322 return false; 4323 } 4324 4325 /// \brief Diagnose a declaration whose declarator-id has the given 4326 /// nested-name-specifier. 4327 /// 4328 /// \param SS The nested-name-specifier of the declarator-id. 4329 /// 4330 /// \param DC The declaration context to which the nested-name-specifier 4331 /// resolves. 4332 /// 4333 /// \param Name The name of the entity being declared. 4334 /// 4335 /// \param Loc The location of the name of the entity being declared. 4336 /// 4337 /// \returns true if we cannot safely recover from this error, false otherwise. 4338 bool Sema::diagnoseQualifiedDeclaration(CXXScopeSpec &SS, DeclContext *DC, 4339 DeclarationName Name, 4340 SourceLocation Loc) { 4341 DeclContext *Cur = CurContext; 4342 while (isa<LinkageSpecDecl>(Cur) || isa<CapturedDecl>(Cur)) 4343 Cur = Cur->getParent(); 4344 4345 // If the user provided a superfluous scope specifier that refers back to the 4346 // class in which the entity is already declared, diagnose and ignore it. 4347 // 4348 // class X { 4349 // void X::f(); 4350 // }; 4351 // 4352 // Note, it was once ill-formed to give redundant qualification in all 4353 // contexts, but that rule was removed by DR482. 4354 if (Cur->Equals(DC)) { 4355 if (Cur->isRecord()) { 4356 Diag(Loc, LangOpts.MicrosoftExt ? diag::warn_member_extra_qualification 4357 : diag::err_member_extra_qualification) 4358 << Name << FixItHint::CreateRemoval(SS.getRange()); 4359 SS.clear(); 4360 } else { 4361 Diag(Loc, diag::warn_namespace_member_extra_qualification) << Name; 4362 } 4363 return false; 4364 } 4365 4366 // Check whether the qualifying scope encloses the scope of the original 4367 // declaration. 4368 if (!Cur->Encloses(DC)) { 4369 if (Cur->isRecord()) 4370 Diag(Loc, diag::err_member_qualification) 4371 << Name << SS.getRange(); 4372 else if (isa<TranslationUnitDecl>(DC)) 4373 Diag(Loc, diag::err_invalid_declarator_global_scope) 4374 << Name << SS.getRange(); 4375 else if (isa<FunctionDecl>(Cur)) 4376 Diag(Loc, diag::err_invalid_declarator_in_function) 4377 << Name << SS.getRange(); 4378 else if (isa<BlockDecl>(Cur)) 4379 Diag(Loc, diag::err_invalid_declarator_in_block) 4380 << Name << SS.getRange(); 4381 else 4382 Diag(Loc, diag::err_invalid_declarator_scope) 4383 << Name << cast<NamedDecl>(Cur) << cast<NamedDecl>(DC) << SS.getRange(); 4384 4385 return true; 4386 } 4387 4388 if (Cur->isRecord()) { 4389 // Cannot qualify members within a class. 4390 Diag(Loc, diag::err_member_qualification) 4391 << Name << SS.getRange(); 4392 SS.clear(); 4393 4394 // C++ constructors and destructors with incorrect scopes can break 4395 // our AST invariants by having the wrong underlying types. If 4396 // that's the case, then drop this declaration entirely. 4397 if ((Name.getNameKind() == DeclarationName::CXXConstructorName || 4398 Name.getNameKind() == DeclarationName::CXXDestructorName) && 4399 !Context.hasSameType(Name.getCXXNameType(), 4400 Context.getTypeDeclType(cast<CXXRecordDecl>(Cur)))) 4401 return true; 4402 4403 return false; 4404 } 4405 4406 // C++11 [dcl.meaning]p1: 4407 // [...] "The nested-name-specifier of the qualified declarator-id shall 4408 // not begin with a decltype-specifer" 4409 NestedNameSpecifierLoc SpecLoc(SS.getScopeRep(), SS.location_data()); 4410 while (SpecLoc.getPrefix()) 4411 SpecLoc = SpecLoc.getPrefix(); 4412 if (dyn_cast_or_null<DecltypeType>( 4413 SpecLoc.getNestedNameSpecifier()->getAsType())) 4414 Diag(Loc, diag::err_decltype_in_declarator) 4415 << SpecLoc.getTypeLoc().getSourceRange(); 4416 4417 return false; 4418 } 4419 4420 NamedDecl *Sema::HandleDeclarator(Scope *S, Declarator &D, 4421 MultiTemplateParamsArg TemplateParamLists) { 4422 // TODO: consider using NameInfo for diagnostic. 4423 DeclarationNameInfo NameInfo = GetNameForDeclarator(D); 4424 DeclarationName Name = NameInfo.getName(); 4425 4426 // All of these full declarators require an identifier. If it doesn't have 4427 // one, the ParsedFreeStandingDeclSpec action should be used. 4428 if (!Name) { 4429 if (!D.isInvalidType()) // Reject this if we think it is valid. 4430 Diag(D.getDeclSpec().getLocStart(), 4431 diag::err_declarator_need_ident) 4432 << D.getDeclSpec().getSourceRange() << D.getSourceRange(); 4433 return nullptr; 4434 } else if (DiagnoseUnexpandedParameterPack(NameInfo, UPPC_DeclarationType)) 4435 return nullptr; 4436 4437 // The scope passed in may not be a decl scope. Zip up the scope tree until 4438 // we find one that is. 4439 while ((S->getFlags() & Scope::DeclScope) == 0 || 4440 (S->getFlags() & Scope::TemplateParamScope) != 0) 4441 S = S->getParent(); 4442 4443 DeclContext *DC = CurContext; 4444 if (D.getCXXScopeSpec().isInvalid()) 4445 D.setInvalidType(); 4446 else if (D.getCXXScopeSpec().isSet()) { 4447 if (DiagnoseUnexpandedParameterPack(D.getCXXScopeSpec(), 4448 UPPC_DeclarationQualifier)) 4449 return nullptr; 4450 4451 bool EnteringContext = !D.getDeclSpec().isFriendSpecified(); 4452 DC = computeDeclContext(D.getCXXScopeSpec(), EnteringContext); 4453 if (!DC || isa<EnumDecl>(DC)) { 4454 // If we could not compute the declaration context, it's because the 4455 // declaration context is dependent but does not refer to a class, 4456 // class template, or class template partial specialization. Complain 4457 // and return early, to avoid the coming semantic disaster. 4458 Diag(D.getIdentifierLoc(), 4459 diag::err_template_qualified_declarator_no_match) 4460 << D.getCXXScopeSpec().getScopeRep() 4461 << D.getCXXScopeSpec().getRange(); 4462 return nullptr; 4463 } 4464 bool IsDependentContext = DC->isDependentContext(); 4465 4466 if (!IsDependentContext && 4467 RequireCompleteDeclContext(D.getCXXScopeSpec(), DC)) 4468 return nullptr; 4469 4470 if (isa<CXXRecordDecl>(DC) && !cast<CXXRecordDecl>(DC)->hasDefinition()) { 4471 Diag(D.getIdentifierLoc(), 4472 diag::err_member_def_undefined_record) 4473 << Name << DC << D.getCXXScopeSpec().getRange(); 4474 D.setInvalidType(); 4475 } else if (!D.getDeclSpec().isFriendSpecified()) { 4476 if (diagnoseQualifiedDeclaration(D.getCXXScopeSpec(), DC, 4477 Name, D.getIdentifierLoc())) { 4478 if (DC->isRecord()) 4479 return nullptr; 4480 4481 D.setInvalidType(); 4482 } 4483 } 4484 4485 // Check whether we need to rebuild the type of the given 4486 // declaration in the current instantiation. 4487 if (EnteringContext && IsDependentContext && 4488 TemplateParamLists.size() != 0) { 4489 ContextRAII SavedContext(*this, DC); 4490 if (RebuildDeclaratorInCurrentInstantiation(*this, D, Name)) 4491 D.setInvalidType(); 4492 } 4493 } 4494 4495 if (DiagnoseClassNameShadow(DC, NameInfo)) 4496 // If this is a typedef, we'll end up spewing multiple diagnostics. 4497 // Just return early; it's safer. 4498 if (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_typedef) 4499 return nullptr; 4500 4501 TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S); 4502 QualType R = TInfo->getType(); 4503 4504 if (DiagnoseUnexpandedParameterPack(D.getIdentifierLoc(), TInfo, 4505 UPPC_DeclarationType)) 4506 D.setInvalidType(); 4507 4508 LookupResult Previous(*this, NameInfo, LookupOrdinaryName, 4509 ForRedeclaration); 4510 4511 // See if this is a redefinition of a variable in the same scope. 4512 if (!D.getCXXScopeSpec().isSet()) { 4513 bool IsLinkageLookup = false; 4514 bool CreateBuiltins = false; 4515 4516 // If the declaration we're planning to build will be a function 4517 // or object with linkage, then look for another declaration with 4518 // linkage (C99 6.2.2p4-5 and C++ [basic.link]p6). 4519 // 4520 // If the declaration we're planning to build will be declared with 4521 // external linkage in the translation unit, create any builtin with 4522 // the same name. 4523 if (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_typedef) 4524 /* Do nothing*/; 4525 else if (CurContext->isFunctionOrMethod() && 4526 (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_extern || 4527 R->isFunctionType())) { 4528 IsLinkageLookup = true; 4529 CreateBuiltins = 4530 CurContext->getEnclosingNamespaceContext()->isTranslationUnit(); 4531 } else if (CurContext->getRedeclContext()->isTranslationUnit() && 4532 D.getDeclSpec().getStorageClassSpec() != DeclSpec::SCS_static) 4533 CreateBuiltins = true; 4534 4535 if (IsLinkageLookup) 4536 Previous.clear(LookupRedeclarationWithLinkage); 4537 4538 LookupName(Previous, S, CreateBuiltins); 4539 } else { // Something like "int foo::x;" 4540 LookupQualifiedName(Previous, DC); 4541 4542 // C++ [dcl.meaning]p1: 4543 // When the declarator-id is qualified, the declaration shall refer to a 4544 // previously declared member of the class or namespace to which the 4545 // qualifier refers (or, in the case of a namespace, of an element of the 4546 // inline namespace set of that namespace (7.3.1)) or to a specialization 4547 // thereof; [...] 4548 // 4549 // Note that we already checked the context above, and that we do not have 4550 // enough information to make sure that Previous contains the declaration 4551 // we want to match. For example, given: 4552 // 4553 // class X { 4554 // void f(); 4555 // void f(float); 4556 // }; 4557 // 4558 // void X::f(int) { } // ill-formed 4559 // 4560 // In this case, Previous will point to the overload set 4561 // containing the two f's declared in X, but neither of them 4562 // matches. 4563 4564 // C++ [dcl.meaning]p1: 4565 // [...] the member shall not merely have been introduced by a 4566 // using-declaration in the scope of the class or namespace nominated by 4567 // the nested-name-specifier of the declarator-id. 4568 RemoveUsingDecls(Previous); 4569 } 4570 4571 if (Previous.isSingleResult() && 4572 Previous.getFoundDecl()->isTemplateParameter()) { 4573 // Maybe we will complain about the shadowed template parameter. 4574 if (!D.isInvalidType()) 4575 DiagnoseTemplateParameterShadow(D.getIdentifierLoc(), 4576 Previous.getFoundDecl()); 4577 4578 // Just pretend that we didn't see the previous declaration. 4579 Previous.clear(); 4580 } 4581 4582 // In C++, the previous declaration we find might be a tag type 4583 // (class or enum). In this case, the new declaration will hide the 4584 // tag type. Note that this does does not apply if we're declaring a 4585 // typedef (C++ [dcl.typedef]p4). 4586 if (Previous.isSingleTagDecl() && 4587 D.getDeclSpec().getStorageClassSpec() != DeclSpec::SCS_typedef) 4588 Previous.clear(); 4589 4590 // Check that there are no default arguments other than in the parameters 4591 // of a function declaration (C++ only). 4592 if (getLangOpts().CPlusPlus) 4593 CheckExtraCXXDefaultArguments(D); 4594 4595 NamedDecl *New; 4596 4597 bool AddToScope = true; 4598 if (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_typedef) { 4599 if (TemplateParamLists.size()) { 4600 Diag(D.getIdentifierLoc(), diag::err_template_typedef); 4601 return nullptr; 4602 } 4603 4604 New = ActOnTypedefDeclarator(S, D, DC, TInfo, Previous); 4605 } else if (R->isFunctionType()) { 4606 New = ActOnFunctionDeclarator(S, D, DC, TInfo, Previous, 4607 TemplateParamLists, 4608 AddToScope); 4609 } else { 4610 New = ActOnVariableDeclarator(S, D, DC, TInfo, Previous, TemplateParamLists, 4611 AddToScope); 4612 } 4613 4614 if (!New) 4615 return nullptr; 4616 4617 // If this has an identifier and is not an invalid redeclaration or 4618 // function template specialization, add it to the scope stack. 4619 if (New->getDeclName() && AddToScope && 4620 !(D.isRedeclaration() && New->isInvalidDecl())) { 4621 // Only make a locally-scoped extern declaration visible if it is the first 4622 // declaration of this entity. Qualified lookup for such an entity should 4623 // only find this declaration if there is no visible declaration of it. 4624 bool AddToContext = !D.isRedeclaration() || !New->isLocalExternDecl(); 4625 PushOnScopeChains(New, S, AddToContext); 4626 if (!AddToContext) 4627 CurContext->addHiddenDecl(New); 4628 } 4629 4630 return New; 4631 } 4632 4633 /// Helper method to turn variable array types into constant array 4634 /// types in certain situations which would otherwise be errors (for 4635 /// GCC compatibility). 4636 static QualType TryToFixInvalidVariablyModifiedType(QualType T, 4637 ASTContext &Context, 4638 bool &SizeIsNegative, 4639 llvm::APSInt &Oversized) { 4640 // This method tries to turn a variable array into a constant 4641 // array even when the size isn't an ICE. This is necessary 4642 // for compatibility with code that depends on gcc's buggy 4643 // constant expression folding, like struct {char x[(int)(char*)2];} 4644 SizeIsNegative = false; 4645 Oversized = 0; 4646 4647 if (T->isDependentType()) 4648 return QualType(); 4649 4650 QualifierCollector Qs; 4651 const Type *Ty = Qs.strip(T); 4652 4653 if (const PointerType* PTy = dyn_cast<PointerType>(Ty)) { 4654 QualType Pointee = PTy->getPointeeType(); 4655 QualType FixedType = 4656 TryToFixInvalidVariablyModifiedType(Pointee, Context, SizeIsNegative, 4657 Oversized); 4658 if (FixedType.isNull()) return FixedType; 4659 FixedType = Context.getPointerType(FixedType); 4660 return Qs.apply(Context, FixedType); 4661 } 4662 if (const ParenType* PTy = dyn_cast<ParenType>(Ty)) { 4663 QualType Inner = PTy->getInnerType(); 4664 QualType FixedType = 4665 TryToFixInvalidVariablyModifiedType(Inner, Context, SizeIsNegative, 4666 Oversized); 4667 if (FixedType.isNull()) return FixedType; 4668 FixedType = Context.getParenType(FixedType); 4669 return Qs.apply(Context, FixedType); 4670 } 4671 4672 const VariableArrayType* VLATy = dyn_cast<VariableArrayType>(T); 4673 if (!VLATy) 4674 return QualType(); 4675 // FIXME: We should probably handle this case 4676 if (VLATy->getElementType()->isVariablyModifiedType()) 4677 return QualType(); 4678 4679 llvm::APSInt Res; 4680 if (!VLATy->getSizeExpr() || 4681 !VLATy->getSizeExpr()->EvaluateAsInt(Res, Context)) 4682 return QualType(); 4683 4684 // Check whether the array size is negative. 4685 if (Res.isSigned() && Res.isNegative()) { 4686 SizeIsNegative = true; 4687 return QualType(); 4688 } 4689 4690 // Check whether the array is too large to be addressed. 4691 unsigned ActiveSizeBits 4692 = ConstantArrayType::getNumAddressingBits(Context, VLATy->getElementType(), 4693 Res); 4694 if (ActiveSizeBits > ConstantArrayType::getMaxSizeBits(Context)) { 4695 Oversized = Res; 4696 return QualType(); 4697 } 4698 4699 return Context.getConstantArrayType(VLATy->getElementType(), 4700 Res, ArrayType::Normal, 0); 4701 } 4702 4703 static void 4704 FixInvalidVariablyModifiedTypeLoc(TypeLoc SrcTL, TypeLoc DstTL) { 4705 if (PointerTypeLoc SrcPTL = SrcTL.getAs<PointerTypeLoc>()) { 4706 PointerTypeLoc DstPTL = DstTL.castAs<PointerTypeLoc>(); 4707 FixInvalidVariablyModifiedTypeLoc(SrcPTL.getPointeeLoc(), 4708 DstPTL.getPointeeLoc()); 4709 DstPTL.setStarLoc(SrcPTL.getStarLoc()); 4710 return; 4711 } 4712 if (ParenTypeLoc SrcPTL = SrcTL.getAs<ParenTypeLoc>()) { 4713 ParenTypeLoc DstPTL = DstTL.castAs<ParenTypeLoc>(); 4714 FixInvalidVariablyModifiedTypeLoc(SrcPTL.getInnerLoc(), 4715 DstPTL.getInnerLoc()); 4716 DstPTL.setLParenLoc(SrcPTL.getLParenLoc()); 4717 DstPTL.setRParenLoc(SrcPTL.getRParenLoc()); 4718 return; 4719 } 4720 ArrayTypeLoc SrcATL = SrcTL.castAs<ArrayTypeLoc>(); 4721 ArrayTypeLoc DstATL = DstTL.castAs<ArrayTypeLoc>(); 4722 TypeLoc SrcElemTL = SrcATL.getElementLoc(); 4723 TypeLoc DstElemTL = DstATL.getElementLoc(); 4724 DstElemTL.initializeFullCopy(SrcElemTL); 4725 DstATL.setLBracketLoc(SrcATL.getLBracketLoc()); 4726 DstATL.setSizeExpr(SrcATL.getSizeExpr()); 4727 DstATL.setRBracketLoc(SrcATL.getRBracketLoc()); 4728 } 4729 4730 /// Helper method to turn variable array types into constant array 4731 /// types in certain situations which would otherwise be errors (for 4732 /// GCC compatibility). 4733 static TypeSourceInfo* 4734 TryToFixInvalidVariablyModifiedTypeSourceInfo(TypeSourceInfo *TInfo, 4735 ASTContext &Context, 4736 bool &SizeIsNegative, 4737 llvm::APSInt &Oversized) { 4738 QualType FixedTy 4739 = TryToFixInvalidVariablyModifiedType(TInfo->getType(), Context, 4740 SizeIsNegative, Oversized); 4741 if (FixedTy.isNull()) 4742 return nullptr; 4743 TypeSourceInfo *FixedTInfo = Context.getTrivialTypeSourceInfo(FixedTy); 4744 FixInvalidVariablyModifiedTypeLoc(TInfo->getTypeLoc(), 4745 FixedTInfo->getTypeLoc()); 4746 return FixedTInfo; 4747 } 4748 4749 /// \brief Register the given locally-scoped extern "C" declaration so 4750 /// that it can be found later for redeclarations. We include any extern "C" 4751 /// declaration that is not visible in the translation unit here, not just 4752 /// function-scope declarations. 4753 void 4754 Sema::RegisterLocallyScopedExternCDecl(NamedDecl *ND, Scope *S) { 4755 if (!getLangOpts().CPlusPlus && 4756 ND->getLexicalDeclContext()->getRedeclContext()->isTranslationUnit()) 4757 // Don't need to track declarations in the TU in C. 4758 return; 4759 4760 // Note that we have a locally-scoped external with this name. 4761 // FIXME: There can be multiple such declarations if they are functions marked 4762 // __attribute__((overloadable)) declared in function scope in C. 4763 LocallyScopedExternCDecls[ND->getDeclName()] = ND; 4764 } 4765 4766 NamedDecl *Sema::findLocallyScopedExternCDecl(DeclarationName Name) { 4767 if (ExternalSource) { 4768 // Load locally-scoped external decls from the external source. 4769 // FIXME: This is inefficient. Maybe add a DeclContext for extern "C" decls? 4770 SmallVector<NamedDecl *, 4> Decls; 4771 ExternalSource->ReadLocallyScopedExternCDecls(Decls); 4772 for (unsigned I = 0, N = Decls.size(); I != N; ++I) { 4773 llvm::DenseMap<DeclarationName, NamedDecl *>::iterator Pos 4774 = LocallyScopedExternCDecls.find(Decls[I]->getDeclName()); 4775 if (Pos == LocallyScopedExternCDecls.end()) 4776 LocallyScopedExternCDecls[Decls[I]->getDeclName()] = Decls[I]; 4777 } 4778 } 4779 4780 NamedDecl *D = LocallyScopedExternCDecls.lookup(Name); 4781 return D ? D->getMostRecentDecl() : nullptr; 4782 } 4783 4784 /// \brief Diagnose function specifiers on a declaration of an identifier that 4785 /// does not identify a function. 4786 void Sema::DiagnoseFunctionSpecifiers(const DeclSpec &DS) { 4787 // FIXME: We should probably indicate the identifier in question to avoid 4788 // confusion for constructs like "inline int a(), b;" 4789 if (DS.isInlineSpecified()) 4790 Diag(DS.getInlineSpecLoc(), 4791 diag::err_inline_non_function); 4792 4793 if (DS.isVirtualSpecified()) 4794 Diag(DS.getVirtualSpecLoc(), 4795 diag::err_virtual_non_function); 4796 4797 if (DS.isExplicitSpecified()) 4798 Diag(DS.getExplicitSpecLoc(), 4799 diag::err_explicit_non_function); 4800 4801 if (DS.isNoreturnSpecified()) 4802 Diag(DS.getNoreturnSpecLoc(), 4803 diag::err_noreturn_non_function); 4804 } 4805 4806 NamedDecl* 4807 Sema::ActOnTypedefDeclarator(Scope* S, Declarator& D, DeclContext* DC, 4808 TypeSourceInfo *TInfo, LookupResult &Previous) { 4809 // Typedef declarators cannot be qualified (C++ [dcl.meaning]p1). 4810 if (D.getCXXScopeSpec().isSet()) { 4811 Diag(D.getIdentifierLoc(), diag::err_qualified_typedef_declarator) 4812 << D.getCXXScopeSpec().getRange(); 4813 D.setInvalidType(); 4814 // Pretend we didn't see the scope specifier. 4815 DC = CurContext; 4816 Previous.clear(); 4817 } 4818 4819 DiagnoseFunctionSpecifiers(D.getDeclSpec()); 4820 4821 if (D.getDeclSpec().isConstexprSpecified()) 4822 Diag(D.getDeclSpec().getConstexprSpecLoc(), diag::err_invalid_constexpr) 4823 << 1; 4824 4825 if (D.getName().Kind != UnqualifiedId::IK_Identifier) { 4826 Diag(D.getName().StartLocation, diag::err_typedef_not_identifier) 4827 << D.getName().getSourceRange(); 4828 return nullptr; 4829 } 4830 4831 TypedefDecl *NewTD = ParseTypedefDecl(S, D, TInfo->getType(), TInfo); 4832 if (!NewTD) return nullptr; 4833 4834 // Handle attributes prior to checking for duplicates in MergeVarDecl 4835 ProcessDeclAttributes(S, NewTD, D); 4836 4837 CheckTypedefForVariablyModifiedType(S, NewTD); 4838 4839 bool Redeclaration = D.isRedeclaration(); 4840 NamedDecl *ND = ActOnTypedefNameDecl(S, DC, NewTD, Previous, Redeclaration); 4841 D.setRedeclaration(Redeclaration); 4842 return ND; 4843 } 4844 4845 void 4846 Sema::CheckTypedefForVariablyModifiedType(Scope *S, TypedefNameDecl *NewTD) { 4847 // C99 6.7.7p2: If a typedef name specifies a variably modified type 4848 // then it shall have block scope. 4849 // Note that variably modified types must be fixed before merging the decl so 4850 // that redeclarations will match. 4851 TypeSourceInfo *TInfo = NewTD->getTypeSourceInfo(); 4852 QualType T = TInfo->getType(); 4853 if (T->isVariablyModifiedType()) { 4854 getCurFunction()->setHasBranchProtectedScope(); 4855 4856 if (S->getFnParent() == nullptr) { 4857 bool SizeIsNegative; 4858 llvm::APSInt Oversized; 4859 TypeSourceInfo *FixedTInfo = 4860 TryToFixInvalidVariablyModifiedTypeSourceInfo(TInfo, Context, 4861 SizeIsNegative, 4862 Oversized); 4863 if (FixedTInfo) { 4864 Diag(NewTD->getLocation(), diag::warn_illegal_constant_array_size); 4865 NewTD->setTypeSourceInfo(FixedTInfo); 4866 } else { 4867 if (SizeIsNegative) 4868 Diag(NewTD->getLocation(), diag::err_typecheck_negative_array_size); 4869 else if (T->isVariableArrayType()) 4870 Diag(NewTD->getLocation(), diag::err_vla_decl_in_file_scope); 4871 else if (Oversized.getBoolValue()) 4872 Diag(NewTD->getLocation(), diag::err_array_too_large) 4873 << Oversized.toString(10); 4874 else 4875 Diag(NewTD->getLocation(), diag::err_vm_decl_in_file_scope); 4876 NewTD->setInvalidDecl(); 4877 } 4878 } 4879 } 4880 } 4881 4882 4883 /// ActOnTypedefNameDecl - Perform semantic checking for a declaration which 4884 /// declares a typedef-name, either using the 'typedef' type specifier or via 4885 /// a C++0x [dcl.typedef]p2 alias-declaration: 'using T = A;'. 4886 NamedDecl* 4887 Sema::ActOnTypedefNameDecl(Scope *S, DeclContext *DC, TypedefNameDecl *NewTD, 4888 LookupResult &Previous, bool &Redeclaration) { 4889 // Merge the decl with the existing one if appropriate. If the decl is 4890 // in an outer scope, it isn't the same thing. 4891 FilterLookupForScope(Previous, DC, S, /*ConsiderLinkage*/false, 4892 /*AllowInlineNamespace*/false); 4893 filterNonConflictingPreviousTypedefDecls(Context, NewTD, Previous); 4894 if (!Previous.empty()) { 4895 Redeclaration = true; 4896 MergeTypedefNameDecl(NewTD, Previous); 4897 } 4898 4899 // If this is the C FILE type, notify the AST context. 4900 if (IdentifierInfo *II = NewTD->getIdentifier()) 4901 if (!NewTD->isInvalidDecl() && 4902 NewTD->getDeclContext()->getRedeclContext()->isTranslationUnit()) { 4903 if (II->isStr("FILE")) 4904 Context.setFILEDecl(NewTD); 4905 else if (II->isStr("jmp_buf")) 4906 Context.setjmp_bufDecl(NewTD); 4907 else if (II->isStr("sigjmp_buf")) 4908 Context.setsigjmp_bufDecl(NewTD); 4909 else if (II->isStr("ucontext_t")) 4910 Context.setucontext_tDecl(NewTD); 4911 } 4912 4913 return NewTD; 4914 } 4915 4916 /// \brief Determines whether the given declaration is an out-of-scope 4917 /// previous declaration. 4918 /// 4919 /// This routine should be invoked when name lookup has found a 4920 /// previous declaration (PrevDecl) that is not in the scope where a 4921 /// new declaration by the same name is being introduced. If the new 4922 /// declaration occurs in a local scope, previous declarations with 4923 /// linkage may still be considered previous declarations (C99 4924 /// 6.2.2p4-5, C++ [basic.link]p6). 4925 /// 4926 /// \param PrevDecl the previous declaration found by name 4927 /// lookup 4928 /// 4929 /// \param DC the context in which the new declaration is being 4930 /// declared. 4931 /// 4932 /// \returns true if PrevDecl is an out-of-scope previous declaration 4933 /// for a new delcaration with the same name. 4934 static bool 4935 isOutOfScopePreviousDeclaration(NamedDecl *PrevDecl, DeclContext *DC, 4936 ASTContext &Context) { 4937 if (!PrevDecl) 4938 return false; 4939 4940 if (!PrevDecl->hasLinkage()) 4941 return false; 4942 4943 if (Context.getLangOpts().CPlusPlus) { 4944 // C++ [basic.link]p6: 4945 // If there is a visible declaration of an entity with linkage 4946 // having the same name and type, ignoring entities declared 4947 // outside the innermost enclosing namespace scope, the block 4948 // scope declaration declares that same entity and receives the 4949 // linkage of the previous declaration. 4950 DeclContext *OuterContext = DC->getRedeclContext(); 4951 if (!OuterContext->isFunctionOrMethod()) 4952 // This rule only applies to block-scope declarations. 4953 return false; 4954 4955 DeclContext *PrevOuterContext = PrevDecl->getDeclContext(); 4956 if (PrevOuterContext->isRecord()) 4957 // We found a member function: ignore it. 4958 return false; 4959 4960 // Find the innermost enclosing namespace for the new and 4961 // previous declarations. 4962 OuterContext = OuterContext->getEnclosingNamespaceContext(); 4963 PrevOuterContext = PrevOuterContext->getEnclosingNamespaceContext(); 4964 4965 // The previous declaration is in a different namespace, so it 4966 // isn't the same function. 4967 if (!OuterContext->Equals(PrevOuterContext)) 4968 return false; 4969 } 4970 4971 return true; 4972 } 4973 4974 static void SetNestedNameSpecifier(DeclaratorDecl *DD, Declarator &D) { 4975 CXXScopeSpec &SS = D.getCXXScopeSpec(); 4976 if (!SS.isSet()) return; 4977 DD->setQualifierInfo(SS.getWithLocInContext(DD->getASTContext())); 4978 } 4979 4980 bool Sema::inferObjCARCLifetime(ValueDecl *decl) { 4981 QualType type = decl->getType(); 4982 Qualifiers::ObjCLifetime lifetime = type.getObjCLifetime(); 4983 if (lifetime == Qualifiers::OCL_Autoreleasing) { 4984 // Various kinds of declaration aren't allowed to be __autoreleasing. 4985 unsigned kind = -1U; 4986 if (VarDecl *var = dyn_cast<VarDecl>(decl)) { 4987 if (var->hasAttr<BlocksAttr>()) 4988 kind = 0; // __block 4989 else if (!var->hasLocalStorage()) 4990 kind = 1; // global 4991 } else if (isa<ObjCIvarDecl>(decl)) { 4992 kind = 3; // ivar 4993 } else if (isa<FieldDecl>(decl)) { 4994 kind = 2; // field 4995 } 4996 4997 if (kind != -1U) { 4998 Diag(decl->getLocation(), diag::err_arc_autoreleasing_var) 4999 << kind; 5000 } 5001 } else if (lifetime == Qualifiers::OCL_None) { 5002 // Try to infer lifetime. 5003 if (!type->isObjCLifetimeType()) 5004 return false; 5005 5006 lifetime = type->getObjCARCImplicitLifetime(); 5007 type = Context.getLifetimeQualifiedType(type, lifetime); 5008 decl->setType(type); 5009 } 5010 5011 if (VarDecl *var = dyn_cast<VarDecl>(decl)) { 5012 // Thread-local variables cannot have lifetime. 5013 if (lifetime && lifetime != Qualifiers::OCL_ExplicitNone && 5014 var->getTLSKind()) { 5015 Diag(var->getLocation(), diag::err_arc_thread_ownership) 5016 << var->getType(); 5017 return true; 5018 } 5019 } 5020 5021 return false; 5022 } 5023 5024 static void checkAttributesAfterMerging(Sema &S, NamedDecl &ND) { 5025 // Ensure that an auto decl is deduced otherwise the checks below might cache 5026 // the wrong linkage. 5027 assert(S.ParsingInitForAutoVars.count(&ND) == 0); 5028 5029 // 'weak' only applies to declarations with external linkage. 5030 if (WeakAttr *Attr = ND.getAttr<WeakAttr>()) { 5031 if (!ND.isExternallyVisible()) { 5032 S.Diag(Attr->getLocation(), diag::err_attribute_weak_static); 5033 ND.dropAttr<WeakAttr>(); 5034 } 5035 } 5036 if (WeakRefAttr *Attr = ND.getAttr<WeakRefAttr>()) { 5037 if (ND.isExternallyVisible()) { 5038 S.Diag(Attr->getLocation(), diag::err_attribute_weakref_not_static); 5039 ND.dropAttr<WeakRefAttr>(); 5040 } 5041 } 5042 5043 // 'selectany' only applies to externally visible varable declarations. 5044 // It does not apply to functions. 5045 if (SelectAnyAttr *Attr = ND.getAttr<SelectAnyAttr>()) { 5046 if (isa<FunctionDecl>(ND) || !ND.isExternallyVisible()) { 5047 S.Diag(Attr->getLocation(), diag::err_attribute_selectany_non_extern_data); 5048 ND.dropAttr<SelectAnyAttr>(); 5049 } 5050 } 5051 5052 // dll attributes require external linkage. 5053 if (const DLLImportAttr *Attr = ND.getAttr<DLLImportAttr>()) { 5054 if (!ND.isExternallyVisible()) { 5055 S.Diag(ND.getLocation(), diag::err_attribute_dll_not_extern) 5056 << &ND << Attr; 5057 ND.setInvalidDecl(); 5058 } 5059 } 5060 if (const DLLExportAttr *Attr = ND.getAttr<DLLExportAttr>()) { 5061 if (!ND.isExternallyVisible()) { 5062 S.Diag(ND.getLocation(), diag::err_attribute_dll_not_extern) 5063 << &ND << Attr; 5064 ND.setInvalidDecl(); 5065 } 5066 } 5067 } 5068 5069 static void checkDLLAttributeRedeclaration(Sema &S, NamedDecl *OldDecl, 5070 NamedDecl *NewDecl, 5071 bool IsSpecialization) { 5072 if (TemplateDecl *OldTD = dyn_cast<TemplateDecl>(OldDecl)) 5073 OldDecl = OldTD->getTemplatedDecl(); 5074 if (TemplateDecl *NewTD = dyn_cast<TemplateDecl>(NewDecl)) 5075 NewDecl = NewTD->getTemplatedDecl(); 5076 5077 if (!OldDecl || !NewDecl) 5078 return; 5079 5080 const DLLImportAttr *OldImportAttr = OldDecl->getAttr<DLLImportAttr>(); 5081 const DLLExportAttr *OldExportAttr = OldDecl->getAttr<DLLExportAttr>(); 5082 const DLLImportAttr *NewImportAttr = NewDecl->getAttr<DLLImportAttr>(); 5083 const DLLExportAttr *NewExportAttr = NewDecl->getAttr<DLLExportAttr>(); 5084 5085 // dllimport and dllexport are inheritable attributes so we have to exclude 5086 // inherited attribute instances. 5087 bool HasNewAttr = (NewImportAttr && !NewImportAttr->isInherited()) || 5088 (NewExportAttr && !NewExportAttr->isInherited()); 5089 5090 // A redeclaration is not allowed to add a dllimport or dllexport attribute, 5091 // the only exception being explicit specializations. 5092 // Implicitly generated declarations are also excluded for now because there 5093 // is no other way to switch these to use dllimport or dllexport. 5094 bool AddsAttr = !(OldImportAttr || OldExportAttr) && HasNewAttr; 5095 5096 if (AddsAttr && !IsSpecialization && !OldDecl->isImplicit()) { 5097 // If the declaration hasn't been used yet, allow with a warning for 5098 // free functions and global variables. 5099 bool JustWarn = false; 5100 if (!OldDecl->isUsed() && OldDecl->getDeclContext()->isFileContext()) { 5101 auto *VD = dyn_cast<VarDecl>(OldDecl); 5102 if (VD && !VD->getDescribedVarTemplate()) 5103 JustWarn = true; 5104 auto *FD = dyn_cast<FunctionDecl>(OldDecl); 5105 if (FD && FD->getTemplatedKind() == FunctionDecl::TK_NonTemplate) 5106 JustWarn = true; 5107 } 5108 5109 unsigned DiagID = JustWarn ? diag::warn_attribute_dll_redeclaration 5110 : diag::err_attribute_dll_redeclaration; 5111 S.Diag(NewDecl->getLocation(), DiagID) 5112 << NewDecl 5113 << (NewImportAttr ? (const Attr *)NewImportAttr : NewExportAttr); 5114 S.Diag(OldDecl->getLocation(), diag::note_previous_declaration); 5115 if (!JustWarn) { 5116 NewDecl->setInvalidDecl(); 5117 return; 5118 } 5119 } 5120 5121 // A redeclaration is not allowed to drop a dllimport attribute, the only 5122 // exceptions being inline function definitions, local extern declarations, 5123 // and qualified friend declarations. 5124 // NB: MSVC converts such a declaration to dllexport. 5125 bool IsInline = false, IsStaticDataMember = false, IsQualifiedFriend = false; 5126 if (const auto *VD = dyn_cast<VarDecl>(NewDecl)) 5127 // Ignore static data because out-of-line definitions are diagnosed 5128 // separately. 5129 IsStaticDataMember = VD->isStaticDataMember(); 5130 else if (const auto *FD = dyn_cast<FunctionDecl>(NewDecl)) { 5131 IsInline = FD->isInlined(); 5132 IsQualifiedFriend = FD->getQualifier() && 5133 FD->getFriendObjectKind() == Decl::FOK_Declared; 5134 } 5135 5136 if (OldImportAttr && !HasNewAttr && !IsInline && !IsStaticDataMember && 5137 !NewDecl->isLocalExternDecl() && !IsQualifiedFriend) { 5138 S.Diag(NewDecl->getLocation(), 5139 diag::warn_redeclaration_without_attribute_prev_attribute_ignored) 5140 << NewDecl << OldImportAttr; 5141 S.Diag(OldDecl->getLocation(), diag::note_previous_declaration); 5142 S.Diag(OldImportAttr->getLocation(), diag::note_previous_attribute); 5143 OldDecl->dropAttr<DLLImportAttr>(); 5144 NewDecl->dropAttr<DLLImportAttr>(); 5145 } 5146 } 5147 5148 /// Given that we are within the definition of the given function, 5149 /// will that definition behave like C99's 'inline', where the 5150 /// definition is discarded except for optimization purposes? 5151 static bool isFunctionDefinitionDiscarded(Sema &S, FunctionDecl *FD) { 5152 // Try to avoid calling GetGVALinkageForFunction. 5153 5154 // All cases of this require the 'inline' keyword. 5155 if (!FD->isInlined()) return false; 5156 5157 // This is only possible in C++ with the gnu_inline attribute. 5158 if (S.getLangOpts().CPlusPlus && !FD->hasAttr<GNUInlineAttr>()) 5159 return false; 5160 5161 // Okay, go ahead and call the relatively-more-expensive function. 5162 5163 #ifndef NDEBUG 5164 // AST quite reasonably asserts that it's working on a function 5165 // definition. We don't really have a way to tell it that we're 5166 // currently defining the function, so just lie to it in +Asserts 5167 // builds. This is an awful hack. 5168 FD->setLazyBody(1); 5169 #endif 5170 5171 bool isC99Inline = 5172 S.Context.GetGVALinkageForFunction(FD) == GVA_AvailableExternally; 5173 5174 #ifndef NDEBUG 5175 FD->setLazyBody(0); 5176 #endif 5177 5178 return isC99Inline; 5179 } 5180 5181 /// Determine whether a variable is extern "C" prior to attaching 5182 /// an initializer. We can't just call isExternC() here, because that 5183 /// will also compute and cache whether the declaration is externally 5184 /// visible, which might change when we attach the initializer. 5185 /// 5186 /// This can only be used if the declaration is known to not be a 5187 /// redeclaration of an internal linkage declaration. 5188 /// 5189 /// For instance: 5190 /// 5191 /// auto x = []{}; 5192 /// 5193 /// Attaching the initializer here makes this declaration not externally 5194 /// visible, because its type has internal linkage. 5195 /// 5196 /// FIXME: This is a hack. 5197 template<typename T> 5198 static bool isIncompleteDeclExternC(Sema &S, const T *D) { 5199 if (S.getLangOpts().CPlusPlus) { 5200 // In C++, the overloadable attribute negates the effects of extern "C". 5201 if (!D->isInExternCContext() || D->template hasAttr<OverloadableAttr>()) 5202 return false; 5203 } 5204 return D->isExternC(); 5205 } 5206 5207 static bool shouldConsiderLinkage(const VarDecl *VD) { 5208 const DeclContext *DC = VD->getDeclContext()->getRedeclContext(); 5209 if (DC->isFunctionOrMethod()) 5210 return VD->hasExternalStorage(); 5211 if (DC->isFileContext()) 5212 return true; 5213 if (DC->isRecord()) 5214 return false; 5215 llvm_unreachable("Unexpected context"); 5216 } 5217 5218 static bool shouldConsiderLinkage(const FunctionDecl *FD) { 5219 const DeclContext *DC = FD->getDeclContext()->getRedeclContext(); 5220 if (DC->isFileContext() || DC->isFunctionOrMethod()) 5221 return true; 5222 if (DC->isRecord()) 5223 return false; 5224 llvm_unreachable("Unexpected context"); 5225 } 5226 5227 static bool hasParsedAttr(Scope *S, const AttributeList *AttrList, 5228 AttributeList::Kind Kind) { 5229 for (const AttributeList *L = AttrList; L; L = L->getNext()) 5230 if (L->getKind() == Kind) 5231 return true; 5232 return false; 5233 } 5234 5235 static bool hasParsedAttr(Scope *S, const Declarator &PD, 5236 AttributeList::Kind Kind) { 5237 // Check decl attributes on the DeclSpec. 5238 if (hasParsedAttr(S, PD.getDeclSpec().getAttributes().getList(), Kind)) 5239 return true; 5240 5241 // Walk the declarator structure, checking decl attributes that were in a type 5242 // position to the decl itself. 5243 for (unsigned I = 0, E = PD.getNumTypeObjects(); I != E; ++I) { 5244 if (hasParsedAttr(S, PD.getTypeObject(I).getAttrs(), Kind)) 5245 return true; 5246 } 5247 5248 // Finally, check attributes on the decl itself. 5249 return hasParsedAttr(S, PD.getAttributes(), Kind); 5250 } 5251 5252 /// Adjust the \c DeclContext for a function or variable that might be a 5253 /// function-local external declaration. 5254 bool Sema::adjustContextForLocalExternDecl(DeclContext *&DC) { 5255 if (!DC->isFunctionOrMethod()) 5256 return false; 5257 5258 // If this is a local extern function or variable declared within a function 5259 // template, don't add it into the enclosing namespace scope until it is 5260 // instantiated; it might have a dependent type right now. 5261 if (DC->isDependentContext()) 5262 return true; 5263 5264 // C++11 [basic.link]p7: 5265 // When a block scope declaration of an entity with linkage is not found to 5266 // refer to some other declaration, then that entity is a member of the 5267 // innermost enclosing namespace. 5268 // 5269 // Per C++11 [namespace.def]p6, the innermost enclosing namespace is a 5270 // semantically-enclosing namespace, not a lexically-enclosing one. 5271 while (!DC->isFileContext() && !isa<LinkageSpecDecl>(DC)) 5272 DC = DC->getParent(); 5273 return true; 5274 } 5275 5276 NamedDecl * 5277 Sema::ActOnVariableDeclarator(Scope *S, Declarator &D, DeclContext *DC, 5278 TypeSourceInfo *TInfo, LookupResult &Previous, 5279 MultiTemplateParamsArg TemplateParamLists, 5280 bool &AddToScope) { 5281 QualType R = TInfo->getType(); 5282 DeclarationName Name = GetNameForDeclarator(D).getName(); 5283 5284 DeclSpec::SCS SCSpec = D.getDeclSpec().getStorageClassSpec(); 5285 VarDecl::StorageClass SC = 5286 StorageClassSpecToVarDeclStorageClass(D.getDeclSpec()); 5287 5288 // dllimport globals without explicit storage class are treated as extern. We 5289 // have to change the storage class this early to get the right DeclContext. 5290 if (SC == SC_None && !DC->isRecord() && 5291 hasParsedAttr(S, D, AttributeList::AT_DLLImport) && 5292 !hasParsedAttr(S, D, AttributeList::AT_DLLExport)) 5293 SC = SC_Extern; 5294 5295 DeclContext *OriginalDC = DC; 5296 bool IsLocalExternDecl = SC == SC_Extern && 5297 adjustContextForLocalExternDecl(DC); 5298 5299 if (getLangOpts().OpenCL) { 5300 // OpenCL v1.0 s6.8.a.3: Pointers to functions are not allowed. 5301 QualType NR = R; 5302 while (NR->isPointerType()) { 5303 if (NR->isFunctionPointerType()) { 5304 Diag(D.getIdentifierLoc(), diag::err_opencl_function_pointer_variable); 5305 D.setInvalidType(); 5306 break; 5307 } 5308 NR = NR->getPointeeType(); 5309 } 5310 5311 if (!getOpenCLOptions().cl_khr_fp16) { 5312 // OpenCL v1.2 s6.1.1.1: reject declaring variables of the half and 5313 // half array type (unless the cl_khr_fp16 extension is enabled). 5314 if (Context.getBaseElementType(R)->isHalfType()) { 5315 Diag(D.getIdentifierLoc(), diag::err_opencl_half_declaration) << R; 5316 D.setInvalidType(); 5317 } 5318 } 5319 } 5320 5321 if (SCSpec == DeclSpec::SCS_mutable) { 5322 // mutable can only appear on non-static class members, so it's always 5323 // an error here 5324 Diag(D.getIdentifierLoc(), diag::err_mutable_nonmember); 5325 D.setInvalidType(); 5326 SC = SC_None; 5327 } 5328 5329 if (getLangOpts().CPlusPlus11 && SCSpec == DeclSpec::SCS_register && 5330 !D.getAsmLabel() && !getSourceManager().isInSystemMacro( 5331 D.getDeclSpec().getStorageClassSpecLoc())) { 5332 // In C++11, the 'register' storage class specifier is deprecated. 5333 // Suppress the warning in system macros, it's used in macros in some 5334 // popular C system headers, such as in glibc's htonl() macro. 5335 Diag(D.getDeclSpec().getStorageClassSpecLoc(), 5336 diag::warn_deprecated_register) 5337 << FixItHint::CreateRemoval(D.getDeclSpec().getStorageClassSpecLoc()); 5338 } 5339 5340 IdentifierInfo *II = Name.getAsIdentifierInfo(); 5341 if (!II) { 5342 Diag(D.getIdentifierLoc(), diag::err_bad_variable_name) 5343 << Name; 5344 return nullptr; 5345 } 5346 5347 DiagnoseFunctionSpecifiers(D.getDeclSpec()); 5348 5349 if (!DC->isRecord() && S->getFnParent() == nullptr) { 5350 // C99 6.9p2: The storage-class specifiers auto and register shall not 5351 // appear in the declaration specifiers in an external declaration. 5352 // Global Register+Asm is a GNU extension we support. 5353 if (SC == SC_Auto || (SC == SC_Register && !D.getAsmLabel())) { 5354 Diag(D.getIdentifierLoc(), diag::err_typecheck_sclass_fscope); 5355 D.setInvalidType(); 5356 } 5357 } 5358 5359 if (getLangOpts().OpenCL) { 5360 // Set up the special work-group-local storage class for variables in the 5361 // OpenCL __local address space. 5362 if (R.getAddressSpace() == LangAS::opencl_local) { 5363 SC = SC_OpenCLWorkGroupLocal; 5364 } 5365 5366 // OpenCL v1.2 s6.9.b p4: 5367 // The sampler type cannot be used with the __local and __global address 5368 // space qualifiers. 5369 if (R->isSamplerT() && (R.getAddressSpace() == LangAS::opencl_local || 5370 R.getAddressSpace() == LangAS::opencl_global)) { 5371 Diag(D.getIdentifierLoc(), diag::err_wrong_sampler_addressspace); 5372 } 5373 5374 // OpenCL 1.2 spec, p6.9 r: 5375 // The event type cannot be used to declare a program scope variable. 5376 // The event type cannot be used with the __local, __constant and __global 5377 // address space qualifiers. 5378 if (R->isEventT()) { 5379 if (S->getParent() == nullptr) { 5380 Diag(D.getLocStart(), diag::err_event_t_global_var); 5381 D.setInvalidType(); 5382 } 5383 5384 if (R.getAddressSpace()) { 5385 Diag(D.getLocStart(), diag::err_event_t_addr_space_qual); 5386 D.setInvalidType(); 5387 } 5388 } 5389 } 5390 5391 bool IsExplicitSpecialization = false; 5392 bool IsVariableTemplateSpecialization = false; 5393 bool IsPartialSpecialization = false; 5394 bool IsVariableTemplate = false; 5395 VarDecl *NewVD = nullptr; 5396 VarTemplateDecl *NewTemplate = nullptr; 5397 TemplateParameterList *TemplateParams = nullptr; 5398 if (!getLangOpts().CPlusPlus) { 5399 NewVD = VarDecl::Create(Context, DC, D.getLocStart(), 5400 D.getIdentifierLoc(), II, 5401 R, TInfo, SC); 5402 5403 if (D.isInvalidType()) 5404 NewVD->setInvalidDecl(); 5405 } else { 5406 bool Invalid = false; 5407 5408 if (DC->isRecord() && !CurContext->isRecord()) { 5409 // This is an out-of-line definition of a static data member. 5410 switch (SC) { 5411 case SC_None: 5412 break; 5413 case SC_Static: 5414 Diag(D.getDeclSpec().getStorageClassSpecLoc(), 5415 diag::err_static_out_of_line) 5416 << FixItHint::CreateRemoval(D.getDeclSpec().getStorageClassSpecLoc()); 5417 break; 5418 case SC_Auto: 5419 case SC_Register: 5420 case SC_Extern: 5421 // [dcl.stc] p2: The auto or register specifiers shall be applied only 5422 // to names of variables declared in a block or to function parameters. 5423 // [dcl.stc] p6: The extern specifier cannot be used in the declaration 5424 // of class members 5425 5426 Diag(D.getDeclSpec().getStorageClassSpecLoc(), 5427 diag::err_storage_class_for_static_member) 5428 << FixItHint::CreateRemoval(D.getDeclSpec().getStorageClassSpecLoc()); 5429 break; 5430 case SC_PrivateExtern: 5431 llvm_unreachable("C storage class in c++!"); 5432 case SC_OpenCLWorkGroupLocal: 5433 llvm_unreachable("OpenCL storage class in c++!"); 5434 } 5435 } 5436 5437 if (SC == SC_Static && CurContext->isRecord()) { 5438 if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(DC)) { 5439 if (RD->isLocalClass()) 5440 Diag(D.getIdentifierLoc(), 5441 diag::err_static_data_member_not_allowed_in_local_class) 5442 << Name << RD->getDeclName(); 5443 5444 // C++98 [class.union]p1: If a union contains a static data member, 5445 // the program is ill-formed. C++11 drops this restriction. 5446 if (RD->isUnion()) 5447 Diag(D.getIdentifierLoc(), 5448 getLangOpts().CPlusPlus11 5449 ? diag::warn_cxx98_compat_static_data_member_in_union 5450 : diag::ext_static_data_member_in_union) << Name; 5451 // We conservatively disallow static data members in anonymous structs. 5452 else if (!RD->getDeclName()) 5453 Diag(D.getIdentifierLoc(), 5454 diag::err_static_data_member_not_allowed_in_anon_struct) 5455 << Name << RD->isUnion(); 5456 } 5457 } 5458 5459 // Match up the template parameter lists with the scope specifier, then 5460 // determine whether we have a template or a template specialization. 5461 TemplateParams = MatchTemplateParametersToScopeSpecifier( 5462 D.getDeclSpec().getLocStart(), D.getIdentifierLoc(), 5463 D.getCXXScopeSpec(), 5464 D.getName().getKind() == UnqualifiedId::IK_TemplateId 5465 ? D.getName().TemplateId 5466 : nullptr, 5467 TemplateParamLists, 5468 /*never a friend*/ false, IsExplicitSpecialization, Invalid); 5469 5470 if (TemplateParams) { 5471 if (!TemplateParams->size() && 5472 D.getName().getKind() != UnqualifiedId::IK_TemplateId) { 5473 // There is an extraneous 'template<>' for this variable. Complain 5474 // about it, but allow the declaration of the variable. 5475 Diag(TemplateParams->getTemplateLoc(), 5476 diag::err_template_variable_noparams) 5477 << II 5478 << SourceRange(TemplateParams->getTemplateLoc(), 5479 TemplateParams->getRAngleLoc()); 5480 TemplateParams = nullptr; 5481 } else { 5482 if (D.getName().getKind() == UnqualifiedId::IK_TemplateId) { 5483 // This is an explicit specialization or a partial specialization. 5484 // FIXME: Check that we can declare a specialization here. 5485 IsVariableTemplateSpecialization = true; 5486 IsPartialSpecialization = TemplateParams->size() > 0; 5487 } else { // if (TemplateParams->size() > 0) 5488 // This is a template declaration. 5489 IsVariableTemplate = true; 5490 5491 // Check that we can declare a template here. 5492 if (CheckTemplateDeclScope(S, TemplateParams)) 5493 return nullptr; 5494 5495 // Only C++1y supports variable templates (N3651). 5496 Diag(D.getIdentifierLoc(), 5497 getLangOpts().CPlusPlus14 5498 ? diag::warn_cxx11_compat_variable_template 5499 : diag::ext_variable_template); 5500 } 5501 } 5502 } else { 5503 assert(D.getName().getKind() != UnqualifiedId::IK_TemplateId && 5504 "should have a 'template<>' for this decl"); 5505 } 5506 5507 if (IsVariableTemplateSpecialization) { 5508 SourceLocation TemplateKWLoc = 5509 TemplateParamLists.size() > 0 5510 ? TemplateParamLists[0]->getTemplateLoc() 5511 : SourceLocation(); 5512 DeclResult Res = ActOnVarTemplateSpecialization( 5513 S, D, TInfo, TemplateKWLoc, TemplateParams, SC, 5514 IsPartialSpecialization); 5515 if (Res.isInvalid()) 5516 return nullptr; 5517 NewVD = cast<VarDecl>(Res.get()); 5518 AddToScope = false; 5519 } else 5520 NewVD = VarDecl::Create(Context, DC, D.getLocStart(), 5521 D.getIdentifierLoc(), II, R, TInfo, SC); 5522 5523 // If this is supposed to be a variable template, create it as such. 5524 if (IsVariableTemplate) { 5525 NewTemplate = 5526 VarTemplateDecl::Create(Context, DC, D.getIdentifierLoc(), Name, 5527 TemplateParams, NewVD); 5528 NewVD->setDescribedVarTemplate(NewTemplate); 5529 } 5530 5531 // If this decl has an auto type in need of deduction, make a note of the 5532 // Decl so we can diagnose uses of it in its own initializer. 5533 if (D.getDeclSpec().containsPlaceholderType() && R->getContainedAutoType()) 5534 ParsingInitForAutoVars.insert(NewVD); 5535 5536 if (D.isInvalidType() || Invalid) { 5537 NewVD->setInvalidDecl(); 5538 if (NewTemplate) 5539 NewTemplate->setInvalidDecl(); 5540 } 5541 5542 SetNestedNameSpecifier(NewVD, D); 5543 5544 // If we have any template parameter lists that don't directly belong to 5545 // the variable (matching the scope specifier), store them. 5546 unsigned VDTemplateParamLists = TemplateParams ? 1 : 0; 5547 if (TemplateParamLists.size() > VDTemplateParamLists) 5548 NewVD->setTemplateParameterListsInfo( 5549 Context, TemplateParamLists.size() - VDTemplateParamLists, 5550 TemplateParamLists.data()); 5551 5552 if (D.getDeclSpec().isConstexprSpecified()) 5553 NewVD->setConstexpr(true); 5554 } 5555 5556 // Set the lexical context. If the declarator has a C++ scope specifier, the 5557 // lexical context will be different from the semantic context. 5558 NewVD->setLexicalDeclContext(CurContext); 5559 if (NewTemplate) 5560 NewTemplate->setLexicalDeclContext(CurContext); 5561 5562 if (IsLocalExternDecl) 5563 NewVD->setLocalExternDecl(); 5564 5565 if (DeclSpec::TSCS TSCS = D.getDeclSpec().getThreadStorageClassSpec()) { 5566 if (NewVD->hasLocalStorage()) { 5567 // C++11 [dcl.stc]p4: 5568 // When thread_local is applied to a variable of block scope the 5569 // storage-class-specifier static is implied if it does not appear 5570 // explicitly. 5571 // Core issue: 'static' is not implied if the variable is declared 5572 // 'extern'. 5573 if (SCSpec == DeclSpec::SCS_unspecified && 5574 TSCS == DeclSpec::TSCS_thread_local && 5575 DC->isFunctionOrMethod()) 5576 NewVD->setTSCSpec(TSCS); 5577 else 5578 Diag(D.getDeclSpec().getThreadStorageClassSpecLoc(), 5579 diag::err_thread_non_global) 5580 << DeclSpec::getSpecifierName(TSCS); 5581 } else if (!Context.getTargetInfo().isTLSSupported()) 5582 Diag(D.getDeclSpec().getThreadStorageClassSpecLoc(), 5583 diag::err_thread_unsupported); 5584 else 5585 NewVD->setTSCSpec(TSCS); 5586 } 5587 5588 // C99 6.7.4p3 5589 // An inline definition of a function with external linkage shall 5590 // not contain a definition of a modifiable object with static or 5591 // thread storage duration... 5592 // We only apply this when the function is required to be defined 5593 // elsewhere, i.e. when the function is not 'extern inline'. Note 5594 // that a local variable with thread storage duration still has to 5595 // be marked 'static'. Also note that it's possible to get these 5596 // semantics in C++ using __attribute__((gnu_inline)). 5597 if (SC == SC_Static && S->getFnParent() != nullptr && 5598 !NewVD->getType().isConstQualified()) { 5599 FunctionDecl *CurFD = getCurFunctionDecl(); 5600 if (CurFD && isFunctionDefinitionDiscarded(*this, CurFD)) { 5601 Diag(D.getDeclSpec().getStorageClassSpecLoc(), 5602 diag::warn_static_local_in_extern_inline); 5603 MaybeSuggestAddingStaticToDecl(CurFD); 5604 } 5605 } 5606 5607 if (D.getDeclSpec().isModulePrivateSpecified()) { 5608 if (IsVariableTemplateSpecialization) 5609 Diag(NewVD->getLocation(), diag::err_module_private_specialization) 5610 << (IsPartialSpecialization ? 1 : 0) 5611 << FixItHint::CreateRemoval( 5612 D.getDeclSpec().getModulePrivateSpecLoc()); 5613 else if (IsExplicitSpecialization) 5614 Diag(NewVD->getLocation(), diag::err_module_private_specialization) 5615 << 2 5616 << FixItHint::CreateRemoval(D.getDeclSpec().getModulePrivateSpecLoc()); 5617 else if (NewVD->hasLocalStorage()) 5618 Diag(NewVD->getLocation(), diag::err_module_private_local) 5619 << 0 << NewVD->getDeclName() 5620 << SourceRange(D.getDeclSpec().getModulePrivateSpecLoc()) 5621 << FixItHint::CreateRemoval(D.getDeclSpec().getModulePrivateSpecLoc()); 5622 else { 5623 NewVD->setModulePrivate(); 5624 if (NewTemplate) 5625 NewTemplate->setModulePrivate(); 5626 } 5627 } 5628 5629 // Handle attributes prior to checking for duplicates in MergeVarDecl 5630 ProcessDeclAttributes(S, NewVD, D); 5631 5632 if (getLangOpts().CUDA) { 5633 // CUDA B.2.5: "__shared__ and __constant__ variables have implied static 5634 // storage [duration]." 5635 if (SC == SC_None && S->getFnParent() != nullptr && 5636 (NewVD->hasAttr<CUDASharedAttr>() || 5637 NewVD->hasAttr<CUDAConstantAttr>())) { 5638 NewVD->setStorageClass(SC_Static); 5639 } 5640 } 5641 5642 // Ensure that dllimport globals without explicit storage class are treated as 5643 // extern. The storage class is set above using parsed attributes. Now we can 5644 // check the VarDecl itself. 5645 assert(!NewVD->hasAttr<DLLImportAttr>() || 5646 NewVD->getAttr<DLLImportAttr>()->isInherited() || 5647 NewVD->isStaticDataMember() || NewVD->getStorageClass() != SC_None); 5648 5649 // In auto-retain/release, infer strong retension for variables of 5650 // retainable type. 5651 if (getLangOpts().ObjCAutoRefCount && inferObjCARCLifetime(NewVD)) 5652 NewVD->setInvalidDecl(); 5653 5654 // Handle GNU asm-label extension (encoded as an attribute). 5655 if (Expr *E = (Expr*)D.getAsmLabel()) { 5656 // The parser guarantees this is a string. 5657 StringLiteral *SE = cast<StringLiteral>(E); 5658 StringRef Label = SE->getString(); 5659 if (S->getFnParent() != nullptr) { 5660 switch (SC) { 5661 case SC_None: 5662 case SC_Auto: 5663 Diag(E->getExprLoc(), diag::warn_asm_label_on_auto_decl) << Label; 5664 break; 5665 case SC_Register: 5666 // Local Named register 5667 if (!Context.getTargetInfo().isValidGCCRegisterName(Label)) 5668 Diag(E->getExprLoc(), diag::err_asm_unknown_register_name) << Label; 5669 break; 5670 case SC_Static: 5671 case SC_Extern: 5672 case SC_PrivateExtern: 5673 case SC_OpenCLWorkGroupLocal: 5674 break; 5675 } 5676 } else if (SC == SC_Register) { 5677 // Global Named register 5678 if (!Context.getTargetInfo().isValidGCCRegisterName(Label)) 5679 Diag(E->getExprLoc(), diag::err_asm_unknown_register_name) << Label; 5680 if (!R->isIntegralType(Context) && !R->isPointerType()) { 5681 Diag(D.getLocStart(), diag::err_asm_bad_register_type); 5682 NewVD->setInvalidDecl(true); 5683 } 5684 } 5685 5686 NewVD->addAttr(::new (Context) AsmLabelAttr(SE->getStrTokenLoc(0), 5687 Context, Label, 0)); 5688 } else if (!ExtnameUndeclaredIdentifiers.empty()) { 5689 llvm::DenseMap<IdentifierInfo*,AsmLabelAttr*>::iterator I = 5690 ExtnameUndeclaredIdentifiers.find(NewVD->getIdentifier()); 5691 if (I != ExtnameUndeclaredIdentifiers.end()) { 5692 NewVD->addAttr(I->second); 5693 ExtnameUndeclaredIdentifiers.erase(I); 5694 } 5695 } 5696 5697 // Diagnose shadowed variables before filtering for scope. 5698 if (D.getCXXScopeSpec().isEmpty()) 5699 CheckShadow(S, NewVD, Previous); 5700 5701 // Don't consider existing declarations that are in a different 5702 // scope and are out-of-semantic-context declarations (if the new 5703 // declaration has linkage). 5704 FilterLookupForScope(Previous, OriginalDC, S, shouldConsiderLinkage(NewVD), 5705 D.getCXXScopeSpec().isNotEmpty() || 5706 IsExplicitSpecialization || 5707 IsVariableTemplateSpecialization); 5708 5709 // Check whether the previous declaration is in the same block scope. This 5710 // affects whether we merge types with it, per C++11 [dcl.array]p3. 5711 if (getLangOpts().CPlusPlus && 5712 NewVD->isLocalVarDecl() && NewVD->hasExternalStorage()) 5713 NewVD->setPreviousDeclInSameBlockScope( 5714 Previous.isSingleResult() && !Previous.isShadowed() && 5715 isDeclInScope(Previous.getFoundDecl(), OriginalDC, S, false)); 5716 5717 if (!getLangOpts().CPlusPlus) { 5718 D.setRedeclaration(CheckVariableDeclaration(NewVD, Previous)); 5719 } else { 5720 // If this is an explicit specialization of a static data member, check it. 5721 if (IsExplicitSpecialization && !NewVD->isInvalidDecl() && 5722 CheckMemberSpecialization(NewVD, Previous)) 5723 NewVD->setInvalidDecl(); 5724 5725 // Merge the decl with the existing one if appropriate. 5726 if (!Previous.empty()) { 5727 if (Previous.isSingleResult() && 5728 isa<FieldDecl>(Previous.getFoundDecl()) && 5729 D.getCXXScopeSpec().isSet()) { 5730 // The user tried to define a non-static data member 5731 // out-of-line (C++ [dcl.meaning]p1). 5732 Diag(NewVD->getLocation(), diag::err_nonstatic_member_out_of_line) 5733 << D.getCXXScopeSpec().getRange(); 5734 Previous.clear(); 5735 NewVD->setInvalidDecl(); 5736 } 5737 } else if (D.getCXXScopeSpec().isSet()) { 5738 // No previous declaration in the qualifying scope. 5739 Diag(D.getIdentifierLoc(), diag::err_no_member) 5740 << Name << computeDeclContext(D.getCXXScopeSpec(), true) 5741 << D.getCXXScopeSpec().getRange(); 5742 NewVD->setInvalidDecl(); 5743 } 5744 5745 if (!IsVariableTemplateSpecialization) 5746 D.setRedeclaration(CheckVariableDeclaration(NewVD, Previous)); 5747 5748 if (NewTemplate) { 5749 VarTemplateDecl *PrevVarTemplate = 5750 NewVD->getPreviousDecl() 5751 ? NewVD->getPreviousDecl()->getDescribedVarTemplate() 5752 : nullptr; 5753 5754 // Check the template parameter list of this declaration, possibly 5755 // merging in the template parameter list from the previous variable 5756 // template declaration. 5757 if (CheckTemplateParameterList( 5758 TemplateParams, 5759 PrevVarTemplate ? PrevVarTemplate->getTemplateParameters() 5760 : nullptr, 5761 (D.getCXXScopeSpec().isSet() && DC && DC->isRecord() && 5762 DC->isDependentContext()) 5763 ? TPC_ClassTemplateMember 5764 : TPC_VarTemplate)) 5765 NewVD->setInvalidDecl(); 5766 5767 // If we are providing an explicit specialization of a static variable 5768 // template, make a note of that. 5769 if (PrevVarTemplate && 5770 PrevVarTemplate->getInstantiatedFromMemberTemplate()) 5771 PrevVarTemplate->setMemberSpecialization(); 5772 } 5773 } 5774 5775 ProcessPragmaWeak(S, NewVD); 5776 5777 // If this is the first declaration of an extern C variable, update 5778 // the map of such variables. 5779 if (NewVD->isFirstDecl() && !NewVD->isInvalidDecl() && 5780 isIncompleteDeclExternC(*this, NewVD)) 5781 RegisterLocallyScopedExternCDecl(NewVD, S); 5782 5783 if (getLangOpts().CPlusPlus && NewVD->isStaticLocal()) { 5784 Decl *ManglingContextDecl; 5785 if (MangleNumberingContext *MCtx = 5786 getCurrentMangleNumberContext(NewVD->getDeclContext(), 5787 ManglingContextDecl)) { 5788 Context.setManglingNumber( 5789 NewVD, MCtx->getManglingNumber(NewVD, S->getMSLocalManglingNumber())); 5790 Context.setStaticLocalNumber(NewVD, MCtx->getStaticLocalNumber(NewVD)); 5791 } 5792 } 5793 5794 if (D.isRedeclaration() && !Previous.empty()) { 5795 checkDLLAttributeRedeclaration( 5796 *this, dyn_cast<NamedDecl>(Previous.getRepresentativeDecl()), NewVD, 5797 IsExplicitSpecialization); 5798 } 5799 5800 if (NewTemplate) { 5801 if (NewVD->isInvalidDecl()) 5802 NewTemplate->setInvalidDecl(); 5803 ActOnDocumentableDecl(NewTemplate); 5804 return NewTemplate; 5805 } 5806 5807 return NewVD; 5808 } 5809 5810 /// \brief Diagnose variable or built-in function shadowing. Implements 5811 /// -Wshadow. 5812 /// 5813 /// This method is called whenever a VarDecl is added to a "useful" 5814 /// scope. 5815 /// 5816 /// \param S the scope in which the shadowing name is being declared 5817 /// \param R the lookup of the name 5818 /// 5819 void Sema::CheckShadow(Scope *S, VarDecl *D, const LookupResult& R) { 5820 // Return if warning is ignored. 5821 if (Diags.isIgnored(diag::warn_decl_shadow, R.getNameLoc())) 5822 return; 5823 5824 // Don't diagnose declarations at file scope. 5825 if (D->hasGlobalStorage()) 5826 return; 5827 5828 DeclContext *NewDC = D->getDeclContext(); 5829 5830 // Only diagnose if we're shadowing an unambiguous field or variable. 5831 if (R.getResultKind() != LookupResult::Found) 5832 return; 5833 5834 NamedDecl* ShadowedDecl = R.getFoundDecl(); 5835 if (!isa<VarDecl>(ShadowedDecl) && !isa<FieldDecl>(ShadowedDecl)) 5836 return; 5837 5838 // Fields are not shadowed by variables in C++ static methods. 5839 if (isa<FieldDecl>(ShadowedDecl)) 5840 if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(NewDC)) 5841 if (MD->isStatic()) 5842 return; 5843 5844 if (VarDecl *shadowedVar = dyn_cast<VarDecl>(ShadowedDecl)) 5845 if (shadowedVar->isExternC()) { 5846 // For shadowing external vars, make sure that we point to the global 5847 // declaration, not a locally scoped extern declaration. 5848 for (auto I : shadowedVar->redecls()) 5849 if (I->isFileVarDecl()) { 5850 ShadowedDecl = I; 5851 break; 5852 } 5853 } 5854 5855 DeclContext *OldDC = ShadowedDecl->getDeclContext(); 5856 5857 // Only warn about certain kinds of shadowing for class members. 5858 if (NewDC && NewDC->isRecord()) { 5859 // In particular, don't warn about shadowing non-class members. 5860 if (!OldDC->isRecord()) 5861 return; 5862 5863 // TODO: should we warn about static data members shadowing 5864 // static data members from base classes? 5865 5866 // TODO: don't diagnose for inaccessible shadowed members. 5867 // This is hard to do perfectly because we might friend the 5868 // shadowing context, but that's just a false negative. 5869 } 5870 5871 // Determine what kind of declaration we're shadowing. 5872 unsigned Kind; 5873 if (isa<RecordDecl>(OldDC)) { 5874 if (isa<FieldDecl>(ShadowedDecl)) 5875 Kind = 3; // field 5876 else 5877 Kind = 2; // static data member 5878 } else if (OldDC->isFileContext()) 5879 Kind = 1; // global 5880 else 5881 Kind = 0; // local 5882 5883 DeclarationName Name = R.getLookupName(); 5884 5885 // Emit warning and note. 5886 if (getSourceManager().isInSystemMacro(R.getNameLoc())) 5887 return; 5888 Diag(R.getNameLoc(), diag::warn_decl_shadow) << Name << Kind << OldDC; 5889 Diag(ShadowedDecl->getLocation(), diag::note_previous_declaration); 5890 } 5891 5892 /// \brief Check -Wshadow without the advantage of a previous lookup. 5893 void Sema::CheckShadow(Scope *S, VarDecl *D) { 5894 if (Diags.isIgnored(diag::warn_decl_shadow, D->getLocation())) 5895 return; 5896 5897 LookupResult R(*this, D->getDeclName(), D->getLocation(), 5898 Sema::LookupOrdinaryName, Sema::ForRedeclaration); 5899 LookupName(R, S); 5900 CheckShadow(S, D, R); 5901 } 5902 5903 /// Check for conflict between this global or extern "C" declaration and 5904 /// previous global or extern "C" declarations. This is only used in C++. 5905 template<typename T> 5906 static bool checkGlobalOrExternCConflict( 5907 Sema &S, const T *ND, bool IsGlobal, LookupResult &Previous) { 5908 assert(S.getLangOpts().CPlusPlus && "only C++ has extern \"C\""); 5909 NamedDecl *Prev = S.findLocallyScopedExternCDecl(ND->getDeclName()); 5910 5911 if (!Prev && IsGlobal && !isIncompleteDeclExternC(S, ND)) { 5912 // The common case: this global doesn't conflict with any extern "C" 5913 // declaration. 5914 return false; 5915 } 5916 5917 if (Prev) { 5918 if (!IsGlobal || isIncompleteDeclExternC(S, ND)) { 5919 // Both the old and new declarations have C language linkage. This is a 5920 // redeclaration. 5921 Previous.clear(); 5922 Previous.addDecl(Prev); 5923 return true; 5924 } 5925 5926 // This is a global, non-extern "C" declaration, and there is a previous 5927 // non-global extern "C" declaration. Diagnose if this is a variable 5928 // declaration. 5929 if (!isa<VarDecl>(ND)) 5930 return false; 5931 } else { 5932 // The declaration is extern "C". Check for any declaration in the 5933 // translation unit which might conflict. 5934 if (IsGlobal) { 5935 // We have already performed the lookup into the translation unit. 5936 IsGlobal = false; 5937 for (LookupResult::iterator I = Previous.begin(), E = Previous.end(); 5938 I != E; ++I) { 5939 if (isa<VarDecl>(*I)) { 5940 Prev = *I; 5941 break; 5942 } 5943 } 5944 } else { 5945 DeclContext::lookup_result R = 5946 S.Context.getTranslationUnitDecl()->lookup(ND->getDeclName()); 5947 for (DeclContext::lookup_result::iterator I = R.begin(), E = R.end(); 5948 I != E; ++I) { 5949 if (isa<VarDecl>(*I)) { 5950 Prev = *I; 5951 break; 5952 } 5953 // FIXME: If we have any other entity with this name in global scope, 5954 // the declaration is ill-formed, but that is a defect: it breaks the 5955 // 'stat' hack, for instance. Only variables can have mangled name 5956 // clashes with extern "C" declarations, so only they deserve a 5957 // diagnostic. 5958 } 5959 } 5960 5961 if (!Prev) 5962 return false; 5963 } 5964 5965 // Use the first declaration's location to ensure we point at something which 5966 // is lexically inside an extern "C" linkage-spec. 5967 assert(Prev && "should have found a previous declaration to diagnose"); 5968 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(Prev)) 5969 Prev = FD->getFirstDecl(); 5970 else 5971 Prev = cast<VarDecl>(Prev)->getFirstDecl(); 5972 5973 S.Diag(ND->getLocation(), diag::err_extern_c_global_conflict) 5974 << IsGlobal << ND; 5975 S.Diag(Prev->getLocation(), diag::note_extern_c_global_conflict) 5976 << IsGlobal; 5977 return false; 5978 } 5979 5980 /// Apply special rules for handling extern "C" declarations. Returns \c true 5981 /// if we have found that this is a redeclaration of some prior entity. 5982 /// 5983 /// Per C++ [dcl.link]p6: 5984 /// Two declarations [for a function or variable] with C language linkage 5985 /// with the same name that appear in different scopes refer to the same 5986 /// [entity]. An entity with C language linkage shall not be declared with 5987 /// the same name as an entity in global scope. 5988 template<typename T> 5989 static bool checkForConflictWithNonVisibleExternC(Sema &S, const T *ND, 5990 LookupResult &Previous) { 5991 if (!S.getLangOpts().CPlusPlus) { 5992 // In C, when declaring a global variable, look for a corresponding 'extern' 5993 // variable declared in function scope. We don't need this in C++, because 5994 // we find local extern decls in the surrounding file-scope DeclContext. 5995 if (ND->getDeclContext()->getRedeclContext()->isTranslationUnit()) { 5996 if (NamedDecl *Prev = S.findLocallyScopedExternCDecl(ND->getDeclName())) { 5997 Previous.clear(); 5998 Previous.addDecl(Prev); 5999 return true; 6000 } 6001 } 6002 return false; 6003 } 6004 6005 // A declaration in the translation unit can conflict with an extern "C" 6006 // declaration. 6007 if (ND->getDeclContext()->getRedeclContext()->isTranslationUnit()) 6008 return checkGlobalOrExternCConflict(S, ND, /*IsGlobal*/true, Previous); 6009 6010 // An extern "C" declaration can conflict with a declaration in the 6011 // translation unit or can be a redeclaration of an extern "C" declaration 6012 // in another scope. 6013 if (isIncompleteDeclExternC(S,ND)) 6014 return checkGlobalOrExternCConflict(S, ND, /*IsGlobal*/false, Previous); 6015 6016 // Neither global nor extern "C": nothing to do. 6017 return false; 6018 } 6019 6020 void Sema::CheckVariableDeclarationType(VarDecl *NewVD) { 6021 // If the decl is already known invalid, don't check it. 6022 if (NewVD->isInvalidDecl()) 6023 return; 6024 6025 TypeSourceInfo *TInfo = NewVD->getTypeSourceInfo(); 6026 QualType T = TInfo->getType(); 6027 6028 // Defer checking an 'auto' type until its initializer is attached. 6029 if (T->isUndeducedType()) 6030 return; 6031 6032 if (NewVD->hasAttrs()) 6033 CheckAlignasUnderalignment(NewVD); 6034 6035 if (T->isObjCObjectType()) { 6036 Diag(NewVD->getLocation(), diag::err_statically_allocated_object) 6037 << FixItHint::CreateInsertion(NewVD->getLocation(), "*"); 6038 T = Context.getObjCObjectPointerType(T); 6039 NewVD->setType(T); 6040 } 6041 6042 // Emit an error if an address space was applied to decl with local storage. 6043 // This includes arrays of objects with address space qualifiers, but not 6044 // automatic variables that point to other address spaces. 6045 // ISO/IEC TR 18037 S5.1.2 6046 if (NewVD->hasLocalStorage() && T.getAddressSpace() != 0) { 6047 Diag(NewVD->getLocation(), diag::err_as_qualified_auto_decl); 6048 NewVD->setInvalidDecl(); 6049 return; 6050 } 6051 6052 // OpenCL v1.2 s6.5 - All program scope variables must be declared in the 6053 // __constant address space. 6054 if (getLangOpts().OpenCL && NewVD->isFileVarDecl() 6055 && T.getAddressSpace() != LangAS::opencl_constant 6056 && !T->isSamplerT()){ 6057 Diag(NewVD->getLocation(), diag::err_opencl_global_invalid_addr_space); 6058 NewVD->setInvalidDecl(); 6059 return; 6060 } 6061 6062 // OpenCL v1.2 s6.8 -- The static qualifier is valid only in program 6063 // scope. 6064 if ((getLangOpts().OpenCLVersion >= 120) 6065 && NewVD->isStaticLocal()) { 6066 Diag(NewVD->getLocation(), diag::err_static_function_scope); 6067 NewVD->setInvalidDecl(); 6068 return; 6069 } 6070 6071 if (NewVD->hasLocalStorage() && T.isObjCGCWeak() 6072 && !NewVD->hasAttr<BlocksAttr>()) { 6073 if (getLangOpts().getGC() != LangOptions::NonGC) 6074 Diag(NewVD->getLocation(), diag::warn_gc_attribute_weak_on_local); 6075 else { 6076 assert(!getLangOpts().ObjCAutoRefCount); 6077 Diag(NewVD->getLocation(), diag::warn_attribute_weak_on_local); 6078 } 6079 } 6080 6081 bool isVM = T->isVariablyModifiedType(); 6082 if (isVM || NewVD->hasAttr<CleanupAttr>() || 6083 NewVD->hasAttr<BlocksAttr>()) 6084 getCurFunction()->setHasBranchProtectedScope(); 6085 6086 if ((isVM && NewVD->hasLinkage()) || 6087 (T->isVariableArrayType() && NewVD->hasGlobalStorage())) { 6088 bool SizeIsNegative; 6089 llvm::APSInt Oversized; 6090 TypeSourceInfo *FixedTInfo = 6091 TryToFixInvalidVariablyModifiedTypeSourceInfo(TInfo, Context, 6092 SizeIsNegative, Oversized); 6093 if (!FixedTInfo && T->isVariableArrayType()) { 6094 const VariableArrayType *VAT = Context.getAsVariableArrayType(T); 6095 // FIXME: This won't give the correct result for 6096 // int a[10][n]; 6097 SourceRange SizeRange = VAT->getSizeExpr()->getSourceRange(); 6098 6099 if (NewVD->isFileVarDecl()) 6100 Diag(NewVD->getLocation(), diag::err_vla_decl_in_file_scope) 6101 << SizeRange; 6102 else if (NewVD->isStaticLocal()) 6103 Diag(NewVD->getLocation(), diag::err_vla_decl_has_static_storage) 6104 << SizeRange; 6105 else 6106 Diag(NewVD->getLocation(), diag::err_vla_decl_has_extern_linkage) 6107 << SizeRange; 6108 NewVD->setInvalidDecl(); 6109 return; 6110 } 6111 6112 if (!FixedTInfo) { 6113 if (NewVD->isFileVarDecl()) 6114 Diag(NewVD->getLocation(), diag::err_vm_decl_in_file_scope); 6115 else 6116 Diag(NewVD->getLocation(), diag::err_vm_decl_has_extern_linkage); 6117 NewVD->setInvalidDecl(); 6118 return; 6119 } 6120 6121 Diag(NewVD->getLocation(), diag::warn_illegal_constant_array_size); 6122 NewVD->setType(FixedTInfo->getType()); 6123 NewVD->setTypeSourceInfo(FixedTInfo); 6124 } 6125 6126 if (T->isVoidType()) { 6127 // C++98 [dcl.stc]p5: The extern specifier can be applied only to the names 6128 // of objects and functions. 6129 if (NewVD->isThisDeclarationADefinition() || getLangOpts().CPlusPlus) { 6130 Diag(NewVD->getLocation(), diag::err_typecheck_decl_incomplete_type) 6131 << T; 6132 NewVD->setInvalidDecl(); 6133 return; 6134 } 6135 } 6136 6137 if (!NewVD->hasLocalStorage() && NewVD->hasAttr<BlocksAttr>()) { 6138 Diag(NewVD->getLocation(), diag::err_block_on_nonlocal); 6139 NewVD->setInvalidDecl(); 6140 return; 6141 } 6142 6143 if (isVM && NewVD->hasAttr<BlocksAttr>()) { 6144 Diag(NewVD->getLocation(), diag::err_block_on_vm); 6145 NewVD->setInvalidDecl(); 6146 return; 6147 } 6148 6149 if (NewVD->isConstexpr() && !T->isDependentType() && 6150 RequireLiteralType(NewVD->getLocation(), T, 6151 diag::err_constexpr_var_non_literal)) { 6152 NewVD->setInvalidDecl(); 6153 return; 6154 } 6155 } 6156 6157 /// \brief Perform semantic checking on a newly-created variable 6158 /// declaration. 6159 /// 6160 /// This routine performs all of the type-checking required for a 6161 /// variable declaration once it has been built. It is used both to 6162 /// check variables after they have been parsed and their declarators 6163 /// have been translated into a declaration, and to check variables 6164 /// that have been instantiated from a template. 6165 /// 6166 /// Sets NewVD->isInvalidDecl() if an error was encountered. 6167 /// 6168 /// Returns true if the variable declaration is a redeclaration. 6169 bool Sema::CheckVariableDeclaration(VarDecl *NewVD, LookupResult &Previous) { 6170 CheckVariableDeclarationType(NewVD); 6171 6172 // If the decl is already known invalid, don't check it. 6173 if (NewVD->isInvalidDecl()) 6174 return false; 6175 6176 // If we did not find anything by this name, look for a non-visible 6177 // extern "C" declaration with the same name. 6178 if (Previous.empty() && 6179 checkForConflictWithNonVisibleExternC(*this, NewVD, Previous)) 6180 Previous.setShadowed(); 6181 6182 // Filter out any non-conflicting previous declarations. 6183 filterNonConflictingPreviousDecls(Context, NewVD, Previous); 6184 6185 if (!Previous.empty()) { 6186 MergeVarDecl(NewVD, Previous); 6187 return true; 6188 } 6189 return false; 6190 } 6191 6192 /// \brief Data used with FindOverriddenMethod 6193 struct FindOverriddenMethodData { 6194 Sema *S; 6195 CXXMethodDecl *Method; 6196 }; 6197 6198 /// \brief Member lookup function that determines whether a given C++ 6199 /// method overrides a method in a base class, to be used with 6200 /// CXXRecordDecl::lookupInBases(). 6201 static bool FindOverriddenMethod(const CXXBaseSpecifier *Specifier, 6202 CXXBasePath &Path, 6203 void *UserData) { 6204 RecordDecl *BaseRecord = Specifier->getType()->getAs<RecordType>()->getDecl(); 6205 6206 FindOverriddenMethodData *Data 6207 = reinterpret_cast<FindOverriddenMethodData*>(UserData); 6208 6209 DeclarationName Name = Data->Method->getDeclName(); 6210 6211 // FIXME: Do we care about other names here too? 6212 if (Name.getNameKind() == DeclarationName::CXXDestructorName) { 6213 // We really want to find the base class destructor here. 6214 QualType T = Data->S->Context.getTypeDeclType(BaseRecord); 6215 CanQualType CT = Data->S->Context.getCanonicalType(T); 6216 6217 Name = Data->S->Context.DeclarationNames.getCXXDestructorName(CT); 6218 } 6219 6220 for (Path.Decls = BaseRecord->lookup(Name); 6221 !Path.Decls.empty(); 6222 Path.Decls = Path.Decls.slice(1)) { 6223 NamedDecl *D = Path.Decls.front(); 6224 if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(D)) { 6225 if (MD->isVirtual() && !Data->S->IsOverload(Data->Method, MD, false)) 6226 return true; 6227 } 6228 } 6229 6230 return false; 6231 } 6232 6233 namespace { 6234 enum OverrideErrorKind { OEK_All, OEK_NonDeleted, OEK_Deleted }; 6235 } 6236 /// \brief Report an error regarding overriding, along with any relevant 6237 /// overriden methods. 6238 /// 6239 /// \param DiagID the primary error to report. 6240 /// \param MD the overriding method. 6241 /// \param OEK which overrides to include as notes. 6242 static void ReportOverrides(Sema& S, unsigned DiagID, const CXXMethodDecl *MD, 6243 OverrideErrorKind OEK = OEK_All) { 6244 S.Diag(MD->getLocation(), DiagID) << MD->getDeclName(); 6245 for (CXXMethodDecl::method_iterator I = MD->begin_overridden_methods(), 6246 E = MD->end_overridden_methods(); 6247 I != E; ++I) { 6248 // This check (& the OEK parameter) could be replaced by a predicate, but 6249 // without lambdas that would be overkill. This is still nicer than writing 6250 // out the diag loop 3 times. 6251 if ((OEK == OEK_All) || 6252 (OEK == OEK_NonDeleted && !(*I)->isDeleted()) || 6253 (OEK == OEK_Deleted && (*I)->isDeleted())) 6254 S.Diag((*I)->getLocation(), diag::note_overridden_virtual_function); 6255 } 6256 } 6257 6258 /// AddOverriddenMethods - See if a method overrides any in the base classes, 6259 /// and if so, check that it's a valid override and remember it. 6260 bool Sema::AddOverriddenMethods(CXXRecordDecl *DC, CXXMethodDecl *MD) { 6261 // Look for virtual methods in base classes that this method might override. 6262 CXXBasePaths Paths; 6263 FindOverriddenMethodData Data; 6264 Data.Method = MD; 6265 Data.S = this; 6266 bool hasDeletedOverridenMethods = false; 6267 bool hasNonDeletedOverridenMethods = false; 6268 bool AddedAny = false; 6269 if (DC->lookupInBases(&FindOverriddenMethod, &Data, Paths)) { 6270 for (auto *I : Paths.found_decls()) { 6271 if (CXXMethodDecl *OldMD = dyn_cast<CXXMethodDecl>(I)) { 6272 MD->addOverriddenMethod(OldMD->getCanonicalDecl()); 6273 if (!CheckOverridingFunctionReturnType(MD, OldMD) && 6274 !CheckOverridingFunctionAttributes(MD, OldMD) && 6275 !CheckOverridingFunctionExceptionSpec(MD, OldMD) && 6276 !CheckIfOverriddenFunctionIsMarkedFinal(MD, OldMD)) { 6277 hasDeletedOverridenMethods |= OldMD->isDeleted(); 6278 hasNonDeletedOverridenMethods |= !OldMD->isDeleted(); 6279 AddedAny = true; 6280 } 6281 } 6282 } 6283 } 6284 6285 if (hasDeletedOverridenMethods && !MD->isDeleted()) { 6286 ReportOverrides(*this, diag::err_non_deleted_override, MD, OEK_Deleted); 6287 } 6288 if (hasNonDeletedOverridenMethods && MD->isDeleted()) { 6289 ReportOverrides(*this, diag::err_deleted_override, MD, OEK_NonDeleted); 6290 } 6291 6292 return AddedAny; 6293 } 6294 6295 namespace { 6296 // Struct for holding all of the extra arguments needed by 6297 // DiagnoseInvalidRedeclaration to call Sema::ActOnFunctionDeclarator. 6298 struct ActOnFDArgs { 6299 Scope *S; 6300 Declarator &D; 6301 MultiTemplateParamsArg TemplateParamLists; 6302 bool AddToScope; 6303 }; 6304 } 6305 6306 namespace { 6307 6308 // Callback to only accept typo corrections that have a non-zero edit distance. 6309 // Also only accept corrections that have the same parent decl. 6310 class DifferentNameValidatorCCC : public CorrectionCandidateCallback { 6311 public: 6312 DifferentNameValidatorCCC(ASTContext &Context, FunctionDecl *TypoFD, 6313 CXXRecordDecl *Parent) 6314 : Context(Context), OriginalFD(TypoFD), 6315 ExpectedParent(Parent ? Parent->getCanonicalDecl() : nullptr) {} 6316 6317 bool ValidateCandidate(const TypoCorrection &candidate) override { 6318 if (candidate.getEditDistance() == 0) 6319 return false; 6320 6321 SmallVector<unsigned, 1> MismatchedParams; 6322 for (TypoCorrection::const_decl_iterator CDecl = candidate.begin(), 6323 CDeclEnd = candidate.end(); 6324 CDecl != CDeclEnd; ++CDecl) { 6325 FunctionDecl *FD = dyn_cast<FunctionDecl>(*CDecl); 6326 6327 if (FD && !FD->hasBody() && 6328 hasSimilarParameters(Context, FD, OriginalFD, MismatchedParams)) { 6329 if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) { 6330 CXXRecordDecl *Parent = MD->getParent(); 6331 if (Parent && Parent->getCanonicalDecl() == ExpectedParent) 6332 return true; 6333 } else if (!ExpectedParent) { 6334 return true; 6335 } 6336 } 6337 } 6338 6339 return false; 6340 } 6341 6342 private: 6343 ASTContext &Context; 6344 FunctionDecl *OriginalFD; 6345 CXXRecordDecl *ExpectedParent; 6346 }; 6347 6348 } 6349 6350 /// \brief Generate diagnostics for an invalid function redeclaration. 6351 /// 6352 /// This routine handles generating the diagnostic messages for an invalid 6353 /// function redeclaration, including finding possible similar declarations 6354 /// or performing typo correction if there are no previous declarations with 6355 /// the same name. 6356 /// 6357 /// Returns a NamedDecl iff typo correction was performed and substituting in 6358 /// the new declaration name does not cause new errors. 6359 static NamedDecl *DiagnoseInvalidRedeclaration( 6360 Sema &SemaRef, LookupResult &Previous, FunctionDecl *NewFD, 6361 ActOnFDArgs &ExtraArgs, bool IsLocalFriend, Scope *S) { 6362 DeclarationName Name = NewFD->getDeclName(); 6363 DeclContext *NewDC = NewFD->getDeclContext(); 6364 SmallVector<unsigned, 1> MismatchedParams; 6365 SmallVector<std::pair<FunctionDecl *, unsigned>, 1> NearMatches; 6366 TypoCorrection Correction; 6367 bool IsDefinition = ExtraArgs.D.isFunctionDefinition(); 6368 unsigned DiagMsg = IsLocalFriend ? diag::err_no_matching_local_friend 6369 : diag::err_member_decl_does_not_match; 6370 LookupResult Prev(SemaRef, Name, NewFD->getLocation(), 6371 IsLocalFriend ? Sema::LookupLocalFriendName 6372 : Sema::LookupOrdinaryName, 6373 Sema::ForRedeclaration); 6374 6375 NewFD->setInvalidDecl(); 6376 if (IsLocalFriend) 6377 SemaRef.LookupName(Prev, S); 6378 else 6379 SemaRef.LookupQualifiedName(Prev, NewDC); 6380 assert(!Prev.isAmbiguous() && 6381 "Cannot have an ambiguity in previous-declaration lookup"); 6382 CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(NewFD); 6383 DifferentNameValidatorCCC Validator(SemaRef.Context, NewFD, 6384 MD ? MD->getParent() : nullptr); 6385 if (!Prev.empty()) { 6386 for (LookupResult::iterator Func = Prev.begin(), FuncEnd = Prev.end(); 6387 Func != FuncEnd; ++Func) { 6388 FunctionDecl *FD = dyn_cast<FunctionDecl>(*Func); 6389 if (FD && 6390 hasSimilarParameters(SemaRef.Context, FD, NewFD, MismatchedParams)) { 6391 // Add 1 to the index so that 0 can mean the mismatch didn't 6392 // involve a parameter 6393 unsigned ParamNum = 6394 MismatchedParams.empty() ? 0 : MismatchedParams.front() + 1; 6395 NearMatches.push_back(std::make_pair(FD, ParamNum)); 6396 } 6397 } 6398 // If the qualified name lookup yielded nothing, try typo correction 6399 } else if ((Correction = SemaRef.CorrectTypo( 6400 Prev.getLookupNameInfo(), Prev.getLookupKind(), S, 6401 &ExtraArgs.D.getCXXScopeSpec(), Validator, 6402 Sema::CTK_ErrorRecovery, IsLocalFriend ? nullptr : NewDC))) { 6403 // Set up everything for the call to ActOnFunctionDeclarator 6404 ExtraArgs.D.SetIdentifier(Correction.getCorrectionAsIdentifierInfo(), 6405 ExtraArgs.D.getIdentifierLoc()); 6406 Previous.clear(); 6407 Previous.setLookupName(Correction.getCorrection()); 6408 for (TypoCorrection::decl_iterator CDecl = Correction.begin(), 6409 CDeclEnd = Correction.end(); 6410 CDecl != CDeclEnd; ++CDecl) { 6411 FunctionDecl *FD = dyn_cast<FunctionDecl>(*CDecl); 6412 if (FD && !FD->hasBody() && 6413 hasSimilarParameters(SemaRef.Context, FD, NewFD, MismatchedParams)) { 6414 Previous.addDecl(FD); 6415 } 6416 } 6417 bool wasRedeclaration = ExtraArgs.D.isRedeclaration(); 6418 6419 NamedDecl *Result; 6420 // Retry building the function declaration with the new previous 6421 // declarations, and with errors suppressed. 6422 { 6423 // Trap errors. 6424 Sema::SFINAETrap Trap(SemaRef); 6425 6426 // TODO: Refactor ActOnFunctionDeclarator so that we can call only the 6427 // pieces need to verify the typo-corrected C++ declaration and hopefully 6428 // eliminate the need for the parameter pack ExtraArgs. 6429 Result = SemaRef.ActOnFunctionDeclarator( 6430 ExtraArgs.S, ExtraArgs.D, 6431 Correction.getCorrectionDecl()->getDeclContext(), 6432 NewFD->getTypeSourceInfo(), Previous, ExtraArgs.TemplateParamLists, 6433 ExtraArgs.AddToScope); 6434 6435 if (Trap.hasErrorOccurred()) 6436 Result = nullptr; 6437 } 6438 6439 if (Result) { 6440 // Determine which correction we picked. 6441 Decl *Canonical = Result->getCanonicalDecl(); 6442 for (LookupResult::iterator I = Previous.begin(), E = Previous.end(); 6443 I != E; ++I) 6444 if ((*I)->getCanonicalDecl() == Canonical) 6445 Correction.setCorrectionDecl(*I); 6446 6447 SemaRef.diagnoseTypo( 6448 Correction, 6449 SemaRef.PDiag(IsLocalFriend 6450 ? diag::err_no_matching_local_friend_suggest 6451 : diag::err_member_decl_does_not_match_suggest) 6452 << Name << NewDC << IsDefinition); 6453 return Result; 6454 } 6455 6456 // Pretend the typo correction never occurred 6457 ExtraArgs.D.SetIdentifier(Name.getAsIdentifierInfo(), 6458 ExtraArgs.D.getIdentifierLoc()); 6459 ExtraArgs.D.setRedeclaration(wasRedeclaration); 6460 Previous.clear(); 6461 Previous.setLookupName(Name); 6462 } 6463 6464 SemaRef.Diag(NewFD->getLocation(), DiagMsg) 6465 << Name << NewDC << IsDefinition << NewFD->getLocation(); 6466 6467 bool NewFDisConst = false; 6468 if (CXXMethodDecl *NewMD = dyn_cast<CXXMethodDecl>(NewFD)) 6469 NewFDisConst = NewMD->isConst(); 6470 6471 for (SmallVectorImpl<std::pair<FunctionDecl *, unsigned> >::iterator 6472 NearMatch = NearMatches.begin(), NearMatchEnd = NearMatches.end(); 6473 NearMatch != NearMatchEnd; ++NearMatch) { 6474 FunctionDecl *FD = NearMatch->first; 6475 CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD); 6476 bool FDisConst = MD && MD->isConst(); 6477 bool IsMember = MD || !IsLocalFriend; 6478 6479 // FIXME: These notes are poorly worded for the local friend case. 6480 if (unsigned Idx = NearMatch->second) { 6481 ParmVarDecl *FDParam = FD->getParamDecl(Idx-1); 6482 SourceLocation Loc = FDParam->getTypeSpecStartLoc(); 6483 if (Loc.isInvalid()) Loc = FD->getLocation(); 6484 SemaRef.Diag(Loc, IsMember ? diag::note_member_def_close_param_match 6485 : diag::note_local_decl_close_param_match) 6486 << Idx << FDParam->getType() 6487 << NewFD->getParamDecl(Idx - 1)->getType(); 6488 } else if (FDisConst != NewFDisConst) { 6489 SemaRef.Diag(FD->getLocation(), diag::note_member_def_close_const_match) 6490 << NewFDisConst << FD->getSourceRange().getEnd(); 6491 } else 6492 SemaRef.Diag(FD->getLocation(), 6493 IsMember ? diag::note_member_def_close_match 6494 : diag::note_local_decl_close_match); 6495 } 6496 return nullptr; 6497 } 6498 6499 static FunctionDecl::StorageClass getFunctionStorageClass(Sema &SemaRef, 6500 Declarator &D) { 6501 switch (D.getDeclSpec().getStorageClassSpec()) { 6502 default: llvm_unreachable("Unknown storage class!"); 6503 case DeclSpec::SCS_auto: 6504 case DeclSpec::SCS_register: 6505 case DeclSpec::SCS_mutable: 6506 SemaRef.Diag(D.getDeclSpec().getStorageClassSpecLoc(), 6507 diag::err_typecheck_sclass_func); 6508 D.setInvalidType(); 6509 break; 6510 case DeclSpec::SCS_unspecified: break; 6511 case DeclSpec::SCS_extern: 6512 if (D.getDeclSpec().isExternInLinkageSpec()) 6513 return SC_None; 6514 return SC_Extern; 6515 case DeclSpec::SCS_static: { 6516 if (SemaRef.CurContext->getRedeclContext()->isFunctionOrMethod()) { 6517 // C99 6.7.1p5: 6518 // The declaration of an identifier for a function that has 6519 // block scope shall have no explicit storage-class specifier 6520 // other than extern 6521 // See also (C++ [dcl.stc]p4). 6522 SemaRef.Diag(D.getDeclSpec().getStorageClassSpecLoc(), 6523 diag::err_static_block_func); 6524 break; 6525 } else 6526 return SC_Static; 6527 } 6528 case DeclSpec::SCS_private_extern: return SC_PrivateExtern; 6529 } 6530 6531 // No explicit storage class has already been returned 6532 return SC_None; 6533 } 6534 6535 static FunctionDecl* CreateNewFunctionDecl(Sema &SemaRef, Declarator &D, 6536 DeclContext *DC, QualType &R, 6537 TypeSourceInfo *TInfo, 6538 FunctionDecl::StorageClass SC, 6539 bool &IsVirtualOkay) { 6540 DeclarationNameInfo NameInfo = SemaRef.GetNameForDeclarator(D); 6541 DeclarationName Name = NameInfo.getName(); 6542 6543 FunctionDecl *NewFD = nullptr; 6544 bool isInline = D.getDeclSpec().isInlineSpecified(); 6545 6546 if (!SemaRef.getLangOpts().CPlusPlus) { 6547 // Determine whether the function was written with a 6548 // prototype. This true when: 6549 // - there is a prototype in the declarator, or 6550 // - the type R of the function is some kind of typedef or other reference 6551 // to a type name (which eventually refers to a function type). 6552 bool HasPrototype = 6553 (D.isFunctionDeclarator() && D.getFunctionTypeInfo().hasPrototype) || 6554 (!isa<FunctionType>(R.getTypePtr()) && R->isFunctionProtoType()); 6555 6556 NewFD = FunctionDecl::Create(SemaRef.Context, DC, 6557 D.getLocStart(), NameInfo, R, 6558 TInfo, SC, isInline, 6559 HasPrototype, false); 6560 if (D.isInvalidType()) 6561 NewFD->setInvalidDecl(); 6562 6563 // Set the lexical context. 6564 NewFD->setLexicalDeclContext(SemaRef.CurContext); 6565 6566 return NewFD; 6567 } 6568 6569 bool isExplicit = D.getDeclSpec().isExplicitSpecified(); 6570 bool isConstexpr = D.getDeclSpec().isConstexprSpecified(); 6571 6572 // Check that the return type is not an abstract class type. 6573 // For record types, this is done by the AbstractClassUsageDiagnoser once 6574 // the class has been completely parsed. 6575 if (!DC->isRecord() && 6576 SemaRef.RequireNonAbstractType( 6577 D.getIdentifierLoc(), R->getAs<FunctionType>()->getReturnType(), 6578 diag::err_abstract_type_in_decl, SemaRef.AbstractReturnType)) 6579 D.setInvalidType(); 6580 6581 if (Name.getNameKind() == DeclarationName::CXXConstructorName) { 6582 // This is a C++ constructor declaration. 6583 assert(DC->isRecord() && 6584 "Constructors can only be declared in a member context"); 6585 6586 R = SemaRef.CheckConstructorDeclarator(D, R, SC); 6587 return CXXConstructorDecl::Create(SemaRef.Context, cast<CXXRecordDecl>(DC), 6588 D.getLocStart(), NameInfo, 6589 R, TInfo, isExplicit, isInline, 6590 /*isImplicitlyDeclared=*/false, 6591 isConstexpr); 6592 6593 } else if (Name.getNameKind() == DeclarationName::CXXDestructorName) { 6594 // This is a C++ destructor declaration. 6595 if (DC->isRecord()) { 6596 R = SemaRef.CheckDestructorDeclarator(D, R, SC); 6597 CXXRecordDecl *Record = cast<CXXRecordDecl>(DC); 6598 CXXDestructorDecl *NewDD = CXXDestructorDecl::Create( 6599 SemaRef.Context, Record, 6600 D.getLocStart(), 6601 NameInfo, R, TInfo, isInline, 6602 /*isImplicitlyDeclared=*/false); 6603 6604 // If the class is complete, then we now create the implicit exception 6605 // specification. If the class is incomplete or dependent, we can't do 6606 // it yet. 6607 if (SemaRef.getLangOpts().CPlusPlus11 && !Record->isDependentType() && 6608 Record->getDefinition() && !Record->isBeingDefined() && 6609 R->getAs<FunctionProtoType>()->getExceptionSpecType() == EST_None) { 6610 SemaRef.AdjustDestructorExceptionSpec(Record, NewDD); 6611 } 6612 6613 IsVirtualOkay = true; 6614 return NewDD; 6615 6616 } else { 6617 SemaRef.Diag(D.getIdentifierLoc(), diag::err_destructor_not_member); 6618 D.setInvalidType(); 6619 6620 // Create a FunctionDecl to satisfy the function definition parsing 6621 // code path. 6622 return FunctionDecl::Create(SemaRef.Context, DC, 6623 D.getLocStart(), 6624 D.getIdentifierLoc(), Name, R, TInfo, 6625 SC, isInline, 6626 /*hasPrototype=*/true, isConstexpr); 6627 } 6628 6629 } else if (Name.getNameKind() == DeclarationName::CXXConversionFunctionName) { 6630 if (!DC->isRecord()) { 6631 SemaRef.Diag(D.getIdentifierLoc(), 6632 diag::err_conv_function_not_member); 6633 return nullptr; 6634 } 6635 6636 SemaRef.CheckConversionDeclarator(D, R, SC); 6637 IsVirtualOkay = true; 6638 return CXXConversionDecl::Create(SemaRef.Context, cast<CXXRecordDecl>(DC), 6639 D.getLocStart(), NameInfo, 6640 R, TInfo, isInline, isExplicit, 6641 isConstexpr, SourceLocation()); 6642 6643 } else if (DC->isRecord()) { 6644 // If the name of the function is the same as the name of the record, 6645 // then this must be an invalid constructor that has a return type. 6646 // (The parser checks for a return type and makes the declarator a 6647 // constructor if it has no return type). 6648 if (Name.getAsIdentifierInfo() && 6649 Name.getAsIdentifierInfo() == cast<CXXRecordDecl>(DC)->getIdentifier()){ 6650 SemaRef.Diag(D.getIdentifierLoc(), diag::err_constructor_return_type) 6651 << SourceRange(D.getDeclSpec().getTypeSpecTypeLoc()) 6652 << SourceRange(D.getIdentifierLoc()); 6653 return nullptr; 6654 } 6655 6656 // This is a C++ method declaration. 6657 CXXMethodDecl *Ret = CXXMethodDecl::Create(SemaRef.Context, 6658 cast<CXXRecordDecl>(DC), 6659 D.getLocStart(), NameInfo, R, 6660 TInfo, SC, isInline, 6661 isConstexpr, SourceLocation()); 6662 IsVirtualOkay = !Ret->isStatic(); 6663 return Ret; 6664 } else { 6665 // Determine whether the function was written with a 6666 // prototype. This true when: 6667 // - we're in C++ (where every function has a prototype), 6668 return FunctionDecl::Create(SemaRef.Context, DC, 6669 D.getLocStart(), 6670 NameInfo, R, TInfo, SC, isInline, 6671 true/*HasPrototype*/, isConstexpr); 6672 } 6673 } 6674 6675 enum OpenCLParamType { 6676 ValidKernelParam, 6677 PtrPtrKernelParam, 6678 PtrKernelParam, 6679 PrivatePtrKernelParam, 6680 InvalidKernelParam, 6681 RecordKernelParam 6682 }; 6683 6684 static OpenCLParamType getOpenCLKernelParameterType(QualType PT) { 6685 if (PT->isPointerType()) { 6686 QualType PointeeType = PT->getPointeeType(); 6687 if (PointeeType->isPointerType()) 6688 return PtrPtrKernelParam; 6689 return PointeeType.getAddressSpace() == 0 ? PrivatePtrKernelParam 6690 : PtrKernelParam; 6691 } 6692 6693 // TODO: Forbid the other integer types (size_t, ptrdiff_t...) when they can 6694 // be used as builtin types. 6695 6696 if (PT->isImageType()) 6697 return PtrKernelParam; 6698 6699 if (PT->isBooleanType()) 6700 return InvalidKernelParam; 6701 6702 if (PT->isEventT()) 6703 return InvalidKernelParam; 6704 6705 if (PT->isHalfType()) 6706 return InvalidKernelParam; 6707 6708 if (PT->isRecordType()) 6709 return RecordKernelParam; 6710 6711 return ValidKernelParam; 6712 } 6713 6714 static void checkIsValidOpenCLKernelParameter( 6715 Sema &S, 6716 Declarator &D, 6717 ParmVarDecl *Param, 6718 llvm::SmallPtrSetImpl<const Type *> &ValidTypes) { 6719 QualType PT = Param->getType(); 6720 6721 // Cache the valid types we encounter to avoid rechecking structs that are 6722 // used again 6723 if (ValidTypes.count(PT.getTypePtr())) 6724 return; 6725 6726 switch (getOpenCLKernelParameterType(PT)) { 6727 case PtrPtrKernelParam: 6728 // OpenCL v1.2 s6.9.a: 6729 // A kernel function argument cannot be declared as a 6730 // pointer to a pointer type. 6731 S.Diag(Param->getLocation(), diag::err_opencl_ptrptr_kernel_param); 6732 D.setInvalidType(); 6733 return; 6734 6735 case PrivatePtrKernelParam: 6736 // OpenCL v1.2 s6.9.a: 6737 // A kernel function argument cannot be declared as a 6738 // pointer to the private address space. 6739 S.Diag(Param->getLocation(), diag::err_opencl_private_ptr_kernel_param); 6740 D.setInvalidType(); 6741 return; 6742 6743 // OpenCL v1.2 s6.9.k: 6744 // Arguments to kernel functions in a program cannot be declared with the 6745 // built-in scalar types bool, half, size_t, ptrdiff_t, intptr_t, and 6746 // uintptr_t or a struct and/or union that contain fields declared to be 6747 // one of these built-in scalar types. 6748 6749 case InvalidKernelParam: 6750 // OpenCL v1.2 s6.8 n: 6751 // A kernel function argument cannot be declared 6752 // of event_t type. 6753 S.Diag(Param->getLocation(), diag::err_bad_kernel_param_type) << PT; 6754 D.setInvalidType(); 6755 return; 6756 6757 case PtrKernelParam: 6758 case ValidKernelParam: 6759 ValidTypes.insert(PT.getTypePtr()); 6760 return; 6761 6762 case RecordKernelParam: 6763 break; 6764 } 6765 6766 // Track nested structs we will inspect 6767 SmallVector<const Decl *, 4> VisitStack; 6768 6769 // Track where we are in the nested structs. Items will migrate from 6770 // VisitStack to HistoryStack as we do the DFS for bad field. 6771 SmallVector<const FieldDecl *, 4> HistoryStack; 6772 HistoryStack.push_back(nullptr); 6773 6774 const RecordDecl *PD = PT->castAs<RecordType>()->getDecl(); 6775 VisitStack.push_back(PD); 6776 6777 assert(VisitStack.back() && "First decl null?"); 6778 6779 do { 6780 const Decl *Next = VisitStack.pop_back_val(); 6781 if (!Next) { 6782 assert(!HistoryStack.empty()); 6783 // Found a marker, we have gone up a level 6784 if (const FieldDecl *Hist = HistoryStack.pop_back_val()) 6785 ValidTypes.insert(Hist->getType().getTypePtr()); 6786 6787 continue; 6788 } 6789 6790 // Adds everything except the original parameter declaration (which is not a 6791 // field itself) to the history stack. 6792 const RecordDecl *RD; 6793 if (const FieldDecl *Field = dyn_cast<FieldDecl>(Next)) { 6794 HistoryStack.push_back(Field); 6795 RD = Field->getType()->castAs<RecordType>()->getDecl(); 6796 } else { 6797 RD = cast<RecordDecl>(Next); 6798 } 6799 6800 // Add a null marker so we know when we've gone back up a level 6801 VisitStack.push_back(nullptr); 6802 6803 for (const auto *FD : RD->fields()) { 6804 QualType QT = FD->getType(); 6805 6806 if (ValidTypes.count(QT.getTypePtr())) 6807 continue; 6808 6809 OpenCLParamType ParamType = getOpenCLKernelParameterType(QT); 6810 if (ParamType == ValidKernelParam) 6811 continue; 6812 6813 if (ParamType == RecordKernelParam) { 6814 VisitStack.push_back(FD); 6815 continue; 6816 } 6817 6818 // OpenCL v1.2 s6.9.p: 6819 // Arguments to kernel functions that are declared to be a struct or union 6820 // do not allow OpenCL objects to be passed as elements of the struct or 6821 // union. 6822 if (ParamType == PtrKernelParam || ParamType == PtrPtrKernelParam || 6823 ParamType == PrivatePtrKernelParam) { 6824 S.Diag(Param->getLocation(), 6825 diag::err_record_with_pointers_kernel_param) 6826 << PT->isUnionType() 6827 << PT; 6828 } else { 6829 S.Diag(Param->getLocation(), diag::err_bad_kernel_param_type) << PT; 6830 } 6831 6832 S.Diag(PD->getLocation(), diag::note_within_field_of_type) 6833 << PD->getDeclName(); 6834 6835 // We have an error, now let's go back up through history and show where 6836 // the offending field came from 6837 for (ArrayRef<const FieldDecl *>::const_iterator I = HistoryStack.begin() + 1, 6838 E = HistoryStack.end(); I != E; ++I) { 6839 const FieldDecl *OuterField = *I; 6840 S.Diag(OuterField->getLocation(), diag::note_within_field_of_type) 6841 << OuterField->getType(); 6842 } 6843 6844 S.Diag(FD->getLocation(), diag::note_illegal_field_declared_here) 6845 << QT->isPointerType() 6846 << QT; 6847 D.setInvalidType(); 6848 return; 6849 } 6850 } while (!VisitStack.empty()); 6851 } 6852 6853 NamedDecl* 6854 Sema::ActOnFunctionDeclarator(Scope *S, Declarator &D, DeclContext *DC, 6855 TypeSourceInfo *TInfo, LookupResult &Previous, 6856 MultiTemplateParamsArg TemplateParamLists, 6857 bool &AddToScope) { 6858 QualType R = TInfo->getType(); 6859 6860 assert(R.getTypePtr()->isFunctionType()); 6861 6862 // TODO: consider using NameInfo for diagnostic. 6863 DeclarationNameInfo NameInfo = GetNameForDeclarator(D); 6864 DeclarationName Name = NameInfo.getName(); 6865 FunctionDecl::StorageClass SC = getFunctionStorageClass(*this, D); 6866 6867 if (DeclSpec::TSCS TSCS = D.getDeclSpec().getThreadStorageClassSpec()) 6868 Diag(D.getDeclSpec().getThreadStorageClassSpecLoc(), 6869 diag::err_invalid_thread) 6870 << DeclSpec::getSpecifierName(TSCS); 6871 6872 if (D.isFirstDeclarationOfMember()) 6873 adjustMemberFunctionCC(R, D.isStaticMember()); 6874 6875 bool isFriend = false; 6876 FunctionTemplateDecl *FunctionTemplate = nullptr; 6877 bool isExplicitSpecialization = false; 6878 bool isFunctionTemplateSpecialization = false; 6879 6880 bool isDependentClassScopeExplicitSpecialization = false; 6881 bool HasExplicitTemplateArgs = false; 6882 TemplateArgumentListInfo TemplateArgs; 6883 6884 bool isVirtualOkay = false; 6885 6886 DeclContext *OriginalDC = DC; 6887 bool IsLocalExternDecl = adjustContextForLocalExternDecl(DC); 6888 6889 FunctionDecl *NewFD = CreateNewFunctionDecl(*this, D, DC, R, TInfo, SC, 6890 isVirtualOkay); 6891 if (!NewFD) return nullptr; 6892 6893 if (OriginalLexicalContext && OriginalLexicalContext->isObjCContainer()) 6894 NewFD->setTopLevelDeclInObjCContainer(); 6895 6896 // Set the lexical context. If this is a function-scope declaration, or has a 6897 // C++ scope specifier, or is the object of a friend declaration, the lexical 6898 // context will be different from the semantic context. 6899 NewFD->setLexicalDeclContext(CurContext); 6900 6901 if (IsLocalExternDecl) 6902 NewFD->setLocalExternDecl(); 6903 6904 if (getLangOpts().CPlusPlus) { 6905 bool isInline = D.getDeclSpec().isInlineSpecified(); 6906 bool isVirtual = D.getDeclSpec().isVirtualSpecified(); 6907 bool isExplicit = D.getDeclSpec().isExplicitSpecified(); 6908 bool isConstexpr = D.getDeclSpec().isConstexprSpecified(); 6909 isFriend = D.getDeclSpec().isFriendSpecified(); 6910 if (isFriend && !isInline && D.isFunctionDefinition()) { 6911 // C++ [class.friend]p5 6912 // A function can be defined in a friend declaration of a 6913 // class . . . . Such a function is implicitly inline. 6914 NewFD->setImplicitlyInline(); 6915 } 6916 6917 // If this is a method defined in an __interface, and is not a constructor 6918 // or an overloaded operator, then set the pure flag (isVirtual will already 6919 // return true). 6920 if (const CXXRecordDecl *Parent = 6921 dyn_cast<CXXRecordDecl>(NewFD->getDeclContext())) { 6922 if (Parent->isInterface() && cast<CXXMethodDecl>(NewFD)->isUserProvided()) 6923 NewFD->setPure(true); 6924 } 6925 6926 SetNestedNameSpecifier(NewFD, D); 6927 isExplicitSpecialization = false; 6928 isFunctionTemplateSpecialization = false; 6929 if (D.isInvalidType()) 6930 NewFD->setInvalidDecl(); 6931 6932 // Match up the template parameter lists with the scope specifier, then 6933 // determine whether we have a template or a template specialization. 6934 bool Invalid = false; 6935 if (TemplateParameterList *TemplateParams = 6936 MatchTemplateParametersToScopeSpecifier( 6937 D.getDeclSpec().getLocStart(), D.getIdentifierLoc(), 6938 D.getCXXScopeSpec(), 6939 D.getName().getKind() == UnqualifiedId::IK_TemplateId 6940 ? D.getName().TemplateId 6941 : nullptr, 6942 TemplateParamLists, isFriend, isExplicitSpecialization, 6943 Invalid)) { 6944 if (TemplateParams->size() > 0) { 6945 // This is a function template 6946 6947 // Check that we can declare a template here. 6948 if (CheckTemplateDeclScope(S, TemplateParams)) 6949 return nullptr; 6950 6951 // A destructor cannot be a template. 6952 if (Name.getNameKind() == DeclarationName::CXXDestructorName) { 6953 Diag(NewFD->getLocation(), diag::err_destructor_template); 6954 return nullptr; 6955 } 6956 6957 // If we're adding a template to a dependent context, we may need to 6958 // rebuilding some of the types used within the template parameter list, 6959 // now that we know what the current instantiation is. 6960 if (DC->isDependentContext()) { 6961 ContextRAII SavedContext(*this, DC); 6962 if (RebuildTemplateParamsInCurrentInstantiation(TemplateParams)) 6963 Invalid = true; 6964 } 6965 6966 6967 FunctionTemplate = FunctionTemplateDecl::Create(Context, DC, 6968 NewFD->getLocation(), 6969 Name, TemplateParams, 6970 NewFD); 6971 FunctionTemplate->setLexicalDeclContext(CurContext); 6972 NewFD->setDescribedFunctionTemplate(FunctionTemplate); 6973 6974 // For source fidelity, store the other template param lists. 6975 if (TemplateParamLists.size() > 1) { 6976 NewFD->setTemplateParameterListsInfo(Context, 6977 TemplateParamLists.size() - 1, 6978 TemplateParamLists.data()); 6979 } 6980 } else { 6981 // This is a function template specialization. 6982 isFunctionTemplateSpecialization = true; 6983 // For source fidelity, store all the template param lists. 6984 if (TemplateParamLists.size() > 0) 6985 NewFD->setTemplateParameterListsInfo(Context, 6986 TemplateParamLists.size(), 6987 TemplateParamLists.data()); 6988 6989 // C++0x [temp.expl.spec]p20 forbids "template<> friend void foo(int);". 6990 if (isFriend) { 6991 // We want to remove the "template<>", found here. 6992 SourceRange RemoveRange = TemplateParams->getSourceRange(); 6993 6994 // If we remove the template<> and the name is not a 6995 // template-id, we're actually silently creating a problem: 6996 // the friend declaration will refer to an untemplated decl, 6997 // and clearly the user wants a template specialization. So 6998 // we need to insert '<>' after the name. 6999 SourceLocation InsertLoc; 7000 if (D.getName().getKind() != UnqualifiedId::IK_TemplateId) { 7001 InsertLoc = D.getName().getSourceRange().getEnd(); 7002 InsertLoc = getLocForEndOfToken(InsertLoc); 7003 } 7004 7005 Diag(D.getIdentifierLoc(), diag::err_template_spec_decl_friend) 7006 << Name << RemoveRange 7007 << FixItHint::CreateRemoval(RemoveRange) 7008 << FixItHint::CreateInsertion(InsertLoc, "<>"); 7009 } 7010 } 7011 } 7012 else { 7013 // All template param lists were matched against the scope specifier: 7014 // this is NOT (an explicit specialization of) a template. 7015 if (TemplateParamLists.size() > 0) 7016 // For source fidelity, store all the template param lists. 7017 NewFD->setTemplateParameterListsInfo(Context, 7018 TemplateParamLists.size(), 7019 TemplateParamLists.data()); 7020 } 7021 7022 if (Invalid) { 7023 NewFD->setInvalidDecl(); 7024 if (FunctionTemplate) 7025 FunctionTemplate->setInvalidDecl(); 7026 } 7027 7028 // C++ [dcl.fct.spec]p5: 7029 // The virtual specifier shall only be used in declarations of 7030 // nonstatic class member functions that appear within a 7031 // member-specification of a class declaration; see 10.3. 7032 // 7033 if (isVirtual && !NewFD->isInvalidDecl()) { 7034 if (!isVirtualOkay) { 7035 Diag(D.getDeclSpec().getVirtualSpecLoc(), 7036 diag::err_virtual_non_function); 7037 } else if (!CurContext->isRecord()) { 7038 // 'virtual' was specified outside of the class. 7039 Diag(D.getDeclSpec().getVirtualSpecLoc(), 7040 diag::err_virtual_out_of_class) 7041 << FixItHint::CreateRemoval(D.getDeclSpec().getVirtualSpecLoc()); 7042 } else if (NewFD->getDescribedFunctionTemplate()) { 7043 // C++ [temp.mem]p3: 7044 // A member function template shall not be virtual. 7045 Diag(D.getDeclSpec().getVirtualSpecLoc(), 7046 diag::err_virtual_member_function_template) 7047 << FixItHint::CreateRemoval(D.getDeclSpec().getVirtualSpecLoc()); 7048 } else { 7049 // Okay: Add virtual to the method. 7050 NewFD->setVirtualAsWritten(true); 7051 } 7052 7053 if (getLangOpts().CPlusPlus14 && 7054 NewFD->getReturnType()->isUndeducedType()) 7055 Diag(D.getDeclSpec().getVirtualSpecLoc(), diag::err_auto_fn_virtual); 7056 } 7057 7058 if (getLangOpts().CPlusPlus14 && 7059 (NewFD->isDependentContext() || 7060 (isFriend && CurContext->isDependentContext())) && 7061 NewFD->getReturnType()->isUndeducedType()) { 7062 // If the function template is referenced directly (for instance, as a 7063 // member of the current instantiation), pretend it has a dependent type. 7064 // This is not really justified by the standard, but is the only sane 7065 // thing to do. 7066 // FIXME: For a friend function, we have not marked the function as being 7067 // a friend yet, so 'isDependentContext' on the FD doesn't work. 7068 const FunctionProtoType *FPT = 7069 NewFD->getType()->castAs<FunctionProtoType>(); 7070 QualType Result = 7071 SubstAutoType(FPT->getReturnType(), Context.DependentTy); 7072 NewFD->setType(Context.getFunctionType(Result, FPT->getParamTypes(), 7073 FPT->getExtProtoInfo())); 7074 } 7075 7076 // C++ [dcl.fct.spec]p3: 7077 // The inline specifier shall not appear on a block scope function 7078 // declaration. 7079 if (isInline && !NewFD->isInvalidDecl()) { 7080 if (CurContext->isFunctionOrMethod()) { 7081 // 'inline' is not allowed on block scope function declaration. 7082 Diag(D.getDeclSpec().getInlineSpecLoc(), 7083 diag::err_inline_declaration_block_scope) << Name 7084 << FixItHint::CreateRemoval(D.getDeclSpec().getInlineSpecLoc()); 7085 } 7086 } 7087 7088 // C++ [dcl.fct.spec]p6: 7089 // The explicit specifier shall be used only in the declaration of a 7090 // constructor or conversion function within its class definition; 7091 // see 12.3.1 and 12.3.2. 7092 if (isExplicit && !NewFD->isInvalidDecl()) { 7093 if (!CurContext->isRecord()) { 7094 // 'explicit' was specified outside of the class. 7095 Diag(D.getDeclSpec().getExplicitSpecLoc(), 7096 diag::err_explicit_out_of_class) 7097 << FixItHint::CreateRemoval(D.getDeclSpec().getExplicitSpecLoc()); 7098 } else if (!isa<CXXConstructorDecl>(NewFD) && 7099 !isa<CXXConversionDecl>(NewFD)) { 7100 // 'explicit' was specified on a function that wasn't a constructor 7101 // or conversion function. 7102 Diag(D.getDeclSpec().getExplicitSpecLoc(), 7103 diag::err_explicit_non_ctor_or_conv_function) 7104 << FixItHint::CreateRemoval(D.getDeclSpec().getExplicitSpecLoc()); 7105 } 7106 } 7107 7108 if (isConstexpr) { 7109 // C++11 [dcl.constexpr]p2: constexpr functions and constexpr constructors 7110 // are implicitly inline. 7111 NewFD->setImplicitlyInline(); 7112 7113 // C++11 [dcl.constexpr]p3: functions declared constexpr are required to 7114 // be either constructors or to return a literal type. Therefore, 7115 // destructors cannot be declared constexpr. 7116 if (isa<CXXDestructorDecl>(NewFD)) 7117 Diag(D.getDeclSpec().getConstexprSpecLoc(), diag::err_constexpr_dtor); 7118 } 7119 7120 // If __module_private__ was specified, mark the function accordingly. 7121 if (D.getDeclSpec().isModulePrivateSpecified()) { 7122 if (isFunctionTemplateSpecialization) { 7123 SourceLocation ModulePrivateLoc 7124 = D.getDeclSpec().getModulePrivateSpecLoc(); 7125 Diag(ModulePrivateLoc, diag::err_module_private_specialization) 7126 << 0 7127 << FixItHint::CreateRemoval(ModulePrivateLoc); 7128 } else { 7129 NewFD->setModulePrivate(); 7130 if (FunctionTemplate) 7131 FunctionTemplate->setModulePrivate(); 7132 } 7133 } 7134 7135 if (isFriend) { 7136 if (FunctionTemplate) { 7137 FunctionTemplate->setObjectOfFriendDecl(); 7138 FunctionTemplate->setAccess(AS_public); 7139 } 7140 NewFD->setObjectOfFriendDecl(); 7141 NewFD->setAccess(AS_public); 7142 } 7143 7144 // If a function is defined as defaulted or deleted, mark it as such now. 7145 // FIXME: Does this ever happen? ActOnStartOfFunctionDef forces the function 7146 // definition kind to FDK_Definition. 7147 switch (D.getFunctionDefinitionKind()) { 7148 case FDK_Declaration: 7149 case FDK_Definition: 7150 break; 7151 7152 case FDK_Defaulted: 7153 NewFD->setDefaulted(); 7154 break; 7155 7156 case FDK_Deleted: 7157 NewFD->setDeletedAsWritten(); 7158 break; 7159 } 7160 7161 if (isa<CXXMethodDecl>(NewFD) && DC == CurContext && 7162 D.isFunctionDefinition()) { 7163 // C++ [class.mfct]p2: 7164 // A member function may be defined (8.4) in its class definition, in 7165 // which case it is an inline member function (7.1.2) 7166 NewFD->setImplicitlyInline(); 7167 } 7168 7169 if (SC == SC_Static && isa<CXXMethodDecl>(NewFD) && 7170 !CurContext->isRecord()) { 7171 // C++ [class.static]p1: 7172 // A data or function member of a class may be declared static 7173 // in a class definition, in which case it is a static member of 7174 // the class. 7175 7176 // Complain about the 'static' specifier if it's on an out-of-line 7177 // member function definition. 7178 Diag(D.getDeclSpec().getStorageClassSpecLoc(), 7179 diag::err_static_out_of_line) 7180 << FixItHint::CreateRemoval(D.getDeclSpec().getStorageClassSpecLoc()); 7181 } 7182 7183 // C++11 [except.spec]p15: 7184 // A deallocation function with no exception-specification is treated 7185 // as if it were specified with noexcept(true). 7186 const FunctionProtoType *FPT = R->getAs<FunctionProtoType>(); 7187 if ((Name.getCXXOverloadedOperator() == OO_Delete || 7188 Name.getCXXOverloadedOperator() == OO_Array_Delete) && 7189 getLangOpts().CPlusPlus11 && FPT && !FPT->hasExceptionSpec()) 7190 NewFD->setType(Context.getFunctionType( 7191 FPT->getReturnType(), FPT->getParamTypes(), 7192 FPT->getExtProtoInfo().withExceptionSpec(EST_BasicNoexcept))); 7193 } 7194 7195 // Filter out previous declarations that don't match the scope. 7196 FilterLookupForScope(Previous, OriginalDC, S, shouldConsiderLinkage(NewFD), 7197 D.getCXXScopeSpec().isNotEmpty() || 7198 isExplicitSpecialization || 7199 isFunctionTemplateSpecialization); 7200 7201 // Handle GNU asm-label extension (encoded as an attribute). 7202 if (Expr *E = (Expr*) D.getAsmLabel()) { 7203 // The parser guarantees this is a string. 7204 StringLiteral *SE = cast<StringLiteral>(E); 7205 NewFD->addAttr(::new (Context) AsmLabelAttr(SE->getStrTokenLoc(0), Context, 7206 SE->getString(), 0)); 7207 } else if (!ExtnameUndeclaredIdentifiers.empty()) { 7208 llvm::DenseMap<IdentifierInfo*,AsmLabelAttr*>::iterator I = 7209 ExtnameUndeclaredIdentifiers.find(NewFD->getIdentifier()); 7210 if (I != ExtnameUndeclaredIdentifiers.end()) { 7211 NewFD->addAttr(I->second); 7212 ExtnameUndeclaredIdentifiers.erase(I); 7213 } 7214 } 7215 7216 // Copy the parameter declarations from the declarator D to the function 7217 // declaration NewFD, if they are available. First scavenge them into Params. 7218 SmallVector<ParmVarDecl*, 16> Params; 7219 if (D.isFunctionDeclarator()) { 7220 DeclaratorChunk::FunctionTypeInfo &FTI = D.getFunctionTypeInfo(); 7221 7222 // Check for C99 6.7.5.3p10 - foo(void) is a non-varargs 7223 // function that takes no arguments, not a function that takes a 7224 // single void argument. 7225 // We let through "const void" here because Sema::GetTypeForDeclarator 7226 // already checks for that case. 7227 if (FTIHasNonVoidParameters(FTI) && FTI.Params[0].Param) { 7228 for (unsigned i = 0, e = FTI.NumParams; i != e; ++i) { 7229 ParmVarDecl *Param = cast<ParmVarDecl>(FTI.Params[i].Param); 7230 assert(Param->getDeclContext() != NewFD && "Was set before ?"); 7231 Param->setDeclContext(NewFD); 7232 Params.push_back(Param); 7233 7234 if (Param->isInvalidDecl()) 7235 NewFD->setInvalidDecl(); 7236 } 7237 } 7238 7239 } else if (const FunctionProtoType *FT = R->getAs<FunctionProtoType>()) { 7240 // When we're declaring a function with a typedef, typeof, etc as in the 7241 // following example, we'll need to synthesize (unnamed) 7242 // parameters for use in the declaration. 7243 // 7244 // @code 7245 // typedef void fn(int); 7246 // fn f; 7247 // @endcode 7248 7249 // Synthesize a parameter for each argument type. 7250 for (const auto &AI : FT->param_types()) { 7251 ParmVarDecl *Param = 7252 BuildParmVarDeclForTypedef(NewFD, D.getIdentifierLoc(), AI); 7253 Param->setScopeInfo(0, Params.size()); 7254 Params.push_back(Param); 7255 } 7256 } else { 7257 assert(R->isFunctionNoProtoType() && NewFD->getNumParams() == 0 && 7258 "Should not need args for typedef of non-prototype fn"); 7259 } 7260 7261 // Finally, we know we have the right number of parameters, install them. 7262 NewFD->setParams(Params); 7263 7264 // Find all anonymous symbols defined during the declaration of this function 7265 // and add to NewFD. This lets us track decls such 'enum Y' in: 7266 // 7267 // void f(enum Y {AA} x) {} 7268 // 7269 // which would otherwise incorrectly end up in the translation unit scope. 7270 NewFD->setDeclsInPrototypeScope(DeclsInPrototypeScope); 7271 DeclsInPrototypeScope.clear(); 7272 7273 if (D.getDeclSpec().isNoreturnSpecified()) 7274 NewFD->addAttr( 7275 ::new(Context) C11NoReturnAttr(D.getDeclSpec().getNoreturnSpecLoc(), 7276 Context, 0)); 7277 7278 // Functions returning a variably modified type violate C99 6.7.5.2p2 7279 // because all functions have linkage. 7280 if (!NewFD->isInvalidDecl() && 7281 NewFD->getReturnType()->isVariablyModifiedType()) { 7282 Diag(NewFD->getLocation(), diag::err_vm_func_decl); 7283 NewFD->setInvalidDecl(); 7284 } 7285 7286 if (D.isFunctionDefinition() && CodeSegStack.CurrentValue && 7287 !NewFD->hasAttr<SectionAttr>()) { 7288 NewFD->addAttr( 7289 SectionAttr::CreateImplicit(Context, SectionAttr::Declspec_allocate, 7290 CodeSegStack.CurrentValue->getString(), 7291 CodeSegStack.CurrentPragmaLocation)); 7292 if (UnifySection(CodeSegStack.CurrentValue->getString(), 7293 PSF_Implicit | PSF_Execute | PSF_Read, NewFD)) 7294 NewFD->dropAttr<SectionAttr>(); 7295 } 7296 7297 // Handle attributes. 7298 ProcessDeclAttributes(S, NewFD, D); 7299 7300 QualType RetType = NewFD->getReturnType(); 7301 const CXXRecordDecl *Ret = RetType->isRecordType() ? 7302 RetType->getAsCXXRecordDecl() : RetType->getPointeeCXXRecordDecl(); 7303 if (!NewFD->isInvalidDecl() && !NewFD->hasAttr<WarnUnusedResultAttr>() && 7304 Ret && Ret->hasAttr<WarnUnusedResultAttr>()) { 7305 const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(NewFD); 7306 // Attach WarnUnusedResult to functions returning types with that attribute. 7307 // Don't apply the attribute to that type's own non-static member functions 7308 // (to avoid warning on things like assignment operators) 7309 if (!MD || MD->getParent() != Ret) 7310 NewFD->addAttr(WarnUnusedResultAttr::CreateImplicit(Context)); 7311 } 7312 7313 if (getLangOpts().OpenCL) { 7314 // OpenCL v1.1 s6.5: Using an address space qualifier in a function return 7315 // type declaration will generate a compilation error. 7316 unsigned AddressSpace = RetType.getAddressSpace(); 7317 if (AddressSpace == LangAS::opencl_local || 7318 AddressSpace == LangAS::opencl_global || 7319 AddressSpace == LangAS::opencl_constant) { 7320 Diag(NewFD->getLocation(), 7321 diag::err_opencl_return_value_with_address_space); 7322 NewFD->setInvalidDecl(); 7323 } 7324 } 7325 7326 if (!getLangOpts().CPlusPlus) { 7327 // Perform semantic checking on the function declaration. 7328 bool isExplicitSpecialization=false; 7329 if (!NewFD->isInvalidDecl() && NewFD->isMain()) 7330 CheckMain(NewFD, D.getDeclSpec()); 7331 7332 if (!NewFD->isInvalidDecl() && NewFD->isMSVCRTEntryPoint()) 7333 CheckMSVCRTEntryPoint(NewFD); 7334 7335 if (!NewFD->isInvalidDecl()) 7336 D.setRedeclaration(CheckFunctionDeclaration(S, NewFD, Previous, 7337 isExplicitSpecialization)); 7338 else if (!Previous.empty()) 7339 // Make graceful recovery from an invalid redeclaration. 7340 D.setRedeclaration(true); 7341 assert((NewFD->isInvalidDecl() || !D.isRedeclaration() || 7342 Previous.getResultKind() != LookupResult::FoundOverloaded) && 7343 "previous declaration set still overloaded"); 7344 } else { 7345 // C++11 [replacement.functions]p3: 7346 // The program's definitions shall not be specified as inline. 7347 // 7348 // N.B. We diagnose declarations instead of definitions per LWG issue 2340. 7349 // 7350 // Suppress the diagnostic if the function is __attribute__((used)), since 7351 // that forces an external definition to be emitted. 7352 if (D.getDeclSpec().isInlineSpecified() && 7353 NewFD->isReplaceableGlobalAllocationFunction() && 7354 !NewFD->hasAttr<UsedAttr>()) 7355 Diag(D.getDeclSpec().getInlineSpecLoc(), 7356 diag::ext_operator_new_delete_declared_inline) 7357 << NewFD->getDeclName(); 7358 7359 // If the declarator is a template-id, translate the parser's template 7360 // argument list into our AST format. 7361 if (D.getName().getKind() == UnqualifiedId::IK_TemplateId) { 7362 TemplateIdAnnotation *TemplateId = D.getName().TemplateId; 7363 TemplateArgs.setLAngleLoc(TemplateId->LAngleLoc); 7364 TemplateArgs.setRAngleLoc(TemplateId->RAngleLoc); 7365 ASTTemplateArgsPtr TemplateArgsPtr(TemplateId->getTemplateArgs(), 7366 TemplateId->NumArgs); 7367 translateTemplateArguments(TemplateArgsPtr, 7368 TemplateArgs); 7369 7370 HasExplicitTemplateArgs = true; 7371 7372 if (NewFD->isInvalidDecl()) { 7373 HasExplicitTemplateArgs = false; 7374 } else if (FunctionTemplate) { 7375 // Function template with explicit template arguments. 7376 Diag(D.getIdentifierLoc(), diag::err_function_template_partial_spec) 7377 << SourceRange(TemplateId->LAngleLoc, TemplateId->RAngleLoc); 7378 7379 HasExplicitTemplateArgs = false; 7380 } else { 7381 assert((isFunctionTemplateSpecialization || 7382 D.getDeclSpec().isFriendSpecified()) && 7383 "should have a 'template<>' for this decl"); 7384 // "friend void foo<>(int);" is an implicit specialization decl. 7385 isFunctionTemplateSpecialization = true; 7386 } 7387 } else if (isFriend && isFunctionTemplateSpecialization) { 7388 // This combination is only possible in a recovery case; the user 7389 // wrote something like: 7390 // template <> friend void foo(int); 7391 // which we're recovering from as if the user had written: 7392 // friend void foo<>(int); 7393 // Go ahead and fake up a template id. 7394 HasExplicitTemplateArgs = true; 7395 TemplateArgs.setLAngleLoc(D.getIdentifierLoc()); 7396 TemplateArgs.setRAngleLoc(D.getIdentifierLoc()); 7397 } 7398 7399 // If it's a friend (and only if it's a friend), it's possible 7400 // that either the specialized function type or the specialized 7401 // template is dependent, and therefore matching will fail. In 7402 // this case, don't check the specialization yet. 7403 bool InstantiationDependent = false; 7404 if (isFunctionTemplateSpecialization && isFriend && 7405 (NewFD->getType()->isDependentType() || DC->isDependentContext() || 7406 TemplateSpecializationType::anyDependentTemplateArguments( 7407 TemplateArgs.getArgumentArray(), TemplateArgs.size(), 7408 InstantiationDependent))) { 7409 assert(HasExplicitTemplateArgs && 7410 "friend function specialization without template args"); 7411 if (CheckDependentFunctionTemplateSpecialization(NewFD, TemplateArgs, 7412 Previous)) 7413 NewFD->setInvalidDecl(); 7414 } else if (isFunctionTemplateSpecialization) { 7415 if (CurContext->isDependentContext() && CurContext->isRecord() 7416 && !isFriend) { 7417 isDependentClassScopeExplicitSpecialization = true; 7418 Diag(NewFD->getLocation(), getLangOpts().MicrosoftExt ? 7419 diag::ext_function_specialization_in_class : 7420 diag::err_function_specialization_in_class) 7421 << NewFD->getDeclName(); 7422 } else if (CheckFunctionTemplateSpecialization(NewFD, 7423 (HasExplicitTemplateArgs ? &TemplateArgs 7424 : nullptr), 7425 Previous)) 7426 NewFD->setInvalidDecl(); 7427 7428 // C++ [dcl.stc]p1: 7429 // A storage-class-specifier shall not be specified in an explicit 7430 // specialization (14.7.3) 7431 FunctionTemplateSpecializationInfo *Info = 7432 NewFD->getTemplateSpecializationInfo(); 7433 if (Info && SC != SC_None) { 7434 if (SC != Info->getTemplate()->getTemplatedDecl()->getStorageClass()) 7435 Diag(NewFD->getLocation(), 7436 diag::err_explicit_specialization_inconsistent_storage_class) 7437 << SC 7438 << FixItHint::CreateRemoval( 7439 D.getDeclSpec().getStorageClassSpecLoc()); 7440 7441 else 7442 Diag(NewFD->getLocation(), 7443 diag::ext_explicit_specialization_storage_class) 7444 << FixItHint::CreateRemoval( 7445 D.getDeclSpec().getStorageClassSpecLoc()); 7446 } 7447 7448 } else if (isExplicitSpecialization && isa<CXXMethodDecl>(NewFD)) { 7449 if (CheckMemberSpecialization(NewFD, Previous)) 7450 NewFD->setInvalidDecl(); 7451 } 7452 7453 // Perform semantic checking on the function declaration. 7454 if (!isDependentClassScopeExplicitSpecialization) { 7455 if (!NewFD->isInvalidDecl() && NewFD->isMain()) 7456 CheckMain(NewFD, D.getDeclSpec()); 7457 7458 if (!NewFD->isInvalidDecl() && NewFD->isMSVCRTEntryPoint()) 7459 CheckMSVCRTEntryPoint(NewFD); 7460 7461 if (!NewFD->isInvalidDecl()) 7462 D.setRedeclaration(CheckFunctionDeclaration(S, NewFD, Previous, 7463 isExplicitSpecialization)); 7464 } 7465 7466 assert((NewFD->isInvalidDecl() || !D.isRedeclaration() || 7467 Previous.getResultKind() != LookupResult::FoundOverloaded) && 7468 "previous declaration set still overloaded"); 7469 7470 NamedDecl *PrincipalDecl = (FunctionTemplate 7471 ? cast<NamedDecl>(FunctionTemplate) 7472 : NewFD); 7473 7474 if (isFriend && D.isRedeclaration()) { 7475 AccessSpecifier Access = AS_public; 7476 if (!NewFD->isInvalidDecl()) 7477 Access = NewFD->getPreviousDecl()->getAccess(); 7478 7479 NewFD->setAccess(Access); 7480 if (FunctionTemplate) FunctionTemplate->setAccess(Access); 7481 } 7482 7483 if (NewFD->isOverloadedOperator() && !DC->isRecord() && 7484 PrincipalDecl->isInIdentifierNamespace(Decl::IDNS_Ordinary)) 7485 PrincipalDecl->setNonMemberOperator(); 7486 7487 // If we have a function template, check the template parameter 7488 // list. This will check and merge default template arguments. 7489 if (FunctionTemplate) { 7490 FunctionTemplateDecl *PrevTemplate = 7491 FunctionTemplate->getPreviousDecl(); 7492 CheckTemplateParameterList(FunctionTemplate->getTemplateParameters(), 7493 PrevTemplate ? PrevTemplate->getTemplateParameters() 7494 : nullptr, 7495 D.getDeclSpec().isFriendSpecified() 7496 ? (D.isFunctionDefinition() 7497 ? TPC_FriendFunctionTemplateDefinition 7498 : TPC_FriendFunctionTemplate) 7499 : (D.getCXXScopeSpec().isSet() && 7500 DC && DC->isRecord() && 7501 DC->isDependentContext()) 7502 ? TPC_ClassTemplateMember 7503 : TPC_FunctionTemplate); 7504 } 7505 7506 if (NewFD->isInvalidDecl()) { 7507 // Ignore all the rest of this. 7508 } else if (!D.isRedeclaration()) { 7509 struct ActOnFDArgs ExtraArgs = { S, D, TemplateParamLists, 7510 AddToScope }; 7511 // Fake up an access specifier if it's supposed to be a class member. 7512 if (isa<CXXRecordDecl>(NewFD->getDeclContext())) 7513 NewFD->setAccess(AS_public); 7514 7515 // Qualified decls generally require a previous declaration. 7516 if (D.getCXXScopeSpec().isSet()) { 7517 // ...with the major exception of templated-scope or 7518 // dependent-scope friend declarations. 7519 7520 // TODO: we currently also suppress this check in dependent 7521 // contexts because (1) the parameter depth will be off when 7522 // matching friend templates and (2) we might actually be 7523 // selecting a friend based on a dependent factor. But there 7524 // are situations where these conditions don't apply and we 7525 // can actually do this check immediately. 7526 if (isFriend && 7527 (TemplateParamLists.size() || 7528 D.getCXXScopeSpec().getScopeRep()->isDependent() || 7529 CurContext->isDependentContext())) { 7530 // ignore these 7531 } else { 7532 // The user tried to provide an out-of-line definition for a 7533 // function that is a member of a class or namespace, but there 7534 // was no such member function declared (C++ [class.mfct]p2, 7535 // C++ [namespace.memdef]p2). For example: 7536 // 7537 // class X { 7538 // void f() const; 7539 // }; 7540 // 7541 // void X::f() { } // ill-formed 7542 // 7543 // Complain about this problem, and attempt to suggest close 7544 // matches (e.g., those that differ only in cv-qualifiers and 7545 // whether the parameter types are references). 7546 7547 if (NamedDecl *Result = DiagnoseInvalidRedeclaration( 7548 *this, Previous, NewFD, ExtraArgs, false, nullptr)) { 7549 AddToScope = ExtraArgs.AddToScope; 7550 return Result; 7551 } 7552 } 7553 7554 // Unqualified local friend declarations are required to resolve 7555 // to something. 7556 } else if (isFriend && cast<CXXRecordDecl>(CurContext)->isLocalClass()) { 7557 if (NamedDecl *Result = DiagnoseInvalidRedeclaration( 7558 *this, Previous, NewFD, ExtraArgs, true, S)) { 7559 AddToScope = ExtraArgs.AddToScope; 7560 return Result; 7561 } 7562 } 7563 7564 } else if (!D.isFunctionDefinition() && 7565 isa<CXXMethodDecl>(NewFD) && NewFD->isOutOfLine() && 7566 !isFriend && !isFunctionTemplateSpecialization && 7567 !isExplicitSpecialization) { 7568 // An out-of-line member function declaration must also be a 7569 // definition (C++ [class.mfct]p2). 7570 // Note that this is not the case for explicit specializations of 7571 // function templates or member functions of class templates, per 7572 // C++ [temp.expl.spec]p2. We also allow these declarations as an 7573 // extension for compatibility with old SWIG code which likes to 7574 // generate them. 7575 Diag(NewFD->getLocation(), diag::ext_out_of_line_declaration) 7576 << D.getCXXScopeSpec().getRange(); 7577 } 7578 } 7579 7580 ProcessPragmaWeak(S, NewFD); 7581 checkAttributesAfterMerging(*this, *NewFD); 7582 7583 AddKnownFunctionAttributes(NewFD); 7584 7585 if (NewFD->hasAttr<OverloadableAttr>() && 7586 !NewFD->getType()->getAs<FunctionProtoType>()) { 7587 Diag(NewFD->getLocation(), 7588 diag::err_attribute_overloadable_no_prototype) 7589 << NewFD; 7590 7591 // Turn this into a variadic function with no parameters. 7592 const FunctionType *FT = NewFD->getType()->getAs<FunctionType>(); 7593 FunctionProtoType::ExtProtoInfo EPI( 7594 Context.getDefaultCallingConvention(true, false)); 7595 EPI.Variadic = true; 7596 EPI.ExtInfo = FT->getExtInfo(); 7597 7598 QualType R = Context.getFunctionType(FT->getReturnType(), None, EPI); 7599 NewFD->setType(R); 7600 } 7601 7602 // If there's a #pragma GCC visibility in scope, and this isn't a class 7603 // member, set the visibility of this function. 7604 if (!DC->isRecord() && NewFD->isExternallyVisible()) 7605 AddPushedVisibilityAttribute(NewFD); 7606 7607 // If there's a #pragma clang arc_cf_code_audited in scope, consider 7608 // marking the function. 7609 AddCFAuditedAttribute(NewFD); 7610 7611 // If this is a function definition, check if we have to apply optnone due to 7612 // a pragma. 7613 if(D.isFunctionDefinition()) 7614 AddRangeBasedOptnone(NewFD); 7615 7616 // If this is the first declaration of an extern C variable, update 7617 // the map of such variables. 7618 if (NewFD->isFirstDecl() && !NewFD->isInvalidDecl() && 7619 isIncompleteDeclExternC(*this, NewFD)) 7620 RegisterLocallyScopedExternCDecl(NewFD, S); 7621 7622 // Set this FunctionDecl's range up to the right paren. 7623 NewFD->setRangeEnd(D.getSourceRange().getEnd()); 7624 7625 if (D.isRedeclaration() && !Previous.empty()) { 7626 checkDLLAttributeRedeclaration( 7627 *this, dyn_cast<NamedDecl>(Previous.getRepresentativeDecl()), NewFD, 7628 isExplicitSpecialization || isFunctionTemplateSpecialization); 7629 } 7630 7631 if (getLangOpts().CPlusPlus) { 7632 if (FunctionTemplate) { 7633 if (NewFD->isInvalidDecl()) 7634 FunctionTemplate->setInvalidDecl(); 7635 return FunctionTemplate; 7636 } 7637 } 7638 7639 if (NewFD->hasAttr<OpenCLKernelAttr>()) { 7640 // OpenCL v1.2 s6.8 static is invalid for kernel functions. 7641 if ((getLangOpts().OpenCLVersion >= 120) 7642 && (SC == SC_Static)) { 7643 Diag(D.getIdentifierLoc(), diag::err_static_kernel); 7644 D.setInvalidType(); 7645 } 7646 7647 // OpenCL v1.2, s6.9 -- Kernels can only have return type void. 7648 if (!NewFD->getReturnType()->isVoidType()) { 7649 SourceRange RTRange = NewFD->getReturnTypeSourceRange(); 7650 Diag(D.getIdentifierLoc(), diag::err_expected_kernel_void_return_type) 7651 << (RTRange.isValid() ? FixItHint::CreateReplacement(RTRange, "void") 7652 : FixItHint()); 7653 D.setInvalidType(); 7654 } 7655 7656 llvm::SmallPtrSet<const Type *, 16> ValidTypes; 7657 for (auto Param : NewFD->params()) 7658 checkIsValidOpenCLKernelParameter(*this, D, Param, ValidTypes); 7659 } 7660 7661 MarkUnusedFileScopedDecl(NewFD); 7662 7663 if (getLangOpts().CUDA) 7664 if (IdentifierInfo *II = NewFD->getIdentifier()) 7665 if (!NewFD->isInvalidDecl() && 7666 NewFD->getDeclContext()->getRedeclContext()->isTranslationUnit()) { 7667 if (II->isStr("cudaConfigureCall")) { 7668 if (!R->getAs<FunctionType>()->getReturnType()->isScalarType()) 7669 Diag(NewFD->getLocation(), diag::err_config_scalar_return); 7670 7671 Context.setcudaConfigureCallDecl(NewFD); 7672 } 7673 } 7674 7675 // Here we have an function template explicit specialization at class scope. 7676 // The actually specialization will be postponed to template instatiation 7677 // time via the ClassScopeFunctionSpecializationDecl node. 7678 if (isDependentClassScopeExplicitSpecialization) { 7679 ClassScopeFunctionSpecializationDecl *NewSpec = 7680 ClassScopeFunctionSpecializationDecl::Create( 7681 Context, CurContext, SourceLocation(), 7682 cast<CXXMethodDecl>(NewFD), 7683 HasExplicitTemplateArgs, TemplateArgs); 7684 CurContext->addDecl(NewSpec); 7685 AddToScope = false; 7686 } 7687 7688 return NewFD; 7689 } 7690 7691 /// \brief Perform semantic checking of a new function declaration. 7692 /// 7693 /// Performs semantic analysis of the new function declaration 7694 /// NewFD. This routine performs all semantic checking that does not 7695 /// require the actual declarator involved in the declaration, and is 7696 /// used both for the declaration of functions as they are parsed 7697 /// (called via ActOnDeclarator) and for the declaration of functions 7698 /// that have been instantiated via C++ template instantiation (called 7699 /// via InstantiateDecl). 7700 /// 7701 /// \param IsExplicitSpecialization whether this new function declaration is 7702 /// an explicit specialization of the previous declaration. 7703 /// 7704 /// This sets NewFD->isInvalidDecl() to true if there was an error. 7705 /// 7706 /// \returns true if the function declaration is a redeclaration. 7707 bool Sema::CheckFunctionDeclaration(Scope *S, FunctionDecl *NewFD, 7708 LookupResult &Previous, 7709 bool IsExplicitSpecialization) { 7710 assert(!NewFD->getReturnType()->isVariablyModifiedType() && 7711 "Variably modified return types are not handled here"); 7712 7713 // Determine whether the type of this function should be merged with 7714 // a previous visible declaration. This never happens for functions in C++, 7715 // and always happens in C if the previous declaration was visible. 7716 bool MergeTypeWithPrevious = !getLangOpts().CPlusPlus && 7717 !Previous.isShadowed(); 7718 7719 // Filter out any non-conflicting previous declarations. 7720 filterNonConflictingPreviousDecls(Context, NewFD, Previous); 7721 7722 bool Redeclaration = false; 7723 NamedDecl *OldDecl = nullptr; 7724 7725 // Merge or overload the declaration with an existing declaration of 7726 // the same name, if appropriate. 7727 if (!Previous.empty()) { 7728 // Determine whether NewFD is an overload of PrevDecl or 7729 // a declaration that requires merging. If it's an overload, 7730 // there's no more work to do here; we'll just add the new 7731 // function to the scope. 7732 if (!AllowOverloadingOfFunction(Previous, Context)) { 7733 NamedDecl *Candidate = Previous.getFoundDecl(); 7734 if (shouldLinkPossiblyHiddenDecl(Candidate, NewFD)) { 7735 Redeclaration = true; 7736 OldDecl = Candidate; 7737 } 7738 } else { 7739 switch (CheckOverload(S, NewFD, Previous, OldDecl, 7740 /*NewIsUsingDecl*/ false)) { 7741 case Ovl_Match: 7742 Redeclaration = true; 7743 break; 7744 7745 case Ovl_NonFunction: 7746 Redeclaration = true; 7747 break; 7748 7749 case Ovl_Overload: 7750 Redeclaration = false; 7751 break; 7752 } 7753 7754 if (!getLangOpts().CPlusPlus && !NewFD->hasAttr<OverloadableAttr>()) { 7755 // If a function name is overloadable in C, then every function 7756 // with that name must be marked "overloadable". 7757 Diag(NewFD->getLocation(), diag::err_attribute_overloadable_missing) 7758 << Redeclaration << NewFD; 7759 NamedDecl *OverloadedDecl = nullptr; 7760 if (Redeclaration) 7761 OverloadedDecl = OldDecl; 7762 else if (!Previous.empty()) 7763 OverloadedDecl = Previous.getRepresentativeDecl(); 7764 if (OverloadedDecl) 7765 Diag(OverloadedDecl->getLocation(), 7766 diag::note_attribute_overloadable_prev_overload); 7767 NewFD->addAttr(OverloadableAttr::CreateImplicit(Context)); 7768 } 7769 } 7770 } 7771 7772 // Check for a previous extern "C" declaration with this name. 7773 if (!Redeclaration && 7774 checkForConflictWithNonVisibleExternC(*this, NewFD, Previous)) { 7775 filterNonConflictingPreviousDecls(Context, NewFD, Previous); 7776 if (!Previous.empty()) { 7777 // This is an extern "C" declaration with the same name as a previous 7778 // declaration, and thus redeclares that entity... 7779 Redeclaration = true; 7780 OldDecl = Previous.getFoundDecl(); 7781 MergeTypeWithPrevious = false; 7782 7783 // ... except in the presence of __attribute__((overloadable)). 7784 if (OldDecl->hasAttr<OverloadableAttr>()) { 7785 if (!getLangOpts().CPlusPlus && !NewFD->hasAttr<OverloadableAttr>()) { 7786 Diag(NewFD->getLocation(), diag::err_attribute_overloadable_missing) 7787 << Redeclaration << NewFD; 7788 Diag(Previous.getFoundDecl()->getLocation(), 7789 diag::note_attribute_overloadable_prev_overload); 7790 NewFD->addAttr(OverloadableAttr::CreateImplicit(Context)); 7791 } 7792 if (IsOverload(NewFD, cast<FunctionDecl>(OldDecl), false)) { 7793 Redeclaration = false; 7794 OldDecl = nullptr; 7795 } 7796 } 7797 } 7798 } 7799 7800 // C++11 [dcl.constexpr]p8: 7801 // A constexpr specifier for a non-static member function that is not 7802 // a constructor declares that member function to be const. 7803 // 7804 // This needs to be delayed until we know whether this is an out-of-line 7805 // definition of a static member function. 7806 // 7807 // This rule is not present in C++1y, so we produce a backwards 7808 // compatibility warning whenever it happens in C++11. 7809 CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(NewFD); 7810 if (!getLangOpts().CPlusPlus14 && MD && MD->isConstexpr() && 7811 !MD->isStatic() && !isa<CXXConstructorDecl>(MD) && 7812 (MD->getTypeQualifiers() & Qualifiers::Const) == 0) { 7813 CXXMethodDecl *OldMD = nullptr; 7814 if (OldDecl) 7815 OldMD = dyn_cast<CXXMethodDecl>(OldDecl->getAsFunction()); 7816 if (!OldMD || !OldMD->isStatic()) { 7817 const FunctionProtoType *FPT = 7818 MD->getType()->castAs<FunctionProtoType>(); 7819 FunctionProtoType::ExtProtoInfo EPI = FPT->getExtProtoInfo(); 7820 EPI.TypeQuals |= Qualifiers::Const; 7821 MD->setType(Context.getFunctionType(FPT->getReturnType(), 7822 FPT->getParamTypes(), EPI)); 7823 7824 // Warn that we did this, if we're not performing template instantiation. 7825 // In that case, we'll have warned already when the template was defined. 7826 if (ActiveTemplateInstantiations.empty()) { 7827 SourceLocation AddConstLoc; 7828 if (FunctionTypeLoc FTL = MD->getTypeSourceInfo()->getTypeLoc() 7829 .IgnoreParens().getAs<FunctionTypeLoc>()) 7830 AddConstLoc = getLocForEndOfToken(FTL.getRParenLoc()); 7831 7832 Diag(MD->getLocation(), diag::warn_cxx14_compat_constexpr_not_const) 7833 << FixItHint::CreateInsertion(AddConstLoc, " const"); 7834 } 7835 } 7836 } 7837 7838 if (Redeclaration) { 7839 // NewFD and OldDecl represent declarations that need to be 7840 // merged. 7841 if (MergeFunctionDecl(NewFD, OldDecl, S, MergeTypeWithPrevious)) { 7842 NewFD->setInvalidDecl(); 7843 return Redeclaration; 7844 } 7845 7846 Previous.clear(); 7847 Previous.addDecl(OldDecl); 7848 7849 if (FunctionTemplateDecl *OldTemplateDecl 7850 = dyn_cast<FunctionTemplateDecl>(OldDecl)) { 7851 NewFD->setPreviousDeclaration(OldTemplateDecl->getTemplatedDecl()); 7852 FunctionTemplateDecl *NewTemplateDecl 7853 = NewFD->getDescribedFunctionTemplate(); 7854 assert(NewTemplateDecl && "Template/non-template mismatch"); 7855 if (CXXMethodDecl *Method 7856 = dyn_cast<CXXMethodDecl>(NewTemplateDecl->getTemplatedDecl())) { 7857 Method->setAccess(OldTemplateDecl->getAccess()); 7858 NewTemplateDecl->setAccess(OldTemplateDecl->getAccess()); 7859 } 7860 7861 // If this is an explicit specialization of a member that is a function 7862 // template, mark it as a member specialization. 7863 if (IsExplicitSpecialization && 7864 NewTemplateDecl->getInstantiatedFromMemberTemplate()) { 7865 NewTemplateDecl->setMemberSpecialization(); 7866 assert(OldTemplateDecl->isMemberSpecialization()); 7867 } 7868 7869 } else { 7870 // This needs to happen first so that 'inline' propagates. 7871 NewFD->setPreviousDeclaration(cast<FunctionDecl>(OldDecl)); 7872 7873 if (isa<CXXMethodDecl>(NewFD)) { 7874 // A valid redeclaration of a C++ method must be out-of-line, 7875 // but (unfortunately) it's not necessarily a definition 7876 // because of templates, which means that the previous 7877 // declaration is not necessarily from the class definition. 7878 7879 // For just setting the access, that doesn't matter. 7880 CXXMethodDecl *oldMethod = cast<CXXMethodDecl>(OldDecl); 7881 NewFD->setAccess(oldMethod->getAccess()); 7882 7883 // Update the key-function state if necessary for this ABI. 7884 if (NewFD->isInlined() && 7885 !Context.getTargetInfo().getCXXABI().canKeyFunctionBeInline()) { 7886 // setNonKeyFunction needs to work with the original 7887 // declaration from the class definition, and isVirtual() is 7888 // just faster in that case, so map back to that now. 7889 oldMethod = cast<CXXMethodDecl>(oldMethod->getFirstDecl()); 7890 if (oldMethod->isVirtual()) { 7891 Context.setNonKeyFunction(oldMethod); 7892 } 7893 } 7894 } 7895 } 7896 } 7897 7898 // Semantic checking for this function declaration (in isolation). 7899 7900 // Diagnose the use of X86 fastcall on unprototyped functions. 7901 QualType NewQType = Context.getCanonicalType(NewFD->getType()); 7902 const FunctionType *NewType = cast<FunctionType>(NewQType); 7903 if (isa<FunctionNoProtoType>(NewType)) { 7904 FunctionType::ExtInfo NewTypeInfo = NewType->getExtInfo(); 7905 if (NewTypeInfo.getCC() == CC_X86FastCall) 7906 Diag(NewFD->getLocation(), diag::err_cconv_knr) 7907 << FunctionType::getNameForCallConv(CC_X86FastCall); 7908 // TODO: Also diagnose unprototyped stdcall functions? 7909 } 7910 7911 if (getLangOpts().CPlusPlus) { 7912 // C++-specific checks. 7913 if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(NewFD)) { 7914 CheckConstructor(Constructor); 7915 } else if (CXXDestructorDecl *Destructor = 7916 dyn_cast<CXXDestructorDecl>(NewFD)) { 7917 CXXRecordDecl *Record = Destructor->getParent(); 7918 QualType ClassType = Context.getTypeDeclType(Record); 7919 7920 // FIXME: Shouldn't we be able to perform this check even when the class 7921 // type is dependent? Both gcc and edg can handle that. 7922 if (!ClassType->isDependentType()) { 7923 DeclarationName Name 7924 = Context.DeclarationNames.getCXXDestructorName( 7925 Context.getCanonicalType(ClassType)); 7926 if (NewFD->getDeclName() != Name) { 7927 Diag(NewFD->getLocation(), diag::err_destructor_name); 7928 NewFD->setInvalidDecl(); 7929 return Redeclaration; 7930 } 7931 } 7932 } else if (CXXConversionDecl *Conversion 7933 = dyn_cast<CXXConversionDecl>(NewFD)) { 7934 ActOnConversionDeclarator(Conversion); 7935 } 7936 7937 // Find any virtual functions that this function overrides. 7938 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(NewFD)) { 7939 if (!Method->isFunctionTemplateSpecialization() && 7940 !Method->getDescribedFunctionTemplate() && 7941 Method->isCanonicalDecl()) { 7942 if (AddOverriddenMethods(Method->getParent(), Method)) { 7943 // If the function was marked as "static", we have a problem. 7944 if (NewFD->getStorageClass() == SC_Static) { 7945 ReportOverrides(*this, diag::err_static_overrides_virtual, Method); 7946 } 7947 } 7948 } 7949 7950 if (Method->isStatic()) 7951 checkThisInStaticMemberFunctionType(Method); 7952 } 7953 7954 // Extra checking for C++ overloaded operators (C++ [over.oper]). 7955 if (NewFD->isOverloadedOperator() && 7956 CheckOverloadedOperatorDeclaration(NewFD)) { 7957 NewFD->setInvalidDecl(); 7958 return Redeclaration; 7959 } 7960 7961 // Extra checking for C++0x literal operators (C++0x [over.literal]). 7962 if (NewFD->getLiteralIdentifier() && 7963 CheckLiteralOperatorDeclaration(NewFD)) { 7964 NewFD->setInvalidDecl(); 7965 return Redeclaration; 7966 } 7967 7968 // In C++, check default arguments now that we have merged decls. Unless 7969 // the lexical context is the class, because in this case this is done 7970 // during delayed parsing anyway. 7971 if (!CurContext->isRecord()) 7972 CheckCXXDefaultArguments(NewFD); 7973 7974 // If this function declares a builtin function, check the type of this 7975 // declaration against the expected type for the builtin. 7976 if (unsigned BuiltinID = NewFD->getBuiltinID()) { 7977 ASTContext::GetBuiltinTypeError Error; 7978 LookupPredefedObjCSuperType(*this, S, NewFD->getIdentifier()); 7979 QualType T = Context.GetBuiltinType(BuiltinID, Error); 7980 if (!T.isNull() && !Context.hasSameType(T, NewFD->getType())) { 7981 // The type of this function differs from the type of the builtin, 7982 // so forget about the builtin entirely. 7983 Context.BuiltinInfo.ForgetBuiltin(BuiltinID, Context.Idents); 7984 } 7985 } 7986 7987 // If this function is declared as being extern "C", then check to see if 7988 // the function returns a UDT (class, struct, or union type) that is not C 7989 // compatible, and if it does, warn the user. 7990 // But, issue any diagnostic on the first declaration only. 7991 if (NewFD->isExternC() && Previous.empty()) { 7992 QualType R = NewFD->getReturnType(); 7993 if (R->isIncompleteType() && !R->isVoidType()) 7994 Diag(NewFD->getLocation(), diag::warn_return_value_udt_incomplete) 7995 << NewFD << R; 7996 else if (!R.isPODType(Context) && !R->isVoidType() && 7997 !R->isObjCObjectPointerType()) 7998 Diag(NewFD->getLocation(), diag::warn_return_value_udt) << NewFD << R; 7999 } 8000 } 8001 return Redeclaration; 8002 } 8003 8004 void Sema::CheckMain(FunctionDecl* FD, const DeclSpec& DS) { 8005 // C++11 [basic.start.main]p3: 8006 // A program that [...] declares main to be inline, static or 8007 // constexpr is ill-formed. 8008 // C11 6.7.4p4: In a hosted environment, no function specifier(s) shall 8009 // appear in a declaration of main. 8010 // static main is not an error under C99, but we should warn about it. 8011 // We accept _Noreturn main as an extension. 8012 if (FD->getStorageClass() == SC_Static) 8013 Diag(DS.getStorageClassSpecLoc(), getLangOpts().CPlusPlus 8014 ? diag::err_static_main : diag::warn_static_main) 8015 << FixItHint::CreateRemoval(DS.getStorageClassSpecLoc()); 8016 if (FD->isInlineSpecified()) 8017 Diag(DS.getInlineSpecLoc(), diag::err_inline_main) 8018 << FixItHint::CreateRemoval(DS.getInlineSpecLoc()); 8019 if (DS.isNoreturnSpecified()) { 8020 SourceLocation NoreturnLoc = DS.getNoreturnSpecLoc(); 8021 SourceRange NoreturnRange(NoreturnLoc, getLocForEndOfToken(NoreturnLoc)); 8022 Diag(NoreturnLoc, diag::ext_noreturn_main); 8023 Diag(NoreturnLoc, diag::note_main_remove_noreturn) 8024 << FixItHint::CreateRemoval(NoreturnRange); 8025 } 8026 if (FD->isConstexpr()) { 8027 Diag(DS.getConstexprSpecLoc(), diag::err_constexpr_main) 8028 << FixItHint::CreateRemoval(DS.getConstexprSpecLoc()); 8029 FD->setConstexpr(false); 8030 } 8031 8032 if (getLangOpts().OpenCL) { 8033 Diag(FD->getLocation(), diag::err_opencl_no_main) 8034 << FD->hasAttr<OpenCLKernelAttr>(); 8035 FD->setInvalidDecl(); 8036 return; 8037 } 8038 8039 QualType T = FD->getType(); 8040 assert(T->isFunctionType() && "function decl is not of function type"); 8041 const FunctionType* FT = T->castAs<FunctionType>(); 8042 8043 if (getLangOpts().GNUMode && !getLangOpts().CPlusPlus) { 8044 // In C with GNU extensions we allow main() to have non-integer return 8045 // type, but we should warn about the extension, and we disable the 8046 // implicit-return-zero rule. 8047 8048 // GCC in C mode accepts qualified 'int'. 8049 if (Context.hasSameUnqualifiedType(FT->getReturnType(), Context.IntTy)) 8050 FD->setHasImplicitReturnZero(true); 8051 else { 8052 Diag(FD->getTypeSpecStartLoc(), diag::ext_main_returns_nonint); 8053 SourceRange RTRange = FD->getReturnTypeSourceRange(); 8054 if (RTRange.isValid()) 8055 Diag(RTRange.getBegin(), diag::note_main_change_return_type) 8056 << FixItHint::CreateReplacement(RTRange, "int"); 8057 } 8058 } else { 8059 // In C and C++, main magically returns 0 if you fall off the end; 8060 // set the flag which tells us that. 8061 // This is C++ [basic.start.main]p5 and C99 5.1.2.2.3. 8062 8063 // All the standards say that main() should return 'int'. 8064 if (Context.hasSameType(FT->getReturnType(), Context.IntTy)) 8065 FD->setHasImplicitReturnZero(true); 8066 else { 8067 // Otherwise, this is just a flat-out error. 8068 SourceRange RTRange = FD->getReturnTypeSourceRange(); 8069 Diag(FD->getTypeSpecStartLoc(), diag::err_main_returns_nonint) 8070 << (RTRange.isValid() ? FixItHint::CreateReplacement(RTRange, "int") 8071 : FixItHint()); 8072 FD->setInvalidDecl(true); 8073 } 8074 } 8075 8076 // Treat protoless main() as nullary. 8077 if (isa<FunctionNoProtoType>(FT)) return; 8078 8079 const FunctionProtoType* FTP = cast<const FunctionProtoType>(FT); 8080 unsigned nparams = FTP->getNumParams(); 8081 assert(FD->getNumParams() == nparams); 8082 8083 bool HasExtraParameters = (nparams > 3); 8084 8085 // Darwin passes an undocumented fourth argument of type char**. If 8086 // other platforms start sprouting these, the logic below will start 8087 // getting shifty. 8088 if (nparams == 4 && Context.getTargetInfo().getTriple().isOSDarwin()) 8089 HasExtraParameters = false; 8090 8091 if (HasExtraParameters) { 8092 Diag(FD->getLocation(), diag::err_main_surplus_args) << nparams; 8093 FD->setInvalidDecl(true); 8094 nparams = 3; 8095 } 8096 8097 // FIXME: a lot of the following diagnostics would be improved 8098 // if we had some location information about types. 8099 8100 QualType CharPP = 8101 Context.getPointerType(Context.getPointerType(Context.CharTy)); 8102 QualType Expected[] = { Context.IntTy, CharPP, CharPP, CharPP }; 8103 8104 for (unsigned i = 0; i < nparams; ++i) { 8105 QualType AT = FTP->getParamType(i); 8106 8107 bool mismatch = true; 8108 8109 if (Context.hasSameUnqualifiedType(AT, Expected[i])) 8110 mismatch = false; 8111 else if (Expected[i] == CharPP) { 8112 // As an extension, the following forms are okay: 8113 // char const ** 8114 // char const * const * 8115 // char * const * 8116 8117 QualifierCollector qs; 8118 const PointerType* PT; 8119 if ((PT = qs.strip(AT)->getAs<PointerType>()) && 8120 (PT = qs.strip(PT->getPointeeType())->getAs<PointerType>()) && 8121 Context.hasSameType(QualType(qs.strip(PT->getPointeeType()), 0), 8122 Context.CharTy)) { 8123 qs.removeConst(); 8124 mismatch = !qs.empty(); 8125 } 8126 } 8127 8128 if (mismatch) { 8129 Diag(FD->getLocation(), diag::err_main_arg_wrong) << i << Expected[i]; 8130 // TODO: suggest replacing given type with expected type 8131 FD->setInvalidDecl(true); 8132 } 8133 } 8134 8135 if (nparams == 1 && !FD->isInvalidDecl()) { 8136 Diag(FD->getLocation(), diag::warn_main_one_arg); 8137 } 8138 8139 if (!FD->isInvalidDecl() && FD->getDescribedFunctionTemplate()) { 8140 Diag(FD->getLocation(), diag::err_mainlike_template_decl) << FD; 8141 FD->setInvalidDecl(); 8142 } 8143 } 8144 8145 void Sema::CheckMSVCRTEntryPoint(FunctionDecl *FD) { 8146 QualType T = FD->getType(); 8147 assert(T->isFunctionType() && "function decl is not of function type"); 8148 const FunctionType *FT = T->castAs<FunctionType>(); 8149 8150 // Set an implicit return of 'zero' if the function can return some integral, 8151 // enumeration, pointer or nullptr type. 8152 if (FT->getReturnType()->isIntegralOrEnumerationType() || 8153 FT->getReturnType()->isAnyPointerType() || 8154 FT->getReturnType()->isNullPtrType()) 8155 // DllMain is exempt because a return value of zero means it failed. 8156 if (FD->getName() != "DllMain") 8157 FD->setHasImplicitReturnZero(true); 8158 8159 if (!FD->isInvalidDecl() && FD->getDescribedFunctionTemplate()) { 8160 Diag(FD->getLocation(), diag::err_mainlike_template_decl) << FD; 8161 FD->setInvalidDecl(); 8162 } 8163 } 8164 8165 bool Sema::CheckForConstantInitializer(Expr *Init, QualType DclT) { 8166 // FIXME: Need strict checking. In C89, we need to check for 8167 // any assignment, increment, decrement, function-calls, or 8168 // commas outside of a sizeof. In C99, it's the same list, 8169 // except that the aforementioned are allowed in unevaluated 8170 // expressions. Everything else falls under the 8171 // "may accept other forms of constant expressions" exception. 8172 // (We never end up here for C++, so the constant expression 8173 // rules there don't matter.) 8174 const Expr *Culprit; 8175 if (Init->isConstantInitializer(Context, false, &Culprit)) 8176 return false; 8177 Diag(Culprit->getExprLoc(), diag::err_init_element_not_constant) 8178 << Culprit->getSourceRange(); 8179 return true; 8180 } 8181 8182 namespace { 8183 // Visits an initialization expression to see if OrigDecl is evaluated in 8184 // its own initialization and throws a warning if it does. 8185 class SelfReferenceChecker 8186 : public EvaluatedExprVisitor<SelfReferenceChecker> { 8187 Sema &S; 8188 Decl *OrigDecl; 8189 bool isRecordType; 8190 bool isPODType; 8191 bool isReferenceType; 8192 8193 public: 8194 typedef EvaluatedExprVisitor<SelfReferenceChecker> Inherited; 8195 8196 SelfReferenceChecker(Sema &S, Decl *OrigDecl) : Inherited(S.Context), 8197 S(S), OrigDecl(OrigDecl) { 8198 isPODType = false; 8199 isRecordType = false; 8200 isReferenceType = false; 8201 if (ValueDecl *VD = dyn_cast<ValueDecl>(OrigDecl)) { 8202 isPODType = VD->getType().isPODType(S.Context); 8203 isRecordType = VD->getType()->isRecordType(); 8204 isReferenceType = VD->getType()->isReferenceType(); 8205 } 8206 } 8207 8208 // For most expressions, the cast is directly above the DeclRefExpr. 8209 // For conditional operators, the cast can be outside the conditional 8210 // operator if both expressions are DeclRefExpr's. 8211 void HandleValue(Expr *E) { 8212 if (isReferenceType) 8213 return; 8214 E = E->IgnoreParens(); 8215 if (DeclRefExpr* DRE = dyn_cast<DeclRefExpr>(E)) { 8216 HandleDeclRefExpr(DRE); 8217 return; 8218 } 8219 8220 if (ConditionalOperator *CO = dyn_cast<ConditionalOperator>(E)) { 8221 HandleValue(CO->getTrueExpr()); 8222 HandleValue(CO->getFalseExpr()); 8223 return; 8224 } 8225 8226 if (BinaryConditionalOperator *BCO = 8227 dyn_cast<BinaryConditionalOperator>(E)) { 8228 HandleValue(BCO->getFalseExpr()); 8229 return; 8230 } 8231 8232 if (OpaqueValueExpr *OVE = dyn_cast<OpaqueValueExpr>(E)) { 8233 HandleValue(OVE->getSourceExpr()); 8234 return; 8235 } 8236 8237 if (BinaryOperator *BO = dyn_cast<BinaryOperator>(E)) { 8238 if (BO->getOpcode() == BO_Comma) 8239 HandleValue(BO->getRHS()); 8240 return; 8241 } 8242 8243 if (isa<MemberExpr>(E)) { 8244 Expr *Base = E->IgnoreParenImpCasts(); 8245 while (MemberExpr *ME = dyn_cast<MemberExpr>(Base)) { 8246 // Check for static member variables and don't warn on them. 8247 if (!isa<FieldDecl>(ME->getMemberDecl())) 8248 return; 8249 Base = ME->getBase()->IgnoreParenImpCasts(); 8250 } 8251 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Base)) 8252 HandleDeclRefExpr(DRE); 8253 return; 8254 } 8255 } 8256 8257 // Reference types are handled here since all uses of references are 8258 // bad, not just r-value uses. 8259 void VisitDeclRefExpr(DeclRefExpr *E) { 8260 if (isReferenceType) 8261 HandleDeclRefExpr(E); 8262 } 8263 8264 void VisitImplicitCastExpr(ImplicitCastExpr *E) { 8265 if (E->getCastKind() == CK_LValueToRValue || 8266 (isRecordType && E->getCastKind() == CK_NoOp)) 8267 HandleValue(E->getSubExpr()); 8268 8269 Inherited::VisitImplicitCastExpr(E); 8270 } 8271 8272 void VisitMemberExpr(MemberExpr *E) { 8273 // Don't warn on arrays since they can be treated as pointers. 8274 if (E->getType()->canDecayToPointerType()) return; 8275 8276 // Warn when a non-static method call is followed by non-static member 8277 // field accesses, which is followed by a DeclRefExpr. 8278 CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(E->getMemberDecl()); 8279 bool Warn = (MD && !MD->isStatic()); 8280 Expr *Base = E->getBase()->IgnoreParenImpCasts(); 8281 while (MemberExpr *ME = dyn_cast<MemberExpr>(Base)) { 8282 if (!isa<FieldDecl>(ME->getMemberDecl())) 8283 Warn = false; 8284 Base = ME->getBase()->IgnoreParenImpCasts(); 8285 } 8286 8287 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Base)) { 8288 if (Warn) 8289 HandleDeclRefExpr(DRE); 8290 return; 8291 } 8292 8293 // The base of a MemberExpr is not a MemberExpr or a DeclRefExpr. 8294 // Visit that expression. 8295 Visit(Base); 8296 } 8297 8298 void VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E) { 8299 if (E->getNumArgs() > 0) 8300 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E->getArg(0))) 8301 HandleDeclRefExpr(DRE); 8302 8303 Inherited::VisitCXXOperatorCallExpr(E); 8304 } 8305 8306 void VisitUnaryOperator(UnaryOperator *E) { 8307 // For POD record types, addresses of its own members are well-defined. 8308 if (E->getOpcode() == UO_AddrOf && isRecordType && 8309 isa<MemberExpr>(E->getSubExpr()->IgnoreParens())) { 8310 if (!isPODType) 8311 HandleValue(E->getSubExpr()); 8312 return; 8313 } 8314 Inherited::VisitUnaryOperator(E); 8315 } 8316 8317 void VisitObjCMessageExpr(ObjCMessageExpr *E) { return; } 8318 8319 void VisitCXXConstructExpr(CXXConstructExpr *E) { 8320 if (E->getConstructor()->isCopyConstructor()) { 8321 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E->getArg(0))) { 8322 HandleDeclRefExpr(DRE); 8323 } 8324 } 8325 Inherited::VisitCXXConstructExpr(E); 8326 } 8327 8328 void VisitCallExpr(CallExpr *E) { 8329 // Treat std::move as a use. 8330 if (E->getNumArgs() == 1) { 8331 if (FunctionDecl *FD = E->getDirectCallee()) { 8332 if (FD->getIdentifier() && FD->getIdentifier()->isStr("move")) { 8333 HandleValue(E->getArg(0)); 8334 } 8335 } 8336 } 8337 8338 Inherited::VisitCallExpr(E); 8339 } 8340 8341 void HandleDeclRefExpr(DeclRefExpr *DRE) { 8342 Decl* ReferenceDecl = DRE->getDecl(); 8343 if (OrigDecl != ReferenceDecl) return; 8344 unsigned diag; 8345 if (isReferenceType) { 8346 diag = diag::warn_uninit_self_reference_in_reference_init; 8347 } else if (cast<VarDecl>(OrigDecl)->isStaticLocal()) { 8348 diag = diag::warn_static_self_reference_in_init; 8349 } else { 8350 diag = diag::warn_uninit_self_reference_in_init; 8351 } 8352 8353 S.DiagRuntimeBehavior(DRE->getLocStart(), DRE, 8354 S.PDiag(diag) 8355 << DRE->getNameInfo().getName() 8356 << OrigDecl->getLocation() 8357 << DRE->getSourceRange()); 8358 } 8359 }; 8360 8361 /// CheckSelfReference - Warns if OrigDecl is used in expression E. 8362 static void CheckSelfReference(Sema &S, Decl* OrigDecl, Expr *E, 8363 bool DirectInit) { 8364 // Parameters arguments are occassionially constructed with itself, 8365 // for instance, in recursive functions. Skip them. 8366 if (isa<ParmVarDecl>(OrigDecl)) 8367 return; 8368 8369 E = E->IgnoreParens(); 8370 8371 // Skip checking T a = a where T is not a record or reference type. 8372 // Doing so is a way to silence uninitialized warnings. 8373 if (!DirectInit && !cast<VarDecl>(OrigDecl)->getType()->isRecordType()) 8374 if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E)) 8375 if (ICE->getCastKind() == CK_LValueToRValue) 8376 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(ICE->getSubExpr())) 8377 if (DRE->getDecl() == OrigDecl) 8378 return; 8379 8380 SelfReferenceChecker(S, OrigDecl).Visit(E); 8381 } 8382 } 8383 8384 /// AddInitializerToDecl - Adds the initializer Init to the 8385 /// declaration dcl. If DirectInit is true, this is C++ direct 8386 /// initialization rather than copy initialization. 8387 void Sema::AddInitializerToDecl(Decl *RealDecl, Expr *Init, 8388 bool DirectInit, bool TypeMayContainAuto) { 8389 // If there is no declaration, there was an error parsing it. Just ignore 8390 // the initializer. 8391 if (!RealDecl || RealDecl->isInvalidDecl()) 8392 return; 8393 8394 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(RealDecl)) { 8395 // With declarators parsed the way they are, the parser cannot 8396 // distinguish between a normal initializer and a pure-specifier. 8397 // Thus this grotesque test. 8398 IntegerLiteral *IL; 8399 if ((IL = dyn_cast<IntegerLiteral>(Init)) && IL->getValue() == 0 && 8400 Context.getCanonicalType(IL->getType()) == Context.IntTy) 8401 CheckPureMethod(Method, Init->getSourceRange()); 8402 else { 8403 Diag(Method->getLocation(), diag::err_member_function_initialization) 8404 << Method->getDeclName() << Init->getSourceRange(); 8405 Method->setInvalidDecl(); 8406 } 8407 return; 8408 } 8409 8410 VarDecl *VDecl = dyn_cast<VarDecl>(RealDecl); 8411 if (!VDecl) { 8412 assert(!isa<FieldDecl>(RealDecl) && "field init shouldn't get here"); 8413 Diag(RealDecl->getLocation(), diag::err_illegal_initializer); 8414 RealDecl->setInvalidDecl(); 8415 return; 8416 } 8417 ParenListExpr *CXXDirectInit = dyn_cast<ParenListExpr>(Init); 8418 8419 // C++11 [decl.spec.auto]p6. Deduce the type which 'auto' stands in for. 8420 if (TypeMayContainAuto && VDecl->getType()->isUndeducedType()) { 8421 Expr *DeduceInit = Init; 8422 // Initializer could be a C++ direct-initializer. Deduction only works if it 8423 // contains exactly one expression. 8424 if (CXXDirectInit) { 8425 if (CXXDirectInit->getNumExprs() == 0) { 8426 // It isn't possible to write this directly, but it is possible to 8427 // end up in this situation with "auto x(some_pack...);" 8428 Diag(CXXDirectInit->getLocStart(), 8429 VDecl->isInitCapture() ? diag::err_init_capture_no_expression 8430 : diag::err_auto_var_init_no_expression) 8431 << VDecl->getDeclName() << VDecl->getType() 8432 << VDecl->getSourceRange(); 8433 RealDecl->setInvalidDecl(); 8434 return; 8435 } else if (CXXDirectInit->getNumExprs() > 1) { 8436 Diag(CXXDirectInit->getExpr(1)->getLocStart(), 8437 VDecl->isInitCapture() 8438 ? diag::err_init_capture_multiple_expressions 8439 : diag::err_auto_var_init_multiple_expressions) 8440 << VDecl->getDeclName() << VDecl->getType() 8441 << VDecl->getSourceRange(); 8442 RealDecl->setInvalidDecl(); 8443 return; 8444 } else { 8445 DeduceInit = CXXDirectInit->getExpr(0); 8446 if (isa<InitListExpr>(DeduceInit)) 8447 Diag(CXXDirectInit->getLocStart(), 8448 diag::err_auto_var_init_paren_braces) 8449 << VDecl->getDeclName() << VDecl->getType() 8450 << VDecl->getSourceRange(); 8451 } 8452 } 8453 8454 // Expressions default to 'id' when we're in a debugger. 8455 bool DefaultedToAuto = false; 8456 if (getLangOpts().DebuggerCastResultToId && 8457 Init->getType() == Context.UnknownAnyTy) { 8458 ExprResult Result = forceUnknownAnyToType(Init, Context.getObjCIdType()); 8459 if (Result.isInvalid()) { 8460 VDecl->setInvalidDecl(); 8461 return; 8462 } 8463 Init = Result.get(); 8464 DefaultedToAuto = true; 8465 } 8466 8467 QualType DeducedType; 8468 if (DeduceAutoType(VDecl->getTypeSourceInfo(), DeduceInit, DeducedType) == 8469 DAR_Failed) 8470 DiagnoseAutoDeductionFailure(VDecl, DeduceInit); 8471 if (DeducedType.isNull()) { 8472 RealDecl->setInvalidDecl(); 8473 return; 8474 } 8475 VDecl->setType(DeducedType); 8476 assert(VDecl->isLinkageValid()); 8477 8478 // In ARC, infer lifetime. 8479 if (getLangOpts().ObjCAutoRefCount && inferObjCARCLifetime(VDecl)) 8480 VDecl->setInvalidDecl(); 8481 8482 // Warn if we deduced 'id'. 'auto' usually implies type-safety, but using 8483 // 'id' instead of a specific object type prevents most of our usual checks. 8484 // We only want to warn outside of template instantiations, though: 8485 // inside a template, the 'id' could have come from a parameter. 8486 if (ActiveTemplateInstantiations.empty() && !DefaultedToAuto && 8487 DeducedType->isObjCIdType()) { 8488 SourceLocation Loc = 8489 VDecl->getTypeSourceInfo()->getTypeLoc().getBeginLoc(); 8490 Diag(Loc, diag::warn_auto_var_is_id) 8491 << VDecl->getDeclName() << DeduceInit->getSourceRange(); 8492 } 8493 8494 // If this is a redeclaration, check that the type we just deduced matches 8495 // the previously declared type. 8496 if (VarDecl *Old = VDecl->getPreviousDecl()) { 8497 // We never need to merge the type, because we cannot form an incomplete 8498 // array of auto, nor deduce such a type. 8499 MergeVarDeclTypes(VDecl, Old, /*MergeTypeWithPrevious*/false); 8500 } 8501 8502 // Check the deduced type is valid for a variable declaration. 8503 CheckVariableDeclarationType(VDecl); 8504 if (VDecl->isInvalidDecl()) 8505 return; 8506 } 8507 8508 // dllimport cannot be used on variable definitions. 8509 if (VDecl->hasAttr<DLLImportAttr>() && !VDecl->isStaticDataMember()) { 8510 Diag(VDecl->getLocation(), diag::err_attribute_dllimport_data_definition); 8511 VDecl->setInvalidDecl(); 8512 return; 8513 } 8514 8515 if (VDecl->isLocalVarDecl() && VDecl->hasExternalStorage()) { 8516 // C99 6.7.8p5. C++ has no such restriction, but that is a defect. 8517 Diag(VDecl->getLocation(), diag::err_block_extern_cant_init); 8518 VDecl->setInvalidDecl(); 8519 return; 8520 } 8521 8522 if (!VDecl->getType()->isDependentType()) { 8523 // A definition must end up with a complete type, which means it must be 8524 // complete with the restriction that an array type might be completed by 8525 // the initializer; note that later code assumes this restriction. 8526 QualType BaseDeclType = VDecl->getType(); 8527 if (const ArrayType *Array = Context.getAsIncompleteArrayType(BaseDeclType)) 8528 BaseDeclType = Array->getElementType(); 8529 if (RequireCompleteType(VDecl->getLocation(), BaseDeclType, 8530 diag::err_typecheck_decl_incomplete_type)) { 8531 RealDecl->setInvalidDecl(); 8532 return; 8533 } 8534 8535 // The variable can not have an abstract class type. 8536 if (RequireNonAbstractType(VDecl->getLocation(), VDecl->getType(), 8537 diag::err_abstract_type_in_decl, 8538 AbstractVariableType)) 8539 VDecl->setInvalidDecl(); 8540 } 8541 8542 const VarDecl *Def; 8543 if ((Def = VDecl->getDefinition()) && Def != VDecl) { 8544 Diag(VDecl->getLocation(), diag::err_redefinition) 8545 << VDecl->getDeclName(); 8546 Diag(Def->getLocation(), diag::note_previous_definition); 8547 VDecl->setInvalidDecl(); 8548 return; 8549 } 8550 8551 const VarDecl *PrevInit = nullptr; 8552 if (getLangOpts().CPlusPlus) { 8553 // C++ [class.static.data]p4 8554 // If a static data member is of const integral or const 8555 // enumeration type, its declaration in the class definition can 8556 // specify a constant-initializer which shall be an integral 8557 // constant expression (5.19). In that case, the member can appear 8558 // in integral constant expressions. The member shall still be 8559 // defined in a namespace scope if it is used in the program and the 8560 // namespace scope definition shall not contain an initializer. 8561 // 8562 // We already performed a redefinition check above, but for static 8563 // data members we also need to check whether there was an in-class 8564 // declaration with an initializer. 8565 if (VDecl->isStaticDataMember() && VDecl->getAnyInitializer(PrevInit)) { 8566 Diag(Init->getExprLoc(), diag::err_static_data_member_reinitialization) 8567 << VDecl->getDeclName(); 8568 Diag(PrevInit->getInit()->getExprLoc(), diag::note_previous_initializer) << 0; 8569 return; 8570 } 8571 8572 if (VDecl->hasLocalStorage()) 8573 getCurFunction()->setHasBranchProtectedScope(); 8574 8575 if (DiagnoseUnexpandedParameterPack(Init, UPPC_Initializer)) { 8576 VDecl->setInvalidDecl(); 8577 return; 8578 } 8579 } 8580 8581 // OpenCL 1.1 6.5.2: "Variables allocated in the __local address space inside 8582 // a kernel function cannot be initialized." 8583 if (VDecl->getStorageClass() == SC_OpenCLWorkGroupLocal) { 8584 Diag(VDecl->getLocation(), diag::err_local_cant_init); 8585 VDecl->setInvalidDecl(); 8586 return; 8587 } 8588 8589 // Get the decls type and save a reference for later, since 8590 // CheckInitializerTypes may change it. 8591 QualType DclT = VDecl->getType(), SavT = DclT; 8592 8593 // Expressions default to 'id' when we're in a debugger 8594 // and we are assigning it to a variable of Objective-C pointer type. 8595 if (getLangOpts().DebuggerCastResultToId && DclT->isObjCObjectPointerType() && 8596 Init->getType() == Context.UnknownAnyTy) { 8597 ExprResult Result = forceUnknownAnyToType(Init, Context.getObjCIdType()); 8598 if (Result.isInvalid()) { 8599 VDecl->setInvalidDecl(); 8600 return; 8601 } 8602 Init = Result.get(); 8603 } 8604 8605 // Perform the initialization. 8606 if (!VDecl->isInvalidDecl()) { 8607 InitializedEntity Entity = InitializedEntity::InitializeVariable(VDecl); 8608 InitializationKind Kind 8609 = DirectInit ? 8610 CXXDirectInit ? InitializationKind::CreateDirect(VDecl->getLocation(), 8611 Init->getLocStart(), 8612 Init->getLocEnd()) 8613 : InitializationKind::CreateDirectList( 8614 VDecl->getLocation()) 8615 : InitializationKind::CreateCopy(VDecl->getLocation(), 8616 Init->getLocStart()); 8617 8618 MultiExprArg Args = Init; 8619 if (CXXDirectInit) 8620 Args = MultiExprArg(CXXDirectInit->getExprs(), 8621 CXXDirectInit->getNumExprs()); 8622 8623 InitializationSequence InitSeq(*this, Entity, Kind, Args); 8624 ExprResult Result = InitSeq.Perform(*this, Entity, Kind, Args, &DclT); 8625 if (Result.isInvalid()) { 8626 VDecl->setInvalidDecl(); 8627 return; 8628 } 8629 8630 Init = Result.getAs<Expr>(); 8631 } 8632 8633 // Check for self-references within variable initializers. 8634 // Variables declared within a function/method body (except for references) 8635 // are handled by a dataflow analysis. 8636 if (!VDecl->hasLocalStorage() || VDecl->getType()->isRecordType() || 8637 VDecl->getType()->isReferenceType()) { 8638 CheckSelfReference(*this, RealDecl, Init, DirectInit); 8639 } 8640 8641 // If the type changed, it means we had an incomplete type that was 8642 // completed by the initializer. For example: 8643 // int ary[] = { 1, 3, 5 }; 8644 // "ary" transitions from an IncompleteArrayType to a ConstantArrayType. 8645 if (!VDecl->isInvalidDecl() && (DclT != SavT)) 8646 VDecl->setType(DclT); 8647 8648 if (!VDecl->isInvalidDecl()) { 8649 checkUnsafeAssigns(VDecl->getLocation(), VDecl->getType(), Init); 8650 8651 if (VDecl->hasAttr<BlocksAttr>()) 8652 checkRetainCycles(VDecl, Init); 8653 8654 // It is safe to assign a weak reference into a strong variable. 8655 // Although this code can still have problems: 8656 // id x = self.weakProp; 8657 // id y = self.weakProp; 8658 // we do not warn to warn spuriously when 'x' and 'y' are on separate 8659 // paths through the function. This should be revisited if 8660 // -Wrepeated-use-of-weak is made flow-sensitive. 8661 if (VDecl->getType().getObjCLifetime() == Qualifiers::OCL_Strong && 8662 !Diags.isIgnored(diag::warn_arc_repeated_use_of_weak, 8663 Init->getLocStart())) 8664 getCurFunction()->markSafeWeakUse(Init); 8665 } 8666 8667 // The initialization is usually a full-expression. 8668 // 8669 // FIXME: If this is a braced initialization of an aggregate, it is not 8670 // an expression, and each individual field initializer is a separate 8671 // full-expression. For instance, in: 8672 // 8673 // struct Temp { ~Temp(); }; 8674 // struct S { S(Temp); }; 8675 // struct T { S a, b; } t = { Temp(), Temp() } 8676 // 8677 // we should destroy the first Temp before constructing the second. 8678 ExprResult Result = ActOnFinishFullExpr(Init, VDecl->getLocation(), 8679 false, 8680 VDecl->isConstexpr()); 8681 if (Result.isInvalid()) { 8682 VDecl->setInvalidDecl(); 8683 return; 8684 } 8685 Init = Result.get(); 8686 8687 // Attach the initializer to the decl. 8688 VDecl->setInit(Init); 8689 8690 if (VDecl->isLocalVarDecl()) { 8691 // C99 6.7.8p4: All the expressions in an initializer for an object that has 8692 // static storage duration shall be constant expressions or string literals. 8693 // C++ does not have this restriction. 8694 if (!getLangOpts().CPlusPlus && !VDecl->isInvalidDecl()) { 8695 const Expr *Culprit; 8696 if (VDecl->getStorageClass() == SC_Static) 8697 CheckForConstantInitializer(Init, DclT); 8698 // C89 is stricter than C99 for non-static aggregate types. 8699 // C89 6.5.7p3: All the expressions [...] in an initializer list 8700 // for an object that has aggregate or union type shall be 8701 // constant expressions. 8702 else if (!getLangOpts().C99 && VDecl->getType()->isAggregateType() && 8703 isa<InitListExpr>(Init) && 8704 !Init->isConstantInitializer(Context, false, &Culprit)) 8705 Diag(Culprit->getExprLoc(), 8706 diag::ext_aggregate_init_not_constant) 8707 << Culprit->getSourceRange(); 8708 } 8709 } else if (VDecl->isStaticDataMember() && 8710 VDecl->getLexicalDeclContext()->isRecord()) { 8711 // This is an in-class initialization for a static data member, e.g., 8712 // 8713 // struct S { 8714 // static const int value = 17; 8715 // }; 8716 8717 // C++ [class.mem]p4: 8718 // A member-declarator can contain a constant-initializer only 8719 // if it declares a static member (9.4) of const integral or 8720 // const enumeration type, see 9.4.2. 8721 // 8722 // C++11 [class.static.data]p3: 8723 // If a non-volatile const static data member is of integral or 8724 // enumeration type, its declaration in the class definition can 8725 // specify a brace-or-equal-initializer in which every initalizer-clause 8726 // that is an assignment-expression is a constant expression. A static 8727 // data member of literal type can be declared in the class definition 8728 // with the constexpr specifier; if so, its declaration shall specify a 8729 // brace-or-equal-initializer in which every initializer-clause that is 8730 // an assignment-expression is a constant expression. 8731 8732 // Do nothing on dependent types. 8733 if (DclT->isDependentType()) { 8734 8735 // Allow any 'static constexpr' members, whether or not they are of literal 8736 // type. We separately check that every constexpr variable is of literal 8737 // type. 8738 } else if (VDecl->isConstexpr()) { 8739 8740 // Require constness. 8741 } else if (!DclT.isConstQualified()) { 8742 Diag(VDecl->getLocation(), diag::err_in_class_initializer_non_const) 8743 << Init->getSourceRange(); 8744 VDecl->setInvalidDecl(); 8745 8746 // We allow integer constant expressions in all cases. 8747 } else if (DclT->isIntegralOrEnumerationType()) { 8748 // Check whether the expression is a constant expression. 8749 SourceLocation Loc; 8750 if (getLangOpts().CPlusPlus11 && DclT.isVolatileQualified()) 8751 // In C++11, a non-constexpr const static data member with an 8752 // in-class initializer cannot be volatile. 8753 Diag(VDecl->getLocation(), diag::err_in_class_initializer_volatile); 8754 else if (Init->isValueDependent()) 8755 ; // Nothing to check. 8756 else if (Init->isIntegerConstantExpr(Context, &Loc)) 8757 ; // Ok, it's an ICE! 8758 else if (Init->isEvaluatable(Context)) { 8759 // If we can constant fold the initializer through heroics, accept it, 8760 // but report this as a use of an extension for -pedantic. 8761 Diag(Loc, diag::ext_in_class_initializer_non_constant) 8762 << Init->getSourceRange(); 8763 } else { 8764 // Otherwise, this is some crazy unknown case. Report the issue at the 8765 // location provided by the isIntegerConstantExpr failed check. 8766 Diag(Loc, diag::err_in_class_initializer_non_constant) 8767 << Init->getSourceRange(); 8768 VDecl->setInvalidDecl(); 8769 } 8770 8771 // We allow foldable floating-point constants as an extension. 8772 } else if (DclT->isFloatingType()) { // also permits complex, which is ok 8773 // In C++98, this is a GNU extension. In C++11, it is not, but we support 8774 // it anyway and provide a fixit to add the 'constexpr'. 8775 if (getLangOpts().CPlusPlus11) { 8776 Diag(VDecl->getLocation(), 8777 diag::ext_in_class_initializer_float_type_cxx11) 8778 << DclT << Init->getSourceRange(); 8779 Diag(VDecl->getLocStart(), 8780 diag::note_in_class_initializer_float_type_cxx11) 8781 << FixItHint::CreateInsertion(VDecl->getLocStart(), "constexpr "); 8782 } else { 8783 Diag(VDecl->getLocation(), diag::ext_in_class_initializer_float_type) 8784 << DclT << Init->getSourceRange(); 8785 8786 if (!Init->isValueDependent() && !Init->isEvaluatable(Context)) { 8787 Diag(Init->getExprLoc(), diag::err_in_class_initializer_non_constant) 8788 << Init->getSourceRange(); 8789 VDecl->setInvalidDecl(); 8790 } 8791 } 8792 8793 // Suggest adding 'constexpr' in C++11 for literal types. 8794 } else if (getLangOpts().CPlusPlus11 && DclT->isLiteralType(Context)) { 8795 Diag(VDecl->getLocation(), diag::err_in_class_initializer_literal_type) 8796 << DclT << Init->getSourceRange() 8797 << FixItHint::CreateInsertion(VDecl->getLocStart(), "constexpr "); 8798 VDecl->setConstexpr(true); 8799 8800 } else { 8801 Diag(VDecl->getLocation(), diag::err_in_class_initializer_bad_type) 8802 << DclT << Init->getSourceRange(); 8803 VDecl->setInvalidDecl(); 8804 } 8805 } else if (VDecl->isFileVarDecl()) { 8806 if (VDecl->getStorageClass() == SC_Extern && 8807 (!getLangOpts().CPlusPlus || 8808 !(Context.getBaseElementType(VDecl->getType()).isConstQualified() || 8809 VDecl->isExternC())) && 8810 !isTemplateInstantiation(VDecl->getTemplateSpecializationKind())) 8811 Diag(VDecl->getLocation(), diag::warn_extern_init); 8812 8813 // C99 6.7.8p4. All file scoped initializers need to be constant. 8814 if (!getLangOpts().CPlusPlus && !VDecl->isInvalidDecl()) 8815 CheckForConstantInitializer(Init, DclT); 8816 } 8817 8818 // We will represent direct-initialization similarly to copy-initialization: 8819 // int x(1); -as-> int x = 1; 8820 // ClassType x(a,b,c); -as-> ClassType x = ClassType(a,b,c); 8821 // 8822 // Clients that want to distinguish between the two forms, can check for 8823 // direct initializer using VarDecl::getInitStyle(). 8824 // A major benefit is that clients that don't particularly care about which 8825 // exactly form was it (like the CodeGen) can handle both cases without 8826 // special case code. 8827 8828 // C++ 8.5p11: 8829 // The form of initialization (using parentheses or '=') is generally 8830 // insignificant, but does matter when the entity being initialized has a 8831 // class type. 8832 if (CXXDirectInit) { 8833 assert(DirectInit && "Call-style initializer must be direct init."); 8834 VDecl->setInitStyle(VarDecl::CallInit); 8835 } else if (DirectInit) { 8836 // This must be list-initialization. No other way is direct-initialization. 8837 VDecl->setInitStyle(VarDecl::ListInit); 8838 } 8839 8840 CheckCompleteVariableDeclaration(VDecl); 8841 } 8842 8843 /// ActOnInitializerError - Given that there was an error parsing an 8844 /// initializer for the given declaration, try to return to some form 8845 /// of sanity. 8846 void Sema::ActOnInitializerError(Decl *D) { 8847 // Our main concern here is re-establishing invariants like "a 8848 // variable's type is either dependent or complete". 8849 if (!D || D->isInvalidDecl()) return; 8850 8851 VarDecl *VD = dyn_cast<VarDecl>(D); 8852 if (!VD) return; 8853 8854 // Auto types are meaningless if we can't make sense of the initializer. 8855 if (ParsingInitForAutoVars.count(D)) { 8856 D->setInvalidDecl(); 8857 return; 8858 } 8859 8860 QualType Ty = VD->getType(); 8861 if (Ty->isDependentType()) return; 8862 8863 // Require a complete type. 8864 if (RequireCompleteType(VD->getLocation(), 8865 Context.getBaseElementType(Ty), 8866 diag::err_typecheck_decl_incomplete_type)) { 8867 VD->setInvalidDecl(); 8868 return; 8869 } 8870 8871 // Require a non-abstract type. 8872 if (RequireNonAbstractType(VD->getLocation(), Ty, 8873 diag::err_abstract_type_in_decl, 8874 AbstractVariableType)) { 8875 VD->setInvalidDecl(); 8876 return; 8877 } 8878 8879 // Don't bother complaining about constructors or destructors, 8880 // though. 8881 } 8882 8883 void Sema::ActOnUninitializedDecl(Decl *RealDecl, 8884 bool TypeMayContainAuto) { 8885 // If there is no declaration, there was an error parsing it. Just ignore it. 8886 if (!RealDecl) 8887 return; 8888 8889 if (VarDecl *Var = dyn_cast<VarDecl>(RealDecl)) { 8890 QualType Type = Var->getType(); 8891 8892 // C++11 [dcl.spec.auto]p3 8893 if (TypeMayContainAuto && Type->getContainedAutoType()) { 8894 Diag(Var->getLocation(), diag::err_auto_var_requires_init) 8895 << Var->getDeclName() << Type; 8896 Var->setInvalidDecl(); 8897 return; 8898 } 8899 8900 // C++11 [class.static.data]p3: A static data member can be declared with 8901 // the constexpr specifier; if so, its declaration shall specify 8902 // a brace-or-equal-initializer. 8903 // C++11 [dcl.constexpr]p1: The constexpr specifier shall be applied only to 8904 // the definition of a variable [...] or the declaration of a static data 8905 // member. 8906 if (Var->isConstexpr() && !Var->isThisDeclarationADefinition()) { 8907 if (Var->isStaticDataMember()) 8908 Diag(Var->getLocation(), 8909 diag::err_constexpr_static_mem_var_requires_init) 8910 << Var->getDeclName(); 8911 else 8912 Diag(Var->getLocation(), diag::err_invalid_constexpr_var_decl); 8913 Var->setInvalidDecl(); 8914 return; 8915 } 8916 8917 // OpenCL v1.1 s6.5.3: variables declared in the constant address space must 8918 // be initialized. 8919 if (!Var->isInvalidDecl() && 8920 Var->getType().getAddressSpace() == LangAS::opencl_constant && 8921 Var->getStorageClass() != SC_Extern && !Var->getInit()) { 8922 Diag(Var->getLocation(), diag::err_opencl_constant_no_init); 8923 Var->setInvalidDecl(); 8924 return; 8925 } 8926 8927 switch (Var->isThisDeclarationADefinition()) { 8928 case VarDecl::Definition: 8929 if (!Var->isStaticDataMember() || !Var->getAnyInitializer()) 8930 break; 8931 8932 // We have an out-of-line definition of a static data member 8933 // that has an in-class initializer, so we type-check this like 8934 // a declaration. 8935 // 8936 // Fall through 8937 8938 case VarDecl::DeclarationOnly: 8939 // It's only a declaration. 8940 8941 // Block scope. C99 6.7p7: If an identifier for an object is 8942 // declared with no linkage (C99 6.2.2p6), the type for the 8943 // object shall be complete. 8944 if (!Type->isDependentType() && Var->isLocalVarDecl() && 8945 !Var->hasLinkage() && !Var->isInvalidDecl() && 8946 RequireCompleteType(Var->getLocation(), Type, 8947 diag::err_typecheck_decl_incomplete_type)) 8948 Var->setInvalidDecl(); 8949 8950 // Make sure that the type is not abstract. 8951 if (!Type->isDependentType() && !Var->isInvalidDecl() && 8952 RequireNonAbstractType(Var->getLocation(), Type, 8953 diag::err_abstract_type_in_decl, 8954 AbstractVariableType)) 8955 Var->setInvalidDecl(); 8956 if (!Type->isDependentType() && !Var->isInvalidDecl() && 8957 Var->getStorageClass() == SC_PrivateExtern) { 8958 Diag(Var->getLocation(), diag::warn_private_extern); 8959 Diag(Var->getLocation(), diag::note_private_extern); 8960 } 8961 8962 return; 8963 8964 case VarDecl::TentativeDefinition: 8965 // File scope. C99 6.9.2p2: A declaration of an identifier for an 8966 // object that has file scope without an initializer, and without a 8967 // storage-class specifier or with the storage-class specifier "static", 8968 // constitutes a tentative definition. Note: A tentative definition with 8969 // external linkage is valid (C99 6.2.2p5). 8970 if (!Var->isInvalidDecl()) { 8971 if (const IncompleteArrayType *ArrayT 8972 = Context.getAsIncompleteArrayType(Type)) { 8973 if (RequireCompleteType(Var->getLocation(), 8974 ArrayT->getElementType(), 8975 diag::err_illegal_decl_array_incomplete_type)) 8976 Var->setInvalidDecl(); 8977 } else if (Var->getStorageClass() == SC_Static) { 8978 // C99 6.9.2p3: If the declaration of an identifier for an object is 8979 // a tentative definition and has internal linkage (C99 6.2.2p3), the 8980 // declared type shall not be an incomplete type. 8981 // NOTE: code such as the following 8982 // static struct s; 8983 // struct s { int a; }; 8984 // is accepted by gcc. Hence here we issue a warning instead of 8985 // an error and we do not invalidate the static declaration. 8986 // NOTE: to avoid multiple warnings, only check the first declaration. 8987 if (Var->isFirstDecl()) 8988 RequireCompleteType(Var->getLocation(), Type, 8989 diag::ext_typecheck_decl_incomplete_type); 8990 } 8991 } 8992 8993 // Record the tentative definition; we're done. 8994 if (!Var->isInvalidDecl()) 8995 TentativeDefinitions.push_back(Var); 8996 return; 8997 } 8998 8999 // Provide a specific diagnostic for uninitialized variable 9000 // definitions with incomplete array type. 9001 if (Type->isIncompleteArrayType()) { 9002 Diag(Var->getLocation(), 9003 diag::err_typecheck_incomplete_array_needs_initializer); 9004 Var->setInvalidDecl(); 9005 return; 9006 } 9007 9008 // Provide a specific diagnostic for uninitialized variable 9009 // definitions with reference type. 9010 if (Type->isReferenceType()) { 9011 Diag(Var->getLocation(), diag::err_reference_var_requires_init) 9012 << Var->getDeclName() 9013 << SourceRange(Var->getLocation(), Var->getLocation()); 9014 Var->setInvalidDecl(); 9015 return; 9016 } 9017 9018 // Do not attempt to type-check the default initializer for a 9019 // variable with dependent type. 9020 if (Type->isDependentType()) 9021 return; 9022 9023 if (Var->isInvalidDecl()) 9024 return; 9025 9026 if (!Var->hasAttr<AliasAttr>()) { 9027 if (RequireCompleteType(Var->getLocation(), 9028 Context.getBaseElementType(Type), 9029 diag::err_typecheck_decl_incomplete_type)) { 9030 Var->setInvalidDecl(); 9031 return; 9032 } 9033 } 9034 9035 // The variable can not have an abstract class type. 9036 if (RequireNonAbstractType(Var->getLocation(), Type, 9037 diag::err_abstract_type_in_decl, 9038 AbstractVariableType)) { 9039 Var->setInvalidDecl(); 9040 return; 9041 } 9042 9043 // Check for jumps past the implicit initializer. C++0x 9044 // clarifies that this applies to a "variable with automatic 9045 // storage duration", not a "local variable". 9046 // C++11 [stmt.dcl]p3 9047 // A program that jumps from a point where a variable with automatic 9048 // storage duration is not in scope to a point where it is in scope is 9049 // ill-formed unless the variable has scalar type, class type with a 9050 // trivial default constructor and a trivial destructor, a cv-qualified 9051 // version of one of these types, or an array of one of the preceding 9052 // types and is declared without an initializer. 9053 if (getLangOpts().CPlusPlus && Var->hasLocalStorage()) { 9054 if (const RecordType *Record 9055 = Context.getBaseElementType(Type)->getAs<RecordType>()) { 9056 CXXRecordDecl *CXXRecord = cast<CXXRecordDecl>(Record->getDecl()); 9057 // Mark the function for further checking even if the looser rules of 9058 // C++11 do not require such checks, so that we can diagnose 9059 // incompatibilities with C++98. 9060 if (!CXXRecord->isPOD()) 9061 getCurFunction()->setHasBranchProtectedScope(); 9062 } 9063 } 9064 9065 // C++03 [dcl.init]p9: 9066 // If no initializer is specified for an object, and the 9067 // object is of (possibly cv-qualified) non-POD class type (or 9068 // array thereof), the object shall be default-initialized; if 9069 // the object is of const-qualified type, the underlying class 9070 // type shall have a user-declared default 9071 // constructor. Otherwise, if no initializer is specified for 9072 // a non- static object, the object and its subobjects, if 9073 // any, have an indeterminate initial value); if the object 9074 // or any of its subobjects are of const-qualified type, the 9075 // program is ill-formed. 9076 // C++0x [dcl.init]p11: 9077 // If no initializer is specified for an object, the object is 9078 // default-initialized; [...]. 9079 InitializedEntity Entity = InitializedEntity::InitializeVariable(Var); 9080 InitializationKind Kind 9081 = InitializationKind::CreateDefault(Var->getLocation()); 9082 9083 InitializationSequence InitSeq(*this, Entity, Kind, None); 9084 ExprResult Init = InitSeq.Perform(*this, Entity, Kind, None); 9085 if (Init.isInvalid()) 9086 Var->setInvalidDecl(); 9087 else if (Init.get()) { 9088 Var->setInit(MaybeCreateExprWithCleanups(Init.get())); 9089 // This is important for template substitution. 9090 Var->setInitStyle(VarDecl::CallInit); 9091 } 9092 9093 CheckCompleteVariableDeclaration(Var); 9094 } 9095 } 9096 9097 void Sema::ActOnCXXForRangeDecl(Decl *D) { 9098 VarDecl *VD = dyn_cast<VarDecl>(D); 9099 if (!VD) { 9100 Diag(D->getLocation(), diag::err_for_range_decl_must_be_var); 9101 D->setInvalidDecl(); 9102 return; 9103 } 9104 9105 VD->setCXXForRangeDecl(true); 9106 9107 // for-range-declaration cannot be given a storage class specifier. 9108 int Error = -1; 9109 switch (VD->getStorageClass()) { 9110 case SC_None: 9111 break; 9112 case SC_Extern: 9113 Error = 0; 9114 break; 9115 case SC_Static: 9116 Error = 1; 9117 break; 9118 case SC_PrivateExtern: 9119 Error = 2; 9120 break; 9121 case SC_Auto: 9122 Error = 3; 9123 break; 9124 case SC_Register: 9125 Error = 4; 9126 break; 9127 case SC_OpenCLWorkGroupLocal: 9128 llvm_unreachable("Unexpected storage class"); 9129 } 9130 if (VD->isConstexpr()) 9131 Error = 5; 9132 if (Error != -1) { 9133 Diag(VD->getOuterLocStart(), diag::err_for_range_storage_class) 9134 << VD->getDeclName() << Error; 9135 D->setInvalidDecl(); 9136 } 9137 } 9138 9139 StmtResult 9140 Sema::ActOnCXXForRangeIdentifier(Scope *S, SourceLocation IdentLoc, 9141 IdentifierInfo *Ident, 9142 ParsedAttributes &Attrs, 9143 SourceLocation AttrEnd) { 9144 // C++1y [stmt.iter]p1: 9145 // A range-based for statement of the form 9146 // for ( for-range-identifier : for-range-initializer ) statement 9147 // is equivalent to 9148 // for ( auto&& for-range-identifier : for-range-initializer ) statement 9149 DeclSpec DS(Attrs.getPool().getFactory()); 9150 9151 const char *PrevSpec; 9152 unsigned DiagID; 9153 DS.SetTypeSpecType(DeclSpec::TST_auto, IdentLoc, PrevSpec, DiagID, 9154 getPrintingPolicy()); 9155 9156 Declarator D(DS, Declarator::ForContext); 9157 D.SetIdentifier(Ident, IdentLoc); 9158 D.takeAttributes(Attrs, AttrEnd); 9159 9160 ParsedAttributes EmptyAttrs(Attrs.getPool().getFactory()); 9161 D.AddTypeInfo(DeclaratorChunk::getReference(0, IdentLoc, /*lvalue*/false), 9162 EmptyAttrs, IdentLoc); 9163 Decl *Var = ActOnDeclarator(S, D); 9164 cast<VarDecl>(Var)->setCXXForRangeDecl(true); 9165 FinalizeDeclaration(Var); 9166 return ActOnDeclStmt(FinalizeDeclaratorGroup(S, DS, Var), IdentLoc, 9167 AttrEnd.isValid() ? AttrEnd : IdentLoc); 9168 } 9169 9170 void Sema::CheckCompleteVariableDeclaration(VarDecl *var) { 9171 if (var->isInvalidDecl()) return; 9172 9173 // In ARC, don't allow jumps past the implicit initialization of a 9174 // local retaining variable. 9175 if (getLangOpts().ObjCAutoRefCount && 9176 var->hasLocalStorage()) { 9177 switch (var->getType().getObjCLifetime()) { 9178 case Qualifiers::OCL_None: 9179 case Qualifiers::OCL_ExplicitNone: 9180 case Qualifiers::OCL_Autoreleasing: 9181 break; 9182 9183 case Qualifiers::OCL_Weak: 9184 case Qualifiers::OCL_Strong: 9185 getCurFunction()->setHasBranchProtectedScope(); 9186 break; 9187 } 9188 } 9189 9190 // Warn about externally-visible variables being defined without a 9191 // prior declaration. We only want to do this for global 9192 // declarations, but we also specifically need to avoid doing it for 9193 // class members because the linkage of an anonymous class can 9194 // change if it's later given a typedef name. 9195 if (var->isThisDeclarationADefinition() && 9196 var->getDeclContext()->getRedeclContext()->isFileContext() && 9197 var->isExternallyVisible() && var->hasLinkage() && 9198 !getDiagnostics().isIgnored(diag::warn_missing_variable_declarations, 9199 var->getLocation())) { 9200 // Find a previous declaration that's not a definition. 9201 VarDecl *prev = var->getPreviousDecl(); 9202 while (prev && prev->isThisDeclarationADefinition()) 9203 prev = prev->getPreviousDecl(); 9204 9205 if (!prev) 9206 Diag(var->getLocation(), diag::warn_missing_variable_declarations) << var; 9207 } 9208 9209 if (var->getTLSKind() == VarDecl::TLS_Static) { 9210 const Expr *Culprit; 9211 if (var->getType().isDestructedType()) { 9212 // GNU C++98 edits for __thread, [basic.start.term]p3: 9213 // The type of an object with thread storage duration shall not 9214 // have a non-trivial destructor. 9215 Diag(var->getLocation(), diag::err_thread_nontrivial_dtor); 9216 if (getLangOpts().CPlusPlus11) 9217 Diag(var->getLocation(), diag::note_use_thread_local); 9218 } else if (getLangOpts().CPlusPlus && var->hasInit() && 9219 !var->getInit()->isConstantInitializer( 9220 Context, var->getType()->isReferenceType(), &Culprit)) { 9221 // GNU C++98 edits for __thread, [basic.start.init]p4: 9222 // An object of thread storage duration shall not require dynamic 9223 // initialization. 9224 // FIXME: Need strict checking here. 9225 Diag(Culprit->getExprLoc(), diag::err_thread_dynamic_init) 9226 << Culprit->getSourceRange(); 9227 if (getLangOpts().CPlusPlus11) 9228 Diag(var->getLocation(), diag::note_use_thread_local); 9229 } 9230 9231 } 9232 9233 if (var->isThisDeclarationADefinition() && 9234 ActiveTemplateInstantiations.empty()) { 9235 PragmaStack<StringLiteral *> *Stack = nullptr; 9236 int SectionFlags = PSF_Implicit | PSF_Read; 9237 if (var->getType().isConstQualified()) 9238 Stack = &ConstSegStack; 9239 else if (!var->getInit()) { 9240 Stack = &BSSSegStack; 9241 SectionFlags |= PSF_Write; 9242 } else { 9243 Stack = &DataSegStack; 9244 SectionFlags |= PSF_Write; 9245 } 9246 if (!var->hasAttr<SectionAttr>() && Stack->CurrentValue) 9247 var->addAttr( 9248 SectionAttr::CreateImplicit(Context, SectionAttr::Declspec_allocate, 9249 Stack->CurrentValue->getString(), 9250 Stack->CurrentPragmaLocation)); 9251 if (const SectionAttr *SA = var->getAttr<SectionAttr>()) 9252 if (UnifySection(SA->getName(), SectionFlags, var)) 9253 var->dropAttr<SectionAttr>(); 9254 9255 // Apply the init_seg attribute if this has an initializer. If the 9256 // initializer turns out to not be dynamic, we'll end up ignoring this 9257 // attribute. 9258 if (CurInitSeg && var->getInit()) 9259 var->addAttr(InitSegAttr::CreateImplicit(Context, CurInitSeg->getString(), 9260 CurInitSegLoc)); 9261 } 9262 9263 // All the following checks are C++ only. 9264 if (!getLangOpts().CPlusPlus) return; 9265 9266 QualType type = var->getType(); 9267 if (type->isDependentType()) return; 9268 9269 // __block variables might require us to capture a copy-initializer. 9270 if (var->hasAttr<BlocksAttr>()) { 9271 // It's currently invalid to ever have a __block variable with an 9272 // array type; should we diagnose that here? 9273 9274 // Regardless, we don't want to ignore array nesting when 9275 // constructing this copy. 9276 if (type->isStructureOrClassType()) { 9277 EnterExpressionEvaluationContext scope(*this, PotentiallyEvaluated); 9278 SourceLocation poi = var->getLocation(); 9279 Expr *varRef =new (Context) DeclRefExpr(var, false, type, VK_LValue, poi); 9280 ExprResult result 9281 = PerformMoveOrCopyInitialization( 9282 InitializedEntity::InitializeBlock(poi, type, false), 9283 var, var->getType(), varRef, /*AllowNRVO=*/true); 9284 if (!result.isInvalid()) { 9285 result = MaybeCreateExprWithCleanups(result); 9286 Expr *init = result.getAs<Expr>(); 9287 Context.setBlockVarCopyInits(var, init); 9288 } 9289 } 9290 } 9291 9292 Expr *Init = var->getInit(); 9293 bool IsGlobal = var->hasGlobalStorage() && !var->isStaticLocal(); 9294 QualType baseType = Context.getBaseElementType(type); 9295 9296 if (!var->getDeclContext()->isDependentContext() && 9297 Init && !Init->isValueDependent()) { 9298 if (IsGlobal && !var->isConstexpr() && 9299 !getDiagnostics().isIgnored(diag::warn_global_constructor, 9300 var->getLocation())) { 9301 // Warn about globals which don't have a constant initializer. Don't 9302 // warn about globals with a non-trivial destructor because we already 9303 // warned about them. 9304 CXXRecordDecl *RD = baseType->getAsCXXRecordDecl(); 9305 if (!(RD && !RD->hasTrivialDestructor()) && 9306 !Init->isConstantInitializer(Context, baseType->isReferenceType())) 9307 Diag(var->getLocation(), diag::warn_global_constructor) 9308 << Init->getSourceRange(); 9309 } 9310 9311 if (var->isConstexpr()) { 9312 SmallVector<PartialDiagnosticAt, 8> Notes; 9313 if (!var->evaluateValue(Notes) || !var->isInitICE()) { 9314 SourceLocation DiagLoc = var->getLocation(); 9315 // If the note doesn't add any useful information other than a source 9316 // location, fold it into the primary diagnostic. 9317 if (Notes.size() == 1 && Notes[0].second.getDiagID() == 9318 diag::note_invalid_subexpr_in_const_expr) { 9319 DiagLoc = Notes[0].first; 9320 Notes.clear(); 9321 } 9322 Diag(DiagLoc, diag::err_constexpr_var_requires_const_init) 9323 << var << Init->getSourceRange(); 9324 for (unsigned I = 0, N = Notes.size(); I != N; ++I) 9325 Diag(Notes[I].first, Notes[I].second); 9326 } 9327 } else if (var->isUsableInConstantExpressions(Context)) { 9328 // Check whether the initializer of a const variable of integral or 9329 // enumeration type is an ICE now, since we can't tell whether it was 9330 // initialized by a constant expression if we check later. 9331 var->checkInitIsICE(); 9332 } 9333 } 9334 9335 // Require the destructor. 9336 if (const RecordType *recordType = baseType->getAs<RecordType>()) 9337 FinalizeVarWithDestructor(var, recordType); 9338 } 9339 9340 /// FinalizeDeclaration - called by ParseDeclarationAfterDeclarator to perform 9341 /// any semantic actions necessary after any initializer has been attached. 9342 void 9343 Sema::FinalizeDeclaration(Decl *ThisDecl) { 9344 // Note that we are no longer parsing the initializer for this declaration. 9345 ParsingInitForAutoVars.erase(ThisDecl); 9346 9347 VarDecl *VD = dyn_cast_or_null<VarDecl>(ThisDecl); 9348 if (!VD) 9349 return; 9350 9351 checkAttributesAfterMerging(*this, *VD); 9352 9353 // Static locals inherit dll attributes from their function. 9354 if (VD->isStaticLocal()) { 9355 if (FunctionDecl *FD = 9356 dyn_cast_or_null<FunctionDecl>(VD->getParentFunctionOrMethod())) { 9357 if (Attr *A = getDLLAttr(FD)) { 9358 auto *NewAttr = cast<InheritableAttr>(A->clone(getASTContext())); 9359 NewAttr->setInherited(true); 9360 VD->addAttr(NewAttr); 9361 } 9362 } 9363 } 9364 9365 // Imported static data members cannot be defined out-of-line. 9366 if (const DLLImportAttr *IA = VD->getAttr<DLLImportAttr>()) { 9367 if (VD->isStaticDataMember() && VD->isOutOfLine() && 9368 VD->isThisDeclarationADefinition()) { 9369 // We allow definitions of dllimport class template static data members 9370 // with a warning. 9371 CXXRecordDecl *Context = 9372 cast<CXXRecordDecl>(VD->getFirstDecl()->getDeclContext()); 9373 bool IsClassTemplateMember = 9374 isa<ClassTemplatePartialSpecializationDecl>(Context) || 9375 Context->getDescribedClassTemplate(); 9376 9377 Diag(VD->getLocation(), 9378 IsClassTemplateMember 9379 ? diag::warn_attribute_dllimport_static_field_definition 9380 : diag::err_attribute_dllimport_static_field_definition); 9381 Diag(IA->getLocation(), diag::note_attribute); 9382 if (!IsClassTemplateMember) 9383 VD->setInvalidDecl(); 9384 } 9385 } 9386 9387 if (UsedAttr *Attr = VD->getAttr<UsedAttr>()) { 9388 if (!Attr->isInherited() && !VD->isThisDeclarationADefinition()) { 9389 Diag(Attr->getLocation(), diag::warn_attribute_ignored) << Attr; 9390 VD->dropAttr<UsedAttr>(); 9391 } 9392 } 9393 9394 if (!VD->isInvalidDecl() && 9395 VD->isThisDeclarationADefinition() == VarDecl::TentativeDefinition) { 9396 if (const VarDecl *Def = VD->getDefinition()) { 9397 if (Def->hasAttr<AliasAttr>()) { 9398 Diag(VD->getLocation(), diag::err_tentative_after_alias) 9399 << VD->getDeclName(); 9400 Diag(Def->getLocation(), diag::note_previous_definition); 9401 VD->setInvalidDecl(); 9402 } 9403 } 9404 } 9405 9406 const DeclContext *DC = VD->getDeclContext(); 9407 // If there's a #pragma GCC visibility in scope, and this isn't a class 9408 // member, set the visibility of this variable. 9409 if (DC->getRedeclContext()->isFileContext() && VD->isExternallyVisible()) 9410 AddPushedVisibilityAttribute(VD); 9411 9412 // FIXME: Warn on unused templates. 9413 if (VD->isFileVarDecl() && !VD->getDescribedVarTemplate() && 9414 !isa<VarTemplatePartialSpecializationDecl>(VD)) 9415 MarkUnusedFileScopedDecl(VD); 9416 9417 // Now we have parsed the initializer and can update the table of magic 9418 // tag values. 9419 if (!VD->hasAttr<TypeTagForDatatypeAttr>() || 9420 !VD->getType()->isIntegralOrEnumerationType()) 9421 return; 9422 9423 for (const auto *I : ThisDecl->specific_attrs<TypeTagForDatatypeAttr>()) { 9424 const Expr *MagicValueExpr = VD->getInit(); 9425 if (!MagicValueExpr) { 9426 continue; 9427 } 9428 llvm::APSInt MagicValueInt; 9429 if (!MagicValueExpr->isIntegerConstantExpr(MagicValueInt, Context)) { 9430 Diag(I->getRange().getBegin(), 9431 diag::err_type_tag_for_datatype_not_ice) 9432 << LangOpts.CPlusPlus << MagicValueExpr->getSourceRange(); 9433 continue; 9434 } 9435 if (MagicValueInt.getActiveBits() > 64) { 9436 Diag(I->getRange().getBegin(), 9437 diag::err_type_tag_for_datatype_too_large) 9438 << LangOpts.CPlusPlus << MagicValueExpr->getSourceRange(); 9439 continue; 9440 } 9441 uint64_t MagicValue = MagicValueInt.getZExtValue(); 9442 RegisterTypeTagForDatatype(I->getArgumentKind(), 9443 MagicValue, 9444 I->getMatchingCType(), 9445 I->getLayoutCompatible(), 9446 I->getMustBeNull()); 9447 } 9448 } 9449 9450 Sema::DeclGroupPtrTy Sema::FinalizeDeclaratorGroup(Scope *S, const DeclSpec &DS, 9451 ArrayRef<Decl *> Group) { 9452 SmallVector<Decl*, 8> Decls; 9453 9454 if (DS.isTypeSpecOwned()) 9455 Decls.push_back(DS.getRepAsDecl()); 9456 9457 DeclaratorDecl *FirstDeclaratorInGroup = nullptr; 9458 for (unsigned i = 0, e = Group.size(); i != e; ++i) 9459 if (Decl *D = Group[i]) { 9460 if (DeclaratorDecl *DD = dyn_cast<DeclaratorDecl>(D)) 9461 if (!FirstDeclaratorInGroup) 9462 FirstDeclaratorInGroup = DD; 9463 Decls.push_back(D); 9464 } 9465 9466 if (DeclSpec::isDeclRep(DS.getTypeSpecType())) { 9467 if (TagDecl *Tag = dyn_cast_or_null<TagDecl>(DS.getRepAsDecl())) { 9468 HandleTagNumbering(*this, Tag, S); 9469 if (!Tag->hasNameForLinkage() && !Tag->hasDeclaratorForAnonDecl()) 9470 Tag->setDeclaratorForAnonDecl(FirstDeclaratorInGroup); 9471 } 9472 } 9473 9474 return BuildDeclaratorGroup(Decls, DS.containsPlaceholderType()); 9475 } 9476 9477 /// BuildDeclaratorGroup - convert a list of declarations into a declaration 9478 /// group, performing any necessary semantic checking. 9479 Sema::DeclGroupPtrTy 9480 Sema::BuildDeclaratorGroup(MutableArrayRef<Decl *> Group, 9481 bool TypeMayContainAuto) { 9482 // C++0x [dcl.spec.auto]p7: 9483 // If the type deduced for the template parameter U is not the same in each 9484 // deduction, the program is ill-formed. 9485 // FIXME: When initializer-list support is added, a distinction is needed 9486 // between the deduced type U and the deduced type which 'auto' stands for. 9487 // auto a = 0, b = { 1, 2, 3 }; 9488 // is legal because the deduced type U is 'int' in both cases. 9489 if (TypeMayContainAuto && Group.size() > 1) { 9490 QualType Deduced; 9491 CanQualType DeducedCanon; 9492 VarDecl *DeducedDecl = nullptr; 9493 for (unsigned i = 0, e = Group.size(); i != e; ++i) { 9494 if (VarDecl *D = dyn_cast<VarDecl>(Group[i])) { 9495 AutoType *AT = D->getType()->getContainedAutoType(); 9496 // Don't reissue diagnostics when instantiating a template. 9497 if (AT && D->isInvalidDecl()) 9498 break; 9499 QualType U = AT ? AT->getDeducedType() : QualType(); 9500 if (!U.isNull()) { 9501 CanQualType UCanon = Context.getCanonicalType(U); 9502 if (Deduced.isNull()) { 9503 Deduced = U; 9504 DeducedCanon = UCanon; 9505 DeducedDecl = D; 9506 } else if (DeducedCanon != UCanon) { 9507 Diag(D->getTypeSourceInfo()->getTypeLoc().getBeginLoc(), 9508 diag::err_auto_different_deductions) 9509 << (AT->isDecltypeAuto() ? 1 : 0) 9510 << Deduced << DeducedDecl->getDeclName() 9511 << U << D->getDeclName() 9512 << DeducedDecl->getInit()->getSourceRange() 9513 << D->getInit()->getSourceRange(); 9514 D->setInvalidDecl(); 9515 break; 9516 } 9517 } 9518 } 9519 } 9520 } 9521 9522 ActOnDocumentableDecls(Group); 9523 9524 return DeclGroupPtrTy::make( 9525 DeclGroupRef::Create(Context, Group.data(), Group.size())); 9526 } 9527 9528 void Sema::ActOnDocumentableDecl(Decl *D) { 9529 ActOnDocumentableDecls(D); 9530 } 9531 9532 void Sema::ActOnDocumentableDecls(ArrayRef<Decl *> Group) { 9533 // Don't parse the comment if Doxygen diagnostics are ignored. 9534 if (Group.empty() || !Group[0]) 9535 return; 9536 9537 if (Diags.isIgnored(diag::warn_doc_param_not_found, Group[0]->getLocation())) 9538 return; 9539 9540 if (Group.size() >= 2) { 9541 // This is a decl group. Normally it will contain only declarations 9542 // produced from declarator list. But in case we have any definitions or 9543 // additional declaration references: 9544 // 'typedef struct S {} S;' 9545 // 'typedef struct S *S;' 9546 // 'struct S *pS;' 9547 // FinalizeDeclaratorGroup adds these as separate declarations. 9548 Decl *MaybeTagDecl = Group[0]; 9549 if (MaybeTagDecl && isa<TagDecl>(MaybeTagDecl)) { 9550 Group = Group.slice(1); 9551 } 9552 } 9553 9554 // See if there are any new comments that are not attached to a decl. 9555 ArrayRef<RawComment *> Comments = Context.getRawCommentList().getComments(); 9556 if (!Comments.empty() && 9557 !Comments.back()->isAttached()) { 9558 // There is at least one comment that not attached to a decl. 9559 // Maybe it should be attached to one of these decls? 9560 // 9561 // Note that this way we pick up not only comments that precede the 9562 // declaration, but also comments that *follow* the declaration -- thanks to 9563 // the lookahead in the lexer: we've consumed the semicolon and looked 9564 // ahead through comments. 9565 for (unsigned i = 0, e = Group.size(); i != e; ++i) 9566 Context.getCommentForDecl(Group[i], &PP); 9567 } 9568 } 9569 9570 /// ActOnParamDeclarator - Called from Parser::ParseFunctionDeclarator() 9571 /// to introduce parameters into function prototype scope. 9572 Decl *Sema::ActOnParamDeclarator(Scope *S, Declarator &D) { 9573 const DeclSpec &DS = D.getDeclSpec(); 9574 9575 // Verify C99 6.7.5.3p2: The only SCS allowed is 'register'. 9576 9577 // C++03 [dcl.stc]p2 also permits 'auto'. 9578 VarDecl::StorageClass StorageClass = SC_None; 9579 if (DS.getStorageClassSpec() == DeclSpec::SCS_register) { 9580 StorageClass = SC_Register; 9581 } else if (getLangOpts().CPlusPlus && 9582 DS.getStorageClassSpec() == DeclSpec::SCS_auto) { 9583 StorageClass = SC_Auto; 9584 } else if (DS.getStorageClassSpec() != DeclSpec::SCS_unspecified) { 9585 Diag(DS.getStorageClassSpecLoc(), 9586 diag::err_invalid_storage_class_in_func_decl); 9587 D.getMutableDeclSpec().ClearStorageClassSpecs(); 9588 } 9589 9590 if (DeclSpec::TSCS TSCS = DS.getThreadStorageClassSpec()) 9591 Diag(DS.getThreadStorageClassSpecLoc(), diag::err_invalid_thread) 9592 << DeclSpec::getSpecifierName(TSCS); 9593 if (DS.isConstexprSpecified()) 9594 Diag(DS.getConstexprSpecLoc(), diag::err_invalid_constexpr) 9595 << 0; 9596 9597 DiagnoseFunctionSpecifiers(DS); 9598 9599 TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S); 9600 QualType parmDeclType = TInfo->getType(); 9601 9602 if (getLangOpts().CPlusPlus) { 9603 // Check that there are no default arguments inside the type of this 9604 // parameter. 9605 CheckExtraCXXDefaultArguments(D); 9606 9607 // Parameter declarators cannot be qualified (C++ [dcl.meaning]p1). 9608 if (D.getCXXScopeSpec().isSet()) { 9609 Diag(D.getIdentifierLoc(), diag::err_qualified_param_declarator) 9610 << D.getCXXScopeSpec().getRange(); 9611 D.getCXXScopeSpec().clear(); 9612 } 9613 } 9614 9615 // Ensure we have a valid name 9616 IdentifierInfo *II = nullptr; 9617 if (D.hasName()) { 9618 II = D.getIdentifier(); 9619 if (!II) { 9620 Diag(D.getIdentifierLoc(), diag::err_bad_parameter_name) 9621 << GetNameForDeclarator(D).getName(); 9622 D.setInvalidType(true); 9623 } 9624 } 9625 9626 // Check for redeclaration of parameters, e.g. int foo(int x, int x); 9627 if (II) { 9628 LookupResult R(*this, II, D.getIdentifierLoc(), LookupOrdinaryName, 9629 ForRedeclaration); 9630 LookupName(R, S); 9631 if (R.isSingleResult()) { 9632 NamedDecl *PrevDecl = R.getFoundDecl(); 9633 if (PrevDecl->isTemplateParameter()) { 9634 // Maybe we will complain about the shadowed template parameter. 9635 DiagnoseTemplateParameterShadow(D.getIdentifierLoc(), PrevDecl); 9636 // Just pretend that we didn't see the previous declaration. 9637 PrevDecl = nullptr; 9638 } else if (S->isDeclScope(PrevDecl)) { 9639 Diag(D.getIdentifierLoc(), diag::err_param_redefinition) << II; 9640 Diag(PrevDecl->getLocation(), diag::note_previous_declaration); 9641 9642 // Recover by removing the name 9643 II = nullptr; 9644 D.SetIdentifier(nullptr, D.getIdentifierLoc()); 9645 D.setInvalidType(true); 9646 } 9647 } 9648 } 9649 9650 // Temporarily put parameter variables in the translation unit, not 9651 // the enclosing context. This prevents them from accidentally 9652 // looking like class members in C++. 9653 ParmVarDecl *New = CheckParameter(Context.getTranslationUnitDecl(), 9654 D.getLocStart(), 9655 D.getIdentifierLoc(), II, 9656 parmDeclType, TInfo, 9657 StorageClass); 9658 9659 if (D.isInvalidType()) 9660 New->setInvalidDecl(); 9661 9662 assert(S->isFunctionPrototypeScope()); 9663 assert(S->getFunctionPrototypeDepth() >= 1); 9664 New->setScopeInfo(S->getFunctionPrototypeDepth() - 1, 9665 S->getNextFunctionPrototypeIndex()); 9666 9667 // Add the parameter declaration into this scope. 9668 S->AddDecl(New); 9669 if (II) 9670 IdResolver.AddDecl(New); 9671 9672 ProcessDeclAttributes(S, New, D); 9673 9674 if (D.getDeclSpec().isModulePrivateSpecified()) 9675 Diag(New->getLocation(), diag::err_module_private_local) 9676 << 1 << New->getDeclName() 9677 << SourceRange(D.getDeclSpec().getModulePrivateSpecLoc()) 9678 << FixItHint::CreateRemoval(D.getDeclSpec().getModulePrivateSpecLoc()); 9679 9680 if (New->hasAttr<BlocksAttr>()) { 9681 Diag(New->getLocation(), diag::err_block_on_nonlocal); 9682 } 9683 return New; 9684 } 9685 9686 /// \brief Synthesizes a variable for a parameter arising from a 9687 /// typedef. 9688 ParmVarDecl *Sema::BuildParmVarDeclForTypedef(DeclContext *DC, 9689 SourceLocation Loc, 9690 QualType T) { 9691 /* FIXME: setting StartLoc == Loc. 9692 Would it be worth to modify callers so as to provide proper source 9693 location for the unnamed parameters, embedding the parameter's type? */ 9694 ParmVarDecl *Param = ParmVarDecl::Create(Context, DC, Loc, Loc, nullptr, 9695 T, Context.getTrivialTypeSourceInfo(T, Loc), 9696 SC_None, nullptr); 9697 Param->setImplicit(); 9698 return Param; 9699 } 9700 9701 void Sema::DiagnoseUnusedParameters(ParmVarDecl * const *Param, 9702 ParmVarDecl * const *ParamEnd) { 9703 // Don't diagnose unused-parameter errors in template instantiations; we 9704 // will already have done so in the template itself. 9705 if (!ActiveTemplateInstantiations.empty()) 9706 return; 9707 9708 for (; Param != ParamEnd; ++Param) { 9709 if (!(*Param)->isReferenced() && (*Param)->getDeclName() && 9710 !(*Param)->hasAttr<UnusedAttr>()) { 9711 Diag((*Param)->getLocation(), diag::warn_unused_parameter) 9712 << (*Param)->getDeclName(); 9713 } 9714 } 9715 } 9716 9717 void Sema::DiagnoseSizeOfParametersAndReturnValue(ParmVarDecl * const *Param, 9718 ParmVarDecl * const *ParamEnd, 9719 QualType ReturnTy, 9720 NamedDecl *D) { 9721 if (LangOpts.NumLargeByValueCopy == 0) // No check. 9722 return; 9723 9724 // Warn if the return value is pass-by-value and larger than the specified 9725 // threshold. 9726 if (!ReturnTy->isDependentType() && ReturnTy.isPODType(Context)) { 9727 unsigned Size = Context.getTypeSizeInChars(ReturnTy).getQuantity(); 9728 if (Size > LangOpts.NumLargeByValueCopy) 9729 Diag(D->getLocation(), diag::warn_return_value_size) 9730 << D->getDeclName() << Size; 9731 } 9732 9733 // Warn if any parameter is pass-by-value and larger than the specified 9734 // threshold. 9735 for (; Param != ParamEnd; ++Param) { 9736 QualType T = (*Param)->getType(); 9737 if (T->isDependentType() || !T.isPODType(Context)) 9738 continue; 9739 unsigned Size = Context.getTypeSizeInChars(T).getQuantity(); 9740 if (Size > LangOpts.NumLargeByValueCopy) 9741 Diag((*Param)->getLocation(), diag::warn_parameter_size) 9742 << (*Param)->getDeclName() << Size; 9743 } 9744 } 9745 9746 ParmVarDecl *Sema::CheckParameter(DeclContext *DC, SourceLocation StartLoc, 9747 SourceLocation NameLoc, IdentifierInfo *Name, 9748 QualType T, TypeSourceInfo *TSInfo, 9749 VarDecl::StorageClass StorageClass) { 9750 // In ARC, infer a lifetime qualifier for appropriate parameter types. 9751 if (getLangOpts().ObjCAutoRefCount && 9752 T.getObjCLifetime() == Qualifiers::OCL_None && 9753 T->isObjCLifetimeType()) { 9754 9755 Qualifiers::ObjCLifetime lifetime; 9756 9757 // Special cases for arrays: 9758 // - if it's const, use __unsafe_unretained 9759 // - otherwise, it's an error 9760 if (T->isArrayType()) { 9761 if (!T.isConstQualified()) { 9762 DelayedDiagnostics.add( 9763 sema::DelayedDiagnostic::makeForbiddenType( 9764 NameLoc, diag::err_arc_array_param_no_ownership, T, false)); 9765 } 9766 lifetime = Qualifiers::OCL_ExplicitNone; 9767 } else { 9768 lifetime = T->getObjCARCImplicitLifetime(); 9769 } 9770 T = Context.getLifetimeQualifiedType(T, lifetime); 9771 } 9772 9773 ParmVarDecl *New = ParmVarDecl::Create(Context, DC, StartLoc, NameLoc, Name, 9774 Context.getAdjustedParameterType(T), 9775 TSInfo, 9776 StorageClass, nullptr); 9777 9778 // Parameters can not be abstract class types. 9779 // For record types, this is done by the AbstractClassUsageDiagnoser once 9780 // the class has been completely parsed. 9781 if (!CurContext->isRecord() && 9782 RequireNonAbstractType(NameLoc, T, diag::err_abstract_type_in_decl, 9783 AbstractParamType)) 9784 New->setInvalidDecl(); 9785 9786 // Parameter declarators cannot be interface types. All ObjC objects are 9787 // passed by reference. 9788 if (T->isObjCObjectType()) { 9789 SourceLocation TypeEndLoc = TSInfo->getTypeLoc().getLocEnd(); 9790 Diag(NameLoc, 9791 diag::err_object_cannot_be_passed_returned_by_value) << 1 << T 9792 << FixItHint::CreateInsertion(TypeEndLoc, "*"); 9793 T = Context.getObjCObjectPointerType(T); 9794 New->setType(T); 9795 } 9796 9797 // ISO/IEC TR 18037 S6.7.3: "The type of an object with automatic storage 9798 // duration shall not be qualified by an address-space qualifier." 9799 // Since all parameters have automatic store duration, they can not have 9800 // an address space. 9801 if (T.getAddressSpace() != 0) { 9802 // OpenCL allows function arguments declared to be an array of a type 9803 // to be qualified with an address space. 9804 if (!(getLangOpts().OpenCL && T->isArrayType())) { 9805 Diag(NameLoc, diag::err_arg_with_address_space); 9806 New->setInvalidDecl(); 9807 } 9808 } 9809 9810 return New; 9811 } 9812 9813 void Sema::ActOnFinishKNRParamDeclarations(Scope *S, Declarator &D, 9814 SourceLocation LocAfterDecls) { 9815 DeclaratorChunk::FunctionTypeInfo &FTI = D.getFunctionTypeInfo(); 9816 9817 // Verify 6.9.1p6: 'every identifier in the identifier list shall be declared' 9818 // for a K&R function. 9819 if (!FTI.hasPrototype) { 9820 for (int i = FTI.NumParams; i != 0; /* decrement in loop */) { 9821 --i; 9822 if (FTI.Params[i].Param == nullptr) { 9823 SmallString<256> Code; 9824 llvm::raw_svector_ostream(Code) 9825 << " int " << FTI.Params[i].Ident->getName() << ";\n"; 9826 Diag(FTI.Params[i].IdentLoc, diag::ext_param_not_declared) 9827 << FTI.Params[i].Ident 9828 << FixItHint::CreateInsertion(LocAfterDecls, Code.str()); 9829 9830 // Implicitly declare the argument as type 'int' for lack of a better 9831 // type. 9832 AttributeFactory attrs; 9833 DeclSpec DS(attrs); 9834 const char* PrevSpec; // unused 9835 unsigned DiagID; // unused 9836 DS.SetTypeSpecType(DeclSpec::TST_int, FTI.Params[i].IdentLoc, PrevSpec, 9837 DiagID, Context.getPrintingPolicy()); 9838 // Use the identifier location for the type source range. 9839 DS.SetRangeStart(FTI.Params[i].IdentLoc); 9840 DS.SetRangeEnd(FTI.Params[i].IdentLoc); 9841 Declarator ParamD(DS, Declarator::KNRTypeListContext); 9842 ParamD.SetIdentifier(FTI.Params[i].Ident, FTI.Params[i].IdentLoc); 9843 FTI.Params[i].Param = ActOnParamDeclarator(S, ParamD); 9844 } 9845 } 9846 } 9847 } 9848 9849 Decl *Sema::ActOnStartOfFunctionDef(Scope *FnBodyScope, Declarator &D) { 9850 assert(getCurFunctionDecl() == nullptr && "Function parsing confused"); 9851 assert(D.isFunctionDeclarator() && "Not a function declarator!"); 9852 Scope *ParentScope = FnBodyScope->getParent(); 9853 9854 D.setFunctionDefinitionKind(FDK_Definition); 9855 Decl *DP = HandleDeclarator(ParentScope, D, MultiTemplateParamsArg()); 9856 return ActOnStartOfFunctionDef(FnBodyScope, DP); 9857 } 9858 9859 void Sema::ActOnFinishInlineMethodDef(CXXMethodDecl *D) { 9860 Consumer.HandleInlineMethodDefinition(D); 9861 } 9862 9863 static bool ShouldWarnAboutMissingPrototype(const FunctionDecl *FD, 9864 const FunctionDecl*& PossibleZeroParamPrototype) { 9865 // Don't warn about invalid declarations. 9866 if (FD->isInvalidDecl()) 9867 return false; 9868 9869 // Or declarations that aren't global. 9870 if (!FD->isGlobal()) 9871 return false; 9872 9873 // Don't warn about C++ member functions. 9874 if (isa<CXXMethodDecl>(FD)) 9875 return false; 9876 9877 // Don't warn about 'main'. 9878 if (FD->isMain()) 9879 return false; 9880 9881 // Don't warn about inline functions. 9882 if (FD->isInlined()) 9883 return false; 9884 9885 // Don't warn about function templates. 9886 if (FD->getDescribedFunctionTemplate()) 9887 return false; 9888 9889 // Don't warn about function template specializations. 9890 if (FD->isFunctionTemplateSpecialization()) 9891 return false; 9892 9893 // Don't warn for OpenCL kernels. 9894 if (FD->hasAttr<OpenCLKernelAttr>()) 9895 return false; 9896 9897 bool MissingPrototype = true; 9898 for (const FunctionDecl *Prev = FD->getPreviousDecl(); 9899 Prev; Prev = Prev->getPreviousDecl()) { 9900 // Ignore any declarations that occur in function or method 9901 // scope, because they aren't visible from the header. 9902 if (Prev->getLexicalDeclContext()->isFunctionOrMethod()) 9903 continue; 9904 9905 MissingPrototype = !Prev->getType()->isFunctionProtoType(); 9906 if (FD->getNumParams() == 0) 9907 PossibleZeroParamPrototype = Prev; 9908 break; 9909 } 9910 9911 return MissingPrototype; 9912 } 9913 9914 void 9915 Sema::CheckForFunctionRedefinition(FunctionDecl *FD, 9916 const FunctionDecl *EffectiveDefinition) { 9917 // Don't complain if we're in GNU89 mode and the previous definition 9918 // was an extern inline function. 9919 const FunctionDecl *Definition = EffectiveDefinition; 9920 if (!Definition) 9921 if (!FD->isDefined(Definition)) 9922 return; 9923 9924 if (canRedefineFunction(Definition, getLangOpts())) 9925 return; 9926 9927 if (getLangOpts().GNUMode && Definition->isInlineSpecified() && 9928 Definition->getStorageClass() == SC_Extern) 9929 Diag(FD->getLocation(), diag::err_redefinition_extern_inline) 9930 << FD->getDeclName() << getLangOpts().CPlusPlus; 9931 else 9932 Diag(FD->getLocation(), diag::err_redefinition) << FD->getDeclName(); 9933 9934 Diag(Definition->getLocation(), diag::note_previous_definition); 9935 FD->setInvalidDecl(); 9936 } 9937 9938 9939 static void RebuildLambdaScopeInfo(CXXMethodDecl *CallOperator, 9940 Sema &S) { 9941 CXXRecordDecl *const LambdaClass = CallOperator->getParent(); 9942 9943 LambdaScopeInfo *LSI = S.PushLambdaScope(); 9944 LSI->CallOperator = CallOperator; 9945 LSI->Lambda = LambdaClass; 9946 LSI->ReturnType = CallOperator->getReturnType(); 9947 const LambdaCaptureDefault LCD = LambdaClass->getLambdaCaptureDefault(); 9948 9949 if (LCD == LCD_None) 9950 LSI->ImpCaptureStyle = CapturingScopeInfo::ImpCap_None; 9951 else if (LCD == LCD_ByCopy) 9952 LSI->ImpCaptureStyle = CapturingScopeInfo::ImpCap_LambdaByval; 9953 else if (LCD == LCD_ByRef) 9954 LSI->ImpCaptureStyle = CapturingScopeInfo::ImpCap_LambdaByref; 9955 DeclarationNameInfo DNI = CallOperator->getNameInfo(); 9956 9957 LSI->IntroducerRange = DNI.getCXXOperatorNameRange(); 9958 LSI->Mutable = !CallOperator->isConst(); 9959 9960 // Add the captures to the LSI so they can be noted as already 9961 // captured within tryCaptureVar. 9962 auto I = LambdaClass->field_begin(); 9963 for (const auto &C : LambdaClass->captures()) { 9964 if (C.capturesVariable()) { 9965 VarDecl *VD = C.getCapturedVar(); 9966 if (VD->isInitCapture()) 9967 S.CurrentInstantiationScope->InstantiatedLocal(VD, VD); 9968 QualType CaptureType = VD->getType(); 9969 const bool ByRef = C.getCaptureKind() == LCK_ByRef; 9970 LSI->addCapture(VD, /*IsBlock*/false, ByRef, 9971 /*RefersToEnclosingLocal*/true, C.getLocation(), 9972 /*EllipsisLoc*/C.isPackExpansion() 9973 ? C.getEllipsisLoc() : SourceLocation(), 9974 CaptureType, /*Expr*/ nullptr); 9975 9976 } else if (C.capturesThis()) { 9977 LSI->addThisCapture(/*Nested*/ false, C.getLocation(), 9978 S.getCurrentThisType(), /*Expr*/ nullptr); 9979 } else { 9980 LSI->addVLATypeCapture(C.getLocation(), I->getType()); 9981 } 9982 ++I; 9983 } 9984 } 9985 9986 Decl *Sema::ActOnStartOfFunctionDef(Scope *FnBodyScope, Decl *D) { 9987 // Clear the last template instantiation error context. 9988 LastTemplateInstantiationErrorContext = ActiveTemplateInstantiation(); 9989 9990 if (!D) 9991 return D; 9992 FunctionDecl *FD = nullptr; 9993 9994 if (FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(D)) 9995 FD = FunTmpl->getTemplatedDecl(); 9996 else 9997 FD = cast<FunctionDecl>(D); 9998 // If we are instantiating a generic lambda call operator, push 9999 // a LambdaScopeInfo onto the function stack. But use the information 10000 // that's already been calculated (ActOnLambdaExpr) to prime the current 10001 // LambdaScopeInfo. 10002 // When the template operator is being specialized, the LambdaScopeInfo, 10003 // has to be properly restored so that tryCaptureVariable doesn't try 10004 // and capture any new variables. In addition when calculating potential 10005 // captures during transformation of nested lambdas, it is necessary to 10006 // have the LSI properly restored. 10007 if (isGenericLambdaCallOperatorSpecialization(FD)) { 10008 assert(ActiveTemplateInstantiations.size() && 10009 "There should be an active template instantiation on the stack " 10010 "when instantiating a generic lambda!"); 10011 RebuildLambdaScopeInfo(cast<CXXMethodDecl>(D), *this); 10012 } 10013 else 10014 // Enter a new function scope 10015 PushFunctionScope(); 10016 10017 // See if this is a redefinition. 10018 if (!FD->isLateTemplateParsed()) 10019 CheckForFunctionRedefinition(FD); 10020 10021 // Builtin functions cannot be defined. 10022 if (unsigned BuiltinID = FD->getBuiltinID()) { 10023 if (!Context.BuiltinInfo.isPredefinedLibFunction(BuiltinID) && 10024 !Context.BuiltinInfo.isPredefinedRuntimeFunction(BuiltinID)) { 10025 Diag(FD->getLocation(), diag::err_builtin_definition) << FD; 10026 FD->setInvalidDecl(); 10027 } 10028 } 10029 10030 // The return type of a function definition must be complete 10031 // (C99 6.9.1p3, C++ [dcl.fct]p6). 10032 QualType ResultType = FD->getReturnType(); 10033 if (!ResultType->isDependentType() && !ResultType->isVoidType() && 10034 !FD->isInvalidDecl() && 10035 RequireCompleteType(FD->getLocation(), ResultType, 10036 diag::err_func_def_incomplete_result)) 10037 FD->setInvalidDecl(); 10038 10039 // GNU warning -Wmissing-prototypes: 10040 // Warn if a global function is defined without a previous 10041 // prototype declaration. This warning is issued even if the 10042 // definition itself provides a prototype. The aim is to detect 10043 // global functions that fail to be declared in header files. 10044 const FunctionDecl *PossibleZeroParamPrototype = nullptr; 10045 if (ShouldWarnAboutMissingPrototype(FD, PossibleZeroParamPrototype)) { 10046 Diag(FD->getLocation(), diag::warn_missing_prototype) << FD; 10047 10048 if (PossibleZeroParamPrototype) { 10049 // We found a declaration that is not a prototype, 10050 // but that could be a zero-parameter prototype 10051 if (TypeSourceInfo *TI = 10052 PossibleZeroParamPrototype->getTypeSourceInfo()) { 10053 TypeLoc TL = TI->getTypeLoc(); 10054 if (FunctionNoProtoTypeLoc FTL = TL.getAs<FunctionNoProtoTypeLoc>()) 10055 Diag(PossibleZeroParamPrototype->getLocation(), 10056 diag::note_declaration_not_a_prototype) 10057 << PossibleZeroParamPrototype 10058 << FixItHint::CreateInsertion(FTL.getRParenLoc(), "void"); 10059 } 10060 } 10061 } 10062 10063 if (FnBodyScope) 10064 PushDeclContext(FnBodyScope, FD); 10065 10066 // Check the validity of our function parameters 10067 CheckParmsForFunctionDef(FD->param_begin(), FD->param_end(), 10068 /*CheckParameterNames=*/true); 10069 10070 // Introduce our parameters into the function scope 10071 for (auto Param : FD->params()) { 10072 Param->setOwningFunction(FD); 10073 10074 // If this has an identifier, add it to the scope stack. 10075 if (Param->getIdentifier() && FnBodyScope) { 10076 CheckShadow(FnBodyScope, Param); 10077 10078 PushOnScopeChains(Param, FnBodyScope); 10079 } 10080 } 10081 10082 // If we had any tags defined in the function prototype, 10083 // introduce them into the function scope. 10084 if (FnBodyScope) { 10085 for (ArrayRef<NamedDecl *>::iterator 10086 I = FD->getDeclsInPrototypeScope().begin(), 10087 E = FD->getDeclsInPrototypeScope().end(); 10088 I != E; ++I) { 10089 NamedDecl *D = *I; 10090 10091 // Some of these decls (like enums) may have been pinned to the translation unit 10092 // for lack of a real context earlier. If so, remove from the translation unit 10093 // and reattach to the current context. 10094 if (D->getLexicalDeclContext() == Context.getTranslationUnitDecl()) { 10095 // Is the decl actually in the context? 10096 for (const auto *DI : Context.getTranslationUnitDecl()->decls()) { 10097 if (DI == D) { 10098 Context.getTranslationUnitDecl()->removeDecl(D); 10099 break; 10100 } 10101 } 10102 // Either way, reassign the lexical decl context to our FunctionDecl. 10103 D->setLexicalDeclContext(CurContext); 10104 } 10105 10106 // If the decl has a non-null name, make accessible in the current scope. 10107 if (!D->getName().empty()) 10108 PushOnScopeChains(D, FnBodyScope, /*AddToContext=*/false); 10109 10110 // Similarly, dive into enums and fish their constants out, making them 10111 // accessible in this scope. 10112 if (auto *ED = dyn_cast<EnumDecl>(D)) { 10113 for (auto *EI : ED->enumerators()) 10114 PushOnScopeChains(EI, FnBodyScope, /*AddToContext=*/false); 10115 } 10116 } 10117 } 10118 10119 // Ensure that the function's exception specification is instantiated. 10120 if (const FunctionProtoType *FPT = FD->getType()->getAs<FunctionProtoType>()) 10121 ResolveExceptionSpec(D->getLocation(), FPT); 10122 10123 // dllimport cannot be applied to non-inline function definitions. 10124 if (FD->hasAttr<DLLImportAttr>() && !FD->isInlined() && 10125 !FD->isTemplateInstantiation()) { 10126 assert(!FD->hasAttr<DLLExportAttr>()); 10127 Diag(FD->getLocation(), diag::err_attribute_dllimport_function_definition); 10128 FD->setInvalidDecl(); 10129 return D; 10130 } 10131 // We want to attach documentation to original Decl (which might be 10132 // a function template). 10133 ActOnDocumentableDecl(D); 10134 if (getCurLexicalContext()->isObjCContainer() && 10135 getCurLexicalContext()->getDeclKind() != Decl::ObjCCategoryImpl && 10136 getCurLexicalContext()->getDeclKind() != Decl::ObjCImplementation) 10137 Diag(FD->getLocation(), diag::warn_function_def_in_objc_container); 10138 10139 return D; 10140 } 10141 10142 /// \brief Given the set of return statements within a function body, 10143 /// compute the variables that are subject to the named return value 10144 /// optimization. 10145 /// 10146 /// Each of the variables that is subject to the named return value 10147 /// optimization will be marked as NRVO variables in the AST, and any 10148 /// return statement that has a marked NRVO variable as its NRVO candidate can 10149 /// use the named return value optimization. 10150 /// 10151 /// This function applies a very simplistic algorithm for NRVO: if every return 10152 /// statement in the scope of a variable has the same NRVO candidate, that 10153 /// candidate is an NRVO variable. 10154 void Sema::computeNRVO(Stmt *Body, FunctionScopeInfo *Scope) { 10155 ReturnStmt **Returns = Scope->Returns.data(); 10156 10157 for (unsigned I = 0, E = Scope->Returns.size(); I != E; ++I) { 10158 if (const VarDecl *NRVOCandidate = Returns[I]->getNRVOCandidate()) { 10159 if (!NRVOCandidate->isNRVOVariable()) 10160 Returns[I]->setNRVOCandidate(nullptr); 10161 } 10162 } 10163 } 10164 10165 bool Sema::canDelayFunctionBody(const Declarator &D) { 10166 // We can't delay parsing the body of a constexpr function template (yet). 10167 if (D.getDeclSpec().isConstexprSpecified()) 10168 return false; 10169 10170 // We can't delay parsing the body of a function template with a deduced 10171 // return type (yet). 10172 if (D.getDeclSpec().containsPlaceholderType()) { 10173 // If the placeholder introduces a non-deduced trailing return type, 10174 // we can still delay parsing it. 10175 if (D.getNumTypeObjects()) { 10176 const auto &Outer = D.getTypeObject(D.getNumTypeObjects() - 1); 10177 if (Outer.Kind == DeclaratorChunk::Function && 10178 Outer.Fun.hasTrailingReturnType()) { 10179 QualType Ty = GetTypeFromParser(Outer.Fun.getTrailingReturnType()); 10180 return Ty.isNull() || !Ty->isUndeducedType(); 10181 } 10182 } 10183 return false; 10184 } 10185 10186 return true; 10187 } 10188 10189 bool Sema::canSkipFunctionBody(Decl *D) { 10190 // We cannot skip the body of a function (or function template) which is 10191 // constexpr, since we may need to evaluate its body in order to parse the 10192 // rest of the file. 10193 // We cannot skip the body of a function with an undeduced return type, 10194 // because any callers of that function need to know the type. 10195 if (const FunctionDecl *FD = D->getAsFunction()) 10196 if (FD->isConstexpr() || FD->getReturnType()->isUndeducedType()) 10197 return false; 10198 return Consumer.shouldSkipFunctionBody(D); 10199 } 10200 10201 Decl *Sema::ActOnSkippedFunctionBody(Decl *Decl) { 10202 if (FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(Decl)) 10203 FD->setHasSkippedBody(); 10204 else if (ObjCMethodDecl *MD = dyn_cast_or_null<ObjCMethodDecl>(Decl)) 10205 MD->setHasSkippedBody(); 10206 return ActOnFinishFunctionBody(Decl, nullptr); 10207 } 10208 10209 Decl *Sema::ActOnFinishFunctionBody(Decl *D, Stmt *BodyArg) { 10210 return ActOnFinishFunctionBody(D, BodyArg, false); 10211 } 10212 10213 Decl *Sema::ActOnFinishFunctionBody(Decl *dcl, Stmt *Body, 10214 bool IsInstantiation) { 10215 FunctionDecl *FD = dcl ? dcl->getAsFunction() : nullptr; 10216 10217 sema::AnalysisBasedWarnings::Policy WP = AnalysisWarnings.getDefaultPolicy(); 10218 sema::AnalysisBasedWarnings::Policy *ActivePolicy = nullptr; 10219 10220 if (FD) { 10221 FD->setBody(Body); 10222 10223 if (getLangOpts().CPlusPlus14 && !FD->isInvalidDecl() && Body && 10224 !FD->isDependentContext() && FD->getReturnType()->isUndeducedType()) { 10225 // If the function has a deduced result type but contains no 'return' 10226 // statements, the result type as written must be exactly 'auto', and 10227 // the deduced result type is 'void'. 10228 if (!FD->getReturnType()->getAs<AutoType>()) { 10229 Diag(dcl->getLocation(), diag::err_auto_fn_no_return_but_not_auto) 10230 << FD->getReturnType(); 10231 FD->setInvalidDecl(); 10232 } else { 10233 // Substitute 'void' for the 'auto' in the type. 10234 TypeLoc ResultType = FD->getTypeSourceInfo()->getTypeLoc(). 10235 IgnoreParens().castAs<FunctionProtoTypeLoc>().getReturnLoc(); 10236 Context.adjustDeducedFunctionResultType( 10237 FD, SubstAutoType(ResultType.getType(), Context.VoidTy)); 10238 } 10239 } 10240 10241 // The only way to be included in UndefinedButUsed is if there is an 10242 // ODR use before the definition. Avoid the expensive map lookup if this 10243 // is the first declaration. 10244 if (!FD->isFirstDecl() && FD->getPreviousDecl()->isUsed()) { 10245 if (!FD->isExternallyVisible()) 10246 UndefinedButUsed.erase(FD); 10247 else if (FD->isInlined() && 10248 (LangOpts.CPlusPlus || !LangOpts.GNUInline) && 10249 (!FD->getPreviousDecl()->hasAttr<GNUInlineAttr>())) 10250 UndefinedButUsed.erase(FD); 10251 } 10252 10253 // If the function implicitly returns zero (like 'main') or is naked, 10254 // don't complain about missing return statements. 10255 if (FD->hasImplicitReturnZero() || FD->hasAttr<NakedAttr>()) 10256 WP.disableCheckFallThrough(); 10257 10258 // MSVC permits the use of pure specifier (=0) on function definition, 10259 // defined at class scope, warn about this non-standard construct. 10260 if (getLangOpts().MicrosoftExt && FD->isPure() && FD->isCanonicalDecl()) 10261 Diag(FD->getLocation(), diag::ext_pure_function_definition); 10262 10263 if (!FD->isInvalidDecl()) { 10264 // Don't diagnose unused parameters of defaulted or deleted functions. 10265 if (Body) 10266 DiagnoseUnusedParameters(FD->param_begin(), FD->param_end()); 10267 DiagnoseSizeOfParametersAndReturnValue(FD->param_begin(), FD->param_end(), 10268 FD->getReturnType(), FD); 10269 10270 // If this is a constructor, we need a vtable. 10271 if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(FD)) 10272 MarkVTableUsed(FD->getLocation(), Constructor->getParent()); 10273 10274 // Try to apply the named return value optimization. We have to check 10275 // if we can do this here because lambdas keep return statements around 10276 // to deduce an implicit return type. 10277 if (getLangOpts().CPlusPlus && FD->getReturnType()->isRecordType() && 10278 !FD->isDependentContext()) 10279 computeNRVO(Body, getCurFunction()); 10280 } 10281 10282 assert((FD == getCurFunctionDecl() || getCurLambda()->CallOperator == FD) && 10283 "Function parsing confused"); 10284 } else if (ObjCMethodDecl *MD = dyn_cast_or_null<ObjCMethodDecl>(dcl)) { 10285 assert(MD == getCurMethodDecl() && "Method parsing confused"); 10286 MD->setBody(Body); 10287 if (!MD->isInvalidDecl()) { 10288 DiagnoseUnusedParameters(MD->param_begin(), MD->param_end()); 10289 DiagnoseSizeOfParametersAndReturnValue(MD->param_begin(), MD->param_end(), 10290 MD->getReturnType(), MD); 10291 10292 if (Body) 10293 computeNRVO(Body, getCurFunction()); 10294 } 10295 if (getCurFunction()->ObjCShouldCallSuper) { 10296 Diag(MD->getLocEnd(), diag::warn_objc_missing_super_call) 10297 << MD->getSelector().getAsString(); 10298 getCurFunction()->ObjCShouldCallSuper = false; 10299 } 10300 if (getCurFunction()->ObjCWarnForNoDesignatedInitChain) { 10301 const ObjCMethodDecl *InitMethod = nullptr; 10302 bool isDesignated = 10303 MD->isDesignatedInitializerForTheInterface(&InitMethod); 10304 assert(isDesignated && InitMethod); 10305 (void)isDesignated; 10306 10307 auto superIsNSObject = [&](const ObjCMethodDecl *MD) { 10308 auto IFace = MD->getClassInterface(); 10309 if (!IFace) 10310 return false; 10311 auto SuperD = IFace->getSuperClass(); 10312 if (!SuperD) 10313 return false; 10314 return SuperD->getIdentifier() == 10315 NSAPIObj->getNSClassId(NSAPI::ClassId_NSObject); 10316 }; 10317 // Don't issue this warning for unavailable inits or direct subclasses 10318 // of NSObject. 10319 if (!MD->isUnavailable() && !superIsNSObject(MD)) { 10320 Diag(MD->getLocation(), 10321 diag::warn_objc_designated_init_missing_super_call); 10322 Diag(InitMethod->getLocation(), 10323 diag::note_objc_designated_init_marked_here); 10324 } 10325 getCurFunction()->ObjCWarnForNoDesignatedInitChain = false; 10326 } 10327 if (getCurFunction()->ObjCWarnForNoInitDelegation) { 10328 // Don't issue this warning for unavaialable inits. 10329 if (!MD->isUnavailable()) 10330 Diag(MD->getLocation(), diag::warn_objc_secondary_init_missing_init_call); 10331 getCurFunction()->ObjCWarnForNoInitDelegation = false; 10332 } 10333 } else { 10334 return nullptr; 10335 } 10336 10337 assert(!getCurFunction()->ObjCShouldCallSuper && 10338 "This should only be set for ObjC methods, which should have been " 10339 "handled in the block above."); 10340 10341 // Verify and clean out per-function state. 10342 if (Body) { 10343 // C++ constructors that have function-try-blocks can't have return 10344 // statements in the handlers of that block. (C++ [except.handle]p14) 10345 // Verify this. 10346 if (FD && isa<CXXConstructorDecl>(FD) && isa<CXXTryStmt>(Body)) 10347 DiagnoseReturnInConstructorExceptionHandler(cast<CXXTryStmt>(Body)); 10348 10349 // Verify that gotos and switch cases don't jump into scopes illegally. 10350 if (getCurFunction()->NeedsScopeChecking() && 10351 !PP.isCodeCompletionEnabled()) 10352 DiagnoseInvalidJumps(Body); 10353 10354 if (CXXDestructorDecl *Destructor = dyn_cast<CXXDestructorDecl>(dcl)) { 10355 if (!Destructor->getParent()->isDependentType()) 10356 CheckDestructor(Destructor); 10357 10358 MarkBaseAndMemberDestructorsReferenced(Destructor->getLocation(), 10359 Destructor->getParent()); 10360 } 10361 10362 // If any errors have occurred, clear out any temporaries that may have 10363 // been leftover. This ensures that these temporaries won't be picked up for 10364 // deletion in some later function. 10365 if (getDiagnostics().hasErrorOccurred() || 10366 getDiagnostics().getSuppressAllDiagnostics()) { 10367 DiscardCleanupsInEvaluationContext(); 10368 } 10369 if (!getDiagnostics().hasUncompilableErrorOccurred() && 10370 !isa<FunctionTemplateDecl>(dcl)) { 10371 // Since the body is valid, issue any analysis-based warnings that are 10372 // enabled. 10373 ActivePolicy = &WP; 10374 } 10375 10376 if (!IsInstantiation && FD && FD->isConstexpr() && !FD->isInvalidDecl() && 10377 (!CheckConstexprFunctionDecl(FD) || 10378 !CheckConstexprFunctionBody(FD, Body))) 10379 FD->setInvalidDecl(); 10380 10381 assert(ExprCleanupObjects.empty() && "Leftover temporaries in function"); 10382 assert(!ExprNeedsCleanups && "Unaccounted cleanups in function"); 10383 assert(MaybeODRUseExprs.empty() && 10384 "Leftover expressions for odr-use checking"); 10385 } 10386 10387 if (!IsInstantiation) 10388 PopDeclContext(); 10389 10390 PopFunctionScopeInfo(ActivePolicy, dcl); 10391 // If any errors have occurred, clear out any temporaries that may have 10392 // been leftover. This ensures that these temporaries won't be picked up for 10393 // deletion in some later function. 10394 if (getDiagnostics().hasErrorOccurred()) { 10395 DiscardCleanupsInEvaluationContext(); 10396 } 10397 10398 return dcl; 10399 } 10400 10401 10402 /// When we finish delayed parsing of an attribute, we must attach it to the 10403 /// relevant Decl. 10404 void Sema::ActOnFinishDelayedAttribute(Scope *S, Decl *D, 10405 ParsedAttributes &Attrs) { 10406 // Always attach attributes to the underlying decl. 10407 if (TemplateDecl *TD = dyn_cast<TemplateDecl>(D)) 10408 D = TD->getTemplatedDecl(); 10409 ProcessDeclAttributeList(S, D, Attrs.getList()); 10410 10411 if (CXXMethodDecl *Method = dyn_cast_or_null<CXXMethodDecl>(D)) 10412 if (Method->isStatic()) 10413 checkThisInStaticMemberFunctionAttributes(Method); 10414 } 10415 10416 10417 /// ImplicitlyDefineFunction - An undeclared identifier was used in a function 10418 /// call, forming a call to an implicitly defined function (per C99 6.5.1p2). 10419 NamedDecl *Sema::ImplicitlyDefineFunction(SourceLocation Loc, 10420 IdentifierInfo &II, Scope *S) { 10421 // Before we produce a declaration for an implicitly defined 10422 // function, see whether there was a locally-scoped declaration of 10423 // this name as a function or variable. If so, use that 10424 // (non-visible) declaration, and complain about it. 10425 if (NamedDecl *ExternCPrev = findLocallyScopedExternCDecl(&II)) { 10426 Diag(Loc, diag::warn_use_out_of_scope_declaration) << ExternCPrev; 10427 Diag(ExternCPrev->getLocation(), diag::note_previous_declaration); 10428 return ExternCPrev; 10429 } 10430 10431 // Extension in C99. Legal in C90, but warn about it. 10432 unsigned diag_id; 10433 if (II.getName().startswith("__builtin_")) 10434 diag_id = diag::warn_builtin_unknown; 10435 else if (getLangOpts().C99) 10436 diag_id = diag::ext_implicit_function_decl; 10437 else 10438 diag_id = diag::warn_implicit_function_decl; 10439 Diag(Loc, diag_id) << &II; 10440 10441 // Because typo correction is expensive, only do it if the implicit 10442 // function declaration is going to be treated as an error. 10443 if (Diags.getDiagnosticLevel(diag_id, Loc) >= DiagnosticsEngine::Error) { 10444 TypoCorrection Corrected; 10445 DeclFilterCCC<FunctionDecl> Validator; 10446 if (S && (Corrected = CorrectTypo(DeclarationNameInfo(&II, Loc), 10447 LookupOrdinaryName, S, nullptr, Validator, 10448 CTK_NonError))) 10449 diagnoseTypo(Corrected, PDiag(diag::note_function_suggestion), 10450 /*ErrorRecovery*/false); 10451 } 10452 10453 // Set a Declarator for the implicit definition: int foo(); 10454 const char *Dummy; 10455 AttributeFactory attrFactory; 10456 DeclSpec DS(attrFactory); 10457 unsigned DiagID; 10458 bool Error = DS.SetTypeSpecType(DeclSpec::TST_int, Loc, Dummy, DiagID, 10459 Context.getPrintingPolicy()); 10460 (void)Error; // Silence warning. 10461 assert(!Error && "Error setting up implicit decl!"); 10462 SourceLocation NoLoc; 10463 Declarator D(DS, Declarator::BlockContext); 10464 D.AddTypeInfo(DeclaratorChunk::getFunction(/*HasProto=*/false, 10465 /*IsAmbiguous=*/false, 10466 /*LParenLoc=*/NoLoc, 10467 /*Params=*/nullptr, 10468 /*NumParams=*/0, 10469 /*EllipsisLoc=*/NoLoc, 10470 /*RParenLoc=*/NoLoc, 10471 /*TypeQuals=*/0, 10472 /*RefQualifierIsLvalueRef=*/true, 10473 /*RefQualifierLoc=*/NoLoc, 10474 /*ConstQualifierLoc=*/NoLoc, 10475 /*VolatileQualifierLoc=*/NoLoc, 10476 /*MutableLoc=*/NoLoc, 10477 EST_None, 10478 /*ESpecLoc=*/NoLoc, 10479 /*Exceptions=*/nullptr, 10480 /*ExceptionRanges=*/nullptr, 10481 /*NumExceptions=*/0, 10482 /*NoexceptExpr=*/nullptr, 10483 Loc, Loc, D), 10484 DS.getAttributes(), 10485 SourceLocation()); 10486 D.SetIdentifier(&II, Loc); 10487 10488 // Insert this function into translation-unit scope. 10489 10490 DeclContext *PrevDC = CurContext; 10491 CurContext = Context.getTranslationUnitDecl(); 10492 10493 FunctionDecl *FD = cast<FunctionDecl>(ActOnDeclarator(TUScope, D)); 10494 FD->setImplicit(); 10495 10496 CurContext = PrevDC; 10497 10498 AddKnownFunctionAttributes(FD); 10499 10500 return FD; 10501 } 10502 10503 /// \brief Adds any function attributes that we know a priori based on 10504 /// the declaration of this function. 10505 /// 10506 /// These attributes can apply both to implicitly-declared builtins 10507 /// (like __builtin___printf_chk) or to library-declared functions 10508 /// like NSLog or printf. 10509 /// 10510 /// We need to check for duplicate attributes both here and where user-written 10511 /// attributes are applied to declarations. 10512 void Sema::AddKnownFunctionAttributes(FunctionDecl *FD) { 10513 if (FD->isInvalidDecl()) 10514 return; 10515 10516 // If this is a built-in function, map its builtin attributes to 10517 // actual attributes. 10518 if (unsigned BuiltinID = FD->getBuiltinID()) { 10519 // Handle printf-formatting attributes. 10520 unsigned FormatIdx; 10521 bool HasVAListArg; 10522 if (Context.BuiltinInfo.isPrintfLike(BuiltinID, FormatIdx, HasVAListArg)) { 10523 if (!FD->hasAttr<FormatAttr>()) { 10524 const char *fmt = "printf"; 10525 unsigned int NumParams = FD->getNumParams(); 10526 if (FormatIdx < NumParams && // NumParams may be 0 (e.g. vfprintf) 10527 FD->getParamDecl(FormatIdx)->getType()->isObjCObjectPointerType()) 10528 fmt = "NSString"; 10529 FD->addAttr(FormatAttr::CreateImplicit(Context, 10530 &Context.Idents.get(fmt), 10531 FormatIdx+1, 10532 HasVAListArg ? 0 : FormatIdx+2, 10533 FD->getLocation())); 10534 } 10535 } 10536 if (Context.BuiltinInfo.isScanfLike(BuiltinID, FormatIdx, 10537 HasVAListArg)) { 10538 if (!FD->hasAttr<FormatAttr>()) 10539 FD->addAttr(FormatAttr::CreateImplicit(Context, 10540 &Context.Idents.get("scanf"), 10541 FormatIdx+1, 10542 HasVAListArg ? 0 : FormatIdx+2, 10543 FD->getLocation())); 10544 } 10545 10546 // Mark const if we don't care about errno and that is the only 10547 // thing preventing the function from being const. This allows 10548 // IRgen to use LLVM intrinsics for such functions. 10549 if (!getLangOpts().MathErrno && 10550 Context.BuiltinInfo.isConstWithoutErrno(BuiltinID)) { 10551 if (!FD->hasAttr<ConstAttr>()) 10552 FD->addAttr(ConstAttr::CreateImplicit(Context, FD->getLocation())); 10553 } 10554 10555 if (Context.BuiltinInfo.isReturnsTwice(BuiltinID) && 10556 !FD->hasAttr<ReturnsTwiceAttr>()) 10557 FD->addAttr(ReturnsTwiceAttr::CreateImplicit(Context, 10558 FD->getLocation())); 10559 if (Context.BuiltinInfo.isNoThrow(BuiltinID) && !FD->hasAttr<NoThrowAttr>()) 10560 FD->addAttr(NoThrowAttr::CreateImplicit(Context, FD->getLocation())); 10561 if (Context.BuiltinInfo.isConst(BuiltinID) && !FD->hasAttr<ConstAttr>()) 10562 FD->addAttr(ConstAttr::CreateImplicit(Context, FD->getLocation())); 10563 } 10564 10565 IdentifierInfo *Name = FD->getIdentifier(); 10566 if (!Name) 10567 return; 10568 if ((!getLangOpts().CPlusPlus && 10569 FD->getDeclContext()->isTranslationUnit()) || 10570 (isa<LinkageSpecDecl>(FD->getDeclContext()) && 10571 cast<LinkageSpecDecl>(FD->getDeclContext())->getLanguage() == 10572 LinkageSpecDecl::lang_c)) { 10573 // Okay: this could be a libc/libm/Objective-C function we know 10574 // about. 10575 } else 10576 return; 10577 10578 if (Name->isStr("asprintf") || Name->isStr("vasprintf")) { 10579 // FIXME: asprintf and vasprintf aren't C99 functions. Should they be 10580 // target-specific builtins, perhaps? 10581 if (!FD->hasAttr<FormatAttr>()) 10582 FD->addAttr(FormatAttr::CreateImplicit(Context, 10583 &Context.Idents.get("printf"), 2, 10584 Name->isStr("vasprintf") ? 0 : 3, 10585 FD->getLocation())); 10586 } 10587 10588 if (Name->isStr("__CFStringMakeConstantString")) { 10589 // We already have a __builtin___CFStringMakeConstantString, 10590 // but builds that use -fno-constant-cfstrings don't go through that. 10591 if (!FD->hasAttr<FormatArgAttr>()) 10592 FD->addAttr(FormatArgAttr::CreateImplicit(Context, 1, 10593 FD->getLocation())); 10594 } 10595 } 10596 10597 TypedefDecl *Sema::ParseTypedefDecl(Scope *S, Declarator &D, QualType T, 10598 TypeSourceInfo *TInfo) { 10599 assert(D.getIdentifier() && "Wrong callback for declspec without declarator"); 10600 assert(!T.isNull() && "GetTypeForDeclarator() returned null type"); 10601 10602 if (!TInfo) { 10603 assert(D.isInvalidType() && "no declarator info for valid type"); 10604 TInfo = Context.getTrivialTypeSourceInfo(T); 10605 } 10606 10607 // Scope manipulation handled by caller. 10608 TypedefDecl *NewTD = TypedefDecl::Create(Context, CurContext, 10609 D.getLocStart(), 10610 D.getIdentifierLoc(), 10611 D.getIdentifier(), 10612 TInfo); 10613 10614 // Bail out immediately if we have an invalid declaration. 10615 if (D.isInvalidType()) { 10616 NewTD->setInvalidDecl(); 10617 return NewTD; 10618 } 10619 10620 if (D.getDeclSpec().isModulePrivateSpecified()) { 10621 if (CurContext->isFunctionOrMethod()) 10622 Diag(NewTD->getLocation(), diag::err_module_private_local) 10623 << 2 << NewTD->getDeclName() 10624 << SourceRange(D.getDeclSpec().getModulePrivateSpecLoc()) 10625 << FixItHint::CreateRemoval(D.getDeclSpec().getModulePrivateSpecLoc()); 10626 else 10627 NewTD->setModulePrivate(); 10628 } 10629 10630 // C++ [dcl.typedef]p8: 10631 // If the typedef declaration defines an unnamed class (or 10632 // enum), the first typedef-name declared by the declaration 10633 // to be that class type (or enum type) is used to denote the 10634 // class type (or enum type) for linkage purposes only. 10635 // We need to check whether the type was declared in the declaration. 10636 switch (D.getDeclSpec().getTypeSpecType()) { 10637 case TST_enum: 10638 case TST_struct: 10639 case TST_interface: 10640 case TST_union: 10641 case TST_class: { 10642 TagDecl *tagFromDeclSpec = cast<TagDecl>(D.getDeclSpec().getRepAsDecl()); 10643 10644 // Do nothing if the tag is not anonymous or already has an 10645 // associated typedef (from an earlier typedef in this decl group). 10646 if (tagFromDeclSpec->getIdentifier()) break; 10647 if (tagFromDeclSpec->getTypedefNameForAnonDecl()) break; 10648 10649 // A well-formed anonymous tag must always be a TUK_Definition. 10650 assert(tagFromDeclSpec->isThisDeclarationADefinition()); 10651 10652 // The type must match the tag exactly; no qualifiers allowed. 10653 if (!Context.hasSameType(T, Context.getTagDeclType(tagFromDeclSpec))) 10654 break; 10655 10656 // If we've already computed linkage for the anonymous tag, then 10657 // adding a typedef name for the anonymous decl can change that 10658 // linkage, which might be a serious problem. Diagnose this as 10659 // unsupported and ignore the typedef name. TODO: we should 10660 // pursue this as a language defect and establish a formal rule 10661 // for how to handle it. 10662 if (tagFromDeclSpec->hasLinkageBeenComputed()) { 10663 Diag(D.getIdentifierLoc(), diag::err_typedef_changes_linkage); 10664 10665 SourceLocation tagLoc = D.getDeclSpec().getTypeSpecTypeLoc(); 10666 tagLoc = getLocForEndOfToken(tagLoc); 10667 10668 llvm::SmallString<40> textToInsert; 10669 textToInsert += ' '; 10670 textToInsert += D.getIdentifier()->getName(); 10671 Diag(tagLoc, diag::note_typedef_changes_linkage) 10672 << FixItHint::CreateInsertion(tagLoc, textToInsert); 10673 break; 10674 } 10675 10676 // Otherwise, set this is the anon-decl typedef for the tag. 10677 tagFromDeclSpec->setTypedefNameForAnonDecl(NewTD); 10678 break; 10679 } 10680 10681 default: 10682 break; 10683 } 10684 10685 return NewTD; 10686 } 10687 10688 10689 /// \brief Check that this is a valid underlying type for an enum declaration. 10690 bool Sema::CheckEnumUnderlyingType(TypeSourceInfo *TI) { 10691 SourceLocation UnderlyingLoc = TI->getTypeLoc().getBeginLoc(); 10692 QualType T = TI->getType(); 10693 10694 if (T->isDependentType()) 10695 return false; 10696 10697 if (const BuiltinType *BT = T->getAs<BuiltinType>()) 10698 if (BT->isInteger()) 10699 return false; 10700 10701 Diag(UnderlyingLoc, diag::err_enum_invalid_underlying) << T; 10702 return true; 10703 } 10704 10705 /// Check whether this is a valid redeclaration of a previous enumeration. 10706 /// \return true if the redeclaration was invalid. 10707 bool Sema::CheckEnumRedeclaration(SourceLocation EnumLoc, bool IsScoped, 10708 QualType EnumUnderlyingTy, 10709 const EnumDecl *Prev) { 10710 bool IsFixed = !EnumUnderlyingTy.isNull(); 10711 10712 if (IsScoped != Prev->isScoped()) { 10713 Diag(EnumLoc, diag::err_enum_redeclare_scoped_mismatch) 10714 << Prev->isScoped(); 10715 Diag(Prev->getLocation(), diag::note_previous_declaration); 10716 return true; 10717 } 10718 10719 if (IsFixed && Prev->isFixed()) { 10720 if (!EnumUnderlyingTy->isDependentType() && 10721 !Prev->getIntegerType()->isDependentType() && 10722 !Context.hasSameUnqualifiedType(EnumUnderlyingTy, 10723 Prev->getIntegerType())) { 10724 // TODO: Highlight the underlying type of the redeclaration. 10725 Diag(EnumLoc, diag::err_enum_redeclare_type_mismatch) 10726 << EnumUnderlyingTy << Prev->getIntegerType(); 10727 Diag(Prev->getLocation(), diag::note_previous_declaration) 10728 << Prev->getIntegerTypeRange(); 10729 return true; 10730 } 10731 } else if (IsFixed != Prev->isFixed()) { 10732 Diag(EnumLoc, diag::err_enum_redeclare_fixed_mismatch) 10733 << Prev->isFixed(); 10734 Diag(Prev->getLocation(), diag::note_previous_declaration); 10735 return true; 10736 } 10737 10738 return false; 10739 } 10740 10741 /// \brief Get diagnostic %select index for tag kind for 10742 /// redeclaration diagnostic message. 10743 /// WARNING: Indexes apply to particular diagnostics only! 10744 /// 10745 /// \returns diagnostic %select index. 10746 static unsigned getRedeclDiagFromTagKind(TagTypeKind Tag) { 10747 switch (Tag) { 10748 case TTK_Struct: return 0; 10749 case TTK_Interface: return 1; 10750 case TTK_Class: return 2; 10751 default: llvm_unreachable("Invalid tag kind for redecl diagnostic!"); 10752 } 10753 } 10754 10755 /// \brief Determine if tag kind is a class-key compatible with 10756 /// class for redeclaration (class, struct, or __interface). 10757 /// 10758 /// \returns true iff the tag kind is compatible. 10759 static bool isClassCompatTagKind(TagTypeKind Tag) 10760 { 10761 return Tag == TTK_Struct || Tag == TTK_Class || Tag == TTK_Interface; 10762 } 10763 10764 /// \brief Determine whether a tag with a given kind is acceptable 10765 /// as a redeclaration of the given tag declaration. 10766 /// 10767 /// \returns true if the new tag kind is acceptable, false otherwise. 10768 bool Sema::isAcceptableTagRedeclaration(const TagDecl *Previous, 10769 TagTypeKind NewTag, bool isDefinition, 10770 SourceLocation NewTagLoc, 10771 const IdentifierInfo &Name) { 10772 // C++ [dcl.type.elab]p3: 10773 // The class-key or enum keyword present in the 10774 // elaborated-type-specifier shall agree in kind with the 10775 // declaration to which the name in the elaborated-type-specifier 10776 // refers. This rule also applies to the form of 10777 // elaborated-type-specifier that declares a class-name or 10778 // friend class since it can be construed as referring to the 10779 // definition of the class. Thus, in any 10780 // elaborated-type-specifier, the enum keyword shall be used to 10781 // refer to an enumeration (7.2), the union class-key shall be 10782 // used to refer to a union (clause 9), and either the class or 10783 // struct class-key shall be used to refer to a class (clause 9) 10784 // declared using the class or struct class-key. 10785 TagTypeKind OldTag = Previous->getTagKind(); 10786 if (!isDefinition || !isClassCompatTagKind(NewTag)) 10787 if (OldTag == NewTag) 10788 return true; 10789 10790 if (isClassCompatTagKind(OldTag) && isClassCompatTagKind(NewTag)) { 10791 // Warn about the struct/class tag mismatch. 10792 bool isTemplate = false; 10793 if (const CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(Previous)) 10794 isTemplate = Record->getDescribedClassTemplate(); 10795 10796 if (!ActiveTemplateInstantiations.empty()) { 10797 // In a template instantiation, do not offer fix-its for tag mismatches 10798 // since they usually mess up the template instead of fixing the problem. 10799 Diag(NewTagLoc, diag::warn_struct_class_tag_mismatch) 10800 << getRedeclDiagFromTagKind(NewTag) << isTemplate << &Name 10801 << getRedeclDiagFromTagKind(OldTag); 10802 return true; 10803 } 10804 10805 if (isDefinition) { 10806 // On definitions, check previous tags and issue a fix-it for each 10807 // one that doesn't match the current tag. 10808 if (Previous->getDefinition()) { 10809 // Don't suggest fix-its for redefinitions. 10810 return true; 10811 } 10812 10813 bool previousMismatch = false; 10814 for (auto I : Previous->redecls()) { 10815 if (I->getTagKind() != NewTag) { 10816 if (!previousMismatch) { 10817 previousMismatch = true; 10818 Diag(NewTagLoc, diag::warn_struct_class_previous_tag_mismatch) 10819 << getRedeclDiagFromTagKind(NewTag) << isTemplate << &Name 10820 << getRedeclDiagFromTagKind(I->getTagKind()); 10821 } 10822 Diag(I->getInnerLocStart(), diag::note_struct_class_suggestion) 10823 << getRedeclDiagFromTagKind(NewTag) 10824 << FixItHint::CreateReplacement(I->getInnerLocStart(), 10825 TypeWithKeyword::getTagTypeKindName(NewTag)); 10826 } 10827 } 10828 return true; 10829 } 10830 10831 // Check for a previous definition. If current tag and definition 10832 // are same type, do nothing. If no definition, but disagree with 10833 // with previous tag type, give a warning, but no fix-it. 10834 const TagDecl *Redecl = Previous->getDefinition() ? 10835 Previous->getDefinition() : Previous; 10836 if (Redecl->getTagKind() == NewTag) { 10837 return true; 10838 } 10839 10840 Diag(NewTagLoc, diag::warn_struct_class_tag_mismatch) 10841 << getRedeclDiagFromTagKind(NewTag) << isTemplate << &Name 10842 << getRedeclDiagFromTagKind(OldTag); 10843 Diag(Redecl->getLocation(), diag::note_previous_use); 10844 10845 // If there is a previous definition, suggest a fix-it. 10846 if (Previous->getDefinition()) { 10847 Diag(NewTagLoc, diag::note_struct_class_suggestion) 10848 << getRedeclDiagFromTagKind(Redecl->getTagKind()) 10849 << FixItHint::CreateReplacement(SourceRange(NewTagLoc), 10850 TypeWithKeyword::getTagTypeKindName(Redecl->getTagKind())); 10851 } 10852 10853 return true; 10854 } 10855 return false; 10856 } 10857 10858 /// Add a minimal nested name specifier fixit hint to allow lookup of a tag name 10859 /// from an outer enclosing namespace or file scope inside a friend declaration. 10860 /// This should provide the commented out code in the following snippet: 10861 /// namespace N { 10862 /// struct X; 10863 /// namespace M { 10864 /// struct Y { friend struct /*N::*/ X; }; 10865 /// } 10866 /// } 10867 static FixItHint createFriendTagNNSFixIt(Sema &SemaRef, NamedDecl *ND, Scope *S, 10868 SourceLocation NameLoc) { 10869 // While the decl is in a namespace, do repeated lookup of that name and see 10870 // if we get the same namespace back. If we do not, continue until 10871 // translation unit scope, at which point we have a fully qualified NNS. 10872 SmallVector<IdentifierInfo *, 4> Namespaces; 10873 DeclContext *DC = ND->getDeclContext()->getRedeclContext(); 10874 for (; !DC->isTranslationUnit(); DC = DC->getParent()) { 10875 // This tag should be declared in a namespace, which can only be enclosed by 10876 // other namespaces. Bail if there's an anonymous namespace in the chain. 10877 NamespaceDecl *Namespace = dyn_cast<NamespaceDecl>(DC); 10878 if (!Namespace || Namespace->isAnonymousNamespace()) 10879 return FixItHint(); 10880 IdentifierInfo *II = Namespace->getIdentifier(); 10881 Namespaces.push_back(II); 10882 NamedDecl *Lookup = SemaRef.LookupSingleName( 10883 S, II, NameLoc, Sema::LookupNestedNameSpecifierName); 10884 if (Lookup == Namespace) 10885 break; 10886 } 10887 10888 // Once we have all the namespaces, reverse them to go outermost first, and 10889 // build an NNS. 10890 SmallString<64> Insertion; 10891 llvm::raw_svector_ostream OS(Insertion); 10892 if (DC->isTranslationUnit()) 10893 OS << "::"; 10894 std::reverse(Namespaces.begin(), Namespaces.end()); 10895 for (auto *II : Namespaces) 10896 OS << II->getName() << "::"; 10897 OS.flush(); 10898 return FixItHint::CreateInsertion(NameLoc, Insertion); 10899 } 10900 10901 /// ActOnTag - This is invoked when we see 'struct foo' or 'struct {'. In the 10902 /// former case, Name will be non-null. In the later case, Name will be null. 10903 /// TagSpec indicates what kind of tag this is. TUK indicates whether this is a 10904 /// reference/declaration/definition of a tag. 10905 /// 10906 /// IsTypeSpecifier is true if this is a type-specifier (or 10907 /// trailing-type-specifier) other than one in an alias-declaration. 10908 Decl *Sema::ActOnTag(Scope *S, unsigned TagSpec, TagUseKind TUK, 10909 SourceLocation KWLoc, CXXScopeSpec &SS, 10910 IdentifierInfo *Name, SourceLocation NameLoc, 10911 AttributeList *Attr, AccessSpecifier AS, 10912 SourceLocation ModulePrivateLoc, 10913 MultiTemplateParamsArg TemplateParameterLists, 10914 bool &OwnedDecl, bool &IsDependent, 10915 SourceLocation ScopedEnumKWLoc, 10916 bool ScopedEnumUsesClassTag, 10917 TypeResult UnderlyingType, 10918 bool IsTypeSpecifier) { 10919 // If this is not a definition, it must have a name. 10920 IdentifierInfo *OrigName = Name; 10921 assert((Name != nullptr || TUK == TUK_Definition) && 10922 "Nameless record must be a definition!"); 10923 assert(TemplateParameterLists.size() == 0 || TUK != TUK_Reference); 10924 10925 OwnedDecl = false; 10926 TagTypeKind Kind = TypeWithKeyword::getTagTypeKindForTypeSpec(TagSpec); 10927 bool ScopedEnum = ScopedEnumKWLoc.isValid(); 10928 10929 // FIXME: Check explicit specializations more carefully. 10930 bool isExplicitSpecialization = false; 10931 bool Invalid = false; 10932 10933 // We only need to do this matching if we have template parameters 10934 // or a scope specifier, which also conveniently avoids this work 10935 // for non-C++ cases. 10936 if (TemplateParameterLists.size() > 0 || 10937 (SS.isNotEmpty() && TUK != TUK_Reference)) { 10938 if (TemplateParameterList *TemplateParams = 10939 MatchTemplateParametersToScopeSpecifier( 10940 KWLoc, NameLoc, SS, nullptr, TemplateParameterLists, 10941 TUK == TUK_Friend, isExplicitSpecialization, Invalid)) { 10942 if (Kind == TTK_Enum) { 10943 Diag(KWLoc, diag::err_enum_template); 10944 return nullptr; 10945 } 10946 10947 if (TemplateParams->size() > 0) { 10948 // This is a declaration or definition of a class template (which may 10949 // be a member of another template). 10950 10951 if (Invalid) 10952 return nullptr; 10953 10954 OwnedDecl = false; 10955 DeclResult Result = CheckClassTemplate(S, TagSpec, TUK, KWLoc, 10956 SS, Name, NameLoc, Attr, 10957 TemplateParams, AS, 10958 ModulePrivateLoc, 10959 /*FriendLoc*/SourceLocation(), 10960 TemplateParameterLists.size()-1, 10961 TemplateParameterLists.data()); 10962 return Result.get(); 10963 } else { 10964 // The "template<>" header is extraneous. 10965 Diag(TemplateParams->getTemplateLoc(), diag::err_template_tag_noparams) 10966 << TypeWithKeyword::getTagTypeKindName(Kind) << Name; 10967 isExplicitSpecialization = true; 10968 } 10969 } 10970 } 10971 10972 // Figure out the underlying type if this a enum declaration. We need to do 10973 // this early, because it's needed to detect if this is an incompatible 10974 // redeclaration. 10975 llvm::PointerUnion<const Type*, TypeSourceInfo*> EnumUnderlying; 10976 10977 if (Kind == TTK_Enum) { 10978 if (UnderlyingType.isInvalid() || (!UnderlyingType.get() && ScopedEnum)) 10979 // No underlying type explicitly specified, or we failed to parse the 10980 // type, default to int. 10981 EnumUnderlying = Context.IntTy.getTypePtr(); 10982 else if (UnderlyingType.get()) { 10983 // C++0x 7.2p2: The type-specifier-seq of an enum-base shall name an 10984 // integral type; any cv-qualification is ignored. 10985 TypeSourceInfo *TI = nullptr; 10986 GetTypeFromParser(UnderlyingType.get(), &TI); 10987 EnumUnderlying = TI; 10988 10989 if (CheckEnumUnderlyingType(TI)) 10990 // Recover by falling back to int. 10991 EnumUnderlying = Context.IntTy.getTypePtr(); 10992 10993 if (DiagnoseUnexpandedParameterPack(TI->getTypeLoc().getBeginLoc(), TI, 10994 UPPC_FixedUnderlyingType)) 10995 EnumUnderlying = Context.IntTy.getTypePtr(); 10996 10997 } else if (getLangOpts().MSVCCompat) 10998 // Microsoft enums are always of int type. 10999 EnumUnderlying = Context.IntTy.getTypePtr(); 11000 } 11001 11002 DeclContext *SearchDC = CurContext; 11003 DeclContext *DC = CurContext; 11004 bool isStdBadAlloc = false; 11005 11006 RedeclarationKind Redecl = ForRedeclaration; 11007 if (TUK == TUK_Friend || TUK == TUK_Reference) 11008 Redecl = NotForRedeclaration; 11009 11010 LookupResult Previous(*this, Name, NameLoc, LookupTagName, Redecl); 11011 if (Name && SS.isNotEmpty()) { 11012 // We have a nested-name tag ('struct foo::bar'). 11013 11014 // Check for invalid 'foo::'. 11015 if (SS.isInvalid()) { 11016 Name = nullptr; 11017 goto CreateNewDecl; 11018 } 11019 11020 // If this is a friend or a reference to a class in a dependent 11021 // context, don't try to make a decl for it. 11022 if (TUK == TUK_Friend || TUK == TUK_Reference) { 11023 DC = computeDeclContext(SS, false); 11024 if (!DC) { 11025 IsDependent = true; 11026 return nullptr; 11027 } 11028 } else { 11029 DC = computeDeclContext(SS, true); 11030 if (!DC) { 11031 Diag(SS.getRange().getBegin(), diag::err_dependent_nested_name_spec) 11032 << SS.getRange(); 11033 return nullptr; 11034 } 11035 } 11036 11037 if (RequireCompleteDeclContext(SS, DC)) 11038 return nullptr; 11039 11040 SearchDC = DC; 11041 // Look-up name inside 'foo::'. 11042 LookupQualifiedName(Previous, DC); 11043 11044 if (Previous.isAmbiguous()) 11045 return nullptr; 11046 11047 if (Previous.empty()) { 11048 // Name lookup did not find anything. However, if the 11049 // nested-name-specifier refers to the current instantiation, 11050 // and that current instantiation has any dependent base 11051 // classes, we might find something at instantiation time: treat 11052 // this as a dependent elaborated-type-specifier. 11053 // But this only makes any sense for reference-like lookups. 11054 if (Previous.wasNotFoundInCurrentInstantiation() && 11055 (TUK == TUK_Reference || TUK == TUK_Friend)) { 11056 IsDependent = true; 11057 return nullptr; 11058 } 11059 11060 // A tag 'foo::bar' must already exist. 11061 Diag(NameLoc, diag::err_not_tag_in_scope) 11062 << Kind << Name << DC << SS.getRange(); 11063 Name = nullptr; 11064 Invalid = true; 11065 goto CreateNewDecl; 11066 } 11067 } else if (Name) { 11068 // If this is a named struct, check to see if there was a previous forward 11069 // declaration or definition. 11070 // FIXME: We're looking into outer scopes here, even when we 11071 // shouldn't be. Doing so can result in ambiguities that we 11072 // shouldn't be diagnosing. 11073 LookupName(Previous, S); 11074 11075 // When declaring or defining a tag, ignore ambiguities introduced 11076 // by types using'ed into this scope. 11077 if (Previous.isAmbiguous() && 11078 (TUK == TUK_Definition || TUK == TUK_Declaration)) { 11079 LookupResult::Filter F = Previous.makeFilter(); 11080 while (F.hasNext()) { 11081 NamedDecl *ND = F.next(); 11082 if (ND->getDeclContext()->getRedeclContext() != SearchDC) 11083 F.erase(); 11084 } 11085 F.done(); 11086 } 11087 11088 // C++11 [namespace.memdef]p3: 11089 // If the name in a friend declaration is neither qualified nor 11090 // a template-id and the declaration is a function or an 11091 // elaborated-type-specifier, the lookup to determine whether 11092 // the entity has been previously declared shall not consider 11093 // any scopes outside the innermost enclosing namespace. 11094 // 11095 // MSVC doesn't implement the above rule for types, so a friend tag 11096 // declaration may be a redeclaration of a type declared in an enclosing 11097 // scope. They do implement this rule for friend functions. 11098 // 11099 // Does it matter that this should be by scope instead of by 11100 // semantic context? 11101 if (!Previous.empty() && TUK == TUK_Friend) { 11102 DeclContext *EnclosingNS = SearchDC->getEnclosingNamespaceContext(); 11103 LookupResult::Filter F = Previous.makeFilter(); 11104 bool FriendSawTagOutsideEnclosingNamespace = false; 11105 while (F.hasNext()) { 11106 NamedDecl *ND = F.next(); 11107 DeclContext *DC = ND->getDeclContext()->getRedeclContext(); 11108 if (DC->isFileContext() && 11109 !EnclosingNS->Encloses(ND->getDeclContext())) { 11110 if (getLangOpts().MSVCCompat) 11111 FriendSawTagOutsideEnclosingNamespace = true; 11112 else 11113 F.erase(); 11114 } 11115 } 11116 F.done(); 11117 11118 // Diagnose this MSVC extension in the easy case where lookup would have 11119 // unambiguously found something outside the enclosing namespace. 11120 if (Previous.isSingleResult() && FriendSawTagOutsideEnclosingNamespace) { 11121 NamedDecl *ND = Previous.getFoundDecl(); 11122 Diag(NameLoc, diag::ext_friend_tag_redecl_outside_namespace) 11123 << createFriendTagNNSFixIt(*this, ND, S, NameLoc); 11124 } 11125 } 11126 11127 // Note: there used to be some attempt at recovery here. 11128 if (Previous.isAmbiguous()) 11129 return nullptr; 11130 11131 if (!getLangOpts().CPlusPlus && TUK != TUK_Reference) { 11132 // FIXME: This makes sure that we ignore the contexts associated 11133 // with C structs, unions, and enums when looking for a matching 11134 // tag declaration or definition. See the similar lookup tweak 11135 // in Sema::LookupName; is there a better way to deal with this? 11136 while (isa<RecordDecl>(SearchDC) || isa<EnumDecl>(SearchDC)) 11137 SearchDC = SearchDC->getParent(); 11138 } 11139 } 11140 11141 if (Previous.isSingleResult() && 11142 Previous.getFoundDecl()->isTemplateParameter()) { 11143 // Maybe we will complain about the shadowed template parameter. 11144 DiagnoseTemplateParameterShadow(NameLoc, Previous.getFoundDecl()); 11145 // Just pretend that we didn't see the previous declaration. 11146 Previous.clear(); 11147 } 11148 11149 if (getLangOpts().CPlusPlus && Name && DC && StdNamespace && 11150 DC->Equals(getStdNamespace()) && Name->isStr("bad_alloc")) { 11151 // This is a declaration of or a reference to "std::bad_alloc". 11152 isStdBadAlloc = true; 11153 11154 if (Previous.empty() && StdBadAlloc) { 11155 // std::bad_alloc has been implicitly declared (but made invisible to 11156 // name lookup). Fill in this implicit declaration as the previous 11157 // declaration, so that the declarations get chained appropriately. 11158 Previous.addDecl(getStdBadAlloc()); 11159 } 11160 } 11161 11162 // If we didn't find a previous declaration, and this is a reference 11163 // (or friend reference), move to the correct scope. In C++, we 11164 // also need to do a redeclaration lookup there, just in case 11165 // there's a shadow friend decl. 11166 if (Name && Previous.empty() && 11167 (TUK == TUK_Reference || TUK == TUK_Friend)) { 11168 if (Invalid) goto CreateNewDecl; 11169 assert(SS.isEmpty()); 11170 11171 if (TUK == TUK_Reference) { 11172 // C++ [basic.scope.pdecl]p5: 11173 // -- for an elaborated-type-specifier of the form 11174 // 11175 // class-key identifier 11176 // 11177 // if the elaborated-type-specifier is used in the 11178 // decl-specifier-seq or parameter-declaration-clause of a 11179 // function defined in namespace scope, the identifier is 11180 // declared as a class-name in the namespace that contains 11181 // the declaration; otherwise, except as a friend 11182 // declaration, the identifier is declared in the smallest 11183 // non-class, non-function-prototype scope that contains the 11184 // declaration. 11185 // 11186 // C99 6.7.2.3p8 has a similar (but not identical!) provision for 11187 // C structs and unions. 11188 // 11189 // It is an error in C++ to declare (rather than define) an enum 11190 // type, including via an elaborated type specifier. We'll 11191 // diagnose that later; for now, declare the enum in the same 11192 // scope as we would have picked for any other tag type. 11193 // 11194 // GNU C also supports this behavior as part of its incomplete 11195 // enum types extension, while GNU C++ does not. 11196 // 11197 // Find the context where we'll be declaring the tag. 11198 // FIXME: We would like to maintain the current DeclContext as the 11199 // lexical context, 11200 while (!SearchDC->isFileContext() && !SearchDC->isFunctionOrMethod()) 11201 SearchDC = SearchDC->getParent(); 11202 11203 // Find the scope where we'll be declaring the tag. 11204 while (S->isClassScope() || 11205 (getLangOpts().CPlusPlus && 11206 S->isFunctionPrototypeScope()) || 11207 ((S->getFlags() & Scope::DeclScope) == 0) || 11208 (S->getEntity() && S->getEntity()->isTransparentContext())) 11209 S = S->getParent(); 11210 } else { 11211 assert(TUK == TUK_Friend); 11212 // C++ [namespace.memdef]p3: 11213 // If a friend declaration in a non-local class first declares a 11214 // class or function, the friend class or function is a member of 11215 // the innermost enclosing namespace. 11216 SearchDC = SearchDC->getEnclosingNamespaceContext(); 11217 } 11218 11219 // In C++, we need to do a redeclaration lookup to properly 11220 // diagnose some problems. 11221 if (getLangOpts().CPlusPlus) { 11222 Previous.setRedeclarationKind(ForRedeclaration); 11223 LookupQualifiedName(Previous, SearchDC); 11224 } 11225 } 11226 11227 if (!Previous.empty()) { 11228 NamedDecl *PrevDecl = Previous.getFoundDecl(); 11229 NamedDecl *DirectPrevDecl = 11230 getLangOpts().MSVCCompat ? *Previous.begin() : PrevDecl; 11231 11232 // It's okay to have a tag decl in the same scope as a typedef 11233 // which hides a tag decl in the same scope. Finding this 11234 // insanity with a redeclaration lookup can only actually happen 11235 // in C++. 11236 // 11237 // This is also okay for elaborated-type-specifiers, which is 11238 // technically forbidden by the current standard but which is 11239 // okay according to the likely resolution of an open issue; 11240 // see http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#407 11241 if (getLangOpts().CPlusPlus) { 11242 if (TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(PrevDecl)) { 11243 if (const TagType *TT = TD->getUnderlyingType()->getAs<TagType>()) { 11244 TagDecl *Tag = TT->getDecl(); 11245 if (Tag->getDeclName() == Name && 11246 Tag->getDeclContext()->getRedeclContext() 11247 ->Equals(TD->getDeclContext()->getRedeclContext())) { 11248 PrevDecl = Tag; 11249 Previous.clear(); 11250 Previous.addDecl(Tag); 11251 Previous.resolveKind(); 11252 } 11253 } 11254 } 11255 } 11256 11257 if (TagDecl *PrevTagDecl = dyn_cast<TagDecl>(PrevDecl)) { 11258 // If this is a use of a previous tag, or if the tag is already declared 11259 // in the same scope (so that the definition/declaration completes or 11260 // rementions the tag), reuse the decl. 11261 if (TUK == TUK_Reference || TUK == TUK_Friend || 11262 isDeclInScope(DirectPrevDecl, SearchDC, S, 11263 SS.isNotEmpty() || isExplicitSpecialization)) { 11264 // Make sure that this wasn't declared as an enum and now used as a 11265 // struct or something similar. 11266 if (!isAcceptableTagRedeclaration(PrevTagDecl, Kind, 11267 TUK == TUK_Definition, KWLoc, 11268 *Name)) { 11269 bool SafeToContinue 11270 = (PrevTagDecl->getTagKind() != TTK_Enum && 11271 Kind != TTK_Enum); 11272 if (SafeToContinue) 11273 Diag(KWLoc, diag::err_use_with_wrong_tag) 11274 << Name 11275 << FixItHint::CreateReplacement(SourceRange(KWLoc), 11276 PrevTagDecl->getKindName()); 11277 else 11278 Diag(KWLoc, diag::err_use_with_wrong_tag) << Name; 11279 Diag(PrevTagDecl->getLocation(), diag::note_previous_use); 11280 11281 if (SafeToContinue) 11282 Kind = PrevTagDecl->getTagKind(); 11283 else { 11284 // Recover by making this an anonymous redefinition. 11285 Name = nullptr; 11286 Previous.clear(); 11287 Invalid = true; 11288 } 11289 } 11290 11291 if (Kind == TTK_Enum && PrevTagDecl->getTagKind() == TTK_Enum) { 11292 const EnumDecl *PrevEnum = cast<EnumDecl>(PrevTagDecl); 11293 11294 // If this is an elaborated-type-specifier for a scoped enumeration, 11295 // the 'class' keyword is not necessary and not permitted. 11296 if (TUK == TUK_Reference || TUK == TUK_Friend) { 11297 if (ScopedEnum) 11298 Diag(ScopedEnumKWLoc, diag::err_enum_class_reference) 11299 << PrevEnum->isScoped() 11300 << FixItHint::CreateRemoval(ScopedEnumKWLoc); 11301 return PrevTagDecl; 11302 } 11303 11304 QualType EnumUnderlyingTy; 11305 if (TypeSourceInfo *TI = EnumUnderlying.dyn_cast<TypeSourceInfo*>()) 11306 EnumUnderlyingTy = TI->getType().getUnqualifiedType(); 11307 else if (const Type *T = EnumUnderlying.dyn_cast<const Type*>()) 11308 EnumUnderlyingTy = QualType(T, 0); 11309 11310 // All conflicts with previous declarations are recovered by 11311 // returning the previous declaration, unless this is a definition, 11312 // in which case we want the caller to bail out. 11313 if (CheckEnumRedeclaration(NameLoc.isValid() ? NameLoc : KWLoc, 11314 ScopedEnum, EnumUnderlyingTy, PrevEnum)) 11315 return TUK == TUK_Declaration ? PrevTagDecl : nullptr; 11316 } 11317 11318 // C++11 [class.mem]p1: 11319 // A member shall not be declared twice in the member-specification, 11320 // except that a nested class or member class template can be declared 11321 // and then later defined. 11322 if (TUK == TUK_Declaration && PrevDecl->isCXXClassMember() && 11323 S->isDeclScope(PrevDecl)) { 11324 Diag(NameLoc, diag::ext_member_redeclared); 11325 Diag(PrevTagDecl->getLocation(), diag::note_previous_declaration); 11326 } 11327 11328 if (!Invalid) { 11329 // If this is a use, just return the declaration we found, unless 11330 // we have attributes. 11331 11332 // FIXME: In the future, return a variant or some other clue 11333 // for the consumer of this Decl to know it doesn't own it. 11334 // For our current ASTs this shouldn't be a problem, but will 11335 // need to be changed with DeclGroups. 11336 if (!Attr && 11337 ((TUK == TUK_Reference && 11338 (!PrevTagDecl->getFriendObjectKind() || getLangOpts().MicrosoftExt)) 11339 || TUK == TUK_Friend)) 11340 return PrevTagDecl; 11341 11342 // Diagnose attempts to redefine a tag. 11343 if (TUK == TUK_Definition) { 11344 if (TagDecl *Def = PrevTagDecl->getDefinition()) { 11345 // If we're defining a specialization and the previous definition 11346 // is from an implicit instantiation, don't emit an error 11347 // here; we'll catch this in the general case below. 11348 bool IsExplicitSpecializationAfterInstantiation = false; 11349 if (isExplicitSpecialization) { 11350 if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(Def)) 11351 IsExplicitSpecializationAfterInstantiation = 11352 RD->getTemplateSpecializationKind() != 11353 TSK_ExplicitSpecialization; 11354 else if (EnumDecl *ED = dyn_cast<EnumDecl>(Def)) 11355 IsExplicitSpecializationAfterInstantiation = 11356 ED->getTemplateSpecializationKind() != 11357 TSK_ExplicitSpecialization; 11358 } 11359 11360 if (!IsExplicitSpecializationAfterInstantiation) { 11361 // A redeclaration in function prototype scope in C isn't 11362 // visible elsewhere, so merely issue a warning. 11363 if (!getLangOpts().CPlusPlus && S->containedInPrototypeScope()) 11364 Diag(NameLoc, diag::warn_redefinition_in_param_list) << Name; 11365 else 11366 Diag(NameLoc, diag::err_redefinition) << Name; 11367 Diag(Def->getLocation(), diag::note_previous_definition); 11368 // If this is a redefinition, recover by making this 11369 // struct be anonymous, which will make any later 11370 // references get the previous definition. 11371 Name = nullptr; 11372 Previous.clear(); 11373 Invalid = true; 11374 } 11375 } else { 11376 // If the type is currently being defined, complain 11377 // about a nested redefinition. 11378 const TagType *Tag 11379 = cast<TagType>(Context.getTagDeclType(PrevTagDecl)); 11380 if (Tag->isBeingDefined()) { 11381 Diag(NameLoc, diag::err_nested_redefinition) << Name; 11382 Diag(PrevTagDecl->getLocation(), 11383 diag::note_previous_definition); 11384 Name = nullptr; 11385 Previous.clear(); 11386 Invalid = true; 11387 } 11388 } 11389 11390 // Okay, this is definition of a previously declared or referenced 11391 // tag. We're going to create a new Decl for it. 11392 } 11393 11394 // Okay, we're going to make a redeclaration. If this is some kind 11395 // of reference, make sure we build the redeclaration in the same DC 11396 // as the original, and ignore the current access specifier. 11397 if (TUK == TUK_Friend || TUK == TUK_Reference) { 11398 SearchDC = PrevTagDecl->getDeclContext(); 11399 AS = AS_none; 11400 } 11401 } 11402 // If we get here we have (another) forward declaration or we 11403 // have a definition. Just create a new decl. 11404 11405 } else { 11406 // If we get here, this is a definition of a new tag type in a nested 11407 // scope, e.g. "struct foo; void bar() { struct foo; }", just create a 11408 // new decl/type. We set PrevDecl to NULL so that the entities 11409 // have distinct types. 11410 Previous.clear(); 11411 } 11412 // If we get here, we're going to create a new Decl. If PrevDecl 11413 // is non-NULL, it's a definition of the tag declared by 11414 // PrevDecl. If it's NULL, we have a new definition. 11415 11416 11417 // Otherwise, PrevDecl is not a tag, but was found with tag 11418 // lookup. This is only actually possible in C++, where a few 11419 // things like templates still live in the tag namespace. 11420 } else { 11421 // Use a better diagnostic if an elaborated-type-specifier 11422 // found the wrong kind of type on the first 11423 // (non-redeclaration) lookup. 11424 if ((TUK == TUK_Reference || TUK == TUK_Friend) && 11425 !Previous.isForRedeclaration()) { 11426 unsigned Kind = 0; 11427 if (isa<TypedefDecl>(PrevDecl)) Kind = 1; 11428 else if (isa<TypeAliasDecl>(PrevDecl)) Kind = 2; 11429 else if (isa<ClassTemplateDecl>(PrevDecl)) Kind = 3; 11430 Diag(NameLoc, diag::err_tag_reference_non_tag) << Kind; 11431 Diag(PrevDecl->getLocation(), diag::note_declared_at); 11432 Invalid = true; 11433 11434 // Otherwise, only diagnose if the declaration is in scope. 11435 } else if (!isDeclInScope(PrevDecl, SearchDC, S, 11436 SS.isNotEmpty() || isExplicitSpecialization)) { 11437 // do nothing 11438 11439 // Diagnose implicit declarations introduced by elaborated types. 11440 } else if (TUK == TUK_Reference || TUK == TUK_Friend) { 11441 unsigned Kind = 0; 11442 if (isa<TypedefDecl>(PrevDecl)) Kind = 1; 11443 else if (isa<TypeAliasDecl>(PrevDecl)) Kind = 2; 11444 else if (isa<ClassTemplateDecl>(PrevDecl)) Kind = 3; 11445 Diag(NameLoc, diag::err_tag_reference_conflict) << Kind; 11446 Diag(PrevDecl->getLocation(), diag::note_previous_decl) << PrevDecl; 11447 Invalid = true; 11448 11449 // Otherwise it's a declaration. Call out a particularly common 11450 // case here. 11451 } else if (TypedefNameDecl *TND = dyn_cast<TypedefNameDecl>(PrevDecl)) { 11452 unsigned Kind = 0; 11453 if (isa<TypeAliasDecl>(PrevDecl)) Kind = 1; 11454 Diag(NameLoc, diag::err_tag_definition_of_typedef) 11455 << Name << Kind << TND->getUnderlyingType(); 11456 Diag(PrevDecl->getLocation(), diag::note_previous_decl) << PrevDecl; 11457 Invalid = true; 11458 11459 // Otherwise, diagnose. 11460 } else { 11461 // The tag name clashes with something else in the target scope, 11462 // issue an error and recover by making this tag be anonymous. 11463 Diag(NameLoc, diag::err_redefinition_different_kind) << Name; 11464 Diag(PrevDecl->getLocation(), diag::note_previous_definition); 11465 Name = nullptr; 11466 Invalid = true; 11467 } 11468 11469 // The existing declaration isn't relevant to us; we're in a 11470 // new scope, so clear out the previous declaration. 11471 Previous.clear(); 11472 } 11473 } 11474 11475 CreateNewDecl: 11476 11477 TagDecl *PrevDecl = nullptr; 11478 if (Previous.isSingleResult()) 11479 PrevDecl = cast<TagDecl>(Previous.getFoundDecl()); 11480 11481 // If there is an identifier, use the location of the identifier as the 11482 // location of the decl, otherwise use the location of the struct/union 11483 // keyword. 11484 SourceLocation Loc = NameLoc.isValid() ? NameLoc : KWLoc; 11485 11486 // Otherwise, create a new declaration. If there is a previous 11487 // declaration of the same entity, the two will be linked via 11488 // PrevDecl. 11489 TagDecl *New; 11490 11491 bool IsForwardReference = false; 11492 if (Kind == TTK_Enum) { 11493 // FIXME: Tag decls should be chained to any simultaneous vardecls, e.g.: 11494 // enum X { A, B, C } D; D should chain to X. 11495 New = EnumDecl::Create(Context, SearchDC, KWLoc, Loc, Name, 11496 cast_or_null<EnumDecl>(PrevDecl), ScopedEnum, 11497 ScopedEnumUsesClassTag, !EnumUnderlying.isNull()); 11498 // If this is an undefined enum, warn. 11499 if (TUK != TUK_Definition && !Invalid) { 11500 TagDecl *Def; 11501 if ((getLangOpts().CPlusPlus11 || getLangOpts().ObjC2) && 11502 cast<EnumDecl>(New)->isFixed()) { 11503 // C++0x: 7.2p2: opaque-enum-declaration. 11504 // Conflicts are diagnosed above. Do nothing. 11505 } 11506 else if (PrevDecl && (Def = cast<EnumDecl>(PrevDecl)->getDefinition())) { 11507 Diag(Loc, diag::ext_forward_ref_enum_def) 11508 << New; 11509 Diag(Def->getLocation(), diag::note_previous_definition); 11510 } else { 11511 unsigned DiagID = diag::ext_forward_ref_enum; 11512 if (getLangOpts().MSVCCompat) 11513 DiagID = diag::ext_ms_forward_ref_enum; 11514 else if (getLangOpts().CPlusPlus) 11515 DiagID = diag::err_forward_ref_enum; 11516 Diag(Loc, DiagID); 11517 11518 // If this is a forward-declared reference to an enumeration, make a 11519 // note of it; we won't actually be introducing the declaration into 11520 // the declaration context. 11521 if (TUK == TUK_Reference) 11522 IsForwardReference = true; 11523 } 11524 } 11525 11526 if (EnumUnderlying) { 11527 EnumDecl *ED = cast<EnumDecl>(New); 11528 if (TypeSourceInfo *TI = EnumUnderlying.dyn_cast<TypeSourceInfo*>()) 11529 ED->setIntegerTypeSourceInfo(TI); 11530 else 11531 ED->setIntegerType(QualType(EnumUnderlying.get<const Type*>(), 0)); 11532 ED->setPromotionType(ED->getIntegerType()); 11533 } 11534 11535 } else { 11536 // struct/union/class 11537 11538 // FIXME: Tag decls should be chained to any simultaneous vardecls, e.g.: 11539 // struct X { int A; } D; D should chain to X. 11540 if (getLangOpts().CPlusPlus) { 11541 // FIXME: Look for a way to use RecordDecl for simple structs. 11542 New = CXXRecordDecl::Create(Context, Kind, SearchDC, KWLoc, Loc, Name, 11543 cast_or_null<CXXRecordDecl>(PrevDecl)); 11544 11545 if (isStdBadAlloc && (!StdBadAlloc || getStdBadAlloc()->isImplicit())) 11546 StdBadAlloc = cast<CXXRecordDecl>(New); 11547 } else 11548 New = RecordDecl::Create(Context, Kind, SearchDC, KWLoc, Loc, Name, 11549 cast_or_null<RecordDecl>(PrevDecl)); 11550 } 11551 11552 // C++11 [dcl.type]p3: 11553 // A type-specifier-seq shall not define a class or enumeration [...]. 11554 if (getLangOpts().CPlusPlus && IsTypeSpecifier && TUK == TUK_Definition) { 11555 Diag(New->getLocation(), diag::err_type_defined_in_type_specifier) 11556 << Context.getTagDeclType(New); 11557 Invalid = true; 11558 } 11559 11560 // Maybe add qualifier info. 11561 if (SS.isNotEmpty()) { 11562 if (SS.isSet()) { 11563 // If this is either a declaration or a definition, check the 11564 // nested-name-specifier against the current context. We don't do this 11565 // for explicit specializations, because they have similar checking 11566 // (with more specific diagnostics) in the call to 11567 // CheckMemberSpecialization, below. 11568 if (!isExplicitSpecialization && 11569 (TUK == TUK_Definition || TUK == TUK_Declaration) && 11570 diagnoseQualifiedDeclaration(SS, DC, OrigName, NameLoc)) 11571 Invalid = true; 11572 11573 New->setQualifierInfo(SS.getWithLocInContext(Context)); 11574 if (TemplateParameterLists.size() > 0) { 11575 New->setTemplateParameterListsInfo(Context, 11576 TemplateParameterLists.size(), 11577 TemplateParameterLists.data()); 11578 } 11579 } 11580 else 11581 Invalid = true; 11582 } 11583 11584 if (RecordDecl *RD = dyn_cast<RecordDecl>(New)) { 11585 // Add alignment attributes if necessary; these attributes are checked when 11586 // the ASTContext lays out the structure. 11587 // 11588 // It is important for implementing the correct semantics that this 11589 // happen here (in act on tag decl). The #pragma pack stack is 11590 // maintained as a result of parser callbacks which can occur at 11591 // many points during the parsing of a struct declaration (because 11592 // the #pragma tokens are effectively skipped over during the 11593 // parsing of the struct). 11594 if (TUK == TUK_Definition) { 11595 AddAlignmentAttributesForRecord(RD); 11596 AddMsStructLayoutForRecord(RD); 11597 } 11598 } 11599 11600 if (ModulePrivateLoc.isValid()) { 11601 if (isExplicitSpecialization) 11602 Diag(New->getLocation(), diag::err_module_private_specialization) 11603 << 2 11604 << FixItHint::CreateRemoval(ModulePrivateLoc); 11605 // __module_private__ does not apply to local classes. However, we only 11606 // diagnose this as an error when the declaration specifiers are 11607 // freestanding. Here, we just ignore the __module_private__. 11608 else if (!SearchDC->isFunctionOrMethod()) 11609 New->setModulePrivate(); 11610 } 11611 11612 // If this is a specialization of a member class (of a class template), 11613 // check the specialization. 11614 if (isExplicitSpecialization && CheckMemberSpecialization(New, Previous)) 11615 Invalid = true; 11616 11617 // If we're declaring or defining a tag in function prototype scope in C, 11618 // note that this type can only be used within the function and add it to 11619 // the list of decls to inject into the function definition scope. 11620 if ((Name || Kind == TTK_Enum) && 11621 getNonFieldDeclScope(S)->isFunctionPrototypeScope()) { 11622 if (getLangOpts().CPlusPlus) { 11623 // C++ [dcl.fct]p6: 11624 // Types shall not be defined in return or parameter types. 11625 if (TUK == TUK_Definition && !IsTypeSpecifier) { 11626 Diag(Loc, diag::err_type_defined_in_param_type) 11627 << Name; 11628 Invalid = true; 11629 } 11630 } else { 11631 Diag(Loc, diag::warn_decl_in_param_list) << Context.getTagDeclType(New); 11632 } 11633 DeclsInPrototypeScope.push_back(New); 11634 } 11635 11636 if (Invalid) 11637 New->setInvalidDecl(); 11638 11639 if (Attr) 11640 ProcessDeclAttributeList(S, New, Attr); 11641 11642 // Set the lexical context. If the tag has a C++ scope specifier, the 11643 // lexical context will be different from the semantic context. 11644 New->setLexicalDeclContext(CurContext); 11645 11646 // Mark this as a friend decl if applicable. 11647 // In Microsoft mode, a friend declaration also acts as a forward 11648 // declaration so we always pass true to setObjectOfFriendDecl to make 11649 // the tag name visible. 11650 if (TUK == TUK_Friend) 11651 New->setObjectOfFriendDecl(getLangOpts().MSVCCompat); 11652 11653 // Set the access specifier. 11654 if (!Invalid && SearchDC->isRecord()) 11655 SetMemberAccessSpecifier(New, PrevDecl, AS); 11656 11657 if (TUK == TUK_Definition) 11658 New->startDefinition(); 11659 11660 // If this has an identifier, add it to the scope stack. 11661 if (TUK == TUK_Friend) { 11662 // We might be replacing an existing declaration in the lookup tables; 11663 // if so, borrow its access specifier. 11664 if (PrevDecl) 11665 New->setAccess(PrevDecl->getAccess()); 11666 11667 DeclContext *DC = New->getDeclContext()->getRedeclContext(); 11668 DC->makeDeclVisibleInContext(New); 11669 if (Name) // can be null along some error paths 11670 if (Scope *EnclosingScope = getScopeForDeclContext(S, DC)) 11671 PushOnScopeChains(New, EnclosingScope, /* AddToContext = */ false); 11672 } else if (Name) { 11673 S = getNonFieldDeclScope(S); 11674 PushOnScopeChains(New, S, !IsForwardReference); 11675 if (IsForwardReference) 11676 SearchDC->makeDeclVisibleInContext(New); 11677 11678 } else { 11679 CurContext->addDecl(New); 11680 } 11681 11682 // If this is the C FILE type, notify the AST context. 11683 if (IdentifierInfo *II = New->getIdentifier()) 11684 if (!New->isInvalidDecl() && 11685 New->getDeclContext()->getRedeclContext()->isTranslationUnit() && 11686 II->isStr("FILE")) 11687 Context.setFILEDecl(New); 11688 11689 if (PrevDecl) 11690 mergeDeclAttributes(New, PrevDecl); 11691 11692 // If there's a #pragma GCC visibility in scope, set the visibility of this 11693 // record. 11694 AddPushedVisibilityAttribute(New); 11695 11696 OwnedDecl = true; 11697 // In C++, don't return an invalid declaration. We can't recover well from 11698 // the cases where we make the type anonymous. 11699 return (Invalid && getLangOpts().CPlusPlus) ? nullptr : New; 11700 } 11701 11702 void Sema::ActOnTagStartDefinition(Scope *S, Decl *TagD) { 11703 AdjustDeclIfTemplate(TagD); 11704 TagDecl *Tag = cast<TagDecl>(TagD); 11705 11706 // Enter the tag context. 11707 PushDeclContext(S, Tag); 11708 11709 ActOnDocumentableDecl(TagD); 11710 11711 // If there's a #pragma GCC visibility in scope, set the visibility of this 11712 // record. 11713 AddPushedVisibilityAttribute(Tag); 11714 } 11715 11716 Decl *Sema::ActOnObjCContainerStartDefinition(Decl *IDecl) { 11717 assert(isa<ObjCContainerDecl>(IDecl) && 11718 "ActOnObjCContainerStartDefinition - Not ObjCContainerDecl"); 11719 DeclContext *OCD = cast<DeclContext>(IDecl); 11720 assert(getContainingDC(OCD) == CurContext && 11721 "The next DeclContext should be lexically contained in the current one."); 11722 CurContext = OCD; 11723 return IDecl; 11724 } 11725 11726 void Sema::ActOnStartCXXMemberDeclarations(Scope *S, Decl *TagD, 11727 SourceLocation FinalLoc, 11728 bool IsFinalSpelledSealed, 11729 SourceLocation LBraceLoc) { 11730 AdjustDeclIfTemplate(TagD); 11731 CXXRecordDecl *Record = cast<CXXRecordDecl>(TagD); 11732 11733 FieldCollector->StartClass(); 11734 11735 if (!Record->getIdentifier()) 11736 return; 11737 11738 if (FinalLoc.isValid()) 11739 Record->addAttr(new (Context) 11740 FinalAttr(FinalLoc, Context, IsFinalSpelledSealed)); 11741 11742 // C++ [class]p2: 11743 // [...] The class-name is also inserted into the scope of the 11744 // class itself; this is known as the injected-class-name. For 11745 // purposes of access checking, the injected-class-name is treated 11746 // as if it were a public member name. 11747 CXXRecordDecl *InjectedClassName 11748 = CXXRecordDecl::Create(Context, Record->getTagKind(), CurContext, 11749 Record->getLocStart(), Record->getLocation(), 11750 Record->getIdentifier(), 11751 /*PrevDecl=*/nullptr, 11752 /*DelayTypeCreation=*/true); 11753 Context.getTypeDeclType(InjectedClassName, Record); 11754 InjectedClassName->setImplicit(); 11755 InjectedClassName->setAccess(AS_public); 11756 if (ClassTemplateDecl *Template = Record->getDescribedClassTemplate()) 11757 InjectedClassName->setDescribedClassTemplate(Template); 11758 PushOnScopeChains(InjectedClassName, S); 11759 assert(InjectedClassName->isInjectedClassName() && 11760 "Broken injected-class-name"); 11761 } 11762 11763 void Sema::ActOnTagFinishDefinition(Scope *S, Decl *TagD, 11764 SourceLocation RBraceLoc) { 11765 AdjustDeclIfTemplate(TagD); 11766 TagDecl *Tag = cast<TagDecl>(TagD); 11767 Tag->setRBraceLoc(RBraceLoc); 11768 11769 // Make sure we "complete" the definition even it is invalid. 11770 if (Tag->isBeingDefined()) { 11771 assert(Tag->isInvalidDecl() && "We should already have completed it"); 11772 if (RecordDecl *RD = dyn_cast<RecordDecl>(Tag)) 11773 RD->completeDefinition(); 11774 } 11775 11776 if (isa<CXXRecordDecl>(Tag)) 11777 FieldCollector->FinishClass(); 11778 11779 // Exit this scope of this tag's definition. 11780 PopDeclContext(); 11781 11782 if (getCurLexicalContext()->isObjCContainer() && 11783 Tag->getDeclContext()->isFileContext()) 11784 Tag->setTopLevelDeclInObjCContainer(); 11785 11786 // Notify the consumer that we've defined a tag. 11787 if (!Tag->isInvalidDecl()) 11788 Consumer.HandleTagDeclDefinition(Tag); 11789 } 11790 11791 void Sema::ActOnObjCContainerFinishDefinition() { 11792 // Exit this scope of this interface definition. 11793 PopDeclContext(); 11794 } 11795 11796 void Sema::ActOnObjCTemporaryExitContainerContext(DeclContext *DC) { 11797 assert(DC == CurContext && "Mismatch of container contexts"); 11798 OriginalLexicalContext = DC; 11799 ActOnObjCContainerFinishDefinition(); 11800 } 11801 11802 void Sema::ActOnObjCReenterContainerContext(DeclContext *DC) { 11803 ActOnObjCContainerStartDefinition(cast<Decl>(DC)); 11804 OriginalLexicalContext = nullptr; 11805 } 11806 11807 void Sema::ActOnTagDefinitionError(Scope *S, Decl *TagD) { 11808 AdjustDeclIfTemplate(TagD); 11809 TagDecl *Tag = cast<TagDecl>(TagD); 11810 Tag->setInvalidDecl(); 11811 11812 // Make sure we "complete" the definition even it is invalid. 11813 if (Tag->isBeingDefined()) { 11814 if (RecordDecl *RD = dyn_cast<RecordDecl>(Tag)) 11815 RD->completeDefinition(); 11816 } 11817 11818 // We're undoing ActOnTagStartDefinition here, not 11819 // ActOnStartCXXMemberDeclarations, so we don't have to mess with 11820 // the FieldCollector. 11821 11822 PopDeclContext(); 11823 } 11824 11825 // Note that FieldName may be null for anonymous bitfields. 11826 ExprResult Sema::VerifyBitField(SourceLocation FieldLoc, 11827 IdentifierInfo *FieldName, 11828 QualType FieldTy, bool IsMsStruct, 11829 Expr *BitWidth, bool *ZeroWidth) { 11830 // Default to true; that shouldn't confuse checks for emptiness 11831 if (ZeroWidth) 11832 *ZeroWidth = true; 11833 11834 // C99 6.7.2.1p4 - verify the field type. 11835 // C++ 9.6p3: A bit-field shall have integral or enumeration type. 11836 if (!FieldTy->isDependentType() && !FieldTy->isIntegralOrEnumerationType()) { 11837 // Handle incomplete types with specific error. 11838 if (RequireCompleteType(FieldLoc, FieldTy, diag::err_field_incomplete)) 11839 return ExprError(); 11840 if (FieldName) 11841 return Diag(FieldLoc, diag::err_not_integral_type_bitfield) 11842 << FieldName << FieldTy << BitWidth->getSourceRange(); 11843 return Diag(FieldLoc, diag::err_not_integral_type_anon_bitfield) 11844 << FieldTy << BitWidth->getSourceRange(); 11845 } else if (DiagnoseUnexpandedParameterPack(const_cast<Expr *>(BitWidth), 11846 UPPC_BitFieldWidth)) 11847 return ExprError(); 11848 11849 // If the bit-width is type- or value-dependent, don't try to check 11850 // it now. 11851 if (BitWidth->isValueDependent() || BitWidth->isTypeDependent()) 11852 return BitWidth; 11853 11854 llvm::APSInt Value; 11855 ExprResult ICE = VerifyIntegerConstantExpression(BitWidth, &Value); 11856 if (ICE.isInvalid()) 11857 return ICE; 11858 BitWidth = ICE.get(); 11859 11860 if (Value != 0 && ZeroWidth) 11861 *ZeroWidth = false; 11862 11863 // Zero-width bitfield is ok for anonymous field. 11864 if (Value == 0 && FieldName) 11865 return Diag(FieldLoc, diag::err_bitfield_has_zero_width) << FieldName; 11866 11867 if (Value.isSigned() && Value.isNegative()) { 11868 if (FieldName) 11869 return Diag(FieldLoc, diag::err_bitfield_has_negative_width) 11870 << FieldName << Value.toString(10); 11871 return Diag(FieldLoc, diag::err_anon_bitfield_has_negative_width) 11872 << Value.toString(10); 11873 } 11874 11875 if (!FieldTy->isDependentType()) { 11876 uint64_t TypeSize = Context.getTypeSize(FieldTy); 11877 if (Value.getZExtValue() > TypeSize) { 11878 if (!getLangOpts().CPlusPlus || IsMsStruct || 11879 Context.getTargetInfo().getCXXABI().isMicrosoft()) { 11880 if (FieldName) 11881 return Diag(FieldLoc, diag::err_bitfield_width_exceeds_type_size) 11882 << FieldName << (unsigned)Value.getZExtValue() 11883 << (unsigned)TypeSize; 11884 11885 return Diag(FieldLoc, diag::err_anon_bitfield_width_exceeds_type_size) 11886 << (unsigned)Value.getZExtValue() << (unsigned)TypeSize; 11887 } 11888 11889 if (FieldName) 11890 Diag(FieldLoc, diag::warn_bitfield_width_exceeds_type_size) 11891 << FieldName << (unsigned)Value.getZExtValue() 11892 << (unsigned)TypeSize; 11893 else 11894 Diag(FieldLoc, diag::warn_anon_bitfield_width_exceeds_type_size) 11895 << (unsigned)Value.getZExtValue() << (unsigned)TypeSize; 11896 } 11897 } 11898 11899 return BitWidth; 11900 } 11901 11902 /// ActOnField - Each field of a C struct/union is passed into this in order 11903 /// to create a FieldDecl object for it. 11904 Decl *Sema::ActOnField(Scope *S, Decl *TagD, SourceLocation DeclStart, 11905 Declarator &D, Expr *BitfieldWidth) { 11906 FieldDecl *Res = HandleField(S, cast_or_null<RecordDecl>(TagD), 11907 DeclStart, D, static_cast<Expr*>(BitfieldWidth), 11908 /*InitStyle=*/ICIS_NoInit, AS_public); 11909 return Res; 11910 } 11911 11912 /// HandleField - Analyze a field of a C struct or a C++ data member. 11913 /// 11914 FieldDecl *Sema::HandleField(Scope *S, RecordDecl *Record, 11915 SourceLocation DeclStart, 11916 Declarator &D, Expr *BitWidth, 11917 InClassInitStyle InitStyle, 11918 AccessSpecifier AS) { 11919 IdentifierInfo *II = D.getIdentifier(); 11920 SourceLocation Loc = DeclStart; 11921 if (II) Loc = D.getIdentifierLoc(); 11922 11923 TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S); 11924 QualType T = TInfo->getType(); 11925 if (getLangOpts().CPlusPlus) { 11926 CheckExtraCXXDefaultArguments(D); 11927 11928 if (DiagnoseUnexpandedParameterPack(D.getIdentifierLoc(), TInfo, 11929 UPPC_DataMemberType)) { 11930 D.setInvalidType(); 11931 T = Context.IntTy; 11932 TInfo = Context.getTrivialTypeSourceInfo(T, Loc); 11933 } 11934 } 11935 11936 // TR 18037 does not allow fields to be declared with address spaces. 11937 if (T.getQualifiers().hasAddressSpace()) { 11938 Diag(Loc, diag::err_field_with_address_space); 11939 D.setInvalidType(); 11940 } 11941 11942 // OpenCL 1.2 spec, s6.9 r: 11943 // The event type cannot be used to declare a structure or union field. 11944 if (LangOpts.OpenCL && T->isEventT()) { 11945 Diag(Loc, diag::err_event_t_struct_field); 11946 D.setInvalidType(); 11947 } 11948 11949 DiagnoseFunctionSpecifiers(D.getDeclSpec()); 11950 11951 if (DeclSpec::TSCS TSCS = D.getDeclSpec().getThreadStorageClassSpec()) 11952 Diag(D.getDeclSpec().getThreadStorageClassSpecLoc(), 11953 diag::err_invalid_thread) 11954 << DeclSpec::getSpecifierName(TSCS); 11955 11956 // Check to see if this name was declared as a member previously 11957 NamedDecl *PrevDecl = nullptr; 11958 LookupResult Previous(*this, II, Loc, LookupMemberName, ForRedeclaration); 11959 LookupName(Previous, S); 11960 switch (Previous.getResultKind()) { 11961 case LookupResult::Found: 11962 case LookupResult::FoundUnresolvedValue: 11963 PrevDecl = Previous.getAsSingle<NamedDecl>(); 11964 break; 11965 11966 case LookupResult::FoundOverloaded: 11967 PrevDecl = Previous.getRepresentativeDecl(); 11968 break; 11969 11970 case LookupResult::NotFound: 11971 case LookupResult::NotFoundInCurrentInstantiation: 11972 case LookupResult::Ambiguous: 11973 break; 11974 } 11975 Previous.suppressDiagnostics(); 11976 11977 if (PrevDecl && PrevDecl->isTemplateParameter()) { 11978 // Maybe we will complain about the shadowed template parameter. 11979 DiagnoseTemplateParameterShadow(D.getIdentifierLoc(), PrevDecl); 11980 // Just pretend that we didn't see the previous declaration. 11981 PrevDecl = nullptr; 11982 } 11983 11984 if (PrevDecl && !isDeclInScope(PrevDecl, Record, S)) 11985 PrevDecl = nullptr; 11986 11987 bool Mutable 11988 = (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_mutable); 11989 SourceLocation TSSL = D.getLocStart(); 11990 FieldDecl *NewFD 11991 = CheckFieldDecl(II, T, TInfo, Record, Loc, Mutable, BitWidth, InitStyle, 11992 TSSL, AS, PrevDecl, &D); 11993 11994 if (NewFD->isInvalidDecl()) 11995 Record->setInvalidDecl(); 11996 11997 if (D.getDeclSpec().isModulePrivateSpecified()) 11998 NewFD->setModulePrivate(); 11999 12000 if (NewFD->isInvalidDecl() && PrevDecl) { 12001 // Don't introduce NewFD into scope; there's already something 12002 // with the same name in the same scope. 12003 } else if (II) { 12004 PushOnScopeChains(NewFD, S); 12005 } else 12006 Record->addDecl(NewFD); 12007 12008 return NewFD; 12009 } 12010 12011 /// \brief Build a new FieldDecl and check its well-formedness. 12012 /// 12013 /// This routine builds a new FieldDecl given the fields name, type, 12014 /// record, etc. \p PrevDecl should refer to any previous declaration 12015 /// with the same name and in the same scope as the field to be 12016 /// created. 12017 /// 12018 /// \returns a new FieldDecl. 12019 /// 12020 /// \todo The Declarator argument is a hack. It will be removed once 12021 FieldDecl *Sema::CheckFieldDecl(DeclarationName Name, QualType T, 12022 TypeSourceInfo *TInfo, 12023 RecordDecl *Record, SourceLocation Loc, 12024 bool Mutable, Expr *BitWidth, 12025 InClassInitStyle InitStyle, 12026 SourceLocation TSSL, 12027 AccessSpecifier AS, NamedDecl *PrevDecl, 12028 Declarator *D) { 12029 IdentifierInfo *II = Name.getAsIdentifierInfo(); 12030 bool InvalidDecl = false; 12031 if (D) InvalidDecl = D->isInvalidType(); 12032 12033 // If we receive a broken type, recover by assuming 'int' and 12034 // marking this declaration as invalid. 12035 if (T.isNull()) { 12036 InvalidDecl = true; 12037 T = Context.IntTy; 12038 } 12039 12040 QualType EltTy = Context.getBaseElementType(T); 12041 if (!EltTy->isDependentType()) { 12042 if (RequireCompleteType(Loc, EltTy, diag::err_field_incomplete)) { 12043 // Fields of incomplete type force their record to be invalid. 12044 Record->setInvalidDecl(); 12045 InvalidDecl = true; 12046 } else { 12047 NamedDecl *Def; 12048 EltTy->isIncompleteType(&Def); 12049 if (Def && Def->isInvalidDecl()) { 12050 Record->setInvalidDecl(); 12051 InvalidDecl = true; 12052 } 12053 } 12054 } 12055 12056 // OpenCL v1.2 s6.9.c: bitfields are not supported. 12057 if (BitWidth && getLangOpts().OpenCL) { 12058 Diag(Loc, diag::err_opencl_bitfields); 12059 InvalidDecl = true; 12060 } 12061 12062 // C99 6.7.2.1p8: A member of a structure or union may have any type other 12063 // than a variably modified type. 12064 if (!InvalidDecl && T->isVariablyModifiedType()) { 12065 bool SizeIsNegative; 12066 llvm::APSInt Oversized; 12067 12068 TypeSourceInfo *FixedTInfo = 12069 TryToFixInvalidVariablyModifiedTypeSourceInfo(TInfo, Context, 12070 SizeIsNegative, 12071 Oversized); 12072 if (FixedTInfo) { 12073 Diag(Loc, diag::warn_illegal_constant_array_size); 12074 TInfo = FixedTInfo; 12075 T = FixedTInfo->getType(); 12076 } else { 12077 if (SizeIsNegative) 12078 Diag(Loc, diag::err_typecheck_negative_array_size); 12079 else if (Oversized.getBoolValue()) 12080 Diag(Loc, diag::err_array_too_large) 12081 << Oversized.toString(10); 12082 else 12083 Diag(Loc, diag::err_typecheck_field_variable_size); 12084 InvalidDecl = true; 12085 } 12086 } 12087 12088 // Fields can not have abstract class types 12089 if (!InvalidDecl && RequireNonAbstractType(Loc, T, 12090 diag::err_abstract_type_in_decl, 12091 AbstractFieldType)) 12092 InvalidDecl = true; 12093 12094 bool ZeroWidth = false; 12095 // If this is declared as a bit-field, check the bit-field. 12096 if (!InvalidDecl && BitWidth) { 12097 BitWidth = VerifyBitField(Loc, II, T, Record->isMsStruct(Context), BitWidth, 12098 &ZeroWidth).get(); 12099 if (!BitWidth) { 12100 InvalidDecl = true; 12101 BitWidth = nullptr; 12102 ZeroWidth = false; 12103 } 12104 } 12105 12106 // Check that 'mutable' is consistent with the type of the declaration. 12107 if (!InvalidDecl && Mutable) { 12108 unsigned DiagID = 0; 12109 if (T->isReferenceType()) 12110 DiagID = diag::err_mutable_reference; 12111 else if (T.isConstQualified()) 12112 DiagID = diag::err_mutable_const; 12113 12114 if (DiagID) { 12115 SourceLocation ErrLoc = Loc; 12116 if (D && D->getDeclSpec().getStorageClassSpecLoc().isValid()) 12117 ErrLoc = D->getDeclSpec().getStorageClassSpecLoc(); 12118 Diag(ErrLoc, DiagID); 12119 Mutable = false; 12120 InvalidDecl = true; 12121 } 12122 } 12123 12124 // C++11 [class.union]p8 (DR1460): 12125 // At most one variant member of a union may have a 12126 // brace-or-equal-initializer. 12127 if (InitStyle != ICIS_NoInit) 12128 checkDuplicateDefaultInit(*this, cast<CXXRecordDecl>(Record), Loc); 12129 12130 FieldDecl *NewFD = FieldDecl::Create(Context, Record, TSSL, Loc, II, T, TInfo, 12131 BitWidth, Mutable, InitStyle); 12132 if (InvalidDecl) 12133 NewFD->setInvalidDecl(); 12134 12135 if (PrevDecl && !isa<TagDecl>(PrevDecl)) { 12136 Diag(Loc, diag::err_duplicate_member) << II; 12137 Diag(PrevDecl->getLocation(), diag::note_previous_declaration); 12138 NewFD->setInvalidDecl(); 12139 } 12140 12141 if (!InvalidDecl && getLangOpts().CPlusPlus) { 12142 if (Record->isUnion()) { 12143 if (const RecordType *RT = EltTy->getAs<RecordType>()) { 12144 CXXRecordDecl* RDecl = cast<CXXRecordDecl>(RT->getDecl()); 12145 if (RDecl->getDefinition()) { 12146 // C++ [class.union]p1: An object of a class with a non-trivial 12147 // constructor, a non-trivial copy constructor, a non-trivial 12148 // destructor, or a non-trivial copy assignment operator 12149 // cannot be a member of a union, nor can an array of such 12150 // objects. 12151 if (CheckNontrivialField(NewFD)) 12152 NewFD->setInvalidDecl(); 12153 } 12154 } 12155 12156 // C++ [class.union]p1: If a union contains a member of reference type, 12157 // the program is ill-formed, except when compiling with MSVC extensions 12158 // enabled. 12159 if (EltTy->isReferenceType()) { 12160 Diag(NewFD->getLocation(), getLangOpts().MicrosoftExt ? 12161 diag::ext_union_member_of_reference_type : 12162 diag::err_union_member_of_reference_type) 12163 << NewFD->getDeclName() << EltTy; 12164 if (!getLangOpts().MicrosoftExt) 12165 NewFD->setInvalidDecl(); 12166 } 12167 } 12168 } 12169 12170 // FIXME: We need to pass in the attributes given an AST 12171 // representation, not a parser representation. 12172 if (D) { 12173 // FIXME: The current scope is almost... but not entirely... correct here. 12174 ProcessDeclAttributes(getCurScope(), NewFD, *D); 12175 12176 if (NewFD->hasAttrs()) 12177 CheckAlignasUnderalignment(NewFD); 12178 } 12179 12180 // In auto-retain/release, infer strong retension for fields of 12181 // retainable type. 12182 if (getLangOpts().ObjCAutoRefCount && inferObjCARCLifetime(NewFD)) 12183 NewFD->setInvalidDecl(); 12184 12185 if (T.isObjCGCWeak()) 12186 Diag(Loc, diag::warn_attribute_weak_on_field); 12187 12188 NewFD->setAccess(AS); 12189 return NewFD; 12190 } 12191 12192 bool Sema::CheckNontrivialField(FieldDecl *FD) { 12193 assert(FD); 12194 assert(getLangOpts().CPlusPlus && "valid check only for C++"); 12195 12196 if (FD->isInvalidDecl() || FD->getType()->isDependentType()) 12197 return false; 12198 12199 QualType EltTy = Context.getBaseElementType(FD->getType()); 12200 if (const RecordType *RT = EltTy->getAs<RecordType>()) { 12201 CXXRecordDecl *RDecl = cast<CXXRecordDecl>(RT->getDecl()); 12202 if (RDecl->getDefinition()) { 12203 // We check for copy constructors before constructors 12204 // because otherwise we'll never get complaints about 12205 // copy constructors. 12206 12207 CXXSpecialMember member = CXXInvalid; 12208 // We're required to check for any non-trivial constructors. Since the 12209 // implicit default constructor is suppressed if there are any 12210 // user-declared constructors, we just need to check that there is a 12211 // trivial default constructor and a trivial copy constructor. (We don't 12212 // worry about move constructors here, since this is a C++98 check.) 12213 if (RDecl->hasNonTrivialCopyConstructor()) 12214 member = CXXCopyConstructor; 12215 else if (!RDecl->hasTrivialDefaultConstructor()) 12216 member = CXXDefaultConstructor; 12217 else if (RDecl->hasNonTrivialCopyAssignment()) 12218 member = CXXCopyAssignment; 12219 else if (RDecl->hasNonTrivialDestructor()) 12220 member = CXXDestructor; 12221 12222 if (member != CXXInvalid) { 12223 if (!getLangOpts().CPlusPlus11 && 12224 getLangOpts().ObjCAutoRefCount && RDecl->hasObjectMember()) { 12225 // Objective-C++ ARC: it is an error to have a non-trivial field of 12226 // a union. However, system headers in Objective-C programs 12227 // occasionally have Objective-C lifetime objects within unions, 12228 // and rather than cause the program to fail, we make those 12229 // members unavailable. 12230 SourceLocation Loc = FD->getLocation(); 12231 if (getSourceManager().isInSystemHeader(Loc)) { 12232 if (!FD->hasAttr<UnavailableAttr>()) 12233 FD->addAttr(UnavailableAttr::CreateImplicit(Context, 12234 "this system field has retaining ownership", 12235 Loc)); 12236 return false; 12237 } 12238 } 12239 12240 Diag(FD->getLocation(), getLangOpts().CPlusPlus11 ? 12241 diag::warn_cxx98_compat_nontrivial_union_or_anon_struct_member : 12242 diag::err_illegal_union_or_anon_struct_member) 12243 << (int)FD->getParent()->isUnion() << FD->getDeclName() << member; 12244 DiagnoseNontrivial(RDecl, member); 12245 return !getLangOpts().CPlusPlus11; 12246 } 12247 } 12248 } 12249 12250 return false; 12251 } 12252 12253 /// TranslateIvarVisibility - Translate visibility from a token ID to an 12254 /// AST enum value. 12255 static ObjCIvarDecl::AccessControl 12256 TranslateIvarVisibility(tok::ObjCKeywordKind ivarVisibility) { 12257 switch (ivarVisibility) { 12258 default: llvm_unreachable("Unknown visitibility kind"); 12259 case tok::objc_private: return ObjCIvarDecl::Private; 12260 case tok::objc_public: return ObjCIvarDecl::Public; 12261 case tok::objc_protected: return ObjCIvarDecl::Protected; 12262 case tok::objc_package: return ObjCIvarDecl::Package; 12263 } 12264 } 12265 12266 /// ActOnIvar - Each ivar field of an objective-c class is passed into this 12267 /// in order to create an IvarDecl object for it. 12268 Decl *Sema::ActOnIvar(Scope *S, 12269 SourceLocation DeclStart, 12270 Declarator &D, Expr *BitfieldWidth, 12271 tok::ObjCKeywordKind Visibility) { 12272 12273 IdentifierInfo *II = D.getIdentifier(); 12274 Expr *BitWidth = (Expr*)BitfieldWidth; 12275 SourceLocation Loc = DeclStart; 12276 if (II) Loc = D.getIdentifierLoc(); 12277 12278 // FIXME: Unnamed fields can be handled in various different ways, for 12279 // example, unnamed unions inject all members into the struct namespace! 12280 12281 TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S); 12282 QualType T = TInfo->getType(); 12283 12284 if (BitWidth) { 12285 // 6.7.2.1p3, 6.7.2.1p4 12286 BitWidth = VerifyBitField(Loc, II, T, /*IsMsStruct*/false, BitWidth).get(); 12287 if (!BitWidth) 12288 D.setInvalidType(); 12289 } else { 12290 // Not a bitfield. 12291 12292 // validate II. 12293 12294 } 12295 if (T->isReferenceType()) { 12296 Diag(Loc, diag::err_ivar_reference_type); 12297 D.setInvalidType(); 12298 } 12299 // C99 6.7.2.1p8: A member of a structure or union may have any type other 12300 // than a variably modified type. 12301 else if (T->isVariablyModifiedType()) { 12302 Diag(Loc, diag::err_typecheck_ivar_variable_size); 12303 D.setInvalidType(); 12304 } 12305 12306 // Get the visibility (access control) for this ivar. 12307 ObjCIvarDecl::AccessControl ac = 12308 Visibility != tok::objc_not_keyword ? TranslateIvarVisibility(Visibility) 12309 : ObjCIvarDecl::None; 12310 // Must set ivar's DeclContext to its enclosing interface. 12311 ObjCContainerDecl *EnclosingDecl = cast<ObjCContainerDecl>(CurContext); 12312 if (!EnclosingDecl || EnclosingDecl->isInvalidDecl()) 12313 return nullptr; 12314 ObjCContainerDecl *EnclosingContext; 12315 if (ObjCImplementationDecl *IMPDecl = 12316 dyn_cast<ObjCImplementationDecl>(EnclosingDecl)) { 12317 if (LangOpts.ObjCRuntime.isFragile()) { 12318 // Case of ivar declared in an implementation. Context is that of its class. 12319 EnclosingContext = IMPDecl->getClassInterface(); 12320 assert(EnclosingContext && "Implementation has no class interface!"); 12321 } 12322 else 12323 EnclosingContext = EnclosingDecl; 12324 } else { 12325 if (ObjCCategoryDecl *CDecl = 12326 dyn_cast<ObjCCategoryDecl>(EnclosingDecl)) { 12327 if (LangOpts.ObjCRuntime.isFragile() || !CDecl->IsClassExtension()) { 12328 Diag(Loc, diag::err_misplaced_ivar) << CDecl->IsClassExtension(); 12329 return nullptr; 12330 } 12331 } 12332 EnclosingContext = EnclosingDecl; 12333 } 12334 12335 // Construct the decl. 12336 ObjCIvarDecl *NewID = ObjCIvarDecl::Create(Context, EnclosingContext, 12337 DeclStart, Loc, II, T, 12338 TInfo, ac, (Expr *)BitfieldWidth); 12339 12340 if (II) { 12341 NamedDecl *PrevDecl = LookupSingleName(S, II, Loc, LookupMemberName, 12342 ForRedeclaration); 12343 if (PrevDecl && isDeclInScope(PrevDecl, EnclosingContext, S) 12344 && !isa<TagDecl>(PrevDecl)) { 12345 Diag(Loc, diag::err_duplicate_member) << II; 12346 Diag(PrevDecl->getLocation(), diag::note_previous_declaration); 12347 NewID->setInvalidDecl(); 12348 } 12349 } 12350 12351 // Process attributes attached to the ivar. 12352 ProcessDeclAttributes(S, NewID, D); 12353 12354 if (D.isInvalidType()) 12355 NewID->setInvalidDecl(); 12356 12357 // In ARC, infer 'retaining' for ivars of retainable type. 12358 if (getLangOpts().ObjCAutoRefCount && inferObjCARCLifetime(NewID)) 12359 NewID->setInvalidDecl(); 12360 12361 if (D.getDeclSpec().isModulePrivateSpecified()) 12362 NewID->setModulePrivate(); 12363 12364 if (II) { 12365 // FIXME: When interfaces are DeclContexts, we'll need to add 12366 // these to the interface. 12367 S->AddDecl(NewID); 12368 IdResolver.AddDecl(NewID); 12369 } 12370 12371 if (LangOpts.ObjCRuntime.isNonFragile() && 12372 !NewID->isInvalidDecl() && isa<ObjCInterfaceDecl>(EnclosingDecl)) 12373 Diag(Loc, diag::warn_ivars_in_interface); 12374 12375 return NewID; 12376 } 12377 12378 /// ActOnLastBitfield - This routine handles synthesized bitfields rules for 12379 /// class and class extensions. For every class \@interface and class 12380 /// extension \@interface, if the last ivar is a bitfield of any type, 12381 /// then add an implicit `char :0` ivar to the end of that interface. 12382 void Sema::ActOnLastBitfield(SourceLocation DeclLoc, 12383 SmallVectorImpl<Decl *> &AllIvarDecls) { 12384 if (LangOpts.ObjCRuntime.isFragile() || AllIvarDecls.empty()) 12385 return; 12386 12387 Decl *ivarDecl = AllIvarDecls[AllIvarDecls.size()-1]; 12388 ObjCIvarDecl *Ivar = cast<ObjCIvarDecl>(ivarDecl); 12389 12390 if (!Ivar->isBitField() || Ivar->getBitWidthValue(Context) == 0) 12391 return; 12392 ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(CurContext); 12393 if (!ID) { 12394 if (ObjCCategoryDecl *CD = dyn_cast<ObjCCategoryDecl>(CurContext)) { 12395 if (!CD->IsClassExtension()) 12396 return; 12397 } 12398 // No need to add this to end of @implementation. 12399 else 12400 return; 12401 } 12402 // All conditions are met. Add a new bitfield to the tail end of ivars. 12403 llvm::APInt Zero(Context.getTypeSize(Context.IntTy), 0); 12404 Expr * BW = IntegerLiteral::Create(Context, Zero, Context.IntTy, DeclLoc); 12405 12406 Ivar = ObjCIvarDecl::Create(Context, cast<ObjCContainerDecl>(CurContext), 12407 DeclLoc, DeclLoc, nullptr, 12408 Context.CharTy, 12409 Context.getTrivialTypeSourceInfo(Context.CharTy, 12410 DeclLoc), 12411 ObjCIvarDecl::Private, BW, 12412 true); 12413 AllIvarDecls.push_back(Ivar); 12414 } 12415 12416 void Sema::ActOnFields(Scope *S, SourceLocation RecLoc, Decl *EnclosingDecl, 12417 ArrayRef<Decl *> Fields, SourceLocation LBrac, 12418 SourceLocation RBrac, AttributeList *Attr) { 12419 assert(EnclosingDecl && "missing record or interface decl"); 12420 12421 // If this is an Objective-C @implementation or category and we have 12422 // new fields here we should reset the layout of the interface since 12423 // it will now change. 12424 if (!Fields.empty() && isa<ObjCContainerDecl>(EnclosingDecl)) { 12425 ObjCContainerDecl *DC = cast<ObjCContainerDecl>(EnclosingDecl); 12426 switch (DC->getKind()) { 12427 default: break; 12428 case Decl::ObjCCategory: 12429 Context.ResetObjCLayout(cast<ObjCCategoryDecl>(DC)->getClassInterface()); 12430 break; 12431 case Decl::ObjCImplementation: 12432 Context. 12433 ResetObjCLayout(cast<ObjCImplementationDecl>(DC)->getClassInterface()); 12434 break; 12435 } 12436 } 12437 12438 RecordDecl *Record = dyn_cast<RecordDecl>(EnclosingDecl); 12439 12440 // Start counting up the number of named members; make sure to include 12441 // members of anonymous structs and unions in the total. 12442 unsigned NumNamedMembers = 0; 12443 if (Record) { 12444 for (const auto *I : Record->decls()) { 12445 if (const auto *IFD = dyn_cast<IndirectFieldDecl>(I)) 12446 if (IFD->getDeclName()) 12447 ++NumNamedMembers; 12448 } 12449 } 12450 12451 // Verify that all the fields are okay. 12452 SmallVector<FieldDecl*, 32> RecFields; 12453 12454 bool ARCErrReported = false; 12455 for (ArrayRef<Decl *>::iterator i = Fields.begin(), end = Fields.end(); 12456 i != end; ++i) { 12457 FieldDecl *FD = cast<FieldDecl>(*i); 12458 12459 // Get the type for the field. 12460 const Type *FDTy = FD->getType().getTypePtr(); 12461 12462 if (!FD->isAnonymousStructOrUnion()) { 12463 // Remember all fields written by the user. 12464 RecFields.push_back(FD); 12465 } 12466 12467 // If the field is already invalid for some reason, don't emit more 12468 // diagnostics about it. 12469 if (FD->isInvalidDecl()) { 12470 EnclosingDecl->setInvalidDecl(); 12471 continue; 12472 } 12473 12474 // C99 6.7.2.1p2: 12475 // A structure or union shall not contain a member with 12476 // incomplete or function type (hence, a structure shall not 12477 // contain an instance of itself, but may contain a pointer to 12478 // an instance of itself), except that the last member of a 12479 // structure with more than one named member may have incomplete 12480 // array type; such a structure (and any union containing, 12481 // possibly recursively, a member that is such a structure) 12482 // shall not be a member of a structure or an element of an 12483 // array. 12484 if (FDTy->isFunctionType()) { 12485 // Field declared as a function. 12486 Diag(FD->getLocation(), diag::err_field_declared_as_function) 12487 << FD->getDeclName(); 12488 FD->setInvalidDecl(); 12489 EnclosingDecl->setInvalidDecl(); 12490 continue; 12491 } else if (FDTy->isIncompleteArrayType() && Record && 12492 ((i + 1 == Fields.end() && !Record->isUnion()) || 12493 ((getLangOpts().MicrosoftExt || 12494 getLangOpts().CPlusPlus) && 12495 (i + 1 == Fields.end() || Record->isUnion())))) { 12496 // Flexible array member. 12497 // Microsoft and g++ is more permissive regarding flexible array. 12498 // It will accept flexible array in union and also 12499 // as the sole element of a struct/class. 12500 unsigned DiagID = 0; 12501 if (Record->isUnion()) 12502 DiagID = getLangOpts().MicrosoftExt 12503 ? diag::ext_flexible_array_union_ms 12504 : getLangOpts().CPlusPlus 12505 ? diag::ext_flexible_array_union_gnu 12506 : diag::err_flexible_array_union; 12507 else if (Fields.size() == 1) 12508 DiagID = getLangOpts().MicrosoftExt 12509 ? diag::ext_flexible_array_empty_aggregate_ms 12510 : getLangOpts().CPlusPlus 12511 ? diag::ext_flexible_array_empty_aggregate_gnu 12512 : NumNamedMembers < 1 12513 ? diag::err_flexible_array_empty_aggregate 12514 : 0; 12515 12516 if (DiagID) 12517 Diag(FD->getLocation(), DiagID) << FD->getDeclName() 12518 << Record->getTagKind(); 12519 // While the layout of types that contain virtual bases is not specified 12520 // by the C++ standard, both the Itanium and Microsoft C++ ABIs place 12521 // virtual bases after the derived members. This would make a flexible 12522 // array member declared at the end of an object not adjacent to the end 12523 // of the type. 12524 if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(Record)) 12525 if (RD->getNumVBases() != 0) 12526 Diag(FD->getLocation(), diag::err_flexible_array_virtual_base) 12527 << FD->getDeclName() << Record->getTagKind(); 12528 if (!getLangOpts().C99) 12529 Diag(FD->getLocation(), diag::ext_c99_flexible_array_member) 12530 << FD->getDeclName() << Record->getTagKind(); 12531 12532 // If the element type has a non-trivial destructor, we would not 12533 // implicitly destroy the elements, so disallow it for now. 12534 // 12535 // FIXME: GCC allows this. We should probably either implicitly delete 12536 // the destructor of the containing class, or just allow this. 12537 QualType BaseElem = Context.getBaseElementType(FD->getType()); 12538 if (!BaseElem->isDependentType() && BaseElem.isDestructedType()) { 12539 Diag(FD->getLocation(), diag::err_flexible_array_has_nontrivial_dtor) 12540 << FD->getDeclName() << FD->getType(); 12541 FD->setInvalidDecl(); 12542 EnclosingDecl->setInvalidDecl(); 12543 continue; 12544 } 12545 // Okay, we have a legal flexible array member at the end of the struct. 12546 if (Record) 12547 Record->setHasFlexibleArrayMember(true); 12548 } else if (!FDTy->isDependentType() && 12549 RequireCompleteType(FD->getLocation(), FD->getType(), 12550 diag::err_field_incomplete)) { 12551 // Incomplete type 12552 FD->setInvalidDecl(); 12553 EnclosingDecl->setInvalidDecl(); 12554 continue; 12555 } else if (const RecordType *FDTTy = FDTy->getAs<RecordType>()) { 12556 if (FDTTy->getDecl()->hasFlexibleArrayMember()) { 12557 // If this is a member of a union, then entire union becomes "flexible". 12558 if (Record && Record->isUnion()) { 12559 Record->setHasFlexibleArrayMember(true); 12560 } else { 12561 // If this is a struct/class and this is not the last element, reject 12562 // it. Note that GCC supports variable sized arrays in the middle of 12563 // structures. 12564 if (i + 1 != Fields.end()) 12565 Diag(FD->getLocation(), diag::ext_variable_sized_type_in_struct) 12566 << FD->getDeclName() << FD->getType(); 12567 else { 12568 // We support flexible arrays at the end of structs in 12569 // other structs as an extension. 12570 Diag(FD->getLocation(), diag::ext_flexible_array_in_struct) 12571 << FD->getDeclName(); 12572 if (Record) 12573 Record->setHasFlexibleArrayMember(true); 12574 } 12575 } 12576 } 12577 if (isa<ObjCContainerDecl>(EnclosingDecl) && 12578 RequireNonAbstractType(FD->getLocation(), FD->getType(), 12579 diag::err_abstract_type_in_decl, 12580 AbstractIvarType)) { 12581 // Ivars can not have abstract class types 12582 FD->setInvalidDecl(); 12583 } 12584 if (Record && FDTTy->getDecl()->hasObjectMember()) 12585 Record->setHasObjectMember(true); 12586 if (Record && FDTTy->getDecl()->hasVolatileMember()) 12587 Record->setHasVolatileMember(true); 12588 } else if (FDTy->isObjCObjectType()) { 12589 /// A field cannot be an Objective-c object 12590 Diag(FD->getLocation(), diag::err_statically_allocated_object) 12591 << FixItHint::CreateInsertion(FD->getLocation(), "*"); 12592 QualType T = Context.getObjCObjectPointerType(FD->getType()); 12593 FD->setType(T); 12594 } else if (getLangOpts().ObjCAutoRefCount && Record && !ARCErrReported && 12595 (!getLangOpts().CPlusPlus || Record->isUnion())) { 12596 // It's an error in ARC if a field has lifetime. 12597 // We don't want to report this in a system header, though, 12598 // so we just make the field unavailable. 12599 // FIXME: that's really not sufficient; we need to make the type 12600 // itself invalid to, say, initialize or copy. 12601 QualType T = FD->getType(); 12602 Qualifiers::ObjCLifetime lifetime = T.getObjCLifetime(); 12603 if (lifetime && lifetime != Qualifiers::OCL_ExplicitNone) { 12604 SourceLocation loc = FD->getLocation(); 12605 if (getSourceManager().isInSystemHeader(loc)) { 12606 if (!FD->hasAttr<UnavailableAttr>()) { 12607 FD->addAttr(UnavailableAttr::CreateImplicit(Context, 12608 "this system field has retaining ownership", 12609 loc)); 12610 } 12611 } else { 12612 Diag(FD->getLocation(), diag::err_arc_objc_object_in_tag) 12613 << T->isBlockPointerType() << Record->getTagKind(); 12614 } 12615 ARCErrReported = true; 12616 } 12617 } else if (getLangOpts().ObjC1 && 12618 getLangOpts().getGC() != LangOptions::NonGC && 12619 Record && !Record->hasObjectMember()) { 12620 if (FD->getType()->isObjCObjectPointerType() || 12621 FD->getType().isObjCGCStrong()) 12622 Record->setHasObjectMember(true); 12623 else if (Context.getAsArrayType(FD->getType())) { 12624 QualType BaseType = Context.getBaseElementType(FD->getType()); 12625 if (BaseType->isRecordType() && 12626 BaseType->getAs<RecordType>()->getDecl()->hasObjectMember()) 12627 Record->setHasObjectMember(true); 12628 else if (BaseType->isObjCObjectPointerType() || 12629 BaseType.isObjCGCStrong()) 12630 Record->setHasObjectMember(true); 12631 } 12632 } 12633 if (Record && FD->getType().isVolatileQualified()) 12634 Record->setHasVolatileMember(true); 12635 // Keep track of the number of named members. 12636 if (FD->getIdentifier()) 12637 ++NumNamedMembers; 12638 } 12639 12640 // Okay, we successfully defined 'Record'. 12641 if (Record) { 12642 bool Completed = false; 12643 if (CXXRecordDecl *CXXRecord = dyn_cast<CXXRecordDecl>(Record)) { 12644 if (!CXXRecord->isInvalidDecl()) { 12645 // Set access bits correctly on the directly-declared conversions. 12646 for (CXXRecordDecl::conversion_iterator 12647 I = CXXRecord->conversion_begin(), 12648 E = CXXRecord->conversion_end(); I != E; ++I) 12649 I.setAccess((*I)->getAccess()); 12650 12651 if (!CXXRecord->isDependentType()) { 12652 if (CXXRecord->hasUserDeclaredDestructor()) { 12653 // Adjust user-defined destructor exception spec. 12654 if (getLangOpts().CPlusPlus11) 12655 AdjustDestructorExceptionSpec(CXXRecord, 12656 CXXRecord->getDestructor()); 12657 } 12658 12659 // Add any implicitly-declared members to this class. 12660 AddImplicitlyDeclaredMembersToClass(CXXRecord); 12661 12662 // If we have virtual base classes, we may end up finding multiple 12663 // final overriders for a given virtual function. Check for this 12664 // problem now. 12665 if (CXXRecord->getNumVBases()) { 12666 CXXFinalOverriderMap FinalOverriders; 12667 CXXRecord->getFinalOverriders(FinalOverriders); 12668 12669 for (CXXFinalOverriderMap::iterator M = FinalOverriders.begin(), 12670 MEnd = FinalOverriders.end(); 12671 M != MEnd; ++M) { 12672 for (OverridingMethods::iterator SO = M->second.begin(), 12673 SOEnd = M->second.end(); 12674 SO != SOEnd; ++SO) { 12675 assert(SO->second.size() > 0 && 12676 "Virtual function without overridding functions?"); 12677 if (SO->second.size() == 1) 12678 continue; 12679 12680 // C++ [class.virtual]p2: 12681 // In a derived class, if a virtual member function of a base 12682 // class subobject has more than one final overrider the 12683 // program is ill-formed. 12684 Diag(Record->getLocation(), diag::err_multiple_final_overriders) 12685 << (const NamedDecl *)M->first << Record; 12686 Diag(M->first->getLocation(), 12687 diag::note_overridden_virtual_function); 12688 for (OverridingMethods::overriding_iterator 12689 OM = SO->second.begin(), 12690 OMEnd = SO->second.end(); 12691 OM != OMEnd; ++OM) 12692 Diag(OM->Method->getLocation(), diag::note_final_overrider) 12693 << (const NamedDecl *)M->first << OM->Method->getParent(); 12694 12695 Record->setInvalidDecl(); 12696 } 12697 } 12698 CXXRecord->completeDefinition(&FinalOverriders); 12699 Completed = true; 12700 } 12701 } 12702 } 12703 } 12704 12705 if (!Completed) 12706 Record->completeDefinition(); 12707 12708 if (Record->hasAttrs()) { 12709 CheckAlignasUnderalignment(Record); 12710 12711 if (const MSInheritanceAttr *IA = Record->getAttr<MSInheritanceAttr>()) 12712 checkMSInheritanceAttrOnDefinition(cast<CXXRecordDecl>(Record), 12713 IA->getRange(), IA->getBestCase(), 12714 IA->getSemanticSpelling()); 12715 } 12716 12717 // Check if the structure/union declaration is a type that can have zero 12718 // size in C. For C this is a language extension, for C++ it may cause 12719 // compatibility problems. 12720 bool CheckForZeroSize; 12721 if (!getLangOpts().CPlusPlus) { 12722 CheckForZeroSize = true; 12723 } else { 12724 // For C++ filter out types that cannot be referenced in C code. 12725 CXXRecordDecl *CXXRecord = cast<CXXRecordDecl>(Record); 12726 CheckForZeroSize = 12727 CXXRecord->getLexicalDeclContext()->isExternCContext() && 12728 !CXXRecord->isDependentType() && 12729 CXXRecord->isCLike(); 12730 } 12731 if (CheckForZeroSize) { 12732 bool ZeroSize = true; 12733 bool IsEmpty = true; 12734 unsigned NonBitFields = 0; 12735 for (RecordDecl::field_iterator I = Record->field_begin(), 12736 E = Record->field_end(); 12737 (NonBitFields == 0 || ZeroSize) && I != E; ++I) { 12738 IsEmpty = false; 12739 if (I->isUnnamedBitfield()) { 12740 if (I->getBitWidthValue(Context) > 0) 12741 ZeroSize = false; 12742 } else { 12743 ++NonBitFields; 12744 QualType FieldType = I->getType(); 12745 if (FieldType->isIncompleteType() || 12746 !Context.getTypeSizeInChars(FieldType).isZero()) 12747 ZeroSize = false; 12748 } 12749 } 12750 12751 // Empty structs are an extension in C (C99 6.7.2.1p7). They are 12752 // allowed in C++, but warn if its declaration is inside 12753 // extern "C" block. 12754 if (ZeroSize) { 12755 Diag(RecLoc, getLangOpts().CPlusPlus ? 12756 diag::warn_zero_size_struct_union_in_extern_c : 12757 diag::warn_zero_size_struct_union_compat) 12758 << IsEmpty << Record->isUnion() << (NonBitFields > 1); 12759 } 12760 12761 // Structs without named members are extension in C (C99 6.7.2.1p7), 12762 // but are accepted by GCC. 12763 if (NonBitFields == 0 && !getLangOpts().CPlusPlus) { 12764 Diag(RecLoc, IsEmpty ? diag::ext_empty_struct_union : 12765 diag::ext_no_named_members_in_struct_union) 12766 << Record->isUnion(); 12767 } 12768 } 12769 } else { 12770 ObjCIvarDecl **ClsFields = 12771 reinterpret_cast<ObjCIvarDecl**>(RecFields.data()); 12772 if (ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(EnclosingDecl)) { 12773 ID->setEndOfDefinitionLoc(RBrac); 12774 // Add ivar's to class's DeclContext. 12775 for (unsigned i = 0, e = RecFields.size(); i != e; ++i) { 12776 ClsFields[i]->setLexicalDeclContext(ID); 12777 ID->addDecl(ClsFields[i]); 12778 } 12779 // Must enforce the rule that ivars in the base classes may not be 12780 // duplicates. 12781 if (ID->getSuperClass()) 12782 DiagnoseDuplicateIvars(ID, ID->getSuperClass()); 12783 } else if (ObjCImplementationDecl *IMPDecl = 12784 dyn_cast<ObjCImplementationDecl>(EnclosingDecl)) { 12785 assert(IMPDecl && "ActOnFields - missing ObjCImplementationDecl"); 12786 for (unsigned I = 0, N = RecFields.size(); I != N; ++I) 12787 // Ivar declared in @implementation never belongs to the implementation. 12788 // Only it is in implementation's lexical context. 12789 ClsFields[I]->setLexicalDeclContext(IMPDecl); 12790 CheckImplementationIvars(IMPDecl, ClsFields, RecFields.size(), RBrac); 12791 IMPDecl->setIvarLBraceLoc(LBrac); 12792 IMPDecl->setIvarRBraceLoc(RBrac); 12793 } else if (ObjCCategoryDecl *CDecl = 12794 dyn_cast<ObjCCategoryDecl>(EnclosingDecl)) { 12795 // case of ivars in class extension; all other cases have been 12796 // reported as errors elsewhere. 12797 // FIXME. Class extension does not have a LocEnd field. 12798 // CDecl->setLocEnd(RBrac); 12799 // Add ivar's to class extension's DeclContext. 12800 // Diagnose redeclaration of private ivars. 12801 ObjCInterfaceDecl *IDecl = CDecl->getClassInterface(); 12802 for (unsigned i = 0, e = RecFields.size(); i != e; ++i) { 12803 if (IDecl) { 12804 if (const ObjCIvarDecl *ClsIvar = 12805 IDecl->getIvarDecl(ClsFields[i]->getIdentifier())) { 12806 Diag(ClsFields[i]->getLocation(), 12807 diag::err_duplicate_ivar_declaration); 12808 Diag(ClsIvar->getLocation(), diag::note_previous_definition); 12809 continue; 12810 } 12811 for (const auto *Ext : IDecl->known_extensions()) { 12812 if (const ObjCIvarDecl *ClsExtIvar 12813 = Ext->getIvarDecl(ClsFields[i]->getIdentifier())) { 12814 Diag(ClsFields[i]->getLocation(), 12815 diag::err_duplicate_ivar_declaration); 12816 Diag(ClsExtIvar->getLocation(), diag::note_previous_definition); 12817 continue; 12818 } 12819 } 12820 } 12821 ClsFields[i]->setLexicalDeclContext(CDecl); 12822 CDecl->addDecl(ClsFields[i]); 12823 } 12824 CDecl->setIvarLBraceLoc(LBrac); 12825 CDecl->setIvarRBraceLoc(RBrac); 12826 } 12827 } 12828 12829 if (Attr) 12830 ProcessDeclAttributeList(S, Record, Attr); 12831 } 12832 12833 /// \brief Determine whether the given integral value is representable within 12834 /// the given type T. 12835 static bool isRepresentableIntegerValue(ASTContext &Context, 12836 llvm::APSInt &Value, 12837 QualType T) { 12838 assert(T->isIntegralType(Context) && "Integral type required!"); 12839 unsigned BitWidth = Context.getIntWidth(T); 12840 12841 if (Value.isUnsigned() || Value.isNonNegative()) { 12842 if (T->isSignedIntegerOrEnumerationType()) 12843 --BitWidth; 12844 return Value.getActiveBits() <= BitWidth; 12845 } 12846 return Value.getMinSignedBits() <= BitWidth; 12847 } 12848 12849 // \brief Given an integral type, return the next larger integral type 12850 // (or a NULL type of no such type exists). 12851 static QualType getNextLargerIntegralType(ASTContext &Context, QualType T) { 12852 // FIXME: Int128/UInt128 support, which also needs to be introduced into 12853 // enum checking below. 12854 assert(T->isIntegralType(Context) && "Integral type required!"); 12855 const unsigned NumTypes = 4; 12856 QualType SignedIntegralTypes[NumTypes] = { 12857 Context.ShortTy, Context.IntTy, Context.LongTy, Context.LongLongTy 12858 }; 12859 QualType UnsignedIntegralTypes[NumTypes] = { 12860 Context.UnsignedShortTy, Context.UnsignedIntTy, Context.UnsignedLongTy, 12861 Context.UnsignedLongLongTy 12862 }; 12863 12864 unsigned BitWidth = Context.getTypeSize(T); 12865 QualType *Types = T->isSignedIntegerOrEnumerationType()? SignedIntegralTypes 12866 : UnsignedIntegralTypes; 12867 for (unsigned I = 0; I != NumTypes; ++I) 12868 if (Context.getTypeSize(Types[I]) > BitWidth) 12869 return Types[I]; 12870 12871 return QualType(); 12872 } 12873 12874 EnumConstantDecl *Sema::CheckEnumConstant(EnumDecl *Enum, 12875 EnumConstantDecl *LastEnumConst, 12876 SourceLocation IdLoc, 12877 IdentifierInfo *Id, 12878 Expr *Val) { 12879 unsigned IntWidth = Context.getTargetInfo().getIntWidth(); 12880 llvm::APSInt EnumVal(IntWidth); 12881 QualType EltTy; 12882 12883 if (Val && DiagnoseUnexpandedParameterPack(Val, UPPC_EnumeratorValue)) 12884 Val = nullptr; 12885 12886 if (Val) 12887 Val = DefaultLvalueConversion(Val).get(); 12888 12889 if (Val) { 12890 if (Enum->isDependentType() || Val->isTypeDependent()) 12891 EltTy = Context.DependentTy; 12892 else { 12893 SourceLocation ExpLoc; 12894 if (getLangOpts().CPlusPlus11 && Enum->isFixed() && 12895 !getLangOpts().MSVCCompat) { 12896 // C++11 [dcl.enum]p5: If the underlying type is fixed, [...] the 12897 // constant-expression in the enumerator-definition shall be a converted 12898 // constant expression of the underlying type. 12899 EltTy = Enum->getIntegerType(); 12900 ExprResult Converted = 12901 CheckConvertedConstantExpression(Val, EltTy, EnumVal, 12902 CCEK_Enumerator); 12903 if (Converted.isInvalid()) 12904 Val = nullptr; 12905 else 12906 Val = Converted.get(); 12907 } else if (!Val->isValueDependent() && 12908 !(Val = VerifyIntegerConstantExpression(Val, 12909 &EnumVal).get())) { 12910 // C99 6.7.2.2p2: Make sure we have an integer constant expression. 12911 } else { 12912 if (Enum->isFixed()) { 12913 EltTy = Enum->getIntegerType(); 12914 12915 // In Obj-C and Microsoft mode, require the enumeration value to be 12916 // representable in the underlying type of the enumeration. In C++11, 12917 // we perform a non-narrowing conversion as part of converted constant 12918 // expression checking. 12919 if (!isRepresentableIntegerValue(Context, EnumVal, EltTy)) { 12920 if (getLangOpts().MSVCCompat) { 12921 Diag(IdLoc, diag::ext_enumerator_too_large) << EltTy; 12922 Val = ImpCastExprToType(Val, EltTy, CK_IntegralCast).get(); 12923 } else 12924 Diag(IdLoc, diag::err_enumerator_too_large) << EltTy; 12925 } else 12926 Val = ImpCastExprToType(Val, EltTy, CK_IntegralCast).get(); 12927 } else if (getLangOpts().CPlusPlus) { 12928 // C++11 [dcl.enum]p5: 12929 // If the underlying type is not fixed, the type of each enumerator 12930 // is the type of its initializing value: 12931 // - If an initializer is specified for an enumerator, the 12932 // initializing value has the same type as the expression. 12933 EltTy = Val->getType(); 12934 } else { 12935 // C99 6.7.2.2p2: 12936 // The expression that defines the value of an enumeration constant 12937 // shall be an integer constant expression that has a value 12938 // representable as an int. 12939 12940 // Complain if the value is not representable in an int. 12941 if (!isRepresentableIntegerValue(Context, EnumVal, Context.IntTy)) 12942 Diag(IdLoc, diag::ext_enum_value_not_int) 12943 << EnumVal.toString(10) << Val->getSourceRange() 12944 << (EnumVal.isUnsigned() || EnumVal.isNonNegative()); 12945 else if (!Context.hasSameType(Val->getType(), Context.IntTy)) { 12946 // Force the type of the expression to 'int'. 12947 Val = ImpCastExprToType(Val, Context.IntTy, CK_IntegralCast).get(); 12948 } 12949 EltTy = Val->getType(); 12950 } 12951 } 12952 } 12953 } 12954 12955 if (!Val) { 12956 if (Enum->isDependentType()) 12957 EltTy = Context.DependentTy; 12958 else if (!LastEnumConst) { 12959 // C++0x [dcl.enum]p5: 12960 // If the underlying type is not fixed, the type of each enumerator 12961 // is the type of its initializing value: 12962 // - If no initializer is specified for the first enumerator, the 12963 // initializing value has an unspecified integral type. 12964 // 12965 // GCC uses 'int' for its unspecified integral type, as does 12966 // C99 6.7.2.2p3. 12967 if (Enum->isFixed()) { 12968 EltTy = Enum->getIntegerType(); 12969 } 12970 else { 12971 EltTy = Context.IntTy; 12972 } 12973 } else { 12974 // Assign the last value + 1. 12975 EnumVal = LastEnumConst->getInitVal(); 12976 ++EnumVal; 12977 EltTy = LastEnumConst->getType(); 12978 12979 // Check for overflow on increment. 12980 if (EnumVal < LastEnumConst->getInitVal()) { 12981 // C++0x [dcl.enum]p5: 12982 // If the underlying type is not fixed, the type of each enumerator 12983 // is the type of its initializing value: 12984 // 12985 // - Otherwise the type of the initializing value is the same as 12986 // the type of the initializing value of the preceding enumerator 12987 // unless the incremented value is not representable in that type, 12988 // in which case the type is an unspecified integral type 12989 // sufficient to contain the incremented value. If no such type 12990 // exists, the program is ill-formed. 12991 QualType T = getNextLargerIntegralType(Context, EltTy); 12992 if (T.isNull() || Enum->isFixed()) { 12993 // There is no integral type larger enough to represent this 12994 // value. Complain, then allow the value to wrap around. 12995 EnumVal = LastEnumConst->getInitVal(); 12996 EnumVal = EnumVal.zext(EnumVal.getBitWidth() * 2); 12997 ++EnumVal; 12998 if (Enum->isFixed()) 12999 // When the underlying type is fixed, this is ill-formed. 13000 Diag(IdLoc, diag::err_enumerator_wrapped) 13001 << EnumVal.toString(10) 13002 << EltTy; 13003 else 13004 Diag(IdLoc, diag::ext_enumerator_increment_too_large) 13005 << EnumVal.toString(10); 13006 } else { 13007 EltTy = T; 13008 } 13009 13010 // Retrieve the last enumerator's value, extent that type to the 13011 // type that is supposed to be large enough to represent the incremented 13012 // value, then increment. 13013 EnumVal = LastEnumConst->getInitVal(); 13014 EnumVal.setIsSigned(EltTy->isSignedIntegerOrEnumerationType()); 13015 EnumVal = EnumVal.zextOrTrunc(Context.getIntWidth(EltTy)); 13016 ++EnumVal; 13017 13018 // If we're not in C++, diagnose the overflow of enumerator values, 13019 // which in C99 means that the enumerator value is not representable in 13020 // an int (C99 6.7.2.2p2). However, we support GCC's extension that 13021 // permits enumerator values that are representable in some larger 13022 // integral type. 13023 if (!getLangOpts().CPlusPlus && !T.isNull()) 13024 Diag(IdLoc, diag::warn_enum_value_overflow); 13025 } else if (!getLangOpts().CPlusPlus && 13026 !isRepresentableIntegerValue(Context, EnumVal, EltTy)) { 13027 // Enforce C99 6.7.2.2p2 even when we compute the next value. 13028 Diag(IdLoc, diag::ext_enum_value_not_int) 13029 << EnumVal.toString(10) << 1; 13030 } 13031 } 13032 } 13033 13034 if (!EltTy->isDependentType()) { 13035 // Make the enumerator value match the signedness and size of the 13036 // enumerator's type. 13037 EnumVal = EnumVal.extOrTrunc(Context.getIntWidth(EltTy)); 13038 EnumVal.setIsSigned(EltTy->isSignedIntegerOrEnumerationType()); 13039 } 13040 13041 return EnumConstantDecl::Create(Context, Enum, IdLoc, Id, EltTy, 13042 Val, EnumVal); 13043 } 13044 13045 13046 Decl *Sema::ActOnEnumConstant(Scope *S, Decl *theEnumDecl, Decl *lastEnumConst, 13047 SourceLocation IdLoc, IdentifierInfo *Id, 13048 AttributeList *Attr, 13049 SourceLocation EqualLoc, Expr *Val) { 13050 EnumDecl *TheEnumDecl = cast<EnumDecl>(theEnumDecl); 13051 EnumConstantDecl *LastEnumConst = 13052 cast_or_null<EnumConstantDecl>(lastEnumConst); 13053 13054 // The scope passed in may not be a decl scope. Zip up the scope tree until 13055 // we find one that is. 13056 S = getNonFieldDeclScope(S); 13057 13058 // Verify that there isn't already something declared with this name in this 13059 // scope. 13060 NamedDecl *PrevDecl = LookupSingleName(S, Id, IdLoc, LookupOrdinaryName, 13061 ForRedeclaration); 13062 if (PrevDecl && PrevDecl->isTemplateParameter()) { 13063 // Maybe we will complain about the shadowed template parameter. 13064 DiagnoseTemplateParameterShadow(IdLoc, PrevDecl); 13065 // Just pretend that we didn't see the previous declaration. 13066 PrevDecl = nullptr; 13067 } 13068 13069 if (PrevDecl) { 13070 // When in C++, we may get a TagDecl with the same name; in this case the 13071 // enum constant will 'hide' the tag. 13072 assert((getLangOpts().CPlusPlus || !isa<TagDecl>(PrevDecl)) && 13073 "Received TagDecl when not in C++!"); 13074 if (!isa<TagDecl>(PrevDecl) && isDeclInScope(PrevDecl, CurContext, S)) { 13075 if (isa<EnumConstantDecl>(PrevDecl)) 13076 Diag(IdLoc, diag::err_redefinition_of_enumerator) << Id; 13077 else 13078 Diag(IdLoc, diag::err_redefinition) << Id; 13079 Diag(PrevDecl->getLocation(), diag::note_previous_definition); 13080 return nullptr; 13081 } 13082 } 13083 13084 // C++ [class.mem]p15: 13085 // If T is the name of a class, then each of the following shall have a name 13086 // different from T: 13087 // - every enumerator of every member of class T that is an unscoped 13088 // enumerated type 13089 if (CXXRecordDecl *Record 13090 = dyn_cast<CXXRecordDecl>( 13091 TheEnumDecl->getDeclContext()->getRedeclContext())) 13092 if (!TheEnumDecl->isScoped() && 13093 Record->getIdentifier() && Record->getIdentifier() == Id) 13094 Diag(IdLoc, diag::err_member_name_of_class) << Id; 13095 13096 EnumConstantDecl *New = 13097 CheckEnumConstant(TheEnumDecl, LastEnumConst, IdLoc, Id, Val); 13098 13099 if (New) { 13100 // Process attributes. 13101 if (Attr) ProcessDeclAttributeList(S, New, Attr); 13102 13103 // Register this decl in the current scope stack. 13104 New->setAccess(TheEnumDecl->getAccess()); 13105 PushOnScopeChains(New, S); 13106 } 13107 13108 ActOnDocumentableDecl(New); 13109 13110 return New; 13111 } 13112 13113 // Returns true when the enum initial expression does not trigger the 13114 // duplicate enum warning. A few common cases are exempted as follows: 13115 // Element2 = Element1 13116 // Element2 = Element1 + 1 13117 // Element2 = Element1 - 1 13118 // Where Element2 and Element1 are from the same enum. 13119 static bool ValidDuplicateEnum(EnumConstantDecl *ECD, EnumDecl *Enum) { 13120 Expr *InitExpr = ECD->getInitExpr(); 13121 if (!InitExpr) 13122 return true; 13123 InitExpr = InitExpr->IgnoreImpCasts(); 13124 13125 if (BinaryOperator *BO = dyn_cast<BinaryOperator>(InitExpr)) { 13126 if (!BO->isAdditiveOp()) 13127 return true; 13128 IntegerLiteral *IL = dyn_cast<IntegerLiteral>(BO->getRHS()); 13129 if (!IL) 13130 return true; 13131 if (IL->getValue() != 1) 13132 return true; 13133 13134 InitExpr = BO->getLHS(); 13135 } 13136 13137 // This checks if the elements are from the same enum. 13138 DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(InitExpr); 13139 if (!DRE) 13140 return true; 13141 13142 EnumConstantDecl *EnumConstant = dyn_cast<EnumConstantDecl>(DRE->getDecl()); 13143 if (!EnumConstant) 13144 return true; 13145 13146 if (cast<EnumDecl>(TagDecl::castFromDeclContext(ECD->getDeclContext())) != 13147 Enum) 13148 return true; 13149 13150 return false; 13151 } 13152 13153 struct DupKey { 13154 int64_t val; 13155 bool isTombstoneOrEmptyKey; 13156 DupKey(int64_t val, bool isTombstoneOrEmptyKey) 13157 : val(val), isTombstoneOrEmptyKey(isTombstoneOrEmptyKey) {} 13158 }; 13159 13160 static DupKey GetDupKey(const llvm::APSInt& Val) { 13161 return DupKey(Val.isSigned() ? Val.getSExtValue() : Val.getZExtValue(), 13162 false); 13163 } 13164 13165 struct DenseMapInfoDupKey { 13166 static DupKey getEmptyKey() { return DupKey(0, true); } 13167 static DupKey getTombstoneKey() { return DupKey(1, true); } 13168 static unsigned getHashValue(const DupKey Key) { 13169 return (unsigned)(Key.val * 37); 13170 } 13171 static bool isEqual(const DupKey& LHS, const DupKey& RHS) { 13172 return LHS.isTombstoneOrEmptyKey == RHS.isTombstoneOrEmptyKey && 13173 LHS.val == RHS.val; 13174 } 13175 }; 13176 13177 // Emits a warning when an element is implicitly set a value that 13178 // a previous element has already been set to. 13179 static void CheckForDuplicateEnumValues(Sema &S, ArrayRef<Decl *> Elements, 13180 EnumDecl *Enum, 13181 QualType EnumType) { 13182 if (S.Diags.isIgnored(diag::warn_duplicate_enum_values, Enum->getLocation())) 13183 return; 13184 // Avoid anonymous enums 13185 if (!Enum->getIdentifier()) 13186 return; 13187 13188 // Only check for small enums. 13189 if (Enum->getNumPositiveBits() > 63 || Enum->getNumNegativeBits() > 64) 13190 return; 13191 13192 typedef SmallVector<EnumConstantDecl *, 3> ECDVector; 13193 typedef SmallVector<ECDVector *, 3> DuplicatesVector; 13194 13195 typedef llvm::PointerUnion<EnumConstantDecl*, ECDVector*> DeclOrVector; 13196 typedef llvm::DenseMap<DupKey, DeclOrVector, DenseMapInfoDupKey> 13197 ValueToVectorMap; 13198 13199 DuplicatesVector DupVector; 13200 ValueToVectorMap EnumMap; 13201 13202 // Populate the EnumMap with all values represented by enum constants without 13203 // an initialier. 13204 for (unsigned i = 0, e = Elements.size(); i != e; ++i) { 13205 EnumConstantDecl *ECD = cast_or_null<EnumConstantDecl>(Elements[i]); 13206 13207 // Null EnumConstantDecl means a previous diagnostic has been emitted for 13208 // this constant. Skip this enum since it may be ill-formed. 13209 if (!ECD) { 13210 return; 13211 } 13212 13213 if (ECD->getInitExpr()) 13214 continue; 13215 13216 DupKey Key = GetDupKey(ECD->getInitVal()); 13217 DeclOrVector &Entry = EnumMap[Key]; 13218 13219 // First time encountering this value. 13220 if (Entry.isNull()) 13221 Entry = ECD; 13222 } 13223 13224 // Create vectors for any values that has duplicates. 13225 for (unsigned i = 0, e = Elements.size(); i != e; ++i) { 13226 EnumConstantDecl *ECD = cast<EnumConstantDecl>(Elements[i]); 13227 if (!ValidDuplicateEnum(ECD, Enum)) 13228 continue; 13229 13230 DupKey Key = GetDupKey(ECD->getInitVal()); 13231 13232 DeclOrVector& Entry = EnumMap[Key]; 13233 if (Entry.isNull()) 13234 continue; 13235 13236 if (EnumConstantDecl *D = Entry.dyn_cast<EnumConstantDecl*>()) { 13237 // Ensure constants are different. 13238 if (D == ECD) 13239 continue; 13240 13241 // Create new vector and push values onto it. 13242 ECDVector *Vec = new ECDVector(); 13243 Vec->push_back(D); 13244 Vec->push_back(ECD); 13245 13246 // Update entry to point to the duplicates vector. 13247 Entry = Vec; 13248 13249 // Store the vector somewhere we can consult later for quick emission of 13250 // diagnostics. 13251 DupVector.push_back(Vec); 13252 continue; 13253 } 13254 13255 ECDVector *Vec = Entry.get<ECDVector*>(); 13256 // Make sure constants are not added more than once. 13257 if (*Vec->begin() == ECD) 13258 continue; 13259 13260 Vec->push_back(ECD); 13261 } 13262 13263 // Emit diagnostics. 13264 for (DuplicatesVector::iterator DupVectorIter = DupVector.begin(), 13265 DupVectorEnd = DupVector.end(); 13266 DupVectorIter != DupVectorEnd; ++DupVectorIter) { 13267 ECDVector *Vec = *DupVectorIter; 13268 assert(Vec->size() > 1 && "ECDVector should have at least 2 elements."); 13269 13270 // Emit warning for one enum constant. 13271 ECDVector::iterator I = Vec->begin(); 13272 S.Diag((*I)->getLocation(), diag::warn_duplicate_enum_values) 13273 << (*I)->getName() << (*I)->getInitVal().toString(10) 13274 << (*I)->getSourceRange(); 13275 ++I; 13276 13277 // Emit one note for each of the remaining enum constants with 13278 // the same value. 13279 for (ECDVector::iterator E = Vec->end(); I != E; ++I) 13280 S.Diag((*I)->getLocation(), diag::note_duplicate_element) 13281 << (*I)->getName() << (*I)->getInitVal().toString(10) 13282 << (*I)->getSourceRange(); 13283 delete Vec; 13284 } 13285 } 13286 13287 void Sema::ActOnEnumBody(SourceLocation EnumLoc, SourceLocation LBraceLoc, 13288 SourceLocation RBraceLoc, Decl *EnumDeclX, 13289 ArrayRef<Decl *> Elements, 13290 Scope *S, AttributeList *Attr) { 13291 EnumDecl *Enum = cast<EnumDecl>(EnumDeclX); 13292 QualType EnumType = Context.getTypeDeclType(Enum); 13293 13294 if (Attr) 13295 ProcessDeclAttributeList(S, Enum, Attr); 13296 13297 if (Enum->isDependentType()) { 13298 for (unsigned i = 0, e = Elements.size(); i != e; ++i) { 13299 EnumConstantDecl *ECD = 13300 cast_or_null<EnumConstantDecl>(Elements[i]); 13301 if (!ECD) continue; 13302 13303 ECD->setType(EnumType); 13304 } 13305 13306 Enum->completeDefinition(Context.DependentTy, Context.DependentTy, 0, 0); 13307 return; 13308 } 13309 13310 // TODO: If the result value doesn't fit in an int, it must be a long or long 13311 // long value. ISO C does not support this, but GCC does as an extension, 13312 // emit a warning. 13313 unsigned IntWidth = Context.getTargetInfo().getIntWidth(); 13314 unsigned CharWidth = Context.getTargetInfo().getCharWidth(); 13315 unsigned ShortWidth = Context.getTargetInfo().getShortWidth(); 13316 13317 // Verify that all the values are okay, compute the size of the values, and 13318 // reverse the list. 13319 unsigned NumNegativeBits = 0; 13320 unsigned NumPositiveBits = 0; 13321 13322 // Keep track of whether all elements have type int. 13323 bool AllElementsInt = true; 13324 13325 for (unsigned i = 0, e = Elements.size(); i != e; ++i) { 13326 EnumConstantDecl *ECD = 13327 cast_or_null<EnumConstantDecl>(Elements[i]); 13328 if (!ECD) continue; // Already issued a diagnostic. 13329 13330 const llvm::APSInt &InitVal = ECD->getInitVal(); 13331 13332 // Keep track of the size of positive and negative values. 13333 if (InitVal.isUnsigned() || InitVal.isNonNegative()) 13334 NumPositiveBits = std::max(NumPositiveBits, 13335 (unsigned)InitVal.getActiveBits()); 13336 else 13337 NumNegativeBits = std::max(NumNegativeBits, 13338 (unsigned)InitVal.getMinSignedBits()); 13339 13340 // Keep track of whether every enum element has type int (very commmon). 13341 if (AllElementsInt) 13342 AllElementsInt = ECD->getType() == Context.IntTy; 13343 } 13344 13345 // Figure out the type that should be used for this enum. 13346 QualType BestType; 13347 unsigned BestWidth; 13348 13349 // C++0x N3000 [conv.prom]p3: 13350 // An rvalue of an unscoped enumeration type whose underlying 13351 // type is not fixed can be converted to an rvalue of the first 13352 // of the following types that can represent all the values of 13353 // the enumeration: int, unsigned int, long int, unsigned long 13354 // int, long long int, or unsigned long long int. 13355 // C99 6.4.4.3p2: 13356 // An identifier declared as an enumeration constant has type int. 13357 // The C99 rule is modified by a gcc extension 13358 QualType BestPromotionType; 13359 13360 bool Packed = Enum->hasAttr<PackedAttr>(); 13361 // -fshort-enums is the equivalent to specifying the packed attribute on all 13362 // enum definitions. 13363 if (LangOpts.ShortEnums) 13364 Packed = true; 13365 13366 if (Enum->isFixed()) { 13367 BestType = Enum->getIntegerType(); 13368 if (BestType->isPromotableIntegerType()) 13369 BestPromotionType = Context.getPromotedIntegerType(BestType); 13370 else 13371 BestPromotionType = BestType; 13372 // We don't need to set BestWidth, because BestType is going to be the type 13373 // of the enumerators, but we do anyway because otherwise some compilers 13374 // warn that it might be used uninitialized. 13375 BestWidth = CharWidth; 13376 } 13377 else if (NumNegativeBits) { 13378 // If there is a negative value, figure out the smallest integer type (of 13379 // int/long/longlong) that fits. 13380 // If it's packed, check also if it fits a char or a short. 13381 if (Packed && NumNegativeBits <= CharWidth && NumPositiveBits < CharWidth) { 13382 BestType = Context.SignedCharTy; 13383 BestWidth = CharWidth; 13384 } else if (Packed && NumNegativeBits <= ShortWidth && 13385 NumPositiveBits < ShortWidth) { 13386 BestType = Context.ShortTy; 13387 BestWidth = ShortWidth; 13388 } else if (NumNegativeBits <= IntWidth && NumPositiveBits < IntWidth) { 13389 BestType = Context.IntTy; 13390 BestWidth = IntWidth; 13391 } else { 13392 BestWidth = Context.getTargetInfo().getLongWidth(); 13393 13394 if (NumNegativeBits <= BestWidth && NumPositiveBits < BestWidth) { 13395 BestType = Context.LongTy; 13396 } else { 13397 BestWidth = Context.getTargetInfo().getLongLongWidth(); 13398 13399 if (NumNegativeBits > BestWidth || NumPositiveBits >= BestWidth) 13400 Diag(Enum->getLocation(), diag::ext_enum_too_large); 13401 BestType = Context.LongLongTy; 13402 } 13403 } 13404 BestPromotionType = (BestWidth <= IntWidth ? Context.IntTy : BestType); 13405 } else { 13406 // If there is no negative value, figure out the smallest type that fits 13407 // all of the enumerator values. 13408 // If it's packed, check also if it fits a char or a short. 13409 if (Packed && NumPositiveBits <= CharWidth) { 13410 BestType = Context.UnsignedCharTy; 13411 BestPromotionType = Context.IntTy; 13412 BestWidth = CharWidth; 13413 } else if (Packed && NumPositiveBits <= ShortWidth) { 13414 BestType = Context.UnsignedShortTy; 13415 BestPromotionType = Context.IntTy; 13416 BestWidth = ShortWidth; 13417 } else if (NumPositiveBits <= IntWidth) { 13418 BestType = Context.UnsignedIntTy; 13419 BestWidth = IntWidth; 13420 BestPromotionType 13421 = (NumPositiveBits == BestWidth || !getLangOpts().CPlusPlus) 13422 ? Context.UnsignedIntTy : Context.IntTy; 13423 } else if (NumPositiveBits <= 13424 (BestWidth = Context.getTargetInfo().getLongWidth())) { 13425 BestType = Context.UnsignedLongTy; 13426 BestPromotionType 13427 = (NumPositiveBits == BestWidth || !getLangOpts().CPlusPlus) 13428 ? Context.UnsignedLongTy : Context.LongTy; 13429 } else { 13430 BestWidth = Context.getTargetInfo().getLongLongWidth(); 13431 assert(NumPositiveBits <= BestWidth && 13432 "How could an initializer get larger than ULL?"); 13433 BestType = Context.UnsignedLongLongTy; 13434 BestPromotionType 13435 = (NumPositiveBits == BestWidth || !getLangOpts().CPlusPlus) 13436 ? Context.UnsignedLongLongTy : Context.LongLongTy; 13437 } 13438 } 13439 13440 // Loop over all of the enumerator constants, changing their types to match 13441 // the type of the enum if needed. 13442 for (unsigned i = 0, e = Elements.size(); i != e; ++i) { 13443 EnumConstantDecl *ECD = cast_or_null<EnumConstantDecl>(Elements[i]); 13444 if (!ECD) continue; // Already issued a diagnostic. 13445 13446 // Standard C says the enumerators have int type, but we allow, as an 13447 // extension, the enumerators to be larger than int size. If each 13448 // enumerator value fits in an int, type it as an int, otherwise type it the 13449 // same as the enumerator decl itself. This means that in "enum { X = 1U }" 13450 // that X has type 'int', not 'unsigned'. 13451 13452 // Determine whether the value fits into an int. 13453 llvm::APSInt InitVal = ECD->getInitVal(); 13454 13455 // If it fits into an integer type, force it. Otherwise force it to match 13456 // the enum decl type. 13457 QualType NewTy; 13458 unsigned NewWidth; 13459 bool NewSign; 13460 if (!getLangOpts().CPlusPlus && 13461 !Enum->isFixed() && 13462 isRepresentableIntegerValue(Context, InitVal, Context.IntTy)) { 13463 NewTy = Context.IntTy; 13464 NewWidth = IntWidth; 13465 NewSign = true; 13466 } else if (ECD->getType() == BestType) { 13467 // Already the right type! 13468 if (getLangOpts().CPlusPlus) 13469 // C++ [dcl.enum]p4: Following the closing brace of an 13470 // enum-specifier, each enumerator has the type of its 13471 // enumeration. 13472 ECD->setType(EnumType); 13473 continue; 13474 } else { 13475 NewTy = BestType; 13476 NewWidth = BestWidth; 13477 NewSign = BestType->isSignedIntegerOrEnumerationType(); 13478 } 13479 13480 // Adjust the APSInt value. 13481 InitVal = InitVal.extOrTrunc(NewWidth); 13482 InitVal.setIsSigned(NewSign); 13483 ECD->setInitVal(InitVal); 13484 13485 // Adjust the Expr initializer and type. 13486 if (ECD->getInitExpr() && 13487 !Context.hasSameType(NewTy, ECD->getInitExpr()->getType())) 13488 ECD->setInitExpr(ImplicitCastExpr::Create(Context, NewTy, 13489 CK_IntegralCast, 13490 ECD->getInitExpr(), 13491 /*base paths*/ nullptr, 13492 VK_RValue)); 13493 if (getLangOpts().CPlusPlus) 13494 // C++ [dcl.enum]p4: Following the closing brace of an 13495 // enum-specifier, each enumerator has the type of its 13496 // enumeration. 13497 ECD->setType(EnumType); 13498 else 13499 ECD->setType(NewTy); 13500 } 13501 13502 Enum->completeDefinition(BestType, BestPromotionType, 13503 NumPositiveBits, NumNegativeBits); 13504 13505 CheckForDuplicateEnumValues(*this, Elements, Enum, EnumType); 13506 13507 // Now that the enum type is defined, ensure it's not been underaligned. 13508 if (Enum->hasAttrs()) 13509 CheckAlignasUnderalignment(Enum); 13510 } 13511 13512 Decl *Sema::ActOnFileScopeAsmDecl(Expr *expr, 13513 SourceLocation StartLoc, 13514 SourceLocation EndLoc) { 13515 StringLiteral *AsmString = cast<StringLiteral>(expr); 13516 13517 FileScopeAsmDecl *New = FileScopeAsmDecl::Create(Context, CurContext, 13518 AsmString, StartLoc, 13519 EndLoc); 13520 CurContext->addDecl(New); 13521 return New; 13522 } 13523 13524 static void checkModuleImportContext(Sema &S, Module *M, 13525 SourceLocation ImportLoc, 13526 DeclContext *DC) { 13527 if (auto *LSD = dyn_cast<LinkageSpecDecl>(DC)) { 13528 switch (LSD->getLanguage()) { 13529 case LinkageSpecDecl::lang_c: 13530 if (!M->IsExternC) { 13531 S.Diag(ImportLoc, diag::err_module_import_in_extern_c) 13532 << M->getFullModuleName(); 13533 S.Diag(LSD->getLocStart(), diag::note_module_import_in_extern_c); 13534 return; 13535 } 13536 break; 13537 case LinkageSpecDecl::lang_cxx: 13538 break; 13539 } 13540 DC = LSD->getParent(); 13541 } 13542 13543 while (isa<LinkageSpecDecl>(DC)) 13544 DC = DC->getParent(); 13545 if (!isa<TranslationUnitDecl>(DC)) { 13546 S.Diag(ImportLoc, diag::err_module_import_not_at_top_level) 13547 << M->getFullModuleName() << DC; 13548 S.Diag(cast<Decl>(DC)->getLocStart(), 13549 diag::note_module_import_not_at_top_level) 13550 << DC; 13551 } 13552 } 13553 13554 DeclResult Sema::ActOnModuleImport(SourceLocation AtLoc, 13555 SourceLocation ImportLoc, 13556 ModuleIdPath Path) { 13557 Module *Mod = 13558 getModuleLoader().loadModule(ImportLoc, Path, Module::AllVisible, 13559 /*IsIncludeDirective=*/false); 13560 if (!Mod) 13561 return true; 13562 13563 checkModuleImportContext(*this, Mod, ImportLoc, CurContext); 13564 13565 // FIXME: we should support importing a submodule within a different submodule 13566 // of the same top-level module. Until we do, make it an error rather than 13567 // silently ignoring the import. 13568 if (Mod->getTopLevelModuleName() == getLangOpts().CurrentModule) 13569 Diag(ImportLoc, diag::err_module_self_import) 13570 << Mod->getFullModuleName() << getLangOpts().CurrentModule; 13571 else if (Mod->getTopLevelModuleName() == getLangOpts().ImplementationOfModule) 13572 Diag(ImportLoc, diag::err_module_import_in_implementation) 13573 << Mod->getFullModuleName() << getLangOpts().ImplementationOfModule; 13574 13575 SmallVector<SourceLocation, 2> IdentifierLocs; 13576 Module *ModCheck = Mod; 13577 for (unsigned I = 0, N = Path.size(); I != N; ++I) { 13578 // If we've run out of module parents, just drop the remaining identifiers. 13579 // We need the length to be consistent. 13580 if (!ModCheck) 13581 break; 13582 ModCheck = ModCheck->Parent; 13583 13584 IdentifierLocs.push_back(Path[I].second); 13585 } 13586 13587 ImportDecl *Import = ImportDecl::Create(Context, 13588 Context.getTranslationUnitDecl(), 13589 AtLoc.isValid()? AtLoc : ImportLoc, 13590 Mod, IdentifierLocs); 13591 Context.getTranslationUnitDecl()->addDecl(Import); 13592 return Import; 13593 } 13594 13595 void Sema::ActOnModuleInclude(SourceLocation DirectiveLoc, Module *Mod) { 13596 checkModuleImportContext(*this, Mod, DirectiveLoc, CurContext); 13597 13598 // FIXME: Should we synthesize an ImportDecl here? 13599 getModuleLoader().makeModuleVisible(Mod, Module::AllVisible, DirectiveLoc, 13600 /*Complain=*/true); 13601 } 13602 13603 void Sema::createImplicitModuleImportForErrorRecovery(SourceLocation Loc, 13604 Module *Mod) { 13605 // Bail if we're not allowed to implicitly import a module here. 13606 if (isSFINAEContext() || !getLangOpts().ModulesErrorRecovery) 13607 return; 13608 13609 // Create the implicit import declaration. 13610 TranslationUnitDecl *TU = getASTContext().getTranslationUnitDecl(); 13611 ImportDecl *ImportD = ImportDecl::CreateImplicit(getASTContext(), TU, 13612 Loc, Mod, Loc); 13613 TU->addDecl(ImportD); 13614 Consumer.HandleImplicitImportDecl(ImportD); 13615 13616 // Make the module visible. 13617 getModuleLoader().makeModuleVisible(Mod, Module::AllVisible, Loc, 13618 /*Complain=*/false); 13619 } 13620 13621 void Sema::ActOnPragmaRedefineExtname(IdentifierInfo* Name, 13622 IdentifierInfo* AliasName, 13623 SourceLocation PragmaLoc, 13624 SourceLocation NameLoc, 13625 SourceLocation AliasNameLoc) { 13626 Decl *PrevDecl = LookupSingleName(TUScope, Name, NameLoc, 13627 LookupOrdinaryName); 13628 AsmLabelAttr *Attr = ::new (Context) AsmLabelAttr(AliasNameLoc, Context, 13629 AliasName->getName(), 0); 13630 13631 if (PrevDecl) 13632 PrevDecl->addAttr(Attr); 13633 else 13634 (void)ExtnameUndeclaredIdentifiers.insert( 13635 std::pair<IdentifierInfo*,AsmLabelAttr*>(Name, Attr)); 13636 } 13637 13638 void Sema::ActOnPragmaWeakID(IdentifierInfo* Name, 13639 SourceLocation PragmaLoc, 13640 SourceLocation NameLoc) { 13641 Decl *PrevDecl = LookupSingleName(TUScope, Name, NameLoc, LookupOrdinaryName); 13642 13643 if (PrevDecl) { 13644 PrevDecl->addAttr(WeakAttr::CreateImplicit(Context, PragmaLoc)); 13645 } else { 13646 (void)WeakUndeclaredIdentifiers.insert( 13647 std::pair<IdentifierInfo*,WeakInfo> 13648 (Name, WeakInfo((IdentifierInfo*)nullptr, NameLoc))); 13649 } 13650 } 13651 13652 void Sema::ActOnPragmaWeakAlias(IdentifierInfo* Name, 13653 IdentifierInfo* AliasName, 13654 SourceLocation PragmaLoc, 13655 SourceLocation NameLoc, 13656 SourceLocation AliasNameLoc) { 13657 Decl *PrevDecl = LookupSingleName(TUScope, AliasName, AliasNameLoc, 13658 LookupOrdinaryName); 13659 WeakInfo W = WeakInfo(Name, NameLoc); 13660 13661 if (PrevDecl) { 13662 if (!PrevDecl->hasAttr<AliasAttr>()) 13663 if (NamedDecl *ND = dyn_cast<NamedDecl>(PrevDecl)) 13664 DeclApplyPragmaWeak(TUScope, ND, W); 13665 } else { 13666 (void)WeakUndeclaredIdentifiers.insert( 13667 std::pair<IdentifierInfo*,WeakInfo>(AliasName, W)); 13668 } 13669 } 13670 13671 Decl *Sema::getObjCDeclContext() const { 13672 return (dyn_cast_or_null<ObjCContainerDecl>(CurContext)); 13673 } 13674 13675 AvailabilityResult Sema::getCurContextAvailability() const { 13676 const Decl *D = cast<Decl>(getCurObjCLexicalContext()); 13677 // If we are within an Objective-C method, we should consult 13678 // both the availability of the method as well as the 13679 // enclosing class. If the class is (say) deprecated, 13680 // the entire method is considered deprecated from the 13681 // purpose of checking if the current context is deprecated. 13682 if (const ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D)) { 13683 AvailabilityResult R = MD->getAvailability(); 13684 if (R != AR_Available) 13685 return R; 13686 D = MD->getClassInterface(); 13687 } 13688 // If we are within an Objective-c @implementation, it 13689 // gets the same availability context as the @interface. 13690 else if (const ObjCImplementationDecl *ID = 13691 dyn_cast<ObjCImplementationDecl>(D)) { 13692 D = ID->getClassInterface(); 13693 } 13694 // Recover from user error. 13695 return D ? D->getAvailability() : AR_Available; 13696 } 13697