1 //===--- SemaDecl.cpp - Semantic Analysis for Declarations ----------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file implements semantic analysis for declarations.
12 //===----------------------------------------------------------------------===//
17 #include "clang/Analysis/PathSensitive/AnalysisContext.h"
18 #include "clang/AST/APValue.h"
19 #include "clang/AST/ASTConsumer.h"
20 #include "clang/AST/ASTContext.h"
21 #include "clang/AST/CXXInheritance.h"
22 #include "clang/AST/DeclTemplate.h"
23 #include "clang/AST/ExprCXX.h"
24 #include "clang/AST/StmtCXX.h"
25 #include "clang/Parse/DeclSpec.h"
26 #include "clang/Parse/ParseDiagnostic.h"
27 #include "clang/Parse/Template.h"
28 #include "clang/Basic/PartialDiagnostic.h"
29 #include "clang/Basic/SourceManager.h"
30 #include "clang/Basic/TargetInfo.h"
31 // FIXME: layering (ideally, Sema shouldn't be dependent on Lex API's)
32 #include "clang/Lex/Preprocessor.h"
33 #include "clang/Lex/HeaderSearch.h"
34 #include "llvm/ADT/Triple.h"
38 using namespace clang;
40 /// getDeclName - Return a pretty name for the specified decl if possible, or
41 /// an empty string if not. This is used for pretty crash reporting.
42 std::string Sema::getDeclName(DeclPtrTy d) {
43 Decl *D = d.getAs<Decl>();
44 if (NamedDecl *DN = dyn_cast_or_null<NamedDecl>(D))
45 return DN->getQualifiedNameAsString();
49 Sema::DeclGroupPtrTy Sema::ConvertDeclToDeclGroup(DeclPtrTy Ptr) {
50 return DeclGroupPtrTy::make(DeclGroupRef(Ptr.getAs<Decl>()));
53 /// \brief If the identifier refers to a type name within this scope,
54 /// return the declaration of that type.
56 /// This routine performs ordinary name lookup of the identifier II
57 /// within the given scope, with optional C++ scope specifier SS, to
58 /// determine whether the name refers to a type. If so, returns an
59 /// opaque pointer (actually a QualType) corresponding to that
60 /// type. Otherwise, returns NULL.
62 /// If name lookup results in an ambiguity, this routine will complain
63 /// and then return NULL.
64 Sema::TypeTy *Sema::getTypeName(IdentifierInfo &II, SourceLocation NameLoc,
65 Scope *S, const CXXScopeSpec *SS,
67 TypeTy *ObjectTypePtr) {
68 // Determine where we will perform name lookup.
69 DeclContext *LookupCtx = 0;
71 QualType ObjectType = QualType::getFromOpaquePtr(ObjectTypePtr);
72 if (ObjectType->isRecordType())
73 LookupCtx = computeDeclContext(ObjectType);
74 } else if (SS && SS->isSet()) {
75 LookupCtx = computeDeclContext(*SS, false);
78 if (isDependentScopeSpecifier(*SS)) {
80 // A qualified-id that refers to a type and in which the
81 // nested-name-specifier depends on a template-parameter (14.6.2)
82 // shall be prefixed by the keyword typename to indicate that the
83 // qualified-id denotes a type, forming an
84 // elaborated-type-specifier (7.1.5.3).
86 // We therefore do not perform any name lookup if the result would
87 // refer to a member of an unknown specialization.
91 // We know from the grammar that this name refers to a type, so build a
92 // TypenameType node to describe the type.
93 // FIXME: Record somewhere that this TypenameType node has no "typename"
94 // keyword associated with it.
95 return CheckTypenameType((NestedNameSpecifier *)SS->getScopeRep(),
96 II, SS->getRange()).getAsOpaquePtr();
102 if (!LookupCtx->isDependentContext() && RequireCompleteDeclContext(*SS))
106 // FIXME: LookupNestedNameSpecifierName isn't the right kind of
107 // lookup for class-names.
108 LookupNameKind Kind = isClassName ? LookupNestedNameSpecifierName :
110 LookupResult Result(*this, &II, NameLoc, Kind);
112 // Perform "qualified" name lookup into the declaration context we
113 // computed, which is either the type of the base of a member access
114 // expression or the declaration context associated with a prior
115 // nested-name-specifier.
116 LookupQualifiedName(Result, LookupCtx);
118 if (ObjectTypePtr && Result.empty()) {
119 // C++ [basic.lookup.classref]p3:
120 // If the unqualified-id is ~type-name, the type-name is looked up
121 // in the context of the entire postfix-expression. If the type T of
122 // the object expression is of a class type C, the type-name is also
123 // looked up in the scope of class C. At least one of the lookups shall
124 // find a name that refers to (possibly cv-qualified) T.
125 LookupName(Result, S);
128 // Perform unqualified name lookup.
129 LookupName(Result, S);
132 NamedDecl *IIDecl = 0;
133 switch (Result.getResultKind()) {
134 case LookupResult::NotFound:
135 case LookupResult::NotFoundInCurrentInstantiation:
136 case LookupResult::FoundOverloaded:
137 case LookupResult::FoundUnresolvedValue:
140 case LookupResult::Ambiguous:
141 // Recover from type-hiding ambiguities by hiding the type. We'll
142 // do the lookup again when looking for an object, and we can
143 // diagnose the error then. If we don't do this, then the error
144 // about hiding the type will be immediately followed by an error
145 // that only makes sense if the identifier was treated like a type.
146 if (Result.getAmbiguityKind() == LookupResult::AmbiguousTagHiding) {
147 Result.suppressDiagnostics();
151 // Look to see if we have a type anywhere in the list of results.
152 for (LookupResult::iterator Res = Result.begin(), ResEnd = Result.end();
153 Res != ResEnd; ++Res) {
154 if (isa<TypeDecl>(*Res) || isa<ObjCInterfaceDecl>(*Res)) {
156 (*Res)->getLocation().getRawEncoding() <
157 IIDecl->getLocation().getRawEncoding())
163 // None of the entities we found is a type, so there is no way
164 // to even assume that the result is a type. In this case, don't
165 // complain about the ambiguity. The parser will either try to
166 // perform this lookup again (e.g., as an object name), which
167 // will produce the ambiguity, or will complain that it expected
169 Result.suppressDiagnostics();
173 // We found a type within the ambiguous lookup; diagnose the
174 // ambiguity and then return that type. This might be the right
175 // answer, or it might not be, but it suppresses any attempt to
176 // perform the name lookup again.
179 case LookupResult::Found:
180 IIDecl = Result.getFoundDecl();
184 assert(IIDecl && "Didn't find decl");
187 if (TypeDecl *TD = dyn_cast<TypeDecl>(IIDecl)) {
188 DiagnoseUseOfDecl(IIDecl, NameLoc);
190 // C++ [temp.local]p2:
191 // Within the scope of a class template specialization or
192 // partial specialization, when the injected-class-name is
193 // not followed by a <, it is equivalent to the
194 // injected-class-name followed by the template-argument s
195 // of the class template specialization or partial
196 // specialization enclosed in <>.
197 if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(TD))
198 if (RD->isInjectedClassName())
199 if (ClassTemplateDecl *Template = RD->getDescribedClassTemplate())
200 T = Template->getInjectedClassNameType(Context);
203 T = Context.getTypeDeclType(TD);
206 T = getQualifiedNameType(*SS, T);
208 } else if (ObjCInterfaceDecl *IDecl = dyn_cast<ObjCInterfaceDecl>(IIDecl)) {
209 T = Context.getObjCInterfaceType(IDecl);
210 } else if (UnresolvedUsingTypenameDecl *UUDecl =
211 dyn_cast<UnresolvedUsingTypenameDecl>(IIDecl)) {
212 // FIXME: preserve source structure information.
213 T = Context.getTypenameType(UUDecl->getTargetNestedNameSpecifier(), &II);
215 // If it's not plausibly a type, suppress diagnostics.
216 Result.suppressDiagnostics();
220 return T.getAsOpaquePtr();
223 /// isTagName() - This method is called *for error recovery purposes only*
224 /// to determine if the specified name is a valid tag name ("struct foo"). If
225 /// so, this returns the TST for the tag corresponding to it (TST_enum,
226 /// TST_union, TST_struct, TST_class). This is used to diagnose cases in C
227 /// where the user forgot to specify the tag.
228 DeclSpec::TST Sema::isTagName(IdentifierInfo &II, Scope *S) {
229 // Do a tag name lookup in this scope.
230 LookupResult R(*this, &II, SourceLocation(), LookupTagName);
231 LookupName(R, S, false);
232 R.suppressDiagnostics();
233 if (R.getResultKind() == LookupResult::Found)
234 if (const TagDecl *TD = R.getAsSingle<TagDecl>()) {
235 switch (TD->getTagKind()) {
236 case TagDecl::TK_struct: return DeclSpec::TST_struct;
237 case TagDecl::TK_union: return DeclSpec::TST_union;
238 case TagDecl::TK_class: return DeclSpec::TST_class;
239 case TagDecl::TK_enum: return DeclSpec::TST_enum;
243 return DeclSpec::TST_unspecified;
246 bool Sema::DiagnoseUnknownTypeName(const IdentifierInfo &II,
247 SourceLocation IILoc,
249 const CXXScopeSpec *SS,
250 TypeTy *&SuggestedType) {
251 // We don't have anything to suggest (yet).
254 // There may have been a typo in the name of the type. Look up typo
255 // results, in case we have something that we can suggest.
256 LookupResult Lookup(*this, &II, IILoc, LookupOrdinaryName,
257 NotForRedeclaration);
259 // FIXME: It would be nice if we could correct for typos in built-in
260 // names, such as "itn" for "int".
262 if (CorrectTypo(Lookup, S, SS) && Lookup.isSingleResult()) {
263 NamedDecl *Result = Lookup.getAsSingle<NamedDecl>();
264 if ((isa<TypeDecl>(Result) || isa<ObjCInterfaceDecl>(Result)) &&
265 !Result->isInvalidDecl()) {
266 // We found a similarly-named type or interface; suggest that.
267 if (!SS || !SS->isSet())
268 Diag(IILoc, diag::err_unknown_typename_suggest)
269 << &II << Lookup.getLookupName()
270 << CodeModificationHint::CreateReplacement(SourceRange(IILoc),
271 Result->getNameAsString());
272 else if (DeclContext *DC = computeDeclContext(*SS, false))
273 Diag(IILoc, diag::err_unknown_nested_typename_suggest)
274 << &II << DC << Lookup.getLookupName() << SS->getRange()
275 << CodeModificationHint::CreateReplacement(SourceRange(IILoc),
276 Result->getNameAsString());
278 llvm_unreachable("could not have corrected a typo here");
280 Diag(Result->getLocation(), diag::note_previous_decl)
281 << Result->getDeclName();
283 SuggestedType = getTypeName(*Result->getIdentifier(), IILoc, S, SS);
288 // FIXME: Should we move the logic that tries to recover from a missing tag
289 // (struct, union, enum) from Parser::ParseImplicitInt here, instead?
291 if (!SS || (!SS->isSet() && !SS->isInvalid()))
292 Diag(IILoc, diag::err_unknown_typename) << &II;
293 else if (DeclContext *DC = computeDeclContext(*SS, false))
294 Diag(IILoc, diag::err_typename_nested_not_found)
295 << &II << DC << SS->getRange();
296 else if (isDependentScopeSpecifier(*SS)) {
297 Diag(SS->getRange().getBegin(), diag::err_typename_missing)
298 << (NestedNameSpecifier *)SS->getScopeRep() << II.getName()
299 << SourceRange(SS->getRange().getBegin(), IILoc)
300 << CodeModificationHint::CreateInsertion(SS->getRange().getBegin(),
302 SuggestedType = ActOnTypenameType(SourceLocation(), *SS, II, IILoc).get();
304 assert(SS && SS->isInvalid() &&
305 "Invalid scope specifier has already been diagnosed");
311 // Determines the context to return to after temporarily entering a
312 // context. This depends in an unnecessarily complicated way on the
313 // exact ordering of callbacks from the parser.
314 DeclContext *Sema::getContainingDC(DeclContext *DC) {
316 // Functions defined inline within classes aren't parsed until we've
317 // finished parsing the top-level class, so the top-level class is
318 // the context we'll need to return to.
319 if (isa<FunctionDecl>(DC)) {
320 DC = DC->getLexicalParent();
322 // A function not defined within a class will always return to its
324 if (!isa<CXXRecordDecl>(DC))
327 // A C++ inline method/friend is parsed *after* the topmost class
328 // it was declared in is fully parsed ("complete"); the topmost
329 // class is the context we need to return to.
330 while (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(DC->getLexicalParent()))
333 // Return the declaration context of the topmost class the inline method is
338 if (isa<ObjCMethodDecl>(DC))
339 return Context.getTranslationUnitDecl();
341 return DC->getLexicalParent();
344 void Sema::PushDeclContext(Scope *S, DeclContext *DC) {
345 assert(getContainingDC(DC) == CurContext &&
346 "The next DeclContext should be lexically contained in the current one.");
351 void Sema::PopDeclContext() {
352 assert(CurContext && "DeclContext imbalance!");
354 CurContext = getContainingDC(CurContext);
357 /// EnterDeclaratorContext - Used when we must lookup names in the context
358 /// of a declarator's nested name specifier.
360 void Sema::EnterDeclaratorContext(Scope *S, DeclContext *DC) {
361 // C++0x [basic.lookup.unqual]p13:
362 // A name used in the definition of a static data member of class
363 // X (after the qualified-id of the static member) is looked up as
364 // if the name was used in a member function of X.
365 // C++0x [basic.lookup.unqual]p14:
366 // If a variable member of a namespace is defined outside of the
367 // scope of its namespace then any name used in the definition of
368 // the variable member (after the declarator-id) is looked up as
369 // if the definition of the variable member occurred in its
371 // Both of these imply that we should push a scope whose context
372 // is the semantic context of the declaration. We can't use
373 // PushDeclContext here because that context is not necessarily
374 // lexically contained in the current context. Fortunately,
375 // the containing scope should have the appropriate information.
377 assert(!S->getEntity() && "scope already has entity");
380 Scope *Ancestor = S->getParent();
381 while (!Ancestor->getEntity()) Ancestor = Ancestor->getParent();
382 assert(Ancestor->getEntity() == CurContext && "ancestor context mismatch");
389 void Sema::ExitDeclaratorContext(Scope *S) {
390 assert(S->getEntity() == CurContext && "Context imbalance!");
392 // Switch back to the lexical context. The safety of this is
393 // enforced by an assert in EnterDeclaratorContext.
394 Scope *Ancestor = S->getParent();
395 while (!Ancestor->getEntity()) Ancestor = Ancestor->getParent();
396 CurContext = (DeclContext*) Ancestor->getEntity();
398 // We don't need to do anything with the scope, which is going to
402 /// \brief Determine whether we allow overloading of the function
403 /// PrevDecl with another declaration.
405 /// This routine determines whether overloading is possible, not
406 /// whether some new function is actually an overload. It will return
407 /// true in C++ (where we can always provide overloads) or, as an
408 /// extension, in C when the previous function is already an
409 /// overloaded function declaration or has the "overloadable"
411 static bool AllowOverloadingOfFunction(LookupResult &Previous,
412 ASTContext &Context) {
413 if (Context.getLangOptions().CPlusPlus)
416 if (Previous.getResultKind() == LookupResult::FoundOverloaded)
419 return (Previous.getResultKind() == LookupResult::Found
420 && Previous.getFoundDecl()->hasAttr<OverloadableAttr>());
423 /// Add this decl to the scope shadowed decl chains.
424 void Sema::PushOnScopeChains(NamedDecl *D, Scope *S, bool AddToContext) {
425 // Move up the scope chain until we find the nearest enclosing
426 // non-transparent context. The declaration will be introduced into this
428 while (S->getEntity() &&
429 ((DeclContext *)S->getEntity())->isTransparentContext())
432 // Add scoped declarations into their context, so that they can be
433 // found later. Declarations without a context won't be inserted
436 CurContext->addDecl(D);
438 // Out-of-line function and variable definitions should not be pushed into
440 if ((isa<FunctionTemplateDecl>(D) &&
441 cast<FunctionTemplateDecl>(D)->getTemplatedDecl()->isOutOfLine()) ||
442 (isa<FunctionDecl>(D) &&
443 (cast<FunctionDecl>(D)->isFunctionTemplateSpecialization() ||
444 cast<FunctionDecl>(D)->isOutOfLine())) ||
445 (isa<VarDecl>(D) && cast<VarDecl>(D)->isOutOfLine()))
448 // If this replaces anything in the current scope,
449 IdentifierResolver::iterator I = IdResolver.begin(D->getDeclName()),
450 IEnd = IdResolver.end();
451 for (; I != IEnd; ++I) {
452 if (S->isDeclScope(DeclPtrTy::make(*I)) && D->declarationReplaces(*I)) {
453 S->RemoveDecl(DeclPtrTy::make(*I));
454 IdResolver.RemoveDecl(*I);
456 // Should only need to replace one decl.
461 S->AddDecl(DeclPtrTy::make(D));
462 IdResolver.AddDecl(D);
465 bool Sema::isDeclInScope(NamedDecl *&D, DeclContext *Ctx, Scope *S) {
466 return IdResolver.isDeclInScope(D, Ctx, Context, S);
469 static bool isOutOfScopePreviousDeclaration(NamedDecl *,
473 /// Filters out lookup results that don't fall within the given scope
474 /// as determined by isDeclInScope.
475 static void FilterLookupForScope(Sema &SemaRef, LookupResult &R,
476 DeclContext *Ctx, Scope *S,
477 bool ConsiderLinkage) {
478 LookupResult::Filter F = R.makeFilter();
479 while (F.hasNext()) {
480 NamedDecl *D = F.next();
482 if (SemaRef.isDeclInScope(D, Ctx, S))
485 if (ConsiderLinkage &&
486 isOutOfScopePreviousDeclaration(D, Ctx, SemaRef.Context))
495 static bool isUsingDecl(NamedDecl *D) {
496 return isa<UsingShadowDecl>(D) ||
497 isa<UnresolvedUsingTypenameDecl>(D) ||
498 isa<UnresolvedUsingValueDecl>(D);
501 /// Removes using shadow declarations from the lookup results.
502 static void RemoveUsingDecls(LookupResult &R) {
503 LookupResult::Filter F = R.makeFilter();
505 if (isUsingDecl(F.next()))
511 static bool ShouldDiagnoseUnusedDecl(const NamedDecl *D) {
512 if (D->isUsed() || D->hasAttr<UnusedAttr>())
515 if (const ValueDecl *VD = dyn_cast<ValueDecl>(D)) {
516 if (const RecordType *RT = VD->getType()->getAs<RecordType>()) {
517 if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(RT->getDecl())) {
518 if (!RD->hasTrivialConstructor())
520 if (!RD->hasTrivialDestructor())
526 return (isa<VarDecl>(D) && !isa<ParmVarDecl>(D) &&
527 !isa<ImplicitParamDecl>(D) &&
528 D->getDeclContext()->isFunctionOrMethod());
531 void Sema::ActOnPopScope(SourceLocation Loc, Scope *S) {
532 if (S->decl_empty()) return;
533 assert((S->getFlags() & (Scope::DeclScope | Scope::TemplateParamScope)) &&
534 "Scope shouldn't contain decls!");
536 for (Scope::decl_iterator I = S->decl_begin(), E = S->decl_end();
538 Decl *TmpD = (*I).getAs<Decl>();
539 assert(TmpD && "This decl didn't get pushed??");
541 assert(isa<NamedDecl>(TmpD) && "Decl isn't NamedDecl?");
542 NamedDecl *D = cast<NamedDecl>(TmpD);
544 if (!D->getDeclName()) continue;
546 // Diagnose unused variables in this scope.
547 if (ShouldDiagnoseUnusedDecl(D))
548 Diag(D->getLocation(), diag::warn_unused_variable) << D->getDeclName();
550 // Remove this name from our lexical scope.
551 IdResolver.RemoveDecl(D);
555 /// getObjCInterfaceDecl - Look up a for a class declaration in the scope.
556 /// return 0 if one not found.
558 /// \param Id the name of the Objective-C class we're looking for. If
559 /// typo-correction fixes this name, the Id will be updated
560 /// to the fixed name.
562 /// \param RecoverLoc if provided, this routine will attempt to
563 /// recover from a typo in the name of an existing Objective-C class
564 /// and, if successful, will return the lookup that results from
566 ObjCInterfaceDecl *Sema::getObjCInterfaceDecl(IdentifierInfo *&Id,
567 SourceLocation RecoverLoc) {
568 // The third "scope" argument is 0 since we aren't enabling lazy built-in
569 // creation from this context.
570 NamedDecl *IDecl = LookupSingleName(TUScope, Id, LookupOrdinaryName);
572 if (!IDecl && !RecoverLoc.isInvalid()) {
573 // Perform typo correction at the given location, but only if we
574 // find an Objective-C class name.
575 LookupResult R(*this, Id, RecoverLoc, LookupOrdinaryName);
576 if (CorrectTypo(R, TUScope, 0) &&
577 (IDecl = R.getAsSingle<ObjCInterfaceDecl>())) {
578 Diag(RecoverLoc, diag::err_undef_interface_suggest)
579 << Id << IDecl->getDeclName()
580 << CodeModificationHint::CreateReplacement(RecoverLoc,
581 IDecl->getNameAsString());
582 Diag(IDecl->getLocation(), diag::note_previous_decl)
583 << IDecl->getDeclName();
585 Id = IDecl->getIdentifier();
589 return dyn_cast_or_null<ObjCInterfaceDecl>(IDecl);
592 /// getNonFieldDeclScope - Retrieves the innermost scope, starting
593 /// from S, where a non-field would be declared. This routine copes
594 /// with the difference between C and C++ scoping rules in structs and
595 /// unions. For example, the following code is well-formed in C but
596 /// ill-formed in C++:
607 /// For the declaration of BAR, this routine will return a different
608 /// scope. The scope S will be the scope of the unnamed enumeration
609 /// within S6. In C++, this routine will return the scope associated
610 /// with S6, because the enumeration's scope is a transparent
611 /// context but structures can contain non-field names. In C, this
612 /// routine will return the translation unit scope, since the
613 /// enumeration's scope is a transparent context and structures cannot
614 /// contain non-field names.
615 Scope *Sema::getNonFieldDeclScope(Scope *S) {
616 while (((S->getFlags() & Scope::DeclScope) == 0) ||
618 ((DeclContext *)S->getEntity())->isTransparentContext()) ||
619 (S->isClassScope() && !getLangOptions().CPlusPlus))
624 void Sema::InitBuiltinVaListType() {
625 if (!Context.getBuiltinVaListType().isNull())
628 IdentifierInfo *VaIdent = &Context.Idents.get("__builtin_va_list");
629 NamedDecl *VaDecl = LookupSingleName(TUScope, VaIdent, LookupOrdinaryName);
630 TypedefDecl *VaTypedef = cast<TypedefDecl>(VaDecl);
631 Context.setBuiltinVaListType(Context.getTypedefType(VaTypedef));
634 /// LazilyCreateBuiltin - The specified Builtin-ID was first used at
635 /// file scope. lazily create a decl for it. ForRedeclaration is true
636 /// if we're creating this built-in in anticipation of redeclaring the
638 NamedDecl *Sema::LazilyCreateBuiltin(IdentifierInfo *II, unsigned bid,
639 Scope *S, bool ForRedeclaration,
640 SourceLocation Loc) {
641 Builtin::ID BID = (Builtin::ID)bid;
643 if (Context.BuiltinInfo.hasVAListUse(BID))
644 InitBuiltinVaListType();
646 ASTContext::GetBuiltinTypeError Error;
647 QualType R = Context.GetBuiltinType(BID, Error);
649 case ASTContext::GE_None:
653 case ASTContext::GE_Missing_stdio:
654 if (ForRedeclaration)
655 Diag(Loc, diag::err_implicit_decl_requires_stdio)
656 << Context.BuiltinInfo.GetName(BID);
659 case ASTContext::GE_Missing_setjmp:
660 if (ForRedeclaration)
661 Diag(Loc, diag::err_implicit_decl_requires_setjmp)
662 << Context.BuiltinInfo.GetName(BID);
666 if (!ForRedeclaration && Context.BuiltinInfo.isPredefinedLibFunction(BID)) {
667 Diag(Loc, diag::ext_implicit_lib_function_decl)
668 << Context.BuiltinInfo.GetName(BID)
670 if (Context.BuiltinInfo.getHeaderName(BID) &&
671 Diags.getDiagnosticLevel(diag::ext_implicit_lib_function_decl)
672 != Diagnostic::Ignored)
673 Diag(Loc, diag::note_please_include_header)
674 << Context.BuiltinInfo.getHeaderName(BID)
675 << Context.BuiltinInfo.GetName(BID);
678 FunctionDecl *New = FunctionDecl::Create(Context,
679 Context.getTranslationUnitDecl(),
680 Loc, II, R, /*TInfo=*/0,
681 FunctionDecl::Extern, false,
682 /*hasPrototype=*/true);
685 // Create Decl objects for each parameter, adding them to the
687 if (FunctionProtoType *FT = dyn_cast<FunctionProtoType>(R)) {
688 llvm::SmallVector<ParmVarDecl*, 16> Params;
689 for (unsigned i = 0, e = FT->getNumArgs(); i != e; ++i)
690 Params.push_back(ParmVarDecl::Create(Context, New, SourceLocation(), 0,
691 FT->getArgType(i), /*TInfo=*/0,
693 New->setParams(Context, Params.data(), Params.size());
696 AddKnownFunctionAttributes(New);
698 // TUScope is the translation-unit scope to insert this function into.
699 // FIXME: This is hideous. We need to teach PushOnScopeChains to
700 // relate Scopes to DeclContexts, and probably eliminate CurContext
701 // entirely, but we're not there yet.
702 DeclContext *SavedContext = CurContext;
703 CurContext = Context.getTranslationUnitDecl();
704 PushOnScopeChains(New, TUScope);
705 CurContext = SavedContext;
709 /// MergeTypeDefDecl - We just parsed a typedef 'New' which has the
710 /// same name and scope as a previous declaration 'Old'. Figure out
711 /// how to resolve this situation, merging decls or emitting
712 /// diagnostics as appropriate. If there was an error, set New to be invalid.
714 void Sema::MergeTypeDefDecl(TypedefDecl *New, LookupResult &OldDecls) {
715 // If the new decl is known invalid already, don't bother doing any
717 if (New->isInvalidDecl()) return;
719 // Allow multiple definitions for ObjC built-in typedefs.
720 // FIXME: Verify the underlying types are equivalent!
721 if (getLangOptions().ObjC1) {
722 const IdentifierInfo *TypeID = New->getIdentifier();
723 switch (TypeID->getLength()) {
726 if (!TypeID->isStr("id"))
728 Context.ObjCIdRedefinitionType = New->getUnderlyingType();
729 // Install the built-in type for 'id', ignoring the current definition.
730 New->setTypeForDecl(Context.getObjCIdType().getTypePtr());
733 if (!TypeID->isStr("Class"))
735 Context.ObjCClassRedefinitionType = New->getUnderlyingType();
736 // Install the built-in type for 'Class', ignoring the current definition.
737 New->setTypeForDecl(Context.getObjCClassType().getTypePtr());
740 if (!TypeID->isStr("SEL"))
742 Context.ObjCSelRedefinitionType = New->getUnderlyingType();
743 // Install the built-in type for 'SEL', ignoring the current definition.
744 New->setTypeForDecl(Context.getObjCSelType().getTypePtr());
747 if (!TypeID->isStr("Protocol"))
749 Context.setObjCProtoType(New->getUnderlyingType());
752 // Fall through - the typedef name was not a builtin type.
755 // Verify the old decl was also a type.
756 TypeDecl *Old = OldDecls.getAsSingle<TypeDecl>();
758 Diag(New->getLocation(), diag::err_redefinition_different_kind)
759 << New->getDeclName();
761 NamedDecl *OldD = OldDecls.getRepresentativeDecl();
762 if (OldD->getLocation().isValid())
763 Diag(OldD->getLocation(), diag::note_previous_definition);
765 return New->setInvalidDecl();
768 // If the old declaration is invalid, just give up here.
769 if (Old->isInvalidDecl())
770 return New->setInvalidDecl();
772 // Determine the "old" type we'll use for checking and diagnostics.
774 if (TypedefDecl *OldTypedef = dyn_cast<TypedefDecl>(Old))
775 OldType = OldTypedef->getUnderlyingType();
777 OldType = Context.getTypeDeclType(Old);
779 // If the typedef types are not identical, reject them in all languages and
780 // with any extensions enabled.
782 if (OldType != New->getUnderlyingType() &&
783 Context.getCanonicalType(OldType) !=
784 Context.getCanonicalType(New->getUnderlyingType())) {
785 Diag(New->getLocation(), diag::err_redefinition_different_typedef)
786 << New->getUnderlyingType() << OldType;
787 if (Old->getLocation().isValid())
788 Diag(Old->getLocation(), diag::note_previous_definition);
789 return New->setInvalidDecl();
792 // The types match. Link up the redeclaration chain if the old
793 // declaration was a typedef.
794 // FIXME: this is a potential source of wierdness if the type
795 // spellings don't match exactly.
796 if (isa<TypedefDecl>(Old))
797 New->setPreviousDeclaration(cast<TypedefDecl>(Old));
799 if (getLangOptions().Microsoft)
802 if (getLangOptions().CPlusPlus) {
803 // C++ [dcl.typedef]p2:
804 // In a given non-class scope, a typedef specifier can be used to
805 // redefine the name of any type declared in that scope to refer
806 // to the type to which it already refers.
807 if (!isa<CXXRecordDecl>(CurContext))
810 // C++0x [dcl.typedef]p4:
811 // In a given class scope, a typedef specifier can be used to redefine
812 // any class-name declared in that scope that is not also a typedef-name
813 // to refer to the type to which it already refers.
815 // This wording came in via DR424, which was a correction to the
816 // wording in DR56, which accidentally banned code like:
819 // typedef struct A { } A;
822 // in the C++03 standard. We implement the C++0x semantics, which
823 // allow the above but disallow
830 // since that was the intent of DR56.
831 if (!isa<TypedefDecl >(Old))
834 Diag(New->getLocation(), diag::err_redefinition)
835 << New->getDeclName();
836 Diag(Old->getLocation(), diag::note_previous_definition);
837 return New->setInvalidDecl();
840 // If we have a redefinition of a typedef in C, emit a warning. This warning
841 // is normally mapped to an error, but can be controlled with
842 // -Wtypedef-redefinition. If either the original or the redefinition is
843 // in a system header, don't emit this for compatibility with GCC.
844 if (PP.getDiagnostics().getSuppressSystemWarnings() &&
845 (Context.getSourceManager().isInSystemHeader(Old->getLocation()) ||
846 Context.getSourceManager().isInSystemHeader(New->getLocation())))
849 Diag(New->getLocation(), diag::warn_redefinition_of_typedef)
850 << New->getDeclName();
851 Diag(Old->getLocation(), diag::note_previous_definition);
855 /// DeclhasAttr - returns true if decl Declaration already has the target
858 DeclHasAttr(const Decl *decl, const Attr *target) {
859 for (const Attr *attr = decl->getAttrs(); attr; attr = attr->getNext())
860 if (attr->getKind() == target->getKind())
866 /// MergeAttributes - append attributes from the Old decl to the New one.
867 static void MergeAttributes(Decl *New, Decl *Old, ASTContext &C) {
868 for (const Attr *attr = Old->getAttrs(); attr; attr = attr->getNext()) {
869 if (!DeclHasAttr(New, attr) && attr->isMerged()) {
870 Attr *NewAttr = attr->clone(C);
871 NewAttr->setInherited(true);
872 New->addAttr(NewAttr);
877 /// Used in MergeFunctionDecl to keep track of function parameters in
879 struct GNUCompatibleParamWarning {
880 ParmVarDecl *OldParm;
881 ParmVarDecl *NewParm;
882 QualType PromotedType;
886 /// getSpecialMember - get the special member enum for a method.
887 static Sema::CXXSpecialMember getSpecialMember(ASTContext &Ctx,
888 const CXXMethodDecl *MD) {
889 if (const CXXConstructorDecl *Ctor = dyn_cast<CXXConstructorDecl>(MD)) {
890 if (Ctor->isDefaultConstructor())
891 return Sema::CXXDefaultConstructor;
892 if (Ctor->isCopyConstructor())
893 return Sema::CXXCopyConstructor;
896 if (isa<CXXDestructorDecl>(MD))
897 return Sema::CXXDestructor;
899 assert(MD->isCopyAssignment() && "Must have copy assignment operator");
900 return Sema::CXXCopyAssignment;
903 /// MergeFunctionDecl - We just parsed a function 'New' from
904 /// declarator D which has the same name and scope as a previous
905 /// declaration 'Old'. Figure out how to resolve this situation,
906 /// merging decls or emitting diagnostics as appropriate.
908 /// In C++, New and Old must be declarations that are not
909 /// overloaded. Use IsOverload to determine whether New and Old are
910 /// overloaded, and to select the Old declaration that New should be
913 /// Returns true if there was an error, false otherwise.
914 bool Sema::MergeFunctionDecl(FunctionDecl *New, Decl *OldD) {
915 // Verify the old decl was also a function.
916 FunctionDecl *Old = 0;
917 if (FunctionTemplateDecl *OldFunctionTemplate
918 = dyn_cast<FunctionTemplateDecl>(OldD))
919 Old = OldFunctionTemplate->getTemplatedDecl();
921 Old = dyn_cast<FunctionDecl>(OldD);
923 if (UsingShadowDecl *Shadow = dyn_cast<UsingShadowDecl>(OldD)) {
924 Diag(New->getLocation(), diag::err_using_decl_conflict_reverse);
925 Diag(Shadow->getTargetDecl()->getLocation(),
926 diag::note_using_decl_target);
927 Diag(Shadow->getUsingDecl()->getLocation(),
928 diag::note_using_decl) << 0;
932 Diag(New->getLocation(), diag::err_redefinition_different_kind)
933 << New->getDeclName();
934 Diag(OldD->getLocation(), diag::note_previous_definition);
938 // Determine whether the previous declaration was a definition,
939 // implicit declaration, or a declaration.
941 if (Old->isThisDeclarationADefinition())
942 PrevDiag = diag::note_previous_definition;
943 else if (Old->isImplicit())
944 PrevDiag = diag::note_previous_implicit_declaration;
946 PrevDiag = diag::note_previous_declaration;
948 QualType OldQType = Context.getCanonicalType(Old->getType());
949 QualType NewQType = Context.getCanonicalType(New->getType());
951 if (!isa<CXXMethodDecl>(New) && !isa<CXXMethodDecl>(Old) &&
952 New->getStorageClass() == FunctionDecl::Static &&
953 Old->getStorageClass() != FunctionDecl::Static) {
954 Diag(New->getLocation(), diag::err_static_non_static)
956 Diag(Old->getLocation(), PrevDiag);
960 if (getLangOptions().CPlusPlus) {
962 // Certain function declarations cannot be overloaded:
963 // -- Function declarations that differ only in the return type
964 // cannot be overloaded.
965 QualType OldReturnType
966 = cast<FunctionType>(OldQType.getTypePtr())->getResultType();
967 QualType NewReturnType
968 = cast<FunctionType>(NewQType.getTypePtr())->getResultType();
969 if (OldReturnType != NewReturnType) {
970 Diag(New->getLocation(), diag::err_ovl_diff_return_type);
971 Diag(Old->getLocation(), PrevDiag) << Old << Old->getType();
975 const CXXMethodDecl* OldMethod = dyn_cast<CXXMethodDecl>(Old);
976 const CXXMethodDecl* NewMethod = dyn_cast<CXXMethodDecl>(New);
977 if (OldMethod && NewMethod) {
978 if (!NewMethod->getFriendObjectKind() &&
979 NewMethod->getLexicalDeclContext()->isRecord()) {
980 // -- Member function declarations with the same name and the
981 // same parameter types cannot be overloaded if any of them
982 // is a static member function declaration.
983 if (OldMethod->isStatic() || NewMethod->isStatic()) {
984 Diag(New->getLocation(), diag::err_ovl_static_nonstatic_member);
985 Diag(Old->getLocation(), PrevDiag) << Old << Old->getType();
989 // C++ [class.mem]p1:
990 // [...] A member shall not be declared twice in the
991 // member-specification, except that a nested class or member
992 // class template can be declared and then later defined.
994 if (isa<CXXConstructorDecl>(OldMethod))
995 NewDiag = diag::err_constructor_redeclared;
996 else if (isa<CXXDestructorDecl>(NewMethod))
997 NewDiag = diag::err_destructor_redeclared;
998 else if (isa<CXXConversionDecl>(NewMethod))
999 NewDiag = diag::err_conv_function_redeclared;
1001 NewDiag = diag::err_member_redeclared;
1003 Diag(New->getLocation(), NewDiag);
1004 Diag(Old->getLocation(), PrevDiag) << Old << Old->getType();
1006 if (OldMethod->isImplicit()) {
1007 Diag(NewMethod->getLocation(),
1008 diag::err_definition_of_implicitly_declared_member)
1009 << New << getSpecialMember(Context, OldMethod);
1011 Diag(OldMethod->getLocation(),
1012 diag::note_previous_implicit_declaration);
1019 // All declarations for a function shall agree exactly in both the
1020 // return type and the parameter-type-list.
1021 // attributes should be ignored when comparing.
1022 if (Context.getNoReturnType(OldQType, false) ==
1023 Context.getNoReturnType(NewQType, false))
1024 return MergeCompatibleFunctionDecls(New, Old);
1026 // Fall through for conflicting redeclarations and redefinitions.
1029 // C: Function types need to be compatible, not identical. This handles
1030 // duplicate function decls like "void f(int); void f(enum X);" properly.
1031 if (!getLangOptions().CPlusPlus &&
1032 Context.typesAreCompatible(OldQType, NewQType)) {
1033 const FunctionType *OldFuncType = OldQType->getAs<FunctionType>();
1034 const FunctionType *NewFuncType = NewQType->getAs<FunctionType>();
1035 const FunctionProtoType *OldProto = 0;
1036 if (isa<FunctionNoProtoType>(NewFuncType) &&
1037 (OldProto = dyn_cast<FunctionProtoType>(OldFuncType))) {
1038 // The old declaration provided a function prototype, but the
1039 // new declaration does not. Merge in the prototype.
1040 assert(!OldProto->hasExceptionSpec() && "Exception spec in C");
1041 llvm::SmallVector<QualType, 16> ParamTypes(OldProto->arg_type_begin(),
1042 OldProto->arg_type_end());
1043 NewQType = Context.getFunctionType(NewFuncType->getResultType(),
1044 ParamTypes.data(), ParamTypes.size(),
1045 OldProto->isVariadic(),
1046 OldProto->getTypeQuals());
1047 New->setType(NewQType);
1048 New->setHasInheritedPrototype();
1050 // Synthesize a parameter for each argument type.
1051 llvm::SmallVector<ParmVarDecl*, 16> Params;
1052 for (FunctionProtoType::arg_type_iterator
1053 ParamType = OldProto->arg_type_begin(),
1054 ParamEnd = OldProto->arg_type_end();
1055 ParamType != ParamEnd; ++ParamType) {
1056 ParmVarDecl *Param = ParmVarDecl::Create(Context, New,
1057 SourceLocation(), 0,
1058 *ParamType, /*TInfo=*/0,
1060 Param->setImplicit();
1061 Params.push_back(Param);
1064 New->setParams(Context, Params.data(), Params.size());
1067 return MergeCompatibleFunctionDecls(New, Old);
1070 // GNU C permits a K&R definition to follow a prototype declaration
1071 // if the declared types of the parameters in the K&R definition
1072 // match the types in the prototype declaration, even when the
1073 // promoted types of the parameters from the K&R definition differ
1074 // from the types in the prototype. GCC then keeps the types from
1077 // If a variadic prototype is followed by a non-variadic K&R definition,
1078 // the K&R definition becomes variadic. This is sort of an edge case, but
1079 // it's legal per the standard depending on how you read C99 6.7.5.3p15 and
1081 if (!getLangOptions().CPlusPlus &&
1082 Old->hasPrototype() && !New->hasPrototype() &&
1083 New->getType()->getAs<FunctionProtoType>() &&
1084 Old->getNumParams() == New->getNumParams()) {
1085 llvm::SmallVector<QualType, 16> ArgTypes;
1086 llvm::SmallVector<GNUCompatibleParamWarning, 16> Warnings;
1087 const FunctionProtoType *OldProto
1088 = Old->getType()->getAs<FunctionProtoType>();
1089 const FunctionProtoType *NewProto
1090 = New->getType()->getAs<FunctionProtoType>();
1092 // Determine whether this is the GNU C extension.
1093 QualType MergedReturn = Context.mergeTypes(OldProto->getResultType(),
1094 NewProto->getResultType());
1095 bool LooseCompatible = !MergedReturn.isNull();
1096 for (unsigned Idx = 0, End = Old->getNumParams();
1097 LooseCompatible && Idx != End; ++Idx) {
1098 ParmVarDecl *OldParm = Old->getParamDecl(Idx);
1099 ParmVarDecl *NewParm = New->getParamDecl(Idx);
1100 if (Context.typesAreCompatible(OldParm->getType(),
1101 NewProto->getArgType(Idx))) {
1102 ArgTypes.push_back(NewParm->getType());
1103 } else if (Context.typesAreCompatible(OldParm->getType(),
1104 NewParm->getType())) {
1105 GNUCompatibleParamWarning Warn
1106 = { OldParm, NewParm, NewProto->getArgType(Idx) };
1107 Warnings.push_back(Warn);
1108 ArgTypes.push_back(NewParm->getType());
1110 LooseCompatible = false;
1113 if (LooseCompatible) {
1114 for (unsigned Warn = 0; Warn < Warnings.size(); ++Warn) {
1115 Diag(Warnings[Warn].NewParm->getLocation(),
1116 diag::ext_param_promoted_not_compatible_with_prototype)
1117 << Warnings[Warn].PromotedType
1118 << Warnings[Warn].OldParm->getType();
1119 Diag(Warnings[Warn].OldParm->getLocation(),
1120 diag::note_previous_declaration);
1123 New->setType(Context.getFunctionType(MergedReturn, &ArgTypes[0],
1125 OldProto->isVariadic(), 0));
1126 return MergeCompatibleFunctionDecls(New, Old);
1129 // Fall through to diagnose conflicting types.
1132 // A function that has already been declared has been redeclared or defined
1133 // with a different type- show appropriate diagnostic
1134 if (unsigned BuiltinID = Old->getBuiltinID()) {
1135 // The user has declared a builtin function with an incompatible
1137 if (Context.BuiltinInfo.isPredefinedLibFunction(BuiltinID)) {
1138 // The function the user is redeclaring is a library-defined
1139 // function like 'malloc' or 'printf'. Warn about the
1140 // redeclaration, then pretend that we don't know about this
1141 // library built-in.
1142 Diag(New->getLocation(), diag::warn_redecl_library_builtin) << New;
1143 Diag(Old->getLocation(), diag::note_previous_builtin_declaration)
1144 << Old << Old->getType();
1145 New->getIdentifier()->setBuiltinID(Builtin::NotBuiltin);
1146 Old->setInvalidDecl();
1150 PrevDiag = diag::note_previous_builtin_declaration;
1153 Diag(New->getLocation(), diag::err_conflicting_types) << New->getDeclName();
1154 Diag(Old->getLocation(), PrevDiag) << Old << Old->getType();
1158 /// \brief Completes the merge of two function declarations that are
1159 /// known to be compatible.
1161 /// This routine handles the merging of attributes and other
1162 /// properties of function declarations form the old declaration to
1163 /// the new declaration, once we know that New is in fact a
1164 /// redeclaration of Old.
1167 bool Sema::MergeCompatibleFunctionDecls(FunctionDecl *New, FunctionDecl *Old) {
1168 // Merge the attributes
1169 MergeAttributes(New, Old, Context);
1171 // Merge the storage class.
1172 if (Old->getStorageClass() != FunctionDecl::Extern &&
1173 Old->getStorageClass() != FunctionDecl::None)
1174 New->setStorageClass(Old->getStorageClass());
1176 // Merge "pure" flag.
1180 // Merge the "deleted" flag.
1181 if (Old->isDeleted())
1184 if (getLangOptions().CPlusPlus)
1185 return MergeCXXFunctionDecl(New, Old);
1190 /// MergeVarDecl - We just parsed a variable 'New' which has the same name
1191 /// and scope as a previous declaration 'Old'. Figure out how to resolve this
1192 /// situation, merging decls or emitting diagnostics as appropriate.
1194 /// Tentative definition rules (C99 6.9.2p2) are checked by
1195 /// FinalizeDeclaratorGroup. Unfortunately, we can't analyze tentative
1196 /// definitions here, since the initializer hasn't been attached.
1198 void Sema::MergeVarDecl(VarDecl *New, LookupResult &Previous) {
1199 // If the new decl is already invalid, don't do any other checking.
1200 if (New->isInvalidDecl())
1203 // Verify the old decl was also a variable.
1205 if (!Previous.isSingleResult() ||
1206 !(Old = dyn_cast<VarDecl>(Previous.getFoundDecl()))) {
1207 Diag(New->getLocation(), diag::err_redefinition_different_kind)
1208 << New->getDeclName();
1209 Diag(Previous.getRepresentativeDecl()->getLocation(),
1210 diag::note_previous_definition);
1211 return New->setInvalidDecl();
1214 MergeAttributes(New, Old, Context);
1218 if (getLangOptions().CPlusPlus) {
1219 if (Context.hasSameType(New->getType(), Old->getType()))
1220 MergedT = New->getType();
1221 // C++ [basic.link]p10:
1222 // [...] the types specified by all declarations referring to a given
1223 // object or function shall be identical, except that declarations for an
1224 // array object can specify array types that differ by the presence or
1225 // absence of a major array bound (8.3.4).
1226 else if (Old->getType()->isIncompleteArrayType() &&
1227 New->getType()->isArrayType()) {
1228 CanQual<ArrayType> OldArray
1229 = Context.getCanonicalType(Old->getType())->getAs<ArrayType>();
1230 CanQual<ArrayType> NewArray
1231 = Context.getCanonicalType(New->getType())->getAs<ArrayType>();
1232 if (OldArray->getElementType() == NewArray->getElementType())
1233 MergedT = New->getType();
1234 } else if (Old->getType()->isArrayType() &&
1235 New->getType()->isIncompleteArrayType()) {
1236 CanQual<ArrayType> OldArray
1237 = Context.getCanonicalType(Old->getType())->getAs<ArrayType>();
1238 CanQual<ArrayType> NewArray
1239 = Context.getCanonicalType(New->getType())->getAs<ArrayType>();
1240 if (OldArray->getElementType() == NewArray->getElementType())
1241 MergedT = Old->getType();
1244 MergedT = Context.mergeTypes(New->getType(), Old->getType());
1246 if (MergedT.isNull()) {
1247 Diag(New->getLocation(), diag::err_redefinition_different_type)
1248 << New->getDeclName();
1249 Diag(Old->getLocation(), diag::note_previous_definition);
1250 return New->setInvalidDecl();
1252 New->setType(MergedT);
1254 // C99 6.2.2p4: Check if we have a static decl followed by a non-static.
1255 if (New->getStorageClass() == VarDecl::Static &&
1256 (Old->getStorageClass() == VarDecl::None || Old->hasExternalStorage())) {
1257 Diag(New->getLocation(), diag::err_static_non_static) << New->getDeclName();
1258 Diag(Old->getLocation(), diag::note_previous_definition);
1259 return New->setInvalidDecl();
1262 // For an identifier declared with the storage-class specifier
1263 // extern in a scope in which a prior declaration of that
1264 // identifier is visible,23) if the prior declaration specifies
1265 // internal or external linkage, the linkage of the identifier at
1266 // the later declaration is the same as the linkage specified at
1267 // the prior declaration. If no prior declaration is visible, or
1268 // if the prior declaration specifies no linkage, then the
1269 // identifier has external linkage.
1270 if (New->hasExternalStorage() && Old->hasLinkage())
1272 else if (New->getStorageClass() != VarDecl::Static &&
1273 Old->getStorageClass() == VarDecl::Static) {
1274 Diag(New->getLocation(), diag::err_non_static_static) << New->getDeclName();
1275 Diag(Old->getLocation(), diag::note_previous_definition);
1276 return New->setInvalidDecl();
1279 // Variables with external linkage are analyzed in FinalizeDeclaratorGroup.
1281 // FIXME: The test for external storage here seems wrong? We still
1282 // need to check for mismatches.
1283 if (!New->hasExternalStorage() && !New->isFileVarDecl() &&
1284 // Don't complain about out-of-line definitions of static members.
1285 !(Old->getLexicalDeclContext()->isRecord() &&
1286 !New->getLexicalDeclContext()->isRecord())) {
1287 Diag(New->getLocation(), diag::err_redefinition) << New->getDeclName();
1288 Diag(Old->getLocation(), diag::note_previous_definition);
1289 return New->setInvalidDecl();
1292 if (New->isThreadSpecified() && !Old->isThreadSpecified()) {
1293 Diag(New->getLocation(), diag::err_thread_non_thread) << New->getDeclName();
1294 Diag(Old->getLocation(), diag::note_previous_definition);
1295 } else if (!New->isThreadSpecified() && Old->isThreadSpecified()) {
1296 Diag(New->getLocation(), diag::err_non_thread_thread) << New->getDeclName();
1297 Diag(Old->getLocation(), diag::note_previous_definition);
1300 // Keep a chain of previous declarations.
1301 New->setPreviousDeclaration(Old);
1303 // Inherit access appropriately.
1304 New->setAccess(Old->getAccess());
1307 /// ParsedFreeStandingDeclSpec - This method is invoked when a declspec with
1308 /// no declarator (e.g. "struct foo;") is parsed.
1309 Sema::DeclPtrTy Sema::ParsedFreeStandingDeclSpec(Scope *S, DeclSpec &DS) {
1310 // FIXME: Error on auto/register at file scope
1311 // FIXME: Error on inline/virtual/explicit
1312 // FIXME: Warn on useless __thread
1313 // FIXME: Warn on useless const/volatile
1314 // FIXME: Warn on useless static/extern/typedef/private_extern/mutable
1315 // FIXME: Warn on useless attributes
1318 if (DS.getTypeSpecType() == DeclSpec::TST_class ||
1319 DS.getTypeSpecType() == DeclSpec::TST_struct ||
1320 DS.getTypeSpecType() == DeclSpec::TST_union ||
1321 DS.getTypeSpecType() == DeclSpec::TST_enum) {
1322 TagD = static_cast<Decl *>(DS.getTypeRep());
1324 if (!TagD) // We probably had an error
1327 // Note that the above type specs guarantee that the
1328 // type rep is a Decl, whereas in many of the others
1330 Tag = dyn_cast<TagDecl>(TagD);
1333 if (unsigned TypeQuals = DS.getTypeQualifiers()) {
1334 // Enforce C99 6.7.3p2: "Types other than pointer types derived from object
1335 // or incomplete types shall not be restrict-qualified."
1336 if (TypeQuals & DeclSpec::TQ_restrict)
1337 Diag(DS.getRestrictSpecLoc(),
1338 diag::err_typecheck_invalid_restrict_not_pointer_noarg)
1339 << DS.getSourceRange();
1342 if (DS.isFriendSpecified()) {
1343 // If we're dealing with a class template decl, assume that the
1344 // template routines are handling it.
1345 if (TagD && isa<ClassTemplateDecl>(TagD))
1347 return ActOnFriendTypeDecl(S, DS, MultiTemplateParamsArg(*this, 0, 0));
1350 if (RecordDecl *Record = dyn_cast_or_null<RecordDecl>(Tag)) {
1351 // If there are attributes in the DeclSpec, apply them to the record.
1352 if (const AttributeList *AL = DS.getAttributes())
1353 ProcessDeclAttributeList(S, Record, AL);
1355 if (!Record->getDeclName() && Record->isDefinition() &&
1356 DS.getStorageClassSpec() != DeclSpec::SCS_typedef) {
1357 if (getLangOptions().CPlusPlus ||
1358 Record->getDeclContext()->isRecord())
1359 return BuildAnonymousStructOrUnion(S, DS, Record);
1361 Diag(DS.getSourceRange().getBegin(), diag::err_no_declarators)
1362 << DS.getSourceRange();
1365 // Microsoft allows unnamed struct/union fields. Don't complain
1367 // FIXME: Should we support Microsoft's extensions in this area?
1368 if (Record->getDeclName() && getLangOptions().Microsoft)
1369 return DeclPtrTy::make(Tag);
1372 if (!DS.isMissingDeclaratorOk() &&
1373 DS.getTypeSpecType() != DeclSpec::TST_error) {
1374 // Warn about typedefs of enums without names, since this is an
1375 // extension in both Microsoft an GNU.
1376 if (DS.getStorageClassSpec() == DeclSpec::SCS_typedef &&
1377 Tag && isa<EnumDecl>(Tag)) {
1378 Diag(DS.getSourceRange().getBegin(), diag::ext_typedef_without_a_name)
1379 << DS.getSourceRange();
1380 return DeclPtrTy::make(Tag);
1383 Diag(DS.getSourceRange().getBegin(), diag::err_no_declarators)
1384 << DS.getSourceRange();
1388 return DeclPtrTy::make(Tag);
1391 /// We are trying to inject an anonymous member into the given scope;
1392 /// check if there's an existing declaration that can't be overloaded.
1394 /// \return true if this is a forbidden redeclaration
1395 static bool CheckAnonMemberRedeclaration(Sema &SemaRef,
1398 DeclarationName Name,
1399 SourceLocation NameLoc,
1400 unsigned diagnostic) {
1401 LookupResult R(SemaRef, Name, NameLoc, Sema::LookupMemberName,
1402 Sema::ForRedeclaration);
1403 if (!SemaRef.LookupName(R, S)) return false;
1405 if (R.getAsSingle<TagDecl>())
1408 // Pick a representative declaration.
1409 NamedDecl *PrevDecl = R.getRepresentativeDecl()->getUnderlyingDecl();
1410 if (PrevDecl && Owner->isRecord()) {
1411 RecordDecl *Record = cast<RecordDecl>(Owner);
1412 if (!SemaRef.isDeclInScope(PrevDecl, Record, S))
1416 SemaRef.Diag(NameLoc, diagnostic) << Name;
1417 SemaRef.Diag(PrevDecl->getLocation(), diag::note_previous_declaration);
1422 /// InjectAnonymousStructOrUnionMembers - Inject the members of the
1423 /// anonymous struct or union AnonRecord into the owning context Owner
1424 /// and scope S. This routine will be invoked just after we realize
1425 /// that an unnamed union or struct is actually an anonymous union or
1432 /// }; // InjectAnonymousStructOrUnionMembers called here to inject i and
1433 /// // f into the surrounding scope.x
1436 /// This routine is recursive, injecting the names of nested anonymous
1437 /// structs/unions into the owning context and scope as well.
1438 bool Sema::InjectAnonymousStructOrUnionMembers(Scope *S, DeclContext *Owner,
1439 RecordDecl *AnonRecord) {
1441 = AnonRecord->isUnion() ? diag::err_anonymous_union_member_redecl
1442 : diag::err_anonymous_struct_member_redecl;
1444 bool Invalid = false;
1445 for (RecordDecl::field_iterator F = AnonRecord->field_begin(),
1446 FEnd = AnonRecord->field_end();
1448 if ((*F)->getDeclName()) {
1449 if (CheckAnonMemberRedeclaration(*this, S, Owner, (*F)->getDeclName(),
1450 (*F)->getLocation(), diagKind)) {
1451 // C++ [class.union]p2:
1452 // The names of the members of an anonymous union shall be
1453 // distinct from the names of any other entity in the
1454 // scope in which the anonymous union is declared.
1457 // C++ [class.union]p2:
1458 // For the purpose of name lookup, after the anonymous union
1459 // definition, the members of the anonymous union are
1460 // considered to have been defined in the scope in which the
1461 // anonymous union is declared.
1462 Owner->makeDeclVisibleInContext(*F);
1463 S->AddDecl(DeclPtrTy::make(*F));
1464 IdResolver.AddDecl(*F);
1466 } else if (const RecordType *InnerRecordType
1467 = (*F)->getType()->getAs<RecordType>()) {
1468 RecordDecl *InnerRecord = InnerRecordType->getDecl();
1469 if (InnerRecord->isAnonymousStructOrUnion())
1470 Invalid = Invalid ||
1471 InjectAnonymousStructOrUnionMembers(S, Owner, InnerRecord);
1478 /// ActOnAnonymousStructOrUnion - Handle the declaration of an
1479 /// anonymous structure or union. Anonymous unions are a C++ feature
1480 /// (C++ [class.union]) and a GNU C extension; anonymous structures
1481 /// are a GNU C and GNU C++ extension.
1482 Sema::DeclPtrTy Sema::BuildAnonymousStructOrUnion(Scope *S, DeclSpec &DS,
1483 RecordDecl *Record) {
1484 DeclContext *Owner = Record->getDeclContext();
1486 // Diagnose whether this anonymous struct/union is an extension.
1487 if (Record->isUnion() && !getLangOptions().CPlusPlus)
1488 Diag(Record->getLocation(), diag::ext_anonymous_union);
1489 else if (!Record->isUnion())
1490 Diag(Record->getLocation(), diag::ext_anonymous_struct);
1492 // C and C++ require different kinds of checks for anonymous
1494 bool Invalid = false;
1495 if (getLangOptions().CPlusPlus) {
1496 const char* PrevSpec = 0;
1498 // C++ [class.union]p3:
1499 // Anonymous unions declared in a named namespace or in the
1500 // global namespace shall be declared static.
1501 if (DS.getStorageClassSpec() != DeclSpec::SCS_static &&
1502 (isa<TranslationUnitDecl>(Owner) ||
1503 (isa<NamespaceDecl>(Owner) &&
1504 cast<NamespaceDecl>(Owner)->getDeclName()))) {
1505 Diag(Record->getLocation(), diag::err_anonymous_union_not_static);
1508 // Recover by adding 'static'.
1509 DS.SetStorageClassSpec(DeclSpec::SCS_static, SourceLocation(),
1512 // C++ [class.union]p3:
1513 // A storage class is not allowed in a declaration of an
1514 // anonymous union in a class scope.
1515 else if (DS.getStorageClassSpec() != DeclSpec::SCS_unspecified &&
1516 isa<RecordDecl>(Owner)) {
1517 Diag(DS.getStorageClassSpecLoc(),
1518 diag::err_anonymous_union_with_storage_spec);
1521 // Recover by removing the storage specifier.
1522 DS.SetStorageClassSpec(DeclSpec::SCS_unspecified, SourceLocation(),
1526 // C++ [class.union]p2:
1527 // The member-specification of an anonymous union shall only
1528 // define non-static data members. [Note: nested types and
1529 // functions cannot be declared within an anonymous union. ]
1530 for (DeclContext::decl_iterator Mem = Record->decls_begin(),
1531 MemEnd = Record->decls_end();
1532 Mem != MemEnd; ++Mem) {
1533 if (FieldDecl *FD = dyn_cast<FieldDecl>(*Mem)) {
1534 // C++ [class.union]p3:
1535 // An anonymous union shall not have private or protected
1536 // members (clause 11).
1537 if (FD->getAccess() == AS_protected || FD->getAccess() == AS_private) {
1538 Diag(FD->getLocation(), diag::err_anonymous_record_nonpublic_member)
1539 << (int)Record->isUnion() << (int)(FD->getAccess() == AS_protected);
1542 } else if ((*Mem)->isImplicit()) {
1543 // Any implicit members are fine.
1544 } else if (isa<TagDecl>(*Mem) && (*Mem)->getDeclContext() != Record) {
1545 // This is a type that showed up in an
1546 // elaborated-type-specifier inside the anonymous struct or
1547 // union, but which actually declares a type outside of the
1548 // anonymous struct or union. It's okay.
1549 } else if (RecordDecl *MemRecord = dyn_cast<RecordDecl>(*Mem)) {
1550 if (!MemRecord->isAnonymousStructOrUnion() &&
1551 MemRecord->getDeclName()) {
1552 // This is a nested type declaration.
1553 Diag(MemRecord->getLocation(), diag::err_anonymous_record_with_type)
1554 << (int)Record->isUnion();
1558 // We have something that isn't a non-static data
1559 // member. Complain about it.
1560 unsigned DK = diag::err_anonymous_record_bad_member;
1561 if (isa<TypeDecl>(*Mem))
1562 DK = diag::err_anonymous_record_with_type;
1563 else if (isa<FunctionDecl>(*Mem))
1564 DK = diag::err_anonymous_record_with_function;
1565 else if (isa<VarDecl>(*Mem))
1566 DK = diag::err_anonymous_record_with_static;
1567 Diag((*Mem)->getLocation(), DK)
1568 << (int)Record->isUnion();
1574 if (!Record->isUnion() && !Owner->isRecord()) {
1575 Diag(Record->getLocation(), diag::err_anonymous_struct_not_member)
1576 << (int)getLangOptions().CPlusPlus;
1580 // Mock up a declarator.
1581 Declarator Dc(DS, Declarator::TypeNameContext);
1582 TypeSourceInfo *TInfo = 0;
1583 GetTypeForDeclarator(Dc, S, &TInfo);
1584 assert(TInfo && "couldn't build declarator info for anonymous struct/union");
1586 // Create a declaration for this anonymous struct/union.
1587 NamedDecl *Anon = 0;
1588 if (RecordDecl *OwningClass = dyn_cast<RecordDecl>(Owner)) {
1589 Anon = FieldDecl::Create(Context, OwningClass, Record->getLocation(),
1590 /*IdentifierInfo=*/0,
1591 Context.getTypeDeclType(Record),
1593 /*BitWidth=*/0, /*Mutable=*/false);
1594 Anon->setAccess(AS_public);
1595 if (getLangOptions().CPlusPlus)
1596 FieldCollector->Add(cast<FieldDecl>(Anon));
1598 VarDecl::StorageClass SC;
1599 switch (DS.getStorageClassSpec()) {
1600 default: assert(0 && "Unknown storage class!");
1601 case DeclSpec::SCS_unspecified: SC = VarDecl::None; break;
1602 case DeclSpec::SCS_extern: SC = VarDecl::Extern; break;
1603 case DeclSpec::SCS_static: SC = VarDecl::Static; break;
1604 case DeclSpec::SCS_auto: SC = VarDecl::Auto; break;
1605 case DeclSpec::SCS_register: SC = VarDecl::Register; break;
1606 case DeclSpec::SCS_private_extern: SC = VarDecl::PrivateExtern; break;
1607 case DeclSpec::SCS_mutable:
1608 // mutable can only appear on non-static class members, so it's always
1610 Diag(Record->getLocation(), diag::err_mutable_nonmember);
1616 Anon = VarDecl::Create(Context, Owner, Record->getLocation(),
1617 /*IdentifierInfo=*/0,
1618 Context.getTypeDeclType(Record),
1622 Anon->setImplicit();
1624 // Add the anonymous struct/union object to the current
1625 // context. We'll be referencing this object when we refer to one of
1627 Owner->addDecl(Anon);
1629 // Inject the members of the anonymous struct/union into the owning
1630 // context and into the identifier resolver chain for name lookup
1632 if (InjectAnonymousStructOrUnionMembers(S, Owner, Record))
1635 // Mark this as an anonymous struct/union type. Note that we do not
1636 // do this until after we have already checked and injected the
1637 // members of this anonymous struct/union type, because otherwise
1638 // the members could be injected twice: once by DeclContext when it
1639 // builds its lookup table, and once by
1640 // InjectAnonymousStructOrUnionMembers.
1641 Record->setAnonymousStructOrUnion(true);
1644 Anon->setInvalidDecl();
1646 return DeclPtrTy::make(Anon);
1650 /// GetNameForDeclarator - Determine the full declaration name for the
1651 /// given Declarator.
1652 DeclarationName Sema::GetNameForDeclarator(Declarator &D) {
1653 return GetNameFromUnqualifiedId(D.getName());
1656 /// \brief Retrieves the canonicalized name from a parsed unqualified-id.
1657 DeclarationName Sema::GetNameFromUnqualifiedId(const UnqualifiedId &Name) {
1658 switch (Name.getKind()) {
1659 case UnqualifiedId::IK_Identifier:
1660 return DeclarationName(Name.Identifier);
1662 case UnqualifiedId::IK_OperatorFunctionId:
1663 return Context.DeclarationNames.getCXXOperatorName(
1664 Name.OperatorFunctionId.Operator);
1666 case UnqualifiedId::IK_LiteralOperatorId:
1667 return Context.DeclarationNames.getCXXLiteralOperatorName(
1670 case UnqualifiedId::IK_ConversionFunctionId: {
1671 QualType Ty = GetTypeFromParser(Name.ConversionFunctionId);
1673 return DeclarationName();
1675 return Context.DeclarationNames.getCXXConversionFunctionName(
1676 Context.getCanonicalType(Ty));
1679 case UnqualifiedId::IK_ConstructorName: {
1680 QualType Ty = GetTypeFromParser(Name.ConstructorName);
1682 return DeclarationName();
1684 return Context.DeclarationNames.getCXXConstructorName(
1685 Context.getCanonicalType(Ty));
1688 case UnqualifiedId::IK_ConstructorTemplateId: {
1689 // In well-formed code, we can only have a constructor
1690 // template-id that refers to the current context, so go there
1691 // to find the actual type being constructed.
1692 CXXRecordDecl *CurClass = dyn_cast<CXXRecordDecl>(CurContext);
1693 if (!CurClass || CurClass->getIdentifier() != Name.TemplateId->Name)
1694 return DeclarationName();
1696 // Determine the type of the class being constructed.
1697 QualType CurClassType;
1698 if (ClassTemplateDecl *ClassTemplate
1699 = CurClass->getDescribedClassTemplate())
1700 CurClassType = ClassTemplate->getInjectedClassNameType(Context);
1702 CurClassType = Context.getTypeDeclType(CurClass);
1704 // FIXME: Check two things: that the template-id names the same type as
1705 // CurClassType, and that the template-id does not occur when the name
1708 return Context.DeclarationNames.getCXXConstructorName(
1709 Context.getCanonicalType(CurClassType));
1712 case UnqualifiedId::IK_DestructorName: {
1713 QualType Ty = GetTypeFromParser(Name.DestructorName);
1715 return DeclarationName();
1717 return Context.DeclarationNames.getCXXDestructorName(
1718 Context.getCanonicalType(Ty));
1721 case UnqualifiedId::IK_TemplateId: {
1723 = TemplateName::getFromVoidPointer(Name.TemplateId->Template);
1724 return Context.getNameForTemplate(TName);
1728 assert(false && "Unknown name kind");
1729 return DeclarationName();
1732 /// isNearlyMatchingFunction - Determine whether the C++ functions
1733 /// Declaration and Definition are "nearly" matching. This heuristic
1734 /// is used to improve diagnostics in the case where an out-of-line
1735 /// function definition doesn't match any declaration within
1736 /// the class or namespace.
1737 static bool isNearlyMatchingFunction(ASTContext &Context,
1738 FunctionDecl *Declaration,
1739 FunctionDecl *Definition) {
1740 if (Declaration->param_size() != Definition->param_size())
1742 for (unsigned Idx = 0; Idx < Declaration->param_size(); ++Idx) {
1743 QualType DeclParamTy = Declaration->getParamDecl(Idx)->getType();
1744 QualType DefParamTy = Definition->getParamDecl(Idx)->getType();
1746 if (!Context.hasSameUnqualifiedType(DeclParamTy.getNonReferenceType(),
1747 DefParamTy.getNonReferenceType()))
1755 Sema::HandleDeclarator(Scope *S, Declarator &D,
1756 MultiTemplateParamsArg TemplateParamLists,
1757 bool IsFunctionDefinition) {
1758 DeclarationName Name = GetNameForDeclarator(D);
1760 // All of these full declarators require an identifier. If it doesn't have
1761 // one, the ParsedFreeStandingDeclSpec action should be used.
1763 if (!D.isInvalidType()) // Reject this if we think it is valid.
1764 Diag(D.getDeclSpec().getSourceRange().getBegin(),
1765 diag::err_declarator_need_ident)
1766 << D.getDeclSpec().getSourceRange() << D.getSourceRange();
1770 // The scope passed in may not be a decl scope. Zip up the scope tree until
1771 // we find one that is.
1772 while ((S->getFlags() & Scope::DeclScope) == 0 ||
1773 (S->getFlags() & Scope::TemplateParamScope) != 0)
1776 // If this is an out-of-line definition of a member of a class template
1777 // or class template partial specialization, we may need to rebuild the
1778 // type specifier in the declarator. See RebuildTypeInCurrentInstantiation()
1779 // for more information.
1780 // FIXME: cope with decltype(expr) and typeof(expr) once the rebuilder can
1781 // handle expressions properly.
1782 DeclSpec &DS = const_cast<DeclSpec&>(D.getDeclSpec());
1783 if (D.getCXXScopeSpec().isSet() && !D.getCXXScopeSpec().isInvalid() &&
1784 isDependentScopeSpecifier(D.getCXXScopeSpec()) &&
1785 (DS.getTypeSpecType() == DeclSpec::TST_typename ||
1786 DS.getTypeSpecType() == DeclSpec::TST_typeofType ||
1787 DS.getTypeSpecType() == DeclSpec::TST_typeofExpr ||
1788 DS.getTypeSpecType() == DeclSpec::TST_decltype)) {
1789 if (DeclContext *DC = computeDeclContext(D.getCXXScopeSpec(), true)) {
1790 // FIXME: Preserve type source info.
1791 QualType T = GetTypeFromParser(DS.getTypeRep());
1793 DeclContext *SavedContext = CurContext;
1795 T = RebuildTypeInCurrentInstantiation(T, D.getIdentifierLoc(), Name);
1796 CurContext = SavedContext;
1800 DS.UpdateTypeRep(T.getAsOpaquePtr());
1807 TypeSourceInfo *TInfo = 0;
1808 QualType R = GetTypeForDeclarator(D, S, &TInfo);
1810 LookupResult Previous(*this, Name, D.getIdentifierLoc(), LookupOrdinaryName,
1813 // See if this is a redefinition of a variable in the same scope.
1814 if (D.getCXXScopeSpec().isInvalid()) {
1817 } else if (!D.getCXXScopeSpec().isSet()) {
1818 bool IsLinkageLookup = false;
1820 // If the declaration we're planning to build will be a function
1821 // or object with linkage, then look for another declaration with
1822 // linkage (C99 6.2.2p4-5 and C++ [basic.link]p6).
1823 if (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_typedef)
1825 else if (R->isFunctionType()) {
1826 if (CurContext->isFunctionOrMethod() ||
1827 D.getDeclSpec().getStorageClassSpec() != DeclSpec::SCS_static)
1828 IsLinkageLookup = true;
1829 } else if (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_extern)
1830 IsLinkageLookup = true;
1831 else if (CurContext->getLookupContext()->isTranslationUnit() &&
1832 D.getDeclSpec().getStorageClassSpec() != DeclSpec::SCS_static)
1833 IsLinkageLookup = true;
1835 if (IsLinkageLookup)
1836 Previous.clear(LookupRedeclarationWithLinkage);
1839 LookupName(Previous, S, /* CreateBuiltins = */ IsLinkageLookup);
1840 } else { // Something like "int foo::x;"
1841 DC = computeDeclContext(D.getCXXScopeSpec(), true);
1844 // If we could not compute the declaration context, it's because the
1845 // declaration context is dependent but does not refer to a class,
1846 // class template, or class template partial specialization. Complain
1847 // and return early, to avoid the coming semantic disaster.
1848 Diag(D.getIdentifierLoc(),
1849 diag::err_template_qualified_declarator_no_match)
1850 << (NestedNameSpecifier*)D.getCXXScopeSpec().getScopeRep()
1851 << D.getCXXScopeSpec().getRange();
1855 if (!DC->isDependentContext() &&
1856 RequireCompleteDeclContext(D.getCXXScopeSpec()))
1859 LookupQualifiedName(Previous, DC);
1861 // Don't consider using declarations as previous declarations for
1862 // out-of-line members.
1863 RemoveUsingDecls(Previous);
1866 // Members (including explicit specializations of templates) of a named
1867 // namespace can also be defined outside that namespace by explicit
1868 // qualification of the name being defined, provided that the entity being
1869 // defined was already declared in the namespace and the definition appears
1870 // after the point of declaration in a namespace that encloses the
1871 // declarations namespace.
1873 // Note that we only check the context at this point. We don't yet
1874 // have enough information to make sure that PrevDecl is actually
1875 // the declaration we want to match. For example, given:
1882 // void X::f(int) { } // ill-formed
1884 // In this case, PrevDecl will point to the overload set
1885 // containing the two f's declared in X, but neither of them
1888 // First check whether we named the global scope.
1889 if (isa<TranslationUnitDecl>(DC)) {
1890 Diag(D.getIdentifierLoc(), diag::err_invalid_declarator_global_scope)
1891 << Name << D.getCXXScopeSpec().getRange();
1893 DeclContext *Cur = CurContext;
1894 while (isa<LinkageSpecDecl>(Cur))
1895 Cur = Cur->getParent();
1896 if (!Cur->Encloses(DC)) {
1897 // The qualifying scope doesn't enclose the original declaration.
1898 // Emit diagnostic based on current scope.
1899 SourceLocation L = D.getIdentifierLoc();
1900 SourceRange R = D.getCXXScopeSpec().getRange();
1901 if (isa<FunctionDecl>(Cur))
1902 Diag(L, diag::err_invalid_declarator_in_function) << Name << R;
1904 Diag(L, diag::err_invalid_declarator_scope)
1905 << Name << cast<NamedDecl>(DC) << R;
1911 if (Previous.isSingleResult() &&
1912 Previous.getFoundDecl()->isTemplateParameter()) {
1913 // Maybe we will complain about the shadowed template parameter.
1914 if (!D.isInvalidType())
1915 if (DiagnoseTemplateParameterShadow(D.getIdentifierLoc(),
1916 Previous.getFoundDecl()))
1919 // Just pretend that we didn't see the previous declaration.
1923 // In C++, the previous declaration we find might be a tag type
1924 // (class or enum). In this case, the new declaration will hide the
1925 // tag type. Note that this does does not apply if we're declaring a
1926 // typedef (C++ [dcl.typedef]p4).
1927 if (Previous.isSingleTagDecl() &&
1928 D.getDeclSpec().getStorageClassSpec() != DeclSpec::SCS_typedef)
1931 bool Redeclaration = false;
1932 if (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_typedef) {
1933 if (TemplateParamLists.size()) {
1934 Diag(D.getIdentifierLoc(), diag::err_template_typedef);
1938 New = ActOnTypedefDeclarator(S, D, DC, R, TInfo, Previous, Redeclaration);
1939 } else if (R->isFunctionType()) {
1940 New = ActOnFunctionDeclarator(S, D, DC, R, TInfo, Previous,
1941 move(TemplateParamLists),
1942 IsFunctionDefinition, Redeclaration);
1944 New = ActOnVariableDeclarator(S, D, DC, R, TInfo, Previous,
1945 move(TemplateParamLists),
1952 // If this has an identifier and is not an invalid redeclaration or
1953 // function template specialization, add it to the scope stack.
1954 if (Name && !(Redeclaration && New->isInvalidDecl()))
1955 PushOnScopeChains(New, S);
1957 return DeclPtrTy::make(New);
1960 /// TryToFixInvalidVariablyModifiedType - Helper method to turn variable array
1961 /// types into constant array types in certain situations which would otherwise
1962 /// be errors (for GCC compatibility).
1963 static QualType TryToFixInvalidVariablyModifiedType(QualType T,
1964 ASTContext &Context,
1965 bool &SizeIsNegative) {
1966 // This method tries to turn a variable array into a constant
1967 // array even when the size isn't an ICE. This is necessary
1968 // for compatibility with code that depends on gcc's buggy
1969 // constant expression folding, like struct {char x[(int)(char*)2];}
1970 SizeIsNegative = false;
1972 QualifierCollector Qs;
1973 const Type *Ty = Qs.strip(T);
1975 if (const PointerType* PTy = dyn_cast<PointerType>(Ty)) {
1976 QualType Pointee = PTy->getPointeeType();
1977 QualType FixedType =
1978 TryToFixInvalidVariablyModifiedType(Pointee, Context, SizeIsNegative);
1979 if (FixedType.isNull()) return FixedType;
1980 FixedType = Context.getPointerType(FixedType);
1981 return Qs.apply(FixedType);
1984 const VariableArrayType* VLATy = dyn_cast<VariableArrayType>(T);
1987 // FIXME: We should probably handle this case
1988 if (VLATy->getElementType()->isVariablyModifiedType())
1991 Expr::EvalResult EvalResult;
1992 if (!VLATy->getSizeExpr() ||
1993 !VLATy->getSizeExpr()->Evaluate(EvalResult, Context) ||
1994 !EvalResult.Val.isInt())
1997 llvm::APSInt &Res = EvalResult.Val.getInt();
1998 if (Res >= llvm::APSInt(Res.getBitWidth(), Res.isUnsigned())) {
1999 // TODO: preserve the size expression in declarator info
2000 return Context.getConstantArrayType(VLATy->getElementType(),
2001 Res, ArrayType::Normal, 0);
2004 SizeIsNegative = true;
2008 /// \brief Register the given locally-scoped external C declaration so
2009 /// that it can be found later for redeclarations
2011 Sema::RegisterLocallyScopedExternCDecl(NamedDecl *ND,
2012 const LookupResult &Previous,
2014 assert(ND->getLexicalDeclContext()->isFunctionOrMethod() &&
2015 "Decl is not a locally-scoped decl!");
2016 // Note that we have a locally-scoped external with this name.
2017 LocallyScopedExternalDecls[ND->getDeclName()] = ND;
2019 if (!Previous.isSingleResult())
2022 NamedDecl *PrevDecl = Previous.getFoundDecl();
2024 // If there was a previous declaration of this variable, it may be
2025 // in our identifier chain. Update the identifier chain with the new
2027 if (S && IdResolver.ReplaceDecl(PrevDecl, ND)) {
2028 // The previous declaration was found on the identifer resolver
2029 // chain, so remove it from its scope.
2030 while (S && !S->isDeclScope(DeclPtrTy::make(PrevDecl)))
2034 S->RemoveDecl(DeclPtrTy::make(PrevDecl));
2038 /// \brief Diagnose function specifiers on a declaration of an identifier that
2039 /// does not identify a function.
2040 void Sema::DiagnoseFunctionSpecifiers(Declarator& D) {
2041 // FIXME: We should probably indicate the identifier in question to avoid
2042 // confusion for constructs like "inline int a(), b;"
2043 if (D.getDeclSpec().isInlineSpecified())
2044 Diag(D.getDeclSpec().getInlineSpecLoc(),
2045 diag::err_inline_non_function);
2047 if (D.getDeclSpec().isVirtualSpecified())
2048 Diag(D.getDeclSpec().getVirtualSpecLoc(),
2049 diag::err_virtual_non_function);
2051 if (D.getDeclSpec().isExplicitSpecified())
2052 Diag(D.getDeclSpec().getExplicitSpecLoc(),
2053 diag::err_explicit_non_function);
2057 Sema::ActOnTypedefDeclarator(Scope* S, Declarator& D, DeclContext* DC,
2058 QualType R, TypeSourceInfo *TInfo,
2059 LookupResult &Previous, bool &Redeclaration) {
2060 // Typedef declarators cannot be qualified (C++ [dcl.meaning]p1).
2061 if (D.getCXXScopeSpec().isSet()) {
2062 Diag(D.getIdentifierLoc(), diag::err_qualified_typedef_declarator)
2063 << D.getCXXScopeSpec().getRange();
2065 // Pretend we didn't see the scope specifier.
2069 if (getLangOptions().CPlusPlus) {
2070 // Check that there are no default arguments (C++ only).
2071 CheckExtraCXXDefaultArguments(D);
2074 DiagnoseFunctionSpecifiers(D);
2076 if (D.getDeclSpec().isThreadSpecified())
2077 Diag(D.getDeclSpec().getThreadSpecLoc(), diag::err_invalid_thread);
2079 TypedefDecl *NewTD = ParseTypedefDecl(S, D, R, TInfo);
2080 if (!NewTD) return 0;
2082 // Handle attributes prior to checking for duplicates in MergeVarDecl
2083 ProcessDeclAttributes(S, NewTD, D);
2085 // Merge the decl with the existing one if appropriate. If the decl is
2086 // in an outer scope, it isn't the same thing.
2087 FilterLookupForScope(*this, Previous, DC, S, /*ConsiderLinkage*/ false);
2088 if (!Previous.empty()) {
2089 Redeclaration = true;
2090 MergeTypeDefDecl(NewTD, Previous);
2093 // C99 6.7.7p2: If a typedef name specifies a variably modified type
2094 // then it shall have block scope.
2095 QualType T = NewTD->getUnderlyingType();
2096 if (T->isVariablyModifiedType()) {
2097 CurFunctionNeedsScopeChecking = true;
2099 if (S->getFnParent() == 0) {
2100 bool SizeIsNegative;
2102 TryToFixInvalidVariablyModifiedType(T, Context, SizeIsNegative);
2103 if (!FixedTy.isNull()) {
2104 Diag(D.getIdentifierLoc(), diag::warn_illegal_constant_array_size);
2105 NewTD->setTypeSourceInfo(Context.getTrivialTypeSourceInfo(FixedTy));
2108 Diag(D.getIdentifierLoc(), diag::err_typecheck_negative_array_size);
2109 else if (T->isVariableArrayType())
2110 Diag(D.getIdentifierLoc(), diag::err_vla_decl_in_file_scope);
2112 Diag(D.getIdentifierLoc(), diag::err_vm_decl_in_file_scope);
2113 NewTD->setInvalidDecl();
2118 // If this is the C FILE type, notify the AST context.
2119 if (IdentifierInfo *II = NewTD->getIdentifier())
2120 if (!NewTD->isInvalidDecl() &&
2121 NewTD->getDeclContext()->getLookupContext()->isTranslationUnit()) {
2122 if (II->isStr("FILE"))
2123 Context.setFILEDecl(NewTD);
2124 else if (II->isStr("jmp_buf"))
2125 Context.setjmp_bufDecl(NewTD);
2126 else if (II->isStr("sigjmp_buf"))
2127 Context.setsigjmp_bufDecl(NewTD);
2133 /// \brief Determines whether the given declaration is an out-of-scope
2134 /// previous declaration.
2136 /// This routine should be invoked when name lookup has found a
2137 /// previous declaration (PrevDecl) that is not in the scope where a
2138 /// new declaration by the same name is being introduced. If the new
2139 /// declaration occurs in a local scope, previous declarations with
2140 /// linkage may still be considered previous declarations (C99
2141 /// 6.2.2p4-5, C++ [basic.link]p6).
2143 /// \param PrevDecl the previous declaration found by name
2146 /// \param DC the context in which the new declaration is being
2149 /// \returns true if PrevDecl is an out-of-scope previous declaration
2150 /// for a new delcaration with the same name.
2152 isOutOfScopePreviousDeclaration(NamedDecl *PrevDecl, DeclContext *DC,
2153 ASTContext &Context) {
2157 if (!PrevDecl->hasLinkage())
2160 if (Context.getLangOptions().CPlusPlus) {
2161 // C++ [basic.link]p6:
2162 // If there is a visible declaration of an entity with linkage
2163 // having the same name and type, ignoring entities declared
2164 // outside the innermost enclosing namespace scope, the block
2165 // scope declaration declares that same entity and receives the
2166 // linkage of the previous declaration.
2167 DeclContext *OuterContext = DC->getLookupContext();
2168 if (!OuterContext->isFunctionOrMethod())
2169 // This rule only applies to block-scope declarations.
2172 DeclContext *PrevOuterContext = PrevDecl->getDeclContext();
2173 if (PrevOuterContext->isRecord())
2174 // We found a member function: ignore it.
2177 // Find the innermost enclosing namespace for the new and
2178 // previous declarations.
2179 while (!OuterContext->isFileContext())
2180 OuterContext = OuterContext->getParent();
2181 while (!PrevOuterContext->isFileContext())
2182 PrevOuterContext = PrevOuterContext->getParent();
2184 // The previous declaration is in a different namespace, so it
2185 // isn't the same function.
2186 if (OuterContext->getPrimaryContext() !=
2187 PrevOuterContext->getPrimaryContext())
2197 Sema::ActOnVariableDeclarator(Scope* S, Declarator& D, DeclContext* DC,
2198 QualType R, TypeSourceInfo *TInfo,
2199 LookupResult &Previous,
2200 MultiTemplateParamsArg TemplateParamLists,
2201 bool &Redeclaration) {
2202 DeclarationName Name = GetNameForDeclarator(D);
2204 // Check that there are no default arguments (C++ only).
2205 if (getLangOptions().CPlusPlus)
2206 CheckExtraCXXDefaultArguments(D);
2209 VarDecl::StorageClass SC;
2210 switch (D.getDeclSpec().getStorageClassSpec()) {
2211 default: assert(0 && "Unknown storage class!");
2212 case DeclSpec::SCS_unspecified: SC = VarDecl::None; break;
2213 case DeclSpec::SCS_extern: SC = VarDecl::Extern; break;
2214 case DeclSpec::SCS_static: SC = VarDecl::Static; break;
2215 case DeclSpec::SCS_auto: SC = VarDecl::Auto; break;
2216 case DeclSpec::SCS_register: SC = VarDecl::Register; break;
2217 case DeclSpec::SCS_private_extern: SC = VarDecl::PrivateExtern; break;
2218 case DeclSpec::SCS_mutable:
2219 // mutable can only appear on non-static class members, so it's always
2221 Diag(D.getIdentifierLoc(), diag::err_mutable_nonmember);
2227 IdentifierInfo *II = Name.getAsIdentifierInfo();
2229 Diag(D.getIdentifierLoc(), diag::err_bad_variable_name)
2230 << Name.getAsString();
2234 DiagnoseFunctionSpecifiers(D);
2236 if (!DC->isRecord() && S->getFnParent() == 0) {
2237 // C99 6.9p2: The storage-class specifiers auto and register shall not
2238 // appear in the declaration specifiers in an external declaration.
2239 if (SC == VarDecl::Auto || SC == VarDecl::Register) {
2241 // If this is a register variable with an asm label specified, then this
2242 // is a GNU extension.
2243 if (SC == VarDecl::Register && D.getAsmLabel())
2244 Diag(D.getIdentifierLoc(), diag::err_unsupported_global_register);
2246 Diag(D.getIdentifierLoc(), diag::err_typecheck_sclass_fscope);
2250 if (DC->isRecord() && !CurContext->isRecord()) {
2251 // This is an out-of-line definition of a static data member.
2252 if (SC == VarDecl::Static) {
2253 Diag(D.getDeclSpec().getStorageClassSpecLoc(),
2254 diag::err_static_out_of_line)
2255 << CodeModificationHint::CreateRemoval(
2256 D.getDeclSpec().getStorageClassSpecLoc());
2257 } else if (SC == VarDecl::None)
2258 SC = VarDecl::Static;
2260 if (SC == VarDecl::Static) {
2261 if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(DC)) {
2262 if (RD->isLocalClass())
2263 Diag(D.getIdentifierLoc(),
2264 diag::err_static_data_member_not_allowed_in_local_class)
2265 << Name << RD->getDeclName();
2269 // Match up the template parameter lists with the scope specifier, then
2270 // determine whether we have a template or a template specialization.
2271 bool isExplicitSpecialization = false;
2272 if (TemplateParameterList *TemplateParams
2273 = MatchTemplateParametersToScopeSpecifier(
2274 D.getDeclSpec().getSourceRange().getBegin(),
2275 D.getCXXScopeSpec(),
2276 (TemplateParameterList**)TemplateParamLists.get(),
2277 TemplateParamLists.size(),
2278 isExplicitSpecialization)) {
2279 if (TemplateParams->size() > 0) {
2280 // There is no such thing as a variable template.
2281 Diag(D.getIdentifierLoc(), diag::err_template_variable)
2283 << SourceRange(TemplateParams->getTemplateLoc(),
2284 TemplateParams->getRAngleLoc());
2287 // There is an extraneous 'template<>' for this variable. Complain
2288 // about it, but allow the declaration of the variable.
2289 Diag(TemplateParams->getTemplateLoc(),
2290 diag::err_template_variable_noparams)
2292 << SourceRange(TemplateParams->getTemplateLoc(),
2293 TemplateParams->getRAngleLoc());
2295 isExplicitSpecialization = true;
2299 NewVD = VarDecl::Create(Context, DC, D.getIdentifierLoc(),
2302 if (D.isInvalidType())
2303 NewVD->setInvalidDecl();
2305 if (D.getDeclSpec().isThreadSpecified()) {
2306 if (NewVD->hasLocalStorage())
2307 Diag(D.getDeclSpec().getThreadSpecLoc(), diag::err_thread_non_global);
2308 else if (!Context.Target.isTLSSupported())
2309 Diag(D.getDeclSpec().getThreadSpecLoc(), diag::err_thread_unsupported);
2311 NewVD->setThreadSpecified(true);
2314 // Set the lexical context. If the declarator has a C++ scope specifier, the
2315 // lexical context will be different from the semantic context.
2316 NewVD->setLexicalDeclContext(CurContext);
2318 // Handle attributes prior to checking for duplicates in MergeVarDecl
2319 ProcessDeclAttributes(S, NewVD, D);
2321 // Handle GNU asm-label extension (encoded as an attribute).
2322 if (Expr *E = (Expr*) D.getAsmLabel()) {
2323 // The parser guarantees this is a string.
2324 StringLiteral *SE = cast<StringLiteral>(E);
2325 NewVD->addAttr(::new (Context) AsmLabelAttr(SE->getString()));
2328 // Don't consider existing declarations that are in a different
2329 // scope and are out-of-semantic-context declarations (if the new
2330 // declaration has linkage).
2331 FilterLookupForScope(*this, Previous, DC, S, NewVD->hasLinkage());
2333 // Merge the decl with the existing one if appropriate.
2334 if (!Previous.empty()) {
2335 if (Previous.isSingleResult() &&
2336 isa<FieldDecl>(Previous.getFoundDecl()) &&
2337 D.getCXXScopeSpec().isSet()) {
2338 // The user tried to define a non-static data member
2339 // out-of-line (C++ [dcl.meaning]p1).
2340 Diag(NewVD->getLocation(), diag::err_nonstatic_member_out_of_line)
2341 << D.getCXXScopeSpec().getRange();
2343 NewVD->setInvalidDecl();
2345 } else if (D.getCXXScopeSpec().isSet()) {
2346 // No previous declaration in the qualifying scope.
2347 Diag(D.getIdentifierLoc(), diag::err_no_member)
2348 << Name << computeDeclContext(D.getCXXScopeSpec(), true)
2349 << D.getCXXScopeSpec().getRange();
2350 NewVD->setInvalidDecl();
2353 CheckVariableDeclaration(NewVD, Previous, Redeclaration);
2355 // This is an explicit specialization of a static data member. Check it.
2356 if (isExplicitSpecialization && !NewVD->isInvalidDecl() &&
2357 CheckMemberSpecialization(NewVD, Previous))
2358 NewVD->setInvalidDecl();
2360 // attributes declared post-definition are currently ignored
2361 if (Previous.isSingleResult()) {
2362 const VarDecl *Def = 0;
2363 VarDecl *PrevDecl = dyn_cast<VarDecl>(Previous.getFoundDecl());
2364 if (PrevDecl && PrevDecl->getDefinition(Def) && D.hasAttributes()) {
2365 Diag(NewVD->getLocation(), diag::warn_attribute_precede_definition);
2366 Diag(Def->getLocation(), diag::note_previous_definition);
2370 // If this is a locally-scoped extern C variable, update the map of
2372 if (CurContext->isFunctionOrMethod() && NewVD->isExternC() &&
2373 !NewVD->isInvalidDecl())
2374 RegisterLocallyScopedExternCDecl(NewVD, Previous, S);
2379 /// \brief Perform semantic checking on a newly-created variable
2382 /// This routine performs all of the type-checking required for a
2383 /// variable declaration once it has been built. It is used both to
2384 /// check variables after they have been parsed and their declarators
2385 /// have been translated into a declaration, and to check variables
2386 /// that have been instantiated from a template.
2388 /// Sets NewVD->isInvalidDecl() if an error was encountered.
2389 void Sema::CheckVariableDeclaration(VarDecl *NewVD,
2390 LookupResult &Previous,
2391 bool &Redeclaration) {
2392 // If the decl is already known invalid, don't check it.
2393 if (NewVD->isInvalidDecl())
2396 QualType T = NewVD->getType();
2398 if (T->isObjCInterfaceType()) {
2399 Diag(NewVD->getLocation(), diag::err_statically_allocated_object);
2400 return NewVD->setInvalidDecl();
2403 // Emit an error if an address space was applied to decl with local storage.
2404 // This includes arrays of objects with address space qualifiers, but not
2405 // automatic variables that point to other address spaces.
2406 // ISO/IEC TR 18037 S5.1.2
2407 if (NewVD->hasLocalStorage() && (T.getAddressSpace() != 0)) {
2408 Diag(NewVD->getLocation(), diag::err_as_qualified_auto_decl);
2409 return NewVD->setInvalidDecl();
2412 if (NewVD->hasLocalStorage() && T.isObjCGCWeak()
2413 && !NewVD->hasAttr<BlocksAttr>())
2414 Diag(NewVD->getLocation(), diag::warn_attribute_weak_on_local);
2416 bool isVM = T->isVariablyModifiedType();
2417 if (isVM || NewVD->hasAttr<CleanupAttr>() ||
2418 NewVD->hasAttr<BlocksAttr>())
2419 CurFunctionNeedsScopeChecking = true;
2421 if ((isVM && NewVD->hasLinkage()) ||
2422 (T->isVariableArrayType() && NewVD->hasGlobalStorage())) {
2423 bool SizeIsNegative;
2425 TryToFixInvalidVariablyModifiedType(T, Context, SizeIsNegative);
2427 if (FixedTy.isNull() && T->isVariableArrayType()) {
2428 const VariableArrayType *VAT = Context.getAsVariableArrayType(T);
2429 // FIXME: This won't give the correct result for
2431 SourceRange SizeRange = VAT->getSizeExpr()->getSourceRange();
2433 if (NewVD->isFileVarDecl())
2434 Diag(NewVD->getLocation(), diag::err_vla_decl_in_file_scope)
2436 else if (NewVD->getStorageClass() == VarDecl::Static)
2437 Diag(NewVD->getLocation(), diag::err_vla_decl_has_static_storage)
2440 Diag(NewVD->getLocation(), diag::err_vla_decl_has_extern_linkage)
2442 return NewVD->setInvalidDecl();
2445 if (FixedTy.isNull()) {
2446 if (NewVD->isFileVarDecl())
2447 Diag(NewVD->getLocation(), diag::err_vm_decl_in_file_scope);
2449 Diag(NewVD->getLocation(), diag::err_vm_decl_has_extern_linkage);
2450 return NewVD->setInvalidDecl();
2453 Diag(NewVD->getLocation(), diag::warn_illegal_constant_array_size);
2454 NewVD->setType(FixedTy);
2457 if (Previous.empty() && NewVD->isExternC()) {
2458 // Since we did not find anything by this name and we're declaring
2459 // an extern "C" variable, look for a non-visible extern "C"
2460 // declaration with the same name.
2461 llvm::DenseMap<DeclarationName, NamedDecl *>::iterator Pos
2462 = LocallyScopedExternalDecls.find(NewVD->getDeclName());
2463 if (Pos != LocallyScopedExternalDecls.end())
2464 Previous.addDecl(Pos->second);
2467 if (T->isVoidType() && !NewVD->hasExternalStorage()) {
2468 Diag(NewVD->getLocation(), diag::err_typecheck_decl_incomplete_type)
2470 return NewVD->setInvalidDecl();
2473 if (!NewVD->hasLocalStorage() && NewVD->hasAttr<BlocksAttr>()) {
2474 Diag(NewVD->getLocation(), diag::err_block_on_nonlocal);
2475 return NewVD->setInvalidDecl();
2478 if (isVM && NewVD->hasAttr<BlocksAttr>()) {
2479 Diag(NewVD->getLocation(), diag::err_block_on_vm);
2480 return NewVD->setInvalidDecl();
2483 if (!Previous.empty()) {
2484 Redeclaration = true;
2485 MergeVarDecl(NewVD, Previous);
2489 /// \brief Data used with FindOverriddenMethod
2490 struct FindOverriddenMethodData {
2492 CXXMethodDecl *Method;
2495 /// \brief Member lookup function that determines whether a given C++
2496 /// method overrides a method in a base class, to be used with
2497 /// CXXRecordDecl::lookupInBases().
2498 static bool FindOverriddenMethod(const CXXBaseSpecifier *Specifier,
2501 RecordDecl *BaseRecord = Specifier->getType()->getAs<RecordType>()->getDecl();
2503 FindOverriddenMethodData *Data
2504 = reinterpret_cast<FindOverriddenMethodData*>(UserData);
2506 DeclarationName Name = Data->Method->getDeclName();
2508 // FIXME: Do we care about other names here too?
2509 if (Name.getNameKind() == DeclarationName::CXXDestructorName) {
2510 // We really want to find the base class constructor here.
2511 QualType T = Data->S->Context.getTypeDeclType(BaseRecord);
2512 CanQualType CT = Data->S->Context.getCanonicalType(T);
2514 Name = Data->S->Context.DeclarationNames.getCXXDestructorName(CT);
2517 for (Path.Decls = BaseRecord->lookup(Name);
2518 Path.Decls.first != Path.Decls.second;
2519 ++Path.Decls.first) {
2520 if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(*Path.Decls.first)) {
2521 if (MD->isVirtual() && !Data->S->IsOverload(Data->Method, MD))
2529 /// AddOverriddenMethods - See if a method overrides any in the base classes,
2530 /// and if so, check that it's a valid override and remember it.
2531 void Sema::AddOverriddenMethods(CXXRecordDecl *DC, CXXMethodDecl *MD) {
2532 // Look for virtual methods in base classes that this method might override.
2534 FindOverriddenMethodData Data;
2537 if (DC->lookupInBases(&FindOverriddenMethod, &Data, Paths)) {
2538 for (CXXBasePaths::decl_iterator I = Paths.found_decls_begin(),
2539 E = Paths.found_decls_end(); I != E; ++I) {
2540 if (CXXMethodDecl *OldMD = dyn_cast<CXXMethodDecl>(*I)) {
2541 if (!CheckOverridingFunctionReturnType(MD, OldMD) &&
2542 !CheckOverridingFunctionExceptionSpec(MD, OldMD) &&
2543 !CheckOverridingFunctionAttributes(MD, OldMD))
2544 MD->addOverriddenMethod(OldMD->getCanonicalDecl());
2551 Sema::ActOnFunctionDeclarator(Scope* S, Declarator& D, DeclContext* DC,
2552 QualType R, TypeSourceInfo *TInfo,
2553 LookupResult &Previous,
2554 MultiTemplateParamsArg TemplateParamLists,
2555 bool IsFunctionDefinition, bool &Redeclaration) {
2556 assert(R.getTypePtr()->isFunctionType());
2558 DeclarationName Name = GetNameForDeclarator(D);
2559 FunctionDecl::StorageClass SC = FunctionDecl::None;
2560 switch (D.getDeclSpec().getStorageClassSpec()) {
2561 default: assert(0 && "Unknown storage class!");
2562 case DeclSpec::SCS_auto:
2563 case DeclSpec::SCS_register:
2564 case DeclSpec::SCS_mutable:
2565 Diag(D.getDeclSpec().getStorageClassSpecLoc(),
2566 diag::err_typecheck_sclass_func);
2569 case DeclSpec::SCS_unspecified: SC = FunctionDecl::None; break;
2570 case DeclSpec::SCS_extern: SC = FunctionDecl::Extern; break;
2571 case DeclSpec::SCS_static: {
2572 if (CurContext->getLookupContext()->isFunctionOrMethod()) {
2574 // The declaration of an identifier for a function that has
2575 // block scope shall have no explicit storage-class specifier
2576 // other than extern
2577 // See also (C++ [dcl.stc]p4).
2578 Diag(D.getDeclSpec().getStorageClassSpecLoc(),
2579 diag::err_static_block_func);
2580 SC = FunctionDecl::None;
2582 SC = FunctionDecl::Static;
2585 case DeclSpec::SCS_private_extern: SC = FunctionDecl::PrivateExtern;break;
2588 if (D.getDeclSpec().isThreadSpecified())
2589 Diag(D.getDeclSpec().getThreadSpecLoc(), diag::err_invalid_thread);
2591 bool isFriend = D.getDeclSpec().isFriendSpecified();
2592 bool isInline = D.getDeclSpec().isInlineSpecified();
2593 bool isVirtual = D.getDeclSpec().isVirtualSpecified();
2594 bool isExplicit = D.getDeclSpec().isExplicitSpecified();
2596 // Check that the return type is not an abstract class type.
2597 // For record types, this is done by the AbstractClassUsageDiagnoser once
2598 // the class has been completely parsed.
2599 if (!DC->isRecord() &&
2600 RequireNonAbstractType(D.getIdentifierLoc(),
2601 R->getAs<FunctionType>()->getResultType(),
2602 diag::err_abstract_type_in_decl,
2603 AbstractReturnType))
2606 // Do not allow returning a objc interface by-value.
2607 if (R->getAs<FunctionType>()->getResultType()->isObjCInterfaceType()) {
2608 Diag(D.getIdentifierLoc(),
2609 diag::err_object_cannot_be_passed_returned_by_value) << 0
2610 << R->getAs<FunctionType>()->getResultType();
2614 bool isVirtualOkay = false;
2615 FunctionDecl *NewFD;
2618 // C++ [class.friend]p5
2619 // A function can be defined in a friend declaration of a
2620 // class . . . . Such a function is implicitly inline.
2621 isInline |= IsFunctionDefinition;
2624 if (Name.getNameKind() == DeclarationName::CXXConstructorName) {
2625 // This is a C++ constructor declaration.
2626 assert(DC->isRecord() &&
2627 "Constructors can only be declared in a member context");
2629 R = CheckConstructorDeclarator(D, R, SC);
2631 // Create the new declaration
2632 NewFD = CXXConstructorDecl::Create(Context,
2633 cast<CXXRecordDecl>(DC),
2634 D.getIdentifierLoc(), Name, R, TInfo,
2635 isExplicit, isInline,
2636 /*isImplicitlyDeclared=*/false);
2637 } else if (Name.getNameKind() == DeclarationName::CXXDestructorName) {
2638 // This is a C++ destructor declaration.
2639 if (DC->isRecord()) {
2640 R = CheckDestructorDeclarator(D, SC);
2642 NewFD = CXXDestructorDecl::Create(Context,
2643 cast<CXXRecordDecl>(DC),
2644 D.getIdentifierLoc(), Name, R,
2646 /*isImplicitlyDeclared=*/false);
2648 isVirtualOkay = true;
2650 Diag(D.getIdentifierLoc(), diag::err_destructor_not_member);
2652 // Create a FunctionDecl to satisfy the function definition parsing
2654 NewFD = FunctionDecl::Create(Context, DC, D.getIdentifierLoc(),
2655 Name, R, TInfo, SC, isInline,
2656 /*hasPrototype=*/true);
2659 } else if (Name.getNameKind() == DeclarationName::CXXConversionFunctionName) {
2660 if (!DC->isRecord()) {
2661 Diag(D.getIdentifierLoc(),
2662 diag::err_conv_function_not_member);
2666 CheckConversionDeclarator(D, R, SC);
2667 NewFD = CXXConversionDecl::Create(Context, cast<CXXRecordDecl>(DC),
2668 D.getIdentifierLoc(), Name, R, TInfo,
2669 isInline, isExplicit);
2671 isVirtualOkay = true;
2672 } else if (DC->isRecord()) {
2673 // If the of the function is the same as the name of the record, then this
2674 // must be an invalid constructor that has a return type.
2675 // (The parser checks for a return type and makes the declarator a
2676 // constructor if it has no return type).
2677 // must have an invalid constructor that has a return type
2678 if (Name.getAsIdentifierInfo() == cast<CXXRecordDecl>(DC)->getIdentifier()){
2679 Diag(D.getIdentifierLoc(), diag::err_constructor_return_type)
2680 << SourceRange(D.getDeclSpec().getTypeSpecTypeLoc())
2681 << SourceRange(D.getIdentifierLoc());
2685 bool isStatic = SC == FunctionDecl::Static;
2688 // Any allocation function for a class T is a static member
2689 // (even if not explicitly declared static).
2690 if (Name.getCXXOverloadedOperator() == OO_New ||
2691 Name.getCXXOverloadedOperator() == OO_Array_New)
2694 // [class.free]p6 Any deallocation function for a class X is a static member
2695 // (even if not explicitly declared static).
2696 if (Name.getCXXOverloadedOperator() == OO_Delete ||
2697 Name.getCXXOverloadedOperator() == OO_Array_Delete)
2700 // This is a C++ method declaration.
2701 NewFD = CXXMethodDecl::Create(Context, cast<CXXRecordDecl>(DC),
2702 D.getIdentifierLoc(), Name, R, TInfo,
2703 isStatic, isInline);
2705 isVirtualOkay = !isStatic;
2707 // Determine whether the function was written with a
2708 // prototype. This true when:
2709 // - we're in C++ (where every function has a prototype),
2710 // - there is a prototype in the declarator, or
2711 // - the type R of the function is some kind of typedef or other reference
2712 // to a type name (which eventually refers to a function type).
2714 getLangOptions().CPlusPlus ||
2715 (D.getNumTypeObjects() && D.getTypeObject(0).Fun.hasPrototype) ||
2716 (!isa<FunctionType>(R.getTypePtr()) && R->isFunctionProtoType());
2718 NewFD = FunctionDecl::Create(Context, DC,
2719 D.getIdentifierLoc(),
2720 Name, R, TInfo, SC, isInline, HasPrototype);
2723 if (D.isInvalidType())
2724 NewFD->setInvalidDecl();
2726 // Set the lexical context. If the declarator has a C++
2727 // scope specifier, or is the object of a friend declaration, the
2728 // lexical context will be different from the semantic context.
2729 NewFD->setLexicalDeclContext(CurContext);
2731 // Match up the template parameter lists with the scope specifier, then
2732 // determine whether we have a template or a template specialization.
2733 FunctionTemplateDecl *FunctionTemplate = 0;
2734 bool isExplicitSpecialization = false;
2735 bool isFunctionTemplateSpecialization = false;
2736 if (TemplateParameterList *TemplateParams
2737 = MatchTemplateParametersToScopeSpecifier(
2738 D.getDeclSpec().getSourceRange().getBegin(),
2739 D.getCXXScopeSpec(),
2740 (TemplateParameterList**)TemplateParamLists.get(),
2741 TemplateParamLists.size(),
2742 isExplicitSpecialization)) {
2743 if (TemplateParams->size() > 0) {
2744 // This is a function template
2746 // Check that we can declare a template here.
2747 if (CheckTemplateDeclScope(S, TemplateParams))
2750 FunctionTemplate = FunctionTemplateDecl::Create(Context, DC,
2751 NewFD->getLocation(),
2752 Name, TemplateParams,
2754 FunctionTemplate->setLexicalDeclContext(CurContext);
2755 NewFD->setDescribedFunctionTemplate(FunctionTemplate);
2757 // This is a function template specialization.
2758 isFunctionTemplateSpecialization = true;
2761 // FIXME: Free this memory properly.
2762 TemplateParamLists.release();
2765 // C++ [dcl.fct.spec]p5:
2766 // The virtual specifier shall only be used in declarations of
2767 // nonstatic class member functions that appear within a
2768 // member-specification of a class declaration; see 10.3.
2770 if (isVirtual && !NewFD->isInvalidDecl()) {
2771 if (!isVirtualOkay) {
2772 Diag(D.getDeclSpec().getVirtualSpecLoc(),
2773 diag::err_virtual_non_function);
2774 } else if (!CurContext->isRecord()) {
2775 // 'virtual' was specified outside of the class.
2776 Diag(D.getDeclSpec().getVirtualSpecLoc(), diag::err_virtual_out_of_class)
2777 << CodeModificationHint::CreateRemoval(
2778 D.getDeclSpec().getVirtualSpecLoc());
2780 // Okay: Add virtual to the method.
2781 CXXRecordDecl *CurClass = cast<CXXRecordDecl>(DC);
2782 CurClass->setMethodAsVirtual(NewFD);
2786 // Filter out previous declarations that don't match the scope.
2787 FilterLookupForScope(*this, Previous, DC, S, NewFD->hasLinkage());
2790 // DC is the namespace in which the function is being declared.
2791 assert((DC->isFileContext() || !Previous.empty()) &&
2792 "previously-undeclared friend function being created "
2793 "in a non-namespace context");
2795 if (FunctionTemplate) {
2796 FunctionTemplate->setObjectOfFriendDecl(
2797 /* PreviouslyDeclared= */ !Previous.empty());
2798 FunctionTemplate->setAccess(AS_public);
2801 NewFD->setObjectOfFriendDecl(/* PreviouslyDeclared= */ !Previous.empty());
2803 NewFD->setAccess(AS_public);
2806 if (SC == FunctionDecl::Static && isa<CXXMethodDecl>(NewFD) &&
2807 !CurContext->isRecord()) {
2808 // C++ [class.static]p1:
2809 // A data or function member of a class may be declared static
2810 // in a class definition, in which case it is a static member of
2813 // Complain about the 'static' specifier if it's on an out-of-line
2814 // member function definition.
2815 Diag(D.getDeclSpec().getStorageClassSpecLoc(),
2816 diag::err_static_out_of_line)
2817 << CodeModificationHint::CreateRemoval(
2818 D.getDeclSpec().getStorageClassSpecLoc());
2821 // Handle GNU asm-label extension (encoded as an attribute).
2822 if (Expr *E = (Expr*) D.getAsmLabel()) {
2823 // The parser guarantees this is a string.
2824 StringLiteral *SE = cast<StringLiteral>(E);
2825 NewFD->addAttr(::new (Context) AsmLabelAttr(SE->getString()));
2828 // Copy the parameter declarations from the declarator D to the function
2829 // declaration NewFD, if they are available. First scavenge them into Params.
2830 llvm::SmallVector<ParmVarDecl*, 16> Params;
2831 if (D.getNumTypeObjects() > 0) {
2832 DeclaratorChunk::FunctionTypeInfo &FTI = D.getTypeObject(0).Fun;
2834 // Check for C99 6.7.5.3p10 - foo(void) is a non-varargs
2835 // function that takes no arguments, not a function that takes a
2836 // single void argument.
2837 // We let through "const void" here because Sema::GetTypeForDeclarator
2838 // already checks for that case.
2839 if (FTI.NumArgs == 1 && !FTI.isVariadic && FTI.ArgInfo[0].Ident == 0 &&
2840 FTI.ArgInfo[0].Param &&
2841 FTI.ArgInfo[0].Param.getAs<ParmVarDecl>()->getType()->isVoidType()) {
2842 // Empty arg list, don't push any params.
2843 ParmVarDecl *Param = FTI.ArgInfo[0].Param.getAs<ParmVarDecl>();
2845 // In C++, the empty parameter-type-list must be spelled "void"; a
2846 // typedef of void is not permitted.
2847 if (getLangOptions().CPlusPlus &&
2848 Param->getType().getUnqualifiedType() != Context.VoidTy)
2849 Diag(Param->getLocation(), diag::err_param_typedef_of_void);
2850 // FIXME: Leaks decl?
2851 } else if (FTI.NumArgs > 0 && FTI.ArgInfo[0].Param != 0) {
2852 for (unsigned i = 0, e = FTI.NumArgs; i != e; ++i) {
2853 ParmVarDecl *Param = FTI.ArgInfo[i].Param.getAs<ParmVarDecl>();
2854 assert(Param->getDeclContext() != NewFD && "Was set before ?");
2855 Param->setDeclContext(NewFD);
2856 Params.push_back(Param);
2860 } else if (const FunctionProtoType *FT = R->getAs<FunctionProtoType>()) {
2861 // When we're declaring a function with a typedef, typeof, etc as in the
2862 // following example, we'll need to synthesize (unnamed)
2863 // parameters for use in the declaration.
2866 // typedef void fn(int);
2870 // Synthesize a parameter for each argument type.
2871 for (FunctionProtoType::arg_type_iterator AI = FT->arg_type_begin(),
2872 AE = FT->arg_type_end(); AI != AE; ++AI) {
2873 ParmVarDecl *Param = ParmVarDecl::Create(Context, NewFD,
2874 SourceLocation(), 0,
2877 Param->setImplicit();
2878 Params.push_back(Param);
2881 assert(R->isFunctionNoProtoType() && NewFD->getNumParams() == 0 &&
2882 "Should not need args for typedef of non-prototype fn");
2884 // Finally, we know we have the right number of parameters, install them.
2885 NewFD->setParams(Context, Params.data(), Params.size());
2887 // If the declarator is a template-id, translate the parser's template
2888 // argument list into our AST format.
2889 bool HasExplicitTemplateArgs = false;
2890 TemplateArgumentListInfo TemplateArgs;
2891 if (D.getName().getKind() == UnqualifiedId::IK_TemplateId) {
2892 TemplateIdAnnotation *TemplateId = D.getName().TemplateId;
2893 TemplateArgs.setLAngleLoc(TemplateId->LAngleLoc);
2894 TemplateArgs.setRAngleLoc(TemplateId->RAngleLoc);
2895 ASTTemplateArgsPtr TemplateArgsPtr(*this,
2896 TemplateId->getTemplateArgs(),
2897 TemplateId->NumArgs);
2898 translateTemplateArguments(TemplateArgsPtr,
2900 TemplateArgsPtr.release();
2902 HasExplicitTemplateArgs = true;
2904 if (FunctionTemplate) {
2905 // FIXME: Diagnose function template with explicit template
2907 HasExplicitTemplateArgs = false;
2908 } else if (!isFunctionTemplateSpecialization &&
2909 !D.getDeclSpec().isFriendSpecified()) {
2910 // We have encountered something that the user meant to be a
2911 // specialization (because it has explicitly-specified template
2912 // arguments) but that was not introduced with a "template<>" (or had
2913 // too few of them).
2914 Diag(D.getIdentifierLoc(), diag::err_template_spec_needs_header)
2915 << SourceRange(TemplateId->LAngleLoc, TemplateId->RAngleLoc)
2916 << CodeModificationHint::CreateInsertion(
2917 D.getDeclSpec().getSourceRange().getBegin(),
2919 isFunctionTemplateSpecialization = true;
2923 if (isFunctionTemplateSpecialization) {
2924 if (CheckFunctionTemplateSpecialization(NewFD,
2925 (HasExplicitTemplateArgs ? &TemplateArgs : 0),
2927 NewFD->setInvalidDecl();
2928 } else if (isExplicitSpecialization && isa<CXXMethodDecl>(NewFD) &&
2929 CheckMemberSpecialization(NewFD, Previous))
2930 NewFD->setInvalidDecl();
2932 // Perform semantic checking on the function declaration.
2933 bool OverloadableAttrRequired = false; // FIXME: HACK!
2934 CheckFunctionDeclaration(S, NewFD, Previous, isExplicitSpecialization,
2935 Redeclaration, /*FIXME:*/OverloadableAttrRequired);
2937 assert((NewFD->isInvalidDecl() || !Redeclaration ||
2938 Previous.getResultKind() != LookupResult::FoundOverloaded) &&
2939 "previous declaration set still overloaded");
2941 // If we have a function template, check the template parameter
2942 // list. This will check and merge default template arguments.
2943 if (FunctionTemplate) {
2944 FunctionTemplateDecl *PrevTemplate = FunctionTemplate->getPreviousDeclaration();
2945 CheckTemplateParameterList(FunctionTemplate->getTemplateParameters(),
2946 PrevTemplate? PrevTemplate->getTemplateParameters() : 0,
2947 D.getDeclSpec().isFriendSpecified()? TPC_FriendFunctionTemplate
2948 : TPC_FunctionTemplate);
2951 if (D.getCXXScopeSpec().isSet() && !NewFD->isInvalidDecl()) {
2952 // Fake up an access specifier if it's supposed to be a class member.
2953 if (isa<CXXRecordDecl>(NewFD->getDeclContext()))
2954 NewFD->setAccess(AS_public);
2956 // An out-of-line member function declaration must also be a
2957 // definition (C++ [dcl.meaning]p1).
2958 // Note that this is not the case for explicit specializations of
2959 // function templates or member functions of class templates, per
2960 // C++ [temp.expl.spec]p2.
2961 if (!IsFunctionDefinition && !isFriend &&
2962 !isFunctionTemplateSpecialization && !isExplicitSpecialization) {
2963 Diag(NewFD->getLocation(), diag::err_out_of_line_declaration)
2964 << D.getCXXScopeSpec().getRange();
2965 NewFD->setInvalidDecl();
2966 } else if (!Redeclaration &&
2967 !(isFriend && CurContext->isDependentContext())) {
2968 // The user tried to provide an out-of-line definition for a
2969 // function that is a member of a class or namespace, but there
2970 // was no such member function declared (C++ [class.mfct]p2,
2971 // C++ [namespace.memdef]p2). For example:
2977 // void X::f() { } // ill-formed
2979 // Complain about this problem, and attempt to suggest close
2980 // matches (e.g., those that differ only in cv-qualifiers and
2981 // whether the parameter types are references).
2982 Diag(D.getIdentifierLoc(), diag::err_member_def_does_not_match)
2983 << Name << DC << D.getCXXScopeSpec().getRange();
2984 NewFD->setInvalidDecl();
2986 LookupResult Prev(*this, Name, D.getIdentifierLoc(), LookupOrdinaryName,
2988 LookupQualifiedName(Prev, DC);
2989 assert(!Prev.isAmbiguous() &&
2990 "Cannot have an ambiguity in previous-declaration lookup");
2991 for (LookupResult::iterator Func = Prev.begin(), FuncEnd = Prev.end();
2992 Func != FuncEnd; ++Func) {
2993 if (isa<FunctionDecl>(*Func) &&
2994 isNearlyMatchingFunction(Context, cast<FunctionDecl>(*Func), NewFD))
2995 Diag((*Func)->getLocation(), diag::note_member_def_close_match);
3000 // Handle attributes. We need to have merged decls when handling attributes
3001 // (for example to check for conflicts, etc).
3002 // FIXME: This needs to happen before we merge declarations. Then,
3003 // let attribute merging cope with attribute conflicts.
3004 ProcessDeclAttributes(S, NewFD, D);
3006 // attributes declared post-definition are currently ignored
3007 if (Redeclaration && Previous.isSingleResult()) {
3008 const FunctionDecl *Def;
3009 FunctionDecl *PrevFD = dyn_cast<FunctionDecl>(Previous.getFoundDecl());
3010 if (PrevFD && PrevFD->getBody(Def) && D.hasAttributes()) {
3011 Diag(NewFD->getLocation(), diag::warn_attribute_precede_definition);
3012 Diag(Def->getLocation(), diag::note_previous_definition);
3016 AddKnownFunctionAttributes(NewFD);
3018 if (OverloadableAttrRequired && !NewFD->getAttr<OverloadableAttr>()) {
3019 // If a function name is overloadable in C, then every function
3020 // with that name must be marked "overloadable".
3021 Diag(NewFD->getLocation(), diag::err_attribute_overloadable_missing)
3022 << Redeclaration << NewFD;
3023 if (!Previous.empty())
3024 Diag(Previous.getRepresentativeDecl()->getLocation(),
3025 diag::note_attribute_overloadable_prev_overload);
3026 NewFD->addAttr(::new (Context) OverloadableAttr());
3029 // If this is a locally-scoped extern C function, update the
3030 // map of such names.
3031 if (CurContext->isFunctionOrMethod() && NewFD->isExternC()
3032 && !NewFD->isInvalidDecl())
3033 RegisterLocallyScopedExternCDecl(NewFD, Previous, S);
3035 // Set this FunctionDecl's range up to the right paren.
3036 NewFD->setLocEnd(D.getSourceRange().getEnd());
3038 if (FunctionTemplate && NewFD->isInvalidDecl())
3039 FunctionTemplate->setInvalidDecl();
3041 if (FunctionTemplate)
3042 return FunctionTemplate;
3047 /// \brief Perform semantic checking of a new function declaration.
3049 /// Performs semantic analysis of the new function declaration
3050 /// NewFD. This routine performs all semantic checking that does not
3051 /// require the actual declarator involved in the declaration, and is
3052 /// used both for the declaration of functions as they are parsed
3053 /// (called via ActOnDeclarator) and for the declaration of functions
3054 /// that have been instantiated via C++ template instantiation (called
3055 /// via InstantiateDecl).
3057 /// \param IsExplicitSpecialiation whether this new function declaration is
3058 /// an explicit specialization of the previous declaration.
3060 /// This sets NewFD->isInvalidDecl() to true if there was an error.
3061 void Sema::CheckFunctionDeclaration(Scope *S, FunctionDecl *NewFD,
3062 LookupResult &Previous,
3063 bool IsExplicitSpecialization,
3064 bool &Redeclaration,
3065 bool &OverloadableAttrRequired) {
3066 // If NewFD is already known erroneous, don't do any of this checking.
3067 if (NewFD->isInvalidDecl())
3070 if (NewFD->getResultType()->isVariablyModifiedType()) {
3071 // Functions returning a variably modified type violate C99 6.7.5.2p2
3072 // because all functions have linkage.
3073 Diag(NewFD->getLocation(), diag::err_vm_func_decl);
3074 return NewFD->setInvalidDecl();
3077 if (NewFD->isMain())
3080 // Check for a previous declaration of this name.
3081 if (Previous.empty() && NewFD->isExternC()) {
3082 // Since we did not find anything by this name and we're declaring
3083 // an extern "C" function, look for a non-visible extern "C"
3084 // declaration with the same name.
3085 llvm::DenseMap<DeclarationName, NamedDecl *>::iterator Pos
3086 = LocallyScopedExternalDecls.find(NewFD->getDeclName());
3087 if (Pos != LocallyScopedExternalDecls.end())
3088 Previous.addDecl(Pos->second);
3091 // Merge or overload the declaration with an existing declaration of
3092 // the same name, if appropriate.
3093 if (!Previous.empty()) {
3094 // Determine whether NewFD is an overload of PrevDecl or
3095 // a declaration that requires merging. If it's an overload,
3096 // there's no more work to do here; we'll just add the new
3097 // function to the scope.
3099 NamedDecl *OldDecl = 0;
3100 if (!AllowOverloadingOfFunction(Previous, Context)) {
3101 Redeclaration = true;
3102 OldDecl = Previous.getFoundDecl();
3104 if (!getLangOptions().CPlusPlus) {
3105 OverloadableAttrRequired = true;
3107 // Functions marked "overloadable" must have a prototype (that
3108 // we can't get through declaration merging).
3109 if (!NewFD->getType()->getAs<FunctionProtoType>()) {
3110 Diag(NewFD->getLocation(),
3111 diag::err_attribute_overloadable_no_prototype)
3113 Redeclaration = true;
3115 // Turn this into a variadic function with no parameters.
3116 QualType R = Context.getFunctionType(
3117 NewFD->getType()->getAs<FunctionType>()->getResultType(),
3120 return NewFD->setInvalidDecl();
3124 switch (CheckOverload(NewFD, Previous, OldDecl)) {
3126 Redeclaration = true;
3127 if (isa<UsingShadowDecl>(OldDecl) && CurContext->isRecord()) {
3128 HideUsingShadowDecl(S, cast<UsingShadowDecl>(OldDecl));
3129 Redeclaration = false;
3133 case Ovl_NonFunction:
3134 Redeclaration = true;
3138 Redeclaration = false;
3143 if (Redeclaration) {
3144 // NewFD and OldDecl represent declarations that need to be
3146 if (MergeFunctionDecl(NewFD, OldDecl))
3147 return NewFD->setInvalidDecl();
3150 Previous.addDecl(OldDecl);
3152 if (FunctionTemplateDecl *OldTemplateDecl
3153 = dyn_cast<FunctionTemplateDecl>(OldDecl)) {
3154 NewFD->setPreviousDeclaration(OldTemplateDecl->getTemplatedDecl());
3155 FunctionTemplateDecl *NewTemplateDecl
3156 = NewFD->getDescribedFunctionTemplate();
3157 assert(NewTemplateDecl && "Template/non-template mismatch");
3158 if (CXXMethodDecl *Method
3159 = dyn_cast<CXXMethodDecl>(NewTemplateDecl->getTemplatedDecl())) {
3160 Method->setAccess(OldTemplateDecl->getAccess());
3161 NewTemplateDecl->setAccess(OldTemplateDecl->getAccess());
3164 // If this is an explicit specialization of a member that is a function
3165 // template, mark it as a member specialization.
3166 if (IsExplicitSpecialization &&
3167 NewTemplateDecl->getInstantiatedFromMemberTemplate()) {
3168 NewTemplateDecl->setMemberSpecialization();
3169 assert(OldTemplateDecl->isMemberSpecialization());
3172 if (isa<CXXMethodDecl>(NewFD)) // Set access for out-of-line definitions
3173 NewFD->setAccess(OldDecl->getAccess());
3174 NewFD->setPreviousDeclaration(cast<FunctionDecl>(OldDecl));
3179 // Semantic checking for this function declaration (in isolation).
3180 if (getLangOptions().CPlusPlus) {
3181 // C++-specific checks.
3182 if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(NewFD)) {
3183 CheckConstructor(Constructor);
3184 } else if (CXXDestructorDecl *Destructor =
3185 dyn_cast<CXXDestructorDecl>(NewFD)) {
3186 CXXRecordDecl *Record = Destructor->getParent();
3187 QualType ClassType = Context.getTypeDeclType(Record);
3189 // FIXME: Shouldn't we be able to perform thisc heck even when the class
3190 // type is dependent? Both gcc and edg can handle that.
3191 if (!ClassType->isDependentType()) {
3192 DeclarationName Name
3193 = Context.DeclarationNames.getCXXDestructorName(
3194 Context.getCanonicalType(ClassType));
3195 if (NewFD->getDeclName() != Name) {
3196 Diag(NewFD->getLocation(), diag::err_destructor_name);
3197 return NewFD->setInvalidDecl();
3201 Record->setUserDeclaredDestructor(true);
3202 // C++ [class]p4: A POD-struct is an aggregate class that has [...] no
3203 // user-defined destructor.
3204 Record->setPOD(false);
3206 // C++ [class.dtor]p3: A destructor is trivial if it is an implicitly-
3207 // declared destructor.
3208 // FIXME: C++0x: don't do this for "= default" destructors
3209 Record->setHasTrivialDestructor(false);
3210 } else if (CXXConversionDecl *Conversion
3211 = dyn_cast<CXXConversionDecl>(NewFD)) {
3212 ActOnConversionDeclarator(Conversion);
3215 // Find any virtual functions that this function overrides.
3216 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(NewFD)) {
3217 if (!Method->isFunctionTemplateSpecialization() &&
3218 !Method->getDescribedFunctionTemplate())
3219 AddOverriddenMethods(Method->getParent(), Method);
3222 // Additional checks for the destructor; make sure we do this after we
3223 // figure out whether the destructor is virtual.
3224 if (CXXDestructorDecl *Destructor = dyn_cast<CXXDestructorDecl>(NewFD))
3225 if (!Destructor->getParent()->isDependentType())
3226 CheckDestructor(Destructor);
3228 // Extra checking for C++ overloaded operators (C++ [over.oper]).
3229 if (NewFD->isOverloadedOperator() &&
3230 CheckOverloadedOperatorDeclaration(NewFD))
3231 return NewFD->setInvalidDecl();
3233 // Extra checking for C++0x literal operators (C++0x [over.literal]).
3234 if (NewFD->getLiteralIdentifier() &&
3235 CheckLiteralOperatorDeclaration(NewFD))
3236 return NewFD->setInvalidDecl();
3238 // In C++, check default arguments now that we have merged decls. Unless
3239 // the lexical context is the class, because in this case this is done
3240 // during delayed parsing anyway.
3241 if (!CurContext->isRecord())
3242 CheckCXXDefaultArguments(NewFD);
3246 void Sema::CheckMain(FunctionDecl* FD) {
3247 // C++ [basic.start.main]p3: A program that declares main to be inline
3248 // or static is ill-formed.
3249 // C99 6.7.4p4: In a hosted environment, the inline function specifier
3250 // shall not appear in a declaration of main.
3251 // static main is not an error under C99, but we should warn about it.
3252 bool isInline = FD->isInlineSpecified();
3253 bool isStatic = FD->getStorageClass() == FunctionDecl::Static;
3254 if (isInline || isStatic) {
3255 unsigned diagID = diag::warn_unusual_main_decl;
3256 if (isInline || getLangOptions().CPlusPlus)
3257 diagID = diag::err_unusual_main_decl;
3259 int which = isStatic + (isInline << 1) - 1;
3260 Diag(FD->getLocation(), diagID) << which;
3263 QualType T = FD->getType();
3264 assert(T->isFunctionType() && "function decl is not of function type");
3265 const FunctionType* FT = T->getAs<FunctionType>();
3267 if (!Context.hasSameUnqualifiedType(FT->getResultType(), Context.IntTy)) {
3268 // TODO: add a replacement fixit to turn the return type into 'int'.
3269 Diag(FD->getTypeSpecStartLoc(), diag::err_main_returns_nonint);
3270 FD->setInvalidDecl(true);
3273 // Treat protoless main() as nullary.
3274 if (isa<FunctionNoProtoType>(FT)) return;
3276 const FunctionProtoType* FTP = cast<const FunctionProtoType>(FT);
3277 unsigned nparams = FTP->getNumArgs();
3278 assert(FD->getNumParams() == nparams);
3280 bool HasExtraParameters = (nparams > 3);
3282 // Darwin passes an undocumented fourth argument of type char**. If
3283 // other platforms start sprouting these, the logic below will start
3286 Context.Target.getTriple().getOS() == llvm::Triple::Darwin)
3287 HasExtraParameters = false;
3289 if (HasExtraParameters) {
3290 Diag(FD->getLocation(), diag::err_main_surplus_args) << nparams;
3291 FD->setInvalidDecl(true);
3295 // FIXME: a lot of the following diagnostics would be improved
3296 // if we had some location information about types.
3299 Context.getPointerType(Context.getPointerType(Context.CharTy));
3300 QualType Expected[] = { Context.IntTy, CharPP, CharPP, CharPP };
3302 for (unsigned i = 0; i < nparams; ++i) {
3303 QualType AT = FTP->getArgType(i);
3305 bool mismatch = true;
3307 if (Context.hasSameUnqualifiedType(AT, Expected[i]))
3309 else if (Expected[i] == CharPP) {
3310 // As an extension, the following forms are okay:
3312 // char const * const *
3315 QualifierCollector qs;
3316 const PointerType* PT;
3317 if ((PT = qs.strip(AT)->getAs<PointerType>()) &&
3318 (PT = qs.strip(PT->getPointeeType())->getAs<PointerType>()) &&
3319 (QualType(qs.strip(PT->getPointeeType()), 0) == Context.CharTy)) {
3321 mismatch = !qs.empty();
3326 Diag(FD->getLocation(), diag::err_main_arg_wrong) << i << Expected[i];
3327 // TODO: suggest replacing given type with expected type
3328 FD->setInvalidDecl(true);
3332 if (nparams == 1 && !FD->isInvalidDecl()) {
3333 Diag(FD->getLocation(), diag::warn_main_one_arg);
3337 bool Sema::CheckForConstantInitializer(Expr *Init, QualType DclT) {
3338 // FIXME: Need strict checking. In C89, we need to check for
3339 // any assignment, increment, decrement, function-calls, or
3340 // commas outside of a sizeof. In C99, it's the same list,
3341 // except that the aforementioned are allowed in unevaluated
3342 // expressions. Everything else falls under the
3343 // "may accept other forms of constant expressions" exception.
3344 // (We never end up here for C++, so the constant expression
3345 // rules there don't matter.)
3346 if (Init->isConstantInitializer(Context))
3348 Diag(Init->getExprLoc(), diag::err_init_element_not_constant)
3349 << Init->getSourceRange();
3353 void Sema::AddInitializerToDecl(DeclPtrTy dcl, ExprArg init) {
3354 AddInitializerToDecl(dcl, move(init), /*DirectInit=*/false);
3357 /// AddInitializerToDecl - Adds the initializer Init to the
3358 /// declaration dcl. If DirectInit is true, this is C++ direct
3359 /// initialization rather than copy initialization.
3360 void Sema::AddInitializerToDecl(DeclPtrTy dcl, ExprArg init, bool DirectInit) {
3361 Decl *RealDecl = dcl.getAs<Decl>();
3362 // If there is no declaration, there was an error parsing it. Just ignore
3367 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(RealDecl)) {
3368 // With declarators parsed the way they are, the parser cannot
3369 // distinguish between a normal initializer and a pure-specifier.
3370 // Thus this grotesque test.
3372 Expr *Init = static_cast<Expr *>(init.get());
3373 if ((IL = dyn_cast<IntegerLiteral>(Init)) && IL->getValue() == 0 &&
3374 Context.getCanonicalType(IL->getType()) == Context.IntTy)
3375 CheckPureMethod(Method, Init->getSourceRange());
3377 Diag(Method->getLocation(), diag::err_member_function_initialization)
3378 << Method->getDeclName() << Init->getSourceRange();
3379 Method->setInvalidDecl();
3384 VarDecl *VDecl = dyn_cast<VarDecl>(RealDecl);
3386 if (getLangOptions().CPlusPlus &&
3387 RealDecl->getLexicalDeclContext()->isRecord() &&
3388 isa<NamedDecl>(RealDecl))
3389 Diag(RealDecl->getLocation(), diag::err_member_initialization)
3390 << cast<NamedDecl>(RealDecl)->getDeclName();
3392 Diag(RealDecl->getLocation(), diag::err_illegal_initializer);
3393 RealDecl->setInvalidDecl();
3397 // A definition must end up with a complete type, which means it must be
3398 // complete with the restriction that an array type might be completed by the
3399 // initializer; note that later code assumes this restriction.
3400 QualType BaseDeclType = VDecl->getType();
3401 if (const ArrayType *Array = Context.getAsIncompleteArrayType(BaseDeclType))
3402 BaseDeclType = Array->getElementType();
3403 if (RequireCompleteType(VDecl->getLocation(), BaseDeclType,
3404 diag::err_typecheck_decl_incomplete_type)) {
3405 RealDecl->setInvalidDecl();
3409 // The variable can not have an abstract class type.
3410 if (RequireNonAbstractType(VDecl->getLocation(), VDecl->getType(),
3411 diag::err_abstract_type_in_decl,
3412 AbstractVariableType))
3413 VDecl->setInvalidDecl();
3415 const VarDecl *Def = 0;
3416 if (VDecl->getDefinition(Def)) {
3417 Diag(VDecl->getLocation(), diag::err_redefinition)
3418 << VDecl->getDeclName();
3419 Diag(Def->getLocation(), diag::note_previous_definition);
3420 VDecl->setInvalidDecl();
3424 // Take ownership of the expression, now that we're sure we have somewhere
3426 Expr *Init = init.takeAs<Expr>();
3427 assert(Init && "missing initializer");
3429 // Capture the variable that is being initialized and the style of
3431 InitializedEntity Entity = InitializedEntity::InitializeVariable(VDecl);
3433 // FIXME: Poor source location information.
3434 InitializationKind Kind
3435 = DirectInit? InitializationKind::CreateDirect(VDecl->getLocation(),
3436 Init->getLocStart(),
3438 : InitializationKind::CreateCopy(VDecl->getLocation(),
3439 Init->getLocStart());
3441 // Get the decls type and save a reference for later, since
3442 // CheckInitializerTypes may change it.
3443 QualType DclT = VDecl->getType(), SavT = DclT;
3444 if (VDecl->isBlockVarDecl()) {
3445 if (VDecl->hasExternalStorage()) { // C99 6.7.8p5
3446 Diag(VDecl->getLocation(), diag::err_block_extern_cant_init);
3447 VDecl->setInvalidDecl();
3448 } else if (!VDecl->isInvalidDecl()) {
3449 InitializationSequence InitSeq(*this, Entity, Kind, &Init, 1);
3450 OwningExprResult Result = InitSeq.Perform(*this, Entity, Kind,
3451 MultiExprArg(*this, (void**)&Init, 1),
3453 if (Result.isInvalid()) {
3454 VDecl->setInvalidDecl();
3458 Init = Result.takeAs<Expr>();
3460 // C++ 3.6.2p2, allow dynamic initialization of static initializers.
3461 // Don't check invalid declarations to avoid emitting useless diagnostics.
3462 if (!getLangOptions().CPlusPlus && !VDecl->isInvalidDecl()) {
3463 if (VDecl->getStorageClass() == VarDecl::Static) // C99 6.7.8p4.
3464 CheckForConstantInitializer(Init, DclT);
3467 } else if (VDecl->isStaticDataMember() &&
3468 VDecl->getLexicalDeclContext()->isRecord()) {
3469 // This is an in-class initialization for a static data member, e.g.,
3472 // static const int value = 17;
3475 // Attach the initializer
3476 VDecl->setInit(Context, Init);
3478 // C++ [class.mem]p4:
3479 // A member-declarator can contain a constant-initializer only
3480 // if it declares a static member (9.4) of const integral or
3481 // const enumeration type, see 9.4.2.
3482 QualType T = VDecl->getType();
3483 if (!T->isDependentType() &&
3484 (!Context.getCanonicalType(T).isConstQualified() ||
3485 !T->isIntegralType())) {
3486 Diag(VDecl->getLocation(), diag::err_member_initialization)
3487 << VDecl->getDeclName() << Init->getSourceRange();
3488 VDecl->setInvalidDecl();
3490 // C++ [class.static.data]p4:
3491 // If a static data member is of const integral or const
3492 // enumeration type, its declaration in the class definition
3493 // can specify a constant-initializer which shall be an
3494 // integral constant expression (5.19).
3495 if (!Init->isTypeDependent() &&
3496 !Init->getType()->isIntegralType()) {
3497 // We have a non-dependent, non-integral or enumeration type.
3498 Diag(Init->getSourceRange().getBegin(),
3499 diag::err_in_class_initializer_non_integral_type)
3500 << Init->getType() << Init->getSourceRange();
3501 VDecl->setInvalidDecl();
3502 } else if (!Init->isTypeDependent() && !Init->isValueDependent()) {
3503 // Check whether the expression is a constant expression.
3506 if (!Init->isIntegerConstantExpr(Value, Context, &Loc)) {
3507 Diag(Loc, diag::err_in_class_initializer_non_constant)
3508 << Init->getSourceRange();
3509 VDecl->setInvalidDecl();
3510 } else if (!VDecl->getType()->isDependentType())
3511 ImpCastExprToType(Init, VDecl->getType(), CastExpr::CK_IntegralCast);
3514 } else if (VDecl->isFileVarDecl()) {
3515 if (VDecl->getStorageClass() == VarDecl::Extern)
3516 Diag(VDecl->getLocation(), diag::warn_extern_init);
3517 if (!VDecl->isInvalidDecl()) {
3518 InitializationSequence InitSeq(*this, Entity, Kind, &Init, 1);
3519 OwningExprResult Result = InitSeq.Perform(*this, Entity, Kind,
3520 MultiExprArg(*this, (void**)&Init, 1),
3522 if (Result.isInvalid()) {
3523 VDecl->setInvalidDecl();
3527 Init = Result.takeAs<Expr>();
3530 // C++ 3.6.2p2, allow dynamic initialization of static initializers.
3531 // Don't check invalid declarations to avoid emitting useless diagnostics.
3532 if (!getLangOptions().CPlusPlus && !VDecl->isInvalidDecl()) {
3533 // C99 6.7.8p4. All file scoped initializers need to be constant.
3534 CheckForConstantInitializer(Init, DclT);
3537 // If the type changed, it means we had an incomplete type that was
3538 // completed by the initializer. For example:
3539 // int ary[] = { 1, 3, 5 };
3540 // "ary" transitions from a VariableArrayType to a ConstantArrayType.
3541 if (!VDecl->isInvalidDecl() && (DclT != SavT)) {
3542 VDecl->setType(DclT);
3543 Init->setType(DclT);
3546 Init = MaybeCreateCXXExprWithTemporaries(Init);
3547 // Attach the initializer to the decl.
3548 VDecl->setInit(Context, Init);
3550 // If the previous declaration of VDecl was a tentative definition,
3551 // remove it from the set of tentative definitions.
3552 if (VDecl->getPreviousDeclaration() &&
3553 VDecl->getPreviousDeclaration()->isTentativeDefinition(Context)) {
3554 bool Deleted = TentativeDefinitions.erase(VDecl->getDeclName());
3555 assert(Deleted && "Unrecorded tentative definition?"); Deleted=Deleted;
3558 if (getLangOptions().CPlusPlus) {
3559 // Make sure we mark the destructor as used if necessary.
3560 QualType InitType = VDecl->getType();
3561 while (const ArrayType *Array = Context.getAsArrayType(InitType))
3562 InitType = Context.getBaseElementType(Array);
3563 if (InitType->isRecordType())
3564 FinalizeVarWithDestructor(VDecl, InitType);
3570 void Sema::ActOnUninitializedDecl(DeclPtrTy dcl,
3571 bool TypeContainsUndeducedAuto) {
3572 Decl *RealDecl = dcl.getAs<Decl>();
3574 // If there is no declaration, there was an error parsing it. Just ignore it.
3578 if (VarDecl *Var = dyn_cast<VarDecl>(RealDecl)) {
3579 QualType Type = Var->getType();
3581 // Record tentative definitions.
3582 if (Var->isTentativeDefinition(Context)) {
3583 std::pair<llvm::DenseMap<DeclarationName, VarDecl *>::iterator, bool>
3585 TentativeDefinitions.insert(std::make_pair(Var->getDeclName(), Var));
3587 // Keep the latest definition in the map. If we see 'int i; int i;' we
3588 // want the second one in the map.
3589 InsertPair.first->second = Var;
3591 // However, for the list, we don't care about the order, just make sure
3592 // that there are no dupes for a given declaration name.
3593 if (InsertPair.second)
3594 TentativeDefinitionList.push_back(Var->getDeclName());
3597 // C++ [dcl.init.ref]p3:
3598 // The initializer can be omitted for a reference only in a
3599 // parameter declaration (8.3.5), in the declaration of a
3600 // function return type, in the declaration of a class member
3601 // within its class declaration (9.2), and where the extern
3602 // specifier is explicitly used.
3603 if (Type->isReferenceType() && !Var->hasExternalStorage()) {
3604 Diag(Var->getLocation(), diag::err_reference_var_requires_init)
3605 << Var->getDeclName()
3606 << SourceRange(Var->getLocation(), Var->getLocation());
3607 Var->setInvalidDecl();
3611 // C++0x [dcl.spec.auto]p3
3612 if (TypeContainsUndeducedAuto) {
3613 Diag(Var->getLocation(), diag::err_auto_var_requires_init)
3614 << Var->getDeclName() << Type;
3615 Var->setInvalidDecl();
3619 // An array without size is an incomplete type, and there are no special
3620 // rules in C++ to make such a definition acceptable.
3621 if (getLangOptions().CPlusPlus && Type->isIncompleteArrayType() &&
3622 !Var->hasExternalStorage()) {
3623 Diag(Var->getLocation(),
3624 diag::err_typecheck_incomplete_array_needs_initializer);
3625 Var->setInvalidDecl();
3629 // C++ [temp.expl.spec]p15:
3630 // An explicit specialization of a static data member of a template is a
3631 // definition if the declaration includes an initializer; otherwise, it
3632 // is a declaration.
3633 if (Var->isStaticDataMember() &&
3634 Var->getInstantiatedFromStaticDataMember() &&
3635 Var->getTemplateSpecializationKind() == TSK_ExplicitSpecialization)
3638 // C++ [dcl.init]p9:
3639 // If no initializer is specified for an object, and the object
3640 // is of (possibly cv-qualified) non-POD class type (or array
3641 // thereof), the object shall be default-initialized; if the
3642 // object is of const-qualified type, the underlying class type
3643 // shall have a user-declared default constructor.
3645 // FIXME: Diagnose the "user-declared default constructor" bit.
3646 if (getLangOptions().CPlusPlus) {
3647 QualType InitType = Type;
3648 if (const ArrayType *Array = Context.getAsArrayType(Type))
3649 InitType = Context.getBaseElementType(Array);
3650 if ((!Var->hasExternalStorage() && !Var->isExternC()) &&
3651 InitType->isRecordType() && !InitType->isDependentType()) {
3652 if (!RequireCompleteType(Var->getLocation(), InitType,
3653 diag::err_invalid_incomplete_type_use)) {
3654 InitializedEntity Entity
3655 = InitializedEntity::InitializeVariable(Var);
3656 InitializationKind Kind
3657 = InitializationKind::CreateDefault(Var->getLocation());
3659 InitializationSequence InitSeq(*this, Entity, Kind, 0, 0);
3660 OwningExprResult Init = InitSeq.Perform(*this, Entity, Kind,
3661 MultiExprArg(*this, 0, 0));
3662 if (Init.isInvalid())
3663 Var->setInvalidDecl();
3665 Var->setInit(Context,
3666 MaybeCreateCXXExprWithTemporaries(Init.takeAs<Expr>()));
3667 FinalizeVarWithDestructor(Var, InitType);
3670 Var->setInvalidDecl();
3674 // The variable can not have an abstract class type.
3675 if (RequireNonAbstractType(Var->getLocation(), Type,
3676 diag::err_abstract_type_in_decl,
3677 AbstractVariableType))
3678 Var->setInvalidDecl();
3682 // FIXME: Temporarily disabled because we are not properly parsing
3683 // linkage specifications on declarations, e.g.,
3685 // extern "C" const CGPoint CGPointerZero;
3687 // C++ [dcl.init]p9:
3689 // If no initializer is specified for an object, and the
3690 // object is of (possibly cv-qualified) non-POD class type (or
3691 // array thereof), the object shall be default-initialized; if
3692 // the object is of const-qualified type, the underlying class
3693 // type shall have a user-declared default
3694 // constructor. Otherwise, if no initializer is specified for
3695 // an object, the object and its subobjects, if any, have an
3696 // indeterminate initial value; if the object or any of its
3697 // subobjects are of const-qualified type, the program is
3700 // This isn't technically an error in C, so we don't diagnose it.
3702 // FIXME: Actually perform the POD/user-defined default
3703 // constructor check.
3704 if (getLangOptions().CPlusPlus &&
3705 Context.getCanonicalType(Type).isConstQualified() &&
3706 !Var->hasExternalStorage())
3707 Diag(Var->getLocation(), diag::err_const_var_requires_init)
3709 << SourceRange(Var->getLocation(), Var->getLocation());
3714 Sema::DeclGroupPtrTy Sema::FinalizeDeclaratorGroup(Scope *S, const DeclSpec &DS,
3716 unsigned NumDecls) {
3717 llvm::SmallVector<Decl*, 8> Decls;
3719 if (DS.isTypeSpecOwned())
3720 Decls.push_back((Decl*)DS.getTypeRep());
3722 for (unsigned i = 0; i != NumDecls; ++i)
3723 if (Decl *D = Group[i].getAs<Decl>())
3726 // Perform semantic analysis that depends on having fully processed both
3727 // the declarator and initializer.
3728 for (unsigned i = 0, e = Decls.size(); i != e; ++i) {
3729 VarDecl *IDecl = dyn_cast<VarDecl>(Decls[i]);
3732 QualType T = IDecl->getType();
3734 // Block scope. C99 6.7p7: If an identifier for an object is declared with
3735 // no linkage (C99 6.2.2p6), the type for the object shall be complete...
3736 if (IDecl->isBlockVarDecl() && !IDecl->hasExternalStorage()) {
3737 if (T->isDependentType()) {
3738 // If T is dependent, we should not require a complete type.
3739 // (RequireCompleteType shouldn't be called with dependent types.)
3740 // But we still can at least check if we've got an array of unspecified
3741 // size without an initializer.
3742 if (!IDecl->isInvalidDecl() && T->isIncompleteArrayType() &&
3743 !IDecl->getInit()) {
3744 Diag(IDecl->getLocation(), diag::err_typecheck_decl_incomplete_type)
3746 IDecl->setInvalidDecl();
3748 } else if (!IDecl->isInvalidDecl()) {
3749 // If T is an incomplete array type with an initializer list that is
3750 // dependent on something, its size has not been fixed. We could attempt
3751 // to fix the size for such arrays, but we would still have to check
3752 // here for initializers containing a C++0x vararg expansion, e.g.
3753 // template <typename... Args> void f(Args... args) {
3754 // int vals[] = { args };
3756 const IncompleteArrayType *IAT = Context.getAsIncompleteArrayType(T);
3757 Expr *Init = IDecl->getInit();
3759 (Init->isTypeDependent() || Init->isValueDependent())) {
3760 // Check that the member type of the array is complete, at least.
3761 if (RequireCompleteType(IDecl->getLocation(), IAT->getElementType(),
3762 diag::err_typecheck_decl_incomplete_type))
3763 IDecl->setInvalidDecl();
3764 } else if (RequireCompleteType(IDecl->getLocation(), T,
3765 diag::err_typecheck_decl_incomplete_type))
3766 IDecl->setInvalidDecl();
3769 // File scope. C99 6.9.2p2: A declaration of an identifier for an
3770 // object that has file scope without an initializer, and without a
3771 // storage-class specifier or with the storage-class specifier "static",
3772 // constitutes a tentative definition. Note: A tentative definition with
3773 // external linkage is valid (C99 6.2.2p5).
3774 if (IDecl->isTentativeDefinition(Context) && !IDecl->isInvalidDecl()) {
3775 if (const IncompleteArrayType *ArrayT
3776 = Context.getAsIncompleteArrayType(T)) {
3777 if (RequireCompleteType(IDecl->getLocation(),
3778 ArrayT->getElementType(),
3779 diag::err_illegal_decl_array_incomplete_type))
3780 IDecl->setInvalidDecl();
3781 } else if (IDecl->getStorageClass() == VarDecl::Static) {
3782 // C99 6.9.2p3: If the declaration of an identifier for an object is
3783 // a tentative definition and has internal linkage (C99 6.2.2p3), the
3784 // declared type shall not be an incomplete type.
3785 // NOTE: code such as the following
3787 // struct s { int a; };
3788 // is accepted by gcc. Hence here we issue a warning instead of
3789 // an error and we do not invalidate the static declaration.
3790 // NOTE: to avoid multiple warnings, only check the first declaration.
3791 if (IDecl->getPreviousDeclaration() == 0)
3792 RequireCompleteType(IDecl->getLocation(), T,
3793 diag::ext_typecheck_decl_incomplete_type);
3797 return DeclGroupPtrTy::make(DeclGroupRef::Create(Context,
3798 Decls.data(), Decls.size()));
3802 /// ActOnParamDeclarator - Called from Parser::ParseFunctionDeclarator()
3803 /// to introduce parameters into function prototype scope.
3805 Sema::ActOnParamDeclarator(Scope *S, Declarator &D) {
3806 const DeclSpec &DS = D.getDeclSpec();
3808 // Verify C99 6.7.5.3p2: The only SCS allowed is 'register'.
3809 VarDecl::StorageClass StorageClass = VarDecl::None;
3810 if (DS.getStorageClassSpec() == DeclSpec::SCS_register) {
3811 StorageClass = VarDecl::Register;
3812 } else if (DS.getStorageClassSpec() != DeclSpec::SCS_unspecified) {
3813 Diag(DS.getStorageClassSpecLoc(),
3814 diag::err_invalid_storage_class_in_func_decl);
3815 D.getMutableDeclSpec().ClearStorageClassSpecs();
3818 if (D.getDeclSpec().isThreadSpecified())
3819 Diag(D.getDeclSpec().getThreadSpecLoc(), diag::err_invalid_thread);
3821 DiagnoseFunctionSpecifiers(D);
3823 // Check that there are no default arguments inside the type of this
3824 // parameter (C++ only).
3825 if (getLangOptions().CPlusPlus)
3826 CheckExtraCXXDefaultArguments(D);
3828 TypeSourceInfo *TInfo = 0;
3829 TagDecl *OwnedDecl = 0;
3830 QualType parmDeclType = GetTypeForDeclarator(D, S, &TInfo, &OwnedDecl);
3832 if (getLangOptions().CPlusPlus && OwnedDecl && OwnedDecl->isDefinition()) {
3834 // Types shall not be defined in return or parameter types.
3835 Diag(OwnedDecl->getLocation(), diag::err_type_defined_in_param_type)
3836 << Context.getTypeDeclType(OwnedDecl);
3839 // TODO: CHECK FOR CONFLICTS, multiple decls with same name in one scope.
3840 // Can this happen for params? We already checked that they don't conflict
3841 // among each other. Here they can only shadow globals, which is ok.
3842 IdentifierInfo *II = D.getIdentifier();
3844 if (NamedDecl *PrevDecl = LookupSingleName(S, II, LookupOrdinaryName)) {
3845 if (PrevDecl->isTemplateParameter()) {
3846 // Maybe we will complain about the shadowed template parameter.
3847 DiagnoseTemplateParameterShadow(D.getIdentifierLoc(), PrevDecl);
3848 // Just pretend that we didn't see the previous declaration.
3850 } else if (S->isDeclScope(DeclPtrTy::make(PrevDecl))) {
3851 Diag(D.getIdentifierLoc(), diag::err_param_redefinition) << II;
3853 // Recover by removing the name
3855 D.SetIdentifier(0, D.getIdentifierLoc());
3860 // Parameters can not be abstract class types.
3861 // For record types, this is done by the AbstractClassUsageDiagnoser once
3862 // the class has been completely parsed.
3863 if (!CurContext->isRecord() &&
3864 RequireNonAbstractType(D.getIdentifierLoc(), parmDeclType,
3865 diag::err_abstract_type_in_decl,
3867 D.setInvalidType(true);
3869 QualType T = adjustParameterType(parmDeclType);
3871 // Temporarily put parameter variables in the translation unit, not
3872 // the enclosing context. This prevents them from accidentally
3873 // looking like class members in C++.
3874 DeclContext *DC = Context.getTranslationUnitDecl();
3877 = ParmVarDecl::Create(Context, DC, D.getIdentifierLoc(), II,
3878 T, TInfo, StorageClass, 0);
3880 if (D.isInvalidType())
3881 New->setInvalidDecl();
3883 // Parameter declarators cannot be interface types. All ObjC objects are
3884 // passed by reference.
3885 if (T->isObjCInterfaceType()) {
3886 Diag(D.getIdentifierLoc(),
3887 diag::err_object_cannot_be_passed_returned_by_value) << 1 << T;
3888 New->setInvalidDecl();
3891 // Parameter declarators cannot be qualified (C++ [dcl.meaning]p1).
3892 if (D.getCXXScopeSpec().isSet()) {
3893 Diag(D.getIdentifierLoc(), diag::err_qualified_param_declarator)
3894 << D.getCXXScopeSpec().getRange();
3895 New->setInvalidDecl();
3898 // ISO/IEC TR 18037 S6.7.3: "The type of an object with automatic storage
3899 // duration shall not be qualified by an address-space qualifier."
3900 // Since all parameters have automatic store duration, they can not have
3901 // an address space.
3902 if (T.getAddressSpace() != 0) {
3903 Diag(D.getIdentifierLoc(),
3904 diag::err_arg_with_address_space);
3905 New->setInvalidDecl();
3909 // Add the parameter declaration into this scope.
3910 S->AddDecl(DeclPtrTy::make(New));
3912 IdResolver.AddDecl(New);
3914 ProcessDeclAttributes(S, New, D);
3916 if (New->hasAttr<BlocksAttr>()) {
3917 Diag(New->getLocation(), diag::err_block_on_nonlocal);
3919 return DeclPtrTy::make(New);
3922 void Sema::ActOnFinishKNRParamDeclarations(Scope *S, Declarator &D,
3923 SourceLocation LocAfterDecls) {
3924 assert(D.getTypeObject(0).Kind == DeclaratorChunk::Function &&
3925 "Not a function declarator!");
3926 DeclaratorChunk::FunctionTypeInfo &FTI = D.getTypeObject(0).Fun;
3928 // Verify 6.9.1p6: 'every identifier in the identifier list shall be declared'
3929 // for a K&R function.
3930 if (!FTI.hasPrototype) {
3931 for (int i = FTI.NumArgs; i != 0; /* decrement in loop */) {
3933 if (FTI.ArgInfo[i].Param == 0) {
3934 llvm::SmallString<256> Code;
3935 llvm::raw_svector_ostream(Code) << " int "
3936 << FTI.ArgInfo[i].Ident->getName()
3938 Diag(FTI.ArgInfo[i].IdentLoc, diag::ext_param_not_declared)
3939 << FTI.ArgInfo[i].Ident
3940 << CodeModificationHint::CreateInsertion(LocAfterDecls, Code.str());
3942 // Implicitly declare the argument as type 'int' for lack of a better
3945 const char* PrevSpec; // unused
3946 unsigned DiagID; // unused
3947 DS.SetTypeSpecType(DeclSpec::TST_int, FTI.ArgInfo[i].IdentLoc,
3949 Declarator ParamD(DS, Declarator::KNRTypeListContext);
3950 ParamD.SetIdentifier(FTI.ArgInfo[i].Ident, FTI.ArgInfo[i].IdentLoc);
3951 FTI.ArgInfo[i].Param = ActOnParamDeclarator(S, ParamD);
3957 Sema::DeclPtrTy Sema::ActOnStartOfFunctionDef(Scope *FnBodyScope,
3959 assert(getCurFunctionDecl() == 0 && "Function parsing confused");
3960 assert(D.getTypeObject(0).Kind == DeclaratorChunk::Function &&
3961 "Not a function declarator!");
3962 DeclaratorChunk::FunctionTypeInfo &FTI = D.getTypeObject(0).Fun;
3964 if (FTI.hasPrototype) {
3965 // FIXME: Diagnose arguments without names in C.
3968 Scope *ParentScope = FnBodyScope->getParent();
3970 DeclPtrTy DP = HandleDeclarator(ParentScope, D,
3971 MultiTemplateParamsArg(*this),
3972 /*IsFunctionDefinition=*/true);
3973 return ActOnStartOfFunctionDef(FnBodyScope, DP);
3976 static bool ShouldWarnAboutMissingPrototype(const FunctionDecl *FD) {
3977 // Don't warn about invalid declarations.
3978 if (FD->isInvalidDecl())
3981 // Or declarations that aren't global.
3982 if (!FD->isGlobal())
3985 // Don't warn about C++ member functions.
3986 if (isa<CXXMethodDecl>(FD))
3989 // Don't warn about 'main'.
3993 // Don't warn about inline functions.
3994 if (FD->isInlineSpecified())
3997 // Don't warn about function templates.
3998 if (FD->getDescribedFunctionTemplate())
4001 // Don't warn about function template specializations.
4002 if (FD->isFunctionTemplateSpecialization())
4005 bool MissingPrototype = true;
4006 for (const FunctionDecl *Prev = FD->getPreviousDeclaration();
4007 Prev; Prev = Prev->getPreviousDeclaration()) {
4008 // Ignore any declarations that occur in function or method
4009 // scope, because they aren't visible from the header.
4010 if (Prev->getDeclContext()->isFunctionOrMethod())
4013 MissingPrototype = !Prev->getType()->isFunctionProtoType();
4017 return MissingPrototype;
4020 Sema::DeclPtrTy Sema::ActOnStartOfFunctionDef(Scope *FnBodyScope, DeclPtrTy D) {
4021 // Clear the last template instantiation error context.
4022 LastTemplateInstantiationErrorContext = ActiveTemplateInstantiation();
4026 FunctionDecl *FD = 0;
4028 if (FunctionTemplateDecl *FunTmpl
4029 = dyn_cast<FunctionTemplateDecl>(D.getAs<Decl>()))
4030 FD = FunTmpl->getTemplatedDecl();
4032 FD = cast<FunctionDecl>(D.getAs<Decl>());
4034 CurFunctionNeedsScopeChecking = false;
4036 // See if this is a redefinition.
4037 const FunctionDecl *Definition;
4038 if (FD->getBody(Definition)) {
4039 Diag(FD->getLocation(), diag::err_redefinition) << FD->getDeclName();
4040 Diag(Definition->getLocation(), diag::note_previous_definition);
4043 // Builtin functions cannot be defined.
4044 if (unsigned BuiltinID = FD->getBuiltinID()) {
4045 if (!Context.BuiltinInfo.isPredefinedLibFunction(BuiltinID)) {
4046 Diag(FD->getLocation(), diag::err_builtin_definition) << FD;
4047 FD->setInvalidDecl();
4051 // The return type of a function definition must be complete
4052 // (C99 6.9.1p3, C++ [dcl.fct]p6).
4053 QualType ResultType = FD->getResultType();
4054 if (!ResultType->isDependentType() && !ResultType->isVoidType() &&
4055 !FD->isInvalidDecl() &&
4056 RequireCompleteType(FD->getLocation(), ResultType,
4057 diag::err_func_def_incomplete_result))
4058 FD->setInvalidDecl();
4060 // GNU warning -Wmissing-prototypes:
4061 // Warn if a global function is defined without a previous
4062 // prototype declaration. This warning is issued even if the
4063 // definition itself provides a prototype. The aim is to detect
4064 // global functions that fail to be declared in header files.
4065 if (ShouldWarnAboutMissingPrototype(FD))
4066 Diag(FD->getLocation(), diag::warn_missing_prototype) << FD;
4069 PushDeclContext(FnBodyScope, FD);
4071 // Check the validity of our function parameters
4072 CheckParmsForFunctionDef(FD);
4074 // Introduce our parameters into the function scope
4075 for (unsigned p = 0, NumParams = FD->getNumParams(); p < NumParams; ++p) {
4076 ParmVarDecl *Param = FD->getParamDecl(p);
4077 Param->setOwningFunction(FD);
4079 // If this has an identifier, add it to the scope stack.
4080 if (Param->getIdentifier() && FnBodyScope)
4081 PushOnScopeChains(Param, FnBodyScope);
4084 // Checking attributes of current function definition
4085 // dllimport attribute.
4086 if (FD->getAttr<DLLImportAttr>() &&
4087 (!FD->getAttr<DLLExportAttr>())) {
4088 // dllimport attribute cannot be applied to definition.
4089 if (!(FD->getAttr<DLLImportAttr>())->isInherited()) {
4090 Diag(FD->getLocation(),
4091 diag::err_attribute_can_be_applied_only_to_symbol_declaration)
4093 FD->setInvalidDecl();
4094 return DeclPtrTy::make(FD);
4096 // If a symbol previously declared dllimport is later defined, the
4097 // attribute is ignored in subsequent references, and a warning is
4099 Diag(FD->getLocation(),
4100 diag::warn_redeclaration_without_attribute_prev_attribute_ignored)
4101 << FD->getNameAsCString() << "dllimport";
4104 return DeclPtrTy::make(FD);
4107 Sema::DeclPtrTy Sema::ActOnFinishFunctionBody(DeclPtrTy D, StmtArg BodyArg) {
4108 return ActOnFinishFunctionBody(D, move(BodyArg), false);
4111 Sema::DeclPtrTy Sema::ActOnFinishFunctionBody(DeclPtrTy D, StmtArg BodyArg,
4112 bool IsInstantiation) {
4113 Decl *dcl = D.getAs<Decl>();
4114 Stmt *Body = BodyArg.takeAs<Stmt>();
4116 // Don't generate EH edges for CallExprs as we'd like to avoid the n^2
4117 // explosion for destrutors that can result and the compile time hit.
4118 AnalysisContext AC(dcl, false);
4119 FunctionDecl *FD = 0;
4120 FunctionTemplateDecl *FunTmpl = dyn_cast_or_null<FunctionTemplateDecl>(dcl);
4122 FD = FunTmpl->getTemplatedDecl();
4124 FD = dyn_cast_or_null<FunctionDecl>(dcl);
4129 // C and C++ allow for main to automagically return 0.
4130 // Implements C++ [basic.start.main]p5 and C99 5.1.2.2.3.
4131 FD->setHasImplicitReturnZero(true);
4133 CheckFallThroughForFunctionDef(FD, Body, AC);
4135 if (!FD->isInvalidDecl())
4136 DiagnoseUnusedParameters(FD->param_begin(), FD->param_end());
4138 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(FD))
4139 MaybeMarkVirtualMembersReferenced(Method->getLocation(), Method);
4141 assert(FD == getCurFunctionDecl() && "Function parsing confused");
4142 } else if (ObjCMethodDecl *MD = dyn_cast_or_null<ObjCMethodDecl>(dcl)) {
4143 assert(MD == getCurMethodDecl() && "Method parsing confused");
4145 CheckFallThroughForFunctionDef(MD, Body, AC);
4146 MD->setEndLoc(Body->getLocEnd());
4148 if (!MD->isInvalidDecl())
4149 DiagnoseUnusedParameters(MD->param_begin(), MD->param_end());
4151 Body->Destroy(Context);
4154 if (!IsInstantiation)
4157 // Verify and clean out per-function state.
4159 assert(&getLabelMap() == &FunctionLabelMap && "Didn't pop block right?");
4161 // Check goto/label use.
4162 for (llvm::DenseMap<IdentifierInfo*, LabelStmt*>::iterator
4163 I = FunctionLabelMap.begin(), E = FunctionLabelMap.end(); I != E; ++I) {
4164 LabelStmt *L = I->second;
4166 // Verify that we have no forward references left. If so, there was a goto
4167 // or address of a label taken, but no definition of it. Label fwd
4168 // definitions are indicated with a null substmt.
4169 if (L->getSubStmt() != 0)
4173 Diag(L->getIdentLoc(), diag::err_undeclared_label_use) << L->getName();
4175 // At this point, we have gotos that use the bogus label. Stitch it into
4176 // the function body so that they aren't leaked and that the AST is well
4179 // The whole function wasn't parsed correctly, just delete this.
4180 L->Destroy(Context);
4184 // Otherwise, the body is valid: we want to stitch the label decl into the
4185 // function somewhere so that it is properly owned and so that the goto
4186 // has a valid target. Do this by creating a new compound stmt with the
4189 // Give the label a sub-statement.
4190 L->setSubStmt(new (Context) NullStmt(L->getIdentLoc()));
4192 CompoundStmt *Compound = isa<CXXTryStmt>(Body) ?
4193 cast<CXXTryStmt>(Body)->getTryBlock() :
4194 cast<CompoundStmt>(Body);
4195 std::vector<Stmt*> Elements(Compound->body_begin(), Compound->body_end());
4196 Elements.push_back(L);
4197 Compound->setStmts(Context, &Elements[0], Elements.size());
4199 FunctionLabelMap.clear();
4201 if (!Body) return D;
4203 CheckUnreachable(AC);
4205 // Verify that that gotos and switch cases don't jump into scopes illegally.
4206 if (CurFunctionNeedsScopeChecking)
4207 DiagnoseInvalidJumps(Body);
4209 // C++ constructors that have function-try-blocks can't have return
4210 // statements in the handlers of that block. (C++ [except.handle]p14)
4212 if (FD && isa<CXXConstructorDecl>(FD) && isa<CXXTryStmt>(Body))
4213 DiagnoseReturnInConstructorExceptionHandler(cast<CXXTryStmt>(Body));
4215 if (CXXDestructorDecl *Destructor = dyn_cast<CXXDestructorDecl>(dcl))
4216 MarkBaseAndMemberDestructorsReferenced(Destructor);
4218 // If any errors have occurred, clear out any temporaries that may have
4219 // been leftover. This ensures that these temporaries won't be picked up for
4220 // deletion in some later function.
4221 if (PP.getDiagnostics().hasErrorOccurred())
4222 ExprTemporaries.clear();
4224 assert(ExprTemporaries.empty() && "Leftover temporaries in function");
4228 /// ImplicitlyDefineFunction - An undeclared identifier was used in a function
4229 /// call, forming a call to an implicitly defined function (per C99 6.5.1p2).
4230 NamedDecl *Sema::ImplicitlyDefineFunction(SourceLocation Loc,
4231 IdentifierInfo &II, Scope *S) {
4232 // Before we produce a declaration for an implicitly defined
4233 // function, see whether there was a locally-scoped declaration of
4234 // this name as a function or variable. If so, use that
4235 // (non-visible) declaration, and complain about it.
4236 llvm::DenseMap<DeclarationName, NamedDecl *>::iterator Pos
4237 = LocallyScopedExternalDecls.find(&II);
4238 if (Pos != LocallyScopedExternalDecls.end()) {
4239 Diag(Loc, diag::warn_use_out_of_scope_declaration) << Pos->second;
4240 Diag(Pos->second->getLocation(), diag::note_previous_declaration);
4244 // Extension in C99. Legal in C90, but warn about it.
4245 if (II.getName().startswith("__builtin_"))
4246 Diag(Loc, diag::warn_builtin_unknown) << &II;
4247 else if (getLangOptions().C99)
4248 Diag(Loc, diag::ext_implicit_function_decl) << &II;
4250 Diag(Loc, diag::warn_implicit_function_decl) << &II;
4252 // Set a Declarator for the implicit definition: int foo();
4256 bool Error = DS.SetTypeSpecType(DeclSpec::TST_int, Loc, Dummy, DiagID);
4257 Error = Error; // Silence warning.
4258 assert(!Error && "Error setting up implicit decl!");
4259 Declarator D(DS, Declarator::BlockContext);
4260 D.AddTypeInfo(DeclaratorChunk::getFunction(false, false, SourceLocation(), 0,
4261 0, 0, false, SourceLocation(),
4262 false, 0,0,0, Loc, Loc, D),
4264 D.SetIdentifier(&II, Loc);
4266 // Insert this function into translation-unit scope.
4268 DeclContext *PrevDC = CurContext;
4269 CurContext = Context.getTranslationUnitDecl();
4272 dyn_cast<FunctionDecl>(ActOnDeclarator(TUScope, D).getAs<Decl>());
4275 CurContext = PrevDC;
4277 AddKnownFunctionAttributes(FD);
4282 /// \brief Adds any function attributes that we know a priori based on
4283 /// the declaration of this function.
4285 /// These attributes can apply both to implicitly-declared builtins
4286 /// (like __builtin___printf_chk) or to library-declared functions
4287 /// like NSLog or printf.
4288 void Sema::AddKnownFunctionAttributes(FunctionDecl *FD) {
4289 if (FD->isInvalidDecl())
4292 // If this is a built-in function, map its builtin attributes to
4293 // actual attributes.
4294 if (unsigned BuiltinID = FD->getBuiltinID()) {
4295 // Handle printf-formatting attributes.
4298 if (Context.BuiltinInfo.isPrintfLike(BuiltinID, FormatIdx, HasVAListArg)) {
4299 if (!FD->getAttr<FormatAttr>())
4300 FD->addAttr(::new (Context) FormatAttr("printf", FormatIdx + 1,
4301 HasVAListArg ? 0 : FormatIdx + 2));
4304 // Mark const if we don't care about errno and that is the only
4305 // thing preventing the function from being const. This allows
4306 // IRgen to use LLVM intrinsics for such functions.
4307 if (!getLangOptions().MathErrno &&
4308 Context.BuiltinInfo.isConstWithoutErrno(BuiltinID)) {
4309 if (!FD->getAttr<ConstAttr>())
4310 FD->addAttr(::new (Context) ConstAttr());
4313 if (Context.BuiltinInfo.isNoReturn(BuiltinID))
4314 FD->addAttr(::new (Context) NoReturnAttr());
4315 if (Context.BuiltinInfo.isNoThrow(BuiltinID))
4316 FD->addAttr(::new (Context) NoThrowAttr());
4317 if (Context.BuiltinInfo.isConst(BuiltinID))
4318 FD->addAttr(::new (Context) ConstAttr());
4321 IdentifierInfo *Name = FD->getIdentifier();
4324 if ((!getLangOptions().CPlusPlus &&
4325 FD->getDeclContext()->isTranslationUnit()) ||
4326 (isa<LinkageSpecDecl>(FD->getDeclContext()) &&
4327 cast<LinkageSpecDecl>(FD->getDeclContext())->getLanguage() ==
4328 LinkageSpecDecl::lang_c)) {
4329 // Okay: this could be a libc/libm/Objective-C function we know
4334 if (Name->isStr("NSLog") || Name->isStr("NSLogv")) {
4335 // FIXME: NSLog and NSLogv should be target specific
4336 if (const FormatAttr *Format = FD->getAttr<FormatAttr>()) {
4337 // FIXME: We known better than our headers.
4338 const_cast<FormatAttr *>(Format)->setType("printf");
4340 FD->addAttr(::new (Context) FormatAttr("printf", 1,
4341 Name->isStr("NSLogv") ? 0 : 2));
4342 } else if (Name->isStr("asprintf") || Name->isStr("vasprintf")) {
4343 // FIXME: asprintf and vasprintf aren't C99 functions. Should they be
4344 // target-specific builtins, perhaps?
4345 if (!FD->getAttr<FormatAttr>())
4346 FD->addAttr(::new (Context) FormatAttr("printf", 2,
4347 Name->isStr("vasprintf") ? 0 : 3));
4351 TypedefDecl *Sema::ParseTypedefDecl(Scope *S, Declarator &D, QualType T,
4352 TypeSourceInfo *TInfo) {
4353 assert(D.getIdentifier() && "Wrong callback for declspec without declarator");
4354 assert(!T.isNull() && "GetTypeForDeclarator() returned null type");
4357 assert(D.isInvalidType() && "no declarator info for valid type");
4358 TInfo = Context.getTrivialTypeSourceInfo(T);
4361 // Scope manipulation handled by caller.
4362 TypedefDecl *NewTD = TypedefDecl::Create(Context, CurContext,
4363 D.getIdentifierLoc(),
4367 if (const TagType *TT = T->getAs<TagType>()) {
4368 TagDecl *TD = TT->getDecl();
4370 // If the TagDecl that the TypedefDecl points to is an anonymous decl
4371 // keep track of the TypedefDecl.
4372 if (!TD->getIdentifier() && !TD->getTypedefForAnonDecl())
4373 TD->setTypedefForAnonDecl(NewTD);
4376 if (D.isInvalidType())
4377 NewTD->setInvalidDecl();
4382 /// \brief Determine whether a tag with a given kind is acceptable
4383 /// as a redeclaration of the given tag declaration.
4385 /// \returns true if the new tag kind is acceptable, false otherwise.
4386 bool Sema::isAcceptableTagRedeclaration(const TagDecl *Previous,
4387 TagDecl::TagKind NewTag,
4388 SourceLocation NewTagLoc,
4389 const IdentifierInfo &Name) {
4390 // C++ [dcl.type.elab]p3:
4391 // The class-key or enum keyword present in the
4392 // elaborated-type-specifier shall agree in kind with the
4393 // declaration to which the name in theelaborated-type-specifier
4394 // refers. This rule also applies to the form of
4395 // elaborated-type-specifier that declares a class-name or
4396 // friend class since it can be construed as referring to the
4397 // definition of the class. Thus, in any
4398 // elaborated-type-specifier, the enum keyword shall be used to
4399 // refer to an enumeration (7.2), the union class-keyshall be
4400 // used to refer to a union (clause 9), and either the class or
4401 // struct class-key shall be used to refer to a class (clause 9)
4402 // declared using the class or struct class-key.
4403 TagDecl::TagKind OldTag = Previous->getTagKind();
4404 if (OldTag == NewTag)
4407 if ((OldTag == TagDecl::TK_struct || OldTag == TagDecl::TK_class) &&
4408 (NewTag == TagDecl::TK_struct || NewTag == TagDecl::TK_class)) {
4409 // Warn about the struct/class tag mismatch.
4410 bool isTemplate = false;
4411 if (const CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(Previous))
4412 isTemplate = Record->getDescribedClassTemplate();
4414 Diag(NewTagLoc, diag::warn_struct_class_tag_mismatch)
4415 << (NewTag == TagDecl::TK_class)
4416 << isTemplate << &Name
4417 << CodeModificationHint::CreateReplacement(SourceRange(NewTagLoc),
4418 OldTag == TagDecl::TK_class? "class" : "struct");
4419 Diag(Previous->getLocation(), diag::note_previous_use);
4425 /// ActOnTag - This is invoked when we see 'struct foo' or 'struct {'. In the
4426 /// former case, Name will be non-null. In the later case, Name will be null.
4427 /// TagSpec indicates what kind of tag this is. TUK indicates whether this is a
4428 /// reference/declaration/definition of a tag.
4429 Sema::DeclPtrTy Sema::ActOnTag(Scope *S, unsigned TagSpec, TagUseKind TUK,
4430 SourceLocation KWLoc, const CXXScopeSpec &SS,
4431 IdentifierInfo *Name, SourceLocation NameLoc,
4432 AttributeList *Attr, AccessSpecifier AS,
4433 MultiTemplateParamsArg TemplateParameterLists,
4434 bool &OwnedDecl, bool &IsDependent) {
4435 // If this is not a definition, it must have a name.
4436 assert((Name != 0 || TUK == TUK_Definition) &&
4437 "Nameless record must be a definition!");
4440 TagDecl::TagKind Kind = TagDecl::getTagKindForTypeSpec(TagSpec);
4442 // FIXME: Check explicit specializations more carefully.
4443 bool isExplicitSpecialization = false;
4444 if (TUK != TUK_Reference) {
4445 if (TemplateParameterList *TemplateParams
4446 = MatchTemplateParametersToScopeSpecifier(KWLoc, SS,
4447 (TemplateParameterList**)TemplateParameterLists.get(),
4448 TemplateParameterLists.size(),
4449 isExplicitSpecialization)) {
4450 if (TemplateParams->size() > 0) {
4451 // This is a declaration or definition of a class template (which may
4452 // be a member of another template).
4454 DeclResult Result = CheckClassTemplate(S, TagSpec, TUK, KWLoc,
4455 SS, Name, NameLoc, Attr,
4458 TemplateParameterLists.release();
4459 return Result.get();
4461 // The "template<>" header is extraneous.
4462 Diag(TemplateParams->getTemplateLoc(), diag::err_template_tag_noparams)
4463 << ElaboratedType::getNameForTagKind(Kind) << Name;
4464 isExplicitSpecialization = true;
4468 TemplateParameterLists.release();
4471 DeclContext *SearchDC = CurContext;
4472 DeclContext *DC = CurContext;
4473 bool isStdBadAlloc = false;
4474 bool Invalid = false;
4476 RedeclarationKind Redecl = (TUK != TUK_Reference ? ForRedeclaration
4477 : NotForRedeclaration);
4479 LookupResult Previous(*this, Name, NameLoc, LookupTagName, Redecl);
4481 if (Name && SS.isNotEmpty()) {
4482 // We have a nested-name tag ('struct foo::bar').
4484 // Check for invalid 'foo::'.
4485 if (SS.isInvalid()) {
4490 // If this is a friend or a reference to a class in a dependent
4491 // context, don't try to make a decl for it.
4492 if (TUK == TUK_Friend || TUK == TUK_Reference) {
4493 DC = computeDeclContext(SS, false);
4500 if (RequireCompleteDeclContext(SS))
4501 return DeclPtrTy::make((Decl *)0);
4503 DC = computeDeclContext(SS, true);
4505 // Look-up name inside 'foo::'.
4506 LookupQualifiedName(Previous, DC);
4508 if (Previous.isAmbiguous())
4511 if (Previous.empty()) {
4512 // Name lookup did not find anything. However, if the
4513 // nested-name-specifier refers to the current instantiation,
4514 // and that current instantiation has any dependent base
4515 // classes, we might find something at instantiation time: treat
4516 // this as a dependent elaborated-type-specifier.
4517 if (Previous.wasNotFoundInCurrentInstantiation()) {
4522 // A tag 'foo::bar' must already exist.
4523 Diag(NameLoc, diag::err_not_tag_in_scope) << Name << SS.getRange();
4529 // If this is a named struct, check to see if there was a previous forward
4530 // declaration or definition.
4531 // FIXME: We're looking into outer scopes here, even when we
4532 // shouldn't be. Doing so can result in ambiguities that we
4533 // shouldn't be diagnosing.
4534 LookupName(Previous, S);
4536 // Note: there used to be some attempt at recovery here.
4537 if (Previous.isAmbiguous())
4540 if (!getLangOptions().CPlusPlus && TUK != TUK_Reference) {
4541 // FIXME: This makes sure that we ignore the contexts associated
4542 // with C structs, unions, and enums when looking for a matching
4543 // tag declaration or definition. See the similar lookup tweak
4544 // in Sema::LookupName; is there a better way to deal with this?
4545 while (isa<RecordDecl>(SearchDC) || isa<EnumDecl>(SearchDC))
4546 SearchDC = SearchDC->getParent();
4550 if (Previous.isSingleResult() &&
4551 Previous.getFoundDecl()->isTemplateParameter()) {
4552 // Maybe we will complain about the shadowed template parameter.
4553 DiagnoseTemplateParameterShadow(NameLoc, Previous.getFoundDecl());
4554 // Just pretend that we didn't see the previous declaration.
4558 if (getLangOptions().CPlusPlus && Name && DC && StdNamespace &&
4559 DC->Equals(StdNamespace) && Name->isStr("bad_alloc")) {
4560 // This is a declaration of or a reference to "std::bad_alloc".
4561 isStdBadAlloc = true;
4563 if (Previous.empty() && StdBadAlloc) {
4564 // std::bad_alloc has been implicitly declared (but made invisible to
4565 // name lookup). Fill in this implicit declaration as the previous
4566 // declaration, so that the declarations get chained appropriately.
4567 Previous.addDecl(StdBadAlloc);
4571 if (!Previous.empty()) {
4572 assert(Previous.isSingleResult());
4573 NamedDecl *PrevDecl = Previous.getFoundDecl();
4574 if (TagDecl *PrevTagDecl = dyn_cast<TagDecl>(PrevDecl)) {
4575 // If this is a use of a previous tag, or if the tag is already declared
4576 // in the same scope (so that the definition/declaration completes or
4577 // rementions the tag), reuse the decl.
4578 if (TUK == TUK_Reference || TUK == TUK_Friend ||
4579 isDeclInScope(PrevDecl, SearchDC, S)) {
4580 // Make sure that this wasn't declared as an enum and now used as a
4581 // struct or something similar.
4582 if (!isAcceptableTagRedeclaration(PrevTagDecl, Kind, KWLoc, *Name)) {
4584 = (PrevTagDecl->getTagKind() != TagDecl::TK_enum &&
4585 Kind != TagDecl::TK_enum);
4587 Diag(KWLoc, diag::err_use_with_wrong_tag)
4589 << CodeModificationHint::CreateReplacement(SourceRange(KWLoc),
4590 PrevTagDecl->getKindName());
4592 Diag(KWLoc, diag::err_use_with_wrong_tag) << Name;
4593 Diag(PrevTagDecl->getLocation(), diag::note_previous_use);
4596 Kind = PrevTagDecl->getTagKind();
4598 // Recover by making this an anonymous redefinition.
4606 // If this is a use, just return the declaration we found.
4608 // FIXME: In the future, return a variant or some other clue
4609 // for the consumer of this Decl to know it doesn't own it.
4610 // For our current ASTs this shouldn't be a problem, but will
4611 // need to be changed with DeclGroups.
4612 if (TUK == TUK_Reference || TUK == TUK_Friend)
4613 return DeclPtrTy::make(PrevTagDecl);
4615 // Diagnose attempts to redefine a tag.
4616 if (TUK == TUK_Definition) {
4617 if (TagDecl *Def = PrevTagDecl->getDefinition(Context)) {
4618 // If we're defining a specialization and the previous definition
4619 // is from an implicit instantiation, don't emit an error
4620 // here; we'll catch this in the general case below.
4621 if (!isExplicitSpecialization ||
4622 !isa<CXXRecordDecl>(Def) ||
4623 cast<CXXRecordDecl>(Def)->getTemplateSpecializationKind()
4624 == TSK_ExplicitSpecialization) {
4625 Diag(NameLoc, diag::err_redefinition) << Name;
4626 Diag(Def->getLocation(), diag::note_previous_definition);
4627 // If this is a redefinition, recover by making this
4628 // struct be anonymous, which will make any later
4629 // references get the previous definition.
4635 // If the type is currently being defined, complain
4636 // about a nested redefinition.
4637 TagType *Tag = cast<TagType>(Context.getTagDeclType(PrevTagDecl));
4638 if (Tag->isBeingDefined()) {
4639 Diag(NameLoc, diag::err_nested_redefinition) << Name;
4640 Diag(PrevTagDecl->getLocation(),
4641 diag::note_previous_definition);
4648 // Okay, this is definition of a previously declared or referenced
4649 // tag PrevDecl. We're going to create a new Decl for it.
4652 // If we get here we have (another) forward declaration or we
4653 // have a definition. Just create a new decl.
4656 // If we get here, this is a definition of a new tag type in a nested
4657 // scope, e.g. "struct foo; void bar() { struct foo; }", just create a
4658 // new decl/type. We set PrevDecl to NULL so that the entities
4659 // have distinct types.
4662 // If we get here, we're going to create a new Decl. If PrevDecl
4663 // is non-NULL, it's a definition of the tag declared by
4664 // PrevDecl. If it's NULL, we have a new definition.
4666 // PrevDecl is a namespace, template, or anything else
4667 // that lives in the IDNS_Tag identifier namespace.
4668 if (isDeclInScope(PrevDecl, SearchDC, S)) {
4669 // The tag name clashes with a namespace name, issue an error and
4670 // recover by making this tag be anonymous.
4671 Diag(NameLoc, diag::err_redefinition_different_kind) << Name;
4672 Diag(PrevDecl->getLocation(), diag::note_previous_definition);
4677 // The existing declaration isn't relevant to us; we're in a
4678 // new scope, so clear out the previous declaration.
4682 } else if (TUK == TUK_Reference && SS.isEmpty() && Name) {
4683 // C++ [basic.scope.pdecl]p5:
4684 // -- for an elaborated-type-specifier of the form
4686 // class-key identifier
4688 // if the elaborated-type-specifier is used in the
4689 // decl-specifier-seq or parameter-declaration-clause of a
4690 // function defined in namespace scope, the identifier is
4691 // declared as a class-name in the namespace that contains
4692 // the declaration; otherwise, except as a friend
4693 // declaration, the identifier is declared in the smallest
4694 // non-class, non-function-prototype scope that contains the
4697 // C99 6.7.2.3p8 has a similar (but not identical!) provision for
4698 // C structs and unions.
4700 // It is an error in C++ to declare (rather than define) an enum
4701 // type, including via an elaborated type specifier. We'll
4702 // diagnose that later; for now, declare the enum in the same
4703 // scope as we would have picked for any other tag type.
4705 // GNU C also supports this behavior as part of its incomplete
4706 // enum types extension, while GNU C++ does not.
4708 // Find the context where we'll be declaring the tag.
4709 // FIXME: We would like to maintain the current DeclContext as the
4711 while (SearchDC->isRecord())
4712 SearchDC = SearchDC->getParent();
4714 // Find the scope where we'll be declaring the tag.
4715 while (S->isClassScope() ||
4716 (getLangOptions().CPlusPlus && S->isFunctionPrototypeScope()) ||
4717 ((S->getFlags() & Scope::DeclScope) == 0) ||
4719 ((DeclContext *)S->getEntity())->isTransparentContext()))
4722 } else if (TUK == TUK_Friend && SS.isEmpty() && Name) {
4723 // C++ [namespace.memdef]p3:
4724 // If a friend declaration in a non-local class first declares a
4725 // class or function, the friend class or function is a member of
4726 // the innermost enclosing namespace.
4727 while (!SearchDC->isFileContext())
4728 SearchDC = SearchDC->getParent();
4730 // The entity of a decl scope is a DeclContext; see PushDeclContext.
4731 while (S->getEntity() != SearchDC)
4737 TagDecl *PrevDecl = 0;
4738 if (Previous.isSingleResult())
4739 PrevDecl = cast<TagDecl>(Previous.getFoundDecl());
4741 // If there is an identifier, use the location of the identifier as the
4742 // location of the decl, otherwise use the location of the struct/union
4744 SourceLocation Loc = NameLoc.isValid() ? NameLoc : KWLoc;
4746 // Otherwise, create a new declaration. If there is a previous
4747 // declaration of the same entity, the two will be linked via
4751 if (Kind == TagDecl::TK_enum) {
4752 // FIXME: Tag decls should be chained to any simultaneous vardecls, e.g.:
4753 // enum X { A, B, C } D; D should chain to X.
4754 New = EnumDecl::Create(Context, SearchDC, Loc, Name, KWLoc,
4755 cast_or_null<EnumDecl>(PrevDecl));
4756 // If this is an undefined enum, warn.
4757 if (TUK != TUK_Definition && !Invalid) {
4758 unsigned DK = getLangOptions().CPlusPlus? diag::err_forward_ref_enum
4759 : diag::ext_forward_ref_enum;
4763 // struct/union/class
4765 // FIXME: Tag decls should be chained to any simultaneous vardecls, e.g.:
4766 // struct X { int A; } D; D should chain to X.
4767 if (getLangOptions().CPlusPlus) {
4768 // FIXME: Look for a way to use RecordDecl for simple structs.
4769 New = CXXRecordDecl::Create(Context, Kind, SearchDC, Loc, Name, KWLoc,
4770 cast_or_null<CXXRecordDecl>(PrevDecl));
4772 if (isStdBadAlloc && (!StdBadAlloc || StdBadAlloc->isImplicit()))
4773 StdBadAlloc = cast<CXXRecordDecl>(New);
4775 New = RecordDecl::Create(Context, Kind, SearchDC, Loc, Name, KWLoc,
4776 cast_or_null<RecordDecl>(PrevDecl));
4779 if (Kind != TagDecl::TK_enum) {
4780 // Handle #pragma pack: if the #pragma pack stack has non-default
4781 // alignment, make up a packed attribute for this decl. These
4782 // attributes are checked when the ASTContext lays out the
4785 // It is important for implementing the correct semantics that this
4786 // happen here (in act on tag decl). The #pragma pack stack is
4787 // maintained as a result of parser callbacks which can occur at
4788 // many points during the parsing of a struct declaration (because
4789 // the #pragma tokens are effectively skipped over during the
4790 // parsing of the struct).
4791 if (unsigned Alignment = getPragmaPackAlignment())
4792 New->addAttr(::new (Context) PragmaPackAttr(Alignment * 8));
4795 if (getLangOptions().CPlusPlus && SS.isEmpty() && Name && !Invalid) {
4796 // C++ [dcl.typedef]p3:
4797 // [...] Similarly, in a given scope, a class or enumeration
4798 // shall not be declared with the same name as a typedef-name
4799 // that is declared in that scope and refers to a type other
4800 // than the class or enumeration itself.
4801 LookupResult Lookup(*this, Name, NameLoc, LookupOrdinaryName,
4803 LookupName(Lookup, S);
4804 TypedefDecl *PrevTypedef = Lookup.getAsSingle<TypedefDecl>();
4805 NamedDecl *PrevTypedefNamed = PrevTypedef;
4806 if (PrevTypedef && isDeclInScope(PrevTypedefNamed, SearchDC, S) &&
4807 Context.getCanonicalType(Context.getTypeDeclType(PrevTypedef)) !=
4808 Context.getCanonicalType(Context.getTypeDeclType(New))) {
4809 Diag(Loc, diag::err_tag_definition_of_typedef)
4810 << Context.getTypeDeclType(New)
4811 << PrevTypedef->getUnderlyingType();
4812 Diag(PrevTypedef->getLocation(), diag::note_previous_definition);
4817 // If this is a specialization of a member class (of a class template),
4818 // check the specialization.
4819 if (isExplicitSpecialization && CheckMemberSpecialization(New, Previous))
4823 New->setInvalidDecl();
4826 ProcessDeclAttributeList(S, New, Attr);
4828 // If we're declaring or defining a tag in function prototype scope
4829 // in C, note that this type can only be used within the function.
4830 if (Name && S->isFunctionPrototypeScope() && !getLangOptions().CPlusPlus)
4831 Diag(Loc, diag::warn_decl_in_param_list) << Context.getTagDeclType(New);
4833 // Set the lexical context. If the tag has a C++ scope specifier, the
4834 // lexical context will be different from the semantic context.
4835 New->setLexicalDeclContext(CurContext);
4837 // Mark this as a friend decl if applicable.
4838 if (TUK == TUK_Friend)
4839 New->setObjectOfFriendDecl(/* PreviouslyDeclared = */ !Previous.empty());
4841 // Set the access specifier.
4842 if (!Invalid && TUK != TUK_Friend)
4843 SetMemberAccessSpecifier(New, PrevDecl, AS);
4845 if (TUK == TUK_Definition)
4846 New->startDefinition();
4848 // If this has an identifier, add it to the scope stack.
4849 if (TUK == TUK_Friend) {
4850 // We might be replacing an existing declaration in the lookup tables;
4851 // if so, borrow its access specifier.
4853 New->setAccess(PrevDecl->getAccess());
4855 // Friend tag decls are visible in fairly strange ways.
4856 if (!CurContext->isDependentContext()) {
4857 DeclContext *DC = New->getDeclContext()->getLookupContext();
4858 DC->makeDeclVisibleInContext(New, /* Recoverable = */ false);
4859 if (Scope *EnclosingScope = getScopeForDeclContext(S, DC))
4860 PushOnScopeChains(New, EnclosingScope, /* AddToContext = */ false);
4863 S = getNonFieldDeclScope(S);
4864 PushOnScopeChains(New, S);
4866 CurContext->addDecl(New);
4869 // If this is the C FILE type, notify the AST context.
4870 if (IdentifierInfo *II = New->getIdentifier())
4871 if (!New->isInvalidDecl() &&
4872 New->getDeclContext()->getLookupContext()->isTranslationUnit() &&
4874 Context.setFILEDecl(New);
4877 return DeclPtrTy::make(New);
4880 void Sema::ActOnTagStartDefinition(Scope *S, DeclPtrTy TagD) {
4881 AdjustDeclIfTemplate(TagD);
4882 TagDecl *Tag = cast<TagDecl>(TagD.getAs<Decl>());
4884 // Enter the tag context.
4885 PushDeclContext(S, Tag);
4888 void Sema::ActOnStartCXXMemberDeclarations(Scope *S, DeclPtrTy TagD,
4889 SourceLocation LBraceLoc) {
4890 AdjustDeclIfTemplate(TagD);
4891 CXXRecordDecl *Record = cast<CXXRecordDecl>(TagD.getAs<Decl>());
4893 FieldCollector->StartClass();
4895 if (!Record->getIdentifier())
4899 // [...] The class-name is also inserted into the scope of the
4900 // class itself; this is known as the injected-class-name. For
4901 // purposes of access checking, the injected-class-name is treated
4902 // as if it were a public member name.
4903 CXXRecordDecl *InjectedClassName
4904 = CXXRecordDecl::Create(Context, Record->getTagKind(),
4905 CurContext, Record->getLocation(),
4906 Record->getIdentifier(),
4907 Record->getTagKeywordLoc(),
4909 InjectedClassName->setImplicit();
4910 InjectedClassName->setAccess(AS_public);
4911 if (ClassTemplateDecl *Template = Record->getDescribedClassTemplate())
4912 InjectedClassName->setDescribedClassTemplate(Template);
4913 PushOnScopeChains(InjectedClassName, S);
4914 assert(InjectedClassName->isInjectedClassName() &&
4915 "Broken injected-class-name");
4918 // Traverses the class and any nested classes, making a note of any
4919 // dynamic classes that have no key function so that we can mark all of
4920 // their virtual member functions as "used" at the end of the translation
4921 // unit. This ensures that all functions needed by the vtable will get
4922 // instantiated/synthesized.
4924 RecordDynamicClassesWithNoKeyFunction(Sema &S, CXXRecordDecl *Record,
4925 SourceLocation Loc) {
4926 // We don't look at dependent or undefined classes.
4927 if (Record->isDependentContext() || !Record->isDefinition())
4930 if (Record->isDynamicClass() && !S.Context.getKeyFunction(Record))
4931 S.ClassesWithUnmarkedVirtualMembers.push_back(std::make_pair(Record, Loc));
4933 for (DeclContext::decl_iterator D = Record->decls_begin(),
4934 DEnd = Record->decls_end();
4936 if (CXXRecordDecl *Nested = dyn_cast<CXXRecordDecl>(*D))
4937 RecordDynamicClassesWithNoKeyFunction(S, Nested, Loc);
4941 void Sema::ActOnTagFinishDefinition(Scope *S, DeclPtrTy TagD,
4942 SourceLocation RBraceLoc) {
4943 AdjustDeclIfTemplate(TagD);
4944 TagDecl *Tag = cast<TagDecl>(TagD.getAs<Decl>());
4945 Tag->setRBraceLoc(RBraceLoc);
4947 if (isa<CXXRecordDecl>(Tag))
4948 FieldCollector->FinishClass();
4950 // Exit this scope of this tag's definition.
4953 if (isa<CXXRecordDecl>(Tag) && !Tag->getDeclContext()->isRecord())
4954 RecordDynamicClassesWithNoKeyFunction(*this, cast<CXXRecordDecl>(Tag),
4957 // Notify the consumer that we've defined a tag.
4958 Consumer.HandleTagDeclDefinition(Tag);
4961 // Note that FieldName may be null for anonymous bitfields.
4962 bool Sema::VerifyBitField(SourceLocation FieldLoc, IdentifierInfo *FieldName,
4963 QualType FieldTy, const Expr *BitWidth,
4965 // Default to true; that shouldn't confuse checks for emptiness
4969 // C99 6.7.2.1p4 - verify the field type.
4970 // C++ 9.6p3: A bit-field shall have integral or enumeration type.
4971 if (!FieldTy->isDependentType() && !FieldTy->isIntegralType()) {
4972 // Handle incomplete types with specific error.
4973 if (RequireCompleteType(FieldLoc, FieldTy, diag::err_field_incomplete))
4976 return Diag(FieldLoc, diag::err_not_integral_type_bitfield)
4977 << FieldName << FieldTy << BitWidth->getSourceRange();
4978 return Diag(FieldLoc, diag::err_not_integral_type_anon_bitfield)
4979 << FieldTy << BitWidth->getSourceRange();
4982 // If the bit-width is type- or value-dependent, don't try to check
4984 if (BitWidth->isValueDependent() || BitWidth->isTypeDependent())
4988 if (VerifyIntegerConstantExpression(BitWidth, &Value))
4991 if (Value != 0 && ZeroWidth)
4994 // Zero-width bitfield is ok for anonymous field.
4995 if (Value == 0 && FieldName)
4996 return Diag(FieldLoc, diag::err_bitfield_has_zero_width) << FieldName;
4998 if (Value.isSigned() && Value.isNegative()) {
5000 return Diag(FieldLoc, diag::err_bitfield_has_negative_width)
5001 << FieldName << Value.toString(10);
5002 return Diag(FieldLoc, diag::err_anon_bitfield_has_negative_width)
5003 << Value.toString(10);
5006 if (!FieldTy->isDependentType()) {
5007 uint64_t TypeSize = Context.getTypeSize(FieldTy);
5008 if (Value.getZExtValue() > TypeSize) {
5010 return Diag(FieldLoc, diag::err_bitfield_width_exceeds_type_size)
5011 << FieldName << (unsigned)TypeSize;
5012 return Diag(FieldLoc, diag::err_anon_bitfield_width_exceeds_type_size)
5013 << (unsigned)TypeSize;
5020 /// ActOnField - Each field of a struct/union/class is passed into this in order
5021 /// to create a FieldDecl object for it.
5022 Sema::DeclPtrTy Sema::ActOnField(Scope *S, DeclPtrTy TagD,
5023 SourceLocation DeclStart,
5024 Declarator &D, ExprTy *BitfieldWidth) {
5025 FieldDecl *Res = HandleField(S, cast_or_null<RecordDecl>(TagD.getAs<Decl>()),
5026 DeclStart, D, static_cast<Expr*>(BitfieldWidth),
5028 return DeclPtrTy::make(Res);
5031 /// HandleField - Analyze a field of a C struct or a C++ data member.
5033 FieldDecl *Sema::HandleField(Scope *S, RecordDecl *Record,
5034 SourceLocation DeclStart,
5035 Declarator &D, Expr *BitWidth,
5036 AccessSpecifier AS) {
5037 IdentifierInfo *II = D.getIdentifier();
5038 SourceLocation Loc = DeclStart;
5039 if (II) Loc = D.getIdentifierLoc();
5041 TypeSourceInfo *TInfo = 0;
5042 QualType T = GetTypeForDeclarator(D, S, &TInfo);
5043 if (getLangOptions().CPlusPlus)
5044 CheckExtraCXXDefaultArguments(D);
5046 DiagnoseFunctionSpecifiers(D);
5048 if (D.getDeclSpec().isThreadSpecified())
5049 Diag(D.getDeclSpec().getThreadSpecLoc(), diag::err_invalid_thread);
5051 NamedDecl *PrevDecl = LookupSingleName(S, II, LookupMemberName,
5054 if (PrevDecl && PrevDecl->isTemplateParameter()) {
5055 // Maybe we will complain about the shadowed template parameter.
5056 DiagnoseTemplateParameterShadow(D.getIdentifierLoc(), PrevDecl);
5057 // Just pretend that we didn't see the previous declaration.
5061 if (PrevDecl && !isDeclInScope(PrevDecl, Record, S))
5065 = (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_mutable);
5066 SourceLocation TSSL = D.getSourceRange().getBegin();
5068 = CheckFieldDecl(II, T, TInfo, Record, Loc, Mutable, BitWidth, TSSL,
5070 if (NewFD->isInvalidDecl() && PrevDecl) {
5071 // Don't introduce NewFD into scope; there's already something
5072 // with the same name in the same scope.
5074 PushOnScopeChains(NewFD, S);
5076 Record->addDecl(NewFD);
5081 /// \brief Build a new FieldDecl and check its well-formedness.
5083 /// This routine builds a new FieldDecl given the fields name, type,
5084 /// record, etc. \p PrevDecl should refer to any previous declaration
5085 /// with the same name and in the same scope as the field to be
5088 /// \returns a new FieldDecl.
5090 /// \todo The Declarator argument is a hack. It will be removed once
5091 FieldDecl *Sema::CheckFieldDecl(DeclarationName Name, QualType T,
5092 TypeSourceInfo *TInfo,
5093 RecordDecl *Record, SourceLocation Loc,
5094 bool Mutable, Expr *BitWidth,
5095 SourceLocation TSSL,
5096 AccessSpecifier AS, NamedDecl *PrevDecl,
5098 IdentifierInfo *II = Name.getAsIdentifierInfo();
5099 bool InvalidDecl = false;
5100 if (D) InvalidDecl = D->isInvalidType();
5102 // If we receive a broken type, recover by assuming 'int' and
5103 // marking this declaration as invalid.
5109 QualType EltTy = Context.getBaseElementType(T);
5110 if (!EltTy->isDependentType() &&
5111 RequireCompleteType(Loc, EltTy, diag::err_field_incomplete))
5114 // C99 6.7.2.1p8: A member of a structure or union may have any type other
5115 // than a variably modified type.
5116 if (!InvalidDecl && T->isVariablyModifiedType()) {
5117 bool SizeIsNegative;
5118 QualType FixedTy = TryToFixInvalidVariablyModifiedType(T, Context,
5120 if (!FixedTy.isNull()) {
5121 Diag(Loc, diag::warn_illegal_constant_array_size);
5125 Diag(Loc, diag::err_typecheck_negative_array_size);
5127 Diag(Loc, diag::err_typecheck_field_variable_size);
5132 // Fields can not have abstract class types
5133 if (!InvalidDecl && RequireNonAbstractType(Loc, T,
5134 diag::err_abstract_type_in_decl,
5138 bool ZeroWidth = false;
5139 // If this is declared as a bit-field, check the bit-field.
5140 if (!InvalidDecl && BitWidth &&
5141 VerifyBitField(Loc, II, T, BitWidth, &ZeroWidth)) {
5143 DeleteExpr(BitWidth);
5148 FieldDecl *NewFD = FieldDecl::Create(Context, Record, Loc, II, T, TInfo,
5151 NewFD->setInvalidDecl();
5153 if (PrevDecl && !isa<TagDecl>(PrevDecl)) {
5154 Diag(Loc, diag::err_duplicate_member) << II;
5155 Diag(PrevDecl->getLocation(), diag::note_previous_declaration);
5156 NewFD->setInvalidDecl();
5159 if (getLangOptions().CPlusPlus) {
5160 CXXRecordDecl* CXXRecord = cast<CXXRecordDecl>(Record);
5162 if (!T->isPODType())
5163 CXXRecord->setPOD(false);
5165 CXXRecord->setEmpty(false);
5167 if (const RecordType *RT = EltTy->getAs<RecordType>()) {
5168 CXXRecordDecl* RDecl = cast<CXXRecordDecl>(RT->getDecl());
5170 if (!RDecl->hasTrivialConstructor())
5171 CXXRecord->setHasTrivialConstructor(false);
5172 if (!RDecl->hasTrivialCopyConstructor())
5173 CXXRecord->setHasTrivialCopyConstructor(false);
5174 if (!RDecl->hasTrivialCopyAssignment())
5175 CXXRecord->setHasTrivialCopyAssignment(false);
5176 if (!RDecl->hasTrivialDestructor())
5177 CXXRecord->setHasTrivialDestructor(false);
5179 // C++ 9.5p1: An object of a class with a non-trivial
5180 // constructor, a non-trivial copy constructor, a non-trivial
5181 // destructor, or a non-trivial copy assignment operator
5182 // cannot be a member of a union, nor can an array of such
5184 // TODO: C++0x alters this restriction significantly.
5185 if (Record->isUnion()) {
5186 // We check for copy constructors before constructors
5187 // because otherwise we'll never get complaints about
5188 // copy constructors.
5190 const CXXSpecialMember invalid = (CXXSpecialMember) -1;
5192 CXXSpecialMember member;
5193 if (!RDecl->hasTrivialCopyConstructor())
5194 member = CXXCopyConstructor;
5195 else if (!RDecl->hasTrivialConstructor())
5196 member = CXXDefaultConstructor;
5197 else if (!RDecl->hasTrivialCopyAssignment())
5198 member = CXXCopyAssignment;
5199 else if (!RDecl->hasTrivialDestructor())
5200 member = CXXDestructor;
5204 if (member != invalid) {
5205 Diag(Loc, diag::err_illegal_union_member) << Name << member;
5206 DiagnoseNontrivial(RT, member);
5207 NewFD->setInvalidDecl();
5213 // FIXME: We need to pass in the attributes given an AST
5214 // representation, not a parser representation.
5216 // FIXME: What to pass instead of TUScope?
5217 ProcessDeclAttributes(TUScope, NewFD, *D);
5219 if (T.isObjCGCWeak())
5220 Diag(Loc, diag::warn_attribute_weak_on_field);
5222 NewFD->setAccess(AS);
5224 // C++ [dcl.init.aggr]p1:
5225 // An aggregate is an array or a class (clause 9) with [...] no
5226 // private or protected non-static data members (clause 11).
5227 // A POD must be an aggregate.
5228 if (getLangOptions().CPlusPlus &&
5229 (AS == AS_private || AS == AS_protected)) {
5230 CXXRecordDecl *CXXRecord = cast<CXXRecordDecl>(Record);
5231 CXXRecord->setAggregate(false);
5232 CXXRecord->setPOD(false);
5238 /// DiagnoseNontrivial - Given that a class has a non-trivial
5239 /// special member, figure out why.
5240 void Sema::DiagnoseNontrivial(const RecordType* T, CXXSpecialMember member) {
5242 CXXRecordDecl* RD = cast<CXXRecordDecl>(T->getDecl());
5244 // Check whether the member was user-declared.
5246 case CXXDefaultConstructor:
5247 if (RD->hasUserDeclaredConstructor()) {
5248 typedef CXXRecordDecl::ctor_iterator ctor_iter;
5249 for (ctor_iter ci = RD->ctor_begin(), ce = RD->ctor_end(); ci != ce;++ci){
5250 const FunctionDecl *body = 0;
5253 !cast<CXXConstructorDecl>(body)->isImplicitlyDefined(Context)) {
5254 SourceLocation CtorLoc = ci->getLocation();
5255 Diag(CtorLoc, diag::note_nontrivial_user_defined) << QT << member;
5260 assert(0 && "found no user-declared constructors");
5265 case CXXCopyConstructor:
5266 if (RD->hasUserDeclaredCopyConstructor()) {
5267 SourceLocation CtorLoc =
5268 RD->getCopyConstructor(Context, 0)->getLocation();
5269 Diag(CtorLoc, diag::note_nontrivial_user_defined) << QT << member;
5274 case CXXCopyAssignment:
5275 if (RD->hasUserDeclaredCopyAssignment()) {
5276 // FIXME: this should use the location of the copy
5277 // assignment, not the type.
5278 SourceLocation TyLoc = RD->getSourceRange().getBegin();
5279 Diag(TyLoc, diag::note_nontrivial_user_defined) << QT << member;
5285 if (RD->hasUserDeclaredDestructor()) {
5286 SourceLocation DtorLoc = RD->getDestructor(Context)->getLocation();
5287 Diag(DtorLoc, diag::note_nontrivial_user_defined) << QT << member;
5293 typedef CXXRecordDecl::base_class_iterator base_iter;
5295 // Virtual bases and members inhibit trivial copying/construction,
5296 // but not trivial destruction.
5297 if (member != CXXDestructor) {
5298 // Check for virtual bases. vbases includes indirect virtual bases,
5299 // so we just iterate through the direct bases.
5300 for (base_iter bi = RD->bases_begin(), be = RD->bases_end(); bi != be; ++bi)
5301 if (bi->isVirtual()) {
5302 SourceLocation BaseLoc = bi->getSourceRange().getBegin();
5303 Diag(BaseLoc, diag::note_nontrivial_has_virtual) << QT << 1;
5307 // Check for virtual methods.
5308 typedef CXXRecordDecl::method_iterator meth_iter;
5309 for (meth_iter mi = RD->method_begin(), me = RD->method_end(); mi != me;
5311 if (mi->isVirtual()) {
5312 SourceLocation MLoc = mi->getSourceRange().getBegin();
5313 Diag(MLoc, diag::note_nontrivial_has_virtual) << QT << 0;
5319 bool (CXXRecordDecl::*hasTrivial)() const;
5321 case CXXDefaultConstructor:
5322 hasTrivial = &CXXRecordDecl::hasTrivialConstructor; break;
5323 case CXXCopyConstructor:
5324 hasTrivial = &CXXRecordDecl::hasTrivialCopyConstructor; break;
5325 case CXXCopyAssignment:
5326 hasTrivial = &CXXRecordDecl::hasTrivialCopyAssignment; break;
5328 hasTrivial = &CXXRecordDecl::hasTrivialDestructor; break;
5330 assert(0 && "unexpected special member"); return;
5333 // Check for nontrivial bases (and recurse).
5334 for (base_iter bi = RD->bases_begin(), be = RD->bases_end(); bi != be; ++bi) {
5335 const RecordType *BaseRT = bi->getType()->getAs<RecordType>();
5336 assert(BaseRT && "Don't know how to handle dependent bases");
5337 CXXRecordDecl *BaseRecTy = cast<CXXRecordDecl>(BaseRT->getDecl());
5338 if (!(BaseRecTy->*hasTrivial)()) {
5339 SourceLocation BaseLoc = bi->getSourceRange().getBegin();
5340 Diag(BaseLoc, diag::note_nontrivial_has_nontrivial) << QT << 1 << member;
5341 DiagnoseNontrivial(BaseRT, member);
5346 // Check for nontrivial members (and recurse).
5347 typedef RecordDecl::field_iterator field_iter;
5348 for (field_iter fi = RD->field_begin(), fe = RD->field_end(); fi != fe;
5350 QualType EltTy = Context.getBaseElementType((*fi)->getType());
5351 if (const RecordType *EltRT = EltTy->getAs<RecordType>()) {
5352 CXXRecordDecl* EltRD = cast<CXXRecordDecl>(EltRT->getDecl());
5354 if (!(EltRD->*hasTrivial)()) {
5355 SourceLocation FLoc = (*fi)->getLocation();
5356 Diag(FLoc, diag::note_nontrivial_has_nontrivial) << QT << 0 << member;
5357 DiagnoseNontrivial(EltRT, member);
5363 assert(0 && "found no explanation for non-trivial member");
5366 /// TranslateIvarVisibility - Translate visibility from a token ID to an
5368 static ObjCIvarDecl::AccessControl
5369 TranslateIvarVisibility(tok::ObjCKeywordKind ivarVisibility) {
5370 switch (ivarVisibility) {
5371 default: assert(0 && "Unknown visitibility kind");
5372 case tok::objc_private: return ObjCIvarDecl::Private;
5373 case tok::objc_public: return ObjCIvarDecl::Public;
5374 case tok::objc_protected: return ObjCIvarDecl::Protected;
5375 case tok::objc_package: return ObjCIvarDecl::Package;
5379 /// ActOnIvar - Each ivar field of an objective-c class is passed into this
5380 /// in order to create an IvarDecl object for it.
5381 Sema::DeclPtrTy Sema::ActOnIvar(Scope *S,
5382 SourceLocation DeclStart,
5384 Declarator &D, ExprTy *BitfieldWidth,
5385 tok::ObjCKeywordKind Visibility) {
5387 IdentifierInfo *II = D.getIdentifier();
5388 Expr *BitWidth = (Expr*)BitfieldWidth;
5389 SourceLocation Loc = DeclStart;
5390 if (II) Loc = D.getIdentifierLoc();
5392 // FIXME: Unnamed fields can be handled in various different ways, for
5393 // example, unnamed unions inject all members into the struct namespace!
5395 TypeSourceInfo *TInfo = 0;
5396 QualType T = GetTypeForDeclarator(D, S, &TInfo);
5399 // 6.7.2.1p3, 6.7.2.1p4
5400 if (VerifyBitField(Loc, II, T, BitWidth)) {
5402 DeleteExpr(BitWidth);
5412 // C99 6.7.2.1p8: A member of a structure or union may have any type other
5413 // than a variably modified type.
5414 if (T->isVariablyModifiedType()) {
5415 Diag(Loc, diag::err_typecheck_ivar_variable_size);
5419 // Get the visibility (access control) for this ivar.
5420 ObjCIvarDecl::AccessControl ac =
5421 Visibility != tok::objc_not_keyword ? TranslateIvarVisibility(Visibility)
5422 : ObjCIvarDecl::None;
5423 // Must set ivar's DeclContext to its enclosing interface.
5424 Decl *EnclosingDecl = IntfDecl.getAs<Decl>();
5425 DeclContext *EnclosingContext;
5426 if (ObjCImplementationDecl *IMPDecl =
5427 dyn_cast<ObjCImplementationDecl>(EnclosingDecl)) {
5428 // Case of ivar declared in an implementation. Context is that of its class.
5429 ObjCInterfaceDecl* IDecl = IMPDecl->getClassInterface();
5430 assert(IDecl && "No class- ActOnIvar");
5431 EnclosingContext = cast_or_null<DeclContext>(IDecl);
5433 EnclosingContext = dyn_cast<DeclContext>(EnclosingDecl);
5434 assert(EnclosingContext && "null DeclContext for ivar - ActOnIvar");
5436 // Construct the decl.
5437 ObjCIvarDecl *NewID = ObjCIvarDecl::Create(Context,
5438 EnclosingContext, Loc, II, T,
5439 TInfo, ac, (Expr *)BitfieldWidth);
5442 NamedDecl *PrevDecl = LookupSingleName(S, II, LookupMemberName,
5444 if (PrevDecl && isDeclInScope(PrevDecl, EnclosingContext, S)
5445 && !isa<TagDecl>(PrevDecl)) {
5446 Diag(Loc, diag::err_duplicate_member) << II;
5447 Diag(PrevDecl->getLocation(), diag::note_previous_declaration);
5448 NewID->setInvalidDecl();
5452 // Process attributes attached to the ivar.
5453 ProcessDeclAttributes(S, NewID, D);
5455 if (D.isInvalidType())
5456 NewID->setInvalidDecl();
5459 // FIXME: When interfaces are DeclContexts, we'll need to add
5460 // these to the interface.
5461 S->AddDecl(DeclPtrTy::make(NewID));
5462 IdResolver.AddDecl(NewID);
5465 return DeclPtrTy::make(NewID);
5468 void Sema::ActOnFields(Scope* S,
5469 SourceLocation RecLoc, DeclPtrTy RecDecl,
5470 DeclPtrTy *Fields, unsigned NumFields,
5471 SourceLocation LBrac, SourceLocation RBrac,
5472 AttributeList *Attr) {
5473 Decl *EnclosingDecl = RecDecl.getAs<Decl>();
5474 assert(EnclosingDecl && "missing record or interface decl");
5476 // If the decl this is being inserted into is invalid, then it may be a
5477 // redeclaration or some other bogus case. Don't try to add fields to it.
5478 if (EnclosingDecl->isInvalidDecl()) {
5479 // FIXME: Deallocate fields?
5484 // Verify that all the fields are okay.
5485 unsigned NumNamedMembers = 0;
5486 llvm::SmallVector<FieldDecl*, 32> RecFields;
5488 RecordDecl *Record = dyn_cast<RecordDecl>(EnclosingDecl);
5489 for (unsigned i = 0; i != NumFields; ++i) {
5490 FieldDecl *FD = cast<FieldDecl>(Fields[i].getAs<Decl>());
5492 // Get the type for the field.
5493 Type *FDTy = FD->getType().getTypePtr();
5495 if (!FD->isAnonymousStructOrUnion()) {
5496 // Remember all fields written by the user.
5497 RecFields.push_back(FD);
5500 // If the field is already invalid for some reason, don't emit more
5501 // diagnostics about it.
5502 if (FD->isInvalidDecl()) {
5503 EnclosingDecl->setInvalidDecl();
5508 // A structure or union shall not contain a member with
5509 // incomplete or function type (hence, a structure shall not
5510 // contain an instance of itself, but may contain a pointer to
5511 // an instance of itself), except that the last member of a
5512 // structure with more than one named member may have incomplete
5513 // array type; such a structure (and any union containing,
5514 // possibly recursively, a member that is such a structure)
5515 // shall not be a member of a structure or an element of an
5517 if (FDTy->isFunctionType()) {
5518 // Field declared as a function.
5519 Diag(FD->getLocation(), diag::err_field_declared_as_function)
5520 << FD->getDeclName();
5521 FD->setInvalidDecl();
5522 EnclosingDecl->setInvalidDecl();
5524 } else if (FDTy->isIncompleteArrayType() && i == NumFields - 1 &&
5525 Record && Record->isStruct()) {
5526 // Flexible array member.
5527 if (NumNamedMembers < 1) {
5528 Diag(FD->getLocation(), diag::err_flexible_array_empty_struct)
5529 << FD->getDeclName();
5530 FD->setInvalidDecl();
5531 EnclosingDecl->setInvalidDecl();
5534 // Okay, we have a legal flexible array member at the end of the struct.
5536 Record->setHasFlexibleArrayMember(true);
5537 } else if (!FDTy->isDependentType() &&
5538 RequireCompleteType(FD->getLocation(), FD->getType(),
5539 diag::err_field_incomplete)) {
5541 FD->setInvalidDecl();
5542 EnclosingDecl->setInvalidDecl();
5544 } else if (const RecordType *FDTTy = FDTy->getAs<RecordType>()) {
5545 if (FDTTy->getDecl()->hasFlexibleArrayMember()) {
5546 // If this is a member of a union, then entire union becomes "flexible".
5547 if (Record && Record->isUnion()) {
5548 Record->setHasFlexibleArrayMember(true);
5550 // If this is a struct/class and this is not the last element, reject
5551 // it. Note that GCC supports variable sized arrays in the middle of
5553 if (i != NumFields-1)
5554 Diag(FD->getLocation(), diag::ext_variable_sized_type_in_struct)
5555 << FD->getDeclName() << FD->getType();
5557 // We support flexible arrays at the end of structs in
5558 // other structs as an extension.
5559 Diag(FD->getLocation(), diag::ext_flexible_array_in_struct)
5560 << FD->getDeclName();
5562 Record->setHasFlexibleArrayMember(true);
5566 if (Record && FDTTy->getDecl()->hasObjectMember())
5567 Record->setHasObjectMember(true);
5568 } else if (FDTy->isObjCInterfaceType()) {
5569 /// A field cannot be an Objective-c object
5570 Diag(FD->getLocation(), diag::err_statically_allocated_object);
5571 FD->setInvalidDecl();
5572 EnclosingDecl->setInvalidDecl();
5574 } else if (getLangOptions().ObjC1 &&
5575 getLangOptions().getGCMode() != LangOptions::NonGC &&
5577 (FD->getType()->isObjCObjectPointerType() ||
5578 FD->getType().isObjCGCStrong()))
5579 Record->setHasObjectMember(true);
5580 // Keep track of the number of named members.
5581 if (FD->getIdentifier())
5585 // Okay, we successfully defined 'Record'.
5587 Record->completeDefinition(Context);
5589 ObjCIvarDecl **ClsFields =
5590 reinterpret_cast<ObjCIvarDecl**>(RecFields.data());
5591 if (ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(EnclosingDecl)) {
5592 ID->setIVarList(ClsFields, RecFields.size(), Context);
5593 ID->setLocEnd(RBrac);
5594 // Add ivar's to class's DeclContext.
5595 for (unsigned i = 0, e = RecFields.size(); i != e; ++i) {
5596 ClsFields[i]->setLexicalDeclContext(ID);
5597 ID->addDecl(ClsFields[i]);
5599 // Must enforce the rule that ivars in the base classes may not be
5601 if (ID->getSuperClass()) {
5602 for (ObjCInterfaceDecl::ivar_iterator IVI = ID->ivar_begin(),
5603 IVE = ID->ivar_end(); IVI != IVE; ++IVI) {
5604 ObjCIvarDecl* Ivar = (*IVI);
5606 if (IdentifierInfo *II = Ivar->getIdentifier()) {
5607 ObjCIvarDecl* prevIvar =
5608 ID->getSuperClass()->lookupInstanceVariable(II);
5610 Diag(Ivar->getLocation(), diag::err_duplicate_member) << II;
5611 Diag(prevIvar->getLocation(), diag::note_previous_declaration);
5616 } else if (ObjCImplementationDecl *IMPDecl =
5617 dyn_cast<ObjCImplementationDecl>(EnclosingDecl)) {
5618 assert(IMPDecl && "ActOnFields - missing ObjCImplementationDecl");
5619 for (unsigned I = 0, N = RecFields.size(); I != N; ++I)
5620 // Ivar declared in @implementation never belongs to the implementation.
5621 // Only it is in implementation's lexical context.
5622 ClsFields[I]->setLexicalDeclContext(IMPDecl);
5623 CheckImplementationIvars(IMPDecl, ClsFields, RecFields.size(), RBrac);
5628 ProcessDeclAttributeList(S, Record, Attr);
5631 EnumConstantDecl *Sema::CheckEnumConstant(EnumDecl *Enum,
5632 EnumConstantDecl *LastEnumConst,
5633 SourceLocation IdLoc,
5636 Expr *Val = (Expr *)val.get();
5638 llvm::APSInt EnumVal(32);
5641 if (Enum->isDependentType())
5642 EltTy = Context.DependentTy;
5644 // Make sure to promote the operand type to int.
5645 UsualUnaryConversions(Val);
5646 if (Val != val.get()) {
5651 // C99 6.7.2.2p2: Make sure we have an integer constant expression.
5652 SourceLocation ExpLoc;
5653 if (VerifyIntegerConstantExpression(Val, &EnumVal)) {
5656 EltTy = Val->getType();
5662 if (Enum->isDependentType())
5663 EltTy = Context.DependentTy;
5664 else if (LastEnumConst) {
5665 // Assign the last value + 1.
5666 EnumVal = LastEnumConst->getInitVal();
5669 // Check for overflow on increment.
5670 if (EnumVal < LastEnumConst->getInitVal())
5671 Diag(IdLoc, diag::warn_enum_value_overflow);
5673 EltTy = LastEnumConst->getType();
5675 // First value, set to zero.
5676 EltTy = Context.IntTy;
5677 EnumVal.zextOrTrunc(static_cast<uint32_t>(Context.getTypeSize(EltTy)));
5678 EnumVal.setIsSigned(true);
5682 assert(!EltTy.isNull() && "Enum constant with NULL type");
5685 return EnumConstantDecl::Create(Context, Enum, IdLoc, Id, EltTy,
5690 Sema::DeclPtrTy Sema::ActOnEnumConstant(Scope *S, DeclPtrTy theEnumDecl,
5691 DeclPtrTy lastEnumConst,
5692 SourceLocation IdLoc,
5694 SourceLocation EqualLoc, ExprTy *val) {
5695 EnumDecl *TheEnumDecl = cast<EnumDecl>(theEnumDecl.getAs<Decl>());
5696 EnumConstantDecl *LastEnumConst =
5697 cast_or_null<EnumConstantDecl>(lastEnumConst.getAs<Decl>());
5698 Expr *Val = static_cast<Expr*>(val);
5700 // The scope passed in may not be a decl scope. Zip up the scope tree until
5701 // we find one that is.
5702 S = getNonFieldDeclScope(S);
5704 // Verify that there isn't already something declared with this name in this
5706 NamedDecl *PrevDecl = LookupSingleName(S, Id, LookupOrdinaryName,
5708 if (PrevDecl && PrevDecl->isTemplateParameter()) {
5709 // Maybe we will complain about the shadowed template parameter.
5710 DiagnoseTemplateParameterShadow(IdLoc, PrevDecl);
5711 // Just pretend that we didn't see the previous declaration.
5716 // When in C++, we may get a TagDecl with the same name; in this case the
5717 // enum constant will 'hide' the tag.
5718 assert((getLangOptions().CPlusPlus || !isa<TagDecl>(PrevDecl)) &&
5719 "Received TagDecl when not in C++!");
5720 if (!isa<TagDecl>(PrevDecl) && isDeclInScope(PrevDecl, CurContext, S)) {
5721 if (isa<EnumConstantDecl>(PrevDecl))
5722 Diag(IdLoc, diag::err_redefinition_of_enumerator) << Id;
5724 Diag(IdLoc, diag::err_redefinition) << Id;
5725 Diag(PrevDecl->getLocation(), diag::note_previous_definition);
5726 if (Val) Val->Destroy(Context);
5731 EnumConstantDecl *New = CheckEnumConstant(TheEnumDecl, LastEnumConst,
5732 IdLoc, Id, Owned(Val));
5734 // Register this decl in the current scope stack.
5736 New->setAccess(TheEnumDecl->getAccess());
5737 PushOnScopeChains(New, S);
5740 return DeclPtrTy::make(New);
5743 void Sema::ActOnEnumBody(SourceLocation EnumLoc, SourceLocation LBraceLoc,
5744 SourceLocation RBraceLoc, DeclPtrTy EnumDeclX,
5745 DeclPtrTy *Elements, unsigned NumElements,
5746 Scope *S, AttributeList *Attr) {
5747 EnumDecl *Enum = cast<EnumDecl>(EnumDeclX.getAs<Decl>());
5748 QualType EnumType = Context.getTypeDeclType(Enum);
5751 ProcessDeclAttributeList(S, Enum, Attr);
5753 if (Enum->isDependentType()) {
5754 for (unsigned i = 0; i != NumElements; ++i) {
5755 EnumConstantDecl *ECD =
5756 cast_or_null<EnumConstantDecl>(Elements[i].getAs<Decl>());
5759 ECD->setType(EnumType);
5762 Enum->completeDefinition(Context, Context.DependentTy, Context.DependentTy);
5766 // TODO: If the result value doesn't fit in an int, it must be a long or long
5767 // long value. ISO C does not support this, but GCC does as an extension,
5769 unsigned IntWidth = Context.Target.getIntWidth();
5770 unsigned CharWidth = Context.Target.getCharWidth();
5771 unsigned ShortWidth = Context.Target.getShortWidth();
5773 // Verify that all the values are okay, compute the size of the values, and
5774 // reverse the list.
5775 unsigned NumNegativeBits = 0;
5776 unsigned NumPositiveBits = 0;
5778 // Keep track of whether all elements have type int.
5779 bool AllElementsInt = true;
5781 for (unsigned i = 0; i != NumElements; ++i) {
5782 EnumConstantDecl *ECD =
5783 cast_or_null<EnumConstantDecl>(Elements[i].getAs<Decl>());
5784 if (!ECD) continue; // Already issued a diagnostic.
5786 // If the enum value doesn't fit in an int, emit an extension warning.
5787 const llvm::APSInt &InitVal = ECD->getInitVal();
5788 assert(InitVal.getBitWidth() >= IntWidth &&
5789 "Should have promoted value to int");
5790 if (!getLangOptions().CPlusPlus && InitVal.getBitWidth() > IntWidth) {
5791 llvm::APSInt V(InitVal);
5793 V.extend(InitVal.getBitWidth());
5795 Diag(ECD->getLocation(), diag::ext_enum_value_not_int)
5796 << InitVal.toString(10);
5799 // Keep track of the size of positive and negative values.
5800 if (InitVal.isUnsigned() || InitVal.isNonNegative())
5801 NumPositiveBits = std::max(NumPositiveBits,
5802 (unsigned)InitVal.getActiveBits());
5804 NumNegativeBits = std::max(NumNegativeBits,
5805 (unsigned)InitVal.getMinSignedBits());
5807 // Keep track of whether every enum element has type int (very commmon).
5809 AllElementsInt = ECD->getType() == Context.IntTy;
5812 // Figure out the type that should be used for this enum.
5813 // FIXME: Support -fshort-enums.
5817 // C++0x N3000 [conv.prom]p3:
5818 // An rvalue of an unscoped enumeration type whose underlying
5819 // type is not fixed can be converted to an rvalue of the first
5820 // of the following types that can represent all the values of
5821 // the enumeration: int, unsigned int, long int, unsigned long
5822 // int, long long int, or unsigned long long int.
5824 // An identifier declared as an enumeration constant has type int.
5825 // The C99 rule is modified by a gcc extension
5826 QualType BestPromotionType;
5828 bool Packed = Enum->getAttr<PackedAttr>() ? true : false;
5830 if (NumNegativeBits) {
5831 // If there is a negative value, figure out the smallest integer type (of
5832 // int/long/longlong) that fits.
5833 // If it's packed, check also if it fits a char or a short.
5834 if (Packed && NumNegativeBits <= CharWidth && NumPositiveBits < CharWidth) {
5835 BestType = Context.SignedCharTy;
5836 BestWidth = CharWidth;
5837 } else if (Packed && NumNegativeBits <= ShortWidth &&
5838 NumPositiveBits < ShortWidth) {
5839 BestType = Context.ShortTy;
5840 BestWidth = ShortWidth;
5841 } else if (NumNegativeBits <= IntWidth && NumPositiveBits < IntWidth) {
5842 BestType = Context.IntTy;
5843 BestWidth = IntWidth;
5845 BestWidth = Context.Target.getLongWidth();
5847 if (NumNegativeBits <= BestWidth && NumPositiveBits < BestWidth) {
5848 BestType = Context.LongTy;
5850 BestWidth = Context.Target.getLongLongWidth();
5852 if (NumNegativeBits > BestWidth || NumPositiveBits >= BestWidth)
5853 Diag(Enum->getLocation(), diag::warn_enum_too_large);
5854 BestType = Context.LongLongTy;
5857 BestPromotionType = (BestWidth <= IntWidth ? Context.IntTy : BestType);
5859 // If there is no negative value, figure out which of uint, ulong, ulonglong
5861 // If it's packed, check also if it fits a char or a short.
5862 if (Packed && NumPositiveBits <= CharWidth) {
5863 BestType = Context.UnsignedCharTy;
5864 BestPromotionType = Context.IntTy;
5865 BestWidth = CharWidth;
5866 } else if (Packed && NumPositiveBits <= ShortWidth) {
5867 BestType = Context.UnsignedShortTy;
5868 BestPromotionType = Context.IntTy;
5869 BestWidth = ShortWidth;
5870 } else if (NumPositiveBits <= IntWidth) {
5871 BestType = Context.UnsignedIntTy;
5872 BestWidth = IntWidth;
5873 BestPromotionType = (NumPositiveBits == BestWidth
5874 ? Context.UnsignedIntTy : Context.IntTy);
5875 } else if (NumPositiveBits <=
5876 (BestWidth = Context.Target.getLongWidth())) {
5877 BestType = Context.UnsignedLongTy;
5878 BestPromotionType = (NumPositiveBits == BestWidth
5879 ? Context.UnsignedLongTy : Context.LongTy);
5881 BestWidth = Context.Target.getLongLongWidth();
5882 assert(NumPositiveBits <= BestWidth &&
5883 "How could an initializer get larger than ULL?");
5884 BestType = Context.UnsignedLongLongTy;
5885 BestPromotionType = (NumPositiveBits == BestWidth
5886 ? Context.UnsignedLongLongTy : Context.LongLongTy);
5890 // If we're in C and the promotion type is larger than an int, just
5891 // use the underlying type, which is generally the unsigned integer
5892 // type of the same rank as the promotion type. This is how the gcc
5894 if (!getLangOptions().CPlusPlus && BestPromotionType != Context.IntTy)
5895 BestPromotionType = BestType;
5897 // Loop over all of the enumerator constants, changing their types to match
5898 // the type of the enum if needed.
5899 for (unsigned i = 0; i != NumElements; ++i) {
5900 EnumConstantDecl *ECD =
5901 cast_or_null<EnumConstantDecl>(Elements[i].getAs<Decl>());
5902 if (!ECD) continue; // Already issued a diagnostic.
5904 // Standard C says the enumerators have int type, but we allow, as an
5905 // extension, the enumerators to be larger than int size. If each
5906 // enumerator value fits in an int, type it as an int, otherwise type it the
5907 // same as the enumerator decl itself. This means that in "enum { X = 1U }"
5908 // that X has type 'int', not 'unsigned'.
5909 if (!getLangOptions().CPlusPlus && ECD->getType() == Context.IntTy)
5912 // Determine whether the value fits into an int.
5913 llvm::APSInt InitVal = ECD->getInitVal();
5915 if (InitVal.isUnsigned() || !InitVal.isNegative())
5916 FitsInInt = InitVal.getActiveBits() < IntWidth;
5918 FitsInInt = InitVal.getMinSignedBits() <= IntWidth;
5920 // If it fits into an integer type, force it. Otherwise force it to match
5921 // the enum decl type.
5925 if (FitsInInt && !getLangOptions().CPlusPlus) {
5926 NewTy = Context.IntTy;
5927 NewWidth = IntWidth;
5929 } else if (ECD->getType() == BestType) {
5930 // Already the right type!
5931 if (getLangOptions().CPlusPlus)
5932 // C++ [dcl.enum]p4: Following the closing brace of an
5933 // enum-specifier, each enumerator has the type of its
5935 ECD->setType(EnumType);
5939 NewWidth = BestWidth;
5940 NewSign = BestType->isSignedIntegerType();
5943 // Adjust the APSInt value.
5944 InitVal.extOrTrunc(NewWidth);
5945 InitVal.setIsSigned(NewSign);
5946 ECD->setInitVal(InitVal);
5948 // Adjust the Expr initializer and type.
5949 if (ECD->getInitExpr())
5950 ECD->setInitExpr(new (Context) ImplicitCastExpr(NewTy,
5951 CastExpr::CK_IntegralCast,
5953 /*isLvalue=*/false));
5954 if (getLangOptions().CPlusPlus)
5955 // C++ [dcl.enum]p4: Following the closing brace of an
5956 // enum-specifier, each enumerator has the type of its
5958 ECD->setType(EnumType);
5960 ECD->setType(NewTy);
5963 Enum->completeDefinition(Context, BestType, BestPromotionType);
5966 Sema::DeclPtrTy Sema::ActOnFileScopeAsmDecl(SourceLocation Loc,
5968 StringLiteral *AsmString = cast<StringLiteral>(expr.takeAs<Expr>());
5970 FileScopeAsmDecl *New = FileScopeAsmDecl::Create(Context, CurContext,
5972 CurContext->addDecl(New);
5973 return DeclPtrTy::make(New);
5976 void Sema::ActOnPragmaWeakID(IdentifierInfo* Name,
5977 SourceLocation PragmaLoc,
5978 SourceLocation NameLoc) {
5979 Decl *PrevDecl = LookupSingleName(TUScope, Name, LookupOrdinaryName);
5982 PrevDecl->addAttr(::new (Context) WeakAttr());
5984 (void)WeakUndeclaredIdentifiers.insert(
5985 std::pair<IdentifierInfo*,WeakInfo>
5986 (Name, WeakInfo((IdentifierInfo*)0, NameLoc)));
5990 void Sema::ActOnPragmaWeakAlias(IdentifierInfo* Name,
5991 IdentifierInfo* AliasName,
5992 SourceLocation PragmaLoc,
5993 SourceLocation NameLoc,
5994 SourceLocation AliasNameLoc) {
5995 Decl *PrevDecl = LookupSingleName(TUScope, AliasName, LookupOrdinaryName);
5996 WeakInfo W = WeakInfo(Name, NameLoc);
5999 if (!PrevDecl->hasAttr<AliasAttr>())
6000 if (NamedDecl *ND = dyn_cast<NamedDecl>(PrevDecl))
6001 DeclApplyPragmaWeak(TUScope, ND, W);
6003 (void)WeakUndeclaredIdentifiers.insert(
6004 std::pair<IdentifierInfo*,WeakInfo>(AliasName, W));