blob: 411307522be73e1dd6959430994142466f539a15 [file] [log] [blame]
Reid Spencer5f016e22007-07-11 17:01:13 +00001//===--- SemaDecl.cpp - Semantic Analysis for Declarations ----------------===//
2//
3// The LLVM Compiler Infrastructure
4//
Chris Lattner0bc735f2007-12-29 19:59:25 +00005// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
Reid Spencer5f016e22007-07-11 17:01:13 +00007//
8//===----------------------------------------------------------------------===//
9//
10// This file implements semantic analysis for declarations.
11//
12//===----------------------------------------------------------------------===//
13
14#include "Sema.h"
Anders Carlssonc44eec62008-07-03 04:20:39 +000015#include "clang/AST/APValue.h"
Chris Lattnere1e79852008-02-06 00:51:33 +000016#include "clang/AST/ASTConsumer.h"
Reid Spencer5f016e22007-07-11 17:01:13 +000017#include "clang/AST/ASTContext.h"
Daniel Dunbarc4a1dea2008-08-11 05:35:13 +000018#include "clang/AST/DeclObjC.h"
Chris Lattner6b6b5372008-06-26 18:38:35 +000019#include "clang/AST/ExprCXX.h"
Reid Spencer5f016e22007-07-11 17:01:13 +000020#include "clang/Parse/DeclSpec.h"
Daniel Dunbare4858a62008-08-11 03:45:03 +000021#include "clang/Basic/Diagnostic.h"
Reid Spencer5f016e22007-07-11 17:01:13 +000022#include "clang/Basic/TargetInfo.h"
Steve Naroff4c49a6c2008-01-30 23:46:05 +000023#include "clang/Basic/SourceManager.h"
24// FIXME: layering (ideally, Sema shouldn't be dependent on Lex API's)
Chris Lattnere1e79852008-02-06 00:51:33 +000025#include "clang/Lex/Preprocessor.h"
Steve Naroff4c49a6c2008-01-30 23:46:05 +000026#include "clang/Lex/HeaderSearch.h"
Reid Spencer5f016e22007-07-11 17:01:13 +000027#include "llvm/ADT/SmallSet.h"
28using namespace clang;
29
Douglas Gregor2def4832008-11-17 20:34:05 +000030Sema::TypeTy *Sema::isTypeName(IdentifierInfo &II, Scope *S,
Argyrios Kyrtzidiseb83ecd2008-11-08 16:45:02 +000031 const CXXScopeSpec *SS) {
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +000032 DeclContext *DC = 0;
33 if (SS) {
34 if (SS->isInvalid())
35 return 0;
36 DC = static_cast<DeclContext*>(SS->getScopeRep());
37 }
38 Decl *IIDecl = LookupDecl(&II, Decl::IDNS_Ordinary, S, DC, false);
Steve Naroffb327ce02008-04-02 14:35:35 +000039
Douglas Gregor2ce52f32008-04-13 21:07:44 +000040 if (IIDecl && (isa<TypedefDecl>(IIDecl) ||
41 isa<ObjCInterfaceDecl>(IIDecl) ||
42 isa<TagDecl>(IIDecl)))
Fariborz Jahanianbece4ac2007-10-12 16:34:10 +000043 return IIDecl;
Steve Naroff3536b442007-09-06 21:24:23 +000044 return 0;
Reid Spencer5f016e22007-07-11 17:01:13 +000045}
46
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +000047DeclContext *Sema::getContainingDC(DeclContext *DC) {
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +000048 if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(DC)) {
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +000049 // A C++ out-of-line method will return to the file declaration context.
Argyrios Kyrtzidis52393042008-11-09 23:41:00 +000050 if (MD->isOutOfLineDefinition())
51 return MD->getLexicalDeclContext();
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +000052
53 // A C++ inline method is parsed *after* the topmost class it was declared in
54 // is fully parsed (it's "complete").
55 // The parsing of a C++ inline method happens at the declaration context of
Argyrios Kyrtzidis77407b82008-11-19 18:01:13 +000056 // the topmost (non-nested) class it is lexically declared in.
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +000057 assert(isa<CXXRecordDecl>(MD->getParent()) && "C++ method not in Record.");
58 DC = MD->getParent();
Argyrios Kyrtzidis77407b82008-11-19 18:01:13 +000059 while (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(DC->getLexicalParent()))
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +000060 DC = RD;
61
62 // Return the declaration context of the topmost class the inline method is
63 // declared in.
64 return DC;
65 }
66
Argyrios Kyrtzidis52393042008-11-09 23:41:00 +000067 if (isa<ObjCMethodDecl>(DC))
68 return Context.getTranslationUnitDecl();
69
70 if (ScopedDecl *SD = dyn_cast<ScopedDecl>(DC))
71 return SD->getLexicalDeclContext();
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +000072
Argyrios Kyrtzidis77407b82008-11-19 18:01:13 +000073 return DC->getLexicalParent();
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +000074}
75
Chris Lattner9fdf9c62008-04-22 18:39:57 +000076void Sema::PushDeclContext(DeclContext *DC) {
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +000077 assert(getContainingDC(DC) == CurContext &&
Argyrios Kyrtzidis52393042008-11-09 23:41:00 +000078 "The next DeclContext should be lexically contained in the current one.");
Chris Lattner9fdf9c62008-04-22 18:39:57 +000079 CurContext = DC;
Chris Lattner0ed844b2008-04-04 06:12:32 +000080}
81
Chris Lattnerb048c982008-04-06 04:47:34 +000082void Sema::PopDeclContext() {
83 assert(CurContext && "DeclContext imbalance!");
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +000084 CurContext = getContainingDC(CurContext);
Chris Lattner0ed844b2008-04-04 06:12:32 +000085}
86
Argyrios Kyrtzidis87f3ff02008-04-12 00:47:19 +000087/// Add this decl to the scope shadowed decl chains.
88void Sema::PushOnScopeChains(NamedDecl *D, Scope *S) {
Argyrios Kyrtzidis87f3ff02008-04-12 00:47:19 +000089 S->AddDecl(D);
Argyrios Kyrtzidis00bc6452008-05-09 23:39:43 +000090
91 // C++ [basic.scope]p4:
92 // -- exactly one declaration shall declare a class name or
93 // enumeration name that is not a typedef name and the other
94 // declarations shall all refer to the same object or
95 // enumerator, or all refer to functions and function templates;
96 // in this case the class name or enumeration name is hidden.
97 if (TagDecl *TD = dyn_cast<TagDecl>(D)) {
98 // We are pushing the name of a tag (enum or class).
Argyrios Kyrtzidis90eb5392008-07-17 17:49:50 +000099 IdentifierResolver::iterator
100 I = IdResolver.begin(TD->getIdentifier(),
101 TD->getDeclContext(), false/*LookInParentCtx*/);
Argyrios Kyrtzidis15a12d02008-09-09 21:18:04 +0000102 if (I != IdResolver.end() && isDeclInScope(*I, TD->getDeclContext(), S)) {
Argyrios Kyrtzidis00bc6452008-05-09 23:39:43 +0000103 // There is already a declaration with the same name in the same
104 // scope. It must be found before we find the new declaration,
105 // so swap the order on the shadowed declaration chain.
106
Argyrios Kyrtzidis90eb5392008-07-17 17:49:50 +0000107 IdResolver.AddShadowedDecl(TD, *I);
Argyrios Kyrtzidis00bc6452008-05-09 23:39:43 +0000108 return;
109 }
Argyrios Kyrtzidisf1af6a72008-10-22 23:08:24 +0000110 } else if (getLangOptions().CPlusPlus && isa<FunctionDecl>(D)) {
111 FunctionDecl *FD = cast<FunctionDecl>(D);
Douglas Gregor8e9bebd2008-10-21 16:13:35 +0000112 // We are pushing the name of a function, which might be an
113 // overloaded name.
114 IdentifierResolver::iterator
Douglas Gregor2def4832008-11-17 20:34:05 +0000115 I = IdResolver.begin(FD->getDeclName(),
Douglas Gregor8e9bebd2008-10-21 16:13:35 +0000116 FD->getDeclContext(), false/*LookInParentCtx*/);
117 if (I != IdResolver.end() &&
118 IdResolver.isDeclInScope(*I, FD->getDeclContext(), S) &&
119 (isa<OverloadedFunctionDecl>(*I) || isa<FunctionDecl>(*I))) {
120 // There is already a declaration with the same name in the same
121 // scope. It must be a function or an overloaded function.
122 OverloadedFunctionDecl* Ovl = dyn_cast<OverloadedFunctionDecl>(*I);
123 if (!Ovl) {
124 // We haven't yet overloaded this function. Take the existing
125 // FunctionDecl and put it into an OverloadedFunctionDecl.
126 Ovl = OverloadedFunctionDecl::Create(Context,
127 FD->getDeclContext(),
Douglas Gregor2def4832008-11-17 20:34:05 +0000128 FD->getDeclName());
Douglas Gregor8e9bebd2008-10-21 16:13:35 +0000129 Ovl->addOverload(dyn_cast<FunctionDecl>(*I));
130
131 // Remove the name binding to the existing FunctionDecl...
132 IdResolver.RemoveDecl(*I);
133
134 // ... and put the OverloadedFunctionDecl in its place.
135 IdResolver.AddDecl(Ovl);
136 }
137
138 // We have an OverloadedFunctionDecl. Add the new FunctionDecl
139 // to its list of overloads.
140 Ovl->addOverload(FD);
141
142 return;
143 }
Argyrios Kyrtzidis00bc6452008-05-09 23:39:43 +0000144 }
Douglas Gregor8e9bebd2008-10-21 16:13:35 +0000145
Argyrios Kyrtzidis00bc6452008-05-09 23:39:43 +0000146 IdResolver.AddDecl(D);
Argyrios Kyrtzidis87f3ff02008-04-12 00:47:19 +0000147}
148
Steve Naroffb216c882007-10-09 22:01:59 +0000149void Sema::ActOnPopScope(SourceLocation Loc, Scope *S) {
Chris Lattner31e05722007-08-26 06:24:45 +0000150 if (S->decl_empty()) return;
151 assert((S->getFlags() & Scope::DeclScope) &&"Scope shouldn't contain decls!");
Argyrios Kyrtzidis00bc6452008-05-09 23:39:43 +0000152
Reid Spencer5f016e22007-07-11 17:01:13 +0000153 for (Scope::decl_iterator I = S->decl_begin(), E = S->decl_end();
154 I != E; ++I) {
Steve Naroffc752d042007-09-13 18:10:37 +0000155 Decl *TmpD = static_cast<Decl*>(*I);
156 assert(TmpD && "This decl didn't get pushed??");
Argyrios Kyrtzidis76435362008-06-10 01:32:09 +0000157
158 if (isa<CXXFieldDecl>(TmpD)) continue;
159
160 assert(isa<ScopedDecl>(TmpD) && "Decl isn't ScopedDecl?");
161 ScopedDecl *D = cast<ScopedDecl>(TmpD);
Steve Naroffc752d042007-09-13 18:10:37 +0000162
Reid Spencer5f016e22007-07-11 17:01:13 +0000163 IdentifierInfo *II = D->getIdentifier();
164 if (!II) continue;
165
Ted Kremeneka89d1972008-09-03 18:03:35 +0000166 // We only want to remove the decls from the identifier decl chains for
167 // local scopes, when inside a function/method.
Argyrios Kyrtzidis76435362008-06-10 01:32:09 +0000168 if (S->getFnParent() != 0)
169 IdResolver.RemoveDecl(D);
Chris Lattner7f925cc2008-04-11 07:00:53 +0000170
Argyrios Kyrtzidis76435362008-06-10 01:32:09 +0000171 // Chain this decl to the containing DeclContext.
172 D->setNext(CurContext->getDeclChain());
173 CurContext->setDeclChain(D);
Reid Spencer5f016e22007-07-11 17:01:13 +0000174 }
175}
176
Steve Naroffe8043c32008-04-01 23:04:06 +0000177/// getObjCInterfaceDecl - Look up a for a class declaration in the scope.
178/// return 0 if one not found.
Steve Naroffe8043c32008-04-01 23:04:06 +0000179ObjCInterfaceDecl *Sema::getObjCInterfaceDecl(IdentifierInfo *Id) {
Steve Naroff31102512008-04-02 18:30:49 +0000180 // The third "scope" argument is 0 since we aren't enabling lazy built-in
181 // creation from this context.
182 Decl *IDecl = LookupDecl(Id, Decl::IDNS_Ordinary, 0, false);
Fariborz Jahanian4cabdfc2007-10-12 19:38:20 +0000183
Steve Naroffb327ce02008-04-02 14:35:35 +0000184 return dyn_cast_or_null<ObjCInterfaceDecl>(IDecl);
Fariborz Jahanian4cabdfc2007-10-12 19:38:20 +0000185}
186
Steve Naroffe8043c32008-04-01 23:04:06 +0000187/// LookupDecl - Look up the inner-most declaration in the specified
Reid Spencer5f016e22007-07-11 17:01:13 +0000188/// namespace.
Douglas Gregor2def4832008-11-17 20:34:05 +0000189Decl *Sema::LookupDecl(DeclarationName Name, unsigned NSI, Scope *S,
Sebastian Redlc42e1182008-11-11 11:37:55 +0000190 const DeclContext *LookupCtx,
191 bool enableLazyBuiltinCreation) {
Douglas Gregor2def4832008-11-17 20:34:05 +0000192 if (!Name) return 0;
Douglas Gregor2ce52f32008-04-13 21:07:44 +0000193 unsigned NS = NSI;
194 if (getLangOptions().CPlusPlus && (NS & Decl::IDNS_Ordinary))
195 NS |= Decl::IDNS_Tag;
Chris Lattner7f925cc2008-04-11 07:00:53 +0000196
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +0000197 IdentifierResolver::iterator
Douglas Gregor2def4832008-11-17 20:34:05 +0000198 I = LookupCtx ? IdResolver.begin(Name, LookupCtx, false/*LookInParentCtx*/)
199 : IdResolver.begin(Name, CurContext, true/*LookInParentCtx*/);
Reid Spencer5f016e22007-07-11 17:01:13 +0000200 // Scan up the scope chain looking for a decl that matches this identifier
201 // that is in the appropriate namespace. This search should not take long, as
202 // shadowing of names is uncommon, and deep shadowing is extremely uncommon.
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +0000203 for (; I != IdResolver.end(); ++I)
Argyrios Kyrtzidis00bc6452008-05-09 23:39:43 +0000204 if ((*I)->getIdentifierNamespace() & NS)
205 return *I;
Chris Lattner7f925cc2008-04-11 07:00:53 +0000206
Reid Spencer5f016e22007-07-11 17:01:13 +0000207 // If we didn't find a use of this identifier, and if the identifier
208 // corresponds to a compiler builtin, create the decl object for the builtin
209 // now, injecting it into translation unit scope, and return it.
Douglas Gregor2ce52f32008-04-13 21:07:44 +0000210 if (NS & Decl::IDNS_Ordinary) {
Douglas Gregor2def4832008-11-17 20:34:05 +0000211 IdentifierInfo *II = Name.getAsIdentifierInfo();
212 if (enableLazyBuiltinCreation && II &&
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +0000213 (LookupCtx == 0 || isa<TranslationUnitDecl>(LookupCtx))) {
Steve Naroffb327ce02008-04-02 14:35:35 +0000214 // If this is a builtin on this (or all) targets, create the decl.
215 if (unsigned BuiltinID = II->getBuiltinID())
216 return LazilyCreateBuiltin((IdentifierInfo *)II, BuiltinID, S);
217 }
Douglas Gregor2def4832008-11-17 20:34:05 +0000218 if (getLangOptions().ObjC1 && II) {
Steve Naroffe8043c32008-04-01 23:04:06 +0000219 // @interface and @compatibility_alias introduce typedef-like names.
220 // Unlike typedef's, they can only be introduced at file-scope (and are
Steve Naroffc822ff42008-04-02 00:39:51 +0000221 // therefore not scoped decls). They can, however, be shadowed by
Steve Naroffe8043c32008-04-01 23:04:06 +0000222 // other names in IDNS_Ordinary.
Steve Naroff31102512008-04-02 18:30:49 +0000223 ObjCInterfaceDeclsTy::iterator IDI = ObjCInterfaceDecls.find(II);
224 if (IDI != ObjCInterfaceDecls.end())
225 return IDI->second;
Steve Naroffe8043c32008-04-01 23:04:06 +0000226 ObjCAliasTy::iterator I = ObjCAliasDecls.find(II);
227 if (I != ObjCAliasDecls.end())
228 return I->second->getClassInterface();
229 }
Reid Spencer5f016e22007-07-11 17:01:13 +0000230 }
231 return 0;
232}
233
Chris Lattner95e2c712008-05-05 22:18:14 +0000234void Sema::InitBuiltinVaListType() {
Anders Carlsson7c50aca2007-10-15 20:28:48 +0000235 if (!Context.getBuiltinVaListType().isNull())
236 return;
237
238 IdentifierInfo *VaIdent = &Context.Idents.get("__builtin_va_list");
Steve Naroffb327ce02008-04-02 14:35:35 +0000239 Decl *VaDecl = LookupDecl(VaIdent, Decl::IDNS_Ordinary, TUScope);
Steve Naroff733002f2007-10-18 22:17:45 +0000240 TypedefDecl *VaTypedef = cast<TypedefDecl>(VaDecl);
Anders Carlsson7c50aca2007-10-15 20:28:48 +0000241 Context.setBuiltinVaListType(Context.getTypedefType(VaTypedef));
242}
243
Reid Spencer5f016e22007-07-11 17:01:13 +0000244/// LazilyCreateBuiltin - The specified Builtin-ID was first used at file scope.
245/// lazily create a decl for it.
Chris Lattner22b73ba2007-10-10 23:42:28 +0000246ScopedDecl *Sema::LazilyCreateBuiltin(IdentifierInfo *II, unsigned bid,
247 Scope *S) {
Reid Spencer5f016e22007-07-11 17:01:13 +0000248 Builtin::ID BID = (Builtin::ID)bid;
249
Chris Lattnerbd7eb1c2008-09-28 05:54:29 +0000250 if (Context.BuiltinInfo.hasVAListUse(BID))
Anders Carlsson7c50aca2007-10-15 20:28:48 +0000251 InitBuiltinVaListType();
252
Anders Carlssonb2cf3572007-10-11 01:00:40 +0000253 QualType R = Context.BuiltinInfo.GetBuiltinType(BID, Context);
Argyrios Kyrtzidisff898cd2008-04-17 14:47:13 +0000254 FunctionDecl *New = FunctionDecl::Create(Context,
255 Context.getTranslationUnitDecl(),
Chris Lattner0ed844b2008-04-04 06:12:32 +0000256 SourceLocation(), II, R,
Chris Lattnera98e58d2008-03-15 21:24:04 +0000257 FunctionDecl::Extern, false, 0);
Reid Spencer5f016e22007-07-11 17:01:13 +0000258
Chris Lattner95e2c712008-05-05 22:18:14 +0000259 // Create Decl objects for each parameter, adding them to the
260 // FunctionDecl.
261 if (FunctionTypeProto *FT = dyn_cast<FunctionTypeProto>(R)) {
262 llvm::SmallVector<ParmVarDecl*, 16> Params;
263 for (unsigned i = 0, e = FT->getNumArgs(); i != e; ++i)
264 Params.push_back(ParmVarDecl::Create(Context, New, SourceLocation(), 0,
265 FT->getArgType(i), VarDecl::None, 0,
266 0));
267 New->setParams(&Params[0], Params.size());
268 }
269
270
271
Chris Lattner7f925cc2008-04-11 07:00:53 +0000272 // TUScope is the translation-unit scope to insert this function into.
Argyrios Kyrtzidis00bc6452008-05-09 23:39:43 +0000273 PushOnScopeChains(New, TUScope);
Reid Spencer5f016e22007-07-11 17:01:13 +0000274 return New;
275}
276
Sebastian Redlc42e1182008-11-11 11:37:55 +0000277/// GetStdNamespace - This method gets the C++ "std" namespace. This is where
278/// everything from the standard library is defined.
279NamespaceDecl *Sema::GetStdNamespace() {
280 if (!StdNamespace) {
Chris Lattner8edea832008-11-20 05:45:14 +0000281 IdentifierInfo *StdIdent = &PP.getIdentifierTable().get("std");
Sebastian Redlc42e1182008-11-11 11:37:55 +0000282 DeclContext *Global = Context.getTranslationUnitDecl();
Chris Lattner8edea832008-11-20 05:45:14 +0000283 Decl *Std = LookupDecl(StdIdent, Decl::IDNS_Tag | Decl::IDNS_Ordinary,
Sebastian Redlc42e1182008-11-11 11:37:55 +0000284 0, Global, /*enableLazyBuiltinCreation=*/false);
285 StdNamespace = dyn_cast_or_null<NamespaceDecl>(Std);
286 }
287 return StdNamespace;
288}
289
Reid Spencer5f016e22007-07-11 17:01:13 +0000290/// MergeTypeDefDecl - We just parsed a typedef 'New' which has the same name
291/// and scope as a previous declaration 'Old'. Figure out how to resolve this
292/// situation, merging decls or emitting diagnostics as appropriate.
293///
Steve Naroffe8043c32008-04-01 23:04:06 +0000294TypedefDecl *Sema::MergeTypeDefDecl(TypedefDecl *New, Decl *OldD) {
Steve Naroff2b255c42008-09-09 14:32:20 +0000295 // Allow multiple definitions for ObjC built-in typedefs.
296 // FIXME: Verify the underlying types are equivalent!
297 if (getLangOptions().ObjC1) {
Chris Lattner2bac0f62008-11-20 05:41:43 +0000298 const IdentifierInfo *TypeID = New->getIdentifier();
299 switch (TypeID->getLength()) {
300 default: break;
301 case 2:
302 if (!TypeID->isStr("id"))
303 break;
Steve Naroff2b255c42008-09-09 14:32:20 +0000304 Context.setObjCIdType(New);
305 return New;
Chris Lattner2bac0f62008-11-20 05:41:43 +0000306 case 5:
307 if (!TypeID->isStr("Class"))
308 break;
Steve Naroff2b255c42008-09-09 14:32:20 +0000309 Context.setObjCClassType(New);
310 return New;
Chris Lattner2bac0f62008-11-20 05:41:43 +0000311 case 3:
312 if (!TypeID->isStr("SEL"))
313 break;
Steve Naroff2b255c42008-09-09 14:32:20 +0000314 Context.setObjCSelType(New);
315 return New;
Chris Lattner2bac0f62008-11-20 05:41:43 +0000316 case 8:
317 if (!TypeID->isStr("Protocol"))
318 break;
Steve Naroff2b255c42008-09-09 14:32:20 +0000319 Context.setObjCProtoType(New->getUnderlyingType());
320 return New;
321 }
322 // Fall through - the typedef name was not a builtin type.
323 }
Reid Spencer5f016e22007-07-11 17:01:13 +0000324 // Verify the old decl was also a typedef.
325 TypedefDecl *Old = dyn_cast<TypedefDecl>(OldD);
326 if (!Old) {
Chris Lattner5dc266a2008-11-20 06:13:02 +0000327 Diag(New->getLocation(), diag::err_redefinition_different_kind)
Chris Lattner08631c52008-11-23 21:45:46 +0000328 << New->getDeclName();
Chris Lattner5f4a6822008-11-23 23:12:31 +0000329 Diag(OldD->getLocation(), diag::note_previous_definition);
Reid Spencer5f016e22007-07-11 17:01:13 +0000330 return New;
331 }
332
Chris Lattner99cb9972008-07-25 18:44:27 +0000333 // If the typedef types are not identical, reject them in all languages and
334 // with any extensions enabled.
335 if (Old->getUnderlyingType() != New->getUnderlyingType() &&
336 Context.getCanonicalType(Old->getUnderlyingType()) !=
337 Context.getCanonicalType(New->getUnderlyingType())) {
Chris Lattner5dc266a2008-11-20 06:13:02 +0000338 Diag(New->getLocation(), diag::err_redefinition_different_typedef)
Chris Lattnerd1625842008-11-24 06:25:27 +0000339 << New->getUnderlyingType() << Old->getUnderlyingType();
Chris Lattner5f4a6822008-11-23 23:12:31 +0000340 Diag(Old->getLocation(), diag::note_previous_definition);
Chris Lattner99cb9972008-07-25 18:44:27 +0000341 return Old;
342 }
343
Eli Friedman54ecfce2008-06-11 06:20:39 +0000344 if (getLangOptions().Microsoft) return New;
345
Douglas Gregorbbe27432008-11-21 16:29:06 +0000346 // C++ [dcl.typedef]p2:
347 // In a given non-class scope, a typedef specifier can be used to
348 // redefine the name of any type declared in that scope to refer
349 // to the type to which it already refers.
350 if (getLangOptions().CPlusPlus && !isa<CXXRecordDecl>(CurContext))
351 return New;
352
353 // In C, redeclaration of a type is a constraint violation (6.7.2.3p1).
Steve Naroff4c49a6c2008-01-30 23:46:05 +0000354 // Apparently GCC, Intel, and Sun all silently ignore the redeclaration if
355 // *either* declaration is in a system header. The code below implements
356 // this adhoc compatibility rule. FIXME: The following code will not
357 // work properly when compiling ".i" files (containing preprocessed output).
Daniel Dunbar2fe09972008-09-12 18:10:20 +0000358 if (PP.getDiagnostics().getSuppressSystemWarnings()) {
359 SourceManager &SrcMgr = Context.getSourceManager();
360 if (SrcMgr.isInSystemHeader(Old->getLocation()))
361 return New;
362 if (SrcMgr.isInSystemHeader(New->getLocation()))
363 return New;
364 }
Eli Friedman54ecfce2008-06-11 06:20:39 +0000365
Chris Lattner08631c52008-11-23 21:45:46 +0000366 Diag(New->getLocation(), diag::err_redefinition) << New->getDeclName();
Chris Lattner5f4a6822008-11-23 23:12:31 +0000367 Diag(Old->getLocation(), diag::note_previous_definition);
Reid Spencer5f016e22007-07-11 17:01:13 +0000368 return New;
369}
370
Chris Lattner6b6b5372008-06-26 18:38:35 +0000371/// DeclhasAttr - returns true if decl Declaration already has the target
372/// attribute.
Chris Lattnerddee4232008-03-03 03:28:21 +0000373static bool DeclHasAttr(const Decl *decl, const Attr *target) {
374 for (const Attr *attr = decl->getAttrs(); attr; attr = attr->getNext())
375 if (attr->getKind() == target->getKind())
376 return true;
377
378 return false;
379}
380
381/// MergeAttributes - append attributes from the Old decl to the New one.
382static void MergeAttributes(Decl *New, Decl *Old) {
383 Attr *attr = const_cast<Attr*>(Old->getAttrs()), *tmp;
384
Chris Lattnerddee4232008-03-03 03:28:21 +0000385 while (attr) {
386 tmp = attr;
387 attr = attr->getNext();
388
389 if (!DeclHasAttr(New, tmp)) {
390 New->addAttr(tmp);
391 } else {
392 tmp->setNext(0);
393 delete(tmp);
394 }
395 }
Nuno Lopes9141bee2008-06-01 22:53:53 +0000396
397 Old->invalidateAttrs();
Chris Lattnerddee4232008-03-03 03:28:21 +0000398}
399
Chris Lattner04421082008-04-08 04:40:51 +0000400/// MergeFunctionDecl - We just parsed a function 'New' from
401/// declarator D which has the same name and scope as a previous
402/// declaration 'Old'. Figure out how to resolve this situation,
403/// merging decls or emitting diagnostics as appropriate.
Douglas Gregor8e9bebd2008-10-21 16:13:35 +0000404/// Redeclaration will be set true if this New is a redeclaration OldD.
405///
406/// In C++, New and Old must be declarations that are not
407/// overloaded. Use IsOverload to determine whether New and Old are
408/// overloaded, and to select the Old declaration that New should be
409/// merged with.
Douglas Gregorf0097952008-04-21 02:02:58 +0000410FunctionDecl *
411Sema::MergeFunctionDecl(FunctionDecl *New, Decl *OldD, bool &Redeclaration) {
Douglas Gregor8e9bebd2008-10-21 16:13:35 +0000412 assert(!isa<OverloadedFunctionDecl>(OldD) &&
413 "Cannot merge with an overloaded function declaration");
414
Douglas Gregorf0097952008-04-21 02:02:58 +0000415 Redeclaration = false;
Reid Spencer5f016e22007-07-11 17:01:13 +0000416 // Verify the old decl was also a function.
417 FunctionDecl *Old = dyn_cast<FunctionDecl>(OldD);
418 if (!Old) {
Chris Lattner5dc266a2008-11-20 06:13:02 +0000419 Diag(New->getLocation(), diag::err_redefinition_different_kind)
Chris Lattner08631c52008-11-23 21:45:46 +0000420 << New->getDeclName();
Chris Lattner5f4a6822008-11-23 23:12:31 +0000421 Diag(OldD->getLocation(), diag::note_previous_definition);
Reid Spencer5f016e22007-07-11 17:01:13 +0000422 return New;
423 }
Douglas Gregor8e9bebd2008-10-21 16:13:35 +0000424
425 // Determine whether the previous declaration was a definition,
426 // implicit declaration, or a declaration.
427 diag::kind PrevDiag;
428 if (Old->isThisDeclarationADefinition())
Chris Lattner5f4a6822008-11-23 23:12:31 +0000429 PrevDiag = diag::note_previous_definition;
Douglas Gregor8e9bebd2008-10-21 16:13:35 +0000430 else if (Old->isImplicit())
Chris Lattner5f4a6822008-11-23 23:12:31 +0000431 PrevDiag = diag::note_previous_implicit_declaration;
Douglas Gregor8e9bebd2008-10-21 16:13:35 +0000432 else
Chris Lattner5f4a6822008-11-23 23:12:31 +0000433 PrevDiag = diag::note_previous_declaration;
Chris Lattner04421082008-04-08 04:40:51 +0000434
Chris Lattner8bcfc5b2008-04-06 23:10:54 +0000435 QualType OldQType = Context.getCanonicalType(Old->getType());
436 QualType NewQType = Context.getCanonicalType(New->getType());
Chris Lattner55196442007-11-20 19:04:50 +0000437
Douglas Gregor8e9bebd2008-10-21 16:13:35 +0000438 if (getLangOptions().CPlusPlus) {
439 // (C++98 13.1p2):
440 // Certain function declarations cannot be overloaded:
441 // -- Function declarations that differ only in the return type
442 // cannot be overloaded.
443 QualType OldReturnType
444 = cast<FunctionType>(OldQType.getTypePtr())->getResultType();
445 QualType NewReturnType
446 = cast<FunctionType>(NewQType.getTypePtr())->getResultType();
447 if (OldReturnType != NewReturnType) {
448 Diag(New->getLocation(), diag::err_ovl_diff_return_type);
449 Diag(Old->getLocation(), PrevDiag);
450 return New;
451 }
452
453 const CXXMethodDecl* OldMethod = dyn_cast<CXXMethodDecl>(Old);
454 const CXXMethodDecl* NewMethod = dyn_cast<CXXMethodDecl>(New);
455 if (OldMethod && NewMethod) {
456 // -- Member function declarations with the same name and the
457 // same parameter types cannot be overloaded if any of them
458 // is a static member function declaration.
459 if (OldMethod->isStatic() || NewMethod->isStatic()) {
460 Diag(New->getLocation(), diag::err_ovl_static_nonstatic_member);
461 Diag(Old->getLocation(), PrevDiag);
462 return New;
463 }
464 }
465
466 // (C++98 8.3.5p3):
467 // All declarations for a function shall agree exactly in both the
468 // return type and the parameter-type-list.
469 if (OldQType == NewQType) {
470 // We have a redeclaration.
471 MergeAttributes(New, Old);
472 Redeclaration = true;
473 return MergeCXXFunctionDecl(New, Old);
474 }
475
476 // Fall through for conflicting redeclarations and redefinitions.
Douglas Gregorf0097952008-04-21 02:02:58 +0000477 }
Chris Lattner04421082008-04-08 04:40:51 +0000478
479 // C: Function types need to be compatible, not identical. This handles
Steve Naroffadbbd0c2008-01-14 20:51:29 +0000480 // duplicate function decls like "void f(int); void f(enum X);" properly.
Chris Lattner04421082008-04-08 04:40:51 +0000481 if (!getLangOptions().CPlusPlus &&
Eli Friedman3d815e72008-08-22 00:56:42 +0000482 Context.typesAreCompatible(OldQType, NewQType)) {
Douglas Gregorf0097952008-04-21 02:02:58 +0000483 MergeAttributes(New, Old);
484 Redeclaration = true;
Steve Naroffadbbd0c2008-01-14 20:51:29 +0000485 return New;
Chris Lattner04421082008-04-08 04:40:51 +0000486 }
Chris Lattnere3995fe2007-11-06 06:07:26 +0000487
Steve Naroff837618c2008-01-16 15:01:34 +0000488 // A function that has already been declared has been redeclared or defined
489 // with a different type- show appropriate diagnostic
Steve Naroff837618c2008-01-16 15:01:34 +0000490
Reid Spencer5f016e22007-07-11 17:01:13 +0000491 // TODO: CHECK FOR CONFLICTS, multiple decls with same name in one scope.
492 // TODO: This is totally simplistic. It should handle merging functions
493 // together etc, merging extern int X; int X; ...
Chris Lattnerd9d22dd2008-11-24 05:29:24 +0000494 Diag(New->getLocation(), diag::err_conflicting_types) << New->getDeclName();
Steve Naroff837618c2008-01-16 15:01:34 +0000495 Diag(Old->getLocation(), PrevDiag);
Reid Spencer5f016e22007-07-11 17:01:13 +0000496 return New;
497}
498
Steve Naroffff9eb1f2008-08-08 17:50:35 +0000499/// Predicate for C "tentative" external object definitions (C99 6.9.2).
Steve Naroffd4d46cd2008-08-10 15:28:06 +0000500static bool isTentativeDefinition(VarDecl *VD) {
Steve Naroffff9eb1f2008-08-08 17:50:35 +0000501 if (VD->isFileVarDecl())
502 return (!VD->getInit() &&
503 (VD->getStorageClass() == VarDecl::None ||
504 VD->getStorageClass() == VarDecl::Static));
505 return false;
506}
507
508/// CheckForFileScopedRedefinitions - Make sure we forgo redefinition errors
509/// when dealing with C "tentative" external object definitions (C99 6.9.2).
510void Sema::CheckForFileScopedRedefinitions(Scope *S, VarDecl *VD) {
511 bool VDIsTentative = isTentativeDefinition(VD);
Steve Narofff855e6f2008-08-10 15:20:13 +0000512 bool VDIsIncompleteArray = VD->getType()->isIncompleteArrayType();
Steve Naroffff9eb1f2008-08-08 17:50:35 +0000513
514 for (IdentifierResolver::iterator
515 I = IdResolver.begin(VD->getIdentifier(),
516 VD->getDeclContext(), false/*LookInParentCtx*/),
517 E = IdResolver.end(); I != E; ++I) {
Argyrios Kyrtzidis15a12d02008-09-09 21:18:04 +0000518 if (*I != VD && isDeclInScope(*I, VD->getDeclContext(), S)) {
Steve Naroffff9eb1f2008-08-08 17:50:35 +0000519 VarDecl *OldDecl = dyn_cast<VarDecl>(*I);
520
Steve Narofff855e6f2008-08-10 15:20:13 +0000521 // Handle the following case:
522 // int a[10];
523 // int a[]; - the code below makes sure we set the correct type.
524 // int a[11]; - this is an error, size isn't 10.
525 if (OldDecl && VDIsTentative && VDIsIncompleteArray &&
526 OldDecl->getType()->isConstantArrayType())
527 VD->setType(OldDecl->getType());
528
Steve Naroffff9eb1f2008-08-08 17:50:35 +0000529 // Check for "tentative" definitions. We can't accomplish this in
530 // MergeVarDecl since the initializer hasn't been attached.
531 if (!OldDecl || isTentativeDefinition(OldDecl) || VDIsTentative)
532 continue;
533
534 // Handle __private_extern__ just like extern.
535 if (OldDecl->getStorageClass() != VarDecl::Extern &&
536 OldDecl->getStorageClass() != VarDecl::PrivateExtern &&
537 VD->getStorageClass() != VarDecl::Extern &&
538 VD->getStorageClass() != VarDecl::PrivateExtern) {
Chris Lattner08631c52008-11-23 21:45:46 +0000539 Diag(VD->getLocation(), diag::err_redefinition) << VD->getDeclName();
Chris Lattner5f4a6822008-11-23 23:12:31 +0000540 Diag(OldDecl->getLocation(), diag::note_previous_definition);
Steve Naroffff9eb1f2008-08-08 17:50:35 +0000541 }
542 }
543 }
544}
545
Reid Spencer5f016e22007-07-11 17:01:13 +0000546/// MergeVarDecl - We just parsed a variable 'New' which has the same name
547/// and scope as a previous declaration 'Old'. Figure out how to resolve this
548/// situation, merging decls or emitting diagnostics as appropriate.
549///
Steve Naroffff9eb1f2008-08-08 17:50:35 +0000550/// Tentative definition rules (C99 6.9.2p2) are checked by
551/// FinalizeDeclaratorGroup. Unfortunately, we can't analyze tentative
552/// definitions here, since the initializer hasn't been attached.
Reid Spencer5f016e22007-07-11 17:01:13 +0000553///
Steve Naroffe8043c32008-04-01 23:04:06 +0000554VarDecl *Sema::MergeVarDecl(VarDecl *New, Decl *OldD) {
Reid Spencer5f016e22007-07-11 17:01:13 +0000555 // Verify the old decl was also a variable.
556 VarDecl *Old = dyn_cast<VarDecl>(OldD);
557 if (!Old) {
Chris Lattnerf3a41af2008-11-20 06:38:18 +0000558 Diag(New->getLocation(), diag::err_redefinition_different_kind)
Chris Lattner08631c52008-11-23 21:45:46 +0000559 << New->getDeclName();
Chris Lattner5f4a6822008-11-23 23:12:31 +0000560 Diag(OldD->getLocation(), diag::note_previous_definition);
Reid Spencer5f016e22007-07-11 17:01:13 +0000561 return New;
562 }
Chris Lattnerddee4232008-03-03 03:28:21 +0000563
564 MergeAttributes(New, Old);
565
Reid Spencer5f016e22007-07-11 17:01:13 +0000566 // Verify the types match.
Chris Lattner8bcfc5b2008-04-06 23:10:54 +0000567 QualType OldCType = Context.getCanonicalType(Old->getType());
568 QualType NewCType = Context.getCanonicalType(New->getType());
Steve Naroff907747b2008-08-09 16:04:40 +0000569 if (OldCType != NewCType && !Context.typesAreCompatible(OldCType, NewCType)) {
Chris Lattner08631c52008-11-23 21:45:46 +0000570 Diag(New->getLocation(), diag::err_redefinition) << New->getDeclName();
Chris Lattner5f4a6822008-11-23 23:12:31 +0000571 Diag(Old->getLocation(), diag::note_previous_definition);
Reid Spencer5f016e22007-07-11 17:01:13 +0000572 return New;
573 }
Steve Naroffb7b032e2008-01-30 00:44:01 +0000574 // C99 6.2.2p4: Check if we have a static decl followed by a non-static.
575 if (New->getStorageClass() == VarDecl::Static &&
576 (Old->getStorageClass() == VarDecl::None ||
577 Old->getStorageClass() == VarDecl::Extern)) {
Chris Lattnerd9d22dd2008-11-24 05:29:24 +0000578 Diag(New->getLocation(), diag::err_static_non_static) << New->getDeclName();
Chris Lattner5f4a6822008-11-23 23:12:31 +0000579 Diag(Old->getLocation(), diag::note_previous_definition);
Steve Naroffb7b032e2008-01-30 00:44:01 +0000580 return New;
581 }
582 // C99 6.2.2p4: Check if we have a non-static decl followed by a static.
583 if (New->getStorageClass() != VarDecl::Static &&
584 Old->getStorageClass() == VarDecl::Static) {
Chris Lattnerd9d22dd2008-11-24 05:29:24 +0000585 Diag(New->getLocation(), diag::err_non_static_static) << New->getDeclName();
Chris Lattner5f4a6822008-11-23 23:12:31 +0000586 Diag(Old->getLocation(), diag::note_previous_definition);
Steve Naroffb7b032e2008-01-30 00:44:01 +0000587 return New;
588 }
Steve Naroff094cefb2008-09-17 14:05:40 +0000589 // Variables with external linkage are analyzed in FinalizeDeclaratorGroup.
590 if (New->getStorageClass() != VarDecl::Extern && !New->isFileVarDecl()) {
Chris Lattner08631c52008-11-23 21:45:46 +0000591 Diag(New->getLocation(), diag::err_redefinition) << New->getDeclName();
Chris Lattner5f4a6822008-11-23 23:12:31 +0000592 Diag(Old->getLocation(), diag::note_previous_definition);
Reid Spencer5f016e22007-07-11 17:01:13 +0000593 }
594 return New;
595}
596
Chris Lattner04421082008-04-08 04:40:51 +0000597/// CheckParmsForFunctionDef - Check that the parameters of the given
598/// function are appropriate for the definition of a function. This
599/// takes care of any checks that cannot be performed on the
600/// declaration itself, e.g., that the types of each of the function
601/// parameters are complete.
602bool Sema::CheckParmsForFunctionDef(FunctionDecl *FD) {
603 bool HasInvalidParm = false;
604 for (unsigned p = 0, NumParams = FD->getNumParams(); p < NumParams; ++p) {
605 ParmVarDecl *Param = FD->getParamDecl(p);
606
607 // C99 6.7.5.3p4: the parameters in a parameter type list in a
608 // function declarator that is part of a function definition of
609 // that function shall not have incomplete type.
610 if (Param->getType()->isIncompleteType() &&
611 !Param->isInvalidDecl()) {
Chris Lattnerf3a41af2008-11-20 06:38:18 +0000612 Diag(Param->getLocation(), diag::err_typecheck_decl_incomplete_type)
Chris Lattnerd9d22dd2008-11-24 05:29:24 +0000613 << Param->getType();
Chris Lattner04421082008-04-08 04:40:51 +0000614 Param->setInvalidDecl();
615 HasInvalidParm = true;
616 }
617 }
618
619 return HasInvalidParm;
620}
621
Reid Spencer5f016e22007-07-11 17:01:13 +0000622/// ParsedFreeStandingDeclSpec - This method is invoked when a declspec with
623/// no declarator (e.g. "struct foo;") is parsed.
624Sema::DeclTy *Sema::ParsedFreeStandingDeclSpec(Scope *S, DeclSpec &DS) {
625 // TODO: emit error on 'int;' or 'const enum foo;'.
626 // TODO: emit error on 'typedef int;'
627 // if (!DS.isMissingDeclaratorOk()) Diag(...);
628
Steve Naroff92199282007-11-17 21:37:36 +0000629 return dyn_cast_or_null<TagDecl>(static_cast<Decl *>(DS.getTypeRep()));
Reid Spencer5f016e22007-07-11 17:01:13 +0000630}
631
Steve Naroffd0091aa2008-01-10 22:15:12 +0000632bool Sema::CheckSingleInitializer(Expr *&Init, QualType DeclType) {
Steve Narofff0090632007-09-02 02:04:30 +0000633 // Get the type before calling CheckSingleAssignmentConstraints(), since
634 // it can promote the expression.
Chris Lattner5cf216b2008-01-04 18:04:52 +0000635 QualType InitType = Init->getType();
Steve Narofff0090632007-09-02 02:04:30 +0000636
Chris Lattner5cf216b2008-01-04 18:04:52 +0000637 AssignConvertType ConvTy = CheckSingleAssignmentConstraints(DeclType, Init);
638 return DiagnoseAssignmentResult(ConvTy, Init->getLocStart(), DeclType,
639 InitType, Init, "initializing");
Steve Narofff0090632007-09-02 02:04:30 +0000640}
641
Steve Naroffa49e1fa2008-01-22 00:55:40 +0000642bool Sema::CheckStringLiteralInit(StringLiteral *strLiteral, QualType &DeclT) {
Chris Lattnerc63a1f22008-08-04 07:31:14 +0000643 const ArrayType *AT = Context.getAsArrayType(DeclT);
644
645 if (const IncompleteArrayType *IAT = dyn_cast<IncompleteArrayType>(AT)) {
Steve Naroffa49e1fa2008-01-22 00:55:40 +0000646 // C99 6.7.8p14. We have an array of character type with unknown size
647 // being initialized to a string literal.
648 llvm::APSInt ConstVal(32);
649 ConstVal = strLiteral->getByteLength() + 1;
650 // Return a new array type (C99 6.7.8p22).
Eli Friedmanc5773c42008-02-15 18:16:39 +0000651 DeclT = Context.getConstantArrayType(IAT->getElementType(), ConstVal,
Steve Naroffa49e1fa2008-01-22 00:55:40 +0000652 ArrayType::Normal, 0);
Chris Lattnerc63a1f22008-08-04 07:31:14 +0000653 } else {
654 const ConstantArrayType *CAT = cast<ConstantArrayType>(AT);
Steve Naroffa49e1fa2008-01-22 00:55:40 +0000655 // C99 6.7.8p14. We have an array of character type with known size.
Chris Lattnerc63a1f22008-08-04 07:31:14 +0000656 // FIXME: Avoid truncation for 64-bit length strings.
657 if (strLiteral->getByteLength() > (unsigned)CAT->getSize().getZExtValue())
Steve Naroffa49e1fa2008-01-22 00:55:40 +0000658 Diag(strLiteral->getSourceRange().getBegin(),
Chris Lattnerdcd5ef12008-11-19 05:27:50 +0000659 diag::warn_initializer_string_for_char_array_too_long)
660 << strLiteral->getSourceRange();
Steve Naroffa49e1fa2008-01-22 00:55:40 +0000661 }
662 // Set type from "char *" to "constant array of char".
663 strLiteral->setType(DeclT);
664 // For now, we always return false (meaning success).
665 return false;
666}
667
668StringLiteral *Sema::IsStringLiteralInit(Expr *Init, QualType DeclType) {
Chris Lattnerc63a1f22008-08-04 07:31:14 +0000669 const ArrayType *AT = Context.getAsArrayType(DeclType);
Steve Naroffa9960332008-01-25 00:51:06 +0000670 if (AT && AT->getElementType()->isCharType()) {
671 return dyn_cast<StringLiteral>(Init);
672 }
Steve Naroffa49e1fa2008-01-22 00:55:40 +0000673 return 0;
674}
675
Douglas Gregorf03d7c72008-11-05 15:29:30 +0000676bool Sema::CheckInitializerTypes(Expr *&Init, QualType &DeclType,
677 SourceLocation InitLoc,
Chris Lattnerd9d22dd2008-11-24 05:29:24 +0000678 DeclarationName InitEntity) {
Douglas Gregor27c8dc02008-10-29 00:13:59 +0000679 // C++ [dcl.init.ref]p1:
Sebastian Redld14094d2008-11-24 20:06:50 +0000680 // A variable declared to be a T&, that is "reference to type T"
Douglas Gregor27c8dc02008-10-29 00:13:59 +0000681 // (8.3.2), shall be initialized by an object, or function, of
682 // type T or by an object that can be converted into a T.
683 if (DeclType->isReferenceType())
684 return CheckReferenceInit(Init, DeclType);
685
Steve Naroffca107302008-01-21 23:53:58 +0000686 // C99 6.7.8p3: The type of the entity to be initialized shall be an array
687 // of unknown size ("[]") or an object type that is not a variable array type.
Chris Lattnerc63a1f22008-08-04 07:31:14 +0000688 if (const VariableArrayType *VAT = Context.getAsVariableArrayType(DeclType))
Chris Lattnerdcd5ef12008-11-19 05:27:50 +0000689 return Diag(InitLoc, diag::err_variable_object_no_init)
690 << VAT->getSizeExpr()->getSourceRange();
Steve Naroffca107302008-01-21 23:53:58 +0000691
Steve Naroff2fdc3742007-12-10 22:44:33 +0000692 InitListExpr *InitList = dyn_cast<InitListExpr>(Init);
693 if (!InitList) {
Steve Naroffa49e1fa2008-01-22 00:55:40 +0000694 // FIXME: Handle wide strings
695 if (StringLiteral *strLiteral = IsStringLiteralInit(Init, DeclType))
696 return CheckStringLiteralInit(strLiteral, DeclType);
Eli Friedmana312ce22008-02-08 00:48:24 +0000697
Douglas Gregorf03d7c72008-11-05 15:29:30 +0000698 // C++ [dcl.init]p14:
699 // -- If the destination type is a (possibly cv-qualified) class
700 // type:
701 if (getLangOptions().CPlusPlus && DeclType->isRecordType()) {
702 QualType DeclTypeC = Context.getCanonicalType(DeclType);
703 QualType InitTypeC = Context.getCanonicalType(Init->getType());
704
705 // -- If the initialization is direct-initialization, or if it is
706 // copy-initialization where the cv-unqualified version of the
707 // source type is the same class as, or a derived class of, the
708 // class of the destination, constructors are considered.
709 if ((DeclTypeC.getUnqualifiedType() == InitTypeC.getUnqualifiedType()) ||
710 IsDerivedFrom(InitTypeC, DeclTypeC)) {
711 CXXConstructorDecl *Constructor
712 = PerformInitializationByConstructor(DeclType, &Init, 1,
713 InitLoc, Init->getSourceRange(),
714 InitEntity, IK_Copy);
715 return Constructor == 0;
716 }
717
718 // -- Otherwise (i.e., for the remaining copy-initialization
719 // cases), user-defined conversion sequences that can
720 // convert from the source type to the destination type or
721 // (when a conversion function is used) to a derived class
722 // thereof are enumerated as described in 13.3.1.4, and the
723 // best one is chosen through overload resolution
724 // (13.3). If the conversion cannot be done or is
725 // ambiguous, the initialization is ill-formed. The
726 // function selected is called with the initializer
727 // expression as its argument; if the function is a
728 // constructor, the call initializes a temporary of the
729 // destination type.
730 // FIXME: We're pretending to do copy elision here; return to
731 // this when we have ASTs for such things.
Chris Lattnerc9c7c4e2008-11-18 22:52:51 +0000732 if (!PerformImplicitConversion(Init, DeclType))
Douglas Gregorf03d7c72008-11-05 15:29:30 +0000733 return false;
Chris Lattnerc9c7c4e2008-11-18 22:52:51 +0000734
735 return Diag(InitLoc, diag::err_typecheck_convert_incompatible)
Chris Lattnerd9d22dd2008-11-24 05:29:24 +0000736 << DeclType << InitEntity << "initializing"
Chris Lattnerc9c7c4e2008-11-18 22:52:51 +0000737 << Init->getSourceRange();
Douglas Gregorf03d7c72008-11-05 15:29:30 +0000738 }
739
Steve Naroff1ac6fdd2008-09-29 20:07:05 +0000740 // C99 6.7.8p16.
Eli Friedmana312ce22008-02-08 00:48:24 +0000741 if (DeclType->isArrayType())
Chris Lattnerdcd5ef12008-11-19 05:27:50 +0000742 return Diag(Init->getLocStart(), diag::err_array_init_list_required)
743 << Init->getSourceRange();
Eli Friedmana312ce22008-02-08 00:48:24 +0000744
Steve Naroffd0091aa2008-01-10 22:15:12 +0000745 return CheckSingleInitializer(Init, DeclType);
Douglas Gregor64bffa92008-11-05 16:20:31 +0000746 } else if (getLangOptions().CPlusPlus) {
747 // C++ [dcl.init]p14:
748 // [...] If the class is an aggregate (8.5.1), and the initializer
749 // is a brace-enclosed list, see 8.5.1.
750 //
751 // Note: 8.5.1 is handled below; here, we diagnose the case where
752 // we have an initializer list and a destination type that is not
753 // an aggregate.
754 // FIXME: In C++0x, this is yet another form of initialization.
755 if (const RecordType *ClassRec = DeclType->getAsRecordType()) {
756 const CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(ClassRec->getDecl());
757 if (!ClassDecl->isAggregate())
Chris Lattnerdcd5ef12008-11-19 05:27:50 +0000758 return Diag(InitLoc, diag::err_init_non_aggr_init_list)
Chris Lattnerd1625842008-11-24 06:25:27 +0000759 << DeclType << Init->getSourceRange();
Douglas Gregor64bffa92008-11-05 16:20:31 +0000760 }
Steve Naroff2fdc3742007-12-10 22:44:33 +0000761 }
Eli Friedmane6f058f2008-06-06 19:40:52 +0000762
Steve Naroff0cca7492008-05-01 22:18:59 +0000763 InitListChecker CheckInitList(this, InitList, DeclType);
764 return CheckInitList.HadError();
Steve Narofff0090632007-09-02 02:04:30 +0000765}
766
Douglas Gregor10bd3682008-11-17 22:58:34 +0000767/// GetNameForDeclarator - Determine the full declaration name for the
768/// given Declarator.
769DeclarationName Sema::GetNameForDeclarator(Declarator &D) {
770 switch (D.getKind()) {
771 case Declarator::DK_Abstract:
772 assert(D.getIdentifier() == 0 && "abstract declarators have no name");
773 return DeclarationName();
774
775 case Declarator::DK_Normal:
776 assert (D.getIdentifier() != 0 && "normal declarators have an identifier");
777 return DeclarationName(D.getIdentifier());
778
779 case Declarator::DK_Constructor: {
780 QualType Ty = Context.getTypeDeclType((TypeDecl *)D.getDeclaratorIdType());
781 Ty = Context.getCanonicalType(Ty);
782 return Context.DeclarationNames.getCXXConstructorName(Ty);
783 }
784
785 case Declarator::DK_Destructor: {
786 QualType Ty = Context.getTypeDeclType((TypeDecl *)D.getDeclaratorIdType());
787 Ty = Context.getCanonicalType(Ty);
788 return Context.DeclarationNames.getCXXDestructorName(Ty);
789 }
790
791 case Declarator::DK_Conversion: {
792 QualType Ty = QualType::getFromOpaquePtr(D.getDeclaratorIdType());
793 Ty = Context.getCanonicalType(Ty);
794 return Context.DeclarationNames.getCXXConversionFunctionName(Ty);
795 }
Douglas Gregore94ca9e42008-11-18 14:39:36 +0000796
797 case Declarator::DK_Operator:
798 assert(D.getIdentifier() == 0 && "operator names have no identifier");
799 return Context.DeclarationNames.getCXXOperatorName(
800 D.getOverloadedOperator());
Douglas Gregor10bd3682008-11-17 22:58:34 +0000801 }
802
803 assert(false && "Unknown name kind");
804 return DeclarationName();
805}
806
Fariborz Jahanian306d68f2007-11-08 23:49:49 +0000807Sema::DeclTy *
Daniel Dunbar914701e2008-08-05 16:28:08 +0000808Sema::ActOnDeclarator(Scope *S, Declarator &D, DeclTy *lastDecl) {
Steve Naroff94745042007-09-13 23:52:58 +0000809 ScopedDecl *LastDeclarator = dyn_cast_or_null<ScopedDecl>((Decl *)lastDecl);
Douglas Gregor10bd3682008-11-17 22:58:34 +0000810 DeclarationName Name = GetNameForDeclarator(D);
811
Chris Lattnere80a59c2007-07-25 00:24:17 +0000812 // All of these full declarators require an identifier. If it doesn't have
813 // one, the ParsedFreeStandingDeclSpec action should be used.
Douglas Gregor10bd3682008-11-17 22:58:34 +0000814 if (!Name) {
Chris Lattner1f6f54b2008-11-11 06:13:16 +0000815 if (!D.getInvalidType()) // Reject this if we think it is valid.
816 Diag(D.getDeclSpec().getSourceRange().getBegin(),
Chris Lattnerfa25bbb2008-11-19 05:08:23 +0000817 diag::err_declarator_need_ident)
818 << D.getDeclSpec().getSourceRange() << D.getSourceRange();
Chris Lattnere80a59c2007-07-25 00:24:17 +0000819 return 0;
820 }
821
Chris Lattner31e05722007-08-26 06:24:45 +0000822 // The scope passed in may not be a decl scope. Zip up the scope tree until
823 // we find one that is.
824 while ((S->getFlags() & Scope::DeclScope) == 0)
825 S = S->getParent();
826
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +0000827 DeclContext *DC;
828 Decl *PrevDecl;
Steve Naroffc752d042007-09-13 18:10:37 +0000829 ScopedDecl *New;
Steve Naroff5912a352007-08-28 20:14:24 +0000830 bool InvalidDecl = false;
Douglas Gregor2ce52f32008-04-13 21:07:44 +0000831
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +0000832 // See if this is a redefinition of a variable in the same scope.
833 if (!D.getCXXScopeSpec().isSet()) {
834 DC = CurContext;
Douglas Gregor10bd3682008-11-17 22:58:34 +0000835 PrevDecl = LookupDecl(Name, Decl::IDNS_Ordinary, S);
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +0000836 } else { // Something like "int foo::x;"
837 DC = static_cast<DeclContext*>(D.getCXXScopeSpec().getScopeRep());
Douglas Gregor10bd3682008-11-17 22:58:34 +0000838 PrevDecl = LookupDecl(Name, Decl::IDNS_Ordinary, S, DC);
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +0000839
840 // C++ 7.3.1.2p2:
841 // Members (including explicit specializations of templates) of a named
842 // namespace can also be defined outside that namespace by explicit
843 // qualification of the name being defined, provided that the entity being
844 // defined was already declared in the namespace and the definition appears
845 // after the point of declaration in a namespace that encloses the
846 // declarations namespace.
847 //
848 if (PrevDecl == 0) {
849 // No previous declaration in the qualifying scope.
Chris Lattnerd3a94e22008-11-20 06:06:08 +0000850 Diag(D.getIdentifierLoc(), diag::err_typecheck_no_member)
Chris Lattner08631c52008-11-23 21:45:46 +0000851 << Name << D.getCXXScopeSpec().getRange();
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +0000852 } else if (!CurContext->Encloses(DC)) {
853 // The qualifying scope doesn't enclose the original declaration.
854 // Emit diagnostic based on current scope.
855 SourceLocation L = D.getIdentifierLoc();
856 SourceRange R = D.getCXXScopeSpec().getRange();
857 if (isa<FunctionDecl>(CurContext)) {
Chris Lattner011bb4e2008-11-23 20:28:15 +0000858 Diag(L, diag::err_invalid_declarator_in_function) << Name << R;
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +0000859 } else {
Chris Lattner011bb4e2008-11-23 20:28:15 +0000860 Diag(L, diag::err_invalid_declarator_scope)
Chris Lattnerd9d22dd2008-11-24 05:29:24 +0000861 << Name << cast<NamedDecl>(DC)->getDeclName() << R;
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +0000862 }
863 }
864 }
865
Douglas Gregor2ce52f32008-04-13 21:07:44 +0000866 // In C++, the previous declaration we find might be a tag type
867 // (class or enum). In this case, the new declaration will hide the
868 // tag type.
869 if (PrevDecl && PrevDecl->getIdentifierNamespace() == Decl::IDNS_Tag)
870 PrevDecl = 0;
871
Chris Lattner41af0932007-11-14 06:34:38 +0000872 QualType R = GetTypeForDeclarator(D, S);
873 assert(!R.isNull() && "GetTypeForDeclarator() returned null type");
874
Reid Spencer5f016e22007-07-11 17:01:13 +0000875 if (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_typedef) {
Douglas Gregor6d6eb572008-05-07 04:49:29 +0000876 // Check that there are no default arguments (C++ only).
877 if (getLangOptions().CPlusPlus)
878 CheckExtraCXXDefaultArguments(D);
879
Chris Lattner41af0932007-11-14 06:34:38 +0000880 TypedefDecl *NewTD = ParseTypedefDecl(S, D, R, LastDeclarator);
Reid Spencer5f016e22007-07-11 17:01:13 +0000881 if (!NewTD) return 0;
882
883 // Handle attributes prior to checking for duplicates in MergeVarDecl
Chris Lattner3ff30c82008-06-29 00:02:00 +0000884 ProcessDeclAttributes(NewTD, D);
Steve Naroffffce4d52008-01-09 23:34:55 +0000885 // Merge the decl with the existing one if appropriate. If the decl is
886 // in an outer scope, it isn't the same thing.
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +0000887 if (PrevDecl && isDeclInScope(PrevDecl, DC, S)) {
Reid Spencer5f016e22007-07-11 17:01:13 +0000888 NewTD = MergeTypeDefDecl(NewTD, PrevDecl);
889 if (NewTD == 0) return 0;
890 }
891 New = NewTD;
Argyrios Kyrtzidis00bc6452008-05-09 23:39:43 +0000892 if (S->getFnParent() == 0) {
Reid Spencer5f016e22007-07-11 17:01:13 +0000893 // C99 6.7.7p2: If a typedef name specifies a variably modified type
894 // then it shall have block scope.
Eli Friedman9db13972008-02-15 12:53:51 +0000895 if (NewTD->getUnderlyingType()->isVariablyModifiedType()) {
896 // FIXME: Diagnostic needs to be fixed.
897 Diag(D.getIdentifierLoc(), diag::err_typecheck_illegal_vla);
Steve Naroffd7444aa2007-08-31 17:20:07 +0000898 InvalidDecl = true;
Reid Spencer5f016e22007-07-11 17:01:13 +0000899 }
900 }
Chris Lattner41af0932007-11-14 06:34:38 +0000901 } else if (R.getTypePtr()->isFunctionType()) {
Chris Lattner271f1a62007-09-27 15:15:46 +0000902 FunctionDecl::StorageClass SC = FunctionDecl::None;
Reid Spencer5f016e22007-07-11 17:01:13 +0000903 switch (D.getDeclSpec().getStorageClassSpec()) {
904 default: assert(0 && "Unknown storage class!");
905 case DeclSpec::SCS_auto:
906 case DeclSpec::SCS_register:
Sebastian Redl669d5d72008-11-14 23:42:31 +0000907 case DeclSpec::SCS_mutable:
Chris Lattnerd1625842008-11-24 06:25:27 +0000908 Diag(D.getIdentifierLoc(), diag::err_typecheck_sclass_func);
Steve Naroff5912a352007-08-28 20:14:24 +0000909 InvalidDecl = true;
910 break;
Reid Spencer5f016e22007-07-11 17:01:13 +0000911 case DeclSpec::SCS_unspecified: SC = FunctionDecl::None; break;
912 case DeclSpec::SCS_extern: SC = FunctionDecl::Extern; break;
913 case DeclSpec::SCS_static: SC = FunctionDecl::Static; break;
Steve Naroff7dd0bd42008-01-28 21:57:15 +0000914 case DeclSpec::SCS_private_extern: SC = FunctionDecl::PrivateExtern;break;
Reid Spencer5f016e22007-07-11 17:01:13 +0000915 }
916
Chris Lattnera98e58d2008-03-15 21:24:04 +0000917 bool isInline = D.getDeclSpec().isInlineSpecified();
Douglas Gregor42a552f2008-11-05 20:51:48 +0000918 // bool isVirtual = D.getDeclSpec().isVirtualSpecified();
Douglas Gregorb48fe382008-10-31 09:07:45 +0000919 bool isExplicit = D.getDeclSpec().isExplicitSpecified();
920
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000921 FunctionDecl *NewFD;
Douglas Gregor42a552f2008-11-05 20:51:48 +0000922 if (D.getKind() == Declarator::DK_Constructor) {
Douglas Gregorb48fe382008-10-31 09:07:45 +0000923 // This is a C++ constructor declaration.
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +0000924 assert(DC->isCXXRecord() &&
Douglas Gregorb48fe382008-10-31 09:07:45 +0000925 "Constructors can only be declared in a member context");
926
Douglas Gregor42a552f2008-11-05 20:51:48 +0000927 bool isInvalidDecl = CheckConstructorDeclarator(D, R, SC);
Douglas Gregorb48fe382008-10-31 09:07:45 +0000928
929 // Create the new declaration
930 NewFD = CXXConstructorDecl::Create(Context,
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +0000931 cast<CXXRecordDecl>(DC),
Douglas Gregor10bd3682008-11-17 22:58:34 +0000932 D.getIdentifierLoc(), Name, R,
Douglas Gregorb48fe382008-10-31 09:07:45 +0000933 isExplicit, isInline,
934 /*isImplicitlyDeclared=*/false);
935
Douglas Gregor42a552f2008-11-05 20:51:48 +0000936 if (isInvalidDecl)
937 NewFD->setInvalidDecl();
938 } else if (D.getKind() == Declarator::DK_Destructor) {
939 // This is a C++ destructor declaration.
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +0000940 if (DC->isCXXRecord()) {
Argyrios Kyrtzidisc7ed9c62008-11-07 22:02:30 +0000941 bool isInvalidDecl = CheckDestructorDeclarator(D, R, SC);
Douglas Gregor42a552f2008-11-05 20:51:48 +0000942
Argyrios Kyrtzidisc7ed9c62008-11-07 22:02:30 +0000943 NewFD = CXXDestructorDecl::Create(Context,
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +0000944 cast<CXXRecordDecl>(DC),
Douglas Gregor10bd3682008-11-17 22:58:34 +0000945 D.getIdentifierLoc(), Name, R,
Argyrios Kyrtzidisc7ed9c62008-11-07 22:02:30 +0000946 isInline,
947 /*isImplicitlyDeclared=*/false);
Douglas Gregor42a552f2008-11-05 20:51:48 +0000948
Argyrios Kyrtzidisc7ed9c62008-11-07 22:02:30 +0000949 if (isInvalidDecl)
950 NewFD->setInvalidDecl();
951 } else {
952 Diag(D.getIdentifierLoc(), diag::err_destructor_not_member);
953 // Create a FunctionDecl to satisfy the function definition parsing
954 // code path.
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +0000955 NewFD = FunctionDecl::Create(Context, DC, D.getIdentifierLoc(),
Douglas Gregor10bd3682008-11-17 22:58:34 +0000956 Name, R, SC, isInline, LastDeclarator,
Argyrios Kyrtzidisc7ed9c62008-11-07 22:02:30 +0000957 // FIXME: Move to DeclGroup...
958 D.getDeclSpec().getSourceRange().getBegin());
Douglas Gregor42a552f2008-11-05 20:51:48 +0000959 NewFD->setInvalidDecl();
Argyrios Kyrtzidisc7ed9c62008-11-07 22:02:30 +0000960 }
Douglas Gregor2f1bc522008-11-07 20:08:42 +0000961 } else if (D.getKind() == Declarator::DK_Conversion) {
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +0000962 if (!DC->isCXXRecord()) {
Douglas Gregor2f1bc522008-11-07 20:08:42 +0000963 Diag(D.getIdentifierLoc(),
964 diag::err_conv_function_not_member);
965 return 0;
966 } else {
967 bool isInvalidDecl = CheckConversionDeclarator(D, R, SC);
968
969 NewFD = CXXConversionDecl::Create(Context,
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +0000970 cast<CXXRecordDecl>(DC),
Douglas Gregor10bd3682008-11-17 22:58:34 +0000971 D.getIdentifierLoc(), Name, R,
Douglas Gregor2f1bc522008-11-07 20:08:42 +0000972 isInline, isExplicit);
973
974 if (isInvalidDecl)
975 NewFD->setInvalidDecl();
976 }
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +0000977 } else if (DC->isCXXRecord()) {
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000978 // This is a C++ method declaration.
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +0000979 NewFD = CXXMethodDecl::Create(Context, cast<CXXRecordDecl>(DC),
Douglas Gregor10bd3682008-11-17 22:58:34 +0000980 D.getIdentifierLoc(), Name, R,
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000981 (SC == FunctionDecl::Static), isInline,
982 LastDeclarator);
983 } else {
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +0000984 NewFD = FunctionDecl::Create(Context, DC,
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000985 D.getIdentifierLoc(),
Douglas Gregor10bd3682008-11-17 22:58:34 +0000986 Name, R, SC, isInline, LastDeclarator,
Steve Naroff0eb07bf2008-10-03 00:02:03 +0000987 // FIXME: Move to DeclGroup...
988 D.getDeclSpec().getSourceRange().getBegin());
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000989 }
Ted Kremenekf5c93c12008-02-27 22:18:07 +0000990 // Handle attributes.
Chris Lattner3ff30c82008-06-29 00:02:00 +0000991 ProcessDeclAttributes(NewFD, D);
Chris Lattner04421082008-04-08 04:40:51 +0000992
Daniel Dunbara80f8742008-08-05 01:35:17 +0000993 // Handle GNU asm-label extension (encoded as an attribute).
Daniel Dunbar914701e2008-08-05 16:28:08 +0000994 if (Expr *E = (Expr*) D.getAsmLabel()) {
Daniel Dunbara80f8742008-08-05 01:35:17 +0000995 // The parser guarantees this is a string.
996 StringLiteral *SE = cast<StringLiteral>(E);
997 NewFD->addAttr(new AsmLabelAttr(std::string(SE->getStrData(),
998 SE->getByteLength())));
999 }
1000
Chris Lattner04421082008-04-08 04:40:51 +00001001 // Copy the parameter declarations from the declarator D to
1002 // the function declaration NewFD, if they are available.
Eli Friedmaneb4b7052008-08-25 21:31:01 +00001003 if (D.getNumTypeObjects() > 0) {
Chris Lattner04421082008-04-08 04:40:51 +00001004 DeclaratorChunk::FunctionTypeInfo &FTI = D.getTypeObject(0).Fun;
1005
1006 // Create Decl objects for each parameter, adding them to the
1007 // FunctionDecl.
1008 llvm::SmallVector<ParmVarDecl*, 16> Params;
1009
1010 // Check for C99 6.7.5.3p10 - foo(void) is a non-varargs
1011 // function that takes no arguments, not a function that takes a
Chris Lattner8123a952008-04-10 02:22:51 +00001012 // single void argument.
Eli Friedman6d1e4b52008-05-22 08:54:03 +00001013 // We let through "const void" here because Sema::GetTypeForDeclarator
1014 // already checks for that case.
Chris Lattner04421082008-04-08 04:40:51 +00001015 if (FTI.NumArgs == 1 && !FTI.isVariadic && FTI.ArgInfo[0].Ident == 0 &&
1016 FTI.ArgInfo[0].Param &&
Chris Lattner04421082008-04-08 04:40:51 +00001017 ((ParmVarDecl*)FTI.ArgInfo[0].Param)->getType()->isVoidType()) {
1018 // empty arg list, don't push any params.
Chris Lattner8123a952008-04-10 02:22:51 +00001019 ParmVarDecl *Param = (ParmVarDecl*)FTI.ArgInfo[0].Param;
1020
Chris Lattnerdef026a2008-04-10 02:26:16 +00001021 // In C++, the empty parameter-type-list must be spelled "void"; a
1022 // typedef of void is not permitted.
1023 if (getLangOptions().CPlusPlus &&
Eli Friedman6d1e4b52008-05-22 08:54:03 +00001024 Param->getType().getUnqualifiedType() != Context.VoidTy) {
Chris Lattner8123a952008-04-10 02:22:51 +00001025 Diag(Param->getLocation(), diag::ext_param_typedef_of_void);
1026 }
Eli Friedmaneb4b7052008-08-25 21:31:01 +00001027 } else if (FTI.NumArgs > 0 && FTI.ArgInfo[0].Param != 0) {
Chris Lattner04421082008-04-08 04:40:51 +00001028 for (unsigned i = 0, e = FTI.NumArgs; i != e; ++i)
1029 Params.push_back((ParmVarDecl *)FTI.ArgInfo[i].Param);
1030 }
1031
1032 NewFD->setParams(&Params[0], Params.size());
Douglas Gregor6cbd3df2008-10-24 18:09:54 +00001033 } else if (R->getAsTypedefType()) {
1034 // When we're declaring a function with a typedef, as in the
1035 // following example, we'll need to synthesize (unnamed)
1036 // parameters for use in the declaration.
1037 //
1038 // @code
1039 // typedef void fn(int);
1040 // fn f;
1041 // @endcode
1042 const FunctionTypeProto *FT = R->getAsFunctionTypeProto();
1043 if (!FT) {
1044 // This is a typedef of a function with no prototype, so we
1045 // don't need to do anything.
1046 } else if ((FT->getNumArgs() == 0) ||
1047 (FT->getNumArgs() == 1 && !FT->isVariadic() &&
1048 FT->getArgType(0)->isVoidType())) {
1049 // This is a zero-argument function. We don't need to do anything.
1050 } else {
1051 // Synthesize a parameter for each argument type.
1052 llvm::SmallVector<ParmVarDecl*, 16> Params;
1053 for (FunctionTypeProto::arg_type_iterator ArgType = FT->arg_type_begin();
1054 ArgType != FT->arg_type_end(); ++ArgType) {
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +00001055 Params.push_back(ParmVarDecl::Create(Context, DC,
Douglas Gregor6cbd3df2008-10-24 18:09:54 +00001056 SourceLocation(), 0,
1057 *ArgType, VarDecl::None,
1058 0, 0));
1059 }
1060
1061 NewFD->setParams(&Params[0], Params.size());
1062 }
Chris Lattner04421082008-04-08 04:40:51 +00001063 }
1064
Douglas Gregor42a552f2008-11-05 20:51:48 +00001065 // C++ constructors and destructors are handled by separate
1066 // routines, since they don't require any declaration merging (C++
1067 // [class.mfct]p2) and they aren't ever pushed into scope, because
1068 // they can't be found by name lookup anyway (C++ [class.ctor]p2).
1069 if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(NewFD))
1070 return ActOnConstructorDeclarator(Constructor);
1071 else if (CXXDestructorDecl *Destructor = dyn_cast<CXXDestructorDecl>(NewFD))
1072 return ActOnDestructorDeclarator(Destructor);
Douglas Gregor2def4832008-11-17 20:34:05 +00001073
1074 // Extra checking for conversion functions, including recording
1075 // the conversion function in its class.
1076 if (CXXConversionDecl *Conversion = dyn_cast<CXXConversionDecl>(NewFD))
1077 ActOnConversionDeclarator(Conversion);
Douglas Gregorb48fe382008-10-31 09:07:45 +00001078
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00001079 // Extra checking for C++ overloaded operators (C++ [over.oper]).
1080 if (NewFD->isOverloadedOperator() &&
1081 CheckOverloadedOperatorDeclaration(NewFD))
1082 NewFD->setInvalidDecl();
1083
Steve Naroffffce4d52008-01-09 23:34:55 +00001084 // Merge the decl with the existing one if appropriate. Since C functions
1085 // are in a flat namespace, make sure we consider decls in outer scopes.
Argyrios Kyrtzidis00bc6452008-05-09 23:39:43 +00001086 if (PrevDecl &&
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +00001087 (!getLangOptions().CPlusPlus||isDeclInScope(PrevDecl, DC, S))) {
Douglas Gregorf0097952008-04-21 02:02:58 +00001088 bool Redeclaration = false;
Douglas Gregor8e9bebd2008-10-21 16:13:35 +00001089
1090 // If C++, determine whether NewFD is an overload of PrevDecl or
1091 // a declaration that requires merging. If it's an overload,
1092 // there's no more work to do here; we'll just add the new
1093 // function to the scope.
1094 OverloadedFunctionDecl::function_iterator MatchedDecl;
1095 if (!getLangOptions().CPlusPlus ||
1096 !IsOverload(NewFD, PrevDecl, MatchedDecl)) {
1097 Decl *OldDecl = PrevDecl;
1098
1099 // If PrevDecl was an overloaded function, extract the
1100 // FunctionDecl that matched.
1101 if (isa<OverloadedFunctionDecl>(PrevDecl))
1102 OldDecl = *MatchedDecl;
1103
1104 // NewFD and PrevDecl represent declarations that need to be
1105 // merged.
1106 NewFD = MergeFunctionDecl(NewFD, OldDecl, Redeclaration);
1107
1108 if (NewFD == 0) return 0;
1109 if (Redeclaration) {
1110 NewFD->setPreviousDeclaration(cast<FunctionDecl>(OldDecl));
1111
1112 if (OldDecl == PrevDecl) {
1113 // Remove the name binding for the previous
1114 // declaration. We'll add the binding back later, but then
1115 // it will refer to the new declaration (which will
1116 // contain more information).
1117 IdResolver.RemoveDecl(cast<NamedDecl>(PrevDecl));
1118 } else {
1119 // We need to update the OverloadedFunctionDecl with the
1120 // latest declaration of this function, so that name
1121 // lookup will always refer to the latest declaration of
1122 // this function.
1123 *MatchedDecl = NewFD;
1124
1125 // Add the redeclaration to the current scope, since we'll
1126 // be skipping PushOnScopeChains.
1127 S->AddDecl(NewFD);
1128
1129 return NewFD;
1130 }
1131 }
Douglas Gregorf0097952008-04-21 02:02:58 +00001132 }
Reid Spencer5f016e22007-07-11 17:01:13 +00001133 }
1134 New = NewFD;
Chris Lattner04421082008-04-08 04:40:51 +00001135
1136 // In C++, check default arguments now that we have merged decls.
1137 if (getLangOptions().CPlusPlus)
1138 CheckCXXDefaultArguments(NewFD);
Reid Spencer5f016e22007-07-11 17:01:13 +00001139 } else {
Douglas Gregor6d6eb572008-05-07 04:49:29 +00001140 // Check that there are no default arguments (C++ only).
1141 if (getLangOptions().CPlusPlus)
1142 CheckExtraCXXDefaultArguments(D);
1143
Ted Kremeneka526c5c2008-01-07 19:49:32 +00001144 if (R.getTypePtr()->isObjCInterfaceType()) {
Chris Lattner3c73c412008-11-19 08:23:25 +00001145 Diag(D.getIdentifierLoc(), diag::err_statically_allocated_object)
1146 << D.getIdentifier();
Fariborz Jahaniane7f64cc2007-10-12 22:10:42 +00001147 InvalidDecl = true;
1148 }
Reid Spencer5f016e22007-07-11 17:01:13 +00001149
1150 VarDecl *NewVD;
1151 VarDecl::StorageClass SC;
1152 switch (D.getDeclSpec().getStorageClassSpec()) {
Chris Lattner9e151e12008-03-15 21:10:16 +00001153 default: assert(0 && "Unknown storage class!");
1154 case DeclSpec::SCS_unspecified: SC = VarDecl::None; break;
1155 case DeclSpec::SCS_extern: SC = VarDecl::Extern; break;
1156 case DeclSpec::SCS_static: SC = VarDecl::Static; break;
1157 case DeclSpec::SCS_auto: SC = VarDecl::Auto; break;
1158 case DeclSpec::SCS_register: SC = VarDecl::Register; break;
1159 case DeclSpec::SCS_private_extern: SC = VarDecl::PrivateExtern; break;
Sebastian Redl669d5d72008-11-14 23:42:31 +00001160 case DeclSpec::SCS_mutable:
1161 // mutable can only appear on non-static class members, so it's always
1162 // an error here
1163 Diag(D.getIdentifierLoc(), diag::err_mutable_nonmember);
1164 InvalidDecl = true;
Douglas Gregore89b0282008-12-01 22:46:22 +00001165 SC = VarDecl::None;
Sebastian Redla11f42f2008-11-17 23:24:37 +00001166 break;
Sebastian Redl669d5d72008-11-14 23:42:31 +00001167 }
Douglas Gregor10bd3682008-11-17 22:58:34 +00001168
1169 IdentifierInfo *II = Name.getAsIdentifierInfo();
1170 if (!II) {
Chris Lattnerf3a41af2008-11-20 06:38:18 +00001171 Diag(D.getIdentifierLoc(), diag::err_bad_variable_name)
1172 << Name.getAsString();
Douglas Gregor10bd3682008-11-17 22:58:34 +00001173 return 0;
1174 }
1175
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +00001176 if (DC->isCXXRecord()) {
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +00001177 assert(SC == VarDecl::Static && "Invalid storage class for member!");
1178 // This is a static data member for a C++ class.
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +00001179 NewVD = CXXClassVarDecl::Create(Context, cast<CXXRecordDecl>(DC),
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +00001180 D.getIdentifierLoc(), II,
1181 R, LastDeclarator);
Steve Narofff0090632007-09-02 02:04:30 +00001182 } else {
Daniel Dunbar6f0200e2008-09-08 20:05:47 +00001183 bool ThreadSpecified = D.getDeclSpec().isThreadSpecified();
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +00001184 if (S->getFnParent() == 0) {
1185 // C99 6.9p2: The storage-class specifiers auto and register shall not
1186 // appear in the declaration specifiers in an external declaration.
1187 if (SC == VarDecl::Auto || SC == VarDecl::Register) {
Chris Lattnerd1625842008-11-24 06:25:27 +00001188 Diag(D.getIdentifierLoc(), diag::err_typecheck_sclass_fscope);
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +00001189 InvalidDecl = true;
1190 }
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +00001191 }
Sebastian Redl669d5d72008-11-14 23:42:31 +00001192 NewVD = VarDecl::Create(Context, DC, D.getIdentifierLoc(),
1193 II, R, SC, LastDeclarator,
1194 // FIXME: Move to DeclGroup...
1195 D.getDeclSpec().getSourceRange().getBegin());
1196 NewVD->setThreadSpecified(ThreadSpecified);
Steve Naroff53a32342007-08-28 18:45:29 +00001197 }
Reid Spencer5f016e22007-07-11 17:01:13 +00001198 // Handle attributes prior to checking for duplicates in MergeVarDecl
Chris Lattner3ff30c82008-06-29 00:02:00 +00001199 ProcessDeclAttributes(NewVD, D);
Nate Begemanc8e89a82008-03-14 18:07:10 +00001200
Daniel Dunbara735ad82008-08-06 00:03:29 +00001201 // Handle GNU asm-label extension (encoded as an attribute).
1202 if (Expr *E = (Expr*) D.getAsmLabel()) {
1203 // The parser guarantees this is a string.
1204 StringLiteral *SE = cast<StringLiteral>(E);
1205 NewVD->addAttr(new AsmLabelAttr(std::string(SE->getStrData(),
1206 SE->getByteLength())));
1207 }
1208
Nate Begemanc8e89a82008-03-14 18:07:10 +00001209 // Emit an error if an address space was applied to decl with local storage.
1210 // This includes arrays of objects with address space qualifiers, but not
1211 // automatic variables that point to other address spaces.
1212 // ISO/IEC TR 18037 S5.1.2
Nate Begeman8e7dafe2008-03-25 18:36:32 +00001213 if (NewVD->hasLocalStorage() && (NewVD->getType().getAddressSpace() != 0)) {
1214 Diag(D.getIdentifierLoc(), diag::err_as_qualified_auto_decl);
1215 InvalidDecl = true;
Nate Begeman5af27e02008-03-14 00:22:18 +00001216 }
Steve Naroffffce4d52008-01-09 23:34:55 +00001217 // Merge the decl with the existing one if appropriate. If the decl is
1218 // in an outer scope, it isn't the same thing.
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +00001219 if (PrevDecl && isDeclInScope(PrevDecl, DC, S)) {
Reid Spencer5f016e22007-07-11 17:01:13 +00001220 NewVD = MergeVarDecl(NewVD, PrevDecl);
1221 if (NewVD == 0) return 0;
1222 }
Reid Spencer5f016e22007-07-11 17:01:13 +00001223 New = NewVD;
1224 }
1225
Argyrios Kyrtzidis52393042008-11-09 23:41:00 +00001226 // Set the lexical context. If the declarator has a C++ scope specifier, the
1227 // lexical context will be different from the semantic context.
1228 New->setLexicalDeclContext(CurContext);
1229
Reid Spencer5f016e22007-07-11 17:01:13 +00001230 // If this has an identifier, add it to the scope stack.
Douglas Gregor10bd3682008-11-17 22:58:34 +00001231 if (Name)
Argyrios Kyrtzidis87f3ff02008-04-12 00:47:19 +00001232 PushOnScopeChains(New, S);
Steve Naroff5912a352007-08-28 20:14:24 +00001233 // If any semantic error occurred, mark the decl as invalid.
1234 if (D.getInvalidType() || InvalidDecl)
1235 New->setInvalidDecl();
Reid Spencer5f016e22007-07-11 17:01:13 +00001236
1237 return New;
1238}
1239
Steve Naroff6594a702008-10-27 11:34:16 +00001240void Sema::InitializerElementNotConstant(const Expr *Init) {
Chris Lattnerdcd5ef12008-11-19 05:27:50 +00001241 Diag(Init->getExprLoc(), diag::err_init_element_not_constant)
1242 << Init->getSourceRange();
Steve Naroff6594a702008-10-27 11:34:16 +00001243}
1244
Eli Friedmanc594b322008-05-20 13:48:25 +00001245bool Sema::CheckAddressConstantExpressionLValue(const Expr* Init) {
1246 switch (Init->getStmtClass()) {
1247 default:
Steve Naroff6594a702008-10-27 11:34:16 +00001248 InitializerElementNotConstant(Init);
Eli Friedmanc594b322008-05-20 13:48:25 +00001249 return true;
1250 case Expr::ParenExprClass: {
1251 const ParenExpr* PE = cast<ParenExpr>(Init);
1252 return CheckAddressConstantExpressionLValue(PE->getSubExpr());
1253 }
1254 case Expr::CompoundLiteralExprClass:
1255 return cast<CompoundLiteralExpr>(Init)->isFileScope();
1256 case Expr::DeclRefExprClass: {
1257 const Decl *D = cast<DeclRefExpr>(Init)->getDecl();
Eli Friedman97c0a392008-05-21 03:39:11 +00001258 if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
1259 if (VD->hasGlobalStorage())
1260 return false;
Steve Naroff6594a702008-10-27 11:34:16 +00001261 InitializerElementNotConstant(Init);
Eli Friedman97c0a392008-05-21 03:39:11 +00001262 return true;
1263 }
Eli Friedmanc594b322008-05-20 13:48:25 +00001264 if (isa<FunctionDecl>(D))
1265 return false;
Steve Naroff6594a702008-10-27 11:34:16 +00001266 InitializerElementNotConstant(Init);
Steve Naroffd0091aa2008-01-10 22:15:12 +00001267 return true;
1268 }
Eli Friedmanc594b322008-05-20 13:48:25 +00001269 case Expr::MemberExprClass: {
1270 const MemberExpr *M = cast<MemberExpr>(Init);
1271 if (M->isArrow())
1272 return CheckAddressConstantExpression(M->getBase());
1273 return CheckAddressConstantExpressionLValue(M->getBase());
1274 }
1275 case Expr::ArraySubscriptExprClass: {
1276 // FIXME: Should we pedwarn for "x[0+0]" (where x is a pointer)?
1277 const ArraySubscriptExpr *ASE = cast<ArraySubscriptExpr>(Init);
1278 return CheckAddressConstantExpression(ASE->getBase()) ||
1279 CheckArithmeticConstantExpression(ASE->getIdx());
1280 }
1281 case Expr::StringLiteralClass:
Chris Lattnerd9f69102008-08-10 01:53:14 +00001282 case Expr::PredefinedExprClass:
Eli Friedmanc594b322008-05-20 13:48:25 +00001283 return false;
1284 case Expr::UnaryOperatorClass: {
1285 const UnaryOperator *Exp = cast<UnaryOperator>(Init);
1286
1287 // C99 6.6p9
1288 if (Exp->getOpcode() == UnaryOperator::Deref)
Eli Friedman97c0a392008-05-21 03:39:11 +00001289 return CheckAddressConstantExpression(Exp->getSubExpr());
Eli Friedmanc594b322008-05-20 13:48:25 +00001290
Steve Naroff6594a702008-10-27 11:34:16 +00001291 InitializerElementNotConstant(Init);
Eli Friedmanc594b322008-05-20 13:48:25 +00001292 return true;
1293 }
1294 }
1295}
1296
1297bool Sema::CheckAddressConstantExpression(const Expr* Init) {
1298 switch (Init->getStmtClass()) {
1299 default:
Steve Naroff6594a702008-10-27 11:34:16 +00001300 InitializerElementNotConstant(Init);
Eli Friedmanc594b322008-05-20 13:48:25 +00001301 return true;
Chris Lattner506ff882008-10-06 07:26:43 +00001302 case Expr::ParenExprClass:
1303 return CheckAddressConstantExpression(cast<ParenExpr>(Init)->getSubExpr());
Eli Friedmanc594b322008-05-20 13:48:25 +00001304 case Expr::StringLiteralClass:
1305 case Expr::ObjCStringLiteralClass:
1306 return false;
Chris Lattner506ff882008-10-06 07:26:43 +00001307 case Expr::CallExprClass:
Douglas Gregorb4609802008-11-14 16:09:21 +00001308 case Expr::CXXOperatorCallExprClass:
Chris Lattner506ff882008-10-06 07:26:43 +00001309 // __builtin___CFStringMakeConstantString is a valid constant l-value.
1310 if (cast<CallExpr>(Init)->isBuiltinCall() ==
1311 Builtin::BI__builtin___CFStringMakeConstantString)
1312 return false;
1313
Steve Naroff6594a702008-10-27 11:34:16 +00001314 InitializerElementNotConstant(Init);
Chris Lattner506ff882008-10-06 07:26:43 +00001315 return true;
1316
Eli Friedmanc594b322008-05-20 13:48:25 +00001317 case Expr::UnaryOperatorClass: {
1318 const UnaryOperator *Exp = cast<UnaryOperator>(Init);
1319
1320 // C99 6.6p9
1321 if (Exp->getOpcode() == UnaryOperator::AddrOf)
1322 return CheckAddressConstantExpressionLValue(Exp->getSubExpr());
1323
1324 if (Exp->getOpcode() == UnaryOperator::Extension)
1325 return CheckAddressConstantExpression(Exp->getSubExpr());
1326
Steve Naroff6594a702008-10-27 11:34:16 +00001327 InitializerElementNotConstant(Init);
Eli Friedmanc594b322008-05-20 13:48:25 +00001328 return true;
1329 }
1330 case Expr::BinaryOperatorClass: {
1331 // FIXME: Should we pedwarn for expressions like "a + 1 + 2"?
1332 const BinaryOperator *Exp = cast<BinaryOperator>(Init);
1333
1334 Expr *PExp = Exp->getLHS();
1335 Expr *IExp = Exp->getRHS();
1336 if (IExp->getType()->isPointerType())
1337 std::swap(PExp, IExp);
1338
1339 // FIXME: Should we pedwarn if IExp isn't an integer constant expression?
1340 return CheckAddressConstantExpression(PExp) ||
1341 CheckArithmeticConstantExpression(IExp);
1342 }
Eli Friedmanc3f07642008-08-25 20:46:57 +00001343 case Expr::ImplicitCastExprClass:
Douglas Gregor6eec8e82008-10-28 15:36:24 +00001344 case Expr::CStyleCastExprClass: {
Eli Friedmanc594b322008-05-20 13:48:25 +00001345 const Expr* SubExpr = cast<CastExpr>(Init)->getSubExpr();
Eli Friedmanc3f07642008-08-25 20:46:57 +00001346 if (Init->getStmtClass() == Expr::ImplicitCastExprClass) {
1347 // Check for implicit promotion
1348 if (SubExpr->getType()->isFunctionType() ||
1349 SubExpr->getType()->isArrayType())
1350 return CheckAddressConstantExpressionLValue(SubExpr);
1351 }
Eli Friedmanc594b322008-05-20 13:48:25 +00001352
1353 // Check for pointer->pointer cast
1354 if (SubExpr->getType()->isPointerType())
1355 return CheckAddressConstantExpression(SubExpr);
1356
Eli Friedmanc3f07642008-08-25 20:46:57 +00001357 if (SubExpr->getType()->isIntegralType()) {
1358 // Check for the special-case of a pointer->int->pointer cast;
1359 // this isn't standard, but some code requires it. See
1360 // PR2720 for an example.
1361 if (const CastExpr* SubCast = dyn_cast<CastExpr>(SubExpr)) {
1362 if (SubCast->getSubExpr()->getType()->isPointerType()) {
1363 unsigned IntWidth = Context.getIntWidth(SubCast->getType());
1364 unsigned PointerWidth = Context.getTypeSize(Context.VoidPtrTy);
1365 if (IntWidth >= PointerWidth) {
1366 return CheckAddressConstantExpression(SubCast->getSubExpr());
1367 }
1368 }
1369 }
1370 }
1371 if (SubExpr->getType()->isArithmeticType()) {
Eli Friedmanc594b322008-05-20 13:48:25 +00001372 return CheckArithmeticConstantExpression(SubExpr);
Eli Friedmanc3f07642008-08-25 20:46:57 +00001373 }
Eli Friedmanc594b322008-05-20 13:48:25 +00001374
Steve Naroff6594a702008-10-27 11:34:16 +00001375 InitializerElementNotConstant(Init);
Eli Friedmanc594b322008-05-20 13:48:25 +00001376 return true;
1377 }
1378 case Expr::ConditionalOperatorClass: {
1379 // FIXME: Should we pedwarn here?
1380 const ConditionalOperator *Exp = cast<ConditionalOperator>(Init);
1381 if (!Exp->getCond()->getType()->isArithmeticType()) {
Steve Naroff6594a702008-10-27 11:34:16 +00001382 InitializerElementNotConstant(Init);
Eli Friedmanc594b322008-05-20 13:48:25 +00001383 return true;
1384 }
1385 if (CheckArithmeticConstantExpression(Exp->getCond()))
1386 return true;
1387 if (Exp->getLHS() &&
1388 CheckAddressConstantExpression(Exp->getLHS()))
1389 return true;
1390 return CheckAddressConstantExpression(Exp->getRHS());
1391 }
1392 case Expr::AddrLabelExprClass:
1393 return false;
1394 }
1395}
1396
Eli Friedman4caf0552008-06-09 05:05:07 +00001397static const Expr* FindExpressionBaseAddress(const Expr* E);
1398
1399static const Expr* FindExpressionBaseAddressLValue(const Expr* E) {
1400 switch (E->getStmtClass()) {
1401 default:
1402 return E;
1403 case Expr::ParenExprClass: {
1404 const ParenExpr* PE = cast<ParenExpr>(E);
1405 return FindExpressionBaseAddressLValue(PE->getSubExpr());
1406 }
1407 case Expr::MemberExprClass: {
1408 const MemberExpr *M = cast<MemberExpr>(E);
1409 if (M->isArrow())
1410 return FindExpressionBaseAddress(M->getBase());
1411 return FindExpressionBaseAddressLValue(M->getBase());
1412 }
1413 case Expr::ArraySubscriptExprClass: {
1414 const ArraySubscriptExpr *ASE = cast<ArraySubscriptExpr>(E);
1415 return FindExpressionBaseAddress(ASE->getBase());
1416 }
1417 case Expr::UnaryOperatorClass: {
1418 const UnaryOperator *Exp = cast<UnaryOperator>(E);
1419
1420 if (Exp->getOpcode() == UnaryOperator::Deref)
1421 return FindExpressionBaseAddress(Exp->getSubExpr());
1422
1423 return E;
1424 }
1425 }
1426}
1427
1428static const Expr* FindExpressionBaseAddress(const Expr* E) {
1429 switch (E->getStmtClass()) {
1430 default:
1431 return E;
1432 case Expr::ParenExprClass: {
1433 const ParenExpr* PE = cast<ParenExpr>(E);
1434 return FindExpressionBaseAddress(PE->getSubExpr());
1435 }
1436 case Expr::UnaryOperatorClass: {
1437 const UnaryOperator *Exp = cast<UnaryOperator>(E);
1438
1439 // C99 6.6p9
1440 if (Exp->getOpcode() == UnaryOperator::AddrOf)
1441 return FindExpressionBaseAddressLValue(Exp->getSubExpr());
1442
1443 if (Exp->getOpcode() == UnaryOperator::Extension)
1444 return FindExpressionBaseAddress(Exp->getSubExpr());
1445
1446 return E;
1447 }
1448 case Expr::BinaryOperatorClass: {
1449 const BinaryOperator *Exp = cast<BinaryOperator>(E);
1450
1451 Expr *PExp = Exp->getLHS();
1452 Expr *IExp = Exp->getRHS();
1453 if (IExp->getType()->isPointerType())
1454 std::swap(PExp, IExp);
1455
1456 return FindExpressionBaseAddress(PExp);
1457 }
1458 case Expr::ImplicitCastExprClass: {
1459 const Expr* SubExpr = cast<ImplicitCastExpr>(E)->getSubExpr();
1460
1461 // Check for implicit promotion
1462 if (SubExpr->getType()->isFunctionType() ||
1463 SubExpr->getType()->isArrayType())
1464 return FindExpressionBaseAddressLValue(SubExpr);
1465
1466 // Check for pointer->pointer cast
1467 if (SubExpr->getType()->isPointerType())
1468 return FindExpressionBaseAddress(SubExpr);
1469
1470 // We assume that we have an arithmetic expression here;
1471 // if we don't, we'll figure it out later
1472 return 0;
1473 }
Douglas Gregor6eec8e82008-10-28 15:36:24 +00001474 case Expr::CStyleCastExprClass: {
Eli Friedman4caf0552008-06-09 05:05:07 +00001475 const Expr* SubExpr = cast<CastExpr>(E)->getSubExpr();
1476
1477 // Check for pointer->pointer cast
1478 if (SubExpr->getType()->isPointerType())
1479 return FindExpressionBaseAddress(SubExpr);
1480
1481 // We assume that we have an arithmetic expression here;
1482 // if we don't, we'll figure it out later
1483 return 0;
1484 }
1485 }
1486}
1487
Anders Carlsson51fe9962008-11-22 21:04:56 +00001488bool Sema::CheckArithmeticConstantExpression(const Expr* Init) {
Eli Friedmanc594b322008-05-20 13:48:25 +00001489 switch (Init->getStmtClass()) {
1490 default:
Steve Naroff6594a702008-10-27 11:34:16 +00001491 InitializerElementNotConstant(Init);
Eli Friedmanc594b322008-05-20 13:48:25 +00001492 return true;
1493 case Expr::ParenExprClass: {
1494 const ParenExpr* PE = cast<ParenExpr>(Init);
1495 return CheckArithmeticConstantExpression(PE->getSubExpr());
1496 }
1497 case Expr::FloatingLiteralClass:
1498 case Expr::IntegerLiteralClass:
1499 case Expr::CharacterLiteralClass:
1500 case Expr::ImaginaryLiteralClass:
1501 case Expr::TypesCompatibleExprClass:
1502 case Expr::CXXBoolLiteralExprClass:
1503 return false;
Douglas Gregorb4609802008-11-14 16:09:21 +00001504 case Expr::CallExprClass:
1505 case Expr::CXXOperatorCallExprClass: {
Eli Friedmanc594b322008-05-20 13:48:25 +00001506 const CallExpr *CE = cast<CallExpr>(Init);
Chris Lattner45b6b9d2008-10-06 06:49:02 +00001507
1508 // Allow any constant foldable calls to builtins.
1509 if (CE->isBuiltinCall() && CE->isEvaluatable(Context))
Eli Friedmanc594b322008-05-20 13:48:25 +00001510 return false;
Chris Lattner45b6b9d2008-10-06 06:49:02 +00001511
Steve Naroff6594a702008-10-27 11:34:16 +00001512 InitializerElementNotConstant(Init);
Eli Friedmanc594b322008-05-20 13:48:25 +00001513 return true;
1514 }
1515 case Expr::DeclRefExprClass: {
1516 const Decl *D = cast<DeclRefExpr>(Init)->getDecl();
1517 if (isa<EnumConstantDecl>(D))
1518 return false;
Steve Naroff6594a702008-10-27 11:34:16 +00001519 InitializerElementNotConstant(Init);
Eli Friedmanc594b322008-05-20 13:48:25 +00001520 return true;
1521 }
1522 case Expr::CompoundLiteralExprClass:
1523 // Allow "(vector type){2,4}"; normal C constraints don't allow this,
1524 // but vectors are allowed to be magic.
1525 if (Init->getType()->isVectorType())
1526 return false;
Steve Naroff6594a702008-10-27 11:34:16 +00001527 InitializerElementNotConstant(Init);
Eli Friedmanc594b322008-05-20 13:48:25 +00001528 return true;
1529 case Expr::UnaryOperatorClass: {
1530 const UnaryOperator *Exp = cast<UnaryOperator>(Init);
1531
1532 switch (Exp->getOpcode()) {
1533 // Address, indirect, pre/post inc/dec, etc are not valid constant exprs.
1534 // See C99 6.6p3.
1535 default:
Steve Naroff6594a702008-10-27 11:34:16 +00001536 InitializerElementNotConstant(Init);
Eli Friedmanc594b322008-05-20 13:48:25 +00001537 return true;
Eli Friedmanc594b322008-05-20 13:48:25 +00001538 case UnaryOperator::OffsetOf:
Eli Friedmanc594b322008-05-20 13:48:25 +00001539 if (Exp->getSubExpr()->getType()->isConstantSizeType())
1540 return false;
Steve Naroff6594a702008-10-27 11:34:16 +00001541 InitializerElementNotConstant(Init);
Eli Friedmanc594b322008-05-20 13:48:25 +00001542 return true;
1543 case UnaryOperator::Extension:
1544 case UnaryOperator::LNot:
1545 case UnaryOperator::Plus:
1546 case UnaryOperator::Minus:
1547 case UnaryOperator::Not:
1548 return CheckArithmeticConstantExpression(Exp->getSubExpr());
1549 }
1550 }
Sebastian Redl05189992008-11-11 17:56:53 +00001551 case Expr::SizeOfAlignOfExprClass: {
1552 const SizeOfAlignOfExpr *Exp = cast<SizeOfAlignOfExpr>(Init);
Eli Friedmanc594b322008-05-20 13:48:25 +00001553 // Special check for void types, which are allowed as an extension
Sebastian Redl05189992008-11-11 17:56:53 +00001554 if (Exp->getTypeOfArgument()->isVoidType())
Eli Friedmanc594b322008-05-20 13:48:25 +00001555 return false;
1556 // alignof always evaluates to a constant.
1557 // FIXME: is sizeof(int[3.0]) a constant expression?
Sebastian Redl05189992008-11-11 17:56:53 +00001558 if (Exp->isSizeOf() && !Exp->getTypeOfArgument()->isConstantSizeType()) {
Steve Naroff6594a702008-10-27 11:34:16 +00001559 InitializerElementNotConstant(Init);
Eli Friedmanc594b322008-05-20 13:48:25 +00001560 return true;
1561 }
1562 return false;
1563 }
1564 case Expr::BinaryOperatorClass: {
1565 const BinaryOperator *Exp = cast<BinaryOperator>(Init);
1566
1567 if (Exp->getLHS()->getType()->isArithmeticType() &&
1568 Exp->getRHS()->getType()->isArithmeticType()) {
1569 return CheckArithmeticConstantExpression(Exp->getLHS()) ||
1570 CheckArithmeticConstantExpression(Exp->getRHS());
1571 }
1572
Eli Friedman4caf0552008-06-09 05:05:07 +00001573 if (Exp->getLHS()->getType()->isPointerType() &&
1574 Exp->getRHS()->getType()->isPointerType()) {
1575 const Expr* LHSBase = FindExpressionBaseAddress(Exp->getLHS());
1576 const Expr* RHSBase = FindExpressionBaseAddress(Exp->getRHS());
1577
1578 // Only allow a null (constant integer) base; we could
1579 // allow some additional cases if necessary, but this
1580 // is sufficient to cover offsetof-like constructs.
1581 if (!LHSBase && !RHSBase) {
1582 return CheckAddressConstantExpression(Exp->getLHS()) ||
1583 CheckAddressConstantExpression(Exp->getRHS());
1584 }
1585 }
1586
Steve Naroff6594a702008-10-27 11:34:16 +00001587 InitializerElementNotConstant(Init);
Eli Friedmanc594b322008-05-20 13:48:25 +00001588 return true;
1589 }
1590 case Expr::ImplicitCastExprClass:
Douglas Gregor6eec8e82008-10-28 15:36:24 +00001591 case Expr::CStyleCastExprClass: {
Argyrios Kyrtzidis0835a3c2008-08-18 23:01:59 +00001592 const Expr *SubExpr = cast<CastExpr>(Init)->getSubExpr();
Eli Friedman6d4abe12008-09-01 22:08:17 +00001593 if (SubExpr->getType()->isArithmeticType())
1594 return CheckArithmeticConstantExpression(SubExpr);
1595
Eli Friedmanb529d832008-09-02 09:37:00 +00001596 if (SubExpr->getType()->isPointerType()) {
1597 const Expr* Base = FindExpressionBaseAddress(SubExpr);
1598 // If the pointer has a null base, this is an offsetof-like construct
1599 if (!Base)
1600 return CheckAddressConstantExpression(SubExpr);
1601 }
1602
Steve Naroff6594a702008-10-27 11:34:16 +00001603 InitializerElementNotConstant(Init);
Eli Friedman6d4abe12008-09-01 22:08:17 +00001604 return true;
Eli Friedmanc594b322008-05-20 13:48:25 +00001605 }
1606 case Expr::ConditionalOperatorClass: {
1607 const ConditionalOperator *Exp = cast<ConditionalOperator>(Init);
Chris Lattner46cfefa2008-10-06 05:42:39 +00001608
1609 // If GNU extensions are disabled, we require all operands to be arithmetic
1610 // constant expressions.
1611 if (getLangOptions().NoExtensions) {
1612 return CheckArithmeticConstantExpression(Exp->getCond()) ||
1613 (Exp->getLHS() && CheckArithmeticConstantExpression(Exp->getLHS())) ||
1614 CheckArithmeticConstantExpression(Exp->getRHS());
1615 }
1616
1617 // Otherwise, we have to emulate some of the behavior of fold here.
1618 // Basically GCC treats things like "4 ? 1 : somefunc()" as a constant
1619 // because it can constant fold things away. To retain compatibility with
1620 // GCC code, we see if we can fold the condition to a constant (which we
1621 // should always be able to do in theory). If so, we only require the
1622 // specified arm of the conditional to be a constant. This is a horrible
1623 // hack, but is require by real world code that uses __builtin_constant_p.
1624 APValue Val;
Chris Lattner6ee7aa12008-11-16 21:24:15 +00001625 if (!Exp->getCond()->Evaluate(Val, Context)) {
1626 // If Evaluate couldn't fold it, CheckArithmeticConstantExpression
Chris Lattner46cfefa2008-10-06 05:42:39 +00001627 // won't be able to either. Use it to emit the diagnostic though.
1628 bool Res = CheckArithmeticConstantExpression(Exp->getCond());
Chris Lattner6ee7aa12008-11-16 21:24:15 +00001629 assert(Res && "Evaluate couldn't evaluate this constant?");
Chris Lattner46cfefa2008-10-06 05:42:39 +00001630 return Res;
1631 }
1632
1633 // Verify that the side following the condition is also a constant.
1634 const Expr *TrueSide = Exp->getLHS(), *FalseSide = Exp->getRHS();
1635 if (Val.getInt() == 0)
1636 std::swap(TrueSide, FalseSide);
1637
1638 if (TrueSide && CheckArithmeticConstantExpression(TrueSide))
Eli Friedmanc594b322008-05-20 13:48:25 +00001639 return true;
Chris Lattner46cfefa2008-10-06 05:42:39 +00001640
1641 // Okay, the evaluated side evaluates to a constant, so we accept this.
1642 // Check to see if the other side is obviously not a constant. If so,
1643 // emit a warning that this is a GNU extension.
Chris Lattner45b6b9d2008-10-06 06:49:02 +00001644 if (FalseSide && !FalseSide->isEvaluatable(Context))
Chris Lattner46cfefa2008-10-06 05:42:39 +00001645 Diag(Init->getExprLoc(),
Chris Lattnerdcd5ef12008-11-19 05:27:50 +00001646 diag::ext_typecheck_expression_not_constant_but_accepted)
1647 << FalseSide->getSourceRange();
Chris Lattner46cfefa2008-10-06 05:42:39 +00001648 return false;
Eli Friedmanc594b322008-05-20 13:48:25 +00001649 }
1650 }
1651}
1652
1653bool Sema::CheckForConstantInitializer(Expr *Init, QualType DclT) {
Anders Carlsson9e09f5d2008-12-05 05:09:56 +00001654 Expr::EvalResult Result;
1655
Nuno Lopes9a979c32008-07-07 16:46:50 +00001656 Init = Init->IgnoreParens();
1657
Anders Carlsson9e09f5d2008-12-05 05:09:56 +00001658 if (Init->Evaluate(Result, Context) && !Result.HasSideEffects)
1659 return false;
1660
Eli Friedmanc594b322008-05-20 13:48:25 +00001661 // Look through CXXDefaultArgExprs; they have no meaning in this context.
1662 if (CXXDefaultArgExpr* DAE = dyn_cast<CXXDefaultArgExpr>(Init))
1663 return CheckForConstantInitializer(DAE->getExpr(), DclT);
1664
Nuno Lopes9a979c32008-07-07 16:46:50 +00001665 if (CompoundLiteralExpr *e = dyn_cast<CompoundLiteralExpr>(Init))
1666 return CheckForConstantInitializer(e->getInitializer(), DclT);
1667
Eli Friedmanc594b322008-05-20 13:48:25 +00001668 if (InitListExpr *Exp = dyn_cast<InitListExpr>(Init)) {
1669 unsigned numInits = Exp->getNumInits();
1670 for (unsigned i = 0; i < numInits; i++) {
1671 // FIXME: Need to get the type of the declaration for C++,
1672 // because it could be a reference?
1673 if (CheckForConstantInitializer(Exp->getInit(i),
1674 Exp->getInit(i)->getType()))
1675 return true;
1676 }
1677 return false;
1678 }
1679
Anders Carlsson9e09f5d2008-12-05 05:09:56 +00001680 // FIXME: We can probably remove some of this code below, now that
1681 // Expr::Evaluate is doing the heavy lifting for scalars.
1682
Eli Friedmanc594b322008-05-20 13:48:25 +00001683 if (Init->isNullPointerConstant(Context))
1684 return false;
1685 if (Init->getType()->isArithmeticType()) {
Chris Lattnerb77792e2008-07-26 22:17:49 +00001686 QualType InitTy = Context.getCanonicalType(Init->getType())
1687 .getUnqualifiedType();
Eli Friedmanc1cc6dc2008-05-30 18:14:48 +00001688 if (InitTy == Context.BoolTy) {
1689 // Special handling for pointers implicitly cast to bool;
1690 // (e.g. "_Bool rr = &rr;"). This is only legal at the top level.
1691 if (ImplicitCastExpr* ICE = dyn_cast<ImplicitCastExpr>(Init)) {
1692 Expr* SubE = ICE->getSubExpr();
1693 if (SubE->getType()->isPointerType() ||
1694 SubE->getType()->isArrayType() ||
1695 SubE->getType()->isFunctionType()) {
1696 return CheckAddressConstantExpression(Init);
1697 }
1698 }
1699 } else if (InitTy->isIntegralType()) {
1700 Expr* SubE = 0;
Argyrios Kyrtzidis0835a3c2008-08-18 23:01:59 +00001701 if (CastExpr* CE = dyn_cast<CastExpr>(Init))
Eli Friedmanc1cc6dc2008-05-30 18:14:48 +00001702 SubE = CE->getSubExpr();
1703 // Special check for pointer cast to int; we allow as an extension
1704 // an address constant cast to an integer if the integer
1705 // is of an appropriate width (this sort of code is apparently used
1706 // in some places).
1707 // FIXME: Add pedwarn?
1708 // FIXME: Don't allow bitfields here! Need the FieldDecl for that.
1709 if (SubE && (SubE->getType()->isPointerType() ||
1710 SubE->getType()->isArrayType() ||
1711 SubE->getType()->isFunctionType())) {
1712 unsigned IntWidth = Context.getTypeSize(Init->getType());
1713 unsigned PointerWidth = Context.getTypeSize(Context.VoidPtrTy);
1714 if (IntWidth >= PointerWidth)
1715 return CheckAddressConstantExpression(Init);
1716 }
Eli Friedmanc594b322008-05-20 13:48:25 +00001717 }
1718
1719 return CheckArithmeticConstantExpression(Init);
1720 }
1721
1722 if (Init->getType()->isPointerType())
1723 return CheckAddressConstantExpression(Init);
1724
Eli Friedmanc1cc6dc2008-05-30 18:14:48 +00001725 // An array type at the top level that isn't an init-list must
1726 // be a string literal
Eli Friedmanc594b322008-05-20 13:48:25 +00001727 if (Init->getType()->isArrayType())
1728 return false;
1729
Nuno Lopes73419bf2008-09-01 18:42:41 +00001730 if (Init->getType()->isFunctionType())
1731 return false;
1732
Steve Naroff8af6a452008-10-02 17:12:56 +00001733 // Allow block exprs at top level.
1734 if (Init->getType()->isBlockPointerType())
1735 return false;
1736
Steve Naroff6594a702008-10-27 11:34:16 +00001737 InitializerElementNotConstant(Init);
Eli Friedmanc594b322008-05-20 13:48:25 +00001738 return true;
Steve Naroffd0091aa2008-01-10 22:15:12 +00001739}
1740
Steve Naroffbb204692007-09-12 14:07:44 +00001741void Sema::AddInitializerToDecl(DeclTy *dcl, ExprTy *init) {
Steve Naroff410e3e22007-09-12 20:13:48 +00001742 Decl *RealDecl = static_cast<Decl *>(dcl);
Steve Naroffbb204692007-09-12 14:07:44 +00001743 Expr *Init = static_cast<Expr *>(init);
Chris Lattner9a11b9a2007-10-19 20:10:30 +00001744 assert(Init && "missing initializer");
Steve Naroffbb204692007-09-12 14:07:44 +00001745
Chris Lattner9a11b9a2007-10-19 20:10:30 +00001746 // If there is no declaration, there was an error parsing it. Just ignore
1747 // the initializer.
1748 if (RealDecl == 0) {
1749 delete Init;
1750 return;
1751 }
Steve Naroffbb204692007-09-12 14:07:44 +00001752
Steve Naroff410e3e22007-09-12 20:13:48 +00001753 VarDecl *VDecl = dyn_cast<VarDecl>(RealDecl);
1754 if (!VDecl) {
Steve Naroff8e74c932007-09-13 21:41:19 +00001755 Diag(dyn_cast<ScopedDecl>(RealDecl)->getLocation(),
1756 diag::err_illegal_initializer);
Steve Naroff410e3e22007-09-12 20:13:48 +00001757 RealDecl->setInvalidDecl();
1758 return;
1759 }
Steve Naroffbb204692007-09-12 14:07:44 +00001760 // Get the decls type and save a reference for later, since
Steve Naroffd0091aa2008-01-10 22:15:12 +00001761 // CheckInitializerTypes may change it.
Steve Naroff410e3e22007-09-12 20:13:48 +00001762 QualType DclT = VDecl->getType(), SavT = DclT;
Steve Naroff248a7532008-04-15 22:42:06 +00001763 if (VDecl->isBlockVarDecl()) {
1764 VarDecl::StorageClass SC = VDecl->getStorageClass();
Steve Naroffbb204692007-09-12 14:07:44 +00001765 if (SC == VarDecl::Extern) { // C99 6.7.8p5
Steve Naroff410e3e22007-09-12 20:13:48 +00001766 Diag(VDecl->getLocation(), diag::err_block_extern_cant_init);
Steve Naroff248a7532008-04-15 22:42:06 +00001767 VDecl->setInvalidDecl();
1768 } else if (!VDecl->isInvalidDecl()) {
Douglas Gregorf03d7c72008-11-05 15:29:30 +00001769 if (CheckInitializerTypes(Init, DclT, VDecl->getLocation(),
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00001770 VDecl->getDeclName()))
Steve Naroff248a7532008-04-15 22:42:06 +00001771 VDecl->setInvalidDecl();
Anders Carlssonc5eb7312008-08-22 05:00:02 +00001772
1773 // C++ 3.6.2p2, allow dynamic initialization of static initializers.
1774 if (!getLangOptions().CPlusPlus) {
1775 if (SC == VarDecl::Static) // C99 6.7.8p4.
1776 CheckForConstantInitializer(Init, DclT);
1777 }
Steve Naroffbb204692007-09-12 14:07:44 +00001778 }
Steve Naroff248a7532008-04-15 22:42:06 +00001779 } else if (VDecl->isFileVarDecl()) {
1780 if (VDecl->getStorageClass() == VarDecl::Extern)
Steve Naroff410e3e22007-09-12 20:13:48 +00001781 Diag(VDecl->getLocation(), diag::warn_extern_init);
Steve Naroff248a7532008-04-15 22:42:06 +00001782 if (!VDecl->isInvalidDecl())
Douglas Gregorf03d7c72008-11-05 15:29:30 +00001783 if (CheckInitializerTypes(Init, DclT, VDecl->getLocation(),
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00001784 VDecl->getDeclName()))
Steve Naroff248a7532008-04-15 22:42:06 +00001785 VDecl->setInvalidDecl();
Steve Naroffd0091aa2008-01-10 22:15:12 +00001786
Anders Carlssonc5eb7312008-08-22 05:00:02 +00001787 // C++ 3.6.2p2, allow dynamic initialization of static initializers.
1788 if (!getLangOptions().CPlusPlus) {
1789 // C99 6.7.8p4. All file scoped initializers need to be constant.
1790 CheckForConstantInitializer(Init, DclT);
1791 }
Steve Naroffbb204692007-09-12 14:07:44 +00001792 }
1793 // If the type changed, it means we had an incomplete type that was
1794 // completed by the initializer. For example:
1795 // int ary[] = { 1, 3, 5 };
1796 // "ary" transitions from a VariableArrayType to a ConstantArrayType.
Christopher Lamb48b12392007-11-29 19:09:19 +00001797 if (!VDecl->isInvalidDecl() && (DclT != SavT)) {
Steve Naroff410e3e22007-09-12 20:13:48 +00001798 VDecl->setType(DclT);
Christopher Lamb48b12392007-11-29 19:09:19 +00001799 Init->setType(DclT);
1800 }
Steve Naroffbb204692007-09-12 14:07:44 +00001801
1802 // Attach the initializer to the decl.
Steve Naroff410e3e22007-09-12 20:13:48 +00001803 VDecl->setInit(Init);
Steve Naroffbb204692007-09-12 14:07:44 +00001804 return;
1805}
1806
Douglas Gregor27c8dc02008-10-29 00:13:59 +00001807void Sema::ActOnUninitializedDecl(DeclTy *dcl) {
1808 Decl *RealDecl = static_cast<Decl *>(dcl);
1809
Argyrios Kyrtzidis48c2e902008-11-07 13:01:22 +00001810 // If there is no declaration, there was an error parsing it. Just ignore it.
1811 if (RealDecl == 0)
1812 return;
1813
Douglas Gregor27c8dc02008-10-29 00:13:59 +00001814 if (VarDecl *Var = dyn_cast<VarDecl>(RealDecl)) {
1815 QualType Type = Var->getType();
1816 // C++ [dcl.init.ref]p3:
1817 // The initializer can be omitted for a reference only in a
1818 // parameter declaration (8.3.5), in the declaration of a
1819 // function return type, in the declaration of a class member
1820 // within its class declaration (9.2), and where the extern
1821 // specifier is explicitly used.
Douglas Gregor18fe5682008-11-03 20:45:27 +00001822 if (Type->isReferenceType() && Var->getStorageClass() != VarDecl::Extern) {
Chris Lattnerd3a94e22008-11-20 06:06:08 +00001823 Diag(Var->getLocation(), diag::err_reference_var_requires_init)
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00001824 << Var->getDeclName()
1825 << SourceRange(Var->getLocation(), Var->getLocation());
Douglas Gregor18fe5682008-11-03 20:45:27 +00001826 Var->setInvalidDecl();
1827 return;
1828 }
1829
1830 // C++ [dcl.init]p9:
1831 //
1832 // If no initializer is specified for an object, and the object
1833 // is of (possibly cv-qualified) non-POD class type (or array
1834 // thereof), the object shall be default-initialized; if the
1835 // object is of const-qualified type, the underlying class type
1836 // shall have a user-declared default constructor.
1837 if (getLangOptions().CPlusPlus) {
1838 QualType InitType = Type;
1839 if (const ArrayType *Array = Context.getAsArrayType(Type))
1840 InitType = Array->getElementType();
1841 if (InitType->isRecordType()) {
Douglas Gregorf03d7c72008-11-05 15:29:30 +00001842 const CXXConstructorDecl *Constructor
1843 = PerformInitializationByConstructor(InitType, 0, 0,
1844 Var->getLocation(),
1845 SourceRange(Var->getLocation(),
1846 Var->getLocation()),
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00001847 Var->getDeclName(),
Douglas Gregorf03d7c72008-11-05 15:29:30 +00001848 IK_Default);
Douglas Gregor18fe5682008-11-03 20:45:27 +00001849 if (!Constructor)
1850 Var->setInvalidDecl();
1851 }
1852 }
Douglas Gregor27c8dc02008-10-29 00:13:59 +00001853
Douglas Gregor818ce482008-10-29 13:50:18 +00001854#if 0
1855 // FIXME: Temporarily disabled because we are not properly parsing
1856 // linkage specifications on declarations, e.g.,
1857 //
1858 // extern "C" const CGPoint CGPointerZero;
1859 //
Douglas Gregor27c8dc02008-10-29 00:13:59 +00001860 // C++ [dcl.init]p9:
1861 //
1862 // If no initializer is specified for an object, and the
1863 // object is of (possibly cv-qualified) non-POD class type (or
1864 // array thereof), the object shall be default-initialized; if
1865 // the object is of const-qualified type, the underlying class
1866 // type shall have a user-declared default
1867 // constructor. Otherwise, if no initializer is specified for
1868 // an object, the object and its subobjects, if any, have an
1869 // indeterminate initial value; if the object or any of its
1870 // subobjects are of const-qualified type, the program is
1871 // ill-formed.
1872 //
1873 // This isn't technically an error in C, so we don't diagnose it.
1874 //
1875 // FIXME: Actually perform the POD/user-defined default
1876 // constructor check.
1877 if (getLangOptions().CPlusPlus &&
Douglas Gregor818ce482008-10-29 13:50:18 +00001878 Context.getCanonicalType(Type).isConstQualified() &&
1879 Var->getStorageClass() != VarDecl::Extern)
Chris Lattnerf3a41af2008-11-20 06:38:18 +00001880 Diag(Var->getLocation(), diag::err_const_var_requires_init)
1881 << Var->getName()
1882 << SourceRange(Var->getLocation(), Var->getLocation());
Douglas Gregor818ce482008-10-29 13:50:18 +00001883#endif
Douglas Gregor27c8dc02008-10-29 00:13:59 +00001884 }
1885}
1886
Reid Spencer5f016e22007-07-11 17:01:13 +00001887/// The declarators are chained together backwards, reverse the list.
1888Sema::DeclTy *Sema::FinalizeDeclaratorGroup(Scope *S, DeclTy *group) {
1889 // Often we have single declarators, handle them quickly.
Steve Naroff94745042007-09-13 23:52:58 +00001890 Decl *GroupDecl = static_cast<Decl*>(group);
1891 if (GroupDecl == 0)
Steve Naroffbb204692007-09-12 14:07:44 +00001892 return 0;
Steve Naroff94745042007-09-13 23:52:58 +00001893
1894 ScopedDecl *Group = dyn_cast<ScopedDecl>(GroupDecl);
1895 ScopedDecl *NewGroup = 0;
Steve Naroffbb204692007-09-12 14:07:44 +00001896 if (Group->getNextDeclarator() == 0)
Reid Spencer5f016e22007-07-11 17:01:13 +00001897 NewGroup = Group;
Steve Naroffbb204692007-09-12 14:07:44 +00001898 else { // reverse the list.
1899 while (Group) {
Steve Naroff94745042007-09-13 23:52:58 +00001900 ScopedDecl *Next = Group->getNextDeclarator();
Steve Naroffbb204692007-09-12 14:07:44 +00001901 Group->setNextDeclarator(NewGroup);
1902 NewGroup = Group;
1903 Group = Next;
1904 }
1905 }
1906 // Perform semantic analysis that depends on having fully processed both
1907 // the declarator and initializer.
Steve Naroff94745042007-09-13 23:52:58 +00001908 for (ScopedDecl *ID = NewGroup; ID; ID = ID->getNextDeclarator()) {
Steve Naroffbb204692007-09-12 14:07:44 +00001909 VarDecl *IDecl = dyn_cast<VarDecl>(ID);
1910 if (!IDecl)
1911 continue;
Steve Naroffbb204692007-09-12 14:07:44 +00001912 QualType T = IDecl->getType();
1913
1914 // C99 6.7.5.2p2: If an identifier is declared to be an object with
1915 // static storage duration, it shall not have a variable length array.
Steve Naroff248a7532008-04-15 22:42:06 +00001916 if ((IDecl->isFileVarDecl() || IDecl->isBlockVarDecl()) &&
1917 IDecl->getStorageClass() == VarDecl::Static) {
Chris Lattnerc63a1f22008-08-04 07:31:14 +00001918 if (T->isVariableArrayType()) {
Eli Friedmanc5773c42008-02-15 18:16:39 +00001919 Diag(IDecl->getLocation(), diag::err_typecheck_illegal_vla);
1920 IDecl->setInvalidDecl();
Steve Naroffbb204692007-09-12 14:07:44 +00001921 }
1922 }
1923 // Block scope. C99 6.7p7: If an identifier for an object is declared with
1924 // no linkage (C99 6.2.2p6), the type for the object shall be complete...
Steve Naroff248a7532008-04-15 22:42:06 +00001925 if (IDecl->isBlockVarDecl() &&
1926 IDecl->getStorageClass() != VarDecl::Extern) {
Chris Lattnerfd89bc82008-04-02 01:05:10 +00001927 if (T->isIncompleteType() && !IDecl->isInvalidDecl()) {
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00001928 Diag(IDecl->getLocation(), diag::err_typecheck_decl_incomplete_type)<<T;
Steve Naroffbb204692007-09-12 14:07:44 +00001929 IDecl->setInvalidDecl();
1930 }
1931 }
1932 // File scope. C99 6.9.2p2: A declaration of an identifier for and
1933 // object that has file scope without an initializer, and without a
1934 // storage-class specifier or with the storage-class specifier "static",
1935 // constitutes a tentative definition. Note: A tentative definition with
1936 // external linkage is valid (C99 6.2.2p5).
Steve Naroffff9eb1f2008-08-08 17:50:35 +00001937 if (isTentativeDefinition(IDecl)) {
Eli Friedman9db13972008-02-15 12:53:51 +00001938 if (T->isIncompleteArrayType()) {
Steve Naroff9a75f8a2008-01-18 20:40:52 +00001939 // C99 6.9.2 (p2, p5): Implicit initialization causes an incomplete
1940 // array to be completed. Don't issue a diagnostic.
Chris Lattnerfd89bc82008-04-02 01:05:10 +00001941 } else if (T->isIncompleteType() && !IDecl->isInvalidDecl()) {
Steve Naroff9a75f8a2008-01-18 20:40:52 +00001942 // C99 6.9.2p3: If the declaration of an identifier for an object is
1943 // a tentative definition and has internal linkage (C99 6.2.2p3), the
1944 // declared type shall not be an incomplete type.
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00001945 Diag(IDecl->getLocation(), diag::err_typecheck_decl_incomplete_type)<<T;
Steve Naroffbb204692007-09-12 14:07:44 +00001946 IDecl->setInvalidDecl();
1947 }
1948 }
Steve Naroffff9eb1f2008-08-08 17:50:35 +00001949 if (IDecl->isFileVarDecl())
1950 CheckForFileScopedRedefinitions(S, IDecl);
Reid Spencer5f016e22007-07-11 17:01:13 +00001951 }
1952 return NewGroup;
1953}
Steve Naroffe1223f72007-08-28 03:03:08 +00001954
Chris Lattner04421082008-04-08 04:40:51 +00001955/// ActOnParamDeclarator - Called from Parser::ParseFunctionDeclarator()
1956/// to introduce parameters into function prototype scope.
1957Sema::DeclTy *
1958Sema::ActOnParamDeclarator(Scope *S, Declarator &D) {
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +00001959 // FIXME: disallow CXXScopeSpec for param declarators.
Chris Lattner985abd92008-06-26 06:49:43 +00001960 const DeclSpec &DS = D.getDeclSpec();
Chris Lattner04421082008-04-08 04:40:51 +00001961
1962 // Verify C99 6.7.5.3p2: The only SCS allowed is 'register'.
Daniel Dunbar33ad0122008-09-03 21:54:21 +00001963 VarDecl::StorageClass StorageClass = VarDecl::None;
1964 if (DS.getStorageClassSpec() == DeclSpec::SCS_register) {
1965 StorageClass = VarDecl::Register;
1966 } else if (DS.getStorageClassSpec() != DeclSpec::SCS_unspecified) {
Chris Lattner04421082008-04-08 04:40:51 +00001967 Diag(DS.getStorageClassSpecLoc(),
1968 diag::err_invalid_storage_class_in_func_decl);
Chris Lattner985abd92008-06-26 06:49:43 +00001969 D.getMutableDeclSpec().ClearStorageClassSpecs();
Chris Lattner04421082008-04-08 04:40:51 +00001970 }
1971 if (DS.isThreadSpecified()) {
1972 Diag(DS.getThreadSpecLoc(),
1973 diag::err_invalid_storage_class_in_func_decl);
Chris Lattner985abd92008-06-26 06:49:43 +00001974 D.getMutableDeclSpec().ClearStorageClassSpecs();
Chris Lattner04421082008-04-08 04:40:51 +00001975 }
1976
Douglas Gregor6d6eb572008-05-07 04:49:29 +00001977 // Check that there are no default arguments inside the type of this
1978 // parameter (C++ only).
1979 if (getLangOptions().CPlusPlus)
1980 CheckExtraCXXDefaultArguments(D);
1981
Chris Lattner04421082008-04-08 04:40:51 +00001982 // In this context, we *do not* check D.getInvalidType(). If the declarator
1983 // type was invalid, GetTypeForDeclarator() still returns a "valid" type,
1984 // though it will not reflect the user specified type.
1985 QualType parmDeclType = GetTypeForDeclarator(D, S);
1986
1987 assert(!parmDeclType.isNull() && "GetTypeForDeclarator() returned null type");
1988
Reid Spencer5f016e22007-07-11 17:01:13 +00001989 // TODO: CHECK FOR CONFLICTS, multiple decls with same name in one scope.
1990 // Can this happen for params? We already checked that they don't conflict
1991 // among each other. Here they can only shadow globals, which is ok.
Chris Lattner04421082008-04-08 04:40:51 +00001992 IdentifierInfo *II = D.getIdentifier();
1993 if (Decl *PrevDecl = LookupDecl(II, Decl::IDNS_Ordinary, S)) {
1994 if (S->isDeclScope(PrevDecl)) {
Chris Lattner08631c52008-11-23 21:45:46 +00001995 Diag(D.getIdentifierLoc(), diag::err_param_redefinition) << II;
Chris Lattner04421082008-04-08 04:40:51 +00001996
1997 // Recover by removing the name
1998 II = 0;
1999 D.SetIdentifier(0, D.getIdentifierLoc());
2000 }
Reid Spencer5f016e22007-07-11 17:01:13 +00002001 }
Steve Naroff6a9f3e32007-08-07 22:44:21 +00002002
2003 // Perform the default function/array conversion (C99 6.7.5.3p[7,8]).
2004 // Doing the promotion here has a win and a loss. The win is the type for
2005 // both Decl's and DeclRefExpr's will match (a convenient invariant for the
2006 // code generator). The loss is the orginal type isn't preserved. For example:
2007 //
2008 // void func(int parmvardecl[5]) { // convert "int [5]" to "int *"
2009 // int blockvardecl[5];
2010 // sizeof(parmvardecl); // size == 4
2011 // sizeof(blockvardecl); // size == 20
2012 // }
2013 //
2014 // For expressions, all implicit conversions are captured using the
2015 // ImplicitCastExpr AST node (we have no such mechanism for Decl's).
2016 //
2017 // FIXME: If a source translation tool needs to see the original type, then
2018 // we need to consider storing both types (in ParmVarDecl)...
2019 //
Chris Lattnere6327742008-04-02 05:18:44 +00002020 if (parmDeclType->isArrayType()) {
Chris Lattner529bd022008-01-02 22:50:48 +00002021 // int x[restrict 4] -> int *restrict
Chris Lattnere6327742008-04-02 05:18:44 +00002022 parmDeclType = Context.getArrayDecayedType(parmDeclType);
Chris Lattner529bd022008-01-02 22:50:48 +00002023 } else if (parmDeclType->isFunctionType())
Steve Naroff6a9f3e32007-08-07 22:44:21 +00002024 parmDeclType = Context.getPointerType(parmDeclType);
2025
Chris Lattner04421082008-04-08 04:40:51 +00002026 ParmVarDecl *New = ParmVarDecl::Create(Context, CurContext,
2027 D.getIdentifierLoc(), II,
Daniel Dunbar33ad0122008-09-03 21:54:21 +00002028 parmDeclType, StorageClass,
Chris Lattner04421082008-04-08 04:40:51 +00002029 0, 0);
Anders Carlssonf78915f2008-02-15 07:04:12 +00002030
Chris Lattner04421082008-04-08 04:40:51 +00002031 if (D.getInvalidType())
Steve Naroff53a32342007-08-28 18:45:29 +00002032 New->setInvalidDecl();
2033
Argyrios Kyrtzidis87f3ff02008-04-12 00:47:19 +00002034 if (II)
2035 PushOnScopeChains(New, S);
Nate Begemanb7894b52008-02-17 21:20:31 +00002036
Chris Lattner3ff30c82008-06-29 00:02:00 +00002037 ProcessDeclAttributes(New, D);
Reid Spencer5f016e22007-07-11 17:01:13 +00002038 return New;
Chris Lattner04421082008-04-08 04:40:51 +00002039
Reid Spencer5f016e22007-07-11 17:01:13 +00002040}
Fariborz Jahanian306d68f2007-11-08 23:49:49 +00002041
Chris Lattnerb652cea2007-10-09 17:14:05 +00002042Sema::DeclTy *Sema::ActOnStartOfFunctionDef(Scope *FnBodyScope, Declarator &D) {
Argyrios Kyrtzidis53d0ea52008-06-28 06:07:14 +00002043 assert(getCurFunctionDecl() == 0 && "Function parsing confused");
Reid Spencer5f016e22007-07-11 17:01:13 +00002044 assert(D.getTypeObject(0).Kind == DeclaratorChunk::Function &&
2045 "Not a function declarator!");
2046 DeclaratorChunk::FunctionTypeInfo &FTI = D.getTypeObject(0).Fun;
Chris Lattner04421082008-04-08 04:40:51 +00002047
Reid Spencer5f016e22007-07-11 17:01:13 +00002048 // Verify 6.9.1p6: 'every identifier in the identifier list shall be declared'
2049 // for a K&R function.
2050 if (!FTI.hasPrototype) {
2051 for (unsigned i = 0, e = FTI.NumArgs; i != e; ++i) {
Chris Lattner04421082008-04-08 04:40:51 +00002052 if (FTI.ArgInfo[i].Param == 0) {
Chris Lattner3c73c412008-11-19 08:23:25 +00002053 Diag(FTI.ArgInfo[i].IdentLoc, diag::ext_param_not_declared)
2054 << FTI.ArgInfo[i].Ident;
Reid Spencer5f016e22007-07-11 17:01:13 +00002055 // Implicitly declare the argument as type 'int' for lack of a better
2056 // type.
Chris Lattner04421082008-04-08 04:40:51 +00002057 DeclSpec DS;
2058 const char* PrevSpec; // unused
2059 DS.SetTypeSpecType(DeclSpec::TST_int, FTI.ArgInfo[i].IdentLoc,
2060 PrevSpec);
2061 Declarator ParamD(DS, Declarator::KNRTypeListContext);
2062 ParamD.SetIdentifier(FTI.ArgInfo[i].Ident, FTI.ArgInfo[i].IdentLoc);
2063 FTI.ArgInfo[i].Param = ActOnParamDeclarator(FnBodyScope, ParamD);
Reid Spencer5f016e22007-07-11 17:01:13 +00002064 }
2065 }
Reid Spencer5f016e22007-07-11 17:01:13 +00002066 } else {
Chris Lattner04421082008-04-08 04:40:51 +00002067 // FIXME: Diagnose arguments without names in C.
Reid Spencer5f016e22007-07-11 17:01:13 +00002068 }
2069
2070 Scope *GlobalScope = FnBodyScope->getParent();
Steve Naroffadbbd0c2008-01-14 20:51:29 +00002071
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +00002072 return ActOnStartOfFunctionDef(FnBodyScope,
Daniel Dunbar914701e2008-08-05 16:28:08 +00002073 ActOnDeclarator(GlobalScope, D, 0));
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +00002074}
2075
2076Sema::DeclTy *Sema::ActOnStartOfFunctionDef(Scope *FnBodyScope, DeclTy *D) {
2077 Decl *decl = static_cast<Decl*>(D);
Chris Lattnere9ba3232008-02-16 01:20:36 +00002078 FunctionDecl *FD = cast<FunctionDecl>(decl);
Douglas Gregor6fc17ff2008-10-29 15:10:40 +00002079
2080 // See if this is a redefinition.
2081 const FunctionDecl *Definition;
2082 if (FD->getBody(Definition)) {
Chris Lattner08631c52008-11-23 21:45:46 +00002083 Diag(FD->getLocation(), diag::err_redefinition) << FD->getDeclName();
Chris Lattner5f4a6822008-11-23 23:12:31 +00002084 Diag(Definition->getLocation(), diag::note_previous_definition);
Douglas Gregor6fc17ff2008-10-29 15:10:40 +00002085 }
2086
Chris Lattnerb048c982008-04-06 04:47:34 +00002087 PushDeclContext(FD);
Chris Lattner04421082008-04-08 04:40:51 +00002088
2089 // Check the validity of our function parameters
2090 CheckParmsForFunctionDef(FD);
2091
2092 // Introduce our parameters into the function scope
2093 for (unsigned p = 0, NumParams = FD->getNumParams(); p < NumParams; ++p) {
2094 ParmVarDecl *Param = FD->getParamDecl(p);
2095 // If this has an identifier, add it to the scope stack.
Argyrios Kyrtzidis87f3ff02008-04-12 00:47:19 +00002096 if (Param->getIdentifier())
2097 PushOnScopeChains(Param, FnBodyScope);
Reid Spencer5f016e22007-07-11 17:01:13 +00002098 }
Chris Lattner04421082008-04-08 04:40:51 +00002099
Reid Spencer5f016e22007-07-11 17:01:13 +00002100 return FD;
2101}
2102
Steve Naroffd6d054d2007-11-11 23:20:51 +00002103Sema::DeclTy *Sema::ActOnFinishFunctionBody(DeclTy *D, StmtTy *Body) {
2104 Decl *dcl = static_cast<Decl *>(D);
Steve Naroff394f3f42008-07-25 17:57:26 +00002105 if (FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(dcl)) {
Steve Naroffd6d054d2007-11-11 23:20:51 +00002106 FD->setBody((Stmt*)Body);
Argyrios Kyrtzidis53d0ea52008-06-28 06:07:14 +00002107 assert(FD == getCurFunctionDecl() && "Function parsing confused");
Steve Naroff394f3f42008-07-25 17:57:26 +00002108 } else if (ObjCMethodDecl *MD = dyn_cast_or_null<ObjCMethodDecl>(dcl)) {
Steve Naroffd6d054d2007-11-11 23:20:51 +00002109 MD->setBody((Stmt*)Body);
Steve Naroff394f3f42008-07-25 17:57:26 +00002110 } else
2111 return 0;
Chris Lattnerb048c982008-04-06 04:47:34 +00002112 PopDeclContext();
Reid Spencer5f016e22007-07-11 17:01:13 +00002113 // Verify and clean out per-function state.
2114
2115 // Check goto/label use.
2116 for (llvm::DenseMap<IdentifierInfo*, LabelStmt*>::iterator
2117 I = LabelMap.begin(), E = LabelMap.end(); I != E; ++I) {
2118 // Verify that we have no forward references left. If so, there was a goto
2119 // or address of a label taken, but no definition of it. Label fwd
2120 // definitions are indicated with a null substmt.
2121 if (I->second->getSubStmt() == 0) {
2122 LabelStmt *L = I->second;
2123 // Emit error.
Chris Lattnerf3a41af2008-11-20 06:38:18 +00002124 Diag(L->getIdentLoc(), diag::err_undeclared_label_use) << L->getName();
Reid Spencer5f016e22007-07-11 17:01:13 +00002125
2126 // At this point, we have gotos that use the bogus label. Stitch it into
2127 // the function body so that they aren't leaked and that the AST is well
2128 // formed.
Chris Lattner0cbc2152008-01-25 00:01:10 +00002129 if (Body) {
2130 L->setSubStmt(new NullStmt(L->getIdentLoc()));
2131 cast<CompoundStmt>((Stmt*)Body)->push_back(L);
2132 } else {
2133 // The whole function wasn't parsed correctly, just delete this.
2134 delete L;
2135 }
Reid Spencer5f016e22007-07-11 17:01:13 +00002136 }
2137 }
2138 LabelMap.clear();
2139
Steve Naroffd6d054d2007-11-11 23:20:51 +00002140 return D;
Fariborz Jahanian60fbca02007-11-10 16:31:34 +00002141}
2142
Reid Spencer5f016e22007-07-11 17:01:13 +00002143/// ImplicitlyDefineFunction - An undeclared identifier was used in a function
2144/// call, forming a call to an implicitly defined function (per C99 6.5.1p2).
Steve Naroff8c9f13e2007-09-16 16:16:00 +00002145ScopedDecl *Sema::ImplicitlyDefineFunction(SourceLocation Loc,
2146 IdentifierInfo &II, Scope *S) {
Chris Lattner37d10842008-05-05 21:18:06 +00002147 // Extension in C99. Legal in C90, but warn about it.
2148 if (getLangOptions().C99)
Chris Lattner3c73c412008-11-19 08:23:25 +00002149 Diag(Loc, diag::ext_implicit_function_decl) << &II;
Chris Lattner37d10842008-05-05 21:18:06 +00002150 else
Chris Lattner3c73c412008-11-19 08:23:25 +00002151 Diag(Loc, diag::warn_implicit_function_decl) << &II;
Reid Spencer5f016e22007-07-11 17:01:13 +00002152
2153 // FIXME: handle stuff like:
2154 // void foo() { extern float X(); }
2155 // void bar() { X(); } <-- implicit decl for X in another scope.
2156
2157 // Set a Declarator for the implicit definition: int foo();
2158 const char *Dummy;
2159 DeclSpec DS;
2160 bool Error = DS.SetTypeSpecType(DeclSpec::TST_int, Loc, Dummy);
2161 Error = Error; // Silence warning.
2162 assert(!Error && "Error setting up implicit decl!");
2163 Declarator D(DS, Declarator::BlockContext);
Argyrios Kyrtzidis971c4fa2008-10-24 21:46:40 +00002164 D.AddTypeInfo(DeclaratorChunk::getFunction(false, false, 0, 0, 0, Loc));
Reid Spencer5f016e22007-07-11 17:01:13 +00002165 D.SetIdentifier(&II, Loc);
2166
Argyrios Kyrtzidis93213bb2008-05-01 21:04:16 +00002167 // Insert this function into translation-unit scope.
2168
2169 DeclContext *PrevDC = CurContext;
2170 CurContext = Context.getTranslationUnitDecl();
2171
Steve Naroffe2ef8152008-04-04 14:32:09 +00002172 FunctionDecl *FD =
Daniel Dunbar914701e2008-08-05 16:28:08 +00002173 dyn_cast<FunctionDecl>(static_cast<Decl*>(ActOnDeclarator(TUScope, D, 0)));
Steve Naroffe2ef8152008-04-04 14:32:09 +00002174 FD->setImplicit();
Argyrios Kyrtzidis93213bb2008-05-01 21:04:16 +00002175
2176 CurContext = PrevDC;
2177
Steve Naroffe2ef8152008-04-04 14:32:09 +00002178 return FD;
Reid Spencer5f016e22007-07-11 17:01:13 +00002179}
2180
2181
Chris Lattner41af0932007-11-14 06:34:38 +00002182TypedefDecl *Sema::ParseTypedefDecl(Scope *S, Declarator &D, QualType T,
Steve Naroff94745042007-09-13 23:52:58 +00002183 ScopedDecl *LastDeclarator) {
Reid Spencer5f016e22007-07-11 17:01:13 +00002184 assert(D.getIdentifier() && "Wrong callback for declspec without declarator");
Steve Naroff5912a352007-08-28 20:14:24 +00002185 assert(!T.isNull() && "GetTypeForDeclarator() returned null type");
Reid Spencer5f016e22007-07-11 17:01:13 +00002186
2187 // Scope manipulation handled by caller.
Chris Lattner0ed844b2008-04-04 06:12:32 +00002188 TypedefDecl *NewTD = TypedefDecl::Create(Context, CurContext,
2189 D.getIdentifierLoc(),
Chris Lattner6c2b6eb2008-03-15 06:12:44 +00002190 D.getIdentifier(),
Chris Lattnerc63e6602008-03-15 21:32:50 +00002191 T, LastDeclarator);
Steve Naroff5912a352007-08-28 20:14:24 +00002192 if (D.getInvalidType())
2193 NewTD->setInvalidDecl();
2194 return NewTD;
Reid Spencer5f016e22007-07-11 17:01:13 +00002195}
2196
Steve Naroff08d92e42007-09-15 18:49:24 +00002197/// ActOnTag - This is invoked when we see 'struct foo' or 'struct {'. In the
Reid Spencer5f016e22007-07-11 17:01:13 +00002198/// former case, Name will be non-null. In the later case, Name will be null.
2199/// TagType indicates what kind of tag this is. TK indicates whether this is a
2200/// reference/declaration/definition of a tag.
Steve Naroff08d92e42007-09-15 18:49:24 +00002201Sema::DeclTy *Sema::ActOnTag(Scope *S, unsigned TagType, TagKind TK,
Argyrios Kyrtzidiseb83ecd2008-11-08 16:45:02 +00002202 SourceLocation KWLoc, const CXXScopeSpec &SS,
2203 IdentifierInfo *Name, SourceLocation NameLoc,
2204 AttributeList *Attr) {
Reid Spencer5f016e22007-07-11 17:01:13 +00002205 // If this is a use of an existing tag, it must have a name.
2206 assert((Name != 0 || TK == TK_Definition) &&
2207 "Nameless record must be a definition!");
2208
Argyrios Kyrtzidis39ba4ae2008-06-09 23:19:58 +00002209 TagDecl::TagKind Kind;
Reid Spencer5f016e22007-07-11 17:01:13 +00002210 switch (TagType) {
2211 default: assert(0 && "Unknown tag type!");
Argyrios Kyrtzidis39ba4ae2008-06-09 23:19:58 +00002212 case DeclSpec::TST_struct: Kind = TagDecl::TK_struct; break;
2213 case DeclSpec::TST_union: Kind = TagDecl::TK_union; break;
2214 case DeclSpec::TST_class: Kind = TagDecl::TK_class; break;
2215 case DeclSpec::TST_enum: Kind = TagDecl::TK_enum; break;
Reid Spencer5f016e22007-07-11 17:01:13 +00002216 }
2217
Ted Kremenek4b7c9832008-09-05 17:16:31 +00002218 // Two code paths: a new one for structs/unions/classes where we create
2219 // separate decls for forward declarations, and an old (eventually to
2220 // be removed) code path for enums.
2221 if (Kind != TagDecl::TK_enum)
Argyrios Kyrtzidis630c81b2008-11-09 22:09:58 +00002222 return ActOnTagStruct(S, Kind, TK, KWLoc, SS, Name, NameLoc, Attr);
Ted Kremenek4b7c9832008-09-05 17:16:31 +00002223
Argyrios Kyrtzidis0f84a232008-11-09 22:53:32 +00002224 DeclContext *DC = CurContext;
2225 ScopedDecl *PrevDecl = 0;
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +00002226
Argyrios Kyrtzidis630c81b2008-11-09 22:09:58 +00002227 if (Name && SS.isNotEmpty()) {
2228 // We have a nested-name tag ('struct foo::bar').
2229
2230 // Check for invalid 'foo::'.
Argyrios Kyrtzidis0f84a232008-11-09 22:53:32 +00002231 if (SS.isInvalid()) {
Argyrios Kyrtzidis630c81b2008-11-09 22:09:58 +00002232 Name = 0;
2233 goto CreateNewDecl;
2234 }
2235
Argyrios Kyrtzidis0f84a232008-11-09 22:53:32 +00002236 DC = static_cast<DeclContext*>(SS.getScopeRep());
2237 // Look-up name inside 'foo::'.
Argyrios Kyrtzidis630c81b2008-11-09 22:09:58 +00002238 PrevDecl = dyn_cast_or_null<TagDecl>(LookupDecl(Name, Decl::IDNS_Tag,S,DC));
2239
2240 // A tag 'foo::bar' must already exist.
2241 if (PrevDecl == 0) {
Chris Lattner3c73c412008-11-19 08:23:25 +00002242 Diag(NameLoc, diag::err_not_tag_in_scope) << Name << SS.getRange();
Argyrios Kyrtzidis630c81b2008-11-09 22:09:58 +00002243 Name = 0;
2244 goto CreateNewDecl;
2245 }
2246 } else {
2247 // If this is a named struct, check to see if there was a previous forward
2248 // declaration or definition.
2249 // Use ScopedDecl instead of TagDecl, because a NamespaceDecl may come up.
2250 PrevDecl = dyn_cast_or_null<ScopedDecl>(LookupDecl(Name, Decl::IDNS_Tag,S));
2251 }
2252
Ted Kremenek7e8cc572008-09-02 21:26:19 +00002253 if (PrevDecl) {
Argyrios Kyrtzidis2d1c5d32008-04-27 13:50:30 +00002254 assert((isa<TagDecl>(PrevDecl) || isa<NamespaceDecl>(PrevDecl)) &&
2255 "unexpected Decl type");
2256 if (TagDecl *PrevTagDecl = dyn_cast<TagDecl>(PrevDecl)) {
Chris Lattner14943b92008-07-03 03:30:58 +00002257 // If this is a use of a previous tag, or if the tag is already declared
2258 // in the same scope (so that the definition/declaration completes or
Argyrios Kyrtzidis2d1c5d32008-04-27 13:50:30 +00002259 // rementions the tag), reuse the decl.
Argyrios Kyrtzidis0f84a232008-11-09 22:53:32 +00002260 if (TK == TK_Reference || isDeclInScope(PrevDecl, DC, S)) {
Chris Lattner14943b92008-07-03 03:30:58 +00002261 // Make sure that this wasn't declared as an enum and now used as a
2262 // struct or something similar.
Argyrios Kyrtzidis39ba4ae2008-06-09 23:19:58 +00002263 if (PrevTagDecl->getTagKind() != Kind) {
Chris Lattner3c73c412008-11-19 08:23:25 +00002264 Diag(KWLoc, diag::err_use_with_wrong_tag) << Name;
Chris Lattner5f4a6822008-11-23 23:12:31 +00002265 Diag(PrevDecl->getLocation(), diag::note_previous_use);
Chris Lattner14943b92008-07-03 03:30:58 +00002266 // Recover by making this an anonymous redefinition.
Argyrios Kyrtzidis2d1c5d32008-04-27 13:50:30 +00002267 Name = 0;
Chris Lattner14943b92008-07-03 03:30:58 +00002268 PrevDecl = 0;
Argyrios Kyrtzidis2d1c5d32008-04-27 13:50:30 +00002269 } else {
Chris Lattner14943b92008-07-03 03:30:58 +00002270 // If this is a use or a forward declaration, we're good.
2271 if (TK != TK_Definition)
2272 return PrevDecl;
2273
2274 // Diagnose attempts to redefine a tag.
2275 if (PrevTagDecl->isDefinition()) {
Chris Lattner3c73c412008-11-19 08:23:25 +00002276 Diag(NameLoc, diag::err_redefinition) << Name;
Chris Lattner5f4a6822008-11-23 23:12:31 +00002277 Diag(PrevDecl->getLocation(), diag::note_previous_definition);
Chris Lattner14943b92008-07-03 03:30:58 +00002278 // If this is a redefinition, recover by making this struct be
2279 // anonymous, which will make any later references get the previous
2280 // definition.
2281 Name = 0;
2282 } else {
2283 // Okay, this is definition of a previously declared or referenced
2284 // tag. Move the location of the decl to be the definition site.
2285 PrevDecl->setLocation(NameLoc);
2286 return PrevDecl;
2287 }
Argyrios Kyrtzidis2d1c5d32008-04-27 13:50:30 +00002288 }
Reid Spencer5f016e22007-07-11 17:01:13 +00002289 }
Argyrios Kyrtzidis2d1c5d32008-04-27 13:50:30 +00002290 // If we get here, this is a definition of a new struct type in a nested
2291 // scope, e.g. "struct foo; void bar() { struct foo; }", just create a new
2292 // type.
2293 } else {
Argyrios Kyrtzidisb02ef242008-07-16 07:45:46 +00002294 // PrevDecl is a namespace.
Argyrios Kyrtzidis0f84a232008-11-09 22:53:32 +00002295 if (isDeclInScope(PrevDecl, DC, S)) {
Ted Kremeneka89d1972008-09-03 18:03:35 +00002296 // The tag name clashes with a namespace name, issue an error and
2297 // recover by making this tag be anonymous.
Chris Lattner3c73c412008-11-19 08:23:25 +00002298 Diag(NameLoc, diag::err_redefinition_different_kind) << Name;
Chris Lattner5f4a6822008-11-23 23:12:31 +00002299 Diag(PrevDecl->getLocation(), diag::note_previous_definition);
Argyrios Kyrtzidisb02ef242008-07-16 07:45:46 +00002300 Name = 0;
2301 }
Reid Spencer5f016e22007-07-11 17:01:13 +00002302 }
Reid Spencer5f016e22007-07-11 17:01:13 +00002303 }
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +00002304
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +00002305 CreateNewDecl:
Reid Spencer5f016e22007-07-11 17:01:13 +00002306
2307 // If there is an identifier, use the location of the identifier as the
2308 // location of the decl, otherwise use the location of the struct/union
2309 // keyword.
2310 SourceLocation Loc = NameLoc.isValid() ? NameLoc : KWLoc;
2311
2312 // Otherwise, if this is the first time we've seen this tag, create the decl.
2313 TagDecl *New;
Argyrios Kyrtzidis39ba4ae2008-06-09 23:19:58 +00002314 if (Kind == TagDecl::TK_enum) {
Reid Spencer5f016e22007-07-11 17:01:13 +00002315 // FIXME: Tag decls should be chained to any simultaneous vardecls, e.g.:
2316 // enum X { A, B, C } D; D should chain to X.
Argyrios Kyrtzidis0f84a232008-11-09 22:53:32 +00002317 New = EnumDecl::Create(Context, DC, Loc, Name, 0);
Reid Spencer5f016e22007-07-11 17:01:13 +00002318 // If this is an undefined enum, warn.
2319 if (TK != TK_Definition) Diag(Loc, diag::ext_forward_ref_enum);
Argyrios Kyrtzidis39ba4ae2008-06-09 23:19:58 +00002320 } else {
2321 // struct/union/class
2322
Reid Spencer5f016e22007-07-11 17:01:13 +00002323 // FIXME: Tag decls should be chained to any simultaneous vardecls, e.g.:
2324 // struct X { int A; } D; D should chain to X.
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +00002325 if (getLangOptions().CPlusPlus)
Ted Kremenek2b345eb2008-09-05 17:39:33 +00002326 // FIXME: Look for a way to use RecordDecl for simple structs.
Argyrios Kyrtzidis0f84a232008-11-09 22:53:32 +00002327 New = CXXRecordDecl::Create(Context, Kind, DC, Loc, Name);
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +00002328 else
Argyrios Kyrtzidis0f84a232008-11-09 22:53:32 +00002329 New = RecordDecl::Create(Context, Kind, DC, Loc, Name);
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +00002330 }
Reid Spencer5f016e22007-07-11 17:01:13 +00002331
2332 // If this has an identifier, add it to the scope stack.
2333 if (Name) {
Chris Lattner31e05722007-08-26 06:24:45 +00002334 // The scope passed in may not be a decl scope. Zip up the scope tree until
2335 // we find one that is.
2336 while ((S->getFlags() & Scope::DeclScope) == 0)
2337 S = S->getParent();
2338
2339 // Add it to the decl chain.
Argyrios Kyrtzidis87f3ff02008-04-12 00:47:19 +00002340 PushOnScopeChains(New, S);
Reid Spencer5f016e22007-07-11 17:01:13 +00002341 }
Chris Lattnere1e79852008-02-06 00:51:33 +00002342
Chris Lattnerf2e4bd52008-06-28 23:58:55 +00002343 if (Attr)
2344 ProcessDeclAttributeList(New, Attr);
Argyrios Kyrtzidis52393042008-11-09 23:41:00 +00002345
2346 // Set the lexical context. If the tag has a C++ scope specifier, the
2347 // lexical context will be different from the semantic context.
2348 New->setLexicalDeclContext(CurContext);
2349
Reid Spencer5f016e22007-07-11 17:01:13 +00002350 return New;
2351}
2352
Ted Kremenek4b7c9832008-09-05 17:16:31 +00002353/// ActOnTagStruct - New "ActOnTag" logic for structs/unions/classes. Unlike
2354/// the logic for enums, we create separate decls for forward declarations.
2355/// This is called by ActOnTag, but eventually will replace its logic.
2356Sema::DeclTy *Sema::ActOnTagStruct(Scope *S, TagDecl::TagKind Kind, TagKind TK,
Argyrios Kyrtzidis630c81b2008-11-09 22:09:58 +00002357 SourceLocation KWLoc, const CXXScopeSpec &SS,
2358 IdentifierInfo *Name, SourceLocation NameLoc,
2359 AttributeList *Attr) {
Argyrios Kyrtzidis0f84a232008-11-09 22:53:32 +00002360 DeclContext *DC = CurContext;
2361 ScopedDecl *PrevDecl = 0;
Argyrios Kyrtzidis630c81b2008-11-09 22:09:58 +00002362
2363 if (Name && SS.isNotEmpty()) {
2364 // We have a nested-name tag ('struct foo::bar').
2365
2366 // Check for invalid 'foo::'.
Argyrios Kyrtzidis0f84a232008-11-09 22:53:32 +00002367 if (SS.isInvalid()) {
Argyrios Kyrtzidis630c81b2008-11-09 22:09:58 +00002368 Name = 0;
2369 goto CreateNewDecl;
2370 }
2371
Argyrios Kyrtzidis0f84a232008-11-09 22:53:32 +00002372 DC = static_cast<DeclContext*>(SS.getScopeRep());
2373 // Look-up name inside 'foo::'.
Argyrios Kyrtzidis630c81b2008-11-09 22:09:58 +00002374 PrevDecl = dyn_cast_or_null<TagDecl>(LookupDecl(Name, Decl::IDNS_Tag,S,DC));
2375
2376 // A tag 'foo::bar' must already exist.
2377 if (PrevDecl == 0) {
Chris Lattner3c73c412008-11-19 08:23:25 +00002378 Diag(NameLoc, diag::err_not_tag_in_scope) << Name << SS.getRange();
Argyrios Kyrtzidis630c81b2008-11-09 22:09:58 +00002379 Name = 0;
2380 goto CreateNewDecl;
2381 }
2382 } else {
2383 // If this is a named struct, check to see if there was a previous forward
2384 // declaration or definition.
2385 // Use ScopedDecl instead of TagDecl, because a NamespaceDecl may come up.
2386 PrevDecl = dyn_cast_or_null<ScopedDecl>(LookupDecl(Name, Decl::IDNS_Tag,S));
2387 }
Ted Kremenek4b7c9832008-09-05 17:16:31 +00002388
2389 if (PrevDecl) {
2390 assert((isa<TagDecl>(PrevDecl) || isa<NamespaceDecl>(PrevDecl)) &&
2391 "unexpected Decl type");
2392
2393 if (TagDecl *PrevTagDecl = dyn_cast<TagDecl>(PrevDecl)) {
2394 // If this is a use of a previous tag, or if the tag is already declared
2395 // in the same scope (so that the definition/declaration completes or
2396 // rementions the tag), reuse the decl.
Argyrios Kyrtzidis0f84a232008-11-09 22:53:32 +00002397 if (TK == TK_Reference || isDeclInScope(PrevDecl, DC, S)) {
Ted Kremenek4b7c9832008-09-05 17:16:31 +00002398 // Make sure that this wasn't declared as an enum and now used as a
2399 // struct or something similar.
2400 if (PrevTagDecl->getTagKind() != Kind) {
Chris Lattner3c73c412008-11-19 08:23:25 +00002401 Diag(KWLoc, diag::err_use_with_wrong_tag) << Name;
Chris Lattner5f4a6822008-11-23 23:12:31 +00002402 Diag(PrevDecl->getLocation(), diag::note_previous_use);
Ted Kremenek4b7c9832008-09-05 17:16:31 +00002403 // Recover by making this an anonymous redefinition.
2404 Name = 0;
2405 PrevDecl = 0;
2406 } else {
2407 // If this is a use, return the original decl.
2408
2409 // FIXME: In the future, return a variant or some other clue
2410 // for the consumer of this Decl to know it doesn't own it.
2411 // For our current ASTs this shouldn't be a problem, but will
2412 // need to be changed with DeclGroups.
2413 if (TK == TK_Reference)
2414 return PrevDecl;
2415
2416 // The new decl is a definition?
2417 if (TK == TK_Definition) {
2418 // Diagnose attempts to redefine a tag.
2419 if (RecordDecl* DefRecord =
2420 cast<RecordDecl>(PrevTagDecl)->getDefinition(Context)) {
Chris Lattner3c73c412008-11-19 08:23:25 +00002421 Diag(NameLoc, diag::err_redefinition) << Name;
Chris Lattner5f4a6822008-11-23 23:12:31 +00002422 Diag(DefRecord->getLocation(), diag::note_previous_definition);
Ted Kremenek4b7c9832008-09-05 17:16:31 +00002423 // If this is a redefinition, recover by making this struct be
2424 // anonymous, which will make any later references get the previous
2425 // definition.
2426 Name = 0;
2427 PrevDecl = 0;
2428 }
2429 // Okay, this is definition of a previously declared or referenced
2430 // tag. We're going to create a new Decl.
2431 }
2432 }
2433 // If we get here we have (another) forward declaration. Just create
2434 // a new decl.
2435 }
2436 else {
2437 // If we get here, this is a definition of a new struct type in a nested
2438 // scope, e.g. "struct foo; void bar() { struct foo; }", just create a
2439 // new decl/type. We set PrevDecl to NULL so that the Records
2440 // have distinct types.
2441 PrevDecl = 0;
2442 }
2443 } else {
2444 // PrevDecl is a namespace.
Argyrios Kyrtzidis0f84a232008-11-09 22:53:32 +00002445 if (isDeclInScope(PrevDecl, DC, S)) {
Ted Kremenek4b7c9832008-09-05 17:16:31 +00002446 // The tag name clashes with a namespace name, issue an error and
2447 // recover by making this tag be anonymous.
Chris Lattner3c73c412008-11-19 08:23:25 +00002448 Diag(NameLoc, diag::err_redefinition_different_kind) << Name;
Chris Lattner5f4a6822008-11-23 23:12:31 +00002449 Diag(PrevDecl->getLocation(), diag::note_previous_definition);
Ted Kremenek4b7c9832008-09-05 17:16:31 +00002450 Name = 0;
2451 }
2452 }
2453 }
Argyrios Kyrtzidis630c81b2008-11-09 22:09:58 +00002454
2455 CreateNewDecl:
2456
Ted Kremenek4b7c9832008-09-05 17:16:31 +00002457 // If there is an identifier, use the location of the identifier as the
2458 // location of the decl, otherwise use the location of the struct/union
2459 // keyword.
2460 SourceLocation Loc = NameLoc.isValid() ? NameLoc : KWLoc;
2461
2462 // Otherwise, if this is the first time we've seen this tag, create the decl.
2463 TagDecl *New;
2464
2465 // FIXME: Tag decls should be chained to any simultaneous vardecls, e.g.:
2466 // struct X { int A; } D; D should chain to X.
2467 if (getLangOptions().CPlusPlus)
Ted Kremenek2b345eb2008-09-05 17:39:33 +00002468 // FIXME: Look for a way to use RecordDecl for simple structs.
Argyrios Kyrtzidis0f84a232008-11-09 22:53:32 +00002469 New = CXXRecordDecl::Create(Context, Kind, DC, Loc, Name,
Ted Kremenek4b7c9832008-09-05 17:16:31 +00002470 dyn_cast_or_null<CXXRecordDecl>(PrevDecl));
2471 else
Argyrios Kyrtzidis0f84a232008-11-09 22:53:32 +00002472 New = RecordDecl::Create(Context, Kind, DC, Loc, Name,
Ted Kremenek4b7c9832008-09-05 17:16:31 +00002473 dyn_cast_or_null<RecordDecl>(PrevDecl));
2474
2475 // If this has an identifier, add it to the scope stack.
2476 if ((TK == TK_Definition || !PrevDecl) && Name) {
2477 // The scope passed in may not be a decl scope. Zip up the scope tree until
2478 // we find one that is.
2479 while ((S->getFlags() & Scope::DeclScope) == 0)
2480 S = S->getParent();
2481
2482 // Add it to the decl chain.
2483 PushOnScopeChains(New, S);
2484 }
Daniel Dunbar3b0db902008-10-16 02:34:03 +00002485
2486 // Handle #pragma pack: if the #pragma pack stack has non-default
2487 // alignment, make up a packed attribute for this decl. These
2488 // attributes are checked when the ASTContext lays out the
2489 // structure.
2490 //
2491 // It is important for implementing the correct semantics that this
2492 // happen here (in act on tag decl). The #pragma pack stack is
2493 // maintained as a result of parser callbacks which can occur at
2494 // many points during the parsing of a struct declaration (because
2495 // the #pragma tokens are effectively skipped over during the
2496 // parsing of the struct).
2497 if (unsigned Alignment = PackContext.getAlignment())
2498 New->addAttr(new PackedAttr(Alignment * 8));
Ted Kremenek4b7c9832008-09-05 17:16:31 +00002499
2500 if (Attr)
2501 ProcessDeclAttributeList(New, Attr);
2502
Argyrios Kyrtzidis52393042008-11-09 23:41:00 +00002503 // Set the lexical context. If the tag has a C++ scope specifier, the
2504 // lexical context will be different from the semantic context.
2505 New->setLexicalDeclContext(CurContext);
2506
Ted Kremenek4b7c9832008-09-05 17:16:31 +00002507 return New;
2508}
2509
2510
Chris Lattner5a6ddbf2008-06-21 19:39:06 +00002511/// Collect the instance variables declared in an Objective-C object. Used in
2512/// the creation of structures from objects using the @defs directive.
Ted Kremenek01e67792008-08-20 03:26:33 +00002513static void CollectIvars(ObjCInterfaceDecl *Class, ASTContext& Ctx,
Chris Lattner7caeabd2008-07-21 22:17:28 +00002514 llvm::SmallVectorImpl<Sema::DeclTy*> &ivars) {
Chris Lattner5a6ddbf2008-06-21 19:39:06 +00002515 if (Class->getSuperClass())
Ted Kremenek01e67792008-08-20 03:26:33 +00002516 CollectIvars(Class->getSuperClass(), Ctx, ivars);
2517
2518 // For each ivar, create a fresh ObjCAtDefsFieldDecl.
Ted Kremeneka89d1972008-09-03 18:03:35 +00002519 for (ObjCInterfaceDecl::ivar_iterator
2520 I=Class->ivar_begin(), E=Class->ivar_end(); I!=E; ++I) {
2521
Ted Kremenek01e67792008-08-20 03:26:33 +00002522 ObjCIvarDecl* ID = *I;
2523 ivars.push_back(ObjCAtDefsFieldDecl::Create(Ctx, ID->getLocation(),
2524 ID->getIdentifier(),
2525 ID->getType(),
2526 ID->getBitWidth()));
2527 }
Chris Lattner5a6ddbf2008-06-21 19:39:06 +00002528}
2529
2530/// Called whenever @defs(ClassName) is encountered in the source. Inserts the
2531/// instance variables of ClassName into Decls.
2532void Sema::ActOnDefs(Scope *S, SourceLocation DeclStart,
2533 IdentifierInfo *ClassName,
Chris Lattner7caeabd2008-07-21 22:17:28 +00002534 llvm::SmallVectorImpl<DeclTy*> &Decls) {
Chris Lattner5a6ddbf2008-06-21 19:39:06 +00002535 // Check that ClassName is a valid class
2536 ObjCInterfaceDecl *Class = getObjCInterfaceDecl(ClassName);
2537 if (!Class) {
Chris Lattner3c73c412008-11-19 08:23:25 +00002538 Diag(DeclStart, diag::err_undef_interface) << ClassName;
Chris Lattner5a6ddbf2008-06-21 19:39:06 +00002539 return;
2540 }
Chris Lattner5a6ddbf2008-06-21 19:39:06 +00002541 // Collect the instance variables
Ted Kremenek01e67792008-08-20 03:26:33 +00002542 CollectIvars(Class, Context, Decls);
Chris Lattner5a6ddbf2008-06-21 19:39:06 +00002543}
2544
Chris Lattner1d353ba2008-11-12 21:17:48 +00002545/// TryToFixInvalidVariablyModifiedType - Helper method to turn variable array
2546/// types into constant array types in certain situations which would otherwise
2547/// be errors (for GCC compatibility).
2548static QualType TryToFixInvalidVariablyModifiedType(QualType T,
2549 ASTContext &Context) {
Eli Friedman1b76ada2008-06-03 21:01:11 +00002550 // This method tries to turn a variable array into a constant
2551 // array even when the size isn't an ICE. This is necessary
2552 // for compatibility with code that depends on gcc's buggy
2553 // constant expression folding, like struct {char x[(int)(char*)2];}
Chris Lattner57d57882008-11-12 19:48:13 +00002554 const VariableArrayType* VLATy = dyn_cast<VariableArrayType>(T);
2555 if (!VLATy) return QualType();
2556
2557 APValue Result;
2558 if (!VLATy->getSizeExpr() ||
Chris Lattner6ee7aa12008-11-16 21:24:15 +00002559 !VLATy->getSizeExpr()->Evaluate(Result, Context))
Chris Lattner57d57882008-11-12 19:48:13 +00002560 return QualType();
2561
2562 assert(Result.isInt() && "Size expressions must be integers!");
2563 llvm::APSInt &Res = Result.getInt();
2564 if (Res > llvm::APSInt(Res.getBitWidth(), Res.isUnsigned()))
2565 return Context.getConstantArrayType(VLATy->getElementType(),
2566 Res, ArrayType::Normal, 0);
Eli Friedman1b76ada2008-06-03 21:01:11 +00002567 return QualType();
2568}
2569
Steve Naroff08d92e42007-09-15 18:49:24 +00002570/// ActOnField - Each field of a struct/union/class is passed into this in order
Reid Spencer5f016e22007-07-11 17:01:13 +00002571/// to create a FieldDecl object for it.
Fariborz Jahanian1d78cc42008-04-10 23:32:45 +00002572Sema::DeclTy *Sema::ActOnField(Scope *S,
Reid Spencer5f016e22007-07-11 17:01:13 +00002573 SourceLocation DeclStart,
2574 Declarator &D, ExprTy *BitfieldWidth) {
2575 IdentifierInfo *II = D.getIdentifier();
2576 Expr *BitWidth = (Expr*)BitfieldWidth;
Reid Spencer5f016e22007-07-11 17:01:13 +00002577 SourceLocation Loc = DeclStart;
2578 if (II) Loc = D.getIdentifierLoc();
2579
2580 // FIXME: Unnamed fields can be handled in various different ways, for
2581 // example, unnamed unions inject all members into the struct namespace!
Ted Kremeneka89d1972008-09-03 18:03:35 +00002582
Reid Spencer5f016e22007-07-11 17:01:13 +00002583 if (BitWidth) {
2584 // TODO: Validate.
2585 //printf("WARNING: BITFIELDS IGNORED!\n");
2586
2587 // 6.7.2.1p3
2588 // 6.7.2.1p4
2589
2590 } else {
2591 // Not a bitfield.
2592
2593 // validate II.
2594
2595 }
2596
2597 QualType T = GetTypeForDeclarator(D, S);
Steve Naroff5912a352007-08-28 20:14:24 +00002598 assert(!T.isNull() && "GetTypeForDeclarator() returned null type");
2599 bool InvalidDecl = false;
Steve Naroffd7444aa2007-08-31 17:20:07 +00002600
Reid Spencer5f016e22007-07-11 17:01:13 +00002601 // C99 6.7.2.1p8: A member of a structure or union may have any type other
2602 // than a variably modified type.
Eli Friedman9db13972008-02-15 12:53:51 +00002603 if (T->isVariablyModifiedType()) {
Chris Lattner1d353ba2008-11-12 21:17:48 +00002604 QualType FixedTy = TryToFixInvalidVariablyModifiedType(T, Context);
Eli Friedman1b76ada2008-06-03 21:01:11 +00002605 if (!FixedTy.isNull()) {
Chris Lattner23cd0d92008-11-13 18:49:38 +00002606 Diag(Loc, diag::warn_illegal_constant_array_size);
Eli Friedman1b76ada2008-06-03 21:01:11 +00002607 T = FixedTy;
2608 } else {
Chris Lattner23cd0d92008-11-13 18:49:38 +00002609 Diag(Loc, diag::err_typecheck_field_variable_size);
Chris Lattner3ab55432008-11-12 19:45:49 +00002610 T = Context.IntTy;
Eli Friedman1b76ada2008-06-03 21:01:11 +00002611 InvalidDecl = true;
2612 }
Reid Spencer5f016e22007-07-11 17:01:13 +00002613 }
Reid Spencer5f016e22007-07-11 17:01:13 +00002614 // FIXME: Chain fielddecls together.
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +00002615 FieldDecl *NewFD;
2616
2617 if (getLangOptions().CPlusPlus) {
2618 // FIXME: Replace CXXFieldDecls with FieldDecls for simple structs.
2619 NewFD = CXXFieldDecl::Create(Context, cast<CXXRecordDecl>(CurContext),
Sebastian Redla11f42f2008-11-17 23:24:37 +00002620 Loc, II, T,
2621 D.getDeclSpec().getStorageClassSpec() ==
2622 DeclSpec::SCS_mutable, BitWidth);
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +00002623 if (II)
2624 PushOnScopeChains(NewFD, S);
2625 }
2626 else
2627 NewFD = FieldDecl::Create(Context, Loc, II, T, BitWidth);
Steve Naroff44739212007-09-11 21:17:26 +00002628
Chris Lattner3ff30c82008-06-29 00:02:00 +00002629 ProcessDeclAttributes(NewFD, D);
Anders Carlssonad148062008-02-16 00:29:18 +00002630
Steve Naroff5912a352007-08-28 20:14:24 +00002631 if (D.getInvalidType() || InvalidDecl)
2632 NewFD->setInvalidDecl();
2633 return NewFD;
Reid Spencer5f016e22007-07-11 17:01:13 +00002634}
2635
Fariborz Jahanian89204a12007-10-01 16:53:59 +00002636/// TranslateIvarVisibility - Translate visibility from a token ID to an
2637/// AST enum value.
Ted Kremeneka526c5c2008-01-07 19:49:32 +00002638static ObjCIvarDecl::AccessControl
Fariborz Jahanian89204a12007-10-01 16:53:59 +00002639TranslateIvarVisibility(tok::ObjCKeywordKind ivarVisibility) {
Steve Narofff13271f2007-09-14 23:09:53 +00002640 switch (ivarVisibility) {
Chris Lattner33d34a62008-10-12 00:28:42 +00002641 default: assert(0 && "Unknown visitibility kind");
2642 case tok::objc_private: return ObjCIvarDecl::Private;
2643 case tok::objc_public: return ObjCIvarDecl::Public;
2644 case tok::objc_protected: return ObjCIvarDecl::Protected;
2645 case tok::objc_package: return ObjCIvarDecl::Package;
Steve Narofff13271f2007-09-14 23:09:53 +00002646 }
2647}
2648
Fariborz Jahanian45bc03f2008-04-11 16:55:42 +00002649/// ActOnIvar - Each ivar field of an objective-c class is passed into this
2650/// in order to create an IvarDecl object for it.
Fariborz Jahanian1d78cc42008-04-10 23:32:45 +00002651Sema::DeclTy *Sema::ActOnIvar(Scope *S,
Fariborz Jahanian45bc03f2008-04-11 16:55:42 +00002652 SourceLocation DeclStart,
2653 Declarator &D, ExprTy *BitfieldWidth,
2654 tok::ObjCKeywordKind Visibility) {
Fariborz Jahanian1d78cc42008-04-10 23:32:45 +00002655 IdentifierInfo *II = D.getIdentifier();
2656 Expr *BitWidth = (Expr*)BitfieldWidth;
2657 SourceLocation Loc = DeclStart;
2658 if (II) Loc = D.getIdentifierLoc();
2659
2660 // FIXME: Unnamed fields can be handled in various different ways, for
2661 // example, unnamed unions inject all members into the struct namespace!
2662
2663
2664 if (BitWidth) {
2665 // TODO: Validate.
2666 //printf("WARNING: BITFIELDS IGNORED!\n");
2667
2668 // 6.7.2.1p3
2669 // 6.7.2.1p4
2670
2671 } else {
2672 // Not a bitfield.
2673
2674 // validate II.
2675
2676 }
2677
2678 QualType T = GetTypeForDeclarator(D, S);
2679 assert(!T.isNull() && "GetTypeForDeclarator() returned null type");
2680 bool InvalidDecl = false;
2681
2682 // C99 6.7.2.1p8: A member of a structure or union may have any type other
2683 // than a variably modified type.
2684 if (T->isVariablyModifiedType()) {
2685 // FIXME: This diagnostic needs work
Chris Lattnerdcd5ef12008-11-19 05:27:50 +00002686 Diag(Loc, diag::err_typecheck_illegal_vla) << SourceRange(Loc);
Fariborz Jahanian1d78cc42008-04-10 23:32:45 +00002687 InvalidDecl = true;
2688 }
2689
Ted Kremenekb8db21d2008-07-23 18:04:17 +00002690 // Get the visibility (access control) for this ivar.
2691 ObjCIvarDecl::AccessControl ac =
2692 Visibility != tok::objc_not_keyword ? TranslateIvarVisibility(Visibility)
2693 : ObjCIvarDecl::None;
2694
2695 // Construct the decl.
2696 ObjCIvarDecl *NewID = ObjCIvarDecl::Create(Context, Loc, II, T, ac,
Steve Naroff8f3b2652008-07-16 18:22:22 +00002697 (Expr *)BitfieldWidth);
Fariborz Jahanian1d78cc42008-04-10 23:32:45 +00002698
Ted Kremenekb8db21d2008-07-23 18:04:17 +00002699 // Process attributes attached to the ivar.
Chris Lattner3ff30c82008-06-29 00:02:00 +00002700 ProcessDeclAttributes(NewID, D);
Fariborz Jahanian1d78cc42008-04-10 23:32:45 +00002701
2702 if (D.getInvalidType() || InvalidDecl)
2703 NewID->setInvalidDecl();
Ted Kremenekb8db21d2008-07-23 18:04:17 +00002704
Fariborz Jahanian1d78cc42008-04-10 23:32:45 +00002705 return NewID;
2706}
2707
Fariborz Jahanian9d048ff2007-09-29 00:54:24 +00002708void Sema::ActOnFields(Scope* S,
Fariborz Jahanian3f5faf72007-10-04 00:45:27 +00002709 SourceLocation RecLoc, DeclTy *RecDecl,
Steve Naroff08d92e42007-09-15 18:49:24 +00002710 DeclTy **Fields, unsigned NumFields,
Daniel Dunbar1bfe1c22008-10-03 02:03:53 +00002711 SourceLocation LBrac, SourceLocation RBrac,
Daniel Dunbar7d076642008-10-03 17:33:35 +00002712 AttributeList *Attr) {
Steve Naroff74216642007-09-14 22:20:54 +00002713 Decl *EnclosingDecl = static_cast<Decl*>(RecDecl);
2714 assert(EnclosingDecl && "missing record or interface decl");
2715 RecordDecl *Record = dyn_cast<RecordDecl>(EnclosingDecl);
2716
Ted Kremenek4b7c9832008-09-05 17:16:31 +00002717 if (Record)
2718 if (RecordDecl* DefRecord = Record->getDefinition(Context)) {
2719 // Diagnose code like:
2720 // struct S { struct S {} X; };
2721 // We discover this when we complete the outer S. Reject and ignore the
2722 // outer S.
Chris Lattnerf3a41af2008-11-20 06:38:18 +00002723 Diag(DefRecord->getLocation(), diag::err_nested_redefinition)
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00002724 << DefRecord->getDeclName();
Chris Lattner5f4a6822008-11-23 23:12:31 +00002725 Diag(RecLoc, diag::note_previous_definition);
Ted Kremenek4b7c9832008-09-05 17:16:31 +00002726 Record->setInvalidDecl();
2727 return;
2728 }
2729
Reid Spencer5f016e22007-07-11 17:01:13 +00002730 // Verify that all the fields are okay.
2731 unsigned NumNamedMembers = 0;
2732 llvm::SmallVector<FieldDecl*, 32> RecFields;
2733 llvm::SmallSet<const IdentifierInfo*, 32> FieldIDs;
Steve Naroff74216642007-09-14 22:20:54 +00002734
Reid Spencer5f016e22007-07-11 17:01:13 +00002735 for (unsigned i = 0; i != NumFields; ++i) {
Fariborz Jahaniane267ab62007-09-14 16:27:55 +00002736
Steve Naroff74216642007-09-14 22:20:54 +00002737 FieldDecl *FD = cast_or_null<FieldDecl>(static_cast<Decl*>(Fields[i]));
2738 assert(FD && "missing field decl");
2739
2740 // Remember all fields.
2741 RecFields.push_back(FD);
Reid Spencer5f016e22007-07-11 17:01:13 +00002742
2743 // Get the type for the field.
Chris Lattner02c642e2007-07-31 21:33:24 +00002744 Type *FDTy = FD->getType().getTypePtr();
Steve Narofff13271f2007-09-14 23:09:53 +00002745
Reid Spencer5f016e22007-07-11 17:01:13 +00002746 // C99 6.7.2.1p2 - A field may not be a function type.
Chris Lattner02c642e2007-07-31 21:33:24 +00002747 if (FDTy->isFunctionType()) {
Chris Lattnerf3a41af2008-11-20 06:38:18 +00002748 Diag(FD->getLocation(), diag::err_field_declared_as_function)
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00002749 << FD->getDeclName();
Steve Naroff74216642007-09-14 22:20:54 +00002750 FD->setInvalidDecl();
2751 EnclosingDecl->setInvalidDecl();
Reid Spencer5f016e22007-07-11 17:01:13 +00002752 continue;
2753 }
Reid Spencer5f016e22007-07-11 17:01:13 +00002754 // C99 6.7.2.1p2 - A field may not be an incomplete type except...
2755 if (FDTy->isIncompleteType()) {
Fariborz Jahaniane267ab62007-09-14 16:27:55 +00002756 if (!Record) { // Incomplete ivar type is always an error.
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00002757 Diag(FD->getLocation(), diag::err_field_incomplete) <<FD->getDeclName();
Steve Naroff74216642007-09-14 22:20:54 +00002758 FD->setInvalidDecl();
2759 EnclosingDecl->setInvalidDecl();
Fariborz Jahanian3f5faf72007-10-04 00:45:27 +00002760 continue;
Fariborz Jahaniane267ab62007-09-14 16:27:55 +00002761 }
Reid Spencer5f016e22007-07-11 17:01:13 +00002762 if (i != NumFields-1 || // ... that the last member ...
Argyrios Kyrtzidis39ba4ae2008-06-09 23:19:58 +00002763 !Record->isStruct() || // ... of a structure ...
Chris Lattner02c642e2007-07-31 21:33:24 +00002764 !FDTy->isArrayType()) { //... may have incomplete array type.
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00002765 Diag(FD->getLocation(), diag::err_field_incomplete) <<FD->getDeclName();
Steve Naroff74216642007-09-14 22:20:54 +00002766 FD->setInvalidDecl();
2767 EnclosingDecl->setInvalidDecl();
Reid Spencer5f016e22007-07-11 17:01:13 +00002768 continue;
2769 }
Fariborz Jahaniane267ab62007-09-14 16:27:55 +00002770 if (NumNamedMembers < 1) { //... must have more than named member ...
Chris Lattnerf3a41af2008-11-20 06:38:18 +00002771 Diag(FD->getLocation(), diag::err_flexible_array_empty_struct)
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00002772 << FD->getDeclName();
Steve Naroff74216642007-09-14 22:20:54 +00002773 FD->setInvalidDecl();
2774 EnclosingDecl->setInvalidDecl();
Reid Spencer5f016e22007-07-11 17:01:13 +00002775 continue;
2776 }
Reid Spencer5f016e22007-07-11 17:01:13 +00002777 // Okay, we have a legal flexible array member at the end of the struct.
Fariborz Jahaniane267ab62007-09-14 16:27:55 +00002778 if (Record)
2779 Record->setHasFlexibleArrayMember(true);
Reid Spencer5f016e22007-07-11 17:01:13 +00002780 }
Reid Spencer5f016e22007-07-11 17:01:13 +00002781 /// C99 6.7.2.1p2 - a struct ending in a flexible array member cannot be the
2782 /// field of another structure or the element of an array.
Chris Lattner02c642e2007-07-31 21:33:24 +00002783 if (const RecordType *FDTTy = FDTy->getAsRecordType()) {
Reid Spencer5f016e22007-07-11 17:01:13 +00002784 if (FDTTy->getDecl()->hasFlexibleArrayMember()) {
2785 // If this is a member of a union, then entire union becomes "flexible".
Argyrios Kyrtzidis39ba4ae2008-06-09 23:19:58 +00002786 if (Record && Record->isUnion()) {
Reid Spencer5f016e22007-07-11 17:01:13 +00002787 Record->setHasFlexibleArrayMember(true);
2788 } else {
2789 // If this is a struct/class and this is not the last element, reject
2790 // it. Note that GCC supports variable sized arrays in the middle of
2791 // structures.
2792 if (i != NumFields-1) {
Chris Lattnerf3a41af2008-11-20 06:38:18 +00002793 Diag(FD->getLocation(), diag::err_variable_sized_type_in_struct)
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00002794 << FD->getDeclName();
Steve Naroff74216642007-09-14 22:20:54 +00002795 FD->setInvalidDecl();
2796 EnclosingDecl->setInvalidDecl();
Reid Spencer5f016e22007-07-11 17:01:13 +00002797 continue;
2798 }
Reid Spencer5f016e22007-07-11 17:01:13 +00002799 // We support flexible arrays at the end of structs in other structs
2800 // as an extension.
Chris Lattnerf3a41af2008-11-20 06:38:18 +00002801 Diag(FD->getLocation(), diag::ext_flexible_array_in_struct)
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00002802 << FD->getDeclName();
Fariborz Jahanian3f5faf72007-10-04 00:45:27 +00002803 if (Record)
Fariborz Jahaniane267ab62007-09-14 16:27:55 +00002804 Record->setHasFlexibleArrayMember(true);
Reid Spencer5f016e22007-07-11 17:01:13 +00002805 }
2806 }
2807 }
Fariborz Jahaniane7f64cc2007-10-12 22:10:42 +00002808 /// A field cannot be an Objective-c object
Ted Kremeneka526c5c2008-01-07 19:49:32 +00002809 if (FDTy->isObjCInterfaceType()) {
Chris Lattnerf3a41af2008-11-20 06:38:18 +00002810 Diag(FD->getLocation(), diag::err_statically_allocated_object)
Chris Lattner08631c52008-11-23 21:45:46 +00002811 << FD->getDeclName();
Fariborz Jahaniane7f64cc2007-10-12 22:10:42 +00002812 FD->setInvalidDecl();
2813 EnclosingDecl->setInvalidDecl();
2814 continue;
2815 }
Reid Spencer5f016e22007-07-11 17:01:13 +00002816 // Keep track of the number of named members.
2817 if (IdentifierInfo *II = FD->getIdentifier()) {
2818 // Detect duplicate member names.
2819 if (!FieldIDs.insert(II)) {
Chris Lattner3c73c412008-11-19 08:23:25 +00002820 Diag(FD->getLocation(), diag::err_duplicate_member) << II;
Reid Spencer5f016e22007-07-11 17:01:13 +00002821 // Find the previous decl.
2822 SourceLocation PrevLoc;
Chris Lattner33d34a62008-10-12 00:28:42 +00002823 for (unsigned i = 0; ; ++i) {
2824 assert(i != RecFields.size() && "Didn't find previous def!");
Reid Spencer5f016e22007-07-11 17:01:13 +00002825 if (RecFields[i]->getIdentifier() == II) {
2826 PrevLoc = RecFields[i]->getLocation();
2827 break;
2828 }
2829 }
Chris Lattner5f4a6822008-11-23 23:12:31 +00002830 Diag(PrevLoc, diag::note_previous_definition);
Steve Naroff74216642007-09-14 22:20:54 +00002831 FD->setInvalidDecl();
2832 EnclosingDecl->setInvalidDecl();
Reid Spencer5f016e22007-07-11 17:01:13 +00002833 continue;
2834 }
2835 ++NumNamedMembers;
2836 }
Reid Spencer5f016e22007-07-11 17:01:13 +00002837 }
2838
Reid Spencer5f016e22007-07-11 17:01:13 +00002839 // Okay, we successfully defined 'Record'.
Chris Lattnere1e79852008-02-06 00:51:33 +00002840 if (Record) {
Ted Kremenek4b7c9832008-09-05 17:16:31 +00002841 Record->defineBody(Context, &RecFields[0], RecFields.size());
Argyrios Kyrtzidisa4755c62008-08-09 00:58:37 +00002842 // If this is a C++ record, HandleTagDeclDefinition will be invoked in
2843 // Sema::ActOnFinishCXXClassDef.
2844 if (!isa<CXXRecordDecl>(Record))
2845 Consumer.HandleTagDeclDefinition(Record);
Chris Lattnere1e79852008-02-06 00:51:33 +00002846 } else {
Chris Lattnera91d3812008-02-05 22:40:55 +00002847 ObjCIvarDecl **ClsFields = reinterpret_cast<ObjCIvarDecl**>(&RecFields[0]);
2848 if (ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(EnclosingDecl))
2849 ID->addInstanceVariablesToClass(ClsFields, RecFields.size(), RBrac);
2850 else if (ObjCImplementationDecl *IMPDecl =
2851 dyn_cast<ObjCImplementationDecl>(EnclosingDecl)) {
Ted Kremeneka526c5c2008-01-07 19:49:32 +00002852 assert(IMPDecl && "ActOnFields - missing ObjCImplementationDecl");
2853 IMPDecl->ObjCAddInstanceVariablesToClassImpl(ClsFields, RecFields.size());
Fariborz Jahanian3a3ca1b2007-10-31 18:48:14 +00002854 CheckImplementationIvars(IMPDecl, ClsFields, RecFields.size(), RBrac);
Fariborz Jahaniand0b90bf2007-09-26 18:27:25 +00002855 }
Fariborz Jahanianb04a0212007-09-14 21:08:27 +00002856 }
Daniel Dunbar7d076642008-10-03 17:33:35 +00002857
2858 if (Attr)
2859 ProcessDeclAttributeList(Record, Attr);
Reid Spencer5f016e22007-07-11 17:01:13 +00002860}
2861
Steve Naroff08d92e42007-09-15 18:49:24 +00002862Sema::DeclTy *Sema::ActOnEnumConstant(Scope *S, DeclTy *theEnumDecl,
Reid Spencer5f016e22007-07-11 17:01:13 +00002863 DeclTy *lastEnumConst,
2864 SourceLocation IdLoc, IdentifierInfo *Id,
2865 SourceLocation EqualLoc, ExprTy *val) {
Chris Lattner0ed844b2008-04-04 06:12:32 +00002866 EnumDecl *TheEnumDecl = cast<EnumDecl>(static_cast<Decl*>(theEnumDecl));
Reid Spencer5f016e22007-07-11 17:01:13 +00002867 EnumConstantDecl *LastEnumConst =
2868 cast_or_null<EnumConstantDecl>(static_cast<Decl*>(lastEnumConst));
2869 Expr *Val = static_cast<Expr*>(val);
2870
Chris Lattner31e05722007-08-26 06:24:45 +00002871 // The scope passed in may not be a decl scope. Zip up the scope tree until
2872 // we find one that is.
2873 while ((S->getFlags() & Scope::DeclScope) == 0)
2874 S = S->getParent();
2875
Reid Spencer5f016e22007-07-11 17:01:13 +00002876 // Verify that there isn't already something declared with this name in this
2877 // scope.
Steve Naroffb327ce02008-04-02 14:35:35 +00002878 if (Decl *PrevDecl = LookupDecl(Id, Decl::IDNS_Ordinary, S)) {
Argyrios Kyrtzidis0ff12f02008-07-16 21:01:53 +00002879 // When in C++, we may get a TagDecl with the same name; in this case the
2880 // enum constant will 'hide' the tag.
2881 assert((getLangOptions().CPlusPlus || !isa<TagDecl>(PrevDecl)) &&
2882 "Received TagDecl when not in C++!");
Argyrios Kyrtzidis15a12d02008-09-09 21:18:04 +00002883 if (!isa<TagDecl>(PrevDecl) && isDeclInScope(PrevDecl, CurContext, S)) {
Reid Spencer5f016e22007-07-11 17:01:13 +00002884 if (isa<EnumConstantDecl>(PrevDecl))
Chris Lattner3c73c412008-11-19 08:23:25 +00002885 Diag(IdLoc, diag::err_redefinition_of_enumerator) << Id;
Reid Spencer5f016e22007-07-11 17:01:13 +00002886 else
Chris Lattner3c73c412008-11-19 08:23:25 +00002887 Diag(IdLoc, diag::err_redefinition) << Id;
Chris Lattner5f4a6822008-11-23 23:12:31 +00002888 Diag(PrevDecl->getLocation(), diag::note_previous_definition);
Chris Lattnera73349d2008-02-26 00:33:57 +00002889 delete Val;
Reid Spencer5f016e22007-07-11 17:01:13 +00002890 return 0;
2891 }
2892 }
2893
2894 llvm::APSInt EnumVal(32);
2895 QualType EltTy;
2896 if (Val) {
Chris Lattner421a23d2007-08-27 21:16:18 +00002897 // Make sure to promote the operand type to int.
2898 UsualUnaryConversions(Val);
2899
Reid Spencer5f016e22007-07-11 17:01:13 +00002900 // C99 6.7.2.2p2: Make sure we have an integer constant expression.
2901 SourceLocation ExpLoc;
Chris Lattner590b6642007-07-15 23:26:56 +00002902 if (!Val->isIntegerConstantExpr(EnumVal, Context, &ExpLoc)) {
Chris Lattner3c73c412008-11-19 08:23:25 +00002903 Diag(ExpLoc, diag::err_enum_value_not_integer_constant_expr) << Id;
Chris Lattnera73349d2008-02-26 00:33:57 +00002904 delete Val;
Chris Lattnerb7416f92007-08-27 17:37:24 +00002905 Val = 0; // Just forget about it.
Chris Lattnere9ca8512007-08-29 16:03:41 +00002906 } else {
2907 EltTy = Val->getType();
Reid Spencer5f016e22007-07-11 17:01:13 +00002908 }
Chris Lattnerb7416f92007-08-27 17:37:24 +00002909 }
2910
2911 if (!Val) {
2912 if (LastEnumConst) {
2913 // Assign the last value + 1.
2914 EnumVal = LastEnumConst->getInitVal();
2915 ++EnumVal;
Chris Lattner421a23d2007-08-27 21:16:18 +00002916
2917 // Check for overflow on increment.
2918 if (EnumVal < LastEnumConst->getInitVal())
2919 Diag(IdLoc, diag::warn_enum_value_overflow);
2920
Chris Lattnerb7416f92007-08-27 17:37:24 +00002921 EltTy = LastEnumConst->getType();
2922 } else {
2923 // First value, set to zero.
2924 EltTy = Context.IntTy;
Chris Lattner98be4942008-03-05 18:54:05 +00002925 EnumVal.zextOrTrunc(static_cast<uint32_t>(Context.getTypeSize(EltTy)));
Chris Lattnerb7416f92007-08-27 17:37:24 +00002926 }
Reid Spencer5f016e22007-07-11 17:01:13 +00002927 }
2928
Chris Lattner6c2b6eb2008-03-15 06:12:44 +00002929 EnumConstantDecl *New =
Chris Lattner0ed844b2008-04-04 06:12:32 +00002930 EnumConstantDecl::Create(Context, TheEnumDecl, IdLoc, Id, EltTy,
2931 Val, EnumVal,
Chris Lattnerc63e6602008-03-15 21:32:50 +00002932 LastEnumConst);
Reid Spencer5f016e22007-07-11 17:01:13 +00002933
2934 // Register this decl in the current scope stack.
Argyrios Kyrtzidis87f3ff02008-04-12 00:47:19 +00002935 PushOnScopeChains(New, S);
Reid Spencer5f016e22007-07-11 17:01:13 +00002936 return New;
2937}
2938
Steve Naroff02408c62008-08-07 14:08:16 +00002939// FIXME: For consistency with ActOnFields(), we should have the parser
2940// pass in the source location for the left/right braces.
Steve Naroff08d92e42007-09-15 18:49:24 +00002941void Sema::ActOnEnumBody(SourceLocation EnumLoc, DeclTy *EnumDeclX,
Reid Spencer5f016e22007-07-11 17:01:13 +00002942 DeclTy **Elements, unsigned NumElements) {
2943 EnumDecl *Enum = cast<EnumDecl>(static_cast<Decl*>(EnumDeclX));
Reid Spencer5f016e22007-07-11 17:01:13 +00002944
Steve Naroff02408c62008-08-07 14:08:16 +00002945 if (Enum && Enum->isDefinition()) {
2946 // Diagnose code like:
2947 // enum e0 {
2948 // E0 = sizeof(enum e0 { E1 })
2949 // };
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00002950 Diag(Enum->getLocation(), diag::err_nested_redefinition)
2951 << Enum->getDeclName();
Chris Lattner5f4a6822008-11-23 23:12:31 +00002952 Diag(EnumLoc, diag::note_previous_definition);
Steve Naroff02408c62008-08-07 14:08:16 +00002953 Enum->setInvalidDecl();
2954 return;
2955 }
Chris Lattnere37f0be2007-08-28 05:10:31 +00002956 // TODO: If the result value doesn't fit in an int, it must be a long or long
2957 // long value. ISO C does not support this, but GCC does as an extension,
2958 // emit a warning.
Chris Lattner98be4942008-03-05 18:54:05 +00002959 unsigned IntWidth = Context.Target.getIntWidth();
Chris Lattnere37f0be2007-08-28 05:10:31 +00002960
Chris Lattnerac609682007-08-28 06:15:15 +00002961 // Verify that all the values are okay, compute the size of the values, and
2962 // reverse the list.
2963 unsigned NumNegativeBits = 0;
2964 unsigned NumPositiveBits = 0;
2965
2966 // Keep track of whether all elements have type int.
2967 bool AllElementsInt = true;
2968
Reid Spencer5f016e22007-07-11 17:01:13 +00002969 EnumConstantDecl *EltList = 0;
2970 for (unsigned i = 0; i != NumElements; ++i) {
2971 EnumConstantDecl *ECD =
2972 cast_or_null<EnumConstantDecl>(static_cast<Decl*>(Elements[i]));
2973 if (!ECD) continue; // Already issued a diagnostic.
Chris Lattner211a30e2007-08-28 05:27:00 +00002974
2975 // If the enum value doesn't fit in an int, emit an extension warning.
Chris Lattner211a30e2007-08-28 05:27:00 +00002976 const llvm::APSInt &InitVal = ECD->getInitVal();
Chris Lattnera73349d2008-02-26 00:33:57 +00002977 assert(InitVal.getBitWidth() >= IntWidth &&
2978 "Should have promoted value to int");
Chris Lattner211a30e2007-08-28 05:27:00 +00002979 if (InitVal.getBitWidth() > IntWidth) {
2980 llvm::APSInt V(InitVal);
2981 V.trunc(IntWidth);
2982 V.extend(InitVal.getBitWidth());
2983 if (V != InitVal)
Chris Lattnerf3a41af2008-11-20 06:38:18 +00002984 Diag(ECD->getLocation(), diag::ext_enum_value_not_int)
2985 << InitVal.toString(10);
Chris Lattner211a30e2007-08-28 05:27:00 +00002986 }
Chris Lattnerac609682007-08-28 06:15:15 +00002987
2988 // Keep track of the size of positive and negative values.
Chris Lattnera73349d2008-02-26 00:33:57 +00002989 if (InitVal.isUnsigned() || InitVal.isNonNegative())
Chris Lattner21dd8212008-01-14 21:47:29 +00002990 NumPositiveBits = std::max(NumPositiveBits,
2991 (unsigned)InitVal.getActiveBits());
Chris Lattnerac609682007-08-28 06:15:15 +00002992 else
Chris Lattner21dd8212008-01-14 21:47:29 +00002993 NumNegativeBits = std::max(NumNegativeBits,
2994 (unsigned)InitVal.getMinSignedBits());
Reid Spencer5f016e22007-07-11 17:01:13 +00002995
Chris Lattnerac609682007-08-28 06:15:15 +00002996 // Keep track of whether every enum element has type int (very commmon).
2997 if (AllElementsInt)
2998 AllElementsInt = ECD->getType() == Context.IntTy;
2999
Reid Spencer5f016e22007-07-11 17:01:13 +00003000 ECD->setNextDeclarator(EltList);
3001 EltList = ECD;
3002 }
3003
Chris Lattnerac609682007-08-28 06:15:15 +00003004 // Figure out the type that should be used for this enum.
3005 // FIXME: Support attribute(packed) on enums and -fshort-enums.
3006 QualType BestType;
Chris Lattnerb7f6e082007-08-29 17:31:48 +00003007 unsigned BestWidth;
Chris Lattnerac609682007-08-28 06:15:15 +00003008
3009 if (NumNegativeBits) {
3010 // If there is a negative value, figure out the smallest integer type (of
3011 // int/long/longlong) that fits.
Chris Lattnerb7f6e082007-08-29 17:31:48 +00003012 if (NumNegativeBits <= IntWidth && NumPositiveBits < IntWidth) {
Chris Lattnerac609682007-08-28 06:15:15 +00003013 BestType = Context.IntTy;
Chris Lattnerb7f6e082007-08-29 17:31:48 +00003014 BestWidth = IntWidth;
3015 } else {
Chris Lattner98be4942008-03-05 18:54:05 +00003016 BestWidth = Context.Target.getLongWidth();
Ted Kremenek9c728dc2007-12-12 22:39:36 +00003017
Chris Lattnerb7f6e082007-08-29 17:31:48 +00003018 if (NumNegativeBits <= BestWidth && NumPositiveBits < BestWidth)
Chris Lattnerac609682007-08-28 06:15:15 +00003019 BestType = Context.LongTy;
3020 else {
Chris Lattner98be4942008-03-05 18:54:05 +00003021 BestWidth = Context.Target.getLongLongWidth();
Ted Kremenek9c728dc2007-12-12 22:39:36 +00003022
Chris Lattnerb7f6e082007-08-29 17:31:48 +00003023 if (NumNegativeBits > BestWidth || NumPositiveBits >= BestWidth)
Chris Lattnerac609682007-08-28 06:15:15 +00003024 Diag(Enum->getLocation(), diag::warn_enum_too_large);
3025 BestType = Context.LongLongTy;
3026 }
3027 }
3028 } else {
3029 // If there is no negative value, figure out which of uint, ulong, ulonglong
3030 // fits.
Chris Lattnerb7f6e082007-08-29 17:31:48 +00003031 if (NumPositiveBits <= IntWidth) {
Chris Lattnerac609682007-08-28 06:15:15 +00003032 BestType = Context.UnsignedIntTy;
Chris Lattnerb7f6e082007-08-29 17:31:48 +00003033 BestWidth = IntWidth;
3034 } else if (NumPositiveBits <=
Chris Lattner98be4942008-03-05 18:54:05 +00003035 (BestWidth = Context.Target.getLongWidth())) {
Chris Lattnerac609682007-08-28 06:15:15 +00003036 BestType = Context.UnsignedLongTy;
Chris Lattner98be4942008-03-05 18:54:05 +00003037 } else {
3038 BestWidth = Context.Target.getLongLongWidth();
Chris Lattnerb7f6e082007-08-29 17:31:48 +00003039 assert(NumPositiveBits <= BestWidth &&
Chris Lattnerac609682007-08-28 06:15:15 +00003040 "How could an initializer get larger than ULL?");
3041 BestType = Context.UnsignedLongLongTy;
3042 }
3043 }
3044
Chris Lattnerb7f6e082007-08-29 17:31:48 +00003045 // Loop over all of the enumerator constants, changing their types to match
3046 // the type of the enum if needed.
3047 for (unsigned i = 0; i != NumElements; ++i) {
3048 EnumConstantDecl *ECD =
3049 cast_or_null<EnumConstantDecl>(static_cast<Decl*>(Elements[i]));
3050 if (!ECD) continue; // Already issued a diagnostic.
3051
3052 // Standard C says the enumerators have int type, but we allow, as an
3053 // extension, the enumerators to be larger than int size. If each
3054 // enumerator value fits in an int, type it as an int, otherwise type it the
3055 // same as the enumerator decl itself. This means that in "enum { X = 1U }"
3056 // that X has type 'int', not 'unsigned'.
Chris Lattnera73349d2008-02-26 00:33:57 +00003057 if (ECD->getType() == Context.IntTy) {
3058 // Make sure the init value is signed.
3059 llvm::APSInt IV = ECD->getInitVal();
3060 IV.setIsSigned(true);
3061 ECD->setInitVal(IV);
Chris Lattnerb7f6e082007-08-29 17:31:48 +00003062 continue; // Already int type.
Chris Lattnera73349d2008-02-26 00:33:57 +00003063 }
Chris Lattnerb7f6e082007-08-29 17:31:48 +00003064
3065 // Determine whether the value fits into an int.
3066 llvm::APSInt InitVal = ECD->getInitVal();
3067 bool FitsInInt;
3068 if (InitVal.isUnsigned() || !InitVal.isNegative())
3069 FitsInInt = InitVal.getActiveBits() < IntWidth;
3070 else
3071 FitsInInt = InitVal.getMinSignedBits() <= IntWidth;
3072
3073 // If it fits into an integer type, force it. Otherwise force it to match
3074 // the enum decl type.
3075 QualType NewTy;
3076 unsigned NewWidth;
3077 bool NewSign;
3078 if (FitsInInt) {
3079 NewTy = Context.IntTy;
3080 NewWidth = IntWidth;
3081 NewSign = true;
3082 } else if (ECD->getType() == BestType) {
3083 // Already the right type!
3084 continue;
3085 } else {
3086 NewTy = BestType;
3087 NewWidth = BestWidth;
3088 NewSign = BestType->isSignedIntegerType();
3089 }
3090
3091 // Adjust the APSInt value.
3092 InitVal.extOrTrunc(NewWidth);
3093 InitVal.setIsSigned(NewSign);
3094 ECD->setInitVal(InitVal);
3095
3096 // Adjust the Expr initializer and type.
Douglas Gregoreb8f3062008-11-12 17:17:38 +00003097 ECD->setInitExpr(new ImplicitCastExpr(NewTy, ECD->getInitExpr(),
3098 /*isLvalue=*/false));
Chris Lattnerb7f6e082007-08-29 17:31:48 +00003099 ECD->setType(NewTy);
3100 }
Chris Lattnerac609682007-08-28 06:15:15 +00003101
Chris Lattnere00b18c2007-08-28 18:24:31 +00003102 Enum->defineElements(EltList, BestType);
Chris Lattnere1e79852008-02-06 00:51:33 +00003103 Consumer.HandleTagDeclDefinition(Enum);
Reid Spencer5f016e22007-07-11 17:01:13 +00003104}
3105
Anders Carlssondfab6cb2008-02-08 00:33:21 +00003106Sema::DeclTy *Sema::ActOnFileScopeAsmDecl(SourceLocation Loc,
3107 ExprTy *expr) {
3108 StringLiteral *AsmString = cast<StringLiteral>((Expr*)expr);
3109
Chris Lattner8e25d862008-03-16 00:16:02 +00003110 return FileScopeAsmDecl::Create(Context, Loc, AsmString);
Anders Carlssondfab6cb2008-02-08 00:33:21 +00003111}
3112
Chris Lattnerc6fdc342008-01-12 07:05:38 +00003113Sema::DeclTy* Sema::ActOnLinkageSpec(SourceLocation Loc,
Chris Lattnerc81c8142008-02-25 21:04:36 +00003114 SourceLocation LBrace,
3115 SourceLocation RBrace,
3116 const char *Lang,
3117 unsigned StrSize,
3118 DeclTy *D) {
Chris Lattnerc6fdc342008-01-12 07:05:38 +00003119 LinkageSpecDecl::LanguageIDs Language;
3120 Decl *dcl = static_cast<Decl *>(D);
3121 if (strncmp(Lang, "\"C\"", StrSize) == 0)
3122 Language = LinkageSpecDecl::lang_c;
3123 else if (strncmp(Lang, "\"C++\"", StrSize) == 0)
3124 Language = LinkageSpecDecl::lang_cxx;
3125 else {
3126 Diag(Loc, diag::err_bad_language);
3127 return 0;
3128 }
3129
3130 // FIXME: Add all the various semantics of linkage specifications
Chris Lattner8e25d862008-03-16 00:16:02 +00003131 return LinkageSpecDecl::Create(Context, Loc, Language, dcl);
Chris Lattnerc6fdc342008-01-12 07:05:38 +00003132}
Daniel Dunbar4cde9272008-10-14 05:35:18 +00003133
3134void Sema::ActOnPragmaPack(PragmaPackKind Kind, IdentifierInfo *Name,
3135 ExprTy *alignment, SourceLocation PragmaLoc,
3136 SourceLocation LParenLoc, SourceLocation RParenLoc) {
3137 Expr *Alignment = static_cast<Expr *>(alignment);
3138
3139 // If specified then alignment must be a "small" power of two.
3140 unsigned AlignmentVal = 0;
3141 if (Alignment) {
3142 llvm::APSInt Val;
3143 if (!Alignment->isIntegerConstantExpr(Val, Context) ||
3144 !Val.isPowerOf2() ||
3145 Val.getZExtValue() > 16) {
3146 Diag(PragmaLoc, diag::warn_pragma_pack_invalid_alignment);
3147 delete Alignment;
3148 return; // Ignore
3149 }
3150
3151 AlignmentVal = (unsigned) Val.getZExtValue();
3152 }
3153
3154 switch (Kind) {
3155 case Action::PPK_Default: // pack([n])
3156 PackContext.setAlignment(AlignmentVal);
3157 break;
3158
3159 case Action::PPK_Show: // pack(show)
3160 // Show the current alignment, making sure to show the right value
3161 // for the default.
3162 AlignmentVal = PackContext.getAlignment();
3163 // FIXME: This should come from the target.
3164 if (AlignmentVal == 0)
3165 AlignmentVal = 8;
Chris Lattner83652232008-11-19 07:25:44 +00003166 Diag(PragmaLoc, diag::warn_pragma_pack_show) << AlignmentVal;
Daniel Dunbar4cde9272008-10-14 05:35:18 +00003167 break;
3168
3169 case Action::PPK_Push: // pack(push [, id] [, [n])
3170 PackContext.push(Name);
3171 // Set the new alignment if specified.
3172 if (Alignment)
3173 PackContext.setAlignment(AlignmentVal);
3174 break;
3175
3176 case Action::PPK_Pop: // pack(pop [, id] [, n])
3177 // MSDN, C/C++ Preprocessor Reference > Pragma Directives > pack:
3178 // "#pragma pack(pop, identifier, n) is undefined"
3179 if (Alignment && Name)
3180 Diag(PragmaLoc, diag::warn_pragma_pack_pop_identifer_and_alignment);
3181
3182 // Do the pop.
3183 if (!PackContext.pop(Name)) {
3184 // If a name was specified then failure indicates the name
3185 // wasn't found. Otherwise failure indicates the stack was
3186 // empty.
Chris Lattnerf3a41af2008-11-20 06:38:18 +00003187 Diag(PragmaLoc, diag::warn_pragma_pack_pop_failed)
3188 << (Name ? "no record matching name" : "stack empty");
Daniel Dunbar4cde9272008-10-14 05:35:18 +00003189
3190 // FIXME: Warn about popping named records as MSVC does.
3191 } else {
3192 // Pop succeeded, set the new alignment if specified.
3193 if (Alignment)
3194 PackContext.setAlignment(AlignmentVal);
3195 }
3196 break;
3197
3198 default:
3199 assert(0 && "Invalid #pragma pack kind.");
3200 }
3201}
3202
3203bool PragmaPackStack::pop(IdentifierInfo *Name) {
3204 if (Stack.empty())
3205 return false;
3206
3207 // If name is empty just pop top.
3208 if (!Name) {
3209 Alignment = Stack.back().first;
3210 Stack.pop_back();
3211 return true;
3212 }
3213
3214 // Otherwise, find the named record.
3215 for (unsigned i = Stack.size(); i != 0; ) {
3216 --i;
Daniel Dunbar06550392008-11-19 10:32:38 +00003217 if (Stack[i].second == Name) {
Daniel Dunbar4cde9272008-10-14 05:35:18 +00003218 // Found it, pop up to and including this record.
3219 Alignment = Stack[i].first;
3220 Stack.erase(Stack.begin() + i, Stack.end());
3221 return true;
3222 }
3223 }
3224
3225 return false;
3226}