SemaDecl.cpp revision a2770ab2cfee53805ff603681317c425389356c2
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 = 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() && S->getEntity()->isTransparentContext()) 1021 S = S->getParent(); 1022 1023 // Add scoped declarations into their context, so that they can be 1024 // found later. Declarations without a context won't be inserted 1025 // into any context. 1026 if (AddToContext) 1027 CurContext->addDecl(D); 1028 1029 // Out-of-line definitions shouldn't be pushed into scope in C++, unless they 1030 // are function-local declarations. 1031 if (getLangOpts().CPlusPlus && D->isOutOfLine() && 1032 !D->getDeclContext()->getRedeclContext()->Equals( 1033 D->getLexicalDeclContext()->getRedeclContext()) && 1034 !D->getLexicalDeclContext()->isFunctionOrMethod()) 1035 return; 1036 1037 // Template instantiations should also not be pushed into scope. 1038 if (isa<FunctionDecl>(D) && 1039 cast<FunctionDecl>(D)->isFunctionTemplateSpecialization()) 1040 return; 1041 1042 // If this replaces anything in the current scope, 1043 IdentifierResolver::iterator I = IdResolver.begin(D->getDeclName()), 1044 IEnd = IdResolver.end(); 1045 for (; I != IEnd; ++I) { 1046 if (S->isDeclScope(*I) && D->declarationReplaces(*I)) { 1047 S->RemoveDecl(*I); 1048 IdResolver.RemoveDecl(*I); 1049 1050 // Should only need to replace one decl. 1051 break; 1052 } 1053 } 1054 1055 S->AddDecl(D); 1056 1057 if (isa<LabelDecl>(D) && !cast<LabelDecl>(D)->isGnuLocal()) { 1058 // Implicitly-generated labels may end up getting generated in an order that 1059 // isn't strictly lexical, which breaks name lookup. Be careful to insert 1060 // the label at the appropriate place in the identifier chain. 1061 for (I = IdResolver.begin(D->getDeclName()); I != IEnd; ++I) { 1062 DeclContext *IDC = (*I)->getLexicalDeclContext()->getRedeclContext(); 1063 if (IDC == CurContext) { 1064 if (!S->isDeclScope(*I)) 1065 continue; 1066 } else if (IDC->Encloses(CurContext)) 1067 break; 1068 } 1069 1070 IdResolver.InsertDeclAfter(I, D); 1071 } else { 1072 IdResolver.AddDecl(D); 1073 } 1074} 1075 1076void Sema::pushExternalDeclIntoScope(NamedDecl *D, DeclarationName Name) { 1077 if (IdResolver.tryAddTopLevelDecl(D, Name) && TUScope) 1078 TUScope->AddDecl(D); 1079} 1080 1081bool Sema::isDeclInScope(NamedDecl *D, DeclContext *Ctx, Scope *S, 1082 bool ExplicitInstantiationOrSpecialization) { 1083 return IdResolver.isDeclInScope(D, Ctx, S, 1084 ExplicitInstantiationOrSpecialization); 1085} 1086 1087Scope *Sema::getScopeForDeclContext(Scope *S, DeclContext *DC) { 1088 DeclContext *TargetDC = DC->getPrimaryContext(); 1089 do { 1090 if (DeclContext *ScopeDC = S->getEntity()) 1091 if (ScopeDC->getPrimaryContext() == TargetDC) 1092 return S; 1093 } while ((S = S->getParent())); 1094 1095 return 0; 1096} 1097 1098static bool isOutOfScopePreviousDeclaration(NamedDecl *, 1099 DeclContext*, 1100 ASTContext&); 1101 1102/// Filters out lookup results that don't fall within the given scope 1103/// as determined by isDeclInScope. 1104void Sema::FilterLookupForScope(LookupResult &R, 1105 DeclContext *Ctx, Scope *S, 1106 bool ConsiderLinkage, 1107 bool ExplicitInstantiationOrSpecialization) { 1108 LookupResult::Filter F = R.makeFilter(); 1109 while (F.hasNext()) { 1110 NamedDecl *D = F.next(); 1111 1112 if (isDeclInScope(D, Ctx, S, ExplicitInstantiationOrSpecialization)) 1113 continue; 1114 1115 if (ConsiderLinkage && 1116 isOutOfScopePreviousDeclaration(D, Ctx, Context)) 1117 continue; 1118 1119 F.erase(); 1120 } 1121 1122 F.done(); 1123} 1124 1125static bool isUsingDecl(NamedDecl *D) { 1126 return isa<UsingShadowDecl>(D) || 1127 isa<UnresolvedUsingTypenameDecl>(D) || 1128 isa<UnresolvedUsingValueDecl>(D); 1129} 1130 1131/// Removes using shadow declarations from the lookup results. 1132static void RemoveUsingDecls(LookupResult &R) { 1133 LookupResult::Filter F = R.makeFilter(); 1134 while (F.hasNext()) 1135 if (isUsingDecl(F.next())) 1136 F.erase(); 1137 1138 F.done(); 1139} 1140 1141/// \brief Check for this common pattern: 1142/// @code 1143/// class S { 1144/// S(const S&); // DO NOT IMPLEMENT 1145/// void operator=(const S&); // DO NOT IMPLEMENT 1146/// }; 1147/// @endcode 1148static bool IsDisallowedCopyOrAssign(const CXXMethodDecl *D) { 1149 // FIXME: Should check for private access too but access is set after we get 1150 // the decl here. 1151 if (D->doesThisDeclarationHaveABody()) 1152 return false; 1153 1154 if (const CXXConstructorDecl *CD = dyn_cast<CXXConstructorDecl>(D)) 1155 return CD->isCopyConstructor(); 1156 if (const CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D)) 1157 return Method->isCopyAssignmentOperator(); 1158 return false; 1159} 1160 1161// We need this to handle 1162// 1163// typedef struct { 1164// void *foo() { return 0; } 1165// } A; 1166// 1167// When we see foo we don't know if after the typedef we will get 'A' or '*A' 1168// for example. If 'A', foo will have external linkage. If we have '*A', 1169// foo will have no linkage. Since we can't know untill we get to the end 1170// of the typedef, this function finds out if D might have non external linkage. 1171// Callers should verify at the end of the TU if it D has external linkage or 1172// not. 1173bool Sema::mightHaveNonExternalLinkage(const DeclaratorDecl *D) { 1174 const DeclContext *DC = D->getDeclContext(); 1175 while (!DC->isTranslationUnit()) { 1176 if (const RecordDecl *RD = dyn_cast<RecordDecl>(DC)){ 1177 if (!RD->hasNameForLinkage()) 1178 return true; 1179 } 1180 DC = DC->getParent(); 1181 } 1182 1183 return !D->isExternallyVisible(); 1184} 1185 1186// FIXME: This needs to be refactored; some other isInMainFile users want 1187// these semantics. 1188static bool isMainFileLoc(const Sema &S, SourceLocation Loc) { 1189 if (S.TUKind != TU_Complete) 1190 return false; 1191 return S.SourceMgr.isInMainFile(Loc); 1192} 1193 1194bool Sema::ShouldWarnIfUnusedFileScopedDecl(const DeclaratorDecl *D) const { 1195 assert(D); 1196 1197 if (D->isInvalidDecl() || D->isUsed() || D->hasAttr<UnusedAttr>()) 1198 return false; 1199 1200 // Ignore class templates. 1201 if (D->getDeclContext()->isDependentContext() || 1202 D->getLexicalDeclContext()->isDependentContext()) 1203 return false; 1204 1205 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) { 1206 if (FD->getTemplateSpecializationKind() == TSK_ImplicitInstantiation) 1207 return false; 1208 1209 if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) { 1210 if (MD->isVirtual() || IsDisallowedCopyOrAssign(MD)) 1211 return false; 1212 } else { 1213 // 'static inline' functions are defined in headers; don't warn. 1214 if (FD->isInlineSpecified() && 1215 !isMainFileLoc(*this, FD->getLocation())) 1216 return false; 1217 } 1218 1219 if (FD->doesThisDeclarationHaveABody() && 1220 Context.DeclMustBeEmitted(FD)) 1221 return false; 1222 } else if (const VarDecl *VD = dyn_cast<VarDecl>(D)) { 1223 // Constants and utility variables are defined in headers with internal 1224 // linkage; don't warn. (Unlike functions, there isn't a convenient marker 1225 // like "inline".) 1226 if (!isMainFileLoc(*this, VD->getLocation())) 1227 return false; 1228 1229 if (Context.DeclMustBeEmitted(VD)) 1230 return false; 1231 1232 if (VD->isStaticDataMember() && 1233 VD->getTemplateSpecializationKind() == TSK_ImplicitInstantiation) 1234 return false; 1235 } else { 1236 return false; 1237 } 1238 1239 // Only warn for unused decls internal to the translation unit. 1240 return mightHaveNonExternalLinkage(D); 1241} 1242 1243void Sema::MarkUnusedFileScopedDecl(const DeclaratorDecl *D) { 1244 if (!D) 1245 return; 1246 1247 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) { 1248 const FunctionDecl *First = FD->getFirstDecl(); 1249 if (FD != First && ShouldWarnIfUnusedFileScopedDecl(First)) 1250 return; // First should already be in the vector. 1251 } 1252 1253 if (const VarDecl *VD = dyn_cast<VarDecl>(D)) { 1254 const VarDecl *First = VD->getFirstDecl(); 1255 if (VD != First && ShouldWarnIfUnusedFileScopedDecl(First)) 1256 return; // First should already be in the vector. 1257 } 1258 1259 if (ShouldWarnIfUnusedFileScopedDecl(D)) 1260 UnusedFileScopedDecls.push_back(D); 1261} 1262 1263static bool ShouldDiagnoseUnusedDecl(const NamedDecl *D) { 1264 if (D->isInvalidDecl()) 1265 return false; 1266 1267 if (D->isReferenced() || D->isUsed() || D->hasAttr<UnusedAttr>()) 1268 return false; 1269 1270 if (isa<LabelDecl>(D)) 1271 return true; 1272 1273 // White-list anything that isn't a local variable. 1274 if (!isa<VarDecl>(D) || isa<ParmVarDecl>(D) || isa<ImplicitParamDecl>(D) || 1275 !D->getDeclContext()->isFunctionOrMethod()) 1276 return false; 1277 1278 // Types of valid local variables should be complete, so this should succeed. 1279 if (const VarDecl *VD = dyn_cast<VarDecl>(D)) { 1280 1281 // White-list anything with an __attribute__((unused)) type. 1282 QualType Ty = VD->getType(); 1283 1284 // Only look at the outermost level of typedef. 1285 if (const TypedefType *TT = Ty->getAs<TypedefType>()) { 1286 if (TT->getDecl()->hasAttr<UnusedAttr>()) 1287 return false; 1288 } 1289 1290 // If we failed to complete the type for some reason, or if the type is 1291 // dependent, don't diagnose the variable. 1292 if (Ty->isIncompleteType() || Ty->isDependentType()) 1293 return false; 1294 1295 if (const TagType *TT = Ty->getAs<TagType>()) { 1296 const TagDecl *Tag = TT->getDecl(); 1297 if (Tag->hasAttr<UnusedAttr>()) 1298 return false; 1299 1300 if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(Tag)) { 1301 if (!RD->hasTrivialDestructor() && !RD->hasAttr<WarnUnusedAttr>()) 1302 return false; 1303 1304 if (const Expr *Init = VD->getInit()) { 1305 if (const ExprWithCleanups *Cleanups = dyn_cast<ExprWithCleanups>(Init)) 1306 Init = Cleanups->getSubExpr(); 1307 const CXXConstructExpr *Construct = 1308 dyn_cast<CXXConstructExpr>(Init); 1309 if (Construct && !Construct->isElidable()) { 1310 CXXConstructorDecl *CD = Construct->getConstructor(); 1311 if (!CD->isTrivial() && !RD->hasAttr<WarnUnusedAttr>()) 1312 return false; 1313 } 1314 } 1315 } 1316 } 1317 1318 // TODO: __attribute__((unused)) templates? 1319 } 1320 1321 return true; 1322} 1323 1324static void GenerateFixForUnusedDecl(const NamedDecl *D, ASTContext &Ctx, 1325 FixItHint &Hint) { 1326 if (isa<LabelDecl>(D)) { 1327 SourceLocation AfterColon = Lexer::findLocationAfterToken(D->getLocEnd(), 1328 tok::colon, Ctx.getSourceManager(), Ctx.getLangOpts(), true); 1329 if (AfterColon.isInvalid()) 1330 return; 1331 Hint = FixItHint::CreateRemoval(CharSourceRange:: 1332 getCharRange(D->getLocStart(), AfterColon)); 1333 } 1334 return; 1335} 1336 1337/// DiagnoseUnusedDecl - Emit warnings about declarations that are not used 1338/// unless they are marked attr(unused). 1339void Sema::DiagnoseUnusedDecl(const NamedDecl *D) { 1340 FixItHint Hint; 1341 if (!ShouldDiagnoseUnusedDecl(D)) 1342 return; 1343 1344 GenerateFixForUnusedDecl(D, Context, Hint); 1345 1346 unsigned DiagID; 1347 if (isa<VarDecl>(D) && cast<VarDecl>(D)->isExceptionVariable()) 1348 DiagID = diag::warn_unused_exception_param; 1349 else if (isa<LabelDecl>(D)) 1350 DiagID = diag::warn_unused_label; 1351 else 1352 DiagID = diag::warn_unused_variable; 1353 1354 Diag(D->getLocation(), DiagID) << D->getDeclName() << Hint; 1355} 1356 1357static void CheckPoppedLabel(LabelDecl *L, Sema &S) { 1358 // Verify that we have no forward references left. If so, there was a goto 1359 // or address of a label taken, but no definition of it. Label fwd 1360 // definitions are indicated with a null substmt. 1361 if (L->getStmt() == 0) 1362 S.Diag(L->getLocation(), diag::err_undeclared_label_use) <<L->getDeclName(); 1363} 1364 1365void Sema::ActOnPopScope(SourceLocation Loc, Scope *S) { 1366 if (S->decl_empty()) return; 1367 assert((S->getFlags() & (Scope::DeclScope | Scope::TemplateParamScope)) && 1368 "Scope shouldn't contain decls!"); 1369 1370 for (Scope::decl_iterator I = S->decl_begin(), E = S->decl_end(); 1371 I != E; ++I) { 1372 Decl *TmpD = (*I); 1373 assert(TmpD && "This decl didn't get pushed??"); 1374 1375 assert(isa<NamedDecl>(TmpD) && "Decl isn't NamedDecl?"); 1376 NamedDecl *D = cast<NamedDecl>(TmpD); 1377 1378 if (!D->getDeclName()) continue; 1379 1380 // Diagnose unused variables in this scope. 1381 if (!S->hasUnrecoverableErrorOccurred()) 1382 DiagnoseUnusedDecl(D); 1383 1384 // If this was a forward reference to a label, verify it was defined. 1385 if (LabelDecl *LD = dyn_cast<LabelDecl>(D)) 1386 CheckPoppedLabel(LD, *this); 1387 1388 // Remove this name from our lexical scope. 1389 IdResolver.RemoveDecl(D); 1390 } 1391} 1392 1393void Sema::ActOnStartFunctionDeclarator() { 1394 ++InFunctionDeclarator; 1395} 1396 1397void Sema::ActOnEndFunctionDeclarator() { 1398 assert(InFunctionDeclarator); 1399 --InFunctionDeclarator; 1400} 1401 1402/// \brief Look for an Objective-C class in the translation unit. 1403/// 1404/// \param Id The name of the Objective-C class we're looking for. If 1405/// typo-correction fixes this name, the Id will be updated 1406/// to the fixed name. 1407/// 1408/// \param IdLoc The location of the name in the translation unit. 1409/// 1410/// \param DoTypoCorrection If true, this routine will attempt typo correction 1411/// if there is no class with the given name. 1412/// 1413/// \returns The declaration of the named Objective-C class, or NULL if the 1414/// class could not be found. 1415ObjCInterfaceDecl *Sema::getObjCInterfaceDecl(IdentifierInfo *&Id, 1416 SourceLocation IdLoc, 1417 bool DoTypoCorrection) { 1418 // The third "scope" argument is 0 since we aren't enabling lazy built-in 1419 // creation from this context. 1420 NamedDecl *IDecl = LookupSingleName(TUScope, Id, IdLoc, LookupOrdinaryName); 1421 1422 if (!IDecl && DoTypoCorrection) { 1423 // Perform typo correction at the given location, but only if we 1424 // find an Objective-C class name. 1425 DeclFilterCCC<ObjCInterfaceDecl> Validator; 1426 if (TypoCorrection C = CorrectTypo(DeclarationNameInfo(Id, IdLoc), 1427 LookupOrdinaryName, TUScope, NULL, 1428 Validator)) { 1429 diagnoseTypo(C, PDiag(diag::err_undef_interface_suggest) << Id); 1430 IDecl = C.getCorrectionDeclAs<ObjCInterfaceDecl>(); 1431 Id = IDecl->getIdentifier(); 1432 } 1433 } 1434 ObjCInterfaceDecl *Def = dyn_cast_or_null<ObjCInterfaceDecl>(IDecl); 1435 // This routine must always return a class definition, if any. 1436 if (Def && Def->getDefinition()) 1437 Def = Def->getDefinition(); 1438 return Def; 1439} 1440 1441/// getNonFieldDeclScope - Retrieves the innermost scope, starting 1442/// from S, where a non-field would be declared. This routine copes 1443/// with the difference between C and C++ scoping rules in structs and 1444/// unions. For example, the following code is well-formed in C but 1445/// ill-formed in C++: 1446/// @code 1447/// struct S6 { 1448/// enum { BAR } e; 1449/// }; 1450/// 1451/// void test_S6() { 1452/// struct S6 a; 1453/// a.e = BAR; 1454/// } 1455/// @endcode 1456/// For the declaration of BAR, this routine will return a different 1457/// scope. The scope S will be the scope of the unnamed enumeration 1458/// within S6. In C++, this routine will return the scope associated 1459/// with S6, because the enumeration's scope is a transparent 1460/// context but structures can contain non-field names. In C, this 1461/// routine will return the translation unit scope, since the 1462/// enumeration's scope is a transparent context and structures cannot 1463/// contain non-field names. 1464Scope *Sema::getNonFieldDeclScope(Scope *S) { 1465 while (((S->getFlags() & Scope::DeclScope) == 0) || 1466 (S->getEntity() && S->getEntity()->isTransparentContext()) || 1467 (S->isClassScope() && !getLangOpts().CPlusPlus)) 1468 S = S->getParent(); 1469 return S; 1470} 1471 1472/// \brief Looks up the declaration of "struct objc_super" and 1473/// saves it for later use in building builtin declaration of 1474/// objc_msgSendSuper and objc_msgSendSuper_stret. If no such 1475/// pre-existing declaration exists no action takes place. 1476static void LookupPredefedObjCSuperType(Sema &ThisSema, Scope *S, 1477 IdentifierInfo *II) { 1478 if (!II->isStr("objc_msgSendSuper")) 1479 return; 1480 ASTContext &Context = ThisSema.Context; 1481 1482 LookupResult Result(ThisSema, &Context.Idents.get("objc_super"), 1483 SourceLocation(), Sema::LookupTagName); 1484 ThisSema.LookupName(Result, S); 1485 if (Result.getResultKind() == LookupResult::Found) 1486 if (const TagDecl *TD = Result.getAsSingle<TagDecl>()) 1487 Context.setObjCSuperType(Context.getTagDeclType(TD)); 1488} 1489 1490/// LazilyCreateBuiltin - The specified Builtin-ID was first used at 1491/// file scope. lazily create a decl for it. ForRedeclaration is true 1492/// if we're creating this built-in in anticipation of redeclaring the 1493/// built-in. 1494NamedDecl *Sema::LazilyCreateBuiltin(IdentifierInfo *II, unsigned bid, 1495 Scope *S, bool ForRedeclaration, 1496 SourceLocation Loc) { 1497 LookupPredefedObjCSuperType(*this, S, II); 1498 1499 Builtin::ID BID = (Builtin::ID)bid; 1500 1501 ASTContext::GetBuiltinTypeError Error; 1502 QualType R = Context.GetBuiltinType(BID, Error); 1503 switch (Error) { 1504 case ASTContext::GE_None: 1505 // Okay 1506 break; 1507 1508 case ASTContext::GE_Missing_stdio: 1509 if (ForRedeclaration) 1510 Diag(Loc, diag::warn_implicit_decl_requires_stdio) 1511 << Context.BuiltinInfo.GetName(BID); 1512 return 0; 1513 1514 case ASTContext::GE_Missing_setjmp: 1515 if (ForRedeclaration) 1516 Diag(Loc, diag::warn_implicit_decl_requires_setjmp) 1517 << Context.BuiltinInfo.GetName(BID); 1518 return 0; 1519 1520 case ASTContext::GE_Missing_ucontext: 1521 if (ForRedeclaration) 1522 Diag(Loc, diag::warn_implicit_decl_requires_ucontext) 1523 << Context.BuiltinInfo.GetName(BID); 1524 return 0; 1525 } 1526 1527 if (!ForRedeclaration && Context.BuiltinInfo.isPredefinedLibFunction(BID)) { 1528 Diag(Loc, diag::ext_implicit_lib_function_decl) 1529 << Context.BuiltinInfo.GetName(BID) 1530 << R; 1531 if (Context.BuiltinInfo.getHeaderName(BID) && 1532 Diags.getDiagnosticLevel(diag::ext_implicit_lib_function_decl, Loc) 1533 != DiagnosticsEngine::Ignored) 1534 Diag(Loc, diag::note_please_include_header) 1535 << Context.BuiltinInfo.getHeaderName(BID) 1536 << Context.BuiltinInfo.GetName(BID); 1537 } 1538 1539 FunctionDecl *New = FunctionDecl::Create(Context, 1540 Context.getTranslationUnitDecl(), 1541 Loc, Loc, II, R, /*TInfo=*/0, 1542 SC_Extern, 1543 false, 1544 /*hasPrototype=*/true); 1545 New->setImplicit(); 1546 1547 // Create Decl objects for each parameter, adding them to the 1548 // FunctionDecl. 1549 if (const FunctionProtoType *FT = dyn_cast<FunctionProtoType>(R)) { 1550 SmallVector<ParmVarDecl*, 16> Params; 1551 for (unsigned i = 0, e = FT->getNumArgs(); i != e; ++i) { 1552 ParmVarDecl *parm = 1553 ParmVarDecl::Create(Context, New, SourceLocation(), 1554 SourceLocation(), 0, 1555 FT->getArgType(i), /*TInfo=*/0, 1556 SC_None, 0); 1557 parm->setScopeInfo(0, i); 1558 Params.push_back(parm); 1559 } 1560 New->setParams(Params); 1561 } 1562 1563 AddKnownFunctionAttributes(New); 1564 1565 // TUScope is the translation-unit scope to insert this function into. 1566 // FIXME: This is hideous. We need to teach PushOnScopeChains to 1567 // relate Scopes to DeclContexts, and probably eliminate CurContext 1568 // entirely, but we're not there yet. 1569 DeclContext *SavedContext = CurContext; 1570 CurContext = Context.getTranslationUnitDecl(); 1571 PushOnScopeChains(New, TUScope); 1572 CurContext = SavedContext; 1573 return New; 1574} 1575 1576/// \brief Filter out any previous declarations that the given declaration 1577/// should not consider because they are not permitted to conflict, e.g., 1578/// because they come from hidden sub-modules and do not refer to the same 1579/// entity. 1580static void filterNonConflictingPreviousDecls(ASTContext &context, 1581 NamedDecl *decl, 1582 LookupResult &previous){ 1583 // This is only interesting when modules are enabled. 1584 if (!context.getLangOpts().Modules) 1585 return; 1586 1587 // Empty sets are uninteresting. 1588 if (previous.empty()) 1589 return; 1590 1591 LookupResult::Filter filter = previous.makeFilter(); 1592 while (filter.hasNext()) { 1593 NamedDecl *old = filter.next(); 1594 1595 // Non-hidden declarations are never ignored. 1596 if (!old->isHidden()) 1597 continue; 1598 1599 if (!old->isExternallyVisible()) 1600 filter.erase(); 1601 } 1602 1603 filter.done(); 1604} 1605 1606bool Sema::isIncompatibleTypedef(TypeDecl *Old, TypedefNameDecl *New) { 1607 QualType OldType; 1608 if (TypedefNameDecl *OldTypedef = dyn_cast<TypedefNameDecl>(Old)) 1609 OldType = OldTypedef->getUnderlyingType(); 1610 else 1611 OldType = Context.getTypeDeclType(Old); 1612 QualType NewType = New->getUnderlyingType(); 1613 1614 if (NewType->isVariablyModifiedType()) { 1615 // Must not redefine a typedef with a variably-modified type. 1616 int Kind = isa<TypeAliasDecl>(Old) ? 1 : 0; 1617 Diag(New->getLocation(), diag::err_redefinition_variably_modified_typedef) 1618 << Kind << NewType; 1619 if (Old->getLocation().isValid()) 1620 Diag(Old->getLocation(), diag::note_previous_definition); 1621 New->setInvalidDecl(); 1622 return true; 1623 } 1624 1625 if (OldType != NewType && 1626 !OldType->isDependentType() && 1627 !NewType->isDependentType() && 1628 !Context.hasSameType(OldType, NewType)) { 1629 int Kind = isa<TypeAliasDecl>(Old) ? 1 : 0; 1630 Diag(New->getLocation(), diag::err_redefinition_different_typedef) 1631 << Kind << NewType << OldType; 1632 if (Old->getLocation().isValid()) 1633 Diag(Old->getLocation(), diag::note_previous_definition); 1634 New->setInvalidDecl(); 1635 return true; 1636 } 1637 return false; 1638} 1639 1640/// MergeTypedefNameDecl - We just parsed a typedef 'New' which has the 1641/// same name and scope as a previous declaration 'Old'. Figure out 1642/// how to resolve this situation, merging decls or emitting 1643/// diagnostics as appropriate. If there was an error, set New to be invalid. 1644/// 1645void Sema::MergeTypedefNameDecl(TypedefNameDecl *New, LookupResult &OldDecls) { 1646 // If the new decl is known invalid already, don't bother doing any 1647 // merging checks. 1648 if (New->isInvalidDecl()) return; 1649 1650 // Allow multiple definitions for ObjC built-in typedefs. 1651 // FIXME: Verify the underlying types are equivalent! 1652 if (getLangOpts().ObjC1) { 1653 const IdentifierInfo *TypeID = New->getIdentifier(); 1654 switch (TypeID->getLength()) { 1655 default: break; 1656 case 2: 1657 { 1658 if (!TypeID->isStr("id")) 1659 break; 1660 QualType T = New->getUnderlyingType(); 1661 if (!T->isPointerType()) 1662 break; 1663 if (!T->isVoidPointerType()) { 1664 QualType PT = T->getAs<PointerType>()->getPointeeType(); 1665 if (!PT->isStructureType()) 1666 break; 1667 } 1668 Context.setObjCIdRedefinitionType(T); 1669 // Install the built-in type for 'id', ignoring the current definition. 1670 New->setTypeForDecl(Context.getObjCIdType().getTypePtr()); 1671 return; 1672 } 1673 case 5: 1674 if (!TypeID->isStr("Class")) 1675 break; 1676 Context.setObjCClassRedefinitionType(New->getUnderlyingType()); 1677 // Install the built-in type for 'Class', ignoring the current definition. 1678 New->setTypeForDecl(Context.getObjCClassType().getTypePtr()); 1679 return; 1680 case 3: 1681 if (!TypeID->isStr("SEL")) 1682 break; 1683 Context.setObjCSelRedefinitionType(New->getUnderlyingType()); 1684 // Install the built-in type for 'SEL', ignoring the current definition. 1685 New->setTypeForDecl(Context.getObjCSelType().getTypePtr()); 1686 return; 1687 } 1688 // Fall through - the typedef name was not a builtin type. 1689 } 1690 1691 // Verify the old decl was also a type. 1692 TypeDecl *Old = OldDecls.getAsSingle<TypeDecl>(); 1693 if (!Old) { 1694 Diag(New->getLocation(), diag::err_redefinition_different_kind) 1695 << New->getDeclName(); 1696 1697 NamedDecl *OldD = OldDecls.getRepresentativeDecl(); 1698 if (OldD->getLocation().isValid()) 1699 Diag(OldD->getLocation(), diag::note_previous_definition); 1700 1701 return New->setInvalidDecl(); 1702 } 1703 1704 // If the old declaration is invalid, just give up here. 1705 if (Old->isInvalidDecl()) 1706 return New->setInvalidDecl(); 1707 1708 // If the typedef types are not identical, reject them in all languages and 1709 // with any extensions enabled. 1710 if (isIncompatibleTypedef(Old, New)) 1711 return; 1712 1713 // The types match. Link up the redeclaration chain and merge attributes if 1714 // the old declaration was a typedef. 1715 if (TypedefNameDecl *Typedef = dyn_cast<TypedefNameDecl>(Old)) { 1716 New->setPreviousDecl(Typedef); 1717 mergeDeclAttributes(New, Old); 1718 } 1719 1720 if (getLangOpts().MicrosoftExt) 1721 return; 1722 1723 if (getLangOpts().CPlusPlus) { 1724 // C++ [dcl.typedef]p2: 1725 // In a given non-class scope, a typedef specifier can be used to 1726 // redefine the name of any type declared in that scope to refer 1727 // to the type to which it already refers. 1728 if (!isa<CXXRecordDecl>(CurContext)) 1729 return; 1730 1731 // C++0x [dcl.typedef]p4: 1732 // In a given class scope, a typedef specifier can be used to redefine 1733 // any class-name declared in that scope that is not also a typedef-name 1734 // to refer to the type to which it already refers. 1735 // 1736 // This wording came in via DR424, which was a correction to the 1737 // wording in DR56, which accidentally banned code like: 1738 // 1739 // struct S { 1740 // typedef struct A { } A; 1741 // }; 1742 // 1743 // in the C++03 standard. We implement the C++0x semantics, which 1744 // allow the above but disallow 1745 // 1746 // struct S { 1747 // typedef int I; 1748 // typedef int I; 1749 // }; 1750 // 1751 // since that was the intent of DR56. 1752 if (!isa<TypedefNameDecl>(Old)) 1753 return; 1754 1755 Diag(New->getLocation(), diag::err_redefinition) 1756 << New->getDeclName(); 1757 Diag(Old->getLocation(), diag::note_previous_definition); 1758 return New->setInvalidDecl(); 1759 } 1760 1761 // Modules always permit redefinition of typedefs, as does C11. 1762 if (getLangOpts().Modules || getLangOpts().C11) 1763 return; 1764 1765 // If we have a redefinition of a typedef in C, emit a warning. This warning 1766 // is normally mapped to an error, but can be controlled with 1767 // -Wtypedef-redefinition. If either the original or the redefinition is 1768 // in a system header, don't emit this for compatibility with GCC. 1769 if (getDiagnostics().getSuppressSystemWarnings() && 1770 (Context.getSourceManager().isInSystemHeader(Old->getLocation()) || 1771 Context.getSourceManager().isInSystemHeader(New->getLocation()))) 1772 return; 1773 1774 Diag(New->getLocation(), diag::warn_redefinition_of_typedef) 1775 << New->getDeclName(); 1776 Diag(Old->getLocation(), diag::note_previous_definition); 1777 return; 1778} 1779 1780/// DeclhasAttr - returns true if decl Declaration already has the target 1781/// attribute. 1782static bool 1783DeclHasAttr(const Decl *D, const Attr *A) { 1784 // There can be multiple AvailabilityAttr in a Decl. Make sure we copy 1785 // all of them. It is mergeAvailabilityAttr in SemaDeclAttr.cpp that is 1786 // responsible for making sure they are consistent. 1787 const AvailabilityAttr *AA = dyn_cast<AvailabilityAttr>(A); 1788 if (AA) 1789 return false; 1790 1791 // The following thread safety attributes can also be duplicated. 1792 switch (A->getKind()) { 1793 case attr::ExclusiveLocksRequired: 1794 case attr::SharedLocksRequired: 1795 case attr::LocksExcluded: 1796 case attr::ExclusiveLockFunction: 1797 case attr::SharedLockFunction: 1798 case attr::UnlockFunction: 1799 case attr::ExclusiveTrylockFunction: 1800 case attr::SharedTrylockFunction: 1801 case attr::GuardedBy: 1802 case attr::PtGuardedBy: 1803 case attr::AcquiredBefore: 1804 case attr::AcquiredAfter: 1805 return false; 1806 default: 1807 ; 1808 } 1809 1810 const OwnershipAttr *OA = dyn_cast<OwnershipAttr>(A); 1811 const AnnotateAttr *Ann = dyn_cast<AnnotateAttr>(A); 1812 for (Decl::attr_iterator i = D->attr_begin(), e = D->attr_end(); i != e; ++i) 1813 if ((*i)->getKind() == A->getKind()) { 1814 if (Ann) { 1815 if (Ann->getAnnotation() == cast<AnnotateAttr>(*i)->getAnnotation()) 1816 return true; 1817 continue; 1818 } 1819 // FIXME: Don't hardcode this check 1820 if (OA && isa<OwnershipAttr>(*i)) 1821 return OA->getOwnKind() == cast<OwnershipAttr>(*i)->getOwnKind(); 1822 return true; 1823 } 1824 1825 return false; 1826} 1827 1828static bool isAttributeTargetADefinition(Decl *D) { 1829 if (VarDecl *VD = dyn_cast<VarDecl>(D)) 1830 return VD->isThisDeclarationADefinition(); 1831 if (TagDecl *TD = dyn_cast<TagDecl>(D)) 1832 return TD->isCompleteDefinition() || TD->isBeingDefined(); 1833 return true; 1834} 1835 1836/// Merge alignment attributes from \p Old to \p New, taking into account the 1837/// special semantics of C11's _Alignas specifier and C++11's alignas attribute. 1838/// 1839/// \return \c true if any attributes were added to \p New. 1840static bool mergeAlignedAttrs(Sema &S, NamedDecl *New, Decl *Old) { 1841 // Look for alignas attributes on Old, and pick out whichever attribute 1842 // specifies the strictest alignment requirement. 1843 AlignedAttr *OldAlignasAttr = 0; 1844 AlignedAttr *OldStrictestAlignAttr = 0; 1845 unsigned OldAlign = 0; 1846 for (specific_attr_iterator<AlignedAttr> 1847 I = Old->specific_attr_begin<AlignedAttr>(), 1848 E = Old->specific_attr_end<AlignedAttr>(); I != E; ++I) { 1849 // FIXME: We have no way of representing inherited dependent alignments 1850 // in a case like: 1851 // template<int A, int B> struct alignas(A) X; 1852 // template<int A, int B> struct alignas(B) X {}; 1853 // For now, we just ignore any alignas attributes which are not on the 1854 // definition in such a case. 1855 if (I->isAlignmentDependent()) 1856 return false; 1857 1858 if (I->isAlignas()) 1859 OldAlignasAttr = *I; 1860 1861 unsigned Align = I->getAlignment(S.Context); 1862 if (Align > OldAlign) { 1863 OldAlign = Align; 1864 OldStrictestAlignAttr = *I; 1865 } 1866 } 1867 1868 // Look for alignas attributes on New. 1869 AlignedAttr *NewAlignasAttr = 0; 1870 unsigned NewAlign = 0; 1871 for (specific_attr_iterator<AlignedAttr> 1872 I = New->specific_attr_begin<AlignedAttr>(), 1873 E = New->specific_attr_end<AlignedAttr>(); I != E; ++I) { 1874 if (I->isAlignmentDependent()) 1875 return false; 1876 1877 if (I->isAlignas()) 1878 NewAlignasAttr = *I; 1879 1880 unsigned Align = I->getAlignment(S.Context); 1881 if (Align > NewAlign) 1882 NewAlign = Align; 1883 } 1884 1885 if (OldAlignasAttr && NewAlignasAttr && OldAlign != NewAlign) { 1886 // Both declarations have 'alignas' attributes. We require them to match. 1887 // C++11 [dcl.align]p6 and C11 6.7.5/7 both come close to saying this, but 1888 // fall short. (If two declarations both have alignas, they must both match 1889 // every definition, and so must match each other if there is a definition.) 1890 1891 // If either declaration only contains 'alignas(0)' specifiers, then it 1892 // specifies the natural alignment for the type. 1893 if (OldAlign == 0 || NewAlign == 0) { 1894 QualType Ty; 1895 if (ValueDecl *VD = dyn_cast<ValueDecl>(New)) 1896 Ty = VD->getType(); 1897 else 1898 Ty = S.Context.getTagDeclType(cast<TagDecl>(New)); 1899 1900 if (OldAlign == 0) 1901 OldAlign = S.Context.getTypeAlign(Ty); 1902 if (NewAlign == 0) 1903 NewAlign = S.Context.getTypeAlign(Ty); 1904 } 1905 1906 if (OldAlign != NewAlign) { 1907 S.Diag(NewAlignasAttr->getLocation(), diag::err_alignas_mismatch) 1908 << (unsigned)S.Context.toCharUnitsFromBits(OldAlign).getQuantity() 1909 << (unsigned)S.Context.toCharUnitsFromBits(NewAlign).getQuantity(); 1910 S.Diag(OldAlignasAttr->getLocation(), diag::note_previous_declaration); 1911 } 1912 } 1913 1914 if (OldAlignasAttr && !NewAlignasAttr && isAttributeTargetADefinition(New)) { 1915 // C++11 [dcl.align]p6: 1916 // if any declaration of an entity has an alignment-specifier, 1917 // every defining declaration of that entity shall specify an 1918 // equivalent alignment. 1919 // C11 6.7.5/7: 1920 // If the definition of an object does not have an alignment 1921 // specifier, any other declaration of that object shall also 1922 // have no alignment specifier. 1923 S.Diag(New->getLocation(), diag::err_alignas_missing_on_definition) 1924 << OldAlignasAttr->isC11(); 1925 S.Diag(OldAlignasAttr->getLocation(), diag::note_alignas_on_declaration) 1926 << OldAlignasAttr->isC11(); 1927 } 1928 1929 bool AnyAdded = false; 1930 1931 // Ensure we have an attribute representing the strictest alignment. 1932 if (OldAlign > NewAlign) { 1933 AlignedAttr *Clone = OldStrictestAlignAttr->clone(S.Context); 1934 Clone->setInherited(true); 1935 New->addAttr(Clone); 1936 AnyAdded = true; 1937 } 1938 1939 // Ensure we have an alignas attribute if the old declaration had one. 1940 if (OldAlignasAttr && !NewAlignasAttr && 1941 !(AnyAdded && OldStrictestAlignAttr->isAlignas())) { 1942 AlignedAttr *Clone = OldAlignasAttr->clone(S.Context); 1943 Clone->setInherited(true); 1944 New->addAttr(Clone); 1945 AnyAdded = true; 1946 } 1947 1948 return AnyAdded; 1949} 1950 1951static bool mergeDeclAttribute(Sema &S, NamedDecl *D, InheritableAttr *Attr, 1952 bool Override) { 1953 InheritableAttr *NewAttr = NULL; 1954 unsigned AttrSpellingListIndex = Attr->getSpellingListIndex(); 1955 if (AvailabilityAttr *AA = dyn_cast<AvailabilityAttr>(Attr)) 1956 NewAttr = S.mergeAvailabilityAttr(D, AA->getRange(), AA->getPlatform(), 1957 AA->getIntroduced(), AA->getDeprecated(), 1958 AA->getObsoleted(), AA->getUnavailable(), 1959 AA->getMessage(), Override, 1960 AttrSpellingListIndex); 1961 else if (VisibilityAttr *VA = dyn_cast<VisibilityAttr>(Attr)) 1962 NewAttr = S.mergeVisibilityAttr(D, VA->getRange(), VA->getVisibility(), 1963 AttrSpellingListIndex); 1964 else if (TypeVisibilityAttr *VA = dyn_cast<TypeVisibilityAttr>(Attr)) 1965 NewAttr = S.mergeTypeVisibilityAttr(D, VA->getRange(), VA->getVisibility(), 1966 AttrSpellingListIndex); 1967 else if (DLLImportAttr *ImportA = dyn_cast<DLLImportAttr>(Attr)) 1968 NewAttr = S.mergeDLLImportAttr(D, ImportA->getRange(), 1969 AttrSpellingListIndex); 1970 else if (DLLExportAttr *ExportA = dyn_cast<DLLExportAttr>(Attr)) 1971 NewAttr = S.mergeDLLExportAttr(D, ExportA->getRange(), 1972 AttrSpellingListIndex); 1973 else if (FormatAttr *FA = dyn_cast<FormatAttr>(Attr)) 1974 NewAttr = S.mergeFormatAttr(D, FA->getRange(), FA->getType(), 1975 FA->getFormatIdx(), FA->getFirstArg(), 1976 AttrSpellingListIndex); 1977 else if (SectionAttr *SA = dyn_cast<SectionAttr>(Attr)) 1978 NewAttr = S.mergeSectionAttr(D, SA->getRange(), SA->getName(), 1979 AttrSpellingListIndex); 1980 else if (isa<AlignedAttr>(Attr)) 1981 // AlignedAttrs are handled separately, because we need to handle all 1982 // such attributes on a declaration at the same time. 1983 NewAttr = 0; 1984 else if (!DeclHasAttr(D, Attr)) 1985 NewAttr = cast<InheritableAttr>(Attr->clone(S.Context)); 1986 1987 if (NewAttr) { 1988 NewAttr->setInherited(true); 1989 D->addAttr(NewAttr); 1990 return true; 1991 } 1992 1993 return false; 1994} 1995 1996static const Decl *getDefinition(const Decl *D) { 1997 if (const TagDecl *TD = dyn_cast<TagDecl>(D)) 1998 return TD->getDefinition(); 1999 if (const VarDecl *VD = dyn_cast<VarDecl>(D)) 2000 return VD->getDefinition(); 2001 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) { 2002 const FunctionDecl* Def; 2003 if (FD->hasBody(Def)) 2004 return Def; 2005 } 2006 return NULL; 2007} 2008 2009static bool hasAttribute(const Decl *D, attr::Kind Kind) { 2010 for (Decl::attr_iterator I = D->attr_begin(), E = D->attr_end(); 2011 I != E; ++I) { 2012 Attr *Attribute = *I; 2013 if (Attribute->getKind() == Kind) 2014 return true; 2015 } 2016 return false; 2017} 2018 2019/// checkNewAttributesAfterDef - If we already have a definition, check that 2020/// there are no new attributes in this declaration. 2021static void checkNewAttributesAfterDef(Sema &S, Decl *New, const Decl *Old) { 2022 if (!New->hasAttrs()) 2023 return; 2024 2025 const Decl *Def = getDefinition(Old); 2026 if (!Def || Def == New) 2027 return; 2028 2029 AttrVec &NewAttributes = New->getAttrs(); 2030 for (unsigned I = 0, E = NewAttributes.size(); I != E;) { 2031 const Attr *NewAttribute = NewAttributes[I]; 2032 if (hasAttribute(Def, NewAttribute->getKind())) { 2033 ++I; 2034 continue; // regular attr merging will take care of validating this. 2035 } 2036 2037 if (isa<C11NoReturnAttr>(NewAttribute)) { 2038 // C's _Noreturn is allowed to be added to a function after it is defined. 2039 ++I; 2040 continue; 2041 } else if (const AlignedAttr *AA = dyn_cast<AlignedAttr>(NewAttribute)) { 2042 if (AA->isAlignas()) { 2043 // C++11 [dcl.align]p6: 2044 // if any declaration of an entity has an alignment-specifier, 2045 // every defining declaration of that entity shall specify an 2046 // equivalent alignment. 2047 // C11 6.7.5/7: 2048 // If the definition of an object does not have an alignment 2049 // specifier, any other declaration of that object shall also 2050 // have no alignment specifier. 2051 S.Diag(Def->getLocation(), diag::err_alignas_missing_on_definition) 2052 << AA->isC11(); 2053 S.Diag(NewAttribute->getLocation(), diag::note_alignas_on_declaration) 2054 << AA->isC11(); 2055 NewAttributes.erase(NewAttributes.begin() + I); 2056 --E; 2057 continue; 2058 } 2059 } 2060 2061 S.Diag(NewAttribute->getLocation(), 2062 diag::warn_attribute_precede_definition); 2063 S.Diag(Def->getLocation(), diag::note_previous_definition); 2064 NewAttributes.erase(NewAttributes.begin() + I); 2065 --E; 2066 } 2067} 2068 2069/// mergeDeclAttributes - Copy attributes from the Old decl to the New one. 2070void Sema::mergeDeclAttributes(NamedDecl *New, Decl *Old, 2071 AvailabilityMergeKind AMK) { 2072 if (!Old->hasAttrs() && !New->hasAttrs()) 2073 return; 2074 2075 // attributes declared post-definition are currently ignored 2076 checkNewAttributesAfterDef(*this, New, Old); 2077 2078 if (!Old->hasAttrs()) 2079 return; 2080 2081 bool foundAny = New->hasAttrs(); 2082 2083 // Ensure that any moving of objects within the allocated map is done before 2084 // we process them. 2085 if (!foundAny) New->setAttrs(AttrVec()); 2086 2087 for (specific_attr_iterator<InheritableAttr> 2088 i = Old->specific_attr_begin<InheritableAttr>(), 2089 e = Old->specific_attr_end<InheritableAttr>(); 2090 i != e; ++i) { 2091 bool Override = false; 2092 // Ignore deprecated/unavailable/availability attributes if requested. 2093 if (isa<DeprecatedAttr>(*i) || 2094 isa<UnavailableAttr>(*i) || 2095 isa<AvailabilityAttr>(*i)) { 2096 switch (AMK) { 2097 case AMK_None: 2098 continue; 2099 2100 case AMK_Redeclaration: 2101 break; 2102 2103 case AMK_Override: 2104 Override = true; 2105 break; 2106 } 2107 } 2108 2109 if (mergeDeclAttribute(*this, New, *i, Override)) 2110 foundAny = true; 2111 } 2112 2113 if (mergeAlignedAttrs(*this, New, Old)) 2114 foundAny = true; 2115 2116 if (!foundAny) New->dropAttrs(); 2117} 2118 2119/// mergeParamDeclAttributes - Copy attributes from the old parameter 2120/// to the new one. 2121static void mergeParamDeclAttributes(ParmVarDecl *newDecl, 2122 const ParmVarDecl *oldDecl, 2123 Sema &S) { 2124 // C++11 [dcl.attr.depend]p2: 2125 // The first declaration of a function shall specify the 2126 // carries_dependency attribute for its declarator-id if any declaration 2127 // of the function specifies the carries_dependency attribute. 2128 if (newDecl->hasAttr<CarriesDependencyAttr>() && 2129 !oldDecl->hasAttr<CarriesDependencyAttr>()) { 2130 S.Diag(newDecl->getAttr<CarriesDependencyAttr>()->getLocation(), 2131 diag::err_carries_dependency_missing_on_first_decl) << 1/*Param*/; 2132 // Find the first declaration of the parameter. 2133 // FIXME: Should we build redeclaration chains for function parameters? 2134 const FunctionDecl *FirstFD = 2135 cast<FunctionDecl>(oldDecl->getDeclContext())->getFirstDecl(); 2136 const ParmVarDecl *FirstVD = 2137 FirstFD->getParamDecl(oldDecl->getFunctionScopeIndex()); 2138 S.Diag(FirstVD->getLocation(), 2139 diag::note_carries_dependency_missing_first_decl) << 1/*Param*/; 2140 } 2141 2142 if (!oldDecl->hasAttrs()) 2143 return; 2144 2145 bool foundAny = newDecl->hasAttrs(); 2146 2147 // Ensure that any moving of objects within the allocated map is 2148 // done before we process them. 2149 if (!foundAny) newDecl->setAttrs(AttrVec()); 2150 2151 for (specific_attr_iterator<InheritableParamAttr> 2152 i = oldDecl->specific_attr_begin<InheritableParamAttr>(), 2153 e = oldDecl->specific_attr_end<InheritableParamAttr>(); i != e; ++i) { 2154 if (!DeclHasAttr(newDecl, *i)) { 2155 InheritableAttr *newAttr = 2156 cast<InheritableParamAttr>((*i)->clone(S.Context)); 2157 newAttr->setInherited(true); 2158 newDecl->addAttr(newAttr); 2159 foundAny = true; 2160 } 2161 } 2162 2163 if (!foundAny) newDecl->dropAttrs(); 2164} 2165 2166namespace { 2167 2168/// Used in MergeFunctionDecl to keep track of function parameters in 2169/// C. 2170struct GNUCompatibleParamWarning { 2171 ParmVarDecl *OldParm; 2172 ParmVarDecl *NewParm; 2173 QualType PromotedType; 2174}; 2175 2176} 2177 2178/// getSpecialMember - get the special member enum for a method. 2179Sema::CXXSpecialMember Sema::getSpecialMember(const CXXMethodDecl *MD) { 2180 if (const CXXConstructorDecl *Ctor = dyn_cast<CXXConstructorDecl>(MD)) { 2181 if (Ctor->isDefaultConstructor()) 2182 return Sema::CXXDefaultConstructor; 2183 2184 if (Ctor->isCopyConstructor()) 2185 return Sema::CXXCopyConstructor; 2186 2187 if (Ctor->isMoveConstructor()) 2188 return Sema::CXXMoveConstructor; 2189 } else if (isa<CXXDestructorDecl>(MD)) { 2190 return Sema::CXXDestructor; 2191 } else if (MD->isCopyAssignmentOperator()) { 2192 return Sema::CXXCopyAssignment; 2193 } else if (MD->isMoveAssignmentOperator()) { 2194 return Sema::CXXMoveAssignment; 2195 } 2196 2197 return Sema::CXXInvalid; 2198} 2199 2200/// canRedefineFunction - checks if a function can be redefined. Currently, 2201/// only extern inline functions can be redefined, and even then only in 2202/// GNU89 mode. 2203static bool canRedefineFunction(const FunctionDecl *FD, 2204 const LangOptions& LangOpts) { 2205 return ((FD->hasAttr<GNUInlineAttr>() || LangOpts.GNUInline) && 2206 !LangOpts.CPlusPlus && 2207 FD->isInlineSpecified() && 2208 FD->getStorageClass() == SC_Extern); 2209} 2210 2211const AttributedType *Sema::getCallingConvAttributedType(QualType T) const { 2212 const AttributedType *AT = T->getAs<AttributedType>(); 2213 while (AT && !AT->isCallingConv()) 2214 AT = AT->getModifiedType()->getAs<AttributedType>(); 2215 return AT; 2216} 2217 2218template <typename T> 2219static bool haveIncompatibleLanguageLinkages(const T *Old, const T *New) { 2220 const DeclContext *DC = Old->getDeclContext(); 2221 if (DC->isRecord()) 2222 return false; 2223 2224 LanguageLinkage OldLinkage = Old->getLanguageLinkage(); 2225 if (OldLinkage == CXXLanguageLinkage && New->isInExternCContext()) 2226 return true; 2227 if (OldLinkage == CLanguageLinkage && New->isInExternCXXContext()) 2228 return true; 2229 return false; 2230} 2231 2232/// MergeFunctionDecl - We just parsed a function 'New' from 2233/// declarator D which has the same name and scope as a previous 2234/// declaration 'Old'. Figure out how to resolve this situation, 2235/// merging decls or emitting diagnostics as appropriate. 2236/// 2237/// In C++, New and Old must be declarations that are not 2238/// overloaded. Use IsOverload to determine whether New and Old are 2239/// overloaded, and to select the Old declaration that New should be 2240/// merged with. 2241/// 2242/// Returns true if there was an error, false otherwise. 2243bool Sema::MergeFunctionDecl(FunctionDecl *New, Decl *OldD, Scope *S, 2244 bool MergeTypeWithOld) { 2245 // Verify the old decl was also a function. 2246 FunctionDecl *Old = 0; 2247 if (FunctionTemplateDecl *OldFunctionTemplate 2248 = dyn_cast<FunctionTemplateDecl>(OldD)) 2249 Old = OldFunctionTemplate->getTemplatedDecl(); 2250 else 2251 Old = dyn_cast<FunctionDecl>(OldD); 2252 if (!Old) { 2253 if (UsingShadowDecl *Shadow = dyn_cast<UsingShadowDecl>(OldD)) { 2254 if (New->getFriendObjectKind()) { 2255 Diag(New->getLocation(), diag::err_using_decl_friend); 2256 Diag(Shadow->getTargetDecl()->getLocation(), 2257 diag::note_using_decl_target); 2258 Diag(Shadow->getUsingDecl()->getLocation(), 2259 diag::note_using_decl) << 0; 2260 return true; 2261 } 2262 2263 Diag(New->getLocation(), diag::err_using_decl_conflict_reverse); 2264 Diag(Shadow->getTargetDecl()->getLocation(), 2265 diag::note_using_decl_target); 2266 Diag(Shadow->getUsingDecl()->getLocation(), 2267 diag::note_using_decl) << 0; 2268 return true; 2269 } 2270 2271 Diag(New->getLocation(), diag::err_redefinition_different_kind) 2272 << New->getDeclName(); 2273 Diag(OldD->getLocation(), diag::note_previous_definition); 2274 return true; 2275 } 2276 2277 // If the old declaration is invalid, just give up here. 2278 if (Old->isInvalidDecl()) 2279 return true; 2280 2281 // Determine whether the previous declaration was a definition, 2282 // implicit declaration, or a declaration. 2283 diag::kind PrevDiag; 2284 if (Old->isThisDeclarationADefinition()) 2285 PrevDiag = diag::note_previous_definition; 2286 else if (Old->isImplicit()) 2287 PrevDiag = diag::note_previous_implicit_declaration; 2288 else 2289 PrevDiag = diag::note_previous_declaration; 2290 2291 // Don't complain about this if we're in GNU89 mode and the old function 2292 // is an extern inline function. 2293 // Don't complain about specializations. They are not supposed to have 2294 // storage classes. 2295 if (!isa<CXXMethodDecl>(New) && !isa<CXXMethodDecl>(Old) && 2296 New->getStorageClass() == SC_Static && 2297 Old->hasExternalFormalLinkage() && 2298 !New->getTemplateSpecializationInfo() && 2299 !canRedefineFunction(Old, getLangOpts())) { 2300 if (getLangOpts().MicrosoftExt) { 2301 Diag(New->getLocation(), diag::warn_static_non_static) << New; 2302 Diag(Old->getLocation(), PrevDiag); 2303 } else { 2304 Diag(New->getLocation(), diag::err_static_non_static) << New; 2305 Diag(Old->getLocation(), PrevDiag); 2306 return true; 2307 } 2308 } 2309 2310 2311 // If a function is first declared with a calling convention, but is later 2312 // declared or defined without one, all following decls assume the calling 2313 // convention of the first. 2314 // 2315 // It's OK if a function is first declared without a calling convention, 2316 // but is later declared or defined with the default calling convention. 2317 // 2318 // To test if either decl has an explicit calling convention, we look for 2319 // AttributedType sugar nodes on the type as written. If they are missing or 2320 // were canonicalized away, we assume the calling convention was implicit. 2321 // 2322 // Note also that we DO NOT return at this point, because we still have 2323 // other tests to run. 2324 QualType OldQType = Context.getCanonicalType(Old->getType()); 2325 QualType NewQType = Context.getCanonicalType(New->getType()); 2326 const FunctionType *OldType = cast<FunctionType>(OldQType); 2327 const FunctionType *NewType = cast<FunctionType>(NewQType); 2328 FunctionType::ExtInfo OldTypeInfo = OldType->getExtInfo(); 2329 FunctionType::ExtInfo NewTypeInfo = NewType->getExtInfo(); 2330 bool RequiresAdjustment = false; 2331 2332 if (OldTypeInfo.getCC() != NewTypeInfo.getCC()) { 2333 FunctionDecl *First = Old->getFirstDecl(); 2334 const FunctionType *FT = 2335 First->getType().getCanonicalType()->castAs<FunctionType>(); 2336 FunctionType::ExtInfo FI = FT->getExtInfo(); 2337 bool NewCCExplicit = getCallingConvAttributedType(New->getType()); 2338 if (!NewCCExplicit) { 2339 // Inherit the CC from the previous declaration if it was specified 2340 // there but not here. 2341 NewTypeInfo = NewTypeInfo.withCallingConv(OldTypeInfo.getCC()); 2342 RequiresAdjustment = true; 2343 } else { 2344 // Calling conventions aren't compatible, so complain. 2345 bool FirstCCExplicit = getCallingConvAttributedType(First->getType()); 2346 Diag(New->getLocation(), diag::err_cconv_change) 2347 << FunctionType::getNameForCallConv(NewTypeInfo.getCC()) 2348 << !FirstCCExplicit 2349 << (!FirstCCExplicit ? "" : 2350 FunctionType::getNameForCallConv(FI.getCC())); 2351 2352 // Put the note on the first decl, since it is the one that matters. 2353 Diag(First->getLocation(), diag::note_previous_declaration); 2354 return true; 2355 } 2356 } 2357 2358 // FIXME: diagnose the other way around? 2359 if (OldTypeInfo.getNoReturn() && !NewTypeInfo.getNoReturn()) { 2360 NewTypeInfo = NewTypeInfo.withNoReturn(true); 2361 RequiresAdjustment = true; 2362 } 2363 2364 // Merge regparm attribute. 2365 if (OldTypeInfo.getHasRegParm() != NewTypeInfo.getHasRegParm() || 2366 OldTypeInfo.getRegParm() != NewTypeInfo.getRegParm()) { 2367 if (NewTypeInfo.getHasRegParm()) { 2368 Diag(New->getLocation(), diag::err_regparm_mismatch) 2369 << NewType->getRegParmType() 2370 << OldType->getRegParmType(); 2371 Diag(Old->getLocation(), diag::note_previous_declaration); 2372 return true; 2373 } 2374 2375 NewTypeInfo = NewTypeInfo.withRegParm(OldTypeInfo.getRegParm()); 2376 RequiresAdjustment = true; 2377 } 2378 2379 // Merge ns_returns_retained attribute. 2380 if (OldTypeInfo.getProducesResult() != NewTypeInfo.getProducesResult()) { 2381 if (NewTypeInfo.getProducesResult()) { 2382 Diag(New->getLocation(), diag::err_returns_retained_mismatch); 2383 Diag(Old->getLocation(), diag::note_previous_declaration); 2384 return true; 2385 } 2386 2387 NewTypeInfo = NewTypeInfo.withProducesResult(true); 2388 RequiresAdjustment = true; 2389 } 2390 2391 if (RequiresAdjustment) { 2392 const FunctionType *AdjustedType = New->getType()->getAs<FunctionType>(); 2393 AdjustedType = Context.adjustFunctionType(AdjustedType, NewTypeInfo); 2394 New->setType(QualType(AdjustedType, 0)); 2395 NewQType = Context.getCanonicalType(New->getType()); 2396 NewType = cast<FunctionType>(NewQType); 2397 } 2398 2399 // If this redeclaration makes the function inline, we may need to add it to 2400 // UndefinedButUsed. 2401 if (!Old->isInlined() && New->isInlined() && 2402 !New->hasAttr<GNUInlineAttr>() && 2403 (getLangOpts().CPlusPlus || !getLangOpts().GNUInline) && 2404 Old->isUsed(false) && 2405 !Old->isDefined() && !New->isThisDeclarationADefinition()) 2406 UndefinedButUsed.insert(std::make_pair(Old->getCanonicalDecl(), 2407 SourceLocation())); 2408 2409 // If this redeclaration makes it newly gnu_inline, we don't want to warn 2410 // about it. 2411 if (New->hasAttr<GNUInlineAttr>() && 2412 Old->isInlined() && !Old->hasAttr<GNUInlineAttr>()) { 2413 UndefinedButUsed.erase(Old->getCanonicalDecl()); 2414 } 2415 2416 if (getLangOpts().CPlusPlus) { 2417 // (C++98 13.1p2): 2418 // Certain function declarations cannot be overloaded: 2419 // -- Function declarations that differ only in the return type 2420 // cannot be overloaded. 2421 2422 // Go back to the type source info to compare the declared return types, 2423 // per C++1y [dcl.type.auto]p13: 2424 // Redeclarations or specializations of a function or function template 2425 // with a declared return type that uses a placeholder type shall also 2426 // use that placeholder, not a deduced type. 2427 QualType OldDeclaredReturnType = (Old->getTypeSourceInfo() 2428 ? Old->getTypeSourceInfo()->getType()->castAs<FunctionType>() 2429 : OldType)->getResultType(); 2430 QualType NewDeclaredReturnType = (New->getTypeSourceInfo() 2431 ? New->getTypeSourceInfo()->getType()->castAs<FunctionType>() 2432 : NewType)->getResultType(); 2433 QualType ResQT; 2434 if (!Context.hasSameType(OldDeclaredReturnType, NewDeclaredReturnType) && 2435 !((NewQType->isDependentType() || OldQType->isDependentType()) && 2436 New->isLocalExternDecl())) { 2437 if (NewDeclaredReturnType->isObjCObjectPointerType() && 2438 OldDeclaredReturnType->isObjCObjectPointerType()) 2439 ResQT = Context.mergeObjCGCQualifiers(NewQType, OldQType); 2440 if (ResQT.isNull()) { 2441 if (New->isCXXClassMember() && New->isOutOfLine()) 2442 Diag(New->getLocation(), 2443 diag::err_member_def_does_not_match_ret_type) << New; 2444 else 2445 Diag(New->getLocation(), diag::err_ovl_diff_return_type); 2446 Diag(Old->getLocation(), PrevDiag) << Old << Old->getType(); 2447 return true; 2448 } 2449 else 2450 NewQType = ResQT; 2451 } 2452 2453 QualType OldReturnType = OldType->getResultType(); 2454 QualType NewReturnType = cast<FunctionType>(NewQType)->getResultType(); 2455 if (OldReturnType != NewReturnType) { 2456 // If this function has a deduced return type and has already been 2457 // defined, copy the deduced value from the old declaration. 2458 AutoType *OldAT = Old->getResultType()->getContainedAutoType(); 2459 if (OldAT && OldAT->isDeduced()) { 2460 New->setType( 2461 SubstAutoType(New->getType(), 2462 OldAT->isDependentType() ? Context.DependentTy 2463 : OldAT->getDeducedType())); 2464 NewQType = Context.getCanonicalType( 2465 SubstAutoType(NewQType, 2466 OldAT->isDependentType() ? Context.DependentTy 2467 : OldAT->getDeducedType())); 2468 } 2469 } 2470 2471 const CXXMethodDecl *OldMethod = dyn_cast<CXXMethodDecl>(Old); 2472 CXXMethodDecl *NewMethod = dyn_cast<CXXMethodDecl>(New); 2473 if (OldMethod && NewMethod) { 2474 // Preserve triviality. 2475 NewMethod->setTrivial(OldMethod->isTrivial()); 2476 2477 // MSVC allows explicit template specialization at class scope: 2478 // 2 CXMethodDecls referring to the same function will be injected. 2479 // We don't want a redeclartion error. 2480 bool IsClassScopeExplicitSpecialization = 2481 OldMethod->isFunctionTemplateSpecialization() && 2482 NewMethod->isFunctionTemplateSpecialization(); 2483 bool isFriend = NewMethod->getFriendObjectKind(); 2484 2485 if (!isFriend && NewMethod->getLexicalDeclContext()->isRecord() && 2486 !IsClassScopeExplicitSpecialization) { 2487 // -- Member function declarations with the same name and the 2488 // same parameter types cannot be overloaded if any of them 2489 // is a static member function declaration. 2490 if (OldMethod->isStatic() != NewMethod->isStatic()) { 2491 Diag(New->getLocation(), diag::err_ovl_static_nonstatic_member); 2492 Diag(Old->getLocation(), PrevDiag) << Old << Old->getType(); 2493 return true; 2494 } 2495 2496 // C++ [class.mem]p1: 2497 // [...] A member shall not be declared twice in the 2498 // member-specification, except that a nested class or member 2499 // class template can be declared and then later defined. 2500 if (ActiveTemplateInstantiations.empty()) { 2501 unsigned NewDiag; 2502 if (isa<CXXConstructorDecl>(OldMethod)) 2503 NewDiag = diag::err_constructor_redeclared; 2504 else if (isa<CXXDestructorDecl>(NewMethod)) 2505 NewDiag = diag::err_destructor_redeclared; 2506 else if (isa<CXXConversionDecl>(NewMethod)) 2507 NewDiag = diag::err_conv_function_redeclared; 2508 else 2509 NewDiag = diag::err_member_redeclared; 2510 2511 Diag(New->getLocation(), NewDiag); 2512 } else { 2513 Diag(New->getLocation(), diag::err_member_redeclared_in_instantiation) 2514 << New << New->getType(); 2515 } 2516 Diag(Old->getLocation(), PrevDiag) << Old << Old->getType(); 2517 2518 // Complain if this is an explicit declaration of a special 2519 // member that was initially declared implicitly. 2520 // 2521 // As an exception, it's okay to befriend such methods in order 2522 // to permit the implicit constructor/destructor/operator calls. 2523 } else if (OldMethod->isImplicit()) { 2524 if (isFriend) { 2525 NewMethod->setImplicit(); 2526 } else { 2527 Diag(NewMethod->getLocation(), 2528 diag::err_definition_of_implicitly_declared_member) 2529 << New << getSpecialMember(OldMethod); 2530 return true; 2531 } 2532 } else if (OldMethod->isExplicitlyDefaulted() && !isFriend) { 2533 Diag(NewMethod->getLocation(), 2534 diag::err_definition_of_explicitly_defaulted_member) 2535 << getSpecialMember(OldMethod); 2536 return true; 2537 } 2538 } 2539 2540 // C++11 [dcl.attr.noreturn]p1: 2541 // The first declaration of a function shall specify the noreturn 2542 // attribute if any declaration of that function specifies the noreturn 2543 // attribute. 2544 if (New->hasAttr<CXX11NoReturnAttr>() && 2545 !Old->hasAttr<CXX11NoReturnAttr>()) { 2546 Diag(New->getAttr<CXX11NoReturnAttr>()->getLocation(), 2547 diag::err_noreturn_missing_on_first_decl); 2548 Diag(Old->getFirstDecl()->getLocation(), 2549 diag::note_noreturn_missing_first_decl); 2550 } 2551 2552 // C++11 [dcl.attr.depend]p2: 2553 // The first declaration of a function shall specify the 2554 // carries_dependency attribute for its declarator-id if any declaration 2555 // of the function specifies the carries_dependency attribute. 2556 if (New->hasAttr<CarriesDependencyAttr>() && 2557 !Old->hasAttr<CarriesDependencyAttr>()) { 2558 Diag(New->getAttr<CarriesDependencyAttr>()->getLocation(), 2559 diag::err_carries_dependency_missing_on_first_decl) << 0/*Function*/; 2560 Diag(Old->getFirstDecl()->getLocation(), 2561 diag::note_carries_dependency_missing_first_decl) << 0/*Function*/; 2562 } 2563 2564 // (C++98 8.3.5p3): 2565 // All declarations for a function shall agree exactly in both the 2566 // return type and the parameter-type-list. 2567 // We also want to respect all the extended bits except noreturn. 2568 2569 // noreturn should now match unless the old type info didn't have it. 2570 QualType OldQTypeForComparison = OldQType; 2571 if (!OldTypeInfo.getNoReturn() && NewTypeInfo.getNoReturn()) { 2572 assert(OldQType == QualType(OldType, 0)); 2573 const FunctionType *OldTypeForComparison 2574 = Context.adjustFunctionType(OldType, OldTypeInfo.withNoReturn(true)); 2575 OldQTypeForComparison = QualType(OldTypeForComparison, 0); 2576 assert(OldQTypeForComparison.isCanonical()); 2577 } 2578 2579 if (haveIncompatibleLanguageLinkages(Old, New)) { 2580 Diag(New->getLocation(), diag::err_different_language_linkage) << New; 2581 Diag(Old->getLocation(), PrevDiag); 2582 return true; 2583 } 2584 2585 if (OldQTypeForComparison == NewQType) 2586 return MergeCompatibleFunctionDecls(New, Old, S, MergeTypeWithOld); 2587 2588 if ((NewQType->isDependentType() || OldQType->isDependentType()) && 2589 New->isLocalExternDecl()) { 2590 // It's OK if we couldn't merge types for a local function declaraton 2591 // if either the old or new type is dependent. We'll merge the types 2592 // when we instantiate the function. 2593 return false; 2594 } 2595 2596 // Fall through for conflicting redeclarations and redefinitions. 2597 } 2598 2599 // C: Function types need to be compatible, not identical. This handles 2600 // duplicate function decls like "void f(int); void f(enum X);" properly. 2601 if (!getLangOpts().CPlusPlus && 2602 Context.typesAreCompatible(OldQType, NewQType)) { 2603 const FunctionType *OldFuncType = OldQType->getAs<FunctionType>(); 2604 const FunctionType *NewFuncType = NewQType->getAs<FunctionType>(); 2605 const FunctionProtoType *OldProto = 0; 2606 if (MergeTypeWithOld && isa<FunctionNoProtoType>(NewFuncType) && 2607 (OldProto = dyn_cast<FunctionProtoType>(OldFuncType))) { 2608 // The old declaration provided a function prototype, but the 2609 // new declaration does not. Merge in the prototype. 2610 assert(!OldProto->hasExceptionSpec() && "Exception spec in C"); 2611 SmallVector<QualType, 16> ParamTypes(OldProto->arg_type_begin(), 2612 OldProto->arg_type_end()); 2613 NewQType = Context.getFunctionType(NewFuncType->getResultType(), 2614 ParamTypes, 2615 OldProto->getExtProtoInfo()); 2616 New->setType(NewQType); 2617 New->setHasInheritedPrototype(); 2618 2619 // Synthesize a parameter for each argument type. 2620 SmallVector<ParmVarDecl*, 16> Params; 2621 for (FunctionProtoType::arg_type_iterator 2622 ParamType = OldProto->arg_type_begin(), 2623 ParamEnd = OldProto->arg_type_end(); 2624 ParamType != ParamEnd; ++ParamType) { 2625 ParmVarDecl *Param = ParmVarDecl::Create(Context, New, 2626 SourceLocation(), 2627 SourceLocation(), 0, 2628 *ParamType, /*TInfo=*/0, 2629 SC_None, 2630 0); 2631 Param->setScopeInfo(0, Params.size()); 2632 Param->setImplicit(); 2633 Params.push_back(Param); 2634 } 2635 2636 New->setParams(Params); 2637 } 2638 2639 return MergeCompatibleFunctionDecls(New, Old, S, MergeTypeWithOld); 2640 } 2641 2642 // GNU C permits a K&R definition to follow a prototype declaration 2643 // if the declared types of the parameters in the K&R definition 2644 // match the types in the prototype declaration, even when the 2645 // promoted types of the parameters from the K&R definition differ 2646 // from the types in the prototype. GCC then keeps the types from 2647 // the prototype. 2648 // 2649 // If a variadic prototype is followed by a non-variadic K&R definition, 2650 // the K&R definition becomes variadic. This is sort of an edge case, but 2651 // it's legal per the standard depending on how you read C99 6.7.5.3p15 and 2652 // C99 6.9.1p8. 2653 if (!getLangOpts().CPlusPlus && 2654 Old->hasPrototype() && !New->hasPrototype() && 2655 New->getType()->getAs<FunctionProtoType>() && 2656 Old->getNumParams() == New->getNumParams()) { 2657 SmallVector<QualType, 16> ArgTypes; 2658 SmallVector<GNUCompatibleParamWarning, 16> Warnings; 2659 const FunctionProtoType *OldProto 2660 = Old->getType()->getAs<FunctionProtoType>(); 2661 const FunctionProtoType *NewProto 2662 = New->getType()->getAs<FunctionProtoType>(); 2663 2664 // Determine whether this is the GNU C extension. 2665 QualType MergedReturn = Context.mergeTypes(OldProto->getResultType(), 2666 NewProto->getResultType()); 2667 bool LooseCompatible = !MergedReturn.isNull(); 2668 for (unsigned Idx = 0, End = Old->getNumParams(); 2669 LooseCompatible && Idx != End; ++Idx) { 2670 ParmVarDecl *OldParm = Old->getParamDecl(Idx); 2671 ParmVarDecl *NewParm = New->getParamDecl(Idx); 2672 if (Context.typesAreCompatible(OldParm->getType(), 2673 NewProto->getArgType(Idx))) { 2674 ArgTypes.push_back(NewParm->getType()); 2675 } else if (Context.typesAreCompatible(OldParm->getType(), 2676 NewParm->getType(), 2677 /*CompareUnqualified=*/true)) { 2678 GNUCompatibleParamWarning Warn 2679 = { OldParm, NewParm, NewProto->getArgType(Idx) }; 2680 Warnings.push_back(Warn); 2681 ArgTypes.push_back(NewParm->getType()); 2682 } else 2683 LooseCompatible = false; 2684 } 2685 2686 if (LooseCompatible) { 2687 for (unsigned Warn = 0; Warn < Warnings.size(); ++Warn) { 2688 Diag(Warnings[Warn].NewParm->getLocation(), 2689 diag::ext_param_promoted_not_compatible_with_prototype) 2690 << Warnings[Warn].PromotedType 2691 << Warnings[Warn].OldParm->getType(); 2692 if (Warnings[Warn].OldParm->getLocation().isValid()) 2693 Diag(Warnings[Warn].OldParm->getLocation(), 2694 diag::note_previous_declaration); 2695 } 2696 2697 if (MergeTypeWithOld) 2698 New->setType(Context.getFunctionType(MergedReturn, ArgTypes, 2699 OldProto->getExtProtoInfo())); 2700 return MergeCompatibleFunctionDecls(New, Old, S, MergeTypeWithOld); 2701 } 2702 2703 // Fall through to diagnose conflicting types. 2704 } 2705 2706 // A function that has already been declared has been redeclared or 2707 // defined with a different type; show an appropriate diagnostic. 2708 2709 // If the previous declaration was an implicitly-generated builtin 2710 // declaration, then at the very least we should use a specialized note. 2711 unsigned BuiltinID; 2712 if (Old->isImplicit() && (BuiltinID = Old->getBuiltinID())) { 2713 // If it's actually a library-defined builtin function like 'malloc' 2714 // or 'printf', just warn about the incompatible redeclaration. 2715 if (Context.BuiltinInfo.isPredefinedLibFunction(BuiltinID)) { 2716 Diag(New->getLocation(), diag::warn_redecl_library_builtin) << New; 2717 Diag(Old->getLocation(), diag::note_previous_builtin_declaration) 2718 << Old << Old->getType(); 2719 2720 // If this is a global redeclaration, just forget hereafter 2721 // about the "builtin-ness" of the function. 2722 // 2723 // Doing this for local extern declarations is problematic. If 2724 // the builtin declaration remains visible, a second invalid 2725 // local declaration will produce a hard error; if it doesn't 2726 // remain visible, a single bogus local redeclaration (which is 2727 // actually only a warning) could break all the downstream code. 2728 if (!New->getLexicalDeclContext()->isFunctionOrMethod()) 2729 New->getIdentifier()->setBuiltinID(Builtin::NotBuiltin); 2730 2731 return false; 2732 } 2733 2734 PrevDiag = diag::note_previous_builtin_declaration; 2735 } 2736 2737 Diag(New->getLocation(), diag::err_conflicting_types) << New->getDeclName(); 2738 Diag(Old->getLocation(), PrevDiag) << Old << Old->getType(); 2739 return true; 2740} 2741 2742/// \brief Completes the merge of two function declarations that are 2743/// known to be compatible. 2744/// 2745/// This routine handles the merging of attributes and other 2746/// properties of function declarations from the old declaration to 2747/// the new declaration, once we know that New is in fact a 2748/// redeclaration of Old. 2749/// 2750/// \returns false 2751bool Sema::MergeCompatibleFunctionDecls(FunctionDecl *New, FunctionDecl *Old, 2752 Scope *S, bool MergeTypeWithOld) { 2753 // Merge the attributes 2754 mergeDeclAttributes(New, Old); 2755 2756 // Merge "pure" flag. 2757 if (Old->isPure()) 2758 New->setPure(); 2759 2760 // Merge "used" flag. 2761 New->setIsUsed(Old->isUsed(false)); 2762 2763 // Merge attributes from the parameters. These can mismatch with K&R 2764 // declarations. 2765 if (New->getNumParams() == Old->getNumParams()) 2766 for (unsigned i = 0, e = New->getNumParams(); i != e; ++i) 2767 mergeParamDeclAttributes(New->getParamDecl(i), Old->getParamDecl(i), 2768 *this); 2769 2770 if (getLangOpts().CPlusPlus) 2771 return MergeCXXFunctionDecl(New, Old, S); 2772 2773 // Merge the function types so the we get the composite types for the return 2774 // and argument types. Per C11 6.2.7/4, only update the type if the old decl 2775 // was visible. 2776 QualType Merged = Context.mergeTypes(Old->getType(), New->getType()); 2777 if (!Merged.isNull() && MergeTypeWithOld) 2778 New->setType(Merged); 2779 2780 return false; 2781} 2782 2783 2784void Sema::mergeObjCMethodDecls(ObjCMethodDecl *newMethod, 2785 ObjCMethodDecl *oldMethod) { 2786 2787 // Merge the attributes, including deprecated/unavailable 2788 AvailabilityMergeKind MergeKind = 2789 isa<ObjCImplDecl>(newMethod->getDeclContext()) ? AMK_Redeclaration 2790 : AMK_Override; 2791 mergeDeclAttributes(newMethod, oldMethod, MergeKind); 2792 2793 // Merge attributes from the parameters. 2794 ObjCMethodDecl::param_const_iterator oi = oldMethod->param_begin(), 2795 oe = oldMethod->param_end(); 2796 for (ObjCMethodDecl::param_iterator 2797 ni = newMethod->param_begin(), ne = newMethod->param_end(); 2798 ni != ne && oi != oe; ++ni, ++oi) 2799 mergeParamDeclAttributes(*ni, *oi, *this); 2800 2801 CheckObjCMethodOverride(newMethod, oldMethod); 2802} 2803 2804/// MergeVarDeclTypes - We parsed a variable 'New' which has the same name and 2805/// scope as a previous declaration 'Old'. Figure out how to merge their types, 2806/// emitting diagnostics as appropriate. 2807/// 2808/// Declarations using the auto type specifier (C++ [decl.spec.auto]) call back 2809/// to here in AddInitializerToDecl. We can't check them before the initializer 2810/// is attached. 2811void Sema::MergeVarDeclTypes(VarDecl *New, VarDecl *Old, 2812 bool MergeTypeWithOld) { 2813 if (New->isInvalidDecl() || Old->isInvalidDecl()) 2814 return; 2815 2816 QualType MergedT; 2817 if (getLangOpts().CPlusPlus) { 2818 if (New->getType()->isUndeducedType()) { 2819 // We don't know what the new type is until the initializer is attached. 2820 return; 2821 } else if (Context.hasSameType(New->getType(), Old->getType())) { 2822 // These could still be something that needs exception specs checked. 2823 return MergeVarDeclExceptionSpecs(New, Old); 2824 } 2825 // C++ [basic.link]p10: 2826 // [...] the types specified by all declarations referring to a given 2827 // object or function shall be identical, except that declarations for an 2828 // array object can specify array types that differ by the presence or 2829 // absence of a major array bound (8.3.4). 2830 else if (Old->getType()->isIncompleteArrayType() && 2831 New->getType()->isArrayType()) { 2832 const ArrayType *OldArray = Context.getAsArrayType(Old->getType()); 2833 const ArrayType *NewArray = Context.getAsArrayType(New->getType()); 2834 if (Context.hasSameType(OldArray->getElementType(), 2835 NewArray->getElementType())) 2836 MergedT = New->getType(); 2837 } else if (Old->getType()->isArrayType() && 2838 New->getType()->isIncompleteArrayType()) { 2839 const ArrayType *OldArray = Context.getAsArrayType(Old->getType()); 2840 const ArrayType *NewArray = Context.getAsArrayType(New->getType()); 2841 if (Context.hasSameType(OldArray->getElementType(), 2842 NewArray->getElementType())) 2843 MergedT = Old->getType(); 2844 } else if (New->getType()->isObjCObjectPointerType() && 2845 Old->getType()->isObjCObjectPointerType()) { 2846 MergedT = Context.mergeObjCGCQualifiers(New->getType(), 2847 Old->getType()); 2848 } 2849 } else { 2850 // C 6.2.7p2: 2851 // All declarations that refer to the same object or function shall have 2852 // compatible type. 2853 MergedT = Context.mergeTypes(New->getType(), Old->getType()); 2854 } 2855 if (MergedT.isNull()) { 2856 // It's OK if we couldn't merge types if either type is dependent, for a 2857 // block-scope variable. In other cases (static data members of class 2858 // templates, variable templates, ...), we require the types to be 2859 // equivalent. 2860 // FIXME: The C++ standard doesn't say anything about this. 2861 if ((New->getType()->isDependentType() || 2862 Old->getType()->isDependentType()) && New->isLocalVarDecl()) { 2863 // If the old type was dependent, we can't merge with it, so the new type 2864 // becomes dependent for now. We'll reproduce the original type when we 2865 // instantiate the TypeSourceInfo for the variable. 2866 if (!New->getType()->isDependentType() && MergeTypeWithOld) 2867 New->setType(Context.DependentTy); 2868 return; 2869 } 2870 2871 // FIXME: Even if this merging succeeds, some other non-visible declaration 2872 // of this variable might have an incompatible type. For instance: 2873 // 2874 // extern int arr[]; 2875 // void f() { extern int arr[2]; } 2876 // void g() { extern int arr[3]; } 2877 // 2878 // Neither C nor C++ requires a diagnostic for this, but we should still try 2879 // to diagnose it. 2880 Diag(New->getLocation(), diag::err_redefinition_different_type) 2881 << New->getDeclName() << New->getType() << Old->getType(); 2882 Diag(Old->getLocation(), diag::note_previous_definition); 2883 return New->setInvalidDecl(); 2884 } 2885 2886 // Don't actually update the type on the new declaration if the old 2887 // declaration was an extern declaration in a different scope. 2888 if (MergeTypeWithOld) 2889 New->setType(MergedT); 2890} 2891 2892static bool mergeTypeWithPrevious(Sema &S, VarDecl *NewVD, VarDecl *OldVD, 2893 LookupResult &Previous) { 2894 // C11 6.2.7p4: 2895 // For an identifier with internal or external linkage declared 2896 // in a scope in which a prior declaration of that identifier is 2897 // visible, if the prior declaration specifies internal or 2898 // external linkage, the type of the identifier at the later 2899 // declaration becomes the composite type. 2900 // 2901 // If the variable isn't visible, we do not merge with its type. 2902 if (Previous.isShadowed()) 2903 return false; 2904 2905 if (S.getLangOpts().CPlusPlus) { 2906 // C++11 [dcl.array]p3: 2907 // If there is a preceding declaration of the entity in the same 2908 // scope in which the bound was specified, an omitted array bound 2909 // is taken to be the same as in that earlier declaration. 2910 return NewVD->isPreviousDeclInSameBlockScope() || 2911 (!OldVD->getLexicalDeclContext()->isFunctionOrMethod() && 2912 !NewVD->getLexicalDeclContext()->isFunctionOrMethod()); 2913 } else { 2914 // If the old declaration was function-local, don't merge with its 2915 // type unless we're in the same function. 2916 return !OldVD->getLexicalDeclContext()->isFunctionOrMethod() || 2917 OldVD->getLexicalDeclContext() == NewVD->getLexicalDeclContext(); 2918 } 2919} 2920 2921/// MergeVarDecl - We just parsed a variable 'New' which has the same name 2922/// and scope as a previous declaration 'Old'. Figure out how to resolve this 2923/// situation, merging decls or emitting diagnostics as appropriate. 2924/// 2925/// Tentative definition rules (C99 6.9.2p2) are checked by 2926/// FinalizeDeclaratorGroup. Unfortunately, we can't analyze tentative 2927/// definitions here, since the initializer hasn't been attached. 2928/// 2929void Sema::MergeVarDecl(VarDecl *New, LookupResult &Previous) { 2930 // If the new decl is already invalid, don't do any other checking. 2931 if (New->isInvalidDecl()) 2932 return; 2933 2934 // Verify the old decl was also a variable or variable template. 2935 VarDecl *Old = 0; 2936 if (Previous.isSingleResult() && 2937 (Old = dyn_cast<VarDecl>(Previous.getFoundDecl()))) { 2938 if (New->getDescribedVarTemplate()) 2939 Old = Old->getDescribedVarTemplate() ? Old : 0; 2940 else 2941 Old = Old->getDescribedVarTemplate() ? 0 : Old; 2942 } 2943 if (!Old) { 2944 Diag(New->getLocation(), diag::err_redefinition_different_kind) 2945 << New->getDeclName(); 2946 Diag(Previous.getRepresentativeDecl()->getLocation(), 2947 diag::note_previous_definition); 2948 return New->setInvalidDecl(); 2949 } 2950 2951 if (!shouldLinkPossiblyHiddenDecl(Old, New)) 2952 return; 2953 2954 // C++ [class.mem]p1: 2955 // A member shall not be declared twice in the member-specification [...] 2956 // 2957 // Here, we need only consider static data members. 2958 if (Old->isStaticDataMember() && !New->isOutOfLine()) { 2959 Diag(New->getLocation(), diag::err_duplicate_member) 2960 << New->getIdentifier(); 2961 Diag(Old->getLocation(), diag::note_previous_declaration); 2962 New->setInvalidDecl(); 2963 } 2964 2965 mergeDeclAttributes(New, Old); 2966 // Warn if an already-declared variable is made a weak_import in a subsequent 2967 // declaration 2968 if (New->getAttr<WeakImportAttr>() && 2969 Old->getStorageClass() == SC_None && 2970 !Old->getAttr<WeakImportAttr>()) { 2971 Diag(New->getLocation(), diag::warn_weak_import) << New->getDeclName(); 2972 Diag(Old->getLocation(), diag::note_previous_definition); 2973 // Remove weak_import attribute on new declaration. 2974 New->dropAttr<WeakImportAttr>(); 2975 } 2976 2977 // Merge the types. 2978 MergeVarDeclTypes(New, Old, mergeTypeWithPrevious(*this, New, Old, Previous)); 2979 2980 if (New->isInvalidDecl()) 2981 return; 2982 2983 // [dcl.stc]p8: Check if we have a non-static decl followed by a static. 2984 if (New->getStorageClass() == SC_Static && 2985 !New->isStaticDataMember() && 2986 Old->hasExternalFormalLinkage()) { 2987 Diag(New->getLocation(), diag::err_static_non_static) << New->getDeclName(); 2988 Diag(Old->getLocation(), diag::note_previous_definition); 2989 return New->setInvalidDecl(); 2990 } 2991 // C99 6.2.2p4: 2992 // For an identifier declared with the storage-class specifier 2993 // extern in a scope in which a prior declaration of that 2994 // identifier is visible,23) if the prior declaration specifies 2995 // internal or external linkage, the linkage of the identifier at 2996 // the later declaration is the same as the linkage specified at 2997 // the prior declaration. If no prior declaration is visible, or 2998 // if the prior declaration specifies no linkage, then the 2999 // identifier has external linkage. 3000 if (New->hasExternalStorage() && Old->hasLinkage()) 3001 /* Okay */; 3002 else if (New->getCanonicalDecl()->getStorageClass() != SC_Static && 3003 !New->isStaticDataMember() && 3004 Old->getCanonicalDecl()->getStorageClass() == SC_Static) { 3005 Diag(New->getLocation(), diag::err_non_static_static) << New->getDeclName(); 3006 Diag(Old->getLocation(), diag::note_previous_definition); 3007 return New->setInvalidDecl(); 3008 } 3009 3010 // Check if extern is followed by non-extern and vice-versa. 3011 if (New->hasExternalStorage() && 3012 !Old->hasLinkage() && Old->isLocalVarDecl()) { 3013 Diag(New->getLocation(), diag::err_extern_non_extern) << New->getDeclName(); 3014 Diag(Old->getLocation(), diag::note_previous_definition); 3015 return New->setInvalidDecl(); 3016 } 3017 if (Old->hasLinkage() && New->isLocalVarDecl() && 3018 !New->hasExternalStorage()) { 3019 Diag(New->getLocation(), diag::err_non_extern_extern) << New->getDeclName(); 3020 Diag(Old->getLocation(), diag::note_previous_definition); 3021 return New->setInvalidDecl(); 3022 } 3023 3024 // Variables with external linkage are analyzed in FinalizeDeclaratorGroup. 3025 3026 // FIXME: The test for external storage here seems wrong? We still 3027 // need to check for mismatches. 3028 if (!New->hasExternalStorage() && !New->isFileVarDecl() && 3029 // Don't complain about out-of-line definitions of static members. 3030 !(Old->getLexicalDeclContext()->isRecord() && 3031 !New->getLexicalDeclContext()->isRecord())) { 3032 Diag(New->getLocation(), diag::err_redefinition) << New->getDeclName(); 3033 Diag(Old->getLocation(), diag::note_previous_definition); 3034 return New->setInvalidDecl(); 3035 } 3036 3037 if (New->getTLSKind() != Old->getTLSKind()) { 3038 if (!Old->getTLSKind()) { 3039 Diag(New->getLocation(), diag::err_thread_non_thread) << New->getDeclName(); 3040 Diag(Old->getLocation(), diag::note_previous_declaration); 3041 } else if (!New->getTLSKind()) { 3042 Diag(New->getLocation(), diag::err_non_thread_thread) << New->getDeclName(); 3043 Diag(Old->getLocation(), diag::note_previous_declaration); 3044 } else { 3045 // Do not allow redeclaration to change the variable between requiring 3046 // static and dynamic initialization. 3047 // FIXME: GCC allows this, but uses the TLS keyword on the first 3048 // declaration to determine the kind. Do we need to be compatible here? 3049 Diag(New->getLocation(), diag::err_thread_thread_different_kind) 3050 << New->getDeclName() << (New->getTLSKind() == VarDecl::TLS_Dynamic); 3051 Diag(Old->getLocation(), diag::note_previous_declaration); 3052 } 3053 } 3054 3055 // C++ doesn't have tentative definitions, so go right ahead and check here. 3056 const VarDecl *Def; 3057 if (getLangOpts().CPlusPlus && 3058 New->isThisDeclarationADefinition() == VarDecl::Definition && 3059 (Def = Old->getDefinition())) { 3060 Diag(New->getLocation(), diag::err_redefinition) << New; 3061 Diag(Def->getLocation(), diag::note_previous_definition); 3062 New->setInvalidDecl(); 3063 return; 3064 } 3065 3066 if (haveIncompatibleLanguageLinkages(Old, New)) { 3067 Diag(New->getLocation(), diag::err_different_language_linkage) << New; 3068 Diag(Old->getLocation(), diag::note_previous_definition); 3069 New->setInvalidDecl(); 3070 return; 3071 } 3072 3073 // Merge "used" flag. 3074 New->setIsUsed(Old->isUsed(false)); 3075 3076 // Keep a chain of previous declarations. 3077 New->setPreviousDecl(Old); 3078 3079 // Inherit access appropriately. 3080 New->setAccess(Old->getAccess()); 3081 3082 if (VarTemplateDecl *VTD = New->getDescribedVarTemplate()) { 3083 if (New->isStaticDataMember() && New->isOutOfLine()) 3084 VTD->setAccess(New->getAccess()); 3085 } 3086} 3087 3088/// ParsedFreeStandingDeclSpec - This method is invoked when a declspec with 3089/// no declarator (e.g. "struct foo;") is parsed. 3090Decl *Sema::ParsedFreeStandingDeclSpec(Scope *S, AccessSpecifier AS, 3091 DeclSpec &DS) { 3092 return ParsedFreeStandingDeclSpec(S, AS, DS, MultiTemplateParamsArg()); 3093} 3094 3095static void HandleTagNumbering(Sema &S, const TagDecl *Tag) { 3096 if (!S.Context.getLangOpts().CPlusPlus) 3097 return; 3098 3099 if (isa<CXXRecordDecl>(Tag->getParent())) { 3100 // If this tag is the direct child of a class, number it if 3101 // it is anonymous. 3102 if (!Tag->getName().empty() || Tag->getTypedefNameForAnonDecl()) 3103 return; 3104 MangleNumberingContext &MCtx = 3105 S.Context.getManglingNumberContext(Tag->getParent()); 3106 S.Context.setManglingNumber(Tag, MCtx.getManglingNumber(Tag)); 3107 return; 3108 } 3109 3110 // If this tag isn't a direct child of a class, number it if it is local. 3111 Decl *ManglingContextDecl; 3112 if (MangleNumberingContext *MCtx = 3113 S.getCurrentMangleNumberContext(Tag->getDeclContext(), 3114 ManglingContextDecl)) { 3115 S.Context.setManglingNumber(Tag, MCtx->getManglingNumber(Tag)); 3116 } 3117} 3118 3119/// ParsedFreeStandingDeclSpec - This method is invoked when a declspec with 3120/// no declarator (e.g. "struct foo;") is parsed. It also accepts template 3121/// parameters to cope with template friend declarations. 3122Decl *Sema::ParsedFreeStandingDeclSpec(Scope *S, AccessSpecifier AS, 3123 DeclSpec &DS, 3124 MultiTemplateParamsArg TemplateParams, 3125 bool IsExplicitInstantiation) { 3126 Decl *TagD = 0; 3127 TagDecl *Tag = 0; 3128 if (DS.getTypeSpecType() == DeclSpec::TST_class || 3129 DS.getTypeSpecType() == DeclSpec::TST_struct || 3130 DS.getTypeSpecType() == DeclSpec::TST_interface || 3131 DS.getTypeSpecType() == DeclSpec::TST_union || 3132 DS.getTypeSpecType() == DeclSpec::TST_enum) { 3133 TagD = DS.getRepAsDecl(); 3134 3135 if (!TagD) // We probably had an error 3136 return 0; 3137 3138 // Note that the above type specs guarantee that the 3139 // type rep is a Decl, whereas in many of the others 3140 // it's a Type. 3141 if (isa<TagDecl>(TagD)) 3142 Tag = cast<TagDecl>(TagD); 3143 else if (ClassTemplateDecl *CTD = dyn_cast<ClassTemplateDecl>(TagD)) 3144 Tag = CTD->getTemplatedDecl(); 3145 } 3146 3147 if (Tag) { 3148 HandleTagNumbering(*this, Tag); 3149 Tag->setFreeStanding(); 3150 if (Tag->isInvalidDecl()) 3151 return Tag; 3152 } 3153 3154 if (unsigned TypeQuals = DS.getTypeQualifiers()) { 3155 // Enforce C99 6.7.3p2: "Types other than pointer types derived from object 3156 // or incomplete types shall not be restrict-qualified." 3157 if (TypeQuals & DeclSpec::TQ_restrict) 3158 Diag(DS.getRestrictSpecLoc(), 3159 diag::err_typecheck_invalid_restrict_not_pointer_noarg) 3160 << DS.getSourceRange(); 3161 } 3162 3163 if (DS.isConstexprSpecified()) { 3164 // C++0x [dcl.constexpr]p1: constexpr can only be applied to declarations 3165 // and definitions of functions and variables. 3166 if (Tag) 3167 Diag(DS.getConstexprSpecLoc(), diag::err_constexpr_tag) 3168 << (DS.getTypeSpecType() == DeclSpec::TST_class ? 0 : 3169 DS.getTypeSpecType() == DeclSpec::TST_struct ? 1 : 3170 DS.getTypeSpecType() == DeclSpec::TST_interface ? 2 : 3171 DS.getTypeSpecType() == DeclSpec::TST_union ? 3 : 4); 3172 else 3173 Diag(DS.getConstexprSpecLoc(), diag::err_constexpr_no_declarators); 3174 // Don't emit warnings after this error. 3175 return TagD; 3176 } 3177 3178 DiagnoseFunctionSpecifiers(DS); 3179 3180 if (DS.isFriendSpecified()) { 3181 // If we're dealing with a decl but not a TagDecl, assume that 3182 // whatever routines created it handled the friendship aspect. 3183 if (TagD && !Tag) 3184 return 0; 3185 return ActOnFriendTypeDecl(S, DS, TemplateParams); 3186 } 3187 3188 CXXScopeSpec &SS = DS.getTypeSpecScope(); 3189 bool IsExplicitSpecialization = 3190 !TemplateParams.empty() && TemplateParams.back()->size() == 0; 3191 if (Tag && SS.isNotEmpty() && !Tag->isCompleteDefinition() && 3192 !IsExplicitInstantiation && !IsExplicitSpecialization) { 3193 // Per C++ [dcl.type.elab]p1, a class declaration cannot have a 3194 // nested-name-specifier unless it is an explicit instantiation 3195 // or an explicit specialization. 3196 // Per C++ [dcl.enum]p1, an opaque-enum-declaration can't either. 3197 Diag(SS.getBeginLoc(), diag::err_standalone_class_nested_name_specifier) 3198 << (DS.getTypeSpecType() == DeclSpec::TST_class ? 0 : 3199 DS.getTypeSpecType() == DeclSpec::TST_struct ? 1 : 3200 DS.getTypeSpecType() == DeclSpec::TST_interface ? 2 : 3201 DS.getTypeSpecType() == DeclSpec::TST_union ? 3 : 4) 3202 << SS.getRange(); 3203 return 0; 3204 } 3205 3206 // Track whether this decl-specifier declares anything. 3207 bool DeclaresAnything = true; 3208 3209 // Handle anonymous struct definitions. 3210 if (RecordDecl *Record = dyn_cast_or_null<RecordDecl>(Tag)) { 3211 if (!Record->getDeclName() && Record->isCompleteDefinition() && 3212 DS.getStorageClassSpec() != DeclSpec::SCS_typedef) { 3213 if (getLangOpts().CPlusPlus || 3214 Record->getDeclContext()->isRecord()) 3215 return BuildAnonymousStructOrUnion(S, DS, AS, Record); 3216 3217 DeclaresAnything = false; 3218 } 3219 } 3220 3221 // Check for Microsoft C extension: anonymous struct member. 3222 if (getLangOpts().MicrosoftExt && !getLangOpts().CPlusPlus && 3223 CurContext->isRecord() && 3224 DS.getStorageClassSpec() == DeclSpec::SCS_unspecified) { 3225 // Handle 2 kinds of anonymous struct: 3226 // struct STRUCT; 3227 // and 3228 // STRUCT_TYPE; <- where STRUCT_TYPE is a typedef struct. 3229 RecordDecl *Record = dyn_cast_or_null<RecordDecl>(Tag); 3230 if ((Record && Record->getDeclName() && !Record->isCompleteDefinition()) || 3231 (DS.getTypeSpecType() == DeclSpec::TST_typename && 3232 DS.getRepAsType().get()->isStructureType())) { 3233 Diag(DS.getLocStart(), diag::ext_ms_anonymous_struct) 3234 << DS.getSourceRange(); 3235 return BuildMicrosoftCAnonymousStruct(S, DS, Record); 3236 } 3237 } 3238 3239 // Skip all the checks below if we have a type error. 3240 if (DS.getTypeSpecType() == DeclSpec::TST_error || 3241 (TagD && TagD->isInvalidDecl())) 3242 return TagD; 3243 3244 if (getLangOpts().CPlusPlus && 3245 DS.getStorageClassSpec() != DeclSpec::SCS_typedef) 3246 if (EnumDecl *Enum = dyn_cast_or_null<EnumDecl>(Tag)) 3247 if (Enum->enumerator_begin() == Enum->enumerator_end() && 3248 !Enum->getIdentifier() && !Enum->isInvalidDecl()) 3249 DeclaresAnything = false; 3250 3251 if (!DS.isMissingDeclaratorOk()) { 3252 // Customize diagnostic for a typedef missing a name. 3253 if (DS.getStorageClassSpec() == DeclSpec::SCS_typedef) 3254 Diag(DS.getLocStart(), diag::ext_typedef_without_a_name) 3255 << DS.getSourceRange(); 3256 else 3257 DeclaresAnything = false; 3258 } 3259 3260 if (DS.isModulePrivateSpecified() && 3261 Tag && Tag->getDeclContext()->isFunctionOrMethod()) 3262 Diag(DS.getModulePrivateSpecLoc(), diag::err_module_private_local_class) 3263 << Tag->getTagKind() 3264 << FixItHint::CreateRemoval(DS.getModulePrivateSpecLoc()); 3265 3266 ActOnDocumentableDecl(TagD); 3267 3268 // C 6.7/2: 3269 // A declaration [...] shall declare at least a declarator [...], a tag, 3270 // or the members of an enumeration. 3271 // C++ [dcl.dcl]p3: 3272 // [If there are no declarators], and except for the declaration of an 3273 // unnamed bit-field, the decl-specifier-seq shall introduce one or more 3274 // names into the program, or shall redeclare a name introduced by a 3275 // previous declaration. 3276 if (!DeclaresAnything) { 3277 // In C, we allow this as a (popular) extension / bug. Don't bother 3278 // producing further diagnostics for redundant qualifiers after this. 3279 Diag(DS.getLocStart(), diag::ext_no_declarators) << DS.getSourceRange(); 3280 return TagD; 3281 } 3282 3283 // C++ [dcl.stc]p1: 3284 // If a storage-class-specifier appears in a decl-specifier-seq, [...] the 3285 // init-declarator-list of the declaration shall not be empty. 3286 // C++ [dcl.fct.spec]p1: 3287 // If a cv-qualifier appears in a decl-specifier-seq, the 3288 // init-declarator-list of the declaration shall not be empty. 3289 // 3290 // Spurious qualifiers here appear to be valid in C. 3291 unsigned DiagID = diag::warn_standalone_specifier; 3292 if (getLangOpts().CPlusPlus) 3293 DiagID = diag::ext_standalone_specifier; 3294 3295 // Note that a linkage-specification sets a storage class, but 3296 // 'extern "C" struct foo;' is actually valid and not theoretically 3297 // useless. 3298 if (DeclSpec::SCS SCS = DS.getStorageClassSpec()) 3299 if (!DS.isExternInLinkageSpec() && SCS != DeclSpec::SCS_typedef) 3300 Diag(DS.getStorageClassSpecLoc(), DiagID) 3301 << DeclSpec::getSpecifierName(SCS); 3302 3303 if (DeclSpec::TSCS TSCS = DS.getThreadStorageClassSpec()) 3304 Diag(DS.getThreadStorageClassSpecLoc(), DiagID) 3305 << DeclSpec::getSpecifierName(TSCS); 3306 if (DS.getTypeQualifiers()) { 3307 if (DS.getTypeQualifiers() & DeclSpec::TQ_const) 3308 Diag(DS.getConstSpecLoc(), DiagID) << "const"; 3309 if (DS.getTypeQualifiers() & DeclSpec::TQ_volatile) 3310 Diag(DS.getConstSpecLoc(), DiagID) << "volatile"; 3311 // Restrict is covered above. 3312 if (DS.getTypeQualifiers() & DeclSpec::TQ_atomic) 3313 Diag(DS.getAtomicSpecLoc(), DiagID) << "_Atomic"; 3314 } 3315 3316 // Warn about ignored type attributes, for example: 3317 // __attribute__((aligned)) struct A; 3318 // Attributes should be placed after tag to apply to type declaration. 3319 if (!DS.getAttributes().empty()) { 3320 DeclSpec::TST TypeSpecType = DS.getTypeSpecType(); 3321 if (TypeSpecType == DeclSpec::TST_class || 3322 TypeSpecType == DeclSpec::TST_struct || 3323 TypeSpecType == DeclSpec::TST_interface || 3324 TypeSpecType == DeclSpec::TST_union || 3325 TypeSpecType == DeclSpec::TST_enum) { 3326 AttributeList* attrs = DS.getAttributes().getList(); 3327 while (attrs) { 3328 Diag(attrs->getLoc(), diag::warn_declspec_attribute_ignored) 3329 << attrs->getName() 3330 << (TypeSpecType == DeclSpec::TST_class ? 0 : 3331 TypeSpecType == DeclSpec::TST_struct ? 1 : 3332 TypeSpecType == DeclSpec::TST_union ? 2 : 3333 TypeSpecType == DeclSpec::TST_interface ? 3 : 4); 3334 attrs = attrs->getNext(); 3335 } 3336 } 3337 } 3338 3339 return TagD; 3340} 3341 3342/// We are trying to inject an anonymous member into the given scope; 3343/// check if there's an existing declaration that can't be overloaded. 3344/// 3345/// \return true if this is a forbidden redeclaration 3346static bool CheckAnonMemberRedeclaration(Sema &SemaRef, 3347 Scope *S, 3348 DeclContext *Owner, 3349 DeclarationName Name, 3350 SourceLocation NameLoc, 3351 unsigned diagnostic) { 3352 LookupResult R(SemaRef, Name, NameLoc, Sema::LookupMemberName, 3353 Sema::ForRedeclaration); 3354 if (!SemaRef.LookupName(R, S)) return false; 3355 3356 if (R.getAsSingle<TagDecl>()) 3357 return false; 3358 3359 // Pick a representative declaration. 3360 NamedDecl *PrevDecl = R.getRepresentativeDecl()->getUnderlyingDecl(); 3361 assert(PrevDecl && "Expected a non-null Decl"); 3362 3363 if (!SemaRef.isDeclInScope(PrevDecl, Owner, S)) 3364 return false; 3365 3366 SemaRef.Diag(NameLoc, diagnostic) << Name; 3367 SemaRef.Diag(PrevDecl->getLocation(), diag::note_previous_declaration); 3368 3369 return true; 3370} 3371 3372/// InjectAnonymousStructOrUnionMembers - Inject the members of the 3373/// anonymous struct or union AnonRecord into the owning context Owner 3374/// and scope S. This routine will be invoked just after we realize 3375/// that an unnamed union or struct is actually an anonymous union or 3376/// struct, e.g., 3377/// 3378/// @code 3379/// union { 3380/// int i; 3381/// float f; 3382/// }; // InjectAnonymousStructOrUnionMembers called here to inject i and 3383/// // f into the surrounding scope.x 3384/// @endcode 3385/// 3386/// This routine is recursive, injecting the names of nested anonymous 3387/// structs/unions into the owning context and scope as well. 3388static bool InjectAnonymousStructOrUnionMembers(Sema &SemaRef, Scope *S, 3389 DeclContext *Owner, 3390 RecordDecl *AnonRecord, 3391 AccessSpecifier AS, 3392 SmallVectorImpl<NamedDecl *> &Chaining, 3393 bool MSAnonStruct) { 3394 unsigned diagKind 3395 = AnonRecord->isUnion() ? diag::err_anonymous_union_member_redecl 3396 : diag::err_anonymous_struct_member_redecl; 3397 3398 bool Invalid = false; 3399 3400 // Look every FieldDecl and IndirectFieldDecl with a name. 3401 for (RecordDecl::decl_iterator D = AnonRecord->decls_begin(), 3402 DEnd = AnonRecord->decls_end(); 3403 D != DEnd; ++D) { 3404 if ((isa<FieldDecl>(*D) || isa<IndirectFieldDecl>(*D)) && 3405 cast<NamedDecl>(*D)->getDeclName()) { 3406 ValueDecl *VD = cast<ValueDecl>(*D); 3407 if (CheckAnonMemberRedeclaration(SemaRef, S, Owner, VD->getDeclName(), 3408 VD->getLocation(), diagKind)) { 3409 // C++ [class.union]p2: 3410 // The names of the members of an anonymous union shall be 3411 // distinct from the names of any other entity in the 3412 // scope in which the anonymous union is declared. 3413 Invalid = true; 3414 } else { 3415 // C++ [class.union]p2: 3416 // For the purpose of name lookup, after the anonymous union 3417 // definition, the members of the anonymous union are 3418 // considered to have been defined in the scope in which the 3419 // anonymous union is declared. 3420 unsigned OldChainingSize = Chaining.size(); 3421 if (IndirectFieldDecl *IF = dyn_cast<IndirectFieldDecl>(VD)) 3422 for (IndirectFieldDecl::chain_iterator PI = IF->chain_begin(), 3423 PE = IF->chain_end(); PI != PE; ++PI) 3424 Chaining.push_back(*PI); 3425 else 3426 Chaining.push_back(VD); 3427 3428 assert(Chaining.size() >= 2); 3429 NamedDecl **NamedChain = 3430 new (SemaRef.Context)NamedDecl*[Chaining.size()]; 3431 for (unsigned i = 0; i < Chaining.size(); i++) 3432 NamedChain[i] = Chaining[i]; 3433 3434 IndirectFieldDecl* IndirectField = 3435 IndirectFieldDecl::Create(SemaRef.Context, Owner, VD->getLocation(), 3436 VD->getIdentifier(), VD->getType(), 3437 NamedChain, Chaining.size()); 3438 3439 IndirectField->setAccess(AS); 3440 IndirectField->setImplicit(); 3441 SemaRef.PushOnScopeChains(IndirectField, S); 3442 3443 // That includes picking up the appropriate access specifier. 3444 if (AS != AS_none) IndirectField->setAccess(AS); 3445 3446 Chaining.resize(OldChainingSize); 3447 } 3448 } 3449 } 3450 3451 return Invalid; 3452} 3453 3454/// StorageClassSpecToVarDeclStorageClass - Maps a DeclSpec::SCS to 3455/// a VarDecl::StorageClass. Any error reporting is up to the caller: 3456/// illegal input values are mapped to SC_None. 3457static StorageClass 3458StorageClassSpecToVarDeclStorageClass(const DeclSpec &DS) { 3459 DeclSpec::SCS StorageClassSpec = DS.getStorageClassSpec(); 3460 assert(StorageClassSpec != DeclSpec::SCS_typedef && 3461 "Parser allowed 'typedef' as storage class VarDecl."); 3462 switch (StorageClassSpec) { 3463 case DeclSpec::SCS_unspecified: return SC_None; 3464 case DeclSpec::SCS_extern: 3465 if (DS.isExternInLinkageSpec()) 3466 return SC_None; 3467 return SC_Extern; 3468 case DeclSpec::SCS_static: return SC_Static; 3469 case DeclSpec::SCS_auto: return SC_Auto; 3470 case DeclSpec::SCS_register: return SC_Register; 3471 case DeclSpec::SCS_private_extern: return SC_PrivateExtern; 3472 // Illegal SCSs map to None: error reporting is up to the caller. 3473 case DeclSpec::SCS_mutable: // Fall through. 3474 case DeclSpec::SCS_typedef: return SC_None; 3475 } 3476 llvm_unreachable("unknown storage class specifier"); 3477} 3478 3479/// BuildAnonymousStructOrUnion - Handle the declaration of an 3480/// anonymous structure or union. Anonymous unions are a C++ feature 3481/// (C++ [class.union]) and a C11 feature; anonymous structures 3482/// are a C11 feature and GNU C++ extension. 3483Decl *Sema::BuildAnonymousStructOrUnion(Scope *S, DeclSpec &DS, 3484 AccessSpecifier AS, 3485 RecordDecl *Record) { 3486 DeclContext *Owner = Record->getDeclContext(); 3487 3488 // Diagnose whether this anonymous struct/union is an extension. 3489 if (Record->isUnion() && !getLangOpts().CPlusPlus && !getLangOpts().C11) 3490 Diag(Record->getLocation(), diag::ext_anonymous_union); 3491 else if (!Record->isUnion() && getLangOpts().CPlusPlus) 3492 Diag(Record->getLocation(), diag::ext_gnu_anonymous_struct); 3493 else if (!Record->isUnion() && !getLangOpts().C11) 3494 Diag(Record->getLocation(), diag::ext_c11_anonymous_struct); 3495 3496 // C and C++ require different kinds of checks for anonymous 3497 // structs/unions. 3498 bool Invalid = false; 3499 if (getLangOpts().CPlusPlus) { 3500 const char* PrevSpec = 0; 3501 unsigned DiagID; 3502 if (Record->isUnion()) { 3503 // C++ [class.union]p6: 3504 // Anonymous unions declared in a named namespace or in the 3505 // global namespace shall be declared static. 3506 if (DS.getStorageClassSpec() != DeclSpec::SCS_static && 3507 (isa<TranslationUnitDecl>(Owner) || 3508 (isa<NamespaceDecl>(Owner) && 3509 cast<NamespaceDecl>(Owner)->getDeclName()))) { 3510 Diag(Record->getLocation(), diag::err_anonymous_union_not_static) 3511 << FixItHint::CreateInsertion(Record->getLocation(), "static "); 3512 3513 // Recover by adding 'static'. 3514 DS.SetStorageClassSpec(*this, DeclSpec::SCS_static, SourceLocation(), 3515 PrevSpec, DiagID); 3516 } 3517 // C++ [class.union]p6: 3518 // A storage class is not allowed in a declaration of an 3519 // anonymous union in a class scope. 3520 else if (DS.getStorageClassSpec() != DeclSpec::SCS_unspecified && 3521 isa<RecordDecl>(Owner)) { 3522 Diag(DS.getStorageClassSpecLoc(), 3523 diag::err_anonymous_union_with_storage_spec) 3524 << FixItHint::CreateRemoval(DS.getStorageClassSpecLoc()); 3525 3526 // Recover by removing the storage specifier. 3527 DS.SetStorageClassSpec(*this, DeclSpec::SCS_unspecified, 3528 SourceLocation(), 3529 PrevSpec, DiagID); 3530 } 3531 } 3532 3533 // Ignore const/volatile/restrict qualifiers. 3534 if (DS.getTypeQualifiers()) { 3535 if (DS.getTypeQualifiers() & DeclSpec::TQ_const) 3536 Diag(DS.getConstSpecLoc(), diag::ext_anonymous_struct_union_qualified) 3537 << Record->isUnion() << "const" 3538 << FixItHint::CreateRemoval(DS.getConstSpecLoc()); 3539 if (DS.getTypeQualifiers() & DeclSpec::TQ_volatile) 3540 Diag(DS.getVolatileSpecLoc(), 3541 diag::ext_anonymous_struct_union_qualified) 3542 << Record->isUnion() << "volatile" 3543 << FixItHint::CreateRemoval(DS.getVolatileSpecLoc()); 3544 if (DS.getTypeQualifiers() & DeclSpec::TQ_restrict) 3545 Diag(DS.getRestrictSpecLoc(), 3546 diag::ext_anonymous_struct_union_qualified) 3547 << Record->isUnion() << "restrict" 3548 << FixItHint::CreateRemoval(DS.getRestrictSpecLoc()); 3549 if (DS.getTypeQualifiers() & DeclSpec::TQ_atomic) 3550 Diag(DS.getAtomicSpecLoc(), 3551 diag::ext_anonymous_struct_union_qualified) 3552 << Record->isUnion() << "_Atomic" 3553 << FixItHint::CreateRemoval(DS.getAtomicSpecLoc()); 3554 3555 DS.ClearTypeQualifiers(); 3556 } 3557 3558 // C++ [class.union]p2: 3559 // The member-specification of an anonymous union shall only 3560 // define non-static data members. [Note: nested types and 3561 // functions cannot be declared within an anonymous union. ] 3562 for (DeclContext::decl_iterator Mem = Record->decls_begin(), 3563 MemEnd = Record->decls_end(); 3564 Mem != MemEnd; ++Mem) { 3565 if (FieldDecl *FD = dyn_cast<FieldDecl>(*Mem)) { 3566 // C++ [class.union]p3: 3567 // An anonymous union shall not have private or protected 3568 // members (clause 11). 3569 assert(FD->getAccess() != AS_none); 3570 if (FD->getAccess() != AS_public) { 3571 Diag(FD->getLocation(), diag::err_anonymous_record_nonpublic_member) 3572 << (int)Record->isUnion() << (int)(FD->getAccess() == AS_protected); 3573 Invalid = true; 3574 } 3575 3576 // C++ [class.union]p1 3577 // An object of a class with a non-trivial constructor, a non-trivial 3578 // copy constructor, a non-trivial destructor, or a non-trivial copy 3579 // assignment operator cannot be a member of a union, nor can an 3580 // array of such objects. 3581 if (CheckNontrivialField(FD)) 3582 Invalid = true; 3583 } else if ((*Mem)->isImplicit()) { 3584 // Any implicit members are fine. 3585 } else if (isa<TagDecl>(*Mem) && (*Mem)->getDeclContext() != Record) { 3586 // This is a type that showed up in an 3587 // elaborated-type-specifier inside the anonymous struct or 3588 // union, but which actually declares a type outside of the 3589 // anonymous struct or union. It's okay. 3590 } else if (RecordDecl *MemRecord = dyn_cast<RecordDecl>(*Mem)) { 3591 if (!MemRecord->isAnonymousStructOrUnion() && 3592 MemRecord->getDeclName()) { 3593 // Visual C++ allows type definition in anonymous struct or union. 3594 if (getLangOpts().MicrosoftExt) 3595 Diag(MemRecord->getLocation(), diag::ext_anonymous_record_with_type) 3596 << (int)Record->isUnion(); 3597 else { 3598 // This is a nested type declaration. 3599 Diag(MemRecord->getLocation(), diag::err_anonymous_record_with_type) 3600 << (int)Record->isUnion(); 3601 Invalid = true; 3602 } 3603 } else { 3604 // This is an anonymous type definition within another anonymous type. 3605 // This is a popular extension, provided by Plan9, MSVC and GCC, but 3606 // not part of standard C++. 3607 Diag(MemRecord->getLocation(), 3608 diag::ext_anonymous_record_with_anonymous_type) 3609 << (int)Record->isUnion(); 3610 } 3611 } else if (isa<AccessSpecDecl>(*Mem)) { 3612 // Any access specifier is fine. 3613 } else { 3614 // We have something that isn't a non-static data 3615 // member. Complain about it. 3616 unsigned DK = diag::err_anonymous_record_bad_member; 3617 if (isa<TypeDecl>(*Mem)) 3618 DK = diag::err_anonymous_record_with_type; 3619 else if (isa<FunctionDecl>(*Mem)) 3620 DK = diag::err_anonymous_record_with_function; 3621 else if (isa<VarDecl>(*Mem)) 3622 DK = diag::err_anonymous_record_with_static; 3623 3624 // Visual C++ allows type definition in anonymous struct or union. 3625 if (getLangOpts().MicrosoftExt && 3626 DK == diag::err_anonymous_record_with_type) 3627 Diag((*Mem)->getLocation(), diag::ext_anonymous_record_with_type) 3628 << (int)Record->isUnion(); 3629 else { 3630 Diag((*Mem)->getLocation(), DK) 3631 << (int)Record->isUnion(); 3632 Invalid = true; 3633 } 3634 } 3635 } 3636 } 3637 3638 if (!Record->isUnion() && !Owner->isRecord()) { 3639 Diag(Record->getLocation(), diag::err_anonymous_struct_not_member) 3640 << (int)getLangOpts().CPlusPlus; 3641 Invalid = true; 3642 } 3643 3644 // Mock up a declarator. 3645 Declarator Dc(DS, Declarator::MemberContext); 3646 TypeSourceInfo *TInfo = GetTypeForDeclarator(Dc, S); 3647 assert(TInfo && "couldn't build declarator info for anonymous struct/union"); 3648 3649 // Create a declaration for this anonymous struct/union. 3650 NamedDecl *Anon = 0; 3651 if (RecordDecl *OwningClass = dyn_cast<RecordDecl>(Owner)) { 3652 Anon = FieldDecl::Create(Context, OwningClass, 3653 DS.getLocStart(), 3654 Record->getLocation(), 3655 /*IdentifierInfo=*/0, 3656 Context.getTypeDeclType(Record), 3657 TInfo, 3658 /*BitWidth=*/0, /*Mutable=*/false, 3659 /*InitStyle=*/ICIS_NoInit); 3660 Anon->setAccess(AS); 3661 if (getLangOpts().CPlusPlus) 3662 FieldCollector->Add(cast<FieldDecl>(Anon)); 3663 } else { 3664 DeclSpec::SCS SCSpec = DS.getStorageClassSpec(); 3665 VarDecl::StorageClass SC = StorageClassSpecToVarDeclStorageClass(DS); 3666 if (SCSpec == DeclSpec::SCS_mutable) { 3667 // mutable can only appear on non-static class members, so it's always 3668 // an error here 3669 Diag(Record->getLocation(), diag::err_mutable_nonmember); 3670 Invalid = true; 3671 SC = SC_None; 3672 } 3673 3674 Anon = VarDecl::Create(Context, Owner, 3675 DS.getLocStart(), 3676 Record->getLocation(), /*IdentifierInfo=*/0, 3677 Context.getTypeDeclType(Record), 3678 TInfo, SC); 3679 3680 // Default-initialize the implicit variable. This initialization will be 3681 // trivial in almost all cases, except if a union member has an in-class 3682 // initializer: 3683 // union { int n = 0; }; 3684 ActOnUninitializedDecl(Anon, /*TypeMayContainAuto=*/false); 3685 } 3686 Anon->setImplicit(); 3687 3688 // Add the anonymous struct/union object to the current 3689 // context. We'll be referencing this object when we refer to one of 3690 // its members. 3691 Owner->addDecl(Anon); 3692 3693 // Inject the members of the anonymous struct/union into the owning 3694 // context and into the identifier resolver chain for name lookup 3695 // purposes. 3696 SmallVector<NamedDecl*, 2> Chain; 3697 Chain.push_back(Anon); 3698 3699 if (InjectAnonymousStructOrUnionMembers(*this, S, Owner, Record, AS, 3700 Chain, false)) 3701 Invalid = true; 3702 3703 // Mark this as an anonymous struct/union type. Note that we do not 3704 // do this until after we have already checked and injected the 3705 // members of this anonymous struct/union type, because otherwise 3706 // the members could be injected twice: once by DeclContext when it 3707 // builds its lookup table, and once by 3708 // InjectAnonymousStructOrUnionMembers. 3709 Record->setAnonymousStructOrUnion(true); 3710 3711 if (Invalid) 3712 Anon->setInvalidDecl(); 3713 3714 return Anon; 3715} 3716 3717/// BuildMicrosoftCAnonymousStruct - Handle the declaration of an 3718/// Microsoft C anonymous structure. 3719/// Ref: http://msdn.microsoft.com/en-us/library/z2cx9y4f.aspx 3720/// Example: 3721/// 3722/// struct A { int a; }; 3723/// struct B { struct A; int b; }; 3724/// 3725/// void foo() { 3726/// B var; 3727/// var.a = 3; 3728/// } 3729/// 3730Decl *Sema::BuildMicrosoftCAnonymousStruct(Scope *S, DeclSpec &DS, 3731 RecordDecl *Record) { 3732 3733 // If there is no Record, get the record via the typedef. 3734 if (!Record) 3735 Record = DS.getRepAsType().get()->getAsStructureType()->getDecl(); 3736 3737 // Mock up a declarator. 3738 Declarator Dc(DS, Declarator::TypeNameContext); 3739 TypeSourceInfo *TInfo = GetTypeForDeclarator(Dc, S); 3740 assert(TInfo && "couldn't build declarator info for anonymous struct"); 3741 3742 // Create a declaration for this anonymous struct. 3743 NamedDecl* Anon = FieldDecl::Create(Context, 3744 cast<RecordDecl>(CurContext), 3745 DS.getLocStart(), 3746 DS.getLocStart(), 3747 /*IdentifierInfo=*/0, 3748 Context.getTypeDeclType(Record), 3749 TInfo, 3750 /*BitWidth=*/0, /*Mutable=*/false, 3751 /*InitStyle=*/ICIS_NoInit); 3752 Anon->setImplicit(); 3753 3754 // Add the anonymous struct object to the current context. 3755 CurContext->addDecl(Anon); 3756 3757 // Inject the members of the anonymous struct into the current 3758 // context and into the identifier resolver chain for name lookup 3759 // purposes. 3760 SmallVector<NamedDecl*, 2> Chain; 3761 Chain.push_back(Anon); 3762 3763 RecordDecl *RecordDef = Record->getDefinition(); 3764 if (!RecordDef || InjectAnonymousStructOrUnionMembers(*this, S, CurContext, 3765 RecordDef, AS_none, 3766 Chain, true)) 3767 Anon->setInvalidDecl(); 3768 3769 return Anon; 3770} 3771 3772/// GetNameForDeclarator - Determine the full declaration name for the 3773/// given Declarator. 3774DeclarationNameInfo Sema::GetNameForDeclarator(Declarator &D) { 3775 return GetNameFromUnqualifiedId(D.getName()); 3776} 3777 3778/// \brief Retrieves the declaration name from a parsed unqualified-id. 3779DeclarationNameInfo 3780Sema::GetNameFromUnqualifiedId(const UnqualifiedId &Name) { 3781 DeclarationNameInfo NameInfo; 3782 NameInfo.setLoc(Name.StartLocation); 3783 3784 switch (Name.getKind()) { 3785 3786 case UnqualifiedId::IK_ImplicitSelfParam: 3787 case UnqualifiedId::IK_Identifier: 3788 NameInfo.setName(Name.Identifier); 3789 NameInfo.setLoc(Name.StartLocation); 3790 return NameInfo; 3791 3792 case UnqualifiedId::IK_OperatorFunctionId: 3793 NameInfo.setName(Context.DeclarationNames.getCXXOperatorName( 3794 Name.OperatorFunctionId.Operator)); 3795 NameInfo.setLoc(Name.StartLocation); 3796 NameInfo.getInfo().CXXOperatorName.BeginOpNameLoc 3797 = Name.OperatorFunctionId.SymbolLocations[0]; 3798 NameInfo.getInfo().CXXOperatorName.EndOpNameLoc 3799 = Name.EndLocation.getRawEncoding(); 3800 return NameInfo; 3801 3802 case UnqualifiedId::IK_LiteralOperatorId: 3803 NameInfo.setName(Context.DeclarationNames.getCXXLiteralOperatorName( 3804 Name.Identifier)); 3805 NameInfo.setLoc(Name.StartLocation); 3806 NameInfo.setCXXLiteralOperatorNameLoc(Name.EndLocation); 3807 return NameInfo; 3808 3809 case UnqualifiedId::IK_ConversionFunctionId: { 3810 TypeSourceInfo *TInfo; 3811 QualType Ty = GetTypeFromParser(Name.ConversionFunctionId, &TInfo); 3812 if (Ty.isNull()) 3813 return DeclarationNameInfo(); 3814 NameInfo.setName(Context.DeclarationNames.getCXXConversionFunctionName( 3815 Context.getCanonicalType(Ty))); 3816 NameInfo.setLoc(Name.StartLocation); 3817 NameInfo.setNamedTypeInfo(TInfo); 3818 return NameInfo; 3819 } 3820 3821 case UnqualifiedId::IK_ConstructorName: { 3822 TypeSourceInfo *TInfo; 3823 QualType Ty = GetTypeFromParser(Name.ConstructorName, &TInfo); 3824 if (Ty.isNull()) 3825 return DeclarationNameInfo(); 3826 NameInfo.setName(Context.DeclarationNames.getCXXConstructorName( 3827 Context.getCanonicalType(Ty))); 3828 NameInfo.setLoc(Name.StartLocation); 3829 NameInfo.setNamedTypeInfo(TInfo); 3830 return NameInfo; 3831 } 3832 3833 case UnqualifiedId::IK_ConstructorTemplateId: { 3834 // In well-formed code, we can only have a constructor 3835 // template-id that refers to the current context, so go there 3836 // to find the actual type being constructed. 3837 CXXRecordDecl *CurClass = dyn_cast<CXXRecordDecl>(CurContext); 3838 if (!CurClass || CurClass->getIdentifier() != Name.TemplateId->Name) 3839 return DeclarationNameInfo(); 3840 3841 // Determine the type of the class being constructed. 3842 QualType CurClassType = Context.getTypeDeclType(CurClass); 3843 3844 // FIXME: Check two things: that the template-id names the same type as 3845 // CurClassType, and that the template-id does not occur when the name 3846 // was qualified. 3847 3848 NameInfo.setName(Context.DeclarationNames.getCXXConstructorName( 3849 Context.getCanonicalType(CurClassType))); 3850 NameInfo.setLoc(Name.StartLocation); 3851 // FIXME: should we retrieve TypeSourceInfo? 3852 NameInfo.setNamedTypeInfo(0); 3853 return NameInfo; 3854 } 3855 3856 case UnqualifiedId::IK_DestructorName: { 3857 TypeSourceInfo *TInfo; 3858 QualType Ty = GetTypeFromParser(Name.DestructorName, &TInfo); 3859 if (Ty.isNull()) 3860 return DeclarationNameInfo(); 3861 NameInfo.setName(Context.DeclarationNames.getCXXDestructorName( 3862 Context.getCanonicalType(Ty))); 3863 NameInfo.setLoc(Name.StartLocation); 3864 NameInfo.setNamedTypeInfo(TInfo); 3865 return NameInfo; 3866 } 3867 3868 case UnqualifiedId::IK_TemplateId: { 3869 TemplateName TName = Name.TemplateId->Template.get(); 3870 SourceLocation TNameLoc = Name.TemplateId->TemplateNameLoc; 3871 return Context.getNameForTemplate(TName, TNameLoc); 3872 } 3873 3874 } // switch (Name.getKind()) 3875 3876 llvm_unreachable("Unknown name kind"); 3877} 3878 3879static QualType getCoreType(QualType Ty) { 3880 do { 3881 if (Ty->isPointerType() || Ty->isReferenceType()) 3882 Ty = Ty->getPointeeType(); 3883 else if (Ty->isArrayType()) 3884 Ty = Ty->castAsArrayTypeUnsafe()->getElementType(); 3885 else 3886 return Ty.withoutLocalFastQualifiers(); 3887 } while (true); 3888} 3889 3890/// hasSimilarParameters - Determine whether the C++ functions Declaration 3891/// and Definition have "nearly" matching parameters. This heuristic is 3892/// used to improve diagnostics in the case where an out-of-line function 3893/// definition doesn't match any declaration within the class or namespace. 3894/// Also sets Params to the list of indices to the parameters that differ 3895/// between the declaration and the definition. If hasSimilarParameters 3896/// returns true and Params is empty, then all of the parameters match. 3897static bool hasSimilarParameters(ASTContext &Context, 3898 FunctionDecl *Declaration, 3899 FunctionDecl *Definition, 3900 SmallVectorImpl<unsigned> &Params) { 3901 Params.clear(); 3902 if (Declaration->param_size() != Definition->param_size()) 3903 return false; 3904 for (unsigned Idx = 0; Idx < Declaration->param_size(); ++Idx) { 3905 QualType DeclParamTy = Declaration->getParamDecl(Idx)->getType(); 3906 QualType DefParamTy = Definition->getParamDecl(Idx)->getType(); 3907 3908 // The parameter types are identical 3909 if (Context.hasSameType(DefParamTy, DeclParamTy)) 3910 continue; 3911 3912 QualType DeclParamBaseTy = getCoreType(DeclParamTy); 3913 QualType DefParamBaseTy = getCoreType(DefParamTy); 3914 const IdentifierInfo *DeclTyName = DeclParamBaseTy.getBaseTypeIdentifier(); 3915 const IdentifierInfo *DefTyName = DefParamBaseTy.getBaseTypeIdentifier(); 3916 3917 if (Context.hasSameUnqualifiedType(DeclParamBaseTy, DefParamBaseTy) || 3918 (DeclTyName && DeclTyName == DefTyName)) 3919 Params.push_back(Idx); 3920 else // The two parameters aren't even close 3921 return false; 3922 } 3923 3924 return true; 3925} 3926 3927/// NeedsRebuildingInCurrentInstantiation - Checks whether the given 3928/// declarator needs to be rebuilt in the current instantiation. 3929/// Any bits of declarator which appear before the name are valid for 3930/// consideration here. That's specifically the type in the decl spec 3931/// and the base type in any member-pointer chunks. 3932static bool RebuildDeclaratorInCurrentInstantiation(Sema &S, Declarator &D, 3933 DeclarationName Name) { 3934 // The types we specifically need to rebuild are: 3935 // - typenames, typeofs, and decltypes 3936 // - types which will become injected class names 3937 // Of course, we also need to rebuild any type referencing such a 3938 // type. It's safest to just say "dependent", but we call out a 3939 // few cases here. 3940 3941 DeclSpec &DS = D.getMutableDeclSpec(); 3942 switch (DS.getTypeSpecType()) { 3943 case DeclSpec::TST_typename: 3944 case DeclSpec::TST_typeofType: 3945 case DeclSpec::TST_underlyingType: 3946 case DeclSpec::TST_atomic: { 3947 // Grab the type from the parser. 3948 TypeSourceInfo *TSI = 0; 3949 QualType T = S.GetTypeFromParser(DS.getRepAsType(), &TSI); 3950 if (T.isNull() || !T->isDependentType()) break; 3951 3952 // Make sure there's a type source info. This isn't really much 3953 // of a waste; most dependent types should have type source info 3954 // attached already. 3955 if (!TSI) 3956 TSI = S.Context.getTrivialTypeSourceInfo(T, DS.getTypeSpecTypeLoc()); 3957 3958 // Rebuild the type in the current instantiation. 3959 TSI = S.RebuildTypeInCurrentInstantiation(TSI, D.getIdentifierLoc(), Name); 3960 if (!TSI) return true; 3961 3962 // Store the new type back in the decl spec. 3963 ParsedType LocType = S.CreateParsedType(TSI->getType(), TSI); 3964 DS.UpdateTypeRep(LocType); 3965 break; 3966 } 3967 3968 case DeclSpec::TST_decltype: 3969 case DeclSpec::TST_typeofExpr: { 3970 Expr *E = DS.getRepAsExpr(); 3971 ExprResult Result = S.RebuildExprInCurrentInstantiation(E); 3972 if (Result.isInvalid()) return true; 3973 DS.UpdateExprRep(Result.get()); 3974 break; 3975 } 3976 3977 default: 3978 // Nothing to do for these decl specs. 3979 break; 3980 } 3981 3982 // It doesn't matter what order we do this in. 3983 for (unsigned I = 0, E = D.getNumTypeObjects(); I != E; ++I) { 3984 DeclaratorChunk &Chunk = D.getTypeObject(I); 3985 3986 // The only type information in the declarator which can come 3987 // before the declaration name is the base type of a member 3988 // pointer. 3989 if (Chunk.Kind != DeclaratorChunk::MemberPointer) 3990 continue; 3991 3992 // Rebuild the scope specifier in-place. 3993 CXXScopeSpec &SS = Chunk.Mem.Scope(); 3994 if (S.RebuildNestedNameSpecifierInCurrentInstantiation(SS)) 3995 return true; 3996 } 3997 3998 return false; 3999} 4000 4001Decl *Sema::ActOnDeclarator(Scope *S, Declarator &D) { 4002 D.setFunctionDefinitionKind(FDK_Declaration); 4003 Decl *Dcl = HandleDeclarator(S, D, MultiTemplateParamsArg()); 4004 4005 if (OriginalLexicalContext && OriginalLexicalContext->isObjCContainer() && 4006 Dcl && Dcl->getDeclContext()->isFileContext()) 4007 Dcl->setTopLevelDeclInObjCContainer(); 4008 4009 return Dcl; 4010} 4011 4012/// DiagnoseClassNameShadow - Implement C++ [class.mem]p13: 4013/// If T is the name of a class, then each of the following shall have a 4014/// name different from T: 4015/// - every static data member of class T; 4016/// - every member function of class T 4017/// - every member of class T that is itself a type; 4018/// \returns true if the declaration name violates these rules. 4019bool Sema::DiagnoseClassNameShadow(DeclContext *DC, 4020 DeclarationNameInfo NameInfo) { 4021 DeclarationName Name = NameInfo.getName(); 4022 4023 if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(DC)) 4024 if (Record->getIdentifier() && Record->getDeclName() == Name) { 4025 Diag(NameInfo.getLoc(), diag::err_member_name_of_class) << Name; 4026 return true; 4027 } 4028 4029 return false; 4030} 4031 4032/// \brief Diagnose a declaration whose declarator-id has the given 4033/// nested-name-specifier. 4034/// 4035/// \param SS The nested-name-specifier of the declarator-id. 4036/// 4037/// \param DC The declaration context to which the nested-name-specifier 4038/// resolves. 4039/// 4040/// \param Name The name of the entity being declared. 4041/// 4042/// \param Loc The location of the name of the entity being declared. 4043/// 4044/// \returns true if we cannot safely recover from this error, false otherwise. 4045bool Sema::diagnoseQualifiedDeclaration(CXXScopeSpec &SS, DeclContext *DC, 4046 DeclarationName Name, 4047 SourceLocation Loc) { 4048 DeclContext *Cur = CurContext; 4049 while (isa<LinkageSpecDecl>(Cur) || isa<CapturedDecl>(Cur)) 4050 Cur = Cur->getParent(); 4051 4052 // C++ [dcl.meaning]p1: 4053 // A declarator-id shall not be qualified except for the definition 4054 // of a member function (9.3) or static data member (9.4) outside of 4055 // its class, the definition or explicit instantiation of a function 4056 // or variable member of a namespace outside of its namespace, or the 4057 // definition of an explicit specialization outside of its namespace, 4058 // or the declaration of a friend function that is a member of 4059 // another class or namespace (11.3). [...] 4060 4061 // The user provided a superfluous scope specifier that refers back to the 4062 // class or namespaces in which the entity is already declared. 4063 // 4064 // class X { 4065 // void X::f(); 4066 // }; 4067 if (Cur->Equals(DC)) { 4068 Diag(Loc, LangOpts.MicrosoftExt? diag::warn_member_extra_qualification 4069 : diag::err_member_extra_qualification) 4070 << Name << FixItHint::CreateRemoval(SS.getRange()); 4071 SS.clear(); 4072 return false; 4073 } 4074 4075 // Check whether the qualifying scope encloses the scope of the original 4076 // declaration. 4077 if (!Cur->Encloses(DC)) { 4078 if (Cur->isRecord()) 4079 Diag(Loc, diag::err_member_qualification) 4080 << Name << SS.getRange(); 4081 else if (isa<TranslationUnitDecl>(DC)) 4082 Diag(Loc, diag::err_invalid_declarator_global_scope) 4083 << Name << SS.getRange(); 4084 else if (isa<FunctionDecl>(Cur)) 4085 Diag(Loc, diag::err_invalid_declarator_in_function) 4086 << Name << SS.getRange(); 4087 else if (isa<BlockDecl>(Cur)) 4088 Diag(Loc, diag::err_invalid_declarator_in_block) 4089 << Name << SS.getRange(); 4090 else 4091 Diag(Loc, diag::err_invalid_declarator_scope) 4092 << Name << cast<NamedDecl>(Cur) << cast<NamedDecl>(DC) << SS.getRange(); 4093 4094 return true; 4095 } 4096 4097 if (Cur->isRecord()) { 4098 // Cannot qualify members within a class. 4099 Diag(Loc, diag::err_member_qualification) 4100 << Name << SS.getRange(); 4101 SS.clear(); 4102 4103 // C++ constructors and destructors with incorrect scopes can break 4104 // our AST invariants by having the wrong underlying types. If 4105 // that's the case, then drop this declaration entirely. 4106 if ((Name.getNameKind() == DeclarationName::CXXConstructorName || 4107 Name.getNameKind() == DeclarationName::CXXDestructorName) && 4108 !Context.hasSameType(Name.getCXXNameType(), 4109 Context.getTypeDeclType(cast<CXXRecordDecl>(Cur)))) 4110 return true; 4111 4112 return false; 4113 } 4114 4115 // C++11 [dcl.meaning]p1: 4116 // [...] "The nested-name-specifier of the qualified declarator-id shall 4117 // not begin with a decltype-specifer" 4118 NestedNameSpecifierLoc SpecLoc(SS.getScopeRep(), SS.location_data()); 4119 while (SpecLoc.getPrefix()) 4120 SpecLoc = SpecLoc.getPrefix(); 4121 if (dyn_cast_or_null<DecltypeType>( 4122 SpecLoc.getNestedNameSpecifier()->getAsType())) 4123 Diag(Loc, diag::err_decltype_in_declarator) 4124 << SpecLoc.getTypeLoc().getSourceRange(); 4125 4126 return false; 4127} 4128 4129NamedDecl *Sema::HandleDeclarator(Scope *S, Declarator &D, 4130 MultiTemplateParamsArg TemplateParamLists) { 4131 // TODO: consider using NameInfo for diagnostic. 4132 DeclarationNameInfo NameInfo = GetNameForDeclarator(D); 4133 DeclarationName Name = NameInfo.getName(); 4134 4135 // All of these full declarators require an identifier. If it doesn't have 4136 // one, the ParsedFreeStandingDeclSpec action should be used. 4137 if (!Name) { 4138 if (!D.isInvalidType()) // Reject this if we think it is valid. 4139 Diag(D.getDeclSpec().getLocStart(), 4140 diag::err_declarator_need_ident) 4141 << D.getDeclSpec().getSourceRange() << D.getSourceRange(); 4142 return 0; 4143 } else if (DiagnoseUnexpandedParameterPack(NameInfo, UPPC_DeclarationType)) 4144 return 0; 4145 4146 // The scope passed in may not be a decl scope. Zip up the scope tree until 4147 // we find one that is. 4148 while ((S->getFlags() & Scope::DeclScope) == 0 || 4149 (S->getFlags() & Scope::TemplateParamScope) != 0) 4150 S = S->getParent(); 4151 4152 DeclContext *DC = CurContext; 4153 if (D.getCXXScopeSpec().isInvalid()) 4154 D.setInvalidType(); 4155 else if (D.getCXXScopeSpec().isSet()) { 4156 if (DiagnoseUnexpandedParameterPack(D.getCXXScopeSpec(), 4157 UPPC_DeclarationQualifier)) 4158 return 0; 4159 4160 bool EnteringContext = !D.getDeclSpec().isFriendSpecified(); 4161 DC = computeDeclContext(D.getCXXScopeSpec(), EnteringContext); 4162 if (!DC) { 4163 // If we could not compute the declaration context, it's because the 4164 // declaration context is dependent but does not refer to a class, 4165 // class template, or class template partial specialization. Complain 4166 // and return early, to avoid the coming semantic disaster. 4167 Diag(D.getIdentifierLoc(), 4168 diag::err_template_qualified_declarator_no_match) 4169 << (NestedNameSpecifier*)D.getCXXScopeSpec().getScopeRep() 4170 << D.getCXXScopeSpec().getRange(); 4171 return 0; 4172 } 4173 bool IsDependentContext = DC->isDependentContext(); 4174 4175 if (!IsDependentContext && 4176 RequireCompleteDeclContext(D.getCXXScopeSpec(), DC)) 4177 return 0; 4178 4179 if (isa<CXXRecordDecl>(DC) && !cast<CXXRecordDecl>(DC)->hasDefinition()) { 4180 Diag(D.getIdentifierLoc(), 4181 diag::err_member_def_undefined_record) 4182 << Name << DC << D.getCXXScopeSpec().getRange(); 4183 D.setInvalidType(); 4184 } else if (!D.getDeclSpec().isFriendSpecified()) { 4185 if (diagnoseQualifiedDeclaration(D.getCXXScopeSpec(), DC, 4186 Name, D.getIdentifierLoc())) { 4187 if (DC->isRecord()) 4188 return 0; 4189 4190 D.setInvalidType(); 4191 } 4192 } 4193 4194 // Check whether we need to rebuild the type of the given 4195 // declaration in the current instantiation. 4196 if (EnteringContext && IsDependentContext && 4197 TemplateParamLists.size() != 0) { 4198 ContextRAII SavedContext(*this, DC); 4199 if (RebuildDeclaratorInCurrentInstantiation(*this, D, Name)) 4200 D.setInvalidType(); 4201 } 4202 } 4203 4204 if (DiagnoseClassNameShadow(DC, NameInfo)) 4205 // If this is a typedef, we'll end up spewing multiple diagnostics. 4206 // Just return early; it's safer. 4207 if (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_typedef) 4208 return 0; 4209 4210 TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S); 4211 QualType R = TInfo->getType(); 4212 4213 if (DiagnoseUnexpandedParameterPack(D.getIdentifierLoc(), TInfo, 4214 UPPC_DeclarationType)) 4215 D.setInvalidType(); 4216 4217 LookupResult Previous(*this, NameInfo, LookupOrdinaryName, 4218 ForRedeclaration); 4219 4220 // See if this is a redefinition of a variable in the same scope. 4221 if (!D.getCXXScopeSpec().isSet()) { 4222 bool IsLinkageLookup = false; 4223 bool CreateBuiltins = false; 4224 4225 // If the declaration we're planning to build will be a function 4226 // or object with linkage, then look for another declaration with 4227 // linkage (C99 6.2.2p4-5 and C++ [basic.link]p6). 4228 // 4229 // If the declaration we're planning to build will be declared with 4230 // external linkage in the translation unit, create any builtin with 4231 // the same name. 4232 if (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_typedef) 4233 /* Do nothing*/; 4234 else if (CurContext->isFunctionOrMethod() && 4235 (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_extern || 4236 R->isFunctionType())) { 4237 IsLinkageLookup = true; 4238 CreateBuiltins = 4239 CurContext->getEnclosingNamespaceContext()->isTranslationUnit(); 4240 } else if (CurContext->getRedeclContext()->isTranslationUnit() && 4241 D.getDeclSpec().getStorageClassSpec() != DeclSpec::SCS_static) 4242 CreateBuiltins = true; 4243 4244 if (IsLinkageLookup) 4245 Previous.clear(LookupRedeclarationWithLinkage); 4246 4247 LookupName(Previous, S, CreateBuiltins); 4248 } else { // Something like "int foo::x;" 4249 LookupQualifiedName(Previous, DC); 4250 4251 // C++ [dcl.meaning]p1: 4252 // When the declarator-id is qualified, the declaration shall refer to a 4253 // previously declared member of the class or namespace to which the 4254 // qualifier refers (or, in the case of a namespace, of an element of the 4255 // inline namespace set of that namespace (7.3.1)) or to a specialization 4256 // thereof; [...] 4257 // 4258 // Note that we already checked the context above, and that we do not have 4259 // enough information to make sure that Previous contains the declaration 4260 // we want to match. For example, given: 4261 // 4262 // class X { 4263 // void f(); 4264 // void f(float); 4265 // }; 4266 // 4267 // void X::f(int) { } // ill-formed 4268 // 4269 // In this case, Previous will point to the overload set 4270 // containing the two f's declared in X, but neither of them 4271 // matches. 4272 4273 // C++ [dcl.meaning]p1: 4274 // [...] the member shall not merely have been introduced by a 4275 // using-declaration in the scope of the class or namespace nominated by 4276 // the nested-name-specifier of the declarator-id. 4277 RemoveUsingDecls(Previous); 4278 } 4279 4280 if (Previous.isSingleResult() && 4281 Previous.getFoundDecl()->isTemplateParameter()) { 4282 // Maybe we will complain about the shadowed template parameter. 4283 if (!D.isInvalidType()) 4284 DiagnoseTemplateParameterShadow(D.getIdentifierLoc(), 4285 Previous.getFoundDecl()); 4286 4287 // Just pretend that we didn't see the previous declaration. 4288 Previous.clear(); 4289 } 4290 4291 // In C++, the previous declaration we find might be a tag type 4292 // (class or enum). In this case, the new declaration will hide the 4293 // tag type. Note that this does does not apply if we're declaring a 4294 // typedef (C++ [dcl.typedef]p4). 4295 if (Previous.isSingleTagDecl() && 4296 D.getDeclSpec().getStorageClassSpec() != DeclSpec::SCS_typedef) 4297 Previous.clear(); 4298 4299 // Check that there are no default arguments other than in the parameters 4300 // of a function declaration (C++ only). 4301 if (getLangOpts().CPlusPlus) 4302 CheckExtraCXXDefaultArguments(D); 4303 4304 NamedDecl *New; 4305 4306 bool AddToScope = true; 4307 if (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_typedef) { 4308 if (TemplateParamLists.size()) { 4309 Diag(D.getIdentifierLoc(), diag::err_template_typedef); 4310 return 0; 4311 } 4312 4313 New = ActOnTypedefDeclarator(S, D, DC, TInfo, Previous); 4314 } else if (R->isFunctionType()) { 4315 New = ActOnFunctionDeclarator(S, D, DC, TInfo, Previous, 4316 TemplateParamLists, 4317 AddToScope); 4318 } else { 4319 New = ActOnVariableDeclarator(S, D, DC, TInfo, Previous, TemplateParamLists, 4320 AddToScope); 4321 } 4322 4323 if (New == 0) 4324 return 0; 4325 4326 // If this has an identifier and is not an invalid redeclaration or 4327 // function template specialization, add it to the scope stack. 4328 if (New->getDeclName() && AddToScope && 4329 !(D.isRedeclaration() && New->isInvalidDecl())) { 4330 // Only make a locally-scoped extern declaration visible if it is the first 4331 // declaration of this entity. Qualified lookup for such an entity should 4332 // only find this declaration if there is no visible declaration of it. 4333 bool AddToContext = !D.isRedeclaration() || !New->isLocalExternDecl(); 4334 PushOnScopeChains(New, S, AddToContext); 4335 if (!AddToContext) 4336 CurContext->addHiddenDecl(New); 4337 } 4338 4339 return New; 4340} 4341 4342/// Helper method to turn variable array types into constant array 4343/// types in certain situations which would otherwise be errors (for 4344/// GCC compatibility). 4345static QualType TryToFixInvalidVariablyModifiedType(QualType T, 4346 ASTContext &Context, 4347 bool &SizeIsNegative, 4348 llvm::APSInt &Oversized) { 4349 // This method tries to turn a variable array into a constant 4350 // array even when the size isn't an ICE. This is necessary 4351 // for compatibility with code that depends on gcc's buggy 4352 // constant expression folding, like struct {char x[(int)(char*)2];} 4353 SizeIsNegative = false; 4354 Oversized = 0; 4355 4356 if (T->isDependentType()) 4357 return QualType(); 4358 4359 QualifierCollector Qs; 4360 const Type *Ty = Qs.strip(T); 4361 4362 if (const PointerType* PTy = dyn_cast<PointerType>(Ty)) { 4363 QualType Pointee = PTy->getPointeeType(); 4364 QualType FixedType = 4365 TryToFixInvalidVariablyModifiedType(Pointee, Context, SizeIsNegative, 4366 Oversized); 4367 if (FixedType.isNull()) return FixedType; 4368 FixedType = Context.getPointerType(FixedType); 4369 return Qs.apply(Context, FixedType); 4370 } 4371 if (const ParenType* PTy = dyn_cast<ParenType>(Ty)) { 4372 QualType Inner = PTy->getInnerType(); 4373 QualType FixedType = 4374 TryToFixInvalidVariablyModifiedType(Inner, Context, SizeIsNegative, 4375 Oversized); 4376 if (FixedType.isNull()) return FixedType; 4377 FixedType = Context.getParenType(FixedType); 4378 return Qs.apply(Context, FixedType); 4379 } 4380 4381 const VariableArrayType* VLATy = dyn_cast<VariableArrayType>(T); 4382 if (!VLATy) 4383 return QualType(); 4384 // FIXME: We should probably handle this case 4385 if (VLATy->getElementType()->isVariablyModifiedType()) 4386 return QualType(); 4387 4388 llvm::APSInt Res; 4389 if (!VLATy->getSizeExpr() || 4390 !VLATy->getSizeExpr()->EvaluateAsInt(Res, Context)) 4391 return QualType(); 4392 4393 // Check whether the array size is negative. 4394 if (Res.isSigned() && Res.isNegative()) { 4395 SizeIsNegative = true; 4396 return QualType(); 4397 } 4398 4399 // Check whether the array is too large to be addressed. 4400 unsigned ActiveSizeBits 4401 = ConstantArrayType::getNumAddressingBits(Context, VLATy->getElementType(), 4402 Res); 4403 if (ActiveSizeBits > ConstantArrayType::getMaxSizeBits(Context)) { 4404 Oversized = Res; 4405 return QualType(); 4406 } 4407 4408 return Context.getConstantArrayType(VLATy->getElementType(), 4409 Res, ArrayType::Normal, 0); 4410} 4411 4412static void 4413FixInvalidVariablyModifiedTypeLoc(TypeLoc SrcTL, TypeLoc DstTL) { 4414 if (PointerTypeLoc SrcPTL = SrcTL.getAs<PointerTypeLoc>()) { 4415 PointerTypeLoc DstPTL = DstTL.castAs<PointerTypeLoc>(); 4416 FixInvalidVariablyModifiedTypeLoc(SrcPTL.getPointeeLoc(), 4417 DstPTL.getPointeeLoc()); 4418 DstPTL.setStarLoc(SrcPTL.getStarLoc()); 4419 return; 4420 } 4421 if (ParenTypeLoc SrcPTL = SrcTL.getAs<ParenTypeLoc>()) { 4422 ParenTypeLoc DstPTL = DstTL.castAs<ParenTypeLoc>(); 4423 FixInvalidVariablyModifiedTypeLoc(SrcPTL.getInnerLoc(), 4424 DstPTL.getInnerLoc()); 4425 DstPTL.setLParenLoc(SrcPTL.getLParenLoc()); 4426 DstPTL.setRParenLoc(SrcPTL.getRParenLoc()); 4427 return; 4428 } 4429 ArrayTypeLoc SrcATL = SrcTL.castAs<ArrayTypeLoc>(); 4430 ArrayTypeLoc DstATL = DstTL.castAs<ArrayTypeLoc>(); 4431 TypeLoc SrcElemTL = SrcATL.getElementLoc(); 4432 TypeLoc DstElemTL = DstATL.getElementLoc(); 4433 DstElemTL.initializeFullCopy(SrcElemTL); 4434 DstATL.setLBracketLoc(SrcATL.getLBracketLoc()); 4435 DstATL.setSizeExpr(SrcATL.getSizeExpr()); 4436 DstATL.setRBracketLoc(SrcATL.getRBracketLoc()); 4437} 4438 4439/// Helper method to turn variable array types into constant array 4440/// types in certain situations which would otherwise be errors (for 4441/// GCC compatibility). 4442static TypeSourceInfo* 4443TryToFixInvalidVariablyModifiedTypeSourceInfo(TypeSourceInfo *TInfo, 4444 ASTContext &Context, 4445 bool &SizeIsNegative, 4446 llvm::APSInt &Oversized) { 4447 QualType FixedTy 4448 = TryToFixInvalidVariablyModifiedType(TInfo->getType(), Context, 4449 SizeIsNegative, Oversized); 4450 if (FixedTy.isNull()) 4451 return 0; 4452 TypeSourceInfo *FixedTInfo = Context.getTrivialTypeSourceInfo(FixedTy); 4453 FixInvalidVariablyModifiedTypeLoc(TInfo->getTypeLoc(), 4454 FixedTInfo->getTypeLoc()); 4455 return FixedTInfo; 4456} 4457 4458/// \brief Register the given locally-scoped extern "C" declaration so 4459/// that it can be found later for redeclarations. We include any extern "C" 4460/// declaration that is not visible in the translation unit here, not just 4461/// function-scope declarations. 4462void 4463Sema::RegisterLocallyScopedExternCDecl(NamedDecl *ND, Scope *S) { 4464 if (!getLangOpts().CPlusPlus && 4465 ND->getLexicalDeclContext()->getRedeclContext()->isTranslationUnit()) 4466 // Don't need to track declarations in the TU in C. 4467 return; 4468 4469 // Note that we have a locally-scoped external with this name. 4470 // FIXME: There can be multiple such declarations if they are functions marked 4471 // __attribute__((overloadable)) declared in function scope in C. 4472 LocallyScopedExternCDecls[ND->getDeclName()] = ND; 4473} 4474 4475NamedDecl *Sema::findLocallyScopedExternCDecl(DeclarationName Name) { 4476 if (ExternalSource) { 4477 // Load locally-scoped external decls from the external source. 4478 // FIXME: This is inefficient. Maybe add a DeclContext for extern "C" decls? 4479 SmallVector<NamedDecl *, 4> Decls; 4480 ExternalSource->ReadLocallyScopedExternCDecls(Decls); 4481 for (unsigned I = 0, N = Decls.size(); I != N; ++I) { 4482 llvm::DenseMap<DeclarationName, NamedDecl *>::iterator Pos 4483 = LocallyScopedExternCDecls.find(Decls[I]->getDeclName()); 4484 if (Pos == LocallyScopedExternCDecls.end()) 4485 LocallyScopedExternCDecls[Decls[I]->getDeclName()] = Decls[I]; 4486 } 4487 } 4488 4489 NamedDecl *D = LocallyScopedExternCDecls.lookup(Name); 4490 return D ? D->getMostRecentDecl() : 0; 4491} 4492 4493/// \brief Diagnose function specifiers on a declaration of an identifier that 4494/// does not identify a function. 4495void Sema::DiagnoseFunctionSpecifiers(const DeclSpec &DS) { 4496 // FIXME: We should probably indicate the identifier in question to avoid 4497 // confusion for constructs like "inline int a(), b;" 4498 if (DS.isInlineSpecified()) 4499 Diag(DS.getInlineSpecLoc(), 4500 diag::err_inline_non_function); 4501 4502 if (DS.isVirtualSpecified()) 4503 Diag(DS.getVirtualSpecLoc(), 4504 diag::err_virtual_non_function); 4505 4506 if (DS.isExplicitSpecified()) 4507 Diag(DS.getExplicitSpecLoc(), 4508 diag::err_explicit_non_function); 4509 4510 if (DS.isNoreturnSpecified()) 4511 Diag(DS.getNoreturnSpecLoc(), 4512 diag::err_noreturn_non_function); 4513} 4514 4515NamedDecl* 4516Sema::ActOnTypedefDeclarator(Scope* S, Declarator& D, DeclContext* DC, 4517 TypeSourceInfo *TInfo, LookupResult &Previous) { 4518 // Typedef declarators cannot be qualified (C++ [dcl.meaning]p1). 4519 if (D.getCXXScopeSpec().isSet()) { 4520 Diag(D.getIdentifierLoc(), diag::err_qualified_typedef_declarator) 4521 << D.getCXXScopeSpec().getRange(); 4522 D.setInvalidType(); 4523 // Pretend we didn't see the scope specifier. 4524 DC = CurContext; 4525 Previous.clear(); 4526 } 4527 4528 DiagnoseFunctionSpecifiers(D.getDeclSpec()); 4529 4530 if (D.getDeclSpec().isConstexprSpecified()) 4531 Diag(D.getDeclSpec().getConstexprSpecLoc(), diag::err_invalid_constexpr) 4532 << 1; 4533 4534 if (D.getName().Kind != UnqualifiedId::IK_Identifier) { 4535 Diag(D.getName().StartLocation, diag::err_typedef_not_identifier) 4536 << D.getName().getSourceRange(); 4537 return 0; 4538 } 4539 4540 TypedefDecl *NewTD = ParseTypedefDecl(S, D, TInfo->getType(), TInfo); 4541 if (!NewTD) return 0; 4542 4543 // Handle attributes prior to checking for duplicates in MergeVarDecl 4544 ProcessDeclAttributes(S, NewTD, D); 4545 4546 CheckTypedefForVariablyModifiedType(S, NewTD); 4547 4548 bool Redeclaration = D.isRedeclaration(); 4549 NamedDecl *ND = ActOnTypedefNameDecl(S, DC, NewTD, Previous, Redeclaration); 4550 D.setRedeclaration(Redeclaration); 4551 return ND; 4552} 4553 4554void 4555Sema::CheckTypedefForVariablyModifiedType(Scope *S, TypedefNameDecl *NewTD) { 4556 // C99 6.7.7p2: If a typedef name specifies a variably modified type 4557 // then it shall have block scope. 4558 // Note that variably modified types must be fixed before merging the decl so 4559 // that redeclarations will match. 4560 TypeSourceInfo *TInfo = NewTD->getTypeSourceInfo(); 4561 QualType T = TInfo->getType(); 4562 if (T->isVariablyModifiedType()) { 4563 getCurFunction()->setHasBranchProtectedScope(); 4564 4565 if (S->getFnParent() == 0) { 4566 bool SizeIsNegative; 4567 llvm::APSInt Oversized; 4568 TypeSourceInfo *FixedTInfo = 4569 TryToFixInvalidVariablyModifiedTypeSourceInfo(TInfo, Context, 4570 SizeIsNegative, 4571 Oversized); 4572 if (FixedTInfo) { 4573 Diag(NewTD->getLocation(), diag::warn_illegal_constant_array_size); 4574 NewTD->setTypeSourceInfo(FixedTInfo); 4575 } else { 4576 if (SizeIsNegative) 4577 Diag(NewTD->getLocation(), diag::err_typecheck_negative_array_size); 4578 else if (T->isVariableArrayType()) 4579 Diag(NewTD->getLocation(), diag::err_vla_decl_in_file_scope); 4580 else if (Oversized.getBoolValue()) 4581 Diag(NewTD->getLocation(), diag::err_array_too_large) 4582 << Oversized.toString(10); 4583 else 4584 Diag(NewTD->getLocation(), diag::err_vm_decl_in_file_scope); 4585 NewTD->setInvalidDecl(); 4586 } 4587 } 4588 } 4589} 4590 4591 4592/// ActOnTypedefNameDecl - Perform semantic checking for a declaration which 4593/// declares a typedef-name, either using the 'typedef' type specifier or via 4594/// a C++0x [dcl.typedef]p2 alias-declaration: 'using T = A;'. 4595NamedDecl* 4596Sema::ActOnTypedefNameDecl(Scope *S, DeclContext *DC, TypedefNameDecl *NewTD, 4597 LookupResult &Previous, bool &Redeclaration) { 4598 // Merge the decl with the existing one if appropriate. If the decl is 4599 // in an outer scope, it isn't the same thing. 4600 FilterLookupForScope(Previous, DC, S, /*ConsiderLinkage*/ false, 4601 /*ExplicitInstantiationOrSpecialization=*/false); 4602 filterNonConflictingPreviousDecls(Context, NewTD, Previous); 4603 if (!Previous.empty()) { 4604 Redeclaration = true; 4605 MergeTypedefNameDecl(NewTD, Previous); 4606 } 4607 4608 // If this is the C FILE type, notify the AST context. 4609 if (IdentifierInfo *II = NewTD->getIdentifier()) 4610 if (!NewTD->isInvalidDecl() && 4611 NewTD->getDeclContext()->getRedeclContext()->isTranslationUnit()) { 4612 if (II->isStr("FILE")) 4613 Context.setFILEDecl(NewTD); 4614 else if (II->isStr("jmp_buf")) 4615 Context.setjmp_bufDecl(NewTD); 4616 else if (II->isStr("sigjmp_buf")) 4617 Context.setsigjmp_bufDecl(NewTD); 4618 else if (II->isStr("ucontext_t")) 4619 Context.setucontext_tDecl(NewTD); 4620 } 4621 4622 return NewTD; 4623} 4624 4625/// \brief Determines whether the given declaration is an out-of-scope 4626/// previous declaration. 4627/// 4628/// This routine should be invoked when name lookup has found a 4629/// previous declaration (PrevDecl) that is not in the scope where a 4630/// new declaration by the same name is being introduced. If the new 4631/// declaration occurs in a local scope, previous declarations with 4632/// linkage may still be considered previous declarations (C99 4633/// 6.2.2p4-5, C++ [basic.link]p6). 4634/// 4635/// \param PrevDecl the previous declaration found by name 4636/// lookup 4637/// 4638/// \param DC the context in which the new declaration is being 4639/// declared. 4640/// 4641/// \returns true if PrevDecl is an out-of-scope previous declaration 4642/// for a new delcaration with the same name. 4643static bool 4644isOutOfScopePreviousDeclaration(NamedDecl *PrevDecl, DeclContext *DC, 4645 ASTContext &Context) { 4646 if (!PrevDecl) 4647 return false; 4648 4649 if (!PrevDecl->hasLinkage()) 4650 return false; 4651 4652 if (Context.getLangOpts().CPlusPlus) { 4653 // C++ [basic.link]p6: 4654 // If there is a visible declaration of an entity with linkage 4655 // having the same name and type, ignoring entities declared 4656 // outside the innermost enclosing namespace scope, the block 4657 // scope declaration declares that same entity and receives the 4658 // linkage of the previous declaration. 4659 DeclContext *OuterContext = DC->getRedeclContext(); 4660 if (!OuterContext->isFunctionOrMethod()) 4661 // This rule only applies to block-scope declarations. 4662 return false; 4663 4664 DeclContext *PrevOuterContext = PrevDecl->getDeclContext(); 4665 if (PrevOuterContext->isRecord()) 4666 // We found a member function: ignore it. 4667 return false; 4668 4669 // Find the innermost enclosing namespace for the new and 4670 // previous declarations. 4671 OuterContext = OuterContext->getEnclosingNamespaceContext(); 4672 PrevOuterContext = PrevOuterContext->getEnclosingNamespaceContext(); 4673 4674 // The previous declaration is in a different namespace, so it 4675 // isn't the same function. 4676 if (!OuterContext->Equals(PrevOuterContext)) 4677 return false; 4678 } 4679 4680 return true; 4681} 4682 4683static void SetNestedNameSpecifier(DeclaratorDecl *DD, Declarator &D) { 4684 CXXScopeSpec &SS = D.getCXXScopeSpec(); 4685 if (!SS.isSet()) return; 4686 DD->setQualifierInfo(SS.getWithLocInContext(DD->getASTContext())); 4687} 4688 4689bool Sema::inferObjCARCLifetime(ValueDecl *decl) { 4690 QualType type = decl->getType(); 4691 Qualifiers::ObjCLifetime lifetime = type.getObjCLifetime(); 4692 if (lifetime == Qualifiers::OCL_Autoreleasing) { 4693 // Various kinds of declaration aren't allowed to be __autoreleasing. 4694 unsigned kind = -1U; 4695 if (VarDecl *var = dyn_cast<VarDecl>(decl)) { 4696 if (var->hasAttr<BlocksAttr>()) 4697 kind = 0; // __block 4698 else if (!var->hasLocalStorage()) 4699 kind = 1; // global 4700 } else if (isa<ObjCIvarDecl>(decl)) { 4701 kind = 3; // ivar 4702 } else if (isa<FieldDecl>(decl)) { 4703 kind = 2; // field 4704 } 4705 4706 if (kind != -1U) { 4707 Diag(decl->getLocation(), diag::err_arc_autoreleasing_var) 4708 << kind; 4709 } 4710 } else if (lifetime == Qualifiers::OCL_None) { 4711 // Try to infer lifetime. 4712 if (!type->isObjCLifetimeType()) 4713 return false; 4714 4715 lifetime = type->getObjCARCImplicitLifetime(); 4716 type = Context.getLifetimeQualifiedType(type, lifetime); 4717 decl->setType(type); 4718 } 4719 4720 if (VarDecl *var = dyn_cast<VarDecl>(decl)) { 4721 // Thread-local variables cannot have lifetime. 4722 if (lifetime && lifetime != Qualifiers::OCL_ExplicitNone && 4723 var->getTLSKind()) { 4724 Diag(var->getLocation(), diag::err_arc_thread_ownership) 4725 << var->getType(); 4726 return true; 4727 } 4728 } 4729 4730 return false; 4731} 4732 4733static void checkAttributesAfterMerging(Sema &S, NamedDecl &ND) { 4734 // 'weak' only applies to declarations with external linkage. 4735 if (WeakAttr *Attr = ND.getAttr<WeakAttr>()) { 4736 if (!ND.isExternallyVisible()) { 4737 S.Diag(Attr->getLocation(), diag::err_attribute_weak_static); 4738 ND.dropAttr<WeakAttr>(); 4739 } 4740 } 4741 if (WeakRefAttr *Attr = ND.getAttr<WeakRefAttr>()) { 4742 if (ND.isExternallyVisible()) { 4743 S.Diag(Attr->getLocation(), diag::err_attribute_weakref_not_static); 4744 ND.dropAttr<WeakRefAttr>(); 4745 } 4746 } 4747 4748 // 'selectany' only applies to externally visible varable declarations. 4749 // It does not apply to functions. 4750 if (SelectAnyAttr *Attr = ND.getAttr<SelectAnyAttr>()) { 4751 if (isa<FunctionDecl>(ND) || !ND.isExternallyVisible()) { 4752 S.Diag(Attr->getLocation(), diag::err_attribute_selectany_non_extern_data); 4753 ND.dropAttr<SelectAnyAttr>(); 4754 } 4755 } 4756} 4757 4758/// Given that we are within the definition of the given function, 4759/// will that definition behave like C99's 'inline', where the 4760/// definition is discarded except for optimization purposes? 4761static bool isFunctionDefinitionDiscarded(Sema &S, FunctionDecl *FD) { 4762 // Try to avoid calling GetGVALinkageForFunction. 4763 4764 // All cases of this require the 'inline' keyword. 4765 if (!FD->isInlined()) return false; 4766 4767 // This is only possible in C++ with the gnu_inline attribute. 4768 if (S.getLangOpts().CPlusPlus && !FD->hasAttr<GNUInlineAttr>()) 4769 return false; 4770 4771 // Okay, go ahead and call the relatively-more-expensive function. 4772 4773#ifndef NDEBUG 4774 // AST quite reasonably asserts that it's working on a function 4775 // definition. We don't really have a way to tell it that we're 4776 // currently defining the function, so just lie to it in +Asserts 4777 // builds. This is an awful hack. 4778 FD->setLazyBody(1); 4779#endif 4780 4781 bool isC99Inline = (S.Context.GetGVALinkageForFunction(FD) == GVA_C99Inline); 4782 4783#ifndef NDEBUG 4784 FD->setLazyBody(0); 4785#endif 4786 4787 return isC99Inline; 4788} 4789 4790/// Determine whether a variable is extern "C" prior to attaching 4791/// an initializer. We can't just call isExternC() here, because that 4792/// will also compute and cache whether the declaration is externally 4793/// visible, which might change when we attach the initializer. 4794/// 4795/// This can only be used if the declaration is known to not be a 4796/// redeclaration of an internal linkage declaration. 4797/// 4798/// For instance: 4799/// 4800/// auto x = []{}; 4801/// 4802/// Attaching the initializer here makes this declaration not externally 4803/// visible, because its type has internal linkage. 4804/// 4805/// FIXME: This is a hack. 4806template<typename T> 4807static bool isIncompleteDeclExternC(Sema &S, const T *D) { 4808 if (S.getLangOpts().CPlusPlus) { 4809 // In C++, the overloadable attribute negates the effects of extern "C". 4810 if (!D->isInExternCContext() || D->template hasAttr<OverloadableAttr>()) 4811 return false; 4812 } 4813 return D->isExternC(); 4814} 4815 4816static bool shouldConsiderLinkage(const VarDecl *VD) { 4817 const DeclContext *DC = VD->getDeclContext()->getRedeclContext(); 4818 if (DC->isFunctionOrMethod()) 4819 return VD->hasExternalStorage(); 4820 if (DC->isFileContext()) 4821 return true; 4822 if (DC->isRecord()) 4823 return false; 4824 llvm_unreachable("Unexpected context"); 4825} 4826 4827static bool shouldConsiderLinkage(const FunctionDecl *FD) { 4828 const DeclContext *DC = FD->getDeclContext()->getRedeclContext(); 4829 if (DC->isFileContext() || DC->isFunctionOrMethod()) 4830 return true; 4831 if (DC->isRecord()) 4832 return false; 4833 llvm_unreachable("Unexpected context"); 4834} 4835 4836/// Adjust the \c DeclContext for a function or variable that might be a 4837/// function-local external declaration. 4838bool Sema::adjustContextForLocalExternDecl(DeclContext *&DC) { 4839 if (!DC->isFunctionOrMethod()) 4840 return false; 4841 4842 // If this is a local extern function or variable declared within a function 4843 // template, don't add it into the enclosing namespace scope until it is 4844 // instantiated; it might have a dependent type right now. 4845 if (DC->isDependentContext()) 4846 return true; 4847 4848 // C++11 [basic.link]p7: 4849 // When a block scope declaration of an entity with linkage is not found to 4850 // refer to some other declaration, then that entity is a member of the 4851 // innermost enclosing namespace. 4852 // 4853 // Per C++11 [namespace.def]p6, the innermost enclosing namespace is a 4854 // semantically-enclosing namespace, not a lexically-enclosing one. 4855 while (!DC->isFileContext() && !isa<LinkageSpecDecl>(DC)) 4856 DC = DC->getParent(); 4857 return true; 4858} 4859 4860NamedDecl * 4861Sema::ActOnVariableDeclarator(Scope *S, Declarator &D, DeclContext *DC, 4862 TypeSourceInfo *TInfo, LookupResult &Previous, 4863 MultiTemplateParamsArg TemplateParamLists, 4864 bool &AddToScope) { 4865 QualType R = TInfo->getType(); 4866 DeclarationName Name = GetNameForDeclarator(D).getName(); 4867 4868 DeclSpec::SCS SCSpec = D.getDeclSpec().getStorageClassSpec(); 4869 VarDecl::StorageClass SC = 4870 StorageClassSpecToVarDeclStorageClass(D.getDeclSpec()); 4871 4872 DeclContext *OriginalDC = DC; 4873 bool IsLocalExternDecl = SC == SC_Extern && 4874 adjustContextForLocalExternDecl(DC); 4875 4876 if (getLangOpts().OpenCL && !getOpenCLOptions().cl_khr_fp16) { 4877 // OpenCL v1.2 s6.1.1.1: reject declaring variables of the half and 4878 // half array type (unless the cl_khr_fp16 extension is enabled). 4879 if (Context.getBaseElementType(R)->isHalfType()) { 4880 Diag(D.getIdentifierLoc(), diag::err_opencl_half_declaration) << R; 4881 D.setInvalidType(); 4882 } 4883 } 4884 4885 if (SCSpec == DeclSpec::SCS_mutable) { 4886 // mutable can only appear on non-static class members, so it's always 4887 // an error here 4888 Diag(D.getIdentifierLoc(), diag::err_mutable_nonmember); 4889 D.setInvalidType(); 4890 SC = SC_None; 4891 } 4892 4893 if (getLangOpts().CPlusPlus11 && SCSpec == DeclSpec::SCS_register && 4894 !D.getAsmLabel() && !getSourceManager().isInSystemMacro( 4895 D.getDeclSpec().getStorageClassSpecLoc())) { 4896 // In C++11, the 'register' storage class specifier is deprecated. 4897 // Suppress the warning in system macros, it's used in macros in some 4898 // popular C system headers, such as in glibc's htonl() macro. 4899 Diag(D.getDeclSpec().getStorageClassSpecLoc(), 4900 diag::warn_deprecated_register) 4901 << FixItHint::CreateRemoval(D.getDeclSpec().getStorageClassSpecLoc()); 4902 } 4903 4904 IdentifierInfo *II = Name.getAsIdentifierInfo(); 4905 if (!II) { 4906 Diag(D.getIdentifierLoc(), diag::err_bad_variable_name) 4907 << Name; 4908 return 0; 4909 } 4910 4911 DiagnoseFunctionSpecifiers(D.getDeclSpec()); 4912 4913 if (!DC->isRecord() && S->getFnParent() == 0) { 4914 // C99 6.9p2: The storage-class specifiers auto and register shall not 4915 // appear in the declaration specifiers in an external declaration. 4916 if (SC == SC_Auto || SC == SC_Register) { 4917 // If this is a register variable with an asm label specified, then this 4918 // is a GNU extension. 4919 if (SC == SC_Register && D.getAsmLabel()) 4920 Diag(D.getIdentifierLoc(), diag::err_unsupported_global_register); 4921 else 4922 Diag(D.getIdentifierLoc(), diag::err_typecheck_sclass_fscope); 4923 D.setInvalidType(); 4924 } 4925 } 4926 4927 if (getLangOpts().OpenCL) { 4928 // Set up the special work-group-local storage class for variables in the 4929 // OpenCL __local address space. 4930 if (R.getAddressSpace() == LangAS::opencl_local) { 4931 SC = SC_OpenCLWorkGroupLocal; 4932 } 4933 4934 // OpenCL v1.2 s6.9.b p4: 4935 // The sampler type cannot be used with the __local and __global address 4936 // space qualifiers. 4937 if (R->isSamplerT() && (R.getAddressSpace() == LangAS::opencl_local || 4938 R.getAddressSpace() == LangAS::opencl_global)) { 4939 Diag(D.getIdentifierLoc(), diag::err_wrong_sampler_addressspace); 4940 } 4941 4942 // OpenCL 1.2 spec, p6.9 r: 4943 // The event type cannot be used to declare a program scope variable. 4944 // The event type cannot be used with the __local, __constant and __global 4945 // address space qualifiers. 4946 if (R->isEventT()) { 4947 if (S->getParent() == 0) { 4948 Diag(D.getLocStart(), diag::err_event_t_global_var); 4949 D.setInvalidType(); 4950 } 4951 4952 if (R.getAddressSpace()) { 4953 Diag(D.getLocStart(), diag::err_event_t_addr_space_qual); 4954 D.setInvalidType(); 4955 } 4956 } 4957 } 4958 4959 bool IsExplicitSpecialization = false; 4960 bool IsVariableTemplateSpecialization = false; 4961 bool IsPartialSpecialization = false; 4962 bool IsVariableTemplate = false; 4963 VarTemplateDecl *PrevVarTemplate = 0; 4964 VarDecl *NewVD = 0; 4965 VarTemplateDecl *NewTemplate = 0; 4966 if (!getLangOpts().CPlusPlus) { 4967 NewVD = VarDecl::Create(Context, DC, D.getLocStart(), 4968 D.getIdentifierLoc(), II, 4969 R, TInfo, SC); 4970 4971 if (D.isInvalidType()) 4972 NewVD->setInvalidDecl(); 4973 } else { 4974 bool Invalid = false; 4975 4976 if (DC->isRecord() && !CurContext->isRecord()) { 4977 // This is an out-of-line definition of a static data member. 4978 switch (SC) { 4979 case SC_None: 4980 break; 4981 case SC_Static: 4982 Diag(D.getDeclSpec().getStorageClassSpecLoc(), 4983 diag::err_static_out_of_line) 4984 << FixItHint::CreateRemoval(D.getDeclSpec().getStorageClassSpecLoc()); 4985 break; 4986 case SC_Auto: 4987 case SC_Register: 4988 case SC_Extern: 4989 // [dcl.stc] p2: The auto or register specifiers shall be applied only 4990 // to names of variables declared in a block or to function parameters. 4991 // [dcl.stc] p6: The extern specifier cannot be used in the declaration 4992 // of class members 4993 4994 Diag(D.getDeclSpec().getStorageClassSpecLoc(), 4995 diag::err_storage_class_for_static_member) 4996 << FixItHint::CreateRemoval(D.getDeclSpec().getStorageClassSpecLoc()); 4997 break; 4998 case SC_PrivateExtern: 4999 llvm_unreachable("C storage class in c++!"); 5000 case SC_OpenCLWorkGroupLocal: 5001 llvm_unreachable("OpenCL storage class in c++!"); 5002 } 5003 } 5004 5005 if (SC == SC_Static && CurContext->isRecord()) { 5006 if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(DC)) { 5007 if (RD->isLocalClass()) 5008 Diag(D.getIdentifierLoc(), 5009 diag::err_static_data_member_not_allowed_in_local_class) 5010 << Name << RD->getDeclName(); 5011 5012 // C++98 [class.union]p1: If a union contains a static data member, 5013 // the program is ill-formed. C++11 drops this restriction. 5014 if (RD->isUnion()) 5015 Diag(D.getIdentifierLoc(), 5016 getLangOpts().CPlusPlus11 5017 ? diag::warn_cxx98_compat_static_data_member_in_union 5018 : diag::ext_static_data_member_in_union) << Name; 5019 // We conservatively disallow static data members in anonymous structs. 5020 else if (!RD->getDeclName()) 5021 Diag(D.getIdentifierLoc(), 5022 diag::err_static_data_member_not_allowed_in_anon_struct) 5023 << Name << RD->isUnion(); 5024 } 5025 } 5026 5027 NamedDecl *PrevDecl = 0; 5028 if (Previous.begin() != Previous.end()) 5029 PrevDecl = (*Previous.begin())->getUnderlyingDecl(); 5030 PrevVarTemplate = dyn_cast_or_null<VarTemplateDecl>(PrevDecl); 5031 5032 // Match up the template parameter lists with the scope specifier, then 5033 // determine whether we have a template or a template specialization. 5034 TemplateParameterList *TemplateParams = 5035 MatchTemplateParametersToScopeSpecifier( 5036 D.getDeclSpec().getLocStart(), D.getIdentifierLoc(), 5037 D.getCXXScopeSpec(), TemplateParamLists, 5038 /*never a friend*/ false, IsExplicitSpecialization, Invalid); 5039 if (TemplateParams) { 5040 if (!TemplateParams->size() && 5041 D.getName().getKind() != UnqualifiedId::IK_TemplateId) { 5042 // There is an extraneous 'template<>' for this variable. Complain 5043 // about it, but allow the declaration of the variable. 5044 Diag(TemplateParams->getTemplateLoc(), 5045 diag::err_template_variable_noparams) 5046 << II 5047 << SourceRange(TemplateParams->getTemplateLoc(), 5048 TemplateParams->getRAngleLoc()); 5049 } else { 5050 // Only C++1y supports variable templates (N3651). 5051 Diag(D.getIdentifierLoc(), 5052 getLangOpts().CPlusPlus1y 5053 ? diag::warn_cxx11_compat_variable_template 5054 : diag::ext_variable_template); 5055 5056 if (D.getName().getKind() == UnqualifiedId::IK_TemplateId) { 5057 // This is an explicit specialization or a partial specialization. 5058 // Check that we can declare a specialization here 5059 5060 IsVariableTemplateSpecialization = true; 5061 IsPartialSpecialization = TemplateParams->size() > 0; 5062 5063 } else { // if (TemplateParams->size() > 0) 5064 // This is a template declaration. 5065 IsVariableTemplate = true; 5066 5067 // Check that we can declare a template here. 5068 if (CheckTemplateDeclScope(S, TemplateParams)) 5069 return 0; 5070 5071 // If there is a previous declaration with the same name, check 5072 // whether this is a valid redeclaration. 5073 if (PrevDecl && !isDeclInScope(PrevDecl, DC, S)) 5074 PrevDecl = PrevVarTemplate = 0; 5075 5076 if (PrevVarTemplate) { 5077 // Ensure that the template parameter lists are compatible. 5078 if (!TemplateParameterListsAreEqual( 5079 TemplateParams, PrevVarTemplate->getTemplateParameters(), 5080 /*Complain=*/true, TPL_TemplateMatch)) 5081 return 0; 5082 } else if (PrevDecl && PrevDecl->isTemplateParameter()) { 5083 // Maybe we will complain about the shadowed template parameter. 5084 DiagnoseTemplateParameterShadow(D.getIdentifierLoc(), PrevDecl); 5085 5086 // Just pretend that we didn't see the previous declaration. 5087 PrevDecl = 0; 5088 } else if (PrevDecl) { 5089 // C++ [temp]p5: 5090 // ... a template name declared in namespace scope or in class 5091 // scope shall be unique in that scope. 5092 Diag(D.getIdentifierLoc(), diag::err_redefinition_different_kind) 5093 << Name; 5094 Diag(PrevDecl->getLocation(), diag::note_previous_definition); 5095 return 0; 5096 } 5097 5098 // Check the template parameter list of this declaration, possibly 5099 // merging in the template parameter list from the previous variable 5100 // template declaration. 5101 if (CheckTemplateParameterList( 5102 TemplateParams, 5103 PrevVarTemplate ? PrevVarTemplate->getTemplateParameters() 5104 : 0, 5105 (D.getCXXScopeSpec().isSet() && DC && DC->isRecord() && 5106 DC->isDependentContext()) 5107 ? TPC_ClassTemplateMember 5108 : TPC_VarTemplate)) 5109 Invalid = true; 5110 5111 if (D.getCXXScopeSpec().isSet()) { 5112 // If the name of the template was qualified, we must be defining 5113 // the template out-of-line. 5114 if (!D.getCXXScopeSpec().isInvalid() && !Invalid && 5115 !PrevVarTemplate) { 5116 Diag(D.getIdentifierLoc(), diag::err_member_decl_does_not_match) 5117 << Name << DC << /*IsDefinition*/true 5118 << D.getCXXScopeSpec().getRange(); 5119 Invalid = true; 5120 } 5121 } 5122 } 5123 } 5124 } else if (D.getName().getKind() == UnqualifiedId::IK_TemplateId) { 5125 TemplateIdAnnotation *TemplateId = D.getName().TemplateId; 5126 5127 // We have encountered something that the user meant to be a 5128 // specialization (because it has explicitly-specified template 5129 // arguments) but that was not introduced with a "template<>" (or had 5130 // too few of them). 5131 // FIXME: Differentiate between attempts for explicit instantiations 5132 // (starting with "template") and the rest. 5133 Diag(D.getIdentifierLoc(), diag::err_template_spec_needs_header) 5134 << SourceRange(TemplateId->LAngleLoc, TemplateId->RAngleLoc) 5135 << FixItHint::CreateInsertion(D.getDeclSpec().getLocStart(), 5136 "template<> "); 5137 IsVariableTemplateSpecialization = true; 5138 } 5139 5140 if (IsVariableTemplateSpecialization) { 5141 if (!PrevVarTemplate) { 5142 Diag(D.getIdentifierLoc(), diag::err_var_spec_no_template) 5143 << IsPartialSpecialization; 5144 return 0; 5145 } 5146 5147 SourceLocation TemplateKWLoc = 5148 TemplateParamLists.size() > 0 5149 ? TemplateParamLists[0]->getTemplateLoc() 5150 : SourceLocation(); 5151 DeclResult Res = ActOnVarTemplateSpecialization( 5152 S, PrevVarTemplate, D, TInfo, TemplateKWLoc, TemplateParams, SC, 5153 IsPartialSpecialization); 5154 if (Res.isInvalid()) 5155 return 0; 5156 NewVD = cast<VarDecl>(Res.get()); 5157 AddToScope = false; 5158 } else 5159 NewVD = VarDecl::Create(Context, DC, D.getLocStart(), 5160 D.getIdentifierLoc(), II, R, TInfo, SC); 5161 5162 // If this is supposed to be a variable template, create it as such. 5163 if (IsVariableTemplate) { 5164 NewTemplate = 5165 VarTemplateDecl::Create(Context, DC, D.getIdentifierLoc(), Name, 5166 TemplateParams, NewVD, PrevVarTemplate); 5167 NewVD->setDescribedVarTemplate(NewTemplate); 5168 } 5169 5170 // If this decl has an auto type in need of deduction, make a note of the 5171 // Decl so we can diagnose uses of it in its own initializer. 5172 if (D.getDeclSpec().containsPlaceholderType() && R->getContainedAutoType()) 5173 ParsingInitForAutoVars.insert(NewVD); 5174 5175 if (D.isInvalidType() || Invalid) { 5176 NewVD->setInvalidDecl(); 5177 if (NewTemplate) 5178 NewTemplate->setInvalidDecl(); 5179 } 5180 5181 SetNestedNameSpecifier(NewVD, D); 5182 5183 // FIXME: Do we need D.getCXXScopeSpec().isSet()? 5184 if (TemplateParams && TemplateParamLists.size() > 1 && 5185 (!IsVariableTemplateSpecialization || D.getCXXScopeSpec().isSet())) { 5186 NewVD->setTemplateParameterListsInfo( 5187 Context, TemplateParamLists.size() - 1, TemplateParamLists.data()); 5188 } else if (IsVariableTemplateSpecialization || 5189 (!TemplateParams && TemplateParamLists.size() > 0 && 5190 (D.getCXXScopeSpec().isSet()))) { 5191 NewVD->setTemplateParameterListsInfo(Context, 5192 TemplateParamLists.size(), 5193 TemplateParamLists.data()); 5194 } 5195 5196 if (D.getDeclSpec().isConstexprSpecified()) 5197 NewVD->setConstexpr(true); 5198 } 5199 5200 // Set the lexical context. If the declarator has a C++ scope specifier, the 5201 // lexical context will be different from the semantic context. 5202 NewVD->setLexicalDeclContext(CurContext); 5203 if (NewTemplate) 5204 NewTemplate->setLexicalDeclContext(CurContext); 5205 5206 if (IsLocalExternDecl) 5207 NewVD->setLocalExternDecl(); 5208 5209 if (DeclSpec::TSCS TSCS = D.getDeclSpec().getThreadStorageClassSpec()) { 5210 if (NewVD->hasLocalStorage()) { 5211 // C++11 [dcl.stc]p4: 5212 // When thread_local is applied to a variable of block scope the 5213 // storage-class-specifier static is implied if it does not appear 5214 // explicitly. 5215 // Core issue: 'static' is not implied if the variable is declared 5216 // 'extern'. 5217 if (SCSpec == DeclSpec::SCS_unspecified && 5218 TSCS == DeclSpec::TSCS_thread_local && 5219 DC->isFunctionOrMethod()) 5220 NewVD->setTSCSpec(TSCS); 5221 else 5222 Diag(D.getDeclSpec().getThreadStorageClassSpecLoc(), 5223 diag::err_thread_non_global) 5224 << DeclSpec::getSpecifierName(TSCS); 5225 } else if (!Context.getTargetInfo().isTLSSupported()) 5226 Diag(D.getDeclSpec().getThreadStorageClassSpecLoc(), 5227 diag::err_thread_unsupported); 5228 else 5229 NewVD->setTSCSpec(TSCS); 5230 } 5231 5232 // C99 6.7.4p3 5233 // An inline definition of a function with external linkage shall 5234 // not contain a definition of a modifiable object with static or 5235 // thread storage duration... 5236 // We only apply this when the function is required to be defined 5237 // elsewhere, i.e. when the function is not 'extern inline'. Note 5238 // that a local variable with thread storage duration still has to 5239 // be marked 'static'. Also note that it's possible to get these 5240 // semantics in C++ using __attribute__((gnu_inline)). 5241 if (SC == SC_Static && S->getFnParent() != 0 && 5242 !NewVD->getType().isConstQualified()) { 5243 FunctionDecl *CurFD = getCurFunctionDecl(); 5244 if (CurFD && isFunctionDefinitionDiscarded(*this, CurFD)) { 5245 Diag(D.getDeclSpec().getStorageClassSpecLoc(), 5246 diag::warn_static_local_in_extern_inline); 5247 MaybeSuggestAddingStaticToDecl(CurFD); 5248 } 5249 } 5250 5251 if (D.getDeclSpec().isModulePrivateSpecified()) { 5252 if (IsVariableTemplateSpecialization) 5253 Diag(NewVD->getLocation(), diag::err_module_private_specialization) 5254 << (IsPartialSpecialization ? 1 : 0) 5255 << FixItHint::CreateRemoval( 5256 D.getDeclSpec().getModulePrivateSpecLoc()); 5257 else if (IsExplicitSpecialization) 5258 Diag(NewVD->getLocation(), diag::err_module_private_specialization) 5259 << 2 5260 << FixItHint::CreateRemoval(D.getDeclSpec().getModulePrivateSpecLoc()); 5261 else if (NewVD->hasLocalStorage()) 5262 Diag(NewVD->getLocation(), diag::err_module_private_local) 5263 << 0 << NewVD->getDeclName() 5264 << SourceRange(D.getDeclSpec().getModulePrivateSpecLoc()) 5265 << FixItHint::CreateRemoval(D.getDeclSpec().getModulePrivateSpecLoc()); 5266 else { 5267 NewVD->setModulePrivate(); 5268 if (NewTemplate) 5269 NewTemplate->setModulePrivate(); 5270 } 5271 } 5272 5273 // Handle attributes prior to checking for duplicates in MergeVarDecl 5274 ProcessDeclAttributes(S, NewVD, D); 5275 5276 if (NewVD->hasAttrs()) 5277 CheckAlignasUnderalignment(NewVD); 5278 5279 if (getLangOpts().CUDA) { 5280 // CUDA B.2.5: "__shared__ and __constant__ variables have implied static 5281 // storage [duration]." 5282 if (SC == SC_None && S->getFnParent() != 0 && 5283 (NewVD->hasAttr<CUDASharedAttr>() || 5284 NewVD->hasAttr<CUDAConstantAttr>())) { 5285 NewVD->setStorageClass(SC_Static); 5286 } 5287 } 5288 5289 // In auto-retain/release, infer strong retension for variables of 5290 // retainable type. 5291 if (getLangOpts().ObjCAutoRefCount && inferObjCARCLifetime(NewVD)) 5292 NewVD->setInvalidDecl(); 5293 5294 // Handle GNU asm-label extension (encoded as an attribute). 5295 if (Expr *E = (Expr*)D.getAsmLabel()) { 5296 // The parser guarantees this is a string. 5297 StringLiteral *SE = cast<StringLiteral>(E); 5298 StringRef Label = SE->getString(); 5299 if (S->getFnParent() != 0) { 5300 switch (SC) { 5301 case SC_None: 5302 case SC_Auto: 5303 Diag(E->getExprLoc(), diag::warn_asm_label_on_auto_decl) << Label; 5304 break; 5305 case SC_Register: 5306 if (!Context.getTargetInfo().isValidGCCRegisterName(Label)) 5307 Diag(E->getExprLoc(), diag::err_asm_unknown_register_name) << Label; 5308 break; 5309 case SC_Static: 5310 case SC_Extern: 5311 case SC_PrivateExtern: 5312 case SC_OpenCLWorkGroupLocal: 5313 break; 5314 } 5315 } 5316 5317 NewVD->addAttr(::new (Context) AsmLabelAttr(SE->getStrTokenLoc(0), 5318 Context, Label)); 5319 } else if (!ExtnameUndeclaredIdentifiers.empty()) { 5320 llvm::DenseMap<IdentifierInfo*,AsmLabelAttr*>::iterator I = 5321 ExtnameUndeclaredIdentifiers.find(NewVD->getIdentifier()); 5322 if (I != ExtnameUndeclaredIdentifiers.end()) { 5323 NewVD->addAttr(I->second); 5324 ExtnameUndeclaredIdentifiers.erase(I); 5325 } 5326 } 5327 5328 // Diagnose shadowed variables before filtering for scope. 5329 if (!D.getCXXScopeSpec().isSet()) 5330 CheckShadow(S, NewVD, Previous); 5331 5332 // Don't consider existing declarations that are in a different 5333 // scope and are out-of-semantic-context declarations (if the new 5334 // declaration has linkage). 5335 FilterLookupForScope( 5336 Previous, OriginalDC, S, shouldConsiderLinkage(NewVD), 5337 IsExplicitSpecialization || IsVariableTemplateSpecialization); 5338 5339 // Check whether the previous declaration is in the same block scope. This 5340 // affects whether we merge types with it, per C++11 [dcl.array]p3. 5341 if (getLangOpts().CPlusPlus && 5342 NewVD->isLocalVarDecl() && NewVD->hasExternalStorage()) 5343 NewVD->setPreviousDeclInSameBlockScope( 5344 Previous.isSingleResult() && !Previous.isShadowed() && 5345 isDeclInScope(Previous.getFoundDecl(), OriginalDC, S, false)); 5346 5347 if (!getLangOpts().CPlusPlus) { 5348 D.setRedeclaration(CheckVariableDeclaration(NewVD, Previous)); 5349 } else { 5350 // Merge the decl with the existing one if appropriate. 5351 if (!Previous.empty()) { 5352 if (Previous.isSingleResult() && 5353 isa<FieldDecl>(Previous.getFoundDecl()) && 5354 D.getCXXScopeSpec().isSet()) { 5355 // The user tried to define a non-static data member 5356 // out-of-line (C++ [dcl.meaning]p1). 5357 Diag(NewVD->getLocation(), diag::err_nonstatic_member_out_of_line) 5358 << D.getCXXScopeSpec().getRange(); 5359 Previous.clear(); 5360 NewVD->setInvalidDecl(); 5361 } 5362 } else if (D.getCXXScopeSpec().isSet()) { 5363 // No previous declaration in the qualifying scope. 5364 Diag(D.getIdentifierLoc(), diag::err_no_member) 5365 << Name << computeDeclContext(D.getCXXScopeSpec(), true) 5366 << D.getCXXScopeSpec().getRange(); 5367 NewVD->setInvalidDecl(); 5368 } 5369 5370 if (!IsVariableTemplateSpecialization) { 5371 if (PrevVarTemplate) { 5372 LookupResult PrevDecl(*this, GetNameForDeclarator(D), 5373 LookupOrdinaryName, ForRedeclaration); 5374 PrevDecl.addDecl(PrevVarTemplate->getTemplatedDecl()); 5375 D.setRedeclaration(CheckVariableDeclaration(NewVD, PrevDecl)); 5376 } else 5377 D.setRedeclaration(CheckVariableDeclaration(NewVD, Previous)); 5378 } 5379 5380 // This is an explicit specialization of a static data member. Check it. 5381 if (IsExplicitSpecialization && !NewVD->isInvalidDecl() && 5382 CheckMemberSpecialization(NewVD, Previous)) 5383 NewVD->setInvalidDecl(); 5384 } 5385 5386 ProcessPragmaWeak(S, NewVD); 5387 checkAttributesAfterMerging(*this, *NewVD); 5388 5389 // If this is the first declaration of an extern C variable, update 5390 // the map of such variables. 5391 if (NewVD->isFirstDecl() && !NewVD->isInvalidDecl() && 5392 isIncompleteDeclExternC(*this, NewVD)) 5393 RegisterLocallyScopedExternCDecl(NewVD, S); 5394 5395 if (getLangOpts().CPlusPlus && NewVD->isStaticLocal()) { 5396 Decl *ManglingContextDecl; 5397 if (MangleNumberingContext *MCtx = 5398 getCurrentMangleNumberContext(NewVD->getDeclContext(), 5399 ManglingContextDecl)) { 5400 Context.setManglingNumber(NewVD, MCtx->getManglingNumber(NewVD)); 5401 } 5402 } 5403 5404 // If we are providing an explicit specialization of a static variable 5405 // template, make a note of that. 5406 if (PrevVarTemplate && PrevVarTemplate->getInstantiatedFromMemberTemplate()) 5407 PrevVarTemplate->setMemberSpecialization(); 5408 5409 if (NewTemplate) { 5410 ActOnDocumentableDecl(NewTemplate); 5411 return NewTemplate; 5412 } 5413 5414 return NewVD; 5415} 5416 5417/// \brief Diagnose variable or built-in function shadowing. Implements 5418/// -Wshadow. 5419/// 5420/// This method is called whenever a VarDecl is added to a "useful" 5421/// scope. 5422/// 5423/// \param S the scope in which the shadowing name is being declared 5424/// \param R the lookup of the name 5425/// 5426void Sema::CheckShadow(Scope *S, VarDecl *D, const LookupResult& R) { 5427 // Return if warning is ignored. 5428 if (Diags.getDiagnosticLevel(diag::warn_decl_shadow, R.getNameLoc()) == 5429 DiagnosticsEngine::Ignored) 5430 return; 5431 5432 // Don't diagnose declarations at file scope. 5433 if (D->hasGlobalStorage()) 5434 return; 5435 5436 DeclContext *NewDC = D->getDeclContext(); 5437 5438 // Only diagnose if we're shadowing an unambiguous field or variable. 5439 if (R.getResultKind() != LookupResult::Found) 5440 return; 5441 5442 NamedDecl* ShadowedDecl = R.getFoundDecl(); 5443 if (!isa<VarDecl>(ShadowedDecl) && !isa<FieldDecl>(ShadowedDecl)) 5444 return; 5445 5446 // Fields are not shadowed by variables in C++ static methods. 5447 if (isa<FieldDecl>(ShadowedDecl)) 5448 if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(NewDC)) 5449 if (MD->isStatic()) 5450 return; 5451 5452 if (VarDecl *shadowedVar = dyn_cast<VarDecl>(ShadowedDecl)) 5453 if (shadowedVar->isExternC()) { 5454 // For shadowing external vars, make sure that we point to the global 5455 // declaration, not a locally scoped extern declaration. 5456 for (VarDecl::redecl_iterator 5457 I = shadowedVar->redecls_begin(), E = shadowedVar->redecls_end(); 5458 I != E; ++I) 5459 if (I->isFileVarDecl()) { 5460 ShadowedDecl = *I; 5461 break; 5462 } 5463 } 5464 5465 DeclContext *OldDC = ShadowedDecl->getDeclContext(); 5466 5467 // Only warn about certain kinds of shadowing for class members. 5468 if (NewDC && NewDC->isRecord()) { 5469 // In particular, don't warn about shadowing non-class members. 5470 if (!OldDC->isRecord()) 5471 return; 5472 5473 // TODO: should we warn about static data members shadowing 5474 // static data members from base classes? 5475 5476 // TODO: don't diagnose for inaccessible shadowed members. 5477 // This is hard to do perfectly because we might friend the 5478 // shadowing context, but that's just a false negative. 5479 } 5480 5481 // Determine what kind of declaration we're shadowing. 5482 unsigned Kind; 5483 if (isa<RecordDecl>(OldDC)) { 5484 if (isa<FieldDecl>(ShadowedDecl)) 5485 Kind = 3; // field 5486 else 5487 Kind = 2; // static data member 5488 } else if (OldDC->isFileContext()) 5489 Kind = 1; // global 5490 else 5491 Kind = 0; // local 5492 5493 DeclarationName Name = R.getLookupName(); 5494 5495 // Emit warning and note. 5496 Diag(R.getNameLoc(), diag::warn_decl_shadow) << Name << Kind << OldDC; 5497 Diag(ShadowedDecl->getLocation(), diag::note_previous_declaration); 5498} 5499 5500/// \brief Check -Wshadow without the advantage of a previous lookup. 5501void Sema::CheckShadow(Scope *S, VarDecl *D) { 5502 if (Diags.getDiagnosticLevel(diag::warn_decl_shadow, D->getLocation()) == 5503 DiagnosticsEngine::Ignored) 5504 return; 5505 5506 LookupResult R(*this, D->getDeclName(), D->getLocation(), 5507 Sema::LookupOrdinaryName, Sema::ForRedeclaration); 5508 LookupName(R, S); 5509 CheckShadow(S, D, R); 5510} 5511 5512/// Check for conflict between this global or extern "C" declaration and 5513/// previous global or extern "C" declarations. This is only used in C++. 5514template<typename T> 5515static bool checkGlobalOrExternCConflict( 5516 Sema &S, const T *ND, bool IsGlobal, LookupResult &Previous) { 5517 assert(S.getLangOpts().CPlusPlus && "only C++ has extern \"C\""); 5518 NamedDecl *Prev = S.findLocallyScopedExternCDecl(ND->getDeclName()); 5519 5520 if (!Prev && IsGlobal && !isIncompleteDeclExternC(S, ND)) { 5521 // The common case: this global doesn't conflict with any extern "C" 5522 // declaration. 5523 return false; 5524 } 5525 5526 if (Prev) { 5527 if (!IsGlobal || isIncompleteDeclExternC(S, ND)) { 5528 // Both the old and new declarations have C language linkage. This is a 5529 // redeclaration. 5530 Previous.clear(); 5531 Previous.addDecl(Prev); 5532 return true; 5533 } 5534 5535 // This is a global, non-extern "C" declaration, and there is a previous 5536 // non-global extern "C" declaration. Diagnose if this is a variable 5537 // declaration. 5538 if (!isa<VarDecl>(ND)) 5539 return false; 5540 } else { 5541 // The declaration is extern "C". Check for any declaration in the 5542 // translation unit which might conflict. 5543 if (IsGlobal) { 5544 // We have already performed the lookup into the translation unit. 5545 IsGlobal = false; 5546 for (LookupResult::iterator I = Previous.begin(), E = Previous.end(); 5547 I != E; ++I) { 5548 if (isa<VarDecl>(*I)) { 5549 Prev = *I; 5550 break; 5551 } 5552 } 5553 } else { 5554 DeclContext::lookup_result R = 5555 S.Context.getTranslationUnitDecl()->lookup(ND->getDeclName()); 5556 for (DeclContext::lookup_result::iterator I = R.begin(), E = R.end(); 5557 I != E; ++I) { 5558 if (isa<VarDecl>(*I)) { 5559 Prev = *I; 5560 break; 5561 } 5562 // FIXME: If we have any other entity with this name in global scope, 5563 // the declaration is ill-formed, but that is a defect: it breaks the 5564 // 'stat' hack, for instance. Only variables can have mangled name 5565 // clashes with extern "C" declarations, so only they deserve a 5566 // diagnostic. 5567 } 5568 } 5569 5570 if (!Prev) 5571 return false; 5572 } 5573 5574 // Use the first declaration's location to ensure we point at something which 5575 // is lexically inside an extern "C" linkage-spec. 5576 assert(Prev && "should have found a previous declaration to diagnose"); 5577 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(Prev)) 5578 Prev = FD->getFirstDecl(); 5579 else 5580 Prev = cast<VarDecl>(Prev)->getFirstDecl(); 5581 5582 S.Diag(ND->getLocation(), diag::err_extern_c_global_conflict) 5583 << IsGlobal << ND; 5584 S.Diag(Prev->getLocation(), diag::note_extern_c_global_conflict) 5585 << IsGlobal; 5586 return false; 5587} 5588 5589/// Apply special rules for handling extern "C" declarations. Returns \c true 5590/// if we have found that this is a redeclaration of some prior entity. 5591/// 5592/// Per C++ [dcl.link]p6: 5593/// Two declarations [for a function or variable] with C language linkage 5594/// with the same name that appear in different scopes refer to the same 5595/// [entity]. An entity with C language linkage shall not be declared with 5596/// the same name as an entity in global scope. 5597template<typename T> 5598static bool checkForConflictWithNonVisibleExternC(Sema &S, const T *ND, 5599 LookupResult &Previous) { 5600 if (!S.getLangOpts().CPlusPlus) { 5601 // In C, when declaring a global variable, look for a corresponding 'extern' 5602 // variable declared in function scope. We don't need this in C++, because 5603 // we find local extern decls in the surrounding file-scope DeclContext. 5604 if (ND->getDeclContext()->getRedeclContext()->isTranslationUnit()) { 5605 if (NamedDecl *Prev = S.findLocallyScopedExternCDecl(ND->getDeclName())) { 5606 Previous.clear(); 5607 Previous.addDecl(Prev); 5608 return true; 5609 } 5610 } 5611 return false; 5612 } 5613 5614 // A declaration in the translation unit can conflict with an extern "C" 5615 // declaration. 5616 if (ND->getDeclContext()->getRedeclContext()->isTranslationUnit()) 5617 return checkGlobalOrExternCConflict(S, ND, /*IsGlobal*/true, Previous); 5618 5619 // An extern "C" declaration can conflict with a declaration in the 5620 // translation unit or can be a redeclaration of an extern "C" declaration 5621 // in another scope. 5622 if (isIncompleteDeclExternC(S,ND)) 5623 return checkGlobalOrExternCConflict(S, ND, /*IsGlobal*/false, Previous); 5624 5625 // Neither global nor extern "C": nothing to do. 5626 return false; 5627} 5628 5629void Sema::CheckVariableDeclarationType(VarDecl *NewVD) { 5630 // If the decl is already known invalid, don't check it. 5631 if (NewVD->isInvalidDecl()) 5632 return; 5633 5634 TypeSourceInfo *TInfo = NewVD->getTypeSourceInfo(); 5635 QualType T = TInfo->getType(); 5636 5637 // Defer checking an 'auto' type until its initializer is attached. 5638 if (T->isUndeducedType()) 5639 return; 5640 5641 if (T->isObjCObjectType()) { 5642 Diag(NewVD->getLocation(), diag::err_statically_allocated_object) 5643 << FixItHint::CreateInsertion(NewVD->getLocation(), "*"); 5644 T = Context.getObjCObjectPointerType(T); 5645 NewVD->setType(T); 5646 } 5647 5648 // Emit an error if an address space was applied to decl with local storage. 5649 // This includes arrays of objects with address space qualifiers, but not 5650 // automatic variables that point to other address spaces. 5651 // ISO/IEC TR 18037 S5.1.2 5652 if (NewVD->hasLocalStorage() && T.getAddressSpace() != 0) { 5653 Diag(NewVD->getLocation(), diag::err_as_qualified_auto_decl); 5654 NewVD->setInvalidDecl(); 5655 return; 5656 } 5657 5658 // OpenCL v1.2 s6.5 - All program scope variables must be declared in the 5659 // __constant address space. 5660 if (getLangOpts().OpenCL && NewVD->isFileVarDecl() 5661 && T.getAddressSpace() != LangAS::opencl_constant 5662 && !T->isSamplerT()){ 5663 Diag(NewVD->getLocation(), diag::err_opencl_global_invalid_addr_space); 5664 NewVD->setInvalidDecl(); 5665 return; 5666 } 5667 5668 // OpenCL v1.2 s6.8 -- The static qualifier is valid only in program 5669 // scope. 5670 if ((getLangOpts().OpenCLVersion >= 120) 5671 && NewVD->isStaticLocal()) { 5672 Diag(NewVD->getLocation(), diag::err_static_function_scope); 5673 NewVD->setInvalidDecl(); 5674 return; 5675 } 5676 5677 if (NewVD->hasLocalStorage() && T.isObjCGCWeak() 5678 && !NewVD->hasAttr<BlocksAttr>()) { 5679 if (getLangOpts().getGC() != LangOptions::NonGC) 5680 Diag(NewVD->getLocation(), diag::warn_gc_attribute_weak_on_local); 5681 else { 5682 assert(!getLangOpts().ObjCAutoRefCount); 5683 Diag(NewVD->getLocation(), diag::warn_attribute_weak_on_local); 5684 } 5685 } 5686 5687 bool isVM = T->isVariablyModifiedType(); 5688 if (isVM || NewVD->hasAttr<CleanupAttr>() || 5689 NewVD->hasAttr<BlocksAttr>()) 5690 getCurFunction()->setHasBranchProtectedScope(); 5691 5692 if ((isVM && NewVD->hasLinkage()) || 5693 (T->isVariableArrayType() && NewVD->hasGlobalStorage())) { 5694 bool SizeIsNegative; 5695 llvm::APSInt Oversized; 5696 TypeSourceInfo *FixedTInfo = 5697 TryToFixInvalidVariablyModifiedTypeSourceInfo(TInfo, Context, 5698 SizeIsNegative, Oversized); 5699 if (FixedTInfo == 0 && T->isVariableArrayType()) { 5700 const VariableArrayType *VAT = Context.getAsVariableArrayType(T); 5701 // FIXME: This won't give the correct result for 5702 // int a[10][n]; 5703 SourceRange SizeRange = VAT->getSizeExpr()->getSourceRange(); 5704 5705 if (NewVD->isFileVarDecl()) 5706 Diag(NewVD->getLocation(), diag::err_vla_decl_in_file_scope) 5707 << SizeRange; 5708 else if (NewVD->isStaticLocal()) 5709 Diag(NewVD->getLocation(), diag::err_vla_decl_has_static_storage) 5710 << SizeRange; 5711 else 5712 Diag(NewVD->getLocation(), diag::err_vla_decl_has_extern_linkage) 5713 << SizeRange; 5714 NewVD->setInvalidDecl(); 5715 return; 5716 } 5717 5718 if (FixedTInfo == 0) { 5719 if (NewVD->isFileVarDecl()) 5720 Diag(NewVD->getLocation(), diag::err_vm_decl_in_file_scope); 5721 else 5722 Diag(NewVD->getLocation(), diag::err_vm_decl_has_extern_linkage); 5723 NewVD->setInvalidDecl(); 5724 return; 5725 } 5726 5727 Diag(NewVD->getLocation(), diag::warn_illegal_constant_array_size); 5728 NewVD->setType(FixedTInfo->getType()); 5729 NewVD->setTypeSourceInfo(FixedTInfo); 5730 } 5731 5732 if (T->isVoidType()) { 5733 // C++98 [dcl.stc]p5: The extern specifier can be applied only to the names 5734 // of objects and functions. 5735 if (NewVD->isThisDeclarationADefinition() || getLangOpts().CPlusPlus) { 5736 Diag(NewVD->getLocation(), diag::err_typecheck_decl_incomplete_type) 5737 << T; 5738 NewVD->setInvalidDecl(); 5739 return; 5740 } 5741 } 5742 5743 if (!NewVD->hasLocalStorage() && NewVD->hasAttr<BlocksAttr>()) { 5744 Diag(NewVD->getLocation(), diag::err_block_on_nonlocal); 5745 NewVD->setInvalidDecl(); 5746 return; 5747 } 5748 5749 if (isVM && NewVD->hasAttr<BlocksAttr>()) { 5750 Diag(NewVD->getLocation(), diag::err_block_on_vm); 5751 NewVD->setInvalidDecl(); 5752 return; 5753 } 5754 5755 if (NewVD->isConstexpr() && !T->isDependentType() && 5756 RequireLiteralType(NewVD->getLocation(), T, 5757 diag::err_constexpr_var_non_literal)) { 5758 // Can't perform this check until the type is deduced. 5759 NewVD->setInvalidDecl(); 5760 return; 5761 } 5762} 5763 5764/// \brief Perform semantic checking on a newly-created variable 5765/// declaration. 5766/// 5767/// This routine performs all of the type-checking required for a 5768/// variable declaration once it has been built. It is used both to 5769/// check variables after they have been parsed and their declarators 5770/// have been translated into a declaration, and to check variables 5771/// that have been instantiated from a template. 5772/// 5773/// Sets NewVD->isInvalidDecl() if an error was encountered. 5774/// 5775/// Returns true if the variable declaration is a redeclaration. 5776bool Sema::CheckVariableDeclaration(VarDecl *NewVD, LookupResult &Previous) { 5777 CheckVariableDeclarationType(NewVD); 5778 5779 // If the decl is already known invalid, don't check it. 5780 if (NewVD->isInvalidDecl()) 5781 return false; 5782 5783 // If we did not find anything by this name, look for a non-visible 5784 // extern "C" declaration with the same name. 5785 if (Previous.empty() && 5786 checkForConflictWithNonVisibleExternC(*this, NewVD, Previous)) 5787 Previous.setShadowed(); 5788 5789 // Filter out any non-conflicting previous declarations. 5790 filterNonConflictingPreviousDecls(Context, NewVD, Previous); 5791 5792 if (!Previous.empty()) { 5793 MergeVarDecl(NewVD, Previous); 5794 return true; 5795 } 5796 return false; 5797} 5798 5799/// \brief Data used with FindOverriddenMethod 5800struct FindOverriddenMethodData { 5801 Sema *S; 5802 CXXMethodDecl *Method; 5803}; 5804 5805/// \brief Member lookup function that determines whether a given C++ 5806/// method overrides a method in a base class, to be used with 5807/// CXXRecordDecl::lookupInBases(). 5808static bool FindOverriddenMethod(const CXXBaseSpecifier *Specifier, 5809 CXXBasePath &Path, 5810 void *UserData) { 5811 RecordDecl *BaseRecord = Specifier->getType()->getAs<RecordType>()->getDecl(); 5812 5813 FindOverriddenMethodData *Data 5814 = reinterpret_cast<FindOverriddenMethodData*>(UserData); 5815 5816 DeclarationName Name = Data->Method->getDeclName(); 5817 5818 // FIXME: Do we care about other names here too? 5819 if (Name.getNameKind() == DeclarationName::CXXDestructorName) { 5820 // We really want to find the base class destructor here. 5821 QualType T = Data->S->Context.getTypeDeclType(BaseRecord); 5822 CanQualType CT = Data->S->Context.getCanonicalType(T); 5823 5824 Name = Data->S->Context.DeclarationNames.getCXXDestructorName(CT); 5825 } 5826 5827 for (Path.Decls = BaseRecord->lookup(Name); 5828 !Path.Decls.empty(); 5829 Path.Decls = Path.Decls.slice(1)) { 5830 NamedDecl *D = Path.Decls.front(); 5831 if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(D)) { 5832 if (MD->isVirtual() && !Data->S->IsOverload(Data->Method, MD, false)) 5833 return true; 5834 } 5835 } 5836 5837 return false; 5838} 5839 5840namespace { 5841 enum OverrideErrorKind { OEK_All, OEK_NonDeleted, OEK_Deleted }; 5842} 5843/// \brief Report an error regarding overriding, along with any relevant 5844/// overriden methods. 5845/// 5846/// \param DiagID the primary error to report. 5847/// \param MD the overriding method. 5848/// \param OEK which overrides to include as notes. 5849static void ReportOverrides(Sema& S, unsigned DiagID, const CXXMethodDecl *MD, 5850 OverrideErrorKind OEK = OEK_All) { 5851 S.Diag(MD->getLocation(), DiagID) << MD->getDeclName(); 5852 for (CXXMethodDecl::method_iterator I = MD->begin_overridden_methods(), 5853 E = MD->end_overridden_methods(); 5854 I != E; ++I) { 5855 // This check (& the OEK parameter) could be replaced by a predicate, but 5856 // without lambdas that would be overkill. This is still nicer than writing 5857 // out the diag loop 3 times. 5858 if ((OEK == OEK_All) || 5859 (OEK == OEK_NonDeleted && !(*I)->isDeleted()) || 5860 (OEK == OEK_Deleted && (*I)->isDeleted())) 5861 S.Diag((*I)->getLocation(), diag::note_overridden_virtual_function); 5862 } 5863} 5864 5865/// AddOverriddenMethods - See if a method overrides any in the base classes, 5866/// and if so, check that it's a valid override and remember it. 5867bool Sema::AddOverriddenMethods(CXXRecordDecl *DC, CXXMethodDecl *MD) { 5868 // Look for virtual methods in base classes that this method might override. 5869 CXXBasePaths Paths; 5870 FindOverriddenMethodData Data; 5871 Data.Method = MD; 5872 Data.S = this; 5873 bool hasDeletedOverridenMethods = false; 5874 bool hasNonDeletedOverridenMethods = false; 5875 bool AddedAny = false; 5876 if (DC->lookupInBases(&FindOverriddenMethod, &Data, Paths)) { 5877 for (CXXBasePaths::decl_iterator I = Paths.found_decls_begin(), 5878 E = Paths.found_decls_end(); I != E; ++I) { 5879 if (CXXMethodDecl *OldMD = dyn_cast<CXXMethodDecl>(*I)) { 5880 MD->addOverriddenMethod(OldMD->getCanonicalDecl()); 5881 if (!CheckOverridingFunctionReturnType(MD, OldMD) && 5882 !CheckOverridingFunctionAttributes(MD, OldMD) && 5883 !CheckOverridingFunctionExceptionSpec(MD, OldMD) && 5884 !CheckIfOverriddenFunctionIsMarkedFinal(MD, OldMD)) { 5885 hasDeletedOverridenMethods |= OldMD->isDeleted(); 5886 hasNonDeletedOverridenMethods |= !OldMD->isDeleted(); 5887 AddedAny = true; 5888 } 5889 } 5890 } 5891 } 5892 5893 if (hasDeletedOverridenMethods && !MD->isDeleted()) { 5894 ReportOverrides(*this, diag::err_non_deleted_override, MD, OEK_Deleted); 5895 } 5896 if (hasNonDeletedOverridenMethods && MD->isDeleted()) { 5897 ReportOverrides(*this, diag::err_deleted_override, MD, OEK_NonDeleted); 5898 } 5899 5900 return AddedAny; 5901} 5902 5903namespace { 5904 // Struct for holding all of the extra arguments needed by 5905 // DiagnoseInvalidRedeclaration to call Sema::ActOnFunctionDeclarator. 5906 struct ActOnFDArgs { 5907 Scope *S; 5908 Declarator &D; 5909 MultiTemplateParamsArg TemplateParamLists; 5910 bool AddToScope; 5911 }; 5912} 5913 5914namespace { 5915 5916// Callback to only accept typo corrections that have a non-zero edit distance. 5917// Also only accept corrections that have the same parent decl. 5918class DifferentNameValidatorCCC : public CorrectionCandidateCallback { 5919 public: 5920 DifferentNameValidatorCCC(ASTContext &Context, FunctionDecl *TypoFD, 5921 CXXRecordDecl *Parent) 5922 : Context(Context), OriginalFD(TypoFD), 5923 ExpectedParent(Parent ? Parent->getCanonicalDecl() : 0) {} 5924 5925 virtual bool ValidateCandidate(const TypoCorrection &candidate) { 5926 if (candidate.getEditDistance() == 0) 5927 return false; 5928 5929 SmallVector<unsigned, 1> MismatchedParams; 5930 for (TypoCorrection::const_decl_iterator CDecl = candidate.begin(), 5931 CDeclEnd = candidate.end(); 5932 CDecl != CDeclEnd; ++CDecl) { 5933 FunctionDecl *FD = dyn_cast<FunctionDecl>(*CDecl); 5934 5935 if (FD && !FD->hasBody() && 5936 hasSimilarParameters(Context, FD, OriginalFD, MismatchedParams)) { 5937 if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) { 5938 CXXRecordDecl *Parent = MD->getParent(); 5939 if (Parent && Parent->getCanonicalDecl() == ExpectedParent) 5940 return true; 5941 } else if (!ExpectedParent) { 5942 return true; 5943 } 5944 } 5945 } 5946 5947 return false; 5948 } 5949 5950 private: 5951 ASTContext &Context; 5952 FunctionDecl *OriginalFD; 5953 CXXRecordDecl *ExpectedParent; 5954}; 5955 5956} 5957 5958/// \brief Generate diagnostics for an invalid function redeclaration. 5959/// 5960/// This routine handles generating the diagnostic messages for an invalid 5961/// function redeclaration, including finding possible similar declarations 5962/// or performing typo correction if there are no previous declarations with 5963/// the same name. 5964/// 5965/// Returns a NamedDecl iff typo correction was performed and substituting in 5966/// the new declaration name does not cause new errors. 5967static NamedDecl *DiagnoseInvalidRedeclaration( 5968 Sema &SemaRef, LookupResult &Previous, FunctionDecl *NewFD, 5969 ActOnFDArgs &ExtraArgs, bool IsLocalFriend, Scope *S) { 5970 DeclarationName Name = NewFD->getDeclName(); 5971 DeclContext *NewDC = NewFD->getDeclContext(); 5972 SmallVector<unsigned, 1> MismatchedParams; 5973 SmallVector<std::pair<FunctionDecl *, unsigned>, 1> NearMatches; 5974 TypoCorrection Correction; 5975 bool IsDefinition = ExtraArgs.D.isFunctionDefinition(); 5976 unsigned DiagMsg = IsLocalFriend ? diag::err_no_matching_local_friend 5977 : diag::err_member_decl_does_not_match; 5978 LookupResult Prev(SemaRef, Name, NewFD->getLocation(), 5979 IsLocalFriend ? Sema::LookupLocalFriendName 5980 : Sema::LookupOrdinaryName, 5981 Sema::ForRedeclaration); 5982 5983 NewFD->setInvalidDecl(); 5984 if (IsLocalFriend) 5985 SemaRef.LookupName(Prev, S); 5986 else 5987 SemaRef.LookupQualifiedName(Prev, NewDC); 5988 assert(!Prev.isAmbiguous() && 5989 "Cannot have an ambiguity in previous-declaration lookup"); 5990 CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(NewFD); 5991 DifferentNameValidatorCCC Validator(SemaRef.Context, NewFD, 5992 MD ? MD->getParent() : 0); 5993 if (!Prev.empty()) { 5994 for (LookupResult::iterator Func = Prev.begin(), FuncEnd = Prev.end(); 5995 Func != FuncEnd; ++Func) { 5996 FunctionDecl *FD = dyn_cast<FunctionDecl>(*Func); 5997 if (FD && 5998 hasSimilarParameters(SemaRef.Context, FD, NewFD, MismatchedParams)) { 5999 // Add 1 to the index so that 0 can mean the mismatch didn't 6000 // involve a parameter 6001 unsigned ParamNum = 6002 MismatchedParams.empty() ? 0 : MismatchedParams.front() + 1; 6003 NearMatches.push_back(std::make_pair(FD, ParamNum)); 6004 } 6005 } 6006 // If the qualified name lookup yielded nothing, try typo correction 6007 } else if ((Correction = SemaRef.CorrectTypo( 6008 Prev.getLookupNameInfo(), Prev.getLookupKind(), S, 6009 &ExtraArgs.D.getCXXScopeSpec(), Validator, 6010 IsLocalFriend ? 0 : NewDC))) { 6011 // Set up everything for the call to ActOnFunctionDeclarator 6012 ExtraArgs.D.SetIdentifier(Correction.getCorrectionAsIdentifierInfo(), 6013 ExtraArgs.D.getIdentifierLoc()); 6014 Previous.clear(); 6015 Previous.setLookupName(Correction.getCorrection()); 6016 for (TypoCorrection::decl_iterator CDecl = Correction.begin(), 6017 CDeclEnd = Correction.end(); 6018 CDecl != CDeclEnd; ++CDecl) { 6019 FunctionDecl *FD = dyn_cast<FunctionDecl>(*CDecl); 6020 if (FD && !FD->hasBody() && 6021 hasSimilarParameters(SemaRef.Context, FD, NewFD, MismatchedParams)) { 6022 Previous.addDecl(FD); 6023 } 6024 } 6025 bool wasRedeclaration = ExtraArgs.D.isRedeclaration(); 6026 6027 NamedDecl *Result; 6028 // Retry building the function declaration with the new previous 6029 // declarations, and with errors suppressed. 6030 { 6031 // Trap errors. 6032 Sema::SFINAETrap Trap(SemaRef); 6033 6034 // TODO: Refactor ActOnFunctionDeclarator so that we can call only the 6035 // pieces need to verify the typo-corrected C++ declaration and hopefully 6036 // eliminate the need for the parameter pack ExtraArgs. 6037 Result = SemaRef.ActOnFunctionDeclarator( 6038 ExtraArgs.S, ExtraArgs.D, 6039 Correction.getCorrectionDecl()->getDeclContext(), 6040 NewFD->getTypeSourceInfo(), Previous, ExtraArgs.TemplateParamLists, 6041 ExtraArgs.AddToScope); 6042 6043 if (Trap.hasErrorOccurred()) 6044 Result = 0; 6045 } 6046 6047 if (Result) { 6048 // Determine which correction we picked. 6049 Decl *Canonical = Result->getCanonicalDecl(); 6050 for (LookupResult::iterator I = Previous.begin(), E = Previous.end(); 6051 I != E; ++I) 6052 if ((*I)->getCanonicalDecl() == Canonical) 6053 Correction.setCorrectionDecl(*I); 6054 6055 SemaRef.diagnoseTypo( 6056 Correction, 6057 SemaRef.PDiag(IsLocalFriend 6058 ? diag::err_no_matching_local_friend_suggest 6059 : diag::err_member_decl_does_not_match_suggest) 6060 << Name << NewDC << IsDefinition); 6061 return Result; 6062 } 6063 6064 // Pretend the typo correction never occurred 6065 ExtraArgs.D.SetIdentifier(Name.getAsIdentifierInfo(), 6066 ExtraArgs.D.getIdentifierLoc()); 6067 ExtraArgs.D.setRedeclaration(wasRedeclaration); 6068 Previous.clear(); 6069 Previous.setLookupName(Name); 6070 } 6071 6072 SemaRef.Diag(NewFD->getLocation(), DiagMsg) 6073 << Name << NewDC << IsDefinition << NewFD->getLocation(); 6074 6075 bool NewFDisConst = false; 6076 if (CXXMethodDecl *NewMD = dyn_cast<CXXMethodDecl>(NewFD)) 6077 NewFDisConst = NewMD->isConst(); 6078 6079 for (SmallVectorImpl<std::pair<FunctionDecl *, unsigned> >::iterator 6080 NearMatch = NearMatches.begin(), NearMatchEnd = NearMatches.end(); 6081 NearMatch != NearMatchEnd; ++NearMatch) { 6082 FunctionDecl *FD = NearMatch->first; 6083 CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD); 6084 bool FDisConst = MD && MD->isConst(); 6085 bool IsMember = MD || !IsLocalFriend; 6086 6087 // FIXME: These notes are poorly worded for the local friend case. 6088 if (unsigned Idx = NearMatch->second) { 6089 ParmVarDecl *FDParam = FD->getParamDecl(Idx-1); 6090 SourceLocation Loc = FDParam->getTypeSpecStartLoc(); 6091 if (Loc.isInvalid()) Loc = FD->getLocation(); 6092 SemaRef.Diag(Loc, IsMember ? diag::note_member_def_close_param_match 6093 : diag::note_local_decl_close_param_match) 6094 << Idx << FDParam->getType() 6095 << NewFD->getParamDecl(Idx - 1)->getType(); 6096 } else if (FDisConst != NewFDisConst) { 6097 SemaRef.Diag(FD->getLocation(), diag::note_member_def_close_const_match) 6098 << NewFDisConst << FD->getSourceRange().getEnd(); 6099 } else 6100 SemaRef.Diag(FD->getLocation(), 6101 IsMember ? diag::note_member_def_close_match 6102 : diag::note_local_decl_close_match); 6103 } 6104 return 0; 6105} 6106 6107static FunctionDecl::StorageClass getFunctionStorageClass(Sema &SemaRef, 6108 Declarator &D) { 6109 switch (D.getDeclSpec().getStorageClassSpec()) { 6110 default: llvm_unreachable("Unknown storage class!"); 6111 case DeclSpec::SCS_auto: 6112 case DeclSpec::SCS_register: 6113 case DeclSpec::SCS_mutable: 6114 SemaRef.Diag(D.getDeclSpec().getStorageClassSpecLoc(), 6115 diag::err_typecheck_sclass_func); 6116 D.setInvalidType(); 6117 break; 6118 case DeclSpec::SCS_unspecified: break; 6119 case DeclSpec::SCS_extern: 6120 if (D.getDeclSpec().isExternInLinkageSpec()) 6121 return SC_None; 6122 return SC_Extern; 6123 case DeclSpec::SCS_static: { 6124 if (SemaRef.CurContext->getRedeclContext()->isFunctionOrMethod()) { 6125 // C99 6.7.1p5: 6126 // The declaration of an identifier for a function that has 6127 // block scope shall have no explicit storage-class specifier 6128 // other than extern 6129 // See also (C++ [dcl.stc]p4). 6130 SemaRef.Diag(D.getDeclSpec().getStorageClassSpecLoc(), 6131 diag::err_static_block_func); 6132 break; 6133 } else 6134 return SC_Static; 6135 } 6136 case DeclSpec::SCS_private_extern: return SC_PrivateExtern; 6137 } 6138 6139 // No explicit storage class has already been returned 6140 return SC_None; 6141} 6142 6143static FunctionDecl* CreateNewFunctionDecl(Sema &SemaRef, Declarator &D, 6144 DeclContext *DC, QualType &R, 6145 TypeSourceInfo *TInfo, 6146 FunctionDecl::StorageClass SC, 6147 bool &IsVirtualOkay) { 6148 DeclarationNameInfo NameInfo = SemaRef.GetNameForDeclarator(D); 6149 DeclarationName Name = NameInfo.getName(); 6150 6151 FunctionDecl *NewFD = 0; 6152 bool isInline = D.getDeclSpec().isInlineSpecified(); 6153 6154 if (!SemaRef.getLangOpts().CPlusPlus) { 6155 // Determine whether the function was written with a 6156 // prototype. This true when: 6157 // - there is a prototype in the declarator, or 6158 // - the type R of the function is some kind of typedef or other reference 6159 // to a type name (which eventually refers to a function type). 6160 bool HasPrototype = 6161 (D.isFunctionDeclarator() && D.getFunctionTypeInfo().hasPrototype) || 6162 (!isa<FunctionType>(R.getTypePtr()) && R->isFunctionProtoType()); 6163 6164 NewFD = FunctionDecl::Create(SemaRef.Context, DC, 6165 D.getLocStart(), NameInfo, R, 6166 TInfo, SC, isInline, 6167 HasPrototype, false); 6168 if (D.isInvalidType()) 6169 NewFD->setInvalidDecl(); 6170 6171 // Set the lexical context. 6172 NewFD->setLexicalDeclContext(SemaRef.CurContext); 6173 6174 return NewFD; 6175 } 6176 6177 bool isExplicit = D.getDeclSpec().isExplicitSpecified(); 6178 bool isConstexpr = D.getDeclSpec().isConstexprSpecified(); 6179 6180 // Check that the return type is not an abstract class type. 6181 // For record types, this is done by the AbstractClassUsageDiagnoser once 6182 // the class has been completely parsed. 6183 if (!DC->isRecord() && 6184 SemaRef.RequireNonAbstractType(D.getIdentifierLoc(), 6185 R->getAs<FunctionType>()->getResultType(), 6186 diag::err_abstract_type_in_decl, 6187 SemaRef.AbstractReturnType)) 6188 D.setInvalidType(); 6189 6190 if (Name.getNameKind() == DeclarationName::CXXConstructorName) { 6191 // This is a C++ constructor declaration. 6192 assert(DC->isRecord() && 6193 "Constructors can only be declared in a member context"); 6194 6195 R = SemaRef.CheckConstructorDeclarator(D, R, SC); 6196 return CXXConstructorDecl::Create(SemaRef.Context, cast<CXXRecordDecl>(DC), 6197 D.getLocStart(), NameInfo, 6198 R, TInfo, isExplicit, isInline, 6199 /*isImplicitlyDeclared=*/false, 6200 isConstexpr); 6201 6202 } else if (Name.getNameKind() == DeclarationName::CXXDestructorName) { 6203 // This is a C++ destructor declaration. 6204 if (DC->isRecord()) { 6205 R = SemaRef.CheckDestructorDeclarator(D, R, SC); 6206 CXXRecordDecl *Record = cast<CXXRecordDecl>(DC); 6207 CXXDestructorDecl *NewDD = CXXDestructorDecl::Create( 6208 SemaRef.Context, Record, 6209 D.getLocStart(), 6210 NameInfo, R, TInfo, isInline, 6211 /*isImplicitlyDeclared=*/false); 6212 6213 // If the class is complete, then we now create the implicit exception 6214 // specification. If the class is incomplete or dependent, we can't do 6215 // it yet. 6216 if (SemaRef.getLangOpts().CPlusPlus11 && !Record->isDependentType() && 6217 Record->getDefinition() && !Record->isBeingDefined() && 6218 R->getAs<FunctionProtoType>()->getExceptionSpecType() == EST_None) { 6219 SemaRef.AdjustDestructorExceptionSpec(Record, NewDD); 6220 } 6221 6222 // The Microsoft ABI requires that we perform the destructor body 6223 // checks (i.e. operator delete() lookup) at every declaration, as 6224 // any translation unit may need to emit a deleting destructor. 6225 if (SemaRef.Context.getTargetInfo().getCXXABI().isMicrosoft() && 6226 !Record->isDependentType() && Record->getDefinition() && 6227 !Record->isBeingDefined()) { 6228 SemaRef.CheckDestructor(NewDD); 6229 } 6230 6231 IsVirtualOkay = true; 6232 return NewDD; 6233 6234 } else { 6235 SemaRef.Diag(D.getIdentifierLoc(), diag::err_destructor_not_member); 6236 D.setInvalidType(); 6237 6238 // Create a FunctionDecl to satisfy the function definition parsing 6239 // code path. 6240 return FunctionDecl::Create(SemaRef.Context, DC, 6241 D.getLocStart(), 6242 D.getIdentifierLoc(), Name, R, TInfo, 6243 SC, isInline, 6244 /*hasPrototype=*/true, isConstexpr); 6245 } 6246 6247 } else if (Name.getNameKind() == DeclarationName::CXXConversionFunctionName) { 6248 if (!DC->isRecord()) { 6249 SemaRef.Diag(D.getIdentifierLoc(), 6250 diag::err_conv_function_not_member); 6251 return 0; 6252 } 6253 6254 SemaRef.CheckConversionDeclarator(D, R, SC); 6255 IsVirtualOkay = true; 6256 return CXXConversionDecl::Create(SemaRef.Context, cast<CXXRecordDecl>(DC), 6257 D.getLocStart(), NameInfo, 6258 R, TInfo, isInline, isExplicit, 6259 isConstexpr, SourceLocation()); 6260 6261 } else if (DC->isRecord()) { 6262 // If the name of the function is the same as the name of the record, 6263 // then this must be an invalid constructor that has a return type. 6264 // (The parser checks for a return type and makes the declarator a 6265 // constructor if it has no return type). 6266 if (Name.getAsIdentifierInfo() && 6267 Name.getAsIdentifierInfo() == cast<CXXRecordDecl>(DC)->getIdentifier()){ 6268 SemaRef.Diag(D.getIdentifierLoc(), diag::err_constructor_return_type) 6269 << SourceRange(D.getDeclSpec().getTypeSpecTypeLoc()) 6270 << SourceRange(D.getIdentifierLoc()); 6271 return 0; 6272 } 6273 6274 // This is a C++ method declaration. 6275 CXXMethodDecl *Ret = CXXMethodDecl::Create(SemaRef.Context, 6276 cast<CXXRecordDecl>(DC), 6277 D.getLocStart(), NameInfo, R, 6278 TInfo, SC, isInline, 6279 isConstexpr, SourceLocation()); 6280 IsVirtualOkay = !Ret->isStatic(); 6281 return Ret; 6282 } else { 6283 // Determine whether the function was written with a 6284 // prototype. This true when: 6285 // - we're in C++ (where every function has a prototype), 6286 return FunctionDecl::Create(SemaRef.Context, DC, 6287 D.getLocStart(), 6288 NameInfo, R, TInfo, SC, isInline, 6289 true/*HasPrototype*/, isConstexpr); 6290 } 6291} 6292 6293void Sema::checkVoidParamDecl(ParmVarDecl *Param) { 6294 // In C++, the empty parameter-type-list must be spelled "void"; a 6295 // typedef of void is not permitted. 6296 if (getLangOpts().CPlusPlus && 6297 Param->getType().getUnqualifiedType() != Context.VoidTy) { 6298 bool IsTypeAlias = false; 6299 if (const TypedefType *TT = Param->getType()->getAs<TypedefType>()) 6300 IsTypeAlias = isa<TypeAliasDecl>(TT->getDecl()); 6301 else if (const TemplateSpecializationType *TST = 6302 Param->getType()->getAs<TemplateSpecializationType>()) 6303 IsTypeAlias = TST->isTypeAlias(); 6304 Diag(Param->getLocation(), diag::err_param_typedef_of_void) 6305 << IsTypeAlias; 6306 } 6307} 6308 6309enum OpenCLParamType { 6310 ValidKernelParam, 6311 PtrPtrKernelParam, 6312 PtrKernelParam, 6313 InvalidKernelParam, 6314 RecordKernelParam 6315}; 6316 6317static OpenCLParamType getOpenCLKernelParameterType(QualType PT) { 6318 if (PT->isPointerType()) { 6319 QualType PointeeType = PT->getPointeeType(); 6320 return PointeeType->isPointerType() ? PtrPtrKernelParam : PtrKernelParam; 6321 } 6322 6323 // TODO: Forbid the other integer types (size_t, ptrdiff_t...) when they can 6324 // be used as builtin types. 6325 6326 if (PT->isImageType()) 6327 return PtrKernelParam; 6328 6329 if (PT->isBooleanType()) 6330 return InvalidKernelParam; 6331 6332 if (PT->isEventT()) 6333 return InvalidKernelParam; 6334 6335 if (PT->isHalfType()) 6336 return InvalidKernelParam; 6337 6338 if (PT->isRecordType()) 6339 return RecordKernelParam; 6340 6341 return ValidKernelParam; 6342} 6343 6344static void checkIsValidOpenCLKernelParameter( 6345 Sema &S, 6346 Declarator &D, 6347 ParmVarDecl *Param, 6348 llvm::SmallPtrSet<const Type *, 16> &ValidTypes) { 6349 QualType PT = Param->getType(); 6350 6351 // Cache the valid types we encounter to avoid rechecking structs that are 6352 // used again 6353 if (ValidTypes.count(PT.getTypePtr())) 6354 return; 6355 6356 switch (getOpenCLKernelParameterType(PT)) { 6357 case PtrPtrKernelParam: 6358 // OpenCL v1.2 s6.9.a: 6359 // A kernel function argument cannot be declared as a 6360 // pointer to a pointer type. 6361 S.Diag(Param->getLocation(), diag::err_opencl_ptrptr_kernel_param); 6362 D.setInvalidType(); 6363 return; 6364 6365 // OpenCL v1.2 s6.9.k: 6366 // Arguments to kernel functions in a program cannot be declared with the 6367 // built-in scalar types bool, half, size_t, ptrdiff_t, intptr_t, and 6368 // uintptr_t or a struct and/or union that contain fields declared to be 6369 // one of these built-in scalar types. 6370 6371 case InvalidKernelParam: 6372 // OpenCL v1.2 s6.8 n: 6373 // A kernel function argument cannot be declared 6374 // of event_t type. 6375 S.Diag(Param->getLocation(), diag::err_bad_kernel_param_type) << PT; 6376 D.setInvalidType(); 6377 return; 6378 6379 case PtrKernelParam: 6380 case ValidKernelParam: 6381 ValidTypes.insert(PT.getTypePtr()); 6382 return; 6383 6384 case RecordKernelParam: 6385 break; 6386 } 6387 6388 // Track nested structs we will inspect 6389 SmallVector<const Decl *, 4> VisitStack; 6390 6391 // Track where we are in the nested structs. Items will migrate from 6392 // VisitStack to HistoryStack as we do the DFS for bad field. 6393 SmallVector<const FieldDecl *, 4> HistoryStack; 6394 HistoryStack.push_back((const FieldDecl *) 0); 6395 6396 const RecordDecl *PD = PT->castAs<RecordType>()->getDecl(); 6397 VisitStack.push_back(PD); 6398 6399 assert(VisitStack.back() && "First decl null?"); 6400 6401 do { 6402 const Decl *Next = VisitStack.pop_back_val(); 6403 if (!Next) { 6404 assert(!HistoryStack.empty()); 6405 // Found a marker, we have gone up a level 6406 if (const FieldDecl *Hist = HistoryStack.pop_back_val()) 6407 ValidTypes.insert(Hist->getType().getTypePtr()); 6408 6409 continue; 6410 } 6411 6412 // Adds everything except the original parameter declaration (which is not a 6413 // field itself) to the history stack. 6414 const RecordDecl *RD; 6415 if (const FieldDecl *Field = dyn_cast<FieldDecl>(Next)) { 6416 HistoryStack.push_back(Field); 6417 RD = Field->getType()->castAs<RecordType>()->getDecl(); 6418 } else { 6419 RD = cast<RecordDecl>(Next); 6420 } 6421 6422 // Add a null marker so we know when we've gone back up a level 6423 VisitStack.push_back((const Decl *) 0); 6424 6425 for (RecordDecl::field_iterator I = RD->field_begin(), 6426 E = RD->field_end(); I != E; ++I) { 6427 const FieldDecl *FD = *I; 6428 QualType QT = FD->getType(); 6429 6430 if (ValidTypes.count(QT.getTypePtr())) 6431 continue; 6432 6433 OpenCLParamType ParamType = getOpenCLKernelParameterType(QT); 6434 if (ParamType == ValidKernelParam) 6435 continue; 6436 6437 if (ParamType == RecordKernelParam) { 6438 VisitStack.push_back(FD); 6439 continue; 6440 } 6441 6442 // OpenCL v1.2 s6.9.p: 6443 // Arguments to kernel functions that are declared to be a struct or union 6444 // do not allow OpenCL objects to be passed as elements of the struct or 6445 // union. 6446 if (ParamType == PtrKernelParam || ParamType == PtrPtrKernelParam) { 6447 S.Diag(Param->getLocation(), 6448 diag::err_record_with_pointers_kernel_param) 6449 << PT->isUnionType() 6450 << PT; 6451 } else { 6452 S.Diag(Param->getLocation(), diag::err_bad_kernel_param_type) << PT; 6453 } 6454 6455 S.Diag(PD->getLocation(), diag::note_within_field_of_type) 6456 << PD->getDeclName(); 6457 6458 // We have an error, now let's go back up through history and show where 6459 // the offending field came from 6460 for (ArrayRef<const FieldDecl *>::const_iterator I = HistoryStack.begin() + 1, 6461 E = HistoryStack.end(); I != E; ++I) { 6462 const FieldDecl *OuterField = *I; 6463 S.Diag(OuterField->getLocation(), diag::note_within_field_of_type) 6464 << OuterField->getType(); 6465 } 6466 6467 S.Diag(FD->getLocation(), diag::note_illegal_field_declared_here) 6468 << QT->isPointerType() 6469 << QT; 6470 D.setInvalidType(); 6471 return; 6472 } 6473 } while (!VisitStack.empty()); 6474} 6475 6476NamedDecl* 6477Sema::ActOnFunctionDeclarator(Scope *S, Declarator &D, DeclContext *DC, 6478 TypeSourceInfo *TInfo, LookupResult &Previous, 6479 MultiTemplateParamsArg TemplateParamLists, 6480 bool &AddToScope) { 6481 QualType R = TInfo->getType(); 6482 6483 assert(R.getTypePtr()->isFunctionType()); 6484 6485 // TODO: consider using NameInfo for diagnostic. 6486 DeclarationNameInfo NameInfo = GetNameForDeclarator(D); 6487 DeclarationName Name = NameInfo.getName(); 6488 FunctionDecl::StorageClass SC = getFunctionStorageClass(*this, D); 6489 6490 if (DeclSpec::TSCS TSCS = D.getDeclSpec().getThreadStorageClassSpec()) 6491 Diag(D.getDeclSpec().getThreadStorageClassSpecLoc(), 6492 diag::err_invalid_thread) 6493 << DeclSpec::getSpecifierName(TSCS); 6494 6495 if (D.isFirstDeclarationOfMember()) 6496 adjustMemberFunctionCC(R, D.isStaticMember()); 6497 6498 bool isFriend = false; 6499 FunctionTemplateDecl *FunctionTemplate = 0; 6500 bool isExplicitSpecialization = false; 6501 bool isFunctionTemplateSpecialization = false; 6502 6503 bool isDependentClassScopeExplicitSpecialization = false; 6504 bool HasExplicitTemplateArgs = false; 6505 TemplateArgumentListInfo TemplateArgs; 6506 6507 bool isVirtualOkay = false; 6508 6509 DeclContext *OriginalDC = DC; 6510 bool IsLocalExternDecl = adjustContextForLocalExternDecl(DC); 6511 6512 FunctionDecl *NewFD = CreateNewFunctionDecl(*this, D, DC, R, TInfo, SC, 6513 isVirtualOkay); 6514 if (!NewFD) return 0; 6515 6516 if (OriginalLexicalContext && OriginalLexicalContext->isObjCContainer()) 6517 NewFD->setTopLevelDeclInObjCContainer(); 6518 6519 // Set the lexical context. If this is a function-scope declaration, or has a 6520 // C++ scope specifier, or is the object of a friend declaration, the lexical 6521 // context will be different from the semantic context. 6522 NewFD->setLexicalDeclContext(CurContext); 6523 6524 if (IsLocalExternDecl) 6525 NewFD->setLocalExternDecl(); 6526 6527 if (getLangOpts().CPlusPlus) { 6528 bool isInline = D.getDeclSpec().isInlineSpecified(); 6529 bool isVirtual = D.getDeclSpec().isVirtualSpecified(); 6530 bool isExplicit = D.getDeclSpec().isExplicitSpecified(); 6531 bool isConstexpr = D.getDeclSpec().isConstexprSpecified(); 6532 isFriend = D.getDeclSpec().isFriendSpecified(); 6533 if (isFriend && !isInline && D.isFunctionDefinition()) { 6534 // C++ [class.friend]p5 6535 // A function can be defined in a friend declaration of a 6536 // class . . . . Such a function is implicitly inline. 6537 NewFD->setImplicitlyInline(); 6538 } 6539 6540 // If this is a method defined in an __interface, and is not a constructor 6541 // or an overloaded operator, then set the pure flag (isVirtual will already 6542 // return true). 6543 if (const CXXRecordDecl *Parent = 6544 dyn_cast<CXXRecordDecl>(NewFD->getDeclContext())) { 6545 if (Parent->isInterface() && cast<CXXMethodDecl>(NewFD)->isUserProvided()) 6546 NewFD->setPure(true); 6547 } 6548 6549 SetNestedNameSpecifier(NewFD, D); 6550 isExplicitSpecialization = false; 6551 isFunctionTemplateSpecialization = false; 6552 if (D.isInvalidType()) 6553 NewFD->setInvalidDecl(); 6554 6555 // Match up the template parameter lists with the scope specifier, then 6556 // determine whether we have a template or a template specialization. 6557 bool Invalid = false; 6558 if (TemplateParameterList *TemplateParams = 6559 MatchTemplateParametersToScopeSpecifier( 6560 D.getDeclSpec().getLocStart(), D.getIdentifierLoc(), 6561 D.getCXXScopeSpec(), TemplateParamLists, isFriend, 6562 isExplicitSpecialization, Invalid)) { 6563 if (TemplateParams->size() > 0) { 6564 // This is a function template 6565 6566 // Check that we can declare a template here. 6567 if (CheckTemplateDeclScope(S, TemplateParams)) 6568 return 0; 6569 6570 // A destructor cannot be a template. 6571 if (Name.getNameKind() == DeclarationName::CXXDestructorName) { 6572 Diag(NewFD->getLocation(), diag::err_destructor_template); 6573 return 0; 6574 } 6575 6576 // If we're adding a template to a dependent context, we may need to 6577 // rebuilding some of the types used within the template parameter list, 6578 // now that we know what the current instantiation is. 6579 if (DC->isDependentContext()) { 6580 ContextRAII SavedContext(*this, DC); 6581 if (RebuildTemplateParamsInCurrentInstantiation(TemplateParams)) 6582 Invalid = true; 6583 } 6584 6585 6586 FunctionTemplate = FunctionTemplateDecl::Create(Context, DC, 6587 NewFD->getLocation(), 6588 Name, TemplateParams, 6589 NewFD); 6590 FunctionTemplate->setLexicalDeclContext(CurContext); 6591 NewFD->setDescribedFunctionTemplate(FunctionTemplate); 6592 6593 // For source fidelity, store the other template param lists. 6594 if (TemplateParamLists.size() > 1) { 6595 NewFD->setTemplateParameterListsInfo(Context, 6596 TemplateParamLists.size() - 1, 6597 TemplateParamLists.data()); 6598 } 6599 } else { 6600 // This is a function template specialization. 6601 isFunctionTemplateSpecialization = true; 6602 // For source fidelity, store all the template param lists. 6603 NewFD->setTemplateParameterListsInfo(Context, 6604 TemplateParamLists.size(), 6605 TemplateParamLists.data()); 6606 6607 // C++0x [temp.expl.spec]p20 forbids "template<> friend void foo(int);". 6608 if (isFriend) { 6609 // We want to remove the "template<>", found here. 6610 SourceRange RemoveRange = TemplateParams->getSourceRange(); 6611 6612 // If we remove the template<> and the name is not a 6613 // template-id, we're actually silently creating a problem: 6614 // the friend declaration will refer to an untemplated decl, 6615 // and clearly the user wants a template specialization. So 6616 // we need to insert '<>' after the name. 6617 SourceLocation InsertLoc; 6618 if (D.getName().getKind() != UnqualifiedId::IK_TemplateId) { 6619 InsertLoc = D.getName().getSourceRange().getEnd(); 6620 InsertLoc = PP.getLocForEndOfToken(InsertLoc); 6621 } 6622 6623 Diag(D.getIdentifierLoc(), diag::err_template_spec_decl_friend) 6624 << Name << RemoveRange 6625 << FixItHint::CreateRemoval(RemoveRange) 6626 << FixItHint::CreateInsertion(InsertLoc, "<>"); 6627 } 6628 } 6629 } 6630 else { 6631 // All template param lists were matched against the scope specifier: 6632 // this is NOT (an explicit specialization of) a template. 6633 if (TemplateParamLists.size() > 0) 6634 // For source fidelity, store all the template param lists. 6635 NewFD->setTemplateParameterListsInfo(Context, 6636 TemplateParamLists.size(), 6637 TemplateParamLists.data()); 6638 } 6639 6640 if (Invalid) { 6641 NewFD->setInvalidDecl(); 6642 if (FunctionTemplate) 6643 FunctionTemplate->setInvalidDecl(); 6644 } 6645 6646 // C++ [dcl.fct.spec]p5: 6647 // The virtual specifier shall only be used in declarations of 6648 // nonstatic class member functions that appear within a 6649 // member-specification of a class declaration; see 10.3. 6650 // 6651 if (isVirtual && !NewFD->isInvalidDecl()) { 6652 if (!isVirtualOkay) { 6653 Diag(D.getDeclSpec().getVirtualSpecLoc(), 6654 diag::err_virtual_non_function); 6655 } else if (!CurContext->isRecord()) { 6656 // 'virtual' was specified outside of the class. 6657 Diag(D.getDeclSpec().getVirtualSpecLoc(), 6658 diag::err_virtual_out_of_class) 6659 << FixItHint::CreateRemoval(D.getDeclSpec().getVirtualSpecLoc()); 6660 } else if (NewFD->getDescribedFunctionTemplate()) { 6661 // C++ [temp.mem]p3: 6662 // A member function template shall not be virtual. 6663 Diag(D.getDeclSpec().getVirtualSpecLoc(), 6664 diag::err_virtual_member_function_template) 6665 << FixItHint::CreateRemoval(D.getDeclSpec().getVirtualSpecLoc()); 6666 } else { 6667 // Okay: Add virtual to the method. 6668 NewFD->setVirtualAsWritten(true); 6669 } 6670 6671 if (getLangOpts().CPlusPlus1y && 6672 NewFD->getResultType()->isUndeducedType()) 6673 Diag(D.getDeclSpec().getVirtualSpecLoc(), diag::err_auto_fn_virtual); 6674 } 6675 6676 if (getLangOpts().CPlusPlus1y && NewFD->isDependentContext() && 6677 NewFD->getResultType()->isUndeducedType()) { 6678 // If the function template is referenced directly (for instance, as a 6679 // member of the current instantiation), pretend it has a dependent type. 6680 // This is not really justified by the standard, but is the only sane 6681 // thing to do. 6682 const FunctionProtoType *FPT = 6683 NewFD->getType()->castAs<FunctionProtoType>(); 6684 QualType Result = SubstAutoType(FPT->getResultType(), 6685 Context.DependentTy); 6686 NewFD->setType(Context.getFunctionType(Result, FPT->getArgTypes(), 6687 FPT->getExtProtoInfo())); 6688 } 6689 6690 // C++ [dcl.fct.spec]p3: 6691 // The inline specifier shall not appear on a block scope function 6692 // declaration. 6693 if (isInline && !NewFD->isInvalidDecl()) { 6694 if (CurContext->isFunctionOrMethod()) { 6695 // 'inline' is not allowed on block scope function declaration. 6696 Diag(D.getDeclSpec().getInlineSpecLoc(), 6697 diag::err_inline_declaration_block_scope) << Name 6698 << FixItHint::CreateRemoval(D.getDeclSpec().getInlineSpecLoc()); 6699 } 6700 } 6701 6702 // C++ [dcl.fct.spec]p6: 6703 // The explicit specifier shall be used only in the declaration of a 6704 // constructor or conversion function within its class definition; 6705 // see 12.3.1 and 12.3.2. 6706 if (isExplicit && !NewFD->isInvalidDecl()) { 6707 if (!CurContext->isRecord()) { 6708 // 'explicit' was specified outside of the class. 6709 Diag(D.getDeclSpec().getExplicitSpecLoc(), 6710 diag::err_explicit_out_of_class) 6711 << FixItHint::CreateRemoval(D.getDeclSpec().getExplicitSpecLoc()); 6712 } else if (!isa<CXXConstructorDecl>(NewFD) && 6713 !isa<CXXConversionDecl>(NewFD)) { 6714 // 'explicit' was specified on a function that wasn't a constructor 6715 // or conversion function. 6716 Diag(D.getDeclSpec().getExplicitSpecLoc(), 6717 diag::err_explicit_non_ctor_or_conv_function) 6718 << FixItHint::CreateRemoval(D.getDeclSpec().getExplicitSpecLoc()); 6719 } 6720 } 6721 6722 if (isConstexpr) { 6723 // C++11 [dcl.constexpr]p2: constexpr functions and constexpr constructors 6724 // are implicitly inline. 6725 NewFD->setImplicitlyInline(); 6726 6727 // C++11 [dcl.constexpr]p3: functions declared constexpr are required to 6728 // be either constructors or to return a literal type. Therefore, 6729 // destructors cannot be declared constexpr. 6730 if (isa<CXXDestructorDecl>(NewFD)) 6731 Diag(D.getDeclSpec().getConstexprSpecLoc(), diag::err_constexpr_dtor); 6732 } 6733 6734 // If __module_private__ was specified, mark the function accordingly. 6735 if (D.getDeclSpec().isModulePrivateSpecified()) { 6736 if (isFunctionTemplateSpecialization) { 6737 SourceLocation ModulePrivateLoc 6738 = D.getDeclSpec().getModulePrivateSpecLoc(); 6739 Diag(ModulePrivateLoc, diag::err_module_private_specialization) 6740 << 0 6741 << FixItHint::CreateRemoval(ModulePrivateLoc); 6742 } else { 6743 NewFD->setModulePrivate(); 6744 if (FunctionTemplate) 6745 FunctionTemplate->setModulePrivate(); 6746 } 6747 } 6748 6749 if (isFriend) { 6750 if (FunctionTemplate) { 6751 FunctionTemplate->setObjectOfFriendDecl(); 6752 FunctionTemplate->setAccess(AS_public); 6753 } 6754 NewFD->setObjectOfFriendDecl(); 6755 NewFD->setAccess(AS_public); 6756 } 6757 6758 // If a function is defined as defaulted or deleted, mark it as such now. 6759 switch (D.getFunctionDefinitionKind()) { 6760 case FDK_Declaration: 6761 case FDK_Definition: 6762 break; 6763 6764 case FDK_Defaulted: 6765 NewFD->setDefaulted(); 6766 break; 6767 6768 case FDK_Deleted: 6769 NewFD->setDeletedAsWritten(); 6770 break; 6771 } 6772 6773 if (isa<CXXMethodDecl>(NewFD) && DC == CurContext && 6774 D.isFunctionDefinition()) { 6775 // C++ [class.mfct]p2: 6776 // A member function may be defined (8.4) in its class definition, in 6777 // which case it is an inline member function (7.1.2) 6778 NewFD->setImplicitlyInline(); 6779 } 6780 6781 if (SC == SC_Static && isa<CXXMethodDecl>(NewFD) && 6782 !CurContext->isRecord()) { 6783 // C++ [class.static]p1: 6784 // A data or function member of a class may be declared static 6785 // in a class definition, in which case it is a static member of 6786 // the class. 6787 6788 // Complain about the 'static' specifier if it's on an out-of-line 6789 // member function definition. 6790 Diag(D.getDeclSpec().getStorageClassSpecLoc(), 6791 diag::err_static_out_of_line) 6792 << FixItHint::CreateRemoval(D.getDeclSpec().getStorageClassSpecLoc()); 6793 } 6794 6795 // C++11 [except.spec]p15: 6796 // A deallocation function with no exception-specification is treated 6797 // as if it were specified with noexcept(true). 6798 const FunctionProtoType *FPT = R->getAs<FunctionProtoType>(); 6799 if ((Name.getCXXOverloadedOperator() == OO_Delete || 6800 Name.getCXXOverloadedOperator() == OO_Array_Delete) && 6801 getLangOpts().CPlusPlus11 && FPT && !FPT->hasExceptionSpec()) { 6802 FunctionProtoType::ExtProtoInfo EPI = FPT->getExtProtoInfo(); 6803 EPI.ExceptionSpecType = EST_BasicNoexcept; 6804 NewFD->setType(Context.getFunctionType(FPT->getResultType(), 6805 FPT->getArgTypes(), EPI)); 6806 } 6807 6808 // C++11 [replacement.functions]p3: 6809 // The program's definitions shall not be specified as inline. 6810 // 6811 // N.B. We diagnose declarations instead of definitions per LWG issue 2340. 6812 if (isInline && NewFD->isReplaceableGlobalAllocationFunction()) 6813 Diag(D.getDeclSpec().getInlineSpecLoc(), 6814 diag::err_operator_new_delete_declared_inline) 6815 << NewFD->getDeclName(); 6816 } 6817 6818 // Filter out previous declarations that don't match the scope. 6819 FilterLookupForScope(Previous, OriginalDC, S, shouldConsiderLinkage(NewFD), 6820 isExplicitSpecialization || 6821 isFunctionTemplateSpecialization); 6822 6823 // Handle GNU asm-label extension (encoded as an attribute). 6824 if (Expr *E = (Expr*) D.getAsmLabel()) { 6825 // The parser guarantees this is a string. 6826 StringLiteral *SE = cast<StringLiteral>(E); 6827 NewFD->addAttr(::new (Context) AsmLabelAttr(SE->getStrTokenLoc(0), Context, 6828 SE->getString())); 6829 } else if (!ExtnameUndeclaredIdentifiers.empty()) { 6830 llvm::DenseMap<IdentifierInfo*,AsmLabelAttr*>::iterator I = 6831 ExtnameUndeclaredIdentifiers.find(NewFD->getIdentifier()); 6832 if (I != ExtnameUndeclaredIdentifiers.end()) { 6833 NewFD->addAttr(I->second); 6834 ExtnameUndeclaredIdentifiers.erase(I); 6835 } 6836 } 6837 6838 // Copy the parameter declarations from the declarator D to the function 6839 // declaration NewFD, if they are available. First scavenge them into Params. 6840 SmallVector<ParmVarDecl*, 16> Params; 6841 if (D.isFunctionDeclarator()) { 6842 DeclaratorChunk::FunctionTypeInfo &FTI = D.getFunctionTypeInfo(); 6843 6844 // Check for C99 6.7.5.3p10 - foo(void) is a non-varargs 6845 // function that takes no arguments, not a function that takes a 6846 // single void argument. 6847 // We let through "const void" here because Sema::GetTypeForDeclarator 6848 // already checks for that case. 6849 if (FTI.NumArgs == 1 && !FTI.isVariadic && FTI.ArgInfo[0].Ident == 0 && 6850 FTI.ArgInfo[0].Param && 6851 cast<ParmVarDecl>(FTI.ArgInfo[0].Param)->getType()->isVoidType()) { 6852 // Empty arg list, don't push any params. 6853 checkVoidParamDecl(cast<ParmVarDecl>(FTI.ArgInfo[0].Param)); 6854 } else if (FTI.NumArgs > 0 && FTI.ArgInfo[0].Param != 0) { 6855 for (unsigned i = 0, e = FTI.NumArgs; i != e; ++i) { 6856 ParmVarDecl *Param = cast<ParmVarDecl>(FTI.ArgInfo[i].Param); 6857 assert(Param->getDeclContext() != NewFD && "Was set before ?"); 6858 Param->setDeclContext(NewFD); 6859 Params.push_back(Param); 6860 6861 if (Param->isInvalidDecl()) 6862 NewFD->setInvalidDecl(); 6863 } 6864 } 6865 6866 } else if (const FunctionProtoType *FT = R->getAs<FunctionProtoType>()) { 6867 // When we're declaring a function with a typedef, typeof, etc as in the 6868 // following example, we'll need to synthesize (unnamed) 6869 // parameters for use in the declaration. 6870 // 6871 // @code 6872 // typedef void fn(int); 6873 // fn f; 6874 // @endcode 6875 6876 // Synthesize a parameter for each argument type. 6877 for (FunctionProtoType::arg_type_iterator AI = FT->arg_type_begin(), 6878 AE = FT->arg_type_end(); AI != AE; ++AI) { 6879 ParmVarDecl *Param = 6880 BuildParmVarDeclForTypedef(NewFD, D.getIdentifierLoc(), *AI); 6881 Param->setScopeInfo(0, Params.size()); 6882 Params.push_back(Param); 6883 } 6884 } else { 6885 assert(R->isFunctionNoProtoType() && NewFD->getNumParams() == 0 && 6886 "Should not need args for typedef of non-prototype fn"); 6887 } 6888 6889 // Finally, we know we have the right number of parameters, install them. 6890 NewFD->setParams(Params); 6891 6892 // Find all anonymous symbols defined during the declaration of this function 6893 // and add to NewFD. This lets us track decls such 'enum Y' in: 6894 // 6895 // void f(enum Y {AA} x) {} 6896 // 6897 // which would otherwise incorrectly end up in the translation unit scope. 6898 NewFD->setDeclsInPrototypeScope(DeclsInPrototypeScope); 6899 DeclsInPrototypeScope.clear(); 6900 6901 if (D.getDeclSpec().isNoreturnSpecified()) 6902 NewFD->addAttr( 6903 ::new(Context) C11NoReturnAttr(D.getDeclSpec().getNoreturnSpecLoc(), 6904 Context)); 6905 6906 // Functions returning a variably modified type violate C99 6.7.5.2p2 6907 // because all functions have linkage. 6908 if (!NewFD->isInvalidDecl() && 6909 NewFD->getResultType()->isVariablyModifiedType()) { 6910 Diag(NewFD->getLocation(), diag::err_vm_func_decl); 6911 NewFD->setInvalidDecl(); 6912 } 6913 6914 // Handle attributes. 6915 ProcessDeclAttributes(S, NewFD, D); 6916 6917 QualType RetType = NewFD->getResultType(); 6918 const CXXRecordDecl *Ret = RetType->isRecordType() ? 6919 RetType->getAsCXXRecordDecl() : RetType->getPointeeCXXRecordDecl(); 6920 if (!NewFD->isInvalidDecl() && !NewFD->hasAttr<WarnUnusedResultAttr>() && 6921 Ret && Ret->hasAttr<WarnUnusedResultAttr>()) { 6922 const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(NewFD); 6923 // Attach the attribute to the new decl. Don't apply the attribute if it 6924 // returns an instance of the class (e.g. assignment operators). 6925 if (!MD || MD->getParent() != Ret) { 6926 NewFD->addAttr(new (Context) WarnUnusedResultAttr(SourceRange(), 6927 Context)); 6928 } 6929 } 6930 6931 if (!getLangOpts().CPlusPlus) { 6932 // Perform semantic checking on the function declaration. 6933 bool isExplicitSpecialization=false; 6934 if (!NewFD->isInvalidDecl() && NewFD->isMain()) 6935 CheckMain(NewFD, D.getDeclSpec()); 6936 6937 if (!NewFD->isInvalidDecl() && NewFD->isMSVCRTEntryPoint()) 6938 CheckMSVCRTEntryPoint(NewFD); 6939 6940 if (!NewFD->isInvalidDecl()) 6941 D.setRedeclaration(CheckFunctionDeclaration(S, NewFD, Previous, 6942 isExplicitSpecialization)); 6943 else if (!Previous.empty()) 6944 // Make graceful recovery from an invalid redeclaration. 6945 D.setRedeclaration(true); 6946 assert((NewFD->isInvalidDecl() || !D.isRedeclaration() || 6947 Previous.getResultKind() != LookupResult::FoundOverloaded) && 6948 "previous declaration set still overloaded"); 6949 } else { 6950 // If the declarator is a template-id, translate the parser's template 6951 // argument list into our AST format. 6952 if (D.getName().getKind() == UnqualifiedId::IK_TemplateId) { 6953 TemplateIdAnnotation *TemplateId = D.getName().TemplateId; 6954 TemplateArgs.setLAngleLoc(TemplateId->LAngleLoc); 6955 TemplateArgs.setRAngleLoc(TemplateId->RAngleLoc); 6956 ASTTemplateArgsPtr TemplateArgsPtr(TemplateId->getTemplateArgs(), 6957 TemplateId->NumArgs); 6958 translateTemplateArguments(TemplateArgsPtr, 6959 TemplateArgs); 6960 6961 HasExplicitTemplateArgs = true; 6962 6963 if (NewFD->isInvalidDecl()) { 6964 HasExplicitTemplateArgs = false; 6965 } else if (FunctionTemplate) { 6966 // Function template with explicit template arguments. 6967 Diag(D.getIdentifierLoc(), diag::err_function_template_partial_spec) 6968 << SourceRange(TemplateId->LAngleLoc, TemplateId->RAngleLoc); 6969 6970 HasExplicitTemplateArgs = false; 6971 } else if (!isFunctionTemplateSpecialization && 6972 !D.getDeclSpec().isFriendSpecified()) { 6973 // We have encountered something that the user meant to be a 6974 // specialization (because it has explicitly-specified template 6975 // arguments) but that was not introduced with a "template<>" (or had 6976 // too few of them). 6977 // FIXME: Differentiate between attempts for explicit instantiations 6978 // (starting with "template") and the rest. 6979 Diag(D.getIdentifierLoc(), diag::err_template_spec_needs_header) 6980 << SourceRange(TemplateId->LAngleLoc, TemplateId->RAngleLoc) 6981 << FixItHint::CreateInsertion( 6982 D.getDeclSpec().getLocStart(), 6983 "template<> "); 6984 isFunctionTemplateSpecialization = true; 6985 } else { 6986 // "friend void foo<>(int);" is an implicit specialization decl. 6987 isFunctionTemplateSpecialization = true; 6988 } 6989 } else if (isFriend && isFunctionTemplateSpecialization) { 6990 // This combination is only possible in a recovery case; the user 6991 // wrote something like: 6992 // template <> friend void foo(int); 6993 // which we're recovering from as if the user had written: 6994 // friend void foo<>(int); 6995 // Go ahead and fake up a template id. 6996 HasExplicitTemplateArgs = true; 6997 TemplateArgs.setLAngleLoc(D.getIdentifierLoc()); 6998 TemplateArgs.setRAngleLoc(D.getIdentifierLoc()); 6999 } 7000 7001 // If it's a friend (and only if it's a friend), it's possible 7002 // that either the specialized function type or the specialized 7003 // template is dependent, and therefore matching will fail. In 7004 // this case, don't check the specialization yet. 7005 bool InstantiationDependent = false; 7006 if (isFunctionTemplateSpecialization && isFriend && 7007 (NewFD->getType()->isDependentType() || DC->isDependentContext() || 7008 TemplateSpecializationType::anyDependentTemplateArguments( 7009 TemplateArgs.getArgumentArray(), TemplateArgs.size(), 7010 InstantiationDependent))) { 7011 assert(HasExplicitTemplateArgs && 7012 "friend function specialization without template args"); 7013 if (CheckDependentFunctionTemplateSpecialization(NewFD, TemplateArgs, 7014 Previous)) 7015 NewFD->setInvalidDecl(); 7016 } else if (isFunctionTemplateSpecialization) { 7017 if (CurContext->isDependentContext() && CurContext->isRecord() 7018 && !isFriend) { 7019 isDependentClassScopeExplicitSpecialization = true; 7020 Diag(NewFD->getLocation(), getLangOpts().MicrosoftExt ? 7021 diag::ext_function_specialization_in_class : 7022 diag::err_function_specialization_in_class) 7023 << NewFD->getDeclName(); 7024 } else if (CheckFunctionTemplateSpecialization(NewFD, 7025 (HasExplicitTemplateArgs ? &TemplateArgs : 0), 7026 Previous)) 7027 NewFD->setInvalidDecl(); 7028 7029 // C++ [dcl.stc]p1: 7030 // A storage-class-specifier shall not be specified in an explicit 7031 // specialization (14.7.3) 7032 FunctionTemplateSpecializationInfo *Info = 7033 NewFD->getTemplateSpecializationInfo(); 7034 if (Info && SC != SC_None) { 7035 if (SC != Info->getTemplate()->getTemplatedDecl()->getStorageClass()) 7036 Diag(NewFD->getLocation(), 7037 diag::err_explicit_specialization_inconsistent_storage_class) 7038 << SC 7039 << FixItHint::CreateRemoval( 7040 D.getDeclSpec().getStorageClassSpecLoc()); 7041 7042 else 7043 Diag(NewFD->getLocation(), 7044 diag::ext_explicit_specialization_storage_class) 7045 << FixItHint::CreateRemoval( 7046 D.getDeclSpec().getStorageClassSpecLoc()); 7047 } 7048 7049 } else if (isExplicitSpecialization && isa<CXXMethodDecl>(NewFD)) { 7050 if (CheckMemberSpecialization(NewFD, Previous)) 7051 NewFD->setInvalidDecl(); 7052 } 7053 7054 // Perform semantic checking on the function declaration. 7055 if (!isDependentClassScopeExplicitSpecialization) { 7056 if (!NewFD->isInvalidDecl() && NewFD->isMain()) 7057 CheckMain(NewFD, D.getDeclSpec()); 7058 7059 if (!NewFD->isInvalidDecl() && NewFD->isMSVCRTEntryPoint()) 7060 CheckMSVCRTEntryPoint(NewFD); 7061 7062 if (NewFD->isInvalidDecl()) { 7063 // If this is a class member, mark the class invalid immediately. 7064 // This avoids some consistency errors later. 7065 if (CXXMethodDecl* methodDecl = dyn_cast<CXXMethodDecl>(NewFD)) 7066 methodDecl->getParent()->setInvalidDecl(); 7067 } else 7068 D.setRedeclaration(CheckFunctionDeclaration(S, NewFD, Previous, 7069 isExplicitSpecialization)); 7070 } 7071 7072 assert((NewFD->isInvalidDecl() || !D.isRedeclaration() || 7073 Previous.getResultKind() != LookupResult::FoundOverloaded) && 7074 "previous declaration set still overloaded"); 7075 7076 NamedDecl *PrincipalDecl = (FunctionTemplate 7077 ? cast<NamedDecl>(FunctionTemplate) 7078 : NewFD); 7079 7080 if (isFriend && D.isRedeclaration()) { 7081 AccessSpecifier Access = AS_public; 7082 if (!NewFD->isInvalidDecl()) 7083 Access = NewFD->getPreviousDecl()->getAccess(); 7084 7085 NewFD->setAccess(Access); 7086 if (FunctionTemplate) FunctionTemplate->setAccess(Access); 7087 } 7088 7089 if (NewFD->isOverloadedOperator() && !DC->isRecord() && 7090 PrincipalDecl->isInIdentifierNamespace(Decl::IDNS_Ordinary)) 7091 PrincipalDecl->setNonMemberOperator(); 7092 7093 // If we have a function template, check the template parameter 7094 // list. This will check and merge default template arguments. 7095 if (FunctionTemplate) { 7096 FunctionTemplateDecl *PrevTemplate = 7097 FunctionTemplate->getPreviousDecl(); 7098 CheckTemplateParameterList(FunctionTemplate->getTemplateParameters(), 7099 PrevTemplate ? PrevTemplate->getTemplateParameters() : 0, 7100 D.getDeclSpec().isFriendSpecified() 7101 ? (D.isFunctionDefinition() 7102 ? TPC_FriendFunctionTemplateDefinition 7103 : TPC_FriendFunctionTemplate) 7104 : (D.getCXXScopeSpec().isSet() && 7105 DC && DC->isRecord() && 7106 DC->isDependentContext()) 7107 ? TPC_ClassTemplateMember 7108 : TPC_FunctionTemplate); 7109 } 7110 7111 if (NewFD->isInvalidDecl()) { 7112 // Ignore all the rest of this. 7113 } else if (!D.isRedeclaration()) { 7114 struct ActOnFDArgs ExtraArgs = { S, D, TemplateParamLists, 7115 AddToScope }; 7116 // Fake up an access specifier if it's supposed to be a class member. 7117 if (isa<CXXRecordDecl>(NewFD->getDeclContext())) 7118 NewFD->setAccess(AS_public); 7119 7120 // Qualified decls generally require a previous declaration. 7121 if (D.getCXXScopeSpec().isSet()) { 7122 // ...with the major exception of templated-scope or 7123 // dependent-scope friend declarations. 7124 7125 // TODO: we currently also suppress this check in dependent 7126 // contexts because (1) the parameter depth will be off when 7127 // matching friend templates and (2) we might actually be 7128 // selecting a friend based on a dependent factor. But there 7129 // are situations where these conditions don't apply and we 7130 // can actually do this check immediately. 7131 if (isFriend && 7132 (TemplateParamLists.size() || 7133 D.getCXXScopeSpec().getScopeRep()->isDependent() || 7134 CurContext->isDependentContext())) { 7135 // ignore these 7136 } else { 7137 // The user tried to provide an out-of-line definition for a 7138 // function that is a member of a class or namespace, but there 7139 // was no such member function declared (C++ [class.mfct]p2, 7140 // C++ [namespace.memdef]p2). For example: 7141 // 7142 // class X { 7143 // void f() const; 7144 // }; 7145 // 7146 // void X::f() { } // ill-formed 7147 // 7148 // Complain about this problem, and attempt to suggest close 7149 // matches (e.g., those that differ only in cv-qualifiers and 7150 // whether the parameter types are references). 7151 7152 if (NamedDecl *Result = DiagnoseInvalidRedeclaration( 7153 *this, Previous, NewFD, ExtraArgs, false, 0)) { 7154 AddToScope = ExtraArgs.AddToScope; 7155 return Result; 7156 } 7157 } 7158 7159 // Unqualified local friend declarations are required to resolve 7160 // to something. 7161 } else if (isFriend && cast<CXXRecordDecl>(CurContext)->isLocalClass()) { 7162 if (NamedDecl *Result = DiagnoseInvalidRedeclaration( 7163 *this, Previous, NewFD, ExtraArgs, true, S)) { 7164 AddToScope = ExtraArgs.AddToScope; 7165 return Result; 7166 } 7167 } 7168 7169 } else if (!D.isFunctionDefinition() && D.getCXXScopeSpec().isSet() && 7170 !isFriend && !isFunctionTemplateSpecialization && 7171 !isExplicitSpecialization) { 7172 // An out-of-line member function declaration must also be a 7173 // definition (C++ [dcl.meaning]p1). 7174 // Note that this is not the case for explicit specializations of 7175 // function templates or member functions of class templates, per 7176 // C++ [temp.expl.spec]p2. We also allow these declarations as an 7177 // extension for compatibility with old SWIG code which likes to 7178 // generate them. 7179 Diag(NewFD->getLocation(), diag::ext_out_of_line_declaration) 7180 << D.getCXXScopeSpec().getRange(); 7181 } 7182 } 7183 7184 ProcessPragmaWeak(S, NewFD); 7185 checkAttributesAfterMerging(*this, *NewFD); 7186 7187 AddKnownFunctionAttributes(NewFD); 7188 7189 if (NewFD->hasAttr<OverloadableAttr>() && 7190 !NewFD->getType()->getAs<FunctionProtoType>()) { 7191 Diag(NewFD->getLocation(), 7192 diag::err_attribute_overloadable_no_prototype) 7193 << NewFD; 7194 7195 // Turn this into a variadic function with no parameters. 7196 const FunctionType *FT = NewFD->getType()->getAs<FunctionType>(); 7197 FunctionProtoType::ExtProtoInfo EPI( 7198 Context.getDefaultCallingConvention(true, false)); 7199 EPI.Variadic = true; 7200 EPI.ExtInfo = FT->getExtInfo(); 7201 7202 QualType R = Context.getFunctionType(FT->getResultType(), None, EPI); 7203 NewFD->setType(R); 7204 } 7205 7206 // If there's a #pragma GCC visibility in scope, and this isn't a class 7207 // member, set the visibility of this function. 7208 if (!DC->isRecord() && NewFD->isExternallyVisible()) 7209 AddPushedVisibilityAttribute(NewFD); 7210 7211 // If there's a #pragma clang arc_cf_code_audited in scope, consider 7212 // marking the function. 7213 AddCFAuditedAttribute(NewFD); 7214 7215 // If this is the first declaration of an extern C variable, update 7216 // the map of such variables. 7217 if (NewFD->isFirstDecl() && !NewFD->isInvalidDecl() && 7218 isIncompleteDeclExternC(*this, NewFD)) 7219 RegisterLocallyScopedExternCDecl(NewFD, S); 7220 7221 // Set this FunctionDecl's range up to the right paren. 7222 NewFD->setRangeEnd(D.getSourceRange().getEnd()); 7223 7224 if (getLangOpts().CPlusPlus) { 7225 if (FunctionTemplate) { 7226 if (NewFD->isInvalidDecl()) 7227 FunctionTemplate->setInvalidDecl(); 7228 return FunctionTemplate; 7229 } 7230 } 7231 7232 if (NewFD->hasAttr<OpenCLKernelAttr>()) { 7233 // OpenCL v1.2 s6.8 static is invalid for kernel functions. 7234 if ((getLangOpts().OpenCLVersion >= 120) 7235 && (SC == SC_Static)) { 7236 Diag(D.getIdentifierLoc(), diag::err_static_kernel); 7237 D.setInvalidType(); 7238 } 7239 7240 // OpenCL v1.2, s6.9 -- Kernels can only have return type void. 7241 if (!NewFD->getResultType()->isVoidType()) { 7242 Diag(D.getIdentifierLoc(), 7243 diag::err_expected_kernel_void_return_type); 7244 D.setInvalidType(); 7245 } 7246 7247 llvm::SmallPtrSet<const Type *, 16> ValidTypes; 7248 for (FunctionDecl::param_iterator PI = NewFD->param_begin(), 7249 PE = NewFD->param_end(); PI != PE; ++PI) { 7250 ParmVarDecl *Param = *PI; 7251 checkIsValidOpenCLKernelParameter(*this, D, Param, ValidTypes); 7252 } 7253 } 7254 7255 MarkUnusedFileScopedDecl(NewFD); 7256 7257 if (getLangOpts().CUDA) 7258 if (IdentifierInfo *II = NewFD->getIdentifier()) 7259 if (!NewFD->isInvalidDecl() && 7260 NewFD->getDeclContext()->getRedeclContext()->isTranslationUnit()) { 7261 if (II->isStr("cudaConfigureCall")) { 7262 if (!R->getAs<FunctionType>()->getResultType()->isScalarType()) 7263 Diag(NewFD->getLocation(), diag::err_config_scalar_return); 7264 7265 Context.setcudaConfigureCallDecl(NewFD); 7266 } 7267 } 7268 7269 // Here we have an function template explicit specialization at class scope. 7270 // The actually specialization will be postponed to template instatiation 7271 // time via the ClassScopeFunctionSpecializationDecl node. 7272 if (isDependentClassScopeExplicitSpecialization) { 7273 ClassScopeFunctionSpecializationDecl *NewSpec = 7274 ClassScopeFunctionSpecializationDecl::Create( 7275 Context, CurContext, SourceLocation(), 7276 cast<CXXMethodDecl>(NewFD), 7277 HasExplicitTemplateArgs, TemplateArgs); 7278 CurContext->addDecl(NewSpec); 7279 AddToScope = false; 7280 } 7281 7282 return NewFD; 7283} 7284 7285/// \brief Perform semantic checking of a new function declaration. 7286/// 7287/// Performs semantic analysis of the new function declaration 7288/// NewFD. This routine performs all semantic checking that does not 7289/// require the actual declarator involved in the declaration, and is 7290/// used both for the declaration of functions as they are parsed 7291/// (called via ActOnDeclarator) and for the declaration of functions 7292/// that have been instantiated via C++ template instantiation (called 7293/// via InstantiateDecl). 7294/// 7295/// \param IsExplicitSpecialization whether this new function declaration is 7296/// an explicit specialization of the previous declaration. 7297/// 7298/// This sets NewFD->isInvalidDecl() to true if there was an error. 7299/// 7300/// \returns true if the function declaration is a redeclaration. 7301bool Sema::CheckFunctionDeclaration(Scope *S, FunctionDecl *NewFD, 7302 LookupResult &Previous, 7303 bool IsExplicitSpecialization) { 7304 assert(!NewFD->getResultType()->isVariablyModifiedType() 7305 && "Variably modified return types are not handled here"); 7306 7307 // Determine whether the type of this function should be merged with 7308 // a previous visible declaration. This never happens for functions in C++, 7309 // and always happens in C if the previous declaration was visible. 7310 bool MergeTypeWithPrevious = !getLangOpts().CPlusPlus && 7311 !Previous.isShadowed(); 7312 7313 // Filter out any non-conflicting previous declarations. 7314 filterNonConflictingPreviousDecls(Context, NewFD, Previous); 7315 7316 bool Redeclaration = false; 7317 NamedDecl *OldDecl = 0; 7318 7319 // Merge or overload the declaration with an existing declaration of 7320 // the same name, if appropriate. 7321 if (!Previous.empty()) { 7322 // Determine whether NewFD is an overload of PrevDecl or 7323 // a declaration that requires merging. If it's an overload, 7324 // there's no more work to do here; we'll just add the new 7325 // function to the scope. 7326 if (!AllowOverloadingOfFunction(Previous, Context)) { 7327 NamedDecl *Candidate = Previous.getFoundDecl(); 7328 if (shouldLinkPossiblyHiddenDecl(Candidate, NewFD)) { 7329 Redeclaration = true; 7330 OldDecl = Candidate; 7331 } 7332 } else { 7333 switch (CheckOverload(S, NewFD, Previous, OldDecl, 7334 /*NewIsUsingDecl*/ false)) { 7335 case Ovl_Match: 7336 Redeclaration = true; 7337 break; 7338 7339 case Ovl_NonFunction: 7340 Redeclaration = true; 7341 break; 7342 7343 case Ovl_Overload: 7344 Redeclaration = false; 7345 break; 7346 } 7347 7348 if (!getLangOpts().CPlusPlus && !NewFD->hasAttr<OverloadableAttr>()) { 7349 // If a function name is overloadable in C, then every function 7350 // with that name must be marked "overloadable". 7351 Diag(NewFD->getLocation(), diag::err_attribute_overloadable_missing) 7352 << Redeclaration << NewFD; 7353 NamedDecl *OverloadedDecl = 0; 7354 if (Redeclaration) 7355 OverloadedDecl = OldDecl; 7356 else if (!Previous.empty()) 7357 OverloadedDecl = Previous.getRepresentativeDecl(); 7358 if (OverloadedDecl) 7359 Diag(OverloadedDecl->getLocation(), 7360 diag::note_attribute_overloadable_prev_overload); 7361 NewFD->addAttr(::new (Context) OverloadableAttr(SourceLocation(), 7362 Context)); 7363 } 7364 } 7365 } 7366 7367 // Check for a previous extern "C" declaration with this name. 7368 if (!Redeclaration && 7369 checkForConflictWithNonVisibleExternC(*this, NewFD, Previous)) { 7370 filterNonConflictingPreviousDecls(Context, NewFD, Previous); 7371 if (!Previous.empty()) { 7372 // This is an extern "C" declaration with the same name as a previous 7373 // declaration, and thus redeclares that entity... 7374 Redeclaration = true; 7375 OldDecl = Previous.getFoundDecl(); 7376 MergeTypeWithPrevious = false; 7377 7378 // ... except in the presence of __attribute__((overloadable)). 7379 if (OldDecl->hasAttr<OverloadableAttr>()) { 7380 if (!getLangOpts().CPlusPlus && !NewFD->hasAttr<OverloadableAttr>()) { 7381 Diag(NewFD->getLocation(), diag::err_attribute_overloadable_missing) 7382 << Redeclaration << NewFD; 7383 Diag(Previous.getFoundDecl()->getLocation(), 7384 diag::note_attribute_overloadable_prev_overload); 7385 NewFD->addAttr(::new (Context) OverloadableAttr(SourceLocation(), 7386 Context)); 7387 } 7388 if (IsOverload(NewFD, cast<FunctionDecl>(OldDecl), false)) { 7389 Redeclaration = false; 7390 OldDecl = 0; 7391 } 7392 } 7393 } 7394 } 7395 7396 // C++11 [dcl.constexpr]p8: 7397 // A constexpr specifier for a non-static member function that is not 7398 // a constructor declares that member function to be const. 7399 // 7400 // This needs to be delayed until we know whether this is an out-of-line 7401 // definition of a static member function. 7402 // 7403 // This rule is not present in C++1y, so we produce a backwards 7404 // compatibility warning whenever it happens in C++11. 7405 CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(NewFD); 7406 if (!getLangOpts().CPlusPlus1y && MD && MD->isConstexpr() && 7407 !MD->isStatic() && !isa<CXXConstructorDecl>(MD) && 7408 (MD->getTypeQualifiers() & Qualifiers::Const) == 0) { 7409 CXXMethodDecl *OldMD = dyn_cast_or_null<CXXMethodDecl>(OldDecl); 7410 if (FunctionTemplateDecl *OldTD = 7411 dyn_cast_or_null<FunctionTemplateDecl>(OldDecl)) 7412 OldMD = dyn_cast<CXXMethodDecl>(OldTD->getTemplatedDecl()); 7413 if (!OldMD || !OldMD->isStatic()) { 7414 const FunctionProtoType *FPT = 7415 MD->getType()->castAs<FunctionProtoType>(); 7416 FunctionProtoType::ExtProtoInfo EPI = FPT->getExtProtoInfo(); 7417 EPI.TypeQuals |= Qualifiers::Const; 7418 MD->setType(Context.getFunctionType(FPT->getResultType(), 7419 FPT->getArgTypes(), EPI)); 7420 7421 // Warn that we did this, if we're not performing template instantiation. 7422 // In that case, we'll have warned already when the template was defined. 7423 if (ActiveTemplateInstantiations.empty()) { 7424 SourceLocation AddConstLoc; 7425 if (FunctionTypeLoc FTL = MD->getTypeSourceInfo()->getTypeLoc() 7426 .IgnoreParens().getAs<FunctionTypeLoc>()) 7427 AddConstLoc = PP.getLocForEndOfToken(FTL.getRParenLoc()); 7428 7429 Diag(MD->getLocation(), diag::warn_cxx1y_compat_constexpr_not_const) 7430 << FixItHint::CreateInsertion(AddConstLoc, " const"); 7431 } 7432 } 7433 } 7434 7435 if (Redeclaration) { 7436 // NewFD and OldDecl represent declarations that need to be 7437 // merged. 7438 if (MergeFunctionDecl(NewFD, OldDecl, S, MergeTypeWithPrevious)) { 7439 NewFD->setInvalidDecl(); 7440 return Redeclaration; 7441 } 7442 7443 Previous.clear(); 7444 Previous.addDecl(OldDecl); 7445 7446 if (FunctionTemplateDecl *OldTemplateDecl 7447 = dyn_cast<FunctionTemplateDecl>(OldDecl)) { 7448 NewFD->setPreviousDeclaration(OldTemplateDecl->getTemplatedDecl()); 7449 FunctionTemplateDecl *NewTemplateDecl 7450 = NewFD->getDescribedFunctionTemplate(); 7451 assert(NewTemplateDecl && "Template/non-template mismatch"); 7452 if (CXXMethodDecl *Method 7453 = dyn_cast<CXXMethodDecl>(NewTemplateDecl->getTemplatedDecl())) { 7454 Method->setAccess(OldTemplateDecl->getAccess()); 7455 NewTemplateDecl->setAccess(OldTemplateDecl->getAccess()); 7456 } 7457 7458 // If this is an explicit specialization of a member that is a function 7459 // template, mark it as a member specialization. 7460 if (IsExplicitSpecialization && 7461 NewTemplateDecl->getInstantiatedFromMemberTemplate()) { 7462 NewTemplateDecl->setMemberSpecialization(); 7463 assert(OldTemplateDecl->isMemberSpecialization()); 7464 } 7465 7466 } else { 7467 // This needs to happen first so that 'inline' propagates. 7468 NewFD->setPreviousDeclaration(cast<FunctionDecl>(OldDecl)); 7469 7470 if (isa<CXXMethodDecl>(NewFD)) { 7471 // A valid redeclaration of a C++ method must be out-of-line, 7472 // but (unfortunately) it's not necessarily a definition 7473 // because of templates, which means that the previous 7474 // declaration is not necessarily from the class definition. 7475 7476 // For just setting the access, that doesn't matter. 7477 CXXMethodDecl *oldMethod = cast<CXXMethodDecl>(OldDecl); 7478 NewFD->setAccess(oldMethod->getAccess()); 7479 7480 // Update the key-function state if necessary for this ABI. 7481 if (NewFD->isInlined() && 7482 !Context.getTargetInfo().getCXXABI().canKeyFunctionBeInline()) { 7483 // setNonKeyFunction needs to work with the original 7484 // declaration from the class definition, and isVirtual() is 7485 // just faster in that case, so map back to that now. 7486 oldMethod = cast<CXXMethodDecl>(oldMethod->getFirstDecl()); 7487 if (oldMethod->isVirtual()) { 7488 Context.setNonKeyFunction(oldMethod); 7489 } 7490 } 7491 } 7492 } 7493 } 7494 7495 // Semantic checking for this function declaration (in isolation). 7496 if (getLangOpts().CPlusPlus) { 7497 // C++-specific checks. 7498 if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(NewFD)) { 7499 CheckConstructor(Constructor); 7500 } else if (CXXDestructorDecl *Destructor = 7501 dyn_cast<CXXDestructorDecl>(NewFD)) { 7502 CXXRecordDecl *Record = Destructor->getParent(); 7503 QualType ClassType = Context.getTypeDeclType(Record); 7504 7505 // FIXME: Shouldn't we be able to perform this check even when the class 7506 // type is dependent? Both gcc and edg can handle that. 7507 if (!ClassType->isDependentType()) { 7508 DeclarationName Name 7509 = Context.DeclarationNames.getCXXDestructorName( 7510 Context.getCanonicalType(ClassType)); 7511 if (NewFD->getDeclName() != Name) { 7512 Diag(NewFD->getLocation(), diag::err_destructor_name); 7513 NewFD->setInvalidDecl(); 7514 return Redeclaration; 7515 } 7516 } 7517 } else if (CXXConversionDecl *Conversion 7518 = dyn_cast<CXXConversionDecl>(NewFD)) { 7519 ActOnConversionDeclarator(Conversion); 7520 } 7521 7522 // Find any virtual functions that this function overrides. 7523 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(NewFD)) { 7524 if (!Method->isFunctionTemplateSpecialization() && 7525 !Method->getDescribedFunctionTemplate() && 7526 Method->isCanonicalDecl()) { 7527 if (AddOverriddenMethods(Method->getParent(), Method)) { 7528 // If the function was marked as "static", we have a problem. 7529 if (NewFD->getStorageClass() == SC_Static) { 7530 ReportOverrides(*this, diag::err_static_overrides_virtual, Method); 7531 } 7532 } 7533 } 7534 7535 if (Method->isStatic()) 7536 checkThisInStaticMemberFunctionType(Method); 7537 } 7538 7539 // Extra checking for C++ overloaded operators (C++ [over.oper]). 7540 if (NewFD->isOverloadedOperator() && 7541 CheckOverloadedOperatorDeclaration(NewFD)) { 7542 NewFD->setInvalidDecl(); 7543 return Redeclaration; 7544 } 7545 7546 // Extra checking for C++0x literal operators (C++0x [over.literal]). 7547 if (NewFD->getLiteralIdentifier() && 7548 CheckLiteralOperatorDeclaration(NewFD)) { 7549 NewFD->setInvalidDecl(); 7550 return Redeclaration; 7551 } 7552 7553 // In C++, check default arguments now that we have merged decls. Unless 7554 // the lexical context is the class, because in this case this is done 7555 // during delayed parsing anyway. 7556 if (!CurContext->isRecord()) 7557 CheckCXXDefaultArguments(NewFD); 7558 7559 // If this function declares a builtin function, check the type of this 7560 // declaration against the expected type for the builtin. 7561 if (unsigned BuiltinID = NewFD->getBuiltinID()) { 7562 ASTContext::GetBuiltinTypeError Error; 7563 LookupPredefedObjCSuperType(*this, S, NewFD->getIdentifier()); 7564 QualType T = Context.GetBuiltinType(BuiltinID, Error); 7565 if (!T.isNull() && !Context.hasSameType(T, NewFD->getType())) { 7566 // The type of this function differs from the type of the builtin, 7567 // so forget about the builtin entirely. 7568 Context.BuiltinInfo.ForgetBuiltin(BuiltinID, Context.Idents); 7569 } 7570 } 7571 7572 // If this function is declared as being extern "C", then check to see if 7573 // the function returns a UDT (class, struct, or union type) that is not C 7574 // compatible, and if it does, warn the user. 7575 // But, issue any diagnostic on the first declaration only. 7576 if (NewFD->isExternC() && Previous.empty()) { 7577 QualType R = NewFD->getResultType(); 7578 if (R->isIncompleteType() && !R->isVoidType()) 7579 Diag(NewFD->getLocation(), diag::warn_return_value_udt_incomplete) 7580 << NewFD << R; 7581 else if (!R.isPODType(Context) && !R->isVoidType() && 7582 !R->isObjCObjectPointerType()) 7583 Diag(NewFD->getLocation(), diag::warn_return_value_udt) << NewFD << R; 7584 } 7585 } 7586 return Redeclaration; 7587} 7588 7589static SourceRange getResultSourceRange(const FunctionDecl *FD) { 7590 const TypeSourceInfo *TSI = FD->getTypeSourceInfo(); 7591 if (!TSI) 7592 return SourceRange(); 7593 7594 TypeLoc TL = TSI->getTypeLoc(); 7595 FunctionTypeLoc FunctionTL = TL.getAs<FunctionTypeLoc>(); 7596 if (!FunctionTL) 7597 return SourceRange(); 7598 7599 TypeLoc ResultTL = FunctionTL.getResultLoc(); 7600 if (ResultTL.getUnqualifiedLoc().getAs<BuiltinTypeLoc>()) 7601 return ResultTL.getSourceRange(); 7602 7603 return SourceRange(); 7604} 7605 7606void Sema::CheckMain(FunctionDecl* FD, const DeclSpec& DS) { 7607 // C++11 [basic.start.main]p3: A program that declares main to be inline, 7608 // static or constexpr is ill-formed. 7609 // C11 6.7.4p4: In a hosted environment, no function specifier(s) shall 7610 // appear in a declaration of main. 7611 // static main is not an error under C99, but we should warn about it. 7612 // We accept _Noreturn main as an extension. 7613 if (FD->getStorageClass() == SC_Static) 7614 Diag(DS.getStorageClassSpecLoc(), getLangOpts().CPlusPlus 7615 ? diag::err_static_main : diag::warn_static_main) 7616 << FixItHint::CreateRemoval(DS.getStorageClassSpecLoc()); 7617 if (FD->isInlineSpecified()) 7618 Diag(DS.getInlineSpecLoc(), diag::err_inline_main) 7619 << FixItHint::CreateRemoval(DS.getInlineSpecLoc()); 7620 if (DS.isNoreturnSpecified()) { 7621 SourceLocation NoreturnLoc = DS.getNoreturnSpecLoc(); 7622 SourceRange NoreturnRange(NoreturnLoc, 7623 PP.getLocForEndOfToken(NoreturnLoc)); 7624 Diag(NoreturnLoc, diag::ext_noreturn_main); 7625 Diag(NoreturnLoc, diag::note_main_remove_noreturn) 7626 << FixItHint::CreateRemoval(NoreturnRange); 7627 } 7628 if (FD->isConstexpr()) { 7629 Diag(DS.getConstexprSpecLoc(), diag::err_constexpr_main) 7630 << FixItHint::CreateRemoval(DS.getConstexprSpecLoc()); 7631 FD->setConstexpr(false); 7632 } 7633 7634 QualType T = FD->getType(); 7635 assert(T->isFunctionType() && "function decl is not of function type"); 7636 const FunctionType* FT = T->castAs<FunctionType>(); 7637 7638 // All the standards say that main() should should return 'int'. 7639 if (Context.hasSameUnqualifiedType(FT->getResultType(), Context.IntTy)) { 7640 // In C and C++, main magically returns 0 if you fall off the end; 7641 // set the flag which tells us that. 7642 // This is C++ [basic.start.main]p5 and C99 5.1.2.2.3. 7643 FD->setHasImplicitReturnZero(true); 7644 7645 // In C with GNU extensions we allow main() to have non-integer return 7646 // type, but we should warn about the extension, and we disable the 7647 // implicit-return-zero rule. 7648 } else if (getLangOpts().GNUMode && !getLangOpts().CPlusPlus) { 7649 Diag(FD->getTypeSpecStartLoc(), diag::ext_main_returns_nonint); 7650 7651 SourceRange ResultRange = getResultSourceRange(FD); 7652 if (ResultRange.isValid()) 7653 Diag(ResultRange.getBegin(), diag::note_main_change_return_type) 7654 << FixItHint::CreateReplacement(ResultRange, "int"); 7655 7656 // Otherwise, this is just a flat-out error. 7657 } else { 7658 SourceRange ResultRange = getResultSourceRange(FD); 7659 if (ResultRange.isValid()) 7660 Diag(FD->getTypeSpecStartLoc(), diag::err_main_returns_nonint) 7661 << FixItHint::CreateReplacement(ResultRange, "int"); 7662 else 7663 Diag(FD->getTypeSpecStartLoc(), diag::err_main_returns_nonint); 7664 7665 FD->setInvalidDecl(true); 7666 } 7667 7668 // Treat protoless main() as nullary. 7669 if (isa<FunctionNoProtoType>(FT)) return; 7670 7671 const FunctionProtoType* FTP = cast<const FunctionProtoType>(FT); 7672 unsigned nparams = FTP->getNumArgs(); 7673 assert(FD->getNumParams() == nparams); 7674 7675 bool HasExtraParameters = (nparams > 3); 7676 7677 // Darwin passes an undocumented fourth argument of type char**. If 7678 // other platforms start sprouting these, the logic below will start 7679 // getting shifty. 7680 if (nparams == 4 && Context.getTargetInfo().getTriple().isOSDarwin()) 7681 HasExtraParameters = false; 7682 7683 if (HasExtraParameters) { 7684 Diag(FD->getLocation(), diag::err_main_surplus_args) << nparams; 7685 FD->setInvalidDecl(true); 7686 nparams = 3; 7687 } 7688 7689 // FIXME: a lot of the following diagnostics would be improved 7690 // if we had some location information about types. 7691 7692 QualType CharPP = 7693 Context.getPointerType(Context.getPointerType(Context.CharTy)); 7694 QualType Expected[] = { Context.IntTy, CharPP, CharPP, CharPP }; 7695 7696 for (unsigned i = 0; i < nparams; ++i) { 7697 QualType AT = FTP->getArgType(i); 7698 7699 bool mismatch = true; 7700 7701 if (Context.hasSameUnqualifiedType(AT, Expected[i])) 7702 mismatch = false; 7703 else if (Expected[i] == CharPP) { 7704 // As an extension, the following forms are okay: 7705 // char const ** 7706 // char const * const * 7707 // char * const * 7708 7709 QualifierCollector qs; 7710 const PointerType* PT; 7711 if ((PT = qs.strip(AT)->getAs<PointerType>()) && 7712 (PT = qs.strip(PT->getPointeeType())->getAs<PointerType>()) && 7713 Context.hasSameType(QualType(qs.strip(PT->getPointeeType()), 0), 7714 Context.CharTy)) { 7715 qs.removeConst(); 7716 mismatch = !qs.empty(); 7717 } 7718 } 7719 7720 if (mismatch) { 7721 Diag(FD->getLocation(), diag::err_main_arg_wrong) << i << Expected[i]; 7722 // TODO: suggest replacing given type with expected type 7723 FD->setInvalidDecl(true); 7724 } 7725 } 7726 7727 if (nparams == 1 && !FD->isInvalidDecl()) { 7728 Diag(FD->getLocation(), diag::warn_main_one_arg); 7729 } 7730 7731 if (!FD->isInvalidDecl() && FD->getDescribedFunctionTemplate()) { 7732 Diag(FD->getLocation(), diag::err_mainlike_template_decl) << FD->getName(); 7733 FD->setInvalidDecl(); 7734 } 7735} 7736 7737void Sema::CheckMSVCRTEntryPoint(FunctionDecl *FD) { 7738 QualType T = FD->getType(); 7739 assert(T->isFunctionType() && "function decl is not of function type"); 7740 const FunctionType *FT = T->castAs<FunctionType>(); 7741 7742 // Set an implicit return of 'zero' if the function can return some integral, 7743 // enumeration, pointer or nullptr type. 7744 if (FT->getResultType()->isIntegralOrEnumerationType() || 7745 FT->getResultType()->isAnyPointerType() || 7746 FT->getResultType()->isNullPtrType()) 7747 // DllMain is exempt because a return value of zero means it failed. 7748 if (FD->getName() != "DllMain") 7749 FD->setHasImplicitReturnZero(true); 7750 7751 if (!FD->isInvalidDecl() && FD->getDescribedFunctionTemplate()) { 7752 Diag(FD->getLocation(), diag::err_mainlike_template_decl) << FD->getName(); 7753 FD->setInvalidDecl(); 7754 } 7755} 7756 7757bool Sema::CheckForConstantInitializer(Expr *Init, QualType DclT) { 7758 // FIXME: Need strict checking. In C89, we need to check for 7759 // any assignment, increment, decrement, function-calls, or 7760 // commas outside of a sizeof. In C99, it's the same list, 7761 // except that the aforementioned are allowed in unevaluated 7762 // expressions. Everything else falls under the 7763 // "may accept other forms of constant expressions" exception. 7764 // (We never end up here for C++, so the constant expression 7765 // rules there don't matter.) 7766 if (Init->isConstantInitializer(Context, false)) 7767 return false; 7768 Diag(Init->getExprLoc(), diag::err_init_element_not_constant) 7769 << Init->getSourceRange(); 7770 return true; 7771} 7772 7773namespace { 7774 // Visits an initialization expression to see if OrigDecl is evaluated in 7775 // its own initialization and throws a warning if it does. 7776 class SelfReferenceChecker 7777 : public EvaluatedExprVisitor<SelfReferenceChecker> { 7778 Sema &S; 7779 Decl *OrigDecl; 7780 bool isRecordType; 7781 bool isPODType; 7782 bool isReferenceType; 7783 7784 public: 7785 typedef EvaluatedExprVisitor<SelfReferenceChecker> Inherited; 7786 7787 SelfReferenceChecker(Sema &S, Decl *OrigDecl) : Inherited(S.Context), 7788 S(S), OrigDecl(OrigDecl) { 7789 isPODType = false; 7790 isRecordType = false; 7791 isReferenceType = false; 7792 if (ValueDecl *VD = dyn_cast<ValueDecl>(OrigDecl)) { 7793 isPODType = VD->getType().isPODType(S.Context); 7794 isRecordType = VD->getType()->isRecordType(); 7795 isReferenceType = VD->getType()->isReferenceType(); 7796 } 7797 } 7798 7799 // For most expressions, the cast is directly above the DeclRefExpr. 7800 // For conditional operators, the cast can be outside the conditional 7801 // operator if both expressions are DeclRefExpr's. 7802 void HandleValue(Expr *E) { 7803 if (isReferenceType) 7804 return; 7805 E = E->IgnoreParenImpCasts(); 7806 if (DeclRefExpr* DRE = dyn_cast<DeclRefExpr>(E)) { 7807 HandleDeclRefExpr(DRE); 7808 return; 7809 } 7810 7811 if (ConditionalOperator *CO = dyn_cast<ConditionalOperator>(E)) { 7812 HandleValue(CO->getTrueExpr()); 7813 HandleValue(CO->getFalseExpr()); 7814 return; 7815 } 7816 7817 if (isa<MemberExpr>(E)) { 7818 Expr *Base = E->IgnoreParenImpCasts(); 7819 while (MemberExpr *ME = dyn_cast<MemberExpr>(Base)) { 7820 // Check for static member variables and don't warn on them. 7821 if (!isa<FieldDecl>(ME->getMemberDecl())) 7822 return; 7823 Base = ME->getBase()->IgnoreParenImpCasts(); 7824 } 7825 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Base)) 7826 HandleDeclRefExpr(DRE); 7827 return; 7828 } 7829 } 7830 7831 // Reference types are handled here since all uses of references are 7832 // bad, not just r-value uses. 7833 void VisitDeclRefExpr(DeclRefExpr *E) { 7834 if (isReferenceType) 7835 HandleDeclRefExpr(E); 7836 } 7837 7838 void VisitImplicitCastExpr(ImplicitCastExpr *E) { 7839 if (E->getCastKind() == CK_LValueToRValue || 7840 (isRecordType && E->getCastKind() == CK_NoOp)) 7841 HandleValue(E->getSubExpr()); 7842 7843 Inherited::VisitImplicitCastExpr(E); 7844 } 7845 7846 void VisitMemberExpr(MemberExpr *E) { 7847 // Don't warn on arrays since they can be treated as pointers. 7848 if (E->getType()->canDecayToPointerType()) return; 7849 7850 // Warn when a non-static method call is followed by non-static member 7851 // field accesses, which is followed by a DeclRefExpr. 7852 CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(E->getMemberDecl()); 7853 bool Warn = (MD && !MD->isStatic()); 7854 Expr *Base = E->getBase()->IgnoreParenImpCasts(); 7855 while (MemberExpr *ME = dyn_cast<MemberExpr>(Base)) { 7856 if (!isa<FieldDecl>(ME->getMemberDecl())) 7857 Warn = false; 7858 Base = ME->getBase()->IgnoreParenImpCasts(); 7859 } 7860 7861 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Base)) { 7862 if (Warn) 7863 HandleDeclRefExpr(DRE); 7864 return; 7865 } 7866 7867 // The base of a MemberExpr is not a MemberExpr or a DeclRefExpr. 7868 // Visit that expression. 7869 Visit(Base); 7870 } 7871 7872 void VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E) { 7873 if (E->getNumArgs() > 0) 7874 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E->getArg(0))) 7875 HandleDeclRefExpr(DRE); 7876 7877 Inherited::VisitCXXOperatorCallExpr(E); 7878 } 7879 7880 void VisitUnaryOperator(UnaryOperator *E) { 7881 // For POD record types, addresses of its own members are well-defined. 7882 if (E->getOpcode() == UO_AddrOf && isRecordType && 7883 isa<MemberExpr>(E->getSubExpr()->IgnoreParens())) { 7884 if (!isPODType) 7885 HandleValue(E->getSubExpr()); 7886 return; 7887 } 7888 Inherited::VisitUnaryOperator(E); 7889 } 7890 7891 void VisitObjCMessageExpr(ObjCMessageExpr *E) { return; } 7892 7893 void HandleDeclRefExpr(DeclRefExpr *DRE) { 7894 Decl* ReferenceDecl = DRE->getDecl(); 7895 if (OrigDecl != ReferenceDecl) return; 7896 unsigned diag; 7897 if (isReferenceType) { 7898 diag = diag::warn_uninit_self_reference_in_reference_init; 7899 } else if (cast<VarDecl>(OrigDecl)->isStaticLocal()) { 7900 diag = diag::warn_static_self_reference_in_init; 7901 } else { 7902 diag = diag::warn_uninit_self_reference_in_init; 7903 } 7904 7905 S.DiagRuntimeBehavior(DRE->getLocStart(), DRE, 7906 S.PDiag(diag) 7907 << DRE->getNameInfo().getName() 7908 << OrigDecl->getLocation() 7909 << DRE->getSourceRange()); 7910 } 7911 }; 7912 7913 /// CheckSelfReference - Warns if OrigDecl is used in expression E. 7914 static void CheckSelfReference(Sema &S, Decl* OrigDecl, Expr *E, 7915 bool DirectInit) { 7916 // Parameters arguments are occassionially constructed with itself, 7917 // for instance, in recursive functions. Skip them. 7918 if (isa<ParmVarDecl>(OrigDecl)) 7919 return; 7920 7921 E = E->IgnoreParens(); 7922 7923 // Skip checking T a = a where T is not a record or reference type. 7924 // Doing so is a way to silence uninitialized warnings. 7925 if (!DirectInit && !cast<VarDecl>(OrigDecl)->getType()->isRecordType()) 7926 if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E)) 7927 if (ICE->getCastKind() == CK_LValueToRValue) 7928 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(ICE->getSubExpr())) 7929 if (DRE->getDecl() == OrigDecl) 7930 return; 7931 7932 SelfReferenceChecker(S, OrigDecl).Visit(E); 7933 } 7934} 7935 7936/// AddInitializerToDecl - Adds the initializer Init to the 7937/// declaration dcl. If DirectInit is true, this is C++ direct 7938/// initialization rather than copy initialization. 7939void Sema::AddInitializerToDecl(Decl *RealDecl, Expr *Init, 7940 bool DirectInit, bool TypeMayContainAuto) { 7941 // If there is no declaration, there was an error parsing it. Just ignore 7942 // the initializer. 7943 if (RealDecl == 0 || RealDecl->isInvalidDecl()) 7944 return; 7945 7946 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(RealDecl)) { 7947 // With declarators parsed the way they are, the parser cannot 7948 // distinguish between a normal initializer and a pure-specifier. 7949 // Thus this grotesque test. 7950 IntegerLiteral *IL; 7951 if ((IL = dyn_cast<IntegerLiteral>(Init)) && IL->getValue() == 0 && 7952 Context.getCanonicalType(IL->getType()) == Context.IntTy) 7953 CheckPureMethod(Method, Init->getSourceRange()); 7954 else { 7955 Diag(Method->getLocation(), diag::err_member_function_initialization) 7956 << Method->getDeclName() << Init->getSourceRange(); 7957 Method->setInvalidDecl(); 7958 } 7959 return; 7960 } 7961 7962 VarDecl *VDecl = dyn_cast<VarDecl>(RealDecl); 7963 if (!VDecl) { 7964 assert(!isa<FieldDecl>(RealDecl) && "field init shouldn't get here"); 7965 Diag(RealDecl->getLocation(), diag::err_illegal_initializer); 7966 RealDecl->setInvalidDecl(); 7967 return; 7968 } 7969 ParenListExpr *CXXDirectInit = dyn_cast<ParenListExpr>(Init); 7970 7971 // C++11 [decl.spec.auto]p6. Deduce the type which 'auto' stands in for. 7972 if (TypeMayContainAuto && VDecl->getType()->isUndeducedType()) { 7973 Expr *DeduceInit = Init; 7974 // Initializer could be a C++ direct-initializer. Deduction only works if it 7975 // contains exactly one expression. 7976 if (CXXDirectInit) { 7977 if (CXXDirectInit->getNumExprs() == 0) { 7978 // It isn't possible to write this directly, but it is possible to 7979 // end up in this situation with "auto x(some_pack...);" 7980 Diag(CXXDirectInit->getLocStart(), 7981 VDecl->isInitCapture() ? diag::err_init_capture_no_expression 7982 : diag::err_auto_var_init_no_expression) 7983 << VDecl->getDeclName() << VDecl->getType() 7984 << VDecl->getSourceRange(); 7985 RealDecl->setInvalidDecl(); 7986 return; 7987 } else if (CXXDirectInit->getNumExprs() > 1) { 7988 Diag(CXXDirectInit->getExpr(1)->getLocStart(), 7989 VDecl->isInitCapture() 7990 ? diag::err_init_capture_multiple_expressions 7991 : diag::err_auto_var_init_multiple_expressions) 7992 << VDecl->getDeclName() << VDecl->getType() 7993 << VDecl->getSourceRange(); 7994 RealDecl->setInvalidDecl(); 7995 return; 7996 } else { 7997 DeduceInit = CXXDirectInit->getExpr(0); 7998 } 7999 } 8000 8001 // Expressions default to 'id' when we're in a debugger. 8002 bool DefaultedToAuto = false; 8003 if (getLangOpts().DebuggerCastResultToId && 8004 Init->getType() == Context.UnknownAnyTy) { 8005 ExprResult Result = forceUnknownAnyToType(Init, Context.getObjCIdType()); 8006 if (Result.isInvalid()) { 8007 VDecl->setInvalidDecl(); 8008 return; 8009 } 8010 Init = Result.take(); 8011 DefaultedToAuto = true; 8012 } 8013 8014 QualType DeducedType; 8015 if (DeduceAutoType(VDecl->getTypeSourceInfo(), DeduceInit, DeducedType) == 8016 DAR_Failed) 8017 DiagnoseAutoDeductionFailure(VDecl, DeduceInit); 8018 if (DeducedType.isNull()) { 8019 RealDecl->setInvalidDecl(); 8020 return; 8021 } 8022 VDecl->setType(DeducedType); 8023 assert(VDecl->isLinkageValid()); 8024 8025 // In ARC, infer lifetime. 8026 if (getLangOpts().ObjCAutoRefCount && inferObjCARCLifetime(VDecl)) 8027 VDecl->setInvalidDecl(); 8028 8029 // Warn if we deduced 'id'. 'auto' usually implies type-safety, but using 8030 // 'id' instead of a specific object type prevents most of our usual checks. 8031 // We only want to warn outside of template instantiations, though: 8032 // inside a template, the 'id' could have come from a parameter. 8033 if (ActiveTemplateInstantiations.empty() && !DefaultedToAuto && 8034 DeducedType->isObjCIdType()) { 8035 SourceLocation Loc = 8036 VDecl->getTypeSourceInfo()->getTypeLoc().getBeginLoc(); 8037 Diag(Loc, diag::warn_auto_var_is_id) 8038 << VDecl->getDeclName() << DeduceInit->getSourceRange(); 8039 } 8040 8041 // If this is a redeclaration, check that the type we just deduced matches 8042 // the previously declared type. 8043 if (VarDecl *Old = VDecl->getPreviousDecl()) { 8044 // We never need to merge the type, because we cannot form an incomplete 8045 // array of auto, nor deduce such a type. 8046 MergeVarDeclTypes(VDecl, Old, /*MergeTypeWithPrevious*/false); 8047 } 8048 8049 // Check the deduced type is valid for a variable declaration. 8050 CheckVariableDeclarationType(VDecl); 8051 if (VDecl->isInvalidDecl()) 8052 return; 8053 } 8054 8055 if (VDecl->isLocalVarDecl() && VDecl->hasExternalStorage()) { 8056 // C99 6.7.8p5. C++ has no such restriction, but that is a defect. 8057 Diag(VDecl->getLocation(), diag::err_block_extern_cant_init); 8058 VDecl->setInvalidDecl(); 8059 return; 8060 } 8061 8062 if (!VDecl->getType()->isDependentType()) { 8063 // A definition must end up with a complete type, which means it must be 8064 // complete with the restriction that an array type might be completed by 8065 // the initializer; note that later code assumes this restriction. 8066 QualType BaseDeclType = VDecl->getType(); 8067 if (const ArrayType *Array = Context.getAsIncompleteArrayType(BaseDeclType)) 8068 BaseDeclType = Array->getElementType(); 8069 if (RequireCompleteType(VDecl->getLocation(), BaseDeclType, 8070 diag::err_typecheck_decl_incomplete_type)) { 8071 RealDecl->setInvalidDecl(); 8072 return; 8073 } 8074 8075 // The variable can not have an abstract class type. 8076 if (RequireNonAbstractType(VDecl->getLocation(), VDecl->getType(), 8077 diag::err_abstract_type_in_decl, 8078 AbstractVariableType)) 8079 VDecl->setInvalidDecl(); 8080 } 8081 8082 const VarDecl *Def; 8083 if ((Def = VDecl->getDefinition()) && Def != VDecl) { 8084 Diag(VDecl->getLocation(), diag::err_redefinition) 8085 << VDecl->getDeclName(); 8086 Diag(Def->getLocation(), diag::note_previous_definition); 8087 VDecl->setInvalidDecl(); 8088 return; 8089 } 8090 8091 const VarDecl* PrevInit = 0; 8092 if (getLangOpts().CPlusPlus) { 8093 // C++ [class.static.data]p4 8094 // If a static data member is of const integral or const 8095 // enumeration type, its declaration in the class definition can 8096 // specify a constant-initializer which shall be an integral 8097 // constant expression (5.19). In that case, the member can appear 8098 // in integral constant expressions. The member shall still be 8099 // defined in a namespace scope if it is used in the program and the 8100 // namespace scope definition shall not contain an initializer. 8101 // 8102 // We already performed a redefinition check above, but for static 8103 // data members we also need to check whether there was an in-class 8104 // declaration with an initializer. 8105 if (VDecl->isStaticDataMember() && VDecl->getAnyInitializer(PrevInit)) { 8106 Diag(VDecl->getLocation(), diag::err_redefinition) 8107 << VDecl->getDeclName(); 8108 Diag(PrevInit->getLocation(), diag::note_previous_definition); 8109 return; 8110 } 8111 8112 if (VDecl->hasLocalStorage()) 8113 getCurFunction()->setHasBranchProtectedScope(); 8114 8115 if (DiagnoseUnexpandedParameterPack(Init, UPPC_Initializer)) { 8116 VDecl->setInvalidDecl(); 8117 return; 8118 } 8119 } 8120 8121 // OpenCL 1.1 6.5.2: "Variables allocated in the __local address space inside 8122 // a kernel function cannot be initialized." 8123 if (VDecl->getStorageClass() == SC_OpenCLWorkGroupLocal) { 8124 Diag(VDecl->getLocation(), diag::err_local_cant_init); 8125 VDecl->setInvalidDecl(); 8126 return; 8127 } 8128 8129 // Get the decls type and save a reference for later, since 8130 // CheckInitializerTypes may change it. 8131 QualType DclT = VDecl->getType(), SavT = DclT; 8132 8133 // Expressions default to 'id' when we're in a debugger 8134 // and we are assigning it to a variable of Objective-C pointer type. 8135 if (getLangOpts().DebuggerCastResultToId && DclT->isObjCObjectPointerType() && 8136 Init->getType() == Context.UnknownAnyTy) { 8137 ExprResult Result = forceUnknownAnyToType(Init, Context.getObjCIdType()); 8138 if (Result.isInvalid()) { 8139 VDecl->setInvalidDecl(); 8140 return; 8141 } 8142 Init = Result.take(); 8143 } 8144 8145 // Perform the initialization. 8146 if (!VDecl->isInvalidDecl()) { 8147 InitializedEntity Entity = InitializedEntity::InitializeVariable(VDecl); 8148 InitializationKind Kind 8149 = DirectInit ? 8150 CXXDirectInit ? InitializationKind::CreateDirect(VDecl->getLocation(), 8151 Init->getLocStart(), 8152 Init->getLocEnd()) 8153 : InitializationKind::CreateDirectList( 8154 VDecl->getLocation()) 8155 : InitializationKind::CreateCopy(VDecl->getLocation(), 8156 Init->getLocStart()); 8157 8158 MultiExprArg Args = Init; 8159 if (CXXDirectInit) 8160 Args = MultiExprArg(CXXDirectInit->getExprs(), 8161 CXXDirectInit->getNumExprs()); 8162 8163 InitializationSequence InitSeq(*this, Entity, Kind, Args); 8164 ExprResult Result = InitSeq.Perform(*this, Entity, Kind, Args, &DclT); 8165 if (Result.isInvalid()) { 8166 VDecl->setInvalidDecl(); 8167 return; 8168 } 8169 8170 Init = Result.takeAs<Expr>(); 8171 } 8172 8173 // Check for self-references within variable initializers. 8174 // Variables declared within a function/method body (except for references) 8175 // are handled by a dataflow analysis. 8176 if (!VDecl->hasLocalStorage() || VDecl->getType()->isRecordType() || 8177 VDecl->getType()->isReferenceType()) { 8178 CheckSelfReference(*this, RealDecl, Init, DirectInit); 8179 } 8180 8181 // If the type changed, it means we had an incomplete type that was 8182 // completed by the initializer. For example: 8183 // int ary[] = { 1, 3, 5 }; 8184 // "ary" transitions from an IncompleteArrayType to a ConstantArrayType. 8185 if (!VDecl->isInvalidDecl() && (DclT != SavT)) 8186 VDecl->setType(DclT); 8187 8188 if (!VDecl->isInvalidDecl()) { 8189 checkUnsafeAssigns(VDecl->getLocation(), VDecl->getType(), Init); 8190 8191 if (VDecl->hasAttr<BlocksAttr>()) 8192 checkRetainCycles(VDecl, Init); 8193 8194 // It is safe to assign a weak reference into a strong variable. 8195 // Although this code can still have problems: 8196 // id x = self.weakProp; 8197 // id y = self.weakProp; 8198 // we do not warn to warn spuriously when 'x' and 'y' are on separate 8199 // paths through the function. This should be revisited if 8200 // -Wrepeated-use-of-weak is made flow-sensitive. 8201 if (VDecl->getType().getObjCLifetime() == Qualifiers::OCL_Strong) { 8202 DiagnosticsEngine::Level Level = 8203 Diags.getDiagnosticLevel(diag::warn_arc_repeated_use_of_weak, 8204 Init->getLocStart()); 8205 if (Level != DiagnosticsEngine::Ignored) 8206 getCurFunction()->markSafeWeakUse(Init); 8207 } 8208 } 8209 8210 // The initialization is usually a full-expression. 8211 // 8212 // FIXME: If this is a braced initialization of an aggregate, it is not 8213 // an expression, and each individual field initializer is a separate 8214 // full-expression. For instance, in: 8215 // 8216 // struct Temp { ~Temp(); }; 8217 // struct S { S(Temp); }; 8218 // struct T { S a, b; } t = { Temp(), Temp() } 8219 // 8220 // we should destroy the first Temp before constructing the second. 8221 ExprResult Result = ActOnFinishFullExpr(Init, VDecl->getLocation(), 8222 false, 8223 VDecl->isConstexpr()); 8224 if (Result.isInvalid()) { 8225 VDecl->setInvalidDecl(); 8226 return; 8227 } 8228 Init = Result.take(); 8229 8230 // Attach the initializer to the decl. 8231 VDecl->setInit(Init); 8232 8233 if (VDecl->isLocalVarDecl()) { 8234 // C99 6.7.8p4: All the expressions in an initializer for an object that has 8235 // static storage duration shall be constant expressions or string literals. 8236 // C++ does not have this restriction. 8237 if (!getLangOpts().CPlusPlus && !VDecl->isInvalidDecl()) { 8238 if (VDecl->getStorageClass() == SC_Static) 8239 CheckForConstantInitializer(Init, DclT); 8240 // C89 is stricter than C99 for non-static aggregate types. 8241 // C89 6.5.7p3: All the expressions [...] in an initializer list 8242 // for an object that has aggregate or union type shall be 8243 // constant expressions. 8244 else if (!getLangOpts().C99 && VDecl->getType()->isAggregateType() && 8245 isa<InitListExpr>(Init) && 8246 !Init->isConstantInitializer(Context, false)) 8247 Diag(Init->getExprLoc(), 8248 diag::ext_aggregate_init_not_constant) 8249 << Init->getSourceRange(); 8250 } 8251 } else if (VDecl->isStaticDataMember() && 8252 VDecl->getLexicalDeclContext()->isRecord()) { 8253 // This is an in-class initialization for a static data member, e.g., 8254 // 8255 // struct S { 8256 // static const int value = 17; 8257 // }; 8258 8259 // C++ [class.mem]p4: 8260 // A member-declarator can contain a constant-initializer only 8261 // if it declares a static member (9.4) of const integral or 8262 // const enumeration type, see 9.4.2. 8263 // 8264 // C++11 [class.static.data]p3: 8265 // If a non-volatile const static data member is of integral or 8266 // enumeration type, its declaration in the class definition can 8267 // specify a brace-or-equal-initializer in which every initalizer-clause 8268 // that is an assignment-expression is a constant expression. A static 8269 // data member of literal type can be declared in the class definition 8270 // with the constexpr specifier; if so, its declaration shall specify a 8271 // brace-or-equal-initializer in which every initializer-clause that is 8272 // an assignment-expression is a constant expression. 8273 8274 // Do nothing on dependent types. 8275 if (DclT->isDependentType()) { 8276 8277 // Allow any 'static constexpr' members, whether or not they are of literal 8278 // type. We separately check that every constexpr variable is of literal 8279 // type. 8280 } else if (VDecl->isConstexpr()) { 8281 8282 // Require constness. 8283 } else if (!DclT.isConstQualified()) { 8284 Diag(VDecl->getLocation(), diag::err_in_class_initializer_non_const) 8285 << Init->getSourceRange(); 8286 VDecl->setInvalidDecl(); 8287 8288 // We allow integer constant expressions in all cases. 8289 } else if (DclT->isIntegralOrEnumerationType()) { 8290 // Check whether the expression is a constant expression. 8291 SourceLocation Loc; 8292 if (getLangOpts().CPlusPlus11 && DclT.isVolatileQualified()) 8293 // In C++11, a non-constexpr const static data member with an 8294 // in-class initializer cannot be volatile. 8295 Diag(VDecl->getLocation(), diag::err_in_class_initializer_volatile); 8296 else if (Init->isValueDependent()) 8297 ; // Nothing to check. 8298 else if (Init->isIntegerConstantExpr(Context, &Loc)) 8299 ; // Ok, it's an ICE! 8300 else if (Init->isEvaluatable(Context)) { 8301 // If we can constant fold the initializer through heroics, accept it, 8302 // but report this as a use of an extension for -pedantic. 8303 Diag(Loc, diag::ext_in_class_initializer_non_constant) 8304 << Init->getSourceRange(); 8305 } else { 8306 // Otherwise, this is some crazy unknown case. Report the issue at the 8307 // location provided by the isIntegerConstantExpr failed check. 8308 Diag(Loc, diag::err_in_class_initializer_non_constant) 8309 << Init->getSourceRange(); 8310 VDecl->setInvalidDecl(); 8311 } 8312 8313 // We allow foldable floating-point constants as an extension. 8314 } else if (DclT->isFloatingType()) { // also permits complex, which is ok 8315 // In C++98, this is a GNU extension. In C++11, it is not, but we support 8316 // it anyway and provide a fixit to add the 'constexpr'. 8317 if (getLangOpts().CPlusPlus11) { 8318 Diag(VDecl->getLocation(), 8319 diag::ext_in_class_initializer_float_type_cxx11) 8320 << DclT << Init->getSourceRange(); 8321 Diag(VDecl->getLocStart(), 8322 diag::note_in_class_initializer_float_type_cxx11) 8323 << FixItHint::CreateInsertion(VDecl->getLocStart(), "constexpr "); 8324 } else { 8325 Diag(VDecl->getLocation(), diag::ext_in_class_initializer_float_type) 8326 << DclT << Init->getSourceRange(); 8327 8328 if (!Init->isValueDependent() && !Init->isEvaluatable(Context)) { 8329 Diag(Init->getExprLoc(), diag::err_in_class_initializer_non_constant) 8330 << Init->getSourceRange(); 8331 VDecl->setInvalidDecl(); 8332 } 8333 } 8334 8335 // Suggest adding 'constexpr' in C++11 for literal types. 8336 } else if (getLangOpts().CPlusPlus11 && DclT->isLiteralType(Context)) { 8337 Diag(VDecl->getLocation(), diag::err_in_class_initializer_literal_type) 8338 << DclT << Init->getSourceRange() 8339 << FixItHint::CreateInsertion(VDecl->getLocStart(), "constexpr "); 8340 VDecl->setConstexpr(true); 8341 8342 } else { 8343 Diag(VDecl->getLocation(), diag::err_in_class_initializer_bad_type) 8344 << DclT << Init->getSourceRange(); 8345 VDecl->setInvalidDecl(); 8346 } 8347 } else if (VDecl->isFileVarDecl()) { 8348 if (VDecl->getStorageClass() == SC_Extern && 8349 (!getLangOpts().CPlusPlus || 8350 !(Context.getBaseElementType(VDecl->getType()).isConstQualified() || 8351 VDecl->isExternC())) && 8352 !isTemplateInstantiation(VDecl->getTemplateSpecializationKind())) 8353 Diag(VDecl->getLocation(), diag::warn_extern_init); 8354 8355 // C99 6.7.8p4. All file scoped initializers need to be constant. 8356 if (!getLangOpts().CPlusPlus && !VDecl->isInvalidDecl()) 8357 CheckForConstantInitializer(Init, DclT); 8358 else if (VDecl->getTLSKind() == VarDecl::TLS_Static && 8359 !VDecl->isInvalidDecl() && !DclT->isDependentType() && 8360 !Init->isValueDependent() && !VDecl->isConstexpr() && 8361 !Init->isConstantInitializer( 8362 Context, VDecl->getType()->isReferenceType())) { 8363 // GNU C++98 edits for __thread, [basic.start.init]p4: 8364 // An object of thread storage duration shall not require dynamic 8365 // initialization. 8366 // FIXME: Need strict checking here. 8367 Diag(VDecl->getLocation(), diag::err_thread_dynamic_init); 8368 if (getLangOpts().CPlusPlus11) 8369 Diag(VDecl->getLocation(), diag::note_use_thread_local); 8370 } 8371 } 8372 8373 // We will represent direct-initialization similarly to copy-initialization: 8374 // int x(1); -as-> int x = 1; 8375 // ClassType x(a,b,c); -as-> ClassType x = ClassType(a,b,c); 8376 // 8377 // Clients that want to distinguish between the two forms, can check for 8378 // direct initializer using VarDecl::getInitStyle(). 8379 // A major benefit is that clients that don't particularly care about which 8380 // exactly form was it (like the CodeGen) can handle both cases without 8381 // special case code. 8382 8383 // C++ 8.5p11: 8384 // The form of initialization (using parentheses or '=') is generally 8385 // insignificant, but does matter when the entity being initialized has a 8386 // class type. 8387 if (CXXDirectInit) { 8388 assert(DirectInit && "Call-style initializer must be direct init."); 8389 VDecl->setInitStyle(VarDecl::CallInit); 8390 } else if (DirectInit) { 8391 // This must be list-initialization. No other way is direct-initialization. 8392 VDecl->setInitStyle(VarDecl::ListInit); 8393 } 8394 8395 CheckCompleteVariableDeclaration(VDecl); 8396} 8397 8398/// ActOnInitializerError - Given that there was an error parsing an 8399/// initializer for the given declaration, try to return to some form 8400/// of sanity. 8401void Sema::ActOnInitializerError(Decl *D) { 8402 // Our main concern here is re-establishing invariants like "a 8403 // variable's type is either dependent or complete". 8404 if (!D || D->isInvalidDecl()) return; 8405 8406 VarDecl *VD = dyn_cast<VarDecl>(D); 8407 if (!VD) return; 8408 8409 // Auto types are meaningless if we can't make sense of the initializer. 8410 if (ParsingInitForAutoVars.count(D)) { 8411 D->setInvalidDecl(); 8412 return; 8413 } 8414 8415 QualType Ty = VD->getType(); 8416 if (Ty->isDependentType()) return; 8417 8418 // Require a complete type. 8419 if (RequireCompleteType(VD->getLocation(), 8420 Context.getBaseElementType(Ty), 8421 diag::err_typecheck_decl_incomplete_type)) { 8422 VD->setInvalidDecl(); 8423 return; 8424 } 8425 8426 // Require an abstract type. 8427 if (RequireNonAbstractType(VD->getLocation(), Ty, 8428 diag::err_abstract_type_in_decl, 8429 AbstractVariableType)) { 8430 VD->setInvalidDecl(); 8431 return; 8432 } 8433 8434 // Don't bother complaining about constructors or destructors, 8435 // though. 8436} 8437 8438void Sema::ActOnUninitializedDecl(Decl *RealDecl, 8439 bool TypeMayContainAuto) { 8440 // If there is no declaration, there was an error parsing it. Just ignore it. 8441 if (RealDecl == 0) 8442 return; 8443 8444 if (VarDecl *Var = dyn_cast<VarDecl>(RealDecl)) { 8445 QualType Type = Var->getType(); 8446 8447 // C++11 [dcl.spec.auto]p3 8448 if (TypeMayContainAuto && Type->getContainedAutoType()) { 8449 Diag(Var->getLocation(), diag::err_auto_var_requires_init) 8450 << Var->getDeclName() << Type; 8451 Var->setInvalidDecl(); 8452 return; 8453 } 8454 8455 // C++11 [class.static.data]p3: A static data member can be declared with 8456 // the constexpr specifier; if so, its declaration shall specify 8457 // a brace-or-equal-initializer. 8458 // C++11 [dcl.constexpr]p1: The constexpr specifier shall be applied only to 8459 // the definition of a variable [...] or the declaration of a static data 8460 // member. 8461 if (Var->isConstexpr() && !Var->isThisDeclarationADefinition()) { 8462 if (Var->isStaticDataMember()) 8463 Diag(Var->getLocation(), 8464 diag::err_constexpr_static_mem_var_requires_init) 8465 << Var->getDeclName(); 8466 else 8467 Diag(Var->getLocation(), diag::err_invalid_constexpr_var_decl); 8468 Var->setInvalidDecl(); 8469 return; 8470 } 8471 8472 switch (Var->isThisDeclarationADefinition()) { 8473 case VarDecl::Definition: 8474 if (!Var->isStaticDataMember() || !Var->getAnyInitializer()) 8475 break; 8476 8477 // We have an out-of-line definition of a static data member 8478 // that has an in-class initializer, so we type-check this like 8479 // a declaration. 8480 // 8481 // Fall through 8482 8483 case VarDecl::DeclarationOnly: 8484 // It's only a declaration. 8485 8486 // Block scope. C99 6.7p7: If an identifier for an object is 8487 // declared with no linkage (C99 6.2.2p6), the type for the 8488 // object shall be complete. 8489 if (!Type->isDependentType() && Var->isLocalVarDecl() && 8490 !Var->hasLinkage() && !Var->isInvalidDecl() && 8491 RequireCompleteType(Var->getLocation(), Type, 8492 diag::err_typecheck_decl_incomplete_type)) 8493 Var->setInvalidDecl(); 8494 8495 // Make sure that the type is not abstract. 8496 if (!Type->isDependentType() && !Var->isInvalidDecl() && 8497 RequireNonAbstractType(Var->getLocation(), Type, 8498 diag::err_abstract_type_in_decl, 8499 AbstractVariableType)) 8500 Var->setInvalidDecl(); 8501 if (!Type->isDependentType() && !Var->isInvalidDecl() && 8502 Var->getStorageClass() == SC_PrivateExtern) { 8503 Diag(Var->getLocation(), diag::warn_private_extern); 8504 Diag(Var->getLocation(), diag::note_private_extern); 8505 } 8506 8507 return; 8508 8509 case VarDecl::TentativeDefinition: 8510 // File scope. C99 6.9.2p2: A declaration of an identifier for an 8511 // object that has file scope without an initializer, and without a 8512 // storage-class specifier or with the storage-class specifier "static", 8513 // constitutes a tentative definition. Note: A tentative definition with 8514 // external linkage is valid (C99 6.2.2p5). 8515 if (!Var->isInvalidDecl()) { 8516 if (const IncompleteArrayType *ArrayT 8517 = Context.getAsIncompleteArrayType(Type)) { 8518 if (RequireCompleteType(Var->getLocation(), 8519 ArrayT->getElementType(), 8520 diag::err_illegal_decl_array_incomplete_type)) 8521 Var->setInvalidDecl(); 8522 } else if (Var->getStorageClass() == SC_Static) { 8523 // C99 6.9.2p3: If the declaration of an identifier for an object is 8524 // a tentative definition and has internal linkage (C99 6.2.2p3), the 8525 // declared type shall not be an incomplete type. 8526 // NOTE: code such as the following 8527 // static struct s; 8528 // struct s { int a; }; 8529 // is accepted by gcc. Hence here we issue a warning instead of 8530 // an error and we do not invalidate the static declaration. 8531 // NOTE: to avoid multiple warnings, only check the first declaration. 8532 if (Var->isFirstDecl()) 8533 RequireCompleteType(Var->getLocation(), Type, 8534 diag::ext_typecheck_decl_incomplete_type); 8535 } 8536 } 8537 8538 // Record the tentative definition; we're done. 8539 if (!Var->isInvalidDecl()) 8540 TentativeDefinitions.push_back(Var); 8541 return; 8542 } 8543 8544 // Provide a specific diagnostic for uninitialized variable 8545 // definitions with incomplete array type. 8546 if (Type->isIncompleteArrayType()) { 8547 Diag(Var->getLocation(), 8548 diag::err_typecheck_incomplete_array_needs_initializer); 8549 Var->setInvalidDecl(); 8550 return; 8551 } 8552 8553 // Provide a specific diagnostic for uninitialized variable 8554 // definitions with reference type. 8555 if (Type->isReferenceType()) { 8556 Diag(Var->getLocation(), diag::err_reference_var_requires_init) 8557 << Var->getDeclName() 8558 << SourceRange(Var->getLocation(), Var->getLocation()); 8559 Var->setInvalidDecl(); 8560 return; 8561 } 8562 8563 // Do not attempt to type-check the default initializer for a 8564 // variable with dependent type. 8565 if (Type->isDependentType()) 8566 return; 8567 8568 if (Var->isInvalidDecl()) 8569 return; 8570 8571 if (RequireCompleteType(Var->getLocation(), 8572 Context.getBaseElementType(Type), 8573 diag::err_typecheck_decl_incomplete_type)) { 8574 Var->setInvalidDecl(); 8575 return; 8576 } 8577 8578 // The variable can not have an abstract class type. 8579 if (RequireNonAbstractType(Var->getLocation(), Type, 8580 diag::err_abstract_type_in_decl, 8581 AbstractVariableType)) { 8582 Var->setInvalidDecl(); 8583 return; 8584 } 8585 8586 // Check for jumps past the implicit initializer. C++0x 8587 // clarifies that this applies to a "variable with automatic 8588 // storage duration", not a "local variable". 8589 // C++11 [stmt.dcl]p3 8590 // A program that jumps from a point where a variable with automatic 8591 // storage duration is not in scope to a point where it is in scope is 8592 // ill-formed unless the variable has scalar type, class type with a 8593 // trivial default constructor and a trivial destructor, a cv-qualified 8594 // version of one of these types, or an array of one of the preceding 8595 // types and is declared without an initializer. 8596 if (getLangOpts().CPlusPlus && Var->hasLocalStorage()) { 8597 if (const RecordType *Record 8598 = Context.getBaseElementType(Type)->getAs<RecordType>()) { 8599 CXXRecordDecl *CXXRecord = cast<CXXRecordDecl>(Record->getDecl()); 8600 // Mark the function for further checking even if the looser rules of 8601 // C++11 do not require such checks, so that we can diagnose 8602 // incompatibilities with C++98. 8603 if (!CXXRecord->isPOD()) 8604 getCurFunction()->setHasBranchProtectedScope(); 8605 } 8606 } 8607 8608 // C++03 [dcl.init]p9: 8609 // If no initializer is specified for an object, and the 8610 // object is of (possibly cv-qualified) non-POD class type (or 8611 // array thereof), the object shall be default-initialized; if 8612 // the object is of const-qualified type, the underlying class 8613 // type shall have a user-declared default 8614 // constructor. Otherwise, if no initializer is specified for 8615 // a non- static object, the object and its subobjects, if 8616 // any, have an indeterminate initial value); if the object 8617 // or any of its subobjects are of const-qualified type, the 8618 // program is ill-formed. 8619 // C++0x [dcl.init]p11: 8620 // If no initializer is specified for an object, the object is 8621 // default-initialized; [...]. 8622 InitializedEntity Entity = InitializedEntity::InitializeVariable(Var); 8623 InitializationKind Kind 8624 = InitializationKind::CreateDefault(Var->getLocation()); 8625 8626 InitializationSequence InitSeq(*this, Entity, Kind, None); 8627 ExprResult Init = InitSeq.Perform(*this, Entity, Kind, None); 8628 if (Init.isInvalid()) 8629 Var->setInvalidDecl(); 8630 else if (Init.get()) { 8631 Var->setInit(MaybeCreateExprWithCleanups(Init.get())); 8632 // This is important for template substitution. 8633 Var->setInitStyle(VarDecl::CallInit); 8634 } 8635 8636 CheckCompleteVariableDeclaration(Var); 8637 } 8638} 8639 8640void Sema::ActOnCXXForRangeDecl(Decl *D) { 8641 VarDecl *VD = dyn_cast<VarDecl>(D); 8642 if (!VD) { 8643 Diag(D->getLocation(), diag::err_for_range_decl_must_be_var); 8644 D->setInvalidDecl(); 8645 return; 8646 } 8647 8648 VD->setCXXForRangeDecl(true); 8649 8650 // for-range-declaration cannot be given a storage class specifier. 8651 int Error = -1; 8652 switch (VD->getStorageClass()) { 8653 case SC_None: 8654 break; 8655 case SC_Extern: 8656 Error = 0; 8657 break; 8658 case SC_Static: 8659 Error = 1; 8660 break; 8661 case SC_PrivateExtern: 8662 Error = 2; 8663 break; 8664 case SC_Auto: 8665 Error = 3; 8666 break; 8667 case SC_Register: 8668 Error = 4; 8669 break; 8670 case SC_OpenCLWorkGroupLocal: 8671 llvm_unreachable("Unexpected storage class"); 8672 } 8673 if (VD->isConstexpr()) 8674 Error = 5; 8675 if (Error != -1) { 8676 Diag(VD->getOuterLocStart(), diag::err_for_range_storage_class) 8677 << VD->getDeclName() << Error; 8678 D->setInvalidDecl(); 8679 } 8680} 8681 8682void Sema::CheckCompleteVariableDeclaration(VarDecl *var) { 8683 if (var->isInvalidDecl()) return; 8684 8685 // In ARC, don't allow jumps past the implicit initialization of a 8686 // local retaining variable. 8687 if (getLangOpts().ObjCAutoRefCount && 8688 var->hasLocalStorage()) { 8689 switch (var->getType().getObjCLifetime()) { 8690 case Qualifiers::OCL_None: 8691 case Qualifiers::OCL_ExplicitNone: 8692 case Qualifiers::OCL_Autoreleasing: 8693 break; 8694 8695 case Qualifiers::OCL_Weak: 8696 case Qualifiers::OCL_Strong: 8697 getCurFunction()->setHasBranchProtectedScope(); 8698 break; 8699 } 8700 } 8701 8702 if (var->isThisDeclarationADefinition() && 8703 var->isExternallyVisible() && var->hasLinkage() && 8704 getDiagnostics().getDiagnosticLevel( 8705 diag::warn_missing_variable_declarations, 8706 var->getLocation())) { 8707 // Find a previous declaration that's not a definition. 8708 VarDecl *prev = var->getPreviousDecl(); 8709 while (prev && prev->isThisDeclarationADefinition()) 8710 prev = prev->getPreviousDecl(); 8711 8712 if (!prev) 8713 Diag(var->getLocation(), diag::warn_missing_variable_declarations) << var; 8714 } 8715 8716 if (var->getTLSKind() == VarDecl::TLS_Static && 8717 var->getType().isDestructedType()) { 8718 // GNU C++98 edits for __thread, [basic.start.term]p3: 8719 // The type of an object with thread storage duration shall not 8720 // have a non-trivial destructor. 8721 Diag(var->getLocation(), diag::err_thread_nontrivial_dtor); 8722 if (getLangOpts().CPlusPlus11) 8723 Diag(var->getLocation(), diag::note_use_thread_local); 8724 } 8725 8726 // All the following checks are C++ only. 8727 if (!getLangOpts().CPlusPlus) return; 8728 8729 QualType type = var->getType(); 8730 if (type->isDependentType()) return; 8731 8732 // __block variables might require us to capture a copy-initializer. 8733 if (var->hasAttr<BlocksAttr>()) { 8734 // It's currently invalid to ever have a __block variable with an 8735 // array type; should we diagnose that here? 8736 8737 // Regardless, we don't want to ignore array nesting when 8738 // constructing this copy. 8739 if (type->isStructureOrClassType()) { 8740 EnterExpressionEvaluationContext scope(*this, PotentiallyEvaluated); 8741 SourceLocation poi = var->getLocation(); 8742 Expr *varRef =new (Context) DeclRefExpr(var, false, type, VK_LValue, poi); 8743 ExprResult result 8744 = PerformMoveOrCopyInitialization( 8745 InitializedEntity::InitializeBlock(poi, type, false), 8746 var, var->getType(), varRef, /*AllowNRVO=*/true); 8747 if (!result.isInvalid()) { 8748 result = MaybeCreateExprWithCleanups(result); 8749 Expr *init = result.takeAs<Expr>(); 8750 Context.setBlockVarCopyInits(var, init); 8751 } 8752 } 8753 } 8754 8755 Expr *Init = var->getInit(); 8756 bool IsGlobal = var->hasGlobalStorage() && !var->isStaticLocal(); 8757 QualType baseType = Context.getBaseElementType(type); 8758 8759 if (!var->getDeclContext()->isDependentContext() && 8760 Init && !Init->isValueDependent()) { 8761 if (IsGlobal && !var->isConstexpr() && 8762 getDiagnostics().getDiagnosticLevel(diag::warn_global_constructor, 8763 var->getLocation()) 8764 != DiagnosticsEngine::Ignored) { 8765 // Warn about globals which don't have a constant initializer. Don't 8766 // warn about globals with a non-trivial destructor because we already 8767 // warned about them. 8768 CXXRecordDecl *RD = baseType->getAsCXXRecordDecl(); 8769 if (!(RD && !RD->hasTrivialDestructor()) && 8770 !Init->isConstantInitializer(Context, baseType->isReferenceType())) 8771 Diag(var->getLocation(), diag::warn_global_constructor) 8772 << Init->getSourceRange(); 8773 } 8774 8775 if (var->isConstexpr()) { 8776 SmallVector<PartialDiagnosticAt, 8> Notes; 8777 if (!var->evaluateValue(Notes) || !var->isInitICE()) { 8778 SourceLocation DiagLoc = var->getLocation(); 8779 // If the note doesn't add any useful information other than a source 8780 // location, fold it into the primary diagnostic. 8781 if (Notes.size() == 1 && Notes[0].second.getDiagID() == 8782 diag::note_invalid_subexpr_in_const_expr) { 8783 DiagLoc = Notes[0].first; 8784 Notes.clear(); 8785 } 8786 Diag(DiagLoc, diag::err_constexpr_var_requires_const_init) 8787 << var << Init->getSourceRange(); 8788 for (unsigned I = 0, N = Notes.size(); I != N; ++I) 8789 Diag(Notes[I].first, Notes[I].second); 8790 } 8791 } else if (var->isUsableInConstantExpressions(Context)) { 8792 // Check whether the initializer of a const variable of integral or 8793 // enumeration type is an ICE now, since we can't tell whether it was 8794 // initialized by a constant expression if we check later. 8795 var->checkInitIsICE(); 8796 } 8797 } 8798 8799 // Require the destructor. 8800 if (const RecordType *recordType = baseType->getAs<RecordType>()) 8801 FinalizeVarWithDestructor(var, recordType); 8802} 8803 8804/// FinalizeDeclaration - called by ParseDeclarationAfterDeclarator to perform 8805/// any semantic actions necessary after any initializer has been attached. 8806void 8807Sema::FinalizeDeclaration(Decl *ThisDecl) { 8808 // Note that we are no longer parsing the initializer for this declaration. 8809 ParsingInitForAutoVars.erase(ThisDecl); 8810 8811 VarDecl *VD = dyn_cast_or_null<VarDecl>(ThisDecl); 8812 if (!VD) 8813 return; 8814 8815 if (UsedAttr *Attr = VD->getAttr<UsedAttr>()) { 8816 if (!Attr->isInherited() && !VD->isThisDeclarationADefinition()) { 8817 Diag(Attr->getLocation(), diag::warn_attribute_ignored) << "used"; 8818 VD->dropAttr<UsedAttr>(); 8819 } 8820 } 8821 8822 const DeclContext *DC = VD->getDeclContext(); 8823 // If there's a #pragma GCC visibility in scope, and this isn't a class 8824 // member, set the visibility of this variable. 8825 if (!DC->isRecord() && VD->isExternallyVisible()) 8826 AddPushedVisibilityAttribute(VD); 8827 8828 if (VD->isFileVarDecl()) 8829 MarkUnusedFileScopedDecl(VD); 8830 8831 // Now we have parsed the initializer and can update the table of magic 8832 // tag values. 8833 if (!VD->hasAttr<TypeTagForDatatypeAttr>() || 8834 !VD->getType()->isIntegralOrEnumerationType()) 8835 return; 8836 8837 for (specific_attr_iterator<TypeTagForDatatypeAttr> 8838 I = ThisDecl->specific_attr_begin<TypeTagForDatatypeAttr>(), 8839 E = ThisDecl->specific_attr_end<TypeTagForDatatypeAttr>(); 8840 I != E; ++I) { 8841 const Expr *MagicValueExpr = VD->getInit(); 8842 if (!MagicValueExpr) { 8843 continue; 8844 } 8845 llvm::APSInt MagicValueInt; 8846 if (!MagicValueExpr->isIntegerConstantExpr(MagicValueInt, Context)) { 8847 Diag(I->getRange().getBegin(), 8848 diag::err_type_tag_for_datatype_not_ice) 8849 << LangOpts.CPlusPlus << MagicValueExpr->getSourceRange(); 8850 continue; 8851 } 8852 if (MagicValueInt.getActiveBits() > 64) { 8853 Diag(I->getRange().getBegin(), 8854 diag::err_type_tag_for_datatype_too_large) 8855 << LangOpts.CPlusPlus << MagicValueExpr->getSourceRange(); 8856 continue; 8857 } 8858 uint64_t MagicValue = MagicValueInt.getZExtValue(); 8859 RegisterTypeTagForDatatype(I->getArgumentKind(), 8860 MagicValue, 8861 I->getMatchingCType(), 8862 I->getLayoutCompatible(), 8863 I->getMustBeNull()); 8864 } 8865} 8866 8867Sema::DeclGroupPtrTy Sema::FinalizeDeclaratorGroup(Scope *S, const DeclSpec &DS, 8868 ArrayRef<Decl *> Group) { 8869 SmallVector<Decl*, 8> Decls; 8870 8871 if (DS.isTypeSpecOwned()) 8872 Decls.push_back(DS.getRepAsDecl()); 8873 8874 DeclaratorDecl *FirstDeclaratorInGroup = 0; 8875 for (unsigned i = 0, e = Group.size(); i != e; ++i) 8876 if (Decl *D = Group[i]) { 8877 if (DeclaratorDecl *DD = dyn_cast<DeclaratorDecl>(D)) 8878 if (!FirstDeclaratorInGroup) 8879 FirstDeclaratorInGroup = DD; 8880 Decls.push_back(D); 8881 } 8882 8883 if (DeclSpec::isDeclRep(DS.getTypeSpecType())) { 8884 if (TagDecl *Tag = dyn_cast_or_null<TagDecl>(DS.getRepAsDecl())) { 8885 HandleTagNumbering(*this, Tag); 8886 if (!Tag->hasNameForLinkage() && !Tag->hasDeclaratorForAnonDecl()) 8887 Tag->setDeclaratorForAnonDecl(FirstDeclaratorInGroup); 8888 } 8889 } 8890 8891 return BuildDeclaratorGroup(Decls, DS.containsPlaceholderType()); 8892} 8893 8894/// BuildDeclaratorGroup - convert a list of declarations into a declaration 8895/// group, performing any necessary semantic checking. 8896Sema::DeclGroupPtrTy 8897Sema::BuildDeclaratorGroup(llvm::MutableArrayRef<Decl *> Group, 8898 bool TypeMayContainAuto) { 8899 // C++0x [dcl.spec.auto]p7: 8900 // If the type deduced for the template parameter U is not the same in each 8901 // deduction, the program is ill-formed. 8902 // FIXME: When initializer-list support is added, a distinction is needed 8903 // between the deduced type U and the deduced type which 'auto' stands for. 8904 // auto a = 0, b = { 1, 2, 3 }; 8905 // is legal because the deduced type U is 'int' in both cases. 8906 if (TypeMayContainAuto && Group.size() > 1) { 8907 QualType Deduced; 8908 CanQualType DeducedCanon; 8909 VarDecl *DeducedDecl = 0; 8910 for (unsigned i = 0, e = Group.size(); i != e; ++i) { 8911 if (VarDecl *D = dyn_cast<VarDecl>(Group[i])) { 8912 AutoType *AT = D->getType()->getContainedAutoType(); 8913 // Don't reissue diagnostics when instantiating a template. 8914 if (AT && D->isInvalidDecl()) 8915 break; 8916 QualType U = AT ? AT->getDeducedType() : QualType(); 8917 if (!U.isNull()) { 8918 CanQualType UCanon = Context.getCanonicalType(U); 8919 if (Deduced.isNull()) { 8920 Deduced = U; 8921 DeducedCanon = UCanon; 8922 DeducedDecl = D; 8923 } else if (DeducedCanon != UCanon) { 8924 Diag(D->getTypeSourceInfo()->getTypeLoc().getBeginLoc(), 8925 diag::err_auto_different_deductions) 8926 << (AT->isDecltypeAuto() ? 1 : 0) 8927 << Deduced << DeducedDecl->getDeclName() 8928 << U << D->getDeclName() 8929 << DeducedDecl->getInit()->getSourceRange() 8930 << D->getInit()->getSourceRange(); 8931 D->setInvalidDecl(); 8932 break; 8933 } 8934 } 8935 } 8936 } 8937 } 8938 8939 ActOnDocumentableDecls(Group); 8940 8941 return DeclGroupPtrTy::make( 8942 DeclGroupRef::Create(Context, Group.data(), Group.size())); 8943} 8944 8945void Sema::ActOnDocumentableDecl(Decl *D) { 8946 ActOnDocumentableDecls(D); 8947} 8948 8949void Sema::ActOnDocumentableDecls(ArrayRef<Decl *> Group) { 8950 // Don't parse the comment if Doxygen diagnostics are ignored. 8951 if (Group.empty() || !Group[0]) 8952 return; 8953 8954 if (Diags.getDiagnosticLevel(diag::warn_doc_param_not_found, 8955 Group[0]->getLocation()) 8956 == DiagnosticsEngine::Ignored) 8957 return; 8958 8959 if (Group.size() >= 2) { 8960 // This is a decl group. Normally it will contain only declarations 8961 // produced from declarator list. But in case we have any definitions or 8962 // additional declaration references: 8963 // 'typedef struct S {} S;' 8964 // 'typedef struct S *S;' 8965 // 'struct S *pS;' 8966 // FinalizeDeclaratorGroup adds these as separate declarations. 8967 Decl *MaybeTagDecl = Group[0]; 8968 if (MaybeTagDecl && isa<TagDecl>(MaybeTagDecl)) { 8969 Group = Group.slice(1); 8970 } 8971 } 8972 8973 // See if there are any new comments that are not attached to a decl. 8974 ArrayRef<RawComment *> Comments = Context.getRawCommentList().getComments(); 8975 if (!Comments.empty() && 8976 !Comments.back()->isAttached()) { 8977 // There is at least one comment that not attached to a decl. 8978 // Maybe it should be attached to one of these decls? 8979 // 8980 // Note that this way we pick up not only comments that precede the 8981 // declaration, but also comments that *follow* the declaration -- thanks to 8982 // the lookahead in the lexer: we've consumed the semicolon and looked 8983 // ahead through comments. 8984 for (unsigned i = 0, e = Group.size(); i != e; ++i) 8985 Context.getCommentForDecl(Group[i], &PP); 8986 } 8987} 8988 8989/// ActOnParamDeclarator - Called from Parser::ParseFunctionDeclarator() 8990/// to introduce parameters into function prototype scope. 8991Decl *Sema::ActOnParamDeclarator(Scope *S, Declarator &D) { 8992 const DeclSpec &DS = D.getDeclSpec(); 8993 8994 // Verify C99 6.7.5.3p2: The only SCS allowed is 'register'. 8995 8996 // C++03 [dcl.stc]p2 also permits 'auto'. 8997 VarDecl::StorageClass StorageClass = SC_None; 8998 if (DS.getStorageClassSpec() == DeclSpec::SCS_register) { 8999 StorageClass = SC_Register; 9000 } else if (getLangOpts().CPlusPlus && 9001 DS.getStorageClassSpec() == DeclSpec::SCS_auto) { 9002 StorageClass = SC_Auto; 9003 } else if (DS.getStorageClassSpec() != DeclSpec::SCS_unspecified) { 9004 Diag(DS.getStorageClassSpecLoc(), 9005 diag::err_invalid_storage_class_in_func_decl); 9006 D.getMutableDeclSpec().ClearStorageClassSpecs(); 9007 } 9008 9009 if (DeclSpec::TSCS TSCS = DS.getThreadStorageClassSpec()) 9010 Diag(DS.getThreadStorageClassSpecLoc(), diag::err_invalid_thread) 9011 << DeclSpec::getSpecifierName(TSCS); 9012 if (DS.isConstexprSpecified()) 9013 Diag(DS.getConstexprSpecLoc(), diag::err_invalid_constexpr) 9014 << 0; 9015 9016 DiagnoseFunctionSpecifiers(DS); 9017 9018 TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S); 9019 QualType parmDeclType = TInfo->getType(); 9020 9021 if (getLangOpts().CPlusPlus) { 9022 // Check that there are no default arguments inside the type of this 9023 // parameter. 9024 CheckExtraCXXDefaultArguments(D); 9025 9026 // Parameter declarators cannot be qualified (C++ [dcl.meaning]p1). 9027 if (D.getCXXScopeSpec().isSet()) { 9028 Diag(D.getIdentifierLoc(), diag::err_qualified_param_declarator) 9029 << D.getCXXScopeSpec().getRange(); 9030 D.getCXXScopeSpec().clear(); 9031 } 9032 } 9033 9034 // Ensure we have a valid name 9035 IdentifierInfo *II = 0; 9036 if (D.hasName()) { 9037 II = D.getIdentifier(); 9038 if (!II) { 9039 Diag(D.getIdentifierLoc(), diag::err_bad_parameter_name) 9040 << GetNameForDeclarator(D).getName().getAsString(); 9041 D.setInvalidType(true); 9042 } 9043 } 9044 9045 // Check for redeclaration of parameters, e.g. int foo(int x, int x); 9046 if (II) { 9047 LookupResult R(*this, II, D.getIdentifierLoc(), LookupOrdinaryName, 9048 ForRedeclaration); 9049 LookupName(R, S); 9050 if (R.isSingleResult()) { 9051 NamedDecl *PrevDecl = R.getFoundDecl(); 9052 if (PrevDecl->isTemplateParameter()) { 9053 // Maybe we will complain about the shadowed template parameter. 9054 DiagnoseTemplateParameterShadow(D.getIdentifierLoc(), PrevDecl); 9055 // Just pretend that we didn't see the previous declaration. 9056 PrevDecl = 0; 9057 } else if (S->isDeclScope(PrevDecl)) { 9058 Diag(D.getIdentifierLoc(), diag::err_param_redefinition) << II; 9059 Diag(PrevDecl->getLocation(), diag::note_previous_declaration); 9060 9061 // Recover by removing the name 9062 II = 0; 9063 D.SetIdentifier(0, D.getIdentifierLoc()); 9064 D.setInvalidType(true); 9065 } 9066 } 9067 } 9068 9069 // Temporarily put parameter variables in the translation unit, not 9070 // the enclosing context. This prevents them from accidentally 9071 // looking like class members in C++. 9072 ParmVarDecl *New = CheckParameter(Context.getTranslationUnitDecl(), 9073 D.getLocStart(), 9074 D.getIdentifierLoc(), II, 9075 parmDeclType, TInfo, 9076 StorageClass); 9077 9078 if (D.isInvalidType()) 9079 New->setInvalidDecl(); 9080 9081 assert(S->isFunctionPrototypeScope()); 9082 assert(S->getFunctionPrototypeDepth() >= 1); 9083 New->setScopeInfo(S->getFunctionPrototypeDepth() - 1, 9084 S->getNextFunctionPrototypeIndex()); 9085 9086 // Add the parameter declaration into this scope. 9087 S->AddDecl(New); 9088 if (II) 9089 IdResolver.AddDecl(New); 9090 9091 ProcessDeclAttributes(S, New, D); 9092 9093 if (D.getDeclSpec().isModulePrivateSpecified()) 9094 Diag(New->getLocation(), diag::err_module_private_local) 9095 << 1 << New->getDeclName() 9096 << SourceRange(D.getDeclSpec().getModulePrivateSpecLoc()) 9097 << FixItHint::CreateRemoval(D.getDeclSpec().getModulePrivateSpecLoc()); 9098 9099 if (New->hasAttr<BlocksAttr>()) { 9100 Diag(New->getLocation(), diag::err_block_on_nonlocal); 9101 } 9102 return New; 9103} 9104 9105/// \brief Synthesizes a variable for a parameter arising from a 9106/// typedef. 9107ParmVarDecl *Sema::BuildParmVarDeclForTypedef(DeclContext *DC, 9108 SourceLocation Loc, 9109 QualType T) { 9110 /* FIXME: setting StartLoc == Loc. 9111 Would it be worth to modify callers so as to provide proper source 9112 location for the unnamed parameters, embedding the parameter's type? */ 9113 ParmVarDecl *Param = ParmVarDecl::Create(Context, DC, Loc, Loc, 0, 9114 T, Context.getTrivialTypeSourceInfo(T, Loc), 9115 SC_None, 0); 9116 Param->setImplicit(); 9117 return Param; 9118} 9119 9120void Sema::DiagnoseUnusedParameters(ParmVarDecl * const *Param, 9121 ParmVarDecl * const *ParamEnd) { 9122 // Don't diagnose unused-parameter errors in template instantiations; we 9123 // will already have done so in the template itself. 9124 if (!ActiveTemplateInstantiations.empty()) 9125 return; 9126 9127 for (; Param != ParamEnd; ++Param) { 9128 if (!(*Param)->isReferenced() && (*Param)->getDeclName() && 9129 !(*Param)->hasAttr<UnusedAttr>()) { 9130 Diag((*Param)->getLocation(), diag::warn_unused_parameter) 9131 << (*Param)->getDeclName(); 9132 } 9133 } 9134} 9135 9136void Sema::DiagnoseSizeOfParametersAndReturnValue(ParmVarDecl * const *Param, 9137 ParmVarDecl * const *ParamEnd, 9138 QualType ReturnTy, 9139 NamedDecl *D) { 9140 if (LangOpts.NumLargeByValueCopy == 0) // No check. 9141 return; 9142 9143 // Warn if the return value is pass-by-value and larger than the specified 9144 // threshold. 9145 if (!ReturnTy->isDependentType() && ReturnTy.isPODType(Context)) { 9146 unsigned Size = Context.getTypeSizeInChars(ReturnTy).getQuantity(); 9147 if (Size > LangOpts.NumLargeByValueCopy) 9148 Diag(D->getLocation(), diag::warn_return_value_size) 9149 << D->getDeclName() << Size; 9150 } 9151 9152 // Warn if any parameter is pass-by-value and larger than the specified 9153 // threshold. 9154 for (; Param != ParamEnd; ++Param) { 9155 QualType T = (*Param)->getType(); 9156 if (T->isDependentType() || !T.isPODType(Context)) 9157 continue; 9158 unsigned Size = Context.getTypeSizeInChars(T).getQuantity(); 9159 if (Size > LangOpts.NumLargeByValueCopy) 9160 Diag((*Param)->getLocation(), diag::warn_parameter_size) 9161 << (*Param)->getDeclName() << Size; 9162 } 9163} 9164 9165ParmVarDecl *Sema::CheckParameter(DeclContext *DC, SourceLocation StartLoc, 9166 SourceLocation NameLoc, IdentifierInfo *Name, 9167 QualType T, TypeSourceInfo *TSInfo, 9168 VarDecl::StorageClass StorageClass) { 9169 // In ARC, infer a lifetime qualifier for appropriate parameter types. 9170 if (getLangOpts().ObjCAutoRefCount && 9171 T.getObjCLifetime() == Qualifiers::OCL_None && 9172 T->isObjCLifetimeType()) { 9173 9174 Qualifiers::ObjCLifetime lifetime; 9175 9176 // Special cases for arrays: 9177 // - if it's const, use __unsafe_unretained 9178 // - otherwise, it's an error 9179 if (T->isArrayType()) { 9180 if (!T.isConstQualified()) { 9181 DelayedDiagnostics.add( 9182 sema::DelayedDiagnostic::makeForbiddenType( 9183 NameLoc, diag::err_arc_array_param_no_ownership, T, false)); 9184 } 9185 lifetime = Qualifiers::OCL_ExplicitNone; 9186 } else { 9187 lifetime = T->getObjCARCImplicitLifetime(); 9188 } 9189 T = Context.getLifetimeQualifiedType(T, lifetime); 9190 } 9191 9192 ParmVarDecl *New = ParmVarDecl::Create(Context, DC, StartLoc, NameLoc, Name, 9193 Context.getAdjustedParameterType(T), 9194 TSInfo, 9195 StorageClass, 0); 9196 9197 // Parameters can not be abstract class types. 9198 // For record types, this is done by the AbstractClassUsageDiagnoser once 9199 // the class has been completely parsed. 9200 if (!CurContext->isRecord() && 9201 RequireNonAbstractType(NameLoc, T, diag::err_abstract_type_in_decl, 9202 AbstractParamType)) 9203 New->setInvalidDecl(); 9204 9205 // Parameter declarators cannot be interface types. All ObjC objects are 9206 // passed by reference. 9207 if (T->isObjCObjectType()) { 9208 SourceLocation TypeEndLoc = TSInfo->getTypeLoc().getLocEnd(); 9209 Diag(NameLoc, 9210 diag::err_object_cannot_be_passed_returned_by_value) << 1 << T 9211 << FixItHint::CreateInsertion(TypeEndLoc, "*"); 9212 T = Context.getObjCObjectPointerType(T); 9213 New->setType(T); 9214 } 9215 9216 // ISO/IEC TR 18037 S6.7.3: "The type of an object with automatic storage 9217 // duration shall not be qualified by an address-space qualifier." 9218 // Since all parameters have automatic store duration, they can not have 9219 // an address space. 9220 if (T.getAddressSpace() != 0) { 9221 Diag(NameLoc, diag::err_arg_with_address_space); 9222 New->setInvalidDecl(); 9223 } 9224 9225 return New; 9226} 9227 9228void Sema::ActOnFinishKNRParamDeclarations(Scope *S, Declarator &D, 9229 SourceLocation LocAfterDecls) { 9230 DeclaratorChunk::FunctionTypeInfo &FTI = D.getFunctionTypeInfo(); 9231 9232 // Verify 6.9.1p6: 'every identifier in the identifier list shall be declared' 9233 // for a K&R function. 9234 if (!FTI.hasPrototype) { 9235 for (int i = FTI.NumArgs; i != 0; /* decrement in loop */) { 9236 --i; 9237 if (FTI.ArgInfo[i].Param == 0) { 9238 SmallString<256> Code; 9239 llvm::raw_svector_ostream(Code) << " int " 9240 << FTI.ArgInfo[i].Ident->getName() 9241 << ";\n"; 9242 Diag(FTI.ArgInfo[i].IdentLoc, diag::ext_param_not_declared) 9243 << FTI.ArgInfo[i].Ident 9244 << FixItHint::CreateInsertion(LocAfterDecls, Code.str()); 9245 9246 // Implicitly declare the argument as type 'int' for lack of a better 9247 // type. 9248 AttributeFactory attrs; 9249 DeclSpec DS(attrs); 9250 const char* PrevSpec; // unused 9251 unsigned DiagID; // unused 9252 DS.SetTypeSpecType(DeclSpec::TST_int, FTI.ArgInfo[i].IdentLoc, 9253 PrevSpec, DiagID); 9254 // Use the identifier location for the type source range. 9255 DS.SetRangeStart(FTI.ArgInfo[i].IdentLoc); 9256 DS.SetRangeEnd(FTI.ArgInfo[i].IdentLoc); 9257 Declarator ParamD(DS, Declarator::KNRTypeListContext); 9258 ParamD.SetIdentifier(FTI.ArgInfo[i].Ident, FTI.ArgInfo[i].IdentLoc); 9259 FTI.ArgInfo[i].Param = ActOnParamDeclarator(S, ParamD); 9260 } 9261 } 9262 } 9263} 9264 9265Decl *Sema::ActOnStartOfFunctionDef(Scope *FnBodyScope, Declarator &D) { 9266 assert(getCurFunctionDecl() == 0 && "Function parsing confused"); 9267 assert(D.isFunctionDeclarator() && "Not a function declarator!"); 9268 Scope *ParentScope = FnBodyScope->getParent(); 9269 9270 D.setFunctionDefinitionKind(FDK_Definition); 9271 Decl *DP = HandleDeclarator(ParentScope, D, MultiTemplateParamsArg()); 9272 return ActOnStartOfFunctionDef(FnBodyScope, DP); 9273} 9274 9275static bool ShouldWarnAboutMissingPrototype(const FunctionDecl *FD, 9276 const FunctionDecl*& PossibleZeroParamPrototype) { 9277 // Don't warn about invalid declarations. 9278 if (FD->isInvalidDecl()) 9279 return false; 9280 9281 // Or declarations that aren't global. 9282 if (!FD->isGlobal()) 9283 return false; 9284 9285 // Don't warn about C++ member functions. 9286 if (isa<CXXMethodDecl>(FD)) 9287 return false; 9288 9289 // Don't warn about 'main'. 9290 if (FD->isMain()) 9291 return false; 9292 9293 // Don't warn about inline functions. 9294 if (FD->isInlined()) 9295 return false; 9296 9297 // Don't warn about function templates. 9298 if (FD->getDescribedFunctionTemplate()) 9299 return false; 9300 9301 // Don't warn about function template specializations. 9302 if (FD->isFunctionTemplateSpecialization()) 9303 return false; 9304 9305 // Don't warn for OpenCL kernels. 9306 if (FD->hasAttr<OpenCLKernelAttr>()) 9307 return false; 9308 9309 bool MissingPrototype = true; 9310 for (const FunctionDecl *Prev = FD->getPreviousDecl(); 9311 Prev; Prev = Prev->getPreviousDecl()) { 9312 // Ignore any declarations that occur in function or method 9313 // scope, because they aren't visible from the header. 9314 if (Prev->getLexicalDeclContext()->isFunctionOrMethod()) 9315 continue; 9316 9317 MissingPrototype = !Prev->getType()->isFunctionProtoType(); 9318 if (FD->getNumParams() == 0) 9319 PossibleZeroParamPrototype = Prev; 9320 break; 9321 } 9322 9323 return MissingPrototype; 9324} 9325 9326void Sema::CheckForFunctionRedefinition(FunctionDecl *FD) { 9327 // Don't complain if we're in GNU89 mode and the previous definition 9328 // was an extern inline function. 9329 const FunctionDecl *Definition; 9330 if (!FD->isDefined(Definition) || 9331 canRedefineFunction(Definition, getLangOpts())) 9332 return; 9333 9334 if (getLangOpts().GNUMode && Definition->isInlineSpecified() && 9335 Definition->getStorageClass() == SC_Extern) 9336 Diag(FD->getLocation(), diag::err_redefinition_extern_inline) 9337 << FD->getDeclName() << getLangOpts().CPlusPlus; 9338 else 9339 Diag(FD->getLocation(), diag::err_redefinition) << FD->getDeclName(); 9340 9341 Diag(Definition->getLocation(), diag::note_previous_definition); 9342 FD->setInvalidDecl(); 9343} 9344 9345Decl *Sema::ActOnStartOfFunctionDef(Scope *FnBodyScope, Decl *D) { 9346 // Clear the last template instantiation error context. 9347 LastTemplateInstantiationErrorContext = ActiveTemplateInstantiation(); 9348 9349 if (!D) 9350 return D; 9351 FunctionDecl *FD = 0; 9352 9353 if (FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(D)) 9354 FD = FunTmpl->getTemplatedDecl(); 9355 else 9356 FD = cast<FunctionDecl>(D); 9357 // If we are instantiating a generic lambda call operator, push 9358 // a LambdaScopeInfo onto the function stack. But use the information 9359 // that's already been calculated (ActOnLambdaExpr) when analyzing the 9360 // template version, to prime the current LambdaScopeInfo. 9361 if (isGenericLambdaCallOperatorSpecialization(FD)) { 9362 CXXMethodDecl *CallOperator = cast<CXXMethodDecl>(D); 9363 CXXRecordDecl *LambdaClass = CallOperator->getParent(); 9364 LambdaExpr *LE = LambdaClass->getLambdaExpr(); 9365 assert(LE && 9366 "No LambdaExpr of closure class when instantiating a generic lambda!"); 9367 assert(ActiveTemplateInstantiations.size() && 9368 "There should be an active template instantiation on the stack " 9369 "when instantiating a generic lambda!"); 9370 PushLambdaScope(); 9371 LambdaScopeInfo *LSI = getCurLambda(); 9372 LSI->CallOperator = CallOperator; 9373 LSI->Lambda = LambdaClass; 9374 LSI->ReturnType = CallOperator->getResultType(); 9375 9376 if (LE->getCaptureDefault() == LCD_None) 9377 LSI->ImpCaptureStyle = CapturingScopeInfo::ImpCap_None; 9378 else if (LE->getCaptureDefault() == LCD_ByCopy) 9379 LSI->ImpCaptureStyle = CapturingScopeInfo::ImpCap_LambdaByval; 9380 else if (LE->getCaptureDefault() == LCD_ByRef) 9381 LSI->ImpCaptureStyle = CapturingScopeInfo::ImpCap_LambdaByref; 9382 9383 LSI->IntroducerRange = LE->getIntroducerRange(); 9384 } 9385 else 9386 // Enter a new function scope 9387 PushFunctionScope(); 9388 9389 // See if this is a redefinition. 9390 if (!FD->isLateTemplateParsed()) 9391 CheckForFunctionRedefinition(FD); 9392 9393 // Builtin functions cannot be defined. 9394 if (unsigned BuiltinID = FD->getBuiltinID()) { 9395 if (!Context.BuiltinInfo.isPredefinedLibFunction(BuiltinID) && 9396 !Context.BuiltinInfo.isPredefinedRuntimeFunction(BuiltinID)) { 9397 Diag(FD->getLocation(), diag::err_builtin_definition) << FD; 9398 FD->setInvalidDecl(); 9399 } 9400 } 9401 9402 // The return type of a function definition must be complete 9403 // (C99 6.9.1p3, C++ [dcl.fct]p6). 9404 QualType ResultType = FD->getResultType(); 9405 if (!ResultType->isDependentType() && !ResultType->isVoidType() && 9406 !FD->isInvalidDecl() && 9407 RequireCompleteType(FD->getLocation(), ResultType, 9408 diag::err_func_def_incomplete_result)) 9409 FD->setInvalidDecl(); 9410 9411 // GNU warning -Wmissing-prototypes: 9412 // Warn if a global function is defined without a previous 9413 // prototype declaration. This warning is issued even if the 9414 // definition itself provides a prototype. The aim is to detect 9415 // global functions that fail to be declared in header files. 9416 const FunctionDecl *PossibleZeroParamPrototype = 0; 9417 if (ShouldWarnAboutMissingPrototype(FD, PossibleZeroParamPrototype)) { 9418 Diag(FD->getLocation(), diag::warn_missing_prototype) << FD; 9419 9420 if (PossibleZeroParamPrototype) { 9421 // We found a declaration that is not a prototype, 9422 // but that could be a zero-parameter prototype 9423 if (TypeSourceInfo *TI = 9424 PossibleZeroParamPrototype->getTypeSourceInfo()) { 9425 TypeLoc TL = TI->getTypeLoc(); 9426 if (FunctionNoProtoTypeLoc FTL = TL.getAs<FunctionNoProtoTypeLoc>()) 9427 Diag(PossibleZeroParamPrototype->getLocation(), 9428 diag::note_declaration_not_a_prototype) 9429 << PossibleZeroParamPrototype 9430 << FixItHint::CreateInsertion(FTL.getRParenLoc(), "void"); 9431 } 9432 } 9433 } 9434 9435 if (FnBodyScope) 9436 PushDeclContext(FnBodyScope, FD); 9437 9438 // Check the validity of our function parameters 9439 CheckParmsForFunctionDef(FD->param_begin(), FD->param_end(), 9440 /*CheckParameterNames=*/true); 9441 9442 // Introduce our parameters into the function scope 9443 for (unsigned p = 0, NumParams = FD->getNumParams(); p < NumParams; ++p) { 9444 ParmVarDecl *Param = FD->getParamDecl(p); 9445 Param->setOwningFunction(FD); 9446 9447 // If this has an identifier, add it to the scope stack. 9448 if (Param->getIdentifier() && FnBodyScope) { 9449 CheckShadow(FnBodyScope, Param); 9450 9451 PushOnScopeChains(Param, FnBodyScope); 9452 } 9453 } 9454 9455 // If we had any tags defined in the function prototype, 9456 // introduce them into the function scope. 9457 if (FnBodyScope) { 9458 for (ArrayRef<NamedDecl *>::iterator 9459 I = FD->getDeclsInPrototypeScope().begin(), 9460 E = FD->getDeclsInPrototypeScope().end(); 9461 I != E; ++I) { 9462 NamedDecl *D = *I; 9463 9464 // Some of these decls (like enums) may have been pinned to the translation unit 9465 // for lack of a real context earlier. If so, remove from the translation unit 9466 // and reattach to the current context. 9467 if (D->getLexicalDeclContext() == Context.getTranslationUnitDecl()) { 9468 // Is the decl actually in the context? 9469 for (DeclContext::decl_iterator DI = Context.getTranslationUnitDecl()->decls_begin(), 9470 DE = Context.getTranslationUnitDecl()->decls_end(); DI != DE; ++DI) { 9471 if (*DI == D) { 9472 Context.getTranslationUnitDecl()->removeDecl(D); 9473 break; 9474 } 9475 } 9476 // Either way, reassign the lexical decl context to our FunctionDecl. 9477 D->setLexicalDeclContext(CurContext); 9478 } 9479 9480 // If the decl has a non-null name, make accessible in the current scope. 9481 if (!D->getName().empty()) 9482 PushOnScopeChains(D, FnBodyScope, /*AddToContext=*/false); 9483 9484 // Similarly, dive into enums and fish their constants out, making them 9485 // accessible in this scope. 9486 if (EnumDecl *ED = dyn_cast<EnumDecl>(D)) { 9487 for (EnumDecl::enumerator_iterator EI = ED->enumerator_begin(), 9488 EE = ED->enumerator_end(); EI != EE; ++EI) 9489 PushOnScopeChains(*EI, FnBodyScope, /*AddToContext=*/false); 9490 } 9491 } 9492 } 9493 9494 // Ensure that the function's exception specification is instantiated. 9495 if (const FunctionProtoType *FPT = FD->getType()->getAs<FunctionProtoType>()) 9496 ResolveExceptionSpec(D->getLocation(), FPT); 9497 9498 // Checking attributes of current function definition 9499 // dllimport attribute. 9500 DLLImportAttr *DA = FD->getAttr<DLLImportAttr>(); 9501 if (DA && (!FD->getAttr<DLLExportAttr>())) { 9502 // dllimport attribute cannot be directly applied to definition. 9503 // Microsoft accepts dllimport for functions defined within class scope. 9504 if (!DA->isInherited() && 9505 !(LangOpts.MicrosoftExt && FD->getLexicalDeclContext()->isRecord())) { 9506 Diag(FD->getLocation(), 9507 diag::err_attribute_can_be_applied_only_to_symbol_declaration) 9508 << "dllimport"; 9509 FD->setInvalidDecl(); 9510 return D; 9511 } 9512 9513 // Visual C++ appears to not think this is an issue, so only issue 9514 // a warning when Microsoft extensions are disabled. 9515 if (!LangOpts.MicrosoftExt) { 9516 // If a symbol previously declared dllimport is later defined, the 9517 // attribute is ignored in subsequent references, and a warning is 9518 // emitted. 9519 Diag(FD->getLocation(), 9520 diag::warn_redeclaration_without_attribute_prev_attribute_ignored) 9521 << FD->getName() << "dllimport"; 9522 } 9523 } 9524 // We want to attach documentation to original Decl (which might be 9525 // a function template). 9526 ActOnDocumentableDecl(D); 9527 return D; 9528} 9529 9530/// \brief Given the set of return statements within a function body, 9531/// compute the variables that are subject to the named return value 9532/// optimization. 9533/// 9534/// Each of the variables that is subject to the named return value 9535/// optimization will be marked as NRVO variables in the AST, and any 9536/// return statement that has a marked NRVO variable as its NRVO candidate can 9537/// use the named return value optimization. 9538/// 9539/// This function applies a very simplistic algorithm for NRVO: if every return 9540/// statement in the function has the same NRVO candidate, that candidate is 9541/// the NRVO variable. 9542/// 9543/// FIXME: Employ a smarter algorithm that accounts for multiple return 9544/// statements and the lifetimes of the NRVO candidates. We should be able to 9545/// find a maximal set of NRVO variables. 9546void Sema::computeNRVO(Stmt *Body, FunctionScopeInfo *Scope) { 9547 ReturnStmt **Returns = Scope->Returns.data(); 9548 9549 const VarDecl *NRVOCandidate = 0; 9550 for (unsigned I = 0, E = Scope->Returns.size(); I != E; ++I) { 9551 if (!Returns[I]->getNRVOCandidate()) 9552 return; 9553 9554 if (!NRVOCandidate) 9555 NRVOCandidate = Returns[I]->getNRVOCandidate(); 9556 else if (NRVOCandidate != Returns[I]->getNRVOCandidate()) 9557 return; 9558 } 9559 9560 if (NRVOCandidate) 9561 const_cast<VarDecl*>(NRVOCandidate)->setNRVOVariable(true); 9562} 9563 9564bool Sema::canSkipFunctionBody(Decl *D) { 9565 if (!Consumer.shouldSkipFunctionBody(D)) 9566 return false; 9567 9568 if (isa<ObjCMethodDecl>(D)) 9569 return true; 9570 9571 FunctionDecl *FD = 0; 9572 if (FunctionTemplateDecl *FTD = dyn_cast<FunctionTemplateDecl>(D)) 9573 FD = FTD->getTemplatedDecl(); 9574 else 9575 FD = cast<FunctionDecl>(D); 9576 9577 // We cannot skip the body of a function (or function template) which is 9578 // constexpr, since we may need to evaluate its body in order to parse the 9579 // rest of the file. 9580 // We cannot skip the body of a function with an undeduced return type, 9581 // because any callers of that function need to know the type. 9582 return !FD->isConstexpr() && !FD->getResultType()->isUndeducedType(); 9583} 9584 9585Decl *Sema::ActOnSkippedFunctionBody(Decl *Decl) { 9586 if (FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(Decl)) 9587 FD->setHasSkippedBody(); 9588 else if (ObjCMethodDecl *MD = dyn_cast_or_null<ObjCMethodDecl>(Decl)) 9589 MD->setHasSkippedBody(); 9590 return ActOnFinishFunctionBody(Decl, 0); 9591} 9592 9593Decl *Sema::ActOnFinishFunctionBody(Decl *D, Stmt *BodyArg) { 9594 return ActOnFinishFunctionBody(D, BodyArg, false); 9595} 9596 9597Decl *Sema::ActOnFinishFunctionBody(Decl *dcl, Stmt *Body, 9598 bool IsInstantiation) { 9599 FunctionDecl *FD = 0; 9600 FunctionTemplateDecl *FunTmpl = dyn_cast_or_null<FunctionTemplateDecl>(dcl); 9601 if (FunTmpl) 9602 FD = FunTmpl->getTemplatedDecl(); 9603 else 9604 FD = dyn_cast_or_null<FunctionDecl>(dcl); 9605 9606 sema::AnalysisBasedWarnings::Policy WP = AnalysisWarnings.getDefaultPolicy(); 9607 sema::AnalysisBasedWarnings::Policy *ActivePolicy = 0; 9608 9609 if (FD) { 9610 FD->setBody(Body); 9611 9612 if (getLangOpts().CPlusPlus1y && !FD->isInvalidDecl() && Body && 9613 !FD->isDependentContext() && FD->getResultType()->isUndeducedType()) { 9614 // If the function has a deduced result type but contains no 'return' 9615 // statements, the result type as written must be exactly 'auto', and 9616 // the deduced result type is 'void'. 9617 if (!FD->getResultType()->getAs<AutoType>()) { 9618 Diag(dcl->getLocation(), diag::err_auto_fn_no_return_but_not_auto) 9619 << FD->getResultType(); 9620 FD->setInvalidDecl(); 9621 } else { 9622 // Substitute 'void' for the 'auto' in the type. 9623 TypeLoc ResultType = FD->getTypeSourceInfo()->getTypeLoc(). 9624 IgnoreParens().castAs<FunctionProtoTypeLoc>().getResultLoc(); 9625 Context.adjustDeducedFunctionResultType( 9626 FD, SubstAutoType(ResultType.getType(), Context.VoidTy)); 9627 } 9628 } 9629 9630 // The only way to be included in UndefinedButUsed is if there is an 9631 // ODR use before the definition. Avoid the expensive map lookup if this 9632 // is the first declaration. 9633 if (!FD->isFirstDecl() && FD->getPreviousDecl()->isUsed()) { 9634 if (!FD->isExternallyVisible()) 9635 UndefinedButUsed.erase(FD); 9636 else if (FD->isInlined() && 9637 (LangOpts.CPlusPlus || !LangOpts.GNUInline) && 9638 (!FD->getPreviousDecl()->hasAttr<GNUInlineAttr>())) 9639 UndefinedButUsed.erase(FD); 9640 } 9641 9642 // If the function implicitly returns zero (like 'main') or is naked, 9643 // don't complain about missing return statements. 9644 if (FD->hasImplicitReturnZero() || FD->hasAttr<NakedAttr>()) 9645 WP.disableCheckFallThrough(); 9646 9647 // MSVC permits the use of pure specifier (=0) on function definition, 9648 // defined at class scope, warn about this non standard construct. 9649 if (getLangOpts().MicrosoftExt && FD->isPure() && FD->isCanonicalDecl()) 9650 Diag(FD->getLocation(), diag::warn_pure_function_definition); 9651 9652 if (!FD->isInvalidDecl()) { 9653 DiagnoseUnusedParameters(FD->param_begin(), FD->param_end()); 9654 DiagnoseSizeOfParametersAndReturnValue(FD->param_begin(), FD->param_end(), 9655 FD->getResultType(), FD); 9656 9657 // If this is a constructor, we need a vtable. 9658 if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(FD)) 9659 MarkVTableUsed(FD->getLocation(), Constructor->getParent()); 9660 9661 // Try to apply the named return value optimization. We have to check 9662 // if we can do this here because lambdas keep return statements around 9663 // to deduce an implicit return type. 9664 if (getLangOpts().CPlusPlus && FD->getResultType()->isRecordType() && 9665 !FD->isDependentContext()) 9666 computeNRVO(Body, getCurFunction()); 9667 } 9668 9669 assert((FD == getCurFunctionDecl() || getCurLambda()->CallOperator == FD) && 9670 "Function parsing confused"); 9671 } else if (ObjCMethodDecl *MD = dyn_cast_or_null<ObjCMethodDecl>(dcl)) { 9672 assert(MD == getCurMethodDecl() && "Method parsing confused"); 9673 MD->setBody(Body); 9674 if (!MD->isInvalidDecl()) { 9675 DiagnoseUnusedParameters(MD->param_begin(), MD->param_end()); 9676 DiagnoseSizeOfParametersAndReturnValue(MD->param_begin(), MD->param_end(), 9677 MD->getResultType(), MD); 9678 9679 if (Body) 9680 computeNRVO(Body, getCurFunction()); 9681 } 9682 if (getCurFunction()->ObjCShouldCallSuper) { 9683 Diag(MD->getLocEnd(), diag::warn_objc_missing_super_call) 9684 << MD->getSelector().getAsString(); 9685 getCurFunction()->ObjCShouldCallSuper = false; 9686 } 9687 } else { 9688 return 0; 9689 } 9690 9691 assert(!getCurFunction()->ObjCShouldCallSuper && 9692 "This should only be set for ObjC methods, which should have been " 9693 "handled in the block above."); 9694 9695 // Verify and clean out per-function state. 9696 if (Body) { 9697 // C++ constructors that have function-try-blocks can't have return 9698 // statements in the handlers of that block. (C++ [except.handle]p14) 9699 // Verify this. 9700 if (FD && isa<CXXConstructorDecl>(FD) && isa<CXXTryStmt>(Body)) 9701 DiagnoseReturnInConstructorExceptionHandler(cast<CXXTryStmt>(Body)); 9702 9703 // Verify that gotos and switch cases don't jump into scopes illegally. 9704 if (getCurFunction()->NeedsScopeChecking() && 9705 !dcl->isInvalidDecl() && 9706 !hasAnyUnrecoverableErrorsInThisFunction() && 9707 !PP.isCodeCompletionEnabled()) 9708 DiagnoseInvalidJumps(Body); 9709 9710 if (CXXDestructorDecl *Destructor = dyn_cast<CXXDestructorDecl>(dcl)) { 9711 if (!Destructor->getParent()->isDependentType()) 9712 CheckDestructor(Destructor); 9713 9714 MarkBaseAndMemberDestructorsReferenced(Destructor->getLocation(), 9715 Destructor->getParent()); 9716 } 9717 9718 // If any errors have occurred, clear out any temporaries that may have 9719 // been leftover. This ensures that these temporaries won't be picked up for 9720 // deletion in some later function. 9721 if (PP.getDiagnostics().hasErrorOccurred() || 9722 PP.getDiagnostics().getSuppressAllDiagnostics()) { 9723 DiscardCleanupsInEvaluationContext(); 9724 } 9725 if (!PP.getDiagnostics().hasUncompilableErrorOccurred() && 9726 !isa<FunctionTemplateDecl>(dcl)) { 9727 // Since the body is valid, issue any analysis-based warnings that are 9728 // enabled. 9729 ActivePolicy = &WP; 9730 } 9731 9732 if (!IsInstantiation && FD && FD->isConstexpr() && !FD->isInvalidDecl() && 9733 (!CheckConstexprFunctionDecl(FD) || 9734 !CheckConstexprFunctionBody(FD, Body))) 9735 FD->setInvalidDecl(); 9736 9737 assert(ExprCleanupObjects.empty() && "Leftover temporaries in function"); 9738 assert(!ExprNeedsCleanups && "Unaccounted cleanups in function"); 9739 assert(MaybeODRUseExprs.empty() && 9740 "Leftover expressions for odr-use checking"); 9741 } 9742 9743 if (!IsInstantiation) 9744 PopDeclContext(); 9745 9746 PopFunctionScopeInfo(ActivePolicy, dcl); 9747 9748 // If any errors have occurred, clear out any temporaries that may have 9749 // been leftover. This ensures that these temporaries won't be picked up for 9750 // deletion in some later function. 9751 if (getDiagnostics().hasErrorOccurred()) { 9752 DiscardCleanupsInEvaluationContext(); 9753 } 9754 9755 return dcl; 9756} 9757 9758 9759/// When we finish delayed parsing of an attribute, we must attach it to the 9760/// relevant Decl. 9761void Sema::ActOnFinishDelayedAttribute(Scope *S, Decl *D, 9762 ParsedAttributes &Attrs) { 9763 // Always attach attributes to the underlying decl. 9764 if (TemplateDecl *TD = dyn_cast<TemplateDecl>(D)) 9765 D = TD->getTemplatedDecl(); 9766 ProcessDeclAttributeList(S, D, Attrs.getList()); 9767 9768 if (CXXMethodDecl *Method = dyn_cast_or_null<CXXMethodDecl>(D)) 9769 if (Method->isStatic()) 9770 checkThisInStaticMemberFunctionAttributes(Method); 9771} 9772 9773 9774/// ImplicitlyDefineFunction - An undeclared identifier was used in a function 9775/// call, forming a call to an implicitly defined function (per C99 6.5.1p2). 9776NamedDecl *Sema::ImplicitlyDefineFunction(SourceLocation Loc, 9777 IdentifierInfo &II, Scope *S) { 9778 // Before we produce a declaration for an implicitly defined 9779 // function, see whether there was a locally-scoped declaration of 9780 // this name as a function or variable. If so, use that 9781 // (non-visible) declaration, and complain about it. 9782 if (NamedDecl *ExternCPrev = findLocallyScopedExternCDecl(&II)) { 9783 Diag(Loc, diag::warn_use_out_of_scope_declaration) << ExternCPrev; 9784 Diag(ExternCPrev->getLocation(), diag::note_previous_declaration); 9785 return ExternCPrev; 9786 } 9787 9788 // Extension in C99. Legal in C90, but warn about it. 9789 unsigned diag_id; 9790 if (II.getName().startswith("__builtin_")) 9791 diag_id = diag::warn_builtin_unknown; 9792 else if (getLangOpts().C99) 9793 diag_id = diag::ext_implicit_function_decl; 9794 else 9795 diag_id = diag::warn_implicit_function_decl; 9796 Diag(Loc, diag_id) << &II; 9797 9798 // Because typo correction is expensive, only do it if the implicit 9799 // function declaration is going to be treated as an error. 9800 if (Diags.getDiagnosticLevel(diag_id, Loc) >= DiagnosticsEngine::Error) { 9801 TypoCorrection Corrected; 9802 DeclFilterCCC<FunctionDecl> Validator; 9803 if (S && (Corrected = CorrectTypo(DeclarationNameInfo(&II, Loc), 9804 LookupOrdinaryName, S, 0, Validator))) 9805 diagnoseTypo(Corrected, PDiag(diag::note_function_suggestion), 9806 /*ErrorRecovery*/false); 9807 } 9808 9809 // Set a Declarator for the implicit definition: int foo(); 9810 const char *Dummy; 9811 AttributeFactory attrFactory; 9812 DeclSpec DS(attrFactory); 9813 unsigned DiagID; 9814 bool Error = DS.SetTypeSpecType(DeclSpec::TST_int, Loc, Dummy, DiagID); 9815 (void)Error; // Silence warning. 9816 assert(!Error && "Error setting up implicit decl!"); 9817 SourceLocation NoLoc; 9818 Declarator D(DS, Declarator::BlockContext); 9819 D.AddTypeInfo(DeclaratorChunk::getFunction(/*HasProto=*/false, 9820 /*IsAmbiguous=*/false, 9821 /*RParenLoc=*/NoLoc, 9822 /*ArgInfo=*/0, 9823 /*NumArgs=*/0, 9824 /*EllipsisLoc=*/NoLoc, 9825 /*RParenLoc=*/NoLoc, 9826 /*TypeQuals=*/0, 9827 /*RefQualifierIsLvalueRef=*/true, 9828 /*RefQualifierLoc=*/NoLoc, 9829 /*ConstQualifierLoc=*/NoLoc, 9830 /*VolatileQualifierLoc=*/NoLoc, 9831 /*MutableLoc=*/NoLoc, 9832 EST_None, 9833 /*ESpecLoc=*/NoLoc, 9834 /*Exceptions=*/0, 9835 /*ExceptionRanges=*/0, 9836 /*NumExceptions=*/0, 9837 /*NoexceptExpr=*/0, 9838 Loc, Loc, D), 9839 DS.getAttributes(), 9840 SourceLocation()); 9841 D.SetIdentifier(&II, Loc); 9842 9843 // Insert this function into translation-unit scope. 9844 9845 DeclContext *PrevDC = CurContext; 9846 CurContext = Context.getTranslationUnitDecl(); 9847 9848 FunctionDecl *FD = cast<FunctionDecl>(ActOnDeclarator(TUScope, D)); 9849 FD->setImplicit(); 9850 9851 CurContext = PrevDC; 9852 9853 AddKnownFunctionAttributes(FD); 9854 9855 return FD; 9856} 9857 9858/// \brief Adds any function attributes that we know a priori based on 9859/// the declaration of this function. 9860/// 9861/// These attributes can apply both to implicitly-declared builtins 9862/// (like __builtin___printf_chk) or to library-declared functions 9863/// like NSLog or printf. 9864/// 9865/// We need to check for duplicate attributes both here and where user-written 9866/// attributes are applied to declarations. 9867void Sema::AddKnownFunctionAttributes(FunctionDecl *FD) { 9868 if (FD->isInvalidDecl()) 9869 return; 9870 9871 // If this is a built-in function, map its builtin attributes to 9872 // actual attributes. 9873 if (unsigned BuiltinID = FD->getBuiltinID()) { 9874 // Handle printf-formatting attributes. 9875 unsigned FormatIdx; 9876 bool HasVAListArg; 9877 if (Context.BuiltinInfo.isPrintfLike(BuiltinID, FormatIdx, HasVAListArg)) { 9878 if (!FD->getAttr<FormatAttr>()) { 9879 const char *fmt = "printf"; 9880 unsigned int NumParams = FD->getNumParams(); 9881 if (FormatIdx < NumParams && // NumParams may be 0 (e.g. vfprintf) 9882 FD->getParamDecl(FormatIdx)->getType()->isObjCObjectPointerType()) 9883 fmt = "NSString"; 9884 FD->addAttr(::new (Context) FormatAttr(FD->getLocation(), Context, 9885 &Context.Idents.get(fmt), 9886 FormatIdx+1, 9887 HasVAListArg ? 0 : FormatIdx+2)); 9888 } 9889 } 9890 if (Context.BuiltinInfo.isScanfLike(BuiltinID, FormatIdx, 9891 HasVAListArg)) { 9892 if (!FD->getAttr<FormatAttr>()) 9893 FD->addAttr(::new (Context) FormatAttr(FD->getLocation(), Context, 9894 &Context.Idents.get("scanf"), 9895 FormatIdx+1, 9896 HasVAListArg ? 0 : FormatIdx+2)); 9897 } 9898 9899 // Mark const if we don't care about errno and that is the only 9900 // thing preventing the function from being const. This allows 9901 // IRgen to use LLVM intrinsics for such functions. 9902 if (!getLangOpts().MathErrno && 9903 Context.BuiltinInfo.isConstWithoutErrno(BuiltinID)) { 9904 if (!FD->getAttr<ConstAttr>()) 9905 FD->addAttr(::new (Context) ConstAttr(FD->getLocation(), Context)); 9906 } 9907 9908 if (Context.BuiltinInfo.isReturnsTwice(BuiltinID) && 9909 !FD->getAttr<ReturnsTwiceAttr>()) 9910 FD->addAttr(::new (Context) ReturnsTwiceAttr(FD->getLocation(), Context)); 9911 if (Context.BuiltinInfo.isNoThrow(BuiltinID) && !FD->getAttr<NoThrowAttr>()) 9912 FD->addAttr(::new (Context) NoThrowAttr(FD->getLocation(), Context)); 9913 if (Context.BuiltinInfo.isConst(BuiltinID) && !FD->getAttr<ConstAttr>()) 9914 FD->addAttr(::new (Context) ConstAttr(FD->getLocation(), Context)); 9915 } 9916 9917 IdentifierInfo *Name = FD->getIdentifier(); 9918 if (!Name) 9919 return; 9920 if ((!getLangOpts().CPlusPlus && 9921 FD->getDeclContext()->isTranslationUnit()) || 9922 (isa<LinkageSpecDecl>(FD->getDeclContext()) && 9923 cast<LinkageSpecDecl>(FD->getDeclContext())->getLanguage() == 9924 LinkageSpecDecl::lang_c)) { 9925 // Okay: this could be a libc/libm/Objective-C function we know 9926 // about. 9927 } else 9928 return; 9929 9930 if (Name->isStr("asprintf") || Name->isStr("vasprintf")) { 9931 // FIXME: asprintf and vasprintf aren't C99 functions. Should they be 9932 // target-specific builtins, perhaps? 9933 if (!FD->getAttr<FormatAttr>()) 9934 FD->addAttr(::new (Context) FormatAttr(FD->getLocation(), Context, 9935 &Context.Idents.get("printf"), 2, 9936 Name->isStr("vasprintf") ? 0 : 3)); 9937 } 9938 9939 if (Name->isStr("__CFStringMakeConstantString")) { 9940 // We already have a __builtin___CFStringMakeConstantString, 9941 // but builds that use -fno-constant-cfstrings don't go through that. 9942 if (!FD->getAttr<FormatArgAttr>()) 9943 FD->addAttr(::new (Context) FormatArgAttr(FD->getLocation(), Context, 1)); 9944 } 9945} 9946 9947TypedefDecl *Sema::ParseTypedefDecl(Scope *S, Declarator &D, QualType T, 9948 TypeSourceInfo *TInfo) { 9949 assert(D.getIdentifier() && "Wrong callback for declspec without declarator"); 9950 assert(!T.isNull() && "GetTypeForDeclarator() returned null type"); 9951 9952 if (!TInfo) { 9953 assert(D.isInvalidType() && "no declarator info for valid type"); 9954 TInfo = Context.getTrivialTypeSourceInfo(T); 9955 } 9956 9957 // Scope manipulation handled by caller. 9958 TypedefDecl *NewTD = TypedefDecl::Create(Context, CurContext, 9959 D.getLocStart(), 9960 D.getIdentifierLoc(), 9961 D.getIdentifier(), 9962 TInfo); 9963 9964 // Bail out immediately if we have an invalid declaration. 9965 if (D.isInvalidType()) { 9966 NewTD->setInvalidDecl(); 9967 return NewTD; 9968 } 9969 9970 if (D.getDeclSpec().isModulePrivateSpecified()) { 9971 if (CurContext->isFunctionOrMethod()) 9972 Diag(NewTD->getLocation(), diag::err_module_private_local) 9973 << 2 << NewTD->getDeclName() 9974 << SourceRange(D.getDeclSpec().getModulePrivateSpecLoc()) 9975 << FixItHint::CreateRemoval(D.getDeclSpec().getModulePrivateSpecLoc()); 9976 else 9977 NewTD->setModulePrivate(); 9978 } 9979 9980 // C++ [dcl.typedef]p8: 9981 // If the typedef declaration defines an unnamed class (or 9982 // enum), the first typedef-name declared by the declaration 9983 // to be that class type (or enum type) is used to denote the 9984 // class type (or enum type) for linkage purposes only. 9985 // We need to check whether the type was declared in the declaration. 9986 switch (D.getDeclSpec().getTypeSpecType()) { 9987 case TST_enum: 9988 case TST_struct: 9989 case TST_interface: 9990 case TST_union: 9991 case TST_class: { 9992 TagDecl *tagFromDeclSpec = cast<TagDecl>(D.getDeclSpec().getRepAsDecl()); 9993 9994 // Do nothing if the tag is not anonymous or already has an 9995 // associated typedef (from an earlier typedef in this decl group). 9996 if (tagFromDeclSpec->getIdentifier()) break; 9997 if (tagFromDeclSpec->getTypedefNameForAnonDecl()) break; 9998 9999 // A well-formed anonymous tag must always be a TUK_Definition. 10000 assert(tagFromDeclSpec->isThisDeclarationADefinition()); 10001 10002 // The type must match the tag exactly; no qualifiers allowed. 10003 if (!Context.hasSameType(T, Context.getTagDeclType(tagFromDeclSpec))) 10004 break; 10005 10006 // Otherwise, set this is the anon-decl typedef for the tag. 10007 tagFromDeclSpec->setTypedefNameForAnonDecl(NewTD); 10008 break; 10009 } 10010 10011 default: 10012 break; 10013 } 10014 10015 return NewTD; 10016} 10017 10018 10019/// \brief Check that this is a valid underlying type for an enum declaration. 10020bool Sema::CheckEnumUnderlyingType(TypeSourceInfo *TI) { 10021 SourceLocation UnderlyingLoc = TI->getTypeLoc().getBeginLoc(); 10022 QualType T = TI->getType(); 10023 10024 if (T->isDependentType()) 10025 return false; 10026 10027 if (const BuiltinType *BT = T->getAs<BuiltinType>()) 10028 if (BT->isInteger()) 10029 return false; 10030 10031 Diag(UnderlyingLoc, diag::err_enum_invalid_underlying) << T; 10032 return true; 10033} 10034 10035/// Check whether this is a valid redeclaration of a previous enumeration. 10036/// \return true if the redeclaration was invalid. 10037bool Sema::CheckEnumRedeclaration(SourceLocation EnumLoc, bool IsScoped, 10038 QualType EnumUnderlyingTy, 10039 const EnumDecl *Prev) { 10040 bool IsFixed = !EnumUnderlyingTy.isNull(); 10041 10042 if (IsScoped != Prev->isScoped()) { 10043 Diag(EnumLoc, diag::err_enum_redeclare_scoped_mismatch) 10044 << Prev->isScoped(); 10045 Diag(Prev->getLocation(), diag::note_previous_use); 10046 return true; 10047 } 10048 10049 if (IsFixed && Prev->isFixed()) { 10050 if (!EnumUnderlyingTy->isDependentType() && 10051 !Prev->getIntegerType()->isDependentType() && 10052 !Context.hasSameUnqualifiedType(EnumUnderlyingTy, 10053 Prev->getIntegerType())) { 10054 Diag(EnumLoc, diag::err_enum_redeclare_type_mismatch) 10055 << EnumUnderlyingTy << Prev->getIntegerType(); 10056 Diag(Prev->getLocation(), diag::note_previous_use); 10057 return true; 10058 } 10059 } else if (IsFixed != Prev->isFixed()) { 10060 Diag(EnumLoc, diag::err_enum_redeclare_fixed_mismatch) 10061 << Prev->isFixed(); 10062 Diag(Prev->getLocation(), diag::note_previous_use); 10063 return true; 10064 } 10065 10066 return false; 10067} 10068 10069/// \brief Get diagnostic %select index for tag kind for 10070/// redeclaration diagnostic message. 10071/// WARNING: Indexes apply to particular diagnostics only! 10072/// 10073/// \returns diagnostic %select index. 10074static unsigned getRedeclDiagFromTagKind(TagTypeKind Tag) { 10075 switch (Tag) { 10076 case TTK_Struct: return 0; 10077 case TTK_Interface: return 1; 10078 case TTK_Class: return 2; 10079 default: llvm_unreachable("Invalid tag kind for redecl diagnostic!"); 10080 } 10081} 10082 10083/// \brief Determine if tag kind is a class-key compatible with 10084/// class for redeclaration (class, struct, or __interface). 10085/// 10086/// \returns true iff the tag kind is compatible. 10087static bool isClassCompatTagKind(TagTypeKind Tag) 10088{ 10089 return Tag == TTK_Struct || Tag == TTK_Class || Tag == TTK_Interface; 10090} 10091 10092/// \brief Determine whether a tag with a given kind is acceptable 10093/// as a redeclaration of the given tag declaration. 10094/// 10095/// \returns true if the new tag kind is acceptable, false otherwise. 10096bool Sema::isAcceptableTagRedeclaration(const TagDecl *Previous, 10097 TagTypeKind NewTag, bool isDefinition, 10098 SourceLocation NewTagLoc, 10099 const IdentifierInfo &Name) { 10100 // C++ [dcl.type.elab]p3: 10101 // The class-key or enum keyword present in the 10102 // elaborated-type-specifier shall agree in kind with the 10103 // declaration to which the name in the elaborated-type-specifier 10104 // refers. This rule also applies to the form of 10105 // elaborated-type-specifier that declares a class-name or 10106 // friend class since it can be construed as referring to the 10107 // definition of the class. Thus, in any 10108 // elaborated-type-specifier, the enum keyword shall be used to 10109 // refer to an enumeration (7.2), the union class-key shall be 10110 // used to refer to a union (clause 9), and either the class or 10111 // struct class-key shall be used to refer to a class (clause 9) 10112 // declared using the class or struct class-key. 10113 TagTypeKind OldTag = Previous->getTagKind(); 10114 if (!isDefinition || !isClassCompatTagKind(NewTag)) 10115 if (OldTag == NewTag) 10116 return true; 10117 10118 if (isClassCompatTagKind(OldTag) && isClassCompatTagKind(NewTag)) { 10119 // Warn about the struct/class tag mismatch. 10120 bool isTemplate = false; 10121 if (const CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(Previous)) 10122 isTemplate = Record->getDescribedClassTemplate(); 10123 10124 if (!ActiveTemplateInstantiations.empty()) { 10125 // In a template instantiation, do not offer fix-its for tag mismatches 10126 // since they usually mess up the template instead of fixing the problem. 10127 Diag(NewTagLoc, diag::warn_struct_class_tag_mismatch) 10128 << getRedeclDiagFromTagKind(NewTag) << isTemplate << &Name 10129 << getRedeclDiagFromTagKind(OldTag); 10130 return true; 10131 } 10132 10133 if (isDefinition) { 10134 // On definitions, check previous tags and issue a fix-it for each 10135 // one that doesn't match the current tag. 10136 if (Previous->getDefinition()) { 10137 // Don't suggest fix-its for redefinitions. 10138 return true; 10139 } 10140 10141 bool previousMismatch = false; 10142 for (TagDecl::redecl_iterator I(Previous->redecls_begin()), 10143 E(Previous->redecls_end()); I != E; ++I) { 10144 if (I->getTagKind() != NewTag) { 10145 if (!previousMismatch) { 10146 previousMismatch = true; 10147 Diag(NewTagLoc, diag::warn_struct_class_previous_tag_mismatch) 10148 << getRedeclDiagFromTagKind(NewTag) << isTemplate << &Name 10149 << getRedeclDiagFromTagKind(I->getTagKind()); 10150 } 10151 Diag(I->getInnerLocStart(), diag::note_struct_class_suggestion) 10152 << getRedeclDiagFromTagKind(NewTag) 10153 << FixItHint::CreateReplacement(I->getInnerLocStart(), 10154 TypeWithKeyword::getTagTypeKindName(NewTag)); 10155 } 10156 } 10157 return true; 10158 } 10159 10160 // Check for a previous definition. If current tag and definition 10161 // are same type, do nothing. If no definition, but disagree with 10162 // with previous tag type, give a warning, but no fix-it. 10163 const TagDecl *Redecl = Previous->getDefinition() ? 10164 Previous->getDefinition() : Previous; 10165 if (Redecl->getTagKind() == NewTag) { 10166 return true; 10167 } 10168 10169 Diag(NewTagLoc, diag::warn_struct_class_tag_mismatch) 10170 << getRedeclDiagFromTagKind(NewTag) << isTemplate << &Name 10171 << getRedeclDiagFromTagKind(OldTag); 10172 Diag(Redecl->getLocation(), diag::note_previous_use); 10173 10174 // If there is a previous defintion, suggest a fix-it. 10175 if (Previous->getDefinition()) { 10176 Diag(NewTagLoc, diag::note_struct_class_suggestion) 10177 << getRedeclDiagFromTagKind(Redecl->getTagKind()) 10178 << FixItHint::CreateReplacement(SourceRange(NewTagLoc), 10179 TypeWithKeyword::getTagTypeKindName(Redecl->getTagKind())); 10180 } 10181 10182 return true; 10183 } 10184 return false; 10185} 10186 10187/// ActOnTag - This is invoked when we see 'struct foo' or 'struct {'. In the 10188/// former case, Name will be non-null. In the later case, Name will be null. 10189/// TagSpec indicates what kind of tag this is. TUK indicates whether this is a 10190/// reference/declaration/definition of a tag. 10191Decl *Sema::ActOnTag(Scope *S, unsigned TagSpec, TagUseKind TUK, 10192 SourceLocation KWLoc, CXXScopeSpec &SS, 10193 IdentifierInfo *Name, SourceLocation NameLoc, 10194 AttributeList *Attr, AccessSpecifier AS, 10195 SourceLocation ModulePrivateLoc, 10196 MultiTemplateParamsArg TemplateParameterLists, 10197 bool &OwnedDecl, bool &IsDependent, 10198 SourceLocation ScopedEnumKWLoc, 10199 bool ScopedEnumUsesClassTag, 10200 TypeResult UnderlyingType) { 10201 // If this is not a definition, it must have a name. 10202 IdentifierInfo *OrigName = Name; 10203 assert((Name != 0 || TUK == TUK_Definition) && 10204 "Nameless record must be a definition!"); 10205 assert(TemplateParameterLists.size() == 0 || TUK != TUK_Reference); 10206 10207 OwnedDecl = false; 10208 TagTypeKind Kind = TypeWithKeyword::getTagTypeKindForTypeSpec(TagSpec); 10209 bool ScopedEnum = ScopedEnumKWLoc.isValid(); 10210 10211 // FIXME: Check explicit specializations more carefully. 10212 bool isExplicitSpecialization = false; 10213 bool Invalid = false; 10214 10215 // We only need to do this matching if we have template parameters 10216 // or a scope specifier, which also conveniently avoids this work 10217 // for non-C++ cases. 10218 if (TemplateParameterLists.size() > 0 || 10219 (SS.isNotEmpty() && TUK != TUK_Reference)) { 10220 if (TemplateParameterList *TemplateParams = 10221 MatchTemplateParametersToScopeSpecifier( 10222 KWLoc, NameLoc, SS, TemplateParameterLists, TUK == TUK_Friend, 10223 isExplicitSpecialization, Invalid)) { 10224 if (Kind == TTK_Enum) { 10225 Diag(KWLoc, diag::err_enum_template); 10226 return 0; 10227 } 10228 10229 if (TemplateParams->size() > 0) { 10230 // This is a declaration or definition of a class template (which may 10231 // be a member of another template). 10232 10233 if (Invalid) 10234 return 0; 10235 10236 OwnedDecl = false; 10237 DeclResult Result = CheckClassTemplate(S, TagSpec, TUK, KWLoc, 10238 SS, Name, NameLoc, Attr, 10239 TemplateParams, AS, 10240 ModulePrivateLoc, 10241 TemplateParameterLists.size()-1, 10242 TemplateParameterLists.data()); 10243 return Result.get(); 10244 } else { 10245 // The "template<>" header is extraneous. 10246 Diag(TemplateParams->getTemplateLoc(), diag::err_template_tag_noparams) 10247 << TypeWithKeyword::getTagTypeKindName(Kind) << Name; 10248 isExplicitSpecialization = true; 10249 } 10250 } 10251 } 10252 10253 // Figure out the underlying type if this a enum declaration. We need to do 10254 // this early, because it's needed to detect if this is an incompatible 10255 // redeclaration. 10256 llvm::PointerUnion<const Type*, TypeSourceInfo*> EnumUnderlying; 10257 10258 if (Kind == TTK_Enum) { 10259 if (UnderlyingType.isInvalid() || (!UnderlyingType.get() && ScopedEnum)) 10260 // No underlying type explicitly specified, or we failed to parse the 10261 // type, default to int. 10262 EnumUnderlying = Context.IntTy.getTypePtr(); 10263 else if (UnderlyingType.get()) { 10264 // C++0x 7.2p2: The type-specifier-seq of an enum-base shall name an 10265 // integral type; any cv-qualification is ignored. 10266 TypeSourceInfo *TI = 0; 10267 GetTypeFromParser(UnderlyingType.get(), &TI); 10268 EnumUnderlying = TI; 10269 10270 if (CheckEnumUnderlyingType(TI)) 10271 // Recover by falling back to int. 10272 EnumUnderlying = Context.IntTy.getTypePtr(); 10273 10274 if (DiagnoseUnexpandedParameterPack(TI->getTypeLoc().getBeginLoc(), TI, 10275 UPPC_FixedUnderlyingType)) 10276 EnumUnderlying = Context.IntTy.getTypePtr(); 10277 10278 } else if (getLangOpts().MicrosoftMode) 10279 // Microsoft enums are always of int type. 10280 EnumUnderlying = Context.IntTy.getTypePtr(); 10281 } 10282 10283 DeclContext *SearchDC = CurContext; 10284 DeclContext *DC = CurContext; 10285 bool isStdBadAlloc = false; 10286 10287 RedeclarationKind Redecl = ForRedeclaration; 10288 if (TUK == TUK_Friend || TUK == TUK_Reference) 10289 Redecl = NotForRedeclaration; 10290 10291 LookupResult Previous(*this, Name, NameLoc, LookupTagName, Redecl); 10292 bool FriendSawTagOutsideEnclosingNamespace = false; 10293 if (Name && SS.isNotEmpty()) { 10294 // We have a nested-name tag ('struct foo::bar'). 10295 10296 // Check for invalid 'foo::'. 10297 if (SS.isInvalid()) { 10298 Name = 0; 10299 goto CreateNewDecl; 10300 } 10301 10302 // If this is a friend or a reference to a class in a dependent 10303 // context, don't try to make a decl for it. 10304 if (TUK == TUK_Friend || TUK == TUK_Reference) { 10305 DC = computeDeclContext(SS, false); 10306 if (!DC) { 10307 IsDependent = true; 10308 return 0; 10309 } 10310 } else { 10311 DC = computeDeclContext(SS, true); 10312 if (!DC) { 10313 Diag(SS.getRange().getBegin(), diag::err_dependent_nested_name_spec) 10314 << SS.getRange(); 10315 return 0; 10316 } 10317 } 10318 10319 if (RequireCompleteDeclContext(SS, DC)) 10320 return 0; 10321 10322 SearchDC = DC; 10323 // Look-up name inside 'foo::'. 10324 LookupQualifiedName(Previous, DC); 10325 10326 if (Previous.isAmbiguous()) 10327 return 0; 10328 10329 if (Previous.empty()) { 10330 // Name lookup did not find anything. However, if the 10331 // nested-name-specifier refers to the current instantiation, 10332 // and that current instantiation has any dependent base 10333 // classes, we might find something at instantiation time: treat 10334 // this as a dependent elaborated-type-specifier. 10335 // But this only makes any sense for reference-like lookups. 10336 if (Previous.wasNotFoundInCurrentInstantiation() && 10337 (TUK == TUK_Reference || TUK == TUK_Friend)) { 10338 IsDependent = true; 10339 return 0; 10340 } 10341 10342 // A tag 'foo::bar' must already exist. 10343 Diag(NameLoc, diag::err_not_tag_in_scope) 10344 << Kind << Name << DC << SS.getRange(); 10345 Name = 0; 10346 Invalid = true; 10347 goto CreateNewDecl; 10348 } 10349 } else if (Name) { 10350 // If this is a named struct, check to see if there was a previous forward 10351 // declaration or definition. 10352 // FIXME: We're looking into outer scopes here, even when we 10353 // shouldn't be. Doing so can result in ambiguities that we 10354 // shouldn't be diagnosing. 10355 LookupName(Previous, S); 10356 10357 // When declaring or defining a tag, ignore ambiguities introduced 10358 // by types using'ed into this scope. 10359 if (Previous.isAmbiguous() && 10360 (TUK == TUK_Definition || TUK == TUK_Declaration)) { 10361 LookupResult::Filter F = Previous.makeFilter(); 10362 while (F.hasNext()) { 10363 NamedDecl *ND = F.next(); 10364 if (ND->getDeclContext()->getRedeclContext() != SearchDC) 10365 F.erase(); 10366 } 10367 F.done(); 10368 } 10369 10370 // C++11 [namespace.memdef]p3: 10371 // If the name in a friend declaration is neither qualified nor 10372 // a template-id and the declaration is a function or an 10373 // elaborated-type-specifier, the lookup to determine whether 10374 // the entity has been previously declared shall not consider 10375 // any scopes outside the innermost enclosing namespace. 10376 // 10377 // Does it matter that this should be by scope instead of by 10378 // semantic context? 10379 if (!Previous.empty() && TUK == TUK_Friend) { 10380 DeclContext *EnclosingNS = SearchDC->getEnclosingNamespaceContext(); 10381 LookupResult::Filter F = Previous.makeFilter(); 10382 while (F.hasNext()) { 10383 NamedDecl *ND = F.next(); 10384 DeclContext *DC = ND->getDeclContext()->getRedeclContext(); 10385 if (DC->isFileContext() && 10386 !EnclosingNS->Encloses(ND->getDeclContext())) { 10387 F.erase(); 10388 FriendSawTagOutsideEnclosingNamespace = true; 10389 } 10390 } 10391 F.done(); 10392 } 10393 10394 // Note: there used to be some attempt at recovery here. 10395 if (Previous.isAmbiguous()) 10396 return 0; 10397 10398 if (!getLangOpts().CPlusPlus && TUK != TUK_Reference) { 10399 // FIXME: This makes sure that we ignore the contexts associated 10400 // with C structs, unions, and enums when looking for a matching 10401 // tag declaration or definition. See the similar lookup tweak 10402 // in Sema::LookupName; is there a better way to deal with this? 10403 while (isa<RecordDecl>(SearchDC) || isa<EnumDecl>(SearchDC)) 10404 SearchDC = SearchDC->getParent(); 10405 } 10406 } else if (S->isFunctionPrototypeScope()) { 10407 // If this is an enum declaration in function prototype scope, set its 10408 // initial context to the translation unit. 10409 // FIXME: [citation needed] 10410 SearchDC = Context.getTranslationUnitDecl(); 10411 } 10412 10413 if (Previous.isSingleResult() && 10414 Previous.getFoundDecl()->isTemplateParameter()) { 10415 // Maybe we will complain about the shadowed template parameter. 10416 DiagnoseTemplateParameterShadow(NameLoc, Previous.getFoundDecl()); 10417 // Just pretend that we didn't see the previous declaration. 10418 Previous.clear(); 10419 } 10420 10421 if (getLangOpts().CPlusPlus && Name && DC && StdNamespace && 10422 DC->Equals(getStdNamespace()) && Name->isStr("bad_alloc")) { 10423 // This is a declaration of or a reference to "std::bad_alloc". 10424 isStdBadAlloc = true; 10425 10426 if (Previous.empty() && StdBadAlloc) { 10427 // std::bad_alloc has been implicitly declared (but made invisible to 10428 // name lookup). Fill in this implicit declaration as the previous 10429 // declaration, so that the declarations get chained appropriately. 10430 Previous.addDecl(getStdBadAlloc()); 10431 } 10432 } 10433 10434 // If we didn't find a previous declaration, and this is a reference 10435 // (or friend reference), move to the correct scope. In C++, we 10436 // also need to do a redeclaration lookup there, just in case 10437 // there's a shadow friend decl. 10438 if (Name && Previous.empty() && 10439 (TUK == TUK_Reference || TUK == TUK_Friend)) { 10440 if (Invalid) goto CreateNewDecl; 10441 assert(SS.isEmpty()); 10442 10443 if (TUK == TUK_Reference) { 10444 // C++ [basic.scope.pdecl]p5: 10445 // -- for an elaborated-type-specifier of the form 10446 // 10447 // class-key identifier 10448 // 10449 // if the elaborated-type-specifier is used in the 10450 // decl-specifier-seq or parameter-declaration-clause of a 10451 // function defined in namespace scope, the identifier is 10452 // declared as a class-name in the namespace that contains 10453 // the declaration; otherwise, except as a friend 10454 // declaration, the identifier is declared in the smallest 10455 // non-class, non-function-prototype scope that contains the 10456 // declaration. 10457 // 10458 // C99 6.7.2.3p8 has a similar (but not identical!) provision for 10459 // C structs and unions. 10460 // 10461 // It is an error in C++ to declare (rather than define) an enum 10462 // type, including via an elaborated type specifier. We'll 10463 // diagnose that later; for now, declare the enum in the same 10464 // scope as we would have picked for any other tag type. 10465 // 10466 // GNU C also supports this behavior as part of its incomplete 10467 // enum types extension, while GNU C++ does not. 10468 // 10469 // Find the context where we'll be declaring the tag. 10470 // FIXME: We would like to maintain the current DeclContext as the 10471 // lexical context, 10472 while (!SearchDC->isFileContext() && !SearchDC->isFunctionOrMethod()) 10473 SearchDC = SearchDC->getParent(); 10474 10475 // Find the scope where we'll be declaring the tag. 10476 while (S->isClassScope() || 10477 (getLangOpts().CPlusPlus && 10478 S->isFunctionPrototypeScope()) || 10479 ((S->getFlags() & Scope::DeclScope) == 0) || 10480 (S->getEntity() && S->getEntity()->isTransparentContext())) 10481 S = S->getParent(); 10482 } else { 10483 assert(TUK == TUK_Friend); 10484 // C++ [namespace.memdef]p3: 10485 // If a friend declaration in a non-local class first declares a 10486 // class or function, the friend class or function is a member of 10487 // the innermost enclosing namespace. 10488 SearchDC = SearchDC->getEnclosingNamespaceContext(); 10489 } 10490 10491 // In C++, we need to do a redeclaration lookup to properly 10492 // diagnose some problems. 10493 if (getLangOpts().CPlusPlus) { 10494 Previous.setRedeclarationKind(ForRedeclaration); 10495 LookupQualifiedName(Previous, SearchDC); 10496 } 10497 } 10498 10499 if (!Previous.empty()) { 10500 NamedDecl *PrevDecl = (*Previous.begin())->getUnderlyingDecl(); 10501 10502 // It's okay to have a tag decl in the same scope as a typedef 10503 // which hides a tag decl in the same scope. Finding this 10504 // insanity with a redeclaration lookup can only actually happen 10505 // in C++. 10506 // 10507 // This is also okay for elaborated-type-specifiers, which is 10508 // technically forbidden by the current standard but which is 10509 // okay according to the likely resolution of an open issue; 10510 // see http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#407 10511 if (getLangOpts().CPlusPlus) { 10512 if (TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(PrevDecl)) { 10513 if (const TagType *TT = TD->getUnderlyingType()->getAs<TagType>()) { 10514 TagDecl *Tag = TT->getDecl(); 10515 if (Tag->getDeclName() == Name && 10516 Tag->getDeclContext()->getRedeclContext() 10517 ->Equals(TD->getDeclContext()->getRedeclContext())) { 10518 PrevDecl = Tag; 10519 Previous.clear(); 10520 Previous.addDecl(Tag); 10521 Previous.resolveKind(); 10522 } 10523 } 10524 } 10525 } 10526 10527 if (TagDecl *PrevTagDecl = dyn_cast<TagDecl>(PrevDecl)) { 10528 // If this is a use of a previous tag, or if the tag is already declared 10529 // in the same scope (so that the definition/declaration completes or 10530 // rementions the tag), reuse the decl. 10531 if (TUK == TUK_Reference || TUK == TUK_Friend || 10532 isDeclInScope(PrevDecl, SearchDC, S, isExplicitSpecialization)) { 10533 // Make sure that this wasn't declared as an enum and now used as a 10534 // struct or something similar. 10535 if (!isAcceptableTagRedeclaration(PrevTagDecl, Kind, 10536 TUK == TUK_Definition, KWLoc, 10537 *Name)) { 10538 bool SafeToContinue 10539 = (PrevTagDecl->getTagKind() != TTK_Enum && 10540 Kind != TTK_Enum); 10541 if (SafeToContinue) 10542 Diag(KWLoc, diag::err_use_with_wrong_tag) 10543 << Name 10544 << FixItHint::CreateReplacement(SourceRange(KWLoc), 10545 PrevTagDecl->getKindName()); 10546 else 10547 Diag(KWLoc, diag::err_use_with_wrong_tag) << Name; 10548 Diag(PrevTagDecl->getLocation(), diag::note_previous_use); 10549 10550 if (SafeToContinue) 10551 Kind = PrevTagDecl->getTagKind(); 10552 else { 10553 // Recover by making this an anonymous redefinition. 10554 Name = 0; 10555 Previous.clear(); 10556 Invalid = true; 10557 } 10558 } 10559 10560 if (Kind == TTK_Enum && PrevTagDecl->getTagKind() == TTK_Enum) { 10561 const EnumDecl *PrevEnum = cast<EnumDecl>(PrevTagDecl); 10562 10563 // If this is an elaborated-type-specifier for a scoped enumeration, 10564 // the 'class' keyword is not necessary and not permitted. 10565 if (TUK == TUK_Reference || TUK == TUK_Friend) { 10566 if (ScopedEnum) 10567 Diag(ScopedEnumKWLoc, diag::err_enum_class_reference) 10568 << PrevEnum->isScoped() 10569 << FixItHint::CreateRemoval(ScopedEnumKWLoc); 10570 return PrevTagDecl; 10571 } 10572 10573 QualType EnumUnderlyingTy; 10574 if (TypeSourceInfo *TI = EnumUnderlying.dyn_cast<TypeSourceInfo*>()) 10575 EnumUnderlyingTy = TI->getType(); 10576 else if (const Type *T = EnumUnderlying.dyn_cast<const Type*>()) 10577 EnumUnderlyingTy = QualType(T, 0); 10578 10579 // All conflicts with previous declarations are recovered by 10580 // returning the previous declaration, unless this is a definition, 10581 // in which case we want the caller to bail out. 10582 if (CheckEnumRedeclaration(NameLoc.isValid() ? NameLoc : KWLoc, 10583 ScopedEnum, EnumUnderlyingTy, PrevEnum)) 10584 return TUK == TUK_Declaration ? PrevTagDecl : 0; 10585 } 10586 10587 // C++11 [class.mem]p1: 10588 // A member shall not be declared twice in the member-specification, 10589 // except that a nested class or member class template can be declared 10590 // and then later defined. 10591 if (TUK == TUK_Declaration && PrevDecl->isCXXClassMember() && 10592 S->isDeclScope(PrevDecl)) { 10593 Diag(NameLoc, diag::ext_member_redeclared); 10594 Diag(PrevTagDecl->getLocation(), diag::note_previous_declaration); 10595 } 10596 10597 if (!Invalid) { 10598 // If this is a use, just return the declaration we found. 10599 10600 // FIXME: In the future, return a variant or some other clue 10601 // for the consumer of this Decl to know it doesn't own it. 10602 // For our current ASTs this shouldn't be a problem, but will 10603 // need to be changed with DeclGroups. 10604 if ((TUK == TUK_Reference && (!PrevTagDecl->getFriendObjectKind() || 10605 getLangOpts().MicrosoftExt)) || TUK == TUK_Friend) 10606 return PrevTagDecl; 10607 10608 // Diagnose attempts to redefine a tag. 10609 if (TUK == TUK_Definition) { 10610 if (TagDecl *Def = PrevTagDecl->getDefinition()) { 10611 // If we're defining a specialization and the previous definition 10612 // is from an implicit instantiation, don't emit an error 10613 // here; we'll catch this in the general case below. 10614 bool IsExplicitSpecializationAfterInstantiation = false; 10615 if (isExplicitSpecialization) { 10616 if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(Def)) 10617 IsExplicitSpecializationAfterInstantiation = 10618 RD->getTemplateSpecializationKind() != 10619 TSK_ExplicitSpecialization; 10620 else if (EnumDecl *ED = dyn_cast<EnumDecl>(Def)) 10621 IsExplicitSpecializationAfterInstantiation = 10622 ED->getTemplateSpecializationKind() != 10623 TSK_ExplicitSpecialization; 10624 } 10625 10626 if (!IsExplicitSpecializationAfterInstantiation) { 10627 // A redeclaration in function prototype scope in C isn't 10628 // visible elsewhere, so merely issue a warning. 10629 if (!getLangOpts().CPlusPlus && S->containedInPrototypeScope()) 10630 Diag(NameLoc, diag::warn_redefinition_in_param_list) << Name; 10631 else 10632 Diag(NameLoc, diag::err_redefinition) << Name; 10633 Diag(Def->getLocation(), diag::note_previous_definition); 10634 // If this is a redefinition, recover by making this 10635 // struct be anonymous, which will make any later 10636 // references get the previous definition. 10637 Name = 0; 10638 Previous.clear(); 10639 Invalid = true; 10640 } 10641 } else { 10642 // If the type is currently being defined, complain 10643 // about a nested redefinition. 10644 const TagType *Tag 10645 = cast<TagType>(Context.getTagDeclType(PrevTagDecl)); 10646 if (Tag->isBeingDefined()) { 10647 Diag(NameLoc, diag::err_nested_redefinition) << Name; 10648 Diag(PrevTagDecl->getLocation(), 10649 diag::note_previous_definition); 10650 Name = 0; 10651 Previous.clear(); 10652 Invalid = true; 10653 } 10654 } 10655 10656 // Okay, this is definition of a previously declared or referenced 10657 // tag PrevDecl. We're going to create a new Decl for it. 10658 } 10659 } 10660 // If we get here we have (another) forward declaration or we 10661 // have a definition. Just create a new decl. 10662 10663 } else { 10664 // If we get here, this is a definition of a new tag type in a nested 10665 // scope, e.g. "struct foo; void bar() { struct foo; }", just create a 10666 // new decl/type. We set PrevDecl to NULL so that the entities 10667 // have distinct types. 10668 Previous.clear(); 10669 } 10670 // If we get here, we're going to create a new Decl. If PrevDecl 10671 // is non-NULL, it's a definition of the tag declared by 10672 // PrevDecl. If it's NULL, we have a new definition. 10673 10674 10675 // Otherwise, PrevDecl is not a tag, but was found with tag 10676 // lookup. This is only actually possible in C++, where a few 10677 // things like templates still live in the tag namespace. 10678 } else { 10679 // Use a better diagnostic if an elaborated-type-specifier 10680 // found the wrong kind of type on the first 10681 // (non-redeclaration) lookup. 10682 if ((TUK == TUK_Reference || TUK == TUK_Friend) && 10683 !Previous.isForRedeclaration()) { 10684 unsigned Kind = 0; 10685 if (isa<TypedefDecl>(PrevDecl)) Kind = 1; 10686 else if (isa<TypeAliasDecl>(PrevDecl)) Kind = 2; 10687 else if (isa<ClassTemplateDecl>(PrevDecl)) Kind = 3; 10688 Diag(NameLoc, diag::err_tag_reference_non_tag) << Kind; 10689 Diag(PrevDecl->getLocation(), diag::note_declared_at); 10690 Invalid = true; 10691 10692 // Otherwise, only diagnose if the declaration is in scope. 10693 } else if (!isDeclInScope(PrevDecl, SearchDC, S, 10694 isExplicitSpecialization)) { 10695 // do nothing 10696 10697 // Diagnose implicit declarations introduced by elaborated types. 10698 } else if (TUK == TUK_Reference || TUK == TUK_Friend) { 10699 unsigned Kind = 0; 10700 if (isa<TypedefDecl>(PrevDecl)) Kind = 1; 10701 else if (isa<TypeAliasDecl>(PrevDecl)) Kind = 2; 10702 else if (isa<ClassTemplateDecl>(PrevDecl)) Kind = 3; 10703 Diag(NameLoc, diag::err_tag_reference_conflict) << Kind; 10704 Diag(PrevDecl->getLocation(), diag::note_previous_decl) << PrevDecl; 10705 Invalid = true; 10706 10707 // Otherwise it's a declaration. Call out a particularly common 10708 // case here. 10709 } else if (TypedefNameDecl *TND = dyn_cast<TypedefNameDecl>(PrevDecl)) { 10710 unsigned Kind = 0; 10711 if (isa<TypeAliasDecl>(PrevDecl)) Kind = 1; 10712 Diag(NameLoc, diag::err_tag_definition_of_typedef) 10713 << Name << Kind << TND->getUnderlyingType(); 10714 Diag(PrevDecl->getLocation(), diag::note_previous_decl) << PrevDecl; 10715 Invalid = true; 10716 10717 // Otherwise, diagnose. 10718 } else { 10719 // The tag name clashes with something else in the target scope, 10720 // issue an error and recover by making this tag be anonymous. 10721 Diag(NameLoc, diag::err_redefinition_different_kind) << Name; 10722 Diag(PrevDecl->getLocation(), diag::note_previous_definition); 10723 Name = 0; 10724 Invalid = true; 10725 } 10726 10727 // The existing declaration isn't relevant to us; we're in a 10728 // new scope, so clear out the previous declaration. 10729 Previous.clear(); 10730 } 10731 } 10732 10733CreateNewDecl: 10734 10735 TagDecl *PrevDecl = 0; 10736 if (Previous.isSingleResult()) 10737 PrevDecl = cast<TagDecl>(Previous.getFoundDecl()); 10738 10739 // If there is an identifier, use the location of the identifier as the 10740 // location of the decl, otherwise use the location of the struct/union 10741 // keyword. 10742 SourceLocation Loc = NameLoc.isValid() ? NameLoc : KWLoc; 10743 10744 // Otherwise, create a new declaration. If there is a previous 10745 // declaration of the same entity, the two will be linked via 10746 // PrevDecl. 10747 TagDecl *New; 10748 10749 bool IsForwardReference = false; 10750 if (Kind == TTK_Enum) { 10751 // FIXME: Tag decls should be chained to any simultaneous vardecls, e.g.: 10752 // enum X { A, B, C } D; D should chain to X. 10753 New = EnumDecl::Create(Context, SearchDC, KWLoc, Loc, Name, 10754 cast_or_null<EnumDecl>(PrevDecl), ScopedEnum, 10755 ScopedEnumUsesClassTag, !EnumUnderlying.isNull()); 10756 // If this is an undefined enum, warn. 10757 if (TUK != TUK_Definition && !Invalid) { 10758 TagDecl *Def; 10759 if ((getLangOpts().CPlusPlus11 || getLangOpts().ObjC2) && 10760 cast<EnumDecl>(New)->isFixed()) { 10761 // C++0x: 7.2p2: opaque-enum-declaration. 10762 // Conflicts are diagnosed above. Do nothing. 10763 } 10764 else if (PrevDecl && (Def = cast<EnumDecl>(PrevDecl)->getDefinition())) { 10765 Diag(Loc, diag::ext_forward_ref_enum_def) 10766 << New; 10767 Diag(Def->getLocation(), diag::note_previous_definition); 10768 } else { 10769 unsigned DiagID = diag::ext_forward_ref_enum; 10770 if (getLangOpts().MicrosoftMode) 10771 DiagID = diag::ext_ms_forward_ref_enum; 10772 else if (getLangOpts().CPlusPlus) 10773 DiagID = diag::err_forward_ref_enum; 10774 Diag(Loc, DiagID); 10775 10776 // If this is a forward-declared reference to an enumeration, make a 10777 // note of it; we won't actually be introducing the declaration into 10778 // the declaration context. 10779 if (TUK == TUK_Reference) 10780 IsForwardReference = true; 10781 } 10782 } 10783 10784 if (EnumUnderlying) { 10785 EnumDecl *ED = cast<EnumDecl>(New); 10786 if (TypeSourceInfo *TI = EnumUnderlying.dyn_cast<TypeSourceInfo*>()) 10787 ED->setIntegerTypeSourceInfo(TI); 10788 else 10789 ED->setIntegerType(QualType(EnumUnderlying.get<const Type*>(), 0)); 10790 ED->setPromotionType(ED->getIntegerType()); 10791 } 10792 10793 } else { 10794 // struct/union/class 10795 10796 // FIXME: Tag decls should be chained to any simultaneous vardecls, e.g.: 10797 // struct X { int A; } D; D should chain to X. 10798 if (getLangOpts().CPlusPlus) { 10799 // FIXME: Look for a way to use RecordDecl for simple structs. 10800 New = CXXRecordDecl::Create(Context, Kind, SearchDC, KWLoc, Loc, Name, 10801 cast_or_null<CXXRecordDecl>(PrevDecl)); 10802 10803 if (isStdBadAlloc && (!StdBadAlloc || getStdBadAlloc()->isImplicit())) 10804 StdBadAlloc = cast<CXXRecordDecl>(New); 10805 } else 10806 New = RecordDecl::Create(Context, Kind, SearchDC, KWLoc, Loc, Name, 10807 cast_or_null<RecordDecl>(PrevDecl)); 10808 } 10809 10810 // Maybe add qualifier info. 10811 if (SS.isNotEmpty()) { 10812 if (SS.isSet()) { 10813 // If this is either a declaration or a definition, check the 10814 // nested-name-specifier against the current context. We don't do this 10815 // for explicit specializations, because they have similar checking 10816 // (with more specific diagnostics) in the call to 10817 // CheckMemberSpecialization, below. 10818 if (!isExplicitSpecialization && 10819 (TUK == TUK_Definition || TUK == TUK_Declaration) && 10820 diagnoseQualifiedDeclaration(SS, DC, OrigName, NameLoc)) 10821 Invalid = true; 10822 10823 New->setQualifierInfo(SS.getWithLocInContext(Context)); 10824 if (TemplateParameterLists.size() > 0) { 10825 New->setTemplateParameterListsInfo(Context, 10826 TemplateParameterLists.size(), 10827 TemplateParameterLists.data()); 10828 } 10829 } 10830 else 10831 Invalid = true; 10832 } 10833 10834 if (RecordDecl *RD = dyn_cast<RecordDecl>(New)) { 10835 // Add alignment attributes if necessary; these attributes are checked when 10836 // the ASTContext lays out the structure. 10837 // 10838 // It is important for implementing the correct semantics that this 10839 // happen here (in act on tag decl). The #pragma pack stack is 10840 // maintained as a result of parser callbacks which can occur at 10841 // many points during the parsing of a struct declaration (because 10842 // the #pragma tokens are effectively skipped over during the 10843 // parsing of the struct). 10844 if (TUK == TUK_Definition) { 10845 AddAlignmentAttributesForRecord(RD); 10846 AddMsStructLayoutForRecord(RD); 10847 } 10848 } 10849 10850 if (ModulePrivateLoc.isValid()) { 10851 if (isExplicitSpecialization) 10852 Diag(New->getLocation(), diag::err_module_private_specialization) 10853 << 2 10854 << FixItHint::CreateRemoval(ModulePrivateLoc); 10855 // __module_private__ does not apply to local classes. However, we only 10856 // diagnose this as an error when the declaration specifiers are 10857 // freestanding. Here, we just ignore the __module_private__. 10858 else if (!SearchDC->isFunctionOrMethod()) 10859 New->setModulePrivate(); 10860 } 10861 10862 // If this is a specialization of a member class (of a class template), 10863 // check the specialization. 10864 if (isExplicitSpecialization && CheckMemberSpecialization(New, Previous)) 10865 Invalid = true; 10866 10867 if (Invalid) 10868 New->setInvalidDecl(); 10869 10870 if (Attr) 10871 ProcessDeclAttributeList(S, New, Attr); 10872 10873 // If we're declaring or defining a tag in function prototype scope 10874 // in C, note that this type can only be used within the function. 10875 if (Name && S->isFunctionPrototypeScope() && !getLangOpts().CPlusPlus) 10876 Diag(Loc, diag::warn_decl_in_param_list) << Context.getTagDeclType(New); 10877 10878 // Set the lexical context. If the tag has a C++ scope specifier, the 10879 // lexical context will be different from the semantic context. 10880 New->setLexicalDeclContext(CurContext); 10881 10882 // Mark this as a friend decl if applicable. 10883 // In Microsoft mode, a friend declaration also acts as a forward 10884 // declaration so we always pass true to setObjectOfFriendDecl to make 10885 // the tag name visible. 10886 if (TUK == TUK_Friend) 10887 New->setObjectOfFriendDecl(!FriendSawTagOutsideEnclosingNamespace && 10888 getLangOpts().MicrosoftExt); 10889 10890 // Set the access specifier. 10891 if (!Invalid && SearchDC->isRecord()) 10892 SetMemberAccessSpecifier(New, PrevDecl, AS); 10893 10894 if (TUK == TUK_Definition) 10895 New->startDefinition(); 10896 10897 // If this has an identifier, add it to the scope stack. 10898 if (TUK == TUK_Friend) { 10899 // We might be replacing an existing declaration in the lookup tables; 10900 // if so, borrow its access specifier. 10901 if (PrevDecl) 10902 New->setAccess(PrevDecl->getAccess()); 10903 10904 DeclContext *DC = New->getDeclContext()->getRedeclContext(); 10905 DC->makeDeclVisibleInContext(New); 10906 if (Name) // can be null along some error paths 10907 if (Scope *EnclosingScope = getScopeForDeclContext(S, DC)) 10908 PushOnScopeChains(New, EnclosingScope, /* AddToContext = */ false); 10909 } else if (Name) { 10910 S = getNonFieldDeclScope(S); 10911 PushOnScopeChains(New, S, !IsForwardReference); 10912 if (IsForwardReference) 10913 SearchDC->makeDeclVisibleInContext(New); 10914 10915 } else { 10916 CurContext->addDecl(New); 10917 } 10918 10919 // If this is the C FILE type, notify the AST context. 10920 if (IdentifierInfo *II = New->getIdentifier()) 10921 if (!New->isInvalidDecl() && 10922 New->getDeclContext()->getRedeclContext()->isTranslationUnit() && 10923 II->isStr("FILE")) 10924 Context.setFILEDecl(New); 10925 10926 // If we were in function prototype scope (and not in C++ mode), add this 10927 // tag to the list of decls to inject into the function definition scope. 10928 if (S->isFunctionPrototypeScope() && !getLangOpts().CPlusPlus && 10929 InFunctionDeclarator && Name) 10930 DeclsInPrototypeScope.push_back(New); 10931 10932 if (PrevDecl) 10933 mergeDeclAttributes(New, PrevDecl); 10934 10935 // If there's a #pragma GCC visibility in scope, set the visibility of this 10936 // record. 10937 AddPushedVisibilityAttribute(New); 10938 10939 OwnedDecl = true; 10940 // In C++, don't return an invalid declaration. We can't recover well from 10941 // the cases where we make the type anonymous. 10942 return (Invalid && getLangOpts().CPlusPlus) ? 0 : New; 10943} 10944 10945void Sema::ActOnTagStartDefinition(Scope *S, Decl *TagD) { 10946 AdjustDeclIfTemplate(TagD); 10947 TagDecl *Tag = cast<TagDecl>(TagD); 10948 10949 // Enter the tag context. 10950 PushDeclContext(S, Tag); 10951 10952 ActOnDocumentableDecl(TagD); 10953 10954 // If there's a #pragma GCC visibility in scope, set the visibility of this 10955 // record. 10956 AddPushedVisibilityAttribute(Tag); 10957} 10958 10959Decl *Sema::ActOnObjCContainerStartDefinition(Decl *IDecl) { 10960 assert(isa<ObjCContainerDecl>(IDecl) && 10961 "ActOnObjCContainerStartDefinition - Not ObjCContainerDecl"); 10962 DeclContext *OCD = cast<DeclContext>(IDecl); 10963 assert(getContainingDC(OCD) == CurContext && 10964 "The next DeclContext should be lexically contained in the current one."); 10965 CurContext = OCD; 10966 return IDecl; 10967} 10968 10969void Sema::ActOnStartCXXMemberDeclarations(Scope *S, Decl *TagD, 10970 SourceLocation FinalLoc, 10971 bool IsFinalSpelledSealed, 10972 SourceLocation LBraceLoc) { 10973 AdjustDeclIfTemplate(TagD); 10974 CXXRecordDecl *Record = cast<CXXRecordDecl>(TagD); 10975 10976 FieldCollector->StartClass(); 10977 10978 if (!Record->getIdentifier()) 10979 return; 10980 10981 if (FinalLoc.isValid()) 10982 Record->addAttr(new (Context) 10983 FinalAttr(FinalLoc, Context, IsFinalSpelledSealed)); 10984 10985 // C++ [class]p2: 10986 // [...] The class-name is also inserted into the scope of the 10987 // class itself; this is known as the injected-class-name. For 10988 // purposes of access checking, the injected-class-name is treated 10989 // as if it were a public member name. 10990 CXXRecordDecl *InjectedClassName 10991 = CXXRecordDecl::Create(Context, Record->getTagKind(), CurContext, 10992 Record->getLocStart(), Record->getLocation(), 10993 Record->getIdentifier(), 10994 /*PrevDecl=*/0, 10995 /*DelayTypeCreation=*/true); 10996 Context.getTypeDeclType(InjectedClassName, Record); 10997 InjectedClassName->setImplicit(); 10998 InjectedClassName->setAccess(AS_public); 10999 if (ClassTemplateDecl *Template = Record->getDescribedClassTemplate()) 11000 InjectedClassName->setDescribedClassTemplate(Template); 11001 PushOnScopeChains(InjectedClassName, S); 11002 assert(InjectedClassName->isInjectedClassName() && 11003 "Broken injected-class-name"); 11004} 11005 11006void Sema::ActOnTagFinishDefinition(Scope *S, Decl *TagD, 11007 SourceLocation RBraceLoc) { 11008 AdjustDeclIfTemplate(TagD); 11009 TagDecl *Tag = cast<TagDecl>(TagD); 11010 Tag->setRBraceLoc(RBraceLoc); 11011 11012 // Make sure we "complete" the definition even it is invalid. 11013 if (Tag->isBeingDefined()) { 11014 assert(Tag->isInvalidDecl() && "We should already have completed it"); 11015 if (RecordDecl *RD = dyn_cast<RecordDecl>(Tag)) 11016 RD->completeDefinition(); 11017 } 11018 11019 if (isa<CXXRecordDecl>(Tag)) 11020 FieldCollector->FinishClass(); 11021 11022 // Exit this scope of this tag's definition. 11023 PopDeclContext(); 11024 11025 if (getCurLexicalContext()->isObjCContainer() && 11026 Tag->getDeclContext()->isFileContext()) 11027 Tag->setTopLevelDeclInObjCContainer(); 11028 11029 // Notify the consumer that we've defined a tag. 11030 if (!Tag->isInvalidDecl()) 11031 Consumer.HandleTagDeclDefinition(Tag); 11032} 11033 11034void Sema::ActOnObjCContainerFinishDefinition() { 11035 // Exit this scope of this interface definition. 11036 PopDeclContext(); 11037} 11038 11039void Sema::ActOnObjCTemporaryExitContainerContext(DeclContext *DC) { 11040 assert(DC == CurContext && "Mismatch of container contexts"); 11041 OriginalLexicalContext = DC; 11042 ActOnObjCContainerFinishDefinition(); 11043} 11044 11045void Sema::ActOnObjCReenterContainerContext(DeclContext *DC) { 11046 ActOnObjCContainerStartDefinition(cast<Decl>(DC)); 11047 OriginalLexicalContext = 0; 11048} 11049 11050void Sema::ActOnTagDefinitionError(Scope *S, Decl *TagD) { 11051 AdjustDeclIfTemplate(TagD); 11052 TagDecl *Tag = cast<TagDecl>(TagD); 11053 Tag->setInvalidDecl(); 11054 11055 // Make sure we "complete" the definition even it is invalid. 11056 if (Tag->isBeingDefined()) { 11057 if (RecordDecl *RD = dyn_cast<RecordDecl>(Tag)) 11058 RD->completeDefinition(); 11059 } 11060 11061 // We're undoing ActOnTagStartDefinition here, not 11062 // ActOnStartCXXMemberDeclarations, so we don't have to mess with 11063 // the FieldCollector. 11064 11065 PopDeclContext(); 11066} 11067 11068// Note that FieldName may be null for anonymous bitfields. 11069ExprResult Sema::VerifyBitField(SourceLocation FieldLoc, 11070 IdentifierInfo *FieldName, 11071 QualType FieldTy, bool IsMsStruct, 11072 Expr *BitWidth, bool *ZeroWidth) { 11073 // Default to true; that shouldn't confuse checks for emptiness 11074 if (ZeroWidth) 11075 *ZeroWidth = true; 11076 11077 // C99 6.7.2.1p4 - verify the field type. 11078 // C++ 9.6p3: A bit-field shall have integral or enumeration type. 11079 if (!FieldTy->isDependentType() && !FieldTy->isIntegralOrEnumerationType()) { 11080 // Handle incomplete types with specific error. 11081 if (RequireCompleteType(FieldLoc, FieldTy, diag::err_field_incomplete)) 11082 return ExprError(); 11083 if (FieldName) 11084 return Diag(FieldLoc, diag::err_not_integral_type_bitfield) 11085 << FieldName << FieldTy << BitWidth->getSourceRange(); 11086 return Diag(FieldLoc, diag::err_not_integral_type_anon_bitfield) 11087 << FieldTy << BitWidth->getSourceRange(); 11088 } else if (DiagnoseUnexpandedParameterPack(const_cast<Expr *>(BitWidth), 11089 UPPC_BitFieldWidth)) 11090 return ExprError(); 11091 11092 // If the bit-width is type- or value-dependent, don't try to check 11093 // it now. 11094 if (BitWidth->isValueDependent() || BitWidth->isTypeDependent()) 11095 return Owned(BitWidth); 11096 11097 llvm::APSInt Value; 11098 ExprResult ICE = VerifyIntegerConstantExpression(BitWidth, &Value); 11099 if (ICE.isInvalid()) 11100 return ICE; 11101 BitWidth = ICE.take(); 11102 11103 if (Value != 0 && ZeroWidth) 11104 *ZeroWidth = false; 11105 11106 // Zero-width bitfield is ok for anonymous field. 11107 if (Value == 0 && FieldName) 11108 return Diag(FieldLoc, diag::err_bitfield_has_zero_width) << FieldName; 11109 11110 if (Value.isSigned() && Value.isNegative()) { 11111 if (FieldName) 11112 return Diag(FieldLoc, diag::err_bitfield_has_negative_width) 11113 << FieldName << Value.toString(10); 11114 return Diag(FieldLoc, diag::err_anon_bitfield_has_negative_width) 11115 << Value.toString(10); 11116 } 11117 11118 if (!FieldTy->isDependentType()) { 11119 uint64_t TypeSize = Context.getTypeSize(FieldTy); 11120 if (Value.getZExtValue() > TypeSize) { 11121 if (!getLangOpts().CPlusPlus || IsMsStruct) { 11122 if (FieldName) 11123 return Diag(FieldLoc, diag::err_bitfield_width_exceeds_type_size) 11124 << FieldName << (unsigned)Value.getZExtValue() 11125 << (unsigned)TypeSize; 11126 11127 return Diag(FieldLoc, diag::err_anon_bitfield_width_exceeds_type_size) 11128 << (unsigned)Value.getZExtValue() << (unsigned)TypeSize; 11129 } 11130 11131 if (FieldName) 11132 Diag(FieldLoc, diag::warn_bitfield_width_exceeds_type_size) 11133 << FieldName << (unsigned)Value.getZExtValue() 11134 << (unsigned)TypeSize; 11135 else 11136 Diag(FieldLoc, diag::warn_anon_bitfield_width_exceeds_type_size) 11137 << (unsigned)Value.getZExtValue() << (unsigned)TypeSize; 11138 } 11139 } 11140 11141 return Owned(BitWidth); 11142} 11143 11144/// ActOnField - Each field of a C struct/union is passed into this in order 11145/// to create a FieldDecl object for it. 11146Decl *Sema::ActOnField(Scope *S, Decl *TagD, SourceLocation DeclStart, 11147 Declarator &D, Expr *BitfieldWidth) { 11148 FieldDecl *Res = HandleField(S, cast_or_null<RecordDecl>(TagD), 11149 DeclStart, D, static_cast<Expr*>(BitfieldWidth), 11150 /*InitStyle=*/ICIS_NoInit, AS_public); 11151 return Res; 11152} 11153 11154/// HandleField - Analyze a field of a C struct or a C++ data member. 11155/// 11156FieldDecl *Sema::HandleField(Scope *S, RecordDecl *Record, 11157 SourceLocation DeclStart, 11158 Declarator &D, Expr *BitWidth, 11159 InClassInitStyle InitStyle, 11160 AccessSpecifier AS) { 11161 IdentifierInfo *II = D.getIdentifier(); 11162 SourceLocation Loc = DeclStart; 11163 if (II) Loc = D.getIdentifierLoc(); 11164 11165 TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S); 11166 QualType T = TInfo->getType(); 11167 if (getLangOpts().CPlusPlus) { 11168 CheckExtraCXXDefaultArguments(D); 11169 11170 if (DiagnoseUnexpandedParameterPack(D.getIdentifierLoc(), TInfo, 11171 UPPC_DataMemberType)) { 11172 D.setInvalidType(); 11173 T = Context.IntTy; 11174 TInfo = Context.getTrivialTypeSourceInfo(T, Loc); 11175 } 11176 } 11177 11178 // TR 18037 does not allow fields to be declared with address spaces. 11179 if (T.getQualifiers().hasAddressSpace()) { 11180 Diag(Loc, diag::err_field_with_address_space); 11181 D.setInvalidType(); 11182 } 11183 11184 // OpenCL 1.2 spec, s6.9 r: 11185 // The event type cannot be used to declare a structure or union field. 11186 if (LangOpts.OpenCL && T->isEventT()) { 11187 Diag(Loc, diag::err_event_t_struct_field); 11188 D.setInvalidType(); 11189 } 11190 11191 DiagnoseFunctionSpecifiers(D.getDeclSpec()); 11192 11193 if (DeclSpec::TSCS TSCS = D.getDeclSpec().getThreadStorageClassSpec()) 11194 Diag(D.getDeclSpec().getThreadStorageClassSpecLoc(), 11195 diag::err_invalid_thread) 11196 << DeclSpec::getSpecifierName(TSCS); 11197 11198 // Check to see if this name was declared as a member previously 11199 NamedDecl *PrevDecl = 0; 11200 LookupResult Previous(*this, II, Loc, LookupMemberName, ForRedeclaration); 11201 LookupName(Previous, S); 11202 switch (Previous.getResultKind()) { 11203 case LookupResult::Found: 11204 case LookupResult::FoundUnresolvedValue: 11205 PrevDecl = Previous.getAsSingle<NamedDecl>(); 11206 break; 11207 11208 case LookupResult::FoundOverloaded: 11209 PrevDecl = Previous.getRepresentativeDecl(); 11210 break; 11211 11212 case LookupResult::NotFound: 11213 case LookupResult::NotFoundInCurrentInstantiation: 11214 case LookupResult::Ambiguous: 11215 break; 11216 } 11217 Previous.suppressDiagnostics(); 11218 11219 if (PrevDecl && PrevDecl->isTemplateParameter()) { 11220 // Maybe we will complain about the shadowed template parameter. 11221 DiagnoseTemplateParameterShadow(D.getIdentifierLoc(), PrevDecl); 11222 // Just pretend that we didn't see the previous declaration. 11223 PrevDecl = 0; 11224 } 11225 11226 if (PrevDecl && !isDeclInScope(PrevDecl, Record, S)) 11227 PrevDecl = 0; 11228 11229 bool Mutable 11230 = (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_mutable); 11231 SourceLocation TSSL = D.getLocStart(); 11232 FieldDecl *NewFD 11233 = CheckFieldDecl(II, T, TInfo, Record, Loc, Mutable, BitWidth, InitStyle, 11234 TSSL, AS, PrevDecl, &D); 11235 11236 if (NewFD->isInvalidDecl()) 11237 Record->setInvalidDecl(); 11238 11239 if (D.getDeclSpec().isModulePrivateSpecified()) 11240 NewFD->setModulePrivate(); 11241 11242 if (NewFD->isInvalidDecl() && PrevDecl) { 11243 // Don't introduce NewFD into scope; there's already something 11244 // with the same name in the same scope. 11245 } else if (II) { 11246 PushOnScopeChains(NewFD, S); 11247 } else 11248 Record->addDecl(NewFD); 11249 11250 return NewFD; 11251} 11252 11253/// \brief Build a new FieldDecl and check its well-formedness. 11254/// 11255/// This routine builds a new FieldDecl given the fields name, type, 11256/// record, etc. \p PrevDecl should refer to any previous declaration 11257/// with the same name and in the same scope as the field to be 11258/// created. 11259/// 11260/// \returns a new FieldDecl. 11261/// 11262/// \todo The Declarator argument is a hack. It will be removed once 11263FieldDecl *Sema::CheckFieldDecl(DeclarationName Name, QualType T, 11264 TypeSourceInfo *TInfo, 11265 RecordDecl *Record, SourceLocation Loc, 11266 bool Mutable, Expr *BitWidth, 11267 InClassInitStyle InitStyle, 11268 SourceLocation TSSL, 11269 AccessSpecifier AS, NamedDecl *PrevDecl, 11270 Declarator *D) { 11271 IdentifierInfo *II = Name.getAsIdentifierInfo(); 11272 bool InvalidDecl = false; 11273 if (D) InvalidDecl = D->isInvalidType(); 11274 11275 // If we receive a broken type, recover by assuming 'int' and 11276 // marking this declaration as invalid. 11277 if (T.isNull()) { 11278 InvalidDecl = true; 11279 T = Context.IntTy; 11280 } 11281 11282 QualType EltTy = Context.getBaseElementType(T); 11283 if (!EltTy->isDependentType()) { 11284 if (RequireCompleteType(Loc, EltTy, diag::err_field_incomplete)) { 11285 // Fields of incomplete type force their record to be invalid. 11286 Record->setInvalidDecl(); 11287 InvalidDecl = true; 11288 } else { 11289 NamedDecl *Def; 11290 EltTy->isIncompleteType(&Def); 11291 if (Def && Def->isInvalidDecl()) { 11292 Record->setInvalidDecl(); 11293 InvalidDecl = true; 11294 } 11295 } 11296 } 11297 11298 // OpenCL v1.2 s6.9.c: bitfields are not supported. 11299 if (BitWidth && getLangOpts().OpenCL) { 11300 Diag(Loc, diag::err_opencl_bitfields); 11301 InvalidDecl = true; 11302 } 11303 11304 // C99 6.7.2.1p8: A member of a structure or union may have any type other 11305 // than a variably modified type. 11306 if (!InvalidDecl && T->isVariablyModifiedType()) { 11307 bool SizeIsNegative; 11308 llvm::APSInt Oversized; 11309 11310 TypeSourceInfo *FixedTInfo = 11311 TryToFixInvalidVariablyModifiedTypeSourceInfo(TInfo, Context, 11312 SizeIsNegative, 11313 Oversized); 11314 if (FixedTInfo) { 11315 Diag(Loc, diag::warn_illegal_constant_array_size); 11316 TInfo = FixedTInfo; 11317 T = FixedTInfo->getType(); 11318 } else { 11319 if (SizeIsNegative) 11320 Diag(Loc, diag::err_typecheck_negative_array_size); 11321 else if (Oversized.getBoolValue()) 11322 Diag(Loc, diag::err_array_too_large) 11323 << Oversized.toString(10); 11324 else 11325 Diag(Loc, diag::err_typecheck_field_variable_size); 11326 InvalidDecl = true; 11327 } 11328 } 11329 11330 // Fields can not have abstract class types 11331 if (!InvalidDecl && RequireNonAbstractType(Loc, T, 11332 diag::err_abstract_type_in_decl, 11333 AbstractFieldType)) 11334 InvalidDecl = true; 11335 11336 bool ZeroWidth = false; 11337 // If this is declared as a bit-field, check the bit-field. 11338 if (!InvalidDecl && BitWidth) { 11339 BitWidth = VerifyBitField(Loc, II, T, Record->isMsStruct(Context), BitWidth, 11340 &ZeroWidth).take(); 11341 if (!BitWidth) { 11342 InvalidDecl = true; 11343 BitWidth = 0; 11344 ZeroWidth = false; 11345 } 11346 } 11347 11348 // Check that 'mutable' is consistent with the type of the declaration. 11349 if (!InvalidDecl && Mutable) { 11350 unsigned DiagID = 0; 11351 if (T->isReferenceType()) 11352 DiagID = diag::err_mutable_reference; 11353 else if (T.isConstQualified()) 11354 DiagID = diag::err_mutable_const; 11355 11356 if (DiagID) { 11357 SourceLocation ErrLoc = Loc; 11358 if (D && D->getDeclSpec().getStorageClassSpecLoc().isValid()) 11359 ErrLoc = D->getDeclSpec().getStorageClassSpecLoc(); 11360 Diag(ErrLoc, DiagID); 11361 Mutable = false; 11362 InvalidDecl = true; 11363 } 11364 } 11365 11366 FieldDecl *NewFD = FieldDecl::Create(Context, Record, TSSL, Loc, II, T, TInfo, 11367 BitWidth, Mutable, InitStyle); 11368 if (InvalidDecl) 11369 NewFD->setInvalidDecl(); 11370 11371 if (PrevDecl && !isa<TagDecl>(PrevDecl)) { 11372 Diag(Loc, diag::err_duplicate_member) << II; 11373 Diag(PrevDecl->getLocation(), diag::note_previous_declaration); 11374 NewFD->setInvalidDecl(); 11375 } 11376 11377 if (!InvalidDecl && getLangOpts().CPlusPlus) { 11378 if (Record->isUnion()) { 11379 if (const RecordType *RT = EltTy->getAs<RecordType>()) { 11380 CXXRecordDecl* RDecl = cast<CXXRecordDecl>(RT->getDecl()); 11381 if (RDecl->getDefinition()) { 11382 // C++ [class.union]p1: An object of a class with a non-trivial 11383 // constructor, a non-trivial copy constructor, a non-trivial 11384 // destructor, or a non-trivial copy assignment operator 11385 // cannot be a member of a union, nor can an array of such 11386 // objects. 11387 if (CheckNontrivialField(NewFD)) 11388 NewFD->setInvalidDecl(); 11389 } 11390 } 11391 11392 // C++ [class.union]p1: If a union contains a member of reference type, 11393 // the program is ill-formed, except when compiling with MSVC extensions 11394 // enabled. 11395 if (EltTy->isReferenceType()) { 11396 Diag(NewFD->getLocation(), getLangOpts().MicrosoftExt ? 11397 diag::ext_union_member_of_reference_type : 11398 diag::err_union_member_of_reference_type) 11399 << NewFD->getDeclName() << EltTy; 11400 if (!getLangOpts().MicrosoftExt) 11401 NewFD->setInvalidDecl(); 11402 } 11403 } 11404 } 11405 11406 // FIXME: We need to pass in the attributes given an AST 11407 // representation, not a parser representation. 11408 if (D) { 11409 // FIXME: The current scope is almost... but not entirely... correct here. 11410 ProcessDeclAttributes(getCurScope(), NewFD, *D); 11411 11412 if (NewFD->hasAttrs()) 11413 CheckAlignasUnderalignment(NewFD); 11414 } 11415 11416 // In auto-retain/release, infer strong retension for fields of 11417 // retainable type. 11418 if (getLangOpts().ObjCAutoRefCount && inferObjCARCLifetime(NewFD)) 11419 NewFD->setInvalidDecl(); 11420 11421 if (T.isObjCGCWeak()) 11422 Diag(Loc, diag::warn_attribute_weak_on_field); 11423 11424 NewFD->setAccess(AS); 11425 return NewFD; 11426} 11427 11428bool Sema::CheckNontrivialField(FieldDecl *FD) { 11429 assert(FD); 11430 assert(getLangOpts().CPlusPlus && "valid check only for C++"); 11431 11432 if (FD->isInvalidDecl() || FD->getType()->isDependentType()) 11433 return false; 11434 11435 QualType EltTy = Context.getBaseElementType(FD->getType()); 11436 if (const RecordType *RT = EltTy->getAs<RecordType>()) { 11437 CXXRecordDecl *RDecl = cast<CXXRecordDecl>(RT->getDecl()); 11438 if (RDecl->getDefinition()) { 11439 // We check for copy constructors before constructors 11440 // because otherwise we'll never get complaints about 11441 // copy constructors. 11442 11443 CXXSpecialMember member = CXXInvalid; 11444 // We're required to check for any non-trivial constructors. Since the 11445 // implicit default constructor is suppressed if there are any 11446 // user-declared constructors, we just need to check that there is a 11447 // trivial default constructor and a trivial copy constructor. (We don't 11448 // worry about move constructors here, since this is a C++98 check.) 11449 if (RDecl->hasNonTrivialCopyConstructor()) 11450 member = CXXCopyConstructor; 11451 else if (!RDecl->hasTrivialDefaultConstructor()) 11452 member = CXXDefaultConstructor; 11453 else if (RDecl->hasNonTrivialCopyAssignment()) 11454 member = CXXCopyAssignment; 11455 else if (RDecl->hasNonTrivialDestructor()) 11456 member = CXXDestructor; 11457 11458 if (member != CXXInvalid) { 11459 if (!getLangOpts().CPlusPlus11 && 11460 getLangOpts().ObjCAutoRefCount && RDecl->hasObjectMember()) { 11461 // Objective-C++ ARC: it is an error to have a non-trivial field of 11462 // a union. However, system headers in Objective-C programs 11463 // occasionally have Objective-C lifetime objects within unions, 11464 // and rather than cause the program to fail, we make those 11465 // members unavailable. 11466 SourceLocation Loc = FD->getLocation(); 11467 if (getSourceManager().isInSystemHeader(Loc)) { 11468 if (!FD->hasAttr<UnavailableAttr>()) 11469 FD->addAttr(new (Context) UnavailableAttr(Loc, Context, 11470 "this system field has retaining ownership")); 11471 return false; 11472 } 11473 } 11474 11475 Diag(FD->getLocation(), getLangOpts().CPlusPlus11 ? 11476 diag::warn_cxx98_compat_nontrivial_union_or_anon_struct_member : 11477 diag::err_illegal_union_or_anon_struct_member) 11478 << (int)FD->getParent()->isUnion() << FD->getDeclName() << member; 11479 DiagnoseNontrivial(RDecl, member); 11480 return !getLangOpts().CPlusPlus11; 11481 } 11482 } 11483 } 11484 11485 return false; 11486} 11487 11488/// TranslateIvarVisibility - Translate visibility from a token ID to an 11489/// AST enum value. 11490static ObjCIvarDecl::AccessControl 11491TranslateIvarVisibility(tok::ObjCKeywordKind ivarVisibility) { 11492 switch (ivarVisibility) { 11493 default: llvm_unreachable("Unknown visitibility kind"); 11494 case tok::objc_private: return ObjCIvarDecl::Private; 11495 case tok::objc_public: return ObjCIvarDecl::Public; 11496 case tok::objc_protected: return ObjCIvarDecl::Protected; 11497 case tok::objc_package: return ObjCIvarDecl::Package; 11498 } 11499} 11500 11501/// ActOnIvar - Each ivar field of an objective-c class is passed into this 11502/// in order to create an IvarDecl object for it. 11503Decl *Sema::ActOnIvar(Scope *S, 11504 SourceLocation DeclStart, 11505 Declarator &D, Expr *BitfieldWidth, 11506 tok::ObjCKeywordKind Visibility) { 11507 11508 IdentifierInfo *II = D.getIdentifier(); 11509 Expr *BitWidth = (Expr*)BitfieldWidth; 11510 SourceLocation Loc = DeclStart; 11511 if (II) Loc = D.getIdentifierLoc(); 11512 11513 // FIXME: Unnamed fields can be handled in various different ways, for 11514 // example, unnamed unions inject all members into the struct namespace! 11515 11516 TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S); 11517 QualType T = TInfo->getType(); 11518 11519 if (BitWidth) { 11520 // 6.7.2.1p3, 6.7.2.1p4 11521 BitWidth = VerifyBitField(Loc, II, T, /*IsMsStruct*/false, BitWidth).take(); 11522 if (!BitWidth) 11523 D.setInvalidType(); 11524 } else { 11525 // Not a bitfield. 11526 11527 // validate II. 11528 11529 } 11530 if (T->isReferenceType()) { 11531 Diag(Loc, diag::err_ivar_reference_type); 11532 D.setInvalidType(); 11533 } 11534 // C99 6.7.2.1p8: A member of a structure or union may have any type other 11535 // than a variably modified type. 11536 else if (T->isVariablyModifiedType()) { 11537 Diag(Loc, diag::err_typecheck_ivar_variable_size); 11538 D.setInvalidType(); 11539 } 11540 11541 // Get the visibility (access control) for this ivar. 11542 ObjCIvarDecl::AccessControl ac = 11543 Visibility != tok::objc_not_keyword ? TranslateIvarVisibility(Visibility) 11544 : ObjCIvarDecl::None; 11545 // Must set ivar's DeclContext to its enclosing interface. 11546 ObjCContainerDecl *EnclosingDecl = cast<ObjCContainerDecl>(CurContext); 11547 if (!EnclosingDecl || EnclosingDecl->isInvalidDecl()) 11548 return 0; 11549 ObjCContainerDecl *EnclosingContext; 11550 if (ObjCImplementationDecl *IMPDecl = 11551 dyn_cast<ObjCImplementationDecl>(EnclosingDecl)) { 11552 if (LangOpts.ObjCRuntime.isFragile()) { 11553 // Case of ivar declared in an implementation. Context is that of its class. 11554 EnclosingContext = IMPDecl->getClassInterface(); 11555 assert(EnclosingContext && "Implementation has no class interface!"); 11556 } 11557 else 11558 EnclosingContext = EnclosingDecl; 11559 } else { 11560 if (ObjCCategoryDecl *CDecl = 11561 dyn_cast<ObjCCategoryDecl>(EnclosingDecl)) { 11562 if (LangOpts.ObjCRuntime.isFragile() || !CDecl->IsClassExtension()) { 11563 Diag(Loc, diag::err_misplaced_ivar) << CDecl->IsClassExtension(); 11564 return 0; 11565 } 11566 } 11567 EnclosingContext = EnclosingDecl; 11568 } 11569 11570 // Construct the decl. 11571 ObjCIvarDecl *NewID = ObjCIvarDecl::Create(Context, EnclosingContext, 11572 DeclStart, Loc, II, T, 11573 TInfo, ac, (Expr *)BitfieldWidth); 11574 11575 if (II) { 11576 NamedDecl *PrevDecl = LookupSingleName(S, II, Loc, LookupMemberName, 11577 ForRedeclaration); 11578 if (PrevDecl && isDeclInScope(PrevDecl, EnclosingContext, S) 11579 && !isa<TagDecl>(PrevDecl)) { 11580 Diag(Loc, diag::err_duplicate_member) << II; 11581 Diag(PrevDecl->getLocation(), diag::note_previous_declaration); 11582 NewID->setInvalidDecl(); 11583 } 11584 } 11585 11586 // Process attributes attached to the ivar. 11587 ProcessDeclAttributes(S, NewID, D); 11588 11589 if (D.isInvalidType()) 11590 NewID->setInvalidDecl(); 11591 11592 // In ARC, infer 'retaining' for ivars of retainable type. 11593 if (getLangOpts().ObjCAutoRefCount && inferObjCARCLifetime(NewID)) 11594 NewID->setInvalidDecl(); 11595 11596 if (D.getDeclSpec().isModulePrivateSpecified()) 11597 NewID->setModulePrivate(); 11598 11599 if (II) { 11600 // FIXME: When interfaces are DeclContexts, we'll need to add 11601 // these to the interface. 11602 S->AddDecl(NewID); 11603 IdResolver.AddDecl(NewID); 11604 } 11605 11606 if (LangOpts.ObjCRuntime.isNonFragile() && 11607 !NewID->isInvalidDecl() && isa<ObjCInterfaceDecl>(EnclosingDecl)) 11608 Diag(Loc, diag::warn_ivars_in_interface); 11609 11610 return NewID; 11611} 11612 11613/// ActOnLastBitfield - This routine handles synthesized bitfields rules for 11614/// class and class extensions. For every class \@interface and class 11615/// extension \@interface, if the last ivar is a bitfield of any type, 11616/// then add an implicit `char :0` ivar to the end of that interface. 11617void Sema::ActOnLastBitfield(SourceLocation DeclLoc, 11618 SmallVectorImpl<Decl *> &AllIvarDecls) { 11619 if (LangOpts.ObjCRuntime.isFragile() || AllIvarDecls.empty()) 11620 return; 11621 11622 Decl *ivarDecl = AllIvarDecls[AllIvarDecls.size()-1]; 11623 ObjCIvarDecl *Ivar = cast<ObjCIvarDecl>(ivarDecl); 11624 11625 if (!Ivar->isBitField() || Ivar->getBitWidthValue(Context) == 0) 11626 return; 11627 ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(CurContext); 11628 if (!ID) { 11629 if (ObjCCategoryDecl *CD = dyn_cast<ObjCCategoryDecl>(CurContext)) { 11630 if (!CD->IsClassExtension()) 11631 return; 11632 } 11633 // No need to add this to end of @implementation. 11634 else 11635 return; 11636 } 11637 // All conditions are met. Add a new bitfield to the tail end of ivars. 11638 llvm::APInt Zero(Context.getTypeSize(Context.IntTy), 0); 11639 Expr * BW = IntegerLiteral::Create(Context, Zero, Context.IntTy, DeclLoc); 11640 11641 Ivar = ObjCIvarDecl::Create(Context, cast<ObjCContainerDecl>(CurContext), 11642 DeclLoc, DeclLoc, 0, 11643 Context.CharTy, 11644 Context.getTrivialTypeSourceInfo(Context.CharTy, 11645 DeclLoc), 11646 ObjCIvarDecl::Private, BW, 11647 true); 11648 AllIvarDecls.push_back(Ivar); 11649} 11650 11651void Sema::ActOnFields(Scope *S, SourceLocation RecLoc, Decl *EnclosingDecl, 11652 ArrayRef<Decl *> Fields, SourceLocation LBrac, 11653 SourceLocation RBrac, AttributeList *Attr) { 11654 assert(EnclosingDecl && "missing record or interface decl"); 11655 11656 // If this is an Objective-C @implementation or category and we have 11657 // new fields here we should reset the layout of the interface since 11658 // it will now change. 11659 if (!Fields.empty() && isa<ObjCContainerDecl>(EnclosingDecl)) { 11660 ObjCContainerDecl *DC = cast<ObjCContainerDecl>(EnclosingDecl); 11661 switch (DC->getKind()) { 11662 default: break; 11663 case Decl::ObjCCategory: 11664 Context.ResetObjCLayout(cast<ObjCCategoryDecl>(DC)->getClassInterface()); 11665 break; 11666 case Decl::ObjCImplementation: 11667 Context. 11668 ResetObjCLayout(cast<ObjCImplementationDecl>(DC)->getClassInterface()); 11669 break; 11670 } 11671 } 11672 11673 RecordDecl *Record = dyn_cast<RecordDecl>(EnclosingDecl); 11674 11675 // Start counting up the number of named members; make sure to include 11676 // members of anonymous structs and unions in the total. 11677 unsigned NumNamedMembers = 0; 11678 if (Record) { 11679 for (RecordDecl::decl_iterator i = Record->decls_begin(), 11680 e = Record->decls_end(); i != e; i++) { 11681 if (IndirectFieldDecl *IFD = dyn_cast<IndirectFieldDecl>(*i)) 11682 if (IFD->getDeclName()) 11683 ++NumNamedMembers; 11684 } 11685 } 11686 11687 // Verify that all the fields are okay. 11688 SmallVector<FieldDecl*, 32> RecFields; 11689 11690 bool ARCErrReported = false; 11691 for (ArrayRef<Decl *>::iterator i = Fields.begin(), end = Fields.end(); 11692 i != end; ++i) { 11693 FieldDecl *FD = cast<FieldDecl>(*i); 11694 11695 // Get the type for the field. 11696 const Type *FDTy = FD->getType().getTypePtr(); 11697 11698 if (!FD->isAnonymousStructOrUnion()) { 11699 // Remember all fields written by the user. 11700 RecFields.push_back(FD); 11701 } 11702 11703 // If the field is already invalid for some reason, don't emit more 11704 // diagnostics about it. 11705 if (FD->isInvalidDecl()) { 11706 EnclosingDecl->setInvalidDecl(); 11707 continue; 11708 } 11709 11710 // C99 6.7.2.1p2: 11711 // A structure or union shall not contain a member with 11712 // incomplete or function type (hence, a structure shall not 11713 // contain an instance of itself, but may contain a pointer to 11714 // an instance of itself), except that the last member of a 11715 // structure with more than one named member may have incomplete 11716 // array type; such a structure (and any union containing, 11717 // possibly recursively, a member that is such a structure) 11718 // shall not be a member of a structure or an element of an 11719 // array. 11720 if (FDTy->isFunctionType()) { 11721 // Field declared as a function. 11722 Diag(FD->getLocation(), diag::err_field_declared_as_function) 11723 << FD->getDeclName(); 11724 FD->setInvalidDecl(); 11725 EnclosingDecl->setInvalidDecl(); 11726 continue; 11727 } else if (FDTy->isIncompleteArrayType() && Record && 11728 ((i + 1 == Fields.end() && !Record->isUnion()) || 11729 ((getLangOpts().MicrosoftExt || 11730 getLangOpts().CPlusPlus) && 11731 (i + 1 == Fields.end() || Record->isUnion())))) { 11732 // Flexible array member. 11733 // Microsoft and g++ is more permissive regarding flexible array. 11734 // It will accept flexible array in union and also 11735 // as the sole element of a struct/class. 11736 if (getLangOpts().MicrosoftExt) { 11737 if (Record->isUnion()) 11738 Diag(FD->getLocation(), diag::ext_flexible_array_union_ms) 11739 << FD->getDeclName(); 11740 else if (Fields.size() == 1) 11741 Diag(FD->getLocation(), diag::ext_flexible_array_empty_aggregate_ms) 11742 << FD->getDeclName() << Record->getTagKind(); 11743 } else if (getLangOpts().CPlusPlus) { 11744 if (Record->isUnion()) 11745 Diag(FD->getLocation(), diag::ext_flexible_array_union_gnu) 11746 << FD->getDeclName(); 11747 else if (Fields.size() == 1) 11748 Diag(FD->getLocation(), diag::ext_flexible_array_empty_aggregate_gnu) 11749 << FD->getDeclName() << Record->getTagKind(); 11750 } else if (!getLangOpts().C99) { 11751 if (Record->isUnion()) 11752 Diag(FD->getLocation(), diag::ext_flexible_array_union_gnu) 11753 << FD->getDeclName(); 11754 else 11755 Diag(FD->getLocation(), diag::ext_c99_flexible_array_member) 11756 << FD->getDeclName() << Record->getTagKind(); 11757 } else if (NumNamedMembers < 1) { 11758 Diag(FD->getLocation(), diag::err_flexible_array_empty_struct) 11759 << FD->getDeclName(); 11760 FD->setInvalidDecl(); 11761 EnclosingDecl->setInvalidDecl(); 11762 continue; 11763 } 11764 if (!FD->getType()->isDependentType() && 11765 !Context.getBaseElementType(FD->getType()).isPODType(Context)) { 11766 Diag(FD->getLocation(), diag::err_flexible_array_has_nonpod_type) 11767 << FD->getDeclName() << FD->getType(); 11768 FD->setInvalidDecl(); 11769 EnclosingDecl->setInvalidDecl(); 11770 continue; 11771 } 11772 // Okay, we have a legal flexible array member at the end of the struct. 11773 if (Record) 11774 Record->setHasFlexibleArrayMember(true); 11775 } else if (!FDTy->isDependentType() && 11776 RequireCompleteType(FD->getLocation(), FD->getType(), 11777 diag::err_field_incomplete)) { 11778 // Incomplete type 11779 FD->setInvalidDecl(); 11780 EnclosingDecl->setInvalidDecl(); 11781 continue; 11782 } else if (const RecordType *FDTTy = FDTy->getAs<RecordType>()) { 11783 if (FDTTy->getDecl()->hasFlexibleArrayMember()) { 11784 // If this is a member of a union, then entire union becomes "flexible". 11785 if (Record && Record->isUnion()) { 11786 Record->setHasFlexibleArrayMember(true); 11787 } else { 11788 // If this is a struct/class and this is not the last element, reject 11789 // it. Note that GCC supports variable sized arrays in the middle of 11790 // structures. 11791 if (i + 1 != Fields.end()) 11792 Diag(FD->getLocation(), diag::ext_variable_sized_type_in_struct) 11793 << FD->getDeclName() << FD->getType(); 11794 else { 11795 // We support flexible arrays at the end of structs in 11796 // other structs as an extension. 11797 Diag(FD->getLocation(), diag::ext_flexible_array_in_struct) 11798 << FD->getDeclName(); 11799 if (Record) 11800 Record->setHasFlexibleArrayMember(true); 11801 } 11802 } 11803 } 11804 if (isa<ObjCContainerDecl>(EnclosingDecl) && 11805 RequireNonAbstractType(FD->getLocation(), FD->getType(), 11806 diag::err_abstract_type_in_decl, 11807 AbstractIvarType)) { 11808 // Ivars can not have abstract class types 11809 FD->setInvalidDecl(); 11810 } 11811 if (Record && FDTTy->getDecl()->hasObjectMember()) 11812 Record->setHasObjectMember(true); 11813 if (Record && FDTTy->getDecl()->hasVolatileMember()) 11814 Record->setHasVolatileMember(true); 11815 } else if (FDTy->isObjCObjectType()) { 11816 /// A field cannot be an Objective-c object 11817 Diag(FD->getLocation(), diag::err_statically_allocated_object) 11818 << FixItHint::CreateInsertion(FD->getLocation(), "*"); 11819 QualType T = Context.getObjCObjectPointerType(FD->getType()); 11820 FD->setType(T); 11821 } else if (getLangOpts().ObjCAutoRefCount && Record && !ARCErrReported && 11822 (!getLangOpts().CPlusPlus || Record->isUnion())) { 11823 // It's an error in ARC if a field has lifetime. 11824 // We don't want to report this in a system header, though, 11825 // so we just make the field unavailable. 11826 // FIXME: that's really not sufficient; we need to make the type 11827 // itself invalid to, say, initialize or copy. 11828 QualType T = FD->getType(); 11829 Qualifiers::ObjCLifetime lifetime = T.getObjCLifetime(); 11830 if (lifetime && lifetime != Qualifiers::OCL_ExplicitNone) { 11831 SourceLocation loc = FD->getLocation(); 11832 if (getSourceManager().isInSystemHeader(loc)) { 11833 if (!FD->hasAttr<UnavailableAttr>()) { 11834 FD->addAttr(new (Context) UnavailableAttr(loc, Context, 11835 "this system field has retaining ownership")); 11836 } 11837 } else { 11838 Diag(FD->getLocation(), diag::err_arc_objc_object_in_tag) 11839 << T->isBlockPointerType() << Record->getTagKind(); 11840 } 11841 ARCErrReported = true; 11842 } 11843 } else if (getLangOpts().ObjC1 && 11844 getLangOpts().getGC() != LangOptions::NonGC && 11845 Record && !Record->hasObjectMember()) { 11846 if (FD->getType()->isObjCObjectPointerType() || 11847 FD->getType().isObjCGCStrong()) 11848 Record->setHasObjectMember(true); 11849 else if (Context.getAsArrayType(FD->getType())) { 11850 QualType BaseType = Context.getBaseElementType(FD->getType()); 11851 if (BaseType->isRecordType() && 11852 BaseType->getAs<RecordType>()->getDecl()->hasObjectMember()) 11853 Record->setHasObjectMember(true); 11854 else if (BaseType->isObjCObjectPointerType() || 11855 BaseType.isObjCGCStrong()) 11856 Record->setHasObjectMember(true); 11857 } 11858 } 11859 if (Record && FD->getType().isVolatileQualified()) 11860 Record->setHasVolatileMember(true); 11861 // Keep track of the number of named members. 11862 if (FD->getIdentifier()) 11863 ++NumNamedMembers; 11864 } 11865 11866 // Okay, we successfully defined 'Record'. 11867 if (Record) { 11868 bool Completed = false; 11869 if (CXXRecordDecl *CXXRecord = dyn_cast<CXXRecordDecl>(Record)) { 11870 if (!CXXRecord->isInvalidDecl()) { 11871 // Set access bits correctly on the directly-declared conversions. 11872 for (CXXRecordDecl::conversion_iterator 11873 I = CXXRecord->conversion_begin(), 11874 E = CXXRecord->conversion_end(); I != E; ++I) 11875 I.setAccess((*I)->getAccess()); 11876 11877 if (!CXXRecord->isDependentType()) { 11878 if (CXXRecord->hasUserDeclaredDestructor()) { 11879 // Adjust user-defined destructor exception spec. 11880 if (getLangOpts().CPlusPlus11) 11881 AdjustDestructorExceptionSpec(CXXRecord, 11882 CXXRecord->getDestructor()); 11883 11884 // The Microsoft ABI requires that we perform the destructor body 11885 // checks (i.e. operator delete() lookup) at every declaration, as 11886 // any translation unit may need to emit a deleting destructor. 11887 if (Context.getTargetInfo().getCXXABI().isMicrosoft()) 11888 CheckDestructor(CXXRecord->getDestructor()); 11889 } 11890 11891 // Add any implicitly-declared members to this class. 11892 AddImplicitlyDeclaredMembersToClass(CXXRecord); 11893 11894 // If we have virtual base classes, we may end up finding multiple 11895 // final overriders for a given virtual function. Check for this 11896 // problem now. 11897 if (CXXRecord->getNumVBases()) { 11898 CXXFinalOverriderMap FinalOverriders; 11899 CXXRecord->getFinalOverriders(FinalOverriders); 11900 11901 for (CXXFinalOverriderMap::iterator M = FinalOverriders.begin(), 11902 MEnd = FinalOverriders.end(); 11903 M != MEnd; ++M) { 11904 for (OverridingMethods::iterator SO = M->second.begin(), 11905 SOEnd = M->second.end(); 11906 SO != SOEnd; ++SO) { 11907 assert(SO->second.size() > 0 && 11908 "Virtual function without overridding functions?"); 11909 if (SO->second.size() == 1) 11910 continue; 11911 11912 // C++ [class.virtual]p2: 11913 // In a derived class, if a virtual member function of a base 11914 // class subobject has more than one final overrider the 11915 // program is ill-formed. 11916 Diag(Record->getLocation(), diag::err_multiple_final_overriders) 11917 << (const NamedDecl *)M->first << Record; 11918 Diag(M->first->getLocation(), 11919 diag::note_overridden_virtual_function); 11920 for (OverridingMethods::overriding_iterator 11921 OM = SO->second.begin(), 11922 OMEnd = SO->second.end(); 11923 OM != OMEnd; ++OM) 11924 Diag(OM->Method->getLocation(), diag::note_final_overrider) 11925 << (const NamedDecl *)M->first << OM->Method->getParent(); 11926 11927 Record->setInvalidDecl(); 11928 } 11929 } 11930 CXXRecord->completeDefinition(&FinalOverriders); 11931 Completed = true; 11932 } 11933 } 11934 } 11935 } 11936 11937 if (!Completed) 11938 Record->completeDefinition(); 11939 11940 if (Record->hasAttrs()) 11941 CheckAlignasUnderalignment(Record); 11942 11943 // Check if the structure/union declaration is a language extension. 11944 if (!getLangOpts().CPlusPlus) { 11945 bool ZeroSize = true; 11946 bool IsEmpty = true; 11947 unsigned NonBitFields = 0; 11948 for (RecordDecl::field_iterator I = Record->field_begin(), 11949 E = Record->field_end(); 11950 (NonBitFields == 0 || ZeroSize) && I != E; ++I) { 11951 IsEmpty = false; 11952 if (I->isUnnamedBitfield()) { 11953 if (I->getBitWidthValue(Context) > 0) 11954 ZeroSize = false; 11955 } else { 11956 ++NonBitFields; 11957 QualType FieldType = I->getType(); 11958 if (FieldType->isIncompleteType() || 11959 !Context.getTypeSizeInChars(FieldType).isZero()) 11960 ZeroSize = false; 11961 } 11962 } 11963 11964 // Empty structs are an extension in C (C99 6.7.2.1p7), but are allowed in 11965 // C++. 11966 if (ZeroSize) 11967 Diag(RecLoc, diag::warn_zero_size_struct_union_compat) << IsEmpty 11968 << Record->isUnion() << (NonBitFields > 1); 11969 11970 // Structs without named members are extension in C (C99 6.7.2.1p7), but 11971 // are accepted by GCC. 11972 if (NonBitFields == 0) { 11973 if (IsEmpty) 11974 Diag(RecLoc, diag::ext_empty_struct_union) << Record->isUnion(); 11975 else 11976 Diag(RecLoc, diag::ext_no_named_members_in_struct_union) << Record->isUnion(); 11977 } 11978 } 11979 } else { 11980 ObjCIvarDecl **ClsFields = 11981 reinterpret_cast<ObjCIvarDecl**>(RecFields.data()); 11982 if (ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(EnclosingDecl)) { 11983 ID->setEndOfDefinitionLoc(RBrac); 11984 // Add ivar's to class's DeclContext. 11985 for (unsigned i = 0, e = RecFields.size(); i != e; ++i) { 11986 ClsFields[i]->setLexicalDeclContext(ID); 11987 ID->addDecl(ClsFields[i]); 11988 } 11989 // Must enforce the rule that ivars in the base classes may not be 11990 // duplicates. 11991 if (ID->getSuperClass()) 11992 DiagnoseDuplicateIvars(ID, ID->getSuperClass()); 11993 } else if (ObjCImplementationDecl *IMPDecl = 11994 dyn_cast<ObjCImplementationDecl>(EnclosingDecl)) { 11995 assert(IMPDecl && "ActOnFields - missing ObjCImplementationDecl"); 11996 for (unsigned I = 0, N = RecFields.size(); I != N; ++I) 11997 // Ivar declared in @implementation never belongs to the implementation. 11998 // Only it is in implementation's lexical context. 11999 ClsFields[I]->setLexicalDeclContext(IMPDecl); 12000 CheckImplementationIvars(IMPDecl, ClsFields, RecFields.size(), RBrac); 12001 IMPDecl->setIvarLBraceLoc(LBrac); 12002 IMPDecl->setIvarRBraceLoc(RBrac); 12003 } else if (ObjCCategoryDecl *CDecl = 12004 dyn_cast<ObjCCategoryDecl>(EnclosingDecl)) { 12005 // case of ivars in class extension; all other cases have been 12006 // reported as errors elsewhere. 12007 // FIXME. Class extension does not have a LocEnd field. 12008 // CDecl->setLocEnd(RBrac); 12009 // Add ivar's to class extension's DeclContext. 12010 // Diagnose redeclaration of private ivars. 12011 ObjCInterfaceDecl *IDecl = CDecl->getClassInterface(); 12012 for (unsigned i = 0, e = RecFields.size(); i != e; ++i) { 12013 if (IDecl) { 12014 if (const ObjCIvarDecl *ClsIvar = 12015 IDecl->getIvarDecl(ClsFields[i]->getIdentifier())) { 12016 Diag(ClsFields[i]->getLocation(), 12017 diag::err_duplicate_ivar_declaration); 12018 Diag(ClsIvar->getLocation(), diag::note_previous_definition); 12019 continue; 12020 } 12021 for (ObjCInterfaceDecl::known_extensions_iterator 12022 Ext = IDecl->known_extensions_begin(), 12023 ExtEnd = IDecl->known_extensions_end(); 12024 Ext != ExtEnd; ++Ext) { 12025 if (const ObjCIvarDecl *ClsExtIvar 12026 = Ext->getIvarDecl(ClsFields[i]->getIdentifier())) { 12027 Diag(ClsFields[i]->getLocation(), 12028 diag::err_duplicate_ivar_declaration); 12029 Diag(ClsExtIvar->getLocation(), diag::note_previous_definition); 12030 continue; 12031 } 12032 } 12033 } 12034 ClsFields[i]->setLexicalDeclContext(CDecl); 12035 CDecl->addDecl(ClsFields[i]); 12036 } 12037 CDecl->setIvarLBraceLoc(LBrac); 12038 CDecl->setIvarRBraceLoc(RBrac); 12039 } 12040 } 12041 12042 if (Attr) 12043 ProcessDeclAttributeList(S, Record, Attr); 12044} 12045 12046/// \brief Determine whether the given integral value is representable within 12047/// the given type T. 12048static bool isRepresentableIntegerValue(ASTContext &Context, 12049 llvm::APSInt &Value, 12050 QualType T) { 12051 assert(T->isIntegralType(Context) && "Integral type required!"); 12052 unsigned BitWidth = Context.getIntWidth(T); 12053 12054 if (Value.isUnsigned() || Value.isNonNegative()) { 12055 if (T->isSignedIntegerOrEnumerationType()) 12056 --BitWidth; 12057 return Value.getActiveBits() <= BitWidth; 12058 } 12059 return Value.getMinSignedBits() <= BitWidth; 12060} 12061 12062// \brief Given an integral type, return the next larger integral type 12063// (or a NULL type of no such type exists). 12064static QualType getNextLargerIntegralType(ASTContext &Context, QualType T) { 12065 // FIXME: Int128/UInt128 support, which also needs to be introduced into 12066 // enum checking below. 12067 assert(T->isIntegralType(Context) && "Integral type required!"); 12068 const unsigned NumTypes = 4; 12069 QualType SignedIntegralTypes[NumTypes] = { 12070 Context.ShortTy, Context.IntTy, Context.LongTy, Context.LongLongTy 12071 }; 12072 QualType UnsignedIntegralTypes[NumTypes] = { 12073 Context.UnsignedShortTy, Context.UnsignedIntTy, Context.UnsignedLongTy, 12074 Context.UnsignedLongLongTy 12075 }; 12076 12077 unsigned BitWidth = Context.getTypeSize(T); 12078 QualType *Types = T->isSignedIntegerOrEnumerationType()? SignedIntegralTypes 12079 : UnsignedIntegralTypes; 12080 for (unsigned I = 0; I != NumTypes; ++I) 12081 if (Context.getTypeSize(Types[I]) > BitWidth) 12082 return Types[I]; 12083 12084 return QualType(); 12085} 12086 12087EnumConstantDecl *Sema::CheckEnumConstant(EnumDecl *Enum, 12088 EnumConstantDecl *LastEnumConst, 12089 SourceLocation IdLoc, 12090 IdentifierInfo *Id, 12091 Expr *Val) { 12092 unsigned IntWidth = Context.getTargetInfo().getIntWidth(); 12093 llvm::APSInt EnumVal(IntWidth); 12094 QualType EltTy; 12095 12096 if (Val && DiagnoseUnexpandedParameterPack(Val, UPPC_EnumeratorValue)) 12097 Val = 0; 12098 12099 if (Val) 12100 Val = DefaultLvalueConversion(Val).take(); 12101 12102 if (Val) { 12103 if (Enum->isDependentType() || Val->isTypeDependent()) 12104 EltTy = Context.DependentTy; 12105 else { 12106 SourceLocation ExpLoc; 12107 if (getLangOpts().CPlusPlus11 && Enum->isFixed() && 12108 !getLangOpts().MicrosoftMode) { 12109 // C++11 [dcl.enum]p5: If the underlying type is fixed, [...] the 12110 // constant-expression in the enumerator-definition shall be a converted 12111 // constant expression of the underlying type. 12112 EltTy = Enum->getIntegerType(); 12113 ExprResult Converted = 12114 CheckConvertedConstantExpression(Val, EltTy, EnumVal, 12115 CCEK_Enumerator); 12116 if (Converted.isInvalid()) 12117 Val = 0; 12118 else 12119 Val = Converted.take(); 12120 } else if (!Val->isValueDependent() && 12121 !(Val = VerifyIntegerConstantExpression(Val, 12122 &EnumVal).take())) { 12123 // C99 6.7.2.2p2: Make sure we have an integer constant expression. 12124 } else { 12125 if (Enum->isFixed()) { 12126 EltTy = Enum->getIntegerType(); 12127 12128 // In Obj-C and Microsoft mode, require the enumeration value to be 12129 // representable in the underlying type of the enumeration. In C++11, 12130 // we perform a non-narrowing conversion as part of converted constant 12131 // expression checking. 12132 if (!isRepresentableIntegerValue(Context, EnumVal, EltTy)) { 12133 if (getLangOpts().MicrosoftMode) { 12134 Diag(IdLoc, diag::ext_enumerator_too_large) << EltTy; 12135 Val = ImpCastExprToType(Val, EltTy, CK_IntegralCast).take(); 12136 } else 12137 Diag(IdLoc, diag::err_enumerator_too_large) << EltTy; 12138 } else 12139 Val = ImpCastExprToType(Val, EltTy, CK_IntegralCast).take(); 12140 } else if (getLangOpts().CPlusPlus) { 12141 // C++11 [dcl.enum]p5: 12142 // If the underlying type is not fixed, the type of each enumerator 12143 // is the type of its initializing value: 12144 // - If an initializer is specified for an enumerator, the 12145 // initializing value has the same type as the expression. 12146 EltTy = Val->getType(); 12147 } else { 12148 // C99 6.7.2.2p2: 12149 // The expression that defines the value of an enumeration constant 12150 // shall be an integer constant expression that has a value 12151 // representable as an int. 12152 12153 // Complain if the value is not representable in an int. 12154 if (!isRepresentableIntegerValue(Context, EnumVal, Context.IntTy)) 12155 Diag(IdLoc, diag::ext_enum_value_not_int) 12156 << EnumVal.toString(10) << Val->getSourceRange() 12157 << (EnumVal.isUnsigned() || EnumVal.isNonNegative()); 12158 else if (!Context.hasSameType(Val->getType(), Context.IntTy)) { 12159 // Force the type of the expression to 'int'. 12160 Val = ImpCastExprToType(Val, Context.IntTy, CK_IntegralCast).take(); 12161 } 12162 EltTy = Val->getType(); 12163 } 12164 } 12165 } 12166 } 12167 12168 if (!Val) { 12169 if (Enum->isDependentType()) 12170 EltTy = Context.DependentTy; 12171 else if (!LastEnumConst) { 12172 // C++0x [dcl.enum]p5: 12173 // If the underlying type is not fixed, the type of each enumerator 12174 // is the type of its initializing value: 12175 // - If no initializer is specified for the first enumerator, the 12176 // initializing value has an unspecified integral type. 12177 // 12178 // GCC uses 'int' for its unspecified integral type, as does 12179 // C99 6.7.2.2p3. 12180 if (Enum->isFixed()) { 12181 EltTy = Enum->getIntegerType(); 12182 } 12183 else { 12184 EltTy = Context.IntTy; 12185 } 12186 } else { 12187 // Assign the last value + 1. 12188 EnumVal = LastEnumConst->getInitVal(); 12189 ++EnumVal; 12190 EltTy = LastEnumConst->getType(); 12191 12192 // Check for overflow on increment. 12193 if (EnumVal < LastEnumConst->getInitVal()) { 12194 // C++0x [dcl.enum]p5: 12195 // If the underlying type is not fixed, the type of each enumerator 12196 // is the type of its initializing value: 12197 // 12198 // - Otherwise the type of the initializing value is the same as 12199 // the type of the initializing value of the preceding enumerator 12200 // unless the incremented value is not representable in that type, 12201 // in which case the type is an unspecified integral type 12202 // sufficient to contain the incremented value. If no such type 12203 // exists, the program is ill-formed. 12204 QualType T = getNextLargerIntegralType(Context, EltTy); 12205 if (T.isNull() || Enum->isFixed()) { 12206 // There is no integral type larger enough to represent this 12207 // value. Complain, then allow the value to wrap around. 12208 EnumVal = LastEnumConst->getInitVal(); 12209 EnumVal = EnumVal.zext(EnumVal.getBitWidth() * 2); 12210 ++EnumVal; 12211 if (Enum->isFixed()) 12212 // When the underlying type is fixed, this is ill-formed. 12213 Diag(IdLoc, diag::err_enumerator_wrapped) 12214 << EnumVal.toString(10) 12215 << EltTy; 12216 else 12217 Diag(IdLoc, diag::warn_enumerator_too_large) 12218 << EnumVal.toString(10); 12219 } else { 12220 EltTy = T; 12221 } 12222 12223 // Retrieve the last enumerator's value, extent that type to the 12224 // type that is supposed to be large enough to represent the incremented 12225 // value, then increment. 12226 EnumVal = LastEnumConst->getInitVal(); 12227 EnumVal.setIsSigned(EltTy->isSignedIntegerOrEnumerationType()); 12228 EnumVal = EnumVal.zextOrTrunc(Context.getIntWidth(EltTy)); 12229 ++EnumVal; 12230 12231 // If we're not in C++, diagnose the overflow of enumerator values, 12232 // which in C99 means that the enumerator value is not representable in 12233 // an int (C99 6.7.2.2p2). However, we support GCC's extension that 12234 // permits enumerator values that are representable in some larger 12235 // integral type. 12236 if (!getLangOpts().CPlusPlus && !T.isNull()) 12237 Diag(IdLoc, diag::warn_enum_value_overflow); 12238 } else if (!getLangOpts().CPlusPlus && 12239 !isRepresentableIntegerValue(Context, EnumVal, EltTy)) { 12240 // Enforce C99 6.7.2.2p2 even when we compute the next value. 12241 Diag(IdLoc, diag::ext_enum_value_not_int) 12242 << EnumVal.toString(10) << 1; 12243 } 12244 } 12245 } 12246 12247 if (!EltTy->isDependentType()) { 12248 // Make the enumerator value match the signedness and size of the 12249 // enumerator's type. 12250 EnumVal = EnumVal.extOrTrunc(Context.getIntWidth(EltTy)); 12251 EnumVal.setIsSigned(EltTy->isSignedIntegerOrEnumerationType()); 12252 } 12253 12254 return EnumConstantDecl::Create(Context, Enum, IdLoc, Id, EltTy, 12255 Val, EnumVal); 12256} 12257 12258 12259Decl *Sema::ActOnEnumConstant(Scope *S, Decl *theEnumDecl, Decl *lastEnumConst, 12260 SourceLocation IdLoc, IdentifierInfo *Id, 12261 AttributeList *Attr, 12262 SourceLocation EqualLoc, Expr *Val) { 12263 EnumDecl *TheEnumDecl = cast<EnumDecl>(theEnumDecl); 12264 EnumConstantDecl *LastEnumConst = 12265 cast_or_null<EnumConstantDecl>(lastEnumConst); 12266 12267 // The scope passed in may not be a decl scope. Zip up the scope tree until 12268 // we find one that is. 12269 S = getNonFieldDeclScope(S); 12270 12271 // Verify that there isn't already something declared with this name in this 12272 // scope. 12273 NamedDecl *PrevDecl = LookupSingleName(S, Id, IdLoc, LookupOrdinaryName, 12274 ForRedeclaration); 12275 if (PrevDecl && PrevDecl->isTemplateParameter()) { 12276 // Maybe we will complain about the shadowed template parameter. 12277 DiagnoseTemplateParameterShadow(IdLoc, PrevDecl); 12278 // Just pretend that we didn't see the previous declaration. 12279 PrevDecl = 0; 12280 } 12281 12282 if (PrevDecl) { 12283 // When in C++, we may get a TagDecl with the same name; in this case the 12284 // enum constant will 'hide' the tag. 12285 assert((getLangOpts().CPlusPlus || !isa<TagDecl>(PrevDecl)) && 12286 "Received TagDecl when not in C++!"); 12287 if (!isa<TagDecl>(PrevDecl) && isDeclInScope(PrevDecl, CurContext, S)) { 12288 if (isa<EnumConstantDecl>(PrevDecl)) 12289 Diag(IdLoc, diag::err_redefinition_of_enumerator) << Id; 12290 else 12291 Diag(IdLoc, diag::err_redefinition) << Id; 12292 Diag(PrevDecl->getLocation(), diag::note_previous_definition); 12293 return 0; 12294 } 12295 } 12296 12297 // C++ [class.mem]p15: 12298 // If T is the name of a class, then each of the following shall have a name 12299 // different from T: 12300 // - every enumerator of every member of class T that is an unscoped 12301 // enumerated type 12302 if (CXXRecordDecl *Record 12303 = dyn_cast<CXXRecordDecl>( 12304 TheEnumDecl->getDeclContext()->getRedeclContext())) 12305 if (!TheEnumDecl->isScoped() && 12306 Record->getIdentifier() && Record->getIdentifier() == Id) 12307 Diag(IdLoc, diag::err_member_name_of_class) << Id; 12308 12309 EnumConstantDecl *New = 12310 CheckEnumConstant(TheEnumDecl, LastEnumConst, IdLoc, Id, Val); 12311 12312 if (New) { 12313 // Process attributes. 12314 if (Attr) ProcessDeclAttributeList(S, New, Attr); 12315 12316 // Register this decl in the current scope stack. 12317 New->setAccess(TheEnumDecl->getAccess()); 12318 PushOnScopeChains(New, S); 12319 } 12320 12321 ActOnDocumentableDecl(New); 12322 12323 return New; 12324} 12325 12326// Returns true when the enum initial expression does not trigger the 12327// duplicate enum warning. A few common cases are exempted as follows: 12328// Element2 = Element1 12329// Element2 = Element1 + 1 12330// Element2 = Element1 - 1 12331// Where Element2 and Element1 are from the same enum. 12332static bool ValidDuplicateEnum(EnumConstantDecl *ECD, EnumDecl *Enum) { 12333 Expr *InitExpr = ECD->getInitExpr(); 12334 if (!InitExpr) 12335 return true; 12336 InitExpr = InitExpr->IgnoreImpCasts(); 12337 12338 if (BinaryOperator *BO = dyn_cast<BinaryOperator>(InitExpr)) { 12339 if (!BO->isAdditiveOp()) 12340 return true; 12341 IntegerLiteral *IL = dyn_cast<IntegerLiteral>(BO->getRHS()); 12342 if (!IL) 12343 return true; 12344 if (IL->getValue() != 1) 12345 return true; 12346 12347 InitExpr = BO->getLHS(); 12348 } 12349 12350 // This checks if the elements are from the same enum. 12351 DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(InitExpr); 12352 if (!DRE) 12353 return true; 12354 12355 EnumConstantDecl *EnumConstant = dyn_cast<EnumConstantDecl>(DRE->getDecl()); 12356 if (!EnumConstant) 12357 return true; 12358 12359 if (cast<EnumDecl>(TagDecl::castFromDeclContext(ECD->getDeclContext())) != 12360 Enum) 12361 return true; 12362 12363 return false; 12364} 12365 12366struct DupKey { 12367 int64_t val; 12368 bool isTombstoneOrEmptyKey; 12369 DupKey(int64_t val, bool isTombstoneOrEmptyKey) 12370 : val(val), isTombstoneOrEmptyKey(isTombstoneOrEmptyKey) {} 12371}; 12372 12373static DupKey GetDupKey(const llvm::APSInt& Val) { 12374 return DupKey(Val.isSigned() ? Val.getSExtValue() : Val.getZExtValue(), 12375 false); 12376} 12377 12378struct DenseMapInfoDupKey { 12379 static DupKey getEmptyKey() { return DupKey(0, true); } 12380 static DupKey getTombstoneKey() { return DupKey(1, true); } 12381 static unsigned getHashValue(const DupKey Key) { 12382 return (unsigned)(Key.val * 37); 12383 } 12384 static bool isEqual(const DupKey& LHS, const DupKey& RHS) { 12385 return LHS.isTombstoneOrEmptyKey == RHS.isTombstoneOrEmptyKey && 12386 LHS.val == RHS.val; 12387 } 12388}; 12389 12390// Emits a warning when an element is implicitly set a value that 12391// a previous element has already been set to. 12392static void CheckForDuplicateEnumValues(Sema &S, ArrayRef<Decl *> Elements, 12393 EnumDecl *Enum, 12394 QualType EnumType) { 12395 if (S.Diags.getDiagnosticLevel(diag::warn_duplicate_enum_values, 12396 Enum->getLocation()) == 12397 DiagnosticsEngine::Ignored) 12398 return; 12399 // Avoid anonymous enums 12400 if (!Enum->getIdentifier()) 12401 return; 12402 12403 // Only check for small enums. 12404 if (Enum->getNumPositiveBits() > 63 || Enum->getNumNegativeBits() > 64) 12405 return; 12406 12407 typedef SmallVector<EnumConstantDecl *, 3> ECDVector; 12408 typedef SmallVector<ECDVector *, 3> DuplicatesVector; 12409 12410 typedef llvm::PointerUnion<EnumConstantDecl*, ECDVector*> DeclOrVector; 12411 typedef llvm::DenseMap<DupKey, DeclOrVector, DenseMapInfoDupKey> 12412 ValueToVectorMap; 12413 12414 DuplicatesVector DupVector; 12415 ValueToVectorMap EnumMap; 12416 12417 // Populate the EnumMap with all values represented by enum constants without 12418 // an initialier. 12419 for (unsigned i = 0, e = Elements.size(); i != e; ++i) { 12420 EnumConstantDecl *ECD = cast_or_null<EnumConstantDecl>(Elements[i]); 12421 12422 // Null EnumConstantDecl means a previous diagnostic has been emitted for 12423 // this constant. Skip this enum since it may be ill-formed. 12424 if (!ECD) { 12425 return; 12426 } 12427 12428 if (ECD->getInitExpr()) 12429 continue; 12430 12431 DupKey Key = GetDupKey(ECD->getInitVal()); 12432 DeclOrVector &Entry = EnumMap[Key]; 12433 12434 // First time encountering this value. 12435 if (Entry.isNull()) 12436 Entry = ECD; 12437 } 12438 12439 // Create vectors for any values that has duplicates. 12440 for (unsigned i = 0, e = Elements.size(); i != e; ++i) { 12441 EnumConstantDecl *ECD = cast<EnumConstantDecl>(Elements[i]); 12442 if (!ValidDuplicateEnum(ECD, Enum)) 12443 continue; 12444 12445 DupKey Key = GetDupKey(ECD->getInitVal()); 12446 12447 DeclOrVector& Entry = EnumMap[Key]; 12448 if (Entry.isNull()) 12449 continue; 12450 12451 if (EnumConstantDecl *D = Entry.dyn_cast<EnumConstantDecl*>()) { 12452 // Ensure constants are different. 12453 if (D == ECD) 12454 continue; 12455 12456 // Create new vector and push values onto it. 12457 ECDVector *Vec = new ECDVector(); 12458 Vec->push_back(D); 12459 Vec->push_back(ECD); 12460 12461 // Update entry to point to the duplicates vector. 12462 Entry = Vec; 12463 12464 // Store the vector somewhere we can consult later for quick emission of 12465 // diagnostics. 12466 DupVector.push_back(Vec); 12467 continue; 12468 } 12469 12470 ECDVector *Vec = Entry.get<ECDVector*>(); 12471 // Make sure constants are not added more than once. 12472 if (*Vec->begin() == ECD) 12473 continue; 12474 12475 Vec->push_back(ECD); 12476 } 12477 12478 // Emit diagnostics. 12479 for (DuplicatesVector::iterator DupVectorIter = DupVector.begin(), 12480 DupVectorEnd = DupVector.end(); 12481 DupVectorIter != DupVectorEnd; ++DupVectorIter) { 12482 ECDVector *Vec = *DupVectorIter; 12483 assert(Vec->size() > 1 && "ECDVector should have at least 2 elements."); 12484 12485 // Emit warning for one enum constant. 12486 ECDVector::iterator I = Vec->begin(); 12487 S.Diag((*I)->getLocation(), diag::warn_duplicate_enum_values) 12488 << (*I)->getName() << (*I)->getInitVal().toString(10) 12489 << (*I)->getSourceRange(); 12490 ++I; 12491 12492 // Emit one note for each of the remaining enum constants with 12493 // the same value. 12494 for (ECDVector::iterator E = Vec->end(); I != E; ++I) 12495 S.Diag((*I)->getLocation(), diag::note_duplicate_element) 12496 << (*I)->getName() << (*I)->getInitVal().toString(10) 12497 << (*I)->getSourceRange(); 12498 delete Vec; 12499 } 12500} 12501 12502void Sema::ActOnEnumBody(SourceLocation EnumLoc, SourceLocation LBraceLoc, 12503 SourceLocation RBraceLoc, Decl *EnumDeclX, 12504 ArrayRef<Decl *> Elements, 12505 Scope *S, AttributeList *Attr) { 12506 EnumDecl *Enum = cast<EnumDecl>(EnumDeclX); 12507 QualType EnumType = Context.getTypeDeclType(Enum); 12508 12509 if (Attr) 12510 ProcessDeclAttributeList(S, Enum, Attr); 12511 12512 if (Enum->isDependentType()) { 12513 for (unsigned i = 0, e = Elements.size(); i != e; ++i) { 12514 EnumConstantDecl *ECD = 12515 cast_or_null<EnumConstantDecl>(Elements[i]); 12516 if (!ECD) continue; 12517 12518 ECD->setType(EnumType); 12519 } 12520 12521 Enum->completeDefinition(Context.DependentTy, Context.DependentTy, 0, 0); 12522 return; 12523 } 12524 12525 // TODO: If the result value doesn't fit in an int, it must be a long or long 12526 // long value. ISO C does not support this, but GCC does as an extension, 12527 // emit a warning. 12528 unsigned IntWidth = Context.getTargetInfo().getIntWidth(); 12529 unsigned CharWidth = Context.getTargetInfo().getCharWidth(); 12530 unsigned ShortWidth = Context.getTargetInfo().getShortWidth(); 12531 12532 // Verify that all the values are okay, compute the size of the values, and 12533 // reverse the list. 12534 unsigned NumNegativeBits = 0; 12535 unsigned NumPositiveBits = 0; 12536 12537 // Keep track of whether all elements have type int. 12538 bool AllElementsInt = true; 12539 12540 for (unsigned i = 0, e = Elements.size(); i != e; ++i) { 12541 EnumConstantDecl *ECD = 12542 cast_or_null<EnumConstantDecl>(Elements[i]); 12543 if (!ECD) continue; // Already issued a diagnostic. 12544 12545 const llvm::APSInt &InitVal = ECD->getInitVal(); 12546 12547 // Keep track of the size of positive and negative values. 12548 if (InitVal.isUnsigned() || InitVal.isNonNegative()) 12549 NumPositiveBits = std::max(NumPositiveBits, 12550 (unsigned)InitVal.getActiveBits()); 12551 else 12552 NumNegativeBits = std::max(NumNegativeBits, 12553 (unsigned)InitVal.getMinSignedBits()); 12554 12555 // Keep track of whether every enum element has type int (very commmon). 12556 if (AllElementsInt) 12557 AllElementsInt = ECD->getType() == Context.IntTy; 12558 } 12559 12560 // Figure out the type that should be used for this enum. 12561 QualType BestType; 12562 unsigned BestWidth; 12563 12564 // C++0x N3000 [conv.prom]p3: 12565 // An rvalue of an unscoped enumeration type whose underlying 12566 // type is not fixed can be converted to an rvalue of the first 12567 // of the following types that can represent all the values of 12568 // the enumeration: int, unsigned int, long int, unsigned long 12569 // int, long long int, or unsigned long long int. 12570 // C99 6.4.4.3p2: 12571 // An identifier declared as an enumeration constant has type int. 12572 // The C99 rule is modified by a gcc extension 12573 QualType BestPromotionType; 12574 12575 bool Packed = Enum->getAttr<PackedAttr>() ? true : false; 12576 // -fshort-enums is the equivalent to specifying the packed attribute on all 12577 // enum definitions. 12578 if (LangOpts.ShortEnums) 12579 Packed = true; 12580 12581 if (Enum->isFixed()) { 12582 BestType = Enum->getIntegerType(); 12583 if (BestType->isPromotableIntegerType()) 12584 BestPromotionType = Context.getPromotedIntegerType(BestType); 12585 else 12586 BestPromotionType = BestType; 12587 // We don't need to set BestWidth, because BestType is going to be the type 12588 // of the enumerators, but we do anyway because otherwise some compilers 12589 // warn that it might be used uninitialized. 12590 BestWidth = CharWidth; 12591 } 12592 else if (NumNegativeBits) { 12593 // If there is a negative value, figure out the smallest integer type (of 12594 // int/long/longlong) that fits. 12595 // If it's packed, check also if it fits a char or a short. 12596 if (Packed && NumNegativeBits <= CharWidth && NumPositiveBits < CharWidth) { 12597 BestType = Context.SignedCharTy; 12598 BestWidth = CharWidth; 12599 } else if (Packed && NumNegativeBits <= ShortWidth && 12600 NumPositiveBits < ShortWidth) { 12601 BestType = Context.ShortTy; 12602 BestWidth = ShortWidth; 12603 } else if (NumNegativeBits <= IntWidth && NumPositiveBits < IntWidth) { 12604 BestType = Context.IntTy; 12605 BestWidth = IntWidth; 12606 } else { 12607 BestWidth = Context.getTargetInfo().getLongWidth(); 12608 12609 if (NumNegativeBits <= BestWidth && NumPositiveBits < BestWidth) { 12610 BestType = Context.LongTy; 12611 } else { 12612 BestWidth = Context.getTargetInfo().getLongLongWidth(); 12613 12614 if (NumNegativeBits > BestWidth || NumPositiveBits >= BestWidth) 12615 Diag(Enum->getLocation(), diag::warn_enum_too_large); 12616 BestType = Context.LongLongTy; 12617 } 12618 } 12619 BestPromotionType = (BestWidth <= IntWidth ? Context.IntTy : BestType); 12620 } else { 12621 // If there is no negative value, figure out the smallest type that fits 12622 // all of the enumerator values. 12623 // If it's packed, check also if it fits a char or a short. 12624 if (Packed && NumPositiveBits <= CharWidth) { 12625 BestType = Context.UnsignedCharTy; 12626 BestPromotionType = Context.IntTy; 12627 BestWidth = CharWidth; 12628 } else if (Packed && NumPositiveBits <= ShortWidth) { 12629 BestType = Context.UnsignedShortTy; 12630 BestPromotionType = Context.IntTy; 12631 BestWidth = ShortWidth; 12632 } else if (NumPositiveBits <= IntWidth) { 12633 BestType = Context.UnsignedIntTy; 12634 BestWidth = IntWidth; 12635 BestPromotionType 12636 = (NumPositiveBits == BestWidth || !getLangOpts().CPlusPlus) 12637 ? Context.UnsignedIntTy : Context.IntTy; 12638 } else if (NumPositiveBits <= 12639 (BestWidth = Context.getTargetInfo().getLongWidth())) { 12640 BestType = Context.UnsignedLongTy; 12641 BestPromotionType 12642 = (NumPositiveBits == BestWidth || !getLangOpts().CPlusPlus) 12643 ? Context.UnsignedLongTy : Context.LongTy; 12644 } else { 12645 BestWidth = Context.getTargetInfo().getLongLongWidth(); 12646 assert(NumPositiveBits <= BestWidth && 12647 "How could an initializer get larger than ULL?"); 12648 BestType = Context.UnsignedLongLongTy; 12649 BestPromotionType 12650 = (NumPositiveBits == BestWidth || !getLangOpts().CPlusPlus) 12651 ? Context.UnsignedLongLongTy : Context.LongLongTy; 12652 } 12653 } 12654 12655 // Loop over all of the enumerator constants, changing their types to match 12656 // the type of the enum if needed. 12657 for (unsigned i = 0, e = Elements.size(); i != e; ++i) { 12658 EnumConstantDecl *ECD = cast_or_null<EnumConstantDecl>(Elements[i]); 12659 if (!ECD) continue; // Already issued a diagnostic. 12660 12661 // Standard C says the enumerators have int type, but we allow, as an 12662 // extension, the enumerators to be larger than int size. If each 12663 // enumerator value fits in an int, type it as an int, otherwise type it the 12664 // same as the enumerator decl itself. This means that in "enum { X = 1U }" 12665 // that X has type 'int', not 'unsigned'. 12666 12667 // Determine whether the value fits into an int. 12668 llvm::APSInt InitVal = ECD->getInitVal(); 12669 12670 // If it fits into an integer type, force it. Otherwise force it to match 12671 // the enum decl type. 12672 QualType NewTy; 12673 unsigned NewWidth; 12674 bool NewSign; 12675 if (!getLangOpts().CPlusPlus && 12676 !Enum->isFixed() && 12677 isRepresentableIntegerValue(Context, InitVal, Context.IntTy)) { 12678 NewTy = Context.IntTy; 12679 NewWidth = IntWidth; 12680 NewSign = true; 12681 } else if (ECD->getType() == BestType) { 12682 // Already the right type! 12683 if (getLangOpts().CPlusPlus) 12684 // C++ [dcl.enum]p4: Following the closing brace of an 12685 // enum-specifier, each enumerator has the type of its 12686 // enumeration. 12687 ECD->setType(EnumType); 12688 continue; 12689 } else { 12690 NewTy = BestType; 12691 NewWidth = BestWidth; 12692 NewSign = BestType->isSignedIntegerOrEnumerationType(); 12693 } 12694 12695 // Adjust the APSInt value. 12696 InitVal = InitVal.extOrTrunc(NewWidth); 12697 InitVal.setIsSigned(NewSign); 12698 ECD->setInitVal(InitVal); 12699 12700 // Adjust the Expr initializer and type. 12701 if (ECD->getInitExpr() && 12702 !Context.hasSameType(NewTy, ECD->getInitExpr()->getType())) 12703 ECD->setInitExpr(ImplicitCastExpr::Create(Context, NewTy, 12704 CK_IntegralCast, 12705 ECD->getInitExpr(), 12706 /*base paths*/ 0, 12707 VK_RValue)); 12708 if (getLangOpts().CPlusPlus) 12709 // C++ [dcl.enum]p4: Following the closing brace of an 12710 // enum-specifier, each enumerator has the type of its 12711 // enumeration. 12712 ECD->setType(EnumType); 12713 else 12714 ECD->setType(NewTy); 12715 } 12716 12717 Enum->completeDefinition(BestType, BestPromotionType, 12718 NumPositiveBits, NumNegativeBits); 12719 12720 // If we're declaring a function, ensure this decl isn't forgotten about - 12721 // it needs to go into the function scope. 12722 if (InFunctionDeclarator) 12723 DeclsInPrototypeScope.push_back(Enum); 12724 12725 CheckForDuplicateEnumValues(*this, Elements, Enum, EnumType); 12726 12727 // Now that the enum type is defined, ensure it's not been underaligned. 12728 if (Enum->hasAttrs()) 12729 CheckAlignasUnderalignment(Enum); 12730} 12731 12732Decl *Sema::ActOnFileScopeAsmDecl(Expr *expr, 12733 SourceLocation StartLoc, 12734 SourceLocation EndLoc) { 12735 StringLiteral *AsmString = cast<StringLiteral>(expr); 12736 12737 FileScopeAsmDecl *New = FileScopeAsmDecl::Create(Context, CurContext, 12738 AsmString, StartLoc, 12739 EndLoc); 12740 CurContext->addDecl(New); 12741 return New; 12742} 12743 12744DeclResult Sema::ActOnModuleImport(SourceLocation AtLoc, 12745 SourceLocation ImportLoc, 12746 ModuleIdPath Path) { 12747 Module *Mod = PP.getModuleLoader().loadModule(ImportLoc, Path, 12748 Module::AllVisible, 12749 /*IsIncludeDirective=*/false); 12750 if (!Mod) 12751 return true; 12752 12753 SmallVector<SourceLocation, 2> IdentifierLocs; 12754 Module *ModCheck = Mod; 12755 for (unsigned I = 0, N = Path.size(); I != N; ++I) { 12756 // If we've run out of module parents, just drop the remaining identifiers. 12757 // We need the length to be consistent. 12758 if (!ModCheck) 12759 break; 12760 ModCheck = ModCheck->Parent; 12761 12762 IdentifierLocs.push_back(Path[I].second); 12763 } 12764 12765 ImportDecl *Import = ImportDecl::Create(Context, 12766 Context.getTranslationUnitDecl(), 12767 AtLoc.isValid()? AtLoc : ImportLoc, 12768 Mod, IdentifierLocs); 12769 Context.getTranslationUnitDecl()->addDecl(Import); 12770 return Import; 12771} 12772 12773void Sema::createImplicitModuleImport(SourceLocation Loc, Module *Mod) { 12774 // Create the implicit import declaration. 12775 TranslationUnitDecl *TU = getASTContext().getTranslationUnitDecl(); 12776 ImportDecl *ImportD = ImportDecl::CreateImplicit(getASTContext(), TU, 12777 Loc, Mod, Loc); 12778 TU->addDecl(ImportD); 12779 Consumer.HandleImplicitImportDecl(ImportD); 12780 12781 // Make the module visible. 12782 PP.getModuleLoader().makeModuleVisible(Mod, Module::AllVisible, Loc, 12783 /*Complain=*/false); 12784} 12785 12786void Sema::ActOnPragmaRedefineExtname(IdentifierInfo* Name, 12787 IdentifierInfo* AliasName, 12788 SourceLocation PragmaLoc, 12789 SourceLocation NameLoc, 12790 SourceLocation AliasNameLoc) { 12791 Decl *PrevDecl = LookupSingleName(TUScope, Name, NameLoc, 12792 LookupOrdinaryName); 12793 AsmLabelAttr *Attr = 12794 ::new (Context) AsmLabelAttr(AliasNameLoc, Context, AliasName->getName()); 12795 12796 if (PrevDecl) 12797 PrevDecl->addAttr(Attr); 12798 else 12799 (void)ExtnameUndeclaredIdentifiers.insert( 12800 std::pair<IdentifierInfo*,AsmLabelAttr*>(Name, Attr)); 12801} 12802 12803void Sema::ActOnPragmaWeakID(IdentifierInfo* Name, 12804 SourceLocation PragmaLoc, 12805 SourceLocation NameLoc) { 12806 Decl *PrevDecl = LookupSingleName(TUScope, Name, NameLoc, LookupOrdinaryName); 12807 12808 if (PrevDecl) { 12809 PrevDecl->addAttr(::new (Context) WeakAttr(PragmaLoc, Context)); 12810 } else { 12811 (void)WeakUndeclaredIdentifiers.insert( 12812 std::pair<IdentifierInfo*,WeakInfo> 12813 (Name, WeakInfo((IdentifierInfo*)0, NameLoc))); 12814 } 12815} 12816 12817void Sema::ActOnPragmaWeakAlias(IdentifierInfo* Name, 12818 IdentifierInfo* AliasName, 12819 SourceLocation PragmaLoc, 12820 SourceLocation NameLoc, 12821 SourceLocation AliasNameLoc) { 12822 Decl *PrevDecl = LookupSingleName(TUScope, AliasName, AliasNameLoc, 12823 LookupOrdinaryName); 12824 WeakInfo W = WeakInfo(Name, NameLoc); 12825 12826 if (PrevDecl) { 12827 if (!PrevDecl->hasAttr<AliasAttr>()) 12828 if (NamedDecl *ND = dyn_cast<NamedDecl>(PrevDecl)) 12829 DeclApplyPragmaWeak(TUScope, ND, W); 12830 } else { 12831 (void)WeakUndeclaredIdentifiers.insert( 12832 std::pair<IdentifierInfo*,WeakInfo>(AliasName, W)); 12833 } 12834} 12835 12836Decl *Sema::getObjCDeclContext() const { 12837 return (dyn_cast_or_null<ObjCContainerDecl>(CurContext)); 12838} 12839 12840AvailabilityResult Sema::getCurContextAvailability() const { 12841 const Decl *D = cast<Decl>(getCurObjCLexicalContext()); 12842 return D->getAvailability(); 12843} 12844