SemaDecl.cpp revision db57a4cdb0a6abf3239f3a794a900ce312c5887b
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 "clang/Sema/Initialization.h" 16#include "clang/Sema/Lookup.h" 17#include "clang/Sema/CXXFieldCollector.h" 18#include "clang/Sema/Scope.h" 19#include "clang/Sema/ScopeInfo.h" 20#include "TypeLocBuilder.h" 21#include "clang/AST/APValue.h" 22#include "clang/AST/ASTConsumer.h" 23#include "clang/AST/ASTContext.h" 24#include "clang/AST/CXXInheritance.h" 25#include "clang/AST/DeclCXX.h" 26#include "clang/AST/DeclObjC.h" 27#include "clang/AST/DeclTemplate.h" 28#include "clang/AST/EvaluatedExprVisitor.h" 29#include "clang/AST/ExprCXX.h" 30#include "clang/AST/StmtCXX.h" 31#include "clang/AST/CharUnits.h" 32#include "clang/Sema/DeclSpec.h" 33#include "clang/Sema/ParsedTemplate.h" 34#include "clang/Parse/ParseDiagnostic.h" 35#include "clang/Basic/PartialDiagnostic.h" 36#include "clang/Basic/SourceManager.h" 37#include "clang/Basic/TargetInfo.h" 38// FIXME: layering (ideally, Sema shouldn't be dependent on Lex API's) 39#include "clang/Lex/Preprocessor.h" 40#include "clang/Lex/HeaderSearch.h" 41#include "llvm/ADT/Triple.h" 42#include <algorithm> 43#include <cstring> 44#include <functional> 45using namespace clang; 46using namespace sema; 47 48Sema::DeclGroupPtrTy Sema::ConvertDeclToDeclGroup(Decl *Ptr) { 49 return DeclGroupPtrTy::make(DeclGroupRef(Ptr)); 50} 51 52/// \brief If the identifier refers to a type name within this scope, 53/// return the declaration of that type. 54/// 55/// This routine performs ordinary name lookup of the identifier II 56/// within the given scope, with optional C++ scope specifier SS, to 57/// determine whether the name refers to a type. If so, returns an 58/// opaque pointer (actually a QualType) corresponding to that 59/// type. Otherwise, returns NULL. 60/// 61/// If name lookup results in an ambiguity, this routine will complain 62/// and then return NULL. 63ParsedType Sema::getTypeName(IdentifierInfo &II, SourceLocation NameLoc, 64 Scope *S, CXXScopeSpec *SS, 65 bool isClassName, bool HasTrailingDot, 66 ParsedType ObjectTypePtr, 67 bool WantNontrivialTypeSourceInfo) { 68 // Determine where we will perform name lookup. 69 DeclContext *LookupCtx = 0; 70 if (ObjectTypePtr) { 71 QualType ObjectType = ObjectTypePtr.get(); 72 if (ObjectType->isRecordType()) 73 LookupCtx = computeDeclContext(ObjectType); 74 } else if (SS && SS->isNotEmpty()) { 75 LookupCtx = computeDeclContext(*SS, false); 76 77 if (!LookupCtx) { 78 if (isDependentScopeSpecifier(*SS)) { 79 // C++ [temp.res]p3: 80 // A qualified-id that refers to a type and in which the 81 // nested-name-specifier depends on a template-parameter (14.6.2) 82 // shall be prefixed by the keyword typename to indicate that the 83 // qualified-id denotes a type, forming an 84 // elaborated-type-specifier (7.1.5.3). 85 // 86 // We therefore do not perform any name lookup if the result would 87 // refer to a member of an unknown specialization. 88 if (!isClassName) 89 return ParsedType(); 90 91 // We know from the grammar that this name refers to a type, 92 // so build a dependent node to describe the type. 93 if (WantNontrivialTypeSourceInfo) 94 return ActOnTypenameType(S, SourceLocation(), *SS, II, NameLoc).get(); 95 96 NestedNameSpecifierLoc QualifierLoc = SS->getWithLocInContext(Context); 97 QualType T = 98 CheckTypenameType(ETK_None, SourceLocation(), QualifierLoc, 99 II, NameLoc); 100 101 return ParsedType::make(T); 102 } 103 104 return ParsedType(); 105 } 106 107 if (!LookupCtx->isDependentContext() && 108 RequireCompleteDeclContext(*SS, LookupCtx)) 109 return ParsedType(); 110 } 111 112 // FIXME: LookupNestedNameSpecifierName isn't the right kind of 113 // lookup for class-names. 114 LookupNameKind Kind = isClassName ? LookupNestedNameSpecifierName : 115 LookupOrdinaryName; 116 LookupResult Result(*this, &II, NameLoc, Kind); 117 if (LookupCtx) { 118 // Perform "qualified" name lookup into the declaration context we 119 // computed, which is either the type of the base of a member access 120 // expression or the declaration context associated with a prior 121 // nested-name-specifier. 122 LookupQualifiedName(Result, LookupCtx); 123 124 if (ObjectTypePtr && Result.empty()) { 125 // C++ [basic.lookup.classref]p3: 126 // If the unqualified-id is ~type-name, the type-name is looked up 127 // in the context of the entire postfix-expression. If the type T of 128 // the object expression is of a class type C, the type-name is also 129 // looked up in the scope of class C. At least one of the lookups shall 130 // find a name that refers to (possibly cv-qualified) T. 131 LookupName(Result, S); 132 } 133 } else { 134 // Perform unqualified name lookup. 135 LookupName(Result, S); 136 } 137 138 NamedDecl *IIDecl = 0; 139 switch (Result.getResultKind()) { 140 case LookupResult::NotFound: 141 case LookupResult::NotFoundInCurrentInstantiation: 142 case LookupResult::FoundOverloaded: 143 case LookupResult::FoundUnresolvedValue: 144 Result.suppressDiagnostics(); 145 return ParsedType(); 146 147 case LookupResult::Ambiguous: 148 // Recover from type-hiding ambiguities by hiding the type. We'll 149 // do the lookup again when looking for an object, and we can 150 // diagnose the error then. If we don't do this, then the error 151 // about hiding the type will be immediately followed by an error 152 // that only makes sense if the identifier was treated like a type. 153 if (Result.getAmbiguityKind() == LookupResult::AmbiguousTagHiding) { 154 Result.suppressDiagnostics(); 155 return ParsedType(); 156 } 157 158 // Look to see if we have a type anywhere in the list of results. 159 for (LookupResult::iterator Res = Result.begin(), ResEnd = Result.end(); 160 Res != ResEnd; ++Res) { 161 if (isa<TypeDecl>(*Res) || isa<ObjCInterfaceDecl>(*Res)) { 162 if (!IIDecl || 163 (*Res)->getLocation().getRawEncoding() < 164 IIDecl->getLocation().getRawEncoding()) 165 IIDecl = *Res; 166 } 167 } 168 169 if (!IIDecl) { 170 // None of the entities we found is a type, so there is no way 171 // to even assume that the result is a type. In this case, don't 172 // complain about the ambiguity. The parser will either try to 173 // perform this lookup again (e.g., as an object name), which 174 // will produce the ambiguity, or will complain that it expected 175 // a type name. 176 Result.suppressDiagnostics(); 177 return ParsedType(); 178 } 179 180 // We found a type within the ambiguous lookup; diagnose the 181 // ambiguity and then return that type. This might be the right 182 // answer, or it might not be, but it suppresses any attempt to 183 // perform the name lookup again. 184 break; 185 186 case LookupResult::Found: 187 IIDecl = Result.getFoundDecl(); 188 break; 189 } 190 191 assert(IIDecl && "Didn't find decl"); 192 193 QualType T; 194 if (TypeDecl *TD = dyn_cast<TypeDecl>(IIDecl)) { 195 DiagnoseUseOfDecl(IIDecl, NameLoc); 196 197 if (T.isNull()) 198 T = Context.getTypeDeclType(TD); 199 200 if (SS && SS->isNotEmpty()) { 201 if (WantNontrivialTypeSourceInfo) { 202 // Construct a type with type-source information. 203 TypeLocBuilder Builder; 204 Builder.pushTypeSpec(T).setNameLoc(NameLoc); 205 206 T = getElaboratedType(ETK_None, *SS, T); 207 ElaboratedTypeLoc ElabTL = Builder.push<ElaboratedTypeLoc>(T); 208 ElabTL.setKeywordLoc(SourceLocation()); 209 ElabTL.setQualifierLoc(SS->getWithLocInContext(Context)); 210 return CreateParsedType(T, Builder.getTypeSourceInfo(Context, T)); 211 } else { 212 T = getElaboratedType(ETK_None, *SS, T); 213 } 214 } 215 } else if (ObjCInterfaceDecl *IDecl = dyn_cast<ObjCInterfaceDecl>(IIDecl)) { 216 (void)DiagnoseUseOfDecl(IDecl, NameLoc); 217 if (!HasTrailingDot) 218 T = Context.getObjCInterfaceType(IDecl); 219 } 220 221 if (T.isNull()) { 222 // If it's not plausibly a type, suppress diagnostics. 223 Result.suppressDiagnostics(); 224 return ParsedType(); 225 } 226 return ParsedType::make(T); 227} 228 229/// isTagName() - This method is called *for error recovery purposes only* 230/// to determine if the specified name is a valid tag name ("struct foo"). If 231/// so, this returns the TST for the tag corresponding to it (TST_enum, 232/// TST_union, TST_struct, TST_class). This is used to diagnose cases in C 233/// where the user forgot to specify the tag. 234DeclSpec::TST Sema::isTagName(IdentifierInfo &II, Scope *S) { 235 // Do a tag name lookup in this scope. 236 LookupResult R(*this, &II, SourceLocation(), LookupTagName); 237 LookupName(R, S, false); 238 R.suppressDiagnostics(); 239 if (R.getResultKind() == LookupResult::Found) 240 if (const TagDecl *TD = R.getAsSingle<TagDecl>()) { 241 switch (TD->getTagKind()) { 242 default: return DeclSpec::TST_unspecified; 243 case TTK_Struct: return DeclSpec::TST_struct; 244 case TTK_Union: return DeclSpec::TST_union; 245 case TTK_Class: return DeclSpec::TST_class; 246 case TTK_Enum: return DeclSpec::TST_enum; 247 } 248 } 249 250 return DeclSpec::TST_unspecified; 251} 252 253/// isMicrosoftMissingTypename - In Microsoft mode, within class scope, 254/// if a CXXScopeSpec's type is equal to the type of one of the base classes 255/// then downgrade the missing typename error to a warning. 256/// This is needed for MSVC compatibility; Example: 257/// @code 258/// template<class T> class A { 259/// public: 260/// typedef int TYPE; 261/// }; 262/// template<class T> class B : public A<T> { 263/// public: 264/// A<T>::TYPE a; // no typename required because A<T> is a base class. 265/// }; 266/// @endcode 267bool Sema::isMicrosoftMissingTypename(const CXXScopeSpec *SS) { 268 if (CurContext->isRecord()) { 269 const Type *Ty = SS->getScopeRep()->getAsType(); 270 271 CXXRecordDecl *RD = cast<CXXRecordDecl>(CurContext); 272 for (CXXRecordDecl::base_class_const_iterator Base = RD->bases_begin(), 273 BaseEnd = RD->bases_end(); Base != BaseEnd; ++Base) 274 if (Context.hasSameUnqualifiedType(QualType(Ty, 1), Base->getType())) 275 return true; 276 } 277 return false; 278} 279 280bool Sema::DiagnoseUnknownTypeName(const IdentifierInfo &II, 281 SourceLocation IILoc, 282 Scope *S, 283 CXXScopeSpec *SS, 284 ParsedType &SuggestedType) { 285 // We don't have anything to suggest (yet). 286 SuggestedType = ParsedType(); 287 288 // There may have been a typo in the name of the type. Look up typo 289 // results, in case we have something that we can suggest. 290 LookupResult Lookup(*this, &II, IILoc, LookupOrdinaryName, 291 NotForRedeclaration); 292 293 if (DeclarationName Corrected = CorrectTypo(Lookup, S, SS, 0, 0, CTC_Type)) { 294 if (NamedDecl *Result = Lookup.getAsSingle<NamedDecl>()) { 295 if ((isa<TypeDecl>(Result) || isa<ObjCInterfaceDecl>(Result)) && 296 !Result->isInvalidDecl()) { 297 // We found a similarly-named type or interface; suggest that. 298 if (!SS || !SS->isSet()) 299 Diag(IILoc, diag::err_unknown_typename_suggest) 300 << &II << Lookup.getLookupName() 301 << FixItHint::CreateReplacement(SourceRange(IILoc), 302 Result->getNameAsString()); 303 else if (DeclContext *DC = computeDeclContext(*SS, false)) 304 Diag(IILoc, diag::err_unknown_nested_typename_suggest) 305 << &II << DC << Lookup.getLookupName() << SS->getRange() 306 << FixItHint::CreateReplacement(SourceRange(IILoc), 307 Result->getNameAsString()); 308 else 309 llvm_unreachable("could not have corrected a typo here"); 310 311 Diag(Result->getLocation(), diag::note_previous_decl) 312 << Result->getDeclName(); 313 314 SuggestedType = getTypeName(*Result->getIdentifier(), IILoc, S, SS, 315 false, false, ParsedType(), 316 /*NonTrivialTypeSourceInfo=*/true); 317 return true; 318 } 319 } else if (Lookup.empty()) { 320 // We corrected to a keyword. 321 // FIXME: Actually recover with the keyword we suggest, and emit a fix-it. 322 Diag(IILoc, diag::err_unknown_typename_suggest) 323 << &II << Corrected; 324 return true; 325 } 326 } 327 328 if (getLangOptions().CPlusPlus) { 329 // See if II is a class template that the user forgot to pass arguments to. 330 UnqualifiedId Name; 331 Name.setIdentifier(&II, IILoc); 332 CXXScopeSpec EmptySS; 333 TemplateTy TemplateResult; 334 bool MemberOfUnknownSpecialization; 335 if (isTemplateName(S, SS ? *SS : EmptySS, /*hasTemplateKeyword=*/false, 336 Name, ParsedType(), true, TemplateResult, 337 MemberOfUnknownSpecialization) == TNK_Type_template) { 338 TemplateName TplName = TemplateResult.getAsVal<TemplateName>(); 339 Diag(IILoc, diag::err_template_missing_args) << TplName; 340 if (TemplateDecl *TplDecl = TplName.getAsTemplateDecl()) { 341 Diag(TplDecl->getLocation(), diag::note_template_decl_here) 342 << TplDecl->getTemplateParameters()->getSourceRange(); 343 } 344 return true; 345 } 346 } 347 348 // FIXME: Should we move the logic that tries to recover from a missing tag 349 // (struct, union, enum) from Parser::ParseImplicitInt here, instead? 350 351 if (!SS || (!SS->isSet() && !SS->isInvalid())) 352 Diag(IILoc, diag::err_unknown_typename) << &II; 353 else if (DeclContext *DC = computeDeclContext(*SS, false)) 354 Diag(IILoc, diag::err_typename_nested_not_found) 355 << &II << DC << SS->getRange(); 356 else if (isDependentScopeSpecifier(*SS)) { 357 unsigned DiagID = diag::err_typename_missing; 358 if (getLangOptions().Microsoft && isMicrosoftMissingTypename(SS)) 359 DiagID = diag::war_typename_missing; 360 361 Diag(SS->getRange().getBegin(), DiagID) 362 << (NestedNameSpecifier *)SS->getScopeRep() << II.getName() 363 << SourceRange(SS->getRange().getBegin(), IILoc) 364 << FixItHint::CreateInsertion(SS->getRange().getBegin(), "typename "); 365 SuggestedType = ActOnTypenameType(S, SourceLocation(), *SS, II, IILoc).get(); 366 } else { 367 assert(SS && SS->isInvalid() && 368 "Invalid scope specifier has already been diagnosed"); 369 } 370 371 return true; 372} 373 374// Determines the context to return to after temporarily entering a 375// context. This depends in an unnecessarily complicated way on the 376// exact ordering of callbacks from the parser. 377DeclContext *Sema::getContainingDC(DeclContext *DC) { 378 379 // Functions defined inline within classes aren't parsed until we've 380 // finished parsing the top-level class, so the top-level class is 381 // the context we'll need to return to. 382 if (isa<FunctionDecl>(DC)) { 383 DC = DC->getLexicalParent(); 384 385 // A function not defined within a class will always return to its 386 // lexical context. 387 if (!isa<CXXRecordDecl>(DC)) 388 return DC; 389 390 // A C++ inline method/friend is parsed *after* the topmost class 391 // it was declared in is fully parsed ("complete"); the topmost 392 // class is the context we need to return to. 393 while (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(DC->getLexicalParent())) 394 DC = RD; 395 396 // Return the declaration context of the topmost class the inline method is 397 // declared in. 398 return DC; 399 } 400 401 // ObjCMethodDecls are parsed (for some reason) outside the context 402 // of the class. 403 if (isa<ObjCMethodDecl>(DC)) 404 return DC->getLexicalParent()->getLexicalParent(); 405 406 return DC->getLexicalParent(); 407} 408 409void Sema::PushDeclContext(Scope *S, DeclContext *DC) { 410 assert(getContainingDC(DC) == CurContext && 411 "The next DeclContext should be lexically contained in the current one."); 412 CurContext = DC; 413 S->setEntity(DC); 414} 415 416void Sema::PopDeclContext() { 417 assert(CurContext && "DeclContext imbalance!"); 418 419 CurContext = getContainingDC(CurContext); 420 assert(CurContext && "Popped translation unit!"); 421} 422 423/// EnterDeclaratorContext - Used when we must lookup names in the context 424/// of a declarator's nested name specifier. 425/// 426void Sema::EnterDeclaratorContext(Scope *S, DeclContext *DC) { 427 // C++0x [basic.lookup.unqual]p13: 428 // A name used in the definition of a static data member of class 429 // X (after the qualified-id of the static member) is looked up as 430 // if the name was used in a member function of X. 431 // C++0x [basic.lookup.unqual]p14: 432 // If a variable member of a namespace is defined outside of the 433 // scope of its namespace then any name used in the definition of 434 // the variable member (after the declarator-id) is looked up as 435 // if the definition of the variable member occurred in its 436 // namespace. 437 // Both of these imply that we should push a scope whose context 438 // is the semantic context of the declaration. We can't use 439 // PushDeclContext here because that context is not necessarily 440 // lexically contained in the current context. Fortunately, 441 // the containing scope should have the appropriate information. 442 443 assert(!S->getEntity() && "scope already has entity"); 444 445#ifndef NDEBUG 446 Scope *Ancestor = S->getParent(); 447 while (!Ancestor->getEntity()) Ancestor = Ancestor->getParent(); 448 assert(Ancestor->getEntity() == CurContext && "ancestor context mismatch"); 449#endif 450 451 CurContext = DC; 452 S->setEntity(DC); 453} 454 455void Sema::ExitDeclaratorContext(Scope *S) { 456 assert(S->getEntity() == CurContext && "Context imbalance!"); 457 458 // Switch back to the lexical context. The safety of this is 459 // enforced by an assert in EnterDeclaratorContext. 460 Scope *Ancestor = S->getParent(); 461 while (!Ancestor->getEntity()) Ancestor = Ancestor->getParent(); 462 CurContext = (DeclContext*) Ancestor->getEntity(); 463 464 // We don't need to do anything with the scope, which is going to 465 // disappear. 466} 467 468/// \brief Determine whether we allow overloading of the function 469/// PrevDecl with another declaration. 470/// 471/// This routine determines whether overloading is possible, not 472/// whether some new function is actually an overload. It will return 473/// true in C++ (where we can always provide overloads) or, as an 474/// extension, in C when the previous function is already an 475/// overloaded function declaration or has the "overloadable" 476/// attribute. 477static bool AllowOverloadingOfFunction(LookupResult &Previous, 478 ASTContext &Context) { 479 if (Context.getLangOptions().CPlusPlus) 480 return true; 481 482 if (Previous.getResultKind() == LookupResult::FoundOverloaded) 483 return true; 484 485 return (Previous.getResultKind() == LookupResult::Found 486 && Previous.getFoundDecl()->hasAttr<OverloadableAttr>()); 487} 488 489/// Add this decl to the scope shadowed decl chains. 490void Sema::PushOnScopeChains(NamedDecl *D, Scope *S, bool AddToContext) { 491 // Move up the scope chain until we find the nearest enclosing 492 // non-transparent context. The declaration will be introduced into this 493 // scope. 494 while (S->getEntity() && 495 ((DeclContext *)S->getEntity())->isTransparentContext()) 496 S = S->getParent(); 497 498 // Add scoped declarations into their context, so that they can be 499 // found later. Declarations without a context won't be inserted 500 // into any context. 501 if (AddToContext) 502 CurContext->addDecl(D); 503 504 // Out-of-line definitions shouldn't be pushed into scope in C++. 505 // Out-of-line variable and function definitions shouldn't even in C. 506 if ((getLangOptions().CPlusPlus || isa<VarDecl>(D) || isa<FunctionDecl>(D)) && 507 D->isOutOfLine()) 508 return; 509 510 // Template instantiations should also not be pushed into scope. 511 if (isa<FunctionDecl>(D) && 512 cast<FunctionDecl>(D)->isFunctionTemplateSpecialization()) 513 return; 514 515 // If this replaces anything in the current scope, 516 IdentifierResolver::iterator I = IdResolver.begin(D->getDeclName()), 517 IEnd = IdResolver.end(); 518 for (; I != IEnd; ++I) { 519 if (S->isDeclScope(*I) && D->declarationReplaces(*I)) { 520 S->RemoveDecl(*I); 521 IdResolver.RemoveDecl(*I); 522 523 // Should only need to replace one decl. 524 break; 525 } 526 } 527 528 S->AddDecl(D); 529 530 if (isa<LabelDecl>(D) && !cast<LabelDecl>(D)->isGnuLocal()) { 531 // Implicitly-generated labels may end up getting generated in an order that 532 // isn't strictly lexical, which breaks name lookup. Be careful to insert 533 // the label at the appropriate place in the identifier chain. 534 for (I = IdResolver.begin(D->getDeclName()); I != IEnd; ++I) { 535 DeclContext *IDC = (*I)->getLexicalDeclContext()->getRedeclContext(); 536 if (IDC == CurContext) { 537 if (!S->isDeclScope(*I)) 538 continue; 539 } else if (IDC->Encloses(CurContext)) 540 break; 541 } 542 543 IdResolver.InsertDeclAfter(I, D); 544 } else { 545 IdResolver.AddDecl(D); 546 } 547} 548 549bool Sema::isDeclInScope(NamedDecl *&D, DeclContext *Ctx, Scope *S, 550 bool ExplicitInstantiationOrSpecialization) { 551 return IdResolver.isDeclInScope(D, Ctx, Context, S, 552 ExplicitInstantiationOrSpecialization); 553} 554 555Scope *Sema::getScopeForDeclContext(Scope *S, DeclContext *DC) { 556 DeclContext *TargetDC = DC->getPrimaryContext(); 557 do { 558 if (DeclContext *ScopeDC = (DeclContext*) S->getEntity()) 559 if (ScopeDC->getPrimaryContext() == TargetDC) 560 return S; 561 } while ((S = S->getParent())); 562 563 return 0; 564} 565 566static bool isOutOfScopePreviousDeclaration(NamedDecl *, 567 DeclContext*, 568 ASTContext&); 569 570/// Filters out lookup results that don't fall within the given scope 571/// as determined by isDeclInScope. 572static void FilterLookupForScope(Sema &SemaRef, LookupResult &R, 573 DeclContext *Ctx, Scope *S, 574 bool ConsiderLinkage, 575 bool ExplicitInstantiationOrSpecialization) { 576 LookupResult::Filter F = R.makeFilter(); 577 while (F.hasNext()) { 578 NamedDecl *D = F.next(); 579 580 if (SemaRef.isDeclInScope(D, Ctx, S, ExplicitInstantiationOrSpecialization)) 581 continue; 582 583 if (ConsiderLinkage && 584 isOutOfScopePreviousDeclaration(D, Ctx, SemaRef.Context)) 585 continue; 586 587 F.erase(); 588 } 589 590 F.done(); 591} 592 593static bool isUsingDecl(NamedDecl *D) { 594 return isa<UsingShadowDecl>(D) || 595 isa<UnresolvedUsingTypenameDecl>(D) || 596 isa<UnresolvedUsingValueDecl>(D); 597} 598 599/// Removes using shadow declarations from the lookup results. 600static void RemoveUsingDecls(LookupResult &R) { 601 LookupResult::Filter F = R.makeFilter(); 602 while (F.hasNext()) 603 if (isUsingDecl(F.next())) 604 F.erase(); 605 606 F.done(); 607} 608 609/// \brief Check for this common pattern: 610/// @code 611/// class S { 612/// S(const S&); // DO NOT IMPLEMENT 613/// void operator=(const S&); // DO NOT IMPLEMENT 614/// }; 615/// @endcode 616static bool IsDisallowedCopyOrAssign(const CXXMethodDecl *D) { 617 // FIXME: Should check for private access too but access is set after we get 618 // the decl here. 619 if (D->isThisDeclarationADefinition()) 620 return false; 621 622 if (const CXXConstructorDecl *CD = dyn_cast<CXXConstructorDecl>(D)) 623 return CD->isCopyConstructor(); 624 if (const CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D)) 625 return Method->isCopyAssignmentOperator(); 626 return false; 627} 628 629bool Sema::ShouldWarnIfUnusedFileScopedDecl(const DeclaratorDecl *D) const { 630 assert(D); 631 632 if (D->isInvalidDecl() || D->isUsed() || D->hasAttr<UnusedAttr>()) 633 return false; 634 635 // Ignore class templates. 636 if (D->getDeclContext()->isDependentContext() || 637 D->getLexicalDeclContext()->isDependentContext()) 638 return false; 639 640 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) { 641 if (FD->getTemplateSpecializationKind() == TSK_ImplicitInstantiation) 642 return false; 643 644 if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) { 645 if (MD->isVirtual() || IsDisallowedCopyOrAssign(MD)) 646 return false; 647 } else { 648 // 'static inline' functions are used in headers; don't warn. 649 if (FD->getStorageClass() == SC_Static && 650 FD->isInlineSpecified()) 651 return false; 652 } 653 654 if (FD->isThisDeclarationADefinition() && 655 Context.DeclMustBeEmitted(FD)) 656 return false; 657 658 } else if (const VarDecl *VD = dyn_cast<VarDecl>(D)) { 659 if (!VD->isFileVarDecl() || 660 VD->getType().isConstant(Context) || 661 Context.DeclMustBeEmitted(VD)) 662 return false; 663 664 if (VD->isStaticDataMember() && 665 VD->getTemplateSpecializationKind() == TSK_ImplicitInstantiation) 666 return false; 667 668 } else { 669 return false; 670 } 671 672 // Only warn for unused decls internal to the translation unit. 673 if (D->getLinkage() == ExternalLinkage) 674 return false; 675 676 return true; 677} 678 679void Sema::MarkUnusedFileScopedDecl(const DeclaratorDecl *D) { 680 if (!D) 681 return; 682 683 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) { 684 const FunctionDecl *First = FD->getFirstDeclaration(); 685 if (FD != First && ShouldWarnIfUnusedFileScopedDecl(First)) 686 return; // First should already be in the vector. 687 } 688 689 if (const VarDecl *VD = dyn_cast<VarDecl>(D)) { 690 const VarDecl *First = VD->getFirstDeclaration(); 691 if (VD != First && ShouldWarnIfUnusedFileScopedDecl(First)) 692 return; // First should already be in the vector. 693 } 694 695 if (ShouldWarnIfUnusedFileScopedDecl(D)) 696 UnusedFileScopedDecls.push_back(D); 697 } 698 699static bool ShouldDiagnoseUnusedDecl(const NamedDecl *D) { 700 if (D->isInvalidDecl()) 701 return false; 702 703 if (D->isUsed() || D->hasAttr<UnusedAttr>()) 704 return false; 705 706 if (isa<LabelDecl>(D)) 707 return true; 708 709 // White-list anything that isn't a local variable. 710 if (!isa<VarDecl>(D) || isa<ParmVarDecl>(D) || isa<ImplicitParamDecl>(D) || 711 !D->getDeclContext()->isFunctionOrMethod()) 712 return false; 713 714 // Types of valid local variables should be complete, so this should succeed. 715 if (const ValueDecl *VD = dyn_cast<ValueDecl>(D)) { 716 717 // White-list anything with an __attribute__((unused)) type. 718 QualType Ty = VD->getType(); 719 720 // Only look at the outermost level of typedef. 721 if (const TypedefType *TT = dyn_cast<TypedefType>(Ty)) { 722 if (TT->getDecl()->hasAttr<UnusedAttr>()) 723 return false; 724 } 725 726 // If we failed to complete the type for some reason, or if the type is 727 // dependent, don't diagnose the variable. 728 if (Ty->isIncompleteType() || Ty->isDependentType()) 729 return false; 730 731 if (const TagType *TT = Ty->getAs<TagType>()) { 732 const TagDecl *Tag = TT->getDecl(); 733 if (Tag->hasAttr<UnusedAttr>()) 734 return false; 735 736 if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(Tag)) { 737 // FIXME: Checking for the presence of a user-declared constructor 738 // isn't completely accurate; we'd prefer to check that the initializer 739 // has no side effects. 740 if (RD->hasUserDeclaredConstructor() || !RD->hasTrivialDestructor()) 741 return false; 742 } 743 } 744 745 // TODO: __attribute__((unused)) templates? 746 } 747 748 return true; 749} 750 751/// DiagnoseUnusedDecl - Emit warnings about declarations that are not used 752/// unless they are marked attr(unused). 753void Sema::DiagnoseUnusedDecl(const NamedDecl *D) { 754 if (!ShouldDiagnoseUnusedDecl(D)) 755 return; 756 757 unsigned DiagID; 758 if (isa<VarDecl>(D) && cast<VarDecl>(D)->isExceptionVariable()) 759 DiagID = diag::warn_unused_exception_param; 760 else if (isa<LabelDecl>(D)) 761 DiagID = diag::warn_unused_label; 762 else 763 DiagID = diag::warn_unused_variable; 764 765 Diag(D->getLocation(), DiagID) << D->getDeclName(); 766} 767 768static void CheckPoppedLabel(LabelDecl *L, Sema &S) { 769 // Verify that we have no forward references left. If so, there was a goto 770 // or address of a label taken, but no definition of it. Label fwd 771 // definitions are indicated with a null substmt. 772 if (L->getStmt() == 0) 773 S.Diag(L->getLocation(), diag::err_undeclared_label_use) <<L->getDeclName(); 774} 775 776void Sema::ActOnPopScope(SourceLocation Loc, Scope *S) { 777 if (S->decl_empty()) return; 778 assert((S->getFlags() & (Scope::DeclScope | Scope::TemplateParamScope)) && 779 "Scope shouldn't contain decls!"); 780 781 for (Scope::decl_iterator I = S->decl_begin(), E = S->decl_end(); 782 I != E; ++I) { 783 Decl *TmpD = (*I); 784 assert(TmpD && "This decl didn't get pushed??"); 785 786 assert(isa<NamedDecl>(TmpD) && "Decl isn't NamedDecl?"); 787 NamedDecl *D = cast<NamedDecl>(TmpD); 788 789 if (!D->getDeclName()) continue; 790 791 // Diagnose unused variables in this scope. 792 if (!S->hasErrorOccurred()) 793 DiagnoseUnusedDecl(D); 794 795 // If this was a forward reference to a label, verify it was defined. 796 if (LabelDecl *LD = dyn_cast<LabelDecl>(D)) 797 CheckPoppedLabel(LD, *this); 798 799 // Remove this name from our lexical scope. 800 IdResolver.RemoveDecl(D); 801 } 802} 803 804/// \brief Look for an Objective-C class in the translation unit. 805/// 806/// \param Id The name of the Objective-C class we're looking for. If 807/// typo-correction fixes this name, the Id will be updated 808/// to the fixed name. 809/// 810/// \param IdLoc The location of the name in the translation unit. 811/// 812/// \param TypoCorrection If true, this routine will attempt typo correction 813/// if there is no class with the given name. 814/// 815/// \returns The declaration of the named Objective-C class, or NULL if the 816/// class could not be found. 817ObjCInterfaceDecl *Sema::getObjCInterfaceDecl(IdentifierInfo *&Id, 818 SourceLocation IdLoc, 819 bool TypoCorrection) { 820 // The third "scope" argument is 0 since we aren't enabling lazy built-in 821 // creation from this context. 822 NamedDecl *IDecl = LookupSingleName(TUScope, Id, IdLoc, LookupOrdinaryName); 823 824 if (!IDecl && TypoCorrection) { 825 // Perform typo correction at the given location, but only if we 826 // find an Objective-C class name. 827 LookupResult R(*this, Id, IdLoc, LookupOrdinaryName); 828 if (CorrectTypo(R, TUScope, 0, 0, false, CTC_NoKeywords) && 829 (IDecl = R.getAsSingle<ObjCInterfaceDecl>())) { 830 Diag(IdLoc, diag::err_undef_interface_suggest) 831 << Id << IDecl->getDeclName() 832 << FixItHint::CreateReplacement(IdLoc, IDecl->getNameAsString()); 833 Diag(IDecl->getLocation(), diag::note_previous_decl) 834 << IDecl->getDeclName(); 835 836 Id = IDecl->getIdentifier(); 837 } 838 } 839 840 return dyn_cast_or_null<ObjCInterfaceDecl>(IDecl); 841} 842 843/// getNonFieldDeclScope - Retrieves the innermost scope, starting 844/// from S, where a non-field would be declared. This routine copes 845/// with the difference between C and C++ scoping rules in structs and 846/// unions. For example, the following code is well-formed in C but 847/// ill-formed in C++: 848/// @code 849/// struct S6 { 850/// enum { BAR } e; 851/// }; 852/// 853/// void test_S6() { 854/// struct S6 a; 855/// a.e = BAR; 856/// } 857/// @endcode 858/// For the declaration of BAR, this routine will return a different 859/// scope. The scope S will be the scope of the unnamed enumeration 860/// within S6. In C++, this routine will return the scope associated 861/// with S6, because the enumeration's scope is a transparent 862/// context but structures can contain non-field names. In C, this 863/// routine will return the translation unit scope, since the 864/// enumeration's scope is a transparent context and structures cannot 865/// contain non-field names. 866Scope *Sema::getNonFieldDeclScope(Scope *S) { 867 while (((S->getFlags() & Scope::DeclScope) == 0) || 868 (S->getEntity() && 869 ((DeclContext *)S->getEntity())->isTransparentContext()) || 870 (S->isClassScope() && !getLangOptions().CPlusPlus)) 871 S = S->getParent(); 872 return S; 873} 874 875/// LazilyCreateBuiltin - The specified Builtin-ID was first used at 876/// file scope. lazily create a decl for it. ForRedeclaration is true 877/// if we're creating this built-in in anticipation of redeclaring the 878/// built-in. 879NamedDecl *Sema::LazilyCreateBuiltin(IdentifierInfo *II, unsigned bid, 880 Scope *S, bool ForRedeclaration, 881 SourceLocation Loc) { 882 Builtin::ID BID = (Builtin::ID)bid; 883 884 ASTContext::GetBuiltinTypeError Error; 885 QualType R = Context.GetBuiltinType(BID, Error); 886 switch (Error) { 887 case ASTContext::GE_None: 888 // Okay 889 break; 890 891 case ASTContext::GE_Missing_stdio: 892 if (ForRedeclaration) 893 Diag(Loc, diag::warn_implicit_decl_requires_stdio) 894 << Context.BuiltinInfo.GetName(BID); 895 return 0; 896 897 case ASTContext::GE_Missing_setjmp: 898 if (ForRedeclaration) 899 Diag(Loc, diag::warn_implicit_decl_requires_setjmp) 900 << Context.BuiltinInfo.GetName(BID); 901 return 0; 902 } 903 904 if (!ForRedeclaration && Context.BuiltinInfo.isPredefinedLibFunction(BID)) { 905 Diag(Loc, diag::ext_implicit_lib_function_decl) 906 << Context.BuiltinInfo.GetName(BID) 907 << R; 908 if (Context.BuiltinInfo.getHeaderName(BID) && 909 Diags.getDiagnosticLevel(diag::ext_implicit_lib_function_decl, Loc) 910 != Diagnostic::Ignored) 911 Diag(Loc, diag::note_please_include_header) 912 << Context.BuiltinInfo.getHeaderName(BID) 913 << Context.BuiltinInfo.GetName(BID); 914 } 915 916 FunctionDecl *New = FunctionDecl::Create(Context, 917 Context.getTranslationUnitDecl(), 918 Loc, Loc, II, R, /*TInfo=*/0, 919 SC_Extern, 920 SC_None, false, 921 /*hasPrototype=*/true); 922 New->setImplicit(); 923 924 // Create Decl objects for each parameter, adding them to the 925 // FunctionDecl. 926 if (const FunctionProtoType *FT = dyn_cast<FunctionProtoType>(R)) { 927 llvm::SmallVector<ParmVarDecl*, 16> Params; 928 for (unsigned i = 0, e = FT->getNumArgs(); i != e; ++i) 929 Params.push_back(ParmVarDecl::Create(Context, New, SourceLocation(), 930 SourceLocation(), 0, 931 FT->getArgType(i), /*TInfo=*/0, 932 SC_None, SC_None, 0)); 933 New->setParams(Params.data(), Params.size()); 934 } 935 936 AddKnownFunctionAttributes(New); 937 938 // TUScope is the translation-unit scope to insert this function into. 939 // FIXME: This is hideous. We need to teach PushOnScopeChains to 940 // relate Scopes to DeclContexts, and probably eliminate CurContext 941 // entirely, but we're not there yet. 942 DeclContext *SavedContext = CurContext; 943 CurContext = Context.getTranslationUnitDecl(); 944 PushOnScopeChains(New, TUScope); 945 CurContext = SavedContext; 946 return New; 947} 948 949/// MergeTypedefNameDecl - We just parsed a typedef 'New' which has the 950/// same name and scope as a previous declaration 'Old'. Figure out 951/// how to resolve this situation, merging decls or emitting 952/// diagnostics as appropriate. If there was an error, set New to be invalid. 953/// 954void Sema::MergeTypedefNameDecl(TypedefNameDecl *New, LookupResult &OldDecls) { 955 // If the new decl is known invalid already, don't bother doing any 956 // merging checks. 957 if (New->isInvalidDecl()) return; 958 959 // Allow multiple definitions for ObjC built-in typedefs. 960 // FIXME: Verify the underlying types are equivalent! 961 if (getLangOptions().ObjC1) { 962 const IdentifierInfo *TypeID = New->getIdentifier(); 963 switch (TypeID->getLength()) { 964 default: break; 965 case 2: 966 if (!TypeID->isStr("id")) 967 break; 968 Context.ObjCIdRedefinitionType = New->getUnderlyingType(); 969 // Install the built-in type for 'id', ignoring the current definition. 970 New->setTypeForDecl(Context.getObjCIdType().getTypePtr()); 971 return; 972 case 5: 973 if (!TypeID->isStr("Class")) 974 break; 975 Context.ObjCClassRedefinitionType = New->getUnderlyingType(); 976 // Install the built-in type for 'Class', ignoring the current definition. 977 New->setTypeForDecl(Context.getObjCClassType().getTypePtr()); 978 return; 979 case 3: 980 if (!TypeID->isStr("SEL")) 981 break; 982 Context.ObjCSelRedefinitionType = New->getUnderlyingType(); 983 // Install the built-in type for 'SEL', ignoring the current definition. 984 New->setTypeForDecl(Context.getObjCSelType().getTypePtr()); 985 return; 986 case 8: 987 if (!TypeID->isStr("Protocol")) 988 break; 989 Context.setObjCProtoType(New->getUnderlyingType()); 990 return; 991 } 992 // Fall through - the typedef name was not a builtin type. 993 } 994 995 // Verify the old decl was also a type. 996 TypeDecl *Old = OldDecls.getAsSingle<TypeDecl>(); 997 if (!Old) { 998 Diag(New->getLocation(), diag::err_redefinition_different_kind) 999 << New->getDeclName(); 1000 1001 NamedDecl *OldD = OldDecls.getRepresentativeDecl(); 1002 if (OldD->getLocation().isValid()) 1003 Diag(OldD->getLocation(), diag::note_previous_definition); 1004 1005 return New->setInvalidDecl(); 1006 } 1007 1008 // If the old declaration is invalid, just give up here. 1009 if (Old->isInvalidDecl()) 1010 return New->setInvalidDecl(); 1011 1012 // Determine the "old" type we'll use for checking and diagnostics. 1013 QualType OldType; 1014 if (TypedefNameDecl *OldTypedef = dyn_cast<TypedefNameDecl>(Old)) 1015 OldType = OldTypedef->getUnderlyingType(); 1016 else 1017 OldType = Context.getTypeDeclType(Old); 1018 1019 // If the typedef types are not identical, reject them in all languages and 1020 // with any extensions enabled. 1021 1022 if (OldType != New->getUnderlyingType() && 1023 Context.getCanonicalType(OldType) != 1024 Context.getCanonicalType(New->getUnderlyingType())) { 1025 int Kind = 0; 1026 if (isa<TypeAliasDecl>(Old)) 1027 Kind = 1; 1028 Diag(New->getLocation(), diag::err_redefinition_different_typedef) 1029 << Kind << New->getUnderlyingType() << OldType; 1030 if (Old->getLocation().isValid()) 1031 Diag(Old->getLocation(), diag::note_previous_definition); 1032 return New->setInvalidDecl(); 1033 } 1034 1035 // The types match. Link up the redeclaration chain if the old 1036 // declaration was a typedef. 1037 // FIXME: this is a potential source of wierdness if the type 1038 // spellings don't match exactly. 1039 if (TypedefNameDecl *Typedef = dyn_cast<TypedefNameDecl>(Old)) 1040 New->setPreviousDeclaration(Typedef); 1041 1042 if (getLangOptions().Microsoft) 1043 return; 1044 1045 if (getLangOptions().CPlusPlus) { 1046 // C++ [dcl.typedef]p2: 1047 // In a given non-class scope, a typedef specifier can be used to 1048 // redefine the name of any type declared in that scope to refer 1049 // to the type to which it already refers. 1050 if (!isa<CXXRecordDecl>(CurContext)) 1051 return; 1052 1053 // C++0x [dcl.typedef]p4: 1054 // In a given class scope, a typedef specifier can be used to redefine 1055 // any class-name declared in that scope that is not also a typedef-name 1056 // to refer to the type to which it already refers. 1057 // 1058 // This wording came in via DR424, which was a correction to the 1059 // wording in DR56, which accidentally banned code like: 1060 // 1061 // struct S { 1062 // typedef struct A { } A; 1063 // }; 1064 // 1065 // in the C++03 standard. We implement the C++0x semantics, which 1066 // allow the above but disallow 1067 // 1068 // struct S { 1069 // typedef int I; 1070 // typedef int I; 1071 // }; 1072 // 1073 // since that was the intent of DR56. 1074 if (!isa<TypedefNameDecl>(Old)) 1075 return; 1076 1077 Diag(New->getLocation(), diag::err_redefinition) 1078 << New->getDeclName(); 1079 Diag(Old->getLocation(), diag::note_previous_definition); 1080 return New->setInvalidDecl(); 1081 } 1082 1083 // If we have a redefinition of a typedef in C, emit a warning. This warning 1084 // is normally mapped to an error, but can be controlled with 1085 // -Wtypedef-redefinition. If either the original or the redefinition is 1086 // in a system header, don't emit this for compatibility with GCC. 1087 if (getDiagnostics().getSuppressSystemWarnings() && 1088 (Context.getSourceManager().isInSystemHeader(Old->getLocation()) || 1089 Context.getSourceManager().isInSystemHeader(New->getLocation()))) 1090 return; 1091 1092 Diag(New->getLocation(), diag::warn_redefinition_of_typedef) 1093 << New->getDeclName(); 1094 Diag(Old->getLocation(), diag::note_previous_definition); 1095 return; 1096} 1097 1098/// DeclhasAttr - returns true if decl Declaration already has the target 1099/// attribute. 1100static bool 1101DeclHasAttr(const Decl *D, const Attr *A) { 1102 const OwnershipAttr *OA = dyn_cast<OwnershipAttr>(A); 1103 for (Decl::attr_iterator i = D->attr_begin(), e = D->attr_end(); i != e; ++i) 1104 if ((*i)->getKind() == A->getKind()) { 1105 // FIXME: Don't hardcode this check 1106 if (OA && isa<OwnershipAttr>(*i)) 1107 return OA->getOwnKind() == cast<OwnershipAttr>(*i)->getOwnKind(); 1108 return true; 1109 } 1110 1111 return false; 1112} 1113 1114/// mergeDeclAttributes - Copy attributes from the Old decl to the New one. 1115static void mergeDeclAttributes(Decl *newDecl, const Decl *oldDecl, 1116 ASTContext &C) { 1117 if (!oldDecl->hasAttrs()) 1118 return; 1119 1120 bool foundAny = newDecl->hasAttrs(); 1121 1122 // Ensure that any moving of objects within the allocated map is done before 1123 // we process them. 1124 if (!foundAny) newDecl->setAttrs(AttrVec()); 1125 1126 for (specific_attr_iterator<InheritableAttr> 1127 i = oldDecl->specific_attr_begin<InheritableAttr>(), 1128 e = oldDecl->specific_attr_end<InheritableAttr>(); i != e; ++i) { 1129 if (!DeclHasAttr(newDecl, *i)) { 1130 InheritableAttr *newAttr = cast<InheritableAttr>((*i)->clone(C)); 1131 newAttr->setInherited(true); 1132 newDecl->addAttr(newAttr); 1133 foundAny = true; 1134 } 1135 } 1136 1137 if (!foundAny) newDecl->dropAttrs(); 1138} 1139 1140/// mergeParamDeclAttributes - Copy attributes from the old parameter 1141/// to the new one. 1142static void mergeParamDeclAttributes(ParmVarDecl *newDecl, 1143 const ParmVarDecl *oldDecl, 1144 ASTContext &C) { 1145 if (!oldDecl->hasAttrs()) 1146 return; 1147 1148 bool foundAny = newDecl->hasAttrs(); 1149 1150 // Ensure that any moving of objects within the allocated map is 1151 // done before we process them. 1152 if (!foundAny) newDecl->setAttrs(AttrVec()); 1153 1154 for (specific_attr_iterator<InheritableParamAttr> 1155 i = oldDecl->specific_attr_begin<InheritableParamAttr>(), 1156 e = oldDecl->specific_attr_end<InheritableParamAttr>(); i != e; ++i) { 1157 if (!DeclHasAttr(newDecl, *i)) { 1158 InheritableAttr *newAttr = cast<InheritableParamAttr>((*i)->clone(C)); 1159 newAttr->setInherited(true); 1160 newDecl->addAttr(newAttr); 1161 foundAny = true; 1162 } 1163 } 1164 1165 if (!foundAny) newDecl->dropAttrs(); 1166} 1167 1168namespace { 1169 1170/// Used in MergeFunctionDecl to keep track of function parameters in 1171/// C. 1172struct GNUCompatibleParamWarning { 1173 ParmVarDecl *OldParm; 1174 ParmVarDecl *NewParm; 1175 QualType PromotedType; 1176}; 1177 1178} 1179 1180/// getSpecialMember - get the special member enum for a method. 1181Sema::CXXSpecialMember Sema::getSpecialMember(const CXXMethodDecl *MD) { 1182 if (const CXXConstructorDecl *Ctor = dyn_cast<CXXConstructorDecl>(MD)) { 1183 if (Ctor->isCopyConstructor()) 1184 return Sema::CXXCopyConstructor; 1185 1186 return Sema::CXXConstructor; 1187 } 1188 1189 if (isa<CXXDestructorDecl>(MD)) 1190 return Sema::CXXDestructor; 1191 1192 assert(MD->isCopyAssignmentOperator() && 1193 "Must have copy assignment operator"); 1194 return Sema::CXXCopyAssignment; 1195} 1196 1197/// canRedefineFunction - checks if a function can be redefined. Currently, 1198/// only extern inline functions can be redefined, and even then only in 1199/// GNU89 mode. 1200static bool canRedefineFunction(const FunctionDecl *FD, 1201 const LangOptions& LangOpts) { 1202 return (LangOpts.GNUMode && !LangOpts.C99 && !LangOpts.CPlusPlus && 1203 FD->isInlineSpecified() && 1204 FD->getStorageClass() == SC_Extern); 1205} 1206 1207/// MergeFunctionDecl - We just parsed a function 'New' from 1208/// declarator D which has the same name and scope as a previous 1209/// declaration 'Old'. Figure out how to resolve this situation, 1210/// merging decls or emitting diagnostics as appropriate. 1211/// 1212/// In C++, New and Old must be declarations that are not 1213/// overloaded. Use IsOverload to determine whether New and Old are 1214/// overloaded, and to select the Old declaration that New should be 1215/// merged with. 1216/// 1217/// Returns true if there was an error, false otherwise. 1218bool Sema::MergeFunctionDecl(FunctionDecl *New, Decl *OldD) { 1219 // Verify the old decl was also a function. 1220 FunctionDecl *Old = 0; 1221 if (FunctionTemplateDecl *OldFunctionTemplate 1222 = dyn_cast<FunctionTemplateDecl>(OldD)) 1223 Old = OldFunctionTemplate->getTemplatedDecl(); 1224 else 1225 Old = dyn_cast<FunctionDecl>(OldD); 1226 if (!Old) { 1227 if (UsingShadowDecl *Shadow = dyn_cast<UsingShadowDecl>(OldD)) { 1228 Diag(New->getLocation(), diag::err_using_decl_conflict_reverse); 1229 Diag(Shadow->getTargetDecl()->getLocation(), 1230 diag::note_using_decl_target); 1231 Diag(Shadow->getUsingDecl()->getLocation(), 1232 diag::note_using_decl) << 0; 1233 return true; 1234 } 1235 1236 Diag(New->getLocation(), diag::err_redefinition_different_kind) 1237 << New->getDeclName(); 1238 Diag(OldD->getLocation(), diag::note_previous_definition); 1239 return true; 1240 } 1241 1242 // Determine whether the previous declaration was a definition, 1243 // implicit declaration, or a declaration. 1244 diag::kind PrevDiag; 1245 if (Old->isThisDeclarationADefinition()) 1246 PrevDiag = diag::note_previous_definition; 1247 else if (Old->isImplicit()) 1248 PrevDiag = diag::note_previous_implicit_declaration; 1249 else 1250 PrevDiag = diag::note_previous_declaration; 1251 1252 QualType OldQType = Context.getCanonicalType(Old->getType()); 1253 QualType NewQType = Context.getCanonicalType(New->getType()); 1254 1255 // Don't complain about this if we're in GNU89 mode and the old function 1256 // is an extern inline function. 1257 if (!isa<CXXMethodDecl>(New) && !isa<CXXMethodDecl>(Old) && 1258 New->getStorageClass() == SC_Static && 1259 Old->getStorageClass() != SC_Static && 1260 !canRedefineFunction(Old, getLangOptions())) { 1261 Diag(New->getLocation(), diag::err_static_non_static) 1262 << New; 1263 Diag(Old->getLocation(), PrevDiag); 1264 return true; 1265 } 1266 1267 // If a function is first declared with a calling convention, but is 1268 // later declared or defined without one, the second decl assumes the 1269 // calling convention of the first. 1270 // 1271 // For the new decl, we have to look at the NON-canonical type to tell the 1272 // difference between a function that really doesn't have a calling 1273 // convention and one that is declared cdecl. That's because in 1274 // canonicalization (see ASTContext.cpp), cdecl is canonicalized away 1275 // because it is the default calling convention. 1276 // 1277 // Note also that we DO NOT return at this point, because we still have 1278 // other tests to run. 1279 const FunctionType *OldType = cast<FunctionType>(OldQType); 1280 const FunctionType *NewType = New->getType()->getAs<FunctionType>(); 1281 FunctionType::ExtInfo OldTypeInfo = OldType->getExtInfo(); 1282 FunctionType::ExtInfo NewTypeInfo = NewType->getExtInfo(); 1283 bool RequiresAdjustment = false; 1284 if (OldTypeInfo.getCC() != CC_Default && 1285 NewTypeInfo.getCC() == CC_Default) { 1286 NewTypeInfo = NewTypeInfo.withCallingConv(OldTypeInfo.getCC()); 1287 RequiresAdjustment = true; 1288 } else if (!Context.isSameCallConv(OldTypeInfo.getCC(), 1289 NewTypeInfo.getCC())) { 1290 // Calling conventions really aren't compatible, so complain. 1291 Diag(New->getLocation(), diag::err_cconv_change) 1292 << FunctionType::getNameForCallConv(NewTypeInfo.getCC()) 1293 << (OldTypeInfo.getCC() == CC_Default) 1294 << (OldTypeInfo.getCC() == CC_Default ? "" : 1295 FunctionType::getNameForCallConv(OldTypeInfo.getCC())); 1296 Diag(Old->getLocation(), diag::note_previous_declaration); 1297 return true; 1298 } 1299 1300 // FIXME: diagnose the other way around? 1301 if (OldTypeInfo.getNoReturn() && !NewTypeInfo.getNoReturn()) { 1302 NewTypeInfo = NewTypeInfo.withNoReturn(true); 1303 RequiresAdjustment = true; 1304 } 1305 1306 // Merge regparm attribute. 1307 if (OldTypeInfo.getHasRegParm() != NewTypeInfo.getHasRegParm() || 1308 OldTypeInfo.getRegParm() != NewTypeInfo.getRegParm()) { 1309 if (NewTypeInfo.getHasRegParm()) { 1310 Diag(New->getLocation(), diag::err_regparm_mismatch) 1311 << NewType->getRegParmType() 1312 << OldType->getRegParmType(); 1313 Diag(Old->getLocation(), diag::note_previous_declaration); 1314 return true; 1315 } 1316 1317 NewTypeInfo = NewTypeInfo.withRegParm(OldTypeInfo.getRegParm()); 1318 RequiresAdjustment = true; 1319 } 1320 1321 if (RequiresAdjustment) { 1322 NewType = Context.adjustFunctionType(NewType, NewTypeInfo); 1323 New->setType(QualType(NewType, 0)); 1324 NewQType = Context.getCanonicalType(New->getType()); 1325 } 1326 1327 if (getLangOptions().CPlusPlus) { 1328 // (C++98 13.1p2): 1329 // Certain function declarations cannot be overloaded: 1330 // -- Function declarations that differ only in the return type 1331 // cannot be overloaded. 1332 QualType OldReturnType = OldType->getResultType(); 1333 QualType NewReturnType = cast<FunctionType>(NewQType)->getResultType(); 1334 QualType ResQT; 1335 if (OldReturnType != NewReturnType) { 1336 if (NewReturnType->isObjCObjectPointerType() 1337 && OldReturnType->isObjCObjectPointerType()) 1338 ResQT = Context.mergeObjCGCQualifiers(NewQType, OldQType); 1339 if (ResQT.isNull()) { 1340 if (New->isCXXClassMember() && New->isOutOfLine()) 1341 Diag(New->getLocation(), 1342 diag::err_member_def_does_not_match_ret_type) << New; 1343 else 1344 Diag(New->getLocation(), diag::err_ovl_diff_return_type); 1345 Diag(Old->getLocation(), PrevDiag) << Old << Old->getType(); 1346 return true; 1347 } 1348 else 1349 NewQType = ResQT; 1350 } 1351 1352 const CXXMethodDecl* OldMethod = dyn_cast<CXXMethodDecl>(Old); 1353 CXXMethodDecl* NewMethod = dyn_cast<CXXMethodDecl>(New); 1354 if (OldMethod && NewMethod) { 1355 // Preserve triviality. 1356 NewMethod->setTrivial(OldMethod->isTrivial()); 1357 1358 bool isFriend = NewMethod->getFriendObjectKind(); 1359 1360 if (!isFriend && NewMethod->getLexicalDeclContext()->isRecord()) { 1361 // -- Member function declarations with the same name and the 1362 // same parameter types cannot be overloaded if any of them 1363 // is a static member function declaration. 1364 if (OldMethod->isStatic() || NewMethod->isStatic()) { 1365 Diag(New->getLocation(), diag::err_ovl_static_nonstatic_member); 1366 Diag(Old->getLocation(), PrevDiag) << Old << Old->getType(); 1367 return true; 1368 } 1369 1370 // C++ [class.mem]p1: 1371 // [...] A member shall not be declared twice in the 1372 // member-specification, except that a nested class or member 1373 // class template can be declared and then later defined. 1374 unsigned NewDiag; 1375 if (isa<CXXConstructorDecl>(OldMethod)) 1376 NewDiag = diag::err_constructor_redeclared; 1377 else if (isa<CXXDestructorDecl>(NewMethod)) 1378 NewDiag = diag::err_destructor_redeclared; 1379 else if (isa<CXXConversionDecl>(NewMethod)) 1380 NewDiag = diag::err_conv_function_redeclared; 1381 else 1382 NewDiag = diag::err_member_redeclared; 1383 1384 Diag(New->getLocation(), NewDiag); 1385 Diag(Old->getLocation(), PrevDiag) << Old << Old->getType(); 1386 1387 // Complain if this is an explicit declaration of a special 1388 // member that was initially declared implicitly. 1389 // 1390 // As an exception, it's okay to befriend such methods in order 1391 // to permit the implicit constructor/destructor/operator calls. 1392 } else if (OldMethod->isImplicit()) { 1393 if (isFriend) { 1394 NewMethod->setImplicit(); 1395 } else { 1396 Diag(NewMethod->getLocation(), 1397 diag::err_definition_of_implicitly_declared_member) 1398 << New << getSpecialMember(OldMethod); 1399 return true; 1400 } 1401 } 1402 } 1403 1404 // (C++98 8.3.5p3): 1405 // All declarations for a function shall agree exactly in both the 1406 // return type and the parameter-type-list. 1407 // We also want to respect all the extended bits except noreturn. 1408 1409 // noreturn should now match unless the old type info didn't have it. 1410 QualType OldQTypeForComparison = OldQType; 1411 if (!OldTypeInfo.getNoReturn() && NewTypeInfo.getNoReturn()) { 1412 assert(OldQType == QualType(OldType, 0)); 1413 const FunctionType *OldTypeForComparison 1414 = Context.adjustFunctionType(OldType, OldTypeInfo.withNoReturn(true)); 1415 OldQTypeForComparison = QualType(OldTypeForComparison, 0); 1416 assert(OldQTypeForComparison.isCanonical()); 1417 } 1418 1419 if (OldQTypeForComparison == NewQType) 1420 return MergeCompatibleFunctionDecls(New, Old); 1421 1422 // Fall through for conflicting redeclarations and redefinitions. 1423 } 1424 1425 // C: Function types need to be compatible, not identical. This handles 1426 // duplicate function decls like "void f(int); void f(enum X);" properly. 1427 if (!getLangOptions().CPlusPlus && 1428 Context.typesAreCompatible(OldQType, NewQType)) { 1429 const FunctionType *OldFuncType = OldQType->getAs<FunctionType>(); 1430 const FunctionType *NewFuncType = NewQType->getAs<FunctionType>(); 1431 const FunctionProtoType *OldProto = 0; 1432 if (isa<FunctionNoProtoType>(NewFuncType) && 1433 (OldProto = dyn_cast<FunctionProtoType>(OldFuncType))) { 1434 // The old declaration provided a function prototype, but the 1435 // new declaration does not. Merge in the prototype. 1436 assert(!OldProto->hasExceptionSpec() && "Exception spec in C"); 1437 llvm::SmallVector<QualType, 16> ParamTypes(OldProto->arg_type_begin(), 1438 OldProto->arg_type_end()); 1439 NewQType = Context.getFunctionType(NewFuncType->getResultType(), 1440 ParamTypes.data(), ParamTypes.size(), 1441 OldProto->getExtProtoInfo()); 1442 New->setType(NewQType); 1443 New->setHasInheritedPrototype(); 1444 1445 // Synthesize a parameter for each argument type. 1446 llvm::SmallVector<ParmVarDecl*, 16> Params; 1447 for (FunctionProtoType::arg_type_iterator 1448 ParamType = OldProto->arg_type_begin(), 1449 ParamEnd = OldProto->arg_type_end(); 1450 ParamType != ParamEnd; ++ParamType) { 1451 ParmVarDecl *Param = ParmVarDecl::Create(Context, New, 1452 SourceLocation(), 1453 SourceLocation(), 0, 1454 *ParamType, /*TInfo=*/0, 1455 SC_None, SC_None, 1456 0); 1457 Param->setImplicit(); 1458 Params.push_back(Param); 1459 } 1460 1461 New->setParams(Params.data(), Params.size()); 1462 } 1463 1464 return MergeCompatibleFunctionDecls(New, Old); 1465 } 1466 1467 // GNU C permits a K&R definition to follow a prototype declaration 1468 // if the declared types of the parameters in the K&R definition 1469 // match the types in the prototype declaration, even when the 1470 // promoted types of the parameters from the K&R definition differ 1471 // from the types in the prototype. GCC then keeps the types from 1472 // the prototype. 1473 // 1474 // If a variadic prototype is followed by a non-variadic K&R definition, 1475 // the K&R definition becomes variadic. This is sort of an edge case, but 1476 // it's legal per the standard depending on how you read C99 6.7.5.3p15 and 1477 // C99 6.9.1p8. 1478 if (!getLangOptions().CPlusPlus && 1479 Old->hasPrototype() && !New->hasPrototype() && 1480 New->getType()->getAs<FunctionProtoType>() && 1481 Old->getNumParams() == New->getNumParams()) { 1482 llvm::SmallVector<QualType, 16> ArgTypes; 1483 llvm::SmallVector<GNUCompatibleParamWarning, 16> Warnings; 1484 const FunctionProtoType *OldProto 1485 = Old->getType()->getAs<FunctionProtoType>(); 1486 const FunctionProtoType *NewProto 1487 = New->getType()->getAs<FunctionProtoType>(); 1488 1489 // Determine whether this is the GNU C extension. 1490 QualType MergedReturn = Context.mergeTypes(OldProto->getResultType(), 1491 NewProto->getResultType()); 1492 bool LooseCompatible = !MergedReturn.isNull(); 1493 for (unsigned Idx = 0, End = Old->getNumParams(); 1494 LooseCompatible && Idx != End; ++Idx) { 1495 ParmVarDecl *OldParm = Old->getParamDecl(Idx); 1496 ParmVarDecl *NewParm = New->getParamDecl(Idx); 1497 if (Context.typesAreCompatible(OldParm->getType(), 1498 NewProto->getArgType(Idx))) { 1499 ArgTypes.push_back(NewParm->getType()); 1500 } else if (Context.typesAreCompatible(OldParm->getType(), 1501 NewParm->getType(), 1502 /*CompareUnqualified=*/true)) { 1503 GNUCompatibleParamWarning Warn 1504 = { OldParm, NewParm, NewProto->getArgType(Idx) }; 1505 Warnings.push_back(Warn); 1506 ArgTypes.push_back(NewParm->getType()); 1507 } else 1508 LooseCompatible = false; 1509 } 1510 1511 if (LooseCompatible) { 1512 for (unsigned Warn = 0; Warn < Warnings.size(); ++Warn) { 1513 Diag(Warnings[Warn].NewParm->getLocation(), 1514 diag::ext_param_promoted_not_compatible_with_prototype) 1515 << Warnings[Warn].PromotedType 1516 << Warnings[Warn].OldParm->getType(); 1517 if (Warnings[Warn].OldParm->getLocation().isValid()) 1518 Diag(Warnings[Warn].OldParm->getLocation(), 1519 diag::note_previous_declaration); 1520 } 1521 1522 New->setType(Context.getFunctionType(MergedReturn, &ArgTypes[0], 1523 ArgTypes.size(), 1524 OldProto->getExtProtoInfo())); 1525 return MergeCompatibleFunctionDecls(New, Old); 1526 } 1527 1528 // Fall through to diagnose conflicting types. 1529 } 1530 1531 // A function that has already been declared has been redeclared or defined 1532 // with a different type- show appropriate diagnostic 1533 if (unsigned BuiltinID = Old->getBuiltinID()) { 1534 // The user has declared a builtin function with an incompatible 1535 // signature. 1536 if (Context.BuiltinInfo.isPredefinedLibFunction(BuiltinID)) { 1537 // The function the user is redeclaring is a library-defined 1538 // function like 'malloc' or 'printf'. Warn about the 1539 // redeclaration, then pretend that we don't know about this 1540 // library built-in. 1541 Diag(New->getLocation(), diag::warn_redecl_library_builtin) << New; 1542 Diag(Old->getLocation(), diag::note_previous_builtin_declaration) 1543 << Old << Old->getType(); 1544 New->getIdentifier()->setBuiltinID(Builtin::NotBuiltin); 1545 Old->setInvalidDecl(); 1546 return false; 1547 } 1548 1549 PrevDiag = diag::note_previous_builtin_declaration; 1550 } 1551 1552 Diag(New->getLocation(), diag::err_conflicting_types) << New->getDeclName(); 1553 Diag(Old->getLocation(), PrevDiag) << Old << Old->getType(); 1554 return true; 1555} 1556 1557/// \brief Completes the merge of two function declarations that are 1558/// known to be compatible. 1559/// 1560/// This routine handles the merging of attributes and other 1561/// properties of function declarations form the old declaration to 1562/// the new declaration, once we know that New is in fact a 1563/// redeclaration of Old. 1564/// 1565/// \returns false 1566bool Sema::MergeCompatibleFunctionDecls(FunctionDecl *New, FunctionDecl *Old) { 1567 // Merge the attributes 1568 mergeDeclAttributes(New, Old, Context); 1569 1570 // Merge the storage class. 1571 if (Old->getStorageClass() != SC_Extern && 1572 Old->getStorageClass() != SC_None) 1573 New->setStorageClass(Old->getStorageClass()); 1574 1575 // Merge "pure" flag. 1576 if (Old->isPure()) 1577 New->setPure(); 1578 1579 // Merge the "deleted" flag. 1580 if (Old->isDeleted()) 1581 New->setDeleted(); 1582 1583 // Merge attributes from the parameters. These can mismatch with K&R 1584 // declarations. 1585 if (New->getNumParams() == Old->getNumParams()) 1586 for (unsigned i = 0, e = New->getNumParams(); i != e; ++i) 1587 mergeParamDeclAttributes(New->getParamDecl(i), Old->getParamDecl(i), 1588 Context); 1589 1590 if (getLangOptions().CPlusPlus) 1591 return MergeCXXFunctionDecl(New, Old); 1592 1593 return false; 1594} 1595 1596void Sema::mergeObjCMethodDecls(ObjCMethodDecl *newMethod, 1597 const ObjCMethodDecl *oldMethod) { 1598 // Merge the attributes. 1599 mergeDeclAttributes(newMethod, oldMethod, Context); 1600 1601 // Merge attributes from the parameters. 1602 for (ObjCMethodDecl::param_iterator oi = oldMethod->param_begin(), 1603 ni = newMethod->param_begin(), ne = newMethod->param_end(); 1604 ni != ne; ++ni, ++oi) 1605 mergeParamDeclAttributes(*ni, *oi, Context); 1606} 1607 1608/// MergeVarDeclTypes - We parsed a variable 'New' which has the same name and 1609/// scope as a previous declaration 'Old'. Figure out how to merge their types, 1610/// emitting diagnostics as appropriate. 1611/// 1612/// Declarations using the auto type specifier (C++ [decl.spec.auto]) call back 1613/// to here in AddInitializerToDecl and AddCXXDirectInitializerToDecl. We can't 1614/// check them before the initializer is attached. 1615/// 1616void Sema::MergeVarDeclTypes(VarDecl *New, VarDecl *Old) { 1617 if (New->isInvalidDecl() || Old->isInvalidDecl()) 1618 return; 1619 1620 QualType MergedT; 1621 if (getLangOptions().CPlusPlus) { 1622 AutoType *AT = New->getType()->getContainedAutoType(); 1623 if (AT && !AT->isDeduced()) { 1624 // We don't know what the new type is until the initializer is attached. 1625 return; 1626 } else if (Context.hasSameType(New->getType(), Old->getType())) { 1627 // These could still be something that needs exception specs checked. 1628 return MergeVarDeclExceptionSpecs(New, Old); 1629 } 1630 // C++ [basic.link]p10: 1631 // [...] the types specified by all declarations referring to a given 1632 // object or function shall be identical, except that declarations for an 1633 // array object can specify array types that differ by the presence or 1634 // absence of a major array bound (8.3.4). 1635 else if (Old->getType()->isIncompleteArrayType() && 1636 New->getType()->isArrayType()) { 1637 CanQual<ArrayType> OldArray 1638 = Context.getCanonicalType(Old->getType())->getAs<ArrayType>(); 1639 CanQual<ArrayType> NewArray 1640 = Context.getCanonicalType(New->getType())->getAs<ArrayType>(); 1641 if (OldArray->getElementType() == NewArray->getElementType()) 1642 MergedT = New->getType(); 1643 } else if (Old->getType()->isArrayType() && 1644 New->getType()->isIncompleteArrayType()) { 1645 CanQual<ArrayType> OldArray 1646 = Context.getCanonicalType(Old->getType())->getAs<ArrayType>(); 1647 CanQual<ArrayType> NewArray 1648 = Context.getCanonicalType(New->getType())->getAs<ArrayType>(); 1649 if (OldArray->getElementType() == NewArray->getElementType()) 1650 MergedT = Old->getType(); 1651 } else if (New->getType()->isObjCObjectPointerType() 1652 && Old->getType()->isObjCObjectPointerType()) { 1653 MergedT = Context.mergeObjCGCQualifiers(New->getType(), 1654 Old->getType()); 1655 } 1656 } else { 1657 MergedT = Context.mergeTypes(New->getType(), Old->getType()); 1658 } 1659 if (MergedT.isNull()) { 1660 Diag(New->getLocation(), diag::err_redefinition_different_type) 1661 << New->getDeclName(); 1662 Diag(Old->getLocation(), diag::note_previous_definition); 1663 return New->setInvalidDecl(); 1664 } 1665 New->setType(MergedT); 1666} 1667 1668/// MergeVarDecl - We just parsed a variable 'New' which has the same name 1669/// and scope as a previous declaration 'Old'. Figure out how to resolve this 1670/// situation, merging decls or emitting diagnostics as appropriate. 1671/// 1672/// Tentative definition rules (C99 6.9.2p2) are checked by 1673/// FinalizeDeclaratorGroup. Unfortunately, we can't analyze tentative 1674/// definitions here, since the initializer hasn't been attached. 1675/// 1676void Sema::MergeVarDecl(VarDecl *New, LookupResult &Previous) { 1677 // If the new decl is already invalid, don't do any other checking. 1678 if (New->isInvalidDecl()) 1679 return; 1680 1681 // Verify the old decl was also a variable. 1682 VarDecl *Old = 0; 1683 if (!Previous.isSingleResult() || 1684 !(Old = dyn_cast<VarDecl>(Previous.getFoundDecl()))) { 1685 Diag(New->getLocation(), diag::err_redefinition_different_kind) 1686 << New->getDeclName(); 1687 Diag(Previous.getRepresentativeDecl()->getLocation(), 1688 diag::note_previous_definition); 1689 return New->setInvalidDecl(); 1690 } 1691 1692 // C++ [class.mem]p1: 1693 // A member shall not be declared twice in the member-specification [...] 1694 // 1695 // Here, we need only consider static data members. 1696 if (Old->isStaticDataMember() && !New->isOutOfLine()) { 1697 Diag(New->getLocation(), diag::err_duplicate_member) 1698 << New->getIdentifier(); 1699 Diag(Old->getLocation(), diag::note_previous_declaration); 1700 New->setInvalidDecl(); 1701 } 1702 1703 mergeDeclAttributes(New, Old, Context); 1704 1705 // Merge the types. 1706 MergeVarDeclTypes(New, Old); 1707 if (New->isInvalidDecl()) 1708 return; 1709 1710 // C99 6.2.2p4: Check if we have a static decl followed by a non-static. 1711 if (New->getStorageClass() == SC_Static && 1712 (Old->getStorageClass() == SC_None || Old->hasExternalStorage())) { 1713 Diag(New->getLocation(), diag::err_static_non_static) << New->getDeclName(); 1714 Diag(Old->getLocation(), diag::note_previous_definition); 1715 return New->setInvalidDecl(); 1716 } 1717 // C99 6.2.2p4: 1718 // For an identifier declared with the storage-class specifier 1719 // extern in a scope in which a prior declaration of that 1720 // identifier is visible,23) if the prior declaration specifies 1721 // internal or external linkage, the linkage of the identifier at 1722 // the later declaration is the same as the linkage specified at 1723 // the prior declaration. If no prior declaration is visible, or 1724 // if the prior declaration specifies no linkage, then the 1725 // identifier has external linkage. 1726 if (New->hasExternalStorage() && Old->hasLinkage()) 1727 /* Okay */; 1728 else if (New->getStorageClass() != SC_Static && 1729 Old->getStorageClass() == SC_Static) { 1730 Diag(New->getLocation(), diag::err_non_static_static) << New->getDeclName(); 1731 Diag(Old->getLocation(), diag::note_previous_definition); 1732 return New->setInvalidDecl(); 1733 } 1734 1735 // Check if extern is followed by non-extern and vice-versa. 1736 if (New->hasExternalStorage() && 1737 !Old->hasLinkage() && Old->isLocalVarDecl()) { 1738 Diag(New->getLocation(), diag::err_extern_non_extern) << New->getDeclName(); 1739 Diag(Old->getLocation(), diag::note_previous_definition); 1740 return New->setInvalidDecl(); 1741 } 1742 if (Old->hasExternalStorage() && 1743 !New->hasLinkage() && New->isLocalVarDecl()) { 1744 Diag(New->getLocation(), diag::err_non_extern_extern) << New->getDeclName(); 1745 Diag(Old->getLocation(), diag::note_previous_definition); 1746 return New->setInvalidDecl(); 1747 } 1748 1749 // Variables with external linkage are analyzed in FinalizeDeclaratorGroup. 1750 1751 // FIXME: The test for external storage here seems wrong? We still 1752 // need to check for mismatches. 1753 if (!New->hasExternalStorage() && !New->isFileVarDecl() && 1754 // Don't complain about out-of-line definitions of static members. 1755 !(Old->getLexicalDeclContext()->isRecord() && 1756 !New->getLexicalDeclContext()->isRecord())) { 1757 Diag(New->getLocation(), diag::err_redefinition) << New->getDeclName(); 1758 Diag(Old->getLocation(), diag::note_previous_definition); 1759 return New->setInvalidDecl(); 1760 } 1761 1762 if (New->isThreadSpecified() && !Old->isThreadSpecified()) { 1763 Diag(New->getLocation(), diag::err_thread_non_thread) << New->getDeclName(); 1764 Diag(Old->getLocation(), diag::note_previous_definition); 1765 } else if (!New->isThreadSpecified() && Old->isThreadSpecified()) { 1766 Diag(New->getLocation(), diag::err_non_thread_thread) << New->getDeclName(); 1767 Diag(Old->getLocation(), diag::note_previous_definition); 1768 } 1769 1770 // C++ doesn't have tentative definitions, so go right ahead and check here. 1771 const VarDecl *Def; 1772 if (getLangOptions().CPlusPlus && 1773 New->isThisDeclarationADefinition() == VarDecl::Definition && 1774 (Def = Old->getDefinition())) { 1775 Diag(New->getLocation(), diag::err_redefinition) 1776 << New->getDeclName(); 1777 Diag(Def->getLocation(), diag::note_previous_definition); 1778 New->setInvalidDecl(); 1779 return; 1780 } 1781 // c99 6.2.2 P4. 1782 // For an identifier declared with the storage-class specifier extern in a 1783 // scope in which a prior declaration of that identifier is visible, if 1784 // the prior declaration specifies internal or external linkage, the linkage 1785 // of the identifier at the later declaration is the same as the linkage 1786 // specified at the prior declaration. 1787 // FIXME. revisit this code. 1788 if (New->hasExternalStorage() && 1789 Old->getLinkage() == InternalLinkage && 1790 New->getDeclContext() == Old->getDeclContext()) 1791 New->setStorageClass(Old->getStorageClass()); 1792 1793 // Keep a chain of previous declarations. 1794 New->setPreviousDeclaration(Old); 1795 1796 // Inherit access appropriately. 1797 New->setAccess(Old->getAccess()); 1798} 1799 1800/// ParsedFreeStandingDeclSpec - This method is invoked when a declspec with 1801/// no declarator (e.g. "struct foo;") is parsed. 1802Decl *Sema::ParsedFreeStandingDeclSpec(Scope *S, AccessSpecifier AS, 1803 DeclSpec &DS) { 1804 Decl *TagD = 0; 1805 TagDecl *Tag = 0; 1806 if (DS.getTypeSpecType() == DeclSpec::TST_class || 1807 DS.getTypeSpecType() == DeclSpec::TST_struct || 1808 DS.getTypeSpecType() == DeclSpec::TST_union || 1809 DS.getTypeSpecType() == DeclSpec::TST_enum) { 1810 TagD = DS.getRepAsDecl(); 1811 1812 if (!TagD) // We probably had an error 1813 return 0; 1814 1815 // Note that the above type specs guarantee that the 1816 // type rep is a Decl, whereas in many of the others 1817 // it's a Type. 1818 Tag = dyn_cast<TagDecl>(TagD); 1819 } 1820 1821 if (unsigned TypeQuals = DS.getTypeQualifiers()) { 1822 // Enforce C99 6.7.3p2: "Types other than pointer types derived from object 1823 // or incomplete types shall not be restrict-qualified." 1824 if (TypeQuals & DeclSpec::TQ_restrict) 1825 Diag(DS.getRestrictSpecLoc(), 1826 diag::err_typecheck_invalid_restrict_not_pointer_noarg) 1827 << DS.getSourceRange(); 1828 } 1829 1830 if (DS.isFriendSpecified()) { 1831 // If we're dealing with a decl but not a TagDecl, assume that 1832 // whatever routines created it handled the friendship aspect. 1833 if (TagD && !Tag) 1834 return 0; 1835 return ActOnFriendTypeDecl(S, DS, MultiTemplateParamsArg(*this, 0, 0)); 1836 } 1837 1838 // Track whether we warned about the fact that there aren't any 1839 // declarators. 1840 bool emittedWarning = false; 1841 1842 if (RecordDecl *Record = dyn_cast_or_null<RecordDecl>(Tag)) { 1843 ProcessDeclAttributeList(S, Record, DS.getAttributes().getList()); 1844 1845 if (!Record->getDeclName() && Record->isDefinition() && 1846 DS.getStorageClassSpec() != DeclSpec::SCS_typedef) { 1847 if (getLangOptions().CPlusPlus || 1848 Record->getDeclContext()->isRecord()) 1849 return BuildAnonymousStructOrUnion(S, DS, AS, Record); 1850 1851 Diag(DS.getSourceRange().getBegin(), diag::ext_no_declarators) 1852 << DS.getSourceRange(); 1853 emittedWarning = true; 1854 } 1855 } 1856 1857 // Check for Microsoft C extension: anonymous struct. 1858 if (getLangOptions().Microsoft && !getLangOptions().CPlusPlus && 1859 CurContext->isRecord() && 1860 DS.getStorageClassSpec() == DeclSpec::SCS_unspecified) { 1861 // Handle 2 kinds of anonymous struct: 1862 // struct STRUCT; 1863 // and 1864 // STRUCT_TYPE; <- where STRUCT_TYPE is a typedef struct. 1865 RecordDecl *Record = dyn_cast_or_null<RecordDecl>(Tag); 1866 if ((Record && Record->getDeclName() && !Record->isDefinition()) || 1867 (DS.getTypeSpecType() == DeclSpec::TST_typename && 1868 DS.getRepAsType().get()->isStructureType())) { 1869 Diag(DS.getSourceRange().getBegin(), diag::ext_ms_anonymous_struct) 1870 << DS.getSourceRange(); 1871 return BuildMicrosoftCAnonymousStruct(S, DS, Record); 1872 } 1873 } 1874 1875 if (getLangOptions().CPlusPlus && 1876 DS.getStorageClassSpec() != DeclSpec::SCS_typedef) 1877 if (EnumDecl *Enum = dyn_cast_or_null<EnumDecl>(Tag)) 1878 if (Enum->enumerator_begin() == Enum->enumerator_end() && 1879 !Enum->getIdentifier() && !Enum->isInvalidDecl()) { 1880 Diag(Enum->getLocation(), diag::ext_no_declarators) 1881 << DS.getSourceRange(); 1882 emittedWarning = true; 1883 } 1884 1885 // Skip all the checks below if we have a type error. 1886 if (DS.getTypeSpecType() == DeclSpec::TST_error) return TagD; 1887 1888 if (!DS.isMissingDeclaratorOk()) { 1889 // Warn about typedefs of enums without names, since this is an 1890 // extension in both Microsoft and GNU. 1891 if (DS.getStorageClassSpec() == DeclSpec::SCS_typedef && 1892 Tag && isa<EnumDecl>(Tag)) { 1893 Diag(DS.getSourceRange().getBegin(), diag::ext_typedef_without_a_name) 1894 << DS.getSourceRange(); 1895 return Tag; 1896 } 1897 1898 Diag(DS.getSourceRange().getBegin(), diag::ext_no_declarators) 1899 << DS.getSourceRange(); 1900 emittedWarning = true; 1901 } 1902 1903 // We're going to complain about a bunch of spurious specifiers; 1904 // only do this if we're declaring a tag, because otherwise we 1905 // should be getting diag::ext_no_declarators. 1906 if (emittedWarning || (TagD && TagD->isInvalidDecl())) 1907 return TagD; 1908 1909 // Note that a linkage-specification sets a storage class, but 1910 // 'extern "C" struct foo;' is actually valid and not theoretically 1911 // useless. 1912 if (DeclSpec::SCS scs = DS.getStorageClassSpec()) 1913 if (!DS.isExternInLinkageSpec()) 1914 Diag(DS.getStorageClassSpecLoc(), diag::warn_standalone_specifier) 1915 << DeclSpec::getSpecifierName(scs); 1916 1917 if (DS.isThreadSpecified()) 1918 Diag(DS.getThreadSpecLoc(), diag::warn_standalone_specifier) << "__thread"; 1919 if (DS.getTypeQualifiers()) { 1920 if (DS.getTypeQualifiers() & DeclSpec::TQ_const) 1921 Diag(DS.getConstSpecLoc(), diag::warn_standalone_specifier) << "const"; 1922 if (DS.getTypeQualifiers() & DeclSpec::TQ_volatile) 1923 Diag(DS.getConstSpecLoc(), diag::warn_standalone_specifier) << "volatile"; 1924 // Restrict is covered above. 1925 } 1926 if (DS.isInlineSpecified()) 1927 Diag(DS.getInlineSpecLoc(), diag::warn_standalone_specifier) << "inline"; 1928 if (DS.isVirtualSpecified()) 1929 Diag(DS.getVirtualSpecLoc(), diag::warn_standalone_specifier) << "virtual"; 1930 if (DS.isExplicitSpecified()) 1931 Diag(DS.getExplicitSpecLoc(), diag::warn_standalone_specifier) <<"explicit"; 1932 1933 // FIXME: Warn on useless attributes 1934 1935 return TagD; 1936} 1937 1938/// ActOnVlaStmt - This rouine if finds a vla expression in a decl spec. 1939/// builds a statement for it and returns it so it is evaluated. 1940StmtResult Sema::ActOnVlaStmt(const DeclSpec &DS) { 1941 StmtResult R; 1942 if (DS.getTypeSpecType() == DeclSpec::TST_typeofExpr) { 1943 Expr *Exp = DS.getRepAsExpr(); 1944 QualType Ty = Exp->getType(); 1945 if (Ty->isPointerType()) { 1946 do 1947 Ty = Ty->getAs<PointerType>()->getPointeeType(); 1948 while (Ty->isPointerType()); 1949 } 1950 if (Ty->isVariableArrayType()) { 1951 R = ActOnExprStmt(MakeFullExpr(Exp)); 1952 } 1953 } 1954 return R; 1955} 1956 1957/// We are trying to inject an anonymous member into the given scope; 1958/// check if there's an existing declaration that can't be overloaded. 1959/// 1960/// \return true if this is a forbidden redeclaration 1961static bool CheckAnonMemberRedeclaration(Sema &SemaRef, 1962 Scope *S, 1963 DeclContext *Owner, 1964 DeclarationName Name, 1965 SourceLocation NameLoc, 1966 unsigned diagnostic) { 1967 LookupResult R(SemaRef, Name, NameLoc, Sema::LookupMemberName, 1968 Sema::ForRedeclaration); 1969 if (!SemaRef.LookupName(R, S)) return false; 1970 1971 if (R.getAsSingle<TagDecl>()) 1972 return false; 1973 1974 // Pick a representative declaration. 1975 NamedDecl *PrevDecl = R.getRepresentativeDecl()->getUnderlyingDecl(); 1976 assert(PrevDecl && "Expected a non-null Decl"); 1977 1978 if (!SemaRef.isDeclInScope(PrevDecl, Owner, S)) 1979 return false; 1980 1981 SemaRef.Diag(NameLoc, diagnostic) << Name; 1982 SemaRef.Diag(PrevDecl->getLocation(), diag::note_previous_declaration); 1983 1984 return true; 1985} 1986 1987/// InjectAnonymousStructOrUnionMembers - Inject the members of the 1988/// anonymous struct or union AnonRecord into the owning context Owner 1989/// and scope S. This routine will be invoked just after we realize 1990/// that an unnamed union or struct is actually an anonymous union or 1991/// struct, e.g., 1992/// 1993/// @code 1994/// union { 1995/// int i; 1996/// float f; 1997/// }; // InjectAnonymousStructOrUnionMembers called here to inject i and 1998/// // f into the surrounding scope.x 1999/// @endcode 2000/// 2001/// This routine is recursive, injecting the names of nested anonymous 2002/// structs/unions into the owning context and scope as well. 2003static bool InjectAnonymousStructOrUnionMembers(Sema &SemaRef, Scope *S, 2004 DeclContext *Owner, 2005 RecordDecl *AnonRecord, 2006 AccessSpecifier AS, 2007 llvm::SmallVector<NamedDecl*, 2> &Chaining, 2008 bool MSAnonStruct) { 2009 unsigned diagKind 2010 = AnonRecord->isUnion() ? diag::err_anonymous_union_member_redecl 2011 : diag::err_anonymous_struct_member_redecl; 2012 2013 bool Invalid = false; 2014 2015 // Look every FieldDecl and IndirectFieldDecl with a name. 2016 for (RecordDecl::decl_iterator D = AnonRecord->decls_begin(), 2017 DEnd = AnonRecord->decls_end(); 2018 D != DEnd; ++D) { 2019 if ((isa<FieldDecl>(*D) || isa<IndirectFieldDecl>(*D)) && 2020 cast<NamedDecl>(*D)->getDeclName()) { 2021 ValueDecl *VD = cast<ValueDecl>(*D); 2022 if (CheckAnonMemberRedeclaration(SemaRef, S, Owner, VD->getDeclName(), 2023 VD->getLocation(), diagKind)) { 2024 // C++ [class.union]p2: 2025 // The names of the members of an anonymous union shall be 2026 // distinct from the names of any other entity in the 2027 // scope in which the anonymous union is declared. 2028 Invalid = true; 2029 } else { 2030 // C++ [class.union]p2: 2031 // For the purpose of name lookup, after the anonymous union 2032 // definition, the members of the anonymous union are 2033 // considered to have been defined in the scope in which the 2034 // anonymous union is declared. 2035 unsigned OldChainingSize = Chaining.size(); 2036 if (IndirectFieldDecl *IF = dyn_cast<IndirectFieldDecl>(VD)) 2037 for (IndirectFieldDecl::chain_iterator PI = IF->chain_begin(), 2038 PE = IF->chain_end(); PI != PE; ++PI) 2039 Chaining.push_back(*PI); 2040 else 2041 Chaining.push_back(VD); 2042 2043 assert(Chaining.size() >= 2); 2044 NamedDecl **NamedChain = 2045 new (SemaRef.Context)NamedDecl*[Chaining.size()]; 2046 for (unsigned i = 0; i < Chaining.size(); i++) 2047 NamedChain[i] = Chaining[i]; 2048 2049 IndirectFieldDecl* IndirectField = 2050 IndirectFieldDecl::Create(SemaRef.Context, Owner, VD->getLocation(), 2051 VD->getIdentifier(), VD->getType(), 2052 NamedChain, Chaining.size()); 2053 2054 IndirectField->setAccess(AS); 2055 IndirectField->setImplicit(); 2056 SemaRef.PushOnScopeChains(IndirectField, S); 2057 2058 // That includes picking up the appropriate access specifier. 2059 if (AS != AS_none) IndirectField->setAccess(AS); 2060 2061 Chaining.resize(OldChainingSize); 2062 } 2063 } 2064 } 2065 2066 return Invalid; 2067} 2068 2069/// StorageClassSpecToVarDeclStorageClass - Maps a DeclSpec::SCS to 2070/// a VarDecl::StorageClass. Any error reporting is up to the caller: 2071/// illegal input values are mapped to SC_None. 2072static StorageClass 2073StorageClassSpecToVarDeclStorageClass(DeclSpec::SCS StorageClassSpec) { 2074 switch (StorageClassSpec) { 2075 case DeclSpec::SCS_unspecified: return SC_None; 2076 case DeclSpec::SCS_extern: return SC_Extern; 2077 case DeclSpec::SCS_static: return SC_Static; 2078 case DeclSpec::SCS_auto: return SC_Auto; 2079 case DeclSpec::SCS_register: return SC_Register; 2080 case DeclSpec::SCS_private_extern: return SC_PrivateExtern; 2081 // Illegal SCSs map to None: error reporting is up to the caller. 2082 case DeclSpec::SCS_mutable: // Fall through. 2083 case DeclSpec::SCS_typedef: return SC_None; 2084 } 2085 llvm_unreachable("unknown storage class specifier"); 2086} 2087 2088/// StorageClassSpecToFunctionDeclStorageClass - Maps a DeclSpec::SCS to 2089/// a StorageClass. Any error reporting is up to the caller: 2090/// illegal input values are mapped to SC_None. 2091static StorageClass 2092StorageClassSpecToFunctionDeclStorageClass(DeclSpec::SCS StorageClassSpec) { 2093 switch (StorageClassSpec) { 2094 case DeclSpec::SCS_unspecified: return SC_None; 2095 case DeclSpec::SCS_extern: return SC_Extern; 2096 case DeclSpec::SCS_static: return SC_Static; 2097 case DeclSpec::SCS_private_extern: return SC_PrivateExtern; 2098 // Illegal SCSs map to None: error reporting is up to the caller. 2099 case DeclSpec::SCS_auto: // Fall through. 2100 case DeclSpec::SCS_mutable: // Fall through. 2101 case DeclSpec::SCS_register: // Fall through. 2102 case DeclSpec::SCS_typedef: return SC_None; 2103 } 2104 llvm_unreachable("unknown storage class specifier"); 2105} 2106 2107/// BuildAnonymousStructOrUnion - Handle the declaration of an 2108/// anonymous structure or union. Anonymous unions are a C++ feature 2109/// (C++ [class.union]) and a GNU C extension; anonymous structures 2110/// are a GNU C and GNU C++ extension. 2111Decl *Sema::BuildAnonymousStructOrUnion(Scope *S, DeclSpec &DS, 2112 AccessSpecifier AS, 2113 RecordDecl *Record) { 2114 DeclContext *Owner = Record->getDeclContext(); 2115 2116 // Diagnose whether this anonymous struct/union is an extension. 2117 if (Record->isUnion() && !getLangOptions().CPlusPlus) 2118 Diag(Record->getLocation(), diag::ext_anonymous_union); 2119 else if (!Record->isUnion()) 2120 Diag(Record->getLocation(), diag::ext_anonymous_struct); 2121 2122 // C and C++ require different kinds of checks for anonymous 2123 // structs/unions. 2124 bool Invalid = false; 2125 if (getLangOptions().CPlusPlus) { 2126 const char* PrevSpec = 0; 2127 unsigned DiagID; 2128 // C++ [class.union]p3: 2129 // Anonymous unions declared in a named namespace or in the 2130 // global namespace shall be declared static. 2131 if (DS.getStorageClassSpec() != DeclSpec::SCS_static && 2132 (isa<TranslationUnitDecl>(Owner) || 2133 (isa<NamespaceDecl>(Owner) && 2134 cast<NamespaceDecl>(Owner)->getDeclName()))) { 2135 Diag(Record->getLocation(), diag::err_anonymous_union_not_static); 2136 Invalid = true; 2137 2138 // Recover by adding 'static'. 2139 DS.SetStorageClassSpec(DeclSpec::SCS_static, SourceLocation(), 2140 PrevSpec, DiagID, getLangOptions()); 2141 } 2142 // C++ [class.union]p3: 2143 // A storage class is not allowed in a declaration of an 2144 // anonymous union in a class scope. 2145 else if (DS.getStorageClassSpec() != DeclSpec::SCS_unspecified && 2146 isa<RecordDecl>(Owner)) { 2147 Diag(DS.getStorageClassSpecLoc(), 2148 diag::err_anonymous_union_with_storage_spec); 2149 Invalid = true; 2150 2151 // Recover by removing the storage specifier. 2152 DS.SetStorageClassSpec(DeclSpec::SCS_unspecified, SourceLocation(), 2153 PrevSpec, DiagID, getLangOptions()); 2154 } 2155 2156 // C++ [class.union]p2: 2157 // The member-specification of an anonymous union shall only 2158 // define non-static data members. [Note: nested types and 2159 // functions cannot be declared within an anonymous union. ] 2160 for (DeclContext::decl_iterator Mem = Record->decls_begin(), 2161 MemEnd = Record->decls_end(); 2162 Mem != MemEnd; ++Mem) { 2163 if (FieldDecl *FD = dyn_cast<FieldDecl>(*Mem)) { 2164 // C++ [class.union]p3: 2165 // An anonymous union shall not have private or protected 2166 // members (clause 11). 2167 assert(FD->getAccess() != AS_none); 2168 if (FD->getAccess() != AS_public) { 2169 Diag(FD->getLocation(), diag::err_anonymous_record_nonpublic_member) 2170 << (int)Record->isUnion() << (int)(FD->getAccess() == AS_protected); 2171 Invalid = true; 2172 } 2173 2174 if (CheckNontrivialField(FD)) 2175 Invalid = true; 2176 } else if ((*Mem)->isImplicit()) { 2177 // Any implicit members are fine. 2178 } else if (isa<TagDecl>(*Mem) && (*Mem)->getDeclContext() != Record) { 2179 // This is a type that showed up in an 2180 // elaborated-type-specifier inside the anonymous struct or 2181 // union, but which actually declares a type outside of the 2182 // anonymous struct or union. It's okay. 2183 } else if (RecordDecl *MemRecord = dyn_cast<RecordDecl>(*Mem)) { 2184 if (!MemRecord->isAnonymousStructOrUnion() && 2185 MemRecord->getDeclName()) { 2186 // Visual C++ allows type definition in anonymous struct or union. 2187 if (getLangOptions().Microsoft) 2188 Diag(MemRecord->getLocation(), diag::ext_anonymous_record_with_type) 2189 << (int)Record->isUnion(); 2190 else { 2191 // This is a nested type declaration. 2192 Diag(MemRecord->getLocation(), diag::err_anonymous_record_with_type) 2193 << (int)Record->isUnion(); 2194 Invalid = true; 2195 } 2196 } 2197 } else if (isa<AccessSpecDecl>(*Mem)) { 2198 // Any access specifier is fine. 2199 } else { 2200 // We have something that isn't a non-static data 2201 // member. Complain about it. 2202 unsigned DK = diag::err_anonymous_record_bad_member; 2203 if (isa<TypeDecl>(*Mem)) 2204 DK = diag::err_anonymous_record_with_type; 2205 else if (isa<FunctionDecl>(*Mem)) 2206 DK = diag::err_anonymous_record_with_function; 2207 else if (isa<VarDecl>(*Mem)) 2208 DK = diag::err_anonymous_record_with_static; 2209 2210 // Visual C++ allows type definition in anonymous struct or union. 2211 if (getLangOptions().Microsoft && 2212 DK == diag::err_anonymous_record_with_type) 2213 Diag((*Mem)->getLocation(), diag::ext_anonymous_record_with_type) 2214 << (int)Record->isUnion(); 2215 else { 2216 Diag((*Mem)->getLocation(), DK) 2217 << (int)Record->isUnion(); 2218 Invalid = true; 2219 } 2220 } 2221 } 2222 } 2223 2224 if (!Record->isUnion() && !Owner->isRecord()) { 2225 Diag(Record->getLocation(), diag::err_anonymous_struct_not_member) 2226 << (int)getLangOptions().CPlusPlus; 2227 Invalid = true; 2228 } 2229 2230 // Mock up a declarator. 2231 Declarator Dc(DS, Declarator::TypeNameContext); 2232 TypeSourceInfo *TInfo = GetTypeForDeclarator(Dc, S); 2233 assert(TInfo && "couldn't build declarator info for anonymous struct/union"); 2234 2235 // Create a declaration for this anonymous struct/union. 2236 NamedDecl *Anon = 0; 2237 if (RecordDecl *OwningClass = dyn_cast<RecordDecl>(Owner)) { 2238 Anon = FieldDecl::Create(Context, OwningClass, 2239 DS.getSourceRange().getBegin(), 2240 Record->getLocation(), 2241 /*IdentifierInfo=*/0, 2242 Context.getTypeDeclType(Record), 2243 TInfo, 2244 /*BitWidth=*/0, /*Mutable=*/false); 2245 Anon->setAccess(AS); 2246 if (getLangOptions().CPlusPlus) 2247 FieldCollector->Add(cast<FieldDecl>(Anon)); 2248 } else { 2249 DeclSpec::SCS SCSpec = DS.getStorageClassSpec(); 2250 assert(SCSpec != DeclSpec::SCS_typedef && 2251 "Parser allowed 'typedef' as storage class VarDecl."); 2252 VarDecl::StorageClass SC = StorageClassSpecToVarDeclStorageClass(SCSpec); 2253 if (SCSpec == DeclSpec::SCS_mutable) { 2254 // mutable can only appear on non-static class members, so it's always 2255 // an error here 2256 Diag(Record->getLocation(), diag::err_mutable_nonmember); 2257 Invalid = true; 2258 SC = SC_None; 2259 } 2260 SCSpec = DS.getStorageClassSpecAsWritten(); 2261 VarDecl::StorageClass SCAsWritten 2262 = StorageClassSpecToVarDeclStorageClass(SCSpec); 2263 2264 Anon = VarDecl::Create(Context, Owner, 2265 DS.getSourceRange().getBegin(), 2266 Record->getLocation(), /*IdentifierInfo=*/0, 2267 Context.getTypeDeclType(Record), 2268 TInfo, SC, SCAsWritten); 2269 } 2270 Anon->setImplicit(); 2271 2272 // Add the anonymous struct/union object to the current 2273 // context. We'll be referencing this object when we refer to one of 2274 // its members. 2275 Owner->addDecl(Anon); 2276 2277 // Inject the members of the anonymous struct/union into the owning 2278 // context and into the identifier resolver chain for name lookup 2279 // purposes. 2280 llvm::SmallVector<NamedDecl*, 2> Chain; 2281 Chain.push_back(Anon); 2282 2283 if (InjectAnonymousStructOrUnionMembers(*this, S, Owner, Record, AS, 2284 Chain, false)) 2285 Invalid = true; 2286 2287 // Mark this as an anonymous struct/union type. Note that we do not 2288 // do this until after we have already checked and injected the 2289 // members of this anonymous struct/union type, because otherwise 2290 // the members could be injected twice: once by DeclContext when it 2291 // builds its lookup table, and once by 2292 // InjectAnonymousStructOrUnionMembers. 2293 Record->setAnonymousStructOrUnion(true); 2294 2295 if (Invalid) 2296 Anon->setInvalidDecl(); 2297 2298 return Anon; 2299} 2300 2301/// BuildMicrosoftCAnonymousStruct - Handle the declaration of an 2302/// Microsoft C anonymous structure. 2303/// Ref: http://msdn.microsoft.com/en-us/library/z2cx9y4f.aspx 2304/// Example: 2305/// 2306/// struct A { int a; }; 2307/// struct B { struct A; int b; }; 2308/// 2309/// void foo() { 2310/// B var; 2311/// var.a = 3; 2312/// } 2313/// 2314Decl *Sema::BuildMicrosoftCAnonymousStruct(Scope *S, DeclSpec &DS, 2315 RecordDecl *Record) { 2316 2317 // If there is no Record, get the record via the typedef. 2318 if (!Record) 2319 Record = DS.getRepAsType().get()->getAsStructureType()->getDecl(); 2320 2321 // Mock up a declarator. 2322 Declarator Dc(DS, Declarator::TypeNameContext); 2323 TypeSourceInfo *TInfo = GetTypeForDeclarator(Dc, S); 2324 assert(TInfo && "couldn't build declarator info for anonymous struct"); 2325 2326 // Create a declaration for this anonymous struct. 2327 NamedDecl* Anon = FieldDecl::Create(Context, 2328 cast<RecordDecl>(CurContext), 2329 DS.getSourceRange().getBegin(), 2330 DS.getSourceRange().getBegin(), 2331 /*IdentifierInfo=*/0, 2332 Context.getTypeDeclType(Record), 2333 TInfo, 2334 /*BitWidth=*/0, /*Mutable=*/false); 2335 Anon->setImplicit(); 2336 2337 // Add the anonymous struct object to the current context. 2338 CurContext->addDecl(Anon); 2339 2340 // Inject the members of the anonymous struct into the current 2341 // context and into the identifier resolver chain for name lookup 2342 // purposes. 2343 llvm::SmallVector<NamedDecl*, 2> Chain; 2344 Chain.push_back(Anon); 2345 2346 if (InjectAnonymousStructOrUnionMembers(*this, S, CurContext, 2347 Record->getDefinition(), 2348 AS_none, Chain, true)) 2349 Anon->setInvalidDecl(); 2350 2351 return Anon; 2352} 2353 2354/// GetNameForDeclarator - Determine the full declaration name for the 2355/// given Declarator. 2356DeclarationNameInfo Sema::GetNameForDeclarator(Declarator &D) { 2357 return GetNameFromUnqualifiedId(D.getName()); 2358} 2359 2360/// \brief Retrieves the declaration name from a parsed unqualified-id. 2361DeclarationNameInfo 2362Sema::GetNameFromUnqualifiedId(const UnqualifiedId &Name) { 2363 DeclarationNameInfo NameInfo; 2364 NameInfo.setLoc(Name.StartLocation); 2365 2366 switch (Name.getKind()) { 2367 2368 case UnqualifiedId::IK_Identifier: 2369 NameInfo.setName(Name.Identifier); 2370 NameInfo.setLoc(Name.StartLocation); 2371 return NameInfo; 2372 2373 case UnqualifiedId::IK_OperatorFunctionId: 2374 NameInfo.setName(Context.DeclarationNames.getCXXOperatorName( 2375 Name.OperatorFunctionId.Operator)); 2376 NameInfo.setLoc(Name.StartLocation); 2377 NameInfo.getInfo().CXXOperatorName.BeginOpNameLoc 2378 = Name.OperatorFunctionId.SymbolLocations[0]; 2379 NameInfo.getInfo().CXXOperatorName.EndOpNameLoc 2380 = Name.EndLocation.getRawEncoding(); 2381 return NameInfo; 2382 2383 case UnqualifiedId::IK_LiteralOperatorId: 2384 NameInfo.setName(Context.DeclarationNames.getCXXLiteralOperatorName( 2385 Name.Identifier)); 2386 NameInfo.setLoc(Name.StartLocation); 2387 NameInfo.setCXXLiteralOperatorNameLoc(Name.EndLocation); 2388 return NameInfo; 2389 2390 case UnqualifiedId::IK_ConversionFunctionId: { 2391 TypeSourceInfo *TInfo; 2392 QualType Ty = GetTypeFromParser(Name.ConversionFunctionId, &TInfo); 2393 if (Ty.isNull()) 2394 return DeclarationNameInfo(); 2395 NameInfo.setName(Context.DeclarationNames.getCXXConversionFunctionName( 2396 Context.getCanonicalType(Ty))); 2397 NameInfo.setLoc(Name.StartLocation); 2398 NameInfo.setNamedTypeInfo(TInfo); 2399 return NameInfo; 2400 } 2401 2402 case UnqualifiedId::IK_ConstructorName: { 2403 TypeSourceInfo *TInfo; 2404 QualType Ty = GetTypeFromParser(Name.ConstructorName, &TInfo); 2405 if (Ty.isNull()) 2406 return DeclarationNameInfo(); 2407 NameInfo.setName(Context.DeclarationNames.getCXXConstructorName( 2408 Context.getCanonicalType(Ty))); 2409 NameInfo.setLoc(Name.StartLocation); 2410 NameInfo.setNamedTypeInfo(TInfo); 2411 return NameInfo; 2412 } 2413 2414 case UnqualifiedId::IK_ConstructorTemplateId: { 2415 // In well-formed code, we can only have a constructor 2416 // template-id that refers to the current context, so go there 2417 // to find the actual type being constructed. 2418 CXXRecordDecl *CurClass = dyn_cast<CXXRecordDecl>(CurContext); 2419 if (!CurClass || CurClass->getIdentifier() != Name.TemplateId->Name) 2420 return DeclarationNameInfo(); 2421 2422 // Determine the type of the class being constructed. 2423 QualType CurClassType = Context.getTypeDeclType(CurClass); 2424 2425 // FIXME: Check two things: that the template-id names the same type as 2426 // CurClassType, and that the template-id does not occur when the name 2427 // was qualified. 2428 2429 NameInfo.setName(Context.DeclarationNames.getCXXConstructorName( 2430 Context.getCanonicalType(CurClassType))); 2431 NameInfo.setLoc(Name.StartLocation); 2432 // FIXME: should we retrieve TypeSourceInfo? 2433 NameInfo.setNamedTypeInfo(0); 2434 return NameInfo; 2435 } 2436 2437 case UnqualifiedId::IK_DestructorName: { 2438 TypeSourceInfo *TInfo; 2439 QualType Ty = GetTypeFromParser(Name.DestructorName, &TInfo); 2440 if (Ty.isNull()) 2441 return DeclarationNameInfo(); 2442 NameInfo.setName(Context.DeclarationNames.getCXXDestructorName( 2443 Context.getCanonicalType(Ty))); 2444 NameInfo.setLoc(Name.StartLocation); 2445 NameInfo.setNamedTypeInfo(TInfo); 2446 return NameInfo; 2447 } 2448 2449 case UnqualifiedId::IK_TemplateId: { 2450 TemplateName TName = Name.TemplateId->Template.get(); 2451 SourceLocation TNameLoc = Name.TemplateId->TemplateNameLoc; 2452 return Context.getNameForTemplate(TName, TNameLoc); 2453 } 2454 2455 } // switch (Name.getKind()) 2456 2457 assert(false && "Unknown name kind"); 2458 return DeclarationNameInfo(); 2459} 2460 2461/// isNearlyMatchingFunction - Determine whether the C++ functions 2462/// Declaration and Definition are "nearly" matching. This heuristic 2463/// is used to improve diagnostics in the case where an out-of-line 2464/// function definition doesn't match any declaration within 2465/// the class or namespace. 2466static bool isNearlyMatchingFunction(ASTContext &Context, 2467 FunctionDecl *Declaration, 2468 FunctionDecl *Definition) { 2469 if (Declaration->param_size() != Definition->param_size()) 2470 return false; 2471 for (unsigned Idx = 0; Idx < Declaration->param_size(); ++Idx) { 2472 QualType DeclParamTy = Declaration->getParamDecl(Idx)->getType(); 2473 QualType DefParamTy = Definition->getParamDecl(Idx)->getType(); 2474 2475 if (!Context.hasSameUnqualifiedType(DeclParamTy.getNonReferenceType(), 2476 DefParamTy.getNonReferenceType())) 2477 return false; 2478 } 2479 2480 return true; 2481} 2482 2483/// NeedsRebuildingInCurrentInstantiation - Checks whether the given 2484/// declarator needs to be rebuilt in the current instantiation. 2485/// Any bits of declarator which appear before the name are valid for 2486/// consideration here. That's specifically the type in the decl spec 2487/// and the base type in any member-pointer chunks. 2488static bool RebuildDeclaratorInCurrentInstantiation(Sema &S, Declarator &D, 2489 DeclarationName Name) { 2490 // The types we specifically need to rebuild are: 2491 // - typenames, typeofs, and decltypes 2492 // - types which will become injected class names 2493 // Of course, we also need to rebuild any type referencing such a 2494 // type. It's safest to just say "dependent", but we call out a 2495 // few cases here. 2496 2497 DeclSpec &DS = D.getMutableDeclSpec(); 2498 switch (DS.getTypeSpecType()) { 2499 case DeclSpec::TST_typename: 2500 case DeclSpec::TST_typeofType: 2501 case DeclSpec::TST_decltype: { 2502 // Grab the type from the parser. 2503 TypeSourceInfo *TSI = 0; 2504 QualType T = S.GetTypeFromParser(DS.getRepAsType(), &TSI); 2505 if (T.isNull() || !T->isDependentType()) break; 2506 2507 // Make sure there's a type source info. This isn't really much 2508 // of a waste; most dependent types should have type source info 2509 // attached already. 2510 if (!TSI) 2511 TSI = S.Context.getTrivialTypeSourceInfo(T, DS.getTypeSpecTypeLoc()); 2512 2513 // Rebuild the type in the current instantiation. 2514 TSI = S.RebuildTypeInCurrentInstantiation(TSI, D.getIdentifierLoc(), Name); 2515 if (!TSI) return true; 2516 2517 // Store the new type back in the decl spec. 2518 ParsedType LocType = S.CreateParsedType(TSI->getType(), TSI); 2519 DS.UpdateTypeRep(LocType); 2520 break; 2521 } 2522 2523 case DeclSpec::TST_typeofExpr: { 2524 Expr *E = DS.getRepAsExpr(); 2525 ExprResult Result = S.RebuildExprInCurrentInstantiation(E); 2526 if (Result.isInvalid()) return true; 2527 DS.UpdateExprRep(Result.get()); 2528 break; 2529 } 2530 2531 default: 2532 // Nothing to do for these decl specs. 2533 break; 2534 } 2535 2536 // It doesn't matter what order we do this in. 2537 for (unsigned I = 0, E = D.getNumTypeObjects(); I != E; ++I) { 2538 DeclaratorChunk &Chunk = D.getTypeObject(I); 2539 2540 // The only type information in the declarator which can come 2541 // before the declaration name is the base type of a member 2542 // pointer. 2543 if (Chunk.Kind != DeclaratorChunk::MemberPointer) 2544 continue; 2545 2546 // Rebuild the scope specifier in-place. 2547 CXXScopeSpec &SS = Chunk.Mem.Scope(); 2548 if (S.RebuildNestedNameSpecifierInCurrentInstantiation(SS)) 2549 return true; 2550 } 2551 2552 return false; 2553} 2554 2555Decl *Sema::ActOnDeclarator(Scope *S, Declarator &D) { 2556 return HandleDeclarator(S, D, MultiTemplateParamsArg(*this), false); 2557} 2558 2559/// DiagnoseClassNameShadow - Implement C++ [class.mem]p13: 2560/// If T is the name of a class, then each of the following shall have a 2561/// name different from T: 2562/// - every static data member of class T; 2563/// - every member function of class T 2564/// - every member of class T that is itself a type; 2565/// \returns true if the declaration name violates these rules. 2566bool Sema::DiagnoseClassNameShadow(DeclContext *DC, 2567 DeclarationNameInfo NameInfo) { 2568 DeclarationName Name = NameInfo.getName(); 2569 2570 if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(DC)) 2571 if (Record->getIdentifier() && Record->getDeclName() == Name) { 2572 Diag(NameInfo.getLoc(), diag::err_member_name_of_class) << Name; 2573 return true; 2574 } 2575 2576 return false; 2577} 2578 2579Decl *Sema::HandleDeclarator(Scope *S, Declarator &D, 2580 MultiTemplateParamsArg TemplateParamLists, 2581 bool IsFunctionDefinition) { 2582 // TODO: consider using NameInfo for diagnostic. 2583 DeclarationNameInfo NameInfo = GetNameForDeclarator(D); 2584 DeclarationName Name = NameInfo.getName(); 2585 2586 // All of these full declarators require an identifier. If it doesn't have 2587 // one, the ParsedFreeStandingDeclSpec action should be used. 2588 if (!Name) { 2589 if (!D.isInvalidType()) // Reject this if we think it is valid. 2590 Diag(D.getDeclSpec().getSourceRange().getBegin(), 2591 diag::err_declarator_need_ident) 2592 << D.getDeclSpec().getSourceRange() << D.getSourceRange(); 2593 return 0; 2594 } else if (DiagnoseUnexpandedParameterPack(NameInfo, UPPC_DeclarationType)) 2595 return 0; 2596 2597 // The scope passed in may not be a decl scope. Zip up the scope tree until 2598 // we find one that is. 2599 while ((S->getFlags() & Scope::DeclScope) == 0 || 2600 (S->getFlags() & Scope::TemplateParamScope) != 0) 2601 S = S->getParent(); 2602 2603 DeclContext *DC = CurContext; 2604 if (D.getCXXScopeSpec().isInvalid()) 2605 D.setInvalidType(); 2606 else if (D.getCXXScopeSpec().isSet()) { 2607 if (DiagnoseUnexpandedParameterPack(D.getCXXScopeSpec(), 2608 UPPC_DeclarationQualifier)) 2609 return 0; 2610 2611 bool EnteringContext = !D.getDeclSpec().isFriendSpecified(); 2612 DC = computeDeclContext(D.getCXXScopeSpec(), EnteringContext); 2613 if (!DC) { 2614 // If we could not compute the declaration context, it's because the 2615 // declaration context is dependent but does not refer to a class, 2616 // class template, or class template partial specialization. Complain 2617 // and return early, to avoid the coming semantic disaster. 2618 Diag(D.getIdentifierLoc(), 2619 diag::err_template_qualified_declarator_no_match) 2620 << (NestedNameSpecifier*)D.getCXXScopeSpec().getScopeRep() 2621 << D.getCXXScopeSpec().getRange(); 2622 return 0; 2623 } 2624 2625 bool IsDependentContext = DC->isDependentContext(); 2626 2627 if (!IsDependentContext && 2628 RequireCompleteDeclContext(D.getCXXScopeSpec(), DC)) 2629 return 0; 2630 2631 if (isa<CXXRecordDecl>(DC)) { 2632 if (!cast<CXXRecordDecl>(DC)->hasDefinition()) { 2633 Diag(D.getIdentifierLoc(), 2634 diag::err_member_def_undefined_record) 2635 << Name << DC << D.getCXXScopeSpec().getRange(); 2636 D.setInvalidType(); 2637 } else if (isa<CXXRecordDecl>(CurContext) && 2638 !D.getDeclSpec().isFriendSpecified()) { 2639 // The user provided a superfluous scope specifier inside a class 2640 // definition: 2641 // 2642 // class X { 2643 // void X::f(); 2644 // }; 2645 if (CurContext->Equals(DC)) 2646 Diag(D.getIdentifierLoc(), diag::warn_member_extra_qualification) 2647 << Name << FixItHint::CreateRemoval(D.getCXXScopeSpec().getRange()); 2648 else 2649 Diag(D.getIdentifierLoc(), diag::err_member_qualification) 2650 << Name << D.getCXXScopeSpec().getRange(); 2651 2652 // Pretend that this qualifier was not here. 2653 D.getCXXScopeSpec().clear(); 2654 } 2655 } 2656 2657 // Check whether we need to rebuild the type of the given 2658 // declaration in the current instantiation. 2659 if (EnteringContext && IsDependentContext && 2660 TemplateParamLists.size() != 0) { 2661 ContextRAII SavedContext(*this, DC); 2662 if (RebuildDeclaratorInCurrentInstantiation(*this, D, Name)) 2663 D.setInvalidType(); 2664 } 2665 } 2666 2667 if (DiagnoseClassNameShadow(DC, NameInfo)) 2668 // If this is a typedef, we'll end up spewing multiple diagnostics. 2669 // Just return early; it's safer. 2670 if (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_typedef) 2671 return 0; 2672 2673 NamedDecl *New; 2674 2675 TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S); 2676 QualType R = TInfo->getType(); 2677 2678 if (DiagnoseUnexpandedParameterPack(D.getIdentifierLoc(), TInfo, 2679 UPPC_DeclarationType)) 2680 D.setInvalidType(); 2681 2682 LookupResult Previous(*this, NameInfo, LookupOrdinaryName, 2683 ForRedeclaration); 2684 2685 // See if this is a redefinition of a variable in the same scope. 2686 if (!D.getCXXScopeSpec().isSet()) { 2687 bool IsLinkageLookup = false; 2688 2689 // If the declaration we're planning to build will be a function 2690 // or object with linkage, then look for another declaration with 2691 // linkage (C99 6.2.2p4-5 and C++ [basic.link]p6). 2692 if (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_typedef) 2693 /* Do nothing*/; 2694 else if (R->isFunctionType()) { 2695 if (CurContext->isFunctionOrMethod() || 2696 D.getDeclSpec().getStorageClassSpec() != DeclSpec::SCS_static) 2697 IsLinkageLookup = true; 2698 } else if (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_extern) 2699 IsLinkageLookup = true; 2700 else if (CurContext->getRedeclContext()->isTranslationUnit() && 2701 D.getDeclSpec().getStorageClassSpec() != DeclSpec::SCS_static) 2702 IsLinkageLookup = true; 2703 2704 if (IsLinkageLookup) 2705 Previous.clear(LookupRedeclarationWithLinkage); 2706 2707 LookupName(Previous, S, /* CreateBuiltins = */ IsLinkageLookup); 2708 } else { // Something like "int foo::x;" 2709 LookupQualifiedName(Previous, DC); 2710 2711 // Don't consider using declarations as previous declarations for 2712 // out-of-line members. 2713 RemoveUsingDecls(Previous); 2714 2715 // C++ 7.3.1.2p2: 2716 // Members (including explicit specializations of templates) of a named 2717 // namespace can also be defined outside that namespace by explicit 2718 // qualification of the name being defined, provided that the entity being 2719 // defined was already declared in the namespace and the definition appears 2720 // after the point of declaration in a namespace that encloses the 2721 // declarations namespace. 2722 // 2723 // Note that we only check the context at this point. We don't yet 2724 // have enough information to make sure that PrevDecl is actually 2725 // the declaration we want to match. For example, given: 2726 // 2727 // class X { 2728 // void f(); 2729 // void f(float); 2730 // }; 2731 // 2732 // void X::f(int) { } // ill-formed 2733 // 2734 // In this case, PrevDecl will point to the overload set 2735 // containing the two f's declared in X, but neither of them 2736 // matches. 2737 2738 // First check whether we named the global scope. 2739 if (isa<TranslationUnitDecl>(DC)) { 2740 Diag(D.getIdentifierLoc(), diag::err_invalid_declarator_global_scope) 2741 << Name << D.getCXXScopeSpec().getRange(); 2742 } else { 2743 DeclContext *Cur = CurContext; 2744 while (isa<LinkageSpecDecl>(Cur)) 2745 Cur = Cur->getParent(); 2746 if (!Cur->Encloses(DC)) { 2747 // The qualifying scope doesn't enclose the original declaration. 2748 // Emit diagnostic based on current scope. 2749 SourceLocation L = D.getIdentifierLoc(); 2750 SourceRange R = D.getCXXScopeSpec().getRange(); 2751 if (isa<FunctionDecl>(Cur)) 2752 Diag(L, diag::err_invalid_declarator_in_function) << Name << R; 2753 else 2754 Diag(L, diag::err_invalid_declarator_scope) 2755 << Name << cast<NamedDecl>(DC) << R; 2756 D.setInvalidType(); 2757 } 2758 } 2759 } 2760 2761 if (Previous.isSingleResult() && 2762 Previous.getFoundDecl()->isTemplateParameter()) { 2763 // Maybe we will complain about the shadowed template parameter. 2764 if (!D.isInvalidType()) 2765 if (DiagnoseTemplateParameterShadow(D.getIdentifierLoc(), 2766 Previous.getFoundDecl())) 2767 D.setInvalidType(); 2768 2769 // Just pretend that we didn't see the previous declaration. 2770 Previous.clear(); 2771 } 2772 2773 // In C++, the previous declaration we find might be a tag type 2774 // (class or enum). In this case, the new declaration will hide the 2775 // tag type. Note that this does does not apply if we're declaring a 2776 // typedef (C++ [dcl.typedef]p4). 2777 if (Previous.isSingleTagDecl() && 2778 D.getDeclSpec().getStorageClassSpec() != DeclSpec::SCS_typedef) 2779 Previous.clear(); 2780 2781 bool Redeclaration = false; 2782 if (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_typedef) { 2783 if (TemplateParamLists.size()) { 2784 Diag(D.getIdentifierLoc(), diag::err_template_typedef); 2785 return 0; 2786 } 2787 2788 New = ActOnTypedefDeclarator(S, D, DC, R, TInfo, Previous, Redeclaration); 2789 } else if (R->isFunctionType()) { 2790 New = ActOnFunctionDeclarator(S, D, DC, R, TInfo, Previous, 2791 move(TemplateParamLists), 2792 IsFunctionDefinition, Redeclaration); 2793 } else { 2794 New = ActOnVariableDeclarator(S, D, DC, R, TInfo, Previous, 2795 move(TemplateParamLists), 2796 Redeclaration); 2797 } 2798 2799 if (New == 0) 2800 return 0; 2801 2802 // If this has an identifier and is not an invalid redeclaration or 2803 // function template specialization, add it to the scope stack. 2804 if (New->getDeclName() && !(Redeclaration && New->isInvalidDecl())) 2805 PushOnScopeChains(New, S); 2806 2807 return New; 2808} 2809 2810/// TryToFixInvalidVariablyModifiedType - Helper method to turn variable array 2811/// types into constant array types in certain situations which would otherwise 2812/// be errors (for GCC compatibility). 2813static QualType TryToFixInvalidVariablyModifiedType(QualType T, 2814 ASTContext &Context, 2815 bool &SizeIsNegative, 2816 llvm::APSInt &Oversized) { 2817 // This method tries to turn a variable array into a constant 2818 // array even when the size isn't an ICE. This is necessary 2819 // for compatibility with code that depends on gcc's buggy 2820 // constant expression folding, like struct {char x[(int)(char*)2];} 2821 SizeIsNegative = false; 2822 Oversized = 0; 2823 2824 if (T->isDependentType()) 2825 return QualType(); 2826 2827 QualifierCollector Qs; 2828 const Type *Ty = Qs.strip(T); 2829 2830 if (const PointerType* PTy = dyn_cast<PointerType>(Ty)) { 2831 QualType Pointee = PTy->getPointeeType(); 2832 QualType FixedType = 2833 TryToFixInvalidVariablyModifiedType(Pointee, Context, SizeIsNegative, 2834 Oversized); 2835 if (FixedType.isNull()) return FixedType; 2836 FixedType = Context.getPointerType(FixedType); 2837 return Qs.apply(Context, FixedType); 2838 } 2839 if (const ParenType* PTy = dyn_cast<ParenType>(Ty)) { 2840 QualType Inner = PTy->getInnerType(); 2841 QualType FixedType = 2842 TryToFixInvalidVariablyModifiedType(Inner, Context, SizeIsNegative, 2843 Oversized); 2844 if (FixedType.isNull()) return FixedType; 2845 FixedType = Context.getParenType(FixedType); 2846 return Qs.apply(Context, FixedType); 2847 } 2848 2849 const VariableArrayType* VLATy = dyn_cast<VariableArrayType>(T); 2850 if (!VLATy) 2851 return QualType(); 2852 // FIXME: We should probably handle this case 2853 if (VLATy->getElementType()->isVariablyModifiedType()) 2854 return QualType(); 2855 2856 Expr::EvalResult EvalResult; 2857 if (!VLATy->getSizeExpr() || 2858 !VLATy->getSizeExpr()->Evaluate(EvalResult, Context) || 2859 !EvalResult.Val.isInt()) 2860 return QualType(); 2861 2862 // Check whether the array size is negative. 2863 llvm::APSInt &Res = EvalResult.Val.getInt(); 2864 if (Res.isSigned() && Res.isNegative()) { 2865 SizeIsNegative = true; 2866 return QualType(); 2867 } 2868 2869 // Check whether the array is too large to be addressed. 2870 unsigned ActiveSizeBits 2871 = ConstantArrayType::getNumAddressingBits(Context, VLATy->getElementType(), 2872 Res); 2873 if (ActiveSizeBits > ConstantArrayType::getMaxSizeBits(Context)) { 2874 Oversized = Res; 2875 return QualType(); 2876 } 2877 2878 return Context.getConstantArrayType(VLATy->getElementType(), 2879 Res, ArrayType::Normal, 0); 2880} 2881 2882/// \brief Register the given locally-scoped external C declaration so 2883/// that it can be found later for redeclarations 2884void 2885Sema::RegisterLocallyScopedExternCDecl(NamedDecl *ND, 2886 const LookupResult &Previous, 2887 Scope *S) { 2888 assert(ND->getLexicalDeclContext()->isFunctionOrMethod() && 2889 "Decl is not a locally-scoped decl!"); 2890 // Note that we have a locally-scoped external with this name. 2891 LocallyScopedExternalDecls[ND->getDeclName()] = ND; 2892 2893 if (!Previous.isSingleResult()) 2894 return; 2895 2896 NamedDecl *PrevDecl = Previous.getFoundDecl(); 2897 2898 // If there was a previous declaration of this variable, it may be 2899 // in our identifier chain. Update the identifier chain with the new 2900 // declaration. 2901 if (S && IdResolver.ReplaceDecl(PrevDecl, ND)) { 2902 // The previous declaration was found on the identifer resolver 2903 // chain, so remove it from its scope. 2904 while (S && !S->isDeclScope(PrevDecl)) 2905 S = S->getParent(); 2906 2907 if (S) 2908 S->RemoveDecl(PrevDecl); 2909 } 2910} 2911 2912/// \brief Diagnose function specifiers on a declaration of an identifier that 2913/// does not identify a function. 2914void Sema::DiagnoseFunctionSpecifiers(Declarator& D) { 2915 // FIXME: We should probably indicate the identifier in question to avoid 2916 // confusion for constructs like "inline int a(), b;" 2917 if (D.getDeclSpec().isInlineSpecified()) 2918 Diag(D.getDeclSpec().getInlineSpecLoc(), 2919 diag::err_inline_non_function); 2920 2921 if (D.getDeclSpec().isVirtualSpecified()) 2922 Diag(D.getDeclSpec().getVirtualSpecLoc(), 2923 diag::err_virtual_non_function); 2924 2925 if (D.getDeclSpec().isExplicitSpecified()) 2926 Diag(D.getDeclSpec().getExplicitSpecLoc(), 2927 diag::err_explicit_non_function); 2928} 2929 2930NamedDecl* 2931Sema::ActOnTypedefDeclarator(Scope* S, Declarator& D, DeclContext* DC, 2932 QualType R, TypeSourceInfo *TInfo, 2933 LookupResult &Previous, bool &Redeclaration) { 2934 // Typedef declarators cannot be qualified (C++ [dcl.meaning]p1). 2935 if (D.getCXXScopeSpec().isSet()) { 2936 Diag(D.getIdentifierLoc(), diag::err_qualified_typedef_declarator) 2937 << D.getCXXScopeSpec().getRange(); 2938 D.setInvalidType(); 2939 // Pretend we didn't see the scope specifier. 2940 DC = CurContext; 2941 Previous.clear(); 2942 } 2943 2944 if (getLangOptions().CPlusPlus) { 2945 // Check that there are no default arguments (C++ only). 2946 CheckExtraCXXDefaultArguments(D); 2947 } 2948 2949 DiagnoseFunctionSpecifiers(D); 2950 2951 if (D.getDeclSpec().isThreadSpecified()) 2952 Diag(D.getDeclSpec().getThreadSpecLoc(), diag::err_invalid_thread); 2953 2954 if (D.getName().Kind != UnqualifiedId::IK_Identifier) { 2955 Diag(D.getName().StartLocation, diag::err_typedef_not_identifier) 2956 << D.getName().getSourceRange(); 2957 return 0; 2958 } 2959 2960 TypedefDecl *NewTD = ParseTypedefDecl(S, D, R, TInfo); 2961 if (!NewTD) return 0; 2962 2963 // Handle attributes prior to checking for duplicates in MergeVarDecl 2964 ProcessDeclAttributes(S, NewTD, D); 2965 2966 return ActOnTypedefNameDecl(S, DC, NewTD, Previous, Redeclaration); 2967} 2968 2969/// ActOnTypedefNameDecl - Perform semantic checking for a declaration which 2970/// declares a typedef-name, either using the 'typedef' type specifier or via 2971/// a C++0x [dcl.typedef]p2 alias-declaration: 'using T = A;'. 2972NamedDecl* 2973Sema::ActOnTypedefNameDecl(Scope *S, DeclContext *DC, TypedefNameDecl *NewTD, 2974 LookupResult &Previous, bool &Redeclaration) { 2975 // C99 6.7.7p2: If a typedef name specifies a variably modified type 2976 // then it shall have block scope. 2977 // Note that variably modified types must be fixed before merging the decl so 2978 // that redeclarations will match. 2979 QualType T = NewTD->getUnderlyingType(); 2980 if (T->isVariablyModifiedType()) { 2981 getCurFunction()->setHasBranchProtectedScope(); 2982 2983 if (S->getFnParent() == 0) { 2984 bool SizeIsNegative; 2985 llvm::APSInt Oversized; 2986 QualType FixedTy = 2987 TryToFixInvalidVariablyModifiedType(T, Context, SizeIsNegative, 2988 Oversized); 2989 if (!FixedTy.isNull()) { 2990 Diag(NewTD->getLocation(), diag::warn_illegal_constant_array_size); 2991 NewTD->setTypeSourceInfo(Context.getTrivialTypeSourceInfo(FixedTy)); 2992 } else { 2993 if (SizeIsNegative) 2994 Diag(NewTD->getLocation(), diag::err_typecheck_negative_array_size); 2995 else if (T->isVariableArrayType()) 2996 Diag(NewTD->getLocation(), diag::err_vla_decl_in_file_scope); 2997 else if (Oversized.getBoolValue()) 2998 Diag(NewTD->getLocation(), diag::err_array_too_large) << Oversized.toString(10); 2999 else 3000 Diag(NewTD->getLocation(), diag::err_vm_decl_in_file_scope); 3001 NewTD->setInvalidDecl(); 3002 } 3003 } 3004 } 3005 3006 // Merge the decl with the existing one if appropriate. If the decl is 3007 // in an outer scope, it isn't the same thing. 3008 FilterLookupForScope(*this, Previous, DC, S, /*ConsiderLinkage*/ false, 3009 /*ExplicitInstantiationOrSpecialization=*/false); 3010 if (!Previous.empty()) { 3011 Redeclaration = true; 3012 MergeTypedefNameDecl(NewTD, Previous); 3013 } 3014 3015 // If this is the C FILE type, notify the AST context. 3016 if (IdentifierInfo *II = NewTD->getIdentifier()) 3017 if (!NewTD->isInvalidDecl() && 3018 NewTD->getDeclContext()->getRedeclContext()->isTranslationUnit()) { 3019 if (II->isStr("FILE")) 3020 Context.setFILEDecl(NewTD); 3021 else if (II->isStr("jmp_buf")) 3022 Context.setjmp_bufDecl(NewTD); 3023 else if (II->isStr("sigjmp_buf")) 3024 Context.setsigjmp_bufDecl(NewTD); 3025 else if (II->isStr("__builtin_va_list")) 3026 Context.setBuiltinVaListType(Context.getTypedefType(NewTD)); 3027 } 3028 3029 return NewTD; 3030} 3031 3032/// \brief Determines whether the given declaration is an out-of-scope 3033/// previous declaration. 3034/// 3035/// This routine should be invoked when name lookup has found a 3036/// previous declaration (PrevDecl) that is not in the scope where a 3037/// new declaration by the same name is being introduced. If the new 3038/// declaration occurs in a local scope, previous declarations with 3039/// linkage may still be considered previous declarations (C99 3040/// 6.2.2p4-5, C++ [basic.link]p6). 3041/// 3042/// \param PrevDecl the previous declaration found by name 3043/// lookup 3044/// 3045/// \param DC the context in which the new declaration is being 3046/// declared. 3047/// 3048/// \returns true if PrevDecl is an out-of-scope previous declaration 3049/// for a new delcaration with the same name. 3050static bool 3051isOutOfScopePreviousDeclaration(NamedDecl *PrevDecl, DeclContext *DC, 3052 ASTContext &Context) { 3053 if (!PrevDecl) 3054 return false; 3055 3056 if (!PrevDecl->hasLinkage()) 3057 return false; 3058 3059 if (Context.getLangOptions().CPlusPlus) { 3060 // C++ [basic.link]p6: 3061 // If there is a visible declaration of an entity with linkage 3062 // having the same name and type, ignoring entities declared 3063 // outside the innermost enclosing namespace scope, the block 3064 // scope declaration declares that same entity and receives the 3065 // linkage of the previous declaration. 3066 DeclContext *OuterContext = DC->getRedeclContext(); 3067 if (!OuterContext->isFunctionOrMethod()) 3068 // This rule only applies to block-scope declarations. 3069 return false; 3070 3071 DeclContext *PrevOuterContext = PrevDecl->getDeclContext(); 3072 if (PrevOuterContext->isRecord()) 3073 // We found a member function: ignore it. 3074 return false; 3075 3076 // Find the innermost enclosing namespace for the new and 3077 // previous declarations. 3078 OuterContext = OuterContext->getEnclosingNamespaceContext(); 3079 PrevOuterContext = PrevOuterContext->getEnclosingNamespaceContext(); 3080 3081 // The previous declaration is in a different namespace, so it 3082 // isn't the same function. 3083 if (!OuterContext->Equals(PrevOuterContext)) 3084 return false; 3085 } 3086 3087 return true; 3088} 3089 3090static void SetNestedNameSpecifier(DeclaratorDecl *DD, Declarator &D) { 3091 CXXScopeSpec &SS = D.getCXXScopeSpec(); 3092 if (!SS.isSet()) return; 3093 DD->setQualifierInfo(SS.getWithLocInContext(DD->getASTContext())); 3094} 3095 3096NamedDecl* 3097Sema::ActOnVariableDeclarator(Scope *S, Declarator &D, DeclContext *DC, 3098 QualType R, TypeSourceInfo *TInfo, 3099 LookupResult &Previous, 3100 MultiTemplateParamsArg TemplateParamLists, 3101 bool &Redeclaration) { 3102 DeclarationName Name = GetNameForDeclarator(D).getName(); 3103 3104 // Check that there are no default arguments (C++ only). 3105 if (getLangOptions().CPlusPlus) 3106 CheckExtraCXXDefaultArguments(D); 3107 3108 DeclSpec::SCS SCSpec = D.getDeclSpec().getStorageClassSpec(); 3109 assert(SCSpec != DeclSpec::SCS_typedef && 3110 "Parser allowed 'typedef' as storage class VarDecl."); 3111 VarDecl::StorageClass SC = StorageClassSpecToVarDeclStorageClass(SCSpec); 3112 if (SCSpec == DeclSpec::SCS_mutable) { 3113 // mutable can only appear on non-static class members, so it's always 3114 // an error here 3115 Diag(D.getIdentifierLoc(), diag::err_mutable_nonmember); 3116 D.setInvalidType(); 3117 SC = SC_None; 3118 } 3119 SCSpec = D.getDeclSpec().getStorageClassSpecAsWritten(); 3120 VarDecl::StorageClass SCAsWritten 3121 = StorageClassSpecToVarDeclStorageClass(SCSpec); 3122 3123 IdentifierInfo *II = Name.getAsIdentifierInfo(); 3124 if (!II) { 3125 Diag(D.getIdentifierLoc(), diag::err_bad_variable_name) 3126 << Name.getAsString(); 3127 return 0; 3128 } 3129 3130 DiagnoseFunctionSpecifiers(D); 3131 3132 if (!DC->isRecord() && S->getFnParent() == 0) { 3133 // C99 6.9p2: The storage-class specifiers auto and register shall not 3134 // appear in the declaration specifiers in an external declaration. 3135 if (SC == SC_Auto || SC == SC_Register) { 3136 3137 // If this is a register variable with an asm label specified, then this 3138 // is a GNU extension. 3139 if (SC == SC_Register && D.getAsmLabel()) 3140 Diag(D.getIdentifierLoc(), diag::err_unsupported_global_register); 3141 else 3142 Diag(D.getIdentifierLoc(), diag::err_typecheck_sclass_fscope); 3143 D.setInvalidType(); 3144 } 3145 } 3146 3147 bool isExplicitSpecialization = false; 3148 VarDecl *NewVD; 3149 if (!getLangOptions().CPlusPlus) { 3150 NewVD = VarDecl::Create(Context, DC, D.getSourceRange().getBegin(), 3151 D.getIdentifierLoc(), II, 3152 R, TInfo, SC, SCAsWritten); 3153 3154 if (D.isInvalidType()) 3155 NewVD->setInvalidDecl(); 3156 } else { 3157 if (DC->isRecord() && !CurContext->isRecord()) { 3158 // This is an out-of-line definition of a static data member. 3159 if (SC == SC_Static) { 3160 Diag(D.getDeclSpec().getStorageClassSpecLoc(), 3161 diag::err_static_out_of_line) 3162 << FixItHint::CreateRemoval(D.getDeclSpec().getStorageClassSpecLoc()); 3163 } else if (SC == SC_None) 3164 SC = SC_Static; 3165 } 3166 if (SC == SC_Static) { 3167 if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(DC)) { 3168 if (RD->isLocalClass()) 3169 Diag(D.getIdentifierLoc(), 3170 diag::err_static_data_member_not_allowed_in_local_class) 3171 << Name << RD->getDeclName(); 3172 3173 // C++ [class.union]p1: If a union contains a static data member, 3174 // the program is ill-formed. 3175 // 3176 // We also disallow static data members in anonymous structs. 3177 if (CurContext->isRecord() && (RD->isUnion() || !RD->getDeclName())) 3178 Diag(D.getIdentifierLoc(), 3179 diag::err_static_data_member_not_allowed_in_union_or_anon_struct) 3180 << Name << RD->isUnion(); 3181 } 3182 } 3183 3184 // Match up the template parameter lists with the scope specifier, then 3185 // determine whether we have a template or a template specialization. 3186 isExplicitSpecialization = false; 3187 bool Invalid = false; 3188 if (TemplateParameterList *TemplateParams 3189 = MatchTemplateParametersToScopeSpecifier( 3190 D.getDeclSpec().getSourceRange().getBegin(), 3191 D.getCXXScopeSpec(), 3192 TemplateParamLists.get(), 3193 TemplateParamLists.size(), 3194 /*never a friend*/ false, 3195 isExplicitSpecialization, 3196 Invalid)) { 3197 if (TemplateParams->size() > 0) { 3198 // There is no such thing as a variable template. 3199 Diag(D.getIdentifierLoc(), diag::err_template_variable) 3200 << II 3201 << SourceRange(TemplateParams->getTemplateLoc(), 3202 TemplateParams->getRAngleLoc()); 3203 return 0; 3204 } else { 3205 // There is an extraneous 'template<>' for this variable. Complain 3206 // about it, but allow the declaration of the variable. 3207 Diag(TemplateParams->getTemplateLoc(), 3208 diag::err_template_variable_noparams) 3209 << II 3210 << SourceRange(TemplateParams->getTemplateLoc(), 3211 TemplateParams->getRAngleLoc()); 3212 isExplicitSpecialization = true; 3213 } 3214 } 3215 3216 NewVD = VarDecl::Create(Context, DC, D.getSourceRange().getBegin(), 3217 D.getIdentifierLoc(), II, 3218 R, TInfo, SC, SCAsWritten); 3219 3220 // If this decl has an auto type in need of deduction, make a note of the 3221 // Decl so we can diagnose uses of it in its own initializer. 3222 if (D.getDeclSpec().getTypeSpecType() == DeclSpec::TST_auto && 3223 R->getContainedAutoType()) 3224 ParsingInitForAutoVars.insert(NewVD); 3225 3226 if (D.isInvalidType() || Invalid) 3227 NewVD->setInvalidDecl(); 3228 3229 SetNestedNameSpecifier(NewVD, D); 3230 3231 if (TemplateParamLists.size() > 0 && D.getCXXScopeSpec().isSet()) { 3232 NewVD->setTemplateParameterListsInfo(Context, 3233 TemplateParamLists.size(), 3234 TemplateParamLists.release()); 3235 } 3236 } 3237 3238 if (D.getDeclSpec().isThreadSpecified()) { 3239 if (NewVD->hasLocalStorage()) 3240 Diag(D.getDeclSpec().getThreadSpecLoc(), diag::err_thread_non_global); 3241 else if (!Context.Target.isTLSSupported()) 3242 Diag(D.getDeclSpec().getThreadSpecLoc(), diag::err_thread_unsupported); 3243 else 3244 NewVD->setThreadSpecified(true); 3245 } 3246 3247 // Set the lexical context. If the declarator has a C++ scope specifier, the 3248 // lexical context will be different from the semantic context. 3249 NewVD->setLexicalDeclContext(CurContext); 3250 3251 // Handle attributes prior to checking for duplicates in MergeVarDecl 3252 ProcessDeclAttributes(S, NewVD, D); 3253 3254 // Handle GNU asm-label extension (encoded as an attribute). 3255 if (Expr *E = (Expr*)D.getAsmLabel()) { 3256 // The parser guarantees this is a string. 3257 StringLiteral *SE = cast<StringLiteral>(E); 3258 llvm::StringRef Label = SE->getString(); 3259 if (S->getFnParent() != 0) { 3260 switch (SC) { 3261 case SC_None: 3262 case SC_Auto: 3263 Diag(E->getExprLoc(), diag::warn_asm_label_on_auto_decl) << Label; 3264 break; 3265 case SC_Register: 3266 if (!Context.Target.isValidGCCRegisterName(Label)) 3267 Diag(E->getExprLoc(), diag::err_asm_unknown_register_name) << Label; 3268 break; 3269 case SC_Static: 3270 case SC_Extern: 3271 case SC_PrivateExtern: 3272 break; 3273 } 3274 } 3275 3276 NewVD->addAttr(::new (Context) AsmLabelAttr(SE->getStrTokenLoc(0), 3277 Context, Label)); 3278 } 3279 3280 // Diagnose shadowed variables before filtering for scope. 3281 if (!D.getCXXScopeSpec().isSet()) 3282 CheckShadow(S, NewVD, Previous); 3283 3284 // Don't consider existing declarations that are in a different 3285 // scope and are out-of-semantic-context declarations (if the new 3286 // declaration has linkage). 3287 FilterLookupForScope(*this, Previous, DC, S, NewVD->hasLinkage(), 3288 isExplicitSpecialization); 3289 3290 if (!getLangOptions().CPlusPlus) 3291 CheckVariableDeclaration(NewVD, Previous, Redeclaration); 3292 else { 3293 // Merge the decl with the existing one if appropriate. 3294 if (!Previous.empty()) { 3295 if (Previous.isSingleResult() && 3296 isa<FieldDecl>(Previous.getFoundDecl()) && 3297 D.getCXXScopeSpec().isSet()) { 3298 // The user tried to define a non-static data member 3299 // out-of-line (C++ [dcl.meaning]p1). 3300 Diag(NewVD->getLocation(), diag::err_nonstatic_member_out_of_line) 3301 << D.getCXXScopeSpec().getRange(); 3302 Previous.clear(); 3303 NewVD->setInvalidDecl(); 3304 } 3305 } else if (D.getCXXScopeSpec().isSet()) { 3306 // No previous declaration in the qualifying scope. 3307 Diag(D.getIdentifierLoc(), diag::err_no_member) 3308 << Name << computeDeclContext(D.getCXXScopeSpec(), true) 3309 << D.getCXXScopeSpec().getRange(); 3310 NewVD->setInvalidDecl(); 3311 } 3312 3313 CheckVariableDeclaration(NewVD, Previous, Redeclaration); 3314 3315 // This is an explicit specialization of a static data member. Check it. 3316 if (isExplicitSpecialization && !NewVD->isInvalidDecl() && 3317 CheckMemberSpecialization(NewVD, Previous)) 3318 NewVD->setInvalidDecl(); 3319 } 3320 3321 // attributes declared post-definition are currently ignored 3322 // FIXME: This should be handled in attribute merging, not 3323 // here. 3324 if (Previous.isSingleResult()) { 3325 VarDecl *Def = dyn_cast<VarDecl>(Previous.getFoundDecl()); 3326 if (Def && (Def = Def->getDefinition()) && 3327 Def != NewVD && D.hasAttributes()) { 3328 Diag(NewVD->getLocation(), diag::warn_attribute_precede_definition); 3329 Diag(Def->getLocation(), diag::note_previous_definition); 3330 } 3331 } 3332 3333 // If this is a locally-scoped extern C variable, update the map of 3334 // such variables. 3335 if (CurContext->isFunctionOrMethod() && NewVD->isExternC() && 3336 !NewVD->isInvalidDecl()) 3337 RegisterLocallyScopedExternCDecl(NewVD, Previous, S); 3338 3339 // If there's a #pragma GCC visibility in scope, and this isn't a class 3340 // member, set the visibility of this variable. 3341 if (NewVD->getLinkage() == ExternalLinkage && !DC->isRecord()) 3342 AddPushedVisibilityAttribute(NewVD); 3343 3344 MarkUnusedFileScopedDecl(NewVD); 3345 3346 return NewVD; 3347} 3348 3349/// \brief Diagnose variable or built-in function shadowing. Implements 3350/// -Wshadow. 3351/// 3352/// This method is called whenever a VarDecl is added to a "useful" 3353/// scope. 3354/// 3355/// \param S the scope in which the shadowing name is being declared 3356/// \param R the lookup of the name 3357/// 3358void Sema::CheckShadow(Scope *S, VarDecl *D, const LookupResult& R) { 3359 // Return if warning is ignored. 3360 if (Diags.getDiagnosticLevel(diag::warn_decl_shadow, R.getNameLoc()) == 3361 Diagnostic::Ignored) 3362 return; 3363 3364 // Don't diagnose declarations at file scope. 3365 DeclContext *NewDC = D->getDeclContext(); 3366 if (NewDC->isFileContext()) 3367 return; 3368 3369 // Only diagnose if we're shadowing an unambiguous field or variable. 3370 if (R.getResultKind() != LookupResult::Found) 3371 return; 3372 3373 NamedDecl* ShadowedDecl = R.getFoundDecl(); 3374 if (!isa<VarDecl>(ShadowedDecl) && !isa<FieldDecl>(ShadowedDecl)) 3375 return; 3376 3377 // Fields are not shadowed by variables in C++ static methods. 3378 if (isa<FieldDecl>(ShadowedDecl)) 3379 if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(NewDC)) 3380 if (MD->isStatic()) 3381 return; 3382 3383 if (VarDecl *shadowedVar = dyn_cast<VarDecl>(ShadowedDecl)) 3384 if (shadowedVar->isExternC()) { 3385 // Don't warn for this case: 3386 // 3387 // @code 3388 // extern int bob; 3389 // void f() { 3390 // extern int bob; 3391 // } 3392 // @endcode 3393 if (D->isExternC()) 3394 return; 3395 3396 // For shadowing external vars, make sure that we point to the global 3397 // declaration, not a locally scoped extern declaration. 3398 for (VarDecl::redecl_iterator 3399 I = shadowedVar->redecls_begin(), E = shadowedVar->redecls_end(); 3400 I != E; ++I) 3401 if (I->isFileVarDecl()) { 3402 ShadowedDecl = *I; 3403 break; 3404 } 3405 } 3406 3407 DeclContext *OldDC = ShadowedDecl->getDeclContext(); 3408 3409 // Only warn about certain kinds of shadowing for class members. 3410 if (NewDC && NewDC->isRecord()) { 3411 // In particular, don't warn about shadowing non-class members. 3412 if (!OldDC->isRecord()) 3413 return; 3414 3415 // TODO: should we warn about static data members shadowing 3416 // static data members from base classes? 3417 3418 // TODO: don't diagnose for inaccessible shadowed members. 3419 // This is hard to do perfectly because we might friend the 3420 // shadowing context, but that's just a false negative. 3421 } 3422 3423 // Determine what kind of declaration we're shadowing. 3424 unsigned Kind; 3425 if (isa<RecordDecl>(OldDC)) { 3426 if (isa<FieldDecl>(ShadowedDecl)) 3427 Kind = 3; // field 3428 else 3429 Kind = 2; // static data member 3430 } else if (OldDC->isFileContext()) 3431 Kind = 1; // global 3432 else 3433 Kind = 0; // local 3434 3435 DeclarationName Name = R.getLookupName(); 3436 3437 // Emit warning and note. 3438 Diag(R.getNameLoc(), diag::warn_decl_shadow) << Name << Kind << OldDC; 3439 Diag(ShadowedDecl->getLocation(), diag::note_previous_declaration); 3440} 3441 3442/// \brief Check -Wshadow without the advantage of a previous lookup. 3443void Sema::CheckShadow(Scope *S, VarDecl *D) { 3444 if (Diags.getDiagnosticLevel(diag::warn_decl_shadow, D->getLocation()) == 3445 Diagnostic::Ignored) 3446 return; 3447 3448 LookupResult R(*this, D->getDeclName(), D->getLocation(), 3449 Sema::LookupOrdinaryName, Sema::ForRedeclaration); 3450 LookupName(R, S); 3451 CheckShadow(S, D, R); 3452} 3453 3454/// \brief Perform semantic checking on a newly-created variable 3455/// declaration. 3456/// 3457/// This routine performs all of the type-checking required for a 3458/// variable declaration once it has been built. It is used both to 3459/// check variables after they have been parsed and their declarators 3460/// have been translated into a declaration, and to check variables 3461/// that have been instantiated from a template. 3462/// 3463/// Sets NewVD->isInvalidDecl() if an error was encountered. 3464void Sema::CheckVariableDeclaration(VarDecl *NewVD, 3465 LookupResult &Previous, 3466 bool &Redeclaration) { 3467 // If the decl is already known invalid, don't check it. 3468 if (NewVD->isInvalidDecl()) 3469 return; 3470 3471 QualType T = NewVD->getType(); 3472 3473 if (T->isObjCObjectType()) { 3474 Diag(NewVD->getLocation(), diag::err_statically_allocated_object); 3475 return NewVD->setInvalidDecl(); 3476 } 3477 3478 // Emit an error if an address space was applied to decl with local storage. 3479 // This includes arrays of objects with address space qualifiers, but not 3480 // automatic variables that point to other address spaces. 3481 // ISO/IEC TR 18037 S5.1.2 3482 if (NewVD->hasLocalStorage() && T.getAddressSpace() != 0) { 3483 Diag(NewVD->getLocation(), diag::err_as_qualified_auto_decl); 3484 return NewVD->setInvalidDecl(); 3485 } 3486 3487 if (NewVD->hasLocalStorage() && T.isObjCGCWeak() 3488 && !NewVD->hasAttr<BlocksAttr>()) 3489 Diag(NewVD->getLocation(), diag::warn_attribute_weak_on_local); 3490 3491 bool isVM = T->isVariablyModifiedType(); 3492 if (isVM || NewVD->hasAttr<CleanupAttr>() || 3493 NewVD->hasAttr<BlocksAttr>()) 3494 getCurFunction()->setHasBranchProtectedScope(); 3495 3496 if ((isVM && NewVD->hasLinkage()) || 3497 (T->isVariableArrayType() && NewVD->hasGlobalStorage())) { 3498 bool SizeIsNegative; 3499 llvm::APSInt Oversized; 3500 QualType FixedTy = 3501 TryToFixInvalidVariablyModifiedType(T, Context, SizeIsNegative, 3502 Oversized); 3503 3504 if (FixedTy.isNull() && T->isVariableArrayType()) { 3505 const VariableArrayType *VAT = Context.getAsVariableArrayType(T); 3506 // FIXME: This won't give the correct result for 3507 // int a[10][n]; 3508 SourceRange SizeRange = VAT->getSizeExpr()->getSourceRange(); 3509 3510 if (NewVD->isFileVarDecl()) 3511 Diag(NewVD->getLocation(), diag::err_vla_decl_in_file_scope) 3512 << SizeRange; 3513 else if (NewVD->getStorageClass() == SC_Static) 3514 Diag(NewVD->getLocation(), diag::err_vla_decl_has_static_storage) 3515 << SizeRange; 3516 else 3517 Diag(NewVD->getLocation(), diag::err_vla_decl_has_extern_linkage) 3518 << SizeRange; 3519 return NewVD->setInvalidDecl(); 3520 } 3521 3522 if (FixedTy.isNull()) { 3523 if (NewVD->isFileVarDecl()) 3524 Diag(NewVD->getLocation(), diag::err_vm_decl_in_file_scope); 3525 else 3526 Diag(NewVD->getLocation(), diag::err_vm_decl_has_extern_linkage); 3527 return NewVD->setInvalidDecl(); 3528 } 3529 3530 Diag(NewVD->getLocation(), diag::warn_illegal_constant_array_size); 3531 NewVD->setType(FixedTy); 3532 } 3533 3534 if (Previous.empty() && NewVD->isExternC()) { 3535 // Since we did not find anything by this name and we're declaring 3536 // an extern "C" variable, look for a non-visible extern "C" 3537 // declaration with the same name. 3538 llvm::DenseMap<DeclarationName, NamedDecl *>::iterator Pos 3539 = LocallyScopedExternalDecls.find(NewVD->getDeclName()); 3540 if (Pos != LocallyScopedExternalDecls.end()) 3541 Previous.addDecl(Pos->second); 3542 } 3543 3544 if (T->isVoidType() && !NewVD->hasExternalStorage()) { 3545 Diag(NewVD->getLocation(), diag::err_typecheck_decl_incomplete_type) 3546 << T; 3547 return NewVD->setInvalidDecl(); 3548 } 3549 3550 if (!NewVD->hasLocalStorage() && NewVD->hasAttr<BlocksAttr>()) { 3551 Diag(NewVD->getLocation(), diag::err_block_on_nonlocal); 3552 return NewVD->setInvalidDecl(); 3553 } 3554 3555 if (isVM && NewVD->hasAttr<BlocksAttr>()) { 3556 Diag(NewVD->getLocation(), diag::err_block_on_vm); 3557 return NewVD->setInvalidDecl(); 3558 } 3559 3560 // Function pointers and references cannot have qualified function type, only 3561 // function pointer-to-members can do that. 3562 QualType Pointee; 3563 unsigned PtrOrRef = 0; 3564 if (const PointerType *Ptr = T->getAs<PointerType>()) 3565 Pointee = Ptr->getPointeeType(); 3566 else if (const ReferenceType *Ref = T->getAs<ReferenceType>()) { 3567 Pointee = Ref->getPointeeType(); 3568 PtrOrRef = 1; 3569 } 3570 if (!Pointee.isNull() && Pointee->isFunctionProtoType() && 3571 Pointee->getAs<FunctionProtoType>()->getTypeQuals() != 0) { 3572 Diag(NewVD->getLocation(), diag::err_invalid_qualified_function_pointer) 3573 << PtrOrRef; 3574 return NewVD->setInvalidDecl(); 3575 } 3576 3577 if (!Previous.empty()) { 3578 Redeclaration = true; 3579 MergeVarDecl(NewVD, Previous); 3580 } 3581} 3582 3583/// \brief Data used with FindOverriddenMethod 3584struct FindOverriddenMethodData { 3585 Sema *S; 3586 CXXMethodDecl *Method; 3587}; 3588 3589/// \brief Member lookup function that determines whether a given C++ 3590/// method overrides a method in a base class, to be used with 3591/// CXXRecordDecl::lookupInBases(). 3592static bool FindOverriddenMethod(const CXXBaseSpecifier *Specifier, 3593 CXXBasePath &Path, 3594 void *UserData) { 3595 RecordDecl *BaseRecord = Specifier->getType()->getAs<RecordType>()->getDecl(); 3596 3597 FindOverriddenMethodData *Data 3598 = reinterpret_cast<FindOverriddenMethodData*>(UserData); 3599 3600 DeclarationName Name = Data->Method->getDeclName(); 3601 3602 // FIXME: Do we care about other names here too? 3603 if (Name.getNameKind() == DeclarationName::CXXDestructorName) { 3604 // We really want to find the base class destructor here. 3605 QualType T = Data->S->Context.getTypeDeclType(BaseRecord); 3606 CanQualType CT = Data->S->Context.getCanonicalType(T); 3607 3608 Name = Data->S->Context.DeclarationNames.getCXXDestructorName(CT); 3609 } 3610 3611 for (Path.Decls = BaseRecord->lookup(Name); 3612 Path.Decls.first != Path.Decls.second; 3613 ++Path.Decls.first) { 3614 NamedDecl *D = *Path.Decls.first; 3615 if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(D)) { 3616 if (MD->isVirtual() && !Data->S->IsOverload(Data->Method, MD, false)) 3617 return true; 3618 } 3619 } 3620 3621 return false; 3622} 3623 3624/// AddOverriddenMethods - See if a method overrides any in the base classes, 3625/// and if so, check that it's a valid override and remember it. 3626bool Sema::AddOverriddenMethods(CXXRecordDecl *DC, CXXMethodDecl *MD) { 3627 // Look for virtual methods in base classes that this method might override. 3628 CXXBasePaths Paths; 3629 FindOverriddenMethodData Data; 3630 Data.Method = MD; 3631 Data.S = this; 3632 bool AddedAny = false; 3633 if (DC->lookupInBases(&FindOverriddenMethod, &Data, Paths)) { 3634 for (CXXBasePaths::decl_iterator I = Paths.found_decls_begin(), 3635 E = Paths.found_decls_end(); I != E; ++I) { 3636 if (CXXMethodDecl *OldMD = dyn_cast<CXXMethodDecl>(*I)) { 3637 if (!CheckOverridingFunctionReturnType(MD, OldMD) && 3638 !CheckOverridingFunctionExceptionSpec(MD, OldMD) && 3639 !CheckIfOverriddenFunctionIsMarkedFinal(MD, OldMD)) { 3640 MD->addOverriddenMethod(OldMD->getCanonicalDecl()); 3641 AddedAny = true; 3642 } 3643 } 3644 } 3645 } 3646 3647 return AddedAny; 3648} 3649 3650static void DiagnoseInvalidRedeclaration(Sema &S, FunctionDecl *NewFD) { 3651 LookupResult Prev(S, NewFD->getDeclName(), NewFD->getLocation(), 3652 Sema::LookupOrdinaryName, Sema::ForRedeclaration); 3653 S.LookupQualifiedName(Prev, NewFD->getDeclContext()); 3654 assert(!Prev.isAmbiguous() && 3655 "Cannot have an ambiguity in previous-declaration lookup"); 3656 for (LookupResult::iterator Func = Prev.begin(), FuncEnd = Prev.end(); 3657 Func != FuncEnd; ++Func) { 3658 if (isa<FunctionDecl>(*Func) && 3659 isNearlyMatchingFunction(S.Context, cast<FunctionDecl>(*Func), NewFD)) 3660 S.Diag((*Func)->getLocation(), diag::note_member_def_close_match); 3661 } 3662} 3663 3664NamedDecl* 3665Sema::ActOnFunctionDeclarator(Scope* S, Declarator& D, DeclContext* DC, 3666 QualType R, TypeSourceInfo *TInfo, 3667 LookupResult &Previous, 3668 MultiTemplateParamsArg TemplateParamLists, 3669 bool IsFunctionDefinition, bool &Redeclaration) { 3670 assert(R.getTypePtr()->isFunctionType()); 3671 3672 // TODO: consider using NameInfo for diagnostic. 3673 DeclarationNameInfo NameInfo = GetNameForDeclarator(D); 3674 DeclarationName Name = NameInfo.getName(); 3675 FunctionDecl::StorageClass SC = SC_None; 3676 switch (D.getDeclSpec().getStorageClassSpec()) { 3677 default: assert(0 && "Unknown storage class!"); 3678 case DeclSpec::SCS_auto: 3679 case DeclSpec::SCS_register: 3680 case DeclSpec::SCS_mutable: 3681 Diag(D.getDeclSpec().getStorageClassSpecLoc(), 3682 diag::err_typecheck_sclass_func); 3683 D.setInvalidType(); 3684 break; 3685 case DeclSpec::SCS_unspecified: SC = SC_None; break; 3686 case DeclSpec::SCS_extern: SC = SC_Extern; break; 3687 case DeclSpec::SCS_static: { 3688 if (CurContext->getRedeclContext()->isFunctionOrMethod()) { 3689 // C99 6.7.1p5: 3690 // The declaration of an identifier for a function that has 3691 // block scope shall have no explicit storage-class specifier 3692 // other than extern 3693 // See also (C++ [dcl.stc]p4). 3694 Diag(D.getDeclSpec().getStorageClassSpecLoc(), 3695 diag::err_static_block_func); 3696 SC = SC_None; 3697 } else 3698 SC = SC_Static; 3699 break; 3700 } 3701 case DeclSpec::SCS_private_extern: SC = SC_PrivateExtern; break; 3702 } 3703 3704 if (D.getDeclSpec().isThreadSpecified()) 3705 Diag(D.getDeclSpec().getThreadSpecLoc(), diag::err_invalid_thread); 3706 3707 // Do not allow returning a objc interface by-value. 3708 if (R->getAs<FunctionType>()->getResultType()->isObjCObjectType()) { 3709 Diag(D.getIdentifierLoc(), 3710 diag::err_object_cannot_be_passed_returned_by_value) << 0 3711 << R->getAs<FunctionType>()->getResultType(); 3712 D.setInvalidType(); 3713 } 3714 3715 FunctionDecl *NewFD; 3716 bool isInline = D.getDeclSpec().isInlineSpecified(); 3717 bool isFriend = false; 3718 DeclSpec::SCS SCSpec = D.getDeclSpec().getStorageClassSpecAsWritten(); 3719 FunctionDecl::StorageClass SCAsWritten 3720 = StorageClassSpecToFunctionDeclStorageClass(SCSpec); 3721 FunctionTemplateDecl *FunctionTemplate = 0; 3722 bool isExplicitSpecialization = false; 3723 bool isFunctionTemplateSpecialization = false; 3724 3725 if (!getLangOptions().CPlusPlus) { 3726 // Determine whether the function was written with a 3727 // prototype. This true when: 3728 // - there is a prototype in the declarator, or 3729 // - the type R of the function is some kind of typedef or other reference 3730 // to a type name (which eventually refers to a function type). 3731 bool HasPrototype = 3732 (D.isFunctionDeclarator() && D.getFunctionTypeInfo().hasPrototype) || 3733 (!isa<FunctionType>(R.getTypePtr()) && R->isFunctionProtoType()); 3734 3735 NewFD = FunctionDecl::Create(Context, DC, D.getSourceRange().getBegin(), 3736 NameInfo, R, TInfo, SC, SCAsWritten, isInline, 3737 HasPrototype); 3738 if (D.isInvalidType()) 3739 NewFD->setInvalidDecl(); 3740 3741 // Set the lexical context. 3742 NewFD->setLexicalDeclContext(CurContext); 3743 // Filter out previous declarations that don't match the scope. 3744 FilterLookupForScope(*this, Previous, DC, S, NewFD->hasLinkage(), 3745 /*ExplicitInstantiationOrSpecialization=*/false); 3746 } else { 3747 isFriend = D.getDeclSpec().isFriendSpecified(); 3748 bool isVirtual = D.getDeclSpec().isVirtualSpecified(); 3749 bool isExplicit = D.getDeclSpec().isExplicitSpecified(); 3750 bool isVirtualOkay = false; 3751 3752 // Check that the return type is not an abstract class type. 3753 // For record types, this is done by the AbstractClassUsageDiagnoser once 3754 // the class has been completely parsed. 3755 if (!DC->isRecord() && 3756 RequireNonAbstractType(D.getIdentifierLoc(), 3757 R->getAs<FunctionType>()->getResultType(), 3758 diag::err_abstract_type_in_decl, 3759 AbstractReturnType)) 3760 D.setInvalidType(); 3761 3762 if (Name.getNameKind() == DeclarationName::CXXConstructorName) { 3763 // This is a C++ constructor declaration. 3764 assert(DC->isRecord() && 3765 "Constructors can only be declared in a member context"); 3766 3767 R = CheckConstructorDeclarator(D, R, SC); 3768 3769 // Create the new declaration 3770 NewFD = CXXConstructorDecl::Create(Context, 3771 cast<CXXRecordDecl>(DC), 3772 D.getSourceRange().getBegin(), 3773 NameInfo, R, TInfo, 3774 isExplicit, isInline, 3775 /*isImplicitlyDeclared=*/false); 3776 } else if (Name.getNameKind() == DeclarationName::CXXDestructorName) { 3777 // This is a C++ destructor declaration. 3778 if (DC->isRecord()) { 3779 R = CheckDestructorDeclarator(D, R, SC); 3780 3781 NewFD = CXXDestructorDecl::Create(Context, 3782 cast<CXXRecordDecl>(DC), 3783 D.getSourceRange().getBegin(), 3784 NameInfo, R, TInfo, 3785 isInline, 3786 /*isImplicitlyDeclared=*/false); 3787 isVirtualOkay = true; 3788 } else { 3789 Diag(D.getIdentifierLoc(), diag::err_destructor_not_member); 3790 3791 // Create a FunctionDecl to satisfy the function definition parsing 3792 // code path. 3793 NewFD = FunctionDecl::Create(Context, DC, D.getSourceRange().getBegin(), 3794 D.getIdentifierLoc(), Name, R, TInfo, 3795 SC, SCAsWritten, isInline, 3796 /*hasPrototype=*/true); 3797 D.setInvalidType(); 3798 } 3799 } else if (Name.getNameKind() == DeclarationName::CXXConversionFunctionName) { 3800 if (!DC->isRecord()) { 3801 Diag(D.getIdentifierLoc(), 3802 diag::err_conv_function_not_member); 3803 return 0; 3804 } 3805 3806 CheckConversionDeclarator(D, R, SC); 3807 NewFD = CXXConversionDecl::Create(Context, cast<CXXRecordDecl>(DC), 3808 D.getSourceRange().getBegin(), 3809 NameInfo, R, TInfo, 3810 isInline, isExplicit, 3811 SourceLocation()); 3812 3813 isVirtualOkay = true; 3814 } else if (DC->isRecord()) { 3815 // If the of the function is the same as the name of the record, then this 3816 // must be an invalid constructor that has a return type. 3817 // (The parser checks for a return type and makes the declarator a 3818 // constructor if it has no return type). 3819 // must have an invalid constructor that has a return type 3820 if (Name.getAsIdentifierInfo() && 3821 Name.getAsIdentifierInfo() == cast<CXXRecordDecl>(DC)->getIdentifier()){ 3822 Diag(D.getIdentifierLoc(), diag::err_constructor_return_type) 3823 << SourceRange(D.getDeclSpec().getTypeSpecTypeLoc()) 3824 << SourceRange(D.getIdentifierLoc()); 3825 return 0; 3826 } 3827 3828 bool isStatic = SC == SC_Static; 3829 3830 // [class.free]p1: 3831 // Any allocation function for a class T is a static member 3832 // (even if not explicitly declared static). 3833 if (Name.getCXXOverloadedOperator() == OO_New || 3834 Name.getCXXOverloadedOperator() == OO_Array_New) 3835 isStatic = true; 3836 3837 // [class.free]p6 Any deallocation function for a class X is a static member 3838 // (even if not explicitly declared static). 3839 if (Name.getCXXOverloadedOperator() == OO_Delete || 3840 Name.getCXXOverloadedOperator() == OO_Array_Delete) 3841 isStatic = true; 3842 3843 // This is a C++ method declaration. 3844 NewFD = CXXMethodDecl::Create(Context, cast<CXXRecordDecl>(DC), 3845 D.getSourceRange().getBegin(), 3846 NameInfo, R, TInfo, 3847 isStatic, SCAsWritten, isInline, 3848 SourceLocation()); 3849 3850 isVirtualOkay = !isStatic; 3851 } else { 3852 // Determine whether the function was written with a 3853 // prototype. This true when: 3854 // - we're in C++ (where every function has a prototype), 3855 NewFD = FunctionDecl::Create(Context, DC, D.getSourceRange().getBegin(), 3856 NameInfo, R, TInfo, SC, SCAsWritten, isInline, 3857 true/*HasPrototype*/); 3858 } 3859 3860 if (isFriend && !isInline && IsFunctionDefinition) { 3861 // C++ [class.friend]p5 3862 // A function can be defined in a friend declaration of a 3863 // class . . . . Such a function is implicitly inline. 3864 NewFD->setImplicitlyInline(); 3865 } 3866 3867 SetNestedNameSpecifier(NewFD, D); 3868 isExplicitSpecialization = false; 3869 isFunctionTemplateSpecialization = false; 3870 if (D.isInvalidType()) 3871 NewFD->setInvalidDecl(); 3872 3873 // Set the lexical context. If the declarator has a C++ 3874 // scope specifier, or is the object of a friend declaration, the 3875 // lexical context will be different from the semantic context. 3876 NewFD->setLexicalDeclContext(CurContext); 3877 3878 // Match up the template parameter lists with the scope specifier, then 3879 // determine whether we have a template or a template specialization. 3880 bool Invalid = false; 3881 if (TemplateParameterList *TemplateParams 3882 = MatchTemplateParametersToScopeSpecifier( 3883 D.getDeclSpec().getSourceRange().getBegin(), 3884 D.getCXXScopeSpec(), 3885 TemplateParamLists.get(), 3886 TemplateParamLists.size(), 3887 isFriend, 3888 isExplicitSpecialization, 3889 Invalid)) { 3890 if (TemplateParams->size() > 0) { 3891 // This is a function template 3892 3893 // Check that we can declare a template here. 3894 if (CheckTemplateDeclScope(S, TemplateParams)) 3895 return 0; 3896 3897 // A destructor cannot be a template. 3898 if (Name.getNameKind() == DeclarationName::CXXDestructorName) { 3899 Diag(NewFD->getLocation(), diag::err_destructor_template); 3900 return 0; 3901 } 3902 3903 FunctionTemplate = FunctionTemplateDecl::Create(Context, DC, 3904 NewFD->getLocation(), 3905 Name, TemplateParams, 3906 NewFD); 3907 FunctionTemplate->setLexicalDeclContext(CurContext); 3908 NewFD->setDescribedFunctionTemplate(FunctionTemplate); 3909 3910 // For source fidelity, store the other template param lists. 3911 if (TemplateParamLists.size() > 1) { 3912 NewFD->setTemplateParameterListsInfo(Context, 3913 TemplateParamLists.size() - 1, 3914 TemplateParamLists.release()); 3915 } 3916 } else { 3917 // This is a function template specialization. 3918 isFunctionTemplateSpecialization = true; 3919 // For source fidelity, store all the template param lists. 3920 NewFD->setTemplateParameterListsInfo(Context, 3921 TemplateParamLists.size(), 3922 TemplateParamLists.release()); 3923 3924 // C++0x [temp.expl.spec]p20 forbids "template<> friend void foo(int);". 3925 if (isFriend) { 3926 // We want to remove the "template<>", found here. 3927 SourceRange RemoveRange = TemplateParams->getSourceRange(); 3928 3929 // If we remove the template<> and the name is not a 3930 // template-id, we're actually silently creating a problem: 3931 // the friend declaration will refer to an untemplated decl, 3932 // and clearly the user wants a template specialization. So 3933 // we need to insert '<>' after the name. 3934 SourceLocation InsertLoc; 3935 if (D.getName().getKind() != UnqualifiedId::IK_TemplateId) { 3936 InsertLoc = D.getName().getSourceRange().getEnd(); 3937 InsertLoc = PP.getLocForEndOfToken(InsertLoc); 3938 } 3939 3940 Diag(D.getIdentifierLoc(), diag::err_template_spec_decl_friend) 3941 << Name << RemoveRange 3942 << FixItHint::CreateRemoval(RemoveRange) 3943 << FixItHint::CreateInsertion(InsertLoc, "<>"); 3944 } 3945 } 3946 } 3947 else { 3948 // All template param lists were matched against the scope specifier: 3949 // this is NOT (an explicit specialization of) a template. 3950 if (TemplateParamLists.size() > 0) 3951 // For source fidelity, store all the template param lists. 3952 NewFD->setTemplateParameterListsInfo(Context, 3953 TemplateParamLists.size(), 3954 TemplateParamLists.release()); 3955 } 3956 3957 if (Invalid) { 3958 NewFD->setInvalidDecl(); 3959 if (FunctionTemplate) 3960 FunctionTemplate->setInvalidDecl(); 3961 } 3962 3963 // C++ [dcl.fct.spec]p5: 3964 // The virtual specifier shall only be used in declarations of 3965 // nonstatic class member functions that appear within a 3966 // member-specification of a class declaration; see 10.3. 3967 // 3968 if (isVirtual && !NewFD->isInvalidDecl()) { 3969 if (!isVirtualOkay) { 3970 Diag(D.getDeclSpec().getVirtualSpecLoc(), 3971 diag::err_virtual_non_function); 3972 } else if (!CurContext->isRecord()) { 3973 // 'virtual' was specified outside of the class. 3974 Diag(D.getDeclSpec().getVirtualSpecLoc(), 3975 diag::err_virtual_out_of_class) 3976 << FixItHint::CreateRemoval(D.getDeclSpec().getVirtualSpecLoc()); 3977 } else if (NewFD->getDescribedFunctionTemplate()) { 3978 // C++ [temp.mem]p3: 3979 // A member function template shall not be virtual. 3980 Diag(D.getDeclSpec().getVirtualSpecLoc(), 3981 diag::err_virtual_member_function_template) 3982 << FixItHint::CreateRemoval(D.getDeclSpec().getVirtualSpecLoc()); 3983 } else { 3984 // Okay: Add virtual to the method. 3985 NewFD->setVirtualAsWritten(true); 3986 } 3987 } 3988 3989 // C++ [dcl.fct.spec]p3: 3990 // The inline specifier shall not appear on a block scope function declaration. 3991 if (isInline && !NewFD->isInvalidDecl()) { 3992 if (CurContext->isFunctionOrMethod()) { 3993 // 'inline' is not allowed on block scope function declaration. 3994 Diag(D.getDeclSpec().getInlineSpecLoc(), 3995 diag::err_inline_declaration_block_scope) << Name 3996 << FixItHint::CreateRemoval(D.getDeclSpec().getInlineSpecLoc()); 3997 } 3998 } 3999 4000 // C++ [dcl.fct.spec]p6: 4001 // The explicit specifier shall be used only in the declaration of a 4002 // constructor or conversion function within its class definition; see 12.3.1 4003 // and 12.3.2. 4004 if (isExplicit && !NewFD->isInvalidDecl()) { 4005 if (!CurContext->isRecord()) { 4006 // 'explicit' was specified outside of the class. 4007 Diag(D.getDeclSpec().getExplicitSpecLoc(), 4008 diag::err_explicit_out_of_class) 4009 << FixItHint::CreateRemoval(D.getDeclSpec().getExplicitSpecLoc()); 4010 } else if (!isa<CXXConstructorDecl>(NewFD) && 4011 !isa<CXXConversionDecl>(NewFD)) { 4012 // 'explicit' was specified on a function that wasn't a constructor 4013 // or conversion function. 4014 Diag(D.getDeclSpec().getExplicitSpecLoc(), 4015 diag::err_explicit_non_ctor_or_conv_function) 4016 << FixItHint::CreateRemoval(D.getDeclSpec().getExplicitSpecLoc()); 4017 } 4018 } 4019 4020 // Filter out previous declarations that don't match the scope. 4021 FilterLookupForScope(*this, Previous, DC, S, NewFD->hasLinkage(), 4022 isExplicitSpecialization || 4023 isFunctionTemplateSpecialization); 4024 4025 if (isFriend) { 4026 // For now, claim that the objects have no previous declaration. 4027 if (FunctionTemplate) { 4028 FunctionTemplate->setObjectOfFriendDecl(false); 4029 FunctionTemplate->setAccess(AS_public); 4030 } 4031 NewFD->setObjectOfFriendDecl(false); 4032 NewFD->setAccess(AS_public); 4033 } 4034 4035 if (isa<CXXMethodDecl>(NewFD) && DC == CurContext && IsFunctionDefinition) { 4036 // A method is implicitly inline if it's defined in its class 4037 // definition. 4038 NewFD->setImplicitlyInline(); 4039 } 4040 4041 if (SC == SC_Static && isa<CXXMethodDecl>(NewFD) && 4042 !CurContext->isRecord()) { 4043 // C++ [class.static]p1: 4044 // A data or function member of a class may be declared static 4045 // in a class definition, in which case it is a static member of 4046 // the class. 4047 4048 // Complain about the 'static' specifier if it's on an out-of-line 4049 // member function definition. 4050 Diag(D.getDeclSpec().getStorageClassSpecLoc(), 4051 diag::err_static_out_of_line) 4052 << FixItHint::CreateRemoval(D.getDeclSpec().getStorageClassSpecLoc()); 4053 } 4054 } 4055 4056 // Handle GNU asm-label extension (encoded as an attribute). 4057 if (Expr *E = (Expr*) D.getAsmLabel()) { 4058 // The parser guarantees this is a string. 4059 StringLiteral *SE = cast<StringLiteral>(E); 4060 NewFD->addAttr(::new (Context) AsmLabelAttr(SE->getStrTokenLoc(0), Context, 4061 SE->getString())); 4062 } 4063 4064 // Copy the parameter declarations from the declarator D to the function 4065 // declaration NewFD, if they are available. First scavenge them into Params. 4066 llvm::SmallVector<ParmVarDecl*, 16> Params; 4067 if (D.isFunctionDeclarator()) { 4068 DeclaratorChunk::FunctionTypeInfo &FTI = D.getFunctionTypeInfo(); 4069 4070 // Check for C99 6.7.5.3p10 - foo(void) is a non-varargs 4071 // function that takes no arguments, not a function that takes a 4072 // single void argument. 4073 // We let through "const void" here because Sema::GetTypeForDeclarator 4074 // already checks for that case. 4075 if (FTI.NumArgs == 1 && !FTI.isVariadic && FTI.ArgInfo[0].Ident == 0 && 4076 FTI.ArgInfo[0].Param && 4077 cast<ParmVarDecl>(FTI.ArgInfo[0].Param)->getType()->isVoidType()) { 4078 // Empty arg list, don't push any params. 4079 ParmVarDecl *Param = cast<ParmVarDecl>(FTI.ArgInfo[0].Param); 4080 4081 // In C++, the empty parameter-type-list must be spelled "void"; a 4082 // typedef of void is not permitted. 4083 if (getLangOptions().CPlusPlus && 4084 Param->getType().getUnqualifiedType() != Context.VoidTy) { 4085 bool IsTypeAlias = false; 4086 if (const TypedefType *TT = Param->getType()->getAs<TypedefType>()) 4087 IsTypeAlias = isa<TypeAliasDecl>(TT->getDecl()); 4088 Diag(Param->getLocation(), diag::err_param_typedef_of_void) 4089 << IsTypeAlias; 4090 } 4091 } else if (FTI.NumArgs > 0 && FTI.ArgInfo[0].Param != 0) { 4092 for (unsigned i = 0, e = FTI.NumArgs; i != e; ++i) { 4093 ParmVarDecl *Param = cast<ParmVarDecl>(FTI.ArgInfo[i].Param); 4094 assert(Param->getDeclContext() != NewFD && "Was set before ?"); 4095 Param->setDeclContext(NewFD); 4096 Params.push_back(Param); 4097 4098 if (Param->isInvalidDecl()) 4099 NewFD->setInvalidDecl(); 4100 } 4101 } 4102 4103 } else if (const FunctionProtoType *FT = R->getAs<FunctionProtoType>()) { 4104 // When we're declaring a function with a typedef, typeof, etc as in the 4105 // following example, we'll need to synthesize (unnamed) 4106 // parameters for use in the declaration. 4107 // 4108 // @code 4109 // typedef void fn(int); 4110 // fn f; 4111 // @endcode 4112 4113 // Synthesize a parameter for each argument type. 4114 for (FunctionProtoType::arg_type_iterator AI = FT->arg_type_begin(), 4115 AE = FT->arg_type_end(); AI != AE; ++AI) { 4116 ParmVarDecl *Param = 4117 BuildParmVarDeclForTypedef(NewFD, D.getIdentifierLoc(), *AI); 4118 Params.push_back(Param); 4119 } 4120 } else { 4121 assert(R->isFunctionNoProtoType() && NewFD->getNumParams() == 0 && 4122 "Should not need args for typedef of non-prototype fn"); 4123 } 4124 // Finally, we know we have the right number of parameters, install them. 4125 NewFD->setParams(Params.data(), Params.size()); 4126 4127 // Process the non-inheritable attributes on this declaration. 4128 ProcessDeclAttributes(S, NewFD, D, 4129 /*NonInheritable=*/true, /*Inheritable=*/false); 4130 4131 if (!getLangOptions().CPlusPlus) { 4132 // Perform semantic checking on the function declaration. 4133 bool isExplctSpecialization=false; 4134 CheckFunctionDeclaration(S, NewFD, Previous, isExplctSpecialization, 4135 Redeclaration); 4136 assert((NewFD->isInvalidDecl() || !Redeclaration || 4137 Previous.getResultKind() != LookupResult::FoundOverloaded) && 4138 "previous declaration set still overloaded"); 4139 } else { 4140 // If the declarator is a template-id, translate the parser's template 4141 // argument list into our AST format. 4142 bool HasExplicitTemplateArgs = false; 4143 TemplateArgumentListInfo TemplateArgs; 4144 if (D.getName().getKind() == UnqualifiedId::IK_TemplateId) { 4145 TemplateIdAnnotation *TemplateId = D.getName().TemplateId; 4146 TemplateArgs.setLAngleLoc(TemplateId->LAngleLoc); 4147 TemplateArgs.setRAngleLoc(TemplateId->RAngleLoc); 4148 ASTTemplateArgsPtr TemplateArgsPtr(*this, 4149 TemplateId->getTemplateArgs(), 4150 TemplateId->NumArgs); 4151 translateTemplateArguments(TemplateArgsPtr, 4152 TemplateArgs); 4153 TemplateArgsPtr.release(); 4154 4155 HasExplicitTemplateArgs = true; 4156 4157 if (FunctionTemplate) { 4158 // Function template with explicit template arguments. 4159 Diag(D.getIdentifierLoc(), diag::err_function_template_partial_spec) 4160 << SourceRange(TemplateId->LAngleLoc, TemplateId->RAngleLoc); 4161 4162 HasExplicitTemplateArgs = false; 4163 } else if (!isFunctionTemplateSpecialization && 4164 !D.getDeclSpec().isFriendSpecified()) { 4165 // We have encountered something that the user meant to be a 4166 // specialization (because it has explicitly-specified template 4167 // arguments) but that was not introduced with a "template<>" (or had 4168 // too few of them). 4169 Diag(D.getIdentifierLoc(), diag::err_template_spec_needs_header) 4170 << SourceRange(TemplateId->LAngleLoc, TemplateId->RAngleLoc) 4171 << FixItHint::CreateInsertion( 4172 D.getDeclSpec().getSourceRange().getBegin(), 4173 "template<> "); 4174 isFunctionTemplateSpecialization = true; 4175 } else { 4176 // "friend void foo<>(int);" is an implicit specialization decl. 4177 isFunctionTemplateSpecialization = true; 4178 } 4179 } else if (isFriend && isFunctionTemplateSpecialization) { 4180 // This combination is only possible in a recovery case; the user 4181 // wrote something like: 4182 // template <> friend void foo(int); 4183 // which we're recovering from as if the user had written: 4184 // friend void foo<>(int); 4185 // Go ahead and fake up a template id. 4186 HasExplicitTemplateArgs = true; 4187 TemplateArgs.setLAngleLoc(D.getIdentifierLoc()); 4188 TemplateArgs.setRAngleLoc(D.getIdentifierLoc()); 4189 } 4190 4191 // If it's a friend (and only if it's a friend), it's possible 4192 // that either the specialized function type or the specialized 4193 // template is dependent, and therefore matching will fail. In 4194 // this case, don't check the specialization yet. 4195 if (isFunctionTemplateSpecialization && isFriend && 4196 (NewFD->getType()->isDependentType() || DC->isDependentContext())) { 4197 assert(HasExplicitTemplateArgs && 4198 "friend function specialization without template args"); 4199 if (CheckDependentFunctionTemplateSpecialization(NewFD, TemplateArgs, 4200 Previous)) 4201 NewFD->setInvalidDecl(); 4202 } else if (isFunctionTemplateSpecialization) { 4203 if (CurContext->isDependentContext() && CurContext->isRecord() 4204 && !isFriend) { 4205 Diag(NewFD->getLocation(), diag::err_function_specialization_in_class) 4206 << NewFD->getDeclName(); 4207 NewFD->setInvalidDecl(); 4208 return 0; 4209 } else if (CheckFunctionTemplateSpecialization(NewFD, 4210 (HasExplicitTemplateArgs ? &TemplateArgs : 0), 4211 Previous)) 4212 NewFD->setInvalidDecl(); 4213 } else if (isExplicitSpecialization && isa<CXXMethodDecl>(NewFD)) { 4214 if (CheckMemberSpecialization(NewFD, Previous)) 4215 NewFD->setInvalidDecl(); 4216 } 4217 4218 // Perform semantic checking on the function declaration. 4219 CheckFunctionDeclaration(S, NewFD, Previous, isExplicitSpecialization, 4220 Redeclaration); 4221 4222 assert((NewFD->isInvalidDecl() || !Redeclaration || 4223 Previous.getResultKind() != LookupResult::FoundOverloaded) && 4224 "previous declaration set still overloaded"); 4225 4226 NamedDecl *PrincipalDecl = (FunctionTemplate 4227 ? cast<NamedDecl>(FunctionTemplate) 4228 : NewFD); 4229 4230 if (isFriend && Redeclaration) { 4231 AccessSpecifier Access = AS_public; 4232 if (!NewFD->isInvalidDecl()) 4233 Access = NewFD->getPreviousDeclaration()->getAccess(); 4234 4235 NewFD->setAccess(Access); 4236 if (FunctionTemplate) FunctionTemplate->setAccess(Access); 4237 4238 PrincipalDecl->setObjectOfFriendDecl(true); 4239 } 4240 4241 if (NewFD->isOverloadedOperator() && !DC->isRecord() && 4242 PrincipalDecl->isInIdentifierNamespace(Decl::IDNS_Ordinary)) 4243 PrincipalDecl->setNonMemberOperator(); 4244 4245 // If we have a function template, check the template parameter 4246 // list. This will check and merge default template arguments. 4247 if (FunctionTemplate) { 4248 FunctionTemplateDecl *PrevTemplate = FunctionTemplate->getPreviousDeclaration(); 4249 CheckTemplateParameterList(FunctionTemplate->getTemplateParameters(), 4250 PrevTemplate? PrevTemplate->getTemplateParameters() : 0, 4251 D.getDeclSpec().isFriendSpecified() 4252 ? (IsFunctionDefinition 4253 ? TPC_FriendFunctionTemplateDefinition 4254 : TPC_FriendFunctionTemplate) 4255 : (D.getCXXScopeSpec().isSet() && 4256 DC && DC->isRecord() && 4257 DC->isDependentContext()) 4258 ? TPC_ClassTemplateMember 4259 : TPC_FunctionTemplate); 4260 } 4261 4262 if (NewFD->isInvalidDecl()) { 4263 // Ignore all the rest of this. 4264 } else if (!Redeclaration) { 4265 // Fake up an access specifier if it's supposed to be a class member. 4266 if (isa<CXXRecordDecl>(NewFD->getDeclContext())) 4267 NewFD->setAccess(AS_public); 4268 4269 // Qualified decls generally require a previous declaration. 4270 if (D.getCXXScopeSpec().isSet()) { 4271 // ...with the major exception of templated-scope or 4272 // dependent-scope friend declarations. 4273 4274 // TODO: we currently also suppress this check in dependent 4275 // contexts because (1) the parameter depth will be off when 4276 // matching friend templates and (2) we might actually be 4277 // selecting a friend based on a dependent factor. But there 4278 // are situations where these conditions don't apply and we 4279 // can actually do this check immediately. 4280 if (isFriend && 4281 (TemplateParamLists.size() || 4282 D.getCXXScopeSpec().getScopeRep()->isDependent() || 4283 CurContext->isDependentContext())) { 4284 // ignore these 4285 } else { 4286 // The user tried to provide an out-of-line definition for a 4287 // function that is a member of a class or namespace, but there 4288 // was no such member function declared (C++ [class.mfct]p2, 4289 // C++ [namespace.memdef]p2). For example: 4290 // 4291 // class X { 4292 // void f() const; 4293 // }; 4294 // 4295 // void X::f() { } // ill-formed 4296 // 4297 // Complain about this problem, and attempt to suggest close 4298 // matches (e.g., those that differ only in cv-qualifiers and 4299 // whether the parameter types are references). 4300 Diag(D.getIdentifierLoc(), diag::err_member_def_does_not_match) 4301 << Name << DC << D.getCXXScopeSpec().getRange(); 4302 NewFD->setInvalidDecl(); 4303 4304 DiagnoseInvalidRedeclaration(*this, NewFD); 4305 } 4306 4307 // Unqualified local friend declarations are required to resolve 4308 // to something. 4309 } else if (isFriend && cast<CXXRecordDecl>(CurContext)->isLocalClass()) { 4310 Diag(D.getIdentifierLoc(), diag::err_no_matching_local_friend); 4311 NewFD->setInvalidDecl(); 4312 DiagnoseInvalidRedeclaration(*this, NewFD); 4313 } 4314 4315 } else if (!IsFunctionDefinition && D.getCXXScopeSpec().isSet() && 4316 !isFriend && !isFunctionTemplateSpecialization && 4317 !isExplicitSpecialization) { 4318 // An out-of-line member function declaration must also be a 4319 // definition (C++ [dcl.meaning]p1). 4320 // Note that this is not the case for explicit specializations of 4321 // function templates or member functions of class templates, per 4322 // C++ [temp.expl.spec]p2. We also allow these declarations as an extension 4323 // for compatibility with old SWIG code which likes to generate them. 4324 Diag(NewFD->getLocation(), diag::ext_out_of_line_declaration) 4325 << D.getCXXScopeSpec().getRange(); 4326 } 4327 } 4328 4329 4330 // Handle attributes. We need to have merged decls when handling attributes 4331 // (for example to check for conflicts, etc). 4332 // FIXME: This needs to happen before we merge declarations. Then, 4333 // let attribute merging cope with attribute conflicts. 4334 ProcessDeclAttributes(S, NewFD, D, 4335 /*NonInheritable=*/false, /*Inheritable=*/true); 4336 4337 // attributes declared post-definition are currently ignored 4338 // FIXME: This should happen during attribute merging 4339 if (Redeclaration && Previous.isSingleResult()) { 4340 const FunctionDecl *Def; 4341 FunctionDecl *PrevFD = dyn_cast<FunctionDecl>(Previous.getFoundDecl()); 4342 if (PrevFD && PrevFD->hasBody(Def) && D.hasAttributes()) { 4343 Diag(NewFD->getLocation(), diag::warn_attribute_precede_definition); 4344 Diag(Def->getLocation(), diag::note_previous_definition); 4345 } 4346 } 4347 4348 AddKnownFunctionAttributes(NewFD); 4349 4350 if (NewFD->hasAttr<OverloadableAttr>() && 4351 !NewFD->getType()->getAs<FunctionProtoType>()) { 4352 Diag(NewFD->getLocation(), 4353 diag::err_attribute_overloadable_no_prototype) 4354 << NewFD; 4355 4356 // Turn this into a variadic function with no parameters. 4357 const FunctionType *FT = NewFD->getType()->getAs<FunctionType>(); 4358 FunctionProtoType::ExtProtoInfo EPI; 4359 EPI.Variadic = true; 4360 EPI.ExtInfo = FT->getExtInfo(); 4361 4362 QualType R = Context.getFunctionType(FT->getResultType(), 0, 0, EPI); 4363 NewFD->setType(R); 4364 } 4365 4366 // If there's a #pragma GCC visibility in scope, and this isn't a class 4367 // member, set the visibility of this function. 4368 if (NewFD->getLinkage() == ExternalLinkage && !DC->isRecord()) 4369 AddPushedVisibilityAttribute(NewFD); 4370 4371 // If this is a locally-scoped extern C function, update the 4372 // map of such names. 4373 if (CurContext->isFunctionOrMethod() && NewFD->isExternC() 4374 && !NewFD->isInvalidDecl()) 4375 RegisterLocallyScopedExternCDecl(NewFD, Previous, S); 4376 4377 // Set this FunctionDecl's range up to the right paren. 4378 NewFD->setRangeEnd(D.getSourceRange().getEnd()); 4379 4380 if (getLangOptions().CPlusPlus) { 4381 if (FunctionTemplate) { 4382 if (NewFD->isInvalidDecl()) 4383 FunctionTemplate->setInvalidDecl(); 4384 return FunctionTemplate; 4385 } 4386 } 4387 4388 MarkUnusedFileScopedDecl(NewFD); 4389 4390 if (getLangOptions().CUDA) 4391 if (IdentifierInfo *II = NewFD->getIdentifier()) 4392 if (!NewFD->isInvalidDecl() && 4393 NewFD->getDeclContext()->getRedeclContext()->isTranslationUnit()) { 4394 if (II->isStr("cudaConfigureCall")) { 4395 if (!R->getAs<FunctionType>()->getResultType()->isScalarType()) 4396 Diag(NewFD->getLocation(), diag::err_config_scalar_return); 4397 4398 Context.setcudaConfigureCallDecl(NewFD); 4399 } 4400 } 4401 4402 return NewFD; 4403} 4404 4405/// \brief Perform semantic checking of a new function declaration. 4406/// 4407/// Performs semantic analysis of the new function declaration 4408/// NewFD. This routine performs all semantic checking that does not 4409/// require the actual declarator involved in the declaration, and is 4410/// used both for the declaration of functions as they are parsed 4411/// (called via ActOnDeclarator) and for the declaration of functions 4412/// that have been instantiated via C++ template instantiation (called 4413/// via InstantiateDecl). 4414/// 4415/// \param IsExplicitSpecialiation whether this new function declaration is 4416/// an explicit specialization of the previous declaration. 4417/// 4418/// This sets NewFD->isInvalidDecl() to true if there was an error. 4419void Sema::CheckFunctionDeclaration(Scope *S, FunctionDecl *NewFD, 4420 LookupResult &Previous, 4421 bool IsExplicitSpecialization, 4422 bool &Redeclaration) { 4423 // If NewFD is already known erroneous, don't do any of this checking. 4424 if (NewFD->isInvalidDecl()) { 4425 // If this is a class member, mark the class invalid immediately. 4426 // This avoids some consistency errors later. 4427 if (isa<CXXMethodDecl>(NewFD)) 4428 cast<CXXMethodDecl>(NewFD)->getParent()->setInvalidDecl(); 4429 4430 return; 4431 } 4432 4433 if (NewFD->getResultType()->isVariablyModifiedType()) { 4434 // Functions returning a variably modified type violate C99 6.7.5.2p2 4435 // because all functions have linkage. 4436 Diag(NewFD->getLocation(), diag::err_vm_func_decl); 4437 return NewFD->setInvalidDecl(); 4438 } 4439 4440 if (NewFD->isMain()) 4441 CheckMain(NewFD); 4442 4443 // Check for a previous declaration of this name. 4444 if (Previous.empty() && NewFD->isExternC()) { 4445 // Since we did not find anything by this name and we're declaring 4446 // an extern "C" function, look for a non-visible extern "C" 4447 // declaration with the same name. 4448 llvm::DenseMap<DeclarationName, NamedDecl *>::iterator Pos 4449 = LocallyScopedExternalDecls.find(NewFD->getDeclName()); 4450 if (Pos != LocallyScopedExternalDecls.end()) 4451 Previous.addDecl(Pos->second); 4452 } 4453 4454 // Merge or overload the declaration with an existing declaration of 4455 // the same name, if appropriate. 4456 if (!Previous.empty()) { 4457 // Determine whether NewFD is an overload of PrevDecl or 4458 // a declaration that requires merging. If it's an overload, 4459 // there's no more work to do here; we'll just add the new 4460 // function to the scope. 4461 4462 NamedDecl *OldDecl = 0; 4463 if (!AllowOverloadingOfFunction(Previous, Context)) { 4464 Redeclaration = true; 4465 OldDecl = Previous.getFoundDecl(); 4466 } else { 4467 switch (CheckOverload(S, NewFD, Previous, OldDecl, 4468 /*NewIsUsingDecl*/ false)) { 4469 case Ovl_Match: 4470 Redeclaration = true; 4471 break; 4472 4473 case Ovl_NonFunction: 4474 Redeclaration = true; 4475 break; 4476 4477 case Ovl_Overload: 4478 Redeclaration = false; 4479 break; 4480 } 4481 4482 if (!getLangOptions().CPlusPlus && !NewFD->hasAttr<OverloadableAttr>()) { 4483 // If a function name is overloadable in C, then every function 4484 // with that name must be marked "overloadable". 4485 Diag(NewFD->getLocation(), diag::err_attribute_overloadable_missing) 4486 << Redeclaration << NewFD; 4487 NamedDecl *OverloadedDecl = 0; 4488 if (Redeclaration) 4489 OverloadedDecl = OldDecl; 4490 else if (!Previous.empty()) 4491 OverloadedDecl = Previous.getRepresentativeDecl(); 4492 if (OverloadedDecl) 4493 Diag(OverloadedDecl->getLocation(), 4494 diag::note_attribute_overloadable_prev_overload); 4495 NewFD->addAttr(::new (Context) OverloadableAttr(SourceLocation(), 4496 Context)); 4497 } 4498 } 4499 4500 if (Redeclaration) { 4501 // NewFD and OldDecl represent declarations that need to be 4502 // merged. 4503 if (MergeFunctionDecl(NewFD, OldDecl)) 4504 return NewFD->setInvalidDecl(); 4505 4506 Previous.clear(); 4507 Previous.addDecl(OldDecl); 4508 4509 if (FunctionTemplateDecl *OldTemplateDecl 4510 = dyn_cast<FunctionTemplateDecl>(OldDecl)) { 4511 NewFD->setPreviousDeclaration(OldTemplateDecl->getTemplatedDecl()); 4512 FunctionTemplateDecl *NewTemplateDecl 4513 = NewFD->getDescribedFunctionTemplate(); 4514 assert(NewTemplateDecl && "Template/non-template mismatch"); 4515 if (CXXMethodDecl *Method 4516 = dyn_cast<CXXMethodDecl>(NewTemplateDecl->getTemplatedDecl())) { 4517 Method->setAccess(OldTemplateDecl->getAccess()); 4518 NewTemplateDecl->setAccess(OldTemplateDecl->getAccess()); 4519 } 4520 4521 // If this is an explicit specialization of a member that is a function 4522 // template, mark it as a member specialization. 4523 if (IsExplicitSpecialization && 4524 NewTemplateDecl->getInstantiatedFromMemberTemplate()) { 4525 NewTemplateDecl->setMemberSpecialization(); 4526 assert(OldTemplateDecl->isMemberSpecialization()); 4527 } 4528 } else { 4529 if (isa<CXXMethodDecl>(NewFD)) // Set access for out-of-line definitions 4530 NewFD->setAccess(OldDecl->getAccess()); 4531 NewFD->setPreviousDeclaration(cast<FunctionDecl>(OldDecl)); 4532 } 4533 } 4534 } 4535 4536 // Semantic checking for this function declaration (in isolation). 4537 if (getLangOptions().CPlusPlus) { 4538 // C++-specific checks. 4539 if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(NewFD)) { 4540 CheckConstructor(Constructor); 4541 } else if (CXXDestructorDecl *Destructor = 4542 dyn_cast<CXXDestructorDecl>(NewFD)) { 4543 CXXRecordDecl *Record = Destructor->getParent(); 4544 QualType ClassType = Context.getTypeDeclType(Record); 4545 4546 // FIXME: Shouldn't we be able to perform this check even when the class 4547 // type is dependent? Both gcc and edg can handle that. 4548 if (!ClassType->isDependentType()) { 4549 DeclarationName Name 4550 = Context.DeclarationNames.getCXXDestructorName( 4551 Context.getCanonicalType(ClassType)); 4552 if (NewFD->getDeclName() != Name) { 4553 Diag(NewFD->getLocation(), diag::err_destructor_name); 4554 return NewFD->setInvalidDecl(); 4555 } 4556 } 4557 } else if (CXXConversionDecl *Conversion 4558 = dyn_cast<CXXConversionDecl>(NewFD)) { 4559 ActOnConversionDeclarator(Conversion); 4560 } 4561 4562 // Find any virtual functions that this function overrides. 4563 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(NewFD)) { 4564 if (!Method->isFunctionTemplateSpecialization() && 4565 !Method->getDescribedFunctionTemplate()) { 4566 if (AddOverriddenMethods(Method->getParent(), Method)) { 4567 // If the function was marked as "static", we have a problem. 4568 if (NewFD->getStorageClass() == SC_Static) { 4569 Diag(NewFD->getLocation(), diag::err_static_overrides_virtual) 4570 << NewFD->getDeclName(); 4571 for (CXXMethodDecl::method_iterator 4572 Overridden = Method->begin_overridden_methods(), 4573 OverriddenEnd = Method->end_overridden_methods(); 4574 Overridden != OverriddenEnd; 4575 ++Overridden) { 4576 Diag((*Overridden)->getLocation(), 4577 diag::note_overridden_virtual_function); 4578 } 4579 } 4580 } 4581 } 4582 } 4583 4584 // Extra checking for C++ overloaded operators (C++ [over.oper]). 4585 if (NewFD->isOverloadedOperator() && 4586 CheckOverloadedOperatorDeclaration(NewFD)) 4587 return NewFD->setInvalidDecl(); 4588 4589 // Extra checking for C++0x literal operators (C++0x [over.literal]). 4590 if (NewFD->getLiteralIdentifier() && 4591 CheckLiteralOperatorDeclaration(NewFD)) 4592 return NewFD->setInvalidDecl(); 4593 4594 // In C++, check default arguments now that we have merged decls. Unless 4595 // the lexical context is the class, because in this case this is done 4596 // during delayed parsing anyway. 4597 if (!CurContext->isRecord()) 4598 CheckCXXDefaultArguments(NewFD); 4599 4600 // If this function declares a builtin function, check the type of this 4601 // declaration against the expected type for the builtin. 4602 if (unsigned BuiltinID = NewFD->getBuiltinID()) { 4603 ASTContext::GetBuiltinTypeError Error; 4604 QualType T = Context.GetBuiltinType(BuiltinID, Error); 4605 if (!T.isNull() && !Context.hasSameType(T, NewFD->getType())) { 4606 // The type of this function differs from the type of the builtin, 4607 // so forget about the builtin entirely. 4608 Context.BuiltinInfo.ForgetBuiltin(BuiltinID, Context.Idents); 4609 } 4610 } 4611 } 4612} 4613 4614void Sema::CheckMain(FunctionDecl* FD) { 4615 // C++ [basic.start.main]p3: A program that declares main to be inline 4616 // or static is ill-formed. 4617 // C99 6.7.4p4: In a hosted environment, the inline function specifier 4618 // shall not appear in a declaration of main. 4619 // static main is not an error under C99, but we should warn about it. 4620 bool isInline = FD->isInlineSpecified(); 4621 bool isStatic = FD->getStorageClass() == SC_Static; 4622 if (isInline || isStatic) { 4623 unsigned diagID = diag::warn_unusual_main_decl; 4624 if (isInline || getLangOptions().CPlusPlus) 4625 diagID = diag::err_unusual_main_decl; 4626 4627 int which = isStatic + (isInline << 1) - 1; 4628 Diag(FD->getLocation(), diagID) << which; 4629 } 4630 4631 QualType T = FD->getType(); 4632 assert(T->isFunctionType() && "function decl is not of function type"); 4633 const FunctionType* FT = T->getAs<FunctionType>(); 4634 4635 if (!Context.hasSameUnqualifiedType(FT->getResultType(), Context.IntTy)) { 4636 Diag(FD->getTypeSpecStartLoc(), diag::err_main_returns_nonint); 4637 FD->setInvalidDecl(true); 4638 } 4639 4640 // Treat protoless main() as nullary. 4641 if (isa<FunctionNoProtoType>(FT)) return; 4642 4643 const FunctionProtoType* FTP = cast<const FunctionProtoType>(FT); 4644 unsigned nparams = FTP->getNumArgs(); 4645 assert(FD->getNumParams() == nparams); 4646 4647 bool HasExtraParameters = (nparams > 3); 4648 4649 // Darwin passes an undocumented fourth argument of type char**. If 4650 // other platforms start sprouting these, the logic below will start 4651 // getting shifty. 4652 if (nparams == 4 && Context.Target.getTriple().isOSDarwin()) 4653 HasExtraParameters = false; 4654 4655 if (HasExtraParameters) { 4656 Diag(FD->getLocation(), diag::err_main_surplus_args) << nparams; 4657 FD->setInvalidDecl(true); 4658 nparams = 3; 4659 } 4660 4661 // FIXME: a lot of the following diagnostics would be improved 4662 // if we had some location information about types. 4663 4664 QualType CharPP = 4665 Context.getPointerType(Context.getPointerType(Context.CharTy)); 4666 QualType Expected[] = { Context.IntTy, CharPP, CharPP, CharPP }; 4667 4668 for (unsigned i = 0; i < nparams; ++i) { 4669 QualType AT = FTP->getArgType(i); 4670 4671 bool mismatch = true; 4672 4673 if (Context.hasSameUnqualifiedType(AT, Expected[i])) 4674 mismatch = false; 4675 else if (Expected[i] == CharPP) { 4676 // As an extension, the following forms are okay: 4677 // char const ** 4678 // char const * const * 4679 // char * const * 4680 4681 QualifierCollector qs; 4682 const PointerType* PT; 4683 if ((PT = qs.strip(AT)->getAs<PointerType>()) && 4684 (PT = qs.strip(PT->getPointeeType())->getAs<PointerType>()) && 4685 (QualType(qs.strip(PT->getPointeeType()), 0) == Context.CharTy)) { 4686 qs.removeConst(); 4687 mismatch = !qs.empty(); 4688 } 4689 } 4690 4691 if (mismatch) { 4692 Diag(FD->getLocation(), diag::err_main_arg_wrong) << i << Expected[i]; 4693 // TODO: suggest replacing given type with expected type 4694 FD->setInvalidDecl(true); 4695 } 4696 } 4697 4698 if (nparams == 1 && !FD->isInvalidDecl()) { 4699 Diag(FD->getLocation(), diag::warn_main_one_arg); 4700 } 4701 4702 if (!FD->isInvalidDecl() && FD->getDescribedFunctionTemplate()) { 4703 Diag(FD->getLocation(), diag::err_main_template_decl); 4704 FD->setInvalidDecl(); 4705 } 4706} 4707 4708bool Sema::CheckForConstantInitializer(Expr *Init, QualType DclT) { 4709 // FIXME: Need strict checking. In C89, we need to check for 4710 // any assignment, increment, decrement, function-calls, or 4711 // commas outside of a sizeof. In C99, it's the same list, 4712 // except that the aforementioned are allowed in unevaluated 4713 // expressions. Everything else falls under the 4714 // "may accept other forms of constant expressions" exception. 4715 // (We never end up here for C++, so the constant expression 4716 // rules there don't matter.) 4717 if (Init->isConstantInitializer(Context, false)) 4718 return false; 4719 Diag(Init->getExprLoc(), diag::err_init_element_not_constant) 4720 << Init->getSourceRange(); 4721 return true; 4722} 4723 4724namespace { 4725 // Visits an initialization expression to see if OrigDecl is evaluated in 4726 // its own initialization and throws a warning if it does. 4727 class SelfReferenceChecker 4728 : public EvaluatedExprVisitor<SelfReferenceChecker> { 4729 Sema &S; 4730 Decl *OrigDecl; 4731 4732 public: 4733 typedef EvaluatedExprVisitor<SelfReferenceChecker> Inherited; 4734 4735 SelfReferenceChecker(Sema &S, Decl *OrigDecl) : Inherited(S.Context), 4736 S(S), OrigDecl(OrigDecl) { } 4737 4738 void VisitExpr(Expr *E) { 4739 if (isa<ObjCMessageExpr>(*E)) return; 4740 Inherited::VisitExpr(E); 4741 } 4742 4743 void VisitImplicitCastExpr(ImplicitCastExpr *E) { 4744 CheckForSelfReference(E); 4745 Inherited::VisitImplicitCastExpr(E); 4746 } 4747 4748 void CheckForSelfReference(ImplicitCastExpr *E) { 4749 if (E->getCastKind() != CK_LValueToRValue) return; 4750 Expr* SubExpr = E->getSubExpr()->IgnoreParenImpCasts(); 4751 DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(SubExpr); 4752 if (!DRE) return; 4753 Decl* ReferenceDecl = DRE->getDecl(); 4754 if (OrigDecl != ReferenceDecl) return; 4755 LookupResult Result(S, DRE->getNameInfo(), Sema::LookupOrdinaryName, 4756 Sema::NotForRedeclaration); 4757 S.Diag(SubExpr->getLocStart(), diag::warn_uninit_self_reference_in_init) 4758 << Result.getLookupName() << OrigDecl->getLocation() 4759 << SubExpr->getSourceRange(); 4760 } 4761 }; 4762} 4763 4764/// AddInitializerToDecl - Adds the initializer Init to the 4765/// declaration dcl. If DirectInit is true, this is C++ direct 4766/// initialization rather than copy initialization. 4767void Sema::AddInitializerToDecl(Decl *RealDecl, Expr *Init, 4768 bool DirectInit, bool TypeMayContainAuto) { 4769 // If there is no declaration, there was an error parsing it. Just ignore 4770 // the initializer. 4771 if (RealDecl == 0 || RealDecl->isInvalidDecl()) 4772 return; 4773 4774 // Check for self-references within variable initializers. 4775 if (VarDecl *vd = dyn_cast<VarDecl>(RealDecl)) { 4776 // Variables declared within a function/method body are handled 4777 // by a dataflow analysis. 4778 if (!vd->hasLocalStorage() && !vd->isStaticLocal()) 4779 SelfReferenceChecker(*this, RealDecl).VisitExpr(Init); 4780 } 4781 else { 4782 SelfReferenceChecker(*this, RealDecl).VisitExpr(Init); 4783 } 4784 4785 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(RealDecl)) { 4786 // With declarators parsed the way they are, the parser cannot 4787 // distinguish between a normal initializer and a pure-specifier. 4788 // Thus this grotesque test. 4789 IntegerLiteral *IL; 4790 if ((IL = dyn_cast<IntegerLiteral>(Init)) && IL->getValue() == 0 && 4791 Context.getCanonicalType(IL->getType()) == Context.IntTy) 4792 CheckPureMethod(Method, Init->getSourceRange()); 4793 else { 4794 Diag(Method->getLocation(), diag::err_member_function_initialization) 4795 << Method->getDeclName() << Init->getSourceRange(); 4796 Method->setInvalidDecl(); 4797 } 4798 return; 4799 } 4800 4801 VarDecl *VDecl = dyn_cast<VarDecl>(RealDecl); 4802 if (!VDecl) { 4803 if (getLangOptions().CPlusPlus && 4804 RealDecl->getLexicalDeclContext()->isRecord() && 4805 isa<NamedDecl>(RealDecl)) 4806 Diag(RealDecl->getLocation(), diag::err_member_initialization); 4807 else 4808 Diag(RealDecl->getLocation(), diag::err_illegal_initializer); 4809 RealDecl->setInvalidDecl(); 4810 return; 4811 } 4812 4813 // C++0x [decl.spec.auto]p6. Deduce the type which 'auto' stands in for. 4814 if (TypeMayContainAuto && VDecl->getType()->getContainedAutoType()) { 4815 TypeSourceInfo *DeducedType = 0; 4816 if (!DeduceAutoType(VDecl->getTypeSourceInfo(), Init, DeducedType)) 4817 Diag(VDecl->getLocation(), diag::err_auto_var_deduction_failure) 4818 << VDecl->getDeclName() << VDecl->getType() << Init->getType() 4819 << Init->getSourceRange(); 4820 if (!DeducedType) { 4821 RealDecl->setInvalidDecl(); 4822 return; 4823 } 4824 VDecl->setTypeSourceInfo(DeducedType); 4825 VDecl->setType(DeducedType->getType()); 4826 4827 // If this is a redeclaration, check that the type we just deduced matches 4828 // the previously declared type. 4829 if (VarDecl *Old = VDecl->getPreviousDeclaration()) 4830 MergeVarDeclTypes(VDecl, Old); 4831 } 4832 4833 4834 // A definition must end up with a complete type, which means it must be 4835 // complete with the restriction that an array type might be completed by the 4836 // initializer; note that later code assumes this restriction. 4837 QualType BaseDeclType = VDecl->getType(); 4838 if (const ArrayType *Array = Context.getAsIncompleteArrayType(BaseDeclType)) 4839 BaseDeclType = Array->getElementType(); 4840 if (RequireCompleteType(VDecl->getLocation(), BaseDeclType, 4841 diag::err_typecheck_decl_incomplete_type)) { 4842 RealDecl->setInvalidDecl(); 4843 return; 4844 } 4845 4846 // The variable can not have an abstract class type. 4847 if (RequireNonAbstractType(VDecl->getLocation(), VDecl->getType(), 4848 diag::err_abstract_type_in_decl, 4849 AbstractVariableType)) 4850 VDecl->setInvalidDecl(); 4851 4852 const VarDecl *Def; 4853 if ((Def = VDecl->getDefinition()) && Def != VDecl) { 4854 Diag(VDecl->getLocation(), diag::err_redefinition) 4855 << VDecl->getDeclName(); 4856 Diag(Def->getLocation(), diag::note_previous_definition); 4857 VDecl->setInvalidDecl(); 4858 return; 4859 } 4860 4861 const VarDecl* PrevInit = 0; 4862 if (getLangOptions().CPlusPlus) { 4863 // C++ [class.static.data]p4 4864 // If a static data member is of const integral or const 4865 // enumeration type, its declaration in the class definition can 4866 // specify a constant-initializer which shall be an integral 4867 // constant expression (5.19). In that case, the member can appear 4868 // in integral constant expressions. The member shall still be 4869 // defined in a namespace scope if it is used in the program and the 4870 // namespace scope definition shall not contain an initializer. 4871 // 4872 // We already performed a redefinition check above, but for static 4873 // data members we also need to check whether there was an in-class 4874 // declaration with an initializer. 4875 if (VDecl->isStaticDataMember() && VDecl->getAnyInitializer(PrevInit)) { 4876 Diag(VDecl->getLocation(), diag::err_redefinition) << VDecl->getDeclName(); 4877 Diag(PrevInit->getLocation(), diag::note_previous_definition); 4878 return; 4879 } 4880 4881 if (VDecl->hasLocalStorage()) 4882 getCurFunction()->setHasBranchProtectedScope(); 4883 4884 if (DiagnoseUnexpandedParameterPack(Init, UPPC_Initializer)) { 4885 VDecl->setInvalidDecl(); 4886 return; 4887 } 4888 } 4889 4890 // Capture the variable that is being initialized and the style of 4891 // initialization. 4892 InitializedEntity Entity = InitializedEntity::InitializeVariable(VDecl); 4893 4894 // FIXME: Poor source location information. 4895 InitializationKind Kind 4896 = DirectInit? InitializationKind::CreateDirect(VDecl->getLocation(), 4897 Init->getLocStart(), 4898 Init->getLocEnd()) 4899 : InitializationKind::CreateCopy(VDecl->getLocation(), 4900 Init->getLocStart()); 4901 4902 // Get the decls type and save a reference for later, since 4903 // CheckInitializerTypes may change it. 4904 QualType DclT = VDecl->getType(), SavT = DclT; 4905 if (VDecl->isLocalVarDecl()) { 4906 if (VDecl->hasExternalStorage()) { // C99 6.7.8p5 4907 Diag(VDecl->getLocation(), diag::err_block_extern_cant_init); 4908 VDecl->setInvalidDecl(); 4909 } else if (!VDecl->isInvalidDecl()) { 4910 InitializationSequence InitSeq(*this, Entity, Kind, &Init, 1); 4911 ExprResult Result = InitSeq.Perform(*this, Entity, Kind, 4912 MultiExprArg(*this, &Init, 1), 4913 &DclT); 4914 if (Result.isInvalid()) { 4915 VDecl->setInvalidDecl(); 4916 return; 4917 } 4918 4919 Init = Result.takeAs<Expr>(); 4920 4921 // C++ 3.6.2p2, allow dynamic initialization of static initializers. 4922 // Don't check invalid declarations to avoid emitting useless diagnostics. 4923 if (!getLangOptions().CPlusPlus && !VDecl->isInvalidDecl()) { 4924 if (VDecl->getStorageClass() == SC_Static) // C99 6.7.8p4. 4925 CheckForConstantInitializer(Init, DclT); 4926 } 4927 } 4928 } else if (VDecl->isStaticDataMember() && 4929 VDecl->getLexicalDeclContext()->isRecord()) { 4930 // This is an in-class initialization for a static data member, e.g., 4931 // 4932 // struct S { 4933 // static const int value = 17; 4934 // }; 4935 4936 // Try to perform the initialization regardless. 4937 if (!VDecl->isInvalidDecl()) { 4938 InitializationSequence InitSeq(*this, Entity, Kind, &Init, 1); 4939 ExprResult Result = InitSeq.Perform(*this, Entity, Kind, 4940 MultiExprArg(*this, &Init, 1), 4941 &DclT); 4942 if (Result.isInvalid()) { 4943 VDecl->setInvalidDecl(); 4944 return; 4945 } 4946 4947 Init = Result.takeAs<Expr>(); 4948 } 4949 4950 // C++ [class.mem]p4: 4951 // A member-declarator can contain a constant-initializer only 4952 // if it declares a static member (9.4) of const integral or 4953 // const enumeration type, see 9.4.2. 4954 QualType T = VDecl->getType(); 4955 4956 // Do nothing on dependent types. 4957 if (T->isDependentType()) { 4958 4959 // Require constness. 4960 } else if (!T.isConstQualified()) { 4961 Diag(VDecl->getLocation(), diag::err_in_class_initializer_non_const) 4962 << Init->getSourceRange(); 4963 VDecl->setInvalidDecl(); 4964 4965 // We allow integer constant expressions in all cases. 4966 } else if (T->isIntegralOrEnumerationType()) { 4967 if (!Init->isValueDependent()) { 4968 // Check whether the expression is a constant expression. 4969 llvm::APSInt Value; 4970 SourceLocation Loc; 4971 if (!Init->isIntegerConstantExpr(Value, Context, &Loc)) { 4972 Diag(Loc, diag::err_in_class_initializer_non_constant) 4973 << Init->getSourceRange(); 4974 VDecl->setInvalidDecl(); 4975 } 4976 } 4977 4978 // We allow floating-point constants as an extension in C++03, and 4979 // C++0x has far more complicated rules that we don't really 4980 // implement fully. 4981 } else { 4982 bool Allowed = false; 4983 if (getLangOptions().CPlusPlus0x) { 4984 Allowed = T->isLiteralType(); 4985 } else if (T->isFloatingType()) { // also permits complex, which is ok 4986 Diag(VDecl->getLocation(), diag::ext_in_class_initializer_float_type) 4987 << T << Init->getSourceRange(); 4988 Allowed = true; 4989 } 4990 4991 if (!Allowed) { 4992 Diag(VDecl->getLocation(), diag::err_in_class_initializer_bad_type) 4993 << T << Init->getSourceRange(); 4994 VDecl->setInvalidDecl(); 4995 4996 // TODO: there are probably expressions that pass here that shouldn't. 4997 } else if (!Init->isValueDependent() && 4998 !Init->isConstantInitializer(Context, false)) { 4999 Diag(Init->getExprLoc(), diag::err_in_class_initializer_non_constant) 5000 << Init->getSourceRange(); 5001 VDecl->setInvalidDecl(); 5002 } 5003 } 5004 } else if (VDecl->isFileVarDecl()) { 5005 if (VDecl->getStorageClassAsWritten() == SC_Extern && 5006 (!getLangOptions().CPlusPlus || 5007 !Context.getBaseElementType(VDecl->getType()).isConstQualified())) 5008 Diag(VDecl->getLocation(), diag::warn_extern_init); 5009 if (!VDecl->isInvalidDecl()) { 5010 InitializationSequence InitSeq(*this, Entity, Kind, &Init, 1); 5011 ExprResult Result = InitSeq.Perform(*this, Entity, Kind, 5012 MultiExprArg(*this, &Init, 1), 5013 &DclT); 5014 if (Result.isInvalid()) { 5015 VDecl->setInvalidDecl(); 5016 return; 5017 } 5018 5019 Init = Result.takeAs<Expr>(); 5020 } 5021 5022 // C++ 3.6.2p2, allow dynamic initialization of static initializers. 5023 // Don't check invalid declarations to avoid emitting useless diagnostics. 5024 if (!getLangOptions().CPlusPlus && !VDecl->isInvalidDecl()) { 5025 // C99 6.7.8p4. All file scoped initializers need to be constant. 5026 CheckForConstantInitializer(Init, DclT); 5027 } 5028 } 5029 // If the type changed, it means we had an incomplete type that was 5030 // completed by the initializer. For example: 5031 // int ary[] = { 1, 3, 5 }; 5032 // "ary" transitions from a VariableArrayType to a ConstantArrayType. 5033 if (!VDecl->isInvalidDecl() && (DclT != SavT)) { 5034 VDecl->setType(DclT); 5035 Init->setType(DclT); 5036 } 5037 5038 5039 // If this variable is a local declaration with record type, make sure it 5040 // doesn't have a flexible member initialization. We only support this as a 5041 // global/static definition. 5042 if (VDecl->hasLocalStorage()) 5043 if (const RecordType *RT = VDecl->getType()->getAs<RecordType>()) 5044 if (RT->getDecl()->hasFlexibleArrayMember()) { 5045 // Check whether the initializer tries to initialize the flexible 5046 // array member itself to anything other than an empty initializer list. 5047 if (InitListExpr *ILE = dyn_cast<InitListExpr>(Init)) { 5048 unsigned Index = std::distance(RT->getDecl()->field_begin(), 5049 RT->getDecl()->field_end()) - 1; 5050 if (Index < ILE->getNumInits() && 5051 !(isa<InitListExpr>(ILE->getInit(Index)) && 5052 cast<InitListExpr>(ILE->getInit(Index))->getNumInits() == 0)) { 5053 Diag(VDecl->getLocation(), diag::err_nonstatic_flexible_variable); 5054 VDecl->setInvalidDecl(); 5055 } 5056 } 5057 } 5058 5059 // Check any implicit conversions within the expression. 5060 CheckImplicitConversions(Init, VDecl->getLocation()); 5061 5062 Init = MaybeCreateExprWithCleanups(Init); 5063 // Attach the initializer to the decl. 5064 VDecl->setInit(Init); 5065 5066 CheckCompleteVariableDeclaration(VDecl); 5067} 5068 5069/// ActOnInitializerError - Given that there was an error parsing an 5070/// initializer for the given declaration, try to return to some form 5071/// of sanity. 5072void Sema::ActOnInitializerError(Decl *D) { 5073 // Our main concern here is re-establishing invariants like "a 5074 // variable's type is either dependent or complete". 5075 if (!D || D->isInvalidDecl()) return; 5076 5077 VarDecl *VD = dyn_cast<VarDecl>(D); 5078 if (!VD) return; 5079 5080 // Auto types are meaningless if we can't make sense of the initializer. 5081 if (ParsingInitForAutoVars.count(D)) { 5082 D->setInvalidDecl(); 5083 return; 5084 } 5085 5086 QualType Ty = VD->getType(); 5087 if (Ty->isDependentType()) return; 5088 5089 // Require a complete type. 5090 if (RequireCompleteType(VD->getLocation(), 5091 Context.getBaseElementType(Ty), 5092 diag::err_typecheck_decl_incomplete_type)) { 5093 VD->setInvalidDecl(); 5094 return; 5095 } 5096 5097 // Require an abstract type. 5098 if (RequireNonAbstractType(VD->getLocation(), Ty, 5099 diag::err_abstract_type_in_decl, 5100 AbstractVariableType)) { 5101 VD->setInvalidDecl(); 5102 return; 5103 } 5104 5105 // Don't bother complaining about constructors or destructors, 5106 // though. 5107} 5108 5109void Sema::ActOnUninitializedDecl(Decl *RealDecl, 5110 bool TypeMayContainAuto) { 5111 // If there is no declaration, there was an error parsing it. Just ignore it. 5112 if (RealDecl == 0) 5113 return; 5114 5115 if (VarDecl *Var = dyn_cast<VarDecl>(RealDecl)) { 5116 QualType Type = Var->getType(); 5117 5118 // C++0x [dcl.spec.auto]p3 5119 if (TypeMayContainAuto && Type->getContainedAutoType()) { 5120 Diag(Var->getLocation(), diag::err_auto_var_requires_init) 5121 << Var->getDeclName() << Type; 5122 Var->setInvalidDecl(); 5123 return; 5124 } 5125 5126 switch (Var->isThisDeclarationADefinition()) { 5127 case VarDecl::Definition: 5128 if (!Var->isStaticDataMember() || !Var->getAnyInitializer()) 5129 break; 5130 5131 // We have an out-of-line definition of a static data member 5132 // that has an in-class initializer, so we type-check this like 5133 // a declaration. 5134 // 5135 // Fall through 5136 5137 case VarDecl::DeclarationOnly: 5138 // It's only a declaration. 5139 5140 // Block scope. C99 6.7p7: If an identifier for an object is 5141 // declared with no linkage (C99 6.2.2p6), the type for the 5142 // object shall be complete. 5143 if (!Type->isDependentType() && Var->isLocalVarDecl() && 5144 !Var->getLinkage() && !Var->isInvalidDecl() && 5145 RequireCompleteType(Var->getLocation(), Type, 5146 diag::err_typecheck_decl_incomplete_type)) 5147 Var->setInvalidDecl(); 5148 5149 // Make sure that the type is not abstract. 5150 if (!Type->isDependentType() && !Var->isInvalidDecl() && 5151 RequireNonAbstractType(Var->getLocation(), Type, 5152 diag::err_abstract_type_in_decl, 5153 AbstractVariableType)) 5154 Var->setInvalidDecl(); 5155 return; 5156 5157 case VarDecl::TentativeDefinition: 5158 // File scope. C99 6.9.2p2: A declaration of an identifier for an 5159 // object that has file scope without an initializer, and without a 5160 // storage-class specifier or with the storage-class specifier "static", 5161 // constitutes a tentative definition. Note: A tentative definition with 5162 // external linkage is valid (C99 6.2.2p5). 5163 if (!Var->isInvalidDecl()) { 5164 if (const IncompleteArrayType *ArrayT 5165 = Context.getAsIncompleteArrayType(Type)) { 5166 if (RequireCompleteType(Var->getLocation(), 5167 ArrayT->getElementType(), 5168 diag::err_illegal_decl_array_incomplete_type)) 5169 Var->setInvalidDecl(); 5170 } else if (Var->getStorageClass() == SC_Static) { 5171 // C99 6.9.2p3: If the declaration of an identifier for an object is 5172 // a tentative definition and has internal linkage (C99 6.2.2p3), the 5173 // declared type shall not be an incomplete type. 5174 // NOTE: code such as the following 5175 // static struct s; 5176 // struct s { int a; }; 5177 // is accepted by gcc. Hence here we issue a warning instead of 5178 // an error and we do not invalidate the static declaration. 5179 // NOTE: to avoid multiple warnings, only check the first declaration. 5180 if (Var->getPreviousDeclaration() == 0) 5181 RequireCompleteType(Var->getLocation(), Type, 5182 diag::ext_typecheck_decl_incomplete_type); 5183 } 5184 } 5185 5186 // Record the tentative definition; we're done. 5187 if (!Var->isInvalidDecl()) 5188 TentativeDefinitions.push_back(Var); 5189 return; 5190 } 5191 5192 // Provide a specific diagnostic for uninitialized variable 5193 // definitions with incomplete array type. 5194 if (Type->isIncompleteArrayType()) { 5195 Diag(Var->getLocation(), 5196 diag::err_typecheck_incomplete_array_needs_initializer); 5197 Var->setInvalidDecl(); 5198 return; 5199 } 5200 5201 // Provide a specific diagnostic for uninitialized variable 5202 // definitions with reference type. 5203 if (Type->isReferenceType()) { 5204 Diag(Var->getLocation(), diag::err_reference_var_requires_init) 5205 << Var->getDeclName() 5206 << SourceRange(Var->getLocation(), Var->getLocation()); 5207 Var->setInvalidDecl(); 5208 return; 5209 } 5210 5211 // Do not attempt to type-check the default initializer for a 5212 // variable with dependent type. 5213 if (Type->isDependentType()) 5214 return; 5215 5216 if (Var->isInvalidDecl()) 5217 return; 5218 5219 if (RequireCompleteType(Var->getLocation(), 5220 Context.getBaseElementType(Type), 5221 diag::err_typecheck_decl_incomplete_type)) { 5222 Var->setInvalidDecl(); 5223 return; 5224 } 5225 5226 // The variable can not have an abstract class type. 5227 if (RequireNonAbstractType(Var->getLocation(), Type, 5228 diag::err_abstract_type_in_decl, 5229 AbstractVariableType)) { 5230 Var->setInvalidDecl(); 5231 return; 5232 } 5233 5234 const RecordType *Record 5235 = Context.getBaseElementType(Type)->getAs<RecordType>(); 5236 if (Record && getLangOptions().CPlusPlus && !getLangOptions().CPlusPlus0x && 5237 cast<CXXRecordDecl>(Record->getDecl())->isPOD()) { 5238 // C++03 [dcl.init]p9: 5239 // If no initializer is specified for an object, and the 5240 // object is of (possibly cv-qualified) non-POD class type (or 5241 // array thereof), the object shall be default-initialized; if 5242 // the object is of const-qualified type, the underlying class 5243 // type shall have a user-declared default 5244 // constructor. Otherwise, if no initializer is specified for 5245 // a non- static object, the object and its subobjects, if 5246 // any, have an indeterminate initial value); if the object 5247 // or any of its subobjects are of const-qualified type, the 5248 // program is ill-formed. 5249 // FIXME: DPG thinks it is very fishy that C++0x disables this. 5250 } else { 5251 // Check for jumps past the implicit initializer. C++0x 5252 // clarifies that this applies to a "variable with automatic 5253 // storage duration", not a "local variable". 5254 if (getLangOptions().CPlusPlus && Var->hasLocalStorage()) 5255 getCurFunction()->setHasBranchProtectedScope(); 5256 5257 InitializedEntity Entity = InitializedEntity::InitializeVariable(Var); 5258 InitializationKind Kind 5259 = InitializationKind::CreateDefault(Var->getLocation()); 5260 5261 InitializationSequence InitSeq(*this, Entity, Kind, 0, 0); 5262 ExprResult Init = InitSeq.Perform(*this, Entity, Kind, 5263 MultiExprArg(*this, 0, 0)); 5264 if (Init.isInvalid()) 5265 Var->setInvalidDecl(); 5266 else if (Init.get()) 5267 Var->setInit(MaybeCreateExprWithCleanups(Init.get())); 5268 } 5269 5270 CheckCompleteVariableDeclaration(Var); 5271 } 5272} 5273 5274void Sema::ActOnCXXForRangeDecl(Decl *D) { 5275 VarDecl *VD = dyn_cast<VarDecl>(D); 5276 if (!VD) { 5277 Diag(D->getLocation(), diag::err_for_range_decl_must_be_var); 5278 D->setInvalidDecl(); 5279 return; 5280 } 5281 5282 VD->setCXXForRangeDecl(true); 5283 5284 // for-range-declaration cannot be given a storage class specifier. 5285 int Error = -1; 5286 switch (VD->getStorageClassAsWritten()) { 5287 case SC_None: 5288 break; 5289 case SC_Extern: 5290 Error = 0; 5291 break; 5292 case SC_Static: 5293 Error = 1; 5294 break; 5295 case SC_PrivateExtern: 5296 Error = 2; 5297 break; 5298 case SC_Auto: 5299 Error = 3; 5300 break; 5301 case SC_Register: 5302 Error = 4; 5303 break; 5304 } 5305 // FIXME: constexpr isn't allowed here. 5306 //if (DS.isConstexprSpecified()) 5307 // Error = 5; 5308 if (Error != -1) { 5309 Diag(VD->getOuterLocStart(), diag::err_for_range_storage_class) 5310 << VD->getDeclName() << Error; 5311 D->setInvalidDecl(); 5312 } 5313} 5314 5315void Sema::CheckCompleteVariableDeclaration(VarDecl *var) { 5316 if (var->isInvalidDecl()) return; 5317 5318 // All the following checks are C++ only. 5319 if (!getLangOptions().CPlusPlus) return; 5320 5321 QualType baseType = Context.getBaseElementType(var->getType()); 5322 if (baseType->isDependentType()) return; 5323 5324 // __block variables might require us to capture a copy-initializer. 5325 if (var->hasAttr<BlocksAttr>()) { 5326 // It's currently invalid to ever have a __block variable with an 5327 // array type; should we diagnose that here? 5328 5329 // Regardless, we don't want to ignore array nesting when 5330 // constructing this copy. 5331 QualType type = var->getType(); 5332 5333 if (type->isStructureOrClassType()) { 5334 SourceLocation poi = var->getLocation(); 5335 Expr *varRef = new (Context) DeclRefExpr(var, type, VK_LValue, poi); 5336 ExprResult result = 5337 PerformCopyInitialization( 5338 InitializedEntity::InitializeBlock(poi, type, false), 5339 poi, Owned(varRef)); 5340 if (!result.isInvalid()) { 5341 result = MaybeCreateExprWithCleanups(result); 5342 Expr *init = result.takeAs<Expr>(); 5343 Context.setBlockVarCopyInits(var, init); 5344 } 5345 } 5346 } 5347 5348 // Check for global constructors. 5349 if (!var->getDeclContext()->isDependentContext() && 5350 var->hasGlobalStorage() && 5351 !var->isStaticLocal() && 5352 var->getInit() && 5353 !var->getInit()->isConstantInitializer(Context, 5354 baseType->isReferenceType())) 5355 Diag(var->getLocation(), diag::warn_global_constructor) 5356 << var->getInit()->getSourceRange(); 5357 5358 // Require the destructor. 5359 if (const RecordType *recordType = baseType->getAs<RecordType>()) 5360 FinalizeVarWithDestructor(var, recordType); 5361} 5362 5363/// FinalizeDeclaration - called by ParseDeclarationAfterDeclarator to perform 5364/// any semantic actions necessary after any initializer has been attached. 5365void 5366Sema::FinalizeDeclaration(Decl *ThisDecl) { 5367 // Note that we are no longer parsing the initializer for this declaration. 5368 ParsingInitForAutoVars.erase(ThisDecl); 5369} 5370 5371Sema::DeclGroupPtrTy 5372Sema::FinalizeDeclaratorGroup(Scope *S, const DeclSpec &DS, 5373 Decl **Group, unsigned NumDecls) { 5374 llvm::SmallVector<Decl*, 8> Decls; 5375 5376 if (DS.isTypeSpecOwned()) 5377 Decls.push_back(DS.getRepAsDecl()); 5378 5379 for (unsigned i = 0; i != NumDecls; ++i) 5380 if (Decl *D = Group[i]) 5381 Decls.push_back(D); 5382 5383 return BuildDeclaratorGroup(Decls.data(), Decls.size(), 5384 DS.getTypeSpecType() == DeclSpec::TST_auto); 5385} 5386 5387/// BuildDeclaratorGroup - convert a list of declarations into a declaration 5388/// group, performing any necessary semantic checking. 5389Sema::DeclGroupPtrTy 5390Sema::BuildDeclaratorGroup(Decl **Group, unsigned NumDecls, 5391 bool TypeMayContainAuto) { 5392 // C++0x [dcl.spec.auto]p7: 5393 // If the type deduced for the template parameter U is not the same in each 5394 // deduction, the program is ill-formed. 5395 // FIXME: When initializer-list support is added, a distinction is needed 5396 // between the deduced type U and the deduced type which 'auto' stands for. 5397 // auto a = 0, b = { 1, 2, 3 }; 5398 // is legal because the deduced type U is 'int' in both cases. 5399 if (TypeMayContainAuto && NumDecls > 1) { 5400 QualType Deduced; 5401 CanQualType DeducedCanon; 5402 VarDecl *DeducedDecl = 0; 5403 for (unsigned i = 0; i != NumDecls; ++i) { 5404 if (VarDecl *D = dyn_cast<VarDecl>(Group[i])) { 5405 AutoType *AT = D->getType()->getContainedAutoType(); 5406 // Don't reissue diagnostics when instantiating a template. 5407 if (AT && D->isInvalidDecl()) 5408 break; 5409 if (AT && AT->isDeduced()) { 5410 QualType U = AT->getDeducedType(); 5411 CanQualType UCanon = Context.getCanonicalType(U); 5412 if (Deduced.isNull()) { 5413 Deduced = U; 5414 DeducedCanon = UCanon; 5415 DeducedDecl = D; 5416 } else if (DeducedCanon != UCanon) { 5417 Diag(D->getTypeSourceInfo()->getTypeLoc().getBeginLoc(), 5418 diag::err_auto_different_deductions) 5419 << Deduced << DeducedDecl->getDeclName() 5420 << U << D->getDeclName() 5421 << DeducedDecl->getInit()->getSourceRange() 5422 << D->getInit()->getSourceRange(); 5423 D->setInvalidDecl(); 5424 break; 5425 } 5426 } 5427 } 5428 } 5429 } 5430 5431 return DeclGroupPtrTy::make(DeclGroupRef::Create(Context, Group, NumDecls)); 5432} 5433 5434 5435/// ActOnParamDeclarator - Called from Parser::ParseFunctionDeclarator() 5436/// to introduce parameters into function prototype scope. 5437Decl *Sema::ActOnParamDeclarator(Scope *S, Declarator &D) { 5438 const DeclSpec &DS = D.getDeclSpec(); 5439 5440 // Verify C99 6.7.5.3p2: The only SCS allowed is 'register'. 5441 VarDecl::StorageClass StorageClass = SC_None; 5442 VarDecl::StorageClass StorageClassAsWritten = SC_None; 5443 if (DS.getStorageClassSpec() == DeclSpec::SCS_register) { 5444 StorageClass = SC_Register; 5445 StorageClassAsWritten = SC_Register; 5446 } else if (DS.getStorageClassSpec() != DeclSpec::SCS_unspecified) { 5447 Diag(DS.getStorageClassSpecLoc(), 5448 diag::err_invalid_storage_class_in_func_decl); 5449 D.getMutableDeclSpec().ClearStorageClassSpecs(); 5450 } 5451 5452 if (D.getDeclSpec().isThreadSpecified()) 5453 Diag(D.getDeclSpec().getThreadSpecLoc(), diag::err_invalid_thread); 5454 5455 DiagnoseFunctionSpecifiers(D); 5456 5457 TagDecl *OwnedDecl = 0; 5458 TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S, &OwnedDecl); 5459 QualType parmDeclType = TInfo->getType(); 5460 5461 if (getLangOptions().CPlusPlus) { 5462 // Check that there are no default arguments inside the type of this 5463 // parameter. 5464 CheckExtraCXXDefaultArguments(D); 5465 5466 if (OwnedDecl && OwnedDecl->isDefinition()) { 5467 // C++ [dcl.fct]p6: 5468 // Types shall not be defined in return or parameter types. 5469 Diag(OwnedDecl->getLocation(), diag::err_type_defined_in_param_type) 5470 << Context.getTypeDeclType(OwnedDecl); 5471 } 5472 5473 // Parameter declarators cannot be qualified (C++ [dcl.meaning]p1). 5474 if (D.getCXXScopeSpec().isSet()) { 5475 Diag(D.getIdentifierLoc(), diag::err_qualified_param_declarator) 5476 << D.getCXXScopeSpec().getRange(); 5477 D.getCXXScopeSpec().clear(); 5478 } 5479 } 5480 5481 // Ensure we have a valid name 5482 IdentifierInfo *II = 0; 5483 if (D.hasName()) { 5484 II = D.getIdentifier(); 5485 if (!II) { 5486 Diag(D.getIdentifierLoc(), diag::err_bad_parameter_name) 5487 << GetNameForDeclarator(D).getName().getAsString(); 5488 D.setInvalidType(true); 5489 } 5490 } 5491 5492 // Check for redeclaration of parameters, e.g. int foo(int x, int x); 5493 if (II) { 5494 LookupResult R(*this, II, D.getIdentifierLoc(), LookupOrdinaryName, 5495 ForRedeclaration); 5496 LookupName(R, S); 5497 if (R.isSingleResult()) { 5498 NamedDecl *PrevDecl = R.getFoundDecl(); 5499 if (PrevDecl->isTemplateParameter()) { 5500 // Maybe we will complain about the shadowed template parameter. 5501 DiagnoseTemplateParameterShadow(D.getIdentifierLoc(), PrevDecl); 5502 // Just pretend that we didn't see the previous declaration. 5503 PrevDecl = 0; 5504 } else if (S->isDeclScope(PrevDecl)) { 5505 Diag(D.getIdentifierLoc(), diag::err_param_redefinition) << II; 5506 Diag(PrevDecl->getLocation(), diag::note_previous_declaration); 5507 5508 // Recover by removing the name 5509 II = 0; 5510 D.SetIdentifier(0, D.getIdentifierLoc()); 5511 D.setInvalidType(true); 5512 } 5513 } 5514 } 5515 5516 // Temporarily put parameter variables in the translation unit, not 5517 // the enclosing context. This prevents them from accidentally 5518 // looking like class members in C++. 5519 ParmVarDecl *New = CheckParameter(Context.getTranslationUnitDecl(), 5520 D.getSourceRange().getBegin(), 5521 D.getIdentifierLoc(), II, 5522 parmDeclType, TInfo, 5523 StorageClass, StorageClassAsWritten); 5524 5525 if (D.isInvalidType()) 5526 New->setInvalidDecl(); 5527 5528 // Add the parameter declaration into this scope. 5529 S->AddDecl(New); 5530 if (II) 5531 IdResolver.AddDecl(New); 5532 5533 ProcessDeclAttributes(S, New, D); 5534 5535 if (New->hasAttr<BlocksAttr>()) { 5536 Diag(New->getLocation(), diag::err_block_on_nonlocal); 5537 } 5538 return New; 5539} 5540 5541/// \brief Synthesizes a variable for a parameter arising from a 5542/// typedef. 5543ParmVarDecl *Sema::BuildParmVarDeclForTypedef(DeclContext *DC, 5544 SourceLocation Loc, 5545 QualType T) { 5546 /* FIXME: setting StartLoc == Loc. 5547 Would it be worth to modify callers so as to provide proper source 5548 location for the unnamed parameters, embedding the parameter's type? */ 5549 ParmVarDecl *Param = ParmVarDecl::Create(Context, DC, Loc, Loc, 0, 5550 T, Context.getTrivialTypeSourceInfo(T, Loc), 5551 SC_None, SC_None, 0); 5552 Param->setImplicit(); 5553 return Param; 5554} 5555 5556void Sema::DiagnoseUnusedParameters(ParmVarDecl * const *Param, 5557 ParmVarDecl * const *ParamEnd) { 5558 // Don't diagnose unused-parameter errors in template instantiations; we 5559 // will already have done so in the template itself. 5560 if (!ActiveTemplateInstantiations.empty()) 5561 return; 5562 5563 for (; Param != ParamEnd; ++Param) { 5564 if (!(*Param)->isUsed() && (*Param)->getDeclName() && 5565 !(*Param)->hasAttr<UnusedAttr>()) { 5566 Diag((*Param)->getLocation(), diag::warn_unused_parameter) 5567 << (*Param)->getDeclName(); 5568 } 5569 } 5570} 5571 5572void Sema::DiagnoseSizeOfParametersAndReturnValue(ParmVarDecl * const *Param, 5573 ParmVarDecl * const *ParamEnd, 5574 QualType ReturnTy, 5575 NamedDecl *D) { 5576 if (LangOpts.NumLargeByValueCopy == 0) // No check. 5577 return; 5578 5579 // Warn if the return value is pass-by-value and larger than the specified 5580 // threshold. 5581 if (ReturnTy->isPODType()) { 5582 unsigned Size = Context.getTypeSizeInChars(ReturnTy).getQuantity(); 5583 if (Size > LangOpts.NumLargeByValueCopy) 5584 Diag(D->getLocation(), diag::warn_return_value_size) 5585 << D->getDeclName() << Size; 5586 } 5587 5588 // Warn if any parameter is pass-by-value and larger than the specified 5589 // threshold. 5590 for (; Param != ParamEnd; ++Param) { 5591 QualType T = (*Param)->getType(); 5592 if (!T->isPODType()) 5593 continue; 5594 unsigned Size = Context.getTypeSizeInChars(T).getQuantity(); 5595 if (Size > LangOpts.NumLargeByValueCopy) 5596 Diag((*Param)->getLocation(), diag::warn_parameter_size) 5597 << (*Param)->getDeclName() << Size; 5598 } 5599} 5600 5601ParmVarDecl *Sema::CheckParameter(DeclContext *DC, SourceLocation StartLoc, 5602 SourceLocation NameLoc, IdentifierInfo *Name, 5603 QualType T, TypeSourceInfo *TSInfo, 5604 VarDecl::StorageClass StorageClass, 5605 VarDecl::StorageClass StorageClassAsWritten) { 5606 ParmVarDecl *New = ParmVarDecl::Create(Context, DC, StartLoc, NameLoc, Name, 5607 adjustParameterType(T), TSInfo, 5608 StorageClass, StorageClassAsWritten, 5609 0); 5610 5611 // Parameters can not be abstract class types. 5612 // For record types, this is done by the AbstractClassUsageDiagnoser once 5613 // the class has been completely parsed. 5614 if (!CurContext->isRecord() && 5615 RequireNonAbstractType(NameLoc, T, diag::err_abstract_type_in_decl, 5616 AbstractParamType)) 5617 New->setInvalidDecl(); 5618 5619 // Parameter declarators cannot be interface types. All ObjC objects are 5620 // passed by reference. 5621 if (T->isObjCObjectType()) { 5622 Diag(NameLoc, 5623 diag::err_object_cannot_be_passed_returned_by_value) << 1 << T; 5624 New->setInvalidDecl(); 5625 } 5626 5627 // ISO/IEC TR 18037 S6.7.3: "The type of an object with automatic storage 5628 // duration shall not be qualified by an address-space qualifier." 5629 // Since all parameters have automatic store duration, they can not have 5630 // an address space. 5631 if (T.getAddressSpace() != 0) { 5632 Diag(NameLoc, diag::err_arg_with_address_space); 5633 New->setInvalidDecl(); 5634 } 5635 5636 return New; 5637} 5638 5639void Sema::ActOnFinishKNRParamDeclarations(Scope *S, Declarator &D, 5640 SourceLocation LocAfterDecls) { 5641 DeclaratorChunk::FunctionTypeInfo &FTI = D.getFunctionTypeInfo(); 5642 5643 // Verify 6.9.1p6: 'every identifier in the identifier list shall be declared' 5644 // for a K&R function. 5645 if (!FTI.hasPrototype) { 5646 for (int i = FTI.NumArgs; i != 0; /* decrement in loop */) { 5647 --i; 5648 if (FTI.ArgInfo[i].Param == 0) { 5649 llvm::SmallString<256> Code; 5650 llvm::raw_svector_ostream(Code) << " int " 5651 << FTI.ArgInfo[i].Ident->getName() 5652 << ";\n"; 5653 Diag(FTI.ArgInfo[i].IdentLoc, diag::ext_param_not_declared) 5654 << FTI.ArgInfo[i].Ident 5655 << FixItHint::CreateInsertion(LocAfterDecls, Code.str()); 5656 5657 // Implicitly declare the argument as type 'int' for lack of a better 5658 // type. 5659 AttributeFactory attrs; 5660 DeclSpec DS(attrs); 5661 const char* PrevSpec; // unused 5662 unsigned DiagID; // unused 5663 DS.SetTypeSpecType(DeclSpec::TST_int, FTI.ArgInfo[i].IdentLoc, 5664 PrevSpec, DiagID); 5665 Declarator ParamD(DS, Declarator::KNRTypeListContext); 5666 ParamD.SetIdentifier(FTI.ArgInfo[i].Ident, FTI.ArgInfo[i].IdentLoc); 5667 FTI.ArgInfo[i].Param = ActOnParamDeclarator(S, ParamD); 5668 } 5669 } 5670 } 5671} 5672 5673Decl *Sema::ActOnStartOfFunctionDef(Scope *FnBodyScope, 5674 Declarator &D) { 5675 assert(getCurFunctionDecl() == 0 && "Function parsing confused"); 5676 assert(D.isFunctionDeclarator() && "Not a function declarator!"); 5677 Scope *ParentScope = FnBodyScope->getParent(); 5678 5679 Decl *DP = HandleDeclarator(ParentScope, D, 5680 MultiTemplateParamsArg(*this), 5681 /*IsFunctionDefinition=*/true); 5682 return ActOnStartOfFunctionDef(FnBodyScope, DP); 5683} 5684 5685static bool ShouldWarnAboutMissingPrototype(const FunctionDecl *FD) { 5686 // Don't warn about invalid declarations. 5687 if (FD->isInvalidDecl()) 5688 return false; 5689 5690 // Or declarations that aren't global. 5691 if (!FD->isGlobal()) 5692 return false; 5693 5694 // Don't warn about C++ member functions. 5695 if (isa<CXXMethodDecl>(FD)) 5696 return false; 5697 5698 // Don't warn about 'main'. 5699 if (FD->isMain()) 5700 return false; 5701 5702 // Don't warn about inline functions. 5703 if (FD->isInlined()) 5704 return false; 5705 5706 // Don't warn about function templates. 5707 if (FD->getDescribedFunctionTemplate()) 5708 return false; 5709 5710 // Don't warn about function template specializations. 5711 if (FD->isFunctionTemplateSpecialization()) 5712 return false; 5713 5714 bool MissingPrototype = true; 5715 for (const FunctionDecl *Prev = FD->getPreviousDeclaration(); 5716 Prev; Prev = Prev->getPreviousDeclaration()) { 5717 // Ignore any declarations that occur in function or method 5718 // scope, because they aren't visible from the header. 5719 if (Prev->getDeclContext()->isFunctionOrMethod()) 5720 continue; 5721 5722 MissingPrototype = !Prev->getType()->isFunctionProtoType(); 5723 break; 5724 } 5725 5726 return MissingPrototype; 5727} 5728 5729Decl *Sema::ActOnStartOfFunctionDef(Scope *FnBodyScope, Decl *D) { 5730 // Clear the last template instantiation error context. 5731 LastTemplateInstantiationErrorContext = ActiveTemplateInstantiation(); 5732 5733 if (!D) 5734 return D; 5735 FunctionDecl *FD = 0; 5736 5737 if (FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(D)) 5738 FD = FunTmpl->getTemplatedDecl(); 5739 else 5740 FD = cast<FunctionDecl>(D); 5741 5742 // Enter a new function scope 5743 PushFunctionScope(); 5744 5745 // See if this is a redefinition. 5746 // But don't complain if we're in GNU89 mode and the previous definition 5747 // was an extern inline function. 5748 const FunctionDecl *Definition; 5749 if (FD->hasBody(Definition) && 5750 !canRedefineFunction(Definition, getLangOptions())) { 5751 if (getLangOptions().GNUMode && Definition->isInlineSpecified() && 5752 Definition->getStorageClass() == SC_Extern) 5753 Diag(FD->getLocation(), diag::err_redefinition_extern_inline) 5754 << FD->getDeclName() << getLangOptions().CPlusPlus; 5755 else 5756 Diag(FD->getLocation(), diag::err_redefinition) << FD->getDeclName(); 5757 Diag(Definition->getLocation(), diag::note_previous_definition); 5758 } 5759 5760 // Builtin functions cannot be defined. 5761 if (unsigned BuiltinID = FD->getBuiltinID()) { 5762 if (!Context.BuiltinInfo.isPredefinedLibFunction(BuiltinID)) { 5763 Diag(FD->getLocation(), diag::err_builtin_definition) << FD; 5764 FD->setInvalidDecl(); 5765 } 5766 } 5767 5768 // The return type of a function definition must be complete 5769 // (C99 6.9.1p3, C++ [dcl.fct]p6). 5770 QualType ResultType = FD->getResultType(); 5771 if (!ResultType->isDependentType() && !ResultType->isVoidType() && 5772 !FD->isInvalidDecl() && 5773 RequireCompleteType(FD->getLocation(), ResultType, 5774 diag::err_func_def_incomplete_result)) 5775 FD->setInvalidDecl(); 5776 5777 // GNU warning -Wmissing-prototypes: 5778 // Warn if a global function is defined without a previous 5779 // prototype declaration. This warning is issued even if the 5780 // definition itself provides a prototype. The aim is to detect 5781 // global functions that fail to be declared in header files. 5782 if (ShouldWarnAboutMissingPrototype(FD)) 5783 Diag(FD->getLocation(), diag::warn_missing_prototype) << FD; 5784 5785 if (FnBodyScope) 5786 PushDeclContext(FnBodyScope, FD); 5787 5788 // Check the validity of our function parameters 5789 CheckParmsForFunctionDef(FD->param_begin(), FD->param_end(), 5790 /*CheckParameterNames=*/true); 5791 5792 // Introduce our parameters into the function scope 5793 for (unsigned p = 0, NumParams = FD->getNumParams(); p < NumParams; ++p) { 5794 ParmVarDecl *Param = FD->getParamDecl(p); 5795 Param->setOwningFunction(FD); 5796 5797 // If this has an identifier, add it to the scope stack. 5798 if (Param->getIdentifier() && FnBodyScope) { 5799 CheckShadow(FnBodyScope, Param); 5800 5801 PushOnScopeChains(Param, FnBodyScope); 5802 } 5803 } 5804 5805 // Checking attributes of current function definition 5806 // dllimport attribute. 5807 DLLImportAttr *DA = FD->getAttr<DLLImportAttr>(); 5808 if (DA && (!FD->getAttr<DLLExportAttr>())) { 5809 // dllimport attribute cannot be directly applied to definition. 5810 // Microsoft accepts dllimport for functions defined within class scope. 5811 if (!DA->isInherited() && 5812 !(LangOpts.Microsoft && FD->getLexicalDeclContext()->isRecord())) { 5813 Diag(FD->getLocation(), 5814 diag::err_attribute_can_be_applied_only_to_symbol_declaration) 5815 << "dllimport"; 5816 FD->setInvalidDecl(); 5817 return FD; 5818 } 5819 5820 // Visual C++ appears to not think this is an issue, so only issue 5821 // a warning when Microsoft extensions are disabled. 5822 if (!LangOpts.Microsoft) { 5823 // If a symbol previously declared dllimport is later defined, the 5824 // attribute is ignored in subsequent references, and a warning is 5825 // emitted. 5826 Diag(FD->getLocation(), 5827 diag::warn_redeclaration_without_attribute_prev_attribute_ignored) 5828 << FD->getName() << "dllimport"; 5829 } 5830 } 5831 return FD; 5832} 5833 5834/// \brief Given the set of return statements within a function body, 5835/// compute the variables that are subject to the named return value 5836/// optimization. 5837/// 5838/// Each of the variables that is subject to the named return value 5839/// optimization will be marked as NRVO variables in the AST, and any 5840/// return statement that has a marked NRVO variable as its NRVO candidate can 5841/// use the named return value optimization. 5842/// 5843/// This function applies a very simplistic algorithm for NRVO: if every return 5844/// statement in the function has the same NRVO candidate, that candidate is 5845/// the NRVO variable. 5846/// 5847/// FIXME: Employ a smarter algorithm that accounts for multiple return 5848/// statements and the lifetimes of the NRVO candidates. We should be able to 5849/// find a maximal set of NRVO variables. 5850static void ComputeNRVO(Stmt *Body, FunctionScopeInfo *Scope) { 5851 ReturnStmt **Returns = Scope->Returns.data(); 5852 5853 const VarDecl *NRVOCandidate = 0; 5854 for (unsigned I = 0, E = Scope->Returns.size(); I != E; ++I) { 5855 if (!Returns[I]->getNRVOCandidate()) 5856 return; 5857 5858 if (!NRVOCandidate) 5859 NRVOCandidate = Returns[I]->getNRVOCandidate(); 5860 else if (NRVOCandidate != Returns[I]->getNRVOCandidate()) 5861 return; 5862 } 5863 5864 if (NRVOCandidate) 5865 const_cast<VarDecl*>(NRVOCandidate)->setNRVOVariable(true); 5866} 5867 5868Decl *Sema::ActOnFinishFunctionBody(Decl *D, Stmt *BodyArg) { 5869 return ActOnFinishFunctionBody(D, move(BodyArg), false); 5870} 5871 5872Decl *Sema::ActOnFinishFunctionBody(Decl *dcl, Stmt *Body, 5873 bool IsInstantiation) { 5874 FunctionDecl *FD = 0; 5875 FunctionTemplateDecl *FunTmpl = dyn_cast_or_null<FunctionTemplateDecl>(dcl); 5876 if (FunTmpl) 5877 FD = FunTmpl->getTemplatedDecl(); 5878 else 5879 FD = dyn_cast_or_null<FunctionDecl>(dcl); 5880 5881 sema::AnalysisBasedWarnings::Policy WP = AnalysisWarnings.getDefaultPolicy(); 5882 sema::AnalysisBasedWarnings::Policy *ActivePolicy = 0; 5883 5884 if (FD) { 5885 FD->setBody(Body); 5886 if (FD->isMain()) { 5887 // C and C++ allow for main to automagically return 0. 5888 // Implements C++ [basic.start.main]p5 and C99 5.1.2.2.3. 5889 FD->setHasImplicitReturnZero(true); 5890 WP.disableCheckFallThrough(); 5891 } 5892 5893 if (!FD->isInvalidDecl()) { 5894 DiagnoseUnusedParameters(FD->param_begin(), FD->param_end()); 5895 DiagnoseSizeOfParametersAndReturnValue(FD->param_begin(), FD->param_end(), 5896 FD->getResultType(), FD); 5897 5898 // If this is a constructor, we need a vtable. 5899 if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(FD)) 5900 MarkVTableUsed(FD->getLocation(), Constructor->getParent()); 5901 5902 ComputeNRVO(Body, getCurFunction()); 5903 } 5904 5905 assert(FD == getCurFunctionDecl() && "Function parsing confused"); 5906 } else if (ObjCMethodDecl *MD = dyn_cast_or_null<ObjCMethodDecl>(dcl)) { 5907 assert(MD == getCurMethodDecl() && "Method parsing confused"); 5908 MD->setBody(Body); 5909 if (Body) 5910 MD->setEndLoc(Body->getLocEnd()); 5911 if (!MD->isInvalidDecl()) { 5912 DiagnoseUnusedParameters(MD->param_begin(), MD->param_end()); 5913 DiagnoseSizeOfParametersAndReturnValue(MD->param_begin(), MD->param_end(), 5914 MD->getResultType(), MD); 5915 } 5916 } else { 5917 return 0; 5918 } 5919 5920 // Verify and clean out per-function state. 5921 if (Body) { 5922 // C++ constructors that have function-try-blocks can't have return 5923 // statements in the handlers of that block. (C++ [except.handle]p14) 5924 // Verify this. 5925 if (FD && isa<CXXConstructorDecl>(FD) && isa<CXXTryStmt>(Body)) 5926 DiagnoseReturnInConstructorExceptionHandler(cast<CXXTryStmt>(Body)); 5927 5928 // Verify that that gotos and switch cases don't jump into scopes illegally. 5929 // Verify that that gotos and switch cases don't jump into scopes illegally. 5930 if (getCurFunction()->NeedsScopeChecking() && 5931 !dcl->isInvalidDecl() && 5932 !hasAnyErrorsInThisFunction()) 5933 DiagnoseInvalidJumps(Body); 5934 5935 if (CXXDestructorDecl *Destructor = dyn_cast<CXXDestructorDecl>(dcl)) { 5936 if (!Destructor->getParent()->isDependentType()) 5937 CheckDestructor(Destructor); 5938 5939 MarkBaseAndMemberDestructorsReferenced(Destructor->getLocation(), 5940 Destructor->getParent()); 5941 } 5942 5943 // If any errors have occurred, clear out any temporaries that may have 5944 // been leftover. This ensures that these temporaries won't be picked up for 5945 // deletion in some later function. 5946 if (PP.getDiagnostics().hasErrorOccurred() || 5947 PP.getDiagnostics().getSuppressAllDiagnostics()) 5948 ExprTemporaries.clear(); 5949 else if (!isa<FunctionTemplateDecl>(dcl)) { 5950 // Since the body is valid, issue any analysis-based warnings that are 5951 // enabled. 5952 ActivePolicy = &WP; 5953 } 5954 5955 assert(ExprTemporaries.empty() && "Leftover temporaries in function"); 5956 } 5957 5958 if (!IsInstantiation) 5959 PopDeclContext(); 5960 5961 PopFunctionOrBlockScope(ActivePolicy, dcl); 5962 5963 // If any errors have occurred, clear out any temporaries that may have 5964 // been leftover. This ensures that these temporaries won't be picked up for 5965 // deletion in some later function. 5966 if (getDiagnostics().hasErrorOccurred()) 5967 ExprTemporaries.clear(); 5968 5969 return dcl; 5970} 5971 5972/// ImplicitlyDefineFunction - An undeclared identifier was used in a function 5973/// call, forming a call to an implicitly defined function (per C99 6.5.1p2). 5974NamedDecl *Sema::ImplicitlyDefineFunction(SourceLocation Loc, 5975 IdentifierInfo &II, Scope *S) { 5976 // Before we produce a declaration for an implicitly defined 5977 // function, see whether there was a locally-scoped declaration of 5978 // this name as a function or variable. If so, use that 5979 // (non-visible) declaration, and complain about it. 5980 llvm::DenseMap<DeclarationName, NamedDecl *>::iterator Pos 5981 = LocallyScopedExternalDecls.find(&II); 5982 if (Pos != LocallyScopedExternalDecls.end()) { 5983 Diag(Loc, diag::warn_use_out_of_scope_declaration) << Pos->second; 5984 Diag(Pos->second->getLocation(), diag::note_previous_declaration); 5985 return Pos->second; 5986 } 5987 5988 // Extension in C99. Legal in C90, but warn about it. 5989 if (II.getName().startswith("__builtin_")) 5990 Diag(Loc, diag::warn_builtin_unknown) << &II; 5991 else if (getLangOptions().C99) 5992 Diag(Loc, diag::ext_implicit_function_decl) << &II; 5993 else 5994 Diag(Loc, diag::warn_implicit_function_decl) << &II; 5995 5996 // Set a Declarator for the implicit definition: int foo(); 5997 const char *Dummy; 5998 AttributeFactory attrFactory; 5999 DeclSpec DS(attrFactory); 6000 unsigned DiagID; 6001 bool Error = DS.SetTypeSpecType(DeclSpec::TST_int, Loc, Dummy, DiagID); 6002 (void)Error; // Silence warning. 6003 assert(!Error && "Error setting up implicit decl!"); 6004 Declarator D(DS, Declarator::BlockContext); 6005 D.AddTypeInfo(DeclaratorChunk::getFunction(false, false, SourceLocation(), 0, 6006 0, 0, true, SourceLocation(), 6007 EST_None, SourceLocation(), 6008 0, 0, 0, 0, Loc, Loc, D), 6009 DS.getAttributes(), 6010 SourceLocation()); 6011 D.SetIdentifier(&II, Loc); 6012 6013 // Insert this function into translation-unit scope. 6014 6015 DeclContext *PrevDC = CurContext; 6016 CurContext = Context.getTranslationUnitDecl(); 6017 6018 FunctionDecl *FD = dyn_cast<FunctionDecl>(ActOnDeclarator(TUScope, D)); 6019 FD->setImplicit(); 6020 6021 CurContext = PrevDC; 6022 6023 AddKnownFunctionAttributes(FD); 6024 6025 return FD; 6026} 6027 6028/// \brief Adds any function attributes that we know a priori based on 6029/// the declaration of this function. 6030/// 6031/// These attributes can apply both to implicitly-declared builtins 6032/// (like __builtin___printf_chk) or to library-declared functions 6033/// like NSLog or printf. 6034void Sema::AddKnownFunctionAttributes(FunctionDecl *FD) { 6035 if (FD->isInvalidDecl()) 6036 return; 6037 6038 // If this is a built-in function, map its builtin attributes to 6039 // actual attributes. 6040 if (unsigned BuiltinID = FD->getBuiltinID()) { 6041 // Handle printf-formatting attributes. 6042 unsigned FormatIdx; 6043 bool HasVAListArg; 6044 if (Context.BuiltinInfo.isPrintfLike(BuiltinID, FormatIdx, HasVAListArg)) { 6045 if (!FD->getAttr<FormatAttr>()) 6046 FD->addAttr(::new (Context) FormatAttr(FD->getLocation(), Context, 6047 "printf", FormatIdx+1, 6048 HasVAListArg ? 0 : FormatIdx+2)); 6049 } 6050 if (Context.BuiltinInfo.isScanfLike(BuiltinID, FormatIdx, 6051 HasVAListArg)) { 6052 if (!FD->getAttr<FormatAttr>()) 6053 FD->addAttr(::new (Context) FormatAttr(FD->getLocation(), Context, 6054 "scanf", FormatIdx+1, 6055 HasVAListArg ? 0 : FormatIdx+2)); 6056 } 6057 6058 // Mark const if we don't care about errno and that is the only 6059 // thing preventing the function from being const. This allows 6060 // IRgen to use LLVM intrinsics for such functions. 6061 if (!getLangOptions().MathErrno && 6062 Context.BuiltinInfo.isConstWithoutErrno(BuiltinID)) { 6063 if (!FD->getAttr<ConstAttr>()) 6064 FD->addAttr(::new (Context) ConstAttr(FD->getLocation(), Context)); 6065 } 6066 6067 if (Context.BuiltinInfo.isNoThrow(BuiltinID)) 6068 FD->addAttr(::new (Context) NoThrowAttr(FD->getLocation(), Context)); 6069 if (Context.BuiltinInfo.isConst(BuiltinID)) 6070 FD->addAttr(::new (Context) ConstAttr(FD->getLocation(), Context)); 6071 } 6072 6073 IdentifierInfo *Name = FD->getIdentifier(); 6074 if (!Name) 6075 return; 6076 if ((!getLangOptions().CPlusPlus && 6077 FD->getDeclContext()->isTranslationUnit()) || 6078 (isa<LinkageSpecDecl>(FD->getDeclContext()) && 6079 cast<LinkageSpecDecl>(FD->getDeclContext())->getLanguage() == 6080 LinkageSpecDecl::lang_c)) { 6081 // Okay: this could be a libc/libm/Objective-C function we know 6082 // about. 6083 } else 6084 return; 6085 6086 if (Name->isStr("NSLog") || Name->isStr("NSLogv")) { 6087 // FIXME: NSLog and NSLogv should be target specific 6088 if (const FormatAttr *Format = FD->getAttr<FormatAttr>()) { 6089 // FIXME: We known better than our headers. 6090 const_cast<FormatAttr *>(Format)->setType(Context, "printf"); 6091 } else 6092 FD->addAttr(::new (Context) FormatAttr(FD->getLocation(), Context, 6093 "printf", 1, 6094 Name->isStr("NSLogv") ? 0 : 2)); 6095 } else if (Name->isStr("asprintf") || Name->isStr("vasprintf")) { 6096 // FIXME: asprintf and vasprintf aren't C99 functions. Should they be 6097 // target-specific builtins, perhaps? 6098 if (!FD->getAttr<FormatAttr>()) 6099 FD->addAttr(::new (Context) FormatAttr(FD->getLocation(), Context, 6100 "printf", 2, 6101 Name->isStr("vasprintf") ? 0 : 3)); 6102 } 6103} 6104 6105TypedefDecl *Sema::ParseTypedefDecl(Scope *S, Declarator &D, QualType T, 6106 TypeSourceInfo *TInfo) { 6107 assert(D.getIdentifier() && "Wrong callback for declspec without declarator"); 6108 assert(!T.isNull() && "GetTypeForDeclarator() returned null type"); 6109 6110 if (!TInfo) { 6111 assert(D.isInvalidType() && "no declarator info for valid type"); 6112 TInfo = Context.getTrivialTypeSourceInfo(T); 6113 } 6114 6115 // Scope manipulation handled by caller. 6116 TypedefDecl *NewTD = TypedefDecl::Create(Context, CurContext, 6117 D.getSourceRange().getBegin(), 6118 D.getIdentifierLoc(), 6119 D.getIdentifier(), 6120 TInfo); 6121 6122 // Bail out immediately if we have an invalid declaration. 6123 if (D.isInvalidType()) { 6124 NewTD->setInvalidDecl(); 6125 return NewTD; 6126 } 6127 6128 // C++ [dcl.typedef]p8: 6129 // If the typedef declaration defines an unnamed class (or 6130 // enum), the first typedef-name declared by the declaration 6131 // to be that class type (or enum type) is used to denote the 6132 // class type (or enum type) for linkage purposes only. 6133 // We need to check whether the type was declared in the declaration. 6134 switch (D.getDeclSpec().getTypeSpecType()) { 6135 case TST_enum: 6136 case TST_struct: 6137 case TST_union: 6138 case TST_class: { 6139 TagDecl *tagFromDeclSpec = cast<TagDecl>(D.getDeclSpec().getRepAsDecl()); 6140 6141 // Do nothing if the tag is not anonymous or already has an 6142 // associated typedef (from an earlier typedef in this decl group). 6143 if (tagFromDeclSpec->getIdentifier()) break; 6144 if (tagFromDeclSpec->getTypedefNameForAnonDecl()) break; 6145 6146 // A well-formed anonymous tag must always be a TUK_Definition. 6147 assert(tagFromDeclSpec->isThisDeclarationADefinition()); 6148 6149 // The type must match the tag exactly; no qualifiers allowed. 6150 if (!Context.hasSameType(T, Context.getTagDeclType(tagFromDeclSpec))) 6151 break; 6152 6153 // Otherwise, set this is the anon-decl typedef for the tag. 6154 tagFromDeclSpec->setTypedefNameForAnonDecl(NewTD); 6155 break; 6156 } 6157 6158 default: 6159 break; 6160 } 6161 6162 return NewTD; 6163} 6164 6165 6166/// \brief Determine whether a tag with a given kind is acceptable 6167/// as a redeclaration of the given tag declaration. 6168/// 6169/// \returns true if the new tag kind is acceptable, false otherwise. 6170bool Sema::isAcceptableTagRedeclaration(const TagDecl *Previous, 6171 TagTypeKind NewTag, 6172 SourceLocation NewTagLoc, 6173 const IdentifierInfo &Name) { 6174 // C++ [dcl.type.elab]p3: 6175 // The class-key or enum keyword present in the 6176 // elaborated-type-specifier shall agree in kind with the 6177 // declaration to which the name in the elaborated-type-specifier 6178 // refers. This rule also applies to the form of 6179 // elaborated-type-specifier that declares a class-name or 6180 // friend class since it can be construed as referring to the 6181 // definition of the class. Thus, in any 6182 // elaborated-type-specifier, the enum keyword shall be used to 6183 // refer to an enumeration (7.2), the union class-key shall be 6184 // used to refer to a union (clause 9), and either the class or 6185 // struct class-key shall be used to refer to a class (clause 9) 6186 // declared using the class or struct class-key. 6187 TagTypeKind OldTag = Previous->getTagKind(); 6188 if (OldTag == NewTag) 6189 return true; 6190 6191 if ((OldTag == TTK_Struct || OldTag == TTK_Class) && 6192 (NewTag == TTK_Struct || NewTag == TTK_Class)) { 6193 // Warn about the struct/class tag mismatch. 6194 bool isTemplate = false; 6195 if (const CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(Previous)) 6196 isTemplate = Record->getDescribedClassTemplate(); 6197 6198 Diag(NewTagLoc, diag::warn_struct_class_tag_mismatch) 6199 << (NewTag == TTK_Class) 6200 << isTemplate << &Name 6201 << FixItHint::CreateReplacement(SourceRange(NewTagLoc), 6202 OldTag == TTK_Class? "class" : "struct"); 6203 Diag(Previous->getLocation(), diag::note_previous_use); 6204 return true; 6205 } 6206 return false; 6207} 6208 6209/// ActOnTag - This is invoked when we see 'struct foo' or 'struct {'. In the 6210/// former case, Name will be non-null. In the later case, Name will be null. 6211/// TagSpec indicates what kind of tag this is. TUK indicates whether this is a 6212/// reference/declaration/definition of a tag. 6213Decl *Sema::ActOnTag(Scope *S, unsigned TagSpec, TagUseKind TUK, 6214 SourceLocation KWLoc, CXXScopeSpec &SS, 6215 IdentifierInfo *Name, SourceLocation NameLoc, 6216 AttributeList *Attr, AccessSpecifier AS, 6217 MultiTemplateParamsArg TemplateParameterLists, 6218 bool &OwnedDecl, bool &IsDependent, 6219 bool ScopedEnum, bool ScopedEnumUsesClassTag, 6220 TypeResult UnderlyingType) { 6221 // If this is not a definition, it must have a name. 6222 assert((Name != 0 || TUK == TUK_Definition) && 6223 "Nameless record must be a definition!"); 6224 assert(TemplateParameterLists.size() == 0 || TUK != TUK_Reference); 6225 6226 OwnedDecl = false; 6227 TagTypeKind Kind = TypeWithKeyword::getTagTypeKindForTypeSpec(TagSpec); 6228 6229 // FIXME: Check explicit specializations more carefully. 6230 bool isExplicitSpecialization = false; 6231 bool Invalid = false; 6232 6233 // We only need to do this matching if we have template parameters 6234 // or a scope specifier, which also conveniently avoids this work 6235 // for non-C++ cases. 6236 if (TemplateParameterLists.size() > 0 || 6237 (SS.isNotEmpty() && TUK != TUK_Reference)) { 6238 if (TemplateParameterList *TemplateParams 6239 = MatchTemplateParametersToScopeSpecifier(KWLoc, SS, 6240 TemplateParameterLists.get(), 6241 TemplateParameterLists.size(), 6242 TUK == TUK_Friend, 6243 isExplicitSpecialization, 6244 Invalid)) { 6245 if (TemplateParams->size() > 0) { 6246 // This is a declaration or definition of a class template (which may 6247 // be a member of another template). 6248 6249 if (Invalid) 6250 return 0; 6251 6252 OwnedDecl = false; 6253 DeclResult Result = CheckClassTemplate(S, TagSpec, TUK, KWLoc, 6254 SS, Name, NameLoc, Attr, 6255 TemplateParams, AS, 6256 TemplateParameterLists.size() - 1, 6257 (TemplateParameterList**) TemplateParameterLists.release()); 6258 return Result.get(); 6259 } else { 6260 // The "template<>" header is extraneous. 6261 Diag(TemplateParams->getTemplateLoc(), diag::err_template_tag_noparams) 6262 << TypeWithKeyword::getTagTypeKindName(Kind) << Name; 6263 isExplicitSpecialization = true; 6264 } 6265 } 6266 } 6267 6268 // Figure out the underlying type if this a enum declaration. We need to do 6269 // this early, because it's needed to detect if this is an incompatible 6270 // redeclaration. 6271 llvm::PointerUnion<const Type*, TypeSourceInfo*> EnumUnderlying; 6272 6273 if (Kind == TTK_Enum) { 6274 if (UnderlyingType.isInvalid() || (!UnderlyingType.get() && ScopedEnum)) 6275 // No underlying type explicitly specified, or we failed to parse the 6276 // type, default to int. 6277 EnumUnderlying = Context.IntTy.getTypePtr(); 6278 else if (UnderlyingType.get()) { 6279 // C++0x 7.2p2: The type-specifier-seq of an enum-base shall name an 6280 // integral type; any cv-qualification is ignored. 6281 TypeSourceInfo *TI = 0; 6282 QualType T = GetTypeFromParser(UnderlyingType.get(), &TI); 6283 EnumUnderlying = TI; 6284 6285 SourceLocation UnderlyingLoc = TI->getTypeLoc().getBeginLoc(); 6286 6287 if (!T->isDependentType() && !T->isIntegralType(Context)) { 6288 Diag(UnderlyingLoc, diag::err_enum_invalid_underlying) 6289 << T; 6290 // Recover by falling back to int. 6291 EnumUnderlying = Context.IntTy.getTypePtr(); 6292 } 6293 6294 if (DiagnoseUnexpandedParameterPack(UnderlyingLoc, TI, 6295 UPPC_FixedUnderlyingType)) 6296 EnumUnderlying = Context.IntTy.getTypePtr(); 6297 6298 } else if (getLangOptions().Microsoft) 6299 // Microsoft enums are always of int type. 6300 EnumUnderlying = Context.IntTy.getTypePtr(); 6301 } 6302 6303 DeclContext *SearchDC = CurContext; 6304 DeclContext *DC = CurContext; 6305 bool isStdBadAlloc = false; 6306 6307 RedeclarationKind Redecl = ForRedeclaration; 6308 if (TUK == TUK_Friend || TUK == TUK_Reference) 6309 Redecl = NotForRedeclaration; 6310 6311 LookupResult Previous(*this, Name, NameLoc, LookupTagName, Redecl); 6312 6313 if (Name && SS.isNotEmpty()) { 6314 // We have a nested-name tag ('struct foo::bar'). 6315 6316 // Check for invalid 'foo::'. 6317 if (SS.isInvalid()) { 6318 Name = 0; 6319 goto CreateNewDecl; 6320 } 6321 6322 // If this is a friend or a reference to a class in a dependent 6323 // context, don't try to make a decl for it. 6324 if (TUK == TUK_Friend || TUK == TUK_Reference) { 6325 DC = computeDeclContext(SS, false); 6326 if (!DC) { 6327 IsDependent = true; 6328 return 0; 6329 } 6330 } else { 6331 DC = computeDeclContext(SS, true); 6332 if (!DC) { 6333 Diag(SS.getRange().getBegin(), diag::err_dependent_nested_name_spec) 6334 << SS.getRange(); 6335 return 0; 6336 } 6337 } 6338 6339 if (RequireCompleteDeclContext(SS, DC)) 6340 return 0; 6341 6342 SearchDC = DC; 6343 // Look-up name inside 'foo::'. 6344 LookupQualifiedName(Previous, DC); 6345 6346 if (Previous.isAmbiguous()) 6347 return 0; 6348 6349 if (Previous.empty()) { 6350 // Name lookup did not find anything. However, if the 6351 // nested-name-specifier refers to the current instantiation, 6352 // and that current instantiation has any dependent base 6353 // classes, we might find something at instantiation time: treat 6354 // this as a dependent elaborated-type-specifier. 6355 // But this only makes any sense for reference-like lookups. 6356 if (Previous.wasNotFoundInCurrentInstantiation() && 6357 (TUK == TUK_Reference || TUK == TUK_Friend)) { 6358 IsDependent = true; 6359 return 0; 6360 } 6361 6362 // A tag 'foo::bar' must already exist. 6363 Diag(NameLoc, diag::err_not_tag_in_scope) 6364 << Kind << Name << DC << SS.getRange(); 6365 Name = 0; 6366 Invalid = true; 6367 goto CreateNewDecl; 6368 } 6369 } else if (Name) { 6370 // If this is a named struct, check to see if there was a previous forward 6371 // declaration or definition. 6372 // FIXME: We're looking into outer scopes here, even when we 6373 // shouldn't be. Doing so can result in ambiguities that we 6374 // shouldn't be diagnosing. 6375 LookupName(Previous, S); 6376 6377 // Note: there used to be some attempt at recovery here. 6378 if (Previous.isAmbiguous()) 6379 return 0; 6380 6381 if (!getLangOptions().CPlusPlus && TUK != TUK_Reference) { 6382 // FIXME: This makes sure that we ignore the contexts associated 6383 // with C structs, unions, and enums when looking for a matching 6384 // tag declaration or definition. See the similar lookup tweak 6385 // in Sema::LookupName; is there a better way to deal with this? 6386 while (isa<RecordDecl>(SearchDC) || isa<EnumDecl>(SearchDC)) 6387 SearchDC = SearchDC->getParent(); 6388 } 6389 } else if (S->isFunctionPrototypeScope()) { 6390 // If this is an enum declaration in function prototype scope, set its 6391 // initial context to the translation unit. 6392 SearchDC = Context.getTranslationUnitDecl(); 6393 } 6394 6395 if (Previous.isSingleResult() && 6396 Previous.getFoundDecl()->isTemplateParameter()) { 6397 // Maybe we will complain about the shadowed template parameter. 6398 DiagnoseTemplateParameterShadow(NameLoc, Previous.getFoundDecl()); 6399 // Just pretend that we didn't see the previous declaration. 6400 Previous.clear(); 6401 } 6402 6403 if (getLangOptions().CPlusPlus && Name && DC && StdNamespace && 6404 DC->Equals(getStdNamespace()) && Name->isStr("bad_alloc")) { 6405 // This is a declaration of or a reference to "std::bad_alloc". 6406 isStdBadAlloc = true; 6407 6408 if (Previous.empty() && StdBadAlloc) { 6409 // std::bad_alloc has been implicitly declared (but made invisible to 6410 // name lookup). Fill in this implicit declaration as the previous 6411 // declaration, so that the declarations get chained appropriately. 6412 Previous.addDecl(getStdBadAlloc()); 6413 } 6414 } 6415 6416 // If we didn't find a previous declaration, and this is a reference 6417 // (or friend reference), move to the correct scope. In C++, we 6418 // also need to do a redeclaration lookup there, just in case 6419 // there's a shadow friend decl. 6420 if (Name && Previous.empty() && 6421 (TUK == TUK_Reference || TUK == TUK_Friend)) { 6422 if (Invalid) goto CreateNewDecl; 6423 assert(SS.isEmpty()); 6424 6425 if (TUK == TUK_Reference) { 6426 // C++ [basic.scope.pdecl]p5: 6427 // -- for an elaborated-type-specifier of the form 6428 // 6429 // class-key identifier 6430 // 6431 // if the elaborated-type-specifier is used in the 6432 // decl-specifier-seq or parameter-declaration-clause of a 6433 // function defined in namespace scope, the identifier is 6434 // declared as a class-name in the namespace that contains 6435 // the declaration; otherwise, except as a friend 6436 // declaration, the identifier is declared in the smallest 6437 // non-class, non-function-prototype scope that contains the 6438 // declaration. 6439 // 6440 // C99 6.7.2.3p8 has a similar (but not identical!) provision for 6441 // C structs and unions. 6442 // 6443 // It is an error in C++ to declare (rather than define) an enum 6444 // type, including via an elaborated type specifier. We'll 6445 // diagnose that later; for now, declare the enum in the same 6446 // scope as we would have picked for any other tag type. 6447 // 6448 // GNU C also supports this behavior as part of its incomplete 6449 // enum types extension, while GNU C++ does not. 6450 // 6451 // Find the context where we'll be declaring the tag. 6452 // FIXME: We would like to maintain the current DeclContext as the 6453 // lexical context, 6454 while (SearchDC->isRecord() || SearchDC->isTransparentContext()) 6455 SearchDC = SearchDC->getParent(); 6456 6457 // Find the scope where we'll be declaring the tag. 6458 while (S->isClassScope() || 6459 (getLangOptions().CPlusPlus && 6460 S->isFunctionPrototypeScope()) || 6461 ((S->getFlags() & Scope::DeclScope) == 0) || 6462 (S->getEntity() && 6463 ((DeclContext *)S->getEntity())->isTransparentContext())) 6464 S = S->getParent(); 6465 } else { 6466 assert(TUK == TUK_Friend); 6467 // C++ [namespace.memdef]p3: 6468 // If a friend declaration in a non-local class first declares a 6469 // class or function, the friend class or function is a member of 6470 // the innermost enclosing namespace. 6471 SearchDC = SearchDC->getEnclosingNamespaceContext(); 6472 } 6473 6474 // In C++, we need to do a redeclaration lookup to properly 6475 // diagnose some problems. 6476 if (getLangOptions().CPlusPlus) { 6477 Previous.setRedeclarationKind(ForRedeclaration); 6478 LookupQualifiedName(Previous, SearchDC); 6479 } 6480 } 6481 6482 if (!Previous.empty()) { 6483 NamedDecl *PrevDecl = (*Previous.begin())->getUnderlyingDecl(); 6484 6485 // It's okay to have a tag decl in the same scope as a typedef 6486 // which hides a tag decl in the same scope. Finding this 6487 // insanity with a redeclaration lookup can only actually happen 6488 // in C++. 6489 // 6490 // This is also okay for elaborated-type-specifiers, which is 6491 // technically forbidden by the current standard but which is 6492 // okay according to the likely resolution of an open issue; 6493 // see http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#407 6494 if (getLangOptions().CPlusPlus) { 6495 if (TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(PrevDecl)) { 6496 if (const TagType *TT = TD->getUnderlyingType()->getAs<TagType>()) { 6497 TagDecl *Tag = TT->getDecl(); 6498 if (Tag->getDeclName() == Name && 6499 Tag->getDeclContext()->getRedeclContext() 6500 ->Equals(TD->getDeclContext()->getRedeclContext())) { 6501 PrevDecl = Tag; 6502 Previous.clear(); 6503 Previous.addDecl(Tag); 6504 Previous.resolveKind(); 6505 } 6506 } 6507 } 6508 } 6509 6510 if (TagDecl *PrevTagDecl = dyn_cast<TagDecl>(PrevDecl)) { 6511 // If this is a use of a previous tag, or if the tag is already declared 6512 // in the same scope (so that the definition/declaration completes or 6513 // rementions the tag), reuse the decl. 6514 if (TUK == TUK_Reference || TUK == TUK_Friend || 6515 isDeclInScope(PrevDecl, SearchDC, S, isExplicitSpecialization)) { 6516 // Make sure that this wasn't declared as an enum and now used as a 6517 // struct or something similar. 6518 if (!isAcceptableTagRedeclaration(PrevTagDecl, Kind, KWLoc, *Name)) { 6519 bool SafeToContinue 6520 = (PrevTagDecl->getTagKind() != TTK_Enum && 6521 Kind != TTK_Enum); 6522 if (SafeToContinue) 6523 Diag(KWLoc, diag::err_use_with_wrong_tag) 6524 << Name 6525 << FixItHint::CreateReplacement(SourceRange(KWLoc), 6526 PrevTagDecl->getKindName()); 6527 else 6528 Diag(KWLoc, diag::err_use_with_wrong_tag) << Name; 6529 Diag(PrevTagDecl->getLocation(), diag::note_previous_use); 6530 6531 if (SafeToContinue) 6532 Kind = PrevTagDecl->getTagKind(); 6533 else { 6534 // Recover by making this an anonymous redefinition. 6535 Name = 0; 6536 Previous.clear(); 6537 Invalid = true; 6538 } 6539 } 6540 6541 if (Kind == TTK_Enum && PrevTagDecl->getTagKind() == TTK_Enum) { 6542 const EnumDecl *PrevEnum = cast<EnumDecl>(PrevTagDecl); 6543 6544 // All conflicts with previous declarations are recovered by 6545 // returning the previous declaration. 6546 if (ScopedEnum != PrevEnum->isScoped()) { 6547 Diag(KWLoc, diag::err_enum_redeclare_scoped_mismatch) 6548 << PrevEnum->isScoped(); 6549 Diag(PrevTagDecl->getLocation(), diag::note_previous_use); 6550 return PrevTagDecl; 6551 } 6552 else if (EnumUnderlying && PrevEnum->isFixed()) { 6553 QualType T; 6554 if (TypeSourceInfo *TI = EnumUnderlying.dyn_cast<TypeSourceInfo*>()) 6555 T = TI->getType(); 6556 else 6557 T = QualType(EnumUnderlying.get<const Type*>(), 0); 6558 6559 if (!Context.hasSameUnqualifiedType(T, PrevEnum->getIntegerType())) { 6560 Diag(NameLoc.isValid() ? NameLoc : KWLoc, 6561 diag::err_enum_redeclare_type_mismatch) 6562 << T 6563 << PrevEnum->getIntegerType(); 6564 Diag(PrevTagDecl->getLocation(), diag::note_previous_use); 6565 return PrevTagDecl; 6566 } 6567 } 6568 else if (!EnumUnderlying.isNull() != PrevEnum->isFixed()) { 6569 Diag(KWLoc, diag::err_enum_redeclare_fixed_mismatch) 6570 << PrevEnum->isFixed(); 6571 Diag(PrevTagDecl->getLocation(), diag::note_previous_use); 6572 return PrevTagDecl; 6573 } 6574 } 6575 6576 if (!Invalid) { 6577 // If this is a use, just return the declaration we found. 6578 6579 // FIXME: In the future, return a variant or some other clue 6580 // for the consumer of this Decl to know it doesn't own it. 6581 // For our current ASTs this shouldn't be a problem, but will 6582 // need to be changed with DeclGroups. 6583 if ((TUK == TUK_Reference && !PrevTagDecl->getFriendObjectKind()) || 6584 TUK == TUK_Friend) 6585 return PrevTagDecl; 6586 6587 // Diagnose attempts to redefine a tag. 6588 if (TUK == TUK_Definition) { 6589 if (TagDecl *Def = PrevTagDecl->getDefinition()) { 6590 // If we're defining a specialization and the previous definition 6591 // is from an implicit instantiation, don't emit an error 6592 // here; we'll catch this in the general case below. 6593 if (!isExplicitSpecialization || 6594 !isa<CXXRecordDecl>(Def) || 6595 cast<CXXRecordDecl>(Def)->getTemplateSpecializationKind() 6596 == TSK_ExplicitSpecialization) { 6597 Diag(NameLoc, diag::err_redefinition) << Name; 6598 Diag(Def->getLocation(), diag::note_previous_definition); 6599 // If this is a redefinition, recover by making this 6600 // struct be anonymous, which will make any later 6601 // references get the previous definition. 6602 Name = 0; 6603 Previous.clear(); 6604 Invalid = true; 6605 } 6606 } else { 6607 // If the type is currently being defined, complain 6608 // about a nested redefinition. 6609 const TagType *Tag 6610 = cast<TagType>(Context.getTagDeclType(PrevTagDecl)); 6611 if (Tag->isBeingDefined()) { 6612 Diag(NameLoc, diag::err_nested_redefinition) << Name; 6613 Diag(PrevTagDecl->getLocation(), 6614 diag::note_previous_definition); 6615 Name = 0; 6616 Previous.clear(); 6617 Invalid = true; 6618 } 6619 } 6620 6621 // Okay, this is definition of a previously declared or referenced 6622 // tag PrevDecl. We're going to create a new Decl for it. 6623 } 6624 } 6625 // If we get here we have (another) forward declaration or we 6626 // have a definition. Just create a new decl. 6627 6628 } else { 6629 // If we get here, this is a definition of a new tag type in a nested 6630 // scope, e.g. "struct foo; void bar() { struct foo; }", just create a 6631 // new decl/type. We set PrevDecl to NULL so that the entities 6632 // have distinct types. 6633 Previous.clear(); 6634 } 6635 // If we get here, we're going to create a new Decl. If PrevDecl 6636 // is non-NULL, it's a definition of the tag declared by 6637 // PrevDecl. If it's NULL, we have a new definition. 6638 6639 6640 // Otherwise, PrevDecl is not a tag, but was found with tag 6641 // lookup. This is only actually possible in C++, where a few 6642 // things like templates still live in the tag namespace. 6643 } else { 6644 assert(getLangOptions().CPlusPlus); 6645 6646 // Use a better diagnostic if an elaborated-type-specifier 6647 // found the wrong kind of type on the first 6648 // (non-redeclaration) lookup. 6649 if ((TUK == TUK_Reference || TUK == TUK_Friend) && 6650 !Previous.isForRedeclaration()) { 6651 unsigned Kind = 0; 6652 if (isa<TypedefDecl>(PrevDecl)) Kind = 1; 6653 else if (isa<TypeAliasDecl>(PrevDecl)) Kind = 2; 6654 else if (isa<ClassTemplateDecl>(PrevDecl)) Kind = 3; 6655 Diag(NameLoc, diag::err_tag_reference_non_tag) << Kind; 6656 Diag(PrevDecl->getLocation(), diag::note_declared_at); 6657 Invalid = true; 6658 6659 // Otherwise, only diagnose if the declaration is in scope. 6660 } else if (!isDeclInScope(PrevDecl, SearchDC, S, 6661 isExplicitSpecialization)) { 6662 // do nothing 6663 6664 // Diagnose implicit declarations introduced by elaborated types. 6665 } else if (TUK == TUK_Reference || TUK == TUK_Friend) { 6666 unsigned Kind = 0; 6667 if (isa<TypedefDecl>(PrevDecl)) Kind = 1; 6668 else if (isa<TypeAliasDecl>(PrevDecl)) Kind = 2; 6669 else if (isa<ClassTemplateDecl>(PrevDecl)) Kind = 3; 6670 Diag(NameLoc, diag::err_tag_reference_conflict) << Kind; 6671 Diag(PrevDecl->getLocation(), diag::note_previous_decl) << PrevDecl; 6672 Invalid = true; 6673 6674 // Otherwise it's a declaration. Call out a particularly common 6675 // case here. 6676 } else if (TypedefNameDecl *TND = dyn_cast<TypedefNameDecl>(PrevDecl)) { 6677 unsigned Kind = 0; 6678 if (isa<TypeAliasDecl>(PrevDecl)) Kind = 1; 6679 Diag(NameLoc, diag::err_tag_definition_of_typedef) 6680 << Name << Kind << TND->getUnderlyingType(); 6681 Diag(PrevDecl->getLocation(), diag::note_previous_decl) << PrevDecl; 6682 Invalid = true; 6683 6684 // Otherwise, diagnose. 6685 } else { 6686 // The tag name clashes with something else in the target scope, 6687 // issue an error and recover by making this tag be anonymous. 6688 Diag(NameLoc, diag::err_redefinition_different_kind) << Name; 6689 Diag(PrevDecl->getLocation(), diag::note_previous_definition); 6690 Name = 0; 6691 Invalid = true; 6692 } 6693 6694 // The existing declaration isn't relevant to us; we're in a 6695 // new scope, so clear out the previous declaration. 6696 Previous.clear(); 6697 } 6698 } 6699 6700CreateNewDecl: 6701 6702 TagDecl *PrevDecl = 0; 6703 if (Previous.isSingleResult()) 6704 PrevDecl = cast<TagDecl>(Previous.getFoundDecl()); 6705 6706 // If there is an identifier, use the location of the identifier as the 6707 // location of the decl, otherwise use the location of the struct/union 6708 // keyword. 6709 SourceLocation Loc = NameLoc.isValid() ? NameLoc : KWLoc; 6710 6711 // Otherwise, create a new declaration. If there is a previous 6712 // declaration of the same entity, the two will be linked via 6713 // PrevDecl. 6714 TagDecl *New; 6715 6716 bool IsForwardReference = false; 6717 if (Kind == TTK_Enum) { 6718 // FIXME: Tag decls should be chained to any simultaneous vardecls, e.g.: 6719 // enum X { A, B, C } D; D should chain to X. 6720 New = EnumDecl::Create(Context, SearchDC, KWLoc, Loc, Name, 6721 cast_or_null<EnumDecl>(PrevDecl), ScopedEnum, 6722 ScopedEnumUsesClassTag, !EnumUnderlying.isNull()); 6723 // If this is an undefined enum, warn. 6724 if (TUK != TUK_Definition && !Invalid) { 6725 TagDecl *Def; 6726 if (getLangOptions().CPlusPlus0x && cast<EnumDecl>(New)->isFixed()) { 6727 // C++0x: 7.2p2: opaque-enum-declaration. 6728 // Conflicts are diagnosed above. Do nothing. 6729 } 6730 else if (PrevDecl && (Def = cast<EnumDecl>(PrevDecl)->getDefinition())) { 6731 Diag(Loc, diag::ext_forward_ref_enum_def) 6732 << New; 6733 Diag(Def->getLocation(), diag::note_previous_definition); 6734 } else { 6735 unsigned DiagID = diag::ext_forward_ref_enum; 6736 if (getLangOptions().Microsoft) 6737 DiagID = diag::ext_ms_forward_ref_enum; 6738 else if (getLangOptions().CPlusPlus) 6739 DiagID = diag::err_forward_ref_enum; 6740 Diag(Loc, DiagID); 6741 6742 // If this is a forward-declared reference to an enumeration, make a 6743 // note of it; we won't actually be introducing the declaration into 6744 // the declaration context. 6745 if (TUK == TUK_Reference) 6746 IsForwardReference = true; 6747 } 6748 } 6749 6750 if (EnumUnderlying) { 6751 EnumDecl *ED = cast<EnumDecl>(New); 6752 if (TypeSourceInfo *TI = EnumUnderlying.dyn_cast<TypeSourceInfo*>()) 6753 ED->setIntegerTypeSourceInfo(TI); 6754 else 6755 ED->setIntegerType(QualType(EnumUnderlying.get<const Type*>(), 0)); 6756 ED->setPromotionType(ED->getIntegerType()); 6757 } 6758 6759 } else { 6760 // struct/union/class 6761 6762 // FIXME: Tag decls should be chained to any simultaneous vardecls, e.g.: 6763 // struct X { int A; } D; D should chain to X. 6764 if (getLangOptions().CPlusPlus) { 6765 // FIXME: Look for a way to use RecordDecl for simple structs. 6766 New = CXXRecordDecl::Create(Context, Kind, SearchDC, KWLoc, Loc, Name, 6767 cast_or_null<CXXRecordDecl>(PrevDecl)); 6768 6769 if (isStdBadAlloc && (!StdBadAlloc || getStdBadAlloc()->isImplicit())) 6770 StdBadAlloc = cast<CXXRecordDecl>(New); 6771 } else 6772 New = RecordDecl::Create(Context, Kind, SearchDC, KWLoc, Loc, Name, 6773 cast_or_null<RecordDecl>(PrevDecl)); 6774 } 6775 6776 // Maybe add qualifier info. 6777 if (SS.isNotEmpty()) { 6778 if (SS.isSet()) { 6779 New->setQualifierInfo(SS.getWithLocInContext(Context)); 6780 if (TemplateParameterLists.size() > 0) { 6781 New->setTemplateParameterListsInfo(Context, 6782 TemplateParameterLists.size(), 6783 (TemplateParameterList**) TemplateParameterLists.release()); 6784 } 6785 } 6786 else 6787 Invalid = true; 6788 } 6789 6790 if (RecordDecl *RD = dyn_cast<RecordDecl>(New)) { 6791 // Add alignment attributes if necessary; these attributes are checked when 6792 // the ASTContext lays out the structure. 6793 // 6794 // It is important for implementing the correct semantics that this 6795 // happen here (in act on tag decl). The #pragma pack stack is 6796 // maintained as a result of parser callbacks which can occur at 6797 // many points during the parsing of a struct declaration (because 6798 // the #pragma tokens are effectively skipped over during the 6799 // parsing of the struct). 6800 AddAlignmentAttributesForRecord(RD); 6801 } 6802 6803 // If this is a specialization of a member class (of a class template), 6804 // check the specialization. 6805 if (isExplicitSpecialization && CheckMemberSpecialization(New, Previous)) 6806 Invalid = true; 6807 6808 if (Invalid) 6809 New->setInvalidDecl(); 6810 6811 if (Attr) 6812 ProcessDeclAttributeList(S, New, Attr); 6813 6814 // If we're declaring or defining a tag in function prototype scope 6815 // in C, note that this type can only be used within the function. 6816 if (Name && S->isFunctionPrototypeScope() && !getLangOptions().CPlusPlus) 6817 Diag(Loc, diag::warn_decl_in_param_list) << Context.getTagDeclType(New); 6818 6819 // Set the lexical context. If the tag has a C++ scope specifier, the 6820 // lexical context will be different from the semantic context. 6821 New->setLexicalDeclContext(CurContext); 6822 6823 // Mark this as a friend decl if applicable. 6824 if (TUK == TUK_Friend) 6825 New->setObjectOfFriendDecl(/* PreviouslyDeclared = */ !Previous.empty()); 6826 6827 // Set the access specifier. 6828 if (!Invalid && SearchDC->isRecord()) 6829 SetMemberAccessSpecifier(New, PrevDecl, AS); 6830 6831 if (TUK == TUK_Definition) 6832 New->startDefinition(); 6833 6834 // If this has an identifier, add it to the scope stack. 6835 if (TUK == TUK_Friend) { 6836 // We might be replacing an existing declaration in the lookup tables; 6837 // if so, borrow its access specifier. 6838 if (PrevDecl) 6839 New->setAccess(PrevDecl->getAccess()); 6840 6841 DeclContext *DC = New->getDeclContext()->getRedeclContext(); 6842 DC->makeDeclVisibleInContext(New, /* Recoverable = */ false); 6843 if (Name) // can be null along some error paths 6844 if (Scope *EnclosingScope = getScopeForDeclContext(S, DC)) 6845 PushOnScopeChains(New, EnclosingScope, /* AddToContext = */ false); 6846 } else if (Name) { 6847 S = getNonFieldDeclScope(S); 6848 PushOnScopeChains(New, S, !IsForwardReference); 6849 if (IsForwardReference) 6850 SearchDC->makeDeclVisibleInContext(New, /* Recoverable = */ false); 6851 6852 } else { 6853 CurContext->addDecl(New); 6854 } 6855 6856 // If this is the C FILE type, notify the AST context. 6857 if (IdentifierInfo *II = New->getIdentifier()) 6858 if (!New->isInvalidDecl() && 6859 New->getDeclContext()->getRedeclContext()->isTranslationUnit() && 6860 II->isStr("FILE")) 6861 Context.setFILEDecl(New); 6862 6863 OwnedDecl = true; 6864 return New; 6865} 6866 6867void Sema::ActOnTagStartDefinition(Scope *S, Decl *TagD) { 6868 AdjustDeclIfTemplate(TagD); 6869 TagDecl *Tag = cast<TagDecl>(TagD); 6870 6871 // Enter the tag context. 6872 PushDeclContext(S, Tag); 6873} 6874 6875void Sema::ActOnStartCXXMemberDeclarations(Scope *S, Decl *TagD, 6876 SourceLocation FinalLoc, 6877 SourceLocation LBraceLoc) { 6878 AdjustDeclIfTemplate(TagD); 6879 CXXRecordDecl *Record = cast<CXXRecordDecl>(TagD); 6880 6881 FieldCollector->StartClass(); 6882 6883 if (!Record->getIdentifier()) 6884 return; 6885 6886 if (FinalLoc.isValid()) 6887 Record->addAttr(new (Context) FinalAttr(FinalLoc, Context)); 6888 6889 // C++ [class]p2: 6890 // [...] The class-name is also inserted into the scope of the 6891 // class itself; this is known as the injected-class-name. For 6892 // purposes of access checking, the injected-class-name is treated 6893 // as if it were a public member name. 6894 CXXRecordDecl *InjectedClassName 6895 = CXXRecordDecl::Create(Context, Record->getTagKind(), CurContext, 6896 Record->getLocStart(), Record->getLocation(), 6897 Record->getIdentifier(), 6898 /*PrevDecl=*/0, 6899 /*DelayTypeCreation=*/true); 6900 Context.getTypeDeclType(InjectedClassName, Record); 6901 InjectedClassName->setImplicit(); 6902 InjectedClassName->setAccess(AS_public); 6903 if (ClassTemplateDecl *Template = Record->getDescribedClassTemplate()) 6904 InjectedClassName->setDescribedClassTemplate(Template); 6905 PushOnScopeChains(InjectedClassName, S); 6906 assert(InjectedClassName->isInjectedClassName() && 6907 "Broken injected-class-name"); 6908} 6909 6910void Sema::ActOnTagFinishDefinition(Scope *S, Decl *TagD, 6911 SourceLocation RBraceLoc) { 6912 AdjustDeclIfTemplate(TagD); 6913 TagDecl *Tag = cast<TagDecl>(TagD); 6914 Tag->setRBraceLoc(RBraceLoc); 6915 6916 if (isa<CXXRecordDecl>(Tag)) 6917 FieldCollector->FinishClass(); 6918 6919 // Exit this scope of this tag's definition. 6920 PopDeclContext(); 6921 6922 // Notify the consumer that we've defined a tag. 6923 Consumer.HandleTagDeclDefinition(Tag); 6924} 6925 6926void Sema::ActOnTagDefinitionError(Scope *S, Decl *TagD) { 6927 AdjustDeclIfTemplate(TagD); 6928 TagDecl *Tag = cast<TagDecl>(TagD); 6929 Tag->setInvalidDecl(); 6930 6931 // We're undoing ActOnTagStartDefinition here, not 6932 // ActOnStartCXXMemberDeclarations, so we don't have to mess with 6933 // the FieldCollector. 6934 6935 PopDeclContext(); 6936} 6937 6938// Note that FieldName may be null for anonymous bitfields. 6939bool Sema::VerifyBitField(SourceLocation FieldLoc, IdentifierInfo *FieldName, 6940 QualType FieldTy, const Expr *BitWidth, 6941 bool *ZeroWidth) { 6942 // Default to true; that shouldn't confuse checks for emptiness 6943 if (ZeroWidth) 6944 *ZeroWidth = true; 6945 6946 // C99 6.7.2.1p4 - verify the field type. 6947 // C++ 9.6p3: A bit-field shall have integral or enumeration type. 6948 if (!FieldTy->isDependentType() && !FieldTy->isIntegralOrEnumerationType()) { 6949 // Handle incomplete types with specific error. 6950 if (RequireCompleteType(FieldLoc, FieldTy, diag::err_field_incomplete)) 6951 return true; 6952 if (FieldName) 6953 return Diag(FieldLoc, diag::err_not_integral_type_bitfield) 6954 << FieldName << FieldTy << BitWidth->getSourceRange(); 6955 return Diag(FieldLoc, diag::err_not_integral_type_anon_bitfield) 6956 << FieldTy << BitWidth->getSourceRange(); 6957 } else if (DiagnoseUnexpandedParameterPack(const_cast<Expr *>(BitWidth), 6958 UPPC_BitFieldWidth)) 6959 return true; 6960 6961 // If the bit-width is type- or value-dependent, don't try to check 6962 // it now. 6963 if (BitWidth->isValueDependent() || BitWidth->isTypeDependent()) 6964 return false; 6965 6966 llvm::APSInt Value; 6967 if (VerifyIntegerConstantExpression(BitWidth, &Value)) 6968 return true; 6969 6970 if (Value != 0 && ZeroWidth) 6971 *ZeroWidth = false; 6972 6973 // Zero-width bitfield is ok for anonymous field. 6974 if (Value == 0 && FieldName) 6975 return Diag(FieldLoc, diag::err_bitfield_has_zero_width) << FieldName; 6976 6977 if (Value.isSigned() && Value.isNegative()) { 6978 if (FieldName) 6979 return Diag(FieldLoc, diag::err_bitfield_has_negative_width) 6980 << FieldName << Value.toString(10); 6981 return Diag(FieldLoc, diag::err_anon_bitfield_has_negative_width) 6982 << Value.toString(10); 6983 } 6984 6985 if (!FieldTy->isDependentType()) { 6986 uint64_t TypeSize = Context.getTypeSize(FieldTy); 6987 if (Value.getZExtValue() > TypeSize) { 6988 if (!getLangOptions().CPlusPlus) { 6989 if (FieldName) 6990 return Diag(FieldLoc, diag::err_bitfield_width_exceeds_type_size) 6991 << FieldName << (unsigned)Value.getZExtValue() 6992 << (unsigned)TypeSize; 6993 6994 return Diag(FieldLoc, diag::err_anon_bitfield_width_exceeds_type_size) 6995 << (unsigned)Value.getZExtValue() << (unsigned)TypeSize; 6996 } 6997 6998 if (FieldName) 6999 Diag(FieldLoc, diag::warn_bitfield_width_exceeds_type_size) 7000 << FieldName << (unsigned)Value.getZExtValue() 7001 << (unsigned)TypeSize; 7002 else 7003 Diag(FieldLoc, diag::warn_anon_bitfield_width_exceeds_type_size) 7004 << (unsigned)Value.getZExtValue() << (unsigned)TypeSize; 7005 } 7006 } 7007 7008 return false; 7009} 7010 7011/// ActOnField - Each field of a struct/union/class is passed into this in order 7012/// to create a FieldDecl object for it. 7013Decl *Sema::ActOnField(Scope *S, Decl *TagD, 7014 SourceLocation DeclStart, 7015 Declarator &D, ExprTy *BitfieldWidth) { 7016 FieldDecl *Res = HandleField(S, cast_or_null<RecordDecl>(TagD), 7017 DeclStart, D, static_cast<Expr*>(BitfieldWidth), 7018 AS_public); 7019 return Res; 7020} 7021 7022/// HandleField - Analyze a field of a C struct or a C++ data member. 7023/// 7024FieldDecl *Sema::HandleField(Scope *S, RecordDecl *Record, 7025 SourceLocation DeclStart, 7026 Declarator &D, Expr *BitWidth, 7027 AccessSpecifier AS) { 7028 IdentifierInfo *II = D.getIdentifier(); 7029 SourceLocation Loc = DeclStart; 7030 if (II) Loc = D.getIdentifierLoc(); 7031 7032 TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S); 7033 QualType T = TInfo->getType(); 7034 if (getLangOptions().CPlusPlus) { 7035 CheckExtraCXXDefaultArguments(D); 7036 7037 if (DiagnoseUnexpandedParameterPack(D.getIdentifierLoc(), TInfo, 7038 UPPC_DataMemberType)) { 7039 D.setInvalidType(); 7040 T = Context.IntTy; 7041 TInfo = Context.getTrivialTypeSourceInfo(T, Loc); 7042 } 7043 } 7044 7045 DiagnoseFunctionSpecifiers(D); 7046 7047 if (D.getDeclSpec().isThreadSpecified()) 7048 Diag(D.getDeclSpec().getThreadSpecLoc(), diag::err_invalid_thread); 7049 7050 // Check to see if this name was declared as a member previously 7051 LookupResult Previous(*this, II, Loc, LookupMemberName, ForRedeclaration); 7052 LookupName(Previous, S); 7053 assert((Previous.empty() || Previous.isOverloadedResult() || 7054 Previous.isSingleResult()) 7055 && "Lookup of member name should be either overloaded, single or null"); 7056 7057 // If the name is overloaded then get any declaration else get the single result 7058 NamedDecl *PrevDecl = Previous.isOverloadedResult() ? 7059 Previous.getRepresentativeDecl() : Previous.getAsSingle<NamedDecl>(); 7060 7061 if (PrevDecl && PrevDecl->isTemplateParameter()) { 7062 // Maybe we will complain about the shadowed template parameter. 7063 DiagnoseTemplateParameterShadow(D.getIdentifierLoc(), PrevDecl); 7064 // Just pretend that we didn't see the previous declaration. 7065 PrevDecl = 0; 7066 } 7067 7068 if (PrevDecl && !isDeclInScope(PrevDecl, Record, S)) 7069 PrevDecl = 0; 7070 7071 bool Mutable 7072 = (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_mutable); 7073 SourceLocation TSSL = D.getSourceRange().getBegin(); 7074 FieldDecl *NewFD 7075 = CheckFieldDecl(II, T, TInfo, Record, Loc, Mutable, BitWidth, TSSL, 7076 AS, PrevDecl, &D); 7077 7078 if (NewFD->isInvalidDecl()) 7079 Record->setInvalidDecl(); 7080 7081 if (NewFD->isInvalidDecl() && PrevDecl) { 7082 // Don't introduce NewFD into scope; there's already something 7083 // with the same name in the same scope. 7084 } else if (II) { 7085 PushOnScopeChains(NewFD, S); 7086 } else 7087 Record->addDecl(NewFD); 7088 7089 return NewFD; 7090} 7091 7092/// \brief Build a new FieldDecl and check its well-formedness. 7093/// 7094/// This routine builds a new FieldDecl given the fields name, type, 7095/// record, etc. \p PrevDecl should refer to any previous declaration 7096/// with the same name and in the same scope as the field to be 7097/// created. 7098/// 7099/// \returns a new FieldDecl. 7100/// 7101/// \todo The Declarator argument is a hack. It will be removed once 7102FieldDecl *Sema::CheckFieldDecl(DeclarationName Name, QualType T, 7103 TypeSourceInfo *TInfo, 7104 RecordDecl *Record, SourceLocation Loc, 7105 bool Mutable, Expr *BitWidth, 7106 SourceLocation TSSL, 7107 AccessSpecifier AS, NamedDecl *PrevDecl, 7108 Declarator *D) { 7109 IdentifierInfo *II = Name.getAsIdentifierInfo(); 7110 bool InvalidDecl = false; 7111 if (D) InvalidDecl = D->isInvalidType(); 7112 7113 // If we receive a broken type, recover by assuming 'int' and 7114 // marking this declaration as invalid. 7115 if (T.isNull()) { 7116 InvalidDecl = true; 7117 T = Context.IntTy; 7118 } 7119 7120 QualType EltTy = Context.getBaseElementType(T); 7121 if (!EltTy->isDependentType() && 7122 RequireCompleteType(Loc, EltTy, diag::err_field_incomplete)) { 7123 // Fields of incomplete type force their record to be invalid. 7124 Record->setInvalidDecl(); 7125 InvalidDecl = true; 7126 } 7127 7128 // C99 6.7.2.1p8: A member of a structure or union may have any type other 7129 // than a variably modified type. 7130 if (!InvalidDecl && T->isVariablyModifiedType()) { 7131 bool SizeIsNegative; 7132 llvm::APSInt Oversized; 7133 QualType FixedTy = TryToFixInvalidVariablyModifiedType(T, Context, 7134 SizeIsNegative, 7135 Oversized); 7136 if (!FixedTy.isNull()) { 7137 Diag(Loc, diag::warn_illegal_constant_array_size); 7138 T = FixedTy; 7139 } else { 7140 if (SizeIsNegative) 7141 Diag(Loc, diag::err_typecheck_negative_array_size); 7142 else if (Oversized.getBoolValue()) 7143 Diag(Loc, diag::err_array_too_large) 7144 << Oversized.toString(10); 7145 else 7146 Diag(Loc, diag::err_typecheck_field_variable_size); 7147 InvalidDecl = true; 7148 } 7149 } 7150 7151 // Fields can not have abstract class types 7152 if (!InvalidDecl && RequireNonAbstractType(Loc, T, 7153 diag::err_abstract_type_in_decl, 7154 AbstractFieldType)) 7155 InvalidDecl = true; 7156 7157 bool ZeroWidth = false; 7158 // If this is declared as a bit-field, check the bit-field. 7159 if (!InvalidDecl && BitWidth && 7160 VerifyBitField(Loc, II, T, BitWidth, &ZeroWidth)) { 7161 InvalidDecl = true; 7162 BitWidth = 0; 7163 ZeroWidth = false; 7164 } 7165 7166 // Check that 'mutable' is consistent with the type of the declaration. 7167 if (!InvalidDecl && Mutable) { 7168 unsigned DiagID = 0; 7169 if (T->isReferenceType()) 7170 DiagID = diag::err_mutable_reference; 7171 else if (T.isConstQualified()) 7172 DiagID = diag::err_mutable_const; 7173 7174 if (DiagID) { 7175 SourceLocation ErrLoc = Loc; 7176 if (D && D->getDeclSpec().getStorageClassSpecLoc().isValid()) 7177 ErrLoc = D->getDeclSpec().getStorageClassSpecLoc(); 7178 Diag(ErrLoc, DiagID); 7179 Mutable = false; 7180 InvalidDecl = true; 7181 } 7182 } 7183 7184 FieldDecl *NewFD = FieldDecl::Create(Context, Record, TSSL, Loc, II, T, TInfo, 7185 BitWidth, Mutable); 7186 if (InvalidDecl) 7187 NewFD->setInvalidDecl(); 7188 7189 if (PrevDecl && !isa<TagDecl>(PrevDecl)) { 7190 Diag(Loc, diag::err_duplicate_member) << II; 7191 Diag(PrevDecl->getLocation(), diag::note_previous_declaration); 7192 NewFD->setInvalidDecl(); 7193 } 7194 7195 if (!InvalidDecl && getLangOptions().CPlusPlus) { 7196 if (Record->isUnion()) { 7197 if (const RecordType *RT = EltTy->getAs<RecordType>()) { 7198 CXXRecordDecl* RDecl = cast<CXXRecordDecl>(RT->getDecl()); 7199 if (RDecl->getDefinition()) { 7200 // C++ [class.union]p1: An object of a class with a non-trivial 7201 // constructor, a non-trivial copy constructor, a non-trivial 7202 // destructor, or a non-trivial copy assignment operator 7203 // cannot be a member of a union, nor can an array of such 7204 // objects. 7205 // TODO: C++0x alters this restriction significantly. 7206 if (CheckNontrivialField(NewFD)) 7207 NewFD->setInvalidDecl(); 7208 } 7209 } 7210 7211 // C++ [class.union]p1: If a union contains a member of reference type, 7212 // the program is ill-formed. 7213 if (EltTy->isReferenceType()) { 7214 Diag(NewFD->getLocation(), diag::err_union_member_of_reference_type) 7215 << NewFD->getDeclName() << EltTy; 7216 NewFD->setInvalidDecl(); 7217 } 7218 } 7219 } 7220 7221 // FIXME: We need to pass in the attributes given an AST 7222 // representation, not a parser representation. 7223 if (D) 7224 // FIXME: What to pass instead of TUScope? 7225 ProcessDeclAttributes(TUScope, NewFD, *D); 7226 7227 if (T.isObjCGCWeak()) 7228 Diag(Loc, diag::warn_attribute_weak_on_field); 7229 7230 NewFD->setAccess(AS); 7231 return NewFD; 7232} 7233 7234bool Sema::CheckNontrivialField(FieldDecl *FD) { 7235 assert(FD); 7236 assert(getLangOptions().CPlusPlus && "valid check only for C++"); 7237 7238 if (FD->isInvalidDecl()) 7239 return true; 7240 7241 QualType EltTy = Context.getBaseElementType(FD->getType()); 7242 if (const RecordType *RT = EltTy->getAs<RecordType>()) { 7243 CXXRecordDecl* RDecl = cast<CXXRecordDecl>(RT->getDecl()); 7244 if (RDecl->getDefinition()) { 7245 // We check for copy constructors before constructors 7246 // because otherwise we'll never get complaints about 7247 // copy constructors. 7248 7249 CXXSpecialMember member = CXXInvalid; 7250 if (!RDecl->hasTrivialCopyConstructor()) 7251 member = CXXCopyConstructor; 7252 else if (!RDecl->hasTrivialConstructor()) 7253 member = CXXConstructor; 7254 else if (!RDecl->hasTrivialCopyAssignment()) 7255 member = CXXCopyAssignment; 7256 else if (!RDecl->hasTrivialDestructor()) 7257 member = CXXDestructor; 7258 7259 if (member != CXXInvalid) { 7260 Diag(FD->getLocation(), diag::err_illegal_union_or_anon_struct_member) 7261 << (int)FD->getParent()->isUnion() << FD->getDeclName() << member; 7262 DiagnoseNontrivial(RT, member); 7263 return true; 7264 } 7265 } 7266 } 7267 7268 return false; 7269} 7270 7271/// DiagnoseNontrivial - Given that a class has a non-trivial 7272/// special member, figure out why. 7273void Sema::DiagnoseNontrivial(const RecordType* T, CXXSpecialMember member) { 7274 QualType QT(T, 0U); 7275 CXXRecordDecl* RD = cast<CXXRecordDecl>(T->getDecl()); 7276 7277 // Check whether the member was user-declared. 7278 switch (member) { 7279 case CXXInvalid: 7280 break; 7281 7282 case CXXConstructor: 7283 if (RD->hasUserDeclaredConstructor()) { 7284 typedef CXXRecordDecl::ctor_iterator ctor_iter; 7285 for (ctor_iter ci = RD->ctor_begin(), ce = RD->ctor_end(); ci != ce;++ci){ 7286 const FunctionDecl *body = 0; 7287 ci->hasBody(body); 7288 if (!body || !cast<CXXConstructorDecl>(body)->isImplicitlyDefined()) { 7289 SourceLocation CtorLoc = ci->getLocation(); 7290 Diag(CtorLoc, diag::note_nontrivial_user_defined) << QT << member; 7291 return; 7292 } 7293 } 7294 7295 assert(0 && "found no user-declared constructors"); 7296 return; 7297 } 7298 break; 7299 7300 case CXXCopyConstructor: 7301 if (RD->hasUserDeclaredCopyConstructor()) { 7302 SourceLocation CtorLoc = 7303 RD->getCopyConstructor(Context, 0)->getLocation(); 7304 Diag(CtorLoc, diag::note_nontrivial_user_defined) << QT << member; 7305 return; 7306 } 7307 break; 7308 7309 case CXXCopyAssignment: 7310 if (RD->hasUserDeclaredCopyAssignment()) { 7311 // FIXME: this should use the location of the copy 7312 // assignment, not the type. 7313 SourceLocation TyLoc = RD->getSourceRange().getBegin(); 7314 Diag(TyLoc, diag::note_nontrivial_user_defined) << QT << member; 7315 return; 7316 } 7317 break; 7318 7319 case CXXDestructor: 7320 if (RD->hasUserDeclaredDestructor()) { 7321 SourceLocation DtorLoc = LookupDestructor(RD)->getLocation(); 7322 Diag(DtorLoc, diag::note_nontrivial_user_defined) << QT << member; 7323 return; 7324 } 7325 break; 7326 } 7327 7328 typedef CXXRecordDecl::base_class_iterator base_iter; 7329 7330 // Virtual bases and members inhibit trivial copying/construction, 7331 // but not trivial destruction. 7332 if (member != CXXDestructor) { 7333 // Check for virtual bases. vbases includes indirect virtual bases, 7334 // so we just iterate through the direct bases. 7335 for (base_iter bi = RD->bases_begin(), be = RD->bases_end(); bi != be; ++bi) 7336 if (bi->isVirtual()) { 7337 SourceLocation BaseLoc = bi->getSourceRange().getBegin(); 7338 Diag(BaseLoc, diag::note_nontrivial_has_virtual) << QT << 1; 7339 return; 7340 } 7341 7342 // Check for virtual methods. 7343 typedef CXXRecordDecl::method_iterator meth_iter; 7344 for (meth_iter mi = RD->method_begin(), me = RD->method_end(); mi != me; 7345 ++mi) { 7346 if (mi->isVirtual()) { 7347 SourceLocation MLoc = mi->getSourceRange().getBegin(); 7348 Diag(MLoc, diag::note_nontrivial_has_virtual) << QT << 0; 7349 return; 7350 } 7351 } 7352 } 7353 7354 bool (CXXRecordDecl::*hasTrivial)() const; 7355 switch (member) { 7356 case CXXConstructor: 7357 hasTrivial = &CXXRecordDecl::hasTrivialConstructor; break; 7358 case CXXCopyConstructor: 7359 hasTrivial = &CXXRecordDecl::hasTrivialCopyConstructor; break; 7360 case CXXCopyAssignment: 7361 hasTrivial = &CXXRecordDecl::hasTrivialCopyAssignment; break; 7362 case CXXDestructor: 7363 hasTrivial = &CXXRecordDecl::hasTrivialDestructor; break; 7364 default: 7365 assert(0 && "unexpected special member"); return; 7366 } 7367 7368 // Check for nontrivial bases (and recurse). 7369 for (base_iter bi = RD->bases_begin(), be = RD->bases_end(); bi != be; ++bi) { 7370 const RecordType *BaseRT = bi->getType()->getAs<RecordType>(); 7371 assert(BaseRT && "Don't know how to handle dependent bases"); 7372 CXXRecordDecl *BaseRecTy = cast<CXXRecordDecl>(BaseRT->getDecl()); 7373 if (!(BaseRecTy->*hasTrivial)()) { 7374 SourceLocation BaseLoc = bi->getSourceRange().getBegin(); 7375 Diag(BaseLoc, diag::note_nontrivial_has_nontrivial) << QT << 1 << member; 7376 DiagnoseNontrivial(BaseRT, member); 7377 return; 7378 } 7379 } 7380 7381 // Check for nontrivial members (and recurse). 7382 typedef RecordDecl::field_iterator field_iter; 7383 for (field_iter fi = RD->field_begin(), fe = RD->field_end(); fi != fe; 7384 ++fi) { 7385 QualType EltTy = Context.getBaseElementType((*fi)->getType()); 7386 if (const RecordType *EltRT = EltTy->getAs<RecordType>()) { 7387 CXXRecordDecl* EltRD = cast<CXXRecordDecl>(EltRT->getDecl()); 7388 7389 if (!(EltRD->*hasTrivial)()) { 7390 SourceLocation FLoc = (*fi)->getLocation(); 7391 Diag(FLoc, diag::note_nontrivial_has_nontrivial) << QT << 0 << member; 7392 DiagnoseNontrivial(EltRT, member); 7393 return; 7394 } 7395 } 7396 } 7397 7398 assert(0 && "found no explanation for non-trivial member"); 7399} 7400 7401/// TranslateIvarVisibility - Translate visibility from a token ID to an 7402/// AST enum value. 7403static ObjCIvarDecl::AccessControl 7404TranslateIvarVisibility(tok::ObjCKeywordKind ivarVisibility) { 7405 switch (ivarVisibility) { 7406 default: assert(0 && "Unknown visitibility kind"); 7407 case tok::objc_private: return ObjCIvarDecl::Private; 7408 case tok::objc_public: return ObjCIvarDecl::Public; 7409 case tok::objc_protected: return ObjCIvarDecl::Protected; 7410 case tok::objc_package: return ObjCIvarDecl::Package; 7411 } 7412} 7413 7414/// ActOnIvar - Each ivar field of an objective-c class is passed into this 7415/// in order to create an IvarDecl object for it. 7416Decl *Sema::ActOnIvar(Scope *S, 7417 SourceLocation DeclStart, 7418 Decl *IntfDecl, 7419 Declarator &D, ExprTy *BitfieldWidth, 7420 tok::ObjCKeywordKind Visibility) { 7421 7422 IdentifierInfo *II = D.getIdentifier(); 7423 Expr *BitWidth = (Expr*)BitfieldWidth; 7424 SourceLocation Loc = DeclStart; 7425 if (II) Loc = D.getIdentifierLoc(); 7426 7427 // FIXME: Unnamed fields can be handled in various different ways, for 7428 // example, unnamed unions inject all members into the struct namespace! 7429 7430 TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S); 7431 QualType T = TInfo->getType(); 7432 7433 if (BitWidth) { 7434 // 6.7.2.1p3, 6.7.2.1p4 7435 if (VerifyBitField(Loc, II, T, BitWidth)) { 7436 D.setInvalidType(); 7437 BitWidth = 0; 7438 } 7439 } else { 7440 // Not a bitfield. 7441 7442 // validate II. 7443 7444 } 7445 if (T->isReferenceType()) { 7446 Diag(Loc, diag::err_ivar_reference_type); 7447 D.setInvalidType(); 7448 } 7449 // C99 6.7.2.1p8: A member of a structure or union may have any type other 7450 // than a variably modified type. 7451 else if (T->isVariablyModifiedType()) { 7452 Diag(Loc, diag::err_typecheck_ivar_variable_size); 7453 D.setInvalidType(); 7454 } 7455 7456 // Get the visibility (access control) for this ivar. 7457 ObjCIvarDecl::AccessControl ac = 7458 Visibility != tok::objc_not_keyword ? TranslateIvarVisibility(Visibility) 7459 : ObjCIvarDecl::None; 7460 // Must set ivar's DeclContext to its enclosing interface. 7461 ObjCContainerDecl *EnclosingDecl = cast<ObjCContainerDecl>(IntfDecl); 7462 ObjCContainerDecl *EnclosingContext; 7463 if (ObjCImplementationDecl *IMPDecl = 7464 dyn_cast<ObjCImplementationDecl>(EnclosingDecl)) { 7465 if (!LangOpts.ObjCNonFragileABI2) { 7466 // Case of ivar declared in an implementation. Context is that of its class. 7467 EnclosingContext = IMPDecl->getClassInterface(); 7468 assert(EnclosingContext && "Implementation has no class interface!"); 7469 } 7470 else 7471 EnclosingContext = EnclosingDecl; 7472 } else { 7473 if (ObjCCategoryDecl *CDecl = 7474 dyn_cast<ObjCCategoryDecl>(EnclosingDecl)) { 7475 if (!LangOpts.ObjCNonFragileABI2 || !CDecl->IsClassExtension()) { 7476 Diag(Loc, diag::err_misplaced_ivar) << CDecl->IsClassExtension(); 7477 return 0; 7478 } 7479 } 7480 EnclosingContext = EnclosingDecl; 7481 } 7482 7483 // Construct the decl. 7484 ObjCIvarDecl *NewID = ObjCIvarDecl::Create(Context, EnclosingContext, 7485 DeclStart, Loc, II, T, 7486 TInfo, ac, (Expr *)BitfieldWidth); 7487 7488 if (II) { 7489 NamedDecl *PrevDecl = LookupSingleName(S, II, Loc, LookupMemberName, 7490 ForRedeclaration); 7491 if (PrevDecl && isDeclInScope(PrevDecl, EnclosingContext, S) 7492 && !isa<TagDecl>(PrevDecl)) { 7493 Diag(Loc, diag::err_duplicate_member) << II; 7494 Diag(PrevDecl->getLocation(), diag::note_previous_declaration); 7495 NewID->setInvalidDecl(); 7496 } 7497 } 7498 7499 // Process attributes attached to the ivar. 7500 ProcessDeclAttributes(S, NewID, D); 7501 7502 if (D.isInvalidType()) 7503 NewID->setInvalidDecl(); 7504 7505 if (II) { 7506 // FIXME: When interfaces are DeclContexts, we'll need to add 7507 // these to the interface. 7508 S->AddDecl(NewID); 7509 IdResolver.AddDecl(NewID); 7510 } 7511 7512 return NewID; 7513} 7514 7515/// ActOnLastBitfield - This routine handles synthesized bitfields rules for 7516/// class and class extensions. For every class @interface and class 7517/// extension @interface, if the last ivar is a bitfield of any type, 7518/// then add an implicit `char :0` ivar to the end of that interface. 7519void Sema::ActOnLastBitfield(SourceLocation DeclLoc, Decl *EnclosingDecl, 7520 llvm::SmallVectorImpl<Decl *> &AllIvarDecls) { 7521 if (!LangOpts.ObjCNonFragileABI2 || AllIvarDecls.empty()) 7522 return; 7523 7524 Decl *ivarDecl = AllIvarDecls[AllIvarDecls.size()-1]; 7525 ObjCIvarDecl *Ivar = cast<ObjCIvarDecl>(ivarDecl); 7526 7527 if (!Ivar->isBitField()) 7528 return; 7529 uint64_t BitFieldSize = 7530 Ivar->getBitWidth()->EvaluateAsInt(Context).getZExtValue(); 7531 if (BitFieldSize == 0) 7532 return; 7533 ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(EnclosingDecl); 7534 if (!ID) { 7535 if (ObjCCategoryDecl *CD = dyn_cast<ObjCCategoryDecl>(EnclosingDecl)) { 7536 if (!CD->IsClassExtension()) 7537 return; 7538 } 7539 // No need to add this to end of @implementation. 7540 else 7541 return; 7542 } 7543 // All conditions are met. Add a new bitfield to the tail end of ivars. 7544 llvm::APInt Zero(Context.getTypeSize(Context.CharTy), 0); 7545 Expr * BW = IntegerLiteral::Create(Context, Zero, Context.CharTy, DeclLoc); 7546 7547 Ivar = ObjCIvarDecl::Create(Context, cast<ObjCContainerDecl>(EnclosingDecl), 7548 DeclLoc, DeclLoc, 0, 7549 Context.CharTy, 7550 Context.CreateTypeSourceInfo(Context.CharTy), 7551 ObjCIvarDecl::Private, BW, 7552 true); 7553 AllIvarDecls.push_back(Ivar); 7554} 7555 7556void Sema::ActOnFields(Scope* S, 7557 SourceLocation RecLoc, Decl *EnclosingDecl, 7558 Decl **Fields, unsigned NumFields, 7559 SourceLocation LBrac, SourceLocation RBrac, 7560 AttributeList *Attr) { 7561 assert(EnclosingDecl && "missing record or interface decl"); 7562 7563 // If the decl this is being inserted into is invalid, then it may be a 7564 // redeclaration or some other bogus case. Don't try to add fields to it. 7565 if (EnclosingDecl->isInvalidDecl()) { 7566 // FIXME: Deallocate fields? 7567 return; 7568 } 7569 7570 7571 // Verify that all the fields are okay. 7572 unsigned NumNamedMembers = 0; 7573 llvm::SmallVector<FieldDecl*, 32> RecFields; 7574 7575 RecordDecl *Record = dyn_cast<RecordDecl>(EnclosingDecl); 7576 for (unsigned i = 0; i != NumFields; ++i) { 7577 FieldDecl *FD = cast<FieldDecl>(Fields[i]); 7578 7579 // Get the type for the field. 7580 const Type *FDTy = FD->getType().getTypePtr(); 7581 7582 if (!FD->isAnonymousStructOrUnion()) { 7583 // Remember all fields written by the user. 7584 RecFields.push_back(FD); 7585 } 7586 7587 // If the field is already invalid for some reason, don't emit more 7588 // diagnostics about it. 7589 if (FD->isInvalidDecl()) { 7590 EnclosingDecl->setInvalidDecl(); 7591 continue; 7592 } 7593 7594 // C99 6.7.2.1p2: 7595 // A structure or union shall not contain a member with 7596 // incomplete or function type (hence, a structure shall not 7597 // contain an instance of itself, but may contain a pointer to 7598 // an instance of itself), except that the last member of a 7599 // structure with more than one named member may have incomplete 7600 // array type; such a structure (and any union containing, 7601 // possibly recursively, a member that is such a structure) 7602 // shall not be a member of a structure or an element of an 7603 // array. 7604 if (FDTy->isFunctionType()) { 7605 // Field declared as a function. 7606 Diag(FD->getLocation(), diag::err_field_declared_as_function) 7607 << FD->getDeclName(); 7608 FD->setInvalidDecl(); 7609 EnclosingDecl->setInvalidDecl(); 7610 continue; 7611 } else if (FDTy->isIncompleteArrayType() && Record && 7612 ((i == NumFields - 1 && !Record->isUnion()) || 7613 ((getLangOptions().Microsoft || getLangOptions().CPlusPlus) && 7614 (i == NumFields - 1 || Record->isUnion())))) { 7615 // Flexible array member. 7616 // Microsoft and g++ is more permissive regarding flexible array. 7617 // It will accept flexible array in union and also 7618 // as the sole element of a struct/class. 7619 if (getLangOptions().Microsoft) { 7620 if (Record->isUnion()) 7621 Diag(FD->getLocation(), diag::ext_flexible_array_union_ms) 7622 << FD->getDeclName(); 7623 else if (NumFields == 1) 7624 Diag(FD->getLocation(), diag::ext_flexible_array_empty_aggregate_ms) 7625 << FD->getDeclName() << Record->getTagKind(); 7626 } else if (getLangOptions().CPlusPlus) { 7627 if (Record->isUnion()) 7628 Diag(FD->getLocation(), diag::ext_flexible_array_union_gnu) 7629 << FD->getDeclName(); 7630 else if (NumFields == 1) 7631 Diag(FD->getLocation(), diag::ext_flexible_array_empty_aggregate_gnu) 7632 << FD->getDeclName() << Record->getTagKind(); 7633 } else if (NumNamedMembers < 1) { 7634 Diag(FD->getLocation(), diag::err_flexible_array_empty_struct) 7635 << FD->getDeclName(); 7636 FD->setInvalidDecl(); 7637 EnclosingDecl->setInvalidDecl(); 7638 continue; 7639 } 7640 if (!FD->getType()->isDependentType() && 7641 !Context.getBaseElementType(FD->getType())->isPODType()) { 7642 Diag(FD->getLocation(), diag::err_flexible_array_has_nonpod_type) 7643 << FD->getDeclName() << FD->getType(); 7644 FD->setInvalidDecl(); 7645 EnclosingDecl->setInvalidDecl(); 7646 continue; 7647 } 7648 // Okay, we have a legal flexible array member at the end of the struct. 7649 if (Record) 7650 Record->setHasFlexibleArrayMember(true); 7651 } else if (!FDTy->isDependentType() && 7652 RequireCompleteType(FD->getLocation(), FD->getType(), 7653 diag::err_field_incomplete)) { 7654 // Incomplete type 7655 FD->setInvalidDecl(); 7656 EnclosingDecl->setInvalidDecl(); 7657 continue; 7658 } else if (const RecordType *FDTTy = FDTy->getAs<RecordType>()) { 7659 if (FDTTy->getDecl()->hasFlexibleArrayMember()) { 7660 // If this is a member of a union, then entire union becomes "flexible". 7661 if (Record && Record->isUnion()) { 7662 Record->setHasFlexibleArrayMember(true); 7663 } else { 7664 // If this is a struct/class and this is not the last element, reject 7665 // it. Note that GCC supports variable sized arrays in the middle of 7666 // structures. 7667 if (i != NumFields-1) 7668 Diag(FD->getLocation(), diag::ext_variable_sized_type_in_struct) 7669 << FD->getDeclName() << FD->getType(); 7670 else { 7671 // We support flexible arrays at the end of structs in 7672 // other structs as an extension. 7673 Diag(FD->getLocation(), diag::ext_flexible_array_in_struct) 7674 << FD->getDeclName(); 7675 if (Record) 7676 Record->setHasFlexibleArrayMember(true); 7677 } 7678 } 7679 } 7680 if (Record && FDTTy->getDecl()->hasObjectMember()) 7681 Record->setHasObjectMember(true); 7682 } else if (FDTy->isObjCObjectType()) { 7683 /// A field cannot be an Objective-c object 7684 Diag(FD->getLocation(), diag::err_statically_allocated_object); 7685 FD->setInvalidDecl(); 7686 EnclosingDecl->setInvalidDecl(); 7687 continue; 7688 } else if (getLangOptions().ObjC1 && 7689 getLangOptions().getGCMode() != LangOptions::NonGC && 7690 Record && 7691 (FD->getType()->isObjCObjectPointerType() || 7692 FD->getType().isObjCGCStrong())) 7693 Record->setHasObjectMember(true); 7694 else if (Context.getAsArrayType(FD->getType())) { 7695 QualType BaseType = Context.getBaseElementType(FD->getType()); 7696 if (Record && BaseType->isRecordType() && 7697 BaseType->getAs<RecordType>()->getDecl()->hasObjectMember()) 7698 Record->setHasObjectMember(true); 7699 } 7700 // Keep track of the number of named members. 7701 if (FD->getIdentifier()) 7702 ++NumNamedMembers; 7703 } 7704 7705 // Okay, we successfully defined 'Record'. 7706 if (Record) { 7707 bool Completed = false; 7708 if (CXXRecordDecl *CXXRecord = dyn_cast<CXXRecordDecl>(Record)) { 7709 if (!CXXRecord->isInvalidDecl()) { 7710 // Set access bits correctly on the directly-declared conversions. 7711 UnresolvedSetImpl *Convs = CXXRecord->getConversionFunctions(); 7712 for (UnresolvedSetIterator I = Convs->begin(), E = Convs->end(); 7713 I != E; ++I) 7714 Convs->setAccess(I, (*I)->getAccess()); 7715 7716 if (!CXXRecord->isDependentType()) { 7717 // Add any implicitly-declared members to this class. 7718 AddImplicitlyDeclaredMembersToClass(CXXRecord); 7719 7720 // If we have virtual base classes, we may end up finding multiple 7721 // final overriders for a given virtual function. Check for this 7722 // problem now. 7723 if (CXXRecord->getNumVBases()) { 7724 CXXFinalOverriderMap FinalOverriders; 7725 CXXRecord->getFinalOverriders(FinalOverriders); 7726 7727 for (CXXFinalOverriderMap::iterator M = FinalOverriders.begin(), 7728 MEnd = FinalOverriders.end(); 7729 M != MEnd; ++M) { 7730 for (OverridingMethods::iterator SO = M->second.begin(), 7731 SOEnd = M->second.end(); 7732 SO != SOEnd; ++SO) { 7733 assert(SO->second.size() > 0 && 7734 "Virtual function without overridding functions?"); 7735 if (SO->second.size() == 1) 7736 continue; 7737 7738 // C++ [class.virtual]p2: 7739 // In a derived class, if a virtual member function of a base 7740 // class subobject has more than one final overrider the 7741 // program is ill-formed. 7742 Diag(Record->getLocation(), diag::err_multiple_final_overriders) 7743 << (NamedDecl *)M->first << Record; 7744 Diag(M->first->getLocation(), 7745 diag::note_overridden_virtual_function); 7746 for (OverridingMethods::overriding_iterator 7747 OM = SO->second.begin(), 7748 OMEnd = SO->second.end(); 7749 OM != OMEnd; ++OM) 7750 Diag(OM->Method->getLocation(), diag::note_final_overrider) 7751 << (NamedDecl *)M->first << OM->Method->getParent(); 7752 7753 Record->setInvalidDecl(); 7754 } 7755 } 7756 CXXRecord->completeDefinition(&FinalOverriders); 7757 Completed = true; 7758 } 7759 } 7760 } 7761 } 7762 7763 if (!Completed) 7764 Record->completeDefinition(); 7765 } else { 7766 ObjCIvarDecl **ClsFields = 7767 reinterpret_cast<ObjCIvarDecl**>(RecFields.data()); 7768 if (ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(EnclosingDecl)) { 7769 ID->setLocEnd(RBrac); 7770 // Add ivar's to class's DeclContext. 7771 for (unsigned i = 0, e = RecFields.size(); i != e; ++i) { 7772 ClsFields[i]->setLexicalDeclContext(ID); 7773 ID->addDecl(ClsFields[i]); 7774 } 7775 // Must enforce the rule that ivars in the base classes may not be 7776 // duplicates. 7777 if (ID->getSuperClass()) 7778 DiagnoseDuplicateIvars(ID, ID->getSuperClass()); 7779 } else if (ObjCImplementationDecl *IMPDecl = 7780 dyn_cast<ObjCImplementationDecl>(EnclosingDecl)) { 7781 assert(IMPDecl && "ActOnFields - missing ObjCImplementationDecl"); 7782 for (unsigned I = 0, N = RecFields.size(); I != N; ++I) 7783 // Ivar declared in @implementation never belongs to the implementation. 7784 // Only it is in implementation's lexical context. 7785 ClsFields[I]->setLexicalDeclContext(IMPDecl); 7786 CheckImplementationIvars(IMPDecl, ClsFields, RecFields.size(), RBrac); 7787 } else if (ObjCCategoryDecl *CDecl = 7788 dyn_cast<ObjCCategoryDecl>(EnclosingDecl)) { 7789 // case of ivars in class extension; all other cases have been 7790 // reported as errors elsewhere. 7791 // FIXME. Class extension does not have a LocEnd field. 7792 // CDecl->setLocEnd(RBrac); 7793 // Add ivar's to class extension's DeclContext. 7794 for (unsigned i = 0, e = RecFields.size(); i != e; ++i) { 7795 ClsFields[i]->setLexicalDeclContext(CDecl); 7796 CDecl->addDecl(ClsFields[i]); 7797 } 7798 } 7799 } 7800 7801 if (Attr) 7802 ProcessDeclAttributeList(S, Record, Attr); 7803 7804 // If there's a #pragma GCC visibility in scope, and this isn't a subclass, 7805 // set the visibility of this record. 7806 if (Record && !Record->getDeclContext()->isRecord()) 7807 AddPushedVisibilityAttribute(Record); 7808} 7809 7810/// \brief Determine whether the given integral value is representable within 7811/// the given type T. 7812static bool isRepresentableIntegerValue(ASTContext &Context, 7813 llvm::APSInt &Value, 7814 QualType T) { 7815 assert(T->isIntegralType(Context) && "Integral type required!"); 7816 unsigned BitWidth = Context.getIntWidth(T); 7817 7818 if (Value.isUnsigned() || Value.isNonNegative()) { 7819 if (T->isSignedIntegerType()) 7820 --BitWidth; 7821 return Value.getActiveBits() <= BitWidth; 7822 } 7823 return Value.getMinSignedBits() <= BitWidth; 7824} 7825 7826// \brief Given an integral type, return the next larger integral type 7827// (or a NULL type of no such type exists). 7828static QualType getNextLargerIntegralType(ASTContext &Context, QualType T) { 7829 // FIXME: Int128/UInt128 support, which also needs to be introduced into 7830 // enum checking below. 7831 assert(T->isIntegralType(Context) && "Integral type required!"); 7832 const unsigned NumTypes = 4; 7833 QualType SignedIntegralTypes[NumTypes] = { 7834 Context.ShortTy, Context.IntTy, Context.LongTy, Context.LongLongTy 7835 }; 7836 QualType UnsignedIntegralTypes[NumTypes] = { 7837 Context.UnsignedShortTy, Context.UnsignedIntTy, Context.UnsignedLongTy, 7838 Context.UnsignedLongLongTy 7839 }; 7840 7841 unsigned BitWidth = Context.getTypeSize(T); 7842 QualType *Types = T->isSignedIntegerType()? SignedIntegralTypes 7843 : UnsignedIntegralTypes; 7844 for (unsigned I = 0; I != NumTypes; ++I) 7845 if (Context.getTypeSize(Types[I]) > BitWidth) 7846 return Types[I]; 7847 7848 return QualType(); 7849} 7850 7851EnumConstantDecl *Sema::CheckEnumConstant(EnumDecl *Enum, 7852 EnumConstantDecl *LastEnumConst, 7853 SourceLocation IdLoc, 7854 IdentifierInfo *Id, 7855 Expr *Val) { 7856 unsigned IntWidth = Context.Target.getIntWidth(); 7857 llvm::APSInt EnumVal(IntWidth); 7858 QualType EltTy; 7859 7860 if (Val && DiagnoseUnexpandedParameterPack(Val, UPPC_EnumeratorValue)) 7861 Val = 0; 7862 7863 if (Val) { 7864 if (Enum->isDependentType() || Val->isTypeDependent()) 7865 EltTy = Context.DependentTy; 7866 else { 7867 // C99 6.7.2.2p2: Make sure we have an integer constant expression. 7868 SourceLocation ExpLoc; 7869 if (!Val->isValueDependent() && 7870 VerifyIntegerConstantExpression(Val, &EnumVal)) { 7871 Val = 0; 7872 } else { 7873 if (!getLangOptions().CPlusPlus) { 7874 // C99 6.7.2.2p2: 7875 // The expression that defines the value of an enumeration constant 7876 // shall be an integer constant expression that has a value 7877 // representable as an int. 7878 7879 // Complain if the value is not representable in an int. 7880 if (!isRepresentableIntegerValue(Context, EnumVal, Context.IntTy)) 7881 Diag(IdLoc, diag::ext_enum_value_not_int) 7882 << EnumVal.toString(10) << Val->getSourceRange() 7883 << (EnumVal.isUnsigned() || EnumVal.isNonNegative()); 7884 else if (!Context.hasSameType(Val->getType(), Context.IntTy)) { 7885 // Force the type of the expression to 'int'. 7886 Val = ImpCastExprToType(Val, Context.IntTy, CK_IntegralCast).take(); 7887 } 7888 } 7889 7890 if (Enum->isFixed()) { 7891 EltTy = Enum->getIntegerType(); 7892 7893 // C++0x [dcl.enum]p5: 7894 // ... if the initializing value of an enumerator cannot be 7895 // represented by the underlying type, the program is ill-formed. 7896 if (!isRepresentableIntegerValue(Context, EnumVal, EltTy)) { 7897 if (getLangOptions().Microsoft) { 7898 Diag(IdLoc, diag::ext_enumerator_too_large) << EltTy; 7899 Val = ImpCastExprToType(Val, EltTy, CK_IntegralCast).take(); 7900 } else 7901 Diag(IdLoc, diag::err_enumerator_too_large) 7902 << EltTy; 7903 } else 7904 Val = ImpCastExprToType(Val, EltTy, CK_IntegralCast).take(); 7905 } 7906 else { 7907 // C++0x [dcl.enum]p5: 7908 // If the underlying type is not fixed, the type of each enumerator 7909 // is the type of its initializing value: 7910 // - If an initializer is specified for an enumerator, the 7911 // initializing value has the same type as the expression. 7912 EltTy = Val->getType(); 7913 } 7914 } 7915 } 7916 } 7917 7918 if (!Val) { 7919 if (Enum->isDependentType()) 7920 EltTy = Context.DependentTy; 7921 else if (!LastEnumConst) { 7922 // C++0x [dcl.enum]p5: 7923 // If the underlying type is not fixed, the type of each enumerator 7924 // is the type of its initializing value: 7925 // - If no initializer is specified for the first enumerator, the 7926 // initializing value has an unspecified integral type. 7927 // 7928 // GCC uses 'int' for its unspecified integral type, as does 7929 // C99 6.7.2.2p3. 7930 if (Enum->isFixed()) { 7931 EltTy = Enum->getIntegerType(); 7932 } 7933 else { 7934 EltTy = Context.IntTy; 7935 } 7936 } else { 7937 // Assign the last value + 1. 7938 EnumVal = LastEnumConst->getInitVal(); 7939 ++EnumVal; 7940 EltTy = LastEnumConst->getType(); 7941 7942 // Check for overflow on increment. 7943 if (EnumVal < LastEnumConst->getInitVal()) { 7944 // C++0x [dcl.enum]p5: 7945 // If the underlying type is not fixed, the type of each enumerator 7946 // is the type of its initializing value: 7947 // 7948 // - Otherwise the type of the initializing value is the same as 7949 // the type of the initializing value of the preceding enumerator 7950 // unless the incremented value is not representable in that type, 7951 // in which case the type is an unspecified integral type 7952 // sufficient to contain the incremented value. If no such type 7953 // exists, the program is ill-formed. 7954 QualType T = getNextLargerIntegralType(Context, EltTy); 7955 if (T.isNull() || Enum->isFixed()) { 7956 // There is no integral type larger enough to represent this 7957 // value. Complain, then allow the value to wrap around. 7958 EnumVal = LastEnumConst->getInitVal(); 7959 EnumVal = EnumVal.zext(EnumVal.getBitWidth() * 2); 7960 ++EnumVal; 7961 if (Enum->isFixed()) 7962 // When the underlying type is fixed, this is ill-formed. 7963 Diag(IdLoc, diag::err_enumerator_wrapped) 7964 << EnumVal.toString(10) 7965 << EltTy; 7966 else 7967 Diag(IdLoc, diag::warn_enumerator_too_large) 7968 << EnumVal.toString(10); 7969 } else { 7970 EltTy = T; 7971 } 7972 7973 // Retrieve the last enumerator's value, extent that type to the 7974 // type that is supposed to be large enough to represent the incremented 7975 // value, then increment. 7976 EnumVal = LastEnumConst->getInitVal(); 7977 EnumVal.setIsSigned(EltTy->isSignedIntegerType()); 7978 EnumVal = EnumVal.zextOrTrunc(Context.getIntWidth(EltTy)); 7979 ++EnumVal; 7980 7981 // If we're not in C++, diagnose the overflow of enumerator values, 7982 // which in C99 means that the enumerator value is not representable in 7983 // an int (C99 6.7.2.2p2). However, we support GCC's extension that 7984 // permits enumerator values that are representable in some larger 7985 // integral type. 7986 if (!getLangOptions().CPlusPlus && !T.isNull()) 7987 Diag(IdLoc, diag::warn_enum_value_overflow); 7988 } else if (!getLangOptions().CPlusPlus && 7989 !isRepresentableIntegerValue(Context, EnumVal, EltTy)) { 7990 // Enforce C99 6.7.2.2p2 even when we compute the next value. 7991 Diag(IdLoc, diag::ext_enum_value_not_int) 7992 << EnumVal.toString(10) << 1; 7993 } 7994 } 7995 } 7996 7997 if (!EltTy->isDependentType()) { 7998 // Make the enumerator value match the signedness and size of the 7999 // enumerator's type. 8000 EnumVal = EnumVal.zextOrTrunc(Context.getIntWidth(EltTy)); 8001 EnumVal.setIsSigned(EltTy->isSignedIntegerType()); 8002 } 8003 8004 return EnumConstantDecl::Create(Context, Enum, IdLoc, Id, EltTy, 8005 Val, EnumVal); 8006} 8007 8008 8009Decl *Sema::ActOnEnumConstant(Scope *S, Decl *theEnumDecl, Decl *lastEnumConst, 8010 SourceLocation IdLoc, IdentifierInfo *Id, 8011 AttributeList *Attr, 8012 SourceLocation EqualLoc, ExprTy *val) { 8013 EnumDecl *TheEnumDecl = cast<EnumDecl>(theEnumDecl); 8014 EnumConstantDecl *LastEnumConst = 8015 cast_or_null<EnumConstantDecl>(lastEnumConst); 8016 Expr *Val = static_cast<Expr*>(val); 8017 8018 // The scope passed in may not be a decl scope. Zip up the scope tree until 8019 // we find one that is. 8020 S = getNonFieldDeclScope(S); 8021 8022 // Verify that there isn't already something declared with this name in this 8023 // scope. 8024 NamedDecl *PrevDecl = LookupSingleName(S, Id, IdLoc, LookupOrdinaryName, 8025 ForRedeclaration); 8026 if (PrevDecl && PrevDecl->isTemplateParameter()) { 8027 // Maybe we will complain about the shadowed template parameter. 8028 DiagnoseTemplateParameterShadow(IdLoc, PrevDecl); 8029 // Just pretend that we didn't see the previous declaration. 8030 PrevDecl = 0; 8031 } 8032 8033 if (PrevDecl) { 8034 // When in C++, we may get a TagDecl with the same name; in this case the 8035 // enum constant will 'hide' the tag. 8036 assert((getLangOptions().CPlusPlus || !isa<TagDecl>(PrevDecl)) && 8037 "Received TagDecl when not in C++!"); 8038 if (!isa<TagDecl>(PrevDecl) && isDeclInScope(PrevDecl, CurContext, S)) { 8039 if (isa<EnumConstantDecl>(PrevDecl)) 8040 Diag(IdLoc, diag::err_redefinition_of_enumerator) << Id; 8041 else 8042 Diag(IdLoc, diag::err_redefinition) << Id; 8043 Diag(PrevDecl->getLocation(), diag::note_previous_definition); 8044 return 0; 8045 } 8046 } 8047 8048 // C++ [class.mem]p13: 8049 // If T is the name of a class, then each of the following shall have a 8050 // name different from T: 8051 // - every enumerator of every member of class T that is an enumerated 8052 // type 8053 if (CXXRecordDecl *Record 8054 = dyn_cast<CXXRecordDecl>( 8055 TheEnumDecl->getDeclContext()->getRedeclContext())) 8056 if (Record->getIdentifier() && Record->getIdentifier() == Id) 8057 Diag(IdLoc, diag::err_member_name_of_class) << Id; 8058 8059 EnumConstantDecl *New = 8060 CheckEnumConstant(TheEnumDecl, LastEnumConst, IdLoc, Id, Val); 8061 8062 if (New) { 8063 // Process attributes. 8064 if (Attr) ProcessDeclAttributeList(S, New, Attr); 8065 8066 // Register this decl in the current scope stack. 8067 New->setAccess(TheEnumDecl->getAccess()); 8068 PushOnScopeChains(New, S); 8069 } 8070 8071 return New; 8072} 8073 8074void Sema::ActOnEnumBody(SourceLocation EnumLoc, SourceLocation LBraceLoc, 8075 SourceLocation RBraceLoc, Decl *EnumDeclX, 8076 Decl **Elements, unsigned NumElements, 8077 Scope *S, AttributeList *Attr) { 8078 EnumDecl *Enum = cast<EnumDecl>(EnumDeclX); 8079 QualType EnumType = Context.getTypeDeclType(Enum); 8080 8081 if (Attr) 8082 ProcessDeclAttributeList(S, Enum, Attr); 8083 8084 if (Enum->isDependentType()) { 8085 for (unsigned i = 0; i != NumElements; ++i) { 8086 EnumConstantDecl *ECD = 8087 cast_or_null<EnumConstantDecl>(Elements[i]); 8088 if (!ECD) continue; 8089 8090 ECD->setType(EnumType); 8091 } 8092 8093 Enum->completeDefinition(Context.DependentTy, Context.DependentTy, 0, 0); 8094 return; 8095 } 8096 8097 // TODO: If the result value doesn't fit in an int, it must be a long or long 8098 // long value. ISO C does not support this, but GCC does as an extension, 8099 // emit a warning. 8100 unsigned IntWidth = Context.Target.getIntWidth(); 8101 unsigned CharWidth = Context.Target.getCharWidth(); 8102 unsigned ShortWidth = Context.Target.getShortWidth(); 8103 8104 // Verify that all the values are okay, compute the size of the values, and 8105 // reverse the list. 8106 unsigned NumNegativeBits = 0; 8107 unsigned NumPositiveBits = 0; 8108 8109 // Keep track of whether all elements have type int. 8110 bool AllElementsInt = true; 8111 8112 for (unsigned i = 0; i != NumElements; ++i) { 8113 EnumConstantDecl *ECD = 8114 cast_or_null<EnumConstantDecl>(Elements[i]); 8115 if (!ECD) continue; // Already issued a diagnostic. 8116 8117 const llvm::APSInt &InitVal = ECD->getInitVal(); 8118 8119 // Keep track of the size of positive and negative values. 8120 if (InitVal.isUnsigned() || InitVal.isNonNegative()) 8121 NumPositiveBits = std::max(NumPositiveBits, 8122 (unsigned)InitVal.getActiveBits()); 8123 else 8124 NumNegativeBits = std::max(NumNegativeBits, 8125 (unsigned)InitVal.getMinSignedBits()); 8126 8127 // Keep track of whether every enum element has type int (very commmon). 8128 if (AllElementsInt) 8129 AllElementsInt = ECD->getType() == Context.IntTy; 8130 } 8131 8132 // Figure out the type that should be used for this enum. 8133 QualType BestType; 8134 unsigned BestWidth; 8135 8136 // C++0x N3000 [conv.prom]p3: 8137 // An rvalue of an unscoped enumeration type whose underlying 8138 // type is not fixed can be converted to an rvalue of the first 8139 // of the following types that can represent all the values of 8140 // the enumeration: int, unsigned int, long int, unsigned long 8141 // int, long long int, or unsigned long long int. 8142 // C99 6.4.4.3p2: 8143 // An identifier declared as an enumeration constant has type int. 8144 // The C99 rule is modified by a gcc extension 8145 QualType BestPromotionType; 8146 8147 bool Packed = Enum->getAttr<PackedAttr>() ? true : false; 8148 // -fshort-enums is the equivalent to specifying the packed attribute on all 8149 // enum definitions. 8150 if (LangOpts.ShortEnums) 8151 Packed = true; 8152 8153 if (Enum->isFixed()) { 8154 BestType = BestPromotionType = Enum->getIntegerType(); 8155 // We don't need to set BestWidth, because BestType is going to be the type 8156 // of the enumerators, but we do anyway because otherwise some compilers 8157 // warn that it might be used uninitialized. 8158 BestWidth = CharWidth; 8159 } 8160 else if (NumNegativeBits) { 8161 // If there is a negative value, figure out the smallest integer type (of 8162 // int/long/longlong) that fits. 8163 // If it's packed, check also if it fits a char or a short. 8164 if (Packed && NumNegativeBits <= CharWidth && NumPositiveBits < CharWidth) { 8165 BestType = Context.SignedCharTy; 8166 BestWidth = CharWidth; 8167 } else if (Packed && NumNegativeBits <= ShortWidth && 8168 NumPositiveBits < ShortWidth) { 8169 BestType = Context.ShortTy; 8170 BestWidth = ShortWidth; 8171 } else if (NumNegativeBits <= IntWidth && NumPositiveBits < IntWidth) { 8172 BestType = Context.IntTy; 8173 BestWidth = IntWidth; 8174 } else { 8175 BestWidth = Context.Target.getLongWidth(); 8176 8177 if (NumNegativeBits <= BestWidth && NumPositiveBits < BestWidth) { 8178 BestType = Context.LongTy; 8179 } else { 8180 BestWidth = Context.Target.getLongLongWidth(); 8181 8182 if (NumNegativeBits > BestWidth || NumPositiveBits >= BestWidth) 8183 Diag(Enum->getLocation(), diag::warn_enum_too_large); 8184 BestType = Context.LongLongTy; 8185 } 8186 } 8187 BestPromotionType = (BestWidth <= IntWidth ? Context.IntTy : BestType); 8188 } else { 8189 // If there is no negative value, figure out the smallest type that fits 8190 // all of the enumerator values. 8191 // If it's packed, check also if it fits a char or a short. 8192 if (Packed && NumPositiveBits <= CharWidth) { 8193 BestType = Context.UnsignedCharTy; 8194 BestPromotionType = Context.IntTy; 8195 BestWidth = CharWidth; 8196 } else if (Packed && NumPositiveBits <= ShortWidth) { 8197 BestType = Context.UnsignedShortTy; 8198 BestPromotionType = Context.IntTy; 8199 BestWidth = ShortWidth; 8200 } else if (NumPositiveBits <= IntWidth) { 8201 BestType = Context.UnsignedIntTy; 8202 BestWidth = IntWidth; 8203 BestPromotionType 8204 = (NumPositiveBits == BestWidth || !getLangOptions().CPlusPlus) 8205 ? Context.UnsignedIntTy : Context.IntTy; 8206 } else if (NumPositiveBits <= 8207 (BestWidth = Context.Target.getLongWidth())) { 8208 BestType = Context.UnsignedLongTy; 8209 BestPromotionType 8210 = (NumPositiveBits == BestWidth || !getLangOptions().CPlusPlus) 8211 ? Context.UnsignedLongTy : Context.LongTy; 8212 } else { 8213 BestWidth = Context.Target.getLongLongWidth(); 8214 assert(NumPositiveBits <= BestWidth && 8215 "How could an initializer get larger than ULL?"); 8216 BestType = Context.UnsignedLongLongTy; 8217 BestPromotionType 8218 = (NumPositiveBits == BestWidth || !getLangOptions().CPlusPlus) 8219 ? Context.UnsignedLongLongTy : Context.LongLongTy; 8220 } 8221 } 8222 8223 // Loop over all of the enumerator constants, changing their types to match 8224 // the type of the enum if needed. 8225 for (unsigned i = 0; i != NumElements; ++i) { 8226 EnumConstantDecl *ECD = cast_or_null<EnumConstantDecl>(Elements[i]); 8227 if (!ECD) continue; // Already issued a diagnostic. 8228 8229 // Standard C says the enumerators have int type, but we allow, as an 8230 // extension, the enumerators to be larger than int size. If each 8231 // enumerator value fits in an int, type it as an int, otherwise type it the 8232 // same as the enumerator decl itself. This means that in "enum { X = 1U }" 8233 // that X has type 'int', not 'unsigned'. 8234 8235 // Determine whether the value fits into an int. 8236 llvm::APSInt InitVal = ECD->getInitVal(); 8237 8238 // If it fits into an integer type, force it. Otherwise force it to match 8239 // the enum decl type. 8240 QualType NewTy; 8241 unsigned NewWidth; 8242 bool NewSign; 8243 if (!getLangOptions().CPlusPlus && 8244 isRepresentableIntegerValue(Context, InitVal, Context.IntTy)) { 8245 NewTy = Context.IntTy; 8246 NewWidth = IntWidth; 8247 NewSign = true; 8248 } else if (ECD->getType() == BestType) { 8249 // Already the right type! 8250 if (getLangOptions().CPlusPlus) 8251 // C++ [dcl.enum]p4: Following the closing brace of an 8252 // enum-specifier, each enumerator has the type of its 8253 // enumeration. 8254 ECD->setType(EnumType); 8255 continue; 8256 } else { 8257 NewTy = BestType; 8258 NewWidth = BestWidth; 8259 NewSign = BestType->isSignedIntegerType(); 8260 } 8261 8262 // Adjust the APSInt value. 8263 InitVal = InitVal.extOrTrunc(NewWidth); 8264 InitVal.setIsSigned(NewSign); 8265 ECD->setInitVal(InitVal); 8266 8267 // Adjust the Expr initializer and type. 8268 if (ECD->getInitExpr() && 8269 !Context.hasSameType(NewTy, ECD->getInitExpr()->getType())) 8270 ECD->setInitExpr(ImplicitCastExpr::Create(Context, NewTy, 8271 CK_IntegralCast, 8272 ECD->getInitExpr(), 8273 /*base paths*/ 0, 8274 VK_RValue)); 8275 if (getLangOptions().CPlusPlus) 8276 // C++ [dcl.enum]p4: Following the closing brace of an 8277 // enum-specifier, each enumerator has the type of its 8278 // enumeration. 8279 ECD->setType(EnumType); 8280 else 8281 ECD->setType(NewTy); 8282 } 8283 8284 Enum->completeDefinition(BestType, BestPromotionType, 8285 NumPositiveBits, NumNegativeBits); 8286} 8287 8288Decl *Sema::ActOnFileScopeAsmDecl(Expr *expr, 8289 SourceLocation StartLoc, 8290 SourceLocation EndLoc) { 8291 StringLiteral *AsmString = cast<StringLiteral>(expr); 8292 8293 FileScopeAsmDecl *New = FileScopeAsmDecl::Create(Context, CurContext, 8294 AsmString, StartLoc, 8295 EndLoc); 8296 CurContext->addDecl(New); 8297 return New; 8298} 8299 8300void Sema::ActOnPragmaWeakID(IdentifierInfo* Name, 8301 SourceLocation PragmaLoc, 8302 SourceLocation NameLoc) { 8303 Decl *PrevDecl = LookupSingleName(TUScope, Name, NameLoc, LookupOrdinaryName); 8304 8305 if (PrevDecl) { 8306 PrevDecl->addAttr(::new (Context) WeakAttr(PragmaLoc, Context)); 8307 } else { 8308 (void)WeakUndeclaredIdentifiers.insert( 8309 std::pair<IdentifierInfo*,WeakInfo> 8310 (Name, WeakInfo((IdentifierInfo*)0, NameLoc))); 8311 } 8312} 8313 8314void Sema::ActOnPragmaWeakAlias(IdentifierInfo* Name, 8315 IdentifierInfo* AliasName, 8316 SourceLocation PragmaLoc, 8317 SourceLocation NameLoc, 8318 SourceLocation AliasNameLoc) { 8319 Decl *PrevDecl = LookupSingleName(TUScope, AliasName, AliasNameLoc, 8320 LookupOrdinaryName); 8321 WeakInfo W = WeakInfo(Name, NameLoc); 8322 8323 if (PrevDecl) { 8324 if (!PrevDecl->hasAttr<AliasAttr>()) 8325 if (NamedDecl *ND = dyn_cast<NamedDecl>(PrevDecl)) 8326 DeclApplyPragmaWeak(TUScope, ND, W); 8327 } else { 8328 (void)WeakUndeclaredIdentifiers.insert( 8329 std::pair<IdentifierInfo*,WeakInfo>(AliasName, W)); 8330 } 8331} 8332