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