SemaDecl.cpp revision 04fa7a33279808dc3e5117c41b5f84c40eeb7362
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/PartialDiagnostic.h" 29#include "clang/Basic/SourceManager.h" 30#include "clang/Basic/TargetInfo.h" 31#include "clang/Lex/HeaderSearch.h" // FIXME: Sema shouldn't depend on Lex 32#include "clang/Lex/ModuleLoader.h" // FIXME: Sema shouldn't depend on Lex 33#include "clang/Lex/Preprocessor.h" // FIXME: Sema shouldn't depend on Lex 34#include "clang/Parse/ParseDiagnostic.h" 35#include "clang/Sema/CXXFieldCollector.h" 36#include "clang/Sema/DeclSpec.h" 37#include "clang/Sema/DelayedDiagnostic.h" 38#include "clang/Sema/Initialization.h" 39#include "clang/Sema/Lookup.h" 40#include "clang/Sema/ParsedTemplate.h" 41#include "clang/Sema/Scope.h" 42#include "clang/Sema/ScopeInfo.h" 43#include "llvm/ADT/SmallString.h" 44#include "llvm/ADT/Triple.h" 45#include <algorithm> 46#include <cstring> 47#include <functional> 48using namespace clang; 49using namespace sema; 50 51Sema::DeclGroupPtrTy Sema::ConvertDeclToDeclGroup(Decl *Ptr, Decl *OwnedType) { 52 if (OwnedType) { 53 Decl *Group[2] = { OwnedType, Ptr }; 54 return DeclGroupPtrTy::make(DeclGroupRef::Create(Context, Group, 2)); 55 } 56 57 return DeclGroupPtrTy::make(DeclGroupRef(Ptr)); 58} 59 60namespace { 61 62class TypeNameValidatorCCC : public CorrectionCandidateCallback { 63 public: 64 TypeNameValidatorCCC(bool AllowInvalid, bool WantClass=false) 65 : AllowInvalidDecl(AllowInvalid), WantClassName(WantClass) { 66 WantExpressionKeywords = false; 67 WantCXXNamedCasts = false; 68 WantRemainingKeywords = false; 69 } 70 71 virtual bool ValidateCandidate(const TypoCorrection &candidate) { 72 if (NamedDecl *ND = candidate.getCorrectionDecl()) 73 return (isa<TypeDecl>(ND) || isa<ObjCInterfaceDecl>(ND)) && 74 (AllowInvalidDecl || !ND->isInvalidDecl()); 75 else 76 return !WantClassName && candidate.isKeyword(); 77 } 78 79 private: 80 bool AllowInvalidDecl; 81 bool WantClassName; 82}; 83 84} 85 86/// \brief Determine whether the token kind starts a simple-type-specifier. 87bool Sema::isSimpleTypeSpecifier(tok::TokenKind Kind) const { 88 switch (Kind) { 89 // FIXME: Take into account the current language when deciding whether a 90 // token kind is a valid type specifier 91 case tok::kw_short: 92 case tok::kw_long: 93 case tok::kw___int64: 94 case tok::kw___int128: 95 case tok::kw_signed: 96 case tok::kw_unsigned: 97 case tok::kw_void: 98 case tok::kw_char: 99 case tok::kw_int: 100 case tok::kw_half: 101 case tok::kw_float: 102 case tok::kw_double: 103 case tok::kw_wchar_t: 104 case tok::kw_bool: 105 case tok::kw___underlying_type: 106 return true; 107 108 case tok::annot_typename: 109 case tok::kw_char16_t: 110 case tok::kw_char32_t: 111 case tok::kw_typeof: 112 case tok::annot_decltype: 113 case tok::kw_decltype: 114 return getLangOpts().CPlusPlus; 115 116 default: 117 break; 118 } 119 120 return false; 121} 122 123/// \brief If the identifier refers to a type name within this scope, 124/// return the declaration of that type. 125/// 126/// This routine performs ordinary name lookup of the identifier II 127/// within the given scope, with optional C++ scope specifier SS, to 128/// determine whether the name refers to a type. If so, returns an 129/// opaque pointer (actually a QualType) corresponding to that 130/// type. Otherwise, returns NULL. 131/// 132/// If name lookup results in an ambiguity, this routine will complain 133/// and then return NULL. 134ParsedType Sema::getTypeName(const IdentifierInfo &II, SourceLocation NameLoc, 135 Scope *S, CXXScopeSpec *SS, 136 bool isClassName, bool HasTrailingDot, 137 ParsedType ObjectTypePtr, 138 bool IsCtorOrDtorName, 139 bool WantNontrivialTypeSourceInfo, 140 IdentifierInfo **CorrectedII) { 141 // Determine where we will perform name lookup. 142 DeclContext *LookupCtx = 0; 143 if (ObjectTypePtr) { 144 QualType ObjectType = ObjectTypePtr.get(); 145 if (ObjectType->isRecordType()) 146 LookupCtx = computeDeclContext(ObjectType); 147 } else if (SS && SS->isNotEmpty()) { 148 LookupCtx = computeDeclContext(*SS, false); 149 150 if (!LookupCtx) { 151 if (isDependentScopeSpecifier(*SS)) { 152 // C++ [temp.res]p3: 153 // A qualified-id that refers to a type and in which the 154 // nested-name-specifier depends on a template-parameter (14.6.2) 155 // shall be prefixed by the keyword typename to indicate that the 156 // qualified-id denotes a type, forming an 157 // elaborated-type-specifier (7.1.5.3). 158 // 159 // We therefore do not perform any name lookup if the result would 160 // refer to a member of an unknown specialization. 161 if (!isClassName && !IsCtorOrDtorName) 162 return ParsedType(); 163 164 // We know from the grammar that this name refers to a type, 165 // so build a dependent node to describe the type. 166 if (WantNontrivialTypeSourceInfo) 167 return ActOnTypenameType(S, SourceLocation(), *SS, II, NameLoc).get(); 168 169 NestedNameSpecifierLoc QualifierLoc = SS->getWithLocInContext(Context); 170 QualType T = 171 CheckTypenameType(ETK_None, SourceLocation(), QualifierLoc, 172 II, NameLoc); 173 174 return ParsedType::make(T); 175 } 176 177 return ParsedType(); 178 } 179 180 if (!LookupCtx->isDependentContext() && 181 RequireCompleteDeclContext(*SS, LookupCtx)) 182 return ParsedType(); 183 } 184 185 // FIXME: LookupNestedNameSpecifierName isn't the right kind of 186 // lookup for class-names. 187 LookupNameKind Kind = isClassName ? LookupNestedNameSpecifierName : 188 LookupOrdinaryName; 189 LookupResult Result(*this, &II, NameLoc, Kind); 190 if (LookupCtx) { 191 // Perform "qualified" name lookup into the declaration context we 192 // computed, which is either the type of the base of a member access 193 // expression or the declaration context associated with a prior 194 // nested-name-specifier. 195 LookupQualifiedName(Result, LookupCtx); 196 197 if (ObjectTypePtr && Result.empty()) { 198 // C++ [basic.lookup.classref]p3: 199 // If the unqualified-id is ~type-name, the type-name is looked up 200 // in the context of the entire postfix-expression. If the type T of 201 // the object expression is of a class type C, the type-name is also 202 // looked up in the scope of class C. At least one of the lookups shall 203 // find a name that refers to (possibly cv-qualified) T. 204 LookupName(Result, S); 205 } 206 } else { 207 // Perform unqualified name lookup. 208 LookupName(Result, S); 209 } 210 211 NamedDecl *IIDecl = 0; 212 switch (Result.getResultKind()) { 213 case LookupResult::NotFound: 214 case LookupResult::NotFoundInCurrentInstantiation: 215 if (CorrectedII) { 216 TypeNameValidatorCCC Validator(true, isClassName); 217 TypoCorrection Correction = CorrectTypo(Result.getLookupNameInfo(), 218 Kind, S, SS, Validator); 219 IdentifierInfo *NewII = Correction.getCorrectionAsIdentifierInfo(); 220 TemplateTy Template; 221 bool MemberOfUnknownSpecialization; 222 UnqualifiedId TemplateName; 223 TemplateName.setIdentifier(NewII, NameLoc); 224 NestedNameSpecifier *NNS = Correction.getCorrectionSpecifier(); 225 CXXScopeSpec NewSS, *NewSSPtr = SS; 226 if (SS && NNS) { 227 NewSS.MakeTrivial(Context, NNS, SourceRange(NameLoc)); 228 NewSSPtr = &NewSS; 229 } 230 if (Correction && (NNS || NewII != &II) && 231 // Ignore a correction to a template type as the to-be-corrected 232 // identifier is not a template (typo correction for template names 233 // is handled elsewhere). 234 !(getLangOpts().CPlusPlus && NewSSPtr && 235 isTemplateName(S, *NewSSPtr, false, TemplateName, ParsedType(), 236 false, Template, MemberOfUnknownSpecialization))) { 237 ParsedType Ty = getTypeName(*NewII, NameLoc, S, NewSSPtr, 238 isClassName, HasTrailingDot, ObjectTypePtr, 239 IsCtorOrDtorName, 240 WantNontrivialTypeSourceInfo); 241 if (Ty) { 242 diagnoseTypo(Correction, 243 PDiag(diag::err_unknown_type_or_class_name_suggest) 244 << Result.getLookupName() << isClassName); 245 if (SS && NNS) 246 SS->MakeTrivial(Context, NNS, SourceRange(NameLoc)); 247 *CorrectedII = NewII; 248 return Ty; 249 } 250 } 251 } 252 // If typo correction failed or was not performed, fall through 253 case LookupResult::FoundOverloaded: 254 case LookupResult::FoundUnresolvedValue: 255 Result.suppressDiagnostics(); 256 return ParsedType(); 257 258 case LookupResult::Ambiguous: 259 // Recover from type-hiding ambiguities by hiding the type. We'll 260 // do the lookup again when looking for an object, and we can 261 // diagnose the error then. If we don't do this, then the error 262 // about hiding the type will be immediately followed by an error 263 // that only makes sense if the identifier was treated like a type. 264 if (Result.getAmbiguityKind() == LookupResult::AmbiguousTagHiding) { 265 Result.suppressDiagnostics(); 266 return ParsedType(); 267 } 268 269 // Look to see if we have a type anywhere in the list of results. 270 for (LookupResult::iterator Res = Result.begin(), ResEnd = Result.end(); 271 Res != ResEnd; ++Res) { 272 if (isa<TypeDecl>(*Res) || isa<ObjCInterfaceDecl>(*Res)) { 273 if (!IIDecl || 274 (*Res)->getLocation().getRawEncoding() < 275 IIDecl->getLocation().getRawEncoding()) 276 IIDecl = *Res; 277 } 278 } 279 280 if (!IIDecl) { 281 // None of the entities we found is a type, so there is no way 282 // to even assume that the result is a type. In this case, don't 283 // complain about the ambiguity. The parser will either try to 284 // perform this lookup again (e.g., as an object name), which 285 // will produce the ambiguity, or will complain that it expected 286 // a type name. 287 Result.suppressDiagnostics(); 288 return ParsedType(); 289 } 290 291 // We found a type within the ambiguous lookup; diagnose the 292 // ambiguity and then return that type. This might be the right 293 // answer, or it might not be, but it suppresses any attempt to 294 // perform the name lookup again. 295 break; 296 297 case LookupResult::Found: 298 IIDecl = Result.getFoundDecl(); 299 break; 300 } 301 302 assert(IIDecl && "Didn't find decl"); 303 304 QualType T; 305 if (TypeDecl *TD = dyn_cast<TypeDecl>(IIDecl)) { 306 DiagnoseUseOfDecl(IIDecl, NameLoc); 307 308 if (T.isNull()) 309 T = Context.getTypeDeclType(TD); 310 311 // NOTE: avoid constructing an ElaboratedType(Loc) if this is a 312 // constructor or destructor name (in such a case, the scope specifier 313 // will be attached to the enclosing Expr or Decl node). 314 if (SS && SS->isNotEmpty() && !IsCtorOrDtorName) { 315 if (WantNontrivialTypeSourceInfo) { 316 // Construct a type with type-source information. 317 TypeLocBuilder Builder; 318 Builder.pushTypeSpec(T).setNameLoc(NameLoc); 319 320 T = getElaboratedType(ETK_None, *SS, T); 321 ElaboratedTypeLoc ElabTL = Builder.push<ElaboratedTypeLoc>(T); 322 ElabTL.setElaboratedKeywordLoc(SourceLocation()); 323 ElabTL.setQualifierLoc(SS->getWithLocInContext(Context)); 324 return CreateParsedType(T, Builder.getTypeSourceInfo(Context, T)); 325 } else { 326 T = getElaboratedType(ETK_None, *SS, T); 327 } 328 } 329 } else if (ObjCInterfaceDecl *IDecl = dyn_cast<ObjCInterfaceDecl>(IIDecl)) { 330 (void)DiagnoseUseOfDecl(IDecl, NameLoc); 331 if (!HasTrailingDot) 332 T = Context.getObjCInterfaceType(IDecl); 333 } 334 335 if (T.isNull()) { 336 // If it's not plausibly a type, suppress diagnostics. 337 Result.suppressDiagnostics(); 338 return ParsedType(); 339 } 340 return ParsedType::make(T); 341} 342 343/// isTagName() - This method is called *for error recovery purposes only* 344/// to determine if the specified name is a valid tag name ("struct foo"). If 345/// so, this returns the TST for the tag corresponding to it (TST_enum, 346/// TST_union, TST_struct, TST_interface, TST_class). This is used to diagnose 347/// cases in C where the user forgot to specify the tag. 348DeclSpec::TST Sema::isTagName(IdentifierInfo &II, Scope *S) { 349 // Do a tag name lookup in this scope. 350 LookupResult R(*this, &II, SourceLocation(), LookupTagName); 351 LookupName(R, S, false); 352 R.suppressDiagnostics(); 353 if (R.getResultKind() == LookupResult::Found) 354 if (const TagDecl *TD = R.getAsSingle<TagDecl>()) { 355 switch (TD->getTagKind()) { 356 case TTK_Struct: return DeclSpec::TST_struct; 357 case TTK_Interface: return DeclSpec::TST_interface; 358 case TTK_Union: return DeclSpec::TST_union; 359 case TTK_Class: return DeclSpec::TST_class; 360 case TTK_Enum: return DeclSpec::TST_enum; 361 } 362 } 363 364 return DeclSpec::TST_unspecified; 365} 366 367/// isMicrosoftMissingTypename - In Microsoft mode, within class scope, 368/// if a CXXScopeSpec's type is equal to the type of one of the base classes 369/// then downgrade the missing typename error to a warning. 370/// This is needed for MSVC compatibility; Example: 371/// @code 372/// template<class T> class A { 373/// public: 374/// typedef int TYPE; 375/// }; 376/// template<class T> class B : public A<T> { 377/// public: 378/// A<T>::TYPE a; // no typename required because A<T> is a base class. 379/// }; 380/// @endcode 381bool Sema::isMicrosoftMissingTypename(const CXXScopeSpec *SS, Scope *S) { 382 if (CurContext->isRecord()) { 383 const Type *Ty = SS->getScopeRep()->getAsType(); 384 385 CXXRecordDecl *RD = cast<CXXRecordDecl>(CurContext); 386 for (CXXRecordDecl::base_class_const_iterator Base = RD->bases_begin(), 387 BaseEnd = RD->bases_end(); Base != BaseEnd; ++Base) 388 if (Context.hasSameUnqualifiedType(QualType(Ty, 1), Base->getType())) 389 return true; 390 return S->isFunctionPrototypeScope(); 391 } 392 return CurContext->isFunctionOrMethod() || S->isFunctionPrototypeScope(); 393} 394 395bool Sema::DiagnoseUnknownTypeName(IdentifierInfo *&II, 396 SourceLocation IILoc, 397 Scope *S, 398 CXXScopeSpec *SS, 399 ParsedType &SuggestedType) { 400 // We don't have anything to suggest (yet). 401 SuggestedType = ParsedType(); 402 403 // There may have been a typo in the name of the type. Look up typo 404 // results, in case we have something that we can suggest. 405 TypeNameValidatorCCC Validator(false); 406 if (TypoCorrection Corrected = CorrectTypo(DeclarationNameInfo(II, IILoc), 407 LookupOrdinaryName, S, SS, 408 Validator)) { 409 if (Corrected.isKeyword()) { 410 // We corrected to a keyword. 411 diagnoseTypo(Corrected, PDiag(diag::err_unknown_typename_suggest) << II); 412 II = Corrected.getCorrectionAsIdentifierInfo(); 413 } else { 414 // We found a similarly-named type or interface; suggest that. 415 if (!SS || !SS->isSet()) { 416 diagnoseTypo(Corrected, 417 PDiag(diag::err_unknown_typename_suggest) << II); 418 } else if (DeclContext *DC = computeDeclContext(*SS, false)) { 419 std::string CorrectedStr(Corrected.getAsString(getLangOpts())); 420 bool DroppedSpecifier = Corrected.WillReplaceSpecifier() && 421 II->getName().equals(CorrectedStr); 422 diagnoseTypo(Corrected, 423 PDiag(diag::err_unknown_nested_typename_suggest) 424 << II << DC << DroppedSpecifier << SS->getRange()); 425 } else { 426 llvm_unreachable("could not have corrected a typo here"); 427 } 428 429 CXXScopeSpec tmpSS; 430 if (Corrected.getCorrectionSpecifier()) 431 tmpSS.MakeTrivial(Context, Corrected.getCorrectionSpecifier(), 432 SourceRange(IILoc)); 433 SuggestedType = getTypeName(*Corrected.getCorrectionAsIdentifierInfo(), 434 IILoc, S, tmpSS.isSet() ? &tmpSS : SS, false, 435 false, ParsedType(), 436 /*IsCtorOrDtorName=*/false, 437 /*NonTrivialTypeSourceInfo=*/true); 438 } 439 return true; 440 } 441 442 if (getLangOpts().CPlusPlus) { 443 // See if II is a class template that the user forgot to pass arguments to. 444 UnqualifiedId Name; 445 Name.setIdentifier(II, IILoc); 446 CXXScopeSpec EmptySS; 447 TemplateTy TemplateResult; 448 bool MemberOfUnknownSpecialization; 449 if (isTemplateName(S, SS ? *SS : EmptySS, /*hasTemplateKeyword=*/false, 450 Name, ParsedType(), true, TemplateResult, 451 MemberOfUnknownSpecialization) == TNK_Type_template) { 452 TemplateName TplName = TemplateResult.get(); 453 Diag(IILoc, diag::err_template_missing_args) << TplName; 454 if (TemplateDecl *TplDecl = TplName.getAsTemplateDecl()) { 455 Diag(TplDecl->getLocation(), diag::note_template_decl_here) 456 << TplDecl->getTemplateParameters()->getSourceRange(); 457 } 458 return true; 459 } 460 } 461 462 // FIXME: Should we move the logic that tries to recover from a missing tag 463 // (struct, union, enum) from Parser::ParseImplicitInt here, instead? 464 465 if (!SS || (!SS->isSet() && !SS->isInvalid())) 466 Diag(IILoc, diag::err_unknown_typename) << II; 467 else if (DeclContext *DC = computeDeclContext(*SS, false)) 468 Diag(IILoc, diag::err_typename_nested_not_found) 469 << II << DC << SS->getRange(); 470 else if (isDependentScopeSpecifier(*SS)) { 471 unsigned DiagID = diag::err_typename_missing; 472 if (getLangOpts().MicrosoftMode && isMicrosoftMissingTypename(SS, S)) 473 DiagID = diag::warn_typename_missing; 474 475 Diag(SS->getRange().getBegin(), DiagID) 476 << (NestedNameSpecifier *)SS->getScopeRep() << II->getName() 477 << SourceRange(SS->getRange().getBegin(), IILoc) 478 << FixItHint::CreateInsertion(SS->getRange().getBegin(), "typename "); 479 SuggestedType = ActOnTypenameType(S, SourceLocation(), 480 *SS, *II, IILoc).get(); 481 } else { 482 assert(SS && SS->isInvalid() && 483 "Invalid scope specifier has already been diagnosed"); 484 } 485 486 return true; 487} 488 489/// \brief Determine whether the given result set contains either a type name 490/// or 491static bool isResultTypeOrTemplate(LookupResult &R, const Token &NextToken) { 492 bool CheckTemplate = R.getSema().getLangOpts().CPlusPlus && 493 NextToken.is(tok::less); 494 495 for (LookupResult::iterator I = R.begin(), IEnd = R.end(); I != IEnd; ++I) { 496 if (isa<TypeDecl>(*I) || isa<ObjCInterfaceDecl>(*I)) 497 return true; 498 499 if (CheckTemplate && isa<TemplateDecl>(*I)) 500 return true; 501 } 502 503 return false; 504} 505 506static bool isTagTypeWithMissingTag(Sema &SemaRef, LookupResult &Result, 507 Scope *S, CXXScopeSpec &SS, 508 IdentifierInfo *&Name, 509 SourceLocation NameLoc) { 510 LookupResult R(SemaRef, Name, NameLoc, Sema::LookupTagName); 511 SemaRef.LookupParsedName(R, S, &SS); 512 if (TagDecl *Tag = R.getAsSingle<TagDecl>()) { 513 const char *TagName = 0; 514 const char *FixItTagName = 0; 515 switch (Tag->getTagKind()) { 516 case TTK_Class: 517 TagName = "class"; 518 FixItTagName = "class "; 519 break; 520 521 case TTK_Enum: 522 TagName = "enum"; 523 FixItTagName = "enum "; 524 break; 525 526 case TTK_Struct: 527 TagName = "struct"; 528 FixItTagName = "struct "; 529 break; 530 531 case TTK_Interface: 532 TagName = "__interface"; 533 FixItTagName = "__interface "; 534 break; 535 536 case TTK_Union: 537 TagName = "union"; 538 FixItTagName = "union "; 539 break; 540 } 541 542 SemaRef.Diag(NameLoc, diag::err_use_of_tag_name_without_tag) 543 << Name << TagName << SemaRef.getLangOpts().CPlusPlus 544 << FixItHint::CreateInsertion(NameLoc, FixItTagName); 545 546 for (LookupResult::iterator I = Result.begin(), IEnd = Result.end(); 547 I != IEnd; ++I) 548 SemaRef.Diag((*I)->getLocation(), diag::note_decl_hiding_tag_type) 549 << Name << TagName; 550 551 // Replace lookup results with just the tag decl. 552 Result.clear(Sema::LookupTagName); 553 SemaRef.LookupParsedName(Result, S, &SS); 554 return true; 555 } 556 557 return false; 558} 559 560/// Build a ParsedType for a simple-type-specifier with a nested-name-specifier. 561static ParsedType buildNestedType(Sema &S, CXXScopeSpec &SS, 562 QualType T, SourceLocation NameLoc) { 563 ASTContext &Context = S.Context; 564 565 TypeLocBuilder Builder; 566 Builder.pushTypeSpec(T).setNameLoc(NameLoc); 567 568 T = S.getElaboratedType(ETK_None, SS, T); 569 ElaboratedTypeLoc ElabTL = Builder.push<ElaboratedTypeLoc>(T); 570 ElabTL.setElaboratedKeywordLoc(SourceLocation()); 571 ElabTL.setQualifierLoc(SS.getWithLocInContext(Context)); 572 return S.CreateParsedType(T, Builder.getTypeSourceInfo(Context, T)); 573} 574 575Sema::NameClassification Sema::ClassifyName(Scope *S, 576 CXXScopeSpec &SS, 577 IdentifierInfo *&Name, 578 SourceLocation NameLoc, 579 const Token &NextToken, 580 bool IsAddressOfOperand, 581 CorrectionCandidateCallback *CCC) { 582 DeclarationNameInfo NameInfo(Name, NameLoc); 583 ObjCMethodDecl *CurMethod = getCurMethodDecl(); 584 585 if (NextToken.is(tok::coloncolon)) { 586 BuildCXXNestedNameSpecifier(S, *Name, NameLoc, NextToken.getLocation(), 587 QualType(), false, SS, 0, false); 588 589 } 590 591 LookupResult Result(*this, Name, NameLoc, LookupOrdinaryName); 592 LookupParsedName(Result, S, &SS, !CurMethod); 593 594 // Perform lookup for Objective-C instance variables (including automatically 595 // synthesized instance variables), if we're in an Objective-C method. 596 // FIXME: This lookup really, really needs to be folded in to the normal 597 // unqualified lookup mechanism. 598 if (!SS.isSet() && CurMethod && !isResultTypeOrTemplate(Result, NextToken)) { 599 ExprResult E = LookupInObjCMethod(Result, S, Name, true); 600 if (E.get() || E.isInvalid()) 601 return E; 602 } 603 604 bool SecondTry = false; 605 bool IsFilteredTemplateName = false; 606 607Corrected: 608 switch (Result.getResultKind()) { 609 case LookupResult::NotFound: 610 // If an unqualified-id is followed by a '(', then we have a function 611 // call. 612 if (!SS.isSet() && NextToken.is(tok::l_paren)) { 613 // In C++, this is an ADL-only call. 614 // FIXME: Reference? 615 if (getLangOpts().CPlusPlus) 616 return BuildDeclarationNameExpr(SS, Result, /*ADL=*/true); 617 618 // C90 6.3.2.2: 619 // If the expression that precedes the parenthesized argument list in a 620 // function call consists solely of an identifier, and if no 621 // declaration is visible for this identifier, the identifier is 622 // implicitly declared exactly as if, in the innermost block containing 623 // the function call, the declaration 624 // 625 // extern int identifier (); 626 // 627 // appeared. 628 // 629 // We also allow this in C99 as an extension. 630 if (NamedDecl *D = ImplicitlyDefineFunction(NameLoc, *Name, S)) { 631 Result.addDecl(D); 632 Result.resolveKind(); 633 return BuildDeclarationNameExpr(SS, Result, /*ADL=*/false); 634 } 635 } 636 637 // In C, we first see whether there is a tag type by the same name, in 638 // which case it's likely that the user just forget to write "enum", 639 // "struct", or "union". 640 if (!getLangOpts().CPlusPlus && !SecondTry && 641 isTagTypeWithMissingTag(*this, Result, S, SS, Name, NameLoc)) { 642 break; 643 } 644 645 // Perform typo correction to determine if there is another name that is 646 // close to this name. 647 if (!SecondTry && CCC) { 648 SecondTry = true; 649 if (TypoCorrection Corrected = CorrectTypo(Result.getLookupNameInfo(), 650 Result.getLookupKind(), S, 651 &SS, *CCC)) { 652 unsigned UnqualifiedDiag = diag::err_undeclared_var_use_suggest; 653 unsigned QualifiedDiag = diag::err_no_member_suggest; 654 655 NamedDecl *FirstDecl = Corrected.getCorrectionDecl(); 656 NamedDecl *UnderlyingFirstDecl 657 = FirstDecl? FirstDecl->getUnderlyingDecl() : 0; 658 if (getLangOpts().CPlusPlus && NextToken.is(tok::less) && 659 UnderlyingFirstDecl && isa<TemplateDecl>(UnderlyingFirstDecl)) { 660 UnqualifiedDiag = diag::err_no_template_suggest; 661 QualifiedDiag = diag::err_no_member_template_suggest; 662 } else if (UnderlyingFirstDecl && 663 (isa<TypeDecl>(UnderlyingFirstDecl) || 664 isa<ObjCInterfaceDecl>(UnderlyingFirstDecl) || 665 isa<ObjCCompatibleAliasDecl>(UnderlyingFirstDecl))) { 666 UnqualifiedDiag = diag::err_unknown_typename_suggest; 667 QualifiedDiag = diag::err_unknown_nested_typename_suggest; 668 } 669 670 if (SS.isEmpty()) { 671 diagnoseTypo(Corrected, PDiag(UnqualifiedDiag) << Name); 672 } else {// FIXME: is this even reachable? Test it. 673 std::string CorrectedStr(Corrected.getAsString(getLangOpts())); 674 bool DroppedSpecifier = Corrected.WillReplaceSpecifier() && 675 Name->getName().equals(CorrectedStr); 676 diagnoseTypo(Corrected, PDiag(QualifiedDiag) 677 << Name << computeDeclContext(SS, false) 678 << DroppedSpecifier << SS.getRange()); 679 } 680 681 // Update the name, so that the caller has the new name. 682 Name = Corrected.getCorrectionAsIdentifierInfo(); 683 684 // Typo correction corrected to a keyword. 685 if (Corrected.isKeyword()) 686 return Name; 687 688 // Also update the LookupResult... 689 // FIXME: This should probably go away at some point 690 Result.clear(); 691 Result.setLookupName(Corrected.getCorrection()); 692 if (FirstDecl) 693 Result.addDecl(FirstDecl); 694 695 // If we found an Objective-C instance variable, let 696 // LookupInObjCMethod build the appropriate expression to 697 // reference the ivar. 698 // FIXME: This is a gross hack. 699 if (ObjCIvarDecl *Ivar = Result.getAsSingle<ObjCIvarDecl>()) { 700 Result.clear(); 701 ExprResult E(LookupInObjCMethod(Result, S, Ivar->getIdentifier())); 702 return E; 703 } 704 705 goto Corrected; 706 } 707 } 708 709 // We failed to correct; just fall through and let the parser deal with it. 710 Result.suppressDiagnostics(); 711 return NameClassification::Unknown(); 712 713 case LookupResult::NotFoundInCurrentInstantiation: { 714 // We performed name lookup into the current instantiation, and there were 715 // dependent bases, so we treat this result the same way as any other 716 // dependent nested-name-specifier. 717 718 // C++ [temp.res]p2: 719 // A name used in a template declaration or definition and that is 720 // dependent on a template-parameter is assumed not to name a type 721 // unless the applicable name lookup finds a type name or the name is 722 // qualified by the keyword typename. 723 // 724 // FIXME: If the next token is '<', we might want to ask the parser to 725 // perform some heroics to see if we actually have a 726 // template-argument-list, which would indicate a missing 'template' 727 // keyword here. 728 return ActOnDependentIdExpression(SS, /*TemplateKWLoc=*/SourceLocation(), 729 NameInfo, IsAddressOfOperand, 730 /*TemplateArgs=*/0); 731 } 732 733 case LookupResult::Found: 734 case LookupResult::FoundOverloaded: 735 case LookupResult::FoundUnresolvedValue: 736 break; 737 738 case LookupResult::Ambiguous: 739 if (getLangOpts().CPlusPlus && NextToken.is(tok::less) && 740 hasAnyAcceptableTemplateNames(Result)) { 741 // C++ [temp.local]p3: 742 // A lookup that finds an injected-class-name (10.2) can result in an 743 // ambiguity in certain cases (for example, if it is found in more than 744 // one base class). If all of the injected-class-names that are found 745 // refer to specializations of the same class template, and if the name 746 // is followed by a template-argument-list, the reference refers to the 747 // class template itself and not a specialization thereof, and is not 748 // ambiguous. 749 // 750 // This filtering can make an ambiguous result into an unambiguous one, 751 // so try again after filtering out template names. 752 FilterAcceptableTemplateNames(Result); 753 if (!Result.isAmbiguous()) { 754 IsFilteredTemplateName = true; 755 break; 756 } 757 } 758 759 // Diagnose the ambiguity and return an error. 760 return NameClassification::Error(); 761 } 762 763 if (getLangOpts().CPlusPlus && NextToken.is(tok::less) && 764 (IsFilteredTemplateName || hasAnyAcceptableTemplateNames(Result))) { 765 // C++ [temp.names]p3: 766 // After name lookup (3.4) finds that a name is a template-name or that 767 // an operator-function-id or a literal- operator-id refers to a set of 768 // overloaded functions any member of which is a function template if 769 // this is followed by a <, the < is always taken as the delimiter of a 770 // template-argument-list and never as the less-than operator. 771 if (!IsFilteredTemplateName) 772 FilterAcceptableTemplateNames(Result); 773 774 if (!Result.empty()) { 775 bool IsFunctionTemplate; 776 bool IsVarTemplate; 777 TemplateName Template; 778 if (Result.end() - Result.begin() > 1) { 779 IsFunctionTemplate = true; 780 Template = Context.getOverloadedTemplateName(Result.begin(), 781 Result.end()); 782 } else { 783 TemplateDecl *TD 784 = cast<TemplateDecl>((*Result.begin())->getUnderlyingDecl()); 785 IsFunctionTemplate = isa<FunctionTemplateDecl>(TD); 786 IsVarTemplate = isa<VarTemplateDecl>(TD); 787 788 if (SS.isSet() && !SS.isInvalid()) 789 Template = Context.getQualifiedTemplateName(SS.getScopeRep(), 790 /*TemplateKeyword=*/false, 791 TD); 792 else 793 Template = TemplateName(TD); 794 } 795 796 if (IsFunctionTemplate) { 797 // Function templates always go through overload resolution, at which 798 // point we'll perform the various checks (e.g., accessibility) we need 799 // to based on which function we selected. 800 Result.suppressDiagnostics(); 801 802 return NameClassification::FunctionTemplate(Template); 803 } 804 805 return IsVarTemplate ? NameClassification::VarTemplate(Template) 806 : NameClassification::TypeTemplate(Template); 807 } 808 } 809 810 NamedDecl *FirstDecl = (*Result.begin())->getUnderlyingDecl(); 811 if (TypeDecl *Type = dyn_cast<TypeDecl>(FirstDecl)) { 812 DiagnoseUseOfDecl(Type, NameLoc); 813 QualType T = Context.getTypeDeclType(Type); 814 if (SS.isNotEmpty()) 815 return buildNestedType(*this, SS, T, NameLoc); 816 return ParsedType::make(T); 817 } 818 819 ObjCInterfaceDecl *Class = dyn_cast<ObjCInterfaceDecl>(FirstDecl); 820 if (!Class) { 821 // FIXME: It's unfortunate that we don't have a Type node for handling this. 822 if (ObjCCompatibleAliasDecl *Alias 823 = dyn_cast<ObjCCompatibleAliasDecl>(FirstDecl)) 824 Class = Alias->getClassInterface(); 825 } 826 827 if (Class) { 828 DiagnoseUseOfDecl(Class, NameLoc); 829 830 if (NextToken.is(tok::period)) { 831 // Interface. <something> is parsed as a property reference expression. 832 // Just return "unknown" as a fall-through for now. 833 Result.suppressDiagnostics(); 834 return NameClassification::Unknown(); 835 } 836 837 QualType T = Context.getObjCInterfaceType(Class); 838 return ParsedType::make(T); 839 } 840 841 // We can have a type template here if we're classifying a template argument. 842 if (isa<TemplateDecl>(FirstDecl) && !isa<FunctionTemplateDecl>(FirstDecl)) 843 return NameClassification::TypeTemplate( 844 TemplateName(cast<TemplateDecl>(FirstDecl))); 845 846 // Check for a tag type hidden by a non-type decl in a few cases where it 847 // seems likely a type is wanted instead of the non-type that was found. 848 bool NextIsOp = NextToken.is(tok::amp) || NextToken.is(tok::star); 849 if ((NextToken.is(tok::identifier) || 850 (NextIsOp && FirstDecl->isFunctionOrFunctionTemplate())) && 851 isTagTypeWithMissingTag(*this, Result, S, SS, Name, NameLoc)) { 852 TypeDecl *Type = Result.getAsSingle<TypeDecl>(); 853 DiagnoseUseOfDecl(Type, NameLoc); 854 QualType T = Context.getTypeDeclType(Type); 855 if (SS.isNotEmpty()) 856 return buildNestedType(*this, SS, T, NameLoc); 857 return ParsedType::make(T); 858 } 859 860 if (FirstDecl->isCXXClassMember()) 861 return BuildPossibleImplicitMemberExpr(SS, SourceLocation(), Result, 0); 862 863 bool ADL = UseArgumentDependentLookup(SS, Result, NextToken.is(tok::l_paren)); 864 return BuildDeclarationNameExpr(SS, Result, ADL); 865} 866 867// Determines the context to return to after temporarily entering a 868// context. This depends in an unnecessarily complicated way on the 869// exact ordering of callbacks from the parser. 870DeclContext *Sema::getContainingDC(DeclContext *DC) { 871 872 // Functions defined inline within classes aren't parsed until we've 873 // finished parsing the top-level class, so the top-level class is 874 // the context we'll need to return to. 875 if (isa<FunctionDecl>(DC)) { 876 DC = DC->getLexicalParent(); 877 878 // A function not defined within a class will always return to its 879 // lexical context. 880 if (!isa<CXXRecordDecl>(DC)) 881 return DC; 882 883 // A C++ inline method/friend is parsed *after* the topmost class 884 // it was declared in is fully parsed ("complete"); the topmost 885 // class is the context we need to return to. 886 while (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(DC->getLexicalParent())) 887 DC = RD; 888 889 // Return the declaration context of the topmost class the inline method is 890 // declared in. 891 return DC; 892 } 893 894 return DC->getLexicalParent(); 895} 896 897void Sema::PushDeclContext(Scope *S, DeclContext *DC) { 898 assert(getContainingDC(DC) == CurContext && 899 "The next DeclContext should be lexically contained in the current one."); 900 CurContext = DC; 901 S->setEntity(DC); 902} 903 904void Sema::PopDeclContext() { 905 assert(CurContext && "DeclContext imbalance!"); 906 907 CurContext = getContainingDC(CurContext); 908 assert(CurContext && "Popped translation unit!"); 909} 910 911/// EnterDeclaratorContext - Used when we must lookup names in the context 912/// of a declarator's nested name specifier. 913/// 914void Sema::EnterDeclaratorContext(Scope *S, DeclContext *DC) { 915 // C++0x [basic.lookup.unqual]p13: 916 // A name used in the definition of a static data member of class 917 // X (after the qualified-id of the static member) is looked up as 918 // if the name was used in a member function of X. 919 // C++0x [basic.lookup.unqual]p14: 920 // If a variable member of a namespace is defined outside of the 921 // scope of its namespace then any name used in the definition of 922 // the variable member (after the declarator-id) is looked up as 923 // if the definition of the variable member occurred in its 924 // namespace. 925 // Both of these imply that we should push a scope whose context 926 // is the semantic context of the declaration. We can't use 927 // PushDeclContext here because that context is not necessarily 928 // lexically contained in the current context. Fortunately, 929 // the containing scope should have the appropriate information. 930 931 assert(!S->getEntity() && "scope already has entity"); 932 933#ifndef NDEBUG 934 Scope *Ancestor = S->getParent(); 935 while (!Ancestor->getEntity()) Ancestor = Ancestor->getParent(); 936 assert(Ancestor->getEntity() == CurContext && "ancestor context mismatch"); 937#endif 938 939 CurContext = DC; 940 S->setEntity(DC); 941} 942 943void Sema::ExitDeclaratorContext(Scope *S) { 944 assert(S->getEntity() == CurContext && "Context imbalance!"); 945 946 // Switch back to the lexical context. The safety of this is 947 // enforced by an assert in EnterDeclaratorContext. 948 Scope *Ancestor = S->getParent(); 949 while (!Ancestor->getEntity()) Ancestor = Ancestor->getParent(); 950 CurContext = (DeclContext*) Ancestor->getEntity(); 951 952 // We don't need to do anything with the scope, which is going to 953 // disappear. 954} 955 956 957void Sema::ActOnReenterFunctionContext(Scope* S, Decl *D) { 958 FunctionDecl *FD = dyn_cast<FunctionDecl>(D); 959 if (FunctionTemplateDecl *TFD = dyn_cast_or_null<FunctionTemplateDecl>(D)) { 960 // We assume that the caller has already called 961 // ActOnReenterTemplateScope 962 FD = TFD->getTemplatedDecl(); 963 } 964 if (!FD) 965 return; 966 967 // Same implementation as PushDeclContext, but enters the context 968 // from the lexical parent, rather than the top-level class. 969 assert(CurContext == FD->getLexicalParent() && 970 "The next DeclContext should be lexically contained in the current one."); 971 CurContext = FD; 972 S->setEntity(CurContext); 973 974 for (unsigned P = 0, NumParams = FD->getNumParams(); P < NumParams; ++P) { 975 ParmVarDecl *Param = FD->getParamDecl(P); 976 // If the parameter has an identifier, then add it to the scope 977 if (Param->getIdentifier()) { 978 S->AddDecl(Param); 979 IdResolver.AddDecl(Param); 980 } 981 } 982} 983 984 985void Sema::ActOnExitFunctionContext() { 986 // Same implementation as PopDeclContext, but returns to the lexical parent, 987 // rather than the top-level class. 988 assert(CurContext && "DeclContext imbalance!"); 989 CurContext = CurContext->getLexicalParent(); 990 assert(CurContext && "Popped translation unit!"); 991} 992 993 994/// \brief Determine whether we allow overloading of the function 995/// PrevDecl with another declaration. 996/// 997/// This routine determines whether overloading is possible, not 998/// whether some new function is actually an overload. It will return 999/// true in C++ (where we can always provide overloads) or, as an 1000/// extension, in C when the previous function is already an 1001/// overloaded function declaration or has the "overloadable" 1002/// attribute. 1003static bool AllowOverloadingOfFunction(LookupResult &Previous, 1004 ASTContext &Context) { 1005 if (Context.getLangOpts().CPlusPlus) 1006 return true; 1007 1008 if (Previous.getResultKind() == LookupResult::FoundOverloaded) 1009 return true; 1010 1011 return (Previous.getResultKind() == LookupResult::Found 1012 && Previous.getFoundDecl()->hasAttr<OverloadableAttr>()); 1013} 1014 1015/// Add this decl to the scope shadowed decl chains. 1016void Sema::PushOnScopeChains(NamedDecl *D, Scope *S, bool AddToContext) { 1017 // Move up the scope chain until we find the nearest enclosing 1018 // non-transparent context. The declaration will be introduced into this 1019 // scope. 1020 while (S->getEntity() && 1021 ((DeclContext *)S->getEntity())->isTransparentContext()) 1022 S = S->getParent(); 1023 1024 // Add scoped declarations into their context, so that they can be 1025 // found later. Declarations without a context won't be inserted 1026 // into any context. 1027 if (AddToContext) 1028 CurContext->addDecl(D); 1029 1030 // Out-of-line definitions shouldn't be pushed into scope in C++, unless they 1031 // are function-local declarations. 1032 if (getLangOpts().CPlusPlus && D->isOutOfLine() && 1033 !D->getDeclContext()->getRedeclContext()->Equals( 1034 D->getLexicalDeclContext()->getRedeclContext()) && 1035 !D->getLexicalDeclContext()->isFunctionOrMethod()) 1036 return; 1037 1038 // Template instantiations should also not be pushed into scope. 1039 if (isa<FunctionDecl>(D) && 1040 cast<FunctionDecl>(D)->isFunctionTemplateSpecialization()) 1041 return; 1042 1043 // If this replaces anything in the current scope, 1044 IdentifierResolver::iterator I = IdResolver.begin(D->getDeclName()), 1045 IEnd = IdResolver.end(); 1046 for (; I != IEnd; ++I) { 1047 if (S->isDeclScope(*I) && D->declarationReplaces(*I)) { 1048 S->RemoveDecl(*I); 1049 IdResolver.RemoveDecl(*I); 1050 1051 // Should only need to replace one decl. 1052 break; 1053 } 1054 } 1055 1056 S->AddDecl(D); 1057 1058 if (isa<LabelDecl>(D) && !cast<LabelDecl>(D)->isGnuLocal()) { 1059 // Implicitly-generated labels may end up getting generated in an order that 1060 // isn't strictly lexical, which breaks name lookup. Be careful to insert 1061 // the label at the appropriate place in the identifier chain. 1062 for (I = IdResolver.begin(D->getDeclName()); I != IEnd; ++I) { 1063 DeclContext *IDC = (*I)->getLexicalDeclContext()->getRedeclContext(); 1064 if (IDC == CurContext) { 1065 if (!S->isDeclScope(*I)) 1066 continue; 1067 } else if (IDC->Encloses(CurContext)) 1068 break; 1069 } 1070 1071 IdResolver.InsertDeclAfter(I, D); 1072 } else { 1073 IdResolver.AddDecl(D); 1074 } 1075} 1076 1077void Sema::pushExternalDeclIntoScope(NamedDecl *D, DeclarationName Name) { 1078 if (IdResolver.tryAddTopLevelDecl(D, Name) && TUScope) 1079 TUScope->AddDecl(D); 1080} 1081 1082bool Sema::isDeclInScope(NamedDecl *D, DeclContext *Ctx, Scope *S, 1083 bool ExplicitInstantiationOrSpecialization) { 1084 return IdResolver.isDeclInScope(D, Ctx, S, 1085 ExplicitInstantiationOrSpecialization); 1086} 1087 1088Scope *Sema::getScopeForDeclContext(Scope *S, DeclContext *DC) { 1089 DeclContext *TargetDC = DC->getPrimaryContext(); 1090 do { 1091 if (DeclContext *ScopeDC = (DeclContext*) S->getEntity()) 1092 if (ScopeDC->getPrimaryContext() == TargetDC) 1093 return S; 1094 } while ((S = S->getParent())); 1095 1096 return 0; 1097} 1098 1099static bool isOutOfScopePreviousDeclaration(NamedDecl *, 1100 DeclContext*, 1101 ASTContext&); 1102 1103/// Filters out lookup results that don't fall within the given scope 1104/// as determined by isDeclInScope. 1105void Sema::FilterLookupForScope(LookupResult &R, 1106 DeclContext *Ctx, Scope *S, 1107 bool ConsiderLinkage, 1108 bool ExplicitInstantiationOrSpecialization) { 1109 LookupResult::Filter F = R.makeFilter(); 1110 while (F.hasNext()) { 1111 NamedDecl *D = F.next(); 1112 1113 if (isDeclInScope(D, Ctx, S, ExplicitInstantiationOrSpecialization)) 1114 continue; 1115 1116 if (ConsiderLinkage && 1117 isOutOfScopePreviousDeclaration(D, Ctx, Context)) 1118 continue; 1119 1120 F.erase(); 1121 } 1122 1123 F.done(); 1124} 1125 1126static bool isUsingDecl(NamedDecl *D) { 1127 return isa<UsingShadowDecl>(D) || 1128 isa<UnresolvedUsingTypenameDecl>(D) || 1129 isa<UnresolvedUsingValueDecl>(D); 1130} 1131 1132/// Removes using shadow declarations from the lookup results. 1133static void RemoveUsingDecls(LookupResult &R) { 1134 LookupResult::Filter F = R.makeFilter(); 1135 while (F.hasNext()) 1136 if (isUsingDecl(F.next())) 1137 F.erase(); 1138 1139 F.done(); 1140} 1141 1142/// \brief Check for this common pattern: 1143/// @code 1144/// class S { 1145/// S(const S&); // DO NOT IMPLEMENT 1146/// void operator=(const S&); // DO NOT IMPLEMENT 1147/// }; 1148/// @endcode 1149static bool IsDisallowedCopyOrAssign(const CXXMethodDecl *D) { 1150 // FIXME: Should check for private access too but access is set after we get 1151 // the decl here. 1152 if (D->doesThisDeclarationHaveABody()) 1153 return false; 1154 1155 if (const CXXConstructorDecl *CD = dyn_cast<CXXConstructorDecl>(D)) 1156 return CD->isCopyConstructor(); 1157 if (const CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D)) 1158 return Method->isCopyAssignmentOperator(); 1159 return false; 1160} 1161 1162// We need this to handle 1163// 1164// typedef struct { 1165// void *foo() { return 0; } 1166// } A; 1167// 1168// When we see foo we don't know if after the typedef we will get 'A' or '*A' 1169// for example. If 'A', foo will have external linkage. If we have '*A', 1170// foo will have no linkage. Since we can't know untill we get to the end 1171// of the typedef, this function finds out if D might have non external linkage. 1172// Callers should verify at the end of the TU if it D has external linkage or 1173// not. 1174bool Sema::mightHaveNonExternalLinkage(const DeclaratorDecl *D) { 1175 const DeclContext *DC = D->getDeclContext(); 1176 while (!DC->isTranslationUnit()) { 1177 if (const RecordDecl *RD = dyn_cast<RecordDecl>(DC)){ 1178 if (!RD->hasNameForLinkage()) 1179 return true; 1180 } 1181 DC = DC->getParent(); 1182 } 1183 1184 return !D->isExternallyVisible(); 1185} 1186 1187// FIXME: This needs to be refactored; some other isInMainFile users want 1188// these semantics. 1189static bool isMainFileLoc(const Sema &S, SourceLocation Loc) { 1190 if (S.TUKind != TU_Complete) 1191 return false; 1192 return S.SourceMgr.isInMainFile(Loc); 1193} 1194 1195bool Sema::ShouldWarnIfUnusedFileScopedDecl(const DeclaratorDecl *D) const { 1196 assert(D); 1197 1198 if (D->isInvalidDecl() || D->isUsed() || D->hasAttr<UnusedAttr>()) 1199 return false; 1200 1201 // Ignore class templates. 1202 if (D->getDeclContext()->isDependentContext() || 1203 D->getLexicalDeclContext()->isDependentContext()) 1204 return false; 1205 1206 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) { 1207 if (FD->getTemplateSpecializationKind() == TSK_ImplicitInstantiation) 1208 return false; 1209 1210 if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) { 1211 if (MD->isVirtual() || IsDisallowedCopyOrAssign(MD)) 1212 return false; 1213 } else { 1214 // 'static inline' functions are defined in headers; don't warn. 1215 if (FD->isInlineSpecified() && 1216 !isMainFileLoc(*this, FD->getLocation())) 1217 return false; 1218 } 1219 1220 if (FD->doesThisDeclarationHaveABody() && 1221 Context.DeclMustBeEmitted(FD)) 1222 return false; 1223 } else if (const VarDecl *VD = dyn_cast<VarDecl>(D)) { 1224 // Constants and utility variables are defined in headers with internal 1225 // linkage; don't warn. (Unlike functions, there isn't a convenient marker 1226 // like "inline".) 1227 if (!isMainFileLoc(*this, VD->getLocation())) 1228 return false; 1229 1230 if (Context.DeclMustBeEmitted(VD)) 1231 return false; 1232 1233 if (VD->isStaticDataMember() && 1234 VD->getTemplateSpecializationKind() == TSK_ImplicitInstantiation) 1235 return false; 1236 } else { 1237 return false; 1238 } 1239 1240 // Only warn for unused decls internal to the translation unit. 1241 return mightHaveNonExternalLinkage(D); 1242} 1243 1244void Sema::MarkUnusedFileScopedDecl(const DeclaratorDecl *D) { 1245 if (!D) 1246 return; 1247 1248 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) { 1249 const FunctionDecl *First = FD->getFirstDeclaration(); 1250 if (FD != First && ShouldWarnIfUnusedFileScopedDecl(First)) 1251 return; // First should already be in the vector. 1252 } 1253 1254 if (const VarDecl *VD = dyn_cast<VarDecl>(D)) { 1255 const VarDecl *First = VD->getFirstDeclaration(); 1256 if (VD != First && ShouldWarnIfUnusedFileScopedDecl(First)) 1257 return; // First should already be in the vector. 1258 } 1259 1260 if (ShouldWarnIfUnusedFileScopedDecl(D)) 1261 UnusedFileScopedDecls.push_back(D); 1262} 1263 1264static bool ShouldDiagnoseUnusedDecl(const NamedDecl *D) { 1265 if (D->isInvalidDecl()) 1266 return false; 1267 1268 if (D->isReferenced() || D->isUsed() || D->hasAttr<UnusedAttr>()) 1269 return false; 1270 1271 if (isa<LabelDecl>(D)) 1272 return true; 1273 1274 // White-list anything that isn't a local variable. 1275 if (!isa<VarDecl>(D) || isa<ParmVarDecl>(D) || isa<ImplicitParamDecl>(D) || 1276 !D->getDeclContext()->isFunctionOrMethod()) 1277 return false; 1278 1279 // Types of valid local variables should be complete, so this should succeed. 1280 if (const VarDecl *VD = dyn_cast<VarDecl>(D)) { 1281 1282 // White-list anything with an __attribute__((unused)) type. 1283 QualType Ty = VD->getType(); 1284 1285 // Only look at the outermost level of typedef. 1286 if (const TypedefType *TT = Ty->getAs<TypedefType>()) { 1287 if (TT->getDecl()->hasAttr<UnusedAttr>()) 1288 return false; 1289 } 1290 1291 // If we failed to complete the type for some reason, or if the type is 1292 // dependent, don't diagnose the variable. 1293 if (Ty->isIncompleteType() || Ty->isDependentType()) 1294 return false; 1295 1296 if (const TagType *TT = Ty->getAs<TagType>()) { 1297 const TagDecl *Tag = TT->getDecl(); 1298 if (Tag->hasAttr<UnusedAttr>()) 1299 return false; 1300 1301 if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(Tag)) { 1302 if (!RD->hasTrivialDestructor() && !RD->hasAttr<WarnUnusedAttr>()) 1303 return false; 1304 1305 if (const Expr *Init = VD->getInit()) { 1306 if (const ExprWithCleanups *Cleanups = dyn_cast<ExprWithCleanups>(Init)) 1307 Init = Cleanups->getSubExpr(); 1308 const CXXConstructExpr *Construct = 1309 dyn_cast<CXXConstructExpr>(Init); 1310 if (Construct && !Construct->isElidable()) { 1311 CXXConstructorDecl *CD = Construct->getConstructor(); 1312 if (!CD->isTrivial() && !RD->hasAttr<WarnUnusedAttr>()) 1313 return false; 1314 } 1315 } 1316 } 1317 } 1318 1319 // TODO: __attribute__((unused)) templates? 1320 } 1321 1322 return true; 1323} 1324 1325static void GenerateFixForUnusedDecl(const NamedDecl *D, ASTContext &Ctx, 1326 FixItHint &Hint) { 1327 if (isa<LabelDecl>(D)) { 1328 SourceLocation AfterColon = Lexer::findLocationAfterToken(D->getLocEnd(), 1329 tok::colon, Ctx.getSourceManager(), Ctx.getLangOpts(), true); 1330 if (AfterColon.isInvalid()) 1331 return; 1332 Hint = FixItHint::CreateRemoval(CharSourceRange:: 1333 getCharRange(D->getLocStart(), AfterColon)); 1334 } 1335 return; 1336} 1337 1338/// DiagnoseUnusedDecl - Emit warnings about declarations that are not used 1339/// unless they are marked attr(unused). 1340void Sema::DiagnoseUnusedDecl(const NamedDecl *D) { 1341 FixItHint Hint; 1342 if (!ShouldDiagnoseUnusedDecl(D)) 1343 return; 1344 1345 GenerateFixForUnusedDecl(D, Context, Hint); 1346 1347 unsigned DiagID; 1348 if (isa<VarDecl>(D) && cast<VarDecl>(D)->isExceptionVariable()) 1349 DiagID = diag::warn_unused_exception_param; 1350 else if (isa<LabelDecl>(D)) 1351 DiagID = diag::warn_unused_label; 1352 else 1353 DiagID = diag::warn_unused_variable; 1354 1355 Diag(D->getLocation(), DiagID) << D->getDeclName() << Hint; 1356} 1357 1358static void CheckPoppedLabel(LabelDecl *L, Sema &S) { 1359 // Verify that we have no forward references left. If so, there was a goto 1360 // or address of a label taken, but no definition of it. Label fwd 1361 // definitions are indicated with a null substmt. 1362 if (L->getStmt() == 0) 1363 S.Diag(L->getLocation(), diag::err_undeclared_label_use) <<L->getDeclName(); 1364} 1365 1366void Sema::ActOnPopScope(SourceLocation Loc, Scope *S) { 1367 if (S->decl_empty()) return; 1368 assert((S->getFlags() & (Scope::DeclScope | Scope::TemplateParamScope)) && 1369 "Scope shouldn't contain decls!"); 1370 1371 for (Scope::decl_iterator I = S->decl_begin(), E = S->decl_end(); 1372 I != E; ++I) { 1373 Decl *TmpD = (*I); 1374 assert(TmpD && "This decl didn't get pushed??"); 1375 1376 assert(isa<NamedDecl>(TmpD) && "Decl isn't NamedDecl?"); 1377 NamedDecl *D = cast<NamedDecl>(TmpD); 1378 1379 if (!D->getDeclName()) continue; 1380 1381 // Diagnose unused variables in this scope. 1382 if (!S->hasUnrecoverableErrorOccurred()) 1383 DiagnoseUnusedDecl(D); 1384 1385 // If this was a forward reference to a label, verify it was defined. 1386 if (LabelDecl *LD = dyn_cast<LabelDecl>(D)) 1387 CheckPoppedLabel(LD, *this); 1388 1389 // Remove this name from our lexical scope. 1390 IdResolver.RemoveDecl(D); 1391 } 1392} 1393 1394void Sema::ActOnStartFunctionDeclarator() { 1395 ++InFunctionDeclarator; 1396} 1397 1398void Sema::ActOnEndFunctionDeclarator() { 1399 assert(InFunctionDeclarator); 1400 --InFunctionDeclarator; 1401} 1402 1403/// \brief Look for an Objective-C class in the translation unit. 1404/// 1405/// \param Id The name of the Objective-C class we're looking for. If 1406/// typo-correction fixes this name, the Id will be updated 1407/// to the fixed name. 1408/// 1409/// \param IdLoc The location of the name in the translation unit. 1410/// 1411/// \param DoTypoCorrection If true, this routine will attempt typo correction 1412/// if there is no class with the given name. 1413/// 1414/// \returns The declaration of the named Objective-C class, or NULL if the 1415/// class could not be found. 1416ObjCInterfaceDecl *Sema::getObjCInterfaceDecl(IdentifierInfo *&Id, 1417 SourceLocation IdLoc, 1418 bool DoTypoCorrection) { 1419 // The third "scope" argument is 0 since we aren't enabling lazy built-in 1420 // creation from this context. 1421 NamedDecl *IDecl = LookupSingleName(TUScope, Id, IdLoc, LookupOrdinaryName); 1422 1423 if (!IDecl && DoTypoCorrection) { 1424 // Perform typo correction at the given location, but only if we 1425 // find an Objective-C class name. 1426 DeclFilterCCC<ObjCInterfaceDecl> Validator; 1427 if (TypoCorrection C = CorrectTypo(DeclarationNameInfo(Id, IdLoc), 1428 LookupOrdinaryName, TUScope, NULL, 1429 Validator)) { 1430 diagnoseTypo(C, PDiag(diag::err_undef_interface_suggest) << Id); 1431 IDecl = C.getCorrectionDeclAs<ObjCInterfaceDecl>(); 1432 Id = IDecl->getIdentifier(); 1433 } 1434 } 1435 ObjCInterfaceDecl *Def = dyn_cast_or_null<ObjCInterfaceDecl>(IDecl); 1436 // This routine must always return a class definition, if any. 1437 if (Def && Def->getDefinition()) 1438 Def = Def->getDefinition(); 1439 return Def; 1440} 1441 1442/// getNonFieldDeclScope - Retrieves the innermost scope, starting 1443/// from S, where a non-field would be declared. This routine copes 1444/// with the difference between C and C++ scoping rules in structs and 1445/// unions. For example, the following code is well-formed in C but 1446/// ill-formed in C++: 1447/// @code 1448/// struct S6 { 1449/// enum { BAR } e; 1450/// }; 1451/// 1452/// void test_S6() { 1453/// struct S6 a; 1454/// a.e = BAR; 1455/// } 1456/// @endcode 1457/// For the declaration of BAR, this routine will return a different 1458/// scope. The scope S will be the scope of the unnamed enumeration 1459/// within S6. In C++, this routine will return the scope associated 1460/// with S6, because the enumeration's scope is a transparent 1461/// context but structures can contain non-field names. In C, this 1462/// routine will return the translation unit scope, since the 1463/// enumeration's scope is a transparent context and structures cannot 1464/// contain non-field names. 1465Scope *Sema::getNonFieldDeclScope(Scope *S) { 1466 while (((S->getFlags() & Scope::DeclScope) == 0) || 1467 (S->getEntity() && 1468 ((DeclContext *)S->getEntity())->isTransparentContext()) || 1469 (S->isClassScope() && !getLangOpts().CPlusPlus)) 1470 S = S->getParent(); 1471 return S; 1472} 1473 1474/// \brief Looks up the declaration of "struct objc_super" and 1475/// saves it for later use in building builtin declaration of 1476/// objc_msgSendSuper and objc_msgSendSuper_stret. If no such 1477/// pre-existing declaration exists no action takes place. 1478static void LookupPredefedObjCSuperType(Sema &ThisSema, Scope *S, 1479 IdentifierInfo *II) { 1480 if (!II->isStr("objc_msgSendSuper")) 1481 return; 1482 ASTContext &Context = ThisSema.Context; 1483 1484 LookupResult Result(ThisSema, &Context.Idents.get("objc_super"), 1485 SourceLocation(), Sema::LookupTagName); 1486 ThisSema.LookupName(Result, S); 1487 if (Result.getResultKind() == LookupResult::Found) 1488 if (const TagDecl *TD = Result.getAsSingle<TagDecl>()) 1489 Context.setObjCSuperType(Context.getTagDeclType(TD)); 1490} 1491 1492/// LazilyCreateBuiltin - The specified Builtin-ID was first used at 1493/// file scope. lazily create a decl for it. ForRedeclaration is true 1494/// if we're creating this built-in in anticipation of redeclaring the 1495/// built-in. 1496NamedDecl *Sema::LazilyCreateBuiltin(IdentifierInfo *II, unsigned bid, 1497 Scope *S, bool ForRedeclaration, 1498 SourceLocation Loc) { 1499 LookupPredefedObjCSuperType(*this, S, II); 1500 1501 Builtin::ID BID = (Builtin::ID)bid; 1502 1503 ASTContext::GetBuiltinTypeError Error; 1504 QualType R = Context.GetBuiltinType(BID, Error); 1505 switch (Error) { 1506 case ASTContext::GE_None: 1507 // Okay 1508 break; 1509 1510 case ASTContext::GE_Missing_stdio: 1511 if (ForRedeclaration) 1512 Diag(Loc, diag::warn_implicit_decl_requires_stdio) 1513 << Context.BuiltinInfo.GetName(BID); 1514 return 0; 1515 1516 case ASTContext::GE_Missing_setjmp: 1517 if (ForRedeclaration) 1518 Diag(Loc, diag::warn_implicit_decl_requires_setjmp) 1519 << Context.BuiltinInfo.GetName(BID); 1520 return 0; 1521 1522 case ASTContext::GE_Missing_ucontext: 1523 if (ForRedeclaration) 1524 Diag(Loc, diag::warn_implicit_decl_requires_ucontext) 1525 << Context.BuiltinInfo.GetName(BID); 1526 return 0; 1527 } 1528 1529 if (!ForRedeclaration && Context.BuiltinInfo.isPredefinedLibFunction(BID)) { 1530 Diag(Loc, diag::ext_implicit_lib_function_decl) 1531 << Context.BuiltinInfo.GetName(BID) 1532 << R; 1533 if (Context.BuiltinInfo.getHeaderName(BID) && 1534 Diags.getDiagnosticLevel(diag::ext_implicit_lib_function_decl, Loc) 1535 != DiagnosticsEngine::Ignored) 1536 Diag(Loc, diag::note_please_include_header) 1537 << Context.BuiltinInfo.getHeaderName(BID) 1538 << Context.BuiltinInfo.GetName(BID); 1539 } 1540 1541 FunctionDecl *New = FunctionDecl::Create(Context, 1542 Context.getTranslationUnitDecl(), 1543 Loc, Loc, II, R, /*TInfo=*/0, 1544 SC_Extern, 1545 false, 1546 /*hasPrototype=*/true); 1547 New->setImplicit(); 1548 1549 // Create Decl objects for each parameter, adding them to the 1550 // FunctionDecl. 1551 if (const FunctionProtoType *FT = dyn_cast<FunctionProtoType>(R)) { 1552 SmallVector<ParmVarDecl*, 16> Params; 1553 for (unsigned i = 0, e = FT->getNumArgs(); i != e; ++i) { 1554 ParmVarDecl *parm = 1555 ParmVarDecl::Create(Context, New, SourceLocation(), 1556 SourceLocation(), 0, 1557 FT->getArgType(i), /*TInfo=*/0, 1558 SC_None, 0); 1559 parm->setScopeInfo(0, i); 1560 Params.push_back(parm); 1561 } 1562 New->setParams(Params); 1563 } 1564 1565 AddKnownFunctionAttributes(New); 1566 1567 // TUScope is the translation-unit scope to insert this function into. 1568 // FIXME: This is hideous. We need to teach PushOnScopeChains to 1569 // relate Scopes to DeclContexts, and probably eliminate CurContext 1570 // entirely, but we're not there yet. 1571 DeclContext *SavedContext = CurContext; 1572 CurContext = Context.getTranslationUnitDecl(); 1573 PushOnScopeChains(New, TUScope); 1574 CurContext = SavedContext; 1575 return New; 1576} 1577 1578/// \brief Filter out any previous declarations that the given declaration 1579/// should not consider because they are not permitted to conflict, e.g., 1580/// because they come from hidden sub-modules and do not refer to the same 1581/// entity. 1582static void filterNonConflictingPreviousDecls(ASTContext &context, 1583 NamedDecl *decl, 1584 LookupResult &previous){ 1585 // This is only interesting when modules are enabled. 1586 if (!context.getLangOpts().Modules) 1587 return; 1588 1589 // Empty sets are uninteresting. 1590 if (previous.empty()) 1591 return; 1592 1593 LookupResult::Filter filter = previous.makeFilter(); 1594 while (filter.hasNext()) { 1595 NamedDecl *old = filter.next(); 1596 1597 // Non-hidden declarations are never ignored. 1598 if (!old->isHidden()) 1599 continue; 1600 1601 if (!old->isExternallyVisible()) 1602 filter.erase(); 1603 } 1604 1605 filter.done(); 1606} 1607 1608bool Sema::isIncompatibleTypedef(TypeDecl *Old, TypedefNameDecl *New) { 1609 QualType OldType; 1610 if (TypedefNameDecl *OldTypedef = dyn_cast<TypedefNameDecl>(Old)) 1611 OldType = OldTypedef->getUnderlyingType(); 1612 else 1613 OldType = Context.getTypeDeclType(Old); 1614 QualType NewType = New->getUnderlyingType(); 1615 1616 if (NewType->isVariablyModifiedType()) { 1617 // Must not redefine a typedef with a variably-modified type. 1618 int Kind = isa<TypeAliasDecl>(Old) ? 1 : 0; 1619 Diag(New->getLocation(), diag::err_redefinition_variably_modified_typedef) 1620 << Kind << NewType; 1621 if (Old->getLocation().isValid()) 1622 Diag(Old->getLocation(), diag::note_previous_definition); 1623 New->setInvalidDecl(); 1624 return true; 1625 } 1626 1627 if (OldType != NewType && 1628 !OldType->isDependentType() && 1629 !NewType->isDependentType() && 1630 !Context.hasSameType(OldType, NewType)) { 1631 int Kind = isa<TypeAliasDecl>(Old) ? 1 : 0; 1632 Diag(New->getLocation(), diag::err_redefinition_different_typedef) 1633 << Kind << NewType << OldType; 1634 if (Old->getLocation().isValid()) 1635 Diag(Old->getLocation(), diag::note_previous_definition); 1636 New->setInvalidDecl(); 1637 return true; 1638 } 1639 return false; 1640} 1641 1642/// MergeTypedefNameDecl - We just parsed a typedef 'New' which has the 1643/// same name and scope as a previous declaration 'Old'. Figure out 1644/// how to resolve this situation, merging decls or emitting 1645/// diagnostics as appropriate. If there was an error, set New to be invalid. 1646/// 1647void Sema::MergeTypedefNameDecl(TypedefNameDecl *New, LookupResult &OldDecls) { 1648 // If the new decl is known invalid already, don't bother doing any 1649 // merging checks. 1650 if (New->isInvalidDecl()) return; 1651 1652 // Allow multiple definitions for ObjC built-in typedefs. 1653 // FIXME: Verify the underlying types are equivalent! 1654 if (getLangOpts().ObjC1) { 1655 const IdentifierInfo *TypeID = New->getIdentifier(); 1656 switch (TypeID->getLength()) { 1657 default: break; 1658 case 2: 1659 { 1660 if (!TypeID->isStr("id")) 1661 break; 1662 QualType T = New->getUnderlyingType(); 1663 if (!T->isPointerType()) 1664 break; 1665 if (!T->isVoidPointerType()) { 1666 QualType PT = T->getAs<PointerType>()->getPointeeType(); 1667 if (!PT->isStructureType()) 1668 break; 1669 } 1670 Context.setObjCIdRedefinitionType(T); 1671 // Install the built-in type for 'id', ignoring the current definition. 1672 New->setTypeForDecl(Context.getObjCIdType().getTypePtr()); 1673 return; 1674 } 1675 case 5: 1676 if (!TypeID->isStr("Class")) 1677 break; 1678 Context.setObjCClassRedefinitionType(New->getUnderlyingType()); 1679 // Install the built-in type for 'Class', ignoring the current definition. 1680 New->setTypeForDecl(Context.getObjCClassType().getTypePtr()); 1681 return; 1682 case 3: 1683 if (!TypeID->isStr("SEL")) 1684 break; 1685 Context.setObjCSelRedefinitionType(New->getUnderlyingType()); 1686 // Install the built-in type for 'SEL', ignoring the current definition. 1687 New->setTypeForDecl(Context.getObjCSelType().getTypePtr()); 1688 return; 1689 } 1690 // Fall through - the typedef name was not a builtin type. 1691 } 1692 1693 // Verify the old decl was also a type. 1694 TypeDecl *Old = OldDecls.getAsSingle<TypeDecl>(); 1695 if (!Old) { 1696 Diag(New->getLocation(), diag::err_redefinition_different_kind) 1697 << New->getDeclName(); 1698 1699 NamedDecl *OldD = OldDecls.getRepresentativeDecl(); 1700 if (OldD->getLocation().isValid()) 1701 Diag(OldD->getLocation(), diag::note_previous_definition); 1702 1703 return New->setInvalidDecl(); 1704 } 1705 1706 // If the old declaration is invalid, just give up here. 1707 if (Old->isInvalidDecl()) 1708 return New->setInvalidDecl(); 1709 1710 // If the typedef types are not identical, reject them in all languages and 1711 // with any extensions enabled. 1712 if (isIncompatibleTypedef(Old, New)) 1713 return; 1714 1715 // The types match. Link up the redeclaration chain if the old 1716 // declaration was a typedef. 1717 if (TypedefNameDecl *Typedef = dyn_cast<TypedefNameDecl>(Old)) 1718 New->setPreviousDeclaration(Typedef); 1719 1720 mergeDeclAttributes(New, Old); 1721 1722 if (getLangOpts().MicrosoftExt) 1723 return; 1724 1725 if (getLangOpts().CPlusPlus) { 1726 // C++ [dcl.typedef]p2: 1727 // In a given non-class scope, a typedef specifier can be used to 1728 // redefine the name of any type declared in that scope to refer 1729 // to the type to which it already refers. 1730 if (!isa<CXXRecordDecl>(CurContext)) 1731 return; 1732 1733 // C++0x [dcl.typedef]p4: 1734 // In a given class scope, a typedef specifier can be used to redefine 1735 // any class-name declared in that scope that is not also a typedef-name 1736 // to refer to the type to which it already refers. 1737 // 1738 // This wording came in via DR424, which was a correction to the 1739 // wording in DR56, which accidentally banned code like: 1740 // 1741 // struct S { 1742 // typedef struct A { } A; 1743 // }; 1744 // 1745 // in the C++03 standard. We implement the C++0x semantics, which 1746 // allow the above but disallow 1747 // 1748 // struct S { 1749 // typedef int I; 1750 // typedef int I; 1751 // }; 1752 // 1753 // since that was the intent of DR56. 1754 if (!isa<TypedefNameDecl>(Old)) 1755 return; 1756 1757 Diag(New->getLocation(), diag::err_redefinition) 1758 << New->getDeclName(); 1759 Diag(Old->getLocation(), diag::note_previous_definition); 1760 return New->setInvalidDecl(); 1761 } 1762 1763 // Modules always permit redefinition of typedefs, as does C11. 1764 if (getLangOpts().Modules || getLangOpts().C11) 1765 return; 1766 1767 // If we have a redefinition of a typedef in C, emit a warning. This warning 1768 // is normally mapped to an error, but can be controlled with 1769 // -Wtypedef-redefinition. If either the original or the redefinition is 1770 // in a system header, don't emit this for compatibility with GCC. 1771 if (getDiagnostics().getSuppressSystemWarnings() && 1772 (Context.getSourceManager().isInSystemHeader(Old->getLocation()) || 1773 Context.getSourceManager().isInSystemHeader(New->getLocation()))) 1774 return; 1775 1776 Diag(New->getLocation(), diag::warn_redefinition_of_typedef) 1777 << New->getDeclName(); 1778 Diag(Old->getLocation(), diag::note_previous_definition); 1779 return; 1780} 1781 1782/// DeclhasAttr - returns true if decl Declaration already has the target 1783/// attribute. 1784static bool 1785DeclHasAttr(const Decl *D, const Attr *A) { 1786 // There can be multiple AvailabilityAttr in a Decl. Make sure we copy 1787 // all of them. It is mergeAvailabilityAttr in SemaDeclAttr.cpp that is 1788 // responsible for making sure they are consistent. 1789 const AvailabilityAttr *AA = dyn_cast<AvailabilityAttr>(A); 1790 if (AA) 1791 return false; 1792 1793 // The following thread safety attributes can also be duplicated. 1794 switch (A->getKind()) { 1795 case attr::ExclusiveLocksRequired: 1796 case attr::SharedLocksRequired: 1797 case attr::LocksExcluded: 1798 case attr::ExclusiveLockFunction: 1799 case attr::SharedLockFunction: 1800 case attr::UnlockFunction: 1801 case attr::ExclusiveTrylockFunction: 1802 case attr::SharedTrylockFunction: 1803 case attr::GuardedBy: 1804 case attr::PtGuardedBy: 1805 case attr::AcquiredBefore: 1806 case attr::AcquiredAfter: 1807 return false; 1808 default: 1809 ; 1810 } 1811 1812 const OwnershipAttr *OA = dyn_cast<OwnershipAttr>(A); 1813 const AnnotateAttr *Ann = dyn_cast<AnnotateAttr>(A); 1814 for (Decl::attr_iterator i = D->attr_begin(), e = D->attr_end(); i != e; ++i) 1815 if ((*i)->getKind() == A->getKind()) { 1816 if (Ann) { 1817 if (Ann->getAnnotation() == cast<AnnotateAttr>(*i)->getAnnotation()) 1818 return true; 1819 continue; 1820 } 1821 // FIXME: Don't hardcode this check 1822 if (OA && isa<OwnershipAttr>(*i)) 1823 return OA->getOwnKind() == cast<OwnershipAttr>(*i)->getOwnKind(); 1824 return true; 1825 } 1826 1827 return false; 1828} 1829 1830static bool isAttributeTargetADefinition(Decl *D) { 1831 if (VarDecl *VD = dyn_cast<VarDecl>(D)) 1832 return VD->isThisDeclarationADefinition(); 1833 if (TagDecl *TD = dyn_cast<TagDecl>(D)) 1834 return TD->isCompleteDefinition() || TD->isBeingDefined(); 1835 return true; 1836} 1837 1838/// Merge alignment attributes from \p Old to \p New, taking into account the 1839/// special semantics of C11's _Alignas specifier and C++11's alignas attribute. 1840/// 1841/// \return \c true if any attributes were added to \p New. 1842static bool mergeAlignedAttrs(Sema &S, NamedDecl *New, Decl *Old) { 1843 // Look for alignas attributes on Old, and pick out whichever attribute 1844 // specifies the strictest alignment requirement. 1845 AlignedAttr *OldAlignasAttr = 0; 1846 AlignedAttr *OldStrictestAlignAttr = 0; 1847 unsigned OldAlign = 0; 1848 for (specific_attr_iterator<AlignedAttr> 1849 I = Old->specific_attr_begin<AlignedAttr>(), 1850 E = Old->specific_attr_end<AlignedAttr>(); I != E; ++I) { 1851 // FIXME: We have no way of representing inherited dependent alignments 1852 // in a case like: 1853 // template<int A, int B> struct alignas(A) X; 1854 // template<int A, int B> struct alignas(B) X {}; 1855 // For now, we just ignore any alignas attributes which are not on the 1856 // definition in such a case. 1857 if (I->isAlignmentDependent()) 1858 return false; 1859 1860 if (I->isAlignas()) 1861 OldAlignasAttr = *I; 1862 1863 unsigned Align = I->getAlignment(S.Context); 1864 if (Align > OldAlign) { 1865 OldAlign = Align; 1866 OldStrictestAlignAttr = *I; 1867 } 1868 } 1869 1870 // Look for alignas attributes on New. 1871 AlignedAttr *NewAlignasAttr = 0; 1872 unsigned NewAlign = 0; 1873 for (specific_attr_iterator<AlignedAttr> 1874 I = New->specific_attr_begin<AlignedAttr>(), 1875 E = New->specific_attr_end<AlignedAttr>(); I != E; ++I) { 1876 if (I->isAlignmentDependent()) 1877 return false; 1878 1879 if (I->isAlignas()) 1880 NewAlignasAttr = *I; 1881 1882 unsigned Align = I->getAlignment(S.Context); 1883 if (Align > NewAlign) 1884 NewAlign = Align; 1885 } 1886 1887 if (OldAlignasAttr && NewAlignasAttr && OldAlign != NewAlign) { 1888 // Both declarations have 'alignas' attributes. We require them to match. 1889 // C++11 [dcl.align]p6 and C11 6.7.5/7 both come close to saying this, but 1890 // fall short. (If two declarations both have alignas, they must both match 1891 // every definition, and so must match each other if there is a definition.) 1892 1893 // If either declaration only contains 'alignas(0)' specifiers, then it 1894 // specifies the natural alignment for the type. 1895 if (OldAlign == 0 || NewAlign == 0) { 1896 QualType Ty; 1897 if (ValueDecl *VD = dyn_cast<ValueDecl>(New)) 1898 Ty = VD->getType(); 1899 else 1900 Ty = S.Context.getTagDeclType(cast<TagDecl>(New)); 1901 1902 if (OldAlign == 0) 1903 OldAlign = S.Context.getTypeAlign(Ty); 1904 if (NewAlign == 0) 1905 NewAlign = S.Context.getTypeAlign(Ty); 1906 } 1907 1908 if (OldAlign != NewAlign) { 1909 S.Diag(NewAlignasAttr->getLocation(), diag::err_alignas_mismatch) 1910 << (unsigned)S.Context.toCharUnitsFromBits(OldAlign).getQuantity() 1911 << (unsigned)S.Context.toCharUnitsFromBits(NewAlign).getQuantity(); 1912 S.Diag(OldAlignasAttr->getLocation(), diag::note_previous_declaration); 1913 } 1914 } 1915 1916 if (OldAlignasAttr && !NewAlignasAttr && isAttributeTargetADefinition(New)) { 1917 // C++11 [dcl.align]p6: 1918 // if any declaration of an entity has an alignment-specifier, 1919 // every defining declaration of that entity shall specify an 1920 // equivalent alignment. 1921 // C11 6.7.5/7: 1922 // If the definition of an object does not have an alignment 1923 // specifier, any other declaration of that object shall also 1924 // have no alignment specifier. 1925 S.Diag(New->getLocation(), diag::err_alignas_missing_on_definition) 1926 << OldAlignasAttr->isC11(); 1927 S.Diag(OldAlignasAttr->getLocation(), diag::note_alignas_on_declaration) 1928 << OldAlignasAttr->isC11(); 1929 } 1930 1931 bool AnyAdded = false; 1932 1933 // Ensure we have an attribute representing the strictest alignment. 1934 if (OldAlign > NewAlign) { 1935 AlignedAttr *Clone = OldStrictestAlignAttr->clone(S.Context); 1936 Clone->setInherited(true); 1937 New->addAttr(Clone); 1938 AnyAdded = true; 1939 } 1940 1941 // Ensure we have an alignas attribute if the old declaration had one. 1942 if (OldAlignasAttr && !NewAlignasAttr && 1943 !(AnyAdded && OldStrictestAlignAttr->isAlignas())) { 1944 AlignedAttr *Clone = OldAlignasAttr->clone(S.Context); 1945 Clone->setInherited(true); 1946 New->addAttr(Clone); 1947 AnyAdded = true; 1948 } 1949 1950 return AnyAdded; 1951} 1952 1953static bool mergeDeclAttribute(Sema &S, NamedDecl *D, InheritableAttr *Attr, 1954 bool Override) { 1955 InheritableAttr *NewAttr = NULL; 1956 unsigned AttrSpellingListIndex = Attr->getSpellingListIndex(); 1957 if (AvailabilityAttr *AA = dyn_cast<AvailabilityAttr>(Attr)) 1958 NewAttr = S.mergeAvailabilityAttr(D, AA->getRange(), AA->getPlatform(), 1959 AA->getIntroduced(), AA->getDeprecated(), 1960 AA->getObsoleted(), AA->getUnavailable(), 1961 AA->getMessage(), Override, 1962 AttrSpellingListIndex); 1963 else if (VisibilityAttr *VA = dyn_cast<VisibilityAttr>(Attr)) 1964 NewAttr = S.mergeVisibilityAttr(D, VA->getRange(), VA->getVisibility(), 1965 AttrSpellingListIndex); 1966 else if (TypeVisibilityAttr *VA = dyn_cast<TypeVisibilityAttr>(Attr)) 1967 NewAttr = S.mergeTypeVisibilityAttr(D, VA->getRange(), VA->getVisibility(), 1968 AttrSpellingListIndex); 1969 else if (DLLImportAttr *ImportA = dyn_cast<DLLImportAttr>(Attr)) 1970 NewAttr = S.mergeDLLImportAttr(D, ImportA->getRange(), 1971 AttrSpellingListIndex); 1972 else if (DLLExportAttr *ExportA = dyn_cast<DLLExportAttr>(Attr)) 1973 NewAttr = S.mergeDLLExportAttr(D, ExportA->getRange(), 1974 AttrSpellingListIndex); 1975 else if (FormatAttr *FA = dyn_cast<FormatAttr>(Attr)) 1976 NewAttr = S.mergeFormatAttr(D, FA->getRange(), FA->getType(), 1977 FA->getFormatIdx(), FA->getFirstArg(), 1978 AttrSpellingListIndex); 1979 else if (SectionAttr *SA = dyn_cast<SectionAttr>(Attr)) 1980 NewAttr = S.mergeSectionAttr(D, SA->getRange(), SA->getName(), 1981 AttrSpellingListIndex); 1982 else if (isa<AlignedAttr>(Attr)) 1983 // AlignedAttrs are handled separately, because we need to handle all 1984 // such attributes on a declaration at the same time. 1985 NewAttr = 0; 1986 else if (!DeclHasAttr(D, Attr)) 1987 NewAttr = cast<InheritableAttr>(Attr->clone(S.Context)); 1988 1989 if (NewAttr) { 1990 NewAttr->setInherited(true); 1991 D->addAttr(NewAttr); 1992 return true; 1993 } 1994 1995 return false; 1996} 1997 1998static const Decl *getDefinition(const Decl *D) { 1999 if (const TagDecl *TD = dyn_cast<TagDecl>(D)) 2000 return TD->getDefinition(); 2001 if (const VarDecl *VD = dyn_cast<VarDecl>(D)) 2002 return VD->getDefinition(); 2003 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) { 2004 const FunctionDecl* Def; 2005 if (FD->hasBody(Def)) 2006 return Def; 2007 } 2008 return NULL; 2009} 2010 2011static bool hasAttribute(const Decl *D, attr::Kind Kind) { 2012 for (Decl::attr_iterator I = D->attr_begin(), E = D->attr_end(); 2013 I != E; ++I) { 2014 Attr *Attribute = *I; 2015 if (Attribute->getKind() == Kind) 2016 return true; 2017 } 2018 return false; 2019} 2020 2021/// checkNewAttributesAfterDef - If we already have a definition, check that 2022/// there are no new attributes in this declaration. 2023static void checkNewAttributesAfterDef(Sema &S, Decl *New, const Decl *Old) { 2024 if (!New->hasAttrs()) 2025 return; 2026 2027 const Decl *Def = getDefinition(Old); 2028 if (!Def || Def == New) 2029 return; 2030 2031 AttrVec &NewAttributes = New->getAttrs(); 2032 for (unsigned I = 0, E = NewAttributes.size(); I != E;) { 2033 const Attr *NewAttribute = NewAttributes[I]; 2034 if (hasAttribute(Def, NewAttribute->getKind())) { 2035 ++I; 2036 continue; // regular attr merging will take care of validating this. 2037 } 2038 2039 if (isa<C11NoReturnAttr>(NewAttribute)) { 2040 // C's _Noreturn is allowed to be added to a function after it is defined. 2041 ++I; 2042 continue; 2043 } else if (const AlignedAttr *AA = dyn_cast<AlignedAttr>(NewAttribute)) { 2044 if (AA->isAlignas()) { 2045 // C++11 [dcl.align]p6: 2046 // if any declaration of an entity has an alignment-specifier, 2047 // every defining declaration of that entity shall specify an 2048 // equivalent alignment. 2049 // C11 6.7.5/7: 2050 // If the definition of an object does not have an alignment 2051 // specifier, any other declaration of that object shall also 2052 // have no alignment specifier. 2053 S.Diag(Def->getLocation(), diag::err_alignas_missing_on_definition) 2054 << AA->isC11(); 2055 S.Diag(NewAttribute->getLocation(), diag::note_alignas_on_declaration) 2056 << AA->isC11(); 2057 NewAttributes.erase(NewAttributes.begin() + I); 2058 --E; 2059 continue; 2060 } 2061 } 2062 2063 S.Diag(NewAttribute->getLocation(), 2064 diag::warn_attribute_precede_definition); 2065 S.Diag(Def->getLocation(), diag::note_previous_definition); 2066 NewAttributes.erase(NewAttributes.begin() + I); 2067 --E; 2068 } 2069} 2070 2071/// mergeDeclAttributes - Copy attributes from the Old decl to the New one. 2072void Sema::mergeDeclAttributes(NamedDecl *New, Decl *Old, 2073 AvailabilityMergeKind AMK) { 2074 if (!Old->hasAttrs() && !New->hasAttrs()) 2075 return; 2076 2077 // attributes declared post-definition are currently ignored 2078 checkNewAttributesAfterDef(*this, New, Old); 2079 2080 if (!Old->hasAttrs()) 2081 return; 2082 2083 bool foundAny = New->hasAttrs(); 2084 2085 // Ensure that any moving of objects within the allocated map is done before 2086 // we process them. 2087 if (!foundAny) New->setAttrs(AttrVec()); 2088 2089 for (specific_attr_iterator<InheritableAttr> 2090 i = Old->specific_attr_begin<InheritableAttr>(), 2091 e = Old->specific_attr_end<InheritableAttr>(); 2092 i != e; ++i) { 2093 bool Override = false; 2094 // Ignore deprecated/unavailable/availability attributes if requested. 2095 if (isa<DeprecatedAttr>(*i) || 2096 isa<UnavailableAttr>(*i) || 2097 isa<AvailabilityAttr>(*i)) { 2098 switch (AMK) { 2099 case AMK_None: 2100 continue; 2101 2102 case AMK_Redeclaration: 2103 break; 2104 2105 case AMK_Override: 2106 Override = true; 2107 break; 2108 } 2109 } 2110 2111 if (mergeDeclAttribute(*this, New, *i, Override)) 2112 foundAny = true; 2113 } 2114 2115 if (mergeAlignedAttrs(*this, New, Old)) 2116 foundAny = true; 2117 2118 if (!foundAny) New->dropAttrs(); 2119} 2120 2121/// mergeParamDeclAttributes - Copy attributes from the old parameter 2122/// to the new one. 2123static void mergeParamDeclAttributes(ParmVarDecl *newDecl, 2124 const ParmVarDecl *oldDecl, 2125 Sema &S) { 2126 // C++11 [dcl.attr.depend]p2: 2127 // The first declaration of a function shall specify the 2128 // carries_dependency attribute for its declarator-id if any declaration 2129 // of the function specifies the carries_dependency attribute. 2130 if (newDecl->hasAttr<CarriesDependencyAttr>() && 2131 !oldDecl->hasAttr<CarriesDependencyAttr>()) { 2132 S.Diag(newDecl->getAttr<CarriesDependencyAttr>()->getLocation(), 2133 diag::err_carries_dependency_missing_on_first_decl) << 1/*Param*/; 2134 // Find the first declaration of the parameter. 2135 // FIXME: Should we build redeclaration chains for function parameters? 2136 const FunctionDecl *FirstFD = 2137 cast<FunctionDecl>(oldDecl->getDeclContext())->getFirstDeclaration(); 2138 const ParmVarDecl *FirstVD = 2139 FirstFD->getParamDecl(oldDecl->getFunctionScopeIndex()); 2140 S.Diag(FirstVD->getLocation(), 2141 diag::note_carries_dependency_missing_first_decl) << 1/*Param*/; 2142 } 2143 2144 if (!oldDecl->hasAttrs()) 2145 return; 2146 2147 bool foundAny = newDecl->hasAttrs(); 2148 2149 // Ensure that any moving of objects within the allocated map is 2150 // done before we process them. 2151 if (!foundAny) newDecl->setAttrs(AttrVec()); 2152 2153 for (specific_attr_iterator<InheritableParamAttr> 2154 i = oldDecl->specific_attr_begin<InheritableParamAttr>(), 2155 e = oldDecl->specific_attr_end<InheritableParamAttr>(); i != e; ++i) { 2156 if (!DeclHasAttr(newDecl, *i)) { 2157 InheritableAttr *newAttr = 2158 cast<InheritableParamAttr>((*i)->clone(S.Context)); 2159 newAttr->setInherited(true); 2160 newDecl->addAttr(newAttr); 2161 foundAny = true; 2162 } 2163 } 2164 2165 if (!foundAny) newDecl->dropAttrs(); 2166} 2167 2168namespace { 2169 2170/// Used in MergeFunctionDecl to keep track of function parameters in 2171/// C. 2172struct GNUCompatibleParamWarning { 2173 ParmVarDecl *OldParm; 2174 ParmVarDecl *NewParm; 2175 QualType PromotedType; 2176}; 2177 2178} 2179 2180/// getSpecialMember - get the special member enum for a method. 2181Sema::CXXSpecialMember Sema::getSpecialMember(const CXXMethodDecl *MD) { 2182 if (const CXXConstructorDecl *Ctor = dyn_cast<CXXConstructorDecl>(MD)) { 2183 if (Ctor->isDefaultConstructor()) 2184 return Sema::CXXDefaultConstructor; 2185 2186 if (Ctor->isCopyConstructor()) 2187 return Sema::CXXCopyConstructor; 2188 2189 if (Ctor->isMoveConstructor()) 2190 return Sema::CXXMoveConstructor; 2191 } else if (isa<CXXDestructorDecl>(MD)) { 2192 return Sema::CXXDestructor; 2193 } else if (MD->isCopyAssignmentOperator()) { 2194 return Sema::CXXCopyAssignment; 2195 } else if (MD->isMoveAssignmentOperator()) { 2196 return Sema::CXXMoveAssignment; 2197 } 2198 2199 return Sema::CXXInvalid; 2200} 2201 2202/// canRedefineFunction - checks if a function can be redefined. Currently, 2203/// only extern inline functions can be redefined, and even then only in 2204/// GNU89 mode. 2205static bool canRedefineFunction(const FunctionDecl *FD, 2206 const LangOptions& LangOpts) { 2207 return ((FD->hasAttr<GNUInlineAttr>() || LangOpts.GNUInline) && 2208 !LangOpts.CPlusPlus && 2209 FD->isInlineSpecified() && 2210 FD->getStorageClass() == SC_Extern); 2211} 2212 2213const AttributedType *Sema::getCallingConvAttributedType(QualType T) const { 2214 const AttributedType *AT = T->getAs<AttributedType>(); 2215 while (AT && !AT->isCallingConv()) 2216 AT = AT->getModifiedType()->getAs<AttributedType>(); 2217 return AT; 2218} 2219 2220template <typename T> 2221static bool haveIncompatibleLanguageLinkages(const T *Old, const T *New) { 2222 const DeclContext *DC = Old->getDeclContext(); 2223 if (DC->isRecord()) 2224 return false; 2225 2226 LanguageLinkage OldLinkage = Old->getLanguageLinkage(); 2227 if (OldLinkage == CXXLanguageLinkage && New->isInExternCContext()) 2228 return true; 2229 if (OldLinkage == CLanguageLinkage && New->isInExternCXXContext()) 2230 return true; 2231 return false; 2232} 2233 2234/// MergeFunctionDecl - We just parsed a function 'New' from 2235/// declarator D which has the same name and scope as a previous 2236/// declaration 'Old'. Figure out how to resolve this situation, 2237/// merging decls or emitting diagnostics as appropriate. 2238/// 2239/// In C++, New and Old must be declarations that are not 2240/// overloaded. Use IsOverload to determine whether New and Old are 2241/// overloaded, and to select the Old declaration that New should be 2242/// merged with. 2243/// 2244/// Returns true if there was an error, false otherwise. 2245bool Sema::MergeFunctionDecl(FunctionDecl *New, Decl *OldD, Scope *S, 2246 bool MergeTypeWithOld) { 2247 // Verify the old decl was also a function. 2248 FunctionDecl *Old = 0; 2249 if (FunctionTemplateDecl *OldFunctionTemplate 2250 = dyn_cast<FunctionTemplateDecl>(OldD)) 2251 Old = OldFunctionTemplate->getTemplatedDecl(); 2252 else 2253 Old = dyn_cast<FunctionDecl>(OldD); 2254 if (!Old) { 2255 if (UsingShadowDecl *Shadow = dyn_cast<UsingShadowDecl>(OldD)) { 2256 if (New->getFriendObjectKind()) { 2257 Diag(New->getLocation(), diag::err_using_decl_friend); 2258 Diag(Shadow->getTargetDecl()->getLocation(), 2259 diag::note_using_decl_target); 2260 Diag(Shadow->getUsingDecl()->getLocation(), 2261 diag::note_using_decl) << 0; 2262 return true; 2263 } 2264 2265 Diag(New->getLocation(), diag::err_using_decl_conflict_reverse); 2266 Diag(Shadow->getTargetDecl()->getLocation(), 2267 diag::note_using_decl_target); 2268 Diag(Shadow->getUsingDecl()->getLocation(), 2269 diag::note_using_decl) << 0; 2270 return true; 2271 } 2272 2273 Diag(New->getLocation(), diag::err_redefinition_different_kind) 2274 << New->getDeclName(); 2275 Diag(OldD->getLocation(), diag::note_previous_definition); 2276 return true; 2277 } 2278 2279 // If the old declaration is invalid, just give up here. 2280 if (Old->isInvalidDecl()) 2281 return true; 2282 2283 // Determine whether the previous declaration was a definition, 2284 // implicit declaration, or a declaration. 2285 diag::kind PrevDiag; 2286 if (Old->isThisDeclarationADefinition()) 2287 PrevDiag = diag::note_previous_definition; 2288 else if (Old->isImplicit()) 2289 PrevDiag = diag::note_previous_implicit_declaration; 2290 else 2291 PrevDiag = diag::note_previous_declaration; 2292 2293 // Don't complain about this if we're in GNU89 mode and the old function 2294 // is an extern inline function. 2295 // Don't complain about specializations. They are not supposed to have 2296 // storage classes. 2297 if (!isa<CXXMethodDecl>(New) && !isa<CXXMethodDecl>(Old) && 2298 New->getStorageClass() == SC_Static && 2299 Old->hasExternalFormalLinkage() && 2300 !New->getTemplateSpecializationInfo() && 2301 !canRedefineFunction(Old, getLangOpts())) { 2302 if (getLangOpts().MicrosoftExt) { 2303 Diag(New->getLocation(), diag::warn_static_non_static) << New; 2304 Diag(Old->getLocation(), PrevDiag); 2305 } else { 2306 Diag(New->getLocation(), diag::err_static_non_static) << New; 2307 Diag(Old->getLocation(), PrevDiag); 2308 return true; 2309 } 2310 } 2311 2312 2313 // If a function is first declared with a calling convention, but is later 2314 // declared or defined without one, all following decls assume the calling 2315 // convention of the first. 2316 // 2317 // It's OK if a function is first declared without a calling convention, 2318 // but is later declared or defined with the default calling convention. 2319 // 2320 // To test if either decl has an explicit calling convention, we look for 2321 // AttributedType sugar nodes on the type as written. If they are missing or 2322 // were canonicalized away, we assume the calling convention was implicit. 2323 // 2324 // Note also that we DO NOT return at this point, because we still have 2325 // other tests to run. 2326 QualType OldQType = Context.getCanonicalType(Old->getType()); 2327 QualType NewQType = Context.getCanonicalType(New->getType()); 2328 const FunctionType *OldType = cast<FunctionType>(OldQType); 2329 const FunctionType *NewType = cast<FunctionType>(NewQType); 2330 FunctionType::ExtInfo OldTypeInfo = OldType->getExtInfo(); 2331 FunctionType::ExtInfo NewTypeInfo = NewType->getExtInfo(); 2332 bool RequiresAdjustment = false; 2333 2334 if (OldTypeInfo.getCC() != NewTypeInfo.getCC()) { 2335 FunctionDecl *First = Old->getFirstDeclaration(); 2336 const FunctionType *FT = 2337 First->getType().getCanonicalType()->castAs<FunctionType>(); 2338 FunctionType::ExtInfo FI = FT->getExtInfo(); 2339 bool NewCCExplicit = getCallingConvAttributedType(New->getType()); 2340 if (!NewCCExplicit) { 2341 // Inherit the CC from the previous declaration if it was specified 2342 // there but not here. 2343 NewTypeInfo = NewTypeInfo.withCallingConv(OldTypeInfo.getCC()); 2344 RequiresAdjustment = true; 2345 } else { 2346 // Calling conventions aren't compatible, so complain. 2347 bool FirstCCExplicit = getCallingConvAttributedType(First->getType()); 2348 Diag(New->getLocation(), diag::err_cconv_change) 2349 << FunctionType::getNameForCallConv(NewTypeInfo.getCC()) 2350 << !FirstCCExplicit 2351 << (!FirstCCExplicit ? "" : 2352 FunctionType::getNameForCallConv(FI.getCC())); 2353 2354 // Put the note on the first decl, since it is the one that matters. 2355 Diag(First->getLocation(), diag::note_previous_declaration); 2356 return true; 2357 } 2358 } 2359 2360 // FIXME: diagnose the other way around? 2361 if (OldTypeInfo.getNoReturn() && !NewTypeInfo.getNoReturn()) { 2362 NewTypeInfo = NewTypeInfo.withNoReturn(true); 2363 RequiresAdjustment = true; 2364 } 2365 2366 // Merge regparm attribute. 2367 if (OldTypeInfo.getHasRegParm() != NewTypeInfo.getHasRegParm() || 2368 OldTypeInfo.getRegParm() != NewTypeInfo.getRegParm()) { 2369 if (NewTypeInfo.getHasRegParm()) { 2370 Diag(New->getLocation(), diag::err_regparm_mismatch) 2371 << NewType->getRegParmType() 2372 << OldType->getRegParmType(); 2373 Diag(Old->getLocation(), diag::note_previous_declaration); 2374 return true; 2375 } 2376 2377 NewTypeInfo = NewTypeInfo.withRegParm(OldTypeInfo.getRegParm()); 2378 RequiresAdjustment = true; 2379 } 2380 2381 // Merge ns_returns_retained attribute. 2382 if (OldTypeInfo.getProducesResult() != NewTypeInfo.getProducesResult()) { 2383 if (NewTypeInfo.getProducesResult()) { 2384 Diag(New->getLocation(), diag::err_returns_retained_mismatch); 2385 Diag(Old->getLocation(), diag::note_previous_declaration); 2386 return true; 2387 } 2388 2389 NewTypeInfo = NewTypeInfo.withProducesResult(true); 2390 RequiresAdjustment = true; 2391 } 2392 2393 if (RequiresAdjustment) { 2394 const FunctionType *AdjustedType = New->getType()->getAs<FunctionType>(); 2395 AdjustedType = Context.adjustFunctionType(AdjustedType, NewTypeInfo); 2396 New->setType(QualType(AdjustedType, 0)); 2397 NewQType = Context.getCanonicalType(New->getType()); 2398 NewType = cast<FunctionType>(NewQType); 2399 } 2400 2401 // If this redeclaration makes the function inline, we may need to add it to 2402 // UndefinedButUsed. 2403 if (!Old->isInlined() && New->isInlined() && 2404 !New->hasAttr<GNUInlineAttr>() && 2405 (getLangOpts().CPlusPlus || !getLangOpts().GNUInline) && 2406 Old->isUsed(false) && 2407 !Old->isDefined() && !New->isThisDeclarationADefinition()) 2408 UndefinedButUsed.insert(std::make_pair(Old->getCanonicalDecl(), 2409 SourceLocation())); 2410 2411 // If this redeclaration makes it newly gnu_inline, we don't want to warn 2412 // about it. 2413 if (New->hasAttr<GNUInlineAttr>() && 2414 Old->isInlined() && !Old->hasAttr<GNUInlineAttr>()) { 2415 UndefinedButUsed.erase(Old->getCanonicalDecl()); 2416 } 2417 2418 if (getLangOpts().CPlusPlus) { 2419 // (C++98 13.1p2): 2420 // Certain function declarations cannot be overloaded: 2421 // -- Function declarations that differ only in the return type 2422 // cannot be overloaded. 2423 2424 // Go back to the type source info to compare the declared return types, 2425 // per C++1y [dcl.type.auto]p13: 2426 // Redeclarations or specializations of a function or function template 2427 // with a declared return type that uses a placeholder type shall also 2428 // use that placeholder, not a deduced type. 2429 QualType OldDeclaredReturnType = (Old->getTypeSourceInfo() 2430 ? Old->getTypeSourceInfo()->getType()->castAs<FunctionType>() 2431 : OldType)->getResultType(); 2432 QualType NewDeclaredReturnType = (New->getTypeSourceInfo() 2433 ? New->getTypeSourceInfo()->getType()->castAs<FunctionType>() 2434 : NewType)->getResultType(); 2435 QualType ResQT; 2436 if (!Context.hasSameType(OldDeclaredReturnType, NewDeclaredReturnType) && 2437 !((NewQType->isDependentType() || OldQType->isDependentType()) && 2438 New->isLocalExternDecl())) { 2439 if (NewDeclaredReturnType->isObjCObjectPointerType() && 2440 OldDeclaredReturnType->isObjCObjectPointerType()) 2441 ResQT = Context.mergeObjCGCQualifiers(NewQType, OldQType); 2442 if (ResQT.isNull()) { 2443 if (New->isCXXClassMember() && New->isOutOfLine()) 2444 Diag(New->getLocation(), 2445 diag::err_member_def_does_not_match_ret_type) << New; 2446 else 2447 Diag(New->getLocation(), diag::err_ovl_diff_return_type); 2448 Diag(Old->getLocation(), PrevDiag) << Old << Old->getType(); 2449 return true; 2450 } 2451 else 2452 NewQType = ResQT; 2453 } 2454 2455 QualType OldReturnType = OldType->getResultType(); 2456 QualType NewReturnType = cast<FunctionType>(NewQType)->getResultType(); 2457 if (OldReturnType != NewReturnType) { 2458 // If this function has a deduced return type and has already been 2459 // defined, copy the deduced value from the old declaration. 2460 AutoType *OldAT = Old->getResultType()->getContainedAutoType(); 2461 if (OldAT && OldAT->isDeduced()) { 2462 New->setType( 2463 SubstAutoType(New->getType(), 2464 OldAT->isDependentType() ? Context.DependentTy 2465 : OldAT->getDeducedType())); 2466 NewQType = Context.getCanonicalType( 2467 SubstAutoType(NewQType, 2468 OldAT->isDependentType() ? Context.DependentTy 2469 : OldAT->getDeducedType())); 2470 } 2471 } 2472 2473 const CXXMethodDecl *OldMethod = dyn_cast<CXXMethodDecl>(Old); 2474 CXXMethodDecl *NewMethod = dyn_cast<CXXMethodDecl>(New); 2475 if (OldMethod && NewMethod) { 2476 // Preserve triviality. 2477 NewMethod->setTrivial(OldMethod->isTrivial()); 2478 2479 // MSVC allows explicit template specialization at class scope: 2480 // 2 CXMethodDecls referring to the same function will be injected. 2481 // We don't want a redeclartion error. 2482 bool IsClassScopeExplicitSpecialization = 2483 OldMethod->isFunctionTemplateSpecialization() && 2484 NewMethod->isFunctionTemplateSpecialization(); 2485 bool isFriend = NewMethod->getFriendObjectKind(); 2486 2487 if (!isFriend && NewMethod->getLexicalDeclContext()->isRecord() && 2488 !IsClassScopeExplicitSpecialization) { 2489 // -- Member function declarations with the same name and the 2490 // same parameter types cannot be overloaded if any of them 2491 // is a static member function declaration. 2492 if (OldMethod->isStatic() != NewMethod->isStatic()) { 2493 Diag(New->getLocation(), diag::err_ovl_static_nonstatic_member); 2494 Diag(Old->getLocation(), PrevDiag) << Old << Old->getType(); 2495 return true; 2496 } 2497 2498 // C++ [class.mem]p1: 2499 // [...] A member shall not be declared twice in the 2500 // member-specification, except that a nested class or member 2501 // class template can be declared and then later defined. 2502 if (ActiveTemplateInstantiations.empty()) { 2503 unsigned NewDiag; 2504 if (isa<CXXConstructorDecl>(OldMethod)) 2505 NewDiag = diag::err_constructor_redeclared; 2506 else if (isa<CXXDestructorDecl>(NewMethod)) 2507 NewDiag = diag::err_destructor_redeclared; 2508 else if (isa<CXXConversionDecl>(NewMethod)) 2509 NewDiag = diag::err_conv_function_redeclared; 2510 else 2511 NewDiag = diag::err_member_redeclared; 2512 2513 Diag(New->getLocation(), NewDiag); 2514 } else { 2515 Diag(New->getLocation(), diag::err_member_redeclared_in_instantiation) 2516 << New << New->getType(); 2517 } 2518 Diag(Old->getLocation(), PrevDiag) << Old << Old->getType(); 2519 2520 // Complain if this is an explicit declaration of a special 2521 // member that was initially declared implicitly. 2522 // 2523 // As an exception, it's okay to befriend such methods in order 2524 // to permit the implicit constructor/destructor/operator calls. 2525 } else if (OldMethod->isImplicit()) { 2526 if (isFriend) { 2527 NewMethod->setImplicit(); 2528 } else { 2529 Diag(NewMethod->getLocation(), 2530 diag::err_definition_of_implicitly_declared_member) 2531 << New << getSpecialMember(OldMethod); 2532 return true; 2533 } 2534 } else if (OldMethod->isExplicitlyDefaulted() && !isFriend) { 2535 Diag(NewMethod->getLocation(), 2536 diag::err_definition_of_explicitly_defaulted_member) 2537 << getSpecialMember(OldMethod); 2538 return true; 2539 } 2540 } 2541 2542 // C++11 [dcl.attr.noreturn]p1: 2543 // The first declaration of a function shall specify the noreturn 2544 // attribute if any declaration of that function specifies the noreturn 2545 // attribute. 2546 if (New->hasAttr<CXX11NoReturnAttr>() && 2547 !Old->hasAttr<CXX11NoReturnAttr>()) { 2548 Diag(New->getAttr<CXX11NoReturnAttr>()->getLocation(), 2549 diag::err_noreturn_missing_on_first_decl); 2550 Diag(Old->getFirstDeclaration()->getLocation(), 2551 diag::note_noreturn_missing_first_decl); 2552 } 2553 2554 // C++11 [dcl.attr.depend]p2: 2555 // The first declaration of a function shall specify the 2556 // carries_dependency attribute for its declarator-id if any declaration 2557 // of the function specifies the carries_dependency attribute. 2558 if (New->hasAttr<CarriesDependencyAttr>() && 2559 !Old->hasAttr<CarriesDependencyAttr>()) { 2560 Diag(New->getAttr<CarriesDependencyAttr>()->getLocation(), 2561 diag::err_carries_dependency_missing_on_first_decl) << 0/*Function*/; 2562 Diag(Old->getFirstDeclaration()->getLocation(), 2563 diag::note_carries_dependency_missing_first_decl) << 0/*Function*/; 2564 } 2565 2566 // (C++98 8.3.5p3): 2567 // All declarations for a function shall agree exactly in both the 2568 // return type and the parameter-type-list. 2569 // We also want to respect all the extended bits except noreturn. 2570 2571 // noreturn should now match unless the old type info didn't have it. 2572 QualType OldQTypeForComparison = OldQType; 2573 if (!OldTypeInfo.getNoReturn() && NewTypeInfo.getNoReturn()) { 2574 assert(OldQType == QualType(OldType, 0)); 2575 const FunctionType *OldTypeForComparison 2576 = Context.adjustFunctionType(OldType, OldTypeInfo.withNoReturn(true)); 2577 OldQTypeForComparison = QualType(OldTypeForComparison, 0); 2578 assert(OldQTypeForComparison.isCanonical()); 2579 } 2580 2581 if (haveIncompatibleLanguageLinkages(Old, New)) { 2582 Diag(New->getLocation(), diag::err_different_language_linkage) << New; 2583 Diag(Old->getLocation(), PrevDiag); 2584 return true; 2585 } 2586 2587 if (OldQTypeForComparison == NewQType) 2588 return MergeCompatibleFunctionDecls(New, Old, S, MergeTypeWithOld); 2589 2590 if ((NewQType->isDependentType() || OldQType->isDependentType()) && 2591 New->isLocalExternDecl()) { 2592 // It's OK if we couldn't merge types for a local function declaraton 2593 // if either the old or new type is dependent. We'll merge the types 2594 // when we instantiate the function. 2595 return false; 2596 } 2597 2598 // Fall through for conflicting redeclarations and redefinitions. 2599 } 2600 2601 // C: Function types need to be compatible, not identical. This handles 2602 // duplicate function decls like "void f(int); void f(enum X);" properly. 2603 if (!getLangOpts().CPlusPlus && 2604 Context.typesAreCompatible(OldQType, NewQType)) { 2605 const FunctionType *OldFuncType = OldQType->getAs<FunctionType>(); 2606 const FunctionType *NewFuncType = NewQType->getAs<FunctionType>(); 2607 const FunctionProtoType *OldProto = 0; 2608 if (MergeTypeWithOld && isa<FunctionNoProtoType>(NewFuncType) && 2609 (OldProto = dyn_cast<FunctionProtoType>(OldFuncType))) { 2610 // The old declaration provided a function prototype, but the 2611 // new declaration does not. Merge in the prototype. 2612 assert(!OldProto->hasExceptionSpec() && "Exception spec in C"); 2613 SmallVector<QualType, 16> ParamTypes(OldProto->arg_type_begin(), 2614 OldProto->arg_type_end()); 2615 NewQType = Context.getFunctionType(NewFuncType->getResultType(), 2616 ParamTypes, 2617 OldProto->getExtProtoInfo()); 2618 New->setType(NewQType); 2619 New->setHasInheritedPrototype(); 2620 2621 // Synthesize a parameter for each argument type. 2622 SmallVector<ParmVarDecl*, 16> Params; 2623 for (FunctionProtoType::arg_type_iterator 2624 ParamType = OldProto->arg_type_begin(), 2625 ParamEnd = OldProto->arg_type_end(); 2626 ParamType != ParamEnd; ++ParamType) { 2627 ParmVarDecl *Param = ParmVarDecl::Create(Context, New, 2628 SourceLocation(), 2629 SourceLocation(), 0, 2630 *ParamType, /*TInfo=*/0, 2631 SC_None, 2632 0); 2633 Param->setScopeInfo(0, Params.size()); 2634 Param->setImplicit(); 2635 Params.push_back(Param); 2636 } 2637 2638 New->setParams(Params); 2639 } 2640 2641 return MergeCompatibleFunctionDecls(New, Old, S, MergeTypeWithOld); 2642 } 2643 2644 // GNU C permits a K&R definition to follow a prototype declaration 2645 // if the declared types of the parameters in the K&R definition 2646 // match the types in the prototype declaration, even when the 2647 // promoted types of the parameters from the K&R definition differ 2648 // from the types in the prototype. GCC then keeps the types from 2649 // the prototype. 2650 // 2651 // If a variadic prototype is followed by a non-variadic K&R definition, 2652 // the K&R definition becomes variadic. This is sort of an edge case, but 2653 // it's legal per the standard depending on how you read C99 6.7.5.3p15 and 2654 // C99 6.9.1p8. 2655 if (!getLangOpts().CPlusPlus && 2656 Old->hasPrototype() && !New->hasPrototype() && 2657 New->getType()->getAs<FunctionProtoType>() && 2658 Old->getNumParams() == New->getNumParams()) { 2659 SmallVector<QualType, 16> ArgTypes; 2660 SmallVector<GNUCompatibleParamWarning, 16> Warnings; 2661 const FunctionProtoType *OldProto 2662 = Old->getType()->getAs<FunctionProtoType>(); 2663 const FunctionProtoType *NewProto 2664 = New->getType()->getAs<FunctionProtoType>(); 2665 2666 // Determine whether this is the GNU C extension. 2667 QualType MergedReturn = Context.mergeTypes(OldProto->getResultType(), 2668 NewProto->getResultType()); 2669 bool LooseCompatible = !MergedReturn.isNull(); 2670 for (unsigned Idx = 0, End = Old->getNumParams(); 2671 LooseCompatible && Idx != End; ++Idx) { 2672 ParmVarDecl *OldParm = Old->getParamDecl(Idx); 2673 ParmVarDecl *NewParm = New->getParamDecl(Idx); 2674 if (Context.typesAreCompatible(OldParm->getType(), 2675 NewProto->getArgType(Idx))) { 2676 ArgTypes.push_back(NewParm->getType()); 2677 } else if (Context.typesAreCompatible(OldParm->getType(), 2678 NewParm->getType(), 2679 /*CompareUnqualified=*/true)) { 2680 GNUCompatibleParamWarning Warn 2681 = { OldParm, NewParm, NewProto->getArgType(Idx) }; 2682 Warnings.push_back(Warn); 2683 ArgTypes.push_back(NewParm->getType()); 2684 } else 2685 LooseCompatible = false; 2686 } 2687 2688 if (LooseCompatible) { 2689 for (unsigned Warn = 0; Warn < Warnings.size(); ++Warn) { 2690 Diag(Warnings[Warn].NewParm->getLocation(), 2691 diag::ext_param_promoted_not_compatible_with_prototype) 2692 << Warnings[Warn].PromotedType 2693 << Warnings[Warn].OldParm->getType(); 2694 if (Warnings[Warn].OldParm->getLocation().isValid()) 2695 Diag(Warnings[Warn].OldParm->getLocation(), 2696 diag::note_previous_declaration); 2697 } 2698 2699 if (MergeTypeWithOld) 2700 New->setType(Context.getFunctionType(MergedReturn, ArgTypes, 2701 OldProto->getExtProtoInfo())); 2702 return MergeCompatibleFunctionDecls(New, Old, S, MergeTypeWithOld); 2703 } 2704 2705 // Fall through to diagnose conflicting types. 2706 } 2707 2708 // A function that has already been declared has been redeclared or 2709 // defined with a different type; show an appropriate diagnostic. 2710 2711 // If the previous declaration was an implicitly-generated builtin 2712 // declaration, then at the very least we should use a specialized note. 2713 unsigned BuiltinID; 2714 if (Old->isImplicit() && (BuiltinID = Old->getBuiltinID())) { 2715 // If it's actually a library-defined builtin function like 'malloc' 2716 // or 'printf', just warn about the incompatible redeclaration. 2717 if (Context.BuiltinInfo.isPredefinedLibFunction(BuiltinID)) { 2718 Diag(New->getLocation(), diag::warn_redecl_library_builtin) << New; 2719 Diag(Old->getLocation(), diag::note_previous_builtin_declaration) 2720 << Old << Old->getType(); 2721 2722 // If this is a global redeclaration, just forget hereafter 2723 // about the "builtin-ness" of the function. 2724 // 2725 // Doing this for local extern declarations is problematic. If 2726 // the builtin declaration remains visible, a second invalid 2727 // local declaration will produce a hard error; if it doesn't 2728 // remain visible, a single bogus local redeclaration (which is 2729 // actually only a warning) could break all the downstream code. 2730 if (!New->getLexicalDeclContext()->isFunctionOrMethod()) 2731 New->getIdentifier()->setBuiltinID(Builtin::NotBuiltin); 2732 2733 return false; 2734 } 2735 2736 PrevDiag = diag::note_previous_builtin_declaration; 2737 } 2738 2739 Diag(New->getLocation(), diag::err_conflicting_types) << New->getDeclName(); 2740 Diag(Old->getLocation(), PrevDiag) << Old << Old->getType(); 2741 return true; 2742} 2743 2744/// \brief Completes the merge of two function declarations that are 2745/// known to be compatible. 2746/// 2747/// This routine handles the merging of attributes and other 2748/// properties of function declarations form the old declaration to 2749/// the new declaration, once we know that New is in fact a 2750/// redeclaration of Old. 2751/// 2752/// \returns false 2753bool Sema::MergeCompatibleFunctionDecls(FunctionDecl *New, FunctionDecl *Old, 2754 Scope *S, bool MergeTypeWithOld) { 2755 // Merge the attributes 2756 mergeDeclAttributes(New, Old); 2757 2758 // Merge "pure" flag. 2759 if (Old->isPure()) 2760 New->setPure(); 2761 2762 // Merge "used" flag. 2763 New->setIsUsed(Old->isUsed(false)); 2764 2765 // Merge attributes from the parameters. These can mismatch with K&R 2766 // declarations. 2767 if (New->getNumParams() == Old->getNumParams()) 2768 for (unsigned i = 0, e = New->getNumParams(); i != e; ++i) 2769 mergeParamDeclAttributes(New->getParamDecl(i), Old->getParamDecl(i), 2770 *this); 2771 2772 if (getLangOpts().CPlusPlus) 2773 return MergeCXXFunctionDecl(New, Old, S); 2774 2775 // Merge the function types so the we get the composite types for the return 2776 // and argument types. Per C11 6.2.7/4, only update the type if the old decl 2777 // was visible. 2778 QualType Merged = Context.mergeTypes(Old->getType(), New->getType()); 2779 if (!Merged.isNull() && MergeTypeWithOld) 2780 New->setType(Merged); 2781 2782 return false; 2783} 2784 2785 2786void Sema::mergeObjCMethodDecls(ObjCMethodDecl *newMethod, 2787 ObjCMethodDecl *oldMethod) { 2788 2789 // Merge the attributes, including deprecated/unavailable 2790 AvailabilityMergeKind MergeKind = 2791 isa<ObjCImplDecl>(newMethod->getDeclContext()) ? AMK_Redeclaration 2792 : AMK_Override; 2793 mergeDeclAttributes(newMethod, oldMethod, MergeKind); 2794 2795 // Merge attributes from the parameters. 2796 ObjCMethodDecl::param_const_iterator oi = oldMethod->param_begin(), 2797 oe = oldMethod->param_end(); 2798 for (ObjCMethodDecl::param_iterator 2799 ni = newMethod->param_begin(), ne = newMethod->param_end(); 2800 ni != ne && oi != oe; ++ni, ++oi) 2801 mergeParamDeclAttributes(*ni, *oi, *this); 2802 2803 CheckObjCMethodOverride(newMethod, oldMethod); 2804} 2805 2806/// MergeVarDeclTypes - We parsed a variable 'New' which has the same name and 2807/// scope as a previous declaration 'Old'. Figure out how to merge their types, 2808/// emitting diagnostics as appropriate. 2809/// 2810/// Declarations using the auto type specifier (C++ [decl.spec.auto]) call back 2811/// to here in AddInitializerToDecl. We can't check them before the initializer 2812/// is attached. 2813void Sema::MergeVarDeclTypes(VarDecl *New, VarDecl *Old, 2814 bool MergeTypeWithOld) { 2815 if (New->isInvalidDecl() || Old->isInvalidDecl()) 2816 return; 2817 2818 QualType MergedT; 2819 if (getLangOpts().CPlusPlus) { 2820 if (New->getType()->isUndeducedType()) { 2821 // We don't know what the new type is until the initializer is attached. 2822 return; 2823 } else if (Context.hasSameType(New->getType(), Old->getType())) { 2824 // These could still be something that needs exception specs checked. 2825 return MergeVarDeclExceptionSpecs(New, Old); 2826 } 2827 // C++ [basic.link]p10: 2828 // [...] the types specified by all declarations referring to a given 2829 // object or function shall be identical, except that declarations for an 2830 // array object can specify array types that differ by the presence or 2831 // absence of a major array bound (8.3.4). 2832 else if (Old->getType()->isIncompleteArrayType() && 2833 New->getType()->isArrayType()) { 2834 const ArrayType *OldArray = Context.getAsArrayType(Old->getType()); 2835 const ArrayType *NewArray = Context.getAsArrayType(New->getType()); 2836 if (Context.hasSameType(OldArray->getElementType(), 2837 NewArray->getElementType())) 2838 MergedT = New->getType(); 2839 } else if (Old->getType()->isArrayType() && 2840 New->getType()->isIncompleteArrayType()) { 2841 const ArrayType *OldArray = Context.getAsArrayType(Old->getType()); 2842 const ArrayType *NewArray = Context.getAsArrayType(New->getType()); 2843 if (Context.hasSameType(OldArray->getElementType(), 2844 NewArray->getElementType())) 2845 MergedT = Old->getType(); 2846 } else if (New->getType()->isObjCObjectPointerType() && 2847 Old->getType()->isObjCObjectPointerType()) { 2848 MergedT = Context.mergeObjCGCQualifiers(New->getType(), 2849 Old->getType()); 2850 } 2851 } else { 2852 // C 6.2.7p2: 2853 // All declarations that refer to the same object or function shall have 2854 // compatible type. 2855 MergedT = Context.mergeTypes(New->getType(), Old->getType()); 2856 } 2857 if (MergedT.isNull()) { 2858 // It's OK if we couldn't merge types if either type is dependent, for a 2859 // block-scope variable. In other cases (static data members of class 2860 // templates, variable templates, ...), we require the types to be 2861 // equivalent. 2862 // FIXME: The C++ standard doesn't say anything about this. 2863 if ((New->getType()->isDependentType() || 2864 Old->getType()->isDependentType()) && New->isLocalVarDecl()) { 2865 // If the old type was dependent, we can't merge with it, so the new type 2866 // becomes dependent for now. We'll reproduce the original type when we 2867 // instantiate the TypeSourceInfo for the variable. 2868 if (!New->getType()->isDependentType() && MergeTypeWithOld) 2869 New->setType(Context.DependentTy); 2870 return; 2871 } 2872 2873 // FIXME: Even if this merging succeeds, some other non-visible declaration 2874 // of this variable might have an incompatible type. For instance: 2875 // 2876 // extern int arr[]; 2877 // void f() { extern int arr[2]; } 2878 // void g() { extern int arr[3]; } 2879 // 2880 // Neither C nor C++ requires a diagnostic for this, but we should still try 2881 // to diagnose it. 2882 Diag(New->getLocation(), diag::err_redefinition_different_type) 2883 << New->getDeclName() << New->getType() << Old->getType(); 2884 Diag(Old->getLocation(), diag::note_previous_definition); 2885 return New->setInvalidDecl(); 2886 } 2887 2888 // Don't actually update the type on the new declaration if the old 2889 // declaration was an extern declaration in a different scope. 2890 if (MergeTypeWithOld) 2891 New->setType(MergedT); 2892} 2893 2894static bool mergeTypeWithPrevious(Sema &S, VarDecl *NewVD, VarDecl *OldVD, 2895 LookupResult &Previous) { 2896 // C11 6.2.7p4: 2897 // For an identifier with internal or external linkage declared 2898 // in a scope in which a prior declaration of that identifier is 2899 // visible, if the prior declaration specifies internal or 2900 // external linkage, the type of the identifier at the later 2901 // declaration becomes the composite type. 2902 // 2903 // If the variable isn't visible, we do not merge with its type. 2904 if (Previous.isShadowed()) 2905 return false; 2906 2907 if (S.getLangOpts().CPlusPlus) { 2908 // C++11 [dcl.array]p3: 2909 // If there is a preceding declaration of the entity in the same 2910 // scope in which the bound was specified, an omitted array bound 2911 // is taken to be the same as in that earlier declaration. 2912 return NewVD->isPreviousDeclInSameBlockScope() || 2913 (!OldVD->getLexicalDeclContext()->isFunctionOrMethod() && 2914 !NewVD->getLexicalDeclContext()->isFunctionOrMethod()); 2915 } else { 2916 // If the old declaration was function-local, don't merge with its 2917 // type unless we're in the same function. 2918 return !OldVD->getLexicalDeclContext()->isFunctionOrMethod() || 2919 OldVD->getLexicalDeclContext() == NewVD->getLexicalDeclContext(); 2920 } 2921} 2922 2923/// MergeVarDecl - We just parsed a variable 'New' which has the same name 2924/// and scope as a previous declaration 'Old'. Figure out how to resolve this 2925/// situation, merging decls or emitting diagnostics as appropriate. 2926/// 2927/// Tentative definition rules (C99 6.9.2p2) are checked by 2928/// FinalizeDeclaratorGroup. Unfortunately, we can't analyze tentative 2929/// definitions here, since the initializer hasn't been attached. 2930/// 2931void Sema::MergeVarDecl(VarDecl *New, LookupResult &Previous) { 2932 // If the new decl is already invalid, don't do any other checking. 2933 if (New->isInvalidDecl()) 2934 return; 2935 2936 // Verify the old decl was also a variable or variable template. 2937 VarDecl *Old = 0; 2938 if (Previous.isSingleResult() && 2939 (Old = dyn_cast<VarDecl>(Previous.getFoundDecl()))) { 2940 if (New->getDescribedVarTemplate()) 2941 Old = Old->getDescribedVarTemplate() ? Old : 0; 2942 else 2943 Old = Old->getDescribedVarTemplate() ? 0 : Old; 2944 } 2945 if (!Old) { 2946 Diag(New->getLocation(), diag::err_redefinition_different_kind) 2947 << New->getDeclName(); 2948 Diag(Previous.getRepresentativeDecl()->getLocation(), 2949 diag::note_previous_definition); 2950 return New->setInvalidDecl(); 2951 } 2952 2953 if (!shouldLinkPossiblyHiddenDecl(Old, New)) 2954 return; 2955 2956 // C++ [class.mem]p1: 2957 // A member shall not be declared twice in the member-specification [...] 2958 // 2959 // Here, we need only consider static data members. 2960 if (Old->isStaticDataMember() && !New->isOutOfLine()) { 2961 Diag(New->getLocation(), diag::err_duplicate_member) 2962 << New->getIdentifier(); 2963 Diag(Old->getLocation(), diag::note_previous_declaration); 2964 New->setInvalidDecl(); 2965 } 2966 2967 mergeDeclAttributes(New, Old); 2968 // Warn if an already-declared variable is made a weak_import in a subsequent 2969 // declaration 2970 if (New->getAttr<WeakImportAttr>() && 2971 Old->getStorageClass() == SC_None && 2972 !Old->getAttr<WeakImportAttr>()) { 2973 Diag(New->getLocation(), diag::warn_weak_import) << New->getDeclName(); 2974 Diag(Old->getLocation(), diag::note_previous_definition); 2975 // Remove weak_import attribute on new declaration. 2976 New->dropAttr<WeakImportAttr>(); 2977 } 2978 2979 // Merge the types. 2980 MergeVarDeclTypes(New, Old, mergeTypeWithPrevious(*this, New, Old, Previous)); 2981 2982 if (New->isInvalidDecl()) 2983 return; 2984 2985 // [dcl.stc]p8: Check if we have a non-static decl followed by a static. 2986 if (New->getStorageClass() == SC_Static && 2987 !New->isStaticDataMember() && 2988 Old->hasExternalFormalLinkage()) { 2989 Diag(New->getLocation(), diag::err_static_non_static) << New->getDeclName(); 2990 Diag(Old->getLocation(), diag::note_previous_definition); 2991 return New->setInvalidDecl(); 2992 } 2993 // C99 6.2.2p4: 2994 // For an identifier declared with the storage-class specifier 2995 // extern in a scope in which a prior declaration of that 2996 // identifier is visible,23) if the prior declaration specifies 2997 // internal or external linkage, the linkage of the identifier at 2998 // the later declaration is the same as the linkage specified at 2999 // the prior declaration. If no prior declaration is visible, or 3000 // if the prior declaration specifies no linkage, then the 3001 // identifier has external linkage. 3002 if (New->hasExternalStorage() && Old->hasLinkage()) 3003 /* Okay */; 3004 else if (New->getCanonicalDecl()->getStorageClass() != SC_Static && 3005 !New->isStaticDataMember() && 3006 Old->getCanonicalDecl()->getStorageClass() == SC_Static) { 3007 Diag(New->getLocation(), diag::err_non_static_static) << New->getDeclName(); 3008 Diag(Old->getLocation(), diag::note_previous_definition); 3009 return New->setInvalidDecl(); 3010 } 3011 3012 // Check if extern is followed by non-extern and vice-versa. 3013 if (New->hasExternalStorage() && 3014 !Old->hasLinkage() && Old->isLocalVarDecl()) { 3015 Diag(New->getLocation(), diag::err_extern_non_extern) << New->getDeclName(); 3016 Diag(Old->getLocation(), diag::note_previous_definition); 3017 return New->setInvalidDecl(); 3018 } 3019 if (Old->hasLinkage() && New->isLocalVarDecl() && 3020 !New->hasExternalStorage()) { 3021 Diag(New->getLocation(), diag::err_non_extern_extern) << New->getDeclName(); 3022 Diag(Old->getLocation(), diag::note_previous_definition); 3023 return New->setInvalidDecl(); 3024 } 3025 3026 // Variables with external linkage are analyzed in FinalizeDeclaratorGroup. 3027 3028 // FIXME: The test for external storage here seems wrong? We still 3029 // need to check for mismatches. 3030 if (!New->hasExternalStorage() && !New->isFileVarDecl() && 3031 // Don't complain about out-of-line definitions of static members. 3032 !(Old->getLexicalDeclContext()->isRecord() && 3033 !New->getLexicalDeclContext()->isRecord())) { 3034 Diag(New->getLocation(), diag::err_redefinition) << New->getDeclName(); 3035 Diag(Old->getLocation(), diag::note_previous_definition); 3036 return New->setInvalidDecl(); 3037 } 3038 3039 if (New->getTLSKind() != Old->getTLSKind()) { 3040 if (!Old->getTLSKind()) { 3041 Diag(New->getLocation(), diag::err_thread_non_thread) << New->getDeclName(); 3042 Diag(Old->getLocation(), diag::note_previous_declaration); 3043 } else if (!New->getTLSKind()) { 3044 Diag(New->getLocation(), diag::err_non_thread_thread) << New->getDeclName(); 3045 Diag(Old->getLocation(), diag::note_previous_declaration); 3046 } else { 3047 // Do not allow redeclaration to change the variable between requiring 3048 // static and dynamic initialization. 3049 // FIXME: GCC allows this, but uses the TLS keyword on the first 3050 // declaration to determine the kind. Do we need to be compatible here? 3051 Diag(New->getLocation(), diag::err_thread_thread_different_kind) 3052 << New->getDeclName() << (New->getTLSKind() == VarDecl::TLS_Dynamic); 3053 Diag(Old->getLocation(), diag::note_previous_declaration); 3054 } 3055 } 3056 3057 // C++ doesn't have tentative definitions, so go right ahead and check here. 3058 const VarDecl *Def; 3059 if (getLangOpts().CPlusPlus && 3060 New->isThisDeclarationADefinition() == VarDecl::Definition && 3061 (Def = Old->getDefinition())) { 3062 Diag(New->getLocation(), diag::err_redefinition) << New; 3063 Diag(Def->getLocation(), diag::note_previous_definition); 3064 New->setInvalidDecl(); 3065 return; 3066 } 3067 3068 if (haveIncompatibleLanguageLinkages(Old, New)) { 3069 Diag(New->getLocation(), diag::err_different_language_linkage) << New; 3070 Diag(Old->getLocation(), diag::note_previous_definition); 3071 New->setInvalidDecl(); 3072 return; 3073 } 3074 3075 // Merge "used" flag. 3076 New->setIsUsed(Old->isUsed(false)); 3077 3078 // Keep a chain of previous declarations. 3079 New->setPreviousDeclaration(Old); 3080 3081 // Inherit access appropriately. 3082 New->setAccess(Old->getAccess()); 3083 3084 if (VarTemplateDecl *VTD = New->getDescribedVarTemplate()) { 3085 if (New->isStaticDataMember() && New->isOutOfLine()) 3086 VTD->setAccess(New->getAccess()); 3087 } 3088} 3089 3090/// ParsedFreeStandingDeclSpec - This method is invoked when a declspec with 3091/// no declarator (e.g. "struct foo;") is parsed. 3092Decl *Sema::ParsedFreeStandingDeclSpec(Scope *S, AccessSpecifier AS, 3093 DeclSpec &DS) { 3094 return ParsedFreeStandingDeclSpec(S, AS, DS, MultiTemplateParamsArg()); 3095} 3096 3097static void HandleTagNumbering(Sema &S, const TagDecl *Tag) { 3098 if (!S.Context.getLangOpts().CPlusPlus) 3099 return; 3100 3101 if (isa<CXXRecordDecl>(Tag->getParent())) { 3102 // If this tag is the direct child of a class, number it if 3103 // it is anonymous. 3104 if (!Tag->getName().empty() || Tag->getTypedefNameForAnonDecl()) 3105 return; 3106 MangleNumberingContext &MCtx = 3107 S.Context.getManglingNumberContext(Tag->getParent()); 3108 S.Context.setManglingNumber(Tag, MCtx.getManglingNumber(Tag)); 3109 return; 3110 } 3111 3112 // If this tag isn't a direct child of a class, number it if it is local. 3113 Decl *ManglingContextDecl; 3114 if (MangleNumberingContext *MCtx = 3115 S.getCurrentMangleNumberContext(Tag->getDeclContext(), 3116 ManglingContextDecl)) { 3117 S.Context.setManglingNumber(Tag, MCtx->getManglingNumber(Tag)); 3118 } 3119} 3120 3121/// ParsedFreeStandingDeclSpec - This method is invoked when a declspec with 3122/// no declarator (e.g. "struct foo;") is parsed. It also accepts template 3123/// parameters to cope with template friend declarations. 3124Decl *Sema::ParsedFreeStandingDeclSpec(Scope *S, AccessSpecifier AS, 3125 DeclSpec &DS, 3126 MultiTemplateParamsArg TemplateParams, 3127 bool IsExplicitInstantiation) { 3128 Decl *TagD = 0; 3129 TagDecl *Tag = 0; 3130 if (DS.getTypeSpecType() == DeclSpec::TST_class || 3131 DS.getTypeSpecType() == DeclSpec::TST_struct || 3132 DS.getTypeSpecType() == DeclSpec::TST_interface || 3133 DS.getTypeSpecType() == DeclSpec::TST_union || 3134 DS.getTypeSpecType() == DeclSpec::TST_enum) { 3135 TagD = DS.getRepAsDecl(); 3136 3137 if (!TagD) // We probably had an error 3138 return 0; 3139 3140 // Note that the above type specs guarantee that the 3141 // type rep is a Decl, whereas in many of the others 3142 // it's a Type. 3143 if (isa<TagDecl>(TagD)) 3144 Tag = cast<TagDecl>(TagD); 3145 else if (ClassTemplateDecl *CTD = dyn_cast<ClassTemplateDecl>(TagD)) 3146 Tag = CTD->getTemplatedDecl(); 3147 } 3148 3149 if (Tag) { 3150 HandleTagNumbering(*this, Tag); 3151 Tag->setFreeStanding(); 3152 if (Tag->isInvalidDecl()) 3153 return Tag; 3154 } 3155 3156 if (unsigned TypeQuals = DS.getTypeQualifiers()) { 3157 // Enforce C99 6.7.3p2: "Types other than pointer types derived from object 3158 // or incomplete types shall not be restrict-qualified." 3159 if (TypeQuals & DeclSpec::TQ_restrict) 3160 Diag(DS.getRestrictSpecLoc(), 3161 diag::err_typecheck_invalid_restrict_not_pointer_noarg) 3162 << DS.getSourceRange(); 3163 } 3164 3165 if (DS.isConstexprSpecified()) { 3166 // C++0x [dcl.constexpr]p1: constexpr can only be applied to declarations 3167 // and definitions of functions and variables. 3168 if (Tag) 3169 Diag(DS.getConstexprSpecLoc(), diag::err_constexpr_tag) 3170 << (DS.getTypeSpecType() == DeclSpec::TST_class ? 0 : 3171 DS.getTypeSpecType() == DeclSpec::TST_struct ? 1 : 3172 DS.getTypeSpecType() == DeclSpec::TST_interface ? 2 : 3173 DS.getTypeSpecType() == DeclSpec::TST_union ? 3 : 4); 3174 else 3175 Diag(DS.getConstexprSpecLoc(), diag::err_constexpr_no_declarators); 3176 // Don't emit warnings after this error. 3177 return TagD; 3178 } 3179 3180 DiagnoseFunctionSpecifiers(DS); 3181 3182 if (DS.isFriendSpecified()) { 3183 // If we're dealing with a decl but not a TagDecl, assume that 3184 // whatever routines created it handled the friendship aspect. 3185 if (TagD && !Tag) 3186 return 0; 3187 return ActOnFriendTypeDecl(S, DS, TemplateParams); 3188 } 3189 3190 CXXScopeSpec &SS = DS.getTypeSpecScope(); 3191 bool IsExplicitSpecialization = 3192 !TemplateParams.empty() && TemplateParams.back()->size() == 0; 3193 if (Tag && SS.isNotEmpty() && !Tag->isCompleteDefinition() && 3194 !IsExplicitInstantiation && !IsExplicitSpecialization) { 3195 // Per C++ [dcl.type.elab]p1, a class declaration cannot have a 3196 // nested-name-specifier unless it is an explicit instantiation 3197 // or an explicit specialization. 3198 // Per C++ [dcl.enum]p1, an opaque-enum-declaration can't either. 3199 Diag(SS.getBeginLoc(), diag::err_standalone_class_nested_name_specifier) 3200 << (DS.getTypeSpecType() == DeclSpec::TST_class ? 0 : 3201 DS.getTypeSpecType() == DeclSpec::TST_struct ? 1 : 3202 DS.getTypeSpecType() == DeclSpec::TST_interface ? 2 : 3203 DS.getTypeSpecType() == DeclSpec::TST_union ? 3 : 4) 3204 << SS.getRange(); 3205 return 0; 3206 } 3207 3208 // Track whether this decl-specifier declares anything. 3209 bool DeclaresAnything = true; 3210 3211 // Handle anonymous struct definitions. 3212 if (RecordDecl *Record = dyn_cast_or_null<RecordDecl>(Tag)) { 3213 if (!Record->getDeclName() && Record->isCompleteDefinition() && 3214 DS.getStorageClassSpec() != DeclSpec::SCS_typedef) { 3215 if (getLangOpts().CPlusPlus || 3216 Record->getDeclContext()->isRecord()) 3217 return BuildAnonymousStructOrUnion(S, DS, AS, Record); 3218 3219 DeclaresAnything = false; 3220 } 3221 } 3222 3223 // Check for Microsoft C extension: anonymous struct member. 3224 if (getLangOpts().MicrosoftExt && !getLangOpts().CPlusPlus && 3225 CurContext->isRecord() && 3226 DS.getStorageClassSpec() == DeclSpec::SCS_unspecified) { 3227 // Handle 2 kinds of anonymous struct: 3228 // struct STRUCT; 3229 // and 3230 // STRUCT_TYPE; <- where STRUCT_TYPE is a typedef struct. 3231 RecordDecl *Record = dyn_cast_or_null<RecordDecl>(Tag); 3232 if ((Record && Record->getDeclName() && !Record->isCompleteDefinition()) || 3233 (DS.getTypeSpecType() == DeclSpec::TST_typename && 3234 DS.getRepAsType().get()->isStructureType())) { 3235 Diag(DS.getLocStart(), diag::ext_ms_anonymous_struct) 3236 << DS.getSourceRange(); 3237 return BuildMicrosoftCAnonymousStruct(S, DS, Record); 3238 } 3239 } 3240 3241 // Skip all the checks below if we have a type error. 3242 if (DS.getTypeSpecType() == DeclSpec::TST_error || 3243 (TagD && TagD->isInvalidDecl())) 3244 return TagD; 3245 3246 if (getLangOpts().CPlusPlus && 3247 DS.getStorageClassSpec() != DeclSpec::SCS_typedef) 3248 if (EnumDecl *Enum = dyn_cast_or_null<EnumDecl>(Tag)) 3249 if (Enum->enumerator_begin() == Enum->enumerator_end() && 3250 !Enum->getIdentifier() && !Enum->isInvalidDecl()) 3251 DeclaresAnything = false; 3252 3253 if (!DS.isMissingDeclaratorOk()) { 3254 // Customize diagnostic for a typedef missing a name. 3255 if (DS.getStorageClassSpec() == DeclSpec::SCS_typedef) 3256 Diag(DS.getLocStart(), diag::ext_typedef_without_a_name) 3257 << DS.getSourceRange(); 3258 else 3259 DeclaresAnything = false; 3260 } 3261 3262 if (DS.isModulePrivateSpecified() && 3263 Tag && Tag->getDeclContext()->isFunctionOrMethod()) 3264 Diag(DS.getModulePrivateSpecLoc(), diag::err_module_private_local_class) 3265 << Tag->getTagKind() 3266 << FixItHint::CreateRemoval(DS.getModulePrivateSpecLoc()); 3267 3268 ActOnDocumentableDecl(TagD); 3269 3270 // C 6.7/2: 3271 // A declaration [...] shall declare at least a declarator [...], a tag, 3272 // or the members of an enumeration. 3273 // C++ [dcl.dcl]p3: 3274 // [If there are no declarators], and except for the declaration of an 3275 // unnamed bit-field, the decl-specifier-seq shall introduce one or more 3276 // names into the program, or shall redeclare a name introduced by a 3277 // previous declaration. 3278 if (!DeclaresAnything) { 3279 // In C, we allow this as a (popular) extension / bug. Don't bother 3280 // producing further diagnostics for redundant qualifiers after this. 3281 Diag(DS.getLocStart(), diag::ext_no_declarators) << DS.getSourceRange(); 3282 return TagD; 3283 } 3284 3285 // C++ [dcl.stc]p1: 3286 // If a storage-class-specifier appears in a decl-specifier-seq, [...] the 3287 // init-declarator-list of the declaration shall not be empty. 3288 // C++ [dcl.fct.spec]p1: 3289 // If a cv-qualifier appears in a decl-specifier-seq, the 3290 // init-declarator-list of the declaration shall not be empty. 3291 // 3292 // Spurious qualifiers here appear to be valid in C. 3293 unsigned DiagID = diag::warn_standalone_specifier; 3294 if (getLangOpts().CPlusPlus) 3295 DiagID = diag::ext_standalone_specifier; 3296 3297 // Note that a linkage-specification sets a storage class, but 3298 // 'extern "C" struct foo;' is actually valid and not theoretically 3299 // useless. 3300 if (DeclSpec::SCS SCS = DS.getStorageClassSpec()) 3301 if (!DS.isExternInLinkageSpec() && SCS != DeclSpec::SCS_typedef) 3302 Diag(DS.getStorageClassSpecLoc(), DiagID) 3303 << DeclSpec::getSpecifierName(SCS); 3304 3305 if (DeclSpec::TSCS TSCS = DS.getThreadStorageClassSpec()) 3306 Diag(DS.getThreadStorageClassSpecLoc(), DiagID) 3307 << DeclSpec::getSpecifierName(TSCS); 3308 if (DS.getTypeQualifiers()) { 3309 if (DS.getTypeQualifiers() & DeclSpec::TQ_const) 3310 Diag(DS.getConstSpecLoc(), DiagID) << "const"; 3311 if (DS.getTypeQualifiers() & DeclSpec::TQ_volatile) 3312 Diag(DS.getConstSpecLoc(), DiagID) << "volatile"; 3313 // Restrict is covered above. 3314 if (DS.getTypeQualifiers() & DeclSpec::TQ_atomic) 3315 Diag(DS.getAtomicSpecLoc(), DiagID) << "_Atomic"; 3316 } 3317 3318 // Warn about ignored type attributes, for example: 3319 // __attribute__((aligned)) struct A; 3320 // Attributes should be placed after tag to apply to type declaration. 3321 if (!DS.getAttributes().empty()) { 3322 DeclSpec::TST TypeSpecType = DS.getTypeSpecType(); 3323 if (TypeSpecType == DeclSpec::TST_class || 3324 TypeSpecType == DeclSpec::TST_struct || 3325 TypeSpecType == DeclSpec::TST_interface || 3326 TypeSpecType == DeclSpec::TST_union || 3327 TypeSpecType == DeclSpec::TST_enum) { 3328 AttributeList* attrs = DS.getAttributes().getList(); 3329 while (attrs) { 3330 Diag(attrs->getLoc(), diag::warn_declspec_attribute_ignored) 3331 << attrs->getName() 3332 << (TypeSpecType == DeclSpec::TST_class ? 0 : 3333 TypeSpecType == DeclSpec::TST_struct ? 1 : 3334 TypeSpecType == DeclSpec::TST_union ? 2 : 3335 TypeSpecType == DeclSpec::TST_interface ? 3 : 4); 3336 attrs = attrs->getNext(); 3337 } 3338 } 3339 } 3340 3341 return TagD; 3342} 3343 3344/// We are trying to inject an anonymous member into the given scope; 3345/// check if there's an existing declaration that can't be overloaded. 3346/// 3347/// \return true if this is a forbidden redeclaration 3348static bool CheckAnonMemberRedeclaration(Sema &SemaRef, 3349 Scope *S, 3350 DeclContext *Owner, 3351 DeclarationName Name, 3352 SourceLocation NameLoc, 3353 unsigned diagnostic) { 3354 LookupResult R(SemaRef, Name, NameLoc, Sema::LookupMemberName, 3355 Sema::ForRedeclaration); 3356 if (!SemaRef.LookupName(R, S)) return false; 3357 3358 if (R.getAsSingle<TagDecl>()) 3359 return false; 3360 3361 // Pick a representative declaration. 3362 NamedDecl *PrevDecl = R.getRepresentativeDecl()->getUnderlyingDecl(); 3363 assert(PrevDecl && "Expected a non-null Decl"); 3364 3365 if (!SemaRef.isDeclInScope(PrevDecl, Owner, S)) 3366 return false; 3367 3368 SemaRef.Diag(NameLoc, diagnostic) << Name; 3369 SemaRef.Diag(PrevDecl->getLocation(), diag::note_previous_declaration); 3370 3371 return true; 3372} 3373 3374/// InjectAnonymousStructOrUnionMembers - Inject the members of the 3375/// anonymous struct or union AnonRecord into the owning context Owner 3376/// and scope S. This routine will be invoked just after we realize 3377/// that an unnamed union or struct is actually an anonymous union or 3378/// struct, e.g., 3379/// 3380/// @code 3381/// union { 3382/// int i; 3383/// float f; 3384/// }; // InjectAnonymousStructOrUnionMembers called here to inject i and 3385/// // f into the surrounding scope.x 3386/// @endcode 3387/// 3388/// This routine is recursive, injecting the names of nested anonymous 3389/// structs/unions into the owning context and scope as well. 3390static bool InjectAnonymousStructOrUnionMembers(Sema &SemaRef, Scope *S, 3391 DeclContext *Owner, 3392 RecordDecl *AnonRecord, 3393 AccessSpecifier AS, 3394 SmallVectorImpl<NamedDecl *> &Chaining, 3395 bool MSAnonStruct) { 3396 unsigned diagKind 3397 = AnonRecord->isUnion() ? diag::err_anonymous_union_member_redecl 3398 : diag::err_anonymous_struct_member_redecl; 3399 3400 bool Invalid = false; 3401 3402 // Look every FieldDecl and IndirectFieldDecl with a name. 3403 for (RecordDecl::decl_iterator D = AnonRecord->decls_begin(), 3404 DEnd = AnonRecord->decls_end(); 3405 D != DEnd; ++D) { 3406 if ((isa<FieldDecl>(*D) || isa<IndirectFieldDecl>(*D)) && 3407 cast<NamedDecl>(*D)->getDeclName()) { 3408 ValueDecl *VD = cast<ValueDecl>(*D); 3409 if (CheckAnonMemberRedeclaration(SemaRef, S, Owner, VD->getDeclName(), 3410 VD->getLocation(), diagKind)) { 3411 // C++ [class.union]p2: 3412 // The names of the members of an anonymous union shall be 3413 // distinct from the names of any other entity in the 3414 // scope in which the anonymous union is declared. 3415 Invalid = true; 3416 } else { 3417 // C++ [class.union]p2: 3418 // For the purpose of name lookup, after the anonymous union 3419 // definition, the members of the anonymous union are 3420 // considered to have been defined in the scope in which the 3421 // anonymous union is declared. 3422 unsigned OldChainingSize = Chaining.size(); 3423 if (IndirectFieldDecl *IF = dyn_cast<IndirectFieldDecl>(VD)) 3424 for (IndirectFieldDecl::chain_iterator PI = IF->chain_begin(), 3425 PE = IF->chain_end(); PI != PE; ++PI) 3426 Chaining.push_back(*PI); 3427 else 3428 Chaining.push_back(VD); 3429 3430 assert(Chaining.size() >= 2); 3431 NamedDecl **NamedChain = 3432 new (SemaRef.Context)NamedDecl*[Chaining.size()]; 3433 for (unsigned i = 0; i < Chaining.size(); i++) 3434 NamedChain[i] = Chaining[i]; 3435 3436 IndirectFieldDecl* IndirectField = 3437 IndirectFieldDecl::Create(SemaRef.Context, Owner, VD->getLocation(), 3438 VD->getIdentifier(), VD->getType(), 3439 NamedChain, Chaining.size()); 3440 3441 IndirectField->setAccess(AS); 3442 IndirectField->setImplicit(); 3443 SemaRef.PushOnScopeChains(IndirectField, S); 3444 3445 // That includes picking up the appropriate access specifier. 3446 if (AS != AS_none) IndirectField->setAccess(AS); 3447 3448 Chaining.resize(OldChainingSize); 3449 } 3450 } 3451 } 3452 3453 return Invalid; 3454} 3455 3456/// StorageClassSpecToVarDeclStorageClass - Maps a DeclSpec::SCS to 3457/// a VarDecl::StorageClass. Any error reporting is up to the caller: 3458/// illegal input values are mapped to SC_None. 3459static StorageClass 3460StorageClassSpecToVarDeclStorageClass(const DeclSpec &DS) { 3461 DeclSpec::SCS StorageClassSpec = DS.getStorageClassSpec(); 3462 assert(StorageClassSpec != DeclSpec::SCS_typedef && 3463 "Parser allowed 'typedef' as storage class VarDecl."); 3464 switch (StorageClassSpec) { 3465 case DeclSpec::SCS_unspecified: return SC_None; 3466 case DeclSpec::SCS_extern: 3467 if (DS.isExternInLinkageSpec()) 3468 return SC_None; 3469 return SC_Extern; 3470 case DeclSpec::SCS_static: return SC_Static; 3471 case DeclSpec::SCS_auto: return SC_Auto; 3472 case DeclSpec::SCS_register: return SC_Register; 3473 case DeclSpec::SCS_private_extern: return SC_PrivateExtern; 3474 // Illegal SCSs map to None: error reporting is up to the caller. 3475 case DeclSpec::SCS_mutable: // Fall through. 3476 case DeclSpec::SCS_typedef: return SC_None; 3477 } 3478 llvm_unreachable("unknown storage class specifier"); 3479} 3480 3481/// BuildAnonymousStructOrUnion - Handle the declaration of an 3482/// anonymous structure or union. Anonymous unions are a C++ feature 3483/// (C++ [class.union]) and a C11 feature; anonymous structures 3484/// are a C11 feature and GNU C++ extension. 3485Decl *Sema::BuildAnonymousStructOrUnion(Scope *S, DeclSpec &DS, 3486 AccessSpecifier AS, 3487 RecordDecl *Record) { 3488 DeclContext *Owner = Record->getDeclContext(); 3489 3490 // Diagnose whether this anonymous struct/union is an extension. 3491 if (Record->isUnion() && !getLangOpts().CPlusPlus && !getLangOpts().C11) 3492 Diag(Record->getLocation(), diag::ext_anonymous_union); 3493 else if (!Record->isUnion() && getLangOpts().CPlusPlus) 3494 Diag(Record->getLocation(), diag::ext_gnu_anonymous_struct); 3495 else if (!Record->isUnion() && !getLangOpts().C11) 3496 Diag(Record->getLocation(), diag::ext_c11_anonymous_struct); 3497 3498 // C and C++ require different kinds of checks for anonymous 3499 // structs/unions. 3500 bool Invalid = false; 3501 if (getLangOpts().CPlusPlus) { 3502 const char* PrevSpec = 0; 3503 unsigned DiagID; 3504 if (Record->isUnion()) { 3505 // C++ [class.union]p6: 3506 // Anonymous unions declared in a named namespace or in the 3507 // global namespace shall be declared static. 3508 if (DS.getStorageClassSpec() != DeclSpec::SCS_static && 3509 (isa<TranslationUnitDecl>(Owner) || 3510 (isa<NamespaceDecl>(Owner) && 3511 cast<NamespaceDecl>(Owner)->getDeclName()))) { 3512 Diag(Record->getLocation(), diag::err_anonymous_union_not_static) 3513 << FixItHint::CreateInsertion(Record->getLocation(), "static "); 3514 3515 // Recover by adding 'static'. 3516 DS.SetStorageClassSpec(*this, DeclSpec::SCS_static, SourceLocation(), 3517 PrevSpec, DiagID); 3518 } 3519 // C++ [class.union]p6: 3520 // A storage class is not allowed in a declaration of an 3521 // anonymous union in a class scope. 3522 else if (DS.getStorageClassSpec() != DeclSpec::SCS_unspecified && 3523 isa<RecordDecl>(Owner)) { 3524 Diag(DS.getStorageClassSpecLoc(), 3525 diag::err_anonymous_union_with_storage_spec) 3526 << FixItHint::CreateRemoval(DS.getStorageClassSpecLoc()); 3527 3528 // Recover by removing the storage specifier. 3529 DS.SetStorageClassSpec(*this, DeclSpec::SCS_unspecified, 3530 SourceLocation(), 3531 PrevSpec, DiagID); 3532 } 3533 } 3534 3535 // Ignore const/volatile/restrict qualifiers. 3536 if (DS.getTypeQualifiers()) { 3537 if (DS.getTypeQualifiers() & DeclSpec::TQ_const) 3538 Diag(DS.getConstSpecLoc(), diag::ext_anonymous_struct_union_qualified) 3539 << Record->isUnion() << "const" 3540 << FixItHint::CreateRemoval(DS.getConstSpecLoc()); 3541 if (DS.getTypeQualifiers() & DeclSpec::TQ_volatile) 3542 Diag(DS.getVolatileSpecLoc(), 3543 diag::ext_anonymous_struct_union_qualified) 3544 << Record->isUnion() << "volatile" 3545 << FixItHint::CreateRemoval(DS.getVolatileSpecLoc()); 3546 if (DS.getTypeQualifiers() & DeclSpec::TQ_restrict) 3547 Diag(DS.getRestrictSpecLoc(), 3548 diag::ext_anonymous_struct_union_qualified) 3549 << Record->isUnion() << "restrict" 3550 << FixItHint::CreateRemoval(DS.getRestrictSpecLoc()); 3551 if (DS.getTypeQualifiers() & DeclSpec::TQ_atomic) 3552 Diag(DS.getAtomicSpecLoc(), 3553 diag::ext_anonymous_struct_union_qualified) 3554 << Record->isUnion() << "_Atomic" 3555 << FixItHint::CreateRemoval(DS.getAtomicSpecLoc()); 3556 3557 DS.ClearTypeQualifiers(); 3558 } 3559 3560 // C++ [class.union]p2: 3561 // The member-specification of an anonymous union shall only 3562 // define non-static data members. [Note: nested types and 3563 // functions cannot be declared within an anonymous union. ] 3564 for (DeclContext::decl_iterator Mem = Record->decls_begin(), 3565 MemEnd = Record->decls_end(); 3566 Mem != MemEnd; ++Mem) { 3567 if (FieldDecl *FD = dyn_cast<FieldDecl>(*Mem)) { 3568 // C++ [class.union]p3: 3569 // An anonymous union shall not have private or protected 3570 // members (clause 11). 3571 assert(FD->getAccess() != AS_none); 3572 if (FD->getAccess() != AS_public) { 3573 Diag(FD->getLocation(), diag::err_anonymous_record_nonpublic_member) 3574 << (int)Record->isUnion() << (int)(FD->getAccess() == AS_protected); 3575 Invalid = true; 3576 } 3577 3578 // C++ [class.union]p1 3579 // An object of a class with a non-trivial constructor, a non-trivial 3580 // copy constructor, a non-trivial destructor, or a non-trivial copy 3581 // assignment operator cannot be a member of a union, nor can an 3582 // array of such objects. 3583 if (CheckNontrivialField(FD)) 3584 Invalid = true; 3585 } else if ((*Mem)->isImplicit()) { 3586 // Any implicit members are fine. 3587 } else if (isa<TagDecl>(*Mem) && (*Mem)->getDeclContext() != Record) { 3588 // This is a type that showed up in an 3589 // elaborated-type-specifier inside the anonymous struct or 3590 // union, but which actually declares a type outside of the 3591 // anonymous struct or union. It's okay. 3592 } else if (RecordDecl *MemRecord = dyn_cast<RecordDecl>(*Mem)) { 3593 if (!MemRecord->isAnonymousStructOrUnion() && 3594 MemRecord->getDeclName()) { 3595 // Visual C++ allows type definition in anonymous struct or union. 3596 if (getLangOpts().MicrosoftExt) 3597 Diag(MemRecord->getLocation(), diag::ext_anonymous_record_with_type) 3598 << (int)Record->isUnion(); 3599 else { 3600 // This is a nested type declaration. 3601 Diag(MemRecord->getLocation(), diag::err_anonymous_record_with_type) 3602 << (int)Record->isUnion(); 3603 Invalid = true; 3604 } 3605 } else { 3606 // This is an anonymous type definition within another anonymous type. 3607 // This is a popular extension, provided by Plan9, MSVC and GCC, but 3608 // not part of standard C++. 3609 Diag(MemRecord->getLocation(), 3610 diag::ext_anonymous_record_with_anonymous_type) 3611 << (int)Record->isUnion(); 3612 } 3613 } else if (isa<AccessSpecDecl>(*Mem)) { 3614 // Any access specifier is fine. 3615 } else { 3616 // We have something that isn't a non-static data 3617 // member. Complain about it. 3618 unsigned DK = diag::err_anonymous_record_bad_member; 3619 if (isa<TypeDecl>(*Mem)) 3620 DK = diag::err_anonymous_record_with_type; 3621 else if (isa<FunctionDecl>(*Mem)) 3622 DK = diag::err_anonymous_record_with_function; 3623 else if (isa<VarDecl>(*Mem)) 3624 DK = diag::err_anonymous_record_with_static; 3625 3626 // Visual C++ allows type definition in anonymous struct or union. 3627 if (getLangOpts().MicrosoftExt && 3628 DK == diag::err_anonymous_record_with_type) 3629 Diag((*Mem)->getLocation(), diag::ext_anonymous_record_with_type) 3630 << (int)Record->isUnion(); 3631 else { 3632 Diag((*Mem)->getLocation(), DK) 3633 << (int)Record->isUnion(); 3634 Invalid = true; 3635 } 3636 } 3637 } 3638 } 3639 3640 if (!Record->isUnion() && !Owner->isRecord()) { 3641 Diag(Record->getLocation(), diag::err_anonymous_struct_not_member) 3642 << (int)getLangOpts().CPlusPlus; 3643 Invalid = true; 3644 } 3645 3646 // Mock up a declarator. 3647 Declarator Dc(DS, Declarator::MemberContext); 3648 TypeSourceInfo *TInfo = GetTypeForDeclarator(Dc, S); 3649 assert(TInfo && "couldn't build declarator info for anonymous struct/union"); 3650 3651 // Create a declaration for this anonymous struct/union. 3652 NamedDecl *Anon = 0; 3653 if (RecordDecl *OwningClass = dyn_cast<RecordDecl>(Owner)) { 3654 Anon = FieldDecl::Create(Context, OwningClass, 3655 DS.getLocStart(), 3656 Record->getLocation(), 3657 /*IdentifierInfo=*/0, 3658 Context.getTypeDeclType(Record), 3659 TInfo, 3660 /*BitWidth=*/0, /*Mutable=*/false, 3661 /*InitStyle=*/ICIS_NoInit); 3662 Anon->setAccess(AS); 3663 if (getLangOpts().CPlusPlus) 3664 FieldCollector->Add(cast<FieldDecl>(Anon)); 3665 } else { 3666 DeclSpec::SCS SCSpec = DS.getStorageClassSpec(); 3667 VarDecl::StorageClass SC = StorageClassSpecToVarDeclStorageClass(DS); 3668 if (SCSpec == DeclSpec::SCS_mutable) { 3669 // mutable can only appear on non-static class members, so it's always 3670 // an error here 3671 Diag(Record->getLocation(), diag::err_mutable_nonmember); 3672 Invalid = true; 3673 SC = SC_None; 3674 } 3675 3676 Anon = VarDecl::Create(Context, Owner, 3677 DS.getLocStart(), 3678 Record->getLocation(), /*IdentifierInfo=*/0, 3679 Context.getTypeDeclType(Record), 3680 TInfo, SC); 3681 3682 // Default-initialize the implicit variable. This initialization will be 3683 // trivial in almost all cases, except if a union member has an in-class 3684 // initializer: 3685 // union { int n = 0; }; 3686 ActOnUninitializedDecl(Anon, /*TypeMayContainAuto=*/false); 3687 } 3688 Anon->setImplicit(); 3689 3690 // Add the anonymous struct/union object to the current 3691 // context. We'll be referencing this object when we refer to one of 3692 // its members. 3693 Owner->addDecl(Anon); 3694 3695 // Inject the members of the anonymous struct/union into the owning 3696 // context and into the identifier resolver chain for name lookup 3697 // purposes. 3698 SmallVector<NamedDecl*, 2> Chain; 3699 Chain.push_back(Anon); 3700 3701 if (InjectAnonymousStructOrUnionMembers(*this, S, Owner, Record, AS, 3702 Chain, false)) 3703 Invalid = true; 3704 3705 // Mark this as an anonymous struct/union type. Note that we do not 3706 // do this until after we have already checked and injected the 3707 // members of this anonymous struct/union type, because otherwise 3708 // the members could be injected twice: once by DeclContext when it 3709 // builds its lookup table, and once by 3710 // InjectAnonymousStructOrUnionMembers. 3711 Record->setAnonymousStructOrUnion(true); 3712 3713 if (Invalid) 3714 Anon->setInvalidDecl(); 3715 3716 return Anon; 3717} 3718 3719/// BuildMicrosoftCAnonymousStruct - Handle the declaration of an 3720/// Microsoft C anonymous structure. 3721/// Ref: http://msdn.microsoft.com/en-us/library/z2cx9y4f.aspx 3722/// Example: 3723/// 3724/// struct A { int a; }; 3725/// struct B { struct A; int b; }; 3726/// 3727/// void foo() { 3728/// B var; 3729/// var.a = 3; 3730/// } 3731/// 3732Decl *Sema::BuildMicrosoftCAnonymousStruct(Scope *S, DeclSpec &DS, 3733 RecordDecl *Record) { 3734 3735 // If there is no Record, get the record via the typedef. 3736 if (!Record) 3737 Record = DS.getRepAsType().get()->getAsStructureType()->getDecl(); 3738 3739 // Mock up a declarator. 3740 Declarator Dc(DS, Declarator::TypeNameContext); 3741 TypeSourceInfo *TInfo = GetTypeForDeclarator(Dc, S); 3742 assert(TInfo && "couldn't build declarator info for anonymous struct"); 3743 3744 // Create a declaration for this anonymous struct. 3745 NamedDecl* Anon = FieldDecl::Create(Context, 3746 cast<RecordDecl>(CurContext), 3747 DS.getLocStart(), 3748 DS.getLocStart(), 3749 /*IdentifierInfo=*/0, 3750 Context.getTypeDeclType(Record), 3751 TInfo, 3752 /*BitWidth=*/0, /*Mutable=*/false, 3753 /*InitStyle=*/ICIS_NoInit); 3754 Anon->setImplicit(); 3755 3756 // Add the anonymous struct object to the current context. 3757 CurContext->addDecl(Anon); 3758 3759 // Inject the members of the anonymous struct into the current 3760 // context and into the identifier resolver chain for name lookup 3761 // purposes. 3762 SmallVector<NamedDecl*, 2> Chain; 3763 Chain.push_back(Anon); 3764 3765 RecordDecl *RecordDef = Record->getDefinition(); 3766 if (!RecordDef || InjectAnonymousStructOrUnionMembers(*this, S, CurContext, 3767 RecordDef, AS_none, 3768 Chain, true)) 3769 Anon->setInvalidDecl(); 3770 3771 return Anon; 3772} 3773 3774/// GetNameForDeclarator - Determine the full declaration name for the 3775/// given Declarator. 3776DeclarationNameInfo Sema::GetNameForDeclarator(Declarator &D) { 3777 return GetNameFromUnqualifiedId(D.getName()); 3778} 3779 3780/// \brief Retrieves the declaration name from a parsed unqualified-id. 3781DeclarationNameInfo 3782Sema::GetNameFromUnqualifiedId(const UnqualifiedId &Name) { 3783 DeclarationNameInfo NameInfo; 3784 NameInfo.setLoc(Name.StartLocation); 3785 3786 switch (Name.getKind()) { 3787 3788 case UnqualifiedId::IK_ImplicitSelfParam: 3789 case UnqualifiedId::IK_Identifier: 3790 NameInfo.setName(Name.Identifier); 3791 NameInfo.setLoc(Name.StartLocation); 3792 return NameInfo; 3793 3794 case UnqualifiedId::IK_OperatorFunctionId: 3795 NameInfo.setName(Context.DeclarationNames.getCXXOperatorName( 3796 Name.OperatorFunctionId.Operator)); 3797 NameInfo.setLoc(Name.StartLocation); 3798 NameInfo.getInfo().CXXOperatorName.BeginOpNameLoc 3799 = Name.OperatorFunctionId.SymbolLocations[0]; 3800 NameInfo.getInfo().CXXOperatorName.EndOpNameLoc 3801 = Name.EndLocation.getRawEncoding(); 3802 return NameInfo; 3803 3804 case UnqualifiedId::IK_LiteralOperatorId: 3805 NameInfo.setName(Context.DeclarationNames.getCXXLiteralOperatorName( 3806 Name.Identifier)); 3807 NameInfo.setLoc(Name.StartLocation); 3808 NameInfo.setCXXLiteralOperatorNameLoc(Name.EndLocation); 3809 return NameInfo; 3810 3811 case UnqualifiedId::IK_ConversionFunctionId: { 3812 TypeSourceInfo *TInfo; 3813 QualType Ty = GetTypeFromParser(Name.ConversionFunctionId, &TInfo); 3814 if (Ty.isNull()) 3815 return DeclarationNameInfo(); 3816 NameInfo.setName(Context.DeclarationNames.getCXXConversionFunctionName( 3817 Context.getCanonicalType(Ty))); 3818 NameInfo.setLoc(Name.StartLocation); 3819 NameInfo.setNamedTypeInfo(TInfo); 3820 return NameInfo; 3821 } 3822 3823 case UnqualifiedId::IK_ConstructorName: { 3824 TypeSourceInfo *TInfo; 3825 QualType Ty = GetTypeFromParser(Name.ConstructorName, &TInfo); 3826 if (Ty.isNull()) 3827 return DeclarationNameInfo(); 3828 NameInfo.setName(Context.DeclarationNames.getCXXConstructorName( 3829 Context.getCanonicalType(Ty))); 3830 NameInfo.setLoc(Name.StartLocation); 3831 NameInfo.setNamedTypeInfo(TInfo); 3832 return NameInfo; 3833 } 3834 3835 case UnqualifiedId::IK_ConstructorTemplateId: { 3836 // In well-formed code, we can only have a constructor 3837 // template-id that refers to the current context, so go there 3838 // to find the actual type being constructed. 3839 CXXRecordDecl *CurClass = dyn_cast<CXXRecordDecl>(CurContext); 3840 if (!CurClass || CurClass->getIdentifier() != Name.TemplateId->Name) 3841 return DeclarationNameInfo(); 3842 3843 // Determine the type of the class being constructed. 3844 QualType CurClassType = Context.getTypeDeclType(CurClass); 3845 3846 // FIXME: Check two things: that the template-id names the same type as 3847 // CurClassType, and that the template-id does not occur when the name 3848 // was qualified. 3849 3850 NameInfo.setName(Context.DeclarationNames.getCXXConstructorName( 3851 Context.getCanonicalType(CurClassType))); 3852 NameInfo.setLoc(Name.StartLocation); 3853 // FIXME: should we retrieve TypeSourceInfo? 3854 NameInfo.setNamedTypeInfo(0); 3855 return NameInfo; 3856 } 3857 3858 case UnqualifiedId::IK_DestructorName: { 3859 TypeSourceInfo *TInfo; 3860 QualType Ty = GetTypeFromParser(Name.DestructorName, &TInfo); 3861 if (Ty.isNull()) 3862 return DeclarationNameInfo(); 3863 NameInfo.setName(Context.DeclarationNames.getCXXDestructorName( 3864 Context.getCanonicalType(Ty))); 3865 NameInfo.setLoc(Name.StartLocation); 3866 NameInfo.setNamedTypeInfo(TInfo); 3867 return NameInfo; 3868 } 3869 3870 case UnqualifiedId::IK_TemplateId: { 3871 TemplateName TName = Name.TemplateId->Template.get(); 3872 SourceLocation TNameLoc = Name.TemplateId->TemplateNameLoc; 3873 return Context.getNameForTemplate(TName, TNameLoc); 3874 } 3875 3876 } // switch (Name.getKind()) 3877 3878 llvm_unreachable("Unknown name kind"); 3879} 3880 3881static QualType getCoreType(QualType Ty) { 3882 do { 3883 if (Ty->isPointerType() || Ty->isReferenceType()) 3884 Ty = Ty->getPointeeType(); 3885 else if (Ty->isArrayType()) 3886 Ty = Ty->castAsArrayTypeUnsafe()->getElementType(); 3887 else 3888 return Ty.withoutLocalFastQualifiers(); 3889 } while (true); 3890} 3891 3892/// hasSimilarParameters - Determine whether the C++ functions Declaration 3893/// and Definition have "nearly" matching parameters. This heuristic is 3894/// used to improve diagnostics in the case where an out-of-line function 3895/// definition doesn't match any declaration within the class or namespace. 3896/// Also sets Params to the list of indices to the parameters that differ 3897/// between the declaration and the definition. If hasSimilarParameters 3898/// returns true and Params is empty, then all of the parameters match. 3899static bool hasSimilarParameters(ASTContext &Context, 3900 FunctionDecl *Declaration, 3901 FunctionDecl *Definition, 3902 SmallVectorImpl<unsigned> &Params) { 3903 Params.clear(); 3904 if (Declaration->param_size() != Definition->param_size()) 3905 return false; 3906 for (unsigned Idx = 0; Idx < Declaration->param_size(); ++Idx) { 3907 QualType DeclParamTy = Declaration->getParamDecl(Idx)->getType(); 3908 QualType DefParamTy = Definition->getParamDecl(Idx)->getType(); 3909 3910 // The parameter types are identical 3911 if (Context.hasSameType(DefParamTy, DeclParamTy)) 3912 continue; 3913 3914 QualType DeclParamBaseTy = getCoreType(DeclParamTy); 3915 QualType DefParamBaseTy = getCoreType(DefParamTy); 3916 const IdentifierInfo *DeclTyName = DeclParamBaseTy.getBaseTypeIdentifier(); 3917 const IdentifierInfo *DefTyName = DefParamBaseTy.getBaseTypeIdentifier(); 3918 3919 if (Context.hasSameUnqualifiedType(DeclParamBaseTy, DefParamBaseTy) || 3920 (DeclTyName && DeclTyName == DefTyName)) 3921 Params.push_back(Idx); 3922 else // The two parameters aren't even close 3923 return false; 3924 } 3925 3926 return true; 3927} 3928 3929/// NeedsRebuildingInCurrentInstantiation - Checks whether the given 3930/// declarator needs to be rebuilt in the current instantiation. 3931/// Any bits of declarator which appear before the name are valid for 3932/// consideration here. That's specifically the type in the decl spec 3933/// and the base type in any member-pointer chunks. 3934static bool RebuildDeclaratorInCurrentInstantiation(Sema &S, Declarator &D, 3935 DeclarationName Name) { 3936 // The types we specifically need to rebuild are: 3937 // - typenames, typeofs, and decltypes 3938 // - types which will become injected class names 3939 // Of course, we also need to rebuild any type referencing such a 3940 // type. It's safest to just say "dependent", but we call out a 3941 // few cases here. 3942 3943 DeclSpec &DS = D.getMutableDeclSpec(); 3944 switch (DS.getTypeSpecType()) { 3945 case DeclSpec::TST_typename: 3946 case DeclSpec::TST_typeofType: 3947 case DeclSpec::TST_underlyingType: 3948 case DeclSpec::TST_atomic: { 3949 // Grab the type from the parser. 3950 TypeSourceInfo *TSI = 0; 3951 QualType T = S.GetTypeFromParser(DS.getRepAsType(), &TSI); 3952 if (T.isNull() || !T->isDependentType()) break; 3953 3954 // Make sure there's a type source info. This isn't really much 3955 // of a waste; most dependent types should have type source info 3956 // attached already. 3957 if (!TSI) 3958 TSI = S.Context.getTrivialTypeSourceInfo(T, DS.getTypeSpecTypeLoc()); 3959 3960 // Rebuild the type in the current instantiation. 3961 TSI = S.RebuildTypeInCurrentInstantiation(TSI, D.getIdentifierLoc(), Name); 3962 if (!TSI) return true; 3963 3964 // Store the new type back in the decl spec. 3965 ParsedType LocType = S.CreateParsedType(TSI->getType(), TSI); 3966 DS.UpdateTypeRep(LocType); 3967 break; 3968 } 3969 3970 case DeclSpec::TST_decltype: 3971 case DeclSpec::TST_typeofExpr: { 3972 Expr *E = DS.getRepAsExpr(); 3973 ExprResult Result = S.RebuildExprInCurrentInstantiation(E); 3974 if (Result.isInvalid()) return true; 3975 DS.UpdateExprRep(Result.get()); 3976 break; 3977 } 3978 3979 default: 3980 // Nothing to do for these decl specs. 3981 break; 3982 } 3983 3984 // It doesn't matter what order we do this in. 3985 for (unsigned I = 0, E = D.getNumTypeObjects(); I != E; ++I) { 3986 DeclaratorChunk &Chunk = D.getTypeObject(I); 3987 3988 // The only type information in the declarator which can come 3989 // before the declaration name is the base type of a member 3990 // pointer. 3991 if (Chunk.Kind != DeclaratorChunk::MemberPointer) 3992 continue; 3993 3994 // Rebuild the scope specifier in-place. 3995 CXXScopeSpec &SS = Chunk.Mem.Scope(); 3996 if (S.RebuildNestedNameSpecifierInCurrentInstantiation(SS)) 3997 return true; 3998 } 3999 4000 return false; 4001} 4002 4003Decl *Sema::ActOnDeclarator(Scope *S, Declarator &D) { 4004 D.setFunctionDefinitionKind(FDK_Declaration); 4005 Decl *Dcl = HandleDeclarator(S, D, MultiTemplateParamsArg()); 4006 4007 if (OriginalLexicalContext && OriginalLexicalContext->isObjCContainer() && 4008 Dcl && Dcl->getDeclContext()->isFileContext()) 4009 Dcl->setTopLevelDeclInObjCContainer(); 4010 4011 return Dcl; 4012} 4013 4014/// DiagnoseClassNameShadow - Implement C++ [class.mem]p13: 4015/// If T is the name of a class, then each of the following shall have a 4016/// name different from T: 4017/// - every static data member of class T; 4018/// - every member function of class T 4019/// - every member of class T that is itself a type; 4020/// \returns true if the declaration name violates these rules. 4021bool Sema::DiagnoseClassNameShadow(DeclContext *DC, 4022 DeclarationNameInfo NameInfo) { 4023 DeclarationName Name = NameInfo.getName(); 4024 4025 if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(DC)) 4026 if (Record->getIdentifier() && Record->getDeclName() == Name) { 4027 Diag(NameInfo.getLoc(), diag::err_member_name_of_class) << Name; 4028 return true; 4029 } 4030 4031 return false; 4032} 4033 4034/// \brief Diagnose a declaration whose declarator-id has the given 4035/// nested-name-specifier. 4036/// 4037/// \param SS The nested-name-specifier of the declarator-id. 4038/// 4039/// \param DC The declaration context to which the nested-name-specifier 4040/// resolves. 4041/// 4042/// \param Name The name of the entity being declared. 4043/// 4044/// \param Loc The location of the name of the entity being declared. 4045/// 4046/// \returns true if we cannot safely recover from this error, false otherwise. 4047bool Sema::diagnoseQualifiedDeclaration(CXXScopeSpec &SS, DeclContext *DC, 4048 DeclarationName Name, 4049 SourceLocation Loc) { 4050 DeclContext *Cur = CurContext; 4051 while (isa<LinkageSpecDecl>(Cur) || isa<CapturedDecl>(Cur)) 4052 Cur = Cur->getParent(); 4053 4054 // C++ [dcl.meaning]p1: 4055 // A declarator-id shall not be qualified except for the definition 4056 // of a member function (9.3) or static data member (9.4) outside of 4057 // its class, the definition or explicit instantiation of a function 4058 // or variable member of a namespace outside of its namespace, or the 4059 // definition of an explicit specialization outside of its namespace, 4060 // or the declaration of a friend function that is a member of 4061 // another class or namespace (11.3). [...] 4062 4063 // The user provided a superfluous scope specifier that refers back to the 4064 // class or namespaces in which the entity is already declared. 4065 // 4066 // class X { 4067 // void X::f(); 4068 // }; 4069 if (Cur->Equals(DC)) { 4070 Diag(Loc, LangOpts.MicrosoftExt? diag::warn_member_extra_qualification 4071 : diag::err_member_extra_qualification) 4072 << Name << FixItHint::CreateRemoval(SS.getRange()); 4073 SS.clear(); 4074 return false; 4075 } 4076 4077 // Check whether the qualifying scope encloses the scope of the original 4078 // declaration. 4079 if (!Cur->Encloses(DC)) { 4080 if (Cur->isRecord()) 4081 Diag(Loc, diag::err_member_qualification) 4082 << Name << SS.getRange(); 4083 else if (isa<TranslationUnitDecl>(DC)) 4084 Diag(Loc, diag::err_invalid_declarator_global_scope) 4085 << Name << SS.getRange(); 4086 else if (isa<FunctionDecl>(Cur)) 4087 Diag(Loc, diag::err_invalid_declarator_in_function) 4088 << Name << SS.getRange(); 4089 else if (isa<BlockDecl>(Cur)) 4090 Diag(Loc, diag::err_invalid_declarator_in_block) 4091 << Name << SS.getRange(); 4092 else 4093 Diag(Loc, diag::err_invalid_declarator_scope) 4094 << Name << cast<NamedDecl>(Cur) << cast<NamedDecl>(DC) << SS.getRange(); 4095 4096 return true; 4097 } 4098 4099 if (Cur->isRecord()) { 4100 // Cannot qualify members within a class. 4101 Diag(Loc, diag::err_member_qualification) 4102 << Name << SS.getRange(); 4103 SS.clear(); 4104 4105 // C++ constructors and destructors with incorrect scopes can break 4106 // our AST invariants by having the wrong underlying types. If 4107 // that's the case, then drop this declaration entirely. 4108 if ((Name.getNameKind() == DeclarationName::CXXConstructorName || 4109 Name.getNameKind() == DeclarationName::CXXDestructorName) && 4110 !Context.hasSameType(Name.getCXXNameType(), 4111 Context.getTypeDeclType(cast<CXXRecordDecl>(Cur)))) 4112 return true; 4113 4114 return false; 4115 } 4116 4117 // C++11 [dcl.meaning]p1: 4118 // [...] "The nested-name-specifier of the qualified declarator-id shall 4119 // not begin with a decltype-specifer" 4120 NestedNameSpecifierLoc SpecLoc(SS.getScopeRep(), SS.location_data()); 4121 while (SpecLoc.getPrefix()) 4122 SpecLoc = SpecLoc.getPrefix(); 4123 if (dyn_cast_or_null<DecltypeType>( 4124 SpecLoc.getNestedNameSpecifier()->getAsType())) 4125 Diag(Loc, diag::err_decltype_in_declarator) 4126 << SpecLoc.getTypeLoc().getSourceRange(); 4127 4128 return false; 4129} 4130 4131NamedDecl *Sema::HandleDeclarator(Scope *S, Declarator &D, 4132 MultiTemplateParamsArg TemplateParamLists) { 4133 // TODO: consider using NameInfo for diagnostic. 4134 DeclarationNameInfo NameInfo = GetNameForDeclarator(D); 4135 DeclarationName Name = NameInfo.getName(); 4136 4137 // All of these full declarators require an identifier. If it doesn't have 4138 // one, the ParsedFreeStandingDeclSpec action should be used. 4139 if (!Name) { 4140 if (!D.isInvalidType()) // Reject this if we think it is valid. 4141 Diag(D.getDeclSpec().getLocStart(), 4142 diag::err_declarator_need_ident) 4143 << D.getDeclSpec().getSourceRange() << D.getSourceRange(); 4144 return 0; 4145 } else if (DiagnoseUnexpandedParameterPack(NameInfo, UPPC_DeclarationType)) 4146 return 0; 4147 4148 // The scope passed in may not be a decl scope. Zip up the scope tree until 4149 // we find one that is. 4150 while ((S->getFlags() & Scope::DeclScope) == 0 || 4151 (S->getFlags() & Scope::TemplateParamScope) != 0) 4152 S = S->getParent(); 4153 4154 DeclContext *DC = CurContext; 4155 if (D.getCXXScopeSpec().isInvalid()) 4156 D.setInvalidType(); 4157 else if (D.getCXXScopeSpec().isSet()) { 4158 if (DiagnoseUnexpandedParameterPack(D.getCXXScopeSpec(), 4159 UPPC_DeclarationQualifier)) 4160 return 0; 4161 4162 bool EnteringContext = !D.getDeclSpec().isFriendSpecified(); 4163 DC = computeDeclContext(D.getCXXScopeSpec(), EnteringContext); 4164 if (!DC) { 4165 // If we could not compute the declaration context, it's because the 4166 // declaration context is dependent but does not refer to a class, 4167 // class template, or class template partial specialization. Complain 4168 // and return early, to avoid the coming semantic disaster. 4169 Diag(D.getIdentifierLoc(), 4170 diag::err_template_qualified_declarator_no_match) 4171 << (NestedNameSpecifier*)D.getCXXScopeSpec().getScopeRep() 4172 << D.getCXXScopeSpec().getRange(); 4173 return 0; 4174 } 4175 bool IsDependentContext = DC->isDependentContext(); 4176 4177 if (!IsDependentContext && 4178 RequireCompleteDeclContext(D.getCXXScopeSpec(), DC)) 4179 return 0; 4180 4181 if (isa<CXXRecordDecl>(DC) && !cast<CXXRecordDecl>(DC)->hasDefinition()) { 4182 Diag(D.getIdentifierLoc(), 4183 diag::err_member_def_undefined_record) 4184 << Name << DC << D.getCXXScopeSpec().getRange(); 4185 D.setInvalidType(); 4186 } else if (!D.getDeclSpec().isFriendSpecified()) { 4187 if (diagnoseQualifiedDeclaration(D.getCXXScopeSpec(), DC, 4188 Name, D.getIdentifierLoc())) { 4189 if (DC->isRecord()) 4190 return 0; 4191 4192 D.setInvalidType(); 4193 } 4194 } 4195 4196 // Check whether we need to rebuild the type of the given 4197 // declaration in the current instantiation. 4198 if (EnteringContext && IsDependentContext && 4199 TemplateParamLists.size() != 0) { 4200 ContextRAII SavedContext(*this, DC); 4201 if (RebuildDeclaratorInCurrentInstantiation(*this, D, Name)) 4202 D.setInvalidType(); 4203 } 4204 } 4205 4206 if (DiagnoseClassNameShadow(DC, NameInfo)) 4207 // If this is a typedef, we'll end up spewing multiple diagnostics. 4208 // Just return early; it's safer. 4209 if (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_typedef) 4210 return 0; 4211 4212 TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S); 4213 QualType R = TInfo->getType(); 4214 4215 if (DiagnoseUnexpandedParameterPack(D.getIdentifierLoc(), TInfo, 4216 UPPC_DeclarationType)) 4217 D.setInvalidType(); 4218 4219 LookupResult Previous(*this, NameInfo, LookupOrdinaryName, 4220 ForRedeclaration); 4221 4222 // See if this is a redefinition of a variable in the same scope. 4223 if (!D.getCXXScopeSpec().isSet()) { 4224 bool IsLinkageLookup = false; 4225 bool CreateBuiltins = false; 4226 4227 // If the declaration we're planning to build will be a function 4228 // or object with linkage, then look for another declaration with 4229 // linkage (C99 6.2.2p4-5 and C++ [basic.link]p6). 4230 // 4231 // If the declaration we're planning to build will be declared with 4232 // external linkage in the translation unit, create any builtin with 4233 // the same name. 4234 if (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_typedef) 4235 /* Do nothing*/; 4236 else if (CurContext->isFunctionOrMethod() && 4237 (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_extern || 4238 R->isFunctionType())) { 4239 IsLinkageLookup = true; 4240 CreateBuiltins = 4241 CurContext->getEnclosingNamespaceContext()->isTranslationUnit(); 4242 } else if (CurContext->getRedeclContext()->isTranslationUnit() && 4243 D.getDeclSpec().getStorageClassSpec() != DeclSpec::SCS_static) 4244 CreateBuiltins = true; 4245 4246 if (IsLinkageLookup) 4247 Previous.clear(LookupRedeclarationWithLinkage); 4248 4249 LookupName(Previous, S, CreateBuiltins); 4250 } else { // Something like "int foo::x;" 4251 LookupQualifiedName(Previous, DC); 4252 4253 // C++ [dcl.meaning]p1: 4254 // When the declarator-id is qualified, the declaration shall refer to a 4255 // previously declared member of the class or namespace to which the 4256 // qualifier refers (or, in the case of a namespace, of an element of the 4257 // inline namespace set of that namespace (7.3.1)) or to a specialization 4258 // thereof; [...] 4259 // 4260 // Note that we already checked the context above, and that we do not have 4261 // enough information to make sure that Previous contains the declaration 4262 // we want to match. For example, given: 4263 // 4264 // class X { 4265 // void f(); 4266 // void f(float); 4267 // }; 4268 // 4269 // void X::f(int) { } // ill-formed 4270 // 4271 // In this case, Previous will point to the overload set 4272 // containing the two f's declared in X, but neither of them 4273 // matches. 4274 4275 // C++ [dcl.meaning]p1: 4276 // [...] the member shall not merely have been introduced by a 4277 // using-declaration in the scope of the class or namespace nominated by 4278 // the nested-name-specifier of the declarator-id. 4279 RemoveUsingDecls(Previous); 4280 } 4281 4282 if (Previous.isSingleResult() && 4283 Previous.getFoundDecl()->isTemplateParameter()) { 4284 // Maybe we will complain about the shadowed template parameter. 4285 if (!D.isInvalidType()) 4286 DiagnoseTemplateParameterShadow(D.getIdentifierLoc(), 4287 Previous.getFoundDecl()); 4288 4289 // Just pretend that we didn't see the previous declaration. 4290 Previous.clear(); 4291 } 4292 4293 // In C++, the previous declaration we find might be a tag type 4294 // (class or enum). In this case, the new declaration will hide the 4295 // tag type. Note that this does does not apply if we're declaring a 4296 // typedef (C++ [dcl.typedef]p4). 4297 if (Previous.isSingleTagDecl() && 4298 D.getDeclSpec().getStorageClassSpec() != DeclSpec::SCS_typedef) 4299 Previous.clear(); 4300 4301 // Check that there are no default arguments other than in the parameters 4302 // of a function declaration (C++ only). 4303 if (getLangOpts().CPlusPlus) 4304 CheckExtraCXXDefaultArguments(D); 4305 4306 NamedDecl *New; 4307 4308 bool AddToScope = true; 4309 if (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_typedef) { 4310 if (TemplateParamLists.size()) { 4311 Diag(D.getIdentifierLoc(), diag::err_template_typedef); 4312 return 0; 4313 } 4314 4315 New = ActOnTypedefDeclarator(S, D, DC, TInfo, Previous); 4316 } else if (R->isFunctionType()) { 4317 New = ActOnFunctionDeclarator(S, D, DC, TInfo, Previous, 4318 TemplateParamLists, 4319 AddToScope); 4320 } else { 4321 New = ActOnVariableDeclarator(S, D, DC, TInfo, Previous, TemplateParamLists, 4322 AddToScope); 4323 } 4324 4325 if (New == 0) 4326 return 0; 4327 4328 // If this has an identifier and is not an invalid redeclaration or 4329 // function template specialization, add it to the scope stack. 4330 if (New->getDeclName() && AddToScope && 4331 !(D.isRedeclaration() && New->isInvalidDecl())) { 4332 // Only make a locally-scoped extern declaration visible if it is the first 4333 // declaration of this entity. Qualified lookup for such an entity should 4334 // only find this declaration if there is no visible declaration of it. 4335 bool AddToContext = !D.isRedeclaration() || !New->isLocalExternDecl(); 4336 PushOnScopeChains(New, S, AddToContext); 4337 if (!AddToContext) 4338 CurContext->addHiddenDecl(New); 4339 } 4340 4341 return New; 4342} 4343 4344/// Helper method to turn variable array types into constant array 4345/// types in certain situations which would otherwise be errors (for 4346/// GCC compatibility). 4347static QualType TryToFixInvalidVariablyModifiedType(QualType T, 4348 ASTContext &Context, 4349 bool &SizeIsNegative, 4350 llvm::APSInt &Oversized) { 4351 // This method tries to turn a variable array into a constant 4352 // array even when the size isn't an ICE. This is necessary 4353 // for compatibility with code that depends on gcc's buggy 4354 // constant expression folding, like struct {char x[(int)(char*)2];} 4355 SizeIsNegative = false; 4356 Oversized = 0; 4357 4358 if (T->isDependentType()) 4359 return QualType(); 4360 4361 QualifierCollector Qs; 4362 const Type *Ty = Qs.strip(T); 4363 4364 if (const PointerType* PTy = dyn_cast<PointerType>(Ty)) { 4365 QualType Pointee = PTy->getPointeeType(); 4366 QualType FixedType = 4367 TryToFixInvalidVariablyModifiedType(Pointee, Context, SizeIsNegative, 4368 Oversized); 4369 if (FixedType.isNull()) return FixedType; 4370 FixedType = Context.getPointerType(FixedType); 4371 return Qs.apply(Context, FixedType); 4372 } 4373 if (const ParenType* PTy = dyn_cast<ParenType>(Ty)) { 4374 QualType Inner = PTy->getInnerType(); 4375 QualType FixedType = 4376 TryToFixInvalidVariablyModifiedType(Inner, Context, SizeIsNegative, 4377 Oversized); 4378 if (FixedType.isNull()) return FixedType; 4379 FixedType = Context.getParenType(FixedType); 4380 return Qs.apply(Context, FixedType); 4381 } 4382 4383 const VariableArrayType* VLATy = dyn_cast<VariableArrayType>(T); 4384 if (!VLATy) 4385 return QualType(); 4386 // FIXME: We should probably handle this case 4387 if (VLATy->getElementType()->isVariablyModifiedType()) 4388 return QualType(); 4389 4390 llvm::APSInt Res; 4391 if (!VLATy->getSizeExpr() || 4392 !VLATy->getSizeExpr()->EvaluateAsInt(Res, Context)) 4393 return QualType(); 4394 4395 // Check whether the array size is negative. 4396 if (Res.isSigned() && Res.isNegative()) { 4397 SizeIsNegative = true; 4398 return QualType(); 4399 } 4400 4401 // Check whether the array is too large to be addressed. 4402 unsigned ActiveSizeBits 4403 = ConstantArrayType::getNumAddressingBits(Context, VLATy->getElementType(), 4404 Res); 4405 if (ActiveSizeBits > ConstantArrayType::getMaxSizeBits(Context)) { 4406 Oversized = Res; 4407 return QualType(); 4408 } 4409 4410 return Context.getConstantArrayType(VLATy->getElementType(), 4411 Res, ArrayType::Normal, 0); 4412} 4413 4414static void 4415FixInvalidVariablyModifiedTypeLoc(TypeLoc SrcTL, TypeLoc DstTL) { 4416 if (PointerTypeLoc SrcPTL = SrcTL.getAs<PointerTypeLoc>()) { 4417 PointerTypeLoc DstPTL = DstTL.castAs<PointerTypeLoc>(); 4418 FixInvalidVariablyModifiedTypeLoc(SrcPTL.getPointeeLoc(), 4419 DstPTL.getPointeeLoc()); 4420 DstPTL.setStarLoc(SrcPTL.getStarLoc()); 4421 return; 4422 } 4423 if (ParenTypeLoc SrcPTL = SrcTL.getAs<ParenTypeLoc>()) { 4424 ParenTypeLoc DstPTL = DstTL.castAs<ParenTypeLoc>(); 4425 FixInvalidVariablyModifiedTypeLoc(SrcPTL.getInnerLoc(), 4426 DstPTL.getInnerLoc()); 4427 DstPTL.setLParenLoc(SrcPTL.getLParenLoc()); 4428 DstPTL.setRParenLoc(SrcPTL.getRParenLoc()); 4429 return; 4430 } 4431 ArrayTypeLoc SrcATL = SrcTL.castAs<ArrayTypeLoc>(); 4432 ArrayTypeLoc DstATL = DstTL.castAs<ArrayTypeLoc>(); 4433 TypeLoc SrcElemTL = SrcATL.getElementLoc(); 4434 TypeLoc DstElemTL = DstATL.getElementLoc(); 4435 DstElemTL.initializeFullCopy(SrcElemTL); 4436 DstATL.setLBracketLoc(SrcATL.getLBracketLoc()); 4437 DstATL.setSizeExpr(SrcATL.getSizeExpr()); 4438 DstATL.setRBracketLoc(SrcATL.getRBracketLoc()); 4439} 4440 4441/// Helper method to turn variable array types into constant array 4442/// types in certain situations which would otherwise be errors (for 4443/// GCC compatibility). 4444static TypeSourceInfo* 4445TryToFixInvalidVariablyModifiedTypeSourceInfo(TypeSourceInfo *TInfo, 4446 ASTContext &Context, 4447 bool &SizeIsNegative, 4448 llvm::APSInt &Oversized) { 4449 QualType FixedTy 4450 = TryToFixInvalidVariablyModifiedType(TInfo->getType(), Context, 4451 SizeIsNegative, Oversized); 4452 if (FixedTy.isNull()) 4453 return 0; 4454 TypeSourceInfo *FixedTInfo = Context.getTrivialTypeSourceInfo(FixedTy); 4455 FixInvalidVariablyModifiedTypeLoc(TInfo->getTypeLoc(), 4456 FixedTInfo->getTypeLoc()); 4457 return FixedTInfo; 4458} 4459 4460/// \brief Register the given locally-scoped extern "C" declaration so 4461/// that it can be found later for redeclarations. We include any extern "C" 4462/// declaration that is not visible in the translation unit here, not just 4463/// function-scope declarations. 4464void 4465Sema::RegisterLocallyScopedExternCDecl(NamedDecl *ND, Scope *S) { 4466 if (!getLangOpts().CPlusPlus && 4467 ND->getLexicalDeclContext()->getRedeclContext()->isTranslationUnit()) 4468 // Don't need to track declarations in the TU in C. 4469 return; 4470 4471 // Note that we have a locally-scoped external with this name. 4472 // FIXME: There can be multiple such declarations if they are functions marked 4473 // __attribute__((overloadable)) declared in function scope in C. 4474 LocallyScopedExternCDecls[ND->getDeclName()] = ND; 4475} 4476 4477NamedDecl *Sema::findLocallyScopedExternCDecl(DeclarationName Name) { 4478 if (ExternalSource) { 4479 // Load locally-scoped external decls from the external source. 4480 // FIXME: This is inefficient. Maybe add a DeclContext for extern "C" decls? 4481 SmallVector<NamedDecl *, 4> Decls; 4482 ExternalSource->ReadLocallyScopedExternCDecls(Decls); 4483 for (unsigned I = 0, N = Decls.size(); I != N; ++I) { 4484 llvm::DenseMap<DeclarationName, NamedDecl *>::iterator Pos 4485 = LocallyScopedExternCDecls.find(Decls[I]->getDeclName()); 4486 if (Pos == LocallyScopedExternCDecls.end()) 4487 LocallyScopedExternCDecls[Decls[I]->getDeclName()] = Decls[I]; 4488 } 4489 } 4490 4491 NamedDecl *D = LocallyScopedExternCDecls.lookup(Name); 4492 return D ? cast<NamedDecl>(D->getMostRecentDecl()) : 0; 4493} 4494 4495/// \brief Diagnose function specifiers on a declaration of an identifier that 4496/// does not identify a function. 4497void Sema::DiagnoseFunctionSpecifiers(const DeclSpec &DS) { 4498 // FIXME: We should probably indicate the identifier in question to avoid 4499 // confusion for constructs like "inline int a(), b;" 4500 if (DS.isInlineSpecified()) 4501 Diag(DS.getInlineSpecLoc(), 4502 diag::err_inline_non_function); 4503 4504 if (DS.isVirtualSpecified()) 4505 Diag(DS.getVirtualSpecLoc(), 4506 diag::err_virtual_non_function); 4507 4508 if (DS.isExplicitSpecified()) 4509 Diag(DS.getExplicitSpecLoc(), 4510 diag::err_explicit_non_function); 4511 4512 if (DS.isNoreturnSpecified()) 4513 Diag(DS.getNoreturnSpecLoc(), 4514 diag::err_noreturn_non_function); 4515} 4516 4517NamedDecl* 4518Sema::ActOnTypedefDeclarator(Scope* S, Declarator& D, DeclContext* DC, 4519 TypeSourceInfo *TInfo, LookupResult &Previous) { 4520 // Typedef declarators cannot be qualified (C++ [dcl.meaning]p1). 4521 if (D.getCXXScopeSpec().isSet()) { 4522 Diag(D.getIdentifierLoc(), diag::err_qualified_typedef_declarator) 4523 << D.getCXXScopeSpec().getRange(); 4524 D.setInvalidType(); 4525 // Pretend we didn't see the scope specifier. 4526 DC = CurContext; 4527 Previous.clear(); 4528 } 4529 4530 DiagnoseFunctionSpecifiers(D.getDeclSpec()); 4531 4532 if (D.getDeclSpec().isConstexprSpecified()) 4533 Diag(D.getDeclSpec().getConstexprSpecLoc(), diag::err_invalid_constexpr) 4534 << 1; 4535 4536 if (D.getName().Kind != UnqualifiedId::IK_Identifier) { 4537 Diag(D.getName().StartLocation, diag::err_typedef_not_identifier) 4538 << D.getName().getSourceRange(); 4539 return 0; 4540 } 4541 4542 TypedefDecl *NewTD = ParseTypedefDecl(S, D, TInfo->getType(), TInfo); 4543 if (!NewTD) return 0; 4544 4545 // Handle attributes prior to checking for duplicates in MergeVarDecl 4546 ProcessDeclAttributes(S, NewTD, D); 4547 4548 CheckTypedefForVariablyModifiedType(S, NewTD); 4549 4550 bool Redeclaration = D.isRedeclaration(); 4551 NamedDecl *ND = ActOnTypedefNameDecl(S, DC, NewTD, Previous, Redeclaration); 4552 D.setRedeclaration(Redeclaration); 4553 return ND; 4554} 4555 4556void 4557Sema::CheckTypedefForVariablyModifiedType(Scope *S, TypedefNameDecl *NewTD) { 4558 // C99 6.7.7p2: If a typedef name specifies a variably modified type 4559 // then it shall have block scope. 4560 // Note that variably modified types must be fixed before merging the decl so 4561 // that redeclarations will match. 4562 TypeSourceInfo *TInfo = NewTD->getTypeSourceInfo(); 4563 QualType T = TInfo->getType(); 4564 if (T->isVariablyModifiedType()) { 4565 getCurFunction()->setHasBranchProtectedScope(); 4566 4567 if (S->getFnParent() == 0) { 4568 bool SizeIsNegative; 4569 llvm::APSInt Oversized; 4570 TypeSourceInfo *FixedTInfo = 4571 TryToFixInvalidVariablyModifiedTypeSourceInfo(TInfo, Context, 4572 SizeIsNegative, 4573 Oversized); 4574 if (FixedTInfo) { 4575 Diag(NewTD->getLocation(), diag::warn_illegal_constant_array_size); 4576 NewTD->setTypeSourceInfo(FixedTInfo); 4577 } else { 4578 if (SizeIsNegative) 4579 Diag(NewTD->getLocation(), diag::err_typecheck_negative_array_size); 4580 else if (T->isVariableArrayType()) 4581 Diag(NewTD->getLocation(), diag::err_vla_decl_in_file_scope); 4582 else if (Oversized.getBoolValue()) 4583 Diag(NewTD->getLocation(), diag::err_array_too_large) 4584 << Oversized.toString(10); 4585 else 4586 Diag(NewTD->getLocation(), diag::err_vm_decl_in_file_scope); 4587 NewTD->setInvalidDecl(); 4588 } 4589 } 4590 } 4591} 4592 4593 4594/// ActOnTypedefNameDecl - Perform semantic checking for a declaration which 4595/// declares a typedef-name, either using the 'typedef' type specifier or via 4596/// a C++0x [dcl.typedef]p2 alias-declaration: 'using T = A;'. 4597NamedDecl* 4598Sema::ActOnTypedefNameDecl(Scope *S, DeclContext *DC, TypedefNameDecl *NewTD, 4599 LookupResult &Previous, bool &Redeclaration) { 4600 // Merge the decl with the existing one if appropriate. If the decl is 4601 // in an outer scope, it isn't the same thing. 4602 FilterLookupForScope(Previous, DC, S, /*ConsiderLinkage*/ false, 4603 /*ExplicitInstantiationOrSpecialization=*/false); 4604 filterNonConflictingPreviousDecls(Context, NewTD, Previous); 4605 if (!Previous.empty()) { 4606 Redeclaration = true; 4607 MergeTypedefNameDecl(NewTD, Previous); 4608 } 4609 4610 // If this is the C FILE type, notify the AST context. 4611 if (IdentifierInfo *II = NewTD->getIdentifier()) 4612 if (!NewTD->isInvalidDecl() && 4613 NewTD->getDeclContext()->getRedeclContext()->isTranslationUnit()) { 4614 if (II->isStr("FILE")) 4615 Context.setFILEDecl(NewTD); 4616 else if (II->isStr("jmp_buf")) 4617 Context.setjmp_bufDecl(NewTD); 4618 else if (II->isStr("sigjmp_buf")) 4619 Context.setsigjmp_bufDecl(NewTD); 4620 else if (II->isStr("ucontext_t")) 4621 Context.setucontext_tDecl(NewTD); 4622 } 4623 4624 return NewTD; 4625} 4626 4627/// \brief Determines whether the given declaration is an out-of-scope 4628/// previous declaration. 4629/// 4630/// This routine should be invoked when name lookup has found a 4631/// previous declaration (PrevDecl) that is not in the scope where a 4632/// new declaration by the same name is being introduced. If the new 4633/// declaration occurs in a local scope, previous declarations with 4634/// linkage may still be considered previous declarations (C99 4635/// 6.2.2p4-5, C++ [basic.link]p6). 4636/// 4637/// \param PrevDecl the previous declaration found by name 4638/// lookup 4639/// 4640/// \param DC the context in which the new declaration is being 4641/// declared. 4642/// 4643/// \returns true if PrevDecl is an out-of-scope previous declaration 4644/// for a new delcaration with the same name. 4645static bool 4646isOutOfScopePreviousDeclaration(NamedDecl *PrevDecl, DeclContext *DC, 4647 ASTContext &Context) { 4648 if (!PrevDecl) 4649 return false; 4650 4651 if (!PrevDecl->hasLinkage()) 4652 return false; 4653 4654 if (Context.getLangOpts().CPlusPlus) { 4655 // C++ [basic.link]p6: 4656 // If there is a visible declaration of an entity with linkage 4657 // having the same name and type, ignoring entities declared 4658 // outside the innermost enclosing namespace scope, the block 4659 // scope declaration declares that same entity and receives the 4660 // linkage of the previous declaration. 4661 DeclContext *OuterContext = DC->getRedeclContext(); 4662 if (!OuterContext->isFunctionOrMethod()) 4663 // This rule only applies to block-scope declarations. 4664 return false; 4665 4666 DeclContext *PrevOuterContext = PrevDecl->getDeclContext(); 4667 if (PrevOuterContext->isRecord()) 4668 // We found a member function: ignore it. 4669 return false; 4670 4671 // Find the innermost enclosing namespace for the new and 4672 // previous declarations. 4673 OuterContext = OuterContext->getEnclosingNamespaceContext(); 4674 PrevOuterContext = PrevOuterContext->getEnclosingNamespaceContext(); 4675 4676 // The previous declaration is in a different namespace, so it 4677 // isn't the same function. 4678 if (!OuterContext->Equals(PrevOuterContext)) 4679 return false; 4680 } 4681 4682 return true; 4683} 4684 4685static void SetNestedNameSpecifier(DeclaratorDecl *DD, Declarator &D) { 4686 CXXScopeSpec &SS = D.getCXXScopeSpec(); 4687 if (!SS.isSet()) return; 4688 DD->setQualifierInfo(SS.getWithLocInContext(DD->getASTContext())); 4689} 4690 4691bool Sema::inferObjCARCLifetime(ValueDecl *decl) { 4692 QualType type = decl->getType(); 4693 Qualifiers::ObjCLifetime lifetime = type.getObjCLifetime(); 4694 if (lifetime == Qualifiers::OCL_Autoreleasing) { 4695 // Various kinds of declaration aren't allowed to be __autoreleasing. 4696 unsigned kind = -1U; 4697 if (VarDecl *var = dyn_cast<VarDecl>(decl)) { 4698 if (var->hasAttr<BlocksAttr>()) 4699 kind = 0; // __block 4700 else if (!var->hasLocalStorage()) 4701 kind = 1; // global 4702 } else if (isa<ObjCIvarDecl>(decl)) { 4703 kind = 3; // ivar 4704 } else if (isa<FieldDecl>(decl)) { 4705 kind = 2; // field 4706 } 4707 4708 if (kind != -1U) { 4709 Diag(decl->getLocation(), diag::err_arc_autoreleasing_var) 4710 << kind; 4711 } 4712 } else if (lifetime == Qualifiers::OCL_None) { 4713 // Try to infer lifetime. 4714 if (!type->isObjCLifetimeType()) 4715 return false; 4716 4717 lifetime = type->getObjCARCImplicitLifetime(); 4718 type = Context.getLifetimeQualifiedType(type, lifetime); 4719 decl->setType(type); 4720 } 4721 4722 if (VarDecl *var = dyn_cast<VarDecl>(decl)) { 4723 // Thread-local variables cannot have lifetime. 4724 if (lifetime && lifetime != Qualifiers::OCL_ExplicitNone && 4725 var->getTLSKind()) { 4726 Diag(var->getLocation(), diag::err_arc_thread_ownership) 4727 << var->getType(); 4728 return true; 4729 } 4730 } 4731 4732 return false; 4733} 4734 4735static void checkAttributesAfterMerging(Sema &S, NamedDecl &ND) { 4736 // 'weak' only applies to declarations with external linkage. 4737 if (WeakAttr *Attr = ND.getAttr<WeakAttr>()) { 4738 if (!ND.isExternallyVisible()) { 4739 S.Diag(Attr->getLocation(), diag::err_attribute_weak_static); 4740 ND.dropAttr<WeakAttr>(); 4741 } 4742 } 4743 if (WeakRefAttr *Attr = ND.getAttr<WeakRefAttr>()) { 4744 if (ND.isExternallyVisible()) { 4745 S.Diag(Attr->getLocation(), diag::err_attribute_weakref_not_static); 4746 ND.dropAttr<WeakRefAttr>(); 4747 } 4748 } 4749 4750 // 'selectany' only applies to externally visible varable declarations. 4751 // It does not apply to functions. 4752 if (SelectAnyAttr *Attr = ND.getAttr<SelectAnyAttr>()) { 4753 if (isa<FunctionDecl>(ND) || !ND.isExternallyVisible()) { 4754 S.Diag(Attr->getLocation(), diag::err_attribute_selectany_non_extern_data); 4755 ND.dropAttr<SelectAnyAttr>(); 4756 } 4757 } 4758} 4759 4760/// Given that we are within the definition of the given function, 4761/// will that definition behave like C99's 'inline', where the 4762/// definition is discarded except for optimization purposes? 4763static bool isFunctionDefinitionDiscarded(Sema &S, FunctionDecl *FD) { 4764 // Try to avoid calling GetGVALinkageForFunction. 4765 4766 // All cases of this require the 'inline' keyword. 4767 if (!FD->isInlined()) return false; 4768 4769 // This is only possible in C++ with the gnu_inline attribute. 4770 if (S.getLangOpts().CPlusPlus && !FD->hasAttr<GNUInlineAttr>()) 4771 return false; 4772 4773 // Okay, go ahead and call the relatively-more-expensive function. 4774 4775#ifndef NDEBUG 4776 // AST quite reasonably asserts that it's working on a function 4777 // definition. We don't really have a way to tell it that we're 4778 // currently defining the function, so just lie to it in +Asserts 4779 // builds. This is an awful hack. 4780 FD->setLazyBody(1); 4781#endif 4782 4783 bool isC99Inline = (S.Context.GetGVALinkageForFunction(FD) == GVA_C99Inline); 4784 4785#ifndef NDEBUG 4786 FD->setLazyBody(0); 4787#endif 4788 4789 return isC99Inline; 4790} 4791 4792/// Determine whether a variable is extern "C" prior to attaching 4793/// an initializer. We can't just call isExternC() here, because that 4794/// will also compute and cache whether the declaration is externally 4795/// visible, which might change when we attach the initializer. 4796/// 4797/// This can only be used if the declaration is known to not be a 4798/// redeclaration of an internal linkage declaration. 4799/// 4800/// For instance: 4801/// 4802/// auto x = []{}; 4803/// 4804/// Attaching the initializer here makes this declaration not externally 4805/// visible, because its type has internal linkage. 4806/// 4807/// FIXME: This is a hack. 4808template<typename T> 4809static bool isIncompleteDeclExternC(Sema &S, const T *D) { 4810 if (S.getLangOpts().CPlusPlus) { 4811 // In C++, the overloadable attribute negates the effects of extern "C". 4812 if (!D->isInExternCContext() || D->template hasAttr<OverloadableAttr>()) 4813 return false; 4814 } 4815 return D->isExternC(); 4816} 4817 4818static bool shouldConsiderLinkage(const VarDecl *VD) { 4819 const DeclContext *DC = VD->getDeclContext()->getRedeclContext(); 4820 if (DC->isFunctionOrMethod()) 4821 return VD->hasExternalStorage(); 4822 if (DC->isFileContext()) 4823 return true; 4824 if (DC->isRecord()) 4825 return false; 4826 llvm_unreachable("Unexpected context"); 4827} 4828 4829static bool shouldConsiderLinkage(const FunctionDecl *FD) { 4830 const DeclContext *DC = FD->getDeclContext()->getRedeclContext(); 4831 if (DC->isFileContext() || DC->isFunctionOrMethod()) 4832 return true; 4833 if (DC->isRecord()) 4834 return false; 4835 llvm_unreachable("Unexpected context"); 4836} 4837 4838/// Adjust the \c DeclContext for a function or variable that might be a 4839/// function-local external declaration. 4840bool Sema::adjustContextForLocalExternDecl(DeclContext *&DC) { 4841 if (!DC->isFunctionOrMethod()) 4842 return false; 4843 4844 // If this is a local extern function or variable declared within a function 4845 // template, don't add it into the enclosing namespace scope until it is 4846 // instantiated; it might have a dependent type right now. 4847 if (DC->isDependentContext()) 4848 return true; 4849 4850 // C++11 [basic.link]p7: 4851 // When a block scope declaration of an entity with linkage is not found to 4852 // refer to some other declaration, then that entity is a member of the 4853 // innermost enclosing namespace. 4854 // 4855 // Per C++11 [namespace.def]p6, the innermost enclosing namespace is a 4856 // semantically-enclosing namespace, not a lexically-enclosing one. 4857 while (!DC->isFileContext() && !isa<LinkageSpecDecl>(DC)) 4858 DC = DC->getParent(); 4859 return true; 4860} 4861 4862NamedDecl * 4863Sema::ActOnVariableDeclarator(Scope *S, Declarator &D, DeclContext *DC, 4864 TypeSourceInfo *TInfo, LookupResult &Previous, 4865 MultiTemplateParamsArg TemplateParamLists, 4866 bool &AddToScope) { 4867 QualType R = TInfo->getType(); 4868 DeclarationName Name = GetNameForDeclarator(D).getName(); 4869 4870 DeclSpec::SCS SCSpec = D.getDeclSpec().getStorageClassSpec(); 4871 VarDecl::StorageClass SC = 4872 StorageClassSpecToVarDeclStorageClass(D.getDeclSpec()); 4873 4874 DeclContext *OriginalDC = DC; 4875 bool IsLocalExternDecl = SC == SC_Extern && 4876 adjustContextForLocalExternDecl(DC); 4877 4878 if (getLangOpts().OpenCL && !getOpenCLOptions().cl_khr_fp16) { 4879 // OpenCL v1.2 s6.1.1.1: reject declaring variables of the half and 4880 // half array type (unless the cl_khr_fp16 extension is enabled). 4881 if (Context.getBaseElementType(R)->isHalfType()) { 4882 Diag(D.getIdentifierLoc(), diag::err_opencl_half_declaration) << R; 4883 D.setInvalidType(); 4884 } 4885 } 4886 4887 if (SCSpec == DeclSpec::SCS_mutable) { 4888 // mutable can only appear on non-static class members, so it's always 4889 // an error here 4890 Diag(D.getIdentifierLoc(), diag::err_mutable_nonmember); 4891 D.setInvalidType(); 4892 SC = SC_None; 4893 } 4894 4895 if (getLangOpts().CPlusPlus11 && SCSpec == DeclSpec::SCS_register && 4896 !D.getAsmLabel() && !getSourceManager().isInSystemMacro( 4897 D.getDeclSpec().getStorageClassSpecLoc())) { 4898 // In C++11, the 'register' storage class specifier is deprecated. 4899 // Suppress the warning in system macros, it's used in macros in some 4900 // popular C system headers, such as in glibc's htonl() macro. 4901 Diag(D.getDeclSpec().getStorageClassSpecLoc(), 4902 diag::warn_deprecated_register) 4903 << FixItHint::CreateRemoval(D.getDeclSpec().getStorageClassSpecLoc()); 4904 } 4905 4906 IdentifierInfo *II = Name.getAsIdentifierInfo(); 4907 if (!II) { 4908 Diag(D.getIdentifierLoc(), diag::err_bad_variable_name) 4909 << Name; 4910 return 0; 4911 } 4912 4913 DiagnoseFunctionSpecifiers(D.getDeclSpec()); 4914 4915 if (!DC->isRecord() && S->getFnParent() == 0) { 4916 // C99 6.9p2: The storage-class specifiers auto and register shall not 4917 // appear in the declaration specifiers in an external declaration. 4918 if (SC == SC_Auto || SC == SC_Register) { 4919 // If this is a register variable with an asm label specified, then this 4920 // is a GNU extension. 4921 if (SC == SC_Register && D.getAsmLabel()) 4922 Diag(D.getIdentifierLoc(), diag::err_unsupported_global_register); 4923 else 4924 Diag(D.getIdentifierLoc(), diag::err_typecheck_sclass_fscope); 4925 D.setInvalidType(); 4926 } 4927 } 4928 4929 if (getLangOpts().OpenCL) { 4930 // Set up the special work-group-local storage class for variables in the 4931 // OpenCL __local address space. 4932 if (R.getAddressSpace() == LangAS::opencl_local) { 4933 SC = SC_OpenCLWorkGroupLocal; 4934 } 4935 4936 // OpenCL v1.2 s6.9.b p4: 4937 // The sampler type cannot be used with the __local and __global address 4938 // space qualifiers. 4939 if (R->isSamplerT() && (R.getAddressSpace() == LangAS::opencl_local || 4940 R.getAddressSpace() == LangAS::opencl_global)) { 4941 Diag(D.getIdentifierLoc(), diag::err_wrong_sampler_addressspace); 4942 } 4943 4944 // OpenCL 1.2 spec, p6.9 r: 4945 // The event type cannot be used to declare a program scope variable. 4946 // The event type cannot be used with the __local, __constant and __global 4947 // address space qualifiers. 4948 if (R->isEventT()) { 4949 if (S->getParent() == 0) { 4950 Diag(D.getLocStart(), diag::err_event_t_global_var); 4951 D.setInvalidType(); 4952 } 4953 4954 if (R.getAddressSpace()) { 4955 Diag(D.getLocStart(), diag::err_event_t_addr_space_qual); 4956 D.setInvalidType(); 4957 } 4958 } 4959 } 4960 4961 bool IsExplicitSpecialization = false; 4962 bool IsVariableTemplateSpecialization = false; 4963 bool IsPartialSpecialization = false; 4964 bool IsVariableTemplate = false; 4965 VarTemplateDecl *PrevVarTemplate = 0; 4966 VarDecl *NewVD = 0; 4967 VarTemplateDecl *NewTemplate = 0; 4968 if (!getLangOpts().CPlusPlus) { 4969 NewVD = VarDecl::Create(Context, DC, D.getLocStart(), 4970 D.getIdentifierLoc(), II, 4971 R, TInfo, SC); 4972 4973 if (D.isInvalidType()) 4974 NewVD->setInvalidDecl(); 4975 } else { 4976 bool Invalid = false; 4977 4978 if (DC->isRecord() && !CurContext->isRecord()) { 4979 // This is an out-of-line definition of a static data member. 4980 switch (SC) { 4981 case SC_None: 4982 break; 4983 case SC_Static: 4984 Diag(D.getDeclSpec().getStorageClassSpecLoc(), 4985 diag::err_static_out_of_line) 4986 << FixItHint::CreateRemoval(D.getDeclSpec().getStorageClassSpecLoc()); 4987 break; 4988 case SC_Auto: 4989 case SC_Register: 4990 case SC_Extern: 4991 // [dcl.stc] p2: The auto or register specifiers shall be applied only 4992 // to names of variables declared in a block or to function parameters. 4993 // [dcl.stc] p6: The extern specifier cannot be used in the declaration 4994 // of class members 4995 4996 Diag(D.getDeclSpec().getStorageClassSpecLoc(), 4997 diag::err_storage_class_for_static_member) 4998 << FixItHint::CreateRemoval(D.getDeclSpec().getStorageClassSpecLoc()); 4999 break; 5000 case SC_PrivateExtern: 5001 llvm_unreachable("C storage class in c++!"); 5002 case SC_OpenCLWorkGroupLocal: 5003 llvm_unreachable("OpenCL storage class in c++!"); 5004 } 5005 } 5006 5007 if (SC == SC_Static && CurContext->isRecord()) { 5008 if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(DC)) { 5009 if (RD->isLocalClass()) 5010 Diag(D.getIdentifierLoc(), 5011 diag::err_static_data_member_not_allowed_in_local_class) 5012 << Name << RD->getDeclName(); 5013 5014 // C++98 [class.union]p1: If a union contains a static data member, 5015 // the program is ill-formed. C++11 drops this restriction. 5016 if (RD->isUnion()) 5017 Diag(D.getIdentifierLoc(), 5018 getLangOpts().CPlusPlus11 5019 ? diag::warn_cxx98_compat_static_data_member_in_union 5020 : diag::ext_static_data_member_in_union) << Name; 5021 // We conservatively disallow static data members in anonymous structs. 5022 else if (!RD->getDeclName()) 5023 Diag(D.getIdentifierLoc(), 5024 diag::err_static_data_member_not_allowed_in_anon_struct) 5025 << Name << RD->isUnion(); 5026 } 5027 } 5028 5029 NamedDecl *PrevDecl = 0; 5030 if (Previous.begin() != Previous.end()) 5031 PrevDecl = (*Previous.begin())->getUnderlyingDecl(); 5032 PrevVarTemplate = dyn_cast_or_null<VarTemplateDecl>(PrevDecl); 5033 5034 // Match up the template parameter lists with the scope specifier, then 5035 // determine whether we have a template or a template specialization. 5036 TemplateParameterList *TemplateParams = 5037 MatchTemplateParametersToScopeSpecifier( 5038 D.getDeclSpec().getLocStart(), D.getIdentifierLoc(), 5039 D.getCXXScopeSpec(), TemplateParamLists, 5040 /*never a friend*/ false, IsExplicitSpecialization, Invalid); 5041 if (TemplateParams) { 5042 if (!TemplateParams->size() && 5043 D.getName().getKind() != UnqualifiedId::IK_TemplateId) { 5044 // There is an extraneous 'template<>' for this variable. Complain 5045 // about it, but allow the declaration of the variable. 5046 Diag(TemplateParams->getTemplateLoc(), 5047 diag::err_template_variable_noparams) 5048 << II 5049 << SourceRange(TemplateParams->getTemplateLoc(), 5050 TemplateParams->getRAngleLoc()); 5051 } else { 5052 // Only C++1y supports variable templates (N3651). 5053 Diag(D.getIdentifierLoc(), 5054 getLangOpts().CPlusPlus1y 5055 ? diag::warn_cxx11_compat_variable_template 5056 : diag::ext_variable_template); 5057 5058 if (D.getName().getKind() == UnqualifiedId::IK_TemplateId) { 5059 // This is an explicit specialization or a partial specialization. 5060 // Check that we can declare a specialization here 5061 5062 IsVariableTemplateSpecialization = true; 5063 IsPartialSpecialization = TemplateParams->size() > 0; 5064 5065 } else { // if (TemplateParams->size() > 0) 5066 // This is a template declaration. 5067 IsVariableTemplate = true; 5068 5069 // Check that we can declare a template here. 5070 if (CheckTemplateDeclScope(S, TemplateParams)) 5071 return 0; 5072 5073 // If there is a previous declaration with the same name, check 5074 // whether this is a valid redeclaration. 5075 if (PrevDecl && !isDeclInScope(PrevDecl, DC, S)) 5076 PrevDecl = PrevVarTemplate = 0; 5077 5078 if (PrevVarTemplate) { 5079 // Ensure that the template parameter lists are compatible. 5080 if (!TemplateParameterListsAreEqual( 5081 TemplateParams, PrevVarTemplate->getTemplateParameters(), 5082 /*Complain=*/true, TPL_TemplateMatch)) 5083 return 0; 5084 } else if (PrevDecl && PrevDecl->isTemplateParameter()) { 5085 // Maybe we will complain about the shadowed template parameter. 5086 DiagnoseTemplateParameterShadow(D.getIdentifierLoc(), PrevDecl); 5087 5088 // Just pretend that we didn't see the previous declaration. 5089 PrevDecl = 0; 5090 } else if (PrevDecl) { 5091 // C++ [temp]p5: 5092 // ... a template name declared in namespace scope or in class 5093 // scope shall be unique in that scope. 5094 Diag(D.getIdentifierLoc(), diag::err_redefinition_different_kind) 5095 << Name; 5096 Diag(PrevDecl->getLocation(), diag::note_previous_definition); 5097 return 0; 5098 } 5099 5100 // Check the template parameter list of this declaration, possibly 5101 // merging in the template parameter list from the previous variable 5102 // template declaration. 5103 if (CheckTemplateParameterList( 5104 TemplateParams, 5105 PrevVarTemplate ? PrevVarTemplate->getTemplateParameters() 5106 : 0, 5107 (D.getCXXScopeSpec().isSet() && DC && DC->isRecord() && 5108 DC->isDependentContext()) 5109 ? TPC_ClassTemplateMember 5110 : TPC_VarTemplate)) 5111 Invalid = true; 5112 5113 if (D.getCXXScopeSpec().isSet()) { 5114 // If the name of the template was qualified, we must be defining 5115 // the template out-of-line. 5116 if (!D.getCXXScopeSpec().isInvalid() && !Invalid && 5117 !PrevVarTemplate) { 5118 Diag(D.getIdentifierLoc(), diag::err_member_decl_does_not_match) 5119 << Name << DC << /*IsDefinition*/true 5120 << D.getCXXScopeSpec().getRange(); 5121 Invalid = true; 5122 } 5123 } 5124 } 5125 } 5126 } else if (D.getName().getKind() == UnqualifiedId::IK_TemplateId) { 5127 TemplateIdAnnotation *TemplateId = D.getName().TemplateId; 5128 5129 // We have encountered something that the user meant to be a 5130 // specialization (because it has explicitly-specified template 5131 // arguments) but that was not introduced with a "template<>" (or had 5132 // too few of them). 5133 // FIXME: Differentiate between attempts for explicit instantiations 5134 // (starting with "template") and the rest. 5135 Diag(D.getIdentifierLoc(), diag::err_template_spec_needs_header) 5136 << SourceRange(TemplateId->LAngleLoc, TemplateId->RAngleLoc) 5137 << FixItHint::CreateInsertion(D.getDeclSpec().getLocStart(), 5138 "template<> "); 5139 IsVariableTemplateSpecialization = true; 5140 } 5141 5142 if (IsVariableTemplateSpecialization) { 5143 if (!PrevVarTemplate) { 5144 Diag(D.getIdentifierLoc(), diag::err_var_spec_no_template) 5145 << IsPartialSpecialization; 5146 return 0; 5147 } 5148 5149 SourceLocation TemplateKWLoc = 5150 TemplateParamLists.size() > 0 5151 ? TemplateParamLists[0]->getTemplateLoc() 5152 : SourceLocation(); 5153 DeclResult Res = ActOnVarTemplateSpecialization( 5154 S, PrevVarTemplate, D, TInfo, TemplateKWLoc, TemplateParams, SC, 5155 IsPartialSpecialization); 5156 if (Res.isInvalid()) 5157 return 0; 5158 NewVD = cast<VarDecl>(Res.get()); 5159 AddToScope = false; 5160 } else 5161 NewVD = VarDecl::Create(Context, DC, D.getLocStart(), 5162 D.getIdentifierLoc(), II, R, TInfo, SC); 5163 5164 // If this is supposed to be a variable template, create it as such. 5165 if (IsVariableTemplate) { 5166 NewTemplate = 5167 VarTemplateDecl::Create(Context, DC, D.getIdentifierLoc(), Name, 5168 TemplateParams, NewVD, PrevVarTemplate); 5169 NewVD->setDescribedVarTemplate(NewTemplate); 5170 } 5171 5172 // If this decl has an auto type in need of deduction, make a note of the 5173 // Decl so we can diagnose uses of it in its own initializer. 5174 if (D.getDeclSpec().containsPlaceholderType() && R->getContainedAutoType()) 5175 ParsingInitForAutoVars.insert(NewVD); 5176 5177 if (D.isInvalidType() || Invalid) { 5178 NewVD->setInvalidDecl(); 5179 if (NewTemplate) 5180 NewTemplate->setInvalidDecl(); 5181 } 5182 5183 SetNestedNameSpecifier(NewVD, D); 5184 5185 // FIXME: Do we need D.getCXXScopeSpec().isSet()? 5186 if (TemplateParams && TemplateParamLists.size() > 1 && 5187 (!IsVariableTemplateSpecialization || D.getCXXScopeSpec().isSet())) { 5188 NewVD->setTemplateParameterListsInfo( 5189 Context, TemplateParamLists.size() - 1, TemplateParamLists.data()); 5190 } else if (IsVariableTemplateSpecialization || 5191 (!TemplateParams && TemplateParamLists.size() > 0 && 5192 (D.getCXXScopeSpec().isSet()))) { 5193 NewVD->setTemplateParameterListsInfo(Context, 5194 TemplateParamLists.size(), 5195 TemplateParamLists.data()); 5196 } 5197 5198 if (D.getDeclSpec().isConstexprSpecified()) 5199 NewVD->setConstexpr(true); 5200 } 5201 5202 // Set the lexical context. If the declarator has a C++ scope specifier, the 5203 // lexical context will be different from the semantic context. 5204 NewVD->setLexicalDeclContext(CurContext); 5205 if (NewTemplate) 5206 NewTemplate->setLexicalDeclContext(CurContext); 5207 5208 if (IsLocalExternDecl) 5209 NewVD->setLocalExternDecl(); 5210 5211 if (DeclSpec::TSCS TSCS = D.getDeclSpec().getThreadStorageClassSpec()) { 5212 if (NewVD->hasLocalStorage()) { 5213 // C++11 [dcl.stc]p4: 5214 // When thread_local is applied to a variable of block scope the 5215 // storage-class-specifier static is implied if it does not appear 5216 // explicitly. 5217 // Core issue: 'static' is not implied if the variable is declared 5218 // 'extern'. 5219 if (SCSpec == DeclSpec::SCS_unspecified && 5220 TSCS == DeclSpec::TSCS_thread_local && 5221 DC->isFunctionOrMethod()) 5222 NewVD->setTSCSpec(TSCS); 5223 else 5224 Diag(D.getDeclSpec().getThreadStorageClassSpecLoc(), 5225 diag::err_thread_non_global) 5226 << DeclSpec::getSpecifierName(TSCS); 5227 } else if (!Context.getTargetInfo().isTLSSupported()) 5228 Diag(D.getDeclSpec().getThreadStorageClassSpecLoc(), 5229 diag::err_thread_unsupported); 5230 else 5231 NewVD->setTSCSpec(TSCS); 5232 } 5233 5234 // C99 6.7.4p3 5235 // An inline definition of a function with external linkage shall 5236 // not contain a definition of a modifiable object with static or 5237 // thread storage duration... 5238 // We only apply this when the function is required to be defined 5239 // elsewhere, i.e. when the function is not 'extern inline'. Note 5240 // that a local variable with thread storage duration still has to 5241 // be marked 'static'. Also note that it's possible to get these 5242 // semantics in C++ using __attribute__((gnu_inline)). 5243 if (SC == SC_Static && S->getFnParent() != 0 && 5244 !NewVD->getType().isConstQualified()) { 5245 FunctionDecl *CurFD = getCurFunctionDecl(); 5246 if (CurFD && isFunctionDefinitionDiscarded(*this, CurFD)) { 5247 Diag(D.getDeclSpec().getStorageClassSpecLoc(), 5248 diag::warn_static_local_in_extern_inline); 5249 MaybeSuggestAddingStaticToDecl(CurFD); 5250 } 5251 } 5252 5253 if (D.getDeclSpec().isModulePrivateSpecified()) { 5254 if (IsVariableTemplateSpecialization) 5255 Diag(NewVD->getLocation(), diag::err_module_private_specialization) 5256 << (IsPartialSpecialization ? 1 : 0) 5257 << FixItHint::CreateRemoval( 5258 D.getDeclSpec().getModulePrivateSpecLoc()); 5259 else if (IsExplicitSpecialization) 5260 Diag(NewVD->getLocation(), diag::err_module_private_specialization) 5261 << 2 5262 << FixItHint::CreateRemoval(D.getDeclSpec().getModulePrivateSpecLoc()); 5263 else if (NewVD->hasLocalStorage()) 5264 Diag(NewVD->getLocation(), diag::err_module_private_local) 5265 << 0 << NewVD->getDeclName() 5266 << SourceRange(D.getDeclSpec().getModulePrivateSpecLoc()) 5267 << FixItHint::CreateRemoval(D.getDeclSpec().getModulePrivateSpecLoc()); 5268 else { 5269 NewVD->setModulePrivate(); 5270 if (NewTemplate) 5271 NewTemplate->setModulePrivate(); 5272 } 5273 } 5274 5275 // Handle attributes prior to checking for duplicates in MergeVarDecl 5276 ProcessDeclAttributes(S, NewVD, D); 5277 5278 if (NewVD->hasAttrs()) 5279 CheckAlignasUnderalignment(NewVD); 5280 5281 if (getLangOpts().CUDA) { 5282 // CUDA B.2.5: "__shared__ and __constant__ variables have implied static 5283 // storage [duration]." 5284 if (SC == SC_None && S->getFnParent() != 0 && 5285 (NewVD->hasAttr<CUDASharedAttr>() || 5286 NewVD->hasAttr<CUDAConstantAttr>())) { 5287 NewVD->setStorageClass(SC_Static); 5288 } 5289 } 5290 5291 // In auto-retain/release, infer strong retension for variables of 5292 // retainable type. 5293 if (getLangOpts().ObjCAutoRefCount && inferObjCARCLifetime(NewVD)) 5294 NewVD->setInvalidDecl(); 5295 5296 // Handle GNU asm-label extension (encoded as an attribute). 5297 if (Expr *E = (Expr*)D.getAsmLabel()) { 5298 // The parser guarantees this is a string. 5299 StringLiteral *SE = cast<StringLiteral>(E); 5300 StringRef Label = SE->getString(); 5301 if (S->getFnParent() != 0) { 5302 switch (SC) { 5303 case SC_None: 5304 case SC_Auto: 5305 Diag(E->getExprLoc(), diag::warn_asm_label_on_auto_decl) << Label; 5306 break; 5307 case SC_Register: 5308 if (!Context.getTargetInfo().isValidGCCRegisterName(Label)) 5309 Diag(E->getExprLoc(), diag::err_asm_unknown_register_name) << Label; 5310 break; 5311 case SC_Static: 5312 case SC_Extern: 5313 case SC_PrivateExtern: 5314 case SC_OpenCLWorkGroupLocal: 5315 break; 5316 } 5317 } 5318 5319 NewVD->addAttr(::new (Context) AsmLabelAttr(SE->getStrTokenLoc(0), 5320 Context, Label)); 5321 } else if (!ExtnameUndeclaredIdentifiers.empty()) { 5322 llvm::DenseMap<IdentifierInfo*,AsmLabelAttr*>::iterator I = 5323 ExtnameUndeclaredIdentifiers.find(NewVD->getIdentifier()); 5324 if (I != ExtnameUndeclaredIdentifiers.end()) { 5325 NewVD->addAttr(I->second); 5326 ExtnameUndeclaredIdentifiers.erase(I); 5327 } 5328 } 5329 5330 // Diagnose shadowed variables before filtering for scope. 5331 if (!D.getCXXScopeSpec().isSet()) 5332 CheckShadow(S, NewVD, Previous); 5333 5334 // Don't consider existing declarations that are in a different 5335 // scope and are out-of-semantic-context declarations (if the new 5336 // declaration has linkage). 5337 FilterLookupForScope( 5338 Previous, OriginalDC, S, shouldConsiderLinkage(NewVD), 5339 IsExplicitSpecialization || IsVariableTemplateSpecialization); 5340 5341 // Check whether the previous declaration is in the same block scope. This 5342 // affects whether we merge types with it, per C++11 [dcl.array]p3. 5343 if (getLangOpts().CPlusPlus && 5344 NewVD->isLocalVarDecl() && NewVD->hasExternalStorage()) 5345 NewVD->setPreviousDeclInSameBlockScope( 5346 Previous.isSingleResult() && !Previous.isShadowed() && 5347 isDeclInScope(Previous.getFoundDecl(), OriginalDC, S, false)); 5348 5349 if (!getLangOpts().CPlusPlus) { 5350 D.setRedeclaration(CheckVariableDeclaration(NewVD, Previous)); 5351 } else { 5352 // Merge the decl with the existing one if appropriate. 5353 if (!Previous.empty()) { 5354 if (Previous.isSingleResult() && 5355 isa<FieldDecl>(Previous.getFoundDecl()) && 5356 D.getCXXScopeSpec().isSet()) { 5357 // The user tried to define a non-static data member 5358 // out-of-line (C++ [dcl.meaning]p1). 5359 Diag(NewVD->getLocation(), diag::err_nonstatic_member_out_of_line) 5360 << D.getCXXScopeSpec().getRange(); 5361 Previous.clear(); 5362 NewVD->setInvalidDecl(); 5363 } 5364 } else if (D.getCXXScopeSpec().isSet()) { 5365 // No previous declaration in the qualifying scope. 5366 Diag(D.getIdentifierLoc(), diag::err_no_member) 5367 << Name << computeDeclContext(D.getCXXScopeSpec(), true) 5368 << D.getCXXScopeSpec().getRange(); 5369 NewVD->setInvalidDecl(); 5370 } 5371 5372 if (!IsVariableTemplateSpecialization) { 5373 if (PrevVarTemplate) { 5374 LookupResult PrevDecl(*this, GetNameForDeclarator(D), 5375 LookupOrdinaryName, ForRedeclaration); 5376 PrevDecl.addDecl(PrevVarTemplate->getTemplatedDecl()); 5377 D.setRedeclaration(CheckVariableDeclaration(NewVD, PrevDecl)); 5378 } else 5379 D.setRedeclaration(CheckVariableDeclaration(NewVD, Previous)); 5380 } 5381 5382 // This is an explicit specialization of a static data member. Check it. 5383 if (IsExplicitSpecialization && !NewVD->isInvalidDecl() && 5384 CheckMemberSpecialization(NewVD, Previous)) 5385 NewVD->setInvalidDecl(); 5386 } 5387 5388 ProcessPragmaWeak(S, NewVD); 5389 checkAttributesAfterMerging(*this, *NewVD); 5390 5391 // If this is the first declaration of an extern C variable, update 5392 // the map of such variables. 5393 if (!NewVD->getPreviousDecl() && !NewVD->isInvalidDecl() && 5394 isIncompleteDeclExternC(*this, NewVD)) 5395 RegisterLocallyScopedExternCDecl(NewVD, S); 5396 5397 if (getLangOpts().CPlusPlus && NewVD->isStaticLocal()) { 5398 Decl *ManglingContextDecl; 5399 if (MangleNumberingContext *MCtx = 5400 getCurrentMangleNumberContext(NewVD->getDeclContext(), 5401 ManglingContextDecl)) { 5402 Context.setManglingNumber(NewVD, MCtx->getManglingNumber(NewVD)); 5403 } 5404 } 5405 5406 // If we are providing an explicit specialization of a static variable 5407 // template, make a note of that. 5408 if (PrevVarTemplate && PrevVarTemplate->getInstantiatedFromMemberTemplate()) 5409 PrevVarTemplate->setMemberSpecialization(); 5410 5411 if (NewTemplate) { 5412 ActOnDocumentableDecl(NewTemplate); 5413 return NewTemplate; 5414 } 5415 5416 return NewVD; 5417} 5418 5419/// \brief Diagnose variable or built-in function shadowing. Implements 5420/// -Wshadow. 5421/// 5422/// This method is called whenever a VarDecl is added to a "useful" 5423/// scope. 5424/// 5425/// \param S the scope in which the shadowing name is being declared 5426/// \param R the lookup of the name 5427/// 5428void Sema::CheckShadow(Scope *S, VarDecl *D, const LookupResult& R) { 5429 // Return if warning is ignored. 5430 if (Diags.getDiagnosticLevel(diag::warn_decl_shadow, R.getNameLoc()) == 5431 DiagnosticsEngine::Ignored) 5432 return; 5433 5434 // Don't diagnose declarations at file scope. 5435 if (D->hasGlobalStorage()) 5436 return; 5437 5438 DeclContext *NewDC = D->getDeclContext(); 5439 5440 // Only diagnose if we're shadowing an unambiguous field or variable. 5441 if (R.getResultKind() != LookupResult::Found) 5442 return; 5443 5444 NamedDecl* ShadowedDecl = R.getFoundDecl(); 5445 if (!isa<VarDecl>(ShadowedDecl) && !isa<FieldDecl>(ShadowedDecl)) 5446 return; 5447 5448 // Fields are not shadowed by variables in C++ static methods. 5449 if (isa<FieldDecl>(ShadowedDecl)) 5450 if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(NewDC)) 5451 if (MD->isStatic()) 5452 return; 5453 5454 if (VarDecl *shadowedVar = dyn_cast<VarDecl>(ShadowedDecl)) 5455 if (shadowedVar->isExternC()) { 5456 // For shadowing external vars, make sure that we point to the global 5457 // declaration, not a locally scoped extern declaration. 5458 for (VarDecl::redecl_iterator 5459 I = shadowedVar->redecls_begin(), E = shadowedVar->redecls_end(); 5460 I != E; ++I) 5461 if (I->isFileVarDecl()) { 5462 ShadowedDecl = *I; 5463 break; 5464 } 5465 } 5466 5467 DeclContext *OldDC = ShadowedDecl->getDeclContext(); 5468 5469 // Only warn about certain kinds of shadowing for class members. 5470 if (NewDC && NewDC->isRecord()) { 5471 // In particular, don't warn about shadowing non-class members. 5472 if (!OldDC->isRecord()) 5473 return; 5474 5475 // TODO: should we warn about static data members shadowing 5476 // static data members from base classes? 5477 5478 // TODO: don't diagnose for inaccessible shadowed members. 5479 // This is hard to do perfectly because we might friend the 5480 // shadowing context, but that's just a false negative. 5481 } 5482 5483 // Determine what kind of declaration we're shadowing. 5484 unsigned Kind; 5485 if (isa<RecordDecl>(OldDC)) { 5486 if (isa<FieldDecl>(ShadowedDecl)) 5487 Kind = 3; // field 5488 else 5489 Kind = 2; // static data member 5490 } else if (OldDC->isFileContext()) 5491 Kind = 1; // global 5492 else 5493 Kind = 0; // local 5494 5495 DeclarationName Name = R.getLookupName(); 5496 5497 // Emit warning and note. 5498 Diag(R.getNameLoc(), diag::warn_decl_shadow) << Name << Kind << OldDC; 5499 Diag(ShadowedDecl->getLocation(), diag::note_previous_declaration); 5500} 5501 5502/// \brief Check -Wshadow without the advantage of a previous lookup. 5503void Sema::CheckShadow(Scope *S, VarDecl *D) { 5504 if (Diags.getDiagnosticLevel(diag::warn_decl_shadow, D->getLocation()) == 5505 DiagnosticsEngine::Ignored) 5506 return; 5507 5508 LookupResult R(*this, D->getDeclName(), D->getLocation(), 5509 Sema::LookupOrdinaryName, Sema::ForRedeclaration); 5510 LookupName(R, S); 5511 CheckShadow(S, D, R); 5512} 5513 5514/// Check for conflict between this global or extern "C" declaration and 5515/// previous global or extern "C" declarations. This is only used in C++. 5516template<typename T> 5517static bool checkGlobalOrExternCConflict( 5518 Sema &S, const T *ND, bool IsGlobal, LookupResult &Previous) { 5519 assert(S.getLangOpts().CPlusPlus && "only C++ has extern \"C\""); 5520 NamedDecl *Prev = S.findLocallyScopedExternCDecl(ND->getDeclName()); 5521 5522 if (!Prev && IsGlobal && !isIncompleteDeclExternC(S, ND)) { 5523 // The common case: this global doesn't conflict with any extern "C" 5524 // declaration. 5525 return false; 5526 } 5527 5528 if (Prev) { 5529 if (!IsGlobal || isIncompleteDeclExternC(S, ND)) { 5530 // Both the old and new declarations have C language linkage. This is a 5531 // redeclaration. 5532 Previous.clear(); 5533 Previous.addDecl(Prev); 5534 return true; 5535 } 5536 5537 // This is a global, non-extern "C" declaration, and there is a previous 5538 // non-global extern "C" declaration. Diagnose if this is a variable 5539 // declaration. 5540 if (!isa<VarDecl>(ND)) 5541 return false; 5542 } else { 5543 // The declaration is extern "C". Check for any declaration in the 5544 // translation unit which might conflict. 5545 if (IsGlobal) { 5546 // We have already performed the lookup into the translation unit. 5547 IsGlobal = false; 5548 for (LookupResult::iterator I = Previous.begin(), E = Previous.end(); 5549 I != E; ++I) { 5550 if (isa<VarDecl>(*I)) { 5551 Prev = *I; 5552 break; 5553 } 5554 } 5555 } else { 5556 DeclContext::lookup_result R = 5557 S.Context.getTranslationUnitDecl()->lookup(ND->getDeclName()); 5558 for (DeclContext::lookup_result::iterator I = R.begin(), E = R.end(); 5559 I != E; ++I) { 5560 if (isa<VarDecl>(*I)) { 5561 Prev = *I; 5562 break; 5563 } 5564 // FIXME: If we have any other entity with this name in global scope, 5565 // the declaration is ill-formed, but that is a defect: it breaks the 5566 // 'stat' hack, for instance. Only variables can have mangled name 5567 // clashes with extern "C" declarations, so only they deserve a 5568 // diagnostic. 5569 } 5570 } 5571 5572 if (!Prev) 5573 return false; 5574 } 5575 5576 // Use the first declaration's location to ensure we point at something which 5577 // is lexically inside an extern "C" linkage-spec. 5578 assert(Prev && "should have found a previous declaration to diagnose"); 5579 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(Prev)) 5580 Prev = FD->getFirstDeclaration(); 5581 else 5582 Prev = cast<VarDecl>(Prev)->getFirstDeclaration(); 5583 5584 S.Diag(ND->getLocation(), diag::err_extern_c_global_conflict) 5585 << IsGlobal << ND; 5586 S.Diag(Prev->getLocation(), diag::note_extern_c_global_conflict) 5587 << IsGlobal; 5588 return false; 5589} 5590 5591/// Apply special rules for handling extern "C" declarations. Returns \c true 5592/// if we have found that this is a redeclaration of some prior entity. 5593/// 5594/// Per C++ [dcl.link]p6: 5595/// Two declarations [for a function or variable] with C language linkage 5596/// with the same name that appear in different scopes refer to the same 5597/// [entity]. An entity with C language linkage shall not be declared with 5598/// the same name as an entity in global scope. 5599template<typename T> 5600static bool checkForConflictWithNonVisibleExternC(Sema &S, const T *ND, 5601 LookupResult &Previous) { 5602 if (!S.getLangOpts().CPlusPlus) { 5603 // In C, when declaring a global variable, look for a corresponding 'extern' 5604 // variable declared in function scope. We don't need this in C++, because 5605 // we find local extern decls in the surrounding file-scope DeclContext. 5606 if (ND->getDeclContext()->getRedeclContext()->isTranslationUnit()) { 5607 if (NamedDecl *Prev = S.findLocallyScopedExternCDecl(ND->getDeclName())) { 5608 Previous.clear(); 5609 Previous.addDecl(Prev); 5610 return true; 5611 } 5612 } 5613 return false; 5614 } 5615 5616 // A declaration in the translation unit can conflict with an extern "C" 5617 // declaration. 5618 if (ND->getDeclContext()->getRedeclContext()->isTranslationUnit()) 5619 return checkGlobalOrExternCConflict(S, ND, /*IsGlobal*/true, Previous); 5620 5621 // An extern "C" declaration can conflict with a declaration in the 5622 // translation unit or can be a redeclaration of an extern "C" declaration 5623 // in another scope. 5624 if (isIncompleteDeclExternC(S,ND)) 5625 return checkGlobalOrExternCConflict(S, ND, /*IsGlobal*/false, Previous); 5626 5627 // Neither global nor extern "C": nothing to do. 5628 return false; 5629} 5630 5631void Sema::CheckVariableDeclarationType(VarDecl *NewVD) { 5632 // If the decl is already known invalid, don't check it. 5633 if (NewVD->isInvalidDecl()) 5634 return; 5635 5636 TypeSourceInfo *TInfo = NewVD->getTypeSourceInfo(); 5637 QualType T = TInfo->getType(); 5638 5639 // Defer checking an 'auto' type until its initializer is attached. 5640 if (T->isUndeducedType()) 5641 return; 5642 5643 if (T->isObjCObjectType()) { 5644 Diag(NewVD->getLocation(), diag::err_statically_allocated_object) 5645 << FixItHint::CreateInsertion(NewVD->getLocation(), "*"); 5646 T = Context.getObjCObjectPointerType(T); 5647 NewVD->setType(T); 5648 } 5649 5650 // Emit an error if an address space was applied to decl with local storage. 5651 // This includes arrays of objects with address space qualifiers, but not 5652 // automatic variables that point to other address spaces. 5653 // ISO/IEC TR 18037 S5.1.2 5654 if (NewVD->hasLocalStorage() && T.getAddressSpace() != 0) { 5655 Diag(NewVD->getLocation(), diag::err_as_qualified_auto_decl); 5656 NewVD->setInvalidDecl(); 5657 return; 5658 } 5659 5660 // OpenCL v1.2 s6.5 - All program scope variables must be declared in the 5661 // __constant address space. 5662 if (getLangOpts().OpenCL && NewVD->isFileVarDecl() 5663 && T.getAddressSpace() != LangAS::opencl_constant 5664 && !T->isSamplerT()){ 5665 Diag(NewVD->getLocation(), diag::err_opencl_global_invalid_addr_space); 5666 NewVD->setInvalidDecl(); 5667 return; 5668 } 5669 5670 // OpenCL v1.2 s6.8 -- The static qualifier is valid only in program 5671 // scope. 5672 if ((getLangOpts().OpenCLVersion >= 120) 5673 && NewVD->isStaticLocal()) { 5674 Diag(NewVD->getLocation(), diag::err_static_function_scope); 5675 NewVD->setInvalidDecl(); 5676 return; 5677 } 5678 5679 if (NewVD->hasLocalStorage() && T.isObjCGCWeak() 5680 && !NewVD->hasAttr<BlocksAttr>()) { 5681 if (getLangOpts().getGC() != LangOptions::NonGC) 5682 Diag(NewVD->getLocation(), diag::warn_gc_attribute_weak_on_local); 5683 else { 5684 assert(!getLangOpts().ObjCAutoRefCount); 5685 Diag(NewVD->getLocation(), diag::warn_attribute_weak_on_local); 5686 } 5687 } 5688 5689 bool isVM = T->isVariablyModifiedType(); 5690 if (isVM || NewVD->hasAttr<CleanupAttr>() || 5691 NewVD->hasAttr<BlocksAttr>()) 5692 getCurFunction()->setHasBranchProtectedScope(); 5693 5694 if ((isVM && NewVD->hasLinkage()) || 5695 (T->isVariableArrayType() && NewVD->hasGlobalStorage())) { 5696 bool SizeIsNegative; 5697 llvm::APSInt Oversized; 5698 TypeSourceInfo *FixedTInfo = 5699 TryToFixInvalidVariablyModifiedTypeSourceInfo(TInfo, Context, 5700 SizeIsNegative, Oversized); 5701 if (FixedTInfo == 0 && T->isVariableArrayType()) { 5702 const VariableArrayType *VAT = Context.getAsVariableArrayType(T); 5703 // FIXME: This won't give the correct result for 5704 // int a[10][n]; 5705 SourceRange SizeRange = VAT->getSizeExpr()->getSourceRange(); 5706 5707 if (NewVD->isFileVarDecl()) 5708 Diag(NewVD->getLocation(), diag::err_vla_decl_in_file_scope) 5709 << SizeRange; 5710 else if (NewVD->isStaticLocal()) 5711 Diag(NewVD->getLocation(), diag::err_vla_decl_has_static_storage) 5712 << SizeRange; 5713 else 5714 Diag(NewVD->getLocation(), diag::err_vla_decl_has_extern_linkage) 5715 << SizeRange; 5716 NewVD->setInvalidDecl(); 5717 return; 5718 } 5719 5720 if (FixedTInfo == 0) { 5721 if (NewVD->isFileVarDecl()) 5722 Diag(NewVD->getLocation(), diag::err_vm_decl_in_file_scope); 5723 else 5724 Diag(NewVD->getLocation(), diag::err_vm_decl_has_extern_linkage); 5725 NewVD->setInvalidDecl(); 5726 return; 5727 } 5728 5729 Diag(NewVD->getLocation(), diag::warn_illegal_constant_array_size); 5730 NewVD->setType(FixedTInfo->getType()); 5731 NewVD->setTypeSourceInfo(FixedTInfo); 5732 } 5733 5734 if (T->isVoidType()) { 5735 // C++98 [dcl.stc]p5: The extern specifier can be applied only to the names 5736 // of objects and functions. 5737 if (NewVD->isThisDeclarationADefinition() || getLangOpts().CPlusPlus) { 5738 Diag(NewVD->getLocation(), diag::err_typecheck_decl_incomplete_type) 5739 << T; 5740 NewVD->setInvalidDecl(); 5741 return; 5742 } 5743 } 5744 5745 if (!NewVD->hasLocalStorage() && NewVD->hasAttr<BlocksAttr>()) { 5746 Diag(NewVD->getLocation(), diag::err_block_on_nonlocal); 5747 NewVD->setInvalidDecl(); 5748 return; 5749 } 5750 5751 if (isVM && NewVD->hasAttr<BlocksAttr>()) { 5752 Diag(NewVD->getLocation(), diag::err_block_on_vm); 5753 NewVD->setInvalidDecl(); 5754 return; 5755 } 5756 5757 if (NewVD->isConstexpr() && !T->isDependentType() && 5758 RequireLiteralType(NewVD->getLocation(), T, 5759 diag::err_constexpr_var_non_literal)) { 5760 // Can't perform this check until the type is deduced. 5761 NewVD->setInvalidDecl(); 5762 return; 5763 } 5764} 5765 5766/// \brief Perform semantic checking on a newly-created variable 5767/// declaration. 5768/// 5769/// This routine performs all of the type-checking required for a 5770/// variable declaration once it has been built. It is used both to 5771/// check variables after they have been parsed and their declarators 5772/// have been translated into a declaration, and to check variables 5773/// that have been instantiated from a template. 5774/// 5775/// Sets NewVD->isInvalidDecl() if an error was encountered. 5776/// 5777/// Returns true if the variable declaration is a redeclaration. 5778bool Sema::CheckVariableDeclaration(VarDecl *NewVD, LookupResult &Previous) { 5779 CheckVariableDeclarationType(NewVD); 5780 5781 // If the decl is already known invalid, don't check it. 5782 if (NewVD->isInvalidDecl()) 5783 return false; 5784 5785 // If we did not find anything by this name, look for a non-visible 5786 // extern "C" declaration with the same name. 5787 if (Previous.empty() && 5788 checkForConflictWithNonVisibleExternC(*this, NewVD, Previous)) 5789 Previous.setShadowed(); 5790 5791 // Filter out any non-conflicting previous declarations. 5792 filterNonConflictingPreviousDecls(Context, NewVD, Previous); 5793 5794 if (!Previous.empty()) { 5795 MergeVarDecl(NewVD, Previous); 5796 return true; 5797 } 5798 return false; 5799} 5800 5801/// \brief Data used with FindOverriddenMethod 5802struct FindOverriddenMethodData { 5803 Sema *S; 5804 CXXMethodDecl *Method; 5805}; 5806 5807/// \brief Member lookup function that determines whether a given C++ 5808/// method overrides a method in a base class, to be used with 5809/// CXXRecordDecl::lookupInBases(). 5810static bool FindOverriddenMethod(const CXXBaseSpecifier *Specifier, 5811 CXXBasePath &Path, 5812 void *UserData) { 5813 RecordDecl *BaseRecord = Specifier->getType()->getAs<RecordType>()->getDecl(); 5814 5815 FindOverriddenMethodData *Data 5816 = reinterpret_cast<FindOverriddenMethodData*>(UserData); 5817 5818 DeclarationName Name = Data->Method->getDeclName(); 5819 5820 // FIXME: Do we care about other names here too? 5821 if (Name.getNameKind() == DeclarationName::CXXDestructorName) { 5822 // We really want to find the base class destructor here. 5823 QualType T = Data->S->Context.getTypeDeclType(BaseRecord); 5824 CanQualType CT = Data->S->Context.getCanonicalType(T); 5825 5826 Name = Data->S->Context.DeclarationNames.getCXXDestructorName(CT); 5827 } 5828 5829 for (Path.Decls = BaseRecord->lookup(Name); 5830 !Path.Decls.empty(); 5831 Path.Decls = Path.Decls.slice(1)) { 5832 NamedDecl *D = Path.Decls.front(); 5833 if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(D)) { 5834 if (MD->isVirtual() && !Data->S->IsOverload(Data->Method, MD, false)) 5835 return true; 5836 } 5837 } 5838 5839 return false; 5840} 5841 5842namespace { 5843 enum OverrideErrorKind { OEK_All, OEK_NonDeleted, OEK_Deleted }; 5844} 5845/// \brief Report an error regarding overriding, along with any relevant 5846/// overriden methods. 5847/// 5848/// \param DiagID the primary error to report. 5849/// \param MD the overriding method. 5850/// \param OEK which overrides to include as notes. 5851static void ReportOverrides(Sema& S, unsigned DiagID, const CXXMethodDecl *MD, 5852 OverrideErrorKind OEK = OEK_All) { 5853 S.Diag(MD->getLocation(), DiagID) << MD->getDeclName(); 5854 for (CXXMethodDecl::method_iterator I = MD->begin_overridden_methods(), 5855 E = MD->end_overridden_methods(); 5856 I != E; ++I) { 5857 // This check (& the OEK parameter) could be replaced by a predicate, but 5858 // without lambdas that would be overkill. This is still nicer than writing 5859 // out the diag loop 3 times. 5860 if ((OEK == OEK_All) || 5861 (OEK == OEK_NonDeleted && !(*I)->isDeleted()) || 5862 (OEK == OEK_Deleted && (*I)->isDeleted())) 5863 S.Diag((*I)->getLocation(), diag::note_overridden_virtual_function); 5864 } 5865} 5866 5867/// AddOverriddenMethods - See if a method overrides any in the base classes, 5868/// and if so, check that it's a valid override and remember it. 5869bool Sema::AddOverriddenMethods(CXXRecordDecl *DC, CXXMethodDecl *MD) { 5870 // Look for virtual methods in base classes that this method might override. 5871 CXXBasePaths Paths; 5872 FindOverriddenMethodData Data; 5873 Data.Method = MD; 5874 Data.S = this; 5875 bool hasDeletedOverridenMethods = false; 5876 bool hasNonDeletedOverridenMethods = false; 5877 bool AddedAny = false; 5878 if (DC->lookupInBases(&FindOverriddenMethod, &Data, Paths)) { 5879 for (CXXBasePaths::decl_iterator I = Paths.found_decls_begin(), 5880 E = Paths.found_decls_end(); I != E; ++I) { 5881 if (CXXMethodDecl *OldMD = dyn_cast<CXXMethodDecl>(*I)) { 5882 MD->addOverriddenMethod(OldMD->getCanonicalDecl()); 5883 if (!CheckOverridingFunctionReturnType(MD, OldMD) && 5884 !CheckOverridingFunctionAttributes(MD, OldMD) && 5885 !CheckOverridingFunctionExceptionSpec(MD, OldMD) && 5886 !CheckIfOverriddenFunctionIsMarkedFinal(MD, OldMD)) { 5887 hasDeletedOverridenMethods |= OldMD->isDeleted(); 5888 hasNonDeletedOverridenMethods |= !OldMD->isDeleted(); 5889 AddedAny = true; 5890 } 5891 } 5892 } 5893 } 5894 5895 if (hasDeletedOverridenMethods && !MD->isDeleted()) { 5896 ReportOverrides(*this, diag::err_non_deleted_override, MD, OEK_Deleted); 5897 } 5898 if (hasNonDeletedOverridenMethods && MD->isDeleted()) { 5899 ReportOverrides(*this, diag::err_deleted_override, MD, OEK_NonDeleted); 5900 } 5901 5902 return AddedAny; 5903} 5904 5905namespace { 5906 // Struct for holding all of the extra arguments needed by 5907 // DiagnoseInvalidRedeclaration to call Sema::ActOnFunctionDeclarator. 5908 struct ActOnFDArgs { 5909 Scope *S; 5910 Declarator &D; 5911 MultiTemplateParamsArg TemplateParamLists; 5912 bool AddToScope; 5913 }; 5914} 5915 5916namespace { 5917 5918// Callback to only accept typo corrections that have a non-zero edit distance. 5919// Also only accept corrections that have the same parent decl. 5920class DifferentNameValidatorCCC : public CorrectionCandidateCallback { 5921 public: 5922 DifferentNameValidatorCCC(ASTContext &Context, FunctionDecl *TypoFD, 5923 CXXRecordDecl *Parent) 5924 : Context(Context), OriginalFD(TypoFD), 5925 ExpectedParent(Parent ? Parent->getCanonicalDecl() : 0) {} 5926 5927 virtual bool ValidateCandidate(const TypoCorrection &candidate) { 5928 if (candidate.getEditDistance() == 0) 5929 return false; 5930 5931 SmallVector<unsigned, 1> MismatchedParams; 5932 for (TypoCorrection::const_decl_iterator CDecl = candidate.begin(), 5933 CDeclEnd = candidate.end(); 5934 CDecl != CDeclEnd; ++CDecl) { 5935 FunctionDecl *FD = dyn_cast<FunctionDecl>(*CDecl); 5936 5937 if (FD && !FD->hasBody() && 5938 hasSimilarParameters(Context, FD, OriginalFD, MismatchedParams)) { 5939 if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) { 5940 CXXRecordDecl *Parent = MD->getParent(); 5941 if (Parent && Parent->getCanonicalDecl() == ExpectedParent) 5942 return true; 5943 } else if (!ExpectedParent) { 5944 return true; 5945 } 5946 } 5947 } 5948 5949 return false; 5950 } 5951 5952 private: 5953 ASTContext &Context; 5954 FunctionDecl *OriginalFD; 5955 CXXRecordDecl *ExpectedParent; 5956}; 5957 5958} 5959 5960/// \brief Generate diagnostics for an invalid function redeclaration. 5961/// 5962/// This routine handles generating the diagnostic messages for an invalid 5963/// function redeclaration, including finding possible similar declarations 5964/// or performing typo correction if there are no previous declarations with 5965/// the same name. 5966/// 5967/// Returns a NamedDecl iff typo correction was performed and substituting in 5968/// the new declaration name does not cause new errors. 5969static NamedDecl *DiagnoseInvalidRedeclaration( 5970 Sema &SemaRef, LookupResult &Previous, FunctionDecl *NewFD, 5971 ActOnFDArgs &ExtraArgs, bool IsLocalFriend, Scope *S) { 5972 DeclarationName Name = NewFD->getDeclName(); 5973 DeclContext *NewDC = NewFD->getDeclContext(); 5974 SmallVector<unsigned, 1> MismatchedParams; 5975 SmallVector<std::pair<FunctionDecl *, unsigned>, 1> NearMatches; 5976 TypoCorrection Correction; 5977 bool IsDefinition = ExtraArgs.D.isFunctionDefinition(); 5978 unsigned DiagMsg = IsLocalFriend ? diag::err_no_matching_local_friend 5979 : diag::err_member_decl_does_not_match; 5980 LookupResult Prev(SemaRef, Name, NewFD->getLocation(), 5981 IsLocalFriend ? Sema::LookupLocalFriendName 5982 : Sema::LookupOrdinaryName, 5983 Sema::ForRedeclaration); 5984 5985 NewFD->setInvalidDecl(); 5986 if (IsLocalFriend) 5987 SemaRef.LookupName(Prev, S); 5988 else 5989 SemaRef.LookupQualifiedName(Prev, NewDC); 5990 assert(!Prev.isAmbiguous() && 5991 "Cannot have an ambiguity in previous-declaration lookup"); 5992 CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(NewFD); 5993 DifferentNameValidatorCCC Validator(SemaRef.Context, NewFD, 5994 MD ? MD->getParent() : 0); 5995 if (!Prev.empty()) { 5996 for (LookupResult::iterator Func = Prev.begin(), FuncEnd = Prev.end(); 5997 Func != FuncEnd; ++Func) { 5998 FunctionDecl *FD = dyn_cast<FunctionDecl>(*Func); 5999 if (FD && 6000 hasSimilarParameters(SemaRef.Context, FD, NewFD, MismatchedParams)) { 6001 // Add 1 to the index so that 0 can mean the mismatch didn't 6002 // involve a parameter 6003 unsigned ParamNum = 6004 MismatchedParams.empty() ? 0 : MismatchedParams.front() + 1; 6005 NearMatches.push_back(std::make_pair(FD, ParamNum)); 6006 } 6007 } 6008 // If the qualified name lookup yielded nothing, try typo correction 6009 } else if ((Correction = SemaRef.CorrectTypo( 6010 Prev.getLookupNameInfo(), Prev.getLookupKind(), S, 6011 &ExtraArgs.D.getCXXScopeSpec(), Validator, 6012 IsLocalFriend ? 0 : NewDC))) { 6013 // Set up everything for the call to ActOnFunctionDeclarator 6014 ExtraArgs.D.SetIdentifier(Correction.getCorrectionAsIdentifierInfo(), 6015 ExtraArgs.D.getIdentifierLoc()); 6016 Previous.clear(); 6017 Previous.setLookupName(Correction.getCorrection()); 6018 for (TypoCorrection::decl_iterator CDecl = Correction.begin(), 6019 CDeclEnd = Correction.end(); 6020 CDecl != CDeclEnd; ++CDecl) { 6021 FunctionDecl *FD = dyn_cast<FunctionDecl>(*CDecl); 6022 if (FD && !FD->hasBody() && 6023 hasSimilarParameters(SemaRef.Context, FD, NewFD, MismatchedParams)) { 6024 Previous.addDecl(FD); 6025 } 6026 } 6027 bool wasRedeclaration = ExtraArgs.D.isRedeclaration(); 6028 6029 NamedDecl *Result; 6030 // Retry building the function declaration with the new previous 6031 // declarations, and with errors suppressed. 6032 { 6033 // Trap errors. 6034 Sema::SFINAETrap Trap(SemaRef); 6035 6036 // TODO: Refactor ActOnFunctionDeclarator so that we can call only the 6037 // pieces need to verify the typo-corrected C++ declaration and hopefully 6038 // eliminate the need for the parameter pack ExtraArgs. 6039 Result = SemaRef.ActOnFunctionDeclarator( 6040 ExtraArgs.S, ExtraArgs.D, 6041 Correction.getCorrectionDecl()->getDeclContext(), 6042 NewFD->getTypeSourceInfo(), Previous, ExtraArgs.TemplateParamLists, 6043 ExtraArgs.AddToScope); 6044 6045 if (Trap.hasErrorOccurred()) 6046 Result = 0; 6047 } 6048 6049 if (Result) { 6050 // Determine which correction we picked. 6051 Decl *Canonical = Result->getCanonicalDecl(); 6052 for (LookupResult::iterator I = Previous.begin(), E = Previous.end(); 6053 I != E; ++I) 6054 if ((*I)->getCanonicalDecl() == Canonical) 6055 Correction.setCorrectionDecl(*I); 6056 6057 SemaRef.diagnoseTypo( 6058 Correction, 6059 SemaRef.PDiag(IsLocalFriend 6060 ? diag::err_no_matching_local_friend_suggest 6061 : diag::err_member_decl_does_not_match_suggest) 6062 << Name << NewDC << IsDefinition); 6063 return Result; 6064 } 6065 6066 // Pretend the typo correction never occurred 6067 ExtraArgs.D.SetIdentifier(Name.getAsIdentifierInfo(), 6068 ExtraArgs.D.getIdentifierLoc()); 6069 ExtraArgs.D.setRedeclaration(wasRedeclaration); 6070 Previous.clear(); 6071 Previous.setLookupName(Name); 6072 } 6073 6074 SemaRef.Diag(NewFD->getLocation(), DiagMsg) 6075 << Name << NewDC << IsDefinition << NewFD->getLocation(); 6076 6077 bool NewFDisConst = false; 6078 if (CXXMethodDecl *NewMD = dyn_cast<CXXMethodDecl>(NewFD)) 6079 NewFDisConst = NewMD->isConst(); 6080 6081 for (SmallVectorImpl<std::pair<FunctionDecl *, unsigned> >::iterator 6082 NearMatch = NearMatches.begin(), NearMatchEnd = NearMatches.end(); 6083 NearMatch != NearMatchEnd; ++NearMatch) { 6084 FunctionDecl *FD = NearMatch->first; 6085 CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD); 6086 bool FDisConst = MD && MD->isConst(); 6087 bool IsMember = MD || !IsLocalFriend; 6088 6089 // FIXME: These notes are poorly worded for the local friend case. 6090 if (unsigned Idx = NearMatch->second) { 6091 ParmVarDecl *FDParam = FD->getParamDecl(Idx-1); 6092 SourceLocation Loc = FDParam->getTypeSpecStartLoc(); 6093 if (Loc.isInvalid()) Loc = FD->getLocation(); 6094 SemaRef.Diag(Loc, IsMember ? diag::note_member_def_close_param_match 6095 : diag::note_local_decl_close_param_match) 6096 << Idx << FDParam->getType() 6097 << NewFD->getParamDecl(Idx - 1)->getType(); 6098 } else if (FDisConst != NewFDisConst) { 6099 SemaRef.Diag(FD->getLocation(), diag::note_member_def_close_const_match) 6100 << NewFDisConst << FD->getSourceRange().getEnd(); 6101 } else 6102 SemaRef.Diag(FD->getLocation(), 6103 IsMember ? diag::note_member_def_close_match 6104 : diag::note_local_decl_close_match); 6105 } 6106 return 0; 6107} 6108 6109static FunctionDecl::StorageClass getFunctionStorageClass(Sema &SemaRef, 6110 Declarator &D) { 6111 switch (D.getDeclSpec().getStorageClassSpec()) { 6112 default: llvm_unreachable("Unknown storage class!"); 6113 case DeclSpec::SCS_auto: 6114 case DeclSpec::SCS_register: 6115 case DeclSpec::SCS_mutable: 6116 SemaRef.Diag(D.getDeclSpec().getStorageClassSpecLoc(), 6117 diag::err_typecheck_sclass_func); 6118 D.setInvalidType(); 6119 break; 6120 case DeclSpec::SCS_unspecified: break; 6121 case DeclSpec::SCS_extern: 6122 if (D.getDeclSpec().isExternInLinkageSpec()) 6123 return SC_None; 6124 return SC_Extern; 6125 case DeclSpec::SCS_static: { 6126 if (SemaRef.CurContext->getRedeclContext()->isFunctionOrMethod()) { 6127 // C99 6.7.1p5: 6128 // The declaration of an identifier for a function that has 6129 // block scope shall have no explicit storage-class specifier 6130 // other than extern 6131 // See also (C++ [dcl.stc]p4). 6132 SemaRef.Diag(D.getDeclSpec().getStorageClassSpecLoc(), 6133 diag::err_static_block_func); 6134 break; 6135 } else 6136 return SC_Static; 6137 } 6138 case DeclSpec::SCS_private_extern: return SC_PrivateExtern; 6139 } 6140 6141 // No explicit storage class has already been returned 6142 return SC_None; 6143} 6144 6145static FunctionDecl* CreateNewFunctionDecl(Sema &SemaRef, Declarator &D, 6146 DeclContext *DC, QualType &R, 6147 TypeSourceInfo *TInfo, 6148 FunctionDecl::StorageClass SC, 6149 bool &IsVirtualOkay) { 6150 DeclarationNameInfo NameInfo = SemaRef.GetNameForDeclarator(D); 6151 DeclarationName Name = NameInfo.getName(); 6152 6153 FunctionDecl *NewFD = 0; 6154 bool isInline = D.getDeclSpec().isInlineSpecified(); 6155 6156 if (!SemaRef.getLangOpts().CPlusPlus) { 6157 // Determine whether the function was written with a 6158 // prototype. This true when: 6159 // - there is a prototype in the declarator, or 6160 // - the type R of the function is some kind of typedef or other reference 6161 // to a type name (which eventually refers to a function type). 6162 bool HasPrototype = 6163 (D.isFunctionDeclarator() && D.getFunctionTypeInfo().hasPrototype) || 6164 (!isa<FunctionType>(R.getTypePtr()) && R->isFunctionProtoType()); 6165 6166 NewFD = FunctionDecl::Create(SemaRef.Context, DC, 6167 D.getLocStart(), NameInfo, R, 6168 TInfo, SC, isInline, 6169 HasPrototype, false); 6170 if (D.isInvalidType()) 6171 NewFD->setInvalidDecl(); 6172 6173 // Set the lexical context. 6174 NewFD->setLexicalDeclContext(SemaRef.CurContext); 6175 6176 return NewFD; 6177 } 6178 6179 bool isExplicit = D.getDeclSpec().isExplicitSpecified(); 6180 bool isConstexpr = D.getDeclSpec().isConstexprSpecified(); 6181 6182 // Check that the return type is not an abstract class type. 6183 // For record types, this is done by the AbstractClassUsageDiagnoser once 6184 // the class has been completely parsed. 6185 if (!DC->isRecord() && 6186 SemaRef.RequireNonAbstractType(D.getIdentifierLoc(), 6187 R->getAs<FunctionType>()->getResultType(), 6188 diag::err_abstract_type_in_decl, 6189 SemaRef.AbstractReturnType)) 6190 D.setInvalidType(); 6191 6192 if (Name.getNameKind() == DeclarationName::CXXConstructorName) { 6193 // This is a C++ constructor declaration. 6194 assert(DC->isRecord() && 6195 "Constructors can only be declared in a member context"); 6196 6197 R = SemaRef.CheckConstructorDeclarator(D, R, SC); 6198 return CXXConstructorDecl::Create(SemaRef.Context, cast<CXXRecordDecl>(DC), 6199 D.getLocStart(), NameInfo, 6200 R, TInfo, isExplicit, isInline, 6201 /*isImplicitlyDeclared=*/false, 6202 isConstexpr); 6203 6204 } else if (Name.getNameKind() == DeclarationName::CXXDestructorName) { 6205 // This is a C++ destructor declaration. 6206 if (DC->isRecord()) { 6207 R = SemaRef.CheckDestructorDeclarator(D, R, SC); 6208 CXXRecordDecl *Record = cast<CXXRecordDecl>(DC); 6209 CXXDestructorDecl *NewDD = CXXDestructorDecl::Create( 6210 SemaRef.Context, Record, 6211 D.getLocStart(), 6212 NameInfo, R, TInfo, isInline, 6213 /*isImplicitlyDeclared=*/false); 6214 6215 // If the class is complete, then we now create the implicit exception 6216 // specification. If the class is incomplete or dependent, we can't do 6217 // it yet. 6218 if (SemaRef.getLangOpts().CPlusPlus11 && !Record->isDependentType() && 6219 Record->getDefinition() && !Record->isBeingDefined() && 6220 R->getAs<FunctionProtoType>()->getExceptionSpecType() == EST_None) { 6221 SemaRef.AdjustDestructorExceptionSpec(Record, NewDD); 6222 } 6223 6224 // The Microsoft ABI requires that we perform the destructor body 6225 // checks (i.e. operator delete() lookup) at every declaration, as 6226 // any translation unit may need to emit a deleting destructor. 6227 if (SemaRef.Context.getTargetInfo().getCXXABI().isMicrosoft() && 6228 !Record->isDependentType() && Record->getDefinition() && 6229 !Record->isBeingDefined()) { 6230 SemaRef.CheckDestructor(NewDD); 6231 } 6232 6233 IsVirtualOkay = true; 6234 return NewDD; 6235 6236 } else { 6237 SemaRef.Diag(D.getIdentifierLoc(), diag::err_destructor_not_member); 6238 D.setInvalidType(); 6239 6240 // Create a FunctionDecl to satisfy the function definition parsing 6241 // code path. 6242 return FunctionDecl::Create(SemaRef.Context, DC, 6243 D.getLocStart(), 6244 D.getIdentifierLoc(), Name, R, TInfo, 6245 SC, isInline, 6246 /*hasPrototype=*/true, isConstexpr); 6247 } 6248 6249 } else if (Name.getNameKind() == DeclarationName::CXXConversionFunctionName) { 6250 if (!DC->isRecord()) { 6251 SemaRef.Diag(D.getIdentifierLoc(), 6252 diag::err_conv_function_not_member); 6253 return 0; 6254 } 6255 6256 SemaRef.CheckConversionDeclarator(D, R, SC); 6257 IsVirtualOkay = true; 6258 return CXXConversionDecl::Create(SemaRef.Context, cast<CXXRecordDecl>(DC), 6259 D.getLocStart(), NameInfo, 6260 R, TInfo, isInline, isExplicit, 6261 isConstexpr, SourceLocation()); 6262 6263 } else if (DC->isRecord()) { 6264 // If the name of the function is the same as the name of the record, 6265 // then this must be an invalid constructor that has a return type. 6266 // (The parser checks for a return type and makes the declarator a 6267 // constructor if it has no return type). 6268 if (Name.getAsIdentifierInfo() && 6269 Name.getAsIdentifierInfo() == cast<CXXRecordDecl>(DC)->getIdentifier()){ 6270 SemaRef.Diag(D.getIdentifierLoc(), diag::err_constructor_return_type) 6271 << SourceRange(D.getDeclSpec().getTypeSpecTypeLoc()) 6272 << SourceRange(D.getIdentifierLoc()); 6273 return 0; 6274 } 6275 6276 // This is a C++ method declaration. 6277 CXXMethodDecl *Ret = CXXMethodDecl::Create(SemaRef.Context, 6278 cast<CXXRecordDecl>(DC), 6279 D.getLocStart(), NameInfo, R, 6280 TInfo, SC, isInline, 6281 isConstexpr, SourceLocation()); 6282 IsVirtualOkay = !Ret->isStatic(); 6283 return Ret; 6284 } else { 6285 // Determine whether the function was written with a 6286 // prototype. This true when: 6287 // - we're in C++ (where every function has a prototype), 6288 return FunctionDecl::Create(SemaRef.Context, DC, 6289 D.getLocStart(), 6290 NameInfo, R, TInfo, SC, isInline, 6291 true/*HasPrototype*/, isConstexpr); 6292 } 6293} 6294 6295void Sema::checkVoidParamDecl(ParmVarDecl *Param) { 6296 // In C++, the empty parameter-type-list must be spelled "void"; a 6297 // typedef of void is not permitted. 6298 if (getLangOpts().CPlusPlus && 6299 Param->getType().getUnqualifiedType() != Context.VoidTy) { 6300 bool IsTypeAlias = false; 6301 if (const TypedefType *TT = Param->getType()->getAs<TypedefType>()) 6302 IsTypeAlias = isa<TypeAliasDecl>(TT->getDecl()); 6303 else if (const TemplateSpecializationType *TST = 6304 Param->getType()->getAs<TemplateSpecializationType>()) 6305 IsTypeAlias = TST->isTypeAlias(); 6306 Diag(Param->getLocation(), diag::err_param_typedef_of_void) 6307 << IsTypeAlias; 6308 } 6309} 6310 6311enum OpenCLParamType { 6312 ValidKernelParam, 6313 PtrPtrKernelParam, 6314 PtrKernelParam, 6315 InvalidKernelParam, 6316 RecordKernelParam 6317}; 6318 6319static OpenCLParamType getOpenCLKernelParameterType(QualType PT) { 6320 if (PT->isPointerType()) { 6321 QualType PointeeType = PT->getPointeeType(); 6322 return PointeeType->isPointerType() ? PtrPtrKernelParam : PtrKernelParam; 6323 } 6324 6325 // TODO: Forbid the other integer types (size_t, ptrdiff_t...) when they can 6326 // be used as builtin types. 6327 6328 if (PT->isImageType()) 6329 return PtrKernelParam; 6330 6331 if (PT->isBooleanType()) 6332 return InvalidKernelParam; 6333 6334 if (PT->isEventT()) 6335 return InvalidKernelParam; 6336 6337 if (PT->isHalfType()) 6338 return InvalidKernelParam; 6339 6340 if (PT->isRecordType()) 6341 return RecordKernelParam; 6342 6343 return ValidKernelParam; 6344} 6345 6346static void checkIsValidOpenCLKernelParameter( 6347 Sema &S, 6348 Declarator &D, 6349 ParmVarDecl *Param, 6350 llvm::SmallPtrSet<const Type *, 16> &ValidTypes) { 6351 QualType PT = Param->getType(); 6352 6353 // Cache the valid types we encounter to avoid rechecking structs that are 6354 // used again 6355 if (ValidTypes.count(PT.getTypePtr())) 6356 return; 6357 6358 switch (getOpenCLKernelParameterType(PT)) { 6359 case PtrPtrKernelParam: 6360 // OpenCL v1.2 s6.9.a: 6361 // A kernel function argument cannot be declared as a 6362 // pointer to a pointer type. 6363 S.Diag(Param->getLocation(), diag::err_opencl_ptrptr_kernel_param); 6364 D.setInvalidType(); 6365 return; 6366 6367 // OpenCL v1.2 s6.9.k: 6368 // Arguments to kernel functions in a program cannot be declared with the 6369 // built-in scalar types bool, half, size_t, ptrdiff_t, intptr_t, and 6370 // uintptr_t or a struct and/or union that contain fields declared to be 6371 // one of these built-in scalar types. 6372 6373 case InvalidKernelParam: 6374 // OpenCL v1.2 s6.8 n: 6375 // A kernel function argument cannot be declared 6376 // of event_t type. 6377 S.Diag(Param->getLocation(), diag::err_bad_kernel_param_type) << PT; 6378 D.setInvalidType(); 6379 return; 6380 6381 case PtrKernelParam: 6382 case ValidKernelParam: 6383 ValidTypes.insert(PT.getTypePtr()); 6384 return; 6385 6386 case RecordKernelParam: 6387 break; 6388 } 6389 6390 // Track nested structs we will inspect 6391 SmallVector<const Decl *, 4> VisitStack; 6392 6393 // Track where we are in the nested structs. Items will migrate from 6394 // VisitStack to HistoryStack as we do the DFS for bad field. 6395 SmallVector<const FieldDecl *, 4> HistoryStack; 6396 HistoryStack.push_back((const FieldDecl *) 0); 6397 6398 const RecordDecl *PD = PT->castAs<RecordType>()->getDecl(); 6399 VisitStack.push_back(PD); 6400 6401 assert(VisitStack.back() && "First decl null?"); 6402 6403 do { 6404 const Decl *Next = VisitStack.pop_back_val(); 6405 if (!Next) { 6406 assert(!HistoryStack.empty()); 6407 // Found a marker, we have gone up a level 6408 if (const FieldDecl *Hist = HistoryStack.pop_back_val()) 6409 ValidTypes.insert(Hist->getType().getTypePtr()); 6410 6411 continue; 6412 } 6413 6414 // Adds everything except the original parameter declaration (which is not a 6415 // field itself) to the history stack. 6416 const RecordDecl *RD; 6417 if (const FieldDecl *Field = dyn_cast<FieldDecl>(Next)) { 6418 HistoryStack.push_back(Field); 6419 RD = Field->getType()->castAs<RecordType>()->getDecl(); 6420 } else { 6421 RD = cast<RecordDecl>(Next); 6422 } 6423 6424 // Add a null marker so we know when we've gone back up a level 6425 VisitStack.push_back((const Decl *) 0); 6426 6427 for (RecordDecl::field_iterator I = RD->field_begin(), 6428 E = RD->field_end(); I != E; ++I) { 6429 const FieldDecl *FD = *I; 6430 QualType QT = FD->getType(); 6431 6432 if (ValidTypes.count(QT.getTypePtr())) 6433 continue; 6434 6435 OpenCLParamType ParamType = getOpenCLKernelParameterType(QT); 6436 if (ParamType == ValidKernelParam) 6437 continue; 6438 6439 if (ParamType == RecordKernelParam) { 6440 VisitStack.push_back(FD); 6441 continue; 6442 } 6443 6444 // OpenCL v1.2 s6.9.p: 6445 // Arguments to kernel functions that are declared to be a struct or union 6446 // do not allow OpenCL objects to be passed as elements of the struct or 6447 // union. 6448 if (ParamType == PtrKernelParam || ParamType == PtrPtrKernelParam) { 6449 S.Diag(Param->getLocation(), 6450 diag::err_record_with_pointers_kernel_param) 6451 << PT->isUnionType() 6452 << PT; 6453 } else { 6454 S.Diag(Param->getLocation(), diag::err_bad_kernel_param_type) << PT; 6455 } 6456 6457 S.Diag(PD->getLocation(), diag::note_within_field_of_type) 6458 << PD->getDeclName(); 6459 6460 // We have an error, now let's go back up through history and show where 6461 // the offending field came from 6462 for (ArrayRef<const FieldDecl *>::const_iterator I = HistoryStack.begin() + 1, 6463 E = HistoryStack.end(); I != E; ++I) { 6464 const FieldDecl *OuterField = *I; 6465 S.Diag(OuterField->getLocation(), diag::note_within_field_of_type) 6466 << OuterField->getType(); 6467 } 6468 6469 S.Diag(FD->getLocation(), diag::note_illegal_field_declared_here) 6470 << QT->isPointerType() 6471 << QT; 6472 D.setInvalidType(); 6473 return; 6474 } 6475 } while (!VisitStack.empty()); 6476} 6477 6478NamedDecl* 6479Sema::ActOnFunctionDeclarator(Scope *S, Declarator &D, DeclContext *DC, 6480 TypeSourceInfo *TInfo, LookupResult &Previous, 6481 MultiTemplateParamsArg TemplateParamLists, 6482 bool &AddToScope) { 6483 QualType R = TInfo->getType(); 6484 6485 assert(R.getTypePtr()->isFunctionType()); 6486 6487 // TODO: consider using NameInfo for diagnostic. 6488 DeclarationNameInfo NameInfo = GetNameForDeclarator(D); 6489 DeclarationName Name = NameInfo.getName(); 6490 FunctionDecl::StorageClass SC = getFunctionStorageClass(*this, D); 6491 6492 if (DeclSpec::TSCS TSCS = D.getDeclSpec().getThreadStorageClassSpec()) 6493 Diag(D.getDeclSpec().getThreadStorageClassSpecLoc(), 6494 diag::err_invalid_thread) 6495 << DeclSpec::getSpecifierName(TSCS); 6496 6497 if (DC->isRecord() && 6498 D.getDeclSpec().getStorageClassSpec() != DeclSpec::SCS_static && 6499 !D.getDeclSpec().isFriendSpecified()) 6500 adjustMemberFunctionCC(R); 6501 6502 bool isFriend = false; 6503 FunctionTemplateDecl *FunctionTemplate = 0; 6504 bool isExplicitSpecialization = false; 6505 bool isFunctionTemplateSpecialization = false; 6506 6507 bool isDependentClassScopeExplicitSpecialization = false; 6508 bool HasExplicitTemplateArgs = false; 6509 TemplateArgumentListInfo TemplateArgs; 6510 6511 bool isVirtualOkay = false; 6512 6513 DeclContext *OriginalDC = DC; 6514 bool IsLocalExternDecl = adjustContextForLocalExternDecl(DC); 6515 6516 FunctionDecl *NewFD = CreateNewFunctionDecl(*this, D, DC, R, TInfo, SC, 6517 isVirtualOkay); 6518 if (!NewFD) return 0; 6519 6520 if (OriginalLexicalContext && OriginalLexicalContext->isObjCContainer()) 6521 NewFD->setTopLevelDeclInObjCContainer(); 6522 6523 // Set the lexical context. If this is a function-scope declaration, or has a 6524 // C++ scope specifier, or is the object of a friend declaration, the lexical 6525 // context will be different from the semantic context. 6526 NewFD->setLexicalDeclContext(CurContext); 6527 6528 if (IsLocalExternDecl) 6529 NewFD->setLocalExternDecl(); 6530 6531 if (getLangOpts().CPlusPlus) { 6532 bool isInline = D.getDeclSpec().isInlineSpecified(); 6533 bool isVirtual = D.getDeclSpec().isVirtualSpecified(); 6534 bool isExplicit = D.getDeclSpec().isExplicitSpecified(); 6535 bool isConstexpr = D.getDeclSpec().isConstexprSpecified(); 6536 isFriend = D.getDeclSpec().isFriendSpecified(); 6537 if (isFriend && !isInline && D.isFunctionDefinition()) { 6538 // C++ [class.friend]p5 6539 // A function can be defined in a friend declaration of a 6540 // class . . . . Such a function is implicitly inline. 6541 NewFD->setImplicitlyInline(); 6542 } 6543 6544 // If this is a method defined in an __interface, and is not a constructor 6545 // or an overloaded operator, then set the pure flag (isVirtual will already 6546 // return true). 6547 if (const CXXRecordDecl *Parent = 6548 dyn_cast<CXXRecordDecl>(NewFD->getDeclContext())) { 6549 if (Parent->isInterface() && cast<CXXMethodDecl>(NewFD)->isUserProvided()) 6550 NewFD->setPure(true); 6551 } 6552 6553 SetNestedNameSpecifier(NewFD, D); 6554 isExplicitSpecialization = false; 6555 isFunctionTemplateSpecialization = false; 6556 if (D.isInvalidType()) 6557 NewFD->setInvalidDecl(); 6558 6559 // Match up the template parameter lists with the scope specifier, then 6560 // determine whether we have a template or a template specialization. 6561 bool Invalid = false; 6562 if (TemplateParameterList *TemplateParams = 6563 MatchTemplateParametersToScopeSpecifier( 6564 D.getDeclSpec().getLocStart(), D.getIdentifierLoc(), 6565 D.getCXXScopeSpec(), TemplateParamLists, isFriend, 6566 isExplicitSpecialization, Invalid)) { 6567 if (TemplateParams->size() > 0) { 6568 // This is a function template 6569 6570 // Check that we can declare a template here. 6571 if (CheckTemplateDeclScope(S, TemplateParams)) 6572 return 0; 6573 6574 // A destructor cannot be a template. 6575 if (Name.getNameKind() == DeclarationName::CXXDestructorName) { 6576 Diag(NewFD->getLocation(), diag::err_destructor_template); 6577 return 0; 6578 } 6579 6580 // If we're adding a template to a dependent context, we may need to 6581 // rebuilding some of the types used within the template parameter list, 6582 // now that we know what the current instantiation is. 6583 if (DC->isDependentContext()) { 6584 ContextRAII SavedContext(*this, DC); 6585 if (RebuildTemplateParamsInCurrentInstantiation(TemplateParams)) 6586 Invalid = true; 6587 } 6588 6589 6590 FunctionTemplate = FunctionTemplateDecl::Create(Context, DC, 6591 NewFD->getLocation(), 6592 Name, TemplateParams, 6593 NewFD); 6594 FunctionTemplate->setLexicalDeclContext(CurContext); 6595 NewFD->setDescribedFunctionTemplate(FunctionTemplate); 6596 6597 // For source fidelity, store the other template param lists. 6598 if (TemplateParamLists.size() > 1) { 6599 NewFD->setTemplateParameterListsInfo(Context, 6600 TemplateParamLists.size() - 1, 6601 TemplateParamLists.data()); 6602 } 6603 } else { 6604 // This is a function template specialization. 6605 isFunctionTemplateSpecialization = true; 6606 // For source fidelity, store all the template param lists. 6607 NewFD->setTemplateParameterListsInfo(Context, 6608 TemplateParamLists.size(), 6609 TemplateParamLists.data()); 6610 6611 // C++0x [temp.expl.spec]p20 forbids "template<> friend void foo(int);". 6612 if (isFriend) { 6613 // We want to remove the "template<>", found here. 6614 SourceRange RemoveRange = TemplateParams->getSourceRange(); 6615 6616 // If we remove the template<> and the name is not a 6617 // template-id, we're actually silently creating a problem: 6618 // the friend declaration will refer to an untemplated decl, 6619 // and clearly the user wants a template specialization. So 6620 // we need to insert '<>' after the name. 6621 SourceLocation InsertLoc; 6622 if (D.getName().getKind() != UnqualifiedId::IK_TemplateId) { 6623 InsertLoc = D.getName().getSourceRange().getEnd(); 6624 InsertLoc = PP.getLocForEndOfToken(InsertLoc); 6625 } 6626 6627 Diag(D.getIdentifierLoc(), diag::err_template_spec_decl_friend) 6628 << Name << RemoveRange 6629 << FixItHint::CreateRemoval(RemoveRange) 6630 << FixItHint::CreateInsertion(InsertLoc, "<>"); 6631 } 6632 } 6633 } 6634 else { 6635 // All template param lists were matched against the scope specifier: 6636 // this is NOT (an explicit specialization of) a template. 6637 if (TemplateParamLists.size() > 0) 6638 // For source fidelity, store all the template param lists. 6639 NewFD->setTemplateParameterListsInfo(Context, 6640 TemplateParamLists.size(), 6641 TemplateParamLists.data()); 6642 } 6643 6644 if (Invalid) { 6645 NewFD->setInvalidDecl(); 6646 if (FunctionTemplate) 6647 FunctionTemplate->setInvalidDecl(); 6648 } 6649 6650 // C++ [dcl.fct.spec]p5: 6651 // The virtual specifier shall only be used in declarations of 6652 // nonstatic class member functions that appear within a 6653 // member-specification of a class declaration; see 10.3. 6654 // 6655 if (isVirtual && !NewFD->isInvalidDecl()) { 6656 if (!isVirtualOkay) { 6657 Diag(D.getDeclSpec().getVirtualSpecLoc(), 6658 diag::err_virtual_non_function); 6659 } else if (!CurContext->isRecord()) { 6660 // 'virtual' was specified outside of the class. 6661 Diag(D.getDeclSpec().getVirtualSpecLoc(), 6662 diag::err_virtual_out_of_class) 6663 << FixItHint::CreateRemoval(D.getDeclSpec().getVirtualSpecLoc()); 6664 } else if (NewFD->getDescribedFunctionTemplate()) { 6665 // C++ [temp.mem]p3: 6666 // A member function template shall not be virtual. 6667 Diag(D.getDeclSpec().getVirtualSpecLoc(), 6668 diag::err_virtual_member_function_template) 6669 << FixItHint::CreateRemoval(D.getDeclSpec().getVirtualSpecLoc()); 6670 } else { 6671 // Okay: Add virtual to the method. 6672 NewFD->setVirtualAsWritten(true); 6673 } 6674 6675 if (getLangOpts().CPlusPlus1y && 6676 NewFD->getResultType()->isUndeducedType()) 6677 Diag(D.getDeclSpec().getVirtualSpecLoc(), diag::err_auto_fn_virtual); 6678 } 6679 6680 if (getLangOpts().CPlusPlus1y && NewFD->isDependentContext() && 6681 NewFD->getResultType()->isUndeducedType()) { 6682 // If the function template is referenced directly (for instance, as a 6683 // member of the current instantiation), pretend it has a dependent type. 6684 // This is not really justified by the standard, but is the only sane 6685 // thing to do. 6686 const FunctionProtoType *FPT = 6687 NewFD->getType()->castAs<FunctionProtoType>(); 6688 QualType Result = SubstAutoType(FPT->getResultType(), 6689 Context.DependentTy); 6690 NewFD->setType(Context.getFunctionType(Result, FPT->getArgTypes(), 6691 FPT->getExtProtoInfo())); 6692 } 6693 6694 // C++ [dcl.fct.spec]p3: 6695 // The inline specifier shall not appear on a block scope function 6696 // declaration. 6697 if (isInline && !NewFD->isInvalidDecl()) { 6698 if (CurContext->isFunctionOrMethod()) { 6699 // 'inline' is not allowed on block scope function declaration. 6700 Diag(D.getDeclSpec().getInlineSpecLoc(), 6701 diag::err_inline_declaration_block_scope) << Name 6702 << FixItHint::CreateRemoval(D.getDeclSpec().getInlineSpecLoc()); 6703 } 6704 } 6705 6706 // C++ [dcl.fct.spec]p6: 6707 // The explicit specifier shall be used only in the declaration of a 6708 // constructor or conversion function within its class definition; 6709 // see 12.3.1 and 12.3.2. 6710 if (isExplicit && !NewFD->isInvalidDecl()) { 6711 if (!CurContext->isRecord()) { 6712 // 'explicit' was specified outside of the class. 6713 Diag(D.getDeclSpec().getExplicitSpecLoc(), 6714 diag::err_explicit_out_of_class) 6715 << FixItHint::CreateRemoval(D.getDeclSpec().getExplicitSpecLoc()); 6716 } else if (!isa<CXXConstructorDecl>(NewFD) && 6717 !isa<CXXConversionDecl>(NewFD)) { 6718 // 'explicit' was specified on a function that wasn't a constructor 6719 // or conversion function. 6720 Diag(D.getDeclSpec().getExplicitSpecLoc(), 6721 diag::err_explicit_non_ctor_or_conv_function) 6722 << FixItHint::CreateRemoval(D.getDeclSpec().getExplicitSpecLoc()); 6723 } 6724 } 6725 6726 if (isConstexpr) { 6727 // C++11 [dcl.constexpr]p2: constexpr functions and constexpr constructors 6728 // are implicitly inline. 6729 NewFD->setImplicitlyInline(); 6730 6731 // C++11 [dcl.constexpr]p3: functions declared constexpr are required to 6732 // be either constructors or to return a literal type. Therefore, 6733 // destructors cannot be declared constexpr. 6734 if (isa<CXXDestructorDecl>(NewFD)) 6735 Diag(D.getDeclSpec().getConstexprSpecLoc(), diag::err_constexpr_dtor); 6736 } 6737 6738 // If __module_private__ was specified, mark the function accordingly. 6739 if (D.getDeclSpec().isModulePrivateSpecified()) { 6740 if (isFunctionTemplateSpecialization) { 6741 SourceLocation ModulePrivateLoc 6742 = D.getDeclSpec().getModulePrivateSpecLoc(); 6743 Diag(ModulePrivateLoc, diag::err_module_private_specialization) 6744 << 0 6745 << FixItHint::CreateRemoval(ModulePrivateLoc); 6746 } else { 6747 NewFD->setModulePrivate(); 6748 if (FunctionTemplate) 6749 FunctionTemplate->setModulePrivate(); 6750 } 6751 } 6752 6753 if (isFriend) { 6754 if (FunctionTemplate) { 6755 FunctionTemplate->setObjectOfFriendDecl(); 6756 FunctionTemplate->setAccess(AS_public); 6757 } 6758 NewFD->setObjectOfFriendDecl(); 6759 NewFD->setAccess(AS_public); 6760 } 6761 6762 // If a function is defined as defaulted or deleted, mark it as such now. 6763 switch (D.getFunctionDefinitionKind()) { 6764 case FDK_Declaration: 6765 case FDK_Definition: 6766 break; 6767 6768 case FDK_Defaulted: 6769 NewFD->setDefaulted(); 6770 break; 6771 6772 case FDK_Deleted: 6773 NewFD->setDeletedAsWritten(); 6774 break; 6775 } 6776 6777 if (isa<CXXMethodDecl>(NewFD) && DC == CurContext && 6778 D.isFunctionDefinition()) { 6779 // C++ [class.mfct]p2: 6780 // A member function may be defined (8.4) in its class definition, in 6781 // which case it is an inline member function (7.1.2) 6782 NewFD->setImplicitlyInline(); 6783 } 6784 6785 if (SC == SC_Static && isa<CXXMethodDecl>(NewFD) && 6786 !CurContext->isRecord()) { 6787 // C++ [class.static]p1: 6788 // A data or function member of a class may be declared static 6789 // in a class definition, in which case it is a static member of 6790 // the class. 6791 6792 // Complain about the 'static' specifier if it's on an out-of-line 6793 // member function definition. 6794 Diag(D.getDeclSpec().getStorageClassSpecLoc(), 6795 diag::err_static_out_of_line) 6796 << FixItHint::CreateRemoval(D.getDeclSpec().getStorageClassSpecLoc()); 6797 } 6798 6799 // C++11 [except.spec]p15: 6800 // A deallocation function with no exception-specification is treated 6801 // as if it were specified with noexcept(true). 6802 const FunctionProtoType *FPT = R->getAs<FunctionProtoType>(); 6803 if ((Name.getCXXOverloadedOperator() == OO_Delete || 6804 Name.getCXXOverloadedOperator() == OO_Array_Delete) && 6805 getLangOpts().CPlusPlus11 && FPT && !FPT->hasExceptionSpec()) { 6806 FunctionProtoType::ExtProtoInfo EPI = FPT->getExtProtoInfo(); 6807 EPI.ExceptionSpecType = EST_BasicNoexcept; 6808 NewFD->setType(Context.getFunctionType(FPT->getResultType(), 6809 FPT->getArgTypes(), EPI)); 6810 } 6811 } 6812 6813 // Filter out previous declarations that don't match the scope. 6814 FilterLookupForScope(Previous, OriginalDC, S, shouldConsiderLinkage(NewFD), 6815 isExplicitSpecialization || 6816 isFunctionTemplateSpecialization); 6817 6818 // Handle GNU asm-label extension (encoded as an attribute). 6819 if (Expr *E = (Expr*) D.getAsmLabel()) { 6820 // The parser guarantees this is a string. 6821 StringLiteral *SE = cast<StringLiteral>(E); 6822 NewFD->addAttr(::new (Context) AsmLabelAttr(SE->getStrTokenLoc(0), Context, 6823 SE->getString())); 6824 } else if (!ExtnameUndeclaredIdentifiers.empty()) { 6825 llvm::DenseMap<IdentifierInfo*,AsmLabelAttr*>::iterator I = 6826 ExtnameUndeclaredIdentifiers.find(NewFD->getIdentifier()); 6827 if (I != ExtnameUndeclaredIdentifiers.end()) { 6828 NewFD->addAttr(I->second); 6829 ExtnameUndeclaredIdentifiers.erase(I); 6830 } 6831 } 6832 6833 // Copy the parameter declarations from the declarator D to the function 6834 // declaration NewFD, if they are available. First scavenge them into Params. 6835 SmallVector<ParmVarDecl*, 16> Params; 6836 if (D.isFunctionDeclarator()) { 6837 DeclaratorChunk::FunctionTypeInfo &FTI = D.getFunctionTypeInfo(); 6838 6839 // Check for C99 6.7.5.3p10 - foo(void) is a non-varargs 6840 // function that takes no arguments, not a function that takes a 6841 // single void argument. 6842 // We let through "const void" here because Sema::GetTypeForDeclarator 6843 // already checks for that case. 6844 if (FTI.NumArgs == 1 && !FTI.isVariadic && FTI.ArgInfo[0].Ident == 0 && 6845 FTI.ArgInfo[0].Param && 6846 cast<ParmVarDecl>(FTI.ArgInfo[0].Param)->getType()->isVoidType()) { 6847 // Empty arg list, don't push any params. 6848 checkVoidParamDecl(cast<ParmVarDecl>(FTI.ArgInfo[0].Param)); 6849 } else if (FTI.NumArgs > 0 && FTI.ArgInfo[0].Param != 0) { 6850 for (unsigned i = 0, e = FTI.NumArgs; i != e; ++i) { 6851 ParmVarDecl *Param = cast<ParmVarDecl>(FTI.ArgInfo[i].Param); 6852 assert(Param->getDeclContext() != NewFD && "Was set before ?"); 6853 Param->setDeclContext(NewFD); 6854 Params.push_back(Param); 6855 6856 if (Param->isInvalidDecl()) 6857 NewFD->setInvalidDecl(); 6858 } 6859 } 6860 6861 } else if (const FunctionProtoType *FT = R->getAs<FunctionProtoType>()) { 6862 // When we're declaring a function with a typedef, typeof, etc as in the 6863 // following example, we'll need to synthesize (unnamed) 6864 // parameters for use in the declaration. 6865 // 6866 // @code 6867 // typedef void fn(int); 6868 // fn f; 6869 // @endcode 6870 6871 // Synthesize a parameter for each argument type. 6872 for (FunctionProtoType::arg_type_iterator AI = FT->arg_type_begin(), 6873 AE = FT->arg_type_end(); AI != AE; ++AI) { 6874 ParmVarDecl *Param = 6875 BuildParmVarDeclForTypedef(NewFD, D.getIdentifierLoc(), *AI); 6876 Param->setScopeInfo(0, Params.size()); 6877 Params.push_back(Param); 6878 } 6879 } else { 6880 assert(R->isFunctionNoProtoType() && NewFD->getNumParams() == 0 && 6881 "Should not need args for typedef of non-prototype fn"); 6882 } 6883 6884 // Finally, we know we have the right number of parameters, install them. 6885 NewFD->setParams(Params); 6886 6887 // Find all anonymous symbols defined during the declaration of this function 6888 // and add to NewFD. This lets us track decls such 'enum Y' in: 6889 // 6890 // void f(enum Y {AA} x) {} 6891 // 6892 // which would otherwise incorrectly end up in the translation unit scope. 6893 NewFD->setDeclsInPrototypeScope(DeclsInPrototypeScope); 6894 DeclsInPrototypeScope.clear(); 6895 6896 if (D.getDeclSpec().isNoreturnSpecified()) 6897 NewFD->addAttr( 6898 ::new(Context) C11NoReturnAttr(D.getDeclSpec().getNoreturnSpecLoc(), 6899 Context)); 6900 6901 // Functions returning a variably modified type violate C99 6.7.5.2p2 6902 // because all functions have linkage. 6903 if (!NewFD->isInvalidDecl() && 6904 NewFD->getResultType()->isVariablyModifiedType()) { 6905 Diag(NewFD->getLocation(), diag::err_vm_func_decl); 6906 NewFD->setInvalidDecl(); 6907 } 6908 6909 // Handle attributes. 6910 ProcessDeclAttributes(S, NewFD, D); 6911 6912 QualType RetType = NewFD->getResultType(); 6913 const CXXRecordDecl *Ret = RetType->isRecordType() ? 6914 RetType->getAsCXXRecordDecl() : RetType->getPointeeCXXRecordDecl(); 6915 if (!NewFD->isInvalidDecl() && !NewFD->hasAttr<WarnUnusedResultAttr>() && 6916 Ret && Ret->hasAttr<WarnUnusedResultAttr>()) { 6917 const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(NewFD); 6918 if (!(MD && MD->getCorrespondingMethodInClass(Ret, true))) { 6919 NewFD->addAttr(new (Context) WarnUnusedResultAttr(SourceRange(), 6920 Context)); 6921 } 6922 } 6923 6924 if (!getLangOpts().CPlusPlus) { 6925 // Perform semantic checking on the function declaration. 6926 bool isExplicitSpecialization=false; 6927 if (!NewFD->isInvalidDecl() && NewFD->isMain()) 6928 CheckMain(NewFD, D.getDeclSpec()); 6929 6930 if (!NewFD->isInvalidDecl() && NewFD->isMSVCRTEntryPoint()) 6931 CheckMSVCRTEntryPoint(NewFD); 6932 6933 if (!NewFD->isInvalidDecl()) 6934 D.setRedeclaration(CheckFunctionDeclaration(S, NewFD, Previous, 6935 isExplicitSpecialization)); 6936 else if (!Previous.empty()) 6937 // Make graceful recovery from an invalid redeclaration. 6938 D.setRedeclaration(true); 6939 assert((NewFD->isInvalidDecl() || !D.isRedeclaration() || 6940 Previous.getResultKind() != LookupResult::FoundOverloaded) && 6941 "previous declaration set still overloaded"); 6942 } else { 6943 // If the declarator is a template-id, translate the parser's template 6944 // argument list into our AST format. 6945 if (D.getName().getKind() == UnqualifiedId::IK_TemplateId) { 6946 TemplateIdAnnotation *TemplateId = D.getName().TemplateId; 6947 TemplateArgs.setLAngleLoc(TemplateId->LAngleLoc); 6948 TemplateArgs.setRAngleLoc(TemplateId->RAngleLoc); 6949 ASTTemplateArgsPtr TemplateArgsPtr(TemplateId->getTemplateArgs(), 6950 TemplateId->NumArgs); 6951 translateTemplateArguments(TemplateArgsPtr, 6952 TemplateArgs); 6953 6954 HasExplicitTemplateArgs = true; 6955 6956 if (NewFD->isInvalidDecl()) { 6957 HasExplicitTemplateArgs = false; 6958 } else if (FunctionTemplate) { 6959 // Function template with explicit template arguments. 6960 Diag(D.getIdentifierLoc(), diag::err_function_template_partial_spec) 6961 << SourceRange(TemplateId->LAngleLoc, TemplateId->RAngleLoc); 6962 6963 HasExplicitTemplateArgs = false; 6964 } else if (!isFunctionTemplateSpecialization && 6965 !D.getDeclSpec().isFriendSpecified()) { 6966 // We have encountered something that the user meant to be a 6967 // specialization (because it has explicitly-specified template 6968 // arguments) but that was not introduced with a "template<>" (or had 6969 // too few of them). 6970 // FIXME: Differentiate between attempts for explicit instantiations 6971 // (starting with "template") and the rest. 6972 Diag(D.getIdentifierLoc(), diag::err_template_spec_needs_header) 6973 << SourceRange(TemplateId->LAngleLoc, TemplateId->RAngleLoc) 6974 << FixItHint::CreateInsertion( 6975 D.getDeclSpec().getLocStart(), 6976 "template<> "); 6977 isFunctionTemplateSpecialization = true; 6978 } else { 6979 // "friend void foo<>(int);" is an implicit specialization decl. 6980 isFunctionTemplateSpecialization = true; 6981 } 6982 } else if (isFriend && isFunctionTemplateSpecialization) { 6983 // This combination is only possible in a recovery case; the user 6984 // wrote something like: 6985 // template <> friend void foo(int); 6986 // which we're recovering from as if the user had written: 6987 // friend void foo<>(int); 6988 // Go ahead and fake up a template id. 6989 HasExplicitTemplateArgs = true; 6990 TemplateArgs.setLAngleLoc(D.getIdentifierLoc()); 6991 TemplateArgs.setRAngleLoc(D.getIdentifierLoc()); 6992 } 6993 6994 // If it's a friend (and only if it's a friend), it's possible 6995 // that either the specialized function type or the specialized 6996 // template is dependent, and therefore matching will fail. In 6997 // this case, don't check the specialization yet. 6998 bool InstantiationDependent = false; 6999 if (isFunctionTemplateSpecialization && isFriend && 7000 (NewFD->getType()->isDependentType() || DC->isDependentContext() || 7001 TemplateSpecializationType::anyDependentTemplateArguments( 7002 TemplateArgs.getArgumentArray(), TemplateArgs.size(), 7003 InstantiationDependent))) { 7004 assert(HasExplicitTemplateArgs && 7005 "friend function specialization without template args"); 7006 if (CheckDependentFunctionTemplateSpecialization(NewFD, TemplateArgs, 7007 Previous)) 7008 NewFD->setInvalidDecl(); 7009 } else if (isFunctionTemplateSpecialization) { 7010 if (CurContext->isDependentContext() && CurContext->isRecord() 7011 && !isFriend) { 7012 isDependentClassScopeExplicitSpecialization = true; 7013 Diag(NewFD->getLocation(), getLangOpts().MicrosoftExt ? 7014 diag::ext_function_specialization_in_class : 7015 diag::err_function_specialization_in_class) 7016 << NewFD->getDeclName(); 7017 } else if (CheckFunctionTemplateSpecialization(NewFD, 7018 (HasExplicitTemplateArgs ? &TemplateArgs : 0), 7019 Previous)) 7020 NewFD->setInvalidDecl(); 7021 7022 // C++ [dcl.stc]p1: 7023 // A storage-class-specifier shall not be specified in an explicit 7024 // specialization (14.7.3) 7025 FunctionTemplateSpecializationInfo *Info = 7026 NewFD->getTemplateSpecializationInfo(); 7027 if (Info && SC != SC_None) { 7028 if (SC != Info->getTemplate()->getTemplatedDecl()->getStorageClass()) 7029 Diag(NewFD->getLocation(), 7030 diag::err_explicit_specialization_inconsistent_storage_class) 7031 << SC 7032 << FixItHint::CreateRemoval( 7033 D.getDeclSpec().getStorageClassSpecLoc()); 7034 7035 else 7036 Diag(NewFD->getLocation(), 7037 diag::ext_explicit_specialization_storage_class) 7038 << FixItHint::CreateRemoval( 7039 D.getDeclSpec().getStorageClassSpecLoc()); 7040 } 7041 7042 } else if (isExplicitSpecialization && isa<CXXMethodDecl>(NewFD)) { 7043 if (CheckMemberSpecialization(NewFD, Previous)) 7044 NewFD->setInvalidDecl(); 7045 } 7046 7047 // Perform semantic checking on the function declaration. 7048 if (!isDependentClassScopeExplicitSpecialization) { 7049 if (!NewFD->isInvalidDecl() && NewFD->isMain()) 7050 CheckMain(NewFD, D.getDeclSpec()); 7051 7052 if (!NewFD->isInvalidDecl() && NewFD->isMSVCRTEntryPoint()) 7053 CheckMSVCRTEntryPoint(NewFD); 7054 7055 if (NewFD->isInvalidDecl()) { 7056 // If this is a class member, mark the class invalid immediately. 7057 // This avoids some consistency errors later. 7058 if (CXXMethodDecl* methodDecl = dyn_cast<CXXMethodDecl>(NewFD)) 7059 methodDecl->getParent()->setInvalidDecl(); 7060 } else 7061 D.setRedeclaration(CheckFunctionDeclaration(S, NewFD, Previous, 7062 isExplicitSpecialization)); 7063 } 7064 7065 assert((NewFD->isInvalidDecl() || !D.isRedeclaration() || 7066 Previous.getResultKind() != LookupResult::FoundOverloaded) && 7067 "previous declaration set still overloaded"); 7068 7069 NamedDecl *PrincipalDecl = (FunctionTemplate 7070 ? cast<NamedDecl>(FunctionTemplate) 7071 : NewFD); 7072 7073 if (isFriend && D.isRedeclaration()) { 7074 AccessSpecifier Access = AS_public; 7075 if (!NewFD->isInvalidDecl()) 7076 Access = NewFD->getPreviousDecl()->getAccess(); 7077 7078 NewFD->setAccess(Access); 7079 if (FunctionTemplate) FunctionTemplate->setAccess(Access); 7080 } 7081 7082 if (NewFD->isOverloadedOperator() && !DC->isRecord() && 7083 PrincipalDecl->isInIdentifierNamespace(Decl::IDNS_Ordinary)) 7084 PrincipalDecl->setNonMemberOperator(); 7085 7086 // If we have a function template, check the template parameter 7087 // list. This will check and merge default template arguments. 7088 if (FunctionTemplate) { 7089 FunctionTemplateDecl *PrevTemplate = 7090 FunctionTemplate->getPreviousDecl(); 7091 CheckTemplateParameterList(FunctionTemplate->getTemplateParameters(), 7092 PrevTemplate ? PrevTemplate->getTemplateParameters() : 0, 7093 D.getDeclSpec().isFriendSpecified() 7094 ? (D.isFunctionDefinition() 7095 ? TPC_FriendFunctionTemplateDefinition 7096 : TPC_FriendFunctionTemplate) 7097 : (D.getCXXScopeSpec().isSet() && 7098 DC && DC->isRecord() && 7099 DC->isDependentContext()) 7100 ? TPC_ClassTemplateMember 7101 : TPC_FunctionTemplate); 7102 } 7103 7104 if (NewFD->isInvalidDecl()) { 7105 // Ignore all the rest of this. 7106 } else if (!D.isRedeclaration()) { 7107 struct ActOnFDArgs ExtraArgs = { S, D, TemplateParamLists, 7108 AddToScope }; 7109 // Fake up an access specifier if it's supposed to be a class member. 7110 if (isa<CXXRecordDecl>(NewFD->getDeclContext())) 7111 NewFD->setAccess(AS_public); 7112 7113 // Qualified decls generally require a previous declaration. 7114 if (D.getCXXScopeSpec().isSet()) { 7115 // ...with the major exception of templated-scope or 7116 // dependent-scope friend declarations. 7117 7118 // TODO: we currently also suppress this check in dependent 7119 // contexts because (1) the parameter depth will be off when 7120 // matching friend templates and (2) we might actually be 7121 // selecting a friend based on a dependent factor. But there 7122 // are situations where these conditions don't apply and we 7123 // can actually do this check immediately. 7124 if (isFriend && 7125 (TemplateParamLists.size() || 7126 D.getCXXScopeSpec().getScopeRep()->isDependent() || 7127 CurContext->isDependentContext())) { 7128 // ignore these 7129 } else { 7130 // The user tried to provide an out-of-line definition for a 7131 // function that is a member of a class or namespace, but there 7132 // was no such member function declared (C++ [class.mfct]p2, 7133 // C++ [namespace.memdef]p2). For example: 7134 // 7135 // class X { 7136 // void f() const; 7137 // }; 7138 // 7139 // void X::f() { } // ill-formed 7140 // 7141 // Complain about this problem, and attempt to suggest close 7142 // matches (e.g., those that differ only in cv-qualifiers and 7143 // whether the parameter types are references). 7144 7145 if (NamedDecl *Result = DiagnoseInvalidRedeclaration( 7146 *this, Previous, NewFD, ExtraArgs, false, 0)) { 7147 AddToScope = ExtraArgs.AddToScope; 7148 return Result; 7149 } 7150 } 7151 7152 // Unqualified local friend declarations are required to resolve 7153 // to something. 7154 } else if (isFriend && cast<CXXRecordDecl>(CurContext)->isLocalClass()) { 7155 if (NamedDecl *Result = DiagnoseInvalidRedeclaration( 7156 *this, Previous, NewFD, ExtraArgs, true, S)) { 7157 AddToScope = ExtraArgs.AddToScope; 7158 return Result; 7159 } 7160 } 7161 7162 } else if (!D.isFunctionDefinition() && D.getCXXScopeSpec().isSet() && 7163 !isFriend && !isFunctionTemplateSpecialization && 7164 !isExplicitSpecialization) { 7165 // An out-of-line member function declaration must also be a 7166 // definition (C++ [dcl.meaning]p1). 7167 // Note that this is not the case for explicit specializations of 7168 // function templates or member functions of class templates, per 7169 // C++ [temp.expl.spec]p2. We also allow these declarations as an 7170 // extension for compatibility with old SWIG code which likes to 7171 // generate them. 7172 Diag(NewFD->getLocation(), diag::ext_out_of_line_declaration) 7173 << D.getCXXScopeSpec().getRange(); 7174 } 7175 } 7176 7177 ProcessPragmaWeak(S, NewFD); 7178 checkAttributesAfterMerging(*this, *NewFD); 7179 7180 AddKnownFunctionAttributes(NewFD); 7181 7182 if (NewFD->hasAttr<OverloadableAttr>() && 7183 !NewFD->getType()->getAs<FunctionProtoType>()) { 7184 Diag(NewFD->getLocation(), 7185 diag::err_attribute_overloadable_no_prototype) 7186 << NewFD; 7187 7188 // Turn this into a variadic function with no parameters. 7189 const FunctionType *FT = NewFD->getType()->getAs<FunctionType>(); 7190 FunctionProtoType::ExtProtoInfo EPI( 7191 Context.getDefaultCallingConvention(true, false)); 7192 EPI.Variadic = true; 7193 EPI.ExtInfo = FT->getExtInfo(); 7194 7195 QualType R = Context.getFunctionType(FT->getResultType(), None, EPI); 7196 NewFD->setType(R); 7197 } 7198 7199 // If there's a #pragma GCC visibility in scope, and this isn't a class 7200 // member, set the visibility of this function. 7201 if (!DC->isRecord() && NewFD->isExternallyVisible()) 7202 AddPushedVisibilityAttribute(NewFD); 7203 7204 // If there's a #pragma clang arc_cf_code_audited in scope, consider 7205 // marking the function. 7206 AddCFAuditedAttribute(NewFD); 7207 7208 // If this is the first declaration of an extern C variable, update 7209 // the map of such variables. 7210 if (!NewFD->getPreviousDecl() && !NewFD->isInvalidDecl() && 7211 isIncompleteDeclExternC(*this, NewFD)) 7212 RegisterLocallyScopedExternCDecl(NewFD, S); 7213 7214 // Set this FunctionDecl's range up to the right paren. 7215 NewFD->setRangeEnd(D.getSourceRange().getEnd()); 7216 7217 if (getLangOpts().CPlusPlus) { 7218 if (FunctionTemplate) { 7219 if (NewFD->isInvalidDecl()) 7220 FunctionTemplate->setInvalidDecl(); 7221 return FunctionTemplate; 7222 } 7223 } 7224 7225 if (NewFD->hasAttr<OpenCLKernelAttr>()) { 7226 // OpenCL v1.2 s6.8 static is invalid for kernel functions. 7227 if ((getLangOpts().OpenCLVersion >= 120) 7228 && (SC == SC_Static)) { 7229 Diag(D.getIdentifierLoc(), diag::err_static_kernel); 7230 D.setInvalidType(); 7231 } 7232 7233 // OpenCL v1.2, s6.9 -- Kernels can only have return type void. 7234 if (!NewFD->getResultType()->isVoidType()) { 7235 Diag(D.getIdentifierLoc(), 7236 diag::err_expected_kernel_void_return_type); 7237 D.setInvalidType(); 7238 } 7239 7240 llvm::SmallPtrSet<const Type *, 16> ValidTypes; 7241 for (FunctionDecl::param_iterator PI = NewFD->param_begin(), 7242 PE = NewFD->param_end(); PI != PE; ++PI) { 7243 ParmVarDecl *Param = *PI; 7244 checkIsValidOpenCLKernelParameter(*this, D, Param, ValidTypes); 7245 } 7246 } 7247 7248 MarkUnusedFileScopedDecl(NewFD); 7249 7250 if (getLangOpts().CUDA) 7251 if (IdentifierInfo *II = NewFD->getIdentifier()) 7252 if (!NewFD->isInvalidDecl() && 7253 NewFD->getDeclContext()->getRedeclContext()->isTranslationUnit()) { 7254 if (II->isStr("cudaConfigureCall")) { 7255 if (!R->getAs<FunctionType>()->getResultType()->isScalarType()) 7256 Diag(NewFD->getLocation(), diag::err_config_scalar_return); 7257 7258 Context.setcudaConfigureCallDecl(NewFD); 7259 } 7260 } 7261 7262 // Here we have an function template explicit specialization at class scope. 7263 // The actually specialization will be postponed to template instatiation 7264 // time via the ClassScopeFunctionSpecializationDecl node. 7265 if (isDependentClassScopeExplicitSpecialization) { 7266 ClassScopeFunctionSpecializationDecl *NewSpec = 7267 ClassScopeFunctionSpecializationDecl::Create( 7268 Context, CurContext, SourceLocation(), 7269 cast<CXXMethodDecl>(NewFD), 7270 HasExplicitTemplateArgs, TemplateArgs); 7271 CurContext->addDecl(NewSpec); 7272 AddToScope = false; 7273 } 7274 7275 return NewFD; 7276} 7277 7278/// \brief Perform semantic checking of a new function declaration. 7279/// 7280/// Performs semantic analysis of the new function declaration 7281/// NewFD. This routine performs all semantic checking that does not 7282/// require the actual declarator involved in the declaration, and is 7283/// used both for the declaration of functions as they are parsed 7284/// (called via ActOnDeclarator) and for the declaration of functions 7285/// that have been instantiated via C++ template instantiation (called 7286/// via InstantiateDecl). 7287/// 7288/// \param IsExplicitSpecialization whether this new function declaration is 7289/// an explicit specialization of the previous declaration. 7290/// 7291/// This sets NewFD->isInvalidDecl() to true if there was an error. 7292/// 7293/// \returns true if the function declaration is a redeclaration. 7294bool Sema::CheckFunctionDeclaration(Scope *S, FunctionDecl *NewFD, 7295 LookupResult &Previous, 7296 bool IsExplicitSpecialization) { 7297 assert(!NewFD->getResultType()->isVariablyModifiedType() 7298 && "Variably modified return types are not handled here"); 7299 7300 // Determine whether the type of this function should be merged with 7301 // a previous visible declaration. This never happens for functions in C++, 7302 // and always happens in C if the previous declaration was visible. 7303 bool MergeTypeWithPrevious = !getLangOpts().CPlusPlus && 7304 !Previous.isShadowed(); 7305 7306 // Filter out any non-conflicting previous declarations. 7307 filterNonConflictingPreviousDecls(Context, NewFD, Previous); 7308 7309 bool Redeclaration = false; 7310 NamedDecl *OldDecl = 0; 7311 7312 // Merge or overload the declaration with an existing declaration of 7313 // the same name, if appropriate. 7314 if (!Previous.empty()) { 7315 // Determine whether NewFD is an overload of PrevDecl or 7316 // a declaration that requires merging. If it's an overload, 7317 // there's no more work to do here; we'll just add the new 7318 // function to the scope. 7319 if (!AllowOverloadingOfFunction(Previous, Context)) { 7320 NamedDecl *Candidate = Previous.getFoundDecl(); 7321 if (shouldLinkPossiblyHiddenDecl(Candidate, NewFD)) { 7322 Redeclaration = true; 7323 OldDecl = Candidate; 7324 } 7325 } else { 7326 switch (CheckOverload(S, NewFD, Previous, OldDecl, 7327 /*NewIsUsingDecl*/ false)) { 7328 case Ovl_Match: 7329 Redeclaration = true; 7330 break; 7331 7332 case Ovl_NonFunction: 7333 Redeclaration = true; 7334 break; 7335 7336 case Ovl_Overload: 7337 Redeclaration = false; 7338 break; 7339 } 7340 7341 if (!getLangOpts().CPlusPlus && !NewFD->hasAttr<OverloadableAttr>()) { 7342 // If a function name is overloadable in C, then every function 7343 // with that name must be marked "overloadable". 7344 Diag(NewFD->getLocation(), diag::err_attribute_overloadable_missing) 7345 << Redeclaration << NewFD; 7346 NamedDecl *OverloadedDecl = 0; 7347 if (Redeclaration) 7348 OverloadedDecl = OldDecl; 7349 else if (!Previous.empty()) 7350 OverloadedDecl = Previous.getRepresentativeDecl(); 7351 if (OverloadedDecl) 7352 Diag(OverloadedDecl->getLocation(), 7353 diag::note_attribute_overloadable_prev_overload); 7354 NewFD->addAttr(::new (Context) OverloadableAttr(SourceLocation(), 7355 Context)); 7356 } 7357 } 7358 } 7359 7360 // Check for a previous extern "C" declaration with this name. 7361 if (!Redeclaration && 7362 checkForConflictWithNonVisibleExternC(*this, NewFD, Previous)) { 7363 filterNonConflictingPreviousDecls(Context, NewFD, Previous); 7364 if (!Previous.empty()) { 7365 // This is an extern "C" declaration with the same name as a previous 7366 // declaration, and thus redeclares that entity... 7367 Redeclaration = true; 7368 OldDecl = Previous.getFoundDecl(); 7369 MergeTypeWithPrevious = false; 7370 7371 // ... except in the presence of __attribute__((overloadable)). 7372 if (OldDecl->hasAttr<OverloadableAttr>()) { 7373 if (!getLangOpts().CPlusPlus && !NewFD->hasAttr<OverloadableAttr>()) { 7374 Diag(NewFD->getLocation(), diag::err_attribute_overloadable_missing) 7375 << Redeclaration << NewFD; 7376 Diag(Previous.getFoundDecl()->getLocation(), 7377 diag::note_attribute_overloadable_prev_overload); 7378 NewFD->addAttr(::new (Context) OverloadableAttr(SourceLocation(), 7379 Context)); 7380 } 7381 if (IsOverload(NewFD, cast<FunctionDecl>(OldDecl), false)) { 7382 Redeclaration = false; 7383 OldDecl = 0; 7384 } 7385 } 7386 } 7387 } 7388 7389 // C++11 [dcl.constexpr]p8: 7390 // A constexpr specifier for a non-static member function that is not 7391 // a constructor declares that member function to be const. 7392 // 7393 // This needs to be delayed until we know whether this is an out-of-line 7394 // definition of a static member function. 7395 // 7396 // This rule is not present in C++1y, so we produce a backwards 7397 // compatibility warning whenever it happens in C++11. 7398 CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(NewFD); 7399 if (!getLangOpts().CPlusPlus1y && MD && MD->isConstexpr() && 7400 !MD->isStatic() && !isa<CXXConstructorDecl>(MD) && 7401 (MD->getTypeQualifiers() & Qualifiers::Const) == 0) { 7402 CXXMethodDecl *OldMD = dyn_cast_or_null<CXXMethodDecl>(OldDecl); 7403 if (FunctionTemplateDecl *OldTD = 7404 dyn_cast_or_null<FunctionTemplateDecl>(OldDecl)) 7405 OldMD = dyn_cast<CXXMethodDecl>(OldTD->getTemplatedDecl()); 7406 if (!OldMD || !OldMD->isStatic()) { 7407 const FunctionProtoType *FPT = 7408 MD->getType()->castAs<FunctionProtoType>(); 7409 FunctionProtoType::ExtProtoInfo EPI = FPT->getExtProtoInfo(); 7410 EPI.TypeQuals |= Qualifiers::Const; 7411 MD->setType(Context.getFunctionType(FPT->getResultType(), 7412 FPT->getArgTypes(), EPI)); 7413 7414 // Warn that we did this, if we're not performing template instantiation. 7415 // In that case, we'll have warned already when the template was defined. 7416 if (ActiveTemplateInstantiations.empty()) { 7417 SourceLocation AddConstLoc; 7418 if (FunctionTypeLoc FTL = MD->getTypeSourceInfo()->getTypeLoc() 7419 .IgnoreParens().getAs<FunctionTypeLoc>()) 7420 AddConstLoc = PP.getLocForEndOfToken(FTL.getRParenLoc()); 7421 7422 Diag(MD->getLocation(), diag::warn_cxx1y_compat_constexpr_not_const) 7423 << FixItHint::CreateInsertion(AddConstLoc, " const"); 7424 } 7425 } 7426 } 7427 7428 if (Redeclaration) { 7429 // NewFD and OldDecl represent declarations that need to be 7430 // merged. 7431 if (MergeFunctionDecl(NewFD, OldDecl, S, MergeTypeWithPrevious)) { 7432 NewFD->setInvalidDecl(); 7433 return Redeclaration; 7434 } 7435 7436 Previous.clear(); 7437 Previous.addDecl(OldDecl); 7438 7439 if (FunctionTemplateDecl *OldTemplateDecl 7440 = dyn_cast<FunctionTemplateDecl>(OldDecl)) { 7441 NewFD->setPreviousDeclaration(OldTemplateDecl->getTemplatedDecl()); 7442 FunctionTemplateDecl *NewTemplateDecl 7443 = NewFD->getDescribedFunctionTemplate(); 7444 assert(NewTemplateDecl && "Template/non-template mismatch"); 7445 if (CXXMethodDecl *Method 7446 = dyn_cast<CXXMethodDecl>(NewTemplateDecl->getTemplatedDecl())) { 7447 Method->setAccess(OldTemplateDecl->getAccess()); 7448 NewTemplateDecl->setAccess(OldTemplateDecl->getAccess()); 7449 } 7450 7451 // If this is an explicit specialization of a member that is a function 7452 // template, mark it as a member specialization. 7453 if (IsExplicitSpecialization && 7454 NewTemplateDecl->getInstantiatedFromMemberTemplate()) { 7455 NewTemplateDecl->setMemberSpecialization(); 7456 assert(OldTemplateDecl->isMemberSpecialization()); 7457 } 7458 7459 } else { 7460 // This needs to happen first so that 'inline' propagates. 7461 NewFD->setPreviousDeclaration(cast<FunctionDecl>(OldDecl)); 7462 7463 if (isa<CXXMethodDecl>(NewFD)) { 7464 // A valid redeclaration of a C++ method must be out-of-line, 7465 // but (unfortunately) it's not necessarily a definition 7466 // because of templates, which means that the previous 7467 // declaration is not necessarily from the class definition. 7468 7469 // For just setting the access, that doesn't matter. 7470 CXXMethodDecl *oldMethod = cast<CXXMethodDecl>(OldDecl); 7471 NewFD->setAccess(oldMethod->getAccess()); 7472 7473 // Update the key-function state if necessary for this ABI. 7474 if (NewFD->isInlined() && 7475 !Context.getTargetInfo().getCXXABI().canKeyFunctionBeInline()) { 7476 // setNonKeyFunction needs to work with the original 7477 // declaration from the class definition, and isVirtual() is 7478 // just faster in that case, so map back to that now. 7479 oldMethod = cast<CXXMethodDecl>(oldMethod->getFirstDeclaration()); 7480 if (oldMethod->isVirtual()) { 7481 Context.setNonKeyFunction(oldMethod); 7482 } 7483 } 7484 } 7485 } 7486 } 7487 7488 // Semantic checking for this function declaration (in isolation). 7489 if (getLangOpts().CPlusPlus) { 7490 // C++-specific checks. 7491 if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(NewFD)) { 7492 CheckConstructor(Constructor); 7493 } else if (CXXDestructorDecl *Destructor = 7494 dyn_cast<CXXDestructorDecl>(NewFD)) { 7495 CXXRecordDecl *Record = Destructor->getParent(); 7496 QualType ClassType = Context.getTypeDeclType(Record); 7497 7498 // FIXME: Shouldn't we be able to perform this check even when the class 7499 // type is dependent? Both gcc and edg can handle that. 7500 if (!ClassType->isDependentType()) { 7501 DeclarationName Name 7502 = Context.DeclarationNames.getCXXDestructorName( 7503 Context.getCanonicalType(ClassType)); 7504 if (NewFD->getDeclName() != Name) { 7505 Diag(NewFD->getLocation(), diag::err_destructor_name); 7506 NewFD->setInvalidDecl(); 7507 return Redeclaration; 7508 } 7509 } 7510 } else if (CXXConversionDecl *Conversion 7511 = dyn_cast<CXXConversionDecl>(NewFD)) { 7512 ActOnConversionDeclarator(Conversion); 7513 } 7514 7515 // Find any virtual functions that this function overrides. 7516 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(NewFD)) { 7517 if (!Method->isFunctionTemplateSpecialization() && 7518 !Method->getDescribedFunctionTemplate() && 7519 Method->isCanonicalDecl()) { 7520 if (AddOverriddenMethods(Method->getParent(), Method)) { 7521 // If the function was marked as "static", we have a problem. 7522 if (NewFD->getStorageClass() == SC_Static) { 7523 ReportOverrides(*this, diag::err_static_overrides_virtual, Method); 7524 } 7525 } 7526 } 7527 7528 if (Method->isStatic()) 7529 checkThisInStaticMemberFunctionType(Method); 7530 } 7531 7532 // Extra checking for C++ overloaded operators (C++ [over.oper]). 7533 if (NewFD->isOverloadedOperator() && 7534 CheckOverloadedOperatorDeclaration(NewFD)) { 7535 NewFD->setInvalidDecl(); 7536 return Redeclaration; 7537 } 7538 7539 // Extra checking for C++0x literal operators (C++0x [over.literal]). 7540 if (NewFD->getLiteralIdentifier() && 7541 CheckLiteralOperatorDeclaration(NewFD)) { 7542 NewFD->setInvalidDecl(); 7543 return Redeclaration; 7544 } 7545 7546 // In C++, check default arguments now that we have merged decls. Unless 7547 // the lexical context is the class, because in this case this is done 7548 // during delayed parsing anyway. 7549 if (!CurContext->isRecord()) 7550 CheckCXXDefaultArguments(NewFD); 7551 7552 // If this function declares a builtin function, check the type of this 7553 // declaration against the expected type for the builtin. 7554 if (unsigned BuiltinID = NewFD->getBuiltinID()) { 7555 ASTContext::GetBuiltinTypeError Error; 7556 LookupPredefedObjCSuperType(*this, S, NewFD->getIdentifier()); 7557 QualType T = Context.GetBuiltinType(BuiltinID, Error); 7558 if (!T.isNull() && !Context.hasSameType(T, NewFD->getType())) { 7559 // The type of this function differs from the type of the builtin, 7560 // so forget about the builtin entirely. 7561 Context.BuiltinInfo.ForgetBuiltin(BuiltinID, Context.Idents); 7562 } 7563 } 7564 7565 // If this function is declared as being extern "C", then check to see if 7566 // the function returns a UDT (class, struct, or union type) that is not C 7567 // compatible, and if it does, warn the user. 7568 // But, issue any diagnostic on the first declaration only. 7569 if (NewFD->isExternC() && Previous.empty()) { 7570 QualType R = NewFD->getResultType(); 7571 if (R->isIncompleteType() && !R->isVoidType()) 7572 Diag(NewFD->getLocation(), diag::warn_return_value_udt_incomplete) 7573 << NewFD << R; 7574 else if (!R.isPODType(Context) && !R->isVoidType() && 7575 !R->isObjCObjectPointerType()) 7576 Diag(NewFD->getLocation(), diag::warn_return_value_udt) << NewFD << R; 7577 } 7578 } 7579 return Redeclaration; 7580} 7581 7582static SourceRange getResultSourceRange(const FunctionDecl *FD) { 7583 const TypeSourceInfo *TSI = FD->getTypeSourceInfo(); 7584 if (!TSI) 7585 return SourceRange(); 7586 7587 TypeLoc TL = TSI->getTypeLoc(); 7588 FunctionTypeLoc FunctionTL = TL.getAs<FunctionTypeLoc>(); 7589 if (!FunctionTL) 7590 return SourceRange(); 7591 7592 TypeLoc ResultTL = FunctionTL.getResultLoc(); 7593 if (ResultTL.getUnqualifiedLoc().getAs<BuiltinTypeLoc>()) 7594 return ResultTL.getSourceRange(); 7595 7596 return SourceRange(); 7597} 7598 7599void Sema::CheckMain(FunctionDecl* FD, const DeclSpec& DS) { 7600 // C++11 [basic.start.main]p3: A program that declares main to be inline, 7601 // static or constexpr is ill-formed. 7602 // C11 6.7.4p4: In a hosted environment, no function specifier(s) shall 7603 // appear in a declaration of main. 7604 // static main is not an error under C99, but we should warn about it. 7605 // We accept _Noreturn main as an extension. 7606 if (FD->getStorageClass() == SC_Static) 7607 Diag(DS.getStorageClassSpecLoc(), getLangOpts().CPlusPlus 7608 ? diag::err_static_main : diag::warn_static_main) 7609 << FixItHint::CreateRemoval(DS.getStorageClassSpecLoc()); 7610 if (FD->isInlineSpecified()) 7611 Diag(DS.getInlineSpecLoc(), diag::err_inline_main) 7612 << FixItHint::CreateRemoval(DS.getInlineSpecLoc()); 7613 if (DS.isNoreturnSpecified()) { 7614 SourceLocation NoreturnLoc = DS.getNoreturnSpecLoc(); 7615 SourceRange NoreturnRange(NoreturnLoc, 7616 PP.getLocForEndOfToken(NoreturnLoc)); 7617 Diag(NoreturnLoc, diag::ext_noreturn_main); 7618 Diag(NoreturnLoc, diag::note_main_remove_noreturn) 7619 << FixItHint::CreateRemoval(NoreturnRange); 7620 } 7621 if (FD->isConstexpr()) { 7622 Diag(DS.getConstexprSpecLoc(), diag::err_constexpr_main) 7623 << FixItHint::CreateRemoval(DS.getConstexprSpecLoc()); 7624 FD->setConstexpr(false); 7625 } 7626 7627 QualType T = FD->getType(); 7628 assert(T->isFunctionType() && "function decl is not of function type"); 7629 const FunctionType* FT = T->castAs<FunctionType>(); 7630 7631 // All the standards say that main() should should return 'int'. 7632 if (Context.hasSameUnqualifiedType(FT->getResultType(), Context.IntTy)) { 7633 // In C and C++, main magically returns 0 if you fall off the end; 7634 // set the flag which tells us that. 7635 // This is C++ [basic.start.main]p5 and C99 5.1.2.2.3. 7636 FD->setHasImplicitReturnZero(true); 7637 7638 // In C with GNU extensions we allow main() to have non-integer return 7639 // type, but we should warn about the extension, and we disable the 7640 // implicit-return-zero rule. 7641 } else if (getLangOpts().GNUMode && !getLangOpts().CPlusPlus) { 7642 Diag(FD->getTypeSpecStartLoc(), diag::ext_main_returns_nonint); 7643 7644 SourceRange ResultRange = getResultSourceRange(FD); 7645 if (ResultRange.isValid()) 7646 Diag(ResultRange.getBegin(), diag::note_main_change_return_type) 7647 << FixItHint::CreateReplacement(ResultRange, "int"); 7648 7649 // Otherwise, this is just a flat-out error. 7650 } else { 7651 SourceRange ResultRange = getResultSourceRange(FD); 7652 if (ResultRange.isValid()) 7653 Diag(FD->getTypeSpecStartLoc(), diag::err_main_returns_nonint) 7654 << FixItHint::CreateReplacement(ResultRange, "int"); 7655 else 7656 Diag(FD->getTypeSpecStartLoc(), diag::err_main_returns_nonint); 7657 7658 FD->setInvalidDecl(true); 7659 } 7660 7661 // Treat protoless main() as nullary. 7662 if (isa<FunctionNoProtoType>(FT)) return; 7663 7664 const FunctionProtoType* FTP = cast<const FunctionProtoType>(FT); 7665 unsigned nparams = FTP->getNumArgs(); 7666 assert(FD->getNumParams() == nparams); 7667 7668 bool HasExtraParameters = (nparams > 3); 7669 7670 // Darwin passes an undocumented fourth argument of type char**. If 7671 // other platforms start sprouting these, the logic below will start 7672 // getting shifty. 7673 if (nparams == 4 && Context.getTargetInfo().getTriple().isOSDarwin()) 7674 HasExtraParameters = false; 7675 7676 if (HasExtraParameters) { 7677 Diag(FD->getLocation(), diag::err_main_surplus_args) << nparams; 7678 FD->setInvalidDecl(true); 7679 nparams = 3; 7680 } 7681 7682 // FIXME: a lot of the following diagnostics would be improved 7683 // if we had some location information about types. 7684 7685 QualType CharPP = 7686 Context.getPointerType(Context.getPointerType(Context.CharTy)); 7687 QualType Expected[] = { Context.IntTy, CharPP, CharPP, CharPP }; 7688 7689 for (unsigned i = 0; i < nparams; ++i) { 7690 QualType AT = FTP->getArgType(i); 7691 7692 bool mismatch = true; 7693 7694 if (Context.hasSameUnqualifiedType(AT, Expected[i])) 7695 mismatch = false; 7696 else if (Expected[i] == CharPP) { 7697 // As an extension, the following forms are okay: 7698 // char const ** 7699 // char const * const * 7700 // char * const * 7701 7702 QualifierCollector qs; 7703 const PointerType* PT; 7704 if ((PT = qs.strip(AT)->getAs<PointerType>()) && 7705 (PT = qs.strip(PT->getPointeeType())->getAs<PointerType>()) && 7706 Context.hasSameType(QualType(qs.strip(PT->getPointeeType()), 0), 7707 Context.CharTy)) { 7708 qs.removeConst(); 7709 mismatch = !qs.empty(); 7710 } 7711 } 7712 7713 if (mismatch) { 7714 Diag(FD->getLocation(), diag::err_main_arg_wrong) << i << Expected[i]; 7715 // TODO: suggest replacing given type with expected type 7716 FD->setInvalidDecl(true); 7717 } 7718 } 7719 7720 if (nparams == 1 && !FD->isInvalidDecl()) { 7721 Diag(FD->getLocation(), diag::warn_main_one_arg); 7722 } 7723 7724 if (!FD->isInvalidDecl() && FD->getDescribedFunctionTemplate()) { 7725 Diag(FD->getLocation(), diag::err_mainlike_template_decl) << FD->getName(); 7726 FD->setInvalidDecl(); 7727 } 7728} 7729 7730void Sema::CheckMSVCRTEntryPoint(FunctionDecl *FD) { 7731 QualType T = FD->getType(); 7732 assert(T->isFunctionType() && "function decl is not of function type"); 7733 const FunctionType *FT = T->castAs<FunctionType>(); 7734 7735 // Set an implicit return of 'zero' if the function can return some integral, 7736 // enumeration, pointer or nullptr type. 7737 if (FT->getResultType()->isIntegralOrEnumerationType() || 7738 FT->getResultType()->isAnyPointerType() || 7739 FT->getResultType()->isNullPtrType()) 7740 // DllMain is exempt because a return value of zero means it failed. 7741 if (FD->getName() != "DllMain") 7742 FD->setHasImplicitReturnZero(true); 7743 7744 if (!FD->isInvalidDecl() && FD->getDescribedFunctionTemplate()) { 7745 Diag(FD->getLocation(), diag::err_mainlike_template_decl) << FD->getName(); 7746 FD->setInvalidDecl(); 7747 } 7748} 7749 7750bool Sema::CheckForConstantInitializer(Expr *Init, QualType DclT) { 7751 // FIXME: Need strict checking. In C89, we need to check for 7752 // any assignment, increment, decrement, function-calls, or 7753 // commas outside of a sizeof. In C99, it's the same list, 7754 // except that the aforementioned are allowed in unevaluated 7755 // expressions. Everything else falls under the 7756 // "may accept other forms of constant expressions" exception. 7757 // (We never end up here for C++, so the constant expression 7758 // rules there don't matter.) 7759 if (Init->isConstantInitializer(Context, false)) 7760 return false; 7761 Diag(Init->getExprLoc(), diag::err_init_element_not_constant) 7762 << Init->getSourceRange(); 7763 return true; 7764} 7765 7766namespace { 7767 // Visits an initialization expression to see if OrigDecl is evaluated in 7768 // its own initialization and throws a warning if it does. 7769 class SelfReferenceChecker 7770 : public EvaluatedExprVisitor<SelfReferenceChecker> { 7771 Sema &S; 7772 Decl *OrigDecl; 7773 bool isRecordType; 7774 bool isPODType; 7775 bool isReferenceType; 7776 7777 public: 7778 typedef EvaluatedExprVisitor<SelfReferenceChecker> Inherited; 7779 7780 SelfReferenceChecker(Sema &S, Decl *OrigDecl) : Inherited(S.Context), 7781 S(S), OrigDecl(OrigDecl) { 7782 isPODType = false; 7783 isRecordType = false; 7784 isReferenceType = false; 7785 if (ValueDecl *VD = dyn_cast<ValueDecl>(OrigDecl)) { 7786 isPODType = VD->getType().isPODType(S.Context); 7787 isRecordType = VD->getType()->isRecordType(); 7788 isReferenceType = VD->getType()->isReferenceType(); 7789 } 7790 } 7791 7792 // For most expressions, the cast is directly above the DeclRefExpr. 7793 // For conditional operators, the cast can be outside the conditional 7794 // operator if both expressions are DeclRefExpr's. 7795 void HandleValue(Expr *E) { 7796 if (isReferenceType) 7797 return; 7798 E = E->IgnoreParenImpCasts(); 7799 if (DeclRefExpr* DRE = dyn_cast<DeclRefExpr>(E)) { 7800 HandleDeclRefExpr(DRE); 7801 return; 7802 } 7803 7804 if (ConditionalOperator *CO = dyn_cast<ConditionalOperator>(E)) { 7805 HandleValue(CO->getTrueExpr()); 7806 HandleValue(CO->getFalseExpr()); 7807 return; 7808 } 7809 7810 if (isa<MemberExpr>(E)) { 7811 Expr *Base = E->IgnoreParenImpCasts(); 7812 while (MemberExpr *ME = dyn_cast<MemberExpr>(Base)) { 7813 // Check for static member variables and don't warn on them. 7814 if (!isa<FieldDecl>(ME->getMemberDecl())) 7815 return; 7816 Base = ME->getBase()->IgnoreParenImpCasts(); 7817 } 7818 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Base)) 7819 HandleDeclRefExpr(DRE); 7820 return; 7821 } 7822 } 7823 7824 // Reference types are handled here since all uses of references are 7825 // bad, not just r-value uses. 7826 void VisitDeclRefExpr(DeclRefExpr *E) { 7827 if (isReferenceType) 7828 HandleDeclRefExpr(E); 7829 } 7830 7831 void VisitImplicitCastExpr(ImplicitCastExpr *E) { 7832 if (E->getCastKind() == CK_LValueToRValue || 7833 (isRecordType && E->getCastKind() == CK_NoOp)) 7834 HandleValue(E->getSubExpr()); 7835 7836 Inherited::VisitImplicitCastExpr(E); 7837 } 7838 7839 void VisitMemberExpr(MemberExpr *E) { 7840 // Don't warn on arrays since they can be treated as pointers. 7841 if (E->getType()->canDecayToPointerType()) return; 7842 7843 // Warn when a non-static method call is followed by non-static member 7844 // field accesses, which is followed by a DeclRefExpr. 7845 CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(E->getMemberDecl()); 7846 bool Warn = (MD && !MD->isStatic()); 7847 Expr *Base = E->getBase()->IgnoreParenImpCasts(); 7848 while (MemberExpr *ME = dyn_cast<MemberExpr>(Base)) { 7849 if (!isa<FieldDecl>(ME->getMemberDecl())) 7850 Warn = false; 7851 Base = ME->getBase()->IgnoreParenImpCasts(); 7852 } 7853 7854 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Base)) { 7855 if (Warn) 7856 HandleDeclRefExpr(DRE); 7857 return; 7858 } 7859 7860 // The base of a MemberExpr is not a MemberExpr or a DeclRefExpr. 7861 // Visit that expression. 7862 Visit(Base); 7863 } 7864 7865 void VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E) { 7866 if (E->getNumArgs() > 0) 7867 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E->getArg(0))) 7868 HandleDeclRefExpr(DRE); 7869 7870 Inherited::VisitCXXOperatorCallExpr(E); 7871 } 7872 7873 void VisitUnaryOperator(UnaryOperator *E) { 7874 // For POD record types, addresses of its own members are well-defined. 7875 if (E->getOpcode() == UO_AddrOf && isRecordType && 7876 isa<MemberExpr>(E->getSubExpr()->IgnoreParens())) { 7877 if (!isPODType) 7878 HandleValue(E->getSubExpr()); 7879 return; 7880 } 7881 Inherited::VisitUnaryOperator(E); 7882 } 7883 7884 void VisitObjCMessageExpr(ObjCMessageExpr *E) { return; } 7885 7886 void HandleDeclRefExpr(DeclRefExpr *DRE) { 7887 Decl* ReferenceDecl = DRE->getDecl(); 7888 if (OrigDecl != ReferenceDecl) return; 7889 unsigned diag; 7890 if (isReferenceType) { 7891 diag = diag::warn_uninit_self_reference_in_reference_init; 7892 } else if (cast<VarDecl>(OrigDecl)->isStaticLocal()) { 7893 diag = diag::warn_static_self_reference_in_init; 7894 } else { 7895 diag = diag::warn_uninit_self_reference_in_init; 7896 } 7897 7898 S.DiagRuntimeBehavior(DRE->getLocStart(), DRE, 7899 S.PDiag(diag) 7900 << DRE->getNameInfo().getName() 7901 << OrigDecl->getLocation() 7902 << DRE->getSourceRange()); 7903 } 7904 }; 7905 7906 /// CheckSelfReference - Warns if OrigDecl is used in expression E. 7907 static void CheckSelfReference(Sema &S, Decl* OrigDecl, Expr *E, 7908 bool DirectInit) { 7909 // Parameters arguments are occassionially constructed with itself, 7910 // for instance, in recursive functions. Skip them. 7911 if (isa<ParmVarDecl>(OrigDecl)) 7912 return; 7913 7914 E = E->IgnoreParens(); 7915 7916 // Skip checking T a = a where T is not a record or reference type. 7917 // Doing so is a way to silence uninitialized warnings. 7918 if (!DirectInit && !cast<VarDecl>(OrigDecl)->getType()->isRecordType()) 7919 if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E)) 7920 if (ICE->getCastKind() == CK_LValueToRValue) 7921 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(ICE->getSubExpr())) 7922 if (DRE->getDecl() == OrigDecl) 7923 return; 7924 7925 SelfReferenceChecker(S, OrigDecl).Visit(E); 7926 } 7927} 7928 7929/// AddInitializerToDecl - Adds the initializer Init to the 7930/// declaration dcl. If DirectInit is true, this is C++ direct 7931/// initialization rather than copy initialization. 7932void Sema::AddInitializerToDecl(Decl *RealDecl, Expr *Init, 7933 bool DirectInit, bool TypeMayContainAuto) { 7934 // If there is no declaration, there was an error parsing it. Just ignore 7935 // the initializer. 7936 if (RealDecl == 0 || RealDecl->isInvalidDecl()) 7937 return; 7938 7939 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(RealDecl)) { 7940 // With declarators parsed the way they are, the parser cannot 7941 // distinguish between a normal initializer and a pure-specifier. 7942 // Thus this grotesque test. 7943 IntegerLiteral *IL; 7944 if ((IL = dyn_cast<IntegerLiteral>(Init)) && IL->getValue() == 0 && 7945 Context.getCanonicalType(IL->getType()) == Context.IntTy) 7946 CheckPureMethod(Method, Init->getSourceRange()); 7947 else { 7948 Diag(Method->getLocation(), diag::err_member_function_initialization) 7949 << Method->getDeclName() << Init->getSourceRange(); 7950 Method->setInvalidDecl(); 7951 } 7952 return; 7953 } 7954 7955 VarDecl *VDecl = dyn_cast<VarDecl>(RealDecl); 7956 if (!VDecl) { 7957 assert(!isa<FieldDecl>(RealDecl) && "field init shouldn't get here"); 7958 Diag(RealDecl->getLocation(), diag::err_illegal_initializer); 7959 RealDecl->setInvalidDecl(); 7960 return; 7961 } 7962 ParenListExpr *CXXDirectInit = dyn_cast<ParenListExpr>(Init); 7963 7964 // C++11 [decl.spec.auto]p6. Deduce the type which 'auto' stands in for. 7965 if (TypeMayContainAuto && VDecl->getType()->isUndeducedType()) { 7966 Expr *DeduceInit = Init; 7967 // Initializer could be a C++ direct-initializer. Deduction only works if it 7968 // contains exactly one expression. 7969 if (CXXDirectInit) { 7970 if (CXXDirectInit->getNumExprs() == 0) { 7971 // It isn't possible to write this directly, but it is possible to 7972 // end up in this situation with "auto x(some_pack...);" 7973 Diag(CXXDirectInit->getLocStart(), 7974 VDecl->isInitCapture() ? diag::err_init_capture_no_expression 7975 : diag::err_auto_var_init_no_expression) 7976 << VDecl->getDeclName() << VDecl->getType() 7977 << VDecl->getSourceRange(); 7978 RealDecl->setInvalidDecl(); 7979 return; 7980 } else if (CXXDirectInit->getNumExprs() > 1) { 7981 Diag(CXXDirectInit->getExpr(1)->getLocStart(), 7982 VDecl->isInitCapture() 7983 ? diag::err_init_capture_multiple_expressions 7984 : diag::err_auto_var_init_multiple_expressions) 7985 << VDecl->getDeclName() << VDecl->getType() 7986 << VDecl->getSourceRange(); 7987 RealDecl->setInvalidDecl(); 7988 return; 7989 } else { 7990 DeduceInit = CXXDirectInit->getExpr(0); 7991 } 7992 } 7993 7994 // Expressions default to 'id' when we're in a debugger. 7995 bool DefaultedToAuto = false; 7996 if (getLangOpts().DebuggerCastResultToId && 7997 Init->getType() == Context.UnknownAnyTy) { 7998 ExprResult Result = forceUnknownAnyToType(Init, Context.getObjCIdType()); 7999 if (Result.isInvalid()) { 8000 VDecl->setInvalidDecl(); 8001 return; 8002 } 8003 Init = Result.take(); 8004 DefaultedToAuto = true; 8005 } 8006 8007 QualType DeducedType; 8008 if (DeduceAutoType(VDecl->getTypeSourceInfo(), DeduceInit, DeducedType) == 8009 DAR_Failed) 8010 DiagnoseAutoDeductionFailure(VDecl, DeduceInit); 8011 if (DeducedType.isNull()) { 8012 RealDecl->setInvalidDecl(); 8013 return; 8014 } 8015 VDecl->setType(DeducedType); 8016 assert(VDecl->isLinkageValid()); 8017 8018 // In ARC, infer lifetime. 8019 if (getLangOpts().ObjCAutoRefCount && inferObjCARCLifetime(VDecl)) 8020 VDecl->setInvalidDecl(); 8021 8022 // Warn if we deduced 'id'. 'auto' usually implies type-safety, but using 8023 // 'id' instead of a specific object type prevents most of our usual checks. 8024 // We only want to warn outside of template instantiations, though: 8025 // inside a template, the 'id' could have come from a parameter. 8026 if (ActiveTemplateInstantiations.empty() && !DefaultedToAuto && 8027 DeducedType->isObjCIdType()) { 8028 SourceLocation Loc = 8029 VDecl->getTypeSourceInfo()->getTypeLoc().getBeginLoc(); 8030 Diag(Loc, diag::warn_auto_var_is_id) 8031 << VDecl->getDeclName() << DeduceInit->getSourceRange(); 8032 } 8033 8034 // If this is a redeclaration, check that the type we just deduced matches 8035 // the previously declared type. 8036 if (VarDecl *Old = VDecl->getPreviousDecl()) { 8037 // We never need to merge the type, because we cannot form an incomplete 8038 // array of auto, nor deduce such a type. 8039 MergeVarDeclTypes(VDecl, Old, /*MergeTypeWithPrevious*/false); 8040 } 8041 8042 // Check the deduced type is valid for a variable declaration. 8043 CheckVariableDeclarationType(VDecl); 8044 if (VDecl->isInvalidDecl()) 8045 return; 8046 } 8047 8048 if (VDecl->isLocalVarDecl() && VDecl->hasExternalStorage()) { 8049 // C99 6.7.8p5. C++ has no such restriction, but that is a defect. 8050 Diag(VDecl->getLocation(), diag::err_block_extern_cant_init); 8051 VDecl->setInvalidDecl(); 8052 return; 8053 } 8054 8055 if (!VDecl->getType()->isDependentType()) { 8056 // A definition must end up with a complete type, which means it must be 8057 // complete with the restriction that an array type might be completed by 8058 // the initializer; note that later code assumes this restriction. 8059 QualType BaseDeclType = VDecl->getType(); 8060 if (const ArrayType *Array = Context.getAsIncompleteArrayType(BaseDeclType)) 8061 BaseDeclType = Array->getElementType(); 8062 if (RequireCompleteType(VDecl->getLocation(), BaseDeclType, 8063 diag::err_typecheck_decl_incomplete_type)) { 8064 RealDecl->setInvalidDecl(); 8065 return; 8066 } 8067 8068 // The variable can not have an abstract class type. 8069 if (RequireNonAbstractType(VDecl->getLocation(), VDecl->getType(), 8070 diag::err_abstract_type_in_decl, 8071 AbstractVariableType)) 8072 VDecl->setInvalidDecl(); 8073 } 8074 8075 const VarDecl *Def; 8076 if ((Def = VDecl->getDefinition()) && Def != VDecl) { 8077 Diag(VDecl->getLocation(), diag::err_redefinition) 8078 << VDecl->getDeclName(); 8079 Diag(Def->getLocation(), diag::note_previous_definition); 8080 VDecl->setInvalidDecl(); 8081 return; 8082 } 8083 8084 const VarDecl* PrevInit = 0; 8085 if (getLangOpts().CPlusPlus) { 8086 // C++ [class.static.data]p4 8087 // If a static data member is of const integral or const 8088 // enumeration type, its declaration in the class definition can 8089 // specify a constant-initializer which shall be an integral 8090 // constant expression (5.19). In that case, the member can appear 8091 // in integral constant expressions. The member shall still be 8092 // defined in a namespace scope if it is used in the program and the 8093 // namespace scope definition shall not contain an initializer. 8094 // 8095 // We already performed a redefinition check above, but for static 8096 // data members we also need to check whether there was an in-class 8097 // declaration with an initializer. 8098 if (VDecl->isStaticDataMember() && VDecl->getAnyInitializer(PrevInit)) { 8099 Diag(VDecl->getLocation(), diag::err_redefinition) 8100 << VDecl->getDeclName(); 8101 Diag(PrevInit->getLocation(), diag::note_previous_definition); 8102 return; 8103 } 8104 8105 if (VDecl->hasLocalStorage()) 8106 getCurFunction()->setHasBranchProtectedScope(); 8107 8108 if (DiagnoseUnexpandedParameterPack(Init, UPPC_Initializer)) { 8109 VDecl->setInvalidDecl(); 8110 return; 8111 } 8112 } 8113 8114 // OpenCL 1.1 6.5.2: "Variables allocated in the __local address space inside 8115 // a kernel function cannot be initialized." 8116 if (VDecl->getStorageClass() == SC_OpenCLWorkGroupLocal) { 8117 Diag(VDecl->getLocation(), diag::err_local_cant_init); 8118 VDecl->setInvalidDecl(); 8119 return; 8120 } 8121 8122 // Get the decls type and save a reference for later, since 8123 // CheckInitializerTypes may change it. 8124 QualType DclT = VDecl->getType(), SavT = DclT; 8125 8126 // Expressions default to 'id' when we're in a debugger 8127 // and we are assigning it to a variable of Objective-C pointer type. 8128 if (getLangOpts().DebuggerCastResultToId && DclT->isObjCObjectPointerType() && 8129 Init->getType() == Context.UnknownAnyTy) { 8130 ExprResult Result = forceUnknownAnyToType(Init, Context.getObjCIdType()); 8131 if (Result.isInvalid()) { 8132 VDecl->setInvalidDecl(); 8133 return; 8134 } 8135 Init = Result.take(); 8136 } 8137 8138 // Perform the initialization. 8139 if (!VDecl->isInvalidDecl()) { 8140 InitializedEntity Entity = InitializedEntity::InitializeVariable(VDecl); 8141 InitializationKind Kind 8142 = DirectInit ? 8143 CXXDirectInit ? InitializationKind::CreateDirect(VDecl->getLocation(), 8144 Init->getLocStart(), 8145 Init->getLocEnd()) 8146 : InitializationKind::CreateDirectList( 8147 VDecl->getLocation()) 8148 : InitializationKind::CreateCopy(VDecl->getLocation(), 8149 Init->getLocStart()); 8150 8151 MultiExprArg Args = Init; 8152 if (CXXDirectInit) 8153 Args = MultiExprArg(CXXDirectInit->getExprs(), 8154 CXXDirectInit->getNumExprs()); 8155 8156 InitializationSequence InitSeq(*this, Entity, Kind, Args); 8157 ExprResult Result = InitSeq.Perform(*this, Entity, Kind, Args, &DclT); 8158 if (Result.isInvalid()) { 8159 VDecl->setInvalidDecl(); 8160 return; 8161 } 8162 8163 Init = Result.takeAs<Expr>(); 8164 } 8165 8166 // Check for self-references within variable initializers. 8167 // Variables declared within a function/method body (except for references) 8168 // are handled by a dataflow analysis. 8169 if (!VDecl->hasLocalStorage() || VDecl->getType()->isRecordType() || 8170 VDecl->getType()->isReferenceType()) { 8171 CheckSelfReference(*this, RealDecl, Init, DirectInit); 8172 } 8173 8174 // If the type changed, it means we had an incomplete type that was 8175 // completed by the initializer. For example: 8176 // int ary[] = { 1, 3, 5 }; 8177 // "ary" transitions from an IncompleteArrayType to a ConstantArrayType. 8178 if (!VDecl->isInvalidDecl() && (DclT != SavT)) 8179 VDecl->setType(DclT); 8180 8181 if (!VDecl->isInvalidDecl()) { 8182 checkUnsafeAssigns(VDecl->getLocation(), VDecl->getType(), Init); 8183 8184 if (VDecl->hasAttr<BlocksAttr>()) 8185 checkRetainCycles(VDecl, Init); 8186 8187 // It is safe to assign a weak reference into a strong variable. 8188 // Although this code can still have problems: 8189 // id x = self.weakProp; 8190 // id y = self.weakProp; 8191 // we do not warn to warn spuriously when 'x' and 'y' are on separate 8192 // paths through the function. This should be revisited if 8193 // -Wrepeated-use-of-weak is made flow-sensitive. 8194 if (VDecl->getType().getObjCLifetime() == Qualifiers::OCL_Strong) { 8195 DiagnosticsEngine::Level Level = 8196 Diags.getDiagnosticLevel(diag::warn_arc_repeated_use_of_weak, 8197 Init->getLocStart()); 8198 if (Level != DiagnosticsEngine::Ignored) 8199 getCurFunction()->markSafeWeakUse(Init); 8200 } 8201 } 8202 8203 // The initialization is usually a full-expression. 8204 // 8205 // FIXME: If this is a braced initialization of an aggregate, it is not 8206 // an expression, and each individual field initializer is a separate 8207 // full-expression. For instance, in: 8208 // 8209 // struct Temp { ~Temp(); }; 8210 // struct S { S(Temp); }; 8211 // struct T { S a, b; } t = { Temp(), Temp() } 8212 // 8213 // we should destroy the first Temp before constructing the second. 8214 ExprResult Result = ActOnFinishFullExpr(Init, VDecl->getLocation(), 8215 false, 8216 VDecl->isConstexpr()); 8217 if (Result.isInvalid()) { 8218 VDecl->setInvalidDecl(); 8219 return; 8220 } 8221 Init = Result.take(); 8222 8223 // Attach the initializer to the decl. 8224 VDecl->setInit(Init); 8225 8226 if (VDecl->isLocalVarDecl()) { 8227 // C99 6.7.8p4: All the expressions in an initializer for an object that has 8228 // static storage duration shall be constant expressions or string literals. 8229 // C++ does not have this restriction. 8230 if (!getLangOpts().CPlusPlus && !VDecl->isInvalidDecl()) { 8231 if (VDecl->getStorageClass() == SC_Static) 8232 CheckForConstantInitializer(Init, DclT); 8233 // C89 is stricter than C99 for non-static aggregate types. 8234 // C89 6.5.7p3: All the expressions [...] in an initializer list 8235 // for an object that has aggregate or union type shall be 8236 // constant expressions. 8237 else if (!getLangOpts().C99 && VDecl->getType()->isAggregateType() && 8238 isa<InitListExpr>(Init) && 8239 !Init->isConstantInitializer(Context, false)) 8240 Diag(Init->getExprLoc(), 8241 diag::ext_aggregate_init_not_constant) 8242 << Init->getSourceRange(); 8243 } 8244 } else if (VDecl->isStaticDataMember() && 8245 VDecl->getLexicalDeclContext()->isRecord()) { 8246 // This is an in-class initialization for a static data member, e.g., 8247 // 8248 // struct S { 8249 // static const int value = 17; 8250 // }; 8251 8252 // C++ [class.mem]p4: 8253 // A member-declarator can contain a constant-initializer only 8254 // if it declares a static member (9.4) of const integral or 8255 // const enumeration type, see 9.4.2. 8256 // 8257 // C++11 [class.static.data]p3: 8258 // If a non-volatile const static data member is of integral or 8259 // enumeration type, its declaration in the class definition can 8260 // specify a brace-or-equal-initializer in which every initalizer-clause 8261 // that is an assignment-expression is a constant expression. A static 8262 // data member of literal type can be declared in the class definition 8263 // with the constexpr specifier; if so, its declaration shall specify a 8264 // brace-or-equal-initializer in which every initializer-clause that is 8265 // an assignment-expression is a constant expression. 8266 8267 // Do nothing on dependent types. 8268 if (DclT->isDependentType()) { 8269 8270 // Allow any 'static constexpr' members, whether or not they are of literal 8271 // type. We separately check that every constexpr variable is of literal 8272 // type. 8273 } else if (VDecl->isConstexpr()) { 8274 8275 // Require constness. 8276 } else if (!DclT.isConstQualified()) { 8277 Diag(VDecl->getLocation(), diag::err_in_class_initializer_non_const) 8278 << Init->getSourceRange(); 8279 VDecl->setInvalidDecl(); 8280 8281 // We allow integer constant expressions in all cases. 8282 } else if (DclT->isIntegralOrEnumerationType()) { 8283 // Check whether the expression is a constant expression. 8284 SourceLocation Loc; 8285 if (getLangOpts().CPlusPlus11 && DclT.isVolatileQualified()) 8286 // In C++11, a non-constexpr const static data member with an 8287 // in-class initializer cannot be volatile. 8288 Diag(VDecl->getLocation(), diag::err_in_class_initializer_volatile); 8289 else if (Init->isValueDependent()) 8290 ; // Nothing to check. 8291 else if (Init->isIntegerConstantExpr(Context, &Loc)) 8292 ; // Ok, it's an ICE! 8293 else if (Init->isEvaluatable(Context)) { 8294 // If we can constant fold the initializer through heroics, accept it, 8295 // but report this as a use of an extension for -pedantic. 8296 Diag(Loc, diag::ext_in_class_initializer_non_constant) 8297 << Init->getSourceRange(); 8298 } else { 8299 // Otherwise, this is some crazy unknown case. Report the issue at the 8300 // location provided by the isIntegerConstantExpr failed check. 8301 Diag(Loc, diag::err_in_class_initializer_non_constant) 8302 << Init->getSourceRange(); 8303 VDecl->setInvalidDecl(); 8304 } 8305 8306 // We allow foldable floating-point constants as an extension. 8307 } else if (DclT->isFloatingType()) { // also permits complex, which is ok 8308 // In C++98, this is a GNU extension. In C++11, it is not, but we support 8309 // it anyway and provide a fixit to add the 'constexpr'. 8310 if (getLangOpts().CPlusPlus11) { 8311 Diag(VDecl->getLocation(), 8312 diag::ext_in_class_initializer_float_type_cxx11) 8313 << DclT << Init->getSourceRange(); 8314 Diag(VDecl->getLocStart(), 8315 diag::note_in_class_initializer_float_type_cxx11) 8316 << FixItHint::CreateInsertion(VDecl->getLocStart(), "constexpr "); 8317 } else { 8318 Diag(VDecl->getLocation(), diag::ext_in_class_initializer_float_type) 8319 << DclT << Init->getSourceRange(); 8320 8321 if (!Init->isValueDependent() && !Init->isEvaluatable(Context)) { 8322 Diag(Init->getExprLoc(), diag::err_in_class_initializer_non_constant) 8323 << Init->getSourceRange(); 8324 VDecl->setInvalidDecl(); 8325 } 8326 } 8327 8328 // Suggest adding 'constexpr' in C++11 for literal types. 8329 } else if (getLangOpts().CPlusPlus11 && DclT->isLiteralType(Context)) { 8330 Diag(VDecl->getLocation(), diag::err_in_class_initializer_literal_type) 8331 << DclT << Init->getSourceRange() 8332 << FixItHint::CreateInsertion(VDecl->getLocStart(), "constexpr "); 8333 VDecl->setConstexpr(true); 8334 8335 } else { 8336 Diag(VDecl->getLocation(), diag::err_in_class_initializer_bad_type) 8337 << DclT << Init->getSourceRange(); 8338 VDecl->setInvalidDecl(); 8339 } 8340 } else if (VDecl->isFileVarDecl()) { 8341 if (VDecl->getStorageClass() == SC_Extern && 8342 (!getLangOpts().CPlusPlus || 8343 !(Context.getBaseElementType(VDecl->getType()).isConstQualified() || 8344 VDecl->isExternC())) && 8345 !isTemplateInstantiation(VDecl->getTemplateSpecializationKind())) 8346 Diag(VDecl->getLocation(), diag::warn_extern_init); 8347 8348 // C99 6.7.8p4. All file scoped initializers need to be constant. 8349 if (!getLangOpts().CPlusPlus && !VDecl->isInvalidDecl()) 8350 CheckForConstantInitializer(Init, DclT); 8351 else if (VDecl->getTLSKind() == VarDecl::TLS_Static && 8352 !VDecl->isInvalidDecl() && !DclT->isDependentType() && 8353 !Init->isValueDependent() && !VDecl->isConstexpr() && 8354 !Init->isConstantInitializer( 8355 Context, VDecl->getType()->isReferenceType())) { 8356 // GNU C++98 edits for __thread, [basic.start.init]p4: 8357 // An object of thread storage duration shall not require dynamic 8358 // initialization. 8359 // FIXME: Need strict checking here. 8360 Diag(VDecl->getLocation(), diag::err_thread_dynamic_init); 8361 if (getLangOpts().CPlusPlus11) 8362 Diag(VDecl->getLocation(), diag::note_use_thread_local); 8363 } 8364 } 8365 8366 // We will represent direct-initialization similarly to copy-initialization: 8367 // int x(1); -as-> int x = 1; 8368 // ClassType x(a,b,c); -as-> ClassType x = ClassType(a,b,c); 8369 // 8370 // Clients that want to distinguish between the two forms, can check for 8371 // direct initializer using VarDecl::getInitStyle(). 8372 // A major benefit is that clients that don't particularly care about which 8373 // exactly form was it (like the CodeGen) can handle both cases without 8374 // special case code. 8375 8376 // C++ 8.5p11: 8377 // The form of initialization (using parentheses or '=') is generally 8378 // insignificant, but does matter when the entity being initialized has a 8379 // class type. 8380 if (CXXDirectInit) { 8381 assert(DirectInit && "Call-style initializer must be direct init."); 8382 VDecl->setInitStyle(VarDecl::CallInit); 8383 } else if (DirectInit) { 8384 // This must be list-initialization. No other way is direct-initialization. 8385 VDecl->setInitStyle(VarDecl::ListInit); 8386 } 8387 8388 CheckCompleteVariableDeclaration(VDecl); 8389} 8390 8391/// ActOnInitializerError - Given that there was an error parsing an 8392/// initializer for the given declaration, try to return to some form 8393/// of sanity. 8394void Sema::ActOnInitializerError(Decl *D) { 8395 // Our main concern here is re-establishing invariants like "a 8396 // variable's type is either dependent or complete". 8397 if (!D || D->isInvalidDecl()) return; 8398 8399 VarDecl *VD = dyn_cast<VarDecl>(D); 8400 if (!VD) return; 8401 8402 // Auto types are meaningless if we can't make sense of the initializer. 8403 if (ParsingInitForAutoVars.count(D)) { 8404 D->setInvalidDecl(); 8405 return; 8406 } 8407 8408 QualType Ty = VD->getType(); 8409 if (Ty->isDependentType()) return; 8410 8411 // Require a complete type. 8412 if (RequireCompleteType(VD->getLocation(), 8413 Context.getBaseElementType(Ty), 8414 diag::err_typecheck_decl_incomplete_type)) { 8415 VD->setInvalidDecl(); 8416 return; 8417 } 8418 8419 // Require an abstract type. 8420 if (RequireNonAbstractType(VD->getLocation(), Ty, 8421 diag::err_abstract_type_in_decl, 8422 AbstractVariableType)) { 8423 VD->setInvalidDecl(); 8424 return; 8425 } 8426 8427 // Don't bother complaining about constructors or destructors, 8428 // though. 8429} 8430 8431void Sema::ActOnUninitializedDecl(Decl *RealDecl, 8432 bool TypeMayContainAuto) { 8433 // If there is no declaration, there was an error parsing it. Just ignore it. 8434 if (RealDecl == 0) 8435 return; 8436 8437 if (VarDecl *Var = dyn_cast<VarDecl>(RealDecl)) { 8438 QualType Type = Var->getType(); 8439 8440 // C++11 [dcl.spec.auto]p3 8441 if (TypeMayContainAuto && Type->getContainedAutoType()) { 8442 Diag(Var->getLocation(), diag::err_auto_var_requires_init) 8443 << Var->getDeclName() << Type; 8444 Var->setInvalidDecl(); 8445 return; 8446 } 8447 8448 // C++11 [class.static.data]p3: A static data member can be declared with 8449 // the constexpr specifier; if so, its declaration shall specify 8450 // a brace-or-equal-initializer. 8451 // C++11 [dcl.constexpr]p1: The constexpr specifier shall be applied only to 8452 // the definition of a variable [...] or the declaration of a static data 8453 // member. 8454 if (Var->isConstexpr() && !Var->isThisDeclarationADefinition()) { 8455 if (Var->isStaticDataMember()) 8456 Diag(Var->getLocation(), 8457 diag::err_constexpr_static_mem_var_requires_init) 8458 << Var->getDeclName(); 8459 else 8460 Diag(Var->getLocation(), diag::err_invalid_constexpr_var_decl); 8461 Var->setInvalidDecl(); 8462 return; 8463 } 8464 8465 switch (Var->isThisDeclarationADefinition()) { 8466 case VarDecl::Definition: 8467 if (!Var->isStaticDataMember() || !Var->getAnyInitializer()) 8468 break; 8469 8470 // We have an out-of-line definition of a static data member 8471 // that has an in-class initializer, so we type-check this like 8472 // a declaration. 8473 // 8474 // Fall through 8475 8476 case VarDecl::DeclarationOnly: 8477 // It's only a declaration. 8478 8479 // Block scope. C99 6.7p7: If an identifier for an object is 8480 // declared with no linkage (C99 6.2.2p6), the type for the 8481 // object shall be complete. 8482 if (!Type->isDependentType() && Var->isLocalVarDecl() && 8483 !Var->hasLinkage() && !Var->isInvalidDecl() && 8484 RequireCompleteType(Var->getLocation(), Type, 8485 diag::err_typecheck_decl_incomplete_type)) 8486 Var->setInvalidDecl(); 8487 8488 // Make sure that the type is not abstract. 8489 if (!Type->isDependentType() && !Var->isInvalidDecl() && 8490 RequireNonAbstractType(Var->getLocation(), Type, 8491 diag::err_abstract_type_in_decl, 8492 AbstractVariableType)) 8493 Var->setInvalidDecl(); 8494 if (!Type->isDependentType() && !Var->isInvalidDecl() && 8495 Var->getStorageClass() == SC_PrivateExtern) { 8496 Diag(Var->getLocation(), diag::warn_private_extern); 8497 Diag(Var->getLocation(), diag::note_private_extern); 8498 } 8499 8500 return; 8501 8502 case VarDecl::TentativeDefinition: 8503 // File scope. C99 6.9.2p2: A declaration of an identifier for an 8504 // object that has file scope without an initializer, and without a 8505 // storage-class specifier or with the storage-class specifier "static", 8506 // constitutes a tentative definition. Note: A tentative definition with 8507 // external linkage is valid (C99 6.2.2p5). 8508 if (!Var->isInvalidDecl()) { 8509 if (const IncompleteArrayType *ArrayT 8510 = Context.getAsIncompleteArrayType(Type)) { 8511 if (RequireCompleteType(Var->getLocation(), 8512 ArrayT->getElementType(), 8513 diag::err_illegal_decl_array_incomplete_type)) 8514 Var->setInvalidDecl(); 8515 } else if (Var->getStorageClass() == SC_Static) { 8516 // C99 6.9.2p3: If the declaration of an identifier for an object is 8517 // a tentative definition and has internal linkage (C99 6.2.2p3), the 8518 // declared type shall not be an incomplete type. 8519 // NOTE: code such as the following 8520 // static struct s; 8521 // struct s { int a; }; 8522 // is accepted by gcc. Hence here we issue a warning instead of 8523 // an error and we do not invalidate the static declaration. 8524 // NOTE: to avoid multiple warnings, only check the first declaration. 8525 if (Var->getPreviousDecl() == 0) 8526 RequireCompleteType(Var->getLocation(), Type, 8527 diag::ext_typecheck_decl_incomplete_type); 8528 } 8529 } 8530 8531 // Record the tentative definition; we're done. 8532 if (!Var->isInvalidDecl()) 8533 TentativeDefinitions.push_back(Var); 8534 return; 8535 } 8536 8537 // Provide a specific diagnostic for uninitialized variable 8538 // definitions with incomplete array type. 8539 if (Type->isIncompleteArrayType()) { 8540 Diag(Var->getLocation(), 8541 diag::err_typecheck_incomplete_array_needs_initializer); 8542 Var->setInvalidDecl(); 8543 return; 8544 } 8545 8546 // Provide a specific diagnostic for uninitialized variable 8547 // definitions with reference type. 8548 if (Type->isReferenceType()) { 8549 Diag(Var->getLocation(), diag::err_reference_var_requires_init) 8550 << Var->getDeclName() 8551 << SourceRange(Var->getLocation(), Var->getLocation()); 8552 Var->setInvalidDecl(); 8553 return; 8554 } 8555 8556 // Do not attempt to type-check the default initializer for a 8557 // variable with dependent type. 8558 if (Type->isDependentType()) 8559 return; 8560 8561 if (Var->isInvalidDecl()) 8562 return; 8563 8564 if (RequireCompleteType(Var->getLocation(), 8565 Context.getBaseElementType(Type), 8566 diag::err_typecheck_decl_incomplete_type)) { 8567 Var->setInvalidDecl(); 8568 return; 8569 } 8570 8571 // The variable can not have an abstract class type. 8572 if (RequireNonAbstractType(Var->getLocation(), Type, 8573 diag::err_abstract_type_in_decl, 8574 AbstractVariableType)) { 8575 Var->setInvalidDecl(); 8576 return; 8577 } 8578 8579 // Check for jumps past the implicit initializer. C++0x 8580 // clarifies that this applies to a "variable with automatic 8581 // storage duration", not a "local variable". 8582 // C++11 [stmt.dcl]p3 8583 // A program that jumps from a point where a variable with automatic 8584 // storage duration is not in scope to a point where it is in scope is 8585 // ill-formed unless the variable has scalar type, class type with a 8586 // trivial default constructor and a trivial destructor, a cv-qualified 8587 // version of one of these types, or an array of one of the preceding 8588 // types and is declared without an initializer. 8589 if (getLangOpts().CPlusPlus && Var->hasLocalStorage()) { 8590 if (const RecordType *Record 8591 = Context.getBaseElementType(Type)->getAs<RecordType>()) { 8592 CXXRecordDecl *CXXRecord = cast<CXXRecordDecl>(Record->getDecl()); 8593 // Mark the function for further checking even if the looser rules of 8594 // C++11 do not require such checks, so that we can diagnose 8595 // incompatibilities with C++98. 8596 if (!CXXRecord->isPOD()) 8597 getCurFunction()->setHasBranchProtectedScope(); 8598 } 8599 } 8600 8601 // C++03 [dcl.init]p9: 8602 // If no initializer is specified for an object, and the 8603 // object is of (possibly cv-qualified) non-POD class type (or 8604 // array thereof), the object shall be default-initialized; if 8605 // the object is of const-qualified type, the underlying class 8606 // type shall have a user-declared default 8607 // constructor. Otherwise, if no initializer is specified for 8608 // a non- static object, the object and its subobjects, if 8609 // any, have an indeterminate initial value); if the object 8610 // or any of its subobjects are of const-qualified type, the 8611 // program is ill-formed. 8612 // C++0x [dcl.init]p11: 8613 // If no initializer is specified for an object, the object is 8614 // default-initialized; [...]. 8615 InitializedEntity Entity = InitializedEntity::InitializeVariable(Var); 8616 InitializationKind Kind 8617 = InitializationKind::CreateDefault(Var->getLocation()); 8618 8619 InitializationSequence InitSeq(*this, Entity, Kind, None); 8620 ExprResult Init = InitSeq.Perform(*this, Entity, Kind, None); 8621 if (Init.isInvalid()) 8622 Var->setInvalidDecl(); 8623 else if (Init.get()) { 8624 Var->setInit(MaybeCreateExprWithCleanups(Init.get())); 8625 // This is important for template substitution. 8626 Var->setInitStyle(VarDecl::CallInit); 8627 } 8628 8629 CheckCompleteVariableDeclaration(Var); 8630 } 8631} 8632 8633void Sema::ActOnCXXForRangeDecl(Decl *D) { 8634 VarDecl *VD = dyn_cast<VarDecl>(D); 8635 if (!VD) { 8636 Diag(D->getLocation(), diag::err_for_range_decl_must_be_var); 8637 D->setInvalidDecl(); 8638 return; 8639 } 8640 8641 VD->setCXXForRangeDecl(true); 8642 8643 // for-range-declaration cannot be given a storage class specifier. 8644 int Error = -1; 8645 switch (VD->getStorageClass()) { 8646 case SC_None: 8647 break; 8648 case SC_Extern: 8649 Error = 0; 8650 break; 8651 case SC_Static: 8652 Error = 1; 8653 break; 8654 case SC_PrivateExtern: 8655 Error = 2; 8656 break; 8657 case SC_Auto: 8658 Error = 3; 8659 break; 8660 case SC_Register: 8661 Error = 4; 8662 break; 8663 case SC_OpenCLWorkGroupLocal: 8664 llvm_unreachable("Unexpected storage class"); 8665 } 8666 if (VD->isConstexpr()) 8667 Error = 5; 8668 if (Error != -1) { 8669 Diag(VD->getOuterLocStart(), diag::err_for_range_storage_class) 8670 << VD->getDeclName() << Error; 8671 D->setInvalidDecl(); 8672 } 8673} 8674 8675void Sema::CheckCompleteVariableDeclaration(VarDecl *var) { 8676 if (var->isInvalidDecl()) return; 8677 8678 // In ARC, don't allow jumps past the implicit initialization of a 8679 // local retaining variable. 8680 if (getLangOpts().ObjCAutoRefCount && 8681 var->hasLocalStorage()) { 8682 switch (var->getType().getObjCLifetime()) { 8683 case Qualifiers::OCL_None: 8684 case Qualifiers::OCL_ExplicitNone: 8685 case Qualifiers::OCL_Autoreleasing: 8686 break; 8687 8688 case Qualifiers::OCL_Weak: 8689 case Qualifiers::OCL_Strong: 8690 getCurFunction()->setHasBranchProtectedScope(); 8691 break; 8692 } 8693 } 8694 8695 if (var->isThisDeclarationADefinition() && 8696 var->isExternallyVisible() && var->hasLinkage() && 8697 getDiagnostics().getDiagnosticLevel( 8698 diag::warn_missing_variable_declarations, 8699 var->getLocation())) { 8700 // Find a previous declaration that's not a definition. 8701 VarDecl *prev = var->getPreviousDecl(); 8702 while (prev && prev->isThisDeclarationADefinition()) 8703 prev = prev->getPreviousDecl(); 8704 8705 if (!prev) 8706 Diag(var->getLocation(), diag::warn_missing_variable_declarations) << var; 8707 } 8708 8709 if (var->getTLSKind() == VarDecl::TLS_Static && 8710 var->getType().isDestructedType()) { 8711 // GNU C++98 edits for __thread, [basic.start.term]p3: 8712 // The type of an object with thread storage duration shall not 8713 // have a non-trivial destructor. 8714 Diag(var->getLocation(), diag::err_thread_nontrivial_dtor); 8715 if (getLangOpts().CPlusPlus11) 8716 Diag(var->getLocation(), diag::note_use_thread_local); 8717 } 8718 8719 // All the following checks are C++ only. 8720 if (!getLangOpts().CPlusPlus) return; 8721 8722 QualType type = var->getType(); 8723 if (type->isDependentType()) return; 8724 8725 // __block variables might require us to capture a copy-initializer. 8726 if (var->hasAttr<BlocksAttr>()) { 8727 // It's currently invalid to ever have a __block variable with an 8728 // array type; should we diagnose that here? 8729 8730 // Regardless, we don't want to ignore array nesting when 8731 // constructing this copy. 8732 if (type->isStructureOrClassType()) { 8733 EnterExpressionEvaluationContext scope(*this, PotentiallyEvaluated); 8734 SourceLocation poi = var->getLocation(); 8735 Expr *varRef =new (Context) DeclRefExpr(var, false, type, VK_LValue, poi); 8736 ExprResult result 8737 = PerformMoveOrCopyInitialization( 8738 InitializedEntity::InitializeBlock(poi, type, false), 8739 var, var->getType(), varRef, /*AllowNRVO=*/true); 8740 if (!result.isInvalid()) { 8741 result = MaybeCreateExprWithCleanups(result); 8742 Expr *init = result.takeAs<Expr>(); 8743 Context.setBlockVarCopyInits(var, init); 8744 } 8745 } 8746 } 8747 8748 Expr *Init = var->getInit(); 8749 bool IsGlobal = var->hasGlobalStorage() && !var->isStaticLocal(); 8750 QualType baseType = Context.getBaseElementType(type); 8751 8752 if (!var->getDeclContext()->isDependentContext() && 8753 Init && !Init->isValueDependent()) { 8754 if (IsGlobal && !var->isConstexpr() && 8755 getDiagnostics().getDiagnosticLevel(diag::warn_global_constructor, 8756 var->getLocation()) 8757 != DiagnosticsEngine::Ignored) { 8758 // Warn about globals which don't have a constant initializer. Don't 8759 // warn about globals with a non-trivial destructor because we already 8760 // warned about them. 8761 CXXRecordDecl *RD = baseType->getAsCXXRecordDecl(); 8762 if (!(RD && !RD->hasTrivialDestructor()) && 8763 !Init->isConstantInitializer(Context, baseType->isReferenceType())) 8764 Diag(var->getLocation(), diag::warn_global_constructor) 8765 << Init->getSourceRange(); 8766 } 8767 8768 if (var->isConstexpr()) { 8769 SmallVector<PartialDiagnosticAt, 8> Notes; 8770 if (!var->evaluateValue(Notes) || !var->isInitICE()) { 8771 SourceLocation DiagLoc = var->getLocation(); 8772 // If the note doesn't add any useful information other than a source 8773 // location, fold it into the primary diagnostic. 8774 if (Notes.size() == 1 && Notes[0].second.getDiagID() == 8775 diag::note_invalid_subexpr_in_const_expr) { 8776 DiagLoc = Notes[0].first; 8777 Notes.clear(); 8778 } 8779 Diag(DiagLoc, diag::err_constexpr_var_requires_const_init) 8780 << var << Init->getSourceRange(); 8781 for (unsigned I = 0, N = Notes.size(); I != N; ++I) 8782 Diag(Notes[I].first, Notes[I].second); 8783 } 8784 } else if (var->isUsableInConstantExpressions(Context)) { 8785 // Check whether the initializer of a const variable of integral or 8786 // enumeration type is an ICE now, since we can't tell whether it was 8787 // initialized by a constant expression if we check later. 8788 var->checkInitIsICE(); 8789 } 8790 } 8791 8792 // Require the destructor. 8793 if (const RecordType *recordType = baseType->getAs<RecordType>()) 8794 FinalizeVarWithDestructor(var, recordType); 8795} 8796 8797/// FinalizeDeclaration - called by ParseDeclarationAfterDeclarator to perform 8798/// any semantic actions necessary after any initializer has been attached. 8799void 8800Sema::FinalizeDeclaration(Decl *ThisDecl) { 8801 // Note that we are no longer parsing the initializer for this declaration. 8802 ParsingInitForAutoVars.erase(ThisDecl); 8803 8804 VarDecl *VD = dyn_cast_or_null<VarDecl>(ThisDecl); 8805 if (!VD) 8806 return; 8807 8808 if (UsedAttr *Attr = VD->getAttr<UsedAttr>()) { 8809 if (!Attr->isInherited() && !VD->isThisDeclarationADefinition()) { 8810 Diag(Attr->getLocation(), diag::warn_attribute_ignored) << "used"; 8811 VD->dropAttr<UsedAttr>(); 8812 } 8813 } 8814 8815 const DeclContext *DC = VD->getDeclContext(); 8816 // If there's a #pragma GCC visibility in scope, and this isn't a class 8817 // member, set the visibility of this variable. 8818 if (!DC->isRecord() && VD->isExternallyVisible()) 8819 AddPushedVisibilityAttribute(VD); 8820 8821 if (VD->isFileVarDecl()) 8822 MarkUnusedFileScopedDecl(VD); 8823 8824 // Now we have parsed the initializer and can update the table of magic 8825 // tag values. 8826 if (!VD->hasAttr<TypeTagForDatatypeAttr>() || 8827 !VD->getType()->isIntegralOrEnumerationType()) 8828 return; 8829 8830 for (specific_attr_iterator<TypeTagForDatatypeAttr> 8831 I = ThisDecl->specific_attr_begin<TypeTagForDatatypeAttr>(), 8832 E = ThisDecl->specific_attr_end<TypeTagForDatatypeAttr>(); 8833 I != E; ++I) { 8834 const Expr *MagicValueExpr = VD->getInit(); 8835 if (!MagicValueExpr) { 8836 continue; 8837 } 8838 llvm::APSInt MagicValueInt; 8839 if (!MagicValueExpr->isIntegerConstantExpr(MagicValueInt, Context)) { 8840 Diag(I->getRange().getBegin(), 8841 diag::err_type_tag_for_datatype_not_ice) 8842 << LangOpts.CPlusPlus << MagicValueExpr->getSourceRange(); 8843 continue; 8844 } 8845 if (MagicValueInt.getActiveBits() > 64) { 8846 Diag(I->getRange().getBegin(), 8847 diag::err_type_tag_for_datatype_too_large) 8848 << LangOpts.CPlusPlus << MagicValueExpr->getSourceRange(); 8849 continue; 8850 } 8851 uint64_t MagicValue = MagicValueInt.getZExtValue(); 8852 RegisterTypeTagForDatatype(I->getArgumentKind(), 8853 MagicValue, 8854 I->getMatchingCType(), 8855 I->getLayoutCompatible(), 8856 I->getMustBeNull()); 8857 } 8858} 8859 8860Sema::DeclGroupPtrTy Sema::FinalizeDeclaratorGroup(Scope *S, const DeclSpec &DS, 8861 ArrayRef<Decl *> Group) { 8862 SmallVector<Decl*, 8> Decls; 8863 8864 if (DS.isTypeSpecOwned()) 8865 Decls.push_back(DS.getRepAsDecl()); 8866 8867 DeclaratorDecl *FirstDeclaratorInGroup = 0; 8868 for (unsigned i = 0, e = Group.size(); i != e; ++i) 8869 if (Decl *D = Group[i]) { 8870 if (DeclaratorDecl *DD = dyn_cast<DeclaratorDecl>(D)) 8871 if (!FirstDeclaratorInGroup) 8872 FirstDeclaratorInGroup = DD; 8873 Decls.push_back(D); 8874 } 8875 8876 if (DeclSpec::isDeclRep(DS.getTypeSpecType())) { 8877 if (TagDecl *Tag = dyn_cast_or_null<TagDecl>(DS.getRepAsDecl())) { 8878 HandleTagNumbering(*this, Tag); 8879 if (!Tag->hasNameForLinkage() && !Tag->hasDeclaratorForAnonDecl()) 8880 Tag->setDeclaratorForAnonDecl(FirstDeclaratorInGroup); 8881 } 8882 } 8883 8884 return BuildDeclaratorGroup(Decls, DS.containsPlaceholderType()); 8885} 8886 8887/// BuildDeclaratorGroup - convert a list of declarations into a declaration 8888/// group, performing any necessary semantic checking. 8889Sema::DeclGroupPtrTy 8890Sema::BuildDeclaratorGroup(llvm::MutableArrayRef<Decl *> Group, 8891 bool TypeMayContainAuto) { 8892 // C++0x [dcl.spec.auto]p7: 8893 // If the type deduced for the template parameter U is not the same in each 8894 // deduction, the program is ill-formed. 8895 // FIXME: When initializer-list support is added, a distinction is needed 8896 // between the deduced type U and the deduced type which 'auto' stands for. 8897 // auto a = 0, b = { 1, 2, 3 }; 8898 // is legal because the deduced type U is 'int' in both cases. 8899 if (TypeMayContainAuto && Group.size() > 1) { 8900 QualType Deduced; 8901 CanQualType DeducedCanon; 8902 VarDecl *DeducedDecl = 0; 8903 for (unsigned i = 0, e = Group.size(); i != e; ++i) { 8904 if (VarDecl *D = dyn_cast<VarDecl>(Group[i])) { 8905 AutoType *AT = D->getType()->getContainedAutoType(); 8906 // Don't reissue diagnostics when instantiating a template. 8907 if (AT && D->isInvalidDecl()) 8908 break; 8909 QualType U = AT ? AT->getDeducedType() : QualType(); 8910 if (!U.isNull()) { 8911 CanQualType UCanon = Context.getCanonicalType(U); 8912 if (Deduced.isNull()) { 8913 Deduced = U; 8914 DeducedCanon = UCanon; 8915 DeducedDecl = D; 8916 } else if (DeducedCanon != UCanon) { 8917 Diag(D->getTypeSourceInfo()->getTypeLoc().getBeginLoc(), 8918 diag::err_auto_different_deductions) 8919 << (AT->isDecltypeAuto() ? 1 : 0) 8920 << Deduced << DeducedDecl->getDeclName() 8921 << U << D->getDeclName() 8922 << DeducedDecl->getInit()->getSourceRange() 8923 << D->getInit()->getSourceRange(); 8924 D->setInvalidDecl(); 8925 break; 8926 } 8927 } 8928 } 8929 } 8930 } 8931 8932 ActOnDocumentableDecls(Group); 8933 8934 return DeclGroupPtrTy::make( 8935 DeclGroupRef::Create(Context, Group.data(), Group.size())); 8936} 8937 8938void Sema::ActOnDocumentableDecl(Decl *D) { 8939 ActOnDocumentableDecls(D); 8940} 8941 8942void Sema::ActOnDocumentableDecls(ArrayRef<Decl *> Group) { 8943 // Don't parse the comment if Doxygen diagnostics are ignored. 8944 if (Group.empty() || !Group[0]) 8945 return; 8946 8947 if (Diags.getDiagnosticLevel(diag::warn_doc_param_not_found, 8948 Group[0]->getLocation()) 8949 == DiagnosticsEngine::Ignored) 8950 return; 8951 8952 if (Group.size() >= 2) { 8953 // This is a decl group. Normally it will contain only declarations 8954 // produced from declarator list. But in case we have any definitions or 8955 // additional declaration references: 8956 // 'typedef struct S {} S;' 8957 // 'typedef struct S *S;' 8958 // 'struct S *pS;' 8959 // FinalizeDeclaratorGroup adds these as separate declarations. 8960 Decl *MaybeTagDecl = Group[0]; 8961 if (MaybeTagDecl && isa<TagDecl>(MaybeTagDecl)) { 8962 Group = Group.slice(1); 8963 } 8964 } 8965 8966 // See if there are any new comments that are not attached to a decl. 8967 ArrayRef<RawComment *> Comments = Context.getRawCommentList().getComments(); 8968 if (!Comments.empty() && 8969 !Comments.back()->isAttached()) { 8970 // There is at least one comment that not attached to a decl. 8971 // Maybe it should be attached to one of these decls? 8972 // 8973 // Note that this way we pick up not only comments that precede the 8974 // declaration, but also comments that *follow* the declaration -- thanks to 8975 // the lookahead in the lexer: we've consumed the semicolon and looked 8976 // ahead through comments. 8977 for (unsigned i = 0, e = Group.size(); i != e; ++i) 8978 Context.getCommentForDecl(Group[i], &PP); 8979 } 8980} 8981 8982/// ActOnParamDeclarator - Called from Parser::ParseFunctionDeclarator() 8983/// to introduce parameters into function prototype scope. 8984Decl *Sema::ActOnParamDeclarator(Scope *S, Declarator &D) { 8985 const DeclSpec &DS = D.getDeclSpec(); 8986 8987 // Verify C99 6.7.5.3p2: The only SCS allowed is 'register'. 8988 8989 // C++03 [dcl.stc]p2 also permits 'auto'. 8990 VarDecl::StorageClass StorageClass = SC_None; 8991 if (DS.getStorageClassSpec() == DeclSpec::SCS_register) { 8992 StorageClass = SC_Register; 8993 } else if (getLangOpts().CPlusPlus && 8994 DS.getStorageClassSpec() == DeclSpec::SCS_auto) { 8995 StorageClass = SC_Auto; 8996 } else if (DS.getStorageClassSpec() != DeclSpec::SCS_unspecified) { 8997 Diag(DS.getStorageClassSpecLoc(), 8998 diag::err_invalid_storage_class_in_func_decl); 8999 D.getMutableDeclSpec().ClearStorageClassSpecs(); 9000 } 9001 9002 if (DeclSpec::TSCS TSCS = DS.getThreadStorageClassSpec()) 9003 Diag(DS.getThreadStorageClassSpecLoc(), diag::err_invalid_thread) 9004 << DeclSpec::getSpecifierName(TSCS); 9005 if (DS.isConstexprSpecified()) 9006 Diag(DS.getConstexprSpecLoc(), diag::err_invalid_constexpr) 9007 << 0; 9008 9009 DiagnoseFunctionSpecifiers(DS); 9010 9011 TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S); 9012 QualType parmDeclType = TInfo->getType(); 9013 9014 if (getLangOpts().CPlusPlus) { 9015 // Check that there are no default arguments inside the type of this 9016 // parameter. 9017 CheckExtraCXXDefaultArguments(D); 9018 9019 // Parameter declarators cannot be qualified (C++ [dcl.meaning]p1). 9020 if (D.getCXXScopeSpec().isSet()) { 9021 Diag(D.getIdentifierLoc(), diag::err_qualified_param_declarator) 9022 << D.getCXXScopeSpec().getRange(); 9023 D.getCXXScopeSpec().clear(); 9024 } 9025 } 9026 9027 // Ensure we have a valid name 9028 IdentifierInfo *II = 0; 9029 if (D.hasName()) { 9030 II = D.getIdentifier(); 9031 if (!II) { 9032 Diag(D.getIdentifierLoc(), diag::err_bad_parameter_name) 9033 << GetNameForDeclarator(D).getName().getAsString(); 9034 D.setInvalidType(true); 9035 } 9036 } 9037 9038 // Check for redeclaration of parameters, e.g. int foo(int x, int x); 9039 if (II) { 9040 LookupResult R(*this, II, D.getIdentifierLoc(), LookupOrdinaryName, 9041 ForRedeclaration); 9042 LookupName(R, S); 9043 if (R.isSingleResult()) { 9044 NamedDecl *PrevDecl = R.getFoundDecl(); 9045 if (PrevDecl->isTemplateParameter()) { 9046 // Maybe we will complain about the shadowed template parameter. 9047 DiagnoseTemplateParameterShadow(D.getIdentifierLoc(), PrevDecl); 9048 // Just pretend that we didn't see the previous declaration. 9049 PrevDecl = 0; 9050 } else if (S->isDeclScope(PrevDecl)) { 9051 Diag(D.getIdentifierLoc(), diag::err_param_redefinition) << II; 9052 Diag(PrevDecl->getLocation(), diag::note_previous_declaration); 9053 9054 // Recover by removing the name 9055 II = 0; 9056 D.SetIdentifier(0, D.getIdentifierLoc()); 9057 D.setInvalidType(true); 9058 } 9059 } 9060 } 9061 9062 // Temporarily put parameter variables in the translation unit, not 9063 // the enclosing context. This prevents them from accidentally 9064 // looking like class members in C++. 9065 ParmVarDecl *New = CheckParameter(Context.getTranslationUnitDecl(), 9066 D.getLocStart(), 9067 D.getIdentifierLoc(), II, 9068 parmDeclType, TInfo, 9069 StorageClass); 9070 9071 if (D.isInvalidType()) 9072 New->setInvalidDecl(); 9073 9074 assert(S->isFunctionPrototypeScope()); 9075 assert(S->getFunctionPrototypeDepth() >= 1); 9076 New->setScopeInfo(S->getFunctionPrototypeDepth() - 1, 9077 S->getNextFunctionPrototypeIndex()); 9078 9079 // Add the parameter declaration into this scope. 9080 S->AddDecl(New); 9081 if (II) 9082 IdResolver.AddDecl(New); 9083 9084 ProcessDeclAttributes(S, New, D); 9085 9086 if (D.getDeclSpec().isModulePrivateSpecified()) 9087 Diag(New->getLocation(), diag::err_module_private_local) 9088 << 1 << New->getDeclName() 9089 << SourceRange(D.getDeclSpec().getModulePrivateSpecLoc()) 9090 << FixItHint::CreateRemoval(D.getDeclSpec().getModulePrivateSpecLoc()); 9091 9092 if (New->hasAttr<BlocksAttr>()) { 9093 Diag(New->getLocation(), diag::err_block_on_nonlocal); 9094 } 9095 return New; 9096} 9097 9098/// \brief Synthesizes a variable for a parameter arising from a 9099/// typedef. 9100ParmVarDecl *Sema::BuildParmVarDeclForTypedef(DeclContext *DC, 9101 SourceLocation Loc, 9102 QualType T) { 9103 /* FIXME: setting StartLoc == Loc. 9104 Would it be worth to modify callers so as to provide proper source 9105 location for the unnamed parameters, embedding the parameter's type? */ 9106 ParmVarDecl *Param = ParmVarDecl::Create(Context, DC, Loc, Loc, 0, 9107 T, Context.getTrivialTypeSourceInfo(T, Loc), 9108 SC_None, 0); 9109 Param->setImplicit(); 9110 return Param; 9111} 9112 9113void Sema::DiagnoseUnusedParameters(ParmVarDecl * const *Param, 9114 ParmVarDecl * const *ParamEnd) { 9115 // Don't diagnose unused-parameter errors in template instantiations; we 9116 // will already have done so in the template itself. 9117 if (!ActiveTemplateInstantiations.empty()) 9118 return; 9119 9120 for (; Param != ParamEnd; ++Param) { 9121 if (!(*Param)->isReferenced() && (*Param)->getDeclName() && 9122 !(*Param)->hasAttr<UnusedAttr>()) { 9123 Diag((*Param)->getLocation(), diag::warn_unused_parameter) 9124 << (*Param)->getDeclName(); 9125 } 9126 } 9127} 9128 9129void Sema::DiagnoseSizeOfParametersAndReturnValue(ParmVarDecl * const *Param, 9130 ParmVarDecl * const *ParamEnd, 9131 QualType ReturnTy, 9132 NamedDecl *D) { 9133 if (LangOpts.NumLargeByValueCopy == 0) // No check. 9134 return; 9135 9136 // Warn if the return value is pass-by-value and larger than the specified 9137 // threshold. 9138 if (!ReturnTy->isDependentType() && ReturnTy.isPODType(Context)) { 9139 unsigned Size = Context.getTypeSizeInChars(ReturnTy).getQuantity(); 9140 if (Size > LangOpts.NumLargeByValueCopy) 9141 Diag(D->getLocation(), diag::warn_return_value_size) 9142 << D->getDeclName() << Size; 9143 } 9144 9145 // Warn if any parameter is pass-by-value and larger than the specified 9146 // threshold. 9147 for (; Param != ParamEnd; ++Param) { 9148 QualType T = (*Param)->getType(); 9149 if (T->isDependentType() || !T.isPODType(Context)) 9150 continue; 9151 unsigned Size = Context.getTypeSizeInChars(T).getQuantity(); 9152 if (Size > LangOpts.NumLargeByValueCopy) 9153 Diag((*Param)->getLocation(), diag::warn_parameter_size) 9154 << (*Param)->getDeclName() << Size; 9155 } 9156} 9157 9158ParmVarDecl *Sema::CheckParameter(DeclContext *DC, SourceLocation StartLoc, 9159 SourceLocation NameLoc, IdentifierInfo *Name, 9160 QualType T, TypeSourceInfo *TSInfo, 9161 VarDecl::StorageClass StorageClass) { 9162 // In ARC, infer a lifetime qualifier for appropriate parameter types. 9163 if (getLangOpts().ObjCAutoRefCount && 9164 T.getObjCLifetime() == Qualifiers::OCL_None && 9165 T->isObjCLifetimeType()) { 9166 9167 Qualifiers::ObjCLifetime lifetime; 9168 9169 // Special cases for arrays: 9170 // - if it's const, use __unsafe_unretained 9171 // - otherwise, it's an error 9172 if (T->isArrayType()) { 9173 if (!T.isConstQualified()) { 9174 DelayedDiagnostics.add( 9175 sema::DelayedDiagnostic::makeForbiddenType( 9176 NameLoc, diag::err_arc_array_param_no_ownership, T, false)); 9177 } 9178 lifetime = Qualifiers::OCL_ExplicitNone; 9179 } else { 9180 lifetime = T->getObjCARCImplicitLifetime(); 9181 } 9182 T = Context.getLifetimeQualifiedType(T, lifetime); 9183 } 9184 9185 ParmVarDecl *New = ParmVarDecl::Create(Context, DC, StartLoc, NameLoc, Name, 9186 Context.getAdjustedParameterType(T), 9187 TSInfo, 9188 StorageClass, 0); 9189 9190 // Parameters can not be abstract class types. 9191 // For record types, this is done by the AbstractClassUsageDiagnoser once 9192 // the class has been completely parsed. 9193 if (!CurContext->isRecord() && 9194 RequireNonAbstractType(NameLoc, T, diag::err_abstract_type_in_decl, 9195 AbstractParamType)) 9196 New->setInvalidDecl(); 9197 9198 // Parameter declarators cannot be interface types. All ObjC objects are 9199 // passed by reference. 9200 if (T->isObjCObjectType()) { 9201 SourceLocation TypeEndLoc = TSInfo->getTypeLoc().getLocEnd(); 9202 Diag(NameLoc, 9203 diag::err_object_cannot_be_passed_returned_by_value) << 1 << T 9204 << FixItHint::CreateInsertion(TypeEndLoc, "*"); 9205 T = Context.getObjCObjectPointerType(T); 9206 New->setType(T); 9207 } 9208 9209 // ISO/IEC TR 18037 S6.7.3: "The type of an object with automatic storage 9210 // duration shall not be qualified by an address-space qualifier." 9211 // Since all parameters have automatic store duration, they can not have 9212 // an address space. 9213 if (T.getAddressSpace() != 0) { 9214 Diag(NameLoc, diag::err_arg_with_address_space); 9215 New->setInvalidDecl(); 9216 } 9217 9218 return New; 9219} 9220 9221void Sema::ActOnFinishKNRParamDeclarations(Scope *S, Declarator &D, 9222 SourceLocation LocAfterDecls) { 9223 DeclaratorChunk::FunctionTypeInfo &FTI = D.getFunctionTypeInfo(); 9224 9225 // Verify 6.9.1p6: 'every identifier in the identifier list shall be declared' 9226 // for a K&R function. 9227 if (!FTI.hasPrototype) { 9228 for (int i = FTI.NumArgs; i != 0; /* decrement in loop */) { 9229 --i; 9230 if (FTI.ArgInfo[i].Param == 0) { 9231 SmallString<256> Code; 9232 llvm::raw_svector_ostream(Code) << " int " 9233 << FTI.ArgInfo[i].Ident->getName() 9234 << ";\n"; 9235 Diag(FTI.ArgInfo[i].IdentLoc, diag::ext_param_not_declared) 9236 << FTI.ArgInfo[i].Ident 9237 << FixItHint::CreateInsertion(LocAfterDecls, Code.str()); 9238 9239 // Implicitly declare the argument as type 'int' for lack of a better 9240 // type. 9241 AttributeFactory attrs; 9242 DeclSpec DS(attrs); 9243 const char* PrevSpec; // unused 9244 unsigned DiagID; // unused 9245 DS.SetTypeSpecType(DeclSpec::TST_int, FTI.ArgInfo[i].IdentLoc, 9246 PrevSpec, DiagID); 9247 // Use the identifier location for the type source range. 9248 DS.SetRangeStart(FTI.ArgInfo[i].IdentLoc); 9249 DS.SetRangeEnd(FTI.ArgInfo[i].IdentLoc); 9250 Declarator ParamD(DS, Declarator::KNRTypeListContext); 9251 ParamD.SetIdentifier(FTI.ArgInfo[i].Ident, FTI.ArgInfo[i].IdentLoc); 9252 FTI.ArgInfo[i].Param = ActOnParamDeclarator(S, ParamD); 9253 } 9254 } 9255 } 9256} 9257 9258Decl *Sema::ActOnStartOfFunctionDef(Scope *FnBodyScope, Declarator &D) { 9259 assert(getCurFunctionDecl() == 0 && "Function parsing confused"); 9260 assert(D.isFunctionDeclarator() && "Not a function declarator!"); 9261 Scope *ParentScope = FnBodyScope->getParent(); 9262 9263 D.setFunctionDefinitionKind(FDK_Definition); 9264 Decl *DP = HandleDeclarator(ParentScope, D, MultiTemplateParamsArg()); 9265 return ActOnStartOfFunctionDef(FnBodyScope, DP); 9266} 9267 9268static bool ShouldWarnAboutMissingPrototype(const FunctionDecl *FD, 9269 const FunctionDecl*& PossibleZeroParamPrototype) { 9270 // Don't warn about invalid declarations. 9271 if (FD->isInvalidDecl()) 9272 return false; 9273 9274 // Or declarations that aren't global. 9275 if (!FD->isGlobal()) 9276 return false; 9277 9278 // Don't warn about C++ member functions. 9279 if (isa<CXXMethodDecl>(FD)) 9280 return false; 9281 9282 // Don't warn about 'main'. 9283 if (FD->isMain()) 9284 return false; 9285 9286 // Don't warn about inline functions. 9287 if (FD->isInlined()) 9288 return false; 9289 9290 // Don't warn about function templates. 9291 if (FD->getDescribedFunctionTemplate()) 9292 return false; 9293 9294 // Don't warn about function template specializations. 9295 if (FD->isFunctionTemplateSpecialization()) 9296 return false; 9297 9298 // Don't warn for OpenCL kernels. 9299 if (FD->hasAttr<OpenCLKernelAttr>()) 9300 return false; 9301 9302 bool MissingPrototype = true; 9303 for (const FunctionDecl *Prev = FD->getPreviousDecl(); 9304 Prev; Prev = Prev->getPreviousDecl()) { 9305 // Ignore any declarations that occur in function or method 9306 // scope, because they aren't visible from the header. 9307 if (Prev->getLexicalDeclContext()->isFunctionOrMethod()) 9308 continue; 9309 9310 MissingPrototype = !Prev->getType()->isFunctionProtoType(); 9311 if (FD->getNumParams() == 0) 9312 PossibleZeroParamPrototype = Prev; 9313 break; 9314 } 9315 9316 return MissingPrototype; 9317} 9318 9319void Sema::CheckForFunctionRedefinition(FunctionDecl *FD) { 9320 // Don't complain if we're in GNU89 mode and the previous definition 9321 // was an extern inline function. 9322 const FunctionDecl *Definition; 9323 if (FD->isDefined(Definition) && 9324 !canRedefineFunction(Definition, getLangOpts())) { 9325 if (getLangOpts().GNUMode && Definition->isInlineSpecified() && 9326 Definition->getStorageClass() == SC_Extern) 9327 Diag(FD->getLocation(), diag::err_redefinition_extern_inline) 9328 << FD->getDeclName() << getLangOpts().CPlusPlus; 9329 else 9330 Diag(FD->getLocation(), diag::err_redefinition) << FD->getDeclName(); 9331 Diag(Definition->getLocation(), diag::note_previous_definition); 9332 FD->setInvalidDecl(); 9333 } 9334} 9335 9336Decl *Sema::ActOnStartOfFunctionDef(Scope *FnBodyScope, Decl *D) { 9337 // Clear the last template instantiation error context. 9338 LastTemplateInstantiationErrorContext = ActiveTemplateInstantiation(); 9339 9340 if (!D) 9341 return D; 9342 FunctionDecl *FD = 0; 9343 9344 if (FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(D)) 9345 FD = FunTmpl->getTemplatedDecl(); 9346 else 9347 FD = cast<FunctionDecl>(D); 9348 // If we are instantiating a generic lambda call operator, push 9349 // a LambdaScopeInfo onto the function stack. But use the information 9350 // that's already been calculated (ActOnLambdaExpr) when analyzing the 9351 // template version, to prime the current LambdaScopeInfo. 9352 if (isGenericLambdaCallOperatorSpecialization(D)) { 9353 CXXMethodDecl *CallOperator = cast<CXXMethodDecl>(D); 9354 CXXRecordDecl *LambdaClass = CallOperator->getParent(); 9355 LambdaExpr *LE = LambdaClass->getLambdaExpr(); 9356 assert(LE && 9357 "No LambdaExpr of closure class when instantiating a generic lambda!"); 9358 assert(ActiveTemplateInstantiations.size() && 9359 "There should be an active template instantiation on the stack " 9360 "when instantiating a generic lambda!"); 9361 PushLambdaScope(); 9362 LambdaScopeInfo *LSI = getCurLambda(); 9363 LSI->CallOperator = CallOperator; 9364 LSI->Lambda = LambdaClass; 9365 LSI->ReturnType = CallOperator->getResultType(); 9366 9367 if (LE->getCaptureDefault() == LCD_None) 9368 LSI->ImpCaptureStyle = CapturingScopeInfo::ImpCap_None; 9369 else if (LE->getCaptureDefault() == LCD_ByCopy) 9370 LSI->ImpCaptureStyle = CapturingScopeInfo::ImpCap_LambdaByval; 9371 else if (LE->getCaptureDefault() == LCD_ByRef) 9372 LSI->ImpCaptureStyle = CapturingScopeInfo::ImpCap_LambdaByref; 9373 9374 LSI->IntroducerRange = LE->getIntroducerRange(); 9375 } 9376 else 9377 // Enter a new function scope 9378 PushFunctionScope(); 9379 9380 // See if this is a redefinition. 9381 if (!FD->isLateTemplateParsed()) 9382 CheckForFunctionRedefinition(FD); 9383 9384 // Builtin functions cannot be defined. 9385 if (unsigned BuiltinID = FD->getBuiltinID()) { 9386 if (!Context.BuiltinInfo.isPredefinedLibFunction(BuiltinID) && 9387 !Context.BuiltinInfo.isPredefinedRuntimeFunction(BuiltinID)) { 9388 Diag(FD->getLocation(), diag::err_builtin_definition) << FD; 9389 FD->setInvalidDecl(); 9390 } 9391 } 9392 9393 // The return type of a function definition must be complete 9394 // (C99 6.9.1p3, C++ [dcl.fct]p6). 9395 QualType ResultType = FD->getResultType(); 9396 if (!ResultType->isDependentType() && !ResultType->isVoidType() && 9397 !FD->isInvalidDecl() && 9398 RequireCompleteType(FD->getLocation(), ResultType, 9399 diag::err_func_def_incomplete_result)) 9400 FD->setInvalidDecl(); 9401 9402 // GNU warning -Wmissing-prototypes: 9403 // Warn if a global function is defined without a previous 9404 // prototype declaration. This warning is issued even if the 9405 // definition itself provides a prototype. The aim is to detect 9406 // global functions that fail to be declared in header files. 9407 const FunctionDecl *PossibleZeroParamPrototype = 0; 9408 if (ShouldWarnAboutMissingPrototype(FD, PossibleZeroParamPrototype)) { 9409 Diag(FD->getLocation(), diag::warn_missing_prototype) << FD; 9410 9411 if (PossibleZeroParamPrototype) { 9412 // We found a declaration that is not a prototype, 9413 // but that could be a zero-parameter prototype 9414 if (TypeSourceInfo *TI = 9415 PossibleZeroParamPrototype->getTypeSourceInfo()) { 9416 TypeLoc TL = TI->getTypeLoc(); 9417 if (FunctionNoProtoTypeLoc FTL = TL.getAs<FunctionNoProtoTypeLoc>()) 9418 Diag(PossibleZeroParamPrototype->getLocation(), 9419 diag::note_declaration_not_a_prototype) 9420 << PossibleZeroParamPrototype 9421 << FixItHint::CreateInsertion(FTL.getRParenLoc(), "void"); 9422 } 9423 } 9424 } 9425 9426 if (FnBodyScope) 9427 PushDeclContext(FnBodyScope, FD); 9428 9429 // Check the validity of our function parameters 9430 CheckParmsForFunctionDef(FD->param_begin(), FD->param_end(), 9431 /*CheckParameterNames=*/true); 9432 9433 // Introduce our parameters into the function scope 9434 for (unsigned p = 0, NumParams = FD->getNumParams(); p < NumParams; ++p) { 9435 ParmVarDecl *Param = FD->getParamDecl(p); 9436 Param->setOwningFunction(FD); 9437 9438 // If this has an identifier, add it to the scope stack. 9439 if (Param->getIdentifier() && FnBodyScope) { 9440 CheckShadow(FnBodyScope, Param); 9441 9442 PushOnScopeChains(Param, FnBodyScope); 9443 } 9444 } 9445 9446 // If we had any tags defined in the function prototype, 9447 // introduce them into the function scope. 9448 if (FnBodyScope) { 9449 for (ArrayRef<NamedDecl *>::iterator 9450 I = FD->getDeclsInPrototypeScope().begin(), 9451 E = FD->getDeclsInPrototypeScope().end(); 9452 I != E; ++I) { 9453 NamedDecl *D = *I; 9454 9455 // Some of these decls (like enums) may have been pinned to the translation unit 9456 // for lack of a real context earlier. If so, remove from the translation unit 9457 // and reattach to the current context. 9458 if (D->getLexicalDeclContext() == Context.getTranslationUnitDecl()) { 9459 // Is the decl actually in the context? 9460 for (DeclContext::decl_iterator DI = Context.getTranslationUnitDecl()->decls_begin(), 9461 DE = Context.getTranslationUnitDecl()->decls_end(); DI != DE; ++DI) { 9462 if (*DI == D) { 9463 Context.getTranslationUnitDecl()->removeDecl(D); 9464 break; 9465 } 9466 } 9467 // Either way, reassign the lexical decl context to our FunctionDecl. 9468 D->setLexicalDeclContext(CurContext); 9469 } 9470 9471 // If the decl has a non-null name, make accessible in the current scope. 9472 if (!D->getName().empty()) 9473 PushOnScopeChains(D, FnBodyScope, /*AddToContext=*/false); 9474 9475 // Similarly, dive into enums and fish their constants out, making them 9476 // accessible in this scope. 9477 if (EnumDecl *ED = dyn_cast<EnumDecl>(D)) { 9478 for (EnumDecl::enumerator_iterator EI = ED->enumerator_begin(), 9479 EE = ED->enumerator_end(); EI != EE; ++EI) 9480 PushOnScopeChains(*EI, FnBodyScope, /*AddToContext=*/false); 9481 } 9482 } 9483 } 9484 9485 // Ensure that the function's exception specification is instantiated. 9486 if (const FunctionProtoType *FPT = FD->getType()->getAs<FunctionProtoType>()) 9487 ResolveExceptionSpec(D->getLocation(), FPT); 9488 9489 // Checking attributes of current function definition 9490 // dllimport attribute. 9491 DLLImportAttr *DA = FD->getAttr<DLLImportAttr>(); 9492 if (DA && (!FD->getAttr<DLLExportAttr>())) { 9493 // dllimport attribute cannot be directly applied to definition. 9494 // Microsoft accepts dllimport for functions defined within class scope. 9495 if (!DA->isInherited() && 9496 !(LangOpts.MicrosoftExt && FD->getLexicalDeclContext()->isRecord())) { 9497 Diag(FD->getLocation(), 9498 diag::err_attribute_can_be_applied_only_to_symbol_declaration) 9499 << "dllimport"; 9500 FD->setInvalidDecl(); 9501 return D; 9502 } 9503 9504 // Visual C++ appears to not think this is an issue, so only issue 9505 // a warning when Microsoft extensions are disabled. 9506 if (!LangOpts.MicrosoftExt) { 9507 // If a symbol previously declared dllimport is later defined, the 9508 // attribute is ignored in subsequent references, and a warning is 9509 // emitted. 9510 Diag(FD->getLocation(), 9511 diag::warn_redeclaration_without_attribute_prev_attribute_ignored) 9512 << FD->getName() << "dllimport"; 9513 } 9514 } 9515 // We want to attach documentation to original Decl (which might be 9516 // a function template). 9517 ActOnDocumentableDecl(D); 9518 return D; 9519} 9520 9521/// \brief Given the set of return statements within a function body, 9522/// compute the variables that are subject to the named return value 9523/// optimization. 9524/// 9525/// Each of the variables that is subject to the named return value 9526/// optimization will be marked as NRVO variables in the AST, and any 9527/// return statement that has a marked NRVO variable as its NRVO candidate can 9528/// use the named return value optimization. 9529/// 9530/// This function applies a very simplistic algorithm for NRVO: if every return 9531/// statement in the function has the same NRVO candidate, that candidate is 9532/// the NRVO variable. 9533/// 9534/// FIXME: Employ a smarter algorithm that accounts for multiple return 9535/// statements and the lifetimes of the NRVO candidates. We should be able to 9536/// find a maximal set of NRVO variables. 9537void Sema::computeNRVO(Stmt *Body, FunctionScopeInfo *Scope) { 9538 ReturnStmt **Returns = Scope->Returns.data(); 9539 9540 const VarDecl *NRVOCandidate = 0; 9541 for (unsigned I = 0, E = Scope->Returns.size(); I != E; ++I) { 9542 if (!Returns[I]->getNRVOCandidate()) 9543 return; 9544 9545 if (!NRVOCandidate) 9546 NRVOCandidate = Returns[I]->getNRVOCandidate(); 9547 else if (NRVOCandidate != Returns[I]->getNRVOCandidate()) 9548 return; 9549 } 9550 9551 if (NRVOCandidate) 9552 const_cast<VarDecl*>(NRVOCandidate)->setNRVOVariable(true); 9553} 9554 9555bool Sema::canSkipFunctionBody(Decl *D) { 9556 if (!Consumer.shouldSkipFunctionBody(D)) 9557 return false; 9558 9559 if (isa<ObjCMethodDecl>(D)) 9560 return true; 9561 9562 FunctionDecl *FD = 0; 9563 if (FunctionTemplateDecl *FTD = dyn_cast<FunctionTemplateDecl>(D)) 9564 FD = FTD->getTemplatedDecl(); 9565 else 9566 FD = cast<FunctionDecl>(D); 9567 9568 // We cannot skip the body of a function (or function template) which is 9569 // constexpr, since we may need to evaluate its body in order to parse the 9570 // rest of the file. 9571 // We cannot skip the body of a function with an undeduced return type, 9572 // because any callers of that function need to know the type. 9573 return !FD->isConstexpr() && !FD->getResultType()->isUndeducedType(); 9574} 9575 9576Decl *Sema::ActOnSkippedFunctionBody(Decl *Decl) { 9577 if (FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(Decl)) 9578 FD->setHasSkippedBody(); 9579 else if (ObjCMethodDecl *MD = dyn_cast_or_null<ObjCMethodDecl>(Decl)) 9580 MD->setHasSkippedBody(); 9581 return ActOnFinishFunctionBody(Decl, 0); 9582} 9583 9584Decl *Sema::ActOnFinishFunctionBody(Decl *D, Stmt *BodyArg) { 9585 return ActOnFinishFunctionBody(D, BodyArg, false); 9586} 9587 9588Decl *Sema::ActOnFinishFunctionBody(Decl *dcl, Stmt *Body, 9589 bool IsInstantiation) { 9590 FunctionDecl *FD = 0; 9591 FunctionTemplateDecl *FunTmpl = dyn_cast_or_null<FunctionTemplateDecl>(dcl); 9592 if (FunTmpl) 9593 FD = FunTmpl->getTemplatedDecl(); 9594 else 9595 FD = dyn_cast_or_null<FunctionDecl>(dcl); 9596 9597 sema::AnalysisBasedWarnings::Policy WP = AnalysisWarnings.getDefaultPolicy(); 9598 sema::AnalysisBasedWarnings::Policy *ActivePolicy = 0; 9599 9600 if (FD) { 9601 FD->setBody(Body); 9602 9603 if (getLangOpts().CPlusPlus1y && !FD->isInvalidDecl() && Body && 9604 !FD->isDependentContext() && FD->getResultType()->isUndeducedType()) { 9605 // If the function has a deduced result type but contains no 'return' 9606 // statements, the result type as written must be exactly 'auto', and 9607 // the deduced result type is 'void'. 9608 if (!FD->getResultType()->getAs<AutoType>()) { 9609 Diag(dcl->getLocation(), diag::err_auto_fn_no_return_but_not_auto) 9610 << FD->getResultType(); 9611 FD->setInvalidDecl(); 9612 } else { 9613 // Substitute 'void' for the 'auto' in the type. 9614 TypeLoc ResultType = FD->getTypeSourceInfo()->getTypeLoc(). 9615 IgnoreParens().castAs<FunctionProtoTypeLoc>().getResultLoc(); 9616 Context.adjustDeducedFunctionResultType( 9617 FD, SubstAutoType(ResultType.getType(), Context.VoidTy)); 9618 } 9619 } 9620 9621 // The only way to be included in UndefinedButUsed is if there is an 9622 // ODR use before the definition. Avoid the expensive map lookup if this 9623 // is the first declaration. 9624 if (FD->getPreviousDecl() != 0 && FD->getPreviousDecl()->isUsed()) { 9625 if (!FD->isExternallyVisible()) 9626 UndefinedButUsed.erase(FD); 9627 else if (FD->isInlined() && 9628 (LangOpts.CPlusPlus || !LangOpts.GNUInline) && 9629 (!FD->getPreviousDecl()->hasAttr<GNUInlineAttr>())) 9630 UndefinedButUsed.erase(FD); 9631 } 9632 9633 // If the function implicitly returns zero (like 'main') or is naked, 9634 // don't complain about missing return statements. 9635 if (FD->hasImplicitReturnZero() || FD->hasAttr<NakedAttr>()) 9636 WP.disableCheckFallThrough(); 9637 9638 // MSVC permits the use of pure specifier (=0) on function definition, 9639 // defined at class scope, warn about this non standard construct. 9640 if (getLangOpts().MicrosoftExt && FD->isPure()) 9641 Diag(FD->getLocation(), diag::warn_pure_function_definition); 9642 9643 if (!FD->isInvalidDecl()) { 9644 DiagnoseUnusedParameters(FD->param_begin(), FD->param_end()); 9645 DiagnoseSizeOfParametersAndReturnValue(FD->param_begin(), FD->param_end(), 9646 FD->getResultType(), FD); 9647 9648 // If this is a constructor, we need a vtable. 9649 if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(FD)) 9650 MarkVTableUsed(FD->getLocation(), Constructor->getParent()); 9651 9652 // Try to apply the named return value optimization. We have to check 9653 // if we can do this here because lambdas keep return statements around 9654 // to deduce an implicit return type. 9655 if (getLangOpts().CPlusPlus && FD->getResultType()->isRecordType() && 9656 !FD->isDependentContext()) 9657 computeNRVO(Body, getCurFunction()); 9658 } 9659 9660 assert((FD == getCurFunctionDecl() || getCurLambda()->CallOperator == FD) && 9661 "Function parsing confused"); 9662 } else if (ObjCMethodDecl *MD = dyn_cast_or_null<ObjCMethodDecl>(dcl)) { 9663 assert(MD == getCurMethodDecl() && "Method parsing confused"); 9664 MD->setBody(Body); 9665 if (!MD->isInvalidDecl()) { 9666 DiagnoseUnusedParameters(MD->param_begin(), MD->param_end()); 9667 DiagnoseSizeOfParametersAndReturnValue(MD->param_begin(), MD->param_end(), 9668 MD->getResultType(), MD); 9669 9670 if (Body) 9671 computeNRVO(Body, getCurFunction()); 9672 } 9673 if (getCurFunction()->ObjCShouldCallSuper) { 9674 Diag(MD->getLocEnd(), diag::warn_objc_missing_super_call) 9675 << MD->getSelector().getAsString(); 9676 getCurFunction()->ObjCShouldCallSuper = false; 9677 } 9678 } else { 9679 return 0; 9680 } 9681 9682 assert(!getCurFunction()->ObjCShouldCallSuper && 9683 "This should only be set for ObjC methods, which should have been " 9684 "handled in the block above."); 9685 9686 // Verify and clean out per-function state. 9687 if (Body) { 9688 // C++ constructors that have function-try-blocks can't have return 9689 // statements in the handlers of that block. (C++ [except.handle]p14) 9690 // Verify this. 9691 if (FD && isa<CXXConstructorDecl>(FD) && isa<CXXTryStmt>(Body)) 9692 DiagnoseReturnInConstructorExceptionHandler(cast<CXXTryStmt>(Body)); 9693 9694 // Verify that gotos and switch cases don't jump into scopes illegally. 9695 if (getCurFunction()->NeedsScopeChecking() && 9696 !dcl->isInvalidDecl() && 9697 !hasAnyUnrecoverableErrorsInThisFunction() && 9698 !PP.isCodeCompletionEnabled()) 9699 DiagnoseInvalidJumps(Body); 9700 9701 if (CXXDestructorDecl *Destructor = dyn_cast<CXXDestructorDecl>(dcl)) { 9702 if (!Destructor->getParent()->isDependentType()) 9703 CheckDestructor(Destructor); 9704 9705 MarkBaseAndMemberDestructorsReferenced(Destructor->getLocation(), 9706 Destructor->getParent()); 9707 } 9708 9709 // If any errors have occurred, clear out any temporaries that may have 9710 // been leftover. This ensures that these temporaries won't be picked up for 9711 // deletion in some later function. 9712 if (PP.getDiagnostics().hasErrorOccurred() || 9713 PP.getDiagnostics().getSuppressAllDiagnostics()) { 9714 DiscardCleanupsInEvaluationContext(); 9715 } 9716 if (!PP.getDiagnostics().hasUncompilableErrorOccurred() && 9717 !isa<FunctionTemplateDecl>(dcl)) { 9718 // Since the body is valid, issue any analysis-based warnings that are 9719 // enabled. 9720 ActivePolicy = &WP; 9721 } 9722 9723 if (!IsInstantiation && FD && FD->isConstexpr() && !FD->isInvalidDecl() && 9724 (!CheckConstexprFunctionDecl(FD) || 9725 !CheckConstexprFunctionBody(FD, Body))) 9726 FD->setInvalidDecl(); 9727 9728 assert(ExprCleanupObjects.empty() && "Leftover temporaries in function"); 9729 assert(!ExprNeedsCleanups && "Unaccounted cleanups in function"); 9730 assert(MaybeODRUseExprs.empty() && 9731 "Leftover expressions for odr-use checking"); 9732 } 9733 9734 if (!IsInstantiation) 9735 PopDeclContext(); 9736 9737 PopFunctionScopeInfo(ActivePolicy, dcl); 9738 9739 // If any errors have occurred, clear out any temporaries that may have 9740 // been leftover. This ensures that these temporaries won't be picked up for 9741 // deletion in some later function. 9742 if (getDiagnostics().hasErrorOccurred()) { 9743 DiscardCleanupsInEvaluationContext(); 9744 } 9745 9746 return dcl; 9747} 9748 9749 9750/// When we finish delayed parsing of an attribute, we must attach it to the 9751/// relevant Decl. 9752void Sema::ActOnFinishDelayedAttribute(Scope *S, Decl *D, 9753 ParsedAttributes &Attrs) { 9754 // Always attach attributes to the underlying decl. 9755 if (TemplateDecl *TD = dyn_cast<TemplateDecl>(D)) 9756 D = TD->getTemplatedDecl(); 9757 ProcessDeclAttributeList(S, D, Attrs.getList()); 9758 9759 if (CXXMethodDecl *Method = dyn_cast_or_null<CXXMethodDecl>(D)) 9760 if (Method->isStatic()) 9761 checkThisInStaticMemberFunctionAttributes(Method); 9762} 9763 9764 9765/// ImplicitlyDefineFunction - An undeclared identifier was used in a function 9766/// call, forming a call to an implicitly defined function (per C99 6.5.1p2). 9767NamedDecl *Sema::ImplicitlyDefineFunction(SourceLocation Loc, 9768 IdentifierInfo &II, Scope *S) { 9769 // Before we produce a declaration for an implicitly defined 9770 // function, see whether there was a locally-scoped declaration of 9771 // this name as a function or variable. If so, use that 9772 // (non-visible) declaration, and complain about it. 9773 if (NamedDecl *ExternCPrev = findLocallyScopedExternCDecl(&II)) { 9774 Diag(Loc, diag::warn_use_out_of_scope_declaration) << ExternCPrev; 9775 Diag(ExternCPrev->getLocation(), diag::note_previous_declaration); 9776 return ExternCPrev; 9777 } 9778 9779 // Extension in C99. Legal in C90, but warn about it. 9780 unsigned diag_id; 9781 if (II.getName().startswith("__builtin_")) 9782 diag_id = diag::warn_builtin_unknown; 9783 else if (getLangOpts().C99) 9784 diag_id = diag::ext_implicit_function_decl; 9785 else 9786 diag_id = diag::warn_implicit_function_decl; 9787 Diag(Loc, diag_id) << &II; 9788 9789 // Because typo correction is expensive, only do it if the implicit 9790 // function declaration is going to be treated as an error. 9791 if (Diags.getDiagnosticLevel(diag_id, Loc) >= DiagnosticsEngine::Error) { 9792 TypoCorrection Corrected; 9793 DeclFilterCCC<FunctionDecl> Validator; 9794 if (S && (Corrected = CorrectTypo(DeclarationNameInfo(&II, Loc), 9795 LookupOrdinaryName, S, 0, Validator))) 9796 diagnoseTypo(Corrected, PDiag(diag::note_function_suggestion), 9797 /*ErrorRecovery*/false); 9798 } 9799 9800 // Set a Declarator for the implicit definition: int foo(); 9801 const char *Dummy; 9802 AttributeFactory attrFactory; 9803 DeclSpec DS(attrFactory); 9804 unsigned DiagID; 9805 bool Error = DS.SetTypeSpecType(DeclSpec::TST_int, Loc, Dummy, DiagID); 9806 (void)Error; // Silence warning. 9807 assert(!Error && "Error setting up implicit decl!"); 9808 SourceLocation NoLoc; 9809 Declarator D(DS, Declarator::BlockContext); 9810 D.AddTypeInfo(DeclaratorChunk::getFunction(/*HasProto=*/false, 9811 /*IsAmbiguous=*/false, 9812 /*RParenLoc=*/NoLoc, 9813 /*ArgInfo=*/0, 9814 /*NumArgs=*/0, 9815 /*EllipsisLoc=*/NoLoc, 9816 /*RParenLoc=*/NoLoc, 9817 /*TypeQuals=*/0, 9818 /*RefQualifierIsLvalueRef=*/true, 9819 /*RefQualifierLoc=*/NoLoc, 9820 /*ConstQualifierLoc=*/NoLoc, 9821 /*VolatileQualifierLoc=*/NoLoc, 9822 /*MutableLoc=*/NoLoc, 9823 EST_None, 9824 /*ESpecLoc=*/NoLoc, 9825 /*Exceptions=*/0, 9826 /*ExceptionRanges=*/0, 9827 /*NumExceptions=*/0, 9828 /*NoexceptExpr=*/0, 9829 Loc, Loc, D), 9830 DS.getAttributes(), 9831 SourceLocation()); 9832 D.SetIdentifier(&II, Loc); 9833 9834 // Insert this function into translation-unit scope. 9835 9836 DeclContext *PrevDC = CurContext; 9837 CurContext = Context.getTranslationUnitDecl(); 9838 9839 FunctionDecl *FD = cast<FunctionDecl>(ActOnDeclarator(TUScope, D)); 9840 FD->setImplicit(); 9841 9842 CurContext = PrevDC; 9843 9844 AddKnownFunctionAttributes(FD); 9845 9846 return FD; 9847} 9848 9849/// \brief Adds any function attributes that we know a priori based on 9850/// the declaration of this function. 9851/// 9852/// These attributes can apply both to implicitly-declared builtins 9853/// (like __builtin___printf_chk) or to library-declared functions 9854/// like NSLog or printf. 9855/// 9856/// We need to check for duplicate attributes both here and where user-written 9857/// attributes are applied to declarations. 9858void Sema::AddKnownFunctionAttributes(FunctionDecl *FD) { 9859 if (FD->isInvalidDecl()) 9860 return; 9861 9862 // If this is a built-in function, map its builtin attributes to 9863 // actual attributes. 9864 if (unsigned BuiltinID = FD->getBuiltinID()) { 9865 // Handle printf-formatting attributes. 9866 unsigned FormatIdx; 9867 bool HasVAListArg; 9868 if (Context.BuiltinInfo.isPrintfLike(BuiltinID, FormatIdx, HasVAListArg)) { 9869 if (!FD->getAttr<FormatAttr>()) { 9870 const char *fmt = "printf"; 9871 unsigned int NumParams = FD->getNumParams(); 9872 if (FormatIdx < NumParams && // NumParams may be 0 (e.g. vfprintf) 9873 FD->getParamDecl(FormatIdx)->getType()->isObjCObjectPointerType()) 9874 fmt = "NSString"; 9875 FD->addAttr(::new (Context) FormatAttr(FD->getLocation(), Context, 9876 &Context.Idents.get(fmt), 9877 FormatIdx+1, 9878 HasVAListArg ? 0 : FormatIdx+2)); 9879 } 9880 } 9881 if (Context.BuiltinInfo.isScanfLike(BuiltinID, FormatIdx, 9882 HasVAListArg)) { 9883 if (!FD->getAttr<FormatAttr>()) 9884 FD->addAttr(::new (Context) FormatAttr(FD->getLocation(), Context, 9885 &Context.Idents.get("scanf"), 9886 FormatIdx+1, 9887 HasVAListArg ? 0 : FormatIdx+2)); 9888 } 9889 9890 // Mark const if we don't care about errno and that is the only 9891 // thing preventing the function from being const. This allows 9892 // IRgen to use LLVM intrinsics for such functions. 9893 if (!getLangOpts().MathErrno && 9894 Context.BuiltinInfo.isConstWithoutErrno(BuiltinID)) { 9895 if (!FD->getAttr<ConstAttr>()) 9896 FD->addAttr(::new (Context) ConstAttr(FD->getLocation(), Context)); 9897 } 9898 9899 if (Context.BuiltinInfo.isReturnsTwice(BuiltinID) && 9900 !FD->getAttr<ReturnsTwiceAttr>()) 9901 FD->addAttr(::new (Context) ReturnsTwiceAttr(FD->getLocation(), Context)); 9902 if (Context.BuiltinInfo.isNoThrow(BuiltinID) && !FD->getAttr<NoThrowAttr>()) 9903 FD->addAttr(::new (Context) NoThrowAttr(FD->getLocation(), Context)); 9904 if (Context.BuiltinInfo.isConst(BuiltinID) && !FD->getAttr<ConstAttr>()) 9905 FD->addAttr(::new (Context) ConstAttr(FD->getLocation(), Context)); 9906 } 9907 9908 IdentifierInfo *Name = FD->getIdentifier(); 9909 if (!Name) 9910 return; 9911 if ((!getLangOpts().CPlusPlus && 9912 FD->getDeclContext()->isTranslationUnit()) || 9913 (isa<LinkageSpecDecl>(FD->getDeclContext()) && 9914 cast<LinkageSpecDecl>(FD->getDeclContext())->getLanguage() == 9915 LinkageSpecDecl::lang_c)) { 9916 // Okay: this could be a libc/libm/Objective-C function we know 9917 // about. 9918 } else 9919 return; 9920 9921 if (Name->isStr("asprintf") || Name->isStr("vasprintf")) { 9922 // FIXME: asprintf and vasprintf aren't C99 functions. Should they be 9923 // target-specific builtins, perhaps? 9924 if (!FD->getAttr<FormatAttr>()) 9925 FD->addAttr(::new (Context) FormatAttr(FD->getLocation(), Context, 9926 &Context.Idents.get("printf"), 2, 9927 Name->isStr("vasprintf") ? 0 : 3)); 9928 } 9929 9930 if (Name->isStr("__CFStringMakeConstantString")) { 9931 // We already have a __builtin___CFStringMakeConstantString, 9932 // but builds that use -fno-constant-cfstrings don't go through that. 9933 if (!FD->getAttr<FormatArgAttr>()) 9934 FD->addAttr(::new (Context) FormatArgAttr(FD->getLocation(), Context, 1)); 9935 } 9936} 9937 9938TypedefDecl *Sema::ParseTypedefDecl(Scope *S, Declarator &D, QualType T, 9939 TypeSourceInfo *TInfo) { 9940 assert(D.getIdentifier() && "Wrong callback for declspec without declarator"); 9941 assert(!T.isNull() && "GetTypeForDeclarator() returned null type"); 9942 9943 if (!TInfo) { 9944 assert(D.isInvalidType() && "no declarator info for valid type"); 9945 TInfo = Context.getTrivialTypeSourceInfo(T); 9946 } 9947 9948 // Scope manipulation handled by caller. 9949 TypedefDecl *NewTD = TypedefDecl::Create(Context, CurContext, 9950 D.getLocStart(), 9951 D.getIdentifierLoc(), 9952 D.getIdentifier(), 9953 TInfo); 9954 9955 // Bail out immediately if we have an invalid declaration. 9956 if (D.isInvalidType()) { 9957 NewTD->setInvalidDecl(); 9958 return NewTD; 9959 } 9960 9961 if (D.getDeclSpec().isModulePrivateSpecified()) { 9962 if (CurContext->isFunctionOrMethod()) 9963 Diag(NewTD->getLocation(), diag::err_module_private_local) 9964 << 2 << NewTD->getDeclName() 9965 << SourceRange(D.getDeclSpec().getModulePrivateSpecLoc()) 9966 << FixItHint::CreateRemoval(D.getDeclSpec().getModulePrivateSpecLoc()); 9967 else 9968 NewTD->setModulePrivate(); 9969 } 9970 9971 // C++ [dcl.typedef]p8: 9972 // If the typedef declaration defines an unnamed class (or 9973 // enum), the first typedef-name declared by the declaration 9974 // to be that class type (or enum type) is used to denote the 9975 // class type (or enum type) for linkage purposes only. 9976 // We need to check whether the type was declared in the declaration. 9977 switch (D.getDeclSpec().getTypeSpecType()) { 9978 case TST_enum: 9979 case TST_struct: 9980 case TST_interface: 9981 case TST_union: 9982 case TST_class: { 9983 TagDecl *tagFromDeclSpec = cast<TagDecl>(D.getDeclSpec().getRepAsDecl()); 9984 9985 // Do nothing if the tag is not anonymous or already has an 9986 // associated typedef (from an earlier typedef in this decl group). 9987 if (tagFromDeclSpec->getIdentifier()) break; 9988 if (tagFromDeclSpec->getTypedefNameForAnonDecl()) break; 9989 9990 // A well-formed anonymous tag must always be a TUK_Definition. 9991 assert(tagFromDeclSpec->isThisDeclarationADefinition()); 9992 9993 // The type must match the tag exactly; no qualifiers allowed. 9994 if (!Context.hasSameType(T, Context.getTagDeclType(tagFromDeclSpec))) 9995 break; 9996 9997 // Otherwise, set this is the anon-decl typedef for the tag. 9998 tagFromDeclSpec->setTypedefNameForAnonDecl(NewTD); 9999 break; 10000 } 10001 10002 default: 10003 break; 10004 } 10005 10006 return NewTD; 10007} 10008 10009 10010/// \brief Check that this is a valid underlying type for an enum declaration. 10011bool Sema::CheckEnumUnderlyingType(TypeSourceInfo *TI) { 10012 SourceLocation UnderlyingLoc = TI->getTypeLoc().getBeginLoc(); 10013 QualType T = TI->getType(); 10014 10015 if (T->isDependentType()) 10016 return false; 10017 10018 if (const BuiltinType *BT = T->getAs<BuiltinType>()) 10019 if (BT->isInteger()) 10020 return false; 10021 10022 Diag(UnderlyingLoc, diag::err_enum_invalid_underlying) << T; 10023 return true; 10024} 10025 10026/// Check whether this is a valid redeclaration of a previous enumeration. 10027/// \return true if the redeclaration was invalid. 10028bool Sema::CheckEnumRedeclaration(SourceLocation EnumLoc, bool IsScoped, 10029 QualType EnumUnderlyingTy, 10030 const EnumDecl *Prev) { 10031 bool IsFixed = !EnumUnderlyingTy.isNull(); 10032 10033 if (IsScoped != Prev->isScoped()) { 10034 Diag(EnumLoc, diag::err_enum_redeclare_scoped_mismatch) 10035 << Prev->isScoped(); 10036 Diag(Prev->getLocation(), diag::note_previous_use); 10037 return true; 10038 } 10039 10040 if (IsFixed && Prev->isFixed()) { 10041 if (!EnumUnderlyingTy->isDependentType() && 10042 !Prev->getIntegerType()->isDependentType() && 10043 !Context.hasSameUnqualifiedType(EnumUnderlyingTy, 10044 Prev->getIntegerType())) { 10045 Diag(EnumLoc, diag::err_enum_redeclare_type_mismatch) 10046 << EnumUnderlyingTy << Prev->getIntegerType(); 10047 Diag(Prev->getLocation(), diag::note_previous_use); 10048 return true; 10049 } 10050 } else if (IsFixed != Prev->isFixed()) { 10051 Diag(EnumLoc, diag::err_enum_redeclare_fixed_mismatch) 10052 << Prev->isFixed(); 10053 Diag(Prev->getLocation(), diag::note_previous_use); 10054 return true; 10055 } 10056 10057 return false; 10058} 10059 10060/// \brief Get diagnostic %select index for tag kind for 10061/// redeclaration diagnostic message. 10062/// WARNING: Indexes apply to particular diagnostics only! 10063/// 10064/// \returns diagnostic %select index. 10065static unsigned getRedeclDiagFromTagKind(TagTypeKind Tag) { 10066 switch (Tag) { 10067 case TTK_Struct: return 0; 10068 case TTK_Interface: return 1; 10069 case TTK_Class: return 2; 10070 default: llvm_unreachable("Invalid tag kind for redecl diagnostic!"); 10071 } 10072} 10073 10074/// \brief Determine if tag kind is a class-key compatible with 10075/// class for redeclaration (class, struct, or __interface). 10076/// 10077/// \returns true iff the tag kind is compatible. 10078static bool isClassCompatTagKind(TagTypeKind Tag) 10079{ 10080 return Tag == TTK_Struct || Tag == TTK_Class || Tag == TTK_Interface; 10081} 10082 10083/// \brief Determine whether a tag with a given kind is acceptable 10084/// as a redeclaration of the given tag declaration. 10085/// 10086/// \returns true if the new tag kind is acceptable, false otherwise. 10087bool Sema::isAcceptableTagRedeclaration(const TagDecl *Previous, 10088 TagTypeKind NewTag, bool isDefinition, 10089 SourceLocation NewTagLoc, 10090 const IdentifierInfo &Name) { 10091 // C++ [dcl.type.elab]p3: 10092 // The class-key or enum keyword present in the 10093 // elaborated-type-specifier shall agree in kind with the 10094 // declaration to which the name in the elaborated-type-specifier 10095 // refers. This rule also applies to the form of 10096 // elaborated-type-specifier that declares a class-name or 10097 // friend class since it can be construed as referring to the 10098 // definition of the class. Thus, in any 10099 // elaborated-type-specifier, the enum keyword shall be used to 10100 // refer to an enumeration (7.2), the union class-key shall be 10101 // used to refer to a union (clause 9), and either the class or 10102 // struct class-key shall be used to refer to a class (clause 9) 10103 // declared using the class or struct class-key. 10104 TagTypeKind OldTag = Previous->getTagKind(); 10105 if (!isDefinition || !isClassCompatTagKind(NewTag)) 10106 if (OldTag == NewTag) 10107 return true; 10108 10109 if (isClassCompatTagKind(OldTag) && isClassCompatTagKind(NewTag)) { 10110 // Warn about the struct/class tag mismatch. 10111 bool isTemplate = false; 10112 if (const CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(Previous)) 10113 isTemplate = Record->getDescribedClassTemplate(); 10114 10115 if (!ActiveTemplateInstantiations.empty()) { 10116 // In a template instantiation, do not offer fix-its for tag mismatches 10117 // since they usually mess up the template instead of fixing the problem. 10118 Diag(NewTagLoc, diag::warn_struct_class_tag_mismatch) 10119 << getRedeclDiagFromTagKind(NewTag) << isTemplate << &Name 10120 << getRedeclDiagFromTagKind(OldTag); 10121 return true; 10122 } 10123 10124 if (isDefinition) { 10125 // On definitions, check previous tags and issue a fix-it for each 10126 // one that doesn't match the current tag. 10127 if (Previous->getDefinition()) { 10128 // Don't suggest fix-its for redefinitions. 10129 return true; 10130 } 10131 10132 bool previousMismatch = false; 10133 for (TagDecl::redecl_iterator I(Previous->redecls_begin()), 10134 E(Previous->redecls_end()); I != E; ++I) { 10135 if (I->getTagKind() != NewTag) { 10136 if (!previousMismatch) { 10137 previousMismatch = true; 10138 Diag(NewTagLoc, diag::warn_struct_class_previous_tag_mismatch) 10139 << getRedeclDiagFromTagKind(NewTag) << isTemplate << &Name 10140 << getRedeclDiagFromTagKind(I->getTagKind()); 10141 } 10142 Diag(I->getInnerLocStart(), diag::note_struct_class_suggestion) 10143 << getRedeclDiagFromTagKind(NewTag) 10144 << FixItHint::CreateReplacement(I->getInnerLocStart(), 10145 TypeWithKeyword::getTagTypeKindName(NewTag)); 10146 } 10147 } 10148 return true; 10149 } 10150 10151 // Check for a previous definition. If current tag and definition 10152 // are same type, do nothing. If no definition, but disagree with 10153 // with previous tag type, give a warning, but no fix-it. 10154 const TagDecl *Redecl = Previous->getDefinition() ? 10155 Previous->getDefinition() : Previous; 10156 if (Redecl->getTagKind() == NewTag) { 10157 return true; 10158 } 10159 10160 Diag(NewTagLoc, diag::warn_struct_class_tag_mismatch) 10161 << getRedeclDiagFromTagKind(NewTag) << isTemplate << &Name 10162 << getRedeclDiagFromTagKind(OldTag); 10163 Diag(Redecl->getLocation(), diag::note_previous_use); 10164 10165 // If there is a previous defintion, suggest a fix-it. 10166 if (Previous->getDefinition()) { 10167 Diag(NewTagLoc, diag::note_struct_class_suggestion) 10168 << getRedeclDiagFromTagKind(Redecl->getTagKind()) 10169 << FixItHint::CreateReplacement(SourceRange(NewTagLoc), 10170 TypeWithKeyword::getTagTypeKindName(Redecl->getTagKind())); 10171 } 10172 10173 return true; 10174 } 10175 return false; 10176} 10177 10178/// ActOnTag - This is invoked when we see 'struct foo' or 'struct {'. In the 10179/// former case, Name will be non-null. In the later case, Name will be null. 10180/// TagSpec indicates what kind of tag this is. TUK indicates whether this is a 10181/// reference/declaration/definition of a tag. 10182Decl *Sema::ActOnTag(Scope *S, unsigned TagSpec, TagUseKind TUK, 10183 SourceLocation KWLoc, CXXScopeSpec &SS, 10184 IdentifierInfo *Name, SourceLocation NameLoc, 10185 AttributeList *Attr, AccessSpecifier AS, 10186 SourceLocation ModulePrivateLoc, 10187 MultiTemplateParamsArg TemplateParameterLists, 10188 bool &OwnedDecl, bool &IsDependent, 10189 SourceLocation ScopedEnumKWLoc, 10190 bool ScopedEnumUsesClassTag, 10191 TypeResult UnderlyingType) { 10192 // If this is not a definition, it must have a name. 10193 IdentifierInfo *OrigName = Name; 10194 assert((Name != 0 || TUK == TUK_Definition) && 10195 "Nameless record must be a definition!"); 10196 assert(TemplateParameterLists.size() == 0 || TUK != TUK_Reference); 10197 10198 OwnedDecl = false; 10199 TagTypeKind Kind = TypeWithKeyword::getTagTypeKindForTypeSpec(TagSpec); 10200 bool ScopedEnum = ScopedEnumKWLoc.isValid(); 10201 10202 // FIXME: Check explicit specializations more carefully. 10203 bool isExplicitSpecialization = false; 10204 bool Invalid = false; 10205 10206 // We only need to do this matching if we have template parameters 10207 // or a scope specifier, which also conveniently avoids this work 10208 // for non-C++ cases. 10209 if (TemplateParameterLists.size() > 0 || 10210 (SS.isNotEmpty() && TUK != TUK_Reference)) { 10211 if (TemplateParameterList *TemplateParams = 10212 MatchTemplateParametersToScopeSpecifier( 10213 KWLoc, NameLoc, SS, TemplateParameterLists, TUK == TUK_Friend, 10214 isExplicitSpecialization, Invalid)) { 10215 if (Kind == TTK_Enum) { 10216 Diag(KWLoc, diag::err_enum_template); 10217 return 0; 10218 } 10219 10220 if (TemplateParams->size() > 0) { 10221 // This is a declaration or definition of a class template (which may 10222 // be a member of another template). 10223 10224 if (Invalid) 10225 return 0; 10226 10227 OwnedDecl = false; 10228 DeclResult Result = CheckClassTemplate(S, TagSpec, TUK, KWLoc, 10229 SS, Name, NameLoc, Attr, 10230 TemplateParams, AS, 10231 ModulePrivateLoc, 10232 TemplateParameterLists.size()-1, 10233 TemplateParameterLists.data()); 10234 return Result.get(); 10235 } else { 10236 // The "template<>" header is extraneous. 10237 Diag(TemplateParams->getTemplateLoc(), diag::err_template_tag_noparams) 10238 << TypeWithKeyword::getTagTypeKindName(Kind) << Name; 10239 isExplicitSpecialization = true; 10240 } 10241 } 10242 } 10243 10244 // Figure out the underlying type if this a enum declaration. We need to do 10245 // this early, because it's needed to detect if this is an incompatible 10246 // redeclaration. 10247 llvm::PointerUnion<const Type*, TypeSourceInfo*> EnumUnderlying; 10248 10249 if (Kind == TTK_Enum) { 10250 if (UnderlyingType.isInvalid() || (!UnderlyingType.get() && ScopedEnum)) 10251 // No underlying type explicitly specified, or we failed to parse the 10252 // type, default to int. 10253 EnumUnderlying = Context.IntTy.getTypePtr(); 10254 else if (UnderlyingType.get()) { 10255 // C++0x 7.2p2: The type-specifier-seq of an enum-base shall name an 10256 // integral type; any cv-qualification is ignored. 10257 TypeSourceInfo *TI = 0; 10258 GetTypeFromParser(UnderlyingType.get(), &TI); 10259 EnumUnderlying = TI; 10260 10261 if (CheckEnumUnderlyingType(TI)) 10262 // Recover by falling back to int. 10263 EnumUnderlying = Context.IntTy.getTypePtr(); 10264 10265 if (DiagnoseUnexpandedParameterPack(TI->getTypeLoc().getBeginLoc(), TI, 10266 UPPC_FixedUnderlyingType)) 10267 EnumUnderlying = Context.IntTy.getTypePtr(); 10268 10269 } else if (getLangOpts().MicrosoftMode) 10270 // Microsoft enums are always of int type. 10271 EnumUnderlying = Context.IntTy.getTypePtr(); 10272 } 10273 10274 DeclContext *SearchDC = CurContext; 10275 DeclContext *DC = CurContext; 10276 bool isStdBadAlloc = false; 10277 10278 RedeclarationKind Redecl = ForRedeclaration; 10279 if (TUK == TUK_Friend || TUK == TUK_Reference) 10280 Redecl = NotForRedeclaration; 10281 10282 LookupResult Previous(*this, Name, NameLoc, LookupTagName, Redecl); 10283 bool FriendSawTagOutsideEnclosingNamespace = false; 10284 if (Name && SS.isNotEmpty()) { 10285 // We have a nested-name tag ('struct foo::bar'). 10286 10287 // Check for invalid 'foo::'. 10288 if (SS.isInvalid()) { 10289 Name = 0; 10290 goto CreateNewDecl; 10291 } 10292 10293 // If this is a friend or a reference to a class in a dependent 10294 // context, don't try to make a decl for it. 10295 if (TUK == TUK_Friend || TUK == TUK_Reference) { 10296 DC = computeDeclContext(SS, false); 10297 if (!DC) { 10298 IsDependent = true; 10299 return 0; 10300 } 10301 } else { 10302 DC = computeDeclContext(SS, true); 10303 if (!DC) { 10304 Diag(SS.getRange().getBegin(), diag::err_dependent_nested_name_spec) 10305 << SS.getRange(); 10306 return 0; 10307 } 10308 } 10309 10310 if (RequireCompleteDeclContext(SS, DC)) 10311 return 0; 10312 10313 SearchDC = DC; 10314 // Look-up name inside 'foo::'. 10315 LookupQualifiedName(Previous, DC); 10316 10317 if (Previous.isAmbiguous()) 10318 return 0; 10319 10320 if (Previous.empty()) { 10321 // Name lookup did not find anything. However, if the 10322 // nested-name-specifier refers to the current instantiation, 10323 // and that current instantiation has any dependent base 10324 // classes, we might find something at instantiation time: treat 10325 // this as a dependent elaborated-type-specifier. 10326 // But this only makes any sense for reference-like lookups. 10327 if (Previous.wasNotFoundInCurrentInstantiation() && 10328 (TUK == TUK_Reference || TUK == TUK_Friend)) { 10329 IsDependent = true; 10330 return 0; 10331 } 10332 10333 // A tag 'foo::bar' must already exist. 10334 Diag(NameLoc, diag::err_not_tag_in_scope) 10335 << Kind << Name << DC << SS.getRange(); 10336 Name = 0; 10337 Invalid = true; 10338 goto CreateNewDecl; 10339 } 10340 } else if (Name) { 10341 // If this is a named struct, check to see if there was a previous forward 10342 // declaration or definition. 10343 // FIXME: We're looking into outer scopes here, even when we 10344 // shouldn't be. Doing so can result in ambiguities that we 10345 // shouldn't be diagnosing. 10346 LookupName(Previous, S); 10347 10348 // When declaring or defining a tag, ignore ambiguities introduced 10349 // by types using'ed into this scope. 10350 if (Previous.isAmbiguous() && 10351 (TUK == TUK_Definition || TUK == TUK_Declaration)) { 10352 LookupResult::Filter F = Previous.makeFilter(); 10353 while (F.hasNext()) { 10354 NamedDecl *ND = F.next(); 10355 if (ND->getDeclContext()->getRedeclContext() != SearchDC) 10356 F.erase(); 10357 } 10358 F.done(); 10359 } 10360 10361 // C++11 [namespace.memdef]p3: 10362 // If the name in a friend declaration is neither qualified nor 10363 // a template-id and the declaration is a function or an 10364 // elaborated-type-specifier, the lookup to determine whether 10365 // the entity has been previously declared shall not consider 10366 // any scopes outside the innermost enclosing namespace. 10367 // 10368 // Does it matter that this should be by scope instead of by 10369 // semantic context? 10370 if (!Previous.empty() && TUK == TUK_Friend) { 10371 DeclContext *EnclosingNS = SearchDC->getEnclosingNamespaceContext(); 10372 LookupResult::Filter F = Previous.makeFilter(); 10373 while (F.hasNext()) { 10374 NamedDecl *ND = F.next(); 10375 DeclContext *DC = ND->getDeclContext()->getRedeclContext(); 10376 if (DC->isFileContext() && 10377 !EnclosingNS->Encloses(ND->getDeclContext())) { 10378 F.erase(); 10379 FriendSawTagOutsideEnclosingNamespace = true; 10380 } 10381 } 10382 F.done(); 10383 } 10384 10385 // Note: there used to be some attempt at recovery here. 10386 if (Previous.isAmbiguous()) 10387 return 0; 10388 10389 if (!getLangOpts().CPlusPlus && TUK != TUK_Reference) { 10390 // FIXME: This makes sure that we ignore the contexts associated 10391 // with C structs, unions, and enums when looking for a matching 10392 // tag declaration or definition. See the similar lookup tweak 10393 // in Sema::LookupName; is there a better way to deal with this? 10394 while (isa<RecordDecl>(SearchDC) || isa<EnumDecl>(SearchDC)) 10395 SearchDC = SearchDC->getParent(); 10396 } 10397 } else if (S->isFunctionPrototypeScope()) { 10398 // If this is an enum declaration in function prototype scope, set its 10399 // initial context to the translation unit. 10400 // FIXME: [citation needed] 10401 SearchDC = Context.getTranslationUnitDecl(); 10402 } 10403 10404 if (Previous.isSingleResult() && 10405 Previous.getFoundDecl()->isTemplateParameter()) { 10406 // Maybe we will complain about the shadowed template parameter. 10407 DiagnoseTemplateParameterShadow(NameLoc, Previous.getFoundDecl()); 10408 // Just pretend that we didn't see the previous declaration. 10409 Previous.clear(); 10410 } 10411 10412 if (getLangOpts().CPlusPlus && Name && DC && StdNamespace && 10413 DC->Equals(getStdNamespace()) && Name->isStr("bad_alloc")) { 10414 // This is a declaration of or a reference to "std::bad_alloc". 10415 isStdBadAlloc = true; 10416 10417 if (Previous.empty() && StdBadAlloc) { 10418 // std::bad_alloc has been implicitly declared (but made invisible to 10419 // name lookup). Fill in this implicit declaration as the previous 10420 // declaration, so that the declarations get chained appropriately. 10421 Previous.addDecl(getStdBadAlloc()); 10422 } 10423 } 10424 10425 // If we didn't find a previous declaration, and this is a reference 10426 // (or friend reference), move to the correct scope. In C++, we 10427 // also need to do a redeclaration lookup there, just in case 10428 // there's a shadow friend decl. 10429 if (Name && Previous.empty() && 10430 (TUK == TUK_Reference || TUK == TUK_Friend)) { 10431 if (Invalid) goto CreateNewDecl; 10432 assert(SS.isEmpty()); 10433 10434 if (TUK == TUK_Reference) { 10435 // C++ [basic.scope.pdecl]p5: 10436 // -- for an elaborated-type-specifier of the form 10437 // 10438 // class-key identifier 10439 // 10440 // if the elaborated-type-specifier is used in the 10441 // decl-specifier-seq or parameter-declaration-clause of a 10442 // function defined in namespace scope, the identifier is 10443 // declared as a class-name in the namespace that contains 10444 // the declaration; otherwise, except as a friend 10445 // declaration, the identifier is declared in the smallest 10446 // non-class, non-function-prototype scope that contains the 10447 // declaration. 10448 // 10449 // C99 6.7.2.3p8 has a similar (but not identical!) provision for 10450 // C structs and unions. 10451 // 10452 // It is an error in C++ to declare (rather than define) an enum 10453 // type, including via an elaborated type specifier. We'll 10454 // diagnose that later; for now, declare the enum in the same 10455 // scope as we would have picked for any other tag type. 10456 // 10457 // GNU C also supports this behavior as part of its incomplete 10458 // enum types extension, while GNU C++ does not. 10459 // 10460 // Find the context where we'll be declaring the tag. 10461 // FIXME: We would like to maintain the current DeclContext as the 10462 // lexical context, 10463 while (!SearchDC->isFileContext() && !SearchDC->isFunctionOrMethod()) 10464 SearchDC = SearchDC->getParent(); 10465 10466 // Find the scope where we'll be declaring the tag. 10467 while (S->isClassScope() || 10468 (getLangOpts().CPlusPlus && 10469 S->isFunctionPrototypeScope()) || 10470 ((S->getFlags() & Scope::DeclScope) == 0) || 10471 (S->getEntity() && 10472 ((DeclContext *)S->getEntity())->isTransparentContext())) 10473 S = S->getParent(); 10474 } else { 10475 assert(TUK == TUK_Friend); 10476 // C++ [namespace.memdef]p3: 10477 // If a friend declaration in a non-local class first declares a 10478 // class or function, the friend class or function is a member of 10479 // the innermost enclosing namespace. 10480 SearchDC = SearchDC->getEnclosingNamespaceContext(); 10481 } 10482 10483 // In C++, we need to do a redeclaration lookup to properly 10484 // diagnose some problems. 10485 if (getLangOpts().CPlusPlus) { 10486 Previous.setRedeclarationKind(ForRedeclaration); 10487 LookupQualifiedName(Previous, SearchDC); 10488 } 10489 } 10490 10491 if (!Previous.empty()) { 10492 NamedDecl *PrevDecl = (*Previous.begin())->getUnderlyingDecl(); 10493 10494 // It's okay to have a tag decl in the same scope as a typedef 10495 // which hides a tag decl in the same scope. Finding this 10496 // insanity with a redeclaration lookup can only actually happen 10497 // in C++. 10498 // 10499 // This is also okay for elaborated-type-specifiers, which is 10500 // technically forbidden by the current standard but which is 10501 // okay according to the likely resolution of an open issue; 10502 // see http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#407 10503 if (getLangOpts().CPlusPlus) { 10504 if (TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(PrevDecl)) { 10505 if (const TagType *TT = TD->getUnderlyingType()->getAs<TagType>()) { 10506 TagDecl *Tag = TT->getDecl(); 10507 if (Tag->getDeclName() == Name && 10508 Tag->getDeclContext()->getRedeclContext() 10509 ->Equals(TD->getDeclContext()->getRedeclContext())) { 10510 PrevDecl = Tag; 10511 Previous.clear(); 10512 Previous.addDecl(Tag); 10513 Previous.resolveKind(); 10514 } 10515 } 10516 } 10517 } 10518 10519 if (TagDecl *PrevTagDecl = dyn_cast<TagDecl>(PrevDecl)) { 10520 // If this is a use of a previous tag, or if the tag is already declared 10521 // in the same scope (so that the definition/declaration completes or 10522 // rementions the tag), reuse the decl. 10523 if (TUK == TUK_Reference || TUK == TUK_Friend || 10524 isDeclInScope(PrevDecl, SearchDC, S, isExplicitSpecialization)) { 10525 // Make sure that this wasn't declared as an enum and now used as a 10526 // struct or something similar. 10527 if (!isAcceptableTagRedeclaration(PrevTagDecl, Kind, 10528 TUK == TUK_Definition, KWLoc, 10529 *Name)) { 10530 bool SafeToContinue 10531 = (PrevTagDecl->getTagKind() != TTK_Enum && 10532 Kind != TTK_Enum); 10533 if (SafeToContinue) 10534 Diag(KWLoc, diag::err_use_with_wrong_tag) 10535 << Name 10536 << FixItHint::CreateReplacement(SourceRange(KWLoc), 10537 PrevTagDecl->getKindName()); 10538 else 10539 Diag(KWLoc, diag::err_use_with_wrong_tag) << Name; 10540 Diag(PrevTagDecl->getLocation(), diag::note_previous_use); 10541 10542 if (SafeToContinue) 10543 Kind = PrevTagDecl->getTagKind(); 10544 else { 10545 // Recover by making this an anonymous redefinition. 10546 Name = 0; 10547 Previous.clear(); 10548 Invalid = true; 10549 } 10550 } 10551 10552 if (Kind == TTK_Enum && PrevTagDecl->getTagKind() == TTK_Enum) { 10553 const EnumDecl *PrevEnum = cast<EnumDecl>(PrevTagDecl); 10554 10555 // If this is an elaborated-type-specifier for a scoped enumeration, 10556 // the 'class' keyword is not necessary and not permitted. 10557 if (TUK == TUK_Reference || TUK == TUK_Friend) { 10558 if (ScopedEnum) 10559 Diag(ScopedEnumKWLoc, diag::err_enum_class_reference) 10560 << PrevEnum->isScoped() 10561 << FixItHint::CreateRemoval(ScopedEnumKWLoc); 10562 return PrevTagDecl; 10563 } 10564 10565 QualType EnumUnderlyingTy; 10566 if (TypeSourceInfo *TI = EnumUnderlying.dyn_cast<TypeSourceInfo*>()) 10567 EnumUnderlyingTy = TI->getType(); 10568 else if (const Type *T = EnumUnderlying.dyn_cast<const Type*>()) 10569 EnumUnderlyingTy = QualType(T, 0); 10570 10571 // All conflicts with previous declarations are recovered by 10572 // returning the previous declaration, unless this is a definition, 10573 // in which case we want the caller to bail out. 10574 if (CheckEnumRedeclaration(NameLoc.isValid() ? NameLoc : KWLoc, 10575 ScopedEnum, EnumUnderlyingTy, PrevEnum)) 10576 return TUK == TUK_Declaration ? PrevTagDecl : 0; 10577 } 10578 10579 // C++11 [class.mem]p1: 10580 // A member shall not be declared twice in the member-specification, 10581 // except that a nested class or member class template can be declared 10582 // and then later defined. 10583 if (TUK == TUK_Declaration && PrevDecl->isCXXClassMember() && 10584 S->isDeclScope(PrevDecl)) { 10585 Diag(NameLoc, diag::ext_member_redeclared); 10586 Diag(PrevTagDecl->getLocation(), diag::note_previous_declaration); 10587 } 10588 10589 if (!Invalid) { 10590 // If this is a use, just return the declaration we found. 10591 10592 // FIXME: In the future, return a variant or some other clue 10593 // for the consumer of this Decl to know it doesn't own it. 10594 // For our current ASTs this shouldn't be a problem, but will 10595 // need to be changed with DeclGroups. 10596 if ((TUK == TUK_Reference && (!PrevTagDecl->getFriendObjectKind() || 10597 getLangOpts().MicrosoftExt)) || TUK == TUK_Friend) 10598 return PrevTagDecl; 10599 10600 // Diagnose attempts to redefine a tag. 10601 if (TUK == TUK_Definition) { 10602 if (TagDecl *Def = PrevTagDecl->getDefinition()) { 10603 // If we're defining a specialization and the previous definition 10604 // is from an implicit instantiation, don't emit an error 10605 // here; we'll catch this in the general case below. 10606 bool IsExplicitSpecializationAfterInstantiation = false; 10607 if (isExplicitSpecialization) { 10608 if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(Def)) 10609 IsExplicitSpecializationAfterInstantiation = 10610 RD->getTemplateSpecializationKind() != 10611 TSK_ExplicitSpecialization; 10612 else if (EnumDecl *ED = dyn_cast<EnumDecl>(Def)) 10613 IsExplicitSpecializationAfterInstantiation = 10614 ED->getTemplateSpecializationKind() != 10615 TSK_ExplicitSpecialization; 10616 } 10617 10618 if (!IsExplicitSpecializationAfterInstantiation) { 10619 // A redeclaration in function prototype scope in C isn't 10620 // visible elsewhere, so merely issue a warning. 10621 if (!getLangOpts().CPlusPlus && S->containedInPrototypeScope()) 10622 Diag(NameLoc, diag::warn_redefinition_in_param_list) << Name; 10623 else 10624 Diag(NameLoc, diag::err_redefinition) << Name; 10625 Diag(Def->getLocation(), diag::note_previous_definition); 10626 // If this is a redefinition, recover by making this 10627 // struct be anonymous, which will make any later 10628 // references get the previous definition. 10629 Name = 0; 10630 Previous.clear(); 10631 Invalid = true; 10632 } 10633 } else { 10634 // If the type is currently being defined, complain 10635 // about a nested redefinition. 10636 const TagType *Tag 10637 = cast<TagType>(Context.getTagDeclType(PrevTagDecl)); 10638 if (Tag->isBeingDefined()) { 10639 Diag(NameLoc, diag::err_nested_redefinition) << Name; 10640 Diag(PrevTagDecl->getLocation(), 10641 diag::note_previous_definition); 10642 Name = 0; 10643 Previous.clear(); 10644 Invalid = true; 10645 } 10646 } 10647 10648 // Okay, this is definition of a previously declared or referenced 10649 // tag PrevDecl. We're going to create a new Decl for it. 10650 } 10651 } 10652 // If we get here we have (another) forward declaration or we 10653 // have a definition. Just create a new decl. 10654 10655 } else { 10656 // If we get here, this is a definition of a new tag type in a nested 10657 // scope, e.g. "struct foo; void bar() { struct foo; }", just create a 10658 // new decl/type. We set PrevDecl to NULL so that the entities 10659 // have distinct types. 10660 Previous.clear(); 10661 } 10662 // If we get here, we're going to create a new Decl. If PrevDecl 10663 // is non-NULL, it's a definition of the tag declared by 10664 // PrevDecl. If it's NULL, we have a new definition. 10665 10666 10667 // Otherwise, PrevDecl is not a tag, but was found with tag 10668 // lookup. This is only actually possible in C++, where a few 10669 // things like templates still live in the tag namespace. 10670 } else { 10671 // Use a better diagnostic if an elaborated-type-specifier 10672 // found the wrong kind of type on the first 10673 // (non-redeclaration) lookup. 10674 if ((TUK == TUK_Reference || TUK == TUK_Friend) && 10675 !Previous.isForRedeclaration()) { 10676 unsigned Kind = 0; 10677 if (isa<TypedefDecl>(PrevDecl)) Kind = 1; 10678 else if (isa<TypeAliasDecl>(PrevDecl)) Kind = 2; 10679 else if (isa<ClassTemplateDecl>(PrevDecl)) Kind = 3; 10680 Diag(NameLoc, diag::err_tag_reference_non_tag) << Kind; 10681 Diag(PrevDecl->getLocation(), diag::note_declared_at); 10682 Invalid = true; 10683 10684 // Otherwise, only diagnose if the declaration is in scope. 10685 } else if (!isDeclInScope(PrevDecl, SearchDC, S, 10686 isExplicitSpecialization)) { 10687 // do nothing 10688 10689 // Diagnose implicit declarations introduced by elaborated types. 10690 } else if (TUK == TUK_Reference || TUK == TUK_Friend) { 10691 unsigned Kind = 0; 10692 if (isa<TypedefDecl>(PrevDecl)) Kind = 1; 10693 else if (isa<TypeAliasDecl>(PrevDecl)) Kind = 2; 10694 else if (isa<ClassTemplateDecl>(PrevDecl)) Kind = 3; 10695 Diag(NameLoc, diag::err_tag_reference_conflict) << Kind; 10696 Diag(PrevDecl->getLocation(), diag::note_previous_decl) << PrevDecl; 10697 Invalid = true; 10698 10699 // Otherwise it's a declaration. Call out a particularly common 10700 // case here. 10701 } else if (TypedefNameDecl *TND = dyn_cast<TypedefNameDecl>(PrevDecl)) { 10702 unsigned Kind = 0; 10703 if (isa<TypeAliasDecl>(PrevDecl)) Kind = 1; 10704 Diag(NameLoc, diag::err_tag_definition_of_typedef) 10705 << Name << Kind << TND->getUnderlyingType(); 10706 Diag(PrevDecl->getLocation(), diag::note_previous_decl) << PrevDecl; 10707 Invalid = true; 10708 10709 // Otherwise, diagnose. 10710 } else { 10711 // The tag name clashes with something else in the target scope, 10712 // issue an error and recover by making this tag be anonymous. 10713 Diag(NameLoc, diag::err_redefinition_different_kind) << Name; 10714 Diag(PrevDecl->getLocation(), diag::note_previous_definition); 10715 Name = 0; 10716 Invalid = true; 10717 } 10718 10719 // The existing declaration isn't relevant to us; we're in a 10720 // new scope, so clear out the previous declaration. 10721 Previous.clear(); 10722 } 10723 } 10724 10725CreateNewDecl: 10726 10727 TagDecl *PrevDecl = 0; 10728 if (Previous.isSingleResult()) 10729 PrevDecl = cast<TagDecl>(Previous.getFoundDecl()); 10730 10731 // If there is an identifier, use the location of the identifier as the 10732 // location of the decl, otherwise use the location of the struct/union 10733 // keyword. 10734 SourceLocation Loc = NameLoc.isValid() ? NameLoc : KWLoc; 10735 10736 // Otherwise, create a new declaration. If there is a previous 10737 // declaration of the same entity, the two will be linked via 10738 // PrevDecl. 10739 TagDecl *New; 10740 10741 bool IsForwardReference = false; 10742 if (Kind == TTK_Enum) { 10743 // FIXME: Tag decls should be chained to any simultaneous vardecls, e.g.: 10744 // enum X { A, B, C } D; D should chain to X. 10745 New = EnumDecl::Create(Context, SearchDC, KWLoc, Loc, Name, 10746 cast_or_null<EnumDecl>(PrevDecl), ScopedEnum, 10747 ScopedEnumUsesClassTag, !EnumUnderlying.isNull()); 10748 // If this is an undefined enum, warn. 10749 if (TUK != TUK_Definition && !Invalid) { 10750 TagDecl *Def; 10751 if ((getLangOpts().CPlusPlus11 || getLangOpts().ObjC2) && 10752 cast<EnumDecl>(New)->isFixed()) { 10753 // C++0x: 7.2p2: opaque-enum-declaration. 10754 // Conflicts are diagnosed above. Do nothing. 10755 } 10756 else if (PrevDecl && (Def = cast<EnumDecl>(PrevDecl)->getDefinition())) { 10757 Diag(Loc, diag::ext_forward_ref_enum_def) 10758 << New; 10759 Diag(Def->getLocation(), diag::note_previous_definition); 10760 } else { 10761 unsigned DiagID = diag::ext_forward_ref_enum; 10762 if (getLangOpts().MicrosoftMode) 10763 DiagID = diag::ext_ms_forward_ref_enum; 10764 else if (getLangOpts().CPlusPlus) 10765 DiagID = diag::err_forward_ref_enum; 10766 Diag(Loc, DiagID); 10767 10768 // If this is a forward-declared reference to an enumeration, make a 10769 // note of it; we won't actually be introducing the declaration into 10770 // the declaration context. 10771 if (TUK == TUK_Reference) 10772 IsForwardReference = true; 10773 } 10774 } 10775 10776 if (EnumUnderlying) { 10777 EnumDecl *ED = cast<EnumDecl>(New); 10778 if (TypeSourceInfo *TI = EnumUnderlying.dyn_cast<TypeSourceInfo*>()) 10779 ED->setIntegerTypeSourceInfo(TI); 10780 else 10781 ED->setIntegerType(QualType(EnumUnderlying.get<const Type*>(), 0)); 10782 ED->setPromotionType(ED->getIntegerType()); 10783 } 10784 10785 } else { 10786 // struct/union/class 10787 10788 // FIXME: Tag decls should be chained to any simultaneous vardecls, e.g.: 10789 // struct X { int A; } D; D should chain to X. 10790 if (getLangOpts().CPlusPlus) { 10791 // FIXME: Look for a way to use RecordDecl for simple structs. 10792 New = CXXRecordDecl::Create(Context, Kind, SearchDC, KWLoc, Loc, Name, 10793 cast_or_null<CXXRecordDecl>(PrevDecl)); 10794 10795 if (isStdBadAlloc && (!StdBadAlloc || getStdBadAlloc()->isImplicit())) 10796 StdBadAlloc = cast<CXXRecordDecl>(New); 10797 } else 10798 New = RecordDecl::Create(Context, Kind, SearchDC, KWLoc, Loc, Name, 10799 cast_or_null<RecordDecl>(PrevDecl)); 10800 } 10801 10802 // Maybe add qualifier info. 10803 if (SS.isNotEmpty()) { 10804 if (SS.isSet()) { 10805 // If this is either a declaration or a definition, check the 10806 // nested-name-specifier against the current context. We don't do this 10807 // for explicit specializations, because they have similar checking 10808 // (with more specific diagnostics) in the call to 10809 // CheckMemberSpecialization, below. 10810 if (!isExplicitSpecialization && 10811 (TUK == TUK_Definition || TUK == TUK_Declaration) && 10812 diagnoseQualifiedDeclaration(SS, DC, OrigName, NameLoc)) 10813 Invalid = true; 10814 10815 New->setQualifierInfo(SS.getWithLocInContext(Context)); 10816 if (TemplateParameterLists.size() > 0) { 10817 New->setTemplateParameterListsInfo(Context, 10818 TemplateParameterLists.size(), 10819 TemplateParameterLists.data()); 10820 } 10821 } 10822 else 10823 Invalid = true; 10824 } 10825 10826 if (RecordDecl *RD = dyn_cast<RecordDecl>(New)) { 10827 // Add alignment attributes if necessary; these attributes are checked when 10828 // the ASTContext lays out the structure. 10829 // 10830 // It is important for implementing the correct semantics that this 10831 // happen here (in act on tag decl). The #pragma pack stack is 10832 // maintained as a result of parser callbacks which can occur at 10833 // many points during the parsing of a struct declaration (because 10834 // the #pragma tokens are effectively skipped over during the 10835 // parsing of the struct). 10836 if (TUK == TUK_Definition) { 10837 AddAlignmentAttributesForRecord(RD); 10838 AddMsStructLayoutForRecord(RD); 10839 } 10840 } 10841 10842 if (ModulePrivateLoc.isValid()) { 10843 if (isExplicitSpecialization) 10844 Diag(New->getLocation(), diag::err_module_private_specialization) 10845 << 2 10846 << FixItHint::CreateRemoval(ModulePrivateLoc); 10847 // __module_private__ does not apply to local classes. However, we only 10848 // diagnose this as an error when the declaration specifiers are 10849 // freestanding. Here, we just ignore the __module_private__. 10850 else if (!SearchDC->isFunctionOrMethod()) 10851 New->setModulePrivate(); 10852 } 10853 10854 // If this is a specialization of a member class (of a class template), 10855 // check the specialization. 10856 if (isExplicitSpecialization && CheckMemberSpecialization(New, Previous)) 10857 Invalid = true; 10858 10859 if (Invalid) 10860 New->setInvalidDecl(); 10861 10862 if (Attr) 10863 ProcessDeclAttributeList(S, New, Attr); 10864 10865 // If we're declaring or defining a tag in function prototype scope 10866 // in C, note that this type can only be used within the function. 10867 if (Name && S->isFunctionPrototypeScope() && !getLangOpts().CPlusPlus) 10868 Diag(Loc, diag::warn_decl_in_param_list) << Context.getTagDeclType(New); 10869 10870 // Set the lexical context. If the tag has a C++ scope specifier, the 10871 // lexical context will be different from the semantic context. 10872 New->setLexicalDeclContext(CurContext); 10873 10874 // Mark this as a friend decl if applicable. 10875 // In Microsoft mode, a friend declaration also acts as a forward 10876 // declaration so we always pass true to setObjectOfFriendDecl to make 10877 // the tag name visible. 10878 if (TUK == TUK_Friend) 10879 New->setObjectOfFriendDecl(!FriendSawTagOutsideEnclosingNamespace && 10880 getLangOpts().MicrosoftExt); 10881 10882 // Set the access specifier. 10883 if (!Invalid && SearchDC->isRecord()) 10884 SetMemberAccessSpecifier(New, PrevDecl, AS); 10885 10886 if (TUK == TUK_Definition) 10887 New->startDefinition(); 10888 10889 // If this has an identifier, add it to the scope stack. 10890 if (TUK == TUK_Friend) { 10891 // We might be replacing an existing declaration in the lookup tables; 10892 // if so, borrow its access specifier. 10893 if (PrevDecl) 10894 New->setAccess(PrevDecl->getAccess()); 10895 10896 DeclContext *DC = New->getDeclContext()->getRedeclContext(); 10897 DC->makeDeclVisibleInContext(New); 10898 if (Name) // can be null along some error paths 10899 if (Scope *EnclosingScope = getScopeForDeclContext(S, DC)) 10900 PushOnScopeChains(New, EnclosingScope, /* AddToContext = */ false); 10901 } else if (Name) { 10902 S = getNonFieldDeclScope(S); 10903 PushOnScopeChains(New, S, !IsForwardReference); 10904 if (IsForwardReference) 10905 SearchDC->makeDeclVisibleInContext(New); 10906 10907 } else { 10908 CurContext->addDecl(New); 10909 } 10910 10911 // If this is the C FILE type, notify the AST context. 10912 if (IdentifierInfo *II = New->getIdentifier()) 10913 if (!New->isInvalidDecl() && 10914 New->getDeclContext()->getRedeclContext()->isTranslationUnit() && 10915 II->isStr("FILE")) 10916 Context.setFILEDecl(New); 10917 10918 // If we were in function prototype scope (and not in C++ mode), add this 10919 // tag to the list of decls to inject into the function definition scope. 10920 if (S->isFunctionPrototypeScope() && !getLangOpts().CPlusPlus && 10921 InFunctionDeclarator && Name) 10922 DeclsInPrototypeScope.push_back(New); 10923 10924 if (PrevDecl) 10925 mergeDeclAttributes(New, PrevDecl); 10926 10927 // If there's a #pragma GCC visibility in scope, set the visibility of this 10928 // record. 10929 AddPushedVisibilityAttribute(New); 10930 10931 OwnedDecl = true; 10932 // In C++, don't return an invalid declaration. We can't recover well from 10933 // the cases where we make the type anonymous. 10934 return (Invalid && getLangOpts().CPlusPlus) ? 0 : New; 10935} 10936 10937void Sema::ActOnTagStartDefinition(Scope *S, Decl *TagD) { 10938 AdjustDeclIfTemplate(TagD); 10939 TagDecl *Tag = cast<TagDecl>(TagD); 10940 10941 // Enter the tag context. 10942 PushDeclContext(S, Tag); 10943 10944 ActOnDocumentableDecl(TagD); 10945 10946 // If there's a #pragma GCC visibility in scope, set the visibility of this 10947 // record. 10948 AddPushedVisibilityAttribute(Tag); 10949} 10950 10951Decl *Sema::ActOnObjCContainerStartDefinition(Decl *IDecl) { 10952 assert(isa<ObjCContainerDecl>(IDecl) && 10953 "ActOnObjCContainerStartDefinition - Not ObjCContainerDecl"); 10954 DeclContext *OCD = cast<DeclContext>(IDecl); 10955 assert(getContainingDC(OCD) == CurContext && 10956 "The next DeclContext should be lexically contained in the current one."); 10957 CurContext = OCD; 10958 return IDecl; 10959} 10960 10961void Sema::ActOnStartCXXMemberDeclarations(Scope *S, Decl *TagD, 10962 SourceLocation FinalLoc, 10963 SourceLocation LBraceLoc) { 10964 AdjustDeclIfTemplate(TagD); 10965 CXXRecordDecl *Record = cast<CXXRecordDecl>(TagD); 10966 10967 FieldCollector->StartClass(); 10968 10969 if (!Record->getIdentifier()) 10970 return; 10971 10972 if (FinalLoc.isValid()) 10973 Record->addAttr(new (Context) FinalAttr(FinalLoc, Context)); 10974 10975 // C++ [class]p2: 10976 // [...] The class-name is also inserted into the scope of the 10977 // class itself; this is known as the injected-class-name. For 10978 // purposes of access checking, the injected-class-name is treated 10979 // as if it were a public member name. 10980 CXXRecordDecl *InjectedClassName 10981 = CXXRecordDecl::Create(Context, Record->getTagKind(), CurContext, 10982 Record->getLocStart(), Record->getLocation(), 10983 Record->getIdentifier(), 10984 /*PrevDecl=*/0, 10985 /*DelayTypeCreation=*/true); 10986 Context.getTypeDeclType(InjectedClassName, Record); 10987 InjectedClassName->setImplicit(); 10988 InjectedClassName->setAccess(AS_public); 10989 if (ClassTemplateDecl *Template = Record->getDescribedClassTemplate()) 10990 InjectedClassName->setDescribedClassTemplate(Template); 10991 PushOnScopeChains(InjectedClassName, S); 10992 assert(InjectedClassName->isInjectedClassName() && 10993 "Broken injected-class-name"); 10994} 10995 10996void Sema::ActOnTagFinishDefinition(Scope *S, Decl *TagD, 10997 SourceLocation RBraceLoc) { 10998 AdjustDeclIfTemplate(TagD); 10999 TagDecl *Tag = cast<TagDecl>(TagD); 11000 Tag->setRBraceLoc(RBraceLoc); 11001 11002 // Make sure we "complete" the definition even it is invalid. 11003 if (Tag->isBeingDefined()) { 11004 assert(Tag->isInvalidDecl() && "We should already have completed it"); 11005 if (RecordDecl *RD = dyn_cast<RecordDecl>(Tag)) 11006 RD->completeDefinition(); 11007 } 11008 11009 if (isa<CXXRecordDecl>(Tag)) 11010 FieldCollector->FinishClass(); 11011 11012 // Exit this scope of this tag's definition. 11013 PopDeclContext(); 11014 11015 if (getCurLexicalContext()->isObjCContainer() && 11016 Tag->getDeclContext()->isFileContext()) 11017 Tag->setTopLevelDeclInObjCContainer(); 11018 11019 // Notify the consumer that we've defined a tag. 11020 if (!Tag->isInvalidDecl()) 11021 Consumer.HandleTagDeclDefinition(Tag); 11022} 11023 11024void Sema::ActOnObjCContainerFinishDefinition() { 11025 // Exit this scope of this interface definition. 11026 PopDeclContext(); 11027} 11028 11029void Sema::ActOnObjCTemporaryExitContainerContext(DeclContext *DC) { 11030 assert(DC == CurContext && "Mismatch of container contexts"); 11031 OriginalLexicalContext = DC; 11032 ActOnObjCContainerFinishDefinition(); 11033} 11034 11035void Sema::ActOnObjCReenterContainerContext(DeclContext *DC) { 11036 ActOnObjCContainerStartDefinition(cast<Decl>(DC)); 11037 OriginalLexicalContext = 0; 11038} 11039 11040void Sema::ActOnTagDefinitionError(Scope *S, Decl *TagD) { 11041 AdjustDeclIfTemplate(TagD); 11042 TagDecl *Tag = cast<TagDecl>(TagD); 11043 Tag->setInvalidDecl(); 11044 11045 // Make sure we "complete" the definition even it is invalid. 11046 if (Tag->isBeingDefined()) { 11047 if (RecordDecl *RD = dyn_cast<RecordDecl>(Tag)) 11048 RD->completeDefinition(); 11049 } 11050 11051 // We're undoing ActOnTagStartDefinition here, not 11052 // ActOnStartCXXMemberDeclarations, so we don't have to mess with 11053 // the FieldCollector. 11054 11055 PopDeclContext(); 11056} 11057 11058// Note that FieldName may be null for anonymous bitfields. 11059ExprResult Sema::VerifyBitField(SourceLocation FieldLoc, 11060 IdentifierInfo *FieldName, 11061 QualType FieldTy, bool IsMsStruct, 11062 Expr *BitWidth, bool *ZeroWidth) { 11063 // Default to true; that shouldn't confuse checks for emptiness 11064 if (ZeroWidth) 11065 *ZeroWidth = true; 11066 11067 // C99 6.7.2.1p4 - verify the field type. 11068 // C++ 9.6p3: A bit-field shall have integral or enumeration type. 11069 if (!FieldTy->isDependentType() && !FieldTy->isIntegralOrEnumerationType()) { 11070 // Handle incomplete types with specific error. 11071 if (RequireCompleteType(FieldLoc, FieldTy, diag::err_field_incomplete)) 11072 return ExprError(); 11073 if (FieldName) 11074 return Diag(FieldLoc, diag::err_not_integral_type_bitfield) 11075 << FieldName << FieldTy << BitWidth->getSourceRange(); 11076 return Diag(FieldLoc, diag::err_not_integral_type_anon_bitfield) 11077 << FieldTy << BitWidth->getSourceRange(); 11078 } else if (DiagnoseUnexpandedParameterPack(const_cast<Expr *>(BitWidth), 11079 UPPC_BitFieldWidth)) 11080 return ExprError(); 11081 11082 // If the bit-width is type- or value-dependent, don't try to check 11083 // it now. 11084 if (BitWidth->isValueDependent() || BitWidth->isTypeDependent()) 11085 return Owned(BitWidth); 11086 11087 llvm::APSInt Value; 11088 ExprResult ICE = VerifyIntegerConstantExpression(BitWidth, &Value); 11089 if (ICE.isInvalid()) 11090 return ICE; 11091 BitWidth = ICE.take(); 11092 11093 if (Value != 0 && ZeroWidth) 11094 *ZeroWidth = false; 11095 11096 // Zero-width bitfield is ok for anonymous field. 11097 if (Value == 0 && FieldName) 11098 return Diag(FieldLoc, diag::err_bitfield_has_zero_width) << FieldName; 11099 11100 if (Value.isSigned() && Value.isNegative()) { 11101 if (FieldName) 11102 return Diag(FieldLoc, diag::err_bitfield_has_negative_width) 11103 << FieldName << Value.toString(10); 11104 return Diag(FieldLoc, diag::err_anon_bitfield_has_negative_width) 11105 << Value.toString(10); 11106 } 11107 11108 if (!FieldTy->isDependentType()) { 11109 uint64_t TypeSize = Context.getTypeSize(FieldTy); 11110 if (Value.getZExtValue() > TypeSize) { 11111 if (!getLangOpts().CPlusPlus || IsMsStruct) { 11112 if (FieldName) 11113 return Diag(FieldLoc, diag::err_bitfield_width_exceeds_type_size) 11114 << FieldName << (unsigned)Value.getZExtValue() 11115 << (unsigned)TypeSize; 11116 11117 return Diag(FieldLoc, diag::err_anon_bitfield_width_exceeds_type_size) 11118 << (unsigned)Value.getZExtValue() << (unsigned)TypeSize; 11119 } 11120 11121 if (FieldName) 11122 Diag(FieldLoc, diag::warn_bitfield_width_exceeds_type_size) 11123 << FieldName << (unsigned)Value.getZExtValue() 11124 << (unsigned)TypeSize; 11125 else 11126 Diag(FieldLoc, diag::warn_anon_bitfield_width_exceeds_type_size) 11127 << (unsigned)Value.getZExtValue() << (unsigned)TypeSize; 11128 } 11129 } 11130 11131 return Owned(BitWidth); 11132} 11133 11134/// ActOnField - Each field of a C struct/union is passed into this in order 11135/// to create a FieldDecl object for it. 11136Decl *Sema::ActOnField(Scope *S, Decl *TagD, SourceLocation DeclStart, 11137 Declarator &D, Expr *BitfieldWidth) { 11138 FieldDecl *Res = HandleField(S, cast_or_null<RecordDecl>(TagD), 11139 DeclStart, D, static_cast<Expr*>(BitfieldWidth), 11140 /*InitStyle=*/ICIS_NoInit, AS_public); 11141 return Res; 11142} 11143 11144/// HandleField - Analyze a field of a C struct or a C++ data member. 11145/// 11146FieldDecl *Sema::HandleField(Scope *S, RecordDecl *Record, 11147 SourceLocation DeclStart, 11148 Declarator &D, Expr *BitWidth, 11149 InClassInitStyle InitStyle, 11150 AccessSpecifier AS) { 11151 IdentifierInfo *II = D.getIdentifier(); 11152 SourceLocation Loc = DeclStart; 11153 if (II) Loc = D.getIdentifierLoc(); 11154 11155 TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S); 11156 QualType T = TInfo->getType(); 11157 if (getLangOpts().CPlusPlus) { 11158 CheckExtraCXXDefaultArguments(D); 11159 11160 if (DiagnoseUnexpandedParameterPack(D.getIdentifierLoc(), TInfo, 11161 UPPC_DataMemberType)) { 11162 D.setInvalidType(); 11163 T = Context.IntTy; 11164 TInfo = Context.getTrivialTypeSourceInfo(T, Loc); 11165 } 11166 } 11167 11168 // TR 18037 does not allow fields to be declared with address spaces. 11169 if (T.getQualifiers().hasAddressSpace()) { 11170 Diag(Loc, diag::err_field_with_address_space); 11171 D.setInvalidType(); 11172 } 11173 11174 // OpenCL 1.2 spec, s6.9 r: 11175 // The event type cannot be used to declare a structure or union field. 11176 if (LangOpts.OpenCL && T->isEventT()) { 11177 Diag(Loc, diag::err_event_t_struct_field); 11178 D.setInvalidType(); 11179 } 11180 11181 DiagnoseFunctionSpecifiers(D.getDeclSpec()); 11182 11183 if (DeclSpec::TSCS TSCS = D.getDeclSpec().getThreadStorageClassSpec()) 11184 Diag(D.getDeclSpec().getThreadStorageClassSpecLoc(), 11185 diag::err_invalid_thread) 11186 << DeclSpec::getSpecifierName(TSCS); 11187 11188 // Check to see if this name was declared as a member previously 11189 NamedDecl *PrevDecl = 0; 11190 LookupResult Previous(*this, II, Loc, LookupMemberName, ForRedeclaration); 11191 LookupName(Previous, S); 11192 switch (Previous.getResultKind()) { 11193 case LookupResult::Found: 11194 case LookupResult::FoundUnresolvedValue: 11195 PrevDecl = Previous.getAsSingle<NamedDecl>(); 11196 break; 11197 11198 case LookupResult::FoundOverloaded: 11199 PrevDecl = Previous.getRepresentativeDecl(); 11200 break; 11201 11202 case LookupResult::NotFound: 11203 case LookupResult::NotFoundInCurrentInstantiation: 11204 case LookupResult::Ambiguous: 11205 break; 11206 } 11207 Previous.suppressDiagnostics(); 11208 11209 if (PrevDecl && PrevDecl->isTemplateParameter()) { 11210 // Maybe we will complain about the shadowed template parameter. 11211 DiagnoseTemplateParameterShadow(D.getIdentifierLoc(), PrevDecl); 11212 // Just pretend that we didn't see the previous declaration. 11213 PrevDecl = 0; 11214 } 11215 11216 if (PrevDecl && !isDeclInScope(PrevDecl, Record, S)) 11217 PrevDecl = 0; 11218 11219 bool Mutable 11220 = (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_mutable); 11221 SourceLocation TSSL = D.getLocStart(); 11222 FieldDecl *NewFD 11223 = CheckFieldDecl(II, T, TInfo, Record, Loc, Mutable, BitWidth, InitStyle, 11224 TSSL, AS, PrevDecl, &D); 11225 11226 if (NewFD->isInvalidDecl()) 11227 Record->setInvalidDecl(); 11228 11229 if (D.getDeclSpec().isModulePrivateSpecified()) 11230 NewFD->setModulePrivate(); 11231 11232 if (NewFD->isInvalidDecl() && PrevDecl) { 11233 // Don't introduce NewFD into scope; there's already something 11234 // with the same name in the same scope. 11235 } else if (II) { 11236 PushOnScopeChains(NewFD, S); 11237 } else 11238 Record->addDecl(NewFD); 11239 11240 return NewFD; 11241} 11242 11243/// \brief Build a new FieldDecl and check its well-formedness. 11244/// 11245/// This routine builds a new FieldDecl given the fields name, type, 11246/// record, etc. \p PrevDecl should refer to any previous declaration 11247/// with the same name and in the same scope as the field to be 11248/// created. 11249/// 11250/// \returns a new FieldDecl. 11251/// 11252/// \todo The Declarator argument is a hack. It will be removed once 11253FieldDecl *Sema::CheckFieldDecl(DeclarationName Name, QualType T, 11254 TypeSourceInfo *TInfo, 11255 RecordDecl *Record, SourceLocation Loc, 11256 bool Mutable, Expr *BitWidth, 11257 InClassInitStyle InitStyle, 11258 SourceLocation TSSL, 11259 AccessSpecifier AS, NamedDecl *PrevDecl, 11260 Declarator *D) { 11261 IdentifierInfo *II = Name.getAsIdentifierInfo(); 11262 bool InvalidDecl = false; 11263 if (D) InvalidDecl = D->isInvalidType(); 11264 11265 // If we receive a broken type, recover by assuming 'int' and 11266 // marking this declaration as invalid. 11267 if (T.isNull()) { 11268 InvalidDecl = true; 11269 T = Context.IntTy; 11270 } 11271 11272 QualType EltTy = Context.getBaseElementType(T); 11273 if (!EltTy->isDependentType()) { 11274 if (RequireCompleteType(Loc, EltTy, diag::err_field_incomplete)) { 11275 // Fields of incomplete type force their record to be invalid. 11276 Record->setInvalidDecl(); 11277 InvalidDecl = true; 11278 } else { 11279 NamedDecl *Def; 11280 EltTy->isIncompleteType(&Def); 11281 if (Def && Def->isInvalidDecl()) { 11282 Record->setInvalidDecl(); 11283 InvalidDecl = true; 11284 } 11285 } 11286 } 11287 11288 // OpenCL v1.2 s6.9.c: bitfields are not supported. 11289 if (BitWidth && getLangOpts().OpenCL) { 11290 Diag(Loc, diag::err_opencl_bitfields); 11291 InvalidDecl = true; 11292 } 11293 11294 // C99 6.7.2.1p8: A member of a structure or union may have any type other 11295 // than a variably modified type. 11296 if (!InvalidDecl && T->isVariablyModifiedType()) { 11297 bool SizeIsNegative; 11298 llvm::APSInt Oversized; 11299 11300 TypeSourceInfo *FixedTInfo = 11301 TryToFixInvalidVariablyModifiedTypeSourceInfo(TInfo, Context, 11302 SizeIsNegative, 11303 Oversized); 11304 if (FixedTInfo) { 11305 Diag(Loc, diag::warn_illegal_constant_array_size); 11306 TInfo = FixedTInfo; 11307 T = FixedTInfo->getType(); 11308 } else { 11309 if (SizeIsNegative) 11310 Diag(Loc, diag::err_typecheck_negative_array_size); 11311 else if (Oversized.getBoolValue()) 11312 Diag(Loc, diag::err_array_too_large) 11313 << Oversized.toString(10); 11314 else 11315 Diag(Loc, diag::err_typecheck_field_variable_size); 11316 InvalidDecl = true; 11317 } 11318 } 11319 11320 // Fields can not have abstract class types 11321 if (!InvalidDecl && RequireNonAbstractType(Loc, T, 11322 diag::err_abstract_type_in_decl, 11323 AbstractFieldType)) 11324 InvalidDecl = true; 11325 11326 bool ZeroWidth = false; 11327 // If this is declared as a bit-field, check the bit-field. 11328 if (!InvalidDecl && BitWidth) { 11329 BitWidth = VerifyBitField(Loc, II, T, Record->isMsStruct(Context), BitWidth, 11330 &ZeroWidth).take(); 11331 if (!BitWidth) { 11332 InvalidDecl = true; 11333 BitWidth = 0; 11334 ZeroWidth = false; 11335 } 11336 } 11337 11338 // Check that 'mutable' is consistent with the type of the declaration. 11339 if (!InvalidDecl && Mutable) { 11340 unsigned DiagID = 0; 11341 if (T->isReferenceType()) 11342 DiagID = diag::err_mutable_reference; 11343 else if (T.isConstQualified()) 11344 DiagID = diag::err_mutable_const; 11345 11346 if (DiagID) { 11347 SourceLocation ErrLoc = Loc; 11348 if (D && D->getDeclSpec().getStorageClassSpecLoc().isValid()) 11349 ErrLoc = D->getDeclSpec().getStorageClassSpecLoc(); 11350 Diag(ErrLoc, DiagID); 11351 Mutable = false; 11352 InvalidDecl = true; 11353 } 11354 } 11355 11356 FieldDecl *NewFD = FieldDecl::Create(Context, Record, TSSL, Loc, II, T, TInfo, 11357 BitWidth, Mutable, InitStyle); 11358 if (InvalidDecl) 11359 NewFD->setInvalidDecl(); 11360 11361 if (PrevDecl && !isa<TagDecl>(PrevDecl)) { 11362 Diag(Loc, diag::err_duplicate_member) << II; 11363 Diag(PrevDecl->getLocation(), diag::note_previous_declaration); 11364 NewFD->setInvalidDecl(); 11365 } 11366 11367 if (!InvalidDecl && getLangOpts().CPlusPlus) { 11368 if (Record->isUnion()) { 11369 if (const RecordType *RT = EltTy->getAs<RecordType>()) { 11370 CXXRecordDecl* RDecl = cast<CXXRecordDecl>(RT->getDecl()); 11371 if (RDecl->getDefinition()) { 11372 // C++ [class.union]p1: An object of a class with a non-trivial 11373 // constructor, a non-trivial copy constructor, a non-trivial 11374 // destructor, or a non-trivial copy assignment operator 11375 // cannot be a member of a union, nor can an array of such 11376 // objects. 11377 if (CheckNontrivialField(NewFD)) 11378 NewFD->setInvalidDecl(); 11379 } 11380 } 11381 11382 // C++ [class.union]p1: If a union contains a member of reference type, 11383 // the program is ill-formed, except when compiling with MSVC extensions 11384 // enabled. 11385 if (EltTy->isReferenceType()) { 11386 Diag(NewFD->getLocation(), getLangOpts().MicrosoftExt ? 11387 diag::ext_union_member_of_reference_type : 11388 diag::err_union_member_of_reference_type) 11389 << NewFD->getDeclName() << EltTy; 11390 if (!getLangOpts().MicrosoftExt) 11391 NewFD->setInvalidDecl(); 11392 } 11393 } 11394 } 11395 11396 // FIXME: We need to pass in the attributes given an AST 11397 // representation, not a parser representation. 11398 if (D) { 11399 // FIXME: The current scope is almost... but not entirely... correct here. 11400 ProcessDeclAttributes(getCurScope(), NewFD, *D); 11401 11402 if (NewFD->hasAttrs()) 11403 CheckAlignasUnderalignment(NewFD); 11404 } 11405 11406 // In auto-retain/release, infer strong retension for fields of 11407 // retainable type. 11408 if (getLangOpts().ObjCAutoRefCount && inferObjCARCLifetime(NewFD)) 11409 NewFD->setInvalidDecl(); 11410 11411 if (T.isObjCGCWeak()) 11412 Diag(Loc, diag::warn_attribute_weak_on_field); 11413 11414 NewFD->setAccess(AS); 11415 return NewFD; 11416} 11417 11418bool Sema::CheckNontrivialField(FieldDecl *FD) { 11419 assert(FD); 11420 assert(getLangOpts().CPlusPlus && "valid check only for C++"); 11421 11422 if (FD->isInvalidDecl() || FD->getType()->isDependentType()) 11423 return false; 11424 11425 QualType EltTy = Context.getBaseElementType(FD->getType()); 11426 if (const RecordType *RT = EltTy->getAs<RecordType>()) { 11427 CXXRecordDecl *RDecl = cast<CXXRecordDecl>(RT->getDecl()); 11428 if (RDecl->getDefinition()) { 11429 // We check for copy constructors before constructors 11430 // because otherwise we'll never get complaints about 11431 // copy constructors. 11432 11433 CXXSpecialMember member = CXXInvalid; 11434 // We're required to check for any non-trivial constructors. Since the 11435 // implicit default constructor is suppressed if there are any 11436 // user-declared constructors, we just need to check that there is a 11437 // trivial default constructor and a trivial copy constructor. (We don't 11438 // worry about move constructors here, since this is a C++98 check.) 11439 if (RDecl->hasNonTrivialCopyConstructor()) 11440 member = CXXCopyConstructor; 11441 else if (!RDecl->hasTrivialDefaultConstructor()) 11442 member = CXXDefaultConstructor; 11443 else if (RDecl->hasNonTrivialCopyAssignment()) 11444 member = CXXCopyAssignment; 11445 else if (RDecl->hasNonTrivialDestructor()) 11446 member = CXXDestructor; 11447 11448 if (member != CXXInvalid) { 11449 if (!getLangOpts().CPlusPlus11 && 11450 getLangOpts().ObjCAutoRefCount && RDecl->hasObjectMember()) { 11451 // Objective-C++ ARC: it is an error to have a non-trivial field of 11452 // a union. However, system headers in Objective-C programs 11453 // occasionally have Objective-C lifetime objects within unions, 11454 // and rather than cause the program to fail, we make those 11455 // members unavailable. 11456 SourceLocation Loc = FD->getLocation(); 11457 if (getSourceManager().isInSystemHeader(Loc)) { 11458 if (!FD->hasAttr<UnavailableAttr>()) 11459 FD->addAttr(new (Context) UnavailableAttr(Loc, Context, 11460 "this system field has retaining ownership")); 11461 return false; 11462 } 11463 } 11464 11465 Diag(FD->getLocation(), getLangOpts().CPlusPlus11 ? 11466 diag::warn_cxx98_compat_nontrivial_union_or_anon_struct_member : 11467 diag::err_illegal_union_or_anon_struct_member) 11468 << (int)FD->getParent()->isUnion() << FD->getDeclName() << member; 11469 DiagnoseNontrivial(RDecl, member); 11470 return !getLangOpts().CPlusPlus11; 11471 } 11472 } 11473 } 11474 11475 return false; 11476} 11477 11478/// TranslateIvarVisibility - Translate visibility from a token ID to an 11479/// AST enum value. 11480static ObjCIvarDecl::AccessControl 11481TranslateIvarVisibility(tok::ObjCKeywordKind ivarVisibility) { 11482 switch (ivarVisibility) { 11483 default: llvm_unreachable("Unknown visitibility kind"); 11484 case tok::objc_private: return ObjCIvarDecl::Private; 11485 case tok::objc_public: return ObjCIvarDecl::Public; 11486 case tok::objc_protected: return ObjCIvarDecl::Protected; 11487 case tok::objc_package: return ObjCIvarDecl::Package; 11488 } 11489} 11490 11491/// ActOnIvar - Each ivar field of an objective-c class is passed into this 11492/// in order to create an IvarDecl object for it. 11493Decl *Sema::ActOnIvar(Scope *S, 11494 SourceLocation DeclStart, 11495 Declarator &D, Expr *BitfieldWidth, 11496 tok::ObjCKeywordKind Visibility) { 11497 11498 IdentifierInfo *II = D.getIdentifier(); 11499 Expr *BitWidth = (Expr*)BitfieldWidth; 11500 SourceLocation Loc = DeclStart; 11501 if (II) Loc = D.getIdentifierLoc(); 11502 11503 // FIXME: Unnamed fields can be handled in various different ways, for 11504 // example, unnamed unions inject all members into the struct namespace! 11505 11506 TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S); 11507 QualType T = TInfo->getType(); 11508 11509 if (BitWidth) { 11510 // 6.7.2.1p3, 6.7.2.1p4 11511 BitWidth = 11512 VerifyBitField(Loc, II, T, /*IsMsStruct=*/false, BitWidth).take(); 11513 if (!BitWidth) 11514 D.setInvalidType(); 11515 } else { 11516 // Not a bitfield. 11517 11518 // validate II. 11519 11520 } 11521 if (T->isReferenceType()) { 11522 Diag(Loc, diag::err_ivar_reference_type); 11523 D.setInvalidType(); 11524 } 11525 // C99 6.7.2.1p8: A member of a structure or union may have any type other 11526 // than a variably modified type. 11527 else if (T->isVariablyModifiedType()) { 11528 Diag(Loc, diag::err_typecheck_ivar_variable_size); 11529 D.setInvalidType(); 11530 } 11531 11532 // Get the visibility (access control) for this ivar. 11533 ObjCIvarDecl::AccessControl ac = 11534 Visibility != tok::objc_not_keyword ? TranslateIvarVisibility(Visibility) 11535 : ObjCIvarDecl::None; 11536 // Must set ivar's DeclContext to its enclosing interface. 11537 ObjCContainerDecl *EnclosingDecl = cast<ObjCContainerDecl>(CurContext); 11538 if (!EnclosingDecl || EnclosingDecl->isInvalidDecl()) 11539 return 0; 11540 ObjCContainerDecl *EnclosingContext; 11541 if (ObjCImplementationDecl *IMPDecl = 11542 dyn_cast<ObjCImplementationDecl>(EnclosingDecl)) { 11543 if (LangOpts.ObjCRuntime.isFragile()) { 11544 // Case of ivar declared in an implementation. Context is that of its class. 11545 EnclosingContext = IMPDecl->getClassInterface(); 11546 assert(EnclosingContext && "Implementation has no class interface!"); 11547 } 11548 else 11549 EnclosingContext = EnclosingDecl; 11550 } else { 11551 if (ObjCCategoryDecl *CDecl = 11552 dyn_cast<ObjCCategoryDecl>(EnclosingDecl)) { 11553 if (LangOpts.ObjCRuntime.isFragile() || !CDecl->IsClassExtension()) { 11554 Diag(Loc, diag::err_misplaced_ivar) << CDecl->IsClassExtension(); 11555 return 0; 11556 } 11557 } 11558 EnclosingContext = EnclosingDecl; 11559 } 11560 11561 // Construct the decl. 11562 ObjCIvarDecl *NewID = ObjCIvarDecl::Create(Context, EnclosingContext, 11563 DeclStart, Loc, II, T, 11564 TInfo, ac, (Expr *)BitfieldWidth); 11565 11566 if (II) { 11567 NamedDecl *PrevDecl = LookupSingleName(S, II, Loc, LookupMemberName, 11568 ForRedeclaration); 11569 if (PrevDecl && isDeclInScope(PrevDecl, EnclosingContext, S) 11570 && !isa<TagDecl>(PrevDecl)) { 11571 Diag(Loc, diag::err_duplicate_member) << II; 11572 Diag(PrevDecl->getLocation(), diag::note_previous_declaration); 11573 NewID->setInvalidDecl(); 11574 } 11575 } 11576 11577 // Process attributes attached to the ivar. 11578 ProcessDeclAttributes(S, NewID, D); 11579 11580 if (D.isInvalidType()) 11581 NewID->setInvalidDecl(); 11582 11583 // In ARC, infer 'retaining' for ivars of retainable type. 11584 if (getLangOpts().ObjCAutoRefCount && inferObjCARCLifetime(NewID)) 11585 NewID->setInvalidDecl(); 11586 11587 if (D.getDeclSpec().isModulePrivateSpecified()) 11588 NewID->setModulePrivate(); 11589 11590 if (II) { 11591 // FIXME: When interfaces are DeclContexts, we'll need to add 11592 // these to the interface. 11593 S->AddDecl(NewID); 11594 IdResolver.AddDecl(NewID); 11595 } 11596 11597 if (LangOpts.ObjCRuntime.isNonFragile() && 11598 !NewID->isInvalidDecl() && isa<ObjCInterfaceDecl>(EnclosingDecl)) 11599 Diag(Loc, diag::warn_ivars_in_interface); 11600 11601 return NewID; 11602} 11603 11604/// ActOnLastBitfield - This routine handles synthesized bitfields rules for 11605/// class and class extensions. For every class \@interface and class 11606/// extension \@interface, if the last ivar is a bitfield of any type, 11607/// then add an implicit `char :0` ivar to the end of that interface. 11608void Sema::ActOnLastBitfield(SourceLocation DeclLoc, 11609 SmallVectorImpl<Decl *> &AllIvarDecls) { 11610 if (LangOpts.ObjCRuntime.isFragile() || AllIvarDecls.empty()) 11611 return; 11612 11613 Decl *ivarDecl = AllIvarDecls[AllIvarDecls.size()-1]; 11614 ObjCIvarDecl *Ivar = cast<ObjCIvarDecl>(ivarDecl); 11615 11616 if (!Ivar->isBitField() || Ivar->getBitWidthValue(Context) == 0) 11617 return; 11618 ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(CurContext); 11619 if (!ID) { 11620 if (ObjCCategoryDecl *CD = dyn_cast<ObjCCategoryDecl>(CurContext)) { 11621 if (!CD->IsClassExtension()) 11622 return; 11623 } 11624 // No need to add this to end of @implementation. 11625 else 11626 return; 11627 } 11628 // All conditions are met. Add a new bitfield to the tail end of ivars. 11629 llvm::APInt Zero(Context.getTypeSize(Context.IntTy), 0); 11630 Expr * BW = IntegerLiteral::Create(Context, Zero, Context.IntTy, DeclLoc); 11631 11632 Ivar = ObjCIvarDecl::Create(Context, cast<ObjCContainerDecl>(CurContext), 11633 DeclLoc, DeclLoc, 0, 11634 Context.CharTy, 11635 Context.getTrivialTypeSourceInfo(Context.CharTy, 11636 DeclLoc), 11637 ObjCIvarDecl::Private, BW, 11638 true); 11639 AllIvarDecls.push_back(Ivar); 11640} 11641 11642void Sema::ActOnFields(Scope *S, SourceLocation RecLoc, Decl *EnclosingDecl, 11643 ArrayRef<Decl *> Fields, SourceLocation LBrac, 11644 SourceLocation RBrac, AttributeList *Attr) { 11645 assert(EnclosingDecl && "missing record or interface decl"); 11646 11647 // If this is an Objective-C @implementation or category and we have 11648 // new fields here we should reset the layout of the interface since 11649 // it will now change. 11650 if (!Fields.empty() && isa<ObjCContainerDecl>(EnclosingDecl)) { 11651 ObjCContainerDecl *DC = cast<ObjCContainerDecl>(EnclosingDecl); 11652 switch (DC->getKind()) { 11653 default: break; 11654 case Decl::ObjCCategory: 11655 Context.ResetObjCLayout(cast<ObjCCategoryDecl>(DC)->getClassInterface()); 11656 break; 11657 case Decl::ObjCImplementation: 11658 Context. 11659 ResetObjCLayout(cast<ObjCImplementationDecl>(DC)->getClassInterface()); 11660 break; 11661 } 11662 } 11663 11664 RecordDecl *Record = dyn_cast<RecordDecl>(EnclosingDecl); 11665 11666 // Start counting up the number of named members; make sure to include 11667 // members of anonymous structs and unions in the total. 11668 unsigned NumNamedMembers = 0; 11669 if (Record) { 11670 for (RecordDecl::decl_iterator i = Record->decls_begin(), 11671 e = Record->decls_end(); i != e; i++) { 11672 if (IndirectFieldDecl *IFD = dyn_cast<IndirectFieldDecl>(*i)) 11673 if (IFD->getDeclName()) 11674 ++NumNamedMembers; 11675 } 11676 } 11677 11678 // Verify that all the fields are okay. 11679 SmallVector<FieldDecl*, 32> RecFields; 11680 11681 bool ARCErrReported = false; 11682 for (ArrayRef<Decl *>::iterator i = Fields.begin(), end = Fields.end(); 11683 i != end; ++i) { 11684 FieldDecl *FD = cast<FieldDecl>(*i); 11685 11686 // Get the type for the field. 11687 const Type *FDTy = FD->getType().getTypePtr(); 11688 11689 if (!FD->isAnonymousStructOrUnion()) { 11690 // Remember all fields written by the user. 11691 RecFields.push_back(FD); 11692 } 11693 11694 // If the field is already invalid for some reason, don't emit more 11695 // diagnostics about it. 11696 if (FD->isInvalidDecl()) { 11697 EnclosingDecl->setInvalidDecl(); 11698 continue; 11699 } 11700 11701 // C99 6.7.2.1p2: 11702 // A structure or union shall not contain a member with 11703 // incomplete or function type (hence, a structure shall not 11704 // contain an instance of itself, but may contain a pointer to 11705 // an instance of itself), except that the last member of a 11706 // structure with more than one named member may have incomplete 11707 // array type; such a structure (and any union containing, 11708 // possibly recursively, a member that is such a structure) 11709 // shall not be a member of a structure or an element of an 11710 // array. 11711 if (FDTy->isFunctionType()) { 11712 // Field declared as a function. 11713 Diag(FD->getLocation(), diag::err_field_declared_as_function) 11714 << FD->getDeclName(); 11715 FD->setInvalidDecl(); 11716 EnclosingDecl->setInvalidDecl(); 11717 continue; 11718 } else if (FDTy->isIncompleteArrayType() && Record && 11719 ((i + 1 == Fields.end() && !Record->isUnion()) || 11720 ((getLangOpts().MicrosoftExt || 11721 getLangOpts().CPlusPlus) && 11722 (i + 1 == Fields.end() || Record->isUnion())))) { 11723 // Flexible array member. 11724 // Microsoft and g++ is more permissive regarding flexible array. 11725 // It will accept flexible array in union and also 11726 // as the sole element of a struct/class. 11727 if (getLangOpts().MicrosoftExt) { 11728 if (Record->isUnion()) 11729 Diag(FD->getLocation(), diag::ext_flexible_array_union_ms) 11730 << FD->getDeclName(); 11731 else if (Fields.size() == 1) 11732 Diag(FD->getLocation(), diag::ext_flexible_array_empty_aggregate_ms) 11733 << FD->getDeclName() << Record->getTagKind(); 11734 } else if (getLangOpts().CPlusPlus) { 11735 if (Record->isUnion()) 11736 Diag(FD->getLocation(), diag::ext_flexible_array_union_gnu) 11737 << FD->getDeclName(); 11738 else if (Fields.size() == 1) 11739 Diag(FD->getLocation(), diag::ext_flexible_array_empty_aggregate_gnu) 11740 << FD->getDeclName() << Record->getTagKind(); 11741 } else if (!getLangOpts().C99) { 11742 if (Record->isUnion()) 11743 Diag(FD->getLocation(), diag::ext_flexible_array_union_gnu) 11744 << FD->getDeclName(); 11745 else 11746 Diag(FD->getLocation(), diag::ext_c99_flexible_array_member) 11747 << FD->getDeclName() << Record->getTagKind(); 11748 } else if (NumNamedMembers < 1) { 11749 Diag(FD->getLocation(), diag::err_flexible_array_empty_struct) 11750 << FD->getDeclName(); 11751 FD->setInvalidDecl(); 11752 EnclosingDecl->setInvalidDecl(); 11753 continue; 11754 } 11755 if (!FD->getType()->isDependentType() && 11756 !Context.getBaseElementType(FD->getType()).isPODType(Context)) { 11757 Diag(FD->getLocation(), diag::err_flexible_array_has_nonpod_type) 11758 << FD->getDeclName() << FD->getType(); 11759 FD->setInvalidDecl(); 11760 EnclosingDecl->setInvalidDecl(); 11761 continue; 11762 } 11763 // Okay, we have a legal flexible array member at the end of the struct. 11764 if (Record) 11765 Record->setHasFlexibleArrayMember(true); 11766 } else if (!FDTy->isDependentType() && 11767 RequireCompleteType(FD->getLocation(), FD->getType(), 11768 diag::err_field_incomplete)) { 11769 // Incomplete type 11770 FD->setInvalidDecl(); 11771 EnclosingDecl->setInvalidDecl(); 11772 continue; 11773 } else if (const RecordType *FDTTy = FDTy->getAs<RecordType>()) { 11774 if (FDTTy->getDecl()->hasFlexibleArrayMember()) { 11775 // If this is a member of a union, then entire union becomes "flexible". 11776 if (Record && Record->isUnion()) { 11777 Record->setHasFlexibleArrayMember(true); 11778 } else { 11779 // If this is a struct/class and this is not the last element, reject 11780 // it. Note that GCC supports variable sized arrays in the middle of 11781 // structures. 11782 if (i + 1 != Fields.end()) 11783 Diag(FD->getLocation(), diag::ext_variable_sized_type_in_struct) 11784 << FD->getDeclName() << FD->getType(); 11785 else { 11786 // We support flexible arrays at the end of structs in 11787 // other structs as an extension. 11788 Diag(FD->getLocation(), diag::ext_flexible_array_in_struct) 11789 << FD->getDeclName(); 11790 if (Record) 11791 Record->setHasFlexibleArrayMember(true); 11792 } 11793 } 11794 } 11795 if (isa<ObjCContainerDecl>(EnclosingDecl) && 11796 RequireNonAbstractType(FD->getLocation(), FD->getType(), 11797 diag::err_abstract_type_in_decl, 11798 AbstractIvarType)) { 11799 // Ivars can not have abstract class types 11800 FD->setInvalidDecl(); 11801 } 11802 if (Record && FDTTy->getDecl()->hasObjectMember()) 11803 Record->setHasObjectMember(true); 11804 if (Record && FDTTy->getDecl()->hasVolatileMember()) 11805 Record->setHasVolatileMember(true); 11806 } else if (FDTy->isObjCObjectType()) { 11807 /// A field cannot be an Objective-c object 11808 Diag(FD->getLocation(), diag::err_statically_allocated_object) 11809 << FixItHint::CreateInsertion(FD->getLocation(), "*"); 11810 QualType T = Context.getObjCObjectPointerType(FD->getType()); 11811 FD->setType(T); 11812 } else if (getLangOpts().ObjCAutoRefCount && Record && !ARCErrReported && 11813 (!getLangOpts().CPlusPlus || Record->isUnion())) { 11814 // It's an error in ARC if a field has lifetime. 11815 // We don't want to report this in a system header, though, 11816 // so we just make the field unavailable. 11817 // FIXME: that's really not sufficient; we need to make the type 11818 // itself invalid to, say, initialize or copy. 11819 QualType T = FD->getType(); 11820 Qualifiers::ObjCLifetime lifetime = T.getObjCLifetime(); 11821 if (lifetime && lifetime != Qualifiers::OCL_ExplicitNone) { 11822 SourceLocation loc = FD->getLocation(); 11823 if (getSourceManager().isInSystemHeader(loc)) { 11824 if (!FD->hasAttr<UnavailableAttr>()) { 11825 FD->addAttr(new (Context) UnavailableAttr(loc, Context, 11826 "this system field has retaining ownership")); 11827 } 11828 } else { 11829 Diag(FD->getLocation(), diag::err_arc_objc_object_in_tag) 11830 << T->isBlockPointerType() << Record->getTagKind(); 11831 } 11832 ARCErrReported = true; 11833 } 11834 } else if (getLangOpts().ObjC1 && 11835 getLangOpts().getGC() != LangOptions::NonGC && 11836 Record && !Record->hasObjectMember()) { 11837 if (FD->getType()->isObjCObjectPointerType() || 11838 FD->getType().isObjCGCStrong()) 11839 Record->setHasObjectMember(true); 11840 else if (Context.getAsArrayType(FD->getType())) { 11841 QualType BaseType = Context.getBaseElementType(FD->getType()); 11842 if (BaseType->isRecordType() && 11843 BaseType->getAs<RecordType>()->getDecl()->hasObjectMember()) 11844 Record->setHasObjectMember(true); 11845 else if (BaseType->isObjCObjectPointerType() || 11846 BaseType.isObjCGCStrong()) 11847 Record->setHasObjectMember(true); 11848 } 11849 } 11850 if (Record && FD->getType().isVolatileQualified()) 11851 Record->setHasVolatileMember(true); 11852 // Keep track of the number of named members. 11853 if (FD->getIdentifier()) 11854 ++NumNamedMembers; 11855 } 11856 11857 // Okay, we successfully defined 'Record'. 11858 if (Record) { 11859 bool Completed = false; 11860 if (CXXRecordDecl *CXXRecord = dyn_cast<CXXRecordDecl>(Record)) { 11861 if (!CXXRecord->isInvalidDecl()) { 11862 // Set access bits correctly on the directly-declared conversions. 11863 for (CXXRecordDecl::conversion_iterator 11864 I = CXXRecord->conversion_begin(), 11865 E = CXXRecord->conversion_end(); I != E; ++I) 11866 I.setAccess((*I)->getAccess()); 11867 11868 if (!CXXRecord->isDependentType()) { 11869 if (CXXRecord->hasUserDeclaredDestructor()) { 11870 // Adjust user-defined destructor exception spec. 11871 if (getLangOpts().CPlusPlus11) 11872 AdjustDestructorExceptionSpec(CXXRecord, 11873 CXXRecord->getDestructor()); 11874 11875 // The Microsoft ABI requires that we perform the destructor body 11876 // checks (i.e. operator delete() lookup) at every declaration, as 11877 // any translation unit may need to emit a deleting destructor. 11878 if (Context.getTargetInfo().getCXXABI().isMicrosoft()) 11879 CheckDestructor(CXXRecord->getDestructor()); 11880 } 11881 11882 // Add any implicitly-declared members to this class. 11883 AddImplicitlyDeclaredMembersToClass(CXXRecord); 11884 11885 // If we have virtual base classes, we may end up finding multiple 11886 // final overriders for a given virtual function. Check for this 11887 // problem now. 11888 if (CXXRecord->getNumVBases()) { 11889 CXXFinalOverriderMap FinalOverriders; 11890 CXXRecord->getFinalOverriders(FinalOverriders); 11891 11892 for (CXXFinalOverriderMap::iterator M = FinalOverriders.begin(), 11893 MEnd = FinalOverriders.end(); 11894 M != MEnd; ++M) { 11895 for (OverridingMethods::iterator SO = M->second.begin(), 11896 SOEnd = M->second.end(); 11897 SO != SOEnd; ++SO) { 11898 assert(SO->second.size() > 0 && 11899 "Virtual function without overridding functions?"); 11900 if (SO->second.size() == 1) 11901 continue; 11902 11903 // C++ [class.virtual]p2: 11904 // In a derived class, if a virtual member function of a base 11905 // class subobject has more than one final overrider the 11906 // program is ill-formed. 11907 Diag(Record->getLocation(), diag::err_multiple_final_overriders) 11908 << (const NamedDecl *)M->first << Record; 11909 Diag(M->first->getLocation(), 11910 diag::note_overridden_virtual_function); 11911 for (OverridingMethods::overriding_iterator 11912 OM = SO->second.begin(), 11913 OMEnd = SO->second.end(); 11914 OM != OMEnd; ++OM) 11915 Diag(OM->Method->getLocation(), diag::note_final_overrider) 11916 << (const NamedDecl *)M->first << OM->Method->getParent(); 11917 11918 Record->setInvalidDecl(); 11919 } 11920 } 11921 CXXRecord->completeDefinition(&FinalOverriders); 11922 Completed = true; 11923 } 11924 } 11925 } 11926 } 11927 11928 if (!Completed) 11929 Record->completeDefinition(); 11930 11931 if (Record->hasAttrs()) 11932 CheckAlignasUnderalignment(Record); 11933 11934 // Check if the structure/union declaration is a language extension. 11935 if (!getLangOpts().CPlusPlus) { 11936 bool ZeroSize = true; 11937 bool IsEmpty = true; 11938 unsigned NonBitFields = 0; 11939 for (RecordDecl::field_iterator I = Record->field_begin(), 11940 E = Record->field_end(); 11941 (NonBitFields == 0 || ZeroSize) && I != E; ++I) { 11942 IsEmpty = false; 11943 if (I->isUnnamedBitfield()) { 11944 if (I->getBitWidthValue(Context) > 0) 11945 ZeroSize = false; 11946 } else { 11947 ++NonBitFields; 11948 QualType FieldType = I->getType(); 11949 if (FieldType->isIncompleteType() || 11950 !Context.getTypeSizeInChars(FieldType).isZero()) 11951 ZeroSize = false; 11952 } 11953 } 11954 11955 // Empty structs are an extension in C (C99 6.7.2.1p7), but are allowed in 11956 // C++. 11957 if (ZeroSize) 11958 Diag(RecLoc, diag::warn_zero_size_struct_union_compat) << IsEmpty 11959 << Record->isUnion() << (NonBitFields > 1); 11960 11961 // Structs without named members are extension in C (C99 6.7.2.1p7), but 11962 // are accepted by GCC. 11963 if (NonBitFields == 0) { 11964 if (IsEmpty) 11965 Diag(RecLoc, diag::ext_empty_struct_union) << Record->isUnion(); 11966 else 11967 Diag(RecLoc, diag::ext_no_named_members_in_struct_union) << Record->isUnion(); 11968 } 11969 } 11970 } else { 11971 ObjCIvarDecl **ClsFields = 11972 reinterpret_cast<ObjCIvarDecl**>(RecFields.data()); 11973 if (ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(EnclosingDecl)) { 11974 ID->setEndOfDefinitionLoc(RBrac); 11975 // Add ivar's to class's DeclContext. 11976 for (unsigned i = 0, e = RecFields.size(); i != e; ++i) { 11977 ClsFields[i]->setLexicalDeclContext(ID); 11978 ID->addDecl(ClsFields[i]); 11979 } 11980 // Must enforce the rule that ivars in the base classes may not be 11981 // duplicates. 11982 if (ID->getSuperClass()) 11983 DiagnoseDuplicateIvars(ID, ID->getSuperClass()); 11984 } else if (ObjCImplementationDecl *IMPDecl = 11985 dyn_cast<ObjCImplementationDecl>(EnclosingDecl)) { 11986 assert(IMPDecl && "ActOnFields - missing ObjCImplementationDecl"); 11987 for (unsigned I = 0, N = RecFields.size(); I != N; ++I) 11988 // Ivar declared in @implementation never belongs to the implementation. 11989 // Only it is in implementation's lexical context. 11990 ClsFields[I]->setLexicalDeclContext(IMPDecl); 11991 CheckImplementationIvars(IMPDecl, ClsFields, RecFields.size(), RBrac); 11992 IMPDecl->setIvarLBraceLoc(LBrac); 11993 IMPDecl->setIvarRBraceLoc(RBrac); 11994 } else if (ObjCCategoryDecl *CDecl = 11995 dyn_cast<ObjCCategoryDecl>(EnclosingDecl)) { 11996 // case of ivars in class extension; all other cases have been 11997 // reported as errors elsewhere. 11998 // FIXME. Class extension does not have a LocEnd field. 11999 // CDecl->setLocEnd(RBrac); 12000 // Add ivar's to class extension's DeclContext. 12001 // Diagnose redeclaration of private ivars. 12002 ObjCInterfaceDecl *IDecl = CDecl->getClassInterface(); 12003 for (unsigned i = 0, e = RecFields.size(); i != e; ++i) { 12004 if (IDecl) { 12005 if (const ObjCIvarDecl *ClsIvar = 12006 IDecl->getIvarDecl(ClsFields[i]->getIdentifier())) { 12007 Diag(ClsFields[i]->getLocation(), 12008 diag::err_duplicate_ivar_declaration); 12009 Diag(ClsIvar->getLocation(), diag::note_previous_definition); 12010 continue; 12011 } 12012 for (ObjCInterfaceDecl::known_extensions_iterator 12013 Ext = IDecl->known_extensions_begin(), 12014 ExtEnd = IDecl->known_extensions_end(); 12015 Ext != ExtEnd; ++Ext) { 12016 if (const ObjCIvarDecl *ClsExtIvar 12017 = Ext->getIvarDecl(ClsFields[i]->getIdentifier())) { 12018 Diag(ClsFields[i]->getLocation(), 12019 diag::err_duplicate_ivar_declaration); 12020 Diag(ClsExtIvar->getLocation(), diag::note_previous_definition); 12021 continue; 12022 } 12023 } 12024 } 12025 ClsFields[i]->setLexicalDeclContext(CDecl); 12026 CDecl->addDecl(ClsFields[i]); 12027 } 12028 CDecl->setIvarLBraceLoc(LBrac); 12029 CDecl->setIvarRBraceLoc(RBrac); 12030 } 12031 } 12032 12033 if (Attr) 12034 ProcessDeclAttributeList(S, Record, Attr); 12035} 12036 12037/// \brief Determine whether the given integral value is representable within 12038/// the given type T. 12039static bool isRepresentableIntegerValue(ASTContext &Context, 12040 llvm::APSInt &Value, 12041 QualType T) { 12042 assert(T->isIntegralType(Context) && "Integral type required!"); 12043 unsigned BitWidth = Context.getIntWidth(T); 12044 12045 if (Value.isUnsigned() || Value.isNonNegative()) { 12046 if (T->isSignedIntegerOrEnumerationType()) 12047 --BitWidth; 12048 return Value.getActiveBits() <= BitWidth; 12049 } 12050 return Value.getMinSignedBits() <= BitWidth; 12051} 12052 12053// \brief Given an integral type, return the next larger integral type 12054// (or a NULL type of no such type exists). 12055static QualType getNextLargerIntegralType(ASTContext &Context, QualType T) { 12056 // FIXME: Int128/UInt128 support, which also needs to be introduced into 12057 // enum checking below. 12058 assert(T->isIntegralType(Context) && "Integral type required!"); 12059 const unsigned NumTypes = 4; 12060 QualType SignedIntegralTypes[NumTypes] = { 12061 Context.ShortTy, Context.IntTy, Context.LongTy, Context.LongLongTy 12062 }; 12063 QualType UnsignedIntegralTypes[NumTypes] = { 12064 Context.UnsignedShortTy, Context.UnsignedIntTy, Context.UnsignedLongTy, 12065 Context.UnsignedLongLongTy 12066 }; 12067 12068 unsigned BitWidth = Context.getTypeSize(T); 12069 QualType *Types = T->isSignedIntegerOrEnumerationType()? SignedIntegralTypes 12070 : UnsignedIntegralTypes; 12071 for (unsigned I = 0; I != NumTypes; ++I) 12072 if (Context.getTypeSize(Types[I]) > BitWidth) 12073 return Types[I]; 12074 12075 return QualType(); 12076} 12077 12078EnumConstantDecl *Sema::CheckEnumConstant(EnumDecl *Enum, 12079 EnumConstantDecl *LastEnumConst, 12080 SourceLocation IdLoc, 12081 IdentifierInfo *Id, 12082 Expr *Val) { 12083 unsigned IntWidth = Context.getTargetInfo().getIntWidth(); 12084 llvm::APSInt EnumVal(IntWidth); 12085 QualType EltTy; 12086 12087 if (Val && DiagnoseUnexpandedParameterPack(Val, UPPC_EnumeratorValue)) 12088 Val = 0; 12089 12090 if (Val) 12091 Val = DefaultLvalueConversion(Val).take(); 12092 12093 if (Val) { 12094 if (Enum->isDependentType() || Val->isTypeDependent()) 12095 EltTy = Context.DependentTy; 12096 else { 12097 SourceLocation ExpLoc; 12098 if (getLangOpts().CPlusPlus11 && Enum->isFixed() && 12099 !getLangOpts().MicrosoftMode) { 12100 // C++11 [dcl.enum]p5: If the underlying type is fixed, [...] the 12101 // constant-expression in the enumerator-definition shall be a converted 12102 // constant expression of the underlying type. 12103 EltTy = Enum->getIntegerType(); 12104 ExprResult Converted = 12105 CheckConvertedConstantExpression(Val, EltTy, EnumVal, 12106 CCEK_Enumerator); 12107 if (Converted.isInvalid()) 12108 Val = 0; 12109 else 12110 Val = Converted.take(); 12111 } else if (!Val->isValueDependent() && 12112 !(Val = VerifyIntegerConstantExpression(Val, 12113 &EnumVal).take())) { 12114 // C99 6.7.2.2p2: Make sure we have an integer constant expression. 12115 } else { 12116 if (Enum->isFixed()) { 12117 EltTy = Enum->getIntegerType(); 12118 12119 // In Obj-C and Microsoft mode, require the enumeration value to be 12120 // representable in the underlying type of the enumeration. In C++11, 12121 // we perform a non-narrowing conversion as part of converted constant 12122 // expression checking. 12123 if (!isRepresentableIntegerValue(Context, EnumVal, EltTy)) { 12124 if (getLangOpts().MicrosoftMode) { 12125 Diag(IdLoc, diag::ext_enumerator_too_large) << EltTy; 12126 Val = ImpCastExprToType(Val, EltTy, CK_IntegralCast).take(); 12127 } else 12128 Diag(IdLoc, diag::err_enumerator_too_large) << EltTy; 12129 } else 12130 Val = ImpCastExprToType(Val, EltTy, CK_IntegralCast).take(); 12131 } else if (getLangOpts().CPlusPlus) { 12132 // C++11 [dcl.enum]p5: 12133 // If the underlying type is not fixed, the type of each enumerator 12134 // is the type of its initializing value: 12135 // - If an initializer is specified for an enumerator, the 12136 // initializing value has the same type as the expression. 12137 EltTy = Val->getType(); 12138 } else { 12139 // C99 6.7.2.2p2: 12140 // The expression that defines the value of an enumeration constant 12141 // shall be an integer constant expression that has a value 12142 // representable as an int. 12143 12144 // Complain if the value is not representable in an int. 12145 if (!isRepresentableIntegerValue(Context, EnumVal, Context.IntTy)) 12146 Diag(IdLoc, diag::ext_enum_value_not_int) 12147 << EnumVal.toString(10) << Val->getSourceRange() 12148 << (EnumVal.isUnsigned() || EnumVal.isNonNegative()); 12149 else if (!Context.hasSameType(Val->getType(), Context.IntTy)) { 12150 // Force the type of the expression to 'int'. 12151 Val = ImpCastExprToType(Val, Context.IntTy, CK_IntegralCast).take(); 12152 } 12153 EltTy = Val->getType(); 12154 } 12155 } 12156 } 12157 } 12158 12159 if (!Val) { 12160 if (Enum->isDependentType()) 12161 EltTy = Context.DependentTy; 12162 else if (!LastEnumConst) { 12163 // C++0x [dcl.enum]p5: 12164 // If the underlying type is not fixed, the type of each enumerator 12165 // is the type of its initializing value: 12166 // - If no initializer is specified for the first enumerator, the 12167 // initializing value has an unspecified integral type. 12168 // 12169 // GCC uses 'int' for its unspecified integral type, as does 12170 // C99 6.7.2.2p3. 12171 if (Enum->isFixed()) { 12172 EltTy = Enum->getIntegerType(); 12173 } 12174 else { 12175 EltTy = Context.IntTy; 12176 } 12177 } else { 12178 // Assign the last value + 1. 12179 EnumVal = LastEnumConst->getInitVal(); 12180 ++EnumVal; 12181 EltTy = LastEnumConst->getType(); 12182 12183 // Check for overflow on increment. 12184 if (EnumVal < LastEnumConst->getInitVal()) { 12185 // C++0x [dcl.enum]p5: 12186 // If the underlying type is not fixed, the type of each enumerator 12187 // is the type of its initializing value: 12188 // 12189 // - Otherwise the type of the initializing value is the same as 12190 // the type of the initializing value of the preceding enumerator 12191 // unless the incremented value is not representable in that type, 12192 // in which case the type is an unspecified integral type 12193 // sufficient to contain the incremented value. If no such type 12194 // exists, the program is ill-formed. 12195 QualType T = getNextLargerIntegralType(Context, EltTy); 12196 if (T.isNull() || Enum->isFixed()) { 12197 // There is no integral type larger enough to represent this 12198 // value. Complain, then allow the value to wrap around. 12199 EnumVal = LastEnumConst->getInitVal(); 12200 EnumVal = EnumVal.zext(EnumVal.getBitWidth() * 2); 12201 ++EnumVal; 12202 if (Enum->isFixed()) 12203 // When the underlying type is fixed, this is ill-formed. 12204 Diag(IdLoc, diag::err_enumerator_wrapped) 12205 << EnumVal.toString(10) 12206 << EltTy; 12207 else 12208 Diag(IdLoc, diag::warn_enumerator_too_large) 12209 << EnumVal.toString(10); 12210 } else { 12211 EltTy = T; 12212 } 12213 12214 // Retrieve the last enumerator's value, extent that type to the 12215 // type that is supposed to be large enough to represent the incremented 12216 // value, then increment. 12217 EnumVal = LastEnumConst->getInitVal(); 12218 EnumVal.setIsSigned(EltTy->isSignedIntegerOrEnumerationType()); 12219 EnumVal = EnumVal.zextOrTrunc(Context.getIntWidth(EltTy)); 12220 ++EnumVal; 12221 12222 // If we're not in C++, diagnose the overflow of enumerator values, 12223 // which in C99 means that the enumerator value is not representable in 12224 // an int (C99 6.7.2.2p2). However, we support GCC's extension that 12225 // permits enumerator values that are representable in some larger 12226 // integral type. 12227 if (!getLangOpts().CPlusPlus && !T.isNull()) 12228 Diag(IdLoc, diag::warn_enum_value_overflow); 12229 } else if (!getLangOpts().CPlusPlus && 12230 !isRepresentableIntegerValue(Context, EnumVal, EltTy)) { 12231 // Enforce C99 6.7.2.2p2 even when we compute the next value. 12232 Diag(IdLoc, diag::ext_enum_value_not_int) 12233 << EnumVal.toString(10) << 1; 12234 } 12235 } 12236 } 12237 12238 if (!EltTy->isDependentType()) { 12239 // Make the enumerator value match the signedness and size of the 12240 // enumerator's type. 12241 EnumVal = EnumVal.extOrTrunc(Context.getIntWidth(EltTy)); 12242 EnumVal.setIsSigned(EltTy->isSignedIntegerOrEnumerationType()); 12243 } 12244 12245 return EnumConstantDecl::Create(Context, Enum, IdLoc, Id, EltTy, 12246 Val, EnumVal); 12247} 12248 12249 12250Decl *Sema::ActOnEnumConstant(Scope *S, Decl *theEnumDecl, Decl *lastEnumConst, 12251 SourceLocation IdLoc, IdentifierInfo *Id, 12252 AttributeList *Attr, 12253 SourceLocation EqualLoc, Expr *Val) { 12254 EnumDecl *TheEnumDecl = cast<EnumDecl>(theEnumDecl); 12255 EnumConstantDecl *LastEnumConst = 12256 cast_or_null<EnumConstantDecl>(lastEnumConst); 12257 12258 // The scope passed in may not be a decl scope. Zip up the scope tree until 12259 // we find one that is. 12260 S = getNonFieldDeclScope(S); 12261 12262 // Verify that there isn't already something declared with this name in this 12263 // scope. 12264 NamedDecl *PrevDecl = LookupSingleName(S, Id, IdLoc, LookupOrdinaryName, 12265 ForRedeclaration); 12266 if (PrevDecl && PrevDecl->isTemplateParameter()) { 12267 // Maybe we will complain about the shadowed template parameter. 12268 DiagnoseTemplateParameterShadow(IdLoc, PrevDecl); 12269 // Just pretend that we didn't see the previous declaration. 12270 PrevDecl = 0; 12271 } 12272 12273 if (PrevDecl) { 12274 // When in C++, we may get a TagDecl with the same name; in this case the 12275 // enum constant will 'hide' the tag. 12276 assert((getLangOpts().CPlusPlus || !isa<TagDecl>(PrevDecl)) && 12277 "Received TagDecl when not in C++!"); 12278 if (!isa<TagDecl>(PrevDecl) && isDeclInScope(PrevDecl, CurContext, S)) { 12279 if (isa<EnumConstantDecl>(PrevDecl)) 12280 Diag(IdLoc, diag::err_redefinition_of_enumerator) << Id; 12281 else 12282 Diag(IdLoc, diag::err_redefinition) << Id; 12283 Diag(PrevDecl->getLocation(), diag::note_previous_definition); 12284 return 0; 12285 } 12286 } 12287 12288 // C++ [class.mem]p15: 12289 // If T is the name of a class, then each of the following shall have a name 12290 // different from T: 12291 // - every enumerator of every member of class T that is an unscoped 12292 // enumerated type 12293 if (CXXRecordDecl *Record 12294 = dyn_cast<CXXRecordDecl>( 12295 TheEnumDecl->getDeclContext()->getRedeclContext())) 12296 if (!TheEnumDecl->isScoped() && 12297 Record->getIdentifier() && Record->getIdentifier() == Id) 12298 Diag(IdLoc, diag::err_member_name_of_class) << Id; 12299 12300 EnumConstantDecl *New = 12301 CheckEnumConstant(TheEnumDecl, LastEnumConst, IdLoc, Id, Val); 12302 12303 if (New) { 12304 // Process attributes. 12305 if (Attr) ProcessDeclAttributeList(S, New, Attr); 12306 12307 // Register this decl in the current scope stack. 12308 New->setAccess(TheEnumDecl->getAccess()); 12309 PushOnScopeChains(New, S); 12310 } 12311 12312 ActOnDocumentableDecl(New); 12313 12314 return New; 12315} 12316 12317// Returns true when the enum initial expression does not trigger the 12318// duplicate enum warning. A few common cases are exempted as follows: 12319// Element2 = Element1 12320// Element2 = Element1 + 1 12321// Element2 = Element1 - 1 12322// Where Element2 and Element1 are from the same enum. 12323static bool ValidDuplicateEnum(EnumConstantDecl *ECD, EnumDecl *Enum) { 12324 Expr *InitExpr = ECD->getInitExpr(); 12325 if (!InitExpr) 12326 return true; 12327 InitExpr = InitExpr->IgnoreImpCasts(); 12328 12329 if (BinaryOperator *BO = dyn_cast<BinaryOperator>(InitExpr)) { 12330 if (!BO->isAdditiveOp()) 12331 return true; 12332 IntegerLiteral *IL = dyn_cast<IntegerLiteral>(BO->getRHS()); 12333 if (!IL) 12334 return true; 12335 if (IL->getValue() != 1) 12336 return true; 12337 12338 InitExpr = BO->getLHS(); 12339 } 12340 12341 // This checks if the elements are from the same enum. 12342 DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(InitExpr); 12343 if (!DRE) 12344 return true; 12345 12346 EnumConstantDecl *EnumConstant = dyn_cast<EnumConstantDecl>(DRE->getDecl()); 12347 if (!EnumConstant) 12348 return true; 12349 12350 if (cast<EnumDecl>(TagDecl::castFromDeclContext(ECD->getDeclContext())) != 12351 Enum) 12352 return true; 12353 12354 return false; 12355} 12356 12357struct DupKey { 12358 int64_t val; 12359 bool isTombstoneOrEmptyKey; 12360 DupKey(int64_t val, bool isTombstoneOrEmptyKey) 12361 : val(val), isTombstoneOrEmptyKey(isTombstoneOrEmptyKey) {} 12362}; 12363 12364static DupKey GetDupKey(const llvm::APSInt& Val) { 12365 return DupKey(Val.isSigned() ? Val.getSExtValue() : Val.getZExtValue(), 12366 false); 12367} 12368 12369struct DenseMapInfoDupKey { 12370 static DupKey getEmptyKey() { return DupKey(0, true); } 12371 static DupKey getTombstoneKey() { return DupKey(1, true); } 12372 static unsigned getHashValue(const DupKey Key) { 12373 return (unsigned)(Key.val * 37); 12374 } 12375 static bool isEqual(const DupKey& LHS, const DupKey& RHS) { 12376 return LHS.isTombstoneOrEmptyKey == RHS.isTombstoneOrEmptyKey && 12377 LHS.val == RHS.val; 12378 } 12379}; 12380 12381// Emits a warning when an element is implicitly set a value that 12382// a previous element has already been set to. 12383static void CheckForDuplicateEnumValues(Sema &S, ArrayRef<Decl *> Elements, 12384 EnumDecl *Enum, 12385 QualType EnumType) { 12386 if (S.Diags.getDiagnosticLevel(diag::warn_duplicate_enum_values, 12387 Enum->getLocation()) == 12388 DiagnosticsEngine::Ignored) 12389 return; 12390 // Avoid anonymous enums 12391 if (!Enum->getIdentifier()) 12392 return; 12393 12394 // Only check for small enums. 12395 if (Enum->getNumPositiveBits() > 63 || Enum->getNumNegativeBits() > 64) 12396 return; 12397 12398 typedef SmallVector<EnumConstantDecl *, 3> ECDVector; 12399 typedef SmallVector<ECDVector *, 3> DuplicatesVector; 12400 12401 typedef llvm::PointerUnion<EnumConstantDecl*, ECDVector*> DeclOrVector; 12402 typedef llvm::DenseMap<DupKey, DeclOrVector, DenseMapInfoDupKey> 12403 ValueToVectorMap; 12404 12405 DuplicatesVector DupVector; 12406 ValueToVectorMap EnumMap; 12407 12408 // Populate the EnumMap with all values represented by enum constants without 12409 // an initialier. 12410 for (unsigned i = 0, e = Elements.size(); i != e; ++i) { 12411 EnumConstantDecl *ECD = cast_or_null<EnumConstantDecl>(Elements[i]); 12412 12413 // Null EnumConstantDecl means a previous diagnostic has been emitted for 12414 // this constant. Skip this enum since it may be ill-formed. 12415 if (!ECD) { 12416 return; 12417 } 12418 12419 if (ECD->getInitExpr()) 12420 continue; 12421 12422 DupKey Key = GetDupKey(ECD->getInitVal()); 12423 DeclOrVector &Entry = EnumMap[Key]; 12424 12425 // First time encountering this value. 12426 if (Entry.isNull()) 12427 Entry = ECD; 12428 } 12429 12430 // Create vectors for any values that has duplicates. 12431 for (unsigned i = 0, e = Elements.size(); i != e; ++i) { 12432 EnumConstantDecl *ECD = cast<EnumConstantDecl>(Elements[i]); 12433 if (!ValidDuplicateEnum(ECD, Enum)) 12434 continue; 12435 12436 DupKey Key = GetDupKey(ECD->getInitVal()); 12437 12438 DeclOrVector& Entry = EnumMap[Key]; 12439 if (Entry.isNull()) 12440 continue; 12441 12442 if (EnumConstantDecl *D = Entry.dyn_cast<EnumConstantDecl*>()) { 12443 // Ensure constants are different. 12444 if (D == ECD) 12445 continue; 12446 12447 // Create new vector and push values onto it. 12448 ECDVector *Vec = new ECDVector(); 12449 Vec->push_back(D); 12450 Vec->push_back(ECD); 12451 12452 // Update entry to point to the duplicates vector. 12453 Entry = Vec; 12454 12455 // Store the vector somewhere we can consult later for quick emission of 12456 // diagnostics. 12457 DupVector.push_back(Vec); 12458 continue; 12459 } 12460 12461 ECDVector *Vec = Entry.get<ECDVector*>(); 12462 // Make sure constants are not added more than once. 12463 if (*Vec->begin() == ECD) 12464 continue; 12465 12466 Vec->push_back(ECD); 12467 } 12468 12469 // Emit diagnostics. 12470 for (DuplicatesVector::iterator DupVectorIter = DupVector.begin(), 12471 DupVectorEnd = DupVector.end(); 12472 DupVectorIter != DupVectorEnd; ++DupVectorIter) { 12473 ECDVector *Vec = *DupVectorIter; 12474 assert(Vec->size() > 1 && "ECDVector should have at least 2 elements."); 12475 12476 // Emit warning for one enum constant. 12477 ECDVector::iterator I = Vec->begin(); 12478 S.Diag((*I)->getLocation(), diag::warn_duplicate_enum_values) 12479 << (*I)->getName() << (*I)->getInitVal().toString(10) 12480 << (*I)->getSourceRange(); 12481 ++I; 12482 12483 // Emit one note for each of the remaining enum constants with 12484 // the same value. 12485 for (ECDVector::iterator E = Vec->end(); I != E; ++I) 12486 S.Diag((*I)->getLocation(), diag::note_duplicate_element) 12487 << (*I)->getName() << (*I)->getInitVal().toString(10) 12488 << (*I)->getSourceRange(); 12489 delete Vec; 12490 } 12491} 12492 12493void Sema::ActOnEnumBody(SourceLocation EnumLoc, SourceLocation LBraceLoc, 12494 SourceLocation RBraceLoc, Decl *EnumDeclX, 12495 ArrayRef<Decl *> Elements, 12496 Scope *S, AttributeList *Attr) { 12497 EnumDecl *Enum = cast<EnumDecl>(EnumDeclX); 12498 QualType EnumType = Context.getTypeDeclType(Enum); 12499 12500 if (Attr) 12501 ProcessDeclAttributeList(S, Enum, Attr); 12502 12503 if (Enum->isDependentType()) { 12504 for (unsigned i = 0, e = Elements.size(); i != e; ++i) { 12505 EnumConstantDecl *ECD = 12506 cast_or_null<EnumConstantDecl>(Elements[i]); 12507 if (!ECD) continue; 12508 12509 ECD->setType(EnumType); 12510 } 12511 12512 Enum->completeDefinition(Context.DependentTy, Context.DependentTy, 0, 0); 12513 return; 12514 } 12515 12516 // TODO: If the result value doesn't fit in an int, it must be a long or long 12517 // long value. ISO C does not support this, but GCC does as an extension, 12518 // emit a warning. 12519 unsigned IntWidth = Context.getTargetInfo().getIntWidth(); 12520 unsigned CharWidth = Context.getTargetInfo().getCharWidth(); 12521 unsigned ShortWidth = Context.getTargetInfo().getShortWidth(); 12522 12523 // Verify that all the values are okay, compute the size of the values, and 12524 // reverse the list. 12525 unsigned NumNegativeBits = 0; 12526 unsigned NumPositiveBits = 0; 12527 12528 // Keep track of whether all elements have type int. 12529 bool AllElementsInt = true; 12530 12531 for (unsigned i = 0, e = Elements.size(); i != e; ++i) { 12532 EnumConstantDecl *ECD = 12533 cast_or_null<EnumConstantDecl>(Elements[i]); 12534 if (!ECD) continue; // Already issued a diagnostic. 12535 12536 const llvm::APSInt &InitVal = ECD->getInitVal(); 12537 12538 // Keep track of the size of positive and negative values. 12539 if (InitVal.isUnsigned() || InitVal.isNonNegative()) 12540 NumPositiveBits = std::max(NumPositiveBits, 12541 (unsigned)InitVal.getActiveBits()); 12542 else 12543 NumNegativeBits = std::max(NumNegativeBits, 12544 (unsigned)InitVal.getMinSignedBits()); 12545 12546 // Keep track of whether every enum element has type int (very commmon). 12547 if (AllElementsInt) 12548 AllElementsInt = ECD->getType() == Context.IntTy; 12549 } 12550 12551 // Figure out the type that should be used for this enum. 12552 QualType BestType; 12553 unsigned BestWidth; 12554 12555 // C++0x N3000 [conv.prom]p3: 12556 // An rvalue of an unscoped enumeration type whose underlying 12557 // type is not fixed can be converted to an rvalue of the first 12558 // of the following types that can represent all the values of 12559 // the enumeration: int, unsigned int, long int, unsigned long 12560 // int, long long int, or unsigned long long int. 12561 // C99 6.4.4.3p2: 12562 // An identifier declared as an enumeration constant has type int. 12563 // The C99 rule is modified by a gcc extension 12564 QualType BestPromotionType; 12565 12566 bool Packed = Enum->getAttr<PackedAttr>() ? true : false; 12567 // -fshort-enums is the equivalent to specifying the packed attribute on all 12568 // enum definitions. 12569 if (LangOpts.ShortEnums) 12570 Packed = true; 12571 12572 if (Enum->isFixed()) { 12573 BestType = Enum->getIntegerType(); 12574 if (BestType->isPromotableIntegerType()) 12575 BestPromotionType = Context.getPromotedIntegerType(BestType); 12576 else 12577 BestPromotionType = BestType; 12578 // We don't need to set BestWidth, because BestType is going to be the type 12579 // of the enumerators, but we do anyway because otherwise some compilers 12580 // warn that it might be used uninitialized. 12581 BestWidth = CharWidth; 12582 } 12583 else if (NumNegativeBits) { 12584 // If there is a negative value, figure out the smallest integer type (of 12585 // int/long/longlong) that fits. 12586 // If it's packed, check also if it fits a char or a short. 12587 if (Packed && NumNegativeBits <= CharWidth && NumPositiveBits < CharWidth) { 12588 BestType = Context.SignedCharTy; 12589 BestWidth = CharWidth; 12590 } else if (Packed && NumNegativeBits <= ShortWidth && 12591 NumPositiveBits < ShortWidth) { 12592 BestType = Context.ShortTy; 12593 BestWidth = ShortWidth; 12594 } else if (NumNegativeBits <= IntWidth && NumPositiveBits < IntWidth) { 12595 BestType = Context.IntTy; 12596 BestWidth = IntWidth; 12597 } else { 12598 BestWidth = Context.getTargetInfo().getLongWidth(); 12599 12600 if (NumNegativeBits <= BestWidth && NumPositiveBits < BestWidth) { 12601 BestType = Context.LongTy; 12602 } else { 12603 BestWidth = Context.getTargetInfo().getLongLongWidth(); 12604 12605 if (NumNegativeBits > BestWidth || NumPositiveBits >= BestWidth) 12606 Diag(Enum->getLocation(), diag::warn_enum_too_large); 12607 BestType = Context.LongLongTy; 12608 } 12609 } 12610 BestPromotionType = (BestWidth <= IntWidth ? Context.IntTy : BestType); 12611 } else { 12612 // If there is no negative value, figure out the smallest type that fits 12613 // all of the enumerator values. 12614 // If it's packed, check also if it fits a char or a short. 12615 if (Packed && NumPositiveBits <= CharWidth) { 12616 BestType = Context.UnsignedCharTy; 12617 BestPromotionType = Context.IntTy; 12618 BestWidth = CharWidth; 12619 } else if (Packed && NumPositiveBits <= ShortWidth) { 12620 BestType = Context.UnsignedShortTy; 12621 BestPromotionType = Context.IntTy; 12622 BestWidth = ShortWidth; 12623 } else if (NumPositiveBits <= IntWidth) { 12624 BestType = Context.UnsignedIntTy; 12625 BestWidth = IntWidth; 12626 BestPromotionType 12627 = (NumPositiveBits == BestWidth || !getLangOpts().CPlusPlus) 12628 ? Context.UnsignedIntTy : Context.IntTy; 12629 } else if (NumPositiveBits <= 12630 (BestWidth = Context.getTargetInfo().getLongWidth())) { 12631 BestType = Context.UnsignedLongTy; 12632 BestPromotionType 12633 = (NumPositiveBits == BestWidth || !getLangOpts().CPlusPlus) 12634 ? Context.UnsignedLongTy : Context.LongTy; 12635 } else { 12636 BestWidth = Context.getTargetInfo().getLongLongWidth(); 12637 assert(NumPositiveBits <= BestWidth && 12638 "How could an initializer get larger than ULL?"); 12639 BestType = Context.UnsignedLongLongTy; 12640 BestPromotionType 12641 = (NumPositiveBits == BestWidth || !getLangOpts().CPlusPlus) 12642 ? Context.UnsignedLongLongTy : Context.LongLongTy; 12643 } 12644 } 12645 12646 // Loop over all of the enumerator constants, changing their types to match 12647 // the type of the enum if needed. 12648 for (unsigned i = 0, e = Elements.size(); i != e; ++i) { 12649 EnumConstantDecl *ECD = cast_or_null<EnumConstantDecl>(Elements[i]); 12650 if (!ECD) continue; // Already issued a diagnostic. 12651 12652 // Standard C says the enumerators have int type, but we allow, as an 12653 // extension, the enumerators to be larger than int size. If each 12654 // enumerator value fits in an int, type it as an int, otherwise type it the 12655 // same as the enumerator decl itself. This means that in "enum { X = 1U }" 12656 // that X has type 'int', not 'unsigned'. 12657 12658 // Determine whether the value fits into an int. 12659 llvm::APSInt InitVal = ECD->getInitVal(); 12660 12661 // If it fits into an integer type, force it. Otherwise force it to match 12662 // the enum decl type. 12663 QualType NewTy; 12664 unsigned NewWidth; 12665 bool NewSign; 12666 if (!getLangOpts().CPlusPlus && 12667 !Enum->isFixed() && 12668 isRepresentableIntegerValue(Context, InitVal, Context.IntTy)) { 12669 NewTy = Context.IntTy; 12670 NewWidth = IntWidth; 12671 NewSign = true; 12672 } else if (ECD->getType() == BestType) { 12673 // Already the right type! 12674 if (getLangOpts().CPlusPlus) 12675 // C++ [dcl.enum]p4: Following the closing brace of an 12676 // enum-specifier, each enumerator has the type of its 12677 // enumeration. 12678 ECD->setType(EnumType); 12679 continue; 12680 } else { 12681 NewTy = BestType; 12682 NewWidth = BestWidth; 12683 NewSign = BestType->isSignedIntegerOrEnumerationType(); 12684 } 12685 12686 // Adjust the APSInt value. 12687 InitVal = InitVal.extOrTrunc(NewWidth); 12688 InitVal.setIsSigned(NewSign); 12689 ECD->setInitVal(InitVal); 12690 12691 // Adjust the Expr initializer and type. 12692 if (ECD->getInitExpr() && 12693 !Context.hasSameType(NewTy, ECD->getInitExpr()->getType())) 12694 ECD->setInitExpr(ImplicitCastExpr::Create(Context, NewTy, 12695 CK_IntegralCast, 12696 ECD->getInitExpr(), 12697 /*base paths*/ 0, 12698 VK_RValue)); 12699 if (getLangOpts().CPlusPlus) 12700 // C++ [dcl.enum]p4: Following the closing brace of an 12701 // enum-specifier, each enumerator has the type of its 12702 // enumeration. 12703 ECD->setType(EnumType); 12704 else 12705 ECD->setType(NewTy); 12706 } 12707 12708 Enum->completeDefinition(BestType, BestPromotionType, 12709 NumPositiveBits, NumNegativeBits); 12710 12711 // If we're declaring a function, ensure this decl isn't forgotten about - 12712 // it needs to go into the function scope. 12713 if (InFunctionDeclarator) 12714 DeclsInPrototypeScope.push_back(Enum); 12715 12716 CheckForDuplicateEnumValues(*this, Elements, Enum, EnumType); 12717 12718 // Now that the enum type is defined, ensure it's not been underaligned. 12719 if (Enum->hasAttrs()) 12720 CheckAlignasUnderalignment(Enum); 12721} 12722 12723Decl *Sema::ActOnFileScopeAsmDecl(Expr *expr, 12724 SourceLocation StartLoc, 12725 SourceLocation EndLoc) { 12726 StringLiteral *AsmString = cast<StringLiteral>(expr); 12727 12728 FileScopeAsmDecl *New = FileScopeAsmDecl::Create(Context, CurContext, 12729 AsmString, StartLoc, 12730 EndLoc); 12731 CurContext->addDecl(New); 12732 return New; 12733} 12734 12735DeclResult Sema::ActOnModuleImport(SourceLocation AtLoc, 12736 SourceLocation ImportLoc, 12737 ModuleIdPath Path) { 12738 Module *Mod = PP.getModuleLoader().loadModule(ImportLoc, Path, 12739 Module::AllVisible, 12740 /*IsIncludeDirective=*/false); 12741 if (!Mod) 12742 return true; 12743 12744 SmallVector<SourceLocation, 2> IdentifierLocs; 12745 Module *ModCheck = Mod; 12746 for (unsigned I = 0, N = Path.size(); I != N; ++I) { 12747 // If we've run out of module parents, just drop the remaining identifiers. 12748 // We need the length to be consistent. 12749 if (!ModCheck) 12750 break; 12751 ModCheck = ModCheck->Parent; 12752 12753 IdentifierLocs.push_back(Path[I].second); 12754 } 12755 12756 ImportDecl *Import = ImportDecl::Create(Context, 12757 Context.getTranslationUnitDecl(), 12758 AtLoc.isValid()? AtLoc : ImportLoc, 12759 Mod, IdentifierLocs); 12760 Context.getTranslationUnitDecl()->addDecl(Import); 12761 return Import; 12762} 12763 12764void Sema::createImplicitModuleImport(SourceLocation Loc, Module *Mod) { 12765 // Create the implicit import declaration. 12766 TranslationUnitDecl *TU = getASTContext().getTranslationUnitDecl(); 12767 ImportDecl *ImportD = ImportDecl::CreateImplicit(getASTContext(), TU, 12768 Loc, Mod, Loc); 12769 TU->addDecl(ImportD); 12770 Consumer.HandleImplicitImportDecl(ImportD); 12771 12772 // Make the module visible. 12773 PP.getModuleLoader().makeModuleVisible(Mod, Module::AllVisible, Loc, 12774 /*Complain=*/false); 12775} 12776 12777void Sema::ActOnPragmaRedefineExtname(IdentifierInfo* Name, 12778 IdentifierInfo* AliasName, 12779 SourceLocation PragmaLoc, 12780 SourceLocation NameLoc, 12781 SourceLocation AliasNameLoc) { 12782 Decl *PrevDecl = LookupSingleName(TUScope, Name, NameLoc, 12783 LookupOrdinaryName); 12784 AsmLabelAttr *Attr = 12785 ::new (Context) AsmLabelAttr(AliasNameLoc, Context, AliasName->getName()); 12786 12787 if (PrevDecl) 12788 PrevDecl->addAttr(Attr); 12789 else 12790 (void)ExtnameUndeclaredIdentifiers.insert( 12791 std::pair<IdentifierInfo*,AsmLabelAttr*>(Name, Attr)); 12792} 12793 12794void Sema::ActOnPragmaWeakID(IdentifierInfo* Name, 12795 SourceLocation PragmaLoc, 12796 SourceLocation NameLoc) { 12797 Decl *PrevDecl = LookupSingleName(TUScope, Name, NameLoc, LookupOrdinaryName); 12798 12799 if (PrevDecl) { 12800 PrevDecl->addAttr(::new (Context) WeakAttr(PragmaLoc, Context)); 12801 } else { 12802 (void)WeakUndeclaredIdentifiers.insert( 12803 std::pair<IdentifierInfo*,WeakInfo> 12804 (Name, WeakInfo((IdentifierInfo*)0, NameLoc))); 12805 } 12806} 12807 12808void Sema::ActOnPragmaWeakAlias(IdentifierInfo* Name, 12809 IdentifierInfo* AliasName, 12810 SourceLocation PragmaLoc, 12811 SourceLocation NameLoc, 12812 SourceLocation AliasNameLoc) { 12813 Decl *PrevDecl = LookupSingleName(TUScope, AliasName, AliasNameLoc, 12814 LookupOrdinaryName); 12815 WeakInfo W = WeakInfo(Name, NameLoc); 12816 12817 if (PrevDecl) { 12818 if (!PrevDecl->hasAttr<AliasAttr>()) 12819 if (NamedDecl *ND = dyn_cast<NamedDecl>(PrevDecl)) 12820 DeclApplyPragmaWeak(TUScope, ND, W); 12821 } else { 12822 (void)WeakUndeclaredIdentifiers.insert( 12823 std::pair<IdentifierInfo*,WeakInfo>(AliasName, W)); 12824 } 12825} 12826 12827Decl *Sema::getObjCDeclContext() const { 12828 return (dyn_cast_or_null<ObjCContainerDecl>(CurContext)); 12829} 12830 12831AvailabilityResult Sema::getCurContextAvailability() const { 12832 const Decl *D = cast<Decl>(getCurObjCLexicalContext()); 12833 return D->getAvailability(); 12834} 12835