blob: 249cbef38a1fd50720ffa706244e55dd652772c7 [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"
Anders Carlssonc44eec62008-07-03 04:20:39 +000017#include "clang/AST/APValue.h"
Chris Lattnere1e79852008-02-06 00:51:33 +000018#include "clang/AST/ASTConsumer.h"
Reid Spencer5f016e22007-07-11 17:01:13 +000019#include "clang/AST/ASTContext.h"
Douglas Gregora8f32e02009-10-06 17:59:45 +000020#include "clang/AST/CXXInheritance.h"
Douglas Gregoraaba5e32009-02-04 19:02:06 +000021#include "clang/AST/DeclTemplate.h"
Chris Lattner6b6b5372008-06-26 18:38:35 +000022#include "clang/AST/ExprCXX.h"
Sebastian Redld3a413d2009-04-26 20:35:05 +000023#include "clang/AST/StmtCXX.h"
Reid Spencer5f016e22007-07-11 17:01:13 +000024#include "clang/Parse/DeclSpec.h"
Douglas Gregora786fdb2009-10-13 23:27:22 +000025#include "clang/Parse/ParseDiagnostic.h"
Douglas Gregor314b97f2009-11-10 19:49:08 +000026#include "clang/Parse/Template.h"
Anders Carlssonb7906612009-08-26 23:45:07 +000027#include "clang/Basic/PartialDiagnostic.h"
Steve Naroff4c49a6c2008-01-30 23:46:05 +000028#include "clang/Basic/SourceManager.h"
Anders Carlssonb7906612009-08-26 23:45:07 +000029#include "clang/Basic/TargetInfo.h"
Steve Naroff4c49a6c2008-01-30 23:46:05 +000030// FIXME: layering (ideally, Sema shouldn't be dependent on Lex API's)
Chris Lattnere1e79852008-02-06 00:51:33 +000031#include "clang/Lex/Preprocessor.h"
Mike Stump1eb44332009-09-09 15:08:12 +000032#include "clang/Lex/HeaderSearch.h"
John McCall66755862009-12-24 09:58:38 +000033#include "llvm/ADT/Triple.h"
Douglas Gregor6ed40e32008-12-23 21:05:05 +000034#include <algorithm>
Douglas Gregor9a8c9a22009-09-28 21:14:19 +000035#include <cstring>
Douglas Gregor6ed40e32008-12-23 21:05:05 +000036#include <functional>
Reid Spencer5f016e22007-07-11 17:01:13 +000037using namespace clang;
38
Chris Lattner21ff9c92009-03-05 01:25:28 +000039/// getDeclName - Return a pretty name for the specified decl if possible, or
Mike Stump1eb44332009-09-09 15:08:12 +000040/// an empty string if not. This is used for pretty crash reporting.
Chris Lattnerb28317a2009-03-28 19:18:32 +000041std::string Sema::getDeclName(DeclPtrTy d) {
42 Decl *D = d.getAs<Decl>();
Chris Lattner21ff9c92009-03-05 01:25:28 +000043 if (NamedDecl *DN = dyn_cast_or_null<NamedDecl>(D))
44 return DN->getQualifiedNameAsString();
45 return "";
46}
47
Chris Lattner682bf922009-03-29 16:50:03 +000048Sema::DeclGroupPtrTy Sema::ConvertDeclToDeclGroup(DeclPtrTy Ptr) {
49 return DeclGroupPtrTy::make(DeclGroupRef(Ptr.getAs<Decl>()));
50}
51
Douglas Gregord6efafa2009-02-04 19:16:12 +000052/// \brief If the identifier refers to a type name within this scope,
53/// return the declaration of that type.
54///
55/// This routine performs ordinary name lookup of the identifier II
56/// within the given scope, with optional C++ scope specifier SS, to
Douglas Gregor1a51b4a2009-02-09 15:09:02 +000057/// determine whether the name refers to a type. If so, returns an
58/// opaque pointer (actually a QualType) corresponding to that
59/// type. Otherwise, returns NULL.
Douglas Gregord6efafa2009-02-04 19:16:12 +000060///
61/// If name lookup results in an ambiguity, this routine will complain
62/// and then return NULL.
Douglas Gregor1a51b4a2009-02-09 15:09:02 +000063Sema::TypeTy *Sema::getTypeName(IdentifierInfo &II, SourceLocation NameLoc,
Jeffrey Yasskin9ab14542010-04-08 16:38:48 +000064 Scope *S, CXXScopeSpec *SS,
Douglas Gregorf6e6fc82009-11-20 22:03:38 +000065 bool isClassName,
66 TypeTy *ObjectTypePtr) {
67 // Determine where we will perform name lookup.
68 DeclContext *LookupCtx = 0;
69 if (ObjectTypePtr) {
70 QualType ObjectType = QualType::getFromOpaquePtr(ObjectTypePtr);
71 if (ObjectType->isRecordType())
72 LookupCtx = computeDeclContext(ObjectType);
Jeffrey Yasskinedc28772010-04-07 23:29:58 +000073 } else if (SS && SS->isNotEmpty()) {
Douglas Gregorf6e6fc82009-11-20 22:03:38 +000074 LookupCtx = computeDeclContext(*SS, false);
75
76 if (!LookupCtx) {
77 if (isDependentScopeSpecifier(*SS)) {
78 // C++ [temp.res]p3:
79 // A qualified-id that refers to a type and in which the
80 // nested-name-specifier depends on a template-parameter (14.6.2)
81 // shall be prefixed by the keyword typename to indicate that the
82 // qualified-id denotes a type, forming an
83 // elaborated-type-specifier (7.1.5.3).
84 //
85 // We therefore do not perform any name lookup if the result would
86 // refer to a member of an unknown specialization.
87 if (!isClassName)
88 return 0;
89
90 // We know from the grammar that this name refers to a type, so build a
Douglas Gregor4714c122010-03-31 17:34:00 +000091 // DependentNameType node to describe the type.
Douglas Gregor107de902010-04-24 15:35:55 +000092 return CheckTypenameType(ETK_None,
Abramo Bagnarae4da7a02010-05-19 21:37:53 +000093 (NestedNameSpecifier *)SS->getScopeRep(), II,
94 SourceLocation(), SS->getRange(), NameLoc
95 ).getAsOpaquePtr();
Douglas Gregorf6e6fc82009-11-20 22:03:38 +000096 }
97
Douglas Gregor42c39f32009-08-26 18:27:52 +000098 return 0;
Douglas Gregorf6e6fc82009-11-20 22:03:38 +000099 }
100
John McCall77bb1aa2010-05-01 00:40:08 +0000101 if (!LookupCtx->isDependentContext() &&
102 RequireCompleteDeclContext(*SS, LookupCtx))
Douglas Gregorf6e6fc82009-11-20 22:03:38 +0000103 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 if (T.isNull())
192 T = Context.getTypeDeclType(TD);
193
Douglas Gregore6258932009-03-19 00:39:20 +0000194 if (SS)
Abramo Bagnara465d41b2010-05-11 21:36:43 +0000195 T = getElaboratedType(ETK_None, *SS, T);
Chris Lattner10ca3372009-10-25 17:16:46 +0000196
197 } else if (ObjCInterfaceDecl *IDecl = dyn_cast<ObjCInterfaceDecl>(IIDecl)) {
Chris Lattner10ca3372009-10-25 17:16:46 +0000198 T = Context.getObjCInterfaceType(IDecl);
John McCall7ba107a2009-11-18 02:36:19 +0000199 } else if (UnresolvedUsingTypenameDecl *UUDecl =
200 dyn_cast<UnresolvedUsingTypenameDecl>(IIDecl)) {
201 // FIXME: preserve source structure information.
Douglas Gregor4a2023f2010-03-31 20:19:30 +0000202 T = Context.getDependentNameType(ETK_None,
203 UUDecl->getTargetNestedNameSpecifier(),
204 &II);
John McCalla24dc2e2009-11-17 02:14:36 +0000205 } else {
206 // If it's not plausibly a type, suppress diagnostics.
207 Result.suppressDiagnostics();
Chris Lattner10ca3372009-10-25 17:16:46 +0000208 return 0;
John McCalla24dc2e2009-11-17 02:14:36 +0000209 }
Douglas Gregore4e5b052009-03-19 00:18:19 +0000210
Chris Lattner10ca3372009-10-25 17:16:46 +0000211 return T.getAsOpaquePtr();
Reid Spencer5f016e22007-07-11 17:01:13 +0000212}
213
Chris Lattner4c97d762009-04-12 21:49:30 +0000214/// isTagName() - This method is called *for error recovery purposes only*
215/// to determine if the specified name is a valid tag name ("struct foo"). If
216/// so, this returns the TST for the tag corresponding to it (TST_enum,
217/// TST_union, TST_struct, TST_class). This is used to diagnose cases in C
218/// where the user forgot to specify the tag.
219DeclSpec::TST Sema::isTagName(IdentifierInfo &II, Scope *S) {
220 // Do a tag name lookup in this scope.
John McCalla24dc2e2009-11-17 02:14:36 +0000221 LookupResult R(*this, &II, SourceLocation(), LookupTagName);
222 LookupName(R, S, false);
223 R.suppressDiagnostics();
224 if (R.getResultKind() == LookupResult::Found)
John McCall1bcee0a2009-12-02 08:25:40 +0000225 if (const TagDecl *TD = R.getAsSingle<TagDecl>()) {
Chris Lattner4c97d762009-04-12 21:49:30 +0000226 switch (TD->getTagKind()) {
Abramo Bagnara465d41b2010-05-11 21:36:43 +0000227 default: return DeclSpec::TST_unspecified;
228 case TTK_Struct: return DeclSpec::TST_struct;
229 case TTK_Union: return DeclSpec::TST_union;
230 case TTK_Class: return DeclSpec::TST_class;
231 case TTK_Enum: return DeclSpec::TST_enum;
Chris Lattner4c97d762009-04-12 21:49:30 +0000232 }
233 }
Mike Stump1eb44332009-09-09 15:08:12 +0000234
Chris Lattner4c97d762009-04-12 21:49:30 +0000235 return DeclSpec::TST_unspecified;
236}
237
Douglas Gregora786fdb2009-10-13 23:27:22 +0000238bool Sema::DiagnoseUnknownTypeName(const IdentifierInfo &II,
239 SourceLocation IILoc,
240 Scope *S,
Jeffrey Yasskin9ab14542010-04-08 16:38:48 +0000241 CXXScopeSpec *SS,
Douglas Gregora786fdb2009-10-13 23:27:22 +0000242 TypeTy *&SuggestedType) {
243 // We don't have anything to suggest (yet).
244 SuggestedType = 0;
245
Douglas Gregor546be3c2009-12-30 17:04:44 +0000246 // There may have been a typo in the name of the type. Look up typo
247 // results, in case we have something that we can suggest.
248 LookupResult Lookup(*this, &II, IILoc, LookupOrdinaryName,
249 NotForRedeclaration);
250
Douglas Gregoraaf87162010-04-14 20:04:41 +0000251 if (DeclarationName Corrected = CorrectTypo(Lookup, S, SS, 0, 0, CTC_Type)) {
252 if (NamedDecl *Result = Lookup.getAsSingle<NamedDecl>()) {
253 if ((isa<TypeDecl>(Result) || isa<ObjCInterfaceDecl>(Result)) &&
254 !Result->isInvalidDecl()) {
255 // We found a similarly-named type or interface; suggest that.
256 if (!SS || !SS->isSet())
257 Diag(IILoc, diag::err_unknown_typename_suggest)
258 << &II << Lookup.getLookupName()
259 << FixItHint::CreateReplacement(SourceRange(IILoc),
260 Result->getNameAsString());
261 else if (DeclContext *DC = computeDeclContext(*SS, false))
262 Diag(IILoc, diag::err_unknown_nested_typename_suggest)
263 << &II << DC << Lookup.getLookupName() << SS->getRange()
264 << FixItHint::CreateReplacement(SourceRange(IILoc),
265 Result->getNameAsString());
266 else
267 llvm_unreachable("could not have corrected a typo here");
Douglas Gregor546be3c2009-12-30 17:04:44 +0000268
Douglas Gregoraaf87162010-04-14 20:04:41 +0000269 Diag(Result->getLocation(), diag::note_previous_decl)
270 << Result->getDeclName();
271
272 SuggestedType = getTypeName(*Result->getIdentifier(), IILoc, S, SS);
273 return true;
274 }
275 } else if (Lookup.empty()) {
276 // We corrected to a keyword.
277 // FIXME: Actually recover with the keyword we suggest, and emit a fix-it.
278 Diag(IILoc, diag::err_unknown_typename_suggest)
279 << &II << Corrected;
280 return true;
Douglas Gregor546be3c2009-12-30 17:04:44 +0000281 }
282 }
283
Jeffrey Yasskinc173be22010-04-08 21:04:54 +0000284 if (getLangOptions().CPlusPlus) {
285 // See if II is a class template that the user forgot to pass arguments to.
286 UnqualifiedId Name;
287 Name.setIdentifier(&II, IILoc);
288 CXXScopeSpec EmptySS;
289 TemplateTy TemplateResult;
Douglas Gregor1fd6d442010-05-21 23:18:07 +0000290 bool MemberOfUnknownSpecialization;
291 if (isTemplateName(S, SS ? *SS : EmptySS, Name, 0, true, TemplateResult,
292 MemberOfUnknownSpecialization) == TNK_Type_template) {
Jeffrey Yasskinc173be22010-04-08 21:04:54 +0000293 TemplateName TplName = TemplateResult.getAsVal<TemplateName>();
294 Diag(IILoc, diag::err_template_missing_args) << TplName;
295 if (TemplateDecl *TplDecl = TplName.getAsTemplateDecl()) {
296 Diag(TplDecl->getLocation(), diag::note_template_decl_here)
297 << TplDecl->getTemplateParameters()->getSourceRange();
298 }
299 return true;
300 }
301 }
302
Douglas Gregora786fdb2009-10-13 23:27:22 +0000303 // FIXME: Should we move the logic that tries to recover from a missing tag
304 // (struct, union, enum) from Parser::ParseImplicitInt here, instead?
305
Douglas Gregor546be3c2009-12-30 17:04:44 +0000306 if (!SS || (!SS->isSet() && !SS->isInvalid()))
Douglas Gregora786fdb2009-10-13 23:27:22 +0000307 Diag(IILoc, diag::err_unknown_typename) << &II;
308 else if (DeclContext *DC = computeDeclContext(*SS, false))
309 Diag(IILoc, diag::err_typename_nested_not_found)
310 << &II << DC << SS->getRange();
311 else if (isDependentScopeSpecifier(*SS)) {
312 Diag(SS->getRange().getBegin(), diag::err_typename_missing)
Daniel Dunbar01eb9b92009-10-18 21:17:35 +0000313 << (NestedNameSpecifier *)SS->getScopeRep() << II.getName()
Douglas Gregora786fdb2009-10-13 23:27:22 +0000314 << SourceRange(SS->getRange().getBegin(), IILoc)
Douglas Gregor849b2432010-03-31 17:46:05 +0000315 << FixItHint::CreateInsertion(SS->getRange().getBegin(), "typename ");
Douglas Gregora786fdb2009-10-13 23:27:22 +0000316 SuggestedType = ActOnTypenameType(SourceLocation(), *SS, II, IILoc).get();
317 } else {
318 assert(SS && SS->isInvalid() &&
319 "Invalid scope specifier has already been diagnosed");
320 }
321
322 return true;
323}
Chris Lattner4c97d762009-04-12 21:49:30 +0000324
John McCall88232aa2009-08-18 00:00:49 +0000325// Determines the context to return to after temporarily entering a
326// context. This depends in an unnecessarily complicated way on the
327// exact ordering of callbacks from the parser.
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +0000328DeclContext *Sema::getContainingDC(DeclContext *DC) {
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +0000329
John McCall88232aa2009-08-18 00:00:49 +0000330 // Functions defined inline within classes aren't parsed until we've
331 // finished parsing the top-level class, so the top-level class is
332 // the context we'll need to return to.
333 if (isa<FunctionDecl>(DC)) {
334 DC = DC->getLexicalParent();
335
336 // A function not defined within a class will always return to its
337 // lexical context.
338 if (!isa<CXXRecordDecl>(DC))
339 return DC;
340
341 // A C++ inline method/friend is parsed *after* the topmost class
342 // it was declared in is fully parsed ("complete"); the topmost
343 // class is the context we need to return to.
Argyrios Kyrtzidis77407b82008-11-19 18:01:13 +0000344 while (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(DC->getLexicalParent()))
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000345 DC = RD;
346
347 // Return the declaration context of the topmost class the inline method is
348 // declared in.
349 return DC;
350 }
351
Argyrios Kyrtzidis52393042008-11-09 23:41:00 +0000352 if (isa<ObjCMethodDecl>(DC))
353 return Context.getTranslationUnitDecl();
354
Argyrios Kyrtzidis77407b82008-11-19 18:01:13 +0000355 return DC->getLexicalParent();
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000356}
357
Douglas Gregor44b43212008-12-11 16:49:14 +0000358void Sema::PushDeclContext(Scope *S, DeclContext *DC) {
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +0000359 assert(getContainingDC(DC) == CurContext &&
Zhongxing Xue50897a2008-12-08 07:14:51 +0000360 "The next DeclContext should be lexically contained in the current one.");
Chris Lattner9fdf9c62008-04-22 18:39:57 +0000361 CurContext = DC;
Douglas Gregor44b43212008-12-11 16:49:14 +0000362 S->setEntity(DC);
Chris Lattner0ed844b2008-04-04 06:12:32 +0000363}
364
Chris Lattnerb048c982008-04-06 04:47:34 +0000365void Sema::PopDeclContext() {
366 assert(CurContext && "DeclContext imbalance!");
Douglas Gregor44b43212008-12-11 16:49:14 +0000367
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +0000368 CurContext = getContainingDC(CurContext);
Chris Lattner0ed844b2008-04-04 06:12:32 +0000369}
370
Argyrios Kyrtzidis179fe1a2009-06-17 23:19:02 +0000371/// EnterDeclaratorContext - Used when we must lookup names in the context
372/// of a declarator's nested name specifier.
John McCall7a1dc562009-12-19 10:49:29 +0000373///
Argyrios Kyrtzidis1d175532009-06-17 23:15:40 +0000374void Sema::EnterDeclaratorContext(Scope *S, DeclContext *DC) {
John McCall7a1dc562009-12-19 10:49:29 +0000375 // C++0x [basic.lookup.unqual]p13:
376 // A name used in the definition of a static data member of class
377 // X (after the qualified-id of the static member) is looked up as
378 // if the name was used in a member function of X.
379 // C++0x [basic.lookup.unqual]p14:
380 // If a variable member of a namespace is defined outside of the
381 // scope of its namespace then any name used in the definition of
382 // the variable member (after the declarator-id) is looked up as
383 // if the definition of the variable member occurred in its
384 // namespace.
385 // Both of these imply that we should push a scope whose context
386 // is the semantic context of the declaration. We can't use
387 // PushDeclContext here because that context is not necessarily
388 // lexically contained in the current context. Fortunately,
389 // the containing scope should have the appropriate information.
390
391 assert(!S->getEntity() && "scope already has entity");
392
393#ifndef NDEBUG
394 Scope *Ancestor = S->getParent();
395 while (!Ancestor->getEntity()) Ancestor = Ancestor->getParent();
396 assert(Ancestor->getEntity() == CurContext && "ancestor context mismatch");
397#endif
398
Argyrios Kyrtzidis1d175532009-06-17 23:15:40 +0000399 CurContext = DC;
John McCall7a1dc562009-12-19 10:49:29 +0000400 S->setEntity(DC);
Argyrios Kyrtzidis1d175532009-06-17 23:15:40 +0000401}
402
Argyrios Kyrtzidis1d175532009-06-17 23:15:40 +0000403void Sema::ExitDeclaratorContext(Scope *S) {
John McCall7a1dc562009-12-19 10:49:29 +0000404 assert(S->getEntity() == CurContext && "Context imbalance!");
Argyrios Kyrtzidis1d175532009-06-17 23:15:40 +0000405
John McCall7a1dc562009-12-19 10:49:29 +0000406 // Switch back to the lexical context. The safety of this is
407 // enforced by an assert in EnterDeclaratorContext.
408 Scope *Ancestor = S->getParent();
409 while (!Ancestor->getEntity()) Ancestor = Ancestor->getParent();
410 CurContext = (DeclContext*) Ancestor->getEntity();
411
412 // We don't need to do anything with the scope, which is going to
413 // disappear.
Argyrios Kyrtzidis1d175532009-06-17 23:15:40 +0000414}
415
Douglas Gregorf9201e02009-02-11 23:02:49 +0000416/// \brief Determine whether we allow overloading of the function
417/// PrevDecl with another declaration.
418///
419/// This routine determines whether overloading is possible, not
420/// whether some new function is actually an overload. It will return
421/// true in C++ (where we can always provide overloads) or, as an
422/// extension, in C when the previous function is already an
423/// overloaded function declaration or has the "overloadable"
424/// attribute.
John McCall68263142009-11-18 22:49:29 +0000425static bool AllowOverloadingOfFunction(LookupResult &Previous,
426 ASTContext &Context) {
Douglas Gregorf9201e02009-02-11 23:02:49 +0000427 if (Context.getLangOptions().CPlusPlus)
428 return true;
429
John McCall68263142009-11-18 22:49:29 +0000430 if (Previous.getResultKind() == LookupResult::FoundOverloaded)
Douglas Gregorf9201e02009-02-11 23:02:49 +0000431 return true;
432
John McCall68263142009-11-18 22:49:29 +0000433 return (Previous.getResultKind() == LookupResult::Found
434 && Previous.getFoundDecl()->hasAttr<OverloadableAttr>());
Douglas Gregorf9201e02009-02-11 23:02:49 +0000435}
436
Argyrios Kyrtzidis87f3ff02008-04-12 00:47:19 +0000437/// Add this decl to the scope shadowed decl chains.
John McCallab88d972009-08-31 22:39:49 +0000438void Sema::PushOnScopeChains(NamedDecl *D, Scope *S, bool AddToContext) {
Douglas Gregor074149e2009-01-05 19:45:36 +0000439 // Move up the scope chain until we find the nearest enclosing
440 // non-transparent context. The declaration will be introduced into this
441 // scope.
Mike Stump1eb44332009-09-09 15:08:12 +0000442 while (S->getEntity() &&
Douglas Gregor074149e2009-01-05 19:45:36 +0000443 ((DeclContext *)S->getEntity())->isTransparentContext())
444 S = S->getParent();
445
Douglas Gregor6ed40e32008-12-23 21:05:05 +0000446 // Add scoped declarations into their context, so that they can be
447 // found later. Declarations without a context won't be inserted
448 // into any context.
John McCallab88d972009-08-31 22:39:49 +0000449 if (AddToContext)
450 CurContext->addDecl(D);
Douglas Gregor6ed40e32008-12-23 21:05:05 +0000451
Chandler Carruth8761d682010-02-21 07:08:09 +0000452 // Out-of-line definitions shouldn't be pushed into scope in C++.
453 // Out-of-line variable and function definitions shouldn't even in C.
454 if ((getLangOptions().CPlusPlus || isa<VarDecl>(D) || isa<FunctionDecl>(D)) &&
455 D->isOutOfLine())
456 return;
457
458 // Template instantiations should also not be pushed into scope.
459 if (isa<FunctionDecl>(D) &&
460 cast<FunctionDecl>(D)->isFunctionTemplateSpecialization())
Douglas Gregord04b1be2009-09-28 18:41:37 +0000461 return;
462
John McCallf36e02d2009-10-09 21:13:30 +0000463 // If this replaces anything in the current scope,
464 IdentifierResolver::iterator I = IdResolver.begin(D->getDeclName()),
465 IEnd = IdResolver.end();
466 for (; I != IEnd; ++I) {
467 if (S->isDeclScope(DeclPtrTy::make(*I)) && D->declarationReplaces(*I)) {
468 S->RemoveDecl(DeclPtrTy::make(*I));
469 IdResolver.RemoveDecl(*I);
Argyrios Kyrtzidis00bc6452008-05-09 23:39:43 +0000470
John McCallf36e02d2009-10-09 21:13:30 +0000471 // Should only need to replace one decl.
472 break;
Douglas Gregor516ff432009-04-24 02:57:34 +0000473 }
Argyrios Kyrtzidis00bc6452008-05-09 23:39:43 +0000474 }
Douglas Gregor8e9bebd2008-10-21 16:13:35 +0000475
John McCallf36e02d2009-10-09 21:13:30 +0000476 S->AddDecl(DeclPtrTy::make(D));
Argyrios Kyrtzidis00bc6452008-05-09 23:39:43 +0000477 IdResolver.AddDecl(D);
Argyrios Kyrtzidis87f3ff02008-04-12 00:47:19 +0000478}
479
Douglas Gregor2531c2d2009-09-28 00:47:05 +0000480bool Sema::isDeclInScope(NamedDecl *&D, DeclContext *Ctx, Scope *S) {
Douglas Gregor2531c2d2009-09-28 00:47:05 +0000481 return IdResolver.isDeclInScope(D, Ctx, Context, S);
482}
483
John McCall68263142009-11-18 22:49:29 +0000484static bool isOutOfScopePreviousDeclaration(NamedDecl *,
485 DeclContext*,
486 ASTContext&);
487
488/// Filters out lookup results that don't fall within the given scope
489/// as determined by isDeclInScope.
490static void FilterLookupForScope(Sema &SemaRef, LookupResult &R,
491 DeclContext *Ctx, Scope *S,
492 bool ConsiderLinkage) {
493 LookupResult::Filter F = R.makeFilter();
494 while (F.hasNext()) {
495 NamedDecl *D = F.next();
496
497 if (SemaRef.isDeclInScope(D, Ctx, S))
498 continue;
499
500 if (ConsiderLinkage &&
501 isOutOfScopePreviousDeclaration(D, Ctx, SemaRef.Context))
502 continue;
503
504 F.erase();
505 }
506
507 F.done();
508}
509
510static bool isUsingDecl(NamedDecl *D) {
511 return isa<UsingShadowDecl>(D) ||
512 isa<UnresolvedUsingTypenameDecl>(D) ||
513 isa<UnresolvedUsingValueDecl>(D);
514}
515
516/// Removes using shadow declarations from the lookup results.
517static void RemoveUsingDecls(LookupResult &R) {
518 LookupResult::Filter F = R.makeFilter();
519 while (F.hasNext())
520 if (isUsingDecl(F.next()))
521 F.erase();
522
523 F.done();
524}
525
Anders Carlsson99a000e2009-11-07 07:18:14 +0000526static bool ShouldDiagnoseUnusedDecl(const NamedDecl *D) {
John McCall86ff3082010-02-04 22:26:26 +0000527 if (D->isInvalidDecl())
528 return false;
529
Anders Carlssonf7613d52009-11-07 07:26:56 +0000530 if (D->isUsed() || D->hasAttr<UnusedAttr>())
531 return false;
John McCall86ff3082010-02-04 22:26:26 +0000532
533 // White-list anything that isn't a local variable.
534 if (!isa<VarDecl>(D) || isa<ParmVarDecl>(D) || isa<ImplicitParamDecl>(D) ||
535 !D->getDeclContext()->isFunctionOrMethod())
536 return false;
537
538 // Types of valid local variables should be complete, so this should succeed.
Anders Carlssonf7613d52009-11-07 07:26:56 +0000539 if (const ValueDecl *VD = dyn_cast<ValueDecl>(D)) {
John McCallaec58602010-03-31 02:47:45 +0000540
541 // White-list anything with an __attribute__((unused)) type.
542 QualType Ty = VD->getType();
543
544 // Only look at the outermost level of typedef.
545 if (const TypedefType *TT = dyn_cast<TypedefType>(Ty)) {
546 if (TT->getDecl()->hasAttr<UnusedAttr>())
547 return false;
548 }
549
Douglas Gregor5764f612010-05-08 23:05:03 +0000550 // If we failed to complete the type for some reason, or if the type is
551 // dependent, don't diagnose the variable.
552 if (Ty->isIncompleteType() || Ty->isDependentType())
Douglas Gregora6a292b2010-04-27 16:20:13 +0000553 return false;
554
John McCallaec58602010-03-31 02:47:45 +0000555 if (const TagType *TT = Ty->getAs<TagType>()) {
556 const TagDecl *Tag = TT->getDecl();
557 if (Tag->hasAttr<UnusedAttr>())
558 return false;
559
560 if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(Tag)) {
Douglas Gregor5764f612010-05-08 23:05:03 +0000561 // FIXME: Checking for the presence of a user-declared constructor
562 // isn't completely accurate; we'd prefer to check that the initializer
563 // has no side effects.
564 if (RD->hasUserDeclaredConstructor() || !RD->hasTrivialDestructor())
Anders Carlssonf7613d52009-11-07 07:26:56 +0000565 return false;
566 }
567 }
John McCallaec58602010-03-31 02:47:45 +0000568
569 // TODO: __attribute__((unused)) templates?
Anders Carlssonf7613d52009-11-07 07:26:56 +0000570 }
571
John McCall86ff3082010-02-04 22:26:26 +0000572 return true;
Anders Carlsson99a000e2009-11-07 07:18:14 +0000573}
574
Douglas Gregor5764f612010-05-08 23:05:03 +0000575void Sema::DiagnoseUnusedDecl(const NamedDecl *D) {
576 if (!ShouldDiagnoseUnusedDecl(D))
577 return;
578
579 if (isa<VarDecl>(D) && cast<VarDecl>(D)->isExceptionVariable())
580 Diag(D->getLocation(), diag::warn_unused_exception_param)
581 << D->getDeclName();
582 else
583 Diag(D->getLocation(), diag::warn_unused_variable)
584 << D->getDeclName();
585}
586
Steve Naroffb216c882007-10-09 22:01:59 +0000587void Sema::ActOnPopScope(SourceLocation Loc, Scope *S) {
Chris Lattner31e05722007-08-26 06:24:45 +0000588 if (S->decl_empty()) return;
Douglas Gregor72c3f312008-12-05 18:15:24 +0000589 assert((S->getFlags() & (Scope::DeclScope | Scope::TemplateParamScope)) &&
Mike Stump1eb44332009-09-09 15:08:12 +0000590 "Scope shouldn't contain decls!");
Argyrios Kyrtzidis00bc6452008-05-09 23:39:43 +0000591
Reid Spencer5f016e22007-07-11 17:01:13 +0000592 for (Scope::decl_iterator I = S->decl_begin(), E = S->decl_end();
593 I != E; ++I) {
Chris Lattnerb28317a2009-03-28 19:18:32 +0000594 Decl *TmpD = (*I).getAs<Decl>();
Steve Naroffc752d042007-09-13 18:10:37 +0000595 assert(TmpD && "This decl didn't get pushed??");
Argyrios Kyrtzidis76435362008-06-10 01:32:09 +0000596
Douglas Gregor44b43212008-12-11 16:49:14 +0000597 assert(isa<NamedDecl>(TmpD) && "Decl isn't NamedDecl?");
598 NamedDecl *D = cast<NamedDecl>(TmpD);
Argyrios Kyrtzidis76435362008-06-10 01:32:09 +0000599
Douglas Gregor44b43212008-12-11 16:49:14 +0000600 if (!D->getDeclName()) continue;
Chris Lattner7f925cc2008-04-11 07:00:53 +0000601
Douglas Gregorb5352cf2009-10-08 21:35:42 +0000602 // Diagnose unused variables in this scope.
Douglas Gregor5764f612010-05-08 23:05:03 +0000603 if (S->getNumErrorsAtStart() == getDiagnostics().getNumErrors())
604 DiagnoseUnusedDecl(D);
605
Douglas Gregor44b43212008-12-11 16:49:14 +0000606 // Remove this name from our lexical scope.
607 IdResolver.RemoveDecl(D);
Reid Spencer5f016e22007-07-11 17:01:13 +0000608 }
609}
610
Douglas Gregorc83c6872010-04-15 22:33:43 +0000611/// \brief Look for an Objective-C class in the translation unit.
Douglas Gregorf06cdae2010-01-03 18:01:57 +0000612///
Douglas Gregorc83c6872010-04-15 22:33:43 +0000613/// \param Id The name of the Objective-C class we're looking for. If
Douglas Gregorf06cdae2010-01-03 18:01:57 +0000614/// typo-correction fixes this name, the Id will be updated
615/// to the fixed name.
616///
Douglas Gregorc83c6872010-04-15 22:33:43 +0000617/// \param IdLoc The location of the name in the translation unit.
618///
619/// \param TypoCorrection If true, this routine will attempt typo correction
620/// if there is no class with the given name.
621///
622/// \returns The declaration of the named Objective-C class, or NULL if the
623/// class could not be found.
Douglas Gregorf06cdae2010-01-03 18:01:57 +0000624ObjCInterfaceDecl *Sema::getObjCInterfaceDecl(IdentifierInfo *&Id,
Douglas Gregorc83c6872010-04-15 22:33:43 +0000625 SourceLocation IdLoc,
626 bool TypoCorrection) {
Steve Naroff31102512008-04-02 18:30:49 +0000627 // The third "scope" argument is 0 since we aren't enabling lazy built-in
628 // creation from this context.
Douglas Gregorc83c6872010-04-15 22:33:43 +0000629 NamedDecl *IDecl = LookupSingleName(TUScope, Id, IdLoc, LookupOrdinaryName);
Mike Stump1eb44332009-09-09 15:08:12 +0000630
Douglas Gregorc83c6872010-04-15 22:33:43 +0000631 if (!IDecl && TypoCorrection) {
Douglas Gregorf06cdae2010-01-03 18:01:57 +0000632 // Perform typo correction at the given location, but only if we
633 // find an Objective-C class name.
Douglas Gregorc83c6872010-04-15 22:33:43 +0000634 LookupResult R(*this, Id, IdLoc, LookupOrdinaryName);
Douglas Gregoraaf87162010-04-14 20:04:41 +0000635 if (CorrectTypo(R, TUScope, 0, 0, false, CTC_NoKeywords) &&
Douglas Gregorf06cdae2010-01-03 18:01:57 +0000636 (IDecl = R.getAsSingle<ObjCInterfaceDecl>())) {
Douglas Gregorc83c6872010-04-15 22:33:43 +0000637 Diag(IdLoc, diag::err_undef_interface_suggest)
Douglas Gregorf06cdae2010-01-03 18:01:57 +0000638 << Id << IDecl->getDeclName()
Douglas Gregorc83c6872010-04-15 22:33:43 +0000639 << FixItHint::CreateReplacement(IdLoc, IDecl->getNameAsString());
Douglas Gregor67dd1d42010-01-07 00:17:44 +0000640 Diag(IDecl->getLocation(), diag::note_previous_decl)
641 << IDecl->getDeclName();
642
Douglas Gregorf06cdae2010-01-03 18:01:57 +0000643 Id = IDecl->getIdentifier();
644 }
645 }
646
Steve Naroffb327ce02008-04-02 14:35:35 +0000647 return dyn_cast_or_null<ObjCInterfaceDecl>(IDecl);
Fariborz Jahanian4cabdfc2007-10-12 19:38:20 +0000648}
649
Douglas Gregor1a0d31a2009-01-12 18:45:55 +0000650/// getNonFieldDeclScope - Retrieves the innermost scope, starting
651/// from S, where a non-field would be declared. This routine copes
652/// with the difference between C and C++ scoping rules in structs and
653/// unions. For example, the following code is well-formed in C but
654/// ill-formed in C++:
655/// @code
656/// struct S6 {
657/// enum { BAR } e;
658/// };
Mike Stump1eb44332009-09-09 15:08:12 +0000659///
Douglas Gregor1a0d31a2009-01-12 18:45:55 +0000660/// void test_S6() {
661/// struct S6 a;
662/// a.e = BAR;
663/// }
664/// @endcode
665/// For the declaration of BAR, this routine will return a different
666/// scope. The scope S will be the scope of the unnamed enumeration
667/// within S6. In C++, this routine will return the scope associated
668/// with S6, because the enumeration's scope is a transparent
669/// context but structures can contain non-field names. In C, this
670/// routine will return the translation unit scope, since the
671/// enumeration's scope is a transparent context and structures cannot
672/// contain non-field names.
673Scope *Sema::getNonFieldDeclScope(Scope *S) {
674 while (((S->getFlags() & Scope::DeclScope) == 0) ||
Mike Stump1eb44332009-09-09 15:08:12 +0000675 (S->getEntity() &&
Douglas Gregor1a0d31a2009-01-12 18:45:55 +0000676 ((DeclContext *)S->getEntity())->isTransparentContext()) ||
677 (S->isClassScope() && !getLangOptions().CPlusPlus))
678 S = S->getParent();
679 return S;
680}
681
Chris Lattner95e2c712008-05-05 22:18:14 +0000682void Sema::InitBuiltinVaListType() {
Anders Carlsson7c50aca2007-10-15 20:28:48 +0000683 if (!Context.getBuiltinVaListType().isNull())
684 return;
Mike Stump1eb44332009-09-09 15:08:12 +0000685
Anders Carlsson7c50aca2007-10-15 20:28:48 +0000686 IdentifierInfo *VaIdent = &Context.Idents.get("__builtin_va_list");
Douglas Gregorc83c6872010-04-15 22:33:43 +0000687 NamedDecl *VaDecl = LookupSingleName(TUScope, VaIdent, SourceLocation(),
688 LookupOrdinaryName, ForRedeclaration);
Steve Naroff733002f2007-10-18 22:17:45 +0000689 TypedefDecl *VaTypedef = cast<TypedefDecl>(VaDecl);
Anders Carlsson7c50aca2007-10-15 20:28:48 +0000690 Context.setBuiltinVaListType(Context.getTypedefType(VaTypedef));
691}
692
Douglas Gregor3e41d602009-02-13 23:20:09 +0000693/// LazilyCreateBuiltin - The specified Builtin-ID was first used at
694/// file scope. lazily create a decl for it. ForRedeclaration is true
695/// if we're creating this built-in in anticipation of redeclaring the
696/// built-in.
Douglas Gregor4afa39d2009-01-20 01:17:11 +0000697NamedDecl *Sema::LazilyCreateBuiltin(IdentifierInfo *II, unsigned bid,
Douglas Gregor3e41d602009-02-13 23:20:09 +0000698 Scope *S, bool ForRedeclaration,
699 SourceLocation Loc) {
Reid Spencer5f016e22007-07-11 17:01:13 +0000700 Builtin::ID BID = (Builtin::ID)bid;
701
Chris Lattnerbd7eb1c2008-09-28 05:54:29 +0000702 if (Context.BuiltinInfo.hasVAListUse(BID))
Anders Carlsson7c50aca2007-10-15 20:28:48 +0000703 InitBuiltinVaListType();
Douglas Gregor3e41d602009-02-13 23:20:09 +0000704
Chris Lattner86df27b2009-06-14 00:45:47 +0000705 ASTContext::GetBuiltinTypeError Error;
Mike Stump1eb44332009-09-09 15:08:12 +0000706 QualType R = Context.GetBuiltinType(BID, Error);
Douglas Gregor370ab3f2009-02-14 01:52:53 +0000707 switch (Error) {
Chris Lattner86df27b2009-06-14 00:45:47 +0000708 case ASTContext::GE_None:
Douglas Gregor370ab3f2009-02-14 01:52:53 +0000709 // Okay
710 break;
711
Mike Stumpf711c412009-07-28 23:57:15 +0000712 case ASTContext::GE_Missing_stdio:
Douglas Gregor370ab3f2009-02-14 01:52:53 +0000713 if (ForRedeclaration)
714 Diag(Loc, diag::err_implicit_decl_requires_stdio)
715 << Context.BuiltinInfo.GetName(BID);
716 return 0;
Mike Stump782fa302009-07-28 02:25:19 +0000717
Mike Stumpf711c412009-07-28 23:57:15 +0000718 case ASTContext::GE_Missing_setjmp:
Mike Stump782fa302009-07-28 02:25:19 +0000719 if (ForRedeclaration)
720 Diag(Loc, diag::err_implicit_decl_requires_setjmp)
721 << Context.BuiltinInfo.GetName(BID);
722 return 0;
Douglas Gregor370ab3f2009-02-14 01:52:53 +0000723 }
Douglas Gregor3e41d602009-02-13 23:20:09 +0000724
725 if (!ForRedeclaration && Context.BuiltinInfo.isPredefinedLibFunction(BID)) {
726 Diag(Loc, diag::ext_implicit_lib_function_decl)
727 << Context.BuiltinInfo.GetName(BID)
728 << R;
Douglas Gregorb1152d82009-02-16 21:58:21 +0000729 if (Context.BuiltinInfo.getHeaderName(BID) &&
Chris Lattner6a7334d2009-04-16 03:59:32 +0000730 Diags.getDiagnosticLevel(diag::ext_implicit_lib_function_decl)
731 != Diagnostic::Ignored)
Douglas Gregor3e41d602009-02-13 23:20:09 +0000732 Diag(Loc, diag::note_please_include_header)
733 << Context.BuiltinInfo.getHeaderName(BID)
734 << Context.BuiltinInfo.GetName(BID);
735 }
736
Argyrios Kyrtzidisff898cd2008-04-17 14:47:13 +0000737 FunctionDecl *New = FunctionDecl::Create(Context,
738 Context.getTranslationUnitDecl(),
John McCalla93c9342009-12-07 02:54:59 +0000739 Loc, II, R, /*TInfo=*/0,
Douglas Gregor16573fa2010-04-19 22:54:31 +0000740 FunctionDecl::Extern,
741 FunctionDecl::None, false,
Douglas Gregor2224f842009-02-25 16:33:18 +0000742 /*hasPrototype=*/true);
Douglas Gregor3e41d602009-02-13 23:20:09 +0000743 New->setImplicit();
744
Chris Lattner95e2c712008-05-05 22:18:14 +0000745 // Create Decl objects for each parameter, adding them to the
746 // FunctionDecl.
Douglas Gregor72564e72009-02-26 23:50:07 +0000747 if (FunctionProtoType *FT = dyn_cast<FunctionProtoType>(R)) {
Chris Lattner95e2c712008-05-05 22:18:14 +0000748 llvm::SmallVector<ParmVarDecl*, 16> Params;
749 for (unsigned i = 0, e = FT->getNumArgs(); i != e; ++i)
750 Params.push_back(ParmVarDecl::Create(Context, New, SourceLocation(), 0,
John McCalla93c9342009-12-07 02:54:59 +0000751 FT->getArgType(i), /*TInfo=*/0,
Douglas Gregor16573fa2010-04-19 22:54:31 +0000752 VarDecl::None, VarDecl::None, 0));
Douglas Gregor838db382010-02-11 01:19:42 +0000753 New->setParams(Params.data(), Params.size());
Chris Lattner95e2c712008-05-05 22:18:14 +0000754 }
Mike Stump1eb44332009-09-09 15:08:12 +0000755
756 AddKnownFunctionAttributes(New);
757
Chris Lattner7f925cc2008-04-11 07:00:53 +0000758 // TUScope is the translation-unit scope to insert this function into.
Douglas Gregora8cc8ce2009-01-09 18:51:29 +0000759 // FIXME: This is hideous. We need to teach PushOnScopeChains to
760 // relate Scopes to DeclContexts, and probably eliminate CurContext
761 // entirely, but we're not there yet.
762 DeclContext *SavedContext = CurContext;
763 CurContext = Context.getTranslationUnitDecl();
Argyrios Kyrtzidis00bc6452008-05-09 23:39:43 +0000764 PushOnScopeChains(New, TUScope);
Douglas Gregora8cc8ce2009-01-09 18:51:29 +0000765 CurContext = SavedContext;
Reid Spencer5f016e22007-07-11 17:01:13 +0000766 return New;
767}
768
Douglas Gregorcda9c672009-02-16 17:45:42 +0000769/// MergeTypeDefDecl - We just parsed a typedef 'New' which has the
770/// same name and scope as a previous declaration 'Old'. Figure out
771/// how to resolve this situation, merging decls or emitting
Chris Lattnereaaebc72009-04-25 08:06:05 +0000772/// diagnostics as appropriate. If there was an error, set New to be invalid.
Reid Spencer5f016e22007-07-11 17:01:13 +0000773///
John McCall68263142009-11-18 22:49:29 +0000774void Sema::MergeTypeDefDecl(TypedefDecl *New, LookupResult &OldDecls) {
775 // If the new decl is known invalid already, don't bother doing any
776 // merging checks.
777 if (New->isInvalidDecl()) return;
Mike Stump1eb44332009-09-09 15:08:12 +0000778
Steve Naroff2b255c42008-09-09 14:32:20 +0000779 // Allow multiple definitions for ObjC built-in typedefs.
780 // FIXME: Verify the underlying types are equivalent!
781 if (getLangOptions().ObjC1) {
Chris Lattner2bac0f62008-11-20 05:41:43 +0000782 const IdentifierInfo *TypeID = New->getIdentifier();
783 switch (TypeID->getLength()) {
784 default: break;
Mike Stump1eb44332009-09-09 15:08:12 +0000785 case 2:
Chris Lattner2bac0f62008-11-20 05:41:43 +0000786 if (!TypeID->isStr("id"))
787 break;
David Chisnall0f436562009-08-17 16:35:33 +0000788 Context.ObjCIdRedefinitionType = New->getUnderlyingType();
Steve Naroff14108da2009-07-10 23:34:53 +0000789 // Install the built-in type for 'id', ignoring the current definition.
790 New->setTypeForDecl(Context.getObjCIdType().getTypePtr());
791 return;
Chris Lattner2bac0f62008-11-20 05:41:43 +0000792 case 5:
793 if (!TypeID->isStr("Class"))
794 break;
David Chisnall0f436562009-08-17 16:35:33 +0000795 Context.ObjCClassRedefinitionType = New->getUnderlyingType();
Steve Naroff14108da2009-07-10 23:34:53 +0000796 // Install the built-in type for 'Class', ignoring the current definition.
797 New->setTypeForDecl(Context.getObjCClassType().getTypePtr());
Chris Lattnereaaebc72009-04-25 08:06:05 +0000798 return;
Chris Lattner2bac0f62008-11-20 05:41:43 +0000799 case 3:
800 if (!TypeID->isStr("SEL"))
801 break;
Fariborz Jahanian369a3bd2009-11-25 23:07:42 +0000802 Context.ObjCSelRedefinitionType = New->getUnderlyingType();
Fariborz Jahanian13dcd002009-11-21 19:53:08 +0000803 // Install the built-in type for 'SEL', ignoring the current definition.
804 New->setTypeForDecl(Context.getObjCSelType().getTypePtr());
Chris Lattnereaaebc72009-04-25 08:06:05 +0000805 return;
Chris Lattner2bac0f62008-11-20 05:41:43 +0000806 case 8:
807 if (!TypeID->isStr("Protocol"))
808 break;
Steve Naroff2b255c42008-09-09 14:32:20 +0000809 Context.setObjCProtoType(New->getUnderlyingType());
Chris Lattnereaaebc72009-04-25 08:06:05 +0000810 return;
Steve Naroff2b255c42008-09-09 14:32:20 +0000811 }
812 // Fall through - the typedef name was not a builtin type.
813 }
John McCall68263142009-11-18 22:49:29 +0000814
Douglas Gregor66973122009-01-28 17:15:10 +0000815 // Verify the old decl was also a type.
John McCall5126fd02009-12-30 00:31:22 +0000816 TypeDecl *Old = OldDecls.getAsSingle<TypeDecl>();
817 if (!Old) {
Mike Stump1eb44332009-09-09 15:08:12 +0000818 Diag(New->getLocation(), diag::err_redefinition_different_kind)
Chris Lattner08631c52008-11-23 21:45:46 +0000819 << New->getDeclName();
John McCall68263142009-11-18 22:49:29 +0000820
821 NamedDecl *OldD = OldDecls.getRepresentativeDecl();
Chris Lattnereaaebc72009-04-25 08:06:05 +0000822 if (OldD->getLocation().isValid())
Fariborz Jahanianc55a2402009-01-16 19:58:32 +0000823 Diag(OldD->getLocation(), diag::note_previous_definition);
John McCall68263142009-11-18 22:49:29 +0000824
Chris Lattnereaaebc72009-04-25 08:06:05 +0000825 return New->setInvalidDecl();
Reid Spencer5f016e22007-07-11 17:01:13 +0000826 }
Douglas Gregor66973122009-01-28 17:15:10 +0000827
John McCall68263142009-11-18 22:49:29 +0000828 // If the old declaration is invalid, just give up here.
829 if (Old->isInvalidDecl())
830 return New->setInvalidDecl();
831
Mike Stump1eb44332009-09-09 15:08:12 +0000832 // Determine the "old" type we'll use for checking and diagnostics.
Douglas Gregor66973122009-01-28 17:15:10 +0000833 QualType OldType;
834 if (TypedefDecl *OldTypedef = dyn_cast<TypedefDecl>(Old))
835 OldType = OldTypedef->getUnderlyingType();
836 else
837 OldType = Context.getTypeDeclType(Old);
838
Chris Lattner99cb9972008-07-25 18:44:27 +0000839 // If the typedef types are not identical, reject them in all languages and
840 // with any extensions enabled.
Douglas Gregor66973122009-01-28 17:15:10 +0000841
Mike Stump1eb44332009-09-09 15:08:12 +0000842 if (OldType != New->getUnderlyingType() &&
843 Context.getCanonicalType(OldType) !=
Chris Lattner99cb9972008-07-25 18:44:27 +0000844 Context.getCanonicalType(New->getUnderlyingType())) {
Chris Lattner5dc266a2008-11-20 06:13:02 +0000845 Diag(New->getLocation(), diag::err_redefinition_different_typedef)
Douglas Gregor66973122009-01-28 17:15:10 +0000846 << New->getUnderlyingType() << OldType;
Chris Lattnereaaebc72009-04-25 08:06:05 +0000847 if (Old->getLocation().isValid())
Fariborz Jahanianc55a2402009-01-16 19:58:32 +0000848 Diag(Old->getLocation(), diag::note_previous_definition);
Chris Lattnereaaebc72009-04-25 08:06:05 +0000849 return New->setInvalidDecl();
Chris Lattner99cb9972008-07-25 18:44:27 +0000850 }
Mike Stump1eb44332009-09-09 15:08:12 +0000851
John McCall5126fd02009-12-30 00:31:22 +0000852 // The types match. Link up the redeclaration chain if the old
853 // declaration was a typedef.
854 // FIXME: this is a potential source of wierdness if the type
855 // spellings don't match exactly.
856 if (isa<TypedefDecl>(Old))
857 New->setPreviousDeclaration(cast<TypedefDecl>(Old));
858
Steve Naroff14108da2009-07-10 23:34:53 +0000859 if (getLangOptions().Microsoft)
Chris Lattnereaaebc72009-04-25 08:06:05 +0000860 return;
Eli Friedman54ecfce2008-06-11 06:20:39 +0000861
Chris Lattner32b06752009-04-17 22:04:20 +0000862 if (getLangOptions().CPlusPlus) {
Douglas Gregor93dda722010-01-11 21:54:40 +0000863 // C++ [dcl.typedef]p2:
864 // In a given non-class scope, a typedef specifier can be used to
865 // redefine the name of any type declared in that scope to refer
866 // to the type to which it already refers.
Chris Lattner32b06752009-04-17 22:04:20 +0000867 if (!isa<CXXRecordDecl>(CurContext))
Chris Lattnereaaebc72009-04-25 08:06:05 +0000868 return;
Douglas Gregor93dda722010-01-11 21:54:40 +0000869
870 // C++0x [dcl.typedef]p4:
871 // In a given class scope, a typedef specifier can be used to redefine
872 // any class-name declared in that scope that is not also a typedef-name
873 // to refer to the type to which it already refers.
874 //
875 // This wording came in via DR424, which was a correction to the
876 // wording in DR56, which accidentally banned code like:
877 //
878 // struct S {
879 // typedef struct A { } A;
880 // };
881 //
882 // in the C++03 standard. We implement the C++0x semantics, which
883 // allow the above but disallow
884 //
885 // struct S {
886 // typedef int I;
887 // typedef int I;
888 // };
889 //
890 // since that was the intent of DR56.
Douglas Gregor05f65002010-01-11 22:30:10 +0000891 if (!isa<TypedefDecl >(Old))
Douglas Gregor93dda722010-01-11 21:54:40 +0000892 return;
893
Chris Lattner32b06752009-04-17 22:04:20 +0000894 Diag(New->getLocation(), diag::err_redefinition)
895 << New->getDeclName();
896 Diag(Old->getLocation(), diag::note_previous_definition);
Chris Lattnereaaebc72009-04-25 08:06:05 +0000897 return New->setInvalidDecl();
Daniel Dunbar2fe09972008-09-12 18:10:20 +0000898 }
Eli Friedman54ecfce2008-06-11 06:20:39 +0000899
Chris Lattner32b06752009-04-17 22:04:20 +0000900 // If we have a redefinition of a typedef in C, emit a warning. This warning
901 // is normally mapped to an error, but can be controlled with
Eli Friedman340a4e52009-06-04 23:03:07 +0000902 // -Wtypedef-redefinition. If either the original or the redefinition is
903 // in a system header, don't emit this for compatibility with GCC.
Chris Lattner6d97e5e2010-03-01 20:59:53 +0000904 if (getDiagnostics().getSuppressSystemWarnings() &&
Eli Friedman340a4e52009-06-04 23:03:07 +0000905 (Context.getSourceManager().isInSystemHeader(Old->getLocation()) ||
906 Context.getSourceManager().isInSystemHeader(New->getLocation())))
Chris Lattnerd0359af2009-04-27 01:46:12 +0000907 return;
Mike Stump1eb44332009-09-09 15:08:12 +0000908
Chris Lattner32b06752009-04-17 22:04:20 +0000909 Diag(New->getLocation(), diag::warn_redefinition_of_typedef)
910 << New->getDeclName();
Chris Lattner5f4a6822008-11-23 23:12:31 +0000911 Diag(Old->getLocation(), diag::note_previous_definition);
Chris Lattnereaaebc72009-04-25 08:06:05 +0000912 return;
Reid Spencer5f016e22007-07-11 17:01:13 +0000913}
914
Chris Lattner6b6b5372008-06-26 18:38:35 +0000915/// DeclhasAttr - returns true if decl Declaration already has the target
916/// attribute.
Mike Stump1eb44332009-09-09 15:08:12 +0000917static bool
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +0000918DeclHasAttr(const Decl *decl, const Attr *target) {
919 for (const Attr *attr = decl->getAttrs(); attr; attr = attr->getNext())
Chris Lattnerddee4232008-03-03 03:28:21 +0000920 if (attr->getKind() == target->getKind())
921 return true;
922
923 return false;
924}
925
926/// MergeAttributes - append attributes from the Old decl to the New one.
Chris Lattnercc581472009-03-04 06:05:19 +0000927static void MergeAttributes(Decl *New, Decl *Old, ASTContext &C) {
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +0000928 for (const Attr *attr = Old->getAttrs(); attr; attr = attr->getNext()) {
929 if (!DeclHasAttr(New, attr) && attr->isMerged()) {
Douglas Gregor9f9bf252009-04-28 06:37:30 +0000930 Attr *NewAttr = attr->clone(C);
931 NewAttr->setInherited(true);
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +0000932 New->addAttr(NewAttr);
Chris Lattnerddee4232008-03-03 03:28:21 +0000933 }
934 }
935}
936
Douglas Gregorc8376562009-03-06 22:43:54 +0000937/// Used in MergeFunctionDecl to keep track of function parameters in
938/// C.
939struct GNUCompatibleParamWarning {
940 ParmVarDecl *OldParm;
941 ParmVarDecl *NewParm;
942 QualType PromotedType;
943};
944
Anders Carlsson5c478cf2009-12-04 22:33:25 +0000945
946/// getSpecialMember - get the special member enum for a method.
Anders Carlsson3b8c53b2010-04-22 05:40:53 +0000947Sema::CXXSpecialMember Sema::getSpecialMember(const CXXMethodDecl *MD) {
Anders Carlsson5c478cf2009-12-04 22:33:25 +0000948 if (const CXXConstructorDecl *Ctor = dyn_cast<CXXConstructorDecl>(MD)) {
Douglas Gregor9e9199d2009-12-22 00:34:07 +0000949 if (Ctor->isCopyConstructor())
Anders Carlsson5c478cf2009-12-04 22:33:25 +0000950 return Sema::CXXCopyConstructor;
Anders Carlsson3b8c53b2010-04-22 05:40:53 +0000951
952 return Sema::CXXConstructor;
Anders Carlsson5c478cf2009-12-04 22:33:25 +0000953 }
954
955 if (isa<CXXDestructorDecl>(MD))
956 return Sema::CXXDestructor;
957
958 assert(MD->isCopyAssignment() && "Must have copy assignment operator");
959 return Sema::CXXCopyAssignment;
960}
961
Charles Davisf3f8d2a2010-02-18 02:00:42 +0000962/// canREdefineFunction - checks if a function can be redefined. Currently,
963/// only extern inline functions can be redefined, and even then only in
964/// GNU89 mode.
965static bool canRedefineFunction(const FunctionDecl *FD,
966 const LangOptions& LangOpts) {
967 return (LangOpts.GNUMode && !LangOpts.C99 && !LangOpts.CPlusPlus &&
968 FD->isInlineSpecified() &&
969 FD->getStorageClass() == FunctionDecl::Extern);
970}
971
Chris Lattner04421082008-04-08 04:40:51 +0000972/// MergeFunctionDecl - We just parsed a function 'New' from
973/// declarator D which has the same name and scope as a previous
974/// declaration 'Old'. Figure out how to resolve this situation,
975/// merging decls or emitting diagnostics as appropriate.
Douglas Gregor8e9bebd2008-10-21 16:13:35 +0000976///
977/// In C++, New and Old must be declarations that are not
978/// overloaded. Use IsOverload to determine whether New and Old are
979/// overloaded, and to select the Old declaration that New should be
980/// merged with.
Douglas Gregorcda9c672009-02-16 17:45:42 +0000981///
982/// Returns true if there was an error, false otherwise.
983bool Sema::MergeFunctionDecl(FunctionDecl *New, Decl *OldD) {
Reid Spencer5f016e22007-07-11 17:01:13 +0000984 // Verify the old decl was also a function.
Douglas Gregore53060f2009-06-25 22:08:12 +0000985 FunctionDecl *Old = 0;
Mike Stump1eb44332009-09-09 15:08:12 +0000986 if (FunctionTemplateDecl *OldFunctionTemplate
Douglas Gregore53060f2009-06-25 22:08:12 +0000987 = dyn_cast<FunctionTemplateDecl>(OldD))
988 Old = OldFunctionTemplate->getTemplatedDecl();
Mike Stump1eb44332009-09-09 15:08:12 +0000989 else
Douglas Gregore53060f2009-06-25 22:08:12 +0000990 Old = dyn_cast<FunctionDecl>(OldD);
Reid Spencer5f016e22007-07-11 17:01:13 +0000991 if (!Old) {
John McCall41ce66f2009-12-10 19:51:03 +0000992 if (UsingShadowDecl *Shadow = dyn_cast<UsingShadowDecl>(OldD)) {
993 Diag(New->getLocation(), diag::err_using_decl_conflict_reverse);
994 Diag(Shadow->getTargetDecl()->getLocation(),
995 diag::note_using_decl_target);
996 Diag(Shadow->getUsingDecl()->getLocation(),
997 diag::note_using_decl) << 0;
998 return true;
999 }
1000
Chris Lattner5dc266a2008-11-20 06:13:02 +00001001 Diag(New->getLocation(), diag::err_redefinition_different_kind)
Chris Lattner08631c52008-11-23 21:45:46 +00001002 << New->getDeclName();
Chris Lattner5f4a6822008-11-23 23:12:31 +00001003 Diag(OldD->getLocation(), diag::note_previous_definition);
Douglas Gregorcda9c672009-02-16 17:45:42 +00001004 return true;
Reid Spencer5f016e22007-07-11 17:01:13 +00001005 }
Douglas Gregor8e9bebd2008-10-21 16:13:35 +00001006
1007 // Determine whether the previous declaration was a definition,
1008 // implicit declaration, or a declaration.
1009 diag::kind PrevDiag;
1010 if (Old->isThisDeclarationADefinition())
Chris Lattner5f4a6822008-11-23 23:12:31 +00001011 PrevDiag = diag::note_previous_definition;
Douglas Gregorcda9c672009-02-16 17:45:42 +00001012 else if (Old->isImplicit())
1013 PrevDiag = diag::note_previous_implicit_declaration;
Mike Stump1eb44332009-09-09 15:08:12 +00001014 else
Chris Lattner5f4a6822008-11-23 23:12:31 +00001015 PrevDiag = diag::note_previous_declaration;
Mike Stump1eb44332009-09-09 15:08:12 +00001016
Chris Lattner8bcfc5b2008-04-06 23:10:54 +00001017 QualType OldQType = Context.getCanonicalType(Old->getType());
1018 QualType NewQType = Context.getCanonicalType(New->getType());
Mike Stump1eb44332009-09-09 15:08:12 +00001019
Charles Davisf3f8d2a2010-02-18 02:00:42 +00001020 // Don't complain about this if we're in GNU89 mode and the old function
1021 // is an extern inline function.
Douglas Gregor04495c82009-02-24 01:23:02 +00001022 if (!isa<CXXMethodDecl>(New) && !isa<CXXMethodDecl>(Old) &&
1023 New->getStorageClass() == FunctionDecl::Static &&
Charles Davisf3f8d2a2010-02-18 02:00:42 +00001024 Old->getStorageClass() != FunctionDecl::Static &&
1025 !canRedefineFunction(Old, getLangOptions())) {
Douglas Gregor04495c82009-02-24 01:23:02 +00001026 Diag(New->getLocation(), diag::err_static_non_static)
1027 << New;
1028 Diag(Old->getLocation(), PrevDiag);
1029 return true;
1030 }
1031
John McCallf82b4e82010-02-04 05:44:44 +00001032 // If a function is first declared with a calling convention, but is
1033 // later declared or defined without one, the second decl assumes the
1034 // calling convention of the first.
1035 //
1036 // For the new decl, we have to look at the NON-canonical type to tell the
1037 // difference between a function that really doesn't have a calling
1038 // convention and one that is declared cdecl. That's because in
1039 // canonicalization (see ASTContext.cpp), cdecl is canonicalized away
1040 // because it is the default calling convention.
1041 //
1042 // Note also that we DO NOT return at this point, because we still have
1043 // other tests to run.
1044 const FunctionType *OldType = OldQType->getAs<FunctionType>();
1045 const FunctionType *NewType = New->getType()->getAs<FunctionType>();
Rafael Espindola264ba482010-03-30 20:24:48 +00001046 const FunctionType::ExtInfo OldTypeInfo = OldType->getExtInfo();
1047 const FunctionType::ExtInfo NewTypeInfo = NewType->getExtInfo();
1048 if (OldTypeInfo.getCC() != CC_Default &&
1049 NewTypeInfo.getCC() == CC_Default) {
1050 NewQType = Context.getCallConvType(NewQType, OldTypeInfo.getCC());
John McCallf82b4e82010-02-04 05:44:44 +00001051 New->setType(NewQType);
1052 NewQType = Context.getCanonicalType(NewQType);
Rafael Espindola264ba482010-03-30 20:24:48 +00001053 } else if (!Context.isSameCallConv(OldTypeInfo.getCC(),
1054 NewTypeInfo.getCC())) {
John McCallf82b4e82010-02-04 05:44:44 +00001055 // Calling conventions really aren't compatible, so complain.
John McCall04a67a62010-02-05 21:31:56 +00001056 Diag(New->getLocation(), diag::err_cconv_change)
Rafael Espindola264ba482010-03-30 20:24:48 +00001057 << FunctionType::getNameForCallConv(NewTypeInfo.getCC())
1058 << (OldTypeInfo.getCC() == CC_Default)
1059 << (OldTypeInfo.getCC() == CC_Default ? "" :
1060 FunctionType::getNameForCallConv(OldTypeInfo.getCC()));
John McCall04a67a62010-02-05 21:31:56 +00001061 Diag(Old->getLocation(), diag::note_previous_declaration);
John McCallf82b4e82010-02-04 05:44:44 +00001062 return true;
1063 }
1064
John McCall04a67a62010-02-05 21:31:56 +00001065 // FIXME: diagnose the other way around?
Rafael Espindola264ba482010-03-30 20:24:48 +00001066 if (OldType->getNoReturnAttr() &&
1067 !NewType->getNoReturnAttr()) {
John McCall04a67a62010-02-05 21:31:56 +00001068 NewQType = Context.getNoReturnType(NewQType);
1069 New->setType(NewQType);
1070 assert(NewQType.isCanonical());
1071 }
1072
Douglas Gregor8e9bebd2008-10-21 16:13:35 +00001073 if (getLangOptions().CPlusPlus) {
1074 // (C++98 13.1p2):
1075 // Certain function declarations cannot be overloaded:
Mike Stump1eb44332009-09-09 15:08:12 +00001076 // -- Function declarations that differ only in the return type
Douglas Gregor8e9bebd2008-10-21 16:13:35 +00001077 // cannot be overloaded.
Mike Stump1eb44332009-09-09 15:08:12 +00001078 QualType OldReturnType
Douglas Gregor8e9bebd2008-10-21 16:13:35 +00001079 = cast<FunctionType>(OldQType.getTypePtr())->getResultType();
Mike Stump1eb44332009-09-09 15:08:12 +00001080 QualType NewReturnType
Douglas Gregor8e9bebd2008-10-21 16:13:35 +00001081 = cast<FunctionType>(NewQType.getTypePtr())->getResultType();
Fariborz Jahanian2390a722010-05-19 21:37:30 +00001082 QualType ResQT;
Douglas Gregor8e9bebd2008-10-21 16:13:35 +00001083 if (OldReturnType != NewReturnType) {
Fariborz Jahanian2390a722010-05-19 21:37:30 +00001084 if (NewReturnType->isObjCObjectPointerType()
1085 && OldReturnType->isObjCObjectPointerType())
1086 ResQT = Context.mergeObjCGCQualifiers(NewQType, OldQType);
1087 if (ResQT.isNull()) {
1088 Diag(New->getLocation(), diag::err_ovl_diff_return_type);
1089 Diag(Old->getLocation(), PrevDiag) << Old << Old->getType();
1090 return true;
1091 }
1092 else
1093 NewQType = ResQT;
Douglas Gregor8e9bebd2008-10-21 16:13:35 +00001094 }
1095
1096 const CXXMethodDecl* OldMethod = dyn_cast<CXXMethodDecl>(Old);
John McCall3d043362010-04-13 07:45:41 +00001097 CXXMethodDecl* NewMethod = dyn_cast<CXXMethodDecl>(New);
Anders Carlsson5c478cf2009-12-04 22:33:25 +00001098 if (OldMethod && NewMethod) {
John McCall3d043362010-04-13 07:45:41 +00001099 // Preserve triviality.
1100 NewMethod->setTrivial(OldMethod->isTrivial());
1101
1102 bool isFriend = NewMethod->getFriendObjectKind();
1103
1104 if (!isFriend && NewMethod->getLexicalDeclContext()->isRecord()) {
Anders Carlsson5c478cf2009-12-04 22:33:25 +00001105 // -- Member function declarations with the same name and the
1106 // same parameter types cannot be overloaded if any of them
1107 // is a static member function declaration.
1108 if (OldMethod->isStatic() || NewMethod->isStatic()) {
1109 Diag(New->getLocation(), diag::err_ovl_static_nonstatic_member);
1110 Diag(Old->getLocation(), PrevDiag) << Old << Old->getType();
1111 return true;
1112 }
1113
1114 // C++ [class.mem]p1:
1115 // [...] A member shall not be declared twice in the
1116 // member-specification, except that a nested class or member
1117 // class template can be declared and then later defined.
1118 unsigned NewDiag;
1119 if (isa<CXXConstructorDecl>(OldMethod))
1120 NewDiag = diag::err_constructor_redeclared;
1121 else if (isa<CXXDestructorDecl>(NewMethod))
1122 NewDiag = diag::err_destructor_redeclared;
1123 else if (isa<CXXConversionDecl>(NewMethod))
1124 NewDiag = diag::err_conv_function_redeclared;
1125 else
1126 NewDiag = diag::err_member_redeclared;
1127
1128 Diag(New->getLocation(), NewDiag);
Douglas Gregor3e41d602009-02-13 23:20:09 +00001129 Diag(Old->getLocation(), PrevDiag) << Old << Old->getType();
John McCall3d043362010-04-13 07:45:41 +00001130
1131 // Complain if this is an explicit declaration of a special
1132 // member that was initially declared implicitly.
1133 //
1134 // As an exception, it's okay to befriend such methods in order
1135 // to permit the implicit constructor/destructor/operator calls.
1136 } else if (OldMethod->isImplicit()) {
1137 if (isFriend) {
1138 NewMethod->setImplicit();
1139 } else {
Anders Carlsson5c478cf2009-12-04 22:33:25 +00001140 Diag(NewMethod->getLocation(),
1141 diag::err_definition_of_implicitly_declared_member)
Anders Carlsson3b8c53b2010-04-22 05:40:53 +00001142 << New << getSpecialMember(OldMethod);
Anders Carlsson5c478cf2009-12-04 22:33:25 +00001143 return true;
1144 }
Douglas Gregor8e9bebd2008-10-21 16:13:35 +00001145 }
1146 }
1147
1148 // (C++98 8.3.5p3):
1149 // All declarations for a function shall agree exactly in both the
1150 // return type and the parameter-type-list.
Nuno Lopesf75b8302009-12-23 23:40:33 +00001151 // attributes should be ignored when comparing.
1152 if (Context.getNoReturnType(OldQType, false) ==
1153 Context.getNoReturnType(NewQType, false))
Douglas Gregor04495c82009-02-24 01:23:02 +00001154 return MergeCompatibleFunctionDecls(New, Old);
Douglas Gregor8e9bebd2008-10-21 16:13:35 +00001155
1156 // Fall through for conflicting redeclarations and redefinitions.
Douglas Gregorf0097952008-04-21 02:02:58 +00001157 }
Chris Lattner04421082008-04-08 04:40:51 +00001158
1159 // C: Function types need to be compatible, not identical. This handles
Steve Naroffadbbd0c2008-01-14 20:51:29 +00001160 // duplicate function decls like "void f(int); void f(enum X);" properly.
Chris Lattner04421082008-04-08 04:40:51 +00001161 if (!getLangOptions().CPlusPlus &&
Eli Friedman3d815e72008-08-22 00:56:42 +00001162 Context.typesAreCompatible(OldQType, NewQType)) {
John McCall183700f2009-09-21 23:43:11 +00001163 const FunctionType *OldFuncType = OldQType->getAs<FunctionType>();
1164 const FunctionType *NewFuncType = NewQType->getAs<FunctionType>();
Douglas Gregor72564e72009-02-26 23:50:07 +00001165 const FunctionProtoType *OldProto = 0;
1166 if (isa<FunctionNoProtoType>(NewFuncType) &&
Douglas Gregorc8376562009-03-06 22:43:54 +00001167 (OldProto = dyn_cast<FunctionProtoType>(OldFuncType))) {
Douglas Gregor68719812009-02-16 18:20:44 +00001168 // The old declaration provided a function prototype, but the
1169 // new declaration does not. Merge in the prototype.
Sebastian Redl465226e2009-05-27 22:11:52 +00001170 assert(!OldProto->hasExceptionSpec() && "Exception spec in C");
Douglas Gregor68719812009-02-16 18:20:44 +00001171 llvm::SmallVector<QualType, 16> ParamTypes(OldProto->arg_type_begin(),
1172 OldProto->arg_type_end());
1173 NewQType = Context.getFunctionType(NewFuncType->getResultType(),
Jay Foadbeaaccd2009-05-21 09:52:38 +00001174 ParamTypes.data(), ParamTypes.size(),
Douglas Gregor68719812009-02-16 18:20:44 +00001175 OldProto->isVariadic(),
Douglas Gregorce056bc2010-02-21 22:15:06 +00001176 OldProto->getTypeQuals(),
1177 false, false, 0, 0,
Rafael Espindola264ba482010-03-30 20:24:48 +00001178 OldProto->getExtInfo());
Douglas Gregor68719812009-02-16 18:20:44 +00001179 New->setType(NewQType);
Anders Carlssona75e8532009-05-14 21:46:00 +00001180 New->setHasInheritedPrototype();
Douglas Gregor450da982009-02-16 20:58:07 +00001181
1182 // Synthesize a parameter for each argument type.
1183 llvm::SmallVector<ParmVarDecl*, 16> Params;
Mike Stump1eb44332009-09-09 15:08:12 +00001184 for (FunctionProtoType::arg_type_iterator
1185 ParamType = OldProto->arg_type_begin(),
Douglas Gregor450da982009-02-16 20:58:07 +00001186 ParamEnd = OldProto->arg_type_end();
1187 ParamType != ParamEnd; ++ParamType) {
1188 ParmVarDecl *Param = ParmVarDecl::Create(Context, New,
1189 SourceLocation(), 0,
John McCalla93c9342009-12-07 02:54:59 +00001190 *ParamType, /*TInfo=*/0,
Douglas Gregor16573fa2010-04-19 22:54:31 +00001191 VarDecl::None, VarDecl::None,
1192 0);
Douglas Gregor450da982009-02-16 20:58:07 +00001193 Param->setImplicit();
1194 Params.push_back(Param);
1195 }
1196
Douglas Gregor838db382010-02-11 01:19:42 +00001197 New->setParams(Params.data(), Params.size());
Mike Stump1eb44332009-09-09 15:08:12 +00001198 }
Douglas Gregor68719812009-02-16 18:20:44 +00001199
Douglas Gregor04495c82009-02-24 01:23:02 +00001200 return MergeCompatibleFunctionDecls(New, Old);
Chris Lattner04421082008-04-08 04:40:51 +00001201 }
Chris Lattnere3995fe2007-11-06 06:07:26 +00001202
Douglas Gregorc8376562009-03-06 22:43:54 +00001203 // GNU C permits a K&R definition to follow a prototype declaration
1204 // if the declared types of the parameters in the K&R definition
1205 // match the types in the prototype declaration, even when the
1206 // promoted types of the parameters from the K&R definition differ
1207 // from the types in the prototype. GCC then keeps the types from
1208 // the prototype.
Eli Friedmanbc4e29f2009-06-01 09:24:59 +00001209 //
1210 // If a variadic prototype is followed by a non-variadic K&R definition,
1211 // the K&R definition becomes variadic. This is sort of an edge case, but
1212 // it's legal per the standard depending on how you read C99 6.7.5.3p15 and
1213 // C99 6.9.1p8.
Douglas Gregorc8376562009-03-06 22:43:54 +00001214 if (!getLangOptions().CPlusPlus &&
Douglas Gregorc8376562009-03-06 22:43:54 +00001215 Old->hasPrototype() && !New->hasPrototype() &&
John McCall183700f2009-09-21 23:43:11 +00001216 New->getType()->getAs<FunctionProtoType>() &&
Douglas Gregorc8376562009-03-06 22:43:54 +00001217 Old->getNumParams() == New->getNumParams()) {
1218 llvm::SmallVector<QualType, 16> ArgTypes;
1219 llvm::SmallVector<GNUCompatibleParamWarning, 16> Warnings;
Mike Stump1eb44332009-09-09 15:08:12 +00001220 const FunctionProtoType *OldProto
John McCall183700f2009-09-21 23:43:11 +00001221 = Old->getType()->getAs<FunctionProtoType>();
Mike Stump1eb44332009-09-09 15:08:12 +00001222 const FunctionProtoType *NewProto
John McCall183700f2009-09-21 23:43:11 +00001223 = New->getType()->getAs<FunctionProtoType>();
Mike Stump1eb44332009-09-09 15:08:12 +00001224
Douglas Gregorc8376562009-03-06 22:43:54 +00001225 // Determine whether this is the GNU C extension.
Eli Friedmanbc4e29f2009-06-01 09:24:59 +00001226 QualType MergedReturn = Context.mergeTypes(OldProto->getResultType(),
1227 NewProto->getResultType());
1228 bool LooseCompatible = !MergedReturn.isNull();
Mike Stump1eb44332009-09-09 15:08:12 +00001229 for (unsigned Idx = 0, End = Old->getNumParams();
Eli Friedmanbc4e29f2009-06-01 09:24:59 +00001230 LooseCompatible && Idx != End; ++Idx) {
Douglas Gregorc8376562009-03-06 22:43:54 +00001231 ParmVarDecl *OldParm = Old->getParamDecl(Idx);
1232 ParmVarDecl *NewParm = New->getParamDecl(Idx);
Mike Stump1eb44332009-09-09 15:08:12 +00001233 if (Context.typesAreCompatible(OldParm->getType(),
Douglas Gregorc8376562009-03-06 22:43:54 +00001234 NewProto->getArgType(Idx))) {
1235 ArgTypes.push_back(NewParm->getType());
1236 } else if (Context.typesAreCompatible(OldParm->getType(),
1237 NewParm->getType())) {
Mike Stump1eb44332009-09-09 15:08:12 +00001238 GNUCompatibleParamWarning Warn
Douglas Gregorc8376562009-03-06 22:43:54 +00001239 = { OldParm, NewParm, NewProto->getArgType(Idx) };
1240 Warnings.push_back(Warn);
1241 ArgTypes.push_back(NewParm->getType());
1242 } else
Eli Friedmanbc4e29f2009-06-01 09:24:59 +00001243 LooseCompatible = false;
Douglas Gregorc8376562009-03-06 22:43:54 +00001244 }
1245
Eli Friedmanbc4e29f2009-06-01 09:24:59 +00001246 if (LooseCompatible) {
Douglas Gregorc8376562009-03-06 22:43:54 +00001247 for (unsigned Warn = 0; Warn < Warnings.size(); ++Warn) {
1248 Diag(Warnings[Warn].NewParm->getLocation(),
1249 diag::ext_param_promoted_not_compatible_with_prototype)
1250 << Warnings[Warn].PromotedType
1251 << Warnings[Warn].OldParm->getType();
Mike Stump1eb44332009-09-09 15:08:12 +00001252 Diag(Warnings[Warn].OldParm->getLocation(),
Douglas Gregorc8376562009-03-06 22:43:54 +00001253 diag::note_previous_declaration);
1254 }
1255
Eli Friedmanbc4e29f2009-06-01 09:24:59 +00001256 New->setType(Context.getFunctionType(MergedReturn, &ArgTypes[0],
1257 ArgTypes.size(),
Douglas Gregorce056bc2010-02-21 22:15:06 +00001258 OldProto->isVariadic(), 0,
1259 false, false, 0, 0,
Rafael Espindola264ba482010-03-30 20:24:48 +00001260 OldProto->getExtInfo()));
Douglas Gregorc8376562009-03-06 22:43:54 +00001261 return MergeCompatibleFunctionDecls(New, Old);
1262 }
1263
1264 // Fall through to diagnose conflicting types.
1265 }
1266
Steve Naroff837618c2008-01-16 15:01:34 +00001267 // A function that has already been declared has been redeclared or defined
1268 // with a different type- show appropriate diagnostic
Douglas Gregor7814e6d2009-09-12 00:22:50 +00001269 if (unsigned BuiltinID = Old->getBuiltinID()) {
Douglas Gregorcda9c672009-02-16 17:45:42 +00001270 // The user has declared a builtin function with an incompatible
1271 // signature.
1272 if (Context.BuiltinInfo.isPredefinedLibFunction(BuiltinID)) {
1273 // The function the user is redeclaring is a library-defined
1274 // function like 'malloc' or 'printf'. Warn about the
Douglas Gregor374e1562009-03-23 17:47:24 +00001275 // redeclaration, then pretend that we don't know about this
1276 // library built-in.
Douglas Gregorcda9c672009-02-16 17:45:42 +00001277 Diag(New->getLocation(), diag::warn_redecl_library_builtin) << New;
1278 Diag(Old->getLocation(), diag::note_previous_builtin_declaration)
1279 << Old << Old->getType();
Douglas Gregor374e1562009-03-23 17:47:24 +00001280 New->getIdentifier()->setBuiltinID(Builtin::NotBuiltin);
1281 Old->setInvalidDecl();
1282 return false;
Douglas Gregorcda9c672009-02-16 17:45:42 +00001283 }
Steve Naroff837618c2008-01-16 15:01:34 +00001284
Douglas Gregorcda9c672009-02-16 17:45:42 +00001285 PrevDiag = diag::note_previous_builtin_declaration;
1286 }
1287
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00001288 Diag(New->getLocation(), diag::err_conflicting_types) << New->getDeclName();
Douglas Gregor3e41d602009-02-13 23:20:09 +00001289 Diag(Old->getLocation(), PrevDiag) << Old << Old->getType();
Douglas Gregorcda9c672009-02-16 17:45:42 +00001290 return true;
Reid Spencer5f016e22007-07-11 17:01:13 +00001291}
1292
Douglas Gregor04495c82009-02-24 01:23:02 +00001293/// \brief Completes the merge of two function declarations that are
Mike Stump1eb44332009-09-09 15:08:12 +00001294/// known to be compatible.
Douglas Gregor04495c82009-02-24 01:23:02 +00001295///
1296/// This routine handles the merging of attributes and other
1297/// properties of function declarations form the old declaration to
1298/// the new declaration, once we know that New is in fact a
1299/// redeclaration of Old.
1300///
1301/// \returns false
1302bool Sema::MergeCompatibleFunctionDecls(FunctionDecl *New, FunctionDecl *Old) {
1303 // Merge the attributes
Chris Lattnercc581472009-03-04 06:05:19 +00001304 MergeAttributes(New, Old, Context);
Douglas Gregor04495c82009-02-24 01:23:02 +00001305
1306 // Merge the storage class.
Douglas Gregor1fc09a92009-09-13 07:46:26 +00001307 if (Old->getStorageClass() != FunctionDecl::Extern &&
1308 Old->getStorageClass() != FunctionDecl::None)
Douglas Gregor9f9bf252009-04-28 06:37:30 +00001309 New->setStorageClass(Old->getStorageClass());
Douglas Gregor04495c82009-02-24 01:23:02 +00001310
Douglas Gregor04495c82009-02-24 01:23:02 +00001311 // Merge "pure" flag.
1312 if (Old->isPure())
1313 New->setPure();
1314
1315 // Merge the "deleted" flag.
1316 if (Old->isDeleted())
1317 New->setDeleted();
Mike Stump1eb44332009-09-09 15:08:12 +00001318
Douglas Gregor04495c82009-02-24 01:23:02 +00001319 if (getLangOptions().CPlusPlus)
1320 return MergeCXXFunctionDecl(New, Old);
1321
1322 return false;
1323}
1324
Reid Spencer5f016e22007-07-11 17:01:13 +00001325/// MergeVarDecl - We just parsed a variable 'New' which has the same name
1326/// and scope as a previous declaration 'Old'. Figure out how to resolve this
1327/// situation, merging decls or emitting diagnostics as appropriate.
1328///
Mike Stump1eb44332009-09-09 15:08:12 +00001329/// Tentative definition rules (C99 6.9.2p2) are checked by
1330/// FinalizeDeclaratorGroup. Unfortunately, we can't analyze tentative
Steve Naroffff9eb1f2008-08-08 17:50:35 +00001331/// definitions here, since the initializer hasn't been attached.
Mike Stump1eb44332009-09-09 15:08:12 +00001332///
John McCall68263142009-11-18 22:49:29 +00001333void Sema::MergeVarDecl(VarDecl *New, LookupResult &Previous) {
1334 // If the new decl is already invalid, don't do any other checking.
1335 if (New->isInvalidDecl())
1336 return;
Mike Stump1eb44332009-09-09 15:08:12 +00001337
Reid Spencer5f016e22007-07-11 17:01:13 +00001338 // Verify the old decl was also a variable.
John McCall68263142009-11-18 22:49:29 +00001339 VarDecl *Old = 0;
1340 if (!Previous.isSingleResult() ||
1341 !(Old = dyn_cast<VarDecl>(Previous.getFoundDecl()))) {
Chris Lattnerf3a41af2008-11-20 06:38:18 +00001342 Diag(New->getLocation(), diag::err_redefinition_different_kind)
Chris Lattner08631c52008-11-23 21:45:46 +00001343 << New->getDeclName();
John McCall68263142009-11-18 22:49:29 +00001344 Diag(Previous.getRepresentativeDecl()->getLocation(),
1345 diag::note_previous_definition);
Chris Lattnereaaebc72009-04-25 08:06:05 +00001346 return New->setInvalidDecl();
Reid Spencer5f016e22007-07-11 17:01:13 +00001347 }
Chris Lattnerddee4232008-03-03 03:28:21 +00001348
Chris Lattnercc581472009-03-04 06:05:19 +00001349 MergeAttributes(New, Old, Context);
Chris Lattnerddee4232008-03-03 03:28:21 +00001350
Eli Friedman13ca96a2009-01-24 23:49:55 +00001351 // Merge the types
Eli Friedman88d936b2009-05-16 13:54:38 +00001352 QualType MergedT;
1353 if (getLangOptions().CPlusPlus) {
1354 if (Context.hasSameType(New->getType(), Old->getType()))
1355 MergedT = New->getType();
Eli Friedman153c33e2009-12-10 08:54:47 +00001356 // C++ [basic.link]p10:
1357 // [...] the types specified by all declarations referring to a given
1358 // object or function shall be identical, except that declarations for an
1359 // array object can specify array types that differ by the presence or
1360 // absence of a major array bound (8.3.4).
Mike Stump1eb44332009-09-09 15:08:12 +00001361 else if (Old->getType()->isIncompleteArrayType() &&
Douglas Gregor8dfb7ec2009-09-09 06:04:29 +00001362 New->getType()->isArrayType()) {
Mike Stump1eb44332009-09-09 15:08:12 +00001363 CanQual<ArrayType> OldArray
Douglas Gregor8dfb7ec2009-09-09 06:04:29 +00001364 = Context.getCanonicalType(Old->getType())->getAs<ArrayType>();
Mike Stump1eb44332009-09-09 15:08:12 +00001365 CanQual<ArrayType> NewArray
Douglas Gregor8dfb7ec2009-09-09 06:04:29 +00001366 = Context.getCanonicalType(New->getType())->getAs<ArrayType>();
1367 if (OldArray->getElementType() == NewArray->getElementType())
1368 MergedT = New->getType();
Eli Friedman153c33e2009-12-10 08:54:47 +00001369 } else if (Old->getType()->isArrayType() &&
1370 New->getType()->isIncompleteArrayType()) {
1371 CanQual<ArrayType> OldArray
1372 = Context.getCanonicalType(Old->getType())->getAs<ArrayType>();
1373 CanQual<ArrayType> NewArray
1374 = Context.getCanonicalType(New->getType())->getAs<ArrayType>();
1375 if (OldArray->getElementType() == NewArray->getElementType())
1376 MergedT = Old->getType();
Fariborz Jahanian2390a722010-05-19 21:37:30 +00001377 } else if (New->getType()->isObjCObjectPointerType()
1378 && Old->getType()->isObjCObjectPointerType()) {
1379 MergedT = Context.mergeObjCGCQualifiers(New->getType(), Old->getType());
Douglas Gregor8dfb7ec2009-09-09 06:04:29 +00001380 }
Eli Friedman88d936b2009-05-16 13:54:38 +00001381 } else {
1382 MergedT = Context.mergeTypes(New->getType(), Old->getType());
1383 }
Eli Friedman13ca96a2009-01-24 23:49:55 +00001384 if (MergedT.isNull()) {
Mike Stump1eb44332009-09-09 15:08:12 +00001385 Diag(New->getLocation(), diag::err_redefinition_different_type)
Douglas Gregor6037fcb2009-01-09 19:42:16 +00001386 << New->getDeclName();
Chris Lattner5f4a6822008-11-23 23:12:31 +00001387 Diag(Old->getLocation(), diag::note_previous_definition);
Chris Lattnereaaebc72009-04-25 08:06:05 +00001388 return New->setInvalidDecl();
Reid Spencer5f016e22007-07-11 17:01:13 +00001389 }
Eli Friedman13ca96a2009-01-24 23:49:55 +00001390 New->setType(MergedT);
Douglas Gregor656de632009-03-11 23:52:16 +00001391
Steve Naroffb7b032e2008-01-30 00:44:01 +00001392 // C99 6.2.2p4: Check if we have a static decl followed by a non-static.
1393 if (New->getStorageClass() == VarDecl::Static &&
Daniel Dunbar5466c7b2009-04-14 02:25:56 +00001394 (Old->getStorageClass() == VarDecl::None || Old->hasExternalStorage())) {
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00001395 Diag(New->getLocation(), diag::err_static_non_static) << New->getDeclName();
Chris Lattner5f4a6822008-11-23 23:12:31 +00001396 Diag(Old->getLocation(), diag::note_previous_definition);
Chris Lattnereaaebc72009-04-25 08:06:05 +00001397 return New->setInvalidDecl();
Steve Naroffb7b032e2008-01-30 00:44:01 +00001398 }
Mike Stump1eb44332009-09-09 15:08:12 +00001399 // C99 6.2.2p4:
Douglas Gregor5ef122e2009-03-19 22:01:50 +00001400 // For an identifier declared with the storage-class specifier
1401 // extern in a scope in which a prior declaration of that
1402 // identifier is visible,23) if the prior declaration specifies
1403 // internal or external linkage, the linkage of the identifier at
1404 // the later declaration is the same as the linkage specified at
1405 // the prior declaration. If no prior declaration is visible, or
1406 // if the prior declaration specifies no linkage, then the
1407 // identifier has external linkage.
Douglas Gregor38179b22009-03-23 16:17:01 +00001408 if (New->hasExternalStorage() && Old->hasLinkage())
Douglas Gregor5ef122e2009-03-19 22:01:50 +00001409 /* Okay */;
1410 else if (New->getStorageClass() != VarDecl::Static &&
1411 Old->getStorageClass() == VarDecl::Static) {
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00001412 Diag(New->getLocation(), diag::err_non_static_static) << New->getDeclName();
Chris Lattner5f4a6822008-11-23 23:12:31 +00001413 Diag(Old->getLocation(), diag::note_previous_definition);
Chris Lattnereaaebc72009-04-25 08:06:05 +00001414 return New->setInvalidDecl();
Steve Naroffb7b032e2008-01-30 00:44:01 +00001415 }
Daniel Dunbar5466c7b2009-04-14 02:25:56 +00001416
Steve Naroff094cefb2008-09-17 14:05:40 +00001417 // Variables with external linkage are analyzed in FinalizeDeclaratorGroup.
Mike Stump1eb44332009-09-09 15:08:12 +00001418
Daniel Dunbar5466c7b2009-04-14 02:25:56 +00001419 // FIXME: The test for external storage here seems wrong? We still
1420 // need to check for mismatches.
1421 if (!New->hasExternalStorage() && !New->isFileVarDecl() &&
Douglas Gregor656de632009-03-11 23:52:16 +00001422 // Don't complain about out-of-line definitions of static members.
1423 !(Old->getLexicalDeclContext()->isRecord() &&
1424 !New->getLexicalDeclContext()->isRecord())) {
Chris Lattner08631c52008-11-23 21:45:46 +00001425 Diag(New->getLocation(), diag::err_redefinition) << New->getDeclName();
Chris Lattner5f4a6822008-11-23 23:12:31 +00001426 Diag(Old->getLocation(), diag::note_previous_definition);
Chris Lattnereaaebc72009-04-25 08:06:05 +00001427 return New->setInvalidDecl();
Reid Spencer5f016e22007-07-11 17:01:13 +00001428 }
Douglas Gregor275a3692009-03-10 23:43:53 +00001429
Eli Friedman63054b32009-04-19 20:27:55 +00001430 if (New->isThreadSpecified() && !Old->isThreadSpecified()) {
1431 Diag(New->getLocation(), diag::err_thread_non_thread) << New->getDeclName();
1432 Diag(Old->getLocation(), diag::note_previous_definition);
1433 } else if (!New->isThreadSpecified() && Old->isThreadSpecified()) {
1434 Diag(New->getLocation(), diag::err_non_thread_thread) << New->getDeclName();
1435 Diag(Old->getLocation(), diag::note_previous_definition);
1436 }
1437
Sebastian Redl4cae1b32010-02-02 18:35:11 +00001438 // C++ doesn't have tentative definitions, so go right ahead and check here.
1439 const VarDecl *Def;
Sebastian Redl6c048a92010-02-03 02:08:48 +00001440 if (getLangOptions().CPlusPlus &&
1441 New->isThisDeclarationADefinition() == VarDecl::Definition &&
Sebastian Redl4cae1b32010-02-02 18:35:11 +00001442 (Def = Old->getDefinition())) {
1443 Diag(New->getLocation(), diag::err_redefinition)
1444 << New->getDeclName();
1445 Diag(Def->getLocation(), diag::note_previous_definition);
1446 New->setInvalidDecl();
1447 return;
1448 }
1449
Douglas Gregor275a3692009-03-10 23:43:53 +00001450 // Keep a chain of previous declarations.
1451 New->setPreviousDeclaration(Old);
John McCall46460a62010-01-20 21:53:11 +00001452
1453 // Inherit access appropriately.
1454 New->setAccess(Old->getAccess());
Reid Spencer5f016e22007-07-11 17:01:13 +00001455}
1456
1457/// ParsedFreeStandingDeclSpec - This method is invoked when a declspec with
1458/// no declarator (e.g. "struct foo;") is parsed.
John McCallaec03712010-05-21 20:45:30 +00001459Sema::DeclPtrTy Sema::ParsedFreeStandingDeclSpec(Scope *S, AccessSpecifier AS,
1460 DeclSpec &DS) {
Eli Friedmand2968362009-04-09 21:26:42 +00001461 // FIXME: Error on auto/register at file scope
1462 // FIXME: Error on inline/virtual/explicit
Eli Friedman63054b32009-04-19 20:27:55 +00001463 // FIXME: Warn on useless __thread
Eli Friedmand2968362009-04-09 21:26:42 +00001464 // FIXME: Warn on useless const/volatile
1465 // FIXME: Warn on useless static/extern/typedef/private_extern/mutable
1466 // FIXME: Warn on useless attributes
John McCalle3af0232009-10-07 23:34:25 +00001467 Decl *TagD = 0;
Douglas Gregor1a51b4a2009-02-09 15:09:02 +00001468 TagDecl *Tag = 0;
1469 if (DS.getTypeSpecType() == DeclSpec::TST_class ||
1470 DS.getTypeSpecType() == DeclSpec::TST_struct ||
1471 DS.getTypeSpecType() == DeclSpec::TST_union ||
Douglas Gregor4d9a16f2009-05-12 23:25:50 +00001472 DS.getTypeSpecType() == DeclSpec::TST_enum) {
John McCalle3af0232009-10-07 23:34:25 +00001473 TagD = static_cast<Decl *>(DS.getTypeRep());
1474
1475 if (!TagD) // We probably had an error
Douglas Gregor4d9a16f2009-05-12 23:25:50 +00001476 return DeclPtrTy();
1477
John McCall67d1a672009-08-06 02:15:43 +00001478 // Note that the above type specs guarantee that the
1479 // type rep is a Decl, whereas in many of the others
1480 // it's a Type.
John McCalle3af0232009-10-07 23:34:25 +00001481 Tag = dyn_cast<TagDecl>(TagD);
Douglas Gregor4d9a16f2009-05-12 23:25:50 +00001482 }
Douglas Gregor1a51b4a2009-02-09 15:09:02 +00001483
Nuno Lopes0a8bab02009-12-17 11:35:26 +00001484 if (unsigned TypeQuals = DS.getTypeQualifiers()) {
1485 // Enforce C99 6.7.3p2: "Types other than pointer types derived from object
1486 // or incomplete types shall not be restrict-qualified."
1487 if (TypeQuals & DeclSpec::TQ_restrict)
1488 Diag(DS.getRestrictSpecLoc(),
1489 diag::err_typecheck_invalid_restrict_not_pointer_noarg)
1490 << DS.getSourceRange();
1491 }
1492
Douglas Gregord85bea22009-09-26 06:47:28 +00001493 if (DS.isFriendSpecified()) {
John McCalle3af0232009-10-07 23:34:25 +00001494 // If we're dealing with a class template decl, assume that the
1495 // template routines are handling it.
1496 if (TagD && isa<ClassTemplateDecl>(TagD))
Douglas Gregord85bea22009-09-26 06:47:28 +00001497 return DeclPtrTy();
John McCalle3af0232009-10-07 23:34:25 +00001498 return ActOnFriendTypeDecl(S, DS, MultiTemplateParamsArg(*this, 0, 0));
Douglas Gregord85bea22009-09-26 06:47:28 +00001499 }
1500
Douglas Gregor4920f1f2009-01-12 22:49:06 +00001501 if (RecordDecl *Record = dyn_cast_or_null<RecordDecl>(Tag)) {
Chris Lattnerd451f832009-10-25 22:21:57 +00001502 // If there are attributes in the DeclSpec, apply them to the record.
1503 if (const AttributeList *AL = DS.getAttributes())
1504 ProcessDeclAttributeList(S, Record, AL);
1505
Douglas Gregor4920f1f2009-01-12 22:49:06 +00001506 if (!Record->getDeclName() && Record->isDefinition() &&
Douglas Gregora71c1292009-03-06 23:06:59 +00001507 DS.getStorageClassSpec() != DeclSpec::SCS_typedef) {
1508 if (getLangOptions().CPlusPlus ||
1509 Record->getDeclContext()->isRecord())
John McCallaec03712010-05-21 20:45:30 +00001510 return BuildAnonymousStructOrUnion(S, DS, AS, Record);
Douglas Gregora71c1292009-03-06 23:06:59 +00001511
Douglas Gregorcb821d02010-04-08 21:33:23 +00001512 Diag(DS.getSourceRange().getBegin(), diag::ext_no_declarators)
Douglas Gregora71c1292009-03-06 23:06:59 +00001513 << DS.getSourceRange();
1514 }
Douglas Gregor4920f1f2009-01-12 22:49:06 +00001515
1516 // Microsoft allows unnamed struct/union fields. Don't complain
1517 // about them.
1518 // FIXME: Should we support Microsoft's extensions in this area?
1519 if (Record->getDeclName() && getLangOptions().Microsoft)
Chris Lattnerb28317a2009-03-28 19:18:32 +00001520 return DeclPtrTy::make(Tag);
Douglas Gregor4920f1f2009-01-12 22:49:06 +00001521 }
Douglas Gregord85bea22009-09-26 06:47:28 +00001522
Mike Stump1eb44332009-09-09 15:08:12 +00001523 if (!DS.isMissingDeclaratorOk() &&
Douglas Gregorddc29e12009-02-06 22:42:48 +00001524 DS.getTypeSpecType() != DeclSpec::TST_error) {
Douglas Gregor21282df2009-01-22 16:23:54 +00001525 // Warn about typedefs of enums without names, since this is an
1526 // extension in both Microsoft an GNU.
Douglas Gregor8158f692009-01-17 02:55:50 +00001527 if (DS.getStorageClassSpec() == DeclSpec::SCS_typedef &&
1528 Tag && isa<EnumDecl>(Tag)) {
Douglas Gregor21282df2009-01-22 16:23:54 +00001529 Diag(DS.getSourceRange().getBegin(), diag::ext_typedef_without_a_name)
Douglas Gregoree159c12009-01-13 23:10:51 +00001530 << DS.getSourceRange();
Chris Lattnerb28317a2009-03-28 19:18:32 +00001531 return DeclPtrTy::make(Tag);
Douglas Gregoree159c12009-01-13 23:10:51 +00001532 }
1533
Douglas Gregorcb821d02010-04-08 21:33:23 +00001534 Diag(DS.getSourceRange().getBegin(), diag::ext_no_declarators)
Sebastian Redla4ed0d82008-12-28 15:28:59 +00001535 << DS.getSourceRange();
Sebastian Redla4ed0d82008-12-28 15:28:59 +00001536 }
Mike Stump1eb44332009-09-09 15:08:12 +00001537
Chris Lattnerb28317a2009-03-28 19:18:32 +00001538 return DeclPtrTy::make(Tag);
Douglas Gregorbcbffc42009-01-07 00:43:41 +00001539}
1540
John McCall1d7c5282009-12-18 10:40:03 +00001541/// We are trying to inject an anonymous member into the given scope;
John McCall68263142009-11-18 22:49:29 +00001542/// check if there's an existing declaration that can't be overloaded.
1543///
1544/// \return true if this is a forbidden redeclaration
John McCall1d7c5282009-12-18 10:40:03 +00001545static bool CheckAnonMemberRedeclaration(Sema &SemaRef,
1546 Scope *S,
Fariborz Jahanian588a4ad2010-01-22 18:30:17 +00001547 DeclContext *Owner,
John McCall1d7c5282009-12-18 10:40:03 +00001548 DeclarationName Name,
1549 SourceLocation NameLoc,
1550 unsigned diagnostic) {
1551 LookupResult R(SemaRef, Name, NameLoc, Sema::LookupMemberName,
1552 Sema::ForRedeclaration);
1553 if (!SemaRef.LookupName(R, S)) return false;
John McCall68263142009-11-18 22:49:29 +00001554
John McCall1d7c5282009-12-18 10:40:03 +00001555 if (R.getAsSingle<TagDecl>())
John McCall68263142009-11-18 22:49:29 +00001556 return false;
1557
1558 // Pick a representative declaration.
John McCall1d7c5282009-12-18 10:40:03 +00001559 NamedDecl *PrevDecl = R.getRepresentativeDecl()->getUnderlyingDecl();
Fariborz Jahanian588a4ad2010-01-22 18:30:17 +00001560 if (PrevDecl && Owner->isRecord()) {
1561 RecordDecl *Record = cast<RecordDecl>(Owner);
1562 if (!SemaRef.isDeclInScope(PrevDecl, Record, S))
1563 return false;
1564 }
John McCall68263142009-11-18 22:49:29 +00001565
John McCall1d7c5282009-12-18 10:40:03 +00001566 SemaRef.Diag(NameLoc, diagnostic) << Name;
1567 SemaRef.Diag(PrevDecl->getLocation(), diag::note_previous_declaration);
John McCall68263142009-11-18 22:49:29 +00001568
1569 return true;
1570}
1571
Douglas Gregorbcbffc42009-01-07 00:43:41 +00001572/// InjectAnonymousStructOrUnionMembers - Inject the members of the
1573/// anonymous struct or union AnonRecord into the owning context Owner
1574/// and scope S. This routine will be invoked just after we realize
1575/// that an unnamed union or struct is actually an anonymous union or
1576/// struct, e.g.,
1577///
1578/// @code
1579/// union {
1580/// int i;
1581/// float f;
1582/// }; // InjectAnonymousStructOrUnionMembers called here to inject i and
1583/// // f into the surrounding scope.x
1584/// @endcode
1585///
1586/// This routine is recursive, injecting the names of nested anonymous
1587/// structs/unions into the owning context and scope as well.
John McCallaec03712010-05-21 20:45:30 +00001588static bool InjectAnonymousStructOrUnionMembers(Sema &SemaRef, Scope *S,
1589 DeclContext *Owner,
1590 RecordDecl *AnonRecord,
1591 AccessSpecifier AS) {
John McCall68263142009-11-18 22:49:29 +00001592 unsigned diagKind
1593 = AnonRecord->isUnion() ? diag::err_anonymous_union_member_redecl
1594 : diag::err_anonymous_struct_member_redecl;
1595
Douglas Gregorbcbffc42009-01-07 00:43:41 +00001596 bool Invalid = false;
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00001597 for (RecordDecl::field_iterator F = AnonRecord->field_begin(),
1598 FEnd = AnonRecord->field_end();
Douglas Gregorbcbffc42009-01-07 00:43:41 +00001599 F != FEnd; ++F) {
1600 if ((*F)->getDeclName()) {
John McCallaec03712010-05-21 20:45:30 +00001601 if (CheckAnonMemberRedeclaration(SemaRef, S, Owner, (*F)->getDeclName(),
John McCall1d7c5282009-12-18 10:40:03 +00001602 (*F)->getLocation(), diagKind)) {
Douglas Gregorbcbffc42009-01-07 00:43:41 +00001603 // C++ [class.union]p2:
1604 // The names of the members of an anonymous union shall be
1605 // distinct from the names of any other entity in the
1606 // scope in which the anonymous union is declared.
Douglas Gregorbcbffc42009-01-07 00:43:41 +00001607 Invalid = true;
1608 } else {
1609 // C++ [class.union]p2:
1610 // For the purpose of name lookup, after the anonymous union
1611 // definition, the members of the anonymous union are
1612 // considered to have been defined in the scope in which the
1613 // anonymous union is declared.
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00001614 Owner->makeDeclVisibleInContext(*F);
John McCallaec03712010-05-21 20:45:30 +00001615 S->AddDecl(Sema::DeclPtrTy::make(*F));
1616 SemaRef.IdResolver.AddDecl(*F);
1617
1618 // That includes picking up the appropriate access specifier.
1619 if (AS != AS_none) (*F)->setAccess(AS);
Douglas Gregorbcbffc42009-01-07 00:43:41 +00001620 }
1621 } else if (const RecordType *InnerRecordType
Ted Kremenek6217b802009-07-29 21:53:49 +00001622 = (*F)->getType()->getAs<RecordType>()) {
Douglas Gregorbcbffc42009-01-07 00:43:41 +00001623 RecordDecl *InnerRecord = InnerRecordType->getDecl();
1624 if (InnerRecord->isAnonymousStructOrUnion())
Mike Stump1eb44332009-09-09 15:08:12 +00001625 Invalid = Invalid ||
John McCallaec03712010-05-21 20:45:30 +00001626 InjectAnonymousStructOrUnionMembers(SemaRef, S, Owner,
1627 InnerRecord, AS);
Douglas Gregorbcbffc42009-01-07 00:43:41 +00001628 }
1629 }
1630
1631 return Invalid;
1632}
1633
Douglas Gregor16573fa2010-04-19 22:54:31 +00001634/// StorageClassSpecToVarDeclStorageClass - Maps a DeclSpec::SCS to
1635/// a VarDecl::StorageClass. Any error reporting is up to the caller:
1636/// illegal input values are mapped to VarDecl::None.
Abramo Bagnarab21b4052010-04-28 13:11:54 +00001637/// If the input declaration context is a linkage specification
1638/// with no braces, then Extern is mapped to None.
Douglas Gregor16573fa2010-04-19 22:54:31 +00001639static VarDecl::StorageClass
Abramo Bagnarab21b4052010-04-28 13:11:54 +00001640StorageClassSpecToVarDeclStorageClass(DeclSpec::SCS StorageClassSpec,
1641 DeclContext *DC) {
Douglas Gregor16573fa2010-04-19 22:54:31 +00001642 switch (StorageClassSpec) {
1643 case DeclSpec::SCS_unspecified: return VarDecl::None;
Abramo Bagnarab21b4052010-04-28 13:11:54 +00001644 case DeclSpec::SCS_extern:
1645 // If the current context is a C++ linkage specification
1646 // having no braces, then the keyword "extern" is properly part
1647 // of the linkage specification itself, rather than being
1648 // the written storage class specifier.
1649 return (DC && isa<LinkageSpecDecl>(DC) &&
1650 !cast<LinkageSpecDecl>(DC)->hasBraces())
1651 ? VarDecl::None : VarDecl::Extern;
Douglas Gregor16573fa2010-04-19 22:54:31 +00001652 case DeclSpec::SCS_static: return VarDecl::Static;
1653 case DeclSpec::SCS_auto: return VarDecl::Auto;
1654 case DeclSpec::SCS_register: return VarDecl::Register;
1655 case DeclSpec::SCS_private_extern: return VarDecl::PrivateExtern;
1656 // Illegal SCSs map to None: error reporting is up to the caller.
1657 case DeclSpec::SCS_mutable: // Fall through.
1658 case DeclSpec::SCS_typedef: return VarDecl::None;
1659 }
1660 llvm_unreachable("unknown storage class specifier");
1661}
1662
1663/// StorageClassSpecToFunctionDeclStorageClass - Maps a DeclSpec::SCS to
1664/// a FunctionDecl::StorageClass. Any error reporting is up to the caller:
1665/// illegal input values are mapped to FunctionDecl::None.
Abramo Bagnarab21b4052010-04-28 13:11:54 +00001666/// If the input declaration context is a linkage specification
1667/// with no braces, then Extern is mapped to None.
Douglas Gregor16573fa2010-04-19 22:54:31 +00001668static FunctionDecl::StorageClass
Abramo Bagnarab21b4052010-04-28 13:11:54 +00001669StorageClassSpecToFunctionDeclStorageClass(DeclSpec::SCS StorageClassSpec,
1670 DeclContext *DC) {
Douglas Gregor16573fa2010-04-19 22:54:31 +00001671 switch (StorageClassSpec) {
1672 case DeclSpec::SCS_unspecified: return FunctionDecl::None;
Abramo Bagnarab21b4052010-04-28 13:11:54 +00001673 case DeclSpec::SCS_extern:
1674 // If the current context is a C++ linkage specification
1675 // having no braces, then the keyword "extern" is properly part
1676 // of the linkage specification itself, rather than being
1677 // the written storage class specifier.
1678 return (DC && isa<LinkageSpecDecl>(DC) &&
1679 !cast<LinkageSpecDecl>(DC)->hasBraces())
1680 ? FunctionDecl::None : FunctionDecl::Extern;
Douglas Gregor16573fa2010-04-19 22:54:31 +00001681 case DeclSpec::SCS_static: return FunctionDecl::Static;
1682 case DeclSpec::SCS_private_extern: return FunctionDecl::PrivateExtern;
1683 // Illegal SCSs map to None: error reporting is up to the caller.
1684 case DeclSpec::SCS_auto: // Fall through.
1685 case DeclSpec::SCS_mutable: // Fall through.
1686 case DeclSpec::SCS_register: // Fall through.
1687 case DeclSpec::SCS_typedef: return FunctionDecl::None;
1688 }
1689 llvm_unreachable("unknown storage class specifier");
1690}
1691
Douglas Gregorbcbffc42009-01-07 00:43:41 +00001692/// ActOnAnonymousStructOrUnion - Handle the declaration of an
1693/// anonymous structure or union. Anonymous unions are a C++ feature
1694/// (C++ [class.union]) and a GNU C extension; anonymous structures
Mike Stump1eb44332009-09-09 15:08:12 +00001695/// are a GNU C and GNU C++ extension.
Chris Lattnerb28317a2009-03-28 19:18:32 +00001696Sema::DeclPtrTy Sema::BuildAnonymousStructOrUnion(Scope *S, DeclSpec &DS,
John McCallaec03712010-05-21 20:45:30 +00001697 AccessSpecifier AS,
Chris Lattnerb28317a2009-03-28 19:18:32 +00001698 RecordDecl *Record) {
Douglas Gregorbcbffc42009-01-07 00:43:41 +00001699 DeclContext *Owner = Record->getDeclContext();
1700
1701 // Diagnose whether this anonymous struct/union is an extension.
1702 if (Record->isUnion() && !getLangOptions().CPlusPlus)
1703 Diag(Record->getLocation(), diag::ext_anonymous_union);
1704 else if (!Record->isUnion())
1705 Diag(Record->getLocation(), diag::ext_anonymous_struct);
Mike Stump1eb44332009-09-09 15:08:12 +00001706
Douglas Gregorbcbffc42009-01-07 00:43:41 +00001707 // C and C++ require different kinds of checks for anonymous
1708 // structs/unions.
1709 bool Invalid = false;
1710 if (getLangOptions().CPlusPlus) {
1711 const char* PrevSpec = 0;
John McCallfec54012009-08-03 20:12:06 +00001712 unsigned DiagID;
Douglas Gregorbcbffc42009-01-07 00:43:41 +00001713 // C++ [class.union]p3:
1714 // Anonymous unions declared in a named namespace or in the
1715 // global namespace shall be declared static.
1716 if (DS.getStorageClassSpec() != DeclSpec::SCS_static &&
1717 (isa<TranslationUnitDecl>(Owner) ||
Mike Stump1eb44332009-09-09 15:08:12 +00001718 (isa<NamespaceDecl>(Owner) &&
Douglas Gregorbcbffc42009-01-07 00:43:41 +00001719 cast<NamespaceDecl>(Owner)->getDeclName()))) {
1720 Diag(Record->getLocation(), diag::err_anonymous_union_not_static);
1721 Invalid = true;
1722
1723 // Recover by adding 'static'.
John McCallfec54012009-08-03 20:12:06 +00001724 DS.SetStorageClassSpec(DeclSpec::SCS_static, SourceLocation(),
1725 PrevSpec, DiagID);
Mike Stump1eb44332009-09-09 15:08:12 +00001726 }
Douglas Gregorbcbffc42009-01-07 00:43:41 +00001727 // C++ [class.union]p3:
1728 // A storage class is not allowed in a declaration of an
1729 // anonymous union in a class scope.
1730 else if (DS.getStorageClassSpec() != DeclSpec::SCS_unspecified &&
1731 isa<RecordDecl>(Owner)) {
Mike Stump1eb44332009-09-09 15:08:12 +00001732 Diag(DS.getStorageClassSpecLoc(),
Douglas Gregorbcbffc42009-01-07 00:43:41 +00001733 diag::err_anonymous_union_with_storage_spec);
1734 Invalid = true;
1735
1736 // Recover by removing the storage specifier.
1737 DS.SetStorageClassSpec(DeclSpec::SCS_unspecified, SourceLocation(),
John McCallfec54012009-08-03 20:12:06 +00001738 PrevSpec, DiagID);
Douglas Gregorbcbffc42009-01-07 00:43:41 +00001739 }
Douglas Gregor6b3945f2009-01-07 19:46:03 +00001740
Mike Stump1eb44332009-09-09 15:08:12 +00001741 // C++ [class.union]p2:
Douglas Gregor6b3945f2009-01-07 19:46:03 +00001742 // The member-specification of an anonymous union shall only
1743 // define non-static data members. [Note: nested types and
1744 // functions cannot be declared within an anonymous union. ]
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00001745 for (DeclContext::decl_iterator Mem = Record->decls_begin(),
1746 MemEnd = Record->decls_end();
Douglas Gregor6b3945f2009-01-07 19:46:03 +00001747 Mem != MemEnd; ++Mem) {
1748 if (FieldDecl *FD = dyn_cast<FieldDecl>(*Mem)) {
1749 // C++ [class.union]p3:
1750 // An anonymous union shall not have private or protected
1751 // members (clause 11).
John McCallaec03712010-05-21 20:45:30 +00001752 assert(FD->getAccess() != AS_none);
1753 if (FD->getAccess() != AS_public) {
Douglas Gregor6b3945f2009-01-07 19:46:03 +00001754 Diag(FD->getLocation(), diag::err_anonymous_record_nonpublic_member)
1755 << (int)Record->isUnion() << (int)(FD->getAccess() == AS_protected);
1756 Invalid = true;
1757 }
1758 } else if ((*Mem)->isImplicit()) {
1759 // Any implicit members are fine.
Douglas Gregor1931b442009-02-03 00:34:39 +00001760 } else if (isa<TagDecl>(*Mem) && (*Mem)->getDeclContext() != Record) {
1761 // This is a type that showed up in an
1762 // elaborated-type-specifier inside the anonymous struct or
1763 // union, but which actually declares a type outside of the
1764 // anonymous struct or union. It's okay.
Douglas Gregor6b3945f2009-01-07 19:46:03 +00001765 } else if (RecordDecl *MemRecord = dyn_cast<RecordDecl>(*Mem)) {
1766 if (!MemRecord->isAnonymousStructOrUnion() &&
1767 MemRecord->getDeclName()) {
1768 // This is a nested type declaration.
1769 Diag(MemRecord->getLocation(), diag::err_anonymous_record_with_type)
1770 << (int)Record->isUnion();
1771 Invalid = true;
1772 }
Abramo Bagnara6206d532010-06-05 05:09:32 +00001773 } else if (isa<AccessSpecDecl>(*Mem)) {
1774 // Any access specifier is fine.
Douglas Gregor6b3945f2009-01-07 19:46:03 +00001775 } else {
1776 // We have something that isn't a non-static data
1777 // member. Complain about it.
1778 unsigned DK = diag::err_anonymous_record_bad_member;
1779 if (isa<TypeDecl>(*Mem))
1780 DK = diag::err_anonymous_record_with_type;
1781 else if (isa<FunctionDecl>(*Mem))
1782 DK = diag::err_anonymous_record_with_function;
1783 else if (isa<VarDecl>(*Mem))
1784 DK = diag::err_anonymous_record_with_static;
1785 Diag((*Mem)->getLocation(), DK)
1786 << (int)Record->isUnion();
1787 Invalid = true;
1788 }
1789 }
Mike Stump1eb44332009-09-09 15:08:12 +00001790 }
Douglas Gregorbcbffc42009-01-07 00:43:41 +00001791
1792 if (!Record->isUnion() && !Owner->isRecord()) {
Douglas Gregor4920f1f2009-01-12 22:49:06 +00001793 Diag(Record->getLocation(), diag::err_anonymous_struct_not_member)
1794 << (int)getLangOptions().CPlusPlus;
Douglas Gregorbcbffc42009-01-07 00:43:41 +00001795 Invalid = true;
1796 }
1797
John McCalleb692e02009-10-22 23:31:08 +00001798 // Mock up a declarator.
1799 Declarator Dc(DS, Declarator::TypeNameContext);
John McCallbf1a0282010-06-04 23:28:52 +00001800 TypeSourceInfo *TInfo = GetTypeForDeclarator(Dc, S);
John McCalla93c9342009-12-07 02:54:59 +00001801 assert(TInfo && "couldn't build declarator info for anonymous struct/union");
John McCalleb692e02009-10-22 23:31:08 +00001802
Mike Stump1eb44332009-09-09 15:08:12 +00001803 // Create a declaration for this anonymous struct/union.
Douglas Gregor4afa39d2009-01-20 01:17:11 +00001804 NamedDecl *Anon = 0;
Douglas Gregorbcbffc42009-01-07 00:43:41 +00001805 if (RecordDecl *OwningClass = dyn_cast<RecordDecl>(Owner)) {
1806 Anon = FieldDecl::Create(Context, OwningClass, Record->getLocation(),
Mike Stump1eb44332009-09-09 15:08:12 +00001807 /*IdentifierInfo=*/0,
Argyrios Kyrtzidisa5d82002009-08-21 00:31:54 +00001808 Context.getTypeDeclType(Record),
John McCalla93c9342009-12-07 02:54:59 +00001809 TInfo,
Argyrios Kyrtzidisa5d82002009-08-21 00:31:54 +00001810 /*BitWidth=*/0, /*Mutable=*/false);
John McCallaec03712010-05-21 20:45:30 +00001811 Anon->setAccess(AS);
Douglas Gregorfe60f842010-05-03 15:18:25 +00001812 if (getLangOptions().CPlusPlus) {
Douglas Gregor6b3945f2009-01-07 19:46:03 +00001813 FieldCollector->Add(cast<FieldDecl>(Anon));
Douglas Gregorfe60f842010-05-03 15:18:25 +00001814 if (!cast<CXXRecordDecl>(Record)->isEmpty())
1815 cast<CXXRecordDecl>(OwningClass)->setEmpty(false);
1816 }
Douglas Gregorbcbffc42009-01-07 00:43:41 +00001817 } else {
Douglas Gregor16573fa2010-04-19 22:54:31 +00001818 DeclSpec::SCS SCSpec = DS.getStorageClassSpec();
1819 assert(SCSpec != DeclSpec::SCS_typedef &&
1820 "Parser allowed 'typedef' as storage class VarDecl.");
Abramo Bagnarab21b4052010-04-28 13:11:54 +00001821 VarDecl::StorageClass SC = StorageClassSpecToVarDeclStorageClass(SCSpec, 0);
Douglas Gregor16573fa2010-04-19 22:54:31 +00001822 if (SCSpec == DeclSpec::SCS_mutable) {
Douglas Gregorbcbffc42009-01-07 00:43:41 +00001823 // mutable can only appear on non-static class members, so it's always
1824 // an error here
1825 Diag(Record->getLocation(), diag::err_mutable_nonmember);
1826 Invalid = true;
1827 SC = VarDecl::None;
Douglas Gregorbcbffc42009-01-07 00:43:41 +00001828 }
Douglas Gregor16573fa2010-04-19 22:54:31 +00001829 SCSpec = DS.getStorageClassSpecAsWritten();
1830 VarDecl::StorageClass SCAsWritten
Abramo Bagnarab21b4052010-04-28 13:11:54 +00001831 = StorageClassSpecToVarDeclStorageClass(SCSpec, 0);
Douglas Gregorbcbffc42009-01-07 00:43:41 +00001832
1833 Anon = VarDecl::Create(Context, Owner, Record->getLocation(),
Mike Stump1eb44332009-09-09 15:08:12 +00001834 /*IdentifierInfo=*/0,
Argyrios Kyrtzidisa5d82002009-08-21 00:31:54 +00001835 Context.getTypeDeclType(Record),
Douglas Gregor16573fa2010-04-19 22:54:31 +00001836 TInfo, SC, SCAsWritten);
Douglas Gregorbcbffc42009-01-07 00:43:41 +00001837 }
Douglas Gregor6b3945f2009-01-07 19:46:03 +00001838 Anon->setImplicit();
Douglas Gregorbcbffc42009-01-07 00:43:41 +00001839
1840 // Add the anonymous struct/union object to the current
1841 // context. We'll be referencing this object when we refer to one of
1842 // its members.
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00001843 Owner->addDecl(Anon);
Douglas Gregorfe60f842010-05-03 15:18:25 +00001844
Douglas Gregorbcbffc42009-01-07 00:43:41 +00001845 // Inject the members of the anonymous struct/union into the owning
1846 // context and into the identifier resolver chain for name lookup
1847 // purposes.
John McCallaec03712010-05-21 20:45:30 +00001848 if (InjectAnonymousStructOrUnionMembers(*this, S, Owner, Record, AS))
Douglas Gregor4920f1f2009-01-12 22:49:06 +00001849 Invalid = true;
Douglas Gregorbcbffc42009-01-07 00:43:41 +00001850
1851 // Mark this as an anonymous struct/union type. Note that we do not
1852 // do this until after we have already checked and injected the
1853 // members of this anonymous struct/union type, because otherwise
1854 // the members could be injected twice: once by DeclContext when it
1855 // builds its lookup table, and once by
Mike Stump1eb44332009-09-09 15:08:12 +00001856 // InjectAnonymousStructOrUnionMembers.
Douglas Gregorbcbffc42009-01-07 00:43:41 +00001857 Record->setAnonymousStructOrUnion(true);
1858
1859 if (Invalid)
1860 Anon->setInvalidDecl();
1861
Chris Lattnerb28317a2009-03-28 19:18:32 +00001862 return DeclPtrTy::make(Anon);
Reid Spencer5f016e22007-07-11 17:01:13 +00001863}
1864
Steve Narofff0090632007-09-02 02:04:30 +00001865
Douglas Gregor10bd3682008-11-17 22:58:34 +00001866/// GetNameForDeclarator - Determine the full declaration name for the
1867/// given Declarator.
1868DeclarationName Sema::GetNameForDeclarator(Declarator &D) {
Douglas Gregor02a24ee2009-11-03 16:56:39 +00001869 return GetNameFromUnqualifiedId(D.getName());
1870}
1871
1872/// \brief Retrieves the canonicalized name from a parsed unqualified-id.
John McCall129e2df2009-11-30 22:42:35 +00001873DeclarationName Sema::GetNameFromUnqualifiedId(const UnqualifiedId &Name) {
Douglas Gregor3f9a0562009-11-03 01:35:08 +00001874 switch (Name.getKind()) {
Douglas Gregor02a24ee2009-11-03 16:56:39 +00001875 case UnqualifiedId::IK_Identifier:
1876 return DeclarationName(Name.Identifier);
Douglas Gregor3f9a0562009-11-03 01:35:08 +00001877
Douglas Gregor02a24ee2009-11-03 16:56:39 +00001878 case UnqualifiedId::IK_OperatorFunctionId:
1879 return Context.DeclarationNames.getCXXOperatorName(
Sean Huntf4fdd9b2009-11-29 03:04:53 +00001880 Name.OperatorFunctionId.Operator);
Sean Hunt0486d742009-11-28 04:44:28 +00001881
1882 case UnqualifiedId::IK_LiteralOperatorId:
Sean Hunt3e518bd2009-11-29 07:34:05 +00001883 return Context.DeclarationNames.getCXXLiteralOperatorName(
1884 Name.Identifier);
Sean Hunt0486d742009-11-28 04:44:28 +00001885
Douglas Gregor02a24ee2009-11-03 16:56:39 +00001886 case UnqualifiedId::IK_ConversionFunctionId: {
1887 QualType Ty = GetTypeFromParser(Name.ConversionFunctionId);
1888 if (Ty.isNull())
1889 return DeclarationName();
Douglas Gregordb422df2009-09-25 21:45:23 +00001890
Douglas Gregor02a24ee2009-11-03 16:56:39 +00001891 return Context.DeclarationNames.getCXXConversionFunctionName(
Sean Huntf4fdd9b2009-11-29 03:04:53 +00001892 Context.getCanonicalType(Ty));
Douglas Gregor02a24ee2009-11-03 16:56:39 +00001893 }
1894
1895 case UnqualifiedId::IK_ConstructorName: {
1896 QualType Ty = GetTypeFromParser(Name.ConstructorName);
1897 if (Ty.isNull())
1898 return DeclarationName();
1899
1900 return Context.DeclarationNames.getCXXConstructorName(
Sean Huntf4fdd9b2009-11-29 03:04:53 +00001901 Context.getCanonicalType(Ty));
Douglas Gregor02a24ee2009-11-03 16:56:39 +00001902 }
1903
Douglas Gregor0efc2c12010-01-13 17:31:36 +00001904 case UnqualifiedId::IK_ConstructorTemplateId: {
1905 // In well-formed code, we can only have a constructor
1906 // template-id that refers to the current context, so go there
1907 // to find the actual type being constructed.
1908 CXXRecordDecl *CurClass = dyn_cast<CXXRecordDecl>(CurContext);
1909 if (!CurClass || CurClass->getIdentifier() != Name.TemplateId->Name)
1910 return DeclarationName();
1911
1912 // Determine the type of the class being constructed.
John McCall3cb0ebd2010-03-10 03:28:59 +00001913 QualType CurClassType = Context.getTypeDeclType(CurClass);
Douglas Gregor0efc2c12010-01-13 17:31:36 +00001914
1915 // FIXME: Check two things: that the template-id names the same type as
1916 // CurClassType, and that the template-id does not occur when the name
1917 // was qualified.
1918
1919 return Context.DeclarationNames.getCXXConstructorName(
1920 Context.getCanonicalType(CurClassType));
1921 }
1922
Douglas Gregor02a24ee2009-11-03 16:56:39 +00001923 case UnqualifiedId::IK_DestructorName: {
1924 QualType Ty = GetTypeFromParser(Name.DestructorName);
1925 if (Ty.isNull())
1926 return DeclarationName();
1927
1928 return Context.DeclarationNames.getCXXDestructorName(
1929 Context.getCanonicalType(Ty));
1930 }
1931
1932 case UnqualifiedId::IK_TemplateId: {
1933 TemplateName TName
John McCall0bd6feb2009-12-02 08:04:21 +00001934 = TemplateName::getFromVoidPointer(Name.TemplateId->Template);
1935 return Context.getNameForTemplate(TName);
Douglas Gregor02a24ee2009-11-03 16:56:39 +00001936 }
Douglas Gregordb422df2009-09-25 21:45:23 +00001937 }
Douglas Gregor02a24ee2009-11-03 16:56:39 +00001938
Douglas Gregor10bd3682008-11-17 22:58:34 +00001939 assert(false && "Unknown name kind");
Douglas Gregor02a24ee2009-11-03 16:56:39 +00001940 return DeclarationName();
Douglas Gregor10bd3682008-11-17 22:58:34 +00001941}
1942
Douglas Gregor4ce205f2009-02-06 17:46:57 +00001943/// isNearlyMatchingFunction - Determine whether the C++ functions
1944/// Declaration and Definition are "nearly" matching. This heuristic
1945/// is used to improve diagnostics in the case where an out-of-line
1946/// function definition doesn't match any declaration within
1947/// the class or namespace.
1948static bool isNearlyMatchingFunction(ASTContext &Context,
1949 FunctionDecl *Declaration,
1950 FunctionDecl *Definition) {
Douglas Gregor584049d2008-12-15 23:53:10 +00001951 if (Declaration->param_size() != Definition->param_size())
1952 return false;
1953 for (unsigned Idx = 0; Idx < Declaration->param_size(); ++Idx) {
1954 QualType DeclParamTy = Declaration->getParamDecl(Idx)->getType();
1955 QualType DefParamTy = Definition->getParamDecl(Idx)->getType();
1956
Douglas Gregora4923eb2009-11-16 21:35:15 +00001957 if (!Context.hasSameUnqualifiedType(DeclParamTy.getNonReferenceType(),
1958 DefParamTy.getNonReferenceType()))
Douglas Gregor584049d2008-12-15 23:53:10 +00001959 return false;
1960 }
1961
1962 return true;
1963}
1964
John McCall63b43852010-04-29 23:50:39 +00001965/// NeedsRebuildingInCurrentInstantiation - Checks whether the given
1966/// declarator needs to be rebuilt in the current instantiation.
1967/// Any bits of declarator which appear before the name are valid for
1968/// consideration here. That's specifically the type in the decl spec
1969/// and the base type in any member-pointer chunks.
1970static bool RebuildDeclaratorInCurrentInstantiation(Sema &S, Declarator &D,
1971 DeclarationName Name) {
1972 // The types we specifically need to rebuild are:
1973 // - typenames, typeofs, and decltypes
1974 // - types which will become injected class names
1975 // Of course, we also need to rebuild any type referencing such a
1976 // type. It's safest to just say "dependent", but we call out a
1977 // few cases here.
1978
1979 DeclSpec &DS = D.getMutableDeclSpec();
1980 switch (DS.getTypeSpecType()) {
1981 case DeclSpec::TST_typename:
1982 case DeclSpec::TST_typeofType:
1983 case DeclSpec::TST_typeofExpr:
1984 case DeclSpec::TST_decltype: {
1985 // Grab the type from the parser.
1986 TypeSourceInfo *TSI = 0;
1987 QualType T = S.GetTypeFromParser(DS.getTypeRep(), &TSI);
1988 if (T.isNull() || !T->isDependentType()) break;
1989
1990 // Make sure there's a type source info. This isn't really much
1991 // of a waste; most dependent types should have type source info
1992 // attached already.
1993 if (!TSI)
1994 TSI = S.Context.getTrivialTypeSourceInfo(T, DS.getTypeSpecTypeLoc());
1995
1996 // Rebuild the type in the current instantiation.
1997 TSI = S.RebuildTypeInCurrentInstantiation(TSI, D.getIdentifierLoc(), Name);
1998 if (!TSI) return true;
1999
2000 // Store the new type back in the decl spec.
2001 QualType LocType = S.CreateLocInfoType(TSI->getType(), TSI);
2002 DS.UpdateTypeRep(LocType.getAsOpaquePtr());
2003 break;
2004 }
2005
2006 default:
2007 // Nothing to do for these decl specs.
2008 break;
2009 }
2010
2011 // It doesn't matter what order we do this in.
2012 for (unsigned I = 0, E = D.getNumTypeObjects(); I != E; ++I) {
2013 DeclaratorChunk &Chunk = D.getTypeObject(I);
2014
2015 // The only type information in the declarator which can come
2016 // before the declaration name is the base type of a member
2017 // pointer.
2018 if (Chunk.Kind != DeclaratorChunk::MemberPointer)
2019 continue;
2020
2021 // Rebuild the scope specifier in-place.
2022 CXXScopeSpec &SS = Chunk.Mem.Scope();
2023 if (S.RebuildNestedNameSpecifierInCurrentInstantiation(SS))
2024 return true;
2025 }
2026
2027 return false;
2028}
2029
Mike Stump1eb44332009-09-09 15:08:12 +00002030Sema::DeclPtrTy
2031Sema::HandleDeclarator(Scope *S, Declarator &D,
Douglas Gregore542c862009-06-23 23:11:28 +00002032 MultiTemplateParamsArg TemplateParamLists,
2033 bool IsFunctionDefinition) {
Douglas Gregor10bd3682008-11-17 22:58:34 +00002034 DeclarationName Name = GetNameForDeclarator(D);
2035
Chris Lattnere80a59c2007-07-25 00:24:17 +00002036 // All of these full declarators require an identifier. If it doesn't have
2037 // one, the ParsedFreeStandingDeclSpec action should be used.
Douglas Gregor10bd3682008-11-17 22:58:34 +00002038 if (!Name) {
Chris Lattnereaaebc72009-04-25 08:06:05 +00002039 if (!D.isInvalidType()) // Reject this if we think it is valid.
Chris Lattner1f6f54b2008-11-11 06:13:16 +00002040 Diag(D.getDeclSpec().getSourceRange().getBegin(),
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00002041 diag::err_declarator_need_ident)
2042 << D.getDeclSpec().getSourceRange() << D.getSourceRange();
Chris Lattnerb28317a2009-03-28 19:18:32 +00002043 return DeclPtrTy();
Chris Lattnere80a59c2007-07-25 00:24:17 +00002044 }
Mike Stump1eb44332009-09-09 15:08:12 +00002045
Chris Lattner31e05722007-08-26 06:24:45 +00002046 // The scope passed in may not be a decl scope. Zip up the scope tree until
2047 // we find one that is.
Douglas Gregor44b43212008-12-11 16:49:14 +00002048 while ((S->getFlags() & Scope::DeclScope) == 0 ||
Douglas Gregoraaba5e32009-02-04 19:02:06 +00002049 (S->getFlags() & Scope::TemplateParamScope) != 0)
Chris Lattner31e05722007-08-26 06:24:45 +00002050 S = S->getParent();
Mike Stump1eb44332009-09-09 15:08:12 +00002051
John McCall63b43852010-04-29 23:50:39 +00002052 DeclContext *DC = CurContext;
2053 if (D.getCXXScopeSpec().isInvalid())
2054 D.setInvalidType();
2055 else if (D.getCXXScopeSpec().isSet()) {
2056 bool EnteringContext = !D.getDeclSpec().isFriendSpecified();
2057 DC = computeDeclContext(D.getCXXScopeSpec(), EnteringContext);
2058 if (!DC) {
2059 // If we could not compute the declaration context, it's because the
2060 // declaration context is dependent but does not refer to a class,
2061 // class template, or class template partial specialization. Complain
2062 // and return early, to avoid the coming semantic disaster.
2063 Diag(D.getIdentifierLoc(),
2064 diag::err_template_qualified_declarator_no_match)
2065 << (NestedNameSpecifier*)D.getCXXScopeSpec().getScopeRep()
2066 << D.getCXXScopeSpec().getRange();
2067 return DeclPtrTy();
2068 }
John McCall0dd7ceb2009-12-19 09:35:56 +00002069
John McCall63b43852010-04-29 23:50:39 +00002070 bool IsDependentContext = DC->isDependentContext();
John McCall0dd7ceb2009-12-19 09:35:56 +00002071
John McCall63b43852010-04-29 23:50:39 +00002072 if (!IsDependentContext &&
John McCall77bb1aa2010-05-01 00:40:08 +00002073 RequireCompleteDeclContext(D.getCXXScopeSpec(), DC))
John McCall63b43852010-04-29 23:50:39 +00002074 return DeclPtrTy();
2075
2076 if (isa<CXXRecordDecl>(DC) && !cast<CXXRecordDecl>(DC)->hasDefinition()) {
2077 Diag(D.getIdentifierLoc(),
2078 diag::err_member_def_undefined_record)
2079 << Name << DC << D.getCXXScopeSpec().getRange();
2080 D.setInvalidType();
2081 }
2082
2083 // Check whether we need to rebuild the type of the given
2084 // declaration in the current instantiation.
2085 if (EnteringContext && IsDependentContext &&
2086 TemplateParamLists.size() != 0) {
2087 ContextRAII SavedContext(*this, DC);
2088 if (RebuildDeclaratorInCurrentInstantiation(*this, D, Name))
2089 D.setInvalidType();
Douglas Gregor4a959d82009-08-06 16:20:37 +00002090 }
2091 }
Mike Stump1eb44332009-09-09 15:08:12 +00002092
Douglas Gregor4afa39d2009-01-20 01:17:11 +00002093 NamedDecl *New;
Douglas Gregorcda9c672009-02-16 17:45:42 +00002094
John McCallbf1a0282010-06-04 23:28:52 +00002095 TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S);
2096 QualType R = TInfo->getType();
Douglas Gregord6f7e9d2009-02-24 20:03:32 +00002097
John McCall68263142009-11-18 22:49:29 +00002098 LookupResult Previous(*this, Name, D.getIdentifierLoc(), LookupOrdinaryName,
2099 ForRedeclaration);
2100
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +00002101 // See if this is a redefinition of a variable in the same scope.
John McCall63b43852010-04-29 23:50:39 +00002102 if (!D.getCXXScopeSpec().isSet()) {
John McCall68263142009-11-18 22:49:29 +00002103 bool IsLinkageLookup = false;
Douglas Gregord6f7e9d2009-02-24 20:03:32 +00002104
2105 // If the declaration we're planning to build will be a function
2106 // or object with linkage, then look for another declaration with
2107 // linkage (C99 6.2.2p4-5 and C++ [basic.link]p6).
2108 if (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_typedef)
2109 /* Do nothing*/;
2110 else if (R->isFunctionType()) {
Douglas Gregor6bec78d2009-07-07 17:00:05 +00002111 if (CurContext->isFunctionOrMethod() ||
2112 D.getDeclSpec().getStorageClassSpec() != DeclSpec::SCS_static)
John McCall68263142009-11-18 22:49:29 +00002113 IsLinkageLookup = true;
Douglas Gregord6f7e9d2009-02-24 20:03:32 +00002114 } else if (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_extern)
John McCall68263142009-11-18 22:49:29 +00002115 IsLinkageLookup = true;
Douglas Gregor6bec78d2009-07-07 17:00:05 +00002116 else if (CurContext->getLookupContext()->isTranslationUnit() &&
2117 D.getDeclSpec().getStorageClassSpec() != DeclSpec::SCS_static)
John McCall68263142009-11-18 22:49:29 +00002118 IsLinkageLookup = true;
2119
2120 if (IsLinkageLookup)
2121 Previous.clear(LookupRedeclarationWithLinkage);
Douglas Gregord6f7e9d2009-02-24 20:03:32 +00002122
John McCall68263142009-11-18 22:49:29 +00002123 LookupName(Previous, S, /* CreateBuiltins = */ IsLinkageLookup);
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +00002124 } else { // Something like "int foo::x;"
John McCall68263142009-11-18 22:49:29 +00002125 LookupQualifiedName(Previous, DC);
2126
2127 // Don't consider using declarations as previous declarations for
2128 // out-of-line members.
2129 RemoveUsingDecls(Previous);
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +00002130
2131 // C++ 7.3.1.2p2:
2132 // Members (including explicit specializations of templates) of a named
2133 // namespace can also be defined outside that namespace by explicit
2134 // qualification of the name being defined, provided that the entity being
2135 // defined was already declared in the namespace and the definition appears
2136 // after the point of declaration in a namespace that encloses the
2137 // declarations namespace.
2138 //
Douglas Gregor584049d2008-12-15 23:53:10 +00002139 // Note that we only check the context at this point. We don't yet
2140 // have enough information to make sure that PrevDecl is actually
2141 // the declaration we want to match. For example, given:
2142 //
Douglas Gregor9d350972008-12-12 08:25:50 +00002143 // class X {
2144 // void f();
Douglas Gregor584049d2008-12-15 23:53:10 +00002145 // void f(float);
Douglas Gregor9d350972008-12-12 08:25:50 +00002146 // };
2147 //
Douglas Gregor584049d2008-12-15 23:53:10 +00002148 // void X::f(int) { } // ill-formed
2149 //
2150 // In this case, PrevDecl will point to the overload set
2151 // containing the two f's declared in X, but neither of them
Mike Stump1eb44332009-09-09 15:08:12 +00002152 // matches.
Douglas Gregor4ce205f2009-02-06 17:46:57 +00002153
2154 // First check whether we named the global scope.
2155 if (isa<TranslationUnitDecl>(DC)) {
Mike Stump1eb44332009-09-09 15:08:12 +00002156 Diag(D.getIdentifierLoc(), diag::err_invalid_declarator_global_scope)
Douglas Gregor4ce205f2009-02-06 17:46:57 +00002157 << Name << D.getCXXScopeSpec().getRange();
Sebastian Redl9770ef02009-11-08 11:36:54 +00002158 } else {
2159 DeclContext *Cur = CurContext;
2160 while (isa<LinkageSpecDecl>(Cur))
2161 Cur = Cur->getParent();
2162 if (!Cur->Encloses(DC)) {
2163 // The qualifying scope doesn't enclose the original declaration.
2164 // Emit diagnostic based on current scope.
2165 SourceLocation L = D.getIdentifierLoc();
2166 SourceRange R = D.getCXXScopeSpec().getRange();
2167 if (isa<FunctionDecl>(Cur))
2168 Diag(L, diag::err_invalid_declarator_in_function) << Name << R;
2169 else
2170 Diag(L, diag::err_invalid_declarator_scope)
2171 << Name << cast<NamedDecl>(DC) << R;
2172 D.setInvalidType();
2173 }
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +00002174 }
2175 }
2176
John McCall68263142009-11-18 22:49:29 +00002177 if (Previous.isSingleResult() &&
2178 Previous.getFoundDecl()->isTemplateParameter()) {
Douglas Gregor72c3f312008-12-05 18:15:24 +00002179 // Maybe we will complain about the shadowed template parameter.
Mike Stump1eb44332009-09-09 15:08:12 +00002180 if (!D.isInvalidType())
John McCall68263142009-11-18 22:49:29 +00002181 if (DiagnoseTemplateParameterShadow(D.getIdentifierLoc(),
2182 Previous.getFoundDecl()))
Chris Lattnereaaebc72009-04-25 08:06:05 +00002183 D.setInvalidType();
Mike Stump1eb44332009-09-09 15:08:12 +00002184
Douglas Gregor72c3f312008-12-05 18:15:24 +00002185 // Just pretend that we didn't see the previous declaration.
John McCall68263142009-11-18 22:49:29 +00002186 Previous.clear();
Douglas Gregor72c3f312008-12-05 18:15:24 +00002187 }
2188
Douglas Gregor2ce52f32008-04-13 21:07:44 +00002189 // In C++, the previous declaration we find might be a tag type
2190 // (class or enum). In this case, the new declaration will hide the
Douglas Gregor66973122009-01-28 17:15:10 +00002191 // tag type. Note that this does does not apply if we're declaring a
2192 // typedef (C++ [dcl.typedef]p4).
John McCall68263142009-11-18 22:49:29 +00002193 if (Previous.isSingleTagDecl() &&
Douglas Gregor66973122009-01-28 17:15:10 +00002194 D.getDeclSpec().getStorageClassSpec() != DeclSpec::SCS_typedef)
John McCall68263142009-11-18 22:49:29 +00002195 Previous.clear();
Douglas Gregor2ce52f32008-04-13 21:07:44 +00002196
Douglas Gregorcda9c672009-02-16 17:45:42 +00002197 bool Redeclaration = false;
Reid Spencer5f016e22007-07-11 17:01:13 +00002198 if (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_typedef) {
Douglas Gregore542c862009-06-23 23:11:28 +00002199 if (TemplateParamLists.size()) {
2200 Diag(D.getIdentifierLoc(), diag::err_template_typedef);
2201 return DeclPtrTy();
2202 }
Mike Stump1eb44332009-09-09 15:08:12 +00002203
John McCalla93c9342009-12-07 02:54:59 +00002204 New = ActOnTypedefDeclarator(S, D, DC, R, TInfo, Previous, Redeclaration);
Douglas Gregord6f7e9d2009-02-24 20:03:32 +00002205 } else if (R->isFunctionType()) {
John McCalla93c9342009-12-07 02:54:59 +00002206 New = ActOnFunctionDeclarator(S, D, DC, R, TInfo, Previous,
Douglas Gregore542c862009-06-23 23:11:28 +00002207 move(TemplateParamLists),
Chris Lattnereaaebc72009-04-25 08:06:05 +00002208 IsFunctionDefinition, Redeclaration);
Reid Spencer5f016e22007-07-11 17:01:13 +00002209 } else {
John McCalla93c9342009-12-07 02:54:59 +00002210 New = ActOnVariableDeclarator(S, D, DC, R, TInfo, Previous,
Douglas Gregordfe3f2d2009-07-22 17:18:37 +00002211 move(TemplateParamLists),
2212 Redeclaration);
Reid Spencer5f016e22007-07-11 17:01:13 +00002213 }
Zhongxing Xu416fcaf2009-01-16 01:13:29 +00002214
2215 if (New == 0)
Chris Lattnerb28317a2009-03-28 19:18:32 +00002216 return DeclPtrTy();
Mike Stump1eb44332009-09-09 15:08:12 +00002217
Douglas Gregorb9aa6b22009-09-24 23:14:47 +00002218 // If this has an identifier and is not an invalid redeclaration or
2219 // function template specialization, add it to the scope stack.
Eli Friedman6bc20132009-12-08 05:40:03 +00002220 if (Name && !(Redeclaration && New->isInvalidDecl()))
Argyrios Kyrtzidis87f3ff02008-04-12 00:47:19 +00002221 PushOnScopeChains(New, S);
Mike Stump1eb44332009-09-09 15:08:12 +00002222
Chris Lattnerb28317a2009-03-28 19:18:32 +00002223 return DeclPtrTy::make(New);
Reid Spencer5f016e22007-07-11 17:01:13 +00002224}
2225
Eli Friedman1ca48132009-02-21 00:44:51 +00002226/// TryToFixInvalidVariablyModifiedType - Helper method to turn variable array
2227/// types into constant array types in certain situations which would otherwise
2228/// be errors (for GCC compatibility).
2229static QualType TryToFixInvalidVariablyModifiedType(QualType T,
2230 ASTContext &Context,
2231 bool &SizeIsNegative) {
2232 // This method tries to turn a variable array into a constant
2233 // array even when the size isn't an ICE. This is necessary
2234 // for compatibility with code that depends on gcc's buggy
2235 // constant expression folding, like struct {char x[(int)(char*)2];}
2236 SizeIsNegative = false;
2237
John McCall0953e762009-09-24 19:53:00 +00002238 QualifierCollector Qs;
2239 const Type *Ty = Qs.strip(T);
2240
2241 if (const PointerType* PTy = dyn_cast<PointerType>(Ty)) {
Eli Friedman1ca48132009-02-21 00:44:51 +00002242 QualType Pointee = PTy->getPointeeType();
2243 QualType FixedType =
2244 TryToFixInvalidVariablyModifiedType(Pointee, Context, SizeIsNegative);
2245 if (FixedType.isNull()) return FixedType;
Eli Friedman61125c82009-02-21 00:58:02 +00002246 FixedType = Context.getPointerType(FixedType);
John McCall0953e762009-09-24 19:53:00 +00002247 return Qs.apply(FixedType);
Eli Friedman1ca48132009-02-21 00:44:51 +00002248 }
2249
2250 const VariableArrayType* VLATy = dyn_cast<VariableArrayType>(T);
Eli Friedmanbc592e62009-02-26 03:58:54 +00002251 if (!VLATy)
2252 return QualType();
2253 // FIXME: We should probably handle this case
2254 if (VLATy->getElementType()->isVariablyModifiedType())
2255 return QualType();
Mike Stump1eb44332009-09-09 15:08:12 +00002256
Eli Friedman1ca48132009-02-21 00:44:51 +00002257 Expr::EvalResult EvalResult;
2258 if (!VLATy->getSizeExpr() ||
Eli Friedmanbc592e62009-02-26 03:58:54 +00002259 !VLATy->getSizeExpr()->Evaluate(EvalResult, Context) ||
2260 !EvalResult.Val.isInt())
Eli Friedman1ca48132009-02-21 00:44:51 +00002261 return QualType();
Eli Friedmanbc592e62009-02-26 03:58:54 +00002262
Eli Friedman1ca48132009-02-21 00:44:51 +00002263 llvm::APSInt &Res = EvalResult.Val.getInt();
Douglas Gregor7e7eb3d2009-07-06 15:59:29 +00002264 if (Res >= llvm::APSInt(Res.getBitWidth(), Res.isUnsigned())) {
John McCall46a617a2009-10-16 00:14:28 +00002265 // TODO: preserve the size expression in declarator info
2266 return Context.getConstantArrayType(VLATy->getElementType(),
2267 Res, ArrayType::Normal, 0);
Douglas Gregor7e7eb3d2009-07-06 15:59:29 +00002268 }
Eli Friedman1ca48132009-02-21 00:44:51 +00002269
2270 SizeIsNegative = true;
2271 return QualType();
2272}
2273
Douglas Gregor63935192009-03-02 00:19:53 +00002274/// \brief Register the given locally-scoped external C declaration so
2275/// that it can be found later for redeclarations
Mike Stump1eb44332009-09-09 15:08:12 +00002276void
John McCall68263142009-11-18 22:49:29 +00002277Sema::RegisterLocallyScopedExternCDecl(NamedDecl *ND,
2278 const LookupResult &Previous,
Douglas Gregor63935192009-03-02 00:19:53 +00002279 Scope *S) {
2280 assert(ND->getLexicalDeclContext()->isFunctionOrMethod() &&
2281 "Decl is not a locally-scoped decl!");
2282 // Note that we have a locally-scoped external with this name.
2283 LocallyScopedExternalDecls[ND->getDeclName()] = ND;
2284
John McCall68263142009-11-18 22:49:29 +00002285 if (!Previous.isSingleResult())
Douglas Gregor63935192009-03-02 00:19:53 +00002286 return;
2287
John McCall68263142009-11-18 22:49:29 +00002288 NamedDecl *PrevDecl = Previous.getFoundDecl();
2289
Douglas Gregor63935192009-03-02 00:19:53 +00002290 // If there was a previous declaration of this variable, it may be
2291 // in our identifier chain. Update the identifier chain with the new
2292 // declaration.
Douglas Gregor2dc0e642009-03-23 23:06:20 +00002293 if (S && IdResolver.ReplaceDecl(PrevDecl, ND)) {
Douglas Gregor63935192009-03-02 00:19:53 +00002294 // The previous declaration was found on the identifer resolver
2295 // chain, so remove it from its scope.
Chris Lattnerb28317a2009-03-28 19:18:32 +00002296 while (S && !S->isDeclScope(DeclPtrTy::make(PrevDecl)))
Douglas Gregor63935192009-03-02 00:19:53 +00002297 S = S->getParent();
2298
2299 if (S)
Chris Lattnerb28317a2009-03-28 19:18:32 +00002300 S->RemoveDecl(DeclPtrTy::make(PrevDecl));
Douglas Gregor63935192009-03-02 00:19:53 +00002301 }
2302}
2303
Eli Friedman85a53192009-04-07 19:37:57 +00002304/// \brief Diagnose function specifiers on a declaration of an identifier that
2305/// does not identify a function.
2306void Sema::DiagnoseFunctionSpecifiers(Declarator& D) {
2307 // FIXME: We should probably indicate the identifier in question to avoid
2308 // confusion for constructs like "inline int a(), b;"
2309 if (D.getDeclSpec().isInlineSpecified())
Mike Stump1eb44332009-09-09 15:08:12 +00002310 Diag(D.getDeclSpec().getInlineSpecLoc(),
Eli Friedman85a53192009-04-07 19:37:57 +00002311 diag::err_inline_non_function);
2312
2313 if (D.getDeclSpec().isVirtualSpecified())
Mike Stump1eb44332009-09-09 15:08:12 +00002314 Diag(D.getDeclSpec().getVirtualSpecLoc(),
Eli Friedman85a53192009-04-07 19:37:57 +00002315 diag::err_virtual_non_function);
2316
2317 if (D.getDeclSpec().isExplicitSpecified())
Mike Stump1eb44332009-09-09 15:08:12 +00002318 Diag(D.getDeclSpec().getExplicitSpecLoc(),
Eli Friedman85a53192009-04-07 19:37:57 +00002319 diag::err_explicit_non_function);
2320}
2321
Douglas Gregor4afa39d2009-01-20 01:17:11 +00002322NamedDecl*
Zhongxing Xud5ed8c32009-01-16 03:34:13 +00002323Sema::ActOnTypedefDeclarator(Scope* S, Declarator& D, DeclContext* DC,
John McCalla93c9342009-12-07 02:54:59 +00002324 QualType R, TypeSourceInfo *TInfo,
John McCall68263142009-11-18 22:49:29 +00002325 LookupResult &Previous, bool &Redeclaration) {
Zhongxing Xud5ed8c32009-01-16 03:34:13 +00002326 // Typedef declarators cannot be qualified (C++ [dcl.meaning]p1).
2327 if (D.getCXXScopeSpec().isSet()) {
2328 Diag(D.getIdentifierLoc(), diag::err_qualified_typedef_declarator)
2329 << D.getCXXScopeSpec().getRange();
Chris Lattnereaaebc72009-04-25 08:06:05 +00002330 D.setInvalidType();
Zhongxing Xud5ed8c32009-01-16 03:34:13 +00002331 // Pretend we didn't see the scope specifier.
Douglas Gregor9de672f2010-03-23 15:26:55 +00002332 DC = CurContext;
2333 Previous.clear();
Zhongxing Xud5ed8c32009-01-16 03:34:13 +00002334 }
2335
Douglas Gregor021c3b32009-03-11 23:00:04 +00002336 if (getLangOptions().CPlusPlus) {
2337 // Check that there are no default arguments (C++ only).
Zhongxing Xud5ed8c32009-01-16 03:34:13 +00002338 CheckExtraCXXDefaultArguments(D);
Douglas Gregor021c3b32009-03-11 23:00:04 +00002339 }
2340
Eli Friedman85a53192009-04-07 19:37:57 +00002341 DiagnoseFunctionSpecifiers(D);
2342
Eli Friedman63054b32009-04-19 20:27:55 +00002343 if (D.getDeclSpec().isThreadSpecified())
2344 Diag(D.getDeclSpec().getThreadSpecLoc(), diag::err_invalid_thread);
2345
John McCalla93c9342009-12-07 02:54:59 +00002346 TypedefDecl *NewTD = ParseTypedefDecl(S, D, R, TInfo);
Zhongxing Xud5ed8c32009-01-16 03:34:13 +00002347 if (!NewTD) return 0;
Mike Stump1eb44332009-09-09 15:08:12 +00002348
Zhongxing Xud5ed8c32009-01-16 03:34:13 +00002349 // Handle attributes prior to checking for duplicates in MergeVarDecl
Douglas Gregor9cdda0c2009-06-17 21:51:59 +00002350 ProcessDeclAttributes(S, NewTD, D);
John McCall68263142009-11-18 22:49:29 +00002351
Zhongxing Xud5ed8c32009-01-16 03:34:13 +00002352 // Merge the decl with the existing one if appropriate. If the decl is
2353 // in an outer scope, it isn't the same thing.
John McCall68263142009-11-18 22:49:29 +00002354 FilterLookupForScope(*this, Previous, DC, S, /*ConsiderLinkage*/ false);
2355 if (!Previous.empty()) {
Douglas Gregorcda9c672009-02-16 17:45:42 +00002356 Redeclaration = true;
John McCall68263142009-11-18 22:49:29 +00002357 MergeTypeDefDecl(NewTD, Previous);
Zhongxing Xud5ed8c32009-01-16 03:34:13 +00002358 }
2359
Chris Lattner38c5ebd2009-04-19 05:21:20 +00002360 // C99 6.7.7p2: If a typedef name specifies a variably modified type
2361 // then it shall have block scope.
2362 QualType T = NewTD->getUnderlyingType();
2363 if (T->isVariablyModifiedType()) {
Douglas Gregor9ea9bdb2010-03-01 23:15:13 +00002364 FunctionNeedsScopeChecking() = true;
Mike Stump1eb44332009-09-09 15:08:12 +00002365
Chris Lattner38c5ebd2009-04-19 05:21:20 +00002366 if (S->getFnParent() == 0) {
Eli Friedman1ca48132009-02-21 00:44:51 +00002367 bool SizeIsNegative;
2368 QualType FixedTy =
2369 TryToFixInvalidVariablyModifiedType(T, Context, SizeIsNegative);
2370 if (!FixedTy.isNull()) {
2371 Diag(D.getIdentifierLoc(), diag::warn_illegal_constant_array_size);
John McCalla93c9342009-12-07 02:54:59 +00002372 NewTD->setTypeSourceInfo(Context.getTrivialTypeSourceInfo(FixedTy));
Eli Friedman1ca48132009-02-21 00:44:51 +00002373 } else {
2374 if (SizeIsNegative)
2375 Diag(D.getIdentifierLoc(), diag::err_typecheck_negative_array_size);
2376 else if (T->isVariableArrayType())
2377 Diag(D.getIdentifierLoc(), diag::err_vla_decl_in_file_scope);
2378 else
2379 Diag(D.getIdentifierLoc(), diag::err_vm_decl_in_file_scope);
Chris Lattnereaaebc72009-04-25 08:06:05 +00002380 NewTD->setInvalidDecl();
Eli Friedman1ca48132009-02-21 00:44:51 +00002381 }
Zhongxing Xud5ed8c32009-01-16 03:34:13 +00002382 }
2383 }
Douglas Gregorc29f77b2009-07-07 16:35:42 +00002384
2385 // If this is the C FILE type, notify the AST context.
2386 if (IdentifierInfo *II = NewTD->getIdentifier())
2387 if (!NewTD->isInvalidDecl() &&
Mike Stump782fa302009-07-28 02:25:19 +00002388 NewTD->getDeclContext()->getLookupContext()->isTranslationUnit()) {
2389 if (II->isStr("FILE"))
2390 Context.setFILEDecl(NewTD);
2391 else if (II->isStr("jmp_buf"))
2392 Context.setjmp_bufDecl(NewTD);
2393 else if (II->isStr("sigjmp_buf"))
2394 Context.setsigjmp_bufDecl(NewTD);
2395 }
2396
Zhongxing Xud5ed8c32009-01-16 03:34:13 +00002397 return NewTD;
2398}
2399
Douglas Gregor8f301052009-02-24 19:23:27 +00002400/// \brief Determines whether the given declaration is an out-of-scope
2401/// previous declaration.
2402///
2403/// This routine should be invoked when name lookup has found a
2404/// previous declaration (PrevDecl) that is not in the scope where a
2405/// new declaration by the same name is being introduced. If the new
2406/// declaration occurs in a local scope, previous declarations with
2407/// linkage may still be considered previous declarations (C99
2408/// 6.2.2p4-5, C++ [basic.link]p6).
2409///
2410/// \param PrevDecl the previous declaration found by name
2411/// lookup
Mike Stump1eb44332009-09-09 15:08:12 +00002412///
Douglas Gregor8f301052009-02-24 19:23:27 +00002413/// \param DC the context in which the new declaration is being
2414/// declared.
2415///
2416/// \returns true if PrevDecl is an out-of-scope previous declaration
2417/// for a new delcaration with the same name.
Mike Stump1eb44332009-09-09 15:08:12 +00002418static bool
Douglas Gregor8f301052009-02-24 19:23:27 +00002419isOutOfScopePreviousDeclaration(NamedDecl *PrevDecl, DeclContext *DC,
2420 ASTContext &Context) {
2421 if (!PrevDecl)
2422 return 0;
2423
Douglas Gregord6f7e9d2009-02-24 20:03:32 +00002424 if (!PrevDecl->hasLinkage())
2425 return false;
Douglas Gregor8f301052009-02-24 19:23:27 +00002426
2427 if (Context.getLangOptions().CPlusPlus) {
2428 // C++ [basic.link]p6:
2429 // If there is a visible declaration of an entity with linkage
2430 // having the same name and type, ignoring entities declared
2431 // outside the innermost enclosing namespace scope, the block
2432 // scope declaration declares that same entity and receives the
2433 // linkage of the previous declaration.
2434 DeclContext *OuterContext = DC->getLookupContext();
2435 if (!OuterContext->isFunctionOrMethod())
2436 // This rule only applies to block-scope declarations.
2437 return false;
2438 else {
2439 DeclContext *PrevOuterContext = PrevDecl->getDeclContext();
2440 if (PrevOuterContext->isRecord())
2441 // We found a member function: ignore it.
2442 return false;
2443 else {
2444 // Find the innermost enclosing namespace for the new and
2445 // previous declarations.
2446 while (!OuterContext->isFileContext())
2447 OuterContext = OuterContext->getParent();
2448 while (!PrevOuterContext->isFileContext())
2449 PrevOuterContext = PrevOuterContext->getParent();
Mike Stump1eb44332009-09-09 15:08:12 +00002450
Douglas Gregor8f301052009-02-24 19:23:27 +00002451 // The previous declaration is in a different namespace, so it
2452 // isn't the same function.
Mike Stump1eb44332009-09-09 15:08:12 +00002453 if (OuterContext->getPrimaryContext() !=
Douglas Gregor8f301052009-02-24 19:23:27 +00002454 PrevOuterContext->getPrimaryContext())
2455 return false;
2456 }
2457 }
2458 }
2459
Douglas Gregor8f301052009-02-24 19:23:27 +00002460 return true;
2461}
2462
John McCallb6217662010-03-15 10:12:16 +00002463static void SetNestedNameSpecifier(DeclaratorDecl *DD, Declarator &D) {
2464 CXXScopeSpec &SS = D.getCXXScopeSpec();
2465 if (!SS.isSet()) return;
2466 DD->setQualifierInfo(static_cast<NestedNameSpecifier*>(SS.getScopeRep()),
2467 SS.getRange());
2468}
2469
Douglas Gregor4afa39d2009-01-20 01:17:11 +00002470NamedDecl*
Zhongxing Xucb8f4f12009-01-16 02:36:34 +00002471Sema::ActOnVariableDeclarator(Scope* S, Declarator& D, DeclContext* DC,
John McCalla93c9342009-12-07 02:54:59 +00002472 QualType R, TypeSourceInfo *TInfo,
John McCall68263142009-11-18 22:49:29 +00002473 LookupResult &Previous,
Douglas Gregordfe3f2d2009-07-22 17:18:37 +00002474 MultiTemplateParamsArg TemplateParamLists,
Douglas Gregorcda9c672009-02-16 17:45:42 +00002475 bool &Redeclaration) {
Zhongxing Xucb8f4f12009-01-16 02:36:34 +00002476 DeclarationName Name = GetNameForDeclarator(D);
2477
2478 // Check that there are no default arguments (C++ only).
2479 if (getLangOptions().CPlusPlus)
2480 CheckExtraCXXDefaultArguments(D);
2481
Douglas Gregor16573fa2010-04-19 22:54:31 +00002482 DeclSpec::SCS SCSpec = D.getDeclSpec().getStorageClassSpec();
2483 assert(SCSpec != DeclSpec::SCS_typedef &&
2484 "Parser allowed 'typedef' as storage class VarDecl.");
Abramo Bagnarab21b4052010-04-28 13:11:54 +00002485 VarDecl::StorageClass SC = StorageClassSpecToVarDeclStorageClass(SCSpec, 0);
Douglas Gregor16573fa2010-04-19 22:54:31 +00002486 if (SCSpec == DeclSpec::SCS_mutable) {
Zhongxing Xucb8f4f12009-01-16 02:36:34 +00002487 // mutable can only appear on non-static class members, so it's always
2488 // an error here
2489 Diag(D.getIdentifierLoc(), diag::err_mutable_nonmember);
Chris Lattnereaaebc72009-04-25 08:06:05 +00002490 D.setInvalidType();
Zhongxing Xucb8f4f12009-01-16 02:36:34 +00002491 SC = VarDecl::None;
Zhongxing Xucb8f4f12009-01-16 02:36:34 +00002492 }
Douglas Gregor16573fa2010-04-19 22:54:31 +00002493 SCSpec = D.getDeclSpec().getStorageClassSpecAsWritten();
2494 VarDecl::StorageClass SCAsWritten
Abramo Bagnarab21b4052010-04-28 13:11:54 +00002495 = StorageClassSpecToVarDeclStorageClass(SCSpec, DC);
Zhongxing Xucb8f4f12009-01-16 02:36:34 +00002496
2497 IdentifierInfo *II = Name.getAsIdentifierInfo();
2498 if (!II) {
2499 Diag(D.getIdentifierLoc(), diag::err_bad_variable_name)
2500 << Name.getAsString();
2501 return 0;
2502 }
2503
Eli Friedman85a53192009-04-07 19:37:57 +00002504 DiagnoseFunctionSpecifiers(D);
Douglas Gregor021c3b32009-03-11 23:00:04 +00002505
Douglas Gregor2d2e9cf2009-03-11 20:22:50 +00002506 if (!DC->isRecord() && S->getFnParent() == 0) {
2507 // C99 6.9p2: The storage-class specifiers auto and register shall not
2508 // appear in the declaration specifiers in an external declaration.
2509 if (SC == VarDecl::Auto || SC == VarDecl::Register) {
Mike Stump1eb44332009-09-09 15:08:12 +00002510
Chris Lattnerd4b19d52009-05-12 21:44:00 +00002511 // If this is a register variable with an asm label specified, then this
2512 // is a GNU extension.
2513 if (SC == VarDecl::Register && D.getAsmLabel())
2514 Diag(D.getIdentifierLoc(), diag::err_unsupported_global_register);
2515 else
2516 Diag(D.getIdentifierLoc(), diag::err_typecheck_sclass_fscope);
Chris Lattnereaaebc72009-04-25 08:06:05 +00002517 D.setInvalidType();
Zhongxing Xucb8f4f12009-01-16 02:36:34 +00002518 }
Zhongxing Xucb8f4f12009-01-16 02:36:34 +00002519 }
Douglas Gregor656de632009-03-11 23:52:16 +00002520 if (DC->isRecord() && !CurContext->isRecord()) {
2521 // This is an out-of-line definition of a static data member.
2522 if (SC == VarDecl::Static) {
Mike Stump1eb44332009-09-09 15:08:12 +00002523 Diag(D.getDeclSpec().getStorageClassSpecLoc(),
Douglas Gregor656de632009-03-11 23:52:16 +00002524 diag::err_static_out_of_line)
Douglas Gregor849b2432010-03-31 17:46:05 +00002525 << FixItHint::CreateRemoval(D.getDeclSpec().getStorageClassSpecLoc());
Douglas Gregor656de632009-03-11 23:52:16 +00002526 } else if (SC == VarDecl::None)
2527 SC = VarDecl::Static;
2528 }
Anders Carlssone98da2e2009-06-24 00:28:53 +00002529 if (SC == VarDecl::Static) {
2530 if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(DC)) {
2531 if (RD->isLocalClass())
Mike Stump1eb44332009-09-09 15:08:12 +00002532 Diag(D.getIdentifierLoc(),
Anders Carlssone98da2e2009-06-24 00:28:53 +00002533 diag::err_static_data_member_not_allowed_in_local_class)
2534 << Name << RD->getDeclName();
2535 }
2536 }
Mike Stump1eb44332009-09-09 15:08:12 +00002537
Douglas Gregordfe3f2d2009-07-22 17:18:37 +00002538 // Match up the template parameter lists with the scope specifier, then
2539 // determine whether we have a template or a template specialization.
Douglas Gregor1fef4e62009-10-07 22:35:40 +00002540 bool isExplicitSpecialization = false;
Douglas Gregordfe3f2d2009-07-22 17:18:37 +00002541 if (TemplateParameterList *TemplateParams
Douglas Gregor1fef4e62009-10-07 22:35:40 +00002542 = MatchTemplateParametersToScopeSpecifier(
Douglas Gregordfe3f2d2009-07-22 17:18:37 +00002543 D.getDeclSpec().getSourceRange().getBegin(),
Douglas Gregor1fef4e62009-10-07 22:35:40 +00002544 D.getCXXScopeSpec(),
Douglas Gregor27eeb5e2009-07-22 22:05:02 +00002545 (TemplateParameterList**)TemplateParamLists.get(),
Douglas Gregor1fef4e62009-10-07 22:35:40 +00002546 TemplateParamLists.size(),
John McCall77e8b112010-04-13 20:37:33 +00002547 /*never a friend*/ false,
Douglas Gregor1fef4e62009-10-07 22:35:40 +00002548 isExplicitSpecialization)) {
Douglas Gregordfe3f2d2009-07-22 17:18:37 +00002549 if (TemplateParams->size() > 0) {
2550 // There is no such thing as a variable template.
2551 Diag(D.getIdentifierLoc(), diag::err_template_variable)
2552 << II
2553 << SourceRange(TemplateParams->getTemplateLoc(),
2554 TemplateParams->getRAngleLoc());
2555 return 0;
2556 } else {
2557 // There is an extraneous 'template<>' for this variable. Complain
2558 // about it, but allow the declaration of the variable.
Mike Stump1eb44332009-09-09 15:08:12 +00002559 Diag(TemplateParams->getTemplateLoc(),
Douglas Gregor7cdbc582009-07-22 23:48:44 +00002560 diag::err_template_variable_noparams)
Douglas Gregordfe3f2d2009-07-22 17:18:37 +00002561 << II
2562 << SourceRange(TemplateParams->getTemplateLoc(),
Mike Stump1eb44332009-09-09 15:08:12 +00002563 TemplateParams->getRAngleLoc());
Douglas Gregor1fef4e62009-10-07 22:35:40 +00002564
2565 isExplicitSpecialization = true;
Douglas Gregordfe3f2d2009-07-22 17:18:37 +00002566 }
Mike Stump1eb44332009-09-09 15:08:12 +00002567 }
2568
Douglas Gregor16573fa2010-04-19 22:54:31 +00002569 VarDecl *NewVD = VarDecl::Create(Context, DC, D.getIdentifierLoc(),
2570 II, R, TInfo, SC, SCAsWritten);
Eli Friedman63054b32009-04-19 20:27:55 +00002571
Chris Lattnereaaebc72009-04-25 08:06:05 +00002572 if (D.isInvalidType())
2573 NewVD->setInvalidDecl();
Mike Stump1eb44332009-09-09 15:08:12 +00002574
John McCallb6217662010-03-15 10:12:16 +00002575 SetNestedNameSpecifier(NewVD, D);
2576
Eli Friedman63054b32009-04-19 20:27:55 +00002577 if (D.getDeclSpec().isThreadSpecified()) {
2578 if (NewVD->hasLocalStorage())
2579 Diag(D.getDeclSpec().getThreadSpecLoc(), diag::err_thread_non_global);
Eli Friedman4fb71b02009-04-19 21:48:33 +00002580 else if (!Context.Target.isTLSSupported())
2581 Diag(D.getDeclSpec().getThreadSpecLoc(), diag::err_thread_unsupported);
Eli Friedman63054b32009-04-19 20:27:55 +00002582 else
2583 NewVD->setThreadSpecified(true);
2584 }
Douglas Gregor4afa39d2009-01-20 01:17:11 +00002585
Douglas Gregor656de632009-03-11 23:52:16 +00002586 // Set the lexical context. If the declarator has a C++ scope specifier, the
2587 // lexical context will be different from the semantic context.
2588 NewVD->setLexicalDeclContext(CurContext);
2589
Zhongxing Xucb8f4f12009-01-16 02:36:34 +00002590 // Handle attributes prior to checking for duplicates in MergeVarDecl
Douglas Gregor9cdda0c2009-06-17 21:51:59 +00002591 ProcessDeclAttributes(S, NewVD, D);
Zhongxing Xucb8f4f12009-01-16 02:36:34 +00002592
2593 // Handle GNU asm-label extension (encoded as an attribute).
2594 if (Expr *E = (Expr*) D.getAsmLabel()) {
2595 // The parser guarantees this is a string.
Mike Stump1eb44332009-09-09 15:08:12 +00002596 StringLiteral *SE = cast<StringLiteral>(E);
Ted Kremenek3d2c43e2010-02-11 05:28:37 +00002597 NewVD->addAttr(::new (Context) AsmLabelAttr(Context, SE->getString()));
Zhongxing Xucb8f4f12009-01-16 02:36:34 +00002598 }
2599
John McCall8472af42010-03-16 21:48:18 +00002600 // Diagnose shadowed variables before filtering for scope.
John McCalla369a952010-03-20 04:12:52 +00002601 if (!D.getCXXScopeSpec().isSet())
John McCall053f4bd2010-03-22 09:20:08 +00002602 CheckShadow(S, NewVD, Previous);
John McCall8472af42010-03-16 21:48:18 +00002603
John McCall68263142009-11-18 22:49:29 +00002604 // Don't consider existing declarations that are in a different
2605 // scope and are out-of-semantic-context declarations (if the new
2606 // declaration has linkage).
2607 FilterLookupForScope(*this, Previous, DC, S, NewVD->hasLinkage());
Douglas Gregor251b4ff2009-10-08 07:24:58 +00002608
Douglas Gregor3d7a12a2009-03-25 23:32:15 +00002609 // Merge the decl with the existing one if appropriate.
John McCall68263142009-11-18 22:49:29 +00002610 if (!Previous.empty()) {
2611 if (Previous.isSingleResult() &&
2612 isa<FieldDecl>(Previous.getFoundDecl()) &&
2613 D.getCXXScopeSpec().isSet()) {
Douglas Gregor3d7a12a2009-03-25 23:32:15 +00002614 // The user tried to define a non-static data member
2615 // out-of-line (C++ [dcl.meaning]p1).
2616 Diag(NewVD->getLocation(), diag::err_nonstatic_member_out_of_line)
2617 << D.getCXXScopeSpec().getRange();
John McCall68263142009-11-18 22:49:29 +00002618 Previous.clear();
Chris Lattnereaaebc72009-04-25 08:06:05 +00002619 NewVD->setInvalidDecl();
Douglas Gregor3d7a12a2009-03-25 23:32:15 +00002620 }
2621 } else if (D.getCXXScopeSpec().isSet()) {
2622 // No previous declaration in the qualifying scope.
Douglas Gregor3f093272009-10-13 21:16:44 +00002623 Diag(D.getIdentifierLoc(), diag::err_no_member)
2624 << Name << computeDeclContext(D.getCXXScopeSpec(), true)
2625 << D.getCXXScopeSpec().getRange();
Chris Lattnereaaebc72009-04-25 08:06:05 +00002626 NewVD->setInvalidDecl();
Douglas Gregor3d7a12a2009-03-25 23:32:15 +00002627 }
2628
John McCall68263142009-11-18 22:49:29 +00002629 CheckVariableDeclaration(NewVD, Previous, Redeclaration);
Douglas Gregor3d7a12a2009-03-25 23:32:15 +00002630
Douglas Gregor251b4ff2009-10-08 07:24:58 +00002631 // This is an explicit specialization of a static data member. Check it.
2632 if (isExplicitSpecialization && !NewVD->isInvalidDecl() &&
John McCall68263142009-11-18 22:49:29 +00002633 CheckMemberSpecialization(NewVD, Previous))
Douglas Gregor251b4ff2009-10-08 07:24:58 +00002634 NewVD->setInvalidDecl();
John McCall68263142009-11-18 22:49:29 +00002635
Ryan Flynn478fbc62009-07-25 22:29:44 +00002636 // attributes declared post-definition are currently ignored
John McCall68263142009-11-18 22:49:29 +00002637 if (Previous.isSingleResult()) {
Sebastian Redl31310a22010-02-01 20:16:42 +00002638 VarDecl *Def = dyn_cast<VarDecl>(Previous.getFoundDecl());
2639 if (Def && (Def = Def->getDefinition()) &&
2640 Def != NewVD && D.hasAttributes()) {
Ryan Flynn478fbc62009-07-25 22:29:44 +00002641 Diag(NewVD->getLocation(), diag::warn_attribute_precede_definition);
2642 Diag(Def->getLocation(), diag::note_previous_definition);
2643 }
2644 }
2645
Douglas Gregor3d7a12a2009-03-25 23:32:15 +00002646 // If this is a locally-scoped extern C variable, update the map of
2647 // such variables.
Douglas Gregor48a83b52009-09-12 00:17:51 +00002648 if (CurContext->isFunctionOrMethod() && NewVD->isExternC() &&
Chris Lattnereaaebc72009-04-25 08:06:05 +00002649 !NewVD->isInvalidDecl())
John McCall68263142009-11-18 22:49:29 +00002650 RegisterLocallyScopedExternCDecl(NewVD, Previous, S);
Douglas Gregor3d7a12a2009-03-25 23:32:15 +00002651
2652 return NewVD;
2653}
2654
John McCall053f4bd2010-03-22 09:20:08 +00002655/// \brief Diagnose variable or built-in function shadowing. Implements
2656/// -Wshadow.
John McCall8472af42010-03-16 21:48:18 +00002657///
John McCall053f4bd2010-03-22 09:20:08 +00002658/// This method is called whenever a VarDecl is added to a "useful"
2659/// scope.
John McCall8472af42010-03-16 21:48:18 +00002660///
John McCalla369a952010-03-20 04:12:52 +00002661/// \param S the scope in which the shadowing name is being declared
2662/// \param R the lookup of the name
John McCall8472af42010-03-16 21:48:18 +00002663///
John McCall053f4bd2010-03-22 09:20:08 +00002664void Sema::CheckShadow(Scope *S, VarDecl *D, const LookupResult& R) {
John McCall8472af42010-03-16 21:48:18 +00002665 // Return if warning is ignored.
2666 if (Diags.getDiagnosticLevel(diag::warn_decl_shadow) == Diagnostic::Ignored)
2667 return;
2668
John McCalla369a952010-03-20 04:12:52 +00002669 // Don't diagnose declarations at file scope. The scope might not
2670 // have a DeclContext if (e.g.) we're parsing a function prototype.
2671 DeclContext *NewDC = static_cast<DeclContext*>(S->getEntity());
2672 if (NewDC && NewDC->isFileContext())
John McCall8472af42010-03-16 21:48:18 +00002673 return;
John McCalla369a952010-03-20 04:12:52 +00002674
2675 // Only diagnose if we're shadowing an unambiguous field or variable.
Douglas Gregorc48c9162010-03-17 16:03:44 +00002676 if (R.getResultKind() != LookupResult::Found)
John McCall8472af42010-03-16 21:48:18 +00002677 return;
John McCall8472af42010-03-16 21:48:18 +00002678
John McCall8472af42010-03-16 21:48:18 +00002679 NamedDecl* ShadowedDecl = R.getFoundDecl();
2680 if (!isa<VarDecl>(ShadowedDecl) && !isa<FieldDecl>(ShadowedDecl))
2681 return;
2682
John McCalla369a952010-03-20 04:12:52 +00002683 DeclContext *OldDC = ShadowedDecl->getDeclContext();
2684
2685 // Only warn about certain kinds of shadowing for class members.
2686 if (NewDC && NewDC->isRecord()) {
2687 // In particular, don't warn about shadowing non-class members.
2688 if (!OldDC->isRecord())
2689 return;
2690
2691 // TODO: should we warn about static data members shadowing
2692 // static data members from base classes?
2693
2694 // TODO: don't diagnose for inaccessible shadowed members.
2695 // This is hard to do perfectly because we might friend the
2696 // shadowing context, but that's just a false negative.
2697 }
2698
2699 // Determine what kind of declaration we're shadowing.
John McCall8472af42010-03-16 21:48:18 +00002700 unsigned Kind;
John McCalla369a952010-03-20 04:12:52 +00002701 if (isa<RecordDecl>(OldDC)) {
John McCall8472af42010-03-16 21:48:18 +00002702 if (isa<FieldDecl>(ShadowedDecl))
2703 Kind = 3; // field
2704 else
2705 Kind = 2; // static data member
John McCalla369a952010-03-20 04:12:52 +00002706 } else if (OldDC->isFileContext())
John McCall8472af42010-03-16 21:48:18 +00002707 Kind = 1; // global
2708 else
2709 Kind = 0; // local
2710
John McCalla369a952010-03-20 04:12:52 +00002711 DeclarationName Name = R.getLookupName();
2712
John McCall8472af42010-03-16 21:48:18 +00002713 // Emit warning and note.
John McCalla369a952010-03-20 04:12:52 +00002714 Diag(R.getNameLoc(), diag::warn_decl_shadow) << Name << Kind << OldDC;
John McCall8472af42010-03-16 21:48:18 +00002715 Diag(ShadowedDecl->getLocation(), diag::note_previous_declaration);
2716}
2717
John McCall053f4bd2010-03-22 09:20:08 +00002718/// \brief Check -Wshadow without the advantage of a previous lookup.
2719void Sema::CheckShadow(Scope *S, VarDecl *D) {
2720 LookupResult R(*this, D->getDeclName(), D->getLocation(),
2721 Sema::LookupOrdinaryName, Sema::ForRedeclaration);
2722 LookupName(R, S);
2723 CheckShadow(S, D, R);
2724}
2725
Douglas Gregor3d7a12a2009-03-25 23:32:15 +00002726/// \brief Perform semantic checking on a newly-created variable
2727/// declaration.
2728///
2729/// This routine performs all of the type-checking required for a
Douglas Gregor180bb632009-05-01 15:47:09 +00002730/// variable declaration once it has been built. It is used both to
Douglas Gregor3d7a12a2009-03-25 23:32:15 +00002731/// check variables after they have been parsed and their declarators
Douglas Gregor180bb632009-05-01 15:47:09 +00002732/// have been translated into a declaration, and to check variables
2733/// that have been instantiated from a template.
Douglas Gregor3d7a12a2009-03-25 23:32:15 +00002734///
Chris Lattnereaaebc72009-04-25 08:06:05 +00002735/// Sets NewVD->isInvalidDecl() if an error was encountered.
John McCall68263142009-11-18 22:49:29 +00002736void Sema::CheckVariableDeclaration(VarDecl *NewVD,
2737 LookupResult &Previous,
Douglas Gregor3d7a12a2009-03-25 23:32:15 +00002738 bool &Redeclaration) {
Chris Lattnereaaebc72009-04-25 08:06:05 +00002739 // If the decl is already known invalid, don't check it.
2740 if (NewVD->isInvalidDecl())
2741 return;
Mike Stump1eb44332009-09-09 15:08:12 +00002742
Douglas Gregor3d7a12a2009-03-25 23:32:15 +00002743 QualType T = NewVD->getType();
2744
John McCallc12c5bb2010-05-15 11:32:37 +00002745 if (T->isObjCObjectType()) {
Douglas Gregor3d7a12a2009-03-25 23:32:15 +00002746 Diag(NewVD->getLocation(), diag::err_statically_allocated_object);
Chris Lattnereaaebc72009-04-25 08:06:05 +00002747 return NewVD->setInvalidDecl();
Douglas Gregor3d7a12a2009-03-25 23:32:15 +00002748 }
Mike Stump1eb44332009-09-09 15:08:12 +00002749
Zhongxing Xucb8f4f12009-01-16 02:36:34 +00002750 // Emit an error if an address space was applied to decl with local storage.
2751 // This includes arrays of objects with address space qualifiers, but not
2752 // automatic variables that point to other address spaces.
2753 // ISO/IEC TR 18037 S5.1.2
Douglas Gregor3d7a12a2009-03-25 23:32:15 +00002754 if (NewVD->hasLocalStorage() && (T.getAddressSpace() != 0)) {
2755 Diag(NewVD->getLocation(), diag::err_as_qualified_auto_decl);
Chris Lattnereaaebc72009-04-25 08:06:05 +00002756 return NewVD->setInvalidDecl();
Zhongxing Xucb8f4f12009-01-16 02:36:34 +00002757 }
Fariborz Jahanian7b5b3172009-02-21 19:44:02 +00002758
Mike Stumpf33651c2009-04-14 00:57:29 +00002759 if (NewVD->hasLocalStorage() && T.isObjCGCWeak()
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +00002760 && !NewVD->hasAttr<BlocksAttr>())
Douglas Gregor3d7a12a2009-03-25 23:32:15 +00002761 Diag(NewVD->getLocation(), diag::warn_attribute_weak_on_local);
Fariborz Jahanian7b5b3172009-02-21 19:44:02 +00002762
Chris Lattner38c5ebd2009-04-19 05:21:20 +00002763 bool isVM = T->isVariablyModifiedType();
Chris Lattnerbe6d2592009-07-19 20:17:11 +00002764 if (isVM || NewVD->hasAttr<CleanupAttr>() ||
Chris Lattner6d97e5e2010-03-01 20:59:53 +00002765 NewVD->hasAttr<BlocksAttr>() ||
2766 // FIXME: We need to diagnose jumps passed initialized variables in C++.
2767 // However, this turns on the scope checker for everything with a variable
2768 // which may impact compile time. See if we can find a better solution
2769 // to this, perhaps only checking functions that contain gotos in C++?
2770 (LangOpts.CPlusPlus && NewVD->hasLocalStorage()))
Douglas Gregor9ea9bdb2010-03-01 23:15:13 +00002771 FunctionNeedsScopeChecking() = true;
Mike Stump1eb44332009-09-09 15:08:12 +00002772
Chris Lattner38c5ebd2009-04-19 05:21:20 +00002773 if ((isVM && NewVD->hasLinkage()) ||
2774 (T->isVariableArrayType() && NewVD->hasGlobalStorage())) {
Anders Carlsson1a7acfa2009-02-28 21:56:50 +00002775 bool SizeIsNegative;
2776 QualType FixedTy =
Douglas Gregor3d7a12a2009-03-25 23:32:15 +00002777 TryToFixInvalidVariablyModifiedType(T, Context, SizeIsNegative);
Mike Stump1eb44332009-09-09 15:08:12 +00002778
Chris Lattnereaaebc72009-04-25 08:06:05 +00002779 if (FixedTy.isNull() && T->isVariableArrayType()) {
Douglas Gregor3d7a12a2009-03-25 23:32:15 +00002780 const VariableArrayType *VAT = Context.getAsVariableArrayType(T);
Mike Stump1eb44332009-09-09 15:08:12 +00002781 // FIXME: This won't give the correct result for
2782 // int a[10][n];
Anders Carlsson1a7acfa2009-02-28 21:56:50 +00002783 SourceRange SizeRange = VAT->getSizeExpr()->getSourceRange();
Mike Stump1eb44332009-09-09 15:08:12 +00002784
Anders Carlsson1a7acfa2009-02-28 21:56:50 +00002785 if (NewVD->isFileVarDecl())
2786 Diag(NewVD->getLocation(), diag::err_vla_decl_in_file_scope)
Chris Lattnereaaebc72009-04-25 08:06:05 +00002787 << SizeRange;
Anders Carlsson1a7acfa2009-02-28 21:56:50 +00002788 else if (NewVD->getStorageClass() == VarDecl::Static)
2789 Diag(NewVD->getLocation(), diag::err_vla_decl_has_static_storage)
Chris Lattnereaaebc72009-04-25 08:06:05 +00002790 << SizeRange;
Anders Carlsson1a7acfa2009-02-28 21:56:50 +00002791 else
2792 Diag(NewVD->getLocation(), diag::err_vla_decl_has_extern_linkage)
Chris Lattnereaaebc72009-04-25 08:06:05 +00002793 << SizeRange;
2794 return NewVD->setInvalidDecl();
Mike Stump1eb44332009-09-09 15:08:12 +00002795 }
2796
Chris Lattnereaaebc72009-04-25 08:06:05 +00002797 if (FixedTy.isNull()) {
Anders Carlsson1a7acfa2009-02-28 21:56:50 +00002798 if (NewVD->isFileVarDecl())
2799 Diag(NewVD->getLocation(), diag::err_vm_decl_in_file_scope);
2800 else
2801 Diag(NewVD->getLocation(), diag::err_vm_decl_has_extern_linkage);
Chris Lattnereaaebc72009-04-25 08:06:05 +00002802 return NewVD->setInvalidDecl();
Anders Carlsson1a7acfa2009-02-28 21:56:50 +00002803 }
Mike Stump1eb44332009-09-09 15:08:12 +00002804
Chris Lattnereaaebc72009-04-25 08:06:05 +00002805 Diag(NewVD->getLocation(), diag::warn_illegal_constant_array_size);
2806 NewVD->setType(FixedTy);
Anders Carlsson1a7acfa2009-02-28 21:56:50 +00002807 }
2808
John McCall68263142009-11-18 22:49:29 +00002809 if (Previous.empty() && NewVD->isExternC()) {
Douglas Gregor63935192009-03-02 00:19:53 +00002810 // Since we did not find anything by this name and we're declaring
2811 // an extern "C" variable, look for a non-visible extern "C"
2812 // declaration with the same name.
2813 llvm::DenseMap<DeclarationName, NamedDecl *>::iterator Pos
Douglas Gregor3d7a12a2009-03-25 23:32:15 +00002814 = LocallyScopedExternalDecls.find(NewVD->getDeclName());
Douglas Gregor63935192009-03-02 00:19:53 +00002815 if (Pos != LocallyScopedExternalDecls.end())
John McCall68263142009-11-18 22:49:29 +00002816 Previous.addDecl(Pos->second);
Douglas Gregor63935192009-03-02 00:19:53 +00002817 }
2818
Chris Lattnereaaebc72009-04-25 08:06:05 +00002819 if (T->isVoidType() && !NewVD->hasExternalStorage()) {
Douglas Gregor3d7a12a2009-03-25 23:32:15 +00002820 Diag(NewVD->getLocation(), diag::err_typecheck_decl_incomplete_type)
2821 << T;
Chris Lattnereaaebc72009-04-25 08:06:05 +00002822 return NewVD->setInvalidDecl();
Douglas Gregor3d7a12a2009-03-25 23:32:15 +00002823 }
Zhongxing Xucb8f4f12009-01-16 02:36:34 +00002824
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +00002825 if (!NewVD->hasLocalStorage() && NewVD->hasAttr<BlocksAttr>()) {
Mike Stumpea000bf2009-04-30 00:19:40 +00002826 Diag(NewVD->getLocation(), diag::err_block_on_nonlocal);
2827 return NewVD->setInvalidDecl();
2828 }
Mike Stump1eb44332009-09-09 15:08:12 +00002829
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +00002830 if (isVM && NewVD->hasAttr<BlocksAttr>()) {
Mike Stumpc975bb02009-05-01 23:41:47 +00002831 Diag(NewVD->getLocation(), diag::err_block_on_vm);
2832 return NewVD->setInvalidDecl();
2833 }
2834
John McCall68263142009-11-18 22:49:29 +00002835 if (!Previous.empty()) {
Douglas Gregorcda9c672009-02-16 17:45:42 +00002836 Redeclaration = true;
John McCall68263142009-11-18 22:49:29 +00002837 MergeVarDecl(NewVD, Previous);
Zhongxing Xucb8f4f12009-01-16 02:36:34 +00002838 }
Zhongxing Xucb8f4f12009-01-16 02:36:34 +00002839}
2840
Douglas Gregora8f32e02009-10-06 17:59:45 +00002841/// \brief Data used with FindOverriddenMethod
2842struct FindOverriddenMethodData {
2843 Sema *S;
2844 CXXMethodDecl *Method;
2845};
2846
2847/// \brief Member lookup function that determines whether a given C++
2848/// method overrides a method in a base class, to be used with
2849/// CXXRecordDecl::lookupInBases().
John McCallaf8e6ed2009-11-12 03:15:40 +00002850static bool FindOverriddenMethod(const CXXBaseSpecifier *Specifier,
Douglas Gregora8f32e02009-10-06 17:59:45 +00002851 CXXBasePath &Path,
2852 void *UserData) {
2853 RecordDecl *BaseRecord = Specifier->getType()->getAs<RecordType>()->getDecl();
Anders Carlsson95496802009-11-26 20:50:40 +00002854
Douglas Gregora8f32e02009-10-06 17:59:45 +00002855 FindOverriddenMethodData *Data
2856 = reinterpret_cast<FindOverriddenMethodData*>(UserData);
Anders Carlsson95496802009-11-26 20:50:40 +00002857
2858 DeclarationName Name = Data->Method->getDeclName();
2859
2860 // FIXME: Do we care about other names here too?
2861 if (Name.getNameKind() == DeclarationName::CXXDestructorName) {
2862 // We really want to find the base class constructor here.
2863 QualType T = Data->S->Context.getTypeDeclType(BaseRecord);
2864 CanQualType CT = Data->S->Context.getCanonicalType(T);
2865
Anders Carlsson1a689722009-11-27 01:26:58 +00002866 Name = Data->S->Context.DeclarationNames.getCXXDestructorName(CT);
Anders Carlsson95496802009-11-26 20:50:40 +00002867 }
2868
2869 for (Path.Decls = BaseRecord->lookup(Name);
Douglas Gregora8f32e02009-10-06 17:59:45 +00002870 Path.Decls.first != Path.Decls.second;
2871 ++Path.Decls.first) {
2872 if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(*Path.Decls.first)) {
John McCall68263142009-11-18 22:49:29 +00002873 if (MD->isVirtual() && !Data->S->IsOverload(Data->Method, MD))
Douglas Gregora8f32e02009-10-06 17:59:45 +00002874 return true;
2875 }
2876 }
2877
2878 return false;
2879}
2880
Sebastian Redla165da02009-11-18 21:51:29 +00002881/// AddOverriddenMethods - See if a method overrides any in the base classes,
2882/// and if so, check that it's a valid override and remember it.
2883void Sema::AddOverriddenMethods(CXXRecordDecl *DC, CXXMethodDecl *MD) {
2884 // Look for virtual methods in base classes that this method might override.
2885 CXXBasePaths Paths;
2886 FindOverriddenMethodData Data;
2887 Data.Method = MD;
2888 Data.S = this;
2889 if (DC->lookupInBases(&FindOverriddenMethod, &Data, Paths)) {
2890 for (CXXBasePaths::decl_iterator I = Paths.found_decls_begin(),
2891 E = Paths.found_decls_end(); I != E; ++I) {
2892 if (CXXMethodDecl *OldMD = dyn_cast<CXXMethodDecl>(*I)) {
2893 if (!CheckOverridingFunctionReturnType(MD, OldMD) &&
Sean Huntbbd37c62009-11-21 08:43:09 +00002894 !CheckOverridingFunctionExceptionSpec(MD, OldMD) &&
2895 !CheckOverridingFunctionAttributes(MD, OldMD))
Anders Carlsson3aaf4862009-12-04 05:51:56 +00002896 MD->addOverriddenMethod(OldMD->getCanonicalDecl());
Sebastian Redla165da02009-11-18 21:51:29 +00002897 }
2898 }
2899 }
2900}
2901
Mike Stump1eb44332009-09-09 15:08:12 +00002902NamedDecl*
Zhongxing Xu416fcaf2009-01-16 01:13:29 +00002903Sema::ActOnFunctionDeclarator(Scope* S, Declarator& D, DeclContext* DC,
John McCalla93c9342009-12-07 02:54:59 +00002904 QualType R, TypeSourceInfo *TInfo,
John McCall68263142009-11-18 22:49:29 +00002905 LookupResult &Previous,
Douglas Gregore542c862009-06-23 23:11:28 +00002906 MultiTemplateParamsArg TemplateParamLists,
Chris Lattnereaaebc72009-04-25 08:06:05 +00002907 bool IsFunctionDefinition, bool &Redeclaration) {
Zhongxing Xu416fcaf2009-01-16 01:13:29 +00002908 assert(R.getTypePtr()->isFunctionType());
2909
2910 DeclarationName Name = GetNameForDeclarator(D);
2911 FunctionDecl::StorageClass SC = FunctionDecl::None;
2912 switch (D.getDeclSpec().getStorageClassSpec()) {
2913 default: assert(0 && "Unknown storage class!");
2914 case DeclSpec::SCS_auto:
2915 case DeclSpec::SCS_register:
2916 case DeclSpec::SCS_mutable:
Mike Stump1eb44332009-09-09 15:08:12 +00002917 Diag(D.getDeclSpec().getStorageClassSpecLoc(),
Douglas Gregor04495c82009-02-24 01:23:02 +00002918 diag::err_typecheck_sclass_func);
Chris Lattnereaaebc72009-04-25 08:06:05 +00002919 D.setInvalidType();
Zhongxing Xu416fcaf2009-01-16 01:13:29 +00002920 break;
2921 case DeclSpec::SCS_unspecified: SC = FunctionDecl::None; break;
2922 case DeclSpec::SCS_extern: SC = FunctionDecl::Extern; break;
Douglas Gregor04495c82009-02-24 01:23:02 +00002923 case DeclSpec::SCS_static: {
Douglas Gregor656de632009-03-11 23:52:16 +00002924 if (CurContext->getLookupContext()->isFunctionOrMethod()) {
Douglas Gregor04495c82009-02-24 01:23:02 +00002925 // C99 6.7.1p5:
2926 // The declaration of an identifier for a function that has
2927 // block scope shall have no explicit storage-class specifier
2928 // other than extern
2929 // See also (C++ [dcl.stc]p4).
Mike Stump1eb44332009-09-09 15:08:12 +00002930 Diag(D.getDeclSpec().getStorageClassSpecLoc(),
Douglas Gregor04495c82009-02-24 01:23:02 +00002931 diag::err_static_block_func);
2932 SC = FunctionDecl::None;
2933 } else
Mike Stump1eb44332009-09-09 15:08:12 +00002934 SC = FunctionDecl::Static;
Douglas Gregor04495c82009-02-24 01:23:02 +00002935 break;
2936 }
Zhongxing Xu416fcaf2009-01-16 01:13:29 +00002937 case DeclSpec::SCS_private_extern: SC = FunctionDecl::PrivateExtern;break;
2938 }
2939
Eli Friedman63054b32009-04-19 20:27:55 +00002940 if (D.getDeclSpec().isThreadSpecified())
2941 Diag(D.getDeclSpec().getThreadSpecLoc(), diag::err_invalid_thread);
2942
John McCall3f9a8a62009-08-11 06:59:38 +00002943 bool isFriend = D.getDeclSpec().isFriendSpecified();
Zhongxing Xu416fcaf2009-01-16 01:13:29 +00002944 bool isInline = D.getDeclSpec().isInlineSpecified();
Douglas Gregor021c3b32009-03-11 23:00:04 +00002945 bool isVirtual = D.getDeclSpec().isVirtualSpecified();
Zhongxing Xu416fcaf2009-01-16 01:13:29 +00002946 bool isExplicit = D.getDeclSpec().isExplicitSpecified();
2947
Douglas Gregor16573fa2010-04-19 22:54:31 +00002948 DeclSpec::SCS SCSpec = D.getDeclSpec().getStorageClassSpecAsWritten();
2949 FunctionDecl::StorageClass SCAsWritten
Abramo Bagnarab21b4052010-04-28 13:11:54 +00002950 = StorageClassSpecToFunctionDeclStorageClass(SCSpec, DC);
Douglas Gregor16573fa2010-04-19 22:54:31 +00002951
Anders Carlsson4681ebd2009-03-22 20:18:17 +00002952 // Check that the return type is not an abstract class type.
Anders Carlsson8211eff2009-03-24 01:19:16 +00002953 // For record types, this is done by the AbstractClassUsageDiagnoser once
Mike Stump1eb44332009-09-09 15:08:12 +00002954 // the class has been completely parsed.
Anders Carlsson8211eff2009-03-24 01:19:16 +00002955 if (!DC->isRecord() &&
Mike Stump1eb44332009-09-09 15:08:12 +00002956 RequireNonAbstractType(D.getIdentifierLoc(),
John McCall183700f2009-09-21 23:43:11 +00002957 R->getAs<FunctionType>()->getResultType(),
Mike Stump1eb44332009-09-09 15:08:12 +00002958 diag::err_abstract_type_in_decl,
Anders Carlsson8211eff2009-03-24 01:19:16 +00002959 AbstractReturnType))
Chris Lattnereaaebc72009-04-25 08:06:05 +00002960 D.setInvalidType();
Mike Stump1eb44332009-09-09 15:08:12 +00002961
Chris Lattnerbb749822009-04-11 19:17:25 +00002962 // Do not allow returning a objc interface by-value.
John McCallc12c5bb2010-05-15 11:32:37 +00002963 if (R->getAs<FunctionType>()->getResultType()->isObjCObjectType()) {
Chris Lattnerbb749822009-04-11 19:17:25 +00002964 Diag(D.getIdentifierLoc(),
2965 diag::err_object_cannot_be_passed_returned_by_value) << 0
John McCall183700f2009-09-21 23:43:11 +00002966 << R->getAs<FunctionType>()->getResultType();
Chris Lattnereaaebc72009-04-25 08:06:05 +00002967 D.setInvalidType();
Chris Lattnerbb749822009-04-11 19:17:25 +00002968 }
Douglas Gregore542c862009-06-23 23:11:28 +00002969
Douglas Gregor021c3b32009-03-11 23:00:04 +00002970 bool isVirtualOkay = false;
Zhongxing Xu416fcaf2009-01-16 01:13:29 +00002971 FunctionDecl *NewFD;
John McCall02cace72009-08-28 07:59:38 +00002972
John McCall3f9a8a62009-08-11 06:59:38 +00002973 if (isFriend) {
John McCall3f9a8a62009-08-11 06:59:38 +00002974 // C++ [class.friend]p5
2975 // A function can be defined in a friend declaration of a
2976 // class . . . . Such a function is implicitly inline.
2977 isInline |= IsFunctionDefinition;
John McCall02cace72009-08-28 07:59:38 +00002978 }
John McCall3f9a8a62009-08-11 06:59:38 +00002979
Douglas Gregor3f9a0562009-11-03 01:35:08 +00002980 if (Name.getNameKind() == DeclarationName::CXXConstructorName) {
Zhongxing Xu416fcaf2009-01-16 01:13:29 +00002981 // This is a C++ constructor declaration.
2982 assert(DC->isRecord() &&
2983 "Constructors can only be declared in a member context");
2984
Chris Lattner65401802009-04-25 08:28:21 +00002985 R = CheckConstructorDeclarator(D, R, SC);
Zhongxing Xu416fcaf2009-01-16 01:13:29 +00002986
2987 // Create the new declaration
Mike Stump1eb44332009-09-09 15:08:12 +00002988 NewFD = CXXConstructorDecl::Create(Context,
Zhongxing Xu416fcaf2009-01-16 01:13:29 +00002989 cast<CXXRecordDecl>(DC),
John McCalla93c9342009-12-07 02:54:59 +00002990 D.getIdentifierLoc(), Name, R, TInfo,
Zhongxing Xu416fcaf2009-01-16 01:13:29 +00002991 isExplicit, isInline,
2992 /*isImplicitlyDeclared=*/false);
Douglas Gregor3f9a0562009-11-03 01:35:08 +00002993 } else if (Name.getNameKind() == DeclarationName::CXXDestructorName) {
Zhongxing Xu416fcaf2009-01-16 01:13:29 +00002994 // This is a C++ destructor declaration.
2995 if (DC->isRecord()) {
Chris Lattner65401802009-04-25 08:28:21 +00002996 R = CheckDestructorDeclarator(D, SC);
Mike Stump1eb44332009-09-09 15:08:12 +00002997
Zhongxing Xu416fcaf2009-01-16 01:13:29 +00002998 NewFD = CXXDestructorDecl::Create(Context,
2999 cast<CXXRecordDecl>(DC),
Mike Stump1eb44332009-09-09 15:08:12 +00003000 D.getIdentifierLoc(), Name, R,
Zhongxing Xu416fcaf2009-01-16 01:13:29 +00003001 isInline,
3002 /*isImplicitlyDeclared=*/false);
John McCall21ef0fa2010-03-11 09:03:00 +00003003 NewFD->setTypeSourceInfo(TInfo);
Zhongxing Xu416fcaf2009-01-16 01:13:29 +00003004
Douglas Gregor021c3b32009-03-11 23:00:04 +00003005 isVirtualOkay = true;
Zhongxing Xu416fcaf2009-01-16 01:13:29 +00003006 } else {
3007 Diag(D.getIdentifierLoc(), diag::err_destructor_not_member);
3008
3009 // Create a FunctionDecl to satisfy the function definition parsing
3010 // code path.
3011 NewFD = FunctionDecl::Create(Context, DC, D.getIdentifierLoc(),
Douglas Gregor16573fa2010-04-19 22:54:31 +00003012 Name, R, TInfo, SC, SCAsWritten, isInline,
Argyrios Kyrtzidisa5d82002009-08-21 00:31:54 +00003013 /*hasPrototype=*/true);
Chris Lattnereaaebc72009-04-25 08:06:05 +00003014 D.setInvalidType();
Zhongxing Xu416fcaf2009-01-16 01:13:29 +00003015 }
Douglas Gregor3f9a0562009-11-03 01:35:08 +00003016 } else if (Name.getNameKind() == DeclarationName::CXXConversionFunctionName) {
Zhongxing Xu416fcaf2009-01-16 01:13:29 +00003017 if (!DC->isRecord()) {
3018 Diag(D.getIdentifierLoc(),
3019 diag::err_conv_function_not_member);
3020 return 0;
Zhongxing Xu416fcaf2009-01-16 01:13:29 +00003021 }
Mike Stump1eb44332009-09-09 15:08:12 +00003022
Chris Lattner6e475012009-04-25 08:35:12 +00003023 CheckConversionDeclarator(D, R, SC);
3024 NewFD = CXXConversionDecl::Create(Context, cast<CXXRecordDecl>(DC),
John McCalla93c9342009-12-07 02:54:59 +00003025 D.getIdentifierLoc(), Name, R, TInfo,
Chris Lattner6e475012009-04-25 08:35:12 +00003026 isInline, isExplicit);
Mike Stump1eb44332009-09-09 15:08:12 +00003027
Chris Lattner6e475012009-04-25 08:35:12 +00003028 isVirtualOkay = true;
Zhongxing Xu416fcaf2009-01-16 01:13:29 +00003029 } else if (DC->isRecord()) {
Anders Carlsson4649cac2009-04-30 22:41:11 +00003030 // If the of the function is the same as the name of the record, then this
Mike Stump1eb44332009-09-09 15:08:12 +00003031 // must be an invalid constructor that has a return type.
3032 // (The parser checks for a return type and makes the declarator a
Anders Carlsson4649cac2009-04-30 22:41:11 +00003033 // constructor if it has no return type).
Mike Stump1eb44332009-09-09 15:08:12 +00003034 // must have an invalid constructor that has a return type
Douglas Gregor6f7a17b2010-02-05 06:12:42 +00003035 if (Name.getAsIdentifierInfo() &&
3036 Name.getAsIdentifierInfo() == cast<CXXRecordDecl>(DC)->getIdentifier()){
Anders Carlsson4649cac2009-04-30 22:41:11 +00003037 Diag(D.getIdentifierLoc(), diag::err_constructor_return_type)
3038 << SourceRange(D.getDeclSpec().getTypeSpecTypeLoc())
3039 << SourceRange(D.getIdentifierLoc());
3040 return 0;
3041 }
Mike Stump1eb44332009-09-09 15:08:12 +00003042
Anders Carlsson67bf2e72009-11-15 18:59:32 +00003043 bool isStatic = SC == FunctionDecl::Static;
3044
3045 // [class.free]p1:
3046 // Any allocation function for a class T is a static member
3047 // (even if not explicitly declared static).
3048 if (Name.getCXXOverloadedOperator() == OO_New ||
3049 Name.getCXXOverloadedOperator() == OO_Array_New)
3050 isStatic = true;
Anders Carlsson1f126bd2009-11-15 19:08:46 +00003051
3052 // [class.free]p6 Any deallocation function for a class X is a static member
3053 // (even if not explicitly declared static).
3054 if (Name.getCXXOverloadedOperator() == OO_Delete ||
3055 Name.getCXXOverloadedOperator() == OO_Array_Delete)
3056 isStatic = true;
Anders Carlsson67bf2e72009-11-15 18:59:32 +00003057
Zhongxing Xu416fcaf2009-01-16 01:13:29 +00003058 // This is a C++ method declaration.
3059 NewFD = CXXMethodDecl::Create(Context, cast<CXXRecordDecl>(DC),
John McCalla93c9342009-12-07 02:54:59 +00003060 D.getIdentifierLoc(), Name, R, TInfo,
Douglas Gregor16573fa2010-04-19 22:54:31 +00003061 isStatic, SCAsWritten, isInline);
Douglas Gregor021c3b32009-03-11 23:00:04 +00003062
Anders Carlsson1f126bd2009-11-15 19:08:46 +00003063 isVirtualOkay = !isStatic;
Zhongxing Xu416fcaf2009-01-16 01:13:29 +00003064 } else {
Douglas Gregord874def2009-03-19 18:33:54 +00003065 // Determine whether the function was written with a
3066 // prototype. This true when:
3067 // - we're in C++ (where every function has a prototype),
3068 // - there is a prototype in the declarator, or
3069 // - the type R of the function is some kind of typedef or other reference
3070 // to a type name (which eventually refers to a function type).
Mike Stump1eb44332009-09-09 15:08:12 +00003071 bool HasPrototype =
Chris Lattner0d48bf92009-03-17 23:17:04 +00003072 getLangOptions().CPlusPlus ||
Douglas Gregor13d7a322009-03-19 18:14:46 +00003073 (D.getNumTypeObjects() && D.getTypeObject(0).Fun.hasPrototype) ||
Douglas Gregord1659a62009-03-23 16:26:51 +00003074 (!isa<FunctionType>(R.getTypePtr()) && R->isFunctionProtoType());
Mike Stump1eb44332009-09-09 15:08:12 +00003075
Zhongxing Xu416fcaf2009-01-16 01:13:29 +00003076 NewFD = FunctionDecl::Create(Context, DC,
3077 D.getIdentifierLoc(),
Douglas Gregor16573fa2010-04-19 22:54:31 +00003078 Name, R, TInfo, SC, SCAsWritten, isInline,
3079 HasPrototype);
Zhongxing Xu416fcaf2009-01-16 01:13:29 +00003080 }
3081
Chris Lattnereaaebc72009-04-25 08:06:05 +00003082 if (D.isInvalidType())
Chris Lattner584be452009-04-25 05:44:12 +00003083 NewFD->setInvalidDecl();
Mike Stump1eb44332009-09-09 15:08:12 +00003084
John McCallb6217662010-03-15 10:12:16 +00003085 SetNestedNameSpecifier(NewFD, D);
3086
Zhongxing Xu416fcaf2009-01-16 01:13:29 +00003087 // Set the lexical context. If the declarator has a C++
John McCall02cace72009-08-28 07:59:38 +00003088 // scope specifier, or is the object of a friend declaration, the
3089 // lexical context will be different from the semantic context.
Zhongxing Xu416fcaf2009-01-16 01:13:29 +00003090 NewFD->setLexicalDeclContext(CurContext);
3091
Douglas Gregorf59a56e2009-07-21 23:53:31 +00003092 // Match up the template parameter lists with the scope specifier, then
3093 // determine whether we have a template or a template specialization.
Douglas Gregorc5c903a2009-06-24 00:23:40 +00003094 FunctionTemplateDecl *FunctionTemplate = 0;
Douglas Gregor1fef4e62009-10-07 22:35:40 +00003095 bool isExplicitSpecialization = false;
Douglas Gregorb9aa6b22009-09-24 23:14:47 +00003096 bool isFunctionTemplateSpecialization = false;
Douglas Gregorf59a56e2009-07-21 23:53:31 +00003097 if (TemplateParameterList *TemplateParams
3098 = MatchTemplateParametersToScopeSpecifier(
3099 D.getDeclSpec().getSourceRange().getBegin(),
3100 D.getCXXScopeSpec(),
Douglas Gregor27eeb5e2009-07-22 22:05:02 +00003101 (TemplateParameterList**)TemplateParamLists.get(),
Douglas Gregor1fef4e62009-10-07 22:35:40 +00003102 TemplateParamLists.size(),
John McCall77e8b112010-04-13 20:37:33 +00003103 isFriend,
Douglas Gregor1fef4e62009-10-07 22:35:40 +00003104 isExplicitSpecialization)) {
Douglas Gregorc5c903a2009-06-24 00:23:40 +00003105 if (TemplateParams->size() > 0) {
3106 // This is a function template
Mike Stump1eb44332009-09-09 15:08:12 +00003107
Douglas Gregor05396e22009-08-25 17:23:04 +00003108 // Check that we can declare a template here.
3109 if (CheckTemplateDeclScope(S, TemplateParams))
3110 return 0;
Mike Stump1eb44332009-09-09 15:08:12 +00003111
Douglas Gregord60e1052009-08-27 16:57:43 +00003112 FunctionTemplate = FunctionTemplateDecl::Create(Context, DC,
Douglas Gregorc5c903a2009-06-24 00:23:40 +00003113 NewFD->getLocation(),
3114 Name, TemplateParams,
3115 NewFD);
Douglas Gregord60e1052009-08-27 16:57:43 +00003116 FunctionTemplate->setLexicalDeclContext(CurContext);
Douglas Gregorc5c903a2009-06-24 00:23:40 +00003117 NewFD->setDescribedFunctionTemplate(FunctionTemplate);
3118 } else {
Douglas Gregorb9aa6b22009-09-24 23:14:47 +00003119 // This is a function template specialization.
3120 isFunctionTemplateSpecialization = true;
John McCall7ad650f2010-03-24 07:46:06 +00003121
John McCallaf2094e2010-04-08 09:05:18 +00003122 // C++0x [temp.expl.spec]p20 forbids "template<> friend void foo(int);".
John McCall7ad650f2010-03-24 07:46:06 +00003123 if (isFriend && isFunctionTemplateSpecialization) {
John McCall5fd378b2010-03-24 08:27:58 +00003124 // We want to remove the "template<>", found here.
3125 SourceRange RemoveRange = TemplateParams->getSourceRange();
3126
3127 // If we remove the template<> and the name is not a
3128 // template-id, we're actually silently creating a problem:
3129 // the friend declaration will refer to an untemplated decl,
3130 // and clearly the user wants a template specialization. So
3131 // we need to insert '<>' after the name.
3132 SourceLocation InsertLoc;
3133 if (D.getName().getKind() != UnqualifiedId::IK_TemplateId) {
3134 InsertLoc = D.getName().getSourceRange().getEnd();
3135 InsertLoc = PP.getLocForEndOfToken(InsertLoc);
3136 }
3137
John McCall7ad650f2010-03-24 07:46:06 +00003138 Diag(D.getIdentifierLoc(), diag::err_template_spec_decl_friend)
John McCall5fd378b2010-03-24 08:27:58 +00003139 << Name << RemoveRange
Douglas Gregor849b2432010-03-31 17:46:05 +00003140 << FixItHint::CreateRemoval(RemoveRange)
3141 << FixItHint::CreateInsertion(InsertLoc, "<>");
John McCall7ad650f2010-03-24 07:46:06 +00003142 }
Douglas Gregorc5c903a2009-06-24 00:23:40 +00003143 }
Mike Stump1eb44332009-09-09 15:08:12 +00003144
Douglas Gregor27eeb5e2009-07-22 22:05:02 +00003145 // FIXME: Free this memory properly.
3146 TemplateParamLists.release();
Mike Stump1eb44332009-09-09 15:08:12 +00003147 }
Douglas Gregorb9aa6b22009-09-24 23:14:47 +00003148
Douglas Gregor021c3b32009-03-11 23:00:04 +00003149 // C++ [dcl.fct.spec]p5:
3150 // The virtual specifier shall only be used in declarations of
3151 // nonstatic class member functions that appear within a
3152 // member-specification of a class declaration; see 10.3.
3153 //
Chris Lattnereaaebc72009-04-25 08:06:05 +00003154 if (isVirtual && !NewFD->isInvalidDecl()) {
Douglas Gregor021c3b32009-03-11 23:00:04 +00003155 if (!isVirtualOkay) {
Mike Stump1eb44332009-09-09 15:08:12 +00003156 Diag(D.getDeclSpec().getVirtualSpecLoc(),
Douglas Gregor021c3b32009-03-11 23:00:04 +00003157 diag::err_virtual_non_function);
3158 } else if (!CurContext->isRecord()) {
3159 // 'virtual' was specified outside of the class.
3160 Diag(D.getDeclSpec().getVirtualSpecLoc(), diag::err_virtual_out_of_class)
Douglas Gregor849b2432010-03-31 17:46:05 +00003161 << FixItHint::CreateRemoval(D.getDeclSpec().getVirtualSpecLoc());
Douglas Gregor021c3b32009-03-11 23:00:04 +00003162 } else {
3163 // Okay: Add virtual to the method.
Douglas Gregor021c3b32009-03-11 23:00:04 +00003164 CXXRecordDecl *CurClass = cast<CXXRecordDecl>(DC);
Fariborz Jahaniane7184df2009-12-03 18:44:40 +00003165 CurClass->setMethodAsVirtual(NewFD);
Douglas Gregor021c3b32009-03-11 23:00:04 +00003166 }
3167 }
3168
Anders Carlsson0757c8c2010-01-24 16:49:46 +00003169 // C++ [dcl.fct.spec]p6:
3170 // The explicit specifier shall be used only in the declaration of a
3171 // constructor or conversion function within its class definition; see 12.3.1
3172 // and 12.3.2.
3173 if (isExplicit && !NewFD->isInvalidDecl()) {
3174 if (!CurContext->isRecord()) {
3175 // 'explicit' was specified outside of the class.
3176 Diag(D.getDeclSpec().getExplicitSpecLoc(),
3177 diag::err_explicit_out_of_class)
Douglas Gregor849b2432010-03-31 17:46:05 +00003178 << FixItHint::CreateRemoval(D.getDeclSpec().getExplicitSpecLoc());
Anders Carlsson0757c8c2010-01-24 16:49:46 +00003179 } else if (!isa<CXXConstructorDecl>(NewFD) &&
3180 !isa<CXXConversionDecl>(NewFD)) {
3181 // 'explicit' was specified on a function that wasn't a constructor
3182 // or conversion function.
3183 Diag(D.getDeclSpec().getExplicitSpecLoc(),
3184 diag::err_explicit_non_ctor_or_conv_function)
Douglas Gregor849b2432010-03-31 17:46:05 +00003185 << FixItHint::CreateRemoval(D.getDeclSpec().getExplicitSpecLoc());
Anders Carlsson0757c8c2010-01-24 16:49:46 +00003186 }
3187 }
3188
John McCall68263142009-11-18 22:49:29 +00003189 // Filter out previous declarations that don't match the scope.
3190 FilterLookupForScope(*this, Previous, DC, S, NewFD->hasLinkage());
3191
Douglas Gregora735b202009-10-13 14:39:41 +00003192 if (isFriend) {
John McCall68263142009-11-18 22:49:29 +00003193 // DC is the namespace in which the function is being declared.
3194 assert((DC->isFileContext() || !Previous.empty()) &&
3195 "previously-undeclared friend function being created "
3196 "in a non-namespace context");
3197
John McCallb0cb0222010-03-27 05:57:59 +00003198 // For now, claim that the objects have no previous declaration.
Douglas Gregora735b202009-10-13 14:39:41 +00003199 if (FunctionTemplate) {
John McCallb0cb0222010-03-27 05:57:59 +00003200 FunctionTemplate->setObjectOfFriendDecl(false);
Douglas Gregora735b202009-10-13 14:39:41 +00003201 FunctionTemplate->setAccess(AS_public);
3202 }
John McCall77e8b112010-04-13 20:37:33 +00003203 NewFD->setObjectOfFriendDecl(false);
Douglas Gregora735b202009-10-13 14:39:41 +00003204 NewFD->setAccess(AS_public);
3205 }
3206
Mike Stump1eb44332009-09-09 15:08:12 +00003207 if (SC == FunctionDecl::Static && isa<CXXMethodDecl>(NewFD) &&
Douglas Gregor656de632009-03-11 23:52:16 +00003208 !CurContext->isRecord()) {
3209 // C++ [class.static]p1:
3210 // A data or function member of a class may be declared static
3211 // in a class definition, in which case it is a static member of
3212 // the class.
3213
3214 // Complain about the 'static' specifier if it's on an out-of-line
3215 // member function definition.
Mike Stump1eb44332009-09-09 15:08:12 +00003216 Diag(D.getDeclSpec().getStorageClassSpecLoc(),
Douglas Gregor656de632009-03-11 23:52:16 +00003217 diag::err_static_out_of_line)
Douglas Gregor849b2432010-03-31 17:46:05 +00003218 << FixItHint::CreateRemoval(D.getDeclSpec().getStorageClassSpecLoc());
Douglas Gregor656de632009-03-11 23:52:16 +00003219 }
3220
Zhongxing Xu416fcaf2009-01-16 01:13:29 +00003221 // Handle GNU asm-label extension (encoded as an attribute).
3222 if (Expr *E = (Expr*) D.getAsmLabel()) {
3223 // The parser guarantees this is a string.
Mike Stump1eb44332009-09-09 15:08:12 +00003224 StringLiteral *SE = cast<StringLiteral>(E);
Ted Kremenek3d2c43e2010-02-11 05:28:37 +00003225 NewFD->addAttr(::new (Context) AsmLabelAttr(Context, SE->getString()));
Zhongxing Xu416fcaf2009-01-16 01:13:29 +00003226 }
3227
Chris Lattner2dbd2852009-04-25 06:12:16 +00003228 // Copy the parameter declarations from the declarator D to the function
3229 // declaration NewFD, if they are available. First scavenge them into Params.
3230 llvm::SmallVector<ParmVarDecl*, 16> Params;
Zhongxing Xu416fcaf2009-01-16 01:13:29 +00003231 if (D.getNumTypeObjects() > 0) {
3232 DeclaratorChunk::FunctionTypeInfo &FTI = D.getTypeObject(0).Fun;
3233
Zhongxing Xu416fcaf2009-01-16 01:13:29 +00003234 // Check for C99 6.7.5.3p10 - foo(void) is a non-varargs
3235 // function that takes no arguments, not a function that takes a
3236 // single void argument.
3237 // We let through "const void" here because Sema::GetTypeForDeclarator
3238 // already checks for that case.
3239 if (FTI.NumArgs == 1 && !FTI.isVariadic && FTI.ArgInfo[0].Ident == 0 &&
3240 FTI.ArgInfo[0].Param &&
Chris Lattnerb28317a2009-03-28 19:18:32 +00003241 FTI.ArgInfo[0].Param.getAs<ParmVarDecl>()->getType()->isVoidType()) {
Chris Lattner2dbd2852009-04-25 06:12:16 +00003242 // Empty arg list, don't push any params.
Chris Lattnerb28317a2009-03-28 19:18:32 +00003243 ParmVarDecl *Param = FTI.ArgInfo[0].Param.getAs<ParmVarDecl>();
Zhongxing Xu416fcaf2009-01-16 01:13:29 +00003244
3245 // In C++, the empty parameter-type-list must be spelled "void"; a
3246 // typedef of void is not permitted.
3247 if (getLangOptions().CPlusPlus &&
Chris Lattner584be452009-04-25 05:44:12 +00003248 Param->getType().getUnqualifiedType() != Context.VoidTy)
Douglas Gregora3a83512009-04-01 23:51:29 +00003249 Diag(Param->getLocation(), diag::err_param_typedef_of_void);
Chris Lattner2dbd2852009-04-25 06:12:16 +00003250 // FIXME: Leaks decl?
Zhongxing Xu416fcaf2009-01-16 01:13:29 +00003251 } else if (FTI.NumArgs > 0 && FTI.ArgInfo[0].Param != 0) {
Argyrios Kyrtzidis9bedef62009-07-14 03:18:53 +00003252 for (unsigned i = 0, e = FTI.NumArgs; i != e; ++i) {
3253 ParmVarDecl *Param = FTI.ArgInfo[i].Param.getAs<ParmVarDecl>();
3254 assert(Param->getDeclContext() != NewFD && "Was set before ?");
3255 Param->setDeclContext(NewFD);
3256 Params.push_back(Param);
John McCallf19de1c2010-04-14 01:27:20 +00003257
3258 if (Param->isInvalidDecl())
3259 NewFD->setInvalidDecl();
Argyrios Kyrtzidis9bedef62009-07-14 03:18:53 +00003260 }
Zhongxing Xu416fcaf2009-01-16 01:13:29 +00003261 }
Mike Stump1eb44332009-09-09 15:08:12 +00003262
John McCall183700f2009-09-21 23:43:11 +00003263 } else if (const FunctionProtoType *FT = R->getAs<FunctionProtoType>()) {
Chris Lattner1ad9b282009-04-25 06:03:53 +00003264 // When we're declaring a function with a typedef, typeof, etc as in the
Zhongxing Xu416fcaf2009-01-16 01:13:29 +00003265 // following example, we'll need to synthesize (unnamed)
3266 // parameters for use in the declaration.
3267 //
3268 // @code
3269 // typedef void fn(int);
3270 // fn f;
3271 // @endcode
Mike Stump1eb44332009-09-09 15:08:12 +00003272
Chris Lattner1ad9b282009-04-25 06:03:53 +00003273 // Synthesize a parameter for each argument type.
Chris Lattner1ad9b282009-04-25 06:03:53 +00003274 for (FunctionProtoType::arg_type_iterator AI = FT->arg_type_begin(),
3275 AE = FT->arg_type_end(); AI != AE; ++AI) {
John McCall82dc0092010-06-04 11:21:44 +00003276 ParmVarDecl *Param =
3277 BuildParmVarDeclForTypedef(NewFD, D.getIdentifierLoc(), *AI);
Chris Lattner1ad9b282009-04-25 06:03:53 +00003278 Params.push_back(Param);
Zhongxing Xu416fcaf2009-01-16 01:13:29 +00003279 }
Chris Lattner84bb9442009-04-25 18:38:18 +00003280 } else {
3281 assert(R->isFunctionNoProtoType() && NewFD->getNumParams() == 0 &&
3282 "Should not need args for typedef of non-prototype fn");
Zhongxing Xu416fcaf2009-01-16 01:13:29 +00003283 }
Chris Lattner2dbd2852009-04-25 06:12:16 +00003284 // Finally, we know we have the right number of parameters, install them.
Douglas Gregor838db382010-02-11 01:19:42 +00003285 NewFD->setParams(Params.data(), Params.size());
Mike Stump1eb44332009-09-09 15:08:12 +00003286
Douglas Gregor0b60d9e2009-09-25 23:53:26 +00003287 // If the declarator is a template-id, translate the parser's template
3288 // argument list into our AST format.
3289 bool HasExplicitTemplateArgs = false;
John McCalld5532b62009-11-23 01:53:49 +00003290 TemplateArgumentListInfo TemplateArgs;
Douglas Gregor3f9a0562009-11-03 01:35:08 +00003291 if (D.getName().getKind() == UnqualifiedId::IK_TemplateId) {
3292 TemplateIdAnnotation *TemplateId = D.getName().TemplateId;
John McCalld5532b62009-11-23 01:53:49 +00003293 TemplateArgs.setLAngleLoc(TemplateId->LAngleLoc);
3294 TemplateArgs.setRAngleLoc(TemplateId->RAngleLoc);
Douglas Gregor0b60d9e2009-09-25 23:53:26 +00003295 ASTTemplateArgsPtr TemplateArgsPtr(*this,
3296 TemplateId->getTemplateArgs(),
Douglas Gregor0b60d9e2009-09-25 23:53:26 +00003297 TemplateId->NumArgs);
3298 translateTemplateArguments(TemplateArgsPtr,
Douglas Gregor0b60d9e2009-09-25 23:53:26 +00003299 TemplateArgs);
3300 TemplateArgsPtr.release();
3301
3302 HasExplicitTemplateArgs = true;
Douglas Gregor0b60d9e2009-09-25 23:53:26 +00003303
3304 if (FunctionTemplate) {
Douglas Gregor1fef4e62009-10-07 22:35:40 +00003305 // FIXME: Diagnose function template with explicit template
Douglas Gregor0b60d9e2009-09-25 23:53:26 +00003306 // arguments.
3307 HasExplicitTemplateArgs = false;
3308 } else if (!isFunctionTemplateSpecialization &&
3309 !D.getDeclSpec().isFriendSpecified()) {
3310 // We have encountered something that the user meant to be a
3311 // specialization (because it has explicitly-specified template
3312 // arguments) but that was not introduced with a "template<>" (or had
3313 // too few of them).
3314 Diag(D.getIdentifierLoc(), diag::err_template_spec_needs_header)
3315 << SourceRange(TemplateId->LAngleLoc, TemplateId->RAngleLoc)
Douglas Gregor849b2432010-03-31 17:46:05 +00003316 << FixItHint::CreateInsertion(
Douglas Gregor0b60d9e2009-09-25 23:53:26 +00003317 D.getDeclSpec().getSourceRange().getBegin(),
3318 "template<> ");
3319 isFunctionTemplateSpecialization = true;
John McCall7ad650f2010-03-24 07:46:06 +00003320 } else {
3321 // "friend void foo<>(int);" is an implicit specialization decl.
3322 isFunctionTemplateSpecialization = true;
Douglas Gregor0b60d9e2009-09-25 23:53:26 +00003323 }
John McCallaf2094e2010-04-08 09:05:18 +00003324 } else if (isFriend && isFunctionTemplateSpecialization) {
3325 // This combination is only possible in a recovery case; the user
3326 // wrote something like:
3327 // template <> friend void foo(int);
3328 // which we're recovering from as if the user had written:
3329 // friend void foo<>(int);
3330 // Go ahead and fake up a template id.
3331 HasExplicitTemplateArgs = true;
3332 TemplateArgs.setLAngleLoc(D.getIdentifierLoc());
3333 TemplateArgs.setRAngleLoc(D.getIdentifierLoc());
Douglas Gregor0b60d9e2009-09-25 23:53:26 +00003334 }
John McCall68263142009-11-18 22:49:29 +00003335
John McCallaf2094e2010-04-08 09:05:18 +00003336 // If it's a friend (and only if it's a friend), it's possible
3337 // that either the specialized function type or the specialized
3338 // template is dependent, and therefore matching will fail. In
3339 // this case, don't check the specialization yet.
3340 if (isFunctionTemplateSpecialization && isFriend &&
3341 (NewFD->getType()->isDependentType() || DC->isDependentContext())) {
3342 assert(HasExplicitTemplateArgs &&
3343 "friend function specialization without template args");
3344 if (CheckDependentFunctionTemplateSpecialization(NewFD, TemplateArgs,
3345 Previous))
Douglas Gregor036ada22010-03-24 17:31:23 +00003346 NewFD->setInvalidDecl();
John McCallaf2094e2010-04-08 09:05:18 +00003347 } else if (isFunctionTemplateSpecialization) {
3348 if (CheckFunctionTemplateSpecialization(NewFD,
3349 (HasExplicitTemplateArgs ? &TemplateArgs : 0),
3350 Previous))
3351 NewFD->setInvalidDecl();
3352 } else if (isExplicitSpecialization && isa<CXXMethodDecl>(NewFD)) {
3353 if (CheckMemberSpecialization(NewFD, Previous))
3354 NewFD->setInvalidDecl();
3355 }
John McCallba9d8532010-04-13 06:39:49 +00003356
Douglas Gregor2dc0e642009-03-23 23:06:20 +00003357 // Perform semantic checking on the function declaration.
3358 bool OverloadableAttrRequired = false; // FIXME: HACK!
John McCall9f54ad42009-12-10 09:41:52 +00003359 CheckFunctionDeclaration(S, NewFD, Previous, isExplicitSpecialization,
Douglas Gregorfd056bc2009-10-13 16:30:37 +00003360 Redeclaration, /*FIXME:*/OverloadableAttrRequired);
Douglas Gregor2dc0e642009-03-23 23:06:20 +00003361
John McCall68263142009-11-18 22:49:29 +00003362 assert((NewFD->isInvalidDecl() || !Redeclaration ||
3363 Previous.getResultKind() != LookupResult::FoundOverloaded) &&
3364 "previous declaration set still overloaded");
3365
John McCall76d32642010-04-24 01:30:58 +00003366 NamedDecl *PrincipalDecl = (FunctionTemplate
3367 ? cast<NamedDecl>(FunctionTemplate)
3368 : NewFD);
3369
John McCallb0cb0222010-03-27 05:57:59 +00003370 if (isFriend && Redeclaration) {
John McCallba9d8532010-04-13 06:39:49 +00003371 AccessSpecifier Access = AS_public;
3372 if (!NewFD->isInvalidDecl())
3373 Access = NewFD->getPreviousDeclaration()->getAccess();
3374
John McCallb0cb0222010-03-27 05:57:59 +00003375 NewFD->setAccess(Access);
John McCall76d32642010-04-24 01:30:58 +00003376 if (FunctionTemplate) FunctionTemplate->setAccess(Access);
3377
3378 PrincipalDecl->setObjectOfFriendDecl(true);
John McCallb0cb0222010-03-27 05:57:59 +00003379 }
3380
John McCall76d32642010-04-24 01:30:58 +00003381 if (NewFD->isOverloadedOperator() && !DC->isRecord() &&
3382 PrincipalDecl->isInIdentifierNamespace(Decl::IDNS_Ordinary))
3383 PrincipalDecl->setNonMemberOperator();
3384
Douglas Gregor5b6d70e2009-11-25 17:50:39 +00003385 // If we have a function template, check the template parameter
3386 // list. This will check and merge default template arguments.
3387 if (FunctionTemplate) {
3388 FunctionTemplateDecl *PrevTemplate = FunctionTemplate->getPreviousDeclaration();
3389 CheckTemplateParameterList(FunctionTemplate->getTemplateParameters(),
3390 PrevTemplate? PrevTemplate->getTemplateParameters() : 0,
3391 D.getDeclSpec().isFriendSpecified()? TPC_FriendFunctionTemplate
3392 : TPC_FunctionTemplate);
3393 }
3394
Chris Lattnereaaebc72009-04-25 08:06:05 +00003395 if (D.getCXXScopeSpec().isSet() && !NewFD->isInvalidDecl()) {
John McCall46460a62010-01-20 21:53:11 +00003396 // Fake up an access specifier if it's supposed to be a class member.
John McCall86ff3082010-02-04 22:26:26 +00003397 if (!Redeclaration && isa<CXXRecordDecl>(NewFD->getDeclContext()))
John McCall46460a62010-01-20 21:53:11 +00003398 NewFD->setAccess(AS_public);
3399
Douglas Gregor2dc0e642009-03-23 23:06:20 +00003400 // An out-of-line member function declaration must also be a
3401 // definition (C++ [dcl.meaning]p1).
Douglas Gregor741fab62009-10-08 15:54:21 +00003402 // Note that this is not the case for explicit specializations of
3403 // function templates or member functions of class templates, per
3404 // C++ [temp.expl.spec]p2.
Douglas Gregord85cef52009-09-17 19:51:30 +00003405 if (!IsFunctionDefinition && !isFriend &&
Douglas Gregor37d681852009-10-12 22:27:17 +00003406 !isFunctionTemplateSpecialization && !isExplicitSpecialization) {
Douglas Gregor2dc0e642009-03-23 23:06:20 +00003407 Diag(NewFD->getLocation(), diag::err_out_of_line_declaration)
3408 << D.getCXXScopeSpec().getRange();
Chris Lattnereaaebc72009-04-25 08:06:05 +00003409 NewFD->setInvalidDecl();
Douglas Gregor5d52e472010-01-16 18:09:52 +00003410 } else if (!Redeclaration &&
3411 !(isFriend && CurContext->isDependentContext())) {
Douglas Gregor2dc0e642009-03-23 23:06:20 +00003412 // The user tried to provide an out-of-line definition for a
3413 // function that is a member of a class or namespace, but there
Mike Stump1eb44332009-09-09 15:08:12 +00003414 // was no such member function declared (C++ [class.mfct]p2,
Douglas Gregor2dc0e642009-03-23 23:06:20 +00003415 // C++ [namespace.memdef]p2). For example:
Mike Stump1eb44332009-09-09 15:08:12 +00003416 //
Douglas Gregor2dc0e642009-03-23 23:06:20 +00003417 // class X {
3418 // void f() const;
Mike Stump1eb44332009-09-09 15:08:12 +00003419 // };
Douglas Gregor2dc0e642009-03-23 23:06:20 +00003420 //
3421 // void X::f() { } // ill-formed
3422 //
3423 // Complain about this problem, and attempt to suggest close
3424 // matches (e.g., those that differ only in cv-qualifiers and
3425 // whether the parameter types are references).
3426 Diag(D.getIdentifierLoc(), diag::err_member_def_does_not_match)
Douglas Gregor3f093272009-10-13 21:16:44 +00003427 << Name << DC << D.getCXXScopeSpec().getRange();
Chris Lattnereaaebc72009-04-25 08:06:05 +00003428 NewFD->setInvalidDecl();
Mike Stump1eb44332009-09-09 15:08:12 +00003429
John McCalla24dc2e2009-11-17 02:14:36 +00003430 LookupResult Prev(*this, Name, D.getIdentifierLoc(), LookupOrdinaryName,
John McCall7d384dd2009-11-18 07:57:50 +00003431 ForRedeclaration);
John McCalla24dc2e2009-11-17 02:14:36 +00003432 LookupQualifiedName(Prev, DC);
Mike Stump1eb44332009-09-09 15:08:12 +00003433 assert(!Prev.isAmbiguous() &&
Douglas Gregor2dc0e642009-03-23 23:06:20 +00003434 "Cannot have an ambiguity in previous-declaration lookup");
3435 for (LookupResult::iterator Func = Prev.begin(), FuncEnd = Prev.end();
3436 Func != FuncEnd; ++Func) {
3437 if (isa<FunctionDecl>(*Func) &&
3438 isNearlyMatchingFunction(Context, cast<FunctionDecl>(*Func), NewFD))
3439 Diag((*Func)->getLocation(), diag::note_member_def_close_match);
3440 }
Douglas Gregor2dc0e642009-03-23 23:06:20 +00003441 }
3442 }
3443
3444 // Handle attributes. We need to have merged decls when handling attributes
3445 // (for example to check for conflicts, etc).
3446 // FIXME: This needs to happen before we merge declarations. Then,
3447 // let attribute merging cope with attribute conflicts.
Douglas Gregor9cdda0c2009-06-17 21:51:59 +00003448 ProcessDeclAttributes(S, NewFD, D);
Ryan Flynn478fbc62009-07-25 22:29:44 +00003449
3450 // attributes declared post-definition are currently ignored
John McCall68263142009-11-18 22:49:29 +00003451 if (Redeclaration && Previous.isSingleResult()) {
3452 const FunctionDecl *Def;
3453 FunctionDecl *PrevFD = dyn_cast<FunctionDecl>(Previous.getFoundDecl());
Ryan Flynn478fbc62009-07-25 22:29:44 +00003454 if (PrevFD && PrevFD->getBody(Def) && D.hasAttributes()) {
3455 Diag(NewFD->getLocation(), diag::warn_attribute_precede_definition);
3456 Diag(Def->getLocation(), diag::note_previous_definition);
3457 }
3458 }
3459
Douglas Gregor2dc0e642009-03-23 23:06:20 +00003460 AddKnownFunctionAttributes(NewFD);
3461
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +00003462 if (OverloadableAttrRequired && !NewFD->getAttr<OverloadableAttr>()) {
Douglas Gregor2dc0e642009-03-23 23:06:20 +00003463 // If a function name is overloadable in C, then every function
3464 // with that name must be marked "overloadable".
3465 Diag(NewFD->getLocation(), diag::err_attribute_overloadable_missing)
3466 << Redeclaration << NewFD;
John McCall68263142009-11-18 22:49:29 +00003467 if (!Previous.empty())
3468 Diag(Previous.getRepresentativeDecl()->getLocation(),
Douglas Gregor2dc0e642009-03-23 23:06:20 +00003469 diag::note_attribute_overloadable_prev_overload);
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +00003470 NewFD->addAttr(::new (Context) OverloadableAttr());
Douglas Gregor2dc0e642009-03-23 23:06:20 +00003471 }
3472
3473 // If this is a locally-scoped extern C function, update the
3474 // map of such names.
Douglas Gregor48a83b52009-09-12 00:17:51 +00003475 if (CurContext->isFunctionOrMethod() && NewFD->isExternC()
Chris Lattnereaaebc72009-04-25 08:06:05 +00003476 && !NewFD->isInvalidDecl())
John McCall68263142009-11-18 22:49:29 +00003477 RegisterLocallyScopedExternCDecl(NewFD, Previous, S);
Douglas Gregor2dc0e642009-03-23 23:06:20 +00003478
Argyrios Kyrtzidis16f19302009-06-25 18:22:24 +00003479 // Set this FunctionDecl's range up to the right paren.
3480 NewFD->setLocEnd(D.getSourceRange().getEnd());
3481
Douglas Gregore53060f2009-06-25 22:08:12 +00003482 if (FunctionTemplate && NewFD->isInvalidDecl())
3483 FunctionTemplate->setInvalidDecl();
Mike Stump1eb44332009-09-09 15:08:12 +00003484
Douglas Gregore53060f2009-06-25 22:08:12 +00003485 if (FunctionTemplate)
3486 return FunctionTemplate;
Mike Stump1eb44332009-09-09 15:08:12 +00003487
Tanya Lattnere6bbc012010-02-12 00:07:30 +00003488
3489 // Keep track of static, non-inlined function definitions that
3490 // have not been used. We will warn later.
3491 // FIXME: Also include static functions declared but not defined.
3492 if (!NewFD->isInvalidDecl() && IsFunctionDefinition
3493 && !NewFD->isInlined() && NewFD->getLinkage() == InternalLinkage
Chris Lattner1a4221c2010-04-09 17:25:05 +00003494 && !NewFD->isUsed() && !NewFD->hasAttr<UnusedAttr>()
3495 && !NewFD->hasAttr<ConstructorAttr>()
3496 && !NewFD->hasAttr<DestructorAttr>())
Tanya Lattnere6bbc012010-02-12 00:07:30 +00003497 UnusedStaticFuncs.push_back(NewFD);
3498
Douglas Gregor2dc0e642009-03-23 23:06:20 +00003499 return NewFD;
3500}
3501
3502/// \brief Perform semantic checking of a new function declaration.
3503///
3504/// Performs semantic analysis of the new function declaration
3505/// NewFD. This routine performs all semantic checking that does not
3506/// require the actual declarator involved in the declaration, and is
3507/// used both for the declaration of functions as they are parsed
3508/// (called via ActOnDeclarator) and for the declaration of functions
3509/// that have been instantiated via C++ template instantiation (called
3510/// via InstantiateDecl).
3511///
Douglas Gregorfd056bc2009-10-13 16:30:37 +00003512/// \param IsExplicitSpecialiation whether this new function declaration is
3513/// an explicit specialization of the previous declaration.
3514///
Chris Lattnereaaebc72009-04-25 08:06:05 +00003515/// This sets NewFD->isInvalidDecl() to true if there was an error.
John McCall9f54ad42009-12-10 09:41:52 +00003516void Sema::CheckFunctionDeclaration(Scope *S, FunctionDecl *NewFD,
John McCall68263142009-11-18 22:49:29 +00003517 LookupResult &Previous,
Douglas Gregorfd056bc2009-10-13 16:30:37 +00003518 bool IsExplicitSpecialization,
Douglas Gregor2dc0e642009-03-23 23:06:20 +00003519 bool &Redeclaration,
3520 bool &OverloadableAttrRequired) {
Chris Lattnereaaebc72009-04-25 08:06:05 +00003521 // If NewFD is already known erroneous, don't do any of this checking.
3522 if (NewFD->isInvalidDecl())
3523 return;
Douglas Gregor2dc0e642009-03-23 23:06:20 +00003524
Eli Friedman88f7b572009-05-16 12:15:55 +00003525 if (NewFD->getResultType()->isVariablyModifiedType()) {
3526 // Functions returning a variably modified type violate C99 6.7.5.2p2
3527 // because all functions have linkage.
3528 Diag(NewFD->getLocation(), diag::err_vm_func_decl);
3529 return NewFD->setInvalidDecl();
3530 }
3531
Douglas Gregor48a83b52009-09-12 00:17:51 +00003532 if (NewFD->isMain())
3533 CheckMain(NewFD);
John McCall8c4859a2009-07-24 03:03:21 +00003534
Douglas Gregor2dc0e642009-03-23 23:06:20 +00003535 // Check for a previous declaration of this name.
John McCall68263142009-11-18 22:49:29 +00003536 if (Previous.empty() && NewFD->isExternC()) {
Douglas Gregor63935192009-03-02 00:19:53 +00003537 // Since we did not find anything by this name and we're declaring
3538 // an extern "C" function, look for a non-visible extern "C"
3539 // declaration with the same name.
3540 llvm::DenseMap<DeclarationName, NamedDecl *>::iterator Pos
Douglas Gregor2dc0e642009-03-23 23:06:20 +00003541 = LocallyScopedExternalDecls.find(NewFD->getDeclName());
Douglas Gregor63935192009-03-02 00:19:53 +00003542 if (Pos != LocallyScopedExternalDecls.end())
John McCall68263142009-11-18 22:49:29 +00003543 Previous.addDecl(Pos->second);
Douglas Gregor63935192009-03-02 00:19:53 +00003544 }
3545
Douglas Gregor04495c82009-02-24 01:23:02 +00003546 // Merge or overload the declaration with an existing declaration of
3547 // the same name, if appropriate.
John McCall68263142009-11-18 22:49:29 +00003548 if (!Previous.empty()) {
Douglas Gregorf9201e02009-02-11 23:02:49 +00003549 // Determine whether NewFD is an overload of PrevDecl or
Zhongxing Xu416fcaf2009-01-16 01:13:29 +00003550 // a declaration that requires merging. If it's an overload,
3551 // there's no more work to do here; we'll just add the new
3552 // function to the scope.
Douglas Gregorae170942009-02-13 00:26:38 +00003553
John McCall68263142009-11-18 22:49:29 +00003554 NamedDecl *OldDecl = 0;
John McCall871b2e72009-12-09 03:35:25 +00003555 if (!AllowOverloadingOfFunction(Previous, Context)) {
3556 Redeclaration = true;
3557 OldDecl = Previous.getFoundDecl();
3558 } else {
3559 if (!getLangOptions().CPlusPlus) {
3560 OverloadableAttrRequired = true;
3561
3562 // Functions marked "overloadable" must have a prototype (that
3563 // we can't get through declaration merging).
3564 if (!NewFD->getType()->getAs<FunctionProtoType>()) {
3565 Diag(NewFD->getLocation(),
3566 diag::err_attribute_overloadable_no_prototype)
3567 << NewFD;
John McCall68263142009-11-18 22:49:29 +00003568 Redeclaration = true;
John McCall871b2e72009-12-09 03:35:25 +00003569
3570 // Turn this into a variadic function with no parameters.
3571 QualType R = Context.getFunctionType(
3572 NewFD->getType()->getAs<FunctionType>()->getResultType(),
Rafael Espindola264ba482010-03-30 20:24:48 +00003573 0, 0, true, 0, false, false, 0, 0,
3574 FunctionType::ExtInfo());
John McCall871b2e72009-12-09 03:35:25 +00003575 NewFD->setType(R);
3576 return NewFD->setInvalidDecl();
3577 }
3578 }
3579
3580 switch (CheckOverload(NewFD, Previous, OldDecl)) {
3581 case Ovl_Match:
John McCall9f54ad42009-12-10 09:41:52 +00003582 Redeclaration = true;
3583 if (isa<UsingShadowDecl>(OldDecl) && CurContext->isRecord()) {
3584 HideUsingShadowDecl(S, cast<UsingShadowDecl>(OldDecl));
3585 Redeclaration = false;
3586 }
John McCall871b2e72009-12-09 03:35:25 +00003587 break;
3588
3589 case Ovl_NonFunction:
3590 Redeclaration = true;
3591 break;
3592
3593 case Ovl_Overload:
3594 Redeclaration = false;
3595 break;
John McCall68263142009-11-18 22:49:29 +00003596 }
3597 }
Zhongxing Xu416fcaf2009-01-16 01:13:29 +00003598
John McCall68263142009-11-18 22:49:29 +00003599 if (Redeclaration) {
Douglas Gregor2dc0e642009-03-23 23:06:20 +00003600 // NewFD and OldDecl represent declarations that need to be
Mike Stump1eb44332009-09-09 15:08:12 +00003601 // merged.
Douglas Gregorcda9c672009-02-16 17:45:42 +00003602 if (MergeFunctionDecl(NewFD, OldDecl))
Chris Lattnereaaebc72009-04-25 08:06:05 +00003603 return NewFD->setInvalidDecl();
Zhongxing Xu416fcaf2009-01-16 01:13:29 +00003604
John McCall68263142009-11-18 22:49:29 +00003605 Previous.clear();
3606 Previous.addDecl(OldDecl);
3607
Douglas Gregore53060f2009-06-25 22:08:12 +00003608 if (FunctionTemplateDecl *OldTemplateDecl
Douglas Gregor37d681852009-10-12 22:27:17 +00003609 = dyn_cast<FunctionTemplateDecl>(OldDecl)) {
Douglas Gregorfd056bc2009-10-13 16:30:37 +00003610 NewFD->setPreviousDeclaration(OldTemplateDecl->getTemplatedDecl());
Douglas Gregor37d681852009-10-12 22:27:17 +00003611 FunctionTemplateDecl *NewTemplateDecl
3612 = NewFD->getDescribedFunctionTemplate();
3613 assert(NewTemplateDecl && "Template/non-template mismatch");
3614 if (CXXMethodDecl *Method
3615 = dyn_cast<CXXMethodDecl>(NewTemplateDecl->getTemplatedDecl())) {
3616 Method->setAccess(OldTemplateDecl->getAccess());
3617 NewTemplateDecl->setAccess(OldTemplateDecl->getAccess());
3618 }
Douglas Gregorfd056bc2009-10-13 16:30:37 +00003619
3620 // If this is an explicit specialization of a member that is a function
3621 // template, mark it as a member specialization.
3622 if (IsExplicitSpecialization &&
3623 NewTemplateDecl->getInstantiatedFromMemberTemplate()) {
3624 NewTemplateDecl->setMemberSpecialization();
3625 assert(OldTemplateDecl->isMemberSpecialization());
3626 }
Douglas Gregor37d681852009-10-12 22:27:17 +00003627 } else {
Argyrios Kyrtzidis9bedef62009-07-14 03:18:53 +00003628 if (isa<CXXMethodDecl>(NewFD)) // Set access for out-of-line definitions
3629 NewFD->setAccess(OldDecl->getAccess());
Douglas Gregore53060f2009-06-25 22:08:12 +00003630 NewFD->setPreviousDeclaration(cast<FunctionDecl>(OldDecl));
Argyrios Kyrtzidis9bedef62009-07-14 03:18:53 +00003631 }
Zhongxing Xu416fcaf2009-01-16 01:13:29 +00003632 }
Douglas Gregor4ce205f2009-02-06 17:46:57 +00003633 }
Zhongxing Xu416fcaf2009-01-16 01:13:29 +00003634
Anders Carlsson2c59d3c2009-09-13 21:33:06 +00003635 // Semantic checking for this function declaration (in isolation).
3636 if (getLangOptions().CPlusPlus) {
3637 // C++-specific checks.
3638 if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(NewFD)) {
3639 CheckConstructor(Constructor);
Anders Carlsson6d701392009-11-15 22:49:34 +00003640 } else if (CXXDestructorDecl *Destructor =
3641 dyn_cast<CXXDestructorDecl>(NewFD)) {
3642 CXXRecordDecl *Record = Destructor->getParent();
Anders Carlsson2c59d3c2009-09-13 21:33:06 +00003643 QualType ClassType = Context.getTypeDeclType(Record);
Anders Carlsson6d701392009-11-15 22:49:34 +00003644
3645 // FIXME: Shouldn't we be able to perform thisc heck even when the class
3646 // type is dependent? Both gcc and edg can handle that.
Anders Carlsson2c59d3c2009-09-13 21:33:06 +00003647 if (!ClassType->isDependentType()) {
3648 DeclarationName Name
3649 = Context.DeclarationNames.getCXXDestructorName(
3650 Context.getCanonicalType(ClassType));
3651 if (NewFD->getDeclName() != Name) {
3652 Diag(NewFD->getLocation(), diag::err_destructor_name);
3653 return NewFD->setInvalidDecl();
3654 }
3655 }
Anders Carlsson6d701392009-11-15 22:49:34 +00003656
Anders Carlsson2c59d3c2009-09-13 21:33:06 +00003657 Record->setUserDeclaredDestructor(true);
3658 // C++ [class]p4: A POD-struct is an aggregate class that has [...] no
3659 // user-defined destructor.
3660 Record->setPOD(false);
3661
3662 // C++ [class.dtor]p3: A destructor is trivial if it is an implicitly-
3663 // declared destructor.
3664 // FIXME: C++0x: don't do this for "= default" destructors
3665 Record->setHasTrivialDestructor(false);
3666 } else if (CXXConversionDecl *Conversion
Douglas Gregor4ba31362009-12-01 17:24:26 +00003667 = dyn_cast<CXXConversionDecl>(NewFD)) {
Anders Carlsson2c59d3c2009-09-13 21:33:06 +00003668 ActOnConversionDeclarator(Conversion);
Douglas Gregor4ba31362009-12-01 17:24:26 +00003669 }
3670
3671 // Find any virtual functions that this function overrides.
Douglas Gregore6342c02009-12-01 17:35:23 +00003672 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(NewFD)) {
3673 if (!Method->isFunctionTemplateSpecialization() &&
3674 !Method->getDescribedFunctionTemplate())
3675 AddOverriddenMethods(Method->getParent(), Method);
3676 }
Anders Carlsson2c59d3c2009-09-13 21:33:06 +00003677
Eli Friedman5fcf1f02009-12-02 07:16:50 +00003678 // Additional checks for the destructor; make sure we do this after we
3679 // figure out whether the destructor is virtual.
3680 if (CXXDestructorDecl *Destructor = dyn_cast<CXXDestructorDecl>(NewFD))
3681 if (!Destructor->getParent()->isDependentType())
3682 CheckDestructor(Destructor);
3683
Anders Carlsson2c59d3c2009-09-13 21:33:06 +00003684 // Extra checking for C++ overloaded operators (C++ [over.oper]).
3685 if (NewFD->isOverloadedOperator() &&
3686 CheckOverloadedOperatorDeclaration(NewFD))
3687 return NewFD->setInvalidDecl();
Sean Hunta6c058d2010-01-13 09:01:02 +00003688
3689 // Extra checking for C++0x literal operators (C++0x [over.literal]).
3690 if (NewFD->getLiteralIdentifier() &&
3691 CheckLiteralOperatorDeclaration(NewFD))
3692 return NewFD->setInvalidDecl();
3693
Anders Carlsson2c59d3c2009-09-13 21:33:06 +00003694 // In C++, check default arguments now that we have merged decls. Unless
3695 // the lexical context is the class, because in this case this is done
3696 // during delayed parsing anyway.
3697 if (!CurContext->isRecord())
3698 CheckCXXDefaultArguments(NewFD);
3699 }
Zhongxing Xu416fcaf2009-01-16 01:13:29 +00003700}
3701
John McCall8c4859a2009-07-24 03:03:21 +00003702void Sema::CheckMain(FunctionDecl* FD) {
John McCall13591ed2009-07-25 04:36:53 +00003703 // C++ [basic.start.main]p3: A program that declares main to be inline
3704 // or static is ill-formed.
3705 // C99 6.7.4p4: In a hosted environment, the inline function specifier
3706 // shall not appear in a declaration of main.
3707 // static main is not an error under C99, but we should warn about it.
Douglas Gregor0130f3c2009-10-27 21:01:01 +00003708 bool isInline = FD->isInlineSpecified();
John McCall13591ed2009-07-25 04:36:53 +00003709 bool isStatic = FD->getStorageClass() == FunctionDecl::Static;
3710 if (isInline || isStatic) {
3711 unsigned diagID = diag::warn_unusual_main_decl;
3712 if (isInline || getLangOptions().CPlusPlus)
3713 diagID = diag::err_unusual_main_decl;
3714
3715 int which = isStatic + (isInline << 1) - 1;
3716 Diag(FD->getLocation(), diagID) << which;
3717 }
3718
3719 QualType T = FD->getType();
3720 assert(T->isFunctionType() && "function decl is not of function type");
John McCall183700f2009-09-21 23:43:11 +00003721 const FunctionType* FT = T->getAs<FunctionType>();
Mike Stump1eb44332009-09-09 15:08:12 +00003722
John McCall13591ed2009-07-25 04:36:53 +00003723 if (!Context.hasSameUnqualifiedType(FT->getResultType(), Context.IntTy)) {
3724 // TODO: add a replacement fixit to turn the return type into 'int'.
3725 Diag(FD->getTypeSpecStartLoc(), diag::err_main_returns_nonint);
3726 FD->setInvalidDecl(true);
3727 }
3728
3729 // Treat protoless main() as nullary.
3730 if (isa<FunctionNoProtoType>(FT)) return;
3731
3732 const FunctionProtoType* FTP = cast<const FunctionProtoType>(FT);
3733 unsigned nparams = FTP->getNumArgs();
3734 assert(FD->getNumParams() == nparams);
3735
John McCall66755862009-12-24 09:58:38 +00003736 bool HasExtraParameters = (nparams > 3);
3737
3738 // Darwin passes an undocumented fourth argument of type char**. If
3739 // other platforms start sprouting these, the logic below will start
3740 // getting shifty.
3741 if (nparams == 4 &&
3742 Context.Target.getTriple().getOS() == llvm::Triple::Darwin)
3743 HasExtraParameters = false;
3744
3745 if (HasExtraParameters) {
John McCall13591ed2009-07-25 04:36:53 +00003746 Diag(FD->getLocation(), diag::err_main_surplus_args) << nparams;
3747 FD->setInvalidDecl(true);
3748 nparams = 3;
3749 }
3750
3751 // FIXME: a lot of the following diagnostics would be improved
3752 // if we had some location information about types.
3753
3754 QualType CharPP =
3755 Context.getPointerType(Context.getPointerType(Context.CharTy));
John McCall66755862009-12-24 09:58:38 +00003756 QualType Expected[] = { Context.IntTy, CharPP, CharPP, CharPP };
John McCall13591ed2009-07-25 04:36:53 +00003757
3758 for (unsigned i = 0; i < nparams; ++i) {
3759 QualType AT = FTP->getArgType(i);
3760
3761 bool mismatch = true;
3762
3763 if (Context.hasSameUnqualifiedType(AT, Expected[i]))
3764 mismatch = false;
3765 else if (Expected[i] == CharPP) {
3766 // As an extension, the following forms are okay:
3767 // char const **
3768 // char const * const *
3769 // char * const *
3770
John McCall0953e762009-09-24 19:53:00 +00003771 QualifierCollector qs;
John McCall13591ed2009-07-25 04:36:53 +00003772 const PointerType* PT;
Ted Kremenek6217b802009-07-29 21:53:49 +00003773 if ((PT = qs.strip(AT)->getAs<PointerType>()) &&
3774 (PT = qs.strip(PT->getPointeeType())->getAs<PointerType>()) &&
John McCall13591ed2009-07-25 04:36:53 +00003775 (QualType(qs.strip(PT->getPointeeType()), 0) == Context.CharTy)) {
3776 qs.removeConst();
3777 mismatch = !qs.empty();
3778 }
3779 }
3780
3781 if (mismatch) {
3782 Diag(FD->getLocation(), diag::err_main_arg_wrong) << i << Expected[i];
3783 // TODO: suggest replacing given type with expected type
3784 FD->setInvalidDecl(true);
3785 }
3786 }
3787
3788 if (nparams == 1 && !FD->isInvalidDecl()) {
3789 Diag(FD->getLocation(), diag::warn_main_one_arg);
3790 }
John McCall8c4859a2009-07-24 03:03:21 +00003791}
3792
Eli Friedmanc594b322008-05-20 13:48:25 +00003793bool Sema::CheckForConstantInitializer(Expr *Init, QualType DclT) {
Eli Friedman3b8a36a2009-02-27 04:17:12 +00003794 // FIXME: Need strict checking. In C89, we need to check for
3795 // any assignment, increment, decrement, function-calls, or
3796 // commas outside of a sizeof. In C99, it's the same list,
3797 // except that the aforementioned are allowed in unevaluated
3798 // expressions. Everything else falls under the
3799 // "may accept other forms of constant expressions" exception.
3800 // (We never end up here for C++, so the constant expression
3801 // rules there don't matter.)
Chris Lattner111c2ee2009-02-24 21:54:33 +00003802 if (Init->isConstantInitializer(Context))
Eli Friedman578a9722009-02-22 06:45:27 +00003803 return false;
Eli Friedman21298282009-02-26 04:47:58 +00003804 Diag(Init->getExprLoc(), diag::err_init_element_not_constant)
3805 << Init->getSourceRange();
Eli Friedmanc594b322008-05-20 13:48:25 +00003806 return true;
Steve Naroffd0091aa2008-01-10 22:15:12 +00003807}
3808
Anders Carlsson9abf2ae2009-08-16 05:13:48 +00003809void Sema::AddInitializerToDecl(DeclPtrTy dcl, ExprArg init) {
3810 AddInitializerToDecl(dcl, move(init), /*DirectInit=*/false);
Douglas Gregor09f41cf2009-01-14 15:45:31 +00003811}
3812
3813/// AddInitializerToDecl - Adds the initializer Init to the
3814/// declaration dcl. If DirectInit is true, this is C++ direct
3815/// initialization rather than copy initialization.
Chris Lattnerb28317a2009-03-28 19:18:32 +00003816void Sema::AddInitializerToDecl(DeclPtrTy dcl, ExprArg init, bool DirectInit) {
3817 Decl *RealDecl = dcl.getAs<Decl>();
Chris Lattner9a11b9a2007-10-19 20:10:30 +00003818 // If there is no declaration, there was an error parsing it. Just ignore
3819 // the initializer.
Eli Friedman3b8a36a2009-02-27 04:17:12 +00003820 if (RealDecl == 0)
Chris Lattner9a11b9a2007-10-19 20:10:30 +00003821 return;
Mike Stump1eb44332009-09-09 15:08:12 +00003822
Douglas Gregor021c3b32009-03-11 23:00:04 +00003823 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(RealDecl)) {
3824 // With declarators parsed the way they are, the parser cannot
3825 // distinguish between a normal initializer and a pure-specifier.
3826 // Thus this grotesque test.
3827 IntegerLiteral *IL;
3828 Expr *Init = static_cast<Expr *>(init.get());
3829 if ((IL = dyn_cast<IntegerLiteral>(Init)) && IL->getValue() == 0 &&
Douglas Gregor4ba31362009-12-01 17:24:26 +00003830 Context.getCanonicalType(IL->getType()) == Context.IntTy)
3831 CheckPureMethod(Method, Init->getSourceRange());
3832 else {
Douglas Gregor021c3b32009-03-11 23:00:04 +00003833 Diag(Method->getLocation(), diag::err_member_function_initialization)
3834 << Method->getDeclName() << Init->getSourceRange();
3835 Method->setInvalidDecl();
3836 }
3837 return;
3838 }
3839
Steve Naroff410e3e22007-09-12 20:13:48 +00003840 VarDecl *VDecl = dyn_cast<VarDecl>(RealDecl);
3841 if (!VDecl) {
Douglas Gregor021c3b32009-03-11 23:00:04 +00003842 if (getLangOptions().CPlusPlus &&
3843 RealDecl->getLexicalDeclContext()->isRecord() &&
3844 isa<NamedDecl>(RealDecl))
3845 Diag(RealDecl->getLocation(), diag::err_member_initialization)
3846 << cast<NamedDecl>(RealDecl)->getDeclName();
3847 else
3848 Diag(RealDecl->getLocation(), diag::err_illegal_initializer);
Steve Naroff410e3e22007-09-12 20:13:48 +00003849 RealDecl->setInvalidDecl();
3850 return;
Eli Friedman3b8a36a2009-02-27 04:17:12 +00003851 }
3852
Eli Friedman49e2b8e2009-11-14 03:40:14 +00003853 // A definition must end up with a complete type, which means it must be
3854 // complete with the restriction that an array type might be completed by the
3855 // initializer; note that later code assumes this restriction.
3856 QualType BaseDeclType = VDecl->getType();
3857 if (const ArrayType *Array = Context.getAsIncompleteArrayType(BaseDeclType))
3858 BaseDeclType = Array->getElementType();
3859 if (RequireCompleteType(VDecl->getLocation(), BaseDeclType,
Eli Friedmana31feca2009-04-13 21:28:54 +00003860 diag::err_typecheck_decl_incomplete_type)) {
3861 RealDecl->setInvalidDecl();
3862 return;
3863 }
3864
Douglas Gregor1ab537b2009-12-03 18:33:45 +00003865 // The variable can not have an abstract class type.
3866 if (RequireNonAbstractType(VDecl->getLocation(), VDecl->getType(),
3867 diag::err_abstract_type_in_decl,
3868 AbstractVariableType))
3869 VDecl->setInvalidDecl();
3870
Sebastian Redl31310a22010-02-01 20:16:42 +00003871 const VarDecl *Def;
3872 if ((Def = VDecl->getDefinition()) && Def != VDecl) {
Mike Stump1eb44332009-09-09 15:08:12 +00003873 Diag(VDecl->getLocation(), diag::err_redefinition)
Douglas Gregor275a3692009-03-10 23:43:53 +00003874 << VDecl->getDeclName();
3875 Diag(Def->getLocation(), diag::note_previous_definition);
3876 VDecl->setInvalidDecl();
3877 return;
3878 }
3879
Eli Friedman3b8a36a2009-02-27 04:17:12 +00003880 // Take ownership of the expression, now that we're sure we have somewhere
3881 // to put it.
Anders Carlssonf1b1d592009-05-01 19:30:39 +00003882 Expr *Init = init.takeAs<Expr>();
Eli Friedman3b8a36a2009-02-27 04:17:12 +00003883 assert(Init && "missing initializer");
3884
Douglas Gregor99a2e602009-12-16 01:38:02 +00003885 // Capture the variable that is being initialized and the style of
3886 // initialization.
3887 InitializedEntity Entity = InitializedEntity::InitializeVariable(VDecl);
3888
3889 // FIXME: Poor source location information.
3890 InitializationKind Kind
3891 = DirectInit? InitializationKind::CreateDirect(VDecl->getLocation(),
3892 Init->getLocStart(),
3893 Init->getLocEnd())
3894 : InitializationKind::CreateCopy(VDecl->getLocation(),
3895 Init->getLocStart());
3896
Steve Naroffbb204692007-09-12 14:07:44 +00003897 // Get the decls type and save a reference for later, since
Steve Naroffd0091aa2008-01-10 22:15:12 +00003898 // CheckInitializerTypes may change it.
Steve Naroff410e3e22007-09-12 20:13:48 +00003899 QualType DclT = VDecl->getType(), SavT = DclT;
Steve Naroff248a7532008-04-15 22:42:06 +00003900 if (VDecl->isBlockVarDecl()) {
Daniel Dunbar5466c7b2009-04-14 02:25:56 +00003901 if (VDecl->hasExternalStorage()) { // C99 6.7.8p5
Steve Naroff410e3e22007-09-12 20:13:48 +00003902 Diag(VDecl->getLocation(), diag::err_block_extern_cant_init);
Steve Naroff248a7532008-04-15 22:42:06 +00003903 VDecl->setInvalidDecl();
3904 } else if (!VDecl->isInvalidDecl()) {
Eli Friedmancfdc81a2009-12-19 08:11:05 +00003905 InitializationSequence InitSeq(*this, Entity, Kind, &Init, 1);
Eli Friedmana91eb542009-12-22 02:10:53 +00003906 OwningExprResult Result = InitSeq.Perform(*this, Entity, Kind,
Eli Friedmancfdc81a2009-12-19 08:11:05 +00003907 MultiExprArg(*this, (void**)&Init, 1),
Eli Friedmana91eb542009-12-22 02:10:53 +00003908 &DclT);
3909 if (Result.isInvalid()) {
Steve Naroff248a7532008-04-15 22:42:06 +00003910 VDecl->setInvalidDecl();
Eli Friedmancfdc81a2009-12-19 08:11:05 +00003911 return;
3912 }
Mike Stump1eb44332009-09-09 15:08:12 +00003913
Eli Friedmana91eb542009-12-22 02:10:53 +00003914 Init = Result.takeAs<Expr>();
3915
Anders Carlssonc5eb7312008-08-22 05:00:02 +00003916 // C++ 3.6.2p2, allow dynamic initialization of static initializers.
Eli Friedmanda153232009-02-20 01:34:21 +00003917 // Don't check invalid declarations to avoid emitting useless diagnostics.
3918 if (!getLangOptions().CPlusPlus && !VDecl->isInvalidDecl()) {
Daniel Dunbar5466c7b2009-04-14 02:25:56 +00003919 if (VDecl->getStorageClass() == VarDecl::Static) // C99 6.7.8p4.
Anders Carlssonc5eb7312008-08-22 05:00:02 +00003920 CheckForConstantInitializer(Init, DclT);
3921 }
Steve Naroffbb204692007-09-12 14:07:44 +00003922 }
Mike Stump1eb44332009-09-09 15:08:12 +00003923 } else if (VDecl->isStaticDataMember() &&
Douglas Gregor021c3b32009-03-11 23:00:04 +00003924 VDecl->getLexicalDeclContext()->isRecord()) {
3925 // This is an in-class initialization for a static data member, e.g.,
3926 //
3927 // struct S {
3928 // static const int value = 17;
3929 // };
3930
3931 // Attach the initializer
Douglas Gregor838db382010-02-11 01:19:42 +00003932 VDecl->setInit(Init);
Douglas Gregor021c3b32009-03-11 23:00:04 +00003933
3934 // C++ [class.mem]p4:
3935 // A member-declarator can contain a constant-initializer only
3936 // if it declares a static member (9.4) of const integral or
3937 // const enumeration type, see 9.4.2.
3938 QualType T = VDecl->getType();
Mike Stump1eb44332009-09-09 15:08:12 +00003939 if (!T->isDependentType() &&
Douglas Gregor021c3b32009-03-11 23:00:04 +00003940 (!Context.getCanonicalType(T).isConstQualified() ||
3941 !T->isIntegralType())) {
3942 Diag(VDecl->getLocation(), diag::err_member_initialization)
3943 << VDecl->getDeclName() << Init->getSourceRange();
3944 VDecl->setInvalidDecl();
3945 } else {
3946 // C++ [class.static.data]p4:
3947 // If a static data member is of const integral or const
3948 // enumeration type, its declaration in the class definition
3949 // can specify a constant-initializer which shall be an
3950 // integral constant expression (5.19).
3951 if (!Init->isTypeDependent() &&
3952 !Init->getType()->isIntegralType()) {
3953 // We have a non-dependent, non-integral or enumeration type.
Mike Stump1eb44332009-09-09 15:08:12 +00003954 Diag(Init->getSourceRange().getBegin(),
Douglas Gregor021c3b32009-03-11 23:00:04 +00003955 diag::err_in_class_initializer_non_integral_type)
3956 << Init->getType() << Init->getSourceRange();
3957 VDecl->setInvalidDecl();
3958 } else if (!Init->isTypeDependent() && !Init->isValueDependent()) {
3959 // Check whether the expression is a constant expression.
3960 llvm::APSInt Value;
3961 SourceLocation Loc;
3962 if (!Init->isIntegerConstantExpr(Value, Context, &Loc)) {
3963 Diag(Loc, diag::err_in_class_initializer_non_constant)
3964 << Init->getSourceRange();
3965 VDecl->setInvalidDecl();
Douglas Gregor3d7a12a2009-03-25 23:32:15 +00003966 } else if (!VDecl->getType()->isDependentType())
Eli Friedman73c39ab2009-10-20 08:27:19 +00003967 ImpCastExprToType(Init, VDecl->getType(), CastExpr::CK_IntegralCast);
Douglas Gregor021c3b32009-03-11 23:00:04 +00003968 }
3969 }
Steve Naroff248a7532008-04-15 22:42:06 +00003970 } else if (VDecl->isFileVarDecl()) {
Douglas Gregor41b1d6b2010-04-19 21:31:25 +00003971 if (VDecl->getStorageClass() == VarDecl::Extern &&
Douglas Gregor66dd9392010-04-22 14:36:26 +00003972 (!getLangOptions().CPlusPlus ||
3973 !Context.getBaseElementType(VDecl->getType()).isConstQualified()))
Steve Naroff410e3e22007-09-12 20:13:48 +00003974 Diag(VDecl->getLocation(), diag::warn_extern_init);
Eli Friedmana91eb542009-12-22 02:10:53 +00003975 if (!VDecl->isInvalidDecl()) {
3976 InitializationSequence InitSeq(*this, Entity, Kind, &Init, 1);
3977 OwningExprResult Result = InitSeq.Perform(*this, Entity, Kind,
3978 MultiExprArg(*this, (void**)&Init, 1),
3979 &DclT);
3980 if (Result.isInvalid()) {
Steve Naroff248a7532008-04-15 22:42:06 +00003981 VDecl->setInvalidDecl();
Eli Friedmana91eb542009-12-22 02:10:53 +00003982 return;
3983 }
3984
3985 Init = Result.takeAs<Expr>();
3986 }
Mike Stump1eb44332009-09-09 15:08:12 +00003987
Anders Carlssonc5eb7312008-08-22 05:00:02 +00003988 // C++ 3.6.2p2, allow dynamic initialization of static initializers.
Eli Friedmanda153232009-02-20 01:34:21 +00003989 // Don't check invalid declarations to avoid emitting useless diagnostics.
3990 if (!getLangOptions().CPlusPlus && !VDecl->isInvalidDecl()) {
Anders Carlssonc5eb7312008-08-22 05:00:02 +00003991 // C99 6.7.8p4. All file scoped initializers need to be constant.
3992 CheckForConstantInitializer(Init, DclT);
3993 }
Steve Naroffbb204692007-09-12 14:07:44 +00003994 }
3995 // If the type changed, it means we had an incomplete type that was
Mike Stump1eb44332009-09-09 15:08:12 +00003996 // completed by the initializer. For example:
Steve Naroffbb204692007-09-12 14:07:44 +00003997 // int ary[] = { 1, 3, 5 };
3998 // "ary" transitions from a VariableArrayType to a ConstantArrayType.
Christopher Lamb48b12392007-11-29 19:09:19 +00003999 if (!VDecl->isInvalidDecl() && (DclT != SavT)) {
Steve Naroff410e3e22007-09-12 20:13:48 +00004000 VDecl->setType(DclT);
Christopher Lamb48b12392007-11-29 19:09:19 +00004001 Init->setType(DclT);
4002 }
Mike Stump1eb44332009-09-09 15:08:12 +00004003
Anders Carlsson0ece4912009-12-15 20:51:39 +00004004 Init = MaybeCreateCXXExprWithTemporaries(Init);
Steve Naroffbb204692007-09-12 14:07:44 +00004005 // Attach the initializer to the decl.
Douglas Gregor838db382010-02-11 01:19:42 +00004006 VDecl->setInit(Init);
Douglas Gregorb6c8c8b2009-04-21 17:11:58 +00004007
Eli Friedmandd4e4852009-12-20 22:29:11 +00004008 if (getLangOptions().CPlusPlus) {
4009 // Make sure we mark the destructor as used if necessary.
4010 QualType InitType = VDecl->getType();
Douglas Gregorbd6d6192010-01-05 19:06:31 +00004011 while (const ArrayType *Array = Context.getAsArrayType(InitType))
Eli Friedmandd4e4852009-12-20 22:29:11 +00004012 InitType = Context.getBaseElementType(Array);
John McCall68c6c9a2010-02-02 09:10:11 +00004013 if (const RecordType *Record = InitType->getAs<RecordType>())
4014 FinalizeVarWithDestructor(VDecl, Record);
Eli Friedmandd4e4852009-12-20 22:29:11 +00004015 }
4016
Steve Naroffbb204692007-09-12 14:07:44 +00004017 return;
4018}
4019
John McCall7727acf2010-03-31 02:13:20 +00004020/// ActOnInitializerError - Given that there was an error parsing an
4021/// initializer for the given declaration, try to return to some form
4022/// of sanity.
4023void Sema::ActOnInitializerError(DeclPtrTy dcl) {
4024 // Our main concern here is re-establishing invariants like "a
4025 // variable's type is either dependent or complete".
4026 Decl *D = dcl.getAs<Decl>();
4027 if (!D || D->isInvalidDecl()) return;
4028
4029 VarDecl *VD = dyn_cast<VarDecl>(D);
4030 if (!VD) return;
4031
4032 QualType Ty = VD->getType();
4033 if (Ty->isDependentType()) return;
4034
4035 // Require a complete type.
4036 if (RequireCompleteType(VD->getLocation(),
4037 Context.getBaseElementType(Ty),
4038 diag::err_typecheck_decl_incomplete_type)) {
4039 VD->setInvalidDecl();
4040 return;
4041 }
4042
4043 // Require an abstract type.
4044 if (RequireNonAbstractType(VD->getLocation(), Ty,
4045 diag::err_abstract_type_in_decl,
4046 AbstractVariableType)) {
4047 VD->setInvalidDecl();
4048 return;
4049 }
4050
4051 // Don't bother complaining about constructors or destructors,
4052 // though.
4053}
4054
Mike Stump1eb44332009-09-09 15:08:12 +00004055void Sema::ActOnUninitializedDecl(DeclPtrTy dcl,
Anders Carlsson6a75cd92009-07-11 00:34:39 +00004056 bool TypeContainsUndeducedAuto) {
Chris Lattnerb28317a2009-03-28 19:18:32 +00004057 Decl *RealDecl = dcl.getAs<Decl>();
Douglas Gregor27c8dc02008-10-29 00:13:59 +00004058
Argyrios Kyrtzidis48c2e902008-11-07 13:01:22 +00004059 // If there is no declaration, there was an error parsing it. Just ignore it.
4060 if (RealDecl == 0)
4061 return;
4062
Douglas Gregor27c8dc02008-10-29 00:13:59 +00004063 if (VarDecl *Var = dyn_cast<VarDecl>(RealDecl)) {
4064 QualType Type = Var->getType();
Douglas Gregorb6c8c8b2009-04-21 17:11:58 +00004065
Anders Carlsson6a75cd92009-07-11 00:34:39 +00004066 // C++0x [dcl.spec.auto]p3
4067 if (TypeContainsUndeducedAuto) {
4068 Diag(Var->getLocation(), diag::err_auto_var_requires_init)
4069 << Var->getDeclName() << Type;
4070 Var->setInvalidDecl();
4071 return;
4072 }
Mike Stump1eb44332009-09-09 15:08:12 +00004073
Douglas Gregor60c93c92010-02-09 07:26:29 +00004074 switch (Var->isThisDeclarationADefinition()) {
4075 case VarDecl::Definition:
4076 if (!Var->isStaticDataMember() || !Var->getAnyInitializer())
4077 break;
4078
4079 // We have an out-of-line definition of a static data member
4080 // that has an in-class initializer, so we type-check this like
4081 // a declaration.
4082 //
4083 // Fall through
4084
4085 case VarDecl::DeclarationOnly:
4086 // It's only a declaration.
4087
4088 // Block scope. C99 6.7p7: If an identifier for an object is
4089 // declared with no linkage (C99 6.2.2p6), the type for the
4090 // object shall be complete.
4091 if (!Type->isDependentType() && Var->isBlockVarDecl() &&
4092 !Var->getLinkage() && !Var->isInvalidDecl() &&
4093 RequireCompleteType(Var->getLocation(), Type,
4094 diag::err_typecheck_decl_incomplete_type))
4095 Var->setInvalidDecl();
4096
4097 // Make sure that the type is not abstract.
4098 if (!Type->isDependentType() && !Var->isInvalidDecl() &&
4099 RequireNonAbstractType(Var->getLocation(), Type,
4100 diag::err_abstract_type_in_decl,
4101 AbstractVariableType))
4102 Var->setInvalidDecl();
4103 return;
4104
4105 case VarDecl::TentativeDefinition:
4106 // File scope. C99 6.9.2p2: A declaration of an identifier for an
4107 // object that has file scope without an initializer, and without a
4108 // storage-class specifier or with the storage-class specifier "static",
4109 // constitutes a tentative definition. Note: A tentative definition with
4110 // external linkage is valid (C99 6.2.2p5).
4111 if (!Var->isInvalidDecl()) {
4112 if (const IncompleteArrayType *ArrayT
4113 = Context.getAsIncompleteArrayType(Type)) {
4114 if (RequireCompleteType(Var->getLocation(),
4115 ArrayT->getElementType(),
4116 diag::err_illegal_decl_array_incomplete_type))
4117 Var->setInvalidDecl();
4118 } else if (Var->getStorageClass() == VarDecl::Static) {
4119 // C99 6.9.2p3: If the declaration of an identifier for an object is
4120 // a tentative definition and has internal linkage (C99 6.2.2p3), the
4121 // declared type shall not be an incomplete type.
4122 // NOTE: code such as the following
4123 // static struct s;
4124 // struct s { int a; };
4125 // is accepted by gcc. Hence here we issue a warning instead of
4126 // an error and we do not invalidate the static declaration.
4127 // NOTE: to avoid multiple warnings, only check the first declaration.
4128 if (Var->getPreviousDeclaration() == 0)
4129 RequireCompleteType(Var->getLocation(), Type,
4130 diag::ext_typecheck_decl_incomplete_type);
4131 }
4132 }
4133
4134 // Record the tentative definition; we're done.
4135 if (!Var->isInvalidDecl())
4136 TentativeDefinitions.push_back(Var);
4137 return;
4138 }
4139
4140 // Provide a specific diagnostic for uninitialized variable
4141 // definitions with incomplete array type.
4142 if (Type->isIncompleteArrayType()) {
Sebastian Redl6e824752009-11-05 19:47:47 +00004143 Diag(Var->getLocation(),
4144 diag::err_typecheck_incomplete_array_needs_initializer);
4145 Var->setInvalidDecl();
4146 return;
4147 }
4148
Douglas Gregor60c93c92010-02-09 07:26:29 +00004149 // Provide a specific diagnostic for uninitialized variable
4150 // definitions with reference type.
4151 if (Type->isReferenceType()) {
4152 Diag(Var->getLocation(), diag::err_reference_var_requires_init)
4153 << Var->getDeclName()
4154 << SourceRange(Var->getLocation(), Var->getLocation());
4155 Var->setInvalidDecl();
4156 return;
4157 }
4158
4159 // Do not attempt to type-check the default initializer for a
4160 // variable with dependent type.
4161 if (Type->isDependentType())
Douglas Gregor251b4ff2009-10-08 07:24:58 +00004162 return;
Douglas Gregor39da0b82009-09-09 23:08:42 +00004163
Douglas Gregor60c93c92010-02-09 07:26:29 +00004164 if (Var->isInvalidDecl())
4165 return;
Douglas Gregor1ab537b2009-12-03 18:33:45 +00004166
Douglas Gregor60c93c92010-02-09 07:26:29 +00004167 if (RequireCompleteType(Var->getLocation(),
4168 Context.getBaseElementType(Type),
4169 diag::err_typecheck_decl_incomplete_type)) {
4170 Var->setInvalidDecl();
4171 return;
Douglas Gregor18fe5682008-11-03 20:45:27 +00004172 }
Douglas Gregor27c8dc02008-10-29 00:13:59 +00004173
Douglas Gregor60c93c92010-02-09 07:26:29 +00004174 // The variable can not have an abstract class type.
4175 if (RequireNonAbstractType(Var->getLocation(), Type,
4176 diag::err_abstract_type_in_decl,
4177 AbstractVariableType)) {
4178 Var->setInvalidDecl();
4179 return;
4180 }
4181
Douglas Gregor516a6bc2010-03-08 02:45:10 +00004182 const RecordType *Record
4183 = Context.getBaseElementType(Type)->getAs<RecordType>();
4184 if (Record && getLangOptions().CPlusPlus && !getLangOptions().CPlusPlus0x &&
4185 cast<CXXRecordDecl>(Record->getDecl())->isPOD()) {
4186 // C++03 [dcl.init]p9:
4187 // If no initializer is specified for an object, and the
4188 // object is of (possibly cv-qualified) non-POD class type (or
4189 // array thereof), the object shall be default-initialized; if
4190 // the object is of const-qualified type, the underlying class
4191 // type shall have a user-declared default
4192 // constructor. Otherwise, if no initializer is specified for
4193 // a non- static object, the object and its subobjects, if
4194 // any, have an indeterminate initial value); if the object
4195 // or any of its subobjects are of const-qualified type, the
4196 // program is ill-formed.
4197 // FIXME: DPG thinks it is very fishy that C++0x disables this.
4198 } else {
4199 InitializedEntity Entity = InitializedEntity::InitializeVariable(Var);
4200 InitializationKind Kind
4201 = InitializationKind::CreateDefault(Var->getLocation());
Douglas Gregor60c93c92010-02-09 07:26:29 +00004202
Douglas Gregor516a6bc2010-03-08 02:45:10 +00004203 InitializationSequence InitSeq(*this, Entity, Kind, 0, 0);
4204 OwningExprResult Init = InitSeq.Perform(*this, Entity, Kind,
4205 MultiExprArg(*this, 0, 0));
4206 if (Init.isInvalid())
4207 Var->setInvalidDecl();
4208 else if (Init.get())
Douglas Gregor838db382010-02-11 01:19:42 +00004209 Var->setInit(MaybeCreateCXXExprWithTemporaries(Init.takeAs<Expr>()));
Douglas Gregor60c93c92010-02-09 07:26:29 +00004210 }
Douglas Gregor516a6bc2010-03-08 02:45:10 +00004211
4212 if (!Var->isInvalidDecl() && getLangOptions().CPlusPlus && Record)
4213 FinalizeVarWithDestructor(Var, Record);
Douglas Gregor27c8dc02008-10-29 00:13:59 +00004214 }
4215}
4216
Eli Friedmanc1dc6532009-05-29 01:49:24 +00004217Sema::DeclGroupPtrTy Sema::FinalizeDeclaratorGroup(Scope *S, const DeclSpec &DS,
4218 DeclPtrTy *Group,
Chris Lattner682bf922009-03-29 16:50:03 +00004219 unsigned NumDecls) {
4220 llvm::SmallVector<Decl*, 8> Decls;
Eli Friedmanc1dc6532009-05-29 01:49:24 +00004221
4222 if (DS.isTypeSpecOwned())
4223 Decls.push_back((Decl*)DS.getTypeRep());
4224
Chris Lattner682bf922009-03-29 16:50:03 +00004225 for (unsigned i = 0; i != NumDecls; ++i)
4226 if (Decl *D = Group[i].getAs<Decl>())
4227 Decls.push_back(D);
Mike Stump1eb44332009-09-09 15:08:12 +00004228
Chris Lattner682bf922009-03-29 16:50:03 +00004229 return DeclGroupPtrTy::make(DeclGroupRef::Create(Context,
Jay Foadbeaaccd2009-05-21 09:52:38 +00004230 Decls.data(), Decls.size()));
Reid Spencer5f016e22007-07-11 17:01:13 +00004231}
Steve Naroffe1223f72007-08-28 03:03:08 +00004232
Chris Lattner682bf922009-03-29 16:50:03 +00004233
Chris Lattner04421082008-04-08 04:40:51 +00004234/// ActOnParamDeclarator - Called from Parser::ParseFunctionDeclarator()
4235/// to introduce parameters into function prototype scope.
Mike Stump1eb44332009-09-09 15:08:12 +00004236Sema::DeclPtrTy
Chris Lattner04421082008-04-08 04:40:51 +00004237Sema::ActOnParamDeclarator(Scope *S, Declarator &D) {
Chris Lattner985abd92008-06-26 06:49:43 +00004238 const DeclSpec &DS = D.getDeclSpec();
Douglas Gregor584049d2008-12-15 23:53:10 +00004239
Chris Lattner04421082008-04-08 04:40:51 +00004240 // Verify C99 6.7.5.3p2: The only SCS allowed is 'register'.
Daniel Dunbar33ad0122008-09-03 21:54:21 +00004241 VarDecl::StorageClass StorageClass = VarDecl::None;
Douglas Gregor16573fa2010-04-19 22:54:31 +00004242 VarDecl::StorageClass StorageClassAsWritten = VarDecl::None;
Daniel Dunbar33ad0122008-09-03 21:54:21 +00004243 if (DS.getStorageClassSpec() == DeclSpec::SCS_register) {
4244 StorageClass = VarDecl::Register;
Douglas Gregor16573fa2010-04-19 22:54:31 +00004245 StorageClassAsWritten = VarDecl::Register;
Daniel Dunbar33ad0122008-09-03 21:54:21 +00004246 } else if (DS.getStorageClassSpec() != DeclSpec::SCS_unspecified) {
Chris Lattner04421082008-04-08 04:40:51 +00004247 Diag(DS.getStorageClassSpecLoc(),
4248 diag::err_invalid_storage_class_in_func_decl);
Chris Lattner985abd92008-06-26 06:49:43 +00004249 D.getMutableDeclSpec().ClearStorageClassSpecs();
Chris Lattner04421082008-04-08 04:40:51 +00004250 }
Eli Friedman63054b32009-04-19 20:27:55 +00004251
4252 if (D.getDeclSpec().isThreadSpecified())
4253 Diag(D.getDeclSpec().getThreadSpecLoc(), diag::err_invalid_thread);
4254
Eli Friedman85a53192009-04-07 19:37:57 +00004255 DiagnoseFunctionSpecifiers(D);
4256
Douglas Gregor6d6eb572008-05-07 04:49:29 +00004257 // Check that there are no default arguments inside the type of this
4258 // parameter (C++ only).
4259 if (getLangOptions().CPlusPlus)
4260 CheckExtraCXXDefaultArguments(D);
Mike Stump1eb44332009-09-09 15:08:12 +00004261
Douglas Gregor402abb52009-05-28 23:31:59 +00004262 TagDecl *OwnedDecl = 0;
John McCallbf1a0282010-06-04 23:28:52 +00004263 TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S, &OwnedDecl);
4264 QualType parmDeclType = TInfo->getType();
Mike Stump1eb44332009-09-09 15:08:12 +00004265
Douglas Gregor402abb52009-05-28 23:31:59 +00004266 if (getLangOptions().CPlusPlus && OwnedDecl && OwnedDecl->isDefinition()) {
4267 // C++ [dcl.fct]p6:
4268 // Types shall not be defined in return or parameter types.
4269 Diag(OwnedDecl->getLocation(), diag::err_type_defined_in_param_type)
4270 << Context.getTypeDeclType(OwnedDecl);
4271 }
4272
Chris Lattnerd84aac12010-02-22 00:40:25 +00004273 // Check for redeclaration of parameters, e.g. int foo(int x, int x);
Chris Lattner04421082008-04-08 04:40:51 +00004274 IdentifierInfo *II = D.getIdentifier();
Chris Lattnercf79b012009-01-21 02:38:50 +00004275 if (II) {
John McCall10f28732010-03-18 06:42:38 +00004276 LookupResult R(*this, II, D.getIdentifierLoc(), LookupOrdinaryName,
4277 ForRedeclaration);
4278 LookupName(R, S);
4279 if (R.isSingleResult()) {
4280 NamedDecl *PrevDecl = R.getFoundDecl();
Chris Lattnercf79b012009-01-21 02:38:50 +00004281 if (PrevDecl->isTemplateParameter()) {
4282 // Maybe we will complain about the shadowed template parameter.
4283 DiagnoseTemplateParameterShadow(D.getIdentifierLoc(), PrevDecl);
4284 // Just pretend that we didn't see the previous declaration.
4285 PrevDecl = 0;
Chris Lattnerb28317a2009-03-28 19:18:32 +00004286 } else if (S->isDeclScope(DeclPtrTy::make(PrevDecl))) {
Chris Lattnercf79b012009-01-21 02:38:50 +00004287 Diag(D.getIdentifierLoc(), diag::err_param_redefinition) << II;
Chris Lattnerd84aac12010-02-22 00:40:25 +00004288 Diag(PrevDecl->getLocation(), diag::note_previous_declaration);
Chris Lattner04421082008-04-08 04:40:51 +00004289
Chris Lattnercf79b012009-01-21 02:38:50 +00004290 // Recover by removing the name
4291 II = 0;
4292 D.SetIdentifier(0, D.getIdentifierLoc());
Fariborz Jahanian9a66c302010-02-12 21:53:14 +00004293 D.setInvalidType(true);
Chris Lattnercf79b012009-01-21 02:38:50 +00004294 }
Chris Lattner04421082008-04-08 04:40:51 +00004295 }
Reid Spencer5f016e22007-07-11 17:01:13 +00004296 }
Steve Naroff6a9f3e32007-08-07 22:44:21 +00004297
John McCall7a9813c2010-01-22 00:28:27 +00004298 // Temporarily put parameter variables in the translation unit, not
4299 // the enclosing context. This prevents them from accidentally
4300 // looking like class members in C++.
Douglas Gregorcb27b0f2010-04-12 07:48:19 +00004301 ParmVarDecl *New = CheckParameter(Context.getTranslationUnitDecl(),
4302 TInfo, parmDeclType, II,
Douglas Gregor16573fa2010-04-19 22:54:31 +00004303 D.getIdentifierLoc(),
4304 StorageClass, StorageClassAsWritten);
Mike Stump1eb44332009-09-09 15:08:12 +00004305
Chris Lattnereaaebc72009-04-25 08:06:05 +00004306 if (D.isInvalidType())
Douglas Gregorcb27b0f2010-04-12 07:48:19 +00004307 New->setInvalidDecl();
4308
Chris Lattnerf97e8fa2009-04-11 19:34:56 +00004309 // Parameter declarators cannot be qualified (C++ [dcl.meaning]p1).
4310 if (D.getCXXScopeSpec().isSet()) {
4311 Diag(D.getIdentifierLoc(), diag::err_qualified_param_declarator)
4312 << D.getCXXScopeSpec().getRange();
4313 New->setInvalidDecl();
4314 }
Douglas Gregorcb27b0f2010-04-12 07:48:19 +00004315
Douglas Gregor44b43212008-12-11 16:49:14 +00004316 // Add the parameter declaration into this scope.
Chris Lattnerb28317a2009-03-28 19:18:32 +00004317 S->AddDecl(DeclPtrTy::make(New));
Argyrios Kyrtzidis87f3ff02008-04-12 00:47:19 +00004318 if (II)
Douglas Gregor44b43212008-12-11 16:49:14 +00004319 IdResolver.AddDecl(New);
Nate Begemanb7894b52008-02-17 21:20:31 +00004320
Douglas Gregor9cdda0c2009-06-17 21:51:59 +00004321 ProcessDeclAttributes(S, New, D);
Mike Stumpea000bf2009-04-30 00:19:40 +00004322
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +00004323 if (New->hasAttr<BlocksAttr>()) {
Mike Stumpea000bf2009-04-30 00:19:40 +00004324 Diag(New->getLocation(), diag::err_block_on_nonlocal);
4325 }
Chris Lattnerb28317a2009-03-28 19:18:32 +00004326 return DeclPtrTy::make(New);
Reid Spencer5f016e22007-07-11 17:01:13 +00004327}
Fariborz Jahanian306d68f2007-11-08 23:49:49 +00004328
John McCall82dc0092010-06-04 11:21:44 +00004329/// \brief Synthesizes a variable for a parameter arising from a
4330/// typedef.
4331ParmVarDecl *Sema::BuildParmVarDeclForTypedef(DeclContext *DC,
4332 SourceLocation Loc,
4333 QualType T) {
4334 ParmVarDecl *Param = ParmVarDecl::Create(Context, DC, Loc, 0,
4335 T, Context.getTrivialTypeSourceInfo(T, Loc),
4336 VarDecl::None, VarDecl::None, 0);
4337 Param->setImplicit();
4338 return Param;
4339}
4340
Douglas Gregorcb27b0f2010-04-12 07:48:19 +00004341ParmVarDecl *Sema::CheckParameter(DeclContext *DC,
4342 TypeSourceInfo *TSInfo, QualType T,
4343 IdentifierInfo *Name,
4344 SourceLocation NameLoc,
Douglas Gregor16573fa2010-04-19 22:54:31 +00004345 VarDecl::StorageClass StorageClass,
4346 VarDecl::StorageClass StorageClassAsWritten) {
Douglas Gregorcb27b0f2010-04-12 07:48:19 +00004347 ParmVarDecl *New = ParmVarDecl::Create(Context, DC, NameLoc, Name,
4348 adjustParameterType(T), TSInfo,
Douglas Gregor16573fa2010-04-19 22:54:31 +00004349 StorageClass, StorageClassAsWritten,
4350 0);
Douglas Gregorcb27b0f2010-04-12 07:48:19 +00004351
4352 // Parameters can not be abstract class types.
4353 // For record types, this is done by the AbstractClassUsageDiagnoser once
4354 // the class has been completely parsed.
4355 if (!CurContext->isRecord() &&
4356 RequireNonAbstractType(NameLoc, T, diag::err_abstract_type_in_decl,
4357 AbstractParamType))
4358 New->setInvalidDecl();
4359
4360 // Parameter declarators cannot be interface types. All ObjC objects are
4361 // passed by reference.
John McCallc12c5bb2010-05-15 11:32:37 +00004362 if (T->isObjCObjectType()) {
Douglas Gregorcb27b0f2010-04-12 07:48:19 +00004363 Diag(NameLoc,
4364 diag::err_object_cannot_be_passed_returned_by_value) << 1 << T;
4365 New->setInvalidDecl();
4366 }
4367
4368 // ISO/IEC TR 18037 S6.7.3: "The type of an object with automatic storage
4369 // duration shall not be qualified by an address-space qualifier."
4370 // Since all parameters have automatic store duration, they can not have
4371 // an address space.
4372 if (T.getAddressSpace() != 0) {
4373 Diag(NameLoc, diag::err_arg_with_address_space);
4374 New->setInvalidDecl();
4375 }
4376
4377 return New;
4378}
4379
Douglas Gregora3a83512009-04-01 23:51:29 +00004380void Sema::ActOnFinishKNRParamDeclarations(Scope *S, Declarator &D,
4381 SourceLocation LocAfterDecls) {
Reid Spencer5f016e22007-07-11 17:01:13 +00004382 assert(D.getTypeObject(0).Kind == DeclaratorChunk::Function &&
4383 "Not a function declarator!");
4384 DeclaratorChunk::FunctionTypeInfo &FTI = D.getTypeObject(0).Fun;
Chris Lattner04421082008-04-08 04:40:51 +00004385
Reid Spencer5f016e22007-07-11 17:01:13 +00004386 // Verify 6.9.1p6: 'every identifier in the identifier list shall be declared'
4387 // for a K&R function.
4388 if (!FTI.hasPrototype) {
Douglas Gregor26103482009-04-02 03:14:12 +00004389 for (int i = FTI.NumArgs; i != 0; /* decrement in loop */) {
4390 --i;
Chris Lattner04421082008-04-08 04:40:51 +00004391 if (FTI.ArgInfo[i].Param == 0) {
Daniel Dunbar5ffe14c2009-10-18 20:26:27 +00004392 llvm::SmallString<256> Code;
4393 llvm::raw_svector_ostream(Code) << " int "
Daniel Dunbar01eb9b92009-10-18 21:17:35 +00004394 << FTI.ArgInfo[i].Ident->getName()
Daniel Dunbar5ffe14c2009-10-18 20:26:27 +00004395 << ";\n";
Chris Lattner3c73c412008-11-19 08:23:25 +00004396 Diag(FTI.ArgInfo[i].IdentLoc, diag::ext_param_not_declared)
Douglas Gregora3a83512009-04-01 23:51:29 +00004397 << FTI.ArgInfo[i].Ident
Douglas Gregor849b2432010-03-31 17:46:05 +00004398 << FixItHint::CreateInsertion(LocAfterDecls, Code.str());
Douglas Gregora3a83512009-04-01 23:51:29 +00004399
Reid Spencer5f016e22007-07-11 17:01:13 +00004400 // Implicitly declare the argument as type 'int' for lack of a better
4401 // type.
Chris Lattner04421082008-04-08 04:40:51 +00004402 DeclSpec DS;
4403 const char* PrevSpec; // unused
John McCallfec54012009-08-03 20:12:06 +00004404 unsigned DiagID; // unused
Mike Stump1eb44332009-09-09 15:08:12 +00004405 DS.SetTypeSpecType(DeclSpec::TST_int, FTI.ArgInfo[i].IdentLoc,
John McCallfec54012009-08-03 20:12:06 +00004406 PrevSpec, DiagID);
Chris Lattner04421082008-04-08 04:40:51 +00004407 Declarator ParamD(DS, Declarator::KNRTypeListContext);
4408 ParamD.SetIdentifier(FTI.ArgInfo[i].Ident, FTI.ArgInfo[i].IdentLoc);
Douglas Gregorbe109b32009-01-23 16:23:13 +00004409 FTI.ArgInfo[i].Param = ActOnParamDeclarator(S, ParamD);
Reid Spencer5f016e22007-07-11 17:01:13 +00004410 }
4411 }
Mike Stump1eb44332009-09-09 15:08:12 +00004412 }
Douglas Gregorbe109b32009-01-23 16:23:13 +00004413}
4414
Chris Lattnerb28317a2009-03-28 19:18:32 +00004415Sema::DeclPtrTy Sema::ActOnStartOfFunctionDef(Scope *FnBodyScope,
4416 Declarator &D) {
Douglas Gregorbe109b32009-01-23 16:23:13 +00004417 assert(getCurFunctionDecl() == 0 && "Function parsing confused");
4418 assert(D.getTypeObject(0).Kind == DeclaratorChunk::Function &&
4419 "Not a function declarator!");
4420 DeclaratorChunk::FunctionTypeInfo &FTI = D.getTypeObject(0).Fun;
4421
4422 if (FTI.hasPrototype) {
Mike Stump1eb44332009-09-09 15:08:12 +00004423 // FIXME: Diagnose arguments without names in C.
Reid Spencer5f016e22007-07-11 17:01:13 +00004424 }
Mike Stump1eb44332009-09-09 15:08:12 +00004425
Douglas Gregor584049d2008-12-15 23:53:10 +00004426 Scope *ParentScope = FnBodyScope->getParent();
Steve Naroffadbbd0c2008-01-14 20:51:29 +00004427
Mike Stump1eb44332009-09-09 15:08:12 +00004428 DeclPtrTy DP = HandleDeclarator(ParentScope, D,
Douglas Gregore542c862009-06-23 23:11:28 +00004429 MultiTemplateParamsArg(*this),
4430 /*IsFunctionDefinition=*/true);
Chris Lattner682bf922009-03-29 16:50:03 +00004431 return ActOnStartOfFunctionDef(FnBodyScope, DP);
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +00004432}
4433
Anders Carlsson9f89dd72009-12-09 03:30:09 +00004434static bool ShouldWarnAboutMissingPrototype(const FunctionDecl *FD) {
4435 // Don't warn about invalid declarations.
4436 if (FD->isInvalidDecl())
4437 return false;
Anders Carlsson63fb6732009-12-09 03:44:46 +00004438
Anders Carlsson9f89dd72009-12-09 03:30:09 +00004439 // Or declarations that aren't global.
4440 if (!FD->isGlobal())
4441 return false;
Anders Carlsson63fb6732009-12-09 03:44:46 +00004442
Anders Carlsson9f89dd72009-12-09 03:30:09 +00004443 // Don't warn about C++ member functions.
4444 if (isa<CXXMethodDecl>(FD))
4445 return false;
Anders Carlsson63fb6732009-12-09 03:44:46 +00004446
Anders Carlsson9f89dd72009-12-09 03:30:09 +00004447 // Don't warn about 'main'.
4448 if (FD->isMain())
4449 return false;
Anders Carlsson63fb6732009-12-09 03:44:46 +00004450
Anders Carlsson9f89dd72009-12-09 03:30:09 +00004451 // Don't warn about inline functions.
4452 if (FD->isInlineSpecified())
4453 return false;
Anders Carlsson63fb6732009-12-09 03:44:46 +00004454
4455 // Don't warn about function templates.
4456 if (FD->getDescribedFunctionTemplate())
4457 return false;
4458
4459 // Don't warn about function template specializations.
4460 if (FD->isFunctionTemplateSpecialization())
4461 return false;
4462
Anders Carlsson9f89dd72009-12-09 03:30:09 +00004463 bool MissingPrototype = true;
4464 for (const FunctionDecl *Prev = FD->getPreviousDeclaration();
4465 Prev; Prev = Prev->getPreviousDeclaration()) {
4466 // Ignore any declarations that occur in function or method
4467 // scope, because they aren't visible from the header.
4468 if (Prev->getDeclContext()->isFunctionOrMethod())
4469 continue;
4470
4471 MissingPrototype = !Prev->getType()->isFunctionProtoType();
4472 break;
4473 }
4474
4475 return MissingPrototype;
4476}
4477
Chris Lattnerb28317a2009-03-28 19:18:32 +00004478Sema::DeclPtrTy Sema::ActOnStartOfFunctionDef(Scope *FnBodyScope, DeclPtrTy D) {
Anders Carlsson0ebb6d32009-10-29 15:46:07 +00004479 // Clear the last template instantiation error context.
4480 LastTemplateInstantiationErrorContext = ActiveTemplateInstantiation();
4481
Douglas Gregor52591bf2009-06-24 00:54:41 +00004482 if (!D)
4483 return D;
Douglas Gregord83d0402009-08-22 00:34:47 +00004484 FunctionDecl *FD = 0;
Mike Stump1eb44332009-09-09 15:08:12 +00004485
4486 if (FunctionTemplateDecl *FunTmpl
Douglas Gregord83d0402009-08-22 00:34:47 +00004487 = dyn_cast<FunctionTemplateDecl>(D.getAs<Decl>()))
4488 FD = FunTmpl->getTemplatedDecl();
4489 else
4490 FD = cast<FunctionDecl>(D.getAs<Decl>());
Douglas Gregor6fc17ff2008-10-29 15:10:40 +00004491
Douglas Gregor9ea9bdb2010-03-01 23:15:13 +00004492 // Enter a new function scope
4493 PushFunctionScope();
Mike Stump1eb44332009-09-09 15:08:12 +00004494
Douglas Gregor6fc17ff2008-10-29 15:10:40 +00004495 // See if this is a redefinition.
Charles Davisf3f8d2a2010-02-18 02:00:42 +00004496 // But don't complain if we're in GNU89 mode and the previous definition
4497 // was an extern inline function.
Douglas Gregor6fc17ff2008-10-29 15:10:40 +00004498 const FunctionDecl *Definition;
Charles Davisf3f8d2a2010-02-18 02:00:42 +00004499 if (FD->getBody(Definition) &&
4500 !canRedefineFunction(Definition, getLangOptions())) {
Chris Lattner08631c52008-11-23 21:45:46 +00004501 Diag(FD->getLocation(), diag::err_redefinition) << FD->getDeclName();
Chris Lattner5f4a6822008-11-23 23:12:31 +00004502 Diag(Definition->getLocation(), diag::note_previous_definition);
Douglas Gregor6fc17ff2008-10-29 15:10:40 +00004503 }
4504
Douglas Gregorcda9c672009-02-16 17:45:42 +00004505 // Builtin functions cannot be defined.
Douglas Gregor7814e6d2009-09-12 00:22:50 +00004506 if (unsigned BuiltinID = FD->getBuiltinID()) {
Douglas Gregor655753a2009-02-17 16:03:01 +00004507 if (!Context.BuiltinInfo.isPredefinedLibFunction(BuiltinID)) {
Douglas Gregorcda9c672009-02-16 17:45:42 +00004508 Diag(FD->getLocation(), diag::err_builtin_definition) << FD;
Douglas Gregor655753a2009-02-17 16:03:01 +00004509 FD->setInvalidDecl();
4510 }
Douglas Gregorcda9c672009-02-16 17:45:42 +00004511 }
4512
Eli Friedman7f0f5dc2009-03-04 07:30:59 +00004513 // The return type of a function definition must be complete
Douglas Gregore7450f52009-03-24 19:52:54 +00004514 // (C99 6.9.1p3, C++ [dcl.fct]p6).
4515 QualType ResultType = FD->getResultType();
4516 if (!ResultType->isDependentType() && !ResultType->isVoidType() &&
Chris Lattner65e6a092009-04-29 05:12:23 +00004517 !FD->isInvalidDecl() &&
Douglas Gregore7450f52009-03-24 19:52:54 +00004518 RequireCompleteType(FD->getLocation(), ResultType,
4519 diag::err_func_def_incomplete_result))
Eli Friedman7f0f5dc2009-03-04 07:30:59 +00004520 FD->setInvalidDecl();
Eli Friedman7f0f5dc2009-03-04 07:30:59 +00004521
Douglas Gregor8499f3f2009-03-31 16:35:03 +00004522 // GNU warning -Wmissing-prototypes:
4523 // Warn if a global function is defined without a previous
4524 // prototype declaration. This warning is issued even if the
4525 // definition itself provides a prototype. The aim is to detect
4526 // global functions that fail to be declared in header files.
Anders Carlsson9f89dd72009-12-09 03:30:09 +00004527 if (ShouldWarnAboutMissingPrototype(FD))
4528 Diag(FD->getLocation(), diag::warn_missing_prototype) << FD;
Douglas Gregor8499f3f2009-03-31 16:35:03 +00004529
Douglas Gregore2c31ff2009-05-15 17:59:04 +00004530 if (FnBodyScope)
4531 PushDeclContext(FnBodyScope, FD);
Anton Korobeynikov2f402702008-12-26 00:52:02 +00004532
Chris Lattner04421082008-04-08 04:40:51 +00004533 // Check the validity of our function parameters
4534 CheckParmsForFunctionDef(FD);
4535
John McCall053f4bd2010-03-22 09:20:08 +00004536 bool ShouldCheckShadow =
4537 Diags.getDiagnosticLevel(diag::warn_decl_shadow) != Diagnostic::Ignored;
4538
Chris Lattner04421082008-04-08 04:40:51 +00004539 // Introduce our parameters into the function scope
4540 for (unsigned p = 0, NumParams = FD->getNumParams(); p < NumParams; ++p) {
4541 ParmVarDecl *Param = FD->getParamDecl(p);
Douglas Gregora8cc8ce2009-01-09 18:51:29 +00004542 Param->setOwningFunction(FD);
4543
Chris Lattner04421082008-04-08 04:40:51 +00004544 // If this has an identifier, add it to the scope stack.
John McCall053f4bd2010-03-22 09:20:08 +00004545 if (Param->getIdentifier() && FnBodyScope) {
4546 if (ShouldCheckShadow)
4547 CheckShadow(FnBodyScope, Param);
4548
Argyrios Kyrtzidis87f3ff02008-04-12 00:47:19 +00004549 PushOnScopeChains(Param, FnBodyScope);
John McCall053f4bd2010-03-22 09:20:08 +00004550 }
Reid Spencer5f016e22007-07-11 17:01:13 +00004551 }
Chris Lattner04421082008-04-08 04:40:51 +00004552
Anton Korobeynikov2f402702008-12-26 00:52:02 +00004553 // Checking attributes of current function definition
4554 // dllimport attribute.
Mike Stump1eb44332009-09-09 15:08:12 +00004555 if (FD->getAttr<DLLImportAttr>() &&
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +00004556 (!FD->getAttr<DLLExportAttr>())) {
Anton Korobeynikov2f402702008-12-26 00:52:02 +00004557 // dllimport attribute cannot be applied to definition.
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +00004558 if (!(FD->getAttr<DLLImportAttr>())->isInherited()) {
Anton Korobeynikov2f402702008-12-26 00:52:02 +00004559 Diag(FD->getLocation(),
4560 diag::err_attribute_can_be_applied_only_to_symbol_declaration)
4561 << "dllimport";
4562 FD->setInvalidDecl();
Chris Lattnerb28317a2009-03-28 19:18:32 +00004563 return DeclPtrTy::make(FD);
Ted Kremenek12911a82010-02-21 05:12:53 +00004564 }
4565
4566 // Visual C++ appears to not think this is an issue, so only issue
4567 // a warning when Microsoft extensions are disabled.
4568 if (!LangOpts.Microsoft) {
Anton Korobeynikov2f402702008-12-26 00:52:02 +00004569 // If a symbol previously declared dllimport is later defined, the
4570 // attribute is ignored in subsequent references, and a warning is
4571 // emitted.
4572 Diag(FD->getLocation(),
4573 diag::warn_redeclaration_without_attribute_prev_attribute_ignored)
4574 << FD->getNameAsCString() << "dllimport";
4575 }
4576 }
Chris Lattnerb28317a2009-03-28 19:18:32 +00004577 return DeclPtrTy::make(FD);
Reid Spencer5f016e22007-07-11 17:01:13 +00004578}
4579
Douglas Gregor5077c382010-05-15 06:01:05 +00004580/// \brief Given the set of return statements within a function body,
4581/// compute the variables that are subject to the named return value
4582/// optimization.
4583///
4584/// Each of the variables that is subject to the named return value
4585/// optimization will be marked as NRVO variables in the AST, and any
4586/// return statement that has a marked NRVO variable as its NRVO candidate can
4587/// use the named return value optimization.
4588///
4589/// This function applies a very simplistic algorithm for NRVO: if every return
4590/// statement in the function has the same NRVO candidate, that candidate is
4591/// the NRVO variable.
4592///
4593/// FIXME: Employ a smarter algorithm that accounts for multiple return
4594/// statements and the lifetimes of the NRVO candidates. We should be able to
4595/// find a maximal set of NRVO variables.
4596static void ComputeNRVO(Stmt *Body, ReturnStmt **Returns, unsigned NumReturns) {
4597 const VarDecl *NRVOCandidate = 0;
4598 for (unsigned I = 0; I != NumReturns; ++I) {
4599 if (!Returns[I]->getNRVOCandidate())
4600 return;
4601
4602 if (!NRVOCandidate)
4603 NRVOCandidate = Returns[I]->getNRVOCandidate();
4604 else if (NRVOCandidate != Returns[I]->getNRVOCandidate())
4605 return;
4606 }
4607
4608 if (NRVOCandidate)
4609 const_cast<VarDecl*>(NRVOCandidate)->setNRVOVariable(true);
4610}
4611
Chris Lattnerb28317a2009-03-28 19:18:32 +00004612Sema::DeclPtrTy Sema::ActOnFinishFunctionBody(DeclPtrTy D, StmtArg BodyArg) {
Douglas Gregore2c31ff2009-05-15 17:59:04 +00004613 return ActOnFinishFunctionBody(D, move(BodyArg), false);
4614}
4615
4616Sema::DeclPtrTy Sema::ActOnFinishFunctionBody(DeclPtrTy D, StmtArg BodyArg,
4617 bool IsInstantiation) {
Chris Lattnerb28317a2009-03-28 19:18:32 +00004618 Decl *dcl = D.getAs<Decl>();
Sebastian Redld3a413d2009-04-26 20:35:05 +00004619 Stmt *Body = BodyArg.takeAs<Stmt>();
Douglas Gregord83d0402009-08-22 00:34:47 +00004620
4621 FunctionDecl *FD = 0;
4622 FunctionTemplateDecl *FunTmpl = dyn_cast_or_null<FunctionTemplateDecl>(dcl);
4623 if (FunTmpl)
4624 FD = FunTmpl->getTemplatedDecl();
4625 else
4626 FD = dyn_cast_or_null<FunctionDecl>(dcl);
4627
Ted Kremenekd064fdc2010-03-23 00:13:23 +00004628 sema::AnalysisBasedWarnings::Policy WP = AnalysisWarnings.getDefaultPolicy();
Ted Kremenekdbdbaaf2010-03-20 21:06:02 +00004629
Douglas Gregord83d0402009-08-22 00:34:47 +00004630 if (FD) {
Chris Lattnera5251fc2009-04-18 09:36:27 +00004631 FD->setBody(Body);
Ted Kremenekdbdbaaf2010-03-20 21:06:02 +00004632 if (FD->isMain()) {
Mike Stump5f28a1e2009-07-24 02:49:01 +00004633 // C and C++ allow for main to automagically return 0.
John McCall0cfeb632009-07-28 01:00:58 +00004634 // Implements C++ [basic.start.main]p5 and C99 5.1.2.2.3.
4635 FD->setHasImplicitReturnZero(true);
Ted Kremenekd064fdc2010-03-23 00:13:23 +00004636 WP.disableCheckFallThrough();
Ted Kremenekdbdbaaf2010-03-20 21:06:02 +00004637 }
Mike Stump1eb44332009-09-09 15:08:12 +00004638
Douglas Gregor6fb745b2010-05-13 16:44:06 +00004639 if (!FD->isInvalidDecl()) {
Douglas Gregore0762c92009-06-19 23:52:42 +00004640 DiagnoseUnusedParameters(FD->param_begin(), FD->param_end());
Douglas Gregor6fb745b2010-05-13 16:44:06 +00004641
4642 // If this is a constructor, we need a vtable.
4643 if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(FD))
4644 MarkVTableUsed(FD->getLocation(), Constructor->getParent());
Douglas Gregor5077c382010-05-15 06:01:05 +00004645
4646 ComputeNRVO(Body, FunctionScopes.back()->Returns.data(),
4647 FunctionScopes.back()->Returns.size());
Douglas Gregor6fb745b2010-05-13 16:44:06 +00004648 }
4649
Argyrios Kyrtzidis53d0ea52008-06-28 06:07:14 +00004650 assert(FD == getCurFunctionDecl() && "Function parsing confused");
Steve Naroff394f3f42008-07-25 17:57:26 +00004651 } else if (ObjCMethodDecl *MD = dyn_cast_or_null<ObjCMethodDecl>(dcl)) {
Chris Lattnerffed1632009-02-16 19:27:54 +00004652 assert(MD == getCurMethodDecl() && "Method parsing confused");
Chris Lattnera5251fc2009-04-18 09:36:27 +00004653 MD->setBody(Body);
Argyrios Kyrtzidisa2e85ad2009-07-18 00:33:33 +00004654 MD->setEndLoc(Body->getLocEnd());
Douglas Gregore0762c92009-06-19 23:52:42 +00004655 if (!MD->isInvalidDecl())
4656 DiagnoseUnusedParameters(MD->param_begin(), MD->param_end());
Ted Kremenek8189cde2009-02-07 01:47:29 +00004657 } else {
4658 Body->Destroy(Context);
Chris Lattnerb28317a2009-03-28 19:18:32 +00004659 return DeclPtrTy();
Ted Kremenek8189cde2009-02-07 01:47:29 +00004660 }
Douglas Gregore2c31ff2009-05-15 17:59:04 +00004661
Reid Spencer5f016e22007-07-11 17:01:13 +00004662 // Verify and clean out per-function state.
Eli Friedman8f17b662009-02-28 05:41:13 +00004663
Reid Spencer5f016e22007-07-11 17:01:13 +00004664 // Check goto/label use.
Steve Naroffcaaacec2009-03-13 15:38:40 +00004665 for (llvm::DenseMap<IdentifierInfo*, LabelStmt*>::iterator
Douglas Gregor9ea9bdb2010-03-01 23:15:13 +00004666 I = getLabelMap().begin(), E = getLabelMap().end(); I != E; ++I) {
Chris Lattnere32f74c2009-04-18 19:30:02 +00004667 LabelStmt *L = I->second;
Mike Stump1eb44332009-09-09 15:08:12 +00004668
Reid Spencer5f016e22007-07-11 17:01:13 +00004669 // Verify that we have no forward references left. If so, there was a goto
4670 // or address of a label taken, but no definition of it. Label fwd
4671 // definitions are indicated with a null substmt.
Chris Lattnere32f74c2009-04-18 19:30:02 +00004672 if (L->getSubStmt() != 0)
4673 continue;
Mike Stump1eb44332009-09-09 15:08:12 +00004674
Chris Lattnere32f74c2009-04-18 19:30:02 +00004675 // Emit error.
4676 Diag(L->getIdentLoc(), diag::err_undeclared_label_use) << L->getName();
Mike Stump1eb44332009-09-09 15:08:12 +00004677
Chris Lattnere32f74c2009-04-18 19:30:02 +00004678 // At this point, we have gotos that use the bogus label. Stitch it into
4679 // the function body so that they aren't leaked and that the AST is well
4680 // formed.
4681 if (Body == 0) {
4682 // The whole function wasn't parsed correctly, just delete this.
4683 L->Destroy(Context);
4684 continue;
Reid Spencer5f016e22007-07-11 17:01:13 +00004685 }
Mike Stump1eb44332009-09-09 15:08:12 +00004686
Chris Lattnere32f74c2009-04-18 19:30:02 +00004687 // Otherwise, the body is valid: we want to stitch the label decl into the
4688 // function somewhere so that it is properly owned and so that the goto
4689 // has a valid target. Do this by creating a new compound stmt with the
4690 // label in it.
Sebastian Redld3a413d2009-04-26 20:35:05 +00004691
Chris Lattnere32f74c2009-04-18 19:30:02 +00004692 // Give the label a sub-statement.
4693 L->setSubStmt(new (Context) NullStmt(L->getIdentLoc()));
Sebastian Redld3a413d2009-04-26 20:35:05 +00004694
4695 CompoundStmt *Compound = isa<CXXTryStmt>(Body) ?
4696 cast<CXXTryStmt>(Body)->getTryBlock() :
4697 cast<CompoundStmt>(Body);
Ted Kremenek4c9f7092010-03-12 22:22:36 +00004698 llvm::SmallVector<Stmt*, 64> Elements(Compound->body_begin(),
4699 Compound->body_end());
Chris Lattnere32f74c2009-04-18 19:30:02 +00004700 Elements.push_back(L);
Ted Kremenek4c9f7092010-03-12 22:22:36 +00004701 Compound->setStmts(Context, Elements.data(), Elements.size());
Reid Spencer5f016e22007-07-11 17:01:13 +00004702 }
Eli Friedman8f17b662009-02-28 05:41:13 +00004703
Douglas Gregor9ea9bdb2010-03-01 23:15:13 +00004704 if (Body) {
Douglas Gregor9ea9bdb2010-03-01 23:15:13 +00004705 // C++ constructors that have function-try-blocks can't have return
4706 // statements in the handlers of that block. (C++ [except.handle]p14)
4707 // Verify this.
4708 if (FD && isa<CXXConstructorDecl>(FD) && isa<CXXTryStmt>(Body))
4709 DiagnoseReturnInConstructorExceptionHandler(cast<CXXTryStmt>(Body));
4710
Ted Kremenekdbdbaaf2010-03-20 21:06:02 +00004711 // Verify that that gotos and switch cases don't jump into scopes illegally.
4712 // Verify that that gotos and switch cases don't jump into scopes illegally.
John McCalldae69ef2010-05-20 07:05:55 +00004713 if (FunctionNeedsScopeChecking() &&
John McCall8a2ca742010-05-20 07:13:26 +00004714 !dcl->isInvalidDecl() &&
John McCalldae69ef2010-05-20 07:05:55 +00004715 !hasAnyErrorsInThisFunction())
Douglas Gregor9ea9bdb2010-03-01 23:15:13 +00004716 DiagnoseInvalidJumps(Body);
Mike Stump1eb44332009-09-09 15:08:12 +00004717
Douglas Gregor9ea9bdb2010-03-01 23:15:13 +00004718 if (CXXDestructorDecl *Destructor = dyn_cast<CXXDestructorDecl>(dcl))
John McCallef027fe2010-03-16 21:39:52 +00004719 MarkBaseAndMemberDestructorsReferenced(Destructor->getLocation(),
4720 Destructor->getParent());
Douglas Gregor9ea9bdb2010-03-01 23:15:13 +00004721
4722 // If any errors have occurred, clear out any temporaries that may have
4723 // been leftover. This ensures that these temporaries won't be picked up for
4724 // deletion in some later function.
4725 if (PP.getDiagnostics().hasErrorOccurred())
4726 ExprTemporaries.clear();
Ted Kremenekdbdbaaf2010-03-20 21:06:02 +00004727 else if (!isa<FunctionTemplateDecl>(dcl)) {
4728 // Since the body is valid, issue any analysis-based warnings that are
4729 // enabled.
4730 QualType ResultType;
4731 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(dcl)) {
4732 ResultType = FD->getResultType();
4733 }
4734 else {
4735 ObjCMethodDecl *MD = cast<ObjCMethodDecl>(dcl);
4736 ResultType = MD->getResultType();
4737 }
Ted Kremenekd064fdc2010-03-23 00:13:23 +00004738 AnalysisWarnings.IssueWarnings(WP, dcl);
Ted Kremenekdbdbaaf2010-03-20 21:06:02 +00004739 }
4740
Douglas Gregor9ea9bdb2010-03-01 23:15:13 +00004741 assert(ExprTemporaries.empty() && "Leftover temporaries in function");
4742 }
4743
John McCall90f97892010-03-25 22:08:03 +00004744 if (!IsInstantiation)
4745 PopDeclContext();
4746
Douglas Gregor9ea9bdb2010-03-01 23:15:13 +00004747 PopFunctionOrBlockScope();
Anders Carlssonf8a9a792009-11-13 19:21:49 +00004748
Douglas Gregord5b57282009-11-15 07:07:58 +00004749 // If any errors have occurred, clear out any temporaries that may have
4750 // been leftover. This ensures that these temporaries won't be picked up for
4751 // deletion in some later function.
Chris Lattner6d97e5e2010-03-01 20:59:53 +00004752 if (getDiagnostics().hasErrorOccurred())
Douglas Gregord5b57282009-11-15 07:07:58 +00004753 ExprTemporaries.clear();
4754
Steve Naroffd6d054d2007-11-11 23:20:51 +00004755 return D;
Fariborz Jahanian60fbca02007-11-10 16:31:34 +00004756}
4757
Reid Spencer5f016e22007-07-11 17:01:13 +00004758/// ImplicitlyDefineFunction - An undeclared identifier was used in a function
4759/// call, forming a call to an implicitly defined function (per C99 6.5.1p2).
Mike Stump1eb44332009-09-09 15:08:12 +00004760NamedDecl *Sema::ImplicitlyDefineFunction(SourceLocation Loc,
Douglas Gregor4afa39d2009-01-20 01:17:11 +00004761 IdentifierInfo &II, Scope *S) {
Douglas Gregor63935192009-03-02 00:19:53 +00004762 // Before we produce a declaration for an implicitly defined
4763 // function, see whether there was a locally-scoped declaration of
4764 // this name as a function or variable. If so, use that
4765 // (non-visible) declaration, and complain about it.
4766 llvm::DenseMap<DeclarationName, NamedDecl *>::iterator Pos
4767 = LocallyScopedExternalDecls.find(&II);
4768 if (Pos != LocallyScopedExternalDecls.end()) {
4769 Diag(Loc, diag::warn_use_out_of_scope_declaration) << Pos->second;
4770 Diag(Pos->second->getLocation(), diag::note_previous_declaration);
4771 return Pos->second;
4772 }
4773
Chris Lattner37d10842008-05-05 21:18:06 +00004774 // Extension in C99. Legal in C90, but warn about it.
Daniel Dunbar01eb9b92009-10-18 21:17:35 +00004775 if (II.getName().startswith("__builtin_"))
Douglas Gregor9a8c9a22009-09-28 21:14:19 +00004776 Diag(Loc, diag::warn_builtin_unknown) << &II;
4777 else if (getLangOptions().C99)
Chris Lattner3c73c412008-11-19 08:23:25 +00004778 Diag(Loc, diag::ext_implicit_function_decl) << &II;
Chris Lattner37d10842008-05-05 21:18:06 +00004779 else
Chris Lattner3c73c412008-11-19 08:23:25 +00004780 Diag(Loc, diag::warn_implicit_function_decl) << &II;
Mike Stump1eb44332009-09-09 15:08:12 +00004781
Reid Spencer5f016e22007-07-11 17:01:13 +00004782 // Set a Declarator for the implicit definition: int foo();
4783 const char *Dummy;
4784 DeclSpec DS;
John McCallfec54012009-08-03 20:12:06 +00004785 unsigned DiagID;
4786 bool Error = DS.SetTypeSpecType(DeclSpec::TST_int, Loc, Dummy, DiagID);
Reid Spencer5f016e22007-07-11 17:01:13 +00004787 Error = Error; // Silence warning.
4788 assert(!Error && "Error setting up implicit decl!");
4789 Declarator D(DS, Declarator::BlockContext);
Sebastian Redl7dc81342009-04-29 17:30:04 +00004790 D.AddTypeInfo(DeclaratorChunk::getFunction(false, false, SourceLocation(), 0,
Sebastian Redl3cc97262009-05-31 11:47:27 +00004791 0, 0, false, SourceLocation(),
Argyrios Kyrtzidis82bf0102009-08-19 23:14:54 +00004792 false, 0,0,0, Loc, Loc, D),
Sebastian Redlab197ba2009-02-09 18:23:29 +00004793 SourceLocation());
Reid Spencer5f016e22007-07-11 17:01:13 +00004794 D.SetIdentifier(&II, Loc);
Sebastian Redlab197ba2009-02-09 18:23:29 +00004795
Argyrios Kyrtzidis93213bb2008-05-01 21:04:16 +00004796 // Insert this function into translation-unit scope.
4797
4798 DeclContext *PrevDC = CurContext;
4799 CurContext = Context.getTranslationUnitDecl();
Mike Stump1eb44332009-09-09 15:08:12 +00004800
4801 FunctionDecl *FD =
Douglas Gregor2e01cda2009-06-23 21:43:56 +00004802 dyn_cast<FunctionDecl>(ActOnDeclarator(TUScope, D).getAs<Decl>());
Steve Naroffe2ef8152008-04-04 14:32:09 +00004803 FD->setImplicit();
Argyrios Kyrtzidis93213bb2008-05-01 21:04:16 +00004804
4805 CurContext = PrevDC;
4806
Douglas Gregor3c385e52009-02-14 18:57:46 +00004807 AddKnownFunctionAttributes(FD);
4808
Steve Naroffe2ef8152008-04-04 14:32:09 +00004809 return FD;
Reid Spencer5f016e22007-07-11 17:01:13 +00004810}
4811
Douglas Gregor3c385e52009-02-14 18:57:46 +00004812/// \brief Adds any function attributes that we know a priori based on
4813/// the declaration of this function.
4814///
4815/// These attributes can apply both to implicitly-declared builtins
4816/// (like __builtin___printf_chk) or to library-declared functions
4817/// like NSLog or printf.
4818void Sema::AddKnownFunctionAttributes(FunctionDecl *FD) {
4819 if (FD->isInvalidDecl())
4820 return;
4821
4822 // If this is a built-in function, map its builtin attributes to
4823 // actual attributes.
Douglas Gregor7814e6d2009-09-12 00:22:50 +00004824 if (unsigned BuiltinID = FD->getBuiltinID()) {
Douglas Gregor3c385e52009-02-14 18:57:46 +00004825 // Handle printf-formatting attributes.
4826 unsigned FormatIdx;
4827 bool HasVAListArg;
4828 if (Context.BuiltinInfo.isPrintfLike(BuiltinID, FormatIdx, HasVAListArg)) {
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +00004829 if (!FD->getAttr<FormatAttr>())
Ted Kremenek3d2c43e2010-02-11 05:28:37 +00004830 FD->addAttr(::new (Context) FormatAttr(Context, "printf", FormatIdx+1,
4831 HasVAListArg ? 0 : FormatIdx+2));
Douglas Gregor3c385e52009-02-14 18:57:46 +00004832 }
Daniel Dunbaref2abfe2009-02-16 22:43:43 +00004833
4834 // Mark const if we don't care about errno and that is the only
4835 // thing preventing the function from being const. This allows
4836 // IRgen to use LLVM intrinsics for such functions.
4837 if (!getLangOptions().MathErrno &&
4838 Context.BuiltinInfo.isConstWithoutErrno(BuiltinID)) {
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +00004839 if (!FD->getAttr<ConstAttr>())
4840 FD->addAttr(::new (Context) ConstAttr());
Daniel Dunbaref2abfe2009-02-16 22:43:43 +00004841 }
Mike Stump0feecbb2009-07-27 19:14:18 +00004842
4843 if (Context.BuiltinInfo.isNoReturn(BuiltinID))
John McCall04a67a62010-02-05 21:31:56 +00004844 FD->setType(Context.getNoReturnType(FD->getType()));
Chris Lattner551f7082009-12-30 22:06:22 +00004845 if (Context.BuiltinInfo.isNoThrow(BuiltinID))
4846 FD->addAttr(::new (Context) NoThrowAttr());
4847 if (Context.BuiltinInfo.isConst(BuiltinID))
4848 FD->addAttr(::new (Context) ConstAttr());
Douglas Gregor3c385e52009-02-14 18:57:46 +00004849 }
4850
4851 IdentifierInfo *Name = FD->getIdentifier();
4852 if (!Name)
4853 return;
Mike Stump1eb44332009-09-09 15:08:12 +00004854 if ((!getLangOptions().CPlusPlus &&
Douglas Gregor3c385e52009-02-14 18:57:46 +00004855 FD->getDeclContext()->isTranslationUnit()) ||
4856 (isa<LinkageSpecDecl>(FD->getDeclContext()) &&
Mike Stump1eb44332009-09-09 15:08:12 +00004857 cast<LinkageSpecDecl>(FD->getDeclContext())->getLanguage() ==
Douglas Gregor3c385e52009-02-14 18:57:46 +00004858 LinkageSpecDecl::lang_c)) {
4859 // Okay: this could be a libc/libm/Objective-C function we know
4860 // about.
4861 } else
4862 return;
4863
Douglas Gregor21e072b2009-04-22 20:56:09 +00004864 if (Name->isStr("NSLog") || Name->isStr("NSLogv")) {
Mike Stump523a8fd2009-07-28 00:07:08 +00004865 // FIXME: NSLog and NSLogv should be target specific
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +00004866 if (const FormatAttr *Format = FD->getAttr<FormatAttr>()) {
Douglas Gregor3c385e52009-02-14 18:57:46 +00004867 // FIXME: We known better than our headers.
Ted Kremenek3d2c43e2010-02-11 05:28:37 +00004868 const_cast<FormatAttr *>(Format)->setType(Context, "printf");
Mike Stump1eb44332009-09-09 15:08:12 +00004869 } else
Ted Kremenek3d2c43e2010-02-11 05:28:37 +00004870 FD->addAttr(::new (Context) FormatAttr(Context, "printf", 1,
Eli Friedmand7dad722009-06-10 04:01:38 +00004871 Name->isStr("NSLogv") ? 0 : 2));
Douglas Gregor21e072b2009-04-22 20:56:09 +00004872 } else if (Name->isStr("asprintf") || Name->isStr("vasprintf")) {
Mike Stump523a8fd2009-07-28 00:07:08 +00004873 // FIXME: asprintf and vasprintf aren't C99 functions. Should they be
Mike Stump1eb44332009-09-09 15:08:12 +00004874 // target-specific builtins, perhaps?
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +00004875 if (!FD->getAttr<FormatAttr>())
Ted Kremenek3d2c43e2010-02-11 05:28:37 +00004876 FD->addAttr(::new (Context) FormatAttr(Context, "printf", 2,
Eli Friedmand7dad722009-06-10 04:01:38 +00004877 Name->isStr("vasprintf") ? 0 : 3));
Mike Stump782fa302009-07-28 02:25:19 +00004878 }
Douglas Gregor3c385e52009-02-14 18:57:46 +00004879}
Reid Spencer5f016e22007-07-11 17:01:13 +00004880
John McCallba6a9bd2009-10-24 08:00:42 +00004881TypedefDecl *Sema::ParseTypedefDecl(Scope *S, Declarator &D, QualType T,
John McCalla93c9342009-12-07 02:54:59 +00004882 TypeSourceInfo *TInfo) {
Reid Spencer5f016e22007-07-11 17:01:13 +00004883 assert(D.getIdentifier() && "Wrong callback for declspec without declarator");
Steve Naroff5912a352007-08-28 20:14:24 +00004884 assert(!T.isNull() && "GetTypeForDeclarator() returned null type");
Mike Stump1eb44332009-09-09 15:08:12 +00004885
John McCalla93c9342009-12-07 02:54:59 +00004886 if (!TInfo) {
John McCallba6a9bd2009-10-24 08:00:42 +00004887 assert(D.isInvalidType() && "no declarator info for valid type");
John McCalla93c9342009-12-07 02:54:59 +00004888 TInfo = Context.getTrivialTypeSourceInfo(T);
John McCallba6a9bd2009-10-24 08:00:42 +00004889 }
4890
Reid Spencer5f016e22007-07-11 17:01:13 +00004891 // Scope manipulation handled by caller.
Chris Lattner0ed844b2008-04-04 06:12:32 +00004892 TypedefDecl *NewTD = TypedefDecl::Create(Context, CurContext,
4893 D.getIdentifierLoc(),
Mike Stump1eb44332009-09-09 15:08:12 +00004894 D.getIdentifier(),
John McCalla93c9342009-12-07 02:54:59 +00004895 TInfo);
Mike Stump1eb44332009-09-09 15:08:12 +00004896
John McCall2191b202009-09-05 06:31:47 +00004897 if (const TagType *TT = T->getAs<TagType>()) {
Anders Carlsson4843e582009-03-10 17:07:44 +00004898 TagDecl *TD = TT->getDecl();
Mike Stump1eb44332009-09-09 15:08:12 +00004899
Anders Carlsson4843e582009-03-10 17:07:44 +00004900 // If the TagDecl that the TypedefDecl points to is an anonymous decl
4901 // keep track of the TypedefDecl.
4902 if (!TD->getIdentifier() && !TD->getTypedefForAnonDecl())
4903 TD->setTypedefForAnonDecl(NewTD);
4904 }
4905
Chris Lattnereaaebc72009-04-25 08:06:05 +00004906 if (D.isInvalidType())
Steve Naroff5912a352007-08-28 20:14:24 +00004907 NewTD->setInvalidDecl();
4908 return NewTD;
Reid Spencer5f016e22007-07-11 17:01:13 +00004909}
4910
Douglas Gregor501c5ce2009-05-14 16:41:31 +00004911
4912/// \brief Determine whether a tag with a given kind is acceptable
4913/// as a redeclaration of the given tag declaration.
4914///
4915/// \returns true if the new tag kind is acceptable, false otherwise.
Mike Stump1eb44332009-09-09 15:08:12 +00004916bool Sema::isAcceptableTagRedeclaration(const TagDecl *Previous,
Abramo Bagnara465d41b2010-05-11 21:36:43 +00004917 TagTypeKind NewTag,
Douglas Gregor501c5ce2009-05-14 16:41:31 +00004918 SourceLocation NewTagLoc,
4919 const IdentifierInfo &Name) {
4920 // C++ [dcl.type.elab]p3:
4921 // The class-key or enum keyword present in the
4922 // elaborated-type-specifier shall agree in kind with the
Abramo Bagnara465d41b2010-05-11 21:36:43 +00004923 // declaration to which the name in the elaborated-type-specifier
Douglas Gregor501c5ce2009-05-14 16:41:31 +00004924 // refers. This rule also applies to the form of
4925 // elaborated-type-specifier that declares a class-name or
4926 // friend class since it can be construed as referring to the
4927 // definition of the class. Thus, in any
4928 // elaborated-type-specifier, the enum keyword shall be used to
Abramo Bagnara465d41b2010-05-11 21:36:43 +00004929 // refer to an enumeration (7.2), the union class-key shall be
Douglas Gregor501c5ce2009-05-14 16:41:31 +00004930 // used to refer to a union (clause 9), and either the class or
4931 // struct class-key shall be used to refer to a class (clause 9)
4932 // declared using the class or struct class-key.
Abramo Bagnara465d41b2010-05-11 21:36:43 +00004933 TagTypeKind OldTag = Previous->getTagKind();
Douglas Gregor501c5ce2009-05-14 16:41:31 +00004934 if (OldTag == NewTag)
4935 return true;
Mike Stump1eb44332009-09-09 15:08:12 +00004936
Abramo Bagnara465d41b2010-05-11 21:36:43 +00004937 if ((OldTag == TTK_Struct || OldTag == TTK_Class) &&
4938 (NewTag == TTK_Struct || NewTag == TTK_Class)) {
Douglas Gregor501c5ce2009-05-14 16:41:31 +00004939 // Warn about the struct/class tag mismatch.
4940 bool isTemplate = false;
4941 if (const CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(Previous))
4942 isTemplate = Record->getDescribedClassTemplate();
4943
4944 Diag(NewTagLoc, diag::warn_struct_class_tag_mismatch)
Abramo Bagnara465d41b2010-05-11 21:36:43 +00004945 << (NewTag == TTK_Class)
Douglas Gregor501c5ce2009-05-14 16:41:31 +00004946 << isTemplate << &Name
Douglas Gregor849b2432010-03-31 17:46:05 +00004947 << FixItHint::CreateReplacement(SourceRange(NewTagLoc),
Abramo Bagnara465d41b2010-05-11 21:36:43 +00004948 OldTag == TTK_Class? "class" : "struct");
Douglas Gregor501c5ce2009-05-14 16:41:31 +00004949 Diag(Previous->getLocation(), diag::note_previous_use);
4950 return true;
4951 }
4952 return false;
4953}
4954
Steve Naroff08d92e42007-09-15 18:49:24 +00004955/// ActOnTag - This is invoked when we see 'struct foo' or 'struct {'. In the
Reid Spencer5f016e22007-07-11 17:01:13 +00004956/// former case, Name will be non-null. In the later case, Name will be null.
John McCall0f434ec2009-07-31 02:45:11 +00004957/// TagSpec indicates what kind of tag this is. TUK indicates whether this is a
Reid Spencer5f016e22007-07-11 17:01:13 +00004958/// reference/declaration/definition of a tag.
John McCall0f434ec2009-07-31 02:45:11 +00004959Sema::DeclPtrTy Sema::ActOnTag(Scope *S, unsigned TagSpec, TagUseKind TUK,
Jeffrey Yasskin9ab14542010-04-08 16:38:48 +00004960 SourceLocation KWLoc, CXXScopeSpec &SS,
Chris Lattnerb28317a2009-03-28 19:18:32 +00004961 IdentifierInfo *Name, SourceLocation NameLoc,
Douglas Gregor402abb52009-05-28 23:31:59 +00004962 AttributeList *Attr, AccessSpecifier AS,
Douglas Gregor7cdbc582009-07-22 23:48:44 +00004963 MultiTemplateParamsArg TemplateParameterLists,
John McCallc4e70192009-09-11 04:59:25 +00004964 bool &OwnedDecl, bool &IsDependent) {
Douglas Gregor7df7b6b2008-12-15 16:32:14 +00004965 // If this is not a definition, it must have a name.
John McCall0f434ec2009-07-31 02:45:11 +00004966 assert((Name != 0 || TUK == TUK_Definition) &&
Reid Spencer5f016e22007-07-11 17:01:13 +00004967 "Nameless record must be a definition!");
Douglas Gregoraaba5e32009-02-04 19:02:06 +00004968
Douglas Gregor402abb52009-05-28 23:31:59 +00004969 OwnedDecl = false;
Abramo Bagnara465d41b2010-05-11 21:36:43 +00004970 TagTypeKind Kind = TypeWithKeyword::getTagTypeKindForTypeSpec(TagSpec);
Mike Stump1eb44332009-09-09 15:08:12 +00004971
Douglas Gregor1fef4e62009-10-07 22:35:40 +00004972 // FIXME: Check explicit specializations more carefully.
4973 bool isExplicitSpecialization = false;
John McCall0f434ec2009-07-31 02:45:11 +00004974 if (TUK != TUK_Reference) {
Douglas Gregor7cdbc582009-07-22 23:48:44 +00004975 if (TemplateParameterList *TemplateParams
4976 = MatchTemplateParametersToScopeSpecifier(KWLoc, SS,
4977 (TemplateParameterList**)TemplateParameterLists.get(),
Douglas Gregor1fef4e62009-10-07 22:35:40 +00004978 TemplateParameterLists.size(),
John McCall77e8b112010-04-13 20:37:33 +00004979 TUK == TUK_Friend,
Douglas Gregor1fef4e62009-10-07 22:35:40 +00004980 isExplicitSpecialization)) {
Douglas Gregord85bea22009-09-26 06:47:28 +00004981 if (TemplateParams->size() > 0) {
Douglas Gregor7cdbc582009-07-22 23:48:44 +00004982 // This is a declaration or definition of a class template (which may
4983 // be a member of another template).
4984 OwnedDecl = false;
John McCall0f434ec2009-07-31 02:45:11 +00004985 DeclResult Result = CheckClassTemplate(S, TagSpec, TUK, KWLoc,
Douglas Gregor7cdbc582009-07-22 23:48:44 +00004986 SS, Name, NameLoc, Attr,
Douglas Gregor05396e22009-08-25 17:23:04 +00004987 TemplateParams,
Douglas Gregor7cdbc582009-07-22 23:48:44 +00004988 AS);
Douglas Gregor05396e22009-08-25 17:23:04 +00004989 TemplateParameterLists.release();
Douglas Gregor7cdbc582009-07-22 23:48:44 +00004990 return Result.get();
4991 } else {
Douglas Gregorf6b11852009-10-08 15:14:33 +00004992 // The "template<>" header is extraneous.
4993 Diag(TemplateParams->getTemplateLoc(), diag::err_template_tag_noparams)
Abramo Bagnara465d41b2010-05-11 21:36:43 +00004994 << TypeWithKeyword::getTagTypeKindName(Kind) << Name;
Douglas Gregorf6b11852009-10-08 15:14:33 +00004995 isExplicitSpecialization = true;
Douglas Gregor7cdbc582009-07-22 23:48:44 +00004996 }
Mike Stump1eb44332009-09-09 15:08:12 +00004997 }
Douglas Gregorf6b11852009-10-08 15:14:33 +00004998
4999 TemplateParameterLists.release();
Mike Stump1eb44332009-09-09 15:08:12 +00005000 }
5001
Douglas Gregor4920f1f2009-01-12 22:49:06 +00005002 DeclContext *SearchDC = CurContext;
Argyrios Kyrtzidis0f84a232008-11-09 22:53:32 +00005003 DeclContext *DC = CurContext;
Douglas Gregor7adb10f2009-09-15 22:30:29 +00005004 bool isStdBadAlloc = false;
Douglas Gregor0b7a1582009-01-17 00:42:38 +00005005 bool Invalid = false;
5006
Chandler Carruth7bf36002010-03-01 21:17:36 +00005007 RedeclarationKind Redecl = ForRedeclaration;
5008 if (TUK == TUK_Friend || TUK == TUK_Reference)
5009 Redecl = NotForRedeclaration;
John McCall68263142009-11-18 22:49:29 +00005010
5011 LookupResult Previous(*this, Name, NameLoc, LookupTagName, Redecl);
John McCall6e247262009-10-10 05:48:19 +00005012
Argyrios Kyrtzidis630c81b2008-11-09 22:09:58 +00005013 if (Name && SS.isNotEmpty()) {
5014 // We have a nested-name tag ('struct foo::bar').
5015
5016 // Check for invalid 'foo::'.
Argyrios Kyrtzidis0f84a232008-11-09 22:53:32 +00005017 if (SS.isInvalid()) {
Argyrios Kyrtzidis630c81b2008-11-09 22:09:58 +00005018 Name = 0;
5019 goto CreateNewDecl;
5020 }
5021
John McCallc4e70192009-09-11 04:59:25 +00005022 // If this is a friend or a reference to a class in a dependent
5023 // context, don't try to make a decl for it.
5024 if (TUK == TUK_Friend || TUK == TUK_Reference) {
5025 DC = computeDeclContext(SS, false);
5026 if (!DC) {
5027 IsDependent = true;
5028 return DeclPtrTy();
5029 }
John McCall77bb1aa2010-05-01 00:40:08 +00005030 } else {
5031 DC = computeDeclContext(SS, true);
5032 if (!DC) {
5033 Diag(SS.getRange().getBegin(), diag::err_dependent_nested_name_spec)
5034 << SS.getRange();
5035 return DeclPtrTy();
5036 }
John McCallc4e70192009-09-11 04:59:25 +00005037 }
5038
John McCall77bb1aa2010-05-01 00:40:08 +00005039 if (RequireCompleteDeclContext(SS, DC))
Douglas Gregor3f5b61c2009-05-14 00:28:11 +00005040 return DeclPtrTy::make((Decl *)0);
5041
Douglas Gregor1931b442009-02-03 00:34:39 +00005042 SearchDC = DC;
Argyrios Kyrtzidis0f84a232008-11-09 22:53:32 +00005043 // Look-up name inside 'foo::'.
John McCall68263142009-11-18 22:49:29 +00005044 LookupQualifiedName(Previous, DC);
John McCall6e247262009-10-10 05:48:19 +00005045
John McCall68263142009-11-18 22:49:29 +00005046 if (Previous.isAmbiguous())
John McCall6e247262009-10-10 05:48:19 +00005047 return DeclPtrTy();
John McCall6e247262009-10-10 05:48:19 +00005048
John McCall68263142009-11-18 22:49:29 +00005049 if (Previous.empty()) {
Douglas Gregor9edad9b2010-01-14 17:47:39 +00005050 // Name lookup did not find anything. However, if the
5051 // nested-name-specifier refers to the current instantiation,
5052 // and that current instantiation has any dependent base
5053 // classes, we might find something at instantiation time: treat
5054 // this as a dependent elaborated-type-specifier.
Douglas Gregor7d3f5762010-01-15 01:44:47 +00005055 if (Previous.wasNotFoundInCurrentInstantiation()) {
Douglas Gregor9edad9b2010-01-14 17:47:39 +00005056 IsDependent = true;
5057 return DeclPtrTy();
5058 }
5059
5060 // A tag 'foo::bar' must already exist.
Douglas Gregor1eabb7d2010-03-31 23:17:41 +00005061 Diag(NameLoc, diag::err_not_tag_in_scope)
5062 << Kind << Name << DC << SS.getRange();
Argyrios Kyrtzidis630c81b2008-11-09 22:09:58 +00005063 Name = 0;
Douglas Gregord0c87372009-05-27 17:30:49 +00005064 Invalid = true;
Argyrios Kyrtzidis630c81b2008-11-09 22:09:58 +00005065 goto CreateNewDecl;
5066 }
Chris Lattnercf79b012009-01-21 02:38:50 +00005067 } else if (Name) {
Argyrios Kyrtzidis630c81b2008-11-09 22:09:58 +00005068 // If this is a named struct, check to see if there was a previous forward
5069 // declaration or definition.
Douglas Gregor2a3009a2009-02-03 19:21:40 +00005070 // FIXME: We're looking into outer scopes here, even when we
5071 // shouldn't be. Doing so can result in ambiguities that we
5072 // shouldn't be diagnosing.
John McCall68263142009-11-18 22:49:29 +00005073 LookupName(Previous, S);
5074
5075 // Note: there used to be some attempt at recovery here.
5076 if (Previous.isAmbiguous())
5077 return DeclPtrTy();
Douglas Gregor72de6672009-01-08 20:45:30 +00005078
John McCall0f434ec2009-07-31 02:45:11 +00005079 if (!getLangOptions().CPlusPlus && TUK != TUK_Reference) {
Douglas Gregor72de6672009-01-08 20:45:30 +00005080 // FIXME: This makes sure that we ignore the contexts associated
5081 // with C structs, unions, and enums when looking for a matching
5082 // tag declaration or definition. See the similar lookup tweak
Douglas Gregor4c921ae2009-01-30 01:04:22 +00005083 // in Sema::LookupName; is there a better way to deal with this?
Douglas Gregor4920f1f2009-01-12 22:49:06 +00005084 while (isa<RecordDecl>(SearchDC) || isa<EnumDecl>(SearchDC))
5085 SearchDC = SearchDC->getParent();
Douglas Gregor72de6672009-01-08 20:45:30 +00005086 }
Argyrios Kyrtzidis630c81b2008-11-09 22:09:58 +00005087 }
5088
John McCall68263142009-11-18 22:49:29 +00005089 if (Previous.isSingleResult() &&
5090 Previous.getFoundDecl()->isTemplateParameter()) {
Douglas Gregor72c3f312008-12-05 18:15:24 +00005091 // Maybe we will complain about the shadowed template parameter.
John McCall68263142009-11-18 22:49:29 +00005092 DiagnoseTemplateParameterShadow(NameLoc, Previous.getFoundDecl());
Douglas Gregor72c3f312008-12-05 18:15:24 +00005093 // Just pretend that we didn't see the previous declaration.
John McCall68263142009-11-18 22:49:29 +00005094 Previous.clear();
Douglas Gregor72c3f312008-12-05 18:15:24 +00005095 }
5096
Douglas Gregor7adb10f2009-09-15 22:30:29 +00005097 if (getLangOptions().CPlusPlus && Name && DC && StdNamespace &&
5098 DC->Equals(StdNamespace) && Name->isStr("bad_alloc")) {
5099 // This is a declaration of or a reference to "std::bad_alloc".
5100 isStdBadAlloc = true;
5101
John McCall68263142009-11-18 22:49:29 +00005102 if (Previous.empty() && StdBadAlloc) {
Douglas Gregor7adb10f2009-09-15 22:30:29 +00005103 // std::bad_alloc has been implicitly declared (but made invisible to
5104 // name lookup). Fill in this implicit declaration as the previous
5105 // declaration, so that the declarations get chained appropriately.
John McCall68263142009-11-18 22:49:29 +00005106 Previous.addDecl(StdBadAlloc);
Douglas Gregor7adb10f2009-09-15 22:30:29 +00005107 }
5108 }
John McCall68263142009-11-18 22:49:29 +00005109
John McCall9c86b512010-03-25 21:28:06 +00005110 // If we didn't find a previous declaration, and this is a reference
5111 // (or friend reference), move to the correct scope. In C++, we
5112 // also need to do a redeclaration lookup there, just in case
5113 // there's a shadow friend decl.
5114 if (Name && Previous.empty() &&
5115 (TUK == TUK_Reference || TUK == TUK_Friend)) {
5116 if (Invalid) goto CreateNewDecl;
5117 assert(SS.isEmpty());
5118
5119 if (TUK == TUK_Reference) {
5120 // C++ [basic.scope.pdecl]p5:
5121 // -- for an elaborated-type-specifier of the form
5122 //
5123 // class-key identifier
5124 //
5125 // if the elaborated-type-specifier is used in the
5126 // decl-specifier-seq or parameter-declaration-clause of a
5127 // function defined in namespace scope, the identifier is
5128 // declared as a class-name in the namespace that contains
5129 // the declaration; otherwise, except as a friend
5130 // declaration, the identifier is declared in the smallest
5131 // non-class, non-function-prototype scope that contains the
5132 // declaration.
5133 //
5134 // C99 6.7.2.3p8 has a similar (but not identical!) provision for
5135 // C structs and unions.
5136 //
5137 // It is an error in C++ to declare (rather than define) an enum
5138 // type, including via an elaborated type specifier. We'll
5139 // diagnose that later; for now, declare the enum in the same
5140 // scope as we would have picked for any other tag type.
5141 //
5142 // GNU C also supports this behavior as part of its incomplete
5143 // enum types extension, while GNU C++ does not.
5144 //
5145 // Find the context where we'll be declaring the tag.
5146 // FIXME: We would like to maintain the current DeclContext as the
5147 // lexical context,
5148 while (SearchDC->isRecord())
5149 SearchDC = SearchDC->getParent();
5150
5151 // Find the scope where we'll be declaring the tag.
5152 while (S->isClassScope() ||
5153 (getLangOptions().CPlusPlus &&
5154 S->isFunctionPrototypeScope()) ||
5155 ((S->getFlags() & Scope::DeclScope) == 0) ||
5156 (S->getEntity() &&
5157 ((DeclContext *)S->getEntity())->isTransparentContext()))
5158 S = S->getParent();
5159 } else {
5160 assert(TUK == TUK_Friend);
5161 // C++ [namespace.memdef]p3:
5162 // If a friend declaration in a non-local class first declares a
5163 // class or function, the friend class or function is a member of
5164 // the innermost enclosing namespace.
5165 SearchDC = SearchDC->getEnclosingNamespaceContext();
John McCall9c86b512010-03-25 21:28:06 +00005166 }
5167
John McCall0d6b1642010-04-23 18:46:30 +00005168 // In C++, we need to do a redeclaration lookup to properly
5169 // diagnose some problems.
John McCall9c86b512010-03-25 21:28:06 +00005170 if (getLangOptions().CPlusPlus) {
5171 Previous.setRedeclarationKind(ForRedeclaration);
5172 LookupQualifiedName(Previous, SearchDC);
5173 }
5174 }
5175
John McCall68263142009-11-18 22:49:29 +00005176 if (!Previous.empty()) {
Douglas Gregor57265e32010-04-12 16:00:01 +00005177 NamedDecl *PrevDecl = (*Previous.begin())->getUnderlyingDecl();
John McCall0d6b1642010-04-23 18:46:30 +00005178
5179 // It's okay to have a tag decl in the same scope as a typedef
5180 // which hides a tag decl in the same scope. Finding this
5181 // insanity with a redeclaration lookup can only actually happen
5182 // in C++.
5183 //
5184 // This is also okay for elaborated-type-specifiers, which is
5185 // technically forbidden by the current standard but which is
5186 // okay according to the likely resolution of an open issue;
5187 // see http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#407
5188 if (getLangOptions().CPlusPlus) {
5189 if (TypedefDecl *TD = dyn_cast<TypedefDecl>(PrevDecl)) {
5190 if (const TagType *TT = TD->getUnderlyingType()->getAs<TagType>()) {
5191 TagDecl *Tag = TT->getDecl();
5192 if (Tag->getDeclName() == Name &&
Douglas Gregorc8fd2da2010-04-27 16:26:47 +00005193 Tag->getDeclContext()->getLookupContext()
5194 ->Equals(TD->getDeclContext()->getLookupContext())) {
John McCall0d6b1642010-04-23 18:46:30 +00005195 PrevDecl = Tag;
5196 Previous.clear();
5197 Previous.addDecl(Tag);
5198 }
5199 }
5200 }
5201 }
5202
Argyrios Kyrtzidis2d1c5d32008-04-27 13:50:30 +00005203 if (TagDecl *PrevTagDecl = dyn_cast<TagDecl>(PrevDecl)) {
Chris Lattner14943b92008-07-03 03:30:58 +00005204 // If this is a use of a previous tag, or if the tag is already declared
5205 // in the same scope (so that the definition/declaration completes or
Argyrios Kyrtzidis2d1c5d32008-04-27 13:50:30 +00005206 // rementions the tag), reuse the decl.
John McCall67d1a672009-08-06 02:15:43 +00005207 if (TUK == TUK_Reference || TUK == TUK_Friend ||
5208 isDeclInScope(PrevDecl, SearchDC, S)) {
Chris Lattner14943b92008-07-03 03:30:58 +00005209 // Make sure that this wasn't declared as an enum and now used as a
5210 // struct or something similar.
Douglas Gregor501c5ce2009-05-14 16:41:31 +00005211 if (!isAcceptableTagRedeclaration(PrevTagDecl, Kind, KWLoc, *Name)) {
Mike Stump1eb44332009-09-09 15:08:12 +00005212 bool SafeToContinue
Abramo Bagnara465d41b2010-05-11 21:36:43 +00005213 = (PrevTagDecl->getTagKind() != TTK_Enum &&
5214 Kind != TTK_Enum);
Douglas Gregora3a83512009-04-01 23:51:29 +00005215 if (SafeToContinue)
Mike Stump1eb44332009-09-09 15:08:12 +00005216 Diag(KWLoc, diag::err_use_with_wrong_tag)
Douglas Gregora3a83512009-04-01 23:51:29 +00005217 << Name
Douglas Gregor849b2432010-03-31 17:46:05 +00005218 << FixItHint::CreateReplacement(SourceRange(KWLoc),
5219 PrevTagDecl->getKindName());
Douglas Gregora3a83512009-04-01 23:51:29 +00005220 else
5221 Diag(KWLoc, diag::err_use_with_wrong_tag) << Name;
John McCall68263142009-11-18 22:49:29 +00005222 Diag(PrevTagDecl->getLocation(), diag::note_previous_use);
Douglas Gregora3a83512009-04-01 23:51:29 +00005223
Mike Stump1eb44332009-09-09 15:08:12 +00005224 if (SafeToContinue)
Douglas Gregora3a83512009-04-01 23:51:29 +00005225 Kind = PrevTagDecl->getTagKind();
5226 else {
5227 // Recover by making this an anonymous redefinition.
5228 Name = 0;
John McCall68263142009-11-18 22:49:29 +00005229 Previous.clear();
Douglas Gregora3a83512009-04-01 23:51:29 +00005230 Invalid = true;
5231 }
5232 }
5233
5234 if (!Invalid) {
Douglas Gregor7df7b6b2008-12-15 16:32:14 +00005235 // If this is a use, just return the declaration we found.
Chris Lattner14943b92008-07-03 03:30:58 +00005236
Douglas Gregor7df7b6b2008-12-15 16:32:14 +00005237 // FIXME: In the future, return a variant or some other clue
5238 // for the consumer of this Decl to know it doesn't own it.
5239 // For our current ASTs this shouldn't be a problem, but will
5240 // need to be changed with DeclGroups.
Douglas Gregore1aa9f32010-06-08 21:27:36 +00005241 if ((TUK == TUK_Reference && !PrevTagDecl->getFriendObjectKind()) ||
5242 TUK == TUK_Friend)
John McCall68263142009-11-18 22:49:29 +00005243 return DeclPtrTy::make(PrevTagDecl);
Douglas Gregoraaba5e32009-02-04 19:02:06 +00005244
Douglas Gregor7df7b6b2008-12-15 16:32:14 +00005245 // Diagnose attempts to redefine a tag.
John McCall0f434ec2009-07-31 02:45:11 +00005246 if (TUK == TUK_Definition) {
Douglas Gregor952b0172010-02-11 01:04:33 +00005247 if (TagDecl *Def = PrevTagDecl->getDefinition()) {
Douglas Gregorb3ae4fc2009-10-12 20:18:28 +00005248 // If we're defining a specialization and the previous definition
5249 // is from an implicit instantiation, don't emit an error
5250 // here; we'll catch this in the general case below.
5251 if (!isExplicitSpecialization ||
5252 !isa<CXXRecordDecl>(Def) ||
5253 cast<CXXRecordDecl>(Def)->getTemplateSpecializationKind()
5254 == TSK_ExplicitSpecialization) {
5255 Diag(NameLoc, diag::err_redefinition) << Name;
5256 Diag(Def->getLocation(), diag::note_previous_definition);
5257 // If this is a redefinition, recover by making this
5258 // struct be anonymous, which will make any later
5259 // references get the previous definition.
5260 Name = 0;
John McCall68263142009-11-18 22:49:29 +00005261 Previous.clear();
Douglas Gregorb3ae4fc2009-10-12 20:18:28 +00005262 Invalid = true;
5263 }
Douglas Gregor0b7a1582009-01-17 00:42:38 +00005264 } else {
5265 // If the type is currently being defined, complain
5266 // about a nested redefinition.
5267 TagType *Tag = cast<TagType>(Context.getTagDeclType(PrevTagDecl));
5268 if (Tag->isBeingDefined()) {
5269 Diag(NameLoc, diag::err_nested_redefinition) << Name;
Mike Stump1eb44332009-09-09 15:08:12 +00005270 Diag(PrevTagDecl->getLocation(),
Douglas Gregor0b7a1582009-01-17 00:42:38 +00005271 diag::note_previous_definition);
5272 Name = 0;
John McCall68263142009-11-18 22:49:29 +00005273 Previous.clear();
Douglas Gregor0b7a1582009-01-17 00:42:38 +00005274 Invalid = true;
5275 }
Douglas Gregor7df7b6b2008-12-15 16:32:14 +00005276 }
Douglas Gregor0b7a1582009-01-17 00:42:38 +00005277
Douglas Gregor7df7b6b2008-12-15 16:32:14 +00005278 // Okay, this is definition of a previously declared or referenced
5279 // tag PrevDecl. We're going to create a new Decl for it.
Douglas Gregor0b7a1582009-01-17 00:42:38 +00005280 }
Argyrios Kyrtzidis2d1c5d32008-04-27 13:50:30 +00005281 }
Douglas Gregor7df7b6b2008-12-15 16:32:14 +00005282 // If we get here we have (another) forward declaration or we
John McCall67d1a672009-08-06 02:15:43 +00005283 // have a definition. Just create a new decl.
5284
Douglas Gregor7df7b6b2008-12-15 16:32:14 +00005285 } else {
5286 // If we get here, this is a definition of a new tag type in a nested
Mike Stump1eb44332009-09-09 15:08:12 +00005287 // scope, e.g. "struct foo; void bar() { struct foo; }", just create a
Douglas Gregor7df7b6b2008-12-15 16:32:14 +00005288 // new decl/type. We set PrevDecl to NULL so that the entities
5289 // have distinct types.
John McCall68263142009-11-18 22:49:29 +00005290 Previous.clear();
Reid Spencer5f016e22007-07-11 17:01:13 +00005291 }
Douglas Gregor7df7b6b2008-12-15 16:32:14 +00005292 // If we get here, we're going to create a new Decl. If PrevDecl
5293 // is non-NULL, it's a definition of the tag declared by
5294 // PrevDecl. If it's NULL, we have a new definition.
John McCall0d6b1642010-04-23 18:46:30 +00005295
5296
5297 // Otherwise, PrevDecl is not a tag, but was found with tag
5298 // lookup. This is only actually possible in C++, where a few
5299 // things like templates still live in the tag namespace.
Argyrios Kyrtzidis2d1c5d32008-04-27 13:50:30 +00005300 } else {
John McCall0d6b1642010-04-23 18:46:30 +00005301 assert(getLangOptions().CPlusPlus);
5302
5303 // Use a better diagnostic if an elaborated-type-specifier
5304 // found the wrong kind of type on the first
5305 // (non-redeclaration) lookup.
5306 if ((TUK == TUK_Reference || TUK == TUK_Friend) &&
5307 !Previous.isForRedeclaration()) {
5308 unsigned Kind = 0;
5309 if (isa<TypedefDecl>(PrevDecl)) Kind = 1;
5310 else if (isa<ClassTemplateDecl>(PrevDecl)) Kind = 2;
5311 Diag(NameLoc, diag::err_tag_reference_non_tag) << Kind;
5312 Diag(PrevDecl->getLocation(), diag::note_declared_at);
5313 Invalid = true;
5314
5315 // Otherwise, only diagnose if the declaration is in scope.
5316 } else if (!isDeclInScope(PrevDecl, SearchDC, S)) {
5317 // do nothing
5318
5319 // Diagnose implicit declarations introduced by elaborated types.
5320 } else if (TUK == TUK_Reference || TUK == TUK_Friend) {
5321 unsigned Kind = 0;
5322 if (isa<TypedefDecl>(PrevDecl)) Kind = 1;
5323 else if (isa<ClassTemplateDecl>(PrevDecl)) Kind = 2;
5324 Diag(NameLoc, diag::err_tag_reference_conflict) << Kind;
5325 Diag(PrevDecl->getLocation(), diag::note_previous_decl) << PrevDecl;
5326 Invalid = true;
5327
5328 // Otherwise it's a declaration. Call out a particularly common
5329 // case here.
5330 } else if (isa<TypedefDecl>(PrevDecl)) {
5331 Diag(NameLoc, diag::err_tag_definition_of_typedef)
5332 << Name
5333 << cast<TypedefDecl>(PrevDecl)->getUnderlyingType();
5334 Diag(PrevDecl->getLocation(), diag::note_previous_decl) << PrevDecl;
5335 Invalid = true;
5336
5337 // Otherwise, diagnose.
5338 } else {
5339 // The tag name clashes with something else in the target scope,
5340 // issue an error and recover by making this tag be anonymous.
Chris Lattner3c73c412008-11-19 08:23:25 +00005341 Diag(NameLoc, diag::err_redefinition_different_kind) << Name;
Chris Lattner5f4a6822008-11-23 23:12:31 +00005342 Diag(PrevDecl->getLocation(), diag::note_previous_definition);
Argyrios Kyrtzidisb02ef242008-07-16 07:45:46 +00005343 Name = 0;
Douglas Gregor0b7a1582009-01-17 00:42:38 +00005344 Invalid = true;
Argyrios Kyrtzidisb02ef242008-07-16 07:45:46 +00005345 }
John McCall0d6b1642010-04-23 18:46:30 +00005346
5347 // The existing declaration isn't relevant to us; we're in a
5348 // new scope, so clear out the previous declaration.
5349 Previous.clear();
Reid Spencer5f016e22007-07-11 17:01:13 +00005350 }
Reid Spencer5f016e22007-07-11 17:01:13 +00005351 }
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +00005352
Chris Lattnercc98eac2008-12-17 07:13:27 +00005353CreateNewDecl:
Mike Stump1eb44332009-09-09 15:08:12 +00005354
John McCall68263142009-11-18 22:49:29 +00005355 TagDecl *PrevDecl = 0;
5356 if (Previous.isSingleResult())
5357 PrevDecl = cast<TagDecl>(Previous.getFoundDecl());
5358
Reid Spencer5f016e22007-07-11 17:01:13 +00005359 // If there is an identifier, use the location of the identifier as the
5360 // location of the decl, otherwise use the location of the struct/union
5361 // keyword.
5362 SourceLocation Loc = NameLoc.isValid() ? NameLoc : KWLoc;
Mike Stump1eb44332009-09-09 15:08:12 +00005363
Douglas Gregor7df7b6b2008-12-15 16:32:14 +00005364 // Otherwise, create a new declaration. If there is a previous
5365 // declaration of the same entity, the two will be linked via
5366 // PrevDecl.
Reid Spencer5f016e22007-07-11 17:01:13 +00005367 TagDecl *New;
Douglas Gregorbcbffc42009-01-07 00:43:41 +00005368
Abramo Bagnara465d41b2010-05-11 21:36:43 +00005369 if (Kind == TTK_Enum) {
Reid Spencer5f016e22007-07-11 17:01:13 +00005370 // FIXME: Tag decls should be chained to any simultaneous vardecls, e.g.:
5371 // enum X { A, B, C } D; D should chain to X.
Douglas Gregor741dd9a2009-07-21 14:46:17 +00005372 New = EnumDecl::Create(Context, SearchDC, Loc, Name, KWLoc,
Douglas Gregor7df7b6b2008-12-15 16:32:14 +00005373 cast_or_null<EnumDecl>(PrevDecl));
Reid Spencer5f016e22007-07-11 17:01:13 +00005374 // If this is an undefined enum, warn.
John McCall0f434ec2009-07-31 02:45:11 +00005375 if (TUK != TUK_Definition && !Invalid) {
Douglas Gregor80711a22009-03-06 18:34:03 +00005376 unsigned DK = getLangOptions().CPlusPlus? diag::err_forward_ref_enum
5377 : diag::ext_forward_ref_enum;
5378 Diag(Loc, DK);
5379 }
Argyrios Kyrtzidis39ba4ae2008-06-09 23:19:58 +00005380 } else {
5381 // struct/union/class
5382
Reid Spencer5f016e22007-07-11 17:01:13 +00005383 // FIXME: Tag decls should be chained to any simultaneous vardecls, e.g.:
5384 // struct X { int A; } D; D should chain to X.
Douglas Gregor7adb10f2009-09-15 22:30:29 +00005385 if (getLangOptions().CPlusPlus) {
Ted Kremenek2b345eb2008-09-05 17:39:33 +00005386 // FIXME: Look for a way to use RecordDecl for simple structs.
Douglas Gregor741dd9a2009-07-21 14:46:17 +00005387 New = CXXRecordDecl::Create(Context, Kind, SearchDC, Loc, Name, KWLoc,
Douglas Gregor7df7b6b2008-12-15 16:32:14 +00005388 cast_or_null<CXXRecordDecl>(PrevDecl));
Douglas Gregor7adb10f2009-09-15 22:30:29 +00005389
5390 if (isStdBadAlloc && (!StdBadAlloc || StdBadAlloc->isImplicit()))
5391 StdBadAlloc = cast<CXXRecordDecl>(New);
5392 } else
Douglas Gregor741dd9a2009-07-21 14:46:17 +00005393 New = RecordDecl::Create(Context, Kind, SearchDC, Loc, Name, KWLoc,
Douglas Gregor7df7b6b2008-12-15 16:32:14 +00005394 cast_or_null<RecordDecl>(PrevDecl));
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +00005395 }
Douglas Gregor7df7b6b2008-12-15 16:32:14 +00005396
John McCallb6217662010-03-15 10:12:16 +00005397 // Maybe add qualifier info.
5398 if (SS.isNotEmpty()) {
Fariborz Jahanian4fb20532010-05-14 21:35:02 +00005399 if (SS.isSet()) {
5400 NestedNameSpecifier *NNS
5401 = static_cast<NestedNameSpecifier*>(SS.getScopeRep());
5402 New->setQualifierInfo(NNS, SS.getRange());
5403 }
5404 else
5405 Invalid = true;
John McCallb6217662010-03-15 10:12:16 +00005406 }
5407
Daniel Dunbar9f21f892010-05-27 01:53:40 +00005408 if (RecordDecl *RD = dyn_cast<RecordDecl>(New)) {
5409 // Add alignment attributes if necessary; these attributes are checked when
5410 // the ASTContext lays out the structure.
Douglas Gregor7df7b6b2008-12-15 16:32:14 +00005411 //
5412 // It is important for implementing the correct semantics that this
5413 // happen here (in act on tag decl). The #pragma pack stack is
5414 // maintained as a result of parser callbacks which can occur at
5415 // many points during the parsing of a struct declaration (because
5416 // the #pragma tokens are effectively skipped over during the
5417 // parsing of the struct).
Daniel Dunbar9f21f892010-05-27 01:53:40 +00005418 AddAlignmentAttributesForRecord(RD);
Douglas Gregor7df7b6b2008-12-15 16:32:14 +00005419 }
5420
Douglas Gregorf6b11852009-10-08 15:14:33 +00005421 // If this is a specialization of a member class (of a class template),
5422 // check the specialization.
John McCall68263142009-11-18 22:49:29 +00005423 if (isExplicitSpecialization && CheckMemberSpecialization(New, Previous))
Douglas Gregorf6b11852009-10-08 15:14:33 +00005424 Invalid = true;
Daniel Dunbar9f21f892010-05-27 01:53:40 +00005425
Douglas Gregor0b7a1582009-01-17 00:42:38 +00005426 if (Invalid)
5427 New->setInvalidDecl();
5428
Douglas Gregor7df7b6b2008-12-15 16:32:14 +00005429 if (Attr)
Douglas Gregor9cdda0c2009-06-17 21:51:59 +00005430 ProcessDeclAttributeList(S, New, Attr);
Douglas Gregor7df7b6b2008-12-15 16:32:14 +00005431
Douglas Gregor0b7a1582009-01-17 00:42:38 +00005432 // If we're declaring or defining a tag in function prototype scope
5433 // in C, note that this type can only be used within the function.
Douglas Gregor3218c4b2009-01-09 22:42:13 +00005434 if (Name && S->isFunctionPrototypeScope() && !getLangOptions().CPlusPlus)
5435 Diag(Loc, diag::warn_decl_in_param_list) << Context.getTagDeclType(New);
5436
Douglas Gregor7df7b6b2008-12-15 16:32:14 +00005437 // Set the lexical context. If the tag has a C++ scope specifier, the
5438 // lexical context will be different from the semantic context.
Douglas Gregor1931b442009-02-03 00:34:39 +00005439 New->setLexicalDeclContext(CurContext);
Douglas Gregor0b7a1582009-01-17 00:42:38 +00005440
John McCall02cace72009-08-28 07:59:38 +00005441 // Mark this as a friend decl if applicable.
5442 if (TUK == TUK_Friend)
John McCall68263142009-11-18 22:49:29 +00005443 New->setObjectOfFriendDecl(/* PreviouslyDeclared = */ !Previous.empty());
John McCall02cace72009-08-28 07:59:38 +00005444
Anders Carlsson0cf88302009-03-26 01:19:02 +00005445 // Set the access specifier.
John McCall9c86b512010-03-25 21:28:06 +00005446 if (!Invalid && SearchDC->isRecord())
Douglas Gregord0c87372009-05-27 17:30:49 +00005447 SetMemberAccessSpecifier(New, PrevDecl, AS);
Douglas Gregor06c0fec2009-03-25 22:00:53 +00005448
John McCall0f434ec2009-07-31 02:45:11 +00005449 if (TUK == TUK_Definition)
Douglas Gregor0b7a1582009-01-17 00:42:38 +00005450 New->startDefinition();
Mike Stump1eb44332009-09-09 15:08:12 +00005451
Reid Spencer5f016e22007-07-11 17:01:13 +00005452 // If this has an identifier, add it to the scope stack.
John McCalld7eff682009-09-02 00:55:30 +00005453 if (TUK == TUK_Friend) {
John McCall82b9fb82009-09-02 19:32:14 +00005454 // We might be replacing an existing declaration in the lookup tables;
5455 // if so, borrow its access specifier.
5456 if (PrevDecl)
5457 New->setAccess(PrevDecl->getAccess());
5458
John McCall9c86b512010-03-25 21:28:06 +00005459 DeclContext *DC = New->getDeclContext()->getLookupContext();
5460 DC->makeDeclVisibleInContext(New, /* Recoverable = */ false);
5461 if (Name) // can be null along some error paths
John McCalld7eff682009-09-02 00:55:30 +00005462 if (Scope *EnclosingScope = getScopeForDeclContext(S, DC))
5463 PushOnScopeChains(New, EnclosingScope, /* AddToContext = */ false);
John McCalld7eff682009-09-02 00:55:30 +00005464 } else if (Name) {
Douglas Gregor1a0d31a2009-01-12 18:45:55 +00005465 S = getNonFieldDeclScope(S);
Douglas Gregor1931b442009-02-03 00:34:39 +00005466 PushOnScopeChains(New, S);
Douglas Gregor4920f1f2009-01-12 22:49:06 +00005467 } else {
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00005468 CurContext->addDecl(New);
Reid Spencer5f016e22007-07-11 17:01:13 +00005469 }
Argyrios Kyrtzidis52393042008-11-09 23:41:00 +00005470
Douglas Gregorc29f77b2009-07-07 16:35:42 +00005471 // If this is the C FILE type, notify the AST context.
5472 if (IdentifierInfo *II = New->getIdentifier())
5473 if (!New->isInvalidDecl() &&
Mike Stump782fa302009-07-28 02:25:19 +00005474 New->getDeclContext()->getLookupContext()->isTranslationUnit() &&
Douglas Gregorc29f77b2009-07-07 16:35:42 +00005475 II->isStr("FILE"))
5476 Context.setFILEDecl(New);
Mike Stump1eb44332009-09-09 15:08:12 +00005477
Douglas Gregor402abb52009-05-28 23:31:59 +00005478 OwnedDecl = true;
Chris Lattnerb28317a2009-03-28 19:18:32 +00005479 return DeclPtrTy::make(New);
Reid Spencer5f016e22007-07-11 17:01:13 +00005480}
5481
Chris Lattnerb28317a2009-03-28 19:18:32 +00005482void Sema::ActOnTagStartDefinition(Scope *S, DeclPtrTy TagD) {
Douglas Gregoraaba5e32009-02-04 19:02:06 +00005483 AdjustDeclIfTemplate(TagD);
Chris Lattnerb28317a2009-03-28 19:18:32 +00005484 TagDecl *Tag = cast<TagDecl>(TagD.getAs<Decl>());
Douglas Gregor48c89f42010-04-24 16:38:41 +00005485
Douglas Gregor72de6672009-01-08 20:45:30 +00005486 // Enter the tag context.
5487 PushDeclContext(S, Tag);
John McCallf9368152009-12-20 07:58:13 +00005488}
Douglas Gregor72de6672009-01-08 20:45:30 +00005489
John McCallf9368152009-12-20 07:58:13 +00005490void Sema::ActOnStartCXXMemberDeclarations(Scope *S, DeclPtrTy TagD,
5491 SourceLocation LBraceLoc) {
5492 AdjustDeclIfTemplate(TagD);
5493 CXXRecordDecl *Record = cast<CXXRecordDecl>(TagD.getAs<Decl>());
Douglas Gregor72de6672009-01-08 20:45:30 +00005494
John McCallf9368152009-12-20 07:58:13 +00005495 FieldCollector->StartClass();
5496
5497 if (!Record->getIdentifier())
5498 return;
5499
5500 // C++ [class]p2:
5501 // [...] The class-name is also inserted into the scope of the
5502 // class itself; this is known as the injected-class-name. For
5503 // purposes of access checking, the injected-class-name is treated
5504 // as if it were a public member name.
5505 CXXRecordDecl *InjectedClassName
5506 = CXXRecordDecl::Create(Context, Record->getTagKind(),
5507 CurContext, Record->getLocation(),
5508 Record->getIdentifier(),
5509 Record->getTagKeywordLoc(),
5510 Record);
5511 InjectedClassName->setImplicit();
5512 InjectedClassName->setAccess(AS_public);
5513 if (ClassTemplateDecl *Template = Record->getDescribedClassTemplate())
5514 InjectedClassName->setDescribedClassTemplate(Template);
5515 PushOnScopeChains(InjectedClassName, S);
5516 assert(InjectedClassName->isInjectedClassName() &&
5517 "Broken injected-class-name");
Douglas Gregor72de6672009-01-08 20:45:30 +00005518}
5519
Argyrios Kyrtzidis07a5b282009-07-14 03:17:52 +00005520void Sema::ActOnTagFinishDefinition(Scope *S, DeclPtrTy TagD,
5521 SourceLocation RBraceLoc) {
Douglas Gregoraaba5e32009-02-04 19:02:06 +00005522 AdjustDeclIfTemplate(TagD);
Chris Lattnerb28317a2009-03-28 19:18:32 +00005523 TagDecl *Tag = cast<TagDecl>(TagD.getAs<Decl>());
Argyrios Kyrtzidis07a5b282009-07-14 03:17:52 +00005524 Tag->setRBraceLoc(RBraceLoc);
Douglas Gregor72de6672009-01-08 20:45:30 +00005525
5526 if (isa<CXXRecordDecl>(Tag))
5527 FieldCollector->FinishClass();
5528
5529 // Exit this scope of this tag's definition.
5530 PopDeclContext();
Douglas Gregoradda8462010-01-06 17:00:51 +00005531
Douglas Gregor72de6672009-01-08 20:45:30 +00005532 // Notify the consumer that we've defined a tag.
5533 Consumer.HandleTagDeclDefinition(Tag);
5534}
Chris Lattner5a6ddbf2008-06-21 19:39:06 +00005535
John McCalldb7bb4a2010-03-17 00:38:33 +00005536void Sema::ActOnTagDefinitionError(Scope *S, DeclPtrTy TagD) {
5537 AdjustDeclIfTemplate(TagD);
5538 TagDecl *Tag = cast<TagDecl>(TagD.getAs<Decl>());
John McCalldb7bb4a2010-03-17 00:38:33 +00005539 Tag->setInvalidDecl();
5540
John McCalla8cab012010-03-17 19:25:57 +00005541 // We're undoing ActOnTagStartDefinition here, not
5542 // ActOnStartCXXMemberDeclarations, so we don't have to mess with
5543 // the FieldCollector.
John McCalldb7bb4a2010-03-17 00:38:33 +00005544
5545 PopDeclContext();
5546}
5547
Chris Lattnerdf9bcd52009-04-20 17:29:38 +00005548// Note that FieldName may be null for anonymous bitfields.
Mike Stump1eb44332009-09-09 15:08:12 +00005549bool Sema::VerifyBitField(SourceLocation FieldLoc, IdentifierInfo *FieldName,
Eli Friedman1d954f62009-08-15 21:55:26 +00005550 QualType FieldTy, const Expr *BitWidth,
5551 bool *ZeroWidth) {
5552 // Default to true; that shouldn't confuse checks for emptiness
5553 if (ZeroWidth)
5554 *ZeroWidth = true;
5555
Chris Lattner24793662009-03-05 22:45:59 +00005556 // C99 6.7.2.1p4 - verify the field type.
Chris Lattner8b963ef2009-03-05 23:01:03 +00005557 // C++ 9.6p3: A bit-field shall have integral or enumeration type.
Douglas Gregor3cf538d2009-03-11 18:59:21 +00005558 if (!FieldTy->isDependentType() && !FieldTy->isIntegralType()) {
Chris Lattner24793662009-03-05 22:45:59 +00005559 // Handle incomplete types with specific error.
Douglas Gregora03aca82009-03-10 21:58:27 +00005560 if (RequireCompleteType(FieldLoc, FieldTy, diag::err_field_incomplete))
5561 return true;
Chris Lattnerdf9bcd52009-04-20 17:29:38 +00005562 if (FieldName)
5563 return Diag(FieldLoc, diag::err_not_integral_type_bitfield)
5564 << FieldName << FieldTy << BitWidth->getSourceRange();
5565 return Diag(FieldLoc, diag::err_not_integral_type_anon_bitfield)
5566 << FieldTy << BitWidth->getSourceRange();
Chris Lattner24793662009-03-05 22:45:59 +00005567 }
Douglas Gregor3cf538d2009-03-11 18:59:21 +00005568
5569 // If the bit-width is type- or value-dependent, don't try to check
5570 // it now.
5571 if (BitWidth->isValueDependent() || BitWidth->isTypeDependent())
5572 return false;
5573
Anders Carlsson9f1e5722008-12-06 20:33:04 +00005574 llvm::APSInt Value;
5575 if (VerifyIntegerConstantExpression(BitWidth, &Value))
5576 return true;
5577
Eli Friedman1d954f62009-08-15 21:55:26 +00005578 if (Value != 0 && ZeroWidth)
5579 *ZeroWidth = false;
5580
Chris Lattnercd087072008-12-12 04:56:04 +00005581 // Zero-width bitfield is ok for anonymous field.
5582 if (Value == 0 && FieldName)
5583 return Diag(FieldLoc, diag::err_bitfield_has_zero_width) << FieldName;
Mike Stump1eb44332009-09-09 15:08:12 +00005584
Chris Lattnerdf9bcd52009-04-20 17:29:38 +00005585 if (Value.isSigned() && Value.isNegative()) {
5586 if (FieldName)
Mike Stump1eb44332009-09-09 15:08:12 +00005587 return Diag(FieldLoc, diag::err_bitfield_has_negative_width)
Chris Lattnerdf9bcd52009-04-20 17:29:38 +00005588 << FieldName << Value.toString(10);
5589 return Diag(FieldLoc, diag::err_anon_bitfield_has_negative_width)
5590 << Value.toString(10);
5591 }
Anders Carlsson9f1e5722008-12-06 20:33:04 +00005592
Douglas Gregor3cf538d2009-03-11 18:59:21 +00005593 if (!FieldTy->isDependentType()) {
5594 uint64_t TypeSize = Context.getTypeSize(FieldTy);
Chris Lattnerdf9bcd52009-04-20 17:29:38 +00005595 if (Value.getZExtValue() > TypeSize) {
Anders Carlsson72468ec2010-04-16 15:16:32 +00005596 if (!getLangOptions().CPlusPlus) {
5597 if (FieldName)
5598 return Diag(FieldLoc, diag::err_bitfield_width_exceeds_type_size)
5599 << FieldName << (unsigned)Value.getZExtValue()
5600 << (unsigned)TypeSize;
5601
5602 return Diag(FieldLoc, diag::err_anon_bitfield_width_exceeds_type_size)
5603 << (unsigned)Value.getZExtValue() << (unsigned)TypeSize;
5604 }
5605
Chris Lattnerdf9bcd52009-04-20 17:29:38 +00005606 if (FieldName)
Anders Carlsson72468ec2010-04-16 15:16:32 +00005607 Diag(FieldLoc, diag::warn_bitfield_width_exceeds_type_size)
5608 << FieldName << (unsigned)Value.getZExtValue()
5609 << (unsigned)TypeSize;
5610 else
5611 Diag(FieldLoc, diag::warn_anon_bitfield_width_exceeds_type_size)
5612 << (unsigned)Value.getZExtValue() << (unsigned)TypeSize;
Chris Lattnerdf9bcd52009-04-20 17:29:38 +00005613 }
Douglas Gregor3cf538d2009-03-11 18:59:21 +00005614 }
Anders Carlsson9f1e5722008-12-06 20:33:04 +00005615
5616 return false;
5617}
5618
Steve Naroff08d92e42007-09-15 18:49:24 +00005619/// ActOnField - Each field of a struct/union/class is passed into this in order
Reid Spencer5f016e22007-07-11 17:01:13 +00005620/// to create a FieldDecl object for it.
Chris Lattnerb28317a2009-03-28 19:18:32 +00005621Sema::DeclPtrTy Sema::ActOnField(Scope *S, DeclPtrTy TagD,
Mike Stump1eb44332009-09-09 15:08:12 +00005622 SourceLocation DeclStart,
Chris Lattnerb28317a2009-03-28 19:18:32 +00005623 Declarator &D, ExprTy *BitfieldWidth) {
5624 FieldDecl *Res = HandleField(S, cast_or_null<RecordDecl>(TagD.getAs<Decl>()),
5625 DeclStart, D, static_cast<Expr*>(BitfieldWidth),
5626 AS_public);
5627 return DeclPtrTy::make(Res);
Chris Lattner24793662009-03-05 22:45:59 +00005628}
5629
5630/// HandleField - Analyze a field of a C struct or a C++ data member.
5631///
5632FieldDecl *Sema::HandleField(Scope *S, RecordDecl *Record,
5633 SourceLocation DeclStart,
Douglas Gregor4dd55f52009-03-11 20:50:30 +00005634 Declarator &D, Expr *BitWidth,
5635 AccessSpecifier AS) {
Reid Spencer5f016e22007-07-11 17:01:13 +00005636 IdentifierInfo *II = D.getIdentifier();
Reid Spencer5f016e22007-07-11 17:01:13 +00005637 SourceLocation Loc = DeclStart;
5638 if (II) Loc = D.getIdentifierLoc();
Mike Stump1eb44332009-09-09 15:08:12 +00005639
John McCallbf1a0282010-06-04 23:28:52 +00005640 TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S);
5641 QualType T = TInfo->getType();
Chris Lattner6491f472009-04-12 22:15:02 +00005642 if (getLangOptions().CPlusPlus)
Douglas Gregor3cf538d2009-03-11 18:59:21 +00005643 CheckExtraCXXDefaultArguments(D);
Douglas Gregor021c3b32009-03-11 23:00:04 +00005644
Eli Friedman85a53192009-04-07 19:37:57 +00005645 DiagnoseFunctionSpecifiers(D);
5646
Eli Friedman63054b32009-04-19 20:27:55 +00005647 if (D.getDeclSpec().isThreadSpecified())
5648 Diag(D.getDeclSpec().getThreadSpecLoc(), diag::err_invalid_thread);
5649
Douglas Gregorc83c6872010-04-15 22:33:43 +00005650 NamedDecl *PrevDecl = LookupSingleName(S, II, Loc, LookupMemberName,
John McCall7d384dd2009-11-18 07:57:50 +00005651 ForRedeclaration);
Douglas Gregorc19ee3e2009-06-17 23:37:01 +00005652
5653 if (PrevDecl && PrevDecl->isTemplateParameter()) {
5654 // Maybe we will complain about the shadowed template parameter.
5655 DiagnoseTemplateParameterShadow(D.getIdentifierLoc(), PrevDecl);
5656 // Just pretend that we didn't see the previous declaration.
5657 PrevDecl = 0;
5658 }
5659
Douglas Gregor3cf538d2009-03-11 18:59:21 +00005660 if (PrevDecl && !isDeclInScope(PrevDecl, Record, S))
5661 PrevDecl = 0;
5662
Steve Naroffea218b82009-07-14 14:58:18 +00005663 bool Mutable
5664 = (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_mutable);
5665 SourceLocation TSSL = D.getSourceRange().getBegin();
5666 FieldDecl *NewFD
John McCalla93c9342009-12-07 02:54:59 +00005667 = CheckFieldDecl(II, T, TInfo, Record, Loc, Mutable, BitWidth, TSSL,
Steve Naroffea218b82009-07-14 14:58:18 +00005668 AS, PrevDecl, &D);
Rafael Espindola01620702010-03-21 22:56:43 +00005669
5670 if (NewFD->isInvalidDecl())
5671 Record->setInvalidDecl();
5672
Douglas Gregor3cf538d2009-03-11 18:59:21 +00005673 if (NewFD->isInvalidDecl() && PrevDecl) {
5674 // Don't introduce NewFD into scope; there's already something
5675 // with the same name in the same scope.
5676 } else if (II) {
5677 PushOnScopeChains(NewFD, S);
5678 } else
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00005679 Record->addDecl(NewFD);
Douglas Gregor3cf538d2009-03-11 18:59:21 +00005680
5681 return NewFD;
5682}
5683
5684/// \brief Build a new FieldDecl and check its well-formedness.
5685///
5686/// This routine builds a new FieldDecl given the fields name, type,
5687/// record, etc. \p PrevDecl should refer to any previous declaration
5688/// with the same name and in the same scope as the field to be
5689/// created.
5690///
5691/// \returns a new FieldDecl.
5692///
Mike Stump1eb44332009-09-09 15:08:12 +00005693/// \todo The Declarator argument is a hack. It will be removed once
Argyrios Kyrtzidisa1d56622009-08-19 01:27:57 +00005694FieldDecl *Sema::CheckFieldDecl(DeclarationName Name, QualType T,
John McCalla93c9342009-12-07 02:54:59 +00005695 TypeSourceInfo *TInfo,
Douglas Gregor3cf538d2009-03-11 18:59:21 +00005696 RecordDecl *Record, SourceLocation Loc,
Mike Stump1eb44332009-09-09 15:08:12 +00005697 bool Mutable, Expr *BitWidth,
Steve Naroffea218b82009-07-14 14:58:18 +00005698 SourceLocation TSSL,
Douglas Gregor4dd55f52009-03-11 20:50:30 +00005699 AccessSpecifier AS, NamedDecl *PrevDecl,
Douglas Gregor3cf538d2009-03-11 18:59:21 +00005700 Declarator *D) {
5701 IdentifierInfo *II = Name.getAsIdentifierInfo();
Steve Naroff5912a352007-08-28 20:14:24 +00005702 bool InvalidDecl = false;
Chris Lattnereaaebc72009-04-25 08:06:05 +00005703 if (D) InvalidDecl = D->isInvalidType();
Sebastian Redl64b45f72009-01-05 20:52:13 +00005704
Douglas Gregor3cf538d2009-03-11 18:59:21 +00005705 // If we receive a broken type, recover by assuming 'int' and
5706 // marking this declaration as invalid.
5707 if (T.isNull()) {
5708 InvalidDecl = true;
5709 T = Context.IntTy;
5710 }
5711
Eli Friedman721e77d2009-12-07 00:22:08 +00005712 QualType EltTy = Context.getBaseElementType(T);
5713 if (!EltTy->isDependentType() &&
5714 RequireCompleteType(Loc, EltTy, diag::err_field_incomplete))
5715 InvalidDecl = true;
5716
Reid Spencer5f016e22007-07-11 17:01:13 +00005717 // C99 6.7.2.1p8: A member of a structure or union may have any type other
5718 // than a variably modified type.
Eli Friedman721e77d2009-12-07 00:22:08 +00005719 if (!InvalidDecl && T->isVariablyModifiedType()) {
Eli Friedman1ca48132009-02-21 00:44:51 +00005720 bool SizeIsNegative;
5721 QualType FixedTy = TryToFixInvalidVariablyModifiedType(T, Context,
5722 SizeIsNegative);
5723 if (!FixedTy.isNull()) {
5724 Diag(Loc, diag::warn_illegal_constant_array_size);
5725 T = FixedTy;
5726 } else {
5727 if (SizeIsNegative)
5728 Diag(Loc, diag::err_typecheck_negative_array_size);
5729 else
5730 Diag(Loc, diag::err_typecheck_field_variable_size);
Eli Friedman1ca48132009-02-21 00:44:51 +00005731 InvalidDecl = true;
5732 }
Reid Spencer5f016e22007-07-11 17:01:13 +00005733 }
Mike Stump1eb44332009-09-09 15:08:12 +00005734
Anders Carlsson4681ebd2009-03-22 20:18:17 +00005735 // Fields can not have abstract class types
Eli Friedman721e77d2009-12-07 00:22:08 +00005736 if (!InvalidDecl && RequireNonAbstractType(Loc, T,
5737 diag::err_abstract_type_in_decl,
5738 AbstractFieldType))
Anders Carlsson4681ebd2009-03-22 20:18:17 +00005739 InvalidDecl = true;
Mike Stump1eb44332009-09-09 15:08:12 +00005740
Eli Friedman1d954f62009-08-15 21:55:26 +00005741 bool ZeroWidth = false;
Douglas Gregor3cf538d2009-03-11 18:59:21 +00005742 // If this is declared as a bit-field, check the bit-field.
Eli Friedman721e77d2009-12-07 00:22:08 +00005743 if (!InvalidDecl && BitWidth &&
5744 VerifyBitField(Loc, II, T, BitWidth, &ZeroWidth)) {
Douglas Gregor3cf538d2009-03-11 18:59:21 +00005745 InvalidDecl = true;
5746 DeleteExpr(BitWidth);
5747 BitWidth = 0;
Eli Friedman1d954f62009-08-15 21:55:26 +00005748 ZeroWidth = false;
Anders Carlsson9f1e5722008-12-06 20:33:04 +00005749 }
Mike Stump1eb44332009-09-09 15:08:12 +00005750
John McCall4bde1e12010-06-04 08:34:12 +00005751 // Check that 'mutable' is consistent with the type of the declaration.
5752 if (!InvalidDecl && Mutable) {
5753 unsigned DiagID = 0;
5754 if (T->isReferenceType())
5755 DiagID = diag::err_mutable_reference;
5756 else if (T.isConstQualified())
5757 DiagID = diag::err_mutable_const;
5758
5759 if (DiagID) {
5760 SourceLocation ErrLoc = Loc;
5761 if (D && D->getDeclSpec().getStorageClassSpecLoc().isValid())
5762 ErrLoc = D->getDeclSpec().getStorageClassSpecLoc();
5763 Diag(ErrLoc, DiagID);
5764 Mutable = false;
5765 InvalidDecl = true;
5766 }
5767 }
5768
John McCalla93c9342009-12-07 02:54:59 +00005769 FieldDecl *NewFD = FieldDecl::Create(Context, Record, Loc, II, T, TInfo,
Argyrios Kyrtzidisa5d82002009-08-21 00:31:54 +00005770 BitWidth, Mutable);
Chris Lattnereaaebc72009-04-25 08:06:05 +00005771 if (InvalidDecl)
5772 NewFD->setInvalidDecl();
Douglas Gregor44b43212008-12-11 16:49:14 +00005773
Douglas Gregor3cf538d2009-03-11 18:59:21 +00005774 if (PrevDecl && !isa<TagDecl>(PrevDecl)) {
5775 Diag(Loc, diag::err_duplicate_member) << II;
5776 Diag(PrevDecl->getLocation(), diag::note_previous_declaration);
5777 NewFD->setInvalidDecl();
Douglas Gregor72de6672009-01-08 20:45:30 +00005778 }
5779
John McCall86ff3082010-02-04 22:26:26 +00005780 if (!InvalidDecl && getLangOptions().CPlusPlus) {
Eli Friedman1d954f62009-08-15 21:55:26 +00005781 CXXRecordDecl* CXXRecord = cast<CXXRecordDecl>(Record);
5782
5783 if (!T->isPODType())
5784 CXXRecord->setPOD(false);
5785 if (!ZeroWidth)
5786 CXXRecord->setEmpty(false);
5787
Ted Kremenek6217b802009-07-29 21:53:49 +00005788 if (const RecordType *RT = EltTy->getAs<RecordType>()) {
Douglas Gregor1f2023a2009-07-22 18:25:24 +00005789 CXXRecordDecl* RDecl = cast<CXXRecordDecl>(RT->getDecl());
5790
5791 if (!RDecl->hasTrivialConstructor())
Eli Friedman1d954f62009-08-15 21:55:26 +00005792 CXXRecord->setHasTrivialConstructor(false);
Douglas Gregor1f2023a2009-07-22 18:25:24 +00005793 if (!RDecl->hasTrivialCopyConstructor())
Eli Friedman1d954f62009-08-15 21:55:26 +00005794 CXXRecord->setHasTrivialCopyConstructor(false);
Douglas Gregor1f2023a2009-07-22 18:25:24 +00005795 if (!RDecl->hasTrivialCopyAssignment())
Eli Friedman1d954f62009-08-15 21:55:26 +00005796 CXXRecord->setHasTrivialCopyAssignment(false);
Douglas Gregor1f2023a2009-07-22 18:25:24 +00005797 if (!RDecl->hasTrivialDestructor())
Eli Friedman1d954f62009-08-15 21:55:26 +00005798 CXXRecord->setHasTrivialDestructor(false);
Douglas Gregor1f2023a2009-07-22 18:25:24 +00005799
5800 // C++ 9.5p1: An object of a class with a non-trivial
5801 // constructor, a non-trivial copy constructor, a non-trivial
5802 // destructor, or a non-trivial copy assignment operator
5803 // cannot be a member of a union, nor can an array of such
5804 // objects.
5805 // TODO: C++0x alters this restriction significantly.
5806 if (Record->isUnion()) {
5807 // We check for copy constructors before constructors
5808 // because otherwise we'll never get complaints about
5809 // copy constructors.
5810
Anders Carlsson3b8c53b2010-04-22 05:40:53 +00005811 CXXSpecialMember member = CXXInvalid;
Douglas Gregor1f2023a2009-07-22 18:25:24 +00005812 if (!RDecl->hasTrivialCopyConstructor())
5813 member = CXXCopyConstructor;
5814 else if (!RDecl->hasTrivialConstructor())
Anders Carlsson3b8c53b2010-04-22 05:40:53 +00005815 member = CXXConstructor;
Douglas Gregor1f2023a2009-07-22 18:25:24 +00005816 else if (!RDecl->hasTrivialCopyAssignment())
5817 member = CXXCopyAssignment;
5818 else if (!RDecl->hasTrivialDestructor())
5819 member = CXXDestructor;
Douglas Gregor1f2023a2009-07-22 18:25:24 +00005820
Anders Carlsson3b8c53b2010-04-22 05:40:53 +00005821 if (member != CXXInvalid) {
Douglas Gregor1f2023a2009-07-22 18:25:24 +00005822 Diag(Loc, diag::err_illegal_union_member) << Name << member;
5823 DiagnoseNontrivial(RT, member);
5824 NewFD->setInvalidDecl();
5825 }
5826 }
5827 }
5828 }
5829
Douglas Gregor3cf538d2009-03-11 18:59:21 +00005830 // FIXME: We need to pass in the attributes given an AST
5831 // representation, not a parser representation.
5832 if (D)
Douglas Gregor9cdda0c2009-06-17 21:51:59 +00005833 // FIXME: What to pass instead of TUScope?
5834 ProcessDeclAttributes(TUScope, NewFD, *D);
Douglas Gregor3cf538d2009-03-11 18:59:21 +00005835
Fariborz Jahanianf6123ca2009-02-19 00:22:47 +00005836 if (T.isObjCGCWeak())
Fariborz Jahanianed7e9ef2009-02-18 18:14:41 +00005837 Diag(Loc, diag::warn_attribute_weak_on_field);
Anders Carlssonad148062008-02-16 00:29:18 +00005838
Douglas Gregor4dd55f52009-03-11 20:50:30 +00005839 NewFD->setAccess(AS);
5840
5841 // C++ [dcl.init.aggr]p1:
5842 // An aggregate is an array or a class (clause 9) with [...] no
5843 // private or protected non-static data members (clause 11).
5844 // A POD must be an aggregate.
5845 if (getLangOptions().CPlusPlus &&
5846 (AS == AS_private || AS == AS_protected)) {
5847 CXXRecordDecl *CXXRecord = cast<CXXRecordDecl>(Record);
5848 CXXRecord->setAggregate(false);
5849 CXXRecord->setPOD(false);
5850 }
5851
Steve Naroff5912a352007-08-28 20:14:24 +00005852 return NewFD;
Reid Spencer5f016e22007-07-11 17:01:13 +00005853}
5854
Douglas Gregor1f2023a2009-07-22 18:25:24 +00005855/// DiagnoseNontrivial - Given that a class has a non-trivial
5856/// special member, figure out why.
5857void Sema::DiagnoseNontrivial(const RecordType* T, CXXSpecialMember member) {
5858 QualType QT(T, 0U);
5859 CXXRecordDecl* RD = cast<CXXRecordDecl>(T->getDecl());
5860
5861 // Check whether the member was user-declared.
5862 switch (member) {
Douglas Gregor66dd9392010-04-22 14:36:26 +00005863 case CXXInvalid:
5864 break;
5865
Anders Carlsson3b8c53b2010-04-22 05:40:53 +00005866 case CXXConstructor:
Douglas Gregor1f2023a2009-07-22 18:25:24 +00005867 if (RD->hasUserDeclaredConstructor()) {
5868 typedef CXXRecordDecl::ctor_iterator ctor_iter;
Sebastian Redl38fd4d02009-10-25 22:31:45 +00005869 for (ctor_iter ci = RD->ctor_begin(), ce = RD->ctor_end(); ci != ce;++ci){
5870 const FunctionDecl *body = 0;
5871 ci->getBody(body);
Anders Carlsson10dc0f82010-04-20 23:32:58 +00005872 if (!body || !cast<CXXConstructorDecl>(body)->isImplicitlyDefined()) {
Douglas Gregor1f2023a2009-07-22 18:25:24 +00005873 SourceLocation CtorLoc = ci->getLocation();
5874 Diag(CtorLoc, diag::note_nontrivial_user_defined) << QT << member;
5875 return;
5876 }
Sebastian Redl38fd4d02009-10-25 22:31:45 +00005877 }
Douglas Gregor1f2023a2009-07-22 18:25:24 +00005878
5879 assert(0 && "found no user-declared constructors");
5880 return;
5881 }
5882 break;
5883
5884 case CXXCopyConstructor:
5885 if (RD->hasUserDeclaredCopyConstructor()) {
5886 SourceLocation CtorLoc =
5887 RD->getCopyConstructor(Context, 0)->getLocation();
5888 Diag(CtorLoc, diag::note_nontrivial_user_defined) << QT << member;
5889 return;
5890 }
5891 break;
5892
5893 case CXXCopyAssignment:
5894 if (RD->hasUserDeclaredCopyAssignment()) {
5895 // FIXME: this should use the location of the copy
5896 // assignment, not the type.
5897 SourceLocation TyLoc = RD->getSourceRange().getBegin();
5898 Diag(TyLoc, diag::note_nontrivial_user_defined) << QT << member;
5899 return;
5900 }
5901 break;
5902
5903 case CXXDestructor:
5904 if (RD->hasUserDeclaredDestructor()) {
5905 SourceLocation DtorLoc = RD->getDestructor(Context)->getLocation();
5906 Diag(DtorLoc, diag::note_nontrivial_user_defined) << QT << member;
5907 return;
5908 }
5909 break;
5910 }
5911
5912 typedef CXXRecordDecl::base_class_iterator base_iter;
5913
5914 // Virtual bases and members inhibit trivial copying/construction,
5915 // but not trivial destruction.
5916 if (member != CXXDestructor) {
5917 // Check for virtual bases. vbases includes indirect virtual bases,
5918 // so we just iterate through the direct bases.
5919 for (base_iter bi = RD->bases_begin(), be = RD->bases_end(); bi != be; ++bi)
5920 if (bi->isVirtual()) {
5921 SourceLocation BaseLoc = bi->getSourceRange().getBegin();
5922 Diag(BaseLoc, diag::note_nontrivial_has_virtual) << QT << 1;
5923 return;
5924 }
5925
5926 // Check for virtual methods.
5927 typedef CXXRecordDecl::method_iterator meth_iter;
5928 for (meth_iter mi = RD->method_begin(), me = RD->method_end(); mi != me;
5929 ++mi) {
5930 if (mi->isVirtual()) {
5931 SourceLocation MLoc = mi->getSourceRange().getBegin();
5932 Diag(MLoc, diag::note_nontrivial_has_virtual) << QT << 0;
5933 return;
5934 }
5935 }
5936 }
Mike Stump1eb44332009-09-09 15:08:12 +00005937
Douglas Gregor1f2023a2009-07-22 18:25:24 +00005938 bool (CXXRecordDecl::*hasTrivial)() const;
5939 switch (member) {
Anders Carlsson3b8c53b2010-04-22 05:40:53 +00005940 case CXXConstructor:
Douglas Gregor1f2023a2009-07-22 18:25:24 +00005941 hasTrivial = &CXXRecordDecl::hasTrivialConstructor; break;
5942 case CXXCopyConstructor:
5943 hasTrivial = &CXXRecordDecl::hasTrivialCopyConstructor; break;
5944 case CXXCopyAssignment:
5945 hasTrivial = &CXXRecordDecl::hasTrivialCopyAssignment; break;
5946 case CXXDestructor:
5947 hasTrivial = &CXXRecordDecl::hasTrivialDestructor; break;
5948 default:
5949 assert(0 && "unexpected special member"); return;
5950 }
5951
5952 // Check for nontrivial bases (and recurse).
5953 for (base_iter bi = RD->bases_begin(), be = RD->bases_end(); bi != be; ++bi) {
Ted Kremenek6217b802009-07-29 21:53:49 +00005954 const RecordType *BaseRT = bi->getType()->getAs<RecordType>();
Sebastian Redl9994a342009-10-25 17:03:50 +00005955 assert(BaseRT && "Don't know how to handle dependent bases");
Douglas Gregor1f2023a2009-07-22 18:25:24 +00005956 CXXRecordDecl *BaseRecTy = cast<CXXRecordDecl>(BaseRT->getDecl());
5957 if (!(BaseRecTy->*hasTrivial)()) {
5958 SourceLocation BaseLoc = bi->getSourceRange().getBegin();
5959 Diag(BaseLoc, diag::note_nontrivial_has_nontrivial) << QT << 1 << member;
5960 DiagnoseNontrivial(BaseRT, member);
5961 return;
5962 }
5963 }
Mike Stump1eb44332009-09-09 15:08:12 +00005964
Douglas Gregor1f2023a2009-07-22 18:25:24 +00005965 // Check for nontrivial members (and recurse).
5966 typedef RecordDecl::field_iterator field_iter;
5967 for (field_iter fi = RD->field_begin(), fe = RD->field_end(); fi != fe;
5968 ++fi) {
Douglas Gregor5e03f9e2009-07-23 23:49:00 +00005969 QualType EltTy = Context.getBaseElementType((*fi)->getType());
Ted Kremenek6217b802009-07-29 21:53:49 +00005970 if (const RecordType *EltRT = EltTy->getAs<RecordType>()) {
Douglas Gregor1f2023a2009-07-22 18:25:24 +00005971 CXXRecordDecl* EltRD = cast<CXXRecordDecl>(EltRT->getDecl());
5972
5973 if (!(EltRD->*hasTrivial)()) {
5974 SourceLocation FLoc = (*fi)->getLocation();
5975 Diag(FLoc, diag::note_nontrivial_has_nontrivial) << QT << 0 << member;
5976 DiagnoseNontrivial(EltRT, member);
5977 return;
5978 }
5979 }
5980 }
5981
5982 assert(0 && "found no explanation for non-trivial member");
5983}
5984
Mike Stump1eb44332009-09-09 15:08:12 +00005985/// TranslateIvarVisibility - Translate visibility from a token ID to an
Fariborz Jahanian89204a12007-10-01 16:53:59 +00005986/// AST enum value.
Ted Kremeneka526c5c2008-01-07 19:49:32 +00005987static ObjCIvarDecl::AccessControl
Fariborz Jahanian89204a12007-10-01 16:53:59 +00005988TranslateIvarVisibility(tok::ObjCKeywordKind ivarVisibility) {
Steve Narofff13271f2007-09-14 23:09:53 +00005989 switch (ivarVisibility) {
Chris Lattner33d34a62008-10-12 00:28:42 +00005990 default: assert(0 && "Unknown visitibility kind");
5991 case tok::objc_private: return ObjCIvarDecl::Private;
5992 case tok::objc_public: return ObjCIvarDecl::Public;
5993 case tok::objc_protected: return ObjCIvarDecl::Protected;
5994 case tok::objc_package: return ObjCIvarDecl::Package;
Steve Narofff13271f2007-09-14 23:09:53 +00005995 }
5996}
5997
Mike Stump1eb44332009-09-09 15:08:12 +00005998/// ActOnIvar - Each ivar field of an objective-c class is passed into this
Fariborz Jahanian45bc03f2008-04-11 16:55:42 +00005999/// in order to create an IvarDecl object for it.
Chris Lattnerb28317a2009-03-28 19:18:32 +00006000Sema::DeclPtrTy Sema::ActOnIvar(Scope *S,
Mike Stump1eb44332009-09-09 15:08:12 +00006001 SourceLocation DeclStart,
Fariborz Jahanian496b5a82009-06-05 18:16:35 +00006002 DeclPtrTy IntfDecl,
Chris Lattnerb28317a2009-03-28 19:18:32 +00006003 Declarator &D, ExprTy *BitfieldWidth,
6004 tok::ObjCKeywordKind Visibility) {
Mike Stump1eb44332009-09-09 15:08:12 +00006005
Fariborz Jahanian1d78cc42008-04-10 23:32:45 +00006006 IdentifierInfo *II = D.getIdentifier();
6007 Expr *BitWidth = (Expr*)BitfieldWidth;
6008 SourceLocation Loc = DeclStart;
6009 if (II) Loc = D.getIdentifierLoc();
Mike Stump1eb44332009-09-09 15:08:12 +00006010
Fariborz Jahanian1d78cc42008-04-10 23:32:45 +00006011 // FIXME: Unnamed fields can be handled in various different ways, for
6012 // example, unnamed unions inject all members into the struct namespace!
Mike Stump1eb44332009-09-09 15:08:12 +00006013
John McCallbf1a0282010-06-04 23:28:52 +00006014 TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S);
6015 QualType T = TInfo->getType();
Mike Stump1eb44332009-09-09 15:08:12 +00006016
Fariborz Jahanian1d78cc42008-04-10 23:32:45 +00006017 if (BitWidth) {
Steve Naroff63359c82009-02-20 17:57:11 +00006018 // 6.7.2.1p3, 6.7.2.1p4
Chris Lattner24793662009-03-05 22:45:59 +00006019 if (VerifyBitField(Loc, II, T, BitWidth)) {
Chris Lattnereaaebc72009-04-25 08:06:05 +00006020 D.setInvalidType();
Chris Lattner24793662009-03-05 22:45:59 +00006021 DeleteExpr(BitWidth);
6022 BitWidth = 0;
6023 }
Fariborz Jahanian1d78cc42008-04-10 23:32:45 +00006024 } else {
6025 // Not a bitfield.
Mike Stump1eb44332009-09-09 15:08:12 +00006026
Fariborz Jahanian1d78cc42008-04-10 23:32:45 +00006027 // validate II.
Mike Stump1eb44332009-09-09 15:08:12 +00006028
Fariborz Jahanian1d78cc42008-04-10 23:32:45 +00006029 }
Fariborz Jahanian0b7bc8e2010-04-26 22:07:03 +00006030 if (T->isReferenceType()) {
6031 Diag(Loc, diag::err_ivar_reference_type);
6032 D.setInvalidType();
6033 }
Fariborz Jahanian1d78cc42008-04-10 23:32:45 +00006034 // C99 6.7.2.1p8: A member of a structure or union may have any type other
6035 // than a variably modified type.
Fariborz Jahanian0b7bc8e2010-04-26 22:07:03 +00006036 else if (T->isVariablyModifiedType()) {
Anders Carlsson96e05bc2008-12-07 00:20:55 +00006037 Diag(Loc, diag::err_typecheck_ivar_variable_size);
Chris Lattnereaaebc72009-04-25 08:06:05 +00006038 D.setInvalidType();
Fariborz Jahanian1d78cc42008-04-10 23:32:45 +00006039 }
Mike Stump1eb44332009-09-09 15:08:12 +00006040
Ted Kremenekb8db21d2008-07-23 18:04:17 +00006041 // Get the visibility (access control) for this ivar.
Mike Stump1eb44332009-09-09 15:08:12 +00006042 ObjCIvarDecl::AccessControl ac =
Ted Kremenekb8db21d2008-07-23 18:04:17 +00006043 Visibility != tok::objc_not_keyword ? TranslateIvarVisibility(Visibility)
6044 : ObjCIvarDecl::None;
Fariborz Jahanian496b5a82009-06-05 18:16:35 +00006045 // Must set ivar's DeclContext to its enclosing interface.
Daniel Dunbara19331f2010-04-02 18:29:09 +00006046 ObjCContainerDecl *EnclosingDecl = IntfDecl.getAs<ObjCContainerDecl>();
6047 ObjCContainerDecl *EnclosingContext;
Mike Stump1eb44332009-09-09 15:08:12 +00006048 if (ObjCImplementationDecl *IMPDecl =
Fariborz Jahanian496b5a82009-06-05 18:16:35 +00006049 dyn_cast<ObjCImplementationDecl>(EnclosingDecl)) {
6050 // Case of ivar declared in an implementation. Context is that of its class.
Daniel Dunbara19331f2010-04-02 18:29:09 +00006051 EnclosingContext = IMPDecl->getClassInterface();
6052 assert(EnclosingContext && "Implementation has no class interface!");
Fariborz Jahanian0bd04592010-04-06 22:43:48 +00006053 } else {
6054 if (ObjCCategoryDecl *CDecl =
6055 dyn_cast<ObjCCategoryDecl>(EnclosingDecl)) {
6056 if (!LangOpts.ObjCNonFragileABI2 || !CDecl->IsClassExtension()) {
6057 Diag(Loc, diag::err_misplaced_ivar) << CDecl->IsClassExtension();
6058 return DeclPtrTy();
6059 }
6060 }
Daniel Dunbara19331f2010-04-02 18:29:09 +00006061 EnclosingContext = EnclosingDecl;
Fariborz Jahanian0bd04592010-04-06 22:43:48 +00006062 }
Mike Stump1eb44332009-09-09 15:08:12 +00006063
Ted Kremenekb8db21d2008-07-23 18:04:17 +00006064 // Construct the decl.
Mike Stump1eb44332009-09-09 15:08:12 +00006065 ObjCIvarDecl *NewID = ObjCIvarDecl::Create(Context,
Argyrios Kyrtzidisa1d56622009-08-19 01:27:57 +00006066 EnclosingContext, Loc, II, T,
John McCalla93c9342009-12-07 02:54:59 +00006067 TInfo, ac, (Expr *)BitfieldWidth);
Mike Stump1eb44332009-09-09 15:08:12 +00006068
Douglas Gregor72de6672009-01-08 20:45:30 +00006069 if (II) {
Douglas Gregorc83c6872010-04-15 22:33:43 +00006070 NamedDecl *PrevDecl = LookupSingleName(S, II, Loc, LookupMemberName,
John McCall7d384dd2009-11-18 07:57:50 +00006071 ForRedeclaration);
Fariborz Jahanian496b5a82009-06-05 18:16:35 +00006072 if (PrevDecl && isDeclInScope(PrevDecl, EnclosingContext, S)
Douglas Gregor72de6672009-01-08 20:45:30 +00006073 && !isa<TagDecl>(PrevDecl)) {
6074 Diag(Loc, diag::err_duplicate_member) << II;
6075 Diag(PrevDecl->getLocation(), diag::note_previous_declaration);
6076 NewID->setInvalidDecl();
6077 }
6078 }
6079
Ted Kremenekb8db21d2008-07-23 18:04:17 +00006080 // Process attributes attached to the ivar.
Douglas Gregor9cdda0c2009-06-17 21:51:59 +00006081 ProcessDeclAttributes(S, NewID, D);
Mike Stump1eb44332009-09-09 15:08:12 +00006082
Chris Lattnereaaebc72009-04-25 08:06:05 +00006083 if (D.isInvalidType())
Fariborz Jahanian1d78cc42008-04-10 23:32:45 +00006084 NewID->setInvalidDecl();
Ted Kremenekb8db21d2008-07-23 18:04:17 +00006085
Douglas Gregor72de6672009-01-08 20:45:30 +00006086 if (II) {
6087 // FIXME: When interfaces are DeclContexts, we'll need to add
6088 // these to the interface.
Chris Lattnerb28317a2009-03-28 19:18:32 +00006089 S->AddDecl(DeclPtrTy::make(NewID));
Douglas Gregor72de6672009-01-08 20:45:30 +00006090 IdResolver.AddDecl(NewID);
6091 }
6092
Chris Lattnerb28317a2009-03-28 19:18:32 +00006093 return DeclPtrTy::make(NewID);
Fariborz Jahanian1d78cc42008-04-10 23:32:45 +00006094}
6095
Fariborz Jahanian9d048ff2007-09-29 00:54:24 +00006096void Sema::ActOnFields(Scope* S,
Chris Lattnerb28317a2009-03-28 19:18:32 +00006097 SourceLocation RecLoc, DeclPtrTy RecDecl,
6098 DeclPtrTy *Fields, unsigned NumFields,
Daniel Dunbar1bfe1c22008-10-03 02:03:53 +00006099 SourceLocation LBrac, SourceLocation RBrac,
Daniel Dunbar7d076642008-10-03 17:33:35 +00006100 AttributeList *Attr) {
Chris Lattnerb28317a2009-03-28 19:18:32 +00006101 Decl *EnclosingDecl = RecDecl.getAs<Decl>();
Steve Naroff74216642007-09-14 22:20:54 +00006102 assert(EnclosingDecl && "missing record or interface decl");
Mike Stump1eb44332009-09-09 15:08:12 +00006103
Chris Lattner1829a6d2009-02-23 22:00:08 +00006104 // If the decl this is being inserted into is invalid, then it may be a
6105 // redeclaration or some other bogus case. Don't try to add fields to it.
6106 if (EnclosingDecl->isInvalidDecl()) {
6107 // FIXME: Deallocate fields?
6108 return;
6109 }
6110
Mike Stump1eb44332009-09-09 15:08:12 +00006111
Reid Spencer5f016e22007-07-11 17:01:13 +00006112 // Verify that all the fields are okay.
6113 unsigned NumNamedMembers = 0;
6114 llvm::SmallVector<FieldDecl*, 32> RecFields;
Douglas Gregor6b3945f2009-01-07 19:46:03 +00006115
Chris Lattner1829a6d2009-02-23 22:00:08 +00006116 RecordDecl *Record = dyn_cast<RecordDecl>(EnclosingDecl);
Reid Spencer5f016e22007-07-11 17:01:13 +00006117 for (unsigned i = 0; i != NumFields; ++i) {
Chris Lattnerb28317a2009-03-28 19:18:32 +00006118 FieldDecl *FD = cast<FieldDecl>(Fields[i].getAs<Decl>());
Mike Stump1eb44332009-09-09 15:08:12 +00006119
Reid Spencer5f016e22007-07-11 17:01:13 +00006120 // Get the type for the field.
Chris Lattner02c642e2007-07-31 21:33:24 +00006121 Type *FDTy = FD->getType().getTypePtr();
Douglas Gregor6b3945f2009-01-07 19:46:03 +00006122
Douglas Gregor72de6672009-01-08 20:45:30 +00006123 if (!FD->isAnonymousStructOrUnion()) {
Douglas Gregor6b3945f2009-01-07 19:46:03 +00006124 // Remember all fields written by the user.
6125 RecFields.push_back(FD);
6126 }
Mike Stump1eb44332009-09-09 15:08:12 +00006127
Chris Lattner24793662009-03-05 22:45:59 +00006128 // If the field is already invalid for some reason, don't emit more
6129 // diagnostics about it.
Eli Friedman721e77d2009-12-07 00:22:08 +00006130 if (FD->isInvalidDecl()) {
6131 EnclosingDecl->setInvalidDecl();
Chris Lattner24793662009-03-05 22:45:59 +00006132 continue;
Eli Friedman721e77d2009-12-07 00:22:08 +00006133 }
Mike Stump1eb44332009-09-09 15:08:12 +00006134
Douglas Gregore7450f52009-03-24 19:52:54 +00006135 // C99 6.7.2.1p2:
6136 // A structure or union shall not contain a member with
6137 // incomplete or function type (hence, a structure shall not
6138 // contain an instance of itself, but may contain a pointer to
6139 // an instance of itself), except that the last member of a
6140 // structure with more than one named member may have incomplete
6141 // array type; such a structure (and any union containing,
6142 // possibly recursively, a member that is such a structure)
6143 // shall not be a member of a structure or an element of an
6144 // array.
Chris Lattner02c642e2007-07-31 21:33:24 +00006145 if (FDTy->isFunctionType()) {
Douglas Gregore7450f52009-03-24 19:52:54 +00006146 // Field declared as a function.
Chris Lattnerf3a41af2008-11-20 06:38:18 +00006147 Diag(FD->getLocation(), diag::err_field_declared_as_function)
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00006148 << FD->getDeclName();
Steve Naroff74216642007-09-14 22:20:54 +00006149 FD->setInvalidDecl();
6150 EnclosingDecl->setInvalidDecl();
Reid Spencer5f016e22007-07-11 17:01:13 +00006151 continue;
Douglas Gregore7450f52009-03-24 19:52:54 +00006152 } else if (FDTy->isIncompleteArrayType() && i == NumFields - 1 &&
6153 Record && Record->isStruct()) {
6154 // Flexible array member.
6155 if (NumNamedMembers < 1) {
Chris Lattnerf3a41af2008-11-20 06:38:18 +00006156 Diag(FD->getLocation(), diag::err_flexible_array_empty_struct)
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00006157 << FD->getDeclName();
Steve Naroff74216642007-09-14 22:20:54 +00006158 FD->setInvalidDecl();
6159 EnclosingDecl->setInvalidDecl();
Reid Spencer5f016e22007-07-11 17:01:13 +00006160 continue;
6161 }
Fariborz Jahanian4142ceb2010-05-26 20:19:07 +00006162 if (!FD->getType()->isDependentType() &&
6163 !Context.getBaseElementType(FD->getType())->isPODType()) {
6164 Diag(FD->getLocation(), diag::err_flexible_array_has_nonpod_type)
Fariborz Jahanian2c0a5402010-05-26 20:46:24 +00006165 << FD->getDeclName() << FD->getType();
Fariborz Jahanian4142ceb2010-05-26 20:19:07 +00006166 FD->setInvalidDecl();
6167 EnclosingDecl->setInvalidDecl();
6168 continue;
6169 }
6170
Reid Spencer5f016e22007-07-11 17:01:13 +00006171 // Okay, we have a legal flexible array member at the end of the struct.
Fariborz Jahaniane267ab62007-09-14 16:27:55 +00006172 if (Record)
6173 Record->setHasFlexibleArrayMember(true);
Douglas Gregore7450f52009-03-24 19:52:54 +00006174 } else if (!FDTy->isDependentType() &&
Mike Stump1eb44332009-09-09 15:08:12 +00006175 RequireCompleteType(FD->getLocation(), FD->getType(),
Douglas Gregore7450f52009-03-24 19:52:54 +00006176 diag::err_field_incomplete)) {
6177 // Incomplete type
6178 FD->setInvalidDecl();
6179 EnclosingDecl->setInvalidDecl();
6180 continue;
Ted Kremenek6217b802009-07-29 21:53:49 +00006181 } else if (const RecordType *FDTTy = FDTy->getAs<RecordType>()) {
Reid Spencer5f016e22007-07-11 17:01:13 +00006182 if (FDTTy->getDecl()->hasFlexibleArrayMember()) {
6183 // If this is a member of a union, then entire union becomes "flexible".
Argyrios Kyrtzidis39ba4ae2008-06-09 23:19:58 +00006184 if (Record && Record->isUnion()) {
Reid Spencer5f016e22007-07-11 17:01:13 +00006185 Record->setHasFlexibleArrayMember(true);
6186 } else {
6187 // If this is a struct/class and this is not the last element, reject
6188 // it. Note that GCC supports variable sized arrays in the middle of
6189 // structures.
Douglas Gregore4f3e062009-03-06 23:41:27 +00006190 if (i != NumFields-1)
6191 Diag(FD->getLocation(), diag::ext_variable_sized_type_in_struct)
Chris Lattner740782a2009-04-25 18:52:45 +00006192 << FD->getDeclName() << FD->getType();
Douglas Gregore4f3e062009-03-06 23:41:27 +00006193 else {
6194 // We support flexible arrays at the end of structs in
6195 // other structs as an extension.
6196 Diag(FD->getLocation(), diag::ext_flexible_array_in_struct)
6197 << FD->getDeclName();
6198 if (Record)
6199 Record->setHasFlexibleArrayMember(true);
Reid Spencer5f016e22007-07-11 17:01:13 +00006200 }
Reid Spencer5f016e22007-07-11 17:01:13 +00006201 }
6202 }
Fariborz Jahanian082b02e2009-07-08 01:18:33 +00006203 if (Record && FDTTy->getDecl()->hasObjectMember())
6204 Record->setHasObjectMember(true);
John McCallc12c5bb2010-05-15 11:32:37 +00006205 } else if (FDTy->isObjCObjectType()) {
Douglas Gregore7450f52009-03-24 19:52:54 +00006206 /// A field cannot be an Objective-c object
Steve Naroffccef3712009-02-20 22:59:16 +00006207 Diag(FD->getLocation(), diag::err_statically_allocated_object);
Fariborz Jahaniane7f64cc2007-10-12 22:10:42 +00006208 FD->setInvalidDecl();
6209 EnclosingDecl->setInvalidDecl();
6210 continue;
Mike Stumpac5fc7c2009-08-04 21:02:39 +00006211 } else if (getLangOptions().ObjC1 &&
6212 getLangOptions().getGCMode() != LangOptions::NonGC &&
6213 Record &&
6214 (FD->getType()->isObjCObjectPointerType() ||
6215 FD->getType().isObjCGCStrong()))
Fariborz Jahanian082b02e2009-07-08 01:18:33 +00006216 Record->setHasObjectMember(true);
Reid Spencer5f016e22007-07-11 17:01:13 +00006217 // Keep track of the number of named members.
Douglas Gregor72de6672009-01-08 20:45:30 +00006218 if (FD->getIdentifier())
Reid Spencer5f016e22007-07-11 17:01:13 +00006219 ++NumNamedMembers;
Reid Spencer5f016e22007-07-11 17:01:13 +00006220 }
Sebastian Redl64b45f72009-01-05 20:52:13 +00006221
Reid Spencer5f016e22007-07-11 17:01:13 +00006222 // Okay, we successfully defined 'Record'.
Chris Lattnere1e79852008-02-06 00:51:33 +00006223 if (Record) {
Douglas Gregor838db382010-02-11 01:19:42 +00006224 Record->completeDefinition();
Chris Lattnere1e79852008-02-06 00:51:33 +00006225 } else {
Jay Foadbeaaccd2009-05-21 09:52:38 +00006226 ObjCIvarDecl **ClsFields =
6227 reinterpret_cast<ObjCIvarDecl**>(RecFields.data());
Fariborz Jahanian60f8c862008-12-13 20:28:25 +00006228 if (ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(EnclosingDecl)) {
Chris Lattner38af2de2009-02-20 21:35:13 +00006229 ID->setLocEnd(RBrac);
Fariborz Jahanian496b5a82009-06-05 18:16:35 +00006230 // Add ivar's to class's DeclContext.
6231 for (unsigned i = 0, e = RecFields.size(); i != e; ++i) {
6232 ClsFields[i]->setLexicalDeclContext(ID);
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00006233 ID->addDecl(ClsFields[i]);
Fariborz Jahanian496b5a82009-06-05 18:16:35 +00006234 }
Fariborz Jahanian3281eff2008-12-16 01:08:35 +00006235 // Must enforce the rule that ivars in the base classes may not be
6236 // duplicates.
Fariborz Jahanianf914b972010-02-23 23:41:11 +00006237 if (ID->getSuperClass())
6238 DiagnoseDuplicateIvars(ID, ID->getSuperClass());
Mike Stump1eb44332009-09-09 15:08:12 +00006239 } else if (ObjCImplementationDecl *IMPDecl =
Chris Lattner1829a6d2009-02-23 22:00:08 +00006240 dyn_cast<ObjCImplementationDecl>(EnclosingDecl)) {
Ted Kremeneka526c5c2008-01-07 19:49:32 +00006241 assert(IMPDecl && "ActOnFields - missing ObjCImplementationDecl");
Fariborz Jahanian496b5a82009-06-05 18:16:35 +00006242 for (unsigned I = 0, N = RecFields.size(); I != N; ++I)
6243 // Ivar declared in @implementation never belongs to the implementation.
6244 // Only it is in implementation's lexical context.
Douglas Gregor8f36aba2009-04-23 03:23:08 +00006245 ClsFields[I]->setLexicalDeclContext(IMPDecl);
Fariborz Jahanian3a3ca1b2007-10-31 18:48:14 +00006246 CheckImplementationIvars(IMPDecl, ClsFields, RecFields.size(), RBrac);
Fariborz Jahanian83c481a2010-02-22 23:04:20 +00006247 } else if (ObjCCategoryDecl *CDecl =
6248 dyn_cast<ObjCCategoryDecl>(EnclosingDecl)) {
Fariborz Jahanian0bd04592010-04-06 22:43:48 +00006249 // case of ivars in class extension; all other cases have been
6250 // reported as errors elsewhere.
6251 // FIXME. Class extension does not have a LocEnd field.
6252 // CDecl->setLocEnd(RBrac);
6253 // Add ivar's to class extension's DeclContext.
6254 for (unsigned i = 0, e = RecFields.size(); i != e; ++i) {
6255 ClsFields[i]->setLexicalDeclContext(CDecl);
6256 CDecl->addDecl(ClsFields[i]);
Fariborz Jahanian83c481a2010-02-22 23:04:20 +00006257 }
Fariborz Jahaniand0b90bf2007-09-26 18:27:25 +00006258 }
Fariborz Jahanianb04a0212007-09-14 21:08:27 +00006259 }
Daniel Dunbar7d076642008-10-03 17:33:35 +00006260
6261 if (Attr)
Douglas Gregor9cdda0c2009-06-17 21:51:59 +00006262 ProcessDeclAttributeList(S, Record, Attr);
Reid Spencer5f016e22007-07-11 17:01:13 +00006263}
6264
Douglas Gregor677e4fe2010-02-01 23:36:03 +00006265/// \brief Determine whether the given integral value is representable within
6266/// the given type T.
6267static bool isRepresentableIntegerValue(ASTContext &Context,
6268 llvm::APSInt &Value,
6269 QualType T) {
6270 assert(T->isIntegralType() && "Integral type required!");
Douglas Gregoraf68d4e2010-04-15 15:53:31 +00006271 unsigned BitWidth = Context.getIntWidth(T);
Douglas Gregor677e4fe2010-02-01 23:36:03 +00006272
6273 if (Value.isUnsigned() || Value.isNonNegative())
6274 return Value.getActiveBits() < BitWidth;
6275
6276 return Value.getMinSignedBits() <= BitWidth;
6277}
6278
6279// \brief Given an integral type, return the next larger integral type
6280// (or a NULL type of no such type exists).
6281static QualType getNextLargerIntegralType(ASTContext &Context, QualType T) {
6282 // FIXME: Int128/UInt128 support, which also needs to be introduced into
6283 // enum checking below.
6284 assert(T->isIntegralType() && "Integral type required!");
6285 const unsigned NumTypes = 4;
6286 QualType SignedIntegralTypes[NumTypes] = {
6287 Context.ShortTy, Context.IntTy, Context.LongTy, Context.LongLongTy
6288 };
6289 QualType UnsignedIntegralTypes[NumTypes] = {
6290 Context.UnsignedShortTy, Context.UnsignedIntTy, Context.UnsignedLongTy,
6291 Context.UnsignedLongLongTy
6292 };
6293
6294 unsigned BitWidth = Context.getTypeSize(T);
6295 QualType *Types = T->isSignedIntegerType()? SignedIntegralTypes
6296 : UnsignedIntegralTypes;
6297 for (unsigned I = 0; I != NumTypes; ++I)
6298 if (Context.getTypeSize(Types[I]) > BitWidth)
6299 return Types[I];
6300
6301 return QualType();
6302}
6303
Douglas Gregor879fd492009-03-17 19:05:46 +00006304EnumConstantDecl *Sema::CheckEnumConstant(EnumDecl *Enum,
6305 EnumConstantDecl *LastEnumConst,
6306 SourceLocation IdLoc,
6307 IdentifierInfo *Id,
6308 ExprArg val) {
6309 Expr *Val = (Expr *)val.get();
6310
Douglas Gregor677e4fe2010-02-01 23:36:03 +00006311 unsigned IntWidth = Context.Target.getIntWidth();
6312 llvm::APSInt EnumVal(IntWidth);
Douglas Gregor879fd492009-03-17 19:05:46 +00006313 QualType EltTy;
Douglas Gregor4912c342009-11-06 00:03:12 +00006314 if (Val) {
Douglas Gregor9b9edd62010-03-02 17:53:14 +00006315 if (Enum->isDependentType() || Val->isTypeDependent())
Douglas Gregor4912c342009-11-06 00:03:12 +00006316 EltTy = Context.DependentTy;
6317 else {
Douglas Gregor4912c342009-11-06 00:03:12 +00006318 // C99 6.7.2.2p2: Make sure we have an integer constant expression.
6319 SourceLocation ExpLoc;
Douglas Gregor9b9edd62010-03-02 17:53:14 +00006320 if (!Val->isValueDependent() &&
6321 VerifyIntegerConstantExpression(Val, &EnumVal)) {
Douglas Gregor4912c342009-11-06 00:03:12 +00006322 Val = 0;
Douglas Gregor677e4fe2010-02-01 23:36:03 +00006323 } else {
6324 if (!getLangOptions().CPlusPlus) {
6325 // C99 6.7.2.2p2:
6326 // The expression that defines the value of an enumeration constant
6327 // shall be an integer constant expression that has a value
6328 // representable as an int.
6329
6330 // Complain if the value is not representable in an int.
6331 if (!isRepresentableIntegerValue(Context, EnumVal, Context.IntTy))
6332 Diag(IdLoc, diag::ext_enum_value_not_int)
6333 << EnumVal.toString(10) << Val->getSourceRange()
Douglas Gregor19c15252010-02-17 22:40:11 +00006334 << (EnumVal.isUnsigned() || EnumVal.isNonNegative());
Douglas Gregor677e4fe2010-02-01 23:36:03 +00006335 else if (!Context.hasSameType(Val->getType(), Context.IntTy)) {
6336 // Force the type of the expression to 'int'.
6337 ImpCastExprToType(Val, Context.IntTy, CastExpr::CK_IntegralCast);
6338
6339 if (Val != val.get()) {
6340 val.release();
6341 val = Val;
6342 }
6343 }
6344 }
6345
6346 // C++0x [dcl.enum]p5:
6347 // If the underlying type is not fixed, the type of each enumerator
6348 // is the type of its initializing value:
6349 // - If an initializer is specified for an enumerator, the
6350 // initializing value has the same type as the expression.
Douglas Gregor4912c342009-11-06 00:03:12 +00006351 EltTy = Val->getType();
6352 }
Douglas Gregor879fd492009-03-17 19:05:46 +00006353 }
6354 }
Mike Stump1eb44332009-09-09 15:08:12 +00006355
Douglas Gregor879fd492009-03-17 19:05:46 +00006356 if (!Val) {
Eli Friedmaned0716b2009-12-11 01:34:50 +00006357 if (Enum->isDependentType())
6358 EltTy = Context.DependentTy;
Douglas Gregor677e4fe2010-02-01 23:36:03 +00006359 else if (!LastEnumConst) {
6360 // C++0x [dcl.enum]p5:
6361 // If the underlying type is not fixed, the type of each enumerator
6362 // is the type of its initializing value:
6363 // - If no initializer is specified for the first enumerator, the
6364 // initializing value has an unspecified integral type.
6365 //
6366 // GCC uses 'int' for its unspecified integral type, as does
6367 // C99 6.7.2.2p3.
6368 EltTy = Context.IntTy;
6369 } else {
Douglas Gregor879fd492009-03-17 19:05:46 +00006370 // Assign the last value + 1.
6371 EnumVal = LastEnumConst->getInitVal();
6372 ++EnumVal;
Douglas Gregor677e4fe2010-02-01 23:36:03 +00006373 EltTy = LastEnumConst->getType();
Douglas Gregor879fd492009-03-17 19:05:46 +00006374
6375 // Check for overflow on increment.
Douglas Gregor677e4fe2010-02-01 23:36:03 +00006376 if (EnumVal < LastEnumConst->getInitVal()) {
6377 // C++0x [dcl.enum]p5:
6378 // If the underlying type is not fixed, the type of each enumerator
6379 // is the type of its initializing value:
6380 //
6381 // - Otherwise the type of the initializing value is the same as
6382 // the type of the initializing value of the preceding enumerator
6383 // unless the incremented value is not representable in that type,
6384 // in which case the type is an unspecified integral type
6385 // sufficient to contain the incremented value. If no such type
6386 // exists, the program is ill-formed.
6387 QualType T = getNextLargerIntegralType(Context, EltTy);
6388 if (T.isNull()) {
6389 // There is no integral type larger enough to represent this
6390 // value. Complain, then allow the value to wrap around.
6391 EnumVal = LastEnumConst->getInitVal();
6392 EnumVal.zext(EnumVal.getBitWidth() * 2);
6393 Diag(IdLoc, diag::warn_enumerator_too_large)
6394 << EnumVal.toString(10);
6395 } else {
6396 EltTy = T;
6397 }
6398
6399 // Retrieve the last enumerator's value, extent that type to the
6400 // type that is supposed to be large enough to represent the incremented
6401 // value, then increment.
6402 EnumVal = LastEnumConst->getInitVal();
6403 EnumVal.setIsSigned(EltTy->isSignedIntegerType());
Douglas Gregoraf68d4e2010-04-15 15:53:31 +00006404 EnumVal.zextOrTrunc(Context.getIntWidth(EltTy));
Douglas Gregor677e4fe2010-02-01 23:36:03 +00006405 ++EnumVal;
6406
6407 // If we're not in C++, diagnose the overflow of enumerator values,
6408 // which in C99 means that the enumerator value is not representable in
6409 // an int (C99 6.7.2.2p2). However, we support GCC's extension that
6410 // permits enumerator values that are representable in some larger
6411 // integral type.
6412 if (!getLangOptions().CPlusPlus && !T.isNull())
6413 Diag(IdLoc, diag::warn_enum_value_overflow);
6414 } else if (!getLangOptions().CPlusPlus &&
6415 !isRepresentableIntegerValue(Context, EnumVal, EltTy)) {
6416 // Enforce C99 6.7.2.2p2 even when we compute the next value.
6417 Diag(IdLoc, diag::ext_enum_value_not_int)
6418 << EnumVal.toString(10) << 1;
6419 }
Douglas Gregor879fd492009-03-17 19:05:46 +00006420 }
6421 }
Mike Stump1eb44332009-09-09 15:08:12 +00006422
Douglas Gregor9b9edd62010-03-02 17:53:14 +00006423 if (!EltTy->isDependentType()) {
Douglas Gregor677e4fe2010-02-01 23:36:03 +00006424 // Make the enumerator value match the signedness and size of the
6425 // enumerator's type.
Douglas Gregoraf68d4e2010-04-15 15:53:31 +00006426 EnumVal.zextOrTrunc(Context.getIntWidth(EltTy));
Douglas Gregor677e4fe2010-02-01 23:36:03 +00006427 EnumVal.setIsSigned(EltTy->isSignedIntegerType());
6428 }
Douglas Gregor4912c342009-11-06 00:03:12 +00006429
Douglas Gregor879fd492009-03-17 19:05:46 +00006430 val.release();
6431 return EnumConstantDecl::Create(Context, Enum, IdLoc, Id, EltTy,
Mike Stump1eb44332009-09-09 15:08:12 +00006432 Val, EnumVal);
Douglas Gregor879fd492009-03-17 19:05:46 +00006433}
6434
6435
Chris Lattnerb28317a2009-03-28 19:18:32 +00006436Sema::DeclPtrTy Sema::ActOnEnumConstant(Scope *S, DeclPtrTy theEnumDecl,
6437 DeclPtrTy lastEnumConst,
6438 SourceLocation IdLoc,
6439 IdentifierInfo *Id,
6440 SourceLocation EqualLoc, ExprTy *val) {
6441 EnumDecl *TheEnumDecl = cast<EnumDecl>(theEnumDecl.getAs<Decl>());
Reid Spencer5f016e22007-07-11 17:01:13 +00006442 EnumConstantDecl *LastEnumConst =
Chris Lattnerb28317a2009-03-28 19:18:32 +00006443 cast_or_null<EnumConstantDecl>(lastEnumConst.getAs<Decl>());
Reid Spencer5f016e22007-07-11 17:01:13 +00006444 Expr *Val = static_cast<Expr*>(val);
6445
Chris Lattner31e05722007-08-26 06:24:45 +00006446 // The scope passed in may not be a decl scope. Zip up the scope tree until
6447 // we find one that is.
Douglas Gregor1a0d31a2009-01-12 18:45:55 +00006448 S = getNonFieldDeclScope(S);
Mike Stump1eb44332009-09-09 15:08:12 +00006449
Reid Spencer5f016e22007-07-11 17:01:13 +00006450 // Verify that there isn't already something declared with this name in this
6451 // scope.
Douglas Gregorc83c6872010-04-15 22:33:43 +00006452 NamedDecl *PrevDecl = LookupSingleName(S, Id, IdLoc, LookupOrdinaryName,
Douglas Gregore39fe722010-01-19 06:06:57 +00006453 ForRedeclaration);
Douglas Gregorf57172b2008-12-08 18:40:42 +00006454 if (PrevDecl && PrevDecl->isTemplateParameter()) {
Douglas Gregor72c3f312008-12-05 18:15:24 +00006455 // Maybe we will complain about the shadowed template parameter.
6456 DiagnoseTemplateParameterShadow(IdLoc, PrevDecl);
6457 // Just pretend that we didn't see the previous declaration.
6458 PrevDecl = 0;
6459 }
6460
6461 if (PrevDecl) {
Argyrios Kyrtzidis0ff12f02008-07-16 21:01:53 +00006462 // When in C++, we may get a TagDecl with the same name; in this case the
6463 // enum constant will 'hide' the tag.
6464 assert((getLangOptions().CPlusPlus || !isa<TagDecl>(PrevDecl)) &&
6465 "Received TagDecl when not in C++!");
Argyrios Kyrtzidis15a12d02008-09-09 21:18:04 +00006466 if (!isa<TagDecl>(PrevDecl) && isDeclInScope(PrevDecl, CurContext, S)) {
Reid Spencer5f016e22007-07-11 17:01:13 +00006467 if (isa<EnumConstantDecl>(PrevDecl))
Chris Lattner3c73c412008-11-19 08:23:25 +00006468 Diag(IdLoc, diag::err_redefinition_of_enumerator) << Id;
Reid Spencer5f016e22007-07-11 17:01:13 +00006469 else
Chris Lattner3c73c412008-11-19 08:23:25 +00006470 Diag(IdLoc, diag::err_redefinition) << Id;
Chris Lattner5f4a6822008-11-23 23:12:31 +00006471 Diag(PrevDecl->getLocation(), diag::note_previous_definition);
Chris Lattnerf306f862009-02-28 19:37:57 +00006472 if (Val) Val->Destroy(Context);
Chris Lattnerb28317a2009-03-28 19:18:32 +00006473 return DeclPtrTy();
Reid Spencer5f016e22007-07-11 17:01:13 +00006474 }
6475 }
6476
Douglas Gregor879fd492009-03-17 19:05:46 +00006477 EnumConstantDecl *New = CheckEnumConstant(TheEnumDecl, LastEnumConst,
6478 IdLoc, Id, Owned(Val));
Chris Lattner421a23d2007-08-27 21:16:18 +00006479
Reid Spencer5f016e22007-07-11 17:01:13 +00006480 // Register this decl in the current scope stack.
John McCall92f88312010-01-23 00:46:32 +00006481 if (New) {
6482 New->setAccess(TheEnumDecl->getAccess());
Douglas Gregor879fd492009-03-17 19:05:46 +00006483 PushOnScopeChains(New, S);
John McCall92f88312010-01-23 00:46:32 +00006484 }
Douglas Gregor45579f52008-12-17 02:04:30 +00006485
Chris Lattnerb28317a2009-03-28 19:18:32 +00006486 return DeclPtrTy::make(New);
Reid Spencer5f016e22007-07-11 17:01:13 +00006487}
6488
Mike Stumpc6e35aa2009-05-16 07:06:02 +00006489void Sema::ActOnEnumBody(SourceLocation EnumLoc, SourceLocation LBraceLoc,
6490 SourceLocation RBraceLoc, DeclPtrTy EnumDeclX,
Edward O'Callaghanfee13812009-08-08 14:36:57 +00006491 DeclPtrTy *Elements, unsigned NumElements,
6492 Scope *S, AttributeList *Attr) {
Chris Lattnerb28317a2009-03-28 19:18:32 +00006493 EnumDecl *Enum = cast<EnumDecl>(EnumDeclX.getAs<Decl>());
Douglas Gregor074149e2009-01-05 19:45:36 +00006494 QualType EnumType = Context.getTypeDeclType(Enum);
Edward O'Callaghanfee13812009-08-08 14:36:57 +00006495
6496 if (Attr)
6497 ProcessDeclAttributeList(S, Enum, Attr);
Mike Stump1eb44332009-09-09 15:08:12 +00006498
Eli Friedmaned0716b2009-12-11 01:34:50 +00006499 if (Enum->isDependentType()) {
6500 for (unsigned i = 0; i != NumElements; ++i) {
6501 EnumConstantDecl *ECD =
6502 cast_or_null<EnumConstantDecl>(Elements[i].getAs<Decl>());
6503 if (!ECD) continue;
6504
6505 ECD->setType(EnumType);
6506 }
6507
John McCall1b5a6182010-05-06 08:49:23 +00006508 Enum->completeDefinition(Context.DependentTy, Context.DependentTy, 0, 0);
Eli Friedmaned0716b2009-12-11 01:34:50 +00006509 return;
6510 }
6511
Chris Lattnere37f0be2007-08-28 05:10:31 +00006512 // TODO: If the result value doesn't fit in an int, it must be a long or long
6513 // long value. ISO C does not support this, but GCC does as an extension,
6514 // emit a warning.
Chris Lattner98be4942008-03-05 18:54:05 +00006515 unsigned IntWidth = Context.Target.getIntWidth();
Edward O'Callaghanfee13812009-08-08 14:36:57 +00006516 unsigned CharWidth = Context.Target.getCharWidth();
6517 unsigned ShortWidth = Context.Target.getShortWidth();
Mike Stump1eb44332009-09-09 15:08:12 +00006518
Chris Lattnerac609682007-08-28 06:15:15 +00006519 // Verify that all the values are okay, compute the size of the values, and
6520 // reverse the list.
6521 unsigned NumNegativeBits = 0;
6522 unsigned NumPositiveBits = 0;
Mike Stump1eb44332009-09-09 15:08:12 +00006523
Chris Lattnerac609682007-08-28 06:15:15 +00006524 // Keep track of whether all elements have type int.
6525 bool AllElementsInt = true;
Mike Stump1eb44332009-09-09 15:08:12 +00006526
Reid Spencer5f016e22007-07-11 17:01:13 +00006527 for (unsigned i = 0; i != NumElements; ++i) {
6528 EnumConstantDecl *ECD =
Chris Lattnerb28317a2009-03-28 19:18:32 +00006529 cast_or_null<EnumConstantDecl>(Elements[i].getAs<Decl>());
Reid Spencer5f016e22007-07-11 17:01:13 +00006530 if (!ECD) continue; // Already issued a diagnostic.
Mike Stump1eb44332009-09-09 15:08:12 +00006531
Chris Lattner211a30e2007-08-28 05:27:00 +00006532 const llvm::APSInt &InitVal = ECD->getInitVal();
Mike Stump1eb44332009-09-09 15:08:12 +00006533
Chris Lattnerac609682007-08-28 06:15:15 +00006534 // Keep track of the size of positive and negative values.
Chris Lattnera73349d2008-02-26 00:33:57 +00006535 if (InitVal.isUnsigned() || InitVal.isNonNegative())
Chris Lattner21dd8212008-01-14 21:47:29 +00006536 NumPositiveBits = std::max(NumPositiveBits,
6537 (unsigned)InitVal.getActiveBits());
Chris Lattnerac609682007-08-28 06:15:15 +00006538 else
Chris Lattner21dd8212008-01-14 21:47:29 +00006539 NumNegativeBits = std::max(NumNegativeBits,
6540 (unsigned)InitVal.getMinSignedBits());
Reid Spencer5f016e22007-07-11 17:01:13 +00006541
Chris Lattnerac609682007-08-28 06:15:15 +00006542 // Keep track of whether every enum element has type int (very commmon).
6543 if (AllElementsInt)
Mike Stump1eb44332009-09-09 15:08:12 +00006544 AllElementsInt = ECD->getType() == Context.IntTy;
Reid Spencer5f016e22007-07-11 17:01:13 +00006545 }
Mike Stump1eb44332009-09-09 15:08:12 +00006546
Chris Lattnerac609682007-08-28 06:15:15 +00006547 // Figure out the type that should be used for this enum.
Edward O'Callaghanfee13812009-08-08 14:36:57 +00006548 // FIXME: Support -fshort-enums.
Chris Lattnerac609682007-08-28 06:15:15 +00006549 QualType BestType;
Chris Lattnerb7f6e082007-08-29 17:31:48 +00006550 unsigned BestWidth;
Edward O'Callaghanfee13812009-08-08 14:36:57 +00006551
John McCall842aef82009-12-09 09:09:27 +00006552 // C++0x N3000 [conv.prom]p3:
6553 // An rvalue of an unscoped enumeration type whose underlying
6554 // type is not fixed can be converted to an rvalue of the first
6555 // of the following types that can represent all the values of
6556 // the enumeration: int, unsigned int, long int, unsigned long
6557 // int, long long int, or unsigned long long int.
6558 // C99 6.4.4.3p2:
6559 // An identifier declared as an enumeration constant has type int.
6560 // The C99 rule is modified by a gcc extension
6561 QualType BestPromotionType;
6562
Edward O'Callaghanfee13812009-08-08 14:36:57 +00006563 bool Packed = Enum->getAttr<PackedAttr>() ? true : false;
6564
Chris Lattnerac609682007-08-28 06:15:15 +00006565 if (NumNegativeBits) {
Mike Stump1eb44332009-09-09 15:08:12 +00006566 // If there is a negative value, figure out the smallest integer type (of
Chris Lattnerac609682007-08-28 06:15:15 +00006567 // int/long/longlong) that fits.
Edward O'Callaghanfee13812009-08-08 14:36:57 +00006568 // If it's packed, check also if it fits a char or a short.
6569 if (Packed && NumNegativeBits <= CharWidth && NumPositiveBits < CharWidth) {
John McCall842aef82009-12-09 09:09:27 +00006570 BestType = Context.SignedCharTy;
6571 BestWidth = CharWidth;
Mike Stump1eb44332009-09-09 15:08:12 +00006572 } else if (Packed && NumNegativeBits <= ShortWidth &&
Edward O'Callaghanfee13812009-08-08 14:36:57 +00006573 NumPositiveBits < ShortWidth) {
John McCall842aef82009-12-09 09:09:27 +00006574 BestType = Context.ShortTy;
6575 BestWidth = ShortWidth;
6576 } else if (NumNegativeBits <= IntWidth && NumPositiveBits < IntWidth) {
Chris Lattnerac609682007-08-28 06:15:15 +00006577 BestType = Context.IntTy;
Chris Lattnerb7f6e082007-08-29 17:31:48 +00006578 BestWidth = IntWidth;
6579 } else {
Chris Lattner98be4942008-03-05 18:54:05 +00006580 BestWidth = Context.Target.getLongWidth();
Mike Stump1eb44332009-09-09 15:08:12 +00006581
John McCall842aef82009-12-09 09:09:27 +00006582 if (NumNegativeBits <= BestWidth && NumPositiveBits < BestWidth) {
Chris Lattnerac609682007-08-28 06:15:15 +00006583 BestType = Context.LongTy;
John McCall842aef82009-12-09 09:09:27 +00006584 } else {
Chris Lattner98be4942008-03-05 18:54:05 +00006585 BestWidth = Context.Target.getLongLongWidth();
Mike Stump1eb44332009-09-09 15:08:12 +00006586
Chris Lattnerb7f6e082007-08-29 17:31:48 +00006587 if (NumNegativeBits > BestWidth || NumPositiveBits >= BestWidth)
Chris Lattnerac609682007-08-28 06:15:15 +00006588 Diag(Enum->getLocation(), diag::warn_enum_too_large);
6589 BestType = Context.LongLongTy;
6590 }
6591 }
John McCall842aef82009-12-09 09:09:27 +00006592 BestPromotionType = (BestWidth <= IntWidth ? Context.IntTy : BestType);
Chris Lattnerac609682007-08-28 06:15:15 +00006593 } else {
Douglas Gregoraa74a1e2010-02-02 20:10:50 +00006594 // If there is no negative value, figure out the smallest type that fits
6595 // all of the enumerator values.
Edward O'Callaghanfee13812009-08-08 14:36:57 +00006596 // If it's packed, check also if it fits a char or a short.
6597 if (Packed && NumPositiveBits <= CharWidth) {
John McCall842aef82009-12-09 09:09:27 +00006598 BestType = Context.UnsignedCharTy;
6599 BestPromotionType = Context.IntTy;
6600 BestWidth = CharWidth;
Edward O'Callaghanfee13812009-08-08 14:36:57 +00006601 } else if (Packed && NumPositiveBits <= ShortWidth) {
John McCall842aef82009-12-09 09:09:27 +00006602 BestType = Context.UnsignedShortTy;
6603 BestPromotionType = Context.IntTy;
6604 BestWidth = ShortWidth;
6605 } else if (NumPositiveBits <= IntWidth) {
Chris Lattnerac609682007-08-28 06:15:15 +00006606 BestType = Context.UnsignedIntTy;
Chris Lattnerb7f6e082007-08-29 17:31:48 +00006607 BestWidth = IntWidth;
Douglas Gregoraa74a1e2010-02-02 20:10:50 +00006608 BestPromotionType
6609 = (NumPositiveBits == BestWidth || !getLangOptions().CPlusPlus)
6610 ? Context.UnsignedIntTy : Context.IntTy;
Chris Lattnerb7f6e082007-08-29 17:31:48 +00006611 } else if (NumPositiveBits <=
Chris Lattner98be4942008-03-05 18:54:05 +00006612 (BestWidth = Context.Target.getLongWidth())) {
Chris Lattnerac609682007-08-28 06:15:15 +00006613 BestType = Context.UnsignedLongTy;
Douglas Gregoraa74a1e2010-02-02 20:10:50 +00006614 BestPromotionType
6615 = (NumPositiveBits == BestWidth || !getLangOptions().CPlusPlus)
6616 ? Context.UnsignedLongTy : Context.LongTy;
Chris Lattner98be4942008-03-05 18:54:05 +00006617 } else {
6618 BestWidth = Context.Target.getLongLongWidth();
Chris Lattnerb7f6e082007-08-29 17:31:48 +00006619 assert(NumPositiveBits <= BestWidth &&
Chris Lattnerac609682007-08-28 06:15:15 +00006620 "How could an initializer get larger than ULL?");
6621 BestType = Context.UnsignedLongLongTy;
Douglas Gregoraa74a1e2010-02-02 20:10:50 +00006622 BestPromotionType
6623 = (NumPositiveBits == BestWidth || !getLangOptions().CPlusPlus)
6624 ? Context.UnsignedLongLongTy : Context.LongLongTy;
Chris Lattnerac609682007-08-28 06:15:15 +00006625 }
6626 }
Mike Stump1eb44332009-09-09 15:08:12 +00006627
Chris Lattnerb7f6e082007-08-29 17:31:48 +00006628 // Loop over all of the enumerator constants, changing their types to match
6629 // the type of the enum if needed.
6630 for (unsigned i = 0; i != NumElements; ++i) {
6631 EnumConstantDecl *ECD =
Chris Lattnerb28317a2009-03-28 19:18:32 +00006632 cast_or_null<EnumConstantDecl>(Elements[i].getAs<Decl>());
Chris Lattnerb7f6e082007-08-29 17:31:48 +00006633 if (!ECD) continue; // Already issued a diagnostic.
6634
6635 // Standard C says the enumerators have int type, but we allow, as an
6636 // extension, the enumerators to be larger than int size. If each
6637 // enumerator value fits in an int, type it as an int, otherwise type it the
6638 // same as the enumerator decl itself. This means that in "enum { X = 1U }"
6639 // that X has type 'int', not 'unsigned'.
Chris Lattnerb7f6e082007-08-29 17:31:48 +00006640
6641 // Determine whether the value fits into an int.
6642 llvm::APSInt InitVal = ECD->getInitVal();
Chris Lattnerb7f6e082007-08-29 17:31:48 +00006643
6644 // If it fits into an integer type, force it. Otherwise force it to match
6645 // the enum decl type.
6646 QualType NewTy;
6647 unsigned NewWidth;
6648 bool NewSign;
Douglas Gregor677e4fe2010-02-01 23:36:03 +00006649 if (!getLangOptions().CPlusPlus &&
6650 isRepresentableIntegerValue(Context, InitVal, Context.IntTy)) {
Chris Lattnerb7f6e082007-08-29 17:31:48 +00006651 NewTy = Context.IntTy;
6652 NewWidth = IntWidth;
6653 NewSign = true;
6654 } else if (ECD->getType() == BestType) {
6655 // Already the right type!
Douglas Gregorc9467cf2008-12-12 02:00:36 +00006656 if (getLangOptions().CPlusPlus)
6657 // C++ [dcl.enum]p4: Following the closing brace of an
6658 // enum-specifier, each enumerator has the type of its
Mike Stump1eb44332009-09-09 15:08:12 +00006659 // enumeration.
Douglas Gregorc9467cf2008-12-12 02:00:36 +00006660 ECD->setType(EnumType);
Chris Lattnerb7f6e082007-08-29 17:31:48 +00006661 continue;
6662 } else {
6663 NewTy = BestType;
6664 NewWidth = BestWidth;
6665 NewSign = BestType->isSignedIntegerType();
6666 }
6667
6668 // Adjust the APSInt value.
6669 InitVal.extOrTrunc(NewWidth);
6670 InitVal.setIsSigned(NewSign);
6671 ECD->setInitVal(InitVal);
Mike Stump1eb44332009-09-09 15:08:12 +00006672
Chris Lattnerb7f6e082007-08-29 17:31:48 +00006673 // Adjust the Expr initializer and type.
Chris Lattner13fd4162009-01-15 19:19:42 +00006674 if (ECD->getInitExpr())
Mike Stump1eb44332009-09-09 15:08:12 +00006675 ECD->setInitExpr(new (Context) ImplicitCastExpr(NewTy,
Eli Friedman73c39ab2009-10-20 08:27:19 +00006676 CastExpr::CK_IntegralCast,
Mike Stump1eb44332009-09-09 15:08:12 +00006677 ECD->getInitExpr(),
Anders Carlssonf1b48b72010-04-24 16:57:13 +00006678 CXXBaseSpecifierArray(),
Ted Kremenek8189cde2009-02-07 01:47:29 +00006679 /*isLvalue=*/false));
Douglas Gregorc9467cf2008-12-12 02:00:36 +00006680 if (getLangOptions().CPlusPlus)
6681 // C++ [dcl.enum]p4: Following the closing brace of an
6682 // enum-specifier, each enumerator has the type of its
Mike Stump1eb44332009-09-09 15:08:12 +00006683 // enumeration.
Douglas Gregorc9467cf2008-12-12 02:00:36 +00006684 ECD->setType(EnumType);
6685 else
6686 ECD->setType(NewTy);
Chris Lattnerb7f6e082007-08-29 17:31:48 +00006687 }
Mike Stump1eb44332009-09-09 15:08:12 +00006688
John McCall1b5a6182010-05-06 08:49:23 +00006689 Enum->completeDefinition(BestType, BestPromotionType,
6690 NumPositiveBits, NumNegativeBits);
Reid Spencer5f016e22007-07-11 17:01:13 +00006691}
6692
Chris Lattnerb28317a2009-03-28 19:18:32 +00006693Sema::DeclPtrTy Sema::ActOnFileScopeAsmDecl(SourceLocation Loc,
6694 ExprArg expr) {
Anders Carlssonf1b1d592009-05-01 19:30:39 +00006695 StringLiteral *AsmString = cast<StringLiteral>(expr.takeAs<Expr>());
Sebastian Redl798d1192008-12-13 16:23:55 +00006696
Douglas Gregor4fe0c8e2009-05-30 00:08:05 +00006697 FileScopeAsmDecl *New = FileScopeAsmDecl::Create(Context, CurContext,
6698 Loc, AsmString);
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00006699 CurContext->addDecl(New);
Douglas Gregor4fe0c8e2009-05-30 00:08:05 +00006700 return DeclPtrTy::make(New);
Anders Carlssondfab6cb2008-02-08 00:33:21 +00006701}
Eli Friedmanc49f19b2009-06-05 02:44:36 +00006702
6703void Sema::ActOnPragmaWeakID(IdentifierInfo* Name,
6704 SourceLocation PragmaLoc,
6705 SourceLocation NameLoc) {
Douglas Gregorc83c6872010-04-15 22:33:43 +00006706 Decl *PrevDecl = LookupSingleName(TUScope, Name, NameLoc, LookupOrdinaryName);
Eli Friedmanc49f19b2009-06-05 02:44:36 +00006707
Eli Friedmanc49f19b2009-06-05 02:44:36 +00006708 if (PrevDecl) {
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +00006709 PrevDecl->addAttr(::new (Context) WeakAttr());
Ryan Flynne25ff832009-07-30 03:15:39 +00006710 } else {
6711 (void)WeakUndeclaredIdentifiers.insert(
6712 std::pair<IdentifierInfo*,WeakInfo>
6713 (Name, WeakInfo((IdentifierInfo*)0, NameLoc)));
Eli Friedmanc49f19b2009-06-05 02:44:36 +00006714 }
Eli Friedmanc49f19b2009-06-05 02:44:36 +00006715}
6716
6717void Sema::ActOnPragmaWeakAlias(IdentifierInfo* Name,
6718 IdentifierInfo* AliasName,
6719 SourceLocation PragmaLoc,
6720 SourceLocation NameLoc,
6721 SourceLocation AliasNameLoc) {
Douglas Gregorc83c6872010-04-15 22:33:43 +00006722 Decl *PrevDecl = LookupSingleName(TUScope, AliasName, AliasNameLoc,
6723 LookupOrdinaryName);
Ryan Flynne25ff832009-07-30 03:15:39 +00006724 WeakInfo W = WeakInfo(Name, NameLoc);
Eli Friedmanc49f19b2009-06-05 02:44:36 +00006725
Eli Friedmanc49f19b2009-06-05 02:44:36 +00006726 if (PrevDecl) {
Ryan Flynne25ff832009-07-30 03:15:39 +00006727 if (!PrevDecl->hasAttr<AliasAttr>())
6728 if (NamedDecl *ND = dyn_cast<NamedDecl>(PrevDecl))
Ryan Flynn7b1fdbd2009-07-31 02:52:19 +00006729 DeclApplyPragmaWeak(TUScope, ND, W);
Ryan Flynne25ff832009-07-30 03:15:39 +00006730 } else {
6731 (void)WeakUndeclaredIdentifiers.insert(
6732 std::pair<IdentifierInfo*,WeakInfo>(AliasName, W));
Eli Friedmanc49f19b2009-06-05 02:44:36 +00006733 }
Eli Friedmanc49f19b2009-06-05 02:44:36 +00006734}