SemaDecl.cpp revision 37e849ad80731ac1b2ad1c64e73bced27802bd8b
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/CXXInheritance.h" 19#include "clang/AST/CharUnits.h" 20#include "clang/AST/CommentDiagnostic.h" 21#include "clang/AST/DeclCXX.h" 22#include "clang/AST/DeclObjC.h" 23#include "clang/AST/DeclTemplate.h" 24#include "clang/AST/EvaluatedExprVisitor.h" 25#include "clang/AST/ExprCXX.h" 26#include "clang/AST/StmtCXX.h" 27#include "clang/Basic/PartialDiagnostic.h" 28#include "clang/Basic/SourceManager.h" 29#include "clang/Basic/TargetInfo.h" 30#include "clang/Lex/HeaderSearch.h" // FIXME: Sema shouldn't depend on Lex 31#include "clang/Lex/ModuleLoader.h" // FIXME: Sema shouldn't depend on Lex 32#include "clang/Lex/Preprocessor.h" // FIXME: Sema shouldn't depend on Lex 33#include "clang/Parse/ParseDiagnostic.h" 34#include "clang/Sema/CXXFieldCollector.h" 35#include "clang/Sema/DeclSpec.h" 36#include "clang/Sema/DelayedDiagnostic.h" 37#include "clang/Sema/Initialization.h" 38#include "clang/Sema/Lookup.h" 39#include "clang/Sema/ParsedTemplate.h" 40#include "clang/Sema/Scope.h" 41#include "clang/Sema/ScopeInfo.h" 42#include "llvm/ADT/SmallString.h" 43#include "llvm/ADT/Triple.h" 44#include <algorithm> 45#include <cstring> 46#include <functional> 47using namespace clang; 48using namespace sema; 49 50Sema::DeclGroupPtrTy Sema::ConvertDeclToDeclGroup(Decl *Ptr, Decl *OwnedType) { 51 if (OwnedType) { 52 Decl *Group[2] = { OwnedType, Ptr }; 53 return DeclGroupPtrTy::make(DeclGroupRef::Create(Context, Group, 2)); 54 } 55 56 return DeclGroupPtrTy::make(DeclGroupRef(Ptr)); 57} 58 59namespace { 60 61class TypeNameValidatorCCC : public CorrectionCandidateCallback { 62 public: 63 TypeNameValidatorCCC(bool AllowInvalid, bool WantClass=false) 64 : AllowInvalidDecl(AllowInvalid), WantClassName(WantClass) { 65 WantExpressionKeywords = false; 66 WantCXXNamedCasts = false; 67 WantRemainingKeywords = false; 68 } 69 70 virtual bool ValidateCandidate(const TypoCorrection &candidate) { 71 if (NamedDecl *ND = candidate.getCorrectionDecl()) 72 return (isa<TypeDecl>(ND) || isa<ObjCInterfaceDecl>(ND)) && 73 (AllowInvalidDecl || !ND->isInvalidDecl()); 74 else 75 return !WantClassName && candidate.isKeyword(); 76 } 77 78 private: 79 bool AllowInvalidDecl; 80 bool WantClassName; 81}; 82 83} 84 85/// \brief Determine whether the token kind starts a simple-type-specifier. 86bool Sema::isSimpleTypeSpecifier(tok::TokenKind Kind) const { 87 switch (Kind) { 88 // FIXME: Take into account the current language when deciding whether a 89 // token kind is a valid type specifier 90 case tok::kw_short: 91 case tok::kw_long: 92 case tok::kw___int64: 93 case tok::kw___int128: 94 case tok::kw_signed: 95 case tok::kw_unsigned: 96 case tok::kw_void: 97 case tok::kw_char: 98 case tok::kw_int: 99 case tok::kw_half: 100 case tok::kw_float: 101 case tok::kw_double: 102 case tok::kw_wchar_t: 103 case tok::kw_bool: 104 case tok::kw___underlying_type: 105 return true; 106 107 case tok::annot_typename: 108 case tok::kw_char16_t: 109 case tok::kw_char32_t: 110 case tok::kw_typeof: 111 case tok::kw_decltype: 112 return getLangOpts().CPlusPlus; 113 114 default: 115 break; 116 } 117 118 return false; 119} 120 121/// \brief If the identifier refers to a type name within this scope, 122/// return the declaration of that type. 123/// 124/// This routine performs ordinary name lookup of the identifier II 125/// within the given scope, with optional C++ scope specifier SS, to 126/// determine whether the name refers to a type. If so, returns an 127/// opaque pointer (actually a QualType) corresponding to that 128/// type. Otherwise, returns NULL. 129/// 130/// If name lookup results in an ambiguity, this routine will complain 131/// and then return NULL. 132ParsedType Sema::getTypeName(const IdentifierInfo &II, SourceLocation NameLoc, 133 Scope *S, CXXScopeSpec *SS, 134 bool isClassName, bool HasTrailingDot, 135 ParsedType ObjectTypePtr, 136 bool IsCtorOrDtorName, 137 bool WantNontrivialTypeSourceInfo, 138 IdentifierInfo **CorrectedII) { 139 // Determine where we will perform name lookup. 140 DeclContext *LookupCtx = 0; 141 if (ObjectTypePtr) { 142 QualType ObjectType = ObjectTypePtr.get(); 143 if (ObjectType->isRecordType()) 144 LookupCtx = computeDeclContext(ObjectType); 145 } else if (SS && SS->isNotEmpty()) { 146 LookupCtx = computeDeclContext(*SS, false); 147 148 if (!LookupCtx) { 149 if (isDependentScopeSpecifier(*SS)) { 150 // C++ [temp.res]p3: 151 // A qualified-id that refers to a type and in which the 152 // nested-name-specifier depends on a template-parameter (14.6.2) 153 // shall be prefixed by the keyword typename to indicate that the 154 // qualified-id denotes a type, forming an 155 // elaborated-type-specifier (7.1.5.3). 156 // 157 // We therefore do not perform any name lookup if the result would 158 // refer to a member of an unknown specialization. 159 if (!isClassName && !IsCtorOrDtorName) 160 return ParsedType(); 161 162 // We know from the grammar that this name refers to a type, 163 // so build a dependent node to describe the type. 164 if (WantNontrivialTypeSourceInfo) 165 return ActOnTypenameType(S, SourceLocation(), *SS, II, NameLoc).get(); 166 167 NestedNameSpecifierLoc QualifierLoc = SS->getWithLocInContext(Context); 168 QualType T = 169 CheckTypenameType(ETK_None, SourceLocation(), QualifierLoc, 170 II, NameLoc); 171 172 return ParsedType::make(T); 173 } 174 175 return ParsedType(); 176 } 177 178 if (!LookupCtx->isDependentContext() && 179 RequireCompleteDeclContext(*SS, LookupCtx)) 180 return ParsedType(); 181 } 182 183 // FIXME: LookupNestedNameSpecifierName isn't the right kind of 184 // lookup for class-names. 185 LookupNameKind Kind = isClassName ? LookupNestedNameSpecifierName : 186 LookupOrdinaryName; 187 LookupResult Result(*this, &II, NameLoc, Kind); 188 if (LookupCtx) { 189 // Perform "qualified" name lookup into the declaration context we 190 // computed, which is either the type of the base of a member access 191 // expression or the declaration context associated with a prior 192 // nested-name-specifier. 193 LookupQualifiedName(Result, LookupCtx); 194 195 if (ObjectTypePtr && Result.empty()) { 196 // C++ [basic.lookup.classref]p3: 197 // If the unqualified-id is ~type-name, the type-name is looked up 198 // in the context of the entire postfix-expression. If the type T of 199 // the object expression is of a class type C, the type-name is also 200 // looked up in the scope of class C. At least one of the lookups shall 201 // find a name that refers to (possibly cv-qualified) T. 202 LookupName(Result, S); 203 } 204 } else { 205 // Perform unqualified name lookup. 206 LookupName(Result, S); 207 } 208 209 NamedDecl *IIDecl = 0; 210 switch (Result.getResultKind()) { 211 case LookupResult::NotFound: 212 case LookupResult::NotFoundInCurrentInstantiation: 213 if (CorrectedII) { 214 TypeNameValidatorCCC Validator(true, isClassName); 215 TypoCorrection Correction = CorrectTypo(Result.getLookupNameInfo(), 216 Kind, S, SS, Validator); 217 IdentifierInfo *NewII = Correction.getCorrectionAsIdentifierInfo(); 218 TemplateTy Template; 219 bool MemberOfUnknownSpecialization; 220 UnqualifiedId TemplateName; 221 TemplateName.setIdentifier(NewII, NameLoc); 222 NestedNameSpecifier *NNS = Correction.getCorrectionSpecifier(); 223 CXXScopeSpec NewSS, *NewSSPtr = SS; 224 if (SS && NNS) { 225 NewSS.MakeTrivial(Context, NNS, SourceRange(NameLoc)); 226 NewSSPtr = &NewSS; 227 } 228 if (Correction && (NNS || NewII != &II) && 229 // Ignore a correction to a template type as the to-be-corrected 230 // identifier is not a template (typo correction for template names 231 // is handled elsewhere). 232 !(getLangOpts().CPlusPlus && NewSSPtr && 233 isTemplateName(S, *NewSSPtr, false, TemplateName, ParsedType(), 234 false, Template, MemberOfUnknownSpecialization))) { 235 ParsedType Ty = getTypeName(*NewII, NameLoc, S, NewSSPtr, 236 isClassName, HasTrailingDot, ObjectTypePtr, 237 IsCtorOrDtorName, 238 WantNontrivialTypeSourceInfo); 239 if (Ty) { 240 std::string CorrectedStr(Correction.getAsString(getLangOpts())); 241 std::string CorrectedQuotedStr( 242 Correction.getQuoted(getLangOpts())); 243 Diag(NameLoc, diag::err_unknown_type_or_class_name_suggest) 244 << Result.getLookupName() << CorrectedQuotedStr << isClassName 245 << FixItHint::CreateReplacement(SourceRange(NameLoc), 246 CorrectedStr); 247 if (NamedDecl *FirstDecl = Correction.getCorrectionDecl()) 248 Diag(FirstDecl->getLocation(), diag::note_previous_decl) 249 << CorrectedQuotedStr; 250 251 if (SS && NNS) 252 SS->MakeTrivial(Context, NNS, SourceRange(NameLoc)); 253 *CorrectedII = NewII; 254 return Ty; 255 } 256 } 257 } 258 // If typo correction failed or was not performed, fall through 259 case LookupResult::FoundOverloaded: 260 case LookupResult::FoundUnresolvedValue: 261 Result.suppressDiagnostics(); 262 return ParsedType(); 263 264 case LookupResult::Ambiguous: 265 // Recover from type-hiding ambiguities by hiding the type. We'll 266 // do the lookup again when looking for an object, and we can 267 // diagnose the error then. If we don't do this, then the error 268 // about hiding the type will be immediately followed by an error 269 // that only makes sense if the identifier was treated like a type. 270 if (Result.getAmbiguityKind() == LookupResult::AmbiguousTagHiding) { 271 Result.suppressDiagnostics(); 272 return ParsedType(); 273 } 274 275 // Look to see if we have a type anywhere in the list of results. 276 for (LookupResult::iterator Res = Result.begin(), ResEnd = Result.end(); 277 Res != ResEnd; ++Res) { 278 if (isa<TypeDecl>(*Res) || isa<ObjCInterfaceDecl>(*Res)) { 279 if (!IIDecl || 280 (*Res)->getLocation().getRawEncoding() < 281 IIDecl->getLocation().getRawEncoding()) 282 IIDecl = *Res; 283 } 284 } 285 286 if (!IIDecl) { 287 // None of the entities we found is a type, so there is no way 288 // to even assume that the result is a type. In this case, don't 289 // complain about the ambiguity. The parser will either try to 290 // perform this lookup again (e.g., as an object name), which 291 // will produce the ambiguity, or will complain that it expected 292 // a type name. 293 Result.suppressDiagnostics(); 294 return ParsedType(); 295 } 296 297 // We found a type within the ambiguous lookup; diagnose the 298 // ambiguity and then return that type. This might be the right 299 // answer, or it might not be, but it suppresses any attempt to 300 // perform the name lookup again. 301 break; 302 303 case LookupResult::Found: 304 IIDecl = Result.getFoundDecl(); 305 break; 306 } 307 308 assert(IIDecl && "Didn't find decl"); 309 310 QualType T; 311 if (TypeDecl *TD = dyn_cast<TypeDecl>(IIDecl)) { 312 DiagnoseUseOfDecl(IIDecl, NameLoc); 313 314 if (T.isNull()) 315 T = Context.getTypeDeclType(TD); 316 317 // NOTE: avoid constructing an ElaboratedType(Loc) if this is a 318 // constructor or destructor name (in such a case, the scope specifier 319 // will be attached to the enclosing Expr or Decl node). 320 if (SS && SS->isNotEmpty() && !IsCtorOrDtorName) { 321 if (WantNontrivialTypeSourceInfo) { 322 // Construct a type with type-source information. 323 TypeLocBuilder Builder; 324 Builder.pushTypeSpec(T).setNameLoc(NameLoc); 325 326 T = getElaboratedType(ETK_None, *SS, T); 327 ElaboratedTypeLoc ElabTL = Builder.push<ElaboratedTypeLoc>(T); 328 ElabTL.setElaboratedKeywordLoc(SourceLocation()); 329 ElabTL.setQualifierLoc(SS->getWithLocInContext(Context)); 330 return CreateParsedType(T, Builder.getTypeSourceInfo(Context, T)); 331 } else { 332 T = getElaboratedType(ETK_None, *SS, T); 333 } 334 } 335 } else if (ObjCInterfaceDecl *IDecl = dyn_cast<ObjCInterfaceDecl>(IIDecl)) { 336 (void)DiagnoseUseOfDecl(IDecl, NameLoc); 337 if (!HasTrailingDot) 338 T = Context.getObjCInterfaceType(IDecl); 339 } 340 341 if (T.isNull()) { 342 // If it's not plausibly a type, suppress diagnostics. 343 Result.suppressDiagnostics(); 344 return ParsedType(); 345 } 346 return ParsedType::make(T); 347} 348 349/// isTagName() - This method is called *for error recovery purposes only* 350/// to determine if the specified name is a valid tag name ("struct foo"). If 351/// so, this returns the TST for the tag corresponding to it (TST_enum, 352/// TST_union, TST_struct, TST_interface, TST_class). This is used to diagnose 353/// cases in C where the user forgot to specify the tag. 354DeclSpec::TST Sema::isTagName(IdentifierInfo &II, Scope *S) { 355 // Do a tag name lookup in this scope. 356 LookupResult R(*this, &II, SourceLocation(), LookupTagName); 357 LookupName(R, S, false); 358 R.suppressDiagnostics(); 359 if (R.getResultKind() == LookupResult::Found) 360 if (const TagDecl *TD = R.getAsSingle<TagDecl>()) { 361 switch (TD->getTagKind()) { 362 case TTK_Struct: return DeclSpec::TST_struct; 363 case TTK_Interface: return DeclSpec::TST_interface; 364 case TTK_Union: return DeclSpec::TST_union; 365 case TTK_Class: return DeclSpec::TST_class; 366 case TTK_Enum: return DeclSpec::TST_enum; 367 } 368 } 369 370 return DeclSpec::TST_unspecified; 371} 372 373/// isMicrosoftMissingTypename - In Microsoft mode, within class scope, 374/// if a CXXScopeSpec's type is equal to the type of one of the base classes 375/// then downgrade the missing typename error to a warning. 376/// This is needed for MSVC compatibility; Example: 377/// @code 378/// template<class T> class A { 379/// public: 380/// typedef int TYPE; 381/// }; 382/// template<class T> class B : public A<T> { 383/// public: 384/// A<T>::TYPE a; // no typename required because A<T> is a base class. 385/// }; 386/// @endcode 387bool Sema::isMicrosoftMissingTypename(const CXXScopeSpec *SS, Scope *S) { 388 if (CurContext->isRecord()) { 389 const Type *Ty = SS->getScopeRep()->getAsType(); 390 391 CXXRecordDecl *RD = cast<CXXRecordDecl>(CurContext); 392 for (CXXRecordDecl::base_class_const_iterator Base = RD->bases_begin(), 393 BaseEnd = RD->bases_end(); Base != BaseEnd; ++Base) 394 if (Context.hasSameUnqualifiedType(QualType(Ty, 1), Base->getType())) 395 return true; 396 return S->isFunctionPrototypeScope(); 397 } 398 return CurContext->isFunctionOrMethod() || S->isFunctionPrototypeScope(); 399} 400 401bool Sema::DiagnoseUnknownTypeName(IdentifierInfo *&II, 402 SourceLocation IILoc, 403 Scope *S, 404 CXXScopeSpec *SS, 405 ParsedType &SuggestedType) { 406 // We don't have anything to suggest (yet). 407 SuggestedType = ParsedType(); 408 409 // There may have been a typo in the name of the type. Look up typo 410 // results, in case we have something that we can suggest. 411 TypeNameValidatorCCC Validator(false); 412 if (TypoCorrection Corrected = CorrectTypo(DeclarationNameInfo(II, IILoc), 413 LookupOrdinaryName, S, SS, 414 Validator)) { 415 std::string CorrectedStr(Corrected.getAsString(getLangOpts())); 416 std::string CorrectedQuotedStr(Corrected.getQuoted(getLangOpts())); 417 418 if (Corrected.isKeyword()) { 419 // We corrected to a keyword. 420 IdentifierInfo *NewII = Corrected.getCorrectionAsIdentifierInfo(); 421 if (!isSimpleTypeSpecifier(NewII->getTokenID())) 422 CorrectedQuotedStr = "the keyword " + CorrectedQuotedStr; 423 Diag(IILoc, diag::err_unknown_typename_suggest) 424 << II << CorrectedQuotedStr 425 << FixItHint::CreateReplacement(Corrected.getCorrectionRange(), 426 CorrectedStr); 427 II = NewII; 428 } else { 429 NamedDecl *Result = Corrected.getCorrectionDecl(); 430 // We found a similarly-named type or interface; suggest that. 431 if (!SS || !SS->isSet()) { 432 Diag(IILoc, diag::err_unknown_typename_suggest) 433 << II << CorrectedQuotedStr 434 << FixItHint::CreateReplacement(Corrected.getCorrectionRange(), 435 CorrectedStr); 436 } else if (DeclContext *DC = computeDeclContext(*SS, false)) { 437 bool droppedSpecifier = Corrected.WillReplaceSpecifier() && 438 II->getName().equals(CorrectedStr); 439 Diag(IILoc, diag::err_unknown_nested_typename_suggest) 440 << II << DC << droppedSpecifier << CorrectedQuotedStr 441 << SS->getRange() 442 << FixItHint::CreateReplacement(Corrected.getCorrectionRange(), 443 CorrectedStr); 444 } 445 else { 446 llvm_unreachable("could not have corrected a typo here"); 447 } 448 449 Diag(Result->getLocation(), diag::note_previous_decl) 450 << CorrectedQuotedStr; 451 452 SuggestedType = getTypeName(*Result->getIdentifier(), IILoc, S, SS, 453 false, false, ParsedType(), 454 /*IsCtorOrDtorName=*/false, 455 /*NonTrivialTypeSourceInfo=*/true); 456 } 457 return true; 458 } 459 460 if (getLangOpts().CPlusPlus) { 461 // See if II is a class template that the user forgot to pass arguments to. 462 UnqualifiedId Name; 463 Name.setIdentifier(II, IILoc); 464 CXXScopeSpec EmptySS; 465 TemplateTy TemplateResult; 466 bool MemberOfUnknownSpecialization; 467 if (isTemplateName(S, SS ? *SS : EmptySS, /*hasTemplateKeyword=*/false, 468 Name, ParsedType(), true, TemplateResult, 469 MemberOfUnknownSpecialization) == TNK_Type_template) { 470 TemplateName TplName = TemplateResult.getAsVal<TemplateName>(); 471 Diag(IILoc, diag::err_template_missing_args) << TplName; 472 if (TemplateDecl *TplDecl = TplName.getAsTemplateDecl()) { 473 Diag(TplDecl->getLocation(), diag::note_template_decl_here) 474 << TplDecl->getTemplateParameters()->getSourceRange(); 475 } 476 return true; 477 } 478 } 479 480 // FIXME: Should we move the logic that tries to recover from a missing tag 481 // (struct, union, enum) from Parser::ParseImplicitInt here, instead? 482 483 if (!SS || (!SS->isSet() && !SS->isInvalid())) 484 Diag(IILoc, diag::err_unknown_typename) << II; 485 else if (DeclContext *DC = computeDeclContext(*SS, false)) 486 Diag(IILoc, diag::err_typename_nested_not_found) 487 << II << DC << SS->getRange(); 488 else if (isDependentScopeSpecifier(*SS)) { 489 unsigned DiagID = diag::err_typename_missing; 490 if (getLangOpts().MicrosoftMode && isMicrosoftMissingTypename(SS, S)) 491 DiagID = diag::warn_typename_missing; 492 493 Diag(SS->getRange().getBegin(), DiagID) 494 << (NestedNameSpecifier *)SS->getScopeRep() << II->getName() 495 << SourceRange(SS->getRange().getBegin(), IILoc) 496 << FixItHint::CreateInsertion(SS->getRange().getBegin(), "typename "); 497 SuggestedType = ActOnTypenameType(S, SourceLocation(), 498 *SS, *II, IILoc).get(); 499 } else { 500 assert(SS && SS->isInvalid() && 501 "Invalid scope specifier has already been diagnosed"); 502 } 503 504 return true; 505} 506 507/// \brief Determine whether the given result set contains either a type name 508/// or 509static bool isResultTypeOrTemplate(LookupResult &R, const Token &NextToken) { 510 bool CheckTemplate = R.getSema().getLangOpts().CPlusPlus && 511 NextToken.is(tok::less); 512 513 for (LookupResult::iterator I = R.begin(), IEnd = R.end(); I != IEnd; ++I) { 514 if (isa<TypeDecl>(*I) || isa<ObjCInterfaceDecl>(*I)) 515 return true; 516 517 if (CheckTemplate && isa<TemplateDecl>(*I)) 518 return true; 519 } 520 521 return false; 522} 523 524static bool isTagTypeWithMissingTag(Sema &SemaRef, LookupResult &Result, 525 Scope *S, CXXScopeSpec &SS, 526 IdentifierInfo *&Name, 527 SourceLocation NameLoc) { 528 LookupResult R(SemaRef, Name, NameLoc, Sema::LookupTagName); 529 SemaRef.LookupParsedName(R, S, &SS); 530 if (TagDecl *Tag = R.getAsSingle<TagDecl>()) { 531 const char *TagName = 0; 532 const char *FixItTagName = 0; 533 switch (Tag->getTagKind()) { 534 case TTK_Class: 535 TagName = "class"; 536 FixItTagName = "class "; 537 break; 538 539 case TTK_Enum: 540 TagName = "enum"; 541 FixItTagName = "enum "; 542 break; 543 544 case TTK_Struct: 545 TagName = "struct"; 546 FixItTagName = "struct "; 547 break; 548 549 case TTK_Interface: 550 TagName = "__interface"; 551 FixItTagName = "__interface "; 552 break; 553 554 case TTK_Union: 555 TagName = "union"; 556 FixItTagName = "union "; 557 break; 558 } 559 560 SemaRef.Diag(NameLoc, diag::err_use_of_tag_name_without_tag) 561 << Name << TagName << SemaRef.getLangOpts().CPlusPlus 562 << FixItHint::CreateInsertion(NameLoc, FixItTagName); 563 564 for (LookupResult::iterator I = Result.begin(), IEnd = Result.end(); 565 I != IEnd; ++I) 566 SemaRef.Diag((*I)->getLocation(), diag::note_decl_hiding_tag_type) 567 << Name << TagName; 568 569 // Replace lookup results with just the tag decl. 570 Result.clear(Sema::LookupTagName); 571 SemaRef.LookupParsedName(Result, S, &SS); 572 return true; 573 } 574 575 return false; 576} 577 578/// Build a ParsedType for a simple-type-specifier with a nested-name-specifier. 579static ParsedType buildNestedType(Sema &S, CXXScopeSpec &SS, 580 QualType T, SourceLocation NameLoc) { 581 ASTContext &Context = S.Context; 582 583 TypeLocBuilder Builder; 584 Builder.pushTypeSpec(T).setNameLoc(NameLoc); 585 586 T = S.getElaboratedType(ETK_None, SS, T); 587 ElaboratedTypeLoc ElabTL = Builder.push<ElaboratedTypeLoc>(T); 588 ElabTL.setElaboratedKeywordLoc(SourceLocation()); 589 ElabTL.setQualifierLoc(SS.getWithLocInContext(Context)); 590 return S.CreateParsedType(T, Builder.getTypeSourceInfo(Context, T)); 591} 592 593Sema::NameClassification Sema::ClassifyName(Scope *S, 594 CXXScopeSpec &SS, 595 IdentifierInfo *&Name, 596 SourceLocation NameLoc, 597 const Token &NextToken, 598 bool IsAddressOfOperand, 599 CorrectionCandidateCallback *CCC) { 600 DeclarationNameInfo NameInfo(Name, NameLoc); 601 ObjCMethodDecl *CurMethod = getCurMethodDecl(); 602 603 if (NextToken.is(tok::coloncolon)) { 604 BuildCXXNestedNameSpecifier(S, *Name, NameLoc, NextToken.getLocation(), 605 QualType(), false, SS, 0, false); 606 607 } 608 609 LookupResult Result(*this, Name, NameLoc, LookupOrdinaryName); 610 LookupParsedName(Result, S, &SS, !CurMethod); 611 612 // Perform lookup for Objective-C instance variables (including automatically 613 // synthesized instance variables), if we're in an Objective-C method. 614 // FIXME: This lookup really, really needs to be folded in to the normal 615 // unqualified lookup mechanism. 616 if (!SS.isSet() && CurMethod && !isResultTypeOrTemplate(Result, NextToken)) { 617 ExprResult E = LookupInObjCMethod(Result, S, Name, true); 618 if (E.get() || E.isInvalid()) 619 return E; 620 } 621 622 bool SecondTry = false; 623 bool IsFilteredTemplateName = false; 624 625Corrected: 626 switch (Result.getResultKind()) { 627 case LookupResult::NotFound: 628 // If an unqualified-id is followed by a '(', then we have a function 629 // call. 630 if (!SS.isSet() && NextToken.is(tok::l_paren)) { 631 // In C++, this is an ADL-only call. 632 // FIXME: Reference? 633 if (getLangOpts().CPlusPlus) 634 return BuildDeclarationNameExpr(SS, Result, /*ADL=*/true); 635 636 // C90 6.3.2.2: 637 // If the expression that precedes the parenthesized argument list in a 638 // function call consists solely of an identifier, and if no 639 // declaration is visible for this identifier, the identifier is 640 // implicitly declared exactly as if, in the innermost block containing 641 // the function call, the declaration 642 // 643 // extern int identifier (); 644 // 645 // appeared. 646 // 647 // We also allow this in C99 as an extension. 648 if (NamedDecl *D = ImplicitlyDefineFunction(NameLoc, *Name, S)) { 649 Result.addDecl(D); 650 Result.resolveKind(); 651 return BuildDeclarationNameExpr(SS, Result, /*ADL=*/false); 652 } 653 } 654 655 // In C, we first see whether there is a tag type by the same name, in 656 // which case it's likely that the user just forget to write "enum", 657 // "struct", or "union". 658 if (!getLangOpts().CPlusPlus && !SecondTry && 659 isTagTypeWithMissingTag(*this, Result, S, SS, Name, NameLoc)) { 660 break; 661 } 662 663 // Perform typo correction to determine if there is another name that is 664 // close to this name. 665 if (!SecondTry && CCC) { 666 SecondTry = true; 667 if (TypoCorrection Corrected = CorrectTypo(Result.getLookupNameInfo(), 668 Result.getLookupKind(), S, 669 &SS, *CCC)) { 670 unsigned UnqualifiedDiag = diag::err_undeclared_var_use_suggest; 671 unsigned QualifiedDiag = diag::err_no_member_suggest; 672 std::string CorrectedStr(Corrected.getAsString(getLangOpts())); 673 std::string CorrectedQuotedStr(Corrected.getQuoted(getLangOpts())); 674 675 NamedDecl *FirstDecl = Corrected.getCorrectionDecl(); 676 NamedDecl *UnderlyingFirstDecl 677 = FirstDecl? FirstDecl->getUnderlyingDecl() : 0; 678 if (getLangOpts().CPlusPlus && NextToken.is(tok::less) && 679 UnderlyingFirstDecl && isa<TemplateDecl>(UnderlyingFirstDecl)) { 680 UnqualifiedDiag = diag::err_no_template_suggest; 681 QualifiedDiag = diag::err_no_member_template_suggest; 682 } else if (UnderlyingFirstDecl && 683 (isa<TypeDecl>(UnderlyingFirstDecl) || 684 isa<ObjCInterfaceDecl>(UnderlyingFirstDecl) || 685 isa<ObjCCompatibleAliasDecl>(UnderlyingFirstDecl))) { 686 UnqualifiedDiag = diag::err_unknown_typename_suggest; 687 QualifiedDiag = diag::err_unknown_nested_typename_suggest; 688 } 689 690 if (SS.isEmpty()) { 691 Diag(NameLoc, UnqualifiedDiag) 692 << Name << CorrectedQuotedStr 693 << FixItHint::CreateReplacement(NameLoc, CorrectedStr); 694 } else {// FIXME: is this even reachable? Test it. 695 bool droppedSpecifier = Corrected.WillReplaceSpecifier() && 696 Name->getName().equals(CorrectedStr); 697 Diag(NameLoc, QualifiedDiag) 698 << Name << computeDeclContext(SS, false) << droppedSpecifier 699 << CorrectedQuotedStr << SS.getRange() 700 << FixItHint::CreateReplacement(Corrected.getCorrectionRange(), 701 CorrectedStr); 702 } 703 704 // Update the name, so that the caller has the new name. 705 Name = Corrected.getCorrectionAsIdentifierInfo(); 706 707 // Typo correction corrected to a keyword. 708 if (Corrected.isKeyword()) 709 return Corrected.getCorrectionAsIdentifierInfo(); 710 711 // Also update the LookupResult... 712 // FIXME: This should probably go away at some point 713 Result.clear(); 714 Result.setLookupName(Corrected.getCorrection()); 715 if (FirstDecl) { 716 Result.addDecl(FirstDecl); 717 Diag(FirstDecl->getLocation(), diag::note_previous_decl) 718 << CorrectedQuotedStr; 719 } 720 721 // If we found an Objective-C instance variable, let 722 // LookupInObjCMethod build the appropriate expression to 723 // reference the ivar. 724 // FIXME: This is a gross hack. 725 if (ObjCIvarDecl *Ivar = Result.getAsSingle<ObjCIvarDecl>()) { 726 Result.clear(); 727 ExprResult E(LookupInObjCMethod(Result, S, Ivar->getIdentifier())); 728 return E; 729 } 730 731 goto Corrected; 732 } 733 } 734 735 // We failed to correct; just fall through and let the parser deal with it. 736 Result.suppressDiagnostics(); 737 return NameClassification::Unknown(); 738 739 case LookupResult::NotFoundInCurrentInstantiation: { 740 // We performed name lookup into the current instantiation, and there were 741 // dependent bases, so we treat this result the same way as any other 742 // dependent nested-name-specifier. 743 744 // C++ [temp.res]p2: 745 // A name used in a template declaration or definition and that is 746 // dependent on a template-parameter is assumed not to name a type 747 // unless the applicable name lookup finds a type name or the name is 748 // qualified by the keyword typename. 749 // 750 // FIXME: If the next token is '<', we might want to ask the parser to 751 // perform some heroics to see if we actually have a 752 // template-argument-list, which would indicate a missing 'template' 753 // keyword here. 754 return ActOnDependentIdExpression(SS, /*TemplateKWLoc=*/SourceLocation(), 755 NameInfo, IsAddressOfOperand, 756 /*TemplateArgs=*/0); 757 } 758 759 case LookupResult::Found: 760 case LookupResult::FoundOverloaded: 761 case LookupResult::FoundUnresolvedValue: 762 break; 763 764 case LookupResult::Ambiguous: 765 if (getLangOpts().CPlusPlus && NextToken.is(tok::less) && 766 hasAnyAcceptableTemplateNames(Result)) { 767 // C++ [temp.local]p3: 768 // A lookup that finds an injected-class-name (10.2) can result in an 769 // ambiguity in certain cases (for example, if it is found in more than 770 // one base class). If all of the injected-class-names that are found 771 // refer to specializations of the same class template, and if the name 772 // is followed by a template-argument-list, the reference refers to the 773 // class template itself and not a specialization thereof, and is not 774 // ambiguous. 775 // 776 // This filtering can make an ambiguous result into an unambiguous one, 777 // so try again after filtering out template names. 778 FilterAcceptableTemplateNames(Result); 779 if (!Result.isAmbiguous()) { 780 IsFilteredTemplateName = true; 781 break; 782 } 783 } 784 785 // Diagnose the ambiguity and return an error. 786 return NameClassification::Error(); 787 } 788 789 if (getLangOpts().CPlusPlus && NextToken.is(tok::less) && 790 (IsFilteredTemplateName || hasAnyAcceptableTemplateNames(Result))) { 791 // C++ [temp.names]p3: 792 // After name lookup (3.4) finds that a name is a template-name or that 793 // an operator-function-id or a literal- operator-id refers to a set of 794 // overloaded functions any member of which is a function template if 795 // this is followed by a <, the < is always taken as the delimiter of a 796 // template-argument-list and never as the less-than operator. 797 if (!IsFilteredTemplateName) 798 FilterAcceptableTemplateNames(Result); 799 800 if (!Result.empty()) { 801 bool IsFunctionTemplate; 802 bool IsVarTemplate; 803 TemplateName Template; 804 if (Result.end() - Result.begin() > 1) { 805 IsFunctionTemplate = true; 806 Template = Context.getOverloadedTemplateName(Result.begin(), 807 Result.end()); 808 } else { 809 TemplateDecl *TD 810 = cast<TemplateDecl>((*Result.begin())->getUnderlyingDecl()); 811 IsFunctionTemplate = isa<FunctionTemplateDecl>(TD); 812 IsVarTemplate = isa<VarTemplateDecl>(TD); 813 814 if (SS.isSet() && !SS.isInvalid()) 815 Template = Context.getQualifiedTemplateName(SS.getScopeRep(), 816 /*TemplateKeyword=*/false, 817 TD); 818 else 819 Template = TemplateName(TD); 820 } 821 822 if (IsFunctionTemplate) { 823 // Function templates always go through overload resolution, at which 824 // point we'll perform the various checks (e.g., accessibility) we need 825 // to based on which function we selected. 826 Result.suppressDiagnostics(); 827 828 return NameClassification::FunctionTemplate(Template); 829 } 830 831 return IsVarTemplate ? NameClassification::VarTemplate(Template) 832 : NameClassification::TypeTemplate(Template); 833 } 834 } 835 836 NamedDecl *FirstDecl = (*Result.begin())->getUnderlyingDecl(); 837 if (TypeDecl *Type = dyn_cast<TypeDecl>(FirstDecl)) { 838 DiagnoseUseOfDecl(Type, NameLoc); 839 QualType T = Context.getTypeDeclType(Type); 840 if (SS.isNotEmpty()) 841 return buildNestedType(*this, SS, T, NameLoc); 842 return ParsedType::make(T); 843 } 844 845 ObjCInterfaceDecl *Class = dyn_cast<ObjCInterfaceDecl>(FirstDecl); 846 if (!Class) { 847 // FIXME: It's unfortunate that we don't have a Type node for handling this. 848 if (ObjCCompatibleAliasDecl *Alias 849 = dyn_cast<ObjCCompatibleAliasDecl>(FirstDecl)) 850 Class = Alias->getClassInterface(); 851 } 852 853 if (Class) { 854 DiagnoseUseOfDecl(Class, NameLoc); 855 856 if (NextToken.is(tok::period)) { 857 // Interface. <something> is parsed as a property reference expression. 858 // Just return "unknown" as a fall-through for now. 859 Result.suppressDiagnostics(); 860 return NameClassification::Unknown(); 861 } 862 863 QualType T = Context.getObjCInterfaceType(Class); 864 return ParsedType::make(T); 865 } 866 867 // We can have a type template here if we're classifying a template argument. 868 if (isa<TemplateDecl>(FirstDecl) && !isa<FunctionTemplateDecl>(FirstDecl)) 869 return NameClassification::TypeTemplate( 870 TemplateName(cast<TemplateDecl>(FirstDecl))); 871 872 // Check for a tag type hidden by a non-type decl in a few cases where it 873 // seems likely a type is wanted instead of the non-type that was found. 874 bool NextIsOp = NextToken.is(tok::amp) || NextToken.is(tok::star); 875 if ((NextToken.is(tok::identifier) || 876 (NextIsOp && FirstDecl->isFunctionOrFunctionTemplate())) && 877 isTagTypeWithMissingTag(*this, Result, S, SS, Name, NameLoc)) { 878 TypeDecl *Type = Result.getAsSingle<TypeDecl>(); 879 DiagnoseUseOfDecl(Type, NameLoc); 880 QualType T = Context.getTypeDeclType(Type); 881 if (SS.isNotEmpty()) 882 return buildNestedType(*this, SS, T, NameLoc); 883 return ParsedType::make(T); 884 } 885 886 if (FirstDecl->isCXXClassMember()) 887 return BuildPossibleImplicitMemberExpr(SS, SourceLocation(), Result, 0); 888 889 bool ADL = UseArgumentDependentLookup(SS, Result, NextToken.is(tok::l_paren)); 890 return BuildDeclarationNameExpr(SS, Result, ADL); 891} 892 893// Determines the context to return to after temporarily entering a 894// context. This depends in an unnecessarily complicated way on the 895// exact ordering of callbacks from the parser. 896DeclContext *Sema::getContainingDC(DeclContext *DC) { 897 898 // Functions defined inline within classes aren't parsed until we've 899 // finished parsing the top-level class, so the top-level class is 900 // the context we'll need to return to. 901 if (isa<FunctionDecl>(DC)) { 902 DC = DC->getLexicalParent(); 903 904 // A function not defined within a class will always return to its 905 // lexical context. 906 if (!isa<CXXRecordDecl>(DC)) 907 return DC; 908 909 // A C++ inline method/friend is parsed *after* the topmost class 910 // it was declared in is fully parsed ("complete"); the topmost 911 // class is the context we need to return to. 912 while (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(DC->getLexicalParent())) 913 DC = RD; 914 915 // Return the declaration context of the topmost class the inline method is 916 // declared in. 917 return DC; 918 } 919 920 return DC->getLexicalParent(); 921} 922 923void Sema::PushDeclContext(Scope *S, DeclContext *DC) { 924 assert(getContainingDC(DC) == CurContext && 925 "The next DeclContext should be lexically contained in the current one."); 926 CurContext = DC; 927 S->setEntity(DC); 928} 929 930void Sema::PopDeclContext() { 931 assert(CurContext && "DeclContext imbalance!"); 932 933 CurContext = getContainingDC(CurContext); 934 assert(CurContext && "Popped translation unit!"); 935} 936 937/// EnterDeclaratorContext - Used when we must lookup names in the context 938/// of a declarator's nested name specifier. 939/// 940void Sema::EnterDeclaratorContext(Scope *S, DeclContext *DC) { 941 // C++0x [basic.lookup.unqual]p13: 942 // A name used in the definition of a static data member of class 943 // X (after the qualified-id of the static member) is looked up as 944 // if the name was used in a member function of X. 945 // C++0x [basic.lookup.unqual]p14: 946 // If a variable member of a namespace is defined outside of the 947 // scope of its namespace then any name used in the definition of 948 // the variable member (after the declarator-id) is looked up as 949 // if the definition of the variable member occurred in its 950 // namespace. 951 // Both of these imply that we should push a scope whose context 952 // is the semantic context of the declaration. We can't use 953 // PushDeclContext here because that context is not necessarily 954 // lexically contained in the current context. Fortunately, 955 // the containing scope should have the appropriate information. 956 957 assert(!S->getEntity() && "scope already has entity"); 958 959#ifndef NDEBUG 960 Scope *Ancestor = S->getParent(); 961 while (!Ancestor->getEntity()) Ancestor = Ancestor->getParent(); 962 assert(Ancestor->getEntity() == CurContext && "ancestor context mismatch"); 963#endif 964 965 CurContext = DC; 966 S->setEntity(DC); 967} 968 969void Sema::ExitDeclaratorContext(Scope *S) { 970 assert(S->getEntity() == CurContext && "Context imbalance!"); 971 972 // Switch back to the lexical context. The safety of this is 973 // enforced by an assert in EnterDeclaratorContext. 974 Scope *Ancestor = S->getParent(); 975 while (!Ancestor->getEntity()) Ancestor = Ancestor->getParent(); 976 CurContext = (DeclContext*) Ancestor->getEntity(); 977 978 // We don't need to do anything with the scope, which is going to 979 // disappear. 980} 981 982 983void Sema::ActOnReenterFunctionContext(Scope* S, Decl *D) { 984 FunctionDecl *FD = dyn_cast<FunctionDecl>(D); 985 if (FunctionTemplateDecl *TFD = dyn_cast_or_null<FunctionTemplateDecl>(D)) { 986 // We assume that the caller has already called 987 // ActOnReenterTemplateScope 988 FD = TFD->getTemplatedDecl(); 989 } 990 if (!FD) 991 return; 992 993 // Same implementation as PushDeclContext, but enters the context 994 // from the lexical parent, rather than the top-level class. 995 assert(CurContext == FD->getLexicalParent() && 996 "The next DeclContext should be lexically contained in the current one."); 997 CurContext = FD; 998 S->setEntity(CurContext); 999 1000 for (unsigned P = 0, NumParams = FD->getNumParams(); P < NumParams; ++P) { 1001 ParmVarDecl *Param = FD->getParamDecl(P); 1002 // If the parameter has an identifier, then add it to the scope 1003 if (Param->getIdentifier()) { 1004 S->AddDecl(Param); 1005 IdResolver.AddDecl(Param); 1006 } 1007 } 1008} 1009 1010 1011void Sema::ActOnExitFunctionContext() { 1012 // Same implementation as PopDeclContext, but returns to the lexical parent, 1013 // rather than the top-level class. 1014 assert(CurContext && "DeclContext imbalance!"); 1015 CurContext = CurContext->getLexicalParent(); 1016 assert(CurContext && "Popped translation unit!"); 1017} 1018 1019 1020/// \brief Determine whether we allow overloading of the function 1021/// PrevDecl with another declaration. 1022/// 1023/// This routine determines whether overloading is possible, not 1024/// whether some new function is actually an overload. It will return 1025/// true in C++ (where we can always provide overloads) or, as an 1026/// extension, in C when the previous function is already an 1027/// overloaded function declaration or has the "overloadable" 1028/// attribute. 1029static bool AllowOverloadingOfFunction(LookupResult &Previous, 1030 ASTContext &Context) { 1031 if (Context.getLangOpts().CPlusPlus) 1032 return true; 1033 1034 if (Previous.getResultKind() == LookupResult::FoundOverloaded) 1035 return true; 1036 1037 return (Previous.getResultKind() == LookupResult::Found 1038 && Previous.getFoundDecl()->hasAttr<OverloadableAttr>()); 1039} 1040 1041/// Add this decl to the scope shadowed decl chains. 1042void Sema::PushOnScopeChains(NamedDecl *D, Scope *S, bool AddToContext) { 1043 // Move up the scope chain until we find the nearest enclosing 1044 // non-transparent context. The declaration will be introduced into this 1045 // scope. 1046 while (S->getEntity() && 1047 ((DeclContext *)S->getEntity())->isTransparentContext()) 1048 S = S->getParent(); 1049 1050 // Add scoped declarations into their context, so that they can be 1051 // found later. Declarations without a context won't be inserted 1052 // into any context. 1053 if (AddToContext) 1054 CurContext->addDecl(D); 1055 1056 // Out-of-line definitions shouldn't be pushed into scope in C++. 1057 // Out-of-line variable and function definitions shouldn't even in C. 1058 if ((getLangOpts().CPlusPlus || isa<VarDecl>(D) || isa<FunctionDecl>(D)) && 1059 D->isOutOfLine() && 1060 !D->getDeclContext()->getRedeclContext()->Equals( 1061 D->getLexicalDeclContext()->getRedeclContext())) 1062 return; 1063 1064 // Template instantiations should also not be pushed into scope. 1065 if (isa<FunctionDecl>(D) && 1066 cast<FunctionDecl>(D)->isFunctionTemplateSpecialization()) 1067 return; 1068 1069 // If this replaces anything in the current scope, 1070 IdentifierResolver::iterator I = IdResolver.begin(D->getDeclName()), 1071 IEnd = IdResolver.end(); 1072 for (; I != IEnd; ++I) { 1073 if (S->isDeclScope(*I) && D->declarationReplaces(*I)) { 1074 S->RemoveDecl(*I); 1075 IdResolver.RemoveDecl(*I); 1076 1077 // Should only need to replace one decl. 1078 break; 1079 } 1080 } 1081 1082 S->AddDecl(D); 1083 1084 if (isa<LabelDecl>(D) && !cast<LabelDecl>(D)->isGnuLocal()) { 1085 // Implicitly-generated labels may end up getting generated in an order that 1086 // isn't strictly lexical, which breaks name lookup. Be careful to insert 1087 // the label at the appropriate place in the identifier chain. 1088 for (I = IdResolver.begin(D->getDeclName()); I != IEnd; ++I) { 1089 DeclContext *IDC = (*I)->getLexicalDeclContext()->getRedeclContext(); 1090 if (IDC == CurContext) { 1091 if (!S->isDeclScope(*I)) 1092 continue; 1093 } else if (IDC->Encloses(CurContext)) 1094 break; 1095 } 1096 1097 IdResolver.InsertDeclAfter(I, D); 1098 } else { 1099 IdResolver.AddDecl(D); 1100 } 1101} 1102 1103void Sema::pushExternalDeclIntoScope(NamedDecl *D, DeclarationName Name) { 1104 if (IdResolver.tryAddTopLevelDecl(D, Name) && TUScope) 1105 TUScope->AddDecl(D); 1106} 1107 1108bool Sema::isDeclInScope(NamedDecl *D, DeclContext *Ctx, Scope *S, 1109 bool ExplicitInstantiationOrSpecialization) { 1110 return IdResolver.isDeclInScope(D, Ctx, S, 1111 ExplicitInstantiationOrSpecialization); 1112} 1113 1114Scope *Sema::getScopeForDeclContext(Scope *S, DeclContext *DC) { 1115 DeclContext *TargetDC = DC->getPrimaryContext(); 1116 do { 1117 if (DeclContext *ScopeDC = (DeclContext*) S->getEntity()) 1118 if (ScopeDC->getPrimaryContext() == TargetDC) 1119 return S; 1120 } while ((S = S->getParent())); 1121 1122 return 0; 1123} 1124 1125static bool isOutOfScopePreviousDeclaration(NamedDecl *, 1126 DeclContext*, 1127 ASTContext&); 1128 1129/// Filters out lookup results that don't fall within the given scope 1130/// as determined by isDeclInScope. 1131void Sema::FilterLookupForScope(LookupResult &R, 1132 DeclContext *Ctx, Scope *S, 1133 bool ConsiderLinkage, 1134 bool ExplicitInstantiationOrSpecialization) { 1135 LookupResult::Filter F = R.makeFilter(); 1136 while (F.hasNext()) { 1137 NamedDecl *D = F.next(); 1138 1139 if (isDeclInScope(D, Ctx, S, ExplicitInstantiationOrSpecialization)) 1140 continue; 1141 1142 if (ConsiderLinkage && 1143 isOutOfScopePreviousDeclaration(D, Ctx, Context)) 1144 continue; 1145 1146 F.erase(); 1147 } 1148 1149 F.done(); 1150} 1151 1152static bool isUsingDecl(NamedDecl *D) { 1153 return isa<UsingShadowDecl>(D) || 1154 isa<UnresolvedUsingTypenameDecl>(D) || 1155 isa<UnresolvedUsingValueDecl>(D); 1156} 1157 1158/// Removes using shadow declarations from the lookup results. 1159static void RemoveUsingDecls(LookupResult &R) { 1160 LookupResult::Filter F = R.makeFilter(); 1161 while (F.hasNext()) 1162 if (isUsingDecl(F.next())) 1163 F.erase(); 1164 1165 F.done(); 1166} 1167 1168/// \brief Check for this common pattern: 1169/// @code 1170/// class S { 1171/// S(const S&); // DO NOT IMPLEMENT 1172/// void operator=(const S&); // DO NOT IMPLEMENT 1173/// }; 1174/// @endcode 1175static bool IsDisallowedCopyOrAssign(const CXXMethodDecl *D) { 1176 // FIXME: Should check for private access too but access is set after we get 1177 // the decl here. 1178 if (D->doesThisDeclarationHaveABody()) 1179 return false; 1180 1181 if (const CXXConstructorDecl *CD = dyn_cast<CXXConstructorDecl>(D)) 1182 return CD->isCopyConstructor(); 1183 if (const CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D)) 1184 return Method->isCopyAssignmentOperator(); 1185 return false; 1186} 1187 1188// We need this to handle 1189// 1190// typedef struct { 1191// void *foo() { return 0; } 1192// } A; 1193// 1194// When we see foo we don't know if after the typedef we will get 'A' or '*A' 1195// for example. If 'A', foo will have external linkage. If we have '*A', 1196// foo will have no linkage. Since we can't know untill we get to the end 1197// of the typedef, this function finds out if D might have non external linkage. 1198// Callers should verify at the end of the TU if it D has external linkage or 1199// not. 1200bool Sema::mightHaveNonExternalLinkage(const DeclaratorDecl *D) { 1201 const DeclContext *DC = D->getDeclContext(); 1202 while (!DC->isTranslationUnit()) { 1203 if (const RecordDecl *RD = dyn_cast<RecordDecl>(DC)){ 1204 if (!RD->hasNameForLinkage()) 1205 return true; 1206 } 1207 DC = DC->getParent(); 1208 } 1209 1210 return !D->isExternallyVisible(); 1211} 1212 1213bool Sema::ShouldWarnIfUnusedFileScopedDecl(const DeclaratorDecl *D) const { 1214 assert(D); 1215 1216 if (D->isInvalidDecl() || D->isUsed() || D->hasAttr<UnusedAttr>()) 1217 return false; 1218 1219 // Ignore class templates. 1220 if (D->getDeclContext()->isDependentContext() || 1221 D->getLexicalDeclContext()->isDependentContext()) 1222 return false; 1223 1224 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) { 1225 if (FD->getTemplateSpecializationKind() == TSK_ImplicitInstantiation) 1226 return false; 1227 1228 if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) { 1229 if (MD->isVirtual() || IsDisallowedCopyOrAssign(MD)) 1230 return false; 1231 } else { 1232 // 'static inline' functions are used in headers; don't warn. 1233 // Make sure we get the storage class from the canonical declaration, 1234 // since otherwise we will get spurious warnings on specialized 1235 // static template functions. 1236 if (FD->getCanonicalDecl()->getStorageClass() == SC_Static && 1237 FD->isInlineSpecified()) 1238 return false; 1239 } 1240 1241 if (FD->doesThisDeclarationHaveABody() && 1242 Context.DeclMustBeEmitted(FD)) 1243 return false; 1244 } else if (const VarDecl *VD = dyn_cast<VarDecl>(D)) { 1245 // Don't warn on variables of const-qualified or reference type, since their 1246 // values can be used even if though they're not odr-used, and because const 1247 // qualified variables can appear in headers in contexts where they're not 1248 // intended to be used. 1249 // FIXME: Use more principled rules for these exemptions. 1250 if (!VD->isFileVarDecl() || 1251 VD->getType().isConstQualified() || 1252 VD->getType()->isReferenceType() || 1253 Context.DeclMustBeEmitted(VD)) 1254 return false; 1255 1256 if (VD->isStaticDataMember() && 1257 VD->getTemplateSpecializationKind() == TSK_ImplicitInstantiation) 1258 return false; 1259 1260 } else { 1261 return false; 1262 } 1263 1264 // Only warn for unused decls internal to the translation unit. 1265 return mightHaveNonExternalLinkage(D); 1266} 1267 1268void Sema::MarkUnusedFileScopedDecl(const DeclaratorDecl *D) { 1269 if (!D) 1270 return; 1271 1272 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) { 1273 const FunctionDecl *First = FD->getFirstDeclaration(); 1274 if (FD != First && ShouldWarnIfUnusedFileScopedDecl(First)) 1275 return; // First should already be in the vector. 1276 } 1277 1278 if (const VarDecl *VD = dyn_cast<VarDecl>(D)) { 1279 const VarDecl *First = VD->getFirstDeclaration(); 1280 if (VD != First && ShouldWarnIfUnusedFileScopedDecl(First)) 1281 return; // First should already be in the vector. 1282 } 1283 1284 if (ShouldWarnIfUnusedFileScopedDecl(D)) 1285 UnusedFileScopedDecls.push_back(D); 1286} 1287 1288static bool ShouldDiagnoseUnusedDecl(const NamedDecl *D) { 1289 if (D->isInvalidDecl()) 1290 return false; 1291 1292 if (D->isReferenced() || D->isUsed() || D->hasAttr<UnusedAttr>()) 1293 return false; 1294 1295 if (isa<LabelDecl>(D)) 1296 return true; 1297 1298 // White-list anything that isn't a local variable. 1299 if (!isa<VarDecl>(D) || isa<ParmVarDecl>(D) || isa<ImplicitParamDecl>(D) || 1300 !D->getDeclContext()->isFunctionOrMethod()) 1301 return false; 1302 1303 // Types of valid local variables should be complete, so this should succeed. 1304 if (const VarDecl *VD = dyn_cast<VarDecl>(D)) { 1305 1306 // White-list anything with an __attribute__((unused)) type. 1307 QualType Ty = VD->getType(); 1308 1309 // Only look at the outermost level of typedef. 1310 if (const TypedefType *TT = Ty->getAs<TypedefType>()) { 1311 if (TT->getDecl()->hasAttr<UnusedAttr>()) 1312 return false; 1313 } 1314 1315 // If we failed to complete the type for some reason, or if the type is 1316 // dependent, don't diagnose the variable. 1317 if (Ty->isIncompleteType() || Ty->isDependentType()) 1318 return false; 1319 1320 if (const TagType *TT = Ty->getAs<TagType>()) { 1321 const TagDecl *Tag = TT->getDecl(); 1322 if (Tag->hasAttr<UnusedAttr>()) 1323 return false; 1324 1325 if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(Tag)) { 1326 if (!RD->hasTrivialDestructor() && !RD->hasAttr<WarnUnusedAttr>()) 1327 return false; 1328 1329 if (const Expr *Init = VD->getInit()) { 1330 if (const ExprWithCleanups *Cleanups = dyn_cast<ExprWithCleanups>(Init)) 1331 Init = Cleanups->getSubExpr(); 1332 const CXXConstructExpr *Construct = 1333 dyn_cast<CXXConstructExpr>(Init); 1334 if (Construct && !Construct->isElidable()) { 1335 CXXConstructorDecl *CD = Construct->getConstructor(); 1336 if (!CD->isTrivial() && !RD->hasAttr<WarnUnusedAttr>()) 1337 return false; 1338 } 1339 } 1340 } 1341 } 1342 1343 // TODO: __attribute__((unused)) templates? 1344 } 1345 1346 return true; 1347} 1348 1349static void GenerateFixForUnusedDecl(const NamedDecl *D, ASTContext &Ctx, 1350 FixItHint &Hint) { 1351 if (isa<LabelDecl>(D)) { 1352 SourceLocation AfterColon = Lexer::findLocationAfterToken(D->getLocEnd(), 1353 tok::colon, Ctx.getSourceManager(), Ctx.getLangOpts(), true); 1354 if (AfterColon.isInvalid()) 1355 return; 1356 Hint = FixItHint::CreateRemoval(CharSourceRange:: 1357 getCharRange(D->getLocStart(), AfterColon)); 1358 } 1359 return; 1360} 1361 1362/// DiagnoseUnusedDecl - Emit warnings about declarations that are not used 1363/// unless they are marked attr(unused). 1364void Sema::DiagnoseUnusedDecl(const NamedDecl *D) { 1365 FixItHint Hint; 1366 if (!ShouldDiagnoseUnusedDecl(D)) 1367 return; 1368 1369 GenerateFixForUnusedDecl(D, Context, Hint); 1370 1371 unsigned DiagID; 1372 if (isa<VarDecl>(D) && cast<VarDecl>(D)->isExceptionVariable()) 1373 DiagID = diag::warn_unused_exception_param; 1374 else if (isa<LabelDecl>(D)) 1375 DiagID = diag::warn_unused_label; 1376 else 1377 DiagID = diag::warn_unused_variable; 1378 1379 Diag(D->getLocation(), DiagID) << D->getDeclName() << Hint; 1380} 1381 1382static void CheckPoppedLabel(LabelDecl *L, Sema &S) { 1383 // Verify that we have no forward references left. If so, there was a goto 1384 // or address of a label taken, but no definition of it. Label fwd 1385 // definitions are indicated with a null substmt. 1386 if (L->getStmt() == 0) 1387 S.Diag(L->getLocation(), diag::err_undeclared_label_use) <<L->getDeclName(); 1388} 1389 1390void Sema::ActOnPopScope(SourceLocation Loc, Scope *S) { 1391 if (S->decl_empty()) return; 1392 assert((S->getFlags() & (Scope::DeclScope | Scope::TemplateParamScope)) && 1393 "Scope shouldn't contain decls!"); 1394 1395 for (Scope::decl_iterator I = S->decl_begin(), E = S->decl_end(); 1396 I != E; ++I) { 1397 Decl *TmpD = (*I); 1398 assert(TmpD && "This decl didn't get pushed??"); 1399 1400 assert(isa<NamedDecl>(TmpD) && "Decl isn't NamedDecl?"); 1401 NamedDecl *D = cast<NamedDecl>(TmpD); 1402 1403 if (!D->getDeclName()) continue; 1404 1405 // Diagnose unused variables in this scope. 1406 if (!S->hasUnrecoverableErrorOccurred()) 1407 DiagnoseUnusedDecl(D); 1408 1409 // If this was a forward reference to a label, verify it was defined. 1410 if (LabelDecl *LD = dyn_cast<LabelDecl>(D)) 1411 CheckPoppedLabel(LD, *this); 1412 1413 // Remove this name from our lexical scope. 1414 IdResolver.RemoveDecl(D); 1415 } 1416} 1417 1418void Sema::ActOnStartFunctionDeclarator() { 1419 ++InFunctionDeclarator; 1420} 1421 1422void Sema::ActOnEndFunctionDeclarator() { 1423 assert(InFunctionDeclarator); 1424 --InFunctionDeclarator; 1425} 1426 1427/// \brief Look for an Objective-C class in the translation unit. 1428/// 1429/// \param Id The name of the Objective-C class we're looking for. If 1430/// typo-correction fixes this name, the Id will be updated 1431/// to the fixed name. 1432/// 1433/// \param IdLoc The location of the name in the translation unit. 1434/// 1435/// \param DoTypoCorrection If true, this routine will attempt typo correction 1436/// if there is no class with the given name. 1437/// 1438/// \returns The declaration of the named Objective-C class, or NULL if the 1439/// class could not be found. 1440ObjCInterfaceDecl *Sema::getObjCInterfaceDecl(IdentifierInfo *&Id, 1441 SourceLocation IdLoc, 1442 bool DoTypoCorrection) { 1443 // The third "scope" argument is 0 since we aren't enabling lazy built-in 1444 // creation from this context. 1445 NamedDecl *IDecl = LookupSingleName(TUScope, Id, IdLoc, LookupOrdinaryName); 1446 1447 if (!IDecl && DoTypoCorrection) { 1448 // Perform typo correction at the given location, but only if we 1449 // find an Objective-C class name. 1450 DeclFilterCCC<ObjCInterfaceDecl> Validator; 1451 if (TypoCorrection C = CorrectTypo(DeclarationNameInfo(Id, IdLoc), 1452 LookupOrdinaryName, TUScope, NULL, 1453 Validator)) { 1454 IDecl = C.getCorrectionDeclAs<ObjCInterfaceDecl>(); 1455 Diag(IdLoc, diag::err_undef_interface_suggest) 1456 << Id << IDecl->getDeclName() 1457 << FixItHint::CreateReplacement(IdLoc, IDecl->getNameAsString()); 1458 Diag(IDecl->getLocation(), diag::note_previous_decl) 1459 << IDecl->getDeclName(); 1460 1461 Id = IDecl->getIdentifier(); 1462 } 1463 } 1464 ObjCInterfaceDecl *Def = dyn_cast_or_null<ObjCInterfaceDecl>(IDecl); 1465 // This routine must always return a class definition, if any. 1466 if (Def && Def->getDefinition()) 1467 Def = Def->getDefinition(); 1468 return Def; 1469} 1470 1471/// getNonFieldDeclScope - Retrieves the innermost scope, starting 1472/// from S, where a non-field would be declared. This routine copes 1473/// with the difference between C and C++ scoping rules in structs and 1474/// unions. For example, the following code is well-formed in C but 1475/// ill-formed in C++: 1476/// @code 1477/// struct S6 { 1478/// enum { BAR } e; 1479/// }; 1480/// 1481/// void test_S6() { 1482/// struct S6 a; 1483/// a.e = BAR; 1484/// } 1485/// @endcode 1486/// For the declaration of BAR, this routine will return a different 1487/// scope. The scope S will be the scope of the unnamed enumeration 1488/// within S6. In C++, this routine will return the scope associated 1489/// with S6, because the enumeration's scope is a transparent 1490/// context but structures can contain non-field names. In C, this 1491/// routine will return the translation unit scope, since the 1492/// enumeration's scope is a transparent context and structures cannot 1493/// contain non-field names. 1494Scope *Sema::getNonFieldDeclScope(Scope *S) { 1495 while (((S->getFlags() & Scope::DeclScope) == 0) || 1496 (S->getEntity() && 1497 ((DeclContext *)S->getEntity())->isTransparentContext()) || 1498 (S->isClassScope() && !getLangOpts().CPlusPlus)) 1499 S = S->getParent(); 1500 return S; 1501} 1502 1503/// \brief Looks up the declaration of "struct objc_super" and 1504/// saves it for later use in building builtin declaration of 1505/// objc_msgSendSuper and objc_msgSendSuper_stret. If no such 1506/// pre-existing declaration exists no action takes place. 1507static void LookupPredefedObjCSuperType(Sema &ThisSema, Scope *S, 1508 IdentifierInfo *II) { 1509 if (!II->isStr("objc_msgSendSuper")) 1510 return; 1511 ASTContext &Context = ThisSema.Context; 1512 1513 LookupResult Result(ThisSema, &Context.Idents.get("objc_super"), 1514 SourceLocation(), Sema::LookupTagName); 1515 ThisSema.LookupName(Result, S); 1516 if (Result.getResultKind() == LookupResult::Found) 1517 if (const TagDecl *TD = Result.getAsSingle<TagDecl>()) 1518 Context.setObjCSuperType(Context.getTagDeclType(TD)); 1519} 1520 1521/// LazilyCreateBuiltin - The specified Builtin-ID was first used at 1522/// file scope. lazily create a decl for it. ForRedeclaration is true 1523/// if we're creating this built-in in anticipation of redeclaring the 1524/// built-in. 1525NamedDecl *Sema::LazilyCreateBuiltin(IdentifierInfo *II, unsigned bid, 1526 Scope *S, bool ForRedeclaration, 1527 SourceLocation Loc) { 1528 LookupPredefedObjCSuperType(*this, S, II); 1529 1530 Builtin::ID BID = (Builtin::ID)bid; 1531 1532 ASTContext::GetBuiltinTypeError Error; 1533 QualType R = Context.GetBuiltinType(BID, Error); 1534 switch (Error) { 1535 case ASTContext::GE_None: 1536 // Okay 1537 break; 1538 1539 case ASTContext::GE_Missing_stdio: 1540 if (ForRedeclaration) 1541 Diag(Loc, diag::warn_implicit_decl_requires_stdio) 1542 << Context.BuiltinInfo.GetName(BID); 1543 return 0; 1544 1545 case ASTContext::GE_Missing_setjmp: 1546 if (ForRedeclaration) 1547 Diag(Loc, diag::warn_implicit_decl_requires_setjmp) 1548 << Context.BuiltinInfo.GetName(BID); 1549 return 0; 1550 1551 case ASTContext::GE_Missing_ucontext: 1552 if (ForRedeclaration) 1553 Diag(Loc, diag::warn_implicit_decl_requires_ucontext) 1554 << Context.BuiltinInfo.GetName(BID); 1555 return 0; 1556 } 1557 1558 if (!ForRedeclaration && Context.BuiltinInfo.isPredefinedLibFunction(BID)) { 1559 Diag(Loc, diag::ext_implicit_lib_function_decl) 1560 << Context.BuiltinInfo.GetName(BID) 1561 << R; 1562 if (Context.BuiltinInfo.getHeaderName(BID) && 1563 Diags.getDiagnosticLevel(diag::ext_implicit_lib_function_decl, Loc) 1564 != DiagnosticsEngine::Ignored) 1565 Diag(Loc, diag::note_please_include_header) 1566 << Context.BuiltinInfo.getHeaderName(BID) 1567 << Context.BuiltinInfo.GetName(BID); 1568 } 1569 1570 FunctionDecl *New = FunctionDecl::Create(Context, 1571 Context.getTranslationUnitDecl(), 1572 Loc, Loc, II, R, /*TInfo=*/0, 1573 SC_Extern, 1574 false, 1575 /*hasPrototype=*/true); 1576 New->setImplicit(); 1577 1578 // Create Decl objects for each parameter, adding them to the 1579 // FunctionDecl. 1580 if (const FunctionProtoType *FT = dyn_cast<FunctionProtoType>(R)) { 1581 SmallVector<ParmVarDecl*, 16> Params; 1582 for (unsigned i = 0, e = FT->getNumArgs(); i != e; ++i) { 1583 ParmVarDecl *parm = 1584 ParmVarDecl::Create(Context, New, SourceLocation(), 1585 SourceLocation(), 0, 1586 FT->getArgType(i), /*TInfo=*/0, 1587 SC_None, 0); 1588 parm->setScopeInfo(0, i); 1589 Params.push_back(parm); 1590 } 1591 New->setParams(Params); 1592 } 1593 1594 AddKnownFunctionAttributes(New); 1595 1596 // TUScope is the translation-unit scope to insert this function into. 1597 // FIXME: This is hideous. We need to teach PushOnScopeChains to 1598 // relate Scopes to DeclContexts, and probably eliminate CurContext 1599 // entirely, but we're not there yet. 1600 DeclContext *SavedContext = CurContext; 1601 CurContext = Context.getTranslationUnitDecl(); 1602 PushOnScopeChains(New, TUScope); 1603 CurContext = SavedContext; 1604 return New; 1605} 1606 1607/// \brief Filter out any previous declarations that the given declaration 1608/// should not consider because they are not permitted to conflict, e.g., 1609/// because they come from hidden sub-modules and do not refer to the same 1610/// entity. 1611static void filterNonConflictingPreviousDecls(ASTContext &context, 1612 NamedDecl *decl, 1613 LookupResult &previous){ 1614 // This is only interesting when modules are enabled. 1615 if (!context.getLangOpts().Modules) 1616 return; 1617 1618 // Empty sets are uninteresting. 1619 if (previous.empty()) 1620 return; 1621 1622 LookupResult::Filter filter = previous.makeFilter(); 1623 while (filter.hasNext()) { 1624 NamedDecl *old = filter.next(); 1625 1626 // Non-hidden declarations are never ignored. 1627 if (!old->isHidden()) 1628 continue; 1629 1630 if (!old->isExternallyVisible()) 1631 filter.erase(); 1632 } 1633 1634 filter.done(); 1635} 1636 1637bool Sema::isIncompatibleTypedef(TypeDecl *Old, TypedefNameDecl *New) { 1638 QualType OldType; 1639 if (TypedefNameDecl *OldTypedef = dyn_cast<TypedefNameDecl>(Old)) 1640 OldType = OldTypedef->getUnderlyingType(); 1641 else 1642 OldType = Context.getTypeDeclType(Old); 1643 QualType NewType = New->getUnderlyingType(); 1644 1645 if (NewType->isVariablyModifiedType()) { 1646 // Must not redefine a typedef with a variably-modified type. 1647 int Kind = isa<TypeAliasDecl>(Old) ? 1 : 0; 1648 Diag(New->getLocation(), diag::err_redefinition_variably_modified_typedef) 1649 << Kind << NewType; 1650 if (Old->getLocation().isValid()) 1651 Diag(Old->getLocation(), diag::note_previous_definition); 1652 New->setInvalidDecl(); 1653 return true; 1654 } 1655 1656 if (OldType != NewType && 1657 !OldType->isDependentType() && 1658 !NewType->isDependentType() && 1659 !Context.hasSameType(OldType, NewType)) { 1660 int Kind = isa<TypeAliasDecl>(Old) ? 1 : 0; 1661 Diag(New->getLocation(), diag::err_redefinition_different_typedef) 1662 << Kind << NewType << OldType; 1663 if (Old->getLocation().isValid()) 1664 Diag(Old->getLocation(), diag::note_previous_definition); 1665 New->setInvalidDecl(); 1666 return true; 1667 } 1668 return false; 1669} 1670 1671/// MergeTypedefNameDecl - We just parsed a typedef 'New' which has the 1672/// same name and scope as a previous declaration 'Old'. Figure out 1673/// how to resolve this situation, merging decls or emitting 1674/// diagnostics as appropriate. If there was an error, set New to be invalid. 1675/// 1676void Sema::MergeTypedefNameDecl(TypedefNameDecl *New, LookupResult &OldDecls) { 1677 // If the new decl is known invalid already, don't bother doing any 1678 // merging checks. 1679 if (New->isInvalidDecl()) return; 1680 1681 // Allow multiple definitions for ObjC built-in typedefs. 1682 // FIXME: Verify the underlying types are equivalent! 1683 if (getLangOpts().ObjC1) { 1684 const IdentifierInfo *TypeID = New->getIdentifier(); 1685 switch (TypeID->getLength()) { 1686 default: break; 1687 case 2: 1688 { 1689 if (!TypeID->isStr("id")) 1690 break; 1691 QualType T = New->getUnderlyingType(); 1692 if (!T->isPointerType()) 1693 break; 1694 if (!T->isVoidPointerType()) { 1695 QualType PT = T->getAs<PointerType>()->getPointeeType(); 1696 if (!PT->isStructureType()) 1697 break; 1698 } 1699 Context.setObjCIdRedefinitionType(T); 1700 // Install the built-in type for 'id', ignoring the current definition. 1701 New->setTypeForDecl(Context.getObjCIdType().getTypePtr()); 1702 return; 1703 } 1704 case 5: 1705 if (!TypeID->isStr("Class")) 1706 break; 1707 Context.setObjCClassRedefinitionType(New->getUnderlyingType()); 1708 // Install the built-in type for 'Class', ignoring the current definition. 1709 New->setTypeForDecl(Context.getObjCClassType().getTypePtr()); 1710 return; 1711 case 3: 1712 if (!TypeID->isStr("SEL")) 1713 break; 1714 Context.setObjCSelRedefinitionType(New->getUnderlyingType()); 1715 // Install the built-in type for 'SEL', ignoring the current definition. 1716 New->setTypeForDecl(Context.getObjCSelType().getTypePtr()); 1717 return; 1718 } 1719 // Fall through - the typedef name was not a builtin type. 1720 } 1721 1722 // Verify the old decl was also a type. 1723 TypeDecl *Old = OldDecls.getAsSingle<TypeDecl>(); 1724 if (!Old) { 1725 Diag(New->getLocation(), diag::err_redefinition_different_kind) 1726 << New->getDeclName(); 1727 1728 NamedDecl *OldD = OldDecls.getRepresentativeDecl(); 1729 if (OldD->getLocation().isValid()) 1730 Diag(OldD->getLocation(), diag::note_previous_definition); 1731 1732 return New->setInvalidDecl(); 1733 } 1734 1735 // If the old declaration is invalid, just give up here. 1736 if (Old->isInvalidDecl()) 1737 return New->setInvalidDecl(); 1738 1739 // If the typedef types are not identical, reject them in all languages and 1740 // with any extensions enabled. 1741 if (isIncompatibleTypedef(Old, New)) 1742 return; 1743 1744 // The types match. Link up the redeclaration chain if the old 1745 // declaration was a typedef. 1746 if (TypedefNameDecl *Typedef = dyn_cast<TypedefNameDecl>(Old)) 1747 New->setPreviousDeclaration(Typedef); 1748 1749 mergeDeclAttributes(New, Old); 1750 1751 if (getLangOpts().MicrosoftExt) 1752 return; 1753 1754 if (getLangOpts().CPlusPlus) { 1755 // C++ [dcl.typedef]p2: 1756 // In a given non-class scope, a typedef specifier can be used to 1757 // redefine the name of any type declared in that scope to refer 1758 // to the type to which it already refers. 1759 if (!isa<CXXRecordDecl>(CurContext)) 1760 return; 1761 1762 // C++0x [dcl.typedef]p4: 1763 // In a given class scope, a typedef specifier can be used to redefine 1764 // any class-name declared in that scope that is not also a typedef-name 1765 // to refer to the type to which it already refers. 1766 // 1767 // This wording came in via DR424, which was a correction to the 1768 // wording in DR56, which accidentally banned code like: 1769 // 1770 // struct S { 1771 // typedef struct A { } A; 1772 // }; 1773 // 1774 // in the C++03 standard. We implement the C++0x semantics, which 1775 // allow the above but disallow 1776 // 1777 // struct S { 1778 // typedef int I; 1779 // typedef int I; 1780 // }; 1781 // 1782 // since that was the intent of DR56. 1783 if (!isa<TypedefNameDecl>(Old)) 1784 return; 1785 1786 Diag(New->getLocation(), diag::err_redefinition) 1787 << New->getDeclName(); 1788 Diag(Old->getLocation(), diag::note_previous_definition); 1789 return New->setInvalidDecl(); 1790 } 1791 1792 // Modules always permit redefinition of typedefs, as does C11. 1793 if (getLangOpts().Modules || getLangOpts().C11) 1794 return; 1795 1796 // If we have a redefinition of a typedef in C, emit a warning. This warning 1797 // is normally mapped to an error, but can be controlled with 1798 // -Wtypedef-redefinition. If either the original or the redefinition is 1799 // in a system header, don't emit this for compatibility with GCC. 1800 if (getDiagnostics().getSuppressSystemWarnings() && 1801 (Context.getSourceManager().isInSystemHeader(Old->getLocation()) || 1802 Context.getSourceManager().isInSystemHeader(New->getLocation()))) 1803 return; 1804 1805 Diag(New->getLocation(), diag::warn_redefinition_of_typedef) 1806 << New->getDeclName(); 1807 Diag(Old->getLocation(), diag::note_previous_definition); 1808 return; 1809} 1810 1811/// DeclhasAttr - returns true if decl Declaration already has the target 1812/// attribute. 1813static bool 1814DeclHasAttr(const Decl *D, const Attr *A) { 1815 // There can be multiple AvailabilityAttr in a Decl. Make sure we copy 1816 // all of them. It is mergeAvailabilityAttr in SemaDeclAttr.cpp that is 1817 // responsible for making sure they are consistent. 1818 const AvailabilityAttr *AA = dyn_cast<AvailabilityAttr>(A); 1819 if (AA) 1820 return false; 1821 1822 // The following thread safety attributes can also be duplicated. 1823 switch (A->getKind()) { 1824 case attr::ExclusiveLocksRequired: 1825 case attr::SharedLocksRequired: 1826 case attr::LocksExcluded: 1827 case attr::ExclusiveLockFunction: 1828 case attr::SharedLockFunction: 1829 case attr::UnlockFunction: 1830 case attr::ExclusiveTrylockFunction: 1831 case attr::SharedTrylockFunction: 1832 case attr::GuardedBy: 1833 case attr::PtGuardedBy: 1834 case attr::AcquiredBefore: 1835 case attr::AcquiredAfter: 1836 return false; 1837 default: 1838 ; 1839 } 1840 1841 const OwnershipAttr *OA = dyn_cast<OwnershipAttr>(A); 1842 const AnnotateAttr *Ann = dyn_cast<AnnotateAttr>(A); 1843 for (Decl::attr_iterator i = D->attr_begin(), e = D->attr_end(); i != e; ++i) 1844 if ((*i)->getKind() == A->getKind()) { 1845 if (Ann) { 1846 if (Ann->getAnnotation() == cast<AnnotateAttr>(*i)->getAnnotation()) 1847 return true; 1848 continue; 1849 } 1850 // FIXME: Don't hardcode this check 1851 if (OA && isa<OwnershipAttr>(*i)) 1852 return OA->getOwnKind() == cast<OwnershipAttr>(*i)->getOwnKind(); 1853 return true; 1854 } 1855 1856 return false; 1857} 1858 1859static bool isAttributeTargetADefinition(Decl *D) { 1860 if (VarDecl *VD = dyn_cast<VarDecl>(D)) 1861 return VD->isThisDeclarationADefinition(); 1862 if (TagDecl *TD = dyn_cast<TagDecl>(D)) 1863 return TD->isCompleteDefinition() || TD->isBeingDefined(); 1864 return true; 1865} 1866 1867/// Merge alignment attributes from \p Old to \p New, taking into account the 1868/// special semantics of C11's _Alignas specifier and C++11's alignas attribute. 1869/// 1870/// \return \c true if any attributes were added to \p New. 1871static bool mergeAlignedAttrs(Sema &S, NamedDecl *New, Decl *Old) { 1872 // Look for alignas attributes on Old, and pick out whichever attribute 1873 // specifies the strictest alignment requirement. 1874 AlignedAttr *OldAlignasAttr = 0; 1875 AlignedAttr *OldStrictestAlignAttr = 0; 1876 unsigned OldAlign = 0; 1877 for (specific_attr_iterator<AlignedAttr> 1878 I = Old->specific_attr_begin<AlignedAttr>(), 1879 E = Old->specific_attr_end<AlignedAttr>(); I != E; ++I) { 1880 // FIXME: We have no way of representing inherited dependent alignments 1881 // in a case like: 1882 // template<int A, int B> struct alignas(A) X; 1883 // template<int A, int B> struct alignas(B) X {}; 1884 // For now, we just ignore any alignas attributes which are not on the 1885 // definition in such a case. 1886 if (I->isAlignmentDependent()) 1887 return false; 1888 1889 if (I->isAlignas()) 1890 OldAlignasAttr = *I; 1891 1892 unsigned Align = I->getAlignment(S.Context); 1893 if (Align > OldAlign) { 1894 OldAlign = Align; 1895 OldStrictestAlignAttr = *I; 1896 } 1897 } 1898 1899 // Look for alignas attributes on New. 1900 AlignedAttr *NewAlignasAttr = 0; 1901 unsigned NewAlign = 0; 1902 for (specific_attr_iterator<AlignedAttr> 1903 I = New->specific_attr_begin<AlignedAttr>(), 1904 E = New->specific_attr_end<AlignedAttr>(); I != E; ++I) { 1905 if (I->isAlignmentDependent()) 1906 return false; 1907 1908 if (I->isAlignas()) 1909 NewAlignasAttr = *I; 1910 1911 unsigned Align = I->getAlignment(S.Context); 1912 if (Align > NewAlign) 1913 NewAlign = Align; 1914 } 1915 1916 if (OldAlignasAttr && NewAlignasAttr && OldAlign != NewAlign) { 1917 // Both declarations have 'alignas' attributes. We require them to match. 1918 // C++11 [dcl.align]p6 and C11 6.7.5/7 both come close to saying this, but 1919 // fall short. (If two declarations both have alignas, they must both match 1920 // every definition, and so must match each other if there is a definition.) 1921 1922 // If either declaration only contains 'alignas(0)' specifiers, then it 1923 // specifies the natural alignment for the type. 1924 if (OldAlign == 0 || NewAlign == 0) { 1925 QualType Ty; 1926 if (ValueDecl *VD = dyn_cast<ValueDecl>(New)) 1927 Ty = VD->getType(); 1928 else 1929 Ty = S.Context.getTagDeclType(cast<TagDecl>(New)); 1930 1931 if (OldAlign == 0) 1932 OldAlign = S.Context.getTypeAlign(Ty); 1933 if (NewAlign == 0) 1934 NewAlign = S.Context.getTypeAlign(Ty); 1935 } 1936 1937 if (OldAlign != NewAlign) { 1938 S.Diag(NewAlignasAttr->getLocation(), diag::err_alignas_mismatch) 1939 << (unsigned)S.Context.toCharUnitsFromBits(OldAlign).getQuantity() 1940 << (unsigned)S.Context.toCharUnitsFromBits(NewAlign).getQuantity(); 1941 S.Diag(OldAlignasAttr->getLocation(), diag::note_previous_declaration); 1942 } 1943 } 1944 1945 if (OldAlignasAttr && !NewAlignasAttr && isAttributeTargetADefinition(New)) { 1946 // C++11 [dcl.align]p6: 1947 // if any declaration of an entity has an alignment-specifier, 1948 // every defining declaration of that entity shall specify an 1949 // equivalent alignment. 1950 // C11 6.7.5/7: 1951 // If the definition of an object does not have an alignment 1952 // specifier, any other declaration of that object shall also 1953 // have no alignment specifier. 1954 S.Diag(New->getLocation(), diag::err_alignas_missing_on_definition) 1955 << OldAlignasAttr->isC11(); 1956 S.Diag(OldAlignasAttr->getLocation(), diag::note_alignas_on_declaration) 1957 << OldAlignasAttr->isC11(); 1958 } 1959 1960 bool AnyAdded = false; 1961 1962 // Ensure we have an attribute representing the strictest alignment. 1963 if (OldAlign > NewAlign) { 1964 AlignedAttr *Clone = OldStrictestAlignAttr->clone(S.Context); 1965 Clone->setInherited(true); 1966 New->addAttr(Clone); 1967 AnyAdded = true; 1968 } 1969 1970 // Ensure we have an alignas attribute if the old declaration had one. 1971 if (OldAlignasAttr && !NewAlignasAttr && 1972 !(AnyAdded && OldStrictestAlignAttr->isAlignas())) { 1973 AlignedAttr *Clone = OldAlignasAttr->clone(S.Context); 1974 Clone->setInherited(true); 1975 New->addAttr(Clone); 1976 AnyAdded = true; 1977 } 1978 1979 return AnyAdded; 1980} 1981 1982static bool mergeDeclAttribute(Sema &S, NamedDecl *D, InheritableAttr *Attr, 1983 bool Override) { 1984 InheritableAttr *NewAttr = NULL; 1985 unsigned AttrSpellingListIndex = Attr->getSpellingListIndex(); 1986 if (AvailabilityAttr *AA = dyn_cast<AvailabilityAttr>(Attr)) 1987 NewAttr = S.mergeAvailabilityAttr(D, AA->getRange(), AA->getPlatform(), 1988 AA->getIntroduced(), AA->getDeprecated(), 1989 AA->getObsoleted(), AA->getUnavailable(), 1990 AA->getMessage(), Override, 1991 AttrSpellingListIndex); 1992 else if (VisibilityAttr *VA = dyn_cast<VisibilityAttr>(Attr)) 1993 NewAttr = S.mergeVisibilityAttr(D, VA->getRange(), VA->getVisibility(), 1994 AttrSpellingListIndex); 1995 else if (TypeVisibilityAttr *VA = dyn_cast<TypeVisibilityAttr>(Attr)) 1996 NewAttr = S.mergeTypeVisibilityAttr(D, VA->getRange(), VA->getVisibility(), 1997 AttrSpellingListIndex); 1998 else if (DLLImportAttr *ImportA = dyn_cast<DLLImportAttr>(Attr)) 1999 NewAttr = S.mergeDLLImportAttr(D, ImportA->getRange(), 2000 AttrSpellingListIndex); 2001 else if (DLLExportAttr *ExportA = dyn_cast<DLLExportAttr>(Attr)) 2002 NewAttr = S.mergeDLLExportAttr(D, ExportA->getRange(), 2003 AttrSpellingListIndex); 2004 else if (FormatAttr *FA = dyn_cast<FormatAttr>(Attr)) 2005 NewAttr = S.mergeFormatAttr(D, FA->getRange(), FA->getType(), 2006 FA->getFormatIdx(), FA->getFirstArg(), 2007 AttrSpellingListIndex); 2008 else if (SectionAttr *SA = dyn_cast<SectionAttr>(Attr)) 2009 NewAttr = S.mergeSectionAttr(D, SA->getRange(), SA->getName(), 2010 AttrSpellingListIndex); 2011 else if (isa<AlignedAttr>(Attr)) 2012 // AlignedAttrs are handled separately, because we need to handle all 2013 // such attributes on a declaration at the same time. 2014 NewAttr = 0; 2015 else if (!DeclHasAttr(D, Attr)) 2016 NewAttr = cast<InheritableAttr>(Attr->clone(S.Context)); 2017 2018 if (NewAttr) { 2019 NewAttr->setInherited(true); 2020 D->addAttr(NewAttr); 2021 return true; 2022 } 2023 2024 return false; 2025} 2026 2027static const Decl *getDefinition(const Decl *D) { 2028 if (const TagDecl *TD = dyn_cast<TagDecl>(D)) 2029 return TD->getDefinition(); 2030 if (const VarDecl *VD = dyn_cast<VarDecl>(D)) 2031 return VD->getDefinition(); 2032 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) { 2033 const FunctionDecl* Def; 2034 if (FD->hasBody(Def)) 2035 return Def; 2036 } 2037 return NULL; 2038} 2039 2040static bool hasAttribute(const Decl *D, attr::Kind Kind) { 2041 for (Decl::attr_iterator I = D->attr_begin(), E = D->attr_end(); 2042 I != E; ++I) { 2043 Attr *Attribute = *I; 2044 if (Attribute->getKind() == Kind) 2045 return true; 2046 } 2047 return false; 2048} 2049 2050/// checkNewAttributesAfterDef - If we already have a definition, check that 2051/// there are no new attributes in this declaration. 2052static void checkNewAttributesAfterDef(Sema &S, Decl *New, const Decl *Old) { 2053 if (!New->hasAttrs()) 2054 return; 2055 2056 const Decl *Def = getDefinition(Old); 2057 if (!Def || Def == New) 2058 return; 2059 2060 AttrVec &NewAttributes = New->getAttrs(); 2061 for (unsigned I = 0, E = NewAttributes.size(); I != E;) { 2062 const Attr *NewAttribute = NewAttributes[I]; 2063 if (hasAttribute(Def, NewAttribute->getKind())) { 2064 ++I; 2065 continue; // regular attr merging will take care of validating this. 2066 } 2067 2068 if (isa<C11NoReturnAttr>(NewAttribute)) { 2069 // C's _Noreturn is allowed to be added to a function after it is defined. 2070 ++I; 2071 continue; 2072 } else if (const AlignedAttr *AA = dyn_cast<AlignedAttr>(NewAttribute)) { 2073 if (AA->isAlignas()) { 2074 // C++11 [dcl.align]p6: 2075 // if any declaration of an entity has an alignment-specifier, 2076 // every defining declaration of that entity shall specify an 2077 // equivalent alignment. 2078 // C11 6.7.5/7: 2079 // If the definition of an object does not have an alignment 2080 // specifier, any other declaration of that object shall also 2081 // have no alignment specifier. 2082 S.Diag(Def->getLocation(), diag::err_alignas_missing_on_definition) 2083 << AA->isC11(); 2084 S.Diag(NewAttribute->getLocation(), diag::note_alignas_on_declaration) 2085 << AA->isC11(); 2086 NewAttributes.erase(NewAttributes.begin() + I); 2087 --E; 2088 continue; 2089 } 2090 } 2091 2092 S.Diag(NewAttribute->getLocation(), 2093 diag::warn_attribute_precede_definition); 2094 S.Diag(Def->getLocation(), diag::note_previous_definition); 2095 NewAttributes.erase(NewAttributes.begin() + I); 2096 --E; 2097 } 2098} 2099 2100/// mergeDeclAttributes - Copy attributes from the Old decl to the New one. 2101void Sema::mergeDeclAttributes(NamedDecl *New, Decl *Old, 2102 AvailabilityMergeKind AMK) { 2103 if (!Old->hasAttrs() && !New->hasAttrs()) 2104 return; 2105 2106 // attributes declared post-definition are currently ignored 2107 checkNewAttributesAfterDef(*this, New, Old); 2108 2109 if (!Old->hasAttrs()) 2110 return; 2111 2112 bool foundAny = New->hasAttrs(); 2113 2114 // Ensure that any moving of objects within the allocated map is done before 2115 // we process them. 2116 if (!foundAny) New->setAttrs(AttrVec()); 2117 2118 for (specific_attr_iterator<InheritableAttr> 2119 i = Old->specific_attr_begin<InheritableAttr>(), 2120 e = Old->specific_attr_end<InheritableAttr>(); 2121 i != e; ++i) { 2122 bool Override = false; 2123 // Ignore deprecated/unavailable/availability attributes if requested. 2124 if (isa<DeprecatedAttr>(*i) || 2125 isa<UnavailableAttr>(*i) || 2126 isa<AvailabilityAttr>(*i)) { 2127 switch (AMK) { 2128 case AMK_None: 2129 continue; 2130 2131 case AMK_Redeclaration: 2132 break; 2133 2134 case AMK_Override: 2135 Override = true; 2136 break; 2137 } 2138 } 2139 2140 if (mergeDeclAttribute(*this, New, *i, Override)) 2141 foundAny = true; 2142 } 2143 2144 if (mergeAlignedAttrs(*this, New, Old)) 2145 foundAny = true; 2146 2147 if (!foundAny) New->dropAttrs(); 2148} 2149 2150/// mergeParamDeclAttributes - Copy attributes from the old parameter 2151/// to the new one. 2152static void mergeParamDeclAttributes(ParmVarDecl *newDecl, 2153 const ParmVarDecl *oldDecl, 2154 Sema &S) { 2155 // C++11 [dcl.attr.depend]p2: 2156 // The first declaration of a function shall specify the 2157 // carries_dependency attribute for its declarator-id if any declaration 2158 // of the function specifies the carries_dependency attribute. 2159 if (newDecl->hasAttr<CarriesDependencyAttr>() && 2160 !oldDecl->hasAttr<CarriesDependencyAttr>()) { 2161 S.Diag(newDecl->getAttr<CarriesDependencyAttr>()->getLocation(), 2162 diag::err_carries_dependency_missing_on_first_decl) << 1/*Param*/; 2163 // Find the first declaration of the parameter. 2164 // FIXME: Should we build redeclaration chains for function parameters? 2165 const FunctionDecl *FirstFD = 2166 cast<FunctionDecl>(oldDecl->getDeclContext())->getFirstDeclaration(); 2167 const ParmVarDecl *FirstVD = 2168 FirstFD->getParamDecl(oldDecl->getFunctionScopeIndex()); 2169 S.Diag(FirstVD->getLocation(), 2170 diag::note_carries_dependency_missing_first_decl) << 1/*Param*/; 2171 } 2172 2173 if (!oldDecl->hasAttrs()) 2174 return; 2175 2176 bool foundAny = newDecl->hasAttrs(); 2177 2178 // Ensure that any moving of objects within the allocated map is 2179 // done before we process them. 2180 if (!foundAny) newDecl->setAttrs(AttrVec()); 2181 2182 for (specific_attr_iterator<InheritableParamAttr> 2183 i = oldDecl->specific_attr_begin<InheritableParamAttr>(), 2184 e = oldDecl->specific_attr_end<InheritableParamAttr>(); i != e; ++i) { 2185 if (!DeclHasAttr(newDecl, *i)) { 2186 InheritableAttr *newAttr = 2187 cast<InheritableParamAttr>((*i)->clone(S.Context)); 2188 newAttr->setInherited(true); 2189 newDecl->addAttr(newAttr); 2190 foundAny = true; 2191 } 2192 } 2193 2194 if (!foundAny) newDecl->dropAttrs(); 2195} 2196 2197namespace { 2198 2199/// Used in MergeFunctionDecl to keep track of function parameters in 2200/// C. 2201struct GNUCompatibleParamWarning { 2202 ParmVarDecl *OldParm; 2203 ParmVarDecl *NewParm; 2204 QualType PromotedType; 2205}; 2206 2207} 2208 2209/// getSpecialMember - get the special member enum for a method. 2210Sema::CXXSpecialMember Sema::getSpecialMember(const CXXMethodDecl *MD) { 2211 if (const CXXConstructorDecl *Ctor = dyn_cast<CXXConstructorDecl>(MD)) { 2212 if (Ctor->isDefaultConstructor()) 2213 return Sema::CXXDefaultConstructor; 2214 2215 if (Ctor->isCopyConstructor()) 2216 return Sema::CXXCopyConstructor; 2217 2218 if (Ctor->isMoveConstructor()) 2219 return Sema::CXXMoveConstructor; 2220 } else if (isa<CXXDestructorDecl>(MD)) { 2221 return Sema::CXXDestructor; 2222 } else if (MD->isCopyAssignmentOperator()) { 2223 return Sema::CXXCopyAssignment; 2224 } else if (MD->isMoveAssignmentOperator()) { 2225 return Sema::CXXMoveAssignment; 2226 } 2227 2228 return Sema::CXXInvalid; 2229} 2230 2231/// canRedefineFunction - checks if a function can be redefined. Currently, 2232/// only extern inline functions can be redefined, and even then only in 2233/// GNU89 mode. 2234static bool canRedefineFunction(const FunctionDecl *FD, 2235 const LangOptions& LangOpts) { 2236 return ((FD->hasAttr<GNUInlineAttr>() || LangOpts.GNUInline) && 2237 !LangOpts.CPlusPlus && 2238 FD->isInlineSpecified() && 2239 FD->getStorageClass() == SC_Extern); 2240} 2241 2242/// Is the given calling convention the ABI default for the given 2243/// declaration? 2244static bool isABIDefaultCC(Sema &S, CallingConv CC, FunctionDecl *D) { 2245 CallingConv ABIDefaultCC; 2246 if (isa<CXXMethodDecl>(D) && cast<CXXMethodDecl>(D)->isInstance()) { 2247 ABIDefaultCC = S.Context.getDefaultCXXMethodCallConv(D->isVariadic()); 2248 } else { 2249 // Free C function or a static method. 2250 ABIDefaultCC = (S.Context.getLangOpts().MRTD ? CC_X86StdCall : CC_C); 2251 } 2252 return ABIDefaultCC == CC; 2253} 2254 2255template <typename T> 2256static bool haveIncompatibleLanguageLinkages(const T *Old, const T *New) { 2257 const DeclContext *DC = Old->getDeclContext(); 2258 if (DC->isRecord()) 2259 return false; 2260 2261 LanguageLinkage OldLinkage = Old->getLanguageLinkage(); 2262 if (OldLinkage == CXXLanguageLinkage && New->isInExternCContext()) 2263 return true; 2264 if (OldLinkage == CLanguageLinkage && New->isInExternCXXContext()) 2265 return true; 2266 return false; 2267} 2268 2269/// MergeFunctionDecl - We just parsed a function 'New' from 2270/// declarator D which has the same name and scope as a previous 2271/// declaration 'Old'. Figure out how to resolve this situation, 2272/// merging decls or emitting diagnostics as appropriate. 2273/// 2274/// In C++, New and Old must be declarations that are not 2275/// overloaded. Use IsOverload to determine whether New and Old are 2276/// overloaded, and to select the Old declaration that New should be 2277/// merged with. 2278/// 2279/// Returns true if there was an error, false otherwise. 2280bool Sema::MergeFunctionDecl(FunctionDecl *New, Decl *OldD, Scope *S, 2281 bool MergeTypeWithOld) { 2282 // Verify the old decl was also a function. 2283 FunctionDecl *Old = 0; 2284 if (FunctionTemplateDecl *OldFunctionTemplate 2285 = dyn_cast<FunctionTemplateDecl>(OldD)) 2286 Old = OldFunctionTemplate->getTemplatedDecl(); 2287 else 2288 Old = dyn_cast<FunctionDecl>(OldD); 2289 if (!Old) { 2290 if (UsingShadowDecl *Shadow = dyn_cast<UsingShadowDecl>(OldD)) { 2291 if (New->getFriendObjectKind()) { 2292 Diag(New->getLocation(), diag::err_using_decl_friend); 2293 Diag(Shadow->getTargetDecl()->getLocation(), 2294 diag::note_using_decl_target); 2295 Diag(Shadow->getUsingDecl()->getLocation(), 2296 diag::note_using_decl) << 0; 2297 return true; 2298 } 2299 2300 Diag(New->getLocation(), diag::err_using_decl_conflict_reverse); 2301 Diag(Shadow->getTargetDecl()->getLocation(), 2302 diag::note_using_decl_target); 2303 Diag(Shadow->getUsingDecl()->getLocation(), 2304 diag::note_using_decl) << 0; 2305 return true; 2306 } 2307 2308 Diag(New->getLocation(), diag::err_redefinition_different_kind) 2309 << New->getDeclName(); 2310 Diag(OldD->getLocation(), diag::note_previous_definition); 2311 return true; 2312 } 2313 2314 // If the old declaration is invalid, just give up here. 2315 if (Old->isInvalidDecl()) 2316 return true; 2317 2318 // Determine whether the previous declaration was a definition, 2319 // implicit declaration, or a declaration. 2320 diag::kind PrevDiag; 2321 if (Old->isThisDeclarationADefinition()) 2322 PrevDiag = diag::note_previous_definition; 2323 else if (Old->isImplicit()) 2324 PrevDiag = diag::note_previous_implicit_declaration; 2325 else 2326 PrevDiag = diag::note_previous_declaration; 2327 2328 QualType OldQType = Context.getCanonicalType(Old->getType()); 2329 QualType NewQType = Context.getCanonicalType(New->getType()); 2330 2331 // Don't complain about this if we're in GNU89 mode and the old function 2332 // is an extern inline function. 2333 // Don't complain about specializations. They are not supposed to have 2334 // storage classes. 2335 if (!isa<CXXMethodDecl>(New) && !isa<CXXMethodDecl>(Old) && 2336 New->getStorageClass() == SC_Static && 2337 Old->hasExternalFormalLinkage() && 2338 !New->getTemplateSpecializationInfo() && 2339 !canRedefineFunction(Old, getLangOpts())) { 2340 if (getLangOpts().MicrosoftExt) { 2341 Diag(New->getLocation(), diag::warn_static_non_static) << New; 2342 Diag(Old->getLocation(), PrevDiag); 2343 } else { 2344 Diag(New->getLocation(), diag::err_static_non_static) << New; 2345 Diag(Old->getLocation(), PrevDiag); 2346 return true; 2347 } 2348 } 2349 2350 // If a function is first declared with a calling convention, but is 2351 // later declared or defined without one, the second decl assumes the 2352 // calling convention of the first. 2353 // 2354 // It's OK if a function is first declared without a calling convention, 2355 // but is later declared or defined with the default calling convention. 2356 // 2357 // For the new decl, we have to look at the NON-canonical type to tell the 2358 // difference between a function that really doesn't have a calling 2359 // convention and one that is declared cdecl. That's because in 2360 // canonicalization (see ASTContext.cpp), cdecl is canonicalized away 2361 // because it is the default calling convention. 2362 // 2363 // Note also that we DO NOT return at this point, because we still have 2364 // other tests to run. 2365 const FunctionType *OldType = cast<FunctionType>(OldQType); 2366 const FunctionType *NewType = New->getType()->getAs<FunctionType>(); 2367 FunctionType::ExtInfo OldTypeInfo = OldType->getExtInfo(); 2368 FunctionType::ExtInfo NewTypeInfo = NewType->getExtInfo(); 2369 bool RequiresAdjustment = false; 2370 if (OldTypeInfo.getCC() == NewTypeInfo.getCC()) { 2371 // Fast path: nothing to do. 2372 2373 // Inherit the CC from the previous declaration if it was specified 2374 // there but not here. 2375 } else if (NewTypeInfo.getCC() == CC_Default) { 2376 NewTypeInfo = NewTypeInfo.withCallingConv(OldTypeInfo.getCC()); 2377 RequiresAdjustment = true; 2378 2379 // Don't complain about mismatches when the default CC is 2380 // effectively the same as the explict one. Only Old decl contains correct 2381 // information about storage class of CXXMethod. 2382 } else if (OldTypeInfo.getCC() == CC_Default && 2383 isABIDefaultCC(*this, NewTypeInfo.getCC(), Old)) { 2384 NewTypeInfo = NewTypeInfo.withCallingConv(OldTypeInfo.getCC()); 2385 RequiresAdjustment = true; 2386 2387 } else if (!Context.isSameCallConv(OldTypeInfo.getCC(), 2388 NewTypeInfo.getCC())) { 2389 // Calling conventions really aren't compatible, so complain. 2390 Diag(New->getLocation(), diag::err_cconv_change) 2391 << FunctionType::getNameForCallConv(NewTypeInfo.getCC()) 2392 << (OldTypeInfo.getCC() == CC_Default) 2393 << (OldTypeInfo.getCC() == CC_Default ? "" : 2394 FunctionType::getNameForCallConv(OldTypeInfo.getCC())); 2395 Diag(Old->getLocation(), diag::note_previous_declaration); 2396 return true; 2397 } 2398 2399 // FIXME: diagnose the other way around? 2400 if (OldTypeInfo.getNoReturn() && !NewTypeInfo.getNoReturn()) { 2401 NewTypeInfo = NewTypeInfo.withNoReturn(true); 2402 RequiresAdjustment = true; 2403 } 2404 2405 // Merge regparm attribute. 2406 if (OldTypeInfo.getHasRegParm() != NewTypeInfo.getHasRegParm() || 2407 OldTypeInfo.getRegParm() != NewTypeInfo.getRegParm()) { 2408 if (NewTypeInfo.getHasRegParm()) { 2409 Diag(New->getLocation(), diag::err_regparm_mismatch) 2410 << NewType->getRegParmType() 2411 << OldType->getRegParmType(); 2412 Diag(Old->getLocation(), diag::note_previous_declaration); 2413 return true; 2414 } 2415 2416 NewTypeInfo = NewTypeInfo.withRegParm(OldTypeInfo.getRegParm()); 2417 RequiresAdjustment = true; 2418 } 2419 2420 // Merge ns_returns_retained attribute. 2421 if (OldTypeInfo.getProducesResult() != NewTypeInfo.getProducesResult()) { 2422 if (NewTypeInfo.getProducesResult()) { 2423 Diag(New->getLocation(), diag::err_returns_retained_mismatch); 2424 Diag(Old->getLocation(), diag::note_previous_declaration); 2425 return true; 2426 } 2427 2428 NewTypeInfo = NewTypeInfo.withProducesResult(true); 2429 RequiresAdjustment = true; 2430 } 2431 2432 if (RequiresAdjustment) { 2433 NewType = Context.adjustFunctionType(NewType, NewTypeInfo); 2434 New->setType(QualType(NewType, 0)); 2435 NewQType = Context.getCanonicalType(New->getType()); 2436 } 2437 2438 // If this redeclaration makes the function inline, we may need to add it to 2439 // UndefinedButUsed. 2440 if (!Old->isInlined() && New->isInlined() && 2441 !New->hasAttr<GNUInlineAttr>() && 2442 (getLangOpts().CPlusPlus || !getLangOpts().GNUInline) && 2443 Old->isUsed(false) && 2444 !Old->isDefined() && !New->isThisDeclarationADefinition()) 2445 UndefinedButUsed.insert(std::make_pair(Old->getCanonicalDecl(), 2446 SourceLocation())); 2447 2448 // If this redeclaration makes it newly gnu_inline, we don't want to warn 2449 // about it. 2450 if (New->hasAttr<GNUInlineAttr>() && 2451 Old->isInlined() && !Old->hasAttr<GNUInlineAttr>()) { 2452 UndefinedButUsed.erase(Old->getCanonicalDecl()); 2453 } 2454 2455 if (getLangOpts().CPlusPlus) { 2456 // (C++98 13.1p2): 2457 // Certain function declarations cannot be overloaded: 2458 // -- Function declarations that differ only in the return type 2459 // cannot be overloaded. 2460 2461 // Go back to the type source info to compare the declared return types, 2462 // per C++1y [dcl.type.auto]p13: 2463 // Redeclarations or specializations of a function or function template 2464 // with a declared return type that uses a placeholder type shall also 2465 // use that placeholder, not a deduced type. 2466 QualType OldDeclaredReturnType = (Old->getTypeSourceInfo() 2467 ? Old->getTypeSourceInfo()->getType()->castAs<FunctionType>() 2468 : OldType)->getResultType(); 2469 QualType NewDeclaredReturnType = (New->getTypeSourceInfo() 2470 ? New->getTypeSourceInfo()->getType()->castAs<FunctionType>() 2471 : NewType)->getResultType(); 2472 QualType ResQT; 2473 if (!Context.hasSameType(OldDeclaredReturnType, NewDeclaredReturnType)) { 2474 if (NewDeclaredReturnType->isObjCObjectPointerType() && 2475 OldDeclaredReturnType->isObjCObjectPointerType()) 2476 ResQT = Context.mergeObjCGCQualifiers(NewQType, OldQType); 2477 if (ResQT.isNull()) { 2478 if (New->isCXXClassMember() && New->isOutOfLine()) 2479 Diag(New->getLocation(), 2480 diag::err_member_def_does_not_match_ret_type) << New; 2481 else 2482 Diag(New->getLocation(), diag::err_ovl_diff_return_type); 2483 Diag(Old->getLocation(), PrevDiag) << Old << Old->getType(); 2484 return true; 2485 } 2486 else 2487 NewQType = ResQT; 2488 } 2489 2490 QualType OldReturnType = OldType->getResultType(); 2491 QualType NewReturnType = cast<FunctionType>(NewQType)->getResultType(); 2492 if (OldReturnType != NewReturnType) { 2493 // If this function has a deduced return type and has already been 2494 // defined, copy the deduced value from the old declaration. 2495 AutoType *OldAT = Old->getResultType()->getContainedAutoType(); 2496 if (OldAT && OldAT->isDeduced()) { 2497 New->setType( 2498 SubstAutoType(New->getType(), 2499 OldAT->isDependentType() ? Context.DependentTy 2500 : OldAT->getDeducedType())); 2501 NewQType = Context.getCanonicalType( 2502 SubstAutoType(NewQType, 2503 OldAT->isDependentType() ? Context.DependentTy 2504 : OldAT->getDeducedType())); 2505 } 2506 } 2507 2508 const CXXMethodDecl *OldMethod = dyn_cast<CXXMethodDecl>(Old); 2509 CXXMethodDecl *NewMethod = dyn_cast<CXXMethodDecl>(New); 2510 if (OldMethod && NewMethod) { 2511 // Preserve triviality. 2512 NewMethod->setTrivial(OldMethod->isTrivial()); 2513 2514 // MSVC allows explicit template specialization at class scope: 2515 // 2 CXMethodDecls referring to the same function will be injected. 2516 // We don't want a redeclartion error. 2517 bool IsClassScopeExplicitSpecialization = 2518 OldMethod->isFunctionTemplateSpecialization() && 2519 NewMethod->isFunctionTemplateSpecialization(); 2520 bool isFriend = NewMethod->getFriendObjectKind(); 2521 2522 if (!isFriend && NewMethod->getLexicalDeclContext()->isRecord() && 2523 !IsClassScopeExplicitSpecialization) { 2524 // -- Member function declarations with the same name and the 2525 // same parameter types cannot be overloaded if any of them 2526 // is a static member function declaration. 2527 if (OldMethod->isStatic() != NewMethod->isStatic()) { 2528 Diag(New->getLocation(), diag::err_ovl_static_nonstatic_member); 2529 Diag(Old->getLocation(), PrevDiag) << Old << Old->getType(); 2530 return true; 2531 } 2532 2533 // C++ [class.mem]p1: 2534 // [...] A member shall not be declared twice in the 2535 // member-specification, except that a nested class or member 2536 // class template can be declared and then later defined. 2537 if (ActiveTemplateInstantiations.empty()) { 2538 unsigned NewDiag; 2539 if (isa<CXXConstructorDecl>(OldMethod)) 2540 NewDiag = diag::err_constructor_redeclared; 2541 else if (isa<CXXDestructorDecl>(NewMethod)) 2542 NewDiag = diag::err_destructor_redeclared; 2543 else if (isa<CXXConversionDecl>(NewMethod)) 2544 NewDiag = diag::err_conv_function_redeclared; 2545 else 2546 NewDiag = diag::err_member_redeclared; 2547 2548 Diag(New->getLocation(), NewDiag); 2549 } else { 2550 Diag(New->getLocation(), diag::err_member_redeclared_in_instantiation) 2551 << New << New->getType(); 2552 } 2553 Diag(Old->getLocation(), PrevDiag) << Old << Old->getType(); 2554 2555 // Complain if this is an explicit declaration of a special 2556 // member that was initially declared implicitly. 2557 // 2558 // As an exception, it's okay to befriend such methods in order 2559 // to permit the implicit constructor/destructor/operator calls. 2560 } else if (OldMethod->isImplicit()) { 2561 if (isFriend) { 2562 NewMethod->setImplicit(); 2563 } else { 2564 Diag(NewMethod->getLocation(), 2565 diag::err_definition_of_implicitly_declared_member) 2566 << New << getSpecialMember(OldMethod); 2567 return true; 2568 } 2569 } else if (OldMethod->isExplicitlyDefaulted() && !isFriend) { 2570 Diag(NewMethod->getLocation(), 2571 diag::err_definition_of_explicitly_defaulted_member) 2572 << getSpecialMember(OldMethod); 2573 return true; 2574 } 2575 } 2576 2577 // C++11 [dcl.attr.noreturn]p1: 2578 // The first declaration of a function shall specify the noreturn 2579 // attribute if any declaration of that function specifies the noreturn 2580 // attribute. 2581 if (New->hasAttr<CXX11NoReturnAttr>() && 2582 !Old->hasAttr<CXX11NoReturnAttr>()) { 2583 Diag(New->getAttr<CXX11NoReturnAttr>()->getLocation(), 2584 diag::err_noreturn_missing_on_first_decl); 2585 Diag(Old->getFirstDeclaration()->getLocation(), 2586 diag::note_noreturn_missing_first_decl); 2587 } 2588 2589 // C++11 [dcl.attr.depend]p2: 2590 // The first declaration of a function shall specify the 2591 // carries_dependency attribute for its declarator-id if any declaration 2592 // of the function specifies the carries_dependency attribute. 2593 if (New->hasAttr<CarriesDependencyAttr>() && 2594 !Old->hasAttr<CarriesDependencyAttr>()) { 2595 Diag(New->getAttr<CarriesDependencyAttr>()->getLocation(), 2596 diag::err_carries_dependency_missing_on_first_decl) << 0/*Function*/; 2597 Diag(Old->getFirstDeclaration()->getLocation(), 2598 diag::note_carries_dependency_missing_first_decl) << 0/*Function*/; 2599 } 2600 2601 // (C++98 8.3.5p3): 2602 // All declarations for a function shall agree exactly in both the 2603 // return type and the parameter-type-list. 2604 // We also want to respect all the extended bits except noreturn. 2605 2606 // noreturn should now match unless the old type info didn't have it. 2607 QualType OldQTypeForComparison = OldQType; 2608 if (!OldTypeInfo.getNoReturn() && NewTypeInfo.getNoReturn()) { 2609 assert(OldQType == QualType(OldType, 0)); 2610 const FunctionType *OldTypeForComparison 2611 = Context.adjustFunctionType(OldType, OldTypeInfo.withNoReturn(true)); 2612 OldQTypeForComparison = QualType(OldTypeForComparison, 0); 2613 assert(OldQTypeForComparison.isCanonical()); 2614 } 2615 2616 if (haveIncompatibleLanguageLinkages(Old, New)) { 2617 Diag(New->getLocation(), diag::err_different_language_linkage) << New; 2618 Diag(Old->getLocation(), PrevDiag); 2619 return true; 2620 } 2621 2622 if (OldQTypeForComparison == NewQType) 2623 return MergeCompatibleFunctionDecls(New, Old, S, MergeTypeWithOld); 2624 2625 // Fall through for conflicting redeclarations and redefinitions. 2626 } 2627 2628 // C: Function types need to be compatible, not identical. This handles 2629 // duplicate function decls like "void f(int); void f(enum X);" properly. 2630 if (!getLangOpts().CPlusPlus && 2631 Context.typesAreCompatible(OldQType, NewQType)) { 2632 const FunctionType *OldFuncType = OldQType->getAs<FunctionType>(); 2633 const FunctionType *NewFuncType = NewQType->getAs<FunctionType>(); 2634 const FunctionProtoType *OldProto = 0; 2635 if (MergeTypeWithOld && isa<FunctionNoProtoType>(NewFuncType) && 2636 (OldProto = dyn_cast<FunctionProtoType>(OldFuncType))) { 2637 // The old declaration provided a function prototype, but the 2638 // new declaration does not. Merge in the prototype. 2639 assert(!OldProto->hasExceptionSpec() && "Exception spec in C"); 2640 SmallVector<QualType, 16> ParamTypes(OldProto->arg_type_begin(), 2641 OldProto->arg_type_end()); 2642 NewQType = Context.getFunctionType(NewFuncType->getResultType(), 2643 ParamTypes, 2644 OldProto->getExtProtoInfo()); 2645 New->setType(NewQType); 2646 New->setHasInheritedPrototype(); 2647 2648 // Synthesize a parameter for each argument type. 2649 SmallVector<ParmVarDecl*, 16> Params; 2650 for (FunctionProtoType::arg_type_iterator 2651 ParamType = OldProto->arg_type_begin(), 2652 ParamEnd = OldProto->arg_type_end(); 2653 ParamType != ParamEnd; ++ParamType) { 2654 ParmVarDecl *Param = ParmVarDecl::Create(Context, New, 2655 SourceLocation(), 2656 SourceLocation(), 0, 2657 *ParamType, /*TInfo=*/0, 2658 SC_None, 2659 0); 2660 Param->setScopeInfo(0, Params.size()); 2661 Param->setImplicit(); 2662 Params.push_back(Param); 2663 } 2664 2665 New->setParams(Params); 2666 } 2667 2668 return MergeCompatibleFunctionDecls(New, Old, S, MergeTypeWithOld); 2669 } 2670 2671 // GNU C permits a K&R definition to follow a prototype declaration 2672 // if the declared types of the parameters in the K&R definition 2673 // match the types in the prototype declaration, even when the 2674 // promoted types of the parameters from the K&R definition differ 2675 // from the types in the prototype. GCC then keeps the types from 2676 // the prototype. 2677 // 2678 // If a variadic prototype is followed by a non-variadic K&R definition, 2679 // the K&R definition becomes variadic. This is sort of an edge case, but 2680 // it's legal per the standard depending on how you read C99 6.7.5.3p15 and 2681 // C99 6.9.1p8. 2682 if (!getLangOpts().CPlusPlus && 2683 Old->hasPrototype() && !New->hasPrototype() && 2684 New->getType()->getAs<FunctionProtoType>() && 2685 Old->getNumParams() == New->getNumParams()) { 2686 SmallVector<QualType, 16> ArgTypes; 2687 SmallVector<GNUCompatibleParamWarning, 16> Warnings; 2688 const FunctionProtoType *OldProto 2689 = Old->getType()->getAs<FunctionProtoType>(); 2690 const FunctionProtoType *NewProto 2691 = New->getType()->getAs<FunctionProtoType>(); 2692 2693 // Determine whether this is the GNU C extension. 2694 QualType MergedReturn = Context.mergeTypes(OldProto->getResultType(), 2695 NewProto->getResultType()); 2696 bool LooseCompatible = !MergedReturn.isNull(); 2697 for (unsigned Idx = 0, End = Old->getNumParams(); 2698 LooseCompatible && Idx != End; ++Idx) { 2699 ParmVarDecl *OldParm = Old->getParamDecl(Idx); 2700 ParmVarDecl *NewParm = New->getParamDecl(Idx); 2701 if (Context.typesAreCompatible(OldParm->getType(), 2702 NewProto->getArgType(Idx))) { 2703 ArgTypes.push_back(NewParm->getType()); 2704 } else if (Context.typesAreCompatible(OldParm->getType(), 2705 NewParm->getType(), 2706 /*CompareUnqualified=*/true)) { 2707 GNUCompatibleParamWarning Warn 2708 = { OldParm, NewParm, NewProto->getArgType(Idx) }; 2709 Warnings.push_back(Warn); 2710 ArgTypes.push_back(NewParm->getType()); 2711 } else 2712 LooseCompatible = false; 2713 } 2714 2715 if (LooseCompatible) { 2716 for (unsigned Warn = 0; Warn < Warnings.size(); ++Warn) { 2717 Diag(Warnings[Warn].NewParm->getLocation(), 2718 diag::ext_param_promoted_not_compatible_with_prototype) 2719 << Warnings[Warn].PromotedType 2720 << Warnings[Warn].OldParm->getType(); 2721 if (Warnings[Warn].OldParm->getLocation().isValid()) 2722 Diag(Warnings[Warn].OldParm->getLocation(), 2723 diag::note_previous_declaration); 2724 } 2725 2726 if (MergeTypeWithOld) 2727 New->setType(Context.getFunctionType(MergedReturn, ArgTypes, 2728 OldProto->getExtProtoInfo())); 2729 return MergeCompatibleFunctionDecls(New, Old, S, MergeTypeWithOld); 2730 } 2731 2732 // Fall through to diagnose conflicting types. 2733 } 2734 2735 // A function that has already been declared has been redeclared or 2736 // defined with a different type; show an appropriate diagnostic. 2737 2738 // If the previous declaration was an implicitly-generated builtin 2739 // declaration, then at the very least we should use a specialized note. 2740 unsigned BuiltinID; 2741 if (Old->isImplicit() && (BuiltinID = Old->getBuiltinID())) { 2742 // If it's actually a library-defined builtin function like 'malloc' 2743 // or 'printf', just warn about the incompatible redeclaration. 2744 if (Context.BuiltinInfo.isPredefinedLibFunction(BuiltinID)) { 2745 Diag(New->getLocation(), diag::warn_redecl_library_builtin) << New; 2746 Diag(Old->getLocation(), diag::note_previous_builtin_declaration) 2747 << Old << Old->getType(); 2748 2749 // If this is a global redeclaration, just forget hereafter 2750 // about the "builtin-ness" of the function. 2751 // 2752 // Doing this for local extern declarations is problematic. If 2753 // the builtin declaration remains visible, a second invalid 2754 // local declaration will produce a hard error; if it doesn't 2755 // remain visible, a single bogus local redeclaration (which is 2756 // actually only a warning) could break all the downstream code. 2757 if (!New->getDeclContext()->isFunctionOrMethod()) 2758 New->getIdentifier()->setBuiltinID(Builtin::NotBuiltin); 2759 2760 return false; 2761 } 2762 2763 PrevDiag = diag::note_previous_builtin_declaration; 2764 } 2765 2766 Diag(New->getLocation(), diag::err_conflicting_types) << New->getDeclName(); 2767 Diag(Old->getLocation(), PrevDiag) << Old << Old->getType(); 2768 return true; 2769} 2770 2771/// \brief Completes the merge of two function declarations that are 2772/// known to be compatible. 2773/// 2774/// This routine handles the merging of attributes and other 2775/// properties of function declarations form the old declaration to 2776/// the new declaration, once we know that New is in fact a 2777/// redeclaration of Old. 2778/// 2779/// \returns false 2780bool Sema::MergeCompatibleFunctionDecls(FunctionDecl *New, FunctionDecl *Old, 2781 Scope *S, bool MergeTypeWithOld) { 2782 // Merge the attributes 2783 mergeDeclAttributes(New, Old); 2784 2785 // Merge "pure" flag. 2786 if (Old->isPure()) 2787 New->setPure(); 2788 2789 // Merge "used" flag. 2790 if (Old->isUsed(false)) 2791 New->setUsed(); 2792 2793 // Merge attributes from the parameters. These can mismatch with K&R 2794 // declarations. 2795 if (New->getNumParams() == Old->getNumParams()) 2796 for (unsigned i = 0, e = New->getNumParams(); i != e; ++i) 2797 mergeParamDeclAttributes(New->getParamDecl(i), Old->getParamDecl(i), 2798 *this); 2799 2800 if (getLangOpts().CPlusPlus) 2801 return MergeCXXFunctionDecl(New, Old, S); 2802 2803 // Merge the function types so the we get the composite types for the return 2804 // and argument types. Per C11 6.2.7/4, only update the type if the old decl 2805 // was visible. 2806 QualType Merged = Context.mergeTypes(Old->getType(), New->getType()); 2807 if (!Merged.isNull() && MergeTypeWithOld) 2808 New->setType(Merged); 2809 2810 return false; 2811} 2812 2813 2814void Sema::mergeObjCMethodDecls(ObjCMethodDecl *newMethod, 2815 ObjCMethodDecl *oldMethod) { 2816 2817 // Merge the attributes, including deprecated/unavailable 2818 AvailabilityMergeKind MergeKind = 2819 isa<ObjCImplDecl>(newMethod->getDeclContext()) ? AMK_Redeclaration 2820 : AMK_Override; 2821 mergeDeclAttributes(newMethod, oldMethod, MergeKind); 2822 2823 // Merge attributes from the parameters. 2824 ObjCMethodDecl::param_const_iterator oi = oldMethod->param_begin(), 2825 oe = oldMethod->param_end(); 2826 for (ObjCMethodDecl::param_iterator 2827 ni = newMethod->param_begin(), ne = newMethod->param_end(); 2828 ni != ne && oi != oe; ++ni, ++oi) 2829 mergeParamDeclAttributes(*ni, *oi, *this); 2830 2831 CheckObjCMethodOverride(newMethod, oldMethod); 2832} 2833 2834/// MergeVarDeclTypes - We parsed a variable 'New' which has the same name and 2835/// scope as a previous declaration 'Old'. Figure out how to merge their types, 2836/// emitting diagnostics as appropriate. 2837/// 2838/// Declarations using the auto type specifier (C++ [decl.spec.auto]) call back 2839/// to here in AddInitializerToDecl. We can't check them before the initializer 2840/// is attached. 2841void Sema::MergeVarDeclTypes(VarDecl *New, VarDecl *Old, 2842 bool MergeTypeWithOld) { 2843 if (New->isInvalidDecl() || Old->isInvalidDecl()) 2844 return; 2845 2846 QualType MergedT; 2847 if (getLangOpts().CPlusPlus) { 2848 if (New->getType()->isUndeducedType()) { 2849 // We don't know what the new type is until the initializer is attached. 2850 return; 2851 } else if (Context.hasSameType(New->getType(), Old->getType())) { 2852 // These could still be something that needs exception specs checked. 2853 return MergeVarDeclExceptionSpecs(New, Old); 2854 } 2855 // C++ [basic.link]p10: 2856 // [...] the types specified by all declarations referring to a given 2857 // object or function shall be identical, except that declarations for an 2858 // array object can specify array types that differ by the presence or 2859 // absence of a major array bound (8.3.4). 2860 else if (Old->getType()->isIncompleteArrayType() && 2861 New->getType()->isArrayType()) { 2862 const ArrayType *OldArray = Context.getAsArrayType(Old->getType()); 2863 const ArrayType *NewArray = Context.getAsArrayType(New->getType()); 2864 if (Context.hasSameType(OldArray->getElementType(), 2865 NewArray->getElementType())) 2866 MergedT = New->getType(); 2867 } else if (Old->getType()->isArrayType() && 2868 New->getType()->isIncompleteArrayType()) { 2869 const ArrayType *OldArray = Context.getAsArrayType(Old->getType()); 2870 const ArrayType *NewArray = Context.getAsArrayType(New->getType()); 2871 if (Context.hasSameType(OldArray->getElementType(), 2872 NewArray->getElementType())) 2873 MergedT = Old->getType(); 2874 } else if (New->getType()->isObjCObjectPointerType() 2875 && Old->getType()->isObjCObjectPointerType()) { 2876 MergedT = Context.mergeObjCGCQualifiers(New->getType(), 2877 Old->getType()); 2878 } 2879 } else { 2880 MergedT = Context.mergeTypes(New->getType(), Old->getType()); 2881 } 2882 if (MergedT.isNull()) { 2883 // It's OK if we couldn't merge types if either type is dependent, for a 2884 // block-scope variable. In other cases (static data members of class 2885 // templates, variable templates, ...), we require the types to be 2886 // equivalent. 2887 // FIXME: The C++ standard doesn't say anything about this. 2888 if ((New->getType()->isDependentType() || 2889 Old->getType()->isDependentType()) && New->isLocalVarDecl()) { 2890 // If the old type was dependent, we can't merge with it, so the new type 2891 // becomes dependent for now. We'll reproduce the original type when we 2892 // instantiate the TypeSourceInfo for the variable. 2893 if (!New->getType()->isDependentType() && MergeTypeWithOld) 2894 New->setType(Context.DependentTy); 2895 return; 2896 } 2897 2898 // FIXME: Even if this merging succeeds, some other non-visible declaration 2899 // of this variable might have an incompatible type. For instance: 2900 // 2901 // extern int arr[]; 2902 // void f() { extern int arr[2]; } 2903 // void g() { extern int arr[3]; } 2904 // 2905 // Neither C nor C++ requires a diagnostic for this, but we should still try 2906 // to diagnose it. 2907 Diag(New->getLocation(), diag::err_redefinition_different_type) 2908 << New->getDeclName() << New->getType() << Old->getType(); 2909 Diag(Old->getLocation(), diag::note_previous_definition); 2910 return New->setInvalidDecl(); 2911 } 2912 2913 // Don't actually update the type on the new declaration if the old 2914 // declaration was a extern declaration in a different scope. 2915 if (MergeTypeWithOld) 2916 New->setType(MergedT); 2917} 2918 2919/// MergeVarDecl - We just parsed a variable 'New' which has the same name 2920/// and scope as a previous declaration 'Old'. Figure out how to resolve this 2921/// situation, merging decls or emitting diagnostics as appropriate. 2922/// 2923/// Tentative definition rules (C99 6.9.2p2) are checked by 2924/// FinalizeDeclaratorGroup. Unfortunately, we can't analyze tentative 2925/// definitions here, since the initializer hasn't been attached. 2926/// 2927void Sema::MergeVarDecl(VarDecl *New, LookupResult &Previous, 2928 bool IsVariableTemplate, bool MergeTypeWithPrevious) { 2929 // If the new decl is already invalid, don't do any other checking. 2930 if (New->isInvalidDecl()) 2931 return; 2932 2933 // Verify the old decl was also a variable or variable template. 2934 VarDecl *Old = 0; 2935 if (Previous.isSingleResult() && 2936 (Old = dyn_cast<VarDecl>(Previous.getFoundDecl()))) { 2937 if (IsVariableTemplate) 2938 Old = Old->getDescribedVarTemplate() ? Old : 0; 2939 else 2940 Old = Old->getDescribedVarTemplate() ? 0 : Old; 2941 } 2942 if (!Old) { 2943 Diag(New->getLocation(), diag::err_redefinition_different_kind) 2944 << New->getDeclName(); 2945 Diag(Previous.getRepresentativeDecl()->getLocation(), 2946 diag::note_previous_definition); 2947 return New->setInvalidDecl(); 2948 } 2949 2950 if (!shouldLinkPossiblyHiddenDecl(Old, New)) 2951 return; 2952 2953 // C++ [class.mem]p1: 2954 // A member shall not be declared twice in the member-specification [...] 2955 // 2956 // Here, we need only consider static data members. 2957 if (Old->isStaticDataMember() && !New->isOutOfLine()) { 2958 Diag(New->getLocation(), diag::err_duplicate_member) 2959 << New->getIdentifier(); 2960 Diag(Old->getLocation(), diag::note_previous_declaration); 2961 New->setInvalidDecl(); 2962 } 2963 2964 mergeDeclAttributes(New, Old); 2965 // Warn if an already-declared variable is made a weak_import in a subsequent 2966 // declaration 2967 if (New->getAttr<WeakImportAttr>() && 2968 Old->getStorageClass() == SC_None && 2969 !Old->getAttr<WeakImportAttr>()) { 2970 Diag(New->getLocation(), diag::warn_weak_import) << New->getDeclName(); 2971 Diag(Old->getLocation(), diag::note_previous_definition); 2972 // Remove weak_import attribute on new declaration. 2973 New->dropAttr<WeakImportAttr>(); 2974 } 2975 2976 // Merge the types. 2977 MergeVarDeclTypes(New, Old, MergeTypeWithPrevious); 2978 if (New->isInvalidDecl()) 2979 return; 2980 2981 // [dcl.stc]p8: Check if we have a non-static decl followed by a static. 2982 if (New->getStorageClass() == SC_Static && 2983 !New->isStaticDataMember() && 2984 Old->hasExternalFormalLinkage()) { 2985 Diag(New->getLocation(), diag::err_static_non_static) << New->getDeclName(); 2986 Diag(Old->getLocation(), diag::note_previous_definition); 2987 return New->setInvalidDecl(); 2988 } 2989 // C99 6.2.2p4: 2990 // For an identifier declared with the storage-class specifier 2991 // extern in a scope in which a prior declaration of that 2992 // identifier is visible,23) if the prior declaration specifies 2993 // internal or external linkage, the linkage of the identifier at 2994 // the later declaration is the same as the linkage specified at 2995 // the prior declaration. If no prior declaration is visible, or 2996 // if the prior declaration specifies no linkage, then the 2997 // identifier has external linkage. 2998 if (New->hasExternalStorage() && Old->hasLinkage()) 2999 /* Okay */; 3000 else if (New->getCanonicalDecl()->getStorageClass() != SC_Static && 3001 !New->isStaticDataMember() && 3002 Old->getCanonicalDecl()->getStorageClass() == SC_Static) { 3003 Diag(New->getLocation(), diag::err_non_static_static) << New->getDeclName(); 3004 Diag(Old->getLocation(), diag::note_previous_definition); 3005 return New->setInvalidDecl(); 3006 } 3007 3008 // Check if extern is followed by non-extern and vice-versa. 3009 if (New->hasExternalStorage() && 3010 !Old->hasLinkage() && Old->isLocalVarDecl()) { 3011 Diag(New->getLocation(), diag::err_extern_non_extern) << New->getDeclName(); 3012 Diag(Old->getLocation(), diag::note_previous_definition); 3013 return New->setInvalidDecl(); 3014 } 3015 if (Old->hasLinkage() && New->isLocalVarDecl() && 3016 !New->hasExternalStorage()) { 3017 Diag(New->getLocation(), diag::err_non_extern_extern) << New->getDeclName(); 3018 Diag(Old->getLocation(), diag::note_previous_definition); 3019 return New->setInvalidDecl(); 3020 } 3021 3022 // Variables with external linkage are analyzed in FinalizeDeclaratorGroup. 3023 3024 // FIXME: The test for external storage here seems wrong? We still 3025 // need to check for mismatches. 3026 if (!New->hasExternalStorage() && !New->isFileVarDecl() && 3027 // Don't complain about out-of-line definitions of static members. 3028 !(Old->getLexicalDeclContext()->isRecord() && 3029 !New->getLexicalDeclContext()->isRecord())) { 3030 Diag(New->getLocation(), diag::err_redefinition) << New->getDeclName(); 3031 Diag(Old->getLocation(), diag::note_previous_definition); 3032 return New->setInvalidDecl(); 3033 } 3034 3035 if (New->getTLSKind() != Old->getTLSKind()) { 3036 if (!Old->getTLSKind()) { 3037 Diag(New->getLocation(), diag::err_thread_non_thread) << New->getDeclName(); 3038 Diag(Old->getLocation(), diag::note_previous_declaration); 3039 } else if (!New->getTLSKind()) { 3040 Diag(New->getLocation(), diag::err_non_thread_thread) << New->getDeclName(); 3041 Diag(Old->getLocation(), diag::note_previous_declaration); 3042 } else { 3043 // Do not allow redeclaration to change the variable between requiring 3044 // static and dynamic initialization. 3045 // FIXME: GCC allows this, but uses the TLS keyword on the first 3046 // declaration to determine the kind. Do we need to be compatible here? 3047 Diag(New->getLocation(), diag::err_thread_thread_different_kind) 3048 << New->getDeclName() << (New->getTLSKind() == VarDecl::TLS_Dynamic); 3049 Diag(Old->getLocation(), diag::note_previous_declaration); 3050 } 3051 } 3052 3053 // C++ doesn't have tentative definitions, so go right ahead and check here. 3054 const VarDecl *Def; 3055 if (getLangOpts().CPlusPlus && 3056 New->isThisDeclarationADefinition() == VarDecl::Definition && 3057 (Def = Old->getDefinition())) { 3058 Diag(New->getLocation(), diag::err_redefinition) << New; 3059 Diag(Def->getLocation(), diag::note_previous_definition); 3060 New->setInvalidDecl(); 3061 return; 3062 } 3063 3064 if (haveIncompatibleLanguageLinkages(Old, New)) { 3065 Diag(New->getLocation(), diag::err_different_language_linkage) << New; 3066 Diag(Old->getLocation(), diag::note_previous_definition); 3067 New->setInvalidDecl(); 3068 return; 3069 } 3070 3071 // Merge "used" flag. 3072 if (Old->isUsed(false)) 3073 New->setUsed(); 3074 3075 // Keep a chain of previous declarations. 3076 New->setPreviousDeclaration(Old); 3077 3078 // Inherit access appropriately. 3079 New->setAccess(Old->getAccess()); 3080} 3081 3082/// ParsedFreeStandingDeclSpec - This method is invoked when a declspec with 3083/// no declarator (e.g. "struct foo;") is parsed. 3084Decl *Sema::ParsedFreeStandingDeclSpec(Scope *S, AccessSpecifier AS, 3085 DeclSpec &DS) { 3086 return ParsedFreeStandingDeclSpec(S, AS, DS, MultiTemplateParamsArg()); 3087} 3088 3089static void HandleTagNumbering(Sema &S, const TagDecl *Tag) { 3090 if (isa<CXXRecordDecl>(Tag->getParent())) { 3091 // If this tag is the direct child of a class, number it if 3092 // it is anonymous. 3093 if (!Tag->getName().empty() || Tag->getTypedefNameForAnonDecl()) 3094 return; 3095 MangleNumberingContext &MCtx = 3096 S.Context.getManglingNumberContext(Tag->getParent()); 3097 S.Context.setManglingNumber(Tag, MCtx.getManglingNumber(Tag)); 3098 return; 3099 } 3100 3101 // If this tag isn't a direct child of a class, number it if it is local. 3102 Decl *ManglingContextDecl; 3103 if (MangleNumberingContext *MCtx = 3104 S.getCurrentMangleNumberContext(Tag->getDeclContext(), 3105 ManglingContextDecl)) { 3106 S.Context.setManglingNumber(Tag, MCtx->getManglingNumber(Tag)); 3107 } 3108} 3109 3110/// ParsedFreeStandingDeclSpec - This method is invoked when a declspec with 3111/// no declarator (e.g. "struct foo;") is parsed. It also accepts template 3112/// parameters to cope with template friend declarations. 3113Decl *Sema::ParsedFreeStandingDeclSpec(Scope *S, AccessSpecifier AS, 3114 DeclSpec &DS, 3115 MultiTemplateParamsArg TemplateParams, 3116 bool IsExplicitInstantiation) { 3117 Decl *TagD = 0; 3118 TagDecl *Tag = 0; 3119 if (DS.getTypeSpecType() == DeclSpec::TST_class || 3120 DS.getTypeSpecType() == DeclSpec::TST_struct || 3121 DS.getTypeSpecType() == DeclSpec::TST_interface || 3122 DS.getTypeSpecType() == DeclSpec::TST_union || 3123 DS.getTypeSpecType() == DeclSpec::TST_enum) { 3124 TagD = DS.getRepAsDecl(); 3125 3126 if (!TagD) // We probably had an error 3127 return 0; 3128 3129 // Note that the above type specs guarantee that the 3130 // type rep is a Decl, whereas in many of the others 3131 // it's a Type. 3132 if (isa<TagDecl>(TagD)) 3133 Tag = cast<TagDecl>(TagD); 3134 else if (ClassTemplateDecl *CTD = dyn_cast<ClassTemplateDecl>(TagD)) 3135 Tag = CTD->getTemplatedDecl(); 3136 } 3137 3138 if (Tag) { 3139 HandleTagNumbering(*this, Tag); 3140 Tag->setFreeStanding(); 3141 if (Tag->isInvalidDecl()) 3142 return Tag; 3143 } 3144 3145 if (unsigned TypeQuals = DS.getTypeQualifiers()) { 3146 // Enforce C99 6.7.3p2: "Types other than pointer types derived from object 3147 // or incomplete types shall not be restrict-qualified." 3148 if (TypeQuals & DeclSpec::TQ_restrict) 3149 Diag(DS.getRestrictSpecLoc(), 3150 diag::err_typecheck_invalid_restrict_not_pointer_noarg) 3151 << DS.getSourceRange(); 3152 } 3153 3154 if (DS.isConstexprSpecified()) { 3155 // C++0x [dcl.constexpr]p1: constexpr can only be applied to declarations 3156 // and definitions of functions and variables. 3157 if (Tag) 3158 Diag(DS.getConstexprSpecLoc(), diag::err_constexpr_tag) 3159 << (DS.getTypeSpecType() == DeclSpec::TST_class ? 0 : 3160 DS.getTypeSpecType() == DeclSpec::TST_struct ? 1 : 3161 DS.getTypeSpecType() == DeclSpec::TST_interface ? 2 : 3162 DS.getTypeSpecType() == DeclSpec::TST_union ? 3 : 4); 3163 else 3164 Diag(DS.getConstexprSpecLoc(), diag::err_constexpr_no_declarators); 3165 // Don't emit warnings after this error. 3166 return TagD; 3167 } 3168 3169 DiagnoseFunctionSpecifiers(DS); 3170 3171 if (DS.isFriendSpecified()) { 3172 // If we're dealing with a decl but not a TagDecl, assume that 3173 // whatever routines created it handled the friendship aspect. 3174 if (TagD && !Tag) 3175 return 0; 3176 return ActOnFriendTypeDecl(S, DS, TemplateParams); 3177 } 3178 3179 CXXScopeSpec &SS = DS.getTypeSpecScope(); 3180 bool IsExplicitSpecialization = 3181 !TemplateParams.empty() && TemplateParams.back()->size() == 0; 3182 if (Tag && SS.isNotEmpty() && !Tag->isCompleteDefinition() && 3183 !IsExplicitInstantiation && !IsExplicitSpecialization) { 3184 // Per C++ [dcl.type.elab]p1, a class declaration cannot have a 3185 // nested-name-specifier unless it is an explicit instantiation 3186 // or an explicit specialization. 3187 // Per C++ [dcl.enum]p1, an opaque-enum-declaration can't either. 3188 Diag(SS.getBeginLoc(), diag::err_standalone_class_nested_name_specifier) 3189 << (DS.getTypeSpecType() == DeclSpec::TST_class ? 0 : 3190 DS.getTypeSpecType() == DeclSpec::TST_struct ? 1 : 3191 DS.getTypeSpecType() == DeclSpec::TST_interface ? 2 : 3192 DS.getTypeSpecType() == DeclSpec::TST_union ? 3 : 4) 3193 << SS.getRange(); 3194 return 0; 3195 } 3196 3197 // Track whether this decl-specifier declares anything. 3198 bool DeclaresAnything = true; 3199 3200 // Handle anonymous struct definitions. 3201 if (RecordDecl *Record = dyn_cast_or_null<RecordDecl>(Tag)) { 3202 if (!Record->getDeclName() && Record->isCompleteDefinition() && 3203 DS.getStorageClassSpec() != DeclSpec::SCS_typedef) { 3204 if (getLangOpts().CPlusPlus || 3205 Record->getDeclContext()->isRecord()) 3206 return BuildAnonymousStructOrUnion(S, DS, AS, Record); 3207 3208 DeclaresAnything = false; 3209 } 3210 } 3211 3212 // Check for Microsoft C extension: anonymous struct member. 3213 if (getLangOpts().MicrosoftExt && !getLangOpts().CPlusPlus && 3214 CurContext->isRecord() && 3215 DS.getStorageClassSpec() == DeclSpec::SCS_unspecified) { 3216 // Handle 2 kinds of anonymous struct: 3217 // struct STRUCT; 3218 // and 3219 // STRUCT_TYPE; <- where STRUCT_TYPE is a typedef struct. 3220 RecordDecl *Record = dyn_cast_or_null<RecordDecl>(Tag); 3221 if ((Record && Record->getDeclName() && !Record->isCompleteDefinition()) || 3222 (DS.getTypeSpecType() == DeclSpec::TST_typename && 3223 DS.getRepAsType().get()->isStructureType())) { 3224 Diag(DS.getLocStart(), diag::ext_ms_anonymous_struct) 3225 << DS.getSourceRange(); 3226 return BuildMicrosoftCAnonymousStruct(S, DS, Record); 3227 } 3228 } 3229 3230 // Skip all the checks below if we have a type error. 3231 if (DS.getTypeSpecType() == DeclSpec::TST_error || 3232 (TagD && TagD->isInvalidDecl())) 3233 return TagD; 3234 3235 if (getLangOpts().CPlusPlus && 3236 DS.getStorageClassSpec() != DeclSpec::SCS_typedef) 3237 if (EnumDecl *Enum = dyn_cast_or_null<EnumDecl>(Tag)) 3238 if (Enum->enumerator_begin() == Enum->enumerator_end() && 3239 !Enum->getIdentifier() && !Enum->isInvalidDecl()) 3240 DeclaresAnything = false; 3241 3242 if (!DS.isMissingDeclaratorOk()) { 3243 // Customize diagnostic for a typedef missing a name. 3244 if (DS.getStorageClassSpec() == DeclSpec::SCS_typedef) 3245 Diag(DS.getLocStart(), diag::ext_typedef_without_a_name) 3246 << DS.getSourceRange(); 3247 else 3248 DeclaresAnything = false; 3249 } 3250 3251 if (DS.isModulePrivateSpecified() && 3252 Tag && Tag->getDeclContext()->isFunctionOrMethod()) 3253 Diag(DS.getModulePrivateSpecLoc(), diag::err_module_private_local_class) 3254 << Tag->getTagKind() 3255 << FixItHint::CreateRemoval(DS.getModulePrivateSpecLoc()); 3256 3257 ActOnDocumentableDecl(TagD); 3258 3259 // C 6.7/2: 3260 // A declaration [...] shall declare at least a declarator [...], a tag, 3261 // or the members of an enumeration. 3262 // C++ [dcl.dcl]p3: 3263 // [If there are no declarators], and except for the declaration of an 3264 // unnamed bit-field, the decl-specifier-seq shall introduce one or more 3265 // names into the program, or shall redeclare a name introduced by a 3266 // previous declaration. 3267 if (!DeclaresAnything) { 3268 // In C, we allow this as a (popular) extension / bug. Don't bother 3269 // producing further diagnostics for redundant qualifiers after this. 3270 Diag(DS.getLocStart(), diag::ext_no_declarators) << DS.getSourceRange(); 3271 return TagD; 3272 } 3273 3274 // C++ [dcl.stc]p1: 3275 // If a storage-class-specifier appears in a decl-specifier-seq, [...] the 3276 // init-declarator-list of the declaration shall not be empty. 3277 // C++ [dcl.fct.spec]p1: 3278 // If a cv-qualifier appears in a decl-specifier-seq, the 3279 // init-declarator-list of the declaration shall not be empty. 3280 // 3281 // Spurious qualifiers here appear to be valid in C. 3282 unsigned DiagID = diag::warn_standalone_specifier; 3283 if (getLangOpts().CPlusPlus) 3284 DiagID = diag::ext_standalone_specifier; 3285 3286 // Note that a linkage-specification sets a storage class, but 3287 // 'extern "C" struct foo;' is actually valid and not theoretically 3288 // useless. 3289 if (DeclSpec::SCS SCS = DS.getStorageClassSpec()) 3290 if (!DS.isExternInLinkageSpec() && SCS != DeclSpec::SCS_typedef) 3291 Diag(DS.getStorageClassSpecLoc(), DiagID) 3292 << DeclSpec::getSpecifierName(SCS); 3293 3294 if (DeclSpec::TSCS TSCS = DS.getThreadStorageClassSpec()) 3295 Diag(DS.getThreadStorageClassSpecLoc(), DiagID) 3296 << DeclSpec::getSpecifierName(TSCS); 3297 if (DS.getTypeQualifiers()) { 3298 if (DS.getTypeQualifiers() & DeclSpec::TQ_const) 3299 Diag(DS.getConstSpecLoc(), DiagID) << "const"; 3300 if (DS.getTypeQualifiers() & DeclSpec::TQ_volatile) 3301 Diag(DS.getConstSpecLoc(), DiagID) << "volatile"; 3302 // Restrict is covered above. 3303 if (DS.getTypeQualifiers() & DeclSpec::TQ_atomic) 3304 Diag(DS.getAtomicSpecLoc(), DiagID) << "_Atomic"; 3305 } 3306 3307 // Warn about ignored type attributes, for example: 3308 // __attribute__((aligned)) struct A; 3309 // Attributes should be placed after tag to apply to type declaration. 3310 if (!DS.getAttributes().empty()) { 3311 DeclSpec::TST TypeSpecType = DS.getTypeSpecType(); 3312 if (TypeSpecType == DeclSpec::TST_class || 3313 TypeSpecType == DeclSpec::TST_struct || 3314 TypeSpecType == DeclSpec::TST_interface || 3315 TypeSpecType == DeclSpec::TST_union || 3316 TypeSpecType == DeclSpec::TST_enum) { 3317 AttributeList* attrs = DS.getAttributes().getList(); 3318 while (attrs) { 3319 Diag(attrs->getLoc(), diag::warn_declspec_attribute_ignored) 3320 << attrs->getName() 3321 << (TypeSpecType == DeclSpec::TST_class ? 0 : 3322 TypeSpecType == DeclSpec::TST_struct ? 1 : 3323 TypeSpecType == DeclSpec::TST_union ? 2 : 3324 TypeSpecType == DeclSpec::TST_interface ? 3 : 4); 3325 attrs = attrs->getNext(); 3326 } 3327 } 3328 } 3329 3330 return TagD; 3331} 3332 3333/// We are trying to inject an anonymous member into the given scope; 3334/// check if there's an existing declaration that can't be overloaded. 3335/// 3336/// \return true if this is a forbidden redeclaration 3337static bool CheckAnonMemberRedeclaration(Sema &SemaRef, 3338 Scope *S, 3339 DeclContext *Owner, 3340 DeclarationName Name, 3341 SourceLocation NameLoc, 3342 unsigned diagnostic) { 3343 LookupResult R(SemaRef, Name, NameLoc, Sema::LookupMemberName, 3344 Sema::ForRedeclaration); 3345 if (!SemaRef.LookupName(R, S)) return false; 3346 3347 if (R.getAsSingle<TagDecl>()) 3348 return false; 3349 3350 // Pick a representative declaration. 3351 NamedDecl *PrevDecl = R.getRepresentativeDecl()->getUnderlyingDecl(); 3352 assert(PrevDecl && "Expected a non-null Decl"); 3353 3354 if (!SemaRef.isDeclInScope(PrevDecl, Owner, S)) 3355 return false; 3356 3357 SemaRef.Diag(NameLoc, diagnostic) << Name; 3358 SemaRef.Diag(PrevDecl->getLocation(), diag::note_previous_declaration); 3359 3360 return true; 3361} 3362 3363/// InjectAnonymousStructOrUnionMembers - Inject the members of the 3364/// anonymous struct or union AnonRecord into the owning context Owner 3365/// and scope S. This routine will be invoked just after we realize 3366/// that an unnamed union or struct is actually an anonymous union or 3367/// struct, e.g., 3368/// 3369/// @code 3370/// union { 3371/// int i; 3372/// float f; 3373/// }; // InjectAnonymousStructOrUnionMembers called here to inject i and 3374/// // f into the surrounding scope.x 3375/// @endcode 3376/// 3377/// This routine is recursive, injecting the names of nested anonymous 3378/// structs/unions into the owning context and scope as well. 3379static bool InjectAnonymousStructOrUnionMembers(Sema &SemaRef, Scope *S, 3380 DeclContext *Owner, 3381 RecordDecl *AnonRecord, 3382 AccessSpecifier AS, 3383 SmallVectorImpl<NamedDecl *> &Chaining, 3384 bool MSAnonStruct) { 3385 unsigned diagKind 3386 = AnonRecord->isUnion() ? diag::err_anonymous_union_member_redecl 3387 : diag::err_anonymous_struct_member_redecl; 3388 3389 bool Invalid = false; 3390 3391 // Look every FieldDecl and IndirectFieldDecl with a name. 3392 for (RecordDecl::decl_iterator D = AnonRecord->decls_begin(), 3393 DEnd = AnonRecord->decls_end(); 3394 D != DEnd; ++D) { 3395 if ((isa<FieldDecl>(*D) || isa<IndirectFieldDecl>(*D)) && 3396 cast<NamedDecl>(*D)->getDeclName()) { 3397 ValueDecl *VD = cast<ValueDecl>(*D); 3398 if (CheckAnonMemberRedeclaration(SemaRef, S, Owner, VD->getDeclName(), 3399 VD->getLocation(), diagKind)) { 3400 // C++ [class.union]p2: 3401 // The names of the members of an anonymous union shall be 3402 // distinct from the names of any other entity in the 3403 // scope in which the anonymous union is declared. 3404 Invalid = true; 3405 } else { 3406 // C++ [class.union]p2: 3407 // For the purpose of name lookup, after the anonymous union 3408 // definition, the members of the anonymous union are 3409 // considered to have been defined in the scope in which the 3410 // anonymous union is declared. 3411 unsigned OldChainingSize = Chaining.size(); 3412 if (IndirectFieldDecl *IF = dyn_cast<IndirectFieldDecl>(VD)) 3413 for (IndirectFieldDecl::chain_iterator PI = IF->chain_begin(), 3414 PE = IF->chain_end(); PI != PE; ++PI) 3415 Chaining.push_back(*PI); 3416 else 3417 Chaining.push_back(VD); 3418 3419 assert(Chaining.size() >= 2); 3420 NamedDecl **NamedChain = 3421 new (SemaRef.Context)NamedDecl*[Chaining.size()]; 3422 for (unsigned i = 0; i < Chaining.size(); i++) 3423 NamedChain[i] = Chaining[i]; 3424 3425 IndirectFieldDecl* IndirectField = 3426 IndirectFieldDecl::Create(SemaRef.Context, Owner, VD->getLocation(), 3427 VD->getIdentifier(), VD->getType(), 3428 NamedChain, Chaining.size()); 3429 3430 IndirectField->setAccess(AS); 3431 IndirectField->setImplicit(); 3432 SemaRef.PushOnScopeChains(IndirectField, S); 3433 3434 // That includes picking up the appropriate access specifier. 3435 if (AS != AS_none) IndirectField->setAccess(AS); 3436 3437 Chaining.resize(OldChainingSize); 3438 } 3439 } 3440 } 3441 3442 return Invalid; 3443} 3444 3445/// StorageClassSpecToVarDeclStorageClass - Maps a DeclSpec::SCS to 3446/// a VarDecl::StorageClass. Any error reporting is up to the caller: 3447/// illegal input values are mapped to SC_None. 3448static StorageClass 3449StorageClassSpecToVarDeclStorageClass(const DeclSpec &DS) { 3450 DeclSpec::SCS StorageClassSpec = DS.getStorageClassSpec(); 3451 assert(StorageClassSpec != DeclSpec::SCS_typedef && 3452 "Parser allowed 'typedef' as storage class VarDecl."); 3453 switch (StorageClassSpec) { 3454 case DeclSpec::SCS_unspecified: return SC_None; 3455 case DeclSpec::SCS_extern: 3456 if (DS.isExternInLinkageSpec()) 3457 return SC_None; 3458 return SC_Extern; 3459 case DeclSpec::SCS_static: return SC_Static; 3460 case DeclSpec::SCS_auto: return SC_Auto; 3461 case DeclSpec::SCS_register: return SC_Register; 3462 case DeclSpec::SCS_private_extern: return SC_PrivateExtern; 3463 // Illegal SCSs map to None: error reporting is up to the caller. 3464 case DeclSpec::SCS_mutable: // Fall through. 3465 case DeclSpec::SCS_typedef: return SC_None; 3466 } 3467 llvm_unreachable("unknown storage class specifier"); 3468} 3469 3470/// BuildAnonymousStructOrUnion - Handle the declaration of an 3471/// anonymous structure or union. Anonymous unions are a C++ feature 3472/// (C++ [class.union]) and a C11 feature; anonymous structures 3473/// are a C11 feature and GNU C++ extension. 3474Decl *Sema::BuildAnonymousStructOrUnion(Scope *S, DeclSpec &DS, 3475 AccessSpecifier AS, 3476 RecordDecl *Record) { 3477 DeclContext *Owner = Record->getDeclContext(); 3478 3479 // Diagnose whether this anonymous struct/union is an extension. 3480 if (Record->isUnion() && !getLangOpts().CPlusPlus && !getLangOpts().C11) 3481 Diag(Record->getLocation(), diag::ext_anonymous_union); 3482 else if (!Record->isUnion() && getLangOpts().CPlusPlus) 3483 Diag(Record->getLocation(), diag::ext_gnu_anonymous_struct); 3484 else if (!Record->isUnion() && !getLangOpts().C11) 3485 Diag(Record->getLocation(), diag::ext_c11_anonymous_struct); 3486 3487 // C and C++ require different kinds of checks for anonymous 3488 // structs/unions. 3489 bool Invalid = false; 3490 if (getLangOpts().CPlusPlus) { 3491 const char* PrevSpec = 0; 3492 unsigned DiagID; 3493 if (Record->isUnion()) { 3494 // C++ [class.union]p6: 3495 // Anonymous unions declared in a named namespace or in the 3496 // global namespace shall be declared static. 3497 if (DS.getStorageClassSpec() != DeclSpec::SCS_static && 3498 (isa<TranslationUnitDecl>(Owner) || 3499 (isa<NamespaceDecl>(Owner) && 3500 cast<NamespaceDecl>(Owner)->getDeclName()))) { 3501 Diag(Record->getLocation(), diag::err_anonymous_union_not_static) 3502 << FixItHint::CreateInsertion(Record->getLocation(), "static "); 3503 3504 // Recover by adding 'static'. 3505 DS.SetStorageClassSpec(*this, DeclSpec::SCS_static, SourceLocation(), 3506 PrevSpec, DiagID); 3507 } 3508 // C++ [class.union]p6: 3509 // A storage class is not allowed in a declaration of an 3510 // anonymous union in a class scope. 3511 else if (DS.getStorageClassSpec() != DeclSpec::SCS_unspecified && 3512 isa<RecordDecl>(Owner)) { 3513 Diag(DS.getStorageClassSpecLoc(), 3514 diag::err_anonymous_union_with_storage_spec) 3515 << FixItHint::CreateRemoval(DS.getStorageClassSpecLoc()); 3516 3517 // Recover by removing the storage specifier. 3518 DS.SetStorageClassSpec(*this, DeclSpec::SCS_unspecified, 3519 SourceLocation(), 3520 PrevSpec, DiagID); 3521 } 3522 } 3523 3524 // Ignore const/volatile/restrict qualifiers. 3525 if (DS.getTypeQualifiers()) { 3526 if (DS.getTypeQualifiers() & DeclSpec::TQ_const) 3527 Diag(DS.getConstSpecLoc(), diag::ext_anonymous_struct_union_qualified) 3528 << Record->isUnion() << "const" 3529 << FixItHint::CreateRemoval(DS.getConstSpecLoc()); 3530 if (DS.getTypeQualifiers() & DeclSpec::TQ_volatile) 3531 Diag(DS.getVolatileSpecLoc(), 3532 diag::ext_anonymous_struct_union_qualified) 3533 << Record->isUnion() << "volatile" 3534 << FixItHint::CreateRemoval(DS.getVolatileSpecLoc()); 3535 if (DS.getTypeQualifiers() & DeclSpec::TQ_restrict) 3536 Diag(DS.getRestrictSpecLoc(), 3537 diag::ext_anonymous_struct_union_qualified) 3538 << Record->isUnion() << "restrict" 3539 << FixItHint::CreateRemoval(DS.getRestrictSpecLoc()); 3540 if (DS.getTypeQualifiers() & DeclSpec::TQ_atomic) 3541 Diag(DS.getAtomicSpecLoc(), 3542 diag::ext_anonymous_struct_union_qualified) 3543 << Record->isUnion() << "_Atomic" 3544 << FixItHint::CreateRemoval(DS.getAtomicSpecLoc()); 3545 3546 DS.ClearTypeQualifiers(); 3547 } 3548 3549 // C++ [class.union]p2: 3550 // The member-specification of an anonymous union shall only 3551 // define non-static data members. [Note: nested types and 3552 // functions cannot be declared within an anonymous union. ] 3553 for (DeclContext::decl_iterator Mem = Record->decls_begin(), 3554 MemEnd = Record->decls_end(); 3555 Mem != MemEnd; ++Mem) { 3556 if (FieldDecl *FD = dyn_cast<FieldDecl>(*Mem)) { 3557 // C++ [class.union]p3: 3558 // An anonymous union shall not have private or protected 3559 // members (clause 11). 3560 assert(FD->getAccess() != AS_none); 3561 if (FD->getAccess() != AS_public) { 3562 Diag(FD->getLocation(), diag::err_anonymous_record_nonpublic_member) 3563 << (int)Record->isUnion() << (int)(FD->getAccess() == AS_protected); 3564 Invalid = true; 3565 } 3566 3567 // C++ [class.union]p1 3568 // An object of a class with a non-trivial constructor, a non-trivial 3569 // copy constructor, a non-trivial destructor, or a non-trivial copy 3570 // assignment operator cannot be a member of a union, nor can an 3571 // array of such objects. 3572 if (CheckNontrivialField(FD)) 3573 Invalid = true; 3574 } else if ((*Mem)->isImplicit()) { 3575 // Any implicit members are fine. 3576 } else if (isa<TagDecl>(*Mem) && (*Mem)->getDeclContext() != Record) { 3577 // This is a type that showed up in an 3578 // elaborated-type-specifier inside the anonymous struct or 3579 // union, but which actually declares a type outside of the 3580 // anonymous struct or union. It's okay. 3581 } else if (RecordDecl *MemRecord = dyn_cast<RecordDecl>(*Mem)) { 3582 if (!MemRecord->isAnonymousStructOrUnion() && 3583 MemRecord->getDeclName()) { 3584 // Visual C++ allows type definition in anonymous struct or union. 3585 if (getLangOpts().MicrosoftExt) 3586 Diag(MemRecord->getLocation(), diag::ext_anonymous_record_with_type) 3587 << (int)Record->isUnion(); 3588 else { 3589 // This is a nested type declaration. 3590 Diag(MemRecord->getLocation(), diag::err_anonymous_record_with_type) 3591 << (int)Record->isUnion(); 3592 Invalid = true; 3593 } 3594 } else { 3595 // This is an anonymous type definition within another anonymous type. 3596 // This is a popular extension, provided by Plan9, MSVC and GCC, but 3597 // not part of standard C++. 3598 Diag(MemRecord->getLocation(), 3599 diag::ext_anonymous_record_with_anonymous_type) 3600 << (int)Record->isUnion(); 3601 } 3602 } else if (isa<AccessSpecDecl>(*Mem)) { 3603 // Any access specifier is fine. 3604 } else { 3605 // We have something that isn't a non-static data 3606 // member. Complain about it. 3607 unsigned DK = diag::err_anonymous_record_bad_member; 3608 if (isa<TypeDecl>(*Mem)) 3609 DK = diag::err_anonymous_record_with_type; 3610 else if (isa<FunctionDecl>(*Mem)) 3611 DK = diag::err_anonymous_record_with_function; 3612 else if (isa<VarDecl>(*Mem)) 3613 DK = diag::err_anonymous_record_with_static; 3614 3615 // Visual C++ allows type definition in anonymous struct or union. 3616 if (getLangOpts().MicrosoftExt && 3617 DK == diag::err_anonymous_record_with_type) 3618 Diag((*Mem)->getLocation(), diag::ext_anonymous_record_with_type) 3619 << (int)Record->isUnion(); 3620 else { 3621 Diag((*Mem)->getLocation(), DK) 3622 << (int)Record->isUnion(); 3623 Invalid = true; 3624 } 3625 } 3626 } 3627 } 3628 3629 if (!Record->isUnion() && !Owner->isRecord()) { 3630 Diag(Record->getLocation(), diag::err_anonymous_struct_not_member) 3631 << (int)getLangOpts().CPlusPlus; 3632 Invalid = true; 3633 } 3634 3635 // Mock up a declarator. 3636 Declarator Dc(DS, Declarator::MemberContext); 3637 TypeSourceInfo *TInfo = GetTypeForDeclarator(Dc, S); 3638 assert(TInfo && "couldn't build declarator info for anonymous struct/union"); 3639 3640 // Create a declaration for this anonymous struct/union. 3641 NamedDecl *Anon = 0; 3642 if (RecordDecl *OwningClass = dyn_cast<RecordDecl>(Owner)) { 3643 Anon = FieldDecl::Create(Context, OwningClass, 3644 DS.getLocStart(), 3645 Record->getLocation(), 3646 /*IdentifierInfo=*/0, 3647 Context.getTypeDeclType(Record), 3648 TInfo, 3649 /*BitWidth=*/0, /*Mutable=*/false, 3650 /*InitStyle=*/ICIS_NoInit); 3651 Anon->setAccess(AS); 3652 if (getLangOpts().CPlusPlus) 3653 FieldCollector->Add(cast<FieldDecl>(Anon)); 3654 } else { 3655 DeclSpec::SCS SCSpec = DS.getStorageClassSpec(); 3656 VarDecl::StorageClass SC = StorageClassSpecToVarDeclStorageClass(DS); 3657 if (SCSpec == DeclSpec::SCS_mutable) { 3658 // mutable can only appear on non-static class members, so it's always 3659 // an error here 3660 Diag(Record->getLocation(), diag::err_mutable_nonmember); 3661 Invalid = true; 3662 SC = SC_None; 3663 } 3664 3665 Anon = VarDecl::Create(Context, Owner, 3666 DS.getLocStart(), 3667 Record->getLocation(), /*IdentifierInfo=*/0, 3668 Context.getTypeDeclType(Record), 3669 TInfo, SC); 3670 3671 // Default-initialize the implicit variable. This initialization will be 3672 // trivial in almost all cases, except if a union member has an in-class 3673 // initializer: 3674 // union { int n = 0; }; 3675 ActOnUninitializedDecl(Anon, /*TypeMayContainAuto=*/false); 3676 } 3677 Anon->setImplicit(); 3678 3679 // Add the anonymous struct/union object to the current 3680 // context. We'll be referencing this object when we refer to one of 3681 // its members. 3682 Owner->addDecl(Anon); 3683 3684 // Inject the members of the anonymous struct/union into the owning 3685 // context and into the identifier resolver chain for name lookup 3686 // purposes. 3687 SmallVector<NamedDecl*, 2> Chain; 3688 Chain.push_back(Anon); 3689 3690 if (InjectAnonymousStructOrUnionMembers(*this, S, Owner, Record, AS, 3691 Chain, false)) 3692 Invalid = true; 3693 3694 // Mark this as an anonymous struct/union type. Note that we do not 3695 // do this until after we have already checked and injected the 3696 // members of this anonymous struct/union type, because otherwise 3697 // the members could be injected twice: once by DeclContext when it 3698 // builds its lookup table, and once by 3699 // InjectAnonymousStructOrUnionMembers. 3700 Record->setAnonymousStructOrUnion(true); 3701 3702 if (Invalid) 3703 Anon->setInvalidDecl(); 3704 3705 return Anon; 3706} 3707 3708/// BuildMicrosoftCAnonymousStruct - Handle the declaration of an 3709/// Microsoft C anonymous structure. 3710/// Ref: http://msdn.microsoft.com/en-us/library/z2cx9y4f.aspx 3711/// Example: 3712/// 3713/// struct A { int a; }; 3714/// struct B { struct A; int b; }; 3715/// 3716/// void foo() { 3717/// B var; 3718/// var.a = 3; 3719/// } 3720/// 3721Decl *Sema::BuildMicrosoftCAnonymousStruct(Scope *S, DeclSpec &DS, 3722 RecordDecl *Record) { 3723 3724 // If there is no Record, get the record via the typedef. 3725 if (!Record) 3726 Record = DS.getRepAsType().get()->getAsStructureType()->getDecl(); 3727 3728 // Mock up a declarator. 3729 Declarator Dc(DS, Declarator::TypeNameContext); 3730 TypeSourceInfo *TInfo = GetTypeForDeclarator(Dc, S); 3731 assert(TInfo && "couldn't build declarator info for anonymous struct"); 3732 3733 // Create a declaration for this anonymous struct. 3734 NamedDecl* Anon = FieldDecl::Create(Context, 3735 cast<RecordDecl>(CurContext), 3736 DS.getLocStart(), 3737 DS.getLocStart(), 3738 /*IdentifierInfo=*/0, 3739 Context.getTypeDeclType(Record), 3740 TInfo, 3741 /*BitWidth=*/0, /*Mutable=*/false, 3742 /*InitStyle=*/ICIS_NoInit); 3743 Anon->setImplicit(); 3744 3745 // Add the anonymous struct object to the current context. 3746 CurContext->addDecl(Anon); 3747 3748 // Inject the members of the anonymous struct into the current 3749 // context and into the identifier resolver chain for name lookup 3750 // purposes. 3751 SmallVector<NamedDecl*, 2> Chain; 3752 Chain.push_back(Anon); 3753 3754 RecordDecl *RecordDef = Record->getDefinition(); 3755 if (!RecordDef || InjectAnonymousStructOrUnionMembers(*this, S, CurContext, 3756 RecordDef, AS_none, 3757 Chain, true)) 3758 Anon->setInvalidDecl(); 3759 3760 return Anon; 3761} 3762 3763/// GetNameForDeclarator - Determine the full declaration name for the 3764/// given Declarator. 3765DeclarationNameInfo Sema::GetNameForDeclarator(Declarator &D) { 3766 return GetNameFromUnqualifiedId(D.getName()); 3767} 3768 3769/// \brief Retrieves the declaration name from a parsed unqualified-id. 3770DeclarationNameInfo 3771Sema::GetNameFromUnqualifiedId(const UnqualifiedId &Name) { 3772 DeclarationNameInfo NameInfo; 3773 NameInfo.setLoc(Name.StartLocation); 3774 3775 switch (Name.getKind()) { 3776 3777 case UnqualifiedId::IK_ImplicitSelfParam: 3778 case UnqualifiedId::IK_Identifier: 3779 NameInfo.setName(Name.Identifier); 3780 NameInfo.setLoc(Name.StartLocation); 3781 return NameInfo; 3782 3783 case UnqualifiedId::IK_OperatorFunctionId: 3784 NameInfo.setName(Context.DeclarationNames.getCXXOperatorName( 3785 Name.OperatorFunctionId.Operator)); 3786 NameInfo.setLoc(Name.StartLocation); 3787 NameInfo.getInfo().CXXOperatorName.BeginOpNameLoc 3788 = Name.OperatorFunctionId.SymbolLocations[0]; 3789 NameInfo.getInfo().CXXOperatorName.EndOpNameLoc 3790 = Name.EndLocation.getRawEncoding(); 3791 return NameInfo; 3792 3793 case UnqualifiedId::IK_LiteralOperatorId: 3794 NameInfo.setName(Context.DeclarationNames.getCXXLiteralOperatorName( 3795 Name.Identifier)); 3796 NameInfo.setLoc(Name.StartLocation); 3797 NameInfo.setCXXLiteralOperatorNameLoc(Name.EndLocation); 3798 return NameInfo; 3799 3800 case UnqualifiedId::IK_ConversionFunctionId: { 3801 TypeSourceInfo *TInfo; 3802 QualType Ty = GetTypeFromParser(Name.ConversionFunctionId, &TInfo); 3803 if (Ty.isNull()) 3804 return DeclarationNameInfo(); 3805 NameInfo.setName(Context.DeclarationNames.getCXXConversionFunctionName( 3806 Context.getCanonicalType(Ty))); 3807 NameInfo.setLoc(Name.StartLocation); 3808 NameInfo.setNamedTypeInfo(TInfo); 3809 return NameInfo; 3810 } 3811 3812 case UnqualifiedId::IK_ConstructorName: { 3813 TypeSourceInfo *TInfo; 3814 QualType Ty = GetTypeFromParser(Name.ConstructorName, &TInfo); 3815 if (Ty.isNull()) 3816 return DeclarationNameInfo(); 3817 NameInfo.setName(Context.DeclarationNames.getCXXConstructorName( 3818 Context.getCanonicalType(Ty))); 3819 NameInfo.setLoc(Name.StartLocation); 3820 NameInfo.setNamedTypeInfo(TInfo); 3821 return NameInfo; 3822 } 3823 3824 case UnqualifiedId::IK_ConstructorTemplateId: { 3825 // In well-formed code, we can only have a constructor 3826 // template-id that refers to the current context, so go there 3827 // to find the actual type being constructed. 3828 CXXRecordDecl *CurClass = dyn_cast<CXXRecordDecl>(CurContext); 3829 if (!CurClass || CurClass->getIdentifier() != Name.TemplateId->Name) 3830 return DeclarationNameInfo(); 3831 3832 // Determine the type of the class being constructed. 3833 QualType CurClassType = Context.getTypeDeclType(CurClass); 3834 3835 // FIXME: Check two things: that the template-id names the same type as 3836 // CurClassType, and that the template-id does not occur when the name 3837 // was qualified. 3838 3839 NameInfo.setName(Context.DeclarationNames.getCXXConstructorName( 3840 Context.getCanonicalType(CurClassType))); 3841 NameInfo.setLoc(Name.StartLocation); 3842 // FIXME: should we retrieve TypeSourceInfo? 3843 NameInfo.setNamedTypeInfo(0); 3844 return NameInfo; 3845 } 3846 3847 case UnqualifiedId::IK_DestructorName: { 3848 TypeSourceInfo *TInfo; 3849 QualType Ty = GetTypeFromParser(Name.DestructorName, &TInfo); 3850 if (Ty.isNull()) 3851 return DeclarationNameInfo(); 3852 NameInfo.setName(Context.DeclarationNames.getCXXDestructorName( 3853 Context.getCanonicalType(Ty))); 3854 NameInfo.setLoc(Name.StartLocation); 3855 NameInfo.setNamedTypeInfo(TInfo); 3856 return NameInfo; 3857 } 3858 3859 case UnqualifiedId::IK_TemplateId: { 3860 TemplateName TName = Name.TemplateId->Template.get(); 3861 SourceLocation TNameLoc = Name.TemplateId->TemplateNameLoc; 3862 return Context.getNameForTemplate(TName, TNameLoc); 3863 } 3864 3865 } // switch (Name.getKind()) 3866 3867 llvm_unreachable("Unknown name kind"); 3868} 3869 3870static QualType getCoreType(QualType Ty) { 3871 do { 3872 if (Ty->isPointerType() || Ty->isReferenceType()) 3873 Ty = Ty->getPointeeType(); 3874 else if (Ty->isArrayType()) 3875 Ty = Ty->castAsArrayTypeUnsafe()->getElementType(); 3876 else 3877 return Ty.withoutLocalFastQualifiers(); 3878 } while (true); 3879} 3880 3881/// hasSimilarParameters - Determine whether the C++ functions Declaration 3882/// and Definition have "nearly" matching parameters. This heuristic is 3883/// used to improve diagnostics in the case where an out-of-line function 3884/// definition doesn't match any declaration within the class or namespace. 3885/// Also sets Params to the list of indices to the parameters that differ 3886/// between the declaration and the definition. If hasSimilarParameters 3887/// returns true and Params is empty, then all of the parameters match. 3888static bool hasSimilarParameters(ASTContext &Context, 3889 FunctionDecl *Declaration, 3890 FunctionDecl *Definition, 3891 SmallVectorImpl<unsigned> &Params) { 3892 Params.clear(); 3893 if (Declaration->param_size() != Definition->param_size()) 3894 return false; 3895 for (unsigned Idx = 0; Idx < Declaration->param_size(); ++Idx) { 3896 QualType DeclParamTy = Declaration->getParamDecl(Idx)->getType(); 3897 QualType DefParamTy = Definition->getParamDecl(Idx)->getType(); 3898 3899 // The parameter types are identical 3900 if (Context.hasSameType(DefParamTy, DeclParamTy)) 3901 continue; 3902 3903 QualType DeclParamBaseTy = getCoreType(DeclParamTy); 3904 QualType DefParamBaseTy = getCoreType(DefParamTy); 3905 const IdentifierInfo *DeclTyName = DeclParamBaseTy.getBaseTypeIdentifier(); 3906 const IdentifierInfo *DefTyName = DefParamBaseTy.getBaseTypeIdentifier(); 3907 3908 if (Context.hasSameUnqualifiedType(DeclParamBaseTy, DefParamBaseTy) || 3909 (DeclTyName && DeclTyName == DefTyName)) 3910 Params.push_back(Idx); 3911 else // The two parameters aren't even close 3912 return false; 3913 } 3914 3915 return true; 3916} 3917 3918/// NeedsRebuildingInCurrentInstantiation - Checks whether the given 3919/// declarator needs to be rebuilt in the current instantiation. 3920/// Any bits of declarator which appear before the name are valid for 3921/// consideration here. That's specifically the type in the decl spec 3922/// and the base type in any member-pointer chunks. 3923static bool RebuildDeclaratorInCurrentInstantiation(Sema &S, Declarator &D, 3924 DeclarationName Name) { 3925 // The types we specifically need to rebuild are: 3926 // - typenames, typeofs, and decltypes 3927 // - types which will become injected class names 3928 // Of course, we also need to rebuild any type referencing such a 3929 // type. It's safest to just say "dependent", but we call out a 3930 // few cases here. 3931 3932 DeclSpec &DS = D.getMutableDeclSpec(); 3933 switch (DS.getTypeSpecType()) { 3934 case DeclSpec::TST_typename: 3935 case DeclSpec::TST_typeofType: 3936 case DeclSpec::TST_underlyingType: 3937 case DeclSpec::TST_atomic: { 3938 // Grab the type from the parser. 3939 TypeSourceInfo *TSI = 0; 3940 QualType T = S.GetTypeFromParser(DS.getRepAsType(), &TSI); 3941 if (T.isNull() || !T->isDependentType()) break; 3942 3943 // Make sure there's a type source info. This isn't really much 3944 // of a waste; most dependent types should have type source info 3945 // attached already. 3946 if (!TSI) 3947 TSI = S.Context.getTrivialTypeSourceInfo(T, DS.getTypeSpecTypeLoc()); 3948 3949 // Rebuild the type in the current instantiation. 3950 TSI = S.RebuildTypeInCurrentInstantiation(TSI, D.getIdentifierLoc(), Name); 3951 if (!TSI) return true; 3952 3953 // Store the new type back in the decl spec. 3954 ParsedType LocType = S.CreateParsedType(TSI->getType(), TSI); 3955 DS.UpdateTypeRep(LocType); 3956 break; 3957 } 3958 3959 case DeclSpec::TST_decltype: 3960 case DeclSpec::TST_typeofExpr: { 3961 Expr *E = DS.getRepAsExpr(); 3962 ExprResult Result = S.RebuildExprInCurrentInstantiation(E); 3963 if (Result.isInvalid()) return true; 3964 DS.UpdateExprRep(Result.get()); 3965 break; 3966 } 3967 3968 default: 3969 // Nothing to do for these decl specs. 3970 break; 3971 } 3972 3973 // It doesn't matter what order we do this in. 3974 for (unsigned I = 0, E = D.getNumTypeObjects(); I != E; ++I) { 3975 DeclaratorChunk &Chunk = D.getTypeObject(I); 3976 3977 // The only type information in the declarator which can come 3978 // before the declaration name is the base type of a member 3979 // pointer. 3980 if (Chunk.Kind != DeclaratorChunk::MemberPointer) 3981 continue; 3982 3983 // Rebuild the scope specifier in-place. 3984 CXXScopeSpec &SS = Chunk.Mem.Scope(); 3985 if (S.RebuildNestedNameSpecifierInCurrentInstantiation(SS)) 3986 return true; 3987 } 3988 3989 return false; 3990} 3991 3992Decl *Sema::ActOnDeclarator(Scope *S, Declarator &D) { 3993 D.setFunctionDefinitionKind(FDK_Declaration); 3994 Decl *Dcl = HandleDeclarator(S, D, MultiTemplateParamsArg()); 3995 3996 if (OriginalLexicalContext && OriginalLexicalContext->isObjCContainer() && 3997 Dcl && Dcl->getDeclContext()->isFileContext()) 3998 Dcl->setTopLevelDeclInObjCContainer(); 3999 4000 return Dcl; 4001} 4002 4003/// DiagnoseClassNameShadow - Implement C++ [class.mem]p13: 4004/// If T is the name of a class, then each of the following shall have a 4005/// name different from T: 4006/// - every static data member of class T; 4007/// - every member function of class T 4008/// - every member of class T that is itself a type; 4009/// \returns true if the declaration name violates these rules. 4010bool Sema::DiagnoseClassNameShadow(DeclContext *DC, 4011 DeclarationNameInfo NameInfo) { 4012 DeclarationName Name = NameInfo.getName(); 4013 4014 if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(DC)) 4015 if (Record->getIdentifier() && Record->getDeclName() == Name) { 4016 Diag(NameInfo.getLoc(), diag::err_member_name_of_class) << Name; 4017 return true; 4018 } 4019 4020 return false; 4021} 4022 4023/// \brief Diagnose a declaration whose declarator-id has the given 4024/// nested-name-specifier. 4025/// 4026/// \param SS The nested-name-specifier of the declarator-id. 4027/// 4028/// \param DC The declaration context to which the nested-name-specifier 4029/// resolves. 4030/// 4031/// \param Name The name of the entity being declared. 4032/// 4033/// \param Loc The location of the name of the entity being declared. 4034/// 4035/// \returns true if we cannot safely recover from this error, false otherwise. 4036bool Sema::diagnoseQualifiedDeclaration(CXXScopeSpec &SS, DeclContext *DC, 4037 DeclarationName Name, 4038 SourceLocation Loc) { 4039 DeclContext *Cur = CurContext; 4040 while (isa<LinkageSpecDecl>(Cur) || isa<CapturedDecl>(Cur)) 4041 Cur = Cur->getParent(); 4042 4043 // C++ [dcl.meaning]p1: 4044 // A declarator-id shall not be qualified except for the definition 4045 // of a member function (9.3) or static data member (9.4) outside of 4046 // its class, the definition or explicit instantiation of a function 4047 // or variable member of a namespace outside of its namespace, or the 4048 // definition of an explicit specialization outside of its namespace, 4049 // or the declaration of a friend function that is a member of 4050 // another class or namespace (11.3). [...] 4051 4052 // The user provided a superfluous scope specifier that refers back to the 4053 // class or namespaces in which the entity is already declared. 4054 // 4055 // class X { 4056 // void X::f(); 4057 // }; 4058 if (Cur->Equals(DC)) { 4059 Diag(Loc, LangOpts.MicrosoftExt? diag::warn_member_extra_qualification 4060 : diag::err_member_extra_qualification) 4061 << Name << FixItHint::CreateRemoval(SS.getRange()); 4062 SS.clear(); 4063 return false; 4064 } 4065 4066 // Check whether the qualifying scope encloses the scope of the original 4067 // declaration. 4068 if (!Cur->Encloses(DC)) { 4069 if (Cur->isRecord()) 4070 Diag(Loc, diag::err_member_qualification) 4071 << Name << SS.getRange(); 4072 else if (isa<TranslationUnitDecl>(DC)) 4073 Diag(Loc, diag::err_invalid_declarator_global_scope) 4074 << Name << SS.getRange(); 4075 else if (isa<FunctionDecl>(Cur)) 4076 Diag(Loc, diag::err_invalid_declarator_in_function) 4077 << Name << SS.getRange(); 4078 else if (isa<BlockDecl>(Cur)) 4079 Diag(Loc, diag::err_invalid_declarator_in_block) 4080 << Name << SS.getRange(); 4081 else 4082 Diag(Loc, diag::err_invalid_declarator_scope) 4083 << Name << cast<NamedDecl>(Cur) << cast<NamedDecl>(DC) << SS.getRange(); 4084 4085 return true; 4086 } 4087 4088 if (Cur->isRecord()) { 4089 // Cannot qualify members within a class. 4090 Diag(Loc, diag::err_member_qualification) 4091 << Name << SS.getRange(); 4092 SS.clear(); 4093 4094 // C++ constructors and destructors with incorrect scopes can break 4095 // our AST invariants by having the wrong underlying types. If 4096 // that's the case, then drop this declaration entirely. 4097 if ((Name.getNameKind() == DeclarationName::CXXConstructorName || 4098 Name.getNameKind() == DeclarationName::CXXDestructorName) && 4099 !Context.hasSameType(Name.getCXXNameType(), 4100 Context.getTypeDeclType(cast<CXXRecordDecl>(Cur)))) 4101 return true; 4102 4103 return false; 4104 } 4105 4106 // C++11 [dcl.meaning]p1: 4107 // [...] "The nested-name-specifier of the qualified declarator-id shall 4108 // not begin with a decltype-specifer" 4109 NestedNameSpecifierLoc SpecLoc(SS.getScopeRep(), SS.location_data()); 4110 while (SpecLoc.getPrefix()) 4111 SpecLoc = SpecLoc.getPrefix(); 4112 if (dyn_cast_or_null<DecltypeType>( 4113 SpecLoc.getNestedNameSpecifier()->getAsType())) 4114 Diag(Loc, diag::err_decltype_in_declarator) 4115 << SpecLoc.getTypeLoc().getSourceRange(); 4116 4117 return false; 4118} 4119 4120NamedDecl *Sema::HandleDeclarator(Scope *S, Declarator &D, 4121 MultiTemplateParamsArg TemplateParamLists) { 4122 // TODO: consider using NameInfo for diagnostic. 4123 DeclarationNameInfo NameInfo = GetNameForDeclarator(D); 4124 DeclarationName Name = NameInfo.getName(); 4125 4126 // All of these full declarators require an identifier. If it doesn't have 4127 // one, the ParsedFreeStandingDeclSpec action should be used. 4128 if (!Name) { 4129 if (!D.isInvalidType()) // Reject this if we think it is valid. 4130 Diag(D.getDeclSpec().getLocStart(), 4131 diag::err_declarator_need_ident) 4132 << D.getDeclSpec().getSourceRange() << D.getSourceRange(); 4133 return 0; 4134 } else if (DiagnoseUnexpandedParameterPack(NameInfo, UPPC_DeclarationType)) 4135 return 0; 4136 4137 // The scope passed in may not be a decl scope. Zip up the scope tree until 4138 // we find one that is. 4139 while ((S->getFlags() & Scope::DeclScope) == 0 || 4140 (S->getFlags() & Scope::TemplateParamScope) != 0) 4141 S = S->getParent(); 4142 4143 DeclContext *DC = CurContext; 4144 if (D.getCXXScopeSpec().isInvalid()) 4145 D.setInvalidType(); 4146 else if (D.getCXXScopeSpec().isSet()) { 4147 if (DiagnoseUnexpandedParameterPack(D.getCXXScopeSpec(), 4148 UPPC_DeclarationQualifier)) 4149 return 0; 4150 4151 bool EnteringContext = !D.getDeclSpec().isFriendSpecified(); 4152 DC = computeDeclContext(D.getCXXScopeSpec(), EnteringContext); 4153 if (!DC) { 4154 // If we could not compute the declaration context, it's because the 4155 // declaration context is dependent but does not refer to a class, 4156 // class template, or class template partial specialization. Complain 4157 // and return early, to avoid the coming semantic disaster. 4158 Diag(D.getIdentifierLoc(), 4159 diag::err_template_qualified_declarator_no_match) 4160 << (NestedNameSpecifier*)D.getCXXScopeSpec().getScopeRep() 4161 << D.getCXXScopeSpec().getRange(); 4162 return 0; 4163 } 4164 bool IsDependentContext = DC->isDependentContext(); 4165 4166 if (!IsDependentContext && 4167 RequireCompleteDeclContext(D.getCXXScopeSpec(), DC)) 4168 return 0; 4169 4170 if (isa<CXXRecordDecl>(DC) && !cast<CXXRecordDecl>(DC)->hasDefinition()) { 4171 Diag(D.getIdentifierLoc(), 4172 diag::err_member_def_undefined_record) 4173 << Name << DC << D.getCXXScopeSpec().getRange(); 4174 D.setInvalidType(); 4175 } else if (!D.getDeclSpec().isFriendSpecified()) { 4176 if (diagnoseQualifiedDeclaration(D.getCXXScopeSpec(), DC, 4177 Name, D.getIdentifierLoc())) { 4178 if (DC->isRecord()) 4179 return 0; 4180 4181 D.setInvalidType(); 4182 } 4183 } 4184 4185 // Check whether we need to rebuild the type of the given 4186 // declaration in the current instantiation. 4187 if (EnteringContext && IsDependentContext && 4188 TemplateParamLists.size() != 0) { 4189 ContextRAII SavedContext(*this, DC); 4190 if (RebuildDeclaratorInCurrentInstantiation(*this, D, Name)) 4191 D.setInvalidType(); 4192 } 4193 } 4194 4195 if (DiagnoseClassNameShadow(DC, NameInfo)) 4196 // If this is a typedef, we'll end up spewing multiple diagnostics. 4197 // Just return early; it's safer. 4198 if (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_typedef) 4199 return 0; 4200 4201 TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S); 4202 QualType R = TInfo->getType(); 4203 4204 if (DiagnoseUnexpandedParameterPack(D.getIdentifierLoc(), TInfo, 4205 UPPC_DeclarationType)) 4206 D.setInvalidType(); 4207 4208 LookupResult Previous(*this, NameInfo, LookupOrdinaryName, 4209 ForRedeclaration); 4210 4211 // See if this is a redefinition of a variable in the same scope. 4212 if (!D.getCXXScopeSpec().isSet()) { 4213 bool IsLinkageLookup = false; 4214 bool CreateBuiltins = false; 4215 4216 // If the declaration we're planning to build will be a function 4217 // or object with linkage, then look for another declaration with 4218 // linkage (C99 6.2.2p4-5 and C++ [basic.link]p6). 4219 // 4220 // If the declaration we're planning to build will be declared with 4221 // external linkage in the translation unit, create any builtin with 4222 // the same name. 4223 if (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_typedef) 4224 /* Do nothing*/; 4225 else if (CurContext->isFunctionOrMethod() && 4226 (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_extern || 4227 R->isFunctionType())) { 4228 IsLinkageLookup = true; 4229 CreateBuiltins = 4230 CurContext->getEnclosingNamespaceContext()->isTranslationUnit(); 4231 } else if (CurContext->getRedeclContext()->isTranslationUnit() && 4232 D.getDeclSpec().getStorageClassSpec() != DeclSpec::SCS_static) 4233 CreateBuiltins = true; 4234 4235 if (IsLinkageLookup) 4236 Previous.clear(LookupRedeclarationWithLinkage); 4237 4238 LookupName(Previous, S, CreateBuiltins); 4239 } else { // Something like "int foo::x;" 4240 LookupQualifiedName(Previous, DC); 4241 4242 // C++ [dcl.meaning]p1: 4243 // When the declarator-id is qualified, the declaration shall refer to a 4244 // previously declared member of the class or namespace to which the 4245 // qualifier refers (or, in the case of a namespace, of an element of the 4246 // inline namespace set of that namespace (7.3.1)) or to a specialization 4247 // thereof; [...] 4248 // 4249 // Note that we already checked the context above, and that we do not have 4250 // enough information to make sure that Previous contains the declaration 4251 // we want to match. For example, given: 4252 // 4253 // class X { 4254 // void f(); 4255 // void f(float); 4256 // }; 4257 // 4258 // void X::f(int) { } // ill-formed 4259 // 4260 // In this case, Previous will point to the overload set 4261 // containing the two f's declared in X, but neither of them 4262 // matches. 4263 4264 // C++ [dcl.meaning]p1: 4265 // [...] the member shall not merely have been introduced by a 4266 // using-declaration in the scope of the class or namespace nominated by 4267 // the nested-name-specifier of the declarator-id. 4268 RemoveUsingDecls(Previous); 4269 } 4270 4271 if (Previous.isSingleResult() && 4272 Previous.getFoundDecl()->isTemplateParameter()) { 4273 // Maybe we will complain about the shadowed template parameter. 4274 if (!D.isInvalidType()) 4275 DiagnoseTemplateParameterShadow(D.getIdentifierLoc(), 4276 Previous.getFoundDecl()); 4277 4278 // Just pretend that we didn't see the previous declaration. 4279 Previous.clear(); 4280 } 4281 4282 // In C++, the previous declaration we find might be a tag type 4283 // (class or enum). In this case, the new declaration will hide the 4284 // tag type. Note that this does does not apply if we're declaring a 4285 // typedef (C++ [dcl.typedef]p4). 4286 if (Previous.isSingleTagDecl() && 4287 D.getDeclSpec().getStorageClassSpec() != DeclSpec::SCS_typedef) 4288 Previous.clear(); 4289 4290 // Check that there are no default arguments other than in the parameters 4291 // of a function declaration (C++ only). 4292 if (getLangOpts().CPlusPlus) 4293 CheckExtraCXXDefaultArguments(D); 4294 4295 NamedDecl *New; 4296 4297 bool AddToScope = true; 4298 if (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_typedef) { 4299 if (TemplateParamLists.size()) { 4300 Diag(D.getIdentifierLoc(), diag::err_template_typedef); 4301 return 0; 4302 } 4303 4304 New = ActOnTypedefDeclarator(S, D, DC, TInfo, Previous); 4305 } else if (R->isFunctionType()) { 4306 New = ActOnFunctionDeclarator(S, D, DC, TInfo, Previous, 4307 TemplateParamLists, 4308 AddToScope); 4309 } else { 4310 New = ActOnVariableDeclarator(S, D, DC, TInfo, Previous, TemplateParamLists, 4311 AddToScope); 4312 } 4313 4314 if (New == 0) 4315 return 0; 4316 4317 // If this has an identifier and is not an invalid redeclaration or 4318 // function template specialization, add it to the scope stack. 4319 if (New->getDeclName() && AddToScope && 4320 !(D.isRedeclaration() && New->isInvalidDecl())) 4321 PushOnScopeChains(New, S); 4322 4323 return New; 4324} 4325 4326/// Helper method to turn variable array types into constant array 4327/// types in certain situations which would otherwise be errors (for 4328/// GCC compatibility). 4329static QualType TryToFixInvalidVariablyModifiedType(QualType T, 4330 ASTContext &Context, 4331 bool &SizeIsNegative, 4332 llvm::APSInt &Oversized) { 4333 // This method tries to turn a variable array into a constant 4334 // array even when the size isn't an ICE. This is necessary 4335 // for compatibility with code that depends on gcc's buggy 4336 // constant expression folding, like struct {char x[(int)(char*)2];} 4337 SizeIsNegative = false; 4338 Oversized = 0; 4339 4340 if (T->isDependentType()) 4341 return QualType(); 4342 4343 QualifierCollector Qs; 4344 const Type *Ty = Qs.strip(T); 4345 4346 if (const PointerType* PTy = dyn_cast<PointerType>(Ty)) { 4347 QualType Pointee = PTy->getPointeeType(); 4348 QualType FixedType = 4349 TryToFixInvalidVariablyModifiedType(Pointee, Context, SizeIsNegative, 4350 Oversized); 4351 if (FixedType.isNull()) return FixedType; 4352 FixedType = Context.getPointerType(FixedType); 4353 return Qs.apply(Context, FixedType); 4354 } 4355 if (const ParenType* PTy = dyn_cast<ParenType>(Ty)) { 4356 QualType Inner = PTy->getInnerType(); 4357 QualType FixedType = 4358 TryToFixInvalidVariablyModifiedType(Inner, Context, SizeIsNegative, 4359 Oversized); 4360 if (FixedType.isNull()) return FixedType; 4361 FixedType = Context.getParenType(FixedType); 4362 return Qs.apply(Context, FixedType); 4363 } 4364 4365 const VariableArrayType* VLATy = dyn_cast<VariableArrayType>(T); 4366 if (!VLATy) 4367 return QualType(); 4368 // FIXME: We should probably handle this case 4369 if (VLATy->getElementType()->isVariablyModifiedType()) 4370 return QualType(); 4371 4372 llvm::APSInt Res; 4373 if (!VLATy->getSizeExpr() || 4374 !VLATy->getSizeExpr()->EvaluateAsInt(Res, Context)) 4375 return QualType(); 4376 4377 // Check whether the array size is negative. 4378 if (Res.isSigned() && Res.isNegative()) { 4379 SizeIsNegative = true; 4380 return QualType(); 4381 } 4382 4383 // Check whether the array is too large to be addressed. 4384 unsigned ActiveSizeBits 4385 = ConstantArrayType::getNumAddressingBits(Context, VLATy->getElementType(), 4386 Res); 4387 if (ActiveSizeBits > ConstantArrayType::getMaxSizeBits(Context)) { 4388 Oversized = Res; 4389 return QualType(); 4390 } 4391 4392 return Context.getConstantArrayType(VLATy->getElementType(), 4393 Res, ArrayType::Normal, 0); 4394} 4395 4396static void 4397FixInvalidVariablyModifiedTypeLoc(TypeLoc SrcTL, TypeLoc DstTL) { 4398 if (PointerTypeLoc SrcPTL = SrcTL.getAs<PointerTypeLoc>()) { 4399 PointerTypeLoc DstPTL = DstTL.castAs<PointerTypeLoc>(); 4400 FixInvalidVariablyModifiedTypeLoc(SrcPTL.getPointeeLoc(), 4401 DstPTL.getPointeeLoc()); 4402 DstPTL.setStarLoc(SrcPTL.getStarLoc()); 4403 return; 4404 } 4405 if (ParenTypeLoc SrcPTL = SrcTL.getAs<ParenTypeLoc>()) { 4406 ParenTypeLoc DstPTL = DstTL.castAs<ParenTypeLoc>(); 4407 FixInvalidVariablyModifiedTypeLoc(SrcPTL.getInnerLoc(), 4408 DstPTL.getInnerLoc()); 4409 DstPTL.setLParenLoc(SrcPTL.getLParenLoc()); 4410 DstPTL.setRParenLoc(SrcPTL.getRParenLoc()); 4411 return; 4412 } 4413 ArrayTypeLoc SrcATL = SrcTL.castAs<ArrayTypeLoc>(); 4414 ArrayTypeLoc DstATL = DstTL.castAs<ArrayTypeLoc>(); 4415 TypeLoc SrcElemTL = SrcATL.getElementLoc(); 4416 TypeLoc DstElemTL = DstATL.getElementLoc(); 4417 DstElemTL.initializeFullCopy(SrcElemTL); 4418 DstATL.setLBracketLoc(SrcATL.getLBracketLoc()); 4419 DstATL.setSizeExpr(SrcATL.getSizeExpr()); 4420 DstATL.setRBracketLoc(SrcATL.getRBracketLoc()); 4421} 4422 4423/// Helper method to turn variable array types into constant array 4424/// types in certain situations which would otherwise be errors (for 4425/// GCC compatibility). 4426static TypeSourceInfo* 4427TryToFixInvalidVariablyModifiedTypeSourceInfo(TypeSourceInfo *TInfo, 4428 ASTContext &Context, 4429 bool &SizeIsNegative, 4430 llvm::APSInt &Oversized) { 4431 QualType FixedTy 4432 = TryToFixInvalidVariablyModifiedType(TInfo->getType(), Context, 4433 SizeIsNegative, Oversized); 4434 if (FixedTy.isNull()) 4435 return 0; 4436 TypeSourceInfo *FixedTInfo = Context.getTrivialTypeSourceInfo(FixedTy); 4437 FixInvalidVariablyModifiedTypeLoc(TInfo->getTypeLoc(), 4438 FixedTInfo->getTypeLoc()); 4439 return FixedTInfo; 4440} 4441 4442/// \brief Register the given locally-scoped extern "C" declaration so 4443/// that it can be found later for redeclarations. We include any extern "C" 4444/// declaration that is not visible in the translation unit here, not just 4445/// function-scope declarations. 4446void 4447Sema::RegisterLocallyScopedExternCDecl(NamedDecl *ND, Scope *S) { 4448 if (!getLangOpts().CPlusPlus && 4449 ND->getLexicalDeclContext()->getRedeclContext()->isTranslationUnit()) 4450 // Don't need to track declarations in the TU in C. 4451 return; 4452 4453 // Note that we have a locally-scoped external with this name. 4454 // FIXME: There can be multiple such declarations if they are functions marked 4455 // __attribute__((overloadable)) declared in function scope in C. 4456 LocallyScopedExternCDecls[ND->getDeclName()] = ND; 4457} 4458 4459NamedDecl *Sema::findLocallyScopedExternCDecl(DeclarationName Name) { 4460 if (ExternalSource) { 4461 // Load locally-scoped external decls from the external source. 4462 // FIXME: This is inefficient. Maybe add a DeclContext for extern "C" decls? 4463 SmallVector<NamedDecl *, 4> Decls; 4464 ExternalSource->ReadLocallyScopedExternCDecls(Decls); 4465 for (unsigned I = 0, N = Decls.size(); I != N; ++I) { 4466 llvm::DenseMap<DeclarationName, NamedDecl *>::iterator Pos 4467 = LocallyScopedExternCDecls.find(Decls[I]->getDeclName()); 4468 if (Pos == LocallyScopedExternCDecls.end()) 4469 LocallyScopedExternCDecls[Decls[I]->getDeclName()] = Decls[I]; 4470 } 4471 } 4472 4473 NamedDecl *D = LocallyScopedExternCDecls.lookup(Name); 4474 return D ? cast<NamedDecl>(D->getMostRecentDecl()) : 0; 4475} 4476 4477/// \brief Diagnose function specifiers on a declaration of an identifier that 4478/// does not identify a function. 4479void Sema::DiagnoseFunctionSpecifiers(const DeclSpec &DS) { 4480 // FIXME: We should probably indicate the identifier in question to avoid 4481 // confusion for constructs like "inline int a(), b;" 4482 if (DS.isInlineSpecified()) 4483 Diag(DS.getInlineSpecLoc(), 4484 diag::err_inline_non_function); 4485 4486 if (DS.isVirtualSpecified()) 4487 Diag(DS.getVirtualSpecLoc(), 4488 diag::err_virtual_non_function); 4489 4490 if (DS.isExplicitSpecified()) 4491 Diag(DS.getExplicitSpecLoc(), 4492 diag::err_explicit_non_function); 4493 4494 if (DS.isNoreturnSpecified()) 4495 Diag(DS.getNoreturnSpecLoc(), 4496 diag::err_noreturn_non_function); 4497} 4498 4499NamedDecl* 4500Sema::ActOnTypedefDeclarator(Scope* S, Declarator& D, DeclContext* DC, 4501 TypeSourceInfo *TInfo, LookupResult &Previous) { 4502 // Typedef declarators cannot be qualified (C++ [dcl.meaning]p1). 4503 if (D.getCXXScopeSpec().isSet()) { 4504 Diag(D.getIdentifierLoc(), diag::err_qualified_typedef_declarator) 4505 << D.getCXXScopeSpec().getRange(); 4506 D.setInvalidType(); 4507 // Pretend we didn't see the scope specifier. 4508 DC = CurContext; 4509 Previous.clear(); 4510 } 4511 4512 DiagnoseFunctionSpecifiers(D.getDeclSpec()); 4513 4514 if (D.getDeclSpec().isConstexprSpecified()) 4515 Diag(D.getDeclSpec().getConstexprSpecLoc(), diag::err_invalid_constexpr) 4516 << 1; 4517 4518 if (D.getName().Kind != UnqualifiedId::IK_Identifier) { 4519 Diag(D.getName().StartLocation, diag::err_typedef_not_identifier) 4520 << D.getName().getSourceRange(); 4521 return 0; 4522 } 4523 4524 TypedefDecl *NewTD = ParseTypedefDecl(S, D, TInfo->getType(), TInfo); 4525 if (!NewTD) return 0; 4526 4527 // Handle attributes prior to checking for duplicates in MergeVarDecl 4528 ProcessDeclAttributes(S, NewTD, D); 4529 4530 CheckTypedefForVariablyModifiedType(S, NewTD); 4531 4532 bool Redeclaration = D.isRedeclaration(); 4533 NamedDecl *ND = ActOnTypedefNameDecl(S, DC, NewTD, Previous, Redeclaration); 4534 D.setRedeclaration(Redeclaration); 4535 return ND; 4536} 4537 4538void 4539Sema::CheckTypedefForVariablyModifiedType(Scope *S, TypedefNameDecl *NewTD) { 4540 // C99 6.7.7p2: If a typedef name specifies a variably modified type 4541 // then it shall have block scope. 4542 // Note that variably modified types must be fixed before merging the decl so 4543 // that redeclarations will match. 4544 TypeSourceInfo *TInfo = NewTD->getTypeSourceInfo(); 4545 QualType T = TInfo->getType(); 4546 if (T->isVariablyModifiedType()) { 4547 getCurFunction()->setHasBranchProtectedScope(); 4548 4549 if (S->getFnParent() == 0) { 4550 bool SizeIsNegative; 4551 llvm::APSInt Oversized; 4552 TypeSourceInfo *FixedTInfo = 4553 TryToFixInvalidVariablyModifiedTypeSourceInfo(TInfo, Context, 4554 SizeIsNegative, 4555 Oversized); 4556 if (FixedTInfo) { 4557 Diag(NewTD->getLocation(), diag::warn_illegal_constant_array_size); 4558 NewTD->setTypeSourceInfo(FixedTInfo); 4559 } else { 4560 if (SizeIsNegative) 4561 Diag(NewTD->getLocation(), diag::err_typecheck_negative_array_size); 4562 else if (T->isVariableArrayType()) 4563 Diag(NewTD->getLocation(), diag::err_vla_decl_in_file_scope); 4564 else if (Oversized.getBoolValue()) 4565 Diag(NewTD->getLocation(), diag::err_array_too_large) 4566 << Oversized.toString(10); 4567 else 4568 Diag(NewTD->getLocation(), diag::err_vm_decl_in_file_scope); 4569 NewTD->setInvalidDecl(); 4570 } 4571 } 4572 } 4573} 4574 4575 4576/// ActOnTypedefNameDecl - Perform semantic checking for a declaration which 4577/// declares a typedef-name, either using the 'typedef' type specifier or via 4578/// a C++0x [dcl.typedef]p2 alias-declaration: 'using T = A;'. 4579NamedDecl* 4580Sema::ActOnTypedefNameDecl(Scope *S, DeclContext *DC, TypedefNameDecl *NewTD, 4581 LookupResult &Previous, bool &Redeclaration) { 4582 // Merge the decl with the existing one if appropriate. If the decl is 4583 // in an outer scope, it isn't the same thing. 4584 FilterLookupForScope(Previous, DC, S, /*ConsiderLinkage*/ false, 4585 /*ExplicitInstantiationOrSpecialization=*/false); 4586 filterNonConflictingPreviousDecls(Context, NewTD, Previous); 4587 if (!Previous.empty()) { 4588 Redeclaration = true; 4589 MergeTypedefNameDecl(NewTD, Previous); 4590 } 4591 4592 // If this is the C FILE type, notify the AST context. 4593 if (IdentifierInfo *II = NewTD->getIdentifier()) 4594 if (!NewTD->isInvalidDecl() && 4595 NewTD->getDeclContext()->getRedeclContext()->isTranslationUnit()) { 4596 if (II->isStr("FILE")) 4597 Context.setFILEDecl(NewTD); 4598 else if (II->isStr("jmp_buf")) 4599 Context.setjmp_bufDecl(NewTD); 4600 else if (II->isStr("sigjmp_buf")) 4601 Context.setsigjmp_bufDecl(NewTD); 4602 else if (II->isStr("ucontext_t")) 4603 Context.setucontext_tDecl(NewTD); 4604 } 4605 4606 return NewTD; 4607} 4608 4609/// \brief Determines whether the given declaration is an out-of-scope 4610/// previous declaration. 4611/// 4612/// This routine should be invoked when name lookup has found a 4613/// previous declaration (PrevDecl) that is not in the scope where a 4614/// new declaration by the same name is being introduced. If the new 4615/// declaration occurs in a local scope, previous declarations with 4616/// linkage may still be considered previous declarations (C99 4617/// 6.2.2p4-5, C++ [basic.link]p6). 4618/// 4619/// \param PrevDecl the previous declaration found by name 4620/// lookup 4621/// 4622/// \param DC the context in which the new declaration is being 4623/// declared. 4624/// 4625/// \returns true if PrevDecl is an out-of-scope previous declaration 4626/// for a new delcaration with the same name. 4627static bool 4628isOutOfScopePreviousDeclaration(NamedDecl *PrevDecl, DeclContext *DC, 4629 ASTContext &Context) { 4630 if (!PrevDecl) 4631 return false; 4632 4633 if (!PrevDecl->hasLinkage()) 4634 return false; 4635 4636 if (Context.getLangOpts().CPlusPlus) { 4637 // C++ [basic.link]p6: 4638 // If there is a visible declaration of an entity with linkage 4639 // having the same name and type, ignoring entities declared 4640 // outside the innermost enclosing namespace scope, the block 4641 // scope declaration declares that same entity and receives the 4642 // linkage of the previous declaration. 4643 DeclContext *OuterContext = DC->getRedeclContext(); 4644 if (!OuterContext->isFunctionOrMethod()) 4645 // This rule only applies to block-scope declarations. 4646 return false; 4647 4648 DeclContext *PrevOuterContext = PrevDecl->getDeclContext(); 4649 if (PrevOuterContext->isRecord()) 4650 // We found a member function: ignore it. 4651 return false; 4652 4653 // Find the innermost enclosing namespace for the new and 4654 // previous declarations. 4655 OuterContext = OuterContext->getEnclosingNamespaceContext(); 4656 PrevOuterContext = PrevOuterContext->getEnclosingNamespaceContext(); 4657 4658 // The previous declaration is in a different namespace, so it 4659 // isn't the same function. 4660 if (!OuterContext->Equals(PrevOuterContext)) 4661 return false; 4662 } 4663 4664 return true; 4665} 4666 4667static void SetNestedNameSpecifier(DeclaratorDecl *DD, Declarator &D) { 4668 CXXScopeSpec &SS = D.getCXXScopeSpec(); 4669 if (!SS.isSet()) return; 4670 DD->setQualifierInfo(SS.getWithLocInContext(DD->getASTContext())); 4671} 4672 4673bool Sema::inferObjCARCLifetime(ValueDecl *decl) { 4674 QualType type = decl->getType(); 4675 Qualifiers::ObjCLifetime lifetime = type.getObjCLifetime(); 4676 if (lifetime == Qualifiers::OCL_Autoreleasing) { 4677 // Various kinds of declaration aren't allowed to be __autoreleasing. 4678 unsigned kind = -1U; 4679 if (VarDecl *var = dyn_cast<VarDecl>(decl)) { 4680 if (var->hasAttr<BlocksAttr>()) 4681 kind = 0; // __block 4682 else if (!var->hasLocalStorage()) 4683 kind = 1; // global 4684 } else if (isa<ObjCIvarDecl>(decl)) { 4685 kind = 3; // ivar 4686 } else if (isa<FieldDecl>(decl)) { 4687 kind = 2; // field 4688 } 4689 4690 if (kind != -1U) { 4691 Diag(decl->getLocation(), diag::err_arc_autoreleasing_var) 4692 << kind; 4693 } 4694 } else if (lifetime == Qualifiers::OCL_None) { 4695 // Try to infer lifetime. 4696 if (!type->isObjCLifetimeType()) 4697 return false; 4698 4699 lifetime = type->getObjCARCImplicitLifetime(); 4700 type = Context.getLifetimeQualifiedType(type, lifetime); 4701 decl->setType(type); 4702 } 4703 4704 if (VarDecl *var = dyn_cast<VarDecl>(decl)) { 4705 // Thread-local variables cannot have lifetime. 4706 if (lifetime && lifetime != Qualifiers::OCL_ExplicitNone && 4707 var->getTLSKind()) { 4708 Diag(var->getLocation(), diag::err_arc_thread_ownership) 4709 << var->getType(); 4710 return true; 4711 } 4712 } 4713 4714 return false; 4715} 4716 4717static void checkAttributesAfterMerging(Sema &S, NamedDecl &ND) { 4718 // 'weak' only applies to declarations with external linkage. 4719 if (WeakAttr *Attr = ND.getAttr<WeakAttr>()) { 4720 if (!ND.isExternallyVisible()) { 4721 S.Diag(Attr->getLocation(), diag::err_attribute_weak_static); 4722 ND.dropAttr<WeakAttr>(); 4723 } 4724 } 4725 if (WeakRefAttr *Attr = ND.getAttr<WeakRefAttr>()) { 4726 if (ND.isExternallyVisible()) { 4727 S.Diag(Attr->getLocation(), diag::err_attribute_weakref_not_static); 4728 ND.dropAttr<WeakRefAttr>(); 4729 } 4730 } 4731 4732 // 'selectany' only applies to externally visible varable declarations. 4733 // It does not apply to functions. 4734 if (SelectAnyAttr *Attr = ND.getAttr<SelectAnyAttr>()) { 4735 if (isa<FunctionDecl>(ND) || !ND.isExternallyVisible()) { 4736 S.Diag(Attr->getLocation(), diag::err_attribute_selectany_non_extern_data); 4737 ND.dropAttr<SelectAnyAttr>(); 4738 } 4739 } 4740} 4741 4742/// Given that we are within the definition of the given function, 4743/// will that definition behave like C99's 'inline', where the 4744/// definition is discarded except for optimization purposes? 4745static bool isFunctionDefinitionDiscarded(Sema &S, FunctionDecl *FD) { 4746 // Try to avoid calling GetGVALinkageForFunction. 4747 4748 // All cases of this require the 'inline' keyword. 4749 if (!FD->isInlined()) return false; 4750 4751 // This is only possible in C++ with the gnu_inline attribute. 4752 if (S.getLangOpts().CPlusPlus && !FD->hasAttr<GNUInlineAttr>()) 4753 return false; 4754 4755 // Okay, go ahead and call the relatively-more-expensive function. 4756 4757#ifndef NDEBUG 4758 // AST quite reasonably asserts that it's working on a function 4759 // definition. We don't really have a way to tell it that we're 4760 // currently defining the function, so just lie to it in +Asserts 4761 // builds. This is an awful hack. 4762 FD->setLazyBody(1); 4763#endif 4764 4765 bool isC99Inline = (S.Context.GetGVALinkageForFunction(FD) == GVA_C99Inline); 4766 4767#ifndef NDEBUG 4768 FD->setLazyBody(0); 4769#endif 4770 4771 return isC99Inline; 4772} 4773 4774/// Determine whether a variable is extern "C" prior to attaching 4775/// an initializer. We can't just call isExternC() here, because that 4776/// will also compute and cache whether the declaration is externally 4777/// visible, which might change when we attach the initializer. 4778/// 4779/// This can only be used if the declaration is known to not be a 4780/// redeclaration of an internal linkage declaration. 4781/// 4782/// For instance: 4783/// 4784/// auto x = []{}; 4785/// 4786/// Attaching the initializer here makes this declaration not externally 4787/// visible, because its type has internal linkage. 4788/// 4789/// FIXME: This is a hack. 4790template<typename T> 4791static bool isIncompleteDeclExternC(Sema &S, const T *D) { 4792 if (S.getLangOpts().CPlusPlus) { 4793 // In C++, the overloadable attribute negates the effects of extern "C". 4794 if (!D->isInExternCContext() || D->template hasAttr<OverloadableAttr>()) 4795 return false; 4796 } 4797 return D->isExternC(); 4798} 4799 4800static bool shouldConsiderLinkage(const VarDecl *VD) { 4801 const DeclContext *DC = VD->getDeclContext()->getRedeclContext(); 4802 if (DC->isFunctionOrMethod()) 4803 return VD->hasExternalStorage(); 4804 if (DC->isFileContext()) 4805 return true; 4806 if (DC->isRecord()) 4807 return false; 4808 llvm_unreachable("Unexpected context"); 4809} 4810 4811static bool shouldConsiderLinkage(const FunctionDecl *FD) { 4812 const DeclContext *DC = FD->getDeclContext()->getRedeclContext(); 4813 if (DC->isFileContext() || DC->isFunctionOrMethod()) 4814 return true; 4815 if (DC->isRecord()) 4816 return false; 4817 llvm_unreachable("Unexpected context"); 4818} 4819 4820bool Sema::HandleVariableRedeclaration(Decl *D, CXXScopeSpec &SS) { 4821 // If this is a redeclaration of a variable template or a forward 4822 // declaration of a variable template partial specialization 4823 // with nested name specifier, complain. 4824 4825 if (D && SS.isNotEmpty() && 4826 (isa<VarTemplateDecl>(D) || 4827 isa<VarTemplatePartialSpecializationDecl>(D))) { 4828 Diag(SS.getBeginLoc(), diag::err_forward_var_nested_name_specifier) 4829 << isa<VarTemplatePartialSpecializationDecl>(D) << SS.getRange(); 4830 return true; 4831 } 4832 return false; 4833} 4834 4835NamedDecl * 4836Sema::ActOnVariableDeclarator(Scope *S, Declarator &D, DeclContext *DC, 4837 TypeSourceInfo *TInfo, LookupResult &Previous, 4838 MultiTemplateParamsArg TemplateParamLists, 4839 bool &AddToScope) { 4840 QualType R = TInfo->getType(); 4841 DeclarationName Name = GetNameForDeclarator(D).getName(); 4842 4843 DeclSpec::SCS SCSpec = D.getDeclSpec().getStorageClassSpec(); 4844 VarDecl::StorageClass SC = 4845 StorageClassSpecToVarDeclStorageClass(D.getDeclSpec()); 4846 4847 if (getLangOpts().OpenCL && !getOpenCLOptions().cl_khr_fp16) { 4848 // OpenCL v1.2 s6.1.1.1: reject declaring variables of the half and 4849 // half array type (unless the cl_khr_fp16 extension is enabled). 4850 if (Context.getBaseElementType(R)->isHalfType()) { 4851 Diag(D.getIdentifierLoc(), diag::err_opencl_half_declaration) << R; 4852 D.setInvalidType(); 4853 } 4854 } 4855 4856 if (SCSpec == DeclSpec::SCS_mutable) { 4857 // mutable can only appear on non-static class members, so it's always 4858 // an error here 4859 Diag(D.getIdentifierLoc(), diag::err_mutable_nonmember); 4860 D.setInvalidType(); 4861 SC = SC_None; 4862 } 4863 4864 if (getLangOpts().CPlusPlus11 && SCSpec == DeclSpec::SCS_register && 4865 !D.getAsmLabel() && !getSourceManager().isInSystemMacro( 4866 D.getDeclSpec().getStorageClassSpecLoc())) { 4867 // In C++11, the 'register' storage class specifier is deprecated. 4868 // Suppress the warning in system macros, it's used in macros in some 4869 // popular C system headers, such as in glibc's htonl() macro. 4870 Diag(D.getDeclSpec().getStorageClassSpecLoc(), 4871 diag::warn_deprecated_register) 4872 << FixItHint::CreateRemoval(D.getDeclSpec().getStorageClassSpecLoc()); 4873 } 4874 4875 IdentifierInfo *II = Name.getAsIdentifierInfo(); 4876 if (!II) { 4877 Diag(D.getIdentifierLoc(), diag::err_bad_variable_name) 4878 << Name; 4879 return 0; 4880 } 4881 4882 DiagnoseFunctionSpecifiers(D.getDeclSpec()); 4883 4884 if (!DC->isRecord() && S->getFnParent() == 0) { 4885 // C99 6.9p2: The storage-class specifiers auto and register shall not 4886 // appear in the declaration specifiers in an external declaration. 4887 if (SC == SC_Auto || SC == SC_Register) { 4888 // If this is a register variable with an asm label specified, then this 4889 // is a GNU extension. 4890 if (SC == SC_Register && D.getAsmLabel()) 4891 Diag(D.getIdentifierLoc(), diag::err_unsupported_global_register); 4892 else 4893 Diag(D.getIdentifierLoc(), diag::err_typecheck_sclass_fscope); 4894 D.setInvalidType(); 4895 } 4896 } 4897 4898 if (getLangOpts().OpenCL) { 4899 // Set up the special work-group-local storage class for variables in the 4900 // OpenCL __local address space. 4901 if (R.getAddressSpace() == LangAS::opencl_local) { 4902 SC = SC_OpenCLWorkGroupLocal; 4903 } 4904 4905 // OpenCL v1.2 s6.9.b p4: 4906 // The sampler type cannot be used with the __local and __global address 4907 // space qualifiers. 4908 if (R->isSamplerT() && (R.getAddressSpace() == LangAS::opencl_local || 4909 R.getAddressSpace() == LangAS::opencl_global)) { 4910 Diag(D.getIdentifierLoc(), diag::err_wrong_sampler_addressspace); 4911 } 4912 4913 // OpenCL 1.2 spec, p6.9 r: 4914 // The event type cannot be used to declare a program scope variable. 4915 // The event type cannot be used with the __local, __constant and __global 4916 // address space qualifiers. 4917 if (R->isEventT()) { 4918 if (S->getParent() == 0) { 4919 Diag(D.getLocStart(), diag::err_event_t_global_var); 4920 D.setInvalidType(); 4921 } 4922 4923 if (R.getAddressSpace()) { 4924 Diag(D.getLocStart(), diag::err_event_t_addr_space_qual); 4925 D.setInvalidType(); 4926 } 4927 } 4928 } 4929 4930 bool IsExplicitSpecialization = false; 4931 bool IsVariableTemplateSpecialization = false; 4932 bool IsPartialSpecialization = false; 4933 bool IsVariableTemplate = false; 4934 bool Invalid = false; // TODO: Can we remove this (error-prone)? 4935 TemplateParameterList *TemplateParams = 0; 4936 VarTemplateDecl *PrevVarTemplate = 0; 4937 VarDecl *NewVD; 4938 if (!getLangOpts().CPlusPlus) { 4939 NewVD = VarDecl::Create(Context, DC, D.getLocStart(), 4940 D.getIdentifierLoc(), II, 4941 R, TInfo, SC); 4942 4943 if (D.isInvalidType()) 4944 NewVD->setInvalidDecl(); 4945 } else { 4946 if (DC->isRecord() && !CurContext->isRecord()) { 4947 // This is an out-of-line definition of a static data member. 4948 switch (SC) { 4949 case SC_None: 4950 break; 4951 case SC_Static: 4952 Diag(D.getDeclSpec().getStorageClassSpecLoc(), 4953 diag::err_static_out_of_line) 4954 << FixItHint::CreateRemoval(D.getDeclSpec().getStorageClassSpecLoc()); 4955 break; 4956 case SC_Auto: 4957 case SC_Register: 4958 case SC_Extern: 4959 // [dcl.stc] p2: The auto or register specifiers shall be applied only 4960 // to names of variables declared in a block or to function parameters. 4961 // [dcl.stc] p6: The extern specifier cannot be used in the declaration 4962 // of class members 4963 4964 Diag(D.getDeclSpec().getStorageClassSpecLoc(), 4965 diag::err_storage_class_for_static_member) 4966 << FixItHint::CreateRemoval(D.getDeclSpec().getStorageClassSpecLoc()); 4967 break; 4968 case SC_PrivateExtern: 4969 llvm_unreachable("C storage class in c++!"); 4970 case SC_OpenCLWorkGroupLocal: 4971 llvm_unreachable("OpenCL storage class in c++!"); 4972 } 4973 } 4974 4975 if (SC == SC_Static && CurContext->isRecord()) { 4976 if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(DC)) { 4977 if (RD->isLocalClass()) 4978 Diag(D.getIdentifierLoc(), 4979 diag::err_static_data_member_not_allowed_in_local_class) 4980 << Name << RD->getDeclName(); 4981 4982 // C++98 [class.union]p1: If a union contains a static data member, 4983 // the program is ill-formed. C++11 drops this restriction. 4984 if (RD->isUnion()) 4985 Diag(D.getIdentifierLoc(), 4986 getLangOpts().CPlusPlus11 4987 ? diag::warn_cxx98_compat_static_data_member_in_union 4988 : diag::ext_static_data_member_in_union) << Name; 4989 // We conservatively disallow static data members in anonymous structs. 4990 else if (!RD->getDeclName()) 4991 Diag(D.getIdentifierLoc(), 4992 diag::err_static_data_member_not_allowed_in_anon_struct) 4993 << Name << RD->isUnion(); 4994 } 4995 } 4996 4997 NamedDecl *PrevDecl = 0; 4998 if (Previous.begin() != Previous.end()) 4999 PrevDecl = (*Previous.begin())->getUnderlyingDecl(); 5000 PrevVarTemplate = dyn_cast_or_null<VarTemplateDecl>(PrevDecl); 5001 5002 // Match up the template parameter lists with the scope specifier, then 5003 // determine whether we have a template or a template specialization. 5004 TemplateParams = MatchTemplateParametersToScopeSpecifier( 5005 D.getDeclSpec().getLocStart(), D.getIdentifierLoc(), 5006 D.getCXXScopeSpec(), TemplateParamLists, 5007 /*never a friend*/ false, IsExplicitSpecialization, Invalid); 5008 if (TemplateParams) { 5009 if (!TemplateParams->size() && 5010 D.getName().getKind() != UnqualifiedId::IK_TemplateId) { 5011 // There is an extraneous 'template<>' for this variable. Complain 5012 // about it, but allow the declaration of the variable. 5013 Diag(TemplateParams->getTemplateLoc(), 5014 diag::err_template_variable_noparams) 5015 << II 5016 << SourceRange(TemplateParams->getTemplateLoc(), 5017 TemplateParams->getRAngleLoc()); 5018 } else { 5019 // Only C++1y supports variable templates (N3651). 5020 Diag(D.getIdentifierLoc(), 5021 getLangOpts().CPlusPlus1y 5022 ? diag::warn_cxx11_compat_variable_template 5023 : diag::ext_variable_template); 5024 5025 if (D.getName().getKind() == UnqualifiedId::IK_TemplateId) { 5026 // This is an explicit specialization or a partial specialization. 5027 // Check that we can declare a specialization here 5028 5029 IsVariableTemplateSpecialization = true; 5030 IsPartialSpecialization = TemplateParams->size() > 0; 5031 5032 } else { // if (TemplateParams->size() > 0) 5033 // This is a template declaration. 5034 IsVariableTemplate = true; 5035 5036 // Check that we can declare a template here. 5037 if (CheckTemplateDeclScope(S, TemplateParams)) 5038 return 0; 5039 5040 // If there is a previous declaration with the same name, check 5041 // whether this is a valid redeclaration. 5042 if (PrevDecl && !isDeclInScope(PrevDecl, DC, S)) 5043 PrevDecl = PrevVarTemplate = 0; 5044 5045 if (PrevVarTemplate) { 5046 // Ensure that the template parameter lists are compatible. 5047 if (!TemplateParameterListsAreEqual( 5048 TemplateParams, PrevVarTemplate->getTemplateParameters(), 5049 /*Complain=*/true, TPL_TemplateMatch)) 5050 return 0; 5051 } else if (PrevDecl && PrevDecl->isTemplateParameter()) { 5052 // Maybe we will complain about the shadowed template parameter. 5053 DiagnoseTemplateParameterShadow(D.getIdentifierLoc(), PrevDecl); 5054 5055 // Just pretend that we didn't see the previous declaration. 5056 PrevDecl = 0; 5057 } else if (PrevDecl) { 5058 // C++ [temp]p5: 5059 // ... a template name declared in namespace scope or in class 5060 // scope shall be unique in that scope. 5061 Diag(D.getIdentifierLoc(), diag::err_redefinition_different_kind) 5062 << Name; 5063 Diag(PrevDecl->getLocation(), diag::note_previous_definition); 5064 return 0; 5065 } 5066 5067 // Check the template parameter list of this declaration, possibly 5068 // merging in the template parameter list from the previous variable 5069 // template declaration. 5070 if (CheckTemplateParameterList( 5071 TemplateParams, 5072 PrevVarTemplate ? PrevVarTemplate->getTemplateParameters() 5073 : 0, 5074 (D.getCXXScopeSpec().isSet() && DC && DC->isRecord() && 5075 DC->isDependentContext()) 5076 ? TPC_ClassTemplateMember 5077 : TPC_VarTemplate)) 5078 Invalid = true; 5079 5080 if (D.getCXXScopeSpec().isSet()) { 5081 // If the name of the template was qualified, we must be defining 5082 // the template out-of-line. 5083 if (!D.getCXXScopeSpec().isInvalid() && !Invalid && 5084 !PrevVarTemplate) { 5085 Diag(D.getIdentifierLoc(), diag::err_member_decl_does_not_match) 5086 << Name << DC << /*IsDefinition*/true 5087 << D.getCXXScopeSpec().getRange(); 5088 Invalid = true; 5089 } 5090 } 5091 } 5092 } 5093 } else if (D.getName().getKind() == UnqualifiedId::IK_TemplateId) { 5094 TemplateIdAnnotation *TemplateId = D.getName().TemplateId; 5095 5096 // We have encountered something that the user meant to be a 5097 // specialization (because it has explicitly-specified template 5098 // arguments) but that was not introduced with a "template<>" (or had 5099 // too few of them). 5100 // FIXME: Differentiate between attempts for explicit instantiations 5101 // (starting with "template") and the rest. 5102 Diag(D.getIdentifierLoc(), diag::err_template_spec_needs_header) 5103 << SourceRange(TemplateId->LAngleLoc, TemplateId->RAngleLoc) 5104 << FixItHint::CreateInsertion(D.getDeclSpec().getLocStart(), 5105 "template<> "); 5106 IsVariableTemplateSpecialization = true; 5107 } 5108 5109 if (IsVariableTemplateSpecialization) { 5110 if (!PrevVarTemplate) { 5111 Diag(D.getIdentifierLoc(), diag::err_var_spec_no_template) 5112 << IsPartialSpecialization; 5113 return 0; 5114 } 5115 5116 SourceLocation TemplateKWLoc = 5117 TemplateParamLists.size() > 0 5118 ? TemplateParamLists[0]->getTemplateLoc() 5119 : SourceLocation(); 5120 DeclResult Res = ActOnVarTemplateSpecialization( 5121 S, PrevVarTemplate, D, TInfo, TemplateKWLoc, TemplateParams, SC, 5122 IsPartialSpecialization); 5123 if (Res.isInvalid()) 5124 return 0; 5125 NewVD = cast<VarDecl>(Res.get()); 5126 AddToScope = false; 5127 } else 5128 NewVD = VarDecl::Create(Context, DC, D.getLocStart(), 5129 D.getIdentifierLoc(), II, R, TInfo, SC); 5130 5131 // If this decl has an auto type in need of deduction, make a note of the 5132 // Decl so we can diagnose uses of it in its own initializer. 5133 if (D.getDeclSpec().containsPlaceholderType() && R->getContainedAutoType()) 5134 ParsingInitForAutoVars.insert(NewVD); 5135 5136 if (D.isInvalidType() || Invalid) 5137 NewVD->setInvalidDecl(); 5138 5139 SetNestedNameSpecifier(NewVD, D); 5140 5141 // FIXME: Do we need D.getCXXScopeSpec().isSet()? 5142 if (TemplateParams && TemplateParamLists.size() > 1 && 5143 (!IsVariableTemplateSpecialization || D.getCXXScopeSpec().isSet())) { 5144 NewVD->setTemplateParameterListsInfo( 5145 Context, TemplateParamLists.size() - 1, TemplateParamLists.data()); 5146 } else if (IsVariableTemplateSpecialization || 5147 (!TemplateParams && TemplateParamLists.size() > 0 && 5148 (D.getCXXScopeSpec().isSet()))) { 5149 NewVD->setTemplateParameterListsInfo(Context, 5150 TemplateParamLists.size(), 5151 TemplateParamLists.data()); 5152 } 5153 5154 if (D.getDeclSpec().isConstexprSpecified()) 5155 NewVD->setConstexpr(true); 5156 } 5157 5158 // Set the lexical context. If the declarator has a C++ scope specifier, the 5159 // lexical context will be different from the semantic context. 5160 NewVD->setLexicalDeclContext(CurContext); 5161 5162 if (DeclSpec::TSCS TSCS = D.getDeclSpec().getThreadStorageClassSpec()) { 5163 if (NewVD->hasLocalStorage()) { 5164 // C++11 [dcl.stc]p4: 5165 // When thread_local is applied to a variable of block scope the 5166 // storage-class-specifier static is implied if it does not appear 5167 // explicitly. 5168 // Core issue: 'static' is not implied if the variable is declared 5169 // 'extern'. 5170 if (SCSpec == DeclSpec::SCS_unspecified && 5171 TSCS == DeclSpec::TSCS_thread_local && 5172 DC->isFunctionOrMethod()) 5173 NewVD->setTSCSpec(TSCS); 5174 else 5175 Diag(D.getDeclSpec().getThreadStorageClassSpecLoc(), 5176 diag::err_thread_non_global) 5177 << DeclSpec::getSpecifierName(TSCS); 5178 } else if (!Context.getTargetInfo().isTLSSupported()) 5179 Diag(D.getDeclSpec().getThreadStorageClassSpecLoc(), 5180 diag::err_thread_unsupported); 5181 else 5182 NewVD->setTSCSpec(TSCS); 5183 } 5184 5185 // C99 6.7.4p3 5186 // An inline definition of a function with external linkage shall 5187 // not contain a definition of a modifiable object with static or 5188 // thread storage duration... 5189 // We only apply this when the function is required to be defined 5190 // elsewhere, i.e. when the function is not 'extern inline'. Note 5191 // that a local variable with thread storage duration still has to 5192 // be marked 'static'. Also note that it's possible to get these 5193 // semantics in C++ using __attribute__((gnu_inline)). 5194 if (SC == SC_Static && S->getFnParent() != 0 && 5195 !NewVD->getType().isConstQualified()) { 5196 FunctionDecl *CurFD = getCurFunctionDecl(); 5197 if (CurFD && isFunctionDefinitionDiscarded(*this, CurFD)) { 5198 Diag(D.getDeclSpec().getStorageClassSpecLoc(), 5199 diag::warn_static_local_in_extern_inline); 5200 MaybeSuggestAddingStaticToDecl(CurFD); 5201 } 5202 } 5203 5204 if (D.getDeclSpec().isModulePrivateSpecified()) { 5205 if (IsVariableTemplateSpecialization) 5206 Diag(NewVD->getLocation(), diag::err_module_private_specialization) 5207 << (IsPartialSpecialization ? 1 : 0) 5208 << FixItHint::CreateRemoval( 5209 D.getDeclSpec().getModulePrivateSpecLoc()); 5210 else if (IsExplicitSpecialization) 5211 Diag(NewVD->getLocation(), diag::err_module_private_specialization) 5212 << 2 5213 << FixItHint::CreateRemoval(D.getDeclSpec().getModulePrivateSpecLoc()); 5214 else if (NewVD->hasLocalStorage()) 5215 Diag(NewVD->getLocation(), diag::err_module_private_local) 5216 << 0 << NewVD->getDeclName() 5217 << SourceRange(D.getDeclSpec().getModulePrivateSpecLoc()) 5218 << FixItHint::CreateRemoval(D.getDeclSpec().getModulePrivateSpecLoc()); 5219 else 5220 NewVD->setModulePrivate(); 5221 } 5222 5223 // Handle attributes prior to checking for duplicates in MergeVarDecl 5224 ProcessDeclAttributes(S, NewVD, D); 5225 5226 if (NewVD->hasAttrs()) 5227 CheckAlignasUnderalignment(NewVD); 5228 5229 if (getLangOpts().CUDA) { 5230 // CUDA B.2.5: "__shared__ and __constant__ variables have implied static 5231 // storage [duration]." 5232 if (SC == SC_None && S->getFnParent() != 0 && 5233 (NewVD->hasAttr<CUDASharedAttr>() || 5234 NewVD->hasAttr<CUDAConstantAttr>())) { 5235 NewVD->setStorageClass(SC_Static); 5236 } 5237 } 5238 5239 // In auto-retain/release, infer strong retension for variables of 5240 // retainable type. 5241 if (getLangOpts().ObjCAutoRefCount && inferObjCARCLifetime(NewVD)) 5242 NewVD->setInvalidDecl(); 5243 5244 // Handle GNU asm-label extension (encoded as an attribute). 5245 if (Expr *E = (Expr*)D.getAsmLabel()) { 5246 // The parser guarantees this is a string. 5247 StringLiteral *SE = cast<StringLiteral>(E); 5248 StringRef Label = SE->getString(); 5249 if (S->getFnParent() != 0) { 5250 switch (SC) { 5251 case SC_None: 5252 case SC_Auto: 5253 Diag(E->getExprLoc(), diag::warn_asm_label_on_auto_decl) << Label; 5254 break; 5255 case SC_Register: 5256 if (!Context.getTargetInfo().isValidGCCRegisterName(Label)) 5257 Diag(E->getExprLoc(), diag::err_asm_unknown_register_name) << Label; 5258 break; 5259 case SC_Static: 5260 case SC_Extern: 5261 case SC_PrivateExtern: 5262 case SC_OpenCLWorkGroupLocal: 5263 break; 5264 } 5265 } 5266 5267 NewVD->addAttr(::new (Context) AsmLabelAttr(SE->getStrTokenLoc(0), 5268 Context, Label)); 5269 } else if (!ExtnameUndeclaredIdentifiers.empty()) { 5270 llvm::DenseMap<IdentifierInfo*,AsmLabelAttr*>::iterator I = 5271 ExtnameUndeclaredIdentifiers.find(NewVD->getIdentifier()); 5272 if (I != ExtnameUndeclaredIdentifiers.end()) { 5273 NewVD->addAttr(I->second); 5274 ExtnameUndeclaredIdentifiers.erase(I); 5275 } 5276 } 5277 5278 // Diagnose shadowed variables before filtering for scope. 5279 // FIXME: Special treatment for static variable template members (?). 5280 if (!D.getCXXScopeSpec().isSet()) 5281 CheckShadow(S, NewVD, Previous); 5282 5283 // Don't consider existing declarations that are in a different 5284 // scope and are out-of-semantic-context declarations (if the new 5285 // declaration has linkage). 5286 FilterLookupForScope( 5287 Previous, DC, S, shouldConsiderLinkage(NewVD), 5288 IsExplicitSpecialization || IsVariableTemplateSpecialization); 5289 5290 // Check whether the previous declaration is in the same block scope. This 5291 // affects whether we merge types with it, per C++11 [dcl.array]p3. 5292 if (getLangOpts().CPlusPlus && 5293 NewVD->isLocalVarDecl() && NewVD->hasExternalStorage()) 5294 NewVD->setPreviousDeclInSameBlockScope( 5295 Previous.isSingleResult() && !Previous.isShadowed() && 5296 isDeclInScope(Previous.getFoundDecl(), DC, S, false)); 5297 5298 if (!getLangOpts().CPlusPlus) { 5299 D.setRedeclaration(CheckVariableDeclaration(NewVD, Previous)); 5300 } else { 5301 // Merge the decl with the existing one if appropriate. 5302 if (!Previous.empty()) { 5303 if (Previous.isSingleResult() && 5304 isa<FieldDecl>(Previous.getFoundDecl()) && 5305 D.getCXXScopeSpec().isSet()) { 5306 // The user tried to define a non-static data member 5307 // out-of-line (C++ [dcl.meaning]p1). 5308 Diag(NewVD->getLocation(), diag::err_nonstatic_member_out_of_line) 5309 << D.getCXXScopeSpec().getRange(); 5310 Previous.clear(); 5311 NewVD->setInvalidDecl(); 5312 } 5313 } else if (D.getCXXScopeSpec().isSet()) { 5314 // No previous declaration in the qualifying scope. 5315 Diag(D.getIdentifierLoc(), diag::err_no_member) 5316 << Name << computeDeclContext(D.getCXXScopeSpec(), true) 5317 << D.getCXXScopeSpec().getRange(); 5318 NewVD->setInvalidDecl(); 5319 } 5320 5321 if (!IsVariableTemplateSpecialization) { 5322 if (PrevVarTemplate) { 5323 LookupResult PrevDecl(*this, GetNameForDeclarator(D), 5324 LookupOrdinaryName, ForRedeclaration); 5325 PrevDecl.addDecl(PrevVarTemplate->getTemplatedDecl()); 5326 D.setRedeclaration( 5327 CheckVariableDeclaration(NewVD, PrevDecl, IsVariableTemplate)); 5328 } else 5329 D.setRedeclaration( 5330 CheckVariableDeclaration(NewVD, Previous, IsVariableTemplate)); 5331 } 5332 5333 // This is an explicit specialization of a static data member. Check it. 5334 // FIXME: Special treatment for static variable template members (?). 5335 if (IsExplicitSpecialization && !NewVD->isInvalidDecl() && 5336 CheckMemberSpecialization(NewVD, Previous)) 5337 NewVD->setInvalidDecl(); 5338 } 5339 5340 ProcessPragmaWeak(S, NewVD); 5341 checkAttributesAfterMerging(*this, *NewVD); 5342 5343 // If this is the first declaration of an extern C variable, update 5344 // the map of such variables. 5345 if (!NewVD->getPreviousDecl() && !NewVD->isInvalidDecl() && 5346 isIncompleteDeclExternC(*this, NewVD)) 5347 RegisterLocallyScopedExternCDecl(NewVD, S); 5348 5349 if (NewVD->isStaticLocal()) { 5350 Decl *ManglingContextDecl; 5351 if (MangleNumberingContext *MCtx = 5352 getCurrentMangleNumberContext(NewVD->getDeclContext(), 5353 ManglingContextDecl)) { 5354 Context.setManglingNumber(NewVD, MCtx->getManglingNumber(NewVD)); 5355 } 5356 } 5357 5358 // If this is not a variable template, return it now. 5359 if (!IsVariableTemplate) 5360 return NewVD; 5361 5362 // If this is supposed to be a variable template, create it as such. 5363 VarTemplateDecl *NewTemplate = 5364 VarTemplateDecl::Create(Context, DC, D.getIdentifierLoc(), Name, 5365 TemplateParams, NewVD, PrevVarTemplate); 5366 NewVD->setDescribedVarTemplate(NewTemplate); 5367 5368 if (D.getDeclSpec().isModulePrivateSpecified()) 5369 NewTemplate->setModulePrivate(); 5370 5371 // If we are providing an explicit specialization of a static variable 5372 // template, make a note of that. 5373 if (PrevVarTemplate && PrevVarTemplate->getInstantiatedFromMemberTemplate()) 5374 NewTemplate->setMemberSpecialization(); 5375 5376 // Set the lexical context of this template 5377 NewTemplate->setLexicalDeclContext(CurContext); 5378 if (NewVD->isStaticDataMember() && NewVD->isOutOfLine()) 5379 NewTemplate->setAccess(NewVD->getAccess()); 5380 5381 if (PrevVarTemplate) 5382 mergeDeclAttributes(NewVD, PrevVarTemplate->getTemplatedDecl()); 5383 5384 AddPushedVisibilityAttribute(NewVD); 5385 5386 PushOnScopeChains(NewTemplate, S); 5387 AddToScope = false; 5388 5389 if (Invalid) { 5390 NewTemplate->setInvalidDecl(); 5391 NewVD->setInvalidDecl(); 5392 } 5393 5394 ActOnDocumentableDecl(NewTemplate); 5395 5396 return NewTemplate; 5397} 5398 5399/// \brief Diagnose variable or built-in function shadowing. Implements 5400/// -Wshadow. 5401/// 5402/// This method is called whenever a VarDecl is added to a "useful" 5403/// scope. 5404/// 5405/// \param S the scope in which the shadowing name is being declared 5406/// \param R the lookup of the name 5407/// 5408void Sema::CheckShadow(Scope *S, VarDecl *D, const LookupResult& R) { 5409 // Return if warning is ignored. 5410 if (Diags.getDiagnosticLevel(diag::warn_decl_shadow, R.getNameLoc()) == 5411 DiagnosticsEngine::Ignored) 5412 return; 5413 5414 // Don't diagnose declarations at file scope. 5415 if (D->hasGlobalStorage()) 5416 return; 5417 5418 DeclContext *NewDC = D->getDeclContext(); 5419 5420 // Only diagnose if we're shadowing an unambiguous field or variable. 5421 if (R.getResultKind() != LookupResult::Found) 5422 return; 5423 5424 NamedDecl* ShadowedDecl = R.getFoundDecl(); 5425 if (!isa<VarDecl>(ShadowedDecl) && !isa<FieldDecl>(ShadowedDecl)) 5426 return; 5427 5428 // Fields are not shadowed by variables in C++ static methods. 5429 if (isa<FieldDecl>(ShadowedDecl)) 5430 if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(NewDC)) 5431 if (MD->isStatic()) 5432 return; 5433 5434 if (VarDecl *shadowedVar = dyn_cast<VarDecl>(ShadowedDecl)) 5435 if (shadowedVar->isExternC()) { 5436 // For shadowing external vars, make sure that we point to the global 5437 // declaration, not a locally scoped extern declaration. 5438 for (VarDecl::redecl_iterator 5439 I = shadowedVar->redecls_begin(), E = shadowedVar->redecls_end(); 5440 I != E; ++I) 5441 if (I->isFileVarDecl()) { 5442 ShadowedDecl = *I; 5443 break; 5444 } 5445 } 5446 5447 DeclContext *OldDC = ShadowedDecl->getDeclContext(); 5448 5449 // Only warn about certain kinds of shadowing for class members. 5450 if (NewDC && NewDC->isRecord()) { 5451 // In particular, don't warn about shadowing non-class members. 5452 if (!OldDC->isRecord()) 5453 return; 5454 5455 // TODO: should we warn about static data members shadowing 5456 // static data members from base classes? 5457 5458 // TODO: don't diagnose for inaccessible shadowed members. 5459 // This is hard to do perfectly because we might friend the 5460 // shadowing context, but that's just a false negative. 5461 } 5462 5463 // Determine what kind of declaration we're shadowing. 5464 unsigned Kind; 5465 if (isa<RecordDecl>(OldDC)) { 5466 if (isa<FieldDecl>(ShadowedDecl)) 5467 Kind = 3; // field 5468 else 5469 Kind = 2; // static data member 5470 } else if (OldDC->isFileContext()) 5471 Kind = 1; // global 5472 else 5473 Kind = 0; // local 5474 5475 DeclarationName Name = R.getLookupName(); 5476 5477 // Emit warning and note. 5478 Diag(R.getNameLoc(), diag::warn_decl_shadow) << Name << Kind << OldDC; 5479 Diag(ShadowedDecl->getLocation(), diag::note_previous_declaration); 5480} 5481 5482/// \brief Check -Wshadow without the advantage of a previous lookup. 5483void Sema::CheckShadow(Scope *S, VarDecl *D) { 5484 if (Diags.getDiagnosticLevel(diag::warn_decl_shadow, D->getLocation()) == 5485 DiagnosticsEngine::Ignored) 5486 return; 5487 5488 LookupResult R(*this, D->getDeclName(), D->getLocation(), 5489 Sema::LookupOrdinaryName, Sema::ForRedeclaration); 5490 LookupName(R, S); 5491 CheckShadow(S, D, R); 5492} 5493 5494/// Check for conflict between this global or extern "C" declaration and 5495/// previous global or extern "C" declarations. This is only used in C++. 5496template<typename T> 5497static bool checkGlobalOrExternCConflict( 5498 Sema &S, const T *ND, bool IsGlobal, LookupResult &Previous) { 5499 assert(S.getLangOpts().CPlusPlus && "only C++ has extern \"C\""); 5500 NamedDecl *Prev = S.findLocallyScopedExternCDecl(ND->getDeclName()); 5501 5502 if (!Prev && IsGlobal && !isIncompleteDeclExternC(S, ND)) { 5503 // The common case: this global doesn't conflict with any extern "C" 5504 // declaration. 5505 return false; 5506 } 5507 5508 if (Prev) { 5509 if (!IsGlobal || isIncompleteDeclExternC(S, ND)) { 5510 // Both the old and new declarations have C language linkage. This is a 5511 // redeclaration. 5512 Previous.clear(); 5513 Previous.addDecl(Prev); 5514 return true; 5515 } 5516 5517 // This is a global, non-extern "C" declaration, and there is a previous 5518 // non-global extern "C" declaration. Diagnose if this is a variable 5519 // declaration. 5520 if (!isa<VarDecl>(ND)) 5521 return false; 5522 } else { 5523 // The declaration is extern "C". Check for any declaration in the 5524 // translation unit which might conflict. 5525 if (IsGlobal) { 5526 // We have already performed the lookup into the translation unit. 5527 IsGlobal = false; 5528 for (LookupResult::iterator I = Previous.begin(), E = Previous.end(); 5529 I != E; ++I) { 5530 if (isa<VarDecl>(*I)) { 5531 Prev = *I; 5532 break; 5533 } 5534 } 5535 } else { 5536 DeclContext::lookup_result R = 5537 S.Context.getTranslationUnitDecl()->lookup(ND->getDeclName()); 5538 for (DeclContext::lookup_result::iterator I = R.begin(), E = R.end(); 5539 I != E; ++I) { 5540 if (isa<VarDecl>(*I)) { 5541 Prev = *I; 5542 break; 5543 } 5544 // FIXME: If we have any other entity with this name in global scope, 5545 // the declaration is ill-formed, but that is a defect: it breaks the 5546 // 'stat' hack, for instance. Only variables can have mangled name 5547 // clashes with extern "C" declarations, so only they deserve a 5548 // diagnostic. 5549 } 5550 } 5551 5552 if (!Prev) 5553 return false; 5554 } 5555 5556 // Use the first declaration's location to ensure we point at something which 5557 // is lexically inside an extern "C" linkage-spec. 5558 assert(Prev && "should have found a previous declaration to diagnose"); 5559 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(Prev)) 5560 Prev = FD->getFirstDeclaration(); 5561 else 5562 Prev = cast<VarDecl>(Prev)->getFirstDeclaration(); 5563 5564 S.Diag(ND->getLocation(), diag::err_extern_c_global_conflict) 5565 << IsGlobal << ND; 5566 S.Diag(Prev->getLocation(), diag::note_extern_c_global_conflict) 5567 << IsGlobal; 5568 return false; 5569} 5570 5571/// Apply special rules for handling extern "C" declarations. Returns \c true 5572/// if we have found that this is a redeclaration of some prior entity. 5573/// 5574/// Per C++ [dcl.link]p6: 5575/// Two declarations [for a function or variable] with C language linkage 5576/// with the same name that appear in different scopes refer to the same 5577/// [entity]. An entity with C language linkage shall not be declared with 5578/// the same name as an entity in global scope. 5579template<typename T> 5580static bool checkForConflictWithNonVisibleExternC(Sema &S, const T *ND, 5581 LookupResult &Previous) { 5582 if (!S.getLangOpts().CPlusPlus) { 5583 // In C, when declaring a global variable, look for a corresponding 'extern' 5584 // variable declared in function scope. 5585 // 5586 // FIXME: The corresponding case in C++ does not work. We should instead 5587 // set the semantic DC for an extern local variable to be the innermost 5588 // enclosing namespace, and ensure they are only found by redeclaration 5589 // lookup. 5590 if (ND->getDeclContext()->getRedeclContext()->isTranslationUnit()) { 5591 if (NamedDecl *Prev = S.findLocallyScopedExternCDecl(ND->getDeclName())) { 5592 Previous.clear(); 5593 Previous.addDecl(Prev); 5594 return true; 5595 } 5596 } 5597 return false; 5598 } 5599 5600 // A declaration in the translation unit can conflict with an extern "C" 5601 // declaration. 5602 if (ND->getDeclContext()->getRedeclContext()->isTranslationUnit()) 5603 return checkGlobalOrExternCConflict(S, ND, /*IsGlobal*/true, Previous); 5604 5605 // An extern "C" declaration can conflict with a declaration in the 5606 // translation unit or can be a redeclaration of an extern "C" declaration 5607 // in another scope. 5608 if (isIncompleteDeclExternC(S,ND)) 5609 return checkGlobalOrExternCConflict(S, ND, /*IsGlobal*/false, Previous); 5610 5611 // Neither global nor extern "C": nothing to do. 5612 return false; 5613} 5614 5615void Sema::CheckVariableDeclarationType(VarDecl *NewVD) { 5616 // If the decl is already known invalid, don't check it. 5617 if (NewVD->isInvalidDecl()) 5618 return; 5619 5620 TypeSourceInfo *TInfo = NewVD->getTypeSourceInfo(); 5621 QualType T = TInfo->getType(); 5622 5623 // Defer checking an 'auto' type until its initializer is attached. 5624 if (T->isUndeducedType()) 5625 return; 5626 5627 if (T->isObjCObjectType()) { 5628 Diag(NewVD->getLocation(), diag::err_statically_allocated_object) 5629 << FixItHint::CreateInsertion(NewVD->getLocation(), "*"); 5630 T = Context.getObjCObjectPointerType(T); 5631 NewVD->setType(T); 5632 } 5633 5634 // Emit an error if an address space was applied to decl with local storage. 5635 // This includes arrays of objects with address space qualifiers, but not 5636 // automatic variables that point to other address spaces. 5637 // ISO/IEC TR 18037 S5.1.2 5638 if (NewVD->hasLocalStorage() && T.getAddressSpace() != 0) { 5639 Diag(NewVD->getLocation(), diag::err_as_qualified_auto_decl); 5640 NewVD->setInvalidDecl(); 5641 return; 5642 } 5643 5644 // OpenCL v1.2 s6.5 - All program scope variables must be declared in the 5645 // __constant address space. 5646 if (getLangOpts().OpenCL && NewVD->isFileVarDecl() 5647 && T.getAddressSpace() != LangAS::opencl_constant 5648 && !T->isSamplerT()){ 5649 Diag(NewVD->getLocation(), diag::err_opencl_global_invalid_addr_space); 5650 NewVD->setInvalidDecl(); 5651 return; 5652 } 5653 5654 // OpenCL v1.2 s6.8 -- The static qualifier is valid only in program 5655 // scope. 5656 if ((getLangOpts().OpenCLVersion >= 120) 5657 && NewVD->isStaticLocal()) { 5658 Diag(NewVD->getLocation(), diag::err_static_function_scope); 5659 NewVD->setInvalidDecl(); 5660 return; 5661 } 5662 5663 if (NewVD->hasLocalStorage() && T.isObjCGCWeak() 5664 && !NewVD->hasAttr<BlocksAttr>()) { 5665 if (getLangOpts().getGC() != LangOptions::NonGC) 5666 Diag(NewVD->getLocation(), diag::warn_gc_attribute_weak_on_local); 5667 else { 5668 assert(!getLangOpts().ObjCAutoRefCount); 5669 Diag(NewVD->getLocation(), diag::warn_attribute_weak_on_local); 5670 } 5671 } 5672 5673 bool isVM = T->isVariablyModifiedType(); 5674 if (isVM || NewVD->hasAttr<CleanupAttr>() || 5675 NewVD->hasAttr<BlocksAttr>()) 5676 getCurFunction()->setHasBranchProtectedScope(); 5677 5678 if ((isVM && NewVD->hasLinkage()) || 5679 (T->isVariableArrayType() && NewVD->hasGlobalStorage())) { 5680 bool SizeIsNegative; 5681 llvm::APSInt Oversized; 5682 TypeSourceInfo *FixedTInfo = 5683 TryToFixInvalidVariablyModifiedTypeSourceInfo(TInfo, Context, 5684 SizeIsNegative, Oversized); 5685 if (FixedTInfo == 0 && T->isVariableArrayType()) { 5686 const VariableArrayType *VAT = Context.getAsVariableArrayType(T); 5687 // FIXME: This won't give the correct result for 5688 // int a[10][n]; 5689 SourceRange SizeRange = VAT->getSizeExpr()->getSourceRange(); 5690 5691 if (NewVD->isFileVarDecl()) 5692 Diag(NewVD->getLocation(), diag::err_vla_decl_in_file_scope) 5693 << SizeRange; 5694 else if (NewVD->isStaticLocal()) 5695 Diag(NewVD->getLocation(), diag::err_vla_decl_has_static_storage) 5696 << SizeRange; 5697 else 5698 Diag(NewVD->getLocation(), diag::err_vla_decl_has_extern_linkage) 5699 << SizeRange; 5700 NewVD->setInvalidDecl(); 5701 return; 5702 } 5703 5704 if (FixedTInfo == 0) { 5705 if (NewVD->isFileVarDecl()) 5706 Diag(NewVD->getLocation(), diag::err_vm_decl_in_file_scope); 5707 else 5708 Diag(NewVD->getLocation(), diag::err_vm_decl_has_extern_linkage); 5709 NewVD->setInvalidDecl(); 5710 return; 5711 } 5712 5713 Diag(NewVD->getLocation(), diag::warn_illegal_constant_array_size); 5714 NewVD->setType(FixedTInfo->getType()); 5715 NewVD->setTypeSourceInfo(FixedTInfo); 5716 } 5717 5718 if (T->isVoidType()) { 5719 // C++98 [dcl.stc]p5: The extern specifier can be applied only to the names 5720 // of objects and functions. 5721 if (NewVD->isThisDeclarationADefinition() || getLangOpts().CPlusPlus) { 5722 Diag(NewVD->getLocation(), diag::err_typecheck_decl_incomplete_type) 5723 << T; 5724 NewVD->setInvalidDecl(); 5725 return; 5726 } 5727 } 5728 5729 if (!NewVD->hasLocalStorage() && NewVD->hasAttr<BlocksAttr>()) { 5730 Diag(NewVD->getLocation(), diag::err_block_on_nonlocal); 5731 NewVD->setInvalidDecl(); 5732 return; 5733 } 5734 5735 if (isVM && NewVD->hasAttr<BlocksAttr>()) { 5736 Diag(NewVD->getLocation(), diag::err_block_on_vm); 5737 NewVD->setInvalidDecl(); 5738 return; 5739 } 5740 5741 if (NewVD->isConstexpr() && !T->isDependentType() && 5742 RequireLiteralType(NewVD->getLocation(), T, 5743 diag::err_constexpr_var_non_literal)) { 5744 // Can't perform this check until the type is deduced. 5745 NewVD->setInvalidDecl(); 5746 return; 5747 } 5748} 5749 5750/// \brief Perform semantic checking on a newly-created variable 5751/// declaration. 5752/// 5753/// This routine performs all of the type-checking required for a 5754/// variable declaration once it has been built. It is used both to 5755/// check variables after they have been parsed and their declarators 5756/// have been translated into a declaration, and to check variables 5757/// that have been instantiated from a template. 5758/// 5759/// Sets NewVD->isInvalidDecl() if an error was encountered. 5760/// 5761/// Returns true if the variable declaration is a redeclaration. 5762bool Sema::CheckVariableDeclaration(VarDecl *NewVD, 5763 LookupResult &Previous, 5764 bool IsVariableTemplate) { 5765 CheckVariableDeclarationType(NewVD); 5766 5767 // If the decl is already known invalid, don't check it. 5768 if (NewVD->isInvalidDecl()) 5769 return false; 5770 5771 // If we did not find anything by this name, look for a non-visible 5772 // extern "C" declaration with the same name. 5773 // 5774 // The actual standards text here is: 5775 // 5776 // C++11 [basic.link]p6: 5777 // The name of a function declared in block scope and the name 5778 // of a variable declared by a block scope extern declaration 5779 // have linkage. If there is a visible declaration of an entity 5780 // with linkage having the same name and type, ignoring entities 5781 // declared outside the innermost enclosing namespace scope, the 5782 // block scope declaration declares that same entity and 5783 // receives the linkage of the previous declaration. 5784 // 5785 // C++11 [dcl.array]p3: 5786 // If there is a preceding declaration of the entity in the same 5787 // scope in which the bound was specified, an omitted array bound 5788 // is taken to be the same as in that earlier declaration. 5789 // 5790 // C11 6.2.7p4: 5791 // For an identifier with internal or external linkage declared 5792 // in a scope in which a prior declaration of that identifier is 5793 // visible, if the prior declaration specifies internal or 5794 // external linkage, the type of the identifier at the later 5795 // declaration becomes the composite type. 5796 // 5797 // The most important point here is that we're not allowed to 5798 // update our understanding of the type according to declarations 5799 // not in scope (in C++) or not visible (in C). 5800 bool MergeTypeWithPrevious; 5801 if (Previous.empty() && 5802 checkForConflictWithNonVisibleExternC(*this, NewVD, Previous)) 5803 MergeTypeWithPrevious = false; 5804 else 5805 MergeTypeWithPrevious = 5806 !Previous.isShadowed() && 5807 (!getLangOpts().CPlusPlus || NewVD->isPreviousDeclInSameBlockScope() || 5808 !NewVD->getLexicalDeclContext()->isFunctionOrMethod()); 5809 5810 // Filter out any non-conflicting previous declarations. 5811 filterNonConflictingPreviousDecls(Context, NewVD, Previous); 5812 5813 if (!Previous.empty()) { 5814 MergeVarDecl(NewVD, Previous, IsVariableTemplate, MergeTypeWithPrevious); 5815 return true; 5816 } 5817 return false; 5818} 5819 5820/// \brief Data used with FindOverriddenMethod 5821struct FindOverriddenMethodData { 5822 Sema *S; 5823 CXXMethodDecl *Method; 5824}; 5825 5826/// \brief Member lookup function that determines whether a given C++ 5827/// method overrides a method in a base class, to be used with 5828/// CXXRecordDecl::lookupInBases(). 5829static bool FindOverriddenMethod(const CXXBaseSpecifier *Specifier, 5830 CXXBasePath &Path, 5831 void *UserData) { 5832 RecordDecl *BaseRecord = Specifier->getType()->getAs<RecordType>()->getDecl(); 5833 5834 FindOverriddenMethodData *Data 5835 = reinterpret_cast<FindOverriddenMethodData*>(UserData); 5836 5837 DeclarationName Name = Data->Method->getDeclName(); 5838 5839 // FIXME: Do we care about other names here too? 5840 if (Name.getNameKind() == DeclarationName::CXXDestructorName) { 5841 // We really want to find the base class destructor here. 5842 QualType T = Data->S->Context.getTypeDeclType(BaseRecord); 5843 CanQualType CT = Data->S->Context.getCanonicalType(T); 5844 5845 Name = Data->S->Context.DeclarationNames.getCXXDestructorName(CT); 5846 } 5847 5848 for (Path.Decls = BaseRecord->lookup(Name); 5849 !Path.Decls.empty(); 5850 Path.Decls = Path.Decls.slice(1)) { 5851 NamedDecl *D = Path.Decls.front(); 5852 if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(D)) { 5853 if (MD->isVirtual() && !Data->S->IsOverload(Data->Method, MD, false)) 5854 return true; 5855 } 5856 } 5857 5858 return false; 5859} 5860 5861namespace { 5862 enum OverrideErrorKind { OEK_All, OEK_NonDeleted, OEK_Deleted }; 5863} 5864/// \brief Report an error regarding overriding, along with any relevant 5865/// overriden methods. 5866/// 5867/// \param DiagID the primary error to report. 5868/// \param MD the overriding method. 5869/// \param OEK which overrides to include as notes. 5870static void ReportOverrides(Sema& S, unsigned DiagID, const CXXMethodDecl *MD, 5871 OverrideErrorKind OEK = OEK_All) { 5872 S.Diag(MD->getLocation(), DiagID) << MD->getDeclName(); 5873 for (CXXMethodDecl::method_iterator I = MD->begin_overridden_methods(), 5874 E = MD->end_overridden_methods(); 5875 I != E; ++I) { 5876 // This check (& the OEK parameter) could be replaced by a predicate, but 5877 // without lambdas that would be overkill. This is still nicer than writing 5878 // out the diag loop 3 times. 5879 if ((OEK == OEK_All) || 5880 (OEK == OEK_NonDeleted && !(*I)->isDeleted()) || 5881 (OEK == OEK_Deleted && (*I)->isDeleted())) 5882 S.Diag((*I)->getLocation(), diag::note_overridden_virtual_function); 5883 } 5884} 5885 5886/// AddOverriddenMethods - See if a method overrides any in the base classes, 5887/// and if so, check that it's a valid override and remember it. 5888bool Sema::AddOverriddenMethods(CXXRecordDecl *DC, CXXMethodDecl *MD) { 5889 // Look for virtual methods in base classes that this method might override. 5890 CXXBasePaths Paths; 5891 FindOverriddenMethodData Data; 5892 Data.Method = MD; 5893 Data.S = this; 5894 bool hasDeletedOverridenMethods = false; 5895 bool hasNonDeletedOverridenMethods = false; 5896 bool AddedAny = false; 5897 if (DC->lookupInBases(&FindOverriddenMethod, &Data, Paths)) { 5898 for (CXXBasePaths::decl_iterator I = Paths.found_decls_begin(), 5899 E = Paths.found_decls_end(); I != E; ++I) { 5900 if (CXXMethodDecl *OldMD = dyn_cast<CXXMethodDecl>(*I)) { 5901 MD->addOverriddenMethod(OldMD->getCanonicalDecl()); 5902 if (!CheckOverridingFunctionReturnType(MD, OldMD) && 5903 !CheckOverridingFunctionAttributes(MD, OldMD) && 5904 !CheckOverridingFunctionExceptionSpec(MD, OldMD) && 5905 !CheckIfOverriddenFunctionIsMarkedFinal(MD, OldMD)) { 5906 hasDeletedOverridenMethods |= OldMD->isDeleted(); 5907 hasNonDeletedOverridenMethods |= !OldMD->isDeleted(); 5908 AddedAny = true; 5909 } 5910 } 5911 } 5912 } 5913 5914 if (hasDeletedOverridenMethods && !MD->isDeleted()) { 5915 ReportOverrides(*this, diag::err_non_deleted_override, MD, OEK_Deleted); 5916 } 5917 if (hasNonDeletedOverridenMethods && MD->isDeleted()) { 5918 ReportOverrides(*this, diag::err_deleted_override, MD, OEK_NonDeleted); 5919 } 5920 5921 return AddedAny; 5922} 5923 5924namespace { 5925 // Struct for holding all of the extra arguments needed by 5926 // DiagnoseInvalidRedeclaration to call Sema::ActOnFunctionDeclarator. 5927 struct ActOnFDArgs { 5928 Scope *S; 5929 Declarator &D; 5930 MultiTemplateParamsArg TemplateParamLists; 5931 bool AddToScope; 5932 }; 5933} 5934 5935namespace { 5936 5937// Callback to only accept typo corrections that have a non-zero edit distance. 5938// Also only accept corrections that have the same parent decl. 5939class DifferentNameValidatorCCC : public CorrectionCandidateCallback { 5940 public: 5941 DifferentNameValidatorCCC(ASTContext &Context, FunctionDecl *TypoFD, 5942 CXXRecordDecl *Parent) 5943 : Context(Context), OriginalFD(TypoFD), 5944 ExpectedParent(Parent ? Parent->getCanonicalDecl() : 0) {} 5945 5946 virtual bool ValidateCandidate(const TypoCorrection &candidate) { 5947 if (candidate.getEditDistance() == 0) 5948 return false; 5949 5950 SmallVector<unsigned, 1> MismatchedParams; 5951 for (TypoCorrection::const_decl_iterator CDecl = candidate.begin(), 5952 CDeclEnd = candidate.end(); 5953 CDecl != CDeclEnd; ++CDecl) { 5954 FunctionDecl *FD = dyn_cast<FunctionDecl>(*CDecl); 5955 5956 if (FD && !FD->hasBody() && 5957 hasSimilarParameters(Context, FD, OriginalFD, MismatchedParams)) { 5958 if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) { 5959 CXXRecordDecl *Parent = MD->getParent(); 5960 if (Parent && Parent->getCanonicalDecl() == ExpectedParent) 5961 return true; 5962 } else if (!ExpectedParent) { 5963 return true; 5964 } 5965 } 5966 } 5967 5968 return false; 5969 } 5970 5971 private: 5972 ASTContext &Context; 5973 FunctionDecl *OriginalFD; 5974 CXXRecordDecl *ExpectedParent; 5975}; 5976 5977} 5978 5979/// \brief Generate diagnostics for an invalid function redeclaration. 5980/// 5981/// This routine handles generating the diagnostic messages for an invalid 5982/// function redeclaration, including finding possible similar declarations 5983/// or performing typo correction if there are no previous declarations with 5984/// the same name. 5985/// 5986/// Returns a NamedDecl iff typo correction was performed and substituting in 5987/// the new declaration name does not cause new errors. 5988static NamedDecl *DiagnoseInvalidRedeclaration( 5989 Sema &SemaRef, LookupResult &Previous, FunctionDecl *NewFD, 5990 ActOnFDArgs &ExtraArgs, bool IsLocalFriend, Scope *S) { 5991 NamedDecl *Result = NULL; 5992 DeclarationName Name = NewFD->getDeclName(); 5993 DeclContext *NewDC = NewFD->getDeclContext(); 5994 SmallVector<unsigned, 1> MismatchedParams; 5995 SmallVector<std::pair<FunctionDecl *, unsigned>, 1> NearMatches; 5996 TypoCorrection Correction; 5997 unsigned DiagMsg = IsLocalFriend ? diag::err_no_matching_local_friend 5998 : diag::err_member_decl_does_not_match; 5999 LookupResult Prev(SemaRef, Name, NewFD->getLocation(), 6000 IsLocalFriend ? Sema::LookupLocalFriendName 6001 : Sema::LookupOrdinaryName, 6002 Sema::ForRedeclaration); 6003 6004 NewFD->setInvalidDecl(); 6005 if (IsLocalFriend) 6006 SemaRef.LookupName(Prev, S); 6007 else 6008 SemaRef.LookupQualifiedName(Prev, NewDC); 6009 assert(!Prev.isAmbiguous() && 6010 "Cannot have an ambiguity in previous-declaration lookup"); 6011 CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(NewFD); 6012 DifferentNameValidatorCCC Validator(SemaRef.Context, NewFD, 6013 MD ? MD->getParent() : 0); 6014 if (!Prev.empty()) { 6015 for (LookupResult::iterator Func = Prev.begin(), FuncEnd = Prev.end(); 6016 Func != FuncEnd; ++Func) { 6017 FunctionDecl *FD = dyn_cast<FunctionDecl>(*Func); 6018 if (FD && 6019 hasSimilarParameters(SemaRef.Context, FD, NewFD, MismatchedParams)) { 6020 // Add 1 to the index so that 0 can mean the mismatch didn't 6021 // involve a parameter 6022 unsigned ParamNum = 6023 MismatchedParams.empty() ? 0 : MismatchedParams.front() + 1; 6024 NearMatches.push_back(std::make_pair(FD, ParamNum)); 6025 } 6026 } 6027 // If the qualified name lookup yielded nothing, try typo correction 6028 } else if ((Correction = SemaRef.CorrectTypo( 6029 Prev.getLookupNameInfo(), Prev.getLookupKind(), S, 0, 6030 Validator, IsLocalFriend ? 0 : NewDC))) { 6031 // Trap errors. 6032 Sema::SFINAETrap Trap(SemaRef); 6033 6034 // Set up everything for the call to ActOnFunctionDeclarator 6035 ExtraArgs.D.SetIdentifier(Correction.getCorrectionAsIdentifierInfo(), 6036 ExtraArgs.D.getIdentifierLoc()); 6037 Previous.clear(); 6038 Previous.setLookupName(Correction.getCorrection()); 6039 for (TypoCorrection::decl_iterator CDecl = Correction.begin(), 6040 CDeclEnd = Correction.end(); 6041 CDecl != CDeclEnd; ++CDecl) { 6042 FunctionDecl *FD = dyn_cast<FunctionDecl>(*CDecl); 6043 if (FD && !FD->hasBody() && 6044 hasSimilarParameters(SemaRef.Context, FD, NewFD, MismatchedParams)) { 6045 Previous.addDecl(FD); 6046 } 6047 } 6048 bool wasRedeclaration = ExtraArgs.D.isRedeclaration(); 6049 // TODO: Refactor ActOnFunctionDeclarator so that we can call only the 6050 // pieces need to verify the typo-corrected C++ declaraction and hopefully 6051 // eliminate the need for the parameter pack ExtraArgs. 6052 Result = SemaRef.ActOnFunctionDeclarator( 6053 ExtraArgs.S, ExtraArgs.D, 6054 Correction.getCorrectionDecl()->getDeclContext(), 6055 NewFD->getTypeSourceInfo(), Previous, ExtraArgs.TemplateParamLists, 6056 ExtraArgs.AddToScope); 6057 if (Trap.hasErrorOccurred()) { 6058 // Pretend the typo correction never occurred 6059 ExtraArgs.D.SetIdentifier(Name.getAsIdentifierInfo(), 6060 ExtraArgs.D.getIdentifierLoc()); 6061 ExtraArgs.D.setRedeclaration(wasRedeclaration); 6062 Previous.clear(); 6063 Previous.setLookupName(Name); 6064 Result = NULL; 6065 } else { 6066 for (LookupResult::iterator Func = Previous.begin(), 6067 FuncEnd = Previous.end(); 6068 Func != FuncEnd; ++Func) { 6069 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(*Func)) 6070 NearMatches.push_back(std::make_pair(FD, 0)); 6071 } 6072 } 6073 if (NearMatches.empty()) { 6074 // Ignore the correction if it didn't yield any close FunctionDecl matches 6075 Correction = TypoCorrection(); 6076 } else { 6077 DiagMsg = IsLocalFriend ? diag::err_no_matching_local_friend_suggest 6078 : diag::err_member_decl_does_not_match_suggest; 6079 } 6080 } 6081 6082 bool IsDefinition = ExtraArgs.D.isFunctionDefinition(); 6083 if (Correction) { 6084 // FIXME: use Correction.getCorrectionRange() instead of computing the range 6085 // here. This requires passing in the CXXScopeSpec to CorrectTypo which in 6086 // turn causes the correction to fully qualify the name. If we fix 6087 // CorrectTypo to minimally qualify then this change should be good. 6088 SourceRange FixItLoc(NewFD->getLocation()); 6089 CXXScopeSpec &SS = ExtraArgs.D.getCXXScopeSpec(); 6090 if (Correction.getCorrectionSpecifier() && SS.isValid()) 6091 FixItLoc.setBegin(SS.getBeginLoc()); 6092 SemaRef.Diag(NewFD->getLocStart(), DiagMsg) 6093 << Name << NewDC << Correction.getQuoted(SemaRef.getLangOpts()) 6094 << IsDefinition 6095 << FixItHint::CreateReplacement( 6096 FixItLoc, Correction.getAsString(SemaRef.getLangOpts())); 6097 } else { 6098 SemaRef.Diag(NewFD->getLocation(), DiagMsg) 6099 << Name << NewDC << IsDefinition << NewFD->getLocation(); 6100 } 6101 6102 bool NewFDisConst = false; 6103 if (CXXMethodDecl *NewMD = dyn_cast<CXXMethodDecl>(NewFD)) 6104 NewFDisConst = NewMD->isConst(); 6105 6106 for (SmallVectorImpl<std::pair<FunctionDecl *, unsigned> >::iterator 6107 NearMatch = NearMatches.begin(), NearMatchEnd = NearMatches.end(); 6108 NearMatch != NearMatchEnd; ++NearMatch) { 6109 FunctionDecl *FD = NearMatch->first; 6110 CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD); 6111 bool FDisConst = MD && MD->isConst(); 6112 bool IsMember = MD || !IsLocalFriend; 6113 6114 if (unsigned Idx = NearMatch->second) { 6115 ParmVarDecl *FDParam = FD->getParamDecl(Idx-1); 6116 SourceLocation Loc = FDParam->getTypeSpecStartLoc(); 6117 if (Loc.isInvalid()) Loc = FD->getLocation(); 6118 SemaRef.Diag(Loc, IsMember ? diag::note_member_def_close_param_match 6119 : diag::note_local_decl_close_param_match) 6120 << Idx << FDParam->getType() 6121 << NewFD->getParamDecl(Idx - 1)->getType(); 6122 } else if (Correction) { 6123 SemaRef.Diag(FD->getLocation(), diag::note_previous_decl) 6124 << Correction.getQuoted(SemaRef.getLangOpts()); 6125 } else if (FDisConst != NewFDisConst) { 6126 SemaRef.Diag(FD->getLocation(), diag::note_member_def_close_const_match) 6127 << NewFDisConst << FD->getSourceRange().getEnd(); 6128 } else 6129 SemaRef.Diag(FD->getLocation(), 6130 IsMember ? diag::note_member_def_close_match 6131 : diag::note_local_decl_close_match); 6132 } 6133 return Result; 6134} 6135 6136static FunctionDecl::StorageClass getFunctionStorageClass(Sema &SemaRef, 6137 Declarator &D) { 6138 switch (D.getDeclSpec().getStorageClassSpec()) { 6139 default: llvm_unreachable("Unknown storage class!"); 6140 case DeclSpec::SCS_auto: 6141 case DeclSpec::SCS_register: 6142 case DeclSpec::SCS_mutable: 6143 SemaRef.Diag(D.getDeclSpec().getStorageClassSpecLoc(), 6144 diag::err_typecheck_sclass_func); 6145 D.setInvalidType(); 6146 break; 6147 case DeclSpec::SCS_unspecified: break; 6148 case DeclSpec::SCS_extern: 6149 if (D.getDeclSpec().isExternInLinkageSpec()) 6150 return SC_None; 6151 return SC_Extern; 6152 case DeclSpec::SCS_static: { 6153 if (SemaRef.CurContext->getRedeclContext()->isFunctionOrMethod()) { 6154 // C99 6.7.1p5: 6155 // The declaration of an identifier for a function that has 6156 // block scope shall have no explicit storage-class specifier 6157 // other than extern 6158 // See also (C++ [dcl.stc]p4). 6159 SemaRef.Diag(D.getDeclSpec().getStorageClassSpecLoc(), 6160 diag::err_static_block_func); 6161 break; 6162 } else 6163 return SC_Static; 6164 } 6165 case DeclSpec::SCS_private_extern: return SC_PrivateExtern; 6166 } 6167 6168 // No explicit storage class has already been returned 6169 return SC_None; 6170} 6171 6172static FunctionDecl* CreateNewFunctionDecl(Sema &SemaRef, Declarator &D, 6173 DeclContext *DC, QualType &R, 6174 TypeSourceInfo *TInfo, 6175 FunctionDecl::StorageClass SC, 6176 bool &IsVirtualOkay) { 6177 DeclarationNameInfo NameInfo = SemaRef.GetNameForDeclarator(D); 6178 DeclarationName Name = NameInfo.getName(); 6179 6180 FunctionDecl *NewFD = 0; 6181 bool isInline = D.getDeclSpec().isInlineSpecified(); 6182 6183 if (!SemaRef.getLangOpts().CPlusPlus) { 6184 // Determine whether the function was written with a 6185 // prototype. This true when: 6186 // - there is a prototype in the declarator, or 6187 // - the type R of the function is some kind of typedef or other reference 6188 // to a type name (which eventually refers to a function type). 6189 bool HasPrototype = 6190 (D.isFunctionDeclarator() && D.getFunctionTypeInfo().hasPrototype) || 6191 (!isa<FunctionType>(R.getTypePtr()) && R->isFunctionProtoType()); 6192 6193 NewFD = FunctionDecl::Create(SemaRef.Context, DC, 6194 D.getLocStart(), NameInfo, R, 6195 TInfo, SC, isInline, 6196 HasPrototype, false); 6197 if (D.isInvalidType()) 6198 NewFD->setInvalidDecl(); 6199 6200 // Set the lexical context. 6201 NewFD->setLexicalDeclContext(SemaRef.CurContext); 6202 6203 return NewFD; 6204 } 6205 6206 bool isExplicit = D.getDeclSpec().isExplicitSpecified(); 6207 bool isConstexpr = D.getDeclSpec().isConstexprSpecified(); 6208 6209 // Check that the return type is not an abstract class type. 6210 // For record types, this is done by the AbstractClassUsageDiagnoser once 6211 // the class has been completely parsed. 6212 if (!DC->isRecord() && 6213 SemaRef.RequireNonAbstractType(D.getIdentifierLoc(), 6214 R->getAs<FunctionType>()->getResultType(), 6215 diag::err_abstract_type_in_decl, 6216 SemaRef.AbstractReturnType)) 6217 D.setInvalidType(); 6218 6219 if (Name.getNameKind() == DeclarationName::CXXConstructorName) { 6220 // This is a C++ constructor declaration. 6221 assert(DC->isRecord() && 6222 "Constructors can only be declared in a member context"); 6223 6224 R = SemaRef.CheckConstructorDeclarator(D, R, SC); 6225 return CXXConstructorDecl::Create(SemaRef.Context, cast<CXXRecordDecl>(DC), 6226 D.getLocStart(), NameInfo, 6227 R, TInfo, isExplicit, isInline, 6228 /*isImplicitlyDeclared=*/false, 6229 isConstexpr); 6230 6231 } else if (Name.getNameKind() == DeclarationName::CXXDestructorName) { 6232 // This is a C++ destructor declaration. 6233 if (DC->isRecord()) { 6234 R = SemaRef.CheckDestructorDeclarator(D, R, SC); 6235 CXXRecordDecl *Record = cast<CXXRecordDecl>(DC); 6236 CXXDestructorDecl *NewDD = CXXDestructorDecl::Create( 6237 SemaRef.Context, Record, 6238 D.getLocStart(), 6239 NameInfo, R, TInfo, isInline, 6240 /*isImplicitlyDeclared=*/false); 6241 6242 // If the class is complete, then we now create the implicit exception 6243 // specification. If the class is incomplete or dependent, we can't do 6244 // it yet. 6245 if (SemaRef.getLangOpts().CPlusPlus11 && !Record->isDependentType() && 6246 Record->getDefinition() && !Record->isBeingDefined() && 6247 R->getAs<FunctionProtoType>()->getExceptionSpecType() == EST_None) { 6248 SemaRef.AdjustDestructorExceptionSpec(Record, NewDD); 6249 } 6250 6251 // The Microsoft ABI requires that we perform the destructor body 6252 // checks (i.e. operator delete() lookup) at every declaration, as 6253 // any translation unit may need to emit a deleting destructor. 6254 if (SemaRef.Context.getTargetInfo().getCXXABI().isMicrosoft() && 6255 !Record->isDependentType() && Record->getDefinition() && 6256 !Record->isBeingDefined()) { 6257 SemaRef.CheckDestructor(NewDD); 6258 } 6259 6260 IsVirtualOkay = true; 6261 return NewDD; 6262 6263 } else { 6264 SemaRef.Diag(D.getIdentifierLoc(), diag::err_destructor_not_member); 6265 D.setInvalidType(); 6266 6267 // Create a FunctionDecl to satisfy the function definition parsing 6268 // code path. 6269 return FunctionDecl::Create(SemaRef.Context, DC, 6270 D.getLocStart(), 6271 D.getIdentifierLoc(), Name, R, TInfo, 6272 SC, isInline, 6273 /*hasPrototype=*/true, isConstexpr); 6274 } 6275 6276 } else if (Name.getNameKind() == DeclarationName::CXXConversionFunctionName) { 6277 if (!DC->isRecord()) { 6278 SemaRef.Diag(D.getIdentifierLoc(), 6279 diag::err_conv_function_not_member); 6280 return 0; 6281 } 6282 6283 SemaRef.CheckConversionDeclarator(D, R, SC); 6284 IsVirtualOkay = true; 6285 return CXXConversionDecl::Create(SemaRef.Context, cast<CXXRecordDecl>(DC), 6286 D.getLocStart(), NameInfo, 6287 R, TInfo, isInline, isExplicit, 6288 isConstexpr, SourceLocation()); 6289 6290 } else if (DC->isRecord()) { 6291 // If the name of the function is the same as the name of the record, 6292 // then this must be an invalid constructor that has a return type. 6293 // (The parser checks for a return type and makes the declarator a 6294 // constructor if it has no return type). 6295 if (Name.getAsIdentifierInfo() && 6296 Name.getAsIdentifierInfo() == cast<CXXRecordDecl>(DC)->getIdentifier()){ 6297 SemaRef.Diag(D.getIdentifierLoc(), diag::err_constructor_return_type) 6298 << SourceRange(D.getDeclSpec().getTypeSpecTypeLoc()) 6299 << SourceRange(D.getIdentifierLoc()); 6300 return 0; 6301 } 6302 6303 // This is a C++ method declaration. 6304 CXXMethodDecl *Ret = CXXMethodDecl::Create(SemaRef.Context, 6305 cast<CXXRecordDecl>(DC), 6306 D.getLocStart(), NameInfo, R, 6307 TInfo, SC, isInline, 6308 isConstexpr, SourceLocation()); 6309 IsVirtualOkay = !Ret->isStatic(); 6310 return Ret; 6311 } else { 6312 // Determine whether the function was written with a 6313 // prototype. This true when: 6314 // - we're in C++ (where every function has a prototype), 6315 return FunctionDecl::Create(SemaRef.Context, DC, 6316 D.getLocStart(), 6317 NameInfo, R, TInfo, SC, isInline, 6318 true/*HasPrototype*/, isConstexpr); 6319 } 6320} 6321 6322void Sema::checkVoidParamDecl(ParmVarDecl *Param) { 6323 // In C++, the empty parameter-type-list must be spelled "void"; a 6324 // typedef of void is not permitted. 6325 if (getLangOpts().CPlusPlus && 6326 Param->getType().getUnqualifiedType() != Context.VoidTy) { 6327 bool IsTypeAlias = false; 6328 if (const TypedefType *TT = Param->getType()->getAs<TypedefType>()) 6329 IsTypeAlias = isa<TypeAliasDecl>(TT->getDecl()); 6330 else if (const TemplateSpecializationType *TST = 6331 Param->getType()->getAs<TemplateSpecializationType>()) 6332 IsTypeAlias = TST->isTypeAlias(); 6333 Diag(Param->getLocation(), diag::err_param_typedef_of_void) 6334 << IsTypeAlias; 6335 } 6336} 6337 6338enum OpenCLParamType { 6339 ValidKernelParam, 6340 PtrPtrKernelParam, 6341 PtrKernelParam, 6342 InvalidKernelParam, 6343 RecordKernelParam 6344}; 6345 6346static OpenCLParamType getOpenCLKernelParameterType(QualType PT) { 6347 if (PT->isPointerType()) { 6348 QualType PointeeType = PT->getPointeeType(); 6349 return PointeeType->isPointerType() ? PtrPtrKernelParam : PtrKernelParam; 6350 } 6351 6352 // TODO: Forbid the other integer types (size_t, ptrdiff_t...) when they can 6353 // be used as builtin types. 6354 6355 if (PT->isImageType()) 6356 return PtrKernelParam; 6357 6358 if (PT->isBooleanType()) 6359 return InvalidKernelParam; 6360 6361 if (PT->isEventT()) 6362 return InvalidKernelParam; 6363 6364 if (PT->isHalfType()) 6365 return InvalidKernelParam; 6366 6367 if (PT->isRecordType()) 6368 return RecordKernelParam; 6369 6370 return ValidKernelParam; 6371} 6372 6373static void checkIsValidOpenCLKernelParameter( 6374 Sema &S, 6375 Declarator &D, 6376 ParmVarDecl *Param, 6377 llvm::SmallPtrSet<const Type *, 16> &ValidTypes) { 6378 QualType PT = Param->getType(); 6379 6380 // Cache the valid types we encounter to avoid rechecking structs that are 6381 // used again 6382 if (ValidTypes.count(PT.getTypePtr())) 6383 return; 6384 6385 switch (getOpenCLKernelParameterType(PT)) { 6386 case PtrPtrKernelParam: 6387 // OpenCL v1.2 s6.9.a: 6388 // A kernel function argument cannot be declared as a 6389 // pointer to a pointer type. 6390 S.Diag(Param->getLocation(), diag::err_opencl_ptrptr_kernel_param); 6391 D.setInvalidType(); 6392 return; 6393 6394 // OpenCL v1.2 s6.9.k: 6395 // Arguments to kernel functions in a program cannot be declared with the 6396 // built-in scalar types bool, half, size_t, ptrdiff_t, intptr_t, and 6397 // uintptr_t or a struct and/or union that contain fields declared to be 6398 // one of these built-in scalar types. 6399 6400 case InvalidKernelParam: 6401 // OpenCL v1.2 s6.8 n: 6402 // A kernel function argument cannot be declared 6403 // of event_t type. 6404 S.Diag(Param->getLocation(), diag::err_bad_kernel_param_type) << PT; 6405 D.setInvalidType(); 6406 return; 6407 6408 case PtrKernelParam: 6409 case ValidKernelParam: 6410 ValidTypes.insert(PT.getTypePtr()); 6411 return; 6412 6413 case RecordKernelParam: 6414 break; 6415 } 6416 6417 // Track nested structs we will inspect 6418 SmallVector<const Decl *, 4> VisitStack; 6419 6420 // Track where we are in the nested structs. Items will migrate from 6421 // VisitStack to HistoryStack as we do the DFS for bad field. 6422 SmallVector<const FieldDecl *, 4> HistoryStack; 6423 HistoryStack.push_back((const FieldDecl *) 0); 6424 6425 const RecordDecl *PD = PT->castAs<RecordType>()->getDecl(); 6426 VisitStack.push_back(PD); 6427 6428 assert(VisitStack.back() && "First decl null?"); 6429 6430 do { 6431 const Decl *Next = VisitStack.pop_back_val(); 6432 if (!Next) { 6433 assert(!HistoryStack.empty()); 6434 // Found a marker, we have gone up a level 6435 if (const FieldDecl *Hist = HistoryStack.pop_back_val()) 6436 ValidTypes.insert(Hist->getType().getTypePtr()); 6437 6438 continue; 6439 } 6440 6441 // Adds everything except the original parameter declaration (which is not a 6442 // field itself) to the history stack. 6443 const RecordDecl *RD; 6444 if (const FieldDecl *Field = dyn_cast<FieldDecl>(Next)) { 6445 HistoryStack.push_back(Field); 6446 RD = Field->getType()->castAs<RecordType>()->getDecl(); 6447 } else { 6448 RD = cast<RecordDecl>(Next); 6449 } 6450 6451 // Add a null marker so we know when we've gone back up a level 6452 VisitStack.push_back((const Decl *) 0); 6453 6454 for (RecordDecl::field_iterator I = RD->field_begin(), 6455 E = RD->field_end(); I != E; ++I) { 6456 const FieldDecl *FD = *I; 6457 QualType QT = FD->getType(); 6458 6459 if (ValidTypes.count(QT.getTypePtr())) 6460 continue; 6461 6462 OpenCLParamType ParamType = getOpenCLKernelParameterType(QT); 6463 if (ParamType == ValidKernelParam) 6464 continue; 6465 6466 if (ParamType == RecordKernelParam) { 6467 VisitStack.push_back(FD); 6468 continue; 6469 } 6470 6471 // OpenCL v1.2 s6.9.p: 6472 // Arguments to kernel functions that are declared to be a struct or union 6473 // do not allow OpenCL objects to be passed as elements of the struct or 6474 // union. 6475 if (ParamType == PtrKernelParam || ParamType == PtrPtrKernelParam) { 6476 S.Diag(Param->getLocation(), 6477 diag::err_record_with_pointers_kernel_param) 6478 << PT->isUnionType() 6479 << PT; 6480 } else { 6481 S.Diag(Param->getLocation(), diag::err_bad_kernel_param_type) << PT; 6482 } 6483 6484 S.Diag(PD->getLocation(), diag::note_within_field_of_type) 6485 << PD->getDeclName(); 6486 6487 // We have an error, now let's go back up through history and show where 6488 // the offending field came from 6489 for (ArrayRef<const FieldDecl *>::const_iterator I = HistoryStack.begin() + 1, 6490 E = HistoryStack.end(); I != E; ++I) { 6491 const FieldDecl *OuterField = *I; 6492 S.Diag(OuterField->getLocation(), diag::note_within_field_of_type) 6493 << OuterField->getType(); 6494 } 6495 6496 S.Diag(FD->getLocation(), diag::note_illegal_field_declared_here) 6497 << QT->isPointerType() 6498 << QT; 6499 D.setInvalidType(); 6500 return; 6501 } 6502 } while (!VisitStack.empty()); 6503} 6504 6505NamedDecl* 6506Sema::ActOnFunctionDeclarator(Scope *S, Declarator &D, DeclContext *DC, 6507 TypeSourceInfo *TInfo, LookupResult &Previous, 6508 MultiTemplateParamsArg TemplateParamLists, 6509 bool &AddToScope) { 6510 QualType R = TInfo->getType(); 6511 6512 assert(R.getTypePtr()->isFunctionType()); 6513 6514 // TODO: consider using NameInfo for diagnostic. 6515 DeclarationNameInfo NameInfo = GetNameForDeclarator(D); 6516 DeclarationName Name = NameInfo.getName(); 6517 FunctionDecl::StorageClass SC = getFunctionStorageClass(*this, D); 6518 6519 if (DeclSpec::TSCS TSCS = D.getDeclSpec().getThreadStorageClassSpec()) 6520 Diag(D.getDeclSpec().getThreadStorageClassSpecLoc(), 6521 diag::err_invalid_thread) 6522 << DeclSpec::getSpecifierName(TSCS); 6523 6524 bool isFriend = false; 6525 FunctionTemplateDecl *FunctionTemplate = 0; 6526 bool isExplicitSpecialization = false; 6527 bool isFunctionTemplateSpecialization = false; 6528 6529 bool isDependentClassScopeExplicitSpecialization = false; 6530 bool HasExplicitTemplateArgs = false; 6531 TemplateArgumentListInfo TemplateArgs; 6532 6533 bool isVirtualOkay = false; 6534 6535 FunctionDecl *NewFD = CreateNewFunctionDecl(*this, D, DC, R, TInfo, SC, 6536 isVirtualOkay); 6537 if (!NewFD) return 0; 6538 6539 if (OriginalLexicalContext && OriginalLexicalContext->isObjCContainer()) 6540 NewFD->setTopLevelDeclInObjCContainer(); 6541 6542 if (getLangOpts().CPlusPlus) { 6543 bool isInline = D.getDeclSpec().isInlineSpecified(); 6544 bool isVirtual = D.getDeclSpec().isVirtualSpecified(); 6545 bool isExplicit = D.getDeclSpec().isExplicitSpecified(); 6546 bool isConstexpr = D.getDeclSpec().isConstexprSpecified(); 6547 isFriend = D.getDeclSpec().isFriendSpecified(); 6548 if (isFriend && !isInline && D.isFunctionDefinition()) { 6549 // C++ [class.friend]p5 6550 // A function can be defined in a friend declaration of a 6551 // class . . . . Such a function is implicitly inline. 6552 NewFD->setImplicitlyInline(); 6553 } 6554 6555 // If this is a method defined in an __interface, and is not a constructor 6556 // or an overloaded operator, then set the pure flag (isVirtual will already 6557 // return true). 6558 if (const CXXRecordDecl *Parent = 6559 dyn_cast<CXXRecordDecl>(NewFD->getDeclContext())) { 6560 if (Parent->isInterface() && cast<CXXMethodDecl>(NewFD)->isUserProvided()) 6561 NewFD->setPure(true); 6562 } 6563 6564 SetNestedNameSpecifier(NewFD, D); 6565 isExplicitSpecialization = false; 6566 isFunctionTemplateSpecialization = false; 6567 if (D.isInvalidType()) 6568 NewFD->setInvalidDecl(); 6569 6570 // Set the lexical context. If the declarator has a C++ 6571 // scope specifier, or is the object of a friend declaration, the 6572 // lexical context will be different from the semantic context. 6573 NewFD->setLexicalDeclContext(CurContext); 6574 6575 // Match up the template parameter lists with the scope specifier, then 6576 // determine whether we have a template or a template specialization. 6577 bool Invalid = false; 6578 if (TemplateParameterList *TemplateParams = 6579 MatchTemplateParametersToScopeSpecifier( 6580 D.getDeclSpec().getLocStart(), D.getIdentifierLoc(), 6581 D.getCXXScopeSpec(), TemplateParamLists, isFriend, 6582 isExplicitSpecialization, Invalid)) { 6583 if (TemplateParams->size() > 0) { 6584 // This is a function template 6585 6586 // Check that we can declare a template here. 6587 if (CheckTemplateDeclScope(S, TemplateParams)) 6588 return 0; 6589 6590 // A destructor cannot be a template. 6591 if (Name.getNameKind() == DeclarationName::CXXDestructorName) { 6592 Diag(NewFD->getLocation(), diag::err_destructor_template); 6593 return 0; 6594 } 6595 6596 // If we're adding a template to a dependent context, we may need to 6597 // rebuilding some of the types used within the template parameter list, 6598 // now that we know what the current instantiation is. 6599 if (DC->isDependentContext()) { 6600 ContextRAII SavedContext(*this, DC); 6601 if (RebuildTemplateParamsInCurrentInstantiation(TemplateParams)) 6602 Invalid = true; 6603 } 6604 6605 6606 FunctionTemplate = FunctionTemplateDecl::Create(Context, DC, 6607 NewFD->getLocation(), 6608 Name, TemplateParams, 6609 NewFD); 6610 FunctionTemplate->setLexicalDeclContext(CurContext); 6611 NewFD->setDescribedFunctionTemplate(FunctionTemplate); 6612 6613 // For source fidelity, store the other template param lists. 6614 if (TemplateParamLists.size() > 1) { 6615 NewFD->setTemplateParameterListsInfo(Context, 6616 TemplateParamLists.size() - 1, 6617 TemplateParamLists.data()); 6618 } 6619 } else { 6620 // This is a function template specialization. 6621 isFunctionTemplateSpecialization = true; 6622 // For source fidelity, store all the template param lists. 6623 NewFD->setTemplateParameterListsInfo(Context, 6624 TemplateParamLists.size(), 6625 TemplateParamLists.data()); 6626 6627 // C++0x [temp.expl.spec]p20 forbids "template<> friend void foo(int);". 6628 if (isFriend) { 6629 // We want to remove the "template<>", found here. 6630 SourceRange RemoveRange = TemplateParams->getSourceRange(); 6631 6632 // If we remove the template<> and the name is not a 6633 // template-id, we're actually silently creating a problem: 6634 // the friend declaration will refer to an untemplated decl, 6635 // and clearly the user wants a template specialization. So 6636 // we need to insert '<>' after the name. 6637 SourceLocation InsertLoc; 6638 if (D.getName().getKind() != UnqualifiedId::IK_TemplateId) { 6639 InsertLoc = D.getName().getSourceRange().getEnd(); 6640 InsertLoc = PP.getLocForEndOfToken(InsertLoc); 6641 } 6642 6643 Diag(D.getIdentifierLoc(), diag::err_template_spec_decl_friend) 6644 << Name << RemoveRange 6645 << FixItHint::CreateRemoval(RemoveRange) 6646 << FixItHint::CreateInsertion(InsertLoc, "<>"); 6647 } 6648 } 6649 } 6650 else { 6651 // All template param lists were matched against the scope specifier: 6652 // this is NOT (an explicit specialization of) a template. 6653 if (TemplateParamLists.size() > 0) 6654 // For source fidelity, store all the template param lists. 6655 NewFD->setTemplateParameterListsInfo(Context, 6656 TemplateParamLists.size(), 6657 TemplateParamLists.data()); 6658 } 6659 6660 if (Invalid) { 6661 NewFD->setInvalidDecl(); 6662 if (FunctionTemplate) 6663 FunctionTemplate->setInvalidDecl(); 6664 } 6665 6666 // C++ [dcl.fct.spec]p5: 6667 // The virtual specifier shall only be used in declarations of 6668 // nonstatic class member functions that appear within a 6669 // member-specification of a class declaration; see 10.3. 6670 // 6671 if (isVirtual && !NewFD->isInvalidDecl()) { 6672 if (!isVirtualOkay) { 6673 Diag(D.getDeclSpec().getVirtualSpecLoc(), 6674 diag::err_virtual_non_function); 6675 } else if (!CurContext->isRecord()) { 6676 // 'virtual' was specified outside of the class. 6677 Diag(D.getDeclSpec().getVirtualSpecLoc(), 6678 diag::err_virtual_out_of_class) 6679 << FixItHint::CreateRemoval(D.getDeclSpec().getVirtualSpecLoc()); 6680 } else if (NewFD->getDescribedFunctionTemplate()) { 6681 // C++ [temp.mem]p3: 6682 // A member function template shall not be virtual. 6683 Diag(D.getDeclSpec().getVirtualSpecLoc(), 6684 diag::err_virtual_member_function_template) 6685 << FixItHint::CreateRemoval(D.getDeclSpec().getVirtualSpecLoc()); 6686 } else { 6687 // Okay: Add virtual to the method. 6688 NewFD->setVirtualAsWritten(true); 6689 } 6690 6691 if (getLangOpts().CPlusPlus1y && 6692 NewFD->getResultType()->isUndeducedType()) 6693 Diag(D.getDeclSpec().getVirtualSpecLoc(), diag::err_auto_fn_virtual); 6694 } 6695 6696 if (getLangOpts().CPlusPlus1y && NewFD->isDependentContext() && 6697 NewFD->getResultType()->isUndeducedType()) { 6698 // If the function template is referenced directly (for instance, as a 6699 // member of the current instantiation), pretend it has a dependent type. 6700 // This is not really justified by the standard, but is the only sane 6701 // thing to do. 6702 const FunctionProtoType *FPT = 6703 NewFD->getType()->castAs<FunctionProtoType>(); 6704 QualType Result = SubstAutoType(FPT->getResultType(), 6705 Context.DependentTy); 6706 NewFD->setType(Context.getFunctionType(Result, FPT->getArgTypes(), 6707 FPT->getExtProtoInfo())); 6708 } 6709 6710 // C++ [dcl.fct.spec]p3: 6711 // The inline specifier shall not appear on a block scope function 6712 // declaration. 6713 if (isInline && !NewFD->isInvalidDecl()) { 6714 if (CurContext->isFunctionOrMethod()) { 6715 // 'inline' is not allowed on block scope function declaration. 6716 Diag(D.getDeclSpec().getInlineSpecLoc(), 6717 diag::err_inline_declaration_block_scope) << Name 6718 << FixItHint::CreateRemoval(D.getDeclSpec().getInlineSpecLoc()); 6719 } 6720 } 6721 6722 // C++ [dcl.fct.spec]p6: 6723 // The explicit specifier shall be used only in the declaration of a 6724 // constructor or conversion function within its class definition; 6725 // see 12.3.1 and 12.3.2. 6726 if (isExplicit && !NewFD->isInvalidDecl()) { 6727 if (!CurContext->isRecord()) { 6728 // 'explicit' was specified outside of the class. 6729 Diag(D.getDeclSpec().getExplicitSpecLoc(), 6730 diag::err_explicit_out_of_class) 6731 << FixItHint::CreateRemoval(D.getDeclSpec().getExplicitSpecLoc()); 6732 } else if (!isa<CXXConstructorDecl>(NewFD) && 6733 !isa<CXXConversionDecl>(NewFD)) { 6734 // 'explicit' was specified on a function that wasn't a constructor 6735 // or conversion function. 6736 Diag(D.getDeclSpec().getExplicitSpecLoc(), 6737 diag::err_explicit_non_ctor_or_conv_function) 6738 << FixItHint::CreateRemoval(D.getDeclSpec().getExplicitSpecLoc()); 6739 } 6740 } 6741 6742 if (isConstexpr) { 6743 // C++11 [dcl.constexpr]p2: constexpr functions and constexpr constructors 6744 // are implicitly inline. 6745 NewFD->setImplicitlyInline(); 6746 6747 // C++11 [dcl.constexpr]p3: functions declared constexpr are required to 6748 // be either constructors or to return a literal type. Therefore, 6749 // destructors cannot be declared constexpr. 6750 if (isa<CXXDestructorDecl>(NewFD)) 6751 Diag(D.getDeclSpec().getConstexprSpecLoc(), diag::err_constexpr_dtor); 6752 } 6753 6754 // If __module_private__ was specified, mark the function accordingly. 6755 if (D.getDeclSpec().isModulePrivateSpecified()) { 6756 if (isFunctionTemplateSpecialization) { 6757 SourceLocation ModulePrivateLoc 6758 = D.getDeclSpec().getModulePrivateSpecLoc(); 6759 Diag(ModulePrivateLoc, diag::err_module_private_specialization) 6760 << 0 6761 << FixItHint::CreateRemoval(ModulePrivateLoc); 6762 } else { 6763 NewFD->setModulePrivate(); 6764 if (FunctionTemplate) 6765 FunctionTemplate->setModulePrivate(); 6766 } 6767 } 6768 6769 if (isFriend) { 6770 if (FunctionTemplate) { 6771 FunctionTemplate->setObjectOfFriendDecl(); 6772 FunctionTemplate->setAccess(AS_public); 6773 } 6774 NewFD->setObjectOfFriendDecl(); 6775 NewFD->setAccess(AS_public); 6776 } 6777 6778 // If a function is defined as defaulted or deleted, mark it as such now. 6779 switch (D.getFunctionDefinitionKind()) { 6780 case FDK_Declaration: 6781 case FDK_Definition: 6782 break; 6783 6784 case FDK_Defaulted: 6785 NewFD->setDefaulted(); 6786 break; 6787 6788 case FDK_Deleted: 6789 NewFD->setDeletedAsWritten(); 6790 break; 6791 } 6792 6793 if (isa<CXXMethodDecl>(NewFD) && DC == CurContext && 6794 D.isFunctionDefinition()) { 6795 // C++ [class.mfct]p2: 6796 // A member function may be defined (8.4) in its class definition, in 6797 // which case it is an inline member function (7.1.2) 6798 NewFD->setImplicitlyInline(); 6799 } 6800 6801 if (SC == SC_Static && isa<CXXMethodDecl>(NewFD) && 6802 !CurContext->isRecord()) { 6803 // C++ [class.static]p1: 6804 // A data or function member of a class may be declared static 6805 // in a class definition, in which case it is a static member of 6806 // the class. 6807 6808 // Complain about the 'static' specifier if it's on an out-of-line 6809 // member function definition. 6810 Diag(D.getDeclSpec().getStorageClassSpecLoc(), 6811 diag::err_static_out_of_line) 6812 << FixItHint::CreateRemoval(D.getDeclSpec().getStorageClassSpecLoc()); 6813 } 6814 6815 // C++11 [except.spec]p15: 6816 // A deallocation function with no exception-specification is treated 6817 // as if it were specified with noexcept(true). 6818 const FunctionProtoType *FPT = R->getAs<FunctionProtoType>(); 6819 if ((Name.getCXXOverloadedOperator() == OO_Delete || 6820 Name.getCXXOverloadedOperator() == OO_Array_Delete) && 6821 getLangOpts().CPlusPlus11 && FPT && !FPT->hasExceptionSpec()) { 6822 FunctionProtoType::ExtProtoInfo EPI = FPT->getExtProtoInfo(); 6823 EPI.ExceptionSpecType = EST_BasicNoexcept; 6824 NewFD->setType(Context.getFunctionType(FPT->getResultType(), 6825 FPT->getArgTypes(), EPI)); 6826 } 6827 } 6828 6829 // Filter out previous declarations that don't match the scope. 6830 FilterLookupForScope(Previous, DC, S, shouldConsiderLinkage(NewFD), 6831 isExplicitSpecialization || 6832 isFunctionTemplateSpecialization); 6833 6834 // Handle GNU asm-label extension (encoded as an attribute). 6835 if (Expr *E = (Expr*) D.getAsmLabel()) { 6836 // The parser guarantees this is a string. 6837 StringLiteral *SE = cast<StringLiteral>(E); 6838 NewFD->addAttr(::new (Context) AsmLabelAttr(SE->getStrTokenLoc(0), Context, 6839 SE->getString())); 6840 } else if (!ExtnameUndeclaredIdentifiers.empty()) { 6841 llvm::DenseMap<IdentifierInfo*,AsmLabelAttr*>::iterator I = 6842 ExtnameUndeclaredIdentifiers.find(NewFD->getIdentifier()); 6843 if (I != ExtnameUndeclaredIdentifiers.end()) { 6844 NewFD->addAttr(I->second); 6845 ExtnameUndeclaredIdentifiers.erase(I); 6846 } 6847 } 6848 6849 // Copy the parameter declarations from the declarator D to the function 6850 // declaration NewFD, if they are available. First scavenge them into Params. 6851 SmallVector<ParmVarDecl*, 16> Params; 6852 if (D.isFunctionDeclarator()) { 6853 DeclaratorChunk::FunctionTypeInfo &FTI = D.getFunctionTypeInfo(); 6854 6855 // Check for C99 6.7.5.3p10 - foo(void) is a non-varargs 6856 // function that takes no arguments, not a function that takes a 6857 // single void argument. 6858 // We let through "const void" here because Sema::GetTypeForDeclarator 6859 // already checks for that case. 6860 if (FTI.NumArgs == 1 && !FTI.isVariadic && FTI.ArgInfo[0].Ident == 0 && 6861 FTI.ArgInfo[0].Param && 6862 cast<ParmVarDecl>(FTI.ArgInfo[0].Param)->getType()->isVoidType()) { 6863 // Empty arg list, don't push any params. 6864 checkVoidParamDecl(cast<ParmVarDecl>(FTI.ArgInfo[0].Param)); 6865 } else if (FTI.NumArgs > 0 && FTI.ArgInfo[0].Param != 0) { 6866 for (unsigned i = 0, e = FTI.NumArgs; i != e; ++i) { 6867 ParmVarDecl *Param = cast<ParmVarDecl>(FTI.ArgInfo[i].Param); 6868 assert(Param->getDeclContext() != NewFD && "Was set before ?"); 6869 Param->setDeclContext(NewFD); 6870 Params.push_back(Param); 6871 6872 if (Param->isInvalidDecl()) 6873 NewFD->setInvalidDecl(); 6874 } 6875 } 6876 6877 } else if (const FunctionProtoType *FT = R->getAs<FunctionProtoType>()) { 6878 // When we're declaring a function with a typedef, typeof, etc as in the 6879 // following example, we'll need to synthesize (unnamed) 6880 // parameters for use in the declaration. 6881 // 6882 // @code 6883 // typedef void fn(int); 6884 // fn f; 6885 // @endcode 6886 6887 // Synthesize a parameter for each argument type. 6888 for (FunctionProtoType::arg_type_iterator AI = FT->arg_type_begin(), 6889 AE = FT->arg_type_end(); AI != AE; ++AI) { 6890 ParmVarDecl *Param = 6891 BuildParmVarDeclForTypedef(NewFD, D.getIdentifierLoc(), *AI); 6892 Param->setScopeInfo(0, Params.size()); 6893 Params.push_back(Param); 6894 } 6895 } else { 6896 assert(R->isFunctionNoProtoType() && NewFD->getNumParams() == 0 && 6897 "Should not need args for typedef of non-prototype fn"); 6898 } 6899 6900 // Finally, we know we have the right number of parameters, install them. 6901 NewFD->setParams(Params); 6902 6903 // Find all anonymous symbols defined during the declaration of this function 6904 // and add to NewFD. This lets us track decls such 'enum Y' in: 6905 // 6906 // void f(enum Y {AA} x) {} 6907 // 6908 // which would otherwise incorrectly end up in the translation unit scope. 6909 NewFD->setDeclsInPrototypeScope(DeclsInPrototypeScope); 6910 DeclsInPrototypeScope.clear(); 6911 6912 if (D.getDeclSpec().isNoreturnSpecified()) 6913 NewFD->addAttr( 6914 ::new(Context) C11NoReturnAttr(D.getDeclSpec().getNoreturnSpecLoc(), 6915 Context)); 6916 6917 // Process the non-inheritable attributes on this declaration. 6918 ProcessDeclAttributes(S, NewFD, D, 6919 /*NonInheritable=*/true, /*Inheritable=*/false); 6920 6921 // Functions returning a variably modified type violate C99 6.7.5.2p2 6922 // because all functions have linkage. 6923 if (!NewFD->isInvalidDecl() && 6924 NewFD->getResultType()->isVariablyModifiedType()) { 6925 Diag(NewFD->getLocation(), diag::err_vm_func_decl); 6926 NewFD->setInvalidDecl(); 6927 } 6928 6929 // Handle attributes. 6930 ProcessDeclAttributes(S, NewFD, D, 6931 /*NonInheritable=*/false, /*Inheritable=*/true); 6932 6933 QualType RetType = NewFD->getResultType(); 6934 const CXXRecordDecl *Ret = RetType->isRecordType() ? 6935 RetType->getAsCXXRecordDecl() : RetType->getPointeeCXXRecordDecl(); 6936 if (!NewFD->isInvalidDecl() && !NewFD->hasAttr<WarnUnusedResultAttr>() && 6937 Ret && Ret->hasAttr<WarnUnusedResultAttr>()) { 6938 const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(NewFD); 6939 if (!(MD && MD->getCorrespondingMethodInClass(Ret, true))) { 6940 NewFD->addAttr(new (Context) WarnUnusedResultAttr(SourceRange(), 6941 Context)); 6942 } 6943 } 6944 6945 if (!getLangOpts().CPlusPlus) { 6946 // Perform semantic checking on the function declaration. 6947 bool isExplicitSpecialization=false; 6948 if (!NewFD->isInvalidDecl() && NewFD->isMain()) 6949 CheckMain(NewFD, D.getDeclSpec()); 6950 6951 if (!NewFD->isInvalidDecl()) 6952 D.setRedeclaration(CheckFunctionDeclaration(S, NewFD, Previous, 6953 isExplicitSpecialization)); 6954 else if (!Previous.empty()) 6955 // Make graceful recovery from an invalid redeclaration. 6956 D.setRedeclaration(true); 6957 assert((NewFD->isInvalidDecl() || !D.isRedeclaration() || 6958 Previous.getResultKind() != LookupResult::FoundOverloaded) && 6959 "previous declaration set still overloaded"); 6960 } else { 6961 // If the declarator is a template-id, translate the parser's template 6962 // argument list into our AST format. 6963 if (D.getName().getKind() == UnqualifiedId::IK_TemplateId) { 6964 TemplateIdAnnotation *TemplateId = D.getName().TemplateId; 6965 TemplateArgs.setLAngleLoc(TemplateId->LAngleLoc); 6966 TemplateArgs.setRAngleLoc(TemplateId->RAngleLoc); 6967 ASTTemplateArgsPtr TemplateArgsPtr(TemplateId->getTemplateArgs(), 6968 TemplateId->NumArgs); 6969 translateTemplateArguments(TemplateArgsPtr, 6970 TemplateArgs); 6971 6972 HasExplicitTemplateArgs = true; 6973 6974 if (NewFD->isInvalidDecl()) { 6975 HasExplicitTemplateArgs = false; 6976 } else if (FunctionTemplate) { 6977 // Function template with explicit template arguments. 6978 Diag(D.getIdentifierLoc(), diag::err_function_template_partial_spec) 6979 << SourceRange(TemplateId->LAngleLoc, TemplateId->RAngleLoc); 6980 6981 HasExplicitTemplateArgs = false; 6982 } else if (!isFunctionTemplateSpecialization && 6983 !D.getDeclSpec().isFriendSpecified()) { 6984 // We have encountered something that the user meant to be a 6985 // specialization (because it has explicitly-specified template 6986 // arguments) but that was not introduced with a "template<>" (or had 6987 // too few of them). 6988 // FIXME: Differentiate between attempts for explicit instantiations 6989 // (starting with "template") and the rest. 6990 Diag(D.getIdentifierLoc(), diag::err_template_spec_needs_header) 6991 << SourceRange(TemplateId->LAngleLoc, TemplateId->RAngleLoc) 6992 << FixItHint::CreateInsertion( 6993 D.getDeclSpec().getLocStart(), 6994 "template<> "); 6995 isFunctionTemplateSpecialization = true; 6996 } else { 6997 // "friend void foo<>(int);" is an implicit specialization decl. 6998 isFunctionTemplateSpecialization = true; 6999 } 7000 } else if (isFriend && isFunctionTemplateSpecialization) { 7001 // This combination is only possible in a recovery case; the user 7002 // wrote something like: 7003 // template <> friend void foo(int); 7004 // which we're recovering from as if the user had written: 7005 // friend void foo<>(int); 7006 // Go ahead and fake up a template id. 7007 HasExplicitTemplateArgs = true; 7008 TemplateArgs.setLAngleLoc(D.getIdentifierLoc()); 7009 TemplateArgs.setRAngleLoc(D.getIdentifierLoc()); 7010 } 7011 7012 // If it's a friend (and only if it's a friend), it's possible 7013 // that either the specialized function type or the specialized 7014 // template is dependent, and therefore matching will fail. In 7015 // this case, don't check the specialization yet. 7016 bool InstantiationDependent = false; 7017 if (isFunctionTemplateSpecialization && isFriend && 7018 (NewFD->getType()->isDependentType() || DC->isDependentContext() || 7019 TemplateSpecializationType::anyDependentTemplateArguments( 7020 TemplateArgs.getArgumentArray(), TemplateArgs.size(), 7021 InstantiationDependent))) { 7022 assert(HasExplicitTemplateArgs && 7023 "friend function specialization without template args"); 7024 if (CheckDependentFunctionTemplateSpecialization(NewFD, TemplateArgs, 7025 Previous)) 7026 NewFD->setInvalidDecl(); 7027 } else if (isFunctionTemplateSpecialization) { 7028 if (CurContext->isDependentContext() && CurContext->isRecord() 7029 && !isFriend) { 7030 isDependentClassScopeExplicitSpecialization = true; 7031 Diag(NewFD->getLocation(), getLangOpts().MicrosoftExt ? 7032 diag::ext_function_specialization_in_class : 7033 diag::err_function_specialization_in_class) 7034 << NewFD->getDeclName(); 7035 } else if (CheckFunctionTemplateSpecialization(NewFD, 7036 (HasExplicitTemplateArgs ? &TemplateArgs : 0), 7037 Previous)) 7038 NewFD->setInvalidDecl(); 7039 7040 // C++ [dcl.stc]p1: 7041 // A storage-class-specifier shall not be specified in an explicit 7042 // specialization (14.7.3) 7043 FunctionTemplateSpecializationInfo *Info = 7044 NewFD->getTemplateSpecializationInfo(); 7045 if (Info && SC != SC_None) { 7046 if (SC != Info->getTemplate()->getTemplatedDecl()->getStorageClass()) 7047 Diag(NewFD->getLocation(), 7048 diag::err_explicit_specialization_inconsistent_storage_class) 7049 << SC 7050 << FixItHint::CreateRemoval( 7051 D.getDeclSpec().getStorageClassSpecLoc()); 7052 7053 else 7054 Diag(NewFD->getLocation(), 7055 diag::ext_explicit_specialization_storage_class) 7056 << FixItHint::CreateRemoval( 7057 D.getDeclSpec().getStorageClassSpecLoc()); 7058 } 7059 7060 } else if (isExplicitSpecialization && isa<CXXMethodDecl>(NewFD)) { 7061 if (CheckMemberSpecialization(NewFD, Previous)) 7062 NewFD->setInvalidDecl(); 7063 } 7064 7065 // Perform semantic checking on the function declaration. 7066 if (!isDependentClassScopeExplicitSpecialization) { 7067 if (!NewFD->isInvalidDecl() && NewFD->isMain()) 7068 CheckMain(NewFD, D.getDeclSpec()); 7069 7070 if (NewFD->isInvalidDecl()) { 7071 // If this is a class member, mark the class invalid immediately. 7072 // This avoids some consistency errors later. 7073 if (CXXMethodDecl* methodDecl = dyn_cast<CXXMethodDecl>(NewFD)) 7074 methodDecl->getParent()->setInvalidDecl(); 7075 } else 7076 D.setRedeclaration(CheckFunctionDeclaration(S, NewFD, Previous, 7077 isExplicitSpecialization)); 7078 } 7079 7080 assert((NewFD->isInvalidDecl() || !D.isRedeclaration() || 7081 Previous.getResultKind() != LookupResult::FoundOverloaded) && 7082 "previous declaration set still overloaded"); 7083 7084 NamedDecl *PrincipalDecl = (FunctionTemplate 7085 ? cast<NamedDecl>(FunctionTemplate) 7086 : NewFD); 7087 7088 if (isFriend && D.isRedeclaration()) { 7089 AccessSpecifier Access = AS_public; 7090 if (!NewFD->isInvalidDecl()) 7091 Access = NewFD->getPreviousDecl()->getAccess(); 7092 7093 NewFD->setAccess(Access); 7094 if (FunctionTemplate) FunctionTemplate->setAccess(Access); 7095 } 7096 7097 if (NewFD->isOverloadedOperator() && !DC->isRecord() && 7098 PrincipalDecl->isInIdentifierNamespace(Decl::IDNS_Ordinary)) 7099 PrincipalDecl->setNonMemberOperator(); 7100 7101 // If we have a function template, check the template parameter 7102 // list. This will check and merge default template arguments. 7103 if (FunctionTemplate) { 7104 FunctionTemplateDecl *PrevTemplate = 7105 FunctionTemplate->getPreviousDecl(); 7106 CheckTemplateParameterList(FunctionTemplate->getTemplateParameters(), 7107 PrevTemplate ? PrevTemplate->getTemplateParameters() : 0, 7108 D.getDeclSpec().isFriendSpecified() 7109 ? (D.isFunctionDefinition() 7110 ? TPC_FriendFunctionTemplateDefinition 7111 : TPC_FriendFunctionTemplate) 7112 : (D.getCXXScopeSpec().isSet() && 7113 DC && DC->isRecord() && 7114 DC->isDependentContext()) 7115 ? TPC_ClassTemplateMember 7116 : TPC_FunctionTemplate); 7117 } 7118 7119 if (NewFD->isInvalidDecl()) { 7120 // Ignore all the rest of this. 7121 } else if (!D.isRedeclaration()) { 7122 struct ActOnFDArgs ExtraArgs = { S, D, TemplateParamLists, 7123 AddToScope }; 7124 // Fake up an access specifier if it's supposed to be a class member. 7125 if (isa<CXXRecordDecl>(NewFD->getDeclContext())) 7126 NewFD->setAccess(AS_public); 7127 7128 // Qualified decls generally require a previous declaration. 7129 if (D.getCXXScopeSpec().isSet()) { 7130 // ...with the major exception of templated-scope or 7131 // dependent-scope friend declarations. 7132 7133 // TODO: we currently also suppress this check in dependent 7134 // contexts because (1) the parameter depth will be off when 7135 // matching friend templates and (2) we might actually be 7136 // selecting a friend based on a dependent factor. But there 7137 // are situations where these conditions don't apply and we 7138 // can actually do this check immediately. 7139 if (isFriend && 7140 (TemplateParamLists.size() || 7141 D.getCXXScopeSpec().getScopeRep()->isDependent() || 7142 CurContext->isDependentContext())) { 7143 // ignore these 7144 } else { 7145 // The user tried to provide an out-of-line definition for a 7146 // function that is a member of a class or namespace, but there 7147 // was no such member function declared (C++ [class.mfct]p2, 7148 // C++ [namespace.memdef]p2). For example: 7149 // 7150 // class X { 7151 // void f() const; 7152 // }; 7153 // 7154 // void X::f() { } // ill-formed 7155 // 7156 // Complain about this problem, and attempt to suggest close 7157 // matches (e.g., those that differ only in cv-qualifiers and 7158 // whether the parameter types are references). 7159 7160 if (NamedDecl *Result = DiagnoseInvalidRedeclaration( 7161 *this, Previous, NewFD, ExtraArgs, false, 0)) { 7162 AddToScope = ExtraArgs.AddToScope; 7163 return Result; 7164 } 7165 } 7166 7167 // Unqualified local friend declarations are required to resolve 7168 // to something. 7169 } else if (isFriend && cast<CXXRecordDecl>(CurContext)->isLocalClass()) { 7170 if (NamedDecl *Result = DiagnoseInvalidRedeclaration( 7171 *this, Previous, NewFD, ExtraArgs, true, S)) { 7172 AddToScope = ExtraArgs.AddToScope; 7173 return Result; 7174 } 7175 } 7176 7177 } else if (!D.isFunctionDefinition() && D.getCXXScopeSpec().isSet() && 7178 !isFriend && !isFunctionTemplateSpecialization && 7179 !isExplicitSpecialization) { 7180 // An out-of-line member function declaration must also be a 7181 // definition (C++ [dcl.meaning]p1). 7182 // Note that this is not the case for explicit specializations of 7183 // function templates or member functions of class templates, per 7184 // C++ [temp.expl.spec]p2. We also allow these declarations as an 7185 // extension for compatibility with old SWIG code which likes to 7186 // generate them. 7187 Diag(NewFD->getLocation(), diag::ext_out_of_line_declaration) 7188 << D.getCXXScopeSpec().getRange(); 7189 } 7190 } 7191 7192 ProcessPragmaWeak(S, NewFD); 7193 checkAttributesAfterMerging(*this, *NewFD); 7194 7195 AddKnownFunctionAttributes(NewFD); 7196 7197 if (NewFD->hasAttr<OverloadableAttr>() && 7198 !NewFD->getType()->getAs<FunctionProtoType>()) { 7199 Diag(NewFD->getLocation(), 7200 diag::err_attribute_overloadable_no_prototype) 7201 << NewFD; 7202 7203 // Turn this into a variadic function with no parameters. 7204 const FunctionType *FT = NewFD->getType()->getAs<FunctionType>(); 7205 FunctionProtoType::ExtProtoInfo EPI; 7206 EPI.Variadic = true; 7207 EPI.ExtInfo = FT->getExtInfo(); 7208 7209 QualType R = Context.getFunctionType(FT->getResultType(), None, EPI); 7210 NewFD->setType(R); 7211 } 7212 7213 // If there's a #pragma GCC visibility in scope, and this isn't a class 7214 // member, set the visibility of this function. 7215 if (!DC->isRecord() && NewFD->isExternallyVisible()) 7216 AddPushedVisibilityAttribute(NewFD); 7217 7218 // If there's a #pragma clang arc_cf_code_audited in scope, consider 7219 // marking the function. 7220 AddCFAuditedAttribute(NewFD); 7221 7222 // If this is the first declaration of an extern C variable, update 7223 // the map of such variables. 7224 if (!NewFD->getPreviousDecl() && !NewFD->isInvalidDecl() && 7225 isIncompleteDeclExternC(*this, NewFD)) 7226 RegisterLocallyScopedExternCDecl(NewFD, S); 7227 7228 // Set this FunctionDecl's range up to the right paren. 7229 NewFD->setRangeEnd(D.getSourceRange().getEnd()); 7230 7231 if (getLangOpts().CPlusPlus) { 7232 if (FunctionTemplate) { 7233 if (NewFD->isInvalidDecl()) 7234 FunctionTemplate->setInvalidDecl(); 7235 return FunctionTemplate; 7236 } 7237 } 7238 7239 if (NewFD->hasAttr<OpenCLKernelAttr>()) { 7240 // OpenCL v1.2 s6.8 static is invalid for kernel functions. 7241 if ((getLangOpts().OpenCLVersion >= 120) 7242 && (SC == SC_Static)) { 7243 Diag(D.getIdentifierLoc(), diag::err_static_kernel); 7244 D.setInvalidType(); 7245 } 7246 7247 // OpenCL v1.2, s6.9 -- Kernels can only have return type void. 7248 if (!NewFD->getResultType()->isVoidType()) { 7249 Diag(D.getIdentifierLoc(), 7250 diag::err_expected_kernel_void_return_type); 7251 D.setInvalidType(); 7252 } 7253 7254 llvm::SmallPtrSet<const Type *, 16> ValidTypes; 7255 for (FunctionDecl::param_iterator PI = NewFD->param_begin(), 7256 PE = NewFD->param_end(); PI != PE; ++PI) { 7257 ParmVarDecl *Param = *PI; 7258 checkIsValidOpenCLKernelParameter(*this, D, Param, ValidTypes); 7259 } 7260 } 7261 7262 MarkUnusedFileScopedDecl(NewFD); 7263 7264 if (getLangOpts().CUDA) 7265 if (IdentifierInfo *II = NewFD->getIdentifier()) 7266 if (!NewFD->isInvalidDecl() && 7267 NewFD->getDeclContext()->getRedeclContext()->isTranslationUnit()) { 7268 if (II->isStr("cudaConfigureCall")) { 7269 if (!R->getAs<FunctionType>()->getResultType()->isScalarType()) 7270 Diag(NewFD->getLocation(), diag::err_config_scalar_return); 7271 7272 Context.setcudaConfigureCallDecl(NewFD); 7273 } 7274 } 7275 7276 // Here we have an function template explicit specialization at class scope. 7277 // The actually specialization will be postponed to template instatiation 7278 // time via the ClassScopeFunctionSpecializationDecl node. 7279 if (isDependentClassScopeExplicitSpecialization) { 7280 ClassScopeFunctionSpecializationDecl *NewSpec = 7281 ClassScopeFunctionSpecializationDecl::Create( 7282 Context, CurContext, SourceLocation(), 7283 cast<CXXMethodDecl>(NewFD), 7284 HasExplicitTemplateArgs, TemplateArgs); 7285 CurContext->addDecl(NewSpec); 7286 AddToScope = false; 7287 } 7288 7289 return NewFD; 7290} 7291 7292/// \brief Perform semantic checking of a new function declaration. 7293/// 7294/// Performs semantic analysis of the new function declaration 7295/// NewFD. This routine performs all semantic checking that does not 7296/// require the actual declarator involved in the declaration, and is 7297/// used both for the declaration of functions as they are parsed 7298/// (called via ActOnDeclarator) and for the declaration of functions 7299/// that have been instantiated via C++ template instantiation (called 7300/// via InstantiateDecl). 7301/// 7302/// \param IsExplicitSpecialization whether this new function declaration is 7303/// an explicit specialization of the previous declaration. 7304/// 7305/// This sets NewFD->isInvalidDecl() to true if there was an error. 7306/// 7307/// \returns true if the function declaration is a redeclaration. 7308bool Sema::CheckFunctionDeclaration(Scope *S, FunctionDecl *NewFD, 7309 LookupResult &Previous, 7310 bool IsExplicitSpecialization) { 7311 assert(!NewFD->getResultType()->isVariablyModifiedType() 7312 && "Variably modified return types are not handled here"); 7313 7314 // Determine whether the type of this function should be merged with 7315 // a previous visible declaration. This never happens for functions in C++, 7316 // and always happens in C if the previous declaration was visible. 7317 bool MergeTypeWithPrevious = !getLangOpts().CPlusPlus && 7318 !Previous.isShadowed(); 7319 7320 // Filter out any non-conflicting previous declarations. 7321 filterNonConflictingPreviousDecls(Context, NewFD, Previous); 7322 7323 bool Redeclaration = false; 7324 NamedDecl *OldDecl = 0; 7325 7326 // Merge or overload the declaration with an existing declaration of 7327 // the same name, if appropriate. 7328 if (!Previous.empty()) { 7329 // Determine whether NewFD is an overload of PrevDecl or 7330 // a declaration that requires merging. If it's an overload, 7331 // there's no more work to do here; we'll just add the new 7332 // function to the scope. 7333 if (!AllowOverloadingOfFunction(Previous, Context)) { 7334 NamedDecl *Candidate = Previous.getFoundDecl(); 7335 if (shouldLinkPossiblyHiddenDecl(Candidate, NewFD)) { 7336 Redeclaration = true; 7337 OldDecl = Candidate; 7338 } 7339 } else { 7340 switch (CheckOverload(S, NewFD, Previous, OldDecl, 7341 /*NewIsUsingDecl*/ false)) { 7342 case Ovl_Match: 7343 Redeclaration = true; 7344 break; 7345 7346 case Ovl_NonFunction: 7347 Redeclaration = true; 7348 break; 7349 7350 case Ovl_Overload: 7351 Redeclaration = false; 7352 break; 7353 } 7354 7355 if (!getLangOpts().CPlusPlus && !NewFD->hasAttr<OverloadableAttr>()) { 7356 // If a function name is overloadable in C, then every function 7357 // with that name must be marked "overloadable". 7358 Diag(NewFD->getLocation(), diag::err_attribute_overloadable_missing) 7359 << Redeclaration << NewFD; 7360 NamedDecl *OverloadedDecl = 0; 7361 if (Redeclaration) 7362 OverloadedDecl = OldDecl; 7363 else if (!Previous.empty()) 7364 OverloadedDecl = Previous.getRepresentativeDecl(); 7365 if (OverloadedDecl) 7366 Diag(OverloadedDecl->getLocation(), 7367 diag::note_attribute_overloadable_prev_overload); 7368 NewFD->addAttr(::new (Context) OverloadableAttr(SourceLocation(), 7369 Context)); 7370 } 7371 } 7372 } 7373 7374 // Check for a previous extern "C" declaration with this name. 7375 if (!Redeclaration && 7376 checkForConflictWithNonVisibleExternC(*this, NewFD, Previous)) { 7377 filterNonConflictingPreviousDecls(Context, NewFD, Previous); 7378 if (!Previous.empty()) { 7379 // This is an extern "C" declaration with the same name as a previous 7380 // declaration, and thus redeclares that entity... 7381 Redeclaration = true; 7382 OldDecl = Previous.getFoundDecl(); 7383 MergeTypeWithPrevious = false; 7384 7385 // ... except in the presence of __attribute__((overloadable)). 7386 if (OldDecl->hasAttr<OverloadableAttr>()) { 7387 if (!getLangOpts().CPlusPlus && !NewFD->hasAttr<OverloadableAttr>()) { 7388 Diag(NewFD->getLocation(), diag::err_attribute_overloadable_missing) 7389 << Redeclaration << NewFD; 7390 Diag(Previous.getFoundDecl()->getLocation(), 7391 diag::note_attribute_overloadable_prev_overload); 7392 NewFD->addAttr(::new (Context) OverloadableAttr(SourceLocation(), 7393 Context)); 7394 } 7395 if (IsOverload(NewFD, cast<FunctionDecl>(OldDecl), false)) { 7396 Redeclaration = false; 7397 OldDecl = 0; 7398 } 7399 } 7400 } 7401 } 7402 7403 // C++11 [dcl.constexpr]p8: 7404 // A constexpr specifier for a non-static member function that is not 7405 // a constructor declares that member function to be const. 7406 // 7407 // This needs to be delayed until we know whether this is an out-of-line 7408 // definition of a static member function. 7409 // 7410 // This rule is not present in C++1y, so we produce a backwards 7411 // compatibility warning whenever it happens in C++11. 7412 CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(NewFD); 7413 if (!getLangOpts().CPlusPlus1y && MD && MD->isConstexpr() && 7414 !MD->isStatic() && !isa<CXXConstructorDecl>(MD) && 7415 (MD->getTypeQualifiers() & Qualifiers::Const) == 0) { 7416 CXXMethodDecl *OldMD = dyn_cast_or_null<CXXMethodDecl>(OldDecl); 7417 if (FunctionTemplateDecl *OldTD = 7418 dyn_cast_or_null<FunctionTemplateDecl>(OldDecl)) 7419 OldMD = dyn_cast<CXXMethodDecl>(OldTD->getTemplatedDecl()); 7420 if (!OldMD || !OldMD->isStatic()) { 7421 const FunctionProtoType *FPT = 7422 MD->getType()->castAs<FunctionProtoType>(); 7423 FunctionProtoType::ExtProtoInfo EPI = FPT->getExtProtoInfo(); 7424 EPI.TypeQuals |= Qualifiers::Const; 7425 MD->setType(Context.getFunctionType(FPT->getResultType(), 7426 FPT->getArgTypes(), EPI)); 7427 7428 // Warn that we did this, if we're not performing template instantiation. 7429 // In that case, we'll have warned already when the template was defined. 7430 if (ActiveTemplateInstantiations.empty()) { 7431 SourceLocation AddConstLoc; 7432 if (FunctionTypeLoc FTL = MD->getTypeSourceInfo()->getTypeLoc() 7433 .IgnoreParens().getAs<FunctionTypeLoc>()) 7434 AddConstLoc = PP.getLocForEndOfToken(FTL.getRParenLoc()); 7435 7436 Diag(MD->getLocation(), diag::warn_cxx1y_compat_constexpr_not_const) 7437 << FixItHint::CreateInsertion(AddConstLoc, " const"); 7438 } 7439 } 7440 } 7441 7442 if (Redeclaration) { 7443 // NewFD and OldDecl represent declarations that need to be 7444 // merged. 7445 if (MergeFunctionDecl(NewFD, OldDecl, S, MergeTypeWithPrevious)) { 7446 NewFD->setInvalidDecl(); 7447 return Redeclaration; 7448 } 7449 7450 Previous.clear(); 7451 Previous.addDecl(OldDecl); 7452 7453 if (FunctionTemplateDecl *OldTemplateDecl 7454 = dyn_cast<FunctionTemplateDecl>(OldDecl)) { 7455 NewFD->setPreviousDeclaration(OldTemplateDecl->getTemplatedDecl()); 7456 FunctionTemplateDecl *NewTemplateDecl 7457 = NewFD->getDescribedFunctionTemplate(); 7458 assert(NewTemplateDecl && "Template/non-template mismatch"); 7459 if (CXXMethodDecl *Method 7460 = dyn_cast<CXXMethodDecl>(NewTemplateDecl->getTemplatedDecl())) { 7461 Method->setAccess(OldTemplateDecl->getAccess()); 7462 NewTemplateDecl->setAccess(OldTemplateDecl->getAccess()); 7463 } 7464 7465 // If this is an explicit specialization of a member that is a function 7466 // template, mark it as a member specialization. 7467 if (IsExplicitSpecialization && 7468 NewTemplateDecl->getInstantiatedFromMemberTemplate()) { 7469 NewTemplateDecl->setMemberSpecialization(); 7470 assert(OldTemplateDecl->isMemberSpecialization()); 7471 } 7472 7473 } else { 7474 // This needs to happen first so that 'inline' propagates. 7475 NewFD->setPreviousDeclaration(cast<FunctionDecl>(OldDecl)); 7476 7477 if (isa<CXXMethodDecl>(NewFD)) { 7478 // A valid redeclaration of a C++ method must be out-of-line, 7479 // but (unfortunately) it's not necessarily a definition 7480 // because of templates, which means that the previous 7481 // declaration is not necessarily from the class definition. 7482 7483 // For just setting the access, that doesn't matter. 7484 CXXMethodDecl *oldMethod = cast<CXXMethodDecl>(OldDecl); 7485 NewFD->setAccess(oldMethod->getAccess()); 7486 7487 // Update the key-function state if necessary for this ABI. 7488 if (NewFD->isInlined() && 7489 !Context.getTargetInfo().getCXXABI().canKeyFunctionBeInline()) { 7490 // setNonKeyFunction needs to work with the original 7491 // declaration from the class definition, and isVirtual() is 7492 // just faster in that case, so map back to that now. 7493 oldMethod = cast<CXXMethodDecl>(oldMethod->getFirstDeclaration()); 7494 if (oldMethod->isVirtual()) { 7495 Context.setNonKeyFunction(oldMethod); 7496 } 7497 } 7498 } 7499 } 7500 } 7501 7502 // Semantic checking for this function declaration (in isolation). 7503 if (getLangOpts().CPlusPlus) { 7504 // C++-specific checks. 7505 if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(NewFD)) { 7506 CheckConstructor(Constructor); 7507 } else if (CXXDestructorDecl *Destructor = 7508 dyn_cast<CXXDestructorDecl>(NewFD)) { 7509 CXXRecordDecl *Record = Destructor->getParent(); 7510 QualType ClassType = Context.getTypeDeclType(Record); 7511 7512 // FIXME: Shouldn't we be able to perform this check even when the class 7513 // type is dependent? Both gcc and edg can handle that. 7514 if (!ClassType->isDependentType()) { 7515 DeclarationName Name 7516 = Context.DeclarationNames.getCXXDestructorName( 7517 Context.getCanonicalType(ClassType)); 7518 if (NewFD->getDeclName() != Name) { 7519 Diag(NewFD->getLocation(), diag::err_destructor_name); 7520 NewFD->setInvalidDecl(); 7521 return Redeclaration; 7522 } 7523 } 7524 } else if (CXXConversionDecl *Conversion 7525 = dyn_cast<CXXConversionDecl>(NewFD)) { 7526 ActOnConversionDeclarator(Conversion); 7527 } 7528 7529 // Find any virtual functions that this function overrides. 7530 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(NewFD)) { 7531 if (!Method->isFunctionTemplateSpecialization() && 7532 !Method->getDescribedFunctionTemplate() && 7533 Method->isCanonicalDecl()) { 7534 if (AddOverriddenMethods(Method->getParent(), Method)) { 7535 // If the function was marked as "static", we have a problem. 7536 if (NewFD->getStorageClass() == SC_Static) { 7537 ReportOverrides(*this, diag::err_static_overrides_virtual, Method); 7538 } 7539 } 7540 } 7541 7542 if (Method->isStatic()) 7543 checkThisInStaticMemberFunctionType(Method); 7544 } 7545 7546 // Extra checking for C++ overloaded operators (C++ [over.oper]). 7547 if (NewFD->isOverloadedOperator() && 7548 CheckOverloadedOperatorDeclaration(NewFD)) { 7549 NewFD->setInvalidDecl(); 7550 return Redeclaration; 7551 } 7552 7553 // Extra checking for C++0x literal operators (C++0x [over.literal]). 7554 if (NewFD->getLiteralIdentifier() && 7555 CheckLiteralOperatorDeclaration(NewFD)) { 7556 NewFD->setInvalidDecl(); 7557 return Redeclaration; 7558 } 7559 7560 // In C++, check default arguments now that we have merged decls. Unless 7561 // the lexical context is the class, because in this case this is done 7562 // during delayed parsing anyway. 7563 if (!CurContext->isRecord()) 7564 CheckCXXDefaultArguments(NewFD); 7565 7566 // If this function declares a builtin function, check the type of this 7567 // declaration against the expected type for the builtin. 7568 if (unsigned BuiltinID = NewFD->getBuiltinID()) { 7569 ASTContext::GetBuiltinTypeError Error; 7570 LookupPredefedObjCSuperType(*this, S, NewFD->getIdentifier()); 7571 QualType T = Context.GetBuiltinType(BuiltinID, Error); 7572 if (!T.isNull() && !Context.hasSameType(T, NewFD->getType())) { 7573 // The type of this function differs from the type of the builtin, 7574 // so forget about the builtin entirely. 7575 Context.BuiltinInfo.ForgetBuiltin(BuiltinID, Context.Idents); 7576 } 7577 } 7578 7579 // If this function is declared as being extern "C", then check to see if 7580 // the function returns a UDT (class, struct, or union type) that is not C 7581 // compatible, and if it does, warn the user. 7582 // But, issue any diagnostic on the first declaration only. 7583 if (NewFD->isExternC() && Previous.empty()) { 7584 QualType R = NewFD->getResultType(); 7585 if (R->isIncompleteType() && !R->isVoidType()) 7586 Diag(NewFD->getLocation(), diag::warn_return_value_udt_incomplete) 7587 << NewFD << R; 7588 else if (!R.isPODType(Context) && !R->isVoidType() && 7589 !R->isObjCObjectPointerType()) 7590 Diag(NewFD->getLocation(), diag::warn_return_value_udt) << NewFD << R; 7591 } 7592 } 7593 return Redeclaration; 7594} 7595 7596static SourceRange getResultSourceRange(const FunctionDecl *FD) { 7597 const TypeSourceInfo *TSI = FD->getTypeSourceInfo(); 7598 if (!TSI) 7599 return SourceRange(); 7600 7601 TypeLoc TL = TSI->getTypeLoc(); 7602 FunctionTypeLoc FunctionTL = TL.getAs<FunctionTypeLoc>(); 7603 if (!FunctionTL) 7604 return SourceRange(); 7605 7606 TypeLoc ResultTL = FunctionTL.getResultLoc(); 7607 if (ResultTL.getUnqualifiedLoc().getAs<BuiltinTypeLoc>()) 7608 return ResultTL.getSourceRange(); 7609 7610 return SourceRange(); 7611} 7612 7613void Sema::CheckMain(FunctionDecl* FD, const DeclSpec& DS) { 7614 // C++11 [basic.start.main]p3: A program that declares main to be inline, 7615 // static or constexpr is ill-formed. 7616 // C11 6.7.4p4: In a hosted environment, no function specifier(s) shall 7617 // appear in a declaration of main. 7618 // static main is not an error under C99, but we should warn about it. 7619 // We accept _Noreturn main as an extension. 7620 if (FD->getStorageClass() == SC_Static) 7621 Diag(DS.getStorageClassSpecLoc(), getLangOpts().CPlusPlus 7622 ? diag::err_static_main : diag::warn_static_main) 7623 << FixItHint::CreateRemoval(DS.getStorageClassSpecLoc()); 7624 if (FD->isInlineSpecified()) 7625 Diag(DS.getInlineSpecLoc(), diag::err_inline_main) 7626 << FixItHint::CreateRemoval(DS.getInlineSpecLoc()); 7627 if (DS.isNoreturnSpecified()) { 7628 SourceLocation NoreturnLoc = DS.getNoreturnSpecLoc(); 7629 SourceRange NoreturnRange(NoreturnLoc, 7630 PP.getLocForEndOfToken(NoreturnLoc)); 7631 Diag(NoreturnLoc, diag::ext_noreturn_main); 7632 Diag(NoreturnLoc, diag::note_main_remove_noreturn) 7633 << FixItHint::CreateRemoval(NoreturnRange); 7634 } 7635 if (FD->isConstexpr()) { 7636 Diag(DS.getConstexprSpecLoc(), diag::err_constexpr_main) 7637 << FixItHint::CreateRemoval(DS.getConstexprSpecLoc()); 7638 FD->setConstexpr(false); 7639 } 7640 7641 QualType T = FD->getType(); 7642 assert(T->isFunctionType() && "function decl is not of function type"); 7643 const FunctionType* FT = T->castAs<FunctionType>(); 7644 7645 // All the standards say that main() should should return 'int'. 7646 if (Context.hasSameUnqualifiedType(FT->getResultType(), Context.IntTy)) { 7647 // In C and C++, main magically returns 0 if you fall off the end; 7648 // set the flag which tells us that. 7649 // This is C++ [basic.start.main]p5 and C99 5.1.2.2.3. 7650 FD->setHasImplicitReturnZero(true); 7651 7652 // In C with GNU extensions we allow main() to have non-integer return 7653 // type, but we should warn about the extension, and we disable the 7654 // implicit-return-zero rule. 7655 } else if (getLangOpts().GNUMode && !getLangOpts().CPlusPlus) { 7656 Diag(FD->getTypeSpecStartLoc(), diag::ext_main_returns_nonint); 7657 7658 SourceRange ResultRange = getResultSourceRange(FD); 7659 if (ResultRange.isValid()) 7660 Diag(ResultRange.getBegin(), diag::note_main_change_return_type) 7661 << FixItHint::CreateReplacement(ResultRange, "int"); 7662 7663 // Otherwise, this is just a flat-out error. 7664 } else { 7665 SourceRange ResultRange = getResultSourceRange(FD); 7666 if (ResultRange.isValid()) 7667 Diag(FD->getTypeSpecStartLoc(), diag::err_main_returns_nonint) 7668 << FixItHint::CreateReplacement(ResultRange, "int"); 7669 else 7670 Diag(FD->getTypeSpecStartLoc(), diag::err_main_returns_nonint); 7671 7672 FD->setInvalidDecl(true); 7673 } 7674 7675 // Treat protoless main() as nullary. 7676 if (isa<FunctionNoProtoType>(FT)) return; 7677 7678 const FunctionProtoType* FTP = cast<const FunctionProtoType>(FT); 7679 unsigned nparams = FTP->getNumArgs(); 7680 assert(FD->getNumParams() == nparams); 7681 7682 bool HasExtraParameters = (nparams > 3); 7683 7684 // Darwin passes an undocumented fourth argument of type char**. If 7685 // other platforms start sprouting these, the logic below will start 7686 // getting shifty. 7687 if (nparams == 4 && Context.getTargetInfo().getTriple().isOSDarwin()) 7688 HasExtraParameters = false; 7689 7690 if (HasExtraParameters) { 7691 Diag(FD->getLocation(), diag::err_main_surplus_args) << nparams; 7692 FD->setInvalidDecl(true); 7693 nparams = 3; 7694 } 7695 7696 // FIXME: a lot of the following diagnostics would be improved 7697 // if we had some location information about types. 7698 7699 QualType CharPP = 7700 Context.getPointerType(Context.getPointerType(Context.CharTy)); 7701 QualType Expected[] = { Context.IntTy, CharPP, CharPP, CharPP }; 7702 7703 for (unsigned i = 0; i < nparams; ++i) { 7704 QualType AT = FTP->getArgType(i); 7705 7706 bool mismatch = true; 7707 7708 if (Context.hasSameUnqualifiedType(AT, Expected[i])) 7709 mismatch = false; 7710 else if (Expected[i] == CharPP) { 7711 // As an extension, the following forms are okay: 7712 // char const ** 7713 // char const * const * 7714 // char * const * 7715 7716 QualifierCollector qs; 7717 const PointerType* PT; 7718 if ((PT = qs.strip(AT)->getAs<PointerType>()) && 7719 (PT = qs.strip(PT->getPointeeType())->getAs<PointerType>()) && 7720 Context.hasSameType(QualType(qs.strip(PT->getPointeeType()), 0), 7721 Context.CharTy)) { 7722 qs.removeConst(); 7723 mismatch = !qs.empty(); 7724 } 7725 } 7726 7727 if (mismatch) { 7728 Diag(FD->getLocation(), diag::err_main_arg_wrong) << i << Expected[i]; 7729 // TODO: suggest replacing given type with expected type 7730 FD->setInvalidDecl(true); 7731 } 7732 } 7733 7734 if (nparams == 1 && !FD->isInvalidDecl()) { 7735 Diag(FD->getLocation(), diag::warn_main_one_arg); 7736 } 7737 7738 if (!FD->isInvalidDecl() && FD->getDescribedFunctionTemplate()) { 7739 Diag(FD->getLocation(), diag::err_main_template_decl); 7740 FD->setInvalidDecl(); 7741 } 7742} 7743 7744bool Sema::CheckForConstantInitializer(Expr *Init, QualType DclT) { 7745 // FIXME: Need strict checking. In C89, we need to check for 7746 // any assignment, increment, decrement, function-calls, or 7747 // commas outside of a sizeof. In C99, it's the same list, 7748 // except that the aforementioned are allowed in unevaluated 7749 // expressions. Everything else falls under the 7750 // "may accept other forms of constant expressions" exception. 7751 // (We never end up here for C++, so the constant expression 7752 // rules there don't matter.) 7753 if (Init->isConstantInitializer(Context, false)) 7754 return false; 7755 Diag(Init->getExprLoc(), diag::err_init_element_not_constant) 7756 << Init->getSourceRange(); 7757 return true; 7758} 7759 7760namespace { 7761 // Visits an initialization expression to see if OrigDecl is evaluated in 7762 // its own initialization and throws a warning if it does. 7763 class SelfReferenceChecker 7764 : public EvaluatedExprVisitor<SelfReferenceChecker> { 7765 Sema &S; 7766 Decl *OrigDecl; 7767 bool isRecordType; 7768 bool isPODType; 7769 bool isReferenceType; 7770 7771 public: 7772 typedef EvaluatedExprVisitor<SelfReferenceChecker> Inherited; 7773 7774 SelfReferenceChecker(Sema &S, Decl *OrigDecl) : Inherited(S.Context), 7775 S(S), OrigDecl(OrigDecl) { 7776 isPODType = false; 7777 isRecordType = false; 7778 isReferenceType = false; 7779 if (ValueDecl *VD = dyn_cast<ValueDecl>(OrigDecl)) { 7780 isPODType = VD->getType().isPODType(S.Context); 7781 isRecordType = VD->getType()->isRecordType(); 7782 isReferenceType = VD->getType()->isReferenceType(); 7783 } 7784 } 7785 7786 // For most expressions, the cast is directly above the DeclRefExpr. 7787 // For conditional operators, the cast can be outside the conditional 7788 // operator if both expressions are DeclRefExpr's. 7789 void HandleValue(Expr *E) { 7790 if (isReferenceType) 7791 return; 7792 E = E->IgnoreParenImpCasts(); 7793 if (DeclRefExpr* DRE = dyn_cast<DeclRefExpr>(E)) { 7794 HandleDeclRefExpr(DRE); 7795 return; 7796 } 7797 7798 if (ConditionalOperator *CO = dyn_cast<ConditionalOperator>(E)) { 7799 HandleValue(CO->getTrueExpr()); 7800 HandleValue(CO->getFalseExpr()); 7801 return; 7802 } 7803 7804 if (isa<MemberExpr>(E)) { 7805 Expr *Base = E->IgnoreParenImpCasts(); 7806 while (MemberExpr *ME = dyn_cast<MemberExpr>(Base)) { 7807 // Check for static member variables and don't warn on them. 7808 if (!isa<FieldDecl>(ME->getMemberDecl())) 7809 return; 7810 Base = ME->getBase()->IgnoreParenImpCasts(); 7811 } 7812 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Base)) 7813 HandleDeclRefExpr(DRE); 7814 return; 7815 } 7816 } 7817 7818 // Reference types are handled here since all uses of references are 7819 // bad, not just r-value uses. 7820 void VisitDeclRefExpr(DeclRefExpr *E) { 7821 if (isReferenceType) 7822 HandleDeclRefExpr(E); 7823 } 7824 7825 void VisitImplicitCastExpr(ImplicitCastExpr *E) { 7826 if (E->getCastKind() == CK_LValueToRValue || 7827 (isRecordType && E->getCastKind() == CK_NoOp)) 7828 HandleValue(E->getSubExpr()); 7829 7830 Inherited::VisitImplicitCastExpr(E); 7831 } 7832 7833 void VisitMemberExpr(MemberExpr *E) { 7834 // Don't warn on arrays since they can be treated as pointers. 7835 if (E->getType()->canDecayToPointerType()) return; 7836 7837 // Warn when a non-static method call is followed by non-static member 7838 // field accesses, which is followed by a DeclRefExpr. 7839 CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(E->getMemberDecl()); 7840 bool Warn = (MD && !MD->isStatic()); 7841 Expr *Base = E->getBase()->IgnoreParenImpCasts(); 7842 while (MemberExpr *ME = dyn_cast<MemberExpr>(Base)) { 7843 if (!isa<FieldDecl>(ME->getMemberDecl())) 7844 Warn = false; 7845 Base = ME->getBase()->IgnoreParenImpCasts(); 7846 } 7847 7848 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Base)) { 7849 if (Warn) 7850 HandleDeclRefExpr(DRE); 7851 return; 7852 } 7853 7854 // The base of a MemberExpr is not a MemberExpr or a DeclRefExpr. 7855 // Visit that expression. 7856 Visit(Base); 7857 } 7858 7859 void VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E) { 7860 if (E->getNumArgs() > 0) 7861 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E->getArg(0))) 7862 HandleDeclRefExpr(DRE); 7863 7864 Inherited::VisitCXXOperatorCallExpr(E); 7865 } 7866 7867 void VisitUnaryOperator(UnaryOperator *E) { 7868 // For POD record types, addresses of its own members are well-defined. 7869 if (E->getOpcode() == UO_AddrOf && isRecordType && 7870 isa<MemberExpr>(E->getSubExpr()->IgnoreParens())) { 7871 if (!isPODType) 7872 HandleValue(E->getSubExpr()); 7873 return; 7874 } 7875 Inherited::VisitUnaryOperator(E); 7876 } 7877 7878 void VisitObjCMessageExpr(ObjCMessageExpr *E) { return; } 7879 7880 void HandleDeclRefExpr(DeclRefExpr *DRE) { 7881 Decl* ReferenceDecl = DRE->getDecl(); 7882 if (OrigDecl != ReferenceDecl) return; 7883 unsigned diag; 7884 if (isReferenceType) { 7885 diag = diag::warn_uninit_self_reference_in_reference_init; 7886 } else if (cast<VarDecl>(OrigDecl)->isStaticLocal()) { 7887 diag = diag::warn_static_self_reference_in_init; 7888 } else { 7889 diag = diag::warn_uninit_self_reference_in_init; 7890 } 7891 7892 S.DiagRuntimeBehavior(DRE->getLocStart(), DRE, 7893 S.PDiag(diag) 7894 << DRE->getNameInfo().getName() 7895 << OrigDecl->getLocation() 7896 << DRE->getSourceRange()); 7897 } 7898 }; 7899 7900 /// CheckSelfReference - Warns if OrigDecl is used in expression E. 7901 static void CheckSelfReference(Sema &S, Decl* OrigDecl, Expr *E, 7902 bool DirectInit) { 7903 // Parameters arguments are occassionially constructed with itself, 7904 // for instance, in recursive functions. Skip them. 7905 if (isa<ParmVarDecl>(OrigDecl)) 7906 return; 7907 7908 E = E->IgnoreParens(); 7909 7910 // Skip checking T a = a where T is not a record or reference type. 7911 // Doing so is a way to silence uninitialized warnings. 7912 if (!DirectInit && !cast<VarDecl>(OrigDecl)->getType()->isRecordType()) 7913 if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E)) 7914 if (ICE->getCastKind() == CK_LValueToRValue) 7915 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(ICE->getSubExpr())) 7916 if (DRE->getDecl() == OrigDecl) 7917 return; 7918 7919 SelfReferenceChecker(S, OrigDecl).Visit(E); 7920 } 7921} 7922 7923/// AddInitializerToDecl - Adds the initializer Init to the 7924/// declaration dcl. If DirectInit is true, this is C++ direct 7925/// initialization rather than copy initialization. 7926void Sema::AddInitializerToDecl(Decl *RealDecl, Expr *Init, 7927 bool DirectInit, bool TypeMayContainAuto) { 7928 // If there is no declaration, there was an error parsing it. Just ignore 7929 // the initializer. 7930 if (RealDecl == 0 || RealDecl->isInvalidDecl()) 7931 return; 7932 7933 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(RealDecl)) { 7934 // With declarators parsed the way they are, the parser cannot 7935 // distinguish between a normal initializer and a pure-specifier. 7936 // Thus this grotesque test. 7937 IntegerLiteral *IL; 7938 if ((IL = dyn_cast<IntegerLiteral>(Init)) && IL->getValue() == 0 && 7939 Context.getCanonicalType(IL->getType()) == Context.IntTy) 7940 CheckPureMethod(Method, Init->getSourceRange()); 7941 else { 7942 Diag(Method->getLocation(), diag::err_member_function_initialization) 7943 << Method->getDeclName() << Init->getSourceRange(); 7944 Method->setInvalidDecl(); 7945 } 7946 return; 7947 } 7948 7949 VarDecl *VDecl = dyn_cast<VarDecl>(RealDecl); 7950 if (!VDecl) { 7951 assert(!isa<FieldDecl>(RealDecl) && "field init shouldn't get here"); 7952 Diag(RealDecl->getLocation(), diag::err_illegal_initializer); 7953 RealDecl->setInvalidDecl(); 7954 return; 7955 } 7956 ParenListExpr *CXXDirectInit = dyn_cast<ParenListExpr>(Init); 7957 7958 // C++11 [decl.spec.auto]p6. Deduce the type which 'auto' stands in for. 7959 if (TypeMayContainAuto && VDecl->getType()->isUndeducedType()) { 7960 Expr *DeduceInit = Init; 7961 // Initializer could be a C++ direct-initializer. Deduction only works if it 7962 // contains exactly one expression. 7963 if (CXXDirectInit) { 7964 if (CXXDirectInit->getNumExprs() == 0) { 7965 // It isn't possible to write this directly, but it is possible to 7966 // end up in this situation with "auto x(some_pack...);" 7967 Diag(CXXDirectInit->getLocStart(), 7968 diag::err_auto_var_init_no_expression) 7969 << VDecl->getDeclName() << VDecl->getType() 7970 << VDecl->getSourceRange(); 7971 RealDecl->setInvalidDecl(); 7972 return; 7973 } else if (CXXDirectInit->getNumExprs() > 1) { 7974 Diag(CXXDirectInit->getExpr(1)->getLocStart(), 7975 diag::err_auto_var_init_multiple_expressions) 7976 << VDecl->getDeclName() << VDecl->getType() 7977 << VDecl->getSourceRange(); 7978 RealDecl->setInvalidDecl(); 7979 return; 7980 } else { 7981 DeduceInit = CXXDirectInit->getExpr(0); 7982 } 7983 } 7984 7985 // Expressions default to 'id' when we're in a debugger. 7986 bool DefaultedToAuto = false; 7987 if (getLangOpts().DebuggerCastResultToId && 7988 Init->getType() == Context.UnknownAnyTy) { 7989 ExprResult Result = forceUnknownAnyToType(Init, Context.getObjCIdType()); 7990 if (Result.isInvalid()) { 7991 VDecl->setInvalidDecl(); 7992 return; 7993 } 7994 Init = Result.take(); 7995 DefaultedToAuto = true; 7996 } 7997 7998 QualType DeducedType; 7999 if (DeduceAutoType(VDecl->getTypeSourceInfo(), DeduceInit, DeducedType) == 8000 DAR_Failed) 8001 DiagnoseAutoDeductionFailure(VDecl, DeduceInit); 8002 if (DeducedType.isNull()) { 8003 RealDecl->setInvalidDecl(); 8004 return; 8005 } 8006 VDecl->setType(DeducedType); 8007 assert(VDecl->isLinkageValid()); 8008 8009 // In ARC, infer lifetime. 8010 if (getLangOpts().ObjCAutoRefCount && inferObjCARCLifetime(VDecl)) 8011 VDecl->setInvalidDecl(); 8012 8013 // Warn if we deduced 'id'. 'auto' usually implies type-safety, but using 8014 // 'id' instead of a specific object type prevents most of our usual checks. 8015 // We only want to warn outside of template instantiations, though: 8016 // inside a template, the 'id' could have come from a parameter. 8017 if (ActiveTemplateInstantiations.empty() && !DefaultedToAuto && 8018 DeducedType->isObjCIdType()) { 8019 SourceLocation Loc = 8020 VDecl->getTypeSourceInfo()->getTypeLoc().getBeginLoc(); 8021 Diag(Loc, diag::warn_auto_var_is_id) 8022 << VDecl->getDeclName() << DeduceInit->getSourceRange(); 8023 } 8024 8025 // If this is a redeclaration, check that the type we just deduced matches 8026 // the previously declared type. 8027 if (VarDecl *Old = VDecl->getPreviousDecl()) { 8028 // We never need to merge the type, because we cannot form an incomplete 8029 // array of auto, nor deduce such a type. 8030 MergeVarDeclTypes(VDecl, Old, /*MergeTypeWithPrevious*/false); 8031 } 8032 8033 // Check the deduced type is valid for a variable declaration. 8034 CheckVariableDeclarationType(VDecl); 8035 if (VDecl->isInvalidDecl()) 8036 return; 8037 } 8038 8039 if (VDecl->isLocalVarDecl() && VDecl->hasExternalStorage()) { 8040 // C99 6.7.8p5. C++ has no such restriction, but that is a defect. 8041 Diag(VDecl->getLocation(), diag::err_block_extern_cant_init); 8042 VDecl->setInvalidDecl(); 8043 return; 8044 } 8045 8046 if (!VDecl->getType()->isDependentType()) { 8047 // A definition must end up with a complete type, which means it must be 8048 // complete with the restriction that an array type might be completed by 8049 // the initializer; note that later code assumes this restriction. 8050 QualType BaseDeclType = VDecl->getType(); 8051 if (const ArrayType *Array = Context.getAsIncompleteArrayType(BaseDeclType)) 8052 BaseDeclType = Array->getElementType(); 8053 if (RequireCompleteType(VDecl->getLocation(), BaseDeclType, 8054 diag::err_typecheck_decl_incomplete_type)) { 8055 RealDecl->setInvalidDecl(); 8056 return; 8057 } 8058 8059 // The variable can not have an abstract class type. 8060 if (RequireNonAbstractType(VDecl->getLocation(), VDecl->getType(), 8061 diag::err_abstract_type_in_decl, 8062 AbstractVariableType)) 8063 VDecl->setInvalidDecl(); 8064 } 8065 8066 const VarDecl *Def; 8067 if ((Def = VDecl->getDefinition()) && Def != VDecl) { 8068 Diag(VDecl->getLocation(), diag::err_redefinition) 8069 << VDecl->getDeclName(); 8070 Diag(Def->getLocation(), diag::note_previous_definition); 8071 VDecl->setInvalidDecl(); 8072 return; 8073 } 8074 8075 const VarDecl* PrevInit = 0; 8076 if (getLangOpts().CPlusPlus) { 8077 // C++ [class.static.data]p4 8078 // If a static data member is of const integral or const 8079 // enumeration type, its declaration in the class definition can 8080 // specify a constant-initializer which shall be an integral 8081 // constant expression (5.19). In that case, the member can appear 8082 // in integral constant expressions. The member shall still be 8083 // defined in a namespace scope if it is used in the program and the 8084 // namespace scope definition shall not contain an initializer. 8085 // 8086 // We already performed a redefinition check above, but for static 8087 // data members we also need to check whether there was an in-class 8088 // declaration with an initializer. 8089 if (VDecl->isStaticDataMember() && VDecl->getAnyInitializer(PrevInit)) { 8090 Diag(VDecl->getLocation(), diag::err_redefinition) 8091 << VDecl->getDeclName(); 8092 Diag(PrevInit->getLocation(), diag::note_previous_definition); 8093 return; 8094 } 8095 8096 if (VDecl->hasLocalStorage()) 8097 getCurFunction()->setHasBranchProtectedScope(); 8098 8099 if (DiagnoseUnexpandedParameterPack(Init, UPPC_Initializer)) { 8100 VDecl->setInvalidDecl(); 8101 return; 8102 } 8103 } 8104 8105 // OpenCL 1.1 6.5.2: "Variables allocated in the __local address space inside 8106 // a kernel function cannot be initialized." 8107 if (VDecl->getStorageClass() == SC_OpenCLWorkGroupLocal) { 8108 Diag(VDecl->getLocation(), diag::err_local_cant_init); 8109 VDecl->setInvalidDecl(); 8110 return; 8111 } 8112 8113 // Get the decls type and save a reference for later, since 8114 // CheckInitializerTypes may change it. 8115 QualType DclT = VDecl->getType(), SavT = DclT; 8116 8117 // Expressions default to 'id' when we're in a debugger 8118 // and we are assigning it to a variable of Objective-C pointer type. 8119 if (getLangOpts().DebuggerCastResultToId && DclT->isObjCObjectPointerType() && 8120 Init->getType() == Context.UnknownAnyTy) { 8121 ExprResult Result = forceUnknownAnyToType(Init, Context.getObjCIdType()); 8122 if (Result.isInvalid()) { 8123 VDecl->setInvalidDecl(); 8124 return; 8125 } 8126 Init = Result.take(); 8127 } 8128 8129 // Perform the initialization. 8130 if (!VDecl->isInvalidDecl()) { 8131 InitializedEntity Entity = InitializedEntity::InitializeVariable(VDecl); 8132 InitializationKind Kind 8133 = DirectInit ? 8134 CXXDirectInit ? InitializationKind::CreateDirect(VDecl->getLocation(), 8135 Init->getLocStart(), 8136 Init->getLocEnd()) 8137 : InitializationKind::CreateDirectList( 8138 VDecl->getLocation()) 8139 : InitializationKind::CreateCopy(VDecl->getLocation(), 8140 Init->getLocStart()); 8141 8142 MultiExprArg Args = Init; 8143 if (CXXDirectInit) 8144 Args = MultiExprArg(CXXDirectInit->getExprs(), 8145 CXXDirectInit->getNumExprs()); 8146 8147 InitializationSequence InitSeq(*this, Entity, Kind, Args); 8148 ExprResult Result = InitSeq.Perform(*this, Entity, Kind, Args, &DclT); 8149 if (Result.isInvalid()) { 8150 VDecl->setInvalidDecl(); 8151 return; 8152 } 8153 8154 Init = Result.takeAs<Expr>(); 8155 } 8156 8157 // Check for self-references within variable initializers. 8158 // Variables declared within a function/method body (except for references) 8159 // are handled by a dataflow analysis. 8160 if (!VDecl->hasLocalStorage() || VDecl->getType()->isRecordType() || 8161 VDecl->getType()->isReferenceType()) { 8162 CheckSelfReference(*this, RealDecl, Init, DirectInit); 8163 } 8164 8165 // If the type changed, it means we had an incomplete type that was 8166 // completed by the initializer. For example: 8167 // int ary[] = { 1, 3, 5 }; 8168 // "ary" transitions from an IncompleteArrayType to a ConstantArrayType. 8169 if (!VDecl->isInvalidDecl() && (DclT != SavT)) 8170 VDecl->setType(DclT); 8171 8172 if (!VDecl->isInvalidDecl()) { 8173 checkUnsafeAssigns(VDecl->getLocation(), VDecl->getType(), Init); 8174 8175 if (VDecl->hasAttr<BlocksAttr>()) 8176 checkRetainCycles(VDecl, Init); 8177 8178 // It is safe to assign a weak reference into a strong variable. 8179 // Although this code can still have problems: 8180 // id x = self.weakProp; 8181 // id y = self.weakProp; 8182 // we do not warn to warn spuriously when 'x' and 'y' are on separate 8183 // paths through the function. This should be revisited if 8184 // -Wrepeated-use-of-weak is made flow-sensitive. 8185 if (VDecl->getType().getObjCLifetime() == Qualifiers::OCL_Strong) { 8186 DiagnosticsEngine::Level Level = 8187 Diags.getDiagnosticLevel(diag::warn_arc_repeated_use_of_weak, 8188 Init->getLocStart()); 8189 if (Level != DiagnosticsEngine::Ignored) 8190 getCurFunction()->markSafeWeakUse(Init); 8191 } 8192 } 8193 8194 // The initialization is usually a full-expression. 8195 // 8196 // FIXME: If this is a braced initialization of an aggregate, it is not 8197 // an expression, and each individual field initializer is a separate 8198 // full-expression. For instance, in: 8199 // 8200 // struct Temp { ~Temp(); }; 8201 // struct S { S(Temp); }; 8202 // struct T { S a, b; } t = { Temp(), Temp() } 8203 // 8204 // we should destroy the first Temp before constructing the second. 8205 ExprResult Result = ActOnFinishFullExpr(Init, VDecl->getLocation(), 8206 false, 8207 VDecl->isConstexpr()); 8208 if (Result.isInvalid()) { 8209 VDecl->setInvalidDecl(); 8210 return; 8211 } 8212 Init = Result.take(); 8213 8214 // Attach the initializer to the decl. 8215 VDecl->setInit(Init); 8216 8217 if (VDecl->isLocalVarDecl()) { 8218 // C99 6.7.8p4: All the expressions in an initializer for an object that has 8219 // static storage duration shall be constant expressions or string literals. 8220 // C++ does not have this restriction. 8221 if (!getLangOpts().CPlusPlus && !VDecl->isInvalidDecl()) { 8222 if (VDecl->getStorageClass() == SC_Static) 8223 CheckForConstantInitializer(Init, DclT); 8224 // C89 is stricter than C99 for non-static aggregate types. 8225 // C89 6.5.7p3: All the expressions [...] in an initializer list 8226 // for an object that has aggregate or union type shall be 8227 // constant expressions. 8228 else if (!getLangOpts().C99 && VDecl->getType()->isAggregateType() && 8229 isa<InitListExpr>(Init) && 8230 !Init->isConstantInitializer(Context, false)) 8231 Diag(Init->getExprLoc(), 8232 diag::ext_aggregate_init_not_constant) 8233 << Init->getSourceRange(); 8234 } 8235 } else if (VDecl->isStaticDataMember() && 8236 VDecl->getLexicalDeclContext()->isRecord()) { 8237 // This is an in-class initialization for a static data member, e.g., 8238 // 8239 // struct S { 8240 // static const int value = 17; 8241 // }; 8242 8243 // C++ [class.mem]p4: 8244 // A member-declarator can contain a constant-initializer only 8245 // if it declares a static member (9.4) of const integral or 8246 // const enumeration type, see 9.4.2. 8247 // 8248 // C++11 [class.static.data]p3: 8249 // If a non-volatile const static data member is of integral or 8250 // enumeration type, its declaration in the class definition can 8251 // specify a brace-or-equal-initializer in which every initalizer-clause 8252 // that is an assignment-expression is a constant expression. A static 8253 // data member of literal type can be declared in the class definition 8254 // with the constexpr specifier; if so, its declaration shall specify a 8255 // brace-or-equal-initializer in which every initializer-clause that is 8256 // an assignment-expression is a constant expression. 8257 8258 // Do nothing on dependent types. 8259 if (DclT->isDependentType()) { 8260 8261 // Allow any 'static constexpr' members, whether or not they are of literal 8262 // type. We separately check that every constexpr variable is of literal 8263 // type. 8264 } else if (VDecl->isConstexpr()) { 8265 8266 // Require constness. 8267 } else if (!DclT.isConstQualified()) { 8268 Diag(VDecl->getLocation(), diag::err_in_class_initializer_non_const) 8269 << Init->getSourceRange(); 8270 VDecl->setInvalidDecl(); 8271 8272 // We allow integer constant expressions in all cases. 8273 } else if (DclT->isIntegralOrEnumerationType()) { 8274 // Check whether the expression is a constant expression. 8275 SourceLocation Loc; 8276 if (getLangOpts().CPlusPlus11 && DclT.isVolatileQualified()) 8277 // In C++11, a non-constexpr const static data member with an 8278 // in-class initializer cannot be volatile. 8279 Diag(VDecl->getLocation(), diag::err_in_class_initializer_volatile); 8280 else if (Init->isValueDependent()) 8281 ; // Nothing to check. 8282 else if (Init->isIntegerConstantExpr(Context, &Loc)) 8283 ; // Ok, it's an ICE! 8284 else if (Init->isEvaluatable(Context)) { 8285 // If we can constant fold the initializer through heroics, accept it, 8286 // but report this as a use of an extension for -pedantic. 8287 Diag(Loc, diag::ext_in_class_initializer_non_constant) 8288 << Init->getSourceRange(); 8289 } else { 8290 // Otherwise, this is some crazy unknown case. Report the issue at the 8291 // location provided by the isIntegerConstantExpr failed check. 8292 Diag(Loc, diag::err_in_class_initializer_non_constant) 8293 << Init->getSourceRange(); 8294 VDecl->setInvalidDecl(); 8295 } 8296 8297 // We allow foldable floating-point constants as an extension. 8298 } else if (DclT->isFloatingType()) { // also permits complex, which is ok 8299 // In C++98, this is a GNU extension. In C++11, it is not, but we support 8300 // it anyway and provide a fixit to add the 'constexpr'. 8301 if (getLangOpts().CPlusPlus11) { 8302 Diag(VDecl->getLocation(), 8303 diag::ext_in_class_initializer_float_type_cxx11) 8304 << DclT << Init->getSourceRange(); 8305 Diag(VDecl->getLocStart(), 8306 diag::note_in_class_initializer_float_type_cxx11) 8307 << FixItHint::CreateInsertion(VDecl->getLocStart(), "constexpr "); 8308 } else { 8309 Diag(VDecl->getLocation(), diag::ext_in_class_initializer_float_type) 8310 << DclT << Init->getSourceRange(); 8311 8312 if (!Init->isValueDependent() && !Init->isEvaluatable(Context)) { 8313 Diag(Init->getExprLoc(), diag::err_in_class_initializer_non_constant) 8314 << Init->getSourceRange(); 8315 VDecl->setInvalidDecl(); 8316 } 8317 } 8318 8319 // Suggest adding 'constexpr' in C++11 for literal types. 8320 } else if (getLangOpts().CPlusPlus11 && DclT->isLiteralType(Context)) { 8321 Diag(VDecl->getLocation(), diag::err_in_class_initializer_literal_type) 8322 << DclT << Init->getSourceRange() 8323 << FixItHint::CreateInsertion(VDecl->getLocStart(), "constexpr "); 8324 VDecl->setConstexpr(true); 8325 8326 } else { 8327 Diag(VDecl->getLocation(), diag::err_in_class_initializer_bad_type) 8328 << DclT << Init->getSourceRange(); 8329 VDecl->setInvalidDecl(); 8330 } 8331 } else if (VDecl->isFileVarDecl()) { 8332 if (VDecl->getStorageClass() == SC_Extern && 8333 (!getLangOpts().CPlusPlus || 8334 !(Context.getBaseElementType(VDecl->getType()).isConstQualified() || 8335 VDecl->isExternC()))) 8336 Diag(VDecl->getLocation(), diag::warn_extern_init); 8337 8338 // C99 6.7.8p4. All file scoped initializers need to be constant. 8339 if (!getLangOpts().CPlusPlus && !VDecl->isInvalidDecl()) 8340 CheckForConstantInitializer(Init, DclT); 8341 else if (VDecl->getTLSKind() == VarDecl::TLS_Static && 8342 !VDecl->isInvalidDecl() && !DclT->isDependentType() && 8343 !Init->isValueDependent() && !VDecl->isConstexpr() && 8344 !Init->isConstantInitializer( 8345 Context, VDecl->getType()->isReferenceType())) { 8346 // GNU C++98 edits for __thread, [basic.start.init]p4: 8347 // An object of thread storage duration shall not require dynamic 8348 // initialization. 8349 // FIXME: Need strict checking here. 8350 Diag(VDecl->getLocation(), diag::err_thread_dynamic_init); 8351 if (getLangOpts().CPlusPlus11) 8352 Diag(VDecl->getLocation(), diag::note_use_thread_local); 8353 } 8354 } 8355 8356 // We will represent direct-initialization similarly to copy-initialization: 8357 // int x(1); -as-> int x = 1; 8358 // ClassType x(a,b,c); -as-> ClassType x = ClassType(a,b,c); 8359 // 8360 // Clients that want to distinguish between the two forms, can check for 8361 // direct initializer using VarDecl::getInitStyle(). 8362 // A major benefit is that clients that don't particularly care about which 8363 // exactly form was it (like the CodeGen) can handle both cases without 8364 // special case code. 8365 8366 // C++ 8.5p11: 8367 // The form of initialization (using parentheses or '=') is generally 8368 // insignificant, but does matter when the entity being initialized has a 8369 // class type. 8370 if (CXXDirectInit) { 8371 assert(DirectInit && "Call-style initializer must be direct init."); 8372 VDecl->setInitStyle(VarDecl::CallInit); 8373 } else if (DirectInit) { 8374 // This must be list-initialization. No other way is direct-initialization. 8375 VDecl->setInitStyle(VarDecl::ListInit); 8376 } 8377 8378 CheckCompleteVariableDeclaration(VDecl); 8379} 8380 8381/// ActOnInitializerError - Given that there was an error parsing an 8382/// initializer for the given declaration, try to return to some form 8383/// of sanity. 8384void Sema::ActOnInitializerError(Decl *D) { 8385 // Our main concern here is re-establishing invariants like "a 8386 // variable's type is either dependent or complete". 8387 if (!D || D->isInvalidDecl()) return; 8388 8389 VarDecl *VD = dyn_cast<VarDecl>(D); 8390 if (!VD) return; 8391 8392 // Auto types are meaningless if we can't make sense of the initializer. 8393 if (ParsingInitForAutoVars.count(D)) { 8394 D->setInvalidDecl(); 8395 return; 8396 } 8397 8398 QualType Ty = VD->getType(); 8399 if (Ty->isDependentType()) return; 8400 8401 // Require a complete type. 8402 if (RequireCompleteType(VD->getLocation(), 8403 Context.getBaseElementType(Ty), 8404 diag::err_typecheck_decl_incomplete_type)) { 8405 VD->setInvalidDecl(); 8406 return; 8407 } 8408 8409 // Require an abstract type. 8410 if (RequireNonAbstractType(VD->getLocation(), Ty, 8411 diag::err_abstract_type_in_decl, 8412 AbstractVariableType)) { 8413 VD->setInvalidDecl(); 8414 return; 8415 } 8416 8417 // Don't bother complaining about constructors or destructors, 8418 // though. 8419} 8420 8421void Sema::ActOnUninitializedDecl(Decl *RealDecl, 8422 bool TypeMayContainAuto) { 8423 // If there is no declaration, there was an error parsing it. Just ignore it. 8424 if (RealDecl == 0) 8425 return; 8426 8427 if (VarDecl *Var = dyn_cast<VarDecl>(RealDecl)) { 8428 QualType Type = Var->getType(); 8429 8430 // C++11 [dcl.spec.auto]p3 8431 if (TypeMayContainAuto && Type->getContainedAutoType()) { 8432 Diag(Var->getLocation(), diag::err_auto_var_requires_init) 8433 << Var->getDeclName() << Type; 8434 Var->setInvalidDecl(); 8435 return; 8436 } 8437 8438 // C++11 [class.static.data]p3: A static data member can be declared with 8439 // the constexpr specifier; if so, its declaration shall specify 8440 // a brace-or-equal-initializer. 8441 // C++11 [dcl.constexpr]p1: The constexpr specifier shall be applied only to 8442 // the definition of a variable [...] or the declaration of a static data 8443 // member. 8444 if (Var->isConstexpr() && !Var->isThisDeclarationADefinition()) { 8445 if (Var->isStaticDataMember()) 8446 Diag(Var->getLocation(), 8447 diag::err_constexpr_static_mem_var_requires_init) 8448 << Var->getDeclName(); 8449 else 8450 Diag(Var->getLocation(), diag::err_invalid_constexpr_var_decl); 8451 Var->setInvalidDecl(); 8452 return; 8453 } 8454 8455 switch (Var->isThisDeclarationADefinition()) { 8456 case VarDecl::Definition: 8457 if (!Var->isStaticDataMember() || !Var->getAnyInitializer()) 8458 break; 8459 8460 // We have an out-of-line definition of a static data member 8461 // that has an in-class initializer, so we type-check this like 8462 // a declaration. 8463 // 8464 // Fall through 8465 8466 case VarDecl::DeclarationOnly: 8467 // It's only a declaration. 8468 8469 // Block scope. C99 6.7p7: If an identifier for an object is 8470 // declared with no linkage (C99 6.2.2p6), the type for the 8471 // object shall be complete. 8472 if (!Type->isDependentType() && Var->isLocalVarDecl() && 8473 !Var->hasLinkage() && !Var->isInvalidDecl() && 8474 RequireCompleteType(Var->getLocation(), Type, 8475 diag::err_typecheck_decl_incomplete_type)) 8476 Var->setInvalidDecl(); 8477 8478 // Make sure that the type is not abstract. 8479 if (!Type->isDependentType() && !Var->isInvalidDecl() && 8480 RequireNonAbstractType(Var->getLocation(), Type, 8481 diag::err_abstract_type_in_decl, 8482 AbstractVariableType)) 8483 Var->setInvalidDecl(); 8484 if (!Type->isDependentType() && !Var->isInvalidDecl() && 8485 Var->getStorageClass() == SC_PrivateExtern) { 8486 Diag(Var->getLocation(), diag::warn_private_extern); 8487 Diag(Var->getLocation(), diag::note_private_extern); 8488 } 8489 8490 return; 8491 8492 case VarDecl::TentativeDefinition: 8493 // File scope. C99 6.9.2p2: A declaration of an identifier for an 8494 // object that has file scope without an initializer, and without a 8495 // storage-class specifier or with the storage-class specifier "static", 8496 // constitutes a tentative definition. Note: A tentative definition with 8497 // external linkage is valid (C99 6.2.2p5). 8498 if (!Var->isInvalidDecl()) { 8499 if (const IncompleteArrayType *ArrayT 8500 = Context.getAsIncompleteArrayType(Type)) { 8501 if (RequireCompleteType(Var->getLocation(), 8502 ArrayT->getElementType(), 8503 diag::err_illegal_decl_array_incomplete_type)) 8504 Var->setInvalidDecl(); 8505 } else if (Var->getStorageClass() == SC_Static) { 8506 // C99 6.9.2p3: If the declaration of an identifier for an object is 8507 // a tentative definition and has internal linkage (C99 6.2.2p3), the 8508 // declared type shall not be an incomplete type. 8509 // NOTE: code such as the following 8510 // static struct s; 8511 // struct s { int a; }; 8512 // is accepted by gcc. Hence here we issue a warning instead of 8513 // an error and we do not invalidate the static declaration. 8514 // NOTE: to avoid multiple warnings, only check the first declaration. 8515 if (Var->getPreviousDecl() == 0) 8516 RequireCompleteType(Var->getLocation(), Type, 8517 diag::ext_typecheck_decl_incomplete_type); 8518 } 8519 } 8520 8521 // Record the tentative definition; we're done. 8522 if (!Var->isInvalidDecl()) 8523 TentativeDefinitions.push_back(Var); 8524 return; 8525 } 8526 8527 // Provide a specific diagnostic for uninitialized variable 8528 // definitions with incomplete array type. 8529 if (Type->isIncompleteArrayType()) { 8530 Diag(Var->getLocation(), 8531 diag::err_typecheck_incomplete_array_needs_initializer); 8532 Var->setInvalidDecl(); 8533 return; 8534 } 8535 8536 // Provide a specific diagnostic for uninitialized variable 8537 // definitions with reference type. 8538 if (Type->isReferenceType()) { 8539 Diag(Var->getLocation(), diag::err_reference_var_requires_init) 8540 << Var->getDeclName() 8541 << SourceRange(Var->getLocation(), Var->getLocation()); 8542 Var->setInvalidDecl(); 8543 return; 8544 } 8545 8546 // Do not attempt to type-check the default initializer for a 8547 // variable with dependent type. 8548 if (Type->isDependentType()) 8549 return; 8550 8551 if (Var->isInvalidDecl()) 8552 return; 8553 8554 if (RequireCompleteType(Var->getLocation(), 8555 Context.getBaseElementType(Type), 8556 diag::err_typecheck_decl_incomplete_type)) { 8557 Var->setInvalidDecl(); 8558 return; 8559 } 8560 8561 // The variable can not have an abstract class type. 8562 if (RequireNonAbstractType(Var->getLocation(), Type, 8563 diag::err_abstract_type_in_decl, 8564 AbstractVariableType)) { 8565 Var->setInvalidDecl(); 8566 return; 8567 } 8568 8569 // Check for jumps past the implicit initializer. C++0x 8570 // clarifies that this applies to a "variable with automatic 8571 // storage duration", not a "local variable". 8572 // C++11 [stmt.dcl]p3 8573 // A program that jumps from a point where a variable with automatic 8574 // storage duration is not in scope to a point where it is in scope is 8575 // ill-formed unless the variable has scalar type, class type with a 8576 // trivial default constructor and a trivial destructor, a cv-qualified 8577 // version of one of these types, or an array of one of the preceding 8578 // types and is declared without an initializer. 8579 if (getLangOpts().CPlusPlus && Var->hasLocalStorage()) { 8580 if (const RecordType *Record 8581 = Context.getBaseElementType(Type)->getAs<RecordType>()) { 8582 CXXRecordDecl *CXXRecord = cast<CXXRecordDecl>(Record->getDecl()); 8583 // Mark the function for further checking even if the looser rules of 8584 // C++11 do not require such checks, so that we can diagnose 8585 // incompatibilities with C++98. 8586 if (!CXXRecord->isPOD()) 8587 getCurFunction()->setHasBranchProtectedScope(); 8588 } 8589 } 8590 8591 // C++03 [dcl.init]p9: 8592 // If no initializer is specified for an object, and the 8593 // object is of (possibly cv-qualified) non-POD class type (or 8594 // array thereof), the object shall be default-initialized; if 8595 // the object is of const-qualified type, the underlying class 8596 // type shall have a user-declared default 8597 // constructor. Otherwise, if no initializer is specified for 8598 // a non- static object, the object and its subobjects, if 8599 // any, have an indeterminate initial value); if the object 8600 // or any of its subobjects are of const-qualified type, the 8601 // program is ill-formed. 8602 // C++0x [dcl.init]p11: 8603 // If no initializer is specified for an object, the object is 8604 // default-initialized; [...]. 8605 InitializedEntity Entity = InitializedEntity::InitializeVariable(Var); 8606 InitializationKind Kind 8607 = InitializationKind::CreateDefault(Var->getLocation()); 8608 8609 InitializationSequence InitSeq(*this, Entity, Kind, None); 8610 ExprResult Init = InitSeq.Perform(*this, Entity, Kind, None); 8611 if (Init.isInvalid()) 8612 Var->setInvalidDecl(); 8613 else if (Init.get()) { 8614 Var->setInit(MaybeCreateExprWithCleanups(Init.get())); 8615 // This is important for template substitution. 8616 Var->setInitStyle(VarDecl::CallInit); 8617 } 8618 8619 CheckCompleteVariableDeclaration(Var); 8620 } 8621} 8622 8623void Sema::ActOnCXXForRangeDecl(Decl *D) { 8624 VarDecl *VD = dyn_cast<VarDecl>(D); 8625 if (!VD) { 8626 Diag(D->getLocation(), diag::err_for_range_decl_must_be_var); 8627 D->setInvalidDecl(); 8628 return; 8629 } 8630 8631 VD->setCXXForRangeDecl(true); 8632 8633 // for-range-declaration cannot be given a storage class specifier. 8634 int Error = -1; 8635 switch (VD->getStorageClass()) { 8636 case SC_None: 8637 break; 8638 case SC_Extern: 8639 Error = 0; 8640 break; 8641 case SC_Static: 8642 Error = 1; 8643 break; 8644 case SC_PrivateExtern: 8645 Error = 2; 8646 break; 8647 case SC_Auto: 8648 Error = 3; 8649 break; 8650 case SC_Register: 8651 Error = 4; 8652 break; 8653 case SC_OpenCLWorkGroupLocal: 8654 llvm_unreachable("Unexpected storage class"); 8655 } 8656 if (VD->isConstexpr()) 8657 Error = 5; 8658 if (Error != -1) { 8659 Diag(VD->getOuterLocStart(), diag::err_for_range_storage_class) 8660 << VD->getDeclName() << Error; 8661 D->setInvalidDecl(); 8662 } 8663} 8664 8665void Sema::CheckCompleteVariableDeclaration(VarDecl *var) { 8666 if (var->isInvalidDecl()) return; 8667 8668 // In ARC, don't allow jumps past the implicit initialization of a 8669 // local retaining variable. 8670 if (getLangOpts().ObjCAutoRefCount && 8671 var->hasLocalStorage()) { 8672 switch (var->getType().getObjCLifetime()) { 8673 case Qualifiers::OCL_None: 8674 case Qualifiers::OCL_ExplicitNone: 8675 case Qualifiers::OCL_Autoreleasing: 8676 break; 8677 8678 case Qualifiers::OCL_Weak: 8679 case Qualifiers::OCL_Strong: 8680 getCurFunction()->setHasBranchProtectedScope(); 8681 break; 8682 } 8683 } 8684 8685 if (var->isThisDeclarationADefinition() && 8686 var->isExternallyVisible() && 8687 getDiagnostics().getDiagnosticLevel( 8688 diag::warn_missing_variable_declarations, 8689 var->getLocation())) { 8690 // Find a previous declaration that's not a definition. 8691 VarDecl *prev = var->getPreviousDecl(); 8692 while (prev && prev->isThisDeclarationADefinition()) 8693 prev = prev->getPreviousDecl(); 8694 8695 if (!prev) 8696 Diag(var->getLocation(), diag::warn_missing_variable_declarations) << var; 8697 } 8698 8699 if (var->getTLSKind() == VarDecl::TLS_Static && 8700 var->getType().isDestructedType()) { 8701 // GNU C++98 edits for __thread, [basic.start.term]p3: 8702 // The type of an object with thread storage duration shall not 8703 // have a non-trivial destructor. 8704 Diag(var->getLocation(), diag::err_thread_nontrivial_dtor); 8705 if (getLangOpts().CPlusPlus11) 8706 Diag(var->getLocation(), diag::note_use_thread_local); 8707 } 8708 8709 // All the following checks are C++ only. 8710 if (!getLangOpts().CPlusPlus) return; 8711 8712 QualType type = var->getType(); 8713 if (type->isDependentType()) return; 8714 8715 // __block variables might require us to capture a copy-initializer. 8716 if (var->hasAttr<BlocksAttr>()) { 8717 // It's currently invalid to ever have a __block variable with an 8718 // array type; should we diagnose that here? 8719 8720 // Regardless, we don't want to ignore array nesting when 8721 // constructing this copy. 8722 if (type->isStructureOrClassType()) { 8723 EnterExpressionEvaluationContext scope(*this, PotentiallyEvaluated); 8724 SourceLocation poi = var->getLocation(); 8725 Expr *varRef =new (Context) DeclRefExpr(var, false, type, VK_LValue, poi); 8726 ExprResult result 8727 = PerformMoveOrCopyInitialization( 8728 InitializedEntity::InitializeBlock(poi, type, false), 8729 var, var->getType(), varRef, /*AllowNRVO=*/true); 8730 if (!result.isInvalid()) { 8731 result = MaybeCreateExprWithCleanups(result); 8732 Expr *init = result.takeAs<Expr>(); 8733 Context.setBlockVarCopyInits(var, init); 8734 } 8735 } 8736 } 8737 8738 Expr *Init = var->getInit(); 8739 bool IsGlobal = var->hasGlobalStorage() && !var->isStaticLocal(); 8740 QualType baseType = Context.getBaseElementType(type); 8741 8742 if (!var->getDeclContext()->isDependentContext() && 8743 Init && !Init->isValueDependent()) { 8744 if (IsGlobal && !var->isConstexpr() && 8745 getDiagnostics().getDiagnosticLevel(diag::warn_global_constructor, 8746 var->getLocation()) 8747 != DiagnosticsEngine::Ignored) { 8748 // Warn about globals which don't have a constant initializer. Don't 8749 // warn about globals with a non-trivial destructor because we already 8750 // warned about them. 8751 CXXRecordDecl *RD = baseType->getAsCXXRecordDecl(); 8752 if (!(RD && !RD->hasTrivialDestructor()) && 8753 !Init->isConstantInitializer(Context, baseType->isReferenceType())) 8754 Diag(var->getLocation(), diag::warn_global_constructor) 8755 << Init->getSourceRange(); 8756 } 8757 8758 if (var->isConstexpr()) { 8759 SmallVector<PartialDiagnosticAt, 8> Notes; 8760 if (!var->evaluateValue(Notes) || !var->isInitICE()) { 8761 SourceLocation DiagLoc = var->getLocation(); 8762 // If the note doesn't add any useful information other than a source 8763 // location, fold it into the primary diagnostic. 8764 if (Notes.size() == 1 && Notes[0].second.getDiagID() == 8765 diag::note_invalid_subexpr_in_const_expr) { 8766 DiagLoc = Notes[0].first; 8767 Notes.clear(); 8768 } 8769 Diag(DiagLoc, diag::err_constexpr_var_requires_const_init) 8770 << var << Init->getSourceRange(); 8771 for (unsigned I = 0, N = Notes.size(); I != N; ++I) 8772 Diag(Notes[I].first, Notes[I].second); 8773 } 8774 } else if (var->isUsableInConstantExpressions(Context)) { 8775 // Check whether the initializer of a const variable of integral or 8776 // enumeration type is an ICE now, since we can't tell whether it was 8777 // initialized by a constant expression if we check later. 8778 var->checkInitIsICE(); 8779 } 8780 } 8781 8782 // Require the destructor. 8783 if (const RecordType *recordType = baseType->getAs<RecordType>()) 8784 FinalizeVarWithDestructor(var, recordType); 8785} 8786 8787/// FinalizeDeclaration - called by ParseDeclarationAfterDeclarator to perform 8788/// any semantic actions necessary after any initializer has been attached. 8789void 8790Sema::FinalizeDeclaration(Decl *ThisDecl) { 8791 // Note that we are no longer parsing the initializer for this declaration. 8792 ParsingInitForAutoVars.erase(ThisDecl); 8793 8794 VarDecl *VD = dyn_cast_or_null<VarDecl>(ThisDecl); 8795 if (!VD) 8796 return; 8797 8798 const DeclContext *DC = VD->getDeclContext(); 8799 // If there's a #pragma GCC visibility in scope, and this isn't a class 8800 // member, set the visibility of this variable. 8801 if (!DC->isRecord() && VD->isExternallyVisible()) 8802 AddPushedVisibilityAttribute(VD); 8803 8804 if (VD->isFileVarDecl()) 8805 MarkUnusedFileScopedDecl(VD); 8806 8807 // Now we have parsed the initializer and can update the table of magic 8808 // tag values. 8809 if (!VD->hasAttr<TypeTagForDatatypeAttr>() || 8810 !VD->getType()->isIntegralOrEnumerationType()) 8811 return; 8812 8813 for (specific_attr_iterator<TypeTagForDatatypeAttr> 8814 I = ThisDecl->specific_attr_begin<TypeTagForDatatypeAttr>(), 8815 E = ThisDecl->specific_attr_end<TypeTagForDatatypeAttr>(); 8816 I != E; ++I) { 8817 const Expr *MagicValueExpr = VD->getInit(); 8818 if (!MagicValueExpr) { 8819 continue; 8820 } 8821 llvm::APSInt MagicValueInt; 8822 if (!MagicValueExpr->isIntegerConstantExpr(MagicValueInt, Context)) { 8823 Diag(I->getRange().getBegin(), 8824 diag::err_type_tag_for_datatype_not_ice) 8825 << LangOpts.CPlusPlus << MagicValueExpr->getSourceRange(); 8826 continue; 8827 } 8828 if (MagicValueInt.getActiveBits() > 64) { 8829 Diag(I->getRange().getBegin(), 8830 diag::err_type_tag_for_datatype_too_large) 8831 << LangOpts.CPlusPlus << MagicValueExpr->getSourceRange(); 8832 continue; 8833 } 8834 uint64_t MagicValue = MagicValueInt.getZExtValue(); 8835 RegisterTypeTagForDatatype(I->getArgumentKind(), 8836 MagicValue, 8837 I->getMatchingCType(), 8838 I->getLayoutCompatible(), 8839 I->getMustBeNull()); 8840 } 8841} 8842 8843Sema::DeclGroupPtrTy Sema::FinalizeDeclaratorGroup(Scope *S, const DeclSpec &DS, 8844 ArrayRef<Decl *> Group) { 8845 SmallVector<Decl*, 8> Decls; 8846 8847 if (DS.isTypeSpecOwned()) 8848 Decls.push_back(DS.getRepAsDecl()); 8849 8850 for (unsigned i = 0, e = Group.size(); i != e; ++i) 8851 if (Decl *D = Group[i]) 8852 Decls.push_back(D); 8853 8854 if (DeclSpec::isDeclRep(DS.getTypeSpecType())) { 8855 if (const TagDecl *Tag = dyn_cast_or_null<TagDecl>(DS.getRepAsDecl())) 8856 HandleTagNumbering(*this, Tag); 8857 } 8858 8859 return BuildDeclaratorGroup(Decls, DS.containsPlaceholderType()); 8860} 8861 8862/// BuildDeclaratorGroup - convert a list of declarations into a declaration 8863/// group, performing any necessary semantic checking. 8864Sema::DeclGroupPtrTy 8865Sema::BuildDeclaratorGroup(llvm::MutableArrayRef<Decl *> Group, 8866 bool TypeMayContainAuto) { 8867 // C++0x [dcl.spec.auto]p7: 8868 // If the type deduced for the template parameter U is not the same in each 8869 // deduction, the program is ill-formed. 8870 // FIXME: When initializer-list support is added, a distinction is needed 8871 // between the deduced type U and the deduced type which 'auto' stands for. 8872 // auto a = 0, b = { 1, 2, 3 }; 8873 // is legal because the deduced type U is 'int' in both cases. 8874 if (TypeMayContainAuto && Group.size() > 1) { 8875 QualType Deduced; 8876 CanQualType DeducedCanon; 8877 VarDecl *DeducedDecl = 0; 8878 for (unsigned i = 0, e = Group.size(); i != e; ++i) { 8879 if (VarDecl *D = dyn_cast<VarDecl>(Group[i])) { 8880 AutoType *AT = D->getType()->getContainedAutoType(); 8881 // Don't reissue diagnostics when instantiating a template. 8882 if (AT && D->isInvalidDecl()) 8883 break; 8884 QualType U = AT ? AT->getDeducedType() : QualType(); 8885 if (!U.isNull()) { 8886 CanQualType UCanon = Context.getCanonicalType(U); 8887 if (Deduced.isNull()) { 8888 Deduced = U; 8889 DeducedCanon = UCanon; 8890 DeducedDecl = D; 8891 } else if (DeducedCanon != UCanon) { 8892 Diag(D->getTypeSourceInfo()->getTypeLoc().getBeginLoc(), 8893 diag::err_auto_different_deductions) 8894 << (AT->isDecltypeAuto() ? 1 : 0) 8895 << Deduced << DeducedDecl->getDeclName() 8896 << U << D->getDeclName() 8897 << DeducedDecl->getInit()->getSourceRange() 8898 << D->getInit()->getSourceRange(); 8899 D->setInvalidDecl(); 8900 break; 8901 } 8902 } 8903 } 8904 } 8905 } 8906 8907 ActOnDocumentableDecls(Group); 8908 8909 return DeclGroupPtrTy::make( 8910 DeclGroupRef::Create(Context, Group.data(), Group.size())); 8911} 8912 8913void Sema::ActOnDocumentableDecl(Decl *D) { 8914 ActOnDocumentableDecls(D); 8915} 8916 8917void Sema::ActOnDocumentableDecls(ArrayRef<Decl *> Group) { 8918 // Don't parse the comment if Doxygen diagnostics are ignored. 8919 if (Group.empty() || !Group[0]) 8920 return; 8921 8922 if (Diags.getDiagnosticLevel(diag::warn_doc_param_not_found, 8923 Group[0]->getLocation()) 8924 == DiagnosticsEngine::Ignored) 8925 return; 8926 8927 if (Group.size() >= 2) { 8928 // This is a decl group. Normally it will contain only declarations 8929 // produced from declarator list. But in case we have any definitions or 8930 // additional declaration references: 8931 // 'typedef struct S {} S;' 8932 // 'typedef struct S *S;' 8933 // 'struct S *pS;' 8934 // FinalizeDeclaratorGroup adds these as separate declarations. 8935 Decl *MaybeTagDecl = Group[0]; 8936 if (MaybeTagDecl && isa<TagDecl>(MaybeTagDecl)) { 8937 Group = Group.slice(1); 8938 } 8939 } 8940 8941 // See if there are any new comments that are not attached to a decl. 8942 ArrayRef<RawComment *> Comments = Context.getRawCommentList().getComments(); 8943 if (!Comments.empty() && 8944 !Comments.back()->isAttached()) { 8945 // There is at least one comment that not attached to a decl. 8946 // Maybe it should be attached to one of these decls? 8947 // 8948 // Note that this way we pick up not only comments that precede the 8949 // declaration, but also comments that *follow* the declaration -- thanks to 8950 // the lookahead in the lexer: we've consumed the semicolon and looked 8951 // ahead through comments. 8952 for (unsigned i = 0, e = Group.size(); i != e; ++i) 8953 Context.getCommentForDecl(Group[i], &PP); 8954 } 8955} 8956 8957/// ActOnParamDeclarator - Called from Parser::ParseFunctionDeclarator() 8958/// to introduce parameters into function prototype scope. 8959Decl *Sema::ActOnParamDeclarator(Scope *S, Declarator &D) { 8960 const DeclSpec &DS = D.getDeclSpec(); 8961 8962 // Verify C99 6.7.5.3p2: The only SCS allowed is 'register'. 8963 // C++03 [dcl.stc]p2 also permits 'auto'. 8964 VarDecl::StorageClass StorageClass = SC_None; 8965 if (DS.getStorageClassSpec() == DeclSpec::SCS_register) { 8966 StorageClass = SC_Register; 8967 } else if (getLangOpts().CPlusPlus && 8968 DS.getStorageClassSpec() == DeclSpec::SCS_auto) { 8969 StorageClass = SC_Auto; 8970 } else if (DS.getStorageClassSpec() != DeclSpec::SCS_unspecified) { 8971 Diag(DS.getStorageClassSpecLoc(), 8972 diag::err_invalid_storage_class_in_func_decl); 8973 D.getMutableDeclSpec().ClearStorageClassSpecs(); 8974 } 8975 8976 if (DeclSpec::TSCS TSCS = DS.getThreadStorageClassSpec()) 8977 Diag(DS.getThreadStorageClassSpecLoc(), diag::err_invalid_thread) 8978 << DeclSpec::getSpecifierName(TSCS); 8979 if (DS.isConstexprSpecified()) 8980 Diag(DS.getConstexprSpecLoc(), diag::err_invalid_constexpr) 8981 << 0; 8982 8983 DiagnoseFunctionSpecifiers(DS); 8984 8985 TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S); 8986 QualType parmDeclType = TInfo->getType(); 8987 8988 if (getLangOpts().CPlusPlus) { 8989 // Check that there are no default arguments inside the type of this 8990 // parameter. 8991 CheckExtraCXXDefaultArguments(D); 8992 8993 // Parameter declarators cannot be qualified (C++ [dcl.meaning]p1). 8994 if (D.getCXXScopeSpec().isSet()) { 8995 Diag(D.getIdentifierLoc(), diag::err_qualified_param_declarator) 8996 << D.getCXXScopeSpec().getRange(); 8997 D.getCXXScopeSpec().clear(); 8998 } 8999 } 9000 9001 // Ensure we have a valid name 9002 IdentifierInfo *II = 0; 9003 if (D.hasName()) { 9004 II = D.getIdentifier(); 9005 if (!II) { 9006 Diag(D.getIdentifierLoc(), diag::err_bad_parameter_name) 9007 << GetNameForDeclarator(D).getName().getAsString(); 9008 D.setInvalidType(true); 9009 } 9010 } 9011 9012 // Check for redeclaration of parameters, e.g. int foo(int x, int x); 9013 if (II) { 9014 LookupResult R(*this, II, D.getIdentifierLoc(), LookupOrdinaryName, 9015 ForRedeclaration); 9016 LookupName(R, S); 9017 if (R.isSingleResult()) { 9018 NamedDecl *PrevDecl = R.getFoundDecl(); 9019 if (PrevDecl->isTemplateParameter()) { 9020 // Maybe we will complain about the shadowed template parameter. 9021 DiagnoseTemplateParameterShadow(D.getIdentifierLoc(), PrevDecl); 9022 // Just pretend that we didn't see the previous declaration. 9023 PrevDecl = 0; 9024 } else if (S->isDeclScope(PrevDecl)) { 9025 Diag(D.getIdentifierLoc(), diag::err_param_redefinition) << II; 9026 Diag(PrevDecl->getLocation(), diag::note_previous_declaration); 9027 9028 // Recover by removing the name 9029 II = 0; 9030 D.SetIdentifier(0, D.getIdentifierLoc()); 9031 D.setInvalidType(true); 9032 } 9033 } 9034 } 9035 9036 // Temporarily put parameter variables in the translation unit, not 9037 // the enclosing context. This prevents them from accidentally 9038 // looking like class members in C++. 9039 ParmVarDecl *New = CheckParameter(Context.getTranslationUnitDecl(), 9040 D.getLocStart(), 9041 D.getIdentifierLoc(), II, 9042 parmDeclType, TInfo, 9043 StorageClass); 9044 9045 if (D.isInvalidType()) 9046 New->setInvalidDecl(); 9047 9048 assert(S->isFunctionPrototypeScope()); 9049 assert(S->getFunctionPrototypeDepth() >= 1); 9050 New->setScopeInfo(S->getFunctionPrototypeDepth() - 1, 9051 S->getNextFunctionPrototypeIndex()); 9052 9053 // Add the parameter declaration into this scope. 9054 S->AddDecl(New); 9055 if (II) 9056 IdResolver.AddDecl(New); 9057 9058 ProcessDeclAttributes(S, New, D); 9059 9060 if (D.getDeclSpec().isModulePrivateSpecified()) 9061 Diag(New->getLocation(), diag::err_module_private_local) 9062 << 1 << New->getDeclName() 9063 << SourceRange(D.getDeclSpec().getModulePrivateSpecLoc()) 9064 << FixItHint::CreateRemoval(D.getDeclSpec().getModulePrivateSpecLoc()); 9065 9066 if (New->hasAttr<BlocksAttr>()) { 9067 Diag(New->getLocation(), diag::err_block_on_nonlocal); 9068 } 9069 return New; 9070} 9071 9072/// \brief Synthesizes a variable for a parameter arising from a 9073/// typedef. 9074ParmVarDecl *Sema::BuildParmVarDeclForTypedef(DeclContext *DC, 9075 SourceLocation Loc, 9076 QualType T) { 9077 /* FIXME: setting StartLoc == Loc. 9078 Would it be worth to modify callers so as to provide proper source 9079 location for the unnamed parameters, embedding the parameter's type? */ 9080 ParmVarDecl *Param = ParmVarDecl::Create(Context, DC, Loc, Loc, 0, 9081 T, Context.getTrivialTypeSourceInfo(T, Loc), 9082 SC_None, 0); 9083 Param->setImplicit(); 9084 return Param; 9085} 9086 9087void Sema::DiagnoseUnusedParameters(ParmVarDecl * const *Param, 9088 ParmVarDecl * const *ParamEnd) { 9089 // Don't diagnose unused-parameter errors in template instantiations; we 9090 // will already have done so in the template itself. 9091 if (!ActiveTemplateInstantiations.empty()) 9092 return; 9093 9094 for (; Param != ParamEnd; ++Param) { 9095 if (!(*Param)->isReferenced() && (*Param)->getDeclName() && 9096 !(*Param)->hasAttr<UnusedAttr>()) { 9097 Diag((*Param)->getLocation(), diag::warn_unused_parameter) 9098 << (*Param)->getDeclName(); 9099 } 9100 } 9101} 9102 9103void Sema::DiagnoseSizeOfParametersAndReturnValue(ParmVarDecl * const *Param, 9104 ParmVarDecl * const *ParamEnd, 9105 QualType ReturnTy, 9106 NamedDecl *D) { 9107 if (LangOpts.NumLargeByValueCopy == 0) // No check. 9108 return; 9109 9110 // Warn if the return value is pass-by-value and larger than the specified 9111 // threshold. 9112 if (!ReturnTy->isDependentType() && ReturnTy.isPODType(Context)) { 9113 unsigned Size = Context.getTypeSizeInChars(ReturnTy).getQuantity(); 9114 if (Size > LangOpts.NumLargeByValueCopy) 9115 Diag(D->getLocation(), diag::warn_return_value_size) 9116 << D->getDeclName() << Size; 9117 } 9118 9119 // Warn if any parameter is pass-by-value and larger than the specified 9120 // threshold. 9121 for (; Param != ParamEnd; ++Param) { 9122 QualType T = (*Param)->getType(); 9123 if (T->isDependentType() || !T.isPODType(Context)) 9124 continue; 9125 unsigned Size = Context.getTypeSizeInChars(T).getQuantity(); 9126 if (Size > LangOpts.NumLargeByValueCopy) 9127 Diag((*Param)->getLocation(), diag::warn_parameter_size) 9128 << (*Param)->getDeclName() << Size; 9129 } 9130} 9131 9132ParmVarDecl *Sema::CheckParameter(DeclContext *DC, SourceLocation StartLoc, 9133 SourceLocation NameLoc, IdentifierInfo *Name, 9134 QualType T, TypeSourceInfo *TSInfo, 9135 VarDecl::StorageClass StorageClass) { 9136 // In ARC, infer a lifetime qualifier for appropriate parameter types. 9137 if (getLangOpts().ObjCAutoRefCount && 9138 T.getObjCLifetime() == Qualifiers::OCL_None && 9139 T->isObjCLifetimeType()) { 9140 9141 Qualifiers::ObjCLifetime lifetime; 9142 9143 // Special cases for arrays: 9144 // - if it's const, use __unsafe_unretained 9145 // - otherwise, it's an error 9146 if (T->isArrayType()) { 9147 if (!T.isConstQualified()) { 9148 DelayedDiagnostics.add( 9149 sema::DelayedDiagnostic::makeForbiddenType( 9150 NameLoc, diag::err_arc_array_param_no_ownership, T, false)); 9151 } 9152 lifetime = Qualifiers::OCL_ExplicitNone; 9153 } else { 9154 lifetime = T->getObjCARCImplicitLifetime(); 9155 } 9156 T = Context.getLifetimeQualifiedType(T, lifetime); 9157 } 9158 9159 ParmVarDecl *New = ParmVarDecl::Create(Context, DC, StartLoc, NameLoc, Name, 9160 Context.getAdjustedParameterType(T), 9161 TSInfo, 9162 StorageClass, 0); 9163 9164 // Parameters can not be abstract class types. 9165 // For record types, this is done by the AbstractClassUsageDiagnoser once 9166 // the class has been completely parsed. 9167 if (!CurContext->isRecord() && 9168 RequireNonAbstractType(NameLoc, T, diag::err_abstract_type_in_decl, 9169 AbstractParamType)) 9170 New->setInvalidDecl(); 9171 9172 // Parameter declarators cannot be interface types. All ObjC objects are 9173 // passed by reference. 9174 if (T->isObjCObjectType()) { 9175 SourceLocation TypeEndLoc = TSInfo->getTypeLoc().getLocEnd(); 9176 Diag(NameLoc, 9177 diag::err_object_cannot_be_passed_returned_by_value) << 1 << T 9178 << FixItHint::CreateInsertion(TypeEndLoc, "*"); 9179 T = Context.getObjCObjectPointerType(T); 9180 New->setType(T); 9181 } 9182 9183 // ISO/IEC TR 18037 S6.7.3: "The type of an object with automatic storage 9184 // duration shall not be qualified by an address-space qualifier." 9185 // Since all parameters have automatic store duration, they can not have 9186 // an address space. 9187 if (T.getAddressSpace() != 0) { 9188 Diag(NameLoc, diag::err_arg_with_address_space); 9189 New->setInvalidDecl(); 9190 } 9191 9192 return New; 9193} 9194 9195void Sema::ActOnFinishKNRParamDeclarations(Scope *S, Declarator &D, 9196 SourceLocation LocAfterDecls) { 9197 DeclaratorChunk::FunctionTypeInfo &FTI = D.getFunctionTypeInfo(); 9198 9199 // Verify 6.9.1p6: 'every identifier in the identifier list shall be declared' 9200 // for a K&R function. 9201 if (!FTI.hasPrototype) { 9202 for (int i = FTI.NumArgs; i != 0; /* decrement in loop */) { 9203 --i; 9204 if (FTI.ArgInfo[i].Param == 0) { 9205 SmallString<256> Code; 9206 llvm::raw_svector_ostream(Code) << " int " 9207 << FTI.ArgInfo[i].Ident->getName() 9208 << ";\n"; 9209 Diag(FTI.ArgInfo[i].IdentLoc, diag::ext_param_not_declared) 9210 << FTI.ArgInfo[i].Ident 9211 << FixItHint::CreateInsertion(LocAfterDecls, Code.str()); 9212 9213 // Implicitly declare the argument as type 'int' for lack of a better 9214 // type. 9215 AttributeFactory attrs; 9216 DeclSpec DS(attrs); 9217 const char* PrevSpec; // unused 9218 unsigned DiagID; // unused 9219 DS.SetTypeSpecType(DeclSpec::TST_int, FTI.ArgInfo[i].IdentLoc, 9220 PrevSpec, DiagID); 9221 // Use the identifier location for the type source range. 9222 DS.SetRangeStart(FTI.ArgInfo[i].IdentLoc); 9223 DS.SetRangeEnd(FTI.ArgInfo[i].IdentLoc); 9224 Declarator ParamD(DS, Declarator::KNRTypeListContext); 9225 ParamD.SetIdentifier(FTI.ArgInfo[i].Ident, FTI.ArgInfo[i].IdentLoc); 9226 FTI.ArgInfo[i].Param = ActOnParamDeclarator(S, ParamD); 9227 } 9228 } 9229 } 9230} 9231 9232Decl *Sema::ActOnStartOfFunctionDef(Scope *FnBodyScope, Declarator &D) { 9233 assert(getCurFunctionDecl() == 0 && "Function parsing confused"); 9234 assert(D.isFunctionDeclarator() && "Not a function declarator!"); 9235 Scope *ParentScope = FnBodyScope->getParent(); 9236 9237 D.setFunctionDefinitionKind(FDK_Definition); 9238 Decl *DP = HandleDeclarator(ParentScope, D, MultiTemplateParamsArg()); 9239 return ActOnStartOfFunctionDef(FnBodyScope, DP); 9240} 9241 9242static bool ShouldWarnAboutMissingPrototype(const FunctionDecl *FD, 9243 const FunctionDecl*& PossibleZeroParamPrototype) { 9244 // Don't warn about invalid declarations. 9245 if (FD->isInvalidDecl()) 9246 return false; 9247 9248 // Or declarations that aren't global. 9249 if (!FD->isGlobal()) 9250 return false; 9251 9252 // Don't warn about C++ member functions. 9253 if (isa<CXXMethodDecl>(FD)) 9254 return false; 9255 9256 // Don't warn about 'main'. 9257 if (FD->isMain()) 9258 return false; 9259 9260 // Don't warn about inline functions. 9261 if (FD->isInlined()) 9262 return false; 9263 9264 // Don't warn about function templates. 9265 if (FD->getDescribedFunctionTemplate()) 9266 return false; 9267 9268 // Don't warn about function template specializations. 9269 if (FD->isFunctionTemplateSpecialization()) 9270 return false; 9271 9272 // Don't warn for OpenCL kernels. 9273 if (FD->hasAttr<OpenCLKernelAttr>()) 9274 return false; 9275 9276 bool MissingPrototype = true; 9277 for (const FunctionDecl *Prev = FD->getPreviousDecl(); 9278 Prev; Prev = Prev->getPreviousDecl()) { 9279 // Ignore any declarations that occur in function or method 9280 // scope, because they aren't visible from the header. 9281 if (Prev->getDeclContext()->isFunctionOrMethod()) 9282 continue; 9283 9284 MissingPrototype = !Prev->getType()->isFunctionProtoType(); 9285 if (FD->getNumParams() == 0) 9286 PossibleZeroParamPrototype = Prev; 9287 break; 9288 } 9289 9290 return MissingPrototype; 9291} 9292 9293void Sema::CheckForFunctionRedefinition(FunctionDecl *FD) { 9294 // Don't complain if we're in GNU89 mode and the previous definition 9295 // was an extern inline function. 9296 const FunctionDecl *Definition; 9297 if (FD->isDefined(Definition) && 9298 !canRedefineFunction(Definition, getLangOpts())) { 9299 if (getLangOpts().GNUMode && Definition->isInlineSpecified() && 9300 Definition->getStorageClass() == SC_Extern) 9301 Diag(FD->getLocation(), diag::err_redefinition_extern_inline) 9302 << FD->getDeclName() << getLangOpts().CPlusPlus; 9303 else 9304 Diag(FD->getLocation(), diag::err_redefinition) << FD->getDeclName(); 9305 Diag(Definition->getLocation(), diag::note_previous_definition); 9306 FD->setInvalidDecl(); 9307 } 9308} 9309 9310Decl *Sema::ActOnStartOfFunctionDef(Scope *FnBodyScope, Decl *D) { 9311 // Clear the last template instantiation error context. 9312 LastTemplateInstantiationErrorContext = ActiveTemplateInstantiation(); 9313 9314 if (!D) 9315 return D; 9316 FunctionDecl *FD = 0; 9317 9318 if (FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(D)) 9319 FD = FunTmpl->getTemplatedDecl(); 9320 else 9321 FD = cast<FunctionDecl>(D); 9322 9323 // Enter a new function scope 9324 PushFunctionScope(); 9325 9326 // See if this is a redefinition. 9327 if (!FD->isLateTemplateParsed()) 9328 CheckForFunctionRedefinition(FD); 9329 9330 // Builtin functions cannot be defined. 9331 if (unsigned BuiltinID = FD->getBuiltinID()) { 9332 if (!Context.BuiltinInfo.isPredefinedLibFunction(BuiltinID) && 9333 !Context.BuiltinInfo.isPredefinedRuntimeFunction(BuiltinID)) { 9334 Diag(FD->getLocation(), diag::err_builtin_definition) << FD; 9335 FD->setInvalidDecl(); 9336 } 9337 } 9338 9339 // The return type of a function definition must be complete 9340 // (C99 6.9.1p3, C++ [dcl.fct]p6). 9341 QualType ResultType = FD->getResultType(); 9342 if (!ResultType->isDependentType() && !ResultType->isVoidType() && 9343 !FD->isInvalidDecl() && 9344 RequireCompleteType(FD->getLocation(), ResultType, 9345 diag::err_func_def_incomplete_result)) 9346 FD->setInvalidDecl(); 9347 9348 // GNU warning -Wmissing-prototypes: 9349 // Warn if a global function is defined without a previous 9350 // prototype declaration. This warning is issued even if the 9351 // definition itself provides a prototype. The aim is to detect 9352 // global functions that fail to be declared in header files. 9353 const FunctionDecl *PossibleZeroParamPrototype = 0; 9354 if (ShouldWarnAboutMissingPrototype(FD, PossibleZeroParamPrototype)) { 9355 Diag(FD->getLocation(), diag::warn_missing_prototype) << FD; 9356 9357 if (PossibleZeroParamPrototype) { 9358 // We found a declaration that is not a prototype, 9359 // but that could be a zero-parameter prototype 9360 if (TypeSourceInfo *TI = 9361 PossibleZeroParamPrototype->getTypeSourceInfo()) { 9362 TypeLoc TL = TI->getTypeLoc(); 9363 if (FunctionNoProtoTypeLoc FTL = TL.getAs<FunctionNoProtoTypeLoc>()) 9364 Diag(PossibleZeroParamPrototype->getLocation(), 9365 diag::note_declaration_not_a_prototype) 9366 << PossibleZeroParamPrototype 9367 << FixItHint::CreateInsertion(FTL.getRParenLoc(), "void"); 9368 } 9369 } 9370 } 9371 9372 if (FnBodyScope) 9373 PushDeclContext(FnBodyScope, FD); 9374 9375 // Check the validity of our function parameters 9376 CheckParmsForFunctionDef(FD->param_begin(), FD->param_end(), 9377 /*CheckParameterNames=*/true); 9378 9379 // Introduce our parameters into the function scope 9380 for (unsigned p = 0, NumParams = FD->getNumParams(); p < NumParams; ++p) { 9381 ParmVarDecl *Param = FD->getParamDecl(p); 9382 Param->setOwningFunction(FD); 9383 9384 // If this has an identifier, add it to the scope stack. 9385 if (Param->getIdentifier() && FnBodyScope) { 9386 CheckShadow(FnBodyScope, Param); 9387 9388 PushOnScopeChains(Param, FnBodyScope); 9389 } 9390 } 9391 9392 // If we had any tags defined in the function prototype, 9393 // introduce them into the function scope. 9394 if (FnBodyScope) { 9395 for (ArrayRef<NamedDecl *>::iterator 9396 I = FD->getDeclsInPrototypeScope().begin(), 9397 E = FD->getDeclsInPrototypeScope().end(); 9398 I != E; ++I) { 9399 NamedDecl *D = *I; 9400 9401 // Some of these decls (like enums) may have been pinned to the translation unit 9402 // for lack of a real context earlier. If so, remove from the translation unit 9403 // and reattach to the current context. 9404 if (D->getLexicalDeclContext() == Context.getTranslationUnitDecl()) { 9405 // Is the decl actually in the context? 9406 for (DeclContext::decl_iterator DI = Context.getTranslationUnitDecl()->decls_begin(), 9407 DE = Context.getTranslationUnitDecl()->decls_end(); DI != DE; ++DI) { 9408 if (*DI == D) { 9409 Context.getTranslationUnitDecl()->removeDecl(D); 9410 break; 9411 } 9412 } 9413 // Either way, reassign the lexical decl context to our FunctionDecl. 9414 D->setLexicalDeclContext(CurContext); 9415 } 9416 9417 // If the decl has a non-null name, make accessible in the current scope. 9418 if (!D->getName().empty()) 9419 PushOnScopeChains(D, FnBodyScope, /*AddToContext=*/false); 9420 9421 // Similarly, dive into enums and fish their constants out, making them 9422 // accessible in this scope. 9423 if (EnumDecl *ED = dyn_cast<EnumDecl>(D)) { 9424 for (EnumDecl::enumerator_iterator EI = ED->enumerator_begin(), 9425 EE = ED->enumerator_end(); EI != EE; ++EI) 9426 PushOnScopeChains(*EI, FnBodyScope, /*AddToContext=*/false); 9427 } 9428 } 9429 } 9430 9431 // Ensure that the function's exception specification is instantiated. 9432 if (const FunctionProtoType *FPT = FD->getType()->getAs<FunctionProtoType>()) 9433 ResolveExceptionSpec(D->getLocation(), FPT); 9434 9435 // Checking attributes of current function definition 9436 // dllimport attribute. 9437 DLLImportAttr *DA = FD->getAttr<DLLImportAttr>(); 9438 if (DA && (!FD->getAttr<DLLExportAttr>())) { 9439 // dllimport attribute cannot be directly applied to definition. 9440 // Microsoft accepts dllimport for functions defined within class scope. 9441 if (!DA->isInherited() && 9442 !(LangOpts.MicrosoftExt && FD->getLexicalDeclContext()->isRecord())) { 9443 Diag(FD->getLocation(), 9444 diag::err_attribute_can_be_applied_only_to_symbol_declaration) 9445 << "dllimport"; 9446 FD->setInvalidDecl(); 9447 return D; 9448 } 9449 9450 // Visual C++ appears to not think this is an issue, so only issue 9451 // a warning when Microsoft extensions are disabled. 9452 if (!LangOpts.MicrosoftExt) { 9453 // If a symbol previously declared dllimport is later defined, the 9454 // attribute is ignored in subsequent references, and a warning is 9455 // emitted. 9456 Diag(FD->getLocation(), 9457 diag::warn_redeclaration_without_attribute_prev_attribute_ignored) 9458 << FD->getName() << "dllimport"; 9459 } 9460 } 9461 // We want to attach documentation to original Decl (which might be 9462 // a function template). 9463 ActOnDocumentableDecl(D); 9464 return D; 9465} 9466 9467/// \brief Given the set of return statements within a function body, 9468/// compute the variables that are subject to the named return value 9469/// optimization. 9470/// 9471/// Each of the variables that is subject to the named return value 9472/// optimization will be marked as NRVO variables in the AST, and any 9473/// return statement that has a marked NRVO variable as its NRVO candidate can 9474/// use the named return value optimization. 9475/// 9476/// This function applies a very simplistic algorithm for NRVO: if every return 9477/// statement in the function has the same NRVO candidate, that candidate is 9478/// the NRVO variable. 9479/// 9480/// FIXME: Employ a smarter algorithm that accounts for multiple return 9481/// statements and the lifetimes of the NRVO candidates. We should be able to 9482/// find a maximal set of NRVO variables. 9483void Sema::computeNRVO(Stmt *Body, FunctionScopeInfo *Scope) { 9484 ReturnStmt **Returns = Scope->Returns.data(); 9485 9486 const VarDecl *NRVOCandidate = 0; 9487 for (unsigned I = 0, E = Scope->Returns.size(); I != E; ++I) { 9488 if (!Returns[I]->getNRVOCandidate()) 9489 return; 9490 9491 if (!NRVOCandidate) 9492 NRVOCandidate = Returns[I]->getNRVOCandidate(); 9493 else if (NRVOCandidate != Returns[I]->getNRVOCandidate()) 9494 return; 9495 } 9496 9497 if (NRVOCandidate) 9498 const_cast<VarDecl*>(NRVOCandidate)->setNRVOVariable(true); 9499} 9500 9501bool Sema::canSkipFunctionBody(Decl *D) { 9502 if (!Consumer.shouldSkipFunctionBody(D)) 9503 return false; 9504 9505 if (isa<ObjCMethodDecl>(D)) 9506 return true; 9507 9508 FunctionDecl *FD = 0; 9509 if (FunctionTemplateDecl *FTD = dyn_cast<FunctionTemplateDecl>(D)) 9510 FD = FTD->getTemplatedDecl(); 9511 else 9512 FD = cast<FunctionDecl>(D); 9513 9514 // We cannot skip the body of a function (or function template) which is 9515 // constexpr, since we may need to evaluate its body in order to parse the 9516 // rest of the file. 9517 // We cannot skip the body of a function with an undeduced return type, 9518 // because any callers of that function need to know the type. 9519 return !FD->isConstexpr() && !FD->getResultType()->isUndeducedType(); 9520} 9521 9522Decl *Sema::ActOnSkippedFunctionBody(Decl *Decl) { 9523 if (FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(Decl)) 9524 FD->setHasSkippedBody(); 9525 else if (ObjCMethodDecl *MD = dyn_cast_or_null<ObjCMethodDecl>(Decl)) 9526 MD->setHasSkippedBody(); 9527 return ActOnFinishFunctionBody(Decl, 0); 9528} 9529 9530Decl *Sema::ActOnFinishFunctionBody(Decl *D, Stmt *BodyArg) { 9531 return ActOnFinishFunctionBody(D, BodyArg, false); 9532} 9533 9534Decl *Sema::ActOnFinishFunctionBody(Decl *dcl, Stmt *Body, 9535 bool IsInstantiation) { 9536 FunctionDecl *FD = 0; 9537 FunctionTemplateDecl *FunTmpl = dyn_cast_or_null<FunctionTemplateDecl>(dcl); 9538 if (FunTmpl) 9539 FD = FunTmpl->getTemplatedDecl(); 9540 else 9541 FD = dyn_cast_or_null<FunctionDecl>(dcl); 9542 9543 sema::AnalysisBasedWarnings::Policy WP = AnalysisWarnings.getDefaultPolicy(); 9544 sema::AnalysisBasedWarnings::Policy *ActivePolicy = 0; 9545 9546 if (FD) { 9547 FD->setBody(Body); 9548 9549 if (getLangOpts().CPlusPlus1y && !FD->isInvalidDecl() && Body && 9550 !FD->isDependentContext() && FD->getResultType()->isUndeducedType()) { 9551 // If the function has a deduced result type but contains no 'return' 9552 // statements, the result type as written must be exactly 'auto', and 9553 // the deduced result type is 'void'. 9554 if (!FD->getResultType()->getAs<AutoType>()) { 9555 Diag(dcl->getLocation(), diag::err_auto_fn_no_return_but_not_auto) 9556 << FD->getResultType(); 9557 FD->setInvalidDecl(); 9558 } else { 9559 // Substitute 'void' for the 'auto' in the type. 9560 TypeLoc ResultType = FD->getTypeSourceInfo()->getTypeLoc(). 9561 IgnoreParens().castAs<FunctionProtoTypeLoc>().getResultLoc(); 9562 Context.adjustDeducedFunctionResultType( 9563 FD, SubstAutoType(ResultType.getType(), Context.VoidTy)); 9564 } 9565 } 9566 9567 // The only way to be included in UndefinedButUsed is if there is an 9568 // ODR use before the definition. Avoid the expensive map lookup if this 9569 // is the first declaration. 9570 if (FD->getPreviousDecl() != 0 && FD->getPreviousDecl()->isUsed()) { 9571 if (!FD->isExternallyVisible()) 9572 UndefinedButUsed.erase(FD); 9573 else if (FD->isInlined() && 9574 (LangOpts.CPlusPlus || !LangOpts.GNUInline) && 9575 (!FD->getPreviousDecl()->hasAttr<GNUInlineAttr>())) 9576 UndefinedButUsed.erase(FD); 9577 } 9578 9579 // If the function implicitly returns zero (like 'main') or is naked, 9580 // don't complain about missing return statements. 9581 if (FD->hasImplicitReturnZero() || FD->hasAttr<NakedAttr>()) 9582 WP.disableCheckFallThrough(); 9583 9584 // MSVC permits the use of pure specifier (=0) on function definition, 9585 // defined at class scope, warn about this non standard construct. 9586 if (getLangOpts().MicrosoftExt && FD->isPure()) 9587 Diag(FD->getLocation(), diag::warn_pure_function_definition); 9588 9589 if (!FD->isInvalidDecl()) { 9590 DiagnoseUnusedParameters(FD->param_begin(), FD->param_end()); 9591 DiagnoseSizeOfParametersAndReturnValue(FD->param_begin(), FD->param_end(), 9592 FD->getResultType(), FD); 9593 9594 // If this is a constructor, we need a vtable. 9595 if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(FD)) 9596 MarkVTableUsed(FD->getLocation(), Constructor->getParent()); 9597 9598 // Try to apply the named return value optimization. We have to check 9599 // if we can do this here because lambdas keep return statements around 9600 // to deduce an implicit return type. 9601 if (getLangOpts().CPlusPlus && FD->getResultType()->isRecordType() && 9602 !FD->isDependentContext()) 9603 computeNRVO(Body, getCurFunction()); 9604 } 9605 9606 assert((FD == getCurFunctionDecl() || getCurLambda()->CallOperator == FD) && 9607 "Function parsing confused"); 9608 } else if (ObjCMethodDecl *MD = dyn_cast_or_null<ObjCMethodDecl>(dcl)) { 9609 assert(MD == getCurMethodDecl() && "Method parsing confused"); 9610 MD->setBody(Body); 9611 if (!MD->isInvalidDecl()) { 9612 DiagnoseUnusedParameters(MD->param_begin(), MD->param_end()); 9613 DiagnoseSizeOfParametersAndReturnValue(MD->param_begin(), MD->param_end(), 9614 MD->getResultType(), MD); 9615 9616 if (Body) 9617 computeNRVO(Body, getCurFunction()); 9618 } 9619 if (getCurFunction()->ObjCShouldCallSuper) { 9620 Diag(MD->getLocEnd(), diag::warn_objc_missing_super_call) 9621 << MD->getSelector().getAsString(); 9622 getCurFunction()->ObjCShouldCallSuper = false; 9623 } 9624 } else { 9625 return 0; 9626 } 9627 9628 assert(!getCurFunction()->ObjCShouldCallSuper && 9629 "This should only be set for ObjC methods, which should have been " 9630 "handled in the block above."); 9631 9632 // Verify and clean out per-function state. 9633 if (Body) { 9634 // C++ constructors that have function-try-blocks can't have return 9635 // statements in the handlers of that block. (C++ [except.handle]p14) 9636 // Verify this. 9637 if (FD && isa<CXXConstructorDecl>(FD) && isa<CXXTryStmt>(Body)) 9638 DiagnoseReturnInConstructorExceptionHandler(cast<CXXTryStmt>(Body)); 9639 9640 // Verify that gotos and switch cases don't jump into scopes illegally. 9641 if (getCurFunction()->NeedsScopeChecking() && 9642 !dcl->isInvalidDecl() && 9643 !hasAnyUnrecoverableErrorsInThisFunction() && 9644 !PP.isCodeCompletionEnabled()) 9645 DiagnoseInvalidJumps(Body); 9646 9647 if (CXXDestructorDecl *Destructor = dyn_cast<CXXDestructorDecl>(dcl)) { 9648 if (!Destructor->getParent()->isDependentType()) 9649 CheckDestructor(Destructor); 9650 9651 MarkBaseAndMemberDestructorsReferenced(Destructor->getLocation(), 9652 Destructor->getParent()); 9653 } 9654 9655 // If any errors have occurred, clear out any temporaries that may have 9656 // been leftover. This ensures that these temporaries won't be picked up for 9657 // deletion in some later function. 9658 if (PP.getDiagnostics().hasErrorOccurred() || 9659 PP.getDiagnostics().getSuppressAllDiagnostics()) { 9660 DiscardCleanupsInEvaluationContext(); 9661 } 9662 if (!PP.getDiagnostics().hasUncompilableErrorOccurred() && 9663 !isa<FunctionTemplateDecl>(dcl)) { 9664 // Since the body is valid, issue any analysis-based warnings that are 9665 // enabled. 9666 ActivePolicy = &WP; 9667 } 9668 9669 if (!IsInstantiation && FD && FD->isConstexpr() && !FD->isInvalidDecl() && 9670 (!CheckConstexprFunctionDecl(FD) || 9671 !CheckConstexprFunctionBody(FD, Body))) 9672 FD->setInvalidDecl(); 9673 9674 assert(ExprCleanupObjects.empty() && "Leftover temporaries in function"); 9675 assert(!ExprNeedsCleanups && "Unaccounted cleanups in function"); 9676 assert(MaybeODRUseExprs.empty() && 9677 "Leftover expressions for odr-use checking"); 9678 } 9679 9680 if (!IsInstantiation) 9681 PopDeclContext(); 9682 9683 PopFunctionScopeInfo(ActivePolicy, dcl); 9684 9685 // If any errors have occurred, clear out any temporaries that may have 9686 // been leftover. This ensures that these temporaries won't be picked up for 9687 // deletion in some later function. 9688 if (getDiagnostics().hasErrorOccurred()) { 9689 DiscardCleanupsInEvaluationContext(); 9690 } 9691 9692 return dcl; 9693} 9694 9695 9696/// When we finish delayed parsing of an attribute, we must attach it to the 9697/// relevant Decl. 9698void Sema::ActOnFinishDelayedAttribute(Scope *S, Decl *D, 9699 ParsedAttributes &Attrs) { 9700 // Always attach attributes to the underlying decl. 9701 if (TemplateDecl *TD = dyn_cast<TemplateDecl>(D)) 9702 D = TD->getTemplatedDecl(); 9703 ProcessDeclAttributeList(S, D, Attrs.getList()); 9704 9705 if (CXXMethodDecl *Method = dyn_cast_or_null<CXXMethodDecl>(D)) 9706 if (Method->isStatic()) 9707 checkThisInStaticMemberFunctionAttributes(Method); 9708} 9709 9710 9711/// ImplicitlyDefineFunction - An undeclared identifier was used in a function 9712/// call, forming a call to an implicitly defined function (per C99 6.5.1p2). 9713NamedDecl *Sema::ImplicitlyDefineFunction(SourceLocation Loc, 9714 IdentifierInfo &II, Scope *S) { 9715 // Before we produce a declaration for an implicitly defined 9716 // function, see whether there was a locally-scoped declaration of 9717 // this name as a function or variable. If so, use that 9718 // (non-visible) declaration, and complain about it. 9719 if (NamedDecl *ExternCPrev = findLocallyScopedExternCDecl(&II)) { 9720 Diag(Loc, diag::warn_use_out_of_scope_declaration) << ExternCPrev; 9721 Diag(ExternCPrev->getLocation(), diag::note_previous_declaration); 9722 return ExternCPrev; 9723 } 9724 9725 // Extension in C99. Legal in C90, but warn about it. 9726 unsigned diag_id; 9727 if (II.getName().startswith("__builtin_")) 9728 diag_id = diag::warn_builtin_unknown; 9729 else if (getLangOpts().C99) 9730 diag_id = diag::ext_implicit_function_decl; 9731 else 9732 diag_id = diag::warn_implicit_function_decl; 9733 Diag(Loc, diag_id) << &II; 9734 9735 // Because typo correction is expensive, only do it if the implicit 9736 // function declaration is going to be treated as an error. 9737 if (Diags.getDiagnosticLevel(diag_id, Loc) >= DiagnosticsEngine::Error) { 9738 TypoCorrection Corrected; 9739 DeclFilterCCC<FunctionDecl> Validator; 9740 if (S && (Corrected = CorrectTypo(DeclarationNameInfo(&II, Loc), 9741 LookupOrdinaryName, S, 0, Validator))) { 9742 std::string CorrectedStr = Corrected.getAsString(getLangOpts()); 9743 std::string CorrectedQuotedStr = Corrected.getQuoted(getLangOpts()); 9744 FunctionDecl *Func = Corrected.getCorrectionDeclAs<FunctionDecl>(); 9745 9746 Diag(Loc, diag::note_function_suggestion) << CorrectedQuotedStr 9747 << FixItHint::CreateReplacement(Loc, CorrectedStr); 9748 9749 if (Func->getLocation().isValid() 9750 && !II.getName().startswith("__builtin_")) 9751 Diag(Func->getLocation(), diag::note_previous_decl) 9752 << CorrectedQuotedStr; 9753 } 9754 } 9755 9756 // Set a Declarator for the implicit definition: int foo(); 9757 const char *Dummy; 9758 AttributeFactory attrFactory; 9759 DeclSpec DS(attrFactory); 9760 unsigned DiagID; 9761 bool Error = DS.SetTypeSpecType(DeclSpec::TST_int, Loc, Dummy, DiagID); 9762 (void)Error; // Silence warning. 9763 assert(!Error && "Error setting up implicit decl!"); 9764 SourceLocation NoLoc; 9765 Declarator D(DS, Declarator::BlockContext); 9766 D.AddTypeInfo(DeclaratorChunk::getFunction(/*HasProto=*/false, 9767 /*IsAmbiguous=*/false, 9768 /*RParenLoc=*/NoLoc, 9769 /*ArgInfo=*/0, 9770 /*NumArgs=*/0, 9771 /*EllipsisLoc=*/NoLoc, 9772 /*RParenLoc=*/NoLoc, 9773 /*TypeQuals=*/0, 9774 /*RefQualifierIsLvalueRef=*/true, 9775 /*RefQualifierLoc=*/NoLoc, 9776 /*ConstQualifierLoc=*/NoLoc, 9777 /*VolatileQualifierLoc=*/NoLoc, 9778 /*MutableLoc=*/NoLoc, 9779 EST_None, 9780 /*ESpecLoc=*/NoLoc, 9781 /*Exceptions=*/0, 9782 /*ExceptionRanges=*/0, 9783 /*NumExceptions=*/0, 9784 /*NoexceptExpr=*/0, 9785 Loc, Loc, D), 9786 DS.getAttributes(), 9787 SourceLocation()); 9788 D.SetIdentifier(&II, Loc); 9789 9790 // Insert this function into translation-unit scope. 9791 9792 DeclContext *PrevDC = CurContext; 9793 CurContext = Context.getTranslationUnitDecl(); 9794 9795 FunctionDecl *FD = cast<FunctionDecl>(ActOnDeclarator(TUScope, D)); 9796 FD->setImplicit(); 9797 9798 CurContext = PrevDC; 9799 9800 AddKnownFunctionAttributes(FD); 9801 9802 return FD; 9803} 9804 9805/// \brief Adds any function attributes that we know a priori based on 9806/// the declaration of this function. 9807/// 9808/// These attributes can apply both to implicitly-declared builtins 9809/// (like __builtin___printf_chk) or to library-declared functions 9810/// like NSLog or printf. 9811/// 9812/// We need to check for duplicate attributes both here and where user-written 9813/// attributes are applied to declarations. 9814void Sema::AddKnownFunctionAttributes(FunctionDecl *FD) { 9815 if (FD->isInvalidDecl()) 9816 return; 9817 9818 // If this is a built-in function, map its builtin attributes to 9819 // actual attributes. 9820 if (unsigned BuiltinID = FD->getBuiltinID()) { 9821 // Handle printf-formatting attributes. 9822 unsigned FormatIdx; 9823 bool HasVAListArg; 9824 if (Context.BuiltinInfo.isPrintfLike(BuiltinID, FormatIdx, HasVAListArg)) { 9825 if (!FD->getAttr<FormatAttr>()) { 9826 const char *fmt = "printf"; 9827 unsigned int NumParams = FD->getNumParams(); 9828 if (FormatIdx < NumParams && // NumParams may be 0 (e.g. vfprintf) 9829 FD->getParamDecl(FormatIdx)->getType()->isObjCObjectPointerType()) 9830 fmt = "NSString"; 9831 FD->addAttr(::new (Context) FormatAttr(FD->getLocation(), Context, 9832 fmt, FormatIdx+1, 9833 HasVAListArg ? 0 : FormatIdx+2)); 9834 } 9835 } 9836 if (Context.BuiltinInfo.isScanfLike(BuiltinID, FormatIdx, 9837 HasVAListArg)) { 9838 if (!FD->getAttr<FormatAttr>()) 9839 FD->addAttr(::new (Context) FormatAttr(FD->getLocation(), Context, 9840 "scanf", FormatIdx+1, 9841 HasVAListArg ? 0 : FormatIdx+2)); 9842 } 9843 9844 // Mark const if we don't care about errno and that is the only 9845 // thing preventing the function from being const. This allows 9846 // IRgen to use LLVM intrinsics for such functions. 9847 if (!getLangOpts().MathErrno && 9848 Context.BuiltinInfo.isConstWithoutErrno(BuiltinID)) { 9849 if (!FD->getAttr<ConstAttr>()) 9850 FD->addAttr(::new (Context) ConstAttr(FD->getLocation(), Context)); 9851 } 9852 9853 if (Context.BuiltinInfo.isReturnsTwice(BuiltinID) && 9854 !FD->getAttr<ReturnsTwiceAttr>()) 9855 FD->addAttr(::new (Context) ReturnsTwiceAttr(FD->getLocation(), Context)); 9856 if (Context.BuiltinInfo.isNoThrow(BuiltinID) && !FD->getAttr<NoThrowAttr>()) 9857 FD->addAttr(::new (Context) NoThrowAttr(FD->getLocation(), Context)); 9858 if (Context.BuiltinInfo.isConst(BuiltinID) && !FD->getAttr<ConstAttr>()) 9859 FD->addAttr(::new (Context) ConstAttr(FD->getLocation(), Context)); 9860 } 9861 9862 IdentifierInfo *Name = FD->getIdentifier(); 9863 if (!Name) 9864 return; 9865 if ((!getLangOpts().CPlusPlus && 9866 FD->getDeclContext()->isTranslationUnit()) || 9867 (isa<LinkageSpecDecl>(FD->getDeclContext()) && 9868 cast<LinkageSpecDecl>(FD->getDeclContext())->getLanguage() == 9869 LinkageSpecDecl::lang_c)) { 9870 // Okay: this could be a libc/libm/Objective-C function we know 9871 // about. 9872 } else 9873 return; 9874 9875 if (Name->isStr("asprintf") || Name->isStr("vasprintf")) { 9876 // FIXME: asprintf and vasprintf aren't C99 functions. Should they be 9877 // target-specific builtins, perhaps? 9878 if (!FD->getAttr<FormatAttr>()) 9879 FD->addAttr(::new (Context) FormatAttr(FD->getLocation(), Context, 9880 "printf", 2, 9881 Name->isStr("vasprintf") ? 0 : 3)); 9882 } 9883 9884 if (Name->isStr("__CFStringMakeConstantString")) { 9885 // We already have a __builtin___CFStringMakeConstantString, 9886 // but builds that use -fno-constant-cfstrings don't go through that. 9887 if (!FD->getAttr<FormatArgAttr>()) 9888 FD->addAttr(::new (Context) FormatArgAttr(FD->getLocation(), Context, 1)); 9889 } 9890} 9891 9892TypedefDecl *Sema::ParseTypedefDecl(Scope *S, Declarator &D, QualType T, 9893 TypeSourceInfo *TInfo) { 9894 assert(D.getIdentifier() && "Wrong callback for declspec without declarator"); 9895 assert(!T.isNull() && "GetTypeForDeclarator() returned null type"); 9896 9897 if (!TInfo) { 9898 assert(D.isInvalidType() && "no declarator info for valid type"); 9899 TInfo = Context.getTrivialTypeSourceInfo(T); 9900 } 9901 9902 // Scope manipulation handled by caller. 9903 TypedefDecl *NewTD = TypedefDecl::Create(Context, CurContext, 9904 D.getLocStart(), 9905 D.getIdentifierLoc(), 9906 D.getIdentifier(), 9907 TInfo); 9908 9909 // Bail out immediately if we have an invalid declaration. 9910 if (D.isInvalidType()) { 9911 NewTD->setInvalidDecl(); 9912 return NewTD; 9913 } 9914 9915 if (D.getDeclSpec().isModulePrivateSpecified()) { 9916 if (CurContext->isFunctionOrMethod()) 9917 Diag(NewTD->getLocation(), diag::err_module_private_local) 9918 << 2 << NewTD->getDeclName() 9919 << SourceRange(D.getDeclSpec().getModulePrivateSpecLoc()) 9920 << FixItHint::CreateRemoval(D.getDeclSpec().getModulePrivateSpecLoc()); 9921 else 9922 NewTD->setModulePrivate(); 9923 } 9924 9925 // C++ [dcl.typedef]p8: 9926 // If the typedef declaration defines an unnamed class (or 9927 // enum), the first typedef-name declared by the declaration 9928 // to be that class type (or enum type) is used to denote the 9929 // class type (or enum type) for linkage purposes only. 9930 // We need to check whether the type was declared in the declaration. 9931 switch (D.getDeclSpec().getTypeSpecType()) { 9932 case TST_enum: 9933 case TST_struct: 9934 case TST_interface: 9935 case TST_union: 9936 case TST_class: { 9937 TagDecl *tagFromDeclSpec = cast<TagDecl>(D.getDeclSpec().getRepAsDecl()); 9938 9939 // Do nothing if the tag is not anonymous or already has an 9940 // associated typedef (from an earlier typedef in this decl group). 9941 if (tagFromDeclSpec->getIdentifier()) break; 9942 if (tagFromDeclSpec->getTypedefNameForAnonDecl()) break; 9943 9944 // A well-formed anonymous tag must always be a TUK_Definition. 9945 assert(tagFromDeclSpec->isThisDeclarationADefinition()); 9946 9947 // The type must match the tag exactly; no qualifiers allowed. 9948 if (!Context.hasSameType(T, Context.getTagDeclType(tagFromDeclSpec))) 9949 break; 9950 9951 // Otherwise, set this is the anon-decl typedef for the tag. 9952 tagFromDeclSpec->setTypedefNameForAnonDecl(NewTD); 9953 break; 9954 } 9955 9956 default: 9957 break; 9958 } 9959 9960 return NewTD; 9961} 9962 9963 9964/// \brief Check that this is a valid underlying type for an enum declaration. 9965bool Sema::CheckEnumUnderlyingType(TypeSourceInfo *TI) { 9966 SourceLocation UnderlyingLoc = TI->getTypeLoc().getBeginLoc(); 9967 QualType T = TI->getType(); 9968 9969 if (T->isDependentType()) 9970 return false; 9971 9972 if (const BuiltinType *BT = T->getAs<BuiltinType>()) 9973 if (BT->isInteger()) 9974 return false; 9975 9976 Diag(UnderlyingLoc, diag::err_enum_invalid_underlying) << T; 9977 return true; 9978} 9979 9980/// Check whether this is a valid redeclaration of a previous enumeration. 9981/// \return true if the redeclaration was invalid. 9982bool Sema::CheckEnumRedeclaration(SourceLocation EnumLoc, bool IsScoped, 9983 QualType EnumUnderlyingTy, 9984 const EnumDecl *Prev) { 9985 bool IsFixed = !EnumUnderlyingTy.isNull(); 9986 9987 if (IsScoped != Prev->isScoped()) { 9988 Diag(EnumLoc, diag::err_enum_redeclare_scoped_mismatch) 9989 << Prev->isScoped(); 9990 Diag(Prev->getLocation(), diag::note_previous_use); 9991 return true; 9992 } 9993 9994 if (IsFixed && Prev->isFixed()) { 9995 if (!EnumUnderlyingTy->isDependentType() && 9996 !Prev->getIntegerType()->isDependentType() && 9997 !Context.hasSameUnqualifiedType(EnumUnderlyingTy, 9998 Prev->getIntegerType())) { 9999 Diag(EnumLoc, diag::err_enum_redeclare_type_mismatch) 10000 << EnumUnderlyingTy << Prev->getIntegerType(); 10001 Diag(Prev->getLocation(), diag::note_previous_use); 10002 return true; 10003 } 10004 } else if (IsFixed != Prev->isFixed()) { 10005 Diag(EnumLoc, diag::err_enum_redeclare_fixed_mismatch) 10006 << Prev->isFixed(); 10007 Diag(Prev->getLocation(), diag::note_previous_use); 10008 return true; 10009 } 10010 10011 return false; 10012} 10013 10014/// \brief Get diagnostic %select index for tag kind for 10015/// redeclaration diagnostic message. 10016/// WARNING: Indexes apply to particular diagnostics only! 10017/// 10018/// \returns diagnostic %select index. 10019static unsigned getRedeclDiagFromTagKind(TagTypeKind Tag) { 10020 switch (Tag) { 10021 case TTK_Struct: return 0; 10022 case TTK_Interface: return 1; 10023 case TTK_Class: return 2; 10024 default: llvm_unreachable("Invalid tag kind for redecl diagnostic!"); 10025 } 10026} 10027 10028/// \brief Determine if tag kind is a class-key compatible with 10029/// class for redeclaration (class, struct, or __interface). 10030/// 10031/// \returns true iff the tag kind is compatible. 10032static bool isClassCompatTagKind(TagTypeKind Tag) 10033{ 10034 return Tag == TTK_Struct || Tag == TTK_Class || Tag == TTK_Interface; 10035} 10036 10037/// \brief Determine whether a tag with a given kind is acceptable 10038/// as a redeclaration of the given tag declaration. 10039/// 10040/// \returns true if the new tag kind is acceptable, false otherwise. 10041bool Sema::isAcceptableTagRedeclaration(const TagDecl *Previous, 10042 TagTypeKind NewTag, bool isDefinition, 10043 SourceLocation NewTagLoc, 10044 const IdentifierInfo &Name) { 10045 // C++ [dcl.type.elab]p3: 10046 // The class-key or enum keyword present in the 10047 // elaborated-type-specifier shall agree in kind with the 10048 // declaration to which the name in the elaborated-type-specifier 10049 // refers. This rule also applies to the form of 10050 // elaborated-type-specifier that declares a class-name or 10051 // friend class since it can be construed as referring to the 10052 // definition of the class. Thus, in any 10053 // elaborated-type-specifier, the enum keyword shall be used to 10054 // refer to an enumeration (7.2), the union class-key shall be 10055 // used to refer to a union (clause 9), and either the class or 10056 // struct class-key shall be used to refer to a class (clause 9) 10057 // declared using the class or struct class-key. 10058 TagTypeKind OldTag = Previous->getTagKind(); 10059 if (!isDefinition || !isClassCompatTagKind(NewTag)) 10060 if (OldTag == NewTag) 10061 return true; 10062 10063 if (isClassCompatTagKind(OldTag) && isClassCompatTagKind(NewTag)) { 10064 // Warn about the struct/class tag mismatch. 10065 bool isTemplate = false; 10066 if (const CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(Previous)) 10067 isTemplate = Record->getDescribedClassTemplate(); 10068 10069 if (!ActiveTemplateInstantiations.empty()) { 10070 // In a template instantiation, do not offer fix-its for tag mismatches 10071 // since they usually mess up the template instead of fixing the problem. 10072 Diag(NewTagLoc, diag::warn_struct_class_tag_mismatch) 10073 << getRedeclDiagFromTagKind(NewTag) << isTemplate << &Name 10074 << getRedeclDiagFromTagKind(OldTag); 10075 return true; 10076 } 10077 10078 if (isDefinition) { 10079 // On definitions, check previous tags and issue a fix-it for each 10080 // one that doesn't match the current tag. 10081 if (Previous->getDefinition()) { 10082 // Don't suggest fix-its for redefinitions. 10083 return true; 10084 } 10085 10086 bool previousMismatch = false; 10087 for (TagDecl::redecl_iterator I(Previous->redecls_begin()), 10088 E(Previous->redecls_end()); I != E; ++I) { 10089 if (I->getTagKind() != NewTag) { 10090 if (!previousMismatch) { 10091 previousMismatch = true; 10092 Diag(NewTagLoc, diag::warn_struct_class_previous_tag_mismatch) 10093 << getRedeclDiagFromTagKind(NewTag) << isTemplate << &Name 10094 << getRedeclDiagFromTagKind(I->getTagKind()); 10095 } 10096 Diag(I->getInnerLocStart(), diag::note_struct_class_suggestion) 10097 << getRedeclDiagFromTagKind(NewTag) 10098 << FixItHint::CreateReplacement(I->getInnerLocStart(), 10099 TypeWithKeyword::getTagTypeKindName(NewTag)); 10100 } 10101 } 10102 return true; 10103 } 10104 10105 // Check for a previous definition. If current tag and definition 10106 // are same type, do nothing. If no definition, but disagree with 10107 // with previous tag type, give a warning, but no fix-it. 10108 const TagDecl *Redecl = Previous->getDefinition() ? 10109 Previous->getDefinition() : Previous; 10110 if (Redecl->getTagKind() == NewTag) { 10111 return true; 10112 } 10113 10114 Diag(NewTagLoc, diag::warn_struct_class_tag_mismatch) 10115 << getRedeclDiagFromTagKind(NewTag) << isTemplate << &Name 10116 << getRedeclDiagFromTagKind(OldTag); 10117 Diag(Redecl->getLocation(), diag::note_previous_use); 10118 10119 // If there is a previous defintion, suggest a fix-it. 10120 if (Previous->getDefinition()) { 10121 Diag(NewTagLoc, diag::note_struct_class_suggestion) 10122 << getRedeclDiagFromTagKind(Redecl->getTagKind()) 10123 << FixItHint::CreateReplacement(SourceRange(NewTagLoc), 10124 TypeWithKeyword::getTagTypeKindName(Redecl->getTagKind())); 10125 } 10126 10127 return true; 10128 } 10129 return false; 10130} 10131 10132/// ActOnTag - This is invoked when we see 'struct foo' or 'struct {'. In the 10133/// former case, Name will be non-null. In the later case, Name will be null. 10134/// TagSpec indicates what kind of tag this is. TUK indicates whether this is a 10135/// reference/declaration/definition of a tag. 10136Decl *Sema::ActOnTag(Scope *S, unsigned TagSpec, TagUseKind TUK, 10137 SourceLocation KWLoc, CXXScopeSpec &SS, 10138 IdentifierInfo *Name, SourceLocation NameLoc, 10139 AttributeList *Attr, AccessSpecifier AS, 10140 SourceLocation ModulePrivateLoc, 10141 MultiTemplateParamsArg TemplateParameterLists, 10142 bool &OwnedDecl, bool &IsDependent, 10143 SourceLocation ScopedEnumKWLoc, 10144 bool ScopedEnumUsesClassTag, 10145 TypeResult UnderlyingType) { 10146 // If this is not a definition, it must have a name. 10147 IdentifierInfo *OrigName = Name; 10148 assert((Name != 0 || TUK == TUK_Definition) && 10149 "Nameless record must be a definition!"); 10150 assert(TemplateParameterLists.size() == 0 || TUK != TUK_Reference); 10151 10152 OwnedDecl = false; 10153 TagTypeKind Kind = TypeWithKeyword::getTagTypeKindForTypeSpec(TagSpec); 10154 bool ScopedEnum = ScopedEnumKWLoc.isValid(); 10155 10156 // FIXME: Check explicit specializations more carefully. 10157 bool isExplicitSpecialization = false; 10158 bool Invalid = false; 10159 10160 // We only need to do this matching if we have template parameters 10161 // or a scope specifier, which also conveniently avoids this work 10162 // for non-C++ cases. 10163 if (TemplateParameterLists.size() > 0 || 10164 (SS.isNotEmpty() && TUK != TUK_Reference)) { 10165 if (TemplateParameterList *TemplateParams = 10166 MatchTemplateParametersToScopeSpecifier( 10167 KWLoc, NameLoc, SS, TemplateParameterLists, TUK == TUK_Friend, 10168 isExplicitSpecialization, Invalid)) { 10169 if (Kind == TTK_Enum) { 10170 Diag(KWLoc, diag::err_enum_template); 10171 return 0; 10172 } 10173 10174 if (TemplateParams->size() > 0) { 10175 // This is a declaration or definition of a class template (which may 10176 // be a member of another template). 10177 10178 if (Invalid) 10179 return 0; 10180 10181 OwnedDecl = false; 10182 DeclResult Result = CheckClassTemplate(S, TagSpec, TUK, KWLoc, 10183 SS, Name, NameLoc, Attr, 10184 TemplateParams, AS, 10185 ModulePrivateLoc, 10186 TemplateParameterLists.size()-1, 10187 TemplateParameterLists.data()); 10188 return Result.get(); 10189 } else { 10190 // The "template<>" header is extraneous. 10191 Diag(TemplateParams->getTemplateLoc(), diag::err_template_tag_noparams) 10192 << TypeWithKeyword::getTagTypeKindName(Kind) << Name; 10193 isExplicitSpecialization = true; 10194 } 10195 } 10196 } 10197 10198 // Figure out the underlying type if this a enum declaration. We need to do 10199 // this early, because it's needed to detect if this is an incompatible 10200 // redeclaration. 10201 llvm::PointerUnion<const Type*, TypeSourceInfo*> EnumUnderlying; 10202 10203 if (Kind == TTK_Enum) { 10204 if (UnderlyingType.isInvalid() || (!UnderlyingType.get() && ScopedEnum)) 10205 // No underlying type explicitly specified, or we failed to parse the 10206 // type, default to int. 10207 EnumUnderlying = Context.IntTy.getTypePtr(); 10208 else if (UnderlyingType.get()) { 10209 // C++0x 7.2p2: The type-specifier-seq of an enum-base shall name an 10210 // integral type; any cv-qualification is ignored. 10211 TypeSourceInfo *TI = 0; 10212 GetTypeFromParser(UnderlyingType.get(), &TI); 10213 EnumUnderlying = TI; 10214 10215 if (CheckEnumUnderlyingType(TI)) 10216 // Recover by falling back to int. 10217 EnumUnderlying = Context.IntTy.getTypePtr(); 10218 10219 if (DiagnoseUnexpandedParameterPack(TI->getTypeLoc().getBeginLoc(), TI, 10220 UPPC_FixedUnderlyingType)) 10221 EnumUnderlying = Context.IntTy.getTypePtr(); 10222 10223 } else if (getLangOpts().MicrosoftMode) 10224 // Microsoft enums are always of int type. 10225 EnumUnderlying = Context.IntTy.getTypePtr(); 10226 } 10227 10228 DeclContext *SearchDC = CurContext; 10229 DeclContext *DC = CurContext; 10230 bool isStdBadAlloc = false; 10231 10232 RedeclarationKind Redecl = ForRedeclaration; 10233 if (TUK == TUK_Friend || TUK == TUK_Reference) 10234 Redecl = NotForRedeclaration; 10235 10236 LookupResult Previous(*this, Name, NameLoc, LookupTagName, Redecl); 10237 bool FriendSawTagOutsideEnclosingNamespace = false; 10238 if (Name && SS.isNotEmpty()) { 10239 // We have a nested-name tag ('struct foo::bar'). 10240 10241 // Check for invalid 'foo::'. 10242 if (SS.isInvalid()) { 10243 Name = 0; 10244 goto CreateNewDecl; 10245 } 10246 10247 // If this is a friend or a reference to a class in a dependent 10248 // context, don't try to make a decl for it. 10249 if (TUK == TUK_Friend || TUK == TUK_Reference) { 10250 DC = computeDeclContext(SS, false); 10251 if (!DC) { 10252 IsDependent = true; 10253 return 0; 10254 } 10255 } else { 10256 DC = computeDeclContext(SS, true); 10257 if (!DC) { 10258 Diag(SS.getRange().getBegin(), diag::err_dependent_nested_name_spec) 10259 << SS.getRange(); 10260 return 0; 10261 } 10262 } 10263 10264 if (RequireCompleteDeclContext(SS, DC)) 10265 return 0; 10266 10267 SearchDC = DC; 10268 // Look-up name inside 'foo::'. 10269 LookupQualifiedName(Previous, DC); 10270 10271 if (Previous.isAmbiguous()) 10272 return 0; 10273 10274 if (Previous.empty()) { 10275 // Name lookup did not find anything. However, if the 10276 // nested-name-specifier refers to the current instantiation, 10277 // and that current instantiation has any dependent base 10278 // classes, we might find something at instantiation time: treat 10279 // this as a dependent elaborated-type-specifier. 10280 // But this only makes any sense for reference-like lookups. 10281 if (Previous.wasNotFoundInCurrentInstantiation() && 10282 (TUK == TUK_Reference || TUK == TUK_Friend)) { 10283 IsDependent = true; 10284 return 0; 10285 } 10286 10287 // A tag 'foo::bar' must already exist. 10288 Diag(NameLoc, diag::err_not_tag_in_scope) 10289 << Kind << Name << DC << SS.getRange(); 10290 Name = 0; 10291 Invalid = true; 10292 goto CreateNewDecl; 10293 } 10294 } else if (Name) { 10295 // If this is a named struct, check to see if there was a previous forward 10296 // declaration or definition. 10297 // FIXME: We're looking into outer scopes here, even when we 10298 // shouldn't be. Doing so can result in ambiguities that we 10299 // shouldn't be diagnosing. 10300 LookupName(Previous, S); 10301 10302 // When declaring or defining a tag, ignore ambiguities introduced 10303 // by types using'ed into this scope. 10304 if (Previous.isAmbiguous() && 10305 (TUK == TUK_Definition || TUK == TUK_Declaration)) { 10306 LookupResult::Filter F = Previous.makeFilter(); 10307 while (F.hasNext()) { 10308 NamedDecl *ND = F.next(); 10309 if (ND->getDeclContext()->getRedeclContext() != SearchDC) 10310 F.erase(); 10311 } 10312 F.done(); 10313 } 10314 10315 // C++11 [namespace.memdef]p3: 10316 // If the name in a friend declaration is neither qualified nor 10317 // a template-id and the declaration is a function or an 10318 // elaborated-type-specifier, the lookup to determine whether 10319 // the entity has been previously declared shall not consider 10320 // any scopes outside the innermost enclosing namespace. 10321 // 10322 // Does it matter that this should be by scope instead of by 10323 // semantic context? 10324 if (!Previous.empty() && TUK == TUK_Friend) { 10325 DeclContext *EnclosingNS = SearchDC->getEnclosingNamespaceContext(); 10326 LookupResult::Filter F = Previous.makeFilter(); 10327 while (F.hasNext()) { 10328 NamedDecl *ND = F.next(); 10329 DeclContext *DC = ND->getDeclContext()->getRedeclContext(); 10330 if (DC->isFileContext() && 10331 !EnclosingNS->Encloses(ND->getDeclContext())) { 10332 F.erase(); 10333 FriendSawTagOutsideEnclosingNamespace = true; 10334 } 10335 } 10336 F.done(); 10337 } 10338 10339 // Note: there used to be some attempt at recovery here. 10340 if (Previous.isAmbiguous()) 10341 return 0; 10342 10343 if (!getLangOpts().CPlusPlus && TUK != TUK_Reference) { 10344 // FIXME: This makes sure that we ignore the contexts associated 10345 // with C structs, unions, and enums when looking for a matching 10346 // tag declaration or definition. See the similar lookup tweak 10347 // in Sema::LookupName; is there a better way to deal with this? 10348 while (isa<RecordDecl>(SearchDC) || isa<EnumDecl>(SearchDC)) 10349 SearchDC = SearchDC->getParent(); 10350 } 10351 } else if (S->isFunctionPrototypeScope()) { 10352 // If this is an enum declaration in function prototype scope, set its 10353 // initial context to the translation unit. 10354 // FIXME: [citation needed] 10355 SearchDC = Context.getTranslationUnitDecl(); 10356 } 10357 10358 if (Previous.isSingleResult() && 10359 Previous.getFoundDecl()->isTemplateParameter()) { 10360 // Maybe we will complain about the shadowed template parameter. 10361 DiagnoseTemplateParameterShadow(NameLoc, Previous.getFoundDecl()); 10362 // Just pretend that we didn't see the previous declaration. 10363 Previous.clear(); 10364 } 10365 10366 if (getLangOpts().CPlusPlus && Name && DC && StdNamespace && 10367 DC->Equals(getStdNamespace()) && Name->isStr("bad_alloc")) { 10368 // This is a declaration of or a reference to "std::bad_alloc". 10369 isStdBadAlloc = true; 10370 10371 if (Previous.empty() && StdBadAlloc) { 10372 // std::bad_alloc has been implicitly declared (but made invisible to 10373 // name lookup). Fill in this implicit declaration as the previous 10374 // declaration, so that the declarations get chained appropriately. 10375 Previous.addDecl(getStdBadAlloc()); 10376 } 10377 } 10378 10379 // If we didn't find a previous declaration, and this is a reference 10380 // (or friend reference), move to the correct scope. In C++, we 10381 // also need to do a redeclaration lookup there, just in case 10382 // there's a shadow friend decl. 10383 if (Name && Previous.empty() && 10384 (TUK == TUK_Reference || TUK == TUK_Friend)) { 10385 if (Invalid) goto CreateNewDecl; 10386 assert(SS.isEmpty()); 10387 10388 if (TUK == TUK_Reference) { 10389 // C++ [basic.scope.pdecl]p5: 10390 // -- for an elaborated-type-specifier of the form 10391 // 10392 // class-key identifier 10393 // 10394 // if the elaborated-type-specifier is used in the 10395 // decl-specifier-seq or parameter-declaration-clause of a 10396 // function defined in namespace scope, the identifier is 10397 // declared as a class-name in the namespace that contains 10398 // the declaration; otherwise, except as a friend 10399 // declaration, the identifier is declared in the smallest 10400 // non-class, non-function-prototype scope that contains the 10401 // declaration. 10402 // 10403 // C99 6.7.2.3p8 has a similar (but not identical!) provision for 10404 // C structs and unions. 10405 // 10406 // It is an error in C++ to declare (rather than define) an enum 10407 // type, including via an elaborated type specifier. We'll 10408 // diagnose that later; for now, declare the enum in the same 10409 // scope as we would have picked for any other tag type. 10410 // 10411 // GNU C also supports this behavior as part of its incomplete 10412 // enum types extension, while GNU C++ does not. 10413 // 10414 // Find the context where we'll be declaring the tag. 10415 // FIXME: We would like to maintain the current DeclContext as the 10416 // lexical context, 10417 while (!SearchDC->isFileContext() && !SearchDC->isFunctionOrMethod()) 10418 SearchDC = SearchDC->getParent(); 10419 10420 // Find the scope where we'll be declaring the tag. 10421 while (S->isClassScope() || 10422 (getLangOpts().CPlusPlus && 10423 S->isFunctionPrototypeScope()) || 10424 ((S->getFlags() & Scope::DeclScope) == 0) || 10425 (S->getEntity() && 10426 ((DeclContext *)S->getEntity())->isTransparentContext())) 10427 S = S->getParent(); 10428 } else { 10429 assert(TUK == TUK_Friend); 10430 // C++ [namespace.memdef]p3: 10431 // If a friend declaration in a non-local class first declares a 10432 // class or function, the friend class or function is a member of 10433 // the innermost enclosing namespace. 10434 SearchDC = SearchDC->getEnclosingNamespaceContext(); 10435 } 10436 10437 // In C++, we need to do a redeclaration lookup to properly 10438 // diagnose some problems. 10439 if (getLangOpts().CPlusPlus) { 10440 Previous.setRedeclarationKind(ForRedeclaration); 10441 LookupQualifiedName(Previous, SearchDC); 10442 } 10443 } 10444 10445 if (!Previous.empty()) { 10446 NamedDecl *PrevDecl = (*Previous.begin())->getUnderlyingDecl(); 10447 10448 // It's okay to have a tag decl in the same scope as a typedef 10449 // which hides a tag decl in the same scope. Finding this 10450 // insanity with a redeclaration lookup can only actually happen 10451 // in C++. 10452 // 10453 // This is also okay for elaborated-type-specifiers, which is 10454 // technically forbidden by the current standard but which is 10455 // okay according to the likely resolution of an open issue; 10456 // see http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#407 10457 if (getLangOpts().CPlusPlus) { 10458 if (TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(PrevDecl)) { 10459 if (const TagType *TT = TD->getUnderlyingType()->getAs<TagType>()) { 10460 TagDecl *Tag = TT->getDecl(); 10461 if (Tag->getDeclName() == Name && 10462 Tag->getDeclContext()->getRedeclContext() 10463 ->Equals(TD->getDeclContext()->getRedeclContext())) { 10464 PrevDecl = Tag; 10465 Previous.clear(); 10466 Previous.addDecl(Tag); 10467 Previous.resolveKind(); 10468 } 10469 } 10470 } 10471 } 10472 10473 if (TagDecl *PrevTagDecl = dyn_cast<TagDecl>(PrevDecl)) { 10474 // If this is a use of a previous tag, or if the tag is already declared 10475 // in the same scope (so that the definition/declaration completes or 10476 // rementions the tag), reuse the decl. 10477 if (TUK == TUK_Reference || TUK == TUK_Friend || 10478 isDeclInScope(PrevDecl, SearchDC, S, isExplicitSpecialization)) { 10479 // Make sure that this wasn't declared as an enum and now used as a 10480 // struct or something similar. 10481 if (!isAcceptableTagRedeclaration(PrevTagDecl, Kind, 10482 TUK == TUK_Definition, KWLoc, 10483 *Name)) { 10484 bool SafeToContinue 10485 = (PrevTagDecl->getTagKind() != TTK_Enum && 10486 Kind != TTK_Enum); 10487 if (SafeToContinue) 10488 Diag(KWLoc, diag::err_use_with_wrong_tag) 10489 << Name 10490 << FixItHint::CreateReplacement(SourceRange(KWLoc), 10491 PrevTagDecl->getKindName()); 10492 else 10493 Diag(KWLoc, diag::err_use_with_wrong_tag) << Name; 10494 Diag(PrevTagDecl->getLocation(), diag::note_previous_use); 10495 10496 if (SafeToContinue) 10497 Kind = PrevTagDecl->getTagKind(); 10498 else { 10499 // Recover by making this an anonymous redefinition. 10500 Name = 0; 10501 Previous.clear(); 10502 Invalid = true; 10503 } 10504 } 10505 10506 if (Kind == TTK_Enum && PrevTagDecl->getTagKind() == TTK_Enum) { 10507 const EnumDecl *PrevEnum = cast<EnumDecl>(PrevTagDecl); 10508 10509 // If this is an elaborated-type-specifier for a scoped enumeration, 10510 // the 'class' keyword is not necessary and not permitted. 10511 if (TUK == TUK_Reference || TUK == TUK_Friend) { 10512 if (ScopedEnum) 10513 Diag(ScopedEnumKWLoc, diag::err_enum_class_reference) 10514 << PrevEnum->isScoped() 10515 << FixItHint::CreateRemoval(ScopedEnumKWLoc); 10516 return PrevTagDecl; 10517 } 10518 10519 QualType EnumUnderlyingTy; 10520 if (TypeSourceInfo *TI = EnumUnderlying.dyn_cast<TypeSourceInfo*>()) 10521 EnumUnderlyingTy = TI->getType(); 10522 else if (const Type *T = EnumUnderlying.dyn_cast<const Type*>()) 10523 EnumUnderlyingTy = QualType(T, 0); 10524 10525 // All conflicts with previous declarations are recovered by 10526 // returning the previous declaration, unless this is a definition, 10527 // in which case we want the caller to bail out. 10528 if (CheckEnumRedeclaration(NameLoc.isValid() ? NameLoc : KWLoc, 10529 ScopedEnum, EnumUnderlyingTy, PrevEnum)) 10530 return TUK == TUK_Declaration ? PrevTagDecl : 0; 10531 } 10532 10533 // C++11 [class.mem]p1: 10534 // A member shall not be declared twice in the member-specification, 10535 // except that a nested class or member class template can be declared 10536 // and then later defined. 10537 if (TUK == TUK_Declaration && PrevDecl->isCXXClassMember() && 10538 S->isDeclScope(PrevDecl)) { 10539 Diag(NameLoc, diag::ext_member_redeclared); 10540 Diag(PrevTagDecl->getLocation(), diag::note_previous_declaration); 10541 } 10542 10543 if (!Invalid) { 10544 // If this is a use, just return the declaration we found. 10545 10546 // FIXME: In the future, return a variant or some other clue 10547 // for the consumer of this Decl to know it doesn't own it. 10548 // For our current ASTs this shouldn't be a problem, but will 10549 // need to be changed with DeclGroups. 10550 if ((TUK == TUK_Reference && (!PrevTagDecl->getFriendObjectKind() || 10551 getLangOpts().MicrosoftExt)) || TUK == TUK_Friend) 10552 return PrevTagDecl; 10553 10554 // Diagnose attempts to redefine a tag. 10555 if (TUK == TUK_Definition) { 10556 if (TagDecl *Def = PrevTagDecl->getDefinition()) { 10557 // If we're defining a specialization and the previous definition 10558 // is from an implicit instantiation, don't emit an error 10559 // here; we'll catch this in the general case below. 10560 bool IsExplicitSpecializationAfterInstantiation = false; 10561 if (isExplicitSpecialization) { 10562 if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(Def)) 10563 IsExplicitSpecializationAfterInstantiation = 10564 RD->getTemplateSpecializationKind() != 10565 TSK_ExplicitSpecialization; 10566 else if (EnumDecl *ED = dyn_cast<EnumDecl>(Def)) 10567 IsExplicitSpecializationAfterInstantiation = 10568 ED->getTemplateSpecializationKind() != 10569 TSK_ExplicitSpecialization; 10570 } 10571 10572 if (!IsExplicitSpecializationAfterInstantiation) { 10573 // A redeclaration in function prototype scope in C isn't 10574 // visible elsewhere, so merely issue a warning. 10575 if (!getLangOpts().CPlusPlus && S->containedInPrototypeScope()) 10576 Diag(NameLoc, diag::warn_redefinition_in_param_list) << Name; 10577 else 10578 Diag(NameLoc, diag::err_redefinition) << Name; 10579 Diag(Def->getLocation(), diag::note_previous_definition); 10580 // If this is a redefinition, recover by making this 10581 // struct be anonymous, which will make any later 10582 // references get the previous definition. 10583 Name = 0; 10584 Previous.clear(); 10585 Invalid = true; 10586 } 10587 } else { 10588 // If the type is currently being defined, complain 10589 // about a nested redefinition. 10590 const TagType *Tag 10591 = cast<TagType>(Context.getTagDeclType(PrevTagDecl)); 10592 if (Tag->isBeingDefined()) { 10593 Diag(NameLoc, diag::err_nested_redefinition) << Name; 10594 Diag(PrevTagDecl->getLocation(), 10595 diag::note_previous_definition); 10596 Name = 0; 10597 Previous.clear(); 10598 Invalid = true; 10599 } 10600 } 10601 10602 // Okay, this is definition of a previously declared or referenced 10603 // tag PrevDecl. We're going to create a new Decl for it. 10604 } 10605 } 10606 // If we get here we have (another) forward declaration or we 10607 // have a definition. Just create a new decl. 10608 10609 } else { 10610 // If we get here, this is a definition of a new tag type in a nested 10611 // scope, e.g. "struct foo; void bar() { struct foo; }", just create a 10612 // new decl/type. We set PrevDecl to NULL so that the entities 10613 // have distinct types. 10614 Previous.clear(); 10615 } 10616 // If we get here, we're going to create a new Decl. If PrevDecl 10617 // is non-NULL, it's a definition of the tag declared by 10618 // PrevDecl. If it's NULL, we have a new definition. 10619 10620 10621 // Otherwise, PrevDecl is not a tag, but was found with tag 10622 // lookup. This is only actually possible in C++, where a few 10623 // things like templates still live in the tag namespace. 10624 } else { 10625 // Use a better diagnostic if an elaborated-type-specifier 10626 // found the wrong kind of type on the first 10627 // (non-redeclaration) lookup. 10628 if ((TUK == TUK_Reference || TUK == TUK_Friend) && 10629 !Previous.isForRedeclaration()) { 10630 unsigned Kind = 0; 10631 if (isa<TypedefDecl>(PrevDecl)) Kind = 1; 10632 else if (isa<TypeAliasDecl>(PrevDecl)) Kind = 2; 10633 else if (isa<ClassTemplateDecl>(PrevDecl)) Kind = 3; 10634 Diag(NameLoc, diag::err_tag_reference_non_tag) << Kind; 10635 Diag(PrevDecl->getLocation(), diag::note_declared_at); 10636 Invalid = true; 10637 10638 // Otherwise, only diagnose if the declaration is in scope. 10639 } else if (!isDeclInScope(PrevDecl, SearchDC, S, 10640 isExplicitSpecialization)) { 10641 // do nothing 10642 10643 // Diagnose implicit declarations introduced by elaborated types. 10644 } else if (TUK == TUK_Reference || TUK == TUK_Friend) { 10645 unsigned Kind = 0; 10646 if (isa<TypedefDecl>(PrevDecl)) Kind = 1; 10647 else if (isa<TypeAliasDecl>(PrevDecl)) Kind = 2; 10648 else if (isa<ClassTemplateDecl>(PrevDecl)) Kind = 3; 10649 Diag(NameLoc, diag::err_tag_reference_conflict) << Kind; 10650 Diag(PrevDecl->getLocation(), diag::note_previous_decl) << PrevDecl; 10651 Invalid = true; 10652 10653 // Otherwise it's a declaration. Call out a particularly common 10654 // case here. 10655 } else if (TypedefNameDecl *TND = dyn_cast<TypedefNameDecl>(PrevDecl)) { 10656 unsigned Kind = 0; 10657 if (isa<TypeAliasDecl>(PrevDecl)) Kind = 1; 10658 Diag(NameLoc, diag::err_tag_definition_of_typedef) 10659 << Name << Kind << TND->getUnderlyingType(); 10660 Diag(PrevDecl->getLocation(), diag::note_previous_decl) << PrevDecl; 10661 Invalid = true; 10662 10663 // Otherwise, diagnose. 10664 } else { 10665 // The tag name clashes with something else in the target scope, 10666 // issue an error and recover by making this tag be anonymous. 10667 Diag(NameLoc, diag::err_redefinition_different_kind) << Name; 10668 Diag(PrevDecl->getLocation(), diag::note_previous_definition); 10669 Name = 0; 10670 Invalid = true; 10671 } 10672 10673 // The existing declaration isn't relevant to us; we're in a 10674 // new scope, so clear out the previous declaration. 10675 Previous.clear(); 10676 } 10677 } 10678 10679CreateNewDecl: 10680 10681 TagDecl *PrevDecl = 0; 10682 if (Previous.isSingleResult()) 10683 PrevDecl = cast<TagDecl>(Previous.getFoundDecl()); 10684 10685 // If there is an identifier, use the location of the identifier as the 10686 // location of the decl, otherwise use the location of the struct/union 10687 // keyword. 10688 SourceLocation Loc = NameLoc.isValid() ? NameLoc : KWLoc; 10689 10690 // Otherwise, create a new declaration. If there is a previous 10691 // declaration of the same entity, the two will be linked via 10692 // PrevDecl. 10693 TagDecl *New; 10694 10695 bool IsForwardReference = false; 10696 if (Kind == TTK_Enum) { 10697 // FIXME: Tag decls should be chained to any simultaneous vardecls, e.g.: 10698 // enum X { A, B, C } D; D should chain to X. 10699 New = EnumDecl::Create(Context, SearchDC, KWLoc, Loc, Name, 10700 cast_or_null<EnumDecl>(PrevDecl), ScopedEnum, 10701 ScopedEnumUsesClassTag, !EnumUnderlying.isNull()); 10702 // If this is an undefined enum, warn. 10703 if (TUK != TUK_Definition && !Invalid) { 10704 TagDecl *Def; 10705 if ((getLangOpts().CPlusPlus11 || getLangOpts().ObjC2) && 10706 cast<EnumDecl>(New)->isFixed()) { 10707 // C++0x: 7.2p2: opaque-enum-declaration. 10708 // Conflicts are diagnosed above. Do nothing. 10709 } 10710 else if (PrevDecl && (Def = cast<EnumDecl>(PrevDecl)->getDefinition())) { 10711 Diag(Loc, diag::ext_forward_ref_enum_def) 10712 << New; 10713 Diag(Def->getLocation(), diag::note_previous_definition); 10714 } else { 10715 unsigned DiagID = diag::ext_forward_ref_enum; 10716 if (getLangOpts().MicrosoftMode) 10717 DiagID = diag::ext_ms_forward_ref_enum; 10718 else if (getLangOpts().CPlusPlus) 10719 DiagID = diag::err_forward_ref_enum; 10720 Diag(Loc, DiagID); 10721 10722 // If this is a forward-declared reference to an enumeration, make a 10723 // note of it; we won't actually be introducing the declaration into 10724 // the declaration context. 10725 if (TUK == TUK_Reference) 10726 IsForwardReference = true; 10727 } 10728 } 10729 10730 if (EnumUnderlying) { 10731 EnumDecl *ED = cast<EnumDecl>(New); 10732 if (TypeSourceInfo *TI = EnumUnderlying.dyn_cast<TypeSourceInfo*>()) 10733 ED->setIntegerTypeSourceInfo(TI); 10734 else 10735 ED->setIntegerType(QualType(EnumUnderlying.get<const Type*>(), 0)); 10736 ED->setPromotionType(ED->getIntegerType()); 10737 } 10738 10739 } else { 10740 // struct/union/class 10741 10742 // FIXME: Tag decls should be chained to any simultaneous vardecls, e.g.: 10743 // struct X { int A; } D; D should chain to X. 10744 if (getLangOpts().CPlusPlus) { 10745 // FIXME: Look for a way to use RecordDecl for simple structs. 10746 New = CXXRecordDecl::Create(Context, Kind, SearchDC, KWLoc, Loc, Name, 10747 cast_or_null<CXXRecordDecl>(PrevDecl)); 10748 10749 if (isStdBadAlloc && (!StdBadAlloc || getStdBadAlloc()->isImplicit())) 10750 StdBadAlloc = cast<CXXRecordDecl>(New); 10751 } else 10752 New = RecordDecl::Create(Context, Kind, SearchDC, KWLoc, Loc, Name, 10753 cast_or_null<RecordDecl>(PrevDecl)); 10754 } 10755 10756 // Maybe add qualifier info. 10757 if (SS.isNotEmpty()) { 10758 if (SS.isSet()) { 10759 // If this is either a declaration or a definition, check the 10760 // nested-name-specifier against the current context. We don't do this 10761 // for explicit specializations, because they have similar checking 10762 // (with more specific diagnostics) in the call to 10763 // CheckMemberSpecialization, below. 10764 if (!isExplicitSpecialization && 10765 (TUK == TUK_Definition || TUK == TUK_Declaration) && 10766 diagnoseQualifiedDeclaration(SS, DC, OrigName, NameLoc)) 10767 Invalid = true; 10768 10769 New->setQualifierInfo(SS.getWithLocInContext(Context)); 10770 if (TemplateParameterLists.size() > 0) { 10771 New->setTemplateParameterListsInfo(Context, 10772 TemplateParameterLists.size(), 10773 TemplateParameterLists.data()); 10774 } 10775 } 10776 else 10777 Invalid = true; 10778 } 10779 10780 if (RecordDecl *RD = dyn_cast<RecordDecl>(New)) { 10781 // Add alignment attributes if necessary; these attributes are checked when 10782 // the ASTContext lays out the structure. 10783 // 10784 // It is important for implementing the correct semantics that this 10785 // happen here (in act on tag decl). The #pragma pack stack is 10786 // maintained as a result of parser callbacks which can occur at 10787 // many points during the parsing of a struct declaration (because 10788 // the #pragma tokens are effectively skipped over during the 10789 // parsing of the struct). 10790 if (TUK == TUK_Definition) { 10791 AddAlignmentAttributesForRecord(RD); 10792 AddMsStructLayoutForRecord(RD); 10793 } 10794 } 10795 10796 if (ModulePrivateLoc.isValid()) { 10797 if (isExplicitSpecialization) 10798 Diag(New->getLocation(), diag::err_module_private_specialization) 10799 << 2 10800 << FixItHint::CreateRemoval(ModulePrivateLoc); 10801 // __module_private__ does not apply to local classes. However, we only 10802 // diagnose this as an error when the declaration specifiers are 10803 // freestanding. Here, we just ignore the __module_private__. 10804 else if (!SearchDC->isFunctionOrMethod()) 10805 New->setModulePrivate(); 10806 } 10807 10808 // If this is a specialization of a member class (of a class template), 10809 // check the specialization. 10810 if (isExplicitSpecialization && CheckMemberSpecialization(New, Previous)) 10811 Invalid = true; 10812 10813 if (Invalid) 10814 New->setInvalidDecl(); 10815 10816 if (Attr) 10817 ProcessDeclAttributeList(S, New, Attr); 10818 10819 // If we're declaring or defining a tag in function prototype scope 10820 // in C, note that this type can only be used within the function. 10821 if (Name && S->isFunctionPrototypeScope() && !getLangOpts().CPlusPlus) 10822 Diag(Loc, diag::warn_decl_in_param_list) << Context.getTagDeclType(New); 10823 10824 // Set the lexical context. If the tag has a C++ scope specifier, the 10825 // lexical context will be different from the semantic context. 10826 New->setLexicalDeclContext(CurContext); 10827 10828 // Mark this as a friend decl if applicable. 10829 // In Microsoft mode, a friend declaration also acts as a forward 10830 // declaration so we always pass true to setObjectOfFriendDecl to make 10831 // the tag name visible. 10832 if (TUK == TUK_Friend) 10833 New->setObjectOfFriendDecl(!FriendSawTagOutsideEnclosingNamespace && 10834 getLangOpts().MicrosoftExt); 10835 10836 // Set the access specifier. 10837 if (!Invalid && SearchDC->isRecord()) 10838 SetMemberAccessSpecifier(New, PrevDecl, AS); 10839 10840 if (TUK == TUK_Definition) 10841 New->startDefinition(); 10842 10843 // If this has an identifier, add it to the scope stack. 10844 if (TUK == TUK_Friend) { 10845 // We might be replacing an existing declaration in the lookup tables; 10846 // if so, borrow its access specifier. 10847 if (PrevDecl) 10848 New->setAccess(PrevDecl->getAccess()); 10849 10850 DeclContext *DC = New->getDeclContext()->getRedeclContext(); 10851 DC->makeDeclVisibleInContext(New); 10852 if (Name) // can be null along some error paths 10853 if (Scope *EnclosingScope = getScopeForDeclContext(S, DC)) 10854 PushOnScopeChains(New, EnclosingScope, /* AddToContext = */ false); 10855 } else if (Name) { 10856 S = getNonFieldDeclScope(S); 10857 PushOnScopeChains(New, S, !IsForwardReference); 10858 if (IsForwardReference) 10859 SearchDC->makeDeclVisibleInContext(New); 10860 10861 } else { 10862 CurContext->addDecl(New); 10863 } 10864 10865 // If this is the C FILE type, notify the AST context. 10866 if (IdentifierInfo *II = New->getIdentifier()) 10867 if (!New->isInvalidDecl() && 10868 New->getDeclContext()->getRedeclContext()->isTranslationUnit() && 10869 II->isStr("FILE")) 10870 Context.setFILEDecl(New); 10871 10872 // If we were in function prototype scope (and not in C++ mode), add this 10873 // tag to the list of decls to inject into the function definition scope. 10874 if (S->isFunctionPrototypeScope() && !getLangOpts().CPlusPlus && 10875 InFunctionDeclarator && Name) 10876 DeclsInPrototypeScope.push_back(New); 10877 10878 if (PrevDecl) 10879 mergeDeclAttributes(New, PrevDecl); 10880 10881 // If there's a #pragma GCC visibility in scope, set the visibility of this 10882 // record. 10883 AddPushedVisibilityAttribute(New); 10884 10885 OwnedDecl = true; 10886 // In C++, don't return an invalid declaration. We can't recover well from 10887 // the cases where we make the type anonymous. 10888 return (Invalid && getLangOpts().CPlusPlus) ? 0 : New; 10889} 10890 10891void Sema::ActOnTagStartDefinition(Scope *S, Decl *TagD) { 10892 AdjustDeclIfTemplate(TagD); 10893 TagDecl *Tag = cast<TagDecl>(TagD); 10894 10895 // Enter the tag context. 10896 PushDeclContext(S, Tag); 10897 10898 ActOnDocumentableDecl(TagD); 10899 10900 // If there's a #pragma GCC visibility in scope, set the visibility of this 10901 // record. 10902 AddPushedVisibilityAttribute(Tag); 10903} 10904 10905Decl *Sema::ActOnObjCContainerStartDefinition(Decl *IDecl) { 10906 assert(isa<ObjCContainerDecl>(IDecl) && 10907 "ActOnObjCContainerStartDefinition - Not ObjCContainerDecl"); 10908 DeclContext *OCD = cast<DeclContext>(IDecl); 10909 assert(getContainingDC(OCD) == CurContext && 10910 "The next DeclContext should be lexically contained in the current one."); 10911 CurContext = OCD; 10912 return IDecl; 10913} 10914 10915void Sema::ActOnStartCXXMemberDeclarations(Scope *S, Decl *TagD, 10916 SourceLocation FinalLoc, 10917 SourceLocation LBraceLoc) { 10918 AdjustDeclIfTemplate(TagD); 10919 CXXRecordDecl *Record = cast<CXXRecordDecl>(TagD); 10920 10921 FieldCollector->StartClass(); 10922 10923 if (!Record->getIdentifier()) 10924 return; 10925 10926 if (FinalLoc.isValid()) 10927 Record->addAttr(new (Context) FinalAttr(FinalLoc, Context)); 10928 10929 // C++ [class]p2: 10930 // [...] The class-name is also inserted into the scope of the 10931 // class itself; this is known as the injected-class-name. For 10932 // purposes of access checking, the injected-class-name is treated 10933 // as if it were a public member name. 10934 CXXRecordDecl *InjectedClassName 10935 = CXXRecordDecl::Create(Context, Record->getTagKind(), CurContext, 10936 Record->getLocStart(), Record->getLocation(), 10937 Record->getIdentifier(), 10938 /*PrevDecl=*/0, 10939 /*DelayTypeCreation=*/true); 10940 Context.getTypeDeclType(InjectedClassName, Record); 10941 InjectedClassName->setImplicit(); 10942 InjectedClassName->setAccess(AS_public); 10943 if (ClassTemplateDecl *Template = Record->getDescribedClassTemplate()) 10944 InjectedClassName->setDescribedClassTemplate(Template); 10945 PushOnScopeChains(InjectedClassName, S); 10946 assert(InjectedClassName->isInjectedClassName() && 10947 "Broken injected-class-name"); 10948} 10949 10950void Sema::ActOnTagFinishDefinition(Scope *S, Decl *TagD, 10951 SourceLocation RBraceLoc) { 10952 AdjustDeclIfTemplate(TagD); 10953 TagDecl *Tag = cast<TagDecl>(TagD); 10954 Tag->setRBraceLoc(RBraceLoc); 10955 10956 // Make sure we "complete" the definition even it is invalid. 10957 if (Tag->isBeingDefined()) { 10958 assert(Tag->isInvalidDecl() && "We should already have completed it"); 10959 if (RecordDecl *RD = dyn_cast<RecordDecl>(Tag)) 10960 RD->completeDefinition(); 10961 } 10962 10963 if (isa<CXXRecordDecl>(Tag)) 10964 FieldCollector->FinishClass(); 10965 10966 // Exit this scope of this tag's definition. 10967 PopDeclContext(); 10968 10969 if (getCurLexicalContext()->isObjCContainer() && 10970 Tag->getDeclContext()->isFileContext()) 10971 Tag->setTopLevelDeclInObjCContainer(); 10972 10973 // Notify the consumer that we've defined a tag. 10974 if (!Tag->isInvalidDecl()) 10975 Consumer.HandleTagDeclDefinition(Tag); 10976} 10977 10978void Sema::ActOnObjCContainerFinishDefinition() { 10979 // Exit this scope of this interface definition. 10980 PopDeclContext(); 10981} 10982 10983void Sema::ActOnObjCTemporaryExitContainerContext(DeclContext *DC) { 10984 assert(DC == CurContext && "Mismatch of container contexts"); 10985 OriginalLexicalContext = DC; 10986 ActOnObjCContainerFinishDefinition(); 10987} 10988 10989void Sema::ActOnObjCReenterContainerContext(DeclContext *DC) { 10990 ActOnObjCContainerStartDefinition(cast<Decl>(DC)); 10991 OriginalLexicalContext = 0; 10992} 10993 10994void Sema::ActOnTagDefinitionError(Scope *S, Decl *TagD) { 10995 AdjustDeclIfTemplate(TagD); 10996 TagDecl *Tag = cast<TagDecl>(TagD); 10997 Tag->setInvalidDecl(); 10998 10999 // Make sure we "complete" the definition even it is invalid. 11000 if (Tag->isBeingDefined()) { 11001 if (RecordDecl *RD = dyn_cast<RecordDecl>(Tag)) 11002 RD->completeDefinition(); 11003 } 11004 11005 // We're undoing ActOnTagStartDefinition here, not 11006 // ActOnStartCXXMemberDeclarations, so we don't have to mess with 11007 // the FieldCollector. 11008 11009 PopDeclContext(); 11010} 11011 11012// Note that FieldName may be null for anonymous bitfields. 11013ExprResult Sema::VerifyBitField(SourceLocation FieldLoc, 11014 IdentifierInfo *FieldName, 11015 QualType FieldTy, bool IsMsStruct, 11016 Expr *BitWidth, bool *ZeroWidth) { 11017 // Default to true; that shouldn't confuse checks for emptiness 11018 if (ZeroWidth) 11019 *ZeroWidth = true; 11020 11021 // C99 6.7.2.1p4 - verify the field type. 11022 // C++ 9.6p3: A bit-field shall have integral or enumeration type. 11023 if (!FieldTy->isDependentType() && !FieldTy->isIntegralOrEnumerationType()) { 11024 // Handle incomplete types with specific error. 11025 if (RequireCompleteType(FieldLoc, FieldTy, diag::err_field_incomplete)) 11026 return ExprError(); 11027 if (FieldName) 11028 return Diag(FieldLoc, diag::err_not_integral_type_bitfield) 11029 << FieldName << FieldTy << BitWidth->getSourceRange(); 11030 return Diag(FieldLoc, diag::err_not_integral_type_anon_bitfield) 11031 << FieldTy << BitWidth->getSourceRange(); 11032 } else if (DiagnoseUnexpandedParameterPack(const_cast<Expr *>(BitWidth), 11033 UPPC_BitFieldWidth)) 11034 return ExprError(); 11035 11036 // If the bit-width is type- or value-dependent, don't try to check 11037 // it now. 11038 if (BitWidth->isValueDependent() || BitWidth->isTypeDependent()) 11039 return Owned(BitWidth); 11040 11041 llvm::APSInt Value; 11042 ExprResult ICE = VerifyIntegerConstantExpression(BitWidth, &Value); 11043 if (ICE.isInvalid()) 11044 return ICE; 11045 BitWidth = ICE.take(); 11046 11047 if (Value != 0 && ZeroWidth) 11048 *ZeroWidth = false; 11049 11050 // Zero-width bitfield is ok for anonymous field. 11051 if (Value == 0 && FieldName) 11052 return Diag(FieldLoc, diag::err_bitfield_has_zero_width) << FieldName; 11053 11054 if (Value.isSigned() && Value.isNegative()) { 11055 if (FieldName) 11056 return Diag(FieldLoc, diag::err_bitfield_has_negative_width) 11057 << FieldName << Value.toString(10); 11058 return Diag(FieldLoc, diag::err_anon_bitfield_has_negative_width) 11059 << Value.toString(10); 11060 } 11061 11062 if (!FieldTy->isDependentType()) { 11063 uint64_t TypeSize = Context.getTypeSize(FieldTy); 11064 if (Value.getZExtValue() > TypeSize) { 11065 if (!getLangOpts().CPlusPlus || IsMsStruct) { 11066 if (FieldName) 11067 return Diag(FieldLoc, diag::err_bitfield_width_exceeds_type_size) 11068 << FieldName << (unsigned)Value.getZExtValue() 11069 << (unsigned)TypeSize; 11070 11071 return Diag(FieldLoc, diag::err_anon_bitfield_width_exceeds_type_size) 11072 << (unsigned)Value.getZExtValue() << (unsigned)TypeSize; 11073 } 11074 11075 if (FieldName) 11076 Diag(FieldLoc, diag::warn_bitfield_width_exceeds_type_size) 11077 << FieldName << (unsigned)Value.getZExtValue() 11078 << (unsigned)TypeSize; 11079 else 11080 Diag(FieldLoc, diag::warn_anon_bitfield_width_exceeds_type_size) 11081 << (unsigned)Value.getZExtValue() << (unsigned)TypeSize; 11082 } 11083 } 11084 11085 return Owned(BitWidth); 11086} 11087 11088/// ActOnField - Each field of a C struct/union is passed into this in order 11089/// to create a FieldDecl object for it. 11090Decl *Sema::ActOnField(Scope *S, Decl *TagD, SourceLocation DeclStart, 11091 Declarator &D, Expr *BitfieldWidth) { 11092 FieldDecl *Res = HandleField(S, cast_or_null<RecordDecl>(TagD), 11093 DeclStart, D, static_cast<Expr*>(BitfieldWidth), 11094 /*InitStyle=*/ICIS_NoInit, AS_public); 11095 return Res; 11096} 11097 11098/// HandleField - Analyze a field of a C struct or a C++ data member. 11099/// 11100FieldDecl *Sema::HandleField(Scope *S, RecordDecl *Record, 11101 SourceLocation DeclStart, 11102 Declarator &D, Expr *BitWidth, 11103 InClassInitStyle InitStyle, 11104 AccessSpecifier AS) { 11105 IdentifierInfo *II = D.getIdentifier(); 11106 SourceLocation Loc = DeclStart; 11107 if (II) Loc = D.getIdentifierLoc(); 11108 11109 TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S); 11110 QualType T = TInfo->getType(); 11111 if (getLangOpts().CPlusPlus) { 11112 CheckExtraCXXDefaultArguments(D); 11113 11114 if (DiagnoseUnexpandedParameterPack(D.getIdentifierLoc(), TInfo, 11115 UPPC_DataMemberType)) { 11116 D.setInvalidType(); 11117 T = Context.IntTy; 11118 TInfo = Context.getTrivialTypeSourceInfo(T, Loc); 11119 } 11120 } 11121 11122 // TR 18037 does not allow fields to be declared with address spaces. 11123 if (T.getQualifiers().hasAddressSpace()) { 11124 Diag(Loc, diag::err_field_with_address_space); 11125 D.setInvalidType(); 11126 } 11127 11128 // OpenCL 1.2 spec, s6.9 r: 11129 // The event type cannot be used to declare a structure or union field. 11130 if (LangOpts.OpenCL && T->isEventT()) { 11131 Diag(Loc, diag::err_event_t_struct_field); 11132 D.setInvalidType(); 11133 } 11134 11135 DiagnoseFunctionSpecifiers(D.getDeclSpec()); 11136 11137 if (DeclSpec::TSCS TSCS = D.getDeclSpec().getThreadStorageClassSpec()) 11138 Diag(D.getDeclSpec().getThreadStorageClassSpecLoc(), 11139 diag::err_invalid_thread) 11140 << DeclSpec::getSpecifierName(TSCS); 11141 11142 // Check to see if this name was declared as a member previously 11143 NamedDecl *PrevDecl = 0; 11144 LookupResult Previous(*this, II, Loc, LookupMemberName, ForRedeclaration); 11145 LookupName(Previous, S); 11146 switch (Previous.getResultKind()) { 11147 case LookupResult::Found: 11148 case LookupResult::FoundUnresolvedValue: 11149 PrevDecl = Previous.getAsSingle<NamedDecl>(); 11150 break; 11151 11152 case LookupResult::FoundOverloaded: 11153 PrevDecl = Previous.getRepresentativeDecl(); 11154 break; 11155 11156 case LookupResult::NotFound: 11157 case LookupResult::NotFoundInCurrentInstantiation: 11158 case LookupResult::Ambiguous: 11159 break; 11160 } 11161 Previous.suppressDiagnostics(); 11162 11163 if (PrevDecl && PrevDecl->isTemplateParameter()) { 11164 // Maybe we will complain about the shadowed template parameter. 11165 DiagnoseTemplateParameterShadow(D.getIdentifierLoc(), PrevDecl); 11166 // Just pretend that we didn't see the previous declaration. 11167 PrevDecl = 0; 11168 } 11169 11170 if (PrevDecl && !isDeclInScope(PrevDecl, Record, S)) 11171 PrevDecl = 0; 11172 11173 bool Mutable 11174 = (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_mutable); 11175 SourceLocation TSSL = D.getLocStart(); 11176 FieldDecl *NewFD 11177 = CheckFieldDecl(II, T, TInfo, Record, Loc, Mutable, BitWidth, InitStyle, 11178 TSSL, AS, PrevDecl, &D); 11179 11180 if (NewFD->isInvalidDecl()) 11181 Record->setInvalidDecl(); 11182 11183 if (D.getDeclSpec().isModulePrivateSpecified()) 11184 NewFD->setModulePrivate(); 11185 11186 if (NewFD->isInvalidDecl() && PrevDecl) { 11187 // Don't introduce NewFD into scope; there's already something 11188 // with the same name in the same scope. 11189 } else if (II) { 11190 PushOnScopeChains(NewFD, S); 11191 } else 11192 Record->addDecl(NewFD); 11193 11194 return NewFD; 11195} 11196 11197/// \brief Build a new FieldDecl and check its well-formedness. 11198/// 11199/// This routine builds a new FieldDecl given the fields name, type, 11200/// record, etc. \p PrevDecl should refer to any previous declaration 11201/// with the same name and in the same scope as the field to be 11202/// created. 11203/// 11204/// \returns a new FieldDecl. 11205/// 11206/// \todo The Declarator argument is a hack. It will be removed once 11207FieldDecl *Sema::CheckFieldDecl(DeclarationName Name, QualType T, 11208 TypeSourceInfo *TInfo, 11209 RecordDecl *Record, SourceLocation Loc, 11210 bool Mutable, Expr *BitWidth, 11211 InClassInitStyle InitStyle, 11212 SourceLocation TSSL, 11213 AccessSpecifier AS, NamedDecl *PrevDecl, 11214 Declarator *D) { 11215 IdentifierInfo *II = Name.getAsIdentifierInfo(); 11216 bool InvalidDecl = false; 11217 if (D) InvalidDecl = D->isInvalidType(); 11218 11219 // If we receive a broken type, recover by assuming 'int' and 11220 // marking this declaration as invalid. 11221 if (T.isNull()) { 11222 InvalidDecl = true; 11223 T = Context.IntTy; 11224 } 11225 11226 QualType EltTy = Context.getBaseElementType(T); 11227 if (!EltTy->isDependentType()) { 11228 if (RequireCompleteType(Loc, EltTy, diag::err_field_incomplete)) { 11229 // Fields of incomplete type force their record to be invalid. 11230 Record->setInvalidDecl(); 11231 InvalidDecl = true; 11232 } else { 11233 NamedDecl *Def; 11234 EltTy->isIncompleteType(&Def); 11235 if (Def && Def->isInvalidDecl()) { 11236 Record->setInvalidDecl(); 11237 InvalidDecl = true; 11238 } 11239 } 11240 } 11241 11242 // OpenCL v1.2 s6.9.c: bitfields are not supported. 11243 if (BitWidth && getLangOpts().OpenCL) { 11244 Diag(Loc, diag::err_opencl_bitfields); 11245 InvalidDecl = true; 11246 } 11247 11248 // C99 6.7.2.1p8: A member of a structure or union may have any type other 11249 // than a variably modified type. 11250 if (!InvalidDecl && T->isVariablyModifiedType()) { 11251 bool SizeIsNegative; 11252 llvm::APSInt Oversized; 11253 11254 TypeSourceInfo *FixedTInfo = 11255 TryToFixInvalidVariablyModifiedTypeSourceInfo(TInfo, Context, 11256 SizeIsNegative, 11257 Oversized); 11258 if (FixedTInfo) { 11259 Diag(Loc, diag::warn_illegal_constant_array_size); 11260 TInfo = FixedTInfo; 11261 T = FixedTInfo->getType(); 11262 } else { 11263 if (SizeIsNegative) 11264 Diag(Loc, diag::err_typecheck_negative_array_size); 11265 else if (Oversized.getBoolValue()) 11266 Diag(Loc, diag::err_array_too_large) 11267 << Oversized.toString(10); 11268 else 11269 Diag(Loc, diag::err_typecheck_field_variable_size); 11270 InvalidDecl = true; 11271 } 11272 } 11273 11274 // Fields can not have abstract class types 11275 if (!InvalidDecl && RequireNonAbstractType(Loc, T, 11276 diag::err_abstract_type_in_decl, 11277 AbstractFieldType)) 11278 InvalidDecl = true; 11279 11280 bool ZeroWidth = false; 11281 // If this is declared as a bit-field, check the bit-field. 11282 if (!InvalidDecl && BitWidth) { 11283 BitWidth = VerifyBitField(Loc, II, T, Record->isMsStruct(Context), BitWidth, 11284 &ZeroWidth).take(); 11285 if (!BitWidth) { 11286 InvalidDecl = true; 11287 BitWidth = 0; 11288 ZeroWidth = false; 11289 } 11290 } 11291 11292 // Check that 'mutable' is consistent with the type of the declaration. 11293 if (!InvalidDecl && Mutable) { 11294 unsigned DiagID = 0; 11295 if (T->isReferenceType()) 11296 DiagID = diag::err_mutable_reference; 11297 else if (T.isConstQualified()) 11298 DiagID = diag::err_mutable_const; 11299 11300 if (DiagID) { 11301 SourceLocation ErrLoc = Loc; 11302 if (D && D->getDeclSpec().getStorageClassSpecLoc().isValid()) 11303 ErrLoc = D->getDeclSpec().getStorageClassSpecLoc(); 11304 Diag(ErrLoc, DiagID); 11305 Mutable = false; 11306 InvalidDecl = true; 11307 } 11308 } 11309 11310 FieldDecl *NewFD = FieldDecl::Create(Context, Record, TSSL, Loc, II, T, TInfo, 11311 BitWidth, Mutable, InitStyle); 11312 if (InvalidDecl) 11313 NewFD->setInvalidDecl(); 11314 11315 if (PrevDecl && !isa<TagDecl>(PrevDecl)) { 11316 Diag(Loc, diag::err_duplicate_member) << II; 11317 Diag(PrevDecl->getLocation(), diag::note_previous_declaration); 11318 NewFD->setInvalidDecl(); 11319 } 11320 11321 if (!InvalidDecl && getLangOpts().CPlusPlus) { 11322 if (Record->isUnion()) { 11323 if (const RecordType *RT = EltTy->getAs<RecordType>()) { 11324 CXXRecordDecl* RDecl = cast<CXXRecordDecl>(RT->getDecl()); 11325 if (RDecl->getDefinition()) { 11326 // C++ [class.union]p1: An object of a class with a non-trivial 11327 // constructor, a non-trivial copy constructor, a non-trivial 11328 // destructor, or a non-trivial copy assignment operator 11329 // cannot be a member of a union, nor can an array of such 11330 // objects. 11331 if (CheckNontrivialField(NewFD)) 11332 NewFD->setInvalidDecl(); 11333 } 11334 } 11335 11336 // C++ [class.union]p1: If a union contains a member of reference type, 11337 // the program is ill-formed, except when compiling with MSVC extensions 11338 // enabled. 11339 if (EltTy->isReferenceType()) { 11340 Diag(NewFD->getLocation(), getLangOpts().MicrosoftExt ? 11341 diag::ext_union_member_of_reference_type : 11342 diag::err_union_member_of_reference_type) 11343 << NewFD->getDeclName() << EltTy; 11344 if (!getLangOpts().MicrosoftExt) 11345 NewFD->setInvalidDecl(); 11346 } 11347 } 11348 } 11349 11350 // FIXME: We need to pass in the attributes given an AST 11351 // representation, not a parser representation. 11352 if (D) { 11353 // FIXME: The current scope is almost... but not entirely... correct here. 11354 ProcessDeclAttributes(getCurScope(), NewFD, *D); 11355 11356 if (NewFD->hasAttrs()) 11357 CheckAlignasUnderalignment(NewFD); 11358 } 11359 11360 // In auto-retain/release, infer strong retension for fields of 11361 // retainable type. 11362 if (getLangOpts().ObjCAutoRefCount && inferObjCARCLifetime(NewFD)) 11363 NewFD->setInvalidDecl(); 11364 11365 if (T.isObjCGCWeak()) 11366 Diag(Loc, diag::warn_attribute_weak_on_field); 11367 11368 NewFD->setAccess(AS); 11369 return NewFD; 11370} 11371 11372bool Sema::CheckNontrivialField(FieldDecl *FD) { 11373 assert(FD); 11374 assert(getLangOpts().CPlusPlus && "valid check only for C++"); 11375 11376 if (FD->isInvalidDecl() || FD->getType()->isDependentType()) 11377 return false; 11378 11379 QualType EltTy = Context.getBaseElementType(FD->getType()); 11380 if (const RecordType *RT = EltTy->getAs<RecordType>()) { 11381 CXXRecordDecl *RDecl = cast<CXXRecordDecl>(RT->getDecl()); 11382 if (RDecl->getDefinition()) { 11383 // We check for copy constructors before constructors 11384 // because otherwise we'll never get complaints about 11385 // copy constructors. 11386 11387 CXXSpecialMember member = CXXInvalid; 11388 // We're required to check for any non-trivial constructors. Since the 11389 // implicit default constructor is suppressed if there are any 11390 // user-declared constructors, we just need to check that there is a 11391 // trivial default constructor and a trivial copy constructor. (We don't 11392 // worry about move constructors here, since this is a C++98 check.) 11393 if (RDecl->hasNonTrivialCopyConstructor()) 11394 member = CXXCopyConstructor; 11395 else if (!RDecl->hasTrivialDefaultConstructor()) 11396 member = CXXDefaultConstructor; 11397 else if (RDecl->hasNonTrivialCopyAssignment()) 11398 member = CXXCopyAssignment; 11399 else if (RDecl->hasNonTrivialDestructor()) 11400 member = CXXDestructor; 11401 11402 if (member != CXXInvalid) { 11403 if (!getLangOpts().CPlusPlus11 && 11404 getLangOpts().ObjCAutoRefCount && RDecl->hasObjectMember()) { 11405 // Objective-C++ ARC: it is an error to have a non-trivial field of 11406 // a union. However, system headers in Objective-C programs 11407 // occasionally have Objective-C lifetime objects within unions, 11408 // and rather than cause the program to fail, we make those 11409 // members unavailable. 11410 SourceLocation Loc = FD->getLocation(); 11411 if (getSourceManager().isInSystemHeader(Loc)) { 11412 if (!FD->hasAttr<UnavailableAttr>()) 11413 FD->addAttr(new (Context) UnavailableAttr(Loc, Context, 11414 "this system field has retaining ownership")); 11415 return false; 11416 } 11417 } 11418 11419 Diag(FD->getLocation(), getLangOpts().CPlusPlus11 ? 11420 diag::warn_cxx98_compat_nontrivial_union_or_anon_struct_member : 11421 diag::err_illegal_union_or_anon_struct_member) 11422 << (int)FD->getParent()->isUnion() << FD->getDeclName() << member; 11423 DiagnoseNontrivial(RDecl, member); 11424 return !getLangOpts().CPlusPlus11; 11425 } 11426 } 11427 } 11428 11429 return false; 11430} 11431 11432/// TranslateIvarVisibility - Translate visibility from a token ID to an 11433/// AST enum value. 11434static ObjCIvarDecl::AccessControl 11435TranslateIvarVisibility(tok::ObjCKeywordKind ivarVisibility) { 11436 switch (ivarVisibility) { 11437 default: llvm_unreachable("Unknown visitibility kind"); 11438 case tok::objc_private: return ObjCIvarDecl::Private; 11439 case tok::objc_public: return ObjCIvarDecl::Public; 11440 case tok::objc_protected: return ObjCIvarDecl::Protected; 11441 case tok::objc_package: return ObjCIvarDecl::Package; 11442 } 11443} 11444 11445/// ActOnIvar - Each ivar field of an objective-c class is passed into this 11446/// in order to create an IvarDecl object for it. 11447Decl *Sema::ActOnIvar(Scope *S, 11448 SourceLocation DeclStart, 11449 Declarator &D, Expr *BitfieldWidth, 11450 tok::ObjCKeywordKind Visibility) { 11451 11452 IdentifierInfo *II = D.getIdentifier(); 11453 Expr *BitWidth = (Expr*)BitfieldWidth; 11454 SourceLocation Loc = DeclStart; 11455 if (II) Loc = D.getIdentifierLoc(); 11456 11457 // FIXME: Unnamed fields can be handled in various different ways, for 11458 // example, unnamed unions inject all members into the struct namespace! 11459 11460 TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S); 11461 QualType T = TInfo->getType(); 11462 11463 if (BitWidth) { 11464 // 6.7.2.1p3, 6.7.2.1p4 11465 BitWidth = 11466 VerifyBitField(Loc, II, T, /*IsMsStruct=*/false, BitWidth).take(); 11467 if (!BitWidth) 11468 D.setInvalidType(); 11469 } else { 11470 // Not a bitfield. 11471 11472 // validate II. 11473 11474 } 11475 if (T->isReferenceType()) { 11476 Diag(Loc, diag::err_ivar_reference_type); 11477 D.setInvalidType(); 11478 } 11479 // C99 6.7.2.1p8: A member of a structure or union may have any type other 11480 // than a variably modified type. 11481 else if (T->isVariablyModifiedType()) { 11482 Diag(Loc, diag::err_typecheck_ivar_variable_size); 11483 D.setInvalidType(); 11484 } 11485 11486 // Get the visibility (access control) for this ivar. 11487 ObjCIvarDecl::AccessControl ac = 11488 Visibility != tok::objc_not_keyword ? TranslateIvarVisibility(Visibility) 11489 : ObjCIvarDecl::None; 11490 // Must set ivar's DeclContext to its enclosing interface. 11491 ObjCContainerDecl *EnclosingDecl = cast<ObjCContainerDecl>(CurContext); 11492 if (!EnclosingDecl || EnclosingDecl->isInvalidDecl()) 11493 return 0; 11494 ObjCContainerDecl *EnclosingContext; 11495 if (ObjCImplementationDecl *IMPDecl = 11496 dyn_cast<ObjCImplementationDecl>(EnclosingDecl)) { 11497 if (LangOpts.ObjCRuntime.isFragile()) { 11498 // Case of ivar declared in an implementation. Context is that of its class. 11499 EnclosingContext = IMPDecl->getClassInterface(); 11500 assert(EnclosingContext && "Implementation has no class interface!"); 11501 } 11502 else 11503 EnclosingContext = EnclosingDecl; 11504 } else { 11505 if (ObjCCategoryDecl *CDecl = 11506 dyn_cast<ObjCCategoryDecl>(EnclosingDecl)) { 11507 if (LangOpts.ObjCRuntime.isFragile() || !CDecl->IsClassExtension()) { 11508 Diag(Loc, diag::err_misplaced_ivar) << CDecl->IsClassExtension(); 11509 return 0; 11510 } 11511 } 11512 EnclosingContext = EnclosingDecl; 11513 } 11514 11515 // Construct the decl. 11516 ObjCIvarDecl *NewID = ObjCIvarDecl::Create(Context, EnclosingContext, 11517 DeclStart, Loc, II, T, 11518 TInfo, ac, (Expr *)BitfieldWidth); 11519 11520 if (II) { 11521 NamedDecl *PrevDecl = LookupSingleName(S, II, Loc, LookupMemberName, 11522 ForRedeclaration); 11523 if (PrevDecl && isDeclInScope(PrevDecl, EnclosingContext, S) 11524 && !isa<TagDecl>(PrevDecl)) { 11525 Diag(Loc, diag::err_duplicate_member) << II; 11526 Diag(PrevDecl->getLocation(), diag::note_previous_declaration); 11527 NewID->setInvalidDecl(); 11528 } 11529 } 11530 11531 // Process attributes attached to the ivar. 11532 ProcessDeclAttributes(S, NewID, D); 11533 11534 if (D.isInvalidType()) 11535 NewID->setInvalidDecl(); 11536 11537 // In ARC, infer 'retaining' for ivars of retainable type. 11538 if (getLangOpts().ObjCAutoRefCount && inferObjCARCLifetime(NewID)) 11539 NewID->setInvalidDecl(); 11540 11541 if (D.getDeclSpec().isModulePrivateSpecified()) 11542 NewID->setModulePrivate(); 11543 11544 if (II) { 11545 // FIXME: When interfaces are DeclContexts, we'll need to add 11546 // these to the interface. 11547 S->AddDecl(NewID); 11548 IdResolver.AddDecl(NewID); 11549 } 11550 11551 if (LangOpts.ObjCRuntime.isNonFragile() && 11552 !NewID->isInvalidDecl() && isa<ObjCInterfaceDecl>(EnclosingDecl)) 11553 Diag(Loc, diag::warn_ivars_in_interface); 11554 11555 return NewID; 11556} 11557 11558/// ActOnLastBitfield - This routine handles synthesized bitfields rules for 11559/// class and class extensions. For every class \@interface and class 11560/// extension \@interface, if the last ivar is a bitfield of any type, 11561/// then add an implicit `char :0` ivar to the end of that interface. 11562void Sema::ActOnLastBitfield(SourceLocation DeclLoc, 11563 SmallVectorImpl<Decl *> &AllIvarDecls) { 11564 if (LangOpts.ObjCRuntime.isFragile() || AllIvarDecls.empty()) 11565 return; 11566 11567 Decl *ivarDecl = AllIvarDecls[AllIvarDecls.size()-1]; 11568 ObjCIvarDecl *Ivar = cast<ObjCIvarDecl>(ivarDecl); 11569 11570 if (!Ivar->isBitField() || Ivar->getBitWidthValue(Context) == 0) 11571 return; 11572 ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(CurContext); 11573 if (!ID) { 11574 if (ObjCCategoryDecl *CD = dyn_cast<ObjCCategoryDecl>(CurContext)) { 11575 if (!CD->IsClassExtension()) 11576 return; 11577 } 11578 // No need to add this to end of @implementation. 11579 else 11580 return; 11581 } 11582 // All conditions are met. Add a new bitfield to the tail end of ivars. 11583 llvm::APInt Zero(Context.getTypeSize(Context.IntTy), 0); 11584 Expr * BW = IntegerLiteral::Create(Context, Zero, Context.IntTy, DeclLoc); 11585 11586 Ivar = ObjCIvarDecl::Create(Context, cast<ObjCContainerDecl>(CurContext), 11587 DeclLoc, DeclLoc, 0, 11588 Context.CharTy, 11589 Context.getTrivialTypeSourceInfo(Context.CharTy, 11590 DeclLoc), 11591 ObjCIvarDecl::Private, BW, 11592 true); 11593 AllIvarDecls.push_back(Ivar); 11594} 11595 11596void Sema::ActOnFields(Scope *S, SourceLocation RecLoc, Decl *EnclosingDecl, 11597 ArrayRef<Decl *> Fields, SourceLocation LBrac, 11598 SourceLocation RBrac, AttributeList *Attr) { 11599 assert(EnclosingDecl && "missing record or interface decl"); 11600 11601 // If this is an Objective-C @implementation or category and we have 11602 // new fields here we should reset the layout of the interface since 11603 // it will now change. 11604 if (!Fields.empty() && isa<ObjCContainerDecl>(EnclosingDecl)) { 11605 ObjCContainerDecl *DC = cast<ObjCContainerDecl>(EnclosingDecl); 11606 switch (DC->getKind()) { 11607 default: break; 11608 case Decl::ObjCCategory: 11609 Context.ResetObjCLayout(cast<ObjCCategoryDecl>(DC)->getClassInterface()); 11610 break; 11611 case Decl::ObjCImplementation: 11612 Context. 11613 ResetObjCLayout(cast<ObjCImplementationDecl>(DC)->getClassInterface()); 11614 break; 11615 } 11616 } 11617 11618 RecordDecl *Record = dyn_cast<RecordDecl>(EnclosingDecl); 11619 11620 // Start counting up the number of named members; make sure to include 11621 // members of anonymous structs and unions in the total. 11622 unsigned NumNamedMembers = 0; 11623 if (Record) { 11624 for (RecordDecl::decl_iterator i = Record->decls_begin(), 11625 e = Record->decls_end(); i != e; i++) { 11626 if (IndirectFieldDecl *IFD = dyn_cast<IndirectFieldDecl>(*i)) 11627 if (IFD->getDeclName()) 11628 ++NumNamedMembers; 11629 } 11630 } 11631 11632 // Verify that all the fields are okay. 11633 SmallVector<FieldDecl*, 32> RecFields; 11634 11635 bool ARCErrReported = false; 11636 for (ArrayRef<Decl *>::iterator i = Fields.begin(), end = Fields.end(); 11637 i != end; ++i) { 11638 FieldDecl *FD = cast<FieldDecl>(*i); 11639 11640 // Get the type for the field. 11641 const Type *FDTy = FD->getType().getTypePtr(); 11642 11643 if (!FD->isAnonymousStructOrUnion()) { 11644 // Remember all fields written by the user. 11645 RecFields.push_back(FD); 11646 } 11647 11648 // If the field is already invalid for some reason, don't emit more 11649 // diagnostics about it. 11650 if (FD->isInvalidDecl()) { 11651 EnclosingDecl->setInvalidDecl(); 11652 continue; 11653 } 11654 11655 // C99 6.7.2.1p2: 11656 // A structure or union shall not contain a member with 11657 // incomplete or function type (hence, a structure shall not 11658 // contain an instance of itself, but may contain a pointer to 11659 // an instance of itself), except that the last member of a 11660 // structure with more than one named member may have incomplete 11661 // array type; such a structure (and any union containing, 11662 // possibly recursively, a member that is such a structure) 11663 // shall not be a member of a structure or an element of an 11664 // array. 11665 if (FDTy->isFunctionType()) { 11666 // Field declared as a function. 11667 Diag(FD->getLocation(), diag::err_field_declared_as_function) 11668 << FD->getDeclName(); 11669 FD->setInvalidDecl(); 11670 EnclosingDecl->setInvalidDecl(); 11671 continue; 11672 } else if (FDTy->isIncompleteArrayType() && Record && 11673 ((i + 1 == Fields.end() && !Record->isUnion()) || 11674 ((getLangOpts().MicrosoftExt || 11675 getLangOpts().CPlusPlus) && 11676 (i + 1 == Fields.end() || Record->isUnion())))) { 11677 // Flexible array member. 11678 // Microsoft and g++ is more permissive regarding flexible array. 11679 // It will accept flexible array in union and also 11680 // as the sole element of a struct/class. 11681 if (getLangOpts().MicrosoftExt) { 11682 if (Record->isUnion()) 11683 Diag(FD->getLocation(), diag::ext_flexible_array_union_ms) 11684 << FD->getDeclName(); 11685 else if (Fields.size() == 1) 11686 Diag(FD->getLocation(), diag::ext_flexible_array_empty_aggregate_ms) 11687 << FD->getDeclName() << Record->getTagKind(); 11688 } else if (getLangOpts().CPlusPlus) { 11689 if (Record->isUnion()) 11690 Diag(FD->getLocation(), diag::ext_flexible_array_union_gnu) 11691 << FD->getDeclName(); 11692 else if (Fields.size() == 1) 11693 Diag(FD->getLocation(), diag::ext_flexible_array_empty_aggregate_gnu) 11694 << FD->getDeclName() << Record->getTagKind(); 11695 } else if (!getLangOpts().C99) { 11696 if (Record->isUnion()) 11697 Diag(FD->getLocation(), diag::ext_flexible_array_union_gnu) 11698 << FD->getDeclName(); 11699 else 11700 Diag(FD->getLocation(), diag::ext_c99_flexible_array_member) 11701 << FD->getDeclName() << Record->getTagKind(); 11702 } else if (NumNamedMembers < 1) { 11703 Diag(FD->getLocation(), diag::err_flexible_array_empty_struct) 11704 << FD->getDeclName(); 11705 FD->setInvalidDecl(); 11706 EnclosingDecl->setInvalidDecl(); 11707 continue; 11708 } 11709 if (!FD->getType()->isDependentType() && 11710 !Context.getBaseElementType(FD->getType()).isPODType(Context)) { 11711 Diag(FD->getLocation(), diag::err_flexible_array_has_nonpod_type) 11712 << FD->getDeclName() << FD->getType(); 11713 FD->setInvalidDecl(); 11714 EnclosingDecl->setInvalidDecl(); 11715 continue; 11716 } 11717 // Okay, we have a legal flexible array member at the end of the struct. 11718 if (Record) 11719 Record->setHasFlexibleArrayMember(true); 11720 } else if (!FDTy->isDependentType() && 11721 RequireCompleteType(FD->getLocation(), FD->getType(), 11722 diag::err_field_incomplete)) { 11723 // Incomplete type 11724 FD->setInvalidDecl(); 11725 EnclosingDecl->setInvalidDecl(); 11726 continue; 11727 } else if (const RecordType *FDTTy = FDTy->getAs<RecordType>()) { 11728 if (FDTTy->getDecl()->hasFlexibleArrayMember()) { 11729 // If this is a member of a union, then entire union becomes "flexible". 11730 if (Record && Record->isUnion()) { 11731 Record->setHasFlexibleArrayMember(true); 11732 } else { 11733 // If this is a struct/class and this is not the last element, reject 11734 // it. Note that GCC supports variable sized arrays in the middle of 11735 // structures. 11736 if (i + 1 != Fields.end()) 11737 Diag(FD->getLocation(), diag::ext_variable_sized_type_in_struct) 11738 << FD->getDeclName() << FD->getType(); 11739 else { 11740 // We support flexible arrays at the end of structs in 11741 // other structs as an extension. 11742 Diag(FD->getLocation(), diag::ext_flexible_array_in_struct) 11743 << FD->getDeclName(); 11744 if (Record) 11745 Record->setHasFlexibleArrayMember(true); 11746 } 11747 } 11748 } 11749 if (isa<ObjCContainerDecl>(EnclosingDecl) && 11750 RequireNonAbstractType(FD->getLocation(), FD->getType(), 11751 diag::err_abstract_type_in_decl, 11752 AbstractIvarType)) { 11753 // Ivars can not have abstract class types 11754 FD->setInvalidDecl(); 11755 } 11756 if (Record && FDTTy->getDecl()->hasObjectMember()) 11757 Record->setHasObjectMember(true); 11758 if (Record && FDTTy->getDecl()->hasVolatileMember()) 11759 Record->setHasVolatileMember(true); 11760 } else if (FDTy->isObjCObjectType()) { 11761 /// A field cannot be an Objective-c object 11762 Diag(FD->getLocation(), diag::err_statically_allocated_object) 11763 << FixItHint::CreateInsertion(FD->getLocation(), "*"); 11764 QualType T = Context.getObjCObjectPointerType(FD->getType()); 11765 FD->setType(T); 11766 } else if (getLangOpts().ObjCAutoRefCount && Record && !ARCErrReported && 11767 (!getLangOpts().CPlusPlus || Record->isUnion())) { 11768 // It's an error in ARC if a field has lifetime. 11769 // We don't want to report this in a system header, though, 11770 // so we just make the field unavailable. 11771 // FIXME: that's really not sufficient; we need to make the type 11772 // itself invalid to, say, initialize or copy. 11773 QualType T = FD->getType(); 11774 Qualifiers::ObjCLifetime lifetime = T.getObjCLifetime(); 11775 if (lifetime && lifetime != Qualifiers::OCL_ExplicitNone) { 11776 SourceLocation loc = FD->getLocation(); 11777 if (getSourceManager().isInSystemHeader(loc)) { 11778 if (!FD->hasAttr<UnavailableAttr>()) { 11779 FD->addAttr(new (Context) UnavailableAttr(loc, Context, 11780 "this system field has retaining ownership")); 11781 } 11782 } else { 11783 Diag(FD->getLocation(), diag::err_arc_objc_object_in_tag) 11784 << T->isBlockPointerType() << Record->getTagKind(); 11785 } 11786 ARCErrReported = true; 11787 } 11788 } else if (getLangOpts().ObjC1 && 11789 getLangOpts().getGC() != LangOptions::NonGC && 11790 Record && !Record->hasObjectMember()) { 11791 if (FD->getType()->isObjCObjectPointerType() || 11792 FD->getType().isObjCGCStrong()) 11793 Record->setHasObjectMember(true); 11794 else if (Context.getAsArrayType(FD->getType())) { 11795 QualType BaseType = Context.getBaseElementType(FD->getType()); 11796 if (BaseType->isRecordType() && 11797 BaseType->getAs<RecordType>()->getDecl()->hasObjectMember()) 11798 Record->setHasObjectMember(true); 11799 else if (BaseType->isObjCObjectPointerType() || 11800 BaseType.isObjCGCStrong()) 11801 Record->setHasObjectMember(true); 11802 } 11803 } 11804 if (Record && FD->getType().isVolatileQualified()) 11805 Record->setHasVolatileMember(true); 11806 // Keep track of the number of named members. 11807 if (FD->getIdentifier()) 11808 ++NumNamedMembers; 11809 } 11810 11811 // Okay, we successfully defined 'Record'. 11812 if (Record) { 11813 bool Completed = false; 11814 if (CXXRecordDecl *CXXRecord = dyn_cast<CXXRecordDecl>(Record)) { 11815 if (!CXXRecord->isInvalidDecl()) { 11816 // Set access bits correctly on the directly-declared conversions. 11817 for (CXXRecordDecl::conversion_iterator 11818 I = CXXRecord->conversion_begin(), 11819 E = CXXRecord->conversion_end(); I != E; ++I) 11820 I.setAccess((*I)->getAccess()); 11821 11822 if (!CXXRecord->isDependentType()) { 11823 if (CXXRecord->hasUserDeclaredDestructor()) { 11824 // Adjust user-defined destructor exception spec. 11825 if (getLangOpts().CPlusPlus11) 11826 AdjustDestructorExceptionSpec(CXXRecord, 11827 CXXRecord->getDestructor()); 11828 11829 // The Microsoft ABI requires that we perform the destructor body 11830 // checks (i.e. operator delete() lookup) at every declaration, as 11831 // any translation unit may need to emit a deleting destructor. 11832 if (Context.getTargetInfo().getCXXABI().isMicrosoft()) 11833 CheckDestructor(CXXRecord->getDestructor()); 11834 } 11835 11836 // Add any implicitly-declared members to this class. 11837 AddImplicitlyDeclaredMembersToClass(CXXRecord); 11838 11839 // If we have virtual base classes, we may end up finding multiple 11840 // final overriders for a given virtual function. Check for this 11841 // problem now. 11842 if (CXXRecord->getNumVBases()) { 11843 CXXFinalOverriderMap FinalOverriders; 11844 CXXRecord->getFinalOverriders(FinalOverriders); 11845 11846 for (CXXFinalOverriderMap::iterator M = FinalOverriders.begin(), 11847 MEnd = FinalOverriders.end(); 11848 M != MEnd; ++M) { 11849 for (OverridingMethods::iterator SO = M->second.begin(), 11850 SOEnd = M->second.end(); 11851 SO != SOEnd; ++SO) { 11852 assert(SO->second.size() > 0 && 11853 "Virtual function without overridding functions?"); 11854 if (SO->second.size() == 1) 11855 continue; 11856 11857 // C++ [class.virtual]p2: 11858 // In a derived class, if a virtual member function of a base 11859 // class subobject has more than one final overrider the 11860 // program is ill-formed. 11861 Diag(Record->getLocation(), diag::err_multiple_final_overriders) 11862 << (const NamedDecl *)M->first << Record; 11863 Diag(M->first->getLocation(), 11864 diag::note_overridden_virtual_function); 11865 for (OverridingMethods::overriding_iterator 11866 OM = SO->second.begin(), 11867 OMEnd = SO->second.end(); 11868 OM != OMEnd; ++OM) 11869 Diag(OM->Method->getLocation(), diag::note_final_overrider) 11870 << (const NamedDecl *)M->first << OM->Method->getParent(); 11871 11872 Record->setInvalidDecl(); 11873 } 11874 } 11875 CXXRecord->completeDefinition(&FinalOverriders); 11876 Completed = true; 11877 } 11878 } 11879 } 11880 } 11881 11882 if (!Completed) 11883 Record->completeDefinition(); 11884 11885 if (Record->hasAttrs()) 11886 CheckAlignasUnderalignment(Record); 11887 11888 // Check if the structure/union declaration is a language extension. 11889 if (!getLangOpts().CPlusPlus) { 11890 bool ZeroSize = true; 11891 bool IsEmpty = true; 11892 unsigned NonBitFields = 0; 11893 for (RecordDecl::field_iterator I = Record->field_begin(), 11894 E = Record->field_end(); 11895 (NonBitFields == 0 || ZeroSize) && I != E; ++I) { 11896 IsEmpty = false; 11897 if (I->isUnnamedBitfield()) { 11898 if (I->getBitWidthValue(Context) > 0) 11899 ZeroSize = false; 11900 } else { 11901 ++NonBitFields; 11902 QualType FieldType = I->getType(); 11903 if (FieldType->isIncompleteType() || 11904 !Context.getTypeSizeInChars(FieldType).isZero()) 11905 ZeroSize = false; 11906 } 11907 } 11908 11909 // Empty structs are an extension in C (C99 6.7.2.1p7), but are allowed in 11910 // C++. 11911 if (ZeroSize) 11912 Diag(RecLoc, diag::warn_zero_size_struct_union_compat) << IsEmpty 11913 << Record->isUnion() << (NonBitFields > 1); 11914 11915 // Structs without named members are extension in C (C99 6.7.2.1p7), but 11916 // are accepted by GCC. 11917 if (NonBitFields == 0) { 11918 if (IsEmpty) 11919 Diag(RecLoc, diag::ext_empty_struct_union) << Record->isUnion(); 11920 else 11921 Diag(RecLoc, diag::ext_no_named_members_in_struct_union) << Record->isUnion(); 11922 } 11923 } 11924 } else { 11925 ObjCIvarDecl **ClsFields = 11926 reinterpret_cast<ObjCIvarDecl**>(RecFields.data()); 11927 if (ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(EnclosingDecl)) { 11928 ID->setEndOfDefinitionLoc(RBrac); 11929 // Add ivar's to class's DeclContext. 11930 for (unsigned i = 0, e = RecFields.size(); i != e; ++i) { 11931 ClsFields[i]->setLexicalDeclContext(ID); 11932 ID->addDecl(ClsFields[i]); 11933 } 11934 // Must enforce the rule that ivars in the base classes may not be 11935 // duplicates. 11936 if (ID->getSuperClass()) 11937 DiagnoseDuplicateIvars(ID, ID->getSuperClass()); 11938 } else if (ObjCImplementationDecl *IMPDecl = 11939 dyn_cast<ObjCImplementationDecl>(EnclosingDecl)) { 11940 assert(IMPDecl && "ActOnFields - missing ObjCImplementationDecl"); 11941 for (unsigned I = 0, N = RecFields.size(); I != N; ++I) 11942 // Ivar declared in @implementation never belongs to the implementation. 11943 // Only it is in implementation's lexical context. 11944 ClsFields[I]->setLexicalDeclContext(IMPDecl); 11945 CheckImplementationIvars(IMPDecl, ClsFields, RecFields.size(), RBrac); 11946 IMPDecl->setIvarLBraceLoc(LBrac); 11947 IMPDecl->setIvarRBraceLoc(RBrac); 11948 } else if (ObjCCategoryDecl *CDecl = 11949 dyn_cast<ObjCCategoryDecl>(EnclosingDecl)) { 11950 // case of ivars in class extension; all other cases have been 11951 // reported as errors elsewhere. 11952 // FIXME. Class extension does not have a LocEnd field. 11953 // CDecl->setLocEnd(RBrac); 11954 // Add ivar's to class extension's DeclContext. 11955 // Diagnose redeclaration of private ivars. 11956 ObjCInterfaceDecl *IDecl = CDecl->getClassInterface(); 11957 for (unsigned i = 0, e = RecFields.size(); i != e; ++i) { 11958 if (IDecl) { 11959 if (const ObjCIvarDecl *ClsIvar = 11960 IDecl->getIvarDecl(ClsFields[i]->getIdentifier())) { 11961 Diag(ClsFields[i]->getLocation(), 11962 diag::err_duplicate_ivar_declaration); 11963 Diag(ClsIvar->getLocation(), diag::note_previous_definition); 11964 continue; 11965 } 11966 for (ObjCInterfaceDecl::known_extensions_iterator 11967 Ext = IDecl->known_extensions_begin(), 11968 ExtEnd = IDecl->known_extensions_end(); 11969 Ext != ExtEnd; ++Ext) { 11970 if (const ObjCIvarDecl *ClsExtIvar 11971 = Ext->getIvarDecl(ClsFields[i]->getIdentifier())) { 11972 Diag(ClsFields[i]->getLocation(), 11973 diag::err_duplicate_ivar_declaration); 11974 Diag(ClsExtIvar->getLocation(), diag::note_previous_definition); 11975 continue; 11976 } 11977 } 11978 } 11979 ClsFields[i]->setLexicalDeclContext(CDecl); 11980 CDecl->addDecl(ClsFields[i]); 11981 } 11982 CDecl->setIvarLBraceLoc(LBrac); 11983 CDecl->setIvarRBraceLoc(RBrac); 11984 } 11985 } 11986 11987 if (Attr) 11988 ProcessDeclAttributeList(S, Record, Attr); 11989} 11990 11991/// \brief Determine whether the given integral value is representable within 11992/// the given type T. 11993static bool isRepresentableIntegerValue(ASTContext &Context, 11994 llvm::APSInt &Value, 11995 QualType T) { 11996 assert(T->isIntegralType(Context) && "Integral type required!"); 11997 unsigned BitWidth = Context.getIntWidth(T); 11998 11999 if (Value.isUnsigned() || Value.isNonNegative()) { 12000 if (T->isSignedIntegerOrEnumerationType()) 12001 --BitWidth; 12002 return Value.getActiveBits() <= BitWidth; 12003 } 12004 return Value.getMinSignedBits() <= BitWidth; 12005} 12006 12007// \brief Given an integral type, return the next larger integral type 12008// (or a NULL type of no such type exists). 12009static QualType getNextLargerIntegralType(ASTContext &Context, QualType T) { 12010 // FIXME: Int128/UInt128 support, which also needs to be introduced into 12011 // enum checking below. 12012 assert(T->isIntegralType(Context) && "Integral type required!"); 12013 const unsigned NumTypes = 4; 12014 QualType SignedIntegralTypes[NumTypes] = { 12015 Context.ShortTy, Context.IntTy, Context.LongTy, Context.LongLongTy 12016 }; 12017 QualType UnsignedIntegralTypes[NumTypes] = { 12018 Context.UnsignedShortTy, Context.UnsignedIntTy, Context.UnsignedLongTy, 12019 Context.UnsignedLongLongTy 12020 }; 12021 12022 unsigned BitWidth = Context.getTypeSize(T); 12023 QualType *Types = T->isSignedIntegerOrEnumerationType()? SignedIntegralTypes 12024 : UnsignedIntegralTypes; 12025 for (unsigned I = 0; I != NumTypes; ++I) 12026 if (Context.getTypeSize(Types[I]) > BitWidth) 12027 return Types[I]; 12028 12029 return QualType(); 12030} 12031 12032EnumConstantDecl *Sema::CheckEnumConstant(EnumDecl *Enum, 12033 EnumConstantDecl *LastEnumConst, 12034 SourceLocation IdLoc, 12035 IdentifierInfo *Id, 12036 Expr *Val) { 12037 unsigned IntWidth = Context.getTargetInfo().getIntWidth(); 12038 llvm::APSInt EnumVal(IntWidth); 12039 QualType EltTy; 12040 12041 if (Val && DiagnoseUnexpandedParameterPack(Val, UPPC_EnumeratorValue)) 12042 Val = 0; 12043 12044 if (Val) 12045 Val = DefaultLvalueConversion(Val).take(); 12046 12047 if (Val) { 12048 if (Enum->isDependentType() || Val->isTypeDependent()) 12049 EltTy = Context.DependentTy; 12050 else { 12051 SourceLocation ExpLoc; 12052 if (getLangOpts().CPlusPlus11 && Enum->isFixed() && 12053 !getLangOpts().MicrosoftMode) { 12054 // C++11 [dcl.enum]p5: If the underlying type is fixed, [...] the 12055 // constant-expression in the enumerator-definition shall be a converted 12056 // constant expression of the underlying type. 12057 EltTy = Enum->getIntegerType(); 12058 ExprResult Converted = 12059 CheckConvertedConstantExpression(Val, EltTy, EnumVal, 12060 CCEK_Enumerator); 12061 if (Converted.isInvalid()) 12062 Val = 0; 12063 else 12064 Val = Converted.take(); 12065 } else if (!Val->isValueDependent() && 12066 !(Val = VerifyIntegerConstantExpression(Val, 12067 &EnumVal).take())) { 12068 // C99 6.7.2.2p2: Make sure we have an integer constant expression. 12069 } else { 12070 if (Enum->isFixed()) { 12071 EltTy = Enum->getIntegerType(); 12072 12073 // In Obj-C and Microsoft mode, require the enumeration value to be 12074 // representable in the underlying type of the enumeration. In C++11, 12075 // we perform a non-narrowing conversion as part of converted constant 12076 // expression checking. 12077 if (!isRepresentableIntegerValue(Context, EnumVal, EltTy)) { 12078 if (getLangOpts().MicrosoftMode) { 12079 Diag(IdLoc, diag::ext_enumerator_too_large) << EltTy; 12080 Val = ImpCastExprToType(Val, EltTy, CK_IntegralCast).take(); 12081 } else 12082 Diag(IdLoc, diag::err_enumerator_too_large) << EltTy; 12083 } else 12084 Val = ImpCastExprToType(Val, EltTy, CK_IntegralCast).take(); 12085 } else if (getLangOpts().CPlusPlus) { 12086 // C++11 [dcl.enum]p5: 12087 // If the underlying type is not fixed, the type of each enumerator 12088 // is the type of its initializing value: 12089 // - If an initializer is specified for an enumerator, the 12090 // initializing value has the same type as the expression. 12091 EltTy = Val->getType(); 12092 } else { 12093 // C99 6.7.2.2p2: 12094 // The expression that defines the value of an enumeration constant 12095 // shall be an integer constant expression that has a value 12096 // representable as an int. 12097 12098 // Complain if the value is not representable in an int. 12099 if (!isRepresentableIntegerValue(Context, EnumVal, Context.IntTy)) 12100 Diag(IdLoc, diag::ext_enum_value_not_int) 12101 << EnumVal.toString(10) << Val->getSourceRange() 12102 << (EnumVal.isUnsigned() || EnumVal.isNonNegative()); 12103 else if (!Context.hasSameType(Val->getType(), Context.IntTy)) { 12104 // Force the type of the expression to 'int'. 12105 Val = ImpCastExprToType(Val, Context.IntTy, CK_IntegralCast).take(); 12106 } 12107 EltTy = Val->getType(); 12108 } 12109 } 12110 } 12111 } 12112 12113 if (!Val) { 12114 if (Enum->isDependentType()) 12115 EltTy = Context.DependentTy; 12116 else if (!LastEnumConst) { 12117 // C++0x [dcl.enum]p5: 12118 // If the underlying type is not fixed, the type of each enumerator 12119 // is the type of its initializing value: 12120 // - If no initializer is specified for the first enumerator, the 12121 // initializing value has an unspecified integral type. 12122 // 12123 // GCC uses 'int' for its unspecified integral type, as does 12124 // C99 6.7.2.2p3. 12125 if (Enum->isFixed()) { 12126 EltTy = Enum->getIntegerType(); 12127 } 12128 else { 12129 EltTy = Context.IntTy; 12130 } 12131 } else { 12132 // Assign the last value + 1. 12133 EnumVal = LastEnumConst->getInitVal(); 12134 ++EnumVal; 12135 EltTy = LastEnumConst->getType(); 12136 12137 // Check for overflow on increment. 12138 if (EnumVal < LastEnumConst->getInitVal()) { 12139 // C++0x [dcl.enum]p5: 12140 // If the underlying type is not fixed, the type of each enumerator 12141 // is the type of its initializing value: 12142 // 12143 // - Otherwise the type of the initializing value is the same as 12144 // the type of the initializing value of the preceding enumerator 12145 // unless the incremented value is not representable in that type, 12146 // in which case the type is an unspecified integral type 12147 // sufficient to contain the incremented value. If no such type 12148 // exists, the program is ill-formed. 12149 QualType T = getNextLargerIntegralType(Context, EltTy); 12150 if (T.isNull() || Enum->isFixed()) { 12151 // There is no integral type larger enough to represent this 12152 // value. Complain, then allow the value to wrap around. 12153 EnumVal = LastEnumConst->getInitVal(); 12154 EnumVal = EnumVal.zext(EnumVal.getBitWidth() * 2); 12155 ++EnumVal; 12156 if (Enum->isFixed()) 12157 // When the underlying type is fixed, this is ill-formed. 12158 Diag(IdLoc, diag::err_enumerator_wrapped) 12159 << EnumVal.toString(10) 12160 << EltTy; 12161 else 12162 Diag(IdLoc, diag::warn_enumerator_too_large) 12163 << EnumVal.toString(10); 12164 } else { 12165 EltTy = T; 12166 } 12167 12168 // Retrieve the last enumerator's value, extent that type to the 12169 // type that is supposed to be large enough to represent the incremented 12170 // value, then increment. 12171 EnumVal = LastEnumConst->getInitVal(); 12172 EnumVal.setIsSigned(EltTy->isSignedIntegerOrEnumerationType()); 12173 EnumVal = EnumVal.zextOrTrunc(Context.getIntWidth(EltTy)); 12174 ++EnumVal; 12175 12176 // If we're not in C++, diagnose the overflow of enumerator values, 12177 // which in C99 means that the enumerator value is not representable in 12178 // an int (C99 6.7.2.2p2). However, we support GCC's extension that 12179 // permits enumerator values that are representable in some larger 12180 // integral type. 12181 if (!getLangOpts().CPlusPlus && !T.isNull()) 12182 Diag(IdLoc, diag::warn_enum_value_overflow); 12183 } else if (!getLangOpts().CPlusPlus && 12184 !isRepresentableIntegerValue(Context, EnumVal, EltTy)) { 12185 // Enforce C99 6.7.2.2p2 even when we compute the next value. 12186 Diag(IdLoc, diag::ext_enum_value_not_int) 12187 << EnumVal.toString(10) << 1; 12188 } 12189 } 12190 } 12191 12192 if (!EltTy->isDependentType()) { 12193 // Make the enumerator value match the signedness and size of the 12194 // enumerator's type. 12195 EnumVal = EnumVal.extOrTrunc(Context.getIntWidth(EltTy)); 12196 EnumVal.setIsSigned(EltTy->isSignedIntegerOrEnumerationType()); 12197 } 12198 12199 return EnumConstantDecl::Create(Context, Enum, IdLoc, Id, EltTy, 12200 Val, EnumVal); 12201} 12202 12203 12204Decl *Sema::ActOnEnumConstant(Scope *S, Decl *theEnumDecl, Decl *lastEnumConst, 12205 SourceLocation IdLoc, IdentifierInfo *Id, 12206 AttributeList *Attr, 12207 SourceLocation EqualLoc, Expr *Val) { 12208 EnumDecl *TheEnumDecl = cast<EnumDecl>(theEnumDecl); 12209 EnumConstantDecl *LastEnumConst = 12210 cast_or_null<EnumConstantDecl>(lastEnumConst); 12211 12212 // The scope passed in may not be a decl scope. Zip up the scope tree until 12213 // we find one that is. 12214 S = getNonFieldDeclScope(S); 12215 12216 // Verify that there isn't already something declared with this name in this 12217 // scope. 12218 NamedDecl *PrevDecl = LookupSingleName(S, Id, IdLoc, LookupOrdinaryName, 12219 ForRedeclaration); 12220 if (PrevDecl && PrevDecl->isTemplateParameter()) { 12221 // Maybe we will complain about the shadowed template parameter. 12222 DiagnoseTemplateParameterShadow(IdLoc, PrevDecl); 12223 // Just pretend that we didn't see the previous declaration. 12224 PrevDecl = 0; 12225 } 12226 12227 if (PrevDecl) { 12228 // When in C++, we may get a TagDecl with the same name; in this case the 12229 // enum constant will 'hide' the tag. 12230 assert((getLangOpts().CPlusPlus || !isa<TagDecl>(PrevDecl)) && 12231 "Received TagDecl when not in C++!"); 12232 if (!isa<TagDecl>(PrevDecl) && isDeclInScope(PrevDecl, CurContext, S)) { 12233 if (isa<EnumConstantDecl>(PrevDecl)) 12234 Diag(IdLoc, diag::err_redefinition_of_enumerator) << Id; 12235 else 12236 Diag(IdLoc, diag::err_redefinition) << Id; 12237 Diag(PrevDecl->getLocation(), diag::note_previous_definition); 12238 return 0; 12239 } 12240 } 12241 12242 // C++ [class.mem]p15: 12243 // If T is the name of a class, then each of the following shall have a name 12244 // different from T: 12245 // - every enumerator of every member of class T that is an unscoped 12246 // enumerated type 12247 if (CXXRecordDecl *Record 12248 = dyn_cast<CXXRecordDecl>( 12249 TheEnumDecl->getDeclContext()->getRedeclContext())) 12250 if (!TheEnumDecl->isScoped() && 12251 Record->getIdentifier() && Record->getIdentifier() == Id) 12252 Diag(IdLoc, diag::err_member_name_of_class) << Id; 12253 12254 EnumConstantDecl *New = 12255 CheckEnumConstant(TheEnumDecl, LastEnumConst, IdLoc, Id, Val); 12256 12257 if (New) { 12258 // Process attributes. 12259 if (Attr) ProcessDeclAttributeList(S, New, Attr); 12260 12261 // Register this decl in the current scope stack. 12262 New->setAccess(TheEnumDecl->getAccess()); 12263 PushOnScopeChains(New, S); 12264 } 12265 12266 ActOnDocumentableDecl(New); 12267 12268 return New; 12269} 12270 12271// Returns true when the enum initial expression does not trigger the 12272// duplicate enum warning. A few common cases are exempted as follows: 12273// Element2 = Element1 12274// Element2 = Element1 + 1 12275// Element2 = Element1 - 1 12276// Where Element2 and Element1 are from the same enum. 12277static bool ValidDuplicateEnum(EnumConstantDecl *ECD, EnumDecl *Enum) { 12278 Expr *InitExpr = ECD->getInitExpr(); 12279 if (!InitExpr) 12280 return true; 12281 InitExpr = InitExpr->IgnoreImpCasts(); 12282 12283 if (BinaryOperator *BO = dyn_cast<BinaryOperator>(InitExpr)) { 12284 if (!BO->isAdditiveOp()) 12285 return true; 12286 IntegerLiteral *IL = dyn_cast<IntegerLiteral>(BO->getRHS()); 12287 if (!IL) 12288 return true; 12289 if (IL->getValue() != 1) 12290 return true; 12291 12292 InitExpr = BO->getLHS(); 12293 } 12294 12295 // This checks if the elements are from the same enum. 12296 DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(InitExpr); 12297 if (!DRE) 12298 return true; 12299 12300 EnumConstantDecl *EnumConstant = dyn_cast<EnumConstantDecl>(DRE->getDecl()); 12301 if (!EnumConstant) 12302 return true; 12303 12304 if (cast<EnumDecl>(TagDecl::castFromDeclContext(ECD->getDeclContext())) != 12305 Enum) 12306 return true; 12307 12308 return false; 12309} 12310 12311struct DupKey { 12312 int64_t val; 12313 bool isTombstoneOrEmptyKey; 12314 DupKey(int64_t val, bool isTombstoneOrEmptyKey) 12315 : val(val), isTombstoneOrEmptyKey(isTombstoneOrEmptyKey) {} 12316}; 12317 12318static DupKey GetDupKey(const llvm::APSInt& Val) { 12319 return DupKey(Val.isSigned() ? Val.getSExtValue() : Val.getZExtValue(), 12320 false); 12321} 12322 12323struct DenseMapInfoDupKey { 12324 static DupKey getEmptyKey() { return DupKey(0, true); } 12325 static DupKey getTombstoneKey() { return DupKey(1, true); } 12326 static unsigned getHashValue(const DupKey Key) { 12327 return (unsigned)(Key.val * 37); 12328 } 12329 static bool isEqual(const DupKey& LHS, const DupKey& RHS) { 12330 return LHS.isTombstoneOrEmptyKey == RHS.isTombstoneOrEmptyKey && 12331 LHS.val == RHS.val; 12332 } 12333}; 12334 12335// Emits a warning when an element is implicitly set a value that 12336// a previous element has already been set to. 12337static void CheckForDuplicateEnumValues(Sema &S, ArrayRef<Decl *> Elements, 12338 EnumDecl *Enum, 12339 QualType EnumType) { 12340 if (S.Diags.getDiagnosticLevel(diag::warn_duplicate_enum_values, 12341 Enum->getLocation()) == 12342 DiagnosticsEngine::Ignored) 12343 return; 12344 // Avoid anonymous enums 12345 if (!Enum->getIdentifier()) 12346 return; 12347 12348 // Only check for small enums. 12349 if (Enum->getNumPositiveBits() > 63 || Enum->getNumNegativeBits() > 64) 12350 return; 12351 12352 typedef SmallVector<EnumConstantDecl *, 3> ECDVector; 12353 typedef SmallVector<ECDVector *, 3> DuplicatesVector; 12354 12355 typedef llvm::PointerUnion<EnumConstantDecl*, ECDVector*> DeclOrVector; 12356 typedef llvm::DenseMap<DupKey, DeclOrVector, DenseMapInfoDupKey> 12357 ValueToVectorMap; 12358 12359 DuplicatesVector DupVector; 12360 ValueToVectorMap EnumMap; 12361 12362 // Populate the EnumMap with all values represented by enum constants without 12363 // an initialier. 12364 for (unsigned i = 0, e = Elements.size(); i != e; ++i) { 12365 EnumConstantDecl *ECD = cast_or_null<EnumConstantDecl>(Elements[i]); 12366 12367 // Null EnumConstantDecl means a previous diagnostic has been emitted for 12368 // this constant. Skip this enum since it may be ill-formed. 12369 if (!ECD) { 12370 return; 12371 } 12372 12373 if (ECD->getInitExpr()) 12374 continue; 12375 12376 DupKey Key = GetDupKey(ECD->getInitVal()); 12377 DeclOrVector &Entry = EnumMap[Key]; 12378 12379 // First time encountering this value. 12380 if (Entry.isNull()) 12381 Entry = ECD; 12382 } 12383 12384 // Create vectors for any values that has duplicates. 12385 for (unsigned i = 0, e = Elements.size(); i != e; ++i) { 12386 EnumConstantDecl *ECD = cast<EnumConstantDecl>(Elements[i]); 12387 if (!ValidDuplicateEnum(ECD, Enum)) 12388 continue; 12389 12390 DupKey Key = GetDupKey(ECD->getInitVal()); 12391 12392 DeclOrVector& Entry = EnumMap[Key]; 12393 if (Entry.isNull()) 12394 continue; 12395 12396 if (EnumConstantDecl *D = Entry.dyn_cast<EnumConstantDecl*>()) { 12397 // Ensure constants are different. 12398 if (D == ECD) 12399 continue; 12400 12401 // Create new vector and push values onto it. 12402 ECDVector *Vec = new ECDVector(); 12403 Vec->push_back(D); 12404 Vec->push_back(ECD); 12405 12406 // Update entry to point to the duplicates vector. 12407 Entry = Vec; 12408 12409 // Store the vector somewhere we can consult later for quick emission of 12410 // diagnostics. 12411 DupVector.push_back(Vec); 12412 continue; 12413 } 12414 12415 ECDVector *Vec = Entry.get<ECDVector*>(); 12416 // Make sure constants are not added more than once. 12417 if (*Vec->begin() == ECD) 12418 continue; 12419 12420 Vec->push_back(ECD); 12421 } 12422 12423 // Emit diagnostics. 12424 for (DuplicatesVector::iterator DupVectorIter = DupVector.begin(), 12425 DupVectorEnd = DupVector.end(); 12426 DupVectorIter != DupVectorEnd; ++DupVectorIter) { 12427 ECDVector *Vec = *DupVectorIter; 12428 assert(Vec->size() > 1 && "ECDVector should have at least 2 elements."); 12429 12430 // Emit warning for one enum constant. 12431 ECDVector::iterator I = Vec->begin(); 12432 S.Diag((*I)->getLocation(), diag::warn_duplicate_enum_values) 12433 << (*I)->getName() << (*I)->getInitVal().toString(10) 12434 << (*I)->getSourceRange(); 12435 ++I; 12436 12437 // Emit one note for each of the remaining enum constants with 12438 // the same value. 12439 for (ECDVector::iterator E = Vec->end(); I != E; ++I) 12440 S.Diag((*I)->getLocation(), diag::note_duplicate_element) 12441 << (*I)->getName() << (*I)->getInitVal().toString(10) 12442 << (*I)->getSourceRange(); 12443 delete Vec; 12444 } 12445} 12446 12447void Sema::ActOnEnumBody(SourceLocation EnumLoc, SourceLocation LBraceLoc, 12448 SourceLocation RBraceLoc, Decl *EnumDeclX, 12449 ArrayRef<Decl *> Elements, 12450 Scope *S, AttributeList *Attr) { 12451 EnumDecl *Enum = cast<EnumDecl>(EnumDeclX); 12452 QualType EnumType = Context.getTypeDeclType(Enum); 12453 12454 if (Attr) 12455 ProcessDeclAttributeList(S, Enum, Attr); 12456 12457 if (Enum->isDependentType()) { 12458 for (unsigned i = 0, e = Elements.size(); i != e; ++i) { 12459 EnumConstantDecl *ECD = 12460 cast_or_null<EnumConstantDecl>(Elements[i]); 12461 if (!ECD) continue; 12462 12463 ECD->setType(EnumType); 12464 } 12465 12466 Enum->completeDefinition(Context.DependentTy, Context.DependentTy, 0, 0); 12467 return; 12468 } 12469 12470 // TODO: If the result value doesn't fit in an int, it must be a long or long 12471 // long value. ISO C does not support this, but GCC does as an extension, 12472 // emit a warning. 12473 unsigned IntWidth = Context.getTargetInfo().getIntWidth(); 12474 unsigned CharWidth = Context.getTargetInfo().getCharWidth(); 12475 unsigned ShortWidth = Context.getTargetInfo().getShortWidth(); 12476 12477 // Verify that all the values are okay, compute the size of the values, and 12478 // reverse the list. 12479 unsigned NumNegativeBits = 0; 12480 unsigned NumPositiveBits = 0; 12481 12482 // Keep track of whether all elements have type int. 12483 bool AllElementsInt = true; 12484 12485 for (unsigned i = 0, e = Elements.size(); i != e; ++i) { 12486 EnumConstantDecl *ECD = 12487 cast_or_null<EnumConstantDecl>(Elements[i]); 12488 if (!ECD) continue; // Already issued a diagnostic. 12489 12490 const llvm::APSInt &InitVal = ECD->getInitVal(); 12491 12492 // Keep track of the size of positive and negative values. 12493 if (InitVal.isUnsigned() || InitVal.isNonNegative()) 12494 NumPositiveBits = std::max(NumPositiveBits, 12495 (unsigned)InitVal.getActiveBits()); 12496 else 12497 NumNegativeBits = std::max(NumNegativeBits, 12498 (unsigned)InitVal.getMinSignedBits()); 12499 12500 // Keep track of whether every enum element has type int (very commmon). 12501 if (AllElementsInt) 12502 AllElementsInt = ECD->getType() == Context.IntTy; 12503 } 12504 12505 // Figure out the type that should be used for this enum. 12506 QualType BestType; 12507 unsigned BestWidth; 12508 12509 // C++0x N3000 [conv.prom]p3: 12510 // An rvalue of an unscoped enumeration type whose underlying 12511 // type is not fixed can be converted to an rvalue of the first 12512 // of the following types that can represent all the values of 12513 // the enumeration: int, unsigned int, long int, unsigned long 12514 // int, long long int, or unsigned long long int. 12515 // C99 6.4.4.3p2: 12516 // An identifier declared as an enumeration constant has type int. 12517 // The C99 rule is modified by a gcc extension 12518 QualType BestPromotionType; 12519 12520 bool Packed = Enum->getAttr<PackedAttr>() ? true : false; 12521 // -fshort-enums is the equivalent to specifying the packed attribute on all 12522 // enum definitions. 12523 if (LangOpts.ShortEnums) 12524 Packed = true; 12525 12526 if (Enum->isFixed()) { 12527 BestType = Enum->getIntegerType(); 12528 if (BestType->isPromotableIntegerType()) 12529 BestPromotionType = Context.getPromotedIntegerType(BestType); 12530 else 12531 BestPromotionType = BestType; 12532 // We don't need to set BestWidth, because BestType is going to be the type 12533 // of the enumerators, but we do anyway because otherwise some compilers 12534 // warn that it might be used uninitialized. 12535 BestWidth = CharWidth; 12536 } 12537 else if (NumNegativeBits) { 12538 // If there is a negative value, figure out the smallest integer type (of 12539 // int/long/longlong) that fits. 12540 // If it's packed, check also if it fits a char or a short. 12541 if (Packed && NumNegativeBits <= CharWidth && NumPositiveBits < CharWidth) { 12542 BestType = Context.SignedCharTy; 12543 BestWidth = CharWidth; 12544 } else if (Packed && NumNegativeBits <= ShortWidth && 12545 NumPositiveBits < ShortWidth) { 12546 BestType = Context.ShortTy; 12547 BestWidth = ShortWidth; 12548 } else if (NumNegativeBits <= IntWidth && NumPositiveBits < IntWidth) { 12549 BestType = Context.IntTy; 12550 BestWidth = IntWidth; 12551 } else { 12552 BestWidth = Context.getTargetInfo().getLongWidth(); 12553 12554 if (NumNegativeBits <= BestWidth && NumPositiveBits < BestWidth) { 12555 BestType = Context.LongTy; 12556 } else { 12557 BestWidth = Context.getTargetInfo().getLongLongWidth(); 12558 12559 if (NumNegativeBits > BestWidth || NumPositiveBits >= BestWidth) 12560 Diag(Enum->getLocation(), diag::warn_enum_too_large); 12561 BestType = Context.LongLongTy; 12562 } 12563 } 12564 BestPromotionType = (BestWidth <= IntWidth ? Context.IntTy : BestType); 12565 } else { 12566 // If there is no negative value, figure out the smallest type that fits 12567 // all of the enumerator values. 12568 // If it's packed, check also if it fits a char or a short. 12569 if (Packed && NumPositiveBits <= CharWidth) { 12570 BestType = Context.UnsignedCharTy; 12571 BestPromotionType = Context.IntTy; 12572 BestWidth = CharWidth; 12573 } else if (Packed && NumPositiveBits <= ShortWidth) { 12574 BestType = Context.UnsignedShortTy; 12575 BestPromotionType = Context.IntTy; 12576 BestWidth = ShortWidth; 12577 } else if (NumPositiveBits <= IntWidth) { 12578 BestType = Context.UnsignedIntTy; 12579 BestWidth = IntWidth; 12580 BestPromotionType 12581 = (NumPositiveBits == BestWidth || !getLangOpts().CPlusPlus) 12582 ? Context.UnsignedIntTy : Context.IntTy; 12583 } else if (NumPositiveBits <= 12584 (BestWidth = Context.getTargetInfo().getLongWidth())) { 12585 BestType = Context.UnsignedLongTy; 12586 BestPromotionType 12587 = (NumPositiveBits == BestWidth || !getLangOpts().CPlusPlus) 12588 ? Context.UnsignedLongTy : Context.LongTy; 12589 } else { 12590 BestWidth = Context.getTargetInfo().getLongLongWidth(); 12591 assert(NumPositiveBits <= BestWidth && 12592 "How could an initializer get larger than ULL?"); 12593 BestType = Context.UnsignedLongLongTy; 12594 BestPromotionType 12595 = (NumPositiveBits == BestWidth || !getLangOpts().CPlusPlus) 12596 ? Context.UnsignedLongLongTy : Context.LongLongTy; 12597 } 12598 } 12599 12600 // Loop over all of the enumerator constants, changing their types to match 12601 // the type of the enum if needed. 12602 for (unsigned i = 0, e = Elements.size(); i != e; ++i) { 12603 EnumConstantDecl *ECD = cast_or_null<EnumConstantDecl>(Elements[i]); 12604 if (!ECD) continue; // Already issued a diagnostic. 12605 12606 // Standard C says the enumerators have int type, but we allow, as an 12607 // extension, the enumerators to be larger than int size. If each 12608 // enumerator value fits in an int, type it as an int, otherwise type it the 12609 // same as the enumerator decl itself. This means that in "enum { X = 1U }" 12610 // that X has type 'int', not 'unsigned'. 12611 12612 // Determine whether the value fits into an int. 12613 llvm::APSInt InitVal = ECD->getInitVal(); 12614 12615 // If it fits into an integer type, force it. Otherwise force it to match 12616 // the enum decl type. 12617 QualType NewTy; 12618 unsigned NewWidth; 12619 bool NewSign; 12620 if (!getLangOpts().CPlusPlus && 12621 !Enum->isFixed() && 12622 isRepresentableIntegerValue(Context, InitVal, Context.IntTy)) { 12623 NewTy = Context.IntTy; 12624 NewWidth = IntWidth; 12625 NewSign = true; 12626 } else if (ECD->getType() == BestType) { 12627 // Already the right type! 12628 if (getLangOpts().CPlusPlus) 12629 // C++ [dcl.enum]p4: Following the closing brace of an 12630 // enum-specifier, each enumerator has the type of its 12631 // enumeration. 12632 ECD->setType(EnumType); 12633 continue; 12634 } else { 12635 NewTy = BestType; 12636 NewWidth = BestWidth; 12637 NewSign = BestType->isSignedIntegerOrEnumerationType(); 12638 } 12639 12640 // Adjust the APSInt value. 12641 InitVal = InitVal.extOrTrunc(NewWidth); 12642 InitVal.setIsSigned(NewSign); 12643 ECD->setInitVal(InitVal); 12644 12645 // Adjust the Expr initializer and type. 12646 if (ECD->getInitExpr() && 12647 !Context.hasSameType(NewTy, ECD->getInitExpr()->getType())) 12648 ECD->setInitExpr(ImplicitCastExpr::Create(Context, NewTy, 12649 CK_IntegralCast, 12650 ECD->getInitExpr(), 12651 /*base paths*/ 0, 12652 VK_RValue)); 12653 if (getLangOpts().CPlusPlus) 12654 // C++ [dcl.enum]p4: Following the closing brace of an 12655 // enum-specifier, each enumerator has the type of its 12656 // enumeration. 12657 ECD->setType(EnumType); 12658 else 12659 ECD->setType(NewTy); 12660 } 12661 12662 Enum->completeDefinition(BestType, BestPromotionType, 12663 NumPositiveBits, NumNegativeBits); 12664 12665 // If we're declaring a function, ensure this decl isn't forgotten about - 12666 // it needs to go into the function scope. 12667 if (InFunctionDeclarator) 12668 DeclsInPrototypeScope.push_back(Enum); 12669 12670 CheckForDuplicateEnumValues(*this, Elements, Enum, EnumType); 12671 12672 // Now that the enum type is defined, ensure it's not been underaligned. 12673 if (Enum->hasAttrs()) 12674 CheckAlignasUnderalignment(Enum); 12675} 12676 12677Decl *Sema::ActOnFileScopeAsmDecl(Expr *expr, 12678 SourceLocation StartLoc, 12679 SourceLocation EndLoc) { 12680 StringLiteral *AsmString = cast<StringLiteral>(expr); 12681 12682 FileScopeAsmDecl *New = FileScopeAsmDecl::Create(Context, CurContext, 12683 AsmString, StartLoc, 12684 EndLoc); 12685 CurContext->addDecl(New); 12686 return New; 12687} 12688 12689DeclResult Sema::ActOnModuleImport(SourceLocation AtLoc, 12690 SourceLocation ImportLoc, 12691 ModuleIdPath Path) { 12692 Module *Mod = PP.getModuleLoader().loadModule(ImportLoc, Path, 12693 Module::AllVisible, 12694 /*IsIncludeDirective=*/false); 12695 if (!Mod) 12696 return true; 12697 12698 SmallVector<SourceLocation, 2> IdentifierLocs; 12699 Module *ModCheck = Mod; 12700 for (unsigned I = 0, N = Path.size(); I != N; ++I) { 12701 // If we've run out of module parents, just drop the remaining identifiers. 12702 // We need the length to be consistent. 12703 if (!ModCheck) 12704 break; 12705 ModCheck = ModCheck->Parent; 12706 12707 IdentifierLocs.push_back(Path[I].second); 12708 } 12709 12710 ImportDecl *Import = ImportDecl::Create(Context, 12711 Context.getTranslationUnitDecl(), 12712 AtLoc.isValid()? AtLoc : ImportLoc, 12713 Mod, IdentifierLocs); 12714 Context.getTranslationUnitDecl()->addDecl(Import); 12715 return Import; 12716} 12717 12718void Sema::createImplicitModuleImport(SourceLocation Loc, Module *Mod) { 12719 // Create the implicit import declaration. 12720 TranslationUnitDecl *TU = getASTContext().getTranslationUnitDecl(); 12721 ImportDecl *ImportD = ImportDecl::CreateImplicit(getASTContext(), TU, 12722 Loc, Mod, Loc); 12723 TU->addDecl(ImportD); 12724 Consumer.HandleImplicitImportDecl(ImportD); 12725 12726 // Make the module visible. 12727 PP.getModuleLoader().makeModuleVisible(Mod, Module::AllVisible, Loc, 12728 /*Complain=*/false); 12729} 12730 12731void Sema::ActOnPragmaRedefineExtname(IdentifierInfo* Name, 12732 IdentifierInfo* AliasName, 12733 SourceLocation PragmaLoc, 12734 SourceLocation NameLoc, 12735 SourceLocation AliasNameLoc) { 12736 Decl *PrevDecl = LookupSingleName(TUScope, Name, NameLoc, 12737 LookupOrdinaryName); 12738 AsmLabelAttr *Attr = 12739 ::new (Context) AsmLabelAttr(AliasNameLoc, Context, AliasName->getName()); 12740 12741 if (PrevDecl) 12742 PrevDecl->addAttr(Attr); 12743 else 12744 (void)ExtnameUndeclaredIdentifiers.insert( 12745 std::pair<IdentifierInfo*,AsmLabelAttr*>(Name, Attr)); 12746} 12747 12748void Sema::ActOnPragmaWeakID(IdentifierInfo* Name, 12749 SourceLocation PragmaLoc, 12750 SourceLocation NameLoc) { 12751 Decl *PrevDecl = LookupSingleName(TUScope, Name, NameLoc, LookupOrdinaryName); 12752 12753 if (PrevDecl) { 12754 PrevDecl->addAttr(::new (Context) WeakAttr(PragmaLoc, Context)); 12755 } else { 12756 (void)WeakUndeclaredIdentifiers.insert( 12757 std::pair<IdentifierInfo*,WeakInfo> 12758 (Name, WeakInfo((IdentifierInfo*)0, NameLoc))); 12759 } 12760} 12761 12762void Sema::ActOnPragmaWeakAlias(IdentifierInfo* Name, 12763 IdentifierInfo* AliasName, 12764 SourceLocation PragmaLoc, 12765 SourceLocation NameLoc, 12766 SourceLocation AliasNameLoc) { 12767 Decl *PrevDecl = LookupSingleName(TUScope, AliasName, AliasNameLoc, 12768 LookupOrdinaryName); 12769 WeakInfo W = WeakInfo(Name, NameLoc); 12770 12771 if (PrevDecl) { 12772 if (!PrevDecl->hasAttr<AliasAttr>()) 12773 if (NamedDecl *ND = dyn_cast<NamedDecl>(PrevDecl)) 12774 DeclApplyPragmaWeak(TUScope, ND, W); 12775 } else { 12776 (void)WeakUndeclaredIdentifiers.insert( 12777 std::pair<IdentifierInfo*,WeakInfo>(AliasName, W)); 12778 } 12779} 12780 12781Decl *Sema::getObjCDeclContext() const { 12782 return (dyn_cast_or_null<ObjCContainerDecl>(CurContext)); 12783} 12784 12785AvailabilityResult Sema::getCurContextAvailability() const { 12786 const Decl *D = cast<Decl>(getCurObjCLexicalContext()); 12787 return D->getAvailability(); 12788} 12789