blob: a493a29a5d2304582edf5ad6a58e8ad8701ac27d [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"
Douglas Gregor20093b42009-12-09 23:02:17 +000015#include "SemaInit.h"
John McCall7d384dd2009-11-18 07:57:50 +000016#include "Lookup.h"
Ted Kremenek1309f9a2010-01-25 04:41:41 +000017#include "clang/Analysis/AnalysisContext.h"
Anders Carlssonc44eec62008-07-03 04:20:39 +000018#include "clang/AST/APValue.h"
Chris Lattnere1e79852008-02-06 00:51:33 +000019#include "clang/AST/ASTConsumer.h"
Reid Spencer5f016e22007-07-11 17:01:13 +000020#include "clang/AST/ASTContext.h"
Douglas Gregora8f32e02009-10-06 17:59:45 +000021#include "clang/AST/CXXInheritance.h"
Douglas Gregoraaba5e32009-02-04 19:02:06 +000022#include "clang/AST/DeclTemplate.h"
Chris Lattner6b6b5372008-06-26 18:38:35 +000023#include "clang/AST/ExprCXX.h"
Sebastian Redld3a413d2009-04-26 20:35:05 +000024#include "clang/AST/StmtCXX.h"
Reid Spencer5f016e22007-07-11 17:01:13 +000025#include "clang/Parse/DeclSpec.h"
Douglas Gregora786fdb2009-10-13 23:27:22 +000026#include "clang/Parse/ParseDiagnostic.h"
Douglas Gregor314b97f2009-11-10 19:49:08 +000027#include "clang/Parse/Template.h"
Anders Carlssonb7906612009-08-26 23:45:07 +000028#include "clang/Basic/PartialDiagnostic.h"
Steve Naroff4c49a6c2008-01-30 23:46:05 +000029#include "clang/Basic/SourceManager.h"
Anders Carlssonb7906612009-08-26 23:45:07 +000030#include "clang/Basic/TargetInfo.h"
Steve Naroff4c49a6c2008-01-30 23:46:05 +000031// FIXME: layering (ideally, Sema shouldn't be dependent on Lex API's)
Chris Lattnere1e79852008-02-06 00:51:33 +000032#include "clang/Lex/Preprocessor.h"
Mike Stump1eb44332009-09-09 15:08:12 +000033#include "clang/Lex/HeaderSearch.h"
John McCall66755862009-12-24 09:58:38 +000034#include "llvm/ADT/Triple.h"
Douglas Gregor6ed40e32008-12-23 21:05:05 +000035#include <algorithm>
Douglas Gregor9a8c9a22009-09-28 21:14:19 +000036#include <cstring>
Douglas Gregor6ed40e32008-12-23 21:05:05 +000037#include <functional>
Reid Spencer5f016e22007-07-11 17:01:13 +000038using namespace clang;
39
Chris Lattner21ff9c92009-03-05 01:25:28 +000040/// getDeclName - Return a pretty name for the specified decl if possible, or
Mike Stump1eb44332009-09-09 15:08:12 +000041/// an empty string if not. This is used for pretty crash reporting.
Chris Lattnerb28317a2009-03-28 19:18:32 +000042std::string Sema::getDeclName(DeclPtrTy d) {
43 Decl *D = d.getAs<Decl>();
Chris Lattner21ff9c92009-03-05 01:25:28 +000044 if (NamedDecl *DN = dyn_cast_or_null<NamedDecl>(D))
45 return DN->getQualifiedNameAsString();
46 return "";
47}
48
Chris Lattner682bf922009-03-29 16:50:03 +000049Sema::DeclGroupPtrTy Sema::ConvertDeclToDeclGroup(DeclPtrTy Ptr) {
50 return DeclGroupPtrTy::make(DeclGroupRef(Ptr.getAs<Decl>()));
51}
52
Douglas Gregord6efafa2009-02-04 19:16:12 +000053/// \brief If the identifier refers to a type name within this scope,
54/// return the declaration of that type.
55///
56/// This routine performs ordinary name lookup of the identifier II
57/// within the given scope, with optional C++ scope specifier SS, to
Douglas Gregor1a51b4a2009-02-09 15:09:02 +000058/// determine whether the name refers to a type. If so, returns an
59/// opaque pointer (actually a QualType) corresponding to that
60/// type. Otherwise, returns NULL.
Douglas Gregord6efafa2009-02-04 19:16:12 +000061///
62/// If name lookup results in an ambiguity, this routine will complain
63/// and then return NULL.
Douglas Gregor1a51b4a2009-02-09 15:09:02 +000064Sema::TypeTy *Sema::getTypeName(IdentifierInfo &II, SourceLocation NameLoc,
Douglas Gregor42c39f32009-08-26 18:27:52 +000065 Scope *S, const CXXScopeSpec *SS,
Douglas Gregorf6e6fc82009-11-20 22:03:38 +000066 bool isClassName,
67 TypeTy *ObjectTypePtr) {
68 // Determine where we will perform name lookup.
69 DeclContext *LookupCtx = 0;
70 if (ObjectTypePtr) {
71 QualType ObjectType = QualType::getFromOpaquePtr(ObjectTypePtr);
72 if (ObjectType->isRecordType())
73 LookupCtx = computeDeclContext(ObjectType);
74 } else if (SS && SS->isSet()) {
75 LookupCtx = computeDeclContext(*SS, false);
76
77 if (!LookupCtx) {
78 if (isDependentScopeSpecifier(*SS)) {
79 // C++ [temp.res]p3:
80 // A qualified-id that refers to a type and in which the
81 // nested-name-specifier depends on a template-parameter (14.6.2)
82 // shall be prefixed by the keyword typename to indicate that the
83 // qualified-id denotes a type, forming an
84 // elaborated-type-specifier (7.1.5.3).
85 //
86 // We therefore do not perform any name lookup if the result would
87 // refer to a member of an unknown specialization.
88 if (!isClassName)
89 return 0;
90
91 // We know from the grammar that this name refers to a type, so build a
92 // TypenameType node to describe the type.
93 // FIXME: Record somewhere that this TypenameType node has no "typename"
94 // keyword associated with it.
95 return CheckTypenameType((NestedNameSpecifier *)SS->getScopeRep(),
96 II, SS->getRange()).getAsOpaquePtr();
97 }
98
Douglas Gregor42c39f32009-08-26 18:27:52 +000099 return 0;
Douglas Gregorf6e6fc82009-11-20 22:03:38 +0000100 }
101
102 if (!LookupCtx->isDependentContext() && RequireCompleteDeclContext(*SS))
103 return 0;
Douglas Gregor42c39f32009-08-26 18:27:52 +0000104 }
Eli Friedman0f0615b2009-12-21 01:42:38 +0000105
106 // FIXME: LookupNestedNameSpecifierName isn't the right kind of
107 // lookup for class-names.
108 LookupNameKind Kind = isClassName ? LookupNestedNameSpecifierName :
109 LookupOrdinaryName;
110 LookupResult Result(*this, &II, NameLoc, Kind);
Douglas Gregorf6e6fc82009-11-20 22:03:38 +0000111 if (LookupCtx) {
112 // Perform "qualified" name lookup into the declaration context we
113 // computed, which is either the type of the base of a member access
114 // expression or the declaration context associated with a prior
115 // nested-name-specifier.
116 LookupQualifiedName(Result, LookupCtx);
Douglas Gregor42af25f2009-05-11 19:58:34 +0000117
Douglas Gregorf6e6fc82009-11-20 22:03:38 +0000118 if (ObjectTypePtr && Result.empty()) {
119 // C++ [basic.lookup.classref]p3:
120 // If the unqualified-id is ~type-name, the type-name is looked up
121 // in the context of the entire postfix-expression. If the type T of
122 // the object expression is of a class type C, the type-name is also
123 // looked up in the scope of class C. At least one of the lookups shall
124 // find a name that refers to (possibly cv-qualified) T.
125 LookupName(Result, S);
126 }
127 } else {
128 // Perform unqualified name lookup.
129 LookupName(Result, S);
130 }
131
Chris Lattner22bd9052009-02-16 22:07:16 +0000132 NamedDecl *IIDecl = 0;
John McCalla24dc2e2009-11-17 02:14:36 +0000133 switch (Result.getResultKind()) {
Chris Lattner22bd9052009-02-16 22:07:16 +0000134 case LookupResult::NotFound:
Douglas Gregor7d3f5762010-01-15 01:44:47 +0000135 case LookupResult::NotFoundInCurrentInstantiation:
Chris Lattner22bd9052009-02-16 22:07:16 +0000136 case LookupResult::FoundOverloaded:
John McCall7ba107a2009-11-18 02:36:19 +0000137 case LookupResult::FoundUnresolvedValue:
John McCallc373d482010-01-27 01:50:18 +0000138 Result.suppressDiagnostics();
Chris Lattner22bd9052009-02-16 22:07:16 +0000139 return 0;
Douglas Gregorb696ea32009-02-04 17:00:24 +0000140
Chris Lattnera64ef0a2009-10-25 22:09:09 +0000141 case LookupResult::Ambiguous:
John McCall6e247262009-10-10 05:48:19 +0000142 // Recover from type-hiding ambiguities by hiding the type. We'll
143 // do the lookup again when looking for an object, and we can
144 // diagnose the error then. If we don't do this, then the error
145 // about hiding the type will be immediately followed by an error
146 // that only makes sense if the identifier was treated like a type.
John McCalla24dc2e2009-11-17 02:14:36 +0000147 if (Result.getAmbiguityKind() == LookupResult::AmbiguousTagHiding) {
148 Result.suppressDiagnostics();
John McCall6e247262009-10-10 05:48:19 +0000149 return 0;
John McCalla24dc2e2009-11-17 02:14:36 +0000150 }
John McCall6e247262009-10-10 05:48:19 +0000151
Douglas Gregor31a19b62009-04-01 21:51:26 +0000152 // Look to see if we have a type anywhere in the list of results.
153 for (LookupResult::iterator Res = Result.begin(), ResEnd = Result.end();
154 Res != ResEnd; ++Res) {
155 if (isa<TypeDecl>(*Res) || isa<ObjCInterfaceDecl>(*Res)) {
Mike Stump1eb44332009-09-09 15:08:12 +0000156 if (!IIDecl ||
157 (*Res)->getLocation().getRawEncoding() <
Douglas Gregor841b53c2009-04-13 15:14:38 +0000158 IIDecl->getLocation().getRawEncoding())
159 IIDecl = *Res;
Douglas Gregor31a19b62009-04-01 21:51:26 +0000160 }
161 }
162
163 if (!IIDecl) {
164 // None of the entities we found is a type, so there is no way
165 // to even assume that the result is a type. In this case, don't
166 // complain about the ambiguity. The parser will either try to
167 // perform this lookup again (e.g., as an object name), which
168 // will produce the ambiguity, or will complain that it expected
169 // a type name.
John McCalla24dc2e2009-11-17 02:14:36 +0000170 Result.suppressDiagnostics();
Douglas Gregor31a19b62009-04-01 21:51:26 +0000171 return 0;
172 }
173
174 // We found a type within the ambiguous lookup; diagnose the
175 // ambiguity and then return that type. This might be the right
176 // answer, or it might not be, but it suppresses any attempt to
177 // perform the name lookup again.
Douglas Gregor31a19b62009-04-01 21:51:26 +0000178 break;
Douglas Gregorb696ea32009-02-04 17:00:24 +0000179
Chris Lattner22bd9052009-02-16 22:07:16 +0000180 case LookupResult::Found:
John McCallf36e02d2009-10-09 21:13:30 +0000181 IIDecl = Result.getFoundDecl();
Chris Lattner22bd9052009-02-16 22:07:16 +0000182 break;
Douglas Gregor7176fff2009-01-15 00:26:24 +0000183 }
184
Chris Lattner10ca3372009-10-25 17:16:46 +0000185 assert(IIDecl && "Didn't find decl");
John McCall54abf7d2009-11-04 02:18:39 +0000186
Chris Lattner10ca3372009-10-25 17:16:46 +0000187 QualType T;
188 if (TypeDecl *TD = dyn_cast<TypeDecl>(IIDecl)) {
John McCall54abf7d2009-11-04 02:18:39 +0000189 DiagnoseUseOfDecl(IIDecl, NameLoc);
John McCalla24dc2e2009-11-17 02:14:36 +0000190
Chris Lattner10ca3372009-10-25 17:16:46 +0000191 // C++ [temp.local]p2:
192 // Within the scope of a class template specialization or
193 // partial specialization, when the injected-class-name is
194 // not followed by a <, it is equivalent to the
195 // injected-class-name followed by the template-argument s
196 // of the class template specialization or partial
197 // specialization enclosed in <>.
198 if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(TD))
199 if (RD->isInjectedClassName())
200 if (ClassTemplateDecl *Template = RD->getDescribedClassTemplate())
201 T = Template->getInjectedClassNameType(Context);
Mike Stump1eb44332009-09-09 15:08:12 +0000202
Chris Lattner10ca3372009-10-25 17:16:46 +0000203 if (T.isNull())
204 T = Context.getTypeDeclType(TD);
205
Douglas Gregore6258932009-03-19 00:39:20 +0000206 if (SS)
207 T = getQualifiedNameType(*SS, T);
Chris Lattner10ca3372009-10-25 17:16:46 +0000208
209 } else if (ObjCInterfaceDecl *IDecl = dyn_cast<ObjCInterfaceDecl>(IIDecl)) {
Chris Lattner10ca3372009-10-25 17:16:46 +0000210 T = Context.getObjCInterfaceType(IDecl);
John McCall7ba107a2009-11-18 02:36:19 +0000211 } else if (UnresolvedUsingTypenameDecl *UUDecl =
212 dyn_cast<UnresolvedUsingTypenameDecl>(IIDecl)) {
213 // FIXME: preserve source structure information.
214 T = Context.getTypenameType(UUDecl->getTargetNestedNameSpecifier(), &II);
John McCalla24dc2e2009-11-17 02:14:36 +0000215 } else {
216 // If it's not plausibly a type, suppress diagnostics.
217 Result.suppressDiagnostics();
Chris Lattner10ca3372009-10-25 17:16:46 +0000218 return 0;
John McCalla24dc2e2009-11-17 02:14:36 +0000219 }
Douglas Gregore4e5b052009-03-19 00:18:19 +0000220
Chris Lattner10ca3372009-10-25 17:16:46 +0000221 return T.getAsOpaquePtr();
Reid Spencer5f016e22007-07-11 17:01:13 +0000222}
223
Chris Lattner4c97d762009-04-12 21:49:30 +0000224/// isTagName() - This method is called *for error recovery purposes only*
225/// to determine if the specified name is a valid tag name ("struct foo"). If
226/// so, this returns the TST for the tag corresponding to it (TST_enum,
227/// TST_union, TST_struct, TST_class). This is used to diagnose cases in C
228/// where the user forgot to specify the tag.
229DeclSpec::TST Sema::isTagName(IdentifierInfo &II, Scope *S) {
230 // Do a tag name lookup in this scope.
John McCalla24dc2e2009-11-17 02:14:36 +0000231 LookupResult R(*this, &II, SourceLocation(), LookupTagName);
232 LookupName(R, S, false);
233 R.suppressDiagnostics();
234 if (R.getResultKind() == LookupResult::Found)
John McCall1bcee0a2009-12-02 08:25:40 +0000235 if (const TagDecl *TD = R.getAsSingle<TagDecl>()) {
Chris Lattner4c97d762009-04-12 21:49:30 +0000236 switch (TD->getTagKind()) {
237 case TagDecl::TK_struct: return DeclSpec::TST_struct;
238 case TagDecl::TK_union: return DeclSpec::TST_union;
239 case TagDecl::TK_class: return DeclSpec::TST_class;
240 case TagDecl::TK_enum: return DeclSpec::TST_enum;
241 }
242 }
Mike Stump1eb44332009-09-09 15:08:12 +0000243
Chris Lattner4c97d762009-04-12 21:49:30 +0000244 return DeclSpec::TST_unspecified;
245}
246
Douglas Gregora786fdb2009-10-13 23:27:22 +0000247bool Sema::DiagnoseUnknownTypeName(const IdentifierInfo &II,
248 SourceLocation IILoc,
249 Scope *S,
250 const CXXScopeSpec *SS,
251 TypeTy *&SuggestedType) {
252 // We don't have anything to suggest (yet).
253 SuggestedType = 0;
254
Douglas Gregor546be3c2009-12-30 17:04:44 +0000255 // There may have been a typo in the name of the type. Look up typo
256 // results, in case we have something that we can suggest.
257 LookupResult Lookup(*this, &II, IILoc, LookupOrdinaryName,
258 NotForRedeclaration);
259
260 // FIXME: It would be nice if we could correct for typos in built-in
261 // names, such as "itn" for "int".
262
263 if (CorrectTypo(Lookup, S, SS) && Lookup.isSingleResult()) {
264 NamedDecl *Result = Lookup.getAsSingle<NamedDecl>();
265 if ((isa<TypeDecl>(Result) || isa<ObjCInterfaceDecl>(Result)) &&
266 !Result->isInvalidDecl()) {
267 // We found a similarly-named type or interface; suggest that.
268 if (!SS || !SS->isSet())
269 Diag(IILoc, diag::err_unknown_typename_suggest)
270 << &II << Lookup.getLookupName()
271 << CodeModificationHint::CreateReplacement(SourceRange(IILoc),
272 Result->getNameAsString());
273 else if (DeclContext *DC = computeDeclContext(*SS, false))
274 Diag(IILoc, diag::err_unknown_nested_typename_suggest)
275 << &II << DC << Lookup.getLookupName() << SS->getRange()
276 << CodeModificationHint::CreateReplacement(SourceRange(IILoc),
277 Result->getNameAsString());
278 else
279 llvm_unreachable("could not have corrected a typo here");
280
Douglas Gregor67dd1d42010-01-07 00:17:44 +0000281 Diag(Result->getLocation(), diag::note_previous_decl)
282 << Result->getDeclName();
283
Douglas Gregor546be3c2009-12-30 17:04:44 +0000284 SuggestedType = getTypeName(*Result->getIdentifier(), IILoc, S, SS);
285 return true;
286 }
287 }
288
Douglas Gregora786fdb2009-10-13 23:27:22 +0000289 // FIXME: Should we move the logic that tries to recover from a missing tag
290 // (struct, union, enum) from Parser::ParseImplicitInt here, instead?
291
Douglas Gregor546be3c2009-12-30 17:04:44 +0000292 if (!SS || (!SS->isSet() && !SS->isInvalid()))
Douglas Gregora786fdb2009-10-13 23:27:22 +0000293 Diag(IILoc, diag::err_unknown_typename) << &II;
294 else if (DeclContext *DC = computeDeclContext(*SS, false))
295 Diag(IILoc, diag::err_typename_nested_not_found)
296 << &II << DC << SS->getRange();
297 else if (isDependentScopeSpecifier(*SS)) {
298 Diag(SS->getRange().getBegin(), diag::err_typename_missing)
Daniel Dunbar01eb9b92009-10-18 21:17:35 +0000299 << (NestedNameSpecifier *)SS->getScopeRep() << II.getName()
Douglas Gregora786fdb2009-10-13 23:27:22 +0000300 << SourceRange(SS->getRange().getBegin(), IILoc)
301 << CodeModificationHint::CreateInsertion(SS->getRange().getBegin(),
302 "typename ");
303 SuggestedType = ActOnTypenameType(SourceLocation(), *SS, II, IILoc).get();
304 } else {
305 assert(SS && SS->isInvalid() &&
306 "Invalid scope specifier has already been diagnosed");
307 }
308
309 return true;
310}
Chris Lattner4c97d762009-04-12 21:49:30 +0000311
John McCall88232aa2009-08-18 00:00:49 +0000312// Determines the context to return to after temporarily entering a
313// context. This depends in an unnecessarily complicated way on the
314// exact ordering of callbacks from the parser.
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +0000315DeclContext *Sema::getContainingDC(DeclContext *DC) {
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +0000316
John McCall88232aa2009-08-18 00:00:49 +0000317 // Functions defined inline within classes aren't parsed until we've
318 // finished parsing the top-level class, so the top-level class is
319 // the context we'll need to return to.
320 if (isa<FunctionDecl>(DC)) {
321 DC = DC->getLexicalParent();
322
323 // A function not defined within a class will always return to its
324 // lexical context.
325 if (!isa<CXXRecordDecl>(DC))
326 return DC;
327
328 // A C++ inline method/friend is parsed *after* the topmost class
329 // it was declared in is fully parsed ("complete"); the topmost
330 // class is the context we need to return to.
Argyrios Kyrtzidis77407b82008-11-19 18:01:13 +0000331 while (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(DC->getLexicalParent()))
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000332 DC = RD;
333
334 // Return the declaration context of the topmost class the inline method is
335 // declared in.
336 return DC;
337 }
338
Argyrios Kyrtzidis52393042008-11-09 23:41:00 +0000339 if (isa<ObjCMethodDecl>(DC))
340 return Context.getTranslationUnitDecl();
341
Argyrios Kyrtzidis77407b82008-11-19 18:01:13 +0000342 return DC->getLexicalParent();
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000343}
344
Douglas Gregor44b43212008-12-11 16:49:14 +0000345void Sema::PushDeclContext(Scope *S, DeclContext *DC) {
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +0000346 assert(getContainingDC(DC) == CurContext &&
Zhongxing Xue50897a2008-12-08 07:14:51 +0000347 "The next DeclContext should be lexically contained in the current one.");
Chris Lattner9fdf9c62008-04-22 18:39:57 +0000348 CurContext = DC;
Douglas Gregor44b43212008-12-11 16:49:14 +0000349 S->setEntity(DC);
Chris Lattner0ed844b2008-04-04 06:12:32 +0000350}
351
Chris Lattnerb048c982008-04-06 04:47:34 +0000352void Sema::PopDeclContext() {
353 assert(CurContext && "DeclContext imbalance!");
Douglas Gregor44b43212008-12-11 16:49:14 +0000354
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +0000355 CurContext = getContainingDC(CurContext);
Chris Lattner0ed844b2008-04-04 06:12:32 +0000356}
357
Argyrios Kyrtzidis179fe1a2009-06-17 23:19:02 +0000358/// EnterDeclaratorContext - Used when we must lookup names in the context
359/// of a declarator's nested name specifier.
John McCall7a1dc562009-12-19 10:49:29 +0000360///
Argyrios Kyrtzidis1d175532009-06-17 23:15:40 +0000361void Sema::EnterDeclaratorContext(Scope *S, DeclContext *DC) {
John McCall7a1dc562009-12-19 10:49:29 +0000362 // C++0x [basic.lookup.unqual]p13:
363 // A name used in the definition of a static data member of class
364 // X (after the qualified-id of the static member) is looked up as
365 // if the name was used in a member function of X.
366 // C++0x [basic.lookup.unqual]p14:
367 // If a variable member of a namespace is defined outside of the
368 // scope of its namespace then any name used in the definition of
369 // the variable member (after the declarator-id) is looked up as
370 // if the definition of the variable member occurred in its
371 // namespace.
372 // Both of these imply that we should push a scope whose context
373 // is the semantic context of the declaration. We can't use
374 // PushDeclContext here because that context is not necessarily
375 // lexically contained in the current context. Fortunately,
376 // the containing scope should have the appropriate information.
377
378 assert(!S->getEntity() && "scope already has entity");
379
380#ifndef NDEBUG
381 Scope *Ancestor = S->getParent();
382 while (!Ancestor->getEntity()) Ancestor = Ancestor->getParent();
383 assert(Ancestor->getEntity() == CurContext && "ancestor context mismatch");
384#endif
385
Argyrios Kyrtzidis1d175532009-06-17 23:15:40 +0000386 CurContext = DC;
John McCall7a1dc562009-12-19 10:49:29 +0000387 S->setEntity(DC);
Argyrios Kyrtzidis1d175532009-06-17 23:15:40 +0000388}
389
Argyrios Kyrtzidis1d175532009-06-17 23:15:40 +0000390void Sema::ExitDeclaratorContext(Scope *S) {
John McCall7a1dc562009-12-19 10:49:29 +0000391 assert(S->getEntity() == CurContext && "Context imbalance!");
Argyrios Kyrtzidis1d175532009-06-17 23:15:40 +0000392
John McCall7a1dc562009-12-19 10:49:29 +0000393 // Switch back to the lexical context. The safety of this is
394 // enforced by an assert in EnterDeclaratorContext.
395 Scope *Ancestor = S->getParent();
396 while (!Ancestor->getEntity()) Ancestor = Ancestor->getParent();
397 CurContext = (DeclContext*) Ancestor->getEntity();
398
399 // We don't need to do anything with the scope, which is going to
400 // disappear.
Argyrios Kyrtzidis1d175532009-06-17 23:15:40 +0000401}
402
Douglas Gregorf9201e02009-02-11 23:02:49 +0000403/// \brief Determine whether we allow overloading of the function
404/// PrevDecl with another declaration.
405///
406/// This routine determines whether overloading is possible, not
407/// whether some new function is actually an overload. It will return
408/// true in C++ (where we can always provide overloads) or, as an
409/// extension, in C when the previous function is already an
410/// overloaded function declaration or has the "overloadable"
411/// attribute.
John McCall68263142009-11-18 22:49:29 +0000412static bool AllowOverloadingOfFunction(LookupResult &Previous,
413 ASTContext &Context) {
Douglas Gregorf9201e02009-02-11 23:02:49 +0000414 if (Context.getLangOptions().CPlusPlus)
415 return true;
416
John McCall68263142009-11-18 22:49:29 +0000417 if (Previous.getResultKind() == LookupResult::FoundOverloaded)
Douglas Gregorf9201e02009-02-11 23:02:49 +0000418 return true;
419
John McCall68263142009-11-18 22:49:29 +0000420 return (Previous.getResultKind() == LookupResult::Found
421 && Previous.getFoundDecl()->hasAttr<OverloadableAttr>());
Douglas Gregorf9201e02009-02-11 23:02:49 +0000422}
423
Argyrios Kyrtzidis87f3ff02008-04-12 00:47:19 +0000424/// Add this decl to the scope shadowed decl chains.
John McCallab88d972009-08-31 22:39:49 +0000425void Sema::PushOnScopeChains(NamedDecl *D, Scope *S, bool AddToContext) {
Douglas Gregor074149e2009-01-05 19:45:36 +0000426 // Move up the scope chain until we find the nearest enclosing
427 // non-transparent context. The declaration will be introduced into this
428 // scope.
Mike Stump1eb44332009-09-09 15:08:12 +0000429 while (S->getEntity() &&
Douglas Gregor074149e2009-01-05 19:45:36 +0000430 ((DeclContext *)S->getEntity())->isTransparentContext())
431 S = S->getParent();
432
Douglas Gregor6ed40e32008-12-23 21:05:05 +0000433 // Add scoped declarations into their context, so that they can be
434 // found later. Declarations without a context won't be inserted
435 // into any context.
John McCallab88d972009-08-31 22:39:49 +0000436 if (AddToContext)
437 CurContext->addDecl(D);
Douglas Gregor6ed40e32008-12-23 21:05:05 +0000438
Douglas Gregord04b1be2009-09-28 18:41:37 +0000439 // Out-of-line function and variable definitions should not be pushed into
440 // scope.
441 if ((isa<FunctionTemplateDecl>(D) &&
442 cast<FunctionTemplateDecl>(D)->getTemplatedDecl()->isOutOfLine()) ||
Eli Friedman6bc20132009-12-08 05:40:03 +0000443 (isa<FunctionDecl>(D) &&
444 (cast<FunctionDecl>(D)->isFunctionTemplateSpecialization() ||
445 cast<FunctionDecl>(D)->isOutOfLine())) ||
Douglas Gregord04b1be2009-09-28 18:41:37 +0000446 (isa<VarDecl>(D) && cast<VarDecl>(D)->isOutOfLine()))
447 return;
448
John McCallf36e02d2009-10-09 21:13:30 +0000449 // If this replaces anything in the current scope,
450 IdentifierResolver::iterator I = IdResolver.begin(D->getDeclName()),
451 IEnd = IdResolver.end();
452 for (; I != IEnd; ++I) {
453 if (S->isDeclScope(DeclPtrTy::make(*I)) && D->declarationReplaces(*I)) {
454 S->RemoveDecl(DeclPtrTy::make(*I));
455 IdResolver.RemoveDecl(*I);
Argyrios Kyrtzidis00bc6452008-05-09 23:39:43 +0000456
John McCallf36e02d2009-10-09 21:13:30 +0000457 // Should only need to replace one decl.
458 break;
Douglas Gregor516ff432009-04-24 02:57:34 +0000459 }
Argyrios Kyrtzidis00bc6452008-05-09 23:39:43 +0000460 }
Douglas Gregor8e9bebd2008-10-21 16:13:35 +0000461
John McCallf36e02d2009-10-09 21:13:30 +0000462 S->AddDecl(DeclPtrTy::make(D));
Argyrios Kyrtzidis00bc6452008-05-09 23:39:43 +0000463 IdResolver.AddDecl(D);
Argyrios Kyrtzidis87f3ff02008-04-12 00:47:19 +0000464}
465
Douglas Gregor2531c2d2009-09-28 00:47:05 +0000466bool Sema::isDeclInScope(NamedDecl *&D, DeclContext *Ctx, Scope *S) {
Douglas Gregor2531c2d2009-09-28 00:47:05 +0000467 return IdResolver.isDeclInScope(D, Ctx, Context, S);
468}
469
John McCall68263142009-11-18 22:49:29 +0000470static bool isOutOfScopePreviousDeclaration(NamedDecl *,
471 DeclContext*,
472 ASTContext&);
473
474/// Filters out lookup results that don't fall within the given scope
475/// as determined by isDeclInScope.
476static void FilterLookupForScope(Sema &SemaRef, LookupResult &R,
477 DeclContext *Ctx, Scope *S,
478 bool ConsiderLinkage) {
479 LookupResult::Filter F = R.makeFilter();
480 while (F.hasNext()) {
481 NamedDecl *D = F.next();
482
483 if (SemaRef.isDeclInScope(D, Ctx, S))
484 continue;
485
486 if (ConsiderLinkage &&
487 isOutOfScopePreviousDeclaration(D, Ctx, SemaRef.Context))
488 continue;
489
490 F.erase();
491 }
492
493 F.done();
494}
495
496static bool isUsingDecl(NamedDecl *D) {
497 return isa<UsingShadowDecl>(D) ||
498 isa<UnresolvedUsingTypenameDecl>(D) ||
499 isa<UnresolvedUsingValueDecl>(D);
500}
501
502/// Removes using shadow declarations from the lookup results.
503static void RemoveUsingDecls(LookupResult &R) {
504 LookupResult::Filter F = R.makeFilter();
505 while (F.hasNext())
506 if (isUsingDecl(F.next()))
507 F.erase();
508
509 F.done();
510}
511
Anders Carlsson99a000e2009-11-07 07:18:14 +0000512static bool ShouldDiagnoseUnusedDecl(const NamedDecl *D) {
Anders Carlssonf7613d52009-11-07 07:26:56 +0000513 if (D->isUsed() || D->hasAttr<UnusedAttr>())
514 return false;
515
516 if (const ValueDecl *VD = dyn_cast<ValueDecl>(D)) {
517 if (const RecordType *RT = VD->getType()->getAs<RecordType>()) {
518 if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(RT->getDecl())) {
519 if (!RD->hasTrivialConstructor())
520 return false;
521 if (!RD->hasTrivialDestructor())
522 return false;
523 }
524 }
525 }
526
527 return (isa<VarDecl>(D) && !isa<ParmVarDecl>(D) &&
528 !isa<ImplicitParamDecl>(D) &&
Anders Carlsson99a000e2009-11-07 07:18:14 +0000529 D->getDeclContext()->isFunctionOrMethod());
530}
531
Steve Naroffb216c882007-10-09 22:01:59 +0000532void Sema::ActOnPopScope(SourceLocation Loc, Scope *S) {
Chris Lattner31e05722007-08-26 06:24:45 +0000533 if (S->decl_empty()) return;
Douglas Gregor72c3f312008-12-05 18:15:24 +0000534 assert((S->getFlags() & (Scope::DeclScope | Scope::TemplateParamScope)) &&
Mike Stump1eb44332009-09-09 15:08:12 +0000535 "Scope shouldn't contain decls!");
Argyrios Kyrtzidis00bc6452008-05-09 23:39:43 +0000536
Reid Spencer5f016e22007-07-11 17:01:13 +0000537 for (Scope::decl_iterator I = S->decl_begin(), E = S->decl_end();
538 I != E; ++I) {
Chris Lattnerb28317a2009-03-28 19:18:32 +0000539 Decl *TmpD = (*I).getAs<Decl>();
Steve Naroffc752d042007-09-13 18:10:37 +0000540 assert(TmpD && "This decl didn't get pushed??");
Argyrios Kyrtzidis76435362008-06-10 01:32:09 +0000541
Douglas Gregor44b43212008-12-11 16:49:14 +0000542 assert(isa<NamedDecl>(TmpD) && "Decl isn't NamedDecl?");
543 NamedDecl *D = cast<NamedDecl>(TmpD);
Argyrios Kyrtzidis76435362008-06-10 01:32:09 +0000544
Douglas Gregor44b43212008-12-11 16:49:14 +0000545 if (!D->getDeclName()) continue;
Chris Lattner7f925cc2008-04-11 07:00:53 +0000546
Douglas Gregorb5352cf2009-10-08 21:35:42 +0000547 // Diagnose unused variables in this scope.
Anders Carlsson99a000e2009-11-07 07:18:14 +0000548 if (ShouldDiagnoseUnusedDecl(D))
549 Diag(D->getLocation(), diag::warn_unused_variable) << D->getDeclName();
Douglas Gregorb5352cf2009-10-08 21:35:42 +0000550
Douglas Gregor44b43212008-12-11 16:49:14 +0000551 // Remove this name from our lexical scope.
552 IdResolver.RemoveDecl(D);
Reid Spencer5f016e22007-07-11 17:01:13 +0000553 }
554}
555
Steve Naroffe8043c32008-04-01 23:04:06 +0000556/// getObjCInterfaceDecl - Look up a for a class declaration in the scope.
557/// return 0 if one not found.
Douglas Gregorf06cdae2010-01-03 18:01:57 +0000558///
559/// \param Id the name of the Objective-C class we're looking for. If
560/// typo-correction fixes this name, the Id will be updated
561/// to the fixed name.
562///
563/// \param RecoverLoc if provided, this routine will attempt to
564/// recover from a typo in the name of an existing Objective-C class
565/// and, if successful, will return the lookup that results from
566/// typo-correction.
567ObjCInterfaceDecl *Sema::getObjCInterfaceDecl(IdentifierInfo *&Id,
568 SourceLocation RecoverLoc) {
Steve Naroff31102512008-04-02 18:30:49 +0000569 // The third "scope" argument is 0 since we aren't enabling lazy built-in
570 // creation from this context.
John McCallf36e02d2009-10-09 21:13:30 +0000571 NamedDecl *IDecl = LookupSingleName(TUScope, Id, LookupOrdinaryName);
Mike Stump1eb44332009-09-09 15:08:12 +0000572
Douglas Gregorf06cdae2010-01-03 18:01:57 +0000573 if (!IDecl && !RecoverLoc.isInvalid()) {
574 // Perform typo correction at the given location, but only if we
575 // find an Objective-C class name.
576 LookupResult R(*this, Id, RecoverLoc, LookupOrdinaryName);
577 if (CorrectTypo(R, TUScope, 0) &&
578 (IDecl = R.getAsSingle<ObjCInterfaceDecl>())) {
579 Diag(RecoverLoc, diag::err_undef_interface_suggest)
580 << Id << IDecl->getDeclName()
581 << CodeModificationHint::CreateReplacement(RecoverLoc,
582 IDecl->getNameAsString());
Douglas Gregor67dd1d42010-01-07 00:17:44 +0000583 Diag(IDecl->getLocation(), diag::note_previous_decl)
584 << IDecl->getDeclName();
585
Douglas Gregorf06cdae2010-01-03 18:01:57 +0000586 Id = IDecl->getIdentifier();
587 }
588 }
589
Steve Naroffb327ce02008-04-02 14:35:35 +0000590 return dyn_cast_or_null<ObjCInterfaceDecl>(IDecl);
Fariborz Jahanian4cabdfc2007-10-12 19:38:20 +0000591}
592
Douglas Gregor1a0d31a2009-01-12 18:45:55 +0000593/// getNonFieldDeclScope - Retrieves the innermost scope, starting
594/// from S, where a non-field would be declared. This routine copes
595/// with the difference between C and C++ scoping rules in structs and
596/// unions. For example, the following code is well-formed in C but
597/// ill-formed in C++:
598/// @code
599/// struct S6 {
600/// enum { BAR } e;
601/// };
Mike Stump1eb44332009-09-09 15:08:12 +0000602///
Douglas Gregor1a0d31a2009-01-12 18:45:55 +0000603/// void test_S6() {
604/// struct S6 a;
605/// a.e = BAR;
606/// }
607/// @endcode
608/// For the declaration of BAR, this routine will return a different
609/// scope. The scope S will be the scope of the unnamed enumeration
610/// within S6. In C++, this routine will return the scope associated
611/// with S6, because the enumeration's scope is a transparent
612/// context but structures can contain non-field names. In C, this
613/// routine will return the translation unit scope, since the
614/// enumeration's scope is a transparent context and structures cannot
615/// contain non-field names.
616Scope *Sema::getNonFieldDeclScope(Scope *S) {
617 while (((S->getFlags() & Scope::DeclScope) == 0) ||
Mike Stump1eb44332009-09-09 15:08:12 +0000618 (S->getEntity() &&
Douglas Gregor1a0d31a2009-01-12 18:45:55 +0000619 ((DeclContext *)S->getEntity())->isTransparentContext()) ||
620 (S->isClassScope() && !getLangOptions().CPlusPlus))
621 S = S->getParent();
622 return S;
623}
624
Chris Lattner95e2c712008-05-05 22:18:14 +0000625void Sema::InitBuiltinVaListType() {
Anders Carlsson7c50aca2007-10-15 20:28:48 +0000626 if (!Context.getBuiltinVaListType().isNull())
627 return;
Mike Stump1eb44332009-09-09 15:08:12 +0000628
Anders Carlsson7c50aca2007-10-15 20:28:48 +0000629 IdentifierInfo *VaIdent = &Context.Idents.get("__builtin_va_list");
John McCallf36e02d2009-10-09 21:13:30 +0000630 NamedDecl *VaDecl = LookupSingleName(TUScope, VaIdent, LookupOrdinaryName);
Steve Naroff733002f2007-10-18 22:17:45 +0000631 TypedefDecl *VaTypedef = cast<TypedefDecl>(VaDecl);
Anders Carlsson7c50aca2007-10-15 20:28:48 +0000632 Context.setBuiltinVaListType(Context.getTypedefType(VaTypedef));
633}
634
Douglas Gregor3e41d602009-02-13 23:20:09 +0000635/// LazilyCreateBuiltin - The specified Builtin-ID was first used at
636/// file scope. lazily create a decl for it. ForRedeclaration is true
637/// if we're creating this built-in in anticipation of redeclaring the
638/// built-in.
Douglas Gregor4afa39d2009-01-20 01:17:11 +0000639NamedDecl *Sema::LazilyCreateBuiltin(IdentifierInfo *II, unsigned bid,
Douglas Gregor3e41d602009-02-13 23:20:09 +0000640 Scope *S, bool ForRedeclaration,
641 SourceLocation Loc) {
Reid Spencer5f016e22007-07-11 17:01:13 +0000642 Builtin::ID BID = (Builtin::ID)bid;
643
Chris Lattnerbd7eb1c2008-09-28 05:54:29 +0000644 if (Context.BuiltinInfo.hasVAListUse(BID))
Anders Carlsson7c50aca2007-10-15 20:28:48 +0000645 InitBuiltinVaListType();
Douglas Gregor3e41d602009-02-13 23:20:09 +0000646
Chris Lattner86df27b2009-06-14 00:45:47 +0000647 ASTContext::GetBuiltinTypeError Error;
Mike Stump1eb44332009-09-09 15:08:12 +0000648 QualType R = Context.GetBuiltinType(BID, Error);
Douglas Gregor370ab3f2009-02-14 01:52:53 +0000649 switch (Error) {
Chris Lattner86df27b2009-06-14 00:45:47 +0000650 case ASTContext::GE_None:
Douglas Gregor370ab3f2009-02-14 01:52:53 +0000651 // Okay
652 break;
653
Mike Stumpf711c412009-07-28 23:57:15 +0000654 case ASTContext::GE_Missing_stdio:
Douglas Gregor370ab3f2009-02-14 01:52:53 +0000655 if (ForRedeclaration)
656 Diag(Loc, diag::err_implicit_decl_requires_stdio)
657 << Context.BuiltinInfo.GetName(BID);
658 return 0;
Mike Stump782fa302009-07-28 02:25:19 +0000659
Mike Stumpf711c412009-07-28 23:57:15 +0000660 case ASTContext::GE_Missing_setjmp:
Mike Stump782fa302009-07-28 02:25:19 +0000661 if (ForRedeclaration)
662 Diag(Loc, diag::err_implicit_decl_requires_setjmp)
663 << Context.BuiltinInfo.GetName(BID);
664 return 0;
Douglas Gregor370ab3f2009-02-14 01:52:53 +0000665 }
Douglas Gregor3e41d602009-02-13 23:20:09 +0000666
667 if (!ForRedeclaration && Context.BuiltinInfo.isPredefinedLibFunction(BID)) {
668 Diag(Loc, diag::ext_implicit_lib_function_decl)
669 << Context.BuiltinInfo.GetName(BID)
670 << R;
Douglas Gregorb1152d82009-02-16 21:58:21 +0000671 if (Context.BuiltinInfo.getHeaderName(BID) &&
Chris Lattner6a7334d2009-04-16 03:59:32 +0000672 Diags.getDiagnosticLevel(diag::ext_implicit_lib_function_decl)
673 != Diagnostic::Ignored)
Douglas Gregor3e41d602009-02-13 23:20:09 +0000674 Diag(Loc, diag::note_please_include_header)
675 << Context.BuiltinInfo.getHeaderName(BID)
676 << Context.BuiltinInfo.GetName(BID);
677 }
678
Argyrios Kyrtzidisff898cd2008-04-17 14:47:13 +0000679 FunctionDecl *New = FunctionDecl::Create(Context,
680 Context.getTranslationUnitDecl(),
John McCalla93c9342009-12-07 02:54:59 +0000681 Loc, II, R, /*TInfo=*/0,
Douglas Gregor2224f842009-02-25 16:33:18 +0000682 FunctionDecl::Extern, false,
683 /*hasPrototype=*/true);
Douglas Gregor3e41d602009-02-13 23:20:09 +0000684 New->setImplicit();
685
Chris Lattner95e2c712008-05-05 22:18:14 +0000686 // Create Decl objects for each parameter, adding them to the
687 // FunctionDecl.
Douglas Gregor72564e72009-02-26 23:50:07 +0000688 if (FunctionProtoType *FT = dyn_cast<FunctionProtoType>(R)) {
Chris Lattner95e2c712008-05-05 22:18:14 +0000689 llvm::SmallVector<ParmVarDecl*, 16> Params;
690 for (unsigned i = 0, e = FT->getNumArgs(); i != e; ++i)
691 Params.push_back(ParmVarDecl::Create(Context, New, SourceLocation(), 0,
John McCalla93c9342009-12-07 02:54:59 +0000692 FT->getArgType(i), /*TInfo=*/0,
Argyrios Kyrtzidisa1d56622009-08-19 01:27:57 +0000693 VarDecl::None, 0));
Jay Foadbeaaccd2009-05-21 09:52:38 +0000694 New->setParams(Context, Params.data(), Params.size());
Chris Lattner95e2c712008-05-05 22:18:14 +0000695 }
Mike Stump1eb44332009-09-09 15:08:12 +0000696
697 AddKnownFunctionAttributes(New);
698
Chris Lattner7f925cc2008-04-11 07:00:53 +0000699 // TUScope is the translation-unit scope to insert this function into.
Douglas Gregora8cc8ce2009-01-09 18:51:29 +0000700 // FIXME: This is hideous. We need to teach PushOnScopeChains to
701 // relate Scopes to DeclContexts, and probably eliminate CurContext
702 // entirely, but we're not there yet.
703 DeclContext *SavedContext = CurContext;
704 CurContext = Context.getTranslationUnitDecl();
Argyrios Kyrtzidis00bc6452008-05-09 23:39:43 +0000705 PushOnScopeChains(New, TUScope);
Douglas Gregora8cc8ce2009-01-09 18:51:29 +0000706 CurContext = SavedContext;
Reid Spencer5f016e22007-07-11 17:01:13 +0000707 return New;
708}
709
Douglas Gregorcda9c672009-02-16 17:45:42 +0000710/// MergeTypeDefDecl - We just parsed a typedef 'New' which has the
711/// same name and scope as a previous declaration 'Old'. Figure out
712/// how to resolve this situation, merging decls or emitting
Chris Lattnereaaebc72009-04-25 08:06:05 +0000713/// diagnostics as appropriate. If there was an error, set New to be invalid.
Reid Spencer5f016e22007-07-11 17:01:13 +0000714///
John McCall68263142009-11-18 22:49:29 +0000715void Sema::MergeTypeDefDecl(TypedefDecl *New, LookupResult &OldDecls) {
716 // If the new decl is known invalid already, don't bother doing any
717 // merging checks.
718 if (New->isInvalidDecl()) return;
Mike Stump1eb44332009-09-09 15:08:12 +0000719
Steve Naroff2b255c42008-09-09 14:32:20 +0000720 // Allow multiple definitions for ObjC built-in typedefs.
721 // FIXME: Verify the underlying types are equivalent!
722 if (getLangOptions().ObjC1) {
Chris Lattner2bac0f62008-11-20 05:41:43 +0000723 const IdentifierInfo *TypeID = New->getIdentifier();
724 switch (TypeID->getLength()) {
725 default: break;
Mike Stump1eb44332009-09-09 15:08:12 +0000726 case 2:
Chris Lattner2bac0f62008-11-20 05:41:43 +0000727 if (!TypeID->isStr("id"))
728 break;
David Chisnall0f436562009-08-17 16:35:33 +0000729 Context.ObjCIdRedefinitionType = New->getUnderlyingType();
Steve Naroff14108da2009-07-10 23:34:53 +0000730 // Install the built-in type for 'id', ignoring the current definition.
731 New->setTypeForDecl(Context.getObjCIdType().getTypePtr());
732 return;
Chris Lattner2bac0f62008-11-20 05:41:43 +0000733 case 5:
734 if (!TypeID->isStr("Class"))
735 break;
David Chisnall0f436562009-08-17 16:35:33 +0000736 Context.ObjCClassRedefinitionType = New->getUnderlyingType();
Steve Naroff14108da2009-07-10 23:34:53 +0000737 // Install the built-in type for 'Class', ignoring the current definition.
738 New->setTypeForDecl(Context.getObjCClassType().getTypePtr());
Chris Lattnereaaebc72009-04-25 08:06:05 +0000739 return;
Chris Lattner2bac0f62008-11-20 05:41:43 +0000740 case 3:
741 if (!TypeID->isStr("SEL"))
742 break;
Fariborz Jahanian369a3bd2009-11-25 23:07:42 +0000743 Context.ObjCSelRedefinitionType = New->getUnderlyingType();
Fariborz Jahanian13dcd002009-11-21 19:53:08 +0000744 // Install the built-in type for 'SEL', ignoring the current definition.
745 New->setTypeForDecl(Context.getObjCSelType().getTypePtr());
Chris Lattnereaaebc72009-04-25 08:06:05 +0000746 return;
Chris Lattner2bac0f62008-11-20 05:41:43 +0000747 case 8:
748 if (!TypeID->isStr("Protocol"))
749 break;
Steve Naroff2b255c42008-09-09 14:32:20 +0000750 Context.setObjCProtoType(New->getUnderlyingType());
Chris Lattnereaaebc72009-04-25 08:06:05 +0000751 return;
Steve Naroff2b255c42008-09-09 14:32:20 +0000752 }
753 // Fall through - the typedef name was not a builtin type.
754 }
John McCall68263142009-11-18 22:49:29 +0000755
Douglas Gregor66973122009-01-28 17:15:10 +0000756 // Verify the old decl was also a type.
John McCall5126fd02009-12-30 00:31:22 +0000757 TypeDecl *Old = OldDecls.getAsSingle<TypeDecl>();
758 if (!Old) {
Mike Stump1eb44332009-09-09 15:08:12 +0000759 Diag(New->getLocation(), diag::err_redefinition_different_kind)
Chris Lattner08631c52008-11-23 21:45:46 +0000760 << New->getDeclName();
John McCall68263142009-11-18 22:49:29 +0000761
762 NamedDecl *OldD = OldDecls.getRepresentativeDecl();
Chris Lattnereaaebc72009-04-25 08:06:05 +0000763 if (OldD->getLocation().isValid())
Fariborz Jahanianc55a2402009-01-16 19:58:32 +0000764 Diag(OldD->getLocation(), diag::note_previous_definition);
John McCall68263142009-11-18 22:49:29 +0000765
Chris Lattnereaaebc72009-04-25 08:06:05 +0000766 return New->setInvalidDecl();
Reid Spencer5f016e22007-07-11 17:01:13 +0000767 }
Douglas Gregor66973122009-01-28 17:15:10 +0000768
John McCall68263142009-11-18 22:49:29 +0000769 // If the old declaration is invalid, just give up here.
770 if (Old->isInvalidDecl())
771 return New->setInvalidDecl();
772
Mike Stump1eb44332009-09-09 15:08:12 +0000773 // Determine the "old" type we'll use for checking and diagnostics.
Douglas Gregor66973122009-01-28 17:15:10 +0000774 QualType OldType;
775 if (TypedefDecl *OldTypedef = dyn_cast<TypedefDecl>(Old))
776 OldType = OldTypedef->getUnderlyingType();
777 else
778 OldType = Context.getTypeDeclType(Old);
779
Chris Lattner99cb9972008-07-25 18:44:27 +0000780 // If the typedef types are not identical, reject them in all languages and
781 // with any extensions enabled.
Douglas Gregor66973122009-01-28 17:15:10 +0000782
Mike Stump1eb44332009-09-09 15:08:12 +0000783 if (OldType != New->getUnderlyingType() &&
784 Context.getCanonicalType(OldType) !=
Chris Lattner99cb9972008-07-25 18:44:27 +0000785 Context.getCanonicalType(New->getUnderlyingType())) {
Chris Lattner5dc266a2008-11-20 06:13:02 +0000786 Diag(New->getLocation(), diag::err_redefinition_different_typedef)
Douglas Gregor66973122009-01-28 17:15:10 +0000787 << New->getUnderlyingType() << OldType;
Chris Lattnereaaebc72009-04-25 08:06:05 +0000788 if (Old->getLocation().isValid())
Fariborz Jahanianc55a2402009-01-16 19:58:32 +0000789 Diag(Old->getLocation(), diag::note_previous_definition);
Chris Lattnereaaebc72009-04-25 08:06:05 +0000790 return New->setInvalidDecl();
Chris Lattner99cb9972008-07-25 18:44:27 +0000791 }
Mike Stump1eb44332009-09-09 15:08:12 +0000792
John McCall5126fd02009-12-30 00:31:22 +0000793 // The types match. Link up the redeclaration chain if the old
794 // declaration was a typedef.
795 // FIXME: this is a potential source of wierdness if the type
796 // spellings don't match exactly.
797 if (isa<TypedefDecl>(Old))
798 New->setPreviousDeclaration(cast<TypedefDecl>(Old));
799
Steve Naroff14108da2009-07-10 23:34:53 +0000800 if (getLangOptions().Microsoft)
Chris Lattnereaaebc72009-04-25 08:06:05 +0000801 return;
Eli Friedman54ecfce2008-06-11 06:20:39 +0000802
Chris Lattner32b06752009-04-17 22:04:20 +0000803 if (getLangOptions().CPlusPlus) {
Douglas Gregor93dda722010-01-11 21:54:40 +0000804 // C++ [dcl.typedef]p2:
805 // In a given non-class scope, a typedef specifier can be used to
806 // redefine the name of any type declared in that scope to refer
807 // to the type to which it already refers.
Chris Lattner32b06752009-04-17 22:04:20 +0000808 if (!isa<CXXRecordDecl>(CurContext))
Chris Lattnereaaebc72009-04-25 08:06:05 +0000809 return;
Douglas Gregor93dda722010-01-11 21:54:40 +0000810
811 // C++0x [dcl.typedef]p4:
812 // In a given class scope, a typedef specifier can be used to redefine
813 // any class-name declared in that scope that is not also a typedef-name
814 // to refer to the type to which it already refers.
815 //
816 // This wording came in via DR424, which was a correction to the
817 // wording in DR56, which accidentally banned code like:
818 //
819 // struct S {
820 // typedef struct A { } A;
821 // };
822 //
823 // in the C++03 standard. We implement the C++0x semantics, which
824 // allow the above but disallow
825 //
826 // struct S {
827 // typedef int I;
828 // typedef int I;
829 // };
830 //
831 // since that was the intent of DR56.
Douglas Gregor05f65002010-01-11 22:30:10 +0000832 if (!isa<TypedefDecl >(Old))
Douglas Gregor93dda722010-01-11 21:54:40 +0000833 return;
834
Chris Lattner32b06752009-04-17 22:04:20 +0000835 Diag(New->getLocation(), diag::err_redefinition)
836 << New->getDeclName();
837 Diag(Old->getLocation(), diag::note_previous_definition);
Chris Lattnereaaebc72009-04-25 08:06:05 +0000838 return New->setInvalidDecl();
Daniel Dunbar2fe09972008-09-12 18:10:20 +0000839 }
Eli Friedman54ecfce2008-06-11 06:20:39 +0000840
Chris Lattner32b06752009-04-17 22:04:20 +0000841 // If we have a redefinition of a typedef in C, emit a warning. This warning
842 // is normally mapped to an error, but can be controlled with
Eli Friedman340a4e52009-06-04 23:03:07 +0000843 // -Wtypedef-redefinition. If either the original or the redefinition is
844 // in a system header, don't emit this for compatibility with GCC.
Chris Lattnerd0359af2009-04-27 01:46:12 +0000845 if (PP.getDiagnostics().getSuppressSystemWarnings() &&
Eli Friedman340a4e52009-06-04 23:03:07 +0000846 (Context.getSourceManager().isInSystemHeader(Old->getLocation()) ||
847 Context.getSourceManager().isInSystemHeader(New->getLocation())))
Chris Lattnerd0359af2009-04-27 01:46:12 +0000848 return;
Mike Stump1eb44332009-09-09 15:08:12 +0000849
Chris Lattner32b06752009-04-17 22:04:20 +0000850 Diag(New->getLocation(), diag::warn_redefinition_of_typedef)
851 << New->getDeclName();
Chris Lattner5f4a6822008-11-23 23:12:31 +0000852 Diag(Old->getLocation(), diag::note_previous_definition);
Chris Lattnereaaebc72009-04-25 08:06:05 +0000853 return;
Reid Spencer5f016e22007-07-11 17:01:13 +0000854}
855
Chris Lattner6b6b5372008-06-26 18:38:35 +0000856/// DeclhasAttr - returns true if decl Declaration already has the target
857/// attribute.
Mike Stump1eb44332009-09-09 15:08:12 +0000858static bool
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +0000859DeclHasAttr(const Decl *decl, const Attr *target) {
860 for (const Attr *attr = decl->getAttrs(); attr; attr = attr->getNext())
Chris Lattnerddee4232008-03-03 03:28:21 +0000861 if (attr->getKind() == target->getKind())
862 return true;
863
864 return false;
865}
866
867/// MergeAttributes - append attributes from the Old decl to the New one.
Chris Lattnercc581472009-03-04 06:05:19 +0000868static void MergeAttributes(Decl *New, Decl *Old, ASTContext &C) {
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +0000869 for (const Attr *attr = Old->getAttrs(); attr; attr = attr->getNext()) {
870 if (!DeclHasAttr(New, attr) && attr->isMerged()) {
Douglas Gregor9f9bf252009-04-28 06:37:30 +0000871 Attr *NewAttr = attr->clone(C);
872 NewAttr->setInherited(true);
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +0000873 New->addAttr(NewAttr);
Chris Lattnerddee4232008-03-03 03:28:21 +0000874 }
875 }
876}
877
Douglas Gregorc8376562009-03-06 22:43:54 +0000878/// Used in MergeFunctionDecl to keep track of function parameters in
879/// C.
880struct GNUCompatibleParamWarning {
881 ParmVarDecl *OldParm;
882 ParmVarDecl *NewParm;
883 QualType PromotedType;
884};
885
Anders Carlsson5c478cf2009-12-04 22:33:25 +0000886
887/// getSpecialMember - get the special member enum for a method.
888static Sema::CXXSpecialMember getSpecialMember(ASTContext &Ctx,
889 const CXXMethodDecl *MD) {
890 if (const CXXConstructorDecl *Ctor = dyn_cast<CXXConstructorDecl>(MD)) {
891 if (Ctor->isDefaultConstructor())
892 return Sema::CXXDefaultConstructor;
Douglas Gregor9e9199d2009-12-22 00:34:07 +0000893 if (Ctor->isCopyConstructor())
Anders Carlsson5c478cf2009-12-04 22:33:25 +0000894 return Sema::CXXCopyConstructor;
895 }
896
897 if (isa<CXXDestructorDecl>(MD))
898 return Sema::CXXDestructor;
899
900 assert(MD->isCopyAssignment() && "Must have copy assignment operator");
901 return Sema::CXXCopyAssignment;
902}
903
Chris Lattner04421082008-04-08 04:40:51 +0000904/// MergeFunctionDecl - We just parsed a function 'New' from
905/// declarator D which has the same name and scope as a previous
906/// declaration 'Old'. Figure out how to resolve this situation,
907/// merging decls or emitting diagnostics as appropriate.
Douglas Gregor8e9bebd2008-10-21 16:13:35 +0000908///
909/// In C++, New and Old must be declarations that are not
910/// overloaded. Use IsOverload to determine whether New and Old are
911/// overloaded, and to select the Old declaration that New should be
912/// merged with.
Douglas Gregorcda9c672009-02-16 17:45:42 +0000913///
914/// Returns true if there was an error, false otherwise.
915bool Sema::MergeFunctionDecl(FunctionDecl *New, Decl *OldD) {
Reid Spencer5f016e22007-07-11 17:01:13 +0000916 // Verify the old decl was also a function.
Douglas Gregore53060f2009-06-25 22:08:12 +0000917 FunctionDecl *Old = 0;
Mike Stump1eb44332009-09-09 15:08:12 +0000918 if (FunctionTemplateDecl *OldFunctionTemplate
Douglas Gregore53060f2009-06-25 22:08:12 +0000919 = dyn_cast<FunctionTemplateDecl>(OldD))
920 Old = OldFunctionTemplate->getTemplatedDecl();
Mike Stump1eb44332009-09-09 15:08:12 +0000921 else
Douglas Gregore53060f2009-06-25 22:08:12 +0000922 Old = dyn_cast<FunctionDecl>(OldD);
Reid Spencer5f016e22007-07-11 17:01:13 +0000923 if (!Old) {
John McCall41ce66f2009-12-10 19:51:03 +0000924 if (UsingShadowDecl *Shadow = dyn_cast<UsingShadowDecl>(OldD)) {
925 Diag(New->getLocation(), diag::err_using_decl_conflict_reverse);
926 Diag(Shadow->getTargetDecl()->getLocation(),
927 diag::note_using_decl_target);
928 Diag(Shadow->getUsingDecl()->getLocation(),
929 diag::note_using_decl) << 0;
930 return true;
931 }
932
Chris Lattner5dc266a2008-11-20 06:13:02 +0000933 Diag(New->getLocation(), diag::err_redefinition_different_kind)
Chris Lattner08631c52008-11-23 21:45:46 +0000934 << New->getDeclName();
Chris Lattner5f4a6822008-11-23 23:12:31 +0000935 Diag(OldD->getLocation(), diag::note_previous_definition);
Douglas Gregorcda9c672009-02-16 17:45:42 +0000936 return true;
Reid Spencer5f016e22007-07-11 17:01:13 +0000937 }
Douglas Gregor8e9bebd2008-10-21 16:13:35 +0000938
939 // Determine whether the previous declaration was a definition,
940 // implicit declaration, or a declaration.
941 diag::kind PrevDiag;
942 if (Old->isThisDeclarationADefinition())
Chris Lattner5f4a6822008-11-23 23:12:31 +0000943 PrevDiag = diag::note_previous_definition;
Douglas Gregorcda9c672009-02-16 17:45:42 +0000944 else if (Old->isImplicit())
945 PrevDiag = diag::note_previous_implicit_declaration;
Mike Stump1eb44332009-09-09 15:08:12 +0000946 else
Chris Lattner5f4a6822008-11-23 23:12:31 +0000947 PrevDiag = diag::note_previous_declaration;
Mike Stump1eb44332009-09-09 15:08:12 +0000948
Chris Lattner8bcfc5b2008-04-06 23:10:54 +0000949 QualType OldQType = Context.getCanonicalType(Old->getType());
950 QualType NewQType = Context.getCanonicalType(New->getType());
Mike Stump1eb44332009-09-09 15:08:12 +0000951
Douglas Gregor04495c82009-02-24 01:23:02 +0000952 if (!isa<CXXMethodDecl>(New) && !isa<CXXMethodDecl>(Old) &&
953 New->getStorageClass() == FunctionDecl::Static &&
954 Old->getStorageClass() != FunctionDecl::Static) {
955 Diag(New->getLocation(), diag::err_static_non_static)
956 << New;
957 Diag(Old->getLocation(), PrevDiag);
958 return true;
959 }
960
Douglas Gregor8e9bebd2008-10-21 16:13:35 +0000961 if (getLangOptions().CPlusPlus) {
962 // (C++98 13.1p2):
963 // Certain function declarations cannot be overloaded:
Mike Stump1eb44332009-09-09 15:08:12 +0000964 // -- Function declarations that differ only in the return type
Douglas Gregor8e9bebd2008-10-21 16:13:35 +0000965 // cannot be overloaded.
Mike Stump1eb44332009-09-09 15:08:12 +0000966 QualType OldReturnType
Douglas Gregor8e9bebd2008-10-21 16:13:35 +0000967 = cast<FunctionType>(OldQType.getTypePtr())->getResultType();
Mike Stump1eb44332009-09-09 15:08:12 +0000968 QualType NewReturnType
Douglas Gregor8e9bebd2008-10-21 16:13:35 +0000969 = cast<FunctionType>(NewQType.getTypePtr())->getResultType();
970 if (OldReturnType != NewReturnType) {
971 Diag(New->getLocation(), diag::err_ovl_diff_return_type);
Douglas Gregor3e41d602009-02-13 23:20:09 +0000972 Diag(Old->getLocation(), PrevDiag) << Old << Old->getType();
Douglas Gregorcda9c672009-02-16 17:45:42 +0000973 return true;
Douglas Gregor8e9bebd2008-10-21 16:13:35 +0000974 }
975
976 const CXXMethodDecl* OldMethod = dyn_cast<CXXMethodDecl>(Old);
977 const CXXMethodDecl* NewMethod = dyn_cast<CXXMethodDecl>(New);
Anders Carlsson5c478cf2009-12-04 22:33:25 +0000978 if (OldMethod && NewMethod) {
979 if (!NewMethod->getFriendObjectKind() &&
980 NewMethod->getLexicalDeclContext()->isRecord()) {
981 // -- Member function declarations with the same name and the
982 // same parameter types cannot be overloaded if any of them
983 // is a static member function declaration.
984 if (OldMethod->isStatic() || NewMethod->isStatic()) {
985 Diag(New->getLocation(), diag::err_ovl_static_nonstatic_member);
986 Diag(Old->getLocation(), PrevDiag) << Old << Old->getType();
987 return true;
988 }
989
990 // C++ [class.mem]p1:
991 // [...] A member shall not be declared twice in the
992 // member-specification, except that a nested class or member
993 // class template can be declared and then later defined.
994 unsigned NewDiag;
995 if (isa<CXXConstructorDecl>(OldMethod))
996 NewDiag = diag::err_constructor_redeclared;
997 else if (isa<CXXDestructorDecl>(NewMethod))
998 NewDiag = diag::err_destructor_redeclared;
999 else if (isa<CXXConversionDecl>(NewMethod))
1000 NewDiag = diag::err_conv_function_redeclared;
1001 else
1002 NewDiag = diag::err_member_redeclared;
1003
1004 Diag(New->getLocation(), NewDiag);
Douglas Gregor3e41d602009-02-13 23:20:09 +00001005 Diag(Old->getLocation(), PrevDiag) << Old << Old->getType();
Anders Carlsson5c478cf2009-12-04 22:33:25 +00001006 } else {
1007 if (OldMethod->isImplicit()) {
1008 Diag(NewMethod->getLocation(),
1009 diag::err_definition_of_implicitly_declared_member)
1010 << New << getSpecialMember(Context, OldMethod);
1011
1012 Diag(OldMethod->getLocation(),
1013 diag::note_previous_implicit_declaration);
1014 return true;
1015 }
Douglas Gregor8e9bebd2008-10-21 16:13:35 +00001016 }
1017 }
1018
1019 // (C++98 8.3.5p3):
1020 // All declarations for a function shall agree exactly in both the
1021 // return type and the parameter-type-list.
Nuno Lopesf75b8302009-12-23 23:40:33 +00001022 // attributes should be ignored when comparing.
1023 if (Context.getNoReturnType(OldQType, false) ==
1024 Context.getNoReturnType(NewQType, false))
Douglas Gregor04495c82009-02-24 01:23:02 +00001025 return MergeCompatibleFunctionDecls(New, Old);
Douglas Gregor8e9bebd2008-10-21 16:13:35 +00001026
1027 // Fall through for conflicting redeclarations and redefinitions.
Douglas Gregorf0097952008-04-21 02:02:58 +00001028 }
Chris Lattner04421082008-04-08 04:40:51 +00001029
1030 // C: Function types need to be compatible, not identical. This handles
Steve Naroffadbbd0c2008-01-14 20:51:29 +00001031 // duplicate function decls like "void f(int); void f(enum X);" properly.
Chris Lattner04421082008-04-08 04:40:51 +00001032 if (!getLangOptions().CPlusPlus &&
Eli Friedman3d815e72008-08-22 00:56:42 +00001033 Context.typesAreCompatible(OldQType, NewQType)) {
John McCall183700f2009-09-21 23:43:11 +00001034 const FunctionType *OldFuncType = OldQType->getAs<FunctionType>();
1035 const FunctionType *NewFuncType = NewQType->getAs<FunctionType>();
Douglas Gregor72564e72009-02-26 23:50:07 +00001036 const FunctionProtoType *OldProto = 0;
1037 if (isa<FunctionNoProtoType>(NewFuncType) &&
Douglas Gregorc8376562009-03-06 22:43:54 +00001038 (OldProto = dyn_cast<FunctionProtoType>(OldFuncType))) {
Douglas Gregor68719812009-02-16 18:20:44 +00001039 // The old declaration provided a function prototype, but the
1040 // new declaration does not. Merge in the prototype.
Sebastian Redl465226e2009-05-27 22:11:52 +00001041 assert(!OldProto->hasExceptionSpec() && "Exception spec in C");
Douglas Gregor68719812009-02-16 18:20:44 +00001042 llvm::SmallVector<QualType, 16> ParamTypes(OldProto->arg_type_begin(),
1043 OldProto->arg_type_end());
1044 NewQType = Context.getFunctionType(NewFuncType->getResultType(),
Jay Foadbeaaccd2009-05-21 09:52:38 +00001045 ParamTypes.data(), ParamTypes.size(),
Douglas Gregor68719812009-02-16 18:20:44 +00001046 OldProto->isVariadic(),
1047 OldProto->getTypeQuals());
1048 New->setType(NewQType);
Anders Carlssona75e8532009-05-14 21:46:00 +00001049 New->setHasInheritedPrototype();
Douglas Gregor450da982009-02-16 20:58:07 +00001050
1051 // Synthesize a parameter for each argument type.
1052 llvm::SmallVector<ParmVarDecl*, 16> Params;
Mike Stump1eb44332009-09-09 15:08:12 +00001053 for (FunctionProtoType::arg_type_iterator
1054 ParamType = OldProto->arg_type_begin(),
Douglas Gregor450da982009-02-16 20:58:07 +00001055 ParamEnd = OldProto->arg_type_end();
1056 ParamType != ParamEnd; ++ParamType) {
1057 ParmVarDecl *Param = ParmVarDecl::Create(Context, New,
1058 SourceLocation(), 0,
John McCalla93c9342009-12-07 02:54:59 +00001059 *ParamType, /*TInfo=*/0,
Argyrios Kyrtzidisa1d56622009-08-19 01:27:57 +00001060 VarDecl::None, 0);
Douglas Gregor450da982009-02-16 20:58:07 +00001061 Param->setImplicit();
1062 Params.push_back(Param);
1063 }
1064
Jay Foadbeaaccd2009-05-21 09:52:38 +00001065 New->setParams(Context, Params.data(), Params.size());
Mike Stump1eb44332009-09-09 15:08:12 +00001066 }
Douglas Gregor68719812009-02-16 18:20:44 +00001067
Douglas Gregor04495c82009-02-24 01:23:02 +00001068 return MergeCompatibleFunctionDecls(New, Old);
Chris Lattner04421082008-04-08 04:40:51 +00001069 }
Chris Lattnere3995fe2007-11-06 06:07:26 +00001070
Douglas Gregorc8376562009-03-06 22:43:54 +00001071 // GNU C permits a K&R definition to follow a prototype declaration
1072 // if the declared types of the parameters in the K&R definition
1073 // match the types in the prototype declaration, even when the
1074 // promoted types of the parameters from the K&R definition differ
1075 // from the types in the prototype. GCC then keeps the types from
1076 // the prototype.
Eli Friedmanbc4e29f2009-06-01 09:24:59 +00001077 //
1078 // If a variadic prototype is followed by a non-variadic K&R definition,
1079 // the K&R definition becomes variadic. This is sort of an edge case, but
1080 // it's legal per the standard depending on how you read C99 6.7.5.3p15 and
1081 // C99 6.9.1p8.
Douglas Gregorc8376562009-03-06 22:43:54 +00001082 if (!getLangOptions().CPlusPlus &&
Douglas Gregorc8376562009-03-06 22:43:54 +00001083 Old->hasPrototype() && !New->hasPrototype() &&
John McCall183700f2009-09-21 23:43:11 +00001084 New->getType()->getAs<FunctionProtoType>() &&
Douglas Gregorc8376562009-03-06 22:43:54 +00001085 Old->getNumParams() == New->getNumParams()) {
1086 llvm::SmallVector<QualType, 16> ArgTypes;
1087 llvm::SmallVector<GNUCompatibleParamWarning, 16> Warnings;
Mike Stump1eb44332009-09-09 15:08:12 +00001088 const FunctionProtoType *OldProto
John McCall183700f2009-09-21 23:43:11 +00001089 = Old->getType()->getAs<FunctionProtoType>();
Mike Stump1eb44332009-09-09 15:08:12 +00001090 const FunctionProtoType *NewProto
John McCall183700f2009-09-21 23:43:11 +00001091 = New->getType()->getAs<FunctionProtoType>();
Mike Stump1eb44332009-09-09 15:08:12 +00001092
Douglas Gregorc8376562009-03-06 22:43:54 +00001093 // Determine whether this is the GNU C extension.
Eli Friedmanbc4e29f2009-06-01 09:24:59 +00001094 QualType MergedReturn = Context.mergeTypes(OldProto->getResultType(),
1095 NewProto->getResultType());
1096 bool LooseCompatible = !MergedReturn.isNull();
Mike Stump1eb44332009-09-09 15:08:12 +00001097 for (unsigned Idx = 0, End = Old->getNumParams();
Eli Friedmanbc4e29f2009-06-01 09:24:59 +00001098 LooseCompatible && Idx != End; ++Idx) {
Douglas Gregorc8376562009-03-06 22:43:54 +00001099 ParmVarDecl *OldParm = Old->getParamDecl(Idx);
1100 ParmVarDecl *NewParm = New->getParamDecl(Idx);
Mike Stump1eb44332009-09-09 15:08:12 +00001101 if (Context.typesAreCompatible(OldParm->getType(),
Douglas Gregorc8376562009-03-06 22:43:54 +00001102 NewProto->getArgType(Idx))) {
1103 ArgTypes.push_back(NewParm->getType());
1104 } else if (Context.typesAreCompatible(OldParm->getType(),
1105 NewParm->getType())) {
Mike Stump1eb44332009-09-09 15:08:12 +00001106 GNUCompatibleParamWarning Warn
Douglas Gregorc8376562009-03-06 22:43:54 +00001107 = { OldParm, NewParm, NewProto->getArgType(Idx) };
1108 Warnings.push_back(Warn);
1109 ArgTypes.push_back(NewParm->getType());
1110 } else
Eli Friedmanbc4e29f2009-06-01 09:24:59 +00001111 LooseCompatible = false;
Douglas Gregorc8376562009-03-06 22:43:54 +00001112 }
1113
Eli Friedmanbc4e29f2009-06-01 09:24:59 +00001114 if (LooseCompatible) {
Douglas Gregorc8376562009-03-06 22:43:54 +00001115 for (unsigned Warn = 0; Warn < Warnings.size(); ++Warn) {
1116 Diag(Warnings[Warn].NewParm->getLocation(),
1117 diag::ext_param_promoted_not_compatible_with_prototype)
1118 << Warnings[Warn].PromotedType
1119 << Warnings[Warn].OldParm->getType();
Mike Stump1eb44332009-09-09 15:08:12 +00001120 Diag(Warnings[Warn].OldParm->getLocation(),
Douglas Gregorc8376562009-03-06 22:43:54 +00001121 diag::note_previous_declaration);
1122 }
1123
Eli Friedmanbc4e29f2009-06-01 09:24:59 +00001124 New->setType(Context.getFunctionType(MergedReturn, &ArgTypes[0],
1125 ArgTypes.size(),
1126 OldProto->isVariadic(), 0));
Douglas Gregorc8376562009-03-06 22:43:54 +00001127 return MergeCompatibleFunctionDecls(New, Old);
1128 }
1129
1130 // Fall through to diagnose conflicting types.
1131 }
1132
Steve Naroff837618c2008-01-16 15:01:34 +00001133 // A function that has already been declared has been redeclared or defined
1134 // with a different type- show appropriate diagnostic
Douglas Gregor7814e6d2009-09-12 00:22:50 +00001135 if (unsigned BuiltinID = Old->getBuiltinID()) {
Douglas Gregorcda9c672009-02-16 17:45:42 +00001136 // The user has declared a builtin function with an incompatible
1137 // signature.
1138 if (Context.BuiltinInfo.isPredefinedLibFunction(BuiltinID)) {
1139 // The function the user is redeclaring is a library-defined
1140 // function like 'malloc' or 'printf'. Warn about the
Douglas Gregor374e1562009-03-23 17:47:24 +00001141 // redeclaration, then pretend that we don't know about this
1142 // library built-in.
Douglas Gregorcda9c672009-02-16 17:45:42 +00001143 Diag(New->getLocation(), diag::warn_redecl_library_builtin) << New;
1144 Diag(Old->getLocation(), diag::note_previous_builtin_declaration)
1145 << Old << Old->getType();
Douglas Gregor374e1562009-03-23 17:47:24 +00001146 New->getIdentifier()->setBuiltinID(Builtin::NotBuiltin);
1147 Old->setInvalidDecl();
1148 return false;
Douglas Gregorcda9c672009-02-16 17:45:42 +00001149 }
Steve Naroff837618c2008-01-16 15:01:34 +00001150
Douglas Gregorcda9c672009-02-16 17:45:42 +00001151 PrevDiag = diag::note_previous_builtin_declaration;
1152 }
1153
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00001154 Diag(New->getLocation(), diag::err_conflicting_types) << New->getDeclName();
Douglas Gregor3e41d602009-02-13 23:20:09 +00001155 Diag(Old->getLocation(), PrevDiag) << Old << Old->getType();
Douglas Gregorcda9c672009-02-16 17:45:42 +00001156 return true;
Reid Spencer5f016e22007-07-11 17:01:13 +00001157}
1158
Douglas Gregor04495c82009-02-24 01:23:02 +00001159/// \brief Completes the merge of two function declarations that are
Mike Stump1eb44332009-09-09 15:08:12 +00001160/// known to be compatible.
Douglas Gregor04495c82009-02-24 01:23:02 +00001161///
1162/// This routine handles the merging of attributes and other
1163/// properties of function declarations form the old declaration to
1164/// the new declaration, once we know that New is in fact a
1165/// redeclaration of Old.
1166///
1167/// \returns false
1168bool Sema::MergeCompatibleFunctionDecls(FunctionDecl *New, FunctionDecl *Old) {
1169 // Merge the attributes
Chris Lattnercc581472009-03-04 06:05:19 +00001170 MergeAttributes(New, Old, Context);
Douglas Gregor04495c82009-02-24 01:23:02 +00001171
1172 // Merge the storage class.
Douglas Gregor1fc09a92009-09-13 07:46:26 +00001173 if (Old->getStorageClass() != FunctionDecl::Extern &&
1174 Old->getStorageClass() != FunctionDecl::None)
Douglas Gregor9f9bf252009-04-28 06:37:30 +00001175 New->setStorageClass(Old->getStorageClass());
Douglas Gregor04495c82009-02-24 01:23:02 +00001176
Douglas Gregor04495c82009-02-24 01:23:02 +00001177 // Merge "pure" flag.
1178 if (Old->isPure())
1179 New->setPure();
1180
1181 // Merge the "deleted" flag.
1182 if (Old->isDeleted())
1183 New->setDeleted();
Mike Stump1eb44332009-09-09 15:08:12 +00001184
Douglas Gregor04495c82009-02-24 01:23:02 +00001185 if (getLangOptions().CPlusPlus)
1186 return MergeCXXFunctionDecl(New, Old);
1187
1188 return false;
1189}
1190
Reid Spencer5f016e22007-07-11 17:01:13 +00001191/// MergeVarDecl - We just parsed a variable 'New' which has the same name
1192/// and scope as a previous declaration 'Old'. Figure out how to resolve this
1193/// situation, merging decls or emitting diagnostics as appropriate.
1194///
Mike Stump1eb44332009-09-09 15:08:12 +00001195/// Tentative definition rules (C99 6.9.2p2) are checked by
1196/// FinalizeDeclaratorGroup. Unfortunately, we can't analyze tentative
Steve Naroffff9eb1f2008-08-08 17:50:35 +00001197/// definitions here, since the initializer hasn't been attached.
Mike Stump1eb44332009-09-09 15:08:12 +00001198///
John McCall68263142009-11-18 22:49:29 +00001199void Sema::MergeVarDecl(VarDecl *New, LookupResult &Previous) {
1200 // If the new decl is already invalid, don't do any other checking.
1201 if (New->isInvalidDecl())
1202 return;
Mike Stump1eb44332009-09-09 15:08:12 +00001203
Reid Spencer5f016e22007-07-11 17:01:13 +00001204 // Verify the old decl was also a variable.
John McCall68263142009-11-18 22:49:29 +00001205 VarDecl *Old = 0;
1206 if (!Previous.isSingleResult() ||
1207 !(Old = dyn_cast<VarDecl>(Previous.getFoundDecl()))) {
Chris Lattnerf3a41af2008-11-20 06:38:18 +00001208 Diag(New->getLocation(), diag::err_redefinition_different_kind)
Chris Lattner08631c52008-11-23 21:45:46 +00001209 << New->getDeclName();
John McCall68263142009-11-18 22:49:29 +00001210 Diag(Previous.getRepresentativeDecl()->getLocation(),
1211 diag::note_previous_definition);
Chris Lattnereaaebc72009-04-25 08:06:05 +00001212 return New->setInvalidDecl();
Reid Spencer5f016e22007-07-11 17:01:13 +00001213 }
Chris Lattnerddee4232008-03-03 03:28:21 +00001214
Chris Lattnercc581472009-03-04 06:05:19 +00001215 MergeAttributes(New, Old, Context);
Chris Lattnerddee4232008-03-03 03:28:21 +00001216
Eli Friedman13ca96a2009-01-24 23:49:55 +00001217 // Merge the types
Eli Friedman88d936b2009-05-16 13:54:38 +00001218 QualType MergedT;
1219 if (getLangOptions().CPlusPlus) {
1220 if (Context.hasSameType(New->getType(), Old->getType()))
1221 MergedT = New->getType();
Eli Friedman153c33e2009-12-10 08:54:47 +00001222 // C++ [basic.link]p10:
1223 // [...] the types specified by all declarations referring to a given
1224 // object or function shall be identical, except that declarations for an
1225 // array object can specify array types that differ by the presence or
1226 // absence of a major array bound (8.3.4).
Mike Stump1eb44332009-09-09 15:08:12 +00001227 else if (Old->getType()->isIncompleteArrayType() &&
Douglas Gregor8dfb7ec2009-09-09 06:04:29 +00001228 New->getType()->isArrayType()) {
Mike Stump1eb44332009-09-09 15:08:12 +00001229 CanQual<ArrayType> OldArray
Douglas Gregor8dfb7ec2009-09-09 06:04:29 +00001230 = Context.getCanonicalType(Old->getType())->getAs<ArrayType>();
Mike Stump1eb44332009-09-09 15:08:12 +00001231 CanQual<ArrayType> NewArray
Douglas Gregor8dfb7ec2009-09-09 06:04:29 +00001232 = Context.getCanonicalType(New->getType())->getAs<ArrayType>();
1233 if (OldArray->getElementType() == NewArray->getElementType())
1234 MergedT = New->getType();
Eli Friedman153c33e2009-12-10 08:54:47 +00001235 } else if (Old->getType()->isArrayType() &&
1236 New->getType()->isIncompleteArrayType()) {
1237 CanQual<ArrayType> OldArray
1238 = Context.getCanonicalType(Old->getType())->getAs<ArrayType>();
1239 CanQual<ArrayType> NewArray
1240 = Context.getCanonicalType(New->getType())->getAs<ArrayType>();
1241 if (OldArray->getElementType() == NewArray->getElementType())
1242 MergedT = Old->getType();
Douglas Gregor8dfb7ec2009-09-09 06:04:29 +00001243 }
Eli Friedman88d936b2009-05-16 13:54:38 +00001244 } else {
1245 MergedT = Context.mergeTypes(New->getType(), Old->getType());
1246 }
Eli Friedman13ca96a2009-01-24 23:49:55 +00001247 if (MergedT.isNull()) {
Mike Stump1eb44332009-09-09 15:08:12 +00001248 Diag(New->getLocation(), diag::err_redefinition_different_type)
Douglas Gregor6037fcb2009-01-09 19:42:16 +00001249 << New->getDeclName();
Chris Lattner5f4a6822008-11-23 23:12:31 +00001250 Diag(Old->getLocation(), diag::note_previous_definition);
Chris Lattnereaaebc72009-04-25 08:06:05 +00001251 return New->setInvalidDecl();
Reid Spencer5f016e22007-07-11 17:01:13 +00001252 }
Eli Friedman13ca96a2009-01-24 23:49:55 +00001253 New->setType(MergedT);
Douglas Gregor656de632009-03-11 23:52:16 +00001254
Steve Naroffb7b032e2008-01-30 00:44:01 +00001255 // C99 6.2.2p4: Check if we have a static decl followed by a non-static.
1256 if (New->getStorageClass() == VarDecl::Static &&
Daniel Dunbar5466c7b2009-04-14 02:25:56 +00001257 (Old->getStorageClass() == VarDecl::None || Old->hasExternalStorage())) {
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00001258 Diag(New->getLocation(), diag::err_static_non_static) << New->getDeclName();
Chris Lattner5f4a6822008-11-23 23:12:31 +00001259 Diag(Old->getLocation(), diag::note_previous_definition);
Chris Lattnereaaebc72009-04-25 08:06:05 +00001260 return New->setInvalidDecl();
Steve Naroffb7b032e2008-01-30 00:44:01 +00001261 }
Mike Stump1eb44332009-09-09 15:08:12 +00001262 // C99 6.2.2p4:
Douglas Gregor5ef122e2009-03-19 22:01:50 +00001263 // For an identifier declared with the storage-class specifier
1264 // extern in a scope in which a prior declaration of that
1265 // identifier is visible,23) if the prior declaration specifies
1266 // internal or external linkage, the linkage of the identifier at
1267 // the later declaration is the same as the linkage specified at
1268 // the prior declaration. If no prior declaration is visible, or
1269 // if the prior declaration specifies no linkage, then the
1270 // identifier has external linkage.
Douglas Gregor38179b22009-03-23 16:17:01 +00001271 if (New->hasExternalStorage() && Old->hasLinkage())
Douglas Gregor5ef122e2009-03-19 22:01:50 +00001272 /* Okay */;
1273 else if (New->getStorageClass() != VarDecl::Static &&
1274 Old->getStorageClass() == VarDecl::Static) {
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00001275 Diag(New->getLocation(), diag::err_non_static_static) << New->getDeclName();
Chris Lattner5f4a6822008-11-23 23:12:31 +00001276 Diag(Old->getLocation(), diag::note_previous_definition);
Chris Lattnereaaebc72009-04-25 08:06:05 +00001277 return New->setInvalidDecl();
Steve Naroffb7b032e2008-01-30 00:44:01 +00001278 }
Daniel Dunbar5466c7b2009-04-14 02:25:56 +00001279
Steve Naroff094cefb2008-09-17 14:05:40 +00001280 // Variables with external linkage are analyzed in FinalizeDeclaratorGroup.
Mike Stump1eb44332009-09-09 15:08:12 +00001281
Daniel Dunbar5466c7b2009-04-14 02:25:56 +00001282 // FIXME: The test for external storage here seems wrong? We still
1283 // need to check for mismatches.
1284 if (!New->hasExternalStorage() && !New->isFileVarDecl() &&
Douglas Gregor656de632009-03-11 23:52:16 +00001285 // Don't complain about out-of-line definitions of static members.
1286 !(Old->getLexicalDeclContext()->isRecord() &&
1287 !New->getLexicalDeclContext()->isRecord())) {
Chris Lattner08631c52008-11-23 21:45:46 +00001288 Diag(New->getLocation(), diag::err_redefinition) << New->getDeclName();
Chris Lattner5f4a6822008-11-23 23:12:31 +00001289 Diag(Old->getLocation(), diag::note_previous_definition);
Chris Lattnereaaebc72009-04-25 08:06:05 +00001290 return New->setInvalidDecl();
Reid Spencer5f016e22007-07-11 17:01:13 +00001291 }
Douglas Gregor275a3692009-03-10 23:43:53 +00001292
Eli Friedman63054b32009-04-19 20:27:55 +00001293 if (New->isThreadSpecified() && !Old->isThreadSpecified()) {
1294 Diag(New->getLocation(), diag::err_thread_non_thread) << New->getDeclName();
1295 Diag(Old->getLocation(), diag::note_previous_definition);
1296 } else if (!New->isThreadSpecified() && Old->isThreadSpecified()) {
1297 Diag(New->getLocation(), diag::err_non_thread_thread) << New->getDeclName();
1298 Diag(Old->getLocation(), diag::note_previous_definition);
1299 }
1300
Douglas Gregor275a3692009-03-10 23:43:53 +00001301 // Keep a chain of previous declarations.
1302 New->setPreviousDeclaration(Old);
John McCall46460a62010-01-20 21:53:11 +00001303
1304 // Inherit access appropriately.
1305 New->setAccess(Old->getAccess());
Reid Spencer5f016e22007-07-11 17:01:13 +00001306}
1307
1308/// ParsedFreeStandingDeclSpec - This method is invoked when a declspec with
1309/// no declarator (e.g. "struct foo;") is parsed.
Chris Lattnerb28317a2009-03-28 19:18:32 +00001310Sema::DeclPtrTy Sema::ParsedFreeStandingDeclSpec(Scope *S, DeclSpec &DS) {
Eli Friedmand2968362009-04-09 21:26:42 +00001311 // FIXME: Error on auto/register at file scope
1312 // FIXME: Error on inline/virtual/explicit
Eli Friedman63054b32009-04-19 20:27:55 +00001313 // FIXME: Warn on useless __thread
Eli Friedmand2968362009-04-09 21:26:42 +00001314 // FIXME: Warn on useless const/volatile
1315 // FIXME: Warn on useless static/extern/typedef/private_extern/mutable
1316 // FIXME: Warn on useless attributes
John McCalle3af0232009-10-07 23:34:25 +00001317 Decl *TagD = 0;
Douglas Gregor1a51b4a2009-02-09 15:09:02 +00001318 TagDecl *Tag = 0;
1319 if (DS.getTypeSpecType() == DeclSpec::TST_class ||
1320 DS.getTypeSpecType() == DeclSpec::TST_struct ||
1321 DS.getTypeSpecType() == DeclSpec::TST_union ||
Douglas Gregor4d9a16f2009-05-12 23:25:50 +00001322 DS.getTypeSpecType() == DeclSpec::TST_enum) {
John McCalle3af0232009-10-07 23:34:25 +00001323 TagD = static_cast<Decl *>(DS.getTypeRep());
1324
1325 if (!TagD) // We probably had an error
Douglas Gregor4d9a16f2009-05-12 23:25:50 +00001326 return DeclPtrTy();
1327
John McCall67d1a672009-08-06 02:15:43 +00001328 // Note that the above type specs guarantee that the
1329 // type rep is a Decl, whereas in many of the others
1330 // it's a Type.
John McCalle3af0232009-10-07 23:34:25 +00001331 Tag = dyn_cast<TagDecl>(TagD);
Douglas Gregor4d9a16f2009-05-12 23:25:50 +00001332 }
Douglas Gregor1a51b4a2009-02-09 15:09:02 +00001333
Nuno Lopes0a8bab02009-12-17 11:35:26 +00001334 if (unsigned TypeQuals = DS.getTypeQualifiers()) {
1335 // Enforce C99 6.7.3p2: "Types other than pointer types derived from object
1336 // or incomplete types shall not be restrict-qualified."
1337 if (TypeQuals & DeclSpec::TQ_restrict)
1338 Diag(DS.getRestrictSpecLoc(),
1339 diag::err_typecheck_invalid_restrict_not_pointer_noarg)
1340 << DS.getSourceRange();
1341 }
1342
Douglas Gregord85bea22009-09-26 06:47:28 +00001343 if (DS.isFriendSpecified()) {
John McCalle3af0232009-10-07 23:34:25 +00001344 // If we're dealing with a class template decl, assume that the
1345 // template routines are handling it.
1346 if (TagD && isa<ClassTemplateDecl>(TagD))
Douglas Gregord85bea22009-09-26 06:47:28 +00001347 return DeclPtrTy();
John McCalle3af0232009-10-07 23:34:25 +00001348 return ActOnFriendTypeDecl(S, DS, MultiTemplateParamsArg(*this, 0, 0));
Douglas Gregord85bea22009-09-26 06:47:28 +00001349 }
1350
Douglas Gregor4920f1f2009-01-12 22:49:06 +00001351 if (RecordDecl *Record = dyn_cast_or_null<RecordDecl>(Tag)) {
Chris Lattnerd451f832009-10-25 22:21:57 +00001352 // If there are attributes in the DeclSpec, apply them to the record.
1353 if (const AttributeList *AL = DS.getAttributes())
1354 ProcessDeclAttributeList(S, Record, AL);
1355
Douglas Gregor4920f1f2009-01-12 22:49:06 +00001356 if (!Record->getDeclName() && Record->isDefinition() &&
Douglas Gregora71c1292009-03-06 23:06:59 +00001357 DS.getStorageClassSpec() != DeclSpec::SCS_typedef) {
1358 if (getLangOptions().CPlusPlus ||
1359 Record->getDeclContext()->isRecord())
1360 return BuildAnonymousStructOrUnion(S, DS, Record);
1361
1362 Diag(DS.getSourceRange().getBegin(), diag::err_no_declarators)
1363 << DS.getSourceRange();
1364 }
Douglas Gregor4920f1f2009-01-12 22:49:06 +00001365
1366 // Microsoft allows unnamed struct/union fields. Don't complain
1367 // about them.
1368 // FIXME: Should we support Microsoft's extensions in this area?
1369 if (Record->getDeclName() && getLangOptions().Microsoft)
Chris Lattnerb28317a2009-03-28 19:18:32 +00001370 return DeclPtrTy::make(Tag);
Douglas Gregor4920f1f2009-01-12 22:49:06 +00001371 }
Douglas Gregord85bea22009-09-26 06:47:28 +00001372
Mike Stump1eb44332009-09-09 15:08:12 +00001373 if (!DS.isMissingDeclaratorOk() &&
Douglas Gregorddc29e12009-02-06 22:42:48 +00001374 DS.getTypeSpecType() != DeclSpec::TST_error) {
Douglas Gregor21282df2009-01-22 16:23:54 +00001375 // Warn about typedefs of enums without names, since this is an
1376 // extension in both Microsoft an GNU.
Douglas Gregor8158f692009-01-17 02:55:50 +00001377 if (DS.getStorageClassSpec() == DeclSpec::SCS_typedef &&
1378 Tag && isa<EnumDecl>(Tag)) {
Douglas Gregor21282df2009-01-22 16:23:54 +00001379 Diag(DS.getSourceRange().getBegin(), diag::ext_typedef_without_a_name)
Douglas Gregoree159c12009-01-13 23:10:51 +00001380 << DS.getSourceRange();
Chris Lattnerb28317a2009-03-28 19:18:32 +00001381 return DeclPtrTy::make(Tag);
Douglas Gregoree159c12009-01-13 23:10:51 +00001382 }
1383
Sebastian Redla4ed0d82008-12-28 15:28:59 +00001384 Diag(DS.getSourceRange().getBegin(), diag::err_no_declarators)
1385 << DS.getSourceRange();
Chris Lattnerb28317a2009-03-28 19:18:32 +00001386 return DeclPtrTy();
Sebastian Redla4ed0d82008-12-28 15:28:59 +00001387 }
Mike Stump1eb44332009-09-09 15:08:12 +00001388
Chris Lattnerb28317a2009-03-28 19:18:32 +00001389 return DeclPtrTy::make(Tag);
Douglas Gregorbcbffc42009-01-07 00:43:41 +00001390}
1391
John McCall1d7c5282009-12-18 10:40:03 +00001392/// We are trying to inject an anonymous member into the given scope;
John McCall68263142009-11-18 22:49:29 +00001393/// check if there's an existing declaration that can't be overloaded.
1394///
1395/// \return true if this is a forbidden redeclaration
John McCall1d7c5282009-12-18 10:40:03 +00001396static bool CheckAnonMemberRedeclaration(Sema &SemaRef,
1397 Scope *S,
Fariborz Jahanian588a4ad2010-01-22 18:30:17 +00001398 DeclContext *Owner,
John McCall1d7c5282009-12-18 10:40:03 +00001399 DeclarationName Name,
1400 SourceLocation NameLoc,
1401 unsigned diagnostic) {
1402 LookupResult R(SemaRef, Name, NameLoc, Sema::LookupMemberName,
1403 Sema::ForRedeclaration);
1404 if (!SemaRef.LookupName(R, S)) return false;
John McCall68263142009-11-18 22:49:29 +00001405
John McCall1d7c5282009-12-18 10:40:03 +00001406 if (R.getAsSingle<TagDecl>())
John McCall68263142009-11-18 22:49:29 +00001407 return false;
1408
1409 // Pick a representative declaration.
John McCall1d7c5282009-12-18 10:40:03 +00001410 NamedDecl *PrevDecl = R.getRepresentativeDecl()->getUnderlyingDecl();
Fariborz Jahanian588a4ad2010-01-22 18:30:17 +00001411 if (PrevDecl && Owner->isRecord()) {
1412 RecordDecl *Record = cast<RecordDecl>(Owner);
1413 if (!SemaRef.isDeclInScope(PrevDecl, Record, S))
1414 return false;
1415 }
John McCall68263142009-11-18 22:49:29 +00001416
John McCall1d7c5282009-12-18 10:40:03 +00001417 SemaRef.Diag(NameLoc, diagnostic) << Name;
1418 SemaRef.Diag(PrevDecl->getLocation(), diag::note_previous_declaration);
John McCall68263142009-11-18 22:49:29 +00001419
1420 return true;
1421}
1422
Douglas Gregorbcbffc42009-01-07 00:43:41 +00001423/// InjectAnonymousStructOrUnionMembers - Inject the members of the
1424/// anonymous struct or union AnonRecord into the owning context Owner
1425/// and scope S. This routine will be invoked just after we realize
1426/// that an unnamed union or struct is actually an anonymous union or
1427/// struct, e.g.,
1428///
1429/// @code
1430/// union {
1431/// int i;
1432/// float f;
1433/// }; // InjectAnonymousStructOrUnionMembers called here to inject i and
1434/// // f into the surrounding scope.x
1435/// @endcode
1436///
1437/// This routine is recursive, injecting the names of nested anonymous
1438/// structs/unions into the owning context and scope as well.
1439bool Sema::InjectAnonymousStructOrUnionMembers(Scope *S, DeclContext *Owner,
1440 RecordDecl *AnonRecord) {
John McCall68263142009-11-18 22:49:29 +00001441 unsigned diagKind
1442 = AnonRecord->isUnion() ? diag::err_anonymous_union_member_redecl
1443 : diag::err_anonymous_struct_member_redecl;
1444
Douglas Gregorbcbffc42009-01-07 00:43:41 +00001445 bool Invalid = false;
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00001446 for (RecordDecl::field_iterator F = AnonRecord->field_begin(),
1447 FEnd = AnonRecord->field_end();
Douglas Gregorbcbffc42009-01-07 00:43:41 +00001448 F != FEnd; ++F) {
1449 if ((*F)->getDeclName()) {
Fariborz Jahanian588a4ad2010-01-22 18:30:17 +00001450 if (CheckAnonMemberRedeclaration(*this, S, Owner, (*F)->getDeclName(),
John McCall1d7c5282009-12-18 10:40:03 +00001451 (*F)->getLocation(), diagKind)) {
Douglas Gregorbcbffc42009-01-07 00:43:41 +00001452 // C++ [class.union]p2:
1453 // The names of the members of an anonymous union shall be
1454 // distinct from the names of any other entity in the
1455 // scope in which the anonymous union is declared.
Douglas Gregorbcbffc42009-01-07 00:43:41 +00001456 Invalid = true;
1457 } else {
1458 // C++ [class.union]p2:
1459 // For the purpose of name lookup, after the anonymous union
1460 // definition, the members of the anonymous union are
1461 // considered to have been defined in the scope in which the
1462 // anonymous union is declared.
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00001463 Owner->makeDeclVisibleInContext(*F);
Chris Lattnerb28317a2009-03-28 19:18:32 +00001464 S->AddDecl(DeclPtrTy::make(*F));
Douglas Gregorbcbffc42009-01-07 00:43:41 +00001465 IdResolver.AddDecl(*F);
1466 }
1467 } else if (const RecordType *InnerRecordType
Ted Kremenek6217b802009-07-29 21:53:49 +00001468 = (*F)->getType()->getAs<RecordType>()) {
Douglas Gregorbcbffc42009-01-07 00:43:41 +00001469 RecordDecl *InnerRecord = InnerRecordType->getDecl();
1470 if (InnerRecord->isAnonymousStructOrUnion())
Mike Stump1eb44332009-09-09 15:08:12 +00001471 Invalid = Invalid ||
Douglas Gregorbcbffc42009-01-07 00:43:41 +00001472 InjectAnonymousStructOrUnionMembers(S, Owner, InnerRecord);
1473 }
1474 }
1475
1476 return Invalid;
1477}
1478
1479/// ActOnAnonymousStructOrUnion - Handle the declaration of an
1480/// anonymous structure or union. Anonymous unions are a C++ feature
1481/// (C++ [class.union]) and a GNU C extension; anonymous structures
Mike Stump1eb44332009-09-09 15:08:12 +00001482/// are a GNU C and GNU C++ extension.
Chris Lattnerb28317a2009-03-28 19:18:32 +00001483Sema::DeclPtrTy Sema::BuildAnonymousStructOrUnion(Scope *S, DeclSpec &DS,
1484 RecordDecl *Record) {
Douglas Gregorbcbffc42009-01-07 00:43:41 +00001485 DeclContext *Owner = Record->getDeclContext();
1486
1487 // Diagnose whether this anonymous struct/union is an extension.
1488 if (Record->isUnion() && !getLangOptions().CPlusPlus)
1489 Diag(Record->getLocation(), diag::ext_anonymous_union);
1490 else if (!Record->isUnion())
1491 Diag(Record->getLocation(), diag::ext_anonymous_struct);
Mike Stump1eb44332009-09-09 15:08:12 +00001492
Douglas Gregorbcbffc42009-01-07 00:43:41 +00001493 // C and C++ require different kinds of checks for anonymous
1494 // structs/unions.
1495 bool Invalid = false;
1496 if (getLangOptions().CPlusPlus) {
1497 const char* PrevSpec = 0;
John McCallfec54012009-08-03 20:12:06 +00001498 unsigned DiagID;
Douglas Gregorbcbffc42009-01-07 00:43:41 +00001499 // C++ [class.union]p3:
1500 // Anonymous unions declared in a named namespace or in the
1501 // global namespace shall be declared static.
1502 if (DS.getStorageClassSpec() != DeclSpec::SCS_static &&
1503 (isa<TranslationUnitDecl>(Owner) ||
Mike Stump1eb44332009-09-09 15:08:12 +00001504 (isa<NamespaceDecl>(Owner) &&
Douglas Gregorbcbffc42009-01-07 00:43:41 +00001505 cast<NamespaceDecl>(Owner)->getDeclName()))) {
1506 Diag(Record->getLocation(), diag::err_anonymous_union_not_static);
1507 Invalid = true;
1508
1509 // Recover by adding 'static'.
John McCallfec54012009-08-03 20:12:06 +00001510 DS.SetStorageClassSpec(DeclSpec::SCS_static, SourceLocation(),
1511 PrevSpec, DiagID);
Mike Stump1eb44332009-09-09 15:08:12 +00001512 }
Douglas Gregorbcbffc42009-01-07 00:43:41 +00001513 // C++ [class.union]p3:
1514 // A storage class is not allowed in a declaration of an
1515 // anonymous union in a class scope.
1516 else if (DS.getStorageClassSpec() != DeclSpec::SCS_unspecified &&
1517 isa<RecordDecl>(Owner)) {
Mike Stump1eb44332009-09-09 15:08:12 +00001518 Diag(DS.getStorageClassSpecLoc(),
Douglas Gregorbcbffc42009-01-07 00:43:41 +00001519 diag::err_anonymous_union_with_storage_spec);
1520 Invalid = true;
1521
1522 // Recover by removing the storage specifier.
1523 DS.SetStorageClassSpec(DeclSpec::SCS_unspecified, SourceLocation(),
John McCallfec54012009-08-03 20:12:06 +00001524 PrevSpec, DiagID);
Douglas Gregorbcbffc42009-01-07 00:43:41 +00001525 }
Douglas Gregor6b3945f2009-01-07 19:46:03 +00001526
Mike Stump1eb44332009-09-09 15:08:12 +00001527 // C++ [class.union]p2:
Douglas Gregor6b3945f2009-01-07 19:46:03 +00001528 // The member-specification of an anonymous union shall only
1529 // define non-static data members. [Note: nested types and
1530 // functions cannot be declared within an anonymous union. ]
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00001531 for (DeclContext::decl_iterator Mem = Record->decls_begin(),
1532 MemEnd = Record->decls_end();
Douglas Gregor6b3945f2009-01-07 19:46:03 +00001533 Mem != MemEnd; ++Mem) {
1534 if (FieldDecl *FD = dyn_cast<FieldDecl>(*Mem)) {
1535 // C++ [class.union]p3:
1536 // An anonymous union shall not have private or protected
1537 // members (clause 11).
1538 if (FD->getAccess() == AS_protected || FD->getAccess() == AS_private) {
1539 Diag(FD->getLocation(), diag::err_anonymous_record_nonpublic_member)
1540 << (int)Record->isUnion() << (int)(FD->getAccess() == AS_protected);
1541 Invalid = true;
1542 }
1543 } else if ((*Mem)->isImplicit()) {
1544 // Any implicit members are fine.
Douglas Gregor1931b442009-02-03 00:34:39 +00001545 } else if (isa<TagDecl>(*Mem) && (*Mem)->getDeclContext() != Record) {
1546 // This is a type that showed up in an
1547 // elaborated-type-specifier inside the anonymous struct or
1548 // union, but which actually declares a type outside of the
1549 // anonymous struct or union. It's okay.
Douglas Gregor6b3945f2009-01-07 19:46:03 +00001550 } else if (RecordDecl *MemRecord = dyn_cast<RecordDecl>(*Mem)) {
1551 if (!MemRecord->isAnonymousStructOrUnion() &&
1552 MemRecord->getDeclName()) {
1553 // This is a nested type declaration.
1554 Diag(MemRecord->getLocation(), diag::err_anonymous_record_with_type)
1555 << (int)Record->isUnion();
1556 Invalid = true;
1557 }
1558 } else {
1559 // We have something that isn't a non-static data
1560 // member. Complain about it.
1561 unsigned DK = diag::err_anonymous_record_bad_member;
1562 if (isa<TypeDecl>(*Mem))
1563 DK = diag::err_anonymous_record_with_type;
1564 else if (isa<FunctionDecl>(*Mem))
1565 DK = diag::err_anonymous_record_with_function;
1566 else if (isa<VarDecl>(*Mem))
1567 DK = diag::err_anonymous_record_with_static;
1568 Diag((*Mem)->getLocation(), DK)
1569 << (int)Record->isUnion();
1570 Invalid = true;
1571 }
1572 }
Mike Stump1eb44332009-09-09 15:08:12 +00001573 }
Douglas Gregorbcbffc42009-01-07 00:43:41 +00001574
1575 if (!Record->isUnion() && !Owner->isRecord()) {
Douglas Gregor4920f1f2009-01-12 22:49:06 +00001576 Diag(Record->getLocation(), diag::err_anonymous_struct_not_member)
1577 << (int)getLangOptions().CPlusPlus;
Douglas Gregorbcbffc42009-01-07 00:43:41 +00001578 Invalid = true;
1579 }
1580
John McCalleb692e02009-10-22 23:31:08 +00001581 // Mock up a declarator.
1582 Declarator Dc(DS, Declarator::TypeNameContext);
John McCalla93c9342009-12-07 02:54:59 +00001583 TypeSourceInfo *TInfo = 0;
1584 GetTypeForDeclarator(Dc, S, &TInfo);
1585 assert(TInfo && "couldn't build declarator info for anonymous struct/union");
John McCalleb692e02009-10-22 23:31:08 +00001586
Mike Stump1eb44332009-09-09 15:08:12 +00001587 // Create a declaration for this anonymous struct/union.
Douglas Gregor4afa39d2009-01-20 01:17:11 +00001588 NamedDecl *Anon = 0;
Douglas Gregorbcbffc42009-01-07 00:43:41 +00001589 if (RecordDecl *OwningClass = dyn_cast<RecordDecl>(Owner)) {
1590 Anon = FieldDecl::Create(Context, OwningClass, Record->getLocation(),
Mike Stump1eb44332009-09-09 15:08:12 +00001591 /*IdentifierInfo=*/0,
Argyrios Kyrtzidisa5d82002009-08-21 00:31:54 +00001592 Context.getTypeDeclType(Record),
John McCalla93c9342009-12-07 02:54:59 +00001593 TInfo,
Argyrios Kyrtzidisa5d82002009-08-21 00:31:54 +00001594 /*BitWidth=*/0, /*Mutable=*/false);
Douglas Gregor6b3945f2009-01-07 19:46:03 +00001595 Anon->setAccess(AS_public);
1596 if (getLangOptions().CPlusPlus)
1597 FieldCollector->Add(cast<FieldDecl>(Anon));
Douglas Gregorbcbffc42009-01-07 00:43:41 +00001598 } else {
1599 VarDecl::StorageClass SC;
1600 switch (DS.getStorageClassSpec()) {
1601 default: assert(0 && "Unknown storage class!");
1602 case DeclSpec::SCS_unspecified: SC = VarDecl::None; break;
1603 case DeclSpec::SCS_extern: SC = VarDecl::Extern; break;
1604 case DeclSpec::SCS_static: SC = VarDecl::Static; break;
1605 case DeclSpec::SCS_auto: SC = VarDecl::Auto; break;
1606 case DeclSpec::SCS_register: SC = VarDecl::Register; break;
1607 case DeclSpec::SCS_private_extern: SC = VarDecl::PrivateExtern; break;
1608 case DeclSpec::SCS_mutable:
1609 // mutable can only appear on non-static class members, so it's always
1610 // an error here
1611 Diag(Record->getLocation(), diag::err_mutable_nonmember);
1612 Invalid = true;
1613 SC = VarDecl::None;
1614 break;
1615 }
1616
1617 Anon = VarDecl::Create(Context, Owner, Record->getLocation(),
Mike Stump1eb44332009-09-09 15:08:12 +00001618 /*IdentifierInfo=*/0,
Argyrios Kyrtzidisa5d82002009-08-21 00:31:54 +00001619 Context.getTypeDeclType(Record),
John McCalla93c9342009-12-07 02:54:59 +00001620 TInfo,
Argyrios Kyrtzidisa5d82002009-08-21 00:31:54 +00001621 SC);
Douglas Gregorbcbffc42009-01-07 00:43:41 +00001622 }
Douglas Gregor6b3945f2009-01-07 19:46:03 +00001623 Anon->setImplicit();
Douglas Gregorbcbffc42009-01-07 00:43:41 +00001624
1625 // Add the anonymous struct/union object to the current
1626 // context. We'll be referencing this object when we refer to one of
1627 // its members.
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00001628 Owner->addDecl(Anon);
Douglas Gregorbcbffc42009-01-07 00:43:41 +00001629
1630 // Inject the members of the anonymous struct/union into the owning
1631 // context and into the identifier resolver chain for name lookup
1632 // purposes.
Douglas Gregor4920f1f2009-01-12 22:49:06 +00001633 if (InjectAnonymousStructOrUnionMembers(S, Owner, Record))
1634 Invalid = true;
Douglas Gregorbcbffc42009-01-07 00:43:41 +00001635
1636 // Mark this as an anonymous struct/union type. Note that we do not
1637 // do this until after we have already checked and injected the
1638 // members of this anonymous struct/union type, because otherwise
1639 // the members could be injected twice: once by DeclContext when it
1640 // builds its lookup table, and once by
Mike Stump1eb44332009-09-09 15:08:12 +00001641 // InjectAnonymousStructOrUnionMembers.
Douglas Gregorbcbffc42009-01-07 00:43:41 +00001642 Record->setAnonymousStructOrUnion(true);
1643
1644 if (Invalid)
1645 Anon->setInvalidDecl();
1646
Chris Lattnerb28317a2009-03-28 19:18:32 +00001647 return DeclPtrTy::make(Anon);
Reid Spencer5f016e22007-07-11 17:01:13 +00001648}
1649
Steve Narofff0090632007-09-02 02:04:30 +00001650
Douglas Gregor10bd3682008-11-17 22:58:34 +00001651/// GetNameForDeclarator - Determine the full declaration name for the
1652/// given Declarator.
1653DeclarationName Sema::GetNameForDeclarator(Declarator &D) {
Douglas Gregor02a24ee2009-11-03 16:56:39 +00001654 return GetNameFromUnqualifiedId(D.getName());
1655}
1656
1657/// \brief Retrieves the canonicalized name from a parsed unqualified-id.
John McCall129e2df2009-11-30 22:42:35 +00001658DeclarationName Sema::GetNameFromUnqualifiedId(const UnqualifiedId &Name) {
Douglas Gregor3f9a0562009-11-03 01:35:08 +00001659 switch (Name.getKind()) {
Douglas Gregor02a24ee2009-11-03 16:56:39 +00001660 case UnqualifiedId::IK_Identifier:
1661 return DeclarationName(Name.Identifier);
Douglas Gregor3f9a0562009-11-03 01:35:08 +00001662
Douglas Gregor02a24ee2009-11-03 16:56:39 +00001663 case UnqualifiedId::IK_OperatorFunctionId:
1664 return Context.DeclarationNames.getCXXOperatorName(
Sean Huntf4fdd9b2009-11-29 03:04:53 +00001665 Name.OperatorFunctionId.Operator);
Sean Hunt0486d742009-11-28 04:44:28 +00001666
1667 case UnqualifiedId::IK_LiteralOperatorId:
Sean Hunt3e518bd2009-11-29 07:34:05 +00001668 return Context.DeclarationNames.getCXXLiteralOperatorName(
1669 Name.Identifier);
Sean Hunt0486d742009-11-28 04:44:28 +00001670
Douglas Gregor02a24ee2009-11-03 16:56:39 +00001671 case UnqualifiedId::IK_ConversionFunctionId: {
1672 QualType Ty = GetTypeFromParser(Name.ConversionFunctionId);
1673 if (Ty.isNull())
1674 return DeclarationName();
Douglas Gregordb422df2009-09-25 21:45:23 +00001675
Douglas Gregor02a24ee2009-11-03 16:56:39 +00001676 return Context.DeclarationNames.getCXXConversionFunctionName(
Sean Huntf4fdd9b2009-11-29 03:04:53 +00001677 Context.getCanonicalType(Ty));
Douglas Gregor02a24ee2009-11-03 16:56:39 +00001678 }
1679
1680 case UnqualifiedId::IK_ConstructorName: {
1681 QualType Ty = GetTypeFromParser(Name.ConstructorName);
1682 if (Ty.isNull())
1683 return DeclarationName();
1684
1685 return Context.DeclarationNames.getCXXConstructorName(
Sean Huntf4fdd9b2009-11-29 03:04:53 +00001686 Context.getCanonicalType(Ty));
Douglas Gregor02a24ee2009-11-03 16:56:39 +00001687 }
1688
Douglas Gregor0efc2c12010-01-13 17:31:36 +00001689 case UnqualifiedId::IK_ConstructorTemplateId: {
1690 // In well-formed code, we can only have a constructor
1691 // template-id that refers to the current context, so go there
1692 // to find the actual type being constructed.
1693 CXXRecordDecl *CurClass = dyn_cast<CXXRecordDecl>(CurContext);
1694 if (!CurClass || CurClass->getIdentifier() != Name.TemplateId->Name)
1695 return DeclarationName();
1696
1697 // Determine the type of the class being constructed.
1698 QualType CurClassType;
1699 if (ClassTemplateDecl *ClassTemplate
1700 = CurClass->getDescribedClassTemplate())
1701 CurClassType = ClassTemplate->getInjectedClassNameType(Context);
1702 else
1703 CurClassType = Context.getTypeDeclType(CurClass);
1704
1705 // FIXME: Check two things: that the template-id names the same type as
1706 // CurClassType, and that the template-id does not occur when the name
1707 // was qualified.
1708
1709 return Context.DeclarationNames.getCXXConstructorName(
1710 Context.getCanonicalType(CurClassType));
1711 }
1712
Douglas Gregor02a24ee2009-11-03 16:56:39 +00001713 case UnqualifiedId::IK_DestructorName: {
1714 QualType Ty = GetTypeFromParser(Name.DestructorName);
1715 if (Ty.isNull())
1716 return DeclarationName();
1717
1718 return Context.DeclarationNames.getCXXDestructorName(
1719 Context.getCanonicalType(Ty));
1720 }
1721
1722 case UnqualifiedId::IK_TemplateId: {
1723 TemplateName TName
John McCall0bd6feb2009-12-02 08:04:21 +00001724 = TemplateName::getFromVoidPointer(Name.TemplateId->Template);
1725 return Context.getNameForTemplate(TName);
Douglas Gregor02a24ee2009-11-03 16:56:39 +00001726 }
Douglas Gregordb422df2009-09-25 21:45:23 +00001727 }
Douglas Gregor02a24ee2009-11-03 16:56:39 +00001728
Douglas Gregor10bd3682008-11-17 22:58:34 +00001729 assert(false && "Unknown name kind");
Douglas Gregor02a24ee2009-11-03 16:56:39 +00001730 return DeclarationName();
Douglas Gregor10bd3682008-11-17 22:58:34 +00001731}
1732
Douglas Gregor4ce205f2009-02-06 17:46:57 +00001733/// isNearlyMatchingFunction - Determine whether the C++ functions
1734/// Declaration and Definition are "nearly" matching. This heuristic
1735/// is used to improve diagnostics in the case where an out-of-line
1736/// function definition doesn't match any declaration within
1737/// the class or namespace.
1738static bool isNearlyMatchingFunction(ASTContext &Context,
1739 FunctionDecl *Declaration,
1740 FunctionDecl *Definition) {
Douglas Gregor584049d2008-12-15 23:53:10 +00001741 if (Declaration->param_size() != Definition->param_size())
1742 return false;
1743 for (unsigned Idx = 0; Idx < Declaration->param_size(); ++Idx) {
1744 QualType DeclParamTy = Declaration->getParamDecl(Idx)->getType();
1745 QualType DefParamTy = Definition->getParamDecl(Idx)->getType();
1746
Douglas Gregora4923eb2009-11-16 21:35:15 +00001747 if (!Context.hasSameUnqualifiedType(DeclParamTy.getNonReferenceType(),
1748 DefParamTy.getNonReferenceType()))
Douglas Gregor584049d2008-12-15 23:53:10 +00001749 return false;
1750 }
1751
1752 return true;
1753}
1754
Mike Stump1eb44332009-09-09 15:08:12 +00001755Sema::DeclPtrTy
1756Sema::HandleDeclarator(Scope *S, Declarator &D,
Douglas Gregore542c862009-06-23 23:11:28 +00001757 MultiTemplateParamsArg TemplateParamLists,
1758 bool IsFunctionDefinition) {
Douglas Gregor10bd3682008-11-17 22:58:34 +00001759 DeclarationName Name = GetNameForDeclarator(D);
1760
Chris Lattnere80a59c2007-07-25 00:24:17 +00001761 // All of these full declarators require an identifier. If it doesn't have
1762 // one, the ParsedFreeStandingDeclSpec action should be used.
Douglas Gregor10bd3682008-11-17 22:58:34 +00001763 if (!Name) {
Chris Lattnereaaebc72009-04-25 08:06:05 +00001764 if (!D.isInvalidType()) // Reject this if we think it is valid.
Chris Lattner1f6f54b2008-11-11 06:13:16 +00001765 Diag(D.getDeclSpec().getSourceRange().getBegin(),
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00001766 diag::err_declarator_need_ident)
1767 << D.getDeclSpec().getSourceRange() << D.getSourceRange();
Chris Lattnerb28317a2009-03-28 19:18:32 +00001768 return DeclPtrTy();
Chris Lattnere80a59c2007-07-25 00:24:17 +00001769 }
Mike Stump1eb44332009-09-09 15:08:12 +00001770
Chris Lattner31e05722007-08-26 06:24:45 +00001771 // The scope passed in may not be a decl scope. Zip up the scope tree until
1772 // we find one that is.
Douglas Gregor44b43212008-12-11 16:49:14 +00001773 while ((S->getFlags() & Scope::DeclScope) == 0 ||
Douglas Gregoraaba5e32009-02-04 19:02:06 +00001774 (S->getFlags() & Scope::TemplateParamScope) != 0)
Chris Lattner31e05722007-08-26 06:24:45 +00001775 S = S->getParent();
Mike Stump1eb44332009-09-09 15:08:12 +00001776
Douglas Gregor4a959d82009-08-06 16:20:37 +00001777 // If this is an out-of-line definition of a member of a class template
1778 // or class template partial specialization, we may need to rebuild the
1779 // type specifier in the declarator. See RebuildTypeInCurrentInstantiation()
1780 // for more information.
1781 // FIXME: cope with decltype(expr) and typeof(expr) once the rebuilder can
1782 // handle expressions properly.
1783 DeclSpec &DS = const_cast<DeclSpec&>(D.getDeclSpec());
1784 if (D.getCXXScopeSpec().isSet() && !D.getCXXScopeSpec().isInvalid() &&
1785 isDependentScopeSpecifier(D.getCXXScopeSpec()) &&
1786 (DS.getTypeSpecType() == DeclSpec::TST_typename ||
1787 DS.getTypeSpecType() == DeclSpec::TST_typeofType ||
1788 DS.getTypeSpecType() == DeclSpec::TST_typeofExpr ||
1789 DS.getTypeSpecType() == DeclSpec::TST_decltype)) {
1790 if (DeclContext *DC = computeDeclContext(D.getCXXScopeSpec(), true)) {
Argyrios Kyrtzidise8661902009-08-19 01:28:28 +00001791 // FIXME: Preserve type source info.
1792 QualType T = GetTypeFromParser(DS.getTypeRep());
John McCall0dd7ceb2009-12-19 09:35:56 +00001793
1794 DeclContext *SavedContext = CurContext;
1795 CurContext = DC;
Douglas Gregor4a959d82009-08-06 16:20:37 +00001796 T = RebuildTypeInCurrentInstantiation(T, D.getIdentifierLoc(), Name);
John McCall0dd7ceb2009-12-19 09:35:56 +00001797 CurContext = SavedContext;
1798
Douglas Gregor4a959d82009-08-06 16:20:37 +00001799 if (T.isNull())
1800 return DeclPtrTy();
1801 DS.UpdateTypeRep(T.getAsOpaquePtr());
1802 }
1803 }
Mike Stump1eb44332009-09-09 15:08:12 +00001804
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +00001805 DeclContext *DC;
Douglas Gregor4afa39d2009-01-20 01:17:11 +00001806 NamedDecl *New;
Douglas Gregorcda9c672009-02-16 17:45:42 +00001807
John McCalla93c9342009-12-07 02:54:59 +00001808 TypeSourceInfo *TInfo = 0;
1809 QualType R = GetTypeForDeclarator(D, S, &TInfo);
Douglas Gregord6f7e9d2009-02-24 20:03:32 +00001810
John McCall68263142009-11-18 22:49:29 +00001811 LookupResult Previous(*this, Name, D.getIdentifierLoc(), LookupOrdinaryName,
1812 ForRedeclaration);
1813
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +00001814 // See if this is a redefinition of a variable in the same scope.
Douglas Gregor9fa14a52009-03-06 19:06:37 +00001815 if (D.getCXXScopeSpec().isInvalid()) {
1816 DC = CurContext;
Chris Lattnereaaebc72009-04-25 08:06:05 +00001817 D.setInvalidType();
Douglas Gregor9fa14a52009-03-06 19:06:37 +00001818 } else if (!D.getCXXScopeSpec().isSet()) {
John McCall68263142009-11-18 22:49:29 +00001819 bool IsLinkageLookup = false;
Douglas Gregord6f7e9d2009-02-24 20:03:32 +00001820
1821 // If the declaration we're planning to build will be a function
1822 // or object with linkage, then look for another declaration with
1823 // linkage (C99 6.2.2p4-5 and C++ [basic.link]p6).
1824 if (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_typedef)
1825 /* Do nothing*/;
1826 else if (R->isFunctionType()) {
Douglas Gregor6bec78d2009-07-07 17:00:05 +00001827 if (CurContext->isFunctionOrMethod() ||
1828 D.getDeclSpec().getStorageClassSpec() != DeclSpec::SCS_static)
John McCall68263142009-11-18 22:49:29 +00001829 IsLinkageLookup = true;
Douglas Gregord6f7e9d2009-02-24 20:03:32 +00001830 } else if (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_extern)
John McCall68263142009-11-18 22:49:29 +00001831 IsLinkageLookup = true;
Douglas Gregor6bec78d2009-07-07 17:00:05 +00001832 else if (CurContext->getLookupContext()->isTranslationUnit() &&
1833 D.getDeclSpec().getStorageClassSpec() != DeclSpec::SCS_static)
John McCall68263142009-11-18 22:49:29 +00001834 IsLinkageLookup = true;
1835
1836 if (IsLinkageLookup)
1837 Previous.clear(LookupRedeclarationWithLinkage);
Douglas Gregord6f7e9d2009-02-24 20:03:32 +00001838
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +00001839 DC = CurContext;
John McCall68263142009-11-18 22:49:29 +00001840 LookupName(Previous, S, /* CreateBuiltins = */ IsLinkageLookup);
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +00001841 } else { // Something like "int foo::x;"
Douglas Gregorf59a56e2009-07-21 23:53:31 +00001842 DC = computeDeclContext(D.getCXXScopeSpec(), true);
Mike Stump1eb44332009-09-09 15:08:12 +00001843
Douglas Gregordacd4342009-08-26 00:04:55 +00001844 if (!DC) {
1845 // If we could not compute the declaration context, it's because the
1846 // declaration context is dependent but does not refer to a class,
1847 // class template, or class template partial specialization. Complain
1848 // and return early, to avoid the coming semantic disaster.
Mike Stump1eb44332009-09-09 15:08:12 +00001849 Diag(D.getIdentifierLoc(),
Douglas Gregordacd4342009-08-26 00:04:55 +00001850 diag::err_template_qualified_declarator_no_match)
1851 << (NestedNameSpecifier*)D.getCXXScopeSpec().getScopeRep()
1852 << D.getCXXScopeSpec().getRange();
1853 return DeclPtrTy();
1854 }
Mike Stump1eb44332009-09-09 15:08:12 +00001855
Douglas Gregorfd056bc2009-10-13 16:30:37 +00001856 if (!DC->isDependentContext() &&
1857 RequireCompleteDeclContext(D.getCXXScopeSpec()))
1858 return DeclPtrTy();
1859
John McCall68263142009-11-18 22:49:29 +00001860 LookupQualifiedName(Previous, DC);
1861
1862 // Don't consider using declarations as previous declarations for
1863 // out-of-line members.
1864 RemoveUsingDecls(Previous);
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +00001865
1866 // C++ 7.3.1.2p2:
1867 // Members (including explicit specializations of templates) of a named
1868 // namespace can also be defined outside that namespace by explicit
1869 // qualification of the name being defined, provided that the entity being
1870 // defined was already declared in the namespace and the definition appears
1871 // after the point of declaration in a namespace that encloses the
1872 // declarations namespace.
1873 //
Douglas Gregor584049d2008-12-15 23:53:10 +00001874 // Note that we only check the context at this point. We don't yet
1875 // have enough information to make sure that PrevDecl is actually
1876 // the declaration we want to match. For example, given:
1877 //
Douglas Gregor9d350972008-12-12 08:25:50 +00001878 // class X {
1879 // void f();
Douglas Gregor584049d2008-12-15 23:53:10 +00001880 // void f(float);
Douglas Gregor9d350972008-12-12 08:25:50 +00001881 // };
1882 //
Douglas Gregor584049d2008-12-15 23:53:10 +00001883 // void X::f(int) { } // ill-formed
1884 //
1885 // In this case, PrevDecl will point to the overload set
1886 // containing the two f's declared in X, but neither of them
Mike Stump1eb44332009-09-09 15:08:12 +00001887 // matches.
Douglas Gregor4ce205f2009-02-06 17:46:57 +00001888
1889 // First check whether we named the global scope.
1890 if (isa<TranslationUnitDecl>(DC)) {
Mike Stump1eb44332009-09-09 15:08:12 +00001891 Diag(D.getIdentifierLoc(), diag::err_invalid_declarator_global_scope)
Douglas Gregor4ce205f2009-02-06 17:46:57 +00001892 << Name << D.getCXXScopeSpec().getRange();
Sebastian Redl9770ef02009-11-08 11:36:54 +00001893 } else {
1894 DeclContext *Cur = CurContext;
1895 while (isa<LinkageSpecDecl>(Cur))
1896 Cur = Cur->getParent();
1897 if (!Cur->Encloses(DC)) {
1898 // The qualifying scope doesn't enclose the original declaration.
1899 // Emit diagnostic based on current scope.
1900 SourceLocation L = D.getIdentifierLoc();
1901 SourceRange R = D.getCXXScopeSpec().getRange();
1902 if (isa<FunctionDecl>(Cur))
1903 Diag(L, diag::err_invalid_declarator_in_function) << Name << R;
1904 else
1905 Diag(L, diag::err_invalid_declarator_scope)
1906 << Name << cast<NamedDecl>(DC) << R;
1907 D.setInvalidType();
1908 }
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +00001909 }
1910 }
1911
John McCall68263142009-11-18 22:49:29 +00001912 if (Previous.isSingleResult() &&
1913 Previous.getFoundDecl()->isTemplateParameter()) {
Douglas Gregor72c3f312008-12-05 18:15:24 +00001914 // Maybe we will complain about the shadowed template parameter.
Mike Stump1eb44332009-09-09 15:08:12 +00001915 if (!D.isInvalidType())
John McCall68263142009-11-18 22:49:29 +00001916 if (DiagnoseTemplateParameterShadow(D.getIdentifierLoc(),
1917 Previous.getFoundDecl()))
Chris Lattnereaaebc72009-04-25 08:06:05 +00001918 D.setInvalidType();
Mike Stump1eb44332009-09-09 15:08:12 +00001919
Douglas Gregor72c3f312008-12-05 18:15:24 +00001920 // Just pretend that we didn't see the previous declaration.
John McCall68263142009-11-18 22:49:29 +00001921 Previous.clear();
Douglas Gregor72c3f312008-12-05 18:15:24 +00001922 }
1923
Douglas Gregor2ce52f32008-04-13 21:07:44 +00001924 // In C++, the previous declaration we find might be a tag type
1925 // (class or enum). In this case, the new declaration will hide the
Douglas Gregor66973122009-01-28 17:15:10 +00001926 // tag type. Note that this does does not apply if we're declaring a
1927 // typedef (C++ [dcl.typedef]p4).
John McCall68263142009-11-18 22:49:29 +00001928 if (Previous.isSingleTagDecl() &&
Douglas Gregor66973122009-01-28 17:15:10 +00001929 D.getDeclSpec().getStorageClassSpec() != DeclSpec::SCS_typedef)
John McCall68263142009-11-18 22:49:29 +00001930 Previous.clear();
Douglas Gregor2ce52f32008-04-13 21:07:44 +00001931
Douglas Gregorcda9c672009-02-16 17:45:42 +00001932 bool Redeclaration = false;
Reid Spencer5f016e22007-07-11 17:01:13 +00001933 if (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_typedef) {
Douglas Gregore542c862009-06-23 23:11:28 +00001934 if (TemplateParamLists.size()) {
1935 Diag(D.getIdentifierLoc(), diag::err_template_typedef);
1936 return DeclPtrTy();
1937 }
Mike Stump1eb44332009-09-09 15:08:12 +00001938
John McCalla93c9342009-12-07 02:54:59 +00001939 New = ActOnTypedefDeclarator(S, D, DC, R, TInfo, Previous, Redeclaration);
Douglas Gregord6f7e9d2009-02-24 20:03:32 +00001940 } else if (R->isFunctionType()) {
John McCalla93c9342009-12-07 02:54:59 +00001941 New = ActOnFunctionDeclarator(S, D, DC, R, TInfo, Previous,
Douglas Gregore542c862009-06-23 23:11:28 +00001942 move(TemplateParamLists),
Chris Lattnereaaebc72009-04-25 08:06:05 +00001943 IsFunctionDefinition, Redeclaration);
Reid Spencer5f016e22007-07-11 17:01:13 +00001944 } else {
John McCalla93c9342009-12-07 02:54:59 +00001945 New = ActOnVariableDeclarator(S, D, DC, R, TInfo, Previous,
Douglas Gregordfe3f2d2009-07-22 17:18:37 +00001946 move(TemplateParamLists),
1947 Redeclaration);
Reid Spencer5f016e22007-07-11 17:01:13 +00001948 }
Zhongxing Xu416fcaf2009-01-16 01:13:29 +00001949
1950 if (New == 0)
Chris Lattnerb28317a2009-03-28 19:18:32 +00001951 return DeclPtrTy();
Mike Stump1eb44332009-09-09 15:08:12 +00001952
Douglas Gregorb9aa6b22009-09-24 23:14:47 +00001953 // If this has an identifier and is not an invalid redeclaration or
1954 // function template specialization, add it to the scope stack.
Eli Friedman6bc20132009-12-08 05:40:03 +00001955 if (Name && !(Redeclaration && New->isInvalidDecl()))
Argyrios Kyrtzidis87f3ff02008-04-12 00:47:19 +00001956 PushOnScopeChains(New, S);
Mike Stump1eb44332009-09-09 15:08:12 +00001957
Chris Lattnerb28317a2009-03-28 19:18:32 +00001958 return DeclPtrTy::make(New);
Reid Spencer5f016e22007-07-11 17:01:13 +00001959}
1960
Eli Friedman1ca48132009-02-21 00:44:51 +00001961/// TryToFixInvalidVariablyModifiedType - Helper method to turn variable array
1962/// types into constant array types in certain situations which would otherwise
1963/// be errors (for GCC compatibility).
1964static QualType TryToFixInvalidVariablyModifiedType(QualType T,
1965 ASTContext &Context,
1966 bool &SizeIsNegative) {
1967 // This method tries to turn a variable array into a constant
1968 // array even when the size isn't an ICE. This is necessary
1969 // for compatibility with code that depends on gcc's buggy
1970 // constant expression folding, like struct {char x[(int)(char*)2];}
1971 SizeIsNegative = false;
1972
John McCall0953e762009-09-24 19:53:00 +00001973 QualifierCollector Qs;
1974 const Type *Ty = Qs.strip(T);
1975
1976 if (const PointerType* PTy = dyn_cast<PointerType>(Ty)) {
Eli Friedman1ca48132009-02-21 00:44:51 +00001977 QualType Pointee = PTy->getPointeeType();
1978 QualType FixedType =
1979 TryToFixInvalidVariablyModifiedType(Pointee, Context, SizeIsNegative);
1980 if (FixedType.isNull()) return FixedType;
Eli Friedman61125c82009-02-21 00:58:02 +00001981 FixedType = Context.getPointerType(FixedType);
John McCall0953e762009-09-24 19:53:00 +00001982 return Qs.apply(FixedType);
Eli Friedman1ca48132009-02-21 00:44:51 +00001983 }
1984
1985 const VariableArrayType* VLATy = dyn_cast<VariableArrayType>(T);
Eli Friedmanbc592e62009-02-26 03:58:54 +00001986 if (!VLATy)
1987 return QualType();
1988 // FIXME: We should probably handle this case
1989 if (VLATy->getElementType()->isVariablyModifiedType())
1990 return QualType();
Mike Stump1eb44332009-09-09 15:08:12 +00001991
Eli Friedman1ca48132009-02-21 00:44:51 +00001992 Expr::EvalResult EvalResult;
1993 if (!VLATy->getSizeExpr() ||
Eli Friedmanbc592e62009-02-26 03:58:54 +00001994 !VLATy->getSizeExpr()->Evaluate(EvalResult, Context) ||
1995 !EvalResult.Val.isInt())
Eli Friedman1ca48132009-02-21 00:44:51 +00001996 return QualType();
Eli Friedmanbc592e62009-02-26 03:58:54 +00001997
Eli Friedman1ca48132009-02-21 00:44:51 +00001998 llvm::APSInt &Res = EvalResult.Val.getInt();
Douglas Gregor7e7eb3d2009-07-06 15:59:29 +00001999 if (Res >= llvm::APSInt(Res.getBitWidth(), Res.isUnsigned())) {
John McCall46a617a2009-10-16 00:14:28 +00002000 // TODO: preserve the size expression in declarator info
2001 return Context.getConstantArrayType(VLATy->getElementType(),
2002 Res, ArrayType::Normal, 0);
Douglas Gregor7e7eb3d2009-07-06 15:59:29 +00002003 }
Eli Friedman1ca48132009-02-21 00:44:51 +00002004
2005 SizeIsNegative = true;
2006 return QualType();
2007}
2008
Douglas Gregor63935192009-03-02 00:19:53 +00002009/// \brief Register the given locally-scoped external C declaration so
2010/// that it can be found later for redeclarations
Mike Stump1eb44332009-09-09 15:08:12 +00002011void
John McCall68263142009-11-18 22:49:29 +00002012Sema::RegisterLocallyScopedExternCDecl(NamedDecl *ND,
2013 const LookupResult &Previous,
Douglas Gregor63935192009-03-02 00:19:53 +00002014 Scope *S) {
2015 assert(ND->getLexicalDeclContext()->isFunctionOrMethod() &&
2016 "Decl is not a locally-scoped decl!");
2017 // Note that we have a locally-scoped external with this name.
2018 LocallyScopedExternalDecls[ND->getDeclName()] = ND;
2019
John McCall68263142009-11-18 22:49:29 +00002020 if (!Previous.isSingleResult())
Douglas Gregor63935192009-03-02 00:19:53 +00002021 return;
2022
John McCall68263142009-11-18 22:49:29 +00002023 NamedDecl *PrevDecl = Previous.getFoundDecl();
2024
Douglas Gregor63935192009-03-02 00:19:53 +00002025 // If there was a previous declaration of this variable, it may be
2026 // in our identifier chain. Update the identifier chain with the new
2027 // declaration.
Douglas Gregor2dc0e642009-03-23 23:06:20 +00002028 if (S && IdResolver.ReplaceDecl(PrevDecl, ND)) {
Douglas Gregor63935192009-03-02 00:19:53 +00002029 // The previous declaration was found on the identifer resolver
2030 // chain, so remove it from its scope.
Chris Lattnerb28317a2009-03-28 19:18:32 +00002031 while (S && !S->isDeclScope(DeclPtrTy::make(PrevDecl)))
Douglas Gregor63935192009-03-02 00:19:53 +00002032 S = S->getParent();
2033
2034 if (S)
Chris Lattnerb28317a2009-03-28 19:18:32 +00002035 S->RemoveDecl(DeclPtrTy::make(PrevDecl));
Douglas Gregor63935192009-03-02 00:19:53 +00002036 }
2037}
2038
Eli Friedman85a53192009-04-07 19:37:57 +00002039/// \brief Diagnose function specifiers on a declaration of an identifier that
2040/// does not identify a function.
2041void Sema::DiagnoseFunctionSpecifiers(Declarator& D) {
2042 // FIXME: We should probably indicate the identifier in question to avoid
2043 // confusion for constructs like "inline int a(), b;"
2044 if (D.getDeclSpec().isInlineSpecified())
Mike Stump1eb44332009-09-09 15:08:12 +00002045 Diag(D.getDeclSpec().getInlineSpecLoc(),
Eli Friedman85a53192009-04-07 19:37:57 +00002046 diag::err_inline_non_function);
2047
2048 if (D.getDeclSpec().isVirtualSpecified())
Mike Stump1eb44332009-09-09 15:08:12 +00002049 Diag(D.getDeclSpec().getVirtualSpecLoc(),
Eli Friedman85a53192009-04-07 19:37:57 +00002050 diag::err_virtual_non_function);
2051
2052 if (D.getDeclSpec().isExplicitSpecified())
Mike Stump1eb44332009-09-09 15:08:12 +00002053 Diag(D.getDeclSpec().getExplicitSpecLoc(),
Eli Friedman85a53192009-04-07 19:37:57 +00002054 diag::err_explicit_non_function);
2055}
2056
Douglas Gregor4afa39d2009-01-20 01:17:11 +00002057NamedDecl*
Zhongxing Xud5ed8c32009-01-16 03:34:13 +00002058Sema::ActOnTypedefDeclarator(Scope* S, Declarator& D, DeclContext* DC,
John McCalla93c9342009-12-07 02:54:59 +00002059 QualType R, TypeSourceInfo *TInfo,
John McCall68263142009-11-18 22:49:29 +00002060 LookupResult &Previous, bool &Redeclaration) {
Zhongxing Xud5ed8c32009-01-16 03:34:13 +00002061 // Typedef declarators cannot be qualified (C++ [dcl.meaning]p1).
2062 if (D.getCXXScopeSpec().isSet()) {
2063 Diag(D.getIdentifierLoc(), diag::err_qualified_typedef_declarator)
2064 << D.getCXXScopeSpec().getRange();
Chris Lattnereaaebc72009-04-25 08:06:05 +00002065 D.setInvalidType();
Zhongxing Xud5ed8c32009-01-16 03:34:13 +00002066 // Pretend we didn't see the scope specifier.
2067 DC = 0;
2068 }
2069
Douglas Gregor021c3b32009-03-11 23:00:04 +00002070 if (getLangOptions().CPlusPlus) {
2071 // Check that there are no default arguments (C++ only).
Zhongxing Xud5ed8c32009-01-16 03:34:13 +00002072 CheckExtraCXXDefaultArguments(D);
Douglas Gregor021c3b32009-03-11 23:00:04 +00002073 }
2074
Eli Friedman85a53192009-04-07 19:37:57 +00002075 DiagnoseFunctionSpecifiers(D);
2076
Eli Friedman63054b32009-04-19 20:27:55 +00002077 if (D.getDeclSpec().isThreadSpecified())
2078 Diag(D.getDeclSpec().getThreadSpecLoc(), diag::err_invalid_thread);
2079
John McCalla93c9342009-12-07 02:54:59 +00002080 TypedefDecl *NewTD = ParseTypedefDecl(S, D, R, TInfo);
Zhongxing Xud5ed8c32009-01-16 03:34:13 +00002081 if (!NewTD) return 0;
Mike Stump1eb44332009-09-09 15:08:12 +00002082
Zhongxing Xud5ed8c32009-01-16 03:34:13 +00002083 // Handle attributes prior to checking for duplicates in MergeVarDecl
Douglas Gregor9cdda0c2009-06-17 21:51:59 +00002084 ProcessDeclAttributes(S, NewTD, D);
John McCall68263142009-11-18 22:49:29 +00002085
Zhongxing Xud5ed8c32009-01-16 03:34:13 +00002086 // Merge the decl with the existing one if appropriate. If the decl is
2087 // in an outer scope, it isn't the same thing.
John McCall68263142009-11-18 22:49:29 +00002088 FilterLookupForScope(*this, Previous, DC, S, /*ConsiderLinkage*/ false);
2089 if (!Previous.empty()) {
Douglas Gregorcda9c672009-02-16 17:45:42 +00002090 Redeclaration = true;
John McCall68263142009-11-18 22:49:29 +00002091 MergeTypeDefDecl(NewTD, Previous);
Zhongxing Xud5ed8c32009-01-16 03:34:13 +00002092 }
2093
Chris Lattner38c5ebd2009-04-19 05:21:20 +00002094 // C99 6.7.7p2: If a typedef name specifies a variably modified type
2095 // then it shall have block scope.
2096 QualType T = NewTD->getUnderlyingType();
2097 if (T->isVariablyModifiedType()) {
2098 CurFunctionNeedsScopeChecking = true;
Mike Stump1eb44332009-09-09 15:08:12 +00002099
Chris Lattner38c5ebd2009-04-19 05:21:20 +00002100 if (S->getFnParent() == 0) {
Eli Friedman1ca48132009-02-21 00:44:51 +00002101 bool SizeIsNegative;
2102 QualType FixedTy =
2103 TryToFixInvalidVariablyModifiedType(T, Context, SizeIsNegative);
2104 if (!FixedTy.isNull()) {
2105 Diag(D.getIdentifierLoc(), diag::warn_illegal_constant_array_size);
John McCalla93c9342009-12-07 02:54:59 +00002106 NewTD->setTypeSourceInfo(Context.getTrivialTypeSourceInfo(FixedTy));
Eli Friedman1ca48132009-02-21 00:44:51 +00002107 } else {
2108 if (SizeIsNegative)
2109 Diag(D.getIdentifierLoc(), diag::err_typecheck_negative_array_size);
2110 else if (T->isVariableArrayType())
2111 Diag(D.getIdentifierLoc(), diag::err_vla_decl_in_file_scope);
2112 else
2113 Diag(D.getIdentifierLoc(), diag::err_vm_decl_in_file_scope);
Chris Lattnereaaebc72009-04-25 08:06:05 +00002114 NewTD->setInvalidDecl();
Eli Friedman1ca48132009-02-21 00:44:51 +00002115 }
Zhongxing Xud5ed8c32009-01-16 03:34:13 +00002116 }
2117 }
Douglas Gregorc29f77b2009-07-07 16:35:42 +00002118
2119 // If this is the C FILE type, notify the AST context.
2120 if (IdentifierInfo *II = NewTD->getIdentifier())
2121 if (!NewTD->isInvalidDecl() &&
Mike Stump782fa302009-07-28 02:25:19 +00002122 NewTD->getDeclContext()->getLookupContext()->isTranslationUnit()) {
2123 if (II->isStr("FILE"))
2124 Context.setFILEDecl(NewTD);
2125 else if (II->isStr("jmp_buf"))
2126 Context.setjmp_bufDecl(NewTD);
2127 else if (II->isStr("sigjmp_buf"))
2128 Context.setsigjmp_bufDecl(NewTD);
2129 }
2130
Zhongxing Xud5ed8c32009-01-16 03:34:13 +00002131 return NewTD;
2132}
2133
Douglas Gregor8f301052009-02-24 19:23:27 +00002134/// \brief Determines whether the given declaration is an out-of-scope
2135/// previous declaration.
2136///
2137/// This routine should be invoked when name lookup has found a
2138/// previous declaration (PrevDecl) that is not in the scope where a
2139/// new declaration by the same name is being introduced. If the new
2140/// declaration occurs in a local scope, previous declarations with
2141/// linkage may still be considered previous declarations (C99
2142/// 6.2.2p4-5, C++ [basic.link]p6).
2143///
2144/// \param PrevDecl the previous declaration found by name
2145/// lookup
Mike Stump1eb44332009-09-09 15:08:12 +00002146///
Douglas Gregor8f301052009-02-24 19:23:27 +00002147/// \param DC the context in which the new declaration is being
2148/// declared.
2149///
2150/// \returns true if PrevDecl is an out-of-scope previous declaration
2151/// for a new delcaration with the same name.
Mike Stump1eb44332009-09-09 15:08:12 +00002152static bool
Douglas Gregor8f301052009-02-24 19:23:27 +00002153isOutOfScopePreviousDeclaration(NamedDecl *PrevDecl, DeclContext *DC,
2154 ASTContext &Context) {
2155 if (!PrevDecl)
2156 return 0;
2157
Douglas Gregord6f7e9d2009-02-24 20:03:32 +00002158 if (!PrevDecl->hasLinkage())
2159 return false;
Douglas Gregor8f301052009-02-24 19:23:27 +00002160
2161 if (Context.getLangOptions().CPlusPlus) {
2162 // C++ [basic.link]p6:
2163 // If there is a visible declaration of an entity with linkage
2164 // having the same name and type, ignoring entities declared
2165 // outside the innermost enclosing namespace scope, the block
2166 // scope declaration declares that same entity and receives the
2167 // linkage of the previous declaration.
2168 DeclContext *OuterContext = DC->getLookupContext();
2169 if (!OuterContext->isFunctionOrMethod())
2170 // This rule only applies to block-scope declarations.
2171 return false;
2172 else {
2173 DeclContext *PrevOuterContext = PrevDecl->getDeclContext();
2174 if (PrevOuterContext->isRecord())
2175 // We found a member function: ignore it.
2176 return false;
2177 else {
2178 // Find the innermost enclosing namespace for the new and
2179 // previous declarations.
2180 while (!OuterContext->isFileContext())
2181 OuterContext = OuterContext->getParent();
2182 while (!PrevOuterContext->isFileContext())
2183 PrevOuterContext = PrevOuterContext->getParent();
Mike Stump1eb44332009-09-09 15:08:12 +00002184
Douglas Gregor8f301052009-02-24 19:23:27 +00002185 // The previous declaration is in a different namespace, so it
2186 // isn't the same function.
Mike Stump1eb44332009-09-09 15:08:12 +00002187 if (OuterContext->getPrimaryContext() !=
Douglas Gregor8f301052009-02-24 19:23:27 +00002188 PrevOuterContext->getPrimaryContext())
2189 return false;
2190 }
2191 }
2192 }
2193
Douglas Gregor8f301052009-02-24 19:23:27 +00002194 return true;
2195}
2196
Douglas Gregor4afa39d2009-01-20 01:17:11 +00002197NamedDecl*
Zhongxing Xucb8f4f12009-01-16 02:36:34 +00002198Sema::ActOnVariableDeclarator(Scope* S, Declarator& D, DeclContext* DC,
John McCalla93c9342009-12-07 02:54:59 +00002199 QualType R, TypeSourceInfo *TInfo,
John McCall68263142009-11-18 22:49:29 +00002200 LookupResult &Previous,
Douglas Gregordfe3f2d2009-07-22 17:18:37 +00002201 MultiTemplateParamsArg TemplateParamLists,
Douglas Gregorcda9c672009-02-16 17:45:42 +00002202 bool &Redeclaration) {
Zhongxing Xucb8f4f12009-01-16 02:36:34 +00002203 DeclarationName Name = GetNameForDeclarator(D);
2204
2205 // Check that there are no default arguments (C++ only).
2206 if (getLangOptions().CPlusPlus)
2207 CheckExtraCXXDefaultArguments(D);
2208
Zhongxing Xucb8f4f12009-01-16 02:36:34 +00002209 VarDecl *NewVD;
2210 VarDecl::StorageClass SC;
2211 switch (D.getDeclSpec().getStorageClassSpec()) {
2212 default: assert(0 && "Unknown storage class!");
2213 case DeclSpec::SCS_unspecified: SC = VarDecl::None; break;
2214 case DeclSpec::SCS_extern: SC = VarDecl::Extern; break;
2215 case DeclSpec::SCS_static: SC = VarDecl::Static; break;
2216 case DeclSpec::SCS_auto: SC = VarDecl::Auto; break;
2217 case DeclSpec::SCS_register: SC = VarDecl::Register; break;
2218 case DeclSpec::SCS_private_extern: SC = VarDecl::PrivateExtern; break;
2219 case DeclSpec::SCS_mutable:
2220 // mutable can only appear on non-static class members, so it's always
2221 // an error here
2222 Diag(D.getIdentifierLoc(), diag::err_mutable_nonmember);
Chris Lattnereaaebc72009-04-25 08:06:05 +00002223 D.setInvalidType();
Zhongxing Xucb8f4f12009-01-16 02:36:34 +00002224 SC = VarDecl::None;
2225 break;
2226 }
2227
2228 IdentifierInfo *II = Name.getAsIdentifierInfo();
2229 if (!II) {
2230 Diag(D.getIdentifierLoc(), diag::err_bad_variable_name)
2231 << Name.getAsString();
2232 return 0;
2233 }
2234
Eli Friedman85a53192009-04-07 19:37:57 +00002235 DiagnoseFunctionSpecifiers(D);
Douglas Gregor021c3b32009-03-11 23:00:04 +00002236
Douglas Gregor2d2e9cf2009-03-11 20:22:50 +00002237 if (!DC->isRecord() && S->getFnParent() == 0) {
2238 // C99 6.9p2: The storage-class specifiers auto and register shall not
2239 // appear in the declaration specifiers in an external declaration.
2240 if (SC == VarDecl::Auto || SC == VarDecl::Register) {
Mike Stump1eb44332009-09-09 15:08:12 +00002241
Chris Lattnerd4b19d52009-05-12 21:44:00 +00002242 // If this is a register variable with an asm label specified, then this
2243 // is a GNU extension.
2244 if (SC == VarDecl::Register && D.getAsmLabel())
2245 Diag(D.getIdentifierLoc(), diag::err_unsupported_global_register);
2246 else
2247 Diag(D.getIdentifierLoc(), diag::err_typecheck_sclass_fscope);
Chris Lattnereaaebc72009-04-25 08:06:05 +00002248 D.setInvalidType();
Zhongxing Xucb8f4f12009-01-16 02:36:34 +00002249 }
Zhongxing Xucb8f4f12009-01-16 02:36:34 +00002250 }
Douglas Gregor656de632009-03-11 23:52:16 +00002251 if (DC->isRecord() && !CurContext->isRecord()) {
2252 // This is an out-of-line definition of a static data member.
2253 if (SC == VarDecl::Static) {
Mike Stump1eb44332009-09-09 15:08:12 +00002254 Diag(D.getDeclSpec().getStorageClassSpecLoc(),
Douglas Gregor656de632009-03-11 23:52:16 +00002255 diag::err_static_out_of_line)
2256 << CodeModificationHint::CreateRemoval(
Chris Lattner29d9c1a2009-12-06 17:36:05 +00002257 D.getDeclSpec().getStorageClassSpecLoc());
Douglas Gregor656de632009-03-11 23:52:16 +00002258 } else if (SC == VarDecl::None)
2259 SC = VarDecl::Static;
2260 }
Anders Carlssone98da2e2009-06-24 00:28:53 +00002261 if (SC == VarDecl::Static) {
2262 if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(DC)) {
2263 if (RD->isLocalClass())
Mike Stump1eb44332009-09-09 15:08:12 +00002264 Diag(D.getIdentifierLoc(),
Anders Carlssone98da2e2009-06-24 00:28:53 +00002265 diag::err_static_data_member_not_allowed_in_local_class)
2266 << Name << RD->getDeclName();
2267 }
2268 }
Mike Stump1eb44332009-09-09 15:08:12 +00002269
Douglas Gregordfe3f2d2009-07-22 17:18:37 +00002270 // Match up the template parameter lists with the scope specifier, then
2271 // determine whether we have a template or a template specialization.
Douglas Gregor1fef4e62009-10-07 22:35:40 +00002272 bool isExplicitSpecialization = false;
Douglas Gregordfe3f2d2009-07-22 17:18:37 +00002273 if (TemplateParameterList *TemplateParams
Douglas Gregor1fef4e62009-10-07 22:35:40 +00002274 = MatchTemplateParametersToScopeSpecifier(
Douglas Gregordfe3f2d2009-07-22 17:18:37 +00002275 D.getDeclSpec().getSourceRange().getBegin(),
Douglas Gregor1fef4e62009-10-07 22:35:40 +00002276 D.getCXXScopeSpec(),
Douglas Gregor27eeb5e2009-07-22 22:05:02 +00002277 (TemplateParameterList**)TemplateParamLists.get(),
Douglas Gregor1fef4e62009-10-07 22:35:40 +00002278 TemplateParamLists.size(),
2279 isExplicitSpecialization)) {
Douglas Gregordfe3f2d2009-07-22 17:18:37 +00002280 if (TemplateParams->size() > 0) {
2281 // There is no such thing as a variable template.
2282 Diag(D.getIdentifierLoc(), diag::err_template_variable)
2283 << II
2284 << SourceRange(TemplateParams->getTemplateLoc(),
2285 TemplateParams->getRAngleLoc());
2286 return 0;
2287 } else {
2288 // There is an extraneous 'template<>' for this variable. Complain
2289 // about it, but allow the declaration of the variable.
Mike Stump1eb44332009-09-09 15:08:12 +00002290 Diag(TemplateParams->getTemplateLoc(),
Douglas Gregor7cdbc582009-07-22 23:48:44 +00002291 diag::err_template_variable_noparams)
Douglas Gregordfe3f2d2009-07-22 17:18:37 +00002292 << II
2293 << SourceRange(TemplateParams->getTemplateLoc(),
Mike Stump1eb44332009-09-09 15:08:12 +00002294 TemplateParams->getRAngleLoc());
Douglas Gregor1fef4e62009-10-07 22:35:40 +00002295
2296 isExplicitSpecialization = true;
Douglas Gregordfe3f2d2009-07-22 17:18:37 +00002297 }
Mike Stump1eb44332009-09-09 15:08:12 +00002298 }
2299
2300 NewVD = VarDecl::Create(Context, DC, D.getIdentifierLoc(),
John McCalla93c9342009-12-07 02:54:59 +00002301 II, R, TInfo, SC);
Eli Friedman63054b32009-04-19 20:27:55 +00002302
Chris Lattnereaaebc72009-04-25 08:06:05 +00002303 if (D.isInvalidType())
2304 NewVD->setInvalidDecl();
Mike Stump1eb44332009-09-09 15:08:12 +00002305
Eli Friedman63054b32009-04-19 20:27:55 +00002306 if (D.getDeclSpec().isThreadSpecified()) {
2307 if (NewVD->hasLocalStorage())
2308 Diag(D.getDeclSpec().getThreadSpecLoc(), diag::err_thread_non_global);
Eli Friedman4fb71b02009-04-19 21:48:33 +00002309 else if (!Context.Target.isTLSSupported())
2310 Diag(D.getDeclSpec().getThreadSpecLoc(), diag::err_thread_unsupported);
Eli Friedman63054b32009-04-19 20:27:55 +00002311 else
2312 NewVD->setThreadSpecified(true);
2313 }
Douglas Gregor4afa39d2009-01-20 01:17:11 +00002314
Douglas Gregor656de632009-03-11 23:52:16 +00002315 // Set the lexical context. If the declarator has a C++ scope specifier, the
2316 // lexical context will be different from the semantic context.
2317 NewVD->setLexicalDeclContext(CurContext);
2318
Zhongxing Xucb8f4f12009-01-16 02:36:34 +00002319 // Handle attributes prior to checking for duplicates in MergeVarDecl
Douglas Gregor9cdda0c2009-06-17 21:51:59 +00002320 ProcessDeclAttributes(S, NewVD, D);
Zhongxing Xucb8f4f12009-01-16 02:36:34 +00002321
2322 // Handle GNU asm-label extension (encoded as an attribute).
2323 if (Expr *E = (Expr*) D.getAsmLabel()) {
2324 // The parser guarantees this is a string.
Mike Stump1eb44332009-09-09 15:08:12 +00002325 StringLiteral *SE = cast<StringLiteral>(E);
Benjamin Kramerbb377ed2009-11-30 17:08:26 +00002326 NewVD->addAttr(::new (Context) AsmLabelAttr(SE->getString()));
Zhongxing Xucb8f4f12009-01-16 02:36:34 +00002327 }
2328
John McCall68263142009-11-18 22:49:29 +00002329 // Don't consider existing declarations that are in a different
2330 // scope and are out-of-semantic-context declarations (if the new
2331 // declaration has linkage).
2332 FilterLookupForScope(*this, Previous, DC, S, NewVD->hasLinkage());
Douglas Gregor251b4ff2009-10-08 07:24:58 +00002333
Douglas Gregor3d7a12a2009-03-25 23:32:15 +00002334 // Merge the decl with the existing one if appropriate.
John McCall68263142009-11-18 22:49:29 +00002335 if (!Previous.empty()) {
2336 if (Previous.isSingleResult() &&
2337 isa<FieldDecl>(Previous.getFoundDecl()) &&
2338 D.getCXXScopeSpec().isSet()) {
Douglas Gregor3d7a12a2009-03-25 23:32:15 +00002339 // The user tried to define a non-static data member
2340 // out-of-line (C++ [dcl.meaning]p1).
2341 Diag(NewVD->getLocation(), diag::err_nonstatic_member_out_of_line)
2342 << D.getCXXScopeSpec().getRange();
John McCall68263142009-11-18 22:49:29 +00002343 Previous.clear();
Chris Lattnereaaebc72009-04-25 08:06:05 +00002344 NewVD->setInvalidDecl();
Douglas Gregor3d7a12a2009-03-25 23:32:15 +00002345 }
2346 } else if (D.getCXXScopeSpec().isSet()) {
2347 // No previous declaration in the qualifying scope.
Douglas Gregor3f093272009-10-13 21:16:44 +00002348 Diag(D.getIdentifierLoc(), diag::err_no_member)
2349 << Name << computeDeclContext(D.getCXXScopeSpec(), true)
2350 << D.getCXXScopeSpec().getRange();
Chris Lattnereaaebc72009-04-25 08:06:05 +00002351 NewVD->setInvalidDecl();
Douglas Gregor3d7a12a2009-03-25 23:32:15 +00002352 }
2353
John McCall68263142009-11-18 22:49:29 +00002354 CheckVariableDeclaration(NewVD, Previous, Redeclaration);
Douglas Gregor3d7a12a2009-03-25 23:32:15 +00002355
Douglas Gregor251b4ff2009-10-08 07:24:58 +00002356 // This is an explicit specialization of a static data member. Check it.
2357 if (isExplicitSpecialization && !NewVD->isInvalidDecl() &&
John McCall68263142009-11-18 22:49:29 +00002358 CheckMemberSpecialization(NewVD, Previous))
Douglas Gregor251b4ff2009-10-08 07:24:58 +00002359 NewVD->setInvalidDecl();
John McCall68263142009-11-18 22:49:29 +00002360
Ryan Flynn478fbc62009-07-25 22:29:44 +00002361 // attributes declared post-definition are currently ignored
John McCall68263142009-11-18 22:49:29 +00002362 if (Previous.isSingleResult()) {
2363 const VarDecl *Def = 0;
2364 VarDecl *PrevDecl = dyn_cast<VarDecl>(Previous.getFoundDecl());
2365 if (PrevDecl && PrevDecl->getDefinition(Def) && D.hasAttributes()) {
Ryan Flynn478fbc62009-07-25 22:29:44 +00002366 Diag(NewVD->getLocation(), diag::warn_attribute_precede_definition);
2367 Diag(Def->getLocation(), diag::note_previous_definition);
2368 }
2369 }
2370
Douglas Gregor3d7a12a2009-03-25 23:32:15 +00002371 // If this is a locally-scoped extern C variable, update the map of
2372 // such variables.
Douglas Gregor48a83b52009-09-12 00:17:51 +00002373 if (CurContext->isFunctionOrMethod() && NewVD->isExternC() &&
Chris Lattnereaaebc72009-04-25 08:06:05 +00002374 !NewVD->isInvalidDecl())
John McCall68263142009-11-18 22:49:29 +00002375 RegisterLocallyScopedExternCDecl(NewVD, Previous, S);
Douglas Gregor3d7a12a2009-03-25 23:32:15 +00002376
2377 return NewVD;
2378}
2379
2380/// \brief Perform semantic checking on a newly-created variable
2381/// declaration.
2382///
2383/// This routine performs all of the type-checking required for a
Douglas Gregor180bb632009-05-01 15:47:09 +00002384/// variable declaration once it has been built. It is used both to
Douglas Gregor3d7a12a2009-03-25 23:32:15 +00002385/// check variables after they have been parsed and their declarators
Douglas Gregor180bb632009-05-01 15:47:09 +00002386/// have been translated into a declaration, and to check variables
2387/// that have been instantiated from a template.
Douglas Gregor3d7a12a2009-03-25 23:32:15 +00002388///
Chris Lattnereaaebc72009-04-25 08:06:05 +00002389/// Sets NewVD->isInvalidDecl() if an error was encountered.
John McCall68263142009-11-18 22:49:29 +00002390void Sema::CheckVariableDeclaration(VarDecl *NewVD,
2391 LookupResult &Previous,
Douglas Gregor3d7a12a2009-03-25 23:32:15 +00002392 bool &Redeclaration) {
Chris Lattnereaaebc72009-04-25 08:06:05 +00002393 // If the decl is already known invalid, don't check it.
2394 if (NewVD->isInvalidDecl())
2395 return;
Mike Stump1eb44332009-09-09 15:08:12 +00002396
Douglas Gregor3d7a12a2009-03-25 23:32:15 +00002397 QualType T = NewVD->getType();
2398
2399 if (T->isObjCInterfaceType()) {
2400 Diag(NewVD->getLocation(), diag::err_statically_allocated_object);
Chris Lattnereaaebc72009-04-25 08:06:05 +00002401 return NewVD->setInvalidDecl();
Douglas Gregor3d7a12a2009-03-25 23:32:15 +00002402 }
Mike Stump1eb44332009-09-09 15:08:12 +00002403
Zhongxing Xucb8f4f12009-01-16 02:36:34 +00002404 // Emit an error if an address space was applied to decl with local storage.
2405 // This includes arrays of objects with address space qualifiers, but not
2406 // automatic variables that point to other address spaces.
2407 // ISO/IEC TR 18037 S5.1.2
Douglas Gregor3d7a12a2009-03-25 23:32:15 +00002408 if (NewVD->hasLocalStorage() && (T.getAddressSpace() != 0)) {
2409 Diag(NewVD->getLocation(), diag::err_as_qualified_auto_decl);
Chris Lattnereaaebc72009-04-25 08:06:05 +00002410 return NewVD->setInvalidDecl();
Zhongxing Xucb8f4f12009-01-16 02:36:34 +00002411 }
Fariborz Jahanian7b5b3172009-02-21 19:44:02 +00002412
Mike Stumpf33651c2009-04-14 00:57:29 +00002413 if (NewVD->hasLocalStorage() && T.isObjCGCWeak()
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +00002414 && !NewVD->hasAttr<BlocksAttr>())
Douglas Gregor3d7a12a2009-03-25 23:32:15 +00002415 Diag(NewVD->getLocation(), diag::warn_attribute_weak_on_local);
Fariborz Jahanian7b5b3172009-02-21 19:44:02 +00002416
Chris Lattner38c5ebd2009-04-19 05:21:20 +00002417 bool isVM = T->isVariablyModifiedType();
Chris Lattnerbe6d2592009-07-19 20:17:11 +00002418 if (isVM || NewVD->hasAttr<CleanupAttr>() ||
2419 NewVD->hasAttr<BlocksAttr>())
Chris Lattner38c5ebd2009-04-19 05:21:20 +00002420 CurFunctionNeedsScopeChecking = true;
Mike Stump1eb44332009-09-09 15:08:12 +00002421
Chris Lattner38c5ebd2009-04-19 05:21:20 +00002422 if ((isVM && NewVD->hasLinkage()) ||
2423 (T->isVariableArrayType() && NewVD->hasGlobalStorage())) {
Anders Carlsson1a7acfa2009-02-28 21:56:50 +00002424 bool SizeIsNegative;
2425 QualType FixedTy =
Douglas Gregor3d7a12a2009-03-25 23:32:15 +00002426 TryToFixInvalidVariablyModifiedType(T, Context, SizeIsNegative);
Mike Stump1eb44332009-09-09 15:08:12 +00002427
Chris Lattnereaaebc72009-04-25 08:06:05 +00002428 if (FixedTy.isNull() && T->isVariableArrayType()) {
Douglas Gregor3d7a12a2009-03-25 23:32:15 +00002429 const VariableArrayType *VAT = Context.getAsVariableArrayType(T);
Mike Stump1eb44332009-09-09 15:08:12 +00002430 // FIXME: This won't give the correct result for
2431 // int a[10][n];
Anders Carlsson1a7acfa2009-02-28 21:56:50 +00002432 SourceRange SizeRange = VAT->getSizeExpr()->getSourceRange();
Mike Stump1eb44332009-09-09 15:08:12 +00002433
Anders Carlsson1a7acfa2009-02-28 21:56:50 +00002434 if (NewVD->isFileVarDecl())
2435 Diag(NewVD->getLocation(), diag::err_vla_decl_in_file_scope)
Chris Lattnereaaebc72009-04-25 08:06:05 +00002436 << SizeRange;
Anders Carlsson1a7acfa2009-02-28 21:56:50 +00002437 else if (NewVD->getStorageClass() == VarDecl::Static)
2438 Diag(NewVD->getLocation(), diag::err_vla_decl_has_static_storage)
Chris Lattnereaaebc72009-04-25 08:06:05 +00002439 << SizeRange;
Anders Carlsson1a7acfa2009-02-28 21:56:50 +00002440 else
2441 Diag(NewVD->getLocation(), diag::err_vla_decl_has_extern_linkage)
Chris Lattnereaaebc72009-04-25 08:06:05 +00002442 << SizeRange;
2443 return NewVD->setInvalidDecl();
Mike Stump1eb44332009-09-09 15:08:12 +00002444 }
2445
Chris Lattnereaaebc72009-04-25 08:06:05 +00002446 if (FixedTy.isNull()) {
Anders Carlsson1a7acfa2009-02-28 21:56:50 +00002447 if (NewVD->isFileVarDecl())
2448 Diag(NewVD->getLocation(), diag::err_vm_decl_in_file_scope);
2449 else
2450 Diag(NewVD->getLocation(), diag::err_vm_decl_has_extern_linkage);
Chris Lattnereaaebc72009-04-25 08:06:05 +00002451 return NewVD->setInvalidDecl();
Anders Carlsson1a7acfa2009-02-28 21:56:50 +00002452 }
Mike Stump1eb44332009-09-09 15:08:12 +00002453
Chris Lattnereaaebc72009-04-25 08:06:05 +00002454 Diag(NewVD->getLocation(), diag::warn_illegal_constant_array_size);
2455 NewVD->setType(FixedTy);
Anders Carlsson1a7acfa2009-02-28 21:56:50 +00002456 }
2457
John McCall68263142009-11-18 22:49:29 +00002458 if (Previous.empty() && NewVD->isExternC()) {
Douglas Gregor63935192009-03-02 00:19:53 +00002459 // Since we did not find anything by this name and we're declaring
2460 // an extern "C" variable, look for a non-visible extern "C"
2461 // declaration with the same name.
2462 llvm::DenseMap<DeclarationName, NamedDecl *>::iterator Pos
Douglas Gregor3d7a12a2009-03-25 23:32:15 +00002463 = LocallyScopedExternalDecls.find(NewVD->getDeclName());
Douglas Gregor63935192009-03-02 00:19:53 +00002464 if (Pos != LocallyScopedExternalDecls.end())
John McCall68263142009-11-18 22:49:29 +00002465 Previous.addDecl(Pos->second);
Douglas Gregor63935192009-03-02 00:19:53 +00002466 }
2467
Chris Lattnereaaebc72009-04-25 08:06:05 +00002468 if (T->isVoidType() && !NewVD->hasExternalStorage()) {
Douglas Gregor3d7a12a2009-03-25 23:32:15 +00002469 Diag(NewVD->getLocation(), diag::err_typecheck_decl_incomplete_type)
2470 << T;
Chris Lattnereaaebc72009-04-25 08:06:05 +00002471 return NewVD->setInvalidDecl();
Douglas Gregor3d7a12a2009-03-25 23:32:15 +00002472 }
Zhongxing Xucb8f4f12009-01-16 02:36:34 +00002473
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +00002474 if (!NewVD->hasLocalStorage() && NewVD->hasAttr<BlocksAttr>()) {
Mike Stumpea000bf2009-04-30 00:19:40 +00002475 Diag(NewVD->getLocation(), diag::err_block_on_nonlocal);
2476 return NewVD->setInvalidDecl();
2477 }
Mike Stump1eb44332009-09-09 15:08:12 +00002478
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +00002479 if (isVM && NewVD->hasAttr<BlocksAttr>()) {
Mike Stumpc975bb02009-05-01 23:41:47 +00002480 Diag(NewVD->getLocation(), diag::err_block_on_vm);
2481 return NewVD->setInvalidDecl();
2482 }
2483
John McCall68263142009-11-18 22:49:29 +00002484 if (!Previous.empty()) {
Douglas Gregorcda9c672009-02-16 17:45:42 +00002485 Redeclaration = true;
John McCall68263142009-11-18 22:49:29 +00002486 MergeVarDecl(NewVD, Previous);
Zhongxing Xucb8f4f12009-01-16 02:36:34 +00002487 }
Zhongxing Xucb8f4f12009-01-16 02:36:34 +00002488}
2489
Douglas Gregora8f32e02009-10-06 17:59:45 +00002490/// \brief Data used with FindOverriddenMethod
2491struct FindOverriddenMethodData {
2492 Sema *S;
2493 CXXMethodDecl *Method;
2494};
2495
2496/// \brief Member lookup function that determines whether a given C++
2497/// method overrides a method in a base class, to be used with
2498/// CXXRecordDecl::lookupInBases().
John McCallaf8e6ed2009-11-12 03:15:40 +00002499static bool FindOverriddenMethod(const CXXBaseSpecifier *Specifier,
Douglas Gregora8f32e02009-10-06 17:59:45 +00002500 CXXBasePath &Path,
2501 void *UserData) {
2502 RecordDecl *BaseRecord = Specifier->getType()->getAs<RecordType>()->getDecl();
Anders Carlsson95496802009-11-26 20:50:40 +00002503
Douglas Gregora8f32e02009-10-06 17:59:45 +00002504 FindOverriddenMethodData *Data
2505 = reinterpret_cast<FindOverriddenMethodData*>(UserData);
Anders Carlsson95496802009-11-26 20:50:40 +00002506
2507 DeclarationName Name = Data->Method->getDeclName();
2508
2509 // FIXME: Do we care about other names here too?
2510 if (Name.getNameKind() == DeclarationName::CXXDestructorName) {
2511 // We really want to find the base class constructor here.
2512 QualType T = Data->S->Context.getTypeDeclType(BaseRecord);
2513 CanQualType CT = Data->S->Context.getCanonicalType(T);
2514
Anders Carlsson1a689722009-11-27 01:26:58 +00002515 Name = Data->S->Context.DeclarationNames.getCXXDestructorName(CT);
Anders Carlsson95496802009-11-26 20:50:40 +00002516 }
2517
2518 for (Path.Decls = BaseRecord->lookup(Name);
Douglas Gregora8f32e02009-10-06 17:59:45 +00002519 Path.Decls.first != Path.Decls.second;
2520 ++Path.Decls.first) {
2521 if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(*Path.Decls.first)) {
John McCall68263142009-11-18 22:49:29 +00002522 if (MD->isVirtual() && !Data->S->IsOverload(Data->Method, MD))
Douglas Gregora8f32e02009-10-06 17:59:45 +00002523 return true;
2524 }
2525 }
2526
2527 return false;
2528}
2529
Sebastian Redla165da02009-11-18 21:51:29 +00002530/// AddOverriddenMethods - See if a method overrides any in the base classes,
2531/// and if so, check that it's a valid override and remember it.
2532void Sema::AddOverriddenMethods(CXXRecordDecl *DC, CXXMethodDecl *MD) {
2533 // Look for virtual methods in base classes that this method might override.
2534 CXXBasePaths Paths;
2535 FindOverriddenMethodData Data;
2536 Data.Method = MD;
2537 Data.S = this;
2538 if (DC->lookupInBases(&FindOverriddenMethod, &Data, Paths)) {
2539 for (CXXBasePaths::decl_iterator I = Paths.found_decls_begin(),
2540 E = Paths.found_decls_end(); I != E; ++I) {
2541 if (CXXMethodDecl *OldMD = dyn_cast<CXXMethodDecl>(*I)) {
2542 if (!CheckOverridingFunctionReturnType(MD, OldMD) &&
Sean Huntbbd37c62009-11-21 08:43:09 +00002543 !CheckOverridingFunctionExceptionSpec(MD, OldMD) &&
2544 !CheckOverridingFunctionAttributes(MD, OldMD))
Anders Carlsson3aaf4862009-12-04 05:51:56 +00002545 MD->addOverriddenMethod(OldMD->getCanonicalDecl());
Sebastian Redla165da02009-11-18 21:51:29 +00002546 }
2547 }
2548 }
2549}
2550
Mike Stump1eb44332009-09-09 15:08:12 +00002551NamedDecl*
Zhongxing Xu416fcaf2009-01-16 01:13:29 +00002552Sema::ActOnFunctionDeclarator(Scope* S, Declarator& D, DeclContext* DC,
John McCalla93c9342009-12-07 02:54:59 +00002553 QualType R, TypeSourceInfo *TInfo,
John McCall68263142009-11-18 22:49:29 +00002554 LookupResult &Previous,
Douglas Gregore542c862009-06-23 23:11:28 +00002555 MultiTemplateParamsArg TemplateParamLists,
Chris Lattnereaaebc72009-04-25 08:06:05 +00002556 bool IsFunctionDefinition, bool &Redeclaration) {
Zhongxing Xu416fcaf2009-01-16 01:13:29 +00002557 assert(R.getTypePtr()->isFunctionType());
2558
2559 DeclarationName Name = GetNameForDeclarator(D);
2560 FunctionDecl::StorageClass SC = FunctionDecl::None;
2561 switch (D.getDeclSpec().getStorageClassSpec()) {
2562 default: assert(0 && "Unknown storage class!");
2563 case DeclSpec::SCS_auto:
2564 case DeclSpec::SCS_register:
2565 case DeclSpec::SCS_mutable:
Mike Stump1eb44332009-09-09 15:08:12 +00002566 Diag(D.getDeclSpec().getStorageClassSpecLoc(),
Douglas Gregor04495c82009-02-24 01:23:02 +00002567 diag::err_typecheck_sclass_func);
Chris Lattnereaaebc72009-04-25 08:06:05 +00002568 D.setInvalidType();
Zhongxing Xu416fcaf2009-01-16 01:13:29 +00002569 break;
2570 case DeclSpec::SCS_unspecified: SC = FunctionDecl::None; break;
2571 case DeclSpec::SCS_extern: SC = FunctionDecl::Extern; break;
Douglas Gregor04495c82009-02-24 01:23:02 +00002572 case DeclSpec::SCS_static: {
Douglas Gregor656de632009-03-11 23:52:16 +00002573 if (CurContext->getLookupContext()->isFunctionOrMethod()) {
Douglas Gregor04495c82009-02-24 01:23:02 +00002574 // C99 6.7.1p5:
2575 // The declaration of an identifier for a function that has
2576 // block scope shall have no explicit storage-class specifier
2577 // other than extern
2578 // See also (C++ [dcl.stc]p4).
Mike Stump1eb44332009-09-09 15:08:12 +00002579 Diag(D.getDeclSpec().getStorageClassSpecLoc(),
Douglas Gregor04495c82009-02-24 01:23:02 +00002580 diag::err_static_block_func);
2581 SC = FunctionDecl::None;
2582 } else
Mike Stump1eb44332009-09-09 15:08:12 +00002583 SC = FunctionDecl::Static;
Douglas Gregor04495c82009-02-24 01:23:02 +00002584 break;
2585 }
Zhongxing Xu416fcaf2009-01-16 01:13:29 +00002586 case DeclSpec::SCS_private_extern: SC = FunctionDecl::PrivateExtern;break;
2587 }
2588
Eli Friedman63054b32009-04-19 20:27:55 +00002589 if (D.getDeclSpec().isThreadSpecified())
2590 Diag(D.getDeclSpec().getThreadSpecLoc(), diag::err_invalid_thread);
2591
John McCall3f9a8a62009-08-11 06:59:38 +00002592 bool isFriend = D.getDeclSpec().isFriendSpecified();
Zhongxing Xu416fcaf2009-01-16 01:13:29 +00002593 bool isInline = D.getDeclSpec().isInlineSpecified();
Douglas Gregor021c3b32009-03-11 23:00:04 +00002594 bool isVirtual = D.getDeclSpec().isVirtualSpecified();
Zhongxing Xu416fcaf2009-01-16 01:13:29 +00002595 bool isExplicit = D.getDeclSpec().isExplicitSpecified();
2596
Anders Carlsson4681ebd2009-03-22 20:18:17 +00002597 // Check that the return type is not an abstract class type.
Anders Carlsson8211eff2009-03-24 01:19:16 +00002598 // For record types, this is done by the AbstractClassUsageDiagnoser once
Mike Stump1eb44332009-09-09 15:08:12 +00002599 // the class has been completely parsed.
Anders Carlsson8211eff2009-03-24 01:19:16 +00002600 if (!DC->isRecord() &&
Mike Stump1eb44332009-09-09 15:08:12 +00002601 RequireNonAbstractType(D.getIdentifierLoc(),
John McCall183700f2009-09-21 23:43:11 +00002602 R->getAs<FunctionType>()->getResultType(),
Mike Stump1eb44332009-09-09 15:08:12 +00002603 diag::err_abstract_type_in_decl,
Anders Carlsson8211eff2009-03-24 01:19:16 +00002604 AbstractReturnType))
Chris Lattnereaaebc72009-04-25 08:06:05 +00002605 D.setInvalidType();
Mike Stump1eb44332009-09-09 15:08:12 +00002606
Chris Lattnerbb749822009-04-11 19:17:25 +00002607 // Do not allow returning a objc interface by-value.
John McCall183700f2009-09-21 23:43:11 +00002608 if (R->getAs<FunctionType>()->getResultType()->isObjCInterfaceType()) {
Chris Lattnerbb749822009-04-11 19:17:25 +00002609 Diag(D.getIdentifierLoc(),
2610 diag::err_object_cannot_be_passed_returned_by_value) << 0
John McCall183700f2009-09-21 23:43:11 +00002611 << R->getAs<FunctionType>()->getResultType();
Chris Lattnereaaebc72009-04-25 08:06:05 +00002612 D.setInvalidType();
Chris Lattnerbb749822009-04-11 19:17:25 +00002613 }
Douglas Gregore542c862009-06-23 23:11:28 +00002614
Douglas Gregor021c3b32009-03-11 23:00:04 +00002615 bool isVirtualOkay = false;
Zhongxing Xu416fcaf2009-01-16 01:13:29 +00002616 FunctionDecl *NewFD;
John McCall02cace72009-08-28 07:59:38 +00002617
John McCall3f9a8a62009-08-11 06:59:38 +00002618 if (isFriend) {
John McCall3f9a8a62009-08-11 06:59:38 +00002619 // C++ [class.friend]p5
2620 // A function can be defined in a friend declaration of a
2621 // class . . . . Such a function is implicitly inline.
2622 isInline |= IsFunctionDefinition;
John McCall02cace72009-08-28 07:59:38 +00002623 }
John McCall3f9a8a62009-08-11 06:59:38 +00002624
Douglas Gregor3f9a0562009-11-03 01:35:08 +00002625 if (Name.getNameKind() == DeclarationName::CXXConstructorName) {
Zhongxing Xu416fcaf2009-01-16 01:13:29 +00002626 // This is a C++ constructor declaration.
2627 assert(DC->isRecord() &&
2628 "Constructors can only be declared in a member context");
2629
Chris Lattner65401802009-04-25 08:28:21 +00002630 R = CheckConstructorDeclarator(D, R, SC);
Zhongxing Xu416fcaf2009-01-16 01:13:29 +00002631
2632 // Create the new declaration
Mike Stump1eb44332009-09-09 15:08:12 +00002633 NewFD = CXXConstructorDecl::Create(Context,
Zhongxing Xu416fcaf2009-01-16 01:13:29 +00002634 cast<CXXRecordDecl>(DC),
John McCalla93c9342009-12-07 02:54:59 +00002635 D.getIdentifierLoc(), Name, R, TInfo,
Zhongxing Xu416fcaf2009-01-16 01:13:29 +00002636 isExplicit, isInline,
2637 /*isImplicitlyDeclared=*/false);
Douglas Gregor3f9a0562009-11-03 01:35:08 +00002638 } else if (Name.getNameKind() == DeclarationName::CXXDestructorName) {
Zhongxing Xu416fcaf2009-01-16 01:13:29 +00002639 // This is a C++ destructor declaration.
2640 if (DC->isRecord()) {
Chris Lattner65401802009-04-25 08:28:21 +00002641 R = CheckDestructorDeclarator(D, SC);
Mike Stump1eb44332009-09-09 15:08:12 +00002642
Zhongxing Xu416fcaf2009-01-16 01:13:29 +00002643 NewFD = CXXDestructorDecl::Create(Context,
2644 cast<CXXRecordDecl>(DC),
Mike Stump1eb44332009-09-09 15:08:12 +00002645 D.getIdentifierLoc(), Name, R,
Zhongxing Xu416fcaf2009-01-16 01:13:29 +00002646 isInline,
2647 /*isImplicitlyDeclared=*/false);
2648
Douglas Gregor021c3b32009-03-11 23:00:04 +00002649 isVirtualOkay = true;
Zhongxing Xu416fcaf2009-01-16 01:13:29 +00002650 } else {
2651 Diag(D.getIdentifierLoc(), diag::err_destructor_not_member);
2652
2653 // Create a FunctionDecl to satisfy the function definition parsing
2654 // code path.
2655 NewFD = FunctionDecl::Create(Context, DC, D.getIdentifierLoc(),
John McCalla93c9342009-12-07 02:54:59 +00002656 Name, R, TInfo, SC, isInline,
Argyrios Kyrtzidisa5d82002009-08-21 00:31:54 +00002657 /*hasPrototype=*/true);
Chris Lattnereaaebc72009-04-25 08:06:05 +00002658 D.setInvalidType();
Zhongxing Xu416fcaf2009-01-16 01:13:29 +00002659 }
Douglas Gregor3f9a0562009-11-03 01:35:08 +00002660 } else if (Name.getNameKind() == DeclarationName::CXXConversionFunctionName) {
Zhongxing Xu416fcaf2009-01-16 01:13:29 +00002661 if (!DC->isRecord()) {
2662 Diag(D.getIdentifierLoc(),
2663 diag::err_conv_function_not_member);
2664 return 0;
Zhongxing Xu416fcaf2009-01-16 01:13:29 +00002665 }
Mike Stump1eb44332009-09-09 15:08:12 +00002666
Chris Lattner6e475012009-04-25 08:35:12 +00002667 CheckConversionDeclarator(D, R, SC);
2668 NewFD = CXXConversionDecl::Create(Context, cast<CXXRecordDecl>(DC),
John McCalla93c9342009-12-07 02:54:59 +00002669 D.getIdentifierLoc(), Name, R, TInfo,
Chris Lattner6e475012009-04-25 08:35:12 +00002670 isInline, isExplicit);
Mike Stump1eb44332009-09-09 15:08:12 +00002671
Chris Lattner6e475012009-04-25 08:35:12 +00002672 isVirtualOkay = true;
Zhongxing Xu416fcaf2009-01-16 01:13:29 +00002673 } else if (DC->isRecord()) {
Anders Carlsson4649cac2009-04-30 22:41:11 +00002674 // If the of the function is the same as the name of the record, then this
Mike Stump1eb44332009-09-09 15:08:12 +00002675 // must be an invalid constructor that has a return type.
2676 // (The parser checks for a return type and makes the declarator a
Anders Carlsson4649cac2009-04-30 22:41:11 +00002677 // constructor if it has no return type).
Mike Stump1eb44332009-09-09 15:08:12 +00002678 // must have an invalid constructor that has a return type
Anders Carlsson4649cac2009-04-30 22:41:11 +00002679 if (Name.getAsIdentifierInfo() == cast<CXXRecordDecl>(DC)->getIdentifier()){
2680 Diag(D.getIdentifierLoc(), diag::err_constructor_return_type)
2681 << SourceRange(D.getDeclSpec().getTypeSpecTypeLoc())
2682 << SourceRange(D.getIdentifierLoc());
2683 return 0;
2684 }
Mike Stump1eb44332009-09-09 15:08:12 +00002685
Anders Carlsson67bf2e72009-11-15 18:59:32 +00002686 bool isStatic = SC == FunctionDecl::Static;
2687
2688 // [class.free]p1:
2689 // Any allocation function for a class T is a static member
2690 // (even if not explicitly declared static).
2691 if (Name.getCXXOverloadedOperator() == OO_New ||
2692 Name.getCXXOverloadedOperator() == OO_Array_New)
2693 isStatic = true;
Anders Carlsson1f126bd2009-11-15 19:08:46 +00002694
2695 // [class.free]p6 Any deallocation function for a class X is a static member
2696 // (even if not explicitly declared static).
2697 if (Name.getCXXOverloadedOperator() == OO_Delete ||
2698 Name.getCXXOverloadedOperator() == OO_Array_Delete)
2699 isStatic = true;
Anders Carlsson67bf2e72009-11-15 18:59:32 +00002700
Zhongxing Xu416fcaf2009-01-16 01:13:29 +00002701 // This is a C++ method declaration.
2702 NewFD = CXXMethodDecl::Create(Context, cast<CXXRecordDecl>(DC),
John McCalla93c9342009-12-07 02:54:59 +00002703 D.getIdentifierLoc(), Name, R, TInfo,
Anders Carlsson67bf2e72009-11-15 18:59:32 +00002704 isStatic, isInline);
Douglas Gregor021c3b32009-03-11 23:00:04 +00002705
Anders Carlsson1f126bd2009-11-15 19:08:46 +00002706 isVirtualOkay = !isStatic;
Zhongxing Xu416fcaf2009-01-16 01:13:29 +00002707 } else {
Douglas Gregord874def2009-03-19 18:33:54 +00002708 // Determine whether the function was written with a
2709 // prototype. This true when:
2710 // - we're in C++ (where every function has a prototype),
2711 // - there is a prototype in the declarator, or
2712 // - the type R of the function is some kind of typedef or other reference
2713 // to a type name (which eventually refers to a function type).
Mike Stump1eb44332009-09-09 15:08:12 +00002714 bool HasPrototype =
Chris Lattner0d48bf92009-03-17 23:17:04 +00002715 getLangOptions().CPlusPlus ||
Douglas Gregor13d7a322009-03-19 18:14:46 +00002716 (D.getNumTypeObjects() && D.getTypeObject(0).Fun.hasPrototype) ||
Douglas Gregord1659a62009-03-23 16:26:51 +00002717 (!isa<FunctionType>(R.getTypePtr()) && R->isFunctionProtoType());
Mike Stump1eb44332009-09-09 15:08:12 +00002718
Zhongxing Xu416fcaf2009-01-16 01:13:29 +00002719 NewFD = FunctionDecl::Create(Context, DC,
2720 D.getIdentifierLoc(),
John McCalla93c9342009-12-07 02:54:59 +00002721 Name, R, TInfo, SC, isInline, HasPrototype);
Zhongxing Xu416fcaf2009-01-16 01:13:29 +00002722 }
2723
Chris Lattnereaaebc72009-04-25 08:06:05 +00002724 if (D.isInvalidType())
Chris Lattner584be452009-04-25 05:44:12 +00002725 NewFD->setInvalidDecl();
Mike Stump1eb44332009-09-09 15:08:12 +00002726
Zhongxing Xu416fcaf2009-01-16 01:13:29 +00002727 // Set the lexical context. If the declarator has a C++
John McCall02cace72009-08-28 07:59:38 +00002728 // scope specifier, or is the object of a friend declaration, the
2729 // lexical context will be different from the semantic context.
Zhongxing Xu416fcaf2009-01-16 01:13:29 +00002730 NewFD->setLexicalDeclContext(CurContext);
2731
Douglas Gregorf59a56e2009-07-21 23:53:31 +00002732 // Match up the template parameter lists with the scope specifier, then
2733 // determine whether we have a template or a template specialization.
Douglas Gregorc5c903a2009-06-24 00:23:40 +00002734 FunctionTemplateDecl *FunctionTemplate = 0;
Douglas Gregor1fef4e62009-10-07 22:35:40 +00002735 bool isExplicitSpecialization = false;
Douglas Gregorb9aa6b22009-09-24 23:14:47 +00002736 bool isFunctionTemplateSpecialization = false;
Douglas Gregorf59a56e2009-07-21 23:53:31 +00002737 if (TemplateParameterList *TemplateParams
2738 = MatchTemplateParametersToScopeSpecifier(
2739 D.getDeclSpec().getSourceRange().getBegin(),
2740 D.getCXXScopeSpec(),
Douglas Gregor27eeb5e2009-07-22 22:05:02 +00002741 (TemplateParameterList**)TemplateParamLists.get(),
Douglas Gregor1fef4e62009-10-07 22:35:40 +00002742 TemplateParamLists.size(),
2743 isExplicitSpecialization)) {
Douglas Gregorc5c903a2009-06-24 00:23:40 +00002744 if (TemplateParams->size() > 0) {
2745 // This is a function template
Mike Stump1eb44332009-09-09 15:08:12 +00002746
Douglas Gregor05396e22009-08-25 17:23:04 +00002747 // Check that we can declare a template here.
2748 if (CheckTemplateDeclScope(S, TemplateParams))
2749 return 0;
Mike Stump1eb44332009-09-09 15:08:12 +00002750
Douglas Gregord60e1052009-08-27 16:57:43 +00002751 FunctionTemplate = FunctionTemplateDecl::Create(Context, DC,
Douglas Gregorc5c903a2009-06-24 00:23:40 +00002752 NewFD->getLocation(),
2753 Name, TemplateParams,
2754 NewFD);
Douglas Gregord60e1052009-08-27 16:57:43 +00002755 FunctionTemplate->setLexicalDeclContext(CurContext);
Douglas Gregorc5c903a2009-06-24 00:23:40 +00002756 NewFD->setDescribedFunctionTemplate(FunctionTemplate);
2757 } else {
Douglas Gregorb9aa6b22009-09-24 23:14:47 +00002758 // This is a function template specialization.
2759 isFunctionTemplateSpecialization = true;
Douglas Gregorc5c903a2009-06-24 00:23:40 +00002760 }
Mike Stump1eb44332009-09-09 15:08:12 +00002761
Douglas Gregor27eeb5e2009-07-22 22:05:02 +00002762 // FIXME: Free this memory properly.
2763 TemplateParamLists.release();
Mike Stump1eb44332009-09-09 15:08:12 +00002764 }
Douglas Gregorb9aa6b22009-09-24 23:14:47 +00002765
Douglas Gregor021c3b32009-03-11 23:00:04 +00002766 // C++ [dcl.fct.spec]p5:
2767 // The virtual specifier shall only be used in declarations of
2768 // nonstatic class member functions that appear within a
2769 // member-specification of a class declaration; see 10.3.
2770 //
Chris Lattnereaaebc72009-04-25 08:06:05 +00002771 if (isVirtual && !NewFD->isInvalidDecl()) {
Douglas Gregor021c3b32009-03-11 23:00:04 +00002772 if (!isVirtualOkay) {
Mike Stump1eb44332009-09-09 15:08:12 +00002773 Diag(D.getDeclSpec().getVirtualSpecLoc(),
Douglas Gregor021c3b32009-03-11 23:00:04 +00002774 diag::err_virtual_non_function);
2775 } else if (!CurContext->isRecord()) {
2776 // 'virtual' was specified outside of the class.
2777 Diag(D.getDeclSpec().getVirtualSpecLoc(), diag::err_virtual_out_of_class)
2778 << CodeModificationHint::CreateRemoval(
Chris Lattner29d9c1a2009-12-06 17:36:05 +00002779 D.getDeclSpec().getVirtualSpecLoc());
Douglas Gregor021c3b32009-03-11 23:00:04 +00002780 } else {
2781 // Okay: Add virtual to the method.
Douglas Gregor021c3b32009-03-11 23:00:04 +00002782 CXXRecordDecl *CurClass = cast<CXXRecordDecl>(DC);
Fariborz Jahaniane7184df2009-12-03 18:44:40 +00002783 CurClass->setMethodAsVirtual(NewFD);
Douglas Gregor021c3b32009-03-11 23:00:04 +00002784 }
2785 }
2786
Anders Carlsson0757c8c2010-01-24 16:49:46 +00002787 // C++ [dcl.fct.spec]p6:
2788 // The explicit specifier shall be used only in the declaration of a
2789 // constructor or conversion function within its class definition; see 12.3.1
2790 // and 12.3.2.
2791 if (isExplicit && !NewFD->isInvalidDecl()) {
2792 if (!CurContext->isRecord()) {
2793 // 'explicit' was specified outside of the class.
2794 Diag(D.getDeclSpec().getExplicitSpecLoc(),
2795 diag::err_explicit_out_of_class)
2796 << CodeModificationHint::CreateRemoval(
2797 D.getDeclSpec().getExplicitSpecLoc());
2798 } else if (!isa<CXXConstructorDecl>(NewFD) &&
2799 !isa<CXXConversionDecl>(NewFD)) {
2800 // 'explicit' was specified on a function that wasn't a constructor
2801 // or conversion function.
2802 Diag(D.getDeclSpec().getExplicitSpecLoc(),
2803 diag::err_explicit_non_ctor_or_conv_function)
2804 << CodeModificationHint::CreateRemoval(
2805 D.getDeclSpec().getExplicitSpecLoc());
2806 }
2807 }
2808
John McCall68263142009-11-18 22:49:29 +00002809 // Filter out previous declarations that don't match the scope.
2810 FilterLookupForScope(*this, Previous, DC, S, NewFD->hasLinkage());
2811
Douglas Gregora735b202009-10-13 14:39:41 +00002812 if (isFriend) {
John McCall68263142009-11-18 22:49:29 +00002813 // DC is the namespace in which the function is being declared.
2814 assert((DC->isFileContext() || !Previous.empty()) &&
2815 "previously-undeclared friend function being created "
2816 "in a non-namespace context");
2817
Douglas Gregora735b202009-10-13 14:39:41 +00002818 if (FunctionTemplate) {
2819 FunctionTemplate->setObjectOfFriendDecl(
John McCall68263142009-11-18 22:49:29 +00002820 /* PreviouslyDeclared= */ !Previous.empty());
Douglas Gregora735b202009-10-13 14:39:41 +00002821 FunctionTemplate->setAccess(AS_public);
2822 }
2823 else
John McCall68263142009-11-18 22:49:29 +00002824 NewFD->setObjectOfFriendDecl(/* PreviouslyDeclared= */ !Previous.empty());
Douglas Gregora735b202009-10-13 14:39:41 +00002825
2826 NewFD->setAccess(AS_public);
2827 }
2828
Mike Stump1eb44332009-09-09 15:08:12 +00002829 if (SC == FunctionDecl::Static && isa<CXXMethodDecl>(NewFD) &&
Douglas Gregor656de632009-03-11 23:52:16 +00002830 !CurContext->isRecord()) {
2831 // C++ [class.static]p1:
2832 // A data or function member of a class may be declared static
2833 // in a class definition, in which case it is a static member of
2834 // the class.
2835
2836 // Complain about the 'static' specifier if it's on an out-of-line
2837 // member function definition.
Mike Stump1eb44332009-09-09 15:08:12 +00002838 Diag(D.getDeclSpec().getStorageClassSpecLoc(),
Douglas Gregor656de632009-03-11 23:52:16 +00002839 diag::err_static_out_of_line)
2840 << CodeModificationHint::CreateRemoval(
Chris Lattner29d9c1a2009-12-06 17:36:05 +00002841 D.getDeclSpec().getStorageClassSpecLoc());
Douglas Gregor656de632009-03-11 23:52:16 +00002842 }
2843
Zhongxing Xu416fcaf2009-01-16 01:13:29 +00002844 // Handle GNU asm-label extension (encoded as an attribute).
2845 if (Expr *E = (Expr*) D.getAsmLabel()) {
2846 // The parser guarantees this is a string.
Mike Stump1eb44332009-09-09 15:08:12 +00002847 StringLiteral *SE = cast<StringLiteral>(E);
Benjamin Kramerbb377ed2009-11-30 17:08:26 +00002848 NewFD->addAttr(::new (Context) AsmLabelAttr(SE->getString()));
Zhongxing Xu416fcaf2009-01-16 01:13:29 +00002849 }
2850
Chris Lattner2dbd2852009-04-25 06:12:16 +00002851 // Copy the parameter declarations from the declarator D to the function
2852 // declaration NewFD, if they are available. First scavenge them into Params.
2853 llvm::SmallVector<ParmVarDecl*, 16> Params;
Zhongxing Xu416fcaf2009-01-16 01:13:29 +00002854 if (D.getNumTypeObjects() > 0) {
2855 DeclaratorChunk::FunctionTypeInfo &FTI = D.getTypeObject(0).Fun;
2856
Zhongxing Xu416fcaf2009-01-16 01:13:29 +00002857 // Check for C99 6.7.5.3p10 - foo(void) is a non-varargs
2858 // function that takes no arguments, not a function that takes a
2859 // single void argument.
2860 // We let through "const void" here because Sema::GetTypeForDeclarator
2861 // already checks for that case.
2862 if (FTI.NumArgs == 1 && !FTI.isVariadic && FTI.ArgInfo[0].Ident == 0 &&
2863 FTI.ArgInfo[0].Param &&
Chris Lattnerb28317a2009-03-28 19:18:32 +00002864 FTI.ArgInfo[0].Param.getAs<ParmVarDecl>()->getType()->isVoidType()) {
Chris Lattner2dbd2852009-04-25 06:12:16 +00002865 // Empty arg list, don't push any params.
Chris Lattnerb28317a2009-03-28 19:18:32 +00002866 ParmVarDecl *Param = FTI.ArgInfo[0].Param.getAs<ParmVarDecl>();
Zhongxing Xu416fcaf2009-01-16 01:13:29 +00002867
2868 // In C++, the empty parameter-type-list must be spelled "void"; a
2869 // typedef of void is not permitted.
2870 if (getLangOptions().CPlusPlus &&
Chris Lattner584be452009-04-25 05:44:12 +00002871 Param->getType().getUnqualifiedType() != Context.VoidTy)
Douglas Gregora3a83512009-04-01 23:51:29 +00002872 Diag(Param->getLocation(), diag::err_param_typedef_of_void);
Chris Lattner2dbd2852009-04-25 06:12:16 +00002873 // FIXME: Leaks decl?
Zhongxing Xu416fcaf2009-01-16 01:13:29 +00002874 } else if (FTI.NumArgs > 0 && FTI.ArgInfo[0].Param != 0) {
Argyrios Kyrtzidis9bedef62009-07-14 03:18:53 +00002875 for (unsigned i = 0, e = FTI.NumArgs; i != e; ++i) {
2876 ParmVarDecl *Param = FTI.ArgInfo[i].Param.getAs<ParmVarDecl>();
2877 assert(Param->getDeclContext() != NewFD && "Was set before ?");
2878 Param->setDeclContext(NewFD);
2879 Params.push_back(Param);
2880 }
Zhongxing Xu416fcaf2009-01-16 01:13:29 +00002881 }
Mike Stump1eb44332009-09-09 15:08:12 +00002882
John McCall183700f2009-09-21 23:43:11 +00002883 } else if (const FunctionProtoType *FT = R->getAs<FunctionProtoType>()) {
Chris Lattner1ad9b282009-04-25 06:03:53 +00002884 // When we're declaring a function with a typedef, typeof, etc as in the
Zhongxing Xu416fcaf2009-01-16 01:13:29 +00002885 // following example, we'll need to synthesize (unnamed)
2886 // parameters for use in the declaration.
2887 //
2888 // @code
2889 // typedef void fn(int);
2890 // fn f;
2891 // @endcode
Mike Stump1eb44332009-09-09 15:08:12 +00002892
Chris Lattner1ad9b282009-04-25 06:03:53 +00002893 // Synthesize a parameter for each argument type.
Chris Lattner1ad9b282009-04-25 06:03:53 +00002894 for (FunctionProtoType::arg_type_iterator AI = FT->arg_type_begin(),
2895 AE = FT->arg_type_end(); AI != AE; ++AI) {
John McCall7a9813c2010-01-22 00:28:27 +00002896 ParmVarDecl *Param = ParmVarDecl::Create(Context, NewFD,
Chris Lattner1ad9b282009-04-25 06:03:53 +00002897 SourceLocation(), 0,
John McCalla93c9342009-12-07 02:54:59 +00002898 *AI, /*TInfo=*/0,
Argyrios Kyrtzidisa1d56622009-08-19 01:27:57 +00002899 VarDecl::None, 0);
Chris Lattner1ad9b282009-04-25 06:03:53 +00002900 Param->setImplicit();
2901 Params.push_back(Param);
Zhongxing Xu416fcaf2009-01-16 01:13:29 +00002902 }
Chris Lattner84bb9442009-04-25 18:38:18 +00002903 } else {
2904 assert(R->isFunctionNoProtoType() && NewFD->getNumParams() == 0 &&
2905 "Should not need args for typedef of non-prototype fn");
Zhongxing Xu416fcaf2009-01-16 01:13:29 +00002906 }
Chris Lattner2dbd2852009-04-25 06:12:16 +00002907 // Finally, we know we have the right number of parameters, install them.
Jay Foadbeaaccd2009-05-21 09:52:38 +00002908 NewFD->setParams(Context, Params.data(), Params.size());
Mike Stump1eb44332009-09-09 15:08:12 +00002909
Douglas Gregor0b60d9e2009-09-25 23:53:26 +00002910 // If the declarator is a template-id, translate the parser's template
2911 // argument list into our AST format.
2912 bool HasExplicitTemplateArgs = false;
John McCalld5532b62009-11-23 01:53:49 +00002913 TemplateArgumentListInfo TemplateArgs;
Douglas Gregor3f9a0562009-11-03 01:35:08 +00002914 if (D.getName().getKind() == UnqualifiedId::IK_TemplateId) {
2915 TemplateIdAnnotation *TemplateId = D.getName().TemplateId;
John McCalld5532b62009-11-23 01:53:49 +00002916 TemplateArgs.setLAngleLoc(TemplateId->LAngleLoc);
2917 TemplateArgs.setRAngleLoc(TemplateId->RAngleLoc);
Douglas Gregor0b60d9e2009-09-25 23:53:26 +00002918 ASTTemplateArgsPtr TemplateArgsPtr(*this,
2919 TemplateId->getTemplateArgs(),
Douglas Gregor0b60d9e2009-09-25 23:53:26 +00002920 TemplateId->NumArgs);
2921 translateTemplateArguments(TemplateArgsPtr,
Douglas Gregor0b60d9e2009-09-25 23:53:26 +00002922 TemplateArgs);
2923 TemplateArgsPtr.release();
2924
2925 HasExplicitTemplateArgs = true;
Douglas Gregor0b60d9e2009-09-25 23:53:26 +00002926
2927 if (FunctionTemplate) {
Douglas Gregor1fef4e62009-10-07 22:35:40 +00002928 // FIXME: Diagnose function template with explicit template
Douglas Gregor0b60d9e2009-09-25 23:53:26 +00002929 // arguments.
2930 HasExplicitTemplateArgs = false;
2931 } else if (!isFunctionTemplateSpecialization &&
2932 !D.getDeclSpec().isFriendSpecified()) {
2933 // We have encountered something that the user meant to be a
2934 // specialization (because it has explicitly-specified template
2935 // arguments) but that was not introduced with a "template<>" (or had
2936 // too few of them).
2937 Diag(D.getIdentifierLoc(), diag::err_template_spec_needs_header)
2938 << SourceRange(TemplateId->LAngleLoc, TemplateId->RAngleLoc)
2939 << CodeModificationHint::CreateInsertion(
2940 D.getDeclSpec().getSourceRange().getBegin(),
2941 "template<> ");
2942 isFunctionTemplateSpecialization = true;
2943 }
2944 }
John McCall68263142009-11-18 22:49:29 +00002945
Douglas Gregor1fef4e62009-10-07 22:35:40 +00002946 if (isFunctionTemplateSpecialization) {
John McCalld5532b62009-11-23 01:53:49 +00002947 if (CheckFunctionTemplateSpecialization(NewFD,
2948 (HasExplicitTemplateArgs ? &TemplateArgs : 0),
John McCall68263142009-11-18 22:49:29 +00002949 Previous))
Douglas Gregor1fef4e62009-10-07 22:35:40 +00002950 NewFD->setInvalidDecl();
2951 } else if (isExplicitSpecialization && isa<CXXMethodDecl>(NewFD) &&
John McCall68263142009-11-18 22:49:29 +00002952 CheckMemberSpecialization(NewFD, Previous))
Douglas Gregorb9aa6b22009-09-24 23:14:47 +00002953 NewFD->setInvalidDecl();
Douglas Gregorfd056bc2009-10-13 16:30:37 +00002954
Douglas Gregor2dc0e642009-03-23 23:06:20 +00002955 // Perform semantic checking on the function declaration.
2956 bool OverloadableAttrRequired = false; // FIXME: HACK!
John McCall9f54ad42009-12-10 09:41:52 +00002957 CheckFunctionDeclaration(S, NewFD, Previous, isExplicitSpecialization,
Douglas Gregorfd056bc2009-10-13 16:30:37 +00002958 Redeclaration, /*FIXME:*/OverloadableAttrRequired);
Douglas Gregor2dc0e642009-03-23 23:06:20 +00002959
John McCall68263142009-11-18 22:49:29 +00002960 assert((NewFD->isInvalidDecl() || !Redeclaration ||
2961 Previous.getResultKind() != LookupResult::FoundOverloaded) &&
2962 "previous declaration set still overloaded");
2963
Douglas Gregor5b6d70e2009-11-25 17:50:39 +00002964 // If we have a function template, check the template parameter
2965 // list. This will check and merge default template arguments.
2966 if (FunctionTemplate) {
2967 FunctionTemplateDecl *PrevTemplate = FunctionTemplate->getPreviousDeclaration();
2968 CheckTemplateParameterList(FunctionTemplate->getTemplateParameters(),
2969 PrevTemplate? PrevTemplate->getTemplateParameters() : 0,
2970 D.getDeclSpec().isFriendSpecified()? TPC_FriendFunctionTemplate
2971 : TPC_FunctionTemplate);
2972 }
2973
Chris Lattnereaaebc72009-04-25 08:06:05 +00002974 if (D.getCXXScopeSpec().isSet() && !NewFD->isInvalidDecl()) {
John McCall46460a62010-01-20 21:53:11 +00002975 // Fake up an access specifier if it's supposed to be a class member.
2976 if (isa<CXXRecordDecl>(NewFD->getDeclContext()))
2977 NewFD->setAccess(AS_public);
2978
Douglas Gregor2dc0e642009-03-23 23:06:20 +00002979 // An out-of-line member function declaration must also be a
2980 // definition (C++ [dcl.meaning]p1).
Douglas Gregor741fab62009-10-08 15:54:21 +00002981 // Note that this is not the case for explicit specializations of
2982 // function templates or member functions of class templates, per
2983 // C++ [temp.expl.spec]p2.
Douglas Gregord85cef52009-09-17 19:51:30 +00002984 if (!IsFunctionDefinition && !isFriend &&
Douglas Gregor37d681852009-10-12 22:27:17 +00002985 !isFunctionTemplateSpecialization && !isExplicitSpecialization) {
Douglas Gregor2dc0e642009-03-23 23:06:20 +00002986 Diag(NewFD->getLocation(), diag::err_out_of_line_declaration)
2987 << D.getCXXScopeSpec().getRange();
Chris Lattnereaaebc72009-04-25 08:06:05 +00002988 NewFD->setInvalidDecl();
Douglas Gregor5d52e472010-01-16 18:09:52 +00002989 } else if (!Redeclaration &&
2990 !(isFriend && CurContext->isDependentContext())) {
Douglas Gregor2dc0e642009-03-23 23:06:20 +00002991 // The user tried to provide an out-of-line definition for a
2992 // function that is a member of a class or namespace, but there
Mike Stump1eb44332009-09-09 15:08:12 +00002993 // was no such member function declared (C++ [class.mfct]p2,
Douglas Gregor2dc0e642009-03-23 23:06:20 +00002994 // C++ [namespace.memdef]p2). For example:
Mike Stump1eb44332009-09-09 15:08:12 +00002995 //
Douglas Gregor2dc0e642009-03-23 23:06:20 +00002996 // class X {
2997 // void f() const;
Mike Stump1eb44332009-09-09 15:08:12 +00002998 // };
Douglas Gregor2dc0e642009-03-23 23:06:20 +00002999 //
3000 // void X::f() { } // ill-formed
3001 //
3002 // Complain about this problem, and attempt to suggest close
3003 // matches (e.g., those that differ only in cv-qualifiers and
3004 // whether the parameter types are references).
3005 Diag(D.getIdentifierLoc(), diag::err_member_def_does_not_match)
Douglas Gregor3f093272009-10-13 21:16:44 +00003006 << Name << DC << D.getCXXScopeSpec().getRange();
Chris Lattnereaaebc72009-04-25 08:06:05 +00003007 NewFD->setInvalidDecl();
Mike Stump1eb44332009-09-09 15:08:12 +00003008
John McCalla24dc2e2009-11-17 02:14:36 +00003009 LookupResult Prev(*this, Name, D.getIdentifierLoc(), LookupOrdinaryName,
John McCall7d384dd2009-11-18 07:57:50 +00003010 ForRedeclaration);
John McCalla24dc2e2009-11-17 02:14:36 +00003011 LookupQualifiedName(Prev, DC);
Mike Stump1eb44332009-09-09 15:08:12 +00003012 assert(!Prev.isAmbiguous() &&
Douglas Gregor2dc0e642009-03-23 23:06:20 +00003013 "Cannot have an ambiguity in previous-declaration lookup");
3014 for (LookupResult::iterator Func = Prev.begin(), FuncEnd = Prev.end();
3015 Func != FuncEnd; ++Func) {
3016 if (isa<FunctionDecl>(*Func) &&
3017 isNearlyMatchingFunction(Context, cast<FunctionDecl>(*Func), NewFD))
3018 Diag((*Func)->getLocation(), diag::note_member_def_close_match);
3019 }
Douglas Gregor2dc0e642009-03-23 23:06:20 +00003020 }
3021 }
3022
3023 // Handle attributes. We need to have merged decls when handling attributes
3024 // (for example to check for conflicts, etc).
3025 // FIXME: This needs to happen before we merge declarations. Then,
3026 // let attribute merging cope with attribute conflicts.
Douglas Gregor9cdda0c2009-06-17 21:51:59 +00003027 ProcessDeclAttributes(S, NewFD, D);
Ryan Flynn478fbc62009-07-25 22:29:44 +00003028
3029 // attributes declared post-definition are currently ignored
John McCall68263142009-11-18 22:49:29 +00003030 if (Redeclaration && Previous.isSingleResult()) {
3031 const FunctionDecl *Def;
3032 FunctionDecl *PrevFD = dyn_cast<FunctionDecl>(Previous.getFoundDecl());
Ryan Flynn478fbc62009-07-25 22:29:44 +00003033 if (PrevFD && PrevFD->getBody(Def) && D.hasAttributes()) {
3034 Diag(NewFD->getLocation(), diag::warn_attribute_precede_definition);
3035 Diag(Def->getLocation(), diag::note_previous_definition);
3036 }
3037 }
3038
Douglas Gregor2dc0e642009-03-23 23:06:20 +00003039 AddKnownFunctionAttributes(NewFD);
3040
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +00003041 if (OverloadableAttrRequired && !NewFD->getAttr<OverloadableAttr>()) {
Douglas Gregor2dc0e642009-03-23 23:06:20 +00003042 // If a function name is overloadable in C, then every function
3043 // with that name must be marked "overloadable".
3044 Diag(NewFD->getLocation(), diag::err_attribute_overloadable_missing)
3045 << Redeclaration << NewFD;
John McCall68263142009-11-18 22:49:29 +00003046 if (!Previous.empty())
3047 Diag(Previous.getRepresentativeDecl()->getLocation(),
Douglas Gregor2dc0e642009-03-23 23:06:20 +00003048 diag::note_attribute_overloadable_prev_overload);
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +00003049 NewFD->addAttr(::new (Context) OverloadableAttr());
Douglas Gregor2dc0e642009-03-23 23:06:20 +00003050 }
3051
3052 // If this is a locally-scoped extern C function, update the
3053 // map of such names.
Douglas Gregor48a83b52009-09-12 00:17:51 +00003054 if (CurContext->isFunctionOrMethod() && NewFD->isExternC()
Chris Lattnereaaebc72009-04-25 08:06:05 +00003055 && !NewFD->isInvalidDecl())
John McCall68263142009-11-18 22:49:29 +00003056 RegisterLocallyScopedExternCDecl(NewFD, Previous, S);
Douglas Gregor2dc0e642009-03-23 23:06:20 +00003057
Argyrios Kyrtzidis16f19302009-06-25 18:22:24 +00003058 // Set this FunctionDecl's range up to the right paren.
3059 NewFD->setLocEnd(D.getSourceRange().getEnd());
3060
Douglas Gregore53060f2009-06-25 22:08:12 +00003061 if (FunctionTemplate && NewFD->isInvalidDecl())
3062 FunctionTemplate->setInvalidDecl();
Mike Stump1eb44332009-09-09 15:08:12 +00003063
Douglas Gregore53060f2009-06-25 22:08:12 +00003064 if (FunctionTemplate)
3065 return FunctionTemplate;
Mike Stump1eb44332009-09-09 15:08:12 +00003066
Douglas Gregor2dc0e642009-03-23 23:06:20 +00003067 return NewFD;
3068}
3069
3070/// \brief Perform semantic checking of a new function declaration.
3071///
3072/// Performs semantic analysis of the new function declaration
3073/// NewFD. This routine performs all semantic checking that does not
3074/// require the actual declarator involved in the declaration, and is
3075/// used both for the declaration of functions as they are parsed
3076/// (called via ActOnDeclarator) and for the declaration of functions
3077/// that have been instantiated via C++ template instantiation (called
3078/// via InstantiateDecl).
3079///
Douglas Gregorfd056bc2009-10-13 16:30:37 +00003080/// \param IsExplicitSpecialiation whether this new function declaration is
3081/// an explicit specialization of the previous declaration.
3082///
Chris Lattnereaaebc72009-04-25 08:06:05 +00003083/// This sets NewFD->isInvalidDecl() to true if there was an error.
John McCall9f54ad42009-12-10 09:41:52 +00003084void Sema::CheckFunctionDeclaration(Scope *S, FunctionDecl *NewFD,
John McCall68263142009-11-18 22:49:29 +00003085 LookupResult &Previous,
Douglas Gregorfd056bc2009-10-13 16:30:37 +00003086 bool IsExplicitSpecialization,
Douglas Gregor2dc0e642009-03-23 23:06:20 +00003087 bool &Redeclaration,
3088 bool &OverloadableAttrRequired) {
Chris Lattnereaaebc72009-04-25 08:06:05 +00003089 // If NewFD is already known erroneous, don't do any of this checking.
3090 if (NewFD->isInvalidDecl())
3091 return;
Douglas Gregor2dc0e642009-03-23 23:06:20 +00003092
Eli Friedman88f7b572009-05-16 12:15:55 +00003093 if (NewFD->getResultType()->isVariablyModifiedType()) {
3094 // Functions returning a variably modified type violate C99 6.7.5.2p2
3095 // because all functions have linkage.
3096 Diag(NewFD->getLocation(), diag::err_vm_func_decl);
3097 return NewFD->setInvalidDecl();
3098 }
3099
Douglas Gregor48a83b52009-09-12 00:17:51 +00003100 if (NewFD->isMain())
3101 CheckMain(NewFD);
John McCall8c4859a2009-07-24 03:03:21 +00003102
Douglas Gregor2dc0e642009-03-23 23:06:20 +00003103 // Check for a previous declaration of this name.
John McCall68263142009-11-18 22:49:29 +00003104 if (Previous.empty() && NewFD->isExternC()) {
Douglas Gregor63935192009-03-02 00:19:53 +00003105 // Since we did not find anything by this name and we're declaring
3106 // an extern "C" function, look for a non-visible extern "C"
3107 // declaration with the same name.
3108 llvm::DenseMap<DeclarationName, NamedDecl *>::iterator Pos
Douglas Gregor2dc0e642009-03-23 23:06:20 +00003109 = LocallyScopedExternalDecls.find(NewFD->getDeclName());
Douglas Gregor63935192009-03-02 00:19:53 +00003110 if (Pos != LocallyScopedExternalDecls.end())
John McCall68263142009-11-18 22:49:29 +00003111 Previous.addDecl(Pos->second);
Douglas Gregor63935192009-03-02 00:19:53 +00003112 }
3113
Douglas Gregor04495c82009-02-24 01:23:02 +00003114 // Merge or overload the declaration with an existing declaration of
3115 // the same name, if appropriate.
John McCall68263142009-11-18 22:49:29 +00003116 if (!Previous.empty()) {
Douglas Gregorf9201e02009-02-11 23:02:49 +00003117 // Determine whether NewFD is an overload of PrevDecl or
Zhongxing Xu416fcaf2009-01-16 01:13:29 +00003118 // a declaration that requires merging. If it's an overload,
3119 // there's no more work to do here; we'll just add the new
3120 // function to the scope.
Douglas Gregorae170942009-02-13 00:26:38 +00003121
John McCall68263142009-11-18 22:49:29 +00003122 NamedDecl *OldDecl = 0;
John McCall871b2e72009-12-09 03:35:25 +00003123 if (!AllowOverloadingOfFunction(Previous, Context)) {
3124 Redeclaration = true;
3125 OldDecl = Previous.getFoundDecl();
3126 } else {
3127 if (!getLangOptions().CPlusPlus) {
3128 OverloadableAttrRequired = true;
3129
3130 // Functions marked "overloadable" must have a prototype (that
3131 // we can't get through declaration merging).
3132 if (!NewFD->getType()->getAs<FunctionProtoType>()) {
3133 Diag(NewFD->getLocation(),
3134 diag::err_attribute_overloadable_no_prototype)
3135 << NewFD;
John McCall68263142009-11-18 22:49:29 +00003136 Redeclaration = true;
John McCall871b2e72009-12-09 03:35:25 +00003137
3138 // Turn this into a variadic function with no parameters.
3139 QualType R = Context.getFunctionType(
3140 NewFD->getType()->getAs<FunctionType>()->getResultType(),
3141 0, 0, true, 0);
3142 NewFD->setType(R);
3143 return NewFD->setInvalidDecl();
3144 }
3145 }
3146
3147 switch (CheckOverload(NewFD, Previous, OldDecl)) {
3148 case Ovl_Match:
John McCall9f54ad42009-12-10 09:41:52 +00003149 Redeclaration = true;
3150 if (isa<UsingShadowDecl>(OldDecl) && CurContext->isRecord()) {
3151 HideUsingShadowDecl(S, cast<UsingShadowDecl>(OldDecl));
3152 Redeclaration = false;
3153 }
John McCall871b2e72009-12-09 03:35:25 +00003154 break;
3155
3156 case Ovl_NonFunction:
3157 Redeclaration = true;
3158 break;
3159
3160 case Ovl_Overload:
3161 Redeclaration = false;
3162 break;
John McCall68263142009-11-18 22:49:29 +00003163 }
3164 }
Zhongxing Xu416fcaf2009-01-16 01:13:29 +00003165
John McCall68263142009-11-18 22:49:29 +00003166 if (Redeclaration) {
Douglas Gregor2dc0e642009-03-23 23:06:20 +00003167 // NewFD and OldDecl represent declarations that need to be
Mike Stump1eb44332009-09-09 15:08:12 +00003168 // merged.
Douglas Gregorcda9c672009-02-16 17:45:42 +00003169 if (MergeFunctionDecl(NewFD, OldDecl))
Chris Lattnereaaebc72009-04-25 08:06:05 +00003170 return NewFD->setInvalidDecl();
Zhongxing Xu416fcaf2009-01-16 01:13:29 +00003171
John McCall68263142009-11-18 22:49:29 +00003172 Previous.clear();
3173 Previous.addDecl(OldDecl);
3174
Douglas Gregore53060f2009-06-25 22:08:12 +00003175 if (FunctionTemplateDecl *OldTemplateDecl
Douglas Gregor37d681852009-10-12 22:27:17 +00003176 = dyn_cast<FunctionTemplateDecl>(OldDecl)) {
Douglas Gregorfd056bc2009-10-13 16:30:37 +00003177 NewFD->setPreviousDeclaration(OldTemplateDecl->getTemplatedDecl());
Douglas Gregor37d681852009-10-12 22:27:17 +00003178 FunctionTemplateDecl *NewTemplateDecl
3179 = NewFD->getDescribedFunctionTemplate();
3180 assert(NewTemplateDecl && "Template/non-template mismatch");
3181 if (CXXMethodDecl *Method
3182 = dyn_cast<CXXMethodDecl>(NewTemplateDecl->getTemplatedDecl())) {
3183 Method->setAccess(OldTemplateDecl->getAccess());
3184 NewTemplateDecl->setAccess(OldTemplateDecl->getAccess());
3185 }
Douglas Gregorfd056bc2009-10-13 16:30:37 +00003186
3187 // If this is an explicit specialization of a member that is a function
3188 // template, mark it as a member specialization.
3189 if (IsExplicitSpecialization &&
3190 NewTemplateDecl->getInstantiatedFromMemberTemplate()) {
3191 NewTemplateDecl->setMemberSpecialization();
3192 assert(OldTemplateDecl->isMemberSpecialization());
3193 }
Douglas Gregor37d681852009-10-12 22:27:17 +00003194 } else {
Argyrios Kyrtzidis9bedef62009-07-14 03:18:53 +00003195 if (isa<CXXMethodDecl>(NewFD)) // Set access for out-of-line definitions
3196 NewFD->setAccess(OldDecl->getAccess());
Douglas Gregore53060f2009-06-25 22:08:12 +00003197 NewFD->setPreviousDeclaration(cast<FunctionDecl>(OldDecl));
Argyrios Kyrtzidis9bedef62009-07-14 03:18:53 +00003198 }
Zhongxing Xu416fcaf2009-01-16 01:13:29 +00003199 }
Douglas Gregor4ce205f2009-02-06 17:46:57 +00003200 }
Zhongxing Xu416fcaf2009-01-16 01:13:29 +00003201
Anders Carlsson2c59d3c2009-09-13 21:33:06 +00003202 // Semantic checking for this function declaration (in isolation).
3203 if (getLangOptions().CPlusPlus) {
3204 // C++-specific checks.
3205 if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(NewFD)) {
3206 CheckConstructor(Constructor);
Anders Carlsson6d701392009-11-15 22:49:34 +00003207 } else if (CXXDestructorDecl *Destructor =
3208 dyn_cast<CXXDestructorDecl>(NewFD)) {
3209 CXXRecordDecl *Record = Destructor->getParent();
Anders Carlsson2c59d3c2009-09-13 21:33:06 +00003210 QualType ClassType = Context.getTypeDeclType(Record);
Anders Carlsson6d701392009-11-15 22:49:34 +00003211
3212 // FIXME: Shouldn't we be able to perform thisc heck even when the class
3213 // type is dependent? Both gcc and edg can handle that.
Anders Carlsson2c59d3c2009-09-13 21:33:06 +00003214 if (!ClassType->isDependentType()) {
3215 DeclarationName Name
3216 = Context.DeclarationNames.getCXXDestructorName(
3217 Context.getCanonicalType(ClassType));
3218 if (NewFD->getDeclName() != Name) {
3219 Diag(NewFD->getLocation(), diag::err_destructor_name);
3220 return NewFD->setInvalidDecl();
3221 }
3222 }
Anders Carlsson6d701392009-11-15 22:49:34 +00003223
Anders Carlsson2c59d3c2009-09-13 21:33:06 +00003224 Record->setUserDeclaredDestructor(true);
3225 // C++ [class]p4: A POD-struct is an aggregate class that has [...] no
3226 // user-defined destructor.
3227 Record->setPOD(false);
3228
3229 // C++ [class.dtor]p3: A destructor is trivial if it is an implicitly-
3230 // declared destructor.
3231 // FIXME: C++0x: don't do this for "= default" destructors
3232 Record->setHasTrivialDestructor(false);
3233 } else if (CXXConversionDecl *Conversion
Douglas Gregor4ba31362009-12-01 17:24:26 +00003234 = dyn_cast<CXXConversionDecl>(NewFD)) {
Anders Carlsson2c59d3c2009-09-13 21:33:06 +00003235 ActOnConversionDeclarator(Conversion);
Douglas Gregor4ba31362009-12-01 17:24:26 +00003236 }
3237
3238 // Find any virtual functions that this function overrides.
Douglas Gregore6342c02009-12-01 17:35:23 +00003239 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(NewFD)) {
3240 if (!Method->isFunctionTemplateSpecialization() &&
3241 !Method->getDescribedFunctionTemplate())
3242 AddOverriddenMethods(Method->getParent(), Method);
3243 }
Anders Carlsson2c59d3c2009-09-13 21:33:06 +00003244
Eli Friedman5fcf1f02009-12-02 07:16:50 +00003245 // Additional checks for the destructor; make sure we do this after we
3246 // figure out whether the destructor is virtual.
3247 if (CXXDestructorDecl *Destructor = dyn_cast<CXXDestructorDecl>(NewFD))
3248 if (!Destructor->getParent()->isDependentType())
3249 CheckDestructor(Destructor);
3250
Anders Carlsson2c59d3c2009-09-13 21:33:06 +00003251 // Extra checking for C++ overloaded operators (C++ [over.oper]).
3252 if (NewFD->isOverloadedOperator() &&
3253 CheckOverloadedOperatorDeclaration(NewFD))
3254 return NewFD->setInvalidDecl();
Sean Hunta6c058d2010-01-13 09:01:02 +00003255
3256 // Extra checking for C++0x literal operators (C++0x [over.literal]).
3257 if (NewFD->getLiteralIdentifier() &&
3258 CheckLiteralOperatorDeclaration(NewFD))
3259 return NewFD->setInvalidDecl();
3260
Anders Carlsson2c59d3c2009-09-13 21:33:06 +00003261 // In C++, check default arguments now that we have merged decls. Unless
3262 // the lexical context is the class, because in this case this is done
3263 // during delayed parsing anyway.
3264 if (!CurContext->isRecord())
3265 CheckCXXDefaultArguments(NewFD);
3266 }
Zhongxing Xu416fcaf2009-01-16 01:13:29 +00003267}
3268
John McCall8c4859a2009-07-24 03:03:21 +00003269void Sema::CheckMain(FunctionDecl* FD) {
John McCall13591ed2009-07-25 04:36:53 +00003270 // C++ [basic.start.main]p3: A program that declares main to be inline
3271 // or static is ill-formed.
3272 // C99 6.7.4p4: In a hosted environment, the inline function specifier
3273 // shall not appear in a declaration of main.
3274 // static main is not an error under C99, but we should warn about it.
Douglas Gregor0130f3c2009-10-27 21:01:01 +00003275 bool isInline = FD->isInlineSpecified();
John McCall13591ed2009-07-25 04:36:53 +00003276 bool isStatic = FD->getStorageClass() == FunctionDecl::Static;
3277 if (isInline || isStatic) {
3278 unsigned diagID = diag::warn_unusual_main_decl;
3279 if (isInline || getLangOptions().CPlusPlus)
3280 diagID = diag::err_unusual_main_decl;
3281
3282 int which = isStatic + (isInline << 1) - 1;
3283 Diag(FD->getLocation(), diagID) << which;
3284 }
3285
3286 QualType T = FD->getType();
3287 assert(T->isFunctionType() && "function decl is not of function type");
John McCall183700f2009-09-21 23:43:11 +00003288 const FunctionType* FT = T->getAs<FunctionType>();
Mike Stump1eb44332009-09-09 15:08:12 +00003289
John McCall13591ed2009-07-25 04:36:53 +00003290 if (!Context.hasSameUnqualifiedType(FT->getResultType(), Context.IntTy)) {
3291 // TODO: add a replacement fixit to turn the return type into 'int'.
3292 Diag(FD->getTypeSpecStartLoc(), diag::err_main_returns_nonint);
3293 FD->setInvalidDecl(true);
3294 }
3295
3296 // Treat protoless main() as nullary.
3297 if (isa<FunctionNoProtoType>(FT)) return;
3298
3299 const FunctionProtoType* FTP = cast<const FunctionProtoType>(FT);
3300 unsigned nparams = FTP->getNumArgs();
3301 assert(FD->getNumParams() == nparams);
3302
John McCall66755862009-12-24 09:58:38 +00003303 bool HasExtraParameters = (nparams > 3);
3304
3305 // Darwin passes an undocumented fourth argument of type char**. If
3306 // other platforms start sprouting these, the logic below will start
3307 // getting shifty.
3308 if (nparams == 4 &&
3309 Context.Target.getTriple().getOS() == llvm::Triple::Darwin)
3310 HasExtraParameters = false;
3311
3312 if (HasExtraParameters) {
John McCall13591ed2009-07-25 04:36:53 +00003313 Diag(FD->getLocation(), diag::err_main_surplus_args) << nparams;
3314 FD->setInvalidDecl(true);
3315 nparams = 3;
3316 }
3317
3318 // FIXME: a lot of the following diagnostics would be improved
3319 // if we had some location information about types.
3320
3321 QualType CharPP =
3322 Context.getPointerType(Context.getPointerType(Context.CharTy));
John McCall66755862009-12-24 09:58:38 +00003323 QualType Expected[] = { Context.IntTy, CharPP, CharPP, CharPP };
John McCall13591ed2009-07-25 04:36:53 +00003324
3325 for (unsigned i = 0; i < nparams; ++i) {
3326 QualType AT = FTP->getArgType(i);
3327
3328 bool mismatch = true;
3329
3330 if (Context.hasSameUnqualifiedType(AT, Expected[i]))
3331 mismatch = false;
3332 else if (Expected[i] == CharPP) {
3333 // As an extension, the following forms are okay:
3334 // char const **
3335 // char const * const *
3336 // char * const *
3337
John McCall0953e762009-09-24 19:53:00 +00003338 QualifierCollector qs;
John McCall13591ed2009-07-25 04:36:53 +00003339 const PointerType* PT;
Ted Kremenek6217b802009-07-29 21:53:49 +00003340 if ((PT = qs.strip(AT)->getAs<PointerType>()) &&
3341 (PT = qs.strip(PT->getPointeeType())->getAs<PointerType>()) &&
John McCall13591ed2009-07-25 04:36:53 +00003342 (QualType(qs.strip(PT->getPointeeType()), 0) == Context.CharTy)) {
3343 qs.removeConst();
3344 mismatch = !qs.empty();
3345 }
3346 }
3347
3348 if (mismatch) {
3349 Diag(FD->getLocation(), diag::err_main_arg_wrong) << i << Expected[i];
3350 // TODO: suggest replacing given type with expected type
3351 FD->setInvalidDecl(true);
3352 }
3353 }
3354
3355 if (nparams == 1 && !FD->isInvalidDecl()) {
3356 Diag(FD->getLocation(), diag::warn_main_one_arg);
3357 }
John McCall8c4859a2009-07-24 03:03:21 +00003358}
3359
Eli Friedmanc594b322008-05-20 13:48:25 +00003360bool Sema::CheckForConstantInitializer(Expr *Init, QualType DclT) {
Eli Friedman3b8a36a2009-02-27 04:17:12 +00003361 // FIXME: Need strict checking. In C89, we need to check for
3362 // any assignment, increment, decrement, function-calls, or
3363 // commas outside of a sizeof. In C99, it's the same list,
3364 // except that the aforementioned are allowed in unevaluated
3365 // expressions. Everything else falls under the
3366 // "may accept other forms of constant expressions" exception.
3367 // (We never end up here for C++, so the constant expression
3368 // rules there don't matter.)
Chris Lattner111c2ee2009-02-24 21:54:33 +00003369 if (Init->isConstantInitializer(Context))
Eli Friedman578a9722009-02-22 06:45:27 +00003370 return false;
Eli Friedman21298282009-02-26 04:47:58 +00003371 Diag(Init->getExprLoc(), diag::err_init_element_not_constant)
3372 << Init->getSourceRange();
Eli Friedmanc594b322008-05-20 13:48:25 +00003373 return true;
Steve Naroffd0091aa2008-01-10 22:15:12 +00003374}
3375
Anders Carlsson9abf2ae2009-08-16 05:13:48 +00003376void Sema::AddInitializerToDecl(DeclPtrTy dcl, ExprArg init) {
3377 AddInitializerToDecl(dcl, move(init), /*DirectInit=*/false);
Douglas Gregor09f41cf2009-01-14 15:45:31 +00003378}
3379
3380/// AddInitializerToDecl - Adds the initializer Init to the
3381/// declaration dcl. If DirectInit is true, this is C++ direct
3382/// initialization rather than copy initialization.
Chris Lattnerb28317a2009-03-28 19:18:32 +00003383void Sema::AddInitializerToDecl(DeclPtrTy dcl, ExprArg init, bool DirectInit) {
3384 Decl *RealDecl = dcl.getAs<Decl>();
Chris Lattner9a11b9a2007-10-19 20:10:30 +00003385 // If there is no declaration, there was an error parsing it. Just ignore
3386 // the initializer.
Eli Friedman3b8a36a2009-02-27 04:17:12 +00003387 if (RealDecl == 0)
Chris Lattner9a11b9a2007-10-19 20:10:30 +00003388 return;
Mike Stump1eb44332009-09-09 15:08:12 +00003389
Douglas Gregor021c3b32009-03-11 23:00:04 +00003390 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(RealDecl)) {
3391 // With declarators parsed the way they are, the parser cannot
3392 // distinguish between a normal initializer and a pure-specifier.
3393 // Thus this grotesque test.
3394 IntegerLiteral *IL;
3395 Expr *Init = static_cast<Expr *>(init.get());
3396 if ((IL = dyn_cast<IntegerLiteral>(Init)) && IL->getValue() == 0 &&
Douglas Gregor4ba31362009-12-01 17:24:26 +00003397 Context.getCanonicalType(IL->getType()) == Context.IntTy)
3398 CheckPureMethod(Method, Init->getSourceRange());
3399 else {
Douglas Gregor021c3b32009-03-11 23:00:04 +00003400 Diag(Method->getLocation(), diag::err_member_function_initialization)
3401 << Method->getDeclName() << Init->getSourceRange();
3402 Method->setInvalidDecl();
3403 }
3404 return;
3405 }
3406
Steve Naroff410e3e22007-09-12 20:13:48 +00003407 VarDecl *VDecl = dyn_cast<VarDecl>(RealDecl);
3408 if (!VDecl) {
Douglas Gregor021c3b32009-03-11 23:00:04 +00003409 if (getLangOptions().CPlusPlus &&
3410 RealDecl->getLexicalDeclContext()->isRecord() &&
3411 isa<NamedDecl>(RealDecl))
3412 Diag(RealDecl->getLocation(), diag::err_member_initialization)
3413 << cast<NamedDecl>(RealDecl)->getDeclName();
3414 else
3415 Diag(RealDecl->getLocation(), diag::err_illegal_initializer);
Steve Naroff410e3e22007-09-12 20:13:48 +00003416 RealDecl->setInvalidDecl();
3417 return;
Eli Friedman3b8a36a2009-02-27 04:17:12 +00003418 }
3419
Eli Friedman49e2b8e2009-11-14 03:40:14 +00003420 // A definition must end up with a complete type, which means it must be
3421 // complete with the restriction that an array type might be completed by the
3422 // initializer; note that later code assumes this restriction.
3423 QualType BaseDeclType = VDecl->getType();
3424 if (const ArrayType *Array = Context.getAsIncompleteArrayType(BaseDeclType))
3425 BaseDeclType = Array->getElementType();
3426 if (RequireCompleteType(VDecl->getLocation(), BaseDeclType,
Eli Friedmana31feca2009-04-13 21:28:54 +00003427 diag::err_typecheck_decl_incomplete_type)) {
3428 RealDecl->setInvalidDecl();
3429 return;
3430 }
3431
Douglas Gregor1ab537b2009-12-03 18:33:45 +00003432 // The variable can not have an abstract class type.
3433 if (RequireNonAbstractType(VDecl->getLocation(), VDecl->getType(),
3434 diag::err_abstract_type_in_decl,
3435 AbstractVariableType))
3436 VDecl->setInvalidDecl();
3437
Douglas Gregor275a3692009-03-10 23:43:53 +00003438 const VarDecl *Def = 0;
3439 if (VDecl->getDefinition(Def)) {
Mike Stump1eb44332009-09-09 15:08:12 +00003440 Diag(VDecl->getLocation(), diag::err_redefinition)
Douglas Gregor275a3692009-03-10 23:43:53 +00003441 << VDecl->getDeclName();
3442 Diag(Def->getLocation(), diag::note_previous_definition);
3443 VDecl->setInvalidDecl();
3444 return;
3445 }
3446
Eli Friedman3b8a36a2009-02-27 04:17:12 +00003447 // Take ownership of the expression, now that we're sure we have somewhere
3448 // to put it.
Anders Carlssonf1b1d592009-05-01 19:30:39 +00003449 Expr *Init = init.takeAs<Expr>();
Eli Friedman3b8a36a2009-02-27 04:17:12 +00003450 assert(Init && "missing initializer");
3451
Douglas Gregor99a2e602009-12-16 01:38:02 +00003452 // Capture the variable that is being initialized and the style of
3453 // initialization.
3454 InitializedEntity Entity = InitializedEntity::InitializeVariable(VDecl);
3455
3456 // FIXME: Poor source location information.
3457 InitializationKind Kind
3458 = DirectInit? InitializationKind::CreateDirect(VDecl->getLocation(),
3459 Init->getLocStart(),
3460 Init->getLocEnd())
3461 : InitializationKind::CreateCopy(VDecl->getLocation(),
3462 Init->getLocStart());
3463
Steve Naroffbb204692007-09-12 14:07:44 +00003464 // Get the decls type and save a reference for later, since
Steve Naroffd0091aa2008-01-10 22:15:12 +00003465 // CheckInitializerTypes may change it.
Steve Naroff410e3e22007-09-12 20:13:48 +00003466 QualType DclT = VDecl->getType(), SavT = DclT;
Steve Naroff248a7532008-04-15 22:42:06 +00003467 if (VDecl->isBlockVarDecl()) {
Daniel Dunbar5466c7b2009-04-14 02:25:56 +00003468 if (VDecl->hasExternalStorage()) { // C99 6.7.8p5
Steve Naroff410e3e22007-09-12 20:13:48 +00003469 Diag(VDecl->getLocation(), diag::err_block_extern_cant_init);
Steve Naroff248a7532008-04-15 22:42:06 +00003470 VDecl->setInvalidDecl();
3471 } else if (!VDecl->isInvalidDecl()) {
Eli Friedmancfdc81a2009-12-19 08:11:05 +00003472 InitializationSequence InitSeq(*this, Entity, Kind, &Init, 1);
Eli Friedmana91eb542009-12-22 02:10:53 +00003473 OwningExprResult Result = InitSeq.Perform(*this, Entity, Kind,
Eli Friedmancfdc81a2009-12-19 08:11:05 +00003474 MultiExprArg(*this, (void**)&Init, 1),
Eli Friedmana91eb542009-12-22 02:10:53 +00003475 &DclT);
3476 if (Result.isInvalid()) {
Steve Naroff248a7532008-04-15 22:42:06 +00003477 VDecl->setInvalidDecl();
Eli Friedmancfdc81a2009-12-19 08:11:05 +00003478 return;
3479 }
Mike Stump1eb44332009-09-09 15:08:12 +00003480
Eli Friedmana91eb542009-12-22 02:10:53 +00003481 Init = Result.takeAs<Expr>();
3482
Anders Carlssonc5eb7312008-08-22 05:00:02 +00003483 // C++ 3.6.2p2, allow dynamic initialization of static initializers.
Eli Friedmanda153232009-02-20 01:34:21 +00003484 // Don't check invalid declarations to avoid emitting useless diagnostics.
3485 if (!getLangOptions().CPlusPlus && !VDecl->isInvalidDecl()) {
Daniel Dunbar5466c7b2009-04-14 02:25:56 +00003486 if (VDecl->getStorageClass() == VarDecl::Static) // C99 6.7.8p4.
Anders Carlssonc5eb7312008-08-22 05:00:02 +00003487 CheckForConstantInitializer(Init, DclT);
3488 }
Steve Naroffbb204692007-09-12 14:07:44 +00003489 }
Mike Stump1eb44332009-09-09 15:08:12 +00003490 } else if (VDecl->isStaticDataMember() &&
Douglas Gregor021c3b32009-03-11 23:00:04 +00003491 VDecl->getLexicalDeclContext()->isRecord()) {
3492 // This is an in-class initialization for a static data member, e.g.,
3493 //
3494 // struct S {
3495 // static const int value = 17;
3496 // };
3497
3498 // Attach the initializer
Douglas Gregor78d15832009-05-26 18:54:04 +00003499 VDecl->setInit(Context, Init);
Douglas Gregor021c3b32009-03-11 23:00:04 +00003500
3501 // C++ [class.mem]p4:
3502 // A member-declarator can contain a constant-initializer only
3503 // if it declares a static member (9.4) of const integral or
3504 // const enumeration type, see 9.4.2.
3505 QualType T = VDecl->getType();
Mike Stump1eb44332009-09-09 15:08:12 +00003506 if (!T->isDependentType() &&
Douglas Gregor021c3b32009-03-11 23:00:04 +00003507 (!Context.getCanonicalType(T).isConstQualified() ||
3508 !T->isIntegralType())) {
3509 Diag(VDecl->getLocation(), diag::err_member_initialization)
3510 << VDecl->getDeclName() << Init->getSourceRange();
3511 VDecl->setInvalidDecl();
3512 } else {
3513 // C++ [class.static.data]p4:
3514 // If a static data member is of const integral or const
3515 // enumeration type, its declaration in the class definition
3516 // can specify a constant-initializer which shall be an
3517 // integral constant expression (5.19).
3518 if (!Init->isTypeDependent() &&
3519 !Init->getType()->isIntegralType()) {
3520 // We have a non-dependent, non-integral or enumeration type.
Mike Stump1eb44332009-09-09 15:08:12 +00003521 Diag(Init->getSourceRange().getBegin(),
Douglas Gregor021c3b32009-03-11 23:00:04 +00003522 diag::err_in_class_initializer_non_integral_type)
3523 << Init->getType() << Init->getSourceRange();
3524 VDecl->setInvalidDecl();
3525 } else if (!Init->isTypeDependent() && !Init->isValueDependent()) {
3526 // Check whether the expression is a constant expression.
3527 llvm::APSInt Value;
3528 SourceLocation Loc;
3529 if (!Init->isIntegerConstantExpr(Value, Context, &Loc)) {
3530 Diag(Loc, diag::err_in_class_initializer_non_constant)
3531 << Init->getSourceRange();
3532 VDecl->setInvalidDecl();
Douglas Gregor3d7a12a2009-03-25 23:32:15 +00003533 } else if (!VDecl->getType()->isDependentType())
Eli Friedman73c39ab2009-10-20 08:27:19 +00003534 ImpCastExprToType(Init, VDecl->getType(), CastExpr::CK_IntegralCast);
Douglas Gregor021c3b32009-03-11 23:00:04 +00003535 }
3536 }
Steve Naroff248a7532008-04-15 22:42:06 +00003537 } else if (VDecl->isFileVarDecl()) {
Steve Naroffee3899e2009-04-15 15:20:03 +00003538 if (VDecl->getStorageClass() == VarDecl::Extern)
Steve Naroff410e3e22007-09-12 20:13:48 +00003539 Diag(VDecl->getLocation(), diag::warn_extern_init);
Eli Friedmana91eb542009-12-22 02:10:53 +00003540 if (!VDecl->isInvalidDecl()) {
3541 InitializationSequence InitSeq(*this, Entity, Kind, &Init, 1);
3542 OwningExprResult Result = InitSeq.Perform(*this, Entity, Kind,
3543 MultiExprArg(*this, (void**)&Init, 1),
3544 &DclT);
3545 if (Result.isInvalid()) {
Steve Naroff248a7532008-04-15 22:42:06 +00003546 VDecl->setInvalidDecl();
Eli Friedmana91eb542009-12-22 02:10:53 +00003547 return;
3548 }
3549
3550 Init = Result.takeAs<Expr>();
3551 }
Mike Stump1eb44332009-09-09 15:08:12 +00003552
Anders Carlssonc5eb7312008-08-22 05:00:02 +00003553 // C++ 3.6.2p2, allow dynamic initialization of static initializers.
Eli Friedmanda153232009-02-20 01:34:21 +00003554 // Don't check invalid declarations to avoid emitting useless diagnostics.
3555 if (!getLangOptions().CPlusPlus && !VDecl->isInvalidDecl()) {
Anders Carlssonc5eb7312008-08-22 05:00:02 +00003556 // C99 6.7.8p4. All file scoped initializers need to be constant.
3557 CheckForConstantInitializer(Init, DclT);
3558 }
Steve Naroffbb204692007-09-12 14:07:44 +00003559 }
3560 // If the type changed, it means we had an incomplete type that was
Mike Stump1eb44332009-09-09 15:08:12 +00003561 // completed by the initializer. For example:
Steve Naroffbb204692007-09-12 14:07:44 +00003562 // int ary[] = { 1, 3, 5 };
3563 // "ary" transitions from a VariableArrayType to a ConstantArrayType.
Christopher Lamb48b12392007-11-29 19:09:19 +00003564 if (!VDecl->isInvalidDecl() && (DclT != SavT)) {
Steve Naroff410e3e22007-09-12 20:13:48 +00003565 VDecl->setType(DclT);
Christopher Lamb48b12392007-11-29 19:09:19 +00003566 Init->setType(DclT);
3567 }
Mike Stump1eb44332009-09-09 15:08:12 +00003568
Anders Carlsson0ece4912009-12-15 20:51:39 +00003569 Init = MaybeCreateCXXExprWithTemporaries(Init);
Steve Naroffbb204692007-09-12 14:07:44 +00003570 // Attach the initializer to the decl.
Douglas Gregor78d15832009-05-26 18:54:04 +00003571 VDecl->setInit(Context, Init);
Douglas Gregorb6c8c8b2009-04-21 17:11:58 +00003572
Eli Friedmandd4e4852009-12-20 22:29:11 +00003573 if (getLangOptions().CPlusPlus) {
3574 // Make sure we mark the destructor as used if necessary.
3575 QualType InitType = VDecl->getType();
Douglas Gregorbd6d6192010-01-05 19:06:31 +00003576 while (const ArrayType *Array = Context.getAsArrayType(InitType))
Eli Friedmandd4e4852009-12-20 22:29:11 +00003577 InitType = Context.getBaseElementType(Array);
3578 if (InitType->isRecordType())
3579 FinalizeVarWithDestructor(VDecl, InitType);
3580 }
3581
Steve Naroffbb204692007-09-12 14:07:44 +00003582 return;
3583}
3584
Mike Stump1eb44332009-09-09 15:08:12 +00003585void Sema::ActOnUninitializedDecl(DeclPtrTy dcl,
Anders Carlsson6a75cd92009-07-11 00:34:39 +00003586 bool TypeContainsUndeducedAuto) {
Chris Lattnerb28317a2009-03-28 19:18:32 +00003587 Decl *RealDecl = dcl.getAs<Decl>();
Douglas Gregor27c8dc02008-10-29 00:13:59 +00003588
Argyrios Kyrtzidis48c2e902008-11-07 13:01:22 +00003589 // If there is no declaration, there was an error parsing it. Just ignore it.
3590 if (RealDecl == 0)
3591 return;
3592
Douglas Gregor27c8dc02008-10-29 00:13:59 +00003593 if (VarDecl *Var = dyn_cast<VarDecl>(RealDecl)) {
3594 QualType Type = Var->getType();
Douglas Gregorb6c8c8b2009-04-21 17:11:58 +00003595
3596 // Record tentative definitions.
Sebastian Redle9d12b62010-01-31 22:27:38 +00003597 if (Var->isTentativeDefinitionNow())
3598 TentativeDefinitions.push_back(Var);
Douglas Gregorb6c8c8b2009-04-21 17:11:58 +00003599
Douglas Gregor27c8dc02008-10-29 00:13:59 +00003600 // C++ [dcl.init.ref]p3:
3601 // The initializer can be omitted for a reference only in a
3602 // parameter declaration (8.3.5), in the declaration of a
3603 // function return type, in the declaration of a class member
3604 // within its class declaration (9.2), and where the extern
3605 // specifier is explicitly used.
Daniel Dunbar5466c7b2009-04-14 02:25:56 +00003606 if (Type->isReferenceType() && !Var->hasExternalStorage()) {
Chris Lattnerd3a94e22008-11-20 06:06:08 +00003607 Diag(Var->getLocation(), diag::err_reference_var_requires_init)
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00003608 << Var->getDeclName()
3609 << SourceRange(Var->getLocation(), Var->getLocation());
Douglas Gregor18fe5682008-11-03 20:45:27 +00003610 Var->setInvalidDecl();
3611 return;
3612 }
3613
Anders Carlsson6a75cd92009-07-11 00:34:39 +00003614 // C++0x [dcl.spec.auto]p3
3615 if (TypeContainsUndeducedAuto) {
3616 Diag(Var->getLocation(), diag::err_auto_var_requires_init)
3617 << Var->getDeclName() << Type;
3618 Var->setInvalidDecl();
3619 return;
3620 }
Mike Stump1eb44332009-09-09 15:08:12 +00003621
Sebastian Redl6e824752009-11-05 19:47:47 +00003622 // An array without size is an incomplete type, and there are no special
3623 // rules in C++ to make such a definition acceptable.
3624 if (getLangOptions().CPlusPlus && Type->isIncompleteArrayType() &&
3625 !Var->hasExternalStorage()) {
3626 Diag(Var->getLocation(),
3627 diag::err_typecheck_incomplete_array_needs_initializer);
3628 Var->setInvalidDecl();
3629 return;
3630 }
3631
Douglas Gregor251b4ff2009-10-08 07:24:58 +00003632 // C++ [temp.expl.spec]p15:
3633 // An explicit specialization of a static data member of a template is a
3634 // definition if the declaration includes an initializer; otherwise, it
3635 // is a declaration.
3636 if (Var->isStaticDataMember() &&
3637 Var->getInstantiatedFromStaticDataMember() &&
3638 Var->getTemplateSpecializationKind() == TSK_ExplicitSpecialization)
3639 return;
3640
Douglas Gregor18fe5682008-11-03 20:45:27 +00003641 // C++ [dcl.init]p9:
Douglas Gregor18fe5682008-11-03 20:45:27 +00003642 // If no initializer is specified for an object, and the object
3643 // is of (possibly cv-qualified) non-POD class type (or array
3644 // thereof), the object shall be default-initialized; if the
3645 // object is of const-qualified type, the underlying class type
3646 // shall have a user-declared default constructor.
Douglas Gregorf8d8d1a2009-09-09 23:58:28 +00003647 //
3648 // FIXME: Diagnose the "user-declared default constructor" bit.
Douglas Gregor18fe5682008-11-03 20:45:27 +00003649 if (getLangOptions().CPlusPlus) {
3650 QualType InitType = Type;
3651 if (const ArrayType *Array = Context.getAsArrayType(Type))
Fariborz Jahanian680a3f32009-10-28 19:04:36 +00003652 InitType = Context.getBaseElementType(Array);
Douglas Gregor48a83b52009-09-12 00:17:51 +00003653 if ((!Var->hasExternalStorage() && !Var->isExternC()) &&
Douglas Gregor8e92bf32009-05-29 14:25:00 +00003654 InitType->isRecordType() && !InitType->isDependentType()) {
Mike Stump1eb44332009-09-09 15:08:12 +00003655 if (!RequireCompleteType(Var->getLocation(), InitType,
Douglas Gregor39da0b82009-09-09 23:08:42 +00003656 diag::err_invalid_incomplete_type_use)) {
Douglas Gregor745880f2009-12-20 22:01:25 +00003657 InitializedEntity Entity
3658 = InitializedEntity::InitializeVariable(Var);
3659 InitializationKind Kind
3660 = InitializationKind::CreateDefault(Var->getLocation());
Douglas Gregor39da0b82009-09-09 23:08:42 +00003661
Douglas Gregor745880f2009-12-20 22:01:25 +00003662 InitializationSequence InitSeq(*this, Entity, Kind, 0, 0);
3663 OwningExprResult Init = InitSeq.Perform(*this, Entity, Kind,
3664 MultiExprArg(*this, 0, 0));
3665 if (Init.isInvalid())
Douglas Gregor39da0b82009-09-09 23:08:42 +00003666 Var->setInvalidDecl();
Douglas Gregorf8d8d1a2009-09-09 23:58:28 +00003667 else {
Douglas Gregor745880f2009-12-20 22:01:25 +00003668 Var->setInit(Context,
3669 MaybeCreateCXXExprWithTemporaries(Init.takeAs<Expr>()));
Douglas Gregor39da0b82009-09-09 23:08:42 +00003670 FinalizeVarWithDestructor(Var, InitType);
Douglas Gregorf8d8d1a2009-09-09 23:58:28 +00003671 }
Douglas Gregor9916a042009-10-08 16:41:22 +00003672 } else {
3673 Var->setInvalidDecl();
Fariborz Jahanian8d2b3562009-06-26 23:49:16 +00003674 }
Douglas Gregor18fe5682008-11-03 20:45:27 +00003675 }
Douglas Gregor1ab537b2009-12-03 18:33:45 +00003676
3677 // The variable can not have an abstract class type.
3678 if (RequireNonAbstractType(Var->getLocation(), Type,
3679 diag::err_abstract_type_in_decl,
3680 AbstractVariableType))
3681 Var->setInvalidDecl();
Douglas Gregor18fe5682008-11-03 20:45:27 +00003682 }
Douglas Gregor27c8dc02008-10-29 00:13:59 +00003683
Douglas Gregor818ce482008-10-29 13:50:18 +00003684#if 0
3685 // FIXME: Temporarily disabled because we are not properly parsing
Mike Stump1eb44332009-09-09 15:08:12 +00003686 // linkage specifications on declarations, e.g.,
Douglas Gregor818ce482008-10-29 13:50:18 +00003687 //
3688 // extern "C" const CGPoint CGPointerZero;
3689 //
Douglas Gregor27c8dc02008-10-29 00:13:59 +00003690 // C++ [dcl.init]p9:
3691 //
3692 // If no initializer is specified for an object, and the
3693 // object is of (possibly cv-qualified) non-POD class type (or
3694 // array thereof), the object shall be default-initialized; if
3695 // the object is of const-qualified type, the underlying class
3696 // type shall have a user-declared default
3697 // constructor. Otherwise, if no initializer is specified for
3698 // an object, the object and its subobjects, if any, have an
3699 // indeterminate initial value; if the object or any of its
3700 // subobjects are of const-qualified type, the program is
3701 // ill-formed.
3702 //
3703 // This isn't technically an error in C, so we don't diagnose it.
3704 //
3705 // FIXME: Actually perform the POD/user-defined default
3706 // constructor check.
3707 if (getLangOptions().CPlusPlus &&
Douglas Gregor818ce482008-10-29 13:50:18 +00003708 Context.getCanonicalType(Type).isConstQualified() &&
Daniel Dunbar5466c7b2009-04-14 02:25:56 +00003709 !Var->hasExternalStorage())
Chris Lattnerf3a41af2008-11-20 06:38:18 +00003710 Diag(Var->getLocation(), diag::err_const_var_requires_init)
3711 << Var->getName()
3712 << SourceRange(Var->getLocation(), Var->getLocation());
Douglas Gregor818ce482008-10-29 13:50:18 +00003713#endif
Douglas Gregor27c8dc02008-10-29 00:13:59 +00003714 }
3715}
3716
Eli Friedmanc1dc6532009-05-29 01:49:24 +00003717Sema::DeclGroupPtrTy Sema::FinalizeDeclaratorGroup(Scope *S, const DeclSpec &DS,
3718 DeclPtrTy *Group,
Chris Lattner682bf922009-03-29 16:50:03 +00003719 unsigned NumDecls) {
3720 llvm::SmallVector<Decl*, 8> Decls;
Eli Friedmanc1dc6532009-05-29 01:49:24 +00003721
3722 if (DS.isTypeSpecOwned())
3723 Decls.push_back((Decl*)DS.getTypeRep());
3724
Chris Lattner682bf922009-03-29 16:50:03 +00003725 for (unsigned i = 0; i != NumDecls; ++i)
3726 if (Decl *D = Group[i].getAs<Decl>())
3727 Decls.push_back(D);
Mike Stump1eb44332009-09-09 15:08:12 +00003728
Steve Naroffbb204692007-09-12 14:07:44 +00003729 // Perform semantic analysis that depends on having fully processed both
3730 // the declarator and initializer.
Chris Lattner682bf922009-03-29 16:50:03 +00003731 for (unsigned i = 0, e = Decls.size(); i != e; ++i) {
3732 VarDecl *IDecl = dyn_cast<VarDecl>(Decls[i]);
Steve Naroffbb204692007-09-12 14:07:44 +00003733 if (!IDecl)
3734 continue;
Steve Naroffbb204692007-09-12 14:07:44 +00003735 QualType T = IDecl->getType();
Mike Stump1eb44332009-09-09 15:08:12 +00003736
Steve Naroffbb204692007-09-12 14:07:44 +00003737 // Block scope. C99 6.7p7: If an identifier for an object is declared with
3738 // no linkage (C99 6.2.2p6), the type for the object shall be complete...
Daniel Dunbar5466c7b2009-04-14 02:25:56 +00003739 if (IDecl->isBlockVarDecl() && !IDecl->hasExternalStorage()) {
Sebastian Redld75191f2009-10-17 19:37:06 +00003740 if (T->isDependentType()) {
3741 // If T is dependent, we should not require a complete type.
3742 // (RequireCompleteType shouldn't be called with dependent types.)
3743 // But we still can at least check if we've got an array of unspecified
3744 // size without an initializer.
3745 if (!IDecl->isInvalidDecl() && T->isIncompleteArrayType() &&
3746 !IDecl->getInit()) {
3747 Diag(IDecl->getLocation(), diag::err_typecheck_decl_incomplete_type)
3748 << T;
3749 IDecl->setInvalidDecl();
3750 }
3751 } else if (!IDecl->isInvalidDecl()) {
3752 // If T is an incomplete array type with an initializer list that is
3753 // dependent on something, its size has not been fixed. We could attempt
3754 // to fix the size for such arrays, but we would still have to check
3755 // here for initializers containing a C++0x vararg expansion, e.g.
3756 // template <typename... Args> void f(Args... args) {
3757 // int vals[] = { args };
3758 // }
Douglas Gregor89c49f02009-11-09 22:08:55 +00003759 const IncompleteArrayType *IAT = Context.getAsIncompleteArrayType(T);
Sebastian Redld75191f2009-10-17 19:37:06 +00003760 Expr *Init = IDecl->getInit();
3761 if (IAT && Init &&
3762 (Init->isTypeDependent() || Init->isValueDependent())) {
3763 // Check that the member type of the array is complete, at least.
3764 if (RequireCompleteType(IDecl->getLocation(), IAT->getElementType(),
3765 diag::err_typecheck_decl_incomplete_type))
3766 IDecl->setInvalidDecl();
3767 } else if (RequireCompleteType(IDecl->getLocation(), T,
3768 diag::err_typecheck_decl_incomplete_type))
3769 IDecl->setInvalidDecl();
3770 }
Steve Naroffbb204692007-09-12 14:07:44 +00003771 }
Douglas Gregorec8b59f2009-07-20 18:46:59 +00003772 // File scope. C99 6.9.2p2: A declaration of an identifier for an
Steve Naroffbb204692007-09-12 14:07:44 +00003773 // object that has file scope without an initializer, and without a
3774 // storage-class specifier or with the storage-class specifier "static",
3775 // constitutes a tentative definition. Note: A tentative definition with
3776 // external linkage is valid (C99 6.2.2p5).
Sebastian Redle9d12b62010-01-31 22:27:38 +00003777 if (IDecl->isThisDeclarationADefinition() == VarDecl::TentativeDefinition &&
3778 !IDecl->isInvalidDecl()) {
Douglas Gregorec8b59f2009-07-20 18:46:59 +00003779 if (const IncompleteArrayType *ArrayT
3780 = Context.getAsIncompleteArrayType(T)) {
3781 if (RequireCompleteType(IDecl->getLocation(),
3782 ArrayT->getElementType(),
3783 diag::err_illegal_decl_array_incomplete_type))
3784 IDecl->setInvalidDecl();
Mike Stumpac5fc7c2009-08-04 21:02:39 +00003785 } else if (IDecl->getStorageClass() == VarDecl::Static) {
Steve Naroff9a75f8a2008-01-18 20:40:52 +00003786 // C99 6.9.2p3: If the declaration of an identifier for an object is
Douglas Gregorec8b59f2009-07-20 18:46:59 +00003787 // a tentative definition and has internal linkage (C99 6.2.2p3), the
Steve Naroff9a75f8a2008-01-18 20:40:52 +00003788 // declared type shall not be an incomplete type.
Douglas Gregorec8b59f2009-07-20 18:46:59 +00003789 // NOTE: code such as the following
3790 // static struct s;
3791 // struct s { int a; };
3792 // is accepted by gcc. Hence here we issue a warning instead of
3793 // an error and we do not invalidate the static declaration.
3794 // NOTE: to avoid multiple warnings, only check the first declaration.
3795 if (IDecl->getPreviousDeclaration() == 0)
3796 RequireCompleteType(IDecl->getLocation(), T,
3797 diag::ext_typecheck_decl_incomplete_type);
Douglas Gregora03aca82009-03-10 21:58:27 +00003798 }
Steve Naroffbb204692007-09-12 14:07:44 +00003799 }
Reid Spencer5f016e22007-07-11 17:01:13 +00003800 }
Chris Lattner682bf922009-03-29 16:50:03 +00003801 return DeclGroupPtrTy::make(DeclGroupRef::Create(Context,
Jay Foadbeaaccd2009-05-21 09:52:38 +00003802 Decls.data(), Decls.size()));
Reid Spencer5f016e22007-07-11 17:01:13 +00003803}
Steve Naroffe1223f72007-08-28 03:03:08 +00003804
Chris Lattner682bf922009-03-29 16:50:03 +00003805
Chris Lattner04421082008-04-08 04:40:51 +00003806/// ActOnParamDeclarator - Called from Parser::ParseFunctionDeclarator()
3807/// to introduce parameters into function prototype scope.
Mike Stump1eb44332009-09-09 15:08:12 +00003808Sema::DeclPtrTy
Chris Lattner04421082008-04-08 04:40:51 +00003809Sema::ActOnParamDeclarator(Scope *S, Declarator &D) {
Chris Lattner985abd92008-06-26 06:49:43 +00003810 const DeclSpec &DS = D.getDeclSpec();
Douglas Gregor584049d2008-12-15 23:53:10 +00003811
Chris Lattner04421082008-04-08 04:40:51 +00003812 // Verify C99 6.7.5.3p2: The only SCS allowed is 'register'.
Daniel Dunbar33ad0122008-09-03 21:54:21 +00003813 VarDecl::StorageClass StorageClass = VarDecl::None;
3814 if (DS.getStorageClassSpec() == DeclSpec::SCS_register) {
3815 StorageClass = VarDecl::Register;
3816 } else if (DS.getStorageClassSpec() != DeclSpec::SCS_unspecified) {
Chris Lattner04421082008-04-08 04:40:51 +00003817 Diag(DS.getStorageClassSpecLoc(),
3818 diag::err_invalid_storage_class_in_func_decl);
Chris Lattner985abd92008-06-26 06:49:43 +00003819 D.getMutableDeclSpec().ClearStorageClassSpecs();
Chris Lattner04421082008-04-08 04:40:51 +00003820 }
Eli Friedman63054b32009-04-19 20:27:55 +00003821
3822 if (D.getDeclSpec().isThreadSpecified())
3823 Diag(D.getDeclSpec().getThreadSpecLoc(), diag::err_invalid_thread);
3824
Eli Friedman85a53192009-04-07 19:37:57 +00003825 DiagnoseFunctionSpecifiers(D);
3826
Douglas Gregor6d6eb572008-05-07 04:49:29 +00003827 // Check that there are no default arguments inside the type of this
3828 // parameter (C++ only).
3829 if (getLangOptions().CPlusPlus)
3830 CheckExtraCXXDefaultArguments(D);
Mike Stump1eb44332009-09-09 15:08:12 +00003831
John McCalla93c9342009-12-07 02:54:59 +00003832 TypeSourceInfo *TInfo = 0;
Douglas Gregor402abb52009-05-28 23:31:59 +00003833 TagDecl *OwnedDecl = 0;
John McCalla93c9342009-12-07 02:54:59 +00003834 QualType parmDeclType = GetTypeForDeclarator(D, S, &TInfo, &OwnedDecl);
Mike Stump1eb44332009-09-09 15:08:12 +00003835
Douglas Gregor402abb52009-05-28 23:31:59 +00003836 if (getLangOptions().CPlusPlus && OwnedDecl && OwnedDecl->isDefinition()) {
3837 // C++ [dcl.fct]p6:
3838 // Types shall not be defined in return or parameter types.
3839 Diag(OwnedDecl->getLocation(), diag::err_type_defined_in_param_type)
3840 << Context.getTypeDeclType(OwnedDecl);
3841 }
3842
Reid Spencer5f016e22007-07-11 17:01:13 +00003843 // TODO: CHECK FOR CONFLICTS, multiple decls with same name in one scope.
3844 // Can this happen for params? We already checked that they don't conflict
3845 // among each other. Here they can only shadow globals, which is ok.
Chris Lattner04421082008-04-08 04:40:51 +00003846 IdentifierInfo *II = D.getIdentifier();
Chris Lattnercf79b012009-01-21 02:38:50 +00003847 if (II) {
John McCallf36e02d2009-10-09 21:13:30 +00003848 if (NamedDecl *PrevDecl = LookupSingleName(S, II, LookupOrdinaryName)) {
Chris Lattnercf79b012009-01-21 02:38:50 +00003849 if (PrevDecl->isTemplateParameter()) {
3850 // Maybe we will complain about the shadowed template parameter.
3851 DiagnoseTemplateParameterShadow(D.getIdentifierLoc(), PrevDecl);
3852 // Just pretend that we didn't see the previous declaration.
3853 PrevDecl = 0;
Chris Lattnerb28317a2009-03-28 19:18:32 +00003854 } else if (S->isDeclScope(DeclPtrTy::make(PrevDecl))) {
Chris Lattnercf79b012009-01-21 02:38:50 +00003855 Diag(D.getIdentifierLoc(), diag::err_param_redefinition) << II;
Chris Lattner04421082008-04-08 04:40:51 +00003856
Chris Lattnercf79b012009-01-21 02:38:50 +00003857 // Recover by removing the name
3858 II = 0;
3859 D.SetIdentifier(0, D.getIdentifierLoc());
3860 }
Chris Lattner04421082008-04-08 04:40:51 +00003861 }
Reid Spencer5f016e22007-07-11 17:01:13 +00003862 }
Steve Naroff6a9f3e32007-08-07 22:44:21 +00003863
Anders Carlsson11f21a02009-03-23 19:10:31 +00003864 // Parameters can not be abstract class types.
Anders Carlsson8211eff2009-03-24 01:19:16 +00003865 // For record types, this is done by the AbstractClassUsageDiagnoser once
Mike Stump1eb44332009-09-09 15:08:12 +00003866 // the class has been completely parsed.
3867 if (!CurContext->isRecord() &&
3868 RequireNonAbstractType(D.getIdentifierLoc(), parmDeclType,
Anders Carlsson11f21a02009-03-23 19:10:31 +00003869 diag::err_abstract_type_in_decl,
Anders Carlsson8211eff2009-03-24 01:19:16 +00003870 AbstractParamType))
Anders Carlsson11f21a02009-03-23 19:10:31 +00003871 D.setInvalidType(true);
Douglas Gregor44b43212008-12-11 16:49:14 +00003872
Douglas Gregor2dc0e642009-03-23 23:06:20 +00003873 QualType T = adjustParameterType(parmDeclType);
Mike Stump1eb44332009-09-09 15:08:12 +00003874
John McCall7a9813c2010-01-22 00:28:27 +00003875 // Temporarily put parameter variables in the translation unit, not
3876 // the enclosing context. This prevents them from accidentally
3877 // looking like class members in C++.
3878 DeclContext *DC = Context.getTranslationUnitDecl();
3879
John McCall58e46772009-10-23 21:48:59 +00003880 ParmVarDecl *New
John McCall7a9813c2010-01-22 00:28:27 +00003881 = ParmVarDecl::Create(Context, DC, D.getIdentifierLoc(), II,
John McCalla93c9342009-12-07 02:54:59 +00003882 T, TInfo, StorageClass, 0);
Mike Stump1eb44332009-09-09 15:08:12 +00003883
Chris Lattnereaaebc72009-04-25 08:06:05 +00003884 if (D.isInvalidType())
Steve Naroff53a32342007-08-28 18:45:29 +00003885 New->setInvalidDecl();
Douglas Gregor44b43212008-12-11 16:49:14 +00003886
Steve Naroffccef3712009-02-20 22:59:16 +00003887 // Parameter declarators cannot be interface types. All ObjC objects are
3888 // passed by reference.
Douglas Gregor2dc0e642009-03-23 23:06:20 +00003889 if (T->isObjCInterfaceType()) {
Chris Lattner2dd979f2009-04-11 19:08:56 +00003890 Diag(D.getIdentifierLoc(),
3891 diag::err_object_cannot_be_passed_returned_by_value) << 1 << T;
Steve Naroffccef3712009-02-20 22:59:16 +00003892 New->setInvalidDecl();
3893 }
Mike Stump1eb44332009-09-09 15:08:12 +00003894
Chris Lattnerf97e8fa2009-04-11 19:34:56 +00003895 // Parameter declarators cannot be qualified (C++ [dcl.meaning]p1).
3896 if (D.getCXXScopeSpec().isSet()) {
3897 Diag(D.getIdentifierLoc(), diag::err_qualified_param_declarator)
3898 << D.getCXXScopeSpec().getRange();
3899 New->setInvalidDecl();
3900 }
Tanya Lattner27a84d02009-09-30 20:47:43 +00003901
3902 // ISO/IEC TR 18037 S6.7.3: "The type of an object with automatic storage
3903 // duration shall not be qualified by an address-space qualifier."
3904 // Since all parameters have automatic store duration, they can not have
3905 // an address space.
3906 if (T.getAddressSpace() != 0) {
3907 Diag(D.getIdentifierLoc(),
3908 diag::err_arg_with_address_space);
3909 New->setInvalidDecl();
3910 }
3911
3912
Douglas Gregor44b43212008-12-11 16:49:14 +00003913 // Add the parameter declaration into this scope.
Chris Lattnerb28317a2009-03-28 19:18:32 +00003914 S->AddDecl(DeclPtrTy::make(New));
Argyrios Kyrtzidis87f3ff02008-04-12 00:47:19 +00003915 if (II)
Douglas Gregor44b43212008-12-11 16:49:14 +00003916 IdResolver.AddDecl(New);
Nate Begemanb7894b52008-02-17 21:20:31 +00003917
Douglas Gregor9cdda0c2009-06-17 21:51:59 +00003918 ProcessDeclAttributes(S, New, D);
Mike Stumpea000bf2009-04-30 00:19:40 +00003919
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +00003920 if (New->hasAttr<BlocksAttr>()) {
Mike Stumpea000bf2009-04-30 00:19:40 +00003921 Diag(New->getLocation(), diag::err_block_on_nonlocal);
3922 }
Chris Lattnerb28317a2009-03-28 19:18:32 +00003923 return DeclPtrTy::make(New);
Reid Spencer5f016e22007-07-11 17:01:13 +00003924}
Fariborz Jahanian306d68f2007-11-08 23:49:49 +00003925
Douglas Gregora3a83512009-04-01 23:51:29 +00003926void Sema::ActOnFinishKNRParamDeclarations(Scope *S, Declarator &D,
3927 SourceLocation LocAfterDecls) {
Reid Spencer5f016e22007-07-11 17:01:13 +00003928 assert(D.getTypeObject(0).Kind == DeclaratorChunk::Function &&
3929 "Not a function declarator!");
3930 DeclaratorChunk::FunctionTypeInfo &FTI = D.getTypeObject(0).Fun;
Chris Lattner04421082008-04-08 04:40:51 +00003931
Reid Spencer5f016e22007-07-11 17:01:13 +00003932 // Verify 6.9.1p6: 'every identifier in the identifier list shall be declared'
3933 // for a K&R function.
3934 if (!FTI.hasPrototype) {
Douglas Gregor26103482009-04-02 03:14:12 +00003935 for (int i = FTI.NumArgs; i != 0; /* decrement in loop */) {
3936 --i;
Chris Lattner04421082008-04-08 04:40:51 +00003937 if (FTI.ArgInfo[i].Param == 0) {
Daniel Dunbar5ffe14c2009-10-18 20:26:27 +00003938 llvm::SmallString<256> Code;
3939 llvm::raw_svector_ostream(Code) << " int "
Daniel Dunbar01eb9b92009-10-18 21:17:35 +00003940 << FTI.ArgInfo[i].Ident->getName()
Daniel Dunbar5ffe14c2009-10-18 20:26:27 +00003941 << ";\n";
Chris Lattner3c73c412008-11-19 08:23:25 +00003942 Diag(FTI.ArgInfo[i].IdentLoc, diag::ext_param_not_declared)
Douglas Gregora3a83512009-04-01 23:51:29 +00003943 << FTI.ArgInfo[i].Ident
Daniel Dunbar5ffe14c2009-10-18 20:26:27 +00003944 << CodeModificationHint::CreateInsertion(LocAfterDecls, Code.str());
Douglas Gregora3a83512009-04-01 23:51:29 +00003945
Reid Spencer5f016e22007-07-11 17:01:13 +00003946 // Implicitly declare the argument as type 'int' for lack of a better
3947 // type.
Chris Lattner04421082008-04-08 04:40:51 +00003948 DeclSpec DS;
3949 const char* PrevSpec; // unused
John McCallfec54012009-08-03 20:12:06 +00003950 unsigned DiagID; // unused
Mike Stump1eb44332009-09-09 15:08:12 +00003951 DS.SetTypeSpecType(DeclSpec::TST_int, FTI.ArgInfo[i].IdentLoc,
John McCallfec54012009-08-03 20:12:06 +00003952 PrevSpec, DiagID);
Chris Lattner04421082008-04-08 04:40:51 +00003953 Declarator ParamD(DS, Declarator::KNRTypeListContext);
3954 ParamD.SetIdentifier(FTI.ArgInfo[i].Ident, FTI.ArgInfo[i].IdentLoc);
Douglas Gregorbe109b32009-01-23 16:23:13 +00003955 FTI.ArgInfo[i].Param = ActOnParamDeclarator(S, ParamD);
Reid Spencer5f016e22007-07-11 17:01:13 +00003956 }
3957 }
Mike Stump1eb44332009-09-09 15:08:12 +00003958 }
Douglas Gregorbe109b32009-01-23 16:23:13 +00003959}
3960
Chris Lattnerb28317a2009-03-28 19:18:32 +00003961Sema::DeclPtrTy Sema::ActOnStartOfFunctionDef(Scope *FnBodyScope,
3962 Declarator &D) {
Douglas Gregorbe109b32009-01-23 16:23:13 +00003963 assert(getCurFunctionDecl() == 0 && "Function parsing confused");
3964 assert(D.getTypeObject(0).Kind == DeclaratorChunk::Function &&
3965 "Not a function declarator!");
3966 DeclaratorChunk::FunctionTypeInfo &FTI = D.getTypeObject(0).Fun;
3967
3968 if (FTI.hasPrototype) {
Mike Stump1eb44332009-09-09 15:08:12 +00003969 // FIXME: Diagnose arguments without names in C.
Reid Spencer5f016e22007-07-11 17:01:13 +00003970 }
Mike Stump1eb44332009-09-09 15:08:12 +00003971
Douglas Gregor584049d2008-12-15 23:53:10 +00003972 Scope *ParentScope = FnBodyScope->getParent();
Steve Naroffadbbd0c2008-01-14 20:51:29 +00003973
Mike Stump1eb44332009-09-09 15:08:12 +00003974 DeclPtrTy DP = HandleDeclarator(ParentScope, D,
Douglas Gregore542c862009-06-23 23:11:28 +00003975 MultiTemplateParamsArg(*this),
3976 /*IsFunctionDefinition=*/true);
Chris Lattner682bf922009-03-29 16:50:03 +00003977 return ActOnStartOfFunctionDef(FnBodyScope, DP);
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +00003978}
3979
Anders Carlsson9f89dd72009-12-09 03:30:09 +00003980static bool ShouldWarnAboutMissingPrototype(const FunctionDecl *FD) {
3981 // Don't warn about invalid declarations.
3982 if (FD->isInvalidDecl())
3983 return false;
Anders Carlsson63fb6732009-12-09 03:44:46 +00003984
Anders Carlsson9f89dd72009-12-09 03:30:09 +00003985 // Or declarations that aren't global.
3986 if (!FD->isGlobal())
3987 return false;
Anders Carlsson63fb6732009-12-09 03:44:46 +00003988
Anders Carlsson9f89dd72009-12-09 03:30:09 +00003989 // Don't warn about C++ member functions.
3990 if (isa<CXXMethodDecl>(FD))
3991 return false;
Anders Carlsson63fb6732009-12-09 03:44:46 +00003992
Anders Carlsson9f89dd72009-12-09 03:30:09 +00003993 // Don't warn about 'main'.
3994 if (FD->isMain())
3995 return false;
Anders Carlsson63fb6732009-12-09 03:44:46 +00003996
Anders Carlsson9f89dd72009-12-09 03:30:09 +00003997 // Don't warn about inline functions.
3998 if (FD->isInlineSpecified())
3999 return false;
Anders Carlsson63fb6732009-12-09 03:44:46 +00004000
4001 // Don't warn about function templates.
4002 if (FD->getDescribedFunctionTemplate())
4003 return false;
4004
4005 // Don't warn about function template specializations.
4006 if (FD->isFunctionTemplateSpecialization())
4007 return false;
4008
Anders Carlsson9f89dd72009-12-09 03:30:09 +00004009 bool MissingPrototype = true;
4010 for (const FunctionDecl *Prev = FD->getPreviousDeclaration();
4011 Prev; Prev = Prev->getPreviousDeclaration()) {
4012 // Ignore any declarations that occur in function or method
4013 // scope, because they aren't visible from the header.
4014 if (Prev->getDeclContext()->isFunctionOrMethod())
4015 continue;
4016
4017 MissingPrototype = !Prev->getType()->isFunctionProtoType();
4018 break;
4019 }
4020
4021 return MissingPrototype;
4022}
4023
Chris Lattnerb28317a2009-03-28 19:18:32 +00004024Sema::DeclPtrTy Sema::ActOnStartOfFunctionDef(Scope *FnBodyScope, DeclPtrTy D) {
Anders Carlsson0ebb6d32009-10-29 15:46:07 +00004025 // Clear the last template instantiation error context.
4026 LastTemplateInstantiationErrorContext = ActiveTemplateInstantiation();
4027
Douglas Gregor52591bf2009-06-24 00:54:41 +00004028 if (!D)
4029 return D;
Douglas Gregord83d0402009-08-22 00:34:47 +00004030 FunctionDecl *FD = 0;
Mike Stump1eb44332009-09-09 15:08:12 +00004031
4032 if (FunctionTemplateDecl *FunTmpl
Douglas Gregord83d0402009-08-22 00:34:47 +00004033 = dyn_cast<FunctionTemplateDecl>(D.getAs<Decl>()))
4034 FD = FunTmpl->getTemplatedDecl();
4035 else
4036 FD = cast<FunctionDecl>(D.getAs<Decl>());
Douglas Gregor6fc17ff2008-10-29 15:10:40 +00004037
Chris Lattner38c5ebd2009-04-19 05:21:20 +00004038 CurFunctionNeedsScopeChecking = false;
Mike Stump1eb44332009-09-09 15:08:12 +00004039
Douglas Gregor6fc17ff2008-10-29 15:10:40 +00004040 // See if this is a redefinition.
4041 const FunctionDecl *Definition;
Argyrios Kyrtzidis6fb0aee2009-06-30 02:35:26 +00004042 if (FD->getBody(Definition)) {
Chris Lattner08631c52008-11-23 21:45:46 +00004043 Diag(FD->getLocation(), diag::err_redefinition) << FD->getDeclName();
Chris Lattner5f4a6822008-11-23 23:12:31 +00004044 Diag(Definition->getLocation(), diag::note_previous_definition);
Douglas Gregor6fc17ff2008-10-29 15:10:40 +00004045 }
4046
Douglas Gregorcda9c672009-02-16 17:45:42 +00004047 // Builtin functions cannot be defined.
Douglas Gregor7814e6d2009-09-12 00:22:50 +00004048 if (unsigned BuiltinID = FD->getBuiltinID()) {
Douglas Gregor655753a2009-02-17 16:03:01 +00004049 if (!Context.BuiltinInfo.isPredefinedLibFunction(BuiltinID)) {
Douglas Gregorcda9c672009-02-16 17:45:42 +00004050 Diag(FD->getLocation(), diag::err_builtin_definition) << FD;
Douglas Gregor655753a2009-02-17 16:03:01 +00004051 FD->setInvalidDecl();
4052 }
Douglas Gregorcda9c672009-02-16 17:45:42 +00004053 }
4054
Eli Friedman7f0f5dc2009-03-04 07:30:59 +00004055 // The return type of a function definition must be complete
Douglas Gregore7450f52009-03-24 19:52:54 +00004056 // (C99 6.9.1p3, C++ [dcl.fct]p6).
4057 QualType ResultType = FD->getResultType();
4058 if (!ResultType->isDependentType() && !ResultType->isVoidType() &&
Chris Lattner65e6a092009-04-29 05:12:23 +00004059 !FD->isInvalidDecl() &&
Douglas Gregore7450f52009-03-24 19:52:54 +00004060 RequireCompleteType(FD->getLocation(), ResultType,
4061 diag::err_func_def_incomplete_result))
Eli Friedman7f0f5dc2009-03-04 07:30:59 +00004062 FD->setInvalidDecl();
Eli Friedman7f0f5dc2009-03-04 07:30:59 +00004063
Douglas Gregor8499f3f2009-03-31 16:35:03 +00004064 // GNU warning -Wmissing-prototypes:
4065 // Warn if a global function is defined without a previous
4066 // prototype declaration. This warning is issued even if the
4067 // definition itself provides a prototype. The aim is to detect
4068 // global functions that fail to be declared in header files.
Anders Carlsson9f89dd72009-12-09 03:30:09 +00004069 if (ShouldWarnAboutMissingPrototype(FD))
4070 Diag(FD->getLocation(), diag::warn_missing_prototype) << FD;
Douglas Gregor8499f3f2009-03-31 16:35:03 +00004071
Douglas Gregore2c31ff2009-05-15 17:59:04 +00004072 if (FnBodyScope)
4073 PushDeclContext(FnBodyScope, FD);
Anton Korobeynikov2f402702008-12-26 00:52:02 +00004074
Chris Lattner04421082008-04-08 04:40:51 +00004075 // Check the validity of our function parameters
4076 CheckParmsForFunctionDef(FD);
4077
4078 // Introduce our parameters into the function scope
4079 for (unsigned p = 0, NumParams = FD->getNumParams(); p < NumParams; ++p) {
4080 ParmVarDecl *Param = FD->getParamDecl(p);
Douglas Gregora8cc8ce2009-01-09 18:51:29 +00004081 Param->setOwningFunction(FD);
4082
Chris Lattner04421082008-04-08 04:40:51 +00004083 // If this has an identifier, add it to the scope stack.
Douglas Gregore2c31ff2009-05-15 17:59:04 +00004084 if (Param->getIdentifier() && FnBodyScope)
Argyrios Kyrtzidis87f3ff02008-04-12 00:47:19 +00004085 PushOnScopeChains(Param, FnBodyScope);
Reid Spencer5f016e22007-07-11 17:01:13 +00004086 }
Chris Lattner04421082008-04-08 04:40:51 +00004087
Anton Korobeynikov2f402702008-12-26 00:52:02 +00004088 // Checking attributes of current function definition
4089 // dllimport attribute.
Mike Stump1eb44332009-09-09 15:08:12 +00004090 if (FD->getAttr<DLLImportAttr>() &&
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +00004091 (!FD->getAttr<DLLExportAttr>())) {
Anton Korobeynikov2f402702008-12-26 00:52:02 +00004092 // dllimport attribute cannot be applied to definition.
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +00004093 if (!(FD->getAttr<DLLImportAttr>())->isInherited()) {
Anton Korobeynikov2f402702008-12-26 00:52:02 +00004094 Diag(FD->getLocation(),
4095 diag::err_attribute_can_be_applied_only_to_symbol_declaration)
4096 << "dllimport";
4097 FD->setInvalidDecl();
Chris Lattnerb28317a2009-03-28 19:18:32 +00004098 return DeclPtrTy::make(FD);
Anton Korobeynikov2f402702008-12-26 00:52:02 +00004099 } else {
4100 // If a symbol previously declared dllimport is later defined, the
4101 // attribute is ignored in subsequent references, and a warning is
4102 // emitted.
4103 Diag(FD->getLocation(),
4104 diag::warn_redeclaration_without_attribute_prev_attribute_ignored)
4105 << FD->getNameAsCString() << "dllimport";
4106 }
4107 }
Chris Lattnerb28317a2009-03-28 19:18:32 +00004108 return DeclPtrTy::make(FD);
Reid Spencer5f016e22007-07-11 17:01:13 +00004109}
4110
Chris Lattnerb28317a2009-03-28 19:18:32 +00004111Sema::DeclPtrTy Sema::ActOnFinishFunctionBody(DeclPtrTy D, StmtArg BodyArg) {
Douglas Gregore2c31ff2009-05-15 17:59:04 +00004112 return ActOnFinishFunctionBody(D, move(BodyArg), false);
4113}
4114
4115Sema::DeclPtrTy Sema::ActOnFinishFunctionBody(DeclPtrTy D, StmtArg BodyArg,
4116 bool IsInstantiation) {
Chris Lattnerb28317a2009-03-28 19:18:32 +00004117 Decl *dcl = D.getAs<Decl>();
Sebastian Redld3a413d2009-04-26 20:35:05 +00004118 Stmt *Body = BodyArg.takeAs<Stmt>();
Douglas Gregord83d0402009-08-22 00:34:47 +00004119
Mike Stump4c45aa12010-01-21 15:20:48 +00004120 // Don't generate EH edges for CallExprs as we'd like to avoid the n^2
4121 // explosion for destrutors that can result and the compile time hit.
4122 AnalysisContext AC(dcl, false);
Douglas Gregord83d0402009-08-22 00:34:47 +00004123 FunctionDecl *FD = 0;
4124 FunctionTemplateDecl *FunTmpl = dyn_cast_or_null<FunctionTemplateDecl>(dcl);
4125 if (FunTmpl)
4126 FD = FunTmpl->getTemplatedDecl();
4127 else
4128 FD = dyn_cast_or_null<FunctionDecl>(dcl);
4129
4130 if (FD) {
Chris Lattnera5251fc2009-04-18 09:36:27 +00004131 FD->setBody(Body);
Douglas Gregor48a83b52009-09-12 00:17:51 +00004132 if (FD->isMain())
Mike Stump5f28a1e2009-07-24 02:49:01 +00004133 // C and C++ allow for main to automagically return 0.
John McCall0cfeb632009-07-28 01:00:58 +00004134 // Implements C++ [basic.start.main]p5 and C99 5.1.2.2.3.
4135 FD->setHasImplicitReturnZero(true);
4136 else
Mike Stumpfa6ef182010-01-13 02:59:54 +00004137 CheckFallThroughForFunctionDef(FD, Body, AC);
Mike Stump1eb44332009-09-09 15:08:12 +00004138
Douglas Gregore0762c92009-06-19 23:52:42 +00004139 if (!FD->isInvalidDecl())
4140 DiagnoseUnusedParameters(FD->param_begin(), FD->param_end());
Mike Stump1eb44332009-09-09 15:08:12 +00004141
Anders Carlssond6a637f2009-12-07 08:24:59 +00004142 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(FD))
4143 MaybeMarkVirtualMembersReferenced(Method->getLocation(), Method);
Mike Stump1eb44332009-09-09 15:08:12 +00004144
Argyrios Kyrtzidis53d0ea52008-06-28 06:07:14 +00004145 assert(FD == getCurFunctionDecl() && "Function parsing confused");
Steve Naroff394f3f42008-07-25 17:57:26 +00004146 } else if (ObjCMethodDecl *MD = dyn_cast_or_null<ObjCMethodDecl>(dcl)) {
Chris Lattnerffed1632009-02-16 19:27:54 +00004147 assert(MD == getCurMethodDecl() && "Method parsing confused");
Chris Lattnera5251fc2009-04-18 09:36:27 +00004148 MD->setBody(Body);
Mike Stumpfa6ef182010-01-13 02:59:54 +00004149 CheckFallThroughForFunctionDef(MD, Body, AC);
Argyrios Kyrtzidisa2e85ad2009-07-18 00:33:33 +00004150 MD->setEndLoc(Body->getLocEnd());
Mike Stump1eb44332009-09-09 15:08:12 +00004151
Douglas Gregore0762c92009-06-19 23:52:42 +00004152 if (!MD->isInvalidDecl())
4153 DiagnoseUnusedParameters(MD->param_begin(), MD->param_end());
Ted Kremenek8189cde2009-02-07 01:47:29 +00004154 } else {
4155 Body->Destroy(Context);
Chris Lattnerb28317a2009-03-28 19:18:32 +00004156 return DeclPtrTy();
Ted Kremenek8189cde2009-02-07 01:47:29 +00004157 }
Douglas Gregore2c31ff2009-05-15 17:59:04 +00004158 if (!IsInstantiation)
4159 PopDeclContext();
4160
Reid Spencer5f016e22007-07-11 17:01:13 +00004161 // Verify and clean out per-function state.
Eli Friedman8f17b662009-02-28 05:41:13 +00004162
Chris Lattner4f2aac32009-04-18 20:05:34 +00004163 assert(&getLabelMap() == &FunctionLabelMap && "Didn't pop block right?");
Mike Stump1eb44332009-09-09 15:08:12 +00004164
Reid Spencer5f016e22007-07-11 17:01:13 +00004165 // Check goto/label use.
Steve Naroffcaaacec2009-03-13 15:38:40 +00004166 for (llvm::DenseMap<IdentifierInfo*, LabelStmt*>::iterator
Chris Lattnerea29a3a2009-04-18 20:01:55 +00004167 I = FunctionLabelMap.begin(), E = FunctionLabelMap.end(); I != E; ++I) {
Chris Lattnere32f74c2009-04-18 19:30:02 +00004168 LabelStmt *L = I->second;
Mike Stump1eb44332009-09-09 15:08:12 +00004169
Reid Spencer5f016e22007-07-11 17:01:13 +00004170 // Verify that we have no forward references left. If so, there was a goto
4171 // or address of a label taken, but no definition of it. Label fwd
4172 // definitions are indicated with a null substmt.
Chris Lattnere32f74c2009-04-18 19:30:02 +00004173 if (L->getSubStmt() != 0)
4174 continue;
Mike Stump1eb44332009-09-09 15:08:12 +00004175
Chris Lattnere32f74c2009-04-18 19:30:02 +00004176 // Emit error.
4177 Diag(L->getIdentLoc(), diag::err_undeclared_label_use) << L->getName();
Mike Stump1eb44332009-09-09 15:08:12 +00004178
Chris Lattnere32f74c2009-04-18 19:30:02 +00004179 // At this point, we have gotos that use the bogus label. Stitch it into
4180 // the function body so that they aren't leaked and that the AST is well
4181 // formed.
4182 if (Body == 0) {
4183 // The whole function wasn't parsed correctly, just delete this.
4184 L->Destroy(Context);
4185 continue;
Reid Spencer5f016e22007-07-11 17:01:13 +00004186 }
Mike Stump1eb44332009-09-09 15:08:12 +00004187
Chris Lattnere32f74c2009-04-18 19:30:02 +00004188 // Otherwise, the body is valid: we want to stitch the label decl into the
4189 // function somewhere so that it is properly owned and so that the goto
4190 // has a valid target. Do this by creating a new compound stmt with the
4191 // label in it.
Sebastian Redld3a413d2009-04-26 20:35:05 +00004192
Chris Lattnere32f74c2009-04-18 19:30:02 +00004193 // Give the label a sub-statement.
4194 L->setSubStmt(new (Context) NullStmt(L->getIdentLoc()));
Sebastian Redld3a413d2009-04-26 20:35:05 +00004195
4196 CompoundStmt *Compound = isa<CXXTryStmt>(Body) ?
4197 cast<CXXTryStmt>(Body)->getTryBlock() :
4198 cast<CompoundStmt>(Body);
4199 std::vector<Stmt*> Elements(Compound->body_begin(), Compound->body_end());
Chris Lattnere32f74c2009-04-18 19:30:02 +00004200 Elements.push_back(L);
Sebastian Redld3a413d2009-04-26 20:35:05 +00004201 Compound->setStmts(Context, &Elements[0], Elements.size());
Reid Spencer5f016e22007-07-11 17:01:13 +00004202 }
Chris Lattnerea29a3a2009-04-18 20:01:55 +00004203 FunctionLabelMap.clear();
Eli Friedman8f17b662009-02-28 05:41:13 +00004204
4205 if (!Body) return D;
4206
Mike Stumpfa6ef182010-01-13 02:59:54 +00004207 CheckUnreachable(AC);
4208
Chris Lattnerb5659372009-04-18 21:00:42 +00004209 // Verify that that gotos and switch cases don't jump into scopes illegally.
Chris Lattner38c5ebd2009-04-19 05:21:20 +00004210 if (CurFunctionNeedsScopeChecking)
4211 DiagnoseInvalidJumps(Body);
Mike Stump1eb44332009-09-09 15:08:12 +00004212
4213 // C++ constructors that have function-try-blocks can't have return
4214 // statements in the handlers of that block. (C++ [except.handle]p14)
Fariborz Jahanian393612e2009-07-21 22:36:06 +00004215 // Verify this.
Douglas Gregord83d0402009-08-22 00:34:47 +00004216 if (FD && isa<CXXConstructorDecl>(FD) && isa<CXXTryStmt>(Body))
Sebastian Redl13e88542009-04-27 21:33:24 +00004217 DiagnoseReturnInConstructorExceptionHandler(cast<CXXTryStmt>(Body));
Mike Stump1eb44332009-09-09 15:08:12 +00004218
Fariborz Jahanian393612e2009-07-21 22:36:06 +00004219 if (CXXDestructorDecl *Destructor = dyn_cast<CXXDestructorDecl>(dcl))
Anders Carlsson9f853df2009-11-17 04:44:12 +00004220 MarkBaseAndMemberDestructorsReferenced(Destructor);
Anders Carlssonf8a9a792009-11-13 19:21:49 +00004221
Douglas Gregord5b57282009-11-15 07:07:58 +00004222 // If any errors have occurred, clear out any temporaries that may have
4223 // been leftover. This ensures that these temporaries won't be picked up for
4224 // deletion in some later function.
4225 if (PP.getDiagnostics().hasErrorOccurred())
4226 ExprTemporaries.clear();
4227
Anders Carlssonf8a9a792009-11-13 19:21:49 +00004228 assert(ExprTemporaries.empty() && "Leftover temporaries in function");
Steve Naroffd6d054d2007-11-11 23:20:51 +00004229 return D;
Fariborz Jahanian60fbca02007-11-10 16:31:34 +00004230}
4231
Reid Spencer5f016e22007-07-11 17:01:13 +00004232/// ImplicitlyDefineFunction - An undeclared identifier was used in a function
4233/// call, forming a call to an implicitly defined function (per C99 6.5.1p2).
Mike Stump1eb44332009-09-09 15:08:12 +00004234NamedDecl *Sema::ImplicitlyDefineFunction(SourceLocation Loc,
Douglas Gregor4afa39d2009-01-20 01:17:11 +00004235 IdentifierInfo &II, Scope *S) {
Douglas Gregor63935192009-03-02 00:19:53 +00004236 // Before we produce a declaration for an implicitly defined
4237 // function, see whether there was a locally-scoped declaration of
4238 // this name as a function or variable. If so, use that
4239 // (non-visible) declaration, and complain about it.
4240 llvm::DenseMap<DeclarationName, NamedDecl *>::iterator Pos
4241 = LocallyScopedExternalDecls.find(&II);
4242 if (Pos != LocallyScopedExternalDecls.end()) {
4243 Diag(Loc, diag::warn_use_out_of_scope_declaration) << Pos->second;
4244 Diag(Pos->second->getLocation(), diag::note_previous_declaration);
4245 return Pos->second;
4246 }
4247
Chris Lattner37d10842008-05-05 21:18:06 +00004248 // Extension in C99. Legal in C90, but warn about it.
Daniel Dunbar01eb9b92009-10-18 21:17:35 +00004249 if (II.getName().startswith("__builtin_"))
Douglas Gregor9a8c9a22009-09-28 21:14:19 +00004250 Diag(Loc, diag::warn_builtin_unknown) << &II;
4251 else if (getLangOptions().C99)
Chris Lattner3c73c412008-11-19 08:23:25 +00004252 Diag(Loc, diag::ext_implicit_function_decl) << &II;
Chris Lattner37d10842008-05-05 21:18:06 +00004253 else
Chris Lattner3c73c412008-11-19 08:23:25 +00004254 Diag(Loc, diag::warn_implicit_function_decl) << &II;
Mike Stump1eb44332009-09-09 15:08:12 +00004255
Reid Spencer5f016e22007-07-11 17:01:13 +00004256 // Set a Declarator for the implicit definition: int foo();
4257 const char *Dummy;
4258 DeclSpec DS;
John McCallfec54012009-08-03 20:12:06 +00004259 unsigned DiagID;
4260 bool Error = DS.SetTypeSpecType(DeclSpec::TST_int, Loc, Dummy, DiagID);
Reid Spencer5f016e22007-07-11 17:01:13 +00004261 Error = Error; // Silence warning.
4262 assert(!Error && "Error setting up implicit decl!");
4263 Declarator D(DS, Declarator::BlockContext);
Sebastian Redl7dc81342009-04-29 17:30:04 +00004264 D.AddTypeInfo(DeclaratorChunk::getFunction(false, false, SourceLocation(), 0,
Sebastian Redl3cc97262009-05-31 11:47:27 +00004265 0, 0, false, SourceLocation(),
Argyrios Kyrtzidis82bf0102009-08-19 23:14:54 +00004266 false, 0,0,0, Loc, Loc, D),
Sebastian Redlab197ba2009-02-09 18:23:29 +00004267 SourceLocation());
Reid Spencer5f016e22007-07-11 17:01:13 +00004268 D.SetIdentifier(&II, Loc);
Sebastian Redlab197ba2009-02-09 18:23:29 +00004269
Argyrios Kyrtzidis93213bb2008-05-01 21:04:16 +00004270 // Insert this function into translation-unit scope.
4271
4272 DeclContext *PrevDC = CurContext;
4273 CurContext = Context.getTranslationUnitDecl();
Mike Stump1eb44332009-09-09 15:08:12 +00004274
4275 FunctionDecl *FD =
Douglas Gregor2e01cda2009-06-23 21:43:56 +00004276 dyn_cast<FunctionDecl>(ActOnDeclarator(TUScope, D).getAs<Decl>());
Steve Naroffe2ef8152008-04-04 14:32:09 +00004277 FD->setImplicit();
Argyrios Kyrtzidis93213bb2008-05-01 21:04:16 +00004278
4279 CurContext = PrevDC;
4280
Douglas Gregor3c385e52009-02-14 18:57:46 +00004281 AddKnownFunctionAttributes(FD);
4282
Steve Naroffe2ef8152008-04-04 14:32:09 +00004283 return FD;
Reid Spencer5f016e22007-07-11 17:01:13 +00004284}
4285
Douglas Gregor3c385e52009-02-14 18:57:46 +00004286/// \brief Adds any function attributes that we know a priori based on
4287/// the declaration of this function.
4288///
4289/// These attributes can apply both to implicitly-declared builtins
4290/// (like __builtin___printf_chk) or to library-declared functions
4291/// like NSLog or printf.
4292void Sema::AddKnownFunctionAttributes(FunctionDecl *FD) {
4293 if (FD->isInvalidDecl())
4294 return;
4295
4296 // If this is a built-in function, map its builtin attributes to
4297 // actual attributes.
Douglas Gregor7814e6d2009-09-12 00:22:50 +00004298 if (unsigned BuiltinID = FD->getBuiltinID()) {
Douglas Gregor3c385e52009-02-14 18:57:46 +00004299 // Handle printf-formatting attributes.
4300 unsigned FormatIdx;
4301 bool HasVAListArg;
4302 if (Context.BuiltinInfo.isPrintfLike(BuiltinID, FormatIdx, HasVAListArg)) {
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +00004303 if (!FD->getAttr<FormatAttr>())
4304 FD->addAttr(::new (Context) FormatAttr("printf", FormatIdx + 1,
Eli Friedmand7dad722009-06-10 04:01:38 +00004305 HasVAListArg ? 0 : FormatIdx + 2));
Douglas Gregor3c385e52009-02-14 18:57:46 +00004306 }
Daniel Dunbaref2abfe2009-02-16 22:43:43 +00004307
4308 // Mark const if we don't care about errno and that is the only
4309 // thing preventing the function from being const. This allows
4310 // IRgen to use LLVM intrinsics for such functions.
4311 if (!getLangOptions().MathErrno &&
4312 Context.BuiltinInfo.isConstWithoutErrno(BuiltinID)) {
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +00004313 if (!FD->getAttr<ConstAttr>())
4314 FD->addAttr(::new (Context) ConstAttr());
Daniel Dunbaref2abfe2009-02-16 22:43:43 +00004315 }
Mike Stump0feecbb2009-07-27 19:14:18 +00004316
4317 if (Context.BuiltinInfo.isNoReturn(BuiltinID))
4318 FD->addAttr(::new (Context) NoReturnAttr());
Chris Lattner551f7082009-12-30 22:06:22 +00004319 if (Context.BuiltinInfo.isNoThrow(BuiltinID))
4320 FD->addAttr(::new (Context) NoThrowAttr());
4321 if (Context.BuiltinInfo.isConst(BuiltinID))
4322 FD->addAttr(::new (Context) ConstAttr());
Douglas Gregor3c385e52009-02-14 18:57:46 +00004323 }
4324
4325 IdentifierInfo *Name = FD->getIdentifier();
4326 if (!Name)
4327 return;
Mike Stump1eb44332009-09-09 15:08:12 +00004328 if ((!getLangOptions().CPlusPlus &&
Douglas Gregor3c385e52009-02-14 18:57:46 +00004329 FD->getDeclContext()->isTranslationUnit()) ||
4330 (isa<LinkageSpecDecl>(FD->getDeclContext()) &&
Mike Stump1eb44332009-09-09 15:08:12 +00004331 cast<LinkageSpecDecl>(FD->getDeclContext())->getLanguage() ==
Douglas Gregor3c385e52009-02-14 18:57:46 +00004332 LinkageSpecDecl::lang_c)) {
4333 // Okay: this could be a libc/libm/Objective-C function we know
4334 // about.
4335 } else
4336 return;
4337
Douglas Gregor21e072b2009-04-22 20:56:09 +00004338 if (Name->isStr("NSLog") || Name->isStr("NSLogv")) {
Mike Stump523a8fd2009-07-28 00:07:08 +00004339 // FIXME: NSLog and NSLogv should be target specific
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +00004340 if (const FormatAttr *Format = FD->getAttr<FormatAttr>()) {
Douglas Gregor3c385e52009-02-14 18:57:46 +00004341 // FIXME: We known better than our headers.
4342 const_cast<FormatAttr *>(Format)->setType("printf");
Mike Stump1eb44332009-09-09 15:08:12 +00004343 } else
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +00004344 FD->addAttr(::new (Context) FormatAttr("printf", 1,
Eli Friedmand7dad722009-06-10 04:01:38 +00004345 Name->isStr("NSLogv") ? 0 : 2));
Douglas Gregor21e072b2009-04-22 20:56:09 +00004346 } else if (Name->isStr("asprintf") || Name->isStr("vasprintf")) {
Mike Stump523a8fd2009-07-28 00:07:08 +00004347 // FIXME: asprintf and vasprintf aren't C99 functions. Should they be
Mike Stump1eb44332009-09-09 15:08:12 +00004348 // target-specific builtins, perhaps?
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +00004349 if (!FD->getAttr<FormatAttr>())
4350 FD->addAttr(::new (Context) FormatAttr("printf", 2,
Eli Friedmand7dad722009-06-10 04:01:38 +00004351 Name->isStr("vasprintf") ? 0 : 3));
Mike Stump782fa302009-07-28 02:25:19 +00004352 }
Douglas Gregor3c385e52009-02-14 18:57:46 +00004353}
Reid Spencer5f016e22007-07-11 17:01:13 +00004354
John McCallba6a9bd2009-10-24 08:00:42 +00004355TypedefDecl *Sema::ParseTypedefDecl(Scope *S, Declarator &D, QualType T,
John McCalla93c9342009-12-07 02:54:59 +00004356 TypeSourceInfo *TInfo) {
Reid Spencer5f016e22007-07-11 17:01:13 +00004357 assert(D.getIdentifier() && "Wrong callback for declspec without declarator");
Steve Naroff5912a352007-08-28 20:14:24 +00004358 assert(!T.isNull() && "GetTypeForDeclarator() returned null type");
Mike Stump1eb44332009-09-09 15:08:12 +00004359
John McCalla93c9342009-12-07 02:54:59 +00004360 if (!TInfo) {
John McCallba6a9bd2009-10-24 08:00:42 +00004361 assert(D.isInvalidType() && "no declarator info for valid type");
John McCalla93c9342009-12-07 02:54:59 +00004362 TInfo = Context.getTrivialTypeSourceInfo(T);
John McCallba6a9bd2009-10-24 08:00:42 +00004363 }
4364
Reid Spencer5f016e22007-07-11 17:01:13 +00004365 // Scope manipulation handled by caller.
Chris Lattner0ed844b2008-04-04 06:12:32 +00004366 TypedefDecl *NewTD = TypedefDecl::Create(Context, CurContext,
4367 D.getIdentifierLoc(),
Mike Stump1eb44332009-09-09 15:08:12 +00004368 D.getIdentifier(),
John McCalla93c9342009-12-07 02:54:59 +00004369 TInfo);
Mike Stump1eb44332009-09-09 15:08:12 +00004370
John McCall2191b202009-09-05 06:31:47 +00004371 if (const TagType *TT = T->getAs<TagType>()) {
Anders Carlsson4843e582009-03-10 17:07:44 +00004372 TagDecl *TD = TT->getDecl();
Mike Stump1eb44332009-09-09 15:08:12 +00004373
Anders Carlsson4843e582009-03-10 17:07:44 +00004374 // If the TagDecl that the TypedefDecl points to is an anonymous decl
4375 // keep track of the TypedefDecl.
4376 if (!TD->getIdentifier() && !TD->getTypedefForAnonDecl())
4377 TD->setTypedefForAnonDecl(NewTD);
4378 }
4379
Chris Lattnereaaebc72009-04-25 08:06:05 +00004380 if (D.isInvalidType())
Steve Naroff5912a352007-08-28 20:14:24 +00004381 NewTD->setInvalidDecl();
4382 return NewTD;
Reid Spencer5f016e22007-07-11 17:01:13 +00004383}
4384
Douglas Gregor501c5ce2009-05-14 16:41:31 +00004385
4386/// \brief Determine whether a tag with a given kind is acceptable
4387/// as a redeclaration of the given tag declaration.
4388///
4389/// \returns true if the new tag kind is acceptable, false otherwise.
Mike Stump1eb44332009-09-09 15:08:12 +00004390bool Sema::isAcceptableTagRedeclaration(const TagDecl *Previous,
Douglas Gregor501c5ce2009-05-14 16:41:31 +00004391 TagDecl::TagKind NewTag,
4392 SourceLocation NewTagLoc,
4393 const IdentifierInfo &Name) {
4394 // C++ [dcl.type.elab]p3:
4395 // The class-key or enum keyword present in the
4396 // elaborated-type-specifier shall agree in kind with the
4397 // declaration to which the name in theelaborated-type-specifier
4398 // refers. This rule also applies to the form of
4399 // elaborated-type-specifier that declares a class-name or
4400 // friend class since it can be construed as referring to the
4401 // definition of the class. Thus, in any
4402 // elaborated-type-specifier, the enum keyword shall be used to
4403 // refer to an enumeration (7.2), the union class-keyshall be
4404 // used to refer to a union (clause 9), and either the class or
4405 // struct class-key shall be used to refer to a class (clause 9)
4406 // declared using the class or struct class-key.
4407 TagDecl::TagKind OldTag = Previous->getTagKind();
4408 if (OldTag == NewTag)
4409 return true;
Mike Stump1eb44332009-09-09 15:08:12 +00004410
Douglas Gregor501c5ce2009-05-14 16:41:31 +00004411 if ((OldTag == TagDecl::TK_struct || OldTag == TagDecl::TK_class) &&
4412 (NewTag == TagDecl::TK_struct || NewTag == TagDecl::TK_class)) {
4413 // Warn about the struct/class tag mismatch.
4414 bool isTemplate = false;
4415 if (const CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(Previous))
4416 isTemplate = Record->getDescribedClassTemplate();
4417
4418 Diag(NewTagLoc, diag::warn_struct_class_tag_mismatch)
4419 << (NewTag == TagDecl::TK_class)
4420 << isTemplate << &Name
Douglas Gregor501c5ce2009-05-14 16:41:31 +00004421 << CodeModificationHint::CreateReplacement(SourceRange(NewTagLoc),
4422 OldTag == TagDecl::TK_class? "class" : "struct");
4423 Diag(Previous->getLocation(), diag::note_previous_use);
4424 return true;
4425 }
4426 return false;
4427}
4428
Steve Naroff08d92e42007-09-15 18:49:24 +00004429/// ActOnTag - This is invoked when we see 'struct foo' or 'struct {'. In the
Reid Spencer5f016e22007-07-11 17:01:13 +00004430/// former case, Name will be non-null. In the later case, Name will be null.
John McCall0f434ec2009-07-31 02:45:11 +00004431/// TagSpec indicates what kind of tag this is. TUK indicates whether this is a
Reid Spencer5f016e22007-07-11 17:01:13 +00004432/// reference/declaration/definition of a tag.
John McCall0f434ec2009-07-31 02:45:11 +00004433Sema::DeclPtrTy Sema::ActOnTag(Scope *S, unsigned TagSpec, TagUseKind TUK,
Chris Lattnerb28317a2009-03-28 19:18:32 +00004434 SourceLocation KWLoc, const CXXScopeSpec &SS,
4435 IdentifierInfo *Name, SourceLocation NameLoc,
Douglas Gregor402abb52009-05-28 23:31:59 +00004436 AttributeList *Attr, AccessSpecifier AS,
Douglas Gregor7cdbc582009-07-22 23:48:44 +00004437 MultiTemplateParamsArg TemplateParameterLists,
John McCallc4e70192009-09-11 04:59:25 +00004438 bool &OwnedDecl, bool &IsDependent) {
Douglas Gregor7df7b6b2008-12-15 16:32:14 +00004439 // If this is not a definition, it must have a name.
John McCall0f434ec2009-07-31 02:45:11 +00004440 assert((Name != 0 || TUK == TUK_Definition) &&
Reid Spencer5f016e22007-07-11 17:01:13 +00004441 "Nameless record must be a definition!");
Douglas Gregoraaba5e32009-02-04 19:02:06 +00004442
Douglas Gregor402abb52009-05-28 23:31:59 +00004443 OwnedDecl = false;
John McCallf1bbbb42009-09-04 01:14:41 +00004444 TagDecl::TagKind Kind = TagDecl::getTagKindForTypeSpec(TagSpec);
Mike Stump1eb44332009-09-09 15:08:12 +00004445
Douglas Gregor1fef4e62009-10-07 22:35:40 +00004446 // FIXME: Check explicit specializations more carefully.
4447 bool isExplicitSpecialization = false;
John McCall0f434ec2009-07-31 02:45:11 +00004448 if (TUK != TUK_Reference) {
Douglas Gregor7cdbc582009-07-22 23:48:44 +00004449 if (TemplateParameterList *TemplateParams
4450 = MatchTemplateParametersToScopeSpecifier(KWLoc, SS,
4451 (TemplateParameterList**)TemplateParameterLists.get(),
Douglas Gregor1fef4e62009-10-07 22:35:40 +00004452 TemplateParameterLists.size(),
4453 isExplicitSpecialization)) {
Douglas Gregord85bea22009-09-26 06:47:28 +00004454 if (TemplateParams->size() > 0) {
Douglas Gregor7cdbc582009-07-22 23:48:44 +00004455 // This is a declaration or definition of a class template (which may
4456 // be a member of another template).
4457 OwnedDecl = false;
John McCall0f434ec2009-07-31 02:45:11 +00004458 DeclResult Result = CheckClassTemplate(S, TagSpec, TUK, KWLoc,
Douglas Gregor7cdbc582009-07-22 23:48:44 +00004459 SS, Name, NameLoc, Attr,
Douglas Gregor05396e22009-08-25 17:23:04 +00004460 TemplateParams,
Douglas Gregor7cdbc582009-07-22 23:48:44 +00004461 AS);
Douglas Gregor05396e22009-08-25 17:23:04 +00004462 TemplateParameterLists.release();
Douglas Gregor7cdbc582009-07-22 23:48:44 +00004463 return Result.get();
4464 } else {
Douglas Gregorf6b11852009-10-08 15:14:33 +00004465 // The "template<>" header is extraneous.
4466 Diag(TemplateParams->getTemplateLoc(), diag::err_template_tag_noparams)
4467 << ElaboratedType::getNameForTagKind(Kind) << Name;
4468 isExplicitSpecialization = true;
Douglas Gregor7cdbc582009-07-22 23:48:44 +00004469 }
Mike Stump1eb44332009-09-09 15:08:12 +00004470 }
Douglas Gregorf6b11852009-10-08 15:14:33 +00004471
4472 TemplateParameterLists.release();
Mike Stump1eb44332009-09-09 15:08:12 +00004473 }
4474
Douglas Gregor4920f1f2009-01-12 22:49:06 +00004475 DeclContext *SearchDC = CurContext;
Argyrios Kyrtzidis0f84a232008-11-09 22:53:32 +00004476 DeclContext *DC = CurContext;
Douglas Gregor7adb10f2009-09-15 22:30:29 +00004477 bool isStdBadAlloc = false;
Douglas Gregor0b7a1582009-01-17 00:42:38 +00004478 bool Invalid = false;
4479
John McCall68263142009-11-18 22:49:29 +00004480 RedeclarationKind Redecl = (TUK != TUK_Reference ? ForRedeclaration
4481 : NotForRedeclaration);
4482
4483 LookupResult Previous(*this, Name, NameLoc, LookupTagName, Redecl);
John McCall6e247262009-10-10 05:48:19 +00004484
Argyrios Kyrtzidis630c81b2008-11-09 22:09:58 +00004485 if (Name && SS.isNotEmpty()) {
4486 // We have a nested-name tag ('struct foo::bar').
4487
4488 // Check for invalid 'foo::'.
Argyrios Kyrtzidis0f84a232008-11-09 22:53:32 +00004489 if (SS.isInvalid()) {
Argyrios Kyrtzidis630c81b2008-11-09 22:09:58 +00004490 Name = 0;
4491 goto CreateNewDecl;
4492 }
4493
John McCallc4e70192009-09-11 04:59:25 +00004494 // If this is a friend or a reference to a class in a dependent
4495 // context, don't try to make a decl for it.
4496 if (TUK == TUK_Friend || TUK == TUK_Reference) {
4497 DC = computeDeclContext(SS, false);
4498 if (!DC) {
4499 IsDependent = true;
4500 return DeclPtrTy();
4501 }
4502 }
4503
Douglas Gregor3f5b61c2009-05-14 00:28:11 +00004504 if (RequireCompleteDeclContext(SS))
4505 return DeclPtrTy::make((Decl *)0);
4506
Douglas Gregorf59a56e2009-07-21 23:53:31 +00004507 DC = computeDeclContext(SS, true);
Douglas Gregor1931b442009-02-03 00:34:39 +00004508 SearchDC = DC;
Argyrios Kyrtzidis0f84a232008-11-09 22:53:32 +00004509 // Look-up name inside 'foo::'.
John McCall68263142009-11-18 22:49:29 +00004510 LookupQualifiedName(Previous, DC);
John McCall6e247262009-10-10 05:48:19 +00004511
John McCall68263142009-11-18 22:49:29 +00004512 if (Previous.isAmbiguous())
John McCall6e247262009-10-10 05:48:19 +00004513 return DeclPtrTy();
John McCall6e247262009-10-10 05:48:19 +00004514
John McCall68263142009-11-18 22:49:29 +00004515 if (Previous.empty()) {
Douglas Gregor9edad9b2010-01-14 17:47:39 +00004516 // Name lookup did not find anything. However, if the
4517 // nested-name-specifier refers to the current instantiation,
4518 // and that current instantiation has any dependent base
4519 // classes, we might find something at instantiation time: treat
4520 // this as a dependent elaborated-type-specifier.
Douglas Gregor7d3f5762010-01-15 01:44:47 +00004521 if (Previous.wasNotFoundInCurrentInstantiation()) {
Douglas Gregor9edad9b2010-01-14 17:47:39 +00004522 IsDependent = true;
4523 return DeclPtrTy();
4524 }
4525
4526 // A tag 'foo::bar' must already exist.
Chris Lattner3c73c412008-11-19 08:23:25 +00004527 Diag(NameLoc, diag::err_not_tag_in_scope) << Name << SS.getRange();
Argyrios Kyrtzidis630c81b2008-11-09 22:09:58 +00004528 Name = 0;
Douglas Gregord0c87372009-05-27 17:30:49 +00004529 Invalid = true;
Argyrios Kyrtzidis630c81b2008-11-09 22:09:58 +00004530 goto CreateNewDecl;
4531 }
Chris Lattnercf79b012009-01-21 02:38:50 +00004532 } else if (Name) {
Argyrios Kyrtzidis630c81b2008-11-09 22:09:58 +00004533 // If this is a named struct, check to see if there was a previous forward
4534 // declaration or definition.
Douglas Gregor2a3009a2009-02-03 19:21:40 +00004535 // FIXME: We're looking into outer scopes here, even when we
4536 // shouldn't be. Doing so can result in ambiguities that we
4537 // shouldn't be diagnosing.
John McCall68263142009-11-18 22:49:29 +00004538 LookupName(Previous, S);
4539
4540 // Note: there used to be some attempt at recovery here.
4541 if (Previous.isAmbiguous())
4542 return DeclPtrTy();
Douglas Gregor72de6672009-01-08 20:45:30 +00004543
John McCall0f434ec2009-07-31 02:45:11 +00004544 if (!getLangOptions().CPlusPlus && TUK != TUK_Reference) {
Douglas Gregor72de6672009-01-08 20:45:30 +00004545 // FIXME: This makes sure that we ignore the contexts associated
4546 // with C structs, unions, and enums when looking for a matching
4547 // tag declaration or definition. See the similar lookup tweak
Douglas Gregor4c921ae2009-01-30 01:04:22 +00004548 // in Sema::LookupName; is there a better way to deal with this?
Douglas Gregor4920f1f2009-01-12 22:49:06 +00004549 while (isa<RecordDecl>(SearchDC) || isa<EnumDecl>(SearchDC))
4550 SearchDC = SearchDC->getParent();
Douglas Gregor72de6672009-01-08 20:45:30 +00004551 }
Argyrios Kyrtzidis630c81b2008-11-09 22:09:58 +00004552 }
4553
John McCall68263142009-11-18 22:49:29 +00004554 if (Previous.isSingleResult() &&
4555 Previous.getFoundDecl()->isTemplateParameter()) {
Douglas Gregor72c3f312008-12-05 18:15:24 +00004556 // Maybe we will complain about the shadowed template parameter.
John McCall68263142009-11-18 22:49:29 +00004557 DiagnoseTemplateParameterShadow(NameLoc, Previous.getFoundDecl());
Douglas Gregor72c3f312008-12-05 18:15:24 +00004558 // Just pretend that we didn't see the previous declaration.
John McCall68263142009-11-18 22:49:29 +00004559 Previous.clear();
Douglas Gregor72c3f312008-12-05 18:15:24 +00004560 }
4561
Douglas Gregor7adb10f2009-09-15 22:30:29 +00004562 if (getLangOptions().CPlusPlus && Name && DC && StdNamespace &&
4563 DC->Equals(StdNamespace) && Name->isStr("bad_alloc")) {
4564 // This is a declaration of or a reference to "std::bad_alloc".
4565 isStdBadAlloc = true;
4566
John McCall68263142009-11-18 22:49:29 +00004567 if (Previous.empty() && StdBadAlloc) {
Douglas Gregor7adb10f2009-09-15 22:30:29 +00004568 // std::bad_alloc has been implicitly declared (but made invisible to
4569 // name lookup). Fill in this implicit declaration as the previous
4570 // declaration, so that the declarations get chained appropriately.
John McCall68263142009-11-18 22:49:29 +00004571 Previous.addDecl(StdBadAlloc);
Douglas Gregor7adb10f2009-09-15 22:30:29 +00004572 }
4573 }
John McCall68263142009-11-18 22:49:29 +00004574
4575 if (!Previous.empty()) {
4576 assert(Previous.isSingleResult());
4577 NamedDecl *PrevDecl = Previous.getFoundDecl();
Argyrios Kyrtzidis2d1c5d32008-04-27 13:50:30 +00004578 if (TagDecl *PrevTagDecl = dyn_cast<TagDecl>(PrevDecl)) {
Chris Lattner14943b92008-07-03 03:30:58 +00004579 // If this is a use of a previous tag, or if the tag is already declared
4580 // in the same scope (so that the definition/declaration completes or
Argyrios Kyrtzidis2d1c5d32008-04-27 13:50:30 +00004581 // rementions the tag), reuse the decl.
John McCall67d1a672009-08-06 02:15:43 +00004582 if (TUK == TUK_Reference || TUK == TUK_Friend ||
4583 isDeclInScope(PrevDecl, SearchDC, S)) {
Chris Lattner14943b92008-07-03 03:30:58 +00004584 // Make sure that this wasn't declared as an enum and now used as a
4585 // struct or something similar.
Douglas Gregor501c5ce2009-05-14 16:41:31 +00004586 if (!isAcceptableTagRedeclaration(PrevTagDecl, Kind, KWLoc, *Name)) {
Mike Stump1eb44332009-09-09 15:08:12 +00004587 bool SafeToContinue
Douglas Gregora3a83512009-04-01 23:51:29 +00004588 = (PrevTagDecl->getTagKind() != TagDecl::TK_enum &&
4589 Kind != TagDecl::TK_enum);
4590 if (SafeToContinue)
Mike Stump1eb44332009-09-09 15:08:12 +00004591 Diag(KWLoc, diag::err_use_with_wrong_tag)
Douglas Gregora3a83512009-04-01 23:51:29 +00004592 << Name
4593 << CodeModificationHint::CreateReplacement(SourceRange(KWLoc),
4594 PrevTagDecl->getKindName());
4595 else
4596 Diag(KWLoc, diag::err_use_with_wrong_tag) << Name;
John McCall68263142009-11-18 22:49:29 +00004597 Diag(PrevTagDecl->getLocation(), diag::note_previous_use);
Douglas Gregora3a83512009-04-01 23:51:29 +00004598
Mike Stump1eb44332009-09-09 15:08:12 +00004599 if (SafeToContinue)
Douglas Gregora3a83512009-04-01 23:51:29 +00004600 Kind = PrevTagDecl->getTagKind();
4601 else {
4602 // Recover by making this an anonymous redefinition.
4603 Name = 0;
John McCall68263142009-11-18 22:49:29 +00004604 Previous.clear();
Douglas Gregora3a83512009-04-01 23:51:29 +00004605 Invalid = true;
4606 }
4607 }
4608
4609 if (!Invalid) {
Douglas Gregor7df7b6b2008-12-15 16:32:14 +00004610 // If this is a use, just return the declaration we found.
Chris Lattner14943b92008-07-03 03:30:58 +00004611
Douglas Gregor7df7b6b2008-12-15 16:32:14 +00004612 // FIXME: In the future, return a variant or some other clue
4613 // for the consumer of this Decl to know it doesn't own it.
4614 // For our current ASTs this shouldn't be a problem, but will
4615 // need to be changed with DeclGroups.
John McCalle3af0232009-10-07 23:34:25 +00004616 if (TUK == TUK_Reference || TUK == TUK_Friend)
John McCall68263142009-11-18 22:49:29 +00004617 return DeclPtrTy::make(PrevTagDecl);
Douglas Gregoraaba5e32009-02-04 19:02:06 +00004618
Douglas Gregor7df7b6b2008-12-15 16:32:14 +00004619 // Diagnose attempts to redefine a tag.
John McCall0f434ec2009-07-31 02:45:11 +00004620 if (TUK == TUK_Definition) {
Douglas Gregor7df7b6b2008-12-15 16:32:14 +00004621 if (TagDecl *Def = PrevTagDecl->getDefinition(Context)) {
Douglas Gregorb3ae4fc2009-10-12 20:18:28 +00004622 // If we're defining a specialization and the previous definition
4623 // is from an implicit instantiation, don't emit an error
4624 // here; we'll catch this in the general case below.
4625 if (!isExplicitSpecialization ||
4626 !isa<CXXRecordDecl>(Def) ||
4627 cast<CXXRecordDecl>(Def)->getTemplateSpecializationKind()
4628 == TSK_ExplicitSpecialization) {
4629 Diag(NameLoc, diag::err_redefinition) << Name;
4630 Diag(Def->getLocation(), diag::note_previous_definition);
4631 // If this is a redefinition, recover by making this
4632 // struct be anonymous, which will make any later
4633 // references get the previous definition.
4634 Name = 0;
John McCall68263142009-11-18 22:49:29 +00004635 Previous.clear();
Douglas Gregorb3ae4fc2009-10-12 20:18:28 +00004636 Invalid = true;
4637 }
Douglas Gregor0b7a1582009-01-17 00:42:38 +00004638 } else {
4639 // If the type is currently being defined, complain
4640 // about a nested redefinition.
4641 TagType *Tag = cast<TagType>(Context.getTagDeclType(PrevTagDecl));
4642 if (Tag->isBeingDefined()) {
4643 Diag(NameLoc, diag::err_nested_redefinition) << Name;
Mike Stump1eb44332009-09-09 15:08:12 +00004644 Diag(PrevTagDecl->getLocation(),
Douglas Gregor0b7a1582009-01-17 00:42:38 +00004645 diag::note_previous_definition);
4646 Name = 0;
John McCall68263142009-11-18 22:49:29 +00004647 Previous.clear();
Douglas Gregor0b7a1582009-01-17 00:42:38 +00004648 Invalid = true;
4649 }
Douglas Gregor7df7b6b2008-12-15 16:32:14 +00004650 }
Douglas Gregor0b7a1582009-01-17 00:42:38 +00004651
Douglas Gregor7df7b6b2008-12-15 16:32:14 +00004652 // Okay, this is definition of a previously declared or referenced
4653 // tag PrevDecl. We're going to create a new Decl for it.
Douglas Gregor0b7a1582009-01-17 00:42:38 +00004654 }
Argyrios Kyrtzidis2d1c5d32008-04-27 13:50:30 +00004655 }
Douglas Gregor7df7b6b2008-12-15 16:32:14 +00004656 // If we get here we have (another) forward declaration or we
John McCall67d1a672009-08-06 02:15:43 +00004657 // have a definition. Just create a new decl.
4658
Douglas Gregor7df7b6b2008-12-15 16:32:14 +00004659 } else {
4660 // If we get here, this is a definition of a new tag type in a nested
Mike Stump1eb44332009-09-09 15:08:12 +00004661 // scope, e.g. "struct foo; void bar() { struct foo; }", just create a
Douglas Gregor7df7b6b2008-12-15 16:32:14 +00004662 // new decl/type. We set PrevDecl to NULL so that the entities
4663 // have distinct types.
John McCall68263142009-11-18 22:49:29 +00004664 Previous.clear();
Reid Spencer5f016e22007-07-11 17:01:13 +00004665 }
Douglas Gregor7df7b6b2008-12-15 16:32:14 +00004666 // If we get here, we're going to create a new Decl. If PrevDecl
4667 // is non-NULL, it's a definition of the tag declared by
4668 // PrevDecl. If it's NULL, we have a new definition.
Argyrios Kyrtzidis2d1c5d32008-04-27 13:50:30 +00004669 } else {
Douglas Gregor66973122009-01-28 17:15:10 +00004670 // PrevDecl is a namespace, template, or anything else
4671 // that lives in the IDNS_Tag identifier namespace.
Douglas Gregor4920f1f2009-01-12 22:49:06 +00004672 if (isDeclInScope(PrevDecl, SearchDC, S)) {
Ted Kremeneka89d1972008-09-03 18:03:35 +00004673 // The tag name clashes with a namespace name, issue an error and
4674 // recover by making this tag be anonymous.
Chris Lattner3c73c412008-11-19 08:23:25 +00004675 Diag(NameLoc, diag::err_redefinition_different_kind) << Name;
Chris Lattner5f4a6822008-11-23 23:12:31 +00004676 Diag(PrevDecl->getLocation(), diag::note_previous_definition);
Argyrios Kyrtzidisb02ef242008-07-16 07:45:46 +00004677 Name = 0;
John McCall68263142009-11-18 22:49:29 +00004678 Previous.clear();
Douglas Gregor0b7a1582009-01-17 00:42:38 +00004679 Invalid = true;
Douglas Gregor7df7b6b2008-12-15 16:32:14 +00004680 } else {
4681 // The existing declaration isn't relevant to us; we're in a
4682 // new scope, so clear out the previous declaration.
John McCall68263142009-11-18 22:49:29 +00004683 Previous.clear();
Argyrios Kyrtzidisb02ef242008-07-16 07:45:46 +00004684 }
Reid Spencer5f016e22007-07-11 17:01:13 +00004685 }
John McCall50234372009-12-04 00:07:04 +00004686 } else if (TUK == TUK_Reference && SS.isEmpty() && Name) {
Douglas Gregor42af25f2009-05-11 19:58:34 +00004687 // C++ [basic.scope.pdecl]p5:
Mike Stump1eb44332009-09-09 15:08:12 +00004688 // -- for an elaborated-type-specifier of the form
Douglas Gregor3218c4b2009-01-09 22:42:13 +00004689 //
4690 // class-key identifier
4691 //
4692 // if the elaborated-type-specifier is used in the
4693 // decl-specifier-seq or parameter-declaration-clause of a
4694 // function defined in namespace scope, the identifier is
4695 // declared as a class-name in the namespace that contains
4696 // the declaration; otherwise, except as a friend
4697 // declaration, the identifier is declared in the smallest
4698 // non-class, non-function-prototype scope that contains the
4699 // declaration.
4700 //
4701 // C99 6.7.2.3p8 has a similar (but not identical!) provision for
4702 // C structs and unions.
Douglas Gregor80711a22009-03-06 18:34:03 +00004703 //
John McCall50234372009-12-04 00:07:04 +00004704 // It is an error in C++ to declare (rather than define) an enum
4705 // type, including via an elaborated type specifier. We'll
4706 // diagnose that later; for now, declare the enum in the same
4707 // scope as we would have picked for any other tag type.
4708 //
Douglas Gregor80711a22009-03-06 18:34:03 +00004709 // GNU C also supports this behavior as part of its incomplete
4710 // enum types extension, while GNU C++ does not.
4711 //
Douglas Gregor3218c4b2009-01-09 22:42:13 +00004712 // Find the context where we'll be declaring the tag.
Douglas Gregor4920f1f2009-01-12 22:49:06 +00004713 // FIXME: We would like to maintain the current DeclContext as the
Mike Stump1eb44332009-09-09 15:08:12 +00004714 // lexical context,
Douglas Gregor1931b442009-02-03 00:34:39 +00004715 while (SearchDC->isRecord())
4716 SearchDC = SearchDC->getParent();
Douglas Gregor3218c4b2009-01-09 22:42:13 +00004717
4718 // Find the scope where we'll be declaring the tag.
Mike Stump1eb44332009-09-09 15:08:12 +00004719 while (S->isClassScope() ||
Douglas Gregor3218c4b2009-01-09 22:42:13 +00004720 (getLangOptions().CPlusPlus && S->isFunctionPrototypeScope()) ||
Douglas Gregor1a0d31a2009-01-12 18:45:55 +00004721 ((S->getFlags() & Scope::DeclScope) == 0) ||
Mike Stump1eb44332009-09-09 15:08:12 +00004722 (S->getEntity() &&
Douglas Gregor1a0d31a2009-01-12 18:45:55 +00004723 ((DeclContext *)S->getEntity())->isTransparentContext()))
Douglas Gregor3218c4b2009-01-09 22:42:13 +00004724 S = S->getParent();
John McCall67d1a672009-08-06 02:15:43 +00004725
4726 } else if (TUK == TUK_Friend && SS.isEmpty() && Name) {
4727 // C++ [namespace.memdef]p3:
4728 // If a friend declaration in a non-local class first declares a
4729 // class or function, the friend class or function is a member of
4730 // the innermost enclosing namespace.
John McCall3f9a8a62009-08-11 06:59:38 +00004731 while (!SearchDC->isFileContext())
John McCall67d1a672009-08-06 02:15:43 +00004732 SearchDC = SearchDC->getParent();
4733
4734 // The entity of a decl scope is a DeclContext; see PushDeclContext.
4735 while (S->getEntity() != SearchDC)
4736 S = S->getParent();
Reid Spencer5f016e22007-07-11 17:01:13 +00004737 }
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +00004738
Chris Lattnercc98eac2008-12-17 07:13:27 +00004739CreateNewDecl:
Mike Stump1eb44332009-09-09 15:08:12 +00004740
John McCall68263142009-11-18 22:49:29 +00004741 TagDecl *PrevDecl = 0;
4742 if (Previous.isSingleResult())
4743 PrevDecl = cast<TagDecl>(Previous.getFoundDecl());
4744
Reid Spencer5f016e22007-07-11 17:01:13 +00004745 // If there is an identifier, use the location of the identifier as the
4746 // location of the decl, otherwise use the location of the struct/union
4747 // keyword.
4748 SourceLocation Loc = NameLoc.isValid() ? NameLoc : KWLoc;
Mike Stump1eb44332009-09-09 15:08:12 +00004749
Douglas Gregor7df7b6b2008-12-15 16:32:14 +00004750 // Otherwise, create a new declaration. If there is a previous
4751 // declaration of the same entity, the two will be linked via
4752 // PrevDecl.
Reid Spencer5f016e22007-07-11 17:01:13 +00004753 TagDecl *New;
Douglas Gregorbcbffc42009-01-07 00:43:41 +00004754
Argyrios Kyrtzidis39ba4ae2008-06-09 23:19:58 +00004755 if (Kind == TagDecl::TK_enum) {
Reid Spencer5f016e22007-07-11 17:01:13 +00004756 // FIXME: Tag decls should be chained to any simultaneous vardecls, e.g.:
4757 // enum X { A, B, C } D; D should chain to X.
Douglas Gregor741dd9a2009-07-21 14:46:17 +00004758 New = EnumDecl::Create(Context, SearchDC, Loc, Name, KWLoc,
Douglas Gregor7df7b6b2008-12-15 16:32:14 +00004759 cast_or_null<EnumDecl>(PrevDecl));
Reid Spencer5f016e22007-07-11 17:01:13 +00004760 // If this is an undefined enum, warn.
John McCall0f434ec2009-07-31 02:45:11 +00004761 if (TUK != TUK_Definition && !Invalid) {
Douglas Gregor80711a22009-03-06 18:34:03 +00004762 unsigned DK = getLangOptions().CPlusPlus? diag::err_forward_ref_enum
4763 : diag::ext_forward_ref_enum;
4764 Diag(Loc, DK);
4765 }
Argyrios Kyrtzidis39ba4ae2008-06-09 23:19:58 +00004766 } else {
4767 // struct/union/class
4768
Reid Spencer5f016e22007-07-11 17:01:13 +00004769 // FIXME: Tag decls should be chained to any simultaneous vardecls, e.g.:
4770 // struct X { int A; } D; D should chain to X.
Douglas Gregor7adb10f2009-09-15 22:30:29 +00004771 if (getLangOptions().CPlusPlus) {
Ted Kremenek2b345eb2008-09-05 17:39:33 +00004772 // FIXME: Look for a way to use RecordDecl for simple structs.
Douglas Gregor741dd9a2009-07-21 14:46:17 +00004773 New = CXXRecordDecl::Create(Context, Kind, SearchDC, Loc, Name, KWLoc,
Douglas Gregor7df7b6b2008-12-15 16:32:14 +00004774 cast_or_null<CXXRecordDecl>(PrevDecl));
Douglas Gregor7adb10f2009-09-15 22:30:29 +00004775
4776 if (isStdBadAlloc && (!StdBadAlloc || StdBadAlloc->isImplicit()))
4777 StdBadAlloc = cast<CXXRecordDecl>(New);
4778 } else
Douglas Gregor741dd9a2009-07-21 14:46:17 +00004779 New = RecordDecl::Create(Context, Kind, SearchDC, Loc, Name, KWLoc,
Douglas Gregor7df7b6b2008-12-15 16:32:14 +00004780 cast_or_null<RecordDecl>(PrevDecl));
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +00004781 }
Douglas Gregor7df7b6b2008-12-15 16:32:14 +00004782
4783 if (Kind != TagDecl::TK_enum) {
4784 // Handle #pragma pack: if the #pragma pack stack has non-default
4785 // alignment, make up a packed attribute for this decl. These
4786 // attributes are checked when the ASTContext lays out the
4787 // structure.
4788 //
4789 // It is important for implementing the correct semantics that this
4790 // happen here (in act on tag decl). The #pragma pack stack is
4791 // maintained as a result of parser callbacks which can occur at
4792 // many points during the parsing of a struct declaration (because
4793 // the #pragma tokens are effectively skipped over during the
4794 // parsing of the struct).
Chris Lattner574aa402009-02-17 01:09:29 +00004795 if (unsigned Alignment = getPragmaPackAlignment())
Anders Carlssona860e752009-08-08 18:23:56 +00004796 New->addAttr(::new (Context) PragmaPackAttr(Alignment * 8));
Douglas Gregor7df7b6b2008-12-15 16:32:14 +00004797 }
4798
Douglas Gregor66973122009-01-28 17:15:10 +00004799 if (getLangOptions().CPlusPlus && SS.isEmpty() && Name && !Invalid) {
4800 // C++ [dcl.typedef]p3:
4801 // [...] Similarly, in a given scope, a class or enumeration
4802 // shall not be declared with the same name as a typedef-name
4803 // that is declared in that scope and refers to a type other
4804 // than the class or enumeration itself.
John McCalla24dc2e2009-11-17 02:14:36 +00004805 LookupResult Lookup(*this, Name, NameLoc, LookupOrdinaryName,
John McCall7d384dd2009-11-18 07:57:50 +00004806 ForRedeclaration);
John McCalla24dc2e2009-11-17 02:14:36 +00004807 LookupName(Lookup, S);
John McCall1bcee0a2009-12-02 08:25:40 +00004808 TypedefDecl *PrevTypedef = Lookup.getAsSingle<TypedefDecl>();
Douglas Gregor2531c2d2009-09-28 00:47:05 +00004809 NamedDecl *PrevTypedefNamed = PrevTypedef;
4810 if (PrevTypedef && isDeclInScope(PrevTypedefNamed, SearchDC, S) &&
Douglas Gregor66973122009-01-28 17:15:10 +00004811 Context.getCanonicalType(Context.getTypeDeclType(PrevTypedef)) !=
4812 Context.getCanonicalType(Context.getTypeDeclType(New))) {
4813 Diag(Loc, diag::err_tag_definition_of_typedef)
4814 << Context.getTypeDeclType(New)
4815 << PrevTypedef->getUnderlyingType();
4816 Diag(PrevTypedef->getLocation(), diag::note_previous_definition);
4817 Invalid = true;
4818 }
4819 }
4820
Douglas Gregorf6b11852009-10-08 15:14:33 +00004821 // If this is a specialization of a member class (of a class template),
4822 // check the specialization.
John McCall68263142009-11-18 22:49:29 +00004823 if (isExplicitSpecialization && CheckMemberSpecialization(New, Previous))
Douglas Gregorf6b11852009-10-08 15:14:33 +00004824 Invalid = true;
4825
Douglas Gregor0b7a1582009-01-17 00:42:38 +00004826 if (Invalid)
4827 New->setInvalidDecl();
4828
Douglas Gregor7df7b6b2008-12-15 16:32:14 +00004829 if (Attr)
Douglas Gregor9cdda0c2009-06-17 21:51:59 +00004830 ProcessDeclAttributeList(S, New, Attr);
Douglas Gregor7df7b6b2008-12-15 16:32:14 +00004831
Douglas Gregor0b7a1582009-01-17 00:42:38 +00004832 // If we're declaring or defining a tag in function prototype scope
4833 // in C, note that this type can only be used within the function.
Douglas Gregor3218c4b2009-01-09 22:42:13 +00004834 if (Name && S->isFunctionPrototypeScope() && !getLangOptions().CPlusPlus)
4835 Diag(Loc, diag::warn_decl_in_param_list) << Context.getTagDeclType(New);
4836
Douglas Gregor7df7b6b2008-12-15 16:32:14 +00004837 // Set the lexical context. If the tag has a C++ scope specifier, the
4838 // lexical context will be different from the semantic context.
Douglas Gregor1931b442009-02-03 00:34:39 +00004839 New->setLexicalDeclContext(CurContext);
Douglas Gregor0b7a1582009-01-17 00:42:38 +00004840
John McCall02cace72009-08-28 07:59:38 +00004841 // Mark this as a friend decl if applicable.
4842 if (TUK == TUK_Friend)
John McCall68263142009-11-18 22:49:29 +00004843 New->setObjectOfFriendDecl(/* PreviouslyDeclared = */ !Previous.empty());
John McCall02cace72009-08-28 07:59:38 +00004844
Anders Carlsson0cf88302009-03-26 01:19:02 +00004845 // Set the access specifier.
Eli Friedman56bea432009-08-27 18:44:04 +00004846 if (!Invalid && TUK != TUK_Friend)
Douglas Gregord0c87372009-05-27 17:30:49 +00004847 SetMemberAccessSpecifier(New, PrevDecl, AS);
Douglas Gregor06c0fec2009-03-25 22:00:53 +00004848
John McCall0f434ec2009-07-31 02:45:11 +00004849 if (TUK == TUK_Definition)
Douglas Gregor0b7a1582009-01-17 00:42:38 +00004850 New->startDefinition();
Mike Stump1eb44332009-09-09 15:08:12 +00004851
Reid Spencer5f016e22007-07-11 17:01:13 +00004852 // If this has an identifier, add it to the scope stack.
John McCalld7eff682009-09-02 00:55:30 +00004853 if (TUK == TUK_Friend) {
John McCall82b9fb82009-09-02 19:32:14 +00004854 // We might be replacing an existing declaration in the lookup tables;
4855 // if so, borrow its access specifier.
4856 if (PrevDecl)
4857 New->setAccess(PrevDecl->getAccess());
4858
John McCalld7eff682009-09-02 00:55:30 +00004859 // Friend tag decls are visible in fairly strange ways.
4860 if (!CurContext->isDependentContext()) {
4861 DeclContext *DC = New->getDeclContext()->getLookupContext();
4862 DC->makeDeclVisibleInContext(New, /* Recoverable = */ false);
4863 if (Scope *EnclosingScope = getScopeForDeclContext(S, DC))
4864 PushOnScopeChains(New, EnclosingScope, /* AddToContext = */ false);
4865 }
4866 } else if (Name) {
Douglas Gregor1a0d31a2009-01-12 18:45:55 +00004867 S = getNonFieldDeclScope(S);
Douglas Gregor1931b442009-02-03 00:34:39 +00004868 PushOnScopeChains(New, S);
Douglas Gregor4920f1f2009-01-12 22:49:06 +00004869 } else {
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00004870 CurContext->addDecl(New);
Reid Spencer5f016e22007-07-11 17:01:13 +00004871 }
Argyrios Kyrtzidis52393042008-11-09 23:41:00 +00004872
Douglas Gregorc29f77b2009-07-07 16:35:42 +00004873 // If this is the C FILE type, notify the AST context.
4874 if (IdentifierInfo *II = New->getIdentifier())
4875 if (!New->isInvalidDecl() &&
Mike Stump782fa302009-07-28 02:25:19 +00004876 New->getDeclContext()->getLookupContext()->isTranslationUnit() &&
Douglas Gregorc29f77b2009-07-07 16:35:42 +00004877 II->isStr("FILE"))
4878 Context.setFILEDecl(New);
Mike Stump1eb44332009-09-09 15:08:12 +00004879
Douglas Gregor402abb52009-05-28 23:31:59 +00004880 OwnedDecl = true;
Chris Lattnerb28317a2009-03-28 19:18:32 +00004881 return DeclPtrTy::make(New);
Reid Spencer5f016e22007-07-11 17:01:13 +00004882}
4883
Chris Lattnerb28317a2009-03-28 19:18:32 +00004884void Sema::ActOnTagStartDefinition(Scope *S, DeclPtrTy TagD) {
Douglas Gregoraaba5e32009-02-04 19:02:06 +00004885 AdjustDeclIfTemplate(TagD);
Chris Lattnerb28317a2009-03-28 19:18:32 +00004886 TagDecl *Tag = cast<TagDecl>(TagD.getAs<Decl>());
Douglas Gregor72de6672009-01-08 20:45:30 +00004887
4888 // Enter the tag context.
4889 PushDeclContext(S, Tag);
John McCallf9368152009-12-20 07:58:13 +00004890}
Douglas Gregor72de6672009-01-08 20:45:30 +00004891
John McCallf9368152009-12-20 07:58:13 +00004892void Sema::ActOnStartCXXMemberDeclarations(Scope *S, DeclPtrTy TagD,
4893 SourceLocation LBraceLoc) {
4894 AdjustDeclIfTemplate(TagD);
4895 CXXRecordDecl *Record = cast<CXXRecordDecl>(TagD.getAs<Decl>());
Douglas Gregor72de6672009-01-08 20:45:30 +00004896
John McCallf9368152009-12-20 07:58:13 +00004897 FieldCollector->StartClass();
4898
4899 if (!Record->getIdentifier())
4900 return;
4901
4902 // C++ [class]p2:
4903 // [...] The class-name is also inserted into the scope of the
4904 // class itself; this is known as the injected-class-name. For
4905 // purposes of access checking, the injected-class-name is treated
4906 // as if it were a public member name.
4907 CXXRecordDecl *InjectedClassName
4908 = CXXRecordDecl::Create(Context, Record->getTagKind(),
4909 CurContext, Record->getLocation(),
4910 Record->getIdentifier(),
4911 Record->getTagKeywordLoc(),
4912 Record);
4913 InjectedClassName->setImplicit();
4914 InjectedClassName->setAccess(AS_public);
4915 if (ClassTemplateDecl *Template = Record->getDescribedClassTemplate())
4916 InjectedClassName->setDescribedClassTemplate(Template);
4917 PushOnScopeChains(InjectedClassName, S);
4918 assert(InjectedClassName->isInjectedClassName() &&
4919 "Broken injected-class-name");
Douglas Gregor72de6672009-01-08 20:45:30 +00004920}
4921
Douglas Gregoradda8462010-01-06 17:00:51 +00004922// Traverses the class and any nested classes, making a note of any
4923// dynamic classes that have no key function so that we can mark all of
4924// their virtual member functions as "used" at the end of the translation
4925// unit. This ensures that all functions needed by the vtable will get
4926// instantiated/synthesized.
4927static void
4928RecordDynamicClassesWithNoKeyFunction(Sema &S, CXXRecordDecl *Record,
4929 SourceLocation Loc) {
4930 // We don't look at dependent or undefined classes.
4931 if (Record->isDependentContext() || !Record->isDefinition())
4932 return;
4933
4934 if (Record->isDynamicClass() && !S.Context.getKeyFunction(Record))
4935 S.ClassesWithUnmarkedVirtualMembers.push_back(std::make_pair(Record, Loc));
4936
4937 for (DeclContext::decl_iterator D = Record->decls_begin(),
4938 DEnd = Record->decls_end();
4939 D != DEnd; ++D) {
4940 if (CXXRecordDecl *Nested = dyn_cast<CXXRecordDecl>(*D))
4941 RecordDynamicClassesWithNoKeyFunction(S, Nested, Loc);
4942 }
4943}
4944
Argyrios Kyrtzidis07a5b282009-07-14 03:17:52 +00004945void Sema::ActOnTagFinishDefinition(Scope *S, DeclPtrTy TagD,
4946 SourceLocation RBraceLoc) {
Douglas Gregoraaba5e32009-02-04 19:02:06 +00004947 AdjustDeclIfTemplate(TagD);
Chris Lattnerb28317a2009-03-28 19:18:32 +00004948 TagDecl *Tag = cast<TagDecl>(TagD.getAs<Decl>());
Argyrios Kyrtzidis07a5b282009-07-14 03:17:52 +00004949 Tag->setRBraceLoc(RBraceLoc);
Douglas Gregor72de6672009-01-08 20:45:30 +00004950
4951 if (isa<CXXRecordDecl>(Tag))
4952 FieldCollector->FinishClass();
4953
4954 // Exit this scope of this tag's definition.
4955 PopDeclContext();
4956
Douglas Gregoradda8462010-01-06 17:00:51 +00004957 if (isa<CXXRecordDecl>(Tag) && !Tag->getDeclContext()->isRecord())
4958 RecordDynamicClassesWithNoKeyFunction(*this, cast<CXXRecordDecl>(Tag),
4959 RBraceLoc);
4960
Douglas Gregor72de6672009-01-08 20:45:30 +00004961 // Notify the consumer that we've defined a tag.
4962 Consumer.HandleTagDeclDefinition(Tag);
4963}
Chris Lattner5a6ddbf2008-06-21 19:39:06 +00004964
Chris Lattnerdf9bcd52009-04-20 17:29:38 +00004965// Note that FieldName may be null for anonymous bitfields.
Mike Stump1eb44332009-09-09 15:08:12 +00004966bool Sema::VerifyBitField(SourceLocation FieldLoc, IdentifierInfo *FieldName,
Eli Friedman1d954f62009-08-15 21:55:26 +00004967 QualType FieldTy, const Expr *BitWidth,
4968 bool *ZeroWidth) {
4969 // Default to true; that shouldn't confuse checks for emptiness
4970 if (ZeroWidth)
4971 *ZeroWidth = true;
4972
Chris Lattner24793662009-03-05 22:45:59 +00004973 // C99 6.7.2.1p4 - verify the field type.
Chris Lattner8b963ef2009-03-05 23:01:03 +00004974 // C++ 9.6p3: A bit-field shall have integral or enumeration type.
Douglas Gregor3cf538d2009-03-11 18:59:21 +00004975 if (!FieldTy->isDependentType() && !FieldTy->isIntegralType()) {
Chris Lattner24793662009-03-05 22:45:59 +00004976 // Handle incomplete types with specific error.
Douglas Gregora03aca82009-03-10 21:58:27 +00004977 if (RequireCompleteType(FieldLoc, FieldTy, diag::err_field_incomplete))
4978 return true;
Chris Lattnerdf9bcd52009-04-20 17:29:38 +00004979 if (FieldName)
4980 return Diag(FieldLoc, diag::err_not_integral_type_bitfield)
4981 << FieldName << FieldTy << BitWidth->getSourceRange();
4982 return Diag(FieldLoc, diag::err_not_integral_type_anon_bitfield)
4983 << FieldTy << BitWidth->getSourceRange();
Chris Lattner24793662009-03-05 22:45:59 +00004984 }
Douglas Gregor3cf538d2009-03-11 18:59:21 +00004985
4986 // If the bit-width is type- or value-dependent, don't try to check
4987 // it now.
4988 if (BitWidth->isValueDependent() || BitWidth->isTypeDependent())
4989 return false;
4990
Anders Carlsson9f1e5722008-12-06 20:33:04 +00004991 llvm::APSInt Value;
4992 if (VerifyIntegerConstantExpression(BitWidth, &Value))
4993 return true;
4994
Eli Friedman1d954f62009-08-15 21:55:26 +00004995 if (Value != 0 && ZeroWidth)
4996 *ZeroWidth = false;
4997
Chris Lattnercd087072008-12-12 04:56:04 +00004998 // Zero-width bitfield is ok for anonymous field.
4999 if (Value == 0 && FieldName)
5000 return Diag(FieldLoc, diag::err_bitfield_has_zero_width) << FieldName;
Mike Stump1eb44332009-09-09 15:08:12 +00005001
Chris Lattnerdf9bcd52009-04-20 17:29:38 +00005002 if (Value.isSigned() && Value.isNegative()) {
5003 if (FieldName)
Mike Stump1eb44332009-09-09 15:08:12 +00005004 return Diag(FieldLoc, diag::err_bitfield_has_negative_width)
Chris Lattnerdf9bcd52009-04-20 17:29:38 +00005005 << FieldName << Value.toString(10);
5006 return Diag(FieldLoc, diag::err_anon_bitfield_has_negative_width)
5007 << Value.toString(10);
5008 }
Anders Carlsson9f1e5722008-12-06 20:33:04 +00005009
Douglas Gregor3cf538d2009-03-11 18:59:21 +00005010 if (!FieldTy->isDependentType()) {
5011 uint64_t TypeSize = Context.getTypeSize(FieldTy);
Chris Lattnerdf9bcd52009-04-20 17:29:38 +00005012 if (Value.getZExtValue() > TypeSize) {
5013 if (FieldName)
5014 return Diag(FieldLoc, diag::err_bitfield_width_exceeds_type_size)
5015 << FieldName << (unsigned)TypeSize;
5016 return Diag(FieldLoc, diag::err_anon_bitfield_width_exceeds_type_size)
5017 << (unsigned)TypeSize;
5018 }
Douglas Gregor3cf538d2009-03-11 18:59:21 +00005019 }
Anders Carlsson9f1e5722008-12-06 20:33:04 +00005020
5021 return false;
5022}
5023
Steve Naroff08d92e42007-09-15 18:49:24 +00005024/// ActOnField - Each field of a struct/union/class is passed into this in order
Reid Spencer5f016e22007-07-11 17:01:13 +00005025/// to create a FieldDecl object for it.
Chris Lattnerb28317a2009-03-28 19:18:32 +00005026Sema::DeclPtrTy Sema::ActOnField(Scope *S, DeclPtrTy TagD,
Mike Stump1eb44332009-09-09 15:08:12 +00005027 SourceLocation DeclStart,
Chris Lattnerb28317a2009-03-28 19:18:32 +00005028 Declarator &D, ExprTy *BitfieldWidth) {
5029 FieldDecl *Res = HandleField(S, cast_or_null<RecordDecl>(TagD.getAs<Decl>()),
5030 DeclStart, D, static_cast<Expr*>(BitfieldWidth),
5031 AS_public);
5032 return DeclPtrTy::make(Res);
Chris Lattner24793662009-03-05 22:45:59 +00005033}
5034
5035/// HandleField - Analyze a field of a C struct or a C++ data member.
5036///
5037FieldDecl *Sema::HandleField(Scope *S, RecordDecl *Record,
5038 SourceLocation DeclStart,
Douglas Gregor4dd55f52009-03-11 20:50:30 +00005039 Declarator &D, Expr *BitWidth,
5040 AccessSpecifier AS) {
Reid Spencer5f016e22007-07-11 17:01:13 +00005041 IdentifierInfo *II = D.getIdentifier();
Reid Spencer5f016e22007-07-11 17:01:13 +00005042 SourceLocation Loc = DeclStart;
5043 if (II) Loc = D.getIdentifierLoc();
Mike Stump1eb44332009-09-09 15:08:12 +00005044
John McCalla93c9342009-12-07 02:54:59 +00005045 TypeSourceInfo *TInfo = 0;
5046 QualType T = GetTypeForDeclarator(D, S, &TInfo);
Chris Lattner6491f472009-04-12 22:15:02 +00005047 if (getLangOptions().CPlusPlus)
Douglas Gregor3cf538d2009-03-11 18:59:21 +00005048 CheckExtraCXXDefaultArguments(D);
Douglas Gregor021c3b32009-03-11 23:00:04 +00005049
Eli Friedman85a53192009-04-07 19:37:57 +00005050 DiagnoseFunctionSpecifiers(D);
5051
Eli Friedman63054b32009-04-19 20:27:55 +00005052 if (D.getDeclSpec().isThreadSpecified())
5053 Diag(D.getDeclSpec().getThreadSpecLoc(), diag::err_invalid_thread);
5054
John McCalla24dc2e2009-11-17 02:14:36 +00005055 NamedDecl *PrevDecl = LookupSingleName(S, II, LookupMemberName,
John McCall7d384dd2009-11-18 07:57:50 +00005056 ForRedeclaration);
Douglas Gregorc19ee3e2009-06-17 23:37:01 +00005057
5058 if (PrevDecl && PrevDecl->isTemplateParameter()) {
5059 // Maybe we will complain about the shadowed template parameter.
5060 DiagnoseTemplateParameterShadow(D.getIdentifierLoc(), PrevDecl);
5061 // Just pretend that we didn't see the previous declaration.
5062 PrevDecl = 0;
5063 }
5064
Douglas Gregor3cf538d2009-03-11 18:59:21 +00005065 if (PrevDecl && !isDeclInScope(PrevDecl, Record, S))
5066 PrevDecl = 0;
5067
Steve Naroffea218b82009-07-14 14:58:18 +00005068 bool Mutable
5069 = (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_mutable);
5070 SourceLocation TSSL = D.getSourceRange().getBegin();
5071 FieldDecl *NewFD
John McCalla93c9342009-12-07 02:54:59 +00005072 = CheckFieldDecl(II, T, TInfo, Record, Loc, Mutable, BitWidth, TSSL,
Steve Naroffea218b82009-07-14 14:58:18 +00005073 AS, PrevDecl, &D);
Douglas Gregor3cf538d2009-03-11 18:59:21 +00005074 if (NewFD->isInvalidDecl() && PrevDecl) {
5075 // Don't introduce NewFD into scope; there's already something
5076 // with the same name in the same scope.
5077 } else if (II) {
5078 PushOnScopeChains(NewFD, S);
5079 } else
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00005080 Record->addDecl(NewFD);
Douglas Gregor3cf538d2009-03-11 18:59:21 +00005081
5082 return NewFD;
5083}
5084
5085/// \brief Build a new FieldDecl and check its well-formedness.
5086///
5087/// This routine builds a new FieldDecl given the fields name, type,
5088/// record, etc. \p PrevDecl should refer to any previous declaration
5089/// with the same name and in the same scope as the field to be
5090/// created.
5091///
5092/// \returns a new FieldDecl.
5093///
Mike Stump1eb44332009-09-09 15:08:12 +00005094/// \todo The Declarator argument is a hack. It will be removed once
Argyrios Kyrtzidisa1d56622009-08-19 01:27:57 +00005095FieldDecl *Sema::CheckFieldDecl(DeclarationName Name, QualType T,
John McCalla93c9342009-12-07 02:54:59 +00005096 TypeSourceInfo *TInfo,
Douglas Gregor3cf538d2009-03-11 18:59:21 +00005097 RecordDecl *Record, SourceLocation Loc,
Mike Stump1eb44332009-09-09 15:08:12 +00005098 bool Mutable, Expr *BitWidth,
Steve Naroffea218b82009-07-14 14:58:18 +00005099 SourceLocation TSSL,
Douglas Gregor4dd55f52009-03-11 20:50:30 +00005100 AccessSpecifier AS, NamedDecl *PrevDecl,
Douglas Gregor3cf538d2009-03-11 18:59:21 +00005101 Declarator *D) {
5102 IdentifierInfo *II = Name.getAsIdentifierInfo();
Steve Naroff5912a352007-08-28 20:14:24 +00005103 bool InvalidDecl = false;
Chris Lattnereaaebc72009-04-25 08:06:05 +00005104 if (D) InvalidDecl = D->isInvalidType();
Sebastian Redl64b45f72009-01-05 20:52:13 +00005105
Douglas Gregor3cf538d2009-03-11 18:59:21 +00005106 // If we receive a broken type, recover by assuming 'int' and
5107 // marking this declaration as invalid.
5108 if (T.isNull()) {
5109 InvalidDecl = true;
5110 T = Context.IntTy;
5111 }
5112
Eli Friedman721e77d2009-12-07 00:22:08 +00005113 QualType EltTy = Context.getBaseElementType(T);
5114 if (!EltTy->isDependentType() &&
5115 RequireCompleteType(Loc, EltTy, diag::err_field_incomplete))
5116 InvalidDecl = true;
5117
Reid Spencer5f016e22007-07-11 17:01:13 +00005118 // C99 6.7.2.1p8: A member of a structure or union may have any type other
5119 // than a variably modified type.
Eli Friedman721e77d2009-12-07 00:22:08 +00005120 if (!InvalidDecl && T->isVariablyModifiedType()) {
Eli Friedman1ca48132009-02-21 00:44:51 +00005121 bool SizeIsNegative;
5122 QualType FixedTy = TryToFixInvalidVariablyModifiedType(T, Context,
5123 SizeIsNegative);
5124 if (!FixedTy.isNull()) {
5125 Diag(Loc, diag::warn_illegal_constant_array_size);
5126 T = FixedTy;
5127 } else {
5128 if (SizeIsNegative)
5129 Diag(Loc, diag::err_typecheck_negative_array_size);
5130 else
5131 Diag(Loc, diag::err_typecheck_field_variable_size);
Eli Friedman1ca48132009-02-21 00:44:51 +00005132 InvalidDecl = true;
5133 }
Reid Spencer5f016e22007-07-11 17:01:13 +00005134 }
Mike Stump1eb44332009-09-09 15:08:12 +00005135
Anders Carlsson4681ebd2009-03-22 20:18:17 +00005136 // Fields can not have abstract class types
Eli Friedman721e77d2009-12-07 00:22:08 +00005137 if (!InvalidDecl && RequireNonAbstractType(Loc, T,
5138 diag::err_abstract_type_in_decl,
5139 AbstractFieldType))
Anders Carlsson4681ebd2009-03-22 20:18:17 +00005140 InvalidDecl = true;
Mike Stump1eb44332009-09-09 15:08:12 +00005141
Eli Friedman1d954f62009-08-15 21:55:26 +00005142 bool ZeroWidth = false;
Douglas Gregor3cf538d2009-03-11 18:59:21 +00005143 // If this is declared as a bit-field, check the bit-field.
Eli Friedman721e77d2009-12-07 00:22:08 +00005144 if (!InvalidDecl && BitWidth &&
5145 VerifyBitField(Loc, II, T, BitWidth, &ZeroWidth)) {
Douglas Gregor3cf538d2009-03-11 18:59:21 +00005146 InvalidDecl = true;
5147 DeleteExpr(BitWidth);
5148 BitWidth = 0;
Eli Friedman1d954f62009-08-15 21:55:26 +00005149 ZeroWidth = false;
Anders Carlsson9f1e5722008-12-06 20:33:04 +00005150 }
Mike Stump1eb44332009-09-09 15:08:12 +00005151
John McCalla93c9342009-12-07 02:54:59 +00005152 FieldDecl *NewFD = FieldDecl::Create(Context, Record, Loc, II, T, TInfo,
Argyrios Kyrtzidisa5d82002009-08-21 00:31:54 +00005153 BitWidth, Mutable);
Chris Lattnereaaebc72009-04-25 08:06:05 +00005154 if (InvalidDecl)
5155 NewFD->setInvalidDecl();
Douglas Gregor44b43212008-12-11 16:49:14 +00005156
Douglas Gregor3cf538d2009-03-11 18:59:21 +00005157 if (PrevDecl && !isa<TagDecl>(PrevDecl)) {
5158 Diag(Loc, diag::err_duplicate_member) << II;
5159 Diag(PrevDecl->getLocation(), diag::note_previous_declaration);
5160 NewFD->setInvalidDecl();
Douglas Gregor72de6672009-01-08 20:45:30 +00005161 }
5162
Douglas Gregor1f2023a2009-07-22 18:25:24 +00005163 if (getLangOptions().CPlusPlus) {
Eli Friedman1d954f62009-08-15 21:55:26 +00005164 CXXRecordDecl* CXXRecord = cast<CXXRecordDecl>(Record);
5165
5166 if (!T->isPODType())
5167 CXXRecord->setPOD(false);
5168 if (!ZeroWidth)
5169 CXXRecord->setEmpty(false);
5170
Ted Kremenek6217b802009-07-29 21:53:49 +00005171 if (const RecordType *RT = EltTy->getAs<RecordType>()) {
Douglas Gregor1f2023a2009-07-22 18:25:24 +00005172 CXXRecordDecl* RDecl = cast<CXXRecordDecl>(RT->getDecl());
5173
5174 if (!RDecl->hasTrivialConstructor())
Eli Friedman1d954f62009-08-15 21:55:26 +00005175 CXXRecord->setHasTrivialConstructor(false);
Douglas Gregor1f2023a2009-07-22 18:25:24 +00005176 if (!RDecl->hasTrivialCopyConstructor())
Eli Friedman1d954f62009-08-15 21:55:26 +00005177 CXXRecord->setHasTrivialCopyConstructor(false);
Douglas Gregor1f2023a2009-07-22 18:25:24 +00005178 if (!RDecl->hasTrivialCopyAssignment())
Eli Friedman1d954f62009-08-15 21:55:26 +00005179 CXXRecord->setHasTrivialCopyAssignment(false);
Douglas Gregor1f2023a2009-07-22 18:25:24 +00005180 if (!RDecl->hasTrivialDestructor())
Eli Friedman1d954f62009-08-15 21:55:26 +00005181 CXXRecord->setHasTrivialDestructor(false);
Douglas Gregor1f2023a2009-07-22 18:25:24 +00005182
5183 // C++ 9.5p1: An object of a class with a non-trivial
5184 // constructor, a non-trivial copy constructor, a non-trivial
5185 // destructor, or a non-trivial copy assignment operator
5186 // cannot be a member of a union, nor can an array of such
5187 // objects.
5188 // TODO: C++0x alters this restriction significantly.
5189 if (Record->isUnion()) {
5190 // We check for copy constructors before constructors
5191 // because otherwise we'll never get complaints about
5192 // copy constructors.
5193
5194 const CXXSpecialMember invalid = (CXXSpecialMember) -1;
5195
5196 CXXSpecialMember member;
5197 if (!RDecl->hasTrivialCopyConstructor())
5198 member = CXXCopyConstructor;
5199 else if (!RDecl->hasTrivialConstructor())
5200 member = CXXDefaultConstructor;
5201 else if (!RDecl->hasTrivialCopyAssignment())
5202 member = CXXCopyAssignment;
5203 else if (!RDecl->hasTrivialDestructor())
5204 member = CXXDestructor;
5205 else
5206 member = invalid;
5207
5208 if (member != invalid) {
5209 Diag(Loc, diag::err_illegal_union_member) << Name << member;
5210 DiagnoseNontrivial(RT, member);
5211 NewFD->setInvalidDecl();
5212 }
5213 }
5214 }
5215 }
5216
Douglas Gregor3cf538d2009-03-11 18:59:21 +00005217 // FIXME: We need to pass in the attributes given an AST
5218 // representation, not a parser representation.
5219 if (D)
Douglas Gregor9cdda0c2009-06-17 21:51:59 +00005220 // FIXME: What to pass instead of TUScope?
5221 ProcessDeclAttributes(TUScope, NewFD, *D);
Douglas Gregor3cf538d2009-03-11 18:59:21 +00005222
Fariborz Jahanianf6123ca2009-02-19 00:22:47 +00005223 if (T.isObjCGCWeak())
Fariborz Jahanianed7e9ef2009-02-18 18:14:41 +00005224 Diag(Loc, diag::warn_attribute_weak_on_field);
Anders Carlssonad148062008-02-16 00:29:18 +00005225
Douglas Gregor4dd55f52009-03-11 20:50:30 +00005226 NewFD->setAccess(AS);
5227
5228 // C++ [dcl.init.aggr]p1:
5229 // An aggregate is an array or a class (clause 9) with [...] no
5230 // private or protected non-static data members (clause 11).
5231 // A POD must be an aggregate.
5232 if (getLangOptions().CPlusPlus &&
5233 (AS == AS_private || AS == AS_protected)) {
5234 CXXRecordDecl *CXXRecord = cast<CXXRecordDecl>(Record);
5235 CXXRecord->setAggregate(false);
5236 CXXRecord->setPOD(false);
5237 }
5238
Steve Naroff5912a352007-08-28 20:14:24 +00005239 return NewFD;
Reid Spencer5f016e22007-07-11 17:01:13 +00005240}
5241
Douglas Gregor1f2023a2009-07-22 18:25:24 +00005242/// DiagnoseNontrivial - Given that a class has a non-trivial
5243/// special member, figure out why.
5244void Sema::DiagnoseNontrivial(const RecordType* T, CXXSpecialMember member) {
5245 QualType QT(T, 0U);
5246 CXXRecordDecl* RD = cast<CXXRecordDecl>(T->getDecl());
5247
5248 // Check whether the member was user-declared.
5249 switch (member) {
5250 case CXXDefaultConstructor:
5251 if (RD->hasUserDeclaredConstructor()) {
5252 typedef CXXRecordDecl::ctor_iterator ctor_iter;
Sebastian Redl38fd4d02009-10-25 22:31:45 +00005253 for (ctor_iter ci = RD->ctor_begin(), ce = RD->ctor_end(); ci != ce;++ci){
5254 const FunctionDecl *body = 0;
5255 ci->getBody(body);
5256 if (!body ||
5257 !cast<CXXConstructorDecl>(body)->isImplicitlyDefined(Context)) {
Douglas Gregor1f2023a2009-07-22 18:25:24 +00005258 SourceLocation CtorLoc = ci->getLocation();
5259 Diag(CtorLoc, diag::note_nontrivial_user_defined) << QT << member;
5260 return;
5261 }
Sebastian Redl38fd4d02009-10-25 22:31:45 +00005262 }
Douglas Gregor1f2023a2009-07-22 18:25:24 +00005263
5264 assert(0 && "found no user-declared constructors");
5265 return;
5266 }
5267 break;
5268
5269 case CXXCopyConstructor:
5270 if (RD->hasUserDeclaredCopyConstructor()) {
5271 SourceLocation CtorLoc =
5272 RD->getCopyConstructor(Context, 0)->getLocation();
5273 Diag(CtorLoc, diag::note_nontrivial_user_defined) << QT << member;
5274 return;
5275 }
5276 break;
5277
5278 case CXXCopyAssignment:
5279 if (RD->hasUserDeclaredCopyAssignment()) {
5280 // FIXME: this should use the location of the copy
5281 // assignment, not the type.
5282 SourceLocation TyLoc = RD->getSourceRange().getBegin();
5283 Diag(TyLoc, diag::note_nontrivial_user_defined) << QT << member;
5284 return;
5285 }
5286 break;
5287
5288 case CXXDestructor:
5289 if (RD->hasUserDeclaredDestructor()) {
5290 SourceLocation DtorLoc = RD->getDestructor(Context)->getLocation();
5291 Diag(DtorLoc, diag::note_nontrivial_user_defined) << QT << member;
5292 return;
5293 }
5294 break;
5295 }
5296
5297 typedef CXXRecordDecl::base_class_iterator base_iter;
5298
5299 // Virtual bases and members inhibit trivial copying/construction,
5300 // but not trivial destruction.
5301 if (member != CXXDestructor) {
5302 // Check for virtual bases. vbases includes indirect virtual bases,
5303 // so we just iterate through the direct bases.
5304 for (base_iter bi = RD->bases_begin(), be = RD->bases_end(); bi != be; ++bi)
5305 if (bi->isVirtual()) {
5306 SourceLocation BaseLoc = bi->getSourceRange().getBegin();
5307 Diag(BaseLoc, diag::note_nontrivial_has_virtual) << QT << 1;
5308 return;
5309 }
5310
5311 // Check for virtual methods.
5312 typedef CXXRecordDecl::method_iterator meth_iter;
5313 for (meth_iter mi = RD->method_begin(), me = RD->method_end(); mi != me;
5314 ++mi) {
5315 if (mi->isVirtual()) {
5316 SourceLocation MLoc = mi->getSourceRange().getBegin();
5317 Diag(MLoc, diag::note_nontrivial_has_virtual) << QT << 0;
5318 return;
5319 }
5320 }
5321 }
Mike Stump1eb44332009-09-09 15:08:12 +00005322
Douglas Gregor1f2023a2009-07-22 18:25:24 +00005323 bool (CXXRecordDecl::*hasTrivial)() const;
5324 switch (member) {
5325 case CXXDefaultConstructor:
5326 hasTrivial = &CXXRecordDecl::hasTrivialConstructor; break;
5327 case CXXCopyConstructor:
5328 hasTrivial = &CXXRecordDecl::hasTrivialCopyConstructor; break;
5329 case CXXCopyAssignment:
5330 hasTrivial = &CXXRecordDecl::hasTrivialCopyAssignment; break;
5331 case CXXDestructor:
5332 hasTrivial = &CXXRecordDecl::hasTrivialDestructor; break;
5333 default:
5334 assert(0 && "unexpected special member"); return;
5335 }
5336
5337 // Check for nontrivial bases (and recurse).
5338 for (base_iter bi = RD->bases_begin(), be = RD->bases_end(); bi != be; ++bi) {
Ted Kremenek6217b802009-07-29 21:53:49 +00005339 const RecordType *BaseRT = bi->getType()->getAs<RecordType>();
Sebastian Redl9994a342009-10-25 17:03:50 +00005340 assert(BaseRT && "Don't know how to handle dependent bases");
Douglas Gregor1f2023a2009-07-22 18:25:24 +00005341 CXXRecordDecl *BaseRecTy = cast<CXXRecordDecl>(BaseRT->getDecl());
5342 if (!(BaseRecTy->*hasTrivial)()) {
5343 SourceLocation BaseLoc = bi->getSourceRange().getBegin();
5344 Diag(BaseLoc, diag::note_nontrivial_has_nontrivial) << QT << 1 << member;
5345 DiagnoseNontrivial(BaseRT, member);
5346 return;
5347 }
5348 }
Mike Stump1eb44332009-09-09 15:08:12 +00005349
Douglas Gregor1f2023a2009-07-22 18:25:24 +00005350 // Check for nontrivial members (and recurse).
5351 typedef RecordDecl::field_iterator field_iter;
5352 for (field_iter fi = RD->field_begin(), fe = RD->field_end(); fi != fe;
5353 ++fi) {
Douglas Gregor5e03f9e2009-07-23 23:49:00 +00005354 QualType EltTy = Context.getBaseElementType((*fi)->getType());
Ted Kremenek6217b802009-07-29 21:53:49 +00005355 if (const RecordType *EltRT = EltTy->getAs<RecordType>()) {
Douglas Gregor1f2023a2009-07-22 18:25:24 +00005356 CXXRecordDecl* EltRD = cast<CXXRecordDecl>(EltRT->getDecl());
5357
5358 if (!(EltRD->*hasTrivial)()) {
5359 SourceLocation FLoc = (*fi)->getLocation();
5360 Diag(FLoc, diag::note_nontrivial_has_nontrivial) << QT << 0 << member;
5361 DiagnoseNontrivial(EltRT, member);
5362 return;
5363 }
5364 }
5365 }
5366
5367 assert(0 && "found no explanation for non-trivial member");
5368}
5369
Mike Stump1eb44332009-09-09 15:08:12 +00005370/// TranslateIvarVisibility - Translate visibility from a token ID to an
Fariborz Jahanian89204a12007-10-01 16:53:59 +00005371/// AST enum value.
Ted Kremeneka526c5c2008-01-07 19:49:32 +00005372static ObjCIvarDecl::AccessControl
Fariborz Jahanian89204a12007-10-01 16:53:59 +00005373TranslateIvarVisibility(tok::ObjCKeywordKind ivarVisibility) {
Steve Narofff13271f2007-09-14 23:09:53 +00005374 switch (ivarVisibility) {
Chris Lattner33d34a62008-10-12 00:28:42 +00005375 default: assert(0 && "Unknown visitibility kind");
5376 case tok::objc_private: return ObjCIvarDecl::Private;
5377 case tok::objc_public: return ObjCIvarDecl::Public;
5378 case tok::objc_protected: return ObjCIvarDecl::Protected;
5379 case tok::objc_package: return ObjCIvarDecl::Package;
Steve Narofff13271f2007-09-14 23:09:53 +00005380 }
5381}
5382
Mike Stump1eb44332009-09-09 15:08:12 +00005383/// ActOnIvar - Each ivar field of an objective-c class is passed into this
Fariborz Jahanian45bc03f2008-04-11 16:55:42 +00005384/// in order to create an IvarDecl object for it.
Chris Lattnerb28317a2009-03-28 19:18:32 +00005385Sema::DeclPtrTy Sema::ActOnIvar(Scope *S,
Mike Stump1eb44332009-09-09 15:08:12 +00005386 SourceLocation DeclStart,
Fariborz Jahanian496b5a82009-06-05 18:16:35 +00005387 DeclPtrTy IntfDecl,
Chris Lattnerb28317a2009-03-28 19:18:32 +00005388 Declarator &D, ExprTy *BitfieldWidth,
5389 tok::ObjCKeywordKind Visibility) {
Mike Stump1eb44332009-09-09 15:08:12 +00005390
Fariborz Jahanian1d78cc42008-04-10 23:32:45 +00005391 IdentifierInfo *II = D.getIdentifier();
5392 Expr *BitWidth = (Expr*)BitfieldWidth;
5393 SourceLocation Loc = DeclStart;
5394 if (II) Loc = D.getIdentifierLoc();
Mike Stump1eb44332009-09-09 15:08:12 +00005395
Fariborz Jahanian1d78cc42008-04-10 23:32:45 +00005396 // FIXME: Unnamed fields can be handled in various different ways, for
5397 // example, unnamed unions inject all members into the struct namespace!
Mike Stump1eb44332009-09-09 15:08:12 +00005398
John McCalla93c9342009-12-07 02:54:59 +00005399 TypeSourceInfo *TInfo = 0;
5400 QualType T = GetTypeForDeclarator(D, S, &TInfo);
Mike Stump1eb44332009-09-09 15:08:12 +00005401
Fariborz Jahanian1d78cc42008-04-10 23:32:45 +00005402 if (BitWidth) {
Steve Naroff63359c82009-02-20 17:57:11 +00005403 // 6.7.2.1p3, 6.7.2.1p4
Chris Lattner24793662009-03-05 22:45:59 +00005404 if (VerifyBitField(Loc, II, T, BitWidth)) {
Chris Lattnereaaebc72009-04-25 08:06:05 +00005405 D.setInvalidType();
Chris Lattner24793662009-03-05 22:45:59 +00005406 DeleteExpr(BitWidth);
5407 BitWidth = 0;
5408 }
Fariborz Jahanian1d78cc42008-04-10 23:32:45 +00005409 } else {
5410 // Not a bitfield.
Mike Stump1eb44332009-09-09 15:08:12 +00005411
Fariborz Jahanian1d78cc42008-04-10 23:32:45 +00005412 // validate II.
Mike Stump1eb44332009-09-09 15:08:12 +00005413
Fariborz Jahanian1d78cc42008-04-10 23:32:45 +00005414 }
Mike Stump1eb44332009-09-09 15:08:12 +00005415
Fariborz Jahanian1d78cc42008-04-10 23:32:45 +00005416 // C99 6.7.2.1p8: A member of a structure or union may have any type other
5417 // than a variably modified type.
5418 if (T->isVariablyModifiedType()) {
Anders Carlsson96e05bc2008-12-07 00:20:55 +00005419 Diag(Loc, diag::err_typecheck_ivar_variable_size);
Chris Lattnereaaebc72009-04-25 08:06:05 +00005420 D.setInvalidType();
Fariborz Jahanian1d78cc42008-04-10 23:32:45 +00005421 }
Mike Stump1eb44332009-09-09 15:08:12 +00005422
Ted Kremenekb8db21d2008-07-23 18:04:17 +00005423 // Get the visibility (access control) for this ivar.
Mike Stump1eb44332009-09-09 15:08:12 +00005424 ObjCIvarDecl::AccessControl ac =
Ted Kremenekb8db21d2008-07-23 18:04:17 +00005425 Visibility != tok::objc_not_keyword ? TranslateIvarVisibility(Visibility)
5426 : ObjCIvarDecl::None;
Fariborz Jahanian496b5a82009-06-05 18:16:35 +00005427 // Must set ivar's DeclContext to its enclosing interface.
5428 Decl *EnclosingDecl = IntfDecl.getAs<Decl>();
5429 DeclContext *EnclosingContext;
Mike Stump1eb44332009-09-09 15:08:12 +00005430 if (ObjCImplementationDecl *IMPDecl =
Fariborz Jahanian496b5a82009-06-05 18:16:35 +00005431 dyn_cast<ObjCImplementationDecl>(EnclosingDecl)) {
5432 // Case of ivar declared in an implementation. Context is that of its class.
5433 ObjCInterfaceDecl* IDecl = IMPDecl->getClassInterface();
5434 assert(IDecl && "No class- ActOnIvar");
5435 EnclosingContext = cast_or_null<DeclContext>(IDecl);
Mike Stumpac5fc7c2009-08-04 21:02:39 +00005436 } else
Fariborz Jahanian496b5a82009-06-05 18:16:35 +00005437 EnclosingContext = dyn_cast<DeclContext>(EnclosingDecl);
5438 assert(EnclosingContext && "null DeclContext for ivar - ActOnIvar");
Mike Stump1eb44332009-09-09 15:08:12 +00005439
Ted Kremenekb8db21d2008-07-23 18:04:17 +00005440 // Construct the decl.
Mike Stump1eb44332009-09-09 15:08:12 +00005441 ObjCIvarDecl *NewID = ObjCIvarDecl::Create(Context,
Argyrios Kyrtzidisa1d56622009-08-19 01:27:57 +00005442 EnclosingContext, Loc, II, T,
John McCalla93c9342009-12-07 02:54:59 +00005443 TInfo, ac, (Expr *)BitfieldWidth);
Mike Stump1eb44332009-09-09 15:08:12 +00005444
Douglas Gregor72de6672009-01-08 20:45:30 +00005445 if (II) {
John McCalla24dc2e2009-11-17 02:14:36 +00005446 NamedDecl *PrevDecl = LookupSingleName(S, II, LookupMemberName,
John McCall7d384dd2009-11-18 07:57:50 +00005447 ForRedeclaration);
Fariborz Jahanian496b5a82009-06-05 18:16:35 +00005448 if (PrevDecl && isDeclInScope(PrevDecl, EnclosingContext, S)
Douglas Gregor72de6672009-01-08 20:45:30 +00005449 && !isa<TagDecl>(PrevDecl)) {
5450 Diag(Loc, diag::err_duplicate_member) << II;
5451 Diag(PrevDecl->getLocation(), diag::note_previous_declaration);
5452 NewID->setInvalidDecl();
5453 }
5454 }
5455
Ted Kremenekb8db21d2008-07-23 18:04:17 +00005456 // Process attributes attached to the ivar.
Douglas Gregor9cdda0c2009-06-17 21:51:59 +00005457 ProcessDeclAttributes(S, NewID, D);
Mike Stump1eb44332009-09-09 15:08:12 +00005458
Chris Lattnereaaebc72009-04-25 08:06:05 +00005459 if (D.isInvalidType())
Fariborz Jahanian1d78cc42008-04-10 23:32:45 +00005460 NewID->setInvalidDecl();
Ted Kremenekb8db21d2008-07-23 18:04:17 +00005461
Douglas Gregor72de6672009-01-08 20:45:30 +00005462 if (II) {
5463 // FIXME: When interfaces are DeclContexts, we'll need to add
5464 // these to the interface.
Chris Lattnerb28317a2009-03-28 19:18:32 +00005465 S->AddDecl(DeclPtrTy::make(NewID));
Douglas Gregor72de6672009-01-08 20:45:30 +00005466 IdResolver.AddDecl(NewID);
5467 }
5468
Chris Lattnerb28317a2009-03-28 19:18:32 +00005469 return DeclPtrTy::make(NewID);
Fariborz Jahanian1d78cc42008-04-10 23:32:45 +00005470}
5471
Fariborz Jahanian9d048ff2007-09-29 00:54:24 +00005472void Sema::ActOnFields(Scope* S,
Chris Lattnerb28317a2009-03-28 19:18:32 +00005473 SourceLocation RecLoc, DeclPtrTy RecDecl,
5474 DeclPtrTy *Fields, unsigned NumFields,
Daniel Dunbar1bfe1c22008-10-03 02:03:53 +00005475 SourceLocation LBrac, SourceLocation RBrac,
Daniel Dunbar7d076642008-10-03 17:33:35 +00005476 AttributeList *Attr) {
Chris Lattnerb28317a2009-03-28 19:18:32 +00005477 Decl *EnclosingDecl = RecDecl.getAs<Decl>();
Steve Naroff74216642007-09-14 22:20:54 +00005478 assert(EnclosingDecl && "missing record or interface decl");
Mike Stump1eb44332009-09-09 15:08:12 +00005479
Chris Lattner1829a6d2009-02-23 22:00:08 +00005480 // If the decl this is being inserted into is invalid, then it may be a
5481 // redeclaration or some other bogus case. Don't try to add fields to it.
5482 if (EnclosingDecl->isInvalidDecl()) {
5483 // FIXME: Deallocate fields?
5484 return;
5485 }
5486
Mike Stump1eb44332009-09-09 15:08:12 +00005487
Reid Spencer5f016e22007-07-11 17:01:13 +00005488 // Verify that all the fields are okay.
5489 unsigned NumNamedMembers = 0;
5490 llvm::SmallVector<FieldDecl*, 32> RecFields;
Douglas Gregor6b3945f2009-01-07 19:46:03 +00005491
Chris Lattner1829a6d2009-02-23 22:00:08 +00005492 RecordDecl *Record = dyn_cast<RecordDecl>(EnclosingDecl);
Reid Spencer5f016e22007-07-11 17:01:13 +00005493 for (unsigned i = 0; i != NumFields; ++i) {
Chris Lattnerb28317a2009-03-28 19:18:32 +00005494 FieldDecl *FD = cast<FieldDecl>(Fields[i].getAs<Decl>());
Mike Stump1eb44332009-09-09 15:08:12 +00005495
Reid Spencer5f016e22007-07-11 17:01:13 +00005496 // Get the type for the field.
Chris Lattner02c642e2007-07-31 21:33:24 +00005497 Type *FDTy = FD->getType().getTypePtr();
Douglas Gregor6b3945f2009-01-07 19:46:03 +00005498
Douglas Gregor72de6672009-01-08 20:45:30 +00005499 if (!FD->isAnonymousStructOrUnion()) {
Douglas Gregor6b3945f2009-01-07 19:46:03 +00005500 // Remember all fields written by the user.
5501 RecFields.push_back(FD);
5502 }
Mike Stump1eb44332009-09-09 15:08:12 +00005503
Chris Lattner24793662009-03-05 22:45:59 +00005504 // If the field is already invalid for some reason, don't emit more
5505 // diagnostics about it.
Eli Friedman721e77d2009-12-07 00:22:08 +00005506 if (FD->isInvalidDecl()) {
5507 EnclosingDecl->setInvalidDecl();
Chris Lattner24793662009-03-05 22:45:59 +00005508 continue;
Eli Friedman721e77d2009-12-07 00:22:08 +00005509 }
Mike Stump1eb44332009-09-09 15:08:12 +00005510
Douglas Gregore7450f52009-03-24 19:52:54 +00005511 // C99 6.7.2.1p2:
5512 // A structure or union shall not contain a member with
5513 // incomplete or function type (hence, a structure shall not
5514 // contain an instance of itself, but may contain a pointer to
5515 // an instance of itself), except that the last member of a
5516 // structure with more than one named member may have incomplete
5517 // array type; such a structure (and any union containing,
5518 // possibly recursively, a member that is such a structure)
5519 // shall not be a member of a structure or an element of an
5520 // array.
Chris Lattner02c642e2007-07-31 21:33:24 +00005521 if (FDTy->isFunctionType()) {
Douglas Gregore7450f52009-03-24 19:52:54 +00005522 // Field declared as a function.
Chris Lattnerf3a41af2008-11-20 06:38:18 +00005523 Diag(FD->getLocation(), diag::err_field_declared_as_function)
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00005524 << FD->getDeclName();
Steve Naroff74216642007-09-14 22:20:54 +00005525 FD->setInvalidDecl();
5526 EnclosingDecl->setInvalidDecl();
Reid Spencer5f016e22007-07-11 17:01:13 +00005527 continue;
Douglas Gregore7450f52009-03-24 19:52:54 +00005528 } else if (FDTy->isIncompleteArrayType() && i == NumFields - 1 &&
5529 Record && Record->isStruct()) {
5530 // Flexible array member.
5531 if (NumNamedMembers < 1) {
Chris Lattnerf3a41af2008-11-20 06:38:18 +00005532 Diag(FD->getLocation(), diag::err_flexible_array_empty_struct)
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00005533 << FD->getDeclName();
Steve Naroff74216642007-09-14 22:20:54 +00005534 FD->setInvalidDecl();
5535 EnclosingDecl->setInvalidDecl();
Reid Spencer5f016e22007-07-11 17:01:13 +00005536 continue;
5537 }
Reid Spencer5f016e22007-07-11 17:01:13 +00005538 // Okay, we have a legal flexible array member at the end of the struct.
Fariborz Jahaniane267ab62007-09-14 16:27:55 +00005539 if (Record)
5540 Record->setHasFlexibleArrayMember(true);
Douglas Gregore7450f52009-03-24 19:52:54 +00005541 } else if (!FDTy->isDependentType() &&
Mike Stump1eb44332009-09-09 15:08:12 +00005542 RequireCompleteType(FD->getLocation(), FD->getType(),
Douglas Gregore7450f52009-03-24 19:52:54 +00005543 diag::err_field_incomplete)) {
5544 // Incomplete type
5545 FD->setInvalidDecl();
5546 EnclosingDecl->setInvalidDecl();
5547 continue;
Ted Kremenek6217b802009-07-29 21:53:49 +00005548 } else if (const RecordType *FDTTy = FDTy->getAs<RecordType>()) {
Reid Spencer5f016e22007-07-11 17:01:13 +00005549 if (FDTTy->getDecl()->hasFlexibleArrayMember()) {
5550 // If this is a member of a union, then entire union becomes "flexible".
Argyrios Kyrtzidis39ba4ae2008-06-09 23:19:58 +00005551 if (Record && Record->isUnion()) {
Reid Spencer5f016e22007-07-11 17:01:13 +00005552 Record->setHasFlexibleArrayMember(true);
5553 } else {
5554 // If this is a struct/class and this is not the last element, reject
5555 // it. Note that GCC supports variable sized arrays in the middle of
5556 // structures.
Douglas Gregore4f3e062009-03-06 23:41:27 +00005557 if (i != NumFields-1)
5558 Diag(FD->getLocation(), diag::ext_variable_sized_type_in_struct)
Chris Lattner740782a2009-04-25 18:52:45 +00005559 << FD->getDeclName() << FD->getType();
Douglas Gregore4f3e062009-03-06 23:41:27 +00005560 else {
5561 // We support flexible arrays at the end of structs in
5562 // other structs as an extension.
5563 Diag(FD->getLocation(), diag::ext_flexible_array_in_struct)
5564 << FD->getDeclName();
5565 if (Record)
5566 Record->setHasFlexibleArrayMember(true);
Reid Spencer5f016e22007-07-11 17:01:13 +00005567 }
Reid Spencer5f016e22007-07-11 17:01:13 +00005568 }
5569 }
Fariborz Jahanian082b02e2009-07-08 01:18:33 +00005570 if (Record && FDTTy->getDecl()->hasObjectMember())
5571 Record->setHasObjectMember(true);
Douglas Gregore7450f52009-03-24 19:52:54 +00005572 } else if (FDTy->isObjCInterfaceType()) {
5573 /// A field cannot be an Objective-c object
Steve Naroffccef3712009-02-20 22:59:16 +00005574 Diag(FD->getLocation(), diag::err_statically_allocated_object);
Fariborz Jahaniane7f64cc2007-10-12 22:10:42 +00005575 FD->setInvalidDecl();
5576 EnclosingDecl->setInvalidDecl();
5577 continue;
Mike Stumpac5fc7c2009-08-04 21:02:39 +00005578 } else if (getLangOptions().ObjC1 &&
5579 getLangOptions().getGCMode() != LangOptions::NonGC &&
5580 Record &&
5581 (FD->getType()->isObjCObjectPointerType() ||
5582 FD->getType().isObjCGCStrong()))
Fariborz Jahanian082b02e2009-07-08 01:18:33 +00005583 Record->setHasObjectMember(true);
Reid Spencer5f016e22007-07-11 17:01:13 +00005584 // Keep track of the number of named members.
Douglas Gregor72de6672009-01-08 20:45:30 +00005585 if (FD->getIdentifier())
Reid Spencer5f016e22007-07-11 17:01:13 +00005586 ++NumNamedMembers;
Reid Spencer5f016e22007-07-11 17:01:13 +00005587 }
Sebastian Redl64b45f72009-01-05 20:52:13 +00005588
Reid Spencer5f016e22007-07-11 17:01:13 +00005589 // Okay, we successfully defined 'Record'.
Chris Lattnere1e79852008-02-06 00:51:33 +00005590 if (Record) {
Douglas Gregor44b43212008-12-11 16:49:14 +00005591 Record->completeDefinition(Context);
Chris Lattnere1e79852008-02-06 00:51:33 +00005592 } else {
Jay Foadbeaaccd2009-05-21 09:52:38 +00005593 ObjCIvarDecl **ClsFields =
5594 reinterpret_cast<ObjCIvarDecl**>(RecFields.data());
Fariborz Jahanian60f8c862008-12-13 20:28:25 +00005595 if (ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(EnclosingDecl)) {
Chris Lattner38af2de2009-02-20 21:35:13 +00005596 ID->setIVarList(ClsFields, RecFields.size(), Context);
5597 ID->setLocEnd(RBrac);
Fariborz Jahanian496b5a82009-06-05 18:16:35 +00005598 // Add ivar's to class's DeclContext.
5599 for (unsigned i = 0, e = RecFields.size(); i != e; ++i) {
5600 ClsFields[i]->setLexicalDeclContext(ID);
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00005601 ID->addDecl(ClsFields[i]);
Fariborz Jahanian496b5a82009-06-05 18:16:35 +00005602 }
Fariborz Jahanian3281eff2008-12-16 01:08:35 +00005603 // Must enforce the rule that ivars in the base classes may not be
5604 // duplicates.
Fariborz Jahanian375d37c2008-12-17 22:21:44 +00005605 if (ID->getSuperClass()) {
Mike Stump1eb44332009-09-09 15:08:12 +00005606 for (ObjCInterfaceDecl::ivar_iterator IVI = ID->ivar_begin(),
Fariborz Jahanian375d37c2008-12-17 22:21:44 +00005607 IVE = ID->ivar_end(); IVI != IVE; ++IVI) {
5608 ObjCIvarDecl* Ivar = (*IVI);
Daniel Dunbarad04e672009-05-03 01:08:28 +00005609
5610 if (IdentifierInfo *II = Ivar->getIdentifier()) {
5611 ObjCIvarDecl* prevIvar =
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00005612 ID->getSuperClass()->lookupInstanceVariable(II);
Daniel Dunbarad04e672009-05-03 01:08:28 +00005613 if (prevIvar) {
5614 Diag(Ivar->getLocation(), diag::err_duplicate_member) << II;
5615 Diag(prevIvar->getLocation(), diag::note_previous_declaration);
5616 }
Fariborz Jahanian3281eff2008-12-16 01:08:35 +00005617 }
Fariborz Jahanian375d37c2008-12-17 22:21:44 +00005618 }
Fariborz Jahanian3281eff2008-12-16 01:08:35 +00005619 }
Mike Stump1eb44332009-09-09 15:08:12 +00005620 } else if (ObjCImplementationDecl *IMPDecl =
Chris Lattner1829a6d2009-02-23 22:00:08 +00005621 dyn_cast<ObjCImplementationDecl>(EnclosingDecl)) {
Ted Kremeneka526c5c2008-01-07 19:49:32 +00005622 assert(IMPDecl && "ActOnFields - missing ObjCImplementationDecl");
Fariborz Jahanian496b5a82009-06-05 18:16:35 +00005623 for (unsigned I = 0, N = RecFields.size(); I != N; ++I)
5624 // Ivar declared in @implementation never belongs to the implementation.
5625 // Only it is in implementation's lexical context.
Douglas Gregor8f36aba2009-04-23 03:23:08 +00005626 ClsFields[I]->setLexicalDeclContext(IMPDecl);
Fariborz Jahanian3a3ca1b2007-10-31 18:48:14 +00005627 CheckImplementationIvars(IMPDecl, ClsFields, RecFields.size(), RBrac);
Fariborz Jahaniand0b90bf2007-09-26 18:27:25 +00005628 }
Fariborz Jahanianb04a0212007-09-14 21:08:27 +00005629 }
Daniel Dunbar7d076642008-10-03 17:33:35 +00005630
5631 if (Attr)
Douglas Gregor9cdda0c2009-06-17 21:51:59 +00005632 ProcessDeclAttributeList(S, Record, Attr);
Reid Spencer5f016e22007-07-11 17:01:13 +00005633}
5634
Douglas Gregor879fd492009-03-17 19:05:46 +00005635EnumConstantDecl *Sema::CheckEnumConstant(EnumDecl *Enum,
5636 EnumConstantDecl *LastEnumConst,
5637 SourceLocation IdLoc,
5638 IdentifierInfo *Id,
5639 ExprArg val) {
5640 Expr *Val = (Expr *)val.get();
5641
5642 llvm::APSInt EnumVal(32);
5643 QualType EltTy;
Douglas Gregor4912c342009-11-06 00:03:12 +00005644 if (Val) {
Eli Friedmaned0716b2009-12-11 01:34:50 +00005645 if (Enum->isDependentType())
Douglas Gregor4912c342009-11-06 00:03:12 +00005646 EltTy = Context.DependentTy;
5647 else {
5648 // Make sure to promote the operand type to int.
5649 UsualUnaryConversions(Val);
5650 if (Val != val.get()) {
5651 val.release();
5652 val = Val;
5653 }
Douglas Gregor879fd492009-03-17 19:05:46 +00005654
Douglas Gregor4912c342009-11-06 00:03:12 +00005655 // C99 6.7.2.2p2: Make sure we have an integer constant expression.
5656 SourceLocation ExpLoc;
Eli Friedmaned0716b2009-12-11 01:34:50 +00005657 if (VerifyIntegerConstantExpression(Val, &EnumVal)) {
Douglas Gregor4912c342009-11-06 00:03:12 +00005658 Val = 0;
5659 } else {
5660 EltTy = Val->getType();
5661 }
Douglas Gregor879fd492009-03-17 19:05:46 +00005662 }
5663 }
Mike Stump1eb44332009-09-09 15:08:12 +00005664
Douglas Gregor879fd492009-03-17 19:05:46 +00005665 if (!Val) {
Eli Friedmaned0716b2009-12-11 01:34:50 +00005666 if (Enum->isDependentType())
5667 EltTy = Context.DependentTy;
5668 else if (LastEnumConst) {
Douglas Gregor879fd492009-03-17 19:05:46 +00005669 // Assign the last value + 1.
5670 EnumVal = LastEnumConst->getInitVal();
5671 ++EnumVal;
5672
5673 // Check for overflow on increment.
5674 if (EnumVal < LastEnumConst->getInitVal())
5675 Diag(IdLoc, diag::warn_enum_value_overflow);
Mike Stump1eb44332009-09-09 15:08:12 +00005676
Douglas Gregor879fd492009-03-17 19:05:46 +00005677 EltTy = LastEnumConst->getType();
5678 } else {
5679 // First value, set to zero.
5680 EltTy = Context.IntTy;
5681 EnumVal.zextOrTrunc(static_cast<uint32_t>(Context.getTypeSize(EltTy)));
Eli Friedman29a7f332009-12-10 22:29:29 +00005682 EnumVal.setIsSigned(true);
Douglas Gregor879fd492009-03-17 19:05:46 +00005683 }
5684 }
Mike Stump1eb44332009-09-09 15:08:12 +00005685
Douglas Gregor4912c342009-11-06 00:03:12 +00005686 assert(!EltTy.isNull() && "Enum constant with NULL type");
5687
Douglas Gregor879fd492009-03-17 19:05:46 +00005688 val.release();
5689 return EnumConstantDecl::Create(Context, Enum, IdLoc, Id, EltTy,
Mike Stump1eb44332009-09-09 15:08:12 +00005690 Val, EnumVal);
Douglas Gregor879fd492009-03-17 19:05:46 +00005691}
5692
5693
Chris Lattnerb28317a2009-03-28 19:18:32 +00005694Sema::DeclPtrTy Sema::ActOnEnumConstant(Scope *S, DeclPtrTy theEnumDecl,
5695 DeclPtrTy lastEnumConst,
5696 SourceLocation IdLoc,
5697 IdentifierInfo *Id,
5698 SourceLocation EqualLoc, ExprTy *val) {
5699 EnumDecl *TheEnumDecl = cast<EnumDecl>(theEnumDecl.getAs<Decl>());
Reid Spencer5f016e22007-07-11 17:01:13 +00005700 EnumConstantDecl *LastEnumConst =
Chris Lattnerb28317a2009-03-28 19:18:32 +00005701 cast_or_null<EnumConstantDecl>(lastEnumConst.getAs<Decl>());
Reid Spencer5f016e22007-07-11 17:01:13 +00005702 Expr *Val = static_cast<Expr*>(val);
5703
Chris Lattner31e05722007-08-26 06:24:45 +00005704 // The scope passed in may not be a decl scope. Zip up the scope tree until
5705 // we find one that is.
Douglas Gregor1a0d31a2009-01-12 18:45:55 +00005706 S = getNonFieldDeclScope(S);
Mike Stump1eb44332009-09-09 15:08:12 +00005707
Reid Spencer5f016e22007-07-11 17:01:13 +00005708 // Verify that there isn't already something declared with this name in this
5709 // scope.
Douglas Gregore39fe722010-01-19 06:06:57 +00005710 NamedDecl *PrevDecl = LookupSingleName(S, Id, LookupOrdinaryName,
5711 ForRedeclaration);
Douglas Gregorf57172b2008-12-08 18:40:42 +00005712 if (PrevDecl && PrevDecl->isTemplateParameter()) {
Douglas Gregor72c3f312008-12-05 18:15:24 +00005713 // Maybe we will complain about the shadowed template parameter.
5714 DiagnoseTemplateParameterShadow(IdLoc, PrevDecl);
5715 // Just pretend that we didn't see the previous declaration.
5716 PrevDecl = 0;
5717 }
5718
5719 if (PrevDecl) {
Argyrios Kyrtzidis0ff12f02008-07-16 21:01:53 +00005720 // When in C++, we may get a TagDecl with the same name; in this case the
5721 // enum constant will 'hide' the tag.
5722 assert((getLangOptions().CPlusPlus || !isa<TagDecl>(PrevDecl)) &&
5723 "Received TagDecl when not in C++!");
Argyrios Kyrtzidis15a12d02008-09-09 21:18:04 +00005724 if (!isa<TagDecl>(PrevDecl) && isDeclInScope(PrevDecl, CurContext, S)) {
Reid Spencer5f016e22007-07-11 17:01:13 +00005725 if (isa<EnumConstantDecl>(PrevDecl))
Chris Lattner3c73c412008-11-19 08:23:25 +00005726 Diag(IdLoc, diag::err_redefinition_of_enumerator) << Id;
Reid Spencer5f016e22007-07-11 17:01:13 +00005727 else
Chris Lattner3c73c412008-11-19 08:23:25 +00005728 Diag(IdLoc, diag::err_redefinition) << Id;
Chris Lattner5f4a6822008-11-23 23:12:31 +00005729 Diag(PrevDecl->getLocation(), diag::note_previous_definition);
Chris Lattnerf306f862009-02-28 19:37:57 +00005730 if (Val) Val->Destroy(Context);
Chris Lattnerb28317a2009-03-28 19:18:32 +00005731 return DeclPtrTy();
Reid Spencer5f016e22007-07-11 17:01:13 +00005732 }
5733 }
5734
Douglas Gregor879fd492009-03-17 19:05:46 +00005735 EnumConstantDecl *New = CheckEnumConstant(TheEnumDecl, LastEnumConst,
5736 IdLoc, Id, Owned(Val));
Chris Lattner421a23d2007-08-27 21:16:18 +00005737
Reid Spencer5f016e22007-07-11 17:01:13 +00005738 // Register this decl in the current scope stack.
John McCall92f88312010-01-23 00:46:32 +00005739 if (New) {
5740 New->setAccess(TheEnumDecl->getAccess());
Douglas Gregor879fd492009-03-17 19:05:46 +00005741 PushOnScopeChains(New, S);
John McCall92f88312010-01-23 00:46:32 +00005742 }
Douglas Gregor45579f52008-12-17 02:04:30 +00005743
Chris Lattnerb28317a2009-03-28 19:18:32 +00005744 return DeclPtrTy::make(New);
Reid Spencer5f016e22007-07-11 17:01:13 +00005745}
5746
Mike Stumpc6e35aa2009-05-16 07:06:02 +00005747void Sema::ActOnEnumBody(SourceLocation EnumLoc, SourceLocation LBraceLoc,
5748 SourceLocation RBraceLoc, DeclPtrTy EnumDeclX,
Edward O'Callaghanfee13812009-08-08 14:36:57 +00005749 DeclPtrTy *Elements, unsigned NumElements,
5750 Scope *S, AttributeList *Attr) {
Chris Lattnerb28317a2009-03-28 19:18:32 +00005751 EnumDecl *Enum = cast<EnumDecl>(EnumDeclX.getAs<Decl>());
Douglas Gregor074149e2009-01-05 19:45:36 +00005752 QualType EnumType = Context.getTypeDeclType(Enum);
Edward O'Callaghanfee13812009-08-08 14:36:57 +00005753
5754 if (Attr)
5755 ProcessDeclAttributeList(S, Enum, Attr);
Mike Stump1eb44332009-09-09 15:08:12 +00005756
Eli Friedmaned0716b2009-12-11 01:34:50 +00005757 if (Enum->isDependentType()) {
5758 for (unsigned i = 0; i != NumElements; ++i) {
5759 EnumConstantDecl *ECD =
5760 cast_or_null<EnumConstantDecl>(Elements[i].getAs<Decl>());
5761 if (!ECD) continue;
5762
5763 ECD->setType(EnumType);
5764 }
5765
5766 Enum->completeDefinition(Context, Context.DependentTy, Context.DependentTy);
5767 return;
5768 }
5769
Chris Lattnere37f0be2007-08-28 05:10:31 +00005770 // TODO: If the result value doesn't fit in an int, it must be a long or long
5771 // long value. ISO C does not support this, but GCC does as an extension,
5772 // emit a warning.
Chris Lattner98be4942008-03-05 18:54:05 +00005773 unsigned IntWidth = Context.Target.getIntWidth();
Edward O'Callaghanfee13812009-08-08 14:36:57 +00005774 unsigned CharWidth = Context.Target.getCharWidth();
5775 unsigned ShortWidth = Context.Target.getShortWidth();
Mike Stump1eb44332009-09-09 15:08:12 +00005776
Chris Lattnerac609682007-08-28 06:15:15 +00005777 // Verify that all the values are okay, compute the size of the values, and
5778 // reverse the list.
5779 unsigned NumNegativeBits = 0;
5780 unsigned NumPositiveBits = 0;
Mike Stump1eb44332009-09-09 15:08:12 +00005781
Chris Lattnerac609682007-08-28 06:15:15 +00005782 // Keep track of whether all elements have type int.
5783 bool AllElementsInt = true;
Mike Stump1eb44332009-09-09 15:08:12 +00005784
Reid Spencer5f016e22007-07-11 17:01:13 +00005785 for (unsigned i = 0; i != NumElements; ++i) {
5786 EnumConstantDecl *ECD =
Chris Lattnerb28317a2009-03-28 19:18:32 +00005787 cast_or_null<EnumConstantDecl>(Elements[i].getAs<Decl>());
Reid Spencer5f016e22007-07-11 17:01:13 +00005788 if (!ECD) continue; // Already issued a diagnostic.
Mike Stump1eb44332009-09-09 15:08:12 +00005789
Chris Lattner211a30e2007-08-28 05:27:00 +00005790 // If the enum value doesn't fit in an int, emit an extension warning.
Chris Lattner211a30e2007-08-28 05:27:00 +00005791 const llvm::APSInt &InitVal = ECD->getInitVal();
Chris Lattnera73349d2008-02-26 00:33:57 +00005792 assert(InitVal.getBitWidth() >= IntWidth &&
5793 "Should have promoted value to int");
Eli Friedman2aaad632009-12-16 20:30:08 +00005794 if (!getLangOptions().CPlusPlus && InitVal.getBitWidth() > IntWidth) {
Chris Lattner211a30e2007-08-28 05:27:00 +00005795 llvm::APSInt V(InitVal);
5796 V.trunc(IntWidth);
5797 V.extend(InitVal.getBitWidth());
5798 if (V != InitVal)
Chris Lattnerf3a41af2008-11-20 06:38:18 +00005799 Diag(ECD->getLocation(), diag::ext_enum_value_not_int)
5800 << InitVal.toString(10);
Chris Lattner211a30e2007-08-28 05:27:00 +00005801 }
Mike Stump1eb44332009-09-09 15:08:12 +00005802
Chris Lattnerac609682007-08-28 06:15:15 +00005803 // Keep track of the size of positive and negative values.
Chris Lattnera73349d2008-02-26 00:33:57 +00005804 if (InitVal.isUnsigned() || InitVal.isNonNegative())
Chris Lattner21dd8212008-01-14 21:47:29 +00005805 NumPositiveBits = std::max(NumPositiveBits,
5806 (unsigned)InitVal.getActiveBits());
Chris Lattnerac609682007-08-28 06:15:15 +00005807 else
Chris Lattner21dd8212008-01-14 21:47:29 +00005808 NumNegativeBits = std::max(NumNegativeBits,
5809 (unsigned)InitVal.getMinSignedBits());
Reid Spencer5f016e22007-07-11 17:01:13 +00005810
Chris Lattnerac609682007-08-28 06:15:15 +00005811 // Keep track of whether every enum element has type int (very commmon).
5812 if (AllElementsInt)
Mike Stump1eb44332009-09-09 15:08:12 +00005813 AllElementsInt = ECD->getType() == Context.IntTy;
Reid Spencer5f016e22007-07-11 17:01:13 +00005814 }
Mike Stump1eb44332009-09-09 15:08:12 +00005815
Chris Lattnerac609682007-08-28 06:15:15 +00005816 // Figure out the type that should be used for this enum.
Edward O'Callaghanfee13812009-08-08 14:36:57 +00005817 // FIXME: Support -fshort-enums.
Chris Lattnerac609682007-08-28 06:15:15 +00005818 QualType BestType;
Chris Lattnerb7f6e082007-08-29 17:31:48 +00005819 unsigned BestWidth;
Edward O'Callaghanfee13812009-08-08 14:36:57 +00005820
John McCall842aef82009-12-09 09:09:27 +00005821 // C++0x N3000 [conv.prom]p3:
5822 // An rvalue of an unscoped enumeration type whose underlying
5823 // type is not fixed can be converted to an rvalue of the first
5824 // of the following types that can represent all the values of
5825 // the enumeration: int, unsigned int, long int, unsigned long
5826 // int, long long int, or unsigned long long int.
5827 // C99 6.4.4.3p2:
5828 // An identifier declared as an enumeration constant has type int.
5829 // The C99 rule is modified by a gcc extension
5830 QualType BestPromotionType;
5831
Edward O'Callaghanfee13812009-08-08 14:36:57 +00005832 bool Packed = Enum->getAttr<PackedAttr>() ? true : false;
5833
Chris Lattnerac609682007-08-28 06:15:15 +00005834 if (NumNegativeBits) {
Mike Stump1eb44332009-09-09 15:08:12 +00005835 // If there is a negative value, figure out the smallest integer type (of
Chris Lattnerac609682007-08-28 06:15:15 +00005836 // int/long/longlong) that fits.
Edward O'Callaghanfee13812009-08-08 14:36:57 +00005837 // If it's packed, check also if it fits a char or a short.
5838 if (Packed && NumNegativeBits <= CharWidth && NumPositiveBits < CharWidth) {
John McCall842aef82009-12-09 09:09:27 +00005839 BestType = Context.SignedCharTy;
5840 BestWidth = CharWidth;
Mike Stump1eb44332009-09-09 15:08:12 +00005841 } else if (Packed && NumNegativeBits <= ShortWidth &&
Edward O'Callaghanfee13812009-08-08 14:36:57 +00005842 NumPositiveBits < ShortWidth) {
John McCall842aef82009-12-09 09:09:27 +00005843 BestType = Context.ShortTy;
5844 BestWidth = ShortWidth;
5845 } else if (NumNegativeBits <= IntWidth && NumPositiveBits < IntWidth) {
Chris Lattnerac609682007-08-28 06:15:15 +00005846 BestType = Context.IntTy;
Chris Lattnerb7f6e082007-08-29 17:31:48 +00005847 BestWidth = IntWidth;
5848 } else {
Chris Lattner98be4942008-03-05 18:54:05 +00005849 BestWidth = Context.Target.getLongWidth();
Mike Stump1eb44332009-09-09 15:08:12 +00005850
John McCall842aef82009-12-09 09:09:27 +00005851 if (NumNegativeBits <= BestWidth && NumPositiveBits < BestWidth) {
Chris Lattnerac609682007-08-28 06:15:15 +00005852 BestType = Context.LongTy;
John McCall842aef82009-12-09 09:09:27 +00005853 } else {
Chris Lattner98be4942008-03-05 18:54:05 +00005854 BestWidth = Context.Target.getLongLongWidth();
Mike Stump1eb44332009-09-09 15:08:12 +00005855
Chris Lattnerb7f6e082007-08-29 17:31:48 +00005856 if (NumNegativeBits > BestWidth || NumPositiveBits >= BestWidth)
Chris Lattnerac609682007-08-28 06:15:15 +00005857 Diag(Enum->getLocation(), diag::warn_enum_too_large);
5858 BestType = Context.LongLongTy;
5859 }
5860 }
John McCall842aef82009-12-09 09:09:27 +00005861 BestPromotionType = (BestWidth <= IntWidth ? Context.IntTy : BestType);
Chris Lattnerac609682007-08-28 06:15:15 +00005862 } else {
5863 // If there is no negative value, figure out which of uint, ulong, ulonglong
5864 // fits.
Edward O'Callaghanfee13812009-08-08 14:36:57 +00005865 // If it's packed, check also if it fits a char or a short.
5866 if (Packed && NumPositiveBits <= CharWidth) {
John McCall842aef82009-12-09 09:09:27 +00005867 BestType = Context.UnsignedCharTy;
5868 BestPromotionType = Context.IntTy;
5869 BestWidth = CharWidth;
Edward O'Callaghanfee13812009-08-08 14:36:57 +00005870 } else if (Packed && NumPositiveBits <= ShortWidth) {
John McCall842aef82009-12-09 09:09:27 +00005871 BestType = Context.UnsignedShortTy;
5872 BestPromotionType = Context.IntTy;
5873 BestWidth = ShortWidth;
5874 } else if (NumPositiveBits <= IntWidth) {
Chris Lattnerac609682007-08-28 06:15:15 +00005875 BestType = Context.UnsignedIntTy;
Chris Lattnerb7f6e082007-08-29 17:31:48 +00005876 BestWidth = IntWidth;
John McCall842aef82009-12-09 09:09:27 +00005877 BestPromotionType = (NumPositiveBits == BestWidth
5878 ? Context.UnsignedIntTy : Context.IntTy);
Chris Lattnerb7f6e082007-08-29 17:31:48 +00005879 } else if (NumPositiveBits <=
Chris Lattner98be4942008-03-05 18:54:05 +00005880 (BestWidth = Context.Target.getLongWidth())) {
Chris Lattnerac609682007-08-28 06:15:15 +00005881 BestType = Context.UnsignedLongTy;
John McCall842aef82009-12-09 09:09:27 +00005882 BestPromotionType = (NumPositiveBits == BestWidth
5883 ? Context.UnsignedLongTy : Context.LongTy);
Chris Lattner98be4942008-03-05 18:54:05 +00005884 } else {
5885 BestWidth = Context.Target.getLongLongWidth();
Chris Lattnerb7f6e082007-08-29 17:31:48 +00005886 assert(NumPositiveBits <= BestWidth &&
Chris Lattnerac609682007-08-28 06:15:15 +00005887 "How could an initializer get larger than ULL?");
5888 BestType = Context.UnsignedLongLongTy;
John McCall842aef82009-12-09 09:09:27 +00005889 BestPromotionType = (NumPositiveBits == BestWidth
5890 ? Context.UnsignedLongLongTy : Context.LongLongTy);
Chris Lattnerac609682007-08-28 06:15:15 +00005891 }
5892 }
Mike Stump1eb44332009-09-09 15:08:12 +00005893
John McCall842aef82009-12-09 09:09:27 +00005894 // If we're in C and the promotion type is larger than an int, just
5895 // use the underlying type, which is generally the unsigned integer
5896 // type of the same rank as the promotion type. This is how the gcc
5897 // extension works.
5898 if (!getLangOptions().CPlusPlus && BestPromotionType != Context.IntTy)
5899 BestPromotionType = BestType;
5900
Chris Lattnerb7f6e082007-08-29 17:31:48 +00005901 // Loop over all of the enumerator constants, changing their types to match
5902 // the type of the enum if needed.
5903 for (unsigned i = 0; i != NumElements; ++i) {
5904 EnumConstantDecl *ECD =
Chris Lattnerb28317a2009-03-28 19:18:32 +00005905 cast_or_null<EnumConstantDecl>(Elements[i].getAs<Decl>());
Chris Lattnerb7f6e082007-08-29 17:31:48 +00005906 if (!ECD) continue; // Already issued a diagnostic.
5907
5908 // Standard C says the enumerators have int type, but we allow, as an
5909 // extension, the enumerators to be larger than int size. If each
5910 // enumerator value fits in an int, type it as an int, otherwise type it the
5911 // same as the enumerator decl itself. This means that in "enum { X = 1U }"
5912 // that X has type 'int', not 'unsigned'.
Eli Friedman29a7f332009-12-10 22:29:29 +00005913 if (!getLangOptions().CPlusPlus && ECD->getType() == Context.IntTy)
5914 continue;
Chris Lattnerb7f6e082007-08-29 17:31:48 +00005915
5916 // Determine whether the value fits into an int.
5917 llvm::APSInt InitVal = ECD->getInitVal();
5918 bool FitsInInt;
5919 if (InitVal.isUnsigned() || !InitVal.isNegative())
5920 FitsInInt = InitVal.getActiveBits() < IntWidth;
5921 else
5922 FitsInInt = InitVal.getMinSignedBits() <= IntWidth;
5923
5924 // If it fits into an integer type, force it. Otherwise force it to match
5925 // the enum decl type.
5926 QualType NewTy;
5927 unsigned NewWidth;
5928 bool NewSign;
Eli Friedman29a7f332009-12-10 22:29:29 +00005929 if (FitsInInt && !getLangOptions().CPlusPlus) {
Chris Lattnerb7f6e082007-08-29 17:31:48 +00005930 NewTy = Context.IntTy;
5931 NewWidth = IntWidth;
5932 NewSign = true;
5933 } else if (ECD->getType() == BestType) {
5934 // Already the right type!
Douglas Gregorc9467cf2008-12-12 02:00:36 +00005935 if (getLangOptions().CPlusPlus)
5936 // C++ [dcl.enum]p4: Following the closing brace of an
5937 // enum-specifier, each enumerator has the type of its
Mike Stump1eb44332009-09-09 15:08:12 +00005938 // enumeration.
Douglas Gregorc9467cf2008-12-12 02:00:36 +00005939 ECD->setType(EnumType);
Chris Lattnerb7f6e082007-08-29 17:31:48 +00005940 continue;
5941 } else {
5942 NewTy = BestType;
5943 NewWidth = BestWidth;
5944 NewSign = BestType->isSignedIntegerType();
5945 }
5946
5947 // Adjust the APSInt value.
5948 InitVal.extOrTrunc(NewWidth);
5949 InitVal.setIsSigned(NewSign);
5950 ECD->setInitVal(InitVal);
Mike Stump1eb44332009-09-09 15:08:12 +00005951
Chris Lattnerb7f6e082007-08-29 17:31:48 +00005952 // Adjust the Expr initializer and type.
Chris Lattner13fd4162009-01-15 19:19:42 +00005953 if (ECD->getInitExpr())
Mike Stump1eb44332009-09-09 15:08:12 +00005954 ECD->setInitExpr(new (Context) ImplicitCastExpr(NewTy,
Eli Friedman73c39ab2009-10-20 08:27:19 +00005955 CastExpr::CK_IntegralCast,
Mike Stump1eb44332009-09-09 15:08:12 +00005956 ECD->getInitExpr(),
Ted Kremenek8189cde2009-02-07 01:47:29 +00005957 /*isLvalue=*/false));
Douglas Gregorc9467cf2008-12-12 02:00:36 +00005958 if (getLangOptions().CPlusPlus)
5959 // C++ [dcl.enum]p4: Following the closing brace of an
5960 // enum-specifier, each enumerator has the type of its
Mike Stump1eb44332009-09-09 15:08:12 +00005961 // enumeration.
Douglas Gregorc9467cf2008-12-12 02:00:36 +00005962 ECD->setType(EnumType);
5963 else
5964 ECD->setType(NewTy);
Chris Lattnerb7f6e082007-08-29 17:31:48 +00005965 }
Mike Stump1eb44332009-09-09 15:08:12 +00005966
John McCall842aef82009-12-09 09:09:27 +00005967 Enum->completeDefinition(Context, BestType, BestPromotionType);
Reid Spencer5f016e22007-07-11 17:01:13 +00005968}
5969
Chris Lattnerb28317a2009-03-28 19:18:32 +00005970Sema::DeclPtrTy Sema::ActOnFileScopeAsmDecl(SourceLocation Loc,
5971 ExprArg expr) {
Anders Carlssonf1b1d592009-05-01 19:30:39 +00005972 StringLiteral *AsmString = cast<StringLiteral>(expr.takeAs<Expr>());
Sebastian Redl798d1192008-12-13 16:23:55 +00005973
Douglas Gregor4fe0c8e2009-05-30 00:08:05 +00005974 FileScopeAsmDecl *New = FileScopeAsmDecl::Create(Context, CurContext,
5975 Loc, AsmString);
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00005976 CurContext->addDecl(New);
Douglas Gregor4fe0c8e2009-05-30 00:08:05 +00005977 return DeclPtrTy::make(New);
Anders Carlssondfab6cb2008-02-08 00:33:21 +00005978}
Eli Friedmanc49f19b2009-06-05 02:44:36 +00005979
5980void Sema::ActOnPragmaWeakID(IdentifierInfo* Name,
5981 SourceLocation PragmaLoc,
5982 SourceLocation NameLoc) {
John McCallf36e02d2009-10-09 21:13:30 +00005983 Decl *PrevDecl = LookupSingleName(TUScope, Name, LookupOrdinaryName);
Eli Friedmanc49f19b2009-06-05 02:44:36 +00005984
Eli Friedmanc49f19b2009-06-05 02:44:36 +00005985 if (PrevDecl) {
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +00005986 PrevDecl->addAttr(::new (Context) WeakAttr());
Ryan Flynne25ff832009-07-30 03:15:39 +00005987 } else {
5988 (void)WeakUndeclaredIdentifiers.insert(
5989 std::pair<IdentifierInfo*,WeakInfo>
5990 (Name, WeakInfo((IdentifierInfo*)0, NameLoc)));
Eli Friedmanc49f19b2009-06-05 02:44:36 +00005991 }
Eli Friedmanc49f19b2009-06-05 02:44:36 +00005992}
5993
5994void Sema::ActOnPragmaWeakAlias(IdentifierInfo* Name,
5995 IdentifierInfo* AliasName,
5996 SourceLocation PragmaLoc,
5997 SourceLocation NameLoc,
5998 SourceLocation AliasNameLoc) {
John McCallf36e02d2009-10-09 21:13:30 +00005999 Decl *PrevDecl = LookupSingleName(TUScope, AliasName, LookupOrdinaryName);
Ryan Flynne25ff832009-07-30 03:15:39 +00006000 WeakInfo W = WeakInfo(Name, NameLoc);
Eli Friedmanc49f19b2009-06-05 02:44:36 +00006001
Eli Friedmanc49f19b2009-06-05 02:44:36 +00006002 if (PrevDecl) {
Ryan Flynne25ff832009-07-30 03:15:39 +00006003 if (!PrevDecl->hasAttr<AliasAttr>())
6004 if (NamedDecl *ND = dyn_cast<NamedDecl>(PrevDecl))
Ryan Flynn7b1fdbd2009-07-31 02:52:19 +00006005 DeclApplyPragmaWeak(TUScope, ND, W);
Ryan Flynne25ff832009-07-30 03:15:39 +00006006 } else {
6007 (void)WeakUndeclaredIdentifiers.insert(
6008 std::pair<IdentifierInfo*,WeakInfo>(AliasName, W));
Eli Friedmanc49f19b2009-06-05 02:44:36 +00006009 }
Eli Friedmanc49f19b2009-06-05 02:44:36 +00006010}