blob: c3b130255b319bceea507b96aef3905fc3dc3c1d [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();
Reid Spencer5f016e22007-07-11 17:01:13 +0000329 Diag(OldD->getLocation(), diag::err_previous_definition);
330 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)
339 << New->getUnderlyingType().getAsString()
340 << Old->getUnderlyingType().getAsString();
Chris Lattner99cb9972008-07-25 18:44:27 +0000341 Diag(Old->getLocation(), diag::err_previous_definition);
342 return Old;
343 }
344
Eli Friedman54ecfce2008-06-11 06:20:39 +0000345 if (getLangOptions().Microsoft) return New;
346
Douglas Gregorbbe27432008-11-21 16:29:06 +0000347 // C++ [dcl.typedef]p2:
348 // In a given non-class scope, a typedef specifier can be used to
349 // redefine the name of any type declared in that scope to refer
350 // to the type to which it already refers.
351 if (getLangOptions().CPlusPlus && !isa<CXXRecordDecl>(CurContext))
352 return New;
353
354 // In C, redeclaration of a type is a constraint violation (6.7.2.3p1).
Steve Naroff4c49a6c2008-01-30 23:46:05 +0000355 // Apparently GCC, Intel, and Sun all silently ignore the redeclaration if
356 // *either* declaration is in a system header. The code below implements
357 // this adhoc compatibility rule. FIXME: The following code will not
358 // work properly when compiling ".i" files (containing preprocessed output).
Daniel Dunbar2fe09972008-09-12 18:10:20 +0000359 if (PP.getDiagnostics().getSuppressSystemWarnings()) {
360 SourceManager &SrcMgr = Context.getSourceManager();
361 if (SrcMgr.isInSystemHeader(Old->getLocation()))
362 return New;
363 if (SrcMgr.isInSystemHeader(New->getLocation()))
364 return New;
365 }
Eli Friedman54ecfce2008-06-11 06:20:39 +0000366
Chris Lattner08631c52008-11-23 21:45:46 +0000367 Diag(New->getLocation(), diag::err_redefinition) << New->getDeclName();
Ted Kremenek2d05c082008-05-23 21:28:18 +0000368 Diag(Old->getLocation(), diag::err_previous_definition);
Reid Spencer5f016e22007-07-11 17:01:13 +0000369 return New;
370}
371
Chris Lattner6b6b5372008-06-26 18:38:35 +0000372/// DeclhasAttr - returns true if decl Declaration already has the target
373/// attribute.
Chris Lattnerddee4232008-03-03 03:28:21 +0000374static bool DeclHasAttr(const Decl *decl, const Attr *target) {
375 for (const Attr *attr = decl->getAttrs(); attr; attr = attr->getNext())
376 if (attr->getKind() == target->getKind())
377 return true;
378
379 return false;
380}
381
382/// MergeAttributes - append attributes from the Old decl to the New one.
383static void MergeAttributes(Decl *New, Decl *Old) {
384 Attr *attr = const_cast<Attr*>(Old->getAttrs()), *tmp;
385
Chris Lattnerddee4232008-03-03 03:28:21 +0000386 while (attr) {
387 tmp = attr;
388 attr = attr->getNext();
389
390 if (!DeclHasAttr(New, tmp)) {
391 New->addAttr(tmp);
392 } else {
393 tmp->setNext(0);
394 delete(tmp);
395 }
396 }
Nuno Lopes9141bee2008-06-01 22:53:53 +0000397
398 Old->invalidateAttrs();
Chris Lattnerddee4232008-03-03 03:28:21 +0000399}
400
Chris Lattner04421082008-04-08 04:40:51 +0000401/// MergeFunctionDecl - We just parsed a function 'New' from
402/// declarator D which has the same name and scope as a previous
403/// declaration 'Old'. Figure out how to resolve this situation,
404/// merging decls or emitting diagnostics as appropriate.
Douglas Gregor8e9bebd2008-10-21 16:13:35 +0000405/// Redeclaration will be set true if this New is a redeclaration OldD.
406///
407/// In C++, New and Old must be declarations that are not
408/// overloaded. Use IsOverload to determine whether New and Old are
409/// overloaded, and to select the Old declaration that New should be
410/// merged with.
Douglas Gregorf0097952008-04-21 02:02:58 +0000411FunctionDecl *
412Sema::MergeFunctionDecl(FunctionDecl *New, Decl *OldD, bool &Redeclaration) {
Douglas Gregor8e9bebd2008-10-21 16:13:35 +0000413 assert(!isa<OverloadedFunctionDecl>(OldD) &&
414 "Cannot merge with an overloaded function declaration");
415
Douglas Gregorf0097952008-04-21 02:02:58 +0000416 Redeclaration = false;
Reid Spencer5f016e22007-07-11 17:01:13 +0000417 // Verify the old decl was also a function.
418 FunctionDecl *Old = dyn_cast<FunctionDecl>(OldD);
419 if (!Old) {
Chris Lattner5dc266a2008-11-20 06:13:02 +0000420 Diag(New->getLocation(), diag::err_redefinition_different_kind)
Chris Lattner08631c52008-11-23 21:45:46 +0000421 << New->getDeclName();
Reid Spencer5f016e22007-07-11 17:01:13 +0000422 Diag(OldD->getLocation(), diag::err_previous_definition);
423 return New;
424 }
Douglas Gregor8e9bebd2008-10-21 16:13:35 +0000425
426 // Determine whether the previous declaration was a definition,
427 // implicit declaration, or a declaration.
428 diag::kind PrevDiag;
429 if (Old->isThisDeclarationADefinition())
430 PrevDiag = diag::err_previous_definition;
431 else if (Old->isImplicit())
432 PrevDiag = diag::err_previous_implicit_declaration;
433 else
434 PrevDiag = diag::err_previous_declaration;
Chris Lattner04421082008-04-08 04:40:51 +0000435
Chris Lattner8bcfc5b2008-04-06 23:10:54 +0000436 QualType OldQType = Context.getCanonicalType(Old->getType());
437 QualType NewQType = Context.getCanonicalType(New->getType());
Chris Lattner55196442007-11-20 19:04:50 +0000438
Douglas Gregor8e9bebd2008-10-21 16:13:35 +0000439 if (getLangOptions().CPlusPlus) {
440 // (C++98 13.1p2):
441 // Certain function declarations cannot be overloaded:
442 // -- Function declarations that differ only in the return type
443 // cannot be overloaded.
444 QualType OldReturnType
445 = cast<FunctionType>(OldQType.getTypePtr())->getResultType();
446 QualType NewReturnType
447 = cast<FunctionType>(NewQType.getTypePtr())->getResultType();
448 if (OldReturnType != NewReturnType) {
449 Diag(New->getLocation(), diag::err_ovl_diff_return_type);
450 Diag(Old->getLocation(), PrevDiag);
451 return New;
452 }
453
454 const CXXMethodDecl* OldMethod = dyn_cast<CXXMethodDecl>(Old);
455 const CXXMethodDecl* NewMethod = dyn_cast<CXXMethodDecl>(New);
456 if (OldMethod && NewMethod) {
457 // -- Member function declarations with the same name and the
458 // same parameter types cannot be overloaded if any of them
459 // is a static member function declaration.
460 if (OldMethod->isStatic() || NewMethod->isStatic()) {
461 Diag(New->getLocation(), diag::err_ovl_static_nonstatic_member);
462 Diag(Old->getLocation(), PrevDiag);
463 return New;
464 }
465 }
466
467 // (C++98 8.3.5p3):
468 // All declarations for a function shall agree exactly in both the
469 // return type and the parameter-type-list.
470 if (OldQType == NewQType) {
471 // We have a redeclaration.
472 MergeAttributes(New, Old);
473 Redeclaration = true;
474 return MergeCXXFunctionDecl(New, Old);
475 }
476
477 // Fall through for conflicting redeclarations and redefinitions.
Douglas Gregorf0097952008-04-21 02:02:58 +0000478 }
Chris Lattner04421082008-04-08 04:40:51 +0000479
480 // C: Function types need to be compatible, not identical. This handles
Steve Naroffadbbd0c2008-01-14 20:51:29 +0000481 // duplicate function decls like "void f(int); void f(enum X);" properly.
Chris Lattner04421082008-04-08 04:40:51 +0000482 if (!getLangOptions().CPlusPlus &&
Eli Friedman3d815e72008-08-22 00:56:42 +0000483 Context.typesAreCompatible(OldQType, NewQType)) {
Douglas Gregorf0097952008-04-21 02:02:58 +0000484 MergeAttributes(New, Old);
485 Redeclaration = true;
Steve Naroffadbbd0c2008-01-14 20:51:29 +0000486 return New;
Chris Lattner04421082008-04-08 04:40:51 +0000487 }
Chris Lattnere3995fe2007-11-06 06:07:26 +0000488
Steve Naroff837618c2008-01-16 15:01:34 +0000489 // A function that has already been declared has been redeclared or defined
490 // with a different type- show appropriate diagnostic
Steve Naroff837618c2008-01-16 15:01:34 +0000491
Reid Spencer5f016e22007-07-11 17:01:13 +0000492 // TODO: CHECK FOR CONFLICTS, multiple decls with same name in one scope.
493 // TODO: This is totally simplistic. It should handle merging functions
494 // together etc, merging extern int X; int X; ...
Chris Lattner5dc266a2008-11-20 06:13:02 +0000495 Diag(New->getLocation(), diag::err_conflicting_types) << New->getName();
Steve Naroff837618c2008-01-16 15:01:34 +0000496 Diag(Old->getLocation(), PrevDiag);
Reid Spencer5f016e22007-07-11 17:01:13 +0000497 return New;
498}
499
Steve Naroffff9eb1f2008-08-08 17:50:35 +0000500/// Predicate for C "tentative" external object definitions (C99 6.9.2).
Steve Naroffd4d46cd2008-08-10 15:28:06 +0000501static bool isTentativeDefinition(VarDecl *VD) {
Steve Naroffff9eb1f2008-08-08 17:50:35 +0000502 if (VD->isFileVarDecl())
503 return (!VD->getInit() &&
504 (VD->getStorageClass() == VarDecl::None ||
505 VD->getStorageClass() == VarDecl::Static));
506 return false;
507}
508
509/// CheckForFileScopedRedefinitions - Make sure we forgo redefinition errors
510/// when dealing with C "tentative" external object definitions (C99 6.9.2).
511void Sema::CheckForFileScopedRedefinitions(Scope *S, VarDecl *VD) {
512 bool VDIsTentative = isTentativeDefinition(VD);
Steve Narofff855e6f2008-08-10 15:20:13 +0000513 bool VDIsIncompleteArray = VD->getType()->isIncompleteArrayType();
Steve Naroffff9eb1f2008-08-08 17:50:35 +0000514
515 for (IdentifierResolver::iterator
516 I = IdResolver.begin(VD->getIdentifier(),
517 VD->getDeclContext(), false/*LookInParentCtx*/),
518 E = IdResolver.end(); I != E; ++I) {
Argyrios Kyrtzidis15a12d02008-09-09 21:18:04 +0000519 if (*I != VD && isDeclInScope(*I, VD->getDeclContext(), S)) {
Steve Naroffff9eb1f2008-08-08 17:50:35 +0000520 VarDecl *OldDecl = dyn_cast<VarDecl>(*I);
521
Steve Narofff855e6f2008-08-10 15:20:13 +0000522 // Handle the following case:
523 // int a[10];
524 // int a[]; - the code below makes sure we set the correct type.
525 // int a[11]; - this is an error, size isn't 10.
526 if (OldDecl && VDIsTentative && VDIsIncompleteArray &&
527 OldDecl->getType()->isConstantArrayType())
528 VD->setType(OldDecl->getType());
529
Steve Naroffff9eb1f2008-08-08 17:50:35 +0000530 // Check for "tentative" definitions. We can't accomplish this in
531 // MergeVarDecl since the initializer hasn't been attached.
532 if (!OldDecl || isTentativeDefinition(OldDecl) || VDIsTentative)
533 continue;
534
535 // Handle __private_extern__ just like extern.
536 if (OldDecl->getStorageClass() != VarDecl::Extern &&
537 OldDecl->getStorageClass() != VarDecl::PrivateExtern &&
538 VD->getStorageClass() != VarDecl::Extern &&
539 VD->getStorageClass() != VarDecl::PrivateExtern) {
Chris Lattner08631c52008-11-23 21:45:46 +0000540 Diag(VD->getLocation(), diag::err_redefinition) << VD->getDeclName();
Steve Naroffff9eb1f2008-08-08 17:50:35 +0000541 Diag(OldDecl->getLocation(), diag::err_previous_definition);
542 }
543 }
544 }
545}
546
Reid Spencer5f016e22007-07-11 17:01:13 +0000547/// MergeVarDecl - We just parsed a variable 'New' which has the same name
548/// and scope as a previous declaration 'Old'. Figure out how to resolve this
549/// situation, merging decls or emitting diagnostics as appropriate.
550///
Steve Naroffff9eb1f2008-08-08 17:50:35 +0000551/// Tentative definition rules (C99 6.9.2p2) are checked by
552/// FinalizeDeclaratorGroup. Unfortunately, we can't analyze tentative
553/// definitions here, since the initializer hasn't been attached.
Reid Spencer5f016e22007-07-11 17:01:13 +0000554///
Steve Naroffe8043c32008-04-01 23:04:06 +0000555VarDecl *Sema::MergeVarDecl(VarDecl *New, Decl *OldD) {
Reid Spencer5f016e22007-07-11 17:01:13 +0000556 // Verify the old decl was also a variable.
557 VarDecl *Old = dyn_cast<VarDecl>(OldD);
558 if (!Old) {
Chris Lattnerf3a41af2008-11-20 06:38:18 +0000559 Diag(New->getLocation(), diag::err_redefinition_different_kind)
Chris Lattner08631c52008-11-23 21:45:46 +0000560 << New->getDeclName();
Reid Spencer5f016e22007-07-11 17:01:13 +0000561 Diag(OldD->getLocation(), diag::err_previous_definition);
562 return New;
563 }
Chris Lattnerddee4232008-03-03 03:28:21 +0000564
565 MergeAttributes(New, Old);
566
Reid Spencer5f016e22007-07-11 17:01:13 +0000567 // Verify the types match.
Chris Lattner8bcfc5b2008-04-06 23:10:54 +0000568 QualType OldCType = Context.getCanonicalType(Old->getType());
569 QualType NewCType = Context.getCanonicalType(New->getType());
Steve Naroff907747b2008-08-09 16:04:40 +0000570 if (OldCType != NewCType && !Context.typesAreCompatible(OldCType, NewCType)) {
Chris Lattner08631c52008-11-23 21:45:46 +0000571 Diag(New->getLocation(), diag::err_redefinition) << New->getDeclName();
Reid Spencer5f016e22007-07-11 17:01:13 +0000572 Diag(Old->getLocation(), diag::err_previous_definition);
573 return New;
574 }
Steve Naroffb7b032e2008-01-30 00:44:01 +0000575 // C99 6.2.2p4: Check if we have a static decl followed by a non-static.
576 if (New->getStorageClass() == VarDecl::Static &&
577 (Old->getStorageClass() == VarDecl::None ||
578 Old->getStorageClass() == VarDecl::Extern)) {
Chris Lattnerf3a41af2008-11-20 06:38:18 +0000579 Diag(New->getLocation(), diag::err_static_non_static) << New->getName();
Steve Naroffb7b032e2008-01-30 00:44:01 +0000580 Diag(Old->getLocation(), diag::err_previous_definition);
581 return New;
582 }
583 // C99 6.2.2p4: Check if we have a non-static decl followed by a static.
584 if (New->getStorageClass() != VarDecl::Static &&
585 Old->getStorageClass() == VarDecl::Static) {
Chris Lattnerf3a41af2008-11-20 06:38:18 +0000586 Diag(New->getLocation(), diag::err_non_static_static) << New->getName();
Steve Naroffb7b032e2008-01-30 00:44:01 +0000587 Diag(Old->getLocation(), diag::err_previous_definition);
588 return New;
589 }
Steve Naroff094cefb2008-09-17 14:05:40 +0000590 // Variables with external linkage are analyzed in FinalizeDeclaratorGroup.
591 if (New->getStorageClass() != VarDecl::Extern && !New->isFileVarDecl()) {
Chris Lattner08631c52008-11-23 21:45:46 +0000592 Diag(New->getLocation(), diag::err_redefinition) << New->getDeclName();
Reid Spencer5f016e22007-07-11 17:01:13 +0000593 Diag(Old->getLocation(), diag::err_previous_definition);
594 }
595 return New;
596}
597
Chris Lattner04421082008-04-08 04:40:51 +0000598/// CheckParmsForFunctionDef - Check that the parameters of the given
599/// function are appropriate for the definition of a function. This
600/// takes care of any checks that cannot be performed on the
601/// declaration itself, e.g., that the types of each of the function
602/// parameters are complete.
603bool Sema::CheckParmsForFunctionDef(FunctionDecl *FD) {
604 bool HasInvalidParm = false;
605 for (unsigned p = 0, NumParams = FD->getNumParams(); p < NumParams; ++p) {
606 ParmVarDecl *Param = FD->getParamDecl(p);
607
608 // C99 6.7.5.3p4: the parameters in a parameter type list in a
609 // function declarator that is part of a function definition of
610 // that function shall not have incomplete type.
611 if (Param->getType()->isIncompleteType() &&
612 !Param->isInvalidDecl()) {
Chris Lattnerf3a41af2008-11-20 06:38:18 +0000613 Diag(Param->getLocation(), diag::err_typecheck_decl_incomplete_type)
614 << Param->getType().getAsString();
Chris Lattner04421082008-04-08 04:40:51 +0000615 Param->setInvalidDecl();
616 HasInvalidParm = true;
617 }
618 }
619
620 return HasInvalidParm;
621}
622
Reid Spencer5f016e22007-07-11 17:01:13 +0000623/// ParsedFreeStandingDeclSpec - This method is invoked when a declspec with
624/// no declarator (e.g. "struct foo;") is parsed.
625Sema::DeclTy *Sema::ParsedFreeStandingDeclSpec(Scope *S, DeclSpec &DS) {
626 // TODO: emit error on 'int;' or 'const enum foo;'.
627 // TODO: emit error on 'typedef int;'
628 // if (!DS.isMissingDeclaratorOk()) Diag(...);
629
Steve Naroff92199282007-11-17 21:37:36 +0000630 return dyn_cast_or_null<TagDecl>(static_cast<Decl *>(DS.getTypeRep()));
Reid Spencer5f016e22007-07-11 17:01:13 +0000631}
632
Steve Naroffd0091aa2008-01-10 22:15:12 +0000633bool Sema::CheckSingleInitializer(Expr *&Init, QualType DeclType) {
Steve Narofff0090632007-09-02 02:04:30 +0000634 // Get the type before calling CheckSingleAssignmentConstraints(), since
635 // it can promote the expression.
Chris Lattner5cf216b2008-01-04 18:04:52 +0000636 QualType InitType = Init->getType();
Steve Narofff0090632007-09-02 02:04:30 +0000637
Chris Lattner5cf216b2008-01-04 18:04:52 +0000638 AssignConvertType ConvTy = CheckSingleAssignmentConstraints(DeclType, Init);
639 return DiagnoseAssignmentResult(ConvTy, Init->getLocStart(), DeclType,
640 InitType, Init, "initializing");
Steve Narofff0090632007-09-02 02:04:30 +0000641}
642
Steve Naroffa49e1fa2008-01-22 00:55:40 +0000643bool Sema::CheckStringLiteralInit(StringLiteral *strLiteral, QualType &DeclT) {
Chris Lattnerc63a1f22008-08-04 07:31:14 +0000644 const ArrayType *AT = Context.getAsArrayType(DeclT);
645
646 if (const IncompleteArrayType *IAT = dyn_cast<IncompleteArrayType>(AT)) {
Steve Naroffa49e1fa2008-01-22 00:55:40 +0000647 // C99 6.7.8p14. We have an array of character type with unknown size
648 // being initialized to a string literal.
649 llvm::APSInt ConstVal(32);
650 ConstVal = strLiteral->getByteLength() + 1;
651 // Return a new array type (C99 6.7.8p22).
Eli Friedmanc5773c42008-02-15 18:16:39 +0000652 DeclT = Context.getConstantArrayType(IAT->getElementType(), ConstVal,
Steve Naroffa49e1fa2008-01-22 00:55:40 +0000653 ArrayType::Normal, 0);
Chris Lattnerc63a1f22008-08-04 07:31:14 +0000654 } else {
655 const ConstantArrayType *CAT = cast<ConstantArrayType>(AT);
Steve Naroffa49e1fa2008-01-22 00:55:40 +0000656 // C99 6.7.8p14. We have an array of character type with known size.
Chris Lattnerc63a1f22008-08-04 07:31:14 +0000657 // FIXME: Avoid truncation for 64-bit length strings.
658 if (strLiteral->getByteLength() > (unsigned)CAT->getSize().getZExtValue())
Steve Naroffa49e1fa2008-01-22 00:55:40 +0000659 Diag(strLiteral->getSourceRange().getBegin(),
Chris Lattnerdcd5ef12008-11-19 05:27:50 +0000660 diag::warn_initializer_string_for_char_array_too_long)
661 << strLiteral->getSourceRange();
Steve Naroffa49e1fa2008-01-22 00:55:40 +0000662 }
663 // Set type from "char *" to "constant array of char".
664 strLiteral->setType(DeclT);
665 // For now, we always return false (meaning success).
666 return false;
667}
668
669StringLiteral *Sema::IsStringLiteralInit(Expr *Init, QualType DeclType) {
Chris Lattnerc63a1f22008-08-04 07:31:14 +0000670 const ArrayType *AT = Context.getAsArrayType(DeclType);
Steve Naroffa9960332008-01-25 00:51:06 +0000671 if (AT && AT->getElementType()->isCharType()) {
672 return dyn_cast<StringLiteral>(Init);
673 }
Steve Naroffa49e1fa2008-01-22 00:55:40 +0000674 return 0;
675}
676
Douglas Gregorf03d7c72008-11-05 15:29:30 +0000677bool Sema::CheckInitializerTypes(Expr *&Init, QualType &DeclType,
678 SourceLocation InitLoc,
679 std::string InitEntity) {
Douglas Gregor27c8dc02008-10-29 00:13:59 +0000680 // C++ [dcl.init.ref]p1:
681 // A variable declared to be a T&, that is “reference to type T”
682 // (8.3.2), shall be initialized by an object, or function, of
683 // type T or by an object that can be converted into a T.
684 if (DeclType->isReferenceType())
685 return CheckReferenceInit(Init, DeclType);
686
Steve Naroffca107302008-01-21 23:53:58 +0000687 // C99 6.7.8p3: The type of the entity to be initialized shall be an array
688 // of unknown size ("[]") or an object type that is not a variable array type.
Chris Lattnerc63a1f22008-08-04 07:31:14 +0000689 if (const VariableArrayType *VAT = Context.getAsVariableArrayType(DeclType))
Chris Lattnerdcd5ef12008-11-19 05:27:50 +0000690 return Diag(InitLoc, diag::err_variable_object_no_init)
691 << VAT->getSizeExpr()->getSourceRange();
Steve Naroffca107302008-01-21 23:53:58 +0000692
Steve Naroff2fdc3742007-12-10 22:44:33 +0000693 InitListExpr *InitList = dyn_cast<InitListExpr>(Init);
694 if (!InitList) {
Steve Naroffa49e1fa2008-01-22 00:55:40 +0000695 // FIXME: Handle wide strings
696 if (StringLiteral *strLiteral = IsStringLiteralInit(Init, DeclType))
697 return CheckStringLiteralInit(strLiteral, DeclType);
Eli Friedmana312ce22008-02-08 00:48:24 +0000698
Douglas Gregorf03d7c72008-11-05 15:29:30 +0000699 // C++ [dcl.init]p14:
700 // -- If the destination type is a (possibly cv-qualified) class
701 // type:
702 if (getLangOptions().CPlusPlus && DeclType->isRecordType()) {
703 QualType DeclTypeC = Context.getCanonicalType(DeclType);
704 QualType InitTypeC = Context.getCanonicalType(Init->getType());
705
706 // -- If the initialization is direct-initialization, or if it is
707 // copy-initialization where the cv-unqualified version of the
708 // source type is the same class as, or a derived class of, the
709 // class of the destination, constructors are considered.
710 if ((DeclTypeC.getUnqualifiedType() == InitTypeC.getUnqualifiedType()) ||
711 IsDerivedFrom(InitTypeC, DeclTypeC)) {
712 CXXConstructorDecl *Constructor
713 = PerformInitializationByConstructor(DeclType, &Init, 1,
714 InitLoc, Init->getSourceRange(),
715 InitEntity, IK_Copy);
716 return Constructor == 0;
717 }
718
719 // -- Otherwise (i.e., for the remaining copy-initialization
720 // cases), user-defined conversion sequences that can
721 // convert from the source type to the destination type or
722 // (when a conversion function is used) to a derived class
723 // thereof are enumerated as described in 13.3.1.4, and the
724 // best one is chosen through overload resolution
725 // (13.3). If the conversion cannot be done or is
726 // ambiguous, the initialization is ill-formed. The
727 // function selected is called with the initializer
728 // expression as its argument; if the function is a
729 // constructor, the call initializes a temporary of the
730 // destination type.
731 // FIXME: We're pretending to do copy elision here; return to
732 // this when we have ASTs for such things.
Chris Lattnerc9c7c4e2008-11-18 22:52:51 +0000733 if (!PerformImplicitConversion(Init, DeclType))
Douglas Gregorf03d7c72008-11-05 15:29:30 +0000734 return false;
Chris Lattnerc9c7c4e2008-11-18 22:52:51 +0000735
736 return Diag(InitLoc, diag::err_typecheck_convert_incompatible)
737 << DeclType.getAsString() << InitEntity << "initializing"
738 << Init->getSourceRange();
Douglas Gregorf03d7c72008-11-05 15:29:30 +0000739 }
740
Steve Naroff1ac6fdd2008-09-29 20:07:05 +0000741 // C99 6.7.8p16.
Eli Friedmana312ce22008-02-08 00:48:24 +0000742 if (DeclType->isArrayType())
Chris Lattnerdcd5ef12008-11-19 05:27:50 +0000743 return Diag(Init->getLocStart(), diag::err_array_init_list_required)
744 << Init->getSourceRange();
Eli Friedmana312ce22008-02-08 00:48:24 +0000745
Steve Naroffd0091aa2008-01-10 22:15:12 +0000746 return CheckSingleInitializer(Init, DeclType);
Douglas Gregor64bffa92008-11-05 16:20:31 +0000747 } else if (getLangOptions().CPlusPlus) {
748 // C++ [dcl.init]p14:
749 // [...] If the class is an aggregate (8.5.1), and the initializer
750 // is a brace-enclosed list, see 8.5.1.
751 //
752 // Note: 8.5.1 is handled below; here, we diagnose the case where
753 // we have an initializer list and a destination type that is not
754 // an aggregate.
755 // FIXME: In C++0x, this is yet another form of initialization.
756 if (const RecordType *ClassRec = DeclType->getAsRecordType()) {
757 const CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(ClassRec->getDecl());
758 if (!ClassDecl->isAggregate())
Chris Lattnerdcd5ef12008-11-19 05:27:50 +0000759 return Diag(InitLoc, diag::err_init_non_aggr_init_list)
760 << DeclType.getAsString() << Init->getSourceRange();
Douglas Gregor64bffa92008-11-05 16:20:31 +0000761 }
Steve Naroff2fdc3742007-12-10 22:44:33 +0000762 }
Eli Friedmane6f058f2008-06-06 19:40:52 +0000763
Steve Naroff0cca7492008-05-01 22:18:59 +0000764 InitListChecker CheckInitList(this, InitList, DeclType);
765 return CheckInitList.HadError();
Steve Narofff0090632007-09-02 02:04:30 +0000766}
767
Douglas Gregor10bd3682008-11-17 22:58:34 +0000768/// GetNameForDeclarator - Determine the full declaration name for the
769/// given Declarator.
770DeclarationName Sema::GetNameForDeclarator(Declarator &D) {
771 switch (D.getKind()) {
772 case Declarator::DK_Abstract:
773 assert(D.getIdentifier() == 0 && "abstract declarators have no name");
774 return DeclarationName();
775
776 case Declarator::DK_Normal:
777 assert (D.getIdentifier() != 0 && "normal declarators have an identifier");
778 return DeclarationName(D.getIdentifier());
779
780 case Declarator::DK_Constructor: {
781 QualType Ty = Context.getTypeDeclType((TypeDecl *)D.getDeclaratorIdType());
782 Ty = Context.getCanonicalType(Ty);
783 return Context.DeclarationNames.getCXXConstructorName(Ty);
784 }
785
786 case Declarator::DK_Destructor: {
787 QualType Ty = Context.getTypeDeclType((TypeDecl *)D.getDeclaratorIdType());
788 Ty = Context.getCanonicalType(Ty);
789 return Context.DeclarationNames.getCXXDestructorName(Ty);
790 }
791
792 case Declarator::DK_Conversion: {
793 QualType Ty = QualType::getFromOpaquePtr(D.getDeclaratorIdType());
794 Ty = Context.getCanonicalType(Ty);
795 return Context.DeclarationNames.getCXXConversionFunctionName(Ty);
796 }
Douglas Gregore94ca9e42008-11-18 14:39:36 +0000797
798 case Declarator::DK_Operator:
799 assert(D.getIdentifier() == 0 && "operator names have no identifier");
800 return Context.DeclarationNames.getCXXOperatorName(
801 D.getOverloadedOperator());
Douglas Gregor10bd3682008-11-17 22:58:34 +0000802 }
803
804 assert(false && "Unknown name kind");
805 return DeclarationName();
806}
807
Fariborz Jahanian306d68f2007-11-08 23:49:49 +0000808Sema::DeclTy *
Daniel Dunbar914701e2008-08-05 16:28:08 +0000809Sema::ActOnDeclarator(Scope *S, Declarator &D, DeclTy *lastDecl) {
Steve Naroff94745042007-09-13 23:52:58 +0000810 ScopedDecl *LastDeclarator = dyn_cast_or_null<ScopedDecl>((Decl *)lastDecl);
Douglas Gregor10bd3682008-11-17 22:58:34 +0000811 DeclarationName Name = GetNameForDeclarator(D);
812
Chris Lattnere80a59c2007-07-25 00:24:17 +0000813 // All of these full declarators require an identifier. If it doesn't have
814 // one, the ParsedFreeStandingDeclSpec action should be used.
Douglas Gregor10bd3682008-11-17 22:58:34 +0000815 if (!Name) {
Chris Lattner1f6f54b2008-11-11 06:13:16 +0000816 if (!D.getInvalidType()) // Reject this if we think it is valid.
817 Diag(D.getDeclSpec().getSourceRange().getBegin(),
Chris Lattnerfa25bbb2008-11-19 05:08:23 +0000818 diag::err_declarator_need_ident)
819 << D.getDeclSpec().getSourceRange() << D.getSourceRange();
Chris Lattnere80a59c2007-07-25 00:24:17 +0000820 return 0;
821 }
822
Chris Lattner31e05722007-08-26 06:24:45 +0000823 // The scope passed in may not be a decl scope. Zip up the scope tree until
824 // we find one that is.
825 while ((S->getFlags() & Scope::DeclScope) == 0)
826 S = S->getParent();
827
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +0000828 DeclContext *DC;
829 Decl *PrevDecl;
Steve Naroffc752d042007-09-13 18:10:37 +0000830 ScopedDecl *New;
Steve Naroff5912a352007-08-28 20:14:24 +0000831 bool InvalidDecl = false;
Douglas Gregor2ce52f32008-04-13 21:07:44 +0000832
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +0000833 // See if this is a redefinition of a variable in the same scope.
834 if (!D.getCXXScopeSpec().isSet()) {
835 DC = CurContext;
Douglas Gregor10bd3682008-11-17 22:58:34 +0000836 PrevDecl = LookupDecl(Name, Decl::IDNS_Ordinary, S);
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +0000837 } else { // Something like "int foo::x;"
838 DC = static_cast<DeclContext*>(D.getCXXScopeSpec().getScopeRep());
Douglas Gregor10bd3682008-11-17 22:58:34 +0000839 PrevDecl = LookupDecl(Name, Decl::IDNS_Ordinary, S, DC);
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +0000840
841 // C++ 7.3.1.2p2:
842 // Members (including explicit specializations of templates) of a named
843 // namespace can also be defined outside that namespace by explicit
844 // qualification of the name being defined, provided that the entity being
845 // defined was already declared in the namespace and the definition appears
846 // after the point of declaration in a namespace that encloses the
847 // declarations namespace.
848 //
849 if (PrevDecl == 0) {
850 // No previous declaration in the qualifying scope.
Chris Lattnerd3a94e22008-11-20 06:06:08 +0000851 Diag(D.getIdentifierLoc(), diag::err_typecheck_no_member)
Chris Lattner08631c52008-11-23 21:45:46 +0000852 << Name << D.getCXXScopeSpec().getRange();
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +0000853 } else if (!CurContext->Encloses(DC)) {
854 // The qualifying scope doesn't enclose the original declaration.
855 // Emit diagnostic based on current scope.
856 SourceLocation L = D.getIdentifierLoc();
857 SourceRange R = D.getCXXScopeSpec().getRange();
858 if (isa<FunctionDecl>(CurContext)) {
Chris Lattner011bb4e2008-11-23 20:28:15 +0000859 Diag(L, diag::err_invalid_declarator_in_function) << Name << R;
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +0000860 } else {
Chris Lattner011bb4e2008-11-23 20:28:15 +0000861 Diag(L, diag::err_invalid_declarator_scope)
Chris Lattnerfa25bbb2008-11-19 05:08:23 +0000862 << Name.getAsString() << cast<NamedDecl>(DC)->getName() << R;
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +0000863 }
864 }
865 }
866
Douglas Gregor2ce52f32008-04-13 21:07:44 +0000867 // In C++, the previous declaration we find might be a tag type
868 // (class or enum). In this case, the new declaration will hide the
869 // tag type.
870 if (PrevDecl && PrevDecl->getIdentifierNamespace() == Decl::IDNS_Tag)
871 PrevDecl = 0;
872
Chris Lattner41af0932007-11-14 06:34:38 +0000873 QualType R = GetTypeForDeclarator(D, S);
874 assert(!R.isNull() && "GetTypeForDeclarator() returned null type");
875
Reid Spencer5f016e22007-07-11 17:01:13 +0000876 if (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_typedef) {
Douglas Gregor6d6eb572008-05-07 04:49:29 +0000877 // Check that there are no default arguments (C++ only).
878 if (getLangOptions().CPlusPlus)
879 CheckExtraCXXDefaultArguments(D);
880
Chris Lattner41af0932007-11-14 06:34:38 +0000881 TypedefDecl *NewTD = ParseTypedefDecl(S, D, R, LastDeclarator);
Reid Spencer5f016e22007-07-11 17:01:13 +0000882 if (!NewTD) return 0;
883
884 // Handle attributes prior to checking for duplicates in MergeVarDecl
Chris Lattner3ff30c82008-06-29 00:02:00 +0000885 ProcessDeclAttributes(NewTD, D);
Steve Naroffffce4d52008-01-09 23:34:55 +0000886 // Merge the decl with the existing one if appropriate. If the decl is
887 // in an outer scope, it isn't the same thing.
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +0000888 if (PrevDecl && isDeclInScope(PrevDecl, DC, S)) {
Reid Spencer5f016e22007-07-11 17:01:13 +0000889 NewTD = MergeTypeDefDecl(NewTD, PrevDecl);
890 if (NewTD == 0) return 0;
891 }
892 New = NewTD;
Argyrios Kyrtzidis00bc6452008-05-09 23:39:43 +0000893 if (S->getFnParent() == 0) {
Reid Spencer5f016e22007-07-11 17:01:13 +0000894 // C99 6.7.7p2: If a typedef name specifies a variably modified type
895 // then it shall have block scope.
Eli Friedman9db13972008-02-15 12:53:51 +0000896 if (NewTD->getUnderlyingType()->isVariablyModifiedType()) {
897 // FIXME: Diagnostic needs to be fixed.
898 Diag(D.getIdentifierLoc(), diag::err_typecheck_illegal_vla);
Steve Naroffd7444aa2007-08-31 17:20:07 +0000899 InvalidDecl = true;
Reid Spencer5f016e22007-07-11 17:01:13 +0000900 }
901 }
Chris Lattner41af0932007-11-14 06:34:38 +0000902 } else if (R.getTypePtr()->isFunctionType()) {
Chris Lattner271f1a62007-09-27 15:15:46 +0000903 FunctionDecl::StorageClass SC = FunctionDecl::None;
Reid Spencer5f016e22007-07-11 17:01:13 +0000904 switch (D.getDeclSpec().getStorageClassSpec()) {
905 default: assert(0 && "Unknown storage class!");
906 case DeclSpec::SCS_auto:
907 case DeclSpec::SCS_register:
Sebastian Redl669d5d72008-11-14 23:42:31 +0000908 case DeclSpec::SCS_mutable:
Chris Lattnerf3a41af2008-11-20 06:38:18 +0000909 Diag(D.getIdentifierLoc(), diag::err_typecheck_sclass_func)
910 << R.getAsString();
Steve Naroff5912a352007-08-28 20:14:24 +0000911 InvalidDecl = true;
912 break;
Reid Spencer5f016e22007-07-11 17:01:13 +0000913 case DeclSpec::SCS_unspecified: SC = FunctionDecl::None; break;
914 case DeclSpec::SCS_extern: SC = FunctionDecl::Extern; break;
915 case DeclSpec::SCS_static: SC = FunctionDecl::Static; break;
Steve Naroff7dd0bd42008-01-28 21:57:15 +0000916 case DeclSpec::SCS_private_extern: SC = FunctionDecl::PrivateExtern;break;
Reid Spencer5f016e22007-07-11 17:01:13 +0000917 }
918
Chris Lattnera98e58d2008-03-15 21:24:04 +0000919 bool isInline = D.getDeclSpec().isInlineSpecified();
Douglas Gregor42a552f2008-11-05 20:51:48 +0000920 // bool isVirtual = D.getDeclSpec().isVirtualSpecified();
Douglas Gregorb48fe382008-10-31 09:07:45 +0000921 bool isExplicit = D.getDeclSpec().isExplicitSpecified();
922
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000923 FunctionDecl *NewFD;
Douglas Gregor42a552f2008-11-05 20:51:48 +0000924 if (D.getKind() == Declarator::DK_Constructor) {
Douglas Gregorb48fe382008-10-31 09:07:45 +0000925 // This is a C++ constructor declaration.
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +0000926 assert(DC->isCXXRecord() &&
Douglas Gregorb48fe382008-10-31 09:07:45 +0000927 "Constructors can only be declared in a member context");
928
Douglas Gregor42a552f2008-11-05 20:51:48 +0000929 bool isInvalidDecl = CheckConstructorDeclarator(D, R, SC);
Douglas Gregorb48fe382008-10-31 09:07:45 +0000930
931 // Create the new declaration
932 NewFD = CXXConstructorDecl::Create(Context,
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +0000933 cast<CXXRecordDecl>(DC),
Douglas Gregor10bd3682008-11-17 22:58:34 +0000934 D.getIdentifierLoc(), Name, R,
Douglas Gregorb48fe382008-10-31 09:07:45 +0000935 isExplicit, isInline,
936 /*isImplicitlyDeclared=*/false);
937
Douglas Gregor42a552f2008-11-05 20:51:48 +0000938 if (isInvalidDecl)
939 NewFD->setInvalidDecl();
940 } else if (D.getKind() == Declarator::DK_Destructor) {
941 // This is a C++ destructor declaration.
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +0000942 if (DC->isCXXRecord()) {
Argyrios Kyrtzidisc7ed9c62008-11-07 22:02:30 +0000943 bool isInvalidDecl = CheckDestructorDeclarator(D, R, SC);
Douglas Gregor42a552f2008-11-05 20:51:48 +0000944
Argyrios Kyrtzidisc7ed9c62008-11-07 22:02:30 +0000945 NewFD = CXXDestructorDecl::Create(Context,
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +0000946 cast<CXXRecordDecl>(DC),
Douglas Gregor10bd3682008-11-17 22:58:34 +0000947 D.getIdentifierLoc(), Name, R,
Argyrios Kyrtzidisc7ed9c62008-11-07 22:02:30 +0000948 isInline,
949 /*isImplicitlyDeclared=*/false);
Douglas Gregor42a552f2008-11-05 20:51:48 +0000950
Argyrios Kyrtzidisc7ed9c62008-11-07 22:02:30 +0000951 if (isInvalidDecl)
952 NewFD->setInvalidDecl();
953 } else {
954 Diag(D.getIdentifierLoc(), diag::err_destructor_not_member);
955 // Create a FunctionDecl to satisfy the function definition parsing
956 // code path.
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +0000957 NewFD = FunctionDecl::Create(Context, DC, D.getIdentifierLoc(),
Douglas Gregor10bd3682008-11-17 22:58:34 +0000958 Name, R, SC, isInline, LastDeclarator,
Argyrios Kyrtzidisc7ed9c62008-11-07 22:02:30 +0000959 // FIXME: Move to DeclGroup...
960 D.getDeclSpec().getSourceRange().getBegin());
Douglas Gregor42a552f2008-11-05 20:51:48 +0000961 NewFD->setInvalidDecl();
Argyrios Kyrtzidisc7ed9c62008-11-07 22:02:30 +0000962 }
Douglas Gregor2f1bc522008-11-07 20:08:42 +0000963 } else if (D.getKind() == Declarator::DK_Conversion) {
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +0000964 if (!DC->isCXXRecord()) {
Douglas Gregor2f1bc522008-11-07 20:08:42 +0000965 Diag(D.getIdentifierLoc(),
966 diag::err_conv_function_not_member);
967 return 0;
968 } else {
969 bool isInvalidDecl = CheckConversionDeclarator(D, R, SC);
970
971 NewFD = CXXConversionDecl::Create(Context,
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +0000972 cast<CXXRecordDecl>(DC),
Douglas Gregor10bd3682008-11-17 22:58:34 +0000973 D.getIdentifierLoc(), Name, R,
Douglas Gregor2f1bc522008-11-07 20:08:42 +0000974 isInline, isExplicit);
975
976 if (isInvalidDecl)
977 NewFD->setInvalidDecl();
978 }
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +0000979 } else if (DC->isCXXRecord()) {
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000980 // This is a C++ method declaration.
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +0000981 NewFD = CXXMethodDecl::Create(Context, cast<CXXRecordDecl>(DC),
Douglas Gregor10bd3682008-11-17 22:58:34 +0000982 D.getIdentifierLoc(), Name, R,
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000983 (SC == FunctionDecl::Static), isInline,
984 LastDeclarator);
985 } else {
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +0000986 NewFD = FunctionDecl::Create(Context, DC,
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000987 D.getIdentifierLoc(),
Douglas Gregor10bd3682008-11-17 22:58:34 +0000988 Name, R, SC, isInline, LastDeclarator,
Steve Naroff0eb07bf2008-10-03 00:02:03 +0000989 // FIXME: Move to DeclGroup...
990 D.getDeclSpec().getSourceRange().getBegin());
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000991 }
Ted Kremenekf5c93c12008-02-27 22:18:07 +0000992 // Handle attributes.
Chris Lattner3ff30c82008-06-29 00:02:00 +0000993 ProcessDeclAttributes(NewFD, D);
Chris Lattner04421082008-04-08 04:40:51 +0000994
Daniel Dunbara80f8742008-08-05 01:35:17 +0000995 // Handle GNU asm-label extension (encoded as an attribute).
Daniel Dunbar914701e2008-08-05 16:28:08 +0000996 if (Expr *E = (Expr*) D.getAsmLabel()) {
Daniel Dunbara80f8742008-08-05 01:35:17 +0000997 // The parser guarantees this is a string.
998 StringLiteral *SE = cast<StringLiteral>(E);
999 NewFD->addAttr(new AsmLabelAttr(std::string(SE->getStrData(),
1000 SE->getByteLength())));
1001 }
1002
Chris Lattner04421082008-04-08 04:40:51 +00001003 // Copy the parameter declarations from the declarator D to
1004 // the function declaration NewFD, if they are available.
Eli Friedmaneb4b7052008-08-25 21:31:01 +00001005 if (D.getNumTypeObjects() > 0) {
Chris Lattner04421082008-04-08 04:40:51 +00001006 DeclaratorChunk::FunctionTypeInfo &FTI = D.getTypeObject(0).Fun;
1007
1008 // Create Decl objects for each parameter, adding them to the
1009 // FunctionDecl.
1010 llvm::SmallVector<ParmVarDecl*, 16> Params;
1011
1012 // Check for C99 6.7.5.3p10 - foo(void) is a non-varargs
1013 // function that takes no arguments, not a function that takes a
Chris Lattner8123a952008-04-10 02:22:51 +00001014 // single void argument.
Eli Friedman6d1e4b52008-05-22 08:54:03 +00001015 // We let through "const void" here because Sema::GetTypeForDeclarator
1016 // already checks for that case.
Chris Lattner04421082008-04-08 04:40:51 +00001017 if (FTI.NumArgs == 1 && !FTI.isVariadic && FTI.ArgInfo[0].Ident == 0 &&
1018 FTI.ArgInfo[0].Param &&
Chris Lattner04421082008-04-08 04:40:51 +00001019 ((ParmVarDecl*)FTI.ArgInfo[0].Param)->getType()->isVoidType()) {
1020 // empty arg list, don't push any params.
Chris Lattner8123a952008-04-10 02:22:51 +00001021 ParmVarDecl *Param = (ParmVarDecl*)FTI.ArgInfo[0].Param;
1022
Chris Lattnerdef026a2008-04-10 02:26:16 +00001023 // In C++, the empty parameter-type-list must be spelled "void"; a
1024 // typedef of void is not permitted.
1025 if (getLangOptions().CPlusPlus &&
Eli Friedman6d1e4b52008-05-22 08:54:03 +00001026 Param->getType().getUnqualifiedType() != Context.VoidTy) {
Chris Lattner8123a952008-04-10 02:22:51 +00001027 Diag(Param->getLocation(), diag::ext_param_typedef_of_void);
1028 }
Eli Friedmaneb4b7052008-08-25 21:31:01 +00001029 } else if (FTI.NumArgs > 0 && FTI.ArgInfo[0].Param != 0) {
Chris Lattner04421082008-04-08 04:40:51 +00001030 for (unsigned i = 0, e = FTI.NumArgs; i != e; ++i)
1031 Params.push_back((ParmVarDecl *)FTI.ArgInfo[i].Param);
1032 }
1033
1034 NewFD->setParams(&Params[0], Params.size());
Douglas Gregor6cbd3df2008-10-24 18:09:54 +00001035 } else if (R->getAsTypedefType()) {
1036 // When we're declaring a function with a typedef, as in the
1037 // following example, we'll need to synthesize (unnamed)
1038 // parameters for use in the declaration.
1039 //
1040 // @code
1041 // typedef void fn(int);
1042 // fn f;
1043 // @endcode
1044 const FunctionTypeProto *FT = R->getAsFunctionTypeProto();
1045 if (!FT) {
1046 // This is a typedef of a function with no prototype, so we
1047 // don't need to do anything.
1048 } else if ((FT->getNumArgs() == 0) ||
1049 (FT->getNumArgs() == 1 && !FT->isVariadic() &&
1050 FT->getArgType(0)->isVoidType())) {
1051 // This is a zero-argument function. We don't need to do anything.
1052 } else {
1053 // Synthesize a parameter for each argument type.
1054 llvm::SmallVector<ParmVarDecl*, 16> Params;
1055 for (FunctionTypeProto::arg_type_iterator ArgType = FT->arg_type_begin();
1056 ArgType != FT->arg_type_end(); ++ArgType) {
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +00001057 Params.push_back(ParmVarDecl::Create(Context, DC,
Douglas Gregor6cbd3df2008-10-24 18:09:54 +00001058 SourceLocation(), 0,
1059 *ArgType, VarDecl::None,
1060 0, 0));
1061 }
1062
1063 NewFD->setParams(&Params[0], Params.size());
1064 }
Chris Lattner04421082008-04-08 04:40:51 +00001065 }
1066
Douglas Gregor42a552f2008-11-05 20:51:48 +00001067 // C++ constructors and destructors are handled by separate
1068 // routines, since they don't require any declaration merging (C++
1069 // [class.mfct]p2) and they aren't ever pushed into scope, because
1070 // they can't be found by name lookup anyway (C++ [class.ctor]p2).
1071 if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(NewFD))
1072 return ActOnConstructorDeclarator(Constructor);
1073 else if (CXXDestructorDecl *Destructor = dyn_cast<CXXDestructorDecl>(NewFD))
1074 return ActOnDestructorDeclarator(Destructor);
Douglas Gregor2def4832008-11-17 20:34:05 +00001075
1076 // Extra checking for conversion functions, including recording
1077 // the conversion function in its class.
1078 if (CXXConversionDecl *Conversion = dyn_cast<CXXConversionDecl>(NewFD))
1079 ActOnConversionDeclarator(Conversion);
Douglas Gregorb48fe382008-10-31 09:07:45 +00001080
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00001081 // Extra checking for C++ overloaded operators (C++ [over.oper]).
1082 if (NewFD->isOverloadedOperator() &&
1083 CheckOverloadedOperatorDeclaration(NewFD))
1084 NewFD->setInvalidDecl();
1085
Steve Naroffffce4d52008-01-09 23:34:55 +00001086 // Merge the decl with the existing one if appropriate. Since C functions
1087 // are in a flat namespace, make sure we consider decls in outer scopes.
Argyrios Kyrtzidis00bc6452008-05-09 23:39:43 +00001088 if (PrevDecl &&
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +00001089 (!getLangOptions().CPlusPlus||isDeclInScope(PrevDecl, DC, S))) {
Douglas Gregorf0097952008-04-21 02:02:58 +00001090 bool Redeclaration = false;
Douglas Gregor8e9bebd2008-10-21 16:13:35 +00001091
1092 // If C++, determine whether NewFD is an overload of PrevDecl or
1093 // a declaration that requires merging. If it's an overload,
1094 // there's no more work to do here; we'll just add the new
1095 // function to the scope.
1096 OverloadedFunctionDecl::function_iterator MatchedDecl;
1097 if (!getLangOptions().CPlusPlus ||
1098 !IsOverload(NewFD, PrevDecl, MatchedDecl)) {
1099 Decl *OldDecl = PrevDecl;
1100
1101 // If PrevDecl was an overloaded function, extract the
1102 // FunctionDecl that matched.
1103 if (isa<OverloadedFunctionDecl>(PrevDecl))
1104 OldDecl = *MatchedDecl;
1105
1106 // NewFD and PrevDecl represent declarations that need to be
1107 // merged.
1108 NewFD = MergeFunctionDecl(NewFD, OldDecl, Redeclaration);
1109
1110 if (NewFD == 0) return 0;
1111 if (Redeclaration) {
1112 NewFD->setPreviousDeclaration(cast<FunctionDecl>(OldDecl));
1113
1114 if (OldDecl == PrevDecl) {
1115 // Remove the name binding for the previous
1116 // declaration. We'll add the binding back later, but then
1117 // it will refer to the new declaration (which will
1118 // contain more information).
1119 IdResolver.RemoveDecl(cast<NamedDecl>(PrevDecl));
1120 } else {
1121 // We need to update the OverloadedFunctionDecl with the
1122 // latest declaration of this function, so that name
1123 // lookup will always refer to the latest declaration of
1124 // this function.
1125 *MatchedDecl = NewFD;
1126
1127 // Add the redeclaration to the current scope, since we'll
1128 // be skipping PushOnScopeChains.
1129 S->AddDecl(NewFD);
1130
1131 return NewFD;
1132 }
1133 }
Douglas Gregorf0097952008-04-21 02:02:58 +00001134 }
Reid Spencer5f016e22007-07-11 17:01:13 +00001135 }
1136 New = NewFD;
Chris Lattner04421082008-04-08 04:40:51 +00001137
1138 // In C++, check default arguments now that we have merged decls.
1139 if (getLangOptions().CPlusPlus)
1140 CheckCXXDefaultArguments(NewFD);
Reid Spencer5f016e22007-07-11 17:01:13 +00001141 } else {
Douglas Gregor6d6eb572008-05-07 04:49:29 +00001142 // Check that there are no default arguments (C++ only).
1143 if (getLangOptions().CPlusPlus)
1144 CheckExtraCXXDefaultArguments(D);
1145
Ted Kremeneka526c5c2008-01-07 19:49:32 +00001146 if (R.getTypePtr()->isObjCInterfaceType()) {
Chris Lattner3c73c412008-11-19 08:23:25 +00001147 Diag(D.getIdentifierLoc(), diag::err_statically_allocated_object)
1148 << D.getIdentifier();
Fariborz Jahaniane7f64cc2007-10-12 22:10:42 +00001149 InvalidDecl = true;
1150 }
Reid Spencer5f016e22007-07-11 17:01:13 +00001151
1152 VarDecl *NewVD;
1153 VarDecl::StorageClass SC;
1154 switch (D.getDeclSpec().getStorageClassSpec()) {
Chris Lattner9e151e12008-03-15 21:10:16 +00001155 default: assert(0 && "Unknown storage class!");
1156 case DeclSpec::SCS_unspecified: SC = VarDecl::None; break;
1157 case DeclSpec::SCS_extern: SC = VarDecl::Extern; break;
1158 case DeclSpec::SCS_static: SC = VarDecl::Static; break;
1159 case DeclSpec::SCS_auto: SC = VarDecl::Auto; break;
1160 case DeclSpec::SCS_register: SC = VarDecl::Register; break;
1161 case DeclSpec::SCS_private_extern: SC = VarDecl::PrivateExtern; break;
Sebastian Redl669d5d72008-11-14 23:42:31 +00001162 case DeclSpec::SCS_mutable:
1163 // mutable can only appear on non-static class members, so it's always
1164 // an error here
1165 Diag(D.getIdentifierLoc(), diag::err_mutable_nonmember);
1166 InvalidDecl = true;
Sebastian Redla11f42f2008-11-17 23:24:37 +00001167 break;
Sebastian Redl669d5d72008-11-14 23:42:31 +00001168 }
Douglas Gregor10bd3682008-11-17 22:58:34 +00001169
1170 IdentifierInfo *II = Name.getAsIdentifierInfo();
1171 if (!II) {
Chris Lattnerf3a41af2008-11-20 06:38:18 +00001172 Diag(D.getIdentifierLoc(), diag::err_bad_variable_name)
1173 << Name.getAsString();
Douglas Gregor10bd3682008-11-17 22:58:34 +00001174 return 0;
1175 }
1176
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +00001177 if (DC->isCXXRecord()) {
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +00001178 assert(SC == VarDecl::Static && "Invalid storage class for member!");
1179 // This is a static data member for a C++ class.
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +00001180 NewVD = CXXClassVarDecl::Create(Context, cast<CXXRecordDecl>(DC),
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +00001181 D.getIdentifierLoc(), II,
1182 R, LastDeclarator);
Steve Narofff0090632007-09-02 02:04:30 +00001183 } else {
Daniel Dunbar6f0200e2008-09-08 20:05:47 +00001184 bool ThreadSpecified = D.getDeclSpec().isThreadSpecified();
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +00001185 if (S->getFnParent() == 0) {
1186 // C99 6.9p2: The storage-class specifiers auto and register shall not
1187 // appear in the declaration specifiers in an external declaration.
1188 if (SC == VarDecl::Auto || SC == VarDecl::Register) {
Chris Lattnerf3a41af2008-11-20 06:38:18 +00001189 Diag(D.getIdentifierLoc(), diag::err_typecheck_sclass_fscope)
1190 << R.getAsString();
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +00001191 InvalidDecl = true;
1192 }
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +00001193 }
Sebastian Redl669d5d72008-11-14 23:42:31 +00001194 NewVD = VarDecl::Create(Context, DC, D.getIdentifierLoc(),
1195 II, R, SC, LastDeclarator,
1196 // FIXME: Move to DeclGroup...
1197 D.getDeclSpec().getSourceRange().getBegin());
1198 NewVD->setThreadSpecified(ThreadSpecified);
Steve Naroff53a32342007-08-28 18:45:29 +00001199 }
Reid Spencer5f016e22007-07-11 17:01:13 +00001200 // Handle attributes prior to checking for duplicates in MergeVarDecl
Chris Lattner3ff30c82008-06-29 00:02:00 +00001201 ProcessDeclAttributes(NewVD, D);
Nate Begemanc8e89a82008-03-14 18:07:10 +00001202
Daniel Dunbara735ad82008-08-06 00:03:29 +00001203 // Handle GNU asm-label extension (encoded as an attribute).
1204 if (Expr *E = (Expr*) D.getAsmLabel()) {
1205 // The parser guarantees this is a string.
1206 StringLiteral *SE = cast<StringLiteral>(E);
1207 NewVD->addAttr(new AsmLabelAttr(std::string(SE->getStrData(),
1208 SE->getByteLength())));
1209 }
1210
Nate Begemanc8e89a82008-03-14 18:07:10 +00001211 // Emit an error if an address space was applied to decl with local storage.
1212 // This includes arrays of objects with address space qualifiers, but not
1213 // automatic variables that point to other address spaces.
1214 // ISO/IEC TR 18037 S5.1.2
Nate Begeman8e7dafe2008-03-25 18:36:32 +00001215 if (NewVD->hasLocalStorage() && (NewVD->getType().getAddressSpace() != 0)) {
1216 Diag(D.getIdentifierLoc(), diag::err_as_qualified_auto_decl);
1217 InvalidDecl = true;
Nate Begeman5af27e02008-03-14 00:22:18 +00001218 }
Steve Naroffffce4d52008-01-09 23:34:55 +00001219 // Merge the decl with the existing one if appropriate. If the decl is
1220 // in an outer scope, it isn't the same thing.
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +00001221 if (PrevDecl && isDeclInScope(PrevDecl, DC, S)) {
Reid Spencer5f016e22007-07-11 17:01:13 +00001222 NewVD = MergeVarDecl(NewVD, PrevDecl);
1223 if (NewVD == 0) return 0;
1224 }
Reid Spencer5f016e22007-07-11 17:01:13 +00001225 New = NewVD;
1226 }
1227
Argyrios Kyrtzidis52393042008-11-09 23:41:00 +00001228 // Set the lexical context. If the declarator has a C++ scope specifier, the
1229 // lexical context will be different from the semantic context.
1230 New->setLexicalDeclContext(CurContext);
1231
Reid Spencer5f016e22007-07-11 17:01:13 +00001232 // If this has an identifier, add it to the scope stack.
Douglas Gregor10bd3682008-11-17 22:58:34 +00001233 if (Name)
Argyrios Kyrtzidis87f3ff02008-04-12 00:47:19 +00001234 PushOnScopeChains(New, S);
Steve Naroff5912a352007-08-28 20:14:24 +00001235 // If any semantic error occurred, mark the decl as invalid.
1236 if (D.getInvalidType() || InvalidDecl)
1237 New->setInvalidDecl();
Reid Spencer5f016e22007-07-11 17:01:13 +00001238
1239 return New;
1240}
1241
Steve Naroff6594a702008-10-27 11:34:16 +00001242void Sema::InitializerElementNotConstant(const Expr *Init) {
Chris Lattnerdcd5ef12008-11-19 05:27:50 +00001243 Diag(Init->getExprLoc(), diag::err_init_element_not_constant)
1244 << Init->getSourceRange();
Steve Naroff6594a702008-10-27 11:34:16 +00001245}
1246
Eli Friedmanc594b322008-05-20 13:48:25 +00001247bool Sema::CheckAddressConstantExpressionLValue(const Expr* Init) {
1248 switch (Init->getStmtClass()) {
1249 default:
Steve Naroff6594a702008-10-27 11:34:16 +00001250 InitializerElementNotConstant(Init);
Eli Friedmanc594b322008-05-20 13:48:25 +00001251 return true;
1252 case Expr::ParenExprClass: {
1253 const ParenExpr* PE = cast<ParenExpr>(Init);
1254 return CheckAddressConstantExpressionLValue(PE->getSubExpr());
1255 }
1256 case Expr::CompoundLiteralExprClass:
1257 return cast<CompoundLiteralExpr>(Init)->isFileScope();
1258 case Expr::DeclRefExprClass: {
1259 const Decl *D = cast<DeclRefExpr>(Init)->getDecl();
Eli Friedman97c0a392008-05-21 03:39:11 +00001260 if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
1261 if (VD->hasGlobalStorage())
1262 return false;
Steve Naroff6594a702008-10-27 11:34:16 +00001263 InitializerElementNotConstant(Init);
Eli Friedman97c0a392008-05-21 03:39:11 +00001264 return true;
1265 }
Eli Friedmanc594b322008-05-20 13:48:25 +00001266 if (isa<FunctionDecl>(D))
1267 return false;
Steve Naroff6594a702008-10-27 11:34:16 +00001268 InitializerElementNotConstant(Init);
Steve Naroffd0091aa2008-01-10 22:15:12 +00001269 return true;
1270 }
Eli Friedmanc594b322008-05-20 13:48:25 +00001271 case Expr::MemberExprClass: {
1272 const MemberExpr *M = cast<MemberExpr>(Init);
1273 if (M->isArrow())
1274 return CheckAddressConstantExpression(M->getBase());
1275 return CheckAddressConstantExpressionLValue(M->getBase());
1276 }
1277 case Expr::ArraySubscriptExprClass: {
1278 // FIXME: Should we pedwarn for "x[0+0]" (where x is a pointer)?
1279 const ArraySubscriptExpr *ASE = cast<ArraySubscriptExpr>(Init);
1280 return CheckAddressConstantExpression(ASE->getBase()) ||
1281 CheckArithmeticConstantExpression(ASE->getIdx());
1282 }
1283 case Expr::StringLiteralClass:
Chris Lattnerd9f69102008-08-10 01:53:14 +00001284 case Expr::PredefinedExprClass:
Eli Friedmanc594b322008-05-20 13:48:25 +00001285 return false;
1286 case Expr::UnaryOperatorClass: {
1287 const UnaryOperator *Exp = cast<UnaryOperator>(Init);
1288
1289 // C99 6.6p9
1290 if (Exp->getOpcode() == UnaryOperator::Deref)
Eli Friedman97c0a392008-05-21 03:39:11 +00001291 return CheckAddressConstantExpression(Exp->getSubExpr());
Eli Friedmanc594b322008-05-20 13:48:25 +00001292
Steve Naroff6594a702008-10-27 11:34:16 +00001293 InitializerElementNotConstant(Init);
Eli Friedmanc594b322008-05-20 13:48:25 +00001294 return true;
1295 }
1296 }
1297}
1298
1299bool Sema::CheckAddressConstantExpression(const Expr* Init) {
1300 switch (Init->getStmtClass()) {
1301 default:
Steve Naroff6594a702008-10-27 11:34:16 +00001302 InitializerElementNotConstant(Init);
Eli Friedmanc594b322008-05-20 13:48:25 +00001303 return true;
Chris Lattner506ff882008-10-06 07:26:43 +00001304 case Expr::ParenExprClass:
1305 return CheckAddressConstantExpression(cast<ParenExpr>(Init)->getSubExpr());
Eli Friedmanc594b322008-05-20 13:48:25 +00001306 case Expr::StringLiteralClass:
1307 case Expr::ObjCStringLiteralClass:
1308 return false;
Chris Lattner506ff882008-10-06 07:26:43 +00001309 case Expr::CallExprClass:
Douglas Gregorb4609802008-11-14 16:09:21 +00001310 case Expr::CXXOperatorCallExprClass:
Chris Lattner506ff882008-10-06 07:26:43 +00001311 // __builtin___CFStringMakeConstantString is a valid constant l-value.
1312 if (cast<CallExpr>(Init)->isBuiltinCall() ==
1313 Builtin::BI__builtin___CFStringMakeConstantString)
1314 return false;
1315
Steve Naroff6594a702008-10-27 11:34:16 +00001316 InitializerElementNotConstant(Init);
Chris Lattner506ff882008-10-06 07:26:43 +00001317 return true;
1318
Eli Friedmanc594b322008-05-20 13:48:25 +00001319 case Expr::UnaryOperatorClass: {
1320 const UnaryOperator *Exp = cast<UnaryOperator>(Init);
1321
1322 // C99 6.6p9
1323 if (Exp->getOpcode() == UnaryOperator::AddrOf)
1324 return CheckAddressConstantExpressionLValue(Exp->getSubExpr());
1325
1326 if (Exp->getOpcode() == UnaryOperator::Extension)
1327 return CheckAddressConstantExpression(Exp->getSubExpr());
1328
Steve Naroff6594a702008-10-27 11:34:16 +00001329 InitializerElementNotConstant(Init);
Eli Friedmanc594b322008-05-20 13:48:25 +00001330 return true;
1331 }
1332 case Expr::BinaryOperatorClass: {
1333 // FIXME: Should we pedwarn for expressions like "a + 1 + 2"?
1334 const BinaryOperator *Exp = cast<BinaryOperator>(Init);
1335
1336 Expr *PExp = Exp->getLHS();
1337 Expr *IExp = Exp->getRHS();
1338 if (IExp->getType()->isPointerType())
1339 std::swap(PExp, IExp);
1340
1341 // FIXME: Should we pedwarn if IExp isn't an integer constant expression?
1342 return CheckAddressConstantExpression(PExp) ||
1343 CheckArithmeticConstantExpression(IExp);
1344 }
Eli Friedmanc3f07642008-08-25 20:46:57 +00001345 case Expr::ImplicitCastExprClass:
Douglas Gregor6eec8e82008-10-28 15:36:24 +00001346 case Expr::CStyleCastExprClass: {
Eli Friedmanc594b322008-05-20 13:48:25 +00001347 const Expr* SubExpr = cast<CastExpr>(Init)->getSubExpr();
Eli Friedmanc3f07642008-08-25 20:46:57 +00001348 if (Init->getStmtClass() == Expr::ImplicitCastExprClass) {
1349 // Check for implicit promotion
1350 if (SubExpr->getType()->isFunctionType() ||
1351 SubExpr->getType()->isArrayType())
1352 return CheckAddressConstantExpressionLValue(SubExpr);
1353 }
Eli Friedmanc594b322008-05-20 13:48:25 +00001354
1355 // Check for pointer->pointer cast
1356 if (SubExpr->getType()->isPointerType())
1357 return CheckAddressConstantExpression(SubExpr);
1358
Eli Friedmanc3f07642008-08-25 20:46:57 +00001359 if (SubExpr->getType()->isIntegralType()) {
1360 // Check for the special-case of a pointer->int->pointer cast;
1361 // this isn't standard, but some code requires it. See
1362 // PR2720 for an example.
1363 if (const CastExpr* SubCast = dyn_cast<CastExpr>(SubExpr)) {
1364 if (SubCast->getSubExpr()->getType()->isPointerType()) {
1365 unsigned IntWidth = Context.getIntWidth(SubCast->getType());
1366 unsigned PointerWidth = Context.getTypeSize(Context.VoidPtrTy);
1367 if (IntWidth >= PointerWidth) {
1368 return CheckAddressConstantExpression(SubCast->getSubExpr());
1369 }
1370 }
1371 }
1372 }
1373 if (SubExpr->getType()->isArithmeticType()) {
Eli Friedmanc594b322008-05-20 13:48:25 +00001374 return CheckArithmeticConstantExpression(SubExpr);
Eli Friedmanc3f07642008-08-25 20:46:57 +00001375 }
Eli Friedmanc594b322008-05-20 13:48:25 +00001376
Steve Naroff6594a702008-10-27 11:34:16 +00001377 InitializerElementNotConstant(Init);
Eli Friedmanc594b322008-05-20 13:48:25 +00001378 return true;
1379 }
1380 case Expr::ConditionalOperatorClass: {
1381 // FIXME: Should we pedwarn here?
1382 const ConditionalOperator *Exp = cast<ConditionalOperator>(Init);
1383 if (!Exp->getCond()->getType()->isArithmeticType()) {
Steve Naroff6594a702008-10-27 11:34:16 +00001384 InitializerElementNotConstant(Init);
Eli Friedmanc594b322008-05-20 13:48:25 +00001385 return true;
1386 }
1387 if (CheckArithmeticConstantExpression(Exp->getCond()))
1388 return true;
1389 if (Exp->getLHS() &&
1390 CheckAddressConstantExpression(Exp->getLHS()))
1391 return true;
1392 return CheckAddressConstantExpression(Exp->getRHS());
1393 }
1394 case Expr::AddrLabelExprClass:
1395 return false;
1396 }
1397}
1398
Eli Friedman4caf0552008-06-09 05:05:07 +00001399static const Expr* FindExpressionBaseAddress(const Expr* E);
1400
1401static const Expr* FindExpressionBaseAddressLValue(const Expr* E) {
1402 switch (E->getStmtClass()) {
1403 default:
1404 return E;
1405 case Expr::ParenExprClass: {
1406 const ParenExpr* PE = cast<ParenExpr>(E);
1407 return FindExpressionBaseAddressLValue(PE->getSubExpr());
1408 }
1409 case Expr::MemberExprClass: {
1410 const MemberExpr *M = cast<MemberExpr>(E);
1411 if (M->isArrow())
1412 return FindExpressionBaseAddress(M->getBase());
1413 return FindExpressionBaseAddressLValue(M->getBase());
1414 }
1415 case Expr::ArraySubscriptExprClass: {
1416 const ArraySubscriptExpr *ASE = cast<ArraySubscriptExpr>(E);
1417 return FindExpressionBaseAddress(ASE->getBase());
1418 }
1419 case Expr::UnaryOperatorClass: {
1420 const UnaryOperator *Exp = cast<UnaryOperator>(E);
1421
1422 if (Exp->getOpcode() == UnaryOperator::Deref)
1423 return FindExpressionBaseAddress(Exp->getSubExpr());
1424
1425 return E;
1426 }
1427 }
1428}
1429
1430static const Expr* FindExpressionBaseAddress(const Expr* E) {
1431 switch (E->getStmtClass()) {
1432 default:
1433 return E;
1434 case Expr::ParenExprClass: {
1435 const ParenExpr* PE = cast<ParenExpr>(E);
1436 return FindExpressionBaseAddress(PE->getSubExpr());
1437 }
1438 case Expr::UnaryOperatorClass: {
1439 const UnaryOperator *Exp = cast<UnaryOperator>(E);
1440
1441 // C99 6.6p9
1442 if (Exp->getOpcode() == UnaryOperator::AddrOf)
1443 return FindExpressionBaseAddressLValue(Exp->getSubExpr());
1444
1445 if (Exp->getOpcode() == UnaryOperator::Extension)
1446 return FindExpressionBaseAddress(Exp->getSubExpr());
1447
1448 return E;
1449 }
1450 case Expr::BinaryOperatorClass: {
1451 const BinaryOperator *Exp = cast<BinaryOperator>(E);
1452
1453 Expr *PExp = Exp->getLHS();
1454 Expr *IExp = Exp->getRHS();
1455 if (IExp->getType()->isPointerType())
1456 std::swap(PExp, IExp);
1457
1458 return FindExpressionBaseAddress(PExp);
1459 }
1460 case Expr::ImplicitCastExprClass: {
1461 const Expr* SubExpr = cast<ImplicitCastExpr>(E)->getSubExpr();
1462
1463 // Check for implicit promotion
1464 if (SubExpr->getType()->isFunctionType() ||
1465 SubExpr->getType()->isArrayType())
1466 return FindExpressionBaseAddressLValue(SubExpr);
1467
1468 // Check for pointer->pointer cast
1469 if (SubExpr->getType()->isPointerType())
1470 return FindExpressionBaseAddress(SubExpr);
1471
1472 // We assume that we have an arithmetic expression here;
1473 // if we don't, we'll figure it out later
1474 return 0;
1475 }
Douglas Gregor6eec8e82008-10-28 15:36:24 +00001476 case Expr::CStyleCastExprClass: {
Eli Friedman4caf0552008-06-09 05:05:07 +00001477 const Expr* SubExpr = cast<CastExpr>(E)->getSubExpr();
1478
1479 // Check for pointer->pointer cast
1480 if (SubExpr->getType()->isPointerType())
1481 return FindExpressionBaseAddress(SubExpr);
1482
1483 // We assume that we have an arithmetic expression here;
1484 // if we don't, we'll figure it out later
1485 return 0;
1486 }
1487 }
1488}
1489
Anders Carlsson51fe9962008-11-22 21:04:56 +00001490bool Sema::CheckArithmeticConstantExpression(const Expr* Init) {
Eli Friedmanc594b322008-05-20 13:48:25 +00001491 switch (Init->getStmtClass()) {
1492 default:
Steve Naroff6594a702008-10-27 11:34:16 +00001493 InitializerElementNotConstant(Init);
Eli Friedmanc594b322008-05-20 13:48:25 +00001494 return true;
1495 case Expr::ParenExprClass: {
1496 const ParenExpr* PE = cast<ParenExpr>(Init);
1497 return CheckArithmeticConstantExpression(PE->getSubExpr());
1498 }
1499 case Expr::FloatingLiteralClass:
1500 case Expr::IntegerLiteralClass:
1501 case Expr::CharacterLiteralClass:
1502 case Expr::ImaginaryLiteralClass:
1503 case Expr::TypesCompatibleExprClass:
1504 case Expr::CXXBoolLiteralExprClass:
1505 return false;
Douglas Gregorb4609802008-11-14 16:09:21 +00001506 case Expr::CallExprClass:
1507 case Expr::CXXOperatorCallExprClass: {
Eli Friedmanc594b322008-05-20 13:48:25 +00001508 const CallExpr *CE = cast<CallExpr>(Init);
Chris Lattner45b6b9d2008-10-06 06:49:02 +00001509
1510 // Allow any constant foldable calls to builtins.
1511 if (CE->isBuiltinCall() && CE->isEvaluatable(Context))
Eli Friedmanc594b322008-05-20 13:48:25 +00001512 return false;
Chris Lattner45b6b9d2008-10-06 06:49:02 +00001513
Steve Naroff6594a702008-10-27 11:34:16 +00001514 InitializerElementNotConstant(Init);
Eli Friedmanc594b322008-05-20 13:48:25 +00001515 return true;
1516 }
1517 case Expr::DeclRefExprClass: {
1518 const Decl *D = cast<DeclRefExpr>(Init)->getDecl();
1519 if (isa<EnumConstantDecl>(D))
1520 return false;
Steve Naroff6594a702008-10-27 11:34:16 +00001521 InitializerElementNotConstant(Init);
Eli Friedmanc594b322008-05-20 13:48:25 +00001522 return true;
1523 }
1524 case Expr::CompoundLiteralExprClass:
1525 // Allow "(vector type){2,4}"; normal C constraints don't allow this,
1526 // but vectors are allowed to be magic.
1527 if (Init->getType()->isVectorType())
1528 return false;
Steve Naroff6594a702008-10-27 11:34:16 +00001529 InitializerElementNotConstant(Init);
Eli Friedmanc594b322008-05-20 13:48:25 +00001530 return true;
1531 case Expr::UnaryOperatorClass: {
1532 const UnaryOperator *Exp = cast<UnaryOperator>(Init);
1533
1534 switch (Exp->getOpcode()) {
1535 // Address, indirect, pre/post inc/dec, etc are not valid constant exprs.
1536 // See C99 6.6p3.
1537 default:
Steve Naroff6594a702008-10-27 11:34:16 +00001538 InitializerElementNotConstant(Init);
Eli Friedmanc594b322008-05-20 13:48:25 +00001539 return true;
Eli Friedmanc594b322008-05-20 13:48:25 +00001540 case UnaryOperator::OffsetOf:
Eli Friedmanc594b322008-05-20 13:48:25 +00001541 if (Exp->getSubExpr()->getType()->isConstantSizeType())
1542 return false;
Steve Naroff6594a702008-10-27 11:34:16 +00001543 InitializerElementNotConstant(Init);
Eli Friedmanc594b322008-05-20 13:48:25 +00001544 return true;
1545 case UnaryOperator::Extension:
1546 case UnaryOperator::LNot:
1547 case UnaryOperator::Plus:
1548 case UnaryOperator::Minus:
1549 case UnaryOperator::Not:
1550 return CheckArithmeticConstantExpression(Exp->getSubExpr());
1551 }
1552 }
Sebastian Redl05189992008-11-11 17:56:53 +00001553 case Expr::SizeOfAlignOfExprClass: {
1554 const SizeOfAlignOfExpr *Exp = cast<SizeOfAlignOfExpr>(Init);
Eli Friedmanc594b322008-05-20 13:48:25 +00001555 // Special check for void types, which are allowed as an extension
Sebastian Redl05189992008-11-11 17:56:53 +00001556 if (Exp->getTypeOfArgument()->isVoidType())
Eli Friedmanc594b322008-05-20 13:48:25 +00001557 return false;
1558 // alignof always evaluates to a constant.
1559 // FIXME: is sizeof(int[3.0]) a constant expression?
Sebastian Redl05189992008-11-11 17:56:53 +00001560 if (Exp->isSizeOf() && !Exp->getTypeOfArgument()->isConstantSizeType()) {
Steve Naroff6594a702008-10-27 11:34:16 +00001561 InitializerElementNotConstant(Init);
Eli Friedmanc594b322008-05-20 13:48:25 +00001562 return true;
1563 }
1564 return false;
1565 }
1566 case Expr::BinaryOperatorClass: {
1567 const BinaryOperator *Exp = cast<BinaryOperator>(Init);
1568
1569 if (Exp->getLHS()->getType()->isArithmeticType() &&
1570 Exp->getRHS()->getType()->isArithmeticType()) {
1571 return CheckArithmeticConstantExpression(Exp->getLHS()) ||
1572 CheckArithmeticConstantExpression(Exp->getRHS());
1573 }
1574
Eli Friedman4caf0552008-06-09 05:05:07 +00001575 if (Exp->getLHS()->getType()->isPointerType() &&
1576 Exp->getRHS()->getType()->isPointerType()) {
1577 const Expr* LHSBase = FindExpressionBaseAddress(Exp->getLHS());
1578 const Expr* RHSBase = FindExpressionBaseAddress(Exp->getRHS());
1579
1580 // Only allow a null (constant integer) base; we could
1581 // allow some additional cases if necessary, but this
1582 // is sufficient to cover offsetof-like constructs.
1583 if (!LHSBase && !RHSBase) {
1584 return CheckAddressConstantExpression(Exp->getLHS()) ||
1585 CheckAddressConstantExpression(Exp->getRHS());
1586 }
1587 }
1588
Steve Naroff6594a702008-10-27 11:34:16 +00001589 InitializerElementNotConstant(Init);
Eli Friedmanc594b322008-05-20 13:48:25 +00001590 return true;
1591 }
1592 case Expr::ImplicitCastExprClass:
Douglas Gregor6eec8e82008-10-28 15:36:24 +00001593 case Expr::CStyleCastExprClass: {
Argyrios Kyrtzidis0835a3c2008-08-18 23:01:59 +00001594 const Expr *SubExpr = cast<CastExpr>(Init)->getSubExpr();
Eli Friedman6d4abe12008-09-01 22:08:17 +00001595 if (SubExpr->getType()->isArithmeticType())
1596 return CheckArithmeticConstantExpression(SubExpr);
1597
Eli Friedmanb529d832008-09-02 09:37:00 +00001598 if (SubExpr->getType()->isPointerType()) {
1599 const Expr* Base = FindExpressionBaseAddress(SubExpr);
1600 // If the pointer has a null base, this is an offsetof-like construct
1601 if (!Base)
1602 return CheckAddressConstantExpression(SubExpr);
1603 }
1604
Steve Naroff6594a702008-10-27 11:34:16 +00001605 InitializerElementNotConstant(Init);
Eli Friedman6d4abe12008-09-01 22:08:17 +00001606 return true;
Eli Friedmanc594b322008-05-20 13:48:25 +00001607 }
1608 case Expr::ConditionalOperatorClass: {
1609 const ConditionalOperator *Exp = cast<ConditionalOperator>(Init);
Chris Lattner46cfefa2008-10-06 05:42:39 +00001610
1611 // If GNU extensions are disabled, we require all operands to be arithmetic
1612 // constant expressions.
1613 if (getLangOptions().NoExtensions) {
1614 return CheckArithmeticConstantExpression(Exp->getCond()) ||
1615 (Exp->getLHS() && CheckArithmeticConstantExpression(Exp->getLHS())) ||
1616 CheckArithmeticConstantExpression(Exp->getRHS());
1617 }
1618
1619 // Otherwise, we have to emulate some of the behavior of fold here.
1620 // Basically GCC treats things like "4 ? 1 : somefunc()" as a constant
1621 // because it can constant fold things away. To retain compatibility with
1622 // GCC code, we see if we can fold the condition to a constant (which we
1623 // should always be able to do in theory). If so, we only require the
1624 // specified arm of the conditional to be a constant. This is a horrible
1625 // hack, but is require by real world code that uses __builtin_constant_p.
1626 APValue Val;
Chris Lattner6ee7aa12008-11-16 21:24:15 +00001627 if (!Exp->getCond()->Evaluate(Val, Context)) {
1628 // If Evaluate couldn't fold it, CheckArithmeticConstantExpression
Chris Lattner46cfefa2008-10-06 05:42:39 +00001629 // won't be able to either. Use it to emit the diagnostic though.
1630 bool Res = CheckArithmeticConstantExpression(Exp->getCond());
Chris Lattner6ee7aa12008-11-16 21:24:15 +00001631 assert(Res && "Evaluate couldn't evaluate this constant?");
Chris Lattner46cfefa2008-10-06 05:42:39 +00001632 return Res;
1633 }
1634
1635 // Verify that the side following the condition is also a constant.
1636 const Expr *TrueSide = Exp->getLHS(), *FalseSide = Exp->getRHS();
1637 if (Val.getInt() == 0)
1638 std::swap(TrueSide, FalseSide);
1639
1640 if (TrueSide && CheckArithmeticConstantExpression(TrueSide))
Eli Friedmanc594b322008-05-20 13:48:25 +00001641 return true;
Chris Lattner46cfefa2008-10-06 05:42:39 +00001642
1643 // Okay, the evaluated side evaluates to a constant, so we accept this.
1644 // Check to see if the other side is obviously not a constant. If so,
1645 // emit a warning that this is a GNU extension.
Chris Lattner45b6b9d2008-10-06 06:49:02 +00001646 if (FalseSide && !FalseSide->isEvaluatable(Context))
Chris Lattner46cfefa2008-10-06 05:42:39 +00001647 Diag(Init->getExprLoc(),
Chris Lattnerdcd5ef12008-11-19 05:27:50 +00001648 diag::ext_typecheck_expression_not_constant_but_accepted)
1649 << FalseSide->getSourceRange();
Chris Lattner46cfefa2008-10-06 05:42:39 +00001650 return false;
Eli Friedmanc594b322008-05-20 13:48:25 +00001651 }
1652 }
1653}
1654
1655bool Sema::CheckForConstantInitializer(Expr *Init, QualType DclT) {
Nuno Lopes9a979c32008-07-07 16:46:50 +00001656 Init = Init->IgnoreParens();
1657
Eli Friedmanc594b322008-05-20 13:48:25 +00001658 // Look through CXXDefaultArgExprs; they have no meaning in this context.
1659 if (CXXDefaultArgExpr* DAE = dyn_cast<CXXDefaultArgExpr>(Init))
1660 return CheckForConstantInitializer(DAE->getExpr(), DclT);
1661
Nuno Lopes9a979c32008-07-07 16:46:50 +00001662 if (CompoundLiteralExpr *e = dyn_cast<CompoundLiteralExpr>(Init))
1663 return CheckForConstantInitializer(e->getInitializer(), DclT);
1664
Eli Friedmanc594b322008-05-20 13:48:25 +00001665 if (InitListExpr *Exp = dyn_cast<InitListExpr>(Init)) {
1666 unsigned numInits = Exp->getNumInits();
1667 for (unsigned i = 0; i < numInits; i++) {
1668 // FIXME: Need to get the type of the declaration for C++,
1669 // because it could be a reference?
1670 if (CheckForConstantInitializer(Exp->getInit(i),
1671 Exp->getInit(i)->getType()))
1672 return true;
1673 }
1674 return false;
1675 }
1676
1677 if (Init->isNullPointerConstant(Context))
1678 return false;
1679 if (Init->getType()->isArithmeticType()) {
Chris Lattnerb77792e2008-07-26 22:17:49 +00001680 QualType InitTy = Context.getCanonicalType(Init->getType())
1681 .getUnqualifiedType();
Eli Friedmanc1cc6dc2008-05-30 18:14:48 +00001682 if (InitTy == Context.BoolTy) {
1683 // Special handling for pointers implicitly cast to bool;
1684 // (e.g. "_Bool rr = &rr;"). This is only legal at the top level.
1685 if (ImplicitCastExpr* ICE = dyn_cast<ImplicitCastExpr>(Init)) {
1686 Expr* SubE = ICE->getSubExpr();
1687 if (SubE->getType()->isPointerType() ||
1688 SubE->getType()->isArrayType() ||
1689 SubE->getType()->isFunctionType()) {
1690 return CheckAddressConstantExpression(Init);
1691 }
1692 }
1693 } else if (InitTy->isIntegralType()) {
1694 Expr* SubE = 0;
Argyrios Kyrtzidis0835a3c2008-08-18 23:01:59 +00001695 if (CastExpr* CE = dyn_cast<CastExpr>(Init))
Eli Friedmanc1cc6dc2008-05-30 18:14:48 +00001696 SubE = CE->getSubExpr();
1697 // Special check for pointer cast to int; we allow as an extension
1698 // an address constant cast to an integer if the integer
1699 // is of an appropriate width (this sort of code is apparently used
1700 // in some places).
1701 // FIXME: Add pedwarn?
1702 // FIXME: Don't allow bitfields here! Need the FieldDecl for that.
1703 if (SubE && (SubE->getType()->isPointerType() ||
1704 SubE->getType()->isArrayType() ||
1705 SubE->getType()->isFunctionType())) {
1706 unsigned IntWidth = Context.getTypeSize(Init->getType());
1707 unsigned PointerWidth = Context.getTypeSize(Context.VoidPtrTy);
1708 if (IntWidth >= PointerWidth)
1709 return CheckAddressConstantExpression(Init);
1710 }
Eli Friedmanc594b322008-05-20 13:48:25 +00001711 }
1712
1713 return CheckArithmeticConstantExpression(Init);
1714 }
1715
1716 if (Init->getType()->isPointerType())
1717 return CheckAddressConstantExpression(Init);
1718
Eli Friedmanc1cc6dc2008-05-30 18:14:48 +00001719 // An array type at the top level that isn't an init-list must
1720 // be a string literal
Eli Friedmanc594b322008-05-20 13:48:25 +00001721 if (Init->getType()->isArrayType())
1722 return false;
1723
Nuno Lopes73419bf2008-09-01 18:42:41 +00001724 if (Init->getType()->isFunctionType())
1725 return false;
1726
Steve Naroff8af6a452008-10-02 17:12:56 +00001727 // Allow block exprs at top level.
1728 if (Init->getType()->isBlockPointerType())
1729 return false;
1730
Steve Naroff6594a702008-10-27 11:34:16 +00001731 InitializerElementNotConstant(Init);
Eli Friedmanc594b322008-05-20 13:48:25 +00001732 return true;
Steve Naroffd0091aa2008-01-10 22:15:12 +00001733}
1734
Steve Naroffbb204692007-09-12 14:07:44 +00001735void Sema::AddInitializerToDecl(DeclTy *dcl, ExprTy *init) {
Steve Naroff410e3e22007-09-12 20:13:48 +00001736 Decl *RealDecl = static_cast<Decl *>(dcl);
Steve Naroffbb204692007-09-12 14:07:44 +00001737 Expr *Init = static_cast<Expr *>(init);
Chris Lattner9a11b9a2007-10-19 20:10:30 +00001738 assert(Init && "missing initializer");
Steve Naroffbb204692007-09-12 14:07:44 +00001739
Chris Lattner9a11b9a2007-10-19 20:10:30 +00001740 // If there is no declaration, there was an error parsing it. Just ignore
1741 // the initializer.
1742 if (RealDecl == 0) {
1743 delete Init;
1744 return;
1745 }
Steve Naroffbb204692007-09-12 14:07:44 +00001746
Steve Naroff410e3e22007-09-12 20:13:48 +00001747 VarDecl *VDecl = dyn_cast<VarDecl>(RealDecl);
1748 if (!VDecl) {
Steve Naroff8e74c932007-09-13 21:41:19 +00001749 Diag(dyn_cast<ScopedDecl>(RealDecl)->getLocation(),
1750 diag::err_illegal_initializer);
Steve Naroff410e3e22007-09-12 20:13:48 +00001751 RealDecl->setInvalidDecl();
1752 return;
1753 }
Steve Naroffbb204692007-09-12 14:07:44 +00001754 // Get the decls type and save a reference for later, since
Steve Naroffd0091aa2008-01-10 22:15:12 +00001755 // CheckInitializerTypes may change it.
Steve Naroff410e3e22007-09-12 20:13:48 +00001756 QualType DclT = VDecl->getType(), SavT = DclT;
Steve Naroff248a7532008-04-15 22:42:06 +00001757 if (VDecl->isBlockVarDecl()) {
1758 VarDecl::StorageClass SC = VDecl->getStorageClass();
Steve Naroffbb204692007-09-12 14:07:44 +00001759 if (SC == VarDecl::Extern) { // C99 6.7.8p5
Steve Naroff410e3e22007-09-12 20:13:48 +00001760 Diag(VDecl->getLocation(), diag::err_block_extern_cant_init);
Steve Naroff248a7532008-04-15 22:42:06 +00001761 VDecl->setInvalidDecl();
1762 } else if (!VDecl->isInvalidDecl()) {
Douglas Gregorf03d7c72008-11-05 15:29:30 +00001763 if (CheckInitializerTypes(Init, DclT, VDecl->getLocation(),
1764 VDecl->getName()))
Steve Naroff248a7532008-04-15 22:42:06 +00001765 VDecl->setInvalidDecl();
Anders Carlssonc5eb7312008-08-22 05:00:02 +00001766
1767 // C++ 3.6.2p2, allow dynamic initialization of static initializers.
1768 if (!getLangOptions().CPlusPlus) {
1769 if (SC == VarDecl::Static) // C99 6.7.8p4.
1770 CheckForConstantInitializer(Init, DclT);
1771 }
Steve Naroffbb204692007-09-12 14:07:44 +00001772 }
Steve Naroff248a7532008-04-15 22:42:06 +00001773 } else if (VDecl->isFileVarDecl()) {
1774 if (VDecl->getStorageClass() == VarDecl::Extern)
Steve Naroff410e3e22007-09-12 20:13:48 +00001775 Diag(VDecl->getLocation(), diag::warn_extern_init);
Steve Naroff248a7532008-04-15 22:42:06 +00001776 if (!VDecl->isInvalidDecl())
Douglas Gregorf03d7c72008-11-05 15:29:30 +00001777 if (CheckInitializerTypes(Init, DclT, VDecl->getLocation(),
1778 VDecl->getName()))
Steve Naroff248a7532008-04-15 22:42:06 +00001779 VDecl->setInvalidDecl();
Steve Naroffd0091aa2008-01-10 22:15:12 +00001780
Anders Carlssonc5eb7312008-08-22 05:00:02 +00001781 // C++ 3.6.2p2, allow dynamic initialization of static initializers.
1782 if (!getLangOptions().CPlusPlus) {
1783 // C99 6.7.8p4. All file scoped initializers need to be constant.
1784 CheckForConstantInitializer(Init, DclT);
1785 }
Steve Naroffbb204692007-09-12 14:07:44 +00001786 }
1787 // If the type changed, it means we had an incomplete type that was
1788 // completed by the initializer. For example:
1789 // int ary[] = { 1, 3, 5 };
1790 // "ary" transitions from a VariableArrayType to a ConstantArrayType.
Christopher Lamb48b12392007-11-29 19:09:19 +00001791 if (!VDecl->isInvalidDecl() && (DclT != SavT)) {
Steve Naroff410e3e22007-09-12 20:13:48 +00001792 VDecl->setType(DclT);
Christopher Lamb48b12392007-11-29 19:09:19 +00001793 Init->setType(DclT);
1794 }
Steve Naroffbb204692007-09-12 14:07:44 +00001795
1796 // Attach the initializer to the decl.
Steve Naroff410e3e22007-09-12 20:13:48 +00001797 VDecl->setInit(Init);
Steve Naroffbb204692007-09-12 14:07:44 +00001798 return;
1799}
1800
Douglas Gregor27c8dc02008-10-29 00:13:59 +00001801void Sema::ActOnUninitializedDecl(DeclTy *dcl) {
1802 Decl *RealDecl = static_cast<Decl *>(dcl);
1803
Argyrios Kyrtzidis48c2e902008-11-07 13:01:22 +00001804 // If there is no declaration, there was an error parsing it. Just ignore it.
1805 if (RealDecl == 0)
1806 return;
1807
Douglas Gregor27c8dc02008-10-29 00:13:59 +00001808 if (VarDecl *Var = dyn_cast<VarDecl>(RealDecl)) {
1809 QualType Type = Var->getType();
1810 // C++ [dcl.init.ref]p3:
1811 // The initializer can be omitted for a reference only in a
1812 // parameter declaration (8.3.5), in the declaration of a
1813 // function return type, in the declaration of a class member
1814 // within its class declaration (9.2), and where the extern
1815 // specifier is explicitly used.
Douglas Gregor18fe5682008-11-03 20:45:27 +00001816 if (Type->isReferenceType() && Var->getStorageClass() != VarDecl::Extern) {
Chris Lattnerd3a94e22008-11-20 06:06:08 +00001817 Diag(Var->getLocation(), diag::err_reference_var_requires_init)
1818 << Var->getName() << SourceRange(Var->getLocation(), Var->getLocation());
Douglas Gregor18fe5682008-11-03 20:45:27 +00001819 Var->setInvalidDecl();
1820 return;
1821 }
1822
1823 // C++ [dcl.init]p9:
1824 //
1825 // If no initializer is specified for an object, and the object
1826 // is of (possibly cv-qualified) non-POD class type (or array
1827 // thereof), the object shall be default-initialized; if the
1828 // object is of const-qualified type, the underlying class type
1829 // shall have a user-declared default constructor.
1830 if (getLangOptions().CPlusPlus) {
1831 QualType InitType = Type;
1832 if (const ArrayType *Array = Context.getAsArrayType(Type))
1833 InitType = Array->getElementType();
1834 if (InitType->isRecordType()) {
Douglas Gregorf03d7c72008-11-05 15:29:30 +00001835 const CXXConstructorDecl *Constructor
1836 = PerformInitializationByConstructor(InitType, 0, 0,
1837 Var->getLocation(),
1838 SourceRange(Var->getLocation(),
1839 Var->getLocation()),
1840 Var->getName(),
1841 IK_Default);
Douglas Gregor18fe5682008-11-03 20:45:27 +00001842 if (!Constructor)
1843 Var->setInvalidDecl();
1844 }
1845 }
Douglas Gregor27c8dc02008-10-29 00:13:59 +00001846
Douglas Gregor818ce482008-10-29 13:50:18 +00001847#if 0
1848 // FIXME: Temporarily disabled because we are not properly parsing
1849 // linkage specifications on declarations, e.g.,
1850 //
1851 // extern "C" const CGPoint CGPointerZero;
1852 //
Douglas Gregor27c8dc02008-10-29 00:13:59 +00001853 // C++ [dcl.init]p9:
1854 //
1855 // If no initializer is specified for an object, and the
1856 // object is of (possibly cv-qualified) non-POD class type (or
1857 // array thereof), the object shall be default-initialized; if
1858 // the object is of const-qualified type, the underlying class
1859 // type shall have a user-declared default
1860 // constructor. Otherwise, if no initializer is specified for
1861 // an object, the object and its subobjects, if any, have an
1862 // indeterminate initial value; if the object or any of its
1863 // subobjects are of const-qualified type, the program is
1864 // ill-formed.
1865 //
1866 // This isn't technically an error in C, so we don't diagnose it.
1867 //
1868 // FIXME: Actually perform the POD/user-defined default
1869 // constructor check.
1870 if (getLangOptions().CPlusPlus &&
Douglas Gregor818ce482008-10-29 13:50:18 +00001871 Context.getCanonicalType(Type).isConstQualified() &&
1872 Var->getStorageClass() != VarDecl::Extern)
Chris Lattnerf3a41af2008-11-20 06:38:18 +00001873 Diag(Var->getLocation(), diag::err_const_var_requires_init)
1874 << Var->getName()
1875 << SourceRange(Var->getLocation(), Var->getLocation());
Douglas Gregor818ce482008-10-29 13:50:18 +00001876#endif
Douglas Gregor27c8dc02008-10-29 00:13:59 +00001877 }
1878}
1879
Reid Spencer5f016e22007-07-11 17:01:13 +00001880/// The declarators are chained together backwards, reverse the list.
1881Sema::DeclTy *Sema::FinalizeDeclaratorGroup(Scope *S, DeclTy *group) {
1882 // Often we have single declarators, handle them quickly.
Steve Naroff94745042007-09-13 23:52:58 +00001883 Decl *GroupDecl = static_cast<Decl*>(group);
1884 if (GroupDecl == 0)
Steve Naroffbb204692007-09-12 14:07:44 +00001885 return 0;
Steve Naroff94745042007-09-13 23:52:58 +00001886
1887 ScopedDecl *Group = dyn_cast<ScopedDecl>(GroupDecl);
1888 ScopedDecl *NewGroup = 0;
Steve Naroffbb204692007-09-12 14:07:44 +00001889 if (Group->getNextDeclarator() == 0)
Reid Spencer5f016e22007-07-11 17:01:13 +00001890 NewGroup = Group;
Steve Naroffbb204692007-09-12 14:07:44 +00001891 else { // reverse the list.
1892 while (Group) {
Steve Naroff94745042007-09-13 23:52:58 +00001893 ScopedDecl *Next = Group->getNextDeclarator();
Steve Naroffbb204692007-09-12 14:07:44 +00001894 Group->setNextDeclarator(NewGroup);
1895 NewGroup = Group;
1896 Group = Next;
1897 }
1898 }
1899 // Perform semantic analysis that depends on having fully processed both
1900 // the declarator and initializer.
Steve Naroff94745042007-09-13 23:52:58 +00001901 for (ScopedDecl *ID = NewGroup; ID; ID = ID->getNextDeclarator()) {
Steve Naroffbb204692007-09-12 14:07:44 +00001902 VarDecl *IDecl = dyn_cast<VarDecl>(ID);
1903 if (!IDecl)
1904 continue;
Steve Naroffbb204692007-09-12 14:07:44 +00001905 QualType T = IDecl->getType();
1906
1907 // C99 6.7.5.2p2: If an identifier is declared to be an object with
1908 // static storage duration, it shall not have a variable length array.
Steve Naroff248a7532008-04-15 22:42:06 +00001909 if ((IDecl->isFileVarDecl() || IDecl->isBlockVarDecl()) &&
1910 IDecl->getStorageClass() == VarDecl::Static) {
Chris Lattnerc63a1f22008-08-04 07:31:14 +00001911 if (T->isVariableArrayType()) {
Eli Friedmanc5773c42008-02-15 18:16:39 +00001912 Diag(IDecl->getLocation(), diag::err_typecheck_illegal_vla);
1913 IDecl->setInvalidDecl();
Steve Naroffbb204692007-09-12 14:07:44 +00001914 }
1915 }
1916 // Block scope. C99 6.7p7: If an identifier for an object is declared with
1917 // no linkage (C99 6.2.2p6), the type for the object shall be complete...
Steve Naroff248a7532008-04-15 22:42:06 +00001918 if (IDecl->isBlockVarDecl() &&
1919 IDecl->getStorageClass() != VarDecl::Extern) {
Chris Lattnerfd89bc82008-04-02 01:05:10 +00001920 if (T->isIncompleteType() && !IDecl->isInvalidDecl()) {
Chris Lattnerf3a41af2008-11-20 06:38:18 +00001921 Diag(IDecl->getLocation(), diag::err_typecheck_decl_incomplete_type)
1922 << T.getAsString();
Steve Naroffbb204692007-09-12 14:07:44 +00001923 IDecl->setInvalidDecl();
1924 }
1925 }
1926 // File scope. C99 6.9.2p2: A declaration of an identifier for and
1927 // object that has file scope without an initializer, and without a
1928 // storage-class specifier or with the storage-class specifier "static",
1929 // constitutes a tentative definition. Note: A tentative definition with
1930 // external linkage is valid (C99 6.2.2p5).
Steve Naroffff9eb1f2008-08-08 17:50:35 +00001931 if (isTentativeDefinition(IDecl)) {
Eli Friedman9db13972008-02-15 12:53:51 +00001932 if (T->isIncompleteArrayType()) {
Steve Naroff9a75f8a2008-01-18 20:40:52 +00001933 // C99 6.9.2 (p2, p5): Implicit initialization causes an incomplete
1934 // array to be completed. Don't issue a diagnostic.
Chris Lattnerfd89bc82008-04-02 01:05:10 +00001935 } else if (T->isIncompleteType() && !IDecl->isInvalidDecl()) {
Steve Naroff9a75f8a2008-01-18 20:40:52 +00001936 // C99 6.9.2p3: If the declaration of an identifier for an object is
1937 // a tentative definition and has internal linkage (C99 6.2.2p3), the
1938 // declared type shall not be an incomplete type.
Chris Lattnerf3a41af2008-11-20 06:38:18 +00001939 Diag(IDecl->getLocation(), diag::err_typecheck_decl_incomplete_type)
1940 << T.getAsString();
Steve Naroffbb204692007-09-12 14:07:44 +00001941 IDecl->setInvalidDecl();
1942 }
1943 }
Steve Naroffff9eb1f2008-08-08 17:50:35 +00001944 if (IDecl->isFileVarDecl())
1945 CheckForFileScopedRedefinitions(S, IDecl);
Reid Spencer5f016e22007-07-11 17:01:13 +00001946 }
1947 return NewGroup;
1948}
Steve Naroffe1223f72007-08-28 03:03:08 +00001949
Chris Lattner04421082008-04-08 04:40:51 +00001950/// ActOnParamDeclarator - Called from Parser::ParseFunctionDeclarator()
1951/// to introduce parameters into function prototype scope.
1952Sema::DeclTy *
1953Sema::ActOnParamDeclarator(Scope *S, Declarator &D) {
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +00001954 // FIXME: disallow CXXScopeSpec for param declarators.
Chris Lattner985abd92008-06-26 06:49:43 +00001955 const DeclSpec &DS = D.getDeclSpec();
Chris Lattner04421082008-04-08 04:40:51 +00001956
1957 // Verify C99 6.7.5.3p2: The only SCS allowed is 'register'.
Daniel Dunbar33ad0122008-09-03 21:54:21 +00001958 VarDecl::StorageClass StorageClass = VarDecl::None;
1959 if (DS.getStorageClassSpec() == DeclSpec::SCS_register) {
1960 StorageClass = VarDecl::Register;
1961 } else if (DS.getStorageClassSpec() != DeclSpec::SCS_unspecified) {
Chris Lattner04421082008-04-08 04:40:51 +00001962 Diag(DS.getStorageClassSpecLoc(),
1963 diag::err_invalid_storage_class_in_func_decl);
Chris Lattner985abd92008-06-26 06:49:43 +00001964 D.getMutableDeclSpec().ClearStorageClassSpecs();
Chris Lattner04421082008-04-08 04:40:51 +00001965 }
1966 if (DS.isThreadSpecified()) {
1967 Diag(DS.getThreadSpecLoc(),
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
Douglas Gregor6d6eb572008-05-07 04:49:29 +00001972 // Check that there are no default arguments inside the type of this
1973 // parameter (C++ only).
1974 if (getLangOptions().CPlusPlus)
1975 CheckExtraCXXDefaultArguments(D);
1976
Chris Lattner04421082008-04-08 04:40:51 +00001977 // In this context, we *do not* check D.getInvalidType(). If the declarator
1978 // type was invalid, GetTypeForDeclarator() still returns a "valid" type,
1979 // though it will not reflect the user specified type.
1980 QualType parmDeclType = GetTypeForDeclarator(D, S);
1981
1982 assert(!parmDeclType.isNull() && "GetTypeForDeclarator() returned null type");
1983
Reid Spencer5f016e22007-07-11 17:01:13 +00001984 // TODO: CHECK FOR CONFLICTS, multiple decls with same name in one scope.
1985 // Can this happen for params? We already checked that they don't conflict
1986 // among each other. Here they can only shadow globals, which is ok.
Chris Lattner04421082008-04-08 04:40:51 +00001987 IdentifierInfo *II = D.getIdentifier();
1988 if (Decl *PrevDecl = LookupDecl(II, Decl::IDNS_Ordinary, S)) {
1989 if (S->isDeclScope(PrevDecl)) {
Chris Lattner08631c52008-11-23 21:45:46 +00001990 Diag(D.getIdentifierLoc(), diag::err_param_redefinition) << II;
Chris Lattner04421082008-04-08 04:40:51 +00001991
1992 // Recover by removing the name
1993 II = 0;
1994 D.SetIdentifier(0, D.getIdentifierLoc());
1995 }
Reid Spencer5f016e22007-07-11 17:01:13 +00001996 }
Steve Naroff6a9f3e32007-08-07 22:44:21 +00001997
1998 // Perform the default function/array conversion (C99 6.7.5.3p[7,8]).
1999 // Doing the promotion here has a win and a loss. The win is the type for
2000 // both Decl's and DeclRefExpr's will match (a convenient invariant for the
2001 // code generator). The loss is the orginal type isn't preserved. For example:
2002 //
2003 // void func(int parmvardecl[5]) { // convert "int [5]" to "int *"
2004 // int blockvardecl[5];
2005 // sizeof(parmvardecl); // size == 4
2006 // sizeof(blockvardecl); // size == 20
2007 // }
2008 //
2009 // For expressions, all implicit conversions are captured using the
2010 // ImplicitCastExpr AST node (we have no such mechanism for Decl's).
2011 //
2012 // FIXME: If a source translation tool needs to see the original type, then
2013 // we need to consider storing both types (in ParmVarDecl)...
2014 //
Chris Lattnere6327742008-04-02 05:18:44 +00002015 if (parmDeclType->isArrayType()) {
Chris Lattner529bd022008-01-02 22:50:48 +00002016 // int x[restrict 4] -> int *restrict
Chris Lattnere6327742008-04-02 05:18:44 +00002017 parmDeclType = Context.getArrayDecayedType(parmDeclType);
Chris Lattner529bd022008-01-02 22:50:48 +00002018 } else if (parmDeclType->isFunctionType())
Steve Naroff6a9f3e32007-08-07 22:44:21 +00002019 parmDeclType = Context.getPointerType(parmDeclType);
2020
Chris Lattner04421082008-04-08 04:40:51 +00002021 ParmVarDecl *New = ParmVarDecl::Create(Context, CurContext,
2022 D.getIdentifierLoc(), II,
Daniel Dunbar33ad0122008-09-03 21:54:21 +00002023 parmDeclType, StorageClass,
Chris Lattner04421082008-04-08 04:40:51 +00002024 0, 0);
Anders Carlssonf78915f2008-02-15 07:04:12 +00002025
Chris Lattner04421082008-04-08 04:40:51 +00002026 if (D.getInvalidType())
Steve Naroff53a32342007-08-28 18:45:29 +00002027 New->setInvalidDecl();
2028
Argyrios Kyrtzidis87f3ff02008-04-12 00:47:19 +00002029 if (II)
2030 PushOnScopeChains(New, S);
Nate Begemanb7894b52008-02-17 21:20:31 +00002031
Chris Lattner3ff30c82008-06-29 00:02:00 +00002032 ProcessDeclAttributes(New, D);
Reid Spencer5f016e22007-07-11 17:01:13 +00002033 return New;
Chris Lattner04421082008-04-08 04:40:51 +00002034
Reid Spencer5f016e22007-07-11 17:01:13 +00002035}
Fariborz Jahanian306d68f2007-11-08 23:49:49 +00002036
Chris Lattnerb652cea2007-10-09 17:14:05 +00002037Sema::DeclTy *Sema::ActOnStartOfFunctionDef(Scope *FnBodyScope, Declarator &D) {
Argyrios Kyrtzidis53d0ea52008-06-28 06:07:14 +00002038 assert(getCurFunctionDecl() == 0 && "Function parsing confused");
Reid Spencer5f016e22007-07-11 17:01:13 +00002039 assert(D.getTypeObject(0).Kind == DeclaratorChunk::Function &&
2040 "Not a function declarator!");
2041 DeclaratorChunk::FunctionTypeInfo &FTI = D.getTypeObject(0).Fun;
Chris Lattner04421082008-04-08 04:40:51 +00002042
Reid Spencer5f016e22007-07-11 17:01:13 +00002043 // Verify 6.9.1p6: 'every identifier in the identifier list shall be declared'
2044 // for a K&R function.
2045 if (!FTI.hasPrototype) {
2046 for (unsigned i = 0, e = FTI.NumArgs; i != e; ++i) {
Chris Lattner04421082008-04-08 04:40:51 +00002047 if (FTI.ArgInfo[i].Param == 0) {
Chris Lattner3c73c412008-11-19 08:23:25 +00002048 Diag(FTI.ArgInfo[i].IdentLoc, diag::ext_param_not_declared)
2049 << FTI.ArgInfo[i].Ident;
Reid Spencer5f016e22007-07-11 17:01:13 +00002050 // Implicitly declare the argument as type 'int' for lack of a better
2051 // type.
Chris Lattner04421082008-04-08 04:40:51 +00002052 DeclSpec DS;
2053 const char* PrevSpec; // unused
2054 DS.SetTypeSpecType(DeclSpec::TST_int, FTI.ArgInfo[i].IdentLoc,
2055 PrevSpec);
2056 Declarator ParamD(DS, Declarator::KNRTypeListContext);
2057 ParamD.SetIdentifier(FTI.ArgInfo[i].Ident, FTI.ArgInfo[i].IdentLoc);
2058 FTI.ArgInfo[i].Param = ActOnParamDeclarator(FnBodyScope, ParamD);
Reid Spencer5f016e22007-07-11 17:01:13 +00002059 }
2060 }
Reid Spencer5f016e22007-07-11 17:01:13 +00002061 } else {
Chris Lattner04421082008-04-08 04:40:51 +00002062 // FIXME: Diagnose arguments without names in C.
Reid Spencer5f016e22007-07-11 17:01:13 +00002063 }
2064
2065 Scope *GlobalScope = FnBodyScope->getParent();
Steve Naroffadbbd0c2008-01-14 20:51:29 +00002066
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +00002067 return ActOnStartOfFunctionDef(FnBodyScope,
Daniel Dunbar914701e2008-08-05 16:28:08 +00002068 ActOnDeclarator(GlobalScope, D, 0));
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +00002069}
2070
2071Sema::DeclTy *Sema::ActOnStartOfFunctionDef(Scope *FnBodyScope, DeclTy *D) {
2072 Decl *decl = static_cast<Decl*>(D);
Chris Lattnere9ba3232008-02-16 01:20:36 +00002073 FunctionDecl *FD = cast<FunctionDecl>(decl);
Douglas Gregor6fc17ff2008-10-29 15:10:40 +00002074
2075 // See if this is a redefinition.
2076 const FunctionDecl *Definition;
2077 if (FD->getBody(Definition)) {
Chris Lattner08631c52008-11-23 21:45:46 +00002078 Diag(FD->getLocation(), diag::err_redefinition) << FD->getDeclName();
Douglas Gregor6fc17ff2008-10-29 15:10:40 +00002079 Diag(Definition->getLocation(), diag::err_previous_definition);
2080 }
2081
Chris Lattnerb048c982008-04-06 04:47:34 +00002082 PushDeclContext(FD);
Chris Lattner04421082008-04-08 04:40:51 +00002083
2084 // Check the validity of our function parameters
2085 CheckParmsForFunctionDef(FD);
2086
2087 // Introduce our parameters into the function scope
2088 for (unsigned p = 0, NumParams = FD->getNumParams(); p < NumParams; ++p) {
2089 ParmVarDecl *Param = FD->getParamDecl(p);
2090 // If this has an identifier, add it to the scope stack.
Argyrios Kyrtzidis87f3ff02008-04-12 00:47:19 +00002091 if (Param->getIdentifier())
2092 PushOnScopeChains(Param, FnBodyScope);
Reid Spencer5f016e22007-07-11 17:01:13 +00002093 }
Chris Lattner04421082008-04-08 04:40:51 +00002094
Reid Spencer5f016e22007-07-11 17:01:13 +00002095 return FD;
2096}
2097
Steve Naroffd6d054d2007-11-11 23:20:51 +00002098Sema::DeclTy *Sema::ActOnFinishFunctionBody(DeclTy *D, StmtTy *Body) {
2099 Decl *dcl = static_cast<Decl *>(D);
Steve Naroff394f3f42008-07-25 17:57:26 +00002100 if (FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(dcl)) {
Steve Naroffd6d054d2007-11-11 23:20:51 +00002101 FD->setBody((Stmt*)Body);
Argyrios Kyrtzidis53d0ea52008-06-28 06:07:14 +00002102 assert(FD == getCurFunctionDecl() && "Function parsing confused");
Steve Naroff394f3f42008-07-25 17:57:26 +00002103 } else if (ObjCMethodDecl *MD = dyn_cast_or_null<ObjCMethodDecl>(dcl)) {
Steve Naroffd6d054d2007-11-11 23:20:51 +00002104 MD->setBody((Stmt*)Body);
Steve Naroff394f3f42008-07-25 17:57:26 +00002105 } else
2106 return 0;
Chris Lattnerb048c982008-04-06 04:47:34 +00002107 PopDeclContext();
Reid Spencer5f016e22007-07-11 17:01:13 +00002108 // Verify and clean out per-function state.
2109
2110 // Check goto/label use.
2111 for (llvm::DenseMap<IdentifierInfo*, LabelStmt*>::iterator
2112 I = LabelMap.begin(), E = LabelMap.end(); I != E; ++I) {
2113 // Verify that we have no forward references left. If so, there was a goto
2114 // or address of a label taken, but no definition of it. Label fwd
2115 // definitions are indicated with a null substmt.
2116 if (I->second->getSubStmt() == 0) {
2117 LabelStmt *L = I->second;
2118 // Emit error.
Chris Lattnerf3a41af2008-11-20 06:38:18 +00002119 Diag(L->getIdentLoc(), diag::err_undeclared_label_use) << L->getName();
Reid Spencer5f016e22007-07-11 17:01:13 +00002120
2121 // At this point, we have gotos that use the bogus label. Stitch it into
2122 // the function body so that they aren't leaked and that the AST is well
2123 // formed.
Chris Lattner0cbc2152008-01-25 00:01:10 +00002124 if (Body) {
2125 L->setSubStmt(new NullStmt(L->getIdentLoc()));
2126 cast<CompoundStmt>((Stmt*)Body)->push_back(L);
2127 } else {
2128 // The whole function wasn't parsed correctly, just delete this.
2129 delete L;
2130 }
Reid Spencer5f016e22007-07-11 17:01:13 +00002131 }
2132 }
2133 LabelMap.clear();
2134
Steve Naroffd6d054d2007-11-11 23:20:51 +00002135 return D;
Fariborz Jahanian60fbca02007-11-10 16:31:34 +00002136}
2137
Reid Spencer5f016e22007-07-11 17:01:13 +00002138/// ImplicitlyDefineFunction - An undeclared identifier was used in a function
2139/// call, forming a call to an implicitly defined function (per C99 6.5.1p2).
Steve Naroff8c9f13e2007-09-16 16:16:00 +00002140ScopedDecl *Sema::ImplicitlyDefineFunction(SourceLocation Loc,
2141 IdentifierInfo &II, Scope *S) {
Chris Lattner37d10842008-05-05 21:18:06 +00002142 // Extension in C99. Legal in C90, but warn about it.
2143 if (getLangOptions().C99)
Chris Lattner3c73c412008-11-19 08:23:25 +00002144 Diag(Loc, diag::ext_implicit_function_decl) << &II;
Chris Lattner37d10842008-05-05 21:18:06 +00002145 else
Chris Lattner3c73c412008-11-19 08:23:25 +00002146 Diag(Loc, diag::warn_implicit_function_decl) << &II;
Reid Spencer5f016e22007-07-11 17:01:13 +00002147
2148 // FIXME: handle stuff like:
2149 // void foo() { extern float X(); }
2150 // void bar() { X(); } <-- implicit decl for X in another scope.
2151
2152 // Set a Declarator for the implicit definition: int foo();
2153 const char *Dummy;
2154 DeclSpec DS;
2155 bool Error = DS.SetTypeSpecType(DeclSpec::TST_int, Loc, Dummy);
2156 Error = Error; // Silence warning.
2157 assert(!Error && "Error setting up implicit decl!");
2158 Declarator D(DS, Declarator::BlockContext);
Argyrios Kyrtzidis971c4fa2008-10-24 21:46:40 +00002159 D.AddTypeInfo(DeclaratorChunk::getFunction(false, false, 0, 0, 0, Loc));
Reid Spencer5f016e22007-07-11 17:01:13 +00002160 D.SetIdentifier(&II, Loc);
2161
Argyrios Kyrtzidis93213bb2008-05-01 21:04:16 +00002162 // Insert this function into translation-unit scope.
2163
2164 DeclContext *PrevDC = CurContext;
2165 CurContext = Context.getTranslationUnitDecl();
2166
Steve Naroffe2ef8152008-04-04 14:32:09 +00002167 FunctionDecl *FD =
Daniel Dunbar914701e2008-08-05 16:28:08 +00002168 dyn_cast<FunctionDecl>(static_cast<Decl*>(ActOnDeclarator(TUScope, D, 0)));
Steve Naroffe2ef8152008-04-04 14:32:09 +00002169 FD->setImplicit();
Argyrios Kyrtzidis93213bb2008-05-01 21:04:16 +00002170
2171 CurContext = PrevDC;
2172
Steve Naroffe2ef8152008-04-04 14:32:09 +00002173 return FD;
Reid Spencer5f016e22007-07-11 17:01:13 +00002174}
2175
2176
Chris Lattner41af0932007-11-14 06:34:38 +00002177TypedefDecl *Sema::ParseTypedefDecl(Scope *S, Declarator &D, QualType T,
Steve Naroff94745042007-09-13 23:52:58 +00002178 ScopedDecl *LastDeclarator) {
Reid Spencer5f016e22007-07-11 17:01:13 +00002179 assert(D.getIdentifier() && "Wrong callback for declspec without declarator");
Steve Naroff5912a352007-08-28 20:14:24 +00002180 assert(!T.isNull() && "GetTypeForDeclarator() returned null type");
Reid Spencer5f016e22007-07-11 17:01:13 +00002181
2182 // Scope manipulation handled by caller.
Chris Lattner0ed844b2008-04-04 06:12:32 +00002183 TypedefDecl *NewTD = TypedefDecl::Create(Context, CurContext,
2184 D.getIdentifierLoc(),
Chris Lattner6c2b6eb2008-03-15 06:12:44 +00002185 D.getIdentifier(),
Chris Lattnerc63e6602008-03-15 21:32:50 +00002186 T, LastDeclarator);
Steve Naroff5912a352007-08-28 20:14:24 +00002187 if (D.getInvalidType())
2188 NewTD->setInvalidDecl();
2189 return NewTD;
Reid Spencer5f016e22007-07-11 17:01:13 +00002190}
2191
Steve Naroff08d92e42007-09-15 18:49:24 +00002192/// ActOnTag - This is invoked when we see 'struct foo' or 'struct {'. In the
Reid Spencer5f016e22007-07-11 17:01:13 +00002193/// former case, Name will be non-null. In the later case, Name will be null.
2194/// TagType indicates what kind of tag this is. TK indicates whether this is a
2195/// reference/declaration/definition of a tag.
Steve Naroff08d92e42007-09-15 18:49:24 +00002196Sema::DeclTy *Sema::ActOnTag(Scope *S, unsigned TagType, TagKind TK,
Argyrios Kyrtzidiseb83ecd2008-11-08 16:45:02 +00002197 SourceLocation KWLoc, const CXXScopeSpec &SS,
2198 IdentifierInfo *Name, SourceLocation NameLoc,
2199 AttributeList *Attr) {
Reid Spencer5f016e22007-07-11 17:01:13 +00002200 // If this is a use of an existing tag, it must have a name.
2201 assert((Name != 0 || TK == TK_Definition) &&
2202 "Nameless record must be a definition!");
2203
Argyrios Kyrtzidis39ba4ae2008-06-09 23:19:58 +00002204 TagDecl::TagKind Kind;
Reid Spencer5f016e22007-07-11 17:01:13 +00002205 switch (TagType) {
2206 default: assert(0 && "Unknown tag type!");
Argyrios Kyrtzidis39ba4ae2008-06-09 23:19:58 +00002207 case DeclSpec::TST_struct: Kind = TagDecl::TK_struct; break;
2208 case DeclSpec::TST_union: Kind = TagDecl::TK_union; break;
2209 case DeclSpec::TST_class: Kind = TagDecl::TK_class; break;
2210 case DeclSpec::TST_enum: Kind = TagDecl::TK_enum; break;
Reid Spencer5f016e22007-07-11 17:01:13 +00002211 }
2212
Ted Kremenek4b7c9832008-09-05 17:16:31 +00002213 // Two code paths: a new one for structs/unions/classes where we create
2214 // separate decls for forward declarations, and an old (eventually to
2215 // be removed) code path for enums.
2216 if (Kind != TagDecl::TK_enum)
Argyrios Kyrtzidis630c81b2008-11-09 22:09:58 +00002217 return ActOnTagStruct(S, Kind, TK, KWLoc, SS, Name, NameLoc, Attr);
Ted Kremenek4b7c9832008-09-05 17:16:31 +00002218
Argyrios Kyrtzidis0f84a232008-11-09 22:53:32 +00002219 DeclContext *DC = CurContext;
2220 ScopedDecl *PrevDecl = 0;
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +00002221
Argyrios Kyrtzidis630c81b2008-11-09 22:09:58 +00002222 if (Name && SS.isNotEmpty()) {
2223 // We have a nested-name tag ('struct foo::bar').
2224
2225 // Check for invalid 'foo::'.
Argyrios Kyrtzidis0f84a232008-11-09 22:53:32 +00002226 if (SS.isInvalid()) {
Argyrios Kyrtzidis630c81b2008-11-09 22:09:58 +00002227 Name = 0;
2228 goto CreateNewDecl;
2229 }
2230
Argyrios Kyrtzidis0f84a232008-11-09 22:53:32 +00002231 DC = static_cast<DeclContext*>(SS.getScopeRep());
2232 // Look-up name inside 'foo::'.
Argyrios Kyrtzidis630c81b2008-11-09 22:09:58 +00002233 PrevDecl = dyn_cast_or_null<TagDecl>(LookupDecl(Name, Decl::IDNS_Tag,S,DC));
2234
2235 // A tag 'foo::bar' must already exist.
2236 if (PrevDecl == 0) {
Chris Lattner3c73c412008-11-19 08:23:25 +00002237 Diag(NameLoc, diag::err_not_tag_in_scope) << Name << SS.getRange();
Argyrios Kyrtzidis630c81b2008-11-09 22:09:58 +00002238 Name = 0;
2239 goto CreateNewDecl;
2240 }
2241 } else {
2242 // If this is a named struct, check to see if there was a previous forward
2243 // declaration or definition.
2244 // Use ScopedDecl instead of TagDecl, because a NamespaceDecl may come up.
2245 PrevDecl = dyn_cast_or_null<ScopedDecl>(LookupDecl(Name, Decl::IDNS_Tag,S));
2246 }
2247
Ted Kremenek7e8cc572008-09-02 21:26:19 +00002248 if (PrevDecl) {
Argyrios Kyrtzidis2d1c5d32008-04-27 13:50:30 +00002249 assert((isa<TagDecl>(PrevDecl) || isa<NamespaceDecl>(PrevDecl)) &&
2250 "unexpected Decl type");
2251 if (TagDecl *PrevTagDecl = dyn_cast<TagDecl>(PrevDecl)) {
Chris Lattner14943b92008-07-03 03:30:58 +00002252 // If this is a use of a previous tag, or if the tag is already declared
2253 // in the same scope (so that the definition/declaration completes or
Argyrios Kyrtzidis2d1c5d32008-04-27 13:50:30 +00002254 // rementions the tag), reuse the decl.
Argyrios Kyrtzidis0f84a232008-11-09 22:53:32 +00002255 if (TK == TK_Reference || isDeclInScope(PrevDecl, DC, S)) {
Chris Lattner14943b92008-07-03 03:30:58 +00002256 // Make sure that this wasn't declared as an enum and now used as a
2257 // struct or something similar.
Argyrios Kyrtzidis39ba4ae2008-06-09 23:19:58 +00002258 if (PrevTagDecl->getTagKind() != Kind) {
Chris Lattner3c73c412008-11-19 08:23:25 +00002259 Diag(KWLoc, diag::err_use_with_wrong_tag) << Name;
Argyrios Kyrtzidis2d1c5d32008-04-27 13:50:30 +00002260 Diag(PrevDecl->getLocation(), diag::err_previous_use);
Chris Lattner14943b92008-07-03 03:30:58 +00002261 // Recover by making this an anonymous redefinition.
Argyrios Kyrtzidis2d1c5d32008-04-27 13:50:30 +00002262 Name = 0;
Chris Lattner14943b92008-07-03 03:30:58 +00002263 PrevDecl = 0;
Argyrios Kyrtzidis2d1c5d32008-04-27 13:50:30 +00002264 } else {
Chris Lattner14943b92008-07-03 03:30:58 +00002265 // If this is a use or a forward declaration, we're good.
2266 if (TK != TK_Definition)
2267 return PrevDecl;
2268
2269 // Diagnose attempts to redefine a tag.
2270 if (PrevTagDecl->isDefinition()) {
Chris Lattner3c73c412008-11-19 08:23:25 +00002271 Diag(NameLoc, diag::err_redefinition) << Name;
Chris Lattner14943b92008-07-03 03:30:58 +00002272 Diag(PrevDecl->getLocation(), diag::err_previous_definition);
2273 // If this is a redefinition, recover by making this struct be
2274 // anonymous, which will make any later references get the previous
2275 // definition.
2276 Name = 0;
2277 } else {
2278 // Okay, this is definition of a previously declared or referenced
2279 // tag. Move the location of the decl to be the definition site.
2280 PrevDecl->setLocation(NameLoc);
2281 return PrevDecl;
2282 }
Argyrios Kyrtzidis2d1c5d32008-04-27 13:50:30 +00002283 }
Reid Spencer5f016e22007-07-11 17:01:13 +00002284 }
Argyrios Kyrtzidis2d1c5d32008-04-27 13:50:30 +00002285 // If we get here, this is a definition of a new struct type in a nested
2286 // scope, e.g. "struct foo; void bar() { struct foo; }", just create a new
2287 // type.
2288 } else {
Argyrios Kyrtzidisb02ef242008-07-16 07:45:46 +00002289 // PrevDecl is a namespace.
Argyrios Kyrtzidis0f84a232008-11-09 22:53:32 +00002290 if (isDeclInScope(PrevDecl, DC, S)) {
Ted Kremeneka89d1972008-09-03 18:03:35 +00002291 // The tag name clashes with a namespace name, issue an error and
2292 // recover by making this tag be anonymous.
Chris Lattner3c73c412008-11-19 08:23:25 +00002293 Diag(NameLoc, diag::err_redefinition_different_kind) << Name;
Argyrios Kyrtzidisb02ef242008-07-16 07:45:46 +00002294 Diag(PrevDecl->getLocation(), diag::err_previous_definition);
2295 Name = 0;
2296 }
Reid Spencer5f016e22007-07-11 17:01:13 +00002297 }
Reid Spencer5f016e22007-07-11 17:01:13 +00002298 }
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +00002299
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +00002300 CreateNewDecl:
Reid Spencer5f016e22007-07-11 17:01:13 +00002301
2302 // If there is an identifier, use the location of the identifier as the
2303 // location of the decl, otherwise use the location of the struct/union
2304 // keyword.
2305 SourceLocation Loc = NameLoc.isValid() ? NameLoc : KWLoc;
2306
2307 // Otherwise, if this is the first time we've seen this tag, create the decl.
2308 TagDecl *New;
Argyrios Kyrtzidis39ba4ae2008-06-09 23:19:58 +00002309 if (Kind == TagDecl::TK_enum) {
Reid Spencer5f016e22007-07-11 17:01:13 +00002310 // FIXME: Tag decls should be chained to any simultaneous vardecls, e.g.:
2311 // enum X { A, B, C } D; D should chain to X.
Argyrios Kyrtzidis0f84a232008-11-09 22:53:32 +00002312 New = EnumDecl::Create(Context, DC, Loc, Name, 0);
Reid Spencer5f016e22007-07-11 17:01:13 +00002313 // If this is an undefined enum, warn.
2314 if (TK != TK_Definition) Diag(Loc, diag::ext_forward_ref_enum);
Argyrios Kyrtzidis39ba4ae2008-06-09 23:19:58 +00002315 } else {
2316 // struct/union/class
2317
Reid Spencer5f016e22007-07-11 17:01:13 +00002318 // FIXME: Tag decls should be chained to any simultaneous vardecls, e.g.:
2319 // struct X { int A; } D; D should chain to X.
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +00002320 if (getLangOptions().CPlusPlus)
Ted Kremenek2b345eb2008-09-05 17:39:33 +00002321 // FIXME: Look for a way to use RecordDecl for simple structs.
Argyrios Kyrtzidis0f84a232008-11-09 22:53:32 +00002322 New = CXXRecordDecl::Create(Context, Kind, DC, Loc, Name);
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +00002323 else
Argyrios Kyrtzidis0f84a232008-11-09 22:53:32 +00002324 New = RecordDecl::Create(Context, Kind, DC, Loc, Name);
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +00002325 }
Reid Spencer5f016e22007-07-11 17:01:13 +00002326
2327 // If this has an identifier, add it to the scope stack.
2328 if (Name) {
Chris Lattner31e05722007-08-26 06:24:45 +00002329 // The scope passed in may not be a decl scope. Zip up the scope tree until
2330 // we find one that is.
2331 while ((S->getFlags() & Scope::DeclScope) == 0)
2332 S = S->getParent();
2333
2334 // Add it to the decl chain.
Argyrios Kyrtzidis87f3ff02008-04-12 00:47:19 +00002335 PushOnScopeChains(New, S);
Reid Spencer5f016e22007-07-11 17:01:13 +00002336 }
Chris Lattnere1e79852008-02-06 00:51:33 +00002337
Chris Lattnerf2e4bd52008-06-28 23:58:55 +00002338 if (Attr)
2339 ProcessDeclAttributeList(New, Attr);
Argyrios Kyrtzidis52393042008-11-09 23:41:00 +00002340
2341 // Set the lexical context. If the tag has a C++ scope specifier, the
2342 // lexical context will be different from the semantic context.
2343 New->setLexicalDeclContext(CurContext);
2344
Reid Spencer5f016e22007-07-11 17:01:13 +00002345 return New;
2346}
2347
Ted Kremenek4b7c9832008-09-05 17:16:31 +00002348/// ActOnTagStruct - New "ActOnTag" logic for structs/unions/classes. Unlike
2349/// the logic for enums, we create separate decls for forward declarations.
2350/// This is called by ActOnTag, but eventually will replace its logic.
2351Sema::DeclTy *Sema::ActOnTagStruct(Scope *S, TagDecl::TagKind Kind, TagKind TK,
Argyrios Kyrtzidis630c81b2008-11-09 22:09:58 +00002352 SourceLocation KWLoc, const CXXScopeSpec &SS,
2353 IdentifierInfo *Name, SourceLocation NameLoc,
2354 AttributeList *Attr) {
Argyrios Kyrtzidis0f84a232008-11-09 22:53:32 +00002355 DeclContext *DC = CurContext;
2356 ScopedDecl *PrevDecl = 0;
Argyrios Kyrtzidis630c81b2008-11-09 22:09:58 +00002357
2358 if (Name && SS.isNotEmpty()) {
2359 // We have a nested-name tag ('struct foo::bar').
2360
2361 // Check for invalid 'foo::'.
Argyrios Kyrtzidis0f84a232008-11-09 22:53:32 +00002362 if (SS.isInvalid()) {
Argyrios Kyrtzidis630c81b2008-11-09 22:09:58 +00002363 Name = 0;
2364 goto CreateNewDecl;
2365 }
2366
Argyrios Kyrtzidis0f84a232008-11-09 22:53:32 +00002367 DC = static_cast<DeclContext*>(SS.getScopeRep());
2368 // Look-up name inside 'foo::'.
Argyrios Kyrtzidis630c81b2008-11-09 22:09:58 +00002369 PrevDecl = dyn_cast_or_null<TagDecl>(LookupDecl(Name, Decl::IDNS_Tag,S,DC));
2370
2371 // A tag 'foo::bar' must already exist.
2372 if (PrevDecl == 0) {
Chris Lattner3c73c412008-11-19 08:23:25 +00002373 Diag(NameLoc, diag::err_not_tag_in_scope) << Name << SS.getRange();
Argyrios Kyrtzidis630c81b2008-11-09 22:09:58 +00002374 Name = 0;
2375 goto CreateNewDecl;
2376 }
2377 } else {
2378 // If this is a named struct, check to see if there was a previous forward
2379 // declaration or definition.
2380 // Use ScopedDecl instead of TagDecl, because a NamespaceDecl may come up.
2381 PrevDecl = dyn_cast_or_null<ScopedDecl>(LookupDecl(Name, Decl::IDNS_Tag,S));
2382 }
Ted Kremenek4b7c9832008-09-05 17:16:31 +00002383
2384 if (PrevDecl) {
2385 assert((isa<TagDecl>(PrevDecl) || isa<NamespaceDecl>(PrevDecl)) &&
2386 "unexpected Decl type");
2387
2388 if (TagDecl *PrevTagDecl = dyn_cast<TagDecl>(PrevDecl)) {
2389 // If this is a use of a previous tag, or if the tag is already declared
2390 // in the same scope (so that the definition/declaration completes or
2391 // rementions the tag), reuse the decl.
Argyrios Kyrtzidis0f84a232008-11-09 22:53:32 +00002392 if (TK == TK_Reference || isDeclInScope(PrevDecl, DC, S)) {
Ted Kremenek4b7c9832008-09-05 17:16:31 +00002393 // Make sure that this wasn't declared as an enum and now used as a
2394 // struct or something similar.
2395 if (PrevTagDecl->getTagKind() != Kind) {
Chris Lattner3c73c412008-11-19 08:23:25 +00002396 Diag(KWLoc, diag::err_use_with_wrong_tag) << Name;
Ted Kremenek4b7c9832008-09-05 17:16:31 +00002397 Diag(PrevDecl->getLocation(), diag::err_previous_use);
2398 // Recover by making this an anonymous redefinition.
2399 Name = 0;
2400 PrevDecl = 0;
2401 } else {
2402 // If this is a use, return the original decl.
2403
2404 // FIXME: In the future, return a variant or some other clue
2405 // for the consumer of this Decl to know it doesn't own it.
2406 // For our current ASTs this shouldn't be a problem, but will
2407 // need to be changed with DeclGroups.
2408 if (TK == TK_Reference)
2409 return PrevDecl;
2410
2411 // The new decl is a definition?
2412 if (TK == TK_Definition) {
2413 // Diagnose attempts to redefine a tag.
2414 if (RecordDecl* DefRecord =
2415 cast<RecordDecl>(PrevTagDecl)->getDefinition(Context)) {
Chris Lattner3c73c412008-11-19 08:23:25 +00002416 Diag(NameLoc, diag::err_redefinition) << Name;
Ted Kremenek4b7c9832008-09-05 17:16:31 +00002417 Diag(DefRecord->getLocation(), diag::err_previous_definition);
2418 // If this is a redefinition, recover by making this struct be
2419 // anonymous, which will make any later references get the previous
2420 // definition.
2421 Name = 0;
2422 PrevDecl = 0;
2423 }
2424 // Okay, this is definition of a previously declared or referenced
2425 // tag. We're going to create a new Decl.
2426 }
2427 }
2428 // If we get here we have (another) forward declaration. Just create
2429 // a new decl.
2430 }
2431 else {
2432 // If we get here, this is a definition of a new struct type in a nested
2433 // scope, e.g. "struct foo; void bar() { struct foo; }", just create a
2434 // new decl/type. We set PrevDecl to NULL so that the Records
2435 // have distinct types.
2436 PrevDecl = 0;
2437 }
2438 } else {
2439 // PrevDecl is a namespace.
Argyrios Kyrtzidis0f84a232008-11-09 22:53:32 +00002440 if (isDeclInScope(PrevDecl, DC, S)) {
Ted Kremenek4b7c9832008-09-05 17:16:31 +00002441 // The tag name clashes with a namespace name, issue an error and
2442 // recover by making this tag be anonymous.
Chris Lattner3c73c412008-11-19 08:23:25 +00002443 Diag(NameLoc, diag::err_redefinition_different_kind) << Name;
Ted Kremenek4b7c9832008-09-05 17:16:31 +00002444 Diag(PrevDecl->getLocation(), diag::err_previous_definition);
2445 Name = 0;
2446 }
2447 }
2448 }
Argyrios Kyrtzidis630c81b2008-11-09 22:09:58 +00002449
2450 CreateNewDecl:
2451
Ted Kremenek4b7c9832008-09-05 17:16:31 +00002452 // If there is an identifier, use the location of the identifier as the
2453 // location of the decl, otherwise use the location of the struct/union
2454 // keyword.
2455 SourceLocation Loc = NameLoc.isValid() ? NameLoc : KWLoc;
2456
2457 // Otherwise, if this is the first time we've seen this tag, create the decl.
2458 TagDecl *New;
2459
2460 // FIXME: Tag decls should be chained to any simultaneous vardecls, e.g.:
2461 // struct X { int A; } D; D should chain to X.
2462 if (getLangOptions().CPlusPlus)
Ted Kremenek2b345eb2008-09-05 17:39:33 +00002463 // FIXME: Look for a way to use RecordDecl for simple structs.
Argyrios Kyrtzidis0f84a232008-11-09 22:53:32 +00002464 New = CXXRecordDecl::Create(Context, Kind, DC, Loc, Name,
Ted Kremenek4b7c9832008-09-05 17:16:31 +00002465 dyn_cast_or_null<CXXRecordDecl>(PrevDecl));
2466 else
Argyrios Kyrtzidis0f84a232008-11-09 22:53:32 +00002467 New = RecordDecl::Create(Context, Kind, DC, Loc, Name,
Ted Kremenek4b7c9832008-09-05 17:16:31 +00002468 dyn_cast_or_null<RecordDecl>(PrevDecl));
2469
2470 // If this has an identifier, add it to the scope stack.
2471 if ((TK == TK_Definition || !PrevDecl) && Name) {
2472 // The scope passed in may not be a decl scope. Zip up the scope tree until
2473 // we find one that is.
2474 while ((S->getFlags() & Scope::DeclScope) == 0)
2475 S = S->getParent();
2476
2477 // Add it to the decl chain.
2478 PushOnScopeChains(New, S);
2479 }
Daniel Dunbar3b0db902008-10-16 02:34:03 +00002480
2481 // Handle #pragma pack: if the #pragma pack stack has non-default
2482 // alignment, make up a packed attribute for this decl. These
2483 // attributes are checked when the ASTContext lays out the
2484 // structure.
2485 //
2486 // It is important for implementing the correct semantics that this
2487 // happen here (in act on tag decl). The #pragma pack stack is
2488 // maintained as a result of parser callbacks which can occur at
2489 // many points during the parsing of a struct declaration (because
2490 // the #pragma tokens are effectively skipped over during the
2491 // parsing of the struct).
2492 if (unsigned Alignment = PackContext.getAlignment())
2493 New->addAttr(new PackedAttr(Alignment * 8));
Ted Kremenek4b7c9832008-09-05 17:16:31 +00002494
2495 if (Attr)
2496 ProcessDeclAttributeList(New, Attr);
2497
Argyrios Kyrtzidis52393042008-11-09 23:41:00 +00002498 // Set the lexical context. If the tag has a C++ scope specifier, the
2499 // lexical context will be different from the semantic context.
2500 New->setLexicalDeclContext(CurContext);
2501
Ted Kremenek4b7c9832008-09-05 17:16:31 +00002502 return New;
2503}
2504
2505
Chris Lattner5a6ddbf2008-06-21 19:39:06 +00002506/// Collect the instance variables declared in an Objective-C object. Used in
2507/// the creation of structures from objects using the @defs directive.
Ted Kremenek01e67792008-08-20 03:26:33 +00002508static void CollectIvars(ObjCInterfaceDecl *Class, ASTContext& Ctx,
Chris Lattner7caeabd2008-07-21 22:17:28 +00002509 llvm::SmallVectorImpl<Sema::DeclTy*> &ivars) {
Chris Lattner5a6ddbf2008-06-21 19:39:06 +00002510 if (Class->getSuperClass())
Ted Kremenek01e67792008-08-20 03:26:33 +00002511 CollectIvars(Class->getSuperClass(), Ctx, ivars);
2512
2513 // For each ivar, create a fresh ObjCAtDefsFieldDecl.
Ted Kremeneka89d1972008-09-03 18:03:35 +00002514 for (ObjCInterfaceDecl::ivar_iterator
2515 I=Class->ivar_begin(), E=Class->ivar_end(); I!=E; ++I) {
2516
Ted Kremenek01e67792008-08-20 03:26:33 +00002517 ObjCIvarDecl* ID = *I;
2518 ivars.push_back(ObjCAtDefsFieldDecl::Create(Ctx, ID->getLocation(),
2519 ID->getIdentifier(),
2520 ID->getType(),
2521 ID->getBitWidth()));
2522 }
Chris Lattner5a6ddbf2008-06-21 19:39:06 +00002523}
2524
2525/// Called whenever @defs(ClassName) is encountered in the source. Inserts the
2526/// instance variables of ClassName into Decls.
2527void Sema::ActOnDefs(Scope *S, SourceLocation DeclStart,
2528 IdentifierInfo *ClassName,
Chris Lattner7caeabd2008-07-21 22:17:28 +00002529 llvm::SmallVectorImpl<DeclTy*> &Decls) {
Chris Lattner5a6ddbf2008-06-21 19:39:06 +00002530 // Check that ClassName is a valid class
2531 ObjCInterfaceDecl *Class = getObjCInterfaceDecl(ClassName);
2532 if (!Class) {
Chris Lattner3c73c412008-11-19 08:23:25 +00002533 Diag(DeclStart, diag::err_undef_interface) << ClassName;
Chris Lattner5a6ddbf2008-06-21 19:39:06 +00002534 return;
2535 }
Chris Lattner5a6ddbf2008-06-21 19:39:06 +00002536 // Collect the instance variables
Ted Kremenek01e67792008-08-20 03:26:33 +00002537 CollectIvars(Class, Context, Decls);
Chris Lattner5a6ddbf2008-06-21 19:39:06 +00002538}
2539
Chris Lattner1d353ba2008-11-12 21:17:48 +00002540/// TryToFixInvalidVariablyModifiedType - Helper method to turn variable array
2541/// types into constant array types in certain situations which would otherwise
2542/// be errors (for GCC compatibility).
2543static QualType TryToFixInvalidVariablyModifiedType(QualType T,
2544 ASTContext &Context) {
Eli Friedman1b76ada2008-06-03 21:01:11 +00002545 // This method tries to turn a variable array into a constant
2546 // array even when the size isn't an ICE. This is necessary
2547 // for compatibility with code that depends on gcc's buggy
2548 // constant expression folding, like struct {char x[(int)(char*)2];}
Chris Lattner57d57882008-11-12 19:48:13 +00002549 const VariableArrayType* VLATy = dyn_cast<VariableArrayType>(T);
2550 if (!VLATy) return QualType();
2551
2552 APValue Result;
2553 if (!VLATy->getSizeExpr() ||
Chris Lattner6ee7aa12008-11-16 21:24:15 +00002554 !VLATy->getSizeExpr()->Evaluate(Result, Context))
Chris Lattner57d57882008-11-12 19:48:13 +00002555 return QualType();
2556
2557 assert(Result.isInt() && "Size expressions must be integers!");
2558 llvm::APSInt &Res = Result.getInt();
2559 if (Res > llvm::APSInt(Res.getBitWidth(), Res.isUnsigned()))
2560 return Context.getConstantArrayType(VLATy->getElementType(),
2561 Res, ArrayType::Normal, 0);
Eli Friedman1b76ada2008-06-03 21:01:11 +00002562 return QualType();
2563}
2564
Steve Naroff08d92e42007-09-15 18:49:24 +00002565/// ActOnField - Each field of a struct/union/class is passed into this in order
Reid Spencer5f016e22007-07-11 17:01:13 +00002566/// to create a FieldDecl object for it.
Fariborz Jahanian1d78cc42008-04-10 23:32:45 +00002567Sema::DeclTy *Sema::ActOnField(Scope *S,
Reid Spencer5f016e22007-07-11 17:01:13 +00002568 SourceLocation DeclStart,
2569 Declarator &D, ExprTy *BitfieldWidth) {
2570 IdentifierInfo *II = D.getIdentifier();
2571 Expr *BitWidth = (Expr*)BitfieldWidth;
Reid Spencer5f016e22007-07-11 17:01:13 +00002572 SourceLocation Loc = DeclStart;
2573 if (II) Loc = D.getIdentifierLoc();
2574
2575 // FIXME: Unnamed fields can be handled in various different ways, for
2576 // example, unnamed unions inject all members into the struct namespace!
Ted Kremeneka89d1972008-09-03 18:03:35 +00002577
Reid Spencer5f016e22007-07-11 17:01:13 +00002578 if (BitWidth) {
2579 // TODO: Validate.
2580 //printf("WARNING: BITFIELDS IGNORED!\n");
2581
2582 // 6.7.2.1p3
2583 // 6.7.2.1p4
2584
2585 } else {
2586 // Not a bitfield.
2587
2588 // validate II.
2589
2590 }
2591
2592 QualType T = GetTypeForDeclarator(D, S);
Steve Naroff5912a352007-08-28 20:14:24 +00002593 assert(!T.isNull() && "GetTypeForDeclarator() returned null type");
2594 bool InvalidDecl = false;
Steve Naroffd7444aa2007-08-31 17:20:07 +00002595
Reid Spencer5f016e22007-07-11 17:01:13 +00002596 // C99 6.7.2.1p8: A member of a structure or union may have any type other
2597 // than a variably modified type.
Eli Friedman9db13972008-02-15 12:53:51 +00002598 if (T->isVariablyModifiedType()) {
Chris Lattner1d353ba2008-11-12 21:17:48 +00002599 QualType FixedTy = TryToFixInvalidVariablyModifiedType(T, Context);
Eli Friedman1b76ada2008-06-03 21:01:11 +00002600 if (!FixedTy.isNull()) {
Chris Lattner23cd0d92008-11-13 18:49:38 +00002601 Diag(Loc, diag::warn_illegal_constant_array_size);
Eli Friedman1b76ada2008-06-03 21:01:11 +00002602 T = FixedTy;
2603 } else {
Chris Lattner23cd0d92008-11-13 18:49:38 +00002604 Diag(Loc, diag::err_typecheck_field_variable_size);
Chris Lattner3ab55432008-11-12 19:45:49 +00002605 T = Context.IntTy;
Eli Friedman1b76ada2008-06-03 21:01:11 +00002606 InvalidDecl = true;
2607 }
Reid Spencer5f016e22007-07-11 17:01:13 +00002608 }
Reid Spencer5f016e22007-07-11 17:01:13 +00002609 // FIXME: Chain fielddecls together.
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +00002610 FieldDecl *NewFD;
2611
2612 if (getLangOptions().CPlusPlus) {
2613 // FIXME: Replace CXXFieldDecls with FieldDecls for simple structs.
2614 NewFD = CXXFieldDecl::Create(Context, cast<CXXRecordDecl>(CurContext),
Sebastian Redla11f42f2008-11-17 23:24:37 +00002615 Loc, II, T,
2616 D.getDeclSpec().getStorageClassSpec() ==
2617 DeclSpec::SCS_mutable, BitWidth);
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +00002618 if (II)
2619 PushOnScopeChains(NewFD, S);
2620 }
2621 else
2622 NewFD = FieldDecl::Create(Context, Loc, II, T, BitWidth);
Steve Naroff44739212007-09-11 21:17:26 +00002623
Chris Lattner3ff30c82008-06-29 00:02:00 +00002624 ProcessDeclAttributes(NewFD, D);
Anders Carlssonad148062008-02-16 00:29:18 +00002625
Steve Naroff5912a352007-08-28 20:14:24 +00002626 if (D.getInvalidType() || InvalidDecl)
2627 NewFD->setInvalidDecl();
2628 return NewFD;
Reid Spencer5f016e22007-07-11 17:01:13 +00002629}
2630
Fariborz Jahanian89204a12007-10-01 16:53:59 +00002631/// TranslateIvarVisibility - Translate visibility from a token ID to an
2632/// AST enum value.
Ted Kremeneka526c5c2008-01-07 19:49:32 +00002633static ObjCIvarDecl::AccessControl
Fariborz Jahanian89204a12007-10-01 16:53:59 +00002634TranslateIvarVisibility(tok::ObjCKeywordKind ivarVisibility) {
Steve Narofff13271f2007-09-14 23:09:53 +00002635 switch (ivarVisibility) {
Chris Lattner33d34a62008-10-12 00:28:42 +00002636 default: assert(0 && "Unknown visitibility kind");
2637 case tok::objc_private: return ObjCIvarDecl::Private;
2638 case tok::objc_public: return ObjCIvarDecl::Public;
2639 case tok::objc_protected: return ObjCIvarDecl::Protected;
2640 case tok::objc_package: return ObjCIvarDecl::Package;
Steve Narofff13271f2007-09-14 23:09:53 +00002641 }
2642}
2643
Fariborz Jahanian45bc03f2008-04-11 16:55:42 +00002644/// ActOnIvar - Each ivar field of an objective-c class is passed into this
2645/// in order to create an IvarDecl object for it.
Fariborz Jahanian1d78cc42008-04-10 23:32:45 +00002646Sema::DeclTy *Sema::ActOnIvar(Scope *S,
Fariborz Jahanian45bc03f2008-04-11 16:55:42 +00002647 SourceLocation DeclStart,
2648 Declarator &D, ExprTy *BitfieldWidth,
2649 tok::ObjCKeywordKind Visibility) {
Fariborz Jahanian1d78cc42008-04-10 23:32:45 +00002650 IdentifierInfo *II = D.getIdentifier();
2651 Expr *BitWidth = (Expr*)BitfieldWidth;
2652 SourceLocation Loc = DeclStart;
2653 if (II) Loc = D.getIdentifierLoc();
2654
2655 // FIXME: Unnamed fields can be handled in various different ways, for
2656 // example, unnamed unions inject all members into the struct namespace!
2657
2658
2659 if (BitWidth) {
2660 // TODO: Validate.
2661 //printf("WARNING: BITFIELDS IGNORED!\n");
2662
2663 // 6.7.2.1p3
2664 // 6.7.2.1p4
2665
2666 } else {
2667 // Not a bitfield.
2668
2669 // validate II.
2670
2671 }
2672
2673 QualType T = GetTypeForDeclarator(D, S);
2674 assert(!T.isNull() && "GetTypeForDeclarator() returned null type");
2675 bool InvalidDecl = false;
2676
2677 // C99 6.7.2.1p8: A member of a structure or union may have any type other
2678 // than a variably modified type.
2679 if (T->isVariablyModifiedType()) {
2680 // FIXME: This diagnostic needs work
Chris Lattnerdcd5ef12008-11-19 05:27:50 +00002681 Diag(Loc, diag::err_typecheck_illegal_vla) << SourceRange(Loc);
Fariborz Jahanian1d78cc42008-04-10 23:32:45 +00002682 InvalidDecl = true;
2683 }
2684
Ted Kremenekb8db21d2008-07-23 18:04:17 +00002685 // Get the visibility (access control) for this ivar.
2686 ObjCIvarDecl::AccessControl ac =
2687 Visibility != tok::objc_not_keyword ? TranslateIvarVisibility(Visibility)
2688 : ObjCIvarDecl::None;
2689
2690 // Construct the decl.
2691 ObjCIvarDecl *NewID = ObjCIvarDecl::Create(Context, Loc, II, T, ac,
Steve Naroff8f3b2652008-07-16 18:22:22 +00002692 (Expr *)BitfieldWidth);
Fariborz Jahanian1d78cc42008-04-10 23:32:45 +00002693
Ted Kremenekb8db21d2008-07-23 18:04:17 +00002694 // Process attributes attached to the ivar.
Chris Lattner3ff30c82008-06-29 00:02:00 +00002695 ProcessDeclAttributes(NewID, D);
Fariborz Jahanian1d78cc42008-04-10 23:32:45 +00002696
2697 if (D.getInvalidType() || InvalidDecl)
2698 NewID->setInvalidDecl();
Ted Kremenekb8db21d2008-07-23 18:04:17 +00002699
Fariborz Jahanian1d78cc42008-04-10 23:32:45 +00002700 return NewID;
2701}
2702
Fariborz Jahanian9d048ff2007-09-29 00:54:24 +00002703void Sema::ActOnFields(Scope* S,
Fariborz Jahanian3f5faf72007-10-04 00:45:27 +00002704 SourceLocation RecLoc, DeclTy *RecDecl,
Steve Naroff08d92e42007-09-15 18:49:24 +00002705 DeclTy **Fields, unsigned NumFields,
Daniel Dunbar1bfe1c22008-10-03 02:03:53 +00002706 SourceLocation LBrac, SourceLocation RBrac,
Daniel Dunbar7d076642008-10-03 17:33:35 +00002707 AttributeList *Attr) {
Steve Naroff74216642007-09-14 22:20:54 +00002708 Decl *EnclosingDecl = static_cast<Decl*>(RecDecl);
2709 assert(EnclosingDecl && "missing record or interface decl");
2710 RecordDecl *Record = dyn_cast<RecordDecl>(EnclosingDecl);
2711
Ted Kremenek4b7c9832008-09-05 17:16:31 +00002712 if (Record)
2713 if (RecordDecl* DefRecord = Record->getDefinition(Context)) {
2714 // Diagnose code like:
2715 // struct S { struct S {} X; };
2716 // We discover this when we complete the outer S. Reject and ignore the
2717 // outer S.
Chris Lattnerf3a41af2008-11-20 06:38:18 +00002718 Diag(DefRecord->getLocation(), diag::err_nested_redefinition)
2719 << DefRecord->getKindName();
Ted Kremenek4b7c9832008-09-05 17:16:31 +00002720 Diag(RecLoc, diag::err_previous_definition);
2721 Record->setInvalidDecl();
2722 return;
2723 }
2724
Reid Spencer5f016e22007-07-11 17:01:13 +00002725 // Verify that all the fields are okay.
2726 unsigned NumNamedMembers = 0;
2727 llvm::SmallVector<FieldDecl*, 32> RecFields;
2728 llvm::SmallSet<const IdentifierInfo*, 32> FieldIDs;
Steve Naroff74216642007-09-14 22:20:54 +00002729
Reid Spencer5f016e22007-07-11 17:01:13 +00002730 for (unsigned i = 0; i != NumFields; ++i) {
Fariborz Jahaniane267ab62007-09-14 16:27:55 +00002731
Steve Naroff74216642007-09-14 22:20:54 +00002732 FieldDecl *FD = cast_or_null<FieldDecl>(static_cast<Decl*>(Fields[i]));
2733 assert(FD && "missing field decl");
2734
2735 // Remember all fields.
2736 RecFields.push_back(FD);
Reid Spencer5f016e22007-07-11 17:01:13 +00002737
2738 // Get the type for the field.
Chris Lattner02c642e2007-07-31 21:33:24 +00002739 Type *FDTy = FD->getType().getTypePtr();
Steve Narofff13271f2007-09-14 23:09:53 +00002740
Reid Spencer5f016e22007-07-11 17:01:13 +00002741 // C99 6.7.2.1p2 - A field may not be a function type.
Chris Lattner02c642e2007-07-31 21:33:24 +00002742 if (FDTy->isFunctionType()) {
Chris Lattnerf3a41af2008-11-20 06:38:18 +00002743 Diag(FD->getLocation(), diag::err_field_declared_as_function)
2744 << FD->getName();
Steve Naroff74216642007-09-14 22:20:54 +00002745 FD->setInvalidDecl();
2746 EnclosingDecl->setInvalidDecl();
Reid Spencer5f016e22007-07-11 17:01:13 +00002747 continue;
2748 }
Reid Spencer5f016e22007-07-11 17:01:13 +00002749 // C99 6.7.2.1p2 - A field may not be an incomplete type except...
2750 if (FDTy->isIncompleteType()) {
Fariborz Jahaniane267ab62007-09-14 16:27:55 +00002751 if (!Record) { // Incomplete ivar type is always an error.
Chris Lattnerf3a41af2008-11-20 06:38:18 +00002752 Diag(FD->getLocation(), diag::err_field_incomplete) << FD->getName();
Steve Naroff74216642007-09-14 22:20:54 +00002753 FD->setInvalidDecl();
2754 EnclosingDecl->setInvalidDecl();
Fariborz Jahanian3f5faf72007-10-04 00:45:27 +00002755 continue;
Fariborz Jahaniane267ab62007-09-14 16:27:55 +00002756 }
Reid Spencer5f016e22007-07-11 17:01:13 +00002757 if (i != NumFields-1 || // ... that the last member ...
Argyrios Kyrtzidis39ba4ae2008-06-09 23:19:58 +00002758 !Record->isStruct() || // ... of a structure ...
Chris Lattner02c642e2007-07-31 21:33:24 +00002759 !FDTy->isArrayType()) { //... may have incomplete array type.
Chris Lattnerf3a41af2008-11-20 06:38:18 +00002760 Diag(FD->getLocation(), diag::err_field_incomplete) << FD->getName();
Steve Naroff74216642007-09-14 22:20:54 +00002761 FD->setInvalidDecl();
2762 EnclosingDecl->setInvalidDecl();
Reid Spencer5f016e22007-07-11 17:01:13 +00002763 continue;
2764 }
Fariborz Jahaniane267ab62007-09-14 16:27:55 +00002765 if (NumNamedMembers < 1) { //... must have more than named member ...
Chris Lattnerf3a41af2008-11-20 06:38:18 +00002766 Diag(FD->getLocation(), diag::err_flexible_array_empty_struct)
2767 << FD->getName();
Steve Naroff74216642007-09-14 22:20:54 +00002768 FD->setInvalidDecl();
2769 EnclosingDecl->setInvalidDecl();
Reid Spencer5f016e22007-07-11 17:01:13 +00002770 continue;
2771 }
Reid Spencer5f016e22007-07-11 17:01:13 +00002772 // Okay, we have a legal flexible array member at the end of the struct.
Fariborz Jahaniane267ab62007-09-14 16:27:55 +00002773 if (Record)
2774 Record->setHasFlexibleArrayMember(true);
Reid Spencer5f016e22007-07-11 17:01:13 +00002775 }
Reid Spencer5f016e22007-07-11 17:01:13 +00002776 /// C99 6.7.2.1p2 - a struct ending in a flexible array member cannot be the
2777 /// field of another structure or the element of an array.
Chris Lattner02c642e2007-07-31 21:33:24 +00002778 if (const RecordType *FDTTy = FDTy->getAsRecordType()) {
Reid Spencer5f016e22007-07-11 17:01:13 +00002779 if (FDTTy->getDecl()->hasFlexibleArrayMember()) {
2780 // If this is a member of a union, then entire union becomes "flexible".
Argyrios Kyrtzidis39ba4ae2008-06-09 23:19:58 +00002781 if (Record && Record->isUnion()) {
Reid Spencer5f016e22007-07-11 17:01:13 +00002782 Record->setHasFlexibleArrayMember(true);
2783 } else {
2784 // If this is a struct/class and this is not the last element, reject
2785 // it. Note that GCC supports variable sized arrays in the middle of
2786 // structures.
2787 if (i != NumFields-1) {
Chris Lattnerf3a41af2008-11-20 06:38:18 +00002788 Diag(FD->getLocation(), diag::err_variable_sized_type_in_struct)
2789 << FD->getName();
Steve Naroff74216642007-09-14 22:20:54 +00002790 FD->setInvalidDecl();
2791 EnclosingDecl->setInvalidDecl();
Reid Spencer5f016e22007-07-11 17:01:13 +00002792 continue;
2793 }
Reid Spencer5f016e22007-07-11 17:01:13 +00002794 // We support flexible arrays at the end of structs in other structs
2795 // as an extension.
Chris Lattnerf3a41af2008-11-20 06:38:18 +00002796 Diag(FD->getLocation(), diag::ext_flexible_array_in_struct)
2797 << FD->getName();
Fariborz Jahanian3f5faf72007-10-04 00:45:27 +00002798 if (Record)
Fariborz Jahaniane267ab62007-09-14 16:27:55 +00002799 Record->setHasFlexibleArrayMember(true);
Reid Spencer5f016e22007-07-11 17:01:13 +00002800 }
2801 }
2802 }
Fariborz Jahaniane7f64cc2007-10-12 22:10:42 +00002803 /// A field cannot be an Objective-c object
Ted Kremeneka526c5c2008-01-07 19:49:32 +00002804 if (FDTy->isObjCInterfaceType()) {
Chris Lattnerf3a41af2008-11-20 06:38:18 +00002805 Diag(FD->getLocation(), diag::err_statically_allocated_object)
Chris Lattner08631c52008-11-23 21:45:46 +00002806 << FD->getDeclName();
Fariborz Jahaniane7f64cc2007-10-12 22:10:42 +00002807 FD->setInvalidDecl();
2808 EnclosingDecl->setInvalidDecl();
2809 continue;
2810 }
Reid Spencer5f016e22007-07-11 17:01:13 +00002811 // Keep track of the number of named members.
2812 if (IdentifierInfo *II = FD->getIdentifier()) {
2813 // Detect duplicate member names.
2814 if (!FieldIDs.insert(II)) {
Chris Lattner3c73c412008-11-19 08:23:25 +00002815 Diag(FD->getLocation(), diag::err_duplicate_member) << II;
Reid Spencer5f016e22007-07-11 17:01:13 +00002816 // Find the previous decl.
2817 SourceLocation PrevLoc;
Chris Lattner33d34a62008-10-12 00:28:42 +00002818 for (unsigned i = 0; ; ++i) {
2819 assert(i != RecFields.size() && "Didn't find previous def!");
Reid Spencer5f016e22007-07-11 17:01:13 +00002820 if (RecFields[i]->getIdentifier() == II) {
2821 PrevLoc = RecFields[i]->getLocation();
2822 break;
2823 }
2824 }
2825 Diag(PrevLoc, diag::err_previous_definition);
Steve Naroff74216642007-09-14 22:20:54 +00002826 FD->setInvalidDecl();
2827 EnclosingDecl->setInvalidDecl();
Reid Spencer5f016e22007-07-11 17:01:13 +00002828 continue;
2829 }
2830 ++NumNamedMembers;
2831 }
Reid Spencer5f016e22007-07-11 17:01:13 +00002832 }
2833
Reid Spencer5f016e22007-07-11 17:01:13 +00002834 // Okay, we successfully defined 'Record'.
Chris Lattnere1e79852008-02-06 00:51:33 +00002835 if (Record) {
Ted Kremenek4b7c9832008-09-05 17:16:31 +00002836 Record->defineBody(Context, &RecFields[0], RecFields.size());
Argyrios Kyrtzidisa4755c62008-08-09 00:58:37 +00002837 // If this is a C++ record, HandleTagDeclDefinition will be invoked in
2838 // Sema::ActOnFinishCXXClassDef.
2839 if (!isa<CXXRecordDecl>(Record))
2840 Consumer.HandleTagDeclDefinition(Record);
Chris Lattnere1e79852008-02-06 00:51:33 +00002841 } else {
Chris Lattnera91d3812008-02-05 22:40:55 +00002842 ObjCIvarDecl **ClsFields = reinterpret_cast<ObjCIvarDecl**>(&RecFields[0]);
2843 if (ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(EnclosingDecl))
2844 ID->addInstanceVariablesToClass(ClsFields, RecFields.size(), RBrac);
2845 else if (ObjCImplementationDecl *IMPDecl =
2846 dyn_cast<ObjCImplementationDecl>(EnclosingDecl)) {
Ted Kremeneka526c5c2008-01-07 19:49:32 +00002847 assert(IMPDecl && "ActOnFields - missing ObjCImplementationDecl");
2848 IMPDecl->ObjCAddInstanceVariablesToClassImpl(ClsFields, RecFields.size());
Fariborz Jahanian3a3ca1b2007-10-31 18:48:14 +00002849 CheckImplementationIvars(IMPDecl, ClsFields, RecFields.size(), RBrac);
Fariborz Jahaniand0b90bf2007-09-26 18:27:25 +00002850 }
Fariborz Jahanianb04a0212007-09-14 21:08:27 +00002851 }
Daniel Dunbar7d076642008-10-03 17:33:35 +00002852
2853 if (Attr)
2854 ProcessDeclAttributeList(Record, Attr);
Reid Spencer5f016e22007-07-11 17:01:13 +00002855}
2856
Steve Naroff08d92e42007-09-15 18:49:24 +00002857Sema::DeclTy *Sema::ActOnEnumConstant(Scope *S, DeclTy *theEnumDecl,
Reid Spencer5f016e22007-07-11 17:01:13 +00002858 DeclTy *lastEnumConst,
2859 SourceLocation IdLoc, IdentifierInfo *Id,
2860 SourceLocation EqualLoc, ExprTy *val) {
Chris Lattner0ed844b2008-04-04 06:12:32 +00002861 EnumDecl *TheEnumDecl = cast<EnumDecl>(static_cast<Decl*>(theEnumDecl));
Reid Spencer5f016e22007-07-11 17:01:13 +00002862 EnumConstantDecl *LastEnumConst =
2863 cast_or_null<EnumConstantDecl>(static_cast<Decl*>(lastEnumConst));
2864 Expr *Val = static_cast<Expr*>(val);
2865
Chris Lattner31e05722007-08-26 06:24:45 +00002866 // The scope passed in may not be a decl scope. Zip up the scope tree until
2867 // we find one that is.
2868 while ((S->getFlags() & Scope::DeclScope) == 0)
2869 S = S->getParent();
2870
Reid Spencer5f016e22007-07-11 17:01:13 +00002871 // Verify that there isn't already something declared with this name in this
2872 // scope.
Steve Naroffb327ce02008-04-02 14:35:35 +00002873 if (Decl *PrevDecl = LookupDecl(Id, Decl::IDNS_Ordinary, S)) {
Argyrios Kyrtzidis0ff12f02008-07-16 21:01:53 +00002874 // When in C++, we may get a TagDecl with the same name; in this case the
2875 // enum constant will 'hide' the tag.
2876 assert((getLangOptions().CPlusPlus || !isa<TagDecl>(PrevDecl)) &&
2877 "Received TagDecl when not in C++!");
Argyrios Kyrtzidis15a12d02008-09-09 21:18:04 +00002878 if (!isa<TagDecl>(PrevDecl) && isDeclInScope(PrevDecl, CurContext, S)) {
Reid Spencer5f016e22007-07-11 17:01:13 +00002879 if (isa<EnumConstantDecl>(PrevDecl))
Chris Lattner3c73c412008-11-19 08:23:25 +00002880 Diag(IdLoc, diag::err_redefinition_of_enumerator) << Id;
Reid Spencer5f016e22007-07-11 17:01:13 +00002881 else
Chris Lattner3c73c412008-11-19 08:23:25 +00002882 Diag(IdLoc, diag::err_redefinition) << Id;
Reid Spencer5f016e22007-07-11 17:01:13 +00002883 Diag(PrevDecl->getLocation(), diag::err_previous_definition);
Chris Lattnera73349d2008-02-26 00:33:57 +00002884 delete Val;
Reid Spencer5f016e22007-07-11 17:01:13 +00002885 return 0;
2886 }
2887 }
2888
2889 llvm::APSInt EnumVal(32);
2890 QualType EltTy;
2891 if (Val) {
Chris Lattner421a23d2007-08-27 21:16:18 +00002892 // Make sure to promote the operand type to int.
2893 UsualUnaryConversions(Val);
2894
Reid Spencer5f016e22007-07-11 17:01:13 +00002895 // C99 6.7.2.2p2: Make sure we have an integer constant expression.
2896 SourceLocation ExpLoc;
Chris Lattner590b6642007-07-15 23:26:56 +00002897 if (!Val->isIntegerConstantExpr(EnumVal, Context, &ExpLoc)) {
Chris Lattner3c73c412008-11-19 08:23:25 +00002898 Diag(ExpLoc, diag::err_enum_value_not_integer_constant_expr) << Id;
Chris Lattnera73349d2008-02-26 00:33:57 +00002899 delete Val;
Chris Lattnerb7416f92007-08-27 17:37:24 +00002900 Val = 0; // Just forget about it.
Chris Lattnere9ca8512007-08-29 16:03:41 +00002901 } else {
2902 EltTy = Val->getType();
Reid Spencer5f016e22007-07-11 17:01:13 +00002903 }
Chris Lattnerb7416f92007-08-27 17:37:24 +00002904 }
2905
2906 if (!Val) {
2907 if (LastEnumConst) {
2908 // Assign the last value + 1.
2909 EnumVal = LastEnumConst->getInitVal();
2910 ++EnumVal;
Chris Lattner421a23d2007-08-27 21:16:18 +00002911
2912 // Check for overflow on increment.
2913 if (EnumVal < LastEnumConst->getInitVal())
2914 Diag(IdLoc, diag::warn_enum_value_overflow);
2915
Chris Lattnerb7416f92007-08-27 17:37:24 +00002916 EltTy = LastEnumConst->getType();
2917 } else {
2918 // First value, set to zero.
2919 EltTy = Context.IntTy;
Chris Lattner98be4942008-03-05 18:54:05 +00002920 EnumVal.zextOrTrunc(static_cast<uint32_t>(Context.getTypeSize(EltTy)));
Chris Lattnerb7416f92007-08-27 17:37:24 +00002921 }
Reid Spencer5f016e22007-07-11 17:01:13 +00002922 }
2923
Chris Lattner6c2b6eb2008-03-15 06:12:44 +00002924 EnumConstantDecl *New =
Chris Lattner0ed844b2008-04-04 06:12:32 +00002925 EnumConstantDecl::Create(Context, TheEnumDecl, IdLoc, Id, EltTy,
2926 Val, EnumVal,
Chris Lattnerc63e6602008-03-15 21:32:50 +00002927 LastEnumConst);
Reid Spencer5f016e22007-07-11 17:01:13 +00002928
2929 // Register this decl in the current scope stack.
Argyrios Kyrtzidis87f3ff02008-04-12 00:47:19 +00002930 PushOnScopeChains(New, S);
Reid Spencer5f016e22007-07-11 17:01:13 +00002931 return New;
2932}
2933
Steve Naroff02408c62008-08-07 14:08:16 +00002934// FIXME: For consistency with ActOnFields(), we should have the parser
2935// pass in the source location for the left/right braces.
Steve Naroff08d92e42007-09-15 18:49:24 +00002936void Sema::ActOnEnumBody(SourceLocation EnumLoc, DeclTy *EnumDeclX,
Reid Spencer5f016e22007-07-11 17:01:13 +00002937 DeclTy **Elements, unsigned NumElements) {
2938 EnumDecl *Enum = cast<EnumDecl>(static_cast<Decl*>(EnumDeclX));
Reid Spencer5f016e22007-07-11 17:01:13 +00002939
Steve Naroff02408c62008-08-07 14:08:16 +00002940 if (Enum && Enum->isDefinition()) {
2941 // Diagnose code like:
2942 // enum e0 {
2943 // E0 = sizeof(enum e0 { E1 })
2944 // };
Chris Lattnerf3a41af2008-11-20 06:38:18 +00002945 Diag(Enum->getLocation(), diag::err_nested_redefinition) << Enum->getName();
Steve Naroff02408c62008-08-07 14:08:16 +00002946 Diag(EnumLoc, diag::err_previous_definition);
2947 Enum->setInvalidDecl();
2948 return;
2949 }
Chris Lattnere37f0be2007-08-28 05:10:31 +00002950 // TODO: If the result value doesn't fit in an int, it must be a long or long
2951 // long value. ISO C does not support this, but GCC does as an extension,
2952 // emit a warning.
Chris Lattner98be4942008-03-05 18:54:05 +00002953 unsigned IntWidth = Context.Target.getIntWidth();
Chris Lattnere37f0be2007-08-28 05:10:31 +00002954
Chris Lattnerac609682007-08-28 06:15:15 +00002955 // Verify that all the values are okay, compute the size of the values, and
2956 // reverse the list.
2957 unsigned NumNegativeBits = 0;
2958 unsigned NumPositiveBits = 0;
2959
2960 // Keep track of whether all elements have type int.
2961 bool AllElementsInt = true;
2962
Reid Spencer5f016e22007-07-11 17:01:13 +00002963 EnumConstantDecl *EltList = 0;
2964 for (unsigned i = 0; i != NumElements; ++i) {
2965 EnumConstantDecl *ECD =
2966 cast_or_null<EnumConstantDecl>(static_cast<Decl*>(Elements[i]));
2967 if (!ECD) continue; // Already issued a diagnostic.
Chris Lattner211a30e2007-08-28 05:27:00 +00002968
2969 // If the enum value doesn't fit in an int, emit an extension warning.
Chris Lattner211a30e2007-08-28 05:27:00 +00002970 const llvm::APSInt &InitVal = ECD->getInitVal();
Chris Lattnera73349d2008-02-26 00:33:57 +00002971 assert(InitVal.getBitWidth() >= IntWidth &&
2972 "Should have promoted value to int");
Chris Lattner211a30e2007-08-28 05:27:00 +00002973 if (InitVal.getBitWidth() > IntWidth) {
2974 llvm::APSInt V(InitVal);
2975 V.trunc(IntWidth);
2976 V.extend(InitVal.getBitWidth());
2977 if (V != InitVal)
Chris Lattnerf3a41af2008-11-20 06:38:18 +00002978 Diag(ECD->getLocation(), diag::ext_enum_value_not_int)
2979 << InitVal.toString(10);
Chris Lattner211a30e2007-08-28 05:27:00 +00002980 }
Chris Lattnerac609682007-08-28 06:15:15 +00002981
2982 // Keep track of the size of positive and negative values.
Chris Lattnera73349d2008-02-26 00:33:57 +00002983 if (InitVal.isUnsigned() || InitVal.isNonNegative())
Chris Lattner21dd8212008-01-14 21:47:29 +00002984 NumPositiveBits = std::max(NumPositiveBits,
2985 (unsigned)InitVal.getActiveBits());
Chris Lattnerac609682007-08-28 06:15:15 +00002986 else
Chris Lattner21dd8212008-01-14 21:47:29 +00002987 NumNegativeBits = std::max(NumNegativeBits,
2988 (unsigned)InitVal.getMinSignedBits());
Reid Spencer5f016e22007-07-11 17:01:13 +00002989
Chris Lattnerac609682007-08-28 06:15:15 +00002990 // Keep track of whether every enum element has type int (very commmon).
2991 if (AllElementsInt)
2992 AllElementsInt = ECD->getType() == Context.IntTy;
2993
Reid Spencer5f016e22007-07-11 17:01:13 +00002994 ECD->setNextDeclarator(EltList);
2995 EltList = ECD;
2996 }
2997
Chris Lattnerac609682007-08-28 06:15:15 +00002998 // Figure out the type that should be used for this enum.
2999 // FIXME: Support attribute(packed) on enums and -fshort-enums.
3000 QualType BestType;
Chris Lattnerb7f6e082007-08-29 17:31:48 +00003001 unsigned BestWidth;
Chris Lattnerac609682007-08-28 06:15:15 +00003002
3003 if (NumNegativeBits) {
3004 // If there is a negative value, figure out the smallest integer type (of
3005 // int/long/longlong) that fits.
Chris Lattnerb7f6e082007-08-29 17:31:48 +00003006 if (NumNegativeBits <= IntWidth && NumPositiveBits < IntWidth) {
Chris Lattnerac609682007-08-28 06:15:15 +00003007 BestType = Context.IntTy;
Chris Lattnerb7f6e082007-08-29 17:31:48 +00003008 BestWidth = IntWidth;
3009 } else {
Chris Lattner98be4942008-03-05 18:54:05 +00003010 BestWidth = Context.Target.getLongWidth();
Ted Kremenek9c728dc2007-12-12 22:39:36 +00003011
Chris Lattnerb7f6e082007-08-29 17:31:48 +00003012 if (NumNegativeBits <= BestWidth && NumPositiveBits < BestWidth)
Chris Lattnerac609682007-08-28 06:15:15 +00003013 BestType = Context.LongTy;
3014 else {
Chris Lattner98be4942008-03-05 18:54:05 +00003015 BestWidth = Context.Target.getLongLongWidth();
Ted Kremenek9c728dc2007-12-12 22:39:36 +00003016
Chris Lattnerb7f6e082007-08-29 17:31:48 +00003017 if (NumNegativeBits > BestWidth || NumPositiveBits >= BestWidth)
Chris Lattnerac609682007-08-28 06:15:15 +00003018 Diag(Enum->getLocation(), diag::warn_enum_too_large);
3019 BestType = Context.LongLongTy;
3020 }
3021 }
3022 } else {
3023 // If there is no negative value, figure out which of uint, ulong, ulonglong
3024 // fits.
Chris Lattnerb7f6e082007-08-29 17:31:48 +00003025 if (NumPositiveBits <= IntWidth) {
Chris Lattnerac609682007-08-28 06:15:15 +00003026 BestType = Context.UnsignedIntTy;
Chris Lattnerb7f6e082007-08-29 17:31:48 +00003027 BestWidth = IntWidth;
3028 } else if (NumPositiveBits <=
Chris Lattner98be4942008-03-05 18:54:05 +00003029 (BestWidth = Context.Target.getLongWidth())) {
Chris Lattnerac609682007-08-28 06:15:15 +00003030 BestType = Context.UnsignedLongTy;
Chris Lattner98be4942008-03-05 18:54:05 +00003031 } else {
3032 BestWidth = Context.Target.getLongLongWidth();
Chris Lattnerb7f6e082007-08-29 17:31:48 +00003033 assert(NumPositiveBits <= BestWidth &&
Chris Lattnerac609682007-08-28 06:15:15 +00003034 "How could an initializer get larger than ULL?");
3035 BestType = Context.UnsignedLongLongTy;
3036 }
3037 }
3038
Chris Lattnerb7f6e082007-08-29 17:31:48 +00003039 // Loop over all of the enumerator constants, changing their types to match
3040 // the type of the enum if needed.
3041 for (unsigned i = 0; i != NumElements; ++i) {
3042 EnumConstantDecl *ECD =
3043 cast_or_null<EnumConstantDecl>(static_cast<Decl*>(Elements[i]));
3044 if (!ECD) continue; // Already issued a diagnostic.
3045
3046 // Standard C says the enumerators have int type, but we allow, as an
3047 // extension, the enumerators to be larger than int size. If each
3048 // enumerator value fits in an int, type it as an int, otherwise type it the
3049 // same as the enumerator decl itself. This means that in "enum { X = 1U }"
3050 // that X has type 'int', not 'unsigned'.
Chris Lattnera73349d2008-02-26 00:33:57 +00003051 if (ECD->getType() == Context.IntTy) {
3052 // Make sure the init value is signed.
3053 llvm::APSInt IV = ECD->getInitVal();
3054 IV.setIsSigned(true);
3055 ECD->setInitVal(IV);
Chris Lattnerb7f6e082007-08-29 17:31:48 +00003056 continue; // Already int type.
Chris Lattnera73349d2008-02-26 00:33:57 +00003057 }
Chris Lattnerb7f6e082007-08-29 17:31:48 +00003058
3059 // Determine whether the value fits into an int.
3060 llvm::APSInt InitVal = ECD->getInitVal();
3061 bool FitsInInt;
3062 if (InitVal.isUnsigned() || !InitVal.isNegative())
3063 FitsInInt = InitVal.getActiveBits() < IntWidth;
3064 else
3065 FitsInInt = InitVal.getMinSignedBits() <= IntWidth;
3066
3067 // If it fits into an integer type, force it. Otherwise force it to match
3068 // the enum decl type.
3069 QualType NewTy;
3070 unsigned NewWidth;
3071 bool NewSign;
3072 if (FitsInInt) {
3073 NewTy = Context.IntTy;
3074 NewWidth = IntWidth;
3075 NewSign = true;
3076 } else if (ECD->getType() == BestType) {
3077 // Already the right type!
3078 continue;
3079 } else {
3080 NewTy = BestType;
3081 NewWidth = BestWidth;
3082 NewSign = BestType->isSignedIntegerType();
3083 }
3084
3085 // Adjust the APSInt value.
3086 InitVal.extOrTrunc(NewWidth);
3087 InitVal.setIsSigned(NewSign);
3088 ECD->setInitVal(InitVal);
3089
3090 // Adjust the Expr initializer and type.
Douglas Gregoreb8f3062008-11-12 17:17:38 +00003091 ECD->setInitExpr(new ImplicitCastExpr(NewTy, ECD->getInitExpr(),
3092 /*isLvalue=*/false));
Chris Lattnerb7f6e082007-08-29 17:31:48 +00003093 ECD->setType(NewTy);
3094 }
Chris Lattnerac609682007-08-28 06:15:15 +00003095
Chris Lattnere00b18c2007-08-28 18:24:31 +00003096 Enum->defineElements(EltList, BestType);
Chris Lattnere1e79852008-02-06 00:51:33 +00003097 Consumer.HandleTagDeclDefinition(Enum);
Reid Spencer5f016e22007-07-11 17:01:13 +00003098}
3099
Anders Carlssondfab6cb2008-02-08 00:33:21 +00003100Sema::DeclTy *Sema::ActOnFileScopeAsmDecl(SourceLocation Loc,
3101 ExprTy *expr) {
3102 StringLiteral *AsmString = cast<StringLiteral>((Expr*)expr);
3103
Chris Lattner8e25d862008-03-16 00:16:02 +00003104 return FileScopeAsmDecl::Create(Context, Loc, AsmString);
Anders Carlssondfab6cb2008-02-08 00:33:21 +00003105}
3106
Chris Lattnerc6fdc342008-01-12 07:05:38 +00003107Sema::DeclTy* Sema::ActOnLinkageSpec(SourceLocation Loc,
Chris Lattnerc81c8142008-02-25 21:04:36 +00003108 SourceLocation LBrace,
3109 SourceLocation RBrace,
3110 const char *Lang,
3111 unsigned StrSize,
3112 DeclTy *D) {
Chris Lattnerc6fdc342008-01-12 07:05:38 +00003113 LinkageSpecDecl::LanguageIDs Language;
3114 Decl *dcl = static_cast<Decl *>(D);
3115 if (strncmp(Lang, "\"C\"", StrSize) == 0)
3116 Language = LinkageSpecDecl::lang_c;
3117 else if (strncmp(Lang, "\"C++\"", StrSize) == 0)
3118 Language = LinkageSpecDecl::lang_cxx;
3119 else {
3120 Diag(Loc, diag::err_bad_language);
3121 return 0;
3122 }
3123
3124 // FIXME: Add all the various semantics of linkage specifications
Chris Lattner8e25d862008-03-16 00:16:02 +00003125 return LinkageSpecDecl::Create(Context, Loc, Language, dcl);
Chris Lattnerc6fdc342008-01-12 07:05:38 +00003126}
Daniel Dunbar4cde9272008-10-14 05:35:18 +00003127
3128void Sema::ActOnPragmaPack(PragmaPackKind Kind, IdentifierInfo *Name,
3129 ExprTy *alignment, SourceLocation PragmaLoc,
3130 SourceLocation LParenLoc, SourceLocation RParenLoc) {
3131 Expr *Alignment = static_cast<Expr *>(alignment);
3132
3133 // If specified then alignment must be a "small" power of two.
3134 unsigned AlignmentVal = 0;
3135 if (Alignment) {
3136 llvm::APSInt Val;
3137 if (!Alignment->isIntegerConstantExpr(Val, Context) ||
3138 !Val.isPowerOf2() ||
3139 Val.getZExtValue() > 16) {
3140 Diag(PragmaLoc, diag::warn_pragma_pack_invalid_alignment);
3141 delete Alignment;
3142 return; // Ignore
3143 }
3144
3145 AlignmentVal = (unsigned) Val.getZExtValue();
3146 }
3147
3148 switch (Kind) {
3149 case Action::PPK_Default: // pack([n])
3150 PackContext.setAlignment(AlignmentVal);
3151 break;
3152
3153 case Action::PPK_Show: // pack(show)
3154 // Show the current alignment, making sure to show the right value
3155 // for the default.
3156 AlignmentVal = PackContext.getAlignment();
3157 // FIXME: This should come from the target.
3158 if (AlignmentVal == 0)
3159 AlignmentVal = 8;
Chris Lattner83652232008-11-19 07:25:44 +00003160 Diag(PragmaLoc, diag::warn_pragma_pack_show) << AlignmentVal;
Daniel Dunbar4cde9272008-10-14 05:35:18 +00003161 break;
3162
3163 case Action::PPK_Push: // pack(push [, id] [, [n])
3164 PackContext.push(Name);
3165 // Set the new alignment if specified.
3166 if (Alignment)
3167 PackContext.setAlignment(AlignmentVal);
3168 break;
3169
3170 case Action::PPK_Pop: // pack(pop [, id] [, n])
3171 // MSDN, C/C++ Preprocessor Reference > Pragma Directives > pack:
3172 // "#pragma pack(pop, identifier, n) is undefined"
3173 if (Alignment && Name)
3174 Diag(PragmaLoc, diag::warn_pragma_pack_pop_identifer_and_alignment);
3175
3176 // Do the pop.
3177 if (!PackContext.pop(Name)) {
3178 // If a name was specified then failure indicates the name
3179 // wasn't found. Otherwise failure indicates the stack was
3180 // empty.
Chris Lattnerf3a41af2008-11-20 06:38:18 +00003181 Diag(PragmaLoc, diag::warn_pragma_pack_pop_failed)
3182 << (Name ? "no record matching name" : "stack empty");
Daniel Dunbar4cde9272008-10-14 05:35:18 +00003183
3184 // FIXME: Warn about popping named records as MSVC does.
3185 } else {
3186 // Pop succeeded, set the new alignment if specified.
3187 if (Alignment)
3188 PackContext.setAlignment(AlignmentVal);
3189 }
3190 break;
3191
3192 default:
3193 assert(0 && "Invalid #pragma pack kind.");
3194 }
3195}
3196
3197bool PragmaPackStack::pop(IdentifierInfo *Name) {
3198 if (Stack.empty())
3199 return false;
3200
3201 // If name is empty just pop top.
3202 if (!Name) {
3203 Alignment = Stack.back().first;
3204 Stack.pop_back();
3205 return true;
3206 }
3207
3208 // Otherwise, find the named record.
3209 for (unsigned i = Stack.size(); i != 0; ) {
3210 --i;
Daniel Dunbar06550392008-11-19 10:32:38 +00003211 if (Stack[i].second == Name) {
Daniel Dunbar4cde9272008-10-14 05:35:18 +00003212 // Found it, pop up to and including this record.
3213 Alignment = Stack[i].first;
3214 Stack.erase(Stack.begin() + i, Stack.end());
3215 return true;
3216 }
3217 }
3218
3219 return false;
3220}