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/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:
138 Result.suppressDiagnostics();
141 case LookupResult::Ambiguous:
142 // Recover from type-hiding ambiguities by hiding the type. We'll
143 // do the lookup again when looking for an object, and we can
144 // diagnose the error then. If we don't do this, then the error
145 // about hiding the type will be immediately followed by an error
146 // that only makes sense if the identifier was treated like a type.
147 if (Result.getAmbiguityKind() == LookupResult::AmbiguousTagHiding) {
148 Result.suppressDiagnostics();
152 // Look to see if we have a type anywhere in the list of results.
153 for (LookupResult::iterator Res = Result.begin(), ResEnd = Result.end();
154 Res != ResEnd; ++Res) {
155 if (isa<TypeDecl>(*Res) || isa<ObjCInterfaceDecl>(*Res)) {
157 (*Res)->getLocation().getRawEncoding() <
158 IIDecl->getLocation().getRawEncoding())
164 // None of the entities we found is a type, so there is no way
165 // to even assume that the result is a type. In this case, don't
166 // complain about the ambiguity. The parser will either try to
167 // perform this lookup again (e.g., as an object name), which
168 // will produce the ambiguity, or will complain that it expected
170 Result.suppressDiagnostics();
174 // We found a type within the ambiguous lookup; diagnose the
175 // ambiguity and then return that type. This might be the right
176 // answer, or it might not be, but it suppresses any attempt to
177 // perform the name lookup again.
180 case LookupResult::Found:
181 IIDecl = Result.getFoundDecl();
185 assert(IIDecl && "Didn't find decl");
188 if (TypeDecl *TD = dyn_cast<TypeDecl>(IIDecl)) {
189 DiagnoseUseOfDecl(IIDecl, NameLoc);
191 // C++ [temp.local]p2:
192 // Within the scope of a class template specialization or
193 // partial specialization, when the injected-class-name is
194 // not followed by a <, it is equivalent to the
195 // injected-class-name followed by the template-argument s
196 // of the class template specialization or partial
197 // specialization enclosed in <>.
198 if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(TD))
199 if (RD->isInjectedClassName())
200 if (ClassTemplateDecl *Template = RD->getDescribedClassTemplate())
201 T = Template->getInjectedClassNameType(Context);
204 T = Context.getTypeDeclType(TD);
207 T = getQualifiedNameType(*SS, T);
209 } else if (ObjCInterfaceDecl *IDecl = dyn_cast<ObjCInterfaceDecl>(IIDecl)) {
210 T = Context.getObjCInterfaceType(IDecl);
211 } else if (UnresolvedUsingTypenameDecl *UUDecl =
212 dyn_cast<UnresolvedUsingTypenameDecl>(IIDecl)) {
213 // FIXME: preserve source structure information.
214 T = Context.getTypenameType(UUDecl->getTargetNestedNameSpecifier(), &II);
216 // If it's not plausibly a type, suppress diagnostics.
217 Result.suppressDiagnostics();
221 return T.getAsOpaquePtr();
224 /// isTagName() - This method is called *for error recovery purposes only*
225 /// to determine if the specified name is a valid tag name ("struct foo"). If
226 /// so, this returns the TST for the tag corresponding to it (TST_enum,
227 /// TST_union, TST_struct, TST_class). This is used to diagnose cases in C
228 /// where the user forgot to specify the tag.
229 DeclSpec::TST Sema::isTagName(IdentifierInfo &II, Scope *S) {
230 // Do a tag name lookup in this scope.
231 LookupResult R(*this, &II, SourceLocation(), LookupTagName);
232 LookupName(R, S, false);
233 R.suppressDiagnostics();
234 if (R.getResultKind() == LookupResult::Found)
235 if (const TagDecl *TD = R.getAsSingle<TagDecl>()) {
236 switch (TD->getTagKind()) {
237 case TagDecl::TK_struct: return DeclSpec::TST_struct;
238 case TagDecl::TK_union: return DeclSpec::TST_union;
239 case TagDecl::TK_class: return DeclSpec::TST_class;
240 case TagDecl::TK_enum: return DeclSpec::TST_enum;
244 return DeclSpec::TST_unspecified;
247 bool Sema::DiagnoseUnknownTypeName(const IdentifierInfo &II,
248 SourceLocation IILoc,
250 const CXXScopeSpec *SS,
251 TypeTy *&SuggestedType) {
252 // We don't have anything to suggest (yet).
255 // There may have been a typo in the name of the type. Look up typo
256 // results, in case we have something that we can suggest.
257 LookupResult Lookup(*this, &II, IILoc, LookupOrdinaryName,
258 NotForRedeclaration);
260 // FIXME: It would be nice if we could correct for typos in built-in
261 // names, such as "itn" for "int".
263 if (CorrectTypo(Lookup, S, SS) && Lookup.isSingleResult()) {
264 NamedDecl *Result = Lookup.getAsSingle<NamedDecl>();
265 if ((isa<TypeDecl>(Result) || isa<ObjCInterfaceDecl>(Result)) &&
266 !Result->isInvalidDecl()) {
267 // We found a similarly-named type or interface; suggest that.
268 if (!SS || !SS->isSet())
269 Diag(IILoc, diag::err_unknown_typename_suggest)
270 << &II << Lookup.getLookupName()
271 << CodeModificationHint::CreateReplacement(SourceRange(IILoc),
272 Result->getNameAsString());
273 else if (DeclContext *DC = computeDeclContext(*SS, false))
274 Diag(IILoc, diag::err_unknown_nested_typename_suggest)
275 << &II << DC << Lookup.getLookupName() << SS->getRange()
276 << CodeModificationHint::CreateReplacement(SourceRange(IILoc),
277 Result->getNameAsString());
279 llvm_unreachable("could not have corrected a typo here");
281 Diag(Result->getLocation(), diag::note_previous_decl)
282 << Result->getDeclName();
284 SuggestedType = getTypeName(*Result->getIdentifier(), IILoc, S, SS);
289 // FIXME: Should we move the logic that tries to recover from a missing tag
290 // (struct, union, enum) from Parser::ParseImplicitInt here, instead?
292 if (!SS || (!SS->isSet() && !SS->isInvalid()))
293 Diag(IILoc, diag::err_unknown_typename) << &II;
294 else if (DeclContext *DC = computeDeclContext(*SS, false))
295 Diag(IILoc, diag::err_typename_nested_not_found)
296 << &II << DC << SS->getRange();
297 else if (isDependentScopeSpecifier(*SS)) {
298 Diag(SS->getRange().getBegin(), diag::err_typename_missing)
299 << (NestedNameSpecifier *)SS->getScopeRep() << II.getName()
300 << SourceRange(SS->getRange().getBegin(), IILoc)
301 << CodeModificationHint::CreateInsertion(SS->getRange().getBegin(),
303 SuggestedType = ActOnTypenameType(SourceLocation(), *SS, II, IILoc).get();
305 assert(SS && SS->isInvalid() &&
306 "Invalid scope specifier has already been diagnosed");
312 // Determines the context to return to after temporarily entering a
313 // context. This depends in an unnecessarily complicated way on the
314 // exact ordering of callbacks from the parser.
315 DeclContext *Sema::getContainingDC(DeclContext *DC) {
317 // Functions defined inline within classes aren't parsed until we've
318 // finished parsing the top-level class, so the top-level class is
319 // the context we'll need to return to.
320 if (isa<FunctionDecl>(DC)) {
321 DC = DC->getLexicalParent();
323 // A function not defined within a class will always return to its
325 if (!isa<CXXRecordDecl>(DC))
328 // A C++ inline method/friend is parsed *after* the topmost class
329 // it was declared in is fully parsed ("complete"); the topmost
330 // class is the context we need to return to.
331 while (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(DC->getLexicalParent()))
334 // Return the declaration context of the topmost class the inline method is
339 if (isa<ObjCMethodDecl>(DC))
340 return Context.getTranslationUnitDecl();
342 return DC->getLexicalParent();
345 void Sema::PushDeclContext(Scope *S, DeclContext *DC) {
346 assert(getContainingDC(DC) == CurContext &&
347 "The next DeclContext should be lexically contained in the current one.");
352 void Sema::PopDeclContext() {
353 assert(CurContext && "DeclContext imbalance!");
355 CurContext = getContainingDC(CurContext);
358 /// EnterDeclaratorContext - Used when we must lookup names in the context
359 /// of a declarator's nested name specifier.
361 void Sema::EnterDeclaratorContext(Scope *S, DeclContext *DC) {
362 // C++0x [basic.lookup.unqual]p13:
363 // A name used in the definition of a static data member of class
364 // X (after the qualified-id of the static member) is looked up as
365 // if the name was used in a member function of X.
366 // C++0x [basic.lookup.unqual]p14:
367 // If a variable member of a namespace is defined outside of the
368 // scope of its namespace then any name used in the definition of
369 // the variable member (after the declarator-id) is looked up as
370 // if the definition of the variable member occurred in its
372 // Both of these imply that we should push a scope whose context
373 // is the semantic context of the declaration. We can't use
374 // PushDeclContext here because that context is not necessarily
375 // lexically contained in the current context. Fortunately,
376 // the containing scope should have the appropriate information.
378 assert(!S->getEntity() && "scope already has entity");
381 Scope *Ancestor = S->getParent();
382 while (!Ancestor->getEntity()) Ancestor = Ancestor->getParent();
383 assert(Ancestor->getEntity() == CurContext && "ancestor context mismatch");
390 void Sema::ExitDeclaratorContext(Scope *S) {
391 assert(S->getEntity() == CurContext && "Context imbalance!");
393 // Switch back to the lexical context. The safety of this is
394 // enforced by an assert in EnterDeclaratorContext.
395 Scope *Ancestor = S->getParent();
396 while (!Ancestor->getEntity()) Ancestor = Ancestor->getParent();
397 CurContext = (DeclContext*) Ancestor->getEntity();
399 // We don't need to do anything with the scope, which is going to
403 /// \brief Determine whether we allow overloading of the function
404 /// PrevDecl with another declaration.
406 /// This routine determines whether overloading is possible, not
407 /// whether some new function is actually an overload. It will return
408 /// true in C++ (where we can always provide overloads) or, as an
409 /// extension, in C when the previous function is already an
410 /// overloaded function declaration or has the "overloadable"
412 static bool AllowOverloadingOfFunction(LookupResult &Previous,
413 ASTContext &Context) {
414 if (Context.getLangOptions().CPlusPlus)
417 if (Previous.getResultKind() == LookupResult::FoundOverloaded)
420 return (Previous.getResultKind() == LookupResult::Found
421 && Previous.getFoundDecl()->hasAttr<OverloadableAttr>());
424 /// Add this decl to the scope shadowed decl chains.
425 void Sema::PushOnScopeChains(NamedDecl *D, Scope *S, bool AddToContext) {
426 // Move up the scope chain until we find the nearest enclosing
427 // non-transparent context. The declaration will be introduced into this
429 while (S->getEntity() &&
430 ((DeclContext *)S->getEntity())->isTransparentContext())
433 // Add scoped declarations into their context, so that they can be
434 // found later. Declarations without a context won't be inserted
437 CurContext->addDecl(D);
439 // Out-of-line definitions shouldn't be pushed into scope in C++.
440 // Out-of-line variable and function definitions shouldn't even in C.
441 if ((getLangOptions().CPlusPlus || isa<VarDecl>(D) || isa<FunctionDecl>(D)) &&
445 // Template instantiations should also not be pushed into scope.
446 if (isa<FunctionDecl>(D) &&
447 cast<FunctionDecl>(D)->isFunctionTemplateSpecialization())
450 // If this replaces anything in the current scope,
451 IdentifierResolver::iterator I = IdResolver.begin(D->getDeclName()),
452 IEnd = IdResolver.end();
453 for (; I != IEnd; ++I) {
454 if (S->isDeclScope(DeclPtrTy::make(*I)) && D->declarationReplaces(*I)) {
455 S->RemoveDecl(DeclPtrTy::make(*I));
456 IdResolver.RemoveDecl(*I);
458 // Should only need to replace one decl.
463 S->AddDecl(DeclPtrTy::make(D));
464 IdResolver.AddDecl(D);
467 bool Sema::isDeclInScope(NamedDecl *&D, DeclContext *Ctx, Scope *S) {
468 return IdResolver.isDeclInScope(D, Ctx, Context, S);
471 static bool isOutOfScopePreviousDeclaration(NamedDecl *,
475 /// Filters out lookup results that don't fall within the given scope
476 /// as determined by isDeclInScope.
477 static void FilterLookupForScope(Sema &SemaRef, LookupResult &R,
478 DeclContext *Ctx, Scope *S,
479 bool ConsiderLinkage) {
480 LookupResult::Filter F = R.makeFilter();
481 while (F.hasNext()) {
482 NamedDecl *D = F.next();
484 if (SemaRef.isDeclInScope(D, Ctx, S))
487 if (ConsiderLinkage &&
488 isOutOfScopePreviousDeclaration(D, Ctx, SemaRef.Context))
497 static bool isUsingDecl(NamedDecl *D) {
498 return isa<UsingShadowDecl>(D) ||
499 isa<UnresolvedUsingTypenameDecl>(D) ||
500 isa<UnresolvedUsingValueDecl>(D);
503 /// Removes using shadow declarations from the lookup results.
504 static void RemoveUsingDecls(LookupResult &R) {
505 LookupResult::Filter F = R.makeFilter();
507 if (isUsingDecl(F.next()))
513 static bool ShouldDiagnoseUnusedDecl(const NamedDecl *D) {
514 if (D->isInvalidDecl())
517 if (D->isUsed() || D->hasAttr<UnusedAttr>())
520 // White-list anything that isn't a local variable.
521 if (!isa<VarDecl>(D) || isa<ParmVarDecl>(D) || isa<ImplicitParamDecl>(D) ||
522 !D->getDeclContext()->isFunctionOrMethod())
525 // Types of valid local variables should be complete, so this should succeed.
526 if (const ValueDecl *VD = dyn_cast<ValueDecl>(D)) {
527 if (const RecordType *RT = VD->getType()->getAs<RecordType>()) {
528 if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(RT->getDecl())) {
529 if (!RD->hasTrivialConstructor())
531 if (!RD->hasTrivialDestructor())
540 void Sema::ActOnPopScope(SourceLocation Loc, Scope *S) {
541 if (S->decl_empty()) return;
542 assert((S->getFlags() & (Scope::DeclScope | Scope::TemplateParamScope)) &&
543 "Scope shouldn't contain decls!");
545 for (Scope::decl_iterator I = S->decl_begin(), E = S->decl_end();
547 Decl *TmpD = (*I).getAs<Decl>();
548 assert(TmpD && "This decl didn't get pushed??");
550 assert(isa<NamedDecl>(TmpD) && "Decl isn't NamedDecl?");
551 NamedDecl *D = cast<NamedDecl>(TmpD);
553 if (!D->getDeclName()) continue;
555 // Diagnose unused variables in this scope.
556 if (ShouldDiagnoseUnusedDecl(D) &&
557 S->getNumErrorsAtStart() == getDiagnostics().getNumErrors())
558 Diag(D->getLocation(), diag::warn_unused_variable) << D->getDeclName();
560 // Remove this name from our lexical scope.
561 IdResolver.RemoveDecl(D);
565 /// getObjCInterfaceDecl - Look up a for a class declaration in the scope.
566 /// return 0 if one not found.
568 /// \param Id the name of the Objective-C class we're looking for. If
569 /// typo-correction fixes this name, the Id will be updated
570 /// to the fixed name.
572 /// \param RecoverLoc if provided, this routine will attempt to
573 /// recover from a typo in the name of an existing Objective-C class
574 /// and, if successful, will return the lookup that results from
576 ObjCInterfaceDecl *Sema::getObjCInterfaceDecl(IdentifierInfo *&Id,
577 SourceLocation RecoverLoc) {
578 // The third "scope" argument is 0 since we aren't enabling lazy built-in
579 // creation from this context.
580 NamedDecl *IDecl = LookupSingleName(TUScope, Id, LookupOrdinaryName);
582 if (!IDecl && !RecoverLoc.isInvalid()) {
583 // Perform typo correction at the given location, but only if we
584 // find an Objective-C class name.
585 LookupResult R(*this, Id, RecoverLoc, LookupOrdinaryName);
586 if (CorrectTypo(R, TUScope, 0) &&
587 (IDecl = R.getAsSingle<ObjCInterfaceDecl>())) {
588 Diag(RecoverLoc, diag::err_undef_interface_suggest)
589 << Id << IDecl->getDeclName()
590 << CodeModificationHint::CreateReplacement(RecoverLoc,
591 IDecl->getNameAsString());
592 Diag(IDecl->getLocation(), diag::note_previous_decl)
593 << IDecl->getDeclName();
595 Id = IDecl->getIdentifier();
599 return dyn_cast_or_null<ObjCInterfaceDecl>(IDecl);
602 /// getNonFieldDeclScope - Retrieves the innermost scope, starting
603 /// from S, where a non-field would be declared. This routine copes
604 /// with the difference between C and C++ scoping rules in structs and
605 /// unions. For example, the following code is well-formed in C but
606 /// ill-formed in C++:
617 /// For the declaration of BAR, this routine will return a different
618 /// scope. The scope S will be the scope of the unnamed enumeration
619 /// within S6. In C++, this routine will return the scope associated
620 /// with S6, because the enumeration's scope is a transparent
621 /// context but structures can contain non-field names. In C, this
622 /// routine will return the translation unit scope, since the
623 /// enumeration's scope is a transparent context and structures cannot
624 /// contain non-field names.
625 Scope *Sema::getNonFieldDeclScope(Scope *S) {
626 while (((S->getFlags() & Scope::DeclScope) == 0) ||
628 ((DeclContext *)S->getEntity())->isTransparentContext()) ||
629 (S->isClassScope() && !getLangOptions().CPlusPlus))
634 void Sema::InitBuiltinVaListType() {
635 if (!Context.getBuiltinVaListType().isNull())
638 IdentifierInfo *VaIdent = &Context.Idents.get("__builtin_va_list");
639 NamedDecl *VaDecl = LookupSingleName(TUScope, VaIdent, LookupOrdinaryName);
640 TypedefDecl *VaTypedef = cast<TypedefDecl>(VaDecl);
641 Context.setBuiltinVaListType(Context.getTypedefType(VaTypedef));
644 /// LazilyCreateBuiltin - The specified Builtin-ID was first used at
645 /// file scope. lazily create a decl for it. ForRedeclaration is true
646 /// if we're creating this built-in in anticipation of redeclaring the
648 NamedDecl *Sema::LazilyCreateBuiltin(IdentifierInfo *II, unsigned bid,
649 Scope *S, bool ForRedeclaration,
650 SourceLocation Loc) {
651 Builtin::ID BID = (Builtin::ID)bid;
653 if (Context.BuiltinInfo.hasVAListUse(BID))
654 InitBuiltinVaListType();
656 ASTContext::GetBuiltinTypeError Error;
657 QualType R = Context.GetBuiltinType(BID, Error);
659 case ASTContext::GE_None:
663 case ASTContext::GE_Missing_stdio:
664 if (ForRedeclaration)
665 Diag(Loc, diag::err_implicit_decl_requires_stdio)
666 << Context.BuiltinInfo.GetName(BID);
669 case ASTContext::GE_Missing_setjmp:
670 if (ForRedeclaration)
671 Diag(Loc, diag::err_implicit_decl_requires_setjmp)
672 << Context.BuiltinInfo.GetName(BID);
676 if (!ForRedeclaration && Context.BuiltinInfo.isPredefinedLibFunction(BID)) {
677 Diag(Loc, diag::ext_implicit_lib_function_decl)
678 << Context.BuiltinInfo.GetName(BID)
680 if (Context.BuiltinInfo.getHeaderName(BID) &&
681 Diags.getDiagnosticLevel(diag::ext_implicit_lib_function_decl)
682 != Diagnostic::Ignored)
683 Diag(Loc, diag::note_please_include_header)
684 << Context.BuiltinInfo.getHeaderName(BID)
685 << Context.BuiltinInfo.GetName(BID);
688 FunctionDecl *New = FunctionDecl::Create(Context,
689 Context.getTranslationUnitDecl(),
690 Loc, II, R, /*TInfo=*/0,
691 FunctionDecl::Extern, false,
692 /*hasPrototype=*/true);
695 // Create Decl objects for each parameter, adding them to the
697 if (FunctionProtoType *FT = dyn_cast<FunctionProtoType>(R)) {
698 llvm::SmallVector<ParmVarDecl*, 16> Params;
699 for (unsigned i = 0, e = FT->getNumArgs(); i != e; ++i)
700 Params.push_back(ParmVarDecl::Create(Context, New, SourceLocation(), 0,
701 FT->getArgType(i), /*TInfo=*/0,
703 New->setParams(Params.data(), Params.size());
706 AddKnownFunctionAttributes(New);
708 // TUScope is the translation-unit scope to insert this function into.
709 // FIXME: This is hideous. We need to teach PushOnScopeChains to
710 // relate Scopes to DeclContexts, and probably eliminate CurContext
711 // entirely, but we're not there yet.
712 DeclContext *SavedContext = CurContext;
713 CurContext = Context.getTranslationUnitDecl();
714 PushOnScopeChains(New, TUScope);
715 CurContext = SavedContext;
719 /// MergeTypeDefDecl - We just parsed a typedef 'New' which has the
720 /// same name and scope as a previous declaration 'Old'. Figure out
721 /// how to resolve this situation, merging decls or emitting
722 /// diagnostics as appropriate. If there was an error, set New to be invalid.
724 void Sema::MergeTypeDefDecl(TypedefDecl *New, LookupResult &OldDecls) {
725 // If the new decl is known invalid already, don't bother doing any
727 if (New->isInvalidDecl()) return;
729 // Allow multiple definitions for ObjC built-in typedefs.
730 // FIXME: Verify the underlying types are equivalent!
731 if (getLangOptions().ObjC1) {
732 const IdentifierInfo *TypeID = New->getIdentifier();
733 switch (TypeID->getLength()) {
736 if (!TypeID->isStr("id"))
738 Context.ObjCIdRedefinitionType = New->getUnderlyingType();
739 // Install the built-in type for 'id', ignoring the current definition.
740 New->setTypeForDecl(Context.getObjCIdType().getTypePtr());
743 if (!TypeID->isStr("Class"))
745 Context.ObjCClassRedefinitionType = New->getUnderlyingType();
746 // Install the built-in type for 'Class', ignoring the current definition.
747 New->setTypeForDecl(Context.getObjCClassType().getTypePtr());
750 if (!TypeID->isStr("SEL"))
752 Context.ObjCSelRedefinitionType = New->getUnderlyingType();
753 // Install the built-in type for 'SEL', ignoring the current definition.
754 New->setTypeForDecl(Context.getObjCSelType().getTypePtr());
757 if (!TypeID->isStr("Protocol"))
759 Context.setObjCProtoType(New->getUnderlyingType());
762 // Fall through - the typedef name was not a builtin type.
765 // Verify the old decl was also a type.
766 TypeDecl *Old = OldDecls.getAsSingle<TypeDecl>();
768 Diag(New->getLocation(), diag::err_redefinition_different_kind)
769 << New->getDeclName();
771 NamedDecl *OldD = OldDecls.getRepresentativeDecl();
772 if (OldD->getLocation().isValid())
773 Diag(OldD->getLocation(), diag::note_previous_definition);
775 return New->setInvalidDecl();
778 // If the old declaration is invalid, just give up here.
779 if (Old->isInvalidDecl())
780 return New->setInvalidDecl();
782 // Determine the "old" type we'll use for checking and diagnostics.
784 if (TypedefDecl *OldTypedef = dyn_cast<TypedefDecl>(Old))
785 OldType = OldTypedef->getUnderlyingType();
787 OldType = Context.getTypeDeclType(Old);
789 // If the typedef types are not identical, reject them in all languages and
790 // with any extensions enabled.
792 if (OldType != New->getUnderlyingType() &&
793 Context.getCanonicalType(OldType) !=
794 Context.getCanonicalType(New->getUnderlyingType())) {
795 Diag(New->getLocation(), diag::err_redefinition_different_typedef)
796 << New->getUnderlyingType() << OldType;
797 if (Old->getLocation().isValid())
798 Diag(Old->getLocation(), diag::note_previous_definition);
799 return New->setInvalidDecl();
802 // The types match. Link up the redeclaration chain if the old
803 // declaration was a typedef.
804 // FIXME: this is a potential source of wierdness if the type
805 // spellings don't match exactly.
806 if (isa<TypedefDecl>(Old))
807 New->setPreviousDeclaration(cast<TypedefDecl>(Old));
809 if (getLangOptions().Microsoft)
812 if (getLangOptions().CPlusPlus) {
813 // C++ [dcl.typedef]p2:
814 // In a given non-class scope, a typedef specifier can be used to
815 // redefine the name of any type declared in that scope to refer
816 // to the type to which it already refers.
817 if (!isa<CXXRecordDecl>(CurContext))
820 // C++0x [dcl.typedef]p4:
821 // In a given class scope, a typedef specifier can be used to redefine
822 // any class-name declared in that scope that is not also a typedef-name
823 // to refer to the type to which it already refers.
825 // This wording came in via DR424, which was a correction to the
826 // wording in DR56, which accidentally banned code like:
829 // typedef struct A { } A;
832 // in the C++03 standard. We implement the C++0x semantics, which
833 // allow the above but disallow
840 // since that was the intent of DR56.
841 if (!isa<TypedefDecl >(Old))
844 Diag(New->getLocation(), diag::err_redefinition)
845 << New->getDeclName();
846 Diag(Old->getLocation(), diag::note_previous_definition);
847 return New->setInvalidDecl();
850 // If we have a redefinition of a typedef in C, emit a warning. This warning
851 // is normally mapped to an error, but can be controlled with
852 // -Wtypedef-redefinition. If either the original or the redefinition is
853 // in a system header, don't emit this for compatibility with GCC.
854 if (getDiagnostics().getSuppressSystemWarnings() &&
855 (Context.getSourceManager().isInSystemHeader(Old->getLocation()) ||
856 Context.getSourceManager().isInSystemHeader(New->getLocation())))
859 Diag(New->getLocation(), diag::warn_redefinition_of_typedef)
860 << New->getDeclName();
861 Diag(Old->getLocation(), diag::note_previous_definition);
865 /// DeclhasAttr - returns true if decl Declaration already has the target
868 DeclHasAttr(const Decl *decl, const Attr *target) {
869 for (const Attr *attr = decl->getAttrs(); attr; attr = attr->getNext())
870 if (attr->getKind() == target->getKind())
876 /// MergeAttributes - append attributes from the Old decl to the New one.
877 static void MergeAttributes(Decl *New, Decl *Old, ASTContext &C) {
878 for (const Attr *attr = Old->getAttrs(); attr; attr = attr->getNext()) {
879 if (!DeclHasAttr(New, attr) && attr->isMerged()) {
880 Attr *NewAttr = attr->clone(C);
881 NewAttr->setInherited(true);
882 New->addAttr(NewAttr);
887 /// Used in MergeFunctionDecl to keep track of function parameters in
889 struct GNUCompatibleParamWarning {
890 ParmVarDecl *OldParm;
891 ParmVarDecl *NewParm;
892 QualType PromotedType;
896 /// getSpecialMember - get the special member enum for a method.
897 static Sema::CXXSpecialMember getSpecialMember(ASTContext &Ctx,
898 const CXXMethodDecl *MD) {
899 if (const CXXConstructorDecl *Ctor = dyn_cast<CXXConstructorDecl>(MD)) {
900 if (Ctor->isDefaultConstructor())
901 return Sema::CXXDefaultConstructor;
902 if (Ctor->isCopyConstructor())
903 return Sema::CXXCopyConstructor;
906 if (isa<CXXDestructorDecl>(MD))
907 return Sema::CXXDestructor;
909 assert(MD->isCopyAssignment() && "Must have copy assignment operator");
910 return Sema::CXXCopyAssignment;
913 /// canREdefineFunction - checks if a function can be redefined. Currently,
914 /// only extern inline functions can be redefined, and even then only in
916 static bool canRedefineFunction(const FunctionDecl *FD,
917 const LangOptions& LangOpts) {
918 return (LangOpts.GNUMode && !LangOpts.C99 && !LangOpts.CPlusPlus &&
919 FD->isInlineSpecified() &&
920 FD->getStorageClass() == FunctionDecl::Extern);
923 /// MergeFunctionDecl - We just parsed a function 'New' from
924 /// declarator D which has the same name and scope as a previous
925 /// declaration 'Old'. Figure out how to resolve this situation,
926 /// merging decls or emitting diagnostics as appropriate.
928 /// In C++, New and Old must be declarations that are not
929 /// overloaded. Use IsOverload to determine whether New and Old are
930 /// overloaded, and to select the Old declaration that New should be
933 /// Returns true if there was an error, false otherwise.
934 bool Sema::MergeFunctionDecl(FunctionDecl *New, Decl *OldD) {
935 // Verify the old decl was also a function.
936 FunctionDecl *Old = 0;
937 if (FunctionTemplateDecl *OldFunctionTemplate
938 = dyn_cast<FunctionTemplateDecl>(OldD))
939 Old = OldFunctionTemplate->getTemplatedDecl();
941 Old = dyn_cast<FunctionDecl>(OldD);
943 if (UsingShadowDecl *Shadow = dyn_cast<UsingShadowDecl>(OldD)) {
944 Diag(New->getLocation(), diag::err_using_decl_conflict_reverse);
945 Diag(Shadow->getTargetDecl()->getLocation(),
946 diag::note_using_decl_target);
947 Diag(Shadow->getUsingDecl()->getLocation(),
948 diag::note_using_decl) << 0;
952 Diag(New->getLocation(), diag::err_redefinition_different_kind)
953 << New->getDeclName();
954 Diag(OldD->getLocation(), diag::note_previous_definition);
958 // Determine whether the previous declaration was a definition,
959 // implicit declaration, or a declaration.
961 if (Old->isThisDeclarationADefinition())
962 PrevDiag = diag::note_previous_definition;
963 else if (Old->isImplicit())
964 PrevDiag = diag::note_previous_implicit_declaration;
966 PrevDiag = diag::note_previous_declaration;
968 QualType OldQType = Context.getCanonicalType(Old->getType());
969 QualType NewQType = Context.getCanonicalType(New->getType());
971 // Don't complain about this if we're in GNU89 mode and the old function
972 // is an extern inline function.
973 if (!isa<CXXMethodDecl>(New) && !isa<CXXMethodDecl>(Old) &&
974 New->getStorageClass() == FunctionDecl::Static &&
975 Old->getStorageClass() != FunctionDecl::Static &&
976 !canRedefineFunction(Old, getLangOptions())) {
977 Diag(New->getLocation(), diag::err_static_non_static)
979 Diag(Old->getLocation(), PrevDiag);
983 // If a function is first declared with a calling convention, but is
984 // later declared or defined without one, the second decl assumes the
985 // calling convention of the first.
987 // For the new decl, we have to look at the NON-canonical type to tell the
988 // difference between a function that really doesn't have a calling
989 // convention and one that is declared cdecl. That's because in
990 // canonicalization (see ASTContext.cpp), cdecl is canonicalized away
991 // because it is the default calling convention.
993 // Note also that we DO NOT return at this point, because we still have
994 // other tests to run.
995 const FunctionType *OldType = OldQType->getAs<FunctionType>();
996 const FunctionType *NewType = New->getType()->getAs<FunctionType>();
997 if (OldType->getCallConv() != CC_Default &&
998 NewType->getCallConv() == CC_Default) {
999 NewQType = Context.getCallConvType(NewQType, OldType->getCallConv());
1000 New->setType(NewQType);
1001 NewQType = Context.getCanonicalType(NewQType);
1002 } else if (!Context.isSameCallConv(OldType->getCallConv(),
1003 NewType->getCallConv())) {
1004 // Calling conventions really aren't compatible, so complain.
1005 Diag(New->getLocation(), diag::err_cconv_change)
1006 << FunctionType::getNameForCallConv(NewType->getCallConv())
1007 << (OldType->getCallConv() == CC_Default)
1008 << (OldType->getCallConv() == CC_Default ? "" :
1009 FunctionType::getNameForCallConv(OldType->getCallConv()));
1010 Diag(Old->getLocation(), diag::note_previous_declaration);
1014 // FIXME: diagnose the other way around?
1015 if (OldType->getNoReturnAttr() && !NewType->getNoReturnAttr()) {
1016 NewQType = Context.getNoReturnType(NewQType);
1017 New->setType(NewQType);
1018 assert(NewQType.isCanonical());
1021 if (getLangOptions().CPlusPlus) {
1023 // Certain function declarations cannot be overloaded:
1024 // -- Function declarations that differ only in the return type
1025 // cannot be overloaded.
1026 QualType OldReturnType
1027 = cast<FunctionType>(OldQType.getTypePtr())->getResultType();
1028 QualType NewReturnType
1029 = cast<FunctionType>(NewQType.getTypePtr())->getResultType();
1030 if (OldReturnType != NewReturnType) {
1031 Diag(New->getLocation(), diag::err_ovl_diff_return_type);
1032 Diag(Old->getLocation(), PrevDiag) << Old << Old->getType();
1036 const CXXMethodDecl* OldMethod = dyn_cast<CXXMethodDecl>(Old);
1037 const CXXMethodDecl* NewMethod = dyn_cast<CXXMethodDecl>(New);
1038 if (OldMethod && NewMethod) {
1039 if (!NewMethod->getFriendObjectKind() &&
1040 NewMethod->getLexicalDeclContext()->isRecord()) {
1041 // -- Member function declarations with the same name and the
1042 // same parameter types cannot be overloaded if any of them
1043 // is a static member function declaration.
1044 if (OldMethod->isStatic() || NewMethod->isStatic()) {
1045 Diag(New->getLocation(), diag::err_ovl_static_nonstatic_member);
1046 Diag(Old->getLocation(), PrevDiag) << Old << Old->getType();
1050 // C++ [class.mem]p1:
1051 // [...] A member shall not be declared twice in the
1052 // member-specification, except that a nested class or member
1053 // class template can be declared and then later defined.
1055 if (isa<CXXConstructorDecl>(OldMethod))
1056 NewDiag = diag::err_constructor_redeclared;
1057 else if (isa<CXXDestructorDecl>(NewMethod))
1058 NewDiag = diag::err_destructor_redeclared;
1059 else if (isa<CXXConversionDecl>(NewMethod))
1060 NewDiag = diag::err_conv_function_redeclared;
1062 NewDiag = diag::err_member_redeclared;
1064 Diag(New->getLocation(), NewDiag);
1065 Diag(Old->getLocation(), PrevDiag) << Old << Old->getType();
1067 if (OldMethod->isImplicit()) {
1068 Diag(NewMethod->getLocation(),
1069 diag::err_definition_of_implicitly_declared_member)
1070 << New << getSpecialMember(Context, OldMethod);
1072 Diag(OldMethod->getLocation(),
1073 diag::note_previous_implicit_declaration);
1080 // All declarations for a function shall agree exactly in both the
1081 // return type and the parameter-type-list.
1082 // attributes should be ignored when comparing.
1083 if (Context.getNoReturnType(OldQType, false) ==
1084 Context.getNoReturnType(NewQType, false))
1085 return MergeCompatibleFunctionDecls(New, Old);
1087 // Fall through for conflicting redeclarations and redefinitions.
1090 // C: Function types need to be compatible, not identical. This handles
1091 // duplicate function decls like "void f(int); void f(enum X);" properly.
1092 if (!getLangOptions().CPlusPlus &&
1093 Context.typesAreCompatible(OldQType, NewQType)) {
1094 const FunctionType *OldFuncType = OldQType->getAs<FunctionType>();
1095 const FunctionType *NewFuncType = NewQType->getAs<FunctionType>();
1096 const FunctionProtoType *OldProto = 0;
1097 if (isa<FunctionNoProtoType>(NewFuncType) &&
1098 (OldProto = dyn_cast<FunctionProtoType>(OldFuncType))) {
1099 // The old declaration provided a function prototype, but the
1100 // new declaration does not. Merge in the prototype.
1101 assert(!OldProto->hasExceptionSpec() && "Exception spec in C");
1102 llvm::SmallVector<QualType, 16> ParamTypes(OldProto->arg_type_begin(),
1103 OldProto->arg_type_end());
1104 NewQType = Context.getFunctionType(NewFuncType->getResultType(),
1105 ParamTypes.data(), ParamTypes.size(),
1106 OldProto->isVariadic(),
1107 OldProto->getTypeQuals(),
1109 OldProto->getNoReturnAttr(),
1110 OldProto->getCallConv());
1111 New->setType(NewQType);
1112 New->setHasInheritedPrototype();
1114 // Synthesize a parameter for each argument type.
1115 llvm::SmallVector<ParmVarDecl*, 16> Params;
1116 for (FunctionProtoType::arg_type_iterator
1117 ParamType = OldProto->arg_type_begin(),
1118 ParamEnd = OldProto->arg_type_end();
1119 ParamType != ParamEnd; ++ParamType) {
1120 ParmVarDecl *Param = ParmVarDecl::Create(Context, New,
1121 SourceLocation(), 0,
1122 *ParamType, /*TInfo=*/0,
1124 Param->setImplicit();
1125 Params.push_back(Param);
1128 New->setParams(Params.data(), Params.size());
1131 return MergeCompatibleFunctionDecls(New, Old);
1134 // GNU C permits a K&R definition to follow a prototype declaration
1135 // if the declared types of the parameters in the K&R definition
1136 // match the types in the prototype declaration, even when the
1137 // promoted types of the parameters from the K&R definition differ
1138 // from the types in the prototype. GCC then keeps the types from
1141 // If a variadic prototype is followed by a non-variadic K&R definition,
1142 // the K&R definition becomes variadic. This is sort of an edge case, but
1143 // it's legal per the standard depending on how you read C99 6.7.5.3p15 and
1145 if (!getLangOptions().CPlusPlus &&
1146 Old->hasPrototype() && !New->hasPrototype() &&
1147 New->getType()->getAs<FunctionProtoType>() &&
1148 Old->getNumParams() == New->getNumParams()) {
1149 llvm::SmallVector<QualType, 16> ArgTypes;
1150 llvm::SmallVector<GNUCompatibleParamWarning, 16> Warnings;
1151 const FunctionProtoType *OldProto
1152 = Old->getType()->getAs<FunctionProtoType>();
1153 const FunctionProtoType *NewProto
1154 = New->getType()->getAs<FunctionProtoType>();
1156 // Determine whether this is the GNU C extension.
1157 QualType MergedReturn = Context.mergeTypes(OldProto->getResultType(),
1158 NewProto->getResultType());
1159 bool LooseCompatible = !MergedReturn.isNull();
1160 for (unsigned Idx = 0, End = Old->getNumParams();
1161 LooseCompatible && Idx != End; ++Idx) {
1162 ParmVarDecl *OldParm = Old->getParamDecl(Idx);
1163 ParmVarDecl *NewParm = New->getParamDecl(Idx);
1164 if (Context.typesAreCompatible(OldParm->getType(),
1165 NewProto->getArgType(Idx))) {
1166 ArgTypes.push_back(NewParm->getType());
1167 } else if (Context.typesAreCompatible(OldParm->getType(),
1168 NewParm->getType())) {
1169 GNUCompatibleParamWarning Warn
1170 = { OldParm, NewParm, NewProto->getArgType(Idx) };
1171 Warnings.push_back(Warn);
1172 ArgTypes.push_back(NewParm->getType());
1174 LooseCompatible = false;
1177 if (LooseCompatible) {
1178 for (unsigned Warn = 0; Warn < Warnings.size(); ++Warn) {
1179 Diag(Warnings[Warn].NewParm->getLocation(),
1180 diag::ext_param_promoted_not_compatible_with_prototype)
1181 << Warnings[Warn].PromotedType
1182 << Warnings[Warn].OldParm->getType();
1183 Diag(Warnings[Warn].OldParm->getLocation(),
1184 diag::note_previous_declaration);
1187 New->setType(Context.getFunctionType(MergedReturn, &ArgTypes[0],
1189 OldProto->isVariadic(), 0,
1191 OldProto->getNoReturnAttr(),
1192 OldProto->getCallConv()));
1193 return MergeCompatibleFunctionDecls(New, Old);
1196 // Fall through to diagnose conflicting types.
1199 // A function that has already been declared has been redeclared or defined
1200 // with a different type- show appropriate diagnostic
1201 if (unsigned BuiltinID = Old->getBuiltinID()) {
1202 // The user has declared a builtin function with an incompatible
1204 if (Context.BuiltinInfo.isPredefinedLibFunction(BuiltinID)) {
1205 // The function the user is redeclaring is a library-defined
1206 // function like 'malloc' or 'printf'. Warn about the
1207 // redeclaration, then pretend that we don't know about this
1208 // library built-in.
1209 Diag(New->getLocation(), diag::warn_redecl_library_builtin) << New;
1210 Diag(Old->getLocation(), diag::note_previous_builtin_declaration)
1211 << Old << Old->getType();
1212 New->getIdentifier()->setBuiltinID(Builtin::NotBuiltin);
1213 Old->setInvalidDecl();
1217 PrevDiag = diag::note_previous_builtin_declaration;
1220 Diag(New->getLocation(), diag::err_conflicting_types) << New->getDeclName();
1221 Diag(Old->getLocation(), PrevDiag) << Old << Old->getType();
1225 /// \brief Completes the merge of two function declarations that are
1226 /// known to be compatible.
1228 /// This routine handles the merging of attributes and other
1229 /// properties of function declarations form the old declaration to
1230 /// the new declaration, once we know that New is in fact a
1231 /// redeclaration of Old.
1234 bool Sema::MergeCompatibleFunctionDecls(FunctionDecl *New, FunctionDecl *Old) {
1235 // Merge the attributes
1236 MergeAttributes(New, Old, Context);
1238 // Merge the storage class.
1239 if (Old->getStorageClass() != FunctionDecl::Extern &&
1240 Old->getStorageClass() != FunctionDecl::None)
1241 New->setStorageClass(Old->getStorageClass());
1243 // Merge "pure" flag.
1247 // Merge the "deleted" flag.
1248 if (Old->isDeleted())
1251 if (getLangOptions().CPlusPlus)
1252 return MergeCXXFunctionDecl(New, Old);
1257 /// MergeVarDecl - We just parsed a variable 'New' which has the same name
1258 /// and scope as a previous declaration 'Old'. Figure out how to resolve this
1259 /// situation, merging decls or emitting diagnostics as appropriate.
1261 /// Tentative definition rules (C99 6.9.2p2) are checked by
1262 /// FinalizeDeclaratorGroup. Unfortunately, we can't analyze tentative
1263 /// definitions here, since the initializer hasn't been attached.
1265 void Sema::MergeVarDecl(VarDecl *New, LookupResult &Previous) {
1266 // If the new decl is already invalid, don't do any other checking.
1267 if (New->isInvalidDecl())
1270 // Verify the old decl was also a variable.
1272 if (!Previous.isSingleResult() ||
1273 !(Old = dyn_cast<VarDecl>(Previous.getFoundDecl()))) {
1274 Diag(New->getLocation(), diag::err_redefinition_different_kind)
1275 << New->getDeclName();
1276 Diag(Previous.getRepresentativeDecl()->getLocation(),
1277 diag::note_previous_definition);
1278 return New->setInvalidDecl();
1281 MergeAttributes(New, Old, Context);
1285 if (getLangOptions().CPlusPlus) {
1286 if (Context.hasSameType(New->getType(), Old->getType()))
1287 MergedT = New->getType();
1288 // C++ [basic.link]p10:
1289 // [...] the types specified by all declarations referring to a given
1290 // object or function shall be identical, except that declarations for an
1291 // array object can specify array types that differ by the presence or
1292 // absence of a major array bound (8.3.4).
1293 else if (Old->getType()->isIncompleteArrayType() &&
1294 New->getType()->isArrayType()) {
1295 CanQual<ArrayType> OldArray
1296 = Context.getCanonicalType(Old->getType())->getAs<ArrayType>();
1297 CanQual<ArrayType> NewArray
1298 = Context.getCanonicalType(New->getType())->getAs<ArrayType>();
1299 if (OldArray->getElementType() == NewArray->getElementType())
1300 MergedT = New->getType();
1301 } else if (Old->getType()->isArrayType() &&
1302 New->getType()->isIncompleteArrayType()) {
1303 CanQual<ArrayType> OldArray
1304 = Context.getCanonicalType(Old->getType())->getAs<ArrayType>();
1305 CanQual<ArrayType> NewArray
1306 = Context.getCanonicalType(New->getType())->getAs<ArrayType>();
1307 if (OldArray->getElementType() == NewArray->getElementType())
1308 MergedT = Old->getType();
1311 MergedT = Context.mergeTypes(New->getType(), Old->getType());
1313 if (MergedT.isNull()) {
1314 Diag(New->getLocation(), diag::err_redefinition_different_type)
1315 << New->getDeclName();
1316 Diag(Old->getLocation(), diag::note_previous_definition);
1317 return New->setInvalidDecl();
1319 New->setType(MergedT);
1321 // C99 6.2.2p4: Check if we have a static decl followed by a non-static.
1322 if (New->getStorageClass() == VarDecl::Static &&
1323 (Old->getStorageClass() == VarDecl::None || Old->hasExternalStorage())) {
1324 Diag(New->getLocation(), diag::err_static_non_static) << New->getDeclName();
1325 Diag(Old->getLocation(), diag::note_previous_definition);
1326 return New->setInvalidDecl();
1329 // For an identifier declared with the storage-class specifier
1330 // extern in a scope in which a prior declaration of that
1331 // identifier is visible,23) if the prior declaration specifies
1332 // internal or external linkage, the linkage of the identifier at
1333 // the later declaration is the same as the linkage specified at
1334 // the prior declaration. If no prior declaration is visible, or
1335 // if the prior declaration specifies no linkage, then the
1336 // identifier has external linkage.
1337 if (New->hasExternalStorage() && Old->hasLinkage())
1339 else if (New->getStorageClass() != VarDecl::Static &&
1340 Old->getStorageClass() == VarDecl::Static) {
1341 Diag(New->getLocation(), diag::err_non_static_static) << New->getDeclName();
1342 Diag(Old->getLocation(), diag::note_previous_definition);
1343 return New->setInvalidDecl();
1346 // Variables with external linkage are analyzed in FinalizeDeclaratorGroup.
1348 // FIXME: The test for external storage here seems wrong? We still
1349 // need to check for mismatches.
1350 if (!New->hasExternalStorage() && !New->isFileVarDecl() &&
1351 // Don't complain about out-of-line definitions of static members.
1352 !(Old->getLexicalDeclContext()->isRecord() &&
1353 !New->getLexicalDeclContext()->isRecord())) {
1354 Diag(New->getLocation(), diag::err_redefinition) << New->getDeclName();
1355 Diag(Old->getLocation(), diag::note_previous_definition);
1356 return New->setInvalidDecl();
1359 if (New->isThreadSpecified() && !Old->isThreadSpecified()) {
1360 Diag(New->getLocation(), diag::err_thread_non_thread) << New->getDeclName();
1361 Diag(Old->getLocation(), diag::note_previous_definition);
1362 } else if (!New->isThreadSpecified() && Old->isThreadSpecified()) {
1363 Diag(New->getLocation(), diag::err_non_thread_thread) << New->getDeclName();
1364 Diag(Old->getLocation(), diag::note_previous_definition);
1367 // C++ doesn't have tentative definitions, so go right ahead and check here.
1369 if (getLangOptions().CPlusPlus &&
1370 New->isThisDeclarationADefinition() == VarDecl::Definition &&
1371 (Def = Old->getDefinition())) {
1372 Diag(New->getLocation(), diag::err_redefinition)
1373 << New->getDeclName();
1374 Diag(Def->getLocation(), diag::note_previous_definition);
1375 New->setInvalidDecl();
1379 // Keep a chain of previous declarations.
1380 New->setPreviousDeclaration(Old);
1382 // Inherit access appropriately.
1383 New->setAccess(Old->getAccess());
1386 /// ParsedFreeStandingDeclSpec - This method is invoked when a declspec with
1387 /// no declarator (e.g. "struct foo;") is parsed.
1388 Sema::DeclPtrTy Sema::ParsedFreeStandingDeclSpec(Scope *S, DeclSpec &DS) {
1389 // FIXME: Error on auto/register at file scope
1390 // FIXME: Error on inline/virtual/explicit
1391 // FIXME: Warn on useless __thread
1392 // FIXME: Warn on useless const/volatile
1393 // FIXME: Warn on useless static/extern/typedef/private_extern/mutable
1394 // FIXME: Warn on useless attributes
1397 if (DS.getTypeSpecType() == DeclSpec::TST_class ||
1398 DS.getTypeSpecType() == DeclSpec::TST_struct ||
1399 DS.getTypeSpecType() == DeclSpec::TST_union ||
1400 DS.getTypeSpecType() == DeclSpec::TST_enum) {
1401 TagD = static_cast<Decl *>(DS.getTypeRep());
1403 if (!TagD) // We probably had an error
1406 // Note that the above type specs guarantee that the
1407 // type rep is a Decl, whereas in many of the others
1409 Tag = dyn_cast<TagDecl>(TagD);
1412 if (unsigned TypeQuals = DS.getTypeQualifiers()) {
1413 // Enforce C99 6.7.3p2: "Types other than pointer types derived from object
1414 // or incomplete types shall not be restrict-qualified."
1415 if (TypeQuals & DeclSpec::TQ_restrict)
1416 Diag(DS.getRestrictSpecLoc(),
1417 diag::err_typecheck_invalid_restrict_not_pointer_noarg)
1418 << DS.getSourceRange();
1421 if (DS.isFriendSpecified()) {
1422 // If we're dealing with a class template decl, assume that the
1423 // template routines are handling it.
1424 if (TagD && isa<ClassTemplateDecl>(TagD))
1426 return ActOnFriendTypeDecl(S, DS, MultiTemplateParamsArg(*this, 0, 0));
1429 if (RecordDecl *Record = dyn_cast_or_null<RecordDecl>(Tag)) {
1430 // If there are attributes in the DeclSpec, apply them to the record.
1431 if (const AttributeList *AL = DS.getAttributes())
1432 ProcessDeclAttributeList(S, Record, AL);
1434 if (!Record->getDeclName() && Record->isDefinition() &&
1435 DS.getStorageClassSpec() != DeclSpec::SCS_typedef) {
1436 if (getLangOptions().CPlusPlus ||
1437 Record->getDeclContext()->isRecord())
1438 return BuildAnonymousStructOrUnion(S, DS, Record);
1440 Diag(DS.getSourceRange().getBegin(), diag::err_no_declarators)
1441 << DS.getSourceRange();
1444 // Microsoft allows unnamed struct/union fields. Don't complain
1446 // FIXME: Should we support Microsoft's extensions in this area?
1447 if (Record->getDeclName() && getLangOptions().Microsoft)
1448 return DeclPtrTy::make(Tag);
1451 if (!DS.isMissingDeclaratorOk() &&
1452 DS.getTypeSpecType() != DeclSpec::TST_error) {
1453 // Warn about typedefs of enums without names, since this is an
1454 // extension in both Microsoft an GNU.
1455 if (DS.getStorageClassSpec() == DeclSpec::SCS_typedef &&
1456 Tag && isa<EnumDecl>(Tag)) {
1457 Diag(DS.getSourceRange().getBegin(), diag::ext_typedef_without_a_name)
1458 << DS.getSourceRange();
1459 return DeclPtrTy::make(Tag);
1462 Diag(DS.getSourceRange().getBegin(), diag::err_no_declarators)
1463 << DS.getSourceRange();
1467 return DeclPtrTy::make(Tag);
1470 /// We are trying to inject an anonymous member into the given scope;
1471 /// check if there's an existing declaration that can't be overloaded.
1473 /// \return true if this is a forbidden redeclaration
1474 static bool CheckAnonMemberRedeclaration(Sema &SemaRef,
1477 DeclarationName Name,
1478 SourceLocation NameLoc,
1479 unsigned diagnostic) {
1480 LookupResult R(SemaRef, Name, NameLoc, Sema::LookupMemberName,
1481 Sema::ForRedeclaration);
1482 if (!SemaRef.LookupName(R, S)) return false;
1484 if (R.getAsSingle<TagDecl>())
1487 // Pick a representative declaration.
1488 NamedDecl *PrevDecl = R.getRepresentativeDecl()->getUnderlyingDecl();
1489 if (PrevDecl && Owner->isRecord()) {
1490 RecordDecl *Record = cast<RecordDecl>(Owner);
1491 if (!SemaRef.isDeclInScope(PrevDecl, Record, S))
1495 SemaRef.Diag(NameLoc, diagnostic) << Name;
1496 SemaRef.Diag(PrevDecl->getLocation(), diag::note_previous_declaration);
1501 /// InjectAnonymousStructOrUnionMembers - Inject the members of the
1502 /// anonymous struct or union AnonRecord into the owning context Owner
1503 /// and scope S. This routine will be invoked just after we realize
1504 /// that an unnamed union or struct is actually an anonymous union or
1511 /// }; // InjectAnonymousStructOrUnionMembers called here to inject i and
1512 /// // f into the surrounding scope.x
1515 /// This routine is recursive, injecting the names of nested anonymous
1516 /// structs/unions into the owning context and scope as well.
1517 bool Sema::InjectAnonymousStructOrUnionMembers(Scope *S, DeclContext *Owner,
1518 RecordDecl *AnonRecord) {
1520 = AnonRecord->isUnion() ? diag::err_anonymous_union_member_redecl
1521 : diag::err_anonymous_struct_member_redecl;
1523 bool Invalid = false;
1524 for (RecordDecl::field_iterator F = AnonRecord->field_begin(),
1525 FEnd = AnonRecord->field_end();
1527 if ((*F)->getDeclName()) {
1528 if (CheckAnonMemberRedeclaration(*this, S, Owner, (*F)->getDeclName(),
1529 (*F)->getLocation(), diagKind)) {
1530 // C++ [class.union]p2:
1531 // The names of the members of an anonymous union shall be
1532 // distinct from the names of any other entity in the
1533 // scope in which the anonymous union is declared.
1536 // C++ [class.union]p2:
1537 // For the purpose of name lookup, after the anonymous union
1538 // definition, the members of the anonymous union are
1539 // considered to have been defined in the scope in which the
1540 // anonymous union is declared.
1541 Owner->makeDeclVisibleInContext(*F);
1542 S->AddDecl(DeclPtrTy::make(*F));
1543 IdResolver.AddDecl(*F);
1545 } else if (const RecordType *InnerRecordType
1546 = (*F)->getType()->getAs<RecordType>()) {
1547 RecordDecl *InnerRecord = InnerRecordType->getDecl();
1548 if (InnerRecord->isAnonymousStructOrUnion())
1549 Invalid = Invalid ||
1550 InjectAnonymousStructOrUnionMembers(S, Owner, InnerRecord);
1557 /// ActOnAnonymousStructOrUnion - Handle the declaration of an
1558 /// anonymous structure or union. Anonymous unions are a C++ feature
1559 /// (C++ [class.union]) and a GNU C extension; anonymous structures
1560 /// are a GNU C and GNU C++ extension.
1561 Sema::DeclPtrTy Sema::BuildAnonymousStructOrUnion(Scope *S, DeclSpec &DS,
1562 RecordDecl *Record) {
1563 DeclContext *Owner = Record->getDeclContext();
1565 // Diagnose whether this anonymous struct/union is an extension.
1566 if (Record->isUnion() && !getLangOptions().CPlusPlus)
1567 Diag(Record->getLocation(), diag::ext_anonymous_union);
1568 else if (!Record->isUnion())
1569 Diag(Record->getLocation(), diag::ext_anonymous_struct);
1571 // C and C++ require different kinds of checks for anonymous
1573 bool Invalid = false;
1574 if (getLangOptions().CPlusPlus) {
1575 const char* PrevSpec = 0;
1577 // C++ [class.union]p3:
1578 // Anonymous unions declared in a named namespace or in the
1579 // global namespace shall be declared static.
1580 if (DS.getStorageClassSpec() != DeclSpec::SCS_static &&
1581 (isa<TranslationUnitDecl>(Owner) ||
1582 (isa<NamespaceDecl>(Owner) &&
1583 cast<NamespaceDecl>(Owner)->getDeclName()))) {
1584 Diag(Record->getLocation(), diag::err_anonymous_union_not_static);
1587 // Recover by adding 'static'.
1588 DS.SetStorageClassSpec(DeclSpec::SCS_static, SourceLocation(),
1591 // C++ [class.union]p3:
1592 // A storage class is not allowed in a declaration of an
1593 // anonymous union in a class scope.
1594 else if (DS.getStorageClassSpec() != DeclSpec::SCS_unspecified &&
1595 isa<RecordDecl>(Owner)) {
1596 Diag(DS.getStorageClassSpecLoc(),
1597 diag::err_anonymous_union_with_storage_spec);
1600 // Recover by removing the storage specifier.
1601 DS.SetStorageClassSpec(DeclSpec::SCS_unspecified, SourceLocation(),
1605 // C++ [class.union]p2:
1606 // The member-specification of an anonymous union shall only
1607 // define non-static data members. [Note: nested types and
1608 // functions cannot be declared within an anonymous union. ]
1609 for (DeclContext::decl_iterator Mem = Record->decls_begin(),
1610 MemEnd = Record->decls_end();
1611 Mem != MemEnd; ++Mem) {
1612 if (FieldDecl *FD = dyn_cast<FieldDecl>(*Mem)) {
1613 // C++ [class.union]p3:
1614 // An anonymous union shall not have private or protected
1615 // members (clause 11).
1616 if (FD->getAccess() == AS_protected || FD->getAccess() == AS_private) {
1617 Diag(FD->getLocation(), diag::err_anonymous_record_nonpublic_member)
1618 << (int)Record->isUnion() << (int)(FD->getAccess() == AS_protected);
1621 } else if ((*Mem)->isImplicit()) {
1622 // Any implicit members are fine.
1623 } else if (isa<TagDecl>(*Mem) && (*Mem)->getDeclContext() != Record) {
1624 // This is a type that showed up in an
1625 // elaborated-type-specifier inside the anonymous struct or
1626 // union, but which actually declares a type outside of the
1627 // anonymous struct or union. It's okay.
1628 } else if (RecordDecl *MemRecord = dyn_cast<RecordDecl>(*Mem)) {
1629 if (!MemRecord->isAnonymousStructOrUnion() &&
1630 MemRecord->getDeclName()) {
1631 // This is a nested type declaration.
1632 Diag(MemRecord->getLocation(), diag::err_anonymous_record_with_type)
1633 << (int)Record->isUnion();
1637 // We have something that isn't a non-static data
1638 // member. Complain about it.
1639 unsigned DK = diag::err_anonymous_record_bad_member;
1640 if (isa<TypeDecl>(*Mem))
1641 DK = diag::err_anonymous_record_with_type;
1642 else if (isa<FunctionDecl>(*Mem))
1643 DK = diag::err_anonymous_record_with_function;
1644 else if (isa<VarDecl>(*Mem))
1645 DK = diag::err_anonymous_record_with_static;
1646 Diag((*Mem)->getLocation(), DK)
1647 << (int)Record->isUnion();
1653 if (!Record->isUnion() && !Owner->isRecord()) {
1654 Diag(Record->getLocation(), diag::err_anonymous_struct_not_member)
1655 << (int)getLangOptions().CPlusPlus;
1659 // Mock up a declarator.
1660 Declarator Dc(DS, Declarator::TypeNameContext);
1661 TypeSourceInfo *TInfo = 0;
1662 GetTypeForDeclarator(Dc, S, &TInfo);
1663 assert(TInfo && "couldn't build declarator info for anonymous struct/union");
1665 // Create a declaration for this anonymous struct/union.
1666 NamedDecl *Anon = 0;
1667 if (RecordDecl *OwningClass = dyn_cast<RecordDecl>(Owner)) {
1668 Anon = FieldDecl::Create(Context, OwningClass, Record->getLocation(),
1669 /*IdentifierInfo=*/0,
1670 Context.getTypeDeclType(Record),
1672 /*BitWidth=*/0, /*Mutable=*/false);
1673 Anon->setAccess(AS_public);
1674 if (getLangOptions().CPlusPlus)
1675 FieldCollector->Add(cast<FieldDecl>(Anon));
1677 VarDecl::StorageClass SC;
1678 switch (DS.getStorageClassSpec()) {
1679 default: assert(0 && "Unknown storage class!");
1680 case DeclSpec::SCS_unspecified: SC = VarDecl::None; break;
1681 case DeclSpec::SCS_extern: SC = VarDecl::Extern; break;
1682 case DeclSpec::SCS_static: SC = VarDecl::Static; break;
1683 case DeclSpec::SCS_auto: SC = VarDecl::Auto; break;
1684 case DeclSpec::SCS_register: SC = VarDecl::Register; break;
1685 case DeclSpec::SCS_private_extern: SC = VarDecl::PrivateExtern; break;
1686 case DeclSpec::SCS_mutable:
1687 // mutable can only appear on non-static class members, so it's always
1689 Diag(Record->getLocation(), diag::err_mutable_nonmember);
1695 Anon = VarDecl::Create(Context, Owner, Record->getLocation(),
1696 /*IdentifierInfo=*/0,
1697 Context.getTypeDeclType(Record),
1701 Anon->setImplicit();
1703 // Add the anonymous struct/union object to the current
1704 // context. We'll be referencing this object when we refer to one of
1706 Owner->addDecl(Anon);
1708 // Inject the members of the anonymous struct/union into the owning
1709 // context and into the identifier resolver chain for name lookup
1711 if (InjectAnonymousStructOrUnionMembers(S, Owner, Record))
1714 // Mark this as an anonymous struct/union type. Note that we do not
1715 // do this until after we have already checked and injected the
1716 // members of this anonymous struct/union type, because otherwise
1717 // the members could be injected twice: once by DeclContext when it
1718 // builds its lookup table, and once by
1719 // InjectAnonymousStructOrUnionMembers.
1720 Record->setAnonymousStructOrUnion(true);
1723 Anon->setInvalidDecl();
1725 return DeclPtrTy::make(Anon);
1729 /// GetNameForDeclarator - Determine the full declaration name for the
1730 /// given Declarator.
1731 DeclarationName Sema::GetNameForDeclarator(Declarator &D) {
1732 return GetNameFromUnqualifiedId(D.getName());
1735 /// \brief Retrieves the canonicalized name from a parsed unqualified-id.
1736 DeclarationName Sema::GetNameFromUnqualifiedId(const UnqualifiedId &Name) {
1737 switch (Name.getKind()) {
1738 case UnqualifiedId::IK_Identifier:
1739 return DeclarationName(Name.Identifier);
1741 case UnqualifiedId::IK_OperatorFunctionId:
1742 return Context.DeclarationNames.getCXXOperatorName(
1743 Name.OperatorFunctionId.Operator);
1745 case UnqualifiedId::IK_LiteralOperatorId:
1746 return Context.DeclarationNames.getCXXLiteralOperatorName(
1749 case UnqualifiedId::IK_ConversionFunctionId: {
1750 QualType Ty = GetTypeFromParser(Name.ConversionFunctionId);
1752 return DeclarationName();
1754 return Context.DeclarationNames.getCXXConversionFunctionName(
1755 Context.getCanonicalType(Ty));
1758 case UnqualifiedId::IK_ConstructorName: {
1759 QualType Ty = GetTypeFromParser(Name.ConstructorName);
1761 return DeclarationName();
1763 return Context.DeclarationNames.getCXXConstructorName(
1764 Context.getCanonicalType(Ty));
1767 case UnqualifiedId::IK_ConstructorTemplateId: {
1768 // In well-formed code, we can only have a constructor
1769 // template-id that refers to the current context, so go there
1770 // to find the actual type being constructed.
1771 CXXRecordDecl *CurClass = dyn_cast<CXXRecordDecl>(CurContext);
1772 if (!CurClass || CurClass->getIdentifier() != Name.TemplateId->Name)
1773 return DeclarationName();
1775 // Determine the type of the class being constructed.
1776 QualType CurClassType;
1777 if (ClassTemplateDecl *ClassTemplate
1778 = CurClass->getDescribedClassTemplate())
1779 CurClassType = ClassTemplate->getInjectedClassNameType(Context);
1781 CurClassType = Context.getTypeDeclType(CurClass);
1783 // FIXME: Check two things: that the template-id names the same type as
1784 // CurClassType, and that the template-id does not occur when the name
1787 return Context.DeclarationNames.getCXXConstructorName(
1788 Context.getCanonicalType(CurClassType));
1791 case UnqualifiedId::IK_DestructorName: {
1792 QualType Ty = GetTypeFromParser(Name.DestructorName);
1794 return DeclarationName();
1796 return Context.DeclarationNames.getCXXDestructorName(
1797 Context.getCanonicalType(Ty));
1800 case UnqualifiedId::IK_TemplateId: {
1802 = TemplateName::getFromVoidPointer(Name.TemplateId->Template);
1803 return Context.getNameForTemplate(TName);
1807 assert(false && "Unknown name kind");
1808 return DeclarationName();
1811 /// isNearlyMatchingFunction - Determine whether the C++ functions
1812 /// Declaration and Definition are "nearly" matching. This heuristic
1813 /// is used to improve diagnostics in the case where an out-of-line
1814 /// function definition doesn't match any declaration within
1815 /// the class or namespace.
1816 static bool isNearlyMatchingFunction(ASTContext &Context,
1817 FunctionDecl *Declaration,
1818 FunctionDecl *Definition) {
1819 if (Declaration->param_size() != Definition->param_size())
1821 for (unsigned Idx = 0; Idx < Declaration->param_size(); ++Idx) {
1822 QualType DeclParamTy = Declaration->getParamDecl(Idx)->getType();
1823 QualType DefParamTy = Definition->getParamDecl(Idx)->getType();
1825 if (!Context.hasSameUnqualifiedType(DeclParamTy.getNonReferenceType(),
1826 DefParamTy.getNonReferenceType()))
1834 Sema::HandleDeclarator(Scope *S, Declarator &D,
1835 MultiTemplateParamsArg TemplateParamLists,
1836 bool IsFunctionDefinition) {
1837 DeclarationName Name = GetNameForDeclarator(D);
1839 // All of these full declarators require an identifier. If it doesn't have
1840 // one, the ParsedFreeStandingDeclSpec action should be used.
1842 if (!D.isInvalidType()) // Reject this if we think it is valid.
1843 Diag(D.getDeclSpec().getSourceRange().getBegin(),
1844 diag::err_declarator_need_ident)
1845 << D.getDeclSpec().getSourceRange() << D.getSourceRange();
1849 // The scope passed in may not be a decl scope. Zip up the scope tree until
1850 // we find one that is.
1851 while ((S->getFlags() & Scope::DeclScope) == 0 ||
1852 (S->getFlags() & Scope::TemplateParamScope) != 0)
1855 // If this is an out-of-line definition of a member of a class template
1856 // or class template partial specialization, we may need to rebuild the
1857 // type specifier in the declarator. See RebuildTypeInCurrentInstantiation()
1858 // for more information.
1859 // FIXME: cope with decltype(expr) and typeof(expr) once the rebuilder can
1860 // handle expressions properly.
1861 DeclSpec &DS = const_cast<DeclSpec&>(D.getDeclSpec());
1862 if (D.getCXXScopeSpec().isSet() && !D.getCXXScopeSpec().isInvalid() &&
1863 isDependentScopeSpecifier(D.getCXXScopeSpec()) &&
1864 (DS.getTypeSpecType() == DeclSpec::TST_typename ||
1865 DS.getTypeSpecType() == DeclSpec::TST_typeofType ||
1866 DS.getTypeSpecType() == DeclSpec::TST_typeofExpr ||
1867 DS.getTypeSpecType() == DeclSpec::TST_decltype)) {
1868 if (DeclContext *DC = computeDeclContext(D.getCXXScopeSpec(), true)) {
1869 // FIXME: Preserve type source info.
1870 QualType T = GetTypeFromParser(DS.getTypeRep());
1872 DeclContext *SavedContext = CurContext;
1874 T = RebuildTypeInCurrentInstantiation(T, D.getIdentifierLoc(), Name);
1875 CurContext = SavedContext;
1879 DS.UpdateTypeRep(T.getAsOpaquePtr());
1886 TypeSourceInfo *TInfo = 0;
1887 QualType R = GetTypeForDeclarator(D, S, &TInfo);
1889 LookupResult Previous(*this, Name, D.getIdentifierLoc(), LookupOrdinaryName,
1892 // See if this is a redefinition of a variable in the same scope.
1893 if (D.getCXXScopeSpec().isInvalid()) {
1896 } else if (!D.getCXXScopeSpec().isSet()) {
1897 bool IsLinkageLookup = false;
1899 // If the declaration we're planning to build will be a function
1900 // or object with linkage, then look for another declaration with
1901 // linkage (C99 6.2.2p4-5 and C++ [basic.link]p6).
1902 if (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_typedef)
1904 else if (R->isFunctionType()) {
1905 if (CurContext->isFunctionOrMethod() ||
1906 D.getDeclSpec().getStorageClassSpec() != DeclSpec::SCS_static)
1907 IsLinkageLookup = true;
1908 } else if (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_extern)
1909 IsLinkageLookup = true;
1910 else if (CurContext->getLookupContext()->isTranslationUnit() &&
1911 D.getDeclSpec().getStorageClassSpec() != DeclSpec::SCS_static)
1912 IsLinkageLookup = true;
1914 if (IsLinkageLookup)
1915 Previous.clear(LookupRedeclarationWithLinkage);
1918 LookupName(Previous, S, /* CreateBuiltins = */ IsLinkageLookup);
1919 } else { // Something like "int foo::x;"
1920 DC = computeDeclContext(D.getCXXScopeSpec(), true);
1923 // If we could not compute the declaration context, it's because the
1924 // declaration context is dependent but does not refer to a class,
1925 // class template, or class template partial specialization. Complain
1926 // and return early, to avoid the coming semantic disaster.
1927 Diag(D.getIdentifierLoc(),
1928 diag::err_template_qualified_declarator_no_match)
1929 << (NestedNameSpecifier*)D.getCXXScopeSpec().getScopeRep()
1930 << D.getCXXScopeSpec().getRange();
1934 if (!DC->isDependentContext() &&
1935 RequireCompleteDeclContext(D.getCXXScopeSpec()))
1938 if (isa<CXXRecordDecl>(DC) && !cast<CXXRecordDecl>(DC)->hasDefinition()) {
1939 Diag(D.getIdentifierLoc(),
1940 diag::err_member_def_undefined_record)
1941 << Name << DC << D.getCXXScopeSpec().getRange();
1945 LookupQualifiedName(Previous, DC);
1947 // Don't consider using declarations as previous declarations for
1948 // out-of-line members.
1949 RemoveUsingDecls(Previous);
1952 // Members (including explicit specializations of templates) of a named
1953 // namespace can also be defined outside that namespace by explicit
1954 // qualification of the name being defined, provided that the entity being
1955 // defined was already declared in the namespace and the definition appears
1956 // after the point of declaration in a namespace that encloses the
1957 // declarations namespace.
1959 // Note that we only check the context at this point. We don't yet
1960 // have enough information to make sure that PrevDecl is actually
1961 // the declaration we want to match. For example, given:
1968 // void X::f(int) { } // ill-formed
1970 // In this case, PrevDecl will point to the overload set
1971 // containing the two f's declared in X, but neither of them
1974 // First check whether we named the global scope.
1975 if (isa<TranslationUnitDecl>(DC)) {
1976 Diag(D.getIdentifierLoc(), diag::err_invalid_declarator_global_scope)
1977 << Name << D.getCXXScopeSpec().getRange();
1979 DeclContext *Cur = CurContext;
1980 while (isa<LinkageSpecDecl>(Cur))
1981 Cur = Cur->getParent();
1982 if (!Cur->Encloses(DC)) {
1983 // The qualifying scope doesn't enclose the original declaration.
1984 // Emit diagnostic based on current scope.
1985 SourceLocation L = D.getIdentifierLoc();
1986 SourceRange R = D.getCXXScopeSpec().getRange();
1987 if (isa<FunctionDecl>(Cur))
1988 Diag(L, diag::err_invalid_declarator_in_function) << Name << R;
1990 Diag(L, diag::err_invalid_declarator_scope)
1991 << Name << cast<NamedDecl>(DC) << R;
1997 if (Previous.isSingleResult() &&
1998 Previous.getFoundDecl()->isTemplateParameter()) {
1999 // Maybe we will complain about the shadowed template parameter.
2000 if (!D.isInvalidType())
2001 if (DiagnoseTemplateParameterShadow(D.getIdentifierLoc(),
2002 Previous.getFoundDecl()))
2005 // Just pretend that we didn't see the previous declaration.
2009 // In C++, the previous declaration we find might be a tag type
2010 // (class or enum). In this case, the new declaration will hide the
2011 // tag type. Note that this does does not apply if we're declaring a
2012 // typedef (C++ [dcl.typedef]p4).
2013 if (Previous.isSingleTagDecl() &&
2014 D.getDeclSpec().getStorageClassSpec() != DeclSpec::SCS_typedef)
2017 bool Redeclaration = false;
2018 if (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_typedef) {
2019 if (TemplateParamLists.size()) {
2020 Diag(D.getIdentifierLoc(), diag::err_template_typedef);
2024 New = ActOnTypedefDeclarator(S, D, DC, R, TInfo, Previous, Redeclaration);
2025 } else if (R->isFunctionType()) {
2026 New = ActOnFunctionDeclarator(S, D, DC, R, TInfo, Previous,
2027 move(TemplateParamLists),
2028 IsFunctionDefinition, Redeclaration);
2030 New = ActOnVariableDeclarator(S, D, DC, R, TInfo, Previous,
2031 move(TemplateParamLists),
2038 // If this has an identifier and is not an invalid redeclaration or
2039 // function template specialization, add it to the scope stack.
2040 if (Name && !(Redeclaration && New->isInvalidDecl()))
2041 PushOnScopeChains(New, S);
2043 return DeclPtrTy::make(New);
2046 /// TryToFixInvalidVariablyModifiedType - Helper method to turn variable array
2047 /// types into constant array types in certain situations which would otherwise
2048 /// be errors (for GCC compatibility).
2049 static QualType TryToFixInvalidVariablyModifiedType(QualType T,
2050 ASTContext &Context,
2051 bool &SizeIsNegative) {
2052 // This method tries to turn a variable array into a constant
2053 // array even when the size isn't an ICE. This is necessary
2054 // for compatibility with code that depends on gcc's buggy
2055 // constant expression folding, like struct {char x[(int)(char*)2];}
2056 SizeIsNegative = false;
2058 QualifierCollector Qs;
2059 const Type *Ty = Qs.strip(T);
2061 if (const PointerType* PTy = dyn_cast<PointerType>(Ty)) {
2062 QualType Pointee = PTy->getPointeeType();
2063 QualType FixedType =
2064 TryToFixInvalidVariablyModifiedType(Pointee, Context, SizeIsNegative);
2065 if (FixedType.isNull()) return FixedType;
2066 FixedType = Context.getPointerType(FixedType);
2067 return Qs.apply(FixedType);
2070 const VariableArrayType* VLATy = dyn_cast<VariableArrayType>(T);
2073 // FIXME: We should probably handle this case
2074 if (VLATy->getElementType()->isVariablyModifiedType())
2077 Expr::EvalResult EvalResult;
2078 if (!VLATy->getSizeExpr() ||
2079 !VLATy->getSizeExpr()->Evaluate(EvalResult, Context) ||
2080 !EvalResult.Val.isInt())
2083 llvm::APSInt &Res = EvalResult.Val.getInt();
2084 if (Res >= llvm::APSInt(Res.getBitWidth(), Res.isUnsigned())) {
2085 // TODO: preserve the size expression in declarator info
2086 return Context.getConstantArrayType(VLATy->getElementType(),
2087 Res, ArrayType::Normal, 0);
2090 SizeIsNegative = true;
2094 /// \brief Register the given locally-scoped external C declaration so
2095 /// that it can be found later for redeclarations
2097 Sema::RegisterLocallyScopedExternCDecl(NamedDecl *ND,
2098 const LookupResult &Previous,
2100 assert(ND->getLexicalDeclContext()->isFunctionOrMethod() &&
2101 "Decl is not a locally-scoped decl!");
2102 // Note that we have a locally-scoped external with this name.
2103 LocallyScopedExternalDecls[ND->getDeclName()] = ND;
2105 if (!Previous.isSingleResult())
2108 NamedDecl *PrevDecl = Previous.getFoundDecl();
2110 // If there was a previous declaration of this variable, it may be
2111 // in our identifier chain. Update the identifier chain with the new
2113 if (S && IdResolver.ReplaceDecl(PrevDecl, ND)) {
2114 // The previous declaration was found on the identifer resolver
2115 // chain, so remove it from its scope.
2116 while (S && !S->isDeclScope(DeclPtrTy::make(PrevDecl)))
2120 S->RemoveDecl(DeclPtrTy::make(PrevDecl));
2124 /// \brief Diagnose function specifiers on a declaration of an identifier that
2125 /// does not identify a function.
2126 void Sema::DiagnoseFunctionSpecifiers(Declarator& D) {
2127 // FIXME: We should probably indicate the identifier in question to avoid
2128 // confusion for constructs like "inline int a(), b;"
2129 if (D.getDeclSpec().isInlineSpecified())
2130 Diag(D.getDeclSpec().getInlineSpecLoc(),
2131 diag::err_inline_non_function);
2133 if (D.getDeclSpec().isVirtualSpecified())
2134 Diag(D.getDeclSpec().getVirtualSpecLoc(),
2135 diag::err_virtual_non_function);
2137 if (D.getDeclSpec().isExplicitSpecified())
2138 Diag(D.getDeclSpec().getExplicitSpecLoc(),
2139 diag::err_explicit_non_function);
2143 Sema::ActOnTypedefDeclarator(Scope* S, Declarator& D, DeclContext* DC,
2144 QualType R, TypeSourceInfo *TInfo,
2145 LookupResult &Previous, bool &Redeclaration) {
2146 // Typedef declarators cannot be qualified (C++ [dcl.meaning]p1).
2147 if (D.getCXXScopeSpec().isSet()) {
2148 Diag(D.getIdentifierLoc(), diag::err_qualified_typedef_declarator)
2149 << D.getCXXScopeSpec().getRange();
2151 // Pretend we didn't see the scope specifier.
2155 if (getLangOptions().CPlusPlus) {
2156 // Check that there are no default arguments (C++ only).
2157 CheckExtraCXXDefaultArguments(D);
2160 DiagnoseFunctionSpecifiers(D);
2162 if (D.getDeclSpec().isThreadSpecified())
2163 Diag(D.getDeclSpec().getThreadSpecLoc(), diag::err_invalid_thread);
2165 TypedefDecl *NewTD = ParseTypedefDecl(S, D, R, TInfo);
2166 if (!NewTD) return 0;
2168 // Handle attributes prior to checking for duplicates in MergeVarDecl
2169 ProcessDeclAttributes(S, NewTD, D);
2171 // Merge the decl with the existing one if appropriate. If the decl is
2172 // in an outer scope, it isn't the same thing.
2173 FilterLookupForScope(*this, Previous, DC, S, /*ConsiderLinkage*/ false);
2174 if (!Previous.empty()) {
2175 Redeclaration = true;
2176 MergeTypeDefDecl(NewTD, Previous);
2179 // C99 6.7.7p2: If a typedef name specifies a variably modified type
2180 // then it shall have block scope.
2181 QualType T = NewTD->getUnderlyingType();
2182 if (T->isVariablyModifiedType()) {
2183 FunctionNeedsScopeChecking() = true;
2185 if (S->getFnParent() == 0) {
2186 bool SizeIsNegative;
2188 TryToFixInvalidVariablyModifiedType(T, Context, SizeIsNegative);
2189 if (!FixedTy.isNull()) {
2190 Diag(D.getIdentifierLoc(), diag::warn_illegal_constant_array_size);
2191 NewTD->setTypeSourceInfo(Context.getTrivialTypeSourceInfo(FixedTy));
2194 Diag(D.getIdentifierLoc(), diag::err_typecheck_negative_array_size);
2195 else if (T->isVariableArrayType())
2196 Diag(D.getIdentifierLoc(), diag::err_vla_decl_in_file_scope);
2198 Diag(D.getIdentifierLoc(), diag::err_vm_decl_in_file_scope);
2199 NewTD->setInvalidDecl();
2204 // If this is the C FILE type, notify the AST context.
2205 if (IdentifierInfo *II = NewTD->getIdentifier())
2206 if (!NewTD->isInvalidDecl() &&
2207 NewTD->getDeclContext()->getLookupContext()->isTranslationUnit()) {
2208 if (II->isStr("FILE"))
2209 Context.setFILEDecl(NewTD);
2210 else if (II->isStr("jmp_buf"))
2211 Context.setjmp_bufDecl(NewTD);
2212 else if (II->isStr("sigjmp_buf"))
2213 Context.setsigjmp_bufDecl(NewTD);
2219 /// \brief Determines whether the given declaration is an out-of-scope
2220 /// previous declaration.
2222 /// This routine should be invoked when name lookup has found a
2223 /// previous declaration (PrevDecl) that is not in the scope where a
2224 /// new declaration by the same name is being introduced. If the new
2225 /// declaration occurs in a local scope, previous declarations with
2226 /// linkage may still be considered previous declarations (C99
2227 /// 6.2.2p4-5, C++ [basic.link]p6).
2229 /// \param PrevDecl the previous declaration found by name
2232 /// \param DC the context in which the new declaration is being
2235 /// \returns true if PrevDecl is an out-of-scope previous declaration
2236 /// for a new delcaration with the same name.
2238 isOutOfScopePreviousDeclaration(NamedDecl *PrevDecl, DeclContext *DC,
2239 ASTContext &Context) {
2243 if (!PrevDecl->hasLinkage())
2246 if (Context.getLangOptions().CPlusPlus) {
2247 // C++ [basic.link]p6:
2248 // If there is a visible declaration of an entity with linkage
2249 // having the same name and type, ignoring entities declared
2250 // outside the innermost enclosing namespace scope, the block
2251 // scope declaration declares that same entity and receives the
2252 // linkage of the previous declaration.
2253 DeclContext *OuterContext = DC->getLookupContext();
2254 if (!OuterContext->isFunctionOrMethod())
2255 // This rule only applies to block-scope declarations.
2258 DeclContext *PrevOuterContext = PrevDecl->getDeclContext();
2259 if (PrevOuterContext->isRecord())
2260 // We found a member function: ignore it.
2263 // Find the innermost enclosing namespace for the new and
2264 // previous declarations.
2265 while (!OuterContext->isFileContext())
2266 OuterContext = OuterContext->getParent();
2267 while (!PrevOuterContext->isFileContext())
2268 PrevOuterContext = PrevOuterContext->getParent();
2270 // The previous declaration is in a different namespace, so it
2271 // isn't the same function.
2272 if (OuterContext->getPrimaryContext() !=
2273 PrevOuterContext->getPrimaryContext())
2283 Sema::ActOnVariableDeclarator(Scope* S, Declarator& D, DeclContext* DC,
2284 QualType R, TypeSourceInfo *TInfo,
2285 LookupResult &Previous,
2286 MultiTemplateParamsArg TemplateParamLists,
2287 bool &Redeclaration) {
2288 DeclarationName Name = GetNameForDeclarator(D);
2290 // Check that there are no default arguments (C++ only).
2291 if (getLangOptions().CPlusPlus)
2292 CheckExtraCXXDefaultArguments(D);
2295 VarDecl::StorageClass SC;
2296 switch (D.getDeclSpec().getStorageClassSpec()) {
2297 default: assert(0 && "Unknown storage class!");
2298 case DeclSpec::SCS_unspecified: SC = VarDecl::None; break;
2299 case DeclSpec::SCS_extern: SC = VarDecl::Extern; break;
2300 case DeclSpec::SCS_static: SC = VarDecl::Static; break;
2301 case DeclSpec::SCS_auto: SC = VarDecl::Auto; break;
2302 case DeclSpec::SCS_register: SC = VarDecl::Register; break;
2303 case DeclSpec::SCS_private_extern: SC = VarDecl::PrivateExtern; break;
2304 case DeclSpec::SCS_mutable:
2305 // mutable can only appear on non-static class members, so it's always
2307 Diag(D.getIdentifierLoc(), diag::err_mutable_nonmember);
2313 IdentifierInfo *II = Name.getAsIdentifierInfo();
2315 Diag(D.getIdentifierLoc(), diag::err_bad_variable_name)
2316 << Name.getAsString();
2320 DiagnoseFunctionSpecifiers(D);
2322 if (!DC->isRecord() && S->getFnParent() == 0) {
2323 // C99 6.9p2: The storage-class specifiers auto and register shall not
2324 // appear in the declaration specifiers in an external declaration.
2325 if (SC == VarDecl::Auto || SC == VarDecl::Register) {
2327 // If this is a register variable with an asm label specified, then this
2328 // is a GNU extension.
2329 if (SC == VarDecl::Register && D.getAsmLabel())
2330 Diag(D.getIdentifierLoc(), diag::err_unsupported_global_register);
2332 Diag(D.getIdentifierLoc(), diag::err_typecheck_sclass_fscope);
2336 if (DC->isRecord() && !CurContext->isRecord()) {
2337 // This is an out-of-line definition of a static data member.
2338 if (SC == VarDecl::Static) {
2339 Diag(D.getDeclSpec().getStorageClassSpecLoc(),
2340 diag::err_static_out_of_line)
2341 << CodeModificationHint::CreateRemoval(
2342 D.getDeclSpec().getStorageClassSpecLoc());
2343 } else if (SC == VarDecl::None)
2344 SC = VarDecl::Static;
2346 if (SC == VarDecl::Static) {
2347 if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(DC)) {
2348 if (RD->isLocalClass())
2349 Diag(D.getIdentifierLoc(),
2350 diag::err_static_data_member_not_allowed_in_local_class)
2351 << Name << RD->getDeclName();
2355 // Match up the template parameter lists with the scope specifier, then
2356 // determine whether we have a template or a template specialization.
2357 bool isExplicitSpecialization = false;
2358 if (TemplateParameterList *TemplateParams
2359 = MatchTemplateParametersToScopeSpecifier(
2360 D.getDeclSpec().getSourceRange().getBegin(),
2361 D.getCXXScopeSpec(),
2362 (TemplateParameterList**)TemplateParamLists.get(),
2363 TemplateParamLists.size(),
2364 isExplicitSpecialization)) {
2365 if (TemplateParams->size() > 0) {
2366 // There is no such thing as a variable template.
2367 Diag(D.getIdentifierLoc(), diag::err_template_variable)
2369 << SourceRange(TemplateParams->getTemplateLoc(),
2370 TemplateParams->getRAngleLoc());
2373 // There is an extraneous 'template<>' for this variable. Complain
2374 // about it, but allow the declaration of the variable.
2375 Diag(TemplateParams->getTemplateLoc(),
2376 diag::err_template_variable_noparams)
2378 << SourceRange(TemplateParams->getTemplateLoc(),
2379 TemplateParams->getRAngleLoc());
2381 isExplicitSpecialization = true;
2385 NewVD = VarDecl::Create(Context, DC, D.getIdentifierLoc(),
2388 if (D.isInvalidType())
2389 NewVD->setInvalidDecl();
2391 if (D.getDeclSpec().isThreadSpecified()) {
2392 if (NewVD->hasLocalStorage())
2393 Diag(D.getDeclSpec().getThreadSpecLoc(), diag::err_thread_non_global);
2394 else if (!Context.Target.isTLSSupported())
2395 Diag(D.getDeclSpec().getThreadSpecLoc(), diag::err_thread_unsupported);
2397 NewVD->setThreadSpecified(true);
2400 // Set the lexical context. If the declarator has a C++ scope specifier, the
2401 // lexical context will be different from the semantic context.
2402 NewVD->setLexicalDeclContext(CurContext);
2404 // Handle attributes prior to checking for duplicates in MergeVarDecl
2405 ProcessDeclAttributes(S, NewVD, D);
2407 // Handle GNU asm-label extension (encoded as an attribute).
2408 if (Expr *E = (Expr*) D.getAsmLabel()) {
2409 // The parser guarantees this is a string.
2410 StringLiteral *SE = cast<StringLiteral>(E);
2411 NewVD->addAttr(::new (Context) AsmLabelAttr(Context, SE->getString()));
2414 // Don't consider existing declarations that are in a different
2415 // scope and are out-of-semantic-context declarations (if the new
2416 // declaration has linkage).
2417 FilterLookupForScope(*this, Previous, DC, S, NewVD->hasLinkage());
2419 // Merge the decl with the existing one if appropriate.
2420 if (!Previous.empty()) {
2421 if (Previous.isSingleResult() &&
2422 isa<FieldDecl>(Previous.getFoundDecl()) &&
2423 D.getCXXScopeSpec().isSet()) {
2424 // The user tried to define a non-static data member
2425 // out-of-line (C++ [dcl.meaning]p1).
2426 Diag(NewVD->getLocation(), diag::err_nonstatic_member_out_of_line)
2427 << D.getCXXScopeSpec().getRange();
2429 NewVD->setInvalidDecl();
2431 } else if (D.getCXXScopeSpec().isSet()) {
2432 // No previous declaration in the qualifying scope.
2433 Diag(D.getIdentifierLoc(), diag::err_no_member)
2434 << Name << computeDeclContext(D.getCXXScopeSpec(), true)
2435 << D.getCXXScopeSpec().getRange();
2436 NewVD->setInvalidDecl();
2439 CheckVariableDeclaration(NewVD, Previous, Redeclaration);
2441 // This is an explicit specialization of a static data member. Check it.
2442 if (isExplicitSpecialization && !NewVD->isInvalidDecl() &&
2443 CheckMemberSpecialization(NewVD, Previous))
2444 NewVD->setInvalidDecl();
2446 // attributes declared post-definition are currently ignored
2447 if (Previous.isSingleResult()) {
2448 VarDecl *Def = dyn_cast<VarDecl>(Previous.getFoundDecl());
2449 if (Def && (Def = Def->getDefinition()) &&
2450 Def != NewVD && D.hasAttributes()) {
2451 Diag(NewVD->getLocation(), diag::warn_attribute_precede_definition);
2452 Diag(Def->getLocation(), diag::note_previous_definition);
2456 // If this is a locally-scoped extern C variable, update the map of
2458 if (CurContext->isFunctionOrMethod() && NewVD->isExternC() &&
2459 !NewVD->isInvalidDecl())
2460 RegisterLocallyScopedExternCDecl(NewVD, Previous, S);
2465 /// \brief Perform semantic checking on a newly-created variable
2468 /// This routine performs all of the type-checking required for a
2469 /// variable declaration once it has been built. It is used both to
2470 /// check variables after they have been parsed and their declarators
2471 /// have been translated into a declaration, and to check variables
2472 /// that have been instantiated from a template.
2474 /// Sets NewVD->isInvalidDecl() if an error was encountered.
2475 void Sema::CheckVariableDeclaration(VarDecl *NewVD,
2476 LookupResult &Previous,
2477 bool &Redeclaration) {
2478 // If the decl is already known invalid, don't check it.
2479 if (NewVD->isInvalidDecl())
2482 QualType T = NewVD->getType();
2484 if (T->isObjCInterfaceType()) {
2485 Diag(NewVD->getLocation(), diag::err_statically_allocated_object);
2486 return NewVD->setInvalidDecl();
2489 // Emit an error if an address space was applied to decl with local storage.
2490 // This includes arrays of objects with address space qualifiers, but not
2491 // automatic variables that point to other address spaces.
2492 // ISO/IEC TR 18037 S5.1.2
2493 if (NewVD->hasLocalStorage() && (T.getAddressSpace() != 0)) {
2494 Diag(NewVD->getLocation(), diag::err_as_qualified_auto_decl);
2495 return NewVD->setInvalidDecl();
2498 if (NewVD->hasLocalStorage() && T.isObjCGCWeak()
2499 && !NewVD->hasAttr<BlocksAttr>())
2500 Diag(NewVD->getLocation(), diag::warn_attribute_weak_on_local);
2502 bool isVM = T->isVariablyModifiedType();
2503 if (isVM || NewVD->hasAttr<CleanupAttr>() ||
2504 NewVD->hasAttr<BlocksAttr>() ||
2505 // FIXME: We need to diagnose jumps passed initialized variables in C++.
2506 // However, this turns on the scope checker for everything with a variable
2507 // which may impact compile time. See if we can find a better solution
2508 // to this, perhaps only checking functions that contain gotos in C++?
2509 (LangOpts.CPlusPlus && NewVD->hasLocalStorage()))
2510 FunctionNeedsScopeChecking() = true;
2512 if ((isVM && NewVD->hasLinkage()) ||
2513 (T->isVariableArrayType() && NewVD->hasGlobalStorage())) {
2514 bool SizeIsNegative;
2516 TryToFixInvalidVariablyModifiedType(T, Context, SizeIsNegative);
2518 if (FixedTy.isNull() && T->isVariableArrayType()) {
2519 const VariableArrayType *VAT = Context.getAsVariableArrayType(T);
2520 // FIXME: This won't give the correct result for
2522 SourceRange SizeRange = VAT->getSizeExpr()->getSourceRange();
2524 if (NewVD->isFileVarDecl())
2525 Diag(NewVD->getLocation(), diag::err_vla_decl_in_file_scope)
2527 else if (NewVD->getStorageClass() == VarDecl::Static)
2528 Diag(NewVD->getLocation(), diag::err_vla_decl_has_static_storage)
2531 Diag(NewVD->getLocation(), diag::err_vla_decl_has_extern_linkage)
2533 return NewVD->setInvalidDecl();
2536 if (FixedTy.isNull()) {
2537 if (NewVD->isFileVarDecl())
2538 Diag(NewVD->getLocation(), diag::err_vm_decl_in_file_scope);
2540 Diag(NewVD->getLocation(), diag::err_vm_decl_has_extern_linkage);
2541 return NewVD->setInvalidDecl();
2544 Diag(NewVD->getLocation(), diag::warn_illegal_constant_array_size);
2545 NewVD->setType(FixedTy);
2548 if (Previous.empty() && NewVD->isExternC()) {
2549 // Since we did not find anything by this name and we're declaring
2550 // an extern "C" variable, look for a non-visible extern "C"
2551 // declaration with the same name.
2552 llvm::DenseMap<DeclarationName, NamedDecl *>::iterator Pos
2553 = LocallyScopedExternalDecls.find(NewVD->getDeclName());
2554 if (Pos != LocallyScopedExternalDecls.end())
2555 Previous.addDecl(Pos->second);
2558 if (T->isVoidType() && !NewVD->hasExternalStorage()) {
2559 Diag(NewVD->getLocation(), diag::err_typecheck_decl_incomplete_type)
2561 return NewVD->setInvalidDecl();
2564 if (!NewVD->hasLocalStorage() && NewVD->hasAttr<BlocksAttr>()) {
2565 Diag(NewVD->getLocation(), diag::err_block_on_nonlocal);
2566 return NewVD->setInvalidDecl();
2569 if (isVM && NewVD->hasAttr<BlocksAttr>()) {
2570 Diag(NewVD->getLocation(), diag::err_block_on_vm);
2571 return NewVD->setInvalidDecl();
2574 if (!Previous.empty()) {
2575 Redeclaration = true;
2576 MergeVarDecl(NewVD, Previous);
2580 /// \brief Data used with FindOverriddenMethod
2581 struct FindOverriddenMethodData {
2583 CXXMethodDecl *Method;
2586 /// \brief Member lookup function that determines whether a given C++
2587 /// method overrides a method in a base class, to be used with
2588 /// CXXRecordDecl::lookupInBases().
2589 static bool FindOverriddenMethod(const CXXBaseSpecifier *Specifier,
2592 RecordDecl *BaseRecord = Specifier->getType()->getAs<RecordType>()->getDecl();
2594 FindOverriddenMethodData *Data
2595 = reinterpret_cast<FindOverriddenMethodData*>(UserData);
2597 DeclarationName Name = Data->Method->getDeclName();
2599 // FIXME: Do we care about other names here too?
2600 if (Name.getNameKind() == DeclarationName::CXXDestructorName) {
2601 // We really want to find the base class constructor here.
2602 QualType T = Data->S->Context.getTypeDeclType(BaseRecord);
2603 CanQualType CT = Data->S->Context.getCanonicalType(T);
2605 Name = Data->S->Context.DeclarationNames.getCXXDestructorName(CT);
2608 for (Path.Decls = BaseRecord->lookup(Name);
2609 Path.Decls.first != Path.Decls.second;
2610 ++Path.Decls.first) {
2611 if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(*Path.Decls.first)) {
2612 if (MD->isVirtual() && !Data->S->IsOverload(Data->Method, MD))
2620 /// AddOverriddenMethods - See if a method overrides any in the base classes,
2621 /// and if so, check that it's a valid override and remember it.
2622 void Sema::AddOverriddenMethods(CXXRecordDecl *DC, CXXMethodDecl *MD) {
2623 // Look for virtual methods in base classes that this method might override.
2625 FindOverriddenMethodData Data;
2628 if (DC->lookupInBases(&FindOverriddenMethod, &Data, Paths)) {
2629 for (CXXBasePaths::decl_iterator I = Paths.found_decls_begin(),
2630 E = Paths.found_decls_end(); I != E; ++I) {
2631 if (CXXMethodDecl *OldMD = dyn_cast<CXXMethodDecl>(*I)) {
2632 if (!CheckOverridingFunctionReturnType(MD, OldMD) &&
2633 !CheckOverridingFunctionExceptionSpec(MD, OldMD) &&
2634 !CheckOverridingFunctionAttributes(MD, OldMD))
2635 MD->addOverriddenMethod(OldMD->getCanonicalDecl());
2642 Sema::ActOnFunctionDeclarator(Scope* S, Declarator& D, DeclContext* DC,
2643 QualType R, TypeSourceInfo *TInfo,
2644 LookupResult &Previous,
2645 MultiTemplateParamsArg TemplateParamLists,
2646 bool IsFunctionDefinition, bool &Redeclaration) {
2647 assert(R.getTypePtr()->isFunctionType());
2649 DeclarationName Name = GetNameForDeclarator(D);
2650 FunctionDecl::StorageClass SC = FunctionDecl::None;
2651 switch (D.getDeclSpec().getStorageClassSpec()) {
2652 default: assert(0 && "Unknown storage class!");
2653 case DeclSpec::SCS_auto:
2654 case DeclSpec::SCS_register:
2655 case DeclSpec::SCS_mutable:
2656 Diag(D.getDeclSpec().getStorageClassSpecLoc(),
2657 diag::err_typecheck_sclass_func);
2660 case DeclSpec::SCS_unspecified: SC = FunctionDecl::None; break;
2661 case DeclSpec::SCS_extern: SC = FunctionDecl::Extern; break;
2662 case DeclSpec::SCS_static: {
2663 if (CurContext->getLookupContext()->isFunctionOrMethod()) {
2665 // The declaration of an identifier for a function that has
2666 // block scope shall have no explicit storage-class specifier
2667 // other than extern
2668 // See also (C++ [dcl.stc]p4).
2669 Diag(D.getDeclSpec().getStorageClassSpecLoc(),
2670 diag::err_static_block_func);
2671 SC = FunctionDecl::None;
2673 SC = FunctionDecl::Static;
2676 case DeclSpec::SCS_private_extern: SC = FunctionDecl::PrivateExtern;break;
2679 if (D.getDeclSpec().isThreadSpecified())
2680 Diag(D.getDeclSpec().getThreadSpecLoc(), diag::err_invalid_thread);
2682 bool isFriend = D.getDeclSpec().isFriendSpecified();
2683 bool isInline = D.getDeclSpec().isInlineSpecified();
2684 bool isVirtual = D.getDeclSpec().isVirtualSpecified();
2685 bool isExplicit = D.getDeclSpec().isExplicitSpecified();
2687 // Check that the return type is not an abstract class type.
2688 // For record types, this is done by the AbstractClassUsageDiagnoser once
2689 // the class has been completely parsed.
2690 if (!DC->isRecord() &&
2691 RequireNonAbstractType(D.getIdentifierLoc(),
2692 R->getAs<FunctionType>()->getResultType(),
2693 diag::err_abstract_type_in_decl,
2694 AbstractReturnType))
2697 // Do not allow returning a objc interface by-value.
2698 if (R->getAs<FunctionType>()->getResultType()->isObjCInterfaceType()) {
2699 Diag(D.getIdentifierLoc(),
2700 diag::err_object_cannot_be_passed_returned_by_value) << 0
2701 << R->getAs<FunctionType>()->getResultType();
2705 bool isVirtualOkay = false;
2706 FunctionDecl *NewFD;
2709 // C++ [class.friend]p5
2710 // A function can be defined in a friend declaration of a
2711 // class . . . . Such a function is implicitly inline.
2712 isInline |= IsFunctionDefinition;
2715 if (Name.getNameKind() == DeclarationName::CXXConstructorName) {
2716 // This is a C++ constructor declaration.
2717 assert(DC->isRecord() &&
2718 "Constructors can only be declared in a member context");
2720 R = CheckConstructorDeclarator(D, R, SC);
2722 // Create the new declaration
2723 NewFD = CXXConstructorDecl::Create(Context,
2724 cast<CXXRecordDecl>(DC),
2725 D.getIdentifierLoc(), Name, R, TInfo,
2726 isExplicit, isInline,
2727 /*isImplicitlyDeclared=*/false);
2728 } else if (Name.getNameKind() == DeclarationName::CXXDestructorName) {
2729 // This is a C++ destructor declaration.
2730 if (DC->isRecord()) {
2731 R = CheckDestructorDeclarator(D, SC);
2733 NewFD = CXXDestructorDecl::Create(Context,
2734 cast<CXXRecordDecl>(DC),
2735 D.getIdentifierLoc(), Name, R,
2737 /*isImplicitlyDeclared=*/false);
2739 isVirtualOkay = true;
2741 Diag(D.getIdentifierLoc(), diag::err_destructor_not_member);
2743 // Create a FunctionDecl to satisfy the function definition parsing
2745 NewFD = FunctionDecl::Create(Context, DC, D.getIdentifierLoc(),
2746 Name, R, TInfo, SC, isInline,
2747 /*hasPrototype=*/true);
2750 } else if (Name.getNameKind() == DeclarationName::CXXConversionFunctionName) {
2751 if (!DC->isRecord()) {
2752 Diag(D.getIdentifierLoc(),
2753 diag::err_conv_function_not_member);
2757 CheckConversionDeclarator(D, R, SC);
2758 NewFD = CXXConversionDecl::Create(Context, cast<CXXRecordDecl>(DC),
2759 D.getIdentifierLoc(), Name, R, TInfo,
2760 isInline, isExplicit);
2762 isVirtualOkay = true;
2763 } else if (DC->isRecord()) {
2764 // If the of the function is the same as the name of the record, then this
2765 // must be an invalid constructor that has a return type.
2766 // (The parser checks for a return type and makes the declarator a
2767 // constructor if it has no return type).
2768 // must have an invalid constructor that has a return type
2769 if (Name.getAsIdentifierInfo() &&
2770 Name.getAsIdentifierInfo() == cast<CXXRecordDecl>(DC)->getIdentifier()){
2771 Diag(D.getIdentifierLoc(), diag::err_constructor_return_type)
2772 << SourceRange(D.getDeclSpec().getTypeSpecTypeLoc())
2773 << SourceRange(D.getIdentifierLoc());
2777 bool isStatic = SC == FunctionDecl::Static;
2780 // Any allocation function for a class T is a static member
2781 // (even if not explicitly declared static).
2782 if (Name.getCXXOverloadedOperator() == OO_New ||
2783 Name.getCXXOverloadedOperator() == OO_Array_New)
2786 // [class.free]p6 Any deallocation function for a class X is a static member
2787 // (even if not explicitly declared static).
2788 if (Name.getCXXOverloadedOperator() == OO_Delete ||
2789 Name.getCXXOverloadedOperator() == OO_Array_Delete)
2792 // This is a C++ method declaration.
2793 NewFD = CXXMethodDecl::Create(Context, cast<CXXRecordDecl>(DC),
2794 D.getIdentifierLoc(), Name, R, TInfo,
2795 isStatic, isInline);
2797 isVirtualOkay = !isStatic;
2799 // Determine whether the function was written with a
2800 // prototype. This true when:
2801 // - we're in C++ (where every function has a prototype),
2802 // - there is a prototype in the declarator, or
2803 // - the type R of the function is some kind of typedef or other reference
2804 // to a type name (which eventually refers to a function type).
2806 getLangOptions().CPlusPlus ||
2807 (D.getNumTypeObjects() && D.getTypeObject(0).Fun.hasPrototype) ||
2808 (!isa<FunctionType>(R.getTypePtr()) && R->isFunctionProtoType());
2810 NewFD = FunctionDecl::Create(Context, DC,
2811 D.getIdentifierLoc(),
2812 Name, R, TInfo, SC, isInline, HasPrototype);
2815 if (D.isInvalidType())
2816 NewFD->setInvalidDecl();
2818 // Set the lexical context. If the declarator has a C++
2819 // scope specifier, or is the object of a friend declaration, the
2820 // lexical context will be different from the semantic context.
2821 NewFD->setLexicalDeclContext(CurContext);
2823 // Match up the template parameter lists with the scope specifier, then
2824 // determine whether we have a template or a template specialization.
2825 FunctionTemplateDecl *FunctionTemplate = 0;
2826 bool isExplicitSpecialization = false;
2827 bool isFunctionTemplateSpecialization = false;
2828 if (TemplateParameterList *TemplateParams
2829 = MatchTemplateParametersToScopeSpecifier(
2830 D.getDeclSpec().getSourceRange().getBegin(),
2831 D.getCXXScopeSpec(),
2832 (TemplateParameterList**)TemplateParamLists.get(),
2833 TemplateParamLists.size(),
2834 isExplicitSpecialization)) {
2835 if (TemplateParams->size() > 0) {
2836 // This is a function template
2838 // Check that we can declare a template here.
2839 if (CheckTemplateDeclScope(S, TemplateParams))
2842 FunctionTemplate = FunctionTemplateDecl::Create(Context, DC,
2843 NewFD->getLocation(),
2844 Name, TemplateParams,
2846 FunctionTemplate->setLexicalDeclContext(CurContext);
2847 NewFD->setDescribedFunctionTemplate(FunctionTemplate);
2849 // This is a function template specialization.
2850 isFunctionTemplateSpecialization = true;
2853 // FIXME: Free this memory properly.
2854 TemplateParamLists.release();
2857 // C++ [dcl.fct.spec]p5:
2858 // The virtual specifier shall only be used in declarations of
2859 // nonstatic class member functions that appear within a
2860 // member-specification of a class declaration; see 10.3.
2862 if (isVirtual && !NewFD->isInvalidDecl()) {
2863 if (!isVirtualOkay) {
2864 Diag(D.getDeclSpec().getVirtualSpecLoc(),
2865 diag::err_virtual_non_function);
2866 } else if (!CurContext->isRecord()) {
2867 // 'virtual' was specified outside of the class.
2868 Diag(D.getDeclSpec().getVirtualSpecLoc(), diag::err_virtual_out_of_class)
2869 << CodeModificationHint::CreateRemoval(
2870 D.getDeclSpec().getVirtualSpecLoc());
2872 // Okay: Add virtual to the method.
2873 CXXRecordDecl *CurClass = cast<CXXRecordDecl>(DC);
2874 CurClass->setMethodAsVirtual(NewFD);
2878 // C++ [dcl.fct.spec]p6:
2879 // The explicit specifier shall be used only in the declaration of a
2880 // constructor or conversion function within its class definition; see 12.3.1
2882 if (isExplicit && !NewFD->isInvalidDecl()) {
2883 if (!CurContext->isRecord()) {
2884 // 'explicit' was specified outside of the class.
2885 Diag(D.getDeclSpec().getExplicitSpecLoc(),
2886 diag::err_explicit_out_of_class)
2887 << CodeModificationHint::CreateRemoval(
2888 D.getDeclSpec().getExplicitSpecLoc());
2889 } else if (!isa<CXXConstructorDecl>(NewFD) &&
2890 !isa<CXXConversionDecl>(NewFD)) {
2891 // 'explicit' was specified on a function that wasn't a constructor
2892 // or conversion function.
2893 Diag(D.getDeclSpec().getExplicitSpecLoc(),
2894 diag::err_explicit_non_ctor_or_conv_function)
2895 << CodeModificationHint::CreateRemoval(
2896 D.getDeclSpec().getExplicitSpecLoc());
2900 // Filter out previous declarations that don't match the scope.
2901 FilterLookupForScope(*this, Previous, DC, S, NewFD->hasLinkage());
2904 // DC is the namespace in which the function is being declared.
2905 assert((DC->isFileContext() || !Previous.empty()) &&
2906 "previously-undeclared friend function being created "
2907 "in a non-namespace context");
2909 if (FunctionTemplate) {
2910 FunctionTemplate->setObjectOfFriendDecl(
2911 /* PreviouslyDeclared= */ !Previous.empty());
2912 FunctionTemplate->setAccess(AS_public);
2915 NewFD->setObjectOfFriendDecl(/* PreviouslyDeclared= */ !Previous.empty());
2917 NewFD->setAccess(AS_public);
2920 if (SC == FunctionDecl::Static && isa<CXXMethodDecl>(NewFD) &&
2921 !CurContext->isRecord()) {
2922 // C++ [class.static]p1:
2923 // A data or function member of a class may be declared static
2924 // in a class definition, in which case it is a static member of
2927 // Complain about the 'static' specifier if it's on an out-of-line
2928 // member function definition.
2929 Diag(D.getDeclSpec().getStorageClassSpecLoc(),
2930 diag::err_static_out_of_line)
2931 << CodeModificationHint::CreateRemoval(
2932 D.getDeclSpec().getStorageClassSpecLoc());
2935 // Handle GNU asm-label extension (encoded as an attribute).
2936 if (Expr *E = (Expr*) D.getAsmLabel()) {
2937 // The parser guarantees this is a string.
2938 StringLiteral *SE = cast<StringLiteral>(E);
2939 NewFD->addAttr(::new (Context) AsmLabelAttr(Context, SE->getString()));
2942 // Copy the parameter declarations from the declarator D to the function
2943 // declaration NewFD, if they are available. First scavenge them into Params.
2944 llvm::SmallVector<ParmVarDecl*, 16> Params;
2945 if (D.getNumTypeObjects() > 0) {
2946 DeclaratorChunk::FunctionTypeInfo &FTI = D.getTypeObject(0).Fun;
2948 // Check for C99 6.7.5.3p10 - foo(void) is a non-varargs
2949 // function that takes no arguments, not a function that takes a
2950 // single void argument.
2951 // We let through "const void" here because Sema::GetTypeForDeclarator
2952 // already checks for that case.
2953 if (FTI.NumArgs == 1 && !FTI.isVariadic && FTI.ArgInfo[0].Ident == 0 &&
2954 FTI.ArgInfo[0].Param &&
2955 FTI.ArgInfo[0].Param.getAs<ParmVarDecl>()->getType()->isVoidType()) {
2956 // Empty arg list, don't push any params.
2957 ParmVarDecl *Param = FTI.ArgInfo[0].Param.getAs<ParmVarDecl>();
2959 // In C++, the empty parameter-type-list must be spelled "void"; a
2960 // typedef of void is not permitted.
2961 if (getLangOptions().CPlusPlus &&
2962 Param->getType().getUnqualifiedType() != Context.VoidTy)
2963 Diag(Param->getLocation(), diag::err_param_typedef_of_void);
2964 // FIXME: Leaks decl?
2965 } else if (FTI.NumArgs > 0 && FTI.ArgInfo[0].Param != 0) {
2966 for (unsigned i = 0, e = FTI.NumArgs; i != e; ++i) {
2967 ParmVarDecl *Param = FTI.ArgInfo[i].Param.getAs<ParmVarDecl>();
2968 assert(Param->getDeclContext() != NewFD && "Was set before ?");
2969 Param->setDeclContext(NewFD);
2970 Params.push_back(Param);
2974 } else if (const FunctionProtoType *FT = R->getAs<FunctionProtoType>()) {
2975 // When we're declaring a function with a typedef, typeof, etc as in the
2976 // following example, we'll need to synthesize (unnamed)
2977 // parameters for use in the declaration.
2980 // typedef void fn(int);
2984 // Synthesize a parameter for each argument type.
2985 for (FunctionProtoType::arg_type_iterator AI = FT->arg_type_begin(),
2986 AE = FT->arg_type_end(); AI != AE; ++AI) {
2987 ParmVarDecl *Param = ParmVarDecl::Create(Context, NewFD,
2988 SourceLocation(), 0,
2991 Param->setImplicit();
2992 Params.push_back(Param);
2995 assert(R->isFunctionNoProtoType() && NewFD->getNumParams() == 0 &&
2996 "Should not need args for typedef of non-prototype fn");
2998 // Finally, we know we have the right number of parameters, install them.
2999 NewFD->setParams(Params.data(), Params.size());
3001 // If the declarator is a template-id, translate the parser's template
3002 // argument list into our AST format.
3003 bool HasExplicitTemplateArgs = false;
3004 TemplateArgumentListInfo TemplateArgs;
3005 if (D.getName().getKind() == UnqualifiedId::IK_TemplateId) {
3006 TemplateIdAnnotation *TemplateId = D.getName().TemplateId;
3007 TemplateArgs.setLAngleLoc(TemplateId->LAngleLoc);
3008 TemplateArgs.setRAngleLoc(TemplateId->RAngleLoc);
3009 ASTTemplateArgsPtr TemplateArgsPtr(*this,
3010 TemplateId->getTemplateArgs(),
3011 TemplateId->NumArgs);
3012 translateTemplateArguments(TemplateArgsPtr,
3014 TemplateArgsPtr.release();
3016 HasExplicitTemplateArgs = true;
3018 if (FunctionTemplate) {
3019 // FIXME: Diagnose function template with explicit template
3021 HasExplicitTemplateArgs = false;
3022 } else if (!isFunctionTemplateSpecialization &&
3023 !D.getDeclSpec().isFriendSpecified()) {
3024 // We have encountered something that the user meant to be a
3025 // specialization (because it has explicitly-specified template
3026 // arguments) but that was not introduced with a "template<>" (or had
3027 // too few of them).
3028 Diag(D.getIdentifierLoc(), diag::err_template_spec_needs_header)
3029 << SourceRange(TemplateId->LAngleLoc, TemplateId->RAngleLoc)
3030 << CodeModificationHint::CreateInsertion(
3031 D.getDeclSpec().getSourceRange().getBegin(),
3033 isFunctionTemplateSpecialization = true;
3037 if (isFunctionTemplateSpecialization) {
3038 if (CheckFunctionTemplateSpecialization(NewFD,
3039 (HasExplicitTemplateArgs ? &TemplateArgs : 0),
3041 NewFD->setInvalidDecl();
3042 } else if (isExplicitSpecialization && isa<CXXMethodDecl>(NewFD) &&
3043 CheckMemberSpecialization(NewFD, Previous))
3044 NewFD->setInvalidDecl();
3046 // Perform semantic checking on the function declaration.
3047 bool OverloadableAttrRequired = false; // FIXME: HACK!
3048 CheckFunctionDeclaration(S, NewFD, Previous, isExplicitSpecialization,
3049 Redeclaration, /*FIXME:*/OverloadableAttrRequired);
3051 assert((NewFD->isInvalidDecl() || !Redeclaration ||
3052 Previous.getResultKind() != LookupResult::FoundOverloaded) &&
3053 "previous declaration set still overloaded");
3055 // If we have a function template, check the template parameter
3056 // list. This will check and merge default template arguments.
3057 if (FunctionTemplate) {
3058 FunctionTemplateDecl *PrevTemplate = FunctionTemplate->getPreviousDeclaration();
3059 CheckTemplateParameterList(FunctionTemplate->getTemplateParameters(),
3060 PrevTemplate? PrevTemplate->getTemplateParameters() : 0,
3061 D.getDeclSpec().isFriendSpecified()? TPC_FriendFunctionTemplate
3062 : TPC_FunctionTemplate);
3065 if (D.getCXXScopeSpec().isSet() && !NewFD->isInvalidDecl()) {
3066 // Fake up an access specifier if it's supposed to be a class member.
3067 if (!Redeclaration && isa<CXXRecordDecl>(NewFD->getDeclContext()))
3068 NewFD->setAccess(AS_public);
3070 // An out-of-line member function declaration must also be a
3071 // definition (C++ [dcl.meaning]p1).
3072 // Note that this is not the case for explicit specializations of
3073 // function templates or member functions of class templates, per
3074 // C++ [temp.expl.spec]p2.
3075 if (!IsFunctionDefinition && !isFriend &&
3076 !isFunctionTemplateSpecialization && !isExplicitSpecialization) {
3077 Diag(NewFD->getLocation(), diag::err_out_of_line_declaration)
3078 << D.getCXXScopeSpec().getRange();
3079 NewFD->setInvalidDecl();
3080 } else if (!Redeclaration &&
3081 !(isFriend && CurContext->isDependentContext())) {
3082 // The user tried to provide an out-of-line definition for a
3083 // function that is a member of a class or namespace, but there
3084 // was no such member function declared (C++ [class.mfct]p2,
3085 // C++ [namespace.memdef]p2). For example:
3091 // void X::f() { } // ill-formed
3093 // Complain about this problem, and attempt to suggest close
3094 // matches (e.g., those that differ only in cv-qualifiers and
3095 // whether the parameter types are references).
3096 Diag(D.getIdentifierLoc(), diag::err_member_def_does_not_match)
3097 << Name << DC << D.getCXXScopeSpec().getRange();
3098 NewFD->setInvalidDecl();
3100 LookupResult Prev(*this, Name, D.getIdentifierLoc(), LookupOrdinaryName,
3102 LookupQualifiedName(Prev, DC);
3103 assert(!Prev.isAmbiguous() &&
3104 "Cannot have an ambiguity in previous-declaration lookup");
3105 for (LookupResult::iterator Func = Prev.begin(), FuncEnd = Prev.end();
3106 Func != FuncEnd; ++Func) {
3107 if (isa<FunctionDecl>(*Func) &&
3108 isNearlyMatchingFunction(Context, cast<FunctionDecl>(*Func), NewFD))
3109 Diag((*Func)->getLocation(), diag::note_member_def_close_match);
3114 // Handle attributes. We need to have merged decls when handling attributes
3115 // (for example to check for conflicts, etc).
3116 // FIXME: This needs to happen before we merge declarations. Then,
3117 // let attribute merging cope with attribute conflicts.
3118 ProcessDeclAttributes(S, NewFD, D);
3120 // attributes declared post-definition are currently ignored
3121 if (Redeclaration && Previous.isSingleResult()) {
3122 const FunctionDecl *Def;
3123 FunctionDecl *PrevFD = dyn_cast<FunctionDecl>(Previous.getFoundDecl());
3124 if (PrevFD && PrevFD->getBody(Def) && D.hasAttributes()) {
3125 Diag(NewFD->getLocation(), diag::warn_attribute_precede_definition);
3126 Diag(Def->getLocation(), diag::note_previous_definition);
3130 AddKnownFunctionAttributes(NewFD);
3132 if (OverloadableAttrRequired && !NewFD->getAttr<OverloadableAttr>()) {
3133 // If a function name is overloadable in C, then every function
3134 // with that name must be marked "overloadable".
3135 Diag(NewFD->getLocation(), diag::err_attribute_overloadable_missing)
3136 << Redeclaration << NewFD;
3137 if (!Previous.empty())
3138 Diag(Previous.getRepresentativeDecl()->getLocation(),
3139 diag::note_attribute_overloadable_prev_overload);
3140 NewFD->addAttr(::new (Context) OverloadableAttr());
3143 // If this is a locally-scoped extern C function, update the
3144 // map of such names.
3145 if (CurContext->isFunctionOrMethod() && NewFD->isExternC()
3146 && !NewFD->isInvalidDecl())
3147 RegisterLocallyScopedExternCDecl(NewFD, Previous, S);
3149 // Set this FunctionDecl's range up to the right paren.
3150 NewFD->setLocEnd(D.getSourceRange().getEnd());
3152 if (FunctionTemplate && NewFD->isInvalidDecl())
3153 FunctionTemplate->setInvalidDecl();
3155 if (FunctionTemplate)
3156 return FunctionTemplate;
3159 // Keep track of static, non-inlined function definitions that
3160 // have not been used. We will warn later.
3161 // FIXME: Also include static functions declared but not defined.
3162 if (!NewFD->isInvalidDecl() && IsFunctionDefinition
3163 && !NewFD->isInlined() && NewFD->getLinkage() == InternalLinkage
3164 && !NewFD->isUsed() && !NewFD->hasAttr<UnusedAttr>())
3165 UnusedStaticFuncs.push_back(NewFD);
3170 /// \brief Perform semantic checking of a new function declaration.
3172 /// Performs semantic analysis of the new function declaration
3173 /// NewFD. This routine performs all semantic checking that does not
3174 /// require the actual declarator involved in the declaration, and is
3175 /// used both for the declaration of functions as they are parsed
3176 /// (called via ActOnDeclarator) and for the declaration of functions
3177 /// that have been instantiated via C++ template instantiation (called
3178 /// via InstantiateDecl).
3180 /// \param IsExplicitSpecialiation whether this new function declaration is
3181 /// an explicit specialization of the previous declaration.
3183 /// This sets NewFD->isInvalidDecl() to true if there was an error.
3184 void Sema::CheckFunctionDeclaration(Scope *S, FunctionDecl *NewFD,
3185 LookupResult &Previous,
3186 bool IsExplicitSpecialization,
3187 bool &Redeclaration,
3188 bool &OverloadableAttrRequired) {
3189 // If NewFD is already known erroneous, don't do any of this checking.
3190 if (NewFD->isInvalidDecl())
3193 if (NewFD->getResultType()->isVariablyModifiedType()) {
3194 // Functions returning a variably modified type violate C99 6.7.5.2p2
3195 // because all functions have linkage.
3196 Diag(NewFD->getLocation(), diag::err_vm_func_decl);
3197 return NewFD->setInvalidDecl();
3200 if (NewFD->isMain())
3203 // Check for a previous declaration of this name.
3204 if (Previous.empty() && NewFD->isExternC()) {
3205 // Since we did not find anything by this name and we're declaring
3206 // an extern "C" function, look for a non-visible extern "C"
3207 // declaration with the same name.
3208 llvm::DenseMap<DeclarationName, NamedDecl *>::iterator Pos
3209 = LocallyScopedExternalDecls.find(NewFD->getDeclName());
3210 if (Pos != LocallyScopedExternalDecls.end())
3211 Previous.addDecl(Pos->second);
3214 // Merge or overload the declaration with an existing declaration of
3215 // the same name, if appropriate.
3216 if (!Previous.empty()) {
3217 // Determine whether NewFD is an overload of PrevDecl or
3218 // a declaration that requires merging. If it's an overload,
3219 // there's no more work to do here; we'll just add the new
3220 // function to the scope.
3222 NamedDecl *OldDecl = 0;
3223 if (!AllowOverloadingOfFunction(Previous, Context)) {
3224 Redeclaration = true;
3225 OldDecl = Previous.getFoundDecl();
3227 if (!getLangOptions().CPlusPlus) {
3228 OverloadableAttrRequired = true;
3230 // Functions marked "overloadable" must have a prototype (that
3231 // we can't get through declaration merging).
3232 if (!NewFD->getType()->getAs<FunctionProtoType>()) {
3233 Diag(NewFD->getLocation(),
3234 diag::err_attribute_overloadable_no_prototype)
3236 Redeclaration = true;
3238 // Turn this into a variadic function with no parameters.
3239 QualType R = Context.getFunctionType(
3240 NewFD->getType()->getAs<FunctionType>()->getResultType(),
3241 0, 0, true, 0, false, false, 0, 0, false, CC_Default);
3243 return NewFD->setInvalidDecl();
3247 switch (CheckOverload(NewFD, Previous, OldDecl)) {
3249 Redeclaration = true;
3250 if (isa<UsingShadowDecl>(OldDecl) && CurContext->isRecord()) {
3251 HideUsingShadowDecl(S, cast<UsingShadowDecl>(OldDecl));
3252 Redeclaration = false;
3256 case Ovl_NonFunction:
3257 Redeclaration = true;
3261 Redeclaration = false;
3266 if (Redeclaration) {
3267 // NewFD and OldDecl represent declarations that need to be
3269 if (MergeFunctionDecl(NewFD, OldDecl))
3270 return NewFD->setInvalidDecl();
3273 Previous.addDecl(OldDecl);
3275 if (FunctionTemplateDecl *OldTemplateDecl
3276 = dyn_cast<FunctionTemplateDecl>(OldDecl)) {
3277 NewFD->setPreviousDeclaration(OldTemplateDecl->getTemplatedDecl());
3278 FunctionTemplateDecl *NewTemplateDecl
3279 = NewFD->getDescribedFunctionTemplate();
3280 assert(NewTemplateDecl && "Template/non-template mismatch");
3281 if (CXXMethodDecl *Method
3282 = dyn_cast<CXXMethodDecl>(NewTemplateDecl->getTemplatedDecl())) {
3283 Method->setAccess(OldTemplateDecl->getAccess());
3284 NewTemplateDecl->setAccess(OldTemplateDecl->getAccess());
3287 // If this is an explicit specialization of a member that is a function
3288 // template, mark it as a member specialization.
3289 if (IsExplicitSpecialization &&
3290 NewTemplateDecl->getInstantiatedFromMemberTemplate()) {
3291 NewTemplateDecl->setMemberSpecialization();
3292 assert(OldTemplateDecl->isMemberSpecialization());
3295 if (isa<CXXMethodDecl>(NewFD)) // Set access for out-of-line definitions
3296 NewFD->setAccess(OldDecl->getAccess());
3297 NewFD->setPreviousDeclaration(cast<FunctionDecl>(OldDecl));
3302 // Semantic checking for this function declaration (in isolation).
3303 if (getLangOptions().CPlusPlus) {
3304 // C++-specific checks.
3305 if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(NewFD)) {
3306 CheckConstructor(Constructor);
3307 } else if (CXXDestructorDecl *Destructor =
3308 dyn_cast<CXXDestructorDecl>(NewFD)) {
3309 CXXRecordDecl *Record = Destructor->getParent();
3310 QualType ClassType = Context.getTypeDeclType(Record);
3312 // FIXME: Shouldn't we be able to perform thisc heck even when the class
3313 // type is dependent? Both gcc and edg can handle that.
3314 if (!ClassType->isDependentType()) {
3315 DeclarationName Name
3316 = Context.DeclarationNames.getCXXDestructorName(
3317 Context.getCanonicalType(ClassType));
3318 if (NewFD->getDeclName() != Name) {
3319 Diag(NewFD->getLocation(), diag::err_destructor_name);
3320 return NewFD->setInvalidDecl();
3324 Record->setUserDeclaredDestructor(true);
3325 // C++ [class]p4: A POD-struct is an aggregate class that has [...] no
3326 // user-defined destructor.
3327 Record->setPOD(false);
3329 // C++ [class.dtor]p3: A destructor is trivial if it is an implicitly-
3330 // declared destructor.
3331 // FIXME: C++0x: don't do this for "= default" destructors
3332 Record->setHasTrivialDestructor(false);
3333 } else if (CXXConversionDecl *Conversion
3334 = dyn_cast<CXXConversionDecl>(NewFD)) {
3335 ActOnConversionDeclarator(Conversion);
3338 // Find any virtual functions that this function overrides.
3339 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(NewFD)) {
3340 if (!Method->isFunctionTemplateSpecialization() &&
3341 !Method->getDescribedFunctionTemplate())
3342 AddOverriddenMethods(Method->getParent(), Method);
3345 // Additional checks for the destructor; make sure we do this after we
3346 // figure out whether the destructor is virtual.
3347 if (CXXDestructorDecl *Destructor = dyn_cast<CXXDestructorDecl>(NewFD))
3348 if (!Destructor->getParent()->isDependentType())
3349 CheckDestructor(Destructor);
3351 // Extra checking for C++ overloaded operators (C++ [over.oper]).
3352 if (NewFD->isOverloadedOperator() &&
3353 CheckOverloadedOperatorDeclaration(NewFD))
3354 return NewFD->setInvalidDecl();
3356 // Extra checking for C++0x literal operators (C++0x [over.literal]).
3357 if (NewFD->getLiteralIdentifier() &&
3358 CheckLiteralOperatorDeclaration(NewFD))
3359 return NewFD->setInvalidDecl();
3361 // In C++, check default arguments now that we have merged decls. Unless
3362 // the lexical context is the class, because in this case this is done
3363 // during delayed parsing anyway.
3364 if (!CurContext->isRecord())
3365 CheckCXXDefaultArguments(NewFD);
3369 void Sema::CheckMain(FunctionDecl* FD) {
3370 // C++ [basic.start.main]p3: A program that declares main to be inline
3371 // or static is ill-formed.
3372 // C99 6.7.4p4: In a hosted environment, the inline function specifier
3373 // shall not appear in a declaration of main.
3374 // static main is not an error under C99, but we should warn about it.
3375 bool isInline = FD->isInlineSpecified();
3376 bool isStatic = FD->getStorageClass() == FunctionDecl::Static;
3377 if (isInline || isStatic) {
3378 unsigned diagID = diag::warn_unusual_main_decl;
3379 if (isInline || getLangOptions().CPlusPlus)
3380 diagID = diag::err_unusual_main_decl;
3382 int which = isStatic + (isInline << 1) - 1;
3383 Diag(FD->getLocation(), diagID) << which;
3386 QualType T = FD->getType();
3387 assert(T->isFunctionType() && "function decl is not of function type");
3388 const FunctionType* FT = T->getAs<FunctionType>();
3390 if (!Context.hasSameUnqualifiedType(FT->getResultType(), Context.IntTy)) {
3391 // TODO: add a replacement fixit to turn the return type into 'int'.
3392 Diag(FD->getTypeSpecStartLoc(), diag::err_main_returns_nonint);
3393 FD->setInvalidDecl(true);
3396 // Treat protoless main() as nullary.
3397 if (isa<FunctionNoProtoType>(FT)) return;
3399 const FunctionProtoType* FTP = cast<const FunctionProtoType>(FT);
3400 unsigned nparams = FTP->getNumArgs();
3401 assert(FD->getNumParams() == nparams);
3403 bool HasExtraParameters = (nparams > 3);
3405 // Darwin passes an undocumented fourth argument of type char**. If
3406 // other platforms start sprouting these, the logic below will start
3409 Context.Target.getTriple().getOS() == llvm::Triple::Darwin)
3410 HasExtraParameters = false;
3412 if (HasExtraParameters) {
3413 Diag(FD->getLocation(), diag::err_main_surplus_args) << nparams;
3414 FD->setInvalidDecl(true);
3418 // FIXME: a lot of the following diagnostics would be improved
3419 // if we had some location information about types.
3422 Context.getPointerType(Context.getPointerType(Context.CharTy));
3423 QualType Expected[] = { Context.IntTy, CharPP, CharPP, CharPP };
3425 for (unsigned i = 0; i < nparams; ++i) {
3426 QualType AT = FTP->getArgType(i);
3428 bool mismatch = true;
3430 if (Context.hasSameUnqualifiedType(AT, Expected[i]))
3432 else if (Expected[i] == CharPP) {
3433 // As an extension, the following forms are okay:
3435 // char const * const *
3438 QualifierCollector qs;
3439 const PointerType* PT;
3440 if ((PT = qs.strip(AT)->getAs<PointerType>()) &&
3441 (PT = qs.strip(PT->getPointeeType())->getAs<PointerType>()) &&
3442 (QualType(qs.strip(PT->getPointeeType()), 0) == Context.CharTy)) {
3444 mismatch = !qs.empty();
3449 Diag(FD->getLocation(), diag::err_main_arg_wrong) << i << Expected[i];
3450 // TODO: suggest replacing given type with expected type
3451 FD->setInvalidDecl(true);
3455 if (nparams == 1 && !FD->isInvalidDecl()) {
3456 Diag(FD->getLocation(), diag::warn_main_one_arg);
3460 bool Sema::CheckForConstantInitializer(Expr *Init, QualType DclT) {
3461 // FIXME: Need strict checking. In C89, we need to check for
3462 // any assignment, increment, decrement, function-calls, or
3463 // commas outside of a sizeof. In C99, it's the same list,
3464 // except that the aforementioned are allowed in unevaluated
3465 // expressions. Everything else falls under the
3466 // "may accept other forms of constant expressions" exception.
3467 // (We never end up here for C++, so the constant expression
3468 // rules there don't matter.)
3469 if (Init->isConstantInitializer(Context))
3471 Diag(Init->getExprLoc(), diag::err_init_element_not_constant)
3472 << Init->getSourceRange();
3476 void Sema::AddInitializerToDecl(DeclPtrTy dcl, ExprArg init) {
3477 AddInitializerToDecl(dcl, move(init), /*DirectInit=*/false);
3480 /// AddInitializerToDecl - Adds the initializer Init to the
3481 /// declaration dcl. If DirectInit is true, this is C++ direct
3482 /// initialization rather than copy initialization.
3483 void Sema::AddInitializerToDecl(DeclPtrTy dcl, ExprArg init, bool DirectInit) {
3484 Decl *RealDecl = dcl.getAs<Decl>();
3485 // If there is no declaration, there was an error parsing it. Just ignore
3490 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(RealDecl)) {
3491 // With declarators parsed the way they are, the parser cannot
3492 // distinguish between a normal initializer and a pure-specifier.
3493 // Thus this grotesque test.
3495 Expr *Init = static_cast<Expr *>(init.get());
3496 if ((IL = dyn_cast<IntegerLiteral>(Init)) && IL->getValue() == 0 &&
3497 Context.getCanonicalType(IL->getType()) == Context.IntTy)
3498 CheckPureMethod(Method, Init->getSourceRange());
3500 Diag(Method->getLocation(), diag::err_member_function_initialization)
3501 << Method->getDeclName() << Init->getSourceRange();
3502 Method->setInvalidDecl();
3507 VarDecl *VDecl = dyn_cast<VarDecl>(RealDecl);
3509 if (getLangOptions().CPlusPlus &&
3510 RealDecl->getLexicalDeclContext()->isRecord() &&
3511 isa<NamedDecl>(RealDecl))
3512 Diag(RealDecl->getLocation(), diag::err_member_initialization)
3513 << cast<NamedDecl>(RealDecl)->getDeclName();
3515 Diag(RealDecl->getLocation(), diag::err_illegal_initializer);
3516 RealDecl->setInvalidDecl();
3520 // A definition must end up with a complete type, which means it must be
3521 // complete with the restriction that an array type might be completed by the
3522 // initializer; note that later code assumes this restriction.
3523 QualType BaseDeclType = VDecl->getType();
3524 if (const ArrayType *Array = Context.getAsIncompleteArrayType(BaseDeclType))
3525 BaseDeclType = Array->getElementType();
3526 if (RequireCompleteType(VDecl->getLocation(), BaseDeclType,
3527 diag::err_typecheck_decl_incomplete_type)) {
3528 RealDecl->setInvalidDecl();
3532 // The variable can not have an abstract class type.
3533 if (RequireNonAbstractType(VDecl->getLocation(), VDecl->getType(),
3534 diag::err_abstract_type_in_decl,
3535 AbstractVariableType))
3536 VDecl->setInvalidDecl();
3539 if ((Def = VDecl->getDefinition()) && Def != VDecl) {
3540 Diag(VDecl->getLocation(), diag::err_redefinition)
3541 << VDecl->getDeclName();
3542 Diag(Def->getLocation(), diag::note_previous_definition);
3543 VDecl->setInvalidDecl();
3547 // Take ownership of the expression, now that we're sure we have somewhere
3549 Expr *Init = init.takeAs<Expr>();
3550 assert(Init && "missing initializer");
3552 // Capture the variable that is being initialized and the style of
3554 InitializedEntity Entity = InitializedEntity::InitializeVariable(VDecl);
3556 // FIXME: Poor source location information.
3557 InitializationKind Kind
3558 = DirectInit? InitializationKind::CreateDirect(VDecl->getLocation(),
3559 Init->getLocStart(),
3561 : InitializationKind::CreateCopy(VDecl->getLocation(),
3562 Init->getLocStart());
3564 // Get the decls type and save a reference for later, since
3565 // CheckInitializerTypes may change it.
3566 QualType DclT = VDecl->getType(), SavT = DclT;
3567 if (VDecl->isBlockVarDecl()) {
3568 if (VDecl->hasExternalStorage()) { // C99 6.7.8p5
3569 Diag(VDecl->getLocation(), diag::err_block_extern_cant_init);
3570 VDecl->setInvalidDecl();
3571 } else if (!VDecl->isInvalidDecl()) {
3572 InitializationSequence InitSeq(*this, Entity, Kind, &Init, 1);
3573 OwningExprResult Result = InitSeq.Perform(*this, Entity, Kind,
3574 MultiExprArg(*this, (void**)&Init, 1),
3576 if (Result.isInvalid()) {
3577 VDecl->setInvalidDecl();
3581 Init = Result.takeAs<Expr>();
3583 // C++ 3.6.2p2, allow dynamic initialization of static initializers.
3584 // Don't check invalid declarations to avoid emitting useless diagnostics.
3585 if (!getLangOptions().CPlusPlus && !VDecl->isInvalidDecl()) {
3586 if (VDecl->getStorageClass() == VarDecl::Static) // C99 6.7.8p4.
3587 CheckForConstantInitializer(Init, DclT);
3590 } else if (VDecl->isStaticDataMember() &&
3591 VDecl->getLexicalDeclContext()->isRecord()) {
3592 // This is an in-class initialization for a static data member, e.g.,
3595 // static const int value = 17;
3598 // Attach the initializer
3599 VDecl->setInit(Init);
3601 // C++ [class.mem]p4:
3602 // A member-declarator can contain a constant-initializer only
3603 // if it declares a static member (9.4) of const integral or
3604 // const enumeration type, see 9.4.2.
3605 QualType T = VDecl->getType();
3606 if (!T->isDependentType() &&
3607 (!Context.getCanonicalType(T).isConstQualified() ||
3608 !T->isIntegralType())) {
3609 Diag(VDecl->getLocation(), diag::err_member_initialization)
3610 << VDecl->getDeclName() << Init->getSourceRange();
3611 VDecl->setInvalidDecl();
3613 // C++ [class.static.data]p4:
3614 // If a static data member is of const integral or const
3615 // enumeration type, its declaration in the class definition
3616 // can specify a constant-initializer which shall be an
3617 // integral constant expression (5.19).
3618 if (!Init->isTypeDependent() &&
3619 !Init->getType()->isIntegralType()) {
3620 // We have a non-dependent, non-integral or enumeration type.
3621 Diag(Init->getSourceRange().getBegin(),
3622 diag::err_in_class_initializer_non_integral_type)
3623 << Init->getType() << Init->getSourceRange();
3624 VDecl->setInvalidDecl();
3625 } else if (!Init->isTypeDependent() && !Init->isValueDependent()) {
3626 // Check whether the expression is a constant expression.
3629 if (!Init->isIntegerConstantExpr(Value, Context, &Loc)) {
3630 Diag(Loc, diag::err_in_class_initializer_non_constant)
3631 << Init->getSourceRange();
3632 VDecl->setInvalidDecl();
3633 } else if (!VDecl->getType()->isDependentType())
3634 ImpCastExprToType(Init, VDecl->getType(), CastExpr::CK_IntegralCast);
3637 } else if (VDecl->isFileVarDecl()) {
3638 if (VDecl->getStorageClass() == VarDecl::Extern)
3639 Diag(VDecl->getLocation(), diag::warn_extern_init);
3640 if (!VDecl->isInvalidDecl()) {
3641 InitializationSequence InitSeq(*this, Entity, Kind, &Init, 1);
3642 OwningExprResult Result = InitSeq.Perform(*this, Entity, Kind,
3643 MultiExprArg(*this, (void**)&Init, 1),
3645 if (Result.isInvalid()) {
3646 VDecl->setInvalidDecl();
3650 Init = Result.takeAs<Expr>();
3653 // C++ 3.6.2p2, allow dynamic initialization of static initializers.
3654 // Don't check invalid declarations to avoid emitting useless diagnostics.
3655 if (!getLangOptions().CPlusPlus && !VDecl->isInvalidDecl()) {
3656 // C99 6.7.8p4. All file scoped initializers need to be constant.
3657 CheckForConstantInitializer(Init, DclT);
3660 // If the type changed, it means we had an incomplete type that was
3661 // completed by the initializer. For example:
3662 // int ary[] = { 1, 3, 5 };
3663 // "ary" transitions from a VariableArrayType to a ConstantArrayType.
3664 if (!VDecl->isInvalidDecl() && (DclT != SavT)) {
3665 VDecl->setType(DclT);
3666 Init->setType(DclT);
3669 Init = MaybeCreateCXXExprWithTemporaries(Init);
3670 // Attach the initializer to the decl.
3671 VDecl->setInit(Init);
3673 if (getLangOptions().CPlusPlus) {
3674 // Make sure we mark the destructor as used if necessary.
3675 QualType InitType = VDecl->getType();
3676 while (const ArrayType *Array = Context.getAsArrayType(InitType))
3677 InitType = Context.getBaseElementType(Array);
3678 if (const RecordType *Record = InitType->getAs<RecordType>())
3679 FinalizeVarWithDestructor(VDecl, Record);
3685 void Sema::ActOnUninitializedDecl(DeclPtrTy dcl,
3686 bool TypeContainsUndeducedAuto) {
3687 Decl *RealDecl = dcl.getAs<Decl>();
3689 // If there is no declaration, there was an error parsing it. Just ignore it.
3693 if (VarDecl *Var = dyn_cast<VarDecl>(RealDecl)) {
3694 QualType Type = Var->getType();
3696 // C++0x [dcl.spec.auto]p3
3697 if (TypeContainsUndeducedAuto) {
3698 Diag(Var->getLocation(), diag::err_auto_var_requires_init)
3699 << Var->getDeclName() << Type;
3700 Var->setInvalidDecl();
3704 switch (Var->isThisDeclarationADefinition()) {
3705 case VarDecl::Definition:
3706 if (!Var->isStaticDataMember() || !Var->getAnyInitializer())
3709 // We have an out-of-line definition of a static data member
3710 // that has an in-class initializer, so we type-check this like
3715 case VarDecl::DeclarationOnly:
3716 // It's only a declaration.
3718 // Block scope. C99 6.7p7: If an identifier for an object is
3719 // declared with no linkage (C99 6.2.2p6), the type for the
3720 // object shall be complete.
3721 if (!Type->isDependentType() && Var->isBlockVarDecl() &&
3722 !Var->getLinkage() && !Var->isInvalidDecl() &&
3723 RequireCompleteType(Var->getLocation(), Type,
3724 diag::err_typecheck_decl_incomplete_type))
3725 Var->setInvalidDecl();
3727 // Make sure that the type is not abstract.
3728 if (!Type->isDependentType() && !Var->isInvalidDecl() &&
3729 RequireNonAbstractType(Var->getLocation(), Type,
3730 diag::err_abstract_type_in_decl,
3731 AbstractVariableType))
3732 Var->setInvalidDecl();
3735 case VarDecl::TentativeDefinition:
3736 // File scope. C99 6.9.2p2: A declaration of an identifier for an
3737 // object that has file scope without an initializer, and without a
3738 // storage-class specifier or with the storage-class specifier "static",
3739 // constitutes a tentative definition. Note: A tentative definition with
3740 // external linkage is valid (C99 6.2.2p5).
3741 if (!Var->isInvalidDecl()) {
3742 if (const IncompleteArrayType *ArrayT
3743 = Context.getAsIncompleteArrayType(Type)) {
3744 if (RequireCompleteType(Var->getLocation(),
3745 ArrayT->getElementType(),
3746 diag::err_illegal_decl_array_incomplete_type))
3747 Var->setInvalidDecl();
3748 } else if (Var->getStorageClass() == VarDecl::Static) {
3749 // C99 6.9.2p3: If the declaration of an identifier for an object is
3750 // a tentative definition and has internal linkage (C99 6.2.2p3), the
3751 // declared type shall not be an incomplete type.
3752 // NOTE: code such as the following
3754 // struct s { int a; };
3755 // is accepted by gcc. Hence here we issue a warning instead of
3756 // an error and we do not invalidate the static declaration.
3757 // NOTE: to avoid multiple warnings, only check the first declaration.
3758 if (Var->getPreviousDeclaration() == 0)
3759 RequireCompleteType(Var->getLocation(), Type,
3760 diag::ext_typecheck_decl_incomplete_type);
3764 // Record the tentative definition; we're done.
3765 if (!Var->isInvalidDecl())
3766 TentativeDefinitions.push_back(Var);
3770 // Provide a specific diagnostic for uninitialized variable
3771 // definitions with incomplete array type.
3772 if (Type->isIncompleteArrayType()) {
3773 Diag(Var->getLocation(),
3774 diag::err_typecheck_incomplete_array_needs_initializer);
3775 Var->setInvalidDecl();
3779 // Provide a specific diagnostic for uninitialized variable
3780 // definitions with reference type.
3781 if (Type->isReferenceType()) {
3782 Diag(Var->getLocation(), diag::err_reference_var_requires_init)
3783 << Var->getDeclName()
3784 << SourceRange(Var->getLocation(), Var->getLocation());
3785 Var->setInvalidDecl();
3789 // Do not attempt to type-check the default initializer for a
3790 // variable with dependent type.
3791 if (Type->isDependentType())
3794 if (Var->isInvalidDecl())
3797 if (RequireCompleteType(Var->getLocation(),
3798 Context.getBaseElementType(Type),
3799 diag::err_typecheck_decl_incomplete_type)) {
3800 Var->setInvalidDecl();
3804 // The variable can not have an abstract class type.
3805 if (RequireNonAbstractType(Var->getLocation(), Type,
3806 diag::err_abstract_type_in_decl,
3807 AbstractVariableType)) {
3808 Var->setInvalidDecl();
3812 InitializedEntity Entity = InitializedEntity::InitializeVariable(Var);
3813 InitializationKind Kind
3814 = InitializationKind::CreateDefault(Var->getLocation());
3816 InitializationSequence InitSeq(*this, Entity, Kind, 0, 0);
3817 OwningExprResult Init = InitSeq.Perform(*this, Entity, Kind,
3818 MultiExprArg(*this, 0, 0));
3819 if (Init.isInvalid())
3820 Var->setInvalidDecl();
3823 Var->setInit(MaybeCreateCXXExprWithTemporaries(Init.takeAs<Expr>()));
3825 if (getLangOptions().CPlusPlus)
3826 if (const RecordType *Record
3827 = Context.getBaseElementType(Type)->getAs<RecordType>())
3828 FinalizeVarWithDestructor(Var, Record);
3833 Sema::DeclGroupPtrTy Sema::FinalizeDeclaratorGroup(Scope *S, const DeclSpec &DS,
3835 unsigned NumDecls) {
3836 llvm::SmallVector<Decl*, 8> Decls;
3838 if (DS.isTypeSpecOwned())
3839 Decls.push_back((Decl*)DS.getTypeRep());
3841 for (unsigned i = 0; i != NumDecls; ++i)
3842 if (Decl *D = Group[i].getAs<Decl>())
3845 return DeclGroupPtrTy::make(DeclGroupRef::Create(Context,
3846 Decls.data(), Decls.size()));
3850 /// ActOnParamDeclarator - Called from Parser::ParseFunctionDeclarator()
3851 /// to introduce parameters into function prototype scope.
3853 Sema::ActOnParamDeclarator(Scope *S, Declarator &D) {
3854 const DeclSpec &DS = D.getDeclSpec();
3856 // Verify C99 6.7.5.3p2: The only SCS allowed is 'register'.
3857 VarDecl::StorageClass StorageClass = VarDecl::None;
3858 if (DS.getStorageClassSpec() == DeclSpec::SCS_register) {
3859 StorageClass = VarDecl::Register;
3860 } else if (DS.getStorageClassSpec() != DeclSpec::SCS_unspecified) {
3861 Diag(DS.getStorageClassSpecLoc(),
3862 diag::err_invalid_storage_class_in_func_decl);
3863 D.getMutableDeclSpec().ClearStorageClassSpecs();
3866 if (D.getDeclSpec().isThreadSpecified())
3867 Diag(D.getDeclSpec().getThreadSpecLoc(), diag::err_invalid_thread);
3869 DiagnoseFunctionSpecifiers(D);
3871 // Check that there are no default arguments inside the type of this
3872 // parameter (C++ only).
3873 if (getLangOptions().CPlusPlus)
3874 CheckExtraCXXDefaultArguments(D);
3876 TypeSourceInfo *TInfo = 0;
3877 TagDecl *OwnedDecl = 0;
3878 QualType parmDeclType = GetTypeForDeclarator(D, S, &TInfo, &OwnedDecl);
3880 if (getLangOptions().CPlusPlus && OwnedDecl && OwnedDecl->isDefinition()) {
3882 // Types shall not be defined in return or parameter types.
3883 Diag(OwnedDecl->getLocation(), diag::err_type_defined_in_param_type)
3884 << Context.getTypeDeclType(OwnedDecl);
3887 // Check for redeclaration of parameters, e.g. int foo(int x, int x);
3888 IdentifierInfo *II = D.getIdentifier();
3890 if (NamedDecl *PrevDecl = LookupSingleName(S, II, LookupOrdinaryName)) {
3891 if (PrevDecl->isTemplateParameter()) {
3892 // Maybe we will complain about the shadowed template parameter.
3893 DiagnoseTemplateParameterShadow(D.getIdentifierLoc(), PrevDecl);
3894 // Just pretend that we didn't see the previous declaration.
3896 } else if (S->isDeclScope(DeclPtrTy::make(PrevDecl))) {
3897 Diag(D.getIdentifierLoc(), diag::err_param_redefinition) << II;
3898 Diag(PrevDecl->getLocation(), diag::note_previous_declaration);
3900 // Recover by removing the name
3902 D.SetIdentifier(0, D.getIdentifierLoc());
3903 D.setInvalidType(true);
3908 // Parameters can not be abstract class types.
3909 // For record types, this is done by the AbstractClassUsageDiagnoser once
3910 // the class has been completely parsed.
3911 if (!CurContext->isRecord() &&
3912 RequireNonAbstractType(D.getIdentifierLoc(), parmDeclType,
3913 diag::err_abstract_type_in_decl,
3915 D.setInvalidType(true);
3917 QualType T = adjustParameterType(parmDeclType);
3919 // Temporarily put parameter variables in the translation unit, not
3920 // the enclosing context. This prevents them from accidentally
3921 // looking like class members in C++.
3922 DeclContext *DC = Context.getTranslationUnitDecl();
3925 = ParmVarDecl::Create(Context, DC, D.getIdentifierLoc(), II,
3926 T, TInfo, StorageClass, 0);
3928 if (D.isInvalidType())
3929 New->setInvalidDecl();
3931 // Parameter declarators cannot be interface types. All ObjC objects are
3932 // passed by reference.
3933 if (T->isObjCInterfaceType()) {
3934 Diag(D.getIdentifierLoc(),
3935 diag::err_object_cannot_be_passed_returned_by_value) << 1 << T;
3936 New->setInvalidDecl();
3939 // Parameter declarators cannot be qualified (C++ [dcl.meaning]p1).
3940 if (D.getCXXScopeSpec().isSet()) {
3941 Diag(D.getIdentifierLoc(), diag::err_qualified_param_declarator)
3942 << D.getCXXScopeSpec().getRange();
3943 New->setInvalidDecl();
3946 // ISO/IEC TR 18037 S6.7.3: "The type of an object with automatic storage
3947 // duration shall not be qualified by an address-space qualifier."
3948 // Since all parameters have automatic store duration, they can not have
3949 // an address space.
3950 if (T.getAddressSpace() != 0) {
3951 Diag(D.getIdentifierLoc(),
3952 diag::err_arg_with_address_space);
3953 New->setInvalidDecl();
3957 // Add the parameter declaration into this scope.
3958 S->AddDecl(DeclPtrTy::make(New));
3960 IdResolver.AddDecl(New);
3962 ProcessDeclAttributes(S, New, D);
3964 if (New->hasAttr<BlocksAttr>()) {
3965 Diag(New->getLocation(), diag::err_block_on_nonlocal);
3967 return DeclPtrTy::make(New);
3970 void Sema::ActOnObjCCatchParam(DeclPtrTy D) {
3971 ParmVarDecl *Param = cast<ParmVarDecl>(D.getAs<Decl>());
3972 Param->setDeclContext(CurContext);
3975 void Sema::ActOnFinishKNRParamDeclarations(Scope *S, Declarator &D,
3976 SourceLocation LocAfterDecls) {
3977 assert(D.getTypeObject(0).Kind == DeclaratorChunk::Function &&
3978 "Not a function declarator!");
3979 DeclaratorChunk::FunctionTypeInfo &FTI = D.getTypeObject(0).Fun;
3981 // Verify 6.9.1p6: 'every identifier in the identifier list shall be declared'
3982 // for a K&R function.
3983 if (!FTI.hasPrototype) {
3984 for (int i = FTI.NumArgs; i != 0; /* decrement in loop */) {
3986 if (FTI.ArgInfo[i].Param == 0) {
3987 llvm::SmallString<256> Code;
3988 llvm::raw_svector_ostream(Code) << " int "
3989 << FTI.ArgInfo[i].Ident->getName()
3991 Diag(FTI.ArgInfo[i].IdentLoc, diag::ext_param_not_declared)
3992 << FTI.ArgInfo[i].Ident
3993 << CodeModificationHint::CreateInsertion(LocAfterDecls, Code.str());
3995 // Implicitly declare the argument as type 'int' for lack of a better
3998 const char* PrevSpec; // unused
3999 unsigned DiagID; // unused
4000 DS.SetTypeSpecType(DeclSpec::TST_int, FTI.ArgInfo[i].IdentLoc,
4002 Declarator ParamD(DS, Declarator::KNRTypeListContext);
4003 ParamD.SetIdentifier(FTI.ArgInfo[i].Ident, FTI.ArgInfo[i].IdentLoc);
4004 FTI.ArgInfo[i].Param = ActOnParamDeclarator(S, ParamD);
4010 Sema::DeclPtrTy Sema::ActOnStartOfFunctionDef(Scope *FnBodyScope,
4012 assert(getCurFunctionDecl() == 0 && "Function parsing confused");
4013 assert(D.getTypeObject(0).Kind == DeclaratorChunk::Function &&
4014 "Not a function declarator!");
4015 DeclaratorChunk::FunctionTypeInfo &FTI = D.getTypeObject(0).Fun;
4017 if (FTI.hasPrototype) {
4018 // FIXME: Diagnose arguments without names in C.
4021 Scope *ParentScope = FnBodyScope->getParent();
4023 DeclPtrTy DP = HandleDeclarator(ParentScope, D,
4024 MultiTemplateParamsArg(*this),
4025 /*IsFunctionDefinition=*/true);
4026 return ActOnStartOfFunctionDef(FnBodyScope, DP);
4029 static bool ShouldWarnAboutMissingPrototype(const FunctionDecl *FD) {
4030 // Don't warn about invalid declarations.
4031 if (FD->isInvalidDecl())
4034 // Or declarations that aren't global.
4035 if (!FD->isGlobal())
4038 // Don't warn about C++ member functions.
4039 if (isa<CXXMethodDecl>(FD))
4042 // Don't warn about 'main'.
4046 // Don't warn about inline functions.
4047 if (FD->isInlineSpecified())
4050 // Don't warn about function templates.
4051 if (FD->getDescribedFunctionTemplate())
4054 // Don't warn about function template specializations.
4055 if (FD->isFunctionTemplateSpecialization())
4058 bool MissingPrototype = true;
4059 for (const FunctionDecl *Prev = FD->getPreviousDeclaration();
4060 Prev; Prev = Prev->getPreviousDeclaration()) {
4061 // Ignore any declarations that occur in function or method
4062 // scope, because they aren't visible from the header.
4063 if (Prev->getDeclContext()->isFunctionOrMethod())
4066 MissingPrototype = !Prev->getType()->isFunctionProtoType();
4070 return MissingPrototype;
4073 Sema::DeclPtrTy Sema::ActOnStartOfFunctionDef(Scope *FnBodyScope, DeclPtrTy D) {
4074 // Clear the last template instantiation error context.
4075 LastTemplateInstantiationErrorContext = ActiveTemplateInstantiation();
4079 FunctionDecl *FD = 0;
4081 if (FunctionTemplateDecl *FunTmpl
4082 = dyn_cast<FunctionTemplateDecl>(D.getAs<Decl>()))
4083 FD = FunTmpl->getTemplatedDecl();
4085 FD = cast<FunctionDecl>(D.getAs<Decl>());
4087 // Enter a new function scope
4088 PushFunctionScope();
4090 // See if this is a redefinition.
4091 // But don't complain if we're in GNU89 mode and the previous definition
4092 // was an extern inline function.
4093 const FunctionDecl *Definition;
4094 if (FD->getBody(Definition) &&
4095 !canRedefineFunction(Definition, getLangOptions())) {
4096 Diag(FD->getLocation(), diag::err_redefinition) << FD->getDeclName();
4097 Diag(Definition->getLocation(), diag::note_previous_definition);
4100 // Builtin functions cannot be defined.
4101 if (unsigned BuiltinID = FD->getBuiltinID()) {
4102 if (!Context.BuiltinInfo.isPredefinedLibFunction(BuiltinID)) {
4103 Diag(FD->getLocation(), diag::err_builtin_definition) << FD;
4104 FD->setInvalidDecl();
4108 // The return type of a function definition must be complete
4109 // (C99 6.9.1p3, C++ [dcl.fct]p6).
4110 QualType ResultType = FD->getResultType();
4111 if (!ResultType->isDependentType() && !ResultType->isVoidType() &&
4112 !FD->isInvalidDecl() &&
4113 RequireCompleteType(FD->getLocation(), ResultType,
4114 diag::err_func_def_incomplete_result))
4115 FD->setInvalidDecl();
4117 // GNU warning -Wmissing-prototypes:
4118 // Warn if a global function is defined without a previous
4119 // prototype declaration. This warning is issued even if the
4120 // definition itself provides a prototype. The aim is to detect
4121 // global functions that fail to be declared in header files.
4122 if (ShouldWarnAboutMissingPrototype(FD))
4123 Diag(FD->getLocation(), diag::warn_missing_prototype) << FD;
4126 PushDeclContext(FnBodyScope, FD);
4128 // Check the validity of our function parameters
4129 CheckParmsForFunctionDef(FD);
4131 // Introduce our parameters into the function scope
4132 for (unsigned p = 0, NumParams = FD->getNumParams(); p < NumParams; ++p) {
4133 ParmVarDecl *Param = FD->getParamDecl(p);
4134 Param->setOwningFunction(FD);
4136 // If this has an identifier, add it to the scope stack.
4137 if (Param->getIdentifier() && FnBodyScope)
4138 PushOnScopeChains(Param, FnBodyScope);
4141 // Checking attributes of current function definition
4142 // dllimport attribute.
4143 if (FD->getAttr<DLLImportAttr>() &&
4144 (!FD->getAttr<DLLExportAttr>())) {
4145 // dllimport attribute cannot be applied to definition.
4146 if (!(FD->getAttr<DLLImportAttr>())->isInherited()) {
4147 Diag(FD->getLocation(),
4148 diag::err_attribute_can_be_applied_only_to_symbol_declaration)
4150 FD->setInvalidDecl();
4151 return DeclPtrTy::make(FD);
4154 // Visual C++ appears to not think this is an issue, so only issue
4155 // a warning when Microsoft extensions are disabled.
4156 if (!LangOpts.Microsoft) {
4157 // If a symbol previously declared dllimport is later defined, the
4158 // attribute is ignored in subsequent references, and a warning is
4160 Diag(FD->getLocation(),
4161 diag::warn_redeclaration_without_attribute_prev_attribute_ignored)
4162 << FD->getNameAsCString() << "dllimport";
4165 return DeclPtrTy::make(FD);
4168 Sema::DeclPtrTy Sema::ActOnFinishFunctionBody(DeclPtrTy D, StmtArg BodyArg) {
4169 return ActOnFinishFunctionBody(D, move(BodyArg), false);
4172 Sema::DeclPtrTy Sema::ActOnFinishFunctionBody(DeclPtrTy D, StmtArg BodyArg,
4173 bool IsInstantiation) {
4174 Decl *dcl = D.getAs<Decl>();
4175 Stmt *Body = BodyArg.takeAs<Stmt>();
4177 // Don't generate EH edges for CallExprs as we'd like to avoid the n^2
4178 // explosion for destrutors that can result and the compile time hit.
4179 AnalysisContext AC(dcl, false);
4180 FunctionDecl *FD = 0;
4181 FunctionTemplateDecl *FunTmpl = dyn_cast_or_null<FunctionTemplateDecl>(dcl);
4183 FD = FunTmpl->getTemplatedDecl();
4185 FD = dyn_cast_or_null<FunctionDecl>(dcl);
4190 // C and C++ allow for main to automagically return 0.
4191 // Implements C++ [basic.start.main]p5 and C99 5.1.2.2.3.
4192 FD->setHasImplicitReturnZero(true);
4194 CheckFallThroughForFunctionDef(FD, Body, AC);
4196 if (!FD->isInvalidDecl())
4197 DiagnoseUnusedParameters(FD->param_begin(), FD->param_end());
4199 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(FD))
4200 MaybeMarkVirtualMembersReferenced(Method->getLocation(), Method);
4202 assert(FD == getCurFunctionDecl() && "Function parsing confused");
4203 } else if (ObjCMethodDecl *MD = dyn_cast_or_null<ObjCMethodDecl>(dcl)) {
4204 assert(MD == getCurMethodDecl() && "Method parsing confused");
4206 CheckFallThroughForFunctionDef(MD, Body, AC);
4207 MD->setEndLoc(Body->getLocEnd());
4209 if (!MD->isInvalidDecl())
4210 DiagnoseUnusedParameters(MD->param_begin(), MD->param_end());
4212 Body->Destroy(Context);
4215 if (!IsInstantiation)
4218 // Verify and clean out per-function state.
4220 // Check goto/label use.
4221 for (llvm::DenseMap<IdentifierInfo*, LabelStmt*>::iterator
4222 I = getLabelMap().begin(), E = getLabelMap().end(); I != E; ++I) {
4223 LabelStmt *L = I->second;
4225 // Verify that we have no forward references left. If so, there was a goto
4226 // or address of a label taken, but no definition of it. Label fwd
4227 // definitions are indicated with a null substmt.
4228 if (L->getSubStmt() != 0)
4232 Diag(L->getIdentLoc(), diag::err_undeclared_label_use) << L->getName();
4234 // At this point, we have gotos that use the bogus label. Stitch it into
4235 // the function body so that they aren't leaked and that the AST is well
4238 // The whole function wasn't parsed correctly, just delete this.
4239 L->Destroy(Context);
4243 // Otherwise, the body is valid: we want to stitch the label decl into the
4244 // function somewhere so that it is properly owned and so that the goto
4245 // has a valid target. Do this by creating a new compound stmt with the
4248 // Give the label a sub-statement.
4249 L->setSubStmt(new (Context) NullStmt(L->getIdentLoc()));
4251 CompoundStmt *Compound = isa<CXXTryStmt>(Body) ?
4252 cast<CXXTryStmt>(Body)->getTryBlock() :
4253 cast<CompoundStmt>(Body);
4254 std::vector<Stmt*> Elements(Compound->body_begin(), Compound->body_end());
4255 Elements.push_back(L);
4256 Compound->setStmts(Context, &Elements[0], Elements.size());
4260 CheckUnreachable(AC);
4262 // C++ constructors that have function-try-blocks can't have return
4263 // statements in the handlers of that block. (C++ [except.handle]p14)
4265 if (FD && isa<CXXConstructorDecl>(FD) && isa<CXXTryStmt>(Body))
4266 DiagnoseReturnInConstructorExceptionHandler(cast<CXXTryStmt>(Body));
4268 // Verify that that gotos and switch cases don't jump into scopes illegally.
4269 // Verify that that gotos and switch cases don't jump into scopes illegally.
4270 if (FunctionNeedsScopeChecking() && !hasAnyErrorsInThisFunction())
4271 DiagnoseInvalidJumps(Body);
4273 if (CXXDestructorDecl *Destructor = dyn_cast<CXXDestructorDecl>(dcl))
4274 MarkBaseAndMemberDestructorsReferenced(Destructor);
4276 // If any errors have occurred, clear out any temporaries that may have
4277 // been leftover. This ensures that these temporaries won't be picked up for
4278 // deletion in some later function.
4279 if (PP.getDiagnostics().hasErrorOccurred())
4280 ExprTemporaries.clear();
4282 assert(ExprTemporaries.empty() && "Leftover temporaries in function");
4285 PopFunctionOrBlockScope();
4287 // If any errors have occurred, clear out any temporaries that may have
4288 // been leftover. This ensures that these temporaries won't be picked up for
4289 // deletion in some later function.
4290 if (getDiagnostics().hasErrorOccurred())
4291 ExprTemporaries.clear();
4296 /// ImplicitlyDefineFunction - An undeclared identifier was used in a function
4297 /// call, forming a call to an implicitly defined function (per C99 6.5.1p2).
4298 NamedDecl *Sema::ImplicitlyDefineFunction(SourceLocation Loc,
4299 IdentifierInfo &II, Scope *S) {
4300 // Before we produce a declaration for an implicitly defined
4301 // function, see whether there was a locally-scoped declaration of
4302 // this name as a function or variable. If so, use that
4303 // (non-visible) declaration, and complain about it.
4304 llvm::DenseMap<DeclarationName, NamedDecl *>::iterator Pos
4305 = LocallyScopedExternalDecls.find(&II);
4306 if (Pos != LocallyScopedExternalDecls.end()) {
4307 Diag(Loc, diag::warn_use_out_of_scope_declaration) << Pos->second;
4308 Diag(Pos->second->getLocation(), diag::note_previous_declaration);
4312 // Extension in C99. Legal in C90, but warn about it.
4313 if (II.getName().startswith("__builtin_"))
4314 Diag(Loc, diag::warn_builtin_unknown) << &II;
4315 else if (getLangOptions().C99)
4316 Diag(Loc, diag::ext_implicit_function_decl) << &II;
4318 Diag(Loc, diag::warn_implicit_function_decl) << &II;
4320 // Set a Declarator for the implicit definition: int foo();
4324 bool Error = DS.SetTypeSpecType(DeclSpec::TST_int, Loc, Dummy, DiagID);
4325 Error = Error; // Silence warning.
4326 assert(!Error && "Error setting up implicit decl!");
4327 Declarator D(DS, Declarator::BlockContext);
4328 D.AddTypeInfo(DeclaratorChunk::getFunction(false, false, SourceLocation(), 0,
4329 0, 0, false, SourceLocation(),
4330 false, 0,0,0, Loc, Loc, D),
4332 D.SetIdentifier(&II, Loc);
4334 // Insert this function into translation-unit scope.
4336 DeclContext *PrevDC = CurContext;
4337 CurContext = Context.getTranslationUnitDecl();
4340 dyn_cast<FunctionDecl>(ActOnDeclarator(TUScope, D).getAs<Decl>());
4343 CurContext = PrevDC;
4345 AddKnownFunctionAttributes(FD);
4350 /// \brief Adds any function attributes that we know a priori based on
4351 /// the declaration of this function.
4353 /// These attributes can apply both to implicitly-declared builtins
4354 /// (like __builtin___printf_chk) or to library-declared functions
4355 /// like NSLog or printf.
4356 void Sema::AddKnownFunctionAttributes(FunctionDecl *FD) {
4357 if (FD->isInvalidDecl())
4360 // If this is a built-in function, map its builtin attributes to
4361 // actual attributes.
4362 if (unsigned BuiltinID = FD->getBuiltinID()) {
4363 // Handle printf-formatting attributes.
4366 if (Context.BuiltinInfo.isPrintfLike(BuiltinID, FormatIdx, HasVAListArg)) {
4367 if (!FD->getAttr<FormatAttr>())
4368 FD->addAttr(::new (Context) FormatAttr(Context, "printf", FormatIdx+1,
4369 HasVAListArg ? 0 : FormatIdx+2));
4372 // Mark const if we don't care about errno and that is the only
4373 // thing preventing the function from being const. This allows
4374 // IRgen to use LLVM intrinsics for such functions.
4375 if (!getLangOptions().MathErrno &&
4376 Context.BuiltinInfo.isConstWithoutErrno(BuiltinID)) {
4377 if (!FD->getAttr<ConstAttr>())
4378 FD->addAttr(::new (Context) ConstAttr());
4381 if (Context.BuiltinInfo.isNoReturn(BuiltinID))
4382 FD->setType(Context.getNoReturnType(FD->getType()));
4383 if (Context.BuiltinInfo.isNoThrow(BuiltinID))
4384 FD->addAttr(::new (Context) NoThrowAttr());
4385 if (Context.BuiltinInfo.isConst(BuiltinID))
4386 FD->addAttr(::new (Context) ConstAttr());
4389 IdentifierInfo *Name = FD->getIdentifier();
4392 if ((!getLangOptions().CPlusPlus &&
4393 FD->getDeclContext()->isTranslationUnit()) ||
4394 (isa<LinkageSpecDecl>(FD->getDeclContext()) &&
4395 cast<LinkageSpecDecl>(FD->getDeclContext())->getLanguage() ==
4396 LinkageSpecDecl::lang_c)) {
4397 // Okay: this could be a libc/libm/Objective-C function we know
4402 if (Name->isStr("NSLog") || Name->isStr("NSLogv")) {
4403 // FIXME: NSLog and NSLogv should be target specific
4404 if (const FormatAttr *Format = FD->getAttr<FormatAttr>()) {
4405 // FIXME: We known better than our headers.
4406 const_cast<FormatAttr *>(Format)->setType(Context, "printf");
4408 FD->addAttr(::new (Context) FormatAttr(Context, "printf", 1,
4409 Name->isStr("NSLogv") ? 0 : 2));
4410 } else if (Name->isStr("asprintf") || Name->isStr("vasprintf")) {
4411 // FIXME: asprintf and vasprintf aren't C99 functions. Should they be
4412 // target-specific builtins, perhaps?
4413 if (!FD->getAttr<FormatAttr>())
4414 FD->addAttr(::new (Context) FormatAttr(Context, "printf", 2,
4415 Name->isStr("vasprintf") ? 0 : 3));
4419 TypedefDecl *Sema::ParseTypedefDecl(Scope *S, Declarator &D, QualType T,
4420 TypeSourceInfo *TInfo) {
4421 assert(D.getIdentifier() && "Wrong callback for declspec without declarator");
4422 assert(!T.isNull() && "GetTypeForDeclarator() returned null type");
4425 assert(D.isInvalidType() && "no declarator info for valid type");
4426 TInfo = Context.getTrivialTypeSourceInfo(T);
4429 // Scope manipulation handled by caller.
4430 TypedefDecl *NewTD = TypedefDecl::Create(Context, CurContext,
4431 D.getIdentifierLoc(),
4435 if (const TagType *TT = T->getAs<TagType>()) {
4436 TagDecl *TD = TT->getDecl();
4438 // If the TagDecl that the TypedefDecl points to is an anonymous decl
4439 // keep track of the TypedefDecl.
4440 if (!TD->getIdentifier() && !TD->getTypedefForAnonDecl())
4441 TD->setTypedefForAnonDecl(NewTD);
4444 if (D.isInvalidType())
4445 NewTD->setInvalidDecl();
4450 /// \brief Determine whether a tag with a given kind is acceptable
4451 /// as a redeclaration of the given tag declaration.
4453 /// \returns true if the new tag kind is acceptable, false otherwise.
4454 bool Sema::isAcceptableTagRedeclaration(const TagDecl *Previous,
4455 TagDecl::TagKind NewTag,
4456 SourceLocation NewTagLoc,
4457 const IdentifierInfo &Name) {
4458 // C++ [dcl.type.elab]p3:
4459 // The class-key or enum keyword present in the
4460 // elaborated-type-specifier shall agree in kind with the
4461 // declaration to which the name in theelaborated-type-specifier
4462 // refers. This rule also applies to the form of
4463 // elaborated-type-specifier that declares a class-name or
4464 // friend class since it can be construed as referring to the
4465 // definition of the class. Thus, in any
4466 // elaborated-type-specifier, the enum keyword shall be used to
4467 // refer to an enumeration (7.2), the union class-keyshall be
4468 // used to refer to a union (clause 9), and either the class or
4469 // struct class-key shall be used to refer to a class (clause 9)
4470 // declared using the class or struct class-key.
4471 TagDecl::TagKind OldTag = Previous->getTagKind();
4472 if (OldTag == NewTag)
4475 if ((OldTag == TagDecl::TK_struct || OldTag == TagDecl::TK_class) &&
4476 (NewTag == TagDecl::TK_struct || NewTag == TagDecl::TK_class)) {
4477 // Warn about the struct/class tag mismatch.
4478 bool isTemplate = false;
4479 if (const CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(Previous))
4480 isTemplate = Record->getDescribedClassTemplate();
4482 Diag(NewTagLoc, diag::warn_struct_class_tag_mismatch)
4483 << (NewTag == TagDecl::TK_class)
4484 << isTemplate << &Name
4485 << CodeModificationHint::CreateReplacement(SourceRange(NewTagLoc),
4486 OldTag == TagDecl::TK_class? "class" : "struct");
4487 Diag(Previous->getLocation(), diag::note_previous_use);
4493 /// ActOnTag - This is invoked when we see 'struct foo' or 'struct {'. In the
4494 /// former case, Name will be non-null. In the later case, Name will be null.
4495 /// TagSpec indicates what kind of tag this is. TUK indicates whether this is a
4496 /// reference/declaration/definition of a tag.
4497 Sema::DeclPtrTy Sema::ActOnTag(Scope *S, unsigned TagSpec, TagUseKind TUK,
4498 SourceLocation KWLoc, const CXXScopeSpec &SS,
4499 IdentifierInfo *Name, SourceLocation NameLoc,
4500 AttributeList *Attr, AccessSpecifier AS,
4501 MultiTemplateParamsArg TemplateParameterLists,
4502 bool &OwnedDecl, bool &IsDependent) {
4503 // If this is not a definition, it must have a name.
4504 assert((Name != 0 || TUK == TUK_Definition) &&
4505 "Nameless record must be a definition!");
4508 TagDecl::TagKind Kind = TagDecl::getTagKindForTypeSpec(TagSpec);
4510 // FIXME: Check explicit specializations more carefully.
4511 bool isExplicitSpecialization = false;
4512 if (TUK != TUK_Reference) {
4513 if (TemplateParameterList *TemplateParams
4514 = MatchTemplateParametersToScopeSpecifier(KWLoc, SS,
4515 (TemplateParameterList**)TemplateParameterLists.get(),
4516 TemplateParameterLists.size(),
4517 isExplicitSpecialization)) {
4518 if (TemplateParams->size() > 0) {
4519 // This is a declaration or definition of a class template (which may
4520 // be a member of another template).
4522 DeclResult Result = CheckClassTemplate(S, TagSpec, TUK, KWLoc,
4523 SS, Name, NameLoc, Attr,
4526 TemplateParameterLists.release();
4527 return Result.get();
4529 // The "template<>" header is extraneous.
4530 Diag(TemplateParams->getTemplateLoc(), diag::err_template_tag_noparams)
4531 << ElaboratedType::getNameForTagKind(Kind) << Name;
4532 isExplicitSpecialization = true;
4536 TemplateParameterLists.release();
4539 DeclContext *SearchDC = CurContext;
4540 DeclContext *DC = CurContext;
4541 bool isStdBadAlloc = false;
4542 bool Invalid = false;
4544 RedeclarationKind Redecl = ForRedeclaration;
4545 if (TUK == TUK_Friend || TUK == TUK_Reference)
4546 Redecl = NotForRedeclaration;
4548 LookupResult Previous(*this, Name, NameLoc, LookupTagName, Redecl);
4550 if (Name && SS.isNotEmpty()) {
4551 // We have a nested-name tag ('struct foo::bar').
4553 // Check for invalid 'foo::'.
4554 if (SS.isInvalid()) {
4559 // If this is a friend or a reference to a class in a dependent
4560 // context, don't try to make a decl for it.
4561 if (TUK == TUK_Friend || TUK == TUK_Reference) {
4562 DC = computeDeclContext(SS, false);
4569 if (RequireCompleteDeclContext(SS))
4570 return DeclPtrTy::make((Decl *)0);
4572 DC = computeDeclContext(SS, true);
4574 // Look-up name inside 'foo::'.
4575 LookupQualifiedName(Previous, DC);
4577 if (Previous.isAmbiguous())
4580 if (Previous.empty()) {
4581 // Name lookup did not find anything. However, if the
4582 // nested-name-specifier refers to the current instantiation,
4583 // and that current instantiation has any dependent base
4584 // classes, we might find something at instantiation time: treat
4585 // this as a dependent elaborated-type-specifier.
4586 if (Previous.wasNotFoundInCurrentInstantiation()) {
4591 // A tag 'foo::bar' must already exist.
4592 Diag(NameLoc, diag::err_not_tag_in_scope) << Name << SS.getRange();
4598 // If this is a named struct, check to see if there was a previous forward
4599 // declaration or definition.
4600 // FIXME: We're looking into outer scopes here, even when we
4601 // shouldn't be. Doing so can result in ambiguities that we
4602 // shouldn't be diagnosing.
4603 LookupName(Previous, S);
4605 // Note: there used to be some attempt at recovery here.
4606 if (Previous.isAmbiguous())
4609 if (!getLangOptions().CPlusPlus && TUK != TUK_Reference) {
4610 // FIXME: This makes sure that we ignore the contexts associated
4611 // with C structs, unions, and enums when looking for a matching
4612 // tag declaration or definition. See the similar lookup tweak
4613 // in Sema::LookupName; is there a better way to deal with this?
4614 while (isa<RecordDecl>(SearchDC) || isa<EnumDecl>(SearchDC))
4615 SearchDC = SearchDC->getParent();
4619 if (Previous.isSingleResult() &&
4620 Previous.getFoundDecl()->isTemplateParameter()) {
4621 // Maybe we will complain about the shadowed template parameter.
4622 DiagnoseTemplateParameterShadow(NameLoc, Previous.getFoundDecl());
4623 // Just pretend that we didn't see the previous declaration.
4627 if (getLangOptions().CPlusPlus && Name && DC && StdNamespace &&
4628 DC->Equals(StdNamespace) && Name->isStr("bad_alloc")) {
4629 // This is a declaration of or a reference to "std::bad_alloc".
4630 isStdBadAlloc = true;
4632 if (Previous.empty() && StdBadAlloc) {
4633 // std::bad_alloc has been implicitly declared (but made invisible to
4634 // name lookup). Fill in this implicit declaration as the previous
4635 // declaration, so that the declarations get chained appropriately.
4636 Previous.addDecl(StdBadAlloc);
4640 if (!Previous.empty()) {
4641 assert(Previous.isSingleResult());
4642 NamedDecl *PrevDecl = Previous.getFoundDecl();
4643 if (TagDecl *PrevTagDecl = dyn_cast<TagDecl>(PrevDecl)) {
4644 // If this is a use of a previous tag, or if the tag is already declared
4645 // in the same scope (so that the definition/declaration completes or
4646 // rementions the tag), reuse the decl.
4647 if (TUK == TUK_Reference || TUK == TUK_Friend ||
4648 isDeclInScope(PrevDecl, SearchDC, S)) {
4649 // Make sure that this wasn't declared as an enum and now used as a
4650 // struct or something similar.
4651 if (!isAcceptableTagRedeclaration(PrevTagDecl, Kind, KWLoc, *Name)) {
4653 = (PrevTagDecl->getTagKind() != TagDecl::TK_enum &&
4654 Kind != TagDecl::TK_enum);
4656 Diag(KWLoc, diag::err_use_with_wrong_tag)
4658 << CodeModificationHint::CreateReplacement(SourceRange(KWLoc),
4659 PrevTagDecl->getKindName());
4661 Diag(KWLoc, diag::err_use_with_wrong_tag) << Name;
4662 Diag(PrevTagDecl->getLocation(), diag::note_previous_use);
4665 Kind = PrevTagDecl->getTagKind();
4667 // Recover by making this an anonymous redefinition.
4675 // If this is a use, just return the declaration we found.
4677 // FIXME: In the future, return a variant or some other clue
4678 // for the consumer of this Decl to know it doesn't own it.
4679 // For our current ASTs this shouldn't be a problem, but will
4680 // need to be changed with DeclGroups.
4681 if (TUK == TUK_Reference || TUK == TUK_Friend)
4682 return DeclPtrTy::make(PrevTagDecl);
4684 // Diagnose attempts to redefine a tag.
4685 if (TUK == TUK_Definition) {
4686 if (TagDecl *Def = PrevTagDecl->getDefinition()) {
4687 // If we're defining a specialization and the previous definition
4688 // is from an implicit instantiation, don't emit an error
4689 // here; we'll catch this in the general case below.
4690 if (!isExplicitSpecialization ||
4691 !isa<CXXRecordDecl>(Def) ||
4692 cast<CXXRecordDecl>(Def)->getTemplateSpecializationKind()
4693 == TSK_ExplicitSpecialization) {
4694 Diag(NameLoc, diag::err_redefinition) << Name;
4695 Diag(Def->getLocation(), diag::note_previous_definition);
4696 // If this is a redefinition, recover by making this
4697 // struct be anonymous, which will make any later
4698 // references get the previous definition.
4704 // If the type is currently being defined, complain
4705 // about a nested redefinition.
4706 TagType *Tag = cast<TagType>(Context.getTagDeclType(PrevTagDecl));
4707 if (Tag->isBeingDefined()) {
4708 Diag(NameLoc, diag::err_nested_redefinition) << Name;
4709 Diag(PrevTagDecl->getLocation(),
4710 diag::note_previous_definition);
4717 // Okay, this is definition of a previously declared or referenced
4718 // tag PrevDecl. We're going to create a new Decl for it.
4721 // If we get here we have (another) forward declaration or we
4722 // have a definition. Just create a new decl.
4725 // If we get here, this is a definition of a new tag type in a nested
4726 // scope, e.g. "struct foo; void bar() { struct foo; }", just create a
4727 // new decl/type. We set PrevDecl to NULL so that the entities
4728 // have distinct types.
4731 // If we get here, we're going to create a new Decl. If PrevDecl
4732 // is non-NULL, it's a definition of the tag declared by
4733 // PrevDecl. If it's NULL, we have a new definition.
4735 // PrevDecl is a namespace, template, or anything else
4736 // that lives in the IDNS_Tag identifier namespace.
4737 if (isDeclInScope(PrevDecl, SearchDC, S)) {
4738 // The tag name clashes with a namespace name, issue an error and
4739 // recover by making this tag be anonymous.
4740 Diag(NameLoc, diag::err_redefinition_different_kind) << Name;
4741 Diag(PrevDecl->getLocation(), diag::note_previous_definition);
4746 // The existing declaration isn't relevant to us; we're in a
4747 // new scope, so clear out the previous declaration.
4751 } else if (TUK == TUK_Reference && SS.isEmpty() && Name) {
4752 // C++ [basic.scope.pdecl]p5:
4753 // -- for an elaborated-type-specifier of the form
4755 // class-key identifier
4757 // if the elaborated-type-specifier is used in the
4758 // decl-specifier-seq or parameter-declaration-clause of a
4759 // function defined in namespace scope, the identifier is
4760 // declared as a class-name in the namespace that contains
4761 // the declaration; otherwise, except as a friend
4762 // declaration, the identifier is declared in the smallest
4763 // non-class, non-function-prototype scope that contains the
4766 // C99 6.7.2.3p8 has a similar (but not identical!) provision for
4767 // C structs and unions.
4769 // It is an error in C++ to declare (rather than define) an enum
4770 // type, including via an elaborated type specifier. We'll
4771 // diagnose that later; for now, declare the enum in the same
4772 // scope as we would have picked for any other tag type.
4774 // GNU C also supports this behavior as part of its incomplete
4775 // enum types extension, while GNU C++ does not.
4777 // Find the context where we'll be declaring the tag.
4778 // FIXME: We would like to maintain the current DeclContext as the
4780 while (SearchDC->isRecord())
4781 SearchDC = SearchDC->getParent();
4783 // Find the scope where we'll be declaring the tag.
4784 while (S->isClassScope() ||
4785 (getLangOptions().CPlusPlus && S->isFunctionPrototypeScope()) ||
4786 ((S->getFlags() & Scope::DeclScope) == 0) ||
4788 ((DeclContext *)S->getEntity())->isTransparentContext()))
4791 } else if (TUK == TUK_Friend && SS.isEmpty() && Name) {
4792 // C++ [namespace.memdef]p3:
4793 // If a friend declaration in a non-local class first declares a
4794 // class or function, the friend class or function is a member of
4795 // the innermost enclosing namespace.
4796 SearchDC = SearchDC->getEnclosingNamespaceContext();
4798 // Look up through our scopes until we find one with an entity which
4799 // matches our declaration context.
4800 while (S->getEntity() &&
4801 ((DeclContext *)S->getEntity())->getPrimaryContext() != SearchDC) {
4803 assert(S && "No enclosing scope matching the enclosing namespace.");
4809 TagDecl *PrevDecl = 0;
4810 if (Previous.isSingleResult())
4811 PrevDecl = cast<TagDecl>(Previous.getFoundDecl());
4813 // If there is an identifier, use the location of the identifier as the
4814 // location of the decl, otherwise use the location of the struct/union
4816 SourceLocation Loc = NameLoc.isValid() ? NameLoc : KWLoc;
4818 // Otherwise, create a new declaration. If there is a previous
4819 // declaration of the same entity, the two will be linked via
4823 if (Kind == TagDecl::TK_enum) {
4824 // FIXME: Tag decls should be chained to any simultaneous vardecls, e.g.:
4825 // enum X { A, B, C } D; D should chain to X.
4826 New = EnumDecl::Create(Context, SearchDC, Loc, Name, KWLoc,
4827 cast_or_null<EnumDecl>(PrevDecl));
4828 // If this is an undefined enum, warn.
4829 if (TUK != TUK_Definition && !Invalid) {
4830 unsigned DK = getLangOptions().CPlusPlus? diag::err_forward_ref_enum
4831 : diag::ext_forward_ref_enum;
4835 // struct/union/class
4837 // FIXME: Tag decls should be chained to any simultaneous vardecls, e.g.:
4838 // struct X { int A; } D; D should chain to X.
4839 if (getLangOptions().CPlusPlus) {
4840 // FIXME: Look for a way to use RecordDecl for simple structs.
4841 New = CXXRecordDecl::Create(Context, Kind, SearchDC, Loc, Name, KWLoc,
4842 cast_or_null<CXXRecordDecl>(PrevDecl));
4844 if (isStdBadAlloc && (!StdBadAlloc || StdBadAlloc->isImplicit()))
4845 StdBadAlloc = cast<CXXRecordDecl>(New);
4847 New = RecordDecl::Create(Context, Kind, SearchDC, Loc, Name, KWLoc,
4848 cast_or_null<RecordDecl>(PrevDecl));
4851 if (Kind != TagDecl::TK_enum) {
4852 // Handle #pragma pack: if the #pragma pack stack has non-default
4853 // alignment, make up a packed attribute for this decl. These
4854 // attributes are checked when the ASTContext lays out the
4857 // It is important for implementing the correct semantics that this
4858 // happen here (in act on tag decl). The #pragma pack stack is
4859 // maintained as a result of parser callbacks which can occur at
4860 // many points during the parsing of a struct declaration (because
4861 // the #pragma tokens are effectively skipped over during the
4862 // parsing of the struct).
4863 if (unsigned Alignment = getPragmaPackAlignment())
4864 New->addAttr(::new (Context) PragmaPackAttr(Alignment * 8));
4867 if (getLangOptions().CPlusPlus && SS.isEmpty() && Name && !Invalid) {
4868 // C++ [dcl.typedef]p3:
4869 // [...] Similarly, in a given scope, a class or enumeration
4870 // shall not be declared with the same name as a typedef-name
4871 // that is declared in that scope and refers to a type other
4872 // than the class or enumeration itself.
4873 LookupResult Lookup(*this, Name, NameLoc, LookupOrdinaryName,
4875 LookupName(Lookup, S);
4876 TypedefDecl *PrevTypedef = Lookup.getAsSingle<TypedefDecl>();
4877 NamedDecl *PrevTypedefNamed = PrevTypedef;
4878 if (PrevTypedef && isDeclInScope(PrevTypedefNamed, SearchDC, S) &&
4879 Context.getCanonicalType(Context.getTypeDeclType(PrevTypedef)) !=
4880 Context.getCanonicalType(Context.getTypeDeclType(New))) {
4881 Diag(Loc, diag::err_tag_definition_of_typedef)
4882 << Context.getTypeDeclType(New)
4883 << PrevTypedef->getUnderlyingType();
4884 Diag(PrevTypedef->getLocation(), diag::note_previous_definition);
4889 // If this is a specialization of a member class (of a class template),
4890 // check the specialization.
4891 if (isExplicitSpecialization && CheckMemberSpecialization(New, Previous))
4895 New->setInvalidDecl();
4898 ProcessDeclAttributeList(S, New, Attr);
4900 // If we're declaring or defining a tag in function prototype scope
4901 // in C, note that this type can only be used within the function.
4902 if (Name && S->isFunctionPrototypeScope() && !getLangOptions().CPlusPlus)
4903 Diag(Loc, diag::warn_decl_in_param_list) << Context.getTagDeclType(New);
4905 // Set the lexical context. If the tag has a C++ scope specifier, the
4906 // lexical context will be different from the semantic context.
4907 New->setLexicalDeclContext(CurContext);
4909 // Mark this as a friend decl if applicable.
4910 if (TUK == TUK_Friend)
4911 New->setObjectOfFriendDecl(/* PreviouslyDeclared = */ !Previous.empty());
4913 // Set the access specifier.
4914 if (!Invalid && TUK != TUK_Friend)
4915 SetMemberAccessSpecifier(New, PrevDecl, AS);
4917 if (TUK == TUK_Definition)
4918 New->startDefinition();
4920 // If this has an identifier, add it to the scope stack.
4921 if (TUK == TUK_Friend) {
4922 // We might be replacing an existing declaration in the lookup tables;
4923 // if so, borrow its access specifier.
4925 New->setAccess(PrevDecl->getAccess());
4927 // Friend tag decls are visible in fairly strange ways.
4928 if (!CurContext->isDependentContext()) {
4929 DeclContext *DC = New->getDeclContext()->getLookupContext();
4930 DC->makeDeclVisibleInContext(New, /* Recoverable = */ false);
4931 if (Scope *EnclosingScope = getScopeForDeclContext(S, DC))
4932 PushOnScopeChains(New, EnclosingScope, /* AddToContext = */ false);
4935 S = getNonFieldDeclScope(S);
4936 PushOnScopeChains(New, S);
4938 CurContext->addDecl(New);
4941 // If this is the C FILE type, notify the AST context.
4942 if (IdentifierInfo *II = New->getIdentifier())
4943 if (!New->isInvalidDecl() &&
4944 New->getDeclContext()->getLookupContext()->isTranslationUnit() &&
4946 Context.setFILEDecl(New);
4949 return DeclPtrTy::make(New);
4952 void Sema::ActOnTagStartDefinition(Scope *S, DeclPtrTy TagD) {
4953 AdjustDeclIfTemplate(TagD);
4954 TagDecl *Tag = cast<TagDecl>(TagD.getAs<Decl>());
4956 // Enter the tag context.
4957 PushDeclContext(S, Tag);
4960 void Sema::ActOnStartCXXMemberDeclarations(Scope *S, DeclPtrTy TagD,
4961 SourceLocation LBraceLoc) {
4962 AdjustDeclIfTemplate(TagD);
4963 CXXRecordDecl *Record = cast<CXXRecordDecl>(TagD.getAs<Decl>());
4965 FieldCollector->StartClass();
4967 if (!Record->getIdentifier())
4971 // [...] The class-name is also inserted into the scope of the
4972 // class itself; this is known as the injected-class-name. For
4973 // purposes of access checking, the injected-class-name is treated
4974 // as if it were a public member name.
4975 CXXRecordDecl *InjectedClassName
4976 = CXXRecordDecl::Create(Context, Record->getTagKind(),
4977 CurContext, Record->getLocation(),
4978 Record->getIdentifier(),
4979 Record->getTagKeywordLoc(),
4981 InjectedClassName->setImplicit();
4982 InjectedClassName->setAccess(AS_public);
4983 if (ClassTemplateDecl *Template = Record->getDescribedClassTemplate())
4984 InjectedClassName->setDescribedClassTemplate(Template);
4985 PushOnScopeChains(InjectedClassName, S);
4986 assert(InjectedClassName->isInjectedClassName() &&
4987 "Broken injected-class-name");
4990 // Traverses the class and any nested classes, making a note of any
4991 // dynamic classes that have no key function so that we can mark all of
4992 // their virtual member functions as "used" at the end of the translation
4993 // unit. This ensures that all functions needed by the vtable will get
4994 // instantiated/synthesized.
4996 RecordDynamicClassesWithNoKeyFunction(Sema &S, CXXRecordDecl *Record,
4997 SourceLocation Loc) {
4998 // We don't look at dependent or undefined classes.
4999 if (Record->isDependentContext() || !Record->isDefinition())
5002 if (Record->isDynamicClass()) {
5003 const CXXMethodDecl *KeyFunction = S.Context.getKeyFunction(Record);
5006 S.ClassesWithUnmarkedVirtualMembers.push_back(std::make_pair(Record,
5009 if ((!KeyFunction || (KeyFunction->getBody() && KeyFunction->isInlined()))
5010 && Record->getLinkage() == ExternalLinkage)
5011 S.Diag(Record->getLocation(), diag::warn_weak_vtable) << Record;
5013 for (DeclContext::decl_iterator D = Record->decls_begin(),
5014 DEnd = Record->decls_end();
5016 if (CXXRecordDecl *Nested = dyn_cast<CXXRecordDecl>(*D))
5017 RecordDynamicClassesWithNoKeyFunction(S, Nested, Loc);
5021 void Sema::ActOnTagFinishDefinition(Scope *S, DeclPtrTy TagD,
5022 SourceLocation RBraceLoc) {
5023 AdjustDeclIfTemplate(TagD);
5024 TagDecl *Tag = cast<TagDecl>(TagD.getAs<Decl>());
5025 Tag->setRBraceLoc(RBraceLoc);
5027 if (isa<CXXRecordDecl>(Tag))
5028 FieldCollector->FinishClass();
5030 // Exit this scope of this tag's definition.
5033 if (isa<CXXRecordDecl>(Tag) && !Tag->getDeclContext()->isRecord())
5034 RecordDynamicClassesWithNoKeyFunction(*this, cast<CXXRecordDecl>(Tag),
5037 // Notify the consumer that we've defined a tag.
5038 Consumer.HandleTagDeclDefinition(Tag);
5041 // Note that FieldName may be null for anonymous bitfields.
5042 bool Sema::VerifyBitField(SourceLocation FieldLoc, IdentifierInfo *FieldName,
5043 QualType FieldTy, const Expr *BitWidth,
5045 // Default to true; that shouldn't confuse checks for emptiness
5049 // C99 6.7.2.1p4 - verify the field type.
5050 // C++ 9.6p3: A bit-field shall have integral or enumeration type.
5051 if (!FieldTy->isDependentType() && !FieldTy->isIntegralType()) {
5052 // Handle incomplete types with specific error.
5053 if (RequireCompleteType(FieldLoc, FieldTy, diag::err_field_incomplete))
5056 return Diag(FieldLoc, diag::err_not_integral_type_bitfield)
5057 << FieldName << FieldTy << BitWidth->getSourceRange();
5058 return Diag(FieldLoc, diag::err_not_integral_type_anon_bitfield)
5059 << FieldTy << BitWidth->getSourceRange();
5062 // If the bit-width is type- or value-dependent, don't try to check
5064 if (BitWidth->isValueDependent() || BitWidth->isTypeDependent())
5068 if (VerifyIntegerConstantExpression(BitWidth, &Value))
5071 if (Value != 0 && ZeroWidth)
5074 // Zero-width bitfield is ok for anonymous field.
5075 if (Value == 0 && FieldName)
5076 return Diag(FieldLoc, diag::err_bitfield_has_zero_width) << FieldName;
5078 if (Value.isSigned() && Value.isNegative()) {
5080 return Diag(FieldLoc, diag::err_bitfield_has_negative_width)
5081 << FieldName << Value.toString(10);
5082 return Diag(FieldLoc, diag::err_anon_bitfield_has_negative_width)
5083 << Value.toString(10);
5086 if (!FieldTy->isDependentType()) {
5087 uint64_t TypeSize = Context.getTypeSize(FieldTy);
5088 if (Value.getZExtValue() > TypeSize) {
5090 return Diag(FieldLoc, diag::err_bitfield_width_exceeds_type_size)
5091 << FieldName << (unsigned)TypeSize;
5092 return Diag(FieldLoc, diag::err_anon_bitfield_width_exceeds_type_size)
5093 << (unsigned)TypeSize;
5100 /// ActOnField - Each field of a struct/union/class is passed into this in order
5101 /// to create a FieldDecl object for it.
5102 Sema::DeclPtrTy Sema::ActOnField(Scope *S, DeclPtrTy TagD,
5103 SourceLocation DeclStart,
5104 Declarator &D, ExprTy *BitfieldWidth) {
5105 FieldDecl *Res = HandleField(S, cast_or_null<RecordDecl>(TagD.getAs<Decl>()),
5106 DeclStart, D, static_cast<Expr*>(BitfieldWidth),
5108 return DeclPtrTy::make(Res);
5111 /// HandleField - Analyze a field of a C struct or a C++ data member.
5113 FieldDecl *Sema::HandleField(Scope *S, RecordDecl *Record,
5114 SourceLocation DeclStart,
5115 Declarator &D, Expr *BitWidth,
5116 AccessSpecifier AS) {
5117 IdentifierInfo *II = D.getIdentifier();
5118 SourceLocation Loc = DeclStart;
5119 if (II) Loc = D.getIdentifierLoc();
5121 TypeSourceInfo *TInfo = 0;
5122 QualType T = GetTypeForDeclarator(D, S, &TInfo);
5123 if (getLangOptions().CPlusPlus)
5124 CheckExtraCXXDefaultArguments(D);
5126 DiagnoseFunctionSpecifiers(D);
5128 if (D.getDeclSpec().isThreadSpecified())
5129 Diag(D.getDeclSpec().getThreadSpecLoc(), diag::err_invalid_thread);
5131 NamedDecl *PrevDecl = LookupSingleName(S, II, LookupMemberName,
5134 if (PrevDecl && PrevDecl->isTemplateParameter()) {
5135 // Maybe we will complain about the shadowed template parameter.
5136 DiagnoseTemplateParameterShadow(D.getIdentifierLoc(), PrevDecl);
5137 // Just pretend that we didn't see the previous declaration.
5141 if (PrevDecl && !isDeclInScope(PrevDecl, Record, S))
5145 = (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_mutable);
5146 SourceLocation TSSL = D.getSourceRange().getBegin();
5148 = CheckFieldDecl(II, T, TInfo, Record, Loc, Mutable, BitWidth, TSSL,
5150 if (NewFD->isInvalidDecl() && PrevDecl) {
5151 // Don't introduce NewFD into scope; there's already something
5152 // with the same name in the same scope.
5154 PushOnScopeChains(NewFD, S);
5156 Record->addDecl(NewFD);
5161 /// \brief Build a new FieldDecl and check its well-formedness.
5163 /// This routine builds a new FieldDecl given the fields name, type,
5164 /// record, etc. \p PrevDecl should refer to any previous declaration
5165 /// with the same name and in the same scope as the field to be
5168 /// \returns a new FieldDecl.
5170 /// \todo The Declarator argument is a hack. It will be removed once
5171 FieldDecl *Sema::CheckFieldDecl(DeclarationName Name, QualType T,
5172 TypeSourceInfo *TInfo,
5173 RecordDecl *Record, SourceLocation Loc,
5174 bool Mutable, Expr *BitWidth,
5175 SourceLocation TSSL,
5176 AccessSpecifier AS, NamedDecl *PrevDecl,
5178 IdentifierInfo *II = Name.getAsIdentifierInfo();
5179 bool InvalidDecl = false;
5180 if (D) InvalidDecl = D->isInvalidType();
5182 // If we receive a broken type, recover by assuming 'int' and
5183 // marking this declaration as invalid.
5189 QualType EltTy = Context.getBaseElementType(T);
5190 if (!EltTy->isDependentType() &&
5191 RequireCompleteType(Loc, EltTy, diag::err_field_incomplete))
5194 // C99 6.7.2.1p8: A member of a structure or union may have any type other
5195 // than a variably modified type.
5196 if (!InvalidDecl && T->isVariablyModifiedType()) {
5197 bool SizeIsNegative;
5198 QualType FixedTy = TryToFixInvalidVariablyModifiedType(T, Context,
5200 if (!FixedTy.isNull()) {
5201 Diag(Loc, diag::warn_illegal_constant_array_size);
5205 Diag(Loc, diag::err_typecheck_negative_array_size);
5207 Diag(Loc, diag::err_typecheck_field_variable_size);
5212 // Fields can not have abstract class types
5213 if (!InvalidDecl && RequireNonAbstractType(Loc, T,
5214 diag::err_abstract_type_in_decl,
5218 bool ZeroWidth = false;
5219 // If this is declared as a bit-field, check the bit-field.
5220 if (!InvalidDecl && BitWidth &&
5221 VerifyBitField(Loc, II, T, BitWidth, &ZeroWidth)) {
5223 DeleteExpr(BitWidth);
5228 FieldDecl *NewFD = FieldDecl::Create(Context, Record, Loc, II, T, TInfo,
5231 NewFD->setInvalidDecl();
5233 if (PrevDecl && !isa<TagDecl>(PrevDecl)) {
5234 Diag(Loc, diag::err_duplicate_member) << II;
5235 Diag(PrevDecl->getLocation(), diag::note_previous_declaration);
5236 NewFD->setInvalidDecl();
5239 if (!InvalidDecl && getLangOptions().CPlusPlus) {
5240 CXXRecordDecl* CXXRecord = cast<CXXRecordDecl>(Record);
5242 if (!T->isPODType())
5243 CXXRecord->setPOD(false);
5245 CXXRecord->setEmpty(false);
5247 if (const RecordType *RT = EltTy->getAs<RecordType>()) {
5248 CXXRecordDecl* RDecl = cast<CXXRecordDecl>(RT->getDecl());
5250 if (!RDecl->hasTrivialConstructor())
5251 CXXRecord->setHasTrivialConstructor(false);
5252 if (!RDecl->hasTrivialCopyConstructor())
5253 CXXRecord->setHasTrivialCopyConstructor(false);
5254 if (!RDecl->hasTrivialCopyAssignment())
5255 CXXRecord->setHasTrivialCopyAssignment(false);
5256 if (!RDecl->hasTrivialDestructor())
5257 CXXRecord->setHasTrivialDestructor(false);
5259 // C++ 9.5p1: An object of a class with a non-trivial
5260 // constructor, a non-trivial copy constructor, a non-trivial
5261 // destructor, or a non-trivial copy assignment operator
5262 // cannot be a member of a union, nor can an array of such
5264 // TODO: C++0x alters this restriction significantly.
5265 if (Record->isUnion()) {
5266 // We check for copy constructors before constructors
5267 // because otherwise we'll never get complaints about
5268 // copy constructors.
5270 const CXXSpecialMember invalid = (CXXSpecialMember) -1;
5272 CXXSpecialMember member;
5273 if (!RDecl->hasTrivialCopyConstructor())
5274 member = CXXCopyConstructor;
5275 else if (!RDecl->hasTrivialConstructor())
5276 member = CXXDefaultConstructor;
5277 else if (!RDecl->hasTrivialCopyAssignment())
5278 member = CXXCopyAssignment;
5279 else if (!RDecl->hasTrivialDestructor())
5280 member = CXXDestructor;
5284 if (member != invalid) {
5285 Diag(Loc, diag::err_illegal_union_member) << Name << member;
5286 DiagnoseNontrivial(RT, member);
5287 NewFD->setInvalidDecl();
5293 // FIXME: We need to pass in the attributes given an AST
5294 // representation, not a parser representation.
5296 // FIXME: What to pass instead of TUScope?
5297 ProcessDeclAttributes(TUScope, NewFD, *D);
5299 if (T.isObjCGCWeak())
5300 Diag(Loc, diag::warn_attribute_weak_on_field);
5302 NewFD->setAccess(AS);
5304 // C++ [dcl.init.aggr]p1:
5305 // An aggregate is an array or a class (clause 9) with [...] no
5306 // private or protected non-static data members (clause 11).
5307 // A POD must be an aggregate.
5308 if (getLangOptions().CPlusPlus &&
5309 (AS == AS_private || AS == AS_protected)) {
5310 CXXRecordDecl *CXXRecord = cast<CXXRecordDecl>(Record);
5311 CXXRecord->setAggregate(false);
5312 CXXRecord->setPOD(false);
5318 /// DiagnoseNontrivial - Given that a class has a non-trivial
5319 /// special member, figure out why.
5320 void Sema::DiagnoseNontrivial(const RecordType* T, CXXSpecialMember member) {
5322 CXXRecordDecl* RD = cast<CXXRecordDecl>(T->getDecl());
5324 // Check whether the member was user-declared.
5326 case CXXDefaultConstructor:
5327 if (RD->hasUserDeclaredConstructor()) {
5328 typedef CXXRecordDecl::ctor_iterator ctor_iter;
5329 for (ctor_iter ci = RD->ctor_begin(), ce = RD->ctor_end(); ci != ce;++ci){
5330 const FunctionDecl *body = 0;
5333 !cast<CXXConstructorDecl>(body)->isImplicitlyDefined(Context)) {
5334 SourceLocation CtorLoc = ci->getLocation();
5335 Diag(CtorLoc, diag::note_nontrivial_user_defined) << QT << member;
5340 assert(0 && "found no user-declared constructors");
5345 case CXXCopyConstructor:
5346 if (RD->hasUserDeclaredCopyConstructor()) {
5347 SourceLocation CtorLoc =
5348 RD->getCopyConstructor(Context, 0)->getLocation();
5349 Diag(CtorLoc, diag::note_nontrivial_user_defined) << QT << member;
5354 case CXXCopyAssignment:
5355 if (RD->hasUserDeclaredCopyAssignment()) {
5356 // FIXME: this should use the location of the copy
5357 // assignment, not the type.
5358 SourceLocation TyLoc = RD->getSourceRange().getBegin();
5359 Diag(TyLoc, diag::note_nontrivial_user_defined) << QT << member;
5365 if (RD->hasUserDeclaredDestructor()) {
5366 SourceLocation DtorLoc = RD->getDestructor(Context)->getLocation();
5367 Diag(DtorLoc, diag::note_nontrivial_user_defined) << QT << member;
5373 typedef CXXRecordDecl::base_class_iterator base_iter;
5375 // Virtual bases and members inhibit trivial copying/construction,
5376 // but not trivial destruction.
5377 if (member != CXXDestructor) {
5378 // Check for virtual bases. vbases includes indirect virtual bases,
5379 // so we just iterate through the direct bases.
5380 for (base_iter bi = RD->bases_begin(), be = RD->bases_end(); bi != be; ++bi)
5381 if (bi->isVirtual()) {
5382 SourceLocation BaseLoc = bi->getSourceRange().getBegin();
5383 Diag(BaseLoc, diag::note_nontrivial_has_virtual) << QT << 1;
5387 // Check for virtual methods.
5388 typedef CXXRecordDecl::method_iterator meth_iter;
5389 for (meth_iter mi = RD->method_begin(), me = RD->method_end(); mi != me;
5391 if (mi->isVirtual()) {
5392 SourceLocation MLoc = mi->getSourceRange().getBegin();
5393 Diag(MLoc, diag::note_nontrivial_has_virtual) << QT << 0;
5399 bool (CXXRecordDecl::*hasTrivial)() const;
5401 case CXXDefaultConstructor:
5402 hasTrivial = &CXXRecordDecl::hasTrivialConstructor; break;
5403 case CXXCopyConstructor:
5404 hasTrivial = &CXXRecordDecl::hasTrivialCopyConstructor; break;
5405 case CXXCopyAssignment:
5406 hasTrivial = &CXXRecordDecl::hasTrivialCopyAssignment; break;
5408 hasTrivial = &CXXRecordDecl::hasTrivialDestructor; break;
5410 assert(0 && "unexpected special member"); return;
5413 // Check for nontrivial bases (and recurse).
5414 for (base_iter bi = RD->bases_begin(), be = RD->bases_end(); bi != be; ++bi) {
5415 const RecordType *BaseRT = bi->getType()->getAs<RecordType>();
5416 assert(BaseRT && "Don't know how to handle dependent bases");
5417 CXXRecordDecl *BaseRecTy = cast<CXXRecordDecl>(BaseRT->getDecl());
5418 if (!(BaseRecTy->*hasTrivial)()) {
5419 SourceLocation BaseLoc = bi->getSourceRange().getBegin();
5420 Diag(BaseLoc, diag::note_nontrivial_has_nontrivial) << QT << 1 << member;
5421 DiagnoseNontrivial(BaseRT, member);
5426 // Check for nontrivial members (and recurse).
5427 typedef RecordDecl::field_iterator field_iter;
5428 for (field_iter fi = RD->field_begin(), fe = RD->field_end(); fi != fe;
5430 QualType EltTy = Context.getBaseElementType((*fi)->getType());
5431 if (const RecordType *EltRT = EltTy->getAs<RecordType>()) {
5432 CXXRecordDecl* EltRD = cast<CXXRecordDecl>(EltRT->getDecl());
5434 if (!(EltRD->*hasTrivial)()) {
5435 SourceLocation FLoc = (*fi)->getLocation();
5436 Diag(FLoc, diag::note_nontrivial_has_nontrivial) << QT << 0 << member;
5437 DiagnoseNontrivial(EltRT, member);
5443 assert(0 && "found no explanation for non-trivial member");
5446 /// TranslateIvarVisibility - Translate visibility from a token ID to an
5448 static ObjCIvarDecl::AccessControl
5449 TranslateIvarVisibility(tok::ObjCKeywordKind ivarVisibility) {
5450 switch (ivarVisibility) {
5451 default: assert(0 && "Unknown visitibility kind");
5452 case tok::objc_private: return ObjCIvarDecl::Private;
5453 case tok::objc_public: return ObjCIvarDecl::Public;
5454 case tok::objc_protected: return ObjCIvarDecl::Protected;
5455 case tok::objc_package: return ObjCIvarDecl::Package;
5459 /// ActOnIvar - Each ivar field of an objective-c class is passed into this
5460 /// in order to create an IvarDecl object for it.
5461 Sema::DeclPtrTy Sema::ActOnIvar(Scope *S,
5462 SourceLocation DeclStart,
5464 Declarator &D, ExprTy *BitfieldWidth,
5465 tok::ObjCKeywordKind Visibility) {
5467 IdentifierInfo *II = D.getIdentifier();
5468 Expr *BitWidth = (Expr*)BitfieldWidth;
5469 SourceLocation Loc = DeclStart;
5470 if (II) Loc = D.getIdentifierLoc();
5472 // FIXME: Unnamed fields can be handled in various different ways, for
5473 // example, unnamed unions inject all members into the struct namespace!
5475 TypeSourceInfo *TInfo = 0;
5476 QualType T = GetTypeForDeclarator(D, S, &TInfo);
5479 // 6.7.2.1p3, 6.7.2.1p4
5480 if (VerifyBitField(Loc, II, T, BitWidth)) {
5482 DeleteExpr(BitWidth);
5492 // C99 6.7.2.1p8: A member of a structure or union may have any type other
5493 // than a variably modified type.
5494 if (T->isVariablyModifiedType()) {
5495 Diag(Loc, diag::err_typecheck_ivar_variable_size);
5499 // Get the visibility (access control) for this ivar.
5500 ObjCIvarDecl::AccessControl ac =
5501 Visibility != tok::objc_not_keyword ? TranslateIvarVisibility(Visibility)
5502 : ObjCIvarDecl::None;
5503 // Must set ivar's DeclContext to its enclosing interface.
5504 Decl *EnclosingDecl = IntfDecl.getAs<Decl>();
5505 DeclContext *EnclosingContext;
5506 if (ObjCImplementationDecl *IMPDecl =
5507 dyn_cast<ObjCImplementationDecl>(EnclosingDecl)) {
5508 // Case of ivar declared in an implementation. Context is that of its class.
5509 ObjCInterfaceDecl* IDecl = IMPDecl->getClassInterface();
5510 assert(IDecl && "No class- ActOnIvar");
5511 EnclosingContext = cast_or_null<DeclContext>(IDecl);
5513 EnclosingContext = dyn_cast<DeclContext>(EnclosingDecl);
5514 assert(EnclosingContext && "null DeclContext for ivar - ActOnIvar");
5516 // Construct the decl.
5517 ObjCIvarDecl *NewID = ObjCIvarDecl::Create(Context,
5518 EnclosingContext, Loc, II, T,
5519 TInfo, ac, (Expr *)BitfieldWidth);
5522 NamedDecl *PrevDecl = LookupSingleName(S, II, LookupMemberName,
5524 if (PrevDecl && isDeclInScope(PrevDecl, EnclosingContext, S)
5525 && !isa<TagDecl>(PrevDecl)) {
5526 Diag(Loc, diag::err_duplicate_member) << II;
5527 Diag(PrevDecl->getLocation(), diag::note_previous_declaration);
5528 NewID->setInvalidDecl();
5532 // Process attributes attached to the ivar.
5533 ProcessDeclAttributes(S, NewID, D);
5535 if (D.isInvalidType())
5536 NewID->setInvalidDecl();
5539 // FIXME: When interfaces are DeclContexts, we'll need to add
5540 // these to the interface.
5541 S->AddDecl(DeclPtrTy::make(NewID));
5542 IdResolver.AddDecl(NewID);
5545 return DeclPtrTy::make(NewID);
5548 void Sema::ActOnFields(Scope* S,
5549 SourceLocation RecLoc, DeclPtrTy RecDecl,
5550 DeclPtrTy *Fields, unsigned NumFields,
5551 SourceLocation LBrac, SourceLocation RBrac,
5552 AttributeList *Attr) {
5553 Decl *EnclosingDecl = RecDecl.getAs<Decl>();
5554 assert(EnclosingDecl && "missing record or interface decl");
5556 // If the decl this is being inserted into is invalid, then it may be a
5557 // redeclaration or some other bogus case. Don't try to add fields to it.
5558 if (EnclosingDecl->isInvalidDecl()) {
5559 // FIXME: Deallocate fields?
5564 // Verify that all the fields are okay.
5565 unsigned NumNamedMembers = 0;
5566 llvm::SmallVector<FieldDecl*, 32> RecFields;
5568 RecordDecl *Record = dyn_cast<RecordDecl>(EnclosingDecl);
5569 for (unsigned i = 0; i != NumFields; ++i) {
5570 FieldDecl *FD = cast<FieldDecl>(Fields[i].getAs<Decl>());
5572 // Get the type for the field.
5573 Type *FDTy = FD->getType().getTypePtr();
5575 if (!FD->isAnonymousStructOrUnion()) {
5576 // Remember all fields written by the user.
5577 RecFields.push_back(FD);
5580 // If the field is already invalid for some reason, don't emit more
5581 // diagnostics about it.
5582 if (FD->isInvalidDecl()) {
5583 EnclosingDecl->setInvalidDecl();
5588 // A structure or union shall not contain a member with
5589 // incomplete or function type (hence, a structure shall not
5590 // contain an instance of itself, but may contain a pointer to
5591 // an instance of itself), except that the last member of a
5592 // structure with more than one named member may have incomplete
5593 // array type; such a structure (and any union containing,
5594 // possibly recursively, a member that is such a structure)
5595 // shall not be a member of a structure or an element of an
5597 if (FDTy->isFunctionType()) {
5598 // Field declared as a function.
5599 Diag(FD->getLocation(), diag::err_field_declared_as_function)
5600 << FD->getDeclName();
5601 FD->setInvalidDecl();
5602 EnclosingDecl->setInvalidDecl();
5604 } else if (FDTy->isIncompleteArrayType() && i == NumFields - 1 &&
5605 Record && Record->isStruct()) {
5606 // Flexible array member.
5607 if (NumNamedMembers < 1) {
5608 Diag(FD->getLocation(), diag::err_flexible_array_empty_struct)
5609 << FD->getDeclName();
5610 FD->setInvalidDecl();
5611 EnclosingDecl->setInvalidDecl();
5614 // Okay, we have a legal flexible array member at the end of the struct.
5616 Record->setHasFlexibleArrayMember(true);
5617 } else if (!FDTy->isDependentType() &&
5618 RequireCompleteType(FD->getLocation(), FD->getType(),
5619 diag::err_field_incomplete)) {
5621 FD->setInvalidDecl();
5622 EnclosingDecl->setInvalidDecl();
5624 } else if (const RecordType *FDTTy = FDTy->getAs<RecordType>()) {
5625 if (FDTTy->getDecl()->hasFlexibleArrayMember()) {
5626 // If this is a member of a union, then entire union becomes "flexible".
5627 if (Record && Record->isUnion()) {
5628 Record->setHasFlexibleArrayMember(true);
5630 // If this is a struct/class and this is not the last element, reject
5631 // it. Note that GCC supports variable sized arrays in the middle of
5633 if (i != NumFields-1)
5634 Diag(FD->getLocation(), diag::ext_variable_sized_type_in_struct)
5635 << FD->getDeclName() << FD->getType();
5637 // We support flexible arrays at the end of structs in
5638 // other structs as an extension.
5639 Diag(FD->getLocation(), diag::ext_flexible_array_in_struct)
5640 << FD->getDeclName();
5642 Record->setHasFlexibleArrayMember(true);
5646 if (Record && FDTTy->getDecl()->hasObjectMember())
5647 Record->setHasObjectMember(true);
5648 } else if (FDTy->isObjCInterfaceType()) {
5649 /// A field cannot be an Objective-c object
5650 Diag(FD->getLocation(), diag::err_statically_allocated_object);
5651 FD->setInvalidDecl();
5652 EnclosingDecl->setInvalidDecl();
5654 } else if (getLangOptions().ObjC1 &&
5655 getLangOptions().getGCMode() != LangOptions::NonGC &&
5657 (FD->getType()->isObjCObjectPointerType() ||
5658 FD->getType().isObjCGCStrong()))
5659 Record->setHasObjectMember(true);
5660 // Keep track of the number of named members.
5661 if (FD->getIdentifier())
5665 // Okay, we successfully defined 'Record'.
5667 Record->completeDefinition();
5669 ObjCIvarDecl **ClsFields =
5670 reinterpret_cast<ObjCIvarDecl**>(RecFields.data());
5671 if (ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(EnclosingDecl)) {
5672 ID->setLocEnd(RBrac);
5673 // Add ivar's to class's DeclContext.
5674 for (unsigned i = 0, e = RecFields.size(); i != e; ++i) {
5675 ClsFields[i]->setLexicalDeclContext(ID);
5676 ID->addDecl(ClsFields[i]);
5678 // Must enforce the rule that ivars in the base classes may not be
5680 if (ID->getSuperClass())
5681 DiagnoseDuplicateIvars(ID, ID->getSuperClass());
5682 } else if (ObjCImplementationDecl *IMPDecl =
5683 dyn_cast<ObjCImplementationDecl>(EnclosingDecl)) {
5684 assert(IMPDecl && "ActOnFields - missing ObjCImplementationDecl");
5685 for (unsigned I = 0, N = RecFields.size(); I != N; ++I)
5686 // Ivar declared in @implementation never belongs to the implementation.
5687 // Only it is in implementation's lexical context.
5688 ClsFields[I]->setLexicalDeclContext(IMPDecl);
5689 CheckImplementationIvars(IMPDecl, ClsFields, RecFields.size(), RBrac);
5690 } else if (ObjCCategoryDecl *CDecl =
5691 dyn_cast<ObjCCategoryDecl>(EnclosingDecl)) {
5692 if (!LangOpts.ObjCNonFragileABI2 || !CDecl->IsClassExtension())
5693 Diag(LBrac, diag::err_misplaced_ivar);
5695 // FIXME. Class extension does not have a LocEnd field.
5696 // CDecl->setLocEnd(RBrac);
5697 // Add ivar's to class extension's DeclContext.
5698 for (unsigned i = 0, e = RecFields.size(); i != e; ++i) {
5699 ClsFields[i]->setLexicalDeclContext(CDecl);
5700 CDecl->addDecl(ClsFields[i]);
5707 ProcessDeclAttributeList(S, Record, Attr);
5710 /// \brief Determine whether the given integral value is representable within
5711 /// the given type T.
5712 static bool isRepresentableIntegerValue(ASTContext &Context,
5713 llvm::APSInt &Value,
5715 assert(T->isIntegralType() && "Integral type required!");
5716 unsigned BitWidth = Context.getTypeSize(T);
5718 if (Value.isUnsigned() || Value.isNonNegative())
5719 return Value.getActiveBits() < BitWidth;
5721 return Value.getMinSignedBits() <= BitWidth;
5724 // \brief Given an integral type, return the next larger integral type
5725 // (or a NULL type of no such type exists).
5726 static QualType getNextLargerIntegralType(ASTContext &Context, QualType T) {
5727 // FIXME: Int128/UInt128 support, which also needs to be introduced into
5728 // enum checking below.
5729 assert(T->isIntegralType() && "Integral type required!");
5730 const unsigned NumTypes = 4;
5731 QualType SignedIntegralTypes[NumTypes] = {
5732 Context.ShortTy, Context.IntTy, Context.LongTy, Context.LongLongTy
5734 QualType UnsignedIntegralTypes[NumTypes] = {
5735 Context.UnsignedShortTy, Context.UnsignedIntTy, Context.UnsignedLongTy,
5736 Context.UnsignedLongLongTy
5739 unsigned BitWidth = Context.getTypeSize(T);
5740 QualType *Types = T->isSignedIntegerType()? SignedIntegralTypes
5741 : UnsignedIntegralTypes;
5742 for (unsigned I = 0; I != NumTypes; ++I)
5743 if (Context.getTypeSize(Types[I]) > BitWidth)
5749 EnumConstantDecl *Sema::CheckEnumConstant(EnumDecl *Enum,
5750 EnumConstantDecl *LastEnumConst,
5751 SourceLocation IdLoc,
5754 Expr *Val = (Expr *)val.get();
5756 unsigned IntWidth = Context.Target.getIntWidth();
5757 llvm::APSInt EnumVal(IntWidth);
5760 if (Enum->isDependentType() || Val->isTypeDependent())
5761 EltTy = Context.DependentTy;
5763 // C99 6.7.2.2p2: Make sure we have an integer constant expression.
5764 SourceLocation ExpLoc;
5765 if (!Val->isValueDependent() &&
5766 VerifyIntegerConstantExpression(Val, &EnumVal)) {
5769 if (!getLangOptions().CPlusPlus) {
5771 // The expression that defines the value of an enumeration constant
5772 // shall be an integer constant expression that has a value
5773 // representable as an int.
5775 // Complain if the value is not representable in an int.
5776 if (!isRepresentableIntegerValue(Context, EnumVal, Context.IntTy))
5777 Diag(IdLoc, diag::ext_enum_value_not_int)
5778 << EnumVal.toString(10) << Val->getSourceRange()
5779 << (EnumVal.isUnsigned() || EnumVal.isNonNegative());
5780 else if (!Context.hasSameType(Val->getType(), Context.IntTy)) {
5781 // Force the type of the expression to 'int'.
5782 ImpCastExprToType(Val, Context.IntTy, CastExpr::CK_IntegralCast);
5784 if (Val != val.get()) {
5791 // C++0x [dcl.enum]p5:
5792 // If the underlying type is not fixed, the type of each enumerator
5793 // is the type of its initializing value:
5794 // - If an initializer is specified for an enumerator, the
5795 // initializing value has the same type as the expression.
5796 EltTy = Val->getType();
5802 if (Enum->isDependentType())
5803 EltTy = Context.DependentTy;
5804 else if (!LastEnumConst) {
5805 // C++0x [dcl.enum]p5:
5806 // If the underlying type is not fixed, the type of each enumerator
5807 // is the type of its initializing value:
5808 // - If no initializer is specified for the first enumerator, the
5809 // initializing value has an unspecified integral type.
5811 // GCC uses 'int' for its unspecified integral type, as does
5813 EltTy = Context.IntTy;
5815 // Assign the last value + 1.
5816 EnumVal = LastEnumConst->getInitVal();
5818 EltTy = LastEnumConst->getType();
5820 // Check for overflow on increment.
5821 if (EnumVal < LastEnumConst->getInitVal()) {
5822 // C++0x [dcl.enum]p5:
5823 // If the underlying type is not fixed, the type of each enumerator
5824 // is the type of its initializing value:
5826 // - Otherwise the type of the initializing value is the same as
5827 // the type of the initializing value of the preceding enumerator
5828 // unless the incremented value is not representable in that type,
5829 // in which case the type is an unspecified integral type
5830 // sufficient to contain the incremented value. If no such type
5831 // exists, the program is ill-formed.
5832 QualType T = getNextLargerIntegralType(Context, EltTy);
5834 // There is no integral type larger enough to represent this
5835 // value. Complain, then allow the value to wrap around.
5836 EnumVal = LastEnumConst->getInitVal();
5837 EnumVal.zext(EnumVal.getBitWidth() * 2);
5838 Diag(IdLoc, diag::warn_enumerator_too_large)
5839 << EnumVal.toString(10);
5844 // Retrieve the last enumerator's value, extent that type to the
5845 // type that is supposed to be large enough to represent the incremented
5846 // value, then increment.
5847 EnumVal = LastEnumConst->getInitVal();
5848 EnumVal.setIsSigned(EltTy->isSignedIntegerType());
5849 EnumVal.zextOrTrunc(Context.getTypeSize(EltTy));
5852 // If we're not in C++, diagnose the overflow of enumerator values,
5853 // which in C99 means that the enumerator value is not representable in
5854 // an int (C99 6.7.2.2p2). However, we support GCC's extension that
5855 // permits enumerator values that are representable in some larger
5857 if (!getLangOptions().CPlusPlus && !T.isNull())
5858 Diag(IdLoc, diag::warn_enum_value_overflow);
5859 } else if (!getLangOptions().CPlusPlus &&
5860 !isRepresentableIntegerValue(Context, EnumVal, EltTy)) {
5861 // Enforce C99 6.7.2.2p2 even when we compute the next value.
5862 Diag(IdLoc, diag::ext_enum_value_not_int)
5863 << EnumVal.toString(10) << 1;
5868 if (!EltTy->isDependentType()) {
5869 // Make the enumerator value match the signedness and size of the
5870 // enumerator's type.
5871 EnumVal.zextOrTrunc(Context.getTypeSize(EltTy));
5872 EnumVal.setIsSigned(EltTy->isSignedIntegerType());
5876 return EnumConstantDecl::Create(Context, Enum, IdLoc, Id, EltTy,
5881 Sema::DeclPtrTy Sema::ActOnEnumConstant(Scope *S, DeclPtrTy theEnumDecl,
5882 DeclPtrTy lastEnumConst,
5883 SourceLocation IdLoc,
5885 SourceLocation EqualLoc, ExprTy *val) {
5886 EnumDecl *TheEnumDecl = cast<EnumDecl>(theEnumDecl.getAs<Decl>());
5887 EnumConstantDecl *LastEnumConst =
5888 cast_or_null<EnumConstantDecl>(lastEnumConst.getAs<Decl>());
5889 Expr *Val = static_cast<Expr*>(val);
5891 // The scope passed in may not be a decl scope. Zip up the scope tree until
5892 // we find one that is.
5893 S = getNonFieldDeclScope(S);
5895 // Verify that there isn't already something declared with this name in this
5897 NamedDecl *PrevDecl = LookupSingleName(S, Id, LookupOrdinaryName,
5899 if (PrevDecl && PrevDecl->isTemplateParameter()) {
5900 // Maybe we will complain about the shadowed template parameter.
5901 DiagnoseTemplateParameterShadow(IdLoc, PrevDecl);
5902 // Just pretend that we didn't see the previous declaration.
5907 // When in C++, we may get a TagDecl with the same name; in this case the
5908 // enum constant will 'hide' the tag.
5909 assert((getLangOptions().CPlusPlus || !isa<TagDecl>(PrevDecl)) &&
5910 "Received TagDecl when not in C++!");
5911 if (!isa<TagDecl>(PrevDecl) && isDeclInScope(PrevDecl, CurContext, S)) {
5912 if (isa<EnumConstantDecl>(PrevDecl))
5913 Diag(IdLoc, diag::err_redefinition_of_enumerator) << Id;
5915 Diag(IdLoc, diag::err_redefinition) << Id;
5916 Diag(PrevDecl->getLocation(), diag::note_previous_definition);
5917 if (Val) Val->Destroy(Context);
5922 EnumConstantDecl *New = CheckEnumConstant(TheEnumDecl, LastEnumConst,
5923 IdLoc, Id, Owned(Val));
5925 // Register this decl in the current scope stack.
5927 New->setAccess(TheEnumDecl->getAccess());
5928 PushOnScopeChains(New, S);
5931 return DeclPtrTy::make(New);
5934 void Sema::ActOnEnumBody(SourceLocation EnumLoc, SourceLocation LBraceLoc,
5935 SourceLocation RBraceLoc, DeclPtrTy EnumDeclX,
5936 DeclPtrTy *Elements, unsigned NumElements,
5937 Scope *S, AttributeList *Attr) {
5938 EnumDecl *Enum = cast<EnumDecl>(EnumDeclX.getAs<Decl>());
5939 QualType EnumType = Context.getTypeDeclType(Enum);
5942 ProcessDeclAttributeList(S, Enum, Attr);
5944 if (Enum->isDependentType()) {
5945 for (unsigned i = 0; i != NumElements; ++i) {
5946 EnumConstantDecl *ECD =
5947 cast_or_null<EnumConstantDecl>(Elements[i].getAs<Decl>());
5950 ECD->setType(EnumType);
5953 Enum->completeDefinition(Context.DependentTy, Context.DependentTy);
5957 // TODO: If the result value doesn't fit in an int, it must be a long or long
5958 // long value. ISO C does not support this, but GCC does as an extension,
5960 unsigned IntWidth = Context.Target.getIntWidth();
5961 unsigned CharWidth = Context.Target.getCharWidth();
5962 unsigned ShortWidth = Context.Target.getShortWidth();
5964 // Verify that all the values are okay, compute the size of the values, and
5965 // reverse the list.
5966 unsigned NumNegativeBits = 0;
5967 unsigned NumPositiveBits = 0;
5969 // Keep track of whether all elements have type int.
5970 bool AllElementsInt = true;
5972 for (unsigned i = 0; i != NumElements; ++i) {
5973 EnumConstantDecl *ECD =
5974 cast_or_null<EnumConstantDecl>(Elements[i].getAs<Decl>());
5975 if (!ECD) continue; // Already issued a diagnostic.
5977 const llvm::APSInt &InitVal = ECD->getInitVal();
5979 // Keep track of the size of positive and negative values.
5980 if (InitVal.isUnsigned() || InitVal.isNonNegative())
5981 NumPositiveBits = std::max(NumPositiveBits,
5982 (unsigned)InitVal.getActiveBits());
5984 NumNegativeBits = std::max(NumNegativeBits,
5985 (unsigned)InitVal.getMinSignedBits());
5987 // Keep track of whether every enum element has type int (very commmon).
5989 AllElementsInt = ECD->getType() == Context.IntTy;
5992 // Figure out the type that should be used for this enum.
5993 // FIXME: Support -fshort-enums.
5997 // C++0x N3000 [conv.prom]p3:
5998 // An rvalue of an unscoped enumeration type whose underlying
5999 // type is not fixed can be converted to an rvalue of the first
6000 // of the following types that can represent all the values of
6001 // the enumeration: int, unsigned int, long int, unsigned long
6002 // int, long long int, or unsigned long long int.
6004 // An identifier declared as an enumeration constant has type int.
6005 // The C99 rule is modified by a gcc extension
6006 QualType BestPromotionType;
6008 bool Packed = Enum->getAttr<PackedAttr>() ? true : false;
6010 if (NumNegativeBits) {
6011 // If there is a negative value, figure out the smallest integer type (of
6012 // int/long/longlong) that fits.
6013 // If it's packed, check also if it fits a char or a short.
6014 if (Packed && NumNegativeBits <= CharWidth && NumPositiveBits < CharWidth) {
6015 BestType = Context.SignedCharTy;
6016 BestWidth = CharWidth;
6017 } else if (Packed && NumNegativeBits <= ShortWidth &&
6018 NumPositiveBits < ShortWidth) {
6019 BestType = Context.ShortTy;
6020 BestWidth = ShortWidth;
6021 } else if (NumNegativeBits <= IntWidth && NumPositiveBits < IntWidth) {
6022 BestType = Context.IntTy;
6023 BestWidth = IntWidth;
6025 BestWidth = Context.Target.getLongWidth();
6027 if (NumNegativeBits <= BestWidth && NumPositiveBits < BestWidth) {
6028 BestType = Context.LongTy;
6030 BestWidth = Context.Target.getLongLongWidth();
6032 if (NumNegativeBits > BestWidth || NumPositiveBits >= BestWidth)
6033 Diag(Enum->getLocation(), diag::warn_enum_too_large);
6034 BestType = Context.LongLongTy;
6037 BestPromotionType = (BestWidth <= IntWidth ? Context.IntTy : BestType);
6039 // If there is no negative value, figure out the smallest type that fits
6040 // all of the enumerator values.
6041 // If it's packed, check also if it fits a char or a short.
6042 if (Packed && NumPositiveBits <= CharWidth) {
6043 BestType = Context.UnsignedCharTy;
6044 BestPromotionType = Context.IntTy;
6045 BestWidth = CharWidth;
6046 } else if (Packed && NumPositiveBits <= ShortWidth) {
6047 BestType = Context.UnsignedShortTy;
6048 BestPromotionType = Context.IntTy;
6049 BestWidth = ShortWidth;
6050 } else if (NumPositiveBits <= IntWidth) {
6051 BestType = Context.UnsignedIntTy;
6052 BestWidth = IntWidth;
6054 = (NumPositiveBits == BestWidth || !getLangOptions().CPlusPlus)
6055 ? Context.UnsignedIntTy : Context.IntTy;
6056 } else if (NumPositiveBits <=
6057 (BestWidth = Context.Target.getLongWidth())) {
6058 BestType = Context.UnsignedLongTy;
6060 = (NumPositiveBits == BestWidth || !getLangOptions().CPlusPlus)
6061 ? Context.UnsignedLongTy : Context.LongTy;
6063 BestWidth = Context.Target.getLongLongWidth();
6064 assert(NumPositiveBits <= BestWidth &&
6065 "How could an initializer get larger than ULL?");
6066 BestType = Context.UnsignedLongLongTy;
6068 = (NumPositiveBits == BestWidth || !getLangOptions().CPlusPlus)
6069 ? Context.UnsignedLongLongTy : Context.LongLongTy;
6073 // Loop over all of the enumerator constants, changing their types to match
6074 // the type of the enum if needed.
6075 for (unsigned i = 0; i != NumElements; ++i) {
6076 EnumConstantDecl *ECD =
6077 cast_or_null<EnumConstantDecl>(Elements[i].getAs<Decl>());
6078 if (!ECD) continue; // Already issued a diagnostic.
6080 // Standard C says the enumerators have int type, but we allow, as an
6081 // extension, the enumerators to be larger than int size. If each
6082 // enumerator value fits in an int, type it as an int, otherwise type it the
6083 // same as the enumerator decl itself. This means that in "enum { X = 1U }"
6084 // that X has type 'int', not 'unsigned'.
6086 // Determine whether the value fits into an int.
6087 llvm::APSInt InitVal = ECD->getInitVal();
6089 // If it fits into an integer type, force it. Otherwise force it to match
6090 // the enum decl type.
6094 if (!getLangOptions().CPlusPlus &&
6095 isRepresentableIntegerValue(Context, InitVal, Context.IntTy)) {
6096 NewTy = Context.IntTy;
6097 NewWidth = IntWidth;
6099 } else if (ECD->getType() == BestType) {
6100 // Already the right type!
6101 if (getLangOptions().CPlusPlus)
6102 // C++ [dcl.enum]p4: Following the closing brace of an
6103 // enum-specifier, each enumerator has the type of its
6105 ECD->setType(EnumType);
6109 NewWidth = BestWidth;
6110 NewSign = BestType->isSignedIntegerType();
6113 // Adjust the APSInt value.
6114 InitVal.extOrTrunc(NewWidth);
6115 InitVal.setIsSigned(NewSign);
6116 ECD->setInitVal(InitVal);
6118 // Adjust the Expr initializer and type.
6119 if (ECD->getInitExpr())
6120 ECD->setInitExpr(new (Context) ImplicitCastExpr(NewTy,
6121 CastExpr::CK_IntegralCast,
6123 /*isLvalue=*/false));
6124 if (getLangOptions().CPlusPlus)
6125 // C++ [dcl.enum]p4: Following the closing brace of an
6126 // enum-specifier, each enumerator has the type of its
6128 ECD->setType(EnumType);
6130 ECD->setType(NewTy);
6133 Enum->completeDefinition(BestType, BestPromotionType);
6136 Sema::DeclPtrTy Sema::ActOnFileScopeAsmDecl(SourceLocation Loc,
6138 StringLiteral *AsmString = cast<StringLiteral>(expr.takeAs<Expr>());
6140 FileScopeAsmDecl *New = FileScopeAsmDecl::Create(Context, CurContext,
6142 CurContext->addDecl(New);
6143 return DeclPtrTy::make(New);
6146 void Sema::ActOnPragmaWeakID(IdentifierInfo* Name,
6147 SourceLocation PragmaLoc,
6148 SourceLocation NameLoc) {
6149 Decl *PrevDecl = LookupSingleName(TUScope, Name, LookupOrdinaryName);
6152 PrevDecl->addAttr(::new (Context) WeakAttr());
6154 (void)WeakUndeclaredIdentifiers.insert(
6155 std::pair<IdentifierInfo*,WeakInfo>
6156 (Name, WeakInfo((IdentifierInfo*)0, NameLoc)));
6160 void Sema::ActOnPragmaWeakAlias(IdentifierInfo* Name,
6161 IdentifierInfo* AliasName,
6162 SourceLocation PragmaLoc,
6163 SourceLocation NameLoc,
6164 SourceLocation AliasNameLoc) {
6165 Decl *PrevDecl = LookupSingleName(TUScope, AliasName, LookupOrdinaryName);
6166 WeakInfo W = WeakInfo(Name, NameLoc);
6169 if (!PrevDecl->hasAttr<AliasAttr>())
6170 if (NamedDecl *ND = dyn_cast<NamedDecl>(PrevDecl))
6171 DeclApplyPragmaWeak(TUScope, ND, W);
6173 (void)WeakUndeclaredIdentifiers.insert(
6174 std::pair<IdentifierInfo*,WeakInfo>(AliasName, W));