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 //===----------------------------------------------------------------------===//
15 #include "clang/AST/APValue.h"
16 #include "clang/AST/ASTConsumer.h"
17 #include "clang/AST/ASTContext.h"
18 #include "clang/Analysis/CFG.h"
19 #include "clang/AST/CXXInheritance.h"
20 #include "clang/AST/DeclObjC.h"
21 #include "clang/AST/DeclTemplate.h"
22 #include "clang/AST/ExprCXX.h"
23 #include "clang/AST/StmtCXX.h"
24 #include "clang/AST/StmtObjC.h"
25 #include "clang/Parse/DeclSpec.h"
26 #include "clang/Parse/ParseDiagnostic.h"
27 #include "clang/Basic/PartialDiagnostic.h"
28 #include "clang/Basic/SourceManager.h"
29 #include "clang/Basic/TargetInfo.h"
30 // FIXME: layering (ideally, Sema shouldn't be dependent on Lex API's)
31 #include "clang/Lex/Preprocessor.h"
32 #include "clang/Lex/HeaderSearch.h"
33 #include "llvm/ADT/BitVector.h"
34 #include "llvm/ADT/STLExtras.h"
39 using namespace clang;
41 /// getDeclName - Return a pretty name for the specified decl if possible, or
42 /// an empty string if not. This is used for pretty crash reporting.
43 std::string Sema::getDeclName(DeclPtrTy d) {
44 Decl *D = d.getAs<Decl>();
45 if (NamedDecl *DN = dyn_cast_or_null<NamedDecl>(D))
46 return DN->getQualifiedNameAsString();
50 Sema::DeclGroupPtrTy Sema::ConvertDeclToDeclGroup(DeclPtrTy Ptr) {
51 return DeclGroupPtrTy::make(DeclGroupRef(Ptr.getAs<Decl>()));
54 /// \brief If the identifier refers to a type name within this scope,
55 /// return the declaration of that type.
57 /// This routine performs ordinary name lookup of the identifier II
58 /// within the given scope, with optional C++ scope specifier SS, to
59 /// determine whether the name refers to a type. If so, returns an
60 /// opaque pointer (actually a QualType) corresponding to that
61 /// type. Otherwise, returns NULL.
63 /// If name lookup results in an ambiguity, this routine will complain
64 /// and then return NULL.
65 Sema::TypeTy *Sema::getTypeName(IdentifierInfo &II, SourceLocation NameLoc,
66 Scope *S, const CXXScopeSpec *SS,
69 // A qualified-id that refers to a type and in which the
70 // nested-name-specifier depends on a template-parameter (14.6.2)
71 // shall be prefixed by the keyword typename to indicate that the
72 // qualified-id denotes a type, forming an
73 // elaborated-type-specifier (7.1.5.3).
75 // We therefore do not perform any name lookup if the result would
76 // refer to a member of an unknown specialization.
77 if (SS && isUnknownSpecialization(*SS)) {
81 // We know from the grammar that this name refers to a type, so build a
82 // TypenameType node to describe the type.
83 // FIXME: Record somewhere that this TypenameType node has no "typename"
84 // keyword associated with it.
85 return CheckTypenameType((NestedNameSpecifier *)SS->getScopeRep(),
86 II, SS->getRange()).getAsOpaquePtr();
90 LookupParsedName(Result, S, SS, &II, LookupOrdinaryName, false, false);
92 NamedDecl *IIDecl = 0;
93 switch (Result.getKind()) {
94 case LookupResult::NotFound:
95 case LookupResult::FoundOverloaded:
98 case LookupResult::Ambiguous:
99 // Recover from type-hiding ambiguities by hiding the type. We'll
100 // do the lookup again when looking for an object, and we can
101 // diagnose the error then. If we don't do this, then the error
102 // about hiding the type will be immediately followed by an error
103 // that only makes sense if the identifier was treated like a type.
104 if (Result.getAmbiguityKind() == LookupResult::AmbiguousTagHiding)
107 // Look to see if we have a type anywhere in the list of results.
108 for (LookupResult::iterator Res = Result.begin(), ResEnd = Result.end();
109 Res != ResEnd; ++Res) {
110 if (isa<TypeDecl>(*Res) || isa<ObjCInterfaceDecl>(*Res)) {
112 (*Res)->getLocation().getRawEncoding() <
113 IIDecl->getLocation().getRawEncoding())
119 // None of the entities we found is a type, so there is no way
120 // to even assume that the result is a type. In this case, don't
121 // complain about the ambiguity. The parser will either try to
122 // perform this lookup again (e.g., as an object name), which
123 // will produce the ambiguity, or will complain that it expected
128 // We found a type within the ambiguous lookup; diagnose the
129 // ambiguity and then return that type. This might be the right
130 // answer, or it might not be, but it suppresses any attempt to
131 // perform the name lookup again.
132 DiagnoseAmbiguousLookup(Result, DeclarationName(&II), NameLoc);
135 case LookupResult::Found:
136 IIDecl = Result.getFoundDecl();
140 assert(IIDecl && "Didn't find decl");
143 if (TypeDecl *TD = dyn_cast<TypeDecl>(IIDecl)) {
144 DiagnoseUseOfDecl(IIDecl, NameLoc);
146 // C++ [temp.local]p2:
147 // Within the scope of a class template specialization or
148 // partial specialization, when the injected-class-name is
149 // not followed by a <, it is equivalent to the
150 // injected-class-name followed by the template-argument s
151 // of the class template specialization or partial
152 // specialization enclosed in <>.
153 if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(TD))
154 if (RD->isInjectedClassName())
155 if (ClassTemplateDecl *Template = RD->getDescribedClassTemplate())
156 T = Template->getInjectedClassNameType(Context);
159 T = Context.getTypeDeclType(TD);
162 T = getQualifiedNameType(*SS, T);
164 } else if (ObjCInterfaceDecl *IDecl = dyn_cast<ObjCInterfaceDecl>(IIDecl)) {
165 DiagnoseUseOfDecl(IIDecl, NameLoc);
166 T = Context.getObjCInterfaceType(IDecl);
170 return T.getAsOpaquePtr();
173 /// isTagName() - This method is called *for error recovery purposes only*
174 /// to determine if the specified name is a valid tag name ("struct foo"). If
175 /// so, this returns the TST for the tag corresponding to it (TST_enum,
176 /// TST_union, TST_struct, TST_class). This is used to diagnose cases in C
177 /// where the user forgot to specify the tag.
178 DeclSpec::TST Sema::isTagName(IdentifierInfo &II, Scope *S) {
179 // Do a tag name lookup in this scope.
181 LookupName(R, S, &II, LookupTagName, false, false);
182 if (R.getKind() == LookupResult::Found)
183 if (const TagDecl *TD = dyn_cast<TagDecl>(R.getAsSingleDecl(Context))) {
184 switch (TD->getTagKind()) {
185 case TagDecl::TK_struct: return DeclSpec::TST_struct;
186 case TagDecl::TK_union: return DeclSpec::TST_union;
187 case TagDecl::TK_class: return DeclSpec::TST_class;
188 case TagDecl::TK_enum: return DeclSpec::TST_enum;
192 return DeclSpec::TST_unspecified;
195 bool Sema::DiagnoseUnknownTypeName(const IdentifierInfo &II,
196 SourceLocation IILoc,
198 const CXXScopeSpec *SS,
199 TypeTy *&SuggestedType) {
200 // We don't have anything to suggest (yet).
203 // FIXME: Should we move the logic that tries to recover from a missing tag
204 // (struct, union, enum) from Parser::ParseImplicitInt here, instead?
207 Diag(IILoc, diag::err_unknown_typename) << &II;
208 else if (DeclContext *DC = computeDeclContext(*SS, false))
209 Diag(IILoc, diag::err_typename_nested_not_found)
210 << &II << DC << SS->getRange();
211 else if (isDependentScopeSpecifier(*SS)) {
212 Diag(SS->getRange().getBegin(), diag::err_typename_missing)
213 << (NestedNameSpecifier *)SS->getScopeRep() << II.getName()
214 << SourceRange(SS->getRange().getBegin(), IILoc)
215 << CodeModificationHint::CreateInsertion(SS->getRange().getBegin(),
217 SuggestedType = ActOnTypenameType(SourceLocation(), *SS, II, IILoc).get();
219 assert(SS && SS->isInvalid() &&
220 "Invalid scope specifier has already been diagnosed");
226 // Determines the context to return to after temporarily entering a
227 // context. This depends in an unnecessarily complicated way on the
228 // exact ordering of callbacks from the parser.
229 DeclContext *Sema::getContainingDC(DeclContext *DC) {
231 // Functions defined inline within classes aren't parsed until we've
232 // finished parsing the top-level class, so the top-level class is
233 // the context we'll need to return to.
234 if (isa<FunctionDecl>(DC)) {
235 DC = DC->getLexicalParent();
237 // A function not defined within a class will always return to its
239 if (!isa<CXXRecordDecl>(DC))
242 // A C++ inline method/friend is parsed *after* the topmost class
243 // it was declared in is fully parsed ("complete"); the topmost
244 // class is the context we need to return to.
245 while (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(DC->getLexicalParent()))
248 // Return the declaration context of the topmost class the inline method is
253 if (isa<ObjCMethodDecl>(DC))
254 return Context.getTranslationUnitDecl();
256 return DC->getLexicalParent();
259 void Sema::PushDeclContext(Scope *S, DeclContext *DC) {
260 assert(getContainingDC(DC) == CurContext &&
261 "The next DeclContext should be lexically contained in the current one.");
266 void Sema::PopDeclContext() {
267 assert(CurContext && "DeclContext imbalance!");
269 CurContext = getContainingDC(CurContext);
272 /// EnterDeclaratorContext - Used when we must lookup names in the context
273 /// of a declarator's nested name specifier.
274 void Sema::EnterDeclaratorContext(Scope *S, DeclContext *DC) {
275 assert(PreDeclaratorDC == 0 && "Previous declarator context not popped?");
276 PreDeclaratorDC = static_cast<DeclContext*>(S->getEntity());
278 assert(CurContext && "No context?");
279 S->setEntity(CurContext);
282 void Sema::ExitDeclaratorContext(Scope *S) {
283 S->setEntity(PreDeclaratorDC);
286 // Reset CurContext to the nearest enclosing context.
287 while (!S->getEntity() && S->getParent())
289 CurContext = static_cast<DeclContext*>(S->getEntity());
290 assert(CurContext && "No context?");
293 /// \brief Determine whether we allow overloading of the function
294 /// PrevDecl with another declaration.
296 /// This routine determines whether overloading is possible, not
297 /// whether some new function is actually an overload. It will return
298 /// true in C++ (where we can always provide overloads) or, as an
299 /// extension, in C when the previous function is already an
300 /// overloaded function declaration or has the "overloadable"
302 static bool AllowOverloadingOfFunction(Decl *PrevDecl, ASTContext &Context) {
303 if (Context.getLangOptions().CPlusPlus)
306 if (isa<OverloadedFunctionDecl>(PrevDecl))
309 return PrevDecl->getAttr<OverloadableAttr>() != 0;
312 /// Add this decl to the scope shadowed decl chains.
313 void Sema::PushOnScopeChains(NamedDecl *D, Scope *S, bool AddToContext) {
314 // Move up the scope chain until we find the nearest enclosing
315 // non-transparent context. The declaration will be introduced into this
317 while (S->getEntity() &&
318 ((DeclContext *)S->getEntity())->isTransparentContext())
321 // Add scoped declarations into their context, so that they can be
322 // found later. Declarations without a context won't be inserted
325 CurContext->addDecl(D);
327 // Out-of-line function and variable definitions should not be pushed into
329 if ((isa<FunctionTemplateDecl>(D) &&
330 cast<FunctionTemplateDecl>(D)->getTemplatedDecl()->isOutOfLine()) ||
331 (isa<FunctionDecl>(D) && cast<FunctionDecl>(D)->isOutOfLine()) ||
332 (isa<VarDecl>(D) && cast<VarDecl>(D)->isOutOfLine()))
335 // If this replaces anything in the current scope,
336 IdentifierResolver::iterator I = IdResolver.begin(D->getDeclName()),
337 IEnd = IdResolver.end();
338 for (; I != IEnd; ++I) {
339 if (S->isDeclScope(DeclPtrTy::make(*I)) && D->declarationReplaces(*I)) {
340 S->RemoveDecl(DeclPtrTy::make(*I));
341 IdResolver.RemoveDecl(*I);
343 // Should only need to replace one decl.
348 S->AddDecl(DeclPtrTy::make(D));
349 IdResolver.AddDecl(D);
352 bool Sema::isDeclInScope(NamedDecl *&D, DeclContext *Ctx, Scope *S) {
353 if (OverloadedFunctionDecl *Ovl = dyn_cast<OverloadedFunctionDecl>(D)) {
354 // Look inside the overload set to determine if any of the declarations
355 // are in scope. (Possibly) build a new overload set containing only
356 // those declarations that are in scope.
357 OverloadedFunctionDecl *NewOvl = 0;
358 bool FoundInScope = false;
359 for (OverloadedFunctionDecl::function_iterator F = Ovl->function_begin(),
360 FEnd = Ovl->function_end();
362 NamedDecl *FD = F->get();
363 if (!isDeclInScope(FD, Ctx, S)) {
364 if (!NewOvl && F != Ovl->function_begin()) {
365 NewOvl = OverloadedFunctionDecl::Create(Context,
366 F->get()->getDeclContext(),
367 F->get()->getDeclName());
369 for (OverloadedFunctionDecl::function_iterator
370 First = Ovl->function_begin();
372 NewOvl->addOverload(*First);
377 NewOvl->addOverload(*F);
384 return IdResolver.isDeclInScope(D, Ctx, Context, S);
387 void Sema::ActOnPopScope(SourceLocation Loc, Scope *S) {
388 if (S->decl_empty()) return;
389 assert((S->getFlags() & (Scope::DeclScope | Scope::TemplateParamScope)) &&
390 "Scope shouldn't contain decls!");
392 for (Scope::decl_iterator I = S->decl_begin(), E = S->decl_end();
394 Decl *TmpD = (*I).getAs<Decl>();
395 assert(TmpD && "This decl didn't get pushed??");
397 assert(isa<NamedDecl>(TmpD) && "Decl isn't NamedDecl?");
398 NamedDecl *D = cast<NamedDecl>(TmpD);
400 if (!D->getDeclName()) continue;
402 // Diagnose unused variables in this scope.
403 if (!D->isUsed() && !D->hasAttr<UnusedAttr>() && isa<VarDecl>(D) &&
404 !isa<ParmVarDecl>(D) && !isa<ImplicitParamDecl>(D) &&
405 D->getDeclContext()->isFunctionOrMethod())
406 Diag(D->getLocation(), diag::warn_unused_variable) << D->getDeclName();
408 // Remove this name from our lexical scope.
409 IdResolver.RemoveDecl(D);
413 /// getObjCInterfaceDecl - Look up a for a class declaration in the scope.
414 /// return 0 if one not found.
415 ObjCInterfaceDecl *Sema::getObjCInterfaceDecl(IdentifierInfo *Id) {
416 // The third "scope" argument is 0 since we aren't enabling lazy built-in
417 // creation from this context.
418 NamedDecl *IDecl = LookupSingleName(TUScope, Id, LookupOrdinaryName);
420 return dyn_cast_or_null<ObjCInterfaceDecl>(IDecl);
423 /// getNonFieldDeclScope - Retrieves the innermost scope, starting
424 /// from S, where a non-field would be declared. This routine copes
425 /// with the difference between C and C++ scoping rules in structs and
426 /// unions. For example, the following code is well-formed in C but
427 /// ill-formed in C++:
438 /// For the declaration of BAR, this routine will return a different
439 /// scope. The scope S will be the scope of the unnamed enumeration
440 /// within S6. In C++, this routine will return the scope associated
441 /// with S6, because the enumeration's scope is a transparent
442 /// context but structures can contain non-field names. In C, this
443 /// routine will return the translation unit scope, since the
444 /// enumeration's scope is a transparent context and structures cannot
445 /// contain non-field names.
446 Scope *Sema::getNonFieldDeclScope(Scope *S) {
447 while (((S->getFlags() & Scope::DeclScope) == 0) ||
449 ((DeclContext *)S->getEntity())->isTransparentContext()) ||
450 (S->isClassScope() && !getLangOptions().CPlusPlus))
455 void Sema::InitBuiltinVaListType() {
456 if (!Context.getBuiltinVaListType().isNull())
459 IdentifierInfo *VaIdent = &Context.Idents.get("__builtin_va_list");
460 NamedDecl *VaDecl = LookupSingleName(TUScope, VaIdent, LookupOrdinaryName);
461 TypedefDecl *VaTypedef = cast<TypedefDecl>(VaDecl);
462 Context.setBuiltinVaListType(Context.getTypedefType(VaTypedef));
465 /// LazilyCreateBuiltin - The specified Builtin-ID was first used at
466 /// file scope. lazily create a decl for it. ForRedeclaration is true
467 /// if we're creating this built-in in anticipation of redeclaring the
469 NamedDecl *Sema::LazilyCreateBuiltin(IdentifierInfo *II, unsigned bid,
470 Scope *S, bool ForRedeclaration,
471 SourceLocation Loc) {
472 Builtin::ID BID = (Builtin::ID)bid;
474 if (Context.BuiltinInfo.hasVAListUse(BID))
475 InitBuiltinVaListType();
477 ASTContext::GetBuiltinTypeError Error;
478 QualType R = Context.GetBuiltinType(BID, Error);
480 case ASTContext::GE_None:
484 case ASTContext::GE_Missing_stdio:
485 if (ForRedeclaration)
486 Diag(Loc, diag::err_implicit_decl_requires_stdio)
487 << Context.BuiltinInfo.GetName(BID);
490 case ASTContext::GE_Missing_setjmp:
491 if (ForRedeclaration)
492 Diag(Loc, diag::err_implicit_decl_requires_setjmp)
493 << Context.BuiltinInfo.GetName(BID);
497 if (!ForRedeclaration && Context.BuiltinInfo.isPredefinedLibFunction(BID)) {
498 Diag(Loc, diag::ext_implicit_lib_function_decl)
499 << Context.BuiltinInfo.GetName(BID)
501 if (Context.BuiltinInfo.getHeaderName(BID) &&
502 Diags.getDiagnosticLevel(diag::ext_implicit_lib_function_decl)
503 != Diagnostic::Ignored)
504 Diag(Loc, diag::note_please_include_header)
505 << Context.BuiltinInfo.getHeaderName(BID)
506 << Context.BuiltinInfo.GetName(BID);
509 FunctionDecl *New = FunctionDecl::Create(Context,
510 Context.getTranslationUnitDecl(),
511 Loc, II, R, /*DInfo=*/0,
512 FunctionDecl::Extern, false,
513 /*hasPrototype=*/true);
516 // Create Decl objects for each parameter, adding them to the
518 if (FunctionProtoType *FT = dyn_cast<FunctionProtoType>(R)) {
519 llvm::SmallVector<ParmVarDecl*, 16> Params;
520 for (unsigned i = 0, e = FT->getNumArgs(); i != e; ++i)
521 Params.push_back(ParmVarDecl::Create(Context, New, SourceLocation(), 0,
522 FT->getArgType(i), /*DInfo=*/0,
524 New->setParams(Context, Params.data(), Params.size());
527 AddKnownFunctionAttributes(New);
529 // TUScope is the translation-unit scope to insert this function into.
530 // FIXME: This is hideous. We need to teach PushOnScopeChains to
531 // relate Scopes to DeclContexts, and probably eliminate CurContext
532 // entirely, but we're not there yet.
533 DeclContext *SavedContext = CurContext;
534 CurContext = Context.getTranslationUnitDecl();
535 PushOnScopeChains(New, TUScope);
536 CurContext = SavedContext;
540 /// MergeTypeDefDecl - We just parsed a typedef 'New' which has the
541 /// same name and scope as a previous declaration 'Old'. Figure out
542 /// how to resolve this situation, merging decls or emitting
543 /// diagnostics as appropriate. If there was an error, set New to be invalid.
545 void Sema::MergeTypeDefDecl(TypedefDecl *New, Decl *OldD) {
546 // If either decl is known invalid already, set the new one to be invalid and
547 // don't bother doing any merging checks.
548 if (New->isInvalidDecl() || OldD->isInvalidDecl())
549 return New->setInvalidDecl();
551 // Allow multiple definitions for ObjC built-in typedefs.
552 // FIXME: Verify the underlying types are equivalent!
553 if (getLangOptions().ObjC1) {
554 const IdentifierInfo *TypeID = New->getIdentifier();
555 switch (TypeID->getLength()) {
558 if (!TypeID->isStr("id"))
560 Context.ObjCIdRedefinitionType = New->getUnderlyingType();
561 // Install the built-in type for 'id', ignoring the current definition.
562 New->setTypeForDecl(Context.getObjCIdType().getTypePtr());
565 if (!TypeID->isStr("Class"))
567 Context.ObjCClassRedefinitionType = New->getUnderlyingType();
568 // Install the built-in type for 'Class', ignoring the current definition.
569 New->setTypeForDecl(Context.getObjCClassType().getTypePtr());
572 if (!TypeID->isStr("SEL"))
574 Context.setObjCSelType(Context.getTypeDeclType(New));
577 if (!TypeID->isStr("Protocol"))
579 Context.setObjCProtoType(New->getUnderlyingType());
582 // Fall through - the typedef name was not a builtin type.
584 // Verify the old decl was also a type.
585 TypeDecl *Old = dyn_cast<TypeDecl>(OldD);
587 Diag(New->getLocation(), diag::err_redefinition_different_kind)
588 << New->getDeclName();
589 if (OldD->getLocation().isValid())
590 Diag(OldD->getLocation(), diag::note_previous_definition);
591 return New->setInvalidDecl();
594 // Determine the "old" type we'll use for checking and diagnostics.
596 if (TypedefDecl *OldTypedef = dyn_cast<TypedefDecl>(Old))
597 OldType = OldTypedef->getUnderlyingType();
599 OldType = Context.getTypeDeclType(Old);
601 // If the typedef types are not identical, reject them in all languages and
602 // with any extensions enabled.
604 if (OldType != New->getUnderlyingType() &&
605 Context.getCanonicalType(OldType) !=
606 Context.getCanonicalType(New->getUnderlyingType())) {
607 Diag(New->getLocation(), diag::err_redefinition_different_typedef)
608 << New->getUnderlyingType() << OldType;
609 if (Old->getLocation().isValid())
610 Diag(Old->getLocation(), diag::note_previous_definition);
611 return New->setInvalidDecl();
614 if (getLangOptions().Microsoft)
617 // C++ [dcl.typedef]p2:
618 // In a given non-class scope, a typedef specifier can be used to
619 // redefine the name of any type declared in that scope to refer
620 // to the type to which it already refers.
621 if (getLangOptions().CPlusPlus) {
622 if (!isa<CXXRecordDecl>(CurContext))
624 Diag(New->getLocation(), diag::err_redefinition)
625 << New->getDeclName();
626 Diag(Old->getLocation(), diag::note_previous_definition);
627 return New->setInvalidDecl();
630 // If we have a redefinition of a typedef in C, emit a warning. This warning
631 // is normally mapped to an error, but can be controlled with
632 // -Wtypedef-redefinition. If either the original or the redefinition is
633 // in a system header, don't emit this for compatibility with GCC.
634 if (PP.getDiagnostics().getSuppressSystemWarnings() &&
635 (Context.getSourceManager().isInSystemHeader(Old->getLocation()) ||
636 Context.getSourceManager().isInSystemHeader(New->getLocation())))
639 Diag(New->getLocation(), diag::warn_redefinition_of_typedef)
640 << New->getDeclName();
641 Diag(Old->getLocation(), diag::note_previous_definition);
645 /// DeclhasAttr - returns true if decl Declaration already has the target
648 DeclHasAttr(const Decl *decl, const Attr *target) {
649 for (const Attr *attr = decl->getAttrs(); attr; attr = attr->getNext())
650 if (attr->getKind() == target->getKind())
656 /// MergeAttributes - append attributes from the Old decl to the New one.
657 static void MergeAttributes(Decl *New, Decl *Old, ASTContext &C) {
658 for (const Attr *attr = Old->getAttrs(); attr; attr = attr->getNext()) {
659 if (!DeclHasAttr(New, attr) && attr->isMerged()) {
660 Attr *NewAttr = attr->clone(C);
661 NewAttr->setInherited(true);
662 New->addAttr(NewAttr);
667 /// Used in MergeFunctionDecl to keep track of function parameters in
669 struct GNUCompatibleParamWarning {
670 ParmVarDecl *OldParm;
671 ParmVarDecl *NewParm;
672 QualType PromotedType;
675 /// MergeFunctionDecl - We just parsed a function 'New' from
676 /// declarator D which has the same name and scope as a previous
677 /// declaration 'Old'. Figure out how to resolve this situation,
678 /// merging decls or emitting diagnostics as appropriate.
680 /// In C++, New and Old must be declarations that are not
681 /// overloaded. Use IsOverload to determine whether New and Old are
682 /// overloaded, and to select the Old declaration that New should be
685 /// Returns true if there was an error, false otherwise.
686 bool Sema::MergeFunctionDecl(FunctionDecl *New, Decl *OldD) {
687 assert(!isa<OverloadedFunctionDecl>(OldD) &&
688 "Cannot merge with an overloaded function declaration");
690 // Verify the old decl was also a function.
691 FunctionDecl *Old = 0;
692 if (FunctionTemplateDecl *OldFunctionTemplate
693 = dyn_cast<FunctionTemplateDecl>(OldD))
694 Old = OldFunctionTemplate->getTemplatedDecl();
696 Old = dyn_cast<FunctionDecl>(OldD);
698 Diag(New->getLocation(), diag::err_redefinition_different_kind)
699 << New->getDeclName();
700 Diag(OldD->getLocation(), diag::note_previous_definition);
704 // Determine whether the previous declaration was a definition,
705 // implicit declaration, or a declaration.
707 if (Old->isThisDeclarationADefinition())
708 PrevDiag = diag::note_previous_definition;
709 else if (Old->isImplicit())
710 PrevDiag = diag::note_previous_implicit_declaration;
712 PrevDiag = diag::note_previous_declaration;
714 QualType OldQType = Context.getCanonicalType(Old->getType());
715 QualType NewQType = Context.getCanonicalType(New->getType());
717 if (!isa<CXXMethodDecl>(New) && !isa<CXXMethodDecl>(Old) &&
718 New->getStorageClass() == FunctionDecl::Static &&
719 Old->getStorageClass() != FunctionDecl::Static) {
720 Diag(New->getLocation(), diag::err_static_non_static)
722 Diag(Old->getLocation(), PrevDiag);
726 if (getLangOptions().CPlusPlus) {
728 // Certain function declarations cannot be overloaded:
729 // -- Function declarations that differ only in the return type
730 // cannot be overloaded.
731 QualType OldReturnType
732 = cast<FunctionType>(OldQType.getTypePtr())->getResultType();
733 QualType NewReturnType
734 = cast<FunctionType>(NewQType.getTypePtr())->getResultType();
735 if (OldReturnType != NewReturnType) {
736 Diag(New->getLocation(), diag::err_ovl_diff_return_type);
737 Diag(Old->getLocation(), PrevDiag) << Old << Old->getType();
741 const CXXMethodDecl* OldMethod = dyn_cast<CXXMethodDecl>(Old);
742 const CXXMethodDecl* NewMethod = dyn_cast<CXXMethodDecl>(New);
743 if (OldMethod && NewMethod && !NewMethod->getFriendObjectKind() &&
744 NewMethod->getLexicalDeclContext()->isRecord()) {
745 // -- Member function declarations with the same name and the
746 // same parameter types cannot be overloaded if any of them
747 // is a static member function declaration.
748 if (OldMethod->isStatic() || NewMethod->isStatic()) {
749 Diag(New->getLocation(), diag::err_ovl_static_nonstatic_member);
750 Diag(Old->getLocation(), PrevDiag) << Old << Old->getType();
754 // C++ [class.mem]p1:
755 // [...] A member shall not be declared twice in the
756 // member-specification, except that a nested class or member
757 // class template can be declared and then later defined.
759 if (isa<CXXConstructorDecl>(OldMethod))
760 NewDiag = diag::err_constructor_redeclared;
761 else if (isa<CXXDestructorDecl>(NewMethod))
762 NewDiag = diag::err_destructor_redeclared;
763 else if (isa<CXXConversionDecl>(NewMethod))
764 NewDiag = diag::err_conv_function_redeclared;
766 NewDiag = diag::err_member_redeclared;
768 Diag(New->getLocation(), NewDiag);
769 Diag(Old->getLocation(), PrevDiag) << Old << Old->getType();
773 // All declarations for a function shall agree exactly in both the
774 // return type and the parameter-type-list.
775 if (OldQType == NewQType)
776 return MergeCompatibleFunctionDecls(New, Old);
778 // Fall through for conflicting redeclarations and redefinitions.
781 // C: Function types need to be compatible, not identical. This handles
782 // duplicate function decls like "void f(int); void f(enum X);" properly.
783 if (!getLangOptions().CPlusPlus &&
784 Context.typesAreCompatible(OldQType, NewQType)) {
785 const FunctionType *OldFuncType = OldQType->getAs<FunctionType>();
786 const FunctionType *NewFuncType = NewQType->getAs<FunctionType>();
787 const FunctionProtoType *OldProto = 0;
788 if (isa<FunctionNoProtoType>(NewFuncType) &&
789 (OldProto = dyn_cast<FunctionProtoType>(OldFuncType))) {
790 // The old declaration provided a function prototype, but the
791 // new declaration does not. Merge in the prototype.
792 assert(!OldProto->hasExceptionSpec() && "Exception spec in C");
793 llvm::SmallVector<QualType, 16> ParamTypes(OldProto->arg_type_begin(),
794 OldProto->arg_type_end());
795 NewQType = Context.getFunctionType(NewFuncType->getResultType(),
796 ParamTypes.data(), ParamTypes.size(),
797 OldProto->isVariadic(),
798 OldProto->getTypeQuals());
799 New->setType(NewQType);
800 New->setHasInheritedPrototype();
802 // Synthesize a parameter for each argument type.
803 llvm::SmallVector<ParmVarDecl*, 16> Params;
804 for (FunctionProtoType::arg_type_iterator
805 ParamType = OldProto->arg_type_begin(),
806 ParamEnd = OldProto->arg_type_end();
807 ParamType != ParamEnd; ++ParamType) {
808 ParmVarDecl *Param = ParmVarDecl::Create(Context, New,
810 *ParamType, /*DInfo=*/0,
812 Param->setImplicit();
813 Params.push_back(Param);
816 New->setParams(Context, Params.data(), Params.size());
819 return MergeCompatibleFunctionDecls(New, Old);
822 // GNU C permits a K&R definition to follow a prototype declaration
823 // if the declared types of the parameters in the K&R definition
824 // match the types in the prototype declaration, even when the
825 // promoted types of the parameters from the K&R definition differ
826 // from the types in the prototype. GCC then keeps the types from
829 // If a variadic prototype is followed by a non-variadic K&R definition,
830 // the K&R definition becomes variadic. This is sort of an edge case, but
831 // it's legal per the standard depending on how you read C99 6.7.5.3p15 and
833 if (!getLangOptions().CPlusPlus &&
834 Old->hasPrototype() && !New->hasPrototype() &&
835 New->getType()->getAs<FunctionProtoType>() &&
836 Old->getNumParams() == New->getNumParams()) {
837 llvm::SmallVector<QualType, 16> ArgTypes;
838 llvm::SmallVector<GNUCompatibleParamWarning, 16> Warnings;
839 const FunctionProtoType *OldProto
840 = Old->getType()->getAs<FunctionProtoType>();
841 const FunctionProtoType *NewProto
842 = New->getType()->getAs<FunctionProtoType>();
844 // Determine whether this is the GNU C extension.
845 QualType MergedReturn = Context.mergeTypes(OldProto->getResultType(),
846 NewProto->getResultType());
847 bool LooseCompatible = !MergedReturn.isNull();
848 for (unsigned Idx = 0, End = Old->getNumParams();
849 LooseCompatible && Idx != End; ++Idx) {
850 ParmVarDecl *OldParm = Old->getParamDecl(Idx);
851 ParmVarDecl *NewParm = New->getParamDecl(Idx);
852 if (Context.typesAreCompatible(OldParm->getType(),
853 NewProto->getArgType(Idx))) {
854 ArgTypes.push_back(NewParm->getType());
855 } else if (Context.typesAreCompatible(OldParm->getType(),
856 NewParm->getType())) {
857 GNUCompatibleParamWarning Warn
858 = { OldParm, NewParm, NewProto->getArgType(Idx) };
859 Warnings.push_back(Warn);
860 ArgTypes.push_back(NewParm->getType());
862 LooseCompatible = false;
865 if (LooseCompatible) {
866 for (unsigned Warn = 0; Warn < Warnings.size(); ++Warn) {
867 Diag(Warnings[Warn].NewParm->getLocation(),
868 diag::ext_param_promoted_not_compatible_with_prototype)
869 << Warnings[Warn].PromotedType
870 << Warnings[Warn].OldParm->getType();
871 Diag(Warnings[Warn].OldParm->getLocation(),
872 diag::note_previous_declaration);
875 New->setType(Context.getFunctionType(MergedReturn, &ArgTypes[0],
877 OldProto->isVariadic(), 0));
878 return MergeCompatibleFunctionDecls(New, Old);
881 // Fall through to diagnose conflicting types.
884 // A function that has already been declared has been redeclared or defined
885 // with a different type- show appropriate diagnostic
886 if (unsigned BuiltinID = Old->getBuiltinID()) {
887 // The user has declared a builtin function with an incompatible
889 if (Context.BuiltinInfo.isPredefinedLibFunction(BuiltinID)) {
890 // The function the user is redeclaring is a library-defined
891 // function like 'malloc' or 'printf'. Warn about the
892 // redeclaration, then pretend that we don't know about this
894 Diag(New->getLocation(), diag::warn_redecl_library_builtin) << New;
895 Diag(Old->getLocation(), diag::note_previous_builtin_declaration)
896 << Old << Old->getType();
897 New->getIdentifier()->setBuiltinID(Builtin::NotBuiltin);
898 Old->setInvalidDecl();
902 PrevDiag = diag::note_previous_builtin_declaration;
905 Diag(New->getLocation(), diag::err_conflicting_types) << New->getDeclName();
906 Diag(Old->getLocation(), PrevDiag) << Old << Old->getType();
910 /// \brief Completes the merge of two function declarations that are
911 /// known to be compatible.
913 /// This routine handles the merging of attributes and other
914 /// properties of function declarations form the old declaration to
915 /// the new declaration, once we know that New is in fact a
916 /// redeclaration of Old.
919 bool Sema::MergeCompatibleFunctionDecls(FunctionDecl *New, FunctionDecl *Old) {
920 // Merge the attributes
921 MergeAttributes(New, Old, Context);
923 // Merge the storage class.
924 if (Old->getStorageClass() != FunctionDecl::Extern &&
925 Old->getStorageClass() != FunctionDecl::None)
926 New->setStorageClass(Old->getStorageClass());
928 // Merge "pure" flag.
932 // Merge the "deleted" flag.
933 if (Old->isDeleted())
936 if (getLangOptions().CPlusPlus)
937 return MergeCXXFunctionDecl(New, Old);
942 /// MergeVarDecl - We just parsed a variable 'New' which has the same name
943 /// and scope as a previous declaration 'Old'. Figure out how to resolve this
944 /// situation, merging decls or emitting diagnostics as appropriate.
946 /// Tentative definition rules (C99 6.9.2p2) are checked by
947 /// FinalizeDeclaratorGroup. Unfortunately, we can't analyze tentative
948 /// definitions here, since the initializer hasn't been attached.
950 void Sema::MergeVarDecl(VarDecl *New, Decl *OldD) {
951 // If either decl is invalid, make sure the new one is marked invalid and
952 // don't do any other checking.
953 if (New->isInvalidDecl() || OldD->isInvalidDecl())
954 return New->setInvalidDecl();
956 // Verify the old decl was also a variable.
957 VarDecl *Old = dyn_cast<VarDecl>(OldD);
959 Diag(New->getLocation(), diag::err_redefinition_different_kind)
960 << New->getDeclName();
961 Diag(OldD->getLocation(), diag::note_previous_definition);
962 return New->setInvalidDecl();
965 MergeAttributes(New, Old, Context);
969 if (getLangOptions().CPlusPlus) {
970 if (Context.hasSameType(New->getType(), Old->getType()))
971 MergedT = New->getType();
972 // C++ [basic.types]p7:
973 // [...] The declared type of an array object might be an array of
974 // unknown size and therefore be incomplete at one point in a
975 // translation unit and complete later on; [...]
976 else if (Old->getType()->isIncompleteArrayType() &&
977 New->getType()->isArrayType()) {
978 CanQual<ArrayType> OldArray
979 = Context.getCanonicalType(Old->getType())->getAs<ArrayType>();
980 CanQual<ArrayType> NewArray
981 = Context.getCanonicalType(New->getType())->getAs<ArrayType>();
982 if (OldArray->getElementType() == NewArray->getElementType())
983 MergedT = New->getType();
986 MergedT = Context.mergeTypes(New->getType(), Old->getType());
988 if (MergedT.isNull()) {
989 Diag(New->getLocation(), diag::err_redefinition_different_type)
990 << New->getDeclName();
991 Diag(Old->getLocation(), diag::note_previous_definition);
992 return New->setInvalidDecl();
994 New->setType(MergedT);
996 // C99 6.2.2p4: Check if we have a static decl followed by a non-static.
997 if (New->getStorageClass() == VarDecl::Static &&
998 (Old->getStorageClass() == VarDecl::None || Old->hasExternalStorage())) {
999 Diag(New->getLocation(), diag::err_static_non_static) << New->getDeclName();
1000 Diag(Old->getLocation(), diag::note_previous_definition);
1001 return New->setInvalidDecl();
1004 // For an identifier declared with the storage-class specifier
1005 // extern in a scope in which a prior declaration of that
1006 // identifier is visible,23) if the prior declaration specifies
1007 // internal or external linkage, the linkage of the identifier at
1008 // the later declaration is the same as the linkage specified at
1009 // the prior declaration. If no prior declaration is visible, or
1010 // if the prior declaration specifies no linkage, then the
1011 // identifier has external linkage.
1012 if (New->hasExternalStorage() && Old->hasLinkage())
1014 else if (New->getStorageClass() != VarDecl::Static &&
1015 Old->getStorageClass() == VarDecl::Static) {
1016 Diag(New->getLocation(), diag::err_non_static_static) << New->getDeclName();
1017 Diag(Old->getLocation(), diag::note_previous_definition);
1018 return New->setInvalidDecl();
1021 // Variables with external linkage are analyzed in FinalizeDeclaratorGroup.
1023 // FIXME: The test for external storage here seems wrong? We still
1024 // need to check for mismatches.
1025 if (!New->hasExternalStorage() && !New->isFileVarDecl() &&
1026 // Don't complain about out-of-line definitions of static members.
1027 !(Old->getLexicalDeclContext()->isRecord() &&
1028 !New->getLexicalDeclContext()->isRecord())) {
1029 Diag(New->getLocation(), diag::err_redefinition) << New->getDeclName();
1030 Diag(Old->getLocation(), diag::note_previous_definition);
1031 return New->setInvalidDecl();
1034 if (New->isThreadSpecified() && !Old->isThreadSpecified()) {
1035 Diag(New->getLocation(), diag::err_thread_non_thread) << New->getDeclName();
1036 Diag(Old->getLocation(), diag::note_previous_definition);
1037 } else if (!New->isThreadSpecified() && Old->isThreadSpecified()) {
1038 Diag(New->getLocation(), diag::err_non_thread_thread) << New->getDeclName();
1039 Diag(Old->getLocation(), diag::note_previous_definition);
1042 // Keep a chain of previous declarations.
1043 New->setPreviousDeclaration(Old);
1046 /// CheckFallThrough - Check that we don't fall off the end of a
1047 /// Statement that should return a value.
1049 /// \returns AlwaysFallThrough iff we always fall off the end of the statement,
1050 /// MaybeFallThrough iff we might or might not fall off the end,
1051 /// NeverFallThroughOrReturn iff we never fall off the end of the statement or
1052 /// return. We assume NeverFallThrough iff we never fall off the end of the
1053 /// statement but we may return. We assume that functions not marked noreturn
1055 Sema::ControlFlowKind Sema::CheckFallThrough(Stmt *Root) {
1056 // FIXME: Eventually share this CFG object when we have other warnings based
1057 // of the CFG. This can be done using AnalysisContext.
1058 llvm::OwningPtr<CFG> cfg (CFG::buildCFG(Root, &Context));
1060 // FIXME: They should never return 0, fix that, delete this code.
1062 // FIXME: This should be NeverFallThrough
1063 return NeverFallThroughOrReturn;
1064 // The CFG leaves in dead things, and we don't want to dead code paths to
1065 // confuse us, so we mark all live things first.
1066 std::queue<CFGBlock*> workq;
1067 llvm::BitVector live(cfg->getNumBlockIDs());
1069 workq.push(&cfg->getEntry());
1071 while (!workq.empty()) {
1072 CFGBlock *item = workq.front();
1074 live.set(item->getBlockID());
1075 for (CFGBlock::succ_iterator I=item->succ_begin(),
1079 if ((*I) && !live[(*I)->getBlockID()]) {
1080 live.set((*I)->getBlockID());
1086 // Now we know what is live, we check the live precessors of the exit block
1087 // and look for fall through paths, being careful to ignore normal returns,
1088 // and exceptional paths.
1089 bool HasLiveReturn = false;
1090 bool HasFakeEdge = false;
1091 bool HasPlainEdge = false;
1092 for (CFGBlock::pred_iterator I=cfg->getExit().pred_begin(),
1093 E = cfg->getExit().pred_end();
1097 if (!live[B.getBlockID()])
1099 if (B.size() == 0) {
1100 // A labeled empty statement, or the entry block...
1101 HasPlainEdge = true;
1104 Stmt *S = B[B.size()-1];
1105 if (isa<ReturnStmt>(S)) {
1106 HasLiveReturn = true;
1109 if (isa<ObjCAtThrowStmt>(S)) {
1113 if (isa<CXXThrowExpr>(S)) {
1117 bool NoReturnEdge = false;
1118 if (CallExpr *C = dyn_cast<CallExpr>(S)) {
1119 Expr *CEE = C->getCallee()->IgnoreParenCasts();
1120 if (CEE->getType().getNoReturnAttr()) {
1121 NoReturnEdge = true;
1123 } else if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(CEE)) {
1124 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(DRE->getDecl())) {
1125 if (FD->hasAttr<NoReturnAttr>()) {
1126 NoReturnEdge = true;
1132 // FIXME: Add noreturn message sends.
1133 if (NoReturnEdge == false)
1134 HasPlainEdge = true;
1136 if (!HasPlainEdge) {
1138 return NeverFallThrough;
1139 return NeverFallThroughOrReturn;
1141 if (HasFakeEdge || HasLiveReturn)
1142 return MaybeFallThrough;
1143 // This says AlwaysFallThrough for calls to functions that are not marked
1144 // noreturn, that don't return. If people would like this warning to be more
1145 // accurate, such functions should be marked as noreturn.
1146 return AlwaysFallThrough;
1149 /// CheckFallThroughForFunctionDef - Check that we don't fall off the end of a
1150 /// function that should return a value. Check that we don't fall off the end
1151 /// of a noreturn function. We assume that functions and blocks not marked
1152 /// noreturn will return.
1153 void Sema::CheckFallThroughForFunctionDef(Decl *D, Stmt *Body) {
1154 // FIXME: Would be nice if we had a better way to control cascading errors,
1155 // but for now, avoid them. The problem is that when Parse sees:
1156 // int foo() { return a; }
1157 // The return is eaten and the Sema code sees just:
1159 // which this code would then warn about.
1160 if (getDiagnostics().hasErrorOccurred())
1163 bool ReturnsVoid = false;
1164 bool HasNoReturn = false;
1165 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
1166 // If the result type of the function is a dependent type, we don't know
1167 // whether it will be void or not, so don't
1168 if (FD->getResultType()->isDependentType())
1170 if (FD->getResultType()->isVoidType())
1172 if (FD->hasAttr<NoReturnAttr>())
1174 } else if (ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D)) {
1175 if (MD->getResultType()->isVoidType())
1177 if (MD->hasAttr<NoReturnAttr>())
1181 // Short circuit for compilation speed.
1182 if ((Diags.getDiagnosticLevel(diag::warn_maybe_falloff_nonvoid_function)
1183 == Diagnostic::Ignored || ReturnsVoid)
1184 && (Diags.getDiagnosticLevel(diag::warn_noreturn_function_has_return_expr)
1185 == Diagnostic::Ignored || !HasNoReturn)
1186 && (Diags.getDiagnosticLevel(diag::warn_suggest_noreturn_block)
1187 == Diagnostic::Ignored || !ReturnsVoid))
1189 // FIXME: Function try block
1190 if (CompoundStmt *Compound = dyn_cast<CompoundStmt>(Body)) {
1191 switch (CheckFallThrough(Body)) {
1192 case MaybeFallThrough:
1194 Diag(Compound->getRBracLoc(), diag::warn_falloff_noreturn_function);
1195 else if (!ReturnsVoid)
1196 Diag(Compound->getRBracLoc(),diag::warn_maybe_falloff_nonvoid_function);
1198 case AlwaysFallThrough:
1200 Diag(Compound->getRBracLoc(), diag::warn_falloff_noreturn_function);
1201 else if (!ReturnsVoid)
1202 Diag(Compound->getRBracLoc(), diag::warn_falloff_nonvoid_function);
1204 case NeverFallThroughOrReturn:
1205 if (ReturnsVoid && !HasNoReturn)
1206 Diag(Compound->getLBracLoc(), diag::warn_suggest_noreturn_function);
1208 case NeverFallThrough:
1214 /// CheckFallThroughForBlock - Check that we don't fall off the end of a block
1215 /// that should return a value. Check that we don't fall off the end of a
1216 /// noreturn block. We assume that functions and blocks not marked noreturn
1218 void Sema::CheckFallThroughForBlock(QualType BlockTy, Stmt *Body) {
1219 // FIXME: Would be nice if we had a better way to control cascading errors,
1220 // but for now, avoid them. The problem is that when Parse sees:
1221 // int foo() { return a; }
1222 // The return is eaten and the Sema code sees just:
1224 // which this code would then warn about.
1225 if (getDiagnostics().hasErrorOccurred())
1227 bool ReturnsVoid = false;
1228 bool HasNoReturn = false;
1229 if (const FunctionType *FT =BlockTy->getPointeeType()->getAs<FunctionType>()){
1230 if (FT->getResultType()->isVoidType())
1232 if (FT->getNoReturnAttr())
1236 // Short circuit for compilation speed.
1239 && (Diags.getDiagnosticLevel(diag::warn_suggest_noreturn_block)
1240 == Diagnostic::Ignored || !ReturnsVoid))
1242 // FIXME: Funtion try block
1243 if (CompoundStmt *Compound = dyn_cast<CompoundStmt>(Body)) {
1244 switch (CheckFallThrough(Body)) {
1245 case MaybeFallThrough:
1247 Diag(Compound->getRBracLoc(), diag::err_noreturn_block_has_return_expr);
1248 else if (!ReturnsVoid)
1249 Diag(Compound->getRBracLoc(), diag::err_maybe_falloff_nonvoid_block);
1251 case AlwaysFallThrough:
1253 Diag(Compound->getRBracLoc(), diag::err_noreturn_block_has_return_expr);
1254 else if (!ReturnsVoid)
1255 Diag(Compound->getRBracLoc(), diag::err_falloff_nonvoid_block);
1257 case NeverFallThroughOrReturn:
1259 Diag(Compound->getLBracLoc(), diag::warn_suggest_noreturn_block);
1261 case NeverFallThrough:
1267 /// CheckParmsForFunctionDef - Check that the parameters of the given
1268 /// function are appropriate for the definition of a function. This
1269 /// takes care of any checks that cannot be performed on the
1270 /// declaration itself, e.g., that the types of each of the function
1271 /// parameters are complete.
1272 bool Sema::CheckParmsForFunctionDef(FunctionDecl *FD) {
1273 bool HasInvalidParm = false;
1274 for (unsigned p = 0, NumParams = FD->getNumParams(); p < NumParams; ++p) {
1275 ParmVarDecl *Param = FD->getParamDecl(p);
1277 // C99 6.7.5.3p4: the parameters in a parameter type list in a
1278 // function declarator that is part of a function definition of
1279 // that function shall not have incomplete type.
1281 // This is also C++ [dcl.fct]p6.
1282 if (!Param->isInvalidDecl() &&
1283 RequireCompleteType(Param->getLocation(), Param->getType(),
1284 diag::err_typecheck_decl_incomplete_type)) {
1285 Param->setInvalidDecl();
1286 HasInvalidParm = true;
1289 // C99 6.9.1p5: If the declarator includes a parameter type list, the
1290 // declaration of each parameter shall include an identifier.
1291 if (Param->getIdentifier() == 0 &&
1292 !Param->isImplicit() &&
1293 !getLangOptions().CPlusPlus)
1294 Diag(Param->getLocation(), diag::err_parameter_name_omitted);
1297 return HasInvalidParm;
1300 /// ParsedFreeStandingDeclSpec - This method is invoked when a declspec with
1301 /// no declarator (e.g. "struct foo;") is parsed.
1302 Sema::DeclPtrTy Sema::ParsedFreeStandingDeclSpec(Scope *S, DeclSpec &DS) {
1303 // FIXME: Error on auto/register at file scope
1304 // FIXME: Error on inline/virtual/explicit
1305 // FIXME: Error on invalid restrict
1306 // FIXME: Warn on useless __thread
1307 // FIXME: Warn on useless const/volatile
1308 // FIXME: Warn on useless static/extern/typedef/private_extern/mutable
1309 // FIXME: Warn on useless attributes
1312 if (DS.getTypeSpecType() == DeclSpec::TST_class ||
1313 DS.getTypeSpecType() == DeclSpec::TST_struct ||
1314 DS.getTypeSpecType() == DeclSpec::TST_union ||
1315 DS.getTypeSpecType() == DeclSpec::TST_enum) {
1316 TagD = static_cast<Decl *>(DS.getTypeRep());
1318 if (!TagD) // We probably had an error
1321 // Note that the above type specs guarantee that the
1322 // type rep is a Decl, whereas in many of the others
1324 Tag = dyn_cast<TagDecl>(TagD);
1327 if (DS.isFriendSpecified()) {
1328 // If we're dealing with a class template decl, assume that the
1329 // template routines are handling it.
1330 if (TagD && isa<ClassTemplateDecl>(TagD))
1332 return ActOnFriendTypeDecl(S, DS, MultiTemplateParamsArg(*this, 0, 0));
1335 if (RecordDecl *Record = dyn_cast_or_null<RecordDecl>(Tag)) {
1336 // If there are attributes in the DeclSpec, apply them to the record.
1337 if (const AttributeList *AL = DS.getAttributes())
1338 ProcessDeclAttributeList(S, Record, AL);
1340 if (!Record->getDeclName() && Record->isDefinition() &&
1341 DS.getStorageClassSpec() != DeclSpec::SCS_typedef) {
1342 if (getLangOptions().CPlusPlus ||
1343 Record->getDeclContext()->isRecord())
1344 return BuildAnonymousStructOrUnion(S, DS, Record);
1346 Diag(DS.getSourceRange().getBegin(), diag::err_no_declarators)
1347 << DS.getSourceRange();
1350 // Microsoft allows unnamed struct/union fields. Don't complain
1352 // FIXME: Should we support Microsoft's extensions in this area?
1353 if (Record->getDeclName() && getLangOptions().Microsoft)
1354 return DeclPtrTy::make(Tag);
1357 if (!DS.isMissingDeclaratorOk() &&
1358 DS.getTypeSpecType() != DeclSpec::TST_error) {
1359 // Warn about typedefs of enums without names, since this is an
1360 // extension in both Microsoft an GNU.
1361 if (DS.getStorageClassSpec() == DeclSpec::SCS_typedef &&
1362 Tag && isa<EnumDecl>(Tag)) {
1363 Diag(DS.getSourceRange().getBegin(), diag::ext_typedef_without_a_name)
1364 << DS.getSourceRange();
1365 return DeclPtrTy::make(Tag);
1368 Diag(DS.getSourceRange().getBegin(), diag::err_no_declarators)
1369 << DS.getSourceRange();
1373 return DeclPtrTy::make(Tag);
1376 /// InjectAnonymousStructOrUnionMembers - Inject the members of the
1377 /// anonymous struct or union AnonRecord into the owning context Owner
1378 /// and scope S. This routine will be invoked just after we realize
1379 /// that an unnamed union or struct is actually an anonymous union or
1386 /// }; // InjectAnonymousStructOrUnionMembers called here to inject i and
1387 /// // f into the surrounding scope.x
1390 /// This routine is recursive, injecting the names of nested anonymous
1391 /// structs/unions into the owning context and scope as well.
1392 bool Sema::InjectAnonymousStructOrUnionMembers(Scope *S, DeclContext *Owner,
1393 RecordDecl *AnonRecord) {
1394 bool Invalid = false;
1395 for (RecordDecl::field_iterator F = AnonRecord->field_begin(),
1396 FEnd = AnonRecord->field_end();
1398 if ((*F)->getDeclName()) {
1400 LookupQualifiedName(R, Owner, (*F)->getDeclName(),
1401 LookupOrdinaryName, true);
1402 NamedDecl *PrevDecl = R.getAsSingleDecl(Context);
1403 if (PrevDecl && !isa<TagDecl>(PrevDecl)) {
1404 // C++ [class.union]p2:
1405 // The names of the members of an anonymous union shall be
1406 // distinct from the names of any other entity in the
1407 // scope in which the anonymous union is declared.
1409 = AnonRecord->isUnion()? diag::err_anonymous_union_member_redecl
1410 : diag::err_anonymous_struct_member_redecl;
1411 Diag((*F)->getLocation(), diagKind)
1412 << (*F)->getDeclName();
1413 Diag(PrevDecl->getLocation(), diag::note_previous_declaration);
1416 // C++ [class.union]p2:
1417 // For the purpose of name lookup, after the anonymous union
1418 // definition, the members of the anonymous union are
1419 // considered to have been defined in the scope in which the
1420 // anonymous union is declared.
1421 Owner->makeDeclVisibleInContext(*F);
1422 S->AddDecl(DeclPtrTy::make(*F));
1423 IdResolver.AddDecl(*F);
1425 } else if (const RecordType *InnerRecordType
1426 = (*F)->getType()->getAs<RecordType>()) {
1427 RecordDecl *InnerRecord = InnerRecordType->getDecl();
1428 if (InnerRecord->isAnonymousStructOrUnion())
1429 Invalid = Invalid ||
1430 InjectAnonymousStructOrUnionMembers(S, Owner, InnerRecord);
1437 /// ActOnAnonymousStructOrUnion - Handle the declaration of an
1438 /// anonymous structure or union. Anonymous unions are a C++ feature
1439 /// (C++ [class.union]) and a GNU C extension; anonymous structures
1440 /// are a GNU C and GNU C++ extension.
1441 Sema::DeclPtrTy Sema::BuildAnonymousStructOrUnion(Scope *S, DeclSpec &DS,
1442 RecordDecl *Record) {
1443 DeclContext *Owner = Record->getDeclContext();
1445 // Diagnose whether this anonymous struct/union is an extension.
1446 if (Record->isUnion() && !getLangOptions().CPlusPlus)
1447 Diag(Record->getLocation(), diag::ext_anonymous_union);
1448 else if (!Record->isUnion())
1449 Diag(Record->getLocation(), diag::ext_anonymous_struct);
1451 // C and C++ require different kinds of checks for anonymous
1453 bool Invalid = false;
1454 if (getLangOptions().CPlusPlus) {
1455 const char* PrevSpec = 0;
1457 // C++ [class.union]p3:
1458 // Anonymous unions declared in a named namespace or in the
1459 // global namespace shall be declared static.
1460 if (DS.getStorageClassSpec() != DeclSpec::SCS_static &&
1461 (isa<TranslationUnitDecl>(Owner) ||
1462 (isa<NamespaceDecl>(Owner) &&
1463 cast<NamespaceDecl>(Owner)->getDeclName()))) {
1464 Diag(Record->getLocation(), diag::err_anonymous_union_not_static);
1467 // Recover by adding 'static'.
1468 DS.SetStorageClassSpec(DeclSpec::SCS_static, SourceLocation(),
1471 // C++ [class.union]p3:
1472 // A storage class is not allowed in a declaration of an
1473 // anonymous union in a class scope.
1474 else if (DS.getStorageClassSpec() != DeclSpec::SCS_unspecified &&
1475 isa<RecordDecl>(Owner)) {
1476 Diag(DS.getStorageClassSpecLoc(),
1477 diag::err_anonymous_union_with_storage_spec);
1480 // Recover by removing the storage specifier.
1481 DS.SetStorageClassSpec(DeclSpec::SCS_unspecified, SourceLocation(),
1485 // C++ [class.union]p2:
1486 // The member-specification of an anonymous union shall only
1487 // define non-static data members. [Note: nested types and
1488 // functions cannot be declared within an anonymous union. ]
1489 for (DeclContext::decl_iterator Mem = Record->decls_begin(),
1490 MemEnd = Record->decls_end();
1491 Mem != MemEnd; ++Mem) {
1492 if (FieldDecl *FD = dyn_cast<FieldDecl>(*Mem)) {
1493 // C++ [class.union]p3:
1494 // An anonymous union shall not have private or protected
1495 // members (clause 11).
1496 if (FD->getAccess() == AS_protected || FD->getAccess() == AS_private) {
1497 Diag(FD->getLocation(), diag::err_anonymous_record_nonpublic_member)
1498 << (int)Record->isUnion() << (int)(FD->getAccess() == AS_protected);
1501 } else if ((*Mem)->isImplicit()) {
1502 // Any implicit members are fine.
1503 } else if (isa<TagDecl>(*Mem) && (*Mem)->getDeclContext() != Record) {
1504 // This is a type that showed up in an
1505 // elaborated-type-specifier inside the anonymous struct or
1506 // union, but which actually declares a type outside of the
1507 // anonymous struct or union. It's okay.
1508 } else if (RecordDecl *MemRecord = dyn_cast<RecordDecl>(*Mem)) {
1509 if (!MemRecord->isAnonymousStructOrUnion() &&
1510 MemRecord->getDeclName()) {
1511 // This is a nested type declaration.
1512 Diag(MemRecord->getLocation(), diag::err_anonymous_record_with_type)
1513 << (int)Record->isUnion();
1517 // We have something that isn't a non-static data
1518 // member. Complain about it.
1519 unsigned DK = diag::err_anonymous_record_bad_member;
1520 if (isa<TypeDecl>(*Mem))
1521 DK = diag::err_anonymous_record_with_type;
1522 else if (isa<FunctionDecl>(*Mem))
1523 DK = diag::err_anonymous_record_with_function;
1524 else if (isa<VarDecl>(*Mem))
1525 DK = diag::err_anonymous_record_with_static;
1526 Diag((*Mem)->getLocation(), DK)
1527 << (int)Record->isUnion();
1533 if (!Record->isUnion() && !Owner->isRecord()) {
1534 Diag(Record->getLocation(), diag::err_anonymous_struct_not_member)
1535 << (int)getLangOptions().CPlusPlus;
1539 // Mock up a declarator.
1540 Declarator Dc(DS, Declarator::TypeNameContext);
1541 DeclaratorInfo *DInfo = 0;
1542 GetTypeForDeclarator(Dc, S, &DInfo);
1543 assert(DInfo && "couldn't build declarator info for anonymous struct/union");
1545 // Create a declaration for this anonymous struct/union.
1546 NamedDecl *Anon = 0;
1547 if (RecordDecl *OwningClass = dyn_cast<RecordDecl>(Owner)) {
1548 Anon = FieldDecl::Create(Context, OwningClass, Record->getLocation(),
1549 /*IdentifierInfo=*/0,
1550 Context.getTypeDeclType(Record),
1552 /*BitWidth=*/0, /*Mutable=*/false);
1553 Anon->setAccess(AS_public);
1554 if (getLangOptions().CPlusPlus)
1555 FieldCollector->Add(cast<FieldDecl>(Anon));
1557 VarDecl::StorageClass SC;
1558 switch (DS.getStorageClassSpec()) {
1559 default: assert(0 && "Unknown storage class!");
1560 case DeclSpec::SCS_unspecified: SC = VarDecl::None; break;
1561 case DeclSpec::SCS_extern: SC = VarDecl::Extern; break;
1562 case DeclSpec::SCS_static: SC = VarDecl::Static; break;
1563 case DeclSpec::SCS_auto: SC = VarDecl::Auto; break;
1564 case DeclSpec::SCS_register: SC = VarDecl::Register; break;
1565 case DeclSpec::SCS_private_extern: SC = VarDecl::PrivateExtern; break;
1566 case DeclSpec::SCS_mutable:
1567 // mutable can only appear on non-static class members, so it's always
1569 Diag(Record->getLocation(), diag::err_mutable_nonmember);
1575 Anon = VarDecl::Create(Context, Owner, Record->getLocation(),
1576 /*IdentifierInfo=*/0,
1577 Context.getTypeDeclType(Record),
1581 Anon->setImplicit();
1583 // Add the anonymous struct/union object to the current
1584 // context. We'll be referencing this object when we refer to one of
1586 Owner->addDecl(Anon);
1588 // Inject the members of the anonymous struct/union into the owning
1589 // context and into the identifier resolver chain for name lookup
1591 if (InjectAnonymousStructOrUnionMembers(S, Owner, Record))
1594 // Mark this as an anonymous struct/union type. Note that we do not
1595 // do this until after we have already checked and injected the
1596 // members of this anonymous struct/union type, because otherwise
1597 // the members could be injected twice: once by DeclContext when it
1598 // builds its lookup table, and once by
1599 // InjectAnonymousStructOrUnionMembers.
1600 Record->setAnonymousStructOrUnion(true);
1603 Anon->setInvalidDecl();
1605 return DeclPtrTy::make(Anon);
1609 /// GetNameForDeclarator - Determine the full declaration name for the
1610 /// given Declarator.
1611 DeclarationName Sema::GetNameForDeclarator(Declarator &D) {
1612 return GetNameFromUnqualifiedId(D.getName());
1615 /// \brief Retrieves the canonicalized name from a parsed unqualified-id.
1616 DeclarationName Sema::GetNameFromUnqualifiedId(UnqualifiedId &Name) {
1617 switch (Name.getKind()) {
1618 case UnqualifiedId::IK_Identifier:
1619 return DeclarationName(Name.Identifier);
1621 case UnqualifiedId::IK_OperatorFunctionId:
1622 return Context.DeclarationNames.getCXXOperatorName(
1623 Name.OperatorFunctionId.Operator);
1625 case UnqualifiedId::IK_ConversionFunctionId: {
1626 QualType Ty = GetTypeFromParser(Name.ConversionFunctionId);
1628 return DeclarationName();
1630 return Context.DeclarationNames.getCXXConversionFunctionName(
1631 Context.getCanonicalType(Ty));
1634 case UnqualifiedId::IK_ConstructorName: {
1635 QualType Ty = GetTypeFromParser(Name.ConstructorName);
1637 return DeclarationName();
1639 return Context.DeclarationNames.getCXXConstructorName(
1640 Context.getCanonicalType(Ty));
1643 case UnqualifiedId::IK_DestructorName: {
1644 QualType Ty = GetTypeFromParser(Name.DestructorName);
1646 return DeclarationName();
1648 return Context.DeclarationNames.getCXXDestructorName(
1649 Context.getCanonicalType(Ty));
1652 case UnqualifiedId::IK_TemplateId: {
1654 = TemplateName::getFromVoidPointer(Name.TemplateId->Template);
1655 if (TemplateDecl *Template = TName.getAsTemplateDecl())
1656 return Template->getDeclName();
1657 if (OverloadedFunctionDecl *Ovl = TName.getAsOverloadedFunctionDecl())
1658 return Ovl->getDeclName();
1660 return DeclarationName();
1664 assert(false && "Unknown name kind");
1665 return DeclarationName();
1668 /// isNearlyMatchingFunction - Determine whether the C++ functions
1669 /// Declaration and Definition are "nearly" matching. This heuristic
1670 /// is used to improve diagnostics in the case where an out-of-line
1671 /// function definition doesn't match any declaration within
1672 /// the class or namespace.
1673 static bool isNearlyMatchingFunction(ASTContext &Context,
1674 FunctionDecl *Declaration,
1675 FunctionDecl *Definition) {
1676 if (Declaration->param_size() != Definition->param_size())
1678 for (unsigned Idx = 0; Idx < Declaration->param_size(); ++Idx) {
1679 QualType DeclParamTy = Declaration->getParamDecl(Idx)->getType();
1680 QualType DefParamTy = Definition->getParamDecl(Idx)->getType();
1682 DeclParamTy = Context.getCanonicalType(DeclParamTy.getNonReferenceType());
1683 DefParamTy = Context.getCanonicalType(DefParamTy.getNonReferenceType());
1684 if (DeclParamTy.getUnqualifiedType() != DefParamTy.getUnqualifiedType())
1692 Sema::HandleDeclarator(Scope *S, Declarator &D,
1693 MultiTemplateParamsArg TemplateParamLists,
1694 bool IsFunctionDefinition) {
1695 DeclarationName Name = GetNameForDeclarator(D);
1697 // All of these full declarators require an identifier. If it doesn't have
1698 // one, the ParsedFreeStandingDeclSpec action should be used.
1700 if (!D.isInvalidType()) // Reject this if we think it is valid.
1701 Diag(D.getDeclSpec().getSourceRange().getBegin(),
1702 diag::err_declarator_need_ident)
1703 << D.getDeclSpec().getSourceRange() << D.getSourceRange();
1707 // The scope passed in may not be a decl scope. Zip up the scope tree until
1708 // we find one that is.
1709 while ((S->getFlags() & Scope::DeclScope) == 0 ||
1710 (S->getFlags() & Scope::TemplateParamScope) != 0)
1713 // If this is an out-of-line definition of a member of a class template
1714 // or class template partial specialization, we may need to rebuild the
1715 // type specifier in the declarator. See RebuildTypeInCurrentInstantiation()
1716 // for more information.
1717 // FIXME: cope with decltype(expr) and typeof(expr) once the rebuilder can
1718 // handle expressions properly.
1719 DeclSpec &DS = const_cast<DeclSpec&>(D.getDeclSpec());
1720 if (D.getCXXScopeSpec().isSet() && !D.getCXXScopeSpec().isInvalid() &&
1721 isDependentScopeSpecifier(D.getCXXScopeSpec()) &&
1722 (DS.getTypeSpecType() == DeclSpec::TST_typename ||
1723 DS.getTypeSpecType() == DeclSpec::TST_typeofType ||
1724 DS.getTypeSpecType() == DeclSpec::TST_typeofExpr ||
1725 DS.getTypeSpecType() == DeclSpec::TST_decltype)) {
1726 if (DeclContext *DC = computeDeclContext(D.getCXXScopeSpec(), true)) {
1727 // FIXME: Preserve type source info.
1728 QualType T = GetTypeFromParser(DS.getTypeRep());
1729 EnterDeclaratorContext(S, DC);
1730 T = RebuildTypeInCurrentInstantiation(T, D.getIdentifierLoc(), Name);
1731 ExitDeclaratorContext(S);
1734 DS.UpdateTypeRep(T.getAsOpaquePtr());
1739 NamedDecl *PrevDecl;
1742 DeclaratorInfo *DInfo = 0;
1743 QualType R = GetTypeForDeclarator(D, S, &DInfo);
1745 // See if this is a redefinition of a variable in the same scope.
1746 if (D.getCXXScopeSpec().isInvalid()) {
1750 } else if (!D.getCXXScopeSpec().isSet()) {
1751 LookupNameKind NameKind = LookupOrdinaryName;
1753 // If the declaration we're planning to build will be a function
1754 // or object with linkage, then look for another declaration with
1755 // linkage (C99 6.2.2p4-5 and C++ [basic.link]p6).
1756 if (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_typedef)
1758 else if (R->isFunctionType()) {
1759 if (CurContext->isFunctionOrMethod() ||
1760 D.getDeclSpec().getStorageClassSpec() != DeclSpec::SCS_static)
1761 NameKind = LookupRedeclarationWithLinkage;
1762 } else if (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_extern)
1763 NameKind = LookupRedeclarationWithLinkage;
1764 else if (CurContext->getLookupContext()->isTranslationUnit() &&
1765 D.getDeclSpec().getStorageClassSpec() != DeclSpec::SCS_static)
1766 NameKind = LookupRedeclarationWithLinkage;
1770 LookupName(R, S, Name, NameKind, true,
1771 NameKind == LookupRedeclarationWithLinkage,
1772 D.getIdentifierLoc());
1773 PrevDecl = R.getAsSingleDecl(Context);
1774 } else { // Something like "int foo::x;"
1775 DC = computeDeclContext(D.getCXXScopeSpec(), true);
1778 // If we could not compute the declaration context, it's because the
1779 // declaration context is dependent but does not refer to a class,
1780 // class template, or class template partial specialization. Complain
1781 // and return early, to avoid the coming semantic disaster.
1782 Diag(D.getIdentifierLoc(),
1783 diag::err_template_qualified_declarator_no_match)
1784 << (NestedNameSpecifier*)D.getCXXScopeSpec().getScopeRep()
1785 << D.getCXXScopeSpec().getRange();
1789 if (!DC->isDependentContext() &&
1790 RequireCompleteDeclContext(D.getCXXScopeSpec()))
1794 LookupQualifiedName(Res, DC, Name, LookupOrdinaryName, true);
1795 PrevDecl = Res.getAsSingleDecl(Context);
1798 // Members (including explicit specializations of templates) of a named
1799 // namespace can also be defined outside that namespace by explicit
1800 // qualification of the name being defined, provided that the entity being
1801 // defined was already declared in the namespace and the definition appears
1802 // after the point of declaration in a namespace that encloses the
1803 // declarations namespace.
1805 // Note that we only check the context at this point. We don't yet
1806 // have enough information to make sure that PrevDecl is actually
1807 // the declaration we want to match. For example, given:
1814 // void X::f(int) { } // ill-formed
1816 // In this case, PrevDecl will point to the overload set
1817 // containing the two f's declared in X, but neither of them
1820 // First check whether we named the global scope.
1821 if (isa<TranslationUnitDecl>(DC)) {
1822 Diag(D.getIdentifierLoc(), diag::err_invalid_declarator_global_scope)
1823 << Name << D.getCXXScopeSpec().getRange();
1824 } else if (!CurContext->Encloses(DC)) {
1825 // The qualifying scope doesn't enclose the original declaration.
1826 // Emit diagnostic based on current scope.
1827 SourceLocation L = D.getIdentifierLoc();
1828 SourceRange R = D.getCXXScopeSpec().getRange();
1829 if (isa<FunctionDecl>(CurContext))
1830 Diag(L, diag::err_invalid_declarator_in_function) << Name << R;
1832 Diag(L, diag::err_invalid_declarator_scope)
1833 << Name << cast<NamedDecl>(DC) << R;
1838 if (PrevDecl && PrevDecl->isTemplateParameter()) {
1839 // Maybe we will complain about the shadowed template parameter.
1840 if (!D.isInvalidType())
1841 if (DiagnoseTemplateParameterShadow(D.getIdentifierLoc(), PrevDecl))
1844 // Just pretend that we didn't see the previous declaration.
1848 // In C++, the previous declaration we find might be a tag type
1849 // (class or enum). In this case, the new declaration will hide the
1850 // tag type. Note that this does does not apply if we're declaring a
1851 // typedef (C++ [dcl.typedef]p4).
1852 if (PrevDecl && PrevDecl->getIdentifierNamespace() == Decl::IDNS_Tag &&
1853 D.getDeclSpec().getStorageClassSpec() != DeclSpec::SCS_typedef)
1856 bool Redeclaration = false;
1857 if (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_typedef) {
1858 if (TemplateParamLists.size()) {
1859 Diag(D.getIdentifierLoc(), diag::err_template_typedef);
1863 New = ActOnTypedefDeclarator(S, D, DC, R, DInfo, PrevDecl, Redeclaration);
1864 } else if (R->isFunctionType()) {
1865 New = ActOnFunctionDeclarator(S, D, DC, R, DInfo, PrevDecl,
1866 move(TemplateParamLists),
1867 IsFunctionDefinition, Redeclaration);
1869 New = ActOnVariableDeclarator(S, D, DC, R, DInfo, PrevDecl,
1870 move(TemplateParamLists),
1877 // If this has an identifier and is not an invalid redeclaration or
1878 // function template specialization, add it to the scope stack.
1879 if (Name && !(Redeclaration && New->isInvalidDecl()) &&
1880 !(isa<FunctionDecl>(New) &&
1881 cast<FunctionDecl>(New)->isFunctionTemplateSpecialization()))
1882 PushOnScopeChains(New, S);
1884 return DeclPtrTy::make(New);
1887 /// TryToFixInvalidVariablyModifiedType - Helper method to turn variable array
1888 /// types into constant array types in certain situations which would otherwise
1889 /// be errors (for GCC compatibility).
1890 static QualType TryToFixInvalidVariablyModifiedType(QualType T,
1891 ASTContext &Context,
1892 bool &SizeIsNegative) {
1893 // This method tries to turn a variable array into a constant
1894 // array even when the size isn't an ICE. This is necessary
1895 // for compatibility with code that depends on gcc's buggy
1896 // constant expression folding, like struct {char x[(int)(char*)2];}
1897 SizeIsNegative = false;
1899 QualifierCollector Qs;
1900 const Type *Ty = Qs.strip(T);
1902 if (const PointerType* PTy = dyn_cast<PointerType>(Ty)) {
1903 QualType Pointee = PTy->getPointeeType();
1904 QualType FixedType =
1905 TryToFixInvalidVariablyModifiedType(Pointee, Context, SizeIsNegative);
1906 if (FixedType.isNull()) return FixedType;
1907 FixedType = Context.getPointerType(FixedType);
1908 return Qs.apply(FixedType);
1911 const VariableArrayType* VLATy = dyn_cast<VariableArrayType>(T);
1914 // FIXME: We should probably handle this case
1915 if (VLATy->getElementType()->isVariablyModifiedType())
1918 Expr::EvalResult EvalResult;
1919 if (!VLATy->getSizeExpr() ||
1920 !VLATy->getSizeExpr()->Evaluate(EvalResult, Context) ||
1921 !EvalResult.Val.isInt())
1924 llvm::APSInt &Res = EvalResult.Val.getInt();
1925 if (Res >= llvm::APSInt(Res.getBitWidth(), Res.isUnsigned())) {
1926 // TODO: preserve the size expression in declarator info
1927 return Context.getConstantArrayType(VLATy->getElementType(),
1928 Res, ArrayType::Normal, 0);
1931 SizeIsNegative = true;
1935 /// \brief Register the given locally-scoped external C declaration so
1936 /// that it can be found later for redeclarations
1938 Sema::RegisterLocallyScopedExternCDecl(NamedDecl *ND, NamedDecl *PrevDecl,
1940 assert(ND->getLexicalDeclContext()->isFunctionOrMethod() &&
1941 "Decl is not a locally-scoped decl!");
1942 // Note that we have a locally-scoped external with this name.
1943 LocallyScopedExternalDecls[ND->getDeclName()] = ND;
1948 // If there was a previous declaration of this variable, it may be
1949 // in our identifier chain. Update the identifier chain with the new
1951 if (S && IdResolver.ReplaceDecl(PrevDecl, ND)) {
1952 // The previous declaration was found on the identifer resolver
1953 // chain, so remove it from its scope.
1954 while (S && !S->isDeclScope(DeclPtrTy::make(PrevDecl)))
1958 S->RemoveDecl(DeclPtrTy::make(PrevDecl));
1962 /// \brief Diagnose function specifiers on a declaration of an identifier that
1963 /// does not identify a function.
1964 void Sema::DiagnoseFunctionSpecifiers(Declarator& D) {
1965 // FIXME: We should probably indicate the identifier in question to avoid
1966 // confusion for constructs like "inline int a(), b;"
1967 if (D.getDeclSpec().isInlineSpecified())
1968 Diag(D.getDeclSpec().getInlineSpecLoc(),
1969 diag::err_inline_non_function);
1971 if (D.getDeclSpec().isVirtualSpecified())
1972 Diag(D.getDeclSpec().getVirtualSpecLoc(),
1973 diag::err_virtual_non_function);
1975 if (D.getDeclSpec().isExplicitSpecified())
1976 Diag(D.getDeclSpec().getExplicitSpecLoc(),
1977 diag::err_explicit_non_function);
1981 Sema::ActOnTypedefDeclarator(Scope* S, Declarator& D, DeclContext* DC,
1982 QualType R, DeclaratorInfo *DInfo,
1983 NamedDecl* PrevDecl, bool &Redeclaration) {
1984 // Typedef declarators cannot be qualified (C++ [dcl.meaning]p1).
1985 if (D.getCXXScopeSpec().isSet()) {
1986 Diag(D.getIdentifierLoc(), diag::err_qualified_typedef_declarator)
1987 << D.getCXXScopeSpec().getRange();
1989 // Pretend we didn't see the scope specifier.
1993 if (getLangOptions().CPlusPlus) {
1994 // Check that there are no default arguments (C++ only).
1995 CheckExtraCXXDefaultArguments(D);
1998 DiagnoseFunctionSpecifiers(D);
2000 if (D.getDeclSpec().isThreadSpecified())
2001 Diag(D.getDeclSpec().getThreadSpecLoc(), diag::err_invalid_thread);
2003 TypedefDecl *NewTD = ParseTypedefDecl(S, D, R, DInfo);
2004 if (!NewTD) return 0;
2006 // Handle attributes prior to checking for duplicates in MergeVarDecl
2007 ProcessDeclAttributes(S, NewTD, D);
2008 // Merge the decl with the existing one if appropriate. If the decl is
2009 // in an outer scope, it isn't the same thing.
2010 if (PrevDecl && isDeclInScope(PrevDecl, DC, S)) {
2011 Redeclaration = true;
2012 MergeTypeDefDecl(NewTD, PrevDecl);
2015 // C99 6.7.7p2: If a typedef name specifies a variably modified type
2016 // then it shall have block scope.
2017 QualType T = NewTD->getUnderlyingType();
2018 if (T->isVariablyModifiedType()) {
2019 CurFunctionNeedsScopeChecking = true;
2021 if (S->getFnParent() == 0) {
2022 bool SizeIsNegative;
2024 TryToFixInvalidVariablyModifiedType(T, Context, SizeIsNegative);
2025 if (!FixedTy.isNull()) {
2026 Diag(D.getIdentifierLoc(), diag::warn_illegal_constant_array_size);
2027 NewTD->setTypeDeclaratorInfo(Context.getTrivialDeclaratorInfo(FixedTy));
2030 Diag(D.getIdentifierLoc(), diag::err_typecheck_negative_array_size);
2031 else if (T->isVariableArrayType())
2032 Diag(D.getIdentifierLoc(), diag::err_vla_decl_in_file_scope);
2034 Diag(D.getIdentifierLoc(), diag::err_vm_decl_in_file_scope);
2035 NewTD->setInvalidDecl();
2040 // If this is the C FILE type, notify the AST context.
2041 if (IdentifierInfo *II = NewTD->getIdentifier())
2042 if (!NewTD->isInvalidDecl() &&
2043 NewTD->getDeclContext()->getLookupContext()->isTranslationUnit()) {
2044 if (II->isStr("FILE"))
2045 Context.setFILEDecl(NewTD);
2046 else if (II->isStr("jmp_buf"))
2047 Context.setjmp_bufDecl(NewTD);
2048 else if (II->isStr("sigjmp_buf"))
2049 Context.setsigjmp_bufDecl(NewTD);
2055 /// \brief Determines whether the given declaration is an out-of-scope
2056 /// previous declaration.
2058 /// This routine should be invoked when name lookup has found a
2059 /// previous declaration (PrevDecl) that is not in the scope where a
2060 /// new declaration by the same name is being introduced. If the new
2061 /// declaration occurs in a local scope, previous declarations with
2062 /// linkage may still be considered previous declarations (C99
2063 /// 6.2.2p4-5, C++ [basic.link]p6).
2065 /// \param PrevDecl the previous declaration found by name
2068 /// \param DC the context in which the new declaration is being
2071 /// \returns true if PrevDecl is an out-of-scope previous declaration
2072 /// for a new delcaration with the same name.
2074 isOutOfScopePreviousDeclaration(NamedDecl *PrevDecl, DeclContext *DC,
2075 ASTContext &Context) {
2079 // FIXME: PrevDecl could be an OverloadedFunctionDecl, in which
2080 // case we need to check each of the overloaded functions.
2081 if (!PrevDecl->hasLinkage())
2084 if (Context.getLangOptions().CPlusPlus) {
2085 // C++ [basic.link]p6:
2086 // If there is a visible declaration of an entity with linkage
2087 // having the same name and type, ignoring entities declared
2088 // outside the innermost enclosing namespace scope, the block
2089 // scope declaration declares that same entity and receives the
2090 // linkage of the previous declaration.
2091 DeclContext *OuterContext = DC->getLookupContext();
2092 if (!OuterContext->isFunctionOrMethod())
2093 // This rule only applies to block-scope declarations.
2096 DeclContext *PrevOuterContext = PrevDecl->getDeclContext();
2097 if (PrevOuterContext->isRecord())
2098 // We found a member function: ignore it.
2101 // Find the innermost enclosing namespace for the new and
2102 // previous declarations.
2103 while (!OuterContext->isFileContext())
2104 OuterContext = OuterContext->getParent();
2105 while (!PrevOuterContext->isFileContext())
2106 PrevOuterContext = PrevOuterContext->getParent();
2108 // The previous declaration is in a different namespace, so it
2109 // isn't the same function.
2110 if (OuterContext->getPrimaryContext() !=
2111 PrevOuterContext->getPrimaryContext())
2121 Sema::ActOnVariableDeclarator(Scope* S, Declarator& D, DeclContext* DC,
2122 QualType R, DeclaratorInfo *DInfo,
2123 NamedDecl* PrevDecl,
2124 MultiTemplateParamsArg TemplateParamLists,
2125 bool &Redeclaration) {
2126 DeclarationName Name = GetNameForDeclarator(D);
2128 // Check that there are no default arguments (C++ only).
2129 if (getLangOptions().CPlusPlus)
2130 CheckExtraCXXDefaultArguments(D);
2133 VarDecl::StorageClass SC;
2134 switch (D.getDeclSpec().getStorageClassSpec()) {
2135 default: assert(0 && "Unknown storage class!");
2136 case DeclSpec::SCS_unspecified: SC = VarDecl::None; break;
2137 case DeclSpec::SCS_extern: SC = VarDecl::Extern; break;
2138 case DeclSpec::SCS_static: SC = VarDecl::Static; break;
2139 case DeclSpec::SCS_auto: SC = VarDecl::Auto; break;
2140 case DeclSpec::SCS_register: SC = VarDecl::Register; break;
2141 case DeclSpec::SCS_private_extern: SC = VarDecl::PrivateExtern; break;
2142 case DeclSpec::SCS_mutable:
2143 // mutable can only appear on non-static class members, so it's always
2145 Diag(D.getIdentifierLoc(), diag::err_mutable_nonmember);
2151 IdentifierInfo *II = Name.getAsIdentifierInfo();
2153 Diag(D.getIdentifierLoc(), diag::err_bad_variable_name)
2154 << Name.getAsString();
2158 DiagnoseFunctionSpecifiers(D);
2160 if (!DC->isRecord() && S->getFnParent() == 0) {
2161 // C99 6.9p2: The storage-class specifiers auto and register shall not
2162 // appear in the declaration specifiers in an external declaration.
2163 if (SC == VarDecl::Auto || SC == VarDecl::Register) {
2165 // If this is a register variable with an asm label specified, then this
2166 // is a GNU extension.
2167 if (SC == VarDecl::Register && D.getAsmLabel())
2168 Diag(D.getIdentifierLoc(), diag::err_unsupported_global_register);
2170 Diag(D.getIdentifierLoc(), diag::err_typecheck_sclass_fscope);
2174 if (DC->isRecord() && !CurContext->isRecord()) {
2175 // This is an out-of-line definition of a static data member.
2176 if (SC == VarDecl::Static) {
2177 Diag(D.getDeclSpec().getStorageClassSpecLoc(),
2178 diag::err_static_out_of_line)
2179 << CodeModificationHint::CreateRemoval(
2180 SourceRange(D.getDeclSpec().getStorageClassSpecLoc()));
2181 } else if (SC == VarDecl::None)
2182 SC = VarDecl::Static;
2184 if (SC == VarDecl::Static) {
2185 if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(DC)) {
2186 if (RD->isLocalClass())
2187 Diag(D.getIdentifierLoc(),
2188 diag::err_static_data_member_not_allowed_in_local_class)
2189 << Name << RD->getDeclName();
2193 // Match up the template parameter lists with the scope specifier, then
2194 // determine whether we have a template or a template specialization.
2195 bool isExplicitSpecialization = false;
2196 if (TemplateParameterList *TemplateParams
2197 = MatchTemplateParametersToScopeSpecifier(
2198 D.getDeclSpec().getSourceRange().getBegin(),
2199 D.getCXXScopeSpec(),
2200 (TemplateParameterList**)TemplateParamLists.get(),
2201 TemplateParamLists.size(),
2202 isExplicitSpecialization)) {
2203 if (TemplateParams->size() > 0) {
2204 // There is no such thing as a variable template.
2205 Diag(D.getIdentifierLoc(), diag::err_template_variable)
2207 << SourceRange(TemplateParams->getTemplateLoc(),
2208 TemplateParams->getRAngleLoc());
2211 // There is an extraneous 'template<>' for this variable. Complain
2212 // about it, but allow the declaration of the variable.
2213 Diag(TemplateParams->getTemplateLoc(),
2214 diag::err_template_variable_noparams)
2216 << SourceRange(TemplateParams->getTemplateLoc(),
2217 TemplateParams->getRAngleLoc());
2219 isExplicitSpecialization = true;
2223 NewVD = VarDecl::Create(Context, DC, D.getIdentifierLoc(),
2226 if (D.isInvalidType())
2227 NewVD->setInvalidDecl();
2229 if (D.getDeclSpec().isThreadSpecified()) {
2230 if (NewVD->hasLocalStorage())
2231 Diag(D.getDeclSpec().getThreadSpecLoc(), diag::err_thread_non_global);
2232 else if (!Context.Target.isTLSSupported())
2233 Diag(D.getDeclSpec().getThreadSpecLoc(), diag::err_thread_unsupported);
2235 NewVD->setThreadSpecified(true);
2238 // Set the lexical context. If the declarator has a C++ scope specifier, the
2239 // lexical context will be different from the semantic context.
2240 NewVD->setLexicalDeclContext(CurContext);
2242 // Handle attributes prior to checking for duplicates in MergeVarDecl
2243 ProcessDeclAttributes(S, NewVD, D);
2245 // Handle GNU asm-label extension (encoded as an attribute).
2246 if (Expr *E = (Expr*) D.getAsmLabel()) {
2247 // The parser guarantees this is a string.
2248 StringLiteral *SE = cast<StringLiteral>(E);
2249 NewVD->addAttr(::new (Context) AsmLabelAttr(std::string(SE->getStrData(),
2250 SE->getByteLength())));
2253 // If name lookup finds a previous declaration that is not in the
2254 // same scope as the new declaration, this may still be an
2255 // acceptable redeclaration.
2256 if (PrevDecl && !isDeclInScope(PrevDecl, DC, S) &&
2257 !(NewVD->hasLinkage() &&
2258 isOutOfScopePreviousDeclaration(PrevDecl, DC, Context)))
2261 // Merge the decl with the existing one if appropriate.
2263 if (isa<FieldDecl>(PrevDecl) && D.getCXXScopeSpec().isSet()) {
2264 // The user tried to define a non-static data member
2265 // out-of-line (C++ [dcl.meaning]p1).
2266 Diag(NewVD->getLocation(), diag::err_nonstatic_member_out_of_line)
2267 << D.getCXXScopeSpec().getRange();
2269 NewVD->setInvalidDecl();
2271 } else if (D.getCXXScopeSpec().isSet()) {
2272 // No previous declaration in the qualifying scope.
2273 Diag(D.getIdentifierLoc(), diag::err_no_member)
2274 << Name << computeDeclContext(D.getCXXScopeSpec(), true)
2275 << D.getCXXScopeSpec().getRange();
2276 NewVD->setInvalidDecl();
2279 CheckVariableDeclaration(NewVD, PrevDecl, Redeclaration);
2281 // This is an explicit specialization of a static data member. Check it.
2282 if (isExplicitSpecialization && !NewVD->isInvalidDecl() &&
2283 CheckMemberSpecialization(NewVD, PrevDecl))
2284 NewVD->setInvalidDecl();
2286 // attributes declared post-definition are currently ignored
2288 const VarDecl *Def = 0, *PrevVD = dyn_cast<VarDecl>(PrevDecl);
2289 if (PrevVD->getDefinition(Def) && D.hasAttributes()) {
2290 Diag(NewVD->getLocation(), diag::warn_attribute_precede_definition);
2291 Diag(Def->getLocation(), diag::note_previous_definition);
2295 // If this is a locally-scoped extern C variable, update the map of
2297 if (CurContext->isFunctionOrMethod() && NewVD->isExternC() &&
2298 !NewVD->isInvalidDecl())
2299 RegisterLocallyScopedExternCDecl(NewVD, PrevDecl, S);
2304 /// \brief Perform semantic checking on a newly-created variable
2307 /// This routine performs all of the type-checking required for a
2308 /// variable declaration once it has been built. It is used both to
2309 /// check variables after they have been parsed and their declarators
2310 /// have been translated into a declaration, and to check variables
2311 /// that have been instantiated from a template.
2313 /// Sets NewVD->isInvalidDecl() if an error was encountered.
2314 void Sema::CheckVariableDeclaration(VarDecl *NewVD, NamedDecl *PrevDecl,
2315 bool &Redeclaration) {
2316 // If the decl is already known invalid, don't check it.
2317 if (NewVD->isInvalidDecl())
2320 QualType T = NewVD->getType();
2322 if (T->isObjCInterfaceType()) {
2323 Diag(NewVD->getLocation(), diag::err_statically_allocated_object);
2324 return NewVD->setInvalidDecl();
2327 // The variable can not have an abstract class type.
2328 if (RequireNonAbstractType(NewVD->getLocation(), T,
2329 diag::err_abstract_type_in_decl,
2330 AbstractVariableType))
2331 return NewVD->setInvalidDecl();
2333 // Emit an error if an address space was applied to decl with local storage.
2334 // This includes arrays of objects with address space qualifiers, but not
2335 // automatic variables that point to other address spaces.
2336 // ISO/IEC TR 18037 S5.1.2
2337 if (NewVD->hasLocalStorage() && (T.getAddressSpace() != 0)) {
2338 Diag(NewVD->getLocation(), diag::err_as_qualified_auto_decl);
2339 return NewVD->setInvalidDecl();
2342 if (NewVD->hasLocalStorage() && T.isObjCGCWeak()
2343 && !NewVD->hasAttr<BlocksAttr>())
2344 Diag(NewVD->getLocation(), diag::warn_attribute_weak_on_local);
2346 bool isVM = T->isVariablyModifiedType();
2347 if (isVM || NewVD->hasAttr<CleanupAttr>() ||
2348 NewVD->hasAttr<BlocksAttr>())
2349 CurFunctionNeedsScopeChecking = true;
2351 if ((isVM && NewVD->hasLinkage()) ||
2352 (T->isVariableArrayType() && NewVD->hasGlobalStorage())) {
2353 bool SizeIsNegative;
2355 TryToFixInvalidVariablyModifiedType(T, Context, SizeIsNegative);
2357 if (FixedTy.isNull() && T->isVariableArrayType()) {
2358 const VariableArrayType *VAT = Context.getAsVariableArrayType(T);
2359 // FIXME: This won't give the correct result for
2361 SourceRange SizeRange = VAT->getSizeExpr()->getSourceRange();
2363 if (NewVD->isFileVarDecl())
2364 Diag(NewVD->getLocation(), diag::err_vla_decl_in_file_scope)
2366 else if (NewVD->getStorageClass() == VarDecl::Static)
2367 Diag(NewVD->getLocation(), diag::err_vla_decl_has_static_storage)
2370 Diag(NewVD->getLocation(), diag::err_vla_decl_has_extern_linkage)
2372 return NewVD->setInvalidDecl();
2375 if (FixedTy.isNull()) {
2376 if (NewVD->isFileVarDecl())
2377 Diag(NewVD->getLocation(), diag::err_vm_decl_in_file_scope);
2379 Diag(NewVD->getLocation(), diag::err_vm_decl_has_extern_linkage);
2380 return NewVD->setInvalidDecl();
2383 Diag(NewVD->getLocation(), diag::warn_illegal_constant_array_size);
2384 NewVD->setType(FixedTy);
2387 if (!PrevDecl && NewVD->isExternC()) {
2388 // Since we did not find anything by this name and we're declaring
2389 // an extern "C" variable, look for a non-visible extern "C"
2390 // declaration with the same name.
2391 llvm::DenseMap<DeclarationName, NamedDecl *>::iterator Pos
2392 = LocallyScopedExternalDecls.find(NewVD->getDeclName());
2393 if (Pos != LocallyScopedExternalDecls.end())
2394 PrevDecl = Pos->second;
2397 if (T->isVoidType() && !NewVD->hasExternalStorage()) {
2398 Diag(NewVD->getLocation(), diag::err_typecheck_decl_incomplete_type)
2400 return NewVD->setInvalidDecl();
2403 if (!NewVD->hasLocalStorage() && NewVD->hasAttr<BlocksAttr>()) {
2404 Diag(NewVD->getLocation(), diag::err_block_on_nonlocal);
2405 return NewVD->setInvalidDecl();
2408 if (isVM && NewVD->hasAttr<BlocksAttr>()) {
2409 Diag(NewVD->getLocation(), diag::err_block_on_vm);
2410 return NewVD->setInvalidDecl();
2414 Redeclaration = true;
2415 MergeVarDecl(NewVD, PrevDecl);
2419 static bool isUsingDecl(Decl *D) {
2420 return isa<UsingDecl>(D) || isa<UnresolvedUsingDecl>(D);
2423 /// \brief Data used with FindOverriddenMethod
2424 struct FindOverriddenMethodData {
2426 CXXMethodDecl *Method;
2429 /// \brief Member lookup function that determines whether a given C++
2430 /// method overrides a method in a base class, to be used with
2431 /// CXXRecordDecl::lookupInBases().
2432 static bool FindOverriddenMethod(CXXBaseSpecifier *Specifier,
2435 RecordDecl *BaseRecord = Specifier->getType()->getAs<RecordType>()->getDecl();
2437 FindOverriddenMethodData *Data
2438 = reinterpret_cast<FindOverriddenMethodData*>(UserData);
2439 for (Path.Decls = BaseRecord->lookup(Data->Method->getDeclName());
2440 Path.Decls.first != Path.Decls.second;
2441 ++Path.Decls.first) {
2442 if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(*Path.Decls.first)) {
2443 OverloadedFunctionDecl::function_iterator MatchedDecl;
2444 if (MD->isVirtual() && !Data->S->IsOverload(Data->Method, MD, MatchedDecl))
2453 Sema::ActOnFunctionDeclarator(Scope* S, Declarator& D, DeclContext* DC,
2454 QualType R, DeclaratorInfo *DInfo,
2455 NamedDecl* PrevDecl,
2456 MultiTemplateParamsArg TemplateParamLists,
2457 bool IsFunctionDefinition, bool &Redeclaration) {
2458 assert(R.getTypePtr()->isFunctionType());
2460 DeclarationName Name = GetNameForDeclarator(D);
2461 FunctionDecl::StorageClass SC = FunctionDecl::None;
2462 switch (D.getDeclSpec().getStorageClassSpec()) {
2463 default: assert(0 && "Unknown storage class!");
2464 case DeclSpec::SCS_auto:
2465 case DeclSpec::SCS_register:
2466 case DeclSpec::SCS_mutable:
2467 Diag(D.getDeclSpec().getStorageClassSpecLoc(),
2468 diag::err_typecheck_sclass_func);
2471 case DeclSpec::SCS_unspecified: SC = FunctionDecl::None; break;
2472 case DeclSpec::SCS_extern: SC = FunctionDecl::Extern; break;
2473 case DeclSpec::SCS_static: {
2474 if (CurContext->getLookupContext()->isFunctionOrMethod()) {
2476 // The declaration of an identifier for a function that has
2477 // block scope shall have no explicit storage-class specifier
2478 // other than extern
2479 // See also (C++ [dcl.stc]p4).
2480 Diag(D.getDeclSpec().getStorageClassSpecLoc(),
2481 diag::err_static_block_func);
2482 SC = FunctionDecl::None;
2484 SC = FunctionDecl::Static;
2487 case DeclSpec::SCS_private_extern: SC = FunctionDecl::PrivateExtern;break;
2490 if (D.getDeclSpec().isThreadSpecified())
2491 Diag(D.getDeclSpec().getThreadSpecLoc(), diag::err_invalid_thread);
2493 bool isFriend = D.getDeclSpec().isFriendSpecified();
2494 bool isInline = D.getDeclSpec().isInlineSpecified();
2495 bool isVirtual = D.getDeclSpec().isVirtualSpecified();
2496 bool isExplicit = D.getDeclSpec().isExplicitSpecified();
2498 // Check that the return type is not an abstract class type.
2499 // For record types, this is done by the AbstractClassUsageDiagnoser once
2500 // the class has been completely parsed.
2501 if (!DC->isRecord() &&
2502 RequireNonAbstractType(D.getIdentifierLoc(),
2503 R->getAs<FunctionType>()->getResultType(),
2504 diag::err_abstract_type_in_decl,
2505 AbstractReturnType))
2508 // Do not allow returning a objc interface by-value.
2509 if (R->getAs<FunctionType>()->getResultType()->isObjCInterfaceType()) {
2510 Diag(D.getIdentifierLoc(),
2511 diag::err_object_cannot_be_passed_returned_by_value) << 0
2512 << R->getAs<FunctionType>()->getResultType();
2516 bool isVirtualOkay = false;
2517 FunctionDecl *NewFD;
2520 // DC is the namespace in which the function is being declared.
2521 assert((DC->isFileContext() || PrevDecl) && "previously-undeclared "
2522 "friend function being created in a non-namespace context");
2524 // C++ [class.friend]p5
2525 // A function can be defined in a friend declaration of a
2526 // class . . . . Such a function is implicitly inline.
2527 isInline |= IsFunctionDefinition;
2530 if (Name.getNameKind() == DeclarationName::CXXConstructorName) {
2531 // This is a C++ constructor declaration.
2532 assert(DC->isRecord() &&
2533 "Constructors can only be declared in a member context");
2535 R = CheckConstructorDeclarator(D, R, SC);
2537 // Create the new declaration
2538 NewFD = CXXConstructorDecl::Create(Context,
2539 cast<CXXRecordDecl>(DC),
2540 D.getIdentifierLoc(), Name, R, DInfo,
2541 isExplicit, isInline,
2542 /*isImplicitlyDeclared=*/false);
2543 } else if (Name.getNameKind() == DeclarationName::CXXDestructorName) {
2544 // This is a C++ destructor declaration.
2545 if (DC->isRecord()) {
2546 R = CheckDestructorDeclarator(D, SC);
2548 NewFD = CXXDestructorDecl::Create(Context,
2549 cast<CXXRecordDecl>(DC),
2550 D.getIdentifierLoc(), Name, R,
2552 /*isImplicitlyDeclared=*/false);
2554 isVirtualOkay = true;
2556 Diag(D.getIdentifierLoc(), diag::err_destructor_not_member);
2558 // Create a FunctionDecl to satisfy the function definition parsing
2560 NewFD = FunctionDecl::Create(Context, DC, D.getIdentifierLoc(),
2561 Name, R, DInfo, SC, isInline,
2562 /*hasPrototype=*/true);
2565 } else if (Name.getNameKind() == DeclarationName::CXXConversionFunctionName) {
2566 if (!DC->isRecord()) {
2567 Diag(D.getIdentifierLoc(),
2568 diag::err_conv_function_not_member);
2572 CheckConversionDeclarator(D, R, SC);
2573 NewFD = CXXConversionDecl::Create(Context, cast<CXXRecordDecl>(DC),
2574 D.getIdentifierLoc(), Name, R, DInfo,
2575 isInline, isExplicit);
2577 isVirtualOkay = true;
2578 } else if (DC->isRecord()) {
2579 // If the of the function is the same as the name of the record, then this
2580 // must be an invalid constructor that has a return type.
2581 // (The parser checks for a return type and makes the declarator a
2582 // constructor if it has no return type).
2583 // must have an invalid constructor that has a return type
2584 if (Name.getAsIdentifierInfo() == cast<CXXRecordDecl>(DC)->getIdentifier()){
2585 Diag(D.getIdentifierLoc(), diag::err_constructor_return_type)
2586 << SourceRange(D.getDeclSpec().getTypeSpecTypeLoc())
2587 << SourceRange(D.getIdentifierLoc());
2591 // This is a C++ method declaration.
2592 NewFD = CXXMethodDecl::Create(Context, cast<CXXRecordDecl>(DC),
2593 D.getIdentifierLoc(), Name, R, DInfo,
2594 (SC == FunctionDecl::Static), isInline);
2596 isVirtualOkay = (SC != FunctionDecl::Static);
2598 // Determine whether the function was written with a
2599 // prototype. This true when:
2600 // - we're in C++ (where every function has a prototype),
2601 // - there is a prototype in the declarator, or
2602 // - the type R of the function is some kind of typedef or other reference
2603 // to a type name (which eventually refers to a function type).
2605 getLangOptions().CPlusPlus ||
2606 (D.getNumTypeObjects() && D.getTypeObject(0).Fun.hasPrototype) ||
2607 (!isa<FunctionType>(R.getTypePtr()) && R->isFunctionProtoType());
2609 NewFD = FunctionDecl::Create(Context, DC,
2610 D.getIdentifierLoc(),
2611 Name, R, DInfo, SC, isInline, HasPrototype);
2614 if (D.isInvalidType())
2615 NewFD->setInvalidDecl();
2617 // Set the lexical context. If the declarator has a C++
2618 // scope specifier, or is the object of a friend declaration, the
2619 // lexical context will be different from the semantic context.
2620 NewFD->setLexicalDeclContext(CurContext);
2622 // Match up the template parameter lists with the scope specifier, then
2623 // determine whether we have a template or a template specialization.
2624 FunctionTemplateDecl *FunctionTemplate = 0;
2625 bool isExplicitSpecialization = false;
2626 bool isFunctionTemplateSpecialization = false;
2627 if (TemplateParameterList *TemplateParams
2628 = MatchTemplateParametersToScopeSpecifier(
2629 D.getDeclSpec().getSourceRange().getBegin(),
2630 D.getCXXScopeSpec(),
2631 (TemplateParameterList**)TemplateParamLists.get(),
2632 TemplateParamLists.size(),
2633 isExplicitSpecialization)) {
2634 if (TemplateParams->size() > 0) {
2635 // This is a function template
2637 // Check that we can declare a template here.
2638 if (CheckTemplateDeclScope(S, TemplateParams))
2641 FunctionTemplate = FunctionTemplateDecl::Create(Context, DC,
2642 NewFD->getLocation(),
2643 Name, TemplateParams,
2645 FunctionTemplate->setLexicalDeclContext(CurContext);
2646 NewFD->setDescribedFunctionTemplate(FunctionTemplate);
2648 // This is a function template specialization.
2649 isFunctionTemplateSpecialization = true;
2652 // FIXME: Free this memory properly.
2653 TemplateParamLists.release();
2656 // C++ [dcl.fct.spec]p5:
2657 // The virtual specifier shall only be used in declarations of
2658 // nonstatic class member functions that appear within a
2659 // member-specification of a class declaration; see 10.3.
2661 if (isVirtual && !NewFD->isInvalidDecl()) {
2662 if (!isVirtualOkay) {
2663 Diag(D.getDeclSpec().getVirtualSpecLoc(),
2664 diag::err_virtual_non_function);
2665 } else if (!CurContext->isRecord()) {
2666 // 'virtual' was specified outside of the class.
2667 Diag(D.getDeclSpec().getVirtualSpecLoc(), diag::err_virtual_out_of_class)
2668 << CodeModificationHint::CreateRemoval(
2669 SourceRange(D.getDeclSpec().getVirtualSpecLoc()));
2671 // Okay: Add virtual to the method.
2672 cast<CXXMethodDecl>(NewFD)->setVirtualAsWritten(true);
2673 CXXRecordDecl *CurClass = cast<CXXRecordDecl>(DC);
2674 CurClass->setAggregate(false);
2675 CurClass->setPOD(false);
2676 CurClass->setEmpty(false);
2677 CurClass->setPolymorphic(true);
2678 CurClass->setHasTrivialConstructor(false);
2679 CurClass->setHasTrivialCopyConstructor(false);
2680 CurClass->setHasTrivialCopyAssignment(false);
2685 if (FunctionTemplate) {
2686 FunctionTemplate->setObjectOfFriendDecl(
2687 /* PreviouslyDeclared= */ PrevDecl != NULL);
2688 FunctionTemplate->setAccess(AS_public);
2691 NewFD->setObjectOfFriendDecl(/* PreviouslyDeclared= */ PrevDecl != NULL);
2693 NewFD->setAccess(AS_public);
2697 if (CXXMethodDecl *NewMD = dyn_cast<CXXMethodDecl>(NewFD)) {
2698 // Look for virtual methods in base classes that this method might override.
2700 FindOverriddenMethodData Data;
2701 Data.Method = NewMD;
2703 if (cast<CXXRecordDecl>(DC)->lookupInBases(&FindOverriddenMethod, &Data,
2705 for (CXXBasePaths::decl_iterator I = Paths.found_decls_begin(),
2706 E = Paths.found_decls_end(); I != E; ++I) {
2707 if (CXXMethodDecl *OldMD = dyn_cast<CXXMethodDecl>(*I)) {
2708 if (!CheckOverridingFunctionReturnType(NewMD, OldMD) &&
2709 !CheckOverridingFunctionExceptionSpec(NewMD, OldMD))
2710 NewMD->addOverriddenMethod(OldMD);
2716 if (SC == FunctionDecl::Static && isa<CXXMethodDecl>(NewFD) &&
2717 !CurContext->isRecord()) {
2718 // C++ [class.static]p1:
2719 // A data or function member of a class may be declared static
2720 // in a class definition, in which case it is a static member of
2723 // Complain about the 'static' specifier if it's on an out-of-line
2724 // member function definition.
2725 Diag(D.getDeclSpec().getStorageClassSpecLoc(),
2726 diag::err_static_out_of_line)
2727 << CodeModificationHint::CreateRemoval(
2728 SourceRange(D.getDeclSpec().getStorageClassSpecLoc()));
2731 // Handle GNU asm-label extension (encoded as an attribute).
2732 if (Expr *E = (Expr*) D.getAsmLabel()) {
2733 // The parser guarantees this is a string.
2734 StringLiteral *SE = cast<StringLiteral>(E);
2735 NewFD->addAttr(::new (Context) AsmLabelAttr(std::string(SE->getStrData(),
2736 SE->getByteLength())));
2739 // Copy the parameter declarations from the declarator D to the function
2740 // declaration NewFD, if they are available. First scavenge them into Params.
2741 llvm::SmallVector<ParmVarDecl*, 16> Params;
2742 if (D.getNumTypeObjects() > 0) {
2743 DeclaratorChunk::FunctionTypeInfo &FTI = D.getTypeObject(0).Fun;
2745 // Check for C99 6.7.5.3p10 - foo(void) is a non-varargs
2746 // function that takes no arguments, not a function that takes a
2747 // single void argument.
2748 // We let through "const void" here because Sema::GetTypeForDeclarator
2749 // already checks for that case.
2750 if (FTI.NumArgs == 1 && !FTI.isVariadic && FTI.ArgInfo[0].Ident == 0 &&
2751 FTI.ArgInfo[0].Param &&
2752 FTI.ArgInfo[0].Param.getAs<ParmVarDecl>()->getType()->isVoidType()) {
2753 // Empty arg list, don't push any params.
2754 ParmVarDecl *Param = FTI.ArgInfo[0].Param.getAs<ParmVarDecl>();
2756 // In C++, the empty parameter-type-list must be spelled "void"; a
2757 // typedef of void is not permitted.
2758 if (getLangOptions().CPlusPlus &&
2759 Param->getType().getUnqualifiedType() != Context.VoidTy)
2760 Diag(Param->getLocation(), diag::err_param_typedef_of_void);
2761 // FIXME: Leaks decl?
2762 } else if (FTI.NumArgs > 0 && FTI.ArgInfo[0].Param != 0) {
2763 for (unsigned i = 0, e = FTI.NumArgs; i != e; ++i) {
2764 ParmVarDecl *Param = FTI.ArgInfo[i].Param.getAs<ParmVarDecl>();
2765 assert(Param->getDeclContext() != NewFD && "Was set before ?");
2766 Param->setDeclContext(NewFD);
2767 Params.push_back(Param);
2771 } else if (const FunctionProtoType *FT = R->getAs<FunctionProtoType>()) {
2772 // When we're declaring a function with a typedef, typeof, etc as in the
2773 // following example, we'll need to synthesize (unnamed)
2774 // parameters for use in the declaration.
2777 // typedef void fn(int);
2781 // Synthesize a parameter for each argument type.
2782 for (FunctionProtoType::arg_type_iterator AI = FT->arg_type_begin(),
2783 AE = FT->arg_type_end(); AI != AE; ++AI) {
2784 ParmVarDecl *Param = ParmVarDecl::Create(Context, DC,
2785 SourceLocation(), 0,
2788 Param->setImplicit();
2789 Params.push_back(Param);
2792 assert(R->isFunctionNoProtoType() && NewFD->getNumParams() == 0 &&
2793 "Should not need args for typedef of non-prototype fn");
2795 // Finally, we know we have the right number of parameters, install them.
2796 NewFD->setParams(Context, Params.data(), Params.size());
2798 // If name lookup finds a previous declaration that is not in the
2799 // same scope as the new declaration, this may still be an
2800 // acceptable redeclaration.
2801 if (PrevDecl && !isDeclInScope(PrevDecl, DC, S) &&
2802 !(NewFD->hasLinkage() &&
2803 isOutOfScopePreviousDeclaration(PrevDecl, DC, Context)))
2806 // If the declarator is a template-id, translate the parser's template
2807 // argument list into our AST format.
2808 bool HasExplicitTemplateArgs = false;
2809 llvm::SmallVector<TemplateArgumentLoc, 16> TemplateArgs;
2810 SourceLocation LAngleLoc, RAngleLoc;
2811 if (D.getName().getKind() == UnqualifiedId::IK_TemplateId) {
2812 TemplateIdAnnotation *TemplateId = D.getName().TemplateId;
2813 ASTTemplateArgsPtr TemplateArgsPtr(*this,
2814 TemplateId->getTemplateArgs(),
2815 TemplateId->getTemplateArgIsType(),
2816 TemplateId->NumArgs);
2817 translateTemplateArguments(TemplateArgsPtr,
2818 TemplateId->getTemplateArgLocations(),
2820 TemplateArgsPtr.release();
2822 HasExplicitTemplateArgs = true;
2823 LAngleLoc = TemplateId->LAngleLoc;
2824 RAngleLoc = TemplateId->RAngleLoc;
2826 if (FunctionTemplate) {
2827 // FIXME: Diagnose function template with explicit template
2829 HasExplicitTemplateArgs = false;
2830 } else if (!isFunctionTemplateSpecialization &&
2831 !D.getDeclSpec().isFriendSpecified()) {
2832 // We have encountered something that the user meant to be a
2833 // specialization (because it has explicitly-specified template
2834 // arguments) but that was not introduced with a "template<>" (or had
2835 // too few of them).
2836 Diag(D.getIdentifierLoc(), diag::err_template_spec_needs_header)
2837 << SourceRange(TemplateId->LAngleLoc, TemplateId->RAngleLoc)
2838 << CodeModificationHint::CreateInsertion(
2839 D.getDeclSpec().getSourceRange().getBegin(),
2841 isFunctionTemplateSpecialization = true;
2845 if (isFunctionTemplateSpecialization) {
2846 if (CheckFunctionTemplateSpecialization(NewFD, HasExplicitTemplateArgs,
2847 LAngleLoc, TemplateArgs.data(),
2848 TemplateArgs.size(), RAngleLoc,
2850 NewFD->setInvalidDecl();
2851 } else if (isExplicitSpecialization && isa<CXXMethodDecl>(NewFD) &&
2852 CheckMemberSpecialization(NewFD, PrevDecl))
2853 NewFD->setInvalidDecl();
2855 // Perform semantic checking on the function declaration.
2856 bool OverloadableAttrRequired = false; // FIXME: HACK!
2857 CheckFunctionDeclaration(NewFD, PrevDecl, isExplicitSpecialization,
2858 Redeclaration, /*FIXME:*/OverloadableAttrRequired);
2860 if (D.getCXXScopeSpec().isSet() && !NewFD->isInvalidDecl()) {
2861 // An out-of-line member function declaration must also be a
2862 // definition (C++ [dcl.meaning]p1).
2863 // Note that this is not the case for explicit specializations of
2864 // function templates or member functions of class templates, per
2865 // C++ [temp.expl.spec]p2.
2866 if (!IsFunctionDefinition && !isFriend &&
2867 !isFunctionTemplateSpecialization && !isExplicitSpecialization) {
2868 Diag(NewFD->getLocation(), diag::err_out_of_line_declaration)
2869 << D.getCXXScopeSpec().getRange();
2870 NewFD->setInvalidDecl();
2871 } else if (!Redeclaration && (!PrevDecl || !isUsingDecl(PrevDecl))) {
2872 // The user tried to provide an out-of-line definition for a
2873 // function that is a member of a class or namespace, but there
2874 // was no such member function declared (C++ [class.mfct]p2,
2875 // C++ [namespace.memdef]p2). For example:
2881 // void X::f() { } // ill-formed
2883 // Complain about this problem, and attempt to suggest close
2884 // matches (e.g., those that differ only in cv-qualifiers and
2885 // whether the parameter types are references).
2886 Diag(D.getIdentifierLoc(), diag::err_member_def_does_not_match)
2887 << Name << DC << D.getCXXScopeSpec().getRange();
2888 NewFD->setInvalidDecl();
2891 LookupQualifiedName(Prev, DC, Name, LookupOrdinaryName, true);
2892 assert(!Prev.isAmbiguous() &&
2893 "Cannot have an ambiguity in previous-declaration lookup");
2894 for (LookupResult::iterator Func = Prev.begin(), FuncEnd = Prev.end();
2895 Func != FuncEnd; ++Func) {
2896 if (isa<FunctionDecl>(*Func) &&
2897 isNearlyMatchingFunction(Context, cast<FunctionDecl>(*Func), NewFD))
2898 Diag((*Func)->getLocation(), diag::note_member_def_close_match);
2905 // Handle attributes. We need to have merged decls when handling attributes
2906 // (for example to check for conflicts, etc).
2907 // FIXME: This needs to happen before we merge declarations. Then,
2908 // let attribute merging cope with attribute conflicts.
2909 ProcessDeclAttributes(S, NewFD, D);
2911 // attributes declared post-definition are currently ignored
2912 if (Redeclaration && PrevDecl) {
2913 const FunctionDecl *Def, *PrevFD = dyn_cast<FunctionDecl>(PrevDecl);
2914 if (PrevFD && PrevFD->getBody(Def) && D.hasAttributes()) {
2915 Diag(NewFD->getLocation(), diag::warn_attribute_precede_definition);
2916 Diag(Def->getLocation(), diag::note_previous_definition);
2920 AddKnownFunctionAttributes(NewFD);
2922 if (OverloadableAttrRequired && !NewFD->getAttr<OverloadableAttr>()) {
2923 // If a function name is overloadable in C, then every function
2924 // with that name must be marked "overloadable".
2925 Diag(NewFD->getLocation(), diag::err_attribute_overloadable_missing)
2926 << Redeclaration << NewFD;
2928 Diag(PrevDecl->getLocation(),
2929 diag::note_attribute_overloadable_prev_overload);
2930 NewFD->addAttr(::new (Context) OverloadableAttr());
2933 // If this is a locally-scoped extern C function, update the
2934 // map of such names.
2935 if (CurContext->isFunctionOrMethod() && NewFD->isExternC()
2936 && !NewFD->isInvalidDecl())
2937 RegisterLocallyScopedExternCDecl(NewFD, PrevDecl, S);
2939 // Set this FunctionDecl's range up to the right paren.
2940 NewFD->setLocEnd(D.getSourceRange().getEnd());
2942 if (FunctionTemplate && NewFD->isInvalidDecl())
2943 FunctionTemplate->setInvalidDecl();
2945 if (FunctionTemplate)
2946 return FunctionTemplate;
2951 /// \brief Perform semantic checking of a new function declaration.
2953 /// Performs semantic analysis of the new function declaration
2954 /// NewFD. This routine performs all semantic checking that does not
2955 /// require the actual declarator involved in the declaration, and is
2956 /// used both for the declaration of functions as they are parsed
2957 /// (called via ActOnDeclarator) and for the declaration of functions
2958 /// that have been instantiated via C++ template instantiation (called
2959 /// via InstantiateDecl).
2961 /// \param IsExplicitSpecialiation whether this new function declaration is
2962 /// an explicit specialization of the previous declaration.
2964 /// This sets NewFD->isInvalidDecl() to true if there was an error.
2965 void Sema::CheckFunctionDeclaration(FunctionDecl *NewFD, NamedDecl *&PrevDecl,
2966 bool IsExplicitSpecialization,
2967 bool &Redeclaration,
2968 bool &OverloadableAttrRequired) {
2969 // If NewFD is already known erroneous, don't do any of this checking.
2970 if (NewFD->isInvalidDecl())
2973 if (NewFD->getResultType()->isVariablyModifiedType()) {
2974 // Functions returning a variably modified type violate C99 6.7.5.2p2
2975 // because all functions have linkage.
2976 Diag(NewFD->getLocation(), diag::err_vm_func_decl);
2977 return NewFD->setInvalidDecl();
2980 if (NewFD->isMain())
2983 // Check for a previous declaration of this name.
2984 if (!PrevDecl && NewFD->isExternC()) {
2985 // Since we did not find anything by this name and we're declaring
2986 // an extern "C" function, look for a non-visible extern "C"
2987 // declaration with the same name.
2988 llvm::DenseMap<DeclarationName, NamedDecl *>::iterator Pos
2989 = LocallyScopedExternalDecls.find(NewFD->getDeclName());
2990 if (Pos != LocallyScopedExternalDecls.end())
2991 PrevDecl = Pos->second;
2994 // Merge or overload the declaration with an existing declaration of
2995 // the same name, if appropriate.
2997 // Determine whether NewFD is an overload of PrevDecl or
2998 // a declaration that requires merging. If it's an overload,
2999 // there's no more work to do here; we'll just add the new
3000 // function to the scope.
3001 OverloadedFunctionDecl::function_iterator MatchedDecl;
3003 if (!getLangOptions().CPlusPlus &&
3004 AllowOverloadingOfFunction(PrevDecl, Context)) {
3005 OverloadableAttrRequired = true;
3007 // Functions marked "overloadable" must have a prototype (that
3008 // we can't get through declaration merging).
3009 if (!NewFD->getType()->getAs<FunctionProtoType>()) {
3010 Diag(NewFD->getLocation(), diag::err_attribute_overloadable_no_prototype)
3012 Redeclaration = true;
3014 // Turn this into a variadic function with no parameters.
3015 QualType R = Context.getFunctionType(
3016 NewFD->getType()->getAs<FunctionType>()->getResultType(),
3019 return NewFD->setInvalidDecl();
3024 (!AllowOverloadingOfFunction(PrevDecl, Context) ||
3025 !IsOverload(NewFD, PrevDecl, MatchedDecl)) && !isUsingDecl(PrevDecl)) {
3026 Redeclaration = true;
3027 Decl *OldDecl = PrevDecl;
3029 // If PrevDecl was an overloaded function, extract the
3030 // FunctionDecl that matched.
3031 if (isa<OverloadedFunctionDecl>(PrevDecl))
3032 OldDecl = *MatchedDecl;
3034 // NewFD and OldDecl represent declarations that need to be
3036 if (MergeFunctionDecl(NewFD, OldDecl))
3037 return NewFD->setInvalidDecl();
3039 if (FunctionTemplateDecl *OldTemplateDecl
3040 = dyn_cast<FunctionTemplateDecl>(OldDecl)) {
3041 NewFD->setPreviousDeclaration(OldTemplateDecl->getTemplatedDecl());
3042 FunctionTemplateDecl *NewTemplateDecl
3043 = NewFD->getDescribedFunctionTemplate();
3044 assert(NewTemplateDecl && "Template/non-template mismatch");
3045 if (CXXMethodDecl *Method
3046 = dyn_cast<CXXMethodDecl>(NewTemplateDecl->getTemplatedDecl())) {
3047 Method->setAccess(OldTemplateDecl->getAccess());
3048 NewTemplateDecl->setAccess(OldTemplateDecl->getAccess());
3051 // If this is an explicit specialization of a member that is a function
3052 // template, mark it as a member specialization.
3053 if (IsExplicitSpecialization &&
3054 NewTemplateDecl->getInstantiatedFromMemberTemplate()) {
3055 NewTemplateDecl->setMemberSpecialization();
3056 assert(OldTemplateDecl->isMemberSpecialization());
3059 if (isa<CXXMethodDecl>(NewFD)) // Set access for out-of-line definitions
3060 NewFD->setAccess(OldDecl->getAccess());
3061 NewFD->setPreviousDeclaration(cast<FunctionDecl>(OldDecl));
3066 // Semantic checking for this function declaration (in isolation).
3067 if (getLangOptions().CPlusPlus) {
3068 // C++-specific checks.
3069 if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(NewFD)) {
3070 CheckConstructor(Constructor);
3071 } else if (isa<CXXDestructorDecl>(NewFD)) {
3072 CXXRecordDecl *Record = cast<CXXRecordDecl>(NewFD->getParent());
3073 QualType ClassType = Context.getTypeDeclType(Record);
3074 if (!ClassType->isDependentType()) {
3075 DeclarationName Name
3076 = Context.DeclarationNames.getCXXDestructorName(
3077 Context.getCanonicalType(ClassType));
3078 if (NewFD->getDeclName() != Name) {
3079 Diag(NewFD->getLocation(), diag::err_destructor_name);
3080 return NewFD->setInvalidDecl();
3083 Record->setUserDeclaredDestructor(true);
3084 // C++ [class]p4: A POD-struct is an aggregate class that has [...] no
3085 // user-defined destructor.
3086 Record->setPOD(false);
3088 // C++ [class.dtor]p3: A destructor is trivial if it is an implicitly-
3089 // declared destructor.
3090 // FIXME: C++0x: don't do this for "= default" destructors
3091 Record->setHasTrivialDestructor(false);
3092 } else if (CXXConversionDecl *Conversion
3093 = dyn_cast<CXXConversionDecl>(NewFD))
3094 ActOnConversionDeclarator(Conversion);
3096 // Extra checking for C++ overloaded operators (C++ [over.oper]).
3097 if (NewFD->isOverloadedOperator() &&
3098 CheckOverloadedOperatorDeclaration(NewFD))
3099 return NewFD->setInvalidDecl();
3101 // In C++, check default arguments now that we have merged decls. Unless
3102 // the lexical context is the class, because in this case this is done
3103 // during delayed parsing anyway.
3104 if (!CurContext->isRecord())
3105 CheckCXXDefaultArguments(NewFD);
3109 void Sema::CheckMain(FunctionDecl* FD) {
3110 // C++ [basic.start.main]p3: A program that declares main to be inline
3111 // or static is ill-formed.
3112 // C99 6.7.4p4: In a hosted environment, the inline function specifier
3113 // shall not appear in a declaration of main.
3114 // static main is not an error under C99, but we should warn about it.
3115 bool isInline = FD->isInlineSpecified();
3116 bool isStatic = FD->getStorageClass() == FunctionDecl::Static;
3117 if (isInline || isStatic) {
3118 unsigned diagID = diag::warn_unusual_main_decl;
3119 if (isInline || getLangOptions().CPlusPlus)
3120 diagID = diag::err_unusual_main_decl;
3122 int which = isStatic + (isInline << 1) - 1;
3123 Diag(FD->getLocation(), diagID) << which;
3126 QualType T = FD->getType();
3127 assert(T->isFunctionType() && "function decl is not of function type");
3128 const FunctionType* FT = T->getAs<FunctionType>();
3130 if (!Context.hasSameUnqualifiedType(FT->getResultType(), Context.IntTy)) {
3131 // TODO: add a replacement fixit to turn the return type into 'int'.
3132 Diag(FD->getTypeSpecStartLoc(), diag::err_main_returns_nonint);
3133 FD->setInvalidDecl(true);
3136 // Treat protoless main() as nullary.
3137 if (isa<FunctionNoProtoType>(FT)) return;
3139 const FunctionProtoType* FTP = cast<const FunctionProtoType>(FT);
3140 unsigned nparams = FTP->getNumArgs();
3141 assert(FD->getNumParams() == nparams);
3144 Diag(FD->getLocation(), diag::err_main_surplus_args) << nparams;
3145 FD->setInvalidDecl(true);
3149 // FIXME: a lot of the following diagnostics would be improved
3150 // if we had some location information about types.
3153 Context.getPointerType(Context.getPointerType(Context.CharTy));
3154 QualType Expected[] = { Context.IntTy, CharPP, CharPP };
3156 for (unsigned i = 0; i < nparams; ++i) {
3157 QualType AT = FTP->getArgType(i);
3159 bool mismatch = true;
3161 if (Context.hasSameUnqualifiedType(AT, Expected[i]))
3163 else if (Expected[i] == CharPP) {
3164 // As an extension, the following forms are okay:
3166 // char const * const *
3169 QualifierCollector qs;
3170 const PointerType* PT;
3171 if ((PT = qs.strip(AT)->getAs<PointerType>()) &&
3172 (PT = qs.strip(PT->getPointeeType())->getAs<PointerType>()) &&
3173 (QualType(qs.strip(PT->getPointeeType()), 0) == Context.CharTy)) {
3175 mismatch = !qs.empty();
3180 Diag(FD->getLocation(), diag::err_main_arg_wrong) << i << Expected[i];
3181 // TODO: suggest replacing given type with expected type
3182 FD->setInvalidDecl(true);
3186 if (nparams == 1 && !FD->isInvalidDecl()) {
3187 Diag(FD->getLocation(), diag::warn_main_one_arg);
3191 bool Sema::CheckForConstantInitializer(Expr *Init, QualType DclT) {
3192 // FIXME: Need strict checking. In C89, we need to check for
3193 // any assignment, increment, decrement, function-calls, or
3194 // commas outside of a sizeof. In C99, it's the same list,
3195 // except that the aforementioned are allowed in unevaluated
3196 // expressions. Everything else falls under the
3197 // "may accept other forms of constant expressions" exception.
3198 // (We never end up here for C++, so the constant expression
3199 // rules there don't matter.)
3200 if (Init->isConstantInitializer(Context))
3202 Diag(Init->getExprLoc(), diag::err_init_element_not_constant)
3203 << Init->getSourceRange();
3207 void Sema::AddInitializerToDecl(DeclPtrTy dcl, ExprArg init) {
3208 AddInitializerToDecl(dcl, move(init), /*DirectInit=*/false);
3211 /// AddInitializerToDecl - Adds the initializer Init to the
3212 /// declaration dcl. If DirectInit is true, this is C++ direct
3213 /// initialization rather than copy initialization.
3214 void Sema::AddInitializerToDecl(DeclPtrTy dcl, ExprArg init, bool DirectInit) {
3215 Decl *RealDecl = dcl.getAs<Decl>();
3216 // If there is no declaration, there was an error parsing it. Just ignore
3221 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(RealDecl)) {
3222 // With declarators parsed the way they are, the parser cannot
3223 // distinguish between a normal initializer and a pure-specifier.
3224 // Thus this grotesque test.
3226 Expr *Init = static_cast<Expr *>(init.get());
3227 if ((IL = dyn_cast<IntegerLiteral>(Init)) && IL->getValue() == 0 &&
3228 Context.getCanonicalType(IL->getType()) == Context.IntTy) {
3229 if (Method->isVirtualAsWritten()) {
3232 // A class is abstract if at least one function is pure virtual.
3233 cast<CXXRecordDecl>(CurContext)->setAbstract(true);
3234 } else if (!Method->isInvalidDecl()) {
3235 Diag(Method->getLocation(), diag::err_non_virtual_pure)
3236 << Method->getDeclName() << Init->getSourceRange();
3237 Method->setInvalidDecl();
3240 Diag(Method->getLocation(), diag::err_member_function_initialization)
3241 << Method->getDeclName() << Init->getSourceRange();
3242 Method->setInvalidDecl();
3247 VarDecl *VDecl = dyn_cast<VarDecl>(RealDecl);
3249 if (getLangOptions().CPlusPlus &&
3250 RealDecl->getLexicalDeclContext()->isRecord() &&
3251 isa<NamedDecl>(RealDecl))
3252 Diag(RealDecl->getLocation(), diag::err_member_initialization)
3253 << cast<NamedDecl>(RealDecl)->getDeclName();
3255 Diag(RealDecl->getLocation(), diag::err_illegal_initializer);
3256 RealDecl->setInvalidDecl();
3260 if (!VDecl->getType()->isArrayType() &&
3261 RequireCompleteType(VDecl->getLocation(), VDecl->getType(),
3262 diag::err_typecheck_decl_incomplete_type)) {
3263 RealDecl->setInvalidDecl();
3267 const VarDecl *Def = 0;
3268 if (VDecl->getDefinition(Def)) {
3269 Diag(VDecl->getLocation(), diag::err_redefinition)
3270 << VDecl->getDeclName();
3271 Diag(Def->getLocation(), diag::note_previous_definition);
3272 VDecl->setInvalidDecl();
3276 // Take ownership of the expression, now that we're sure we have somewhere
3278 Expr *Init = init.takeAs<Expr>();
3279 assert(Init && "missing initializer");
3281 // Get the decls type and save a reference for later, since
3282 // CheckInitializerTypes may change it.
3283 QualType DclT = VDecl->getType(), SavT = DclT;
3284 if (VDecl->isBlockVarDecl()) {
3285 if (VDecl->hasExternalStorage()) { // C99 6.7.8p5
3286 Diag(VDecl->getLocation(), diag::err_block_extern_cant_init);
3287 VDecl->setInvalidDecl();
3288 } else if (!VDecl->isInvalidDecl()) {
3289 if (CheckInitializerTypes(Init, DclT, VDecl->getLocation(),
3290 VDecl->getDeclName(), DirectInit))
3291 VDecl->setInvalidDecl();
3293 // C++ 3.6.2p2, allow dynamic initialization of static initializers.
3294 // Don't check invalid declarations to avoid emitting useless diagnostics.
3295 if (!getLangOptions().CPlusPlus && !VDecl->isInvalidDecl()) {
3296 if (VDecl->getStorageClass() == VarDecl::Static) // C99 6.7.8p4.
3297 CheckForConstantInitializer(Init, DclT);
3300 } else if (VDecl->isStaticDataMember() &&
3301 VDecl->getLexicalDeclContext()->isRecord()) {
3302 // This is an in-class initialization for a static data member, e.g.,
3305 // static const int value = 17;
3308 // Attach the initializer
3309 VDecl->setInit(Context, Init);
3311 // C++ [class.mem]p4:
3312 // A member-declarator can contain a constant-initializer only
3313 // if it declares a static member (9.4) of const integral or
3314 // const enumeration type, see 9.4.2.
3315 QualType T = VDecl->getType();
3316 if (!T->isDependentType() &&
3317 (!Context.getCanonicalType(T).isConstQualified() ||
3318 !T->isIntegralType())) {
3319 Diag(VDecl->getLocation(), diag::err_member_initialization)
3320 << VDecl->getDeclName() << Init->getSourceRange();
3321 VDecl->setInvalidDecl();
3323 // C++ [class.static.data]p4:
3324 // If a static data member is of const integral or const
3325 // enumeration type, its declaration in the class definition
3326 // can specify a constant-initializer which shall be an
3327 // integral constant expression (5.19).
3328 if (!Init->isTypeDependent() &&
3329 !Init->getType()->isIntegralType()) {
3330 // We have a non-dependent, non-integral or enumeration type.
3331 Diag(Init->getSourceRange().getBegin(),
3332 diag::err_in_class_initializer_non_integral_type)
3333 << Init->getType() << Init->getSourceRange();
3334 VDecl->setInvalidDecl();
3335 } else if (!Init->isTypeDependent() && !Init->isValueDependent()) {
3336 // Check whether the expression is a constant expression.
3339 if (!Init->isIntegerConstantExpr(Value, Context, &Loc)) {
3340 Diag(Loc, diag::err_in_class_initializer_non_constant)
3341 << Init->getSourceRange();
3342 VDecl->setInvalidDecl();
3343 } else if (!VDecl->getType()->isDependentType())
3344 ImpCastExprToType(Init, VDecl->getType(), CastExpr::CK_IntegralCast);
3347 } else if (VDecl->isFileVarDecl()) {
3348 if (VDecl->getStorageClass() == VarDecl::Extern)
3349 Diag(VDecl->getLocation(), diag::warn_extern_init);
3350 if (!VDecl->isInvalidDecl())
3351 if (CheckInitializerTypes(Init, DclT, VDecl->getLocation(),
3352 VDecl->getDeclName(), DirectInit))
3353 VDecl->setInvalidDecl();
3355 // C++ 3.6.2p2, allow dynamic initialization of static initializers.
3356 // Don't check invalid declarations to avoid emitting useless diagnostics.
3357 if (!getLangOptions().CPlusPlus && !VDecl->isInvalidDecl()) {
3358 // C99 6.7.8p4. All file scoped initializers need to be constant.
3359 CheckForConstantInitializer(Init, DclT);
3362 // If the type changed, it means we had an incomplete type that was
3363 // completed by the initializer. For example:
3364 // int ary[] = { 1, 3, 5 };
3365 // "ary" transitions from a VariableArrayType to a ConstantArrayType.
3366 if (!VDecl->isInvalidDecl() && (DclT != SavT)) {
3367 VDecl->setType(DclT);
3368 Init->setType(DclT);
3371 Init = MaybeCreateCXXExprWithTemporaries(Init,
3372 /*ShouldDestroyTemporaries=*/true);
3373 // Attach the initializer to the decl.
3374 VDecl->setInit(Context, Init);
3376 // If the previous declaration of VDecl was a tentative definition,
3377 // remove it from the set of tentative definitions.
3378 if (VDecl->getPreviousDeclaration() &&
3379 VDecl->getPreviousDeclaration()->isTentativeDefinition(Context)) {
3380 bool Deleted = TentativeDefinitions.erase(VDecl->getDeclName());
3381 assert(Deleted && "Unrecorded tentative definition?"); Deleted=Deleted;
3387 void Sema::ActOnUninitializedDecl(DeclPtrTy dcl,
3388 bool TypeContainsUndeducedAuto) {
3389 Decl *RealDecl = dcl.getAs<Decl>();
3391 // If there is no declaration, there was an error parsing it. Just ignore it.
3395 if (VarDecl *Var = dyn_cast<VarDecl>(RealDecl)) {
3396 QualType Type = Var->getType();
3398 // Record tentative definitions.
3399 if (Var->isTentativeDefinition(Context)) {
3400 std::pair<llvm::DenseMap<DeclarationName, VarDecl *>::iterator, bool>
3402 TentativeDefinitions.insert(std::make_pair(Var->getDeclName(), Var));
3404 // Keep the latest definition in the map. If we see 'int i; int i;' we
3405 // want the second one in the map.
3406 InsertPair.first->second = Var;
3408 // However, for the list, we don't care about the order, just make sure
3409 // that there are no dupes for a given declaration name.
3410 if (InsertPair.second)
3411 TentativeDefinitionList.push_back(Var->getDeclName());
3414 // C++ [dcl.init.ref]p3:
3415 // The initializer can be omitted for a reference only in a
3416 // parameter declaration (8.3.5), in the declaration of a
3417 // function return type, in the declaration of a class member
3418 // within its class declaration (9.2), and where the extern
3419 // specifier is explicitly used.
3420 if (Type->isReferenceType() && !Var->hasExternalStorage()) {
3421 Diag(Var->getLocation(), diag::err_reference_var_requires_init)
3422 << Var->getDeclName()
3423 << SourceRange(Var->getLocation(), Var->getLocation());
3424 Var->setInvalidDecl();
3428 // C++0x [dcl.spec.auto]p3
3429 if (TypeContainsUndeducedAuto) {
3430 Diag(Var->getLocation(), diag::err_auto_var_requires_init)
3431 << Var->getDeclName() << Type;
3432 Var->setInvalidDecl();
3436 // C++ [temp.expl.spec]p15:
3437 // An explicit specialization of a static data member of a template is a
3438 // definition if the declaration includes an initializer; otherwise, it
3439 // is a declaration.
3440 if (Var->isStaticDataMember() &&
3441 Var->getInstantiatedFromStaticDataMember() &&
3442 Var->getTemplateSpecializationKind() == TSK_ExplicitSpecialization)
3445 // C++ [dcl.init]p9:
3446 // If no initializer is specified for an object, and the object
3447 // is of (possibly cv-qualified) non-POD class type (or array
3448 // thereof), the object shall be default-initialized; if the
3449 // object is of const-qualified type, the underlying class type
3450 // shall have a user-declared default constructor.
3452 // FIXME: Diagnose the "user-declared default constructor" bit.
3453 if (getLangOptions().CPlusPlus) {
3454 QualType InitType = Type;
3455 if (const ArrayType *Array = Context.getAsArrayType(Type))
3456 InitType = Context.getBaseElementType(Array);
3457 if ((!Var->hasExternalStorage() && !Var->isExternC()) &&
3458 InitType->isRecordType() && !InitType->isDependentType()) {
3459 if (!RequireCompleteType(Var->getLocation(), InitType,
3460 diag::err_invalid_incomplete_type_use)) {
3461 ASTOwningVector<&ActionBase::DeleteExpr> ConstructorArgs(*this);
3463 CXXConstructorDecl *Constructor
3464 = PerformInitializationByConstructor(InitType,
3465 MultiExprArg(*this, 0, 0),
3467 SourceRange(Var->getLocation(),
3468 Var->getLocation()),
3473 // FIXME: Location info for the variable initialization?
3475 Var->setInvalidDecl();
3477 // FIXME: Cope with initialization of arrays
3478 if (!Constructor->isTrivial() &&
3479 InitializeVarWithConstructor(Var, Constructor,
3480 move_arg(ConstructorArgs)))
3481 Var->setInvalidDecl();
3483 FinalizeVarWithDestructor(Var, InitType);
3486 Var->setInvalidDecl();
3492 // FIXME: Temporarily disabled because we are not properly parsing
3493 // linkage specifications on declarations, e.g.,
3495 // extern "C" const CGPoint CGPointerZero;
3497 // C++ [dcl.init]p9:
3499 // If no initializer is specified for an object, and the
3500 // object is of (possibly cv-qualified) non-POD class type (or
3501 // array thereof), the object shall be default-initialized; if
3502 // the object is of const-qualified type, the underlying class
3503 // type shall have a user-declared default
3504 // constructor. Otherwise, if no initializer is specified for
3505 // an object, the object and its subobjects, if any, have an
3506 // indeterminate initial value; if the object or any of its
3507 // subobjects are of const-qualified type, the program is
3510 // This isn't technically an error in C, so we don't diagnose it.
3512 // FIXME: Actually perform the POD/user-defined default
3513 // constructor check.
3514 if (getLangOptions().CPlusPlus &&
3515 Context.getCanonicalType(Type).isConstQualified() &&
3516 !Var->hasExternalStorage())
3517 Diag(Var->getLocation(), diag::err_const_var_requires_init)
3519 << SourceRange(Var->getLocation(), Var->getLocation());
3524 Sema::DeclGroupPtrTy Sema::FinalizeDeclaratorGroup(Scope *S, const DeclSpec &DS,
3526 unsigned NumDecls) {
3527 llvm::SmallVector<Decl*, 8> Decls;
3529 if (DS.isTypeSpecOwned())
3530 Decls.push_back((Decl*)DS.getTypeRep());
3532 for (unsigned i = 0; i != NumDecls; ++i)
3533 if (Decl *D = Group[i].getAs<Decl>())
3536 // Perform semantic analysis that depends on having fully processed both
3537 // the declarator and initializer.
3538 for (unsigned i = 0, e = Decls.size(); i != e; ++i) {
3539 VarDecl *IDecl = dyn_cast<VarDecl>(Decls[i]);
3542 QualType T = IDecl->getType();
3544 // Block scope. C99 6.7p7: If an identifier for an object is declared with
3545 // no linkage (C99 6.2.2p6), the type for the object shall be complete...
3546 if (IDecl->isBlockVarDecl() && !IDecl->hasExternalStorage()) {
3547 if (T->isDependentType()) {
3548 // If T is dependent, we should not require a complete type.
3549 // (RequireCompleteType shouldn't be called with dependent types.)
3550 // But we still can at least check if we've got an array of unspecified
3551 // size without an initializer.
3552 if (!IDecl->isInvalidDecl() && T->isIncompleteArrayType() &&
3553 !IDecl->getInit()) {
3554 Diag(IDecl->getLocation(), diag::err_typecheck_decl_incomplete_type)
3556 IDecl->setInvalidDecl();
3558 } else if (!IDecl->isInvalidDecl()) {
3559 // If T is an incomplete array type with an initializer list that is
3560 // dependent on something, its size has not been fixed. We could attempt
3561 // to fix the size for such arrays, but we would still have to check
3562 // here for initializers containing a C++0x vararg expansion, e.g.
3563 // template <typename... Args> void f(Args... args) {
3564 // int vals[] = { args };
3566 const IncompleteArrayType *IAT = T->getAs<IncompleteArrayType>();
3567 Expr *Init = IDecl->getInit();
3569 (Init->isTypeDependent() || Init->isValueDependent())) {
3570 // Check that the member type of the array is complete, at least.
3571 if (RequireCompleteType(IDecl->getLocation(), IAT->getElementType(),
3572 diag::err_typecheck_decl_incomplete_type))
3573 IDecl->setInvalidDecl();
3574 } else if (RequireCompleteType(IDecl->getLocation(), T,
3575 diag::err_typecheck_decl_incomplete_type))
3576 IDecl->setInvalidDecl();
3579 // File scope. C99 6.9.2p2: A declaration of an identifier for an
3580 // object that has file scope without an initializer, and without a
3581 // storage-class specifier or with the storage-class specifier "static",
3582 // constitutes a tentative definition. Note: A tentative definition with
3583 // external linkage is valid (C99 6.2.2p5).
3584 if (IDecl->isTentativeDefinition(Context) && !IDecl->isInvalidDecl()) {
3585 if (const IncompleteArrayType *ArrayT
3586 = Context.getAsIncompleteArrayType(T)) {
3587 if (RequireCompleteType(IDecl->getLocation(),
3588 ArrayT->getElementType(),
3589 diag::err_illegal_decl_array_incomplete_type))
3590 IDecl->setInvalidDecl();
3591 } else if (IDecl->getStorageClass() == VarDecl::Static) {
3592 // C99 6.9.2p3: If the declaration of an identifier for an object is
3593 // a tentative definition and has internal linkage (C99 6.2.2p3), the
3594 // declared type shall not be an incomplete type.
3595 // NOTE: code such as the following
3597 // struct s { int a; };
3598 // is accepted by gcc. Hence here we issue a warning instead of
3599 // an error and we do not invalidate the static declaration.
3600 // NOTE: to avoid multiple warnings, only check the first declaration.
3601 if (IDecl->getPreviousDeclaration() == 0)
3602 RequireCompleteType(IDecl->getLocation(), T,
3603 diag::ext_typecheck_decl_incomplete_type);
3607 return DeclGroupPtrTy::make(DeclGroupRef::Create(Context,
3608 Decls.data(), Decls.size()));
3612 /// ActOnParamDeclarator - Called from Parser::ParseFunctionDeclarator()
3613 /// to introduce parameters into function prototype scope.
3615 Sema::ActOnParamDeclarator(Scope *S, Declarator &D) {
3616 const DeclSpec &DS = D.getDeclSpec();
3618 // Verify C99 6.7.5.3p2: The only SCS allowed is 'register'.
3619 VarDecl::StorageClass StorageClass = VarDecl::None;
3620 if (DS.getStorageClassSpec() == DeclSpec::SCS_register) {
3621 StorageClass = VarDecl::Register;
3622 } else if (DS.getStorageClassSpec() != DeclSpec::SCS_unspecified) {
3623 Diag(DS.getStorageClassSpecLoc(),
3624 diag::err_invalid_storage_class_in_func_decl);
3625 D.getMutableDeclSpec().ClearStorageClassSpecs();
3628 if (D.getDeclSpec().isThreadSpecified())
3629 Diag(D.getDeclSpec().getThreadSpecLoc(), diag::err_invalid_thread);
3631 DiagnoseFunctionSpecifiers(D);
3633 // Check that there are no default arguments inside the type of this
3634 // parameter (C++ only).
3635 if (getLangOptions().CPlusPlus)
3636 CheckExtraCXXDefaultArguments(D);
3638 DeclaratorInfo *DInfo = 0;
3639 TagDecl *OwnedDecl = 0;
3640 QualType parmDeclType = GetTypeForDeclarator(D, S, &DInfo, &OwnedDecl);
3642 if (getLangOptions().CPlusPlus && OwnedDecl && OwnedDecl->isDefinition()) {
3644 // Types shall not be defined in return or parameter types.
3645 Diag(OwnedDecl->getLocation(), diag::err_type_defined_in_param_type)
3646 << Context.getTypeDeclType(OwnedDecl);
3649 // TODO: CHECK FOR CONFLICTS, multiple decls with same name in one scope.
3650 // Can this happen for params? We already checked that they don't conflict
3651 // among each other. Here they can only shadow globals, which is ok.
3652 IdentifierInfo *II = D.getIdentifier();
3654 if (NamedDecl *PrevDecl = LookupSingleName(S, II, LookupOrdinaryName)) {
3655 if (PrevDecl->isTemplateParameter()) {
3656 // Maybe we will complain about the shadowed template parameter.
3657 DiagnoseTemplateParameterShadow(D.getIdentifierLoc(), PrevDecl);
3658 // Just pretend that we didn't see the previous declaration.
3660 } else if (S->isDeclScope(DeclPtrTy::make(PrevDecl))) {
3661 Diag(D.getIdentifierLoc(), diag::err_param_redefinition) << II;
3663 // Recover by removing the name
3665 D.SetIdentifier(0, D.getIdentifierLoc());
3670 // Parameters can not be abstract class types.
3671 // For record types, this is done by the AbstractClassUsageDiagnoser once
3672 // the class has been completely parsed.
3673 if (!CurContext->isRecord() &&
3674 RequireNonAbstractType(D.getIdentifierLoc(), parmDeclType,
3675 diag::err_abstract_type_in_decl,
3677 D.setInvalidType(true);
3679 QualType T = adjustParameterType(parmDeclType);
3682 = ParmVarDecl::Create(Context, CurContext, D.getIdentifierLoc(), II,
3683 T, DInfo, StorageClass, 0);
3685 if (D.isInvalidType())
3686 New->setInvalidDecl();
3688 // Parameter declarators cannot be interface types. All ObjC objects are
3689 // passed by reference.
3690 if (T->isObjCInterfaceType()) {
3691 Diag(D.getIdentifierLoc(),
3692 diag::err_object_cannot_be_passed_returned_by_value) << 1 << T;
3693 New->setInvalidDecl();
3696 // Parameter declarators cannot be qualified (C++ [dcl.meaning]p1).
3697 if (D.getCXXScopeSpec().isSet()) {
3698 Diag(D.getIdentifierLoc(), diag::err_qualified_param_declarator)
3699 << D.getCXXScopeSpec().getRange();
3700 New->setInvalidDecl();
3703 // ISO/IEC TR 18037 S6.7.3: "The type of an object with automatic storage
3704 // duration shall not be qualified by an address-space qualifier."
3705 // Since all parameters have automatic store duration, they can not have
3706 // an address space.
3707 if (T.getAddressSpace() != 0) {
3708 Diag(D.getIdentifierLoc(),
3709 diag::err_arg_with_address_space);
3710 New->setInvalidDecl();
3714 // Add the parameter declaration into this scope.
3715 S->AddDecl(DeclPtrTy::make(New));
3717 IdResolver.AddDecl(New);
3719 ProcessDeclAttributes(S, New, D);
3721 if (New->hasAttr<BlocksAttr>()) {
3722 Diag(New->getLocation(), diag::err_block_on_nonlocal);
3724 return DeclPtrTy::make(New);
3727 void Sema::ActOnFinishKNRParamDeclarations(Scope *S, Declarator &D,
3728 SourceLocation LocAfterDecls) {
3729 assert(D.getTypeObject(0).Kind == DeclaratorChunk::Function &&
3730 "Not a function declarator!");
3731 DeclaratorChunk::FunctionTypeInfo &FTI = D.getTypeObject(0).Fun;
3733 // Verify 6.9.1p6: 'every identifier in the identifier list shall be declared'
3734 // for a K&R function.
3735 if (!FTI.hasPrototype) {
3736 for (int i = FTI.NumArgs; i != 0; /* decrement in loop */) {
3738 if (FTI.ArgInfo[i].Param == 0) {
3739 llvm::SmallString<256> Code;
3740 llvm::raw_svector_ostream(Code) << " int "
3741 << FTI.ArgInfo[i].Ident->getName()
3743 Diag(FTI.ArgInfo[i].IdentLoc, diag::ext_param_not_declared)
3744 << FTI.ArgInfo[i].Ident
3745 << CodeModificationHint::CreateInsertion(LocAfterDecls, Code.str());
3747 // Implicitly declare the argument as type 'int' for lack of a better
3750 const char* PrevSpec; // unused
3751 unsigned DiagID; // unused
3752 DS.SetTypeSpecType(DeclSpec::TST_int, FTI.ArgInfo[i].IdentLoc,
3754 Declarator ParamD(DS, Declarator::KNRTypeListContext);
3755 ParamD.SetIdentifier(FTI.ArgInfo[i].Ident, FTI.ArgInfo[i].IdentLoc);
3756 FTI.ArgInfo[i].Param = ActOnParamDeclarator(S, ParamD);
3762 Sema::DeclPtrTy Sema::ActOnStartOfFunctionDef(Scope *FnBodyScope,
3764 assert(getCurFunctionDecl() == 0 && "Function parsing confused");
3765 assert(D.getTypeObject(0).Kind == DeclaratorChunk::Function &&
3766 "Not a function declarator!");
3767 DeclaratorChunk::FunctionTypeInfo &FTI = D.getTypeObject(0).Fun;
3769 if (FTI.hasPrototype) {
3770 // FIXME: Diagnose arguments without names in C.
3773 Scope *ParentScope = FnBodyScope->getParent();
3775 DeclPtrTy DP = HandleDeclarator(ParentScope, D,
3776 MultiTemplateParamsArg(*this),
3777 /*IsFunctionDefinition=*/true);
3778 return ActOnStartOfFunctionDef(FnBodyScope, DP);
3781 Sema::DeclPtrTy Sema::ActOnStartOfFunctionDef(Scope *FnBodyScope, DeclPtrTy D) {
3782 // Clear the last template instantiation error context.
3783 LastTemplateInstantiationErrorContext = ActiveTemplateInstantiation();
3787 FunctionDecl *FD = 0;
3789 if (FunctionTemplateDecl *FunTmpl
3790 = dyn_cast<FunctionTemplateDecl>(D.getAs<Decl>()))
3791 FD = FunTmpl->getTemplatedDecl();
3793 FD = cast<FunctionDecl>(D.getAs<Decl>());
3795 CurFunctionNeedsScopeChecking = false;
3797 // See if this is a redefinition.
3798 const FunctionDecl *Definition;
3799 if (FD->getBody(Definition)) {
3800 Diag(FD->getLocation(), diag::err_redefinition) << FD->getDeclName();
3801 Diag(Definition->getLocation(), diag::note_previous_definition);
3804 // Builtin functions cannot be defined.
3805 if (unsigned BuiltinID = FD->getBuiltinID()) {
3806 if (!Context.BuiltinInfo.isPredefinedLibFunction(BuiltinID)) {
3807 Diag(FD->getLocation(), diag::err_builtin_definition) << FD;
3808 FD->setInvalidDecl();
3812 // The return type of a function definition must be complete
3813 // (C99 6.9.1p3, C++ [dcl.fct]p6).
3814 QualType ResultType = FD->getResultType();
3815 if (!ResultType->isDependentType() && !ResultType->isVoidType() &&
3816 !FD->isInvalidDecl() &&
3817 RequireCompleteType(FD->getLocation(), ResultType,
3818 diag::err_func_def_incomplete_result))
3819 FD->setInvalidDecl();
3821 // GNU warning -Wmissing-prototypes:
3822 // Warn if a global function is defined without a previous
3823 // prototype declaration. This warning is issued even if the
3824 // definition itself provides a prototype. The aim is to detect
3825 // global functions that fail to be declared in header files.
3826 if (!FD->isInvalidDecl() && FD->isGlobal() && !isa<CXXMethodDecl>(FD) &&
3828 bool MissingPrototype = true;
3829 for (const FunctionDecl *Prev = FD->getPreviousDeclaration();
3830 Prev; Prev = Prev->getPreviousDeclaration()) {
3831 // Ignore any declarations that occur in function or method
3832 // scope, because they aren't visible from the header.
3833 if (Prev->getDeclContext()->isFunctionOrMethod())
3836 MissingPrototype = !Prev->getType()->isFunctionProtoType();
3840 if (MissingPrototype)
3841 Diag(FD->getLocation(), diag::warn_missing_prototype) << FD;
3845 PushDeclContext(FnBodyScope, FD);
3847 // Check the validity of our function parameters
3848 CheckParmsForFunctionDef(FD);
3850 // Introduce our parameters into the function scope
3851 for (unsigned p = 0, NumParams = FD->getNumParams(); p < NumParams; ++p) {
3852 ParmVarDecl *Param = FD->getParamDecl(p);
3853 Param->setOwningFunction(FD);
3855 // If this has an identifier, add it to the scope stack.
3856 if (Param->getIdentifier() && FnBodyScope)
3857 PushOnScopeChains(Param, FnBodyScope);
3860 // Checking attributes of current function definition
3861 // dllimport attribute.
3862 if (FD->getAttr<DLLImportAttr>() &&
3863 (!FD->getAttr<DLLExportAttr>())) {
3864 // dllimport attribute cannot be applied to definition.
3865 if (!(FD->getAttr<DLLImportAttr>())->isInherited()) {
3866 Diag(FD->getLocation(),
3867 diag::err_attribute_can_be_applied_only_to_symbol_declaration)
3869 FD->setInvalidDecl();
3870 return DeclPtrTy::make(FD);
3872 // If a symbol previously declared dllimport is later defined, the
3873 // attribute is ignored in subsequent references, and a warning is
3875 Diag(FD->getLocation(),
3876 diag::warn_redeclaration_without_attribute_prev_attribute_ignored)
3877 << FD->getNameAsCString() << "dllimport";
3880 return DeclPtrTy::make(FD);
3883 Sema::DeclPtrTy Sema::ActOnFinishFunctionBody(DeclPtrTy D, StmtArg BodyArg) {
3884 return ActOnFinishFunctionBody(D, move(BodyArg), false);
3887 Sema::DeclPtrTy Sema::ActOnFinishFunctionBody(DeclPtrTy D, StmtArg BodyArg,
3888 bool IsInstantiation) {
3889 Decl *dcl = D.getAs<Decl>();
3890 Stmt *Body = BodyArg.takeAs<Stmt>();
3892 FunctionDecl *FD = 0;
3893 FunctionTemplateDecl *FunTmpl = dyn_cast_or_null<FunctionTemplateDecl>(dcl);
3895 FD = FunTmpl->getTemplatedDecl();
3897 FD = dyn_cast_or_null<FunctionDecl>(dcl);
3902 // C and C++ allow for main to automagically return 0.
3903 // Implements C++ [basic.start.main]p5 and C99 5.1.2.2.3.
3904 FD->setHasImplicitReturnZero(true);
3906 CheckFallThroughForFunctionDef(FD, Body);
3908 if (!FD->isInvalidDecl())
3909 DiagnoseUnusedParameters(FD->param_begin(), FD->param_end());
3911 // C++ [basic.def.odr]p2:
3912 // [...] A virtual member function is used if it is not pure. [...]
3913 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(FD))
3914 if (Method->isVirtual() && !Method->isPure())
3915 MarkDeclarationReferenced(Method->getLocation(), Method);
3917 assert(FD == getCurFunctionDecl() && "Function parsing confused");
3918 } else if (ObjCMethodDecl *MD = dyn_cast_or_null<ObjCMethodDecl>(dcl)) {
3919 assert(MD == getCurMethodDecl() && "Method parsing confused");
3921 CheckFallThroughForFunctionDef(MD, Body);
3922 MD->setEndLoc(Body->getLocEnd());
3924 if (!MD->isInvalidDecl())
3925 DiagnoseUnusedParameters(MD->param_begin(), MD->param_end());
3927 Body->Destroy(Context);
3930 if (!IsInstantiation)
3933 // Verify and clean out per-function state.
3935 assert(&getLabelMap() == &FunctionLabelMap && "Didn't pop block right?");
3937 // Check goto/label use.
3938 for (llvm::DenseMap<IdentifierInfo*, LabelStmt*>::iterator
3939 I = FunctionLabelMap.begin(), E = FunctionLabelMap.end(); I != E; ++I) {
3940 LabelStmt *L = I->second;
3942 // Verify that we have no forward references left. If so, there was a goto
3943 // or address of a label taken, but no definition of it. Label fwd
3944 // definitions are indicated with a null substmt.
3945 if (L->getSubStmt() != 0)
3949 Diag(L->getIdentLoc(), diag::err_undeclared_label_use) << L->getName();
3951 // At this point, we have gotos that use the bogus label. Stitch it into
3952 // the function body so that they aren't leaked and that the AST is well
3955 // The whole function wasn't parsed correctly, just delete this.
3956 L->Destroy(Context);
3960 // Otherwise, the body is valid: we want to stitch the label decl into the
3961 // function somewhere so that it is properly owned and so that the goto
3962 // has a valid target. Do this by creating a new compound stmt with the
3965 // Give the label a sub-statement.
3966 L->setSubStmt(new (Context) NullStmt(L->getIdentLoc()));
3968 CompoundStmt *Compound = isa<CXXTryStmt>(Body) ?
3969 cast<CXXTryStmt>(Body)->getTryBlock() :
3970 cast<CompoundStmt>(Body);
3971 std::vector<Stmt*> Elements(Compound->body_begin(), Compound->body_end());
3972 Elements.push_back(L);
3973 Compound->setStmts(Context, &Elements[0], Elements.size());
3975 FunctionLabelMap.clear();
3977 if (!Body) return D;
3979 // Verify that that gotos and switch cases don't jump into scopes illegally.
3980 if (CurFunctionNeedsScopeChecking)
3981 DiagnoseInvalidJumps(Body);
3983 // C++ constructors that have function-try-blocks can't have return
3984 // statements in the handlers of that block. (C++ [except.handle]p14)
3986 if (FD && isa<CXXConstructorDecl>(FD) && isa<CXXTryStmt>(Body))
3987 DiagnoseReturnInConstructorExceptionHandler(cast<CXXTryStmt>(Body));
3989 if (CXXDestructorDecl *Destructor = dyn_cast<CXXDestructorDecl>(dcl))
3990 computeBaseOrMembersToDestroy(Destructor);
3994 /// ImplicitlyDefineFunction - An undeclared identifier was used in a function
3995 /// call, forming a call to an implicitly defined function (per C99 6.5.1p2).
3996 NamedDecl *Sema::ImplicitlyDefineFunction(SourceLocation Loc,
3997 IdentifierInfo &II, Scope *S) {
3998 // Before we produce a declaration for an implicitly defined
3999 // function, see whether there was a locally-scoped declaration of
4000 // this name as a function or variable. If so, use that
4001 // (non-visible) declaration, and complain about it.
4002 llvm::DenseMap<DeclarationName, NamedDecl *>::iterator Pos
4003 = LocallyScopedExternalDecls.find(&II);
4004 if (Pos != LocallyScopedExternalDecls.end()) {
4005 Diag(Loc, diag::warn_use_out_of_scope_declaration) << Pos->second;
4006 Diag(Pos->second->getLocation(), diag::note_previous_declaration);
4010 // Extension in C99. Legal in C90, but warn about it.
4011 if (II.getName().startswith("__builtin_"))
4012 Diag(Loc, diag::warn_builtin_unknown) << &II;
4013 else if (getLangOptions().C99)
4014 Diag(Loc, diag::ext_implicit_function_decl) << &II;
4016 Diag(Loc, diag::warn_implicit_function_decl) << &II;
4018 // Set a Declarator for the implicit definition: int foo();
4022 bool Error = DS.SetTypeSpecType(DeclSpec::TST_int, Loc, Dummy, DiagID);
4023 Error = Error; // Silence warning.
4024 assert(!Error && "Error setting up implicit decl!");
4025 Declarator D(DS, Declarator::BlockContext);
4026 D.AddTypeInfo(DeclaratorChunk::getFunction(false, false, SourceLocation(), 0,
4027 0, 0, false, SourceLocation(),
4028 false, 0,0,0, Loc, Loc, D),
4030 D.SetIdentifier(&II, Loc);
4032 // Insert this function into translation-unit scope.
4034 DeclContext *PrevDC = CurContext;
4035 CurContext = Context.getTranslationUnitDecl();
4038 dyn_cast<FunctionDecl>(ActOnDeclarator(TUScope, D).getAs<Decl>());
4041 CurContext = PrevDC;
4043 AddKnownFunctionAttributes(FD);
4048 /// \brief Adds any function attributes that we know a priori based on
4049 /// the declaration of this function.
4051 /// These attributes can apply both to implicitly-declared builtins
4052 /// (like __builtin___printf_chk) or to library-declared functions
4053 /// like NSLog or printf.
4054 void Sema::AddKnownFunctionAttributes(FunctionDecl *FD) {
4055 if (FD->isInvalidDecl())
4058 // If this is a built-in function, map its builtin attributes to
4059 // actual attributes.
4060 if (unsigned BuiltinID = FD->getBuiltinID()) {
4061 // Handle printf-formatting attributes.
4064 if (Context.BuiltinInfo.isPrintfLike(BuiltinID, FormatIdx, HasVAListArg)) {
4065 if (!FD->getAttr<FormatAttr>())
4066 FD->addAttr(::new (Context) FormatAttr("printf", FormatIdx + 1,
4067 HasVAListArg ? 0 : FormatIdx + 2));
4070 // Mark const if we don't care about errno and that is the only
4071 // thing preventing the function from being const. This allows
4072 // IRgen to use LLVM intrinsics for such functions.
4073 if (!getLangOptions().MathErrno &&
4074 Context.BuiltinInfo.isConstWithoutErrno(BuiltinID)) {
4075 if (!FD->getAttr<ConstAttr>())
4076 FD->addAttr(::new (Context) ConstAttr());
4079 if (Context.BuiltinInfo.isNoReturn(BuiltinID))
4080 FD->addAttr(::new (Context) NoReturnAttr());
4083 IdentifierInfo *Name = FD->getIdentifier();
4086 if ((!getLangOptions().CPlusPlus &&
4087 FD->getDeclContext()->isTranslationUnit()) ||
4088 (isa<LinkageSpecDecl>(FD->getDeclContext()) &&
4089 cast<LinkageSpecDecl>(FD->getDeclContext())->getLanguage() ==
4090 LinkageSpecDecl::lang_c)) {
4091 // Okay: this could be a libc/libm/Objective-C function we know
4096 if (Name->isStr("NSLog") || Name->isStr("NSLogv")) {
4097 // FIXME: NSLog and NSLogv should be target specific
4098 if (const FormatAttr *Format = FD->getAttr<FormatAttr>()) {
4099 // FIXME: We known better than our headers.
4100 const_cast<FormatAttr *>(Format)->setType("printf");
4102 FD->addAttr(::new (Context) FormatAttr("printf", 1,
4103 Name->isStr("NSLogv") ? 0 : 2));
4104 } else if (Name->isStr("asprintf") || Name->isStr("vasprintf")) {
4105 // FIXME: asprintf and vasprintf aren't C99 functions. Should they be
4106 // target-specific builtins, perhaps?
4107 if (!FD->getAttr<FormatAttr>())
4108 FD->addAttr(::new (Context) FormatAttr("printf", 2,
4109 Name->isStr("vasprintf") ? 0 : 3));
4113 TypedefDecl *Sema::ParseTypedefDecl(Scope *S, Declarator &D, QualType T,
4114 DeclaratorInfo *DInfo) {
4115 assert(D.getIdentifier() && "Wrong callback for declspec without declarator");
4116 assert(!T.isNull() && "GetTypeForDeclarator() returned null type");
4119 assert(D.isInvalidType() && "no declarator info for valid type");
4120 DInfo = Context.getTrivialDeclaratorInfo(T);
4123 // Scope manipulation handled by caller.
4124 TypedefDecl *NewTD = TypedefDecl::Create(Context, CurContext,
4125 D.getIdentifierLoc(),
4129 if (const TagType *TT = T->getAs<TagType>()) {
4130 TagDecl *TD = TT->getDecl();
4132 // If the TagDecl that the TypedefDecl points to is an anonymous decl
4133 // keep track of the TypedefDecl.
4134 if (!TD->getIdentifier() && !TD->getTypedefForAnonDecl())
4135 TD->setTypedefForAnonDecl(NewTD);
4138 if (D.isInvalidType())
4139 NewTD->setInvalidDecl();
4144 /// \brief Determine whether a tag with a given kind is acceptable
4145 /// as a redeclaration of the given tag declaration.
4147 /// \returns true if the new tag kind is acceptable, false otherwise.
4148 bool Sema::isAcceptableTagRedeclaration(const TagDecl *Previous,
4149 TagDecl::TagKind NewTag,
4150 SourceLocation NewTagLoc,
4151 const IdentifierInfo &Name) {
4152 // C++ [dcl.type.elab]p3:
4153 // The class-key or enum keyword present in the
4154 // elaborated-type-specifier shall agree in kind with the
4155 // declaration to which the name in theelaborated-type-specifier
4156 // refers. This rule also applies to the form of
4157 // elaborated-type-specifier that declares a class-name or
4158 // friend class since it can be construed as referring to the
4159 // definition of the class. Thus, in any
4160 // elaborated-type-specifier, the enum keyword shall be used to
4161 // refer to an enumeration (7.2), the union class-keyshall be
4162 // used to refer to a union (clause 9), and either the class or
4163 // struct class-key shall be used to refer to a class (clause 9)
4164 // declared using the class or struct class-key.
4165 TagDecl::TagKind OldTag = Previous->getTagKind();
4166 if (OldTag == NewTag)
4169 if ((OldTag == TagDecl::TK_struct || OldTag == TagDecl::TK_class) &&
4170 (NewTag == TagDecl::TK_struct || NewTag == TagDecl::TK_class)) {
4171 // Warn about the struct/class tag mismatch.
4172 bool isTemplate = false;
4173 if (const CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(Previous))
4174 isTemplate = Record->getDescribedClassTemplate();
4176 Diag(NewTagLoc, diag::warn_struct_class_tag_mismatch)
4177 << (NewTag == TagDecl::TK_class)
4178 << isTemplate << &Name
4179 << CodeModificationHint::CreateReplacement(SourceRange(NewTagLoc),
4180 OldTag == TagDecl::TK_class? "class" : "struct");
4181 Diag(Previous->getLocation(), diag::note_previous_use);
4187 /// ActOnTag - This is invoked when we see 'struct foo' or 'struct {'. In the
4188 /// former case, Name will be non-null. In the later case, Name will be null.
4189 /// TagSpec indicates what kind of tag this is. TUK indicates whether this is a
4190 /// reference/declaration/definition of a tag.
4191 Sema::DeclPtrTy Sema::ActOnTag(Scope *S, unsigned TagSpec, TagUseKind TUK,
4192 SourceLocation KWLoc, const CXXScopeSpec &SS,
4193 IdentifierInfo *Name, SourceLocation NameLoc,
4194 AttributeList *Attr, AccessSpecifier AS,
4195 MultiTemplateParamsArg TemplateParameterLists,
4196 bool &OwnedDecl, bool &IsDependent) {
4197 // If this is not a definition, it must have a name.
4198 assert((Name != 0 || TUK == TUK_Definition) &&
4199 "Nameless record must be a definition!");
4202 TagDecl::TagKind Kind = TagDecl::getTagKindForTypeSpec(TagSpec);
4204 // FIXME: Check explicit specializations more carefully.
4205 bool isExplicitSpecialization = false;
4206 if (TUK != TUK_Reference) {
4207 if (TemplateParameterList *TemplateParams
4208 = MatchTemplateParametersToScopeSpecifier(KWLoc, SS,
4209 (TemplateParameterList**)TemplateParameterLists.get(),
4210 TemplateParameterLists.size(),
4211 isExplicitSpecialization)) {
4212 if (TemplateParams->size() > 0) {
4213 // This is a declaration or definition of a class template (which may
4214 // be a member of another template).
4216 DeclResult Result = CheckClassTemplate(S, TagSpec, TUK, KWLoc,
4217 SS, Name, NameLoc, Attr,
4220 TemplateParameterLists.release();
4221 return Result.get();
4223 // The "template<>" header is extraneous.
4224 Diag(TemplateParams->getTemplateLoc(), diag::err_template_tag_noparams)
4225 << ElaboratedType::getNameForTagKind(Kind) << Name;
4226 isExplicitSpecialization = true;
4230 TemplateParameterLists.release();
4233 DeclContext *SearchDC = CurContext;
4234 DeclContext *DC = CurContext;
4235 NamedDecl *PrevDecl = 0;
4236 bool isStdBadAlloc = false;
4237 bool Invalid = false;
4239 bool RedeclarationOnly = (TUK != TUK_Reference);
4241 if (Name && SS.isNotEmpty()) {
4242 // We have a nested-name tag ('struct foo::bar').
4244 // Check for invalid 'foo::'.
4245 if (SS.isInvalid()) {
4250 // If this is a friend or a reference to a class in a dependent
4251 // context, don't try to make a decl for it.
4252 if (TUK == TUK_Friend || TUK == TUK_Reference) {
4253 DC = computeDeclContext(SS, false);
4260 if (RequireCompleteDeclContext(SS))
4261 return DeclPtrTy::make((Decl *)0);
4263 DC = computeDeclContext(SS, true);
4265 // Look-up name inside 'foo::'.
4267 LookupQualifiedName(R, DC, Name, LookupTagName, RedeclarationOnly);
4269 if (R.isAmbiguous()) {
4270 DiagnoseAmbiguousLookup(R, Name, NameLoc, SS.getRange());
4274 if (R.getKind() == LookupResult::Found)
4275 PrevDecl = dyn_cast<TagDecl>(R.getFoundDecl());
4277 // A tag 'foo::bar' must already exist.
4279 Diag(NameLoc, diag::err_not_tag_in_scope) << Name << SS.getRange();
4285 // If this is a named struct, check to see if there was a previous forward
4286 // declaration or definition.
4287 // FIXME: We're looking into outer scopes here, even when we
4288 // shouldn't be. Doing so can result in ambiguities that we
4289 // shouldn't be diagnosing.
4291 LookupName(R, S, Name, LookupTagName, RedeclarationOnly);
4292 if (R.isAmbiguous()) {
4293 DiagnoseAmbiguousLookup(R, Name, NameLoc);
4294 // FIXME: This is not best way to recover from case like:
4298 // causes needless "incomplete type" error later.
4303 PrevDecl = R.getAsSingleDecl(Context);
4305 if (!getLangOptions().CPlusPlus && TUK != TUK_Reference) {
4306 // FIXME: This makes sure that we ignore the contexts associated
4307 // with C structs, unions, and enums when looking for a matching
4308 // tag declaration or definition. See the similar lookup tweak
4309 // in Sema::LookupName; is there a better way to deal with this?
4310 while (isa<RecordDecl>(SearchDC) || isa<EnumDecl>(SearchDC))
4311 SearchDC = SearchDC->getParent();
4315 if (PrevDecl && PrevDecl->isTemplateParameter()) {
4316 // Maybe we will complain about the shadowed template parameter.
4317 DiagnoseTemplateParameterShadow(NameLoc, PrevDecl);
4318 // Just pretend that we didn't see the previous declaration.
4322 if (getLangOptions().CPlusPlus && Name && DC && StdNamespace &&
4323 DC->Equals(StdNamespace) && Name->isStr("bad_alloc")) {
4324 // This is a declaration of or a reference to "std::bad_alloc".
4325 isStdBadAlloc = true;
4327 if (!PrevDecl && StdBadAlloc) {
4328 // std::bad_alloc has been implicitly declared (but made invisible to
4329 // name lookup). Fill in this implicit declaration as the previous
4330 // declaration, so that the declarations get chained appropriately.
4331 PrevDecl = StdBadAlloc;
4336 if (TagDecl *PrevTagDecl = dyn_cast<TagDecl>(PrevDecl)) {
4337 // If this is a use of a previous tag, or if the tag is already declared
4338 // in the same scope (so that the definition/declaration completes or
4339 // rementions the tag), reuse the decl.
4340 if (TUK == TUK_Reference || TUK == TUK_Friend ||
4341 isDeclInScope(PrevDecl, SearchDC, S)) {
4342 // Make sure that this wasn't declared as an enum and now used as a
4343 // struct or something similar.
4344 if (!isAcceptableTagRedeclaration(PrevTagDecl, Kind, KWLoc, *Name)) {
4346 = (PrevTagDecl->getTagKind() != TagDecl::TK_enum &&
4347 Kind != TagDecl::TK_enum);
4349 Diag(KWLoc, diag::err_use_with_wrong_tag)
4351 << CodeModificationHint::CreateReplacement(SourceRange(KWLoc),
4352 PrevTagDecl->getKindName());
4354 Diag(KWLoc, diag::err_use_with_wrong_tag) << Name;
4355 Diag(PrevDecl->getLocation(), diag::note_previous_use);
4358 Kind = PrevTagDecl->getTagKind();
4360 // Recover by making this an anonymous redefinition.
4368 // If this is a use, just return the declaration we found.
4370 // FIXME: In the future, return a variant or some other clue
4371 // for the consumer of this Decl to know it doesn't own it.
4372 // For our current ASTs this shouldn't be a problem, but will
4373 // need to be changed with DeclGroups.
4374 if (TUK == TUK_Reference || TUK == TUK_Friend)
4375 return DeclPtrTy::make(PrevDecl);
4377 // Diagnose attempts to redefine a tag.
4378 if (TUK == TUK_Definition) {
4379 if (TagDecl *Def = PrevTagDecl->getDefinition(Context)) {
4380 // If we're defining a specialization and the previous definition
4381 // is from an implicit instantiation, don't emit an error
4382 // here; we'll catch this in the general case below.
4383 if (!isExplicitSpecialization ||
4384 !isa<CXXRecordDecl>(Def) ||
4385 cast<CXXRecordDecl>(Def)->getTemplateSpecializationKind()
4386 == TSK_ExplicitSpecialization) {
4387 Diag(NameLoc, diag::err_redefinition) << Name;
4388 Diag(Def->getLocation(), diag::note_previous_definition);
4389 // If this is a redefinition, recover by making this
4390 // struct be anonymous, which will make any later
4391 // references get the previous definition.
4397 // If the type is currently being defined, complain
4398 // about a nested redefinition.
4399 TagType *Tag = cast<TagType>(Context.getTagDeclType(PrevTagDecl));
4400 if (Tag->isBeingDefined()) {
4401 Diag(NameLoc, diag::err_nested_redefinition) << Name;
4402 Diag(PrevTagDecl->getLocation(),
4403 diag::note_previous_definition);
4410 // Okay, this is definition of a previously declared or referenced
4411 // tag PrevDecl. We're going to create a new Decl for it.
4414 // If we get here we have (another) forward declaration or we
4415 // have a definition. Just create a new decl.
4418 // If we get here, this is a definition of a new tag type in a nested
4419 // scope, e.g. "struct foo; void bar() { struct foo; }", just create a
4420 // new decl/type. We set PrevDecl to NULL so that the entities
4421 // have distinct types.
4424 // If we get here, we're going to create a new Decl. If PrevDecl
4425 // is non-NULL, it's a definition of the tag declared by
4426 // PrevDecl. If it's NULL, we have a new definition.
4428 // PrevDecl is a namespace, template, or anything else
4429 // that lives in the IDNS_Tag identifier namespace.
4430 if (isDeclInScope(PrevDecl, SearchDC, S)) {
4431 // The tag name clashes with a namespace name, issue an error and
4432 // recover by making this tag be anonymous.
4433 Diag(NameLoc, diag::err_redefinition_different_kind) << Name;
4434 Diag(PrevDecl->getLocation(), diag::note_previous_definition);
4439 // The existing declaration isn't relevant to us; we're in a
4440 // new scope, so clear out the previous declaration.
4444 } else if (TUK == TUK_Reference && SS.isEmpty() && Name &&
4445 (Kind != TagDecl::TK_enum || !getLangOptions().CPlusPlus)) {
4446 // C++ [basic.scope.pdecl]p5:
4447 // -- for an elaborated-type-specifier of the form
4449 // class-key identifier
4451 // if the elaborated-type-specifier is used in the
4452 // decl-specifier-seq or parameter-declaration-clause of a
4453 // function defined in namespace scope, the identifier is
4454 // declared as a class-name in the namespace that contains
4455 // the declaration; otherwise, except as a friend
4456 // declaration, the identifier is declared in the smallest
4457 // non-class, non-function-prototype scope that contains the
4460 // C99 6.7.2.3p8 has a similar (but not identical!) provision for
4461 // C structs and unions.
4463 // GNU C also supports this behavior as part of its incomplete
4464 // enum types extension, while GNU C++ does not.
4466 // Find the context where we'll be declaring the tag.
4467 // FIXME: We would like to maintain the current DeclContext as the
4469 while (SearchDC->isRecord())
4470 SearchDC = SearchDC->getParent();
4472 // Find the scope where we'll be declaring the tag.
4473 while (S->isClassScope() ||
4474 (getLangOptions().CPlusPlus && S->isFunctionPrototypeScope()) ||
4475 ((S->getFlags() & Scope::DeclScope) == 0) ||
4477 ((DeclContext *)S->getEntity())->isTransparentContext()))
4480 } else if (TUK == TUK_Friend && SS.isEmpty() && Name) {
4481 // C++ [namespace.memdef]p3:
4482 // If a friend declaration in a non-local class first declares a
4483 // class or function, the friend class or function is a member of
4484 // the innermost enclosing namespace.
4485 while (!SearchDC->isFileContext())
4486 SearchDC = SearchDC->getParent();
4488 // The entity of a decl scope is a DeclContext; see PushDeclContext.
4489 while (S->getEntity() != SearchDC)
4495 // If there is an identifier, use the location of the identifier as the
4496 // location of the decl, otherwise use the location of the struct/union
4498 SourceLocation Loc = NameLoc.isValid() ? NameLoc : KWLoc;
4500 // Otherwise, create a new declaration. If there is a previous
4501 // declaration of the same entity, the two will be linked via
4505 if (Kind == TagDecl::TK_enum) {
4506 // FIXME: Tag decls should be chained to any simultaneous vardecls, e.g.:
4507 // enum X { A, B, C } D; D should chain to X.
4508 New = EnumDecl::Create(Context, SearchDC, Loc, Name, KWLoc,
4509 cast_or_null<EnumDecl>(PrevDecl));
4510 // If this is an undefined enum, warn.
4511 if (TUK != TUK_Definition && !Invalid) {
4512 unsigned DK = getLangOptions().CPlusPlus? diag::err_forward_ref_enum
4513 : diag::ext_forward_ref_enum;
4517 // struct/union/class
4519 // FIXME: Tag decls should be chained to any simultaneous vardecls, e.g.:
4520 // struct X { int A; } D; D should chain to X.
4521 if (getLangOptions().CPlusPlus) {
4522 // FIXME: Look for a way to use RecordDecl for simple structs.
4523 New = CXXRecordDecl::Create(Context, Kind, SearchDC, Loc, Name, KWLoc,
4524 cast_or_null<CXXRecordDecl>(PrevDecl));
4526 if (isStdBadAlloc && (!StdBadAlloc || StdBadAlloc->isImplicit()))
4527 StdBadAlloc = cast<CXXRecordDecl>(New);
4529 New = RecordDecl::Create(Context, Kind, SearchDC, Loc, Name, KWLoc,
4530 cast_or_null<RecordDecl>(PrevDecl));
4533 if (Kind != TagDecl::TK_enum) {
4534 // Handle #pragma pack: if the #pragma pack stack has non-default
4535 // alignment, make up a packed attribute for this decl. These
4536 // attributes are checked when the ASTContext lays out the
4539 // It is important for implementing the correct semantics that this
4540 // happen here (in act on tag decl). The #pragma pack stack is
4541 // maintained as a result of parser callbacks which can occur at
4542 // many points during the parsing of a struct declaration (because
4543 // the #pragma tokens are effectively skipped over during the
4544 // parsing of the struct).
4545 if (unsigned Alignment = getPragmaPackAlignment())
4546 New->addAttr(::new (Context) PragmaPackAttr(Alignment * 8));
4549 if (getLangOptions().CPlusPlus && SS.isEmpty() && Name && !Invalid) {
4550 // C++ [dcl.typedef]p3:
4551 // [...] Similarly, in a given scope, a class or enumeration
4552 // shall not be declared with the same name as a typedef-name
4553 // that is declared in that scope and refers to a type other
4554 // than the class or enumeration itself.
4555 LookupResult Lookup;
4556 LookupName(Lookup, S, Name, LookupOrdinaryName, true);
4557 TypedefDecl *PrevTypedef = 0;
4558 if (NamedDecl *Prev = Lookup.getAsSingleDecl(Context))
4559 PrevTypedef = dyn_cast<TypedefDecl>(Prev);
4561 NamedDecl *PrevTypedefNamed = PrevTypedef;
4562 if (PrevTypedef && isDeclInScope(PrevTypedefNamed, SearchDC, S) &&
4563 Context.getCanonicalType(Context.getTypeDeclType(PrevTypedef)) !=
4564 Context.getCanonicalType(Context.getTypeDeclType(New))) {
4565 Diag(Loc, diag::err_tag_definition_of_typedef)
4566 << Context.getTypeDeclType(New)
4567 << PrevTypedef->getUnderlyingType();
4568 Diag(PrevTypedef->getLocation(), diag::note_previous_definition);
4573 // If this is a specialization of a member class (of a class template),
4574 // check the specialization.
4575 if (isExplicitSpecialization && CheckMemberSpecialization(New, PrevDecl))
4579 New->setInvalidDecl();
4582 ProcessDeclAttributeList(S, New, Attr);
4584 // If we're declaring or defining a tag in function prototype scope
4585 // in C, note that this type can only be used within the function.
4586 if (Name && S->isFunctionPrototypeScope() && !getLangOptions().CPlusPlus)
4587 Diag(Loc, diag::warn_decl_in_param_list) << Context.getTagDeclType(New);
4589 // Set the lexical context. If the tag has a C++ scope specifier, the
4590 // lexical context will be different from the semantic context.
4591 New->setLexicalDeclContext(CurContext);
4593 // Mark this as a friend decl if applicable.
4594 if (TUK == TUK_Friend)
4595 New->setObjectOfFriendDecl(/* PreviouslyDeclared = */ PrevDecl != NULL);
4597 // Set the access specifier.
4598 if (!Invalid && TUK != TUK_Friend)
4599 SetMemberAccessSpecifier(New, PrevDecl, AS);
4601 if (TUK == TUK_Definition)
4602 New->startDefinition();
4604 // If this has an identifier, add it to the scope stack.
4605 if (TUK == TUK_Friend) {
4606 // We might be replacing an existing declaration in the lookup tables;
4607 // if so, borrow its access specifier.
4609 New->setAccess(PrevDecl->getAccess());
4611 // Friend tag decls are visible in fairly strange ways.
4612 if (!CurContext->isDependentContext()) {
4613 DeclContext *DC = New->getDeclContext()->getLookupContext();
4614 DC->makeDeclVisibleInContext(New, /* Recoverable = */ false);
4615 if (Scope *EnclosingScope = getScopeForDeclContext(S, DC))
4616 PushOnScopeChains(New, EnclosingScope, /* AddToContext = */ false);
4619 S = getNonFieldDeclScope(S);
4620 PushOnScopeChains(New, S);
4622 CurContext->addDecl(New);
4625 // If this is the C FILE type, notify the AST context.
4626 if (IdentifierInfo *II = New->getIdentifier())
4627 if (!New->isInvalidDecl() &&
4628 New->getDeclContext()->getLookupContext()->isTranslationUnit() &&
4630 Context.setFILEDecl(New);
4633 return DeclPtrTy::make(New);
4636 void Sema::ActOnTagStartDefinition(Scope *S, DeclPtrTy TagD) {
4637 AdjustDeclIfTemplate(TagD);
4638 TagDecl *Tag = cast<TagDecl>(TagD.getAs<Decl>());
4640 // Enter the tag context.
4641 PushDeclContext(S, Tag);
4643 if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(Tag)) {
4644 FieldCollector->StartClass();
4646 if (Record->getIdentifier()) {
4648 // [...] The class-name is also inserted into the scope of the
4649 // class itself; this is known as the injected-class-name. For
4650 // purposes of access checking, the injected-class-name is treated
4651 // as if it were a public member name.
4652 CXXRecordDecl *InjectedClassName
4653 = CXXRecordDecl::Create(Context, Record->getTagKind(),
4654 CurContext, Record->getLocation(),
4655 Record->getIdentifier(),
4656 Record->getTagKeywordLoc(),
4658 InjectedClassName->setImplicit();
4659 InjectedClassName->setAccess(AS_public);
4660 if (ClassTemplateDecl *Template = Record->getDescribedClassTemplate())
4661 InjectedClassName->setDescribedClassTemplate(Template);
4662 PushOnScopeChains(InjectedClassName, S);
4663 assert(InjectedClassName->isInjectedClassName() &&
4664 "Broken injected-class-name");
4669 void Sema::ActOnTagFinishDefinition(Scope *S, DeclPtrTy TagD,
4670 SourceLocation RBraceLoc) {
4671 AdjustDeclIfTemplate(TagD);
4672 TagDecl *Tag = cast<TagDecl>(TagD.getAs<Decl>());
4673 Tag->setRBraceLoc(RBraceLoc);
4675 if (isa<CXXRecordDecl>(Tag))
4676 FieldCollector->FinishClass();
4678 // Exit this scope of this tag's definition.
4681 // Notify the consumer that we've defined a tag.
4682 Consumer.HandleTagDeclDefinition(Tag);
4685 // Note that FieldName may be null for anonymous bitfields.
4686 bool Sema::VerifyBitField(SourceLocation FieldLoc, IdentifierInfo *FieldName,
4687 QualType FieldTy, const Expr *BitWidth,
4689 // Default to true; that shouldn't confuse checks for emptiness
4693 // C99 6.7.2.1p4 - verify the field type.
4694 // C++ 9.6p3: A bit-field shall have integral or enumeration type.
4695 if (!FieldTy->isDependentType() && !FieldTy->isIntegralType()) {
4696 // Handle incomplete types with specific error.
4697 if (RequireCompleteType(FieldLoc, FieldTy, diag::err_field_incomplete))
4700 return Diag(FieldLoc, diag::err_not_integral_type_bitfield)
4701 << FieldName << FieldTy << BitWidth->getSourceRange();
4702 return Diag(FieldLoc, diag::err_not_integral_type_anon_bitfield)
4703 << FieldTy << BitWidth->getSourceRange();
4706 // If the bit-width is type- or value-dependent, don't try to check
4708 if (BitWidth->isValueDependent() || BitWidth->isTypeDependent())
4712 if (VerifyIntegerConstantExpression(BitWidth, &Value))
4715 if (Value != 0 && ZeroWidth)
4718 // Zero-width bitfield is ok for anonymous field.
4719 if (Value == 0 && FieldName)
4720 return Diag(FieldLoc, diag::err_bitfield_has_zero_width) << FieldName;
4722 if (Value.isSigned() && Value.isNegative()) {
4724 return Diag(FieldLoc, diag::err_bitfield_has_negative_width)
4725 << FieldName << Value.toString(10);
4726 return Diag(FieldLoc, diag::err_anon_bitfield_has_negative_width)
4727 << Value.toString(10);
4730 if (!FieldTy->isDependentType()) {
4731 uint64_t TypeSize = Context.getTypeSize(FieldTy);
4732 if (Value.getZExtValue() > TypeSize) {
4734 return Diag(FieldLoc, diag::err_bitfield_width_exceeds_type_size)
4735 << FieldName << (unsigned)TypeSize;
4736 return Diag(FieldLoc, diag::err_anon_bitfield_width_exceeds_type_size)
4737 << (unsigned)TypeSize;
4744 /// ActOnField - Each field of a struct/union/class is passed into this in order
4745 /// to create a FieldDecl object for it.
4746 Sema::DeclPtrTy Sema::ActOnField(Scope *S, DeclPtrTy TagD,
4747 SourceLocation DeclStart,
4748 Declarator &D, ExprTy *BitfieldWidth) {
4749 FieldDecl *Res = HandleField(S, cast_or_null<RecordDecl>(TagD.getAs<Decl>()),
4750 DeclStart, D, static_cast<Expr*>(BitfieldWidth),
4752 return DeclPtrTy::make(Res);
4755 /// HandleField - Analyze a field of a C struct or a C++ data member.
4757 FieldDecl *Sema::HandleField(Scope *S, RecordDecl *Record,
4758 SourceLocation DeclStart,
4759 Declarator &D, Expr *BitWidth,
4760 AccessSpecifier AS) {
4761 IdentifierInfo *II = D.getIdentifier();
4762 SourceLocation Loc = DeclStart;
4763 if (II) Loc = D.getIdentifierLoc();
4765 DeclaratorInfo *DInfo = 0;
4766 QualType T = GetTypeForDeclarator(D, S, &DInfo);
4767 if (getLangOptions().CPlusPlus)
4768 CheckExtraCXXDefaultArguments(D);
4770 DiagnoseFunctionSpecifiers(D);
4772 if (D.getDeclSpec().isThreadSpecified())
4773 Diag(D.getDeclSpec().getThreadSpecLoc(), diag::err_invalid_thread);
4775 NamedDecl *PrevDecl = LookupSingleName(S, II, LookupMemberName, true);
4777 if (PrevDecl && PrevDecl->isTemplateParameter()) {
4778 // Maybe we will complain about the shadowed template parameter.
4779 DiagnoseTemplateParameterShadow(D.getIdentifierLoc(), PrevDecl);
4780 // Just pretend that we didn't see the previous declaration.
4784 if (PrevDecl && !isDeclInScope(PrevDecl, Record, S))
4788 = (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_mutable);
4789 SourceLocation TSSL = D.getSourceRange().getBegin();
4791 = CheckFieldDecl(II, T, DInfo, Record, Loc, Mutable, BitWidth, TSSL,
4793 if (NewFD->isInvalidDecl() && PrevDecl) {
4794 // Don't introduce NewFD into scope; there's already something
4795 // with the same name in the same scope.
4797 PushOnScopeChains(NewFD, S);
4799 Record->addDecl(NewFD);
4804 /// \brief Build a new FieldDecl and check its well-formedness.
4806 /// This routine builds a new FieldDecl given the fields name, type,
4807 /// record, etc. \p PrevDecl should refer to any previous declaration
4808 /// with the same name and in the same scope as the field to be
4811 /// \returns a new FieldDecl.
4813 /// \todo The Declarator argument is a hack. It will be removed once
4814 FieldDecl *Sema::CheckFieldDecl(DeclarationName Name, QualType T,
4815 DeclaratorInfo *DInfo,
4816 RecordDecl *Record, SourceLocation Loc,
4817 bool Mutable, Expr *BitWidth,
4818 SourceLocation TSSL,
4819 AccessSpecifier AS, NamedDecl *PrevDecl,
4821 IdentifierInfo *II = Name.getAsIdentifierInfo();
4822 bool InvalidDecl = false;
4823 if (D) InvalidDecl = D->isInvalidType();
4825 // If we receive a broken type, recover by assuming 'int' and
4826 // marking this declaration as invalid.
4832 // C99 6.7.2.1p8: A member of a structure or union may have any type other
4833 // than a variably modified type.
4834 if (T->isVariablyModifiedType()) {
4835 bool SizeIsNegative;
4836 QualType FixedTy = TryToFixInvalidVariablyModifiedType(T, Context,
4838 if (!FixedTy.isNull()) {
4839 Diag(Loc, diag::warn_illegal_constant_array_size);
4843 Diag(Loc, diag::err_typecheck_negative_array_size);
4845 Diag(Loc, diag::err_typecheck_field_variable_size);
4850 // Fields can not have abstract class types
4851 if (RequireNonAbstractType(Loc, T, diag::err_abstract_type_in_decl,
4855 bool ZeroWidth = false;
4856 // If this is declared as a bit-field, check the bit-field.
4857 if (BitWidth && VerifyBitField(Loc, II, T, BitWidth, &ZeroWidth)) {
4859 DeleteExpr(BitWidth);
4864 FieldDecl *NewFD = FieldDecl::Create(Context, Record, Loc, II, T, DInfo,
4867 NewFD->setInvalidDecl();
4869 if (PrevDecl && !isa<TagDecl>(PrevDecl)) {
4870 Diag(Loc, diag::err_duplicate_member) << II;
4871 Diag(PrevDecl->getLocation(), diag::note_previous_declaration);
4872 NewFD->setInvalidDecl();
4875 if (getLangOptions().CPlusPlus) {
4876 QualType EltTy = Context.getBaseElementType(T);
4878 CXXRecordDecl* CXXRecord = cast<CXXRecordDecl>(Record);
4880 if (!T->isPODType())
4881 CXXRecord->setPOD(false);
4883 CXXRecord->setEmpty(false);
4885 if (const RecordType *RT = EltTy->getAs<RecordType>()) {
4886 CXXRecordDecl* RDecl = cast<CXXRecordDecl>(RT->getDecl());
4888 if (!RDecl->hasTrivialConstructor())
4889 CXXRecord->setHasTrivialConstructor(false);
4890 if (!RDecl->hasTrivialCopyConstructor())
4891 CXXRecord->setHasTrivialCopyConstructor(false);
4892 if (!RDecl->hasTrivialCopyAssignment())
4893 CXXRecord->setHasTrivialCopyAssignment(false);
4894 if (!RDecl->hasTrivialDestructor())
4895 CXXRecord->setHasTrivialDestructor(false);
4897 // C++ 9.5p1: An object of a class with a non-trivial
4898 // constructor, a non-trivial copy constructor, a non-trivial
4899 // destructor, or a non-trivial copy assignment operator
4900 // cannot be a member of a union, nor can an array of such
4902 // TODO: C++0x alters this restriction significantly.
4903 if (Record->isUnion()) {
4904 // We check for copy constructors before constructors
4905 // because otherwise we'll never get complaints about
4906 // copy constructors.
4908 const CXXSpecialMember invalid = (CXXSpecialMember) -1;
4910 CXXSpecialMember member;
4911 if (!RDecl->hasTrivialCopyConstructor())
4912 member = CXXCopyConstructor;
4913 else if (!RDecl->hasTrivialConstructor())
4914 member = CXXDefaultConstructor;
4915 else if (!RDecl->hasTrivialCopyAssignment())
4916 member = CXXCopyAssignment;
4917 else if (!RDecl->hasTrivialDestructor())
4918 member = CXXDestructor;
4922 if (member != invalid) {
4923 Diag(Loc, diag::err_illegal_union_member) << Name << member;
4924 DiagnoseNontrivial(RT, member);
4925 NewFD->setInvalidDecl();
4931 // FIXME: We need to pass in the attributes given an AST
4932 // representation, not a parser representation.
4934 // FIXME: What to pass instead of TUScope?
4935 ProcessDeclAttributes(TUScope, NewFD, *D);
4937 if (T.isObjCGCWeak())
4938 Diag(Loc, diag::warn_attribute_weak_on_field);
4940 NewFD->setAccess(AS);
4942 // C++ [dcl.init.aggr]p1:
4943 // An aggregate is an array or a class (clause 9) with [...] no
4944 // private or protected non-static data members (clause 11).
4945 // A POD must be an aggregate.
4946 if (getLangOptions().CPlusPlus &&
4947 (AS == AS_private || AS == AS_protected)) {
4948 CXXRecordDecl *CXXRecord = cast<CXXRecordDecl>(Record);
4949 CXXRecord->setAggregate(false);
4950 CXXRecord->setPOD(false);
4956 /// DiagnoseNontrivial - Given that a class has a non-trivial
4957 /// special member, figure out why.
4958 void Sema::DiagnoseNontrivial(const RecordType* T, CXXSpecialMember member) {
4960 CXXRecordDecl* RD = cast<CXXRecordDecl>(T->getDecl());
4962 // Check whether the member was user-declared.
4964 case CXXDefaultConstructor:
4965 if (RD->hasUserDeclaredConstructor()) {
4966 typedef CXXRecordDecl::ctor_iterator ctor_iter;
4967 for (ctor_iter ci = RD->ctor_begin(), ce = RD->ctor_end(); ci != ce;++ci){
4968 const FunctionDecl *body = 0;
4971 !cast<CXXConstructorDecl>(body)->isImplicitlyDefined(Context)) {
4972 SourceLocation CtorLoc = ci->getLocation();
4973 Diag(CtorLoc, diag::note_nontrivial_user_defined) << QT << member;
4978 assert(0 && "found no user-declared constructors");
4983 case CXXCopyConstructor:
4984 if (RD->hasUserDeclaredCopyConstructor()) {
4985 SourceLocation CtorLoc =
4986 RD->getCopyConstructor(Context, 0)->getLocation();
4987 Diag(CtorLoc, diag::note_nontrivial_user_defined) << QT << member;
4992 case CXXCopyAssignment:
4993 if (RD->hasUserDeclaredCopyAssignment()) {
4994 // FIXME: this should use the location of the copy
4995 // assignment, not the type.
4996 SourceLocation TyLoc = RD->getSourceRange().getBegin();
4997 Diag(TyLoc, diag::note_nontrivial_user_defined) << QT << member;
5003 if (RD->hasUserDeclaredDestructor()) {
5004 SourceLocation DtorLoc = RD->getDestructor(Context)->getLocation();
5005 Diag(DtorLoc, diag::note_nontrivial_user_defined) << QT << member;
5011 typedef CXXRecordDecl::base_class_iterator base_iter;
5013 // Virtual bases and members inhibit trivial copying/construction,
5014 // but not trivial destruction.
5015 if (member != CXXDestructor) {
5016 // Check for virtual bases. vbases includes indirect virtual bases,
5017 // so we just iterate through the direct bases.
5018 for (base_iter bi = RD->bases_begin(), be = RD->bases_end(); bi != be; ++bi)
5019 if (bi->isVirtual()) {
5020 SourceLocation BaseLoc = bi->getSourceRange().getBegin();
5021 Diag(BaseLoc, diag::note_nontrivial_has_virtual) << QT << 1;
5025 // Check for virtual methods.
5026 typedef CXXRecordDecl::method_iterator meth_iter;
5027 for (meth_iter mi = RD->method_begin(), me = RD->method_end(); mi != me;
5029 if (mi->isVirtual()) {
5030 SourceLocation MLoc = mi->getSourceRange().getBegin();
5031 Diag(MLoc, diag::note_nontrivial_has_virtual) << QT << 0;
5037 bool (CXXRecordDecl::*hasTrivial)() const;
5039 case CXXDefaultConstructor:
5040 hasTrivial = &CXXRecordDecl::hasTrivialConstructor; break;
5041 case CXXCopyConstructor:
5042 hasTrivial = &CXXRecordDecl::hasTrivialCopyConstructor; break;
5043 case CXXCopyAssignment:
5044 hasTrivial = &CXXRecordDecl::hasTrivialCopyAssignment; break;
5046 hasTrivial = &CXXRecordDecl::hasTrivialDestructor; break;
5048 assert(0 && "unexpected special member"); return;
5051 // Check for nontrivial bases (and recurse).
5052 for (base_iter bi = RD->bases_begin(), be = RD->bases_end(); bi != be; ++bi) {
5053 const RecordType *BaseRT = bi->getType()->getAs<RecordType>();
5054 assert(BaseRT && "Don't know how to handle dependent bases");
5055 CXXRecordDecl *BaseRecTy = cast<CXXRecordDecl>(BaseRT->getDecl());
5056 if (!(BaseRecTy->*hasTrivial)()) {
5057 SourceLocation BaseLoc = bi->getSourceRange().getBegin();
5058 Diag(BaseLoc, diag::note_nontrivial_has_nontrivial) << QT << 1 << member;
5059 DiagnoseNontrivial(BaseRT, member);
5064 // Check for nontrivial members (and recurse).
5065 typedef RecordDecl::field_iterator field_iter;
5066 for (field_iter fi = RD->field_begin(), fe = RD->field_end(); fi != fe;
5068 QualType EltTy = Context.getBaseElementType((*fi)->getType());
5069 if (const RecordType *EltRT = EltTy->getAs<RecordType>()) {
5070 CXXRecordDecl* EltRD = cast<CXXRecordDecl>(EltRT->getDecl());
5072 if (!(EltRD->*hasTrivial)()) {
5073 SourceLocation FLoc = (*fi)->getLocation();
5074 Diag(FLoc, diag::note_nontrivial_has_nontrivial) << QT << 0 << member;
5075 DiagnoseNontrivial(EltRT, member);
5081 assert(0 && "found no explanation for non-trivial member");
5084 /// TranslateIvarVisibility - Translate visibility from a token ID to an
5086 static ObjCIvarDecl::AccessControl
5087 TranslateIvarVisibility(tok::ObjCKeywordKind ivarVisibility) {
5088 switch (ivarVisibility) {
5089 default: assert(0 && "Unknown visitibility kind");
5090 case tok::objc_private: return ObjCIvarDecl::Private;
5091 case tok::objc_public: return ObjCIvarDecl::Public;
5092 case tok::objc_protected: return ObjCIvarDecl::Protected;
5093 case tok::objc_package: return ObjCIvarDecl::Package;
5097 /// ActOnIvar - Each ivar field of an objective-c class is passed into this
5098 /// in order to create an IvarDecl object for it.
5099 Sema::DeclPtrTy Sema::ActOnIvar(Scope *S,
5100 SourceLocation DeclStart,
5102 Declarator &D, ExprTy *BitfieldWidth,
5103 tok::ObjCKeywordKind Visibility) {
5105 IdentifierInfo *II = D.getIdentifier();
5106 Expr *BitWidth = (Expr*)BitfieldWidth;
5107 SourceLocation Loc = DeclStart;
5108 if (II) Loc = D.getIdentifierLoc();
5110 // FIXME: Unnamed fields can be handled in various different ways, for
5111 // example, unnamed unions inject all members into the struct namespace!
5113 DeclaratorInfo *DInfo = 0;
5114 QualType T = GetTypeForDeclarator(D, S, &DInfo);
5117 // 6.7.2.1p3, 6.7.2.1p4
5118 if (VerifyBitField(Loc, II, T, BitWidth)) {
5120 DeleteExpr(BitWidth);
5130 // C99 6.7.2.1p8: A member of a structure or union may have any type other
5131 // than a variably modified type.
5132 if (T->isVariablyModifiedType()) {
5133 Diag(Loc, diag::err_typecheck_ivar_variable_size);
5137 // Get the visibility (access control) for this ivar.
5138 ObjCIvarDecl::AccessControl ac =
5139 Visibility != tok::objc_not_keyword ? TranslateIvarVisibility(Visibility)
5140 : ObjCIvarDecl::None;
5141 // Must set ivar's DeclContext to its enclosing interface.
5142 Decl *EnclosingDecl = IntfDecl.getAs<Decl>();
5143 DeclContext *EnclosingContext;
5144 if (ObjCImplementationDecl *IMPDecl =
5145 dyn_cast<ObjCImplementationDecl>(EnclosingDecl)) {
5146 // Case of ivar declared in an implementation. Context is that of its class.
5147 ObjCInterfaceDecl* IDecl = IMPDecl->getClassInterface();
5148 assert(IDecl && "No class- ActOnIvar");
5149 EnclosingContext = cast_or_null<DeclContext>(IDecl);
5151 EnclosingContext = dyn_cast<DeclContext>(EnclosingDecl);
5152 assert(EnclosingContext && "null DeclContext for ivar - ActOnIvar");
5154 // Construct the decl.
5155 ObjCIvarDecl *NewID = ObjCIvarDecl::Create(Context,
5156 EnclosingContext, Loc, II, T,
5157 DInfo, ac, (Expr *)BitfieldWidth);
5160 NamedDecl *PrevDecl = LookupSingleName(S, II, LookupMemberName, true);
5161 if (PrevDecl && isDeclInScope(PrevDecl, EnclosingContext, S)
5162 && !isa<TagDecl>(PrevDecl)) {
5163 Diag(Loc, diag::err_duplicate_member) << II;
5164 Diag(PrevDecl->getLocation(), diag::note_previous_declaration);
5165 NewID->setInvalidDecl();
5169 // Process attributes attached to the ivar.
5170 ProcessDeclAttributes(S, NewID, D);
5172 if (D.isInvalidType())
5173 NewID->setInvalidDecl();
5176 // FIXME: When interfaces are DeclContexts, we'll need to add
5177 // these to the interface.
5178 S->AddDecl(DeclPtrTy::make(NewID));
5179 IdResolver.AddDecl(NewID);
5182 return DeclPtrTy::make(NewID);
5185 void Sema::ActOnFields(Scope* S,
5186 SourceLocation RecLoc, DeclPtrTy RecDecl,
5187 DeclPtrTy *Fields, unsigned NumFields,
5188 SourceLocation LBrac, SourceLocation RBrac,
5189 AttributeList *Attr) {
5190 Decl *EnclosingDecl = RecDecl.getAs<Decl>();
5191 assert(EnclosingDecl && "missing record or interface decl");
5193 // If the decl this is being inserted into is invalid, then it may be a
5194 // redeclaration or some other bogus case. Don't try to add fields to it.
5195 if (EnclosingDecl->isInvalidDecl()) {
5196 // FIXME: Deallocate fields?
5201 // Verify that all the fields are okay.
5202 unsigned NumNamedMembers = 0;
5203 llvm::SmallVector<FieldDecl*, 32> RecFields;
5205 RecordDecl *Record = dyn_cast<RecordDecl>(EnclosingDecl);
5206 for (unsigned i = 0; i != NumFields; ++i) {
5207 FieldDecl *FD = cast<FieldDecl>(Fields[i].getAs<Decl>());
5209 // Get the type for the field.
5210 Type *FDTy = FD->getType().getTypePtr();
5212 if (!FD->isAnonymousStructOrUnion()) {
5213 // Remember all fields written by the user.
5214 RecFields.push_back(FD);
5217 // If the field is already invalid for some reason, don't emit more
5218 // diagnostics about it.
5219 if (FD->isInvalidDecl())
5223 // A structure or union shall not contain a member with
5224 // incomplete or function type (hence, a structure shall not
5225 // contain an instance of itself, but may contain a pointer to
5226 // an instance of itself), except that the last member of a
5227 // structure with more than one named member may have incomplete
5228 // array type; such a structure (and any union containing,
5229 // possibly recursively, a member that is such a structure)
5230 // shall not be a member of a structure or an element of an
5232 if (FDTy->isFunctionType()) {
5233 // Field declared as a function.
5234 Diag(FD->getLocation(), diag::err_field_declared_as_function)
5235 << FD->getDeclName();
5236 FD->setInvalidDecl();
5237 EnclosingDecl->setInvalidDecl();
5239 } else if (FDTy->isIncompleteArrayType() && i == NumFields - 1 &&
5240 Record && Record->isStruct()) {
5241 // Flexible array member.
5242 if (NumNamedMembers < 1) {
5243 Diag(FD->getLocation(), diag::err_flexible_array_empty_struct)
5244 << FD->getDeclName();
5245 FD->setInvalidDecl();
5246 EnclosingDecl->setInvalidDecl();
5249 // Okay, we have a legal flexible array member at the end of the struct.
5251 Record->setHasFlexibleArrayMember(true);
5252 } else if (!FDTy->isDependentType() &&
5253 RequireCompleteType(FD->getLocation(), FD->getType(),
5254 diag::err_field_incomplete)) {
5256 FD->setInvalidDecl();
5257 EnclosingDecl->setInvalidDecl();
5259 } else if (const RecordType *FDTTy = FDTy->getAs<RecordType>()) {
5260 if (FDTTy->getDecl()->hasFlexibleArrayMember()) {
5261 // If this is a member of a union, then entire union becomes "flexible".
5262 if (Record && Record->isUnion()) {
5263 Record->setHasFlexibleArrayMember(true);
5265 // If this is a struct/class and this is not the last element, reject
5266 // it. Note that GCC supports variable sized arrays in the middle of
5268 if (i != NumFields-1)
5269 Diag(FD->getLocation(), diag::ext_variable_sized_type_in_struct)
5270 << FD->getDeclName() << FD->getType();
5272 // We support flexible arrays at the end of structs in
5273 // other structs as an extension.
5274 Diag(FD->getLocation(), diag::ext_flexible_array_in_struct)
5275 << FD->getDeclName();
5277 Record->setHasFlexibleArrayMember(true);
5281 if (Record && FDTTy->getDecl()->hasObjectMember())
5282 Record->setHasObjectMember(true);
5283 } else if (FDTy->isObjCInterfaceType()) {
5284 /// A field cannot be an Objective-c object
5285 Diag(FD->getLocation(), diag::err_statically_allocated_object);
5286 FD->setInvalidDecl();
5287 EnclosingDecl->setInvalidDecl();
5289 } else if (getLangOptions().ObjC1 &&
5290 getLangOptions().getGCMode() != LangOptions::NonGC &&
5292 (FD->getType()->isObjCObjectPointerType() ||
5293 FD->getType().isObjCGCStrong()))
5294 Record->setHasObjectMember(true);
5295 // Keep track of the number of named members.
5296 if (FD->getIdentifier())
5300 // Okay, we successfully defined 'Record'.
5302 Record->completeDefinition(Context);
5304 ObjCIvarDecl **ClsFields =
5305 reinterpret_cast<ObjCIvarDecl**>(RecFields.data());
5306 if (ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(EnclosingDecl)) {
5307 ID->setIVarList(ClsFields, RecFields.size(), Context);
5308 ID->setLocEnd(RBrac);
5309 // Add ivar's to class's DeclContext.
5310 for (unsigned i = 0, e = RecFields.size(); i != e; ++i) {
5311 ClsFields[i]->setLexicalDeclContext(ID);
5312 ID->addDecl(ClsFields[i]);
5314 // Must enforce the rule that ivars in the base classes may not be
5316 if (ID->getSuperClass()) {
5317 for (ObjCInterfaceDecl::ivar_iterator IVI = ID->ivar_begin(),
5318 IVE = ID->ivar_end(); IVI != IVE; ++IVI) {
5319 ObjCIvarDecl* Ivar = (*IVI);
5321 if (IdentifierInfo *II = Ivar->getIdentifier()) {
5322 ObjCIvarDecl* prevIvar =
5323 ID->getSuperClass()->lookupInstanceVariable(II);
5325 Diag(Ivar->getLocation(), diag::err_duplicate_member) << II;
5326 Diag(prevIvar->getLocation(), diag::note_previous_declaration);
5331 } else if (ObjCImplementationDecl *IMPDecl =
5332 dyn_cast<ObjCImplementationDecl>(EnclosingDecl)) {
5333 assert(IMPDecl && "ActOnFields - missing ObjCImplementationDecl");
5334 for (unsigned I = 0, N = RecFields.size(); I != N; ++I)
5335 // Ivar declared in @implementation never belongs to the implementation.
5336 // Only it is in implementation's lexical context.
5337 ClsFields[I]->setLexicalDeclContext(IMPDecl);
5338 CheckImplementationIvars(IMPDecl, ClsFields, RecFields.size(), RBrac);
5343 ProcessDeclAttributeList(S, Record, Attr);
5346 EnumConstantDecl *Sema::CheckEnumConstant(EnumDecl *Enum,
5347 EnumConstantDecl *LastEnumConst,
5348 SourceLocation IdLoc,
5351 Expr *Val = (Expr *)val.get();
5353 llvm::APSInt EnumVal(32);
5355 if (Val && !Val->isTypeDependent()) {
5356 // Make sure to promote the operand type to int.
5357 UsualUnaryConversions(Val);
5358 if (Val != val.get()) {
5363 // C99 6.7.2.2p2: Make sure we have an integer constant expression.
5364 SourceLocation ExpLoc;
5365 if (!Val->isValueDependent() &&
5366 VerifyIntegerConstantExpression(Val, &EnumVal)) {
5369 EltTy = Val->getType();
5374 if (LastEnumConst) {
5375 // Assign the last value + 1.
5376 EnumVal = LastEnumConst->getInitVal();
5379 // Check for overflow on increment.
5380 if (EnumVal < LastEnumConst->getInitVal())
5381 Diag(IdLoc, diag::warn_enum_value_overflow);
5383 EltTy = LastEnumConst->getType();
5385 // First value, set to zero.
5386 EltTy = Context.IntTy;
5387 EnumVal.zextOrTrunc(static_cast<uint32_t>(Context.getTypeSize(EltTy)));
5392 return EnumConstantDecl::Create(Context, Enum, IdLoc, Id, EltTy,
5397 Sema::DeclPtrTy Sema::ActOnEnumConstant(Scope *S, DeclPtrTy theEnumDecl,
5398 DeclPtrTy lastEnumConst,
5399 SourceLocation IdLoc,
5401 SourceLocation EqualLoc, ExprTy *val) {
5402 EnumDecl *TheEnumDecl = cast<EnumDecl>(theEnumDecl.getAs<Decl>());
5403 EnumConstantDecl *LastEnumConst =
5404 cast_or_null<EnumConstantDecl>(lastEnumConst.getAs<Decl>());
5405 Expr *Val = static_cast<Expr*>(val);
5407 // The scope passed in may not be a decl scope. Zip up the scope tree until
5408 // we find one that is.
5409 S = getNonFieldDeclScope(S);
5411 // Verify that there isn't already something declared with this name in this
5413 NamedDecl *PrevDecl = LookupSingleName(S, Id, LookupOrdinaryName);
5414 if (PrevDecl && PrevDecl->isTemplateParameter()) {
5415 // Maybe we will complain about the shadowed template parameter.
5416 DiagnoseTemplateParameterShadow(IdLoc, PrevDecl);
5417 // Just pretend that we didn't see the previous declaration.
5422 // When in C++, we may get a TagDecl with the same name; in this case the
5423 // enum constant will 'hide' the tag.
5424 assert((getLangOptions().CPlusPlus || !isa<TagDecl>(PrevDecl)) &&
5425 "Received TagDecl when not in C++!");
5426 if (!isa<TagDecl>(PrevDecl) && isDeclInScope(PrevDecl, CurContext, S)) {
5427 if (isa<EnumConstantDecl>(PrevDecl))
5428 Diag(IdLoc, diag::err_redefinition_of_enumerator) << Id;
5430 Diag(IdLoc, diag::err_redefinition) << Id;
5431 Diag(PrevDecl->getLocation(), diag::note_previous_definition);
5432 if (Val) Val->Destroy(Context);
5437 EnumConstantDecl *New = CheckEnumConstant(TheEnumDecl, LastEnumConst,
5438 IdLoc, Id, Owned(Val));
5440 // Register this decl in the current scope stack.
5442 PushOnScopeChains(New, S);
5444 return DeclPtrTy::make(New);
5447 void Sema::ActOnEnumBody(SourceLocation EnumLoc, SourceLocation LBraceLoc,
5448 SourceLocation RBraceLoc, DeclPtrTy EnumDeclX,
5449 DeclPtrTy *Elements, unsigned NumElements,
5450 Scope *S, AttributeList *Attr) {
5451 EnumDecl *Enum = cast<EnumDecl>(EnumDeclX.getAs<Decl>());
5452 QualType EnumType = Context.getTypeDeclType(Enum);
5455 ProcessDeclAttributeList(S, Enum, Attr);
5457 // TODO: If the result value doesn't fit in an int, it must be a long or long
5458 // long value. ISO C does not support this, but GCC does as an extension,
5460 unsigned IntWidth = Context.Target.getIntWidth();
5461 unsigned CharWidth = Context.Target.getCharWidth();
5462 unsigned ShortWidth = Context.Target.getShortWidth();
5464 // Verify that all the values are okay, compute the size of the values, and
5465 // reverse the list.
5466 unsigned NumNegativeBits = 0;
5467 unsigned NumPositiveBits = 0;
5469 // Keep track of whether all elements have type int.
5470 bool AllElementsInt = true;
5472 for (unsigned i = 0; i != NumElements; ++i) {
5473 EnumConstantDecl *ECD =
5474 cast_or_null<EnumConstantDecl>(Elements[i].getAs<Decl>());
5475 if (!ECD) continue; // Already issued a diagnostic.
5477 // If the enum value doesn't fit in an int, emit an extension warning.
5478 const llvm::APSInt &InitVal = ECD->getInitVal();
5479 assert(InitVal.getBitWidth() >= IntWidth &&
5480 "Should have promoted value to int");
5481 if (InitVal.getBitWidth() > IntWidth) {
5482 llvm::APSInt V(InitVal);
5484 V.extend(InitVal.getBitWidth());
5486 Diag(ECD->getLocation(), diag::ext_enum_value_not_int)
5487 << InitVal.toString(10);
5490 // Keep track of the size of positive and negative values.
5491 if (InitVal.isUnsigned() || InitVal.isNonNegative())
5492 NumPositiveBits = std::max(NumPositiveBits,
5493 (unsigned)InitVal.getActiveBits());
5495 NumNegativeBits = std::max(NumNegativeBits,
5496 (unsigned)InitVal.getMinSignedBits());
5498 // Keep track of whether every enum element has type int (very commmon).
5500 AllElementsInt = ECD->getType() == Context.IntTy;
5503 // Figure out the type that should be used for this enum.
5504 // FIXME: Support -fshort-enums.
5508 bool Packed = Enum->getAttr<PackedAttr>() ? true : false;
5510 if (NumNegativeBits) {
5511 // If there is a negative value, figure out the smallest integer type (of
5512 // int/long/longlong) that fits.
5513 // If it's packed, check also if it fits a char or a short.
5514 if (Packed && NumNegativeBits <= CharWidth && NumPositiveBits < CharWidth) {
5515 BestType = Context.SignedCharTy;
5516 BestWidth = CharWidth;
5517 } else if (Packed && NumNegativeBits <= ShortWidth &&
5518 NumPositiveBits < ShortWidth) {
5519 BestType = Context.ShortTy;
5520 BestWidth = ShortWidth;
5522 else if (NumNegativeBits <= IntWidth && NumPositiveBits < IntWidth) {
5523 BestType = Context.IntTy;
5524 BestWidth = IntWidth;
5526 BestWidth = Context.Target.getLongWidth();
5528 if (NumNegativeBits <= BestWidth && NumPositiveBits < BestWidth)
5529 BestType = Context.LongTy;
5531 BestWidth = Context.Target.getLongLongWidth();
5533 if (NumNegativeBits > BestWidth || NumPositiveBits >= BestWidth)
5534 Diag(Enum->getLocation(), diag::warn_enum_too_large);
5535 BestType = Context.LongLongTy;
5539 // If there is no negative value, figure out which of uint, ulong, ulonglong
5541 // If it's packed, check also if it fits a char or a short.
5542 if (Packed && NumPositiveBits <= CharWidth) {
5543 BestType = Context.UnsignedCharTy;
5544 BestWidth = CharWidth;
5545 } else if (Packed && NumPositiveBits <= ShortWidth) {
5546 BestType = Context.UnsignedShortTy;
5547 BestWidth = ShortWidth;
5549 else if (NumPositiveBits <= IntWidth) {
5550 BestType = Context.UnsignedIntTy;
5551 BestWidth = IntWidth;
5552 } else if (NumPositiveBits <=
5553 (BestWidth = Context.Target.getLongWidth())) {
5554 BestType = Context.UnsignedLongTy;
5556 BestWidth = Context.Target.getLongLongWidth();
5557 assert(NumPositiveBits <= BestWidth &&
5558 "How could an initializer get larger than ULL?");
5559 BestType = Context.UnsignedLongLongTy;
5563 // Loop over all of the enumerator constants, changing their types to match
5564 // the type of the enum if needed.
5565 for (unsigned i = 0; i != NumElements; ++i) {
5566 EnumConstantDecl *ECD =
5567 cast_or_null<EnumConstantDecl>(Elements[i].getAs<Decl>());
5568 if (!ECD) continue; // Already issued a diagnostic.
5570 // Standard C says the enumerators have int type, but we allow, as an
5571 // extension, the enumerators to be larger than int size. If each
5572 // enumerator value fits in an int, type it as an int, otherwise type it the
5573 // same as the enumerator decl itself. This means that in "enum { X = 1U }"
5574 // that X has type 'int', not 'unsigned'.
5575 if (ECD->getType() == Context.IntTy) {
5576 // Make sure the init value is signed.
5577 llvm::APSInt IV = ECD->getInitVal();
5578 IV.setIsSigned(true);
5579 ECD->setInitVal(IV);
5581 if (getLangOptions().CPlusPlus)
5582 // C++ [dcl.enum]p4: Following the closing brace of an
5583 // enum-specifier, each enumerator has the type of its
5585 ECD->setType(EnumType);
5586 continue; // Already int type.
5589 // Determine whether the value fits into an int.
5590 llvm::APSInt InitVal = ECD->getInitVal();
5592 if (InitVal.isUnsigned() || !InitVal.isNegative())
5593 FitsInInt = InitVal.getActiveBits() < IntWidth;
5595 FitsInInt = InitVal.getMinSignedBits() <= IntWidth;
5597 // If it fits into an integer type, force it. Otherwise force it to match
5598 // the enum decl type.
5603 NewTy = Context.IntTy;
5604 NewWidth = IntWidth;
5606 } else if (ECD->getType() == BestType) {
5607 // Already the right type!
5608 if (getLangOptions().CPlusPlus)
5609 // C++ [dcl.enum]p4: Following the closing brace of an
5610 // enum-specifier, each enumerator has the type of its
5612 ECD->setType(EnumType);
5616 NewWidth = BestWidth;
5617 NewSign = BestType->isSignedIntegerType();
5620 // Adjust the APSInt value.
5621 InitVal.extOrTrunc(NewWidth);
5622 InitVal.setIsSigned(NewSign);
5623 ECD->setInitVal(InitVal);
5625 // Adjust the Expr initializer and type.
5626 if (ECD->getInitExpr())
5627 ECD->setInitExpr(new (Context) ImplicitCastExpr(NewTy,
5628 CastExpr::CK_IntegralCast,
5630 /*isLvalue=*/false));
5631 if (getLangOptions().CPlusPlus)
5632 // C++ [dcl.enum]p4: Following the closing brace of an
5633 // enum-specifier, each enumerator has the type of its
5635 ECD->setType(EnumType);
5637 ECD->setType(NewTy);
5640 Enum->completeDefinition(Context, BestType);
5643 Sema::DeclPtrTy Sema::ActOnFileScopeAsmDecl(SourceLocation Loc,
5645 StringLiteral *AsmString = cast<StringLiteral>(expr.takeAs<Expr>());
5647 FileScopeAsmDecl *New = FileScopeAsmDecl::Create(Context, CurContext,
5649 CurContext->addDecl(New);
5650 return DeclPtrTy::make(New);
5653 void Sema::ActOnPragmaWeakID(IdentifierInfo* Name,
5654 SourceLocation PragmaLoc,
5655 SourceLocation NameLoc) {
5656 Decl *PrevDecl = LookupSingleName(TUScope, Name, LookupOrdinaryName);
5659 PrevDecl->addAttr(::new (Context) WeakAttr());
5661 (void)WeakUndeclaredIdentifiers.insert(
5662 std::pair<IdentifierInfo*,WeakInfo>
5663 (Name, WeakInfo((IdentifierInfo*)0, NameLoc)));
5667 void Sema::ActOnPragmaWeakAlias(IdentifierInfo* Name,
5668 IdentifierInfo* AliasName,
5669 SourceLocation PragmaLoc,
5670 SourceLocation NameLoc,
5671 SourceLocation AliasNameLoc) {
5672 Decl *PrevDecl = LookupSingleName(TUScope, AliasName, LookupOrdinaryName);
5673 WeakInfo W = WeakInfo(Name, NameLoc);
5676 if (!PrevDecl->hasAttr<AliasAttr>())
5677 if (NamedDecl *ND = dyn_cast<NamedDecl>(PrevDecl))
5678 DeclApplyPragmaWeak(TUScope, ND, W);
5680 (void)WeakUndeclaredIdentifiers.insert(
5681 std::pair<IdentifierInfo*,WeakInfo>(AliasName, W));