blob: 71b3c526a167b0da276f1c31b232a41a4a8e3a4c [file] [log] [blame]
Chris Lattner697e5d62006-11-09 06:32:27 +00001//===--- SemaDecl.cpp - Semantic Analysis for Declarations ----------------===//
2//
3// The LLVM Compiler Infrastructure
4//
Chris Lattner5b12ab82007-12-29 19:59:25 +00005// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
Chris Lattner697e5d62006-11-09 06:32:27 +00007//
8//===----------------------------------------------------------------------===//
9//
10// This file implements semantic analysis for declarations.
11//
12//===----------------------------------------------------------------------===//
13
John McCall83024632010-08-25 22:03:47 +000014#include "clang/Sema/SemaInternal.h"
Douglas Gregorc3a6ade2010-08-12 20:07:10 +000015#include "clang/Sema/Initialization.h"
16#include "clang/Sema/Lookup.h"
John McCallcc14d1f2010-08-24 08:50:51 +000017#include "clang/Sema/CXXFieldCollector.h"
18#include "clang/Sema/Scope.h"
John McCallaab3e412010-08-25 08:40:02 +000019#include "clang/Sema/ScopeInfo.h"
Douglas Gregor844cb502011-03-01 18:12:44 +000020#include "TypeLocBuilder.h"
Anders Carlsson7a241ba2008-07-03 04:20:39 +000021#include "clang/AST/APValue.h"
Chris Lattner622c1932008-02-06 00:51:33 +000022#include "clang/AST/ASTConsumer.h"
Chris Lattner5c5fbcc2006-12-03 08:41:30 +000023#include "clang/AST/ASTContext.h"
Douglas Gregor36d1b142009-10-06 17:59:45 +000024#include "clang/AST/CXXInheritance.h"
John McCall28a0cf72010-08-25 07:42:41 +000025#include "clang/AST/DeclCXX.h"
John McCallde6836a2010-08-24 07:21:54 +000026#include "clang/AST/DeclObjC.h"
Douglas Gregorded2d7b2009-02-04 19:02:06 +000027#include "clang/AST/DeclTemplate.h"
Chandler Carruth33bf3e72011-03-27 09:46:56 +000028#include "clang/AST/EvaluatedExprVisitor.h"
Chris Lattner2c6fcf52008-06-26 18:38:35 +000029#include "clang/AST/ExprCXX.h"
Sebastian Redla7b98a72009-04-26 20:35:05 +000030#include "clang/AST/StmtCXX.h"
Argyrios Kyrtzidisaf84ec02010-11-17 23:11:54 +000031#include "clang/AST/CharUnits.h"
John McCall8b0666c2010-08-20 18:27:03 +000032#include "clang/Sema/DeclSpec.h"
33#include "clang/Sema/ParsedTemplate.h"
Douglas Gregor15e56022009-10-13 23:27:22 +000034#include "clang/Parse/ParseDiagnostic.h"
Anders Carlssond624e162009-08-26 23:45:07 +000035#include "clang/Basic/PartialDiagnostic.h"
Fariborz Jahanianed1933b2011-10-03 22:11:57 +000036#include "clang/Sema/DelayedDiagnostic.h"
Steve Naroffe101f952008-01-30 23:46:05 +000037#include "clang/Basic/SourceManager.h"
Anders Carlssond624e162009-08-26 23:45:07 +000038#include "clang/Basic/TargetInfo.h"
Steve Naroffe101f952008-01-30 23:46:05 +000039// FIXME: layering (ideally, Sema shouldn't be dependent on Lex API's)
Chris Lattner622c1932008-02-06 00:51:33 +000040#include "clang/Lex/Preprocessor.h"
Mike Stump11289f42009-09-09 15:08:12 +000041#include "clang/Lex/HeaderSearch.h"
Douglas Gregor08142532011-08-26 23:56:07 +000042#include "clang/Lex/ModuleLoader.h"
John McCall0e21fcc2009-12-24 09:58:38 +000043#include "llvm/ADT/Triple.h"
Douglas Gregor8b9ccca2008-12-23 21:05:05 +000044#include <algorithm>
Douglas Gregor56fbc372009-09-28 21:14:19 +000045#include <cstring>
Douglas Gregor8b9ccca2008-12-23 21:05:05 +000046#include <functional>
Chris Lattner697e5d62006-11-09 06:32:27 +000047using namespace clang;
John McCallaab3e412010-08-25 08:40:02 +000048using namespace sema;
Chris Lattner697e5d62006-11-09 06:32:27 +000049
Richard Smithcd1c0552011-07-01 19:46:12 +000050Sema::DeclGroupPtrTy Sema::ConvertDeclToDeclGroup(Decl *Ptr, Decl *OwnedType) {
51 if (OwnedType) {
52 Decl *Group[2] = { OwnedType, Ptr };
53 return DeclGroupPtrTy::make(DeclGroupRef::Create(Context, Group, 2));
54 }
55
John McCall48871652010-08-21 09:40:31 +000056 return DeclGroupPtrTy::make(DeclGroupRef(Ptr));
Chris Lattner5bbb3c82009-03-29 16:50:03 +000057}
58
Douglas Gregorec6e1892009-02-04 19:16:12 +000059/// \brief If the identifier refers to a type name within this scope,
60/// return the declaration of that type.
61///
62/// This routine performs ordinary name lookup of the identifier II
63/// within the given scope, with optional C++ scope specifier SS, to
Douglas Gregor9817f4a2009-02-09 15:09:02 +000064/// determine whether the name refers to a type. If so, returns an
65/// opaque pointer (actually a QualType) corresponding to that
66/// type. Otherwise, returns NULL.
Douglas Gregorec6e1892009-02-04 19:16:12 +000067///
68/// If name lookup results in an ambiguity, this routine will complain
69/// and then return NULL.
John McCallba7bf592010-08-24 05:47:05 +000070ParsedType Sema::getTypeName(IdentifierInfo &II, SourceLocation NameLoc,
71 Scope *S, CXXScopeSpec *SS,
Fariborz Jahanian87967422011-02-08 18:05:59 +000072 bool isClassName, bool HasTrailingDot,
Douglas Gregor844cb502011-03-01 18:12:44 +000073 ParsedType ObjectTypePtr,
Kaelyn Uhrain85308c62011-10-11 01:02:41 +000074 bool WantNontrivialTypeSourceInfo,
75 IdentifierInfo **CorrectedII) {
Douglas Gregora25d65d2009-11-20 22:03:38 +000076 // Determine where we will perform name lookup.
77 DeclContext *LookupCtx = 0;
78 if (ObjectTypePtr) {
John McCallba7bf592010-08-24 05:47:05 +000079 QualType ObjectType = ObjectTypePtr.get();
Douglas Gregora25d65d2009-11-20 22:03:38 +000080 if (ObjectType->isRecordType())
81 LookupCtx = computeDeclContext(ObjectType);
Jeffrey Yasskin4e150f82010-04-07 23:29:58 +000082 } else if (SS && SS->isNotEmpty()) {
Douglas Gregora25d65d2009-11-20 22:03:38 +000083 LookupCtx = computeDeclContext(*SS, false);
84
85 if (!LookupCtx) {
86 if (isDependentScopeSpecifier(*SS)) {
87 // C++ [temp.res]p3:
88 // A qualified-id that refers to a type and in which the
89 // nested-name-specifier depends on a template-parameter (14.6.2)
90 // shall be prefixed by the keyword typename to indicate that the
91 // qualified-id denotes a type, forming an
92 // elaborated-type-specifier (7.1.5.3).
93 //
94 // We therefore do not perform any name lookup if the result would
95 // refer to a member of an unknown specialization.
96 if (!isClassName)
John McCallba7bf592010-08-24 05:47:05 +000097 return ParsedType();
Douglas Gregora25d65d2009-11-20 22:03:38 +000098
John McCallc392f372010-06-11 00:33:02 +000099 // We know from the grammar that this name refers to a type,
100 // so build a dependent node to describe the type.
Douglas Gregor844cb502011-03-01 18:12:44 +0000101 if (WantNontrivialTypeSourceInfo)
102 return ActOnTypenameType(S, SourceLocation(), *SS, II, NameLoc).get();
103
104 NestedNameSpecifierLoc QualifierLoc = SS->getWithLocInContext(Context);
John McCallba7bf592010-08-24 05:47:05 +0000105 QualType T =
Douglas Gregor844cb502011-03-01 18:12:44 +0000106 CheckTypenameType(ETK_None, SourceLocation(), QualifierLoc,
Douglas Gregor9cbc22b2011-02-28 22:42:13 +0000107 II, NameLoc);
Douglas Gregor844cb502011-03-01 18:12:44 +0000108
109 return ParsedType::make(T);
Douglas Gregora25d65d2009-11-20 22:03:38 +0000110 }
111
John McCallba7bf592010-08-24 05:47:05 +0000112 return ParsedType();
Douglas Gregora25d65d2009-11-20 22:03:38 +0000113 }
114
John McCall0b66eb32010-05-01 00:40:08 +0000115 if (!LookupCtx->isDependentContext() &&
116 RequireCompleteDeclContext(*SS, LookupCtx))
John McCallba7bf592010-08-24 05:47:05 +0000117 return ParsedType();
Douglas Gregor5e0962f2009-08-26 18:27:52 +0000118 }
Eli Friedman9025ec22009-12-21 01:42:38 +0000119
120 // FIXME: LookupNestedNameSpecifierName isn't the right kind of
121 // lookup for class-names.
122 LookupNameKind Kind = isClassName ? LookupNestedNameSpecifierName :
123 LookupOrdinaryName;
124 LookupResult Result(*this, &II, NameLoc, Kind);
Douglas Gregora25d65d2009-11-20 22:03:38 +0000125 if (LookupCtx) {
126 // Perform "qualified" name lookup into the declaration context we
127 // computed, which is either the type of the base of a member access
128 // expression or the declaration context associated with a prior
129 // nested-name-specifier.
130 LookupQualifiedName(Result, LookupCtx);
Douglas Gregorc9f9b862009-05-11 19:58:34 +0000131
Douglas Gregora25d65d2009-11-20 22:03:38 +0000132 if (ObjectTypePtr && Result.empty()) {
133 // C++ [basic.lookup.classref]p3:
134 // If the unqualified-id is ~type-name, the type-name is looked up
135 // in the context of the entire postfix-expression. If the type T of
136 // the object expression is of a class type C, the type-name is also
137 // looked up in the scope of class C. At least one of the lookups shall
138 // find a name that refers to (possibly cv-qualified) T.
139 LookupName(Result, S);
140 }
141 } else {
142 // Perform unqualified name lookup.
143 LookupName(Result, S);
144 }
145
Chris Lattnera3778332009-02-16 22:07:16 +0000146 NamedDecl *IIDecl = 0;
John McCall27b18f82009-11-17 02:14:36 +0000147 switch (Result.getResultKind()) {
Chris Lattnera3778332009-02-16 22:07:16 +0000148 case LookupResult::NotFound:
Douglas Gregord0d2ee02010-01-15 01:44:47 +0000149 case LookupResult::NotFoundInCurrentInstantiation:
Kaelyn Uhrain85308c62011-10-11 01:02:41 +0000150 if (CorrectedII) {
151 TypoCorrection Correction = CorrectTypo(Result.getLookupNameInfo(),
152 Kind, S, SS, 0, false,
153 Sema::CTC_Type);
154 IdentifierInfo *NewII = Correction.getCorrectionAsIdentifierInfo();
155 TemplateTy Template;
156 bool MemberOfUnknownSpecialization;
157 UnqualifiedId TemplateName;
158 TemplateName.setIdentifier(NewII, NameLoc);
159 NestedNameSpecifier *NNS = Correction.getCorrectionSpecifier();
160 CXXScopeSpec NewSS, *NewSSPtr = SS;
161 if (SS && NNS) {
162 NewSS.MakeTrivial(Context, NNS, SourceRange(NameLoc));
163 NewSSPtr = &NewSS;
164 }
165 if (Correction && (NNS || NewII != &II) &&
166 // Ignore a correction to a template type as the to-be-corrected
167 // identifier is not a template (typo correction for template names
168 // is handled elsewhere).
169 !(getLangOptions().CPlusPlus && NewSSPtr &&
170 isTemplateName(S, *NewSSPtr, false, TemplateName, ParsedType(),
171 false, Template, MemberOfUnknownSpecialization))) {
172 ParsedType Ty = getTypeName(*NewII, NameLoc, S, NewSSPtr,
173 isClassName, HasTrailingDot, ObjectTypePtr,
174 WantNontrivialTypeSourceInfo);
175 if (Ty) {
176 std::string CorrectedStr(Correction.getAsString(getLangOptions()));
177 std::string CorrectedQuotedStr(
178 Correction.getQuoted(getLangOptions()));
179 Diag(NameLoc, diag::err_unknown_typename_suggest)
180 << Result.getLookupName() << CorrectedQuotedStr
181 << FixItHint::CreateReplacement(SourceRange(NameLoc),
182 CorrectedStr);
183 if (NamedDecl *FirstDecl = Correction.getCorrectionDecl())
184 Diag(FirstDecl->getLocation(), diag::note_previous_decl)
185 << CorrectedQuotedStr;
186
187 if (SS && NNS)
188 SS->MakeTrivial(Context, NNS, SourceRange(NameLoc));
189 *CorrectedII = NewII;
190 return Ty;
191 }
192 }
193 }
194 // If typo correction failed or was not performed, fall through
Chris Lattnera3778332009-02-16 22:07:16 +0000195 case LookupResult::FoundOverloaded:
John McCalle61f2ba2009-11-18 02:36:19 +0000196 case LookupResult::FoundUnresolvedValue:
John McCall58cc69d2010-01-27 01:50:18 +0000197 Result.suppressDiagnostics();
John McCallba7bf592010-08-24 05:47:05 +0000198 return ParsedType();
Douglas Gregor8a6be5e2009-02-04 17:00:24 +0000199
Chris Lattnere40853a2009-10-25 22:09:09 +0000200 case LookupResult::Ambiguous:
John McCall6538c932009-10-10 05:48:19 +0000201 // Recover from type-hiding ambiguities by hiding the type. We'll
202 // do the lookup again when looking for an object, and we can
203 // diagnose the error then. If we don't do this, then the error
204 // about hiding the type will be immediately followed by an error
205 // that only makes sense if the identifier was treated like a type.
John McCall27b18f82009-11-17 02:14:36 +0000206 if (Result.getAmbiguityKind() == LookupResult::AmbiguousTagHiding) {
207 Result.suppressDiagnostics();
John McCallba7bf592010-08-24 05:47:05 +0000208 return ParsedType();
John McCall27b18f82009-11-17 02:14:36 +0000209 }
John McCall6538c932009-10-10 05:48:19 +0000210
Douglas Gregorfe3d7d02009-04-01 21:51:26 +0000211 // Look to see if we have a type anywhere in the list of results.
212 for (LookupResult::iterator Res = Result.begin(), ResEnd = Result.end();
213 Res != ResEnd; ++Res) {
214 if (isa<TypeDecl>(*Res) || isa<ObjCInterfaceDecl>(*Res)) {
Mike Stump11289f42009-09-09 15:08:12 +0000215 if (!IIDecl ||
216 (*Res)->getLocation().getRawEncoding() <
Douglas Gregor712a3512009-04-13 15:14:38 +0000217 IIDecl->getLocation().getRawEncoding())
218 IIDecl = *Res;
Douglas Gregorfe3d7d02009-04-01 21:51:26 +0000219 }
220 }
221
222 if (!IIDecl) {
223 // None of the entities we found is a type, so there is no way
224 // to even assume that the result is a type. In this case, don't
225 // complain about the ambiguity. The parser will either try to
226 // perform this lookup again (e.g., as an object name), which
227 // will produce the ambiguity, or will complain that it expected
228 // a type name.
John McCall27b18f82009-11-17 02:14:36 +0000229 Result.suppressDiagnostics();
John McCallba7bf592010-08-24 05:47:05 +0000230 return ParsedType();
Douglas Gregorfe3d7d02009-04-01 21:51:26 +0000231 }
232
233 // We found a type within the ambiguous lookup; diagnose the
234 // ambiguity and then return that type. This might be the right
235 // answer, or it might not be, but it suppresses any attempt to
236 // perform the name lookup again.
Douglas Gregorfe3d7d02009-04-01 21:51:26 +0000237 break;
Douglas Gregor8a6be5e2009-02-04 17:00:24 +0000238
Chris Lattnera3778332009-02-16 22:07:16 +0000239 case LookupResult::Found:
John McCall9f3059a2009-10-09 21:13:30 +0000240 IIDecl = Result.getFoundDecl();
Chris Lattnera3778332009-02-16 22:07:16 +0000241 break;
Douglas Gregor960b5bc2009-01-15 00:26:24 +0000242 }
243
Chris Lattner17e15f12009-10-25 17:16:46 +0000244 assert(IIDecl && "Didn't find decl");
John McCall28a6aea2009-11-04 02:18:39 +0000245
Chris Lattner17e15f12009-10-25 17:16:46 +0000246 QualType T;
247 if (TypeDecl *TD = dyn_cast<TypeDecl>(IIDecl)) {
John McCall28a6aea2009-11-04 02:18:39 +0000248 DiagnoseUseOfDecl(IIDecl, NameLoc);
John McCall27b18f82009-11-17 02:14:36 +0000249
Chris Lattner17e15f12009-10-25 17:16:46 +0000250 if (T.isNull())
251 T = Context.getTypeDeclType(TD);
252
Douglas Gregor844cb502011-03-01 18:12:44 +0000253 if (SS && SS->isNotEmpty()) {
254 if (WantNontrivialTypeSourceInfo) {
255 // Construct a type with type-source information.
256 TypeLocBuilder Builder;
257 Builder.pushTypeSpec(T).setNameLoc(NameLoc);
258
259 T = getElaboratedType(ETK_None, *SS, T);
260 ElaboratedTypeLoc ElabTL = Builder.push<ElaboratedTypeLoc>(T);
261 ElabTL.setKeywordLoc(SourceLocation());
262 ElabTL.setQualifierLoc(SS->getWithLocInContext(Context));
263 return CreateParsedType(T, Builder.getTypeSourceInfo(Context, T));
264 } else {
265 T = getElaboratedType(ETK_None, *SS, T);
266 }
267 }
Chris Lattner17e15f12009-10-25 17:16:46 +0000268 } else if (ObjCInterfaceDecl *IDecl = dyn_cast<ObjCInterfaceDecl>(IIDecl)) {
Fariborz Jahanian08891f52011-03-08 19:12:46 +0000269 (void)DiagnoseUseOfDecl(IDecl, NameLoc);
Fariborz Jahanian87967422011-02-08 18:05:59 +0000270 if (!HasTrailingDot)
271 T = Context.getObjCInterfaceType(IDecl);
272 }
273
274 if (T.isNull()) {
John McCall27b18f82009-11-17 02:14:36 +0000275 // If it's not plausibly a type, suppress diagnostics.
276 Result.suppressDiagnostics();
John McCallba7bf592010-08-24 05:47:05 +0000277 return ParsedType();
John McCall27b18f82009-11-17 02:14:36 +0000278 }
John McCallba7bf592010-08-24 05:47:05 +0000279 return ParsedType::make(T);
Chris Lattnere168f762006-11-10 05:29:30 +0000280}
281
Chris Lattnerffaa0e62009-04-12 21:49:30 +0000282/// isTagName() - This method is called *for error recovery purposes only*
283/// to determine if the specified name is a valid tag name ("struct foo"). If
284/// so, this returns the TST for the tag corresponding to it (TST_enum,
285/// TST_union, TST_struct, TST_class). This is used to diagnose cases in C
286/// where the user forgot to specify the tag.
287DeclSpec::TST Sema::isTagName(IdentifierInfo &II, Scope *S) {
288 // Do a tag name lookup in this scope.
John McCall27b18f82009-11-17 02:14:36 +0000289 LookupResult R(*this, &II, SourceLocation(), LookupTagName);
290 LookupName(R, S, false);
291 R.suppressDiagnostics();
292 if (R.getResultKind() == LookupResult::Found)
John McCall67c00872009-12-02 08:25:40 +0000293 if (const TagDecl *TD = R.getAsSingle<TagDecl>()) {
Chris Lattnerffaa0e62009-04-12 21:49:30 +0000294 switch (TD->getTagKind()) {
Abramo Bagnara6150c882010-05-11 21:36:43 +0000295 default: return DeclSpec::TST_unspecified;
296 case TTK_Struct: return DeclSpec::TST_struct;
297 case TTK_Union: return DeclSpec::TST_union;
298 case TTK_Class: return DeclSpec::TST_class;
299 case TTK_Enum: return DeclSpec::TST_enum;
Chris Lattnerffaa0e62009-04-12 21:49:30 +0000300 }
301 }
Mike Stump11289f42009-09-09 15:08:12 +0000302
Chris Lattnerffaa0e62009-04-12 21:49:30 +0000303 return DeclSpec::TST_unspecified;
304}
305
Francois Pichet48c946e2011-04-13 02:38:49 +0000306/// isMicrosoftMissingTypename - In Microsoft mode, within class scope,
307/// if a CXXScopeSpec's type is equal to the type of one of the base classes
308/// then downgrade the missing typename error to a warning.
309/// This is needed for MSVC compatibility; Example:
310/// @code
311/// template<class T> class A {
312/// public:
313/// typedef int TYPE;
314/// };
315/// template<class T> class B : public A<T> {
316/// public:
317/// A<T>::TYPE a; // no typename required because A<T> is a base class.
318/// };
319/// @endcode
Francois Pichet9a57fb52011-10-11 01:50:09 +0000320bool Sema::isMicrosoftMissingTypename(const CXXScopeSpec *SS, Scope *S) {
Francois Pichet48c946e2011-04-13 02:38:49 +0000321 if (CurContext->isRecord()) {
Francois Pichetefc283c2011-04-13 02:44:57 +0000322 const Type *Ty = SS->getScopeRep()->getAsType();
Francois Pichet48c946e2011-04-13 02:38:49 +0000323
324 CXXRecordDecl *RD = cast<CXXRecordDecl>(CurContext);
325 for (CXXRecordDecl::base_class_const_iterator Base = RD->bases_begin(),
326 BaseEnd = RD->bases_end(); Base != BaseEnd; ++Base)
327 if (Context.hasSameUnqualifiedType(QualType(Ty, 1), Base->getType()))
328 return true;
Francois Pichet9a57fb52011-10-11 01:50:09 +0000329 return S->isFunctionPrototypeScope();
Francois Pichet48c946e2011-04-13 02:38:49 +0000330 }
Francois Pichet9a57fb52011-10-11 01:50:09 +0000331 return CurContext->isFunctionOrMethod() || S->isFunctionPrototypeScope();
Francois Pichet48c946e2011-04-13 02:38:49 +0000332}
333
Douglas Gregor15e56022009-10-13 23:27:22 +0000334bool Sema::DiagnoseUnknownTypeName(const IdentifierInfo &II,
335 SourceLocation IILoc,
336 Scope *S,
Jeffrey Yasskinc76498d2010-04-08 16:38:48 +0000337 CXXScopeSpec *SS,
John McCallba7bf592010-08-24 05:47:05 +0000338 ParsedType &SuggestedType) {
Douglas Gregor15e56022009-10-13 23:27:22 +0000339 // We don't have anything to suggest (yet).
John McCallba7bf592010-08-24 05:47:05 +0000340 SuggestedType = ParsedType();
Douglas Gregor15e56022009-10-13 23:27:22 +0000341
Douglas Gregor2d435302009-12-30 17:04:44 +0000342 // There may have been a typo in the name of the type. Look up typo
343 // results, in case we have something that we can suggest.
Douglas Gregorc2fa1692011-06-28 16:20:02 +0000344 if (TypoCorrection Corrected = CorrectTypo(DeclarationNameInfo(&II, IILoc),
345 LookupOrdinaryName, S, SS, NULL,
346 false, CTC_Type)) {
347 std::string CorrectedStr(Corrected.getAsString(getLangOptions()));
348 std::string CorrectedQuotedStr(Corrected.getQuoted(getLangOptions()));
Douglas Gregor2d435302009-12-30 17:04:44 +0000349
Douglas Gregorc2fa1692011-06-28 16:20:02 +0000350 if (Corrected.isKeyword()) {
351 // We corrected to a keyword.
352 // FIXME: Actually recover with the keyword we suggest, and emit a fix-it.
353 Diag(IILoc, diag::err_unknown_typename_suggest)
354 << &II << CorrectedQuotedStr;
355 return true;
356 } else {
357 NamedDecl *Result = Corrected.getCorrectionDecl();
Douglas Gregor280e1ee2010-04-14 20:04:41 +0000358 if ((isa<TypeDecl>(Result) || isa<ObjCInterfaceDecl>(Result)) &&
359 !Result->isInvalidDecl()) {
360 // We found a similarly-named type or interface; suggest that.
361 if (!SS || !SS->isSet())
362 Diag(IILoc, diag::err_unknown_typename_suggest)
Douglas Gregorc2fa1692011-06-28 16:20:02 +0000363 << &II << CorrectedQuotedStr
364 << FixItHint::CreateReplacement(SourceRange(IILoc), CorrectedStr);
Douglas Gregor280e1ee2010-04-14 20:04:41 +0000365 else if (DeclContext *DC = computeDeclContext(*SS, false))
366 Diag(IILoc, diag::err_unknown_nested_typename_suggest)
Douglas Gregorc2fa1692011-06-28 16:20:02 +0000367 << &II << DC << CorrectedQuotedStr << SS->getRange()
368 << FixItHint::CreateReplacement(SourceRange(IILoc), CorrectedStr);
Douglas Gregor280e1ee2010-04-14 20:04:41 +0000369 else
370 llvm_unreachable("could not have corrected a typo here");
Douglas Gregor2d435302009-12-30 17:04:44 +0000371
Douglas Gregor280e1ee2010-04-14 20:04:41 +0000372 Diag(Result->getLocation(), diag::note_previous_decl)
Douglas Gregorc2fa1692011-06-28 16:20:02 +0000373 << CorrectedQuotedStr;
Douglas Gregor280e1ee2010-04-14 20:04:41 +0000374
Douglas Gregor844cb502011-03-01 18:12:44 +0000375 SuggestedType = getTypeName(*Result->getIdentifier(), IILoc, S, SS,
376 false, false, ParsedType(),
377 /*NonTrivialTypeSourceInfo=*/true);
Douglas Gregor280e1ee2010-04-14 20:04:41 +0000378 return true;
379 }
Douglas Gregor2d435302009-12-30 17:04:44 +0000380 }
381 }
382
Jeffrey Yasskin54eba422010-04-08 21:04:54 +0000383 if (getLangOptions().CPlusPlus) {
384 // See if II is a class template that the user forgot to pass arguments to.
385 UnqualifiedId Name;
386 Name.setIdentifier(&II, IILoc);
387 CXXScopeSpec EmptySS;
388 TemplateTy TemplateResult;
Douglas Gregor786123d2010-05-21 23:18:07 +0000389 bool MemberOfUnknownSpecialization;
Abramo Bagnara7c5dee42010-08-06 12:11:11 +0000390 if (isTemplateName(S, SS ? *SS : EmptySS, /*hasTemplateKeyword=*/false,
John McCallba7bf592010-08-24 05:47:05 +0000391 Name, ParsedType(), true, TemplateResult,
Douglas Gregor786123d2010-05-21 23:18:07 +0000392 MemberOfUnknownSpecialization) == TNK_Type_template) {
Jeffrey Yasskin54eba422010-04-08 21:04:54 +0000393 TemplateName TplName = TemplateResult.getAsVal<TemplateName>();
394 Diag(IILoc, diag::err_template_missing_args) << TplName;
395 if (TemplateDecl *TplDecl = TplName.getAsTemplateDecl()) {
396 Diag(TplDecl->getLocation(), diag::note_template_decl_here)
397 << TplDecl->getTemplateParameters()->getSourceRange();
398 }
399 return true;
400 }
401 }
402
Douglas Gregor15e56022009-10-13 23:27:22 +0000403 // FIXME: Should we move the logic that tries to recover from a missing tag
404 // (struct, union, enum) from Parser::ParseImplicitInt here, instead?
405
Douglas Gregor2d435302009-12-30 17:04:44 +0000406 if (!SS || (!SS->isSet() && !SS->isInvalid()))
Douglas Gregor15e56022009-10-13 23:27:22 +0000407 Diag(IILoc, diag::err_unknown_typename) << &II;
408 else if (DeclContext *DC = computeDeclContext(*SS, false))
409 Diag(IILoc, diag::err_typename_nested_not_found)
410 << &II << DC << SS->getRange();
411 else if (isDependentScopeSpecifier(*SS)) {
Francois Pichet48c946e2011-04-13 02:38:49 +0000412 unsigned DiagID = diag::err_typename_missing;
Francois Pichet9a57fb52011-10-11 01:50:09 +0000413 if (getLangOptions().MicrosoftMode && isMicrosoftMissingTypename(SS, S))
Francois Pichet93921652011-04-22 08:25:24 +0000414 DiagID = diag::warn_typename_missing;
Francois Pichet48c946e2011-04-13 02:38:49 +0000415
416 Diag(SS->getRange().getBegin(), DiagID)
Daniel Dunbar07d07852009-10-18 21:17:35 +0000417 << (NestedNameSpecifier *)SS->getScopeRep() << II.getName()
Douglas Gregor15e56022009-10-13 23:27:22 +0000418 << SourceRange(SS->getRange().getBegin(), IILoc)
Douglas Gregora771f462010-03-31 17:46:05 +0000419 << FixItHint::CreateInsertion(SS->getRange().getBegin(), "typename ");
Douglas Gregorf7d77712010-06-16 22:31:08 +0000420 SuggestedType = ActOnTypenameType(S, SourceLocation(), *SS, II, IILoc).get();
Douglas Gregor15e56022009-10-13 23:27:22 +0000421 } else {
422 assert(SS && SS->isInvalid() &&
423 "Invalid scope specifier has already been diagnosed");
424 }
425
426 return true;
427}
Chris Lattnerffaa0e62009-04-12 21:49:30 +0000428
Douglas Gregor0e7dde52011-04-24 05:37:28 +0000429/// \brief Determine whether the given result set contains either a type name
430/// or
431static bool isResultTypeOrTemplate(LookupResult &R, const Token &NextToken) {
432 bool CheckTemplate = R.getSema().getLangOptions().CPlusPlus &&
433 NextToken.is(tok::less);
434
435 for (LookupResult::iterator I = R.begin(), IEnd = R.end(); I != IEnd; ++I) {
436 if (isa<TypeDecl>(*I) || isa<ObjCInterfaceDecl>(*I))
437 return true;
438
439 if (CheckTemplate && isa<TemplateDecl>(*I))
440 return true;
441 }
442
443 return false;
444}
445
446Sema::NameClassification Sema::ClassifyName(Scope *S,
447 CXXScopeSpec &SS,
448 IdentifierInfo *&Name,
449 SourceLocation NameLoc,
450 const Token &NextToken) {
451 DeclarationNameInfo NameInfo(Name, NameLoc);
452 ObjCMethodDecl *CurMethod = getCurMethodDecl();
453
454 if (NextToken.is(tok::coloncolon)) {
455 BuildCXXNestedNameSpecifier(S, *Name, NameLoc, NextToken.getLocation(),
456 QualType(), false, SS, 0, false);
457
458 }
459
460 LookupResult Result(*this, Name, NameLoc, LookupOrdinaryName);
461 LookupParsedName(Result, S, &SS, !CurMethod);
462
463 // Perform lookup for Objective-C instance variables (including automatically
464 // synthesized instance variables), if we're in an Objective-C method.
465 // FIXME: This lookup really, really needs to be folded in to the normal
466 // unqualified lookup mechanism.
467 if (!SS.isSet() && CurMethod && !isResultTypeOrTemplate(Result, NextToken)) {
468 ExprResult E = LookupInObjCMethod(Result, S, Name, true);
Douglas Gregorb90f5182011-04-25 15:05:41 +0000469 if (E.get() || E.isInvalid())
Douglas Gregor0e7dde52011-04-24 05:37:28 +0000470 return E;
Douglas Gregor0e7dde52011-04-24 05:37:28 +0000471 }
472
473 bool SecondTry = false;
474 bool IsFilteredTemplateName = false;
475
476Corrected:
477 switch (Result.getResultKind()) {
478 case LookupResult::NotFound:
479 // If an unqualified-id is followed by a '(', then we have a function
480 // call.
481 if (!SS.isSet() && NextToken.is(tok::l_paren)) {
482 // In C++, this is an ADL-only call.
483 // FIXME: Reference?
484 if (getLangOptions().CPlusPlus)
485 return BuildDeclarationNameExpr(SS, Result, /*ADL=*/true);
486
487 // C90 6.3.2.2:
488 // If the expression that precedes the parenthesized argument list in a
489 // function call consists solely of an identifier, and if no
490 // declaration is visible for this identifier, the identifier is
491 // implicitly declared exactly as if, in the innermost block containing
492 // the function call, the declaration
493 //
494 // extern int identifier ();
495 //
496 // appeared.
497 //
498 // We also allow this in C99 as an extension.
499 if (NamedDecl *D = ImplicitlyDefineFunction(NameLoc, *Name, S)) {
500 Result.addDecl(D);
501 Result.resolveKind();
502 return BuildDeclarationNameExpr(SS, Result, /*ADL=*/false);
503 }
504 }
505
506 // In C, we first see whether there is a tag type by the same name, in
507 // which case it's likely that the user just forget to write "enum",
508 // "struct", or "union".
509 if (!getLangOptions().CPlusPlus && !SecondTry) {
510 Result.clear(LookupTagName);
511 LookupParsedName(Result, S, &SS);
512 if (TagDecl *Tag = Result.getAsSingle<TagDecl>()) {
513 const char *TagName = 0;
514 const char *FixItTagName = 0;
515 switch (Tag->getTagKind()) {
516 case TTK_Class:
517 TagName = "class";
518 FixItTagName = "class ";
519 break;
520
521 case TTK_Enum:
522 TagName = "enum";
523 FixItTagName = "enum ";
524 break;
525
526 case TTK_Struct:
527 TagName = "struct";
528 FixItTagName = "struct ";
529 break;
530
531 case TTK_Union:
532 TagName = "union";
533 FixItTagName = "union ";
534 break;
535 }
536
537 Diag(NameLoc, diag::err_use_of_tag_name_without_tag)
538 << Name << TagName << getLangOptions().CPlusPlus
539 << FixItHint::CreateInsertion(NameLoc, FixItTagName);
540 break;
541 }
542
543 Result.clear(LookupOrdinaryName);
544 }
545
546 // Perform typo correction to determine if there is another name that is
547 // close to this name.
548 if (!SecondTry) {
Douglas Gregor5cf0e152011-07-14 04:54:23 +0000549 SecondTry = true;
Douglas Gregorc2fa1692011-06-28 16:20:02 +0000550 if (TypoCorrection Corrected = CorrectTypo(Result.getLookupNameInfo(),
551 Result.getLookupKind(), S, &SS)) {
Douglas Gregor5e16c162011-04-27 03:47:06 +0000552 unsigned UnqualifiedDiag = diag::err_undeclared_var_use_suggest;
553 unsigned QualifiedDiag = diag::err_no_member_suggest;
Douglas Gregorc2fa1692011-06-28 16:20:02 +0000554 std::string CorrectedStr(Corrected.getAsString(getLangOptions()));
555 std::string CorrectedQuotedStr(Corrected.getQuoted(getLangOptions()));
Douglas Gregor5e16c162011-04-27 03:47:06 +0000556
Douglas Gregorc2fa1692011-06-28 16:20:02 +0000557 NamedDecl *FirstDecl = Corrected.getCorrectionDecl();
Douglas Gregor8b02cd02011-04-27 04:48:22 +0000558 NamedDecl *UnderlyingFirstDecl
559 = FirstDecl? FirstDecl->getUnderlyingDecl() : 0;
Douglas Gregor5e16c162011-04-27 03:47:06 +0000560 if (getLangOptions().CPlusPlus && NextToken.is(tok::less) &&
Douglas Gregor8b02cd02011-04-27 04:48:22 +0000561 UnderlyingFirstDecl && isa<TemplateDecl>(UnderlyingFirstDecl)) {
Douglas Gregor5e16c162011-04-27 03:47:06 +0000562 UnqualifiedDiag = diag::err_no_template_suggest;
563 QualifiedDiag = diag::err_no_member_template_suggest;
Douglas Gregor8b02cd02011-04-27 04:48:22 +0000564 } else if (UnderlyingFirstDecl &&
565 (isa<TypeDecl>(UnderlyingFirstDecl) ||
566 isa<ObjCInterfaceDecl>(UnderlyingFirstDecl) ||
567 isa<ObjCCompatibleAliasDecl>(UnderlyingFirstDecl))) {
Douglas Gregor5e16c162011-04-27 03:47:06 +0000568 UnqualifiedDiag = diag::err_unknown_typename_suggest;
569 QualifiedDiag = diag::err_unknown_nested_typename_suggest;
570 }
Douglas Gregorc2fa1692011-06-28 16:20:02 +0000571
Douglas Gregor0e7dde52011-04-24 05:37:28 +0000572 if (SS.isEmpty())
Douglas Gregor5e16c162011-04-27 03:47:06 +0000573 Diag(NameLoc, UnqualifiedDiag)
Douglas Gregorc2fa1692011-06-28 16:20:02 +0000574 << Name << CorrectedQuotedStr
575 << FixItHint::CreateReplacement(NameLoc, CorrectedStr);
Douglas Gregor0e7dde52011-04-24 05:37:28 +0000576 else
Douglas Gregor5e16c162011-04-27 03:47:06 +0000577 Diag(NameLoc, QualifiedDiag)
Douglas Gregorc2fa1692011-06-28 16:20:02 +0000578 << Name << computeDeclContext(SS, false) << CorrectedQuotedStr
Douglas Gregor0e7dde52011-04-24 05:37:28 +0000579 << SS.getRange()
Douglas Gregorc2fa1692011-06-28 16:20:02 +0000580 << FixItHint::CreateReplacement(NameLoc, CorrectedStr);
Douglas Gregor0e7dde52011-04-24 05:37:28 +0000581
582 // Update the name, so that the caller has the new name.
Douglas Gregorc2fa1692011-06-28 16:20:02 +0000583 Name = Corrected.getCorrectionAsIdentifierInfo();
Douglas Gregor0e7dde52011-04-24 05:37:28 +0000584
Douglas Gregorc2fa1692011-06-28 16:20:02 +0000585 // Also update the LookupResult...
586 // FIXME: This should probably go away at some point
587 Result.clear();
588 Result.setLookupName(Corrected.getCorrection());
589 if (FirstDecl) Result.addDecl(FirstDecl);
590
Douglas Gregor0e7dde52011-04-24 05:37:28 +0000591 // Typo correction corrected to a keyword.
Douglas Gregorc2fa1692011-06-28 16:20:02 +0000592 if (Corrected.isKeyword())
593 return Corrected.getCorrectionAsIdentifierInfo();
Douglas Gregor0e7dde52011-04-24 05:37:28 +0000594
Douglas Gregor5cf0e152011-07-14 04:54:23 +0000595 if (FirstDecl)
596 Diag(FirstDecl->getLocation(), diag::note_previous_decl)
597 << CorrectedQuotedStr;
Douglas Gregor0e7dde52011-04-24 05:37:28 +0000598
599 // If we found an Objective-C instance variable, let
600 // LookupInObjCMethod build the appropriate expression to
601 // reference the ivar.
602 // FIXME: This is a gross hack.
603 if (ObjCIvarDecl *Ivar = Result.getAsSingle<ObjCIvarDecl>()) {
604 Result.clear();
605 ExprResult E(LookupInObjCMethod(Result, S, Ivar->getIdentifier()));
606 return move(E);
607 }
608
609 goto Corrected;
610 }
611 }
612
613 // We failed to correct; just fall through and let the parser deal with it.
614 Result.suppressDiagnostics();
615 return NameClassification::Unknown();
616
617 case LookupResult::NotFoundInCurrentInstantiation:
618 // We performed name lookup into the current instantiation, and there were
619 // dependent bases, so we treat this result the same way as any other
620 // dependent nested-name-specifier.
621
622 // C++ [temp.res]p2:
623 // A name used in a template declaration or definition and that is
624 // dependent on a template-parameter is assumed not to name a type
625 // unless the applicable name lookup finds a type name or the name is
626 // qualified by the keyword typename.
627 //
628 // FIXME: If the next token is '<', we might want to ask the parser to
629 // perform some heroics to see if we actually have a
630 // template-argument-list, which would indicate a missing 'template'
631 // keyword here.
632 return BuildDependentDeclRefExpr(SS, NameInfo, /*TemplateArgs=*/0);
633
634 case LookupResult::Found:
635 case LookupResult::FoundOverloaded:
636 case LookupResult::FoundUnresolvedValue:
637 break;
638
639 case LookupResult::Ambiguous:
Douglas Gregor8b02cd02011-04-27 04:48:22 +0000640 if (getLangOptions().CPlusPlus && NextToken.is(tok::less) &&
641 hasAnyAcceptableTemplateNames(Result)) {
Douglas Gregor0e7dde52011-04-24 05:37:28 +0000642 // C++ [temp.local]p3:
643 // A lookup that finds an injected-class-name (10.2) can result in an
644 // ambiguity in certain cases (for example, if it is found in more than
645 // one base class). If all of the injected-class-names that are found
646 // refer to specializations of the same class template, and if the name
647 // is followed by a template-argument-list, the reference refers to the
648 // class template itself and not a specialization thereof, and is not
649 // ambiguous.
650 //
651 // This filtering can make an ambiguous result into an unambiguous one,
652 // so try again after filtering out template names.
653 FilterAcceptableTemplateNames(Result);
654 if (!Result.isAmbiguous()) {
655 IsFilteredTemplateName = true;
656 break;
657 }
658 }
659
660 // Diagnose the ambiguity and return an error.
661 return NameClassification::Error();
662 }
663
664 if (getLangOptions().CPlusPlus && NextToken.is(tok::less) &&
665 (IsFilteredTemplateName || hasAnyAcceptableTemplateNames(Result))) {
666 // C++ [temp.names]p3:
667 // After name lookup (3.4) finds that a name is a template-name or that
668 // an operator-function-id or a literal- operator-id refers to a set of
669 // overloaded functions any member of which is a function template if
670 // this is followed by a <, the < is always taken as the delimiter of a
671 // template-argument-list and never as the less-than operator.
672 if (!IsFilteredTemplateName)
673 FilterAcceptableTemplateNames(Result);
674
Douglas Gregor8b02cd02011-04-27 04:48:22 +0000675 if (!Result.empty()) {
676 bool IsFunctionTemplate;
677 TemplateName Template;
678 if (Result.end() - Result.begin() > 1) {
679 IsFunctionTemplate = true;
680 Template = Context.getOverloadedTemplateName(Result.begin(),
681 Result.end());
682 } else {
683 TemplateDecl *TD
684 = cast<TemplateDecl>((*Result.begin())->getUnderlyingDecl());
685 IsFunctionTemplate = isa<FunctionTemplateDecl>(TD);
686
687 if (SS.isSet() && !SS.isInvalid())
688 Template = Context.getQualifiedTemplateName(SS.getScopeRep(),
Douglas Gregor0e7dde52011-04-24 05:37:28 +0000689 /*TemplateKeyword=*/false,
Douglas Gregor8b02cd02011-04-27 04:48:22 +0000690 TD);
691 else
692 Template = TemplateName(TD);
693 }
Douglas Gregor0e7dde52011-04-24 05:37:28 +0000694
Douglas Gregor8b02cd02011-04-27 04:48:22 +0000695 if (IsFunctionTemplate) {
696 // Function templates always go through overload resolution, at which
697 // point we'll perform the various checks (e.g., accessibility) we need
698 // to based on which function we selected.
699 Result.suppressDiagnostics();
700
701 return NameClassification::FunctionTemplate(Template);
702 }
703
704 return NameClassification::TypeTemplate(Template);
Douglas Gregor0e7dde52011-04-24 05:37:28 +0000705 }
Douglas Gregor0e7dde52011-04-24 05:37:28 +0000706 }
707
Douglas Gregor8b02cd02011-04-27 04:48:22 +0000708 NamedDecl *FirstDecl = (*Result.begin())->getUnderlyingDecl();
Douglas Gregor0e7dde52011-04-24 05:37:28 +0000709 if (TypeDecl *Type = dyn_cast<TypeDecl>(FirstDecl)) {
710 DiagnoseUseOfDecl(Type, NameLoc);
711 QualType T = Context.getTypeDeclType(Type);
712 return ParsedType::make(T);
713 }
714
715 ObjCInterfaceDecl *Class = dyn_cast<ObjCInterfaceDecl>(FirstDecl);
716 if (!Class) {
717 // FIXME: It's unfortunate that we don't have a Type node for handling this.
718 if (ObjCCompatibleAliasDecl *Alias
719 = dyn_cast<ObjCCompatibleAliasDecl>(FirstDecl))
720 Class = Alias->getClassInterface();
721 }
722
723 if (Class) {
724 DiagnoseUseOfDecl(Class, NameLoc);
725
726 if (NextToken.is(tok::period)) {
727 // Interface. <something> is parsed as a property reference expression.
728 // Just return "unknown" as a fall-through for now.
729 Result.suppressDiagnostics();
730 return NameClassification::Unknown();
731 }
732
733 QualType T = Context.getObjCInterfaceType(Class);
734 return ParsedType::make(T);
735 }
736
Douglas Gregor8b02cd02011-04-27 04:48:22 +0000737 if (!Result.empty() && (*Result.begin())->isCXXClassMember())
738 return BuildPossibleImplicitMemberExpr(SS, Result, 0);
739
Douglas Gregor0e7dde52011-04-24 05:37:28 +0000740 bool ADL = UseArgumentDependentLookup(SS, Result, NextToken.is(tok::l_paren));
741 return BuildDeclarationNameExpr(SS, Result, ADL);
742}
743
John McCall5ed6e8f2009-08-18 00:00:49 +0000744// Determines the context to return to after temporarily entering a
745// context. This depends in an unnecessarily complicated way on the
746// exact ordering of callbacks from the parser.
Argyrios Kyrtzidis16ac9be2008-11-08 17:17:31 +0000747DeclContext *Sema::getContainingDC(DeclContext *DC) {
Argyrios Kyrtzidis16ac9be2008-11-08 17:17:31 +0000748
John McCall5ed6e8f2009-08-18 00:00:49 +0000749 // Functions defined inline within classes aren't parsed until we've
750 // finished parsing the top-level class, so the top-level class is
751 // the context we'll need to return to.
752 if (isa<FunctionDecl>(DC)) {
753 DC = DC->getLexicalParent();
754
755 // A function not defined within a class will always return to its
756 // lexical context.
757 if (!isa<CXXRecordDecl>(DC))
758 return DC;
759
760 // A C++ inline method/friend is parsed *after* the topmost class
761 // it was declared in is fully parsed ("complete"); the topmost
762 // class is the context we need to return to.
Argyrios Kyrtzidis0d09c492008-11-19 18:01:13 +0000763 while (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(DC->getLexicalParent()))
Argyrios Kyrtzidised983422008-07-01 10:37:29 +0000764 DC = RD;
765
766 // Return the declaration context of the topmost class the inline method is
767 // declared in.
768 return DC;
769 }
770
Argyrios Kyrtzidis0d09c492008-11-19 18:01:13 +0000771 return DC->getLexicalParent();
Argyrios Kyrtzidised983422008-07-01 10:37:29 +0000772}
773
Douglas Gregor91f84212008-12-11 16:49:14 +0000774void Sema::PushDeclContext(Scope *S, DeclContext *DC) {
Argyrios Kyrtzidis16ac9be2008-11-08 17:17:31 +0000775 assert(getContainingDC(DC) == CurContext &&
Zhongxing Xu17a37eb2008-12-08 07:14:51 +0000776 "The next DeclContext should be lexically contained in the current one.");
Chris Lattnerbec41342008-04-22 18:39:57 +0000777 CurContext = DC;
Douglas Gregor91f84212008-12-11 16:49:14 +0000778 S->setEntity(DC);
Chris Lattnerc5ffed42008-04-04 06:12:32 +0000779}
780
Chris Lattner0a5ff0d2008-04-06 04:47:34 +0000781void Sema::PopDeclContext() {
782 assert(CurContext && "DeclContext imbalance!");
Douglas Gregor91f84212008-12-11 16:49:14 +0000783
Argyrios Kyrtzidis16ac9be2008-11-08 17:17:31 +0000784 CurContext = getContainingDC(CurContext);
John McCalldd762d12010-07-23 22:45:07 +0000785 assert(CurContext && "Popped translation unit!");
Chris Lattnerc5ffed42008-04-04 06:12:32 +0000786}
787
Argyrios Kyrtzidis9941a4d2009-06-17 23:19:02 +0000788/// EnterDeclaratorContext - Used when we must lookup names in the context
789/// of a declarator's nested name specifier.
John McCall6df5fef2009-12-19 10:49:29 +0000790///
Argyrios Kyrtzidis7bcce492009-06-17 23:15:40 +0000791void Sema::EnterDeclaratorContext(Scope *S, DeclContext *DC) {
John McCall6df5fef2009-12-19 10:49:29 +0000792 // C++0x [basic.lookup.unqual]p13:
793 // A name used in the definition of a static data member of class
794 // X (after the qualified-id of the static member) is looked up as
795 // if the name was used in a member function of X.
796 // C++0x [basic.lookup.unqual]p14:
797 // If a variable member of a namespace is defined outside of the
798 // scope of its namespace then any name used in the definition of
799 // the variable member (after the declarator-id) is looked up as
800 // if the definition of the variable member occurred in its
801 // namespace.
802 // Both of these imply that we should push a scope whose context
803 // is the semantic context of the declaration. We can't use
804 // PushDeclContext here because that context is not necessarily
805 // lexically contained in the current context. Fortunately,
806 // the containing scope should have the appropriate information.
807
808 assert(!S->getEntity() && "scope already has entity");
809
810#ifndef NDEBUG
811 Scope *Ancestor = S->getParent();
812 while (!Ancestor->getEntity()) Ancestor = Ancestor->getParent();
813 assert(Ancestor->getEntity() == CurContext && "ancestor context mismatch");
814#endif
815
Argyrios Kyrtzidis7bcce492009-06-17 23:15:40 +0000816 CurContext = DC;
John McCall6df5fef2009-12-19 10:49:29 +0000817 S->setEntity(DC);
Argyrios Kyrtzidis7bcce492009-06-17 23:15:40 +0000818}
819
Argyrios Kyrtzidis7bcce492009-06-17 23:15:40 +0000820void Sema::ExitDeclaratorContext(Scope *S) {
John McCall6df5fef2009-12-19 10:49:29 +0000821 assert(S->getEntity() == CurContext && "Context imbalance!");
Argyrios Kyrtzidis7bcce492009-06-17 23:15:40 +0000822
John McCall6df5fef2009-12-19 10:49:29 +0000823 // Switch back to the lexical context. The safety of this is
824 // enforced by an assert in EnterDeclaratorContext.
825 Scope *Ancestor = S->getParent();
826 while (!Ancestor->getEntity()) Ancestor = Ancestor->getParent();
827 CurContext = (DeclContext*) Ancestor->getEntity();
828
829 // We don't need to do anything with the scope, which is going to
830 // disappear.
Argyrios Kyrtzidis7bcce492009-06-17 23:15:40 +0000831}
832
Caitlin Sadowski990d5712011-09-08 17:42:31 +0000833
834void Sema::ActOnReenterFunctionContext(Scope* S, Decl *D) {
835 FunctionDecl *FD = dyn_cast<FunctionDecl>(D);
836 if (FunctionTemplateDecl *TFD = dyn_cast_or_null<FunctionTemplateDecl>(D)) {
837 // We assume that the caller has already called
838 // ActOnReenterTemplateScope
839 FD = TFD->getTemplatedDecl();
840 }
841 if (!FD)
842 return;
843
844 PushDeclContext(S, FD);
845 for (unsigned P = 0, NumParams = FD->getNumParams(); P < NumParams; ++P) {
846 ParmVarDecl *Param = FD->getParamDecl(P);
847 // If the parameter has an identifier, then add it to the scope
848 if (Param->getIdentifier()) {
849 S->AddDecl(Param);
850 IdResolver.AddDecl(Param);
851 }
852 }
853}
854
855
Douglas Gregor4e5cbdc2009-02-11 23:02:49 +0000856/// \brief Determine whether we allow overloading of the function
857/// PrevDecl with another declaration.
858///
859/// This routine determines whether overloading is possible, not
860/// whether some new function is actually an overload. It will return
861/// true in C++ (where we can always provide overloads) or, as an
862/// extension, in C when the previous function is already an
863/// overloaded function declaration or has the "overloadable"
864/// attribute.
John McCall1f82f242009-11-18 22:49:29 +0000865static bool AllowOverloadingOfFunction(LookupResult &Previous,
866 ASTContext &Context) {
Douglas Gregor4e5cbdc2009-02-11 23:02:49 +0000867 if (Context.getLangOptions().CPlusPlus)
868 return true;
869
John McCall1f82f242009-11-18 22:49:29 +0000870 if (Previous.getResultKind() == LookupResult::FoundOverloaded)
Douglas Gregor4e5cbdc2009-02-11 23:02:49 +0000871 return true;
872
John McCall1f82f242009-11-18 22:49:29 +0000873 return (Previous.getResultKind() == LookupResult::Found
874 && Previous.getFoundDecl()->hasAttr<OverloadableAttr>());
Douglas Gregor4e5cbdc2009-02-11 23:02:49 +0000875}
876
Argyrios Kyrtzidisb8a49202008-04-12 00:47:19 +0000877/// Add this decl to the scope shadowed decl chains.
John McCall759e32b2009-08-31 22:39:49 +0000878void Sema::PushOnScopeChains(NamedDecl *D, Scope *S, bool AddToContext) {
Douglas Gregor07665a62009-01-05 19:45:36 +0000879 // Move up the scope chain until we find the nearest enclosing
880 // non-transparent context. The declaration will be introduced into this
881 // scope.
Mike Stump11289f42009-09-09 15:08:12 +0000882 while (S->getEntity() &&
Douglas Gregor07665a62009-01-05 19:45:36 +0000883 ((DeclContext *)S->getEntity())->isTransparentContext())
884 S = S->getParent();
885
Douglas Gregor8b9ccca2008-12-23 21:05:05 +0000886 // Add scoped declarations into their context, so that they can be
887 // found later. Declarations without a context won't be inserted
888 // into any context.
John McCall759e32b2009-08-31 22:39:49 +0000889 if (AddToContext)
890 CurContext->addDecl(D);
Douglas Gregor8b9ccca2008-12-23 21:05:05 +0000891
Chandler Carruthf50ef6e2010-02-21 07:08:09 +0000892 // Out-of-line definitions shouldn't be pushed into scope in C++.
893 // Out-of-line variable and function definitions shouldn't even in C.
894 if ((getLangOptions().CPlusPlus || isa<VarDecl>(D) || isa<FunctionDecl>(D)) &&
Douglas Gregorf7b98952011-10-09 22:57:49 +0000895 D->isOutOfLine() &&
896 !D->getDeclContext()->getRedeclContext()->Equals(
897 D->getLexicalDeclContext()->getRedeclContext()))
Chandler Carruthf50ef6e2010-02-21 07:08:09 +0000898 return;
899
900 // Template instantiations should also not be pushed into scope.
901 if (isa<FunctionDecl>(D) &&
902 cast<FunctionDecl>(D)->isFunctionTemplateSpecialization())
Douglas Gregor5ad7c542009-09-28 18:41:37 +0000903 return;
904
John McCall9f3059a2009-10-09 21:13:30 +0000905 // If this replaces anything in the current scope,
906 IdentifierResolver::iterator I = IdResolver.begin(D->getDeclName()),
907 IEnd = IdResolver.end();
908 for (; I != IEnd; ++I) {
John McCall48871652010-08-21 09:40:31 +0000909 if (S->isDeclScope(*I) && D->declarationReplaces(*I)) {
910 S->RemoveDecl(*I);
John McCall9f3059a2009-10-09 21:13:30 +0000911 IdResolver.RemoveDecl(*I);
Argyrios Kyrtzidisfa8e15b2008-05-09 23:39:43 +0000912
John McCall9f3059a2009-10-09 21:13:30 +0000913 // Should only need to replace one decl.
914 break;
Douglas Gregor38feed82009-04-24 02:57:34 +0000915 }
Argyrios Kyrtzidisfa8e15b2008-05-09 23:39:43 +0000916 }
Douglas Gregor5251f1b2008-10-21 16:13:35 +0000917
John McCall48871652010-08-21 09:40:31 +0000918 S->AddDecl(D);
Douglas Gregor88764cf2011-03-14 21:19:51 +0000919
920 if (isa<LabelDecl>(D) && !cast<LabelDecl>(D)->isGnuLocal()) {
921 // Implicitly-generated labels may end up getting generated in an order that
922 // isn't strictly lexical, which breaks name lookup. Be careful to insert
923 // the label at the appropriate place in the identifier chain.
924 for (I = IdResolver.begin(D->getDeclName()); I != IEnd; ++I) {
Douglas Gregord7d7e0d2011-03-24 14:35:16 +0000925 DeclContext *IDC = (*I)->getLexicalDeclContext()->getRedeclContext();
Douglas Gregor46c04e72011-03-16 16:39:03 +0000926 if (IDC == CurContext) {
927 if (!S->isDeclScope(*I))
928 continue;
929 } else if (IDC->Encloses(CurContext))
Douglas Gregor88764cf2011-03-14 21:19:51 +0000930 break;
931 }
932
Douglas Gregor46c04e72011-03-16 16:39:03 +0000933 IdResolver.InsertDeclAfter(I, D);
Douglas Gregor88764cf2011-03-14 21:19:51 +0000934 } else {
935 IdResolver.AddDecl(D);
936 }
Argyrios Kyrtzidisb8a49202008-04-12 00:47:19 +0000937}
938
Douglas Gregordb446112011-03-07 16:54:27 +0000939bool Sema::isDeclInScope(NamedDecl *&D, DeclContext *Ctx, Scope *S,
940 bool ExplicitInstantiationOrSpecialization) {
941 return IdResolver.isDeclInScope(D, Ctx, Context, S,
942 ExplicitInstantiationOrSpecialization);
Douglas Gregor505ad492009-09-28 00:47:05 +0000943}
944
John McCallcc14d1f2010-08-24 08:50:51 +0000945Scope *Sema::getScopeForDeclContext(Scope *S, DeclContext *DC) {
946 DeclContext *TargetDC = DC->getPrimaryContext();
947 do {
948 if (DeclContext *ScopeDC = (DeclContext*) S->getEntity())
949 if (ScopeDC->getPrimaryContext() == TargetDC)
950 return S;
951 } while ((S = S->getParent()));
952
953 return 0;
954}
955
John McCall1f82f242009-11-18 22:49:29 +0000956static bool isOutOfScopePreviousDeclaration(NamedDecl *,
957 DeclContext*,
958 ASTContext&);
959
960/// Filters out lookup results that don't fall within the given scope
961/// as determined by isDeclInScope.
Richard Smith3f1b5d02011-05-05 21:57:07 +0000962void Sema::FilterLookupForScope(LookupResult &R,
963 DeclContext *Ctx, Scope *S,
964 bool ConsiderLinkage,
965 bool ExplicitInstantiationOrSpecialization) {
John McCall1f82f242009-11-18 22:49:29 +0000966 LookupResult::Filter F = R.makeFilter();
967 while (F.hasNext()) {
968 NamedDecl *D = F.next();
969
Richard Smith3f1b5d02011-05-05 21:57:07 +0000970 if (isDeclInScope(D, Ctx, S, ExplicitInstantiationOrSpecialization))
John McCall1f82f242009-11-18 22:49:29 +0000971 continue;
972
973 if (ConsiderLinkage &&
Richard Smith3f1b5d02011-05-05 21:57:07 +0000974 isOutOfScopePreviousDeclaration(D, Ctx, Context))
John McCall1f82f242009-11-18 22:49:29 +0000975 continue;
976
977 F.erase();
978 }
979
980 F.done();
981}
982
983static bool isUsingDecl(NamedDecl *D) {
984 return isa<UsingShadowDecl>(D) ||
985 isa<UnresolvedUsingTypenameDecl>(D) ||
986 isa<UnresolvedUsingValueDecl>(D);
987}
988
989/// Removes using shadow declarations from the lookup results.
990static void RemoveUsingDecls(LookupResult &R) {
991 LookupResult::Filter F = R.makeFilter();
992 while (F.hasNext())
993 if (isUsingDecl(F.next()))
994 F.erase();
995
996 F.done();
997}
998
Argyrios Kyrtzidis04c7fa02010-08-15 10:17:33 +0000999/// \brief Check for this common pattern:
1000/// @code
1001/// class S {
1002/// S(const S&); // DO NOT IMPLEMENT
1003/// void operator=(const S&); // DO NOT IMPLEMENT
1004/// };
1005/// @endcode
1006static bool IsDisallowedCopyOrAssign(const CXXMethodDecl *D) {
1007 // FIXME: Should check for private access too but access is set after we get
1008 // the decl here.
Alexis Hunt4a8ea102011-05-06 20:44:56 +00001009 if (D->doesThisDeclarationHaveABody())
Argyrios Kyrtzidis04c7fa02010-08-15 10:17:33 +00001010 return false;
1011
1012 if (const CXXConstructorDecl *CD = dyn_cast<CXXConstructorDecl>(D))
1013 return CD->isCopyConstructor();
Douglas Gregora1ce1f82010-09-27 22:06:20 +00001014 if (const CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D))
1015 return Method->isCopyAssignmentOperator();
1016 return false;
Argyrios Kyrtzidis04c7fa02010-08-15 10:17:33 +00001017}
1018
Argyrios Kyrtzidis1b30d9c2010-08-15 01:15:20 +00001019bool Sema::ShouldWarnIfUnusedFileScopedDecl(const DeclaratorDecl *D) const {
1020 assert(D);
Argyrios Kyrtzidis540bc012010-08-13 18:42:29 +00001021
Argyrios Kyrtzidis1b30d9c2010-08-15 01:15:20 +00001022 if (D->isInvalidDecl() || D->isUsed() || D->hasAttr<UnusedAttr>())
1023 return false;
1024
1025 // Ignore class templates.
Chandler Carruth8e666512011-01-03 19:27:19 +00001026 if (D->getDeclContext()->isDependentContext() ||
1027 D->getLexicalDeclContext()->isDependentContext())
Argyrios Kyrtzidis1b30d9c2010-08-15 01:15:20 +00001028 return false;
1029
Argyrios Kyrtzidis1b30d9c2010-08-15 01:15:20 +00001030 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
Argyrios Kyrtzidis04c7fa02010-08-15 10:17:33 +00001031 if (FD->getTemplateSpecializationKind() == TSK_ImplicitInstantiation)
1032 return false;
Argyrios Kyrtzidis1b30d9c2010-08-15 01:15:20 +00001033
Argyrios Kyrtzidis04c7fa02010-08-15 10:17:33 +00001034 if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) {
1035 if (MD->isVirtual() || IsDisallowedCopyOrAssign(MD))
1036 return false;
1037 } else {
1038 // 'static inline' functions are used in headers; don't warn.
John McCall8e7d6562010-08-26 03:08:43 +00001039 if (FD->getStorageClass() == SC_Static &&
Argyrios Kyrtzidis04c7fa02010-08-15 10:17:33 +00001040 FD->isInlineSpecified())
1041 return false;
1042 }
Argyrios Kyrtzidis1b30d9c2010-08-15 01:15:20 +00001043
Alexis Hunt4a8ea102011-05-06 20:44:56 +00001044 if (FD->doesThisDeclarationHaveABody() &&
John McCalld37d35b2010-10-27 01:41:35 +00001045 Context.DeclMustBeEmitted(FD))
1046 return false;
John McCalld37d35b2010-10-27 01:41:35 +00001047 } else if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
1048 if (!VD->isFileVarDecl() ||
1049 VD->getType().isConstant(Context) ||
1050 Context.DeclMustBeEmitted(VD))
1051 return false;
1052
Argyrios Kyrtzidis1b30d9c2010-08-15 01:15:20 +00001053 if (VD->isStaticDataMember() &&
1054 VD->getTemplateSpecializationKind() == TSK_ImplicitInstantiation)
1055 return false;
1056
John McCalld37d35b2010-10-27 01:41:35 +00001057 } else {
1058 return false;
Argyrios Kyrtzidis1b30d9c2010-08-15 01:15:20 +00001059 }
1060
John McCalld37d35b2010-10-27 01:41:35 +00001061 // Only warn for unused decls internal to the translation unit.
1062 if (D->getLinkage() == ExternalLinkage)
1063 return false;
Argyrios Kyrtzidis1b30d9c2010-08-15 01:15:20 +00001064
John McCalld37d35b2010-10-27 01:41:35 +00001065 return true;
1066}
1067
1068void Sema::MarkUnusedFileScopedDecl(const DeclaratorDecl *D) {
Argyrios Kyrtzidis1b30d9c2010-08-15 01:15:20 +00001069 if (!D)
1070 return;
1071
1072 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
1073 const FunctionDecl *First = FD->getFirstDeclaration();
1074 if (FD != First && ShouldWarnIfUnusedFileScopedDecl(First))
1075 return; // First should already be in the vector.
1076 }
1077
1078 if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
1079 const VarDecl *First = VD->getFirstDeclaration();
1080 if (VD != First && ShouldWarnIfUnusedFileScopedDecl(First))
1081 return; // First should already be in the vector.
1082 }
1083
1084 if (ShouldWarnIfUnusedFileScopedDecl(D))
1085 UnusedFileScopedDecls.push_back(D);
1086 }
Argyrios Kyrtzidis35672e72010-08-13 18:42:17 +00001087
Anders Carlsson2889e0e2009-11-07 07:18:14 +00001088static bool ShouldDiagnoseUnusedDecl(const NamedDecl *D) {
John McCall67da35c2010-02-04 22:26:26 +00001089 if (D->isInvalidDecl())
1090 return false;
1091
Anders Carlssonf5dc6fa2009-11-07 07:26:56 +00001092 if (D->isUsed() || D->hasAttr<UnusedAttr>())
1093 return false;
John McCall67da35c2010-02-04 22:26:26 +00001094
Chris Lattnercab02a62011-02-17 20:34:02 +00001095 if (isa<LabelDecl>(D))
1096 return true;
1097
John McCall67da35c2010-02-04 22:26:26 +00001098 // White-list anything that isn't a local variable.
1099 if (!isa<VarDecl>(D) || isa<ParmVarDecl>(D) || isa<ImplicitParamDecl>(D) ||
1100 !D->getDeclContext()->isFunctionOrMethod())
1101 return false;
1102
1103 // Types of valid local variables should be complete, so this should succeed.
Anders Carlssonf5dc6fa2009-11-07 07:26:56 +00001104 if (const ValueDecl *VD = dyn_cast<ValueDecl>(D)) {
John McCallcef15822010-03-31 02:47:45 +00001105
1106 // White-list anything with an __attribute__((unused)) type.
1107 QualType Ty = VD->getType();
1108
1109 // Only look at the outermost level of typedef.
1110 if (const TypedefType *TT = dyn_cast<TypedefType>(Ty)) {
1111 if (TT->getDecl()->hasAttr<UnusedAttr>())
1112 return false;
1113 }
1114
Douglas Gregor14f232e2010-05-08 23:05:03 +00001115 // If we failed to complete the type for some reason, or if the type is
1116 // dependent, don't diagnose the variable.
1117 if (Ty->isIncompleteType() || Ty->isDependentType())
Douglas Gregor19defcd2010-04-27 16:20:13 +00001118 return false;
1119
John McCallcef15822010-03-31 02:47:45 +00001120 if (const TagType *TT = Ty->getAs<TagType>()) {
1121 const TagDecl *Tag = TT->getDecl();
1122 if (Tag->hasAttr<UnusedAttr>())
1123 return false;
1124
1125 if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(Tag)) {
Douglas Gregor14f232e2010-05-08 23:05:03 +00001126 // FIXME: Checking for the presence of a user-declared constructor
1127 // isn't completely accurate; we'd prefer to check that the initializer
1128 // has no side effects.
1129 if (RD->hasUserDeclaredConstructor() || !RD->hasTrivialDestructor())
Anders Carlssonf5dc6fa2009-11-07 07:26:56 +00001130 return false;
1131 }
1132 }
John McCallcef15822010-03-31 02:47:45 +00001133
1134 // TODO: __attribute__((unused)) templates?
Anders Carlssonf5dc6fa2009-11-07 07:26:56 +00001135 }
1136
John McCall67da35c2010-02-04 22:26:26 +00001137 return true;
Anders Carlsson2889e0e2009-11-07 07:18:14 +00001138}
1139
Anna Zaks964f4c62011-07-28 20:52:06 +00001140static void GenerateFixForUnusedDecl(const NamedDecl *D, ASTContext &Ctx,
1141 FixItHint &Hint) {
1142 if (isa<LabelDecl>(D)) {
1143 SourceLocation AfterColon = Lexer::findLocationAfterToken(D->getLocEnd(),
1144 tok::colon, Ctx.getSourceManager(), Ctx.getLangOptions(), true);
1145 if (AfterColon.isInvalid())
1146 return;
1147 Hint = FixItHint::CreateRemoval(CharSourceRange::
1148 getCharRange(D->getLocStart(), AfterColon));
1149 }
1150 return;
1151}
1152
Chris Lattnerebb5c6c2011-02-18 01:27:55 +00001153/// DiagnoseUnusedDecl - Emit warnings about declarations that are not used
1154/// unless they are marked attr(unused).
Douglas Gregor14f232e2010-05-08 23:05:03 +00001155void Sema::DiagnoseUnusedDecl(const NamedDecl *D) {
Anna Zaks964f4c62011-07-28 20:52:06 +00001156 FixItHint Hint;
Douglas Gregor14f232e2010-05-08 23:05:03 +00001157 if (!ShouldDiagnoseUnusedDecl(D))
1158 return;
1159
Anna Zaks964f4c62011-07-28 20:52:06 +00001160 GenerateFixForUnusedDecl(D, Context, Hint);
1161
Chris Lattnercab02a62011-02-17 20:34:02 +00001162 unsigned DiagID;
Douglas Gregor14f232e2010-05-08 23:05:03 +00001163 if (isa<VarDecl>(D) && cast<VarDecl>(D)->isExceptionVariable())
Chris Lattnercab02a62011-02-17 20:34:02 +00001164 DiagID = diag::warn_unused_exception_param;
1165 else if (isa<LabelDecl>(D))
1166 DiagID = diag::warn_unused_label;
Douglas Gregor14f232e2010-05-08 23:05:03 +00001167 else
Chris Lattnercab02a62011-02-17 20:34:02 +00001168 DiagID = diag::warn_unused_variable;
1169
Anna Zaks964f4c62011-07-28 20:52:06 +00001170 Diag(D->getLocation(), DiagID) << D->getDeclName() << Hint;
Douglas Gregor14f232e2010-05-08 23:05:03 +00001171}
1172
Chris Lattnerebb5c6c2011-02-18 01:27:55 +00001173static void CheckPoppedLabel(LabelDecl *L, Sema &S) {
1174 // Verify that we have no forward references left. If so, there was a goto
1175 // or address of a label taken, but no definition of it. Label fwd
1176 // definitions are indicated with a null substmt.
1177 if (L->getStmt() == 0)
1178 S.Diag(L->getLocation(), diag::err_undeclared_label_use) <<L->getDeclName();
1179}
1180
Steve Naroffc62adb62007-10-09 22:01:59 +00001181void Sema::ActOnPopScope(SourceLocation Loc, Scope *S) {
Chris Lattner1a76a3c2007-08-26 06:24:45 +00001182 if (S->decl_empty()) return;
Douglas Gregor5101c242008-12-05 18:15:24 +00001183 assert((S->getFlags() & (Scope::DeclScope | Scope::TemplateParamScope)) &&
Mike Stump11289f42009-09-09 15:08:12 +00001184 "Scope shouldn't contain decls!");
Argyrios Kyrtzidisfa8e15b2008-05-09 23:39:43 +00001185
Chris Lattner302b4be2006-11-19 02:31:38 +00001186 for (Scope::decl_iterator I = S->decl_begin(), E = S->decl_end();
1187 I != E; ++I) {
John McCall48871652010-08-21 09:40:31 +00001188 Decl *TmpD = (*I);
Steve Naroff9324db12007-09-13 18:10:37 +00001189 assert(TmpD && "This decl didn't get pushed??");
Argyrios Kyrtzidis406fb232008-06-10 01:32:09 +00001190
Douglas Gregor91f84212008-12-11 16:49:14 +00001191 assert(isa<NamedDecl>(TmpD) && "Decl isn't NamedDecl?");
1192 NamedDecl *D = cast<NamedDecl>(TmpD);
Argyrios Kyrtzidis406fb232008-06-10 01:32:09 +00001193
Douglas Gregor91f84212008-12-11 16:49:14 +00001194 if (!D->getDeclName()) continue;
Chris Lattnerc5c95b52008-04-11 07:00:53 +00001195
Douglas Gregor3beaf9b2009-10-08 21:35:42 +00001196 // Diagnose unused variables in this scope.
Argyrios Kyrtzidis18653422010-11-19 00:19:12 +00001197 if (!S->hasErrorOccurred())
Douglas Gregor14f232e2010-05-08 23:05:03 +00001198 DiagnoseUnusedDecl(D);
1199
Chris Lattnerebb5c6c2011-02-18 01:27:55 +00001200 // If this was a forward reference to a label, verify it was defined.
1201 if (LabelDecl *LD = dyn_cast<LabelDecl>(D))
1202 CheckPoppedLabel(LD, *this);
1203
Douglas Gregor91f84212008-12-11 16:49:14 +00001204 // Remove this name from our lexical scope.
1205 IdResolver.RemoveDecl(D);
Chris Lattner302b4be2006-11-19 02:31:38 +00001206 }
1207}
1208
Douglas Gregor1c283312010-08-11 12:19:30 +00001209/// \brief Look for an Objective-C class in the translation unit.
1210///
1211/// \param Id The name of the Objective-C class we're looking for. If
1212/// typo-correction fixes this name, the Id will be updated
1213/// to the fixed name.
1214///
1215/// \param IdLoc The location of the name in the translation unit.
1216///
1217/// \param TypoCorrection If true, this routine will attempt typo correction
1218/// if there is no class with the given name.
1219///
1220/// \returns The declaration of the named Objective-C class, or NULL if the
1221/// class could not be found.
1222ObjCInterfaceDecl *Sema::getObjCInterfaceDecl(IdentifierInfo *&Id,
1223 SourceLocation IdLoc,
Douglas Gregorc2fa1692011-06-28 16:20:02 +00001224 bool DoTypoCorrection) {
Douglas Gregor1c283312010-08-11 12:19:30 +00001225 // The third "scope" argument is 0 since we aren't enabling lazy built-in
1226 // creation from this context.
1227 NamedDecl *IDecl = LookupSingleName(TUScope, Id, IdLoc, LookupOrdinaryName);
1228
Douglas Gregorc2fa1692011-06-28 16:20:02 +00001229 if (!IDecl && DoTypoCorrection) {
Douglas Gregor1c283312010-08-11 12:19:30 +00001230 // Perform typo correction at the given location, but only if we
1231 // find an Objective-C class name.
Douglas Gregorc2fa1692011-06-28 16:20:02 +00001232 TypoCorrection C;
1233 if ((C = CorrectTypo(DeclarationNameInfo(Id, IdLoc), LookupOrdinaryName,
1234 TUScope, NULL, NULL, false, CTC_NoKeywords)) &&
1235 (IDecl = C.getCorrectionDeclAs<ObjCInterfaceDecl>())) {
Douglas Gregor1c283312010-08-11 12:19:30 +00001236 Diag(IdLoc, diag::err_undef_interface_suggest)
1237 << Id << IDecl->getDeclName()
1238 << FixItHint::CreateReplacement(IdLoc, IDecl->getNameAsString());
1239 Diag(IDecl->getLocation(), diag::note_previous_decl)
1240 << IDecl->getDeclName();
1241
1242 Id = IDecl->getIdentifier();
1243 }
1244 }
1245
1246 return dyn_cast_or_null<ObjCInterfaceDecl>(IDecl);
1247}
1248
Douglas Gregor45a33ec2009-01-12 18:45:55 +00001249/// getNonFieldDeclScope - Retrieves the innermost scope, starting
1250/// from S, where a non-field would be declared. This routine copes
1251/// with the difference between C and C++ scoping rules in structs and
1252/// unions. For example, the following code is well-formed in C but
1253/// ill-formed in C++:
1254/// @code
1255/// struct S6 {
1256/// enum { BAR } e;
1257/// };
Mike Stump11289f42009-09-09 15:08:12 +00001258///
Douglas Gregor45a33ec2009-01-12 18:45:55 +00001259/// void test_S6() {
1260/// struct S6 a;
1261/// a.e = BAR;
1262/// }
1263/// @endcode
1264/// For the declaration of BAR, this routine will return a different
1265/// scope. The scope S will be the scope of the unnamed enumeration
1266/// within S6. In C++, this routine will return the scope associated
1267/// with S6, because the enumeration's scope is a transparent
1268/// context but structures can contain non-field names. In C, this
1269/// routine will return the translation unit scope, since the
1270/// enumeration's scope is a transparent context and structures cannot
1271/// contain non-field names.
1272Scope *Sema::getNonFieldDeclScope(Scope *S) {
1273 while (((S->getFlags() & Scope::DeclScope) == 0) ||
Mike Stump11289f42009-09-09 15:08:12 +00001274 (S->getEntity() &&
Douglas Gregor45a33ec2009-01-12 18:45:55 +00001275 ((DeclContext *)S->getEntity())->isTransparentContext()) ||
1276 (S->isClassScope() && !getLangOptions().CPlusPlus))
1277 S = S->getParent();
1278 return S;
1279}
1280
Douglas Gregorb9063fc2009-02-13 23:20:09 +00001281/// LazilyCreateBuiltin - The specified Builtin-ID was first used at
1282/// file scope. lazily create a decl for it. ForRedeclaration is true
1283/// if we're creating this built-in in anticipation of redeclaring the
1284/// built-in.
Douglas Gregor6e6ad602009-01-20 01:17:11 +00001285NamedDecl *Sema::LazilyCreateBuiltin(IdentifierInfo *II, unsigned bid,
Douglas Gregorb9063fc2009-02-13 23:20:09 +00001286 Scope *S, bool ForRedeclaration,
1287 SourceLocation Loc) {
Chris Lattner9561a0b2007-01-28 08:20:04 +00001288 Builtin::ID BID = (Builtin::ID)bid;
1289
Chris Lattnerecd79c62009-06-14 00:45:47 +00001290 ASTContext::GetBuiltinTypeError Error;
Mike Stump11289f42009-09-09 15:08:12 +00001291 QualType R = Context.GetBuiltinType(BID, Error);
Douglas Gregor538c3d82009-02-14 01:52:53 +00001292 switch (Error) {
Chris Lattnerecd79c62009-06-14 00:45:47 +00001293 case ASTContext::GE_None:
Douglas Gregor538c3d82009-02-14 01:52:53 +00001294 // Okay
1295 break;
1296
Mike Stump93246cc2009-07-28 23:57:15 +00001297 case ASTContext::GE_Missing_stdio:
Douglas Gregor538c3d82009-02-14 01:52:53 +00001298 if (ForRedeclaration)
Douglas Gregorbfe022c2011-01-03 09:37:44 +00001299 Diag(Loc, diag::warn_implicit_decl_requires_stdio)
Douglas Gregor538c3d82009-02-14 01:52:53 +00001300 << Context.BuiltinInfo.GetName(BID);
1301 return 0;
Mike Stumpa4de80b2009-07-28 02:25:19 +00001302
Mike Stump93246cc2009-07-28 23:57:15 +00001303 case ASTContext::GE_Missing_setjmp:
Mike Stumpa4de80b2009-07-28 02:25:19 +00001304 if (ForRedeclaration)
Douglas Gregorbfe022c2011-01-03 09:37:44 +00001305 Diag(Loc, diag::warn_implicit_decl_requires_setjmp)
Mike Stumpa4de80b2009-07-28 02:25:19 +00001306 << Context.BuiltinInfo.GetName(BID);
1307 return 0;
Douglas Gregor538c3d82009-02-14 01:52:53 +00001308 }
Douglas Gregorb9063fc2009-02-13 23:20:09 +00001309
1310 if (!ForRedeclaration && Context.BuiltinInfo.isPredefinedLibFunction(BID)) {
1311 Diag(Loc, diag::ext_implicit_lib_function_decl)
1312 << Context.BuiltinInfo.GetName(BID)
1313 << R;
Douglas Gregor9eebd972009-02-16 21:58:21 +00001314 if (Context.BuiltinInfo.getHeaderName(BID) &&
Argyrios Kyrtzidis1cb0de12010-12-15 18:44:22 +00001315 Diags.getDiagnosticLevel(diag::ext_implicit_lib_function_decl, Loc)
David Blaikie9c902b52011-09-25 23:23:43 +00001316 != DiagnosticsEngine::Ignored)
Douglas Gregorb9063fc2009-02-13 23:20:09 +00001317 Diag(Loc, diag::note_please_include_header)
1318 << Context.BuiltinInfo.getHeaderName(BID)
1319 << Context.BuiltinInfo.GetName(BID);
1320 }
1321
Argyrios Kyrtzidis6d053032008-04-17 14:47:13 +00001322 FunctionDecl *New = FunctionDecl::Create(Context,
1323 Context.getTranslationUnitDecl(),
Abramo Bagnaradff19302011-03-08 08:55:46 +00001324 Loc, Loc, II, R, /*TInfo=*/0,
John McCall8e7d6562010-08-26 03:08:43 +00001325 SC_Extern,
1326 SC_None, false,
Douglas Gregor739ef0c2009-02-25 16:33:18 +00001327 /*hasPrototype=*/true);
Douglas Gregorb9063fc2009-02-13 23:20:09 +00001328 New->setImplicit();
1329
Chris Lattner4dd27102008-05-05 22:18:14 +00001330 // Create Decl objects for each parameter, adding them to the
1331 // FunctionDecl.
John McCall424cec92011-01-19 06:33:43 +00001332 if (const FunctionProtoType *FT = dyn_cast<FunctionProtoType>(R)) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001333 SmallVector<ParmVarDecl*, 16> Params;
John McCall8fb0d9d2011-05-01 22:35:37 +00001334 for (unsigned i = 0, e = FT->getNumArgs(); i != e; ++i) {
1335 ParmVarDecl *parm =
1336 ParmVarDecl::Create(Context, New, SourceLocation(),
1337 SourceLocation(), 0,
1338 FT->getArgType(i), /*TInfo=*/0,
1339 SC_None, SC_None, 0);
1340 parm->setScopeInfo(0, i);
1341 Params.push_back(parm);
1342 }
David Blaikie9c70e042011-09-21 18:16:56 +00001343 New->setParams(Params);
Chris Lattner4dd27102008-05-05 22:18:14 +00001344 }
Mike Stump11289f42009-09-09 15:08:12 +00001345
1346 AddKnownFunctionAttributes(New);
1347
Chris Lattnerc5c95b52008-04-11 07:00:53 +00001348 // TUScope is the translation-unit scope to insert this function into.
Douglas Gregorc72e6452009-01-09 18:51:29 +00001349 // FIXME: This is hideous. We need to teach PushOnScopeChains to
1350 // relate Scopes to DeclContexts, and probably eliminate CurContext
1351 // entirely, but we're not there yet.
1352 DeclContext *SavedContext = CurContext;
1353 CurContext = Context.getTranslationUnitDecl();
Argyrios Kyrtzidisfa8e15b2008-05-09 23:39:43 +00001354 PushOnScopeChains(New, TUScope);
Douglas Gregorc72e6452009-01-09 18:51:29 +00001355 CurContext = SavedContext;
Chris Lattner9561a0b2007-01-28 08:20:04 +00001356 return New;
1357}
1358
Richard Smithdda56e42011-04-15 14:24:37 +00001359/// MergeTypedefNameDecl - We just parsed a typedef 'New' which has the
Douglas Gregor75a45ba2009-02-16 17:45:42 +00001360/// same name and scope as a previous declaration 'Old'. Figure out
1361/// how to resolve this situation, merging decls or emitting
Chris Lattnerf6d1c9c2009-04-25 08:06:05 +00001362/// diagnostics as appropriate. If there was an error, set New to be invalid.
Chris Lattner01564d92007-01-27 19:27:06 +00001363///
Richard Smithdda56e42011-04-15 14:24:37 +00001364void Sema::MergeTypedefNameDecl(TypedefNameDecl *New, LookupResult &OldDecls) {
John McCall1f82f242009-11-18 22:49:29 +00001365 // If the new decl is known invalid already, don't bother doing any
1366 // merging checks.
1367 if (New->isInvalidDecl()) return;
Mike Stump11289f42009-09-09 15:08:12 +00001368
Steve Naroff44cfcb62008-09-09 14:32:20 +00001369 // Allow multiple definitions for ObjC built-in typedefs.
1370 // FIXME: Verify the underlying types are equivalent!
1371 if (getLangOptions().ObjC1) {
Chris Lattner66e32812008-11-20 05:41:43 +00001372 const IdentifierInfo *TypeID = New->getIdentifier();
1373 switch (TypeID->getLength()) {
1374 default: break;
Mike Stump11289f42009-09-09 15:08:12 +00001375 case 2:
Chris Lattner66e32812008-11-20 05:41:43 +00001376 if (!TypeID->isStr("id"))
1377 break;
Douglas Gregor97673472011-08-11 20:58:55 +00001378 Context.setObjCIdRedefinitionType(New->getUnderlyingType());
Steve Naroff7cae42b2009-07-10 23:34:53 +00001379 // Install the built-in type for 'id', ignoring the current definition.
1380 New->setTypeForDecl(Context.getObjCIdType().getTypePtr());
1381 return;
Chris Lattner66e32812008-11-20 05:41:43 +00001382 case 5:
1383 if (!TypeID->isStr("Class"))
1384 break;
Douglas Gregor97673472011-08-11 20:58:55 +00001385 Context.setObjCClassRedefinitionType(New->getUnderlyingType());
Steve Naroff7cae42b2009-07-10 23:34:53 +00001386 // Install the built-in type for 'Class', ignoring the current definition.
1387 New->setTypeForDecl(Context.getObjCClassType().getTypePtr());
Chris Lattnerf6d1c9c2009-04-25 08:06:05 +00001388 return;
Chris Lattner66e32812008-11-20 05:41:43 +00001389 case 3:
1390 if (!TypeID->isStr("SEL"))
1391 break;
Douglas Gregor97673472011-08-11 20:58:55 +00001392 Context.setObjCSelRedefinitionType(New->getUnderlyingType());
Fariborz Jahanian252ba5f2009-11-21 19:53:08 +00001393 // Install the built-in type for 'SEL', ignoring the current definition.
1394 New->setTypeForDecl(Context.getObjCSelType().getTypePtr());
Chris Lattnerf6d1c9c2009-04-25 08:06:05 +00001395 return;
Steve Naroff44cfcb62008-09-09 14:32:20 +00001396 }
1397 // Fall through - the typedef name was not a builtin type.
1398 }
John McCall1f82f242009-11-18 22:49:29 +00001399
Douglas Gregorfb034662009-01-28 17:15:10 +00001400 // Verify the old decl was also a type.
John McCall91f1a022009-12-30 00:31:22 +00001401 TypeDecl *Old = OldDecls.getAsSingle<TypeDecl>();
1402 if (!Old) {
Mike Stump11289f42009-09-09 15:08:12 +00001403 Diag(New->getLocation(), diag::err_redefinition_different_kind)
Chris Lattnere3d20d92008-11-23 21:45:46 +00001404 << New->getDeclName();
John McCall1f82f242009-11-18 22:49:29 +00001405
1406 NamedDecl *OldD = OldDecls.getRepresentativeDecl();
Chris Lattnerf6d1c9c2009-04-25 08:06:05 +00001407 if (OldD->getLocation().isValid())
Fariborz Jahanian1778f4b2009-01-16 19:58:32 +00001408 Diag(OldD->getLocation(), diag::note_previous_definition);
John McCall1f82f242009-11-18 22:49:29 +00001409
Chris Lattnerf6d1c9c2009-04-25 08:06:05 +00001410 return New->setInvalidDecl();
Chris Lattnerc511efb2007-01-27 19:32:14 +00001411 }
Douglas Gregorfb034662009-01-28 17:15:10 +00001412
John McCall1f82f242009-11-18 22:49:29 +00001413 // If the old declaration is invalid, just give up here.
1414 if (Old->isInvalidDecl())
1415 return New->setInvalidDecl();
1416
Mike Stump11289f42009-09-09 15:08:12 +00001417 // Determine the "old" type we'll use for checking and diagnostics.
Douglas Gregorfb034662009-01-28 17:15:10 +00001418 QualType OldType;
Richard Smithdda56e42011-04-15 14:24:37 +00001419 if (TypedefNameDecl *OldTypedef = dyn_cast<TypedefNameDecl>(Old))
Douglas Gregorfb034662009-01-28 17:15:10 +00001420 OldType = OldTypedef->getUnderlyingType();
1421 else
1422 OldType = Context.getTypeDeclType(Old);
1423
Chris Lattnerf9c49e52008-07-25 18:44:27 +00001424 // If the typedef types are not identical, reject them in all languages and
1425 // with any extensions enabled.
Douglas Gregorfb034662009-01-28 17:15:10 +00001426
Mike Stump11289f42009-09-09 15:08:12 +00001427 if (OldType != New->getUnderlyingType() &&
1428 Context.getCanonicalType(OldType) !=
Chris Lattnerf9c49e52008-07-25 18:44:27 +00001429 Context.getCanonicalType(New->getUnderlyingType())) {
Richard Smithdda56e42011-04-15 14:24:37 +00001430 int Kind = 0;
1431 if (isa<TypeAliasDecl>(Old))
1432 Kind = 1;
Chris Lattnerf7e3f6d2008-11-20 06:13:02 +00001433 Diag(New->getLocation(), diag::err_redefinition_different_typedef)
Richard Smithdda56e42011-04-15 14:24:37 +00001434 << Kind << New->getUnderlyingType() << OldType;
Chris Lattnerf6d1c9c2009-04-25 08:06:05 +00001435 if (Old->getLocation().isValid())
Fariborz Jahanian1778f4b2009-01-16 19:58:32 +00001436 Diag(Old->getLocation(), diag::note_previous_definition);
Chris Lattnerf6d1c9c2009-04-25 08:06:05 +00001437 return New->setInvalidDecl();
Chris Lattnerf9c49e52008-07-25 18:44:27 +00001438 }
Mike Stump11289f42009-09-09 15:08:12 +00001439
John McCall91f1a022009-12-30 00:31:22 +00001440 // The types match. Link up the redeclaration chain if the old
1441 // declaration was a typedef.
Nick Lewycky0bdf13e2011-07-02 02:05:12 +00001442 // FIXME: this is a potential source of weirdness if the type
John McCall91f1a022009-12-30 00:31:22 +00001443 // spellings don't match exactly.
Richard Smithdda56e42011-04-15 14:24:37 +00001444 if (TypedefNameDecl *Typedef = dyn_cast<TypedefNameDecl>(Old))
1445 New->setPreviousDeclaration(Typedef);
John McCall91f1a022009-12-30 00:31:22 +00001446
Douglas Gregoref15bdb2011-09-09 18:32:39 +00001447 // __module_private__ is propagated to later declarations.
1448 if (Old->isModulePrivate())
1449 New->setModulePrivate();
Douglas Gregor2820e692011-09-09 19:05:14 +00001450 else if (New->isModulePrivate())
1451 diagnoseModulePrivateRedeclaration(New, Old);
1452
Francois Pichet0706d202011-09-17 17:15:52 +00001453 if (getLangOptions().MicrosoftExt)
Chris Lattnerf6d1c9c2009-04-25 08:06:05 +00001454 return;
Eli Friedman61b529f2008-06-11 06:20:39 +00001455
Chris Lattner2581fc32009-04-17 22:04:20 +00001456 if (getLangOptions().CPlusPlus) {
Douglas Gregor9dd13ab2010-01-11 21:54:40 +00001457 // C++ [dcl.typedef]p2:
1458 // In a given non-class scope, a typedef specifier can be used to
1459 // redefine the name of any type declared in that scope to refer
1460 // to the type to which it already refers.
Chris Lattner2581fc32009-04-17 22:04:20 +00001461 if (!isa<CXXRecordDecl>(CurContext))
Chris Lattnerf6d1c9c2009-04-25 08:06:05 +00001462 return;
Douglas Gregor9dd13ab2010-01-11 21:54:40 +00001463
1464 // C++0x [dcl.typedef]p4:
1465 // In a given class scope, a typedef specifier can be used to redefine
1466 // any class-name declared in that scope that is not also a typedef-name
1467 // to refer to the type to which it already refers.
1468 //
1469 // This wording came in via DR424, which was a correction to the
1470 // wording in DR56, which accidentally banned code like:
1471 //
1472 // struct S {
1473 // typedef struct A { } A;
1474 // };
1475 //
1476 // in the C++03 standard. We implement the C++0x semantics, which
1477 // allow the above but disallow
1478 //
1479 // struct S {
1480 // typedef int I;
1481 // typedef int I;
1482 // };
1483 //
1484 // since that was the intent of DR56.
Richard Smithdda56e42011-04-15 14:24:37 +00001485 if (!isa<TypedefNameDecl>(Old))
Douglas Gregor9dd13ab2010-01-11 21:54:40 +00001486 return;
1487
Chris Lattner2581fc32009-04-17 22:04:20 +00001488 Diag(New->getLocation(), diag::err_redefinition)
1489 << New->getDeclName();
1490 Diag(Old->getLocation(), diag::note_previous_definition);
Chris Lattnerf6d1c9c2009-04-25 08:06:05 +00001491 return New->setInvalidDecl();
Daniel Dunbar84b70f72008-09-12 18:10:20 +00001492 }
Eli Friedman61b529f2008-06-11 06:20:39 +00001493
Chris Lattner2581fc32009-04-17 22:04:20 +00001494 // If we have a redefinition of a typedef in C, emit a warning. This warning
1495 // is normally mapped to an error, but can be controlled with
Eli Friedman319ce952009-06-04 23:03:07 +00001496 // -Wtypedef-redefinition. If either the original or the redefinition is
1497 // in a system header, don't emit this for compatibility with GCC.
Chris Lattner30d0cfd2010-03-01 20:59:53 +00001498 if (getDiagnostics().getSuppressSystemWarnings() &&
Eli Friedman319ce952009-06-04 23:03:07 +00001499 (Context.getSourceManager().isInSystemHeader(Old->getLocation()) ||
1500 Context.getSourceManager().isInSystemHeader(New->getLocation())))
Chris Lattner9a845892009-04-27 01:46:12 +00001501 return;
Mike Stump11289f42009-09-09 15:08:12 +00001502
Chris Lattner2581fc32009-04-17 22:04:20 +00001503 Diag(New->getLocation(), diag::warn_redefinition_of_typedef)
1504 << New->getDeclName();
Chris Lattner0369c572008-11-23 23:12:31 +00001505 Diag(Old->getLocation(), diag::note_previous_definition);
Chris Lattnerf6d1c9c2009-04-25 08:06:05 +00001506 return;
Chris Lattner01564d92007-01-27 19:27:06 +00001507}
1508
Chris Lattner2c6fcf52008-06-26 18:38:35 +00001509/// DeclhasAttr - returns true if decl Declaration already has the target
1510/// attribute.
Mike Stump11289f42009-09-09 15:08:12 +00001511static bool
Alexis Huntdcfba7b2010-08-18 23:23:40 +00001512DeclHasAttr(const Decl *D, const Attr *A) {
1513 const OwnershipAttr *OA = dyn_cast<OwnershipAttr>(A);
Julien Lerouge5a6b6982011-09-09 22:41:49 +00001514 const AnnotateAttr *Ann = dyn_cast<AnnotateAttr>(A);
Alexis Huntdcfba7b2010-08-18 23:23:40 +00001515 for (Decl::attr_iterator i = D->attr_begin(), e = D->attr_end(); i != e; ++i)
1516 if ((*i)->getKind() == A->getKind()) {
Julien Lerouge5a6b6982011-09-09 22:41:49 +00001517 if (Ann) {
1518 if (Ann->getAnnotation() == cast<AnnotateAttr>(*i)->getAnnotation())
1519 return true;
1520 continue;
1521 }
Alexis Huntdcfba7b2010-08-18 23:23:40 +00001522 // FIXME: Don't hardcode this check
1523 if (OA && isa<OwnershipAttr>(*i))
1524 return OA->getOwnKind() == cast<OwnershipAttr>(*i)->getOwnKind();
Chris Lattner84966392008-03-03 03:28:21 +00001525 return true;
Alexis Huntdcfba7b2010-08-18 23:23:40 +00001526 }
Chris Lattner84966392008-03-03 03:28:21 +00001527
1528 return false;
1529}
1530
John McCallf79e87d2011-03-02 04:00:57 +00001531/// mergeDeclAttributes - Copy attributes from the Old decl to the New one.
1532static void mergeDeclAttributes(Decl *newDecl, const Decl *oldDecl,
John McCalld2930c22011-07-22 02:45:48 +00001533 ASTContext &C, bool mergeDeprecation = true) {
John McCallf79e87d2011-03-02 04:00:57 +00001534 if (!oldDecl->hasAttrs())
Alexis Huntdcfba7b2010-08-18 23:23:40 +00001535 return;
John McCallf79e87d2011-03-02 04:00:57 +00001536
1537 bool foundAny = newDecl->hasAttrs();
1538
Alexis Huntdcfba7b2010-08-18 23:23:40 +00001539 // Ensure that any moving of objects within the allocated map is done before
1540 // we process them.
John McCallf79e87d2011-03-02 04:00:57 +00001541 if (!foundAny) newDecl->setAttrs(AttrVec());
1542
Peter Collingbourneab8bc062011-01-21 02:08:36 +00001543 for (specific_attr_iterator<InheritableAttr>
John McCallf79e87d2011-03-02 04:00:57 +00001544 i = oldDecl->specific_attr_begin<InheritableAttr>(),
1545 e = oldDecl->specific_attr_end<InheritableAttr>(); i != e; ++i) {
Douglas Gregorb1fa1482011-09-23 20:23:42 +00001546 // Ignore deprecated/unavailable/availability attributes if requested.
John McCalld2930c22011-07-22 02:45:48 +00001547 if (!mergeDeprecation &&
Douglas Gregorb1fa1482011-09-23 20:23:42 +00001548 (isa<DeprecatedAttr>(*i) ||
1549 isa<UnavailableAttr>(*i) ||
1550 isa<AvailabilityAttr>(*i)))
John McCalld2930c22011-07-22 02:45:48 +00001551 continue;
1552
John McCallf79e87d2011-03-02 04:00:57 +00001553 if (!DeclHasAttr(newDecl, *i)) {
1554 InheritableAttr *newAttr = cast<InheritableAttr>((*i)->clone(C));
1555 newAttr->setInherited(true);
1556 newDecl->addAttr(newAttr);
1557 foundAny = true;
Chris Lattner84966392008-03-03 03:28:21 +00001558 }
1559 }
John McCallf79e87d2011-03-02 04:00:57 +00001560
1561 if (!foundAny) newDecl->dropAttrs();
1562}
1563
1564/// mergeParamDeclAttributes - Copy attributes from the old parameter
1565/// to the new one.
1566static void mergeParamDeclAttributes(ParmVarDecl *newDecl,
1567 const ParmVarDecl *oldDecl,
1568 ASTContext &C) {
1569 if (!oldDecl->hasAttrs())
1570 return;
1571
1572 bool foundAny = newDecl->hasAttrs();
1573
1574 // Ensure that any moving of objects within the allocated map is
1575 // done before we process them.
1576 if (!foundAny) newDecl->setAttrs(AttrVec());
1577
1578 for (specific_attr_iterator<InheritableParamAttr>
1579 i = oldDecl->specific_attr_begin<InheritableParamAttr>(),
1580 e = oldDecl->specific_attr_end<InheritableParamAttr>(); i != e; ++i) {
1581 if (!DeclHasAttr(newDecl, *i)) {
1582 InheritableAttr *newAttr = cast<InheritableParamAttr>((*i)->clone(C));
1583 newAttr->setInherited(true);
1584 newDecl->addAttr(newAttr);
1585 foundAny = true;
1586 }
1587 }
1588
1589 if (!foundAny) newDecl->dropAttrs();
Chris Lattner84966392008-03-03 03:28:21 +00001590}
1591
Dan Gohman28ade552010-07-26 21:25:24 +00001592namespace {
1593
Douglas Gregora74a2972009-03-06 22:43:54 +00001594/// Used in MergeFunctionDecl to keep track of function parameters in
1595/// C.
1596struct GNUCompatibleParamWarning {
1597 ParmVarDecl *OldParm;
1598 ParmVarDecl *NewParm;
1599 QualType PromotedType;
1600};
1601
Dan Gohman28ade552010-07-26 21:25:24 +00001602}
Anders Carlsson1f78b2b2009-12-04 22:33:25 +00001603
1604/// getSpecialMember - get the special member enum for a method.
Anders Carlsson05bf0092010-04-22 05:40:53 +00001605Sema::CXXSpecialMember Sema::getSpecialMember(const CXXMethodDecl *MD) {
Anders Carlsson1f78b2b2009-12-04 22:33:25 +00001606 if (const CXXConstructorDecl *Ctor = dyn_cast<CXXConstructorDecl>(MD)) {
Alexis Hunt80f00ff2011-05-10 19:08:14 +00001607 if (Ctor->isDefaultConstructor())
1608 return Sema::CXXDefaultConstructor;
Alexis Huntd051b872011-05-26 01:26:05 +00001609
1610 if (Ctor->isCopyConstructor())
1611 return Sema::CXXCopyConstructor;
1612
1613 if (Ctor->isMoveConstructor())
1614 return Sema::CXXMoveConstructor;
Alexis Hunt119c10e2011-05-25 23:16:36 +00001615 } else if (isa<CXXDestructorDecl>(MD)) {
Anders Carlsson1f78b2b2009-12-04 22:33:25 +00001616 return Sema::CXXDestructor;
Alexis Hunt119c10e2011-05-25 23:16:36 +00001617 } else if (MD->isCopyAssignmentOperator()) {
Alexis Hunt80f00ff2011-05-10 19:08:14 +00001618 return Sema::CXXCopyAssignment;
Sebastian Redle9c4e842011-09-04 18:14:28 +00001619 } else if (MD->isMoveAssignmentOperator()) {
1620 return Sema::CXXMoveAssignment;
Alexis Hunt119c10e2011-05-25 23:16:36 +00001621 }
Alexis Hunt80f00ff2011-05-10 19:08:14 +00001622
Alexis Hunt80f00ff2011-05-10 19:08:14 +00001623 return Sema::CXXInvalid;
Anders Carlsson1f78b2b2009-12-04 22:33:25 +00001624}
1625
Sebastian Redl243d9052010-06-09 21:17:41 +00001626/// canRedefineFunction - checks if a function can be redefined. Currently,
Charles Davisfea48452010-02-18 02:00:42 +00001627/// only extern inline functions can be redefined, and even then only in
1628/// GNU89 mode.
1629static bool canRedefineFunction(const FunctionDecl *FD,
1630 const LangOptions& LangOpts) {
Eli Friedman51dd0182011-06-13 23:56:42 +00001631 return ((FD->hasAttr<GNUInlineAttr>() || LangOpts.GNUInline) &&
1632 !LangOpts.CPlusPlus &&
Charles Davisfea48452010-02-18 02:00:42 +00001633 FD->isInlineSpecified() &&
John McCall8e7d6562010-08-26 03:08:43 +00001634 FD->getStorageClass() == SC_Extern);
Charles Davisfea48452010-02-18 02:00:42 +00001635}
1636
Chris Lattneraa9c7ae2008-04-08 04:40:51 +00001637/// MergeFunctionDecl - We just parsed a function 'New' from
1638/// declarator D which has the same name and scope as a previous
1639/// declaration 'Old'. Figure out how to resolve this situation,
1640/// merging decls or emitting diagnostics as appropriate.
Douglas Gregor5251f1b2008-10-21 16:13:35 +00001641///
1642/// In C++, New and Old must be declarations that are not
1643/// overloaded. Use IsOverload to determine whether New and Old are
1644/// overloaded, and to select the Old declaration that New should be
1645/// merged with.
Douglas Gregor75a45ba2009-02-16 17:45:42 +00001646///
1647/// Returns true if there was an error, false otherwise.
1648bool Sema::MergeFunctionDecl(FunctionDecl *New, Decl *OldD) {
Chris Lattnerc511efb2007-01-27 19:32:14 +00001649 // Verify the old decl was also a function.
Douglas Gregorad3f2fc2009-06-25 22:08:12 +00001650 FunctionDecl *Old = 0;
Mike Stump11289f42009-09-09 15:08:12 +00001651 if (FunctionTemplateDecl *OldFunctionTemplate
Douglas Gregorad3f2fc2009-06-25 22:08:12 +00001652 = dyn_cast<FunctionTemplateDecl>(OldD))
1653 Old = OldFunctionTemplate->getTemplatedDecl();
Mike Stump11289f42009-09-09 15:08:12 +00001654 else
Douglas Gregorad3f2fc2009-06-25 22:08:12 +00001655 Old = dyn_cast<FunctionDecl>(OldD);
Chris Lattnerc511efb2007-01-27 19:32:14 +00001656 if (!Old) {
John McCalle29c5cd2009-12-10 19:51:03 +00001657 if (UsingShadowDecl *Shadow = dyn_cast<UsingShadowDecl>(OldD)) {
1658 Diag(New->getLocation(), diag::err_using_decl_conflict_reverse);
1659 Diag(Shadow->getTargetDecl()->getLocation(),
1660 diag::note_using_decl_target);
1661 Diag(Shadow->getUsingDecl()->getLocation(),
1662 diag::note_using_decl) << 0;
1663 return true;
1664 }
1665
Chris Lattnerf7e3f6d2008-11-20 06:13:02 +00001666 Diag(New->getLocation(), diag::err_redefinition_different_kind)
Chris Lattnere3d20d92008-11-23 21:45:46 +00001667 << New->getDeclName();
Chris Lattner0369c572008-11-23 23:12:31 +00001668 Diag(OldD->getLocation(), diag::note_previous_definition);
Douglas Gregor75a45ba2009-02-16 17:45:42 +00001669 return true;
Chris Lattnerc511efb2007-01-27 19:32:14 +00001670 }
Douglas Gregor5251f1b2008-10-21 16:13:35 +00001671
1672 // Determine whether the previous declaration was a definition,
1673 // implicit declaration, or a declaration.
1674 diag::kind PrevDiag;
1675 if (Old->isThisDeclarationADefinition())
Chris Lattner0369c572008-11-23 23:12:31 +00001676 PrevDiag = diag::note_previous_definition;
Douglas Gregor75a45ba2009-02-16 17:45:42 +00001677 else if (Old->isImplicit())
1678 PrevDiag = diag::note_previous_implicit_declaration;
Mike Stump11289f42009-09-09 15:08:12 +00001679 else
Chris Lattner0369c572008-11-23 23:12:31 +00001680 PrevDiag = diag::note_previous_declaration;
Mike Stump11289f42009-09-09 15:08:12 +00001681
Chris Lattnerfc4379f2008-04-06 23:10:54 +00001682 QualType OldQType = Context.getCanonicalType(Old->getType());
1683 QualType NewQType = Context.getCanonicalType(New->getType());
Mike Stump11289f42009-09-09 15:08:12 +00001684
Charles Davisfea48452010-02-18 02:00:42 +00001685 // Don't complain about this if we're in GNU89 mode and the old function
1686 // is an extern inline function.
Douglas Gregore62c0a42009-02-24 01:23:02 +00001687 if (!isa<CXXMethodDecl>(New) && !isa<CXXMethodDecl>(Old) &&
John McCall8e7d6562010-08-26 03:08:43 +00001688 New->getStorageClass() == SC_Static &&
1689 Old->getStorageClass() != SC_Static &&
Charles Davisfea48452010-02-18 02:00:42 +00001690 !canRedefineFunction(Old, getLangOptions())) {
Francois Pichet0706d202011-09-17 17:15:52 +00001691 if (getLangOptions().MicrosoftExt) {
Francois Pichet6841a122011-04-22 19:50:06 +00001692 Diag(New->getLocation(), diag::warn_static_non_static) << New;
1693 Diag(Old->getLocation(), PrevDiag);
1694 } else {
1695 Diag(New->getLocation(), diag::err_static_non_static) << New;
1696 Diag(Old->getLocation(), PrevDiag);
1697 return true;
1698 }
Douglas Gregore62c0a42009-02-24 01:23:02 +00001699 }
1700
John McCallcddbad02010-02-04 05:44:44 +00001701 // If a function is first declared with a calling convention, but is
1702 // later declared or defined without one, the second decl assumes the
1703 // calling convention of the first.
1704 //
1705 // For the new decl, we have to look at the NON-canonical type to tell the
1706 // difference between a function that really doesn't have a calling
1707 // convention and one that is declared cdecl. That's because in
1708 // canonicalization (see ASTContext.cpp), cdecl is canonicalized away
1709 // because it is the default calling convention.
1710 //
1711 // Note also that we DO NOT return at this point, because we still have
1712 // other tests to run.
John McCall4f5019e2010-12-19 02:44:49 +00001713 const FunctionType *OldType = cast<FunctionType>(OldQType);
John McCallcddbad02010-02-04 05:44:44 +00001714 const FunctionType *NewType = New->getType()->getAs<FunctionType>();
John McCall4f5019e2010-12-19 02:44:49 +00001715 FunctionType::ExtInfo OldTypeInfo = OldType->getExtInfo();
1716 FunctionType::ExtInfo NewTypeInfo = NewType->getExtInfo();
1717 bool RequiresAdjustment = false;
Rafael Espindolac50c27c2010-03-30 20:24:48 +00001718 if (OldTypeInfo.getCC() != CC_Default &&
1719 NewTypeInfo.getCC() == CC_Default) {
John McCall4f5019e2010-12-19 02:44:49 +00001720 NewTypeInfo = NewTypeInfo.withCallingConv(OldTypeInfo.getCC());
1721 RequiresAdjustment = true;
Rafael Espindolac50c27c2010-03-30 20:24:48 +00001722 } else if (!Context.isSameCallConv(OldTypeInfo.getCC(),
1723 NewTypeInfo.getCC())) {
John McCallcddbad02010-02-04 05:44:44 +00001724 // Calling conventions really aren't compatible, so complain.
John McCallab26cfa2010-02-05 21:31:56 +00001725 Diag(New->getLocation(), diag::err_cconv_change)
Rafael Espindolac50c27c2010-03-30 20:24:48 +00001726 << FunctionType::getNameForCallConv(NewTypeInfo.getCC())
1727 << (OldTypeInfo.getCC() == CC_Default)
1728 << (OldTypeInfo.getCC() == CC_Default ? "" :
1729 FunctionType::getNameForCallConv(OldTypeInfo.getCC()));
John McCallab26cfa2010-02-05 21:31:56 +00001730 Diag(Old->getLocation(), diag::note_previous_declaration);
John McCallcddbad02010-02-04 05:44:44 +00001731 return true;
1732 }
1733
John McCallab26cfa2010-02-05 21:31:56 +00001734 // FIXME: diagnose the other way around?
John McCall4f5019e2010-12-19 02:44:49 +00001735 if (OldTypeInfo.getNoReturn() && !NewTypeInfo.getNoReturn()) {
1736 NewTypeInfo = NewTypeInfo.withNoReturn(true);
1737 RequiresAdjustment = true;
John McCallab26cfa2010-02-05 21:31:56 +00001738 }
1739
Douglas Gregor77e274f2010-06-18 21:30:25 +00001740 // Merge regparm attribute.
Eli Friedmanc5b20b52011-04-09 08:18:08 +00001741 if (OldTypeInfo.getHasRegParm() != NewTypeInfo.getHasRegParm() ||
1742 OldTypeInfo.getRegParm() != NewTypeInfo.getRegParm()) {
1743 if (NewTypeInfo.getHasRegParm()) {
Douglas Gregor77e274f2010-06-18 21:30:25 +00001744 Diag(New->getLocation(), diag::err_regparm_mismatch)
1745 << NewType->getRegParmType()
1746 << OldType->getRegParmType();
1747 Diag(Old->getLocation(), diag::note_previous_declaration);
1748 return true;
1749 }
John McCall4f5019e2010-12-19 02:44:49 +00001750
1751 NewTypeInfo = NewTypeInfo.withRegParm(OldTypeInfo.getRegParm());
1752 RequiresAdjustment = true;
1753 }
1754
Douglas Gregorf1404d72011-10-14 15:55:40 +00001755 // Merge ns_returns_retained attribute.
1756 if (OldTypeInfo.getProducesResult() != NewTypeInfo.getProducesResult()) {
1757 if (NewTypeInfo.getProducesResult()) {
1758 Diag(New->getLocation(), diag::err_returns_retained_mismatch);
1759 Diag(Old->getLocation(), diag::note_previous_declaration);
1760 return true;
1761 }
1762
1763 NewTypeInfo = NewTypeInfo.withProducesResult(true);
1764 RequiresAdjustment = true;
1765 }
1766
John McCall4f5019e2010-12-19 02:44:49 +00001767 if (RequiresAdjustment) {
1768 NewType = Context.adjustFunctionType(NewType, NewTypeInfo);
1769 New->setType(QualType(NewType, 0));
1770 NewQType = Context.getCanonicalType(New->getType());
Douglas Gregor77e274f2010-06-18 21:30:25 +00001771 }
1772
Douglas Gregor5251f1b2008-10-21 16:13:35 +00001773 if (getLangOptions().CPlusPlus) {
1774 // (C++98 13.1p2):
1775 // Certain function declarations cannot be overloaded:
Mike Stump11289f42009-09-09 15:08:12 +00001776 // -- Function declarations that differ only in the return type
Douglas Gregor5251f1b2008-10-21 16:13:35 +00001777 // cannot be overloaded.
John McCall4f5019e2010-12-19 02:44:49 +00001778 QualType OldReturnType = OldType->getResultType();
1779 QualType NewReturnType = cast<FunctionType>(NewQType)->getResultType();
Fariborz Jahanianf633ebd2010-05-19 21:37:30 +00001780 QualType ResQT;
Douglas Gregor5251f1b2008-10-21 16:13:35 +00001781 if (OldReturnType != NewReturnType) {
Fariborz Jahanianf633ebd2010-05-19 21:37:30 +00001782 if (NewReturnType->isObjCObjectPointerType()
1783 && OldReturnType->isObjCObjectPointerType())
1784 ResQT = Context.mergeObjCGCQualifiers(NewQType, OldQType);
1785 if (ResQT.isNull()) {
Argyrios Kyrtzidis3d320862011-02-05 05:54:49 +00001786 if (New->isCXXClassMember() && New->isOutOfLine())
1787 Diag(New->getLocation(),
1788 diag::err_member_def_does_not_match_ret_type) << New;
1789 else
1790 Diag(New->getLocation(), diag::err_ovl_diff_return_type);
Fariborz Jahanianf633ebd2010-05-19 21:37:30 +00001791 Diag(Old->getLocation(), PrevDiag) << Old << Old->getType();
1792 return true;
1793 }
1794 else
1795 NewQType = ResQT;
Douglas Gregor5251f1b2008-10-21 16:13:35 +00001796 }
1797
1798 const CXXMethodDecl* OldMethod = dyn_cast<CXXMethodDecl>(Old);
John McCall43314ab2010-04-13 07:45:41 +00001799 CXXMethodDecl* NewMethod = dyn_cast<CXXMethodDecl>(New);
Anders Carlsson1f78b2b2009-12-04 22:33:25 +00001800 if (OldMethod && NewMethod) {
John McCall43314ab2010-04-13 07:45:41 +00001801 // Preserve triviality.
1802 NewMethod->setTrivial(OldMethod->isTrivial());
Francois Pichetc2fac712011-05-14 19:17:07 +00001803
Francois Pichet00c7e6c2011-08-14 03:52:19 +00001804 // MSVC allows explicit template specialization at class scope:
1805 // 2 CXMethodDecls referring to the same function will be injected.
1806 // We don't want a redeclartion error.
1807 bool IsClassScopeExplicitSpecialization =
1808 OldMethod->isFunctionTemplateSpecialization() &&
1809 NewMethod->isFunctionTemplateSpecialization();
John McCall43314ab2010-04-13 07:45:41 +00001810 bool isFriend = NewMethod->getFriendObjectKind();
1811
Francois Pichet00c7e6c2011-08-14 03:52:19 +00001812 if (!isFriend && NewMethod->getLexicalDeclContext()->isRecord() &&
1813 !IsClassScopeExplicitSpecialization) {
Anders Carlsson1f78b2b2009-12-04 22:33:25 +00001814 // -- Member function declarations with the same name and the
1815 // same parameter types cannot be overloaded if any of them
1816 // is a static member function declaration.
1817 if (OldMethod->isStatic() || NewMethod->isStatic()) {
1818 Diag(New->getLocation(), diag::err_ovl_static_nonstatic_member);
1819 Diag(Old->getLocation(), PrevDiag) << Old << Old->getType();
1820 return true;
1821 }
1822
1823 // C++ [class.mem]p1:
1824 // [...] A member shall not be declared twice in the
1825 // member-specification, except that a nested class or member
1826 // class template can be declared and then later defined.
1827 unsigned NewDiag;
1828 if (isa<CXXConstructorDecl>(OldMethod))
1829 NewDiag = diag::err_constructor_redeclared;
1830 else if (isa<CXXDestructorDecl>(NewMethod))
1831 NewDiag = diag::err_destructor_redeclared;
1832 else if (isa<CXXConversionDecl>(NewMethod))
1833 NewDiag = diag::err_conv_function_redeclared;
1834 else
1835 NewDiag = diag::err_member_redeclared;
1836
1837 Diag(New->getLocation(), NewDiag);
Douglas Gregorb9063fc2009-02-13 23:20:09 +00001838 Diag(Old->getLocation(), PrevDiag) << Old << Old->getType();
John McCall43314ab2010-04-13 07:45:41 +00001839
1840 // Complain if this is an explicit declaration of a special
1841 // member that was initially declared implicitly.
1842 //
1843 // As an exception, it's okay to befriend such methods in order
1844 // to permit the implicit constructor/destructor/operator calls.
1845 } else if (OldMethod->isImplicit()) {
1846 if (isFriend) {
1847 NewMethod->setImplicit();
1848 } else {
Anders Carlsson1f78b2b2009-12-04 22:33:25 +00001849 Diag(NewMethod->getLocation(),
1850 diag::err_definition_of_implicitly_declared_member)
Anders Carlsson05bf0092010-04-22 05:40:53 +00001851 << New << getSpecialMember(OldMethod);
Anders Carlsson1f78b2b2009-12-04 22:33:25 +00001852 return true;
1853 }
Alexis Hunt6d5b96c2011-05-10 00:49:42 +00001854 } else if (OldMethod->isExplicitlyDefaulted()) {
1855 Diag(NewMethod->getLocation(),
1856 diag::err_definition_of_explicitly_defaulted_member)
1857 << getSpecialMember(OldMethod);
1858 return true;
Douglas Gregor5251f1b2008-10-21 16:13:35 +00001859 }
1860 }
1861
1862 // (C++98 8.3.5p3):
1863 // All declarations for a function shall agree exactly in both the
1864 // return type and the parameter-type-list.
John McCall4f5019e2010-12-19 02:44:49 +00001865 // We also want to respect all the extended bits except noreturn.
1866
1867 // noreturn should now match unless the old type info didn't have it.
1868 QualType OldQTypeForComparison = OldQType;
1869 if (!OldTypeInfo.getNoReturn() && NewTypeInfo.getNoReturn()) {
1870 assert(OldQType == QualType(OldType, 0));
1871 const FunctionType *OldTypeForComparison
1872 = Context.adjustFunctionType(OldType, OldTypeInfo.withNoReturn(true));
1873 OldQTypeForComparison = QualType(OldTypeForComparison, 0);
1874 assert(OldQTypeForComparison.isCanonical());
1875 }
1876
1877 if (OldQTypeForComparison == NewQType)
Douglas Gregore62c0a42009-02-24 01:23:02 +00001878 return MergeCompatibleFunctionDecls(New, Old);
Douglas Gregor5251f1b2008-10-21 16:13:35 +00001879
1880 // Fall through for conflicting redeclarations and redefinitions.
Douglas Gregor89f238c2008-04-21 02:02:58 +00001881 }
Chris Lattneraa9c7ae2008-04-08 04:40:51 +00001882
1883 // C: Function types need to be compatible, not identical. This handles
Steve Naroff012484d2008-01-14 20:51:29 +00001884 // duplicate function decls like "void f(int); void f(enum X);" properly.
Chris Lattneraa9c7ae2008-04-08 04:40:51 +00001885 if (!getLangOptions().CPlusPlus &&
Eli Friedman47f77112008-08-22 00:56:42 +00001886 Context.typesAreCompatible(OldQType, NewQType)) {
John McCall9dd450b2009-09-21 23:43:11 +00001887 const FunctionType *OldFuncType = OldQType->getAs<FunctionType>();
1888 const FunctionType *NewFuncType = NewQType->getAs<FunctionType>();
Douglas Gregordeaad8c2009-02-26 23:50:07 +00001889 const FunctionProtoType *OldProto = 0;
1890 if (isa<FunctionNoProtoType>(NewFuncType) &&
Douglas Gregora74a2972009-03-06 22:43:54 +00001891 (OldProto = dyn_cast<FunctionProtoType>(OldFuncType))) {
Douglas Gregorbcbf8632009-02-16 18:20:44 +00001892 // The old declaration provided a function prototype, but the
1893 // new declaration does not. Merge in the prototype.
Sebastian Redl5068f77ac2009-05-27 22:11:52 +00001894 assert(!OldProto->hasExceptionSpec() && "Exception spec in C");
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001895 SmallVector<QualType, 16> ParamTypes(OldProto->arg_type_begin(),
Douglas Gregorbcbf8632009-02-16 18:20:44 +00001896 OldProto->arg_type_end());
1897 NewQType = Context.getFunctionType(NewFuncType->getResultType(),
Jay Foad7d0479f2009-05-21 09:52:38 +00001898 ParamTypes.data(), ParamTypes.size(),
John McCalldb40c7f2010-12-14 08:05:40 +00001899 OldProto->getExtProtoInfo());
Douglas Gregorbcbf8632009-02-16 18:20:44 +00001900 New->setType(NewQType);
Anders Carlssone0dd1d52009-05-14 21:46:00 +00001901 New->setHasInheritedPrototype();
Douglas Gregorbfdd6072009-02-16 20:58:07 +00001902
1903 // Synthesize a parameter for each argument type.
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001904 SmallVector<ParmVarDecl*, 16> Params;
Mike Stump11289f42009-09-09 15:08:12 +00001905 for (FunctionProtoType::arg_type_iterator
1906 ParamType = OldProto->arg_type_begin(),
Douglas Gregorbfdd6072009-02-16 20:58:07 +00001907 ParamEnd = OldProto->arg_type_end();
1908 ParamType != ParamEnd; ++ParamType) {
1909 ParmVarDecl *Param = ParmVarDecl::Create(Context, New,
Abramo Bagnaradff19302011-03-08 08:55:46 +00001910 SourceLocation(),
Douglas Gregorbfdd6072009-02-16 20:58:07 +00001911 SourceLocation(), 0,
John McCallbcd03502009-12-07 02:54:59 +00001912 *ParamType, /*TInfo=*/0,
John McCall8e7d6562010-08-26 03:08:43 +00001913 SC_None, SC_None,
Douglas Gregorc4df4072010-04-19 22:54:31 +00001914 0);
John McCall8fb0d9d2011-05-01 22:35:37 +00001915 Param->setScopeInfo(0, Params.size());
Douglas Gregorbfdd6072009-02-16 20:58:07 +00001916 Param->setImplicit();
1917 Params.push_back(Param);
1918 }
1919
David Blaikie9c70e042011-09-21 18:16:56 +00001920 New->setParams(Params);
Mike Stump11289f42009-09-09 15:08:12 +00001921 }
Douglas Gregorbcbf8632009-02-16 18:20:44 +00001922
Douglas Gregore62c0a42009-02-24 01:23:02 +00001923 return MergeCompatibleFunctionDecls(New, Old);
Chris Lattneraa9c7ae2008-04-08 04:40:51 +00001924 }
Chris Lattner45d561a2007-11-06 06:07:26 +00001925
Douglas Gregora74a2972009-03-06 22:43:54 +00001926 // GNU C permits a K&R definition to follow a prototype declaration
1927 // if the declared types of the parameters in the K&R definition
1928 // match the types in the prototype declaration, even when the
1929 // promoted types of the parameters from the K&R definition differ
1930 // from the types in the prototype. GCC then keeps the types from
1931 // the prototype.
Eli Friedmanfcbf7d22009-06-01 09:24:59 +00001932 //
1933 // If a variadic prototype is followed by a non-variadic K&R definition,
1934 // the K&R definition becomes variadic. This is sort of an edge case, but
1935 // it's legal per the standard depending on how you read C99 6.7.5.3p15 and
1936 // C99 6.9.1p8.
Douglas Gregora74a2972009-03-06 22:43:54 +00001937 if (!getLangOptions().CPlusPlus &&
Douglas Gregora74a2972009-03-06 22:43:54 +00001938 Old->hasPrototype() && !New->hasPrototype() &&
John McCall9dd450b2009-09-21 23:43:11 +00001939 New->getType()->getAs<FunctionProtoType>() &&
Douglas Gregora74a2972009-03-06 22:43:54 +00001940 Old->getNumParams() == New->getNumParams()) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001941 SmallVector<QualType, 16> ArgTypes;
1942 SmallVector<GNUCompatibleParamWarning, 16> Warnings;
Mike Stump11289f42009-09-09 15:08:12 +00001943 const FunctionProtoType *OldProto
John McCall9dd450b2009-09-21 23:43:11 +00001944 = Old->getType()->getAs<FunctionProtoType>();
Mike Stump11289f42009-09-09 15:08:12 +00001945 const FunctionProtoType *NewProto
John McCall9dd450b2009-09-21 23:43:11 +00001946 = New->getType()->getAs<FunctionProtoType>();
Mike Stump11289f42009-09-09 15:08:12 +00001947
Douglas Gregora74a2972009-03-06 22:43:54 +00001948 // Determine whether this is the GNU C extension.
Eli Friedmanfcbf7d22009-06-01 09:24:59 +00001949 QualType MergedReturn = Context.mergeTypes(OldProto->getResultType(),
1950 NewProto->getResultType());
1951 bool LooseCompatible = !MergedReturn.isNull();
Mike Stump11289f42009-09-09 15:08:12 +00001952 for (unsigned Idx = 0, End = Old->getNumParams();
Eli Friedmanfcbf7d22009-06-01 09:24:59 +00001953 LooseCompatible && Idx != End; ++Idx) {
Douglas Gregora74a2972009-03-06 22:43:54 +00001954 ParmVarDecl *OldParm = Old->getParamDecl(Idx);
1955 ParmVarDecl *NewParm = New->getParamDecl(Idx);
Mike Stump11289f42009-09-09 15:08:12 +00001956 if (Context.typesAreCompatible(OldParm->getType(),
Douglas Gregora74a2972009-03-06 22:43:54 +00001957 NewProto->getArgType(Idx))) {
1958 ArgTypes.push_back(NewParm->getType());
1959 } else if (Context.typesAreCompatible(OldParm->getType(),
Douglas Gregor17ea3f52010-07-29 15:18:02 +00001960 NewParm->getType(),
1961 /*CompareUnqualified=*/true)) {
Mike Stump11289f42009-09-09 15:08:12 +00001962 GNUCompatibleParamWarning Warn
Douglas Gregora74a2972009-03-06 22:43:54 +00001963 = { OldParm, NewParm, NewProto->getArgType(Idx) };
1964 Warnings.push_back(Warn);
1965 ArgTypes.push_back(NewParm->getType());
1966 } else
Eli Friedmanfcbf7d22009-06-01 09:24:59 +00001967 LooseCompatible = false;
Douglas Gregora74a2972009-03-06 22:43:54 +00001968 }
1969
Eli Friedmanfcbf7d22009-06-01 09:24:59 +00001970 if (LooseCompatible) {
Douglas Gregora74a2972009-03-06 22:43:54 +00001971 for (unsigned Warn = 0; Warn < Warnings.size(); ++Warn) {
1972 Diag(Warnings[Warn].NewParm->getLocation(),
1973 diag::ext_param_promoted_not_compatible_with_prototype)
1974 << Warnings[Warn].PromotedType
1975 << Warnings[Warn].OldParm->getType();
Douglas Gregor17ea3f52010-07-29 15:18:02 +00001976 if (Warnings[Warn].OldParm->getLocation().isValid())
1977 Diag(Warnings[Warn].OldParm->getLocation(),
1978 diag::note_previous_declaration);
Douglas Gregora74a2972009-03-06 22:43:54 +00001979 }
1980
Eli Friedmanfcbf7d22009-06-01 09:24:59 +00001981 New->setType(Context.getFunctionType(MergedReturn, &ArgTypes[0],
1982 ArgTypes.size(),
John McCalldb40c7f2010-12-14 08:05:40 +00001983 OldProto->getExtProtoInfo()));
Douglas Gregora74a2972009-03-06 22:43:54 +00001984 return MergeCompatibleFunctionDecls(New, Old);
1985 }
1986
1987 // Fall through to diagnose conflicting types.
1988 }
1989
Steve Naroff17832a42008-01-16 15:01:34 +00001990 // A function that has already been declared has been redeclared or defined
1991 // with a different type- show appropriate diagnostic
Douglas Gregor15fc9562009-09-12 00:22:50 +00001992 if (unsigned BuiltinID = Old->getBuiltinID()) {
Douglas Gregor75a45ba2009-02-16 17:45:42 +00001993 // The user has declared a builtin function with an incompatible
1994 // signature.
1995 if (Context.BuiltinInfo.isPredefinedLibFunction(BuiltinID)) {
1996 // The function the user is redeclaring is a library-defined
1997 // function like 'malloc' or 'printf'. Warn about the
Douglas Gregor893c2c92009-03-23 17:47:24 +00001998 // redeclaration, then pretend that we don't know about this
1999 // library built-in.
Douglas Gregor75a45ba2009-02-16 17:45:42 +00002000 Diag(New->getLocation(), diag::warn_redecl_library_builtin) << New;
2001 Diag(Old->getLocation(), diag::note_previous_builtin_declaration)
2002 << Old << Old->getType();
Douglas Gregor893c2c92009-03-23 17:47:24 +00002003 New->getIdentifier()->setBuiltinID(Builtin::NotBuiltin);
2004 Old->setInvalidDecl();
2005 return false;
Douglas Gregor75a45ba2009-02-16 17:45:42 +00002006 }
Steve Naroff17832a42008-01-16 15:01:34 +00002007
Douglas Gregor75a45ba2009-02-16 17:45:42 +00002008 PrevDiag = diag::note_previous_builtin_declaration;
2009 }
2010
Chris Lattnerf3d3fae2008-11-24 05:29:24 +00002011 Diag(New->getLocation(), diag::err_conflicting_types) << New->getDeclName();
Douglas Gregorb9063fc2009-02-13 23:20:09 +00002012 Diag(Old->getLocation(), PrevDiag) << Old << Old->getType();
Douglas Gregor75a45ba2009-02-16 17:45:42 +00002013 return true;
Chris Lattner01564d92007-01-27 19:27:06 +00002014}
2015
Douglas Gregore62c0a42009-02-24 01:23:02 +00002016/// \brief Completes the merge of two function declarations that are
Mike Stump11289f42009-09-09 15:08:12 +00002017/// known to be compatible.
Douglas Gregore62c0a42009-02-24 01:23:02 +00002018///
2019/// This routine handles the merging of attributes and other
2020/// properties of function declarations form the old declaration to
2021/// the new declaration, once we know that New is in fact a
2022/// redeclaration of Old.
2023///
2024/// \returns false
2025bool Sema::MergeCompatibleFunctionDecls(FunctionDecl *New, FunctionDecl *Old) {
2026 // Merge the attributes
John McCallf79e87d2011-03-02 04:00:57 +00002027 mergeDeclAttributes(New, Old, Context);
Douglas Gregore62c0a42009-02-24 01:23:02 +00002028
2029 // Merge the storage class.
John McCall8e7d6562010-08-26 03:08:43 +00002030 if (Old->getStorageClass() != SC_Extern &&
2031 Old->getStorageClass() != SC_None)
Douglas Gregor76fe50c2009-04-28 06:37:30 +00002032 New->setStorageClass(Old->getStorageClass());
Douglas Gregore62c0a42009-02-24 01:23:02 +00002033
Douglas Gregore62c0a42009-02-24 01:23:02 +00002034 // Merge "pure" flag.
2035 if (Old->isPure())
2036 New->setPure();
2037
Douglas Gregoref15bdb2011-09-09 18:32:39 +00002038 // __module_private__ is propagated to later declarations.
2039 if (Old->isModulePrivate())
2040 New->setModulePrivate();
Douglas Gregor2820e692011-09-09 19:05:14 +00002041 else if (New->isModulePrivate())
2042 diagnoseModulePrivateRedeclaration(New, Old);
2043
John McCallf79e87d2011-03-02 04:00:57 +00002044 // Merge attributes from the parameters. These can mismatch with K&R
2045 // declarations.
2046 if (New->getNumParams() == Old->getNumParams())
2047 for (unsigned i = 0, e = New->getNumParams(); i != e; ++i)
2048 mergeParamDeclAttributes(New->getParamDecl(i), Old->getParamDecl(i),
2049 Context);
2050
Douglas Gregore62c0a42009-02-24 01:23:02 +00002051 if (getLangOptions().CPlusPlus)
2052 return MergeCXXFunctionDecl(New, Old);
2053
2054 return false;
2055}
2056
John McCall31168b02011-06-15 23:02:42 +00002057
John McCallf79e87d2011-03-02 04:00:57 +00002058void Sema::mergeObjCMethodDecls(ObjCMethodDecl *newMethod,
2059 const ObjCMethodDecl *oldMethod) {
John McCalld2930c22011-07-22 02:45:48 +00002060 // We don't want to merge unavailable and deprecated attributes
2061 // except from interface to implementation.
2062 bool mergeDeprecation = isa<ObjCImplDecl>(newMethod->getDeclContext());
2063
John McCallf79e87d2011-03-02 04:00:57 +00002064 // Merge the attributes.
John McCalld2930c22011-07-22 02:45:48 +00002065 mergeDeclAttributes(newMethod, oldMethod, Context, mergeDeprecation);
John McCallf79e87d2011-03-02 04:00:57 +00002066
2067 // Merge attributes from the parameters.
Argyrios Kyrtzidisb8c3aaf2011-10-03 06:37:04 +00002068 ObjCMethodDecl::param_const_iterator oi = oldMethod->param_begin();
2069 for (ObjCMethodDecl::param_iterator
John McCallf79e87d2011-03-02 04:00:57 +00002070 ni = newMethod->param_begin(), ne = newMethod->param_end();
2071 ni != ne; ++ni, ++oi)
Douglas Gregor33823722011-06-11 01:09:30 +00002072 mergeParamDeclAttributes(*ni, *oi, Context);
John McCalld2930c22011-07-22 02:45:48 +00002073
Douglas Gregor33823722011-06-11 01:09:30 +00002074 CheckObjCMethodOverride(newMethod, oldMethod, true);
John McCallf79e87d2011-03-02 04:00:57 +00002075}
2076
Sebastian Redlfa453cf2011-03-12 11:50:43 +00002077/// MergeVarDeclTypes - We parsed a variable 'New' which has the same name and
2078/// scope as a previous declaration 'Old'. Figure out how to merge their types,
Richard Smith30482bc2011-02-20 03:19:35 +00002079/// emitting diagnostics as appropriate.
2080///
2081/// Declarations using the auto type specifier (C++ [decl.spec.auto]) call back
2082/// to here in AddInitializerToDecl and AddCXXDirectInitializerToDecl. We can't
2083/// check them before the initializer is attached.
2084///
2085void Sema::MergeVarDeclTypes(VarDecl *New, VarDecl *Old) {
2086 if (New->isInvalidDecl() || Old->isInvalidDecl())
2087 return;
2088
2089 QualType MergedT;
2090 if (getLangOptions().CPlusPlus) {
2091 AutoType *AT = New->getType()->getContainedAutoType();
2092 if (AT && !AT->isDeduced()) {
2093 // We don't know what the new type is until the initializer is attached.
2094 return;
Sebastian Redlfa453cf2011-03-12 11:50:43 +00002095 } else if (Context.hasSameType(New->getType(), Old->getType())) {
2096 // These could still be something that needs exception specs checked.
2097 return MergeVarDeclExceptionSpecs(New, Old);
2098 }
Richard Smith30482bc2011-02-20 03:19:35 +00002099 // C++ [basic.link]p10:
2100 // [...] the types specified by all declarations referring to a given
2101 // object or function shall be identical, except that declarations for an
2102 // array object can specify array types that differ by the presence or
2103 // absence of a major array bound (8.3.4).
2104 else if (Old->getType()->isIncompleteArrayType() &&
2105 New->getType()->isArrayType()) {
2106 CanQual<ArrayType> OldArray
2107 = Context.getCanonicalType(Old->getType())->getAs<ArrayType>();
2108 CanQual<ArrayType> NewArray
2109 = Context.getCanonicalType(New->getType())->getAs<ArrayType>();
2110 if (OldArray->getElementType() == NewArray->getElementType())
2111 MergedT = New->getType();
2112 } else if (Old->getType()->isArrayType() &&
2113 New->getType()->isIncompleteArrayType()) {
2114 CanQual<ArrayType> OldArray
2115 = Context.getCanonicalType(Old->getType())->getAs<ArrayType>();
2116 CanQual<ArrayType> NewArray
2117 = Context.getCanonicalType(New->getType())->getAs<ArrayType>();
2118 if (OldArray->getElementType() == NewArray->getElementType())
2119 MergedT = Old->getType();
2120 } else if (New->getType()->isObjCObjectPointerType()
2121 && Old->getType()->isObjCObjectPointerType()) {
2122 MergedT = Context.mergeObjCGCQualifiers(New->getType(),
2123 Old->getType());
2124 }
2125 } else {
2126 MergedT = Context.mergeTypes(New->getType(), Old->getType());
2127 }
2128 if (MergedT.isNull()) {
2129 Diag(New->getLocation(), diag::err_redefinition_different_type)
2130 << New->getDeclName();
2131 Diag(Old->getLocation(), diag::note_previous_definition);
2132 return New->setInvalidDecl();
2133 }
2134 New->setType(MergedT);
2135}
2136
Chris Lattner01564d92007-01-27 19:27:06 +00002137/// MergeVarDecl - We just parsed a variable 'New' which has the same name
2138/// and scope as a previous declaration 'Old'. Figure out how to resolve this
2139/// situation, merging decls or emitting diagnostics as appropriate.
2140///
Mike Stump11289f42009-09-09 15:08:12 +00002141/// Tentative definition rules (C99 6.9.2p2) are checked by
2142/// FinalizeDeclaratorGroup. Unfortunately, we can't analyze tentative
Steve Naroff5bb8f222008-08-08 17:50:35 +00002143/// definitions here, since the initializer hasn't been attached.
Mike Stump11289f42009-09-09 15:08:12 +00002144///
John McCall1f82f242009-11-18 22:49:29 +00002145void Sema::MergeVarDecl(VarDecl *New, LookupResult &Previous) {
2146 // If the new decl is already invalid, don't do any other checking.
2147 if (New->isInvalidDecl())
2148 return;
Mike Stump11289f42009-09-09 15:08:12 +00002149
Chris Lattnerc511efb2007-01-27 19:32:14 +00002150 // Verify the old decl was also a variable.
John McCall1f82f242009-11-18 22:49:29 +00002151 VarDecl *Old = 0;
2152 if (!Previous.isSingleResult() ||
2153 !(Old = dyn_cast<VarDecl>(Previous.getFoundDecl()))) {
Chris Lattner651d42d2008-11-20 06:38:18 +00002154 Diag(New->getLocation(), diag::err_redefinition_different_kind)
Chris Lattnere3d20d92008-11-23 21:45:46 +00002155 << New->getDeclName();
John McCall1f82f242009-11-18 22:49:29 +00002156 Diag(Previous.getRepresentativeDecl()->getLocation(),
2157 diag::note_previous_definition);
Chris Lattnerf6d1c9c2009-04-25 08:06:05 +00002158 return New->setInvalidDecl();
Chris Lattnerc511efb2007-01-27 19:32:14 +00002159 }
Chris Lattner84966392008-03-03 03:28:21 +00002160
Douglas Gregor2c7d9292010-08-30 14:32:14 +00002161 // C++ [class.mem]p1:
2162 // A member shall not be declared twice in the member-specification [...]
2163 //
2164 // Here, we need only consider static data members.
2165 if (Old->isStaticDataMember() && !New->isOutOfLine()) {
2166 Diag(New->getLocation(), diag::err_duplicate_member)
2167 << New->getIdentifier();
2168 Diag(Old->getLocation(), diag::note_previous_declaration);
2169 New->setInvalidDecl();
2170 }
2171
John McCallf79e87d2011-03-02 04:00:57 +00002172 mergeDeclAttributes(New, Old, Context);
Fariborz Jahanian33e02262011-06-22 22:08:50 +00002173 // Warn if an already-declared variable is made a weak_import in a subsequent declaration
Fariborz Jahanianab578bf2011-06-20 17:50:03 +00002174 if (New->getAttr<WeakImportAttr>() &&
2175 Old->getStorageClass() == SC_None &&
Fariborz Jahanian33e02262011-06-22 22:08:50 +00002176 !Old->getAttr<WeakImportAttr>()) {
2177 Diag(New->getLocation(), diag::warn_weak_import) << New->getDeclName();
2178 Diag(Old->getLocation(), diag::note_previous_definition);
2179 // Remove weak_import attribute on new declaration.
Fariborz Jahanian0dfc9502011-06-23 17:50:10 +00002180 New->dropAttr<WeakImportAttr>();
Fariborz Jahanian33e02262011-06-22 22:08:50 +00002181 }
Chris Lattner84966392008-03-03 03:28:21 +00002182
Richard Smith30482bc2011-02-20 03:19:35 +00002183 // Merge the types.
2184 MergeVarDeclTypes(New, Old);
2185 if (New->isInvalidDecl())
2186 return;
Douglas Gregor04e9a032009-03-11 23:52:16 +00002187
Steve Naroff1e787362008-01-30 00:44:01 +00002188 // C99 6.2.2p4: Check if we have a static decl followed by a non-static.
John McCall8e7d6562010-08-26 03:08:43 +00002189 if (New->getStorageClass() == SC_Static &&
2190 (Old->getStorageClass() == SC_None || Old->hasExternalStorage())) {
Chris Lattnerf3d3fae2008-11-24 05:29:24 +00002191 Diag(New->getLocation(), diag::err_static_non_static) << New->getDeclName();
Chris Lattner0369c572008-11-23 23:12:31 +00002192 Diag(Old->getLocation(), diag::note_previous_definition);
Chris Lattnerf6d1c9c2009-04-25 08:06:05 +00002193 return New->setInvalidDecl();
Steve Naroff1e787362008-01-30 00:44:01 +00002194 }
Mike Stump11289f42009-09-09 15:08:12 +00002195 // C99 6.2.2p4:
Douglas Gregor37311622009-03-19 22:01:50 +00002196 // For an identifier declared with the storage-class specifier
2197 // extern in a scope in which a prior declaration of that
2198 // identifier is visible,23) if the prior declaration specifies
2199 // internal or external linkage, the linkage of the identifier at
2200 // the later declaration is the same as the linkage specified at
2201 // the prior declaration. If no prior declaration is visible, or
2202 // if the prior declaration specifies no linkage, then the
2203 // identifier has external linkage.
Douglas Gregord4eca012009-03-23 16:17:01 +00002204 if (New->hasExternalStorage() && Old->hasLinkage())
Douglas Gregor37311622009-03-19 22:01:50 +00002205 /* Okay */;
John McCall8e7d6562010-08-26 03:08:43 +00002206 else if (New->getStorageClass() != SC_Static &&
2207 Old->getStorageClass() == SC_Static) {
Chris Lattnerf3d3fae2008-11-24 05:29:24 +00002208 Diag(New->getLocation(), diag::err_non_static_static) << New->getDeclName();
Chris Lattner0369c572008-11-23 23:12:31 +00002209 Diag(Old->getLocation(), diag::note_previous_definition);
Chris Lattnerf6d1c9c2009-04-25 08:06:05 +00002210 return New->setInvalidDecl();
Steve Naroff1e787362008-01-30 00:44:01 +00002211 }
Daniel Dunbar0ca16602009-04-14 02:25:56 +00002212
Argyrios Kyrtzidis819f6102011-01-31 07:04:46 +00002213 // Check if extern is followed by non-extern and vice-versa.
2214 if (New->hasExternalStorage() &&
2215 !Old->hasLinkage() && Old->isLocalVarDecl()) {
2216 Diag(New->getLocation(), diag::err_extern_non_extern) << New->getDeclName();
2217 Diag(Old->getLocation(), diag::note_previous_definition);
2218 return New->setInvalidDecl();
2219 }
2220 if (Old->hasExternalStorage() &&
2221 !New->hasLinkage() && New->isLocalVarDecl()) {
2222 Diag(New->getLocation(), diag::err_non_extern_extern) << New->getDeclName();
2223 Diag(Old->getLocation(), diag::note_previous_definition);
2224 return New->setInvalidDecl();
2225 }
2226
Douglas Gregoref15bdb2011-09-09 18:32:39 +00002227 // __module_private__ is propagated to later declarations.
2228 if (Old->isModulePrivate())
2229 New->setModulePrivate();
Douglas Gregor2820e692011-09-09 19:05:14 +00002230 else if (New->isModulePrivate())
2231 diagnoseModulePrivateRedeclaration(New, Old);
Douglas Gregoref15bdb2011-09-09 18:32:39 +00002232
Steve Naroffa5629372008-09-17 14:05:40 +00002233 // Variables with external linkage are analyzed in FinalizeDeclaratorGroup.
Mike Stump11289f42009-09-09 15:08:12 +00002234
Daniel Dunbar0ca16602009-04-14 02:25:56 +00002235 // FIXME: The test for external storage here seems wrong? We still
2236 // need to check for mismatches.
2237 if (!New->hasExternalStorage() && !New->isFileVarDecl() &&
Douglas Gregor04e9a032009-03-11 23:52:16 +00002238 // Don't complain about out-of-line definitions of static members.
2239 !(Old->getLexicalDeclContext()->isRecord() &&
2240 !New->getLexicalDeclContext()->isRecord())) {
Chris Lattnere3d20d92008-11-23 21:45:46 +00002241 Diag(New->getLocation(), diag::err_redefinition) << New->getDeclName();
Chris Lattner0369c572008-11-23 23:12:31 +00002242 Diag(Old->getLocation(), diag::note_previous_definition);
Chris Lattnerf6d1c9c2009-04-25 08:06:05 +00002243 return New->setInvalidDecl();
Steve Naroff6fbf0dc2007-03-16 00:33:25 +00002244 }
Douglas Gregor0760fa12009-03-10 23:43:53 +00002245
Eli Friedmand5c0eed2009-04-19 20:27:55 +00002246 if (New->isThreadSpecified() && !Old->isThreadSpecified()) {
2247 Diag(New->getLocation(), diag::err_thread_non_thread) << New->getDeclName();
2248 Diag(Old->getLocation(), diag::note_previous_definition);
2249 } else if (!New->isThreadSpecified() && Old->isThreadSpecified()) {
2250 Diag(New->getLocation(), diag::err_non_thread_thread) << New->getDeclName();
2251 Diag(Old->getLocation(), diag::note_previous_definition);
2252 }
2253
Sebastian Redlf1842912010-02-02 18:35:11 +00002254 // C++ doesn't have tentative definitions, so go right ahead and check here.
2255 const VarDecl *Def;
Sebastian Redld85be0c2010-02-03 02:08:48 +00002256 if (getLangOptions().CPlusPlus &&
2257 New->isThisDeclarationADefinition() == VarDecl::Definition &&
Sebastian Redlf1842912010-02-02 18:35:11 +00002258 (Def = Old->getDefinition())) {
2259 Diag(New->getLocation(), diag::err_redefinition)
2260 << New->getDeclName();
2261 Diag(Def->getLocation(), diag::note_previous_definition);
2262 New->setInvalidDecl();
2263 return;
2264 }
Fariborz Jahanianad356a12010-06-25 00:05:45 +00002265 // c99 6.2.2 P4.
2266 // For an identifier declared with the storage-class specifier extern in a
2267 // scope in which a prior declaration of that identifier is visible, if
2268 // the prior declaration specifies internal or external linkage, the linkage
2269 // of the identifier at the later declaration is the same as the linkage
2270 // specified at the prior declaration.
2271 // FIXME. revisit this code.
Fariborz Jahaniancc99b3c2010-06-21 16:08:37 +00002272 if (New->hasExternalStorage() &&
Fariborz Jahanian4f9c9d62010-06-24 18:50:41 +00002273 Old->getLinkage() == InternalLinkage &&
2274 New->getDeclContext() == Old->getDeclContext())
Fariborz Jahaniancc99b3c2010-06-21 16:08:37 +00002275 New->setStorageClass(Old->getStorageClass());
2276
Douglas Gregor0760fa12009-03-10 23:43:53 +00002277 // Keep a chain of previous declarations.
2278 New->setPreviousDeclaration(Old);
John McCall401982f2010-01-20 21:53:11 +00002279
2280 // Inherit access appropriately.
2281 New->setAccess(Old->getAccess());
Chris Lattner01564d92007-01-27 19:27:06 +00002282}
2283
Chris Lattnerb6738ec2007-01-28 00:38:24 +00002284/// ParsedFreeStandingDeclSpec - This method is invoked when a declspec with
2285/// no declarator (e.g. "struct foo;") is parsed.
John McCall48871652010-08-21 09:40:31 +00002286Decl *Sema::ParsedFreeStandingDeclSpec(Scope *S, AccessSpecifier AS,
John McCallaa017372011-03-22 23:00:04 +00002287 DeclSpec &DS) {
Chandler Carruth7c9856d2011-05-03 18:35:10 +00002288 return ParsedFreeStandingDeclSpec(S, AS, DS,
2289 MultiTemplateParamsArg(*this, 0, 0));
2290}
2291
2292/// ParsedFreeStandingDeclSpec - This method is invoked when a declspec with
2293/// no declarator (e.g. "struct foo;") is parsed. It also accopts template
2294/// parameters to cope with template friend declarations.
2295Decl *Sema::ParsedFreeStandingDeclSpec(Scope *S, AccessSpecifier AS,
2296 DeclSpec &DS,
2297 MultiTemplateParamsArg TemplateParams) {
John McCallc3987482009-10-07 23:34:25 +00002298 Decl *TagD = 0;
Douglas Gregor9817f4a2009-02-09 15:09:02 +00002299 TagDecl *Tag = 0;
2300 if (DS.getTypeSpecType() == DeclSpec::TST_class ||
2301 DS.getTypeSpecType() == DeclSpec::TST_struct ||
2302 DS.getTypeSpecType() == DeclSpec::TST_union ||
Douglas Gregor1b57ff32009-05-12 23:25:50 +00002303 DS.getTypeSpecType() == DeclSpec::TST_enum) {
John McCallba7bf592010-08-24 05:47:05 +00002304 TagD = DS.getRepAsDecl();
John McCallc3987482009-10-07 23:34:25 +00002305
2306 if (!TagD) // We probably had an error
John McCall48871652010-08-21 09:40:31 +00002307 return 0;
Douglas Gregor1b57ff32009-05-12 23:25:50 +00002308
John McCall07e91c02009-08-06 02:15:43 +00002309 // Note that the above type specs guarantee that the
2310 // type rep is a Decl, whereas in many of the others
2311 // it's a Type.
John McCallc3987482009-10-07 23:34:25 +00002312 Tag = dyn_cast<TagDecl>(TagD);
Douglas Gregor1b57ff32009-05-12 23:25:50 +00002313 }
Douglas Gregor9817f4a2009-02-09 15:09:02 +00002314
Argyrios Kyrtzidis201d3772011-09-30 22:11:31 +00002315 if (Tag)
2316 Tag->setFreeStanding();
2317
Nuno Lopese9823fa2009-12-17 11:35:26 +00002318 if (unsigned TypeQuals = DS.getTypeQualifiers()) {
2319 // Enforce C99 6.7.3p2: "Types other than pointer types derived from object
2320 // or incomplete types shall not be restrict-qualified."
2321 if (TypeQuals & DeclSpec::TQ_restrict)
2322 Diag(DS.getRestrictSpecLoc(),
2323 diag::err_typecheck_invalid_restrict_not_pointer_noarg)
2324 << DS.getSourceRange();
2325 }
2326
Richard Smitha77a0a62011-08-15 21:04:07 +00002327 if (DS.isConstexprSpecified()) {
2328 // C++0x [dcl.constexpr]p1: constexpr can only be applied to declarations
2329 // and definitions of functions and variables.
2330 if (Tag)
2331 Diag(DS.getConstexprSpecLoc(), diag::err_constexpr_tag)
2332 << (DS.getTypeSpecType() == DeclSpec::TST_class ? 0 :
2333 DS.getTypeSpecType() == DeclSpec::TST_struct ? 1 :
2334 DS.getTypeSpecType() == DeclSpec::TST_union ? 2 : 3);
2335 else
2336 Diag(DS.getConstexprSpecLoc(), diag::err_constexpr_no_declarators);
2337 // Don't emit warnings after this error.
2338 return TagD;
2339 }
2340
Douglas Gregor3dad8422009-09-26 06:47:28 +00002341 if (DS.isFriendSpecified()) {
John McCallace48cd2010-10-19 01:40:49 +00002342 // If we're dealing with a decl but not a TagDecl, assume that
2343 // whatever routines created it handled the friendship aspect.
2344 if (TagD && !Tag)
John McCall48871652010-08-21 09:40:31 +00002345 return 0;
Chandler Carruth7c9856d2011-05-03 18:35:10 +00002346 return ActOnFriendTypeDecl(S, DS, TemplateParams);
Douglas Gregor3dad8422009-09-26 06:47:28 +00002347 }
John McCallaa017372011-03-22 23:00:04 +00002348
2349 // Track whether we warned about the fact that there aren't any
2350 // declarators.
2351 bool emittedWarning = false;
Douglas Gregor3dad8422009-09-26 06:47:28 +00002352
Douglas Gregorc6f58fe2009-01-12 22:49:06 +00002353 if (RecordDecl *Record = dyn_cast_or_null<RecordDecl>(Tag)) {
John McCall53fa7142010-12-24 02:08:15 +00002354 ProcessDeclAttributeList(S, Record, DS.getAttributes().getList());
Chris Lattnerecf328e2009-10-25 22:21:57 +00002355
John McCallf937c022011-10-07 06:10:15 +00002356 if (!Record->getDeclName() && Record->isCompleteDefinition() &&
Douglas Gregor2e7cba62009-03-06 23:06:59 +00002357 DS.getStorageClassSpec() != DeclSpec::SCS_typedef) {
2358 if (getLangOptions().CPlusPlus ||
2359 Record->getDeclContext()->isRecord())
John McCallb54367d2010-05-21 20:45:30 +00002360 return BuildAnonymousStructOrUnion(S, DS, AS, Record);
Douglas Gregor2e7cba62009-03-06 23:06:59 +00002361
Douglas Gregorf19ac0e2010-04-08 21:33:23 +00002362 Diag(DS.getSourceRange().getBegin(), diag::ext_no_declarators)
Douglas Gregor2e7cba62009-03-06 23:06:59 +00002363 << DS.getSourceRange();
John McCallaa017372011-03-22 23:00:04 +00002364 emittedWarning = true;
Douglas Gregor2e7cba62009-03-06 23:06:59 +00002365 }
Francois Pichet0c71f6c2010-11-23 06:07:27 +00002366 }
Douglas Gregorc6f58fe2009-01-12 22:49:06 +00002367
Francois Pichet0c71f6c2010-11-23 06:07:27 +00002368 // Check for Microsoft C extension: anonymous struct.
Francois Pichet0706d202011-09-17 17:15:52 +00002369 if (getLangOptions().MicrosoftExt && !getLangOptions().CPlusPlus &&
Francois Pichet0c71f6c2010-11-23 06:07:27 +00002370 CurContext->isRecord() &&
2371 DS.getStorageClassSpec() == DeclSpec::SCS_unspecified) {
2372 // Handle 2 kinds of anonymous struct:
2373 // struct STRUCT;
2374 // and
2375 // STRUCT_TYPE; <- where STRUCT_TYPE is a typedef struct.
2376 RecordDecl *Record = dyn_cast_or_null<RecordDecl>(Tag);
John McCallf937c022011-10-07 06:10:15 +00002377 if ((Record && Record->getDeclName() && !Record->isCompleteDefinition()) ||
Francois Pichet0c71f6c2010-11-23 06:07:27 +00002378 (DS.getTypeSpecType() == DeclSpec::TST_typename &&
2379 DS.getRepAsType().get()->isStructureType())) {
2380 Diag(DS.getSourceRange().getBegin(), diag::ext_ms_anonymous_struct)
2381 << DS.getSourceRange();
2382 return BuildMicrosoftCAnonymousStruct(S, DS, Record);
2383 }
Douglas Gregorc6f58fe2009-01-12 22:49:06 +00002384 }
Douglas Gregor3dad8422009-09-26 06:47:28 +00002385
Douglas Gregoraa8c9722010-07-13 06:24:26 +00002386 if (getLangOptions().CPlusPlus &&
2387 DS.getStorageClassSpec() != DeclSpec::SCS_typedef)
2388 if (EnumDecl *Enum = dyn_cast_or_null<EnumDecl>(Tag))
2389 if (Enum->enumerator_begin() == Enum->enumerator_end() &&
John McCallaa017372011-03-22 23:00:04 +00002390 !Enum->getIdentifier() && !Enum->isInvalidDecl()) {
Douglas Gregoraa8c9722010-07-13 06:24:26 +00002391 Diag(Enum->getLocation(), diag::ext_no_declarators)
2392 << DS.getSourceRange();
John McCallaa017372011-03-22 23:00:04 +00002393 emittedWarning = true;
2394 }
2395
2396 // Skip all the checks below if we have a type error.
2397 if (DS.getTypeSpecType() == DeclSpec::TST_error) return TagD;
Douglas Gregoraa8c9722010-07-13 06:24:26 +00002398
John McCallaa017372011-03-22 23:00:04 +00002399 if (!DS.isMissingDeclaratorOk()) {
Douglas Gregor2d9dde0e2009-01-22 16:23:54 +00002400 // Warn about typedefs of enums without names, since this is an
Douglas Gregor3a8e0d72010-07-16 15:40:40 +00002401 // extension in both Microsoft and GNU.
Douglas Gregor051d8fd2009-01-17 02:55:50 +00002402 if (DS.getStorageClassSpec() == DeclSpec::SCS_typedef &&
2403 Tag && isa<EnumDecl>(Tag)) {
Douglas Gregor3a8e0d72010-07-16 15:40:40 +00002404 Diag(DS.getSourceRange().getBegin(), diag::ext_typedef_without_a_name)
2405 << DS.getSourceRange();
John McCall48871652010-08-21 09:40:31 +00002406 return Tag;
Douglas Gregor2b136fe2009-01-13 23:10:51 +00002407 }
2408
Douglas Gregorf19ac0e2010-04-08 21:33:23 +00002409 Diag(DS.getSourceRange().getBegin(), diag::ext_no_declarators)
Sebastian Redla2b5e312008-12-28 15:28:59 +00002410 << DS.getSourceRange();
John McCallaa017372011-03-22 23:00:04 +00002411 emittedWarning = true;
Sebastian Redla2b5e312008-12-28 15:28:59 +00002412 }
Mike Stump11289f42009-09-09 15:08:12 +00002413
John McCallaa017372011-03-22 23:00:04 +00002414 // We're going to complain about a bunch of spurious specifiers;
2415 // only do this if we're declaring a tag, because otherwise we
2416 // should be getting diag::ext_no_declarators.
2417 if (emittedWarning || (TagD && TagD->isInvalidDecl()))
2418 return TagD;
2419
John McCall4d55f5a2011-03-26 02:09:52 +00002420 // Note that a linkage-specification sets a storage class, but
2421 // 'extern "C" struct foo;' is actually valid and not theoretically
2422 // useless.
John McCallaa017372011-03-22 23:00:04 +00002423 if (DeclSpec::SCS scs = DS.getStorageClassSpec())
John McCall4d55f5a2011-03-26 02:09:52 +00002424 if (!DS.isExternInLinkageSpec())
2425 Diag(DS.getStorageClassSpecLoc(), diag::warn_standalone_specifier)
2426 << DeclSpec::getSpecifierName(scs);
2427
John McCallaa017372011-03-22 23:00:04 +00002428 if (DS.isThreadSpecified())
2429 Diag(DS.getThreadSpecLoc(), diag::warn_standalone_specifier) << "__thread";
2430 if (DS.getTypeQualifiers()) {
2431 if (DS.getTypeQualifiers() & DeclSpec::TQ_const)
2432 Diag(DS.getConstSpecLoc(), diag::warn_standalone_specifier) << "const";
2433 if (DS.getTypeQualifiers() & DeclSpec::TQ_volatile)
2434 Diag(DS.getConstSpecLoc(), diag::warn_standalone_specifier) << "volatile";
2435 // Restrict is covered above.
2436 }
2437 if (DS.isInlineSpecified())
2438 Diag(DS.getInlineSpecLoc(), diag::warn_standalone_specifier) << "inline";
2439 if (DS.isVirtualSpecified())
2440 Diag(DS.getVirtualSpecLoc(), diag::warn_standalone_specifier) << "virtual";
2441 if (DS.isExplicitSpecified())
2442 Diag(DS.getExplicitSpecLoc(), diag::warn_standalone_specifier) <<"explicit";
2443
Douglas Gregor41866812011-09-12 18:37:38 +00002444 if (DS.isModulePrivateSpecified() &&
2445 Tag && Tag->getDeclContext()->isFunctionOrMethod())
2446 Diag(DS.getModulePrivateSpecLoc(), diag::err_module_private_local_class)
2447 << Tag->getTagKind()
2448 << FixItHint::CreateRemoval(DS.getModulePrivateSpecLoc());
2449
John McCallaa017372011-03-22 23:00:04 +00002450 // FIXME: Warn on useless attributes
2451
John McCall48871652010-08-21 09:40:31 +00002452 return TagD;
Douglas Gregor9ac7a072009-01-07 00:43:41 +00002453}
2454
Fariborz Jahanian1db5c942010-09-28 20:42:35 +00002455/// ActOnVlaStmt - This rouine if finds a vla expression in a decl spec.
2456/// builds a statement for it and returns it so it is evaluated.
2457StmtResult Sema::ActOnVlaStmt(const DeclSpec &DS) {
2458 StmtResult R;
2459 if (DS.getTypeSpecType() == DeclSpec::TST_typeofExpr) {
2460 Expr *Exp = DS.getRepAsExpr();
2461 QualType Ty = Exp->getType();
2462 if (Ty->isPointerType()) {
2463 do
2464 Ty = Ty->getAs<PointerType>()->getPointeeType();
2465 while (Ty->isPointerType());
2466 }
2467 if (Ty->isVariableArrayType()) {
2468 R = ActOnExprStmt(MakeFullExpr(Exp));
2469 }
2470 }
2471 return R;
2472}
2473
John McCallea305ed2009-12-18 10:40:03 +00002474/// We are trying to inject an anonymous member into the given scope;
John McCall1f82f242009-11-18 22:49:29 +00002475/// check if there's an existing declaration that can't be overloaded.
2476///
2477/// \return true if this is a forbidden redeclaration
John McCallea305ed2009-12-18 10:40:03 +00002478static bool CheckAnonMemberRedeclaration(Sema &SemaRef,
2479 Scope *S,
Fariborz Jahanian53967e22010-01-22 18:30:17 +00002480 DeclContext *Owner,
John McCallea305ed2009-12-18 10:40:03 +00002481 DeclarationName Name,
2482 SourceLocation NameLoc,
2483 unsigned diagnostic) {
2484 LookupResult R(SemaRef, Name, NameLoc, Sema::LookupMemberName,
2485 Sema::ForRedeclaration);
2486 if (!SemaRef.LookupName(R, S)) return false;
John McCall1f82f242009-11-18 22:49:29 +00002487
John McCallea305ed2009-12-18 10:40:03 +00002488 if (R.getAsSingle<TagDecl>())
John McCall1f82f242009-11-18 22:49:29 +00002489 return false;
2490
2491 // Pick a representative declaration.
John McCallea305ed2009-12-18 10:40:03 +00002492 NamedDecl *PrevDecl = R.getRepresentativeDecl()->getUnderlyingDecl();
Argyrios Kyrtzidise619e992010-09-23 14:26:01 +00002493 assert(PrevDecl && "Expected a non-null Decl");
2494
2495 if (!SemaRef.isDeclInScope(PrevDecl, Owner, S))
2496 return false;
John McCall1f82f242009-11-18 22:49:29 +00002497
John McCallea305ed2009-12-18 10:40:03 +00002498 SemaRef.Diag(NameLoc, diagnostic) << Name;
2499 SemaRef.Diag(PrevDecl->getLocation(), diag::note_previous_declaration);
John McCall1f82f242009-11-18 22:49:29 +00002500
2501 return true;
2502}
2503
Douglas Gregor9ac7a072009-01-07 00:43:41 +00002504/// InjectAnonymousStructOrUnionMembers - Inject the members of the
2505/// anonymous struct or union AnonRecord into the owning context Owner
2506/// and scope S. This routine will be invoked just after we realize
2507/// that an unnamed union or struct is actually an anonymous union or
2508/// struct, e.g.,
2509///
2510/// @code
2511/// union {
2512/// int i;
2513/// float f;
2514/// }; // InjectAnonymousStructOrUnionMembers called here to inject i and
2515/// // f into the surrounding scope.x
2516/// @endcode
2517///
2518/// This routine is recursive, injecting the names of nested anonymous
2519/// structs/unions into the owning context and scope as well.
John McCallb54367d2010-05-21 20:45:30 +00002520static bool InjectAnonymousStructOrUnionMembers(Sema &SemaRef, Scope *S,
2521 DeclContext *Owner,
2522 RecordDecl *AnonRecord,
Francois Pichet783dd6e2010-11-21 06:08:52 +00002523 AccessSpecifier AS,
Chris Lattner0e62c1c2011-07-23 10:55:15 +00002524 SmallVector<NamedDecl*, 2> &Chaining,
Francois Pichet0c71f6c2010-11-23 06:07:27 +00002525 bool MSAnonStruct) {
John McCall1f82f242009-11-18 22:49:29 +00002526 unsigned diagKind
2527 = AnonRecord->isUnion() ? diag::err_anonymous_union_member_redecl
2528 : diag::err_anonymous_struct_member_redecl;
2529
Douglas Gregor9ac7a072009-01-07 00:43:41 +00002530 bool Invalid = false;
Francois Pichet0c71f6c2010-11-23 06:07:27 +00002531
2532 // Look every FieldDecl and IndirectFieldDecl with a name.
2533 for (RecordDecl::decl_iterator D = AnonRecord->decls_begin(),
2534 DEnd = AnonRecord->decls_end();
2535 D != DEnd; ++D) {
2536 if ((isa<FieldDecl>(*D) || isa<IndirectFieldDecl>(*D)) &&
2537 cast<NamedDecl>(*D)->getDeclName()) {
2538 ValueDecl *VD = cast<ValueDecl>(*D);
2539 if (CheckAnonMemberRedeclaration(SemaRef, S, Owner, VD->getDeclName(),
2540 VD->getLocation(), diagKind)) {
Douglas Gregor9ac7a072009-01-07 00:43:41 +00002541 // C++ [class.union]p2:
2542 // The names of the members of an anonymous union shall be
2543 // distinct from the names of any other entity in the
2544 // scope in which the anonymous union is declared.
Douglas Gregor9ac7a072009-01-07 00:43:41 +00002545 Invalid = true;
2546 } else {
2547 // C++ [class.union]p2:
2548 // For the purpose of name lookup, after the anonymous union
2549 // definition, the members of the anonymous union are
2550 // considered to have been defined in the scope in which the
2551 // anonymous union is declared.
Francois Pichet0c71f6c2010-11-23 06:07:27 +00002552 unsigned OldChainingSize = Chaining.size();
2553 if (IndirectFieldDecl *IF = dyn_cast<IndirectFieldDecl>(VD))
2554 for (IndirectFieldDecl::chain_iterator PI = IF->chain_begin(),
2555 PE = IF->chain_end(); PI != PE; ++PI)
2556 Chaining.push_back(*PI);
2557 else
2558 Chaining.push_back(VD);
2559
Francois Pichet783dd6e2010-11-21 06:08:52 +00002560 assert(Chaining.size() >= 2);
2561 NamedDecl **NamedChain =
2562 new (SemaRef.Context)NamedDecl*[Chaining.size()];
2563 for (unsigned i = 0; i < Chaining.size(); i++)
2564 NamedChain[i] = Chaining[i];
2565
2566 IndirectFieldDecl* IndirectField =
Francois Pichet0c71f6c2010-11-23 06:07:27 +00002567 IndirectFieldDecl::Create(SemaRef.Context, Owner, VD->getLocation(),
2568 VD->getIdentifier(), VD->getType(),
Francois Pichet783dd6e2010-11-21 06:08:52 +00002569 NamedChain, Chaining.size());
2570
2571 IndirectField->setAccess(AS);
2572 IndirectField->setImplicit();
2573 SemaRef.PushOnScopeChains(IndirectField, S);
John McCallb54367d2010-05-21 20:45:30 +00002574
2575 // That includes picking up the appropriate access specifier.
Francois Pichet0c71f6c2010-11-23 06:07:27 +00002576 if (AS != AS_none) IndirectField->setAccess(AS);
Francois Pichet783dd6e2010-11-21 06:08:52 +00002577
Francois Pichet0c71f6c2010-11-23 06:07:27 +00002578 Chaining.resize(OldChainingSize);
Douglas Gregor9ac7a072009-01-07 00:43:41 +00002579 }
Douglas Gregor9ac7a072009-01-07 00:43:41 +00002580 }
2581 }
2582
2583 return Invalid;
2584}
2585
Douglas Gregorc4df4072010-04-19 22:54:31 +00002586/// StorageClassSpecToVarDeclStorageClass - Maps a DeclSpec::SCS to
2587/// a VarDecl::StorageClass. Any error reporting is up to the caller:
John McCall8e7d6562010-08-26 03:08:43 +00002588/// illegal input values are mapped to SC_None.
2589static StorageClass
Abramo Bagnaraed5b6892010-07-30 16:47:02 +00002590StorageClassSpecToVarDeclStorageClass(DeclSpec::SCS StorageClassSpec) {
Douglas Gregorc4df4072010-04-19 22:54:31 +00002591 switch (StorageClassSpec) {
John McCall8e7d6562010-08-26 03:08:43 +00002592 case DeclSpec::SCS_unspecified: return SC_None;
2593 case DeclSpec::SCS_extern: return SC_Extern;
2594 case DeclSpec::SCS_static: return SC_Static;
2595 case DeclSpec::SCS_auto: return SC_Auto;
2596 case DeclSpec::SCS_register: return SC_Register;
2597 case DeclSpec::SCS_private_extern: return SC_PrivateExtern;
Douglas Gregorc4df4072010-04-19 22:54:31 +00002598 // Illegal SCSs map to None: error reporting is up to the caller.
2599 case DeclSpec::SCS_mutable: // Fall through.
John McCall8e7d6562010-08-26 03:08:43 +00002600 case DeclSpec::SCS_typedef: return SC_None;
Douglas Gregorc4df4072010-04-19 22:54:31 +00002601 }
2602 llvm_unreachable("unknown storage class specifier");
2603}
2604
2605/// StorageClassSpecToFunctionDeclStorageClass - Maps a DeclSpec::SCS to
John McCall8e7d6562010-08-26 03:08:43 +00002606/// a StorageClass. Any error reporting is up to the caller:
2607/// illegal input values are mapped to SC_None.
2608static StorageClass
Abramo Bagnaraed5b6892010-07-30 16:47:02 +00002609StorageClassSpecToFunctionDeclStorageClass(DeclSpec::SCS StorageClassSpec) {
Douglas Gregorc4df4072010-04-19 22:54:31 +00002610 switch (StorageClassSpec) {
John McCall8e7d6562010-08-26 03:08:43 +00002611 case DeclSpec::SCS_unspecified: return SC_None;
2612 case DeclSpec::SCS_extern: return SC_Extern;
2613 case DeclSpec::SCS_static: return SC_Static;
2614 case DeclSpec::SCS_private_extern: return SC_PrivateExtern;
Douglas Gregorc4df4072010-04-19 22:54:31 +00002615 // Illegal SCSs map to None: error reporting is up to the caller.
2616 case DeclSpec::SCS_auto: // Fall through.
2617 case DeclSpec::SCS_mutable: // Fall through.
2618 case DeclSpec::SCS_register: // Fall through.
John McCall8e7d6562010-08-26 03:08:43 +00002619 case DeclSpec::SCS_typedef: return SC_None;
Douglas Gregorc4df4072010-04-19 22:54:31 +00002620 }
2621 llvm_unreachable("unknown storage class specifier");
2622}
2623
Francois Pichet0c71f6c2010-11-23 06:07:27 +00002624/// BuildAnonymousStructOrUnion - Handle the declaration of an
Douglas Gregor9ac7a072009-01-07 00:43:41 +00002625/// anonymous structure or union. Anonymous unions are a C++ feature
2626/// (C++ [class.union]) and a GNU C extension; anonymous structures
Mike Stump11289f42009-09-09 15:08:12 +00002627/// are a GNU C and GNU C++ extension.
John McCall48871652010-08-21 09:40:31 +00002628Decl *Sema::BuildAnonymousStructOrUnion(Scope *S, DeclSpec &DS,
2629 AccessSpecifier AS,
2630 RecordDecl *Record) {
Douglas Gregor9ac7a072009-01-07 00:43:41 +00002631 DeclContext *Owner = Record->getDeclContext();
2632
2633 // Diagnose whether this anonymous struct/union is an extension.
2634 if (Record->isUnion() && !getLangOptions().CPlusPlus)
2635 Diag(Record->getLocation(), diag::ext_anonymous_union);
2636 else if (!Record->isUnion())
2637 Diag(Record->getLocation(), diag::ext_anonymous_struct);
Mike Stump11289f42009-09-09 15:08:12 +00002638
Douglas Gregor9ac7a072009-01-07 00:43:41 +00002639 // C and C++ require different kinds of checks for anonymous
2640 // structs/unions.
2641 bool Invalid = false;
2642 if (getLangOptions().CPlusPlus) {
2643 const char* PrevSpec = 0;
John McCall49bfce42009-08-03 20:12:06 +00002644 unsigned DiagID;
Douglas Gregor9ac7a072009-01-07 00:43:41 +00002645 // C++ [class.union]p3:
2646 // Anonymous unions declared in a named namespace or in the
2647 // global namespace shall be declared static.
2648 if (DS.getStorageClassSpec() != DeclSpec::SCS_static &&
2649 (isa<TranslationUnitDecl>(Owner) ||
Mike Stump11289f42009-09-09 15:08:12 +00002650 (isa<NamespaceDecl>(Owner) &&
Douglas Gregor9ac7a072009-01-07 00:43:41 +00002651 cast<NamespaceDecl>(Owner)->getDeclName()))) {
2652 Diag(Record->getLocation(), diag::err_anonymous_union_not_static);
2653 Invalid = true;
2654
2655 // Recover by adding 'static'.
Peter Collingbourne485b80f2011-10-06 03:01:00 +00002656 DS.SetStorageClassSpec(*this, DeclSpec::SCS_static, SourceLocation(),
2657 PrevSpec, DiagID);
Mike Stump11289f42009-09-09 15:08:12 +00002658 }
Douglas Gregor9ac7a072009-01-07 00:43:41 +00002659 // C++ [class.union]p3:
2660 // A storage class is not allowed in a declaration of an
2661 // anonymous union in a class scope.
2662 else if (DS.getStorageClassSpec() != DeclSpec::SCS_unspecified &&
2663 isa<RecordDecl>(Owner)) {
Mike Stump11289f42009-09-09 15:08:12 +00002664 Diag(DS.getStorageClassSpecLoc(),
Douglas Gregor9ac7a072009-01-07 00:43:41 +00002665 diag::err_anonymous_union_with_storage_spec);
2666 Invalid = true;
2667
2668 // Recover by removing the storage specifier.
Peter Collingbourne485b80f2011-10-06 03:01:00 +00002669 DS.SetStorageClassSpec(*this, DeclSpec::SCS_unspecified, SourceLocation(),
2670 PrevSpec, DiagID);
Douglas Gregor9ac7a072009-01-07 00:43:41 +00002671 }
Douglas Gregorf4d33272009-01-07 19:46:03 +00002672
Douglas Gregor0f8bc972011-05-09 23:05:33 +00002673 // Ignore const/volatile/restrict qualifiers.
2674 if (DS.getTypeQualifiers()) {
2675 if (DS.getTypeQualifiers() & DeclSpec::TQ_const)
2676 Diag(DS.getConstSpecLoc(), diag::ext_anonymous_struct_union_qualified)
2677 << Record->isUnion() << 0
2678 << FixItHint::CreateRemoval(DS.getConstSpecLoc());
2679 if (DS.getTypeQualifiers() & DeclSpec::TQ_volatile)
2680 Diag(DS.getVolatileSpecLoc(), diag::ext_anonymous_struct_union_qualified)
2681 << Record->isUnion() << 1
2682 << FixItHint::CreateRemoval(DS.getVolatileSpecLoc());
2683 if (DS.getTypeQualifiers() & DeclSpec::TQ_restrict)
2684 Diag(DS.getRestrictSpecLoc(), diag::ext_anonymous_struct_union_qualified)
2685 << Record->isUnion() << 2
2686 << FixItHint::CreateRemoval(DS.getRestrictSpecLoc());
2687
2688 DS.ClearTypeQualifiers();
2689 }
2690
Mike Stump11289f42009-09-09 15:08:12 +00002691 // C++ [class.union]p2:
Douglas Gregorf4d33272009-01-07 19:46:03 +00002692 // The member-specification of an anonymous union shall only
2693 // define non-static data members. [Note: nested types and
2694 // functions cannot be declared within an anonymous union. ]
Argyrios Kyrtzidiscfbfe782009-06-30 02:36:12 +00002695 for (DeclContext::decl_iterator Mem = Record->decls_begin(),
2696 MemEnd = Record->decls_end();
Douglas Gregorf4d33272009-01-07 19:46:03 +00002697 Mem != MemEnd; ++Mem) {
2698 if (FieldDecl *FD = dyn_cast<FieldDecl>(*Mem)) {
2699 // C++ [class.union]p3:
2700 // An anonymous union shall not have private or protected
2701 // members (clause 11).
John McCallb54367d2010-05-21 20:45:30 +00002702 assert(FD->getAccess() != AS_none);
2703 if (FD->getAccess() != AS_public) {
Douglas Gregorf4d33272009-01-07 19:46:03 +00002704 Diag(FD->getLocation(), diag::err_anonymous_record_nonpublic_member)
2705 << (int)Record->isUnion() << (int)(FD->getAccess() == AS_protected);
2706 Invalid = true;
2707 }
Argyrios Kyrtzidis33aee392010-08-16 17:27:08 +00002708
Alexis Hunt97ab5542011-05-16 22:41:40 +00002709 // C++ [class.union]p1
2710 // An object of a class with a non-trivial constructor, a non-trivial
2711 // copy constructor, a non-trivial destructor, or a non-trivial copy
2712 // assignment operator cannot be a member of a union, nor can an
2713 // array of such objects.
2714 if (!getLangOptions().CPlusPlus0x && CheckNontrivialField(FD))
Argyrios Kyrtzidis33aee392010-08-16 17:27:08 +00002715 Invalid = true;
Douglas Gregorf4d33272009-01-07 19:46:03 +00002716 } else if ((*Mem)->isImplicit()) {
2717 // Any implicit members are fine.
Douglas Gregor8761da52009-02-03 00:34:39 +00002718 } else if (isa<TagDecl>(*Mem) && (*Mem)->getDeclContext() != Record) {
2719 // This is a type that showed up in an
2720 // elaborated-type-specifier inside the anonymous struct or
2721 // union, but which actually declares a type outside of the
2722 // anonymous struct or union. It's okay.
Douglas Gregorf4d33272009-01-07 19:46:03 +00002723 } else if (RecordDecl *MemRecord = dyn_cast<RecordDecl>(*Mem)) {
2724 if (!MemRecord->isAnonymousStructOrUnion() &&
2725 MemRecord->getDeclName()) {
Francois Pichet4ad4b582010-09-08 11:32:25 +00002726 // Visual C++ allows type definition in anonymous struct or union.
Francois Pichet0706d202011-09-17 17:15:52 +00002727 if (getLangOptions().MicrosoftExt)
Francois Pichet4ad4b582010-09-08 11:32:25 +00002728 Diag(MemRecord->getLocation(), diag::ext_anonymous_record_with_type)
2729 << (int)Record->isUnion();
2730 else {
2731 // This is a nested type declaration.
2732 Diag(MemRecord->getLocation(), diag::err_anonymous_record_with_type)
2733 << (int)Record->isUnion();
2734 Invalid = true;
2735 }
Douglas Gregorf4d33272009-01-07 19:46:03 +00002736 }
Abramo Bagnarad7340582010-06-05 05:09:32 +00002737 } else if (isa<AccessSpecDecl>(*Mem)) {
2738 // Any access specifier is fine.
Douglas Gregorf4d33272009-01-07 19:46:03 +00002739 } else {
2740 // We have something that isn't a non-static data
2741 // member. Complain about it.
2742 unsigned DK = diag::err_anonymous_record_bad_member;
2743 if (isa<TypeDecl>(*Mem))
2744 DK = diag::err_anonymous_record_with_type;
2745 else if (isa<FunctionDecl>(*Mem))
2746 DK = diag::err_anonymous_record_with_function;
2747 else if (isa<VarDecl>(*Mem))
2748 DK = diag::err_anonymous_record_with_static;
Francois Pichet4ad4b582010-09-08 11:32:25 +00002749
2750 // Visual C++ allows type definition in anonymous struct or union.
Francois Pichet0706d202011-09-17 17:15:52 +00002751 if (getLangOptions().MicrosoftExt &&
Francois Pichet4ad4b582010-09-08 11:32:25 +00002752 DK == diag::err_anonymous_record_with_type)
2753 Diag((*Mem)->getLocation(), diag::ext_anonymous_record_with_type)
Douglas Gregorf4d33272009-01-07 19:46:03 +00002754 << (int)Record->isUnion();
Francois Pichet4ad4b582010-09-08 11:32:25 +00002755 else {
2756 Diag((*Mem)->getLocation(), DK)
2757 << (int)Record->isUnion();
Douglas Gregorf4d33272009-01-07 19:46:03 +00002758 Invalid = true;
Francois Pichet4ad4b582010-09-08 11:32:25 +00002759 }
Douglas Gregorf4d33272009-01-07 19:46:03 +00002760 }
2761 }
Mike Stump11289f42009-09-09 15:08:12 +00002762 }
Douglas Gregor9ac7a072009-01-07 00:43:41 +00002763
2764 if (!Record->isUnion() && !Owner->isRecord()) {
Douglas Gregorc6f58fe2009-01-12 22:49:06 +00002765 Diag(Record->getLocation(), diag::err_anonymous_struct_not_member)
2766 << (int)getLangOptions().CPlusPlus;
Douglas Gregor9ac7a072009-01-07 00:43:41 +00002767 Invalid = true;
2768 }
2769
John McCallfa2d6922009-10-22 23:31:08 +00002770 // Mock up a declarator.
Argyrios Kyrtzidis7baa0af2011-06-28 03:01:18 +00002771 Declarator Dc(DS, Declarator::MemberContext);
John McCall8cb7bdf2010-06-04 23:28:52 +00002772 TypeSourceInfo *TInfo = GetTypeForDeclarator(Dc, S);
John McCallbcd03502009-12-07 02:54:59 +00002773 assert(TInfo && "couldn't build declarator info for anonymous struct/union");
John McCallfa2d6922009-10-22 23:31:08 +00002774
Mike Stump11289f42009-09-09 15:08:12 +00002775 // Create a declaration for this anonymous struct/union.
Douglas Gregor6e6ad602009-01-20 01:17:11 +00002776 NamedDecl *Anon = 0;
Douglas Gregor9ac7a072009-01-07 00:43:41 +00002777 if (RecordDecl *OwningClass = dyn_cast<RecordDecl>(Owner)) {
Abramo Bagnaradff19302011-03-08 08:55:46 +00002778 Anon = FieldDecl::Create(Context, OwningClass,
2779 DS.getSourceRange().getBegin(),
2780 Record->getLocation(),
Mike Stump11289f42009-09-09 15:08:12 +00002781 /*IdentifierInfo=*/0,
Argyrios Kyrtzidis6032ef12009-08-21 00:31:54 +00002782 Context.getTypeDeclType(Record),
John McCallbcd03502009-12-07 02:54:59 +00002783 TInfo,
Richard Smith938f40b2011-06-11 17:19:42 +00002784 /*BitWidth=*/0, /*Mutable=*/false,
2785 /*HasInit=*/false);
John McCallb54367d2010-05-21 20:45:30 +00002786 Anon->setAccess(AS);
Douglas Gregor9d5938a2010-09-28 20:38:10 +00002787 if (getLangOptions().CPlusPlus)
Douglas Gregorf4d33272009-01-07 19:46:03 +00002788 FieldCollector->Add(cast<FieldDecl>(Anon));
Douglas Gregor9ac7a072009-01-07 00:43:41 +00002789 } else {
Douglas Gregorc4df4072010-04-19 22:54:31 +00002790 DeclSpec::SCS SCSpec = DS.getStorageClassSpec();
2791 assert(SCSpec != DeclSpec::SCS_typedef &&
2792 "Parser allowed 'typedef' as storage class VarDecl.");
Abramo Bagnaraed5b6892010-07-30 16:47:02 +00002793 VarDecl::StorageClass SC = StorageClassSpecToVarDeclStorageClass(SCSpec);
Douglas Gregorc4df4072010-04-19 22:54:31 +00002794 if (SCSpec == DeclSpec::SCS_mutable) {
Douglas Gregor9ac7a072009-01-07 00:43:41 +00002795 // mutable can only appear on non-static class members, so it's always
2796 // an error here
2797 Diag(Record->getLocation(), diag::err_mutable_nonmember);
2798 Invalid = true;
John McCall8e7d6562010-08-26 03:08:43 +00002799 SC = SC_None;
Douglas Gregor9ac7a072009-01-07 00:43:41 +00002800 }
Douglas Gregorc4df4072010-04-19 22:54:31 +00002801 SCSpec = DS.getStorageClassSpecAsWritten();
2802 VarDecl::StorageClass SCAsWritten
Abramo Bagnaraed5b6892010-07-30 16:47:02 +00002803 = StorageClassSpecToVarDeclStorageClass(SCSpec);
Douglas Gregor9ac7a072009-01-07 00:43:41 +00002804
Abramo Bagnaradff19302011-03-08 08:55:46 +00002805 Anon = VarDecl::Create(Context, Owner,
2806 DS.getSourceRange().getBegin(),
2807 Record->getLocation(), /*IdentifierInfo=*/0,
Argyrios Kyrtzidis6032ef12009-08-21 00:31:54 +00002808 Context.getTypeDeclType(Record),
Douglas Gregorc4df4072010-04-19 22:54:31 +00002809 TInfo, SC, SCAsWritten);
Richard Smith40372352011-09-18 00:06:34 +00002810
2811 // Default-initialize the implicit variable. This initialization will be
2812 // trivial in almost all cases, except if a union member has an in-class
2813 // initializer:
2814 // union { int n = 0; };
2815 ActOnUninitializedDecl(Anon, /*TypeMayContainAuto=*/false);
Douglas Gregor9ac7a072009-01-07 00:43:41 +00002816 }
Douglas Gregorf4d33272009-01-07 19:46:03 +00002817 Anon->setImplicit();
Douglas Gregor9ac7a072009-01-07 00:43:41 +00002818
2819 // Add the anonymous struct/union object to the current
2820 // context. We'll be referencing this object when we refer to one of
2821 // its members.
Argyrios Kyrtzidiscfbfe782009-06-30 02:36:12 +00002822 Owner->addDecl(Anon);
Douglas Gregor456ad1a2010-05-03 15:18:25 +00002823
Douglas Gregor9ac7a072009-01-07 00:43:41 +00002824 // Inject the members of the anonymous struct/union into the owning
2825 // context and into the identifier resolver chain for name lookup
2826 // purposes.
Chris Lattner0e62c1c2011-07-23 10:55:15 +00002827 SmallVector<NamedDecl*, 2> Chain;
Francois Pichet783dd6e2010-11-21 06:08:52 +00002828 Chain.push_back(Anon);
2829
Francois Pichet0c71f6c2010-11-23 06:07:27 +00002830 if (InjectAnonymousStructOrUnionMembers(*this, S, Owner, Record, AS,
2831 Chain, false))
Douglas Gregorc6f58fe2009-01-12 22:49:06 +00002832 Invalid = true;
Douglas Gregor9ac7a072009-01-07 00:43:41 +00002833
2834 // Mark this as an anonymous struct/union type. Note that we do not
2835 // do this until after we have already checked and injected the
2836 // members of this anonymous struct/union type, because otherwise
2837 // the members could be injected twice: once by DeclContext when it
2838 // builds its lookup table, and once by
Mike Stump11289f42009-09-09 15:08:12 +00002839 // InjectAnonymousStructOrUnionMembers.
Douglas Gregor9ac7a072009-01-07 00:43:41 +00002840 Record->setAnonymousStructOrUnion(true);
2841
2842 if (Invalid)
2843 Anon->setInvalidDecl();
2844
John McCall48871652010-08-21 09:40:31 +00002845 return Anon;
Chris Lattnerb6738ec2007-01-28 00:38:24 +00002846}
2847
Francois Pichet0c71f6c2010-11-23 06:07:27 +00002848/// BuildMicrosoftCAnonymousStruct - Handle the declaration of an
2849/// Microsoft C anonymous structure.
2850/// Ref: http://msdn.microsoft.com/en-us/library/z2cx9y4f.aspx
2851/// Example:
2852///
2853/// struct A { int a; };
2854/// struct B { struct A; int b; };
2855///
2856/// void foo() {
2857/// B var;
2858/// var.a = 3;
2859/// }
2860///
2861Decl *Sema::BuildMicrosoftCAnonymousStruct(Scope *S, DeclSpec &DS,
2862 RecordDecl *Record) {
2863
2864 // If there is no Record, get the record via the typedef.
2865 if (!Record)
2866 Record = DS.getRepAsType().get()->getAsStructureType()->getDecl();
2867
2868 // Mock up a declarator.
2869 Declarator Dc(DS, Declarator::TypeNameContext);
2870 TypeSourceInfo *TInfo = GetTypeForDeclarator(Dc, S);
2871 assert(TInfo && "couldn't build declarator info for anonymous struct");
2872
2873 // Create a declaration for this anonymous struct.
2874 NamedDecl* Anon = FieldDecl::Create(Context,
2875 cast<RecordDecl>(CurContext),
2876 DS.getSourceRange().getBegin(),
Abramo Bagnaradff19302011-03-08 08:55:46 +00002877 DS.getSourceRange().getBegin(),
Francois Pichet0c71f6c2010-11-23 06:07:27 +00002878 /*IdentifierInfo=*/0,
2879 Context.getTypeDeclType(Record),
2880 TInfo,
Richard Smith938f40b2011-06-11 17:19:42 +00002881 /*BitWidth=*/0, /*Mutable=*/false,
2882 /*HasInit=*/false);
Francois Pichet0c71f6c2010-11-23 06:07:27 +00002883 Anon->setImplicit();
2884
2885 // Add the anonymous struct object to the current context.
2886 CurContext->addDecl(Anon);
2887
2888 // Inject the members of the anonymous struct into the current
2889 // context and into the identifier resolver chain for name lookup
2890 // purposes.
Chris Lattner0e62c1c2011-07-23 10:55:15 +00002891 SmallVector<NamedDecl*, 2> Chain;
Francois Pichet0c71f6c2010-11-23 06:07:27 +00002892 Chain.push_back(Anon);
2893
2894 if (InjectAnonymousStructOrUnionMembers(*this, S, CurContext,
2895 Record->getDefinition(),
2896 AS_none, Chain, true))
2897 Anon->setInvalidDecl();
2898
2899 return Anon;
2900}
Steve Naroff2fea1392007-09-02 02:04:30 +00002901
Douglas Gregor92751d42008-11-17 22:58:34 +00002902/// GetNameForDeclarator - Determine the full declaration name for the
2903/// given Declarator.
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00002904DeclarationNameInfo Sema::GetNameForDeclarator(Declarator &D) {
Douglas Gregora121b752009-11-03 16:56:39 +00002905 return GetNameFromUnqualifiedId(D.getName());
2906}
2907
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00002908/// \brief Retrieves the declaration name from a parsed unqualified-id.
2909DeclarationNameInfo
2910Sema::GetNameFromUnqualifiedId(const UnqualifiedId &Name) {
2911 DeclarationNameInfo NameInfo;
2912 NameInfo.setLoc(Name.StartLocation);
2913
Douglas Gregor7861a802009-11-03 01:35:08 +00002914 switch (Name.getKind()) {
Alexis Hunt34458502009-11-28 04:44:28 +00002915
Fariborz Jahanian7f4427f2011-07-12 17:16:56 +00002916 case UnqualifiedId::IK_ImplicitSelfParam:
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00002917 case UnqualifiedId::IK_Identifier:
2918 NameInfo.setName(Name.Identifier);
2919 NameInfo.setLoc(Name.StartLocation);
2920 return NameInfo;
Alexis Hunt34458502009-11-28 04:44:28 +00002921
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00002922 case UnqualifiedId::IK_OperatorFunctionId:
2923 NameInfo.setName(Context.DeclarationNames.getCXXOperatorName(
2924 Name.OperatorFunctionId.Operator));
2925 NameInfo.setLoc(Name.StartLocation);
2926 NameInfo.getInfo().CXXOperatorName.BeginOpNameLoc
2927 = Name.OperatorFunctionId.SymbolLocations[0];
2928 NameInfo.getInfo().CXXOperatorName.EndOpNameLoc
2929 = Name.EndLocation.getRawEncoding();
2930 return NameInfo;
Douglas Gregor9de54ea2010-01-13 17:31:36 +00002931
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00002932 case UnqualifiedId::IK_LiteralOperatorId:
2933 NameInfo.setName(Context.DeclarationNames.getCXXLiteralOperatorName(
2934 Name.Identifier));
2935 NameInfo.setLoc(Name.StartLocation);
2936 NameInfo.setCXXLiteralOperatorNameLoc(Name.EndLocation);
2937 return NameInfo;
Douglas Gregor9de54ea2010-01-13 17:31:36 +00002938
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00002939 case UnqualifiedId::IK_ConversionFunctionId: {
2940 TypeSourceInfo *TInfo;
2941 QualType Ty = GetTypeFromParser(Name.ConversionFunctionId, &TInfo);
2942 if (Ty.isNull())
2943 return DeclarationNameInfo();
2944 NameInfo.setName(Context.DeclarationNames.getCXXConversionFunctionName(
2945 Context.getCanonicalType(Ty)));
2946 NameInfo.setLoc(Name.StartLocation);
2947 NameInfo.setNamedTypeInfo(TInfo);
2948 return NameInfo;
Douglas Gregord90fd522009-09-25 21:45:23 +00002949 }
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00002950
2951 case UnqualifiedId::IK_ConstructorName: {
2952 TypeSourceInfo *TInfo;
2953 QualType Ty = GetTypeFromParser(Name.ConstructorName, &TInfo);
2954 if (Ty.isNull())
2955 return DeclarationNameInfo();
2956 NameInfo.setName(Context.DeclarationNames.getCXXConstructorName(
2957 Context.getCanonicalType(Ty)));
2958 NameInfo.setLoc(Name.StartLocation);
2959 NameInfo.setNamedTypeInfo(TInfo);
2960 return NameInfo;
2961 }
2962
2963 case UnqualifiedId::IK_ConstructorTemplateId: {
2964 // In well-formed code, we can only have a constructor
2965 // template-id that refers to the current context, so go there
2966 // to find the actual type being constructed.
2967 CXXRecordDecl *CurClass = dyn_cast<CXXRecordDecl>(CurContext);
2968 if (!CurClass || CurClass->getIdentifier() != Name.TemplateId->Name)
2969 return DeclarationNameInfo();
2970
2971 // Determine the type of the class being constructed.
2972 QualType CurClassType = Context.getTypeDeclType(CurClass);
2973
2974 // FIXME: Check two things: that the template-id names the same type as
2975 // CurClassType, and that the template-id does not occur when the name
2976 // was qualified.
2977
2978 NameInfo.setName(Context.DeclarationNames.getCXXConstructorName(
2979 Context.getCanonicalType(CurClassType)));
2980 NameInfo.setLoc(Name.StartLocation);
2981 // FIXME: should we retrieve TypeSourceInfo?
2982 NameInfo.setNamedTypeInfo(0);
2983 return NameInfo;
2984 }
2985
2986 case UnqualifiedId::IK_DestructorName: {
2987 TypeSourceInfo *TInfo;
2988 QualType Ty = GetTypeFromParser(Name.DestructorName, &TInfo);
2989 if (Ty.isNull())
2990 return DeclarationNameInfo();
2991 NameInfo.setName(Context.DeclarationNames.getCXXDestructorName(
2992 Context.getCanonicalType(Ty)));
2993 NameInfo.setLoc(Name.StartLocation);
2994 NameInfo.setNamedTypeInfo(TInfo);
2995 return NameInfo;
2996 }
2997
2998 case UnqualifiedId::IK_TemplateId: {
John McCall3e56fd42010-08-23 07:28:44 +00002999 TemplateName TName = Name.TemplateId->Template.get();
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00003000 SourceLocation TNameLoc = Name.TemplateId->TemplateNameLoc;
3001 return Context.getNameForTemplate(TName, TNameLoc);
3002 }
3003
3004 } // switch (Name.getKind())
3005
David Blaikie83d382b2011-09-23 05:06:16 +00003006 llvm_unreachable("Unknown name kind");
Douglas Gregor92751d42008-11-17 22:58:34 +00003007}
3008
Kaelyn Uhrain7d9bc632011-08-04 17:40:00 +00003009static QualType getCoreType(QualType Ty) {
3010 do {
3011 if (Ty->isPointerType() || Ty->isReferenceType())
3012 Ty = Ty->getPointeeType();
3013 else if (Ty->isArrayType())
3014 Ty = Ty->castAsArrayTypeUnsafe()->getElementType();
3015 else
3016 return Ty.withoutLocalFastQualifiers();
3017 } while (true);
3018}
3019
Kaelyn Uhrain0a32fca2011-10-11 00:28:39 +00003020/// hasSimilarParameters - Determine whether the C++ functions Declaration
3021/// and Definition have "nearly" matching parameters. This heuristic is
3022/// used to improve diagnostics in the case where an out-of-line function
3023/// definition doesn't match any declaration within the class or namespace.
3024/// Also sets Params to the list of indices to the parameters that differ
3025/// between the declaration and the definition. If hasSimilarParameters
3026/// returns true and Params is empty, then all of the parameters match.
3027static bool hasSimilarParameters(ASTContext &Context,
Douglas Gregor8af63e42009-02-06 17:46:57 +00003028 FunctionDecl *Declaration,
Kaelyn Uhrain7d9bc632011-08-04 17:40:00 +00003029 FunctionDecl *Definition,
3030 llvm::SmallVectorImpl<unsigned> &Params) {
3031 Params.clear();
Douglas Gregorad590502008-12-15 23:53:10 +00003032 if (Declaration->param_size() != Definition->param_size())
3033 return false;
3034 for (unsigned Idx = 0; Idx < Declaration->param_size(); ++Idx) {
3035 QualType DeclParamTy = Declaration->getParamDecl(Idx)->getType();
3036 QualType DefParamTy = Definition->getParamDecl(Idx)->getType();
3037
Kaelyn Uhrain7d9bc632011-08-04 17:40:00 +00003038 // The parameter types are identical
Matt Beaumont-Gay56381b82011-08-23 01:35:51 +00003039 if (Context.hasSameType(DefParamTy, DeclParamTy))
Kaelyn Uhrain7d9bc632011-08-04 17:40:00 +00003040 continue;
3041
3042 QualType DeclParamBaseTy = getCoreType(DeclParamTy);
3043 QualType DefParamBaseTy = getCoreType(DefParamTy);
3044 const IdentifierInfo *DeclTyName = DeclParamBaseTy.getBaseTypeIdentifier();
3045 const IdentifierInfo *DefTyName = DefParamBaseTy.getBaseTypeIdentifier();
3046
3047 if (Context.hasSameUnqualifiedType(DeclParamBaseTy, DefParamBaseTy) ||
3048 (DeclTyName && DeclTyName == DefTyName))
3049 Params.push_back(Idx);
3050 else // The two parameters aren't even close
Douglas Gregorad590502008-12-15 23:53:10 +00003051 return false;
3052 }
3053
3054 return true;
3055}
3056
John McCall99b2fe52010-04-29 23:50:39 +00003057/// NeedsRebuildingInCurrentInstantiation - Checks whether the given
3058/// declarator needs to be rebuilt in the current instantiation.
3059/// Any bits of declarator which appear before the name are valid for
3060/// consideration here. That's specifically the type in the decl spec
3061/// and the base type in any member-pointer chunks.
3062static bool RebuildDeclaratorInCurrentInstantiation(Sema &S, Declarator &D,
3063 DeclarationName Name) {
3064 // The types we specifically need to rebuild are:
3065 // - typenames, typeofs, and decltypes
3066 // - types which will become injected class names
3067 // Of course, we also need to rebuild any type referencing such a
3068 // type. It's safest to just say "dependent", but we call out a
3069 // few cases here.
3070
3071 DeclSpec &DS = D.getMutableDeclSpec();
3072 switch (DS.getTypeSpecType()) {
3073 case DeclSpec::TST_typename:
3074 case DeclSpec::TST_typeofType:
Alexis Hunt4a257072011-05-19 05:37:45 +00003075 case DeclSpec::TST_decltype:
Eli Friedman0dfb8892011-10-06 23:00:33 +00003076 case DeclSpec::TST_underlyingType:
3077 case DeclSpec::TST_atomic: {
John McCall99b2fe52010-04-29 23:50:39 +00003078 // Grab the type from the parser.
3079 TypeSourceInfo *TSI = 0;
John McCallba7bf592010-08-24 05:47:05 +00003080 QualType T = S.GetTypeFromParser(DS.getRepAsType(), &TSI);
John McCall99b2fe52010-04-29 23:50:39 +00003081 if (T.isNull() || !T->isDependentType()) break;
3082
3083 // Make sure there's a type source info. This isn't really much
3084 // of a waste; most dependent types should have type source info
3085 // attached already.
3086 if (!TSI)
3087 TSI = S.Context.getTrivialTypeSourceInfo(T, DS.getTypeSpecTypeLoc());
3088
3089 // Rebuild the type in the current instantiation.
3090 TSI = S.RebuildTypeInCurrentInstantiation(TSI, D.getIdentifierLoc(), Name);
3091 if (!TSI) return true;
3092
3093 // Store the new type back in the decl spec.
John McCallba7bf592010-08-24 05:47:05 +00003094 ParsedType LocType = S.CreateParsedType(TSI->getType(), TSI);
3095 DS.UpdateTypeRep(LocType);
3096 break;
3097 }
3098
3099 case DeclSpec::TST_typeofExpr: {
3100 Expr *E = DS.getRepAsExpr();
John McCalldadc5752010-08-24 06:29:42 +00003101 ExprResult Result = S.RebuildExprInCurrentInstantiation(E);
John McCallba7bf592010-08-24 05:47:05 +00003102 if (Result.isInvalid()) return true;
3103 DS.UpdateExprRep(Result.get());
John McCall99b2fe52010-04-29 23:50:39 +00003104 break;
3105 }
3106
3107 default:
3108 // Nothing to do for these decl specs.
3109 break;
3110 }
3111
3112 // It doesn't matter what order we do this in.
3113 for (unsigned I = 0, E = D.getNumTypeObjects(); I != E; ++I) {
3114 DeclaratorChunk &Chunk = D.getTypeObject(I);
3115
3116 // The only type information in the declarator which can come
3117 // before the declaration name is the base type of a member
3118 // pointer.
3119 if (Chunk.Kind != DeclaratorChunk::MemberPointer)
3120 continue;
3121
3122 // Rebuild the scope specifier in-place.
3123 CXXScopeSpec &SS = Chunk.Mem.Scope();
3124 if (S.RebuildNestedNameSpecifierInCurrentInstantiation(SS))
3125 return true;
3126 }
3127
3128 return false;
3129}
3130
Anders Carlsson1052fd72011-07-04 16:28:17 +00003131Decl *Sema::ActOnDeclarator(Scope *S, Declarator &D) {
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00003132 D.setFunctionDefinition(false);
3133 return HandleDeclarator(S, D, MultiTemplateParamsArg(*this));
John McCallde6836a2010-08-24 07:21:54 +00003134}
3135
Richard Smithdda56e42011-04-15 14:24:37 +00003136/// DiagnoseClassNameShadow - Implement C++ [class.mem]p13:
3137/// If T is the name of a class, then each of the following shall have a
3138/// name different from T:
3139/// - every static data member of class T;
3140/// - every member function of class T
3141/// - every member of class T that is itself a type;
3142/// \returns true if the declaration name violates these rules.
3143bool Sema::DiagnoseClassNameShadow(DeclContext *DC,
3144 DeclarationNameInfo NameInfo) {
3145 DeclarationName Name = NameInfo.getName();
3146
3147 if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(DC))
3148 if (Record->getIdentifier() && Record->getDeclName() == Name) {
3149 Diag(NameInfo.getLoc(), diag::err_member_name_of_class) << Name;
3150 return true;
3151 }
3152
3153 return false;
3154}
3155
John McCall48871652010-08-21 09:40:31 +00003156Decl *Sema::HandleDeclarator(Scope *S, Declarator &D,
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00003157 MultiTemplateParamsArg TemplateParamLists) {
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00003158 // TODO: consider using NameInfo for diagnostic.
3159 DeclarationNameInfo NameInfo = GetNameForDeclarator(D);
3160 DeclarationName Name = NameInfo.getName();
Douglas Gregor92751d42008-11-17 22:58:34 +00003161
Chris Lattner02c04392007-07-25 00:24:17 +00003162 // All of these full declarators require an identifier. If it doesn't have
3163 // one, the ParsedFreeStandingDeclSpec action should be used.
Douglas Gregor92751d42008-11-17 22:58:34 +00003164 if (!Name) {
Chris Lattnerf6d1c9c2009-04-25 08:06:05 +00003165 if (!D.isInvalidType()) // Reject this if we think it is valid.
Chris Lattner8c5dd732008-11-11 06:13:16 +00003166 Diag(D.getDeclSpec().getSourceRange().getBegin(),
Chris Lattner3b054132008-11-19 05:08:23 +00003167 diag::err_declarator_need_ident)
3168 << D.getDeclSpec().getSourceRange() << D.getSourceRange();
John McCall48871652010-08-21 09:40:31 +00003169 return 0;
Douglas Gregorc4356532010-12-16 00:46:58 +00003170 } else if (DiagnoseUnexpandedParameterPack(NameInfo, UPPC_DeclarationType))
3171 return 0;
Mike Stump11289f42009-09-09 15:08:12 +00003172
Chris Lattner1a76a3c2007-08-26 06:24:45 +00003173 // The scope passed in may not be a decl scope. Zip up the scope tree until
3174 // we find one that is.
Douglas Gregor91f84212008-12-11 16:49:14 +00003175 while ((S->getFlags() & Scope::DeclScope) == 0 ||
Douglas Gregorded2d7b2009-02-04 19:02:06 +00003176 (S->getFlags() & Scope::TemplateParamScope) != 0)
Chris Lattner1a76a3c2007-08-26 06:24:45 +00003177 S = S->getParent();
Mike Stump11289f42009-09-09 15:08:12 +00003178
John McCall99b2fe52010-04-29 23:50:39 +00003179 DeclContext *DC = CurContext;
3180 if (D.getCXXScopeSpec().isInvalid())
3181 D.setInvalidType();
3182 else if (D.getCXXScopeSpec().isSet()) {
Douglas Gregor6c110f32010-12-16 01:14:37 +00003183 if (DiagnoseUnexpandedParameterPack(D.getCXXScopeSpec(),
3184 UPPC_DeclarationQualifier))
3185 return 0;
3186
John McCall99b2fe52010-04-29 23:50:39 +00003187 bool EnteringContext = !D.getDeclSpec().isFriendSpecified();
3188 DC = computeDeclContext(D.getCXXScopeSpec(), EnteringContext);
3189 if (!DC) {
3190 // If we could not compute the declaration context, it's because the
3191 // declaration context is dependent but does not refer to a class,
3192 // class template, or class template partial specialization. Complain
3193 // and return early, to avoid the coming semantic disaster.
3194 Diag(D.getIdentifierLoc(),
3195 diag::err_template_qualified_declarator_no_match)
3196 << (NestedNameSpecifier*)D.getCXXScopeSpec().getScopeRep()
3197 << D.getCXXScopeSpec().getRange();
John McCall48871652010-08-21 09:40:31 +00003198 return 0;
John McCall99b2fe52010-04-29 23:50:39 +00003199 }
John McCall99b2fe52010-04-29 23:50:39 +00003200 bool IsDependentContext = DC->isDependentContext();
John McCall4d6d6132009-12-19 09:35:56 +00003201
John McCall99b2fe52010-04-29 23:50:39 +00003202 if (!IsDependentContext &&
John McCall0b66eb32010-05-01 00:40:08 +00003203 RequireCompleteDeclContext(D.getCXXScopeSpec(), DC))
John McCall48871652010-08-21 09:40:31 +00003204 return 0;
John McCall99b2fe52010-04-29 23:50:39 +00003205
Douglas Gregora007d362010-10-13 22:19:53 +00003206 if (isa<CXXRecordDecl>(DC)) {
3207 if (!cast<CXXRecordDecl>(DC)->hasDefinition()) {
3208 Diag(D.getIdentifierLoc(),
3209 diag::err_member_def_undefined_record)
3210 << Name << DC << D.getCXXScopeSpec().getRange();
3211 D.setInvalidType();
3212 } else if (isa<CXXRecordDecl>(CurContext) &&
3213 !D.getDeclSpec().isFriendSpecified()) {
3214 // The user provided a superfluous scope specifier inside a class
3215 // definition:
3216 //
3217 // class X {
3218 // void X::f();
3219 // };
3220 if (CurContext->Equals(DC))
3221 Diag(D.getIdentifierLoc(), diag::warn_member_extra_qualification)
3222 << Name << FixItHint::CreateRemoval(D.getCXXScopeSpec().getRange());
3223 else
3224 Diag(D.getIdentifierLoc(), diag::err_member_qualification)
3225 << Name << D.getCXXScopeSpec().getRange();
3226
3227 // Pretend that this qualifier was not here.
3228 D.getCXXScopeSpec().clear();
3229 }
John McCall99b2fe52010-04-29 23:50:39 +00003230 }
3231
3232 // Check whether we need to rebuild the type of the given
3233 // declaration in the current instantiation.
3234 if (EnteringContext && IsDependentContext &&
3235 TemplateParamLists.size() != 0) {
3236 ContextRAII SavedContext(*this, DC);
3237 if (RebuildDeclaratorInCurrentInstantiation(*this, D, Name))
3238 D.setInvalidType();
Douglas Gregor15acfb92009-08-06 16:20:37 +00003239 }
3240 }
Richard Smithdda56e42011-04-15 14:24:37 +00003241
3242 if (DiagnoseClassNameShadow(DC, NameInfo))
3243 // If this is a typedef, we'll end up spewing multiple diagnostics.
3244 // Just return early; it's safer.
3245 if (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_typedef)
3246 return 0;
Douglas Gregor36c22a22010-10-15 13:21:21 +00003247
Douglas Gregor6e6ad602009-01-20 01:17:11 +00003248 NamedDecl *New;
Douglas Gregor75a45ba2009-02-16 17:45:42 +00003249
John McCall8cb7bdf2010-06-04 23:28:52 +00003250 TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S);
3251 QualType R = TInfo->getType();
Douglas Gregoreddf4332009-02-24 20:03:32 +00003252
Douglas Gregor506bd562010-12-13 22:49:22 +00003253 if (DiagnoseUnexpandedParameterPack(D.getIdentifierLoc(), TInfo,
3254 UPPC_DeclarationType))
3255 D.setInvalidType();
3256
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00003257 LookupResult Previous(*this, NameInfo, LookupOrdinaryName,
John McCall1f82f242009-11-18 22:49:29 +00003258 ForRedeclaration);
3259
Argyrios Kyrtzidis16ac9be2008-11-08 17:17:31 +00003260 // See if this is a redefinition of a variable in the same scope.
John McCall99b2fe52010-04-29 23:50:39 +00003261 if (!D.getCXXScopeSpec().isSet()) {
John McCall1f82f242009-11-18 22:49:29 +00003262 bool IsLinkageLookup = false;
Douglas Gregoreddf4332009-02-24 20:03:32 +00003263
3264 // If the declaration we're planning to build will be a function
3265 // or object with linkage, then look for another declaration with
3266 // linkage (C99 6.2.2p4-5 and C++ [basic.link]p6).
3267 if (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_typedef)
3268 /* Do nothing*/;
3269 else if (R->isFunctionType()) {
Douglas Gregor20749772009-07-07 17:00:05 +00003270 if (CurContext->isFunctionOrMethod() ||
3271 D.getDeclSpec().getStorageClassSpec() != DeclSpec::SCS_static)
John McCall1f82f242009-11-18 22:49:29 +00003272 IsLinkageLookup = true;
Douglas Gregoreddf4332009-02-24 20:03:32 +00003273 } else if (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_extern)
John McCall1f82f242009-11-18 22:49:29 +00003274 IsLinkageLookup = true;
Sebastian Redl50c68252010-08-31 00:36:30 +00003275 else if (CurContext->getRedeclContext()->isTranslationUnit() &&
Douglas Gregor20749772009-07-07 17:00:05 +00003276 D.getDeclSpec().getStorageClassSpec() != DeclSpec::SCS_static)
John McCall1f82f242009-11-18 22:49:29 +00003277 IsLinkageLookup = true;
3278
3279 if (IsLinkageLookup)
3280 Previous.clear(LookupRedeclarationWithLinkage);
Douglas Gregoreddf4332009-02-24 20:03:32 +00003281
John McCall1f82f242009-11-18 22:49:29 +00003282 LookupName(Previous, S, /* CreateBuiltins = */ IsLinkageLookup);
Argyrios Kyrtzidis16ac9be2008-11-08 17:17:31 +00003283 } else { // Something like "int foo::x;"
John McCall1f82f242009-11-18 22:49:29 +00003284 LookupQualifiedName(Previous, DC);
3285
3286 // Don't consider using declarations as previous declarations for
3287 // out-of-line members.
3288 RemoveUsingDecls(Previous);
Argyrios Kyrtzidis16ac9be2008-11-08 17:17:31 +00003289
3290 // C++ 7.3.1.2p2:
3291 // Members (including explicit specializations of templates) of a named
3292 // namespace can also be defined outside that namespace by explicit
3293 // qualification of the name being defined, provided that the entity being
3294 // defined was already declared in the namespace and the definition appears
3295 // after the point of declaration in a namespace that encloses the
3296 // declarations namespace.
3297 //
Douglas Gregorad590502008-12-15 23:53:10 +00003298 // Note that we only check the context at this point. We don't yet
3299 // have enough information to make sure that PrevDecl is actually
3300 // the declaration we want to match. For example, given:
3301 //
Douglas Gregor4287b372008-12-12 08:25:50 +00003302 // class X {
3303 // void f();
Douglas Gregorad590502008-12-15 23:53:10 +00003304 // void f(float);
Douglas Gregor4287b372008-12-12 08:25:50 +00003305 // };
3306 //
Douglas Gregorad590502008-12-15 23:53:10 +00003307 // void X::f(int) { } // ill-formed
3308 //
3309 // In this case, PrevDecl will point to the overload set
3310 // containing the two f's declared in X, but neither of them
Mike Stump11289f42009-09-09 15:08:12 +00003311 // matches.
Douglas Gregor8af63e42009-02-06 17:46:57 +00003312
3313 // First check whether we named the global scope.
3314 if (isa<TranslationUnitDecl>(DC)) {
Mike Stump11289f42009-09-09 15:08:12 +00003315 Diag(D.getIdentifierLoc(), diag::err_invalid_declarator_global_scope)
Douglas Gregor8af63e42009-02-06 17:46:57 +00003316 << Name << D.getCXXScopeSpec().getRange();
Sebastian Redlafb8be72009-11-08 11:36:54 +00003317 } else {
3318 DeclContext *Cur = CurContext;
3319 while (isa<LinkageSpecDecl>(Cur))
3320 Cur = Cur->getParent();
3321 if (!Cur->Encloses(DC)) {
3322 // The qualifying scope doesn't enclose the original declaration.
3323 // Emit diagnostic based on current scope.
3324 SourceLocation L = D.getIdentifierLoc();
3325 SourceRange R = D.getCXXScopeSpec().getRange();
3326 if (isa<FunctionDecl>(Cur))
3327 Diag(L, diag::err_invalid_declarator_in_function) << Name << R;
3328 else
3329 Diag(L, diag::err_invalid_declarator_scope)
3330 << Name << cast<NamedDecl>(DC) << R;
3331 D.setInvalidType();
3332 }
Argyrios Kyrtzidis16ac9be2008-11-08 17:17:31 +00003333 }
3334 }
3335
John McCall1f82f242009-11-18 22:49:29 +00003336 if (Previous.isSingleResult() &&
3337 Previous.getFoundDecl()->isTemplateParameter()) {
Douglas Gregor5101c242008-12-05 18:15:24 +00003338 // Maybe we will complain about the shadowed template parameter.
Mike Stump11289f42009-09-09 15:08:12 +00003339 if (!D.isInvalidType())
John McCall1f82f242009-11-18 22:49:29 +00003340 if (DiagnoseTemplateParameterShadow(D.getIdentifierLoc(),
3341 Previous.getFoundDecl()))
Chris Lattnerf6d1c9c2009-04-25 08:06:05 +00003342 D.setInvalidType();
Mike Stump11289f42009-09-09 15:08:12 +00003343
Douglas Gregor5101c242008-12-05 18:15:24 +00003344 // Just pretend that we didn't see the previous declaration.
John McCall1f82f242009-11-18 22:49:29 +00003345 Previous.clear();
Douglas Gregor5101c242008-12-05 18:15:24 +00003346 }
3347
Douglas Gregor83a586e2008-04-13 21:07:44 +00003348 // In C++, the previous declaration we find might be a tag type
3349 // (class or enum). In this case, the new declaration will hide the
Douglas Gregorfb034662009-01-28 17:15:10 +00003350 // tag type. Note that this does does not apply if we're declaring a
3351 // typedef (C++ [dcl.typedef]p4).
John McCall1f82f242009-11-18 22:49:29 +00003352 if (Previous.isSingleTagDecl() &&
Douglas Gregorfb034662009-01-28 17:15:10 +00003353 D.getDeclSpec().getStorageClassSpec() != DeclSpec::SCS_typedef)
John McCall1f82f242009-11-18 22:49:29 +00003354 Previous.clear();
Douglas Gregor83a586e2008-04-13 21:07:44 +00003355
Francois Pichet00c7e6c2011-08-14 03:52:19 +00003356 bool AddToScope = true;
Chris Lattner01a7c532007-01-25 23:09:03 +00003357 if (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_typedef) {
Douglas Gregorb52fabb2009-06-23 23:11:28 +00003358 if (TemplateParamLists.size()) {
3359 Diag(D.getIdentifierLoc(), diag::err_template_typedef);
John McCall48871652010-08-21 09:40:31 +00003360 return 0;
Douglas Gregorb52fabb2009-06-23 23:11:28 +00003361 }
Mike Stump11289f42009-09-09 15:08:12 +00003362
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00003363 New = ActOnTypedefDeclarator(S, D, DC, TInfo, Previous);
Douglas Gregoreddf4332009-02-24 20:03:32 +00003364 } else if (R->isFunctionType()) {
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00003365 New = ActOnFunctionDeclarator(S, D, DC, TInfo, Previous,
Douglas Gregorb52fabb2009-06-23 23:11:28 +00003366 move(TemplateParamLists),
Francois Pichet00c7e6c2011-08-14 03:52:19 +00003367 AddToScope);
Chris Lattner01a7c532007-01-25 23:09:03 +00003368 } else {
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00003369 New = ActOnVariableDeclarator(S, D, DC, TInfo, Previous,
3370 move(TemplateParamLists));
Chris Lattner01a7c532007-01-25 23:09:03 +00003371 }
Zhongxing Xubece5d62009-01-16 01:13:29 +00003372
3373 if (New == 0)
John McCall48871652010-08-21 09:40:31 +00003374 return 0;
Mike Stump11289f42009-09-09 15:08:12 +00003375
Douglas Gregor3a923c2d2009-09-24 23:14:47 +00003376 // If this has an identifier and is not an invalid redeclaration or
3377 // function template specialization, add it to the scope stack.
Francois Pichet00c7e6c2011-08-14 03:52:19 +00003378 if (New->getDeclName() && AddToScope &&
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00003379 !(D.isRedeclaration() && New->isInvalidDecl()))
Argyrios Kyrtzidisb8a49202008-04-12 00:47:19 +00003380 PushOnScopeChains(New, S);
Mike Stump11289f42009-09-09 15:08:12 +00003381
John McCall48871652010-08-21 09:40:31 +00003382 return New;
Chris Lattnere168f762006-11-10 05:29:30 +00003383}
3384
Eli Friedmana3b1d032009-02-21 00:44:51 +00003385/// TryToFixInvalidVariablyModifiedType - Helper method to turn variable array
3386/// types into constant array types in certain situations which would otherwise
3387/// be errors (for GCC compatibility).
3388static QualType TryToFixInvalidVariablyModifiedType(QualType T,
3389 ASTContext &Context,
Douglas Gregorcaa1bf42010-08-18 00:39:00 +00003390 bool &SizeIsNegative,
3391 llvm::APSInt &Oversized) {
Eli Friedmana3b1d032009-02-21 00:44:51 +00003392 // This method tries to turn a variable array into a constant
3393 // array even when the size isn't an ICE. This is necessary
3394 // for compatibility with code that depends on gcc's buggy
3395 // constant expression folding, like struct {char x[(int)(char*)2];}
3396 SizeIsNegative = false;
Douglas Gregorcaa1bf42010-08-18 00:39:00 +00003397 Oversized = 0;
3398
3399 if (T->isDependentType())
3400 return QualType();
3401
John McCall8ccfcb52009-09-24 19:53:00 +00003402 QualifierCollector Qs;
3403 const Type *Ty = Qs.strip(T);
3404
3405 if (const PointerType* PTy = dyn_cast<PointerType>(Ty)) {
Eli Friedmana3b1d032009-02-21 00:44:51 +00003406 QualType Pointee = PTy->getPointeeType();
3407 QualType FixedType =
Douglas Gregorcaa1bf42010-08-18 00:39:00 +00003408 TryToFixInvalidVariablyModifiedType(Pointee, Context, SizeIsNegative,
3409 Oversized);
Eli Friedmana3b1d032009-02-21 00:44:51 +00003410 if (FixedType.isNull()) return FixedType;
Eli Friedman44c0f2a2009-02-21 00:58:02 +00003411 FixedType = Context.getPointerType(FixedType);
John McCall717d9b02010-12-10 11:01:00 +00003412 return Qs.apply(Context, FixedType);
Eli Friedmana3b1d032009-02-21 00:44:51 +00003413 }
Abramo Bagnara924a8f32010-12-10 16:29:40 +00003414 if (const ParenType* PTy = dyn_cast<ParenType>(Ty)) {
3415 QualType Inner = PTy->getInnerType();
3416 QualType FixedType =
3417 TryToFixInvalidVariablyModifiedType(Inner, Context, SizeIsNegative,
3418 Oversized);
3419 if (FixedType.isNull()) return FixedType;
3420 FixedType = Context.getParenType(FixedType);
3421 return Qs.apply(Context, FixedType);
3422 }
Eli Friedmana3b1d032009-02-21 00:44:51 +00003423
3424 const VariableArrayType* VLATy = dyn_cast<VariableArrayType>(T);
Eli Friedmanadf40d42009-02-26 03:58:54 +00003425 if (!VLATy)
3426 return QualType();
3427 // FIXME: We should probably handle this case
3428 if (VLATy->getElementType()->isVariablyModifiedType())
3429 return QualType();
Mike Stump11289f42009-09-09 15:08:12 +00003430
Eli Friedmana3b1d032009-02-21 00:44:51 +00003431 Expr::EvalResult EvalResult;
3432 if (!VLATy->getSizeExpr() ||
Eli Friedmanadf40d42009-02-26 03:58:54 +00003433 !VLATy->getSizeExpr()->Evaluate(EvalResult, Context) ||
3434 !EvalResult.Val.isInt())
Eli Friedmana3b1d032009-02-21 00:44:51 +00003435 return QualType();
Eli Friedmanadf40d42009-02-26 03:58:54 +00003436
Douglas Gregorcaa1bf42010-08-18 00:39:00 +00003437 // Check whether the array size is negative.
Eli Friedmana3b1d032009-02-21 00:44:51 +00003438 llvm::APSInt &Res = EvalResult.Val.getInt();
Douglas Gregorcaa1bf42010-08-18 00:39:00 +00003439 if (Res.isSigned() && Res.isNegative()) {
3440 SizeIsNegative = true;
3441 return QualType();
Douglas Gregor04318252009-07-06 15:59:29 +00003442 }
Eli Friedmana3b1d032009-02-21 00:44:51 +00003443
Douglas Gregorcaa1bf42010-08-18 00:39:00 +00003444 // Check whether the array is too large to be addressed.
3445 unsigned ActiveSizeBits
3446 = ConstantArrayType::getNumAddressingBits(Context, VLATy->getElementType(),
3447 Res);
3448 if (ActiveSizeBits > ConstantArrayType::getMaxSizeBits(Context)) {
3449 Oversized = Res;
3450 return QualType();
3451 }
3452
3453 return Context.getConstantArrayType(VLATy->getElementType(),
3454 Res, ArrayType::Normal, 0);
Eli Friedmana3b1d032009-02-21 00:44:51 +00003455}
3456
Douglas Gregor5a80bd12009-03-02 00:19:53 +00003457/// \brief Register the given locally-scoped external C declaration so
3458/// that it can be found later for redeclarations
Mike Stump11289f42009-09-09 15:08:12 +00003459void
John McCall1f82f242009-11-18 22:49:29 +00003460Sema::RegisterLocallyScopedExternCDecl(NamedDecl *ND,
3461 const LookupResult &Previous,
Douglas Gregor5a80bd12009-03-02 00:19:53 +00003462 Scope *S) {
3463 assert(ND->getLexicalDeclContext()->isFunctionOrMethod() &&
3464 "Decl is not a locally-scoped decl!");
3465 // Note that we have a locally-scoped external with this name.
3466 LocallyScopedExternalDecls[ND->getDeclName()] = ND;
3467
John McCall1f82f242009-11-18 22:49:29 +00003468 if (!Previous.isSingleResult())
Douglas Gregor5a80bd12009-03-02 00:19:53 +00003469 return;
3470
John McCall1f82f242009-11-18 22:49:29 +00003471 NamedDecl *PrevDecl = Previous.getFoundDecl();
3472
Douglas Gregor5a80bd12009-03-02 00:19:53 +00003473 // If there was a previous declaration of this variable, it may be
3474 // in our identifier chain. Update the identifier chain with the new
3475 // declaration.
Douglas Gregorf4f296d2009-03-23 23:06:20 +00003476 if (S && IdResolver.ReplaceDecl(PrevDecl, ND)) {
Douglas Gregor5a80bd12009-03-02 00:19:53 +00003477 // The previous declaration was found on the identifer resolver
3478 // chain, so remove it from its scope.
Douglas Gregor825faf72011-06-29 21:22:02 +00003479
3480 if (S->isDeclScope(PrevDecl)) {
3481 // Special case for redeclarations in the SAME scope.
3482 // Because this declaration is going to be added to the identifier chain
3483 // later, we should temporarily take it OFF the chain.
3484 IdResolver.RemoveDecl(ND);
3485
3486 } else {
3487 // Find the scope for the original declaration.
3488 while (S && !S->isDeclScope(PrevDecl))
3489 S = S->getParent();
3490 }
Douglas Gregor5a80bd12009-03-02 00:19:53 +00003491
3492 if (S)
John McCall48871652010-08-21 09:40:31 +00003493 S->RemoveDecl(PrevDecl);
Douglas Gregor5a80bd12009-03-02 00:19:53 +00003494 }
3495}
3496
Douglas Gregordc5c9582011-07-28 14:20:37 +00003497llvm::DenseMap<DeclarationName, NamedDecl *>::iterator
3498Sema::findLocallyScopedExternalDecl(DeclarationName Name) {
3499 if (ExternalSource) {
3500 // Load locally-scoped external decls from the external source.
3501 SmallVector<NamedDecl *, 4> Decls;
3502 ExternalSource->ReadLocallyScopedExternalDecls(Decls);
3503 for (unsigned I = 0, N = Decls.size(); I != N; ++I) {
3504 llvm::DenseMap<DeclarationName, NamedDecl *>::iterator Pos
3505 = LocallyScopedExternalDecls.find(Decls[I]->getDeclName());
3506 if (Pos == LocallyScopedExternalDecls.end())
3507 LocallyScopedExternalDecls[Decls[I]->getDeclName()] = Decls[I];
3508 }
3509 }
3510
3511 return LocallyScopedExternalDecls.find(Name);
3512}
3513
Eli Friedman574c7452009-04-07 19:37:57 +00003514/// \brief Diagnose function specifiers on a declaration of an identifier that
3515/// does not identify a function.
3516void Sema::DiagnoseFunctionSpecifiers(Declarator& D) {
3517 // FIXME: We should probably indicate the identifier in question to avoid
3518 // confusion for constructs like "inline int a(), b;"
3519 if (D.getDeclSpec().isInlineSpecified())
Mike Stump11289f42009-09-09 15:08:12 +00003520 Diag(D.getDeclSpec().getInlineSpecLoc(),
Eli Friedman574c7452009-04-07 19:37:57 +00003521 diag::err_inline_non_function);
3522
3523 if (D.getDeclSpec().isVirtualSpecified())
Mike Stump11289f42009-09-09 15:08:12 +00003524 Diag(D.getDeclSpec().getVirtualSpecLoc(),
Eli Friedman574c7452009-04-07 19:37:57 +00003525 diag::err_virtual_non_function);
3526
3527 if (D.getDeclSpec().isExplicitSpecified())
Mike Stump11289f42009-09-09 15:08:12 +00003528 Diag(D.getDeclSpec().getExplicitSpecLoc(),
Eli Friedman574c7452009-04-07 19:37:57 +00003529 diag::err_explicit_non_function);
3530}
3531
Douglas Gregor6e6ad602009-01-20 01:17:11 +00003532NamedDecl*
Zhongxing Xuac8ef9e2009-01-16 03:34:13 +00003533Sema::ActOnTypedefDeclarator(Scope* S, Declarator& D, DeclContext* DC,
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00003534 TypeSourceInfo *TInfo, LookupResult &Previous) {
Zhongxing Xuac8ef9e2009-01-16 03:34:13 +00003535 // Typedef declarators cannot be qualified (C++ [dcl.meaning]p1).
3536 if (D.getCXXScopeSpec().isSet()) {
3537 Diag(D.getIdentifierLoc(), diag::err_qualified_typedef_declarator)
3538 << D.getCXXScopeSpec().getRange();
Chris Lattnerf6d1c9c2009-04-25 08:06:05 +00003539 D.setInvalidType();
Zhongxing Xuac8ef9e2009-01-16 03:34:13 +00003540 // Pretend we didn't see the scope specifier.
Douglas Gregorb525ef82010-03-23 15:26:55 +00003541 DC = CurContext;
3542 Previous.clear();
Zhongxing Xuac8ef9e2009-01-16 03:34:13 +00003543 }
3544
Douglas Gregor0c880302009-03-11 23:00:04 +00003545 if (getLangOptions().CPlusPlus) {
3546 // Check that there are no default arguments (C++ only).
Zhongxing Xuac8ef9e2009-01-16 03:34:13 +00003547 CheckExtraCXXDefaultArguments(D);
Douglas Gregor0c880302009-03-11 23:00:04 +00003548 }
3549
Eli Friedman574c7452009-04-07 19:37:57 +00003550 DiagnoseFunctionSpecifiers(D);
3551
Eli Friedmand5c0eed2009-04-19 20:27:55 +00003552 if (D.getDeclSpec().isThreadSpecified())
3553 Diag(D.getDeclSpec().getThreadSpecLoc(), diag::err_invalid_thread);
Richard Smitha77a0a62011-08-15 21:04:07 +00003554 if (D.getDeclSpec().isConstexprSpecified())
3555 Diag(D.getDeclSpec().getConstexprSpecLoc(), diag::err_invalid_constexpr)
3556 << 1;
Eli Friedmand5c0eed2009-04-19 20:27:55 +00003557
Douglas Gregord8f446f2010-07-13 06:37:01 +00003558 if (D.getName().Kind != UnqualifiedId::IK_Identifier) {
3559 Diag(D.getName().StartLocation, diag::err_typedef_not_identifier)
3560 << D.getName().getSourceRange();
3561 return 0;
3562 }
3563
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00003564 TypedefDecl *NewTD = ParseTypedefDecl(S, D, TInfo->getType(), TInfo);
Zhongxing Xuac8ef9e2009-01-16 03:34:13 +00003565 if (!NewTD) return 0;
Mike Stump11289f42009-09-09 15:08:12 +00003566
Zhongxing Xuac8ef9e2009-01-16 03:34:13 +00003567 // Handle attributes prior to checking for duplicates in MergeVarDecl
Douglas Gregor758a8692009-06-17 21:51:59 +00003568 ProcessDeclAttributes(S, NewTD, D);
John McCall1f82f242009-11-18 22:49:29 +00003569
Richard Smith3f1b5d02011-05-05 21:57:07 +00003570 CheckTypedefForVariablyModifiedType(S, NewTD);
3571
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00003572 bool Redeclaration = D.isRedeclaration();
3573 NamedDecl *ND = ActOnTypedefNameDecl(S, DC, NewTD, Previous, Redeclaration);
3574 D.setRedeclaration(Redeclaration);
3575 return ND;
Richard Smithdda56e42011-04-15 14:24:37 +00003576}
3577
Richard Smith3f1b5d02011-05-05 21:57:07 +00003578void
3579Sema::CheckTypedefForVariablyModifiedType(Scope *S, TypedefNameDecl *NewTD) {
Chris Lattner9fecd742009-04-19 05:21:20 +00003580 // C99 6.7.7p2: If a typedef name specifies a variably modified type
3581 // then it shall have block scope.
Eli Friedman88f4ed92010-08-10 03:13:15 +00003582 // Note that variably modified types must be fixed before merging the decl so
3583 // that redeclarations will match.
Chris Lattner9fecd742009-04-19 05:21:20 +00003584 QualType T = NewTD->getUnderlyingType();
3585 if (T->isVariablyModifiedType()) {
John McCallaab3e412010-08-25 08:40:02 +00003586 getCurFunction()->setHasBranchProtectedScope();
Mike Stump11289f42009-09-09 15:08:12 +00003587
Chris Lattner9fecd742009-04-19 05:21:20 +00003588 if (S->getFnParent() == 0) {
Eli Friedmana3b1d032009-02-21 00:44:51 +00003589 bool SizeIsNegative;
Douglas Gregorcaa1bf42010-08-18 00:39:00 +00003590 llvm::APSInt Oversized;
Eli Friedmana3b1d032009-02-21 00:44:51 +00003591 QualType FixedTy =
Douglas Gregorcaa1bf42010-08-18 00:39:00 +00003592 TryToFixInvalidVariablyModifiedType(T, Context, SizeIsNegative,
3593 Oversized);
Eli Friedmana3b1d032009-02-21 00:44:51 +00003594 if (!FixedTy.isNull()) {
Richard Smithdda56e42011-04-15 14:24:37 +00003595 Diag(NewTD->getLocation(), diag::warn_illegal_constant_array_size);
John McCallbcd03502009-12-07 02:54:59 +00003596 NewTD->setTypeSourceInfo(Context.getTrivialTypeSourceInfo(FixedTy));
Eli Friedmana3b1d032009-02-21 00:44:51 +00003597 } else {
3598 if (SizeIsNegative)
Richard Smithdda56e42011-04-15 14:24:37 +00003599 Diag(NewTD->getLocation(), diag::err_typecheck_negative_array_size);
Eli Friedmana3b1d032009-02-21 00:44:51 +00003600 else if (T->isVariableArrayType())
Richard Smithdda56e42011-04-15 14:24:37 +00003601 Diag(NewTD->getLocation(), diag::err_vla_decl_in_file_scope);
Douglas Gregorcaa1bf42010-08-18 00:39:00 +00003602 else if (Oversized.getBoolValue())
Richard Smithdda56e42011-04-15 14:24:37 +00003603 Diag(NewTD->getLocation(), diag::err_array_too_large) << Oversized.toString(10);
Eli Friedmana3b1d032009-02-21 00:44:51 +00003604 else
Richard Smithdda56e42011-04-15 14:24:37 +00003605 Diag(NewTD->getLocation(), diag::err_vm_decl_in_file_scope);
Chris Lattnerf6d1c9c2009-04-25 08:06:05 +00003606 NewTD->setInvalidDecl();
Eli Friedmana3b1d032009-02-21 00:44:51 +00003607 }
Zhongxing Xuac8ef9e2009-01-16 03:34:13 +00003608 }
3609 }
Richard Smith3f1b5d02011-05-05 21:57:07 +00003610}
Douglas Gregor27821ce2009-07-07 16:35:42 +00003611
Richard Smith3f1b5d02011-05-05 21:57:07 +00003612
3613/// ActOnTypedefNameDecl - Perform semantic checking for a declaration which
3614/// declares a typedef-name, either using the 'typedef' type specifier or via
3615/// a C++0x [dcl.typedef]p2 alias-declaration: 'using T = A;'.
3616NamedDecl*
3617Sema::ActOnTypedefNameDecl(Scope *S, DeclContext *DC, TypedefNameDecl *NewTD,
3618 LookupResult &Previous, bool &Redeclaration) {
Eli Friedman88f4ed92010-08-10 03:13:15 +00003619 // Merge the decl with the existing one if appropriate. If the decl is
3620 // in an outer scope, it isn't the same thing.
Richard Smith3f1b5d02011-05-05 21:57:07 +00003621 FilterLookupForScope(Previous, DC, S, /*ConsiderLinkage*/ false,
Douglas Gregordb446112011-03-07 16:54:27 +00003622 /*ExplicitInstantiationOrSpecialization=*/false);
Eli Friedman88f4ed92010-08-10 03:13:15 +00003623 if (!Previous.empty()) {
3624 Redeclaration = true;
Richard Smithdda56e42011-04-15 14:24:37 +00003625 MergeTypedefNameDecl(NewTD, Previous);
Eli Friedman88f4ed92010-08-10 03:13:15 +00003626 }
3627
Douglas Gregor27821ce2009-07-07 16:35:42 +00003628 // If this is the C FILE type, notify the AST context.
3629 if (IdentifierInfo *II = NewTD->getIdentifier())
3630 if (!NewTD->isInvalidDecl() &&
Sebastian Redl50c68252010-08-31 00:36:30 +00003631 NewTD->getDeclContext()->getRedeclContext()->isTranslationUnit()) {
Mike Stumpa4de80b2009-07-28 02:25:19 +00003632 if (II->isStr("FILE"))
3633 Context.setFILEDecl(NewTD);
3634 else if (II->isStr("jmp_buf"))
3635 Context.setjmp_bufDecl(NewTD);
3636 else if (II->isStr("sigjmp_buf"))
3637 Context.setsigjmp_bufDecl(NewTD);
Douglas Gregor2c2c4cd2010-10-05 15:41:24 +00003638 else if (II->isStr("__builtin_va_list"))
3639 Context.setBuiltinVaListType(Context.getTypedefType(NewTD));
Mike Stumpa4de80b2009-07-28 02:25:19 +00003640 }
3641
Zhongxing Xuac8ef9e2009-01-16 03:34:13 +00003642 return NewTD;
3643}
3644
Douglas Gregor5d68a202009-02-24 19:23:27 +00003645/// \brief Determines whether the given declaration is an out-of-scope
3646/// previous declaration.
3647///
3648/// This routine should be invoked when name lookup has found a
3649/// previous declaration (PrevDecl) that is not in the scope where a
3650/// new declaration by the same name is being introduced. If the new
3651/// declaration occurs in a local scope, previous declarations with
3652/// linkage may still be considered previous declarations (C99
3653/// 6.2.2p4-5, C++ [basic.link]p6).
3654///
3655/// \param PrevDecl the previous declaration found by name
3656/// lookup
Mike Stump11289f42009-09-09 15:08:12 +00003657///
Douglas Gregor5d68a202009-02-24 19:23:27 +00003658/// \param DC the context in which the new declaration is being
3659/// declared.
3660///
3661/// \returns true if PrevDecl is an out-of-scope previous declaration
3662/// for a new delcaration with the same name.
Mike Stump11289f42009-09-09 15:08:12 +00003663static bool
Douglas Gregor5d68a202009-02-24 19:23:27 +00003664isOutOfScopePreviousDeclaration(NamedDecl *PrevDecl, DeclContext *DC,
3665 ASTContext &Context) {
3666 if (!PrevDecl)
Sebastian Redl50c68252010-08-31 00:36:30 +00003667 return false;
Douglas Gregor5d68a202009-02-24 19:23:27 +00003668
Douglas Gregoreddf4332009-02-24 20:03:32 +00003669 if (!PrevDecl->hasLinkage())
3670 return false;
Douglas Gregor5d68a202009-02-24 19:23:27 +00003671
3672 if (Context.getLangOptions().CPlusPlus) {
3673 // C++ [basic.link]p6:
3674 // If there is a visible declaration of an entity with linkage
3675 // having the same name and type, ignoring entities declared
3676 // outside the innermost enclosing namespace scope, the block
3677 // scope declaration declares that same entity and receives the
3678 // linkage of the previous declaration.
Sebastian Redl50c68252010-08-31 00:36:30 +00003679 DeclContext *OuterContext = DC->getRedeclContext();
Douglas Gregor5d68a202009-02-24 19:23:27 +00003680 if (!OuterContext->isFunctionOrMethod())
3681 // This rule only applies to block-scope declarations.
3682 return false;
Douglas Gregorfcee9462010-08-27 22:55:10 +00003683
3684 DeclContext *PrevOuterContext = PrevDecl->getDeclContext();
3685 if (PrevOuterContext->isRecord())
3686 // We found a member function: ignore it.
3687 return false;
3688
3689 // Find the innermost enclosing namespace for the new and
3690 // previous declarations.
Sebastian Redl50c68252010-08-31 00:36:30 +00003691 OuterContext = OuterContext->getEnclosingNamespaceContext();
3692 PrevOuterContext = PrevOuterContext->getEnclosingNamespaceContext();
Mike Stump11289f42009-09-09 15:08:12 +00003693
Douglas Gregorfcee9462010-08-27 22:55:10 +00003694 // The previous declaration is in a different namespace, so it
3695 // isn't the same function.
3696 if (!OuterContext->Equals(PrevOuterContext))
3697 return false;
Douglas Gregor5d68a202009-02-24 19:23:27 +00003698 }
3699
Douglas Gregor5d68a202009-02-24 19:23:27 +00003700 return true;
3701}
3702
John McCall3e11ebe2010-03-15 10:12:16 +00003703static void SetNestedNameSpecifier(DeclaratorDecl *DD, Declarator &D) {
3704 CXXScopeSpec &SS = D.getCXXScopeSpec();
3705 if (!SS.isSet()) return;
Douglas Gregor14454802011-02-25 02:25:35 +00003706 DD->setQualifierInfo(SS.getWithLocInContext(DD->getASTContext()));
John McCall3e11ebe2010-03-15 10:12:16 +00003707}
3708
John McCall31168b02011-06-15 23:02:42 +00003709bool Sema::inferObjCARCLifetime(ValueDecl *decl) {
3710 QualType type = decl->getType();
3711 Qualifiers::ObjCLifetime lifetime = type.getObjCLifetime();
3712 if (lifetime == Qualifiers::OCL_Autoreleasing) {
3713 // Various kinds of declaration aren't allowed to be __autoreleasing.
3714 unsigned kind = -1U;
3715 if (VarDecl *var = dyn_cast<VarDecl>(decl)) {
3716 if (var->hasAttr<BlocksAttr>())
3717 kind = 0; // __block
3718 else if (!var->hasLocalStorage())
3719 kind = 1; // global
3720 } else if (isa<ObjCIvarDecl>(decl)) {
3721 kind = 3; // ivar
3722 } else if (isa<FieldDecl>(decl)) {
3723 kind = 2; // field
3724 }
3725
3726 if (kind != -1U) {
3727 Diag(decl->getLocation(), diag::err_arc_autoreleasing_var)
3728 << kind;
3729 }
3730 } else if (lifetime == Qualifiers::OCL_None) {
3731 // Try to infer lifetime.
3732 if (!type->isObjCLifetimeType())
3733 return false;
3734
3735 lifetime = type->getObjCARCImplicitLifetime();
3736 type = Context.getLifetimeQualifiedType(type, lifetime);
3737 decl->setType(type);
3738 }
3739
3740 if (VarDecl *var = dyn_cast<VarDecl>(decl)) {
3741 // Thread-local variables cannot have lifetime.
3742 if (lifetime && lifetime != Qualifiers::OCL_ExplicitNone &&
3743 var->isThreadSpecified()) {
Argyrios Kyrtzidiscff00d92011-06-24 00:08:59 +00003744 Diag(var->getLocation(), diag::err_arc_thread_ownership)
John McCall31168b02011-06-15 23:02:42 +00003745 << var->getType();
3746 return true;
3747 }
3748 }
3749
3750 return false;
3751}
3752
Douglas Gregor6e6ad602009-01-20 01:17:11 +00003753NamedDecl*
Chris Lattner88fdea82010-10-10 18:16:20 +00003754Sema::ActOnVariableDeclarator(Scope *S, Declarator &D, DeclContext *DC,
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00003755 TypeSourceInfo *TInfo, LookupResult &Previous,
3756 MultiTemplateParamsArg TemplateParamLists) {
3757 QualType R = TInfo->getType();
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00003758 DeclarationName Name = GetNameForDeclarator(D).getName();
Zhongxing Xu9b7714d2009-01-16 02:36:34 +00003759
3760 // Check that there are no default arguments (C++ only).
3761 if (getLangOptions().CPlusPlus)
3762 CheckExtraCXXDefaultArguments(D);
3763
Douglas Gregorc4df4072010-04-19 22:54:31 +00003764 DeclSpec::SCS SCSpec = D.getDeclSpec().getStorageClassSpec();
3765 assert(SCSpec != DeclSpec::SCS_typedef &&
3766 "Parser allowed 'typedef' as storage class VarDecl.");
Abramo Bagnaraed5b6892010-07-30 16:47:02 +00003767 VarDecl::StorageClass SC = StorageClassSpecToVarDeclStorageClass(SCSpec);
Douglas Gregorc4df4072010-04-19 22:54:31 +00003768 if (SCSpec == DeclSpec::SCS_mutable) {
Zhongxing Xu9b7714d2009-01-16 02:36:34 +00003769 // mutable can only appear on non-static class members, so it's always
3770 // an error here
3771 Diag(D.getIdentifierLoc(), diag::err_mutable_nonmember);
Chris Lattnerf6d1c9c2009-04-25 08:06:05 +00003772 D.setInvalidType();
John McCall8e7d6562010-08-26 03:08:43 +00003773 SC = SC_None;
Zhongxing Xu9b7714d2009-01-16 02:36:34 +00003774 }
Douglas Gregorc4df4072010-04-19 22:54:31 +00003775 SCSpec = D.getDeclSpec().getStorageClassSpecAsWritten();
3776 VarDecl::StorageClass SCAsWritten
Abramo Bagnaraed5b6892010-07-30 16:47:02 +00003777 = StorageClassSpecToVarDeclStorageClass(SCSpec);
Zhongxing Xu9b7714d2009-01-16 02:36:34 +00003778
3779 IdentifierInfo *II = Name.getAsIdentifierInfo();
3780 if (!II) {
3781 Diag(D.getIdentifierLoc(), diag::err_bad_variable_name)
Douglas Gregorbb64afc2011-10-09 18:55:59 +00003782 << Name;
Zhongxing Xu9b7714d2009-01-16 02:36:34 +00003783 return 0;
3784 }
3785
Eli Friedman574c7452009-04-07 19:37:57 +00003786 DiagnoseFunctionSpecifiers(D);
Douglas Gregor0c880302009-03-11 23:00:04 +00003787
Douglas Gregor212cab32009-03-11 20:22:50 +00003788 if (!DC->isRecord() && S->getFnParent() == 0) {
3789 // C99 6.9p2: The storage-class specifiers auto and register shall not
3790 // appear in the declaration specifiers in an external declaration.
John McCall8e7d6562010-08-26 03:08:43 +00003791 if (SC == SC_Auto || SC == SC_Register) {
Mike Stump11289f42009-09-09 15:08:12 +00003792
Chris Lattnerd98e7cf72009-05-12 21:44:00 +00003793 // If this is a register variable with an asm label specified, then this
3794 // is a GNU extension.
John McCall8e7d6562010-08-26 03:08:43 +00003795 if (SC == SC_Register && D.getAsmLabel())
Chris Lattnerd98e7cf72009-05-12 21:44:00 +00003796 Diag(D.getIdentifierLoc(), diag::err_unsupported_global_register);
3797 else
3798 Diag(D.getIdentifierLoc(), diag::err_typecheck_sclass_fscope);
Chris Lattnerf6d1c9c2009-04-25 08:06:05 +00003799 D.setInvalidType();
Zhongxing Xu9b7714d2009-01-16 02:36:34 +00003800 }
Zhongxing Xu9b7714d2009-01-16 02:36:34 +00003801 }
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00003802
Peter Collingbourne2dbb7082011-09-19 21:14:35 +00003803 if (getLangOptions().OpenCL) {
3804 // Set up the special work-group-local storage class for variables in the
3805 // OpenCL __local address space.
3806 if (R.getAddressSpace() == LangAS::opencl_local)
3807 SC = SC_OpenCLWorkGroupLocal;
3808 }
3809
Ted Kremenek582a0992011-01-23 17:04:59 +00003810 bool isExplicitSpecialization = false;
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00003811 VarDecl *NewVD;
3812 if (!getLangOptions().CPlusPlus) {
Abramo Bagnaradff19302011-03-08 08:55:46 +00003813 NewVD = VarDecl::Create(Context, DC, D.getSourceRange().getBegin(),
3814 D.getIdentifierLoc(), II,
3815 R, TInfo, SC, SCAsWritten);
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00003816
3817 if (D.isInvalidType())
3818 NewVD->setInvalidDecl();
3819 } else {
3820 if (DC->isRecord() && !CurContext->isRecord()) {
3821 // This is an out-of-line definition of a static data member.
3822 if (SC == SC_Static) {
3823 Diag(D.getDeclSpec().getStorageClassSpecLoc(),
3824 diag::err_static_out_of_line)
3825 << FixItHint::CreateRemoval(D.getDeclSpec().getStorageClassSpecLoc());
3826 } else if (SC == SC_None)
3827 SC = SC_Static;
Anders Carlssond2e8adf2009-06-24 00:28:53 +00003828 }
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00003829 if (SC == SC_Static) {
3830 if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(DC)) {
3831 if (RD->isLocalClass())
3832 Diag(D.getIdentifierLoc(),
3833 diag::err_static_data_member_not_allowed_in_local_class)
3834 << Name << RD->getDeclName();
Mike Stump11289f42009-09-09 15:08:12 +00003835
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00003836 // C++ [class.union]p1: If a union contains a static data member,
3837 // the program is ill-formed.
3838 //
3839 // We also disallow static data members in anonymous structs.
3840 if (CurContext->isRecord() && (RD->isUnion() || !RD->getDeclName()))
3841 Diag(D.getIdentifierLoc(),
3842 diag::err_static_data_member_not_allowed_in_union_or_anon_struct)
3843 << Name << RD->isUnion();
3844 }
3845 }
3846
3847 // Match up the template parameter lists with the scope specifier, then
3848 // determine whether we have a template or a template specialization.
3849 isExplicitSpecialization = false;
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00003850 bool Invalid = false;
3851 if (TemplateParameterList *TemplateParams
Douglas Gregor5c0405d2009-10-07 22:35:40 +00003852 = MatchTemplateParametersToScopeSpecifier(
Douglas Gregor972fe532011-05-10 18:27:06 +00003853 D.getDeclSpec().getSourceRange().getBegin(),
3854 D.getIdentifierLoc(),
Douglas Gregor5c0405d2009-10-07 22:35:40 +00003855 D.getCXXScopeSpec(),
John McCallace48cd2010-10-19 01:40:49 +00003856 TemplateParamLists.get(),
3857 TemplateParamLists.size(),
John McCalle820e5e2010-04-13 20:37:33 +00003858 /*never a friend*/ false,
Douglas Gregor5f0e2522010-07-14 23:14:12 +00003859 isExplicitSpecialization,
3860 Invalid)) {
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00003861 if (TemplateParams->size() > 0) {
3862 // There is no such thing as a variable template.
3863 Diag(D.getIdentifierLoc(), diag::err_template_variable)
3864 << II
3865 << SourceRange(TemplateParams->getTemplateLoc(),
3866 TemplateParams->getRAngleLoc());
3867 return 0;
3868 } else {
3869 // There is an extraneous 'template<>' for this variable. Complain
3870 // about it, but allow the declaration of the variable.
3871 Diag(TemplateParams->getTemplateLoc(),
3872 diag::err_template_variable_noparams)
3873 << II
3874 << SourceRange(TemplateParams->getTemplateLoc(),
3875 TemplateParams->getRAngleLoc());
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00003876 }
Douglas Gregorb09f3d82009-07-22 17:18:37 +00003877 }
Mike Stump11289f42009-09-09 15:08:12 +00003878
Abramo Bagnaradff19302011-03-08 08:55:46 +00003879 NewVD = VarDecl::Create(Context, DC, D.getSourceRange().getBegin(),
3880 D.getIdentifierLoc(), II,
3881 R, TInfo, SC, SCAsWritten);
Eli Friedmand5c0eed2009-04-19 20:27:55 +00003882
Richard Smithb2bc2e62011-02-21 20:05:19 +00003883 // If this decl has an auto type in need of deduction, make a note of the
3884 // Decl so we can diagnose uses of it in its own initializer.
3885 if (D.getDeclSpec().getTypeSpecType() == DeclSpec::TST_auto &&
3886 R->getContainedAutoType())
3887 ParsingInitForAutoVars.insert(NewVD);
Richard Smith30482bc2011-02-20 03:19:35 +00003888
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00003889 if (D.isInvalidType() || Invalid)
3890 NewVD->setInvalidDecl();
Mike Stump11289f42009-09-09 15:08:12 +00003891
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00003892 SetNestedNameSpecifier(NewVD, D);
John McCall3e11ebe2010-03-15 10:12:16 +00003893
Abramo Bagnara60804e12011-03-18 15:16:37 +00003894 if (TemplateParamLists.size() > 0 && D.getCXXScopeSpec().isSet()) {
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00003895 NewVD->setTemplateParameterListsInfo(Context,
Abramo Bagnara60804e12011-03-18 15:16:37 +00003896 TemplateParamLists.size(),
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00003897 TemplateParamLists.release());
3898 }
Richard Smitha77a0a62011-08-15 21:04:07 +00003899
3900 if (D.getDeclSpec().isConstexprSpecified()) {
Richard Smith2316cd82011-09-29 19:11:37 +00003901 // FIXME: once we know whether there's an initializer, apply this to
3902 // static data members too.
3903 if (!NewVD->isStaticDataMember() &&
3904 !NewVD->isThisDeclarationADefinition()) {
3905 // 'constexpr' is redundant and ill-formed on a non-defining declaration
3906 // of a variable. Suggest replacing it with 'const' if appropriate.
3907 SourceLocation ConstexprLoc = D.getDeclSpec().getConstexprSpecLoc();
3908 SourceRange ConstexprRange(ConstexprLoc, ConstexprLoc);
3909 // If the declarator is complex, we need to move the keyword to the
3910 // innermost chunk as we switch it from 'constexpr' to 'const'.
3911 int Kind = DeclaratorChunk::Paren;
3912 for (unsigned I = 0, E = D.getNumTypeObjects(); I != E; ++I) {
3913 Kind = D.getTypeObject(I).Kind;
3914 if (Kind != DeclaratorChunk::Paren)
3915 break;
3916 }
3917 if ((D.getDeclSpec().getTypeQualifiers() & DeclSpec::TQ_const) ||
3918 Kind == DeclaratorChunk::Reference)
3919 Diag(ConstexprLoc, diag::err_invalid_constexpr_var_decl)
3920 << FixItHint::CreateRemoval(ConstexprRange);
3921 else if (Kind == DeclaratorChunk::Paren)
3922 Diag(ConstexprLoc, diag::err_invalid_constexpr_var_decl)
3923 << FixItHint::CreateReplacement(ConstexprRange, "const");
3924 else
3925 Diag(ConstexprLoc, diag::err_invalid_constexpr_var_decl)
3926 << FixItHint::CreateRemoval(ConstexprRange)
3927 << FixItHint::CreateInsertion(D.getIdentifierLoc(), "const ");
3928 } else {
3929 NewVD->setConstexpr(true);
3930 }
Richard Smitha77a0a62011-08-15 21:04:07 +00003931 }
Abramo Bagnarada41d0c2010-06-12 08:15:14 +00003932 }
3933
Douglas Gregor41866812011-09-12 18:37:38 +00003934 // Set the lexical context. If the declarator has a C++ scope specifier, the
3935 // lexical context will be different from the semantic context.
3936 NewVD->setLexicalDeclContext(CurContext);
3937
Eli Friedmand5c0eed2009-04-19 20:27:55 +00003938 if (D.getDeclSpec().isThreadSpecified()) {
3939 if (NewVD->hasLocalStorage())
3940 Diag(D.getDeclSpec().getThreadSpecLoc(), diag::err_thread_non_global);
Douglas Gregore8bbc122011-09-02 00:18:52 +00003941 else if (!Context.getTargetInfo().isTLSSupported())
Eli Friedmandaea3f62009-04-19 21:48:33 +00003942 Diag(D.getDeclSpec().getThreadSpecLoc(), diag::err_thread_unsupported);
Eli Friedmand5c0eed2009-04-19 20:27:55 +00003943 else
3944 NewVD->setThreadSpecified(true);
3945 }
Douglas Gregor6e6ad602009-01-20 01:17:11 +00003946
Douglas Gregor3c7cd6a2011-09-09 20:53:38 +00003947 if (D.getDeclSpec().isModulePrivateSpecified()) {
3948 if (isExplicitSpecialization)
3949 Diag(NewVD->getLocation(), diag::err_module_private_specialization)
3950 << 2
3951 << FixItHint::CreateRemoval(D.getDeclSpec().getModulePrivateSpecLoc());
Douglas Gregor41866812011-09-12 18:37:38 +00003952 else if (NewVD->hasLocalStorage())
3953 Diag(NewVD->getLocation(), diag::err_module_private_local)
3954 << 0 << NewVD->getDeclName()
3955 << SourceRange(D.getDeclSpec().getModulePrivateSpecLoc())
3956 << FixItHint::CreateRemoval(D.getDeclSpec().getModulePrivateSpecLoc());
Douglas Gregor3c7cd6a2011-09-09 20:53:38 +00003957 else
3958 NewVD->setModulePrivate();
3959 }
Douglas Gregor26701a42011-09-09 02:06:17 +00003960
Zhongxing Xu9b7714d2009-01-16 02:36:34 +00003961 // Handle attributes prior to checking for duplicates in MergeVarDecl
Douglas Gregor758a8692009-06-17 21:51:59 +00003962 ProcessDeclAttributes(S, NewVD, D);
Zhongxing Xu9b7714d2009-01-16 02:36:34 +00003963
John McCall31168b02011-06-15 23:02:42 +00003964 // In auto-retain/release, infer strong retension for variables of
3965 // retainable type.
3966 if (getLangOptions().ObjCAutoRefCount && inferObjCARCLifetime(NewVD))
3967 NewVD->setInvalidDecl();
3968
Zhongxing Xu9b7714d2009-01-16 02:36:34 +00003969 // Handle GNU asm-label extension (encoded as an attribute).
Chris Lattner88fdea82010-10-10 18:16:20 +00003970 if (Expr *E = (Expr*)D.getAsmLabel()) {
Zhongxing Xu9b7714d2009-01-16 02:36:34 +00003971 // The parser guarantees this is a string.
Mike Stump11289f42009-09-09 15:08:12 +00003972 StringLiteral *SE = cast<StringLiteral>(E);
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003973 StringRef Label = SE->getString();
Abramo Bagnara13392232011-01-11 15:16:52 +00003974 if (S->getFnParent() != 0) {
3975 switch (SC) {
3976 case SC_None:
3977 case SC_Auto:
3978 Diag(E->getExprLoc(), diag::warn_asm_label_on_auto_decl) << Label;
3979 break;
3980 case SC_Register:
Douglas Gregore8bbc122011-09-02 00:18:52 +00003981 if (!Context.getTargetInfo().isValidGCCRegisterName(Label))
Abramo Bagnara13392232011-01-11 15:16:52 +00003982 Diag(E->getExprLoc(), diag::err_asm_unknown_register_name) << Label;
3983 break;
3984 case SC_Static:
3985 case SC_Extern:
3986 case SC_PrivateExtern:
Peter Collingbourne2dbb7082011-09-19 21:14:35 +00003987 case SC_OpenCLWorkGroupLocal:
Abramo Bagnara13392232011-01-11 15:16:52 +00003988 break;
3989 }
3990 }
3991
3992 NewVD->addAttr(::new (Context) AsmLabelAttr(SE->getStrTokenLoc(0),
Rafael Espindola478abca2011-01-01 21:47:03 +00003993 Context, Label));
Zhongxing Xu9b7714d2009-01-16 02:36:34 +00003994 }
3995
John McCalla2a3f7d2010-03-16 21:48:18 +00003996 // Diagnose shadowed variables before filtering for scope.
John McCall2d8c7602010-03-20 04:12:52 +00003997 if (!D.getCXXScopeSpec().isSet())
John McCalldf8b37c2010-03-22 09:20:08 +00003998 CheckShadow(S, NewVD, Previous);
John McCalla2a3f7d2010-03-16 21:48:18 +00003999
John McCall1f82f242009-11-18 22:49:29 +00004000 // Don't consider existing declarations that are in a different
4001 // scope and are out-of-semantic-context declarations (if the new
4002 // declaration has linkage).
Richard Smith3f1b5d02011-05-05 21:57:07 +00004003 FilterLookupForScope(Previous, DC, S, NewVD->hasLinkage(),
Douglas Gregordb446112011-03-07 16:54:27 +00004004 isExplicitSpecialization);
Douglas Gregor86d142a2009-10-08 07:24:58 +00004005
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00004006 if (!getLangOptions().CPlusPlus) {
4007 D.setRedeclaration(CheckVariableDeclaration(NewVD, Previous));
4008 } else {
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00004009 // Merge the decl with the existing one if appropriate.
4010 if (!Previous.empty()) {
4011 if (Previous.isSingleResult() &&
4012 isa<FieldDecl>(Previous.getFoundDecl()) &&
4013 D.getCXXScopeSpec().isSet()) {
4014 // The user tried to define a non-static data member
4015 // out-of-line (C++ [dcl.meaning]p1).
4016 Diag(NewVD->getLocation(), diag::err_nonstatic_member_out_of_line)
4017 << D.getCXXScopeSpec().getRange();
4018 Previous.clear();
4019 NewVD->setInvalidDecl();
4020 }
4021 } else if (D.getCXXScopeSpec().isSet()) {
4022 // No previous declaration in the qualifying scope.
4023 Diag(D.getIdentifierLoc(), diag::err_no_member)
4024 << Name << computeDeclContext(D.getCXXScopeSpec(), true)
Douglas Gregoref1a09a2009-03-25 23:32:15 +00004025 << D.getCXXScopeSpec().getRange();
Chris Lattnerf6d1c9c2009-04-25 08:06:05 +00004026 NewVD->setInvalidDecl();
Douglas Gregoref1a09a2009-03-25 23:32:15 +00004027 }
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00004028
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00004029 D.setRedeclaration(CheckVariableDeclaration(NewVD, Previous));
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00004030
4031 // This is an explicit specialization of a static data member. Check it.
4032 if (isExplicitSpecialization && !NewVD->isInvalidDecl() &&
4033 CheckMemberSpecialization(NewVD, Previous))
4034 NewVD->setInvalidDecl();
Douglas Gregoref1a09a2009-03-25 23:32:15 +00004035 }
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00004036
Ryan Flynne5dc8592009-07-25 22:29:44 +00004037 // attributes declared post-definition are currently ignored
Alexis Huntdcfba7b2010-08-18 23:23:40 +00004038 // FIXME: This should be handled in attribute merging, not
4039 // here.
John McCall1f82f242009-11-18 22:49:29 +00004040 if (Previous.isSingleResult()) {
Sebastian Redl5ca79842010-02-01 20:16:42 +00004041 VarDecl *Def = dyn_cast<VarDecl>(Previous.getFoundDecl());
4042 if (Def && (Def = Def->getDefinition()) &&
4043 Def != NewVD && D.hasAttributes()) {
Ryan Flynne5dc8592009-07-25 22:29:44 +00004044 Diag(NewVD->getLocation(), diag::warn_attribute_precede_definition);
4045 Diag(Def->getLocation(), diag::note_previous_definition);
4046 }
4047 }
4048
Douglas Gregoref1a09a2009-03-25 23:32:15 +00004049 // If this is a locally-scoped extern C variable, update the map of
4050 // such variables.
Douglas Gregor16618f22009-09-12 00:17:51 +00004051 if (CurContext->isFunctionOrMethod() && NewVD->isExternC() &&
Chris Lattnerf6d1c9c2009-04-25 08:06:05 +00004052 !NewVD->isInvalidDecl())
John McCall1f82f242009-11-18 22:49:29 +00004053 RegisterLocallyScopedExternCDecl(NewVD, Previous, S);
Douglas Gregoref1a09a2009-03-25 23:32:15 +00004054
Eli Friedman570024a2010-08-05 06:57:20 +00004055 // If there's a #pragma GCC visibility in scope, and this isn't a class
4056 // member, set the visibility of this variable.
4057 if (NewVD->getLinkage() == ExternalLinkage && !DC->isRecord())
4058 AddPushedVisibilityAttribute(NewVD);
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00004059
Argyrios Kyrtzidis1b30d9c2010-08-15 01:15:20 +00004060 MarkUnusedFileScopedDecl(NewVD);
4061
Douglas Gregoref1a09a2009-03-25 23:32:15 +00004062 return NewVD;
4063}
4064
John McCalldf8b37c2010-03-22 09:20:08 +00004065/// \brief Diagnose variable or built-in function shadowing. Implements
4066/// -Wshadow.
John McCalla2a3f7d2010-03-16 21:48:18 +00004067///
John McCalldf8b37c2010-03-22 09:20:08 +00004068/// This method is called whenever a VarDecl is added to a "useful"
4069/// scope.
John McCalla2a3f7d2010-03-16 21:48:18 +00004070///
John McCall2d8c7602010-03-20 04:12:52 +00004071/// \param S the scope in which the shadowing name is being declared
4072/// \param R the lookup of the name
John McCalla2a3f7d2010-03-16 21:48:18 +00004073///
John McCalldf8b37c2010-03-22 09:20:08 +00004074void Sema::CheckShadow(Scope *S, VarDecl *D, const LookupResult& R) {
John McCalla2a3f7d2010-03-16 21:48:18 +00004075 // Return if warning is ignored.
Argyrios Kyrtzidis1cb0de12010-12-15 18:44:22 +00004076 if (Diags.getDiagnosticLevel(diag::warn_decl_shadow, R.getNameLoc()) ==
David Blaikie9c902b52011-09-25 23:23:43 +00004077 DiagnosticsEngine::Ignored)
John McCalla2a3f7d2010-03-16 21:48:18 +00004078 return;
4079
Argyrios Kyrtzidis898fdbf2011-02-08 18:21:25 +00004080 // Don't diagnose declarations at file scope.
Argyrios Kyrtzidisbd0a3fe2011-04-25 21:39:50 +00004081 if (D->hasGlobalStorage())
John McCalla2a3f7d2010-03-16 21:48:18 +00004082 return;
Argyrios Kyrtzidisbd0a3fe2011-04-25 21:39:50 +00004083
4084 DeclContext *NewDC = D->getDeclContext();
4085
John McCall2d8c7602010-03-20 04:12:52 +00004086 // Only diagnose if we're shadowing an unambiguous field or variable.
Douglas Gregor319aa6c2010-03-17 16:03:44 +00004087 if (R.getResultKind() != LookupResult::Found)
John McCalla2a3f7d2010-03-16 21:48:18 +00004088 return;
John McCalla2a3f7d2010-03-16 21:48:18 +00004089
John McCalla2a3f7d2010-03-16 21:48:18 +00004090 NamedDecl* ShadowedDecl = R.getFoundDecl();
4091 if (!isa<VarDecl>(ShadowedDecl) && !isa<FieldDecl>(ShadowedDecl))
4092 return;
4093
Argyrios Kyrtzidisf46cc652011-01-31 07:04:54 +00004094 // Fields are not shadowed by variables in C++ static methods.
4095 if (isa<FieldDecl>(ShadowedDecl))
4096 if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(NewDC))
4097 if (MD->isStatic())
4098 return;
4099
Argyrios Kyrtzidis857dd062011-01-31 07:04:50 +00004100 if (VarDecl *shadowedVar = dyn_cast<VarDecl>(ShadowedDecl))
4101 if (shadowedVar->isExternC()) {
Argyrios Kyrtzidis857dd062011-01-31 07:04:50 +00004102 // For shadowing external vars, make sure that we point to the global
4103 // declaration, not a locally scoped extern declaration.
4104 for (VarDecl::redecl_iterator
4105 I = shadowedVar->redecls_begin(), E = shadowedVar->redecls_end();
4106 I != E; ++I)
4107 if (I->isFileVarDecl()) {
4108 ShadowedDecl = *I;
4109 break;
4110 }
4111 }
4112
4113 DeclContext *OldDC = ShadowedDecl->getDeclContext();
4114
John McCall2d8c7602010-03-20 04:12:52 +00004115 // Only warn about certain kinds of shadowing for class members.
4116 if (NewDC && NewDC->isRecord()) {
4117 // In particular, don't warn about shadowing non-class members.
4118 if (!OldDC->isRecord())
4119 return;
4120
4121 // TODO: should we warn about static data members shadowing
4122 // static data members from base classes?
4123
4124 // TODO: don't diagnose for inaccessible shadowed members.
4125 // This is hard to do perfectly because we might friend the
4126 // shadowing context, but that's just a false negative.
4127 }
4128
4129 // Determine what kind of declaration we're shadowing.
John McCalla2a3f7d2010-03-16 21:48:18 +00004130 unsigned Kind;
John McCall2d8c7602010-03-20 04:12:52 +00004131 if (isa<RecordDecl>(OldDC)) {
John McCalla2a3f7d2010-03-16 21:48:18 +00004132 if (isa<FieldDecl>(ShadowedDecl))
4133 Kind = 3; // field
4134 else
4135 Kind = 2; // static data member
John McCall2d8c7602010-03-20 04:12:52 +00004136 } else if (OldDC->isFileContext())
John McCalla2a3f7d2010-03-16 21:48:18 +00004137 Kind = 1; // global
4138 else
4139 Kind = 0; // local
4140
John McCall2d8c7602010-03-20 04:12:52 +00004141 DeclarationName Name = R.getLookupName();
4142
John McCalla2a3f7d2010-03-16 21:48:18 +00004143 // Emit warning and note.
John McCall2d8c7602010-03-20 04:12:52 +00004144 Diag(R.getNameLoc(), diag::warn_decl_shadow) << Name << Kind << OldDC;
John McCalla2a3f7d2010-03-16 21:48:18 +00004145 Diag(ShadowedDecl->getLocation(), diag::note_previous_declaration);
4146}
4147
John McCalldf8b37c2010-03-22 09:20:08 +00004148/// \brief Check -Wshadow without the advantage of a previous lookup.
4149void Sema::CheckShadow(Scope *S, VarDecl *D) {
Argyrios Kyrtzidis1cb0de12010-12-15 18:44:22 +00004150 if (Diags.getDiagnosticLevel(diag::warn_decl_shadow, D->getLocation()) ==
David Blaikie9c902b52011-09-25 23:23:43 +00004151 DiagnosticsEngine::Ignored)
Argyrios Kyrtzidis1cb0de12010-12-15 18:44:22 +00004152 return;
4153
John McCalldf8b37c2010-03-22 09:20:08 +00004154 LookupResult R(*this, D->getDeclName(), D->getLocation(),
4155 Sema::LookupOrdinaryName, Sema::ForRedeclaration);
4156 LookupName(R, S);
4157 CheckShadow(S, D, R);
4158}
4159
Douglas Gregoref1a09a2009-03-25 23:32:15 +00004160/// \brief Perform semantic checking on a newly-created variable
4161/// declaration.
4162///
4163/// This routine performs all of the type-checking required for a
Douglas Gregorf16a8a72009-05-01 15:47:09 +00004164/// variable declaration once it has been built. It is used both to
Douglas Gregoref1a09a2009-03-25 23:32:15 +00004165/// check variables after they have been parsed and their declarators
Douglas Gregorf16a8a72009-05-01 15:47:09 +00004166/// have been translated into a declaration, and to check variables
4167/// that have been instantiated from a template.
Douglas Gregoref1a09a2009-03-25 23:32:15 +00004168///
Chris Lattnerf6d1c9c2009-04-25 08:06:05 +00004169/// Sets NewVD->isInvalidDecl() if an error was encountered.
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00004170///
4171/// Returns true if the variable declaration is a redeclaration.
4172bool Sema::CheckVariableDeclaration(VarDecl *NewVD,
4173 LookupResult &Previous) {
Chris Lattnerf6d1c9c2009-04-25 08:06:05 +00004174 // If the decl is already known invalid, don't check it.
4175 if (NewVD->isInvalidDecl())
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00004176 return false;
Mike Stump11289f42009-09-09 15:08:12 +00004177
Douglas Gregoref1a09a2009-03-25 23:32:15 +00004178 QualType T = NewVD->getType();
4179
John McCall8b07ec22010-05-15 11:32:37 +00004180 if (T->isObjCObjectType()) {
Fariborz Jahanian9a14c212011-07-25 21:12:27 +00004181 Diag(NewVD->getLocation(), diag::err_statically_allocated_object)
4182 << FixItHint::CreateInsertion(NewVD->getLocation(), "*");
Fariborz Jahanian6507135e2011-07-26 17:58:54 +00004183 T = Context.getObjCObjectPointerType(T);
4184 NewVD->setType(T);
Douglas Gregoref1a09a2009-03-25 23:32:15 +00004185 }
Mike Stump11289f42009-09-09 15:08:12 +00004186
Zhongxing Xu9b7714d2009-01-16 02:36:34 +00004187 // Emit an error if an address space was applied to decl with local storage.
4188 // This includes arrays of objects with address space qualifiers, but not
4189 // automatic variables that point to other address spaces.
4190 // ISO/IEC TR 18037 S5.1.2
Chris Lattner88fdea82010-10-10 18:16:20 +00004191 if (NewVD->hasLocalStorage() && T.getAddressSpace() != 0) {
Douglas Gregoref1a09a2009-03-25 23:32:15 +00004192 Diag(NewVD->getLocation(), diag::err_as_qualified_auto_decl);
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00004193 NewVD->setInvalidDecl();
4194 return false;
Zhongxing Xu9b7714d2009-01-16 02:36:34 +00004195 }
Fariborz Jahanian0c9404e2009-02-21 19:44:02 +00004196
Mike Stumpca5ae662009-04-14 00:57:29 +00004197 if (NewVD->hasLocalStorage() && T.isObjCGCWeak()
Fariborz Jahanianc32830c2011-06-07 20:15:46 +00004198 && !NewVD->hasAttr<BlocksAttr>()) {
Douglas Gregor79a91412011-09-13 17:21:33 +00004199 if (getLangOptions().getGC() != LangOptions::NonGC)
Fariborz Jahanianc32830c2011-06-07 20:15:46 +00004200 Diag(NewVD->getLocation(), diag::warn_gc_attribute_weak_on_local);
4201 else
4202 Diag(NewVD->getLocation(), diag::warn_attribute_weak_on_local);
4203 }
Chris Lattner88fdea82010-10-10 18:16:20 +00004204
Chris Lattner9fecd742009-04-19 05:21:20 +00004205 bool isVM = T->isVariablyModifiedType();
Chris Lattner9662cd32009-07-19 20:17:11 +00004206 if (isVM || NewVD->hasAttr<CleanupAttr>() ||
John McCalld4e1b762010-08-01 01:24:59 +00004207 NewVD->hasAttr<BlocksAttr>())
John McCallaab3e412010-08-25 08:40:02 +00004208 getCurFunction()->setHasBranchProtectedScope();
Mike Stump11289f42009-09-09 15:08:12 +00004209
Chris Lattner9fecd742009-04-19 05:21:20 +00004210 if ((isVM && NewVD->hasLinkage()) ||
4211 (T->isVariableArrayType() && NewVD->hasGlobalStorage())) {
Anders Carlsson6c885802009-02-28 21:56:50 +00004212 bool SizeIsNegative;
Douglas Gregorcaa1bf42010-08-18 00:39:00 +00004213 llvm::APSInt Oversized;
Anders Carlsson6c885802009-02-28 21:56:50 +00004214 QualType FixedTy =
Douglas Gregorcaa1bf42010-08-18 00:39:00 +00004215 TryToFixInvalidVariablyModifiedType(T, Context, SizeIsNegative,
4216 Oversized);
Mike Stump11289f42009-09-09 15:08:12 +00004217
Chris Lattnerf6d1c9c2009-04-25 08:06:05 +00004218 if (FixedTy.isNull() && T->isVariableArrayType()) {
Douglas Gregoref1a09a2009-03-25 23:32:15 +00004219 const VariableArrayType *VAT = Context.getAsVariableArrayType(T);
Mike Stump11289f42009-09-09 15:08:12 +00004220 // FIXME: This won't give the correct result for
4221 // int a[10][n];
Anders Carlsson6c885802009-02-28 21:56:50 +00004222 SourceRange SizeRange = VAT->getSizeExpr()->getSourceRange();
Mike Stump11289f42009-09-09 15:08:12 +00004223
Anders Carlsson6c885802009-02-28 21:56:50 +00004224 if (NewVD->isFileVarDecl())
4225 Diag(NewVD->getLocation(), diag::err_vla_decl_in_file_scope)
Chris Lattnerf6d1c9c2009-04-25 08:06:05 +00004226 << SizeRange;
John McCall8e7d6562010-08-26 03:08:43 +00004227 else if (NewVD->getStorageClass() == SC_Static)
Anders Carlsson6c885802009-02-28 21:56:50 +00004228 Diag(NewVD->getLocation(), diag::err_vla_decl_has_static_storage)
Chris Lattnerf6d1c9c2009-04-25 08:06:05 +00004229 << SizeRange;
Anders Carlsson6c885802009-02-28 21:56:50 +00004230 else
4231 Diag(NewVD->getLocation(), diag::err_vla_decl_has_extern_linkage)
Chris Lattnerf6d1c9c2009-04-25 08:06:05 +00004232 << SizeRange;
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00004233 NewVD->setInvalidDecl();
4234 return false;
Mike Stump11289f42009-09-09 15:08:12 +00004235 }
4236
Chris Lattnerf6d1c9c2009-04-25 08:06:05 +00004237 if (FixedTy.isNull()) {
Anders Carlsson6c885802009-02-28 21:56:50 +00004238 if (NewVD->isFileVarDecl())
4239 Diag(NewVD->getLocation(), diag::err_vm_decl_in_file_scope);
4240 else
4241 Diag(NewVD->getLocation(), diag::err_vm_decl_has_extern_linkage);
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00004242 NewVD->setInvalidDecl();
4243 return false;
Anders Carlsson6c885802009-02-28 21:56:50 +00004244 }
Mike Stump11289f42009-09-09 15:08:12 +00004245
Chris Lattnerf6d1c9c2009-04-25 08:06:05 +00004246 Diag(NewVD->getLocation(), diag::warn_illegal_constant_array_size);
4247 NewVD->setType(FixedTy);
Anders Carlsson6c885802009-02-28 21:56:50 +00004248 }
4249
John McCall1f82f242009-11-18 22:49:29 +00004250 if (Previous.empty() && NewVD->isExternC()) {
Douglas Gregor5a80bd12009-03-02 00:19:53 +00004251 // Since we did not find anything by this name and we're declaring
4252 // an extern "C" variable, look for a non-visible extern "C"
4253 // declaration with the same name.
4254 llvm::DenseMap<DeclarationName, NamedDecl *>::iterator Pos
Douglas Gregordc5c9582011-07-28 14:20:37 +00004255 = findLocallyScopedExternalDecl(NewVD->getDeclName());
Douglas Gregor5a80bd12009-03-02 00:19:53 +00004256 if (Pos != LocallyScopedExternalDecls.end())
John McCall1f82f242009-11-18 22:49:29 +00004257 Previous.addDecl(Pos->second);
Douglas Gregor5a80bd12009-03-02 00:19:53 +00004258 }
4259
Chris Lattnerf6d1c9c2009-04-25 08:06:05 +00004260 if (T->isVoidType() && !NewVD->hasExternalStorage()) {
Douglas Gregoref1a09a2009-03-25 23:32:15 +00004261 Diag(NewVD->getLocation(), diag::err_typecheck_decl_incomplete_type)
4262 << T;
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00004263 NewVD->setInvalidDecl();
4264 return false;
Douglas Gregoref1a09a2009-03-25 23:32:15 +00004265 }
Zhongxing Xu9b7714d2009-01-16 02:36:34 +00004266
Argyrios Kyrtzidisb4b64ca2009-06-30 02:34:44 +00004267 if (!NewVD->hasLocalStorage() && NewVD->hasAttr<BlocksAttr>()) {
Mike Stumpe9efa802009-04-30 00:19:40 +00004268 Diag(NewVD->getLocation(), diag::err_block_on_nonlocal);
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00004269 NewVD->setInvalidDecl();
4270 return false;
Mike Stumpe9efa802009-04-30 00:19:40 +00004271 }
Mike Stump11289f42009-09-09 15:08:12 +00004272
Argyrios Kyrtzidisb4b64ca2009-06-30 02:34:44 +00004273 if (isVM && NewVD->hasAttr<BlocksAttr>()) {
Mike Stumpa7128632009-05-01 23:41:47 +00004274 Diag(NewVD->getLocation(), diag::err_block_on_vm);
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00004275 NewVD->setInvalidDecl();
4276 return false;
Mike Stumpa7128632009-05-01 23:41:47 +00004277 }
4278
Sebastian Redl5467c9f2010-07-12 23:11:43 +00004279 // Function pointers and references cannot have qualified function type, only
4280 // function pointer-to-members can do that.
4281 QualType Pointee;
4282 unsigned PtrOrRef = 0;
4283 if (const PointerType *Ptr = T->getAs<PointerType>())
4284 Pointee = Ptr->getPointeeType();
4285 else if (const ReferenceType *Ref = T->getAs<ReferenceType>()) {
4286 Pointee = Ref->getPointeeType();
4287 PtrOrRef = 1;
4288 }
4289 if (!Pointee.isNull() && Pointee->isFunctionProtoType() &&
4290 Pointee->getAs<FunctionProtoType>()->getTypeQuals() != 0) {
4291 Diag(NewVD->getLocation(), diag::err_invalid_qualified_function_pointer)
4292 << PtrOrRef;
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00004293 NewVD->setInvalidDecl();
4294 return false;
Sebastian Redl5467c9f2010-07-12 23:11:43 +00004295 }
4296
John McCall1f82f242009-11-18 22:49:29 +00004297 if (!Previous.empty()) {
John McCall1f82f242009-11-18 22:49:29 +00004298 MergeVarDecl(NewVD, Previous);
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00004299 return true;
Zhongxing Xu9b7714d2009-01-16 02:36:34 +00004300 }
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00004301 return false;
Zhongxing Xu9b7714d2009-01-16 02:36:34 +00004302}
4303
Douglas Gregor36d1b142009-10-06 17:59:45 +00004304/// \brief Data used with FindOverriddenMethod
4305struct FindOverriddenMethodData {
4306 Sema *S;
4307 CXXMethodDecl *Method;
4308};
4309
4310/// \brief Member lookup function that determines whether a given C++
4311/// method overrides a method in a base class, to be used with
4312/// CXXRecordDecl::lookupInBases().
John McCall84c16cf2009-11-12 03:15:40 +00004313static bool FindOverriddenMethod(const CXXBaseSpecifier *Specifier,
Douglas Gregor36d1b142009-10-06 17:59:45 +00004314 CXXBasePath &Path,
4315 void *UserData) {
4316 RecordDecl *BaseRecord = Specifier->getType()->getAs<RecordType>()->getDecl();
Anders Carlssone985fae2009-11-26 20:50:40 +00004317
Douglas Gregor36d1b142009-10-06 17:59:45 +00004318 FindOverriddenMethodData *Data
4319 = reinterpret_cast<FindOverriddenMethodData*>(UserData);
Anders Carlssone985fae2009-11-26 20:50:40 +00004320
4321 DeclarationName Name = Data->Method->getDeclName();
4322
4323 // FIXME: Do we care about other names here too?
4324 if (Name.getNameKind() == DeclarationName::CXXDestructorName) {
John McCalle9cccd82010-06-16 08:42:20 +00004325 // We really want to find the base class destructor here.
Anders Carlssone985fae2009-11-26 20:50:40 +00004326 QualType T = Data->S->Context.getTypeDeclType(BaseRecord);
4327 CanQualType CT = Data->S->Context.getCanonicalType(T);
4328
Anders Carlsson5a4f7722009-11-27 01:26:58 +00004329 Name = Data->S->Context.DeclarationNames.getCXXDestructorName(CT);
Anders Carlssone985fae2009-11-26 20:50:40 +00004330 }
4331
4332 for (Path.Decls = BaseRecord->lookup(Name);
Douglas Gregor36d1b142009-10-06 17:59:45 +00004333 Path.Decls.first != Path.Decls.second;
4334 ++Path.Decls.first) {
John McCall38e5f432010-06-16 09:33:39 +00004335 NamedDecl *D = *Path.Decls.first;
John McCalle9cccd82010-06-16 08:42:20 +00004336 if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(D)) {
4337 if (MD->isVirtual() && !Data->S->IsOverload(Data->Method, MD, false))
Douglas Gregor36d1b142009-10-06 17:59:45 +00004338 return true;
4339 }
4340 }
4341
4342 return false;
4343}
4344
Sebastian Redld5b24532009-11-18 21:51:29 +00004345/// AddOverriddenMethods - See if a method overrides any in the base classes,
4346/// and if so, check that it's a valid override and remember it.
Douglas Gregor5a2bb5b2010-10-13 22:55:32 +00004347bool Sema::AddOverriddenMethods(CXXRecordDecl *DC, CXXMethodDecl *MD) {
Sebastian Redld5b24532009-11-18 21:51:29 +00004348 // Look for virtual methods in base classes that this method might override.
4349 CXXBasePaths Paths;
4350 FindOverriddenMethodData Data;
4351 Data.Method = MD;
4352 Data.S = this;
Douglas Gregor5a2bb5b2010-10-13 22:55:32 +00004353 bool AddedAny = false;
Sebastian Redld5b24532009-11-18 21:51:29 +00004354 if (DC->lookupInBases(&FindOverriddenMethod, &Data, Paths)) {
4355 for (CXXBasePaths::decl_iterator I = Paths.found_decls_begin(),
4356 E = Paths.found_decls_end(); I != E; ++I) {
4357 if (CXXMethodDecl *OldMD = dyn_cast<CXXMethodDecl>(*I)) {
Richard Trieu95d88092011-07-01 20:02:53 +00004358 MD->addOverriddenMethod(OldMD->getCanonicalDecl());
Sebastian Redld5b24532009-11-18 21:51:29 +00004359 if (!CheckOverridingFunctionReturnType(MD, OldMD) &&
Alexis Hunt96d5c762009-11-21 08:43:09 +00004360 !CheckOverridingFunctionExceptionSpec(MD, OldMD) &&
Anders Carlsson3f610c72011-01-20 16:25:36 +00004361 !CheckIfOverriddenFunctionIsMarkedFinal(MD, OldMD)) {
Douglas Gregor5a2bb5b2010-10-13 22:55:32 +00004362 AddedAny = true;
4363 }
Sebastian Redld5b24532009-11-18 21:51:29 +00004364 }
4365 }
4366 }
Douglas Gregor5a2bb5b2010-10-13 22:55:32 +00004367
4368 return AddedAny;
Sebastian Redld5b24532009-11-18 21:51:29 +00004369}
4370
Kaelyn Uhrain0a32fca2011-10-11 00:28:39 +00004371namespace {
4372 // Struct for holding all of the extra arguments needed by
4373 // DiagnoseInvalidRedeclaration to call Sema::ActOnFunctionDeclarator.
4374 struct ActOnFDArgs {
4375 Scope *S;
4376 Declarator &D;
Kaelyn Uhrain0a32fca2011-10-11 00:28:39 +00004377 MultiTemplateParamsArg TemplateParamLists;
Kaelyn Uhrain0a32fca2011-10-11 00:28:39 +00004378 bool AddToScope;
4379 };
4380}
4381
4382/// \brief Generate diagnostics for an invalid function redeclaration.
4383///
4384/// This routine handles generating the diagnostic messages for an invalid
4385/// function redeclaration, including finding possible similar declarations
4386/// or performing typo correction if there are no previous declarations with
4387/// the same name.
4388///
4389/// Returns a NamedDecl iff typo correction was performed and substituting in
4390/// the new declaration name does not cause new errors.
4391static NamedDecl* DiagnoseInvalidRedeclaration(
Kaelyn Uhrain8af2c9f2011-10-11 00:28:52 +00004392 Sema &SemaRef, LookupResult &Previous, FunctionDecl *NewFD,
Kaelyn Uhrain0a32fca2011-10-11 00:28:39 +00004393 ActOnFDArgs &ExtraArgs) {
Kaelyn Uhrain0a32fca2011-10-11 00:28:39 +00004394 NamedDecl *Result = NULL;
Kaelyn Uhrainfd81a352011-08-18 18:19:12 +00004395 DeclarationName Name = NewFD->getDeclName();
Kaelyn Uhrain0a32fca2011-10-11 00:28:39 +00004396 DeclContext *NewDC = NewFD->getDeclContext();
Kaelyn Uhrain8af2c9f2011-10-11 00:28:52 +00004397 LookupResult Prev(SemaRef, Name, NewFD->getLocation(),
John McCallf7cfb222010-10-13 05:45:15 +00004398 Sema::LookupOrdinaryName, Sema::ForRedeclaration);
Kaelyn Uhrain7d9bc632011-08-04 17:40:00 +00004399 llvm::SmallVector<unsigned, 1> MismatchedParams;
Kaelyn Uhrainfd81a352011-08-18 18:19:12 +00004400 llvm::SmallVector<std::pair<FunctionDecl*, unsigned>, 1> NearMatches;
4401 TypoCorrection Correction;
Kaelyn Uhrain8af2c9f2011-10-11 00:28:52 +00004402 bool isFriendDecl = (SemaRef.getLangOptions().CPlusPlus &&
4403 ExtraArgs.D.getDeclSpec().isFriendSpecified());
Kaelyn Uhrainfd81a352011-08-18 18:19:12 +00004404 unsigned DiagMsg = isFriendDecl ? diag::err_no_matching_local_friend
4405 : diag::err_member_def_does_not_match;
4406
4407 NewFD->setInvalidDecl();
Kaelyn Uhrain8af2c9f2011-10-11 00:28:52 +00004408 SemaRef.LookupQualifiedName(Prev, NewDC);
John McCallf7cfb222010-10-13 05:45:15 +00004409 assert(!Prev.isAmbiguous() &&
4410 "Cannot have an ambiguity in previous-declaration lookup");
Kaelyn Uhrainfd81a352011-08-18 18:19:12 +00004411 if (!Prev.empty()) {
4412 for (LookupResult::iterator Func = Prev.begin(), FuncEnd = Prev.end();
4413 Func != FuncEnd; ++Func) {
4414 FunctionDecl *FD = dyn_cast<FunctionDecl>(*Func);
Kaelyn Uhrain8af2c9f2011-10-11 00:28:52 +00004415 if (FD &&
4416 hasSimilarParameters(SemaRef.Context, FD, NewFD, MismatchedParams)) {
Kaelyn Uhrainfd81a352011-08-18 18:19:12 +00004417 // Add 1 to the index so that 0 can mean the mismatch didn't
4418 // involve a parameter
4419 unsigned ParamNum =
4420 MismatchedParams.empty() ? 0 : MismatchedParams.front() + 1;
4421 NearMatches.push_back(std::make_pair(FD, ParamNum));
4422 }
Kaelyn Uhrain7d9bc632011-08-04 17:40:00 +00004423 }
Kaelyn Uhrainfd81a352011-08-18 18:19:12 +00004424 // If the qualified name lookup yielded nothing, try typo correction
Kaelyn Uhrain8af2c9f2011-10-11 00:28:52 +00004425 } else if ((Correction = SemaRef.CorrectTypo(Prev.getLookupNameInfo(),
Kaelyn Uhrain0a32fca2011-10-11 00:28:39 +00004426 Prev.getLookupKind(), 0, 0, NewDC)) &&
Kaelyn Uhrain40aa7c92011-08-18 21:57:36 +00004427 Correction.getCorrection() != Name) {
Kaelyn Uhrain0a32fca2011-10-11 00:28:39 +00004428 // Trap errors.
Kaelyn Uhrain8af2c9f2011-10-11 00:28:52 +00004429 Sema::SFINAETrap Trap(SemaRef);
Kaelyn Uhrain0a32fca2011-10-11 00:28:39 +00004430
4431 // Set up everything for the call to ActOnFunctionDeclarator
4432 ExtraArgs.D.SetIdentifier(Correction.getCorrectionAsIdentifierInfo(),
4433 ExtraArgs.D.getIdentifierLoc());
4434 Previous.clear();
4435 Previous.setLookupName(Correction.getCorrection());
Kaelyn Uhrainfd81a352011-08-18 18:19:12 +00004436 for (TypoCorrection::decl_iterator CDecl = Correction.begin(),
4437 CDeclEnd = Correction.end();
4438 CDecl != CDeclEnd; ++CDecl) {
4439 FunctionDecl *FD = dyn_cast<FunctionDecl>(*CDecl);
Kaelyn Uhrain8af2c9f2011-10-11 00:28:52 +00004440 if (FD && hasSimilarParameters(SemaRef.Context, FD, NewFD,
4441 MismatchedParams)) {
Kaelyn Uhrain0a32fca2011-10-11 00:28:39 +00004442 Previous.addDecl(FD);
Kaelyn Uhrainfd81a352011-08-18 18:19:12 +00004443 }
4444 }
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00004445 bool wasRedeclaration = ExtraArgs.D.isRedeclaration();
Kaelyn Uhrain0a32fca2011-10-11 00:28:39 +00004446 // TODO: Refactor ActOnFunctionDeclarator so that we can call only the
4447 // pieces need to verify the typo-corrected C++ declaraction and hopefully
4448 // eliminate the need for the parameter pack ExtraArgs.
Kaelyn Uhrain8af2c9f2011-10-11 00:28:52 +00004449 Result = SemaRef.ActOnFunctionDeclarator(ExtraArgs.S, ExtraArgs.D,
4450 NewFD->getDeclContext(),
4451 NewFD->getTypeSourceInfo(),
4452 Previous,
4453 ExtraArgs.TemplateParamLists,
4454 ExtraArgs.AddToScope);
Kaelyn Uhrain0a32fca2011-10-11 00:28:39 +00004455 if (Trap.hasErrorOccurred()) {
4456 // Pretend the typo correction never occurred
4457 ExtraArgs.D.SetIdentifier(Name.getAsIdentifierInfo(),
4458 ExtraArgs.D.getIdentifierLoc());
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00004459 ExtraArgs.D.setRedeclaration(wasRedeclaration);
Kaelyn Uhrain0a32fca2011-10-11 00:28:39 +00004460 Previous.clear();
4461 Previous.setLookupName(Name);
4462 Result = NULL;
4463 } else {
4464 for (LookupResult::iterator Func = Previous.begin(),
4465 FuncEnd = Previous.end();
4466 Func != FuncEnd; ++Func) {
4467 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(*Func))
4468 NearMatches.push_back(std::make_pair(FD, 0));
4469 }
4470 }
4471 if (NearMatches.empty()) {
4472 // Ignore the correction if it didn't yield any close FunctionDecl matches
4473 Correction = TypoCorrection();
4474 } else {
Kaelyn Uhrain7fbe2f72011-09-14 19:37:32 +00004475 DiagMsg = isFriendDecl ? diag::err_no_matching_local_friend_suggest
4476 : diag::err_member_def_does_not_match_suggest;
Kaelyn Uhrain0a32fca2011-10-11 00:28:39 +00004477 }
Kaelyn Uhrainfd81a352011-08-18 18:19:12 +00004478 }
4479
4480 if (Correction)
Kaelyn Uhrain8af2c9f2011-10-11 00:28:52 +00004481 SemaRef.Diag(NewFD->getLocation(), DiagMsg)
4482 << Name << NewDC << Correction.getQuoted(SemaRef.getLangOptions())
Kaelyn Uhrainfd81a352011-08-18 18:19:12 +00004483 << FixItHint::CreateReplacement(
Kaelyn Uhrain8af2c9f2011-10-11 00:28:52 +00004484 NewFD->getLocation(),
4485 Correction.getAsString(SemaRef.getLangOptions()));
Kaelyn Uhrainfd81a352011-08-18 18:19:12 +00004486 else
Kaelyn Uhrain8af2c9f2011-10-11 00:28:52 +00004487 SemaRef.Diag(NewFD->getLocation(), DiagMsg)
4488 << Name << NewDC << NewFD->getLocation();
Kaelyn Uhrainfd81a352011-08-18 18:19:12 +00004489
Kaelyn Uhrain1a6eb992011-10-10 18:01:37 +00004490 bool NewFDisConst = false;
4491 if (CXXMethodDecl *NewMD = dyn_cast<CXXMethodDecl>(NewFD))
4492 NewFDisConst = NewMD->getTypeQualifiers() & Qualifiers::Const;
4493
Kaelyn Uhrainfd81a352011-08-18 18:19:12 +00004494 for (llvm::SmallVector<std::pair<FunctionDecl*, unsigned>, 1>::iterator
4495 NearMatch = NearMatches.begin(), NearMatchEnd = NearMatches.end();
4496 NearMatch != NearMatchEnd; ++NearMatch) {
4497 FunctionDecl *FD = NearMatch->first;
Kaelyn Uhrain1a6eb992011-10-10 18:01:37 +00004498 bool FDisConst = false;
4499 if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD))
4500 FDisConst = MD->getTypeQualifiers() & Qualifiers::Const;
Kaelyn Uhrainfd81a352011-08-18 18:19:12 +00004501
4502 if (unsigned Idx = NearMatch->second) {
4503 ParmVarDecl *FDParam = FD->getParamDecl(Idx-1);
Kaelyn Uhrain8af2c9f2011-10-11 00:28:52 +00004504 SemaRef.Diag(FDParam->getTypeSpecStartLoc(),
Kaelyn Uhrainfd81a352011-08-18 18:19:12 +00004505 diag::note_member_def_close_param_match)
4506 << Idx << FDParam->getType() << NewFD->getParamDecl(Idx-1)->getType();
4507 } else if (Correction) {
Kaelyn Uhrain8af2c9f2011-10-11 00:28:52 +00004508 SemaRef.Diag(FD->getLocation(), diag::note_previous_decl)
4509 << Correction.getQuoted(SemaRef.getLangOptions());
Kaelyn Uhrain1a6eb992011-10-10 18:01:37 +00004510 } else if (FDisConst != NewFDisConst) {
Kaelyn Uhrain8af2c9f2011-10-11 00:28:52 +00004511 SemaRef.Diag(FD->getLocation(), diag::note_member_def_close_const_match)
Kaelyn Uhrain1a6eb992011-10-10 18:01:37 +00004512 << NewFDisConst << FD->getSourceRange().getEnd();
Kaelyn Uhrainfd81a352011-08-18 18:19:12 +00004513 } else
Kaelyn Uhrain8af2c9f2011-10-11 00:28:52 +00004514 SemaRef.Diag(FD->getLocation(), diag::note_member_def_close_match);
John McCallf7cfb222010-10-13 05:45:15 +00004515 }
Kaelyn Uhrain0a32fca2011-10-11 00:28:39 +00004516 return Result;
John McCallf7cfb222010-10-13 05:45:15 +00004517}
4518
Kaelyn Uhraine1a9ff72011-10-11 00:28:49 +00004519static FunctionDecl::StorageClass getFunctionStorageClass(Sema &SemaRef, Declarator &D) {
4520 switch (D.getDeclSpec().getStorageClassSpec()) {
4521 default: llvm_unreachable("Unknown storage class!");
4522 case DeclSpec::SCS_auto:
4523 case DeclSpec::SCS_register:
4524 case DeclSpec::SCS_mutable:
4525 SemaRef.Diag(D.getDeclSpec().getStorageClassSpecLoc(),
4526 diag::err_typecheck_sclass_func);
4527 D.setInvalidType();
4528 break;
4529 case DeclSpec::SCS_unspecified: break;
4530 case DeclSpec::SCS_extern: return SC_Extern;
4531 case DeclSpec::SCS_static: {
4532 if (SemaRef.CurContext->getRedeclContext()->isFunctionOrMethod()) {
4533 // C99 6.7.1p5:
4534 // The declaration of an identifier for a function that has
4535 // block scope shall have no explicit storage-class specifier
4536 // other than extern
4537 // See also (C++ [dcl.stc]p4).
4538 SemaRef.Diag(D.getDeclSpec().getStorageClassSpecLoc(),
4539 diag::err_static_block_func);
4540 break;
4541 } else
4542 return SC_Static;
4543 }
4544 case DeclSpec::SCS_private_extern: return SC_PrivateExtern;
4545 }
4546
4547 // No explicit storage class has already been returned
4548 return SC_None;
4549}
4550
4551static FunctionDecl* CreateNewFunctionDecl(Sema &SemaRef, Declarator &D,
4552 DeclContext *DC, QualType &R,
4553 TypeSourceInfo *TInfo,
4554 FunctionDecl::StorageClass SC,
4555 bool &IsVirtualOkay) {
4556 DeclarationNameInfo NameInfo = SemaRef.GetNameForDeclarator(D);
4557 DeclarationName Name = NameInfo.getName();
4558
4559 FunctionDecl *NewFD = 0;
4560 bool isInline = D.getDeclSpec().isInlineSpecified();
4561 DeclSpec::SCS SCSpec = D.getDeclSpec().getStorageClassSpecAsWritten();
4562 FunctionDecl::StorageClass SCAsWritten
4563 = StorageClassSpecToFunctionDeclStorageClass(SCSpec);
4564
4565 if (!SemaRef.getLangOptions().CPlusPlus) {
4566 // Determine whether the function was written with a
4567 // prototype. This true when:
4568 // - there is a prototype in the declarator, or
4569 // - the type R of the function is some kind of typedef or other reference
4570 // to a type name (which eventually refers to a function type).
4571 bool HasPrototype =
4572 (D.isFunctionDeclarator() && D.getFunctionTypeInfo().hasPrototype) ||
4573 (!isa<FunctionType>(R.getTypePtr()) && R->isFunctionProtoType());
4574
4575 NewFD = FunctionDecl::Create(SemaRef.Context, DC, D.getSourceRange().getBegin(),
4576 NameInfo, R, TInfo, SC, SCAsWritten, isInline,
4577 HasPrototype);
4578 if (D.isInvalidType())
4579 NewFD->setInvalidDecl();
4580
4581 // Set the lexical context.
4582 NewFD->setLexicalDeclContext(SemaRef.CurContext);
4583
4584 return NewFD;
4585 }
4586
4587 bool isExplicit = D.getDeclSpec().isExplicitSpecified();
4588 bool isConstexpr = D.getDeclSpec().isConstexprSpecified();
4589
4590 // Check that the return type is not an abstract class type.
4591 // For record types, this is done by the AbstractClassUsageDiagnoser once
4592 // the class has been completely parsed.
4593 if (!DC->isRecord() &&
4594 SemaRef.RequireNonAbstractType(D.getIdentifierLoc(),
4595 R->getAs<FunctionType>()->getResultType(),
4596 diag::err_abstract_type_in_decl,
4597 SemaRef.AbstractReturnType))
4598 D.setInvalidType();
4599
4600 if (Name.getNameKind() == DeclarationName::CXXConstructorName) {
4601 // This is a C++ constructor declaration.
4602 assert(DC->isRecord() &&
4603 "Constructors can only be declared in a member context");
4604
4605 R = SemaRef.CheckConstructorDeclarator(D, R, SC);
4606 return CXXConstructorDecl::Create(SemaRef.Context, cast<CXXRecordDecl>(DC),
4607 D.getSourceRange().getBegin(), NameInfo,
4608 R, TInfo, isExplicit, isInline,
4609 /*isImplicitlyDeclared=*/false,
4610 isConstexpr);
4611
4612 } else if (Name.getNameKind() == DeclarationName::CXXDestructorName) {
4613 // This is a C++ destructor declaration.
4614 if (DC->isRecord()) {
4615 R = SemaRef.CheckDestructorDeclarator(D, R, SC);
4616 CXXRecordDecl *Record = cast<CXXRecordDecl>(DC);
4617 CXXDestructorDecl *NewDD = CXXDestructorDecl::Create(
4618 SemaRef.Context, Record,
4619 D.getSourceRange().getBegin(),
4620 NameInfo, R, TInfo, isInline,
4621 /*isImplicitlyDeclared=*/false);
4622
4623 // If the class is complete, then we now create the implicit exception
4624 // specification. If the class is incomplete or dependent, we can't do
4625 // it yet.
4626 if (SemaRef.getLangOptions().CPlusPlus0x && !Record->isDependentType() &&
4627 Record->getDefinition() && !Record->isBeingDefined() &&
4628 R->getAs<FunctionProtoType>()->getExceptionSpecType() == EST_None) {
4629 SemaRef.AdjustDestructorExceptionSpec(Record, NewDD);
4630 }
4631
4632 IsVirtualOkay = true;
4633 return NewDD;
4634
4635 } else {
4636 SemaRef.Diag(D.getIdentifierLoc(), diag::err_destructor_not_member);
4637 D.setInvalidType();
4638
4639 // Create a FunctionDecl to satisfy the function definition parsing
4640 // code path.
4641 return FunctionDecl::Create(SemaRef.Context, DC,
4642 D.getSourceRange().getBegin(),
4643 D.getIdentifierLoc(), Name, R, TInfo,
4644 SC, SCAsWritten, isInline,
4645 /*hasPrototype=*/true, isConstexpr);
4646 }
4647
4648 } else if (Name.getNameKind() == DeclarationName::CXXConversionFunctionName) {
4649 if (!DC->isRecord()) {
4650 SemaRef.Diag(D.getIdentifierLoc(),
4651 diag::err_conv_function_not_member);
4652 return 0;
4653 }
4654
4655 SemaRef.CheckConversionDeclarator(D, R, SC);
4656 IsVirtualOkay = true;
4657 return CXXConversionDecl::Create(SemaRef.Context, cast<CXXRecordDecl>(DC),
4658 D.getSourceRange().getBegin(), NameInfo,
4659 R, TInfo, isInline, isExplicit,
4660 isConstexpr, SourceLocation());
4661
4662 } else if (DC->isRecord()) {
4663 // If the name of the function is the same as the name of the record,
4664 // then this must be an invalid constructor that has a return type.
4665 // (The parser checks for a return type and makes the declarator a
4666 // constructor if it has no return type).
4667 if (Name.getAsIdentifierInfo() &&
4668 Name.getAsIdentifierInfo() == cast<CXXRecordDecl>(DC)->getIdentifier()){
4669 SemaRef.Diag(D.getIdentifierLoc(), diag::err_constructor_return_type)
4670 << SourceRange(D.getDeclSpec().getTypeSpecTypeLoc())
4671 << SourceRange(D.getIdentifierLoc());
4672 return 0;
4673 }
4674
4675 bool isStatic = SC == SC_Static;
4676
4677 // [class.free]p1:
4678 // Any allocation function for a class T is a static member
4679 // (even if not explicitly declared static).
4680 if (Name.getCXXOverloadedOperator() == OO_New ||
4681 Name.getCXXOverloadedOperator() == OO_Array_New)
4682 isStatic = true;
4683
4684 // [class.free]p6 Any deallocation function for a class X is a static member
4685 // (even if not explicitly declared static).
4686 if (Name.getCXXOverloadedOperator() == OO_Delete ||
4687 Name.getCXXOverloadedOperator() == OO_Array_Delete)
4688 isStatic = true;
4689
4690 IsVirtualOkay = !isStatic;
4691
4692 // This is a C++ method declaration.
4693 return CXXMethodDecl::Create(SemaRef.Context, cast<CXXRecordDecl>(DC),
4694 D.getSourceRange().getBegin(), NameInfo, R,
4695 TInfo, isStatic, SCAsWritten, isInline,
4696 isConstexpr, SourceLocation());
4697
4698 } else {
4699 // Determine whether the function was written with a
4700 // prototype. This true when:
4701 // - we're in C++ (where every function has a prototype),
4702 return FunctionDecl::Create(SemaRef.Context, DC,
4703 D.getSourceRange().getBegin(),
4704 NameInfo, R, TInfo, SC, SCAsWritten, isInline,
4705 true/*HasPrototype*/, isConstexpr);
4706 }
4707}
4708
Mike Stump11289f42009-09-09 15:08:12 +00004709NamedDecl*
Nick Lewycky0bdf13e2011-07-02 02:05:12 +00004710Sema::ActOnFunctionDeclarator(Scope *S, Declarator &D, DeclContext *DC,
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00004711 TypeSourceInfo *TInfo, LookupResult &Previous,
Douglas Gregorb52fabb2009-06-23 23:11:28 +00004712 MultiTemplateParamsArg TemplateParamLists,
Francois Pichet00c7e6c2011-08-14 03:52:19 +00004713 bool &AddToScope) {
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00004714 QualType R = TInfo->getType();
4715
Zhongxing Xubece5d62009-01-16 01:13:29 +00004716 assert(R.getTypePtr()->isFunctionType());
4717
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00004718 // TODO: consider using NameInfo for diagnostic.
4719 DeclarationNameInfo NameInfo = GetNameForDeclarator(D);
4720 DeclarationName Name = NameInfo.getName();
Kaelyn Uhraine1a9ff72011-10-11 00:28:49 +00004721 FunctionDecl::StorageClass SC = getFunctionStorageClass(*this, D);
Zhongxing Xubece5d62009-01-16 01:13:29 +00004722
Eli Friedmand5c0eed2009-04-19 20:27:55 +00004723 if (D.getDeclSpec().isThreadSpecified())
4724 Diag(D.getDeclSpec().getThreadSpecLoc(), diag::err_invalid_thread);
4725
Chris Lattner347eec92009-04-11 19:17:25 +00004726 // Do not allow returning a objc interface by-value.
John McCall8b07ec22010-05-15 11:32:37 +00004727 if (R->getAs<FunctionType>()->getResultType()->isObjCObjectType()) {
Chris Lattner347eec92009-04-11 19:17:25 +00004728 Diag(D.getIdentifierLoc(),
4729 diag::err_object_cannot_be_passed_returned_by_value) << 0
Fariborz Jahanian6507135e2011-07-26 17:58:54 +00004730 << R->getAs<FunctionType>()->getResultType()
4731 << FixItHint::CreateInsertion(D.getIdentifierLoc(), "*");
4732
4733 QualType T = R->getAs<FunctionType>()->getResultType();
4734 T = Context.getObjCObjectPointerType(T);
4735 if (const FunctionProtoType *FPT = dyn_cast<FunctionProtoType>(R)) {
4736 FunctionProtoType::ExtProtoInfo EPI = FPT->getExtProtoInfo();
4737 R = Context.getFunctionType(T, FPT->arg_type_begin(),
4738 FPT->getNumArgs(), EPI);
4739 }
4740 else if (isa<FunctionNoProtoType>(R))
4741 R = Context.getFunctionNoProtoType(T);
Chris Lattner347eec92009-04-11 19:17:25 +00004742 }
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00004743
Douglas Gregor513e63c2010-12-10 19:28:19 +00004744 bool isFriend = false;
Douglas Gregor513e63c2010-12-10 19:28:19 +00004745 FunctionTemplateDecl *FunctionTemplate = 0;
4746 bool isExplicitSpecialization = false;
4747 bool isFunctionTemplateSpecialization = false;
Francois Pichet00c7e6c2011-08-14 03:52:19 +00004748 bool isDependentClassScopeExplicitSpecialization = false;
Kaelyn Uhraine1a9ff72011-10-11 00:28:49 +00004749 bool isVirtualOkay = false;
Abramo Bagnara60804e12011-03-18 15:16:37 +00004750
Kaelyn Uhraine1a9ff72011-10-11 00:28:49 +00004751 FunctionDecl *NewFD = CreateNewFunctionDecl(*this, D, DC, R, TInfo, SC,
4752 isVirtualOkay);
4753 if (!NewFD) return 0;
4754
4755 if (getLangOptions().CPlusPlus) {
4756 bool isInline = D.getDeclSpec().isInlineSpecified();
Douglas Gregor513e63c2010-12-10 19:28:19 +00004757 bool isVirtual = D.getDeclSpec().isVirtualSpecified();
4758 bool isExplicit = D.getDeclSpec().isExplicitSpecified();
Richard Smitha77a0a62011-08-15 21:04:07 +00004759 bool isConstexpr = D.getDeclSpec().isConstexprSpecified();
Kaelyn Uhraine1a9ff72011-10-11 00:28:49 +00004760 isFriend = D.getDeclSpec().isFriendSpecified();
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00004761 if (isFriend && !isInline && D.isFunctionDefinition()) {
Abramo Bagnaraa3088e62011-03-18 15:21:59 +00004762 // C++ [class.friend]p5
4763 // A function can be defined in a friend declaration of a
4764 // class . . . . Such a function is implicitly inline.
4765 NewFD->setImplicitlyInline();
4766 }
4767
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00004768 SetNestedNameSpecifier(NewFD, D);
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00004769 isExplicitSpecialization = false;
4770 isFunctionTemplateSpecialization = false;
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00004771 if (D.isInvalidType())
4772 NewFD->setInvalidDecl();
4773
4774 // Set the lexical context. If the declarator has a C++
4775 // scope specifier, or is the object of a friend declaration, the
4776 // lexical context will be different from the semantic context.
4777 NewFD->setLexicalDeclContext(CurContext);
4778
4779 // Match up the template parameter lists with the scope specifier, then
4780 // determine whether we have a template or a template specialization.
4781 bool Invalid = false;
4782 if (TemplateParameterList *TemplateParams
Douglas Gregor93ded322011-03-04 22:45:55 +00004783 = MatchTemplateParametersToScopeSpecifier(
Douglas Gregord8d297c2009-07-21 23:53:31 +00004784 D.getDeclSpec().getSourceRange().getBegin(),
Douglas Gregor972fe532011-05-10 18:27:06 +00004785 D.getIdentifierLoc(),
Douglas Gregord8d297c2009-07-21 23:53:31 +00004786 D.getCXXScopeSpec(),
John McCall2c2eb122010-10-16 06:59:13 +00004787 TemplateParamLists.get(),
4788 TemplateParamLists.size(),
4789 isFriend,
4790 isExplicitSpecialization,
4791 Invalid)) {
Abramo Bagnara60804e12011-03-18 15:16:37 +00004792 if (TemplateParams->size() > 0) {
4793 // This is a function template
Abramo Bagnarada41d0c2010-06-12 08:15:14 +00004794
Abramo Bagnara60804e12011-03-18 15:16:37 +00004795 // Check that we can declare a template here.
4796 if (CheckTemplateDeclScope(S, TemplateParams))
4797 return 0;
Mike Stump11289f42009-09-09 15:08:12 +00004798
Abramo Bagnara60804e12011-03-18 15:16:37 +00004799 // A destructor cannot be a template.
4800 if (Name.getNameKind() == DeclarationName::CXXDestructorName) {
4801 Diag(NewFD->getLocation(), diag::err_destructor_template);
4802 return 0;
John McCall1f0479e2010-03-24 08:27:58 +00004803 }
Douglas Gregor041b0842011-10-14 15:31:12 +00004804
4805 // If we're adding a template to a dependent context, we may need to
4806 // rebuilding some of the types used within the template parameter list,
4807 // now that we know what the current instantiation is.
4808 if (DC->isDependentContext()) {
4809 ContextRAII SavedContext(*this, DC);
4810 if (RebuildTemplateParamsInCurrentInstantiation(TemplateParams))
4811 Invalid = true;
4812 }
4813
John McCall1f0479e2010-03-24 08:27:58 +00004814
Abramo Bagnara60804e12011-03-18 15:16:37 +00004815 FunctionTemplate = FunctionTemplateDecl::Create(Context, DC,
4816 NewFD->getLocation(),
4817 Name, TemplateParams,
4818 NewFD);
4819 FunctionTemplate->setLexicalDeclContext(CurContext);
4820 NewFD->setDescribedFunctionTemplate(FunctionTemplate);
4821
4822 // For source fidelity, store the other template param lists.
4823 if (TemplateParamLists.size() > 1) {
4824 NewFD->setTemplateParameterListsInfo(Context,
4825 TemplateParamLists.size() - 1,
4826 TemplateParamLists.release());
4827 }
4828 } else {
4829 // This is a function template specialization.
4830 isFunctionTemplateSpecialization = true;
4831 // For source fidelity, store all the template param lists.
4832 NewFD->setTemplateParameterListsInfo(Context,
4833 TemplateParamLists.size(),
4834 TemplateParamLists.release());
4835
4836 // C++0x [temp.expl.spec]p20 forbids "template<> friend void foo(int);".
4837 if (isFriend) {
4838 // We want to remove the "template<>", found here.
4839 SourceRange RemoveRange = TemplateParams->getSourceRange();
4840
4841 // If we remove the template<> and the name is not a
4842 // template-id, we're actually silently creating a problem:
4843 // the friend declaration will refer to an untemplated decl,
4844 // and clearly the user wants a template specialization. So
4845 // we need to insert '<>' after the name.
4846 SourceLocation InsertLoc;
4847 if (D.getName().getKind() != UnqualifiedId::IK_TemplateId) {
4848 InsertLoc = D.getName().getSourceRange().getEnd();
4849 InsertLoc = PP.getLocForEndOfToken(InsertLoc);
4850 }
4851
4852 Diag(D.getIdentifierLoc(), diag::err_template_spec_decl_friend)
4853 << Name << RemoveRange
4854 << FixItHint::CreateRemoval(RemoveRange)
4855 << FixItHint::CreateInsertion(InsertLoc, "<>");
4856 }
4857 }
4858 }
4859 else {
4860 // All template param lists were matched against the scope specifier:
4861 // this is NOT (an explicit specialization of) a template.
4862 if (TemplateParamLists.size() > 0)
4863 // For source fidelity, store all the template param lists.
4864 NewFD->setTemplateParameterListsInfo(Context,
4865 TemplateParamLists.size(),
4866 TemplateParamLists.release());
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00004867 }
4868
4869 if (Invalid) {
4870 NewFD->setInvalidDecl();
4871 if (FunctionTemplate)
4872 FunctionTemplate->setInvalidDecl();
4873 }
Kaelyn Uhraine1a9ff72011-10-11 00:28:49 +00004874
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00004875 // C++ [dcl.fct.spec]p5:
4876 // The virtual specifier shall only be used in declarations of
4877 // nonstatic class member functions that appear within a
4878 // member-specification of a class declaration; see 10.3.
4879 //
4880 if (isVirtual && !NewFD->isInvalidDecl()) {
4881 if (!isVirtualOkay) {
4882 Diag(D.getDeclSpec().getVirtualSpecLoc(),
4883 diag::err_virtual_non_function);
4884 } else if (!CurContext->isRecord()) {
4885 // 'virtual' was specified outside of the class.
Anders Carlssone9738992011-01-22 14:43:56 +00004886 Diag(D.getDeclSpec().getVirtualSpecLoc(),
4887 diag::err_virtual_out_of_class)
4888 << FixItHint::CreateRemoval(D.getDeclSpec().getVirtualSpecLoc());
4889 } else if (NewFD->getDescribedFunctionTemplate()) {
4890 // C++ [temp.mem]p3:
4891 // A member function template shall not be virtual.
4892 Diag(D.getDeclSpec().getVirtualSpecLoc(),
4893 diag::err_virtual_member_function_template)
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00004894 << FixItHint::CreateRemoval(D.getDeclSpec().getVirtualSpecLoc());
4895 } else {
4896 // Okay: Add virtual to the method.
4897 NewFD->setVirtualAsWritten(true);
John McCall816d75b2010-03-24 07:46:06 +00004898 }
Douglas Gregorc1da0f02009-06-24 00:23:40 +00004899 }
Abramo Bagnarada41d0c2010-06-12 08:15:14 +00004900
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00004901 // C++ [dcl.fct.spec]p3:
4902 // The inline specifier shall not appear on a block scope function declaration.
4903 if (isInline && !NewFD->isInvalidDecl()) {
4904 if (CurContext->isFunctionOrMethod()) {
4905 // 'inline' is not allowed on block scope function declaration.
4906 Diag(D.getDeclSpec().getInlineSpecLoc(),
4907 diag::err_inline_declaration_block_scope) << Name
4908 << FixItHint::CreateRemoval(D.getDeclSpec().getInlineSpecLoc());
4909 }
4910 }
Kaelyn Uhraine1a9ff72011-10-11 00:28:49 +00004911
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00004912 // C++ [dcl.fct.spec]p6:
4913 // The explicit specifier shall be used only in the declaration of a
4914 // constructor or conversion function within its class definition; see 12.3.1
4915 // and 12.3.2.
4916 if (isExplicit && !NewFD->isInvalidDecl()) {
4917 if (!CurContext->isRecord()) {
4918 // 'explicit' was specified outside of the class.
4919 Diag(D.getDeclSpec().getExplicitSpecLoc(),
4920 diag::err_explicit_out_of_class)
4921 << FixItHint::CreateRemoval(D.getDeclSpec().getExplicitSpecLoc());
4922 } else if (!isa<CXXConstructorDecl>(NewFD) &&
4923 !isa<CXXConversionDecl>(NewFD)) {
4924 // 'explicit' was specified on a function that wasn't a constructor
4925 // or conversion function.
4926 Diag(D.getDeclSpec().getExplicitSpecLoc(),
4927 diag::err_explicit_non_ctor_or_conv_function)
4928 << FixItHint::CreateRemoval(D.getDeclSpec().getExplicitSpecLoc());
4929 }
4930 }
Abramo Bagnarada41d0c2010-06-12 08:15:14 +00004931
Richard Smitha77a0a62011-08-15 21:04:07 +00004932 if (isConstexpr) {
4933 // C++0x [dcl.constexpr]p2: constexpr functions and constexpr constructors
4934 // are implicitly inline.
4935 NewFD->setImplicitlyInline();
4936
Richard Smitha77a0a62011-08-15 21:04:07 +00004937 // C++0x [dcl.constexpr]p3: functions declared constexpr are required to
4938 // be either constructors or to return a literal type. Therefore,
4939 // destructors cannot be declared constexpr.
4940 if (isa<CXXDestructorDecl>(NewFD))
Richard Smitheb3c10c2011-10-01 02:31:28 +00004941 Diag(D.getDeclSpec().getConstexprSpecLoc(), diag::err_constexpr_dtor);
Richard Smitha77a0a62011-08-15 21:04:07 +00004942 }
4943
Douglas Gregor26701a42011-09-09 02:06:17 +00004944 // If __module_private__ was specified, mark the function accordingly.
4945 if (D.getDeclSpec().isModulePrivateSpecified()) {
Douglas Gregor3c7cd6a2011-09-09 20:53:38 +00004946 if (isFunctionTemplateSpecialization) {
4947 SourceLocation ModulePrivateLoc
4948 = D.getDeclSpec().getModulePrivateSpecLoc();
4949 Diag(ModulePrivateLoc, diag::err_module_private_specialization)
4950 << 0
4951 << FixItHint::CreateRemoval(ModulePrivateLoc);
4952 } else {
4953 NewFD->setModulePrivate();
4954 if (FunctionTemplate)
4955 FunctionTemplate->setModulePrivate();
4956 }
Douglas Gregor26701a42011-09-09 02:06:17 +00004957 }
Richard Smitha77a0a62011-08-15 21:04:07 +00004958
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00004959 if (isFriend) {
4960 // For now, claim that the objects have no previous declaration.
4961 if (FunctionTemplate) {
4962 FunctionTemplate->setObjectOfFriendDecl(false);
4963 FunctionTemplate->setAccess(AS_public);
4964 }
4965 NewFD->setObjectOfFriendDecl(false);
4966 NewFD->setAccess(AS_public);
4967 }
4968
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00004969 if (isa<CXXMethodDecl>(NewFD) && DC == CurContext &&
4970 D.isFunctionDefinition()) {
John McCall357d0f32010-12-15 04:00:32 +00004971 // A method is implicitly inline if it's defined in its class
4972 // definition.
4973 NewFD->setImplicitlyInline();
4974 }
4975
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00004976 if (SC == SC_Static && isa<CXXMethodDecl>(NewFD) &&
4977 !CurContext->isRecord()) {
4978 // C++ [class.static]p1:
4979 // A data or function member of a class may be declared static
4980 // in a class definition, in which case it is a static member of
4981 // the class.
4982
4983 // Complain about the 'static' specifier if it's on an out-of-line
4984 // member function definition.
4985 Diag(D.getDeclSpec().getStorageClassSpecLoc(),
4986 diag::err_static_out_of_line)
4987 << FixItHint::CreateRemoval(D.getDeclSpec().getStorageClassSpecLoc());
4988 }
Douglas Gregor5f0e2522010-07-14 23:14:12 +00004989 }
Kaelyn Uhraine1a9ff72011-10-11 00:28:49 +00004990
4991 // Filter out previous declarations that don't match the scope.
4992 FilterLookupForScope(Previous, DC, S, NewFD->hasLinkage(),
4993 isExplicitSpecialization ||
4994 isFunctionTemplateSpecialization);
Douglas Gregor5f0e2522010-07-14 23:14:12 +00004995
Zhongxing Xubece5d62009-01-16 01:13:29 +00004996 // Handle GNU asm-label extension (encoded as an attribute).
4997 if (Expr *E = (Expr*) D.getAsmLabel()) {
4998 // The parser guarantees this is a string.
Mike Stump11289f42009-09-09 15:08:12 +00004999 StringLiteral *SE = cast<StringLiteral>(E);
Alexis Huntdcfba7b2010-08-18 23:23:40 +00005000 NewFD->addAttr(::new (Context) AsmLabelAttr(SE->getStrTokenLoc(0), Context,
5001 SE->getString()));
Zhongxing Xubece5d62009-01-16 01:13:29 +00005002 }
5003
Chris Lattner9af40c12009-04-25 06:12:16 +00005004 // Copy the parameter declarations from the declarator D to the function
5005 // declaration NewFD, if they are available. First scavenge them into Params.
Chris Lattner0e62c1c2011-07-23 10:55:15 +00005006 SmallVector<ParmVarDecl*, 16> Params;
Abramo Bagnara6d810632010-12-14 22:11:44 +00005007 if (D.isFunctionDeclarator()) {
Abramo Bagnara924a8f32010-12-10 16:29:40 +00005008 DeclaratorChunk::FunctionTypeInfo &FTI = D.getFunctionTypeInfo();
Zhongxing Xubece5d62009-01-16 01:13:29 +00005009
Zhongxing Xubece5d62009-01-16 01:13:29 +00005010 // Check for C99 6.7.5.3p10 - foo(void) is a non-varargs
5011 // function that takes no arguments, not a function that takes a
5012 // single void argument.
5013 // We let through "const void" here because Sema::GetTypeForDeclarator
5014 // already checks for that case.
5015 if (FTI.NumArgs == 1 && !FTI.isVariadic && FTI.ArgInfo[0].Ident == 0 &&
5016 FTI.ArgInfo[0].Param &&
John McCall48871652010-08-21 09:40:31 +00005017 cast<ParmVarDecl>(FTI.ArgInfo[0].Param)->getType()->isVoidType()) {
Chris Lattner9af40c12009-04-25 06:12:16 +00005018 // Empty arg list, don't push any params.
John McCall48871652010-08-21 09:40:31 +00005019 ParmVarDecl *Param = cast<ParmVarDecl>(FTI.ArgInfo[0].Param);
Zhongxing Xubece5d62009-01-16 01:13:29 +00005020
5021 // In C++, the empty parameter-type-list must be spelled "void"; a
5022 // typedef of void is not permitted.
5023 if (getLangOptions().CPlusPlus &&
Richard Smithdda56e42011-04-15 14:24:37 +00005024 Param->getType().getUnqualifiedType() != Context.VoidTy) {
5025 bool IsTypeAlias = false;
5026 if (const TypedefType *TT = Param->getType()->getAs<TypedefType>())
5027 IsTypeAlias = isa<TypeAliasDecl>(TT->getDecl());
Richard Smith3f1b5d02011-05-05 21:57:07 +00005028 else if (const TemplateSpecializationType *TST =
5029 Param->getType()->getAs<TemplateSpecializationType>())
5030 IsTypeAlias = TST->isTypeAlias();
Richard Smithdda56e42011-04-15 14:24:37 +00005031 Diag(Param->getLocation(), diag::err_param_typedef_of_void)
5032 << IsTypeAlias;
5033 }
Zhongxing Xubece5d62009-01-16 01:13:29 +00005034 } else if (FTI.NumArgs > 0 && FTI.ArgInfo[0].Param != 0) {
Argyrios Kyrtzidis11a846a2009-07-14 03:18:53 +00005035 for (unsigned i = 0, e = FTI.NumArgs; i != e; ++i) {
John McCall48871652010-08-21 09:40:31 +00005036 ParmVarDecl *Param = cast<ParmVarDecl>(FTI.ArgInfo[i].Param);
Argyrios Kyrtzidis11a846a2009-07-14 03:18:53 +00005037 assert(Param->getDeclContext() != NewFD && "Was set before ?");
5038 Param->setDeclContext(NewFD);
5039 Params.push_back(Param);
John McCallb7238602010-04-14 01:27:20 +00005040
5041 if (Param->isInvalidDecl())
5042 NewFD->setInvalidDecl();
Argyrios Kyrtzidis11a846a2009-07-14 03:18:53 +00005043 }
Zhongxing Xubece5d62009-01-16 01:13:29 +00005044 }
Mike Stump11289f42009-09-09 15:08:12 +00005045
John McCall9dd450b2009-09-21 23:43:11 +00005046 } else if (const FunctionProtoType *FT = R->getAs<FunctionProtoType>()) {
Chris Lattner47c0d002009-04-25 06:03:53 +00005047 // When we're declaring a function with a typedef, typeof, etc as in the
Zhongxing Xubece5d62009-01-16 01:13:29 +00005048 // following example, we'll need to synthesize (unnamed)
5049 // parameters for use in the declaration.
5050 //
5051 // @code
5052 // typedef void fn(int);
5053 // fn f;
5054 // @endcode
Mike Stump11289f42009-09-09 15:08:12 +00005055
Chris Lattner47c0d002009-04-25 06:03:53 +00005056 // Synthesize a parameter for each argument type.
Chris Lattner47c0d002009-04-25 06:03:53 +00005057 for (FunctionProtoType::arg_type_iterator AI = FT->arg_type_begin(),
5058 AE = FT->arg_type_end(); AI != AE; ++AI) {
John McCalla3ccba02010-06-04 11:21:44 +00005059 ParmVarDecl *Param =
5060 BuildParmVarDeclForTypedef(NewFD, D.getIdentifierLoc(), *AI);
John McCall8fb0d9d2011-05-01 22:35:37 +00005061 Param->setScopeInfo(0, Params.size());
Chris Lattner47c0d002009-04-25 06:03:53 +00005062 Params.push_back(Param);
Zhongxing Xubece5d62009-01-16 01:13:29 +00005063 }
Chris Lattner49303b22009-04-25 18:38:18 +00005064 } else {
5065 assert(R->isFunctionNoProtoType() && NewFD->getNumParams() == 0 &&
5066 "Should not need args for typedef of non-prototype fn");
Zhongxing Xubece5d62009-01-16 01:13:29 +00005067 }
Chris Lattner9af40c12009-04-25 06:12:16 +00005068 // Finally, we know we have the right number of parameters, install them.
David Blaikie9c70e042011-09-21 18:16:56 +00005069 NewFD->setParams(Params);
Mike Stump11289f42009-09-09 15:08:12 +00005070
Peter Collingbourne9f2a9902011-01-21 02:08:54 +00005071 // Process the non-inheritable attributes on this declaration.
5072 ProcessDeclAttributes(S, NewFD, D,
5073 /*NonInheritable=*/true, /*Inheritable=*/false);
5074
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00005075 if (!getLangOptions().CPlusPlus) {
5076 // Perform semantic checking on the function declaration.
Douglas Gregor522d5eb2011-06-06 15:22:55 +00005077 bool isExplicitSpecialization=false;
David Blaikied937bf12011-09-08 06:33:04 +00005078 if (!NewFD->isInvalidDecl()) {
5079 if (NewFD->getResultType()->isVariablyModifiedType()) {
5080 // Functions returning a variably modified type violate C99 6.7.5.2p2
5081 // because all functions have linkage.
5082 Diag(NewFD->getLocation(), diag::err_vm_func_decl);
5083 NewFD->setInvalidDecl();
5084 } else {
5085 if (NewFD->isMain())
5086 CheckMain(NewFD, D.getDeclSpec());
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00005087 D.setRedeclaration(CheckFunctionDeclaration(S, NewFD, Previous,
5088 isExplicitSpecialization));
David Blaikied937bf12011-09-08 06:33:04 +00005089 }
5090 }
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00005091 assert((NewFD->isInvalidDecl() || !D.isRedeclaration() ||
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00005092 Previous.getResultKind() != LookupResult::FoundOverloaded) &&
5093 "previous declaration set still overloaded");
5094 } else {
5095 // If the declarator is a template-id, translate the parser's template
5096 // argument list into our AST format.
5097 bool HasExplicitTemplateArgs = false;
5098 TemplateArgumentListInfo TemplateArgs;
5099 if (D.getName().getKind() == UnqualifiedId::IK_TemplateId) {
5100 TemplateIdAnnotation *TemplateId = D.getName().TemplateId;
5101 TemplateArgs.setLAngleLoc(TemplateId->LAngleLoc);
5102 TemplateArgs.setRAngleLoc(TemplateId->RAngleLoc);
5103 ASTTemplateArgsPtr TemplateArgsPtr(*this,
5104 TemplateId->getTemplateArgs(),
5105 TemplateId->NumArgs);
5106 translateTemplateArguments(TemplateArgsPtr,
5107 TemplateArgs);
5108 TemplateArgsPtr.release();
Douglas Gregor0e876e02009-09-25 23:53:26 +00005109
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00005110 HasExplicitTemplateArgs = true;
Douglas Gregor0e876e02009-09-25 23:53:26 +00005111
Douglas Gregor522d5eb2011-06-06 15:22:55 +00005112 if (NewFD->isInvalidDecl()) {
5113 HasExplicitTemplateArgs = false;
5114 } else if (FunctionTemplate) {
Douglas Gregora5f6f9c2011-01-24 18:54:39 +00005115 // Function template with explicit template arguments.
5116 Diag(D.getIdentifierLoc(), diag::err_function_template_partial_spec)
5117 << SourceRange(TemplateId->LAngleLoc, TemplateId->RAngleLoc);
5118
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00005119 HasExplicitTemplateArgs = false;
5120 } else if (!isFunctionTemplateSpecialization &&
5121 !D.getDeclSpec().isFriendSpecified()) {
5122 // We have encountered something that the user meant to be a
5123 // specialization (because it has explicitly-specified template
5124 // arguments) but that was not introduced with a "template<>" (or had
5125 // too few of them).
5126 Diag(D.getIdentifierLoc(), diag::err_template_spec_needs_header)
5127 << SourceRange(TemplateId->LAngleLoc, TemplateId->RAngleLoc)
5128 << FixItHint::CreateInsertion(
5129 D.getDeclSpec().getSourceRange().getBegin(),
5130 "template<> ");
5131 isFunctionTemplateSpecialization = true;
John McCallf7cfb222010-10-13 05:45:15 +00005132 } else {
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00005133 // "friend void foo<>(int);" is an implicit specialization decl.
5134 isFunctionTemplateSpecialization = true;
Francois Pichet6d76e6c2010-10-01 21:19:28 +00005135 }
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00005136 } else if (isFriend && isFunctionTemplateSpecialization) {
5137 // This combination is only possible in a recovery case; the user
5138 // wrote something like:
5139 // template <> friend void foo(int);
5140 // which we're recovering from as if the user had written:
5141 // friend void foo<>(int);
5142 // Go ahead and fake up a template id.
5143 HasExplicitTemplateArgs = true;
5144 TemplateArgs.setLAngleLoc(D.getIdentifierLoc());
5145 TemplateArgs.setRAngleLoc(D.getIdentifierLoc());
Douglas Gregorf4f296d2009-03-23 23:06:20 +00005146 }
John McCallf7cfb222010-10-13 05:45:15 +00005147
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00005148 // If it's a friend (and only if it's a friend), it's possible
5149 // that either the specialized function type or the specialized
5150 // template is dependent, and therefore matching will fail. In
5151 // this case, don't check the specialization yet.
Douglas Gregore9d075e2011-10-09 20:59:17 +00005152 bool InstantiationDependent = false;
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00005153 if (isFunctionTemplateSpecialization && isFriend &&
Douglas Gregore9d075e2011-10-09 20:59:17 +00005154 (NewFD->getType()->isDependentType() || DC->isDependentContext() ||
5155 TemplateSpecializationType::anyDependentTemplateArguments(
5156 TemplateArgs.getArgumentArray(), TemplateArgs.size(),
5157 InstantiationDependent))) {
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00005158 assert(HasExplicitTemplateArgs &&
5159 "friend function specialization without template args");
5160 if (CheckDependentFunctionTemplateSpecialization(NewFD, TemplateArgs,
5161 Previous))
5162 NewFD->setInvalidDecl();
5163 } else if (isFunctionTemplateSpecialization) {
Douglas Gregor63fab342011-03-16 19:27:09 +00005164 if (CurContext->isDependentContext() && CurContext->isRecord()
Francois Pichetb5037052011-06-03 13:59:45 +00005165 && !isFriend) {
Francois Pichet00c7e6c2011-08-14 03:52:19 +00005166 isDependentClassScopeExplicitSpecialization = true;
Francois Pichet0706d202011-09-17 17:15:52 +00005167 Diag(NewFD->getLocation(), getLangOptions().MicrosoftExt ?
Francois Pichet00c7e6c2011-08-14 03:52:19 +00005168 diag::ext_function_specialization_in_class :
5169 diag::err_function_specialization_in_class)
Douglas Gregor63fab342011-03-16 19:27:09 +00005170 << NewFD->getDeclName();
Douglas Gregor63fab342011-03-16 19:27:09 +00005171 } else if (CheckFunctionTemplateSpecialization(NewFD,
5172 (HasExplicitTemplateArgs ? &TemplateArgs : 0),
5173 Previous))
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00005174 NewFD->setInvalidDecl();
Douglas Gregor781ba6e2011-05-21 18:53:30 +00005175
5176 // C++ [dcl.stc]p1:
5177 // A storage-class-specifier shall not be specified in an explicit
5178 // specialization (14.7.3)
5179 if (SC != SC_None) {
Douglas Gregor84265a02011-06-17 05:09:08 +00005180 if (SC != NewFD->getStorageClass())
5181 Diag(NewFD->getLocation(),
5182 diag::err_explicit_specialization_inconsistent_storage_class)
5183 << SC
5184 << FixItHint::CreateRemoval(
5185 D.getDeclSpec().getStorageClassSpecLoc());
5186
5187 else
5188 Diag(NewFD->getLocation(),
5189 diag::ext_explicit_specialization_storage_class)
5190 << FixItHint::CreateRemoval(
5191 D.getDeclSpec().getStorageClassSpecLoc());
Douglas Gregor781ba6e2011-05-21 18:53:30 +00005192 }
5193
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00005194 } else if (isExplicitSpecialization && isa<CXXMethodDecl>(NewFD)) {
5195 if (CheckMemberSpecialization(NewFD, Previous))
5196 NewFD->setInvalidDecl();
5197 }
Douglas Gregorf4f296d2009-03-23 23:06:20 +00005198
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00005199 // Perform semantic checking on the function declaration.
David Blaikied937bf12011-09-08 06:33:04 +00005200 if (!isDependentClassScopeExplicitSpecialization) {
5201 if (NewFD->isInvalidDecl()) {
5202 // If this is a class member, mark the class invalid immediately.
5203 // This avoids some consistency errors later.
5204 if (CXXMethodDecl* methodDecl = dyn_cast<CXXMethodDecl>(NewFD))
5205 methodDecl->getParent()->setInvalidDecl();
5206 } else {
5207 if (NewFD->isMain())
5208 CheckMain(NewFD, D.getDeclSpec());
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00005209 D.setRedeclaration(CheckFunctionDeclaration(S, NewFD, Previous,
5210 isExplicitSpecialization));
David Blaikied937bf12011-09-08 06:33:04 +00005211 }
5212 }
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00005213
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00005214 assert((NewFD->isInvalidDecl() || !D.isRedeclaration() ||
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00005215 Previous.getResultKind() != LookupResult::FoundOverloaded) &&
5216 "previous declaration set still overloaded");
5217
Richard Smitheb3c10c2011-10-01 02:31:28 +00005218 if (NewFD->isConstexpr() && !NewFD->isInvalidDecl() &&
5219 !CheckConstexprFunctionDecl(NewFD, CCK_Declaration))
5220 NewFD->setInvalidDecl();
5221
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00005222 NamedDecl *PrincipalDecl = (FunctionTemplate
5223 ? cast<NamedDecl>(FunctionTemplate)
5224 : NewFD);
5225
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00005226 if (isFriend && D.isRedeclaration()) {
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00005227 AccessSpecifier Access = AS_public;
5228 if (!NewFD->isInvalidDecl())
5229 Access = NewFD->getPreviousDeclaration()->getAccess();
5230
5231 NewFD->setAccess(Access);
5232 if (FunctionTemplate) FunctionTemplate->setAccess(Access);
5233
5234 PrincipalDecl->setObjectOfFriendDecl(true);
5235 }
5236
5237 if (NewFD->isOverloadedOperator() && !DC->isRecord() &&
5238 PrincipalDecl->isInIdentifierNamespace(Decl::IDNS_Ordinary))
5239 PrincipalDecl->setNonMemberOperator();
5240
5241 // If we have a function template, check the template parameter
5242 // list. This will check and merge default template arguments.
5243 if (FunctionTemplate) {
5244 FunctionTemplateDecl *PrevTemplate = FunctionTemplate->getPreviousDeclaration();
5245 CheckTemplateParameterList(FunctionTemplate->getTemplateParameters(),
5246 PrevTemplate? PrevTemplate->getTemplateParameters() : 0,
Douglas Gregora99fb4c2011-02-04 04:20:44 +00005247 D.getDeclSpec().isFriendSpecified()
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00005248 ? (D.isFunctionDefinition()
Douglas Gregora99fb4c2011-02-04 04:20:44 +00005249 ? TPC_FriendFunctionTemplateDefinition
5250 : TPC_FriendFunctionTemplate)
5251 : (D.getCXXScopeSpec().isSet() &&
Douglas Gregor4d5c2972011-02-04 12:22:53 +00005252 DC && DC->isRecord() &&
5253 DC->isDependentContext())
Douglas Gregora99fb4c2011-02-04 04:20:44 +00005254 ? TPC_ClassTemplateMember
5255 : TPC_FunctionTemplate);
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00005256 }
5257
5258 if (NewFD->isInvalidDecl()) {
5259 // Ignore all the rest of this.
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00005260 } else if (!D.isRedeclaration()) {
Kaelyn Uhrain8af2c9f2011-10-11 00:28:52 +00005261 struct ActOnFDArgs ExtraArgs = { S, D, TemplateParamLists,
Kaelyn Uhrain0a32fca2011-10-11 00:28:39 +00005262 AddToScope };
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00005263 // Fake up an access specifier if it's supposed to be a class member.
5264 if (isa<CXXRecordDecl>(NewFD->getDeclContext()))
5265 NewFD->setAccess(AS_public);
5266
5267 // Qualified decls generally require a previous declaration.
5268 if (D.getCXXScopeSpec().isSet()) {
5269 // ...with the major exception of templated-scope or
5270 // dependent-scope friend declarations.
5271
5272 // TODO: we currently also suppress this check in dependent
5273 // contexts because (1) the parameter depth will be off when
5274 // matching friend templates and (2) we might actually be
5275 // selecting a friend based on a dependent factor. But there
5276 // are situations where these conditions don't apply and we
5277 // can actually do this check immediately.
5278 if (isFriend &&
Abramo Bagnara60804e12011-03-18 15:16:37 +00005279 (TemplateParamLists.size() ||
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00005280 D.getCXXScopeSpec().getScopeRep()->isDependent() ||
5281 CurContext->isDependentContext())) {
Chandler Carruthf8b554f2011-08-19 01:38:33 +00005282 // ignore these
5283 } else {
5284 // The user tried to provide an out-of-line definition for a
5285 // function that is a member of a class or namespace, but there
5286 // was no such member function declared (C++ [class.mfct]p2,
5287 // C++ [namespace.memdef]p2). For example:
5288 //
5289 // class X {
5290 // void f() const;
5291 // };
5292 //
5293 // void X::f() { } // ill-formed
5294 //
5295 // Complain about this problem, and attempt to suggest close
5296 // matches (e.g., those that differ only in cv-qualifiers and
5297 // whether the parameter types are references).
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00005298
Kaelyn Uhrain0a32fca2011-10-11 00:28:39 +00005299 if (NamedDecl *Result = DiagnoseInvalidRedeclaration(*this, Previous,
Kaelyn Uhrain8af2c9f2011-10-11 00:28:52 +00005300 NewFD,
Kaelyn Uhrain0a32fca2011-10-11 00:28:39 +00005301 ExtraArgs)) {
Kaelyn Uhrain0a32fca2011-10-11 00:28:39 +00005302 AddToScope = ExtraArgs.AddToScope;
5303 return Result;
5304 }
Chandler Carruthf8b554f2011-08-19 01:38:33 +00005305 }
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00005306
5307 // Unqualified local friend declarations are required to resolve
5308 // to something.
Chandler Carruthe92e42f2011-08-19 01:40:11 +00005309 } else if (isFriend && cast<CXXRecordDecl>(CurContext)->isLocalClass()) {
Kaelyn Uhrain0a32fca2011-10-11 00:28:39 +00005310 if (NamedDecl *Result = DiagnoseInvalidRedeclaration(*this, Previous,
Kaelyn Uhrain8af2c9f2011-10-11 00:28:52 +00005311 NewFD,
Kaelyn Uhrain0a32fca2011-10-11 00:28:39 +00005312 ExtraArgs)) {
Kaelyn Uhrain0a32fca2011-10-11 00:28:39 +00005313 AddToScope = ExtraArgs.AddToScope;
5314 return Result;
5315 }
Chandler Carruthe92e42f2011-08-19 01:40:11 +00005316 }
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00005317
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00005318 } else if (!D.isFunctionDefinition() && D.getCXXScopeSpec().isSet() &&
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00005319 !isFriend && !isFunctionTemplateSpecialization &&
Alexis Hunt5a7fa252011-05-12 06:15:49 +00005320 !isExplicitSpecialization) {
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00005321 // An out-of-line member function declaration must also be a
5322 // definition (C++ [dcl.meaning]p1).
5323 // Note that this is not the case for explicit specializations of
5324 // function templates or member functions of class templates, per
5325 // C++ [temp.expl.spec]p2. We also allow these declarations as an extension
5326 // for compatibility with old SWIG code which likes to generate them.
5327 Diag(NewFD->getLocation(), diag::ext_out_of_line_declaration)
5328 << D.getCXXScopeSpec().getRange();
5329 }
5330 }
Alexis Hunt5a7fa252011-05-12 06:15:49 +00005331
5332
Douglas Gregorf4f296d2009-03-23 23:06:20 +00005333 // Handle attributes. We need to have merged decls when handling attributes
5334 // (for example to check for conflicts, etc).
5335 // FIXME: This needs to happen before we merge declarations. Then,
5336 // let attribute merging cope with attribute conflicts.
Peter Collingbourne9f2a9902011-01-21 02:08:54 +00005337 ProcessDeclAttributes(S, NewFD, D,
5338 /*NonInheritable=*/false, /*Inheritable=*/true);
Ryan Flynne5dc8592009-07-25 22:29:44 +00005339
5340 // attributes declared post-definition are currently ignored
Alexis Huntdcfba7b2010-08-18 23:23:40 +00005341 // FIXME: This should happen during attribute merging
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00005342 if (D.isRedeclaration() && Previous.isSingleResult()) {
John McCall1f82f242009-11-18 22:49:29 +00005343 const FunctionDecl *Def;
5344 FunctionDecl *PrevFD = dyn_cast<FunctionDecl>(Previous.getFoundDecl());
Alexis Hunt4a8ea102011-05-06 20:44:56 +00005345 if (PrevFD && PrevFD->isDefined(Def) && D.hasAttributes()) {
Ryan Flynne5dc8592009-07-25 22:29:44 +00005346 Diag(NewFD->getLocation(), diag::warn_attribute_precede_definition);
5347 Diag(Def->getLocation(), diag::note_previous_definition);
5348 }
5349 }
5350
Douglas Gregorf4f296d2009-03-23 23:06:20 +00005351 AddKnownFunctionAttributes(NewFD);
5352
Douglas Gregor72609052010-08-06 13:50:58 +00005353 if (NewFD->hasAttr<OverloadableAttr>() &&
5354 !NewFD->getType()->getAs<FunctionProtoType>()) {
5355 Diag(NewFD->getLocation(),
5356 diag::err_attribute_overloadable_no_prototype)
5357 << NewFD;
5358
5359 // Turn this into a variadic function with no parameters.
5360 const FunctionType *FT = NewFD->getType()->getAs<FunctionType>();
John McCalldb40c7f2010-12-14 08:05:40 +00005361 FunctionProtoType::ExtProtoInfo EPI;
5362 EPI.Variadic = true;
5363 EPI.ExtInfo = FT->getExtInfo();
5364
5365 QualType R = Context.getFunctionType(FT->getResultType(), 0, 0, EPI);
Douglas Gregor72609052010-08-06 13:50:58 +00005366 NewFD->setType(R);
5367 }
5368
Eli Friedman570024a2010-08-05 06:57:20 +00005369 // If there's a #pragma GCC visibility in scope, and this isn't a class
5370 // member, set the visibility of this function.
5371 if (NewFD->getLinkage() == ExternalLinkage && !DC->isRecord())
5372 AddPushedVisibilityAttribute(NewFD);
5373
John McCall32f5fe12011-09-30 05:12:12 +00005374 // If there's a #pragma clang arc_cf_code_audited in scope, consider
5375 // marking the function.
5376 AddCFAuditedAttribute(NewFD);
5377
Douglas Gregorf4f296d2009-03-23 23:06:20 +00005378 // If this is a locally-scoped extern C function, update the
5379 // map of such names.
Douglas Gregor16618f22009-09-12 00:17:51 +00005380 if (CurContext->isFunctionOrMethod() && NewFD->isExternC()
Chris Lattnerf6d1c9c2009-04-25 08:06:05 +00005381 && !NewFD->isInvalidDecl())
John McCall1f82f242009-11-18 22:49:29 +00005382 RegisterLocallyScopedExternCDecl(NewFD, Previous, S);
Douglas Gregorf4f296d2009-03-23 23:06:20 +00005383
Argyrios Kyrtzidis16eecc42009-06-25 18:22:24 +00005384 // Set this FunctionDecl's range up to the right paren.
Abramo Bagnaraea947882011-03-08 16:41:52 +00005385 NewFD->setRangeEnd(D.getSourceRange().getEnd());
Argyrios Kyrtzidis16eecc42009-06-25 18:22:24 +00005386
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00005387 if (getLangOptions().CPlusPlus) {
5388 if (FunctionTemplate) {
5389 if (NewFD->isInvalidDecl())
5390 FunctionTemplate->setInvalidDecl();
5391 return FunctionTemplate;
5392 }
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00005393 }
Mike Stump11289f42009-09-09 15:08:12 +00005394
Argyrios Kyrtzidis1b30d9c2010-08-15 01:15:20 +00005395 MarkUnusedFileScopedDecl(NewFD);
Peter Collingbourne9e2c81f2011-02-09 21:04:32 +00005396
5397 if (getLangOptions().CUDA)
5398 if (IdentifierInfo *II = NewFD->getIdentifier())
5399 if (!NewFD->isInvalidDecl() &&
5400 NewFD->getDeclContext()->getRedeclContext()->isTranslationUnit()) {
5401 if (II->isStr("cudaConfigureCall")) {
5402 if (!R->getAs<FunctionType>()->getResultType()->isScalarType())
5403 Diag(NewFD->getLocation(), diag::err_config_scalar_return);
5404
5405 Context.setcudaConfigureCallDecl(NewFD);
5406 }
5407 }
Francois Pichet00c7e6c2011-08-14 03:52:19 +00005408
5409 // Here we have an function template explicit specialization at class scope.
5410 // The actually specialization will be postponed to template instatiation
5411 // time via the ClassScopeFunctionSpecializationDecl node.
5412 if (isDependentClassScopeExplicitSpecialization) {
5413 ClassScopeFunctionSpecializationDecl *NewSpec =
5414 ClassScopeFunctionSpecializationDecl::Create(
5415 Context, CurContext, SourceLocation(),
5416 cast<CXXMethodDecl>(NewFD));
5417 CurContext->addDecl(NewSpec);
5418 AddToScope = false;
5419 }
Peter Collingbourne9e2c81f2011-02-09 21:04:32 +00005420
Douglas Gregorf4f296d2009-03-23 23:06:20 +00005421 return NewFD;
5422}
5423
5424/// \brief Perform semantic checking of a new function declaration.
5425///
5426/// Performs semantic analysis of the new function declaration
5427/// NewFD. This routine performs all semantic checking that does not
5428/// require the actual declarator involved in the declaration, and is
5429/// used both for the declaration of functions as they are parsed
5430/// (called via ActOnDeclarator) and for the declaration of functions
5431/// that have been instantiated via C++ template instantiation (called
5432/// via InstantiateDecl).
5433///
Douglas Gregorcf915552009-10-13 16:30:37 +00005434/// \param IsExplicitSpecialiation whether this new function declaration is
5435/// an explicit specialization of the previous declaration.
5436///
Chris Lattnerf6d1c9c2009-04-25 08:06:05 +00005437/// This sets NewFD->isInvalidDecl() to true if there was an error.
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00005438///
5439/// Returns true if the function declaration is a redeclaration.
5440bool Sema::CheckFunctionDeclaration(Scope *S, FunctionDecl *NewFD,
John McCall1f82f242009-11-18 22:49:29 +00005441 LookupResult &Previous,
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00005442 bool IsExplicitSpecialization) {
David Blaikied937bf12011-09-08 06:33:04 +00005443 assert(!NewFD->getResultType()->isVariablyModifiedType()
5444 && "Variably modified return types are not handled here");
John McCalld9baf6a2009-07-24 03:03:21 +00005445
Douglas Gregorf4f296d2009-03-23 23:06:20 +00005446 // Check for a previous declaration of this name.
John McCall1f82f242009-11-18 22:49:29 +00005447 if (Previous.empty() && NewFD->isExternC()) {
Douglas Gregor5a80bd12009-03-02 00:19:53 +00005448 // Since we did not find anything by this name and we're declaring
5449 // an extern "C" function, look for a non-visible extern "C"
5450 // declaration with the same name.
5451 llvm::DenseMap<DeclarationName, NamedDecl *>::iterator Pos
Douglas Gregordc5c9582011-07-28 14:20:37 +00005452 = findLocallyScopedExternalDecl(NewFD->getDeclName());
Douglas Gregor5a80bd12009-03-02 00:19:53 +00005453 if (Pos != LocallyScopedExternalDecls.end())
John McCall1f82f242009-11-18 22:49:29 +00005454 Previous.addDecl(Pos->second);
Douglas Gregor5a80bd12009-03-02 00:19:53 +00005455 }
5456
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00005457 bool Redeclaration = false;
5458
Douglas Gregore62c0a42009-02-24 01:23:02 +00005459 // Merge or overload the declaration with an existing declaration of
5460 // the same name, if appropriate.
John McCall1f82f242009-11-18 22:49:29 +00005461 if (!Previous.empty()) {
Douglas Gregor4e5cbdc2009-02-11 23:02:49 +00005462 // Determine whether NewFD is an overload of PrevDecl or
Zhongxing Xubece5d62009-01-16 01:13:29 +00005463 // a declaration that requires merging. If it's an overload,
5464 // there's no more work to do here; we'll just add the new
5465 // function to the scope.
Douglas Gregor633b7372009-02-13 00:26:38 +00005466
John McCall1f82f242009-11-18 22:49:29 +00005467 NamedDecl *OldDecl = 0;
John McCalldaa3d6b2009-12-09 03:35:25 +00005468 if (!AllowOverloadingOfFunction(Previous, Context)) {
5469 Redeclaration = true;
5470 OldDecl = Previous.getFoundDecl();
5471 } else {
John McCalle9cccd82010-06-16 08:42:20 +00005472 switch (CheckOverload(S, NewFD, Previous, OldDecl,
5473 /*NewIsUsingDecl*/ false)) {
John McCalldaa3d6b2009-12-09 03:35:25 +00005474 case Ovl_Match:
John McCall84d87672009-12-10 09:41:52 +00005475 Redeclaration = true;
John McCalldaa3d6b2009-12-09 03:35:25 +00005476 break;
5477
5478 case Ovl_NonFunction:
5479 Redeclaration = true;
5480 break;
5481
5482 case Ovl_Overload:
5483 Redeclaration = false;
5484 break;
John McCall1f82f242009-11-18 22:49:29 +00005485 }
Peter Collingbourne9f2a9902011-01-21 02:08:54 +00005486
5487 if (!getLangOptions().CPlusPlus && !NewFD->hasAttr<OverloadableAttr>()) {
5488 // If a function name is overloadable in C, then every function
5489 // with that name must be marked "overloadable".
5490 Diag(NewFD->getLocation(), diag::err_attribute_overloadable_missing)
5491 << Redeclaration << NewFD;
5492 NamedDecl *OverloadedDecl = 0;
5493 if (Redeclaration)
5494 OverloadedDecl = OldDecl;
5495 else if (!Previous.empty())
5496 OverloadedDecl = Previous.getRepresentativeDecl();
5497 if (OverloadedDecl)
5498 Diag(OverloadedDecl->getLocation(),
5499 diag::note_attribute_overloadable_prev_overload);
5500 NewFD->addAttr(::new (Context) OverloadableAttr(SourceLocation(),
5501 Context));
5502 }
John McCall1f82f242009-11-18 22:49:29 +00005503 }
Zhongxing Xubece5d62009-01-16 01:13:29 +00005504
John McCall1f82f242009-11-18 22:49:29 +00005505 if (Redeclaration) {
Douglas Gregorf4f296d2009-03-23 23:06:20 +00005506 // NewFD and OldDecl represent declarations that need to be
Mike Stump11289f42009-09-09 15:08:12 +00005507 // merged.
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00005508 if (MergeFunctionDecl(NewFD, OldDecl)) {
5509 NewFD->setInvalidDecl();
5510 return Redeclaration;
5511 }
Zhongxing Xubece5d62009-01-16 01:13:29 +00005512
John McCall1f82f242009-11-18 22:49:29 +00005513 Previous.clear();
5514 Previous.addDecl(OldDecl);
5515
Douglas Gregorad3f2fc2009-06-25 22:08:12 +00005516 if (FunctionTemplateDecl *OldTemplateDecl
Douglas Gregorca027af2009-10-12 22:27:17 +00005517 = dyn_cast<FunctionTemplateDecl>(OldDecl)) {
Douglas Gregorcf915552009-10-13 16:30:37 +00005518 NewFD->setPreviousDeclaration(OldTemplateDecl->getTemplatedDecl());
Douglas Gregorca027af2009-10-12 22:27:17 +00005519 FunctionTemplateDecl *NewTemplateDecl
5520 = NewFD->getDescribedFunctionTemplate();
5521 assert(NewTemplateDecl && "Template/non-template mismatch");
5522 if (CXXMethodDecl *Method
5523 = dyn_cast<CXXMethodDecl>(NewTemplateDecl->getTemplatedDecl())) {
5524 Method->setAccess(OldTemplateDecl->getAccess());
5525 NewTemplateDecl->setAccess(OldTemplateDecl->getAccess());
5526 }
Douglas Gregorcf915552009-10-13 16:30:37 +00005527
5528 // If this is an explicit specialization of a member that is a function
5529 // template, mark it as a member specialization.
5530 if (IsExplicitSpecialization &&
5531 NewTemplateDecl->getInstantiatedFromMemberTemplate()) {
5532 NewTemplateDecl->setMemberSpecialization();
5533 assert(OldTemplateDecl->isMemberSpecialization());
5534 }
Douglas Gregoref15bdb2011-09-09 18:32:39 +00005535
5536 if (OldTemplateDecl->isModulePrivate())
5537 NewTemplateDecl->setModulePrivate();
5538
Douglas Gregorca027af2009-10-12 22:27:17 +00005539 } else {
Argyrios Kyrtzidis11a846a2009-07-14 03:18:53 +00005540 if (isa<CXXMethodDecl>(NewFD)) // Set access for out-of-line definitions
5541 NewFD->setAccess(OldDecl->getAccess());
Douglas Gregorad3f2fc2009-06-25 22:08:12 +00005542 NewFD->setPreviousDeclaration(cast<FunctionDecl>(OldDecl));
Argyrios Kyrtzidis11a846a2009-07-14 03:18:53 +00005543 }
Zhongxing Xubece5d62009-01-16 01:13:29 +00005544 }
Douglas Gregor8af63e42009-02-06 17:46:57 +00005545 }
Zhongxing Xubece5d62009-01-16 01:13:29 +00005546
Anders Carlsson1b12ed42009-09-13 21:33:06 +00005547 // Semantic checking for this function declaration (in isolation).
5548 if (getLangOptions().CPlusPlus) {
5549 // C++-specific checks.
5550 if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(NewFD)) {
5551 CheckConstructor(Constructor);
Anders Carlsson2a50e952009-11-15 22:49:34 +00005552 } else if (CXXDestructorDecl *Destructor =
5553 dyn_cast<CXXDestructorDecl>(NewFD)) {
5554 CXXRecordDecl *Record = Destructor->getParent();
Anders Carlsson1b12ed42009-09-13 21:33:06 +00005555 QualType ClassType = Context.getTypeDeclType(Record);
Anders Carlsson2a50e952009-11-15 22:49:34 +00005556
Douglas Gregor7454c562010-07-02 20:37:36 +00005557 // FIXME: Shouldn't we be able to perform this check even when the class
Anders Carlsson2a50e952009-11-15 22:49:34 +00005558 // type is dependent? Both gcc and edg can handle that.
Anders Carlsson1b12ed42009-09-13 21:33:06 +00005559 if (!ClassType->isDependentType()) {
5560 DeclarationName Name
5561 = Context.DeclarationNames.getCXXDestructorName(
5562 Context.getCanonicalType(ClassType));
5563 if (NewFD->getDeclName() != Name) {
5564 Diag(NewFD->getLocation(), diag::err_destructor_name);
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00005565 NewFD->setInvalidDecl();
5566 return Redeclaration;
Anders Carlsson1b12ed42009-09-13 21:33:06 +00005567 }
5568 }
Anders Carlsson1b12ed42009-09-13 21:33:06 +00005569 } else if (CXXConversionDecl *Conversion
Douglas Gregor21920e372009-12-01 17:24:26 +00005570 = dyn_cast<CXXConversionDecl>(NewFD)) {
Anders Carlsson1b12ed42009-09-13 21:33:06 +00005571 ActOnConversionDeclarator(Conversion);
Douglas Gregor21920e372009-12-01 17:24:26 +00005572 }
5573
5574 // Find any virtual functions that this function overrides.
Douglas Gregor6be3de32009-12-01 17:35:23 +00005575 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(NewFD)) {
5576 if (!Method->isFunctionTemplateSpecialization() &&
Douglas Gregor5a2bb5b2010-10-13 22:55:32 +00005577 !Method->getDescribedFunctionTemplate()) {
5578 if (AddOverriddenMethods(Method->getParent(), Method)) {
5579 // If the function was marked as "static", we have a problem.
5580 if (NewFD->getStorageClass() == SC_Static) {
5581 Diag(NewFD->getLocation(), diag::err_static_overrides_virtual)
5582 << NewFD->getDeclName();
5583 for (CXXMethodDecl::method_iterator
5584 Overridden = Method->begin_overridden_methods(),
5585 OverriddenEnd = Method->end_overridden_methods();
5586 Overridden != OverriddenEnd;
5587 ++Overridden) {
5588 Diag((*Overridden)->getLocation(),
5589 diag::note_overridden_virtual_function);
5590 }
5591 }
Argyrios Kyrtzidis7272d9c2011-02-03 18:01:15 +00005592 }
Douglas Gregor5a2bb5b2010-10-13 22:55:32 +00005593 }
Douglas Gregor6be3de32009-12-01 17:35:23 +00005594 }
Anders Carlsson1b12ed42009-09-13 21:33:06 +00005595
5596 // Extra checking for C++ overloaded operators (C++ [over.oper]).
5597 if (NewFD->isOverloadedOperator() &&
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00005598 CheckOverloadedOperatorDeclaration(NewFD)) {
5599 NewFD->setInvalidDecl();
5600 return Redeclaration;
5601 }
Alexis Huntc88db062010-01-13 09:01:02 +00005602
5603 // Extra checking for C++0x literal operators (C++0x [over.literal]).
5604 if (NewFD->getLiteralIdentifier() &&
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00005605 CheckLiteralOperatorDeclaration(NewFD)) {
5606 NewFD->setInvalidDecl();
5607 return Redeclaration;
5608 }
Alexis Huntc88db062010-01-13 09:01:02 +00005609
Anders Carlsson1b12ed42009-09-13 21:33:06 +00005610 // In C++, check default arguments now that we have merged decls. Unless
5611 // the lexical context is the class, because in this case this is done
5612 // during delayed parsing anyway.
5613 if (!CurContext->isRecord())
5614 CheckCXXDefaultArguments(NewFD);
Douglas Gregor9246b682010-12-21 19:47:46 +00005615
5616 // If this function declares a builtin function, check the type of this
5617 // declaration against the expected type for the builtin.
5618 if (unsigned BuiltinID = NewFD->getBuiltinID()) {
5619 ASTContext::GetBuiltinTypeError Error;
5620 QualType T = Context.GetBuiltinType(BuiltinID, Error);
5621 if (!T.isNull() && !Context.hasSameType(T, NewFD->getType())) {
5622 // The type of this function differs from the type of the builtin,
5623 // so forget about the builtin entirely.
5624 Context.BuiltinInfo.ForgetBuiltin(BuiltinID, Context.Idents);
5625 }
5626 }
Anders Carlsson1b12ed42009-09-13 21:33:06 +00005627 }
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00005628 return Redeclaration;
Zhongxing Xubece5d62009-01-16 01:13:29 +00005629}
5630
David Blaikied937bf12011-09-08 06:33:04 +00005631void Sema::CheckMain(FunctionDecl* FD, const DeclSpec& DS) {
John McCall02dee0a2009-07-25 04:36:53 +00005632 // C++ [basic.start.main]p3: A program that declares main to be inline
5633 // or static is ill-formed.
5634 // C99 6.7.4p4: In a hosted environment, the inline function specifier
5635 // shall not appear in a declaration of main.
5636 // static main is not an error under C99, but we should warn about it.
David Blaikied937bf12011-09-08 06:33:04 +00005637 if (FD->getStorageClass() == SC_Static)
5638 Diag(DS.getStorageClassSpecLoc(), getLangOptions().CPlusPlus
5639 ? diag::err_static_main : diag::warn_static_main)
5640 << FixItHint::CreateRemoval(DS.getStorageClassSpecLoc());
5641 if (FD->isInlineSpecified())
5642 Diag(DS.getInlineSpecLoc(), diag::err_inline_main)
5643 << FixItHint::CreateRemoval(DS.getInlineSpecLoc());
John McCall02dee0a2009-07-25 04:36:53 +00005644
5645 QualType T = FD->getType();
5646 assert(T->isFunctionType() && "function decl is not of function type");
John McCall9dd450b2009-09-21 23:43:11 +00005647 const FunctionType* FT = T->getAs<FunctionType>();
Mike Stump11289f42009-09-09 15:08:12 +00005648
John McCall02dee0a2009-07-25 04:36:53 +00005649 if (!Context.hasSameUnqualifiedType(FT->getResultType(), Context.IntTy)) {
Douglas Gregorf05c0952011-02-19 19:04:23 +00005650 Diag(FD->getTypeSpecStartLoc(), diag::err_main_returns_nonint);
John McCall02dee0a2009-07-25 04:36:53 +00005651 FD->setInvalidDecl(true);
5652 }
5653
5654 // Treat protoless main() as nullary.
5655 if (isa<FunctionNoProtoType>(FT)) return;
5656
5657 const FunctionProtoType* FTP = cast<const FunctionProtoType>(FT);
5658 unsigned nparams = FTP->getNumArgs();
5659 assert(FD->getNumParams() == nparams);
5660
John McCall0e21fcc2009-12-24 09:58:38 +00005661 bool HasExtraParameters = (nparams > 3);
5662
5663 // Darwin passes an undocumented fourth argument of type char**. If
5664 // other platforms start sprouting these, the logic below will start
5665 // getting shifty.
Douglas Gregore8bbc122011-09-02 00:18:52 +00005666 if (nparams == 4 && Context.getTargetInfo().getTriple().isOSDarwin())
John McCall0e21fcc2009-12-24 09:58:38 +00005667 HasExtraParameters = false;
5668
5669 if (HasExtraParameters) {
John McCall02dee0a2009-07-25 04:36:53 +00005670 Diag(FD->getLocation(), diag::err_main_surplus_args) << nparams;
5671 FD->setInvalidDecl(true);
5672 nparams = 3;
5673 }
5674
5675 // FIXME: a lot of the following diagnostics would be improved
5676 // if we had some location information about types.
5677
5678 QualType CharPP =
5679 Context.getPointerType(Context.getPointerType(Context.CharTy));
John McCall0e21fcc2009-12-24 09:58:38 +00005680 QualType Expected[] = { Context.IntTy, CharPP, CharPP, CharPP };
John McCall02dee0a2009-07-25 04:36:53 +00005681
5682 for (unsigned i = 0; i < nparams; ++i) {
5683 QualType AT = FTP->getArgType(i);
5684
5685 bool mismatch = true;
5686
5687 if (Context.hasSameUnqualifiedType(AT, Expected[i]))
5688 mismatch = false;
5689 else if (Expected[i] == CharPP) {
5690 // As an extension, the following forms are okay:
5691 // char const **
5692 // char const * const *
5693 // char * const *
5694
John McCall8ccfcb52009-09-24 19:53:00 +00005695 QualifierCollector qs;
John McCall02dee0a2009-07-25 04:36:53 +00005696 const PointerType* PT;
Ted Kremenekc23c7e62009-07-29 21:53:49 +00005697 if ((PT = qs.strip(AT)->getAs<PointerType>()) &&
5698 (PT = qs.strip(PT->getPointeeType())->getAs<PointerType>()) &&
John McCall02dee0a2009-07-25 04:36:53 +00005699 (QualType(qs.strip(PT->getPointeeType()), 0) == Context.CharTy)) {
5700 qs.removeConst();
5701 mismatch = !qs.empty();
5702 }
5703 }
5704
5705 if (mismatch) {
5706 Diag(FD->getLocation(), diag::err_main_arg_wrong) << i << Expected[i];
5707 // TODO: suggest replacing given type with expected type
5708 FD->setInvalidDecl(true);
5709 }
5710 }
5711
5712 if (nparams == 1 && !FD->isInvalidDecl()) {
5713 Diag(FD->getLocation(), diag::warn_main_one_arg);
5714 }
Douglas Gregorbff62032010-10-21 16:57:46 +00005715
5716 if (!FD->isInvalidDecl() && FD->getDescribedFunctionTemplate()) {
5717 Diag(FD->getLocation(), diag::err_main_template_decl);
5718 FD->setInvalidDecl();
5719 }
John McCalld9baf6a2009-07-24 03:03:21 +00005720}
5721
Eli Friedmand5a55bd2008-05-20 13:48:25 +00005722bool Sema::CheckForConstantInitializer(Expr *Init, QualType DclT) {
Eli Friedman2c7bd6b2009-02-27 04:17:12 +00005723 // FIXME: Need strict checking. In C89, we need to check for
5724 // any assignment, increment, decrement, function-calls, or
5725 // commas outside of a sizeof. In C99, it's the same list,
5726 // except that the aforementioned are allowed in unevaluated
5727 // expressions. Everything else falls under the
5728 // "may accept other forms of constant expressions" exception.
5729 // (We never end up here for C++, so the constant expression
5730 // rules there don't matter.)
John McCall8b0f4ff2010-08-02 21:13:48 +00005731 if (Init->isConstantInitializer(Context, false))
Eli Friedman7bfab362009-02-22 06:45:27 +00005732 return false;
Eli Friedman4f294cf2009-02-26 04:47:58 +00005733 Diag(Init->getExprLoc(), diag::err_init_element_not_constant)
5734 << Init->getSourceRange();
Eli Friedmand5a55bd2008-05-20 13:48:25 +00005735 return true;
Steve Naroff98f72032008-01-10 22:15:12 +00005736}
5737
Chandler Carruth33bf3e72011-03-27 09:46:56 +00005738namespace {
5739 // Visits an initialization expression to see if OrigDecl is evaluated in
5740 // its own initialization and throws a warning if it does.
5741 class SelfReferenceChecker
5742 : public EvaluatedExprVisitor<SelfReferenceChecker> {
5743 Sema &S;
5744 Decl *OrigDecl;
Richard Trieua04ad1a2011-09-01 21:44:13 +00005745 bool isRecordType;
5746 bool isPODType;
Chandler Carruth33bf3e72011-03-27 09:46:56 +00005747
5748 public:
5749 typedef EvaluatedExprVisitor<SelfReferenceChecker> Inherited;
5750
5751 SelfReferenceChecker(Sema &S, Decl *OrigDecl) : Inherited(S.Context),
Richard Trieua04ad1a2011-09-01 21:44:13 +00005752 S(S), OrigDecl(OrigDecl) {
5753 isPODType = false;
5754 isRecordType = false;
5755 if (ValueDecl *VD = dyn_cast<ValueDecl>(OrigDecl)) {
5756 isPODType = VD->getType().isPODType(S.Context);
5757 isRecordType = VD->getType()->isRecordType();
5758 }
5759 }
Chandler Carruth33bf3e72011-03-27 09:46:56 +00005760
5761 void VisitExpr(Expr *E) {
5762 if (isa<ObjCMessageExpr>(*E)) return;
Richard Trieua04ad1a2011-09-01 21:44:13 +00005763 if (isRecordType) {
5764 Expr *expr = E;
5765 if (MemberExpr *ME = dyn_cast<MemberExpr>(E)) {
5766 ValueDecl *VD = ME->getMemberDecl();
5767 if (isa<EnumConstantDecl>(VD) || isa<VarDecl>(VD)) return;
5768 expr = ME->getBase();
5769 }
5770 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(expr)) {
5771 HandleDeclRefExpr(DRE);
5772 return;
5773 }
5774 }
Chandler Carruth33bf3e72011-03-27 09:46:56 +00005775 Inherited::VisitExpr(E);
5776 }
5777
Richard Trieua04ad1a2011-09-01 21:44:13 +00005778 void VisitMemberExpr(MemberExpr *E) {
Richard Trieuaa5e2562011-09-07 00:58:53 +00005779 if (E->getType()->canDecayToPointerType()) return;
Richard Trieua04ad1a2011-09-01 21:44:13 +00005780 if (isa<FieldDecl>(E->getMemberDecl()))
5781 if (DeclRefExpr *DRE
5782 = dyn_cast<DeclRefExpr>(E->getBase()->IgnoreParenImpCasts())) {
5783 HandleDeclRefExpr(DRE);
5784 return;
5785 }
5786 Inherited::VisitMemberExpr(E);
5787 }
5788
Chandler Carruth33bf3e72011-03-27 09:46:56 +00005789 void VisitImplicitCastExpr(ImplicitCastExpr *E) {
Richard Trieua04ad1a2011-09-01 21:44:13 +00005790 if ((!isRecordType &&E->getCastKind() == CK_LValueToRValue) ||
5791 (isRecordType && E->getCastKind() == CK_NoOp)) {
5792 Expr* SubExpr = E->getSubExpr()->IgnoreParenImpCasts();
5793 if (MemberExpr *ME = dyn_cast<MemberExpr>(SubExpr))
5794 SubExpr = ME->getBase()->IgnoreParenImpCasts();
5795 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(SubExpr)) {
5796 HandleDeclRefExpr(DRE);
5797 return;
5798 }
5799 }
Chandler Carruth33bf3e72011-03-27 09:46:56 +00005800 Inherited::VisitImplicitCastExpr(E);
5801 }
5802
Richard Trieua04ad1a2011-09-01 21:44:13 +00005803 void VisitUnaryOperator(UnaryOperator *E) {
5804 // For POD record types, addresses of its own members are well-defined.
5805 if (isRecordType && isPODType) return;
5806 Inherited::VisitUnaryOperator(E);
5807 }
5808
5809 void HandleDeclRefExpr(DeclRefExpr *DRE) {
5810 Decl* ReferenceDecl = DRE->getDecl();
Chandler Carruth33bf3e72011-03-27 09:46:56 +00005811 if (OrigDecl != ReferenceDecl) return;
5812 LookupResult Result(S, DRE->getNameInfo(), Sema::LookupOrdinaryName,
5813 Sema::NotForRedeclaration);
Richard Trieua04ad1a2011-09-01 21:44:13 +00005814 S.DiagRuntimeBehavior(DRE->getLocStart(), DRE,
Douglas Gregorfcafc6e2011-05-24 16:02:01 +00005815 S.PDiag(diag::warn_uninit_self_reference_in_init)
Richard Trieua04ad1a2011-09-01 21:44:13 +00005816 << Result.getLookupName()
Douglas Gregorfcafc6e2011-05-24 16:02:01 +00005817 << OrigDecl->getLocation()
Richard Trieua04ad1a2011-09-01 21:44:13 +00005818 << DRE->getSourceRange());
Chandler Carruth33bf3e72011-03-27 09:46:56 +00005819 }
5820 };
5821}
5822
Richard Trieua04ad1a2011-09-01 21:44:13 +00005823/// CheckSelfReference - Warns if OrigDecl is used in expression E.
5824void Sema::CheckSelfReference(Decl* OrigDecl, Expr *E) {
5825 SelfReferenceChecker(*this, OrigDecl).VisitExpr(E);
5826}
5827
Douglas Gregor5fb53972009-01-14 15:45:31 +00005828/// AddInitializerToDecl - Adds the initializer Init to the
5829/// declaration dcl. If DirectInit is true, this is C++ direct
5830/// initialization rather than copy initialization.
Richard Smith30482bc2011-02-20 03:19:35 +00005831void Sema::AddInitializerToDecl(Decl *RealDecl, Expr *Init,
5832 bool DirectInit, bool TypeMayContainAuto) {
Chris Lattner8beb9de2007-10-19 20:10:30 +00005833 // If there is no declaration, there was an error parsing it. Just ignore
5834 // the initializer.
Richard Smith30482bc2011-02-20 03:19:35 +00005835 if (RealDecl == 0 || RealDecl->isInvalidDecl())
Chris Lattner8beb9de2007-10-19 20:10:30 +00005836 return;
Mike Stump11289f42009-09-09 15:08:12 +00005837
Ted Kremenek37881932011-04-04 23:29:12 +00005838 // Check for self-references within variable initializers.
5839 if (VarDecl *vd = dyn_cast<VarDecl>(RealDecl)) {
5840 // Variables declared within a function/method body are handled
5841 // by a dataflow analysis.
5842 if (!vd->hasLocalStorage() && !vd->isStaticLocal())
Richard Trieua04ad1a2011-09-01 21:44:13 +00005843 CheckSelfReference(RealDecl, Init);
Ted Kremenek37881932011-04-04 23:29:12 +00005844 }
5845 else {
Richard Trieua04ad1a2011-09-01 21:44:13 +00005846 CheckSelfReference(RealDecl, Init);
Ted Kremenek37881932011-04-04 23:29:12 +00005847 }
Chandler Carruth33bf3e72011-03-27 09:46:56 +00005848
Douglas Gregor0c880302009-03-11 23:00:04 +00005849 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(RealDecl)) {
5850 // With declarators parsed the way they are, the parser cannot
5851 // distinguish between a normal initializer and a pure-specifier.
5852 // Thus this grotesque test.
5853 IntegerLiteral *IL;
Douglas Gregor0c880302009-03-11 23:00:04 +00005854 if ((IL = dyn_cast<IntegerLiteral>(Init)) && IL->getValue() == 0 &&
Douglas Gregor21920e372009-12-01 17:24:26 +00005855 Context.getCanonicalType(IL->getType()) == Context.IntTy)
5856 CheckPureMethod(Method, Init->getSourceRange());
5857 else {
Douglas Gregor0c880302009-03-11 23:00:04 +00005858 Diag(Method->getLocation(), diag::err_member_function_initialization)
5859 << Method->getDeclName() << Init->getSourceRange();
5860 Method->setInvalidDecl();
5861 }
5862 return;
5863 }
5864
Steve Naroff437b4d82007-09-12 20:13:48 +00005865 VarDecl *VDecl = dyn_cast<VarDecl>(RealDecl);
5866 if (!VDecl) {
Richard Smith4a4beec2011-06-12 11:43:46 +00005867 assert(!isa<FieldDecl>(RealDecl) && "field init shouldn't get here");
5868 Diag(RealDecl->getLocation(), diag::err_illegal_initializer);
Steve Naroff437b4d82007-09-12 20:13:48 +00005869 RealDecl->setInvalidDecl();
5870 return;
Eli Friedman2c7bd6b2009-02-27 04:17:12 +00005871 }
5872
Richard Smith30482bc2011-02-20 03:19:35 +00005873 // C++0x [decl.spec.auto]p6. Deduce the type which 'auto' stands in for.
5874 if (TypeMayContainAuto && VDecl->getType()->getContainedAutoType()) {
Richard Smith9647d3c2011-03-17 16:11:59 +00005875 TypeSourceInfo *DeducedType = 0;
5876 if (!DeduceAutoType(VDecl->getTypeSourceInfo(), Init, DeducedType))
Richard Smith30482bc2011-02-20 03:19:35 +00005877 Diag(VDecl->getLocation(), diag::err_auto_var_deduction_failure)
5878 << VDecl->getDeclName() << VDecl->getType() << Init->getType()
5879 << Init->getSourceRange();
Richard Smith9647d3c2011-03-17 16:11:59 +00005880 if (!DeducedType) {
Richard Smith30482bc2011-02-20 03:19:35 +00005881 RealDecl->setInvalidDecl();
5882 return;
5883 }
Richard Smith9647d3c2011-03-17 16:11:59 +00005884 VDecl->setTypeSourceInfo(DeducedType);
5885 VDecl->setType(DeducedType->getType());
Richard Smith30482bc2011-02-20 03:19:35 +00005886
John McCall31168b02011-06-15 23:02:42 +00005887 // In ARC, infer lifetime.
5888 if (getLangOptions().ObjCAutoRefCount && inferObjCARCLifetime(VDecl))
5889 VDecl->setInvalidDecl();
5890
Richard Smith30482bc2011-02-20 03:19:35 +00005891 // If this is a redeclaration, check that the type we just deduced matches
5892 // the previously declared type.
5893 if (VarDecl *Old = VDecl->getPreviousDeclaration())
5894 MergeVarDeclTypes(VDecl, Old);
5895 }
Douglas Gregorf0f83692010-08-24 05:27:49 +00005896
5897
Eli Friedmanc9827d12009-11-14 03:40:14 +00005898 // A definition must end up with a complete type, which means it must be
5899 // complete with the restriction that an array type might be completed by the
5900 // initializer; note that later code assumes this restriction.
5901 QualType BaseDeclType = VDecl->getType();
5902 if (const ArrayType *Array = Context.getAsIncompleteArrayType(BaseDeclType))
5903 BaseDeclType = Array->getElementType();
5904 if (RequireCompleteType(VDecl->getLocation(), BaseDeclType,
Eli Friedman337cd3a2009-04-13 21:28:54 +00005905 diag::err_typecheck_decl_incomplete_type)) {
5906 RealDecl->setInvalidDecl();
5907 return;
5908 }
5909
Douglas Gregorc99f1552009-12-03 18:33:45 +00005910 // The variable can not have an abstract class type.
5911 if (RequireNonAbstractType(VDecl->getLocation(), VDecl->getType(),
5912 diag::err_abstract_type_in_decl,
5913 AbstractVariableType))
5914 VDecl->setInvalidDecl();
5915
Sebastian Redl5ca79842010-02-01 20:16:42 +00005916 const VarDecl *Def;
5917 if ((Def = VDecl->getDefinition()) && Def != VDecl) {
Mike Stump11289f42009-09-09 15:08:12 +00005918 Diag(VDecl->getLocation(), diag::err_redefinition)
Douglas Gregor0760fa12009-03-10 23:43:53 +00005919 << VDecl->getDeclName();
5920 Diag(Def->getLocation(), diag::note_previous_definition);
5921 VDecl->setInvalidDecl();
5922 return;
5923 }
Douglas Gregorf0f83692010-08-24 05:27:49 +00005924
Douglas Gregorf0f83692010-08-24 05:27:49 +00005925 const VarDecl* PrevInit = 0;
Douglas Gregor71f39c92010-12-16 01:31:22 +00005926 if (getLangOptions().CPlusPlus) {
5927 // C++ [class.static.data]p4
5928 // If a static data member is of const integral or const
5929 // enumeration type, its declaration in the class definition can
5930 // specify a constant-initializer which shall be an integral
5931 // constant expression (5.19). In that case, the member can appear
5932 // in integral constant expressions. The member shall still be
5933 // defined in a namespace scope if it is used in the program and the
5934 // namespace scope definition shall not contain an initializer.
5935 //
5936 // We already performed a redefinition check above, but for static
5937 // data members we also need to check whether there was an in-class
5938 // declaration with an initializer.
5939 if (VDecl->isStaticDataMember() && VDecl->getAnyInitializer(PrevInit)) {
5940 Diag(VDecl->getLocation(), diag::err_redefinition) << VDecl->getDeclName();
5941 Diag(PrevInit->getLocation(), diag::note_previous_definition);
5942 return;
5943 }
Douglas Gregor0760fa12009-03-10 23:43:53 +00005944
Douglas Gregor71f39c92010-12-16 01:31:22 +00005945 if (VDecl->hasLocalStorage())
5946 getCurFunction()->setHasBranchProtectedScope();
5947
5948 if (DiagnoseUnexpandedParameterPack(Init, UPPC_Initializer)) {
5949 VDecl->setInvalidDecl();
5950 return;
5951 }
5952 }
John McCalld4e1b762010-08-01 01:24:59 +00005953
Peter Collingbourne2dbb7082011-09-19 21:14:35 +00005954 // OpenCL 1.1 6.5.2: "Variables allocated in the __local address space inside
5955 // a kernel function cannot be initialized."
5956 if (VDecl->getStorageClass() == SC_OpenCLWorkGroupLocal) {
5957 Diag(VDecl->getLocation(), diag::err_local_cant_init);
5958 VDecl->setInvalidDecl();
5959 return;
5960 }
5961
Douglas Gregor85dabae2009-12-16 01:38:02 +00005962 // Capture the variable that is being initialized and the style of
5963 // initialization.
5964 InitializedEntity Entity = InitializedEntity::InitializeVariable(VDecl);
5965
5966 // FIXME: Poor source location information.
5967 InitializationKind Kind
5968 = DirectInit? InitializationKind::CreateDirect(VDecl->getLocation(),
5969 Init->getLocStart(),
5970 Init->getLocEnd())
5971 : InitializationKind::CreateCopy(VDecl->getLocation(),
5972 Init->getLocStart());
5973
Steve Naroff61091402007-09-12 14:07:44 +00005974 // Get the decls type and save a reference for later, since
Steve Naroff98f72032008-01-10 22:15:12 +00005975 // CheckInitializerTypes may change it.
Steve Naroff437b4d82007-09-12 20:13:48 +00005976 QualType DclT = VDecl->getType(), SavT = DclT;
John McCall1c9c3fd2010-10-15 04:57:14 +00005977 if (VDecl->isLocalVarDecl()) {
Daniel Dunbar0ca16602009-04-14 02:25:56 +00005978 if (VDecl->hasExternalStorage()) { // C99 6.7.8p5
Steve Naroff437b4d82007-09-12 20:13:48 +00005979 Diag(VDecl->getLocation(), diag::err_block_extern_cant_init);
Steve Naroff08899ff2008-04-15 22:42:06 +00005980 VDecl->setInvalidDecl();
5981 } else if (!VDecl->isInvalidDecl()) {
Eli Friedman78275202009-12-19 08:11:05 +00005982 InitializationSequence InitSeq(*this, Entity, Kind, &Init, 1);
John McCalldadc5752010-08-24 06:29:42 +00005983 ExprResult Result = InitSeq.Perform(*this, Entity, Kind,
John McCall37ad5512010-08-23 06:44:23 +00005984 MultiExprArg(*this, &Init, 1),
Eli Friedman463e5232009-12-22 02:10:53 +00005985 &DclT);
5986 if (Result.isInvalid()) {
Steve Naroff08899ff2008-04-15 22:42:06 +00005987 VDecl->setInvalidDecl();
Eli Friedman78275202009-12-19 08:11:05 +00005988 return;
5989 }
Mike Stump11289f42009-09-09 15:08:12 +00005990
Eli Friedman463e5232009-12-22 02:10:53 +00005991 Init = Result.takeAs<Expr>();
5992
Anders Carlsson41e08812008-08-22 05:00:02 +00005993 // C++ 3.6.2p2, allow dynamic initialization of static initializers.
Eli Friedmance982572009-02-20 01:34:21 +00005994 // Don't check invalid declarations to avoid emitting useless diagnostics.
5995 if (!getLangOptions().CPlusPlus && !VDecl->isInvalidDecl()) {
John McCall8e7d6562010-08-26 03:08:43 +00005996 if (VDecl->getStorageClass() == SC_Static) // C99 6.7.8p4.
Anders Carlsson41e08812008-08-22 05:00:02 +00005997 CheckForConstantInitializer(Init, DclT);
5998 }
Steve Naroff61091402007-09-12 14:07:44 +00005999 }
Mike Stump11289f42009-09-09 15:08:12 +00006000 } else if (VDecl->isStaticDataMember() &&
Douglas Gregor0c880302009-03-11 23:00:04 +00006001 VDecl->getLexicalDeclContext()->isRecord()) {
6002 // This is an in-class initialization for a static data member, e.g.,
6003 //
6004 // struct S {
6005 // static const int value = 17;
6006 // };
6007
John McCalldb768922010-09-10 23:21:22 +00006008 // Try to perform the initialization regardless.
6009 if (!VDecl->isInvalidDecl()) {
6010 InitializationSequence InitSeq(*this, Entity, Kind, &Init, 1);
6011 ExprResult Result = InitSeq.Perform(*this, Entity, Kind,
6012 MultiExprArg(*this, &Init, 1),
6013 &DclT);
6014 if (Result.isInvalid()) {
6015 VDecl->setInvalidDecl();
6016 return;
6017 }
6018
6019 Init = Result.takeAs<Expr>();
6020 }
Douglas Gregor0c880302009-03-11 23:00:04 +00006021
6022 // C++ [class.mem]p4:
6023 // A member-declarator can contain a constant-initializer only
6024 // if it declares a static member (9.4) of const integral or
6025 // const enumeration type, see 9.4.2.
Richard Smith2316cd82011-09-29 19:11:37 +00006026 //
6027 // C++0x [class.static.data]p3:
6028 // If a non-volatile const static data member is of integral or
6029 // enumeration type, its declaration in the class definition can
6030 // specify a brace-or-equal-initializer in which every initalizer-clause
6031 // that is an assignment-expression is a constant expression. A static
6032 // data member of literal type can be declared in the class definition
6033 // with the constexpr specifier; if so, its declaration shall specify a
6034 // brace-or-equal-initializer in which every initializer-clause that is
6035 // an assignment-expression is a constant expression.
Douglas Gregor0c880302009-03-11 23:00:04 +00006036 QualType T = VDecl->getType();
John McCalldb768922010-09-10 23:21:22 +00006037
6038 // Do nothing on dependent types.
6039 if (T->isDependentType()) {
6040
Richard Smith2316cd82011-09-29 19:11:37 +00006041 // Allow any 'static constexpr' members, whether or not they are of literal
6042 // type. We separately check that the initializer is a constant expression,
6043 // which implicitly requires the member to be of literal type.
6044 } else if (VDecl->isConstexpr()) {
6045
John McCalldb768922010-09-10 23:21:22 +00006046 // Require constness.
6047 } else if (!T.isConstQualified()) {
6048 Diag(VDecl->getLocation(), diag::err_in_class_initializer_non_const)
6049 << Init->getSourceRange();
Douglas Gregor0c880302009-03-11 23:00:04 +00006050 VDecl->setInvalidDecl();
John McCalldb768922010-09-10 23:21:22 +00006051
6052 // We allow integer constant expressions in all cases.
6053 } else if (T->isIntegralOrEnumerationType()) {
Chris Lattner9925ec82011-06-14 05:46:29 +00006054 // Check whether the expression is a constant expression.
6055 SourceLocation Loc;
Richard Smithee6311d2011-09-29 21:28:14 +00006056 if (getLangOptions().CPlusPlus0x && T.isVolatileQualified())
6057 // In C++0x, a non-constexpr const static data member with an
6058 // in-class initializer cannot be volatile.
6059 Diag(VDecl->getLocation(), diag::err_in_class_initializer_volatile);
6060 else if (Init->isValueDependent())
Chris Lattner9925ec82011-06-14 05:46:29 +00006061 ; // Nothing to check.
6062 else if (Init->isIntegerConstantExpr(Context, &Loc))
6063 ; // Ok, it's an ICE!
6064 else if (Init->isEvaluatable(Context)) {
6065 // If we can constant fold the initializer through heroics, accept it,
6066 // but report this as a use of an extension for -pedantic.
6067 Diag(Loc, diag::ext_in_class_initializer_non_constant)
6068 << Init->getSourceRange();
6069 } else {
6070 // Otherwise, this is some crazy unknown case. Report the issue at the
6071 // location provided by the isIntegerConstantExpr failed check.
6072 Diag(Loc, diag::err_in_class_initializer_non_constant)
6073 << Init->getSourceRange();
6074 VDecl->setInvalidDecl();
John McCalldb768922010-09-10 23:21:22 +00006075 }
6076
Richard Smith2316cd82011-09-29 19:11:37 +00006077 // We allow floating-point constants as an extension.
6078 } else if (T->isFloatingType()) { // also permits complex, which is ok
6079 Diag(VDecl->getLocation(), diag::ext_in_class_initializer_float_type)
6080 << T << Init->getSourceRange();
Richard Smith7b729cd2011-09-30 00:33:19 +00006081 if (getLangOptions().CPlusPlus0x)
6082 Diag(VDecl->getLocation(),
6083 diag::note_in_class_initializer_float_type_constexpr)
6084 << FixItHint::CreateInsertion(VDecl->getLocStart(), "constexpr ");
John McCalldb768922010-09-10 23:21:22 +00006085
Richard Smith2316cd82011-09-29 19:11:37 +00006086 if (!Init->isValueDependent() &&
6087 !Init->isConstantInitializer(Context, false)) {
John McCalldb768922010-09-10 23:21:22 +00006088 Diag(Init->getExprLoc(), diag::err_in_class_initializer_non_constant)
6089 << Init->getSourceRange();
6090 VDecl->setInvalidDecl();
Douglas Gregor0c880302009-03-11 23:00:04 +00006091 }
Richard Smith256336d2011-09-29 23:18:34 +00006092
6093 // Suggest adding 'constexpr' in C++0x for literal types.
6094 } else if (getLangOptions().CPlusPlus0x && T->isLiteralType()) {
6095 Diag(VDecl->getLocation(), diag::err_in_class_initializer_literal_type)
6096 << T << Init->getSourceRange()
6097 << FixItHint::CreateInsertion(VDecl->getLocStart(), "constexpr ");
6098 VDecl->setConstexpr(true);
6099
Richard Smith2316cd82011-09-29 19:11:37 +00006100 } else {
6101 Diag(VDecl->getLocation(), diag::err_in_class_initializer_bad_type)
6102 << T << Init->getSourceRange();
6103 VDecl->setInvalidDecl();
Douglas Gregor0c880302009-03-11 23:00:04 +00006104 }
Steve Naroff08899ff2008-04-15 22:42:06 +00006105 } else if (VDecl->isFileVarDecl()) {
Douglas Gregord4e1fb52010-10-15 01:21:46 +00006106 if (VDecl->getStorageClassAsWritten() == SC_Extern &&
Douglas Gregorfceea362010-04-22 14:36:26 +00006107 (!getLangOptions().CPlusPlus ||
6108 !Context.getBaseElementType(VDecl->getType()).isConstQualified()))
Steve Naroff437b4d82007-09-12 20:13:48 +00006109 Diag(VDecl->getLocation(), diag::warn_extern_init);
Eli Friedman463e5232009-12-22 02:10:53 +00006110 if (!VDecl->isInvalidDecl()) {
6111 InitializationSequence InitSeq(*this, Entity, Kind, &Init, 1);
John McCalldadc5752010-08-24 06:29:42 +00006112 ExprResult Result = InitSeq.Perform(*this, Entity, Kind,
John McCall37ad5512010-08-23 06:44:23 +00006113 MultiExprArg(*this, &Init, 1),
Eli Friedman463e5232009-12-22 02:10:53 +00006114 &DclT);
6115 if (Result.isInvalid()) {
Steve Naroff08899ff2008-04-15 22:42:06 +00006116 VDecl->setInvalidDecl();
Eli Friedman463e5232009-12-22 02:10:53 +00006117 return;
6118 }
6119
6120 Init = Result.takeAs<Expr>();
6121 }
Mike Stump11289f42009-09-09 15:08:12 +00006122
Anders Carlsson41e08812008-08-22 05:00:02 +00006123 // C++ 3.6.2p2, allow dynamic initialization of static initializers.
Eli Friedmance982572009-02-20 01:34:21 +00006124 // Don't check invalid declarations to avoid emitting useless diagnostics.
6125 if (!getLangOptions().CPlusPlus && !VDecl->isInvalidDecl()) {
Anders Carlsson41e08812008-08-22 05:00:02 +00006126 // C99 6.7.8p4. All file scoped initializers need to be constant.
6127 CheckForConstantInitializer(Init, DclT);
6128 }
Steve Naroff61091402007-09-12 14:07:44 +00006129 }
6130 // If the type changed, it means we had an incomplete type that was
Mike Stump11289f42009-09-09 15:08:12 +00006131 // completed by the initializer. For example:
Steve Naroff61091402007-09-12 14:07:44 +00006132 // int ary[] = { 1, 3, 5 };
6133 // "ary" transitions from a VariableArrayType to a ConstantArrayType.
Christopher Lamb2ed9afd2007-11-29 19:09:19 +00006134 if (!VDecl->isInvalidDecl() && (DclT != SavT)) {
Steve Naroff437b4d82007-09-12 20:13:48 +00006135 VDecl->setType(DclT);
Christopher Lamb2ed9afd2007-11-29 19:09:19 +00006136 Init->setType(DclT);
6137 }
Chris Lattner88fdea82010-10-10 18:16:20 +00006138
John McCallacf0ee52010-10-08 02:01:28 +00006139 // Check any implicit conversions within the expression.
6140 CheckImplicitConversions(Init, VDecl->getLocation());
John McCall31168b02011-06-15 23:02:42 +00006141
6142 if (!VDecl->isInvalidDecl())
6143 checkUnsafeAssigns(VDecl->getLocation(), VDecl->getType(), Init);
Richard Smith2316cd82011-09-29 19:11:37 +00006144
6145 if (VDecl->isConstexpr() && !VDecl->isInvalidDecl() &&
6146 !VDecl->getType()->isDependentType() &&
6147 !Init->isTypeDependent() && !Init->isValueDependent() &&
6148 !Init->isConstantInitializer(Context,
6149 VDecl->getType()->isReferenceType())) {
6150 // FIXME: Improve this diagnostic to explain why the initializer is not
6151 // a constant expression.
6152 Diag(VDecl->getLocation(), diag::err_constexpr_var_requires_const_init)
6153 << VDecl << Init->getSourceRange();
6154 }
John McCall31168b02011-06-15 23:02:42 +00006155
John McCall5d413782010-12-06 08:20:24 +00006156 Init = MaybeCreateExprWithCleanups(Init);
Steve Naroff61091402007-09-12 14:07:44 +00006157 // Attach the initializer to the decl.
Douglas Gregord5058122010-02-11 01:19:42 +00006158 VDecl->setInit(Init);
Douglas Gregorbeecd582009-04-21 17:11:58 +00006159
John McCall8b7fd8f12011-01-19 11:48:09 +00006160 CheckCompleteVariableDeclaration(VDecl);
Steve Naroff61091402007-09-12 14:07:44 +00006161}
6162
John McCalleae5acb2010-03-31 02:13:20 +00006163/// ActOnInitializerError - Given that there was an error parsing an
6164/// initializer for the given declaration, try to return to some form
6165/// of sanity.
John McCall48871652010-08-21 09:40:31 +00006166void Sema::ActOnInitializerError(Decl *D) {
John McCalleae5acb2010-03-31 02:13:20 +00006167 // Our main concern here is re-establishing invariants like "a
6168 // variable's type is either dependent or complete".
John McCalleae5acb2010-03-31 02:13:20 +00006169 if (!D || D->isInvalidDecl()) return;
6170
6171 VarDecl *VD = dyn_cast<VarDecl>(D);
6172 if (!VD) return;
6173
Richard Smith30482bc2011-02-20 03:19:35 +00006174 // Auto types are meaningless if we can't make sense of the initializer.
Richard Smithb2bc2e62011-02-21 20:05:19 +00006175 if (ParsingInitForAutoVars.count(D)) {
6176 D->setInvalidDecl();
Richard Smith30482bc2011-02-20 03:19:35 +00006177 return;
6178 }
6179
John McCalleae5acb2010-03-31 02:13:20 +00006180 QualType Ty = VD->getType();
6181 if (Ty->isDependentType()) return;
6182
6183 // Require a complete type.
6184 if (RequireCompleteType(VD->getLocation(),
6185 Context.getBaseElementType(Ty),
6186 diag::err_typecheck_decl_incomplete_type)) {
6187 VD->setInvalidDecl();
6188 return;
6189 }
6190
6191 // Require an abstract type.
6192 if (RequireNonAbstractType(VD->getLocation(), Ty,
6193 diag::err_abstract_type_in_decl,
6194 AbstractVariableType)) {
6195 VD->setInvalidDecl();
6196 return;
6197 }
6198
6199 // Don't bother complaining about constructors or destructors,
6200 // though.
6201}
6202
John McCall48871652010-08-21 09:40:31 +00006203void Sema::ActOnUninitializedDecl(Decl *RealDecl,
Richard Smith30482bc2011-02-20 03:19:35 +00006204 bool TypeMayContainAuto) {
Argyrios Kyrtzidis6709e7d2008-11-07 13:01:22 +00006205 // If there is no declaration, there was an error parsing it. Just ignore it.
6206 if (RealDecl == 0)
6207 return;
6208
Douglas Gregor8e1cf602008-10-29 00:13:59 +00006209 if (VarDecl *Var = dyn_cast<VarDecl>(RealDecl)) {
6210 QualType Type = Var->getType();
Douglas Gregorbeecd582009-04-21 17:11:58 +00006211
Anders Carlssonae019932009-07-11 00:34:39 +00006212 // C++0x [dcl.spec.auto]p3
Richard Smith30482bc2011-02-20 03:19:35 +00006213 if (TypeMayContainAuto && Type->getContainedAutoType()) {
Anders Carlssonae019932009-07-11 00:34:39 +00006214 Diag(Var->getLocation(), diag::err_auto_var_requires_init)
6215 << Var->getDeclName() << Type;
6216 Var->setInvalidDecl();
6217 return;
6218 }
Mike Stump11289f42009-09-09 15:08:12 +00006219
Richard Smith2316cd82011-09-29 19:11:37 +00006220 // C++0x [dcl.constexpr]p9: An object or reference declared constexpr must
6221 // have an initializer.
6222 // C++0x [class.static.data]p3: A static data member can be declared with
6223 // the constexpr specifier; if so, its declaration shall specify
6224 // a brace-or-equal-initializer.
Richard Smith43a87fe2011-10-06 09:21:12 +00006225 //
6226 // A static data member's definition may inherit an initializer from an
6227 // in-class declaration.
6228 if (Var->isConstexpr() && !Var->getAnyInitializer()) {
6229 Diag(Var->getLocation(), diag::err_constexpr_var_requires_init)
6230 << Var->getDeclName();
Richard Smith2316cd82011-09-29 19:11:37 +00006231 Var->setInvalidDecl();
6232 return;
6233 }
6234
Douglas Gregore6565622010-02-09 07:26:29 +00006235 switch (Var->isThisDeclarationADefinition()) {
6236 case VarDecl::Definition:
6237 if (!Var->isStaticDataMember() || !Var->getAnyInitializer())
6238 break;
6239
6240 // We have an out-of-line definition of a static data member
6241 // that has an in-class initializer, so we type-check this like
6242 // a declaration.
6243 //
6244 // Fall through
6245
6246 case VarDecl::DeclarationOnly:
6247 // It's only a declaration.
6248
6249 // Block scope. C99 6.7p7: If an identifier for an object is
6250 // declared with no linkage (C99 6.2.2p6), the type for the
6251 // object shall be complete.
John McCall1c9c3fd2010-10-15 04:57:14 +00006252 if (!Type->isDependentType() && Var->isLocalVarDecl() &&
Douglas Gregore6565622010-02-09 07:26:29 +00006253 !Var->getLinkage() && !Var->isInvalidDecl() &&
6254 RequireCompleteType(Var->getLocation(), Type,
6255 diag::err_typecheck_decl_incomplete_type))
6256 Var->setInvalidDecl();
6257
6258 // Make sure that the type is not abstract.
6259 if (!Type->isDependentType() && !Var->isInvalidDecl() &&
6260 RequireNonAbstractType(Var->getLocation(), Type,
6261 diag::err_abstract_type_in_decl,
6262 AbstractVariableType))
6263 Var->setInvalidDecl();
6264 return;
6265
6266 case VarDecl::TentativeDefinition:
6267 // File scope. C99 6.9.2p2: A declaration of an identifier for an
6268 // object that has file scope without an initializer, and without a
6269 // storage-class specifier or with the storage-class specifier "static",
6270 // constitutes a tentative definition. Note: A tentative definition with
6271 // external linkage is valid (C99 6.2.2p5).
6272 if (!Var->isInvalidDecl()) {
6273 if (const IncompleteArrayType *ArrayT
6274 = Context.getAsIncompleteArrayType(Type)) {
6275 if (RequireCompleteType(Var->getLocation(),
6276 ArrayT->getElementType(),
6277 diag::err_illegal_decl_array_incomplete_type))
6278 Var->setInvalidDecl();
John McCall8e7d6562010-08-26 03:08:43 +00006279 } else if (Var->getStorageClass() == SC_Static) {
Douglas Gregore6565622010-02-09 07:26:29 +00006280 // C99 6.9.2p3: If the declaration of an identifier for an object is
6281 // a tentative definition and has internal linkage (C99 6.2.2p3), the
6282 // declared type shall not be an incomplete type.
6283 // NOTE: code such as the following
6284 // static struct s;
6285 // struct s { int a; };
6286 // is accepted by gcc. Hence here we issue a warning instead of
6287 // an error and we do not invalidate the static declaration.
6288 // NOTE: to avoid multiple warnings, only check the first declaration.
6289 if (Var->getPreviousDeclaration() == 0)
6290 RequireCompleteType(Var->getLocation(), Type,
6291 diag::ext_typecheck_decl_incomplete_type);
6292 }
6293 }
6294
6295 // Record the tentative definition; we're done.
6296 if (!Var->isInvalidDecl())
6297 TentativeDefinitions.push_back(Var);
6298 return;
6299 }
6300
6301 // Provide a specific diagnostic for uninitialized variable
6302 // definitions with incomplete array type.
6303 if (Type->isIncompleteArrayType()) {
Sebastian Redl10600672009-11-05 19:47:47 +00006304 Diag(Var->getLocation(),
6305 diag::err_typecheck_incomplete_array_needs_initializer);
6306 Var->setInvalidDecl();
6307 return;
6308 }
6309
John McCalla755f0f2010-08-01 01:25:24 +00006310 // Provide a specific diagnostic for uninitialized variable
6311 // definitions with reference type.
6312 if (Type->isReferenceType()) {
6313 Diag(Var->getLocation(), diag::err_reference_var_requires_init)
6314 << Var->getDeclName()
6315 << SourceRange(Var->getLocation(), Var->getLocation());
6316 Var->setInvalidDecl();
6317 return;
6318 }
Douglas Gregore6565622010-02-09 07:26:29 +00006319
6320 // Do not attempt to type-check the default initializer for a
6321 // variable with dependent type.
6322 if (Type->isDependentType())
Douglas Gregor86d142a2009-10-08 07:24:58 +00006323 return;
Douglas Gregor5d3507d2009-09-09 23:08:42 +00006324
Douglas Gregore6565622010-02-09 07:26:29 +00006325 if (Var->isInvalidDecl())
6326 return;
Douglas Gregorc99f1552009-12-03 18:33:45 +00006327
Douglas Gregore6565622010-02-09 07:26:29 +00006328 if (RequireCompleteType(Var->getLocation(),
6329 Context.getBaseElementType(Type),
6330 diag::err_typecheck_decl_incomplete_type)) {
6331 Var->setInvalidDecl();
6332 return;
Douglas Gregorc28b57d2008-11-03 20:45:27 +00006333 }
Douglas Gregor8e1cf602008-10-29 00:13:59 +00006334
Douglas Gregore6565622010-02-09 07:26:29 +00006335 // The variable can not have an abstract class type.
6336 if (RequireNonAbstractType(Var->getLocation(), Type,
6337 diag::err_abstract_type_in_decl,
6338 AbstractVariableType)) {
6339 Var->setInvalidDecl();
6340 return;
6341 }
6342
Douglas Gregor9574af62011-05-21 17:52:48 +00006343 // Check for jumps past the implicit initializer. C++0x
6344 // clarifies that this applies to a "variable with automatic
6345 // storage duration", not a "local variable".
6346 // C++0x [stmt.dcl]p3
6347 // A program that jumps from a point where a variable with automatic
6348 // storage duration is not in scope to a point where it is in scope is
6349 // ill-formed unless the variable has scalar type, class type with a
6350 // trivial default constructor and a trivial destructor, a cv-qualified
6351 // version of one of these types, or an array of one of the preceding
6352 // types and is declared without an initializer.
6353 if (getLangOptions().CPlusPlus && Var->hasLocalStorage()) {
6354 if (const RecordType *Record
6355 = Context.getBaseElementType(Type)->getAs<RecordType>()) {
Alexis Hunt466627c2011-05-11 22:50:12 +00006356 CXXRecordDecl *CXXRecord = cast<CXXRecordDecl>(Record->getDecl());
Douglas Gregor9574af62011-05-21 17:52:48 +00006357 if ((!getLangOptions().CPlusPlus0x && !CXXRecord->isPOD()) ||
6358 (getLangOptions().CPlusPlus0x &&
6359 (!CXXRecord->hasTrivialDefaultConstructor() ||
Douglas Gregor22ae6962011-05-27 21:28:00 +00006360 !CXXRecord->hasTrivialDestructor())))
Alexis Hunt466627c2011-05-11 22:50:12 +00006361 getCurFunction()->setHasBranchProtectedScope();
6362 }
Douglas Gregore6565622010-02-09 07:26:29 +00006363 }
Douglas Gregor9574af62011-05-21 17:52:48 +00006364
6365 // C++03 [dcl.init]p9:
6366 // If no initializer is specified for an object, and the
6367 // object is of (possibly cv-qualified) non-POD class type (or
6368 // array thereof), the object shall be default-initialized; if
6369 // the object is of const-qualified type, the underlying class
6370 // type shall have a user-declared default
6371 // constructor. Otherwise, if no initializer is specified for
6372 // a non- static object, the object and its subobjects, if
6373 // any, have an indeterminate initial value); if the object
6374 // or any of its subobjects are of const-qualified type, the
6375 // program is ill-formed.
6376 // C++0x [dcl.init]p11:
6377 // If no initializer is specified for an object, the object is
6378 // default-initialized; [...].
6379 InitializedEntity Entity = InitializedEntity::InitializeVariable(Var);
6380 InitializationKind Kind
6381 = InitializationKind::CreateDefault(Var->getLocation());
6382
6383 InitializationSequence InitSeq(*this, Entity, Kind, 0, 0);
6384 ExprResult Init = InitSeq.Perform(*this, Entity, Kind,
6385 MultiExprArg(*this, 0, 0));
6386 if (Init.isInvalid())
6387 Var->setInvalidDecl();
6388 else if (Init.get())
6389 Var->setInit(MaybeCreateExprWithCleanups(Init.get()));
Douglas Gregor589973b2010-03-08 02:45:10 +00006390
John McCall8b7fd8f12011-01-19 11:48:09 +00006391 CheckCompleteVariableDeclaration(Var);
Douglas Gregor8e1cf602008-10-29 00:13:59 +00006392 }
6393}
6394
Richard Smith02e85f32011-04-14 22:09:26 +00006395void Sema::ActOnCXXForRangeDecl(Decl *D) {
6396 VarDecl *VD = dyn_cast<VarDecl>(D);
6397 if (!VD) {
6398 Diag(D->getLocation(), diag::err_for_range_decl_must_be_var);
6399 D->setInvalidDecl();
6400 return;
6401 }
6402
6403 VD->setCXXForRangeDecl(true);
6404
6405 // for-range-declaration cannot be given a storage class specifier.
6406 int Error = -1;
6407 switch (VD->getStorageClassAsWritten()) {
6408 case SC_None:
6409 break;
6410 case SC_Extern:
6411 Error = 0;
6412 break;
6413 case SC_Static:
6414 Error = 1;
6415 break;
6416 case SC_PrivateExtern:
6417 Error = 2;
6418 break;
6419 case SC_Auto:
6420 Error = 3;
6421 break;
6422 case SC_Register:
6423 Error = 4;
6424 break;
Peter Collingbourne2dbb7082011-09-19 21:14:35 +00006425 case SC_OpenCLWorkGroupLocal:
Peter Collingbourne9a8f1532011-09-20 12:40:26 +00006426 llvm_unreachable("Unexpected storage class");
Richard Smith02e85f32011-04-14 22:09:26 +00006427 }
Richard Smith2316cd82011-09-29 19:11:37 +00006428 if (VD->isConstexpr())
6429 Error = 5;
Richard Smith02e85f32011-04-14 22:09:26 +00006430 if (Error != -1) {
6431 Diag(VD->getOuterLocStart(), diag::err_for_range_storage_class)
6432 << VD->getDeclName() << Error;
6433 D->setInvalidDecl();
6434 }
6435}
6436
John McCall8b7fd8f12011-01-19 11:48:09 +00006437void Sema::CheckCompleteVariableDeclaration(VarDecl *var) {
6438 if (var->isInvalidDecl()) return;
6439
John McCall31168b02011-06-15 23:02:42 +00006440 // In ARC, don't allow jumps past the implicit initialization of a
6441 // local retaining variable.
6442 if (getLangOptions().ObjCAutoRefCount &&
6443 var->hasLocalStorage()) {
6444 switch (var->getType().getObjCLifetime()) {
6445 case Qualifiers::OCL_None:
6446 case Qualifiers::OCL_ExplicitNone:
6447 case Qualifiers::OCL_Autoreleasing:
6448 break;
6449
6450 case Qualifiers::OCL_Weak:
6451 case Qualifiers::OCL_Strong:
6452 getCurFunction()->setHasBranchProtectedScope();
6453 break;
6454 }
6455 }
6456
John McCall8b7fd8f12011-01-19 11:48:09 +00006457 // All the following checks are C++ only.
6458 if (!getLangOptions().CPlusPlus) return;
6459
6460 QualType baseType = Context.getBaseElementType(var->getType());
6461 if (baseType->isDependentType()) return;
6462
6463 // __block variables might require us to capture a copy-initializer.
6464 if (var->hasAttr<BlocksAttr>()) {
6465 // It's currently invalid to ever have a __block variable with an
6466 // array type; should we diagnose that here?
6467
6468 // Regardless, we don't want to ignore array nesting when
6469 // constructing this copy.
6470 QualType type = var->getType();
6471
6472 if (type->isStructureOrClassType()) {
6473 SourceLocation poi = var->getLocation();
6474 Expr *varRef = new (Context) DeclRefExpr(var, type, VK_LValue, poi);
6475 ExprResult result =
6476 PerformCopyInitialization(
6477 InitializedEntity::InitializeBlock(poi, type, false),
6478 poi, Owned(varRef));
6479 if (!result.isInvalid()) {
6480 result = MaybeCreateExprWithCleanups(result);
6481 Expr *init = result.takeAs<Expr>();
6482 Context.setBlockVarCopyInits(var, init);
6483 }
6484 }
6485 }
6486
6487 // Check for global constructors.
6488 if (!var->getDeclContext()->isDependentContext() &&
6489 var->hasGlobalStorage() &&
6490 !var->isStaticLocal() &&
6491 var->getInit() &&
6492 !var->getInit()->isConstantInitializer(Context,
6493 baseType->isReferenceType()))
6494 Diag(var->getLocation(), diag::warn_global_constructor)
6495 << var->getInit()->getSourceRange();
6496
6497 // Require the destructor.
6498 if (const RecordType *recordType = baseType->getAs<RecordType>())
6499 FinalizeVarWithDestructor(var, recordType);
6500}
6501
Richard Smithb2bc2e62011-02-21 20:05:19 +00006502/// FinalizeDeclaration - called by ParseDeclarationAfterDeclarator to perform
6503/// any semantic actions necessary after any initializer has been attached.
6504void
6505Sema::FinalizeDeclaration(Decl *ThisDecl) {
6506 // Note that we are no longer parsing the initializer for this declaration.
6507 ParsingInitForAutoVars.erase(ThisDecl);
6508}
6509
John McCallba7bf592010-08-24 05:47:05 +00006510Sema::DeclGroupPtrTy
6511Sema::FinalizeDeclaratorGroup(Scope *S, const DeclSpec &DS,
6512 Decl **Group, unsigned NumDecls) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00006513 SmallVector<Decl*, 8> Decls;
Eli Friedman55b9ecb2009-05-29 01:49:24 +00006514
6515 if (DS.isTypeSpecOwned())
John McCallba7bf592010-08-24 05:47:05 +00006516 Decls.push_back(DS.getRepAsDecl());
Eli Friedman55b9ecb2009-05-29 01:49:24 +00006517
Richard Smith2abf6762011-02-23 00:37:57 +00006518 for (unsigned i = 0; i != NumDecls; ++i)
6519 if (Decl *D = Group[i])
6520 Decls.push_back(D);
6521
Chandler Carruth33bf3e72011-03-27 09:46:56 +00006522 return BuildDeclaratorGroup(Decls.data(), Decls.size(),
Richard Smith2abf6762011-02-23 00:37:57 +00006523 DS.getTypeSpecType() == DeclSpec::TST_auto);
6524}
6525
6526/// BuildDeclaratorGroup - convert a list of declarations into a declaration
6527/// group, performing any necessary semantic checking.
6528Sema::DeclGroupPtrTy
6529Sema::BuildDeclaratorGroup(Decl **Group, unsigned NumDecls,
6530 bool TypeMayContainAuto) {
Richard Smith30482bc2011-02-20 03:19:35 +00006531 // C++0x [dcl.spec.auto]p7:
6532 // If the type deduced for the template parameter U is not the same in each
6533 // deduction, the program is ill-formed.
6534 // FIXME: When initializer-list support is added, a distinction is needed
6535 // between the deduced type U and the deduced type which 'auto' stands for.
6536 // auto a = 0, b = { 1, 2, 3 };
6537 // is legal because the deduced type U is 'int' in both cases.
Richard Smith2abf6762011-02-23 00:37:57 +00006538 if (TypeMayContainAuto && NumDecls > 1) {
Richard Smith30482bc2011-02-20 03:19:35 +00006539 QualType Deduced;
6540 CanQualType DeducedCanon;
6541 VarDecl *DeducedDecl = 0;
6542 for (unsigned i = 0; i != NumDecls; ++i) {
6543 if (VarDecl *D = dyn_cast<VarDecl>(Group[i])) {
6544 AutoType *AT = D->getType()->getContainedAutoType();
Richard Smith2abf6762011-02-23 00:37:57 +00006545 // Don't reissue diagnostics when instantiating a template.
6546 if (AT && D->isInvalidDecl())
6547 break;
Richard Smith30482bc2011-02-20 03:19:35 +00006548 if (AT && AT->isDeduced()) {
6549 QualType U = AT->getDeducedType();
6550 CanQualType UCanon = Context.getCanonicalType(U);
6551 if (Deduced.isNull()) {
6552 Deduced = U;
6553 DeducedCanon = UCanon;
6554 DeducedDecl = D;
6555 } else if (DeducedCanon != UCanon) {
Richard Smith2abf6762011-02-23 00:37:57 +00006556 Diag(D->getTypeSourceInfo()->getTypeLoc().getBeginLoc(),
6557 diag::err_auto_different_deductions)
Richard Smith30482bc2011-02-20 03:19:35 +00006558 << Deduced << DeducedDecl->getDeclName()
6559 << U << D->getDeclName()
6560 << DeducedDecl->getInit()->getSourceRange()
6561 << D->getInit()->getSourceRange();
Richard Smith2abf6762011-02-23 00:37:57 +00006562 D->setInvalidDecl();
Richard Smith30482bc2011-02-20 03:19:35 +00006563 break;
6564 }
6565 }
6566 }
6567 }
6568 }
6569
Richard Smith2abf6762011-02-23 00:37:57 +00006570 return DeclGroupPtrTy::make(DeclGroupRef::Create(Context, Group, NumDecls));
Chris Lattner776fac82007-06-09 00:53:06 +00006571}
Steve Naroff7e6f7c22007-08-28 03:03:08 +00006572
Chris Lattner5bbb3c82009-03-29 16:50:03 +00006573
Chris Lattneraa9c7ae2008-04-08 04:40:51 +00006574/// ActOnParamDeclarator - Called from Parser::ParseFunctionDeclarator()
6575/// to introduce parameters into function prototype scope.
John McCall48871652010-08-21 09:40:31 +00006576Decl *Sema::ActOnParamDeclarator(Scope *S, Declarator &D) {
Chris Lattnercf31de32008-06-26 06:49:43 +00006577 const DeclSpec &DS = D.getDeclSpec();
Douglas Gregorad590502008-12-15 23:53:10 +00006578
Chris Lattneraa9c7ae2008-04-08 04:40:51 +00006579 // Verify C99 6.7.5.3p2: The only SCS allowed is 'register'.
John McCall8e7d6562010-08-26 03:08:43 +00006580 VarDecl::StorageClass StorageClass = SC_None;
6581 VarDecl::StorageClass StorageClassAsWritten = SC_None;
Daniel Dunbar0ff41922008-09-03 21:54:21 +00006582 if (DS.getStorageClassSpec() == DeclSpec::SCS_register) {
John McCall8e7d6562010-08-26 03:08:43 +00006583 StorageClass = SC_Register;
6584 StorageClassAsWritten = SC_Register;
Daniel Dunbar0ff41922008-09-03 21:54:21 +00006585 } else if (DS.getStorageClassSpec() != DeclSpec::SCS_unspecified) {
Chris Lattneraa9c7ae2008-04-08 04:40:51 +00006586 Diag(DS.getStorageClassSpecLoc(),
6587 diag::err_invalid_storage_class_in_func_decl);
Chris Lattnercf31de32008-06-26 06:49:43 +00006588 D.getMutableDeclSpec().ClearStorageClassSpecs();
Chris Lattneraa9c7ae2008-04-08 04:40:51 +00006589 }
Eli Friedmand5c0eed2009-04-19 20:27:55 +00006590
6591 if (D.getDeclSpec().isThreadSpecified())
6592 Diag(D.getDeclSpec().getThreadSpecLoc(), diag::err_invalid_thread);
Richard Smitha77a0a62011-08-15 21:04:07 +00006593 if (D.getDeclSpec().isConstexprSpecified())
6594 Diag(D.getDeclSpec().getConstexprSpecLoc(), diag::err_invalid_constexpr)
6595 << 0;
Eli Friedmand5c0eed2009-04-19 20:27:55 +00006596
Eli Friedman574c7452009-04-07 19:37:57 +00006597 DiagnoseFunctionSpecifiers(D);
6598
Argyrios Kyrtzidisef7022f2011-06-28 03:01:15 +00006599 TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S);
John McCall8cb7bdf2010-06-04 23:28:52 +00006600 QualType parmDeclType = TInfo->getType();
Mike Stump11289f42009-09-09 15:08:12 +00006601
Douglas Gregor27b4c162010-12-23 22:44:42 +00006602 if (getLangOptions().CPlusPlus) {
6603 // Check that there are no default arguments inside the type of this
6604 // parameter.
6605 CheckExtraCXXDefaultArguments(D);
Douglas Gregor27b4c162010-12-23 22:44:42 +00006606
6607 // Parameter declarators cannot be qualified (C++ [dcl.meaning]p1).
6608 if (D.getCXXScopeSpec().isSet()) {
6609 Diag(D.getIdentifierLoc(), diag::err_qualified_param_declarator)
6610 << D.getCXXScopeSpec().getRange();
6611 D.getCXXScopeSpec().clear();
6612 }
Douglas Gregord6ab8742009-05-28 23:31:59 +00006613 }
6614
Alexis Hunta56cbcc2010-11-03 01:07:06 +00006615 // Ensure we have a valid name
6616 IdentifierInfo *II = 0;
6617 if (D.hasName()) {
6618 II = D.getIdentifier();
6619 if (!II) {
6620 Diag(D.getIdentifierLoc(), diag::err_bad_parameter_name)
6621 << GetNameForDeclarator(D).getName().getAsString();
6622 D.setInvalidType(true);
6623 }
6624 }
6625
Chris Lattnerdd1cb5b2010-02-22 00:40:25 +00006626 // Check for redeclaration of parameters, e.g. int foo(int x, int x);
Chris Lattnerd9773512009-01-21 02:38:50 +00006627 if (II) {
John McCall84f02672010-03-18 06:42:38 +00006628 LookupResult R(*this, II, D.getIdentifierLoc(), LookupOrdinaryName,
6629 ForRedeclaration);
6630 LookupName(R, S);
6631 if (R.isSingleResult()) {
6632 NamedDecl *PrevDecl = R.getFoundDecl();
Chris Lattnerd9773512009-01-21 02:38:50 +00006633 if (PrevDecl->isTemplateParameter()) {
6634 // Maybe we will complain about the shadowed template parameter.
6635 DiagnoseTemplateParameterShadow(D.getIdentifierLoc(), PrevDecl);
6636 // Just pretend that we didn't see the previous declaration.
6637 PrevDecl = 0;
John McCall48871652010-08-21 09:40:31 +00006638 } else if (S->isDeclScope(PrevDecl)) {
Chris Lattnerd9773512009-01-21 02:38:50 +00006639 Diag(D.getIdentifierLoc(), diag::err_param_redefinition) << II;
Chris Lattnerdd1cb5b2010-02-22 00:40:25 +00006640 Diag(PrevDecl->getLocation(), diag::note_previous_declaration);
Chris Lattneraa9c7ae2008-04-08 04:40:51 +00006641
Chris Lattnerd9773512009-01-21 02:38:50 +00006642 // Recover by removing the name
6643 II = 0;
6644 D.SetIdentifier(0, D.getIdentifierLoc());
Fariborz Jahanian5ec502e2010-02-12 21:53:14 +00006645 D.setInvalidType(true);
Chris Lattnerd9773512009-01-21 02:38:50 +00006646 }
Chris Lattneraa9c7ae2008-04-08 04:40:51 +00006647 }
Chris Lattnerc5cdf4d2007-01-21 07:42:07 +00006648 }
Steve Naroff773df5c2007-08-07 22:44:21 +00006649
John McCallf7b2fb52010-01-22 00:28:27 +00006650 // Temporarily put parameter variables in the translation unit, not
6651 // the enclosing context. This prevents them from accidentally
6652 // looking like class members in C++.
Douglas Gregor940bca72010-04-12 07:48:19 +00006653 ParmVarDecl *New = CheckParameter(Context.getTranslationUnitDecl(),
Abramo Bagnaradff19302011-03-08 08:55:46 +00006654 D.getSourceRange().getBegin(),
6655 D.getIdentifierLoc(), II,
6656 parmDeclType, TInfo,
Douglas Gregorc4df4072010-04-19 22:54:31 +00006657 StorageClass, StorageClassAsWritten);
Mike Stump11289f42009-09-09 15:08:12 +00006658
Chris Lattnerf6d1c9c2009-04-25 08:06:05 +00006659 if (D.isInvalidType())
John McCall8fb0d9d2011-05-01 22:35:37 +00006660 New->setInvalidDecl();
6661
6662 assert(S->isFunctionPrototypeScope());
6663 assert(S->getFunctionPrototypeDepth() >= 1);
6664 New->setScopeInfo(S->getFunctionPrototypeDepth() - 1,
6665 S->getNextFunctionPrototypeIndex());
Douglas Gregor940bca72010-04-12 07:48:19 +00006666
Douglas Gregor91f84212008-12-11 16:49:14 +00006667 // Add the parameter declaration into this scope.
John McCall48871652010-08-21 09:40:31 +00006668 S->AddDecl(New);
Argyrios Kyrtzidisb8a49202008-04-12 00:47:19 +00006669 if (II)
Douglas Gregor91f84212008-12-11 16:49:14 +00006670 IdResolver.AddDecl(New);
Nate Begemand8c41562008-02-17 21:20:31 +00006671
Douglas Gregor758a8692009-06-17 21:51:59 +00006672 ProcessDeclAttributes(S, New, D);
Mike Stumpe9efa802009-04-30 00:19:40 +00006673
Douglas Gregor41866812011-09-12 18:37:38 +00006674 if (D.getDeclSpec().isModulePrivateSpecified())
6675 Diag(New->getLocation(), diag::err_module_private_local)
6676 << 1 << New->getDeclName()
6677 << SourceRange(D.getDeclSpec().getModulePrivateSpecLoc())
6678 << FixItHint::CreateRemoval(D.getDeclSpec().getModulePrivateSpecLoc());
6679
Argyrios Kyrtzidisb4b64ca2009-06-30 02:34:44 +00006680 if (New->hasAttr<BlocksAttr>()) {
Mike Stumpe9efa802009-04-30 00:19:40 +00006681 Diag(New->getLocation(), diag::err_block_on_nonlocal);
6682 }
John McCall48871652010-08-21 09:40:31 +00006683 return New;
Chris Lattnerc5cdf4d2007-01-21 07:42:07 +00006684}
Fariborz Jahanian56ff1462007-11-08 23:49:49 +00006685
John McCalla3ccba02010-06-04 11:21:44 +00006686/// \brief Synthesizes a variable for a parameter arising from a
6687/// typedef.
6688ParmVarDecl *Sema::BuildParmVarDeclForTypedef(DeclContext *DC,
6689 SourceLocation Loc,
6690 QualType T) {
Abramo Bagnaradff19302011-03-08 08:55:46 +00006691 /* FIXME: setting StartLoc == Loc.
6692 Would it be worth to modify callers so as to provide proper source
6693 location for the unnamed parameters, embedding the parameter's type? */
6694 ParmVarDecl *Param = ParmVarDecl::Create(Context, DC, Loc, Loc, 0,
John McCalla3ccba02010-06-04 11:21:44 +00006695 T, Context.getTrivialTypeSourceInfo(T, Loc),
John McCall8e7d6562010-08-26 03:08:43 +00006696 SC_None, SC_None, 0);
John McCalla3ccba02010-06-04 11:21:44 +00006697 Param->setImplicit();
6698 return Param;
6699}
6700
John McCallc5990642010-08-24 09:05:15 +00006701void Sema::DiagnoseUnusedParameters(ParmVarDecl * const *Param,
6702 ParmVarDecl * const *ParamEnd) {
John McCallc5990642010-08-24 09:05:15 +00006703 // Don't diagnose unused-parameter errors in template instantiations; we
6704 // will already have done so in the template itself.
6705 if (!ActiveTemplateInstantiations.empty())
6706 return;
6707
6708 for (; Param != ParamEnd; ++Param) {
6709 if (!(*Param)->isUsed() && (*Param)->getDeclName() &&
6710 !(*Param)->hasAttr<UnusedAttr>()) {
6711 Diag((*Param)->getLocation(), diag::warn_unused_parameter)
6712 << (*Param)->getDeclName();
6713 }
6714 }
6715}
6716
Argyrios Kyrtzidisaf84ec02010-11-17 23:11:54 +00006717void Sema::DiagnoseSizeOfParametersAndReturnValue(ParmVarDecl * const *Param,
6718 ParmVarDecl * const *ParamEnd,
6719 QualType ReturnTy,
6720 NamedDecl *D) {
Argyrios Kyrtzidisef6c8da2010-11-18 00:20:36 +00006721 if (LangOpts.NumLargeByValueCopy == 0) // No check.
Argyrios Kyrtzidisaf84ec02010-11-17 23:11:54 +00006722 return;
6723
Argyrios Kyrtzidisef6c8da2010-11-18 00:20:36 +00006724 // Warn if the return value is pass-by-value and larger than the specified
6725 // threshold.
John McCall31168b02011-06-15 23:02:42 +00006726 if (ReturnTy.isPODType(Context)) {
Argyrios Kyrtzidisaf84ec02010-11-17 23:11:54 +00006727 unsigned Size = Context.getTypeSizeInChars(ReturnTy).getQuantity();
Argyrios Kyrtzidisef6c8da2010-11-18 00:20:36 +00006728 if (Size > LangOpts.NumLargeByValueCopy)
Argyrios Kyrtzidisaf84ec02010-11-17 23:11:54 +00006729 Diag(D->getLocation(), diag::warn_return_value_size)
6730 << D->getDeclName() << Size;
6731 }
6732
Argyrios Kyrtzidisef6c8da2010-11-18 00:20:36 +00006733 // Warn if any parameter is pass-by-value and larger than the specified
6734 // threshold.
Argyrios Kyrtzidisaf84ec02010-11-17 23:11:54 +00006735 for (; Param != ParamEnd; ++Param) {
6736 QualType T = (*Param)->getType();
John McCall31168b02011-06-15 23:02:42 +00006737 if (!T.isPODType(Context))
Argyrios Kyrtzidisaf84ec02010-11-17 23:11:54 +00006738 continue;
6739 unsigned Size = Context.getTypeSizeInChars(T).getQuantity();
Argyrios Kyrtzidisef6c8da2010-11-18 00:20:36 +00006740 if (Size > LangOpts.NumLargeByValueCopy)
Argyrios Kyrtzidisaf84ec02010-11-17 23:11:54 +00006741 Diag((*Param)->getLocation(), diag::warn_parameter_size)
6742 << (*Param)->getDeclName() << Size;
6743 }
6744}
6745
Abramo Bagnaradff19302011-03-08 08:55:46 +00006746ParmVarDecl *Sema::CheckParameter(DeclContext *DC, SourceLocation StartLoc,
6747 SourceLocation NameLoc, IdentifierInfo *Name,
6748 QualType T, TypeSourceInfo *TSInfo,
Douglas Gregorc4df4072010-04-19 22:54:31 +00006749 VarDecl::StorageClass StorageClass,
6750 VarDecl::StorageClass StorageClassAsWritten) {
John McCall31168b02011-06-15 23:02:42 +00006751 // In ARC, infer a lifetime qualifier for appropriate parameter types.
6752 if (getLangOptions().ObjCAutoRefCount &&
6753 T.getObjCLifetime() == Qualifiers::OCL_None &&
6754 T->isObjCLifetimeType()) {
6755
6756 Qualifiers::ObjCLifetime lifetime;
6757
6758 // Special cases for arrays:
6759 // - if it's const, use __unsafe_unretained
6760 // - otherwise, it's an error
6761 if (T->isArrayType()) {
6762 if (!T.isConstQualified()) {
Fariborz Jahanianed1933b2011-10-03 22:11:57 +00006763 DelayedDiagnostics.add(
6764 sema::DelayedDiagnostic::makeForbiddenType(
6765 NameLoc, diag::err_arc_array_param_no_ownership, T, false));
John McCall31168b02011-06-15 23:02:42 +00006766 }
6767 lifetime = Qualifiers::OCL_ExplicitNone;
6768 } else {
6769 lifetime = T->getObjCARCImplicitLifetime();
6770 }
6771 T = Context.getLifetimeQualifiedType(T, lifetime);
6772 }
6773
Abramo Bagnaradff19302011-03-08 08:55:46 +00006774 ParmVarDecl *New = ParmVarDecl::Create(Context, DC, StartLoc, NameLoc, Name,
Douglas Gregor84280642011-07-12 04:42:08 +00006775 Context.getAdjustedParameterType(T),
6776 TSInfo,
Douglas Gregorc4df4072010-04-19 22:54:31 +00006777 StorageClass, StorageClassAsWritten,
6778 0);
Douglas Gregor940bca72010-04-12 07:48:19 +00006779
6780 // Parameters can not be abstract class types.
6781 // For record types, this is done by the AbstractClassUsageDiagnoser once
6782 // the class has been completely parsed.
6783 if (!CurContext->isRecord() &&
6784 RequireNonAbstractType(NameLoc, T, diag::err_abstract_type_in_decl,
6785 AbstractParamType))
6786 New->setInvalidDecl();
6787
6788 // Parameter declarators cannot be interface types. All ObjC objects are
6789 // passed by reference.
John McCall8b07ec22010-05-15 11:32:37 +00006790 if (T->isObjCObjectType()) {
Douglas Gregor940bca72010-04-12 07:48:19 +00006791 Diag(NameLoc,
Fariborz Jahanian6507135e2011-07-26 17:58:54 +00006792 diag::err_object_cannot_be_passed_returned_by_value) << 1 << T
6793 << FixItHint::CreateInsertion(NameLoc, "*");
6794 T = Context.getObjCObjectPointerType(T);
6795 New->setType(T);
Douglas Gregor940bca72010-04-12 07:48:19 +00006796 }
6797
6798 // ISO/IEC TR 18037 S6.7.3: "The type of an object with automatic storage
6799 // duration shall not be qualified by an address-space qualifier."
6800 // Since all parameters have automatic store duration, they can not have
6801 // an address space.
6802 if (T.getAddressSpace() != 0) {
6803 Diag(NameLoc, diag::err_arg_with_address_space);
6804 New->setInvalidDecl();
6805 }
6806
6807 return New;
6808}
6809
Douglas Gregor170512f2009-04-01 23:51:29 +00006810void Sema::ActOnFinishKNRParamDeclarations(Scope *S, Declarator &D,
6811 SourceLocation LocAfterDecls) {
Abramo Bagnara924a8f32010-12-10 16:29:40 +00006812 DeclaratorChunk::FunctionTypeInfo &FTI = D.getFunctionTypeInfo();
Chris Lattneraa9c7ae2008-04-08 04:40:51 +00006813
Chris Lattner5c5fbcc2006-12-03 08:41:30 +00006814 // Verify 6.9.1p6: 'every identifier in the identifier list shall be declared'
6815 // for a K&R function.
6816 if (!FTI.hasPrototype) {
Douglas Gregor862ffb12009-04-02 03:14:12 +00006817 for (int i = FTI.NumArgs; i != 0; /* decrement in loop */) {
6818 --i;
Chris Lattneraa9c7ae2008-04-08 04:40:51 +00006819 if (FTI.ArgInfo[i].Param == 0) {
Daniel Dunbar70e7ead2009-10-18 20:26:27 +00006820 llvm::SmallString<256> Code;
6821 llvm::raw_svector_ostream(Code) << " int "
Daniel Dunbar07d07852009-10-18 21:17:35 +00006822 << FTI.ArgInfo[i].Ident->getName()
Daniel Dunbar70e7ead2009-10-18 20:26:27 +00006823 << ";\n";
Chris Lattner4bd8dd82008-11-19 08:23:25 +00006824 Diag(FTI.ArgInfo[i].IdentLoc, diag::ext_param_not_declared)
Douglas Gregor170512f2009-04-01 23:51:29 +00006825 << FTI.ArgInfo[i].Ident
Douglas Gregora771f462010-03-31 17:46:05 +00006826 << FixItHint::CreateInsertion(LocAfterDecls, Code.str());
Douglas Gregor170512f2009-04-01 23:51:29 +00006827
Chris Lattner5c5fbcc2006-12-03 08:41:30 +00006828 // Implicitly declare the argument as type 'int' for lack of a better
6829 // type.
John McCall084e83d2011-03-24 11:26:52 +00006830 AttributeFactory attrs;
6831 DeclSpec DS(attrs);
Chris Lattneraa9c7ae2008-04-08 04:40:51 +00006832 const char* PrevSpec; // unused
John McCall49bfce42009-08-03 20:12:06 +00006833 unsigned DiagID; // unused
Mike Stump11289f42009-09-09 15:08:12 +00006834 DS.SetTypeSpecType(DeclSpec::TST_int, FTI.ArgInfo[i].IdentLoc,
John McCall49bfce42009-08-03 20:12:06 +00006835 PrevSpec, DiagID);
Chris Lattneraa9c7ae2008-04-08 04:40:51 +00006836 Declarator ParamD(DS, Declarator::KNRTypeListContext);
6837 ParamD.SetIdentifier(FTI.ArgInfo[i].Ident, FTI.ArgInfo[i].IdentLoc);
Douglas Gregor9aa89042009-01-23 16:23:13 +00006838 FTI.ArgInfo[i].Param = ActOnParamDeclarator(S, ParamD);
Chris Lattner5c5fbcc2006-12-03 08:41:30 +00006839 }
6840 }
Mike Stump11289f42009-09-09 15:08:12 +00006841 }
Douglas Gregor9aa89042009-01-23 16:23:13 +00006842}
6843
John McCall48871652010-08-21 09:40:31 +00006844Decl *Sema::ActOnStartOfFunctionDef(Scope *FnBodyScope,
6845 Declarator &D) {
Douglas Gregor9aa89042009-01-23 16:23:13 +00006846 assert(getCurFunctionDecl() == 0 && "Function parsing confused");
Abramo Bagnara924a8f32010-12-10 16:29:40 +00006847 assert(D.isFunctionDeclarator() && "Not a function declarator!");
Douglas Gregorad590502008-12-15 23:53:10 +00006848 Scope *ParentScope = FnBodyScope->getParent();
Steve Naroff012484d2008-01-14 20:51:29 +00006849
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00006850 D.setFunctionDefinition(true);
John McCall48871652010-08-21 09:40:31 +00006851 Decl *DP = HandleDeclarator(ParentScope, D,
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00006852 MultiTemplateParamsArg(*this));
Chris Lattner5bbb3c82009-03-29 16:50:03 +00006853 return ActOnStartOfFunctionDef(FnBodyScope, DP);
Argyrios Kyrtzidised983422008-07-01 10:37:29 +00006854}
6855
Anders Carlsson31c7e882009-12-09 03:30:09 +00006856static bool ShouldWarnAboutMissingPrototype(const FunctionDecl *FD) {
6857 // Don't warn about invalid declarations.
6858 if (FD->isInvalidDecl())
6859 return false;
Anders Carlssona0388252009-12-09 03:44:46 +00006860
Anders Carlsson31c7e882009-12-09 03:30:09 +00006861 // Or declarations that aren't global.
6862 if (!FD->isGlobal())
6863 return false;
Anders Carlssona0388252009-12-09 03:44:46 +00006864
Anders Carlsson31c7e882009-12-09 03:30:09 +00006865 // Don't warn about C++ member functions.
6866 if (isa<CXXMethodDecl>(FD))
6867 return false;
Anders Carlssona0388252009-12-09 03:44:46 +00006868
Anders Carlsson31c7e882009-12-09 03:30:09 +00006869 // Don't warn about 'main'.
6870 if (FD->isMain())
6871 return false;
Anders Carlssona0388252009-12-09 03:44:46 +00006872
Anders Carlsson31c7e882009-12-09 03:30:09 +00006873 // Don't warn about inline functions.
John McCall30cd20a2011-03-22 07:16:37 +00006874 if (FD->isInlined())
Anders Carlsson31c7e882009-12-09 03:30:09 +00006875 return false;
Anders Carlssona0388252009-12-09 03:44:46 +00006876
6877 // Don't warn about function templates.
6878 if (FD->getDescribedFunctionTemplate())
6879 return false;
6880
6881 // Don't warn about function template specializations.
6882 if (FD->isFunctionTemplateSpecialization())
6883 return false;
6884
Anders Carlsson31c7e882009-12-09 03:30:09 +00006885 bool MissingPrototype = true;
6886 for (const FunctionDecl *Prev = FD->getPreviousDeclaration();
6887 Prev; Prev = Prev->getPreviousDeclaration()) {
6888 // Ignore any declarations that occur in function or method
6889 // scope, because they aren't visible from the header.
6890 if (Prev->getDeclContext()->isFunctionOrMethod())
6891 continue;
6892
6893 MissingPrototype = !Prev->getType()->isFunctionProtoType();
6894 break;
6895 }
6896
6897 return MissingPrototype;
6898}
6899
Francois Pichetdcb3ebe2011-04-22 23:20:44 +00006900void Sema::CheckForFunctionRedefinition(FunctionDecl *FD) {
6901 // Don't complain if we're in GNU89 mode and the previous definition
6902 // was an extern inline function.
6903 const FunctionDecl *Definition;
Alexis Hunt4a8ea102011-05-06 20:44:56 +00006904 if (FD->isDefined(Definition) &&
Francois Pichetdcb3ebe2011-04-22 23:20:44 +00006905 !canRedefineFunction(Definition, getLangOptions())) {
6906 if (getLangOptions().GNUMode && Definition->isInlineSpecified() &&
6907 Definition->getStorageClass() == SC_Extern)
6908 Diag(FD->getLocation(), diag::err_redefinition_extern_inline)
6909 << FD->getDeclName() << getLangOptions().CPlusPlus;
6910 else
6911 Diag(FD->getLocation(), diag::err_redefinition) << FD->getDeclName();
6912 Diag(Definition->getLocation(), diag::note_previous_definition);
6913 }
6914}
6915
John McCall48871652010-08-21 09:40:31 +00006916Decl *Sema::ActOnStartOfFunctionDef(Scope *FnBodyScope, Decl *D) {
Anders Carlsson561f7932009-10-29 15:46:07 +00006917 // Clear the last template instantiation error context.
6918 LastTemplateInstantiationErrorContext = ActiveTemplateInstantiation();
6919
Douglas Gregor17a7c122009-06-24 00:54:41 +00006920 if (!D)
6921 return D;
Douglas Gregorc45a40a2009-08-22 00:34:47 +00006922 FunctionDecl *FD = 0;
Mike Stump11289f42009-09-09 15:08:12 +00006923
John McCall48871652010-08-21 09:40:31 +00006924 if (FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(D))
Douglas Gregorc45a40a2009-08-22 00:34:47 +00006925 FD = FunTmpl->getTemplatedDecl();
6926 else
John McCall48871652010-08-21 09:40:31 +00006927 FD = cast<FunctionDecl>(D);
Douglas Gregorcad304ba2008-10-29 15:10:40 +00006928
Douglas Gregor9a28e842010-03-01 23:15:13 +00006929 // Enter a new function scope
6930 PushFunctionScope();
Mike Stump11289f42009-09-09 15:08:12 +00006931
Douglas Gregorcad304ba2008-10-29 15:10:40 +00006932 // See if this is a redefinition.
Francois Pichetdcb3ebe2011-04-22 23:20:44 +00006933 if (!FD->isLateTemplateParsed())
6934 CheckForFunctionRedefinition(FD);
Douglas Gregorcad304ba2008-10-29 15:10:40 +00006935
Douglas Gregor75a45ba2009-02-16 17:45:42 +00006936 // Builtin functions cannot be defined.
Douglas Gregor15fc9562009-09-12 00:22:50 +00006937 if (unsigned BuiltinID = FD->getBuiltinID()) {
Douglas Gregor7a0febe2009-02-17 16:03:01 +00006938 if (!Context.BuiltinInfo.isPredefinedLibFunction(BuiltinID)) {
Douglas Gregor75a45ba2009-02-16 17:45:42 +00006939 Diag(FD->getLocation(), diag::err_builtin_definition) << FD;
Douglas Gregor7a0febe2009-02-17 16:03:01 +00006940 FD->setInvalidDecl();
6941 }
Douglas Gregor75a45ba2009-02-16 17:45:42 +00006942 }
6943
Eli Friedman9ad72442009-03-04 07:30:59 +00006944 // The return type of a function definition must be complete
Douglas Gregorac1fb652009-03-24 19:52:54 +00006945 // (C99 6.9.1p3, C++ [dcl.fct]p6).
6946 QualType ResultType = FD->getResultType();
6947 if (!ResultType->isDependentType() && !ResultType->isVoidType() &&
Chris Lattner0f94c5a2009-04-29 05:12:23 +00006948 !FD->isInvalidDecl() &&
Douglas Gregorac1fb652009-03-24 19:52:54 +00006949 RequireCompleteType(FD->getLocation(), ResultType,
6950 diag::err_func_def_incomplete_result))
Eli Friedman9ad72442009-03-04 07:30:59 +00006951 FD->setInvalidDecl();
Eli Friedman9ad72442009-03-04 07:30:59 +00006952
Douglas Gregorf1b876d2009-03-31 16:35:03 +00006953 // GNU warning -Wmissing-prototypes:
6954 // Warn if a global function is defined without a previous
6955 // prototype declaration. This warning is issued even if the
6956 // definition itself provides a prototype. The aim is to detect
6957 // global functions that fail to be declared in header files.
Anders Carlsson31c7e882009-12-09 03:30:09 +00006958 if (ShouldWarnAboutMissingPrototype(FD))
6959 Diag(FD->getLocation(), diag::warn_missing_prototype) << FD;
Douglas Gregorf1b876d2009-03-31 16:35:03 +00006960
Douglas Gregor67da0d92009-05-15 17:59:04 +00006961 if (FnBodyScope)
6962 PushDeclContext(FnBodyScope, FD);
Anton Korobeynikovd72f47a2008-12-26 00:52:02 +00006963
Chris Lattneraa9c7ae2008-04-08 04:40:51 +00006964 // Check the validity of our function parameters
Douglas Gregorb524d902010-11-01 18:37:59 +00006965 CheckParmsForFunctionDef(FD->param_begin(), FD->param_end(),
6966 /*CheckParameterNames=*/true);
Chris Lattneraa9c7ae2008-04-08 04:40:51 +00006967
6968 // Introduce our parameters into the function scope
6969 for (unsigned p = 0, NumParams = FD->getNumParams(); p < NumParams; ++p) {
6970 ParmVarDecl *Param = FD->getParamDecl(p);
Douglas Gregorc72e6452009-01-09 18:51:29 +00006971 Param->setOwningFunction(FD);
6972
Chris Lattneraa9c7ae2008-04-08 04:40:51 +00006973 // If this has an identifier, add it to the scope stack.
John McCalldf8b37c2010-03-22 09:20:08 +00006974 if (Param->getIdentifier() && FnBodyScope) {
Argyrios Kyrtzidis1cb0de12010-12-15 18:44:22 +00006975 CheckShadow(FnBodyScope, Param);
John McCalldf8b37c2010-03-22 09:20:08 +00006976
Argyrios Kyrtzidisb8a49202008-04-12 00:47:19 +00006977 PushOnScopeChains(Param, FnBodyScope);
John McCalldf8b37c2010-03-22 09:20:08 +00006978 }
Chris Lattnerf61c8a82007-01-21 19:04:43 +00006979 }
Chris Lattneraa9c7ae2008-04-08 04:40:51 +00006980
Anton Korobeynikovd72f47a2008-12-26 00:52:02 +00006981 // Checking attributes of current function definition
6982 // dllimport attribute.
Alexis Huntdcfba7b2010-08-18 23:23:40 +00006983 DLLImportAttr *DA = FD->getAttr<DLLImportAttr>();
6984 if (DA && (!FD->getAttr<DLLExportAttr>())) {
6985 // dllimport attribute cannot be directly applied to definition.
Francois Pichet3096d202011-03-29 10:39:17 +00006986 // Microsoft accepts dllimport for functions defined within class scope.
6987 if (!DA->isInherited() &&
Francois Pichet0706d202011-09-17 17:15:52 +00006988 !(LangOpts.MicrosoftExt && FD->getLexicalDeclContext()->isRecord())) {
Anton Korobeynikovd72f47a2008-12-26 00:52:02 +00006989 Diag(FD->getLocation(),
6990 diag::err_attribute_can_be_applied_only_to_symbol_declaration)
6991 << "dllimport";
6992 FD->setInvalidDecl();
John McCall48871652010-08-21 09:40:31 +00006993 return FD;
Ted Kremeneka3cfc4d2010-02-21 05:12:53 +00006994 }
6995
6996 // Visual C++ appears to not think this is an issue, so only issue
6997 // a warning when Microsoft extensions are disabled.
Francois Pichet0706d202011-09-17 17:15:52 +00006998 if (!LangOpts.MicrosoftExt) {
Anton Korobeynikovd72f47a2008-12-26 00:52:02 +00006999 // If a symbol previously declared dllimport is later defined, the
7000 // attribute is ignored in subsequent references, and a warning is
7001 // emitted.
7002 Diag(FD->getLocation(),
7003 diag::warn_redeclaration_without_attribute_prev_attribute_ignored)
Daniel Dunbar56df9772010-08-17 22:39:59 +00007004 << FD->getName() << "dllimport";
Anton Korobeynikovd72f47a2008-12-26 00:52:02 +00007005 }
7006 }
John McCall48871652010-08-21 09:40:31 +00007007 return FD;
Chris Lattnere168f762006-11-10 05:29:30 +00007008}
7009
Douglas Gregor6fd1b182010-05-15 06:01:05 +00007010/// \brief Given the set of return statements within a function body,
7011/// compute the variables that are subject to the named return value
7012/// optimization.
7013///
7014/// Each of the variables that is subject to the named return value
7015/// optimization will be marked as NRVO variables in the AST, and any
7016/// return statement that has a marked NRVO variable as its NRVO candidate can
7017/// use the named return value optimization.
7018///
7019/// This function applies a very simplistic algorithm for NRVO: if every return
7020/// statement in the function has the same NRVO candidate, that candidate is
7021/// the NRVO variable.
7022///
7023/// FIXME: Employ a smarter algorithm that accounts for multiple return
7024/// statements and the lifetimes of the NRVO candidates. We should be able to
7025/// find a maximal set of NRVO variables.
Douglas Gregor49695f02011-09-06 20:46:03 +00007026void Sema::computeNRVO(Stmt *Body, FunctionScopeInfo *Scope) {
John McCallaab3e412010-08-25 08:40:02 +00007027 ReturnStmt **Returns = Scope->Returns.data();
7028
Douglas Gregor6fd1b182010-05-15 06:01:05 +00007029 const VarDecl *NRVOCandidate = 0;
John McCallaab3e412010-08-25 08:40:02 +00007030 for (unsigned I = 0, E = Scope->Returns.size(); I != E; ++I) {
Douglas Gregor6fd1b182010-05-15 06:01:05 +00007031 if (!Returns[I]->getNRVOCandidate())
7032 return;
7033
7034 if (!NRVOCandidate)
7035 NRVOCandidate = Returns[I]->getNRVOCandidate();
7036 else if (NRVOCandidate != Returns[I]->getNRVOCandidate())
7037 return;
7038 }
7039
7040 if (NRVOCandidate)
7041 const_cast<VarDecl*>(NRVOCandidate)->setNRVOVariable(true);
7042}
7043
John McCallfaf5fb42010-08-26 23:41:50 +00007044Decl *Sema::ActOnFinishFunctionBody(Decl *D, Stmt *BodyArg) {
Douglas Gregor67da0d92009-05-15 17:59:04 +00007045 return ActOnFinishFunctionBody(D, move(BodyArg), false);
7046}
7047
John McCallb268a282010-08-23 23:25:46 +00007048Decl *Sema::ActOnFinishFunctionBody(Decl *dcl, Stmt *Body,
7049 bool IsInstantiation) {
Douglas Gregorc45a40a2009-08-22 00:34:47 +00007050 FunctionDecl *FD = 0;
7051 FunctionTemplateDecl *FunTmpl = dyn_cast_or_null<FunctionTemplateDecl>(dcl);
7052 if (FunTmpl)
7053 FD = FunTmpl->getTemplatedDecl();
7054 else
7055 FD = dyn_cast_or_null<FunctionDecl>(dcl);
7056
Ted Kremenek0b405322010-03-23 00:13:23 +00007057 sema::AnalysisBasedWarnings::Policy WP = AnalysisWarnings.getDefaultPolicy();
Ted Kremenek1767a272011-02-23 01:51:48 +00007058 sema::AnalysisBasedWarnings::Policy *ActivePolicy = 0;
Ted Kremenek918fe842010-03-20 21:06:02 +00007059
Douglas Gregorc45a40a2009-08-22 00:34:47 +00007060 if (FD) {
Chris Lattner960cc522009-04-18 09:36:27 +00007061 FD->setBody(Body);
Ted Kremenek918fe842010-03-20 21:06:02 +00007062 if (FD->isMain()) {
Mike Stump8e79f992009-07-24 02:49:01 +00007063 // C and C++ allow for main to automagically return 0.
John McCallcaa19452009-07-28 01:00:58 +00007064 // Implements C++ [basic.start.main]p5 and C99 5.1.2.2.3.
7065 FD->setHasImplicitReturnZero(true);
Ted Kremenek0b405322010-03-23 00:13:23 +00007066 WP.disableCheckFallThrough();
Douglas Gregor9824aec2011-07-11 15:24:01 +00007067 } else if (FD->hasAttr<NakedAttr>()) {
7068 // If the function is marked 'naked', don't complain about missing return
7069 // statements.
7070 WP.disableCheckFallThrough();
Ted Kremenek918fe842010-03-20 21:06:02 +00007071 }
Mike Stump11289f42009-09-09 15:08:12 +00007072
Francois Pichet3abc9b82011-05-11 02:14:46 +00007073 // MSVC permits the use of pure specifier (=0) on function definition,
7074 // defined at class scope, warn about this non standard construct.
Francois Pichet0706d202011-09-17 17:15:52 +00007075 if (getLangOptions().MicrosoftExt && FD->isPure())
Francois Pichet3abc9b82011-05-11 02:14:46 +00007076 Diag(FD->getLocation(), diag::warn_pure_function_definition);
7077
Douglas Gregor88d292c2010-05-13 16:44:06 +00007078 if (!FD->isInvalidDecl()) {
Douglas Gregorc9c02ed2009-06-19 23:52:42 +00007079 DiagnoseUnusedParameters(FD->param_begin(), FD->param_end());
Argyrios Kyrtzidisaf84ec02010-11-17 23:11:54 +00007080 DiagnoseSizeOfParametersAndReturnValue(FD->param_begin(), FD->param_end(),
7081 FD->getResultType(), FD);
Douglas Gregor88d292c2010-05-13 16:44:06 +00007082
7083 // If this is a constructor, we need a vtable.
7084 if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(FD))
7085 MarkVTableUsed(FD->getLocation(), Constructor->getParent());
Douglas Gregor6fd1b182010-05-15 06:01:05 +00007086
Douglas Gregor49695f02011-09-06 20:46:03 +00007087 computeNRVO(Body, getCurFunction());
Douglas Gregor88d292c2010-05-13 16:44:06 +00007088 }
7089
Argyrios Kyrtzidis853fbea2008-06-28 06:07:14 +00007090 assert(FD == getCurFunctionDecl() && "Function parsing confused");
Steve Naroff542cd5d2008-07-25 17:57:26 +00007091 } else if (ObjCMethodDecl *MD = dyn_cast_or_null<ObjCMethodDecl>(dcl)) {
Chris Lattner1598a3a2009-02-16 19:27:54 +00007092 assert(MD == getCurMethodDecl() && "Method parsing confused");
Chris Lattner960cc522009-04-18 09:36:27 +00007093 MD->setBody(Body);
Argyrios Kyrtzidisd5756a62011-01-03 22:33:06 +00007094 if (Body)
7095 MD->setEndLoc(Body->getLocEnd());
Argyrios Kyrtzidisaf84ec02010-11-17 23:11:54 +00007096 if (!MD->isInvalidDecl()) {
Douglas Gregorc9c02ed2009-06-19 23:52:42 +00007097 DiagnoseUnusedParameters(MD->param_begin(), MD->param_end());
Argyrios Kyrtzidisaf84ec02010-11-17 23:11:54 +00007098 DiagnoseSizeOfParametersAndReturnValue(MD->param_begin(), MD->param_end(),
7099 MD->getResultType(), MD);
Douglas Gregore3f3ea02011-09-06 20:33:37 +00007100
7101 if (Body)
Douglas Gregor49695f02011-09-06 20:46:03 +00007102 computeNRVO(Body, getCurFunction());
Argyrios Kyrtzidisaf84ec02010-11-17 23:11:54 +00007103 }
Nico Weber715abaf2011-08-22 17:25:57 +00007104 if (ObjCShouldCallSuperDealloc) {
7105 Diag(MD->getLocEnd(), diag::warn_objc_missing_super_dealloc);
7106 ObjCShouldCallSuperDealloc = false;
7107 }
Nico Weber1fb82662011-08-28 22:35:17 +00007108 if (ObjCShouldCallSuperFinalize) {
7109 Diag(MD->getLocEnd(), diag::warn_objc_missing_super_finalize);
7110 ObjCShouldCallSuperFinalize = false;
7111 }
Ted Kremenek5a201952009-02-07 01:47:29 +00007112 } else {
John McCall48871652010-08-21 09:40:31 +00007113 return 0;
Ted Kremenek5a201952009-02-07 01:47:29 +00007114 }
Douglas Gregor67da0d92009-05-15 17:59:04 +00007115
Nico Weber715abaf2011-08-22 17:25:57 +00007116 assert(!ObjCShouldCallSuperDealloc && "This should only be set for "
7117 "ObjC methods, which should have been handled in the block above.");
Nico Weber1fb82662011-08-28 22:35:17 +00007118 assert(!ObjCShouldCallSuperFinalize && "This should only be set for "
7119 "ObjC methods, which should have been handled in the block above.");
Nico Weber715abaf2011-08-22 17:25:57 +00007120
Chris Lattnere2473062007-05-28 06:28:18 +00007121 // Verify and clean out per-function state.
Douglas Gregor9a28e842010-03-01 23:15:13 +00007122 if (Body) {
Douglas Gregor9a28e842010-03-01 23:15:13 +00007123 // C++ constructors that have function-try-blocks can't have return
7124 // statements in the handlers of that block. (C++ [except.handle]p14)
7125 // Verify this.
7126 if (FD && isa<CXXConstructorDecl>(FD) && isa<CXXTryStmt>(Body))
7127 DiagnoseReturnInConstructorExceptionHandler(cast<CXXTryStmt>(Body));
7128
Richard Smithdef8bdb2011-08-12 18:44:32 +00007129 // Verify that gotos and switch cases don't jump into scopes illegally.
John McCallaab3e412010-08-25 08:40:02 +00007130 if (getCurFunction()->NeedsScopeChecking() &&
John McCall58efb8e2010-05-20 07:13:26 +00007131 !dcl->isInvalidDecl() &&
John McCall31168b02011-06-15 23:02:42 +00007132 !hasAnyUnrecoverableErrorsInThisFunction())
Douglas Gregor9a28e842010-03-01 23:15:13 +00007133 DiagnoseInvalidJumps(Body);
Mike Stump11289f42009-09-09 15:08:12 +00007134
John McCalldeb646e2010-08-04 01:04:25 +00007135 if (CXXDestructorDecl *Destructor = dyn_cast<CXXDestructorDecl>(dcl)) {
7136 if (!Destructor->getParent()->isDependentType())
7137 CheckDestructor(Destructor);
7138
John McCalla6309952010-03-16 21:39:52 +00007139 MarkBaseAndMemberDestructorsReferenced(Destructor->getLocation(),
7140 Destructor->getParent());
John McCalldeb646e2010-08-04 01:04:25 +00007141 }
Douglas Gregor9a28e842010-03-01 23:15:13 +00007142
7143 // If any errors have occurred, clear out any temporaries that may have
7144 // been leftover. This ensures that these temporaries won't be picked up for
7145 // deletion in some later function.
Douglas Gregor550b98b2011-03-04 23:08:02 +00007146 if (PP.getDiagnostics().hasErrorOccurred() ||
John McCall31168b02011-06-15 23:02:42 +00007147 PP.getDiagnostics().getSuppressAllDiagnostics()) {
Douglas Gregor9a28e842010-03-01 23:15:13 +00007148 ExprTemporaries.clear();
John McCall31168b02011-06-15 23:02:42 +00007149 ExprNeedsCleanups = false;
7150 } else if (!isa<FunctionTemplateDecl>(dcl)) {
Ted Kremenek918fe842010-03-20 21:06:02 +00007151 // Since the body is valid, issue any analysis-based warnings that are
7152 // enabled.
Ted Kremenek1767a272011-02-23 01:51:48 +00007153 ActivePolicy = &WP;
Ted Kremenek918fe842010-03-20 21:06:02 +00007154 }
7155
Richard Smitheb3c10c2011-10-01 02:31:28 +00007156 if (FD && FD->isConstexpr() && !FD->isInvalidDecl() &&
7157 !CheckConstexprFunctionBody(FD, Body))
7158 FD->setInvalidDecl();
7159
Douglas Gregor9a28e842010-03-01 23:15:13 +00007160 assert(ExprTemporaries.empty() && "Leftover temporaries in function");
John McCall31168b02011-06-15 23:02:42 +00007161 assert(!ExprNeedsCleanups && "Unaccounted cleanups in function");
Douglas Gregor9a28e842010-03-01 23:15:13 +00007162 }
7163
John McCalle99d5f32010-03-25 22:08:03 +00007164 if (!IsInstantiation)
7165 PopDeclContext();
7166
Ted Kremenek1767a272011-02-23 01:51:48 +00007167 PopFunctionOrBlockScope(ActivePolicy, dcl);
Anders Carlsson1fe64cb2009-11-13 19:21:49 +00007168
Douglas Gregora7e3ea32009-11-15 07:07:58 +00007169 // If any errors have occurred, clear out any temporaries that may have
7170 // been leftover. This ensures that these temporaries won't be picked up for
7171 // deletion in some later function.
John McCall31168b02011-06-15 23:02:42 +00007172 if (getDiagnostics().hasErrorOccurred()) {
Douglas Gregora7e3ea32009-11-15 07:07:58 +00007173 ExprTemporaries.clear();
John McCall31168b02011-06-15 23:02:42 +00007174 ExprNeedsCleanups = false;
7175 }
Argyrios Kyrtzidis35672e72010-08-13 18:42:17 +00007176
John McCall48871652010-08-21 09:40:31 +00007177 return dcl;
Fariborz Jahanian85e1d0d2007-11-10 16:31:34 +00007178}
7179
Caitlin Sadowski9385dd72011-09-08 17:42:22 +00007180
7181/// When we finish delayed parsing of an attribute, we must attach it to the
7182/// relevant Decl.
7183void Sema::ActOnFinishDelayedAttribute(Scope *S, Decl *D,
7184 ParsedAttributes &Attrs) {
7185 ProcessDeclAttributeList(S, D, Attrs.getList());
7186}
7187
7188
Chris Lattnerac18be92006-11-20 06:49:47 +00007189/// ImplicitlyDefineFunction - An undeclared identifier was used in a function
7190/// call, forming a call to an implicitly defined function (per C99 6.5.1p2).
Mike Stump11289f42009-09-09 15:08:12 +00007191NamedDecl *Sema::ImplicitlyDefineFunction(SourceLocation Loc,
Douglas Gregor6e6ad602009-01-20 01:17:11 +00007192 IdentifierInfo &II, Scope *S) {
Douglas Gregor5a80bd12009-03-02 00:19:53 +00007193 // Before we produce a declaration for an implicitly defined
7194 // function, see whether there was a locally-scoped declaration of
7195 // this name as a function or variable. If so, use that
7196 // (non-visible) declaration, and complain about it.
7197 llvm::DenseMap<DeclarationName, NamedDecl *>::iterator Pos
Douglas Gregordc5c9582011-07-28 14:20:37 +00007198 = findLocallyScopedExternalDecl(&II);
Douglas Gregor5a80bd12009-03-02 00:19:53 +00007199 if (Pos != LocallyScopedExternalDecls.end()) {
7200 Diag(Loc, diag::warn_use_out_of_scope_declaration) << Pos->second;
7201 Diag(Pos->second->getLocation(), diag::note_previous_declaration);
7202 return Pos->second;
7203 }
7204
Chris Lattner00e26072008-05-05 21:18:06 +00007205 // Extension in C99. Legal in C90, but warn about it.
Daniel Dunbar07d07852009-10-18 21:17:35 +00007206 if (II.getName().startswith("__builtin_"))
Douglas Gregor56fbc372009-09-28 21:14:19 +00007207 Diag(Loc, diag::warn_builtin_unknown) << &II;
7208 else if (getLangOptions().C99)
Chris Lattner4bd8dd82008-11-19 08:23:25 +00007209 Diag(Loc, diag::ext_implicit_function_decl) << &II;
Chris Lattner00e26072008-05-05 21:18:06 +00007210 else
Chris Lattner4bd8dd82008-11-19 08:23:25 +00007211 Diag(Loc, diag::warn_implicit_function_decl) << &II;
Mike Stump11289f42009-09-09 15:08:12 +00007212
Chris Lattnerac18be92006-11-20 06:49:47 +00007213 // Set a Declarator for the implicit definition: int foo();
Chris Lattner353f5742006-11-28 04:50:12 +00007214 const char *Dummy;
John McCall084e83d2011-03-24 11:26:52 +00007215 AttributeFactory attrFactory;
7216 DeclSpec DS(attrFactory);
John McCall49bfce42009-08-03 20:12:06 +00007217 unsigned DiagID;
7218 bool Error = DS.SetTypeSpecType(DeclSpec::TST_int, Loc, Dummy, DiagID);
Jeffrey Yasskinb3321532010-12-23 01:01:28 +00007219 (void)Error; // Silence warning.
Chris Lattner353f5742006-11-28 04:50:12 +00007220 assert(!Error && "Error setting up implicit decl!");
Chris Lattnerac18be92006-11-20 06:49:47 +00007221 Declarator D(DS, Declarator::BlockContext);
John McCall084e83d2011-03-24 11:26:52 +00007222 D.AddTypeInfo(DeclaratorChunk::getFunction(false, false, SourceLocation(), 0,
Douglas Gregor54992352011-01-26 03:43:54 +00007223 0, 0, true, SourceLocation(),
Douglas Gregorad69e652011-07-13 21:47:47 +00007224 SourceLocation(),
Sebastian Redl802a4532011-03-05 22:42:13 +00007225 EST_None, SourceLocation(),
7226 0, 0, 0, 0, Loc, Loc, D),
John McCall084e83d2011-03-24 11:26:52 +00007227 DS.getAttributes(),
Sebastian Redlf6591ca2009-02-09 18:23:29 +00007228 SourceLocation());
Chris Lattnerac18be92006-11-20 06:49:47 +00007229 D.SetIdentifier(&II, Loc);
Sebastian Redlf6591ca2009-02-09 18:23:29 +00007230
Argyrios Kyrtzidis694dda12008-05-01 21:04:16 +00007231 // Insert this function into translation-unit scope.
7232
7233 DeclContext *PrevDC = CurContext;
7234 CurContext = Context.getTranslationUnitDecl();
Mike Stump11289f42009-09-09 15:08:12 +00007235
John McCall48871652010-08-21 09:40:31 +00007236 FunctionDecl *FD = dyn_cast<FunctionDecl>(ActOnDeclarator(TUScope, D));
Steve Naroff3913ea42008-04-04 14:32:09 +00007237 FD->setImplicit();
Argyrios Kyrtzidis694dda12008-05-01 21:04:16 +00007238
7239 CurContext = PrevDC;
7240
Douglas Gregore711f702009-02-14 18:57:46 +00007241 AddKnownFunctionAttributes(FD);
7242
Steve Naroff3913ea42008-04-04 14:32:09 +00007243 return FD;
Chris Lattnerac18be92006-11-20 06:49:47 +00007244}
7245
Douglas Gregore711f702009-02-14 18:57:46 +00007246/// \brief Adds any function attributes that we know a priori based on
7247/// the declaration of this function.
7248///
7249/// These attributes can apply both to implicitly-declared builtins
7250/// (like __builtin___printf_chk) or to library-declared functions
7251/// like NSLog or printf.
Douglas Gregor88336832011-06-15 05:45:11 +00007252///
7253/// We need to check for duplicate attributes both here and where user-written
7254/// attributes are applied to declarations.
Douglas Gregore711f702009-02-14 18:57:46 +00007255void Sema::AddKnownFunctionAttributes(FunctionDecl *FD) {
7256 if (FD->isInvalidDecl())
7257 return;
7258
7259 // If this is a built-in function, map its builtin attributes to
7260 // actual attributes.
Douglas Gregor15fc9562009-09-12 00:22:50 +00007261 if (unsigned BuiltinID = FD->getBuiltinID()) {
Douglas Gregore711f702009-02-14 18:57:46 +00007262 // Handle printf-formatting attributes.
7263 unsigned FormatIdx;
7264 bool HasVAListArg;
7265 if (Context.BuiltinInfo.isPrintfLike(BuiltinID, FormatIdx, HasVAListArg)) {
Argyrios Kyrtzidisb4b64ca2009-06-30 02:34:44 +00007266 if (!FD->getAttr<FormatAttr>())
Alexis Huntdcfba7b2010-08-18 23:23:40 +00007267 FD->addAttr(::new (Context) FormatAttr(FD->getLocation(), Context,
7268 "printf", FormatIdx+1,
Ted Kremenek7f4945a2010-02-11 05:28:37 +00007269 HasVAListArg ? 0 : FormatIdx+2));
Douglas Gregore711f702009-02-14 18:57:46 +00007270 }
Ted Kremenek5932c352010-07-16 02:11:15 +00007271 if (Context.BuiltinInfo.isScanfLike(BuiltinID, FormatIdx,
7272 HasVAListArg)) {
7273 if (!FD->getAttr<FormatAttr>())
Alexis Huntdcfba7b2010-08-18 23:23:40 +00007274 FD->addAttr(::new (Context) FormatAttr(FD->getLocation(), Context,
7275 "scanf", FormatIdx+1,
Ted Kremenek5932c352010-07-16 02:11:15 +00007276 HasVAListArg ? 0 : FormatIdx+2));
7277 }
Daniel Dunbar8eb018a2009-02-16 22:43:43 +00007278
7279 // Mark const if we don't care about errno and that is the only
7280 // thing preventing the function from being const. This allows
7281 // IRgen to use LLVM intrinsics for such functions.
7282 if (!getLangOptions().MathErrno &&
7283 Context.BuiltinInfo.isConstWithoutErrno(BuiltinID)) {
Argyrios Kyrtzidisb4b64ca2009-06-30 02:34:44 +00007284 if (!FD->getAttr<ConstAttr>())
Alexis Huntdcfba7b2010-08-18 23:23:40 +00007285 FD->addAttr(::new (Context) ConstAttr(FD->getLocation(), Context));
Daniel Dunbar8eb018a2009-02-16 22:43:43 +00007286 }
Mike Stumpca6c8752009-07-27 19:14:18 +00007287
Rafael Espindola2d21ab02011-10-12 19:51:18 +00007288 if (Context.BuiltinInfo.isReturnsTwice(BuiltinID) &&
7289 !FD->getAttr<ReturnsTwiceAttr>())
7290 FD->addAttr(::new (Context) ReturnsTwiceAttr(FD->getLocation(), Context));
Douglas Gregor88336832011-06-15 05:45:11 +00007291 if (Context.BuiltinInfo.isNoThrow(BuiltinID) && !FD->getAttr<NoThrowAttr>())
Alexis Huntdcfba7b2010-08-18 23:23:40 +00007292 FD->addAttr(::new (Context) NoThrowAttr(FD->getLocation(), Context));
Douglas Gregor88336832011-06-15 05:45:11 +00007293 if (Context.BuiltinInfo.isConst(BuiltinID) && !FD->getAttr<ConstAttr>())
Alexis Huntdcfba7b2010-08-18 23:23:40 +00007294 FD->addAttr(::new (Context) ConstAttr(FD->getLocation(), Context));
Douglas Gregore711f702009-02-14 18:57:46 +00007295 }
7296
7297 IdentifierInfo *Name = FD->getIdentifier();
7298 if (!Name)
7299 return;
Mike Stump11289f42009-09-09 15:08:12 +00007300 if ((!getLangOptions().CPlusPlus &&
Douglas Gregore711f702009-02-14 18:57:46 +00007301 FD->getDeclContext()->isTranslationUnit()) ||
7302 (isa<LinkageSpecDecl>(FD->getDeclContext()) &&
Mike Stump11289f42009-09-09 15:08:12 +00007303 cast<LinkageSpecDecl>(FD->getDeclContext())->getLanguage() ==
Douglas Gregore711f702009-02-14 18:57:46 +00007304 LinkageSpecDecl::lang_c)) {
7305 // Okay: this could be a libc/libm/Objective-C function we know
7306 // about.
7307 } else
7308 return;
7309
Douglas Gregorfedd4282009-04-22 20:56:09 +00007310 if (Name->isStr("NSLog") || Name->isStr("NSLogv")) {
Mike Stump82a9e442009-07-28 00:07:08 +00007311 // FIXME: NSLog and NSLogv should be target specific
Argyrios Kyrtzidisb4b64ca2009-06-30 02:34:44 +00007312 if (const FormatAttr *Format = FD->getAttr<FormatAttr>()) {
Douglas Gregore711f702009-02-14 18:57:46 +00007313 // FIXME: We known better than our headers.
Ted Kremenek7f4945a2010-02-11 05:28:37 +00007314 const_cast<FormatAttr *>(Format)->setType(Context, "printf");
Mike Stump11289f42009-09-09 15:08:12 +00007315 } else
Alexis Huntdcfba7b2010-08-18 23:23:40 +00007316 FD->addAttr(::new (Context) FormatAttr(FD->getLocation(), Context,
7317 "printf", 1,
Eli Friedmanf4799842009-06-10 04:01:38 +00007318 Name->isStr("NSLogv") ? 0 : 2));
Douglas Gregorfedd4282009-04-22 20:56:09 +00007319 } else if (Name->isStr("asprintf") || Name->isStr("vasprintf")) {
Mike Stump82a9e442009-07-28 00:07:08 +00007320 // FIXME: asprintf and vasprintf aren't C99 functions. Should they be
Mike Stump11289f42009-09-09 15:08:12 +00007321 // target-specific builtins, perhaps?
Argyrios Kyrtzidisb4b64ca2009-06-30 02:34:44 +00007322 if (!FD->getAttr<FormatAttr>())
Alexis Huntdcfba7b2010-08-18 23:23:40 +00007323 FD->addAttr(::new (Context) FormatAttr(FD->getLocation(), Context,
7324 "printf", 2,
Eli Friedmanf4799842009-06-10 04:01:38 +00007325 Name->isStr("vasprintf") ? 0 : 3));
Mike Stumpa4de80b2009-07-28 02:25:19 +00007326 }
Douglas Gregore711f702009-02-14 18:57:46 +00007327}
Chris Lattner302b4be2006-11-19 02:31:38 +00007328
John McCall703a3f82009-10-24 08:00:42 +00007329TypedefDecl *Sema::ParseTypedefDecl(Scope *S, Declarator &D, QualType T,
John McCallbcd03502009-12-07 02:54:59 +00007330 TypeSourceInfo *TInfo) {
Chris Lattner776fac82007-06-09 00:53:06 +00007331 assert(D.getIdentifier() && "Wrong callback for declspec without declarator");
Steve Narofff93b6722007-08-28 20:14:24 +00007332 assert(!T.isNull() && "GetTypeForDeclarator() returned null type");
Mike Stump11289f42009-09-09 15:08:12 +00007333
John McCallbcd03502009-12-07 02:54:59 +00007334 if (!TInfo) {
John McCall703a3f82009-10-24 08:00:42 +00007335 assert(D.isInvalidType() && "no declarator info for valid type");
John McCallbcd03502009-12-07 02:54:59 +00007336 TInfo = Context.getTrivialTypeSourceInfo(T);
John McCall703a3f82009-10-24 08:00:42 +00007337 }
7338
Chris Lattner18b19622007-01-22 07:39:13 +00007339 // Scope manipulation handled by caller.
Chris Lattnerc5ffed42008-04-04 06:12:32 +00007340 TypedefDecl *NewTD = TypedefDecl::Create(Context, CurContext,
Abramo Bagnarab3185b02011-03-06 15:48:19 +00007341 D.getSourceRange().getBegin(),
Chris Lattnerc5ffed42008-04-04 06:12:32 +00007342 D.getIdentifierLoc(),
Mike Stump11289f42009-09-09 15:08:12 +00007343 D.getIdentifier(),
John McCallbcd03502009-12-07 02:54:59 +00007344 TInfo);
Mike Stump11289f42009-09-09 15:08:12 +00007345
John McCall04fcd0d2011-02-01 08:20:08 +00007346 // Bail out immediately if we have an invalid declaration.
7347 if (D.isInvalidType()) {
7348 NewTD->setInvalidDecl();
7349 return NewTD;
Anders Carlsson02751152009-03-10 17:07:44 +00007350 }
7351
Douglas Gregor41866812011-09-12 18:37:38 +00007352 if (D.getDeclSpec().isModulePrivateSpecified()) {
7353 if (CurContext->isFunctionOrMethod())
7354 Diag(NewTD->getLocation(), diag::err_module_private_local)
7355 << 2 << NewTD->getDeclName()
7356 << SourceRange(D.getDeclSpec().getModulePrivateSpecLoc())
7357 << FixItHint::CreateRemoval(D.getDeclSpec().getModulePrivateSpecLoc());
7358 else
7359 NewTD->setModulePrivate();
7360 }
Douglas Gregor26701a42011-09-09 02:06:17 +00007361
John McCall04fcd0d2011-02-01 08:20:08 +00007362 // C++ [dcl.typedef]p8:
7363 // If the typedef declaration defines an unnamed class (or
7364 // enum), the first typedef-name declared by the declaration
7365 // to be that class type (or enum type) is used to denote the
7366 // class type (or enum type) for linkage purposes only.
7367 // We need to check whether the type was declared in the declaration.
7368 switch (D.getDeclSpec().getTypeSpecType()) {
7369 case TST_enum:
7370 case TST_struct:
7371 case TST_union:
7372 case TST_class: {
7373 TagDecl *tagFromDeclSpec = cast<TagDecl>(D.getDeclSpec().getRepAsDecl());
7374
7375 // Do nothing if the tag is not anonymous or already has an
7376 // associated typedef (from an earlier typedef in this decl group).
7377 if (tagFromDeclSpec->getIdentifier()) break;
Richard Smithdda56e42011-04-15 14:24:37 +00007378 if (tagFromDeclSpec->getTypedefNameForAnonDecl()) break;
John McCall04fcd0d2011-02-01 08:20:08 +00007379
7380 // A well-formed anonymous tag must always be a TUK_Definition.
7381 assert(tagFromDeclSpec->isThisDeclarationADefinition());
7382
7383 // The type must match the tag exactly; no qualifiers allowed.
7384 if (!Context.hasSameType(T, Context.getTagDeclType(tagFromDeclSpec)))
7385 break;
7386
7387 // Otherwise, set this is the anon-decl typedef for the tag.
Richard Smithdda56e42011-04-15 14:24:37 +00007388 tagFromDeclSpec->setTypedefNameForAnonDecl(NewTD);
John McCall04fcd0d2011-02-01 08:20:08 +00007389 break;
7390 }
7391
7392 default:
7393 break;
7394 }
7395
Steve Narofff93b6722007-08-28 20:14:24 +00007396 return NewTD;
Chris Lattnere168f762006-11-10 05:29:30 +00007397}
7398
Douglas Gregord9034f02009-05-14 16:41:31 +00007399
7400/// \brief Determine whether a tag with a given kind is acceptable
7401/// as a redeclaration of the given tag declaration.
7402///
7403/// \returns true if the new tag kind is acceptable, false otherwise.
Mike Stump11289f42009-09-09 15:08:12 +00007404bool Sema::isAcceptableTagRedeclaration(const TagDecl *Previous,
Richard Trieucaa33d32011-06-10 03:11:26 +00007405 TagTypeKind NewTag, bool isDefinition,
Douglas Gregord9034f02009-05-14 16:41:31 +00007406 SourceLocation NewTagLoc,
7407 const IdentifierInfo &Name) {
7408 // C++ [dcl.type.elab]p3:
7409 // The class-key or enum keyword present in the
7410 // elaborated-type-specifier shall agree in kind with the
Abramo Bagnara6150c882010-05-11 21:36:43 +00007411 // declaration to which the name in the elaborated-type-specifier
Douglas Gregord9034f02009-05-14 16:41:31 +00007412 // refers. This rule also applies to the form of
7413 // elaborated-type-specifier that declares a class-name or
7414 // friend class since it can be construed as referring to the
7415 // definition of the class. Thus, in any
7416 // elaborated-type-specifier, the enum keyword shall be used to
Abramo Bagnara6150c882010-05-11 21:36:43 +00007417 // refer to an enumeration (7.2), the union class-key shall be
Douglas Gregord9034f02009-05-14 16:41:31 +00007418 // used to refer to a union (clause 9), and either the class or
7419 // struct class-key shall be used to refer to a class (clause 9)
7420 // declared using the class or struct class-key.
Abramo Bagnara6150c882010-05-11 21:36:43 +00007421 TagTypeKind OldTag = Previous->getTagKind();
Richard Trieucaa33d32011-06-10 03:11:26 +00007422 if (!isDefinition || (NewTag != TTK_Class && NewTag != TTK_Struct))
7423 if (OldTag == NewTag)
7424 return true;
Mike Stump11289f42009-09-09 15:08:12 +00007425
Abramo Bagnara6150c882010-05-11 21:36:43 +00007426 if ((OldTag == TTK_Struct || OldTag == TTK_Class) &&
7427 (NewTag == TTK_Struct || NewTag == TTK_Class)) {
Douglas Gregord9034f02009-05-14 16:41:31 +00007428 // Warn about the struct/class tag mismatch.
7429 bool isTemplate = false;
7430 if (const CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(Previous))
7431 isTemplate = Record->getDescribedClassTemplate();
7432
Richard Trieucaa33d32011-06-10 03:11:26 +00007433 if (!ActiveTemplateInstantiations.empty()) {
7434 // In a template instantiation, do not offer fix-its for tag mismatches
7435 // since they usually mess up the template instead of fixing the problem.
7436 Diag(NewTagLoc, diag::warn_struct_class_tag_mismatch)
7437 << (NewTag == TTK_Class) << isTemplate << &Name;
7438 return true;
7439 }
7440
7441 if (isDefinition) {
7442 // On definitions, check previous tags and issue a fix-it for each
7443 // one that doesn't match the current tag.
7444 if (Previous->getDefinition()) {
7445 // Don't suggest fix-its for redefinitions.
7446 return true;
7447 }
7448
7449 bool previousMismatch = false;
7450 for (TagDecl::redecl_iterator I(Previous->redecls_begin()),
7451 E(Previous->redecls_end()); I != E; ++I) {
7452 if (I->getTagKind() != NewTag) {
7453 if (!previousMismatch) {
7454 previousMismatch = true;
7455 Diag(NewTagLoc, diag::warn_struct_class_previous_tag_mismatch)
7456 << (NewTag == TTK_Class) << isTemplate << &Name;
7457 }
7458 Diag(I->getInnerLocStart(), diag::note_struct_class_suggestion)
7459 << (NewTag == TTK_Class)
7460 << FixItHint::CreateReplacement(I->getInnerLocStart(),
7461 NewTag == TTK_Class?
7462 "class" : "struct");
7463 }
7464 }
7465 return true;
7466 }
7467
7468 // Check for a previous definition. If current tag and definition
7469 // are same type, do nothing. If no definition, but disagree with
7470 // with previous tag type, give a warning, but no fix-it.
7471 const TagDecl *Redecl = Previous->getDefinition() ?
7472 Previous->getDefinition() : Previous;
7473 if (Redecl->getTagKind() == NewTag) {
7474 return true;
7475 }
7476
Douglas Gregord9034f02009-05-14 16:41:31 +00007477 Diag(NewTagLoc, diag::warn_struct_class_tag_mismatch)
Abramo Bagnara6150c882010-05-11 21:36:43 +00007478 << (NewTag == TTK_Class)
Richard Trieucaa33d32011-06-10 03:11:26 +00007479 << isTemplate << &Name;
7480 Diag(Redecl->getLocation(), diag::note_previous_use);
7481
7482 // If there is a previous defintion, suggest a fix-it.
7483 if (Previous->getDefinition()) {
7484 Diag(NewTagLoc, diag::note_struct_class_suggestion)
7485 << (Redecl->getTagKind() == TTK_Class)
7486 << FixItHint::CreateReplacement(SourceRange(NewTagLoc),
7487 Redecl->getTagKind() == TTK_Class? "class" : "struct");
7488 }
7489
Douglas Gregord9034f02009-05-14 16:41:31 +00007490 return true;
7491 }
7492 return false;
7493}
7494
Steve Naroff30d242c2007-09-15 18:49:24 +00007495/// ActOnTag - This is invoked when we see 'struct foo' or 'struct {'. In the
Chris Lattner1300fb92007-01-23 23:42:53 +00007496/// former case, Name will be non-null. In the later case, Name will be null.
John McCall9bb74a52009-07-31 02:45:11 +00007497/// TagSpec indicates what kind of tag this is. TUK indicates whether this is a
Chris Lattner1300fb92007-01-23 23:42:53 +00007498/// reference/declaration/definition of a tag.
John McCall48871652010-08-21 09:40:31 +00007499Decl *Sema::ActOnTag(Scope *S, unsigned TagSpec, TagUseKind TUK,
Douglas Gregor009f6992010-09-16 23:58:57 +00007500 SourceLocation KWLoc, CXXScopeSpec &SS,
7501 IdentifierInfo *Name, SourceLocation NameLoc,
7502 AttributeList *Attr, AccessSpecifier AS,
Douglas Gregor2820e692011-09-09 19:05:14 +00007503 SourceLocation ModulePrivateLoc,
Douglas Gregor009f6992010-09-16 23:58:57 +00007504 MultiTemplateParamsArg TemplateParameterLists,
Abramo Bagnara0e05e242010-12-03 18:54:17 +00007505 bool &OwnedDecl, bool &IsDependent,
7506 bool ScopedEnum, bool ScopedEnumUsesClassTag,
Douglas Gregor0bf31402010-10-08 23:50:27 +00007507 TypeResult UnderlyingType) {
Douglas Gregorc811d8f2008-12-15 16:32:14 +00007508 // If this is not a definition, it must have a name.
John McCall9bb74a52009-07-31 02:45:11 +00007509 assert((Name != 0 || TUK == TUK_Definition) &&
Chris Lattner7b9ace62007-01-23 20:11:08 +00007510 "Nameless record must be a definition!");
John McCallace48cd2010-10-19 01:40:49 +00007511 assert(TemplateParameterLists.size() == 0 || TUK != TUK_Reference);
Douglas Gregorded2d7b2009-02-04 19:02:06 +00007512
Douglas Gregord6ab8742009-05-28 23:31:59 +00007513 OwnedDecl = false;
Abramo Bagnara6150c882010-05-11 21:36:43 +00007514 TagTypeKind Kind = TypeWithKeyword::getTagTypeKindForTypeSpec(TagSpec);
Mike Stump11289f42009-09-09 15:08:12 +00007515
Douglas Gregor5c0405d2009-10-07 22:35:40 +00007516 // FIXME: Check explicit specializations more carefully.
7517 bool isExplicitSpecialization = false;
Douglas Gregor5f0e2522010-07-14 23:14:12 +00007518 bool Invalid = false;
John McCallace48cd2010-10-19 01:40:49 +00007519
7520 // We only need to do this matching if we have template parameters
7521 // or a scope specifier, which also conveniently avoids this work
7522 // for non-C++ cases.
Abramo Bagnara60804e12011-03-18 15:16:37 +00007523 if (TemplateParameterLists.size() > 0 ||
John McCallace48cd2010-10-19 01:40:49 +00007524 (SS.isNotEmpty() && TUK != TUK_Reference)) {
Douglas Gregore93e46c2009-07-22 23:48:44 +00007525 if (TemplateParameterList *TemplateParams
Douglas Gregor972fe532011-05-10 18:27:06 +00007526 = MatchTemplateParametersToScopeSpecifier(KWLoc, NameLoc, SS,
John McCallc9739e32010-10-16 07:23:36 +00007527 TemplateParameterLists.get(),
Abramo Bagnara60804e12011-03-18 15:16:37 +00007528 TemplateParameterLists.size(),
John McCalle820e5e2010-04-13 20:37:33 +00007529 TUK == TUK_Friend,
Douglas Gregor5f0e2522010-07-14 23:14:12 +00007530 isExplicitSpecialization,
7531 Invalid)) {
Douglas Gregor3dad8422009-09-26 06:47:28 +00007532 if (TemplateParams->size() > 0) {
Douglas Gregore93e46c2009-07-22 23:48:44 +00007533 // This is a declaration or definition of a class template (which may
7534 // be a member of another template).
Abramo Bagnara60804e12011-03-18 15:16:37 +00007535
Douglas Gregor5f0e2522010-07-14 23:14:12 +00007536 if (Invalid)
John McCall48871652010-08-21 09:40:31 +00007537 return 0;
Abramo Bagnara0adf29a2011-03-10 13:28:31 +00007538
Douglas Gregore93e46c2009-07-22 23:48:44 +00007539 OwnedDecl = false;
John McCall9bb74a52009-07-31 02:45:11 +00007540 DeclResult Result = CheckClassTemplate(S, TagSpec, TUK, KWLoc,
Douglas Gregore93e46c2009-07-22 23:48:44 +00007541 SS, Name, NameLoc, Attr,
Abramo Bagnara0adf29a2011-03-10 13:28:31 +00007542 TemplateParams, AS,
Douglas Gregor2820e692011-09-09 19:05:14 +00007543 ModulePrivateLoc,
Abramo Bagnara60804e12011-03-18 15:16:37 +00007544 TemplateParameterLists.size() - 1,
Abramo Bagnara0adf29a2011-03-10 13:28:31 +00007545 (TemplateParameterList**) TemplateParameterLists.release());
Douglas Gregore93e46c2009-07-22 23:48:44 +00007546 return Result.get();
7547 } else {
Douglas Gregorbbe8f462009-10-08 15:14:33 +00007548 // The "template<>" header is extraneous.
7549 Diag(TemplateParams->getTemplateLoc(), diag::err_template_tag_noparams)
Abramo Bagnara6150c882010-05-11 21:36:43 +00007550 << TypeWithKeyword::getTagTypeKindName(Kind) << Name;
Douglas Gregorbbe8f462009-10-08 15:14:33 +00007551 isExplicitSpecialization = true;
Douglas Gregore93e46c2009-07-22 23:48:44 +00007552 }
Mike Stump11289f42009-09-09 15:08:12 +00007553 }
7554 }
7555
Douglas Gregor0bf31402010-10-08 23:50:27 +00007556 // Figure out the underlying type if this a enum declaration. We need to do
7557 // this early, because it's needed to detect if this is an incompatible
7558 // redeclaration.
7559 llvm::PointerUnion<const Type*, TypeSourceInfo*> EnumUnderlying;
7560
7561 if (Kind == TTK_Enum) {
7562 if (UnderlyingType.isInvalid() || (!UnderlyingType.get() && ScopedEnum))
7563 // No underlying type explicitly specified, or we failed to parse the
7564 // type, default to int.
7565 EnumUnderlying = Context.IntTy.getTypePtr();
7566 else if (UnderlyingType.get()) {
7567 // C++0x 7.2p2: The type-specifier-seq of an enum-base shall name an
7568 // integral type; any cv-qualification is ignored.
7569 TypeSourceInfo *TI = 0;
7570 QualType T = GetTypeFromParser(UnderlyingType.get(), &TI);
7571 EnumUnderlying = TI;
7572
7573 SourceLocation UnderlyingLoc = TI->getTypeLoc().getBeginLoc();
7574
7575 if (!T->isDependentType() && !T->isIntegralType(Context)) {
7576 Diag(UnderlyingLoc, diag::err_enum_invalid_underlying)
7577 << T;
7578 // Recover by falling back to int.
7579 EnumUnderlying = Context.IntTy.getTypePtr();
7580 }
Douglas Gregor2b988fd2010-12-16 00:24:44 +00007581
7582 if (DiagnoseUnexpandedParameterPack(UnderlyingLoc, TI,
7583 UPPC_FixedUnderlyingType))
7584 EnumUnderlying = Context.IntTy.getTypePtr();
7585
Francois Pichet0706d202011-09-17 17:15:52 +00007586 } else if (getLangOptions().MicrosoftExt)
Francois Picheta3108062010-10-18 15:01:13 +00007587 // Microsoft enums are always of int type.
7588 EnumUnderlying = Context.IntTy.getTypePtr();
Douglas Gregor0bf31402010-10-08 23:50:27 +00007589 }
7590
Douglas Gregorc6f58fe2009-01-12 22:49:06 +00007591 DeclContext *SearchDC = CurContext;
Argyrios Kyrtzidis8ad00b22008-11-09 22:53:32 +00007592 DeclContext *DC = CurContext;
Douglas Gregor87f54062009-09-15 22:30:29 +00007593 bool isStdBadAlloc = false;
Douglas Gregordee1be82009-01-17 00:42:38 +00007594
Chandler Carrutha419dbb2010-03-01 21:17:36 +00007595 RedeclarationKind Redecl = ForRedeclaration;
7596 if (TUK == TUK_Friend || TUK == TUK_Reference)
7597 Redecl = NotForRedeclaration;
John McCall1f82f242009-11-18 22:49:29 +00007598
7599 LookupResult Previous(*this, Name, NameLoc, LookupTagName, Redecl);
John McCall6538c932009-10-10 05:48:19 +00007600
Argyrios Kyrtzidise02eb2b2008-11-09 22:09:58 +00007601 if (Name && SS.isNotEmpty()) {
7602 // We have a nested-name tag ('struct foo::bar').
7603
7604 // Check for invalid 'foo::'.
Argyrios Kyrtzidis8ad00b22008-11-09 22:53:32 +00007605 if (SS.isInvalid()) {
Argyrios Kyrtzidise02eb2b2008-11-09 22:09:58 +00007606 Name = 0;
7607 goto CreateNewDecl;
7608 }
7609
John McCall7f41d982009-09-11 04:59:25 +00007610 // If this is a friend or a reference to a class in a dependent
7611 // context, don't try to make a decl for it.
7612 if (TUK == TUK_Friend || TUK == TUK_Reference) {
7613 DC = computeDeclContext(SS, false);
7614 if (!DC) {
7615 IsDependent = true;
John McCall48871652010-08-21 09:40:31 +00007616 return 0;
John McCall7f41d982009-09-11 04:59:25 +00007617 }
John McCall0b66eb32010-05-01 00:40:08 +00007618 } else {
7619 DC = computeDeclContext(SS, true);
7620 if (!DC) {
7621 Diag(SS.getRange().getBegin(), diag::err_dependent_nested_name_spec)
7622 << SS.getRange();
John McCall48871652010-08-21 09:40:31 +00007623 return 0;
John McCall0b66eb32010-05-01 00:40:08 +00007624 }
John McCall7f41d982009-09-11 04:59:25 +00007625 }
7626
John McCall0b66eb32010-05-01 00:40:08 +00007627 if (RequireCompleteDeclContext(SS, DC))
John McCall48871652010-08-21 09:40:31 +00007628 return 0;
Douglas Gregor2ec748c2009-05-14 00:28:11 +00007629
Douglas Gregor8761da52009-02-03 00:34:39 +00007630 SearchDC = DC;
Argyrios Kyrtzidis8ad00b22008-11-09 22:53:32 +00007631 // Look-up name inside 'foo::'.
John McCall1f82f242009-11-18 22:49:29 +00007632 LookupQualifiedName(Previous, DC);
John McCall6538c932009-10-10 05:48:19 +00007633
John McCall1f82f242009-11-18 22:49:29 +00007634 if (Previous.isAmbiguous())
John McCall48871652010-08-21 09:40:31 +00007635 return 0;
John McCall6538c932009-10-10 05:48:19 +00007636
John McCall1f82f242009-11-18 22:49:29 +00007637 if (Previous.empty()) {
Douglas Gregord2e6a452010-01-14 17:47:39 +00007638 // Name lookup did not find anything. However, if the
7639 // nested-name-specifier refers to the current instantiation,
7640 // and that current instantiation has any dependent base
7641 // classes, we might find something at instantiation time: treat
7642 // this as a dependent elaborated-type-specifier.
John McCallace48cd2010-10-19 01:40:49 +00007643 // But this only makes any sense for reference-like lookups.
7644 if (Previous.wasNotFoundInCurrentInstantiation() &&
7645 (TUK == TUK_Reference || TUK == TUK_Friend)) {
Douglas Gregord2e6a452010-01-14 17:47:39 +00007646 IsDependent = true;
John McCall48871652010-08-21 09:40:31 +00007647 return 0;
Douglas Gregord2e6a452010-01-14 17:47:39 +00007648 }
7649
7650 // A tag 'foo::bar' must already exist.
Douglas Gregorf5af3582010-03-31 23:17:41 +00007651 Diag(NameLoc, diag::err_not_tag_in_scope)
7652 << Kind << Name << DC << SS.getRange();
Argyrios Kyrtzidise02eb2b2008-11-09 22:09:58 +00007653 Name = 0;
Douglas Gregorb8006faf2009-05-27 17:30:49 +00007654 Invalid = true;
Argyrios Kyrtzidise02eb2b2008-11-09 22:09:58 +00007655 goto CreateNewDecl;
7656 }
Chris Lattnerd9773512009-01-21 02:38:50 +00007657 } else if (Name) {
Argyrios Kyrtzidise02eb2b2008-11-09 22:09:58 +00007658 // If this is a named struct, check to see if there was a previous forward
7659 // declaration or definition.
Douglas Gregor889ceb72009-02-03 19:21:40 +00007660 // FIXME: We're looking into outer scopes here, even when we
7661 // shouldn't be. Doing so can result in ambiguities that we
7662 // shouldn't be diagnosing.
John McCall1f82f242009-11-18 22:49:29 +00007663 LookupName(Previous, S);
7664
Douglas Gregor5d1d9e32011-05-09 21:46:33 +00007665 if (Previous.isAmbiguous() &&
7666 (TUK == TUK_Definition || TUK == TUK_Declaration)) {
Douglas Gregored8a29b2011-05-04 00:25:33 +00007667 LookupResult::Filter F = Previous.makeFilter();
7668 while (F.hasNext()) {
7669 NamedDecl *ND = F.next();
7670 if (ND->getDeclContext()->getRedeclContext() != SearchDC)
7671 F.erase();
7672 }
7673 F.done();
Douglas Gregored8a29b2011-05-04 00:25:33 +00007674 }
7675
John McCall1f82f242009-11-18 22:49:29 +00007676 // Note: there used to be some attempt at recovery here.
7677 if (Previous.isAmbiguous())
John McCall48871652010-08-21 09:40:31 +00007678 return 0;
Douglas Gregor82ac25e2009-01-08 20:45:30 +00007679
John McCall9bb74a52009-07-31 02:45:11 +00007680 if (!getLangOptions().CPlusPlus && TUK != TUK_Reference) {
Douglas Gregor82ac25e2009-01-08 20:45:30 +00007681 // FIXME: This makes sure that we ignore the contexts associated
7682 // with C structs, unions, and enums when looking for a matching
7683 // tag declaration or definition. See the similar lookup tweak
Douglas Gregored8f2882009-01-30 01:04:22 +00007684 // in Sema::LookupName; is there a better way to deal with this?
Douglas Gregorc6f58fe2009-01-12 22:49:06 +00007685 while (isa<RecordDecl>(SearchDC) || isa<EnumDecl>(SearchDC))
7686 SearchDC = SearchDC->getParent();
Douglas Gregor82ac25e2009-01-08 20:45:30 +00007687 }
Douglas Gregor009f6992010-09-16 23:58:57 +00007688 } else if (S->isFunctionPrototypeScope()) {
7689 // If this is an enum declaration in function prototype scope, set its
7690 // initial context to the translation unit.
7691 SearchDC = Context.getTranslationUnitDecl();
Argyrios Kyrtzidise02eb2b2008-11-09 22:09:58 +00007692 }
7693
John McCall1f82f242009-11-18 22:49:29 +00007694 if (Previous.isSingleResult() &&
7695 Previous.getFoundDecl()->isTemplateParameter()) {
Douglas Gregor5101c242008-12-05 18:15:24 +00007696 // Maybe we will complain about the shadowed template parameter.
John McCall1f82f242009-11-18 22:49:29 +00007697 DiagnoseTemplateParameterShadow(NameLoc, Previous.getFoundDecl());
Douglas Gregor5101c242008-12-05 18:15:24 +00007698 // Just pretend that we didn't see the previous declaration.
John McCall1f82f242009-11-18 22:49:29 +00007699 Previous.clear();
Douglas Gregor5101c242008-12-05 18:15:24 +00007700 }
7701
Douglas Gregor87f54062009-09-15 22:30:29 +00007702 if (getLangOptions().CPlusPlus && Name && DC && StdNamespace &&
Argyrios Kyrtzidis2d688102010-08-02 07:14:54 +00007703 DC->Equals(getStdNamespace()) && Name->isStr("bad_alloc")) {
Douglas Gregor87f54062009-09-15 22:30:29 +00007704 // This is a declaration of or a reference to "std::bad_alloc".
7705 isStdBadAlloc = true;
7706
John McCall1f82f242009-11-18 22:49:29 +00007707 if (Previous.empty() && StdBadAlloc) {
Douglas Gregor87f54062009-09-15 22:30:29 +00007708 // std::bad_alloc has been implicitly declared (but made invisible to
7709 // name lookup). Fill in this implicit declaration as the previous
7710 // declaration, so that the declarations get chained appropriately.
Argyrios Kyrtzidis2d688102010-08-02 07:14:54 +00007711 Previous.addDecl(getStdBadAlloc());
Douglas Gregor87f54062009-09-15 22:30:29 +00007712 }
7713 }
John McCall1f82f242009-11-18 22:49:29 +00007714
John McCalle9eaf8e2010-03-25 21:28:06 +00007715 // If we didn't find a previous declaration, and this is a reference
7716 // (or friend reference), move to the correct scope. In C++, we
7717 // also need to do a redeclaration lookup there, just in case
7718 // there's a shadow friend decl.
7719 if (Name && Previous.empty() &&
7720 (TUK == TUK_Reference || TUK == TUK_Friend)) {
7721 if (Invalid) goto CreateNewDecl;
7722 assert(SS.isEmpty());
7723
7724 if (TUK == TUK_Reference) {
7725 // C++ [basic.scope.pdecl]p5:
7726 // -- for an elaborated-type-specifier of the form
7727 //
7728 // class-key identifier
7729 //
7730 // if the elaborated-type-specifier is used in the
7731 // decl-specifier-seq or parameter-declaration-clause of a
7732 // function defined in namespace scope, the identifier is
7733 // declared as a class-name in the namespace that contains
7734 // the declaration; otherwise, except as a friend
7735 // declaration, the identifier is declared in the smallest
7736 // non-class, non-function-prototype scope that contains the
7737 // declaration.
7738 //
7739 // C99 6.7.2.3p8 has a similar (but not identical!) provision for
7740 // C structs and unions.
7741 //
7742 // It is an error in C++ to declare (rather than define) an enum
7743 // type, including via an elaborated type specifier. We'll
7744 // diagnose that later; for now, declare the enum in the same
7745 // scope as we would have picked for any other tag type.
7746 //
7747 // GNU C also supports this behavior as part of its incomplete
7748 // enum types extension, while GNU C++ does not.
7749 //
7750 // Find the context where we'll be declaring the tag.
7751 // FIXME: We would like to maintain the current DeclContext as the
7752 // lexical context,
Rafael Espindola9e976dc2011-01-20 02:26:24 +00007753 while (SearchDC->isRecord() || SearchDC->isTransparentContext())
John McCalle9eaf8e2010-03-25 21:28:06 +00007754 SearchDC = SearchDC->getParent();
7755
7756 // Find the scope where we'll be declaring the tag.
7757 while (S->isClassScope() ||
7758 (getLangOptions().CPlusPlus &&
7759 S->isFunctionPrototypeScope()) ||
7760 ((S->getFlags() & Scope::DeclScope) == 0) ||
7761 (S->getEntity() &&
7762 ((DeclContext *)S->getEntity())->isTransparentContext()))
7763 S = S->getParent();
7764 } else {
7765 assert(TUK == TUK_Friend);
7766 // C++ [namespace.memdef]p3:
7767 // If a friend declaration in a non-local class first declares a
7768 // class or function, the friend class or function is a member of
7769 // the innermost enclosing namespace.
7770 SearchDC = SearchDC->getEnclosingNamespaceContext();
John McCalle9eaf8e2010-03-25 21:28:06 +00007771 }
7772
John McCalle87beb22010-04-23 18:46:30 +00007773 // In C++, we need to do a redeclaration lookup to properly
7774 // diagnose some problems.
John McCalle9eaf8e2010-03-25 21:28:06 +00007775 if (getLangOptions().CPlusPlus) {
7776 Previous.setRedeclarationKind(ForRedeclaration);
7777 LookupQualifiedName(Previous, SearchDC);
7778 }
7779 }
7780
John McCall1f82f242009-11-18 22:49:29 +00007781 if (!Previous.empty()) {
Douglas Gregorce40e2e2010-04-12 16:00:01 +00007782 NamedDecl *PrevDecl = (*Previous.begin())->getUnderlyingDecl();
John McCalle87beb22010-04-23 18:46:30 +00007783
7784 // It's okay to have a tag decl in the same scope as a typedef
7785 // which hides a tag decl in the same scope. Finding this
7786 // insanity with a redeclaration lookup can only actually happen
7787 // in C++.
7788 //
7789 // This is also okay for elaborated-type-specifiers, which is
7790 // technically forbidden by the current standard but which is
7791 // okay according to the likely resolution of an open issue;
7792 // see http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#407
7793 if (getLangOptions().CPlusPlus) {
Richard Smithdda56e42011-04-15 14:24:37 +00007794 if (TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(PrevDecl)) {
John McCalle87beb22010-04-23 18:46:30 +00007795 if (const TagType *TT = TD->getUnderlyingType()->getAs<TagType>()) {
7796 TagDecl *Tag = TT->getDecl();
7797 if (Tag->getDeclName() == Name &&
Sebastian Redl50c68252010-08-31 00:36:30 +00007798 Tag->getDeclContext()->getRedeclContext()
7799 ->Equals(TD->getDeclContext()->getRedeclContext())) {
John McCalle87beb22010-04-23 18:46:30 +00007800 PrevDecl = Tag;
7801 Previous.clear();
7802 Previous.addDecl(Tag);
Douglas Gregorfcee9462010-08-27 22:55:10 +00007803 Previous.resolveKind();
John McCalle87beb22010-04-23 18:46:30 +00007804 }
7805 }
7806 }
7807 }
7808
Argyrios Kyrtzidis08114892008-04-27 13:50:30 +00007809 if (TagDecl *PrevTagDecl = dyn_cast<TagDecl>(PrevDecl)) {
Chris Lattner9ff58d72008-07-03 03:30:58 +00007810 // If this is a use of a previous tag, or if the tag is already declared
7811 // in the same scope (so that the definition/declaration completes or
Argyrios Kyrtzidis08114892008-04-27 13:50:30 +00007812 // rementions the tag), reuse the decl.
John McCall07e91c02009-08-06 02:15:43 +00007813 if (TUK == TUK_Reference || TUK == TUK_Friend ||
Douglas Gregordb446112011-03-07 16:54:27 +00007814 isDeclInScope(PrevDecl, SearchDC, S, isExplicitSpecialization)) {
Chris Lattner9ff58d72008-07-03 03:30:58 +00007815 // Make sure that this wasn't declared as an enum and now used as a
7816 // struct or something similar.
Richard Trieucaa33d32011-06-10 03:11:26 +00007817 if (!isAcceptableTagRedeclaration(PrevTagDecl, Kind,
7818 TUK == TUK_Definition, KWLoc,
7819 *Name)) {
Mike Stump11289f42009-09-09 15:08:12 +00007820 bool SafeToContinue
Abramo Bagnara6150c882010-05-11 21:36:43 +00007821 = (PrevTagDecl->getTagKind() != TTK_Enum &&
7822 Kind != TTK_Enum);
Douglas Gregor170512f2009-04-01 23:51:29 +00007823 if (SafeToContinue)
Mike Stump11289f42009-09-09 15:08:12 +00007824 Diag(KWLoc, diag::err_use_with_wrong_tag)
Douglas Gregor170512f2009-04-01 23:51:29 +00007825 << Name
Douglas Gregora771f462010-03-31 17:46:05 +00007826 << FixItHint::CreateReplacement(SourceRange(KWLoc),
7827 PrevTagDecl->getKindName());
Douglas Gregor170512f2009-04-01 23:51:29 +00007828 else
7829 Diag(KWLoc, diag::err_use_with_wrong_tag) << Name;
John McCall1f82f242009-11-18 22:49:29 +00007830 Diag(PrevTagDecl->getLocation(), diag::note_previous_use);
Douglas Gregor170512f2009-04-01 23:51:29 +00007831
Mike Stump11289f42009-09-09 15:08:12 +00007832 if (SafeToContinue)
Douglas Gregor170512f2009-04-01 23:51:29 +00007833 Kind = PrevTagDecl->getTagKind();
7834 else {
7835 // Recover by making this an anonymous redefinition.
7836 Name = 0;
John McCall1f82f242009-11-18 22:49:29 +00007837 Previous.clear();
Douglas Gregor170512f2009-04-01 23:51:29 +00007838 Invalid = true;
7839 }
7840 }
7841
Douglas Gregor0bf31402010-10-08 23:50:27 +00007842 if (Kind == TTK_Enum && PrevTagDecl->getTagKind() == TTK_Enum) {
7843 const EnumDecl *PrevEnum = cast<EnumDecl>(PrevTagDecl);
7844
7845 // All conflicts with previous declarations are recovered by
7846 // returning the previous declaration.
7847 if (ScopedEnum != PrevEnum->isScoped()) {
7848 Diag(KWLoc, diag::err_enum_redeclare_scoped_mismatch)
7849 << PrevEnum->isScoped();
7850 Diag(PrevTagDecl->getLocation(), diag::note_previous_use);
7851 return PrevTagDecl;
7852 }
7853 else if (EnumUnderlying && PrevEnum->isFixed()) {
7854 QualType T;
7855 if (TypeSourceInfo *TI = EnumUnderlying.dyn_cast<TypeSourceInfo*>())
7856 T = TI->getType();
7857 else
7858 T = QualType(EnumUnderlying.get<const Type*>(), 0);
7859
7860 if (!Context.hasSameUnqualifiedType(T, PrevEnum->getIntegerType())) {
Douglas Gregor1a099ba2010-12-01 16:10:38 +00007861 Diag(NameLoc.isValid() ? NameLoc : KWLoc,
7862 diag::err_enum_redeclare_type_mismatch)
7863 << T
7864 << PrevEnum->getIntegerType();
Douglas Gregor0bf31402010-10-08 23:50:27 +00007865 Diag(PrevTagDecl->getLocation(), diag::note_previous_use);
7866 return PrevTagDecl;
7867 }
7868 }
7869 else if (!EnumUnderlying.isNull() != PrevEnum->isFixed()) {
7870 Diag(KWLoc, diag::err_enum_redeclare_fixed_mismatch)
7871 << PrevEnum->isFixed();
7872 Diag(PrevTagDecl->getLocation(), diag::note_previous_use);
7873 return PrevTagDecl;
7874 }
7875 }
7876
Douglas Gregor170512f2009-04-01 23:51:29 +00007877 if (!Invalid) {
Douglas Gregorc811d8f2008-12-15 16:32:14 +00007878 // If this is a use, just return the declaration we found.
Chris Lattner9ff58d72008-07-03 03:30:58 +00007879
Douglas Gregorc811d8f2008-12-15 16:32:14 +00007880 // FIXME: In the future, return a variant or some other clue
7881 // for the consumer of this Decl to know it doesn't own it.
7882 // For our current ASTs this shouldn't be a problem, but will
7883 // need to be changed with DeclGroups.
Francois Pichete37eeba2011-06-01 04:14:20 +00007884 if ((TUK == TUK_Reference && (!PrevTagDecl->getFriendObjectKind() ||
Francois Pichet0706d202011-09-17 17:15:52 +00007885 getLangOptions().MicrosoftExt)) || TUK == TUK_Friend)
John McCall48871652010-08-21 09:40:31 +00007886 return PrevTagDecl;
Douglas Gregorded2d7b2009-02-04 19:02:06 +00007887
Douglas Gregorc811d8f2008-12-15 16:32:14 +00007888 // Diagnose attempts to redefine a tag.
John McCall9bb74a52009-07-31 02:45:11 +00007889 if (TUK == TUK_Definition) {
Douglas Gregor0a5a2212010-02-11 01:04:33 +00007890 if (TagDecl *Def = PrevTagDecl->getDefinition()) {
Douglas Gregor06db9f52009-10-12 20:18:28 +00007891 // If we're defining a specialization and the previous definition
7892 // is from an implicit instantiation, don't emit an error
7893 // here; we'll catch this in the general case below.
7894 if (!isExplicitSpecialization ||
7895 !isa<CXXRecordDecl>(Def) ||
7896 cast<CXXRecordDecl>(Def)->getTemplateSpecializationKind()
7897 == TSK_ExplicitSpecialization) {
7898 Diag(NameLoc, diag::err_redefinition) << Name;
7899 Diag(Def->getLocation(), diag::note_previous_definition);
7900 // If this is a redefinition, recover by making this
7901 // struct be anonymous, which will make any later
7902 // references get the previous definition.
7903 Name = 0;
John McCall1f82f242009-11-18 22:49:29 +00007904 Previous.clear();
Douglas Gregor06db9f52009-10-12 20:18:28 +00007905 Invalid = true;
7906 }
Douglas Gregordee1be82009-01-17 00:42:38 +00007907 } else {
7908 // If the type is currently being defined, complain
7909 // about a nested redefinition.
John McCall424cec92011-01-19 06:33:43 +00007910 const TagType *Tag
7911 = cast<TagType>(Context.getTagDeclType(PrevTagDecl));
Douglas Gregordee1be82009-01-17 00:42:38 +00007912 if (Tag->isBeingDefined()) {
7913 Diag(NameLoc, diag::err_nested_redefinition) << Name;
Mike Stump11289f42009-09-09 15:08:12 +00007914 Diag(PrevTagDecl->getLocation(),
Douglas Gregordee1be82009-01-17 00:42:38 +00007915 diag::note_previous_definition);
7916 Name = 0;
John McCall1f82f242009-11-18 22:49:29 +00007917 Previous.clear();
Douglas Gregordee1be82009-01-17 00:42:38 +00007918 Invalid = true;
7919 }
Douglas Gregorc811d8f2008-12-15 16:32:14 +00007920 }
Douglas Gregordee1be82009-01-17 00:42:38 +00007921
Douglas Gregorc811d8f2008-12-15 16:32:14 +00007922 // Okay, this is definition of a previously declared or referenced
7923 // tag PrevDecl. We're going to create a new Decl for it.
Douglas Gregordee1be82009-01-17 00:42:38 +00007924 }
Argyrios Kyrtzidis08114892008-04-27 13:50:30 +00007925 }
Douglas Gregorc811d8f2008-12-15 16:32:14 +00007926 // If we get here we have (another) forward declaration or we
John McCall07e91c02009-08-06 02:15:43 +00007927 // have a definition. Just create a new decl.
7928
Douglas Gregorc811d8f2008-12-15 16:32:14 +00007929 } else {
7930 // If we get here, this is a definition of a new tag type in a nested
Mike Stump11289f42009-09-09 15:08:12 +00007931 // scope, e.g. "struct foo; void bar() { struct foo; }", just create a
Douglas Gregorc811d8f2008-12-15 16:32:14 +00007932 // new decl/type. We set PrevDecl to NULL so that the entities
7933 // have distinct types.
John McCall1f82f242009-11-18 22:49:29 +00007934 Previous.clear();
Chris Lattner7b9ace62007-01-23 20:11:08 +00007935 }
Douglas Gregorc811d8f2008-12-15 16:32:14 +00007936 // If we get here, we're going to create a new Decl. If PrevDecl
7937 // is non-NULL, it's a definition of the tag declared by
7938 // PrevDecl. If it's NULL, we have a new definition.
John McCalle87beb22010-04-23 18:46:30 +00007939
7940
7941 // Otherwise, PrevDecl is not a tag, but was found with tag
7942 // lookup. This is only actually possible in C++, where a few
7943 // things like templates still live in the tag namespace.
Argyrios Kyrtzidis08114892008-04-27 13:50:30 +00007944 } else {
John McCalle87beb22010-04-23 18:46:30 +00007945 assert(getLangOptions().CPlusPlus);
7946
7947 // Use a better diagnostic if an elaborated-type-specifier
7948 // found the wrong kind of type on the first
7949 // (non-redeclaration) lookup.
7950 if ((TUK == TUK_Reference || TUK == TUK_Friend) &&
7951 !Previous.isForRedeclaration()) {
7952 unsigned Kind = 0;
7953 if (isa<TypedefDecl>(PrevDecl)) Kind = 1;
Richard Smithdda56e42011-04-15 14:24:37 +00007954 else if (isa<TypeAliasDecl>(PrevDecl)) Kind = 2;
7955 else if (isa<ClassTemplateDecl>(PrevDecl)) Kind = 3;
John McCalle87beb22010-04-23 18:46:30 +00007956 Diag(NameLoc, diag::err_tag_reference_non_tag) << Kind;
7957 Diag(PrevDecl->getLocation(), diag::note_declared_at);
7958 Invalid = true;
7959
7960 // Otherwise, only diagnose if the declaration is in scope.
Douglas Gregordb446112011-03-07 16:54:27 +00007961 } else if (!isDeclInScope(PrevDecl, SearchDC, S,
7962 isExplicitSpecialization)) {
John McCalle87beb22010-04-23 18:46:30 +00007963 // do nothing
7964
7965 // Diagnose implicit declarations introduced by elaborated types.
7966 } else if (TUK == TUK_Reference || TUK == TUK_Friend) {
7967 unsigned Kind = 0;
7968 if (isa<TypedefDecl>(PrevDecl)) Kind = 1;
Richard Smithdda56e42011-04-15 14:24:37 +00007969 else if (isa<TypeAliasDecl>(PrevDecl)) Kind = 2;
7970 else if (isa<ClassTemplateDecl>(PrevDecl)) Kind = 3;
John McCalle87beb22010-04-23 18:46:30 +00007971 Diag(NameLoc, diag::err_tag_reference_conflict) << Kind;
7972 Diag(PrevDecl->getLocation(), diag::note_previous_decl) << PrevDecl;
7973 Invalid = true;
7974
7975 // Otherwise it's a declaration. Call out a particularly common
7976 // case here.
Richard Smithdda56e42011-04-15 14:24:37 +00007977 } else if (TypedefNameDecl *TND = dyn_cast<TypedefNameDecl>(PrevDecl)) {
7978 unsigned Kind = 0;
7979 if (isa<TypeAliasDecl>(PrevDecl)) Kind = 1;
John McCalle87beb22010-04-23 18:46:30 +00007980 Diag(NameLoc, diag::err_tag_definition_of_typedef)
Richard Smithdda56e42011-04-15 14:24:37 +00007981 << Name << Kind << TND->getUnderlyingType();
John McCalle87beb22010-04-23 18:46:30 +00007982 Diag(PrevDecl->getLocation(), diag::note_previous_decl) << PrevDecl;
7983 Invalid = true;
7984
7985 // Otherwise, diagnose.
7986 } else {
7987 // The tag name clashes with something else in the target scope,
7988 // issue an error and recover by making this tag be anonymous.
Chris Lattner4bd8dd82008-11-19 08:23:25 +00007989 Diag(NameLoc, diag::err_redefinition_different_kind) << Name;
Chris Lattner0369c572008-11-23 23:12:31 +00007990 Diag(PrevDecl->getLocation(), diag::note_previous_definition);
Argyrios Kyrtzidis7da34d02008-07-16 07:45:46 +00007991 Name = 0;
Douglas Gregordee1be82009-01-17 00:42:38 +00007992 Invalid = true;
Argyrios Kyrtzidis7da34d02008-07-16 07:45:46 +00007993 }
John McCalle87beb22010-04-23 18:46:30 +00007994
7995 // The existing declaration isn't relevant to us; we're in a
7996 // new scope, so clear out the previous declaration.
7997 Previous.clear();
Chris Lattner8799cf22007-01-23 01:57:16 +00007998 }
Chris Lattner18b19622007-01-22 07:39:13 +00007999 }
Argyrios Kyrtzidis16ac9be2008-11-08 17:17:31 +00008000
Chris Lattner438e5012008-12-17 07:13:27 +00008001CreateNewDecl:
Mike Stump11289f42009-09-09 15:08:12 +00008002
John McCall1f82f242009-11-18 22:49:29 +00008003 TagDecl *PrevDecl = 0;
8004 if (Previous.isSingleResult())
8005 PrevDecl = cast<TagDecl>(Previous.getFoundDecl());
8006
Chris Lattnerbf0b7982007-01-23 04:27:41 +00008007 // If there is an identifier, use the location of the identifier as the
8008 // location of the decl, otherwise use the location of the struct/union
8009 // keyword.
8010 SourceLocation Loc = NameLoc.isValid() ? NameLoc : KWLoc;
Mike Stump11289f42009-09-09 15:08:12 +00008011
Douglas Gregorc811d8f2008-12-15 16:32:14 +00008012 // Otherwise, create a new declaration. If there is a previous
8013 // declaration of the same entity, the two will be linked via
8014 // PrevDecl.
Chris Lattner7b9ace62007-01-23 20:11:08 +00008015 TagDecl *New;
Douglas Gregor9ac7a072009-01-07 00:43:41 +00008016
Douglas Gregor0bf31402010-10-08 23:50:27 +00008017 bool IsForwardReference = false;
Abramo Bagnara6150c882010-05-11 21:36:43 +00008018 if (Kind == TTK_Enum) {
Chris Lattner776fac82007-06-09 00:53:06 +00008019 // FIXME: Tag decls should be chained to any simultaneous vardecls, e.g.:
8020 // enum X { A, B, C } D; D should chain to X.
Abramo Bagnara29c2d462011-03-09 14:09:51 +00008021 New = EnumDecl::Create(Context, SearchDC, KWLoc, Loc, Name,
Douglas Gregor0bf31402010-10-08 23:50:27 +00008022 cast_or_null<EnumDecl>(PrevDecl), ScopedEnum,
Abramo Bagnara0e05e242010-12-03 18:54:17 +00008023 ScopedEnumUsesClassTag, !EnumUnderlying.isNull());
Chris Lattner5f521502007-01-25 06:27:24 +00008024 // If this is an undefined enum, warn.
Douglas Gregorc9ea2d52010-06-22 14:26:35 +00008025 if (TUK != TUK_Definition && !Invalid) {
8026 TagDecl *Def;
Douglas Gregor0bf31402010-10-08 23:50:27 +00008027 if (getLangOptions().CPlusPlus0x && cast<EnumDecl>(New)->isFixed()) {
8028 // C++0x: 7.2p2: opaque-enum-declaration.
8029 // Conflicts are diagnosed above. Do nothing.
8030 }
8031 else if (PrevDecl && (Def = cast<EnumDecl>(PrevDecl)->getDefinition())) {
Douglas Gregorc9ea2d52010-06-22 14:26:35 +00008032 Diag(Loc, diag::ext_forward_ref_enum_def)
8033 << New;
8034 Diag(Def->getLocation(), diag::note_previous_definition);
8035 } else {
Francois Pichet488b4a72010-09-12 05:06:55 +00008036 unsigned DiagID = diag::ext_forward_ref_enum;
Francois Pichet0706d202011-09-17 17:15:52 +00008037 if (getLangOptions().MicrosoftExt)
Francois Pichet488b4a72010-09-12 05:06:55 +00008038 DiagID = diag::ext_ms_forward_ref_enum;
8039 else if (getLangOptions().CPlusPlus)
8040 DiagID = diag::err_forward_ref_enum;
8041 Diag(Loc, DiagID);
Douglas Gregor0bf31402010-10-08 23:50:27 +00008042
8043 // If this is a forward-declared reference to an enumeration, make a
8044 // note of it; we won't actually be introducing the declaration into
8045 // the declaration context.
8046 if (TUK == TUK_Reference)
8047 IsForwardReference = true;
Douglas Gregorc9ea2d52010-06-22 14:26:35 +00008048 }
Douglas Gregord45b93b2009-03-06 18:34:03 +00008049 }
Douglas Gregor0bf31402010-10-08 23:50:27 +00008050
8051 if (EnumUnderlying) {
8052 EnumDecl *ED = cast<EnumDecl>(New);
8053 if (TypeSourceInfo *TI = EnumUnderlying.dyn_cast<TypeSourceInfo*>())
8054 ED->setIntegerTypeSourceInfo(TI);
8055 else
8056 ED->setIntegerType(QualType(EnumUnderlying.get<const Type*>(), 0));
8057 ED->setPromotionType(ED->getIntegerType());
8058 }
8059
Argyrios Kyrtzidis554a07b2008-06-09 23:19:58 +00008060 } else {
8061 // struct/union/class
8062
Chris Lattner776fac82007-06-09 00:53:06 +00008063 // FIXME: Tag decls should be chained to any simultaneous vardecls, e.g.:
8064 // struct X { int A; } D; D should chain to X.
Douglas Gregor87f54062009-09-15 22:30:29 +00008065 if (getLangOptions().CPlusPlus) {
Ted Kremenek6ddf53e2008-09-05 17:39:33 +00008066 // FIXME: Look for a way to use RecordDecl for simple structs.
Abramo Bagnara29c2d462011-03-09 14:09:51 +00008067 New = CXXRecordDecl::Create(Context, Kind, SearchDC, KWLoc, Loc, Name,
Douglas Gregorc811d8f2008-12-15 16:32:14 +00008068 cast_or_null<CXXRecordDecl>(PrevDecl));
Abramo Bagnara29c2d462011-03-09 14:09:51 +00008069
Argyrios Kyrtzidis2d688102010-08-02 07:14:54 +00008070 if (isStdBadAlloc && (!StdBadAlloc || getStdBadAlloc()->isImplicit()))
Douglas Gregor87f54062009-09-15 22:30:29 +00008071 StdBadAlloc = cast<CXXRecordDecl>(New);
8072 } else
Abramo Bagnara29c2d462011-03-09 14:09:51 +00008073 New = RecordDecl::Create(Context, Kind, SearchDC, KWLoc, Loc, Name,
Douglas Gregorc811d8f2008-12-15 16:32:14 +00008074 cast_or_null<RecordDecl>(PrevDecl));
Argyrios Kyrtzidised983422008-07-01 10:37:29 +00008075 }
Douglas Gregorc811d8f2008-12-15 16:32:14 +00008076
John McCall3e11ebe2010-03-15 10:12:16 +00008077 // Maybe add qualifier info.
8078 if (SS.isNotEmpty()) {
Fariborz Jahanian862fac92010-05-14 21:35:02 +00008079 if (SS.isSet()) {
Douglas Gregor14454802011-02-25 02:25:35 +00008080 New->setQualifierInfo(SS.getWithLocInContext(Context));
Abramo Bagnara60804e12011-03-18 15:16:37 +00008081 if (TemplateParameterLists.size() > 0) {
Douglas Gregor20527e22010-06-15 17:44:38 +00008082 New->setTemplateParameterListsInfo(Context,
Abramo Bagnara60804e12011-03-18 15:16:37 +00008083 TemplateParameterLists.size(),
Abramo Bagnarada41d0c2010-06-12 08:15:14 +00008084 (TemplateParameterList**) TemplateParameterLists.release());
8085 }
Fariborz Jahanian862fac92010-05-14 21:35:02 +00008086 }
8087 else
8088 Invalid = true;
John McCall3e11ebe2010-03-15 10:12:16 +00008089 }
8090
Daniel Dunbar8804f2e2010-05-27 01:53:40 +00008091 if (RecordDecl *RD = dyn_cast<RecordDecl>(New)) {
8092 // Add alignment attributes if necessary; these attributes are checked when
8093 // the ASTContext lays out the structure.
Douglas Gregorc811d8f2008-12-15 16:32:14 +00008094 //
8095 // It is important for implementing the correct semantics that this
8096 // happen here (in act on tag decl). The #pragma pack stack is
8097 // maintained as a result of parser callbacks which can occur at
8098 // many points during the parsing of a struct declaration (because
8099 // the #pragma tokens are effectively skipped over during the
8100 // parsing of the struct).
Daniel Dunbar8804f2e2010-05-27 01:53:40 +00008101 AddAlignmentAttributesForRecord(RD);
Fariborz Jahanian6b4e26b2011-04-26 17:54:40 +00008102
8103 AddMsStructLayoutForRecord(RD);
Douglas Gregorc811d8f2008-12-15 16:32:14 +00008104 }
8105
Douglas Gregoref15bdb2011-09-09 18:32:39 +00008106 if (PrevDecl && PrevDecl->isModulePrivate())
8107 New->setModulePrivate();
Douglas Gregor2820e692011-09-09 19:05:14 +00008108 else if (ModulePrivateLoc.isValid()) {
Douglas Gregor3c7cd6a2011-09-09 20:53:38 +00008109 if (isExplicitSpecialization)
8110 Diag(New->getLocation(), diag::err_module_private_specialization)
8111 << 2
8112 << FixItHint::CreateRemoval(ModulePrivateLoc);
8113 else if (PrevDecl && !PrevDecl->isModulePrivate())
Douglas Gregor2820e692011-09-09 19:05:14 +00008114 diagnoseModulePrivateRedeclaration(New, PrevDecl, ModulePrivateLoc);
Douglas Gregor41866812011-09-12 18:37:38 +00008115 // __module_private__ does not apply to local classes. However, we only
8116 // diagnose this as an error when the declaration specifiers are
8117 // freestanding. Here, we just ignore the __module_private__.
8118 // foobar
8119 else if (!SearchDC->isFunctionOrMethod())
Douglas Gregor2820e692011-09-09 19:05:14 +00008120 New->setModulePrivate();
8121 }
8122
Douglas Gregorbbe8f462009-10-08 15:14:33 +00008123 // If this is a specialization of a member class (of a class template),
8124 // check the specialization.
John McCall1f82f242009-11-18 22:49:29 +00008125 if (isExplicitSpecialization && CheckMemberSpecialization(New, Previous))
Douglas Gregorbbe8f462009-10-08 15:14:33 +00008126 Invalid = true;
Daniel Dunbar8804f2e2010-05-27 01:53:40 +00008127
Douglas Gregordee1be82009-01-17 00:42:38 +00008128 if (Invalid)
8129 New->setInvalidDecl();
8130
Douglas Gregorc811d8f2008-12-15 16:32:14 +00008131 if (Attr)
Douglas Gregor758a8692009-06-17 21:51:59 +00008132 ProcessDeclAttributeList(S, New, Attr);
Douglas Gregorc811d8f2008-12-15 16:32:14 +00008133
Douglas Gregordee1be82009-01-17 00:42:38 +00008134 // If we're declaring or defining a tag in function prototype scope
8135 // in C, note that this type can only be used within the function.
Douglas Gregor658b9552009-01-09 22:42:13 +00008136 if (Name && S->isFunctionPrototypeScope() && !getLangOptions().CPlusPlus)
8137 Diag(Loc, diag::warn_decl_in_param_list) << Context.getTagDeclType(New);
8138
Douglas Gregorc811d8f2008-12-15 16:32:14 +00008139 // Set the lexical context. If the tag has a C++ scope specifier, the
8140 // lexical context will be different from the semantic context.
Douglas Gregor8761da52009-02-03 00:34:39 +00008141 New->setLexicalDeclContext(CurContext);
Douglas Gregordee1be82009-01-17 00:42:38 +00008142
John McCallaa74a0c2009-08-28 07:59:38 +00008143 // Mark this as a friend decl if applicable.
Francois Pichete37eeba2011-06-01 04:14:20 +00008144 // In Microsoft mode, a friend declaration also acts as a forward
8145 // declaration so we always pass true to setObjectOfFriendDecl to make
8146 // the tag name visible.
John McCallaa74a0c2009-08-28 07:59:38 +00008147 if (TUK == TUK_Friend)
Francois Pichete37eeba2011-06-01 04:14:20 +00008148 New->setObjectOfFriendDecl(/* PreviouslyDeclared = */ !Previous.empty() ||
Francois Pichet0706d202011-09-17 17:15:52 +00008149 getLangOptions().MicrosoftExt);
John McCallaa74a0c2009-08-28 07:59:38 +00008150
Anders Carlsson5558ca12009-03-26 01:19:02 +00008151 // Set the access specifier.
John McCalle9eaf8e2010-03-25 21:28:06 +00008152 if (!Invalid && SearchDC->isRecord())
Douglas Gregorb8006faf2009-05-27 17:30:49 +00008153 SetMemberAccessSpecifier(New, PrevDecl, AS);
Douglas Gregor6c2adff2009-03-25 22:00:53 +00008154
John McCall9bb74a52009-07-31 02:45:11 +00008155 if (TUK == TUK_Definition)
Douglas Gregordee1be82009-01-17 00:42:38 +00008156 New->startDefinition();
Mike Stump11289f42009-09-09 15:08:12 +00008157
Chris Lattner18b19622007-01-22 07:39:13 +00008158 // If this has an identifier, add it to the scope stack.
John McCall2dc078f2009-09-02 00:55:30 +00008159 if (TUK == TUK_Friend) {
John McCallf8bd8612009-09-02 19:32:14 +00008160 // We might be replacing an existing declaration in the lookup tables;
8161 // if so, borrow its access specifier.
8162 if (PrevDecl)
8163 New->setAccess(PrevDecl->getAccess());
8164
Sebastian Redl50c68252010-08-31 00:36:30 +00008165 DeclContext *DC = New->getDeclContext()->getRedeclContext();
John McCalle9eaf8e2010-03-25 21:28:06 +00008166 DC->makeDeclVisibleInContext(New, /* Recoverable = */ false);
8167 if (Name) // can be null along some error paths
John McCall2dc078f2009-09-02 00:55:30 +00008168 if (Scope *EnclosingScope = getScopeForDeclContext(S, DC))
8169 PushOnScopeChains(New, EnclosingScope, /* AddToContext = */ false);
John McCall2dc078f2009-09-02 00:55:30 +00008170 } else if (Name) {
Douglas Gregor45a33ec2009-01-12 18:45:55 +00008171 S = getNonFieldDeclScope(S);
Douglas Gregor0bf31402010-10-08 23:50:27 +00008172 PushOnScopeChains(New, S, !IsForwardReference);
8173 if (IsForwardReference)
8174 SearchDC->makeDeclVisibleInContext(New, /* Recoverable = */ false);
8175
Douglas Gregorc6f58fe2009-01-12 22:49:06 +00008176 } else {
Argyrios Kyrtzidiscfbfe782009-06-30 02:36:12 +00008177 CurContext->addDecl(New);
Chris Lattner18b19622007-01-22 07:39:13 +00008178 }
Argyrios Kyrtzidis9e59b572008-11-09 23:41:00 +00008179
Douglas Gregor27821ce2009-07-07 16:35:42 +00008180 // If this is the C FILE type, notify the AST context.
8181 if (IdentifierInfo *II = New->getIdentifier())
8182 if (!New->isInvalidDecl() &&
Sebastian Redl50c68252010-08-31 00:36:30 +00008183 New->getDeclContext()->getRedeclContext()->isTranslationUnit() &&
Douglas Gregor27821ce2009-07-07 16:35:42 +00008184 II->isStr("FILE"))
8185 Context.setFILEDecl(New);
Mike Stump11289f42009-09-09 15:08:12 +00008186
Douglas Gregord6ab8742009-05-28 23:31:59 +00008187 OwnedDecl = true;
John McCall48871652010-08-21 09:40:31 +00008188 return New;
Chris Lattner18b19622007-01-22 07:39:13 +00008189}
Chris Lattner1300fb92007-01-23 23:42:53 +00008190
John McCall48871652010-08-21 09:40:31 +00008191void Sema::ActOnTagStartDefinition(Scope *S, Decl *TagD) {
Douglas Gregorded2d7b2009-02-04 19:02:06 +00008192 AdjustDeclIfTemplate(TagD);
John McCall48871652010-08-21 09:40:31 +00008193 TagDecl *Tag = cast<TagDecl>(TagD);
Douglas Gregorba41d012010-04-24 16:38:41 +00008194
Douglas Gregor82ac25e2009-01-08 20:45:30 +00008195 // Enter the tag context.
8196 PushDeclContext(S, Tag);
John McCall1c7e6ec2009-12-20 07:58:13 +00008197}
Douglas Gregor82ac25e2009-01-08 20:45:30 +00008198
Argyrios Kyrtzidis9321ad32011-10-06 23:23:20 +00008199Decl *Sema::ActOnObjCContainerStartDefinition(Decl *IDecl) {
Fariborz Jahanian8d382dc2011-08-22 15:54:49 +00008200 assert(isa<ObjCContainerDecl>(IDecl) &&
8201 "ActOnObjCContainerStartDefinition - Not ObjCContainerDecl");
8202 DeclContext *OCD = cast<DeclContext>(IDecl);
8203 assert(getContainingDC(OCD) == CurContext &&
8204 "The next DeclContext should be lexically contained in the current one.");
8205 CurContext = OCD;
Argyrios Kyrtzidis9321ad32011-10-06 23:23:20 +00008206 return IDecl;
Fariborz Jahanian8d382dc2011-08-22 15:54:49 +00008207}
8208
John McCall48871652010-08-21 09:40:31 +00008209void Sema::ActOnStartCXXMemberDeclarations(Scope *S, Decl *TagD,
Anders Carlsson30f29442011-03-25 14:31:08 +00008210 SourceLocation FinalLoc,
John McCall1c7e6ec2009-12-20 07:58:13 +00008211 SourceLocation LBraceLoc) {
8212 AdjustDeclIfTemplate(TagD);
John McCall48871652010-08-21 09:40:31 +00008213 CXXRecordDecl *Record = cast<CXXRecordDecl>(TagD);
Douglas Gregor82ac25e2009-01-08 20:45:30 +00008214
John McCall1c7e6ec2009-12-20 07:58:13 +00008215 FieldCollector->StartClass();
8216
8217 if (!Record->getIdentifier())
8218 return;
8219
Anders Carlsson30f29442011-03-25 14:31:08 +00008220 if (FinalLoc.isValid())
8221 Record->addAttr(new (Context) FinalAttr(FinalLoc, Context));
Anders Carlssonfc1eef42011-01-22 17:51:53 +00008222
John McCall1c7e6ec2009-12-20 07:58:13 +00008223 // C++ [class]p2:
8224 // [...] The class-name is also inserted into the scope of the
8225 // class itself; this is known as the injected-class-name. For
8226 // purposes of access checking, the injected-class-name is treated
8227 // as if it were a public member name.
8228 CXXRecordDecl *InjectedClassName
Abramo Bagnara29c2d462011-03-09 14:09:51 +00008229 = CXXRecordDecl::Create(Context, Record->getTagKind(), CurContext,
8230 Record->getLocStart(), Record->getLocation(),
John McCall1c7e6ec2009-12-20 07:58:13 +00008231 Record->getIdentifier(),
Argyrios Kyrtzidis470c4542010-10-14 20:14:21 +00008232 /*PrevDecl=*/0,
8233 /*DelayTypeCreation=*/true);
8234 Context.getTypeDeclType(InjectedClassName, Record);
John McCall1c7e6ec2009-12-20 07:58:13 +00008235 InjectedClassName->setImplicit();
8236 InjectedClassName->setAccess(AS_public);
8237 if (ClassTemplateDecl *Template = Record->getDescribedClassTemplate())
8238 InjectedClassName->setDescribedClassTemplate(Template);
8239 PushOnScopeChains(InjectedClassName, S);
8240 assert(InjectedClassName->isInjectedClassName() &&
8241 "Broken injected-class-name");
Douglas Gregor82ac25e2009-01-08 20:45:30 +00008242}
8243
John McCall48871652010-08-21 09:40:31 +00008244void Sema::ActOnTagFinishDefinition(Scope *S, Decl *TagD,
Argyrios Kyrtzidis23e1f1d2009-07-14 03:17:52 +00008245 SourceLocation RBraceLoc) {
Douglas Gregorded2d7b2009-02-04 19:02:06 +00008246 AdjustDeclIfTemplate(TagD);
John McCall48871652010-08-21 09:40:31 +00008247 TagDecl *Tag = cast<TagDecl>(TagD);
Argyrios Kyrtzidis23e1f1d2009-07-14 03:17:52 +00008248 Tag->setRBraceLoc(RBraceLoc);
Douglas Gregor82ac25e2009-01-08 20:45:30 +00008249
8250 if (isa<CXXRecordDecl>(Tag))
8251 FieldCollector->FinishClass();
8252
8253 // Exit this scope of this tag's definition.
8254 PopDeclContext();
Douglas Gregor859f0ae2010-01-06 17:00:51 +00008255
Douglas Gregor82ac25e2009-01-08 20:45:30 +00008256 // Notify the consumer that we've defined a tag.
8257 Consumer.HandleTagDeclDefinition(Tag);
8258}
Chris Lattner535b8302008-06-21 19:39:06 +00008259
Fariborz Jahanian4327b322011-08-29 17:33:12 +00008260void Sema::ActOnObjCContainerFinishDefinition() {
Fariborz Jahanian8d382dc2011-08-22 15:54:49 +00008261 // Exit this scope of this interface definition.
8262 PopDeclContext();
8263}
Argyrios Kyrtzidis9321ad32011-10-06 23:23:20 +00008264
8265void Sema::ActOnObjCTemporaryExitContainerContext() {
8266 OriginalLexicalContext = CurContext;
8267 ActOnObjCContainerFinishDefinition();
8268}
8269
8270void Sema::ActOnObjCReenterContainerContext() {
8271 ActOnObjCContainerStartDefinition(cast<Decl>(OriginalLexicalContext));
8272 OriginalLexicalContext = 0;
8273}
8274
John McCall48871652010-08-21 09:40:31 +00008275void Sema::ActOnTagDefinitionError(Scope *S, Decl *TagD) {
John McCall2ff380a2010-03-17 00:38:33 +00008276 AdjustDeclIfTemplate(TagD);
John McCall48871652010-08-21 09:40:31 +00008277 TagDecl *Tag = cast<TagDecl>(TagD);
John McCall2ff380a2010-03-17 00:38:33 +00008278 Tag->setInvalidDecl();
8279
John McCall71ba5f22010-03-17 19:25:57 +00008280 // We're undoing ActOnTagStartDefinition here, not
8281 // ActOnStartCXXMemberDeclarations, so we don't have to mess with
8282 // the FieldCollector.
John McCall2ff380a2010-03-17 00:38:33 +00008283
8284 PopDeclContext();
8285}
8286
Chris Lattnerf9b00eb2009-04-20 17:29:38 +00008287// Note that FieldName may be null for anonymous bitfields.
Mike Stump11289f42009-09-09 15:08:12 +00008288bool Sema::VerifyBitField(SourceLocation FieldLoc, IdentifierInfo *FieldName,
Eli Friedmanc96d4962009-08-15 21:55:26 +00008289 QualType FieldTy, const Expr *BitWidth,
8290 bool *ZeroWidth) {
8291 // Default to true; that shouldn't confuse checks for emptiness
8292 if (ZeroWidth)
8293 *ZeroWidth = true;
8294
Chris Lattner73bf7b42009-03-05 22:45:59 +00008295 // C99 6.7.2.1p4 - verify the field type.
Chris Lattnerd26760a2009-03-05 23:01:03 +00008296 // C++ 9.6p3: A bit-field shall have integral or enumeration type.
Douglas Gregorb90df602010-06-16 00:17:44 +00008297 if (!FieldTy->isDependentType() && !FieldTy->isIntegralOrEnumerationType()) {
Chris Lattner73bf7b42009-03-05 22:45:59 +00008298 // Handle incomplete types with specific error.
Douglas Gregor81457422009-03-10 21:58:27 +00008299 if (RequireCompleteType(FieldLoc, FieldTy, diag::err_field_incomplete))
8300 return true;
Chris Lattnerf9b00eb2009-04-20 17:29:38 +00008301 if (FieldName)
8302 return Diag(FieldLoc, diag::err_not_integral_type_bitfield)
8303 << FieldName << FieldTy << BitWidth->getSourceRange();
8304 return Diag(FieldLoc, diag::err_not_integral_type_anon_bitfield)
8305 << FieldTy << BitWidth->getSourceRange();
Douglas Gregora02a72a2010-12-15 23:18:36 +00008306 } else if (DiagnoseUnexpandedParameterPack(const_cast<Expr *>(BitWidth),
8307 UPPC_BitFieldWidth))
8308 return true;
Douglas Gregor1efa4372009-03-11 18:59:21 +00008309
8310 // If the bit-width is type- or value-dependent, don't try to check
8311 // it now.
8312 if (BitWidth->isValueDependent() || BitWidth->isTypeDependent())
8313 return false;
8314
Anders Carlsson5df391e2008-12-06 20:33:04 +00008315 llvm::APSInt Value;
8316 if (VerifyIntegerConstantExpression(BitWidth, &Value))
8317 return true;
8318
Eli Friedmanc96d4962009-08-15 21:55:26 +00008319 if (Value != 0 && ZeroWidth)
8320 *ZeroWidth = false;
8321
Chris Lattner81ed6802008-12-12 04:56:04 +00008322 // Zero-width bitfield is ok for anonymous field.
8323 if (Value == 0 && FieldName)
8324 return Diag(FieldLoc, diag::err_bitfield_has_zero_width) << FieldName;
Mike Stump11289f42009-09-09 15:08:12 +00008325
Chris Lattnerf9b00eb2009-04-20 17:29:38 +00008326 if (Value.isSigned() && Value.isNegative()) {
8327 if (FieldName)
Mike Stump11289f42009-09-09 15:08:12 +00008328 return Diag(FieldLoc, diag::err_bitfield_has_negative_width)
Chris Lattnerf9b00eb2009-04-20 17:29:38 +00008329 << FieldName << Value.toString(10);
8330 return Diag(FieldLoc, diag::err_anon_bitfield_has_negative_width)
8331 << Value.toString(10);
8332 }
Anders Carlsson5df391e2008-12-06 20:33:04 +00008333
Douglas Gregor1efa4372009-03-11 18:59:21 +00008334 if (!FieldTy->isDependentType()) {
8335 uint64_t TypeSize = Context.getTypeSize(FieldTy);
Chris Lattnerf9b00eb2009-04-20 17:29:38 +00008336 if (Value.getZExtValue() > TypeSize) {
Anders Carlssond5635fe2010-04-16 15:16:32 +00008337 if (!getLangOptions().CPlusPlus) {
8338 if (FieldName)
8339 return Diag(FieldLoc, diag::err_bitfield_width_exceeds_type_size)
8340 << FieldName << (unsigned)Value.getZExtValue()
8341 << (unsigned)TypeSize;
8342
8343 return Diag(FieldLoc, diag::err_anon_bitfield_width_exceeds_type_size)
8344 << (unsigned)Value.getZExtValue() << (unsigned)TypeSize;
8345 }
8346
Chris Lattnerf9b00eb2009-04-20 17:29:38 +00008347 if (FieldName)
Anders Carlssond5635fe2010-04-16 15:16:32 +00008348 Diag(FieldLoc, diag::warn_bitfield_width_exceeds_type_size)
8349 << FieldName << (unsigned)Value.getZExtValue()
8350 << (unsigned)TypeSize;
8351 else
8352 Diag(FieldLoc, diag::warn_anon_bitfield_width_exceeds_type_size)
8353 << (unsigned)Value.getZExtValue() << (unsigned)TypeSize;
Chris Lattnerf9b00eb2009-04-20 17:29:38 +00008354 }
Douglas Gregor1efa4372009-03-11 18:59:21 +00008355 }
Anders Carlsson5df391e2008-12-06 20:33:04 +00008356
8357 return false;
8358}
8359
Richard Smith938f40b2011-06-11 17:19:42 +00008360/// ActOnField - Each field of a C struct/union is passed into this in order
Chris Lattner1300fb92007-01-23 23:42:53 +00008361/// to create a FieldDecl object for it.
Richard Smith938f40b2011-06-11 17:19:42 +00008362Decl *Sema::ActOnField(Scope *S, Decl *TagD, SourceLocation DeclStart,
Richard Trieu2bd04012011-09-09 02:00:50 +00008363 Declarator &D, Expr *BitfieldWidth) {
John McCall48871652010-08-21 09:40:31 +00008364 FieldDecl *Res = HandleField(S, cast_or_null<RecordDecl>(TagD),
Chris Lattner83f095c2009-03-28 19:18:32 +00008365 DeclStart, D, static_cast<Expr*>(BitfieldWidth),
Richard Smith938f40b2011-06-11 17:19:42 +00008366 /*HasInit=*/false, AS_public);
John McCall48871652010-08-21 09:40:31 +00008367 return Res;
Chris Lattner73bf7b42009-03-05 22:45:59 +00008368}
8369
8370/// HandleField - Analyze a field of a C struct or a C++ data member.
8371///
8372FieldDecl *Sema::HandleField(Scope *S, RecordDecl *Record,
8373 SourceLocation DeclStart,
Richard Smith938f40b2011-06-11 17:19:42 +00008374 Declarator &D, Expr *BitWidth, bool HasInit,
Douglas Gregor4261e4c2009-03-11 20:50:30 +00008375 AccessSpecifier AS) {
Chris Lattner1300fb92007-01-23 23:42:53 +00008376 IdentifierInfo *II = D.getIdentifier();
Chris Lattner1300fb92007-01-23 23:42:53 +00008377 SourceLocation Loc = DeclStart;
8378 if (II) Loc = D.getIdentifierLoc();
Mike Stump11289f42009-09-09 15:08:12 +00008379
John McCall8cb7bdf2010-06-04 23:28:52 +00008380 TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S);
8381 QualType T = TInfo->getType();
Douglas Gregora02a72a2010-12-15 23:18:36 +00008382 if (getLangOptions().CPlusPlus) {
Douglas Gregor1efa4372009-03-11 18:59:21 +00008383 CheckExtraCXXDefaultArguments(D);
Douglas Gregor0c880302009-03-11 23:00:04 +00008384
Douglas Gregora02a72a2010-12-15 23:18:36 +00008385 if (DiagnoseUnexpandedParameterPack(D.getIdentifierLoc(), TInfo,
8386 UPPC_DataMemberType)) {
8387 D.setInvalidType();
8388 T = Context.IntTy;
8389 TInfo = Context.getTrivialTypeSourceInfo(T, Loc);
8390 }
8391 }
8392
Eli Friedman574c7452009-04-07 19:37:57 +00008393 DiagnoseFunctionSpecifiers(D);
8394
Eli Friedmand5c0eed2009-04-19 20:27:55 +00008395 if (D.getDeclSpec().isThreadSpecified())
8396 Diag(D.getDeclSpec().getThreadSpecLoc(), diag::err_invalid_thread);
Richard Smitha77a0a62011-08-15 21:04:07 +00008397 if (D.getDeclSpec().isConstexprSpecified())
8398 Diag(D.getDeclSpec().getConstexprSpecLoc(), diag::err_invalid_constexpr)
8399 << 2;
Douglas Gregor2c7d9292010-08-30 14:32:14 +00008400
8401 // Check to see if this name was declared as a member previously
8402 LookupResult Previous(*this, II, Loc, LookupMemberName, ForRedeclaration);
8403 LookupName(Previous, S);
8404 assert((Previous.empty() || Previous.isOverloadedResult() ||
8405 Previous.isSingleResult())
8406 && "Lookup of member name should be either overloaded, single or null");
Eli Friedmand5c0eed2009-04-19 20:27:55 +00008407
Douglas Gregor2c7d9292010-08-30 14:32:14 +00008408 // If the name is overloaded then get any declaration else get the single result
8409 NamedDecl *PrevDecl = Previous.isOverloadedResult() ?
8410 Previous.getRepresentativeDecl() : Previous.getAsSingle<NamedDecl>();
Douglas Gregorf187420f2009-06-17 23:37:01 +00008411
8412 if (PrevDecl && PrevDecl->isTemplateParameter()) {
8413 // Maybe we will complain about the shadowed template parameter.
8414 DiagnoseTemplateParameterShadow(D.getIdentifierLoc(), PrevDecl);
8415 // Just pretend that we didn't see the previous declaration.
8416 PrevDecl = 0;
8417 }
8418
Douglas Gregor1efa4372009-03-11 18:59:21 +00008419 if (PrevDecl && !isDeclInScope(PrevDecl, Record, S))
8420 PrevDecl = 0;
8421
Steve Naroff5ec6ff72009-07-14 14:58:18 +00008422 bool Mutable
8423 = (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_mutable);
8424 SourceLocation TSSL = D.getSourceRange().getBegin();
8425 FieldDecl *NewFD
Richard Smith938f40b2011-06-11 17:19:42 +00008426 = CheckFieldDecl(II, T, TInfo, Record, Loc, Mutable, BitWidth, HasInit,
8427 TSSL, AS, PrevDecl, &D);
Rafael Espindola568586f2010-03-21 22:56:43 +00008428
8429 if (NewFD->isInvalidDecl())
8430 Record->setInvalidDecl();
8431
Douglas Gregor3baa6702011-09-12 16:11:24 +00008432 if (D.getDeclSpec().isModulePrivateSpecified())
8433 NewFD->setModulePrivate();
8434
Douglas Gregor1efa4372009-03-11 18:59:21 +00008435 if (NewFD->isInvalidDecl() && PrevDecl) {
8436 // Don't introduce NewFD into scope; there's already something
8437 // with the same name in the same scope.
8438 } else if (II) {
8439 PushOnScopeChains(NewFD, S);
8440 } else
Argyrios Kyrtzidiscfbfe782009-06-30 02:36:12 +00008441 Record->addDecl(NewFD);
Douglas Gregor1efa4372009-03-11 18:59:21 +00008442
8443 return NewFD;
8444}
8445
8446/// \brief Build a new FieldDecl and check its well-formedness.
8447///
8448/// This routine builds a new FieldDecl given the fields name, type,
8449/// record, etc. \p PrevDecl should refer to any previous declaration
8450/// with the same name and in the same scope as the field to be
8451/// created.
8452///
8453/// \returns a new FieldDecl.
8454///
Mike Stump11289f42009-09-09 15:08:12 +00008455/// \todo The Declarator argument is a hack. It will be removed once
Argyrios Kyrtzidis60ed5602009-08-19 01:27:57 +00008456FieldDecl *Sema::CheckFieldDecl(DeclarationName Name, QualType T,
John McCallbcd03502009-12-07 02:54:59 +00008457 TypeSourceInfo *TInfo,
Douglas Gregor1efa4372009-03-11 18:59:21 +00008458 RecordDecl *Record, SourceLocation Loc,
Richard Smith938f40b2011-06-11 17:19:42 +00008459 bool Mutable, Expr *BitWidth, bool HasInit,
Steve Naroff5ec6ff72009-07-14 14:58:18 +00008460 SourceLocation TSSL,
Douglas Gregor4261e4c2009-03-11 20:50:30 +00008461 AccessSpecifier AS, NamedDecl *PrevDecl,
Douglas Gregor1efa4372009-03-11 18:59:21 +00008462 Declarator *D) {
8463 IdentifierInfo *II = Name.getAsIdentifierInfo();
Steve Narofff93b6722007-08-28 20:14:24 +00008464 bool InvalidDecl = false;
Chris Lattnerf6d1c9c2009-04-25 08:06:05 +00008465 if (D) InvalidDecl = D->isInvalidType();
Sebastian Redlbaad4e72009-01-05 20:52:13 +00008466
Douglas Gregor1efa4372009-03-11 18:59:21 +00008467 // If we receive a broken type, recover by assuming 'int' and
8468 // marking this declaration as invalid.
8469 if (T.isNull()) {
8470 InvalidDecl = true;
8471 T = Context.IntTy;
8472 }
8473
Eli Friedmand0e8de22009-12-07 00:22:08 +00008474 QualType EltTy = Context.getBaseElementType(T);
8475 if (!EltTy->isDependentType() &&
John McCall2677e102010-08-16 23:42:35 +00008476 RequireCompleteType(Loc, EltTy, diag::err_field_incomplete)) {
8477 // Fields of incomplete type force their record to be invalid.
8478 Record->setInvalidDecl();
Eli Friedmand0e8de22009-12-07 00:22:08 +00008479 InvalidDecl = true;
John McCall2677e102010-08-16 23:42:35 +00008480 }
Eli Friedmand0e8de22009-12-07 00:22:08 +00008481
Steve Naroff8eeeb132007-05-08 21:09:37 +00008482 // C99 6.7.2.1p8: A member of a structure or union may have any type other
8483 // than a variably modified type.
Eli Friedmand0e8de22009-12-07 00:22:08 +00008484 if (!InvalidDecl && T->isVariablyModifiedType()) {
Eli Friedmana3b1d032009-02-21 00:44:51 +00008485 bool SizeIsNegative;
Douglas Gregorcaa1bf42010-08-18 00:39:00 +00008486 llvm::APSInt Oversized;
Eli Friedmana3b1d032009-02-21 00:44:51 +00008487 QualType FixedTy = TryToFixInvalidVariablyModifiedType(T, Context,
Douglas Gregorcaa1bf42010-08-18 00:39:00 +00008488 SizeIsNegative,
8489 Oversized);
Eli Friedmana3b1d032009-02-21 00:44:51 +00008490 if (!FixedTy.isNull()) {
8491 Diag(Loc, diag::warn_illegal_constant_array_size);
8492 T = FixedTy;
8493 } else {
8494 if (SizeIsNegative)
8495 Diag(Loc, diag::err_typecheck_negative_array_size);
Douglas Gregorcaa1bf42010-08-18 00:39:00 +00008496 else if (Oversized.getBoolValue())
8497 Diag(Loc, diag::err_array_too_large)
8498 << Oversized.toString(10);
Eli Friedmana3b1d032009-02-21 00:44:51 +00008499 else
8500 Diag(Loc, diag::err_typecheck_field_variable_size);
Eli Friedmana3b1d032009-02-21 00:44:51 +00008501 InvalidDecl = true;
8502 }
Steve Naroff8eeeb132007-05-08 21:09:37 +00008503 }
Mike Stump11289f42009-09-09 15:08:12 +00008504
Anders Carlsson576cc6f2009-03-22 20:18:17 +00008505 // Fields can not have abstract class types
Eli Friedmand0e8de22009-12-07 00:22:08 +00008506 if (!InvalidDecl && RequireNonAbstractType(Loc, T,
8507 diag::err_abstract_type_in_decl,
8508 AbstractFieldType))
Anders Carlsson576cc6f2009-03-22 20:18:17 +00008509 InvalidDecl = true;
Mike Stump11289f42009-09-09 15:08:12 +00008510
Eli Friedmanc96d4962009-08-15 21:55:26 +00008511 bool ZeroWidth = false;
Douglas Gregor1efa4372009-03-11 18:59:21 +00008512 // If this is declared as a bit-field, check the bit-field.
Eli Friedmand0e8de22009-12-07 00:22:08 +00008513 if (!InvalidDecl && BitWidth &&
8514 VerifyBitField(Loc, II, T, BitWidth, &ZeroWidth)) {
Douglas Gregor1efa4372009-03-11 18:59:21 +00008515 InvalidDecl = true;
Douglas Gregor1efa4372009-03-11 18:59:21 +00008516 BitWidth = 0;
Eli Friedmanc96d4962009-08-15 21:55:26 +00008517 ZeroWidth = false;
Anders Carlsson5df391e2008-12-06 20:33:04 +00008518 }
Mike Stump11289f42009-09-09 15:08:12 +00008519
John McCallb1cd7da2010-06-04 08:34:12 +00008520 // Check that 'mutable' is consistent with the type of the declaration.
8521 if (!InvalidDecl && Mutable) {
8522 unsigned DiagID = 0;
8523 if (T->isReferenceType())
8524 DiagID = diag::err_mutable_reference;
8525 else if (T.isConstQualified())
8526 DiagID = diag::err_mutable_const;
8527
8528 if (DiagID) {
8529 SourceLocation ErrLoc = Loc;
8530 if (D && D->getDeclSpec().getStorageClassSpecLoc().isValid())
8531 ErrLoc = D->getDeclSpec().getStorageClassSpecLoc();
8532 Diag(ErrLoc, DiagID);
8533 Mutable = false;
8534 InvalidDecl = true;
8535 }
8536 }
8537
Abramo Bagnaradff19302011-03-08 08:55:46 +00008538 FieldDecl *NewFD = FieldDecl::Create(Context, Record, TSSL, Loc, II, T, TInfo,
Richard Smith938f40b2011-06-11 17:19:42 +00008539 BitWidth, Mutable, HasInit);
Chris Lattnerf6d1c9c2009-04-25 08:06:05 +00008540 if (InvalidDecl)
8541 NewFD->setInvalidDecl();
Douglas Gregor91f84212008-12-11 16:49:14 +00008542
Douglas Gregor1efa4372009-03-11 18:59:21 +00008543 if (PrevDecl && !isa<TagDecl>(PrevDecl)) {
8544 Diag(Loc, diag::err_duplicate_member) << II;
8545 Diag(PrevDecl->getLocation(), diag::note_previous_declaration);
8546 NewFD->setInvalidDecl();
Douglas Gregor82ac25e2009-01-08 20:45:30 +00008547 }
8548
John McCall67da35c2010-02-04 22:26:26 +00008549 if (!InvalidDecl && getLangOptions().CPlusPlus) {
Anders Carlsson2ceb3472010-11-07 19:13:55 +00008550 if (Record->isUnion()) {
8551 if (const RecordType *RT = EltTy->getAs<RecordType>()) {
8552 CXXRecordDecl* RDecl = cast<CXXRecordDecl>(RT->getDecl());
8553 if (RDecl->getDefinition()) {
8554 // C++ [class.union]p1: An object of a class with a non-trivial
8555 // constructor, a non-trivial copy constructor, a non-trivial
8556 // destructor, or a non-trivial copy assignment operator
8557 // cannot be a member of a union, nor can an array of such
8558 // objects.
Alexis Hunt97ab5542011-05-16 22:41:40 +00008559 if (!getLangOptions().CPlusPlus0x && CheckNontrivialField(NewFD))
Anders Carlsson2ceb3472010-11-07 19:13:55 +00008560 NewFD->setInvalidDecl();
8561 }
8562 }
8563
8564 // C++ [class.union]p1: If a union contains a member of reference type,
8565 // the program is ill-formed.
8566 if (EltTy->isReferenceType()) {
8567 Diag(NewFD->getLocation(), diag::err_union_member_of_reference_type)
8568 << NewFD->getDeclName() << EltTy;
8569 NewFD->setInvalidDecl();
Douglas Gregor8a273912009-07-22 18:25:24 +00008570 }
8571 }
8572 }
8573
Douglas Gregor1efa4372009-03-11 18:59:21 +00008574 // FIXME: We need to pass in the attributes given an AST
8575 // representation, not a parser representation.
8576 if (D)
Douglas Gregor758a8692009-06-17 21:51:59 +00008577 // FIXME: What to pass instead of TUScope?
8578 ProcessDeclAttributes(TUScope, NewFD, *D);
Douglas Gregor1efa4372009-03-11 18:59:21 +00008579
John McCall31168b02011-06-15 23:02:42 +00008580 // In auto-retain/release, infer strong retension for fields of
8581 // retainable type.
8582 if (getLangOptions().ObjCAutoRefCount && inferObjCARCLifetime(NewFD))
8583 NewFD->setInvalidDecl();
8584
Fariborz Jahaniand29fecd2009-02-19 00:22:47 +00008585 if (T.isObjCGCWeak())
Fariborz Jahaniand35c7922009-02-18 18:14:41 +00008586 Diag(Loc, diag::warn_attribute_weak_on_field);
Anders Carlsson28e71082008-02-16 00:29:18 +00008587
Douglas Gregor4261e4c2009-03-11 20:50:30 +00008588 NewFD->setAccess(AS);
Steve Narofff93b6722007-08-28 20:14:24 +00008589 return NewFD;
Chris Lattner1300fb92007-01-23 23:42:53 +00008590}
8591
Argyrios Kyrtzidis33aee392010-08-16 17:27:08 +00008592bool Sema::CheckNontrivialField(FieldDecl *FD) {
8593 assert(FD);
8594 assert(getLangOptions().CPlusPlus && "valid check only for C++");
8595
8596 if (FD->isInvalidDecl())
8597 return true;
8598
8599 QualType EltTy = Context.getBaseElementType(FD->getType());
8600 if (const RecordType *RT = EltTy->getAs<RecordType>()) {
8601 CXXRecordDecl* RDecl = cast<CXXRecordDecl>(RT->getDecl());
8602 if (RDecl->getDefinition()) {
8603 // We check for copy constructors before constructors
8604 // because otherwise we'll never get complaints about
8605 // copy constructors.
8606
8607 CXXSpecialMember member = CXXInvalid;
8608 if (!RDecl->hasTrivialCopyConstructor())
8609 member = CXXCopyConstructor;
Alexis Huntf479f1b2011-05-09 18:22:59 +00008610 else if (!RDecl->hasTrivialDefaultConstructor())
Alexis Hunt80f00ff2011-05-10 19:08:14 +00008611 member = CXXDefaultConstructor;
Argyrios Kyrtzidis33aee392010-08-16 17:27:08 +00008612 else if (!RDecl->hasTrivialCopyAssignment())
8613 member = CXXCopyAssignment;
8614 else if (!RDecl->hasTrivialDestructor())
8615 member = CXXDestructor;
8616
8617 if (member != CXXInvalid) {
John McCall31168b02011-06-15 23:02:42 +00008618 if (getLangOptions().ObjCAutoRefCount && RDecl->hasObjectMember()) {
8619 // Objective-C++ ARC: it is an error to have a non-trivial field of
8620 // a union. However, system headers in Objective-C programs
8621 // occasionally have Objective-C lifetime objects within unions,
8622 // and rather than cause the program to fail, we make those
8623 // members unavailable.
8624 SourceLocation Loc = FD->getLocation();
8625 if (getSourceManager().isInSystemHeader(Loc)) {
8626 if (!FD->hasAttr<UnavailableAttr>())
8627 FD->addAttr(new (Context) UnavailableAttr(Loc, Context,
Argyrios Kyrtzidiscff00d92011-06-24 00:08:59 +00008628 "this system field has retaining ownership"));
John McCall31168b02011-06-15 23:02:42 +00008629 return false;
8630 }
8631 }
8632
Argyrios Kyrtzidis33aee392010-08-16 17:27:08 +00008633 Diag(FD->getLocation(), diag::err_illegal_union_or_anon_struct_member)
8634 << (int)FD->getParent()->isUnion() << FD->getDeclName() << member;
8635 DiagnoseNontrivial(RT, member);
8636 return true;
8637 }
8638 }
8639 }
8640
8641 return false;
8642}
8643
Douglas Gregor8a273912009-07-22 18:25:24 +00008644/// DiagnoseNontrivial - Given that a class has a non-trivial
8645/// special member, figure out why.
8646void Sema::DiagnoseNontrivial(const RecordType* T, CXXSpecialMember member) {
8647 QualType QT(T, 0U);
8648 CXXRecordDecl* RD = cast<CXXRecordDecl>(T->getDecl());
8649
8650 // Check whether the member was user-declared.
8651 switch (member) {
Douglas Gregorfceea362010-04-22 14:36:26 +00008652 case CXXInvalid:
8653 break;
8654
Alexis Hunt80f00ff2011-05-10 19:08:14 +00008655 case CXXDefaultConstructor:
Douglas Gregor8a273912009-07-22 18:25:24 +00008656 if (RD->hasUserDeclaredConstructor()) {
8657 typedef CXXRecordDecl::ctor_iterator ctor_iter;
Sebastian Redle24b1622009-10-25 22:31:45 +00008658 for (ctor_iter ci = RD->ctor_begin(), ce = RD->ctor_end(); ci != ce;++ci){
8659 const FunctionDecl *body = 0;
Argyrios Kyrtzidis36ea3222010-07-07 11:31:19 +00008660 ci->hasBody(body);
Anders Carlssonb7229932010-04-20 23:32:58 +00008661 if (!body || !cast<CXXConstructorDecl>(body)->isImplicitlyDefined()) {
Douglas Gregor8a273912009-07-22 18:25:24 +00008662 SourceLocation CtorLoc = ci->getLocation();
8663 Diag(CtorLoc, diag::note_nontrivial_user_defined) << QT << member;
8664 return;
8665 }
Sebastian Redle24b1622009-10-25 22:31:45 +00008666 }
Douglas Gregor8a273912009-07-22 18:25:24 +00008667
David Blaikie83d382b2011-09-23 05:06:16 +00008668 llvm_unreachable("found no user-declared constructors");
Douglas Gregor8a273912009-07-22 18:25:24 +00008669 }
8670 break;
8671
8672 case CXXCopyConstructor:
8673 if (RD->hasUserDeclaredCopyConstructor()) {
8674 SourceLocation CtorLoc =
Alexis Huntfcaeae42011-05-25 20:50:04 +00008675 RD->getCopyConstructor(0)->getLocation();
8676 Diag(CtorLoc, diag::note_nontrivial_user_defined) << QT << member;
8677 return;
8678 }
8679 break;
8680
8681 case CXXMoveConstructor:
8682 if (RD->hasUserDeclaredMoveConstructor()) {
8683 SourceLocation CtorLoc = RD->getMoveConstructor()->getLocation();
Douglas Gregor8a273912009-07-22 18:25:24 +00008684 Diag(CtorLoc, diag::note_nontrivial_user_defined) << QT << member;
8685 return;
8686 }
8687 break;
8688
8689 case CXXCopyAssignment:
8690 if (RD->hasUserDeclaredCopyAssignment()) {
8691 // FIXME: this should use the location of the copy
8692 // assignment, not the type.
8693 SourceLocation TyLoc = RD->getSourceRange().getBegin();
8694 Diag(TyLoc, diag::note_nontrivial_user_defined) << QT << member;
8695 return;
8696 }
8697 break;
8698
Alexis Huntfcaeae42011-05-25 20:50:04 +00008699 case CXXMoveAssignment:
8700 if (RD->hasUserDeclaredMoveAssignment()) {
8701 SourceLocation AssignLoc = RD->getMoveAssignmentOperator()->getLocation();
8702 Diag(AssignLoc, diag::note_nontrivial_user_defined) << QT << member;
8703 return;
8704 }
8705 break;
8706
Douglas Gregor8a273912009-07-22 18:25:24 +00008707 case CXXDestructor:
8708 if (RD->hasUserDeclaredDestructor()) {
Douglas Gregore71edda2010-07-01 22:47:18 +00008709 SourceLocation DtorLoc = LookupDestructor(RD)->getLocation();
Douglas Gregor8a273912009-07-22 18:25:24 +00008710 Diag(DtorLoc, diag::note_nontrivial_user_defined) << QT << member;
8711 return;
8712 }
8713 break;
8714 }
8715
8716 typedef CXXRecordDecl::base_class_iterator base_iter;
8717
8718 // Virtual bases and members inhibit trivial copying/construction,
8719 // but not trivial destruction.
8720 if (member != CXXDestructor) {
8721 // Check for virtual bases. vbases includes indirect virtual bases,
8722 // so we just iterate through the direct bases.
8723 for (base_iter bi = RD->bases_begin(), be = RD->bases_end(); bi != be; ++bi)
8724 if (bi->isVirtual()) {
8725 SourceLocation BaseLoc = bi->getSourceRange().getBegin();
8726 Diag(BaseLoc, diag::note_nontrivial_has_virtual) << QT << 1;
8727 return;
8728 }
8729
8730 // Check for virtual methods.
8731 typedef CXXRecordDecl::method_iterator meth_iter;
8732 for (meth_iter mi = RD->method_begin(), me = RD->method_end(); mi != me;
8733 ++mi) {
8734 if (mi->isVirtual()) {
8735 SourceLocation MLoc = mi->getSourceRange().getBegin();
8736 Diag(MLoc, diag::note_nontrivial_has_virtual) << QT << 0;
8737 return;
8738 }
8739 }
8740 }
Mike Stump11289f42009-09-09 15:08:12 +00008741
Douglas Gregor8a273912009-07-22 18:25:24 +00008742 bool (CXXRecordDecl::*hasTrivial)() const;
8743 switch (member) {
Alexis Hunt80f00ff2011-05-10 19:08:14 +00008744 case CXXDefaultConstructor:
Alexis Huntf479f1b2011-05-09 18:22:59 +00008745 hasTrivial = &CXXRecordDecl::hasTrivialDefaultConstructor; break;
Douglas Gregor8a273912009-07-22 18:25:24 +00008746 case CXXCopyConstructor:
8747 hasTrivial = &CXXRecordDecl::hasTrivialCopyConstructor; break;
8748 case CXXCopyAssignment:
8749 hasTrivial = &CXXRecordDecl::hasTrivialCopyAssignment; break;
8750 case CXXDestructor:
8751 hasTrivial = &CXXRecordDecl::hasTrivialDestructor; break;
8752 default:
David Blaikieaa347f92011-09-23 20:26:49 +00008753 llvm_unreachable("unexpected special member");
Douglas Gregor8a273912009-07-22 18:25:24 +00008754 }
8755
8756 // Check for nontrivial bases (and recurse).
8757 for (base_iter bi = RD->bases_begin(), be = RD->bases_end(); bi != be; ++bi) {
Ted Kremenekc23c7e62009-07-29 21:53:49 +00008758 const RecordType *BaseRT = bi->getType()->getAs<RecordType>();
Sebastian Redl1054fae2009-10-25 17:03:50 +00008759 assert(BaseRT && "Don't know how to handle dependent bases");
Douglas Gregor8a273912009-07-22 18:25:24 +00008760 CXXRecordDecl *BaseRecTy = cast<CXXRecordDecl>(BaseRT->getDecl());
8761 if (!(BaseRecTy->*hasTrivial)()) {
8762 SourceLocation BaseLoc = bi->getSourceRange().getBegin();
8763 Diag(BaseLoc, diag::note_nontrivial_has_nontrivial) << QT << 1 << member;
8764 DiagnoseNontrivial(BaseRT, member);
8765 return;
8766 }
8767 }
Mike Stump11289f42009-09-09 15:08:12 +00008768
Douglas Gregor8a273912009-07-22 18:25:24 +00008769 // Check for nontrivial members (and recurse).
8770 typedef RecordDecl::field_iterator field_iter;
8771 for (field_iter fi = RD->field_begin(), fe = RD->field_end(); fi != fe;
8772 ++fi) {
Douglas Gregor79f83ed2009-07-23 23:49:00 +00008773 QualType EltTy = Context.getBaseElementType((*fi)->getType());
Ted Kremenekc23c7e62009-07-29 21:53:49 +00008774 if (const RecordType *EltRT = EltTy->getAs<RecordType>()) {
Douglas Gregor8a273912009-07-22 18:25:24 +00008775 CXXRecordDecl* EltRD = cast<CXXRecordDecl>(EltRT->getDecl());
8776
8777 if (!(EltRD->*hasTrivial)()) {
8778 SourceLocation FLoc = (*fi)->getLocation();
8779 Diag(FLoc, diag::note_nontrivial_has_nontrivial) << QT << 0 << member;
8780 DiagnoseNontrivial(EltRT, member);
8781 return;
8782 }
8783 }
John McCall31168b02011-06-15 23:02:42 +00008784
8785 if (EltTy->isObjCLifetimeType()) {
8786 switch (EltTy.getObjCLifetime()) {
8787 case Qualifiers::OCL_None:
8788 case Qualifiers::OCL_ExplicitNone:
8789 break;
8790
8791 case Qualifiers::OCL_Autoreleasing:
8792 case Qualifiers::OCL_Weak:
8793 case Qualifiers::OCL_Strong:
Argyrios Kyrtzidiscff00d92011-06-24 00:08:59 +00008794 Diag((*fi)->getLocation(), diag::note_nontrivial_objc_ownership)
John McCall31168b02011-06-15 23:02:42 +00008795 << QT << EltTy.getObjCLifetime();
8796 return;
8797 }
8798 }
Douglas Gregor8a273912009-07-22 18:25:24 +00008799 }
8800
David Blaikie83d382b2011-09-23 05:06:16 +00008801 llvm_unreachable("found no explanation for non-trivial member");
Douglas Gregor8a273912009-07-22 18:25:24 +00008802}
8803
Mike Stump11289f42009-09-09 15:08:12 +00008804/// TranslateIvarVisibility - Translate visibility from a token ID to an
Fariborz Jahanianf26702eb2007-10-01 16:53:59 +00008805/// AST enum value.
Ted Kremenek1b0ea822008-01-07 19:49:32 +00008806static ObjCIvarDecl::AccessControl
Fariborz Jahanianf26702eb2007-10-01 16:53:59 +00008807TranslateIvarVisibility(tok::ObjCKeywordKind ivarVisibility) {
Steve Naroff2e688fd2007-09-14 23:09:53 +00008808 switch (ivarVisibility) {
David Blaikie83d382b2011-09-23 05:06:16 +00008809 default: llvm_unreachable("Unknown visitibility kind");
Chris Lattner79ef8432008-10-12 00:28:42 +00008810 case tok::objc_private: return ObjCIvarDecl::Private;
8811 case tok::objc_public: return ObjCIvarDecl::Public;
8812 case tok::objc_protected: return ObjCIvarDecl::Protected;
8813 case tok::objc_package: return ObjCIvarDecl::Package;
Steve Naroff2e688fd2007-09-14 23:09:53 +00008814 }
8815}
8816
Mike Stump11289f42009-09-09 15:08:12 +00008817/// ActOnIvar - Each ivar field of an objective-c class is passed into this
Fariborz Jahanian96376742008-04-11 16:55:42 +00008818/// in order to create an IvarDecl object for it.
John McCall48871652010-08-21 09:40:31 +00008819Decl *Sema::ActOnIvar(Scope *S,
Mike Stump11289f42009-09-09 15:08:12 +00008820 SourceLocation DeclStart,
Richard Trieu2bd04012011-09-09 02:00:50 +00008821 Declarator &D, Expr *BitfieldWidth,
Chris Lattner83f095c2009-03-28 19:18:32 +00008822 tok::ObjCKeywordKind Visibility) {
Mike Stump11289f42009-09-09 15:08:12 +00008823
Fariborz Jahaniande615832008-04-10 23:32:45 +00008824 IdentifierInfo *II = D.getIdentifier();
8825 Expr *BitWidth = (Expr*)BitfieldWidth;
8826 SourceLocation Loc = DeclStart;
8827 if (II) Loc = D.getIdentifierLoc();
Mike Stump11289f42009-09-09 15:08:12 +00008828
Fariborz Jahaniande615832008-04-10 23:32:45 +00008829 // FIXME: Unnamed fields can be handled in various different ways, for
8830 // example, unnamed unions inject all members into the struct namespace!
Mike Stump11289f42009-09-09 15:08:12 +00008831
John McCall8cb7bdf2010-06-04 23:28:52 +00008832 TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S);
8833 QualType T = TInfo->getType();
Mike Stump11289f42009-09-09 15:08:12 +00008834
Fariborz Jahaniande615832008-04-10 23:32:45 +00008835 if (BitWidth) {
Steve Naroff17b2f5d2009-02-20 17:57:11 +00008836 // 6.7.2.1p3, 6.7.2.1p4
Chris Lattner73bf7b42009-03-05 22:45:59 +00008837 if (VerifyBitField(Loc, II, T, BitWidth)) {
Chris Lattnerf6d1c9c2009-04-25 08:06:05 +00008838 D.setInvalidType();
Chris Lattner73bf7b42009-03-05 22:45:59 +00008839 BitWidth = 0;
8840 }
Fariborz Jahaniande615832008-04-10 23:32:45 +00008841 } else {
8842 // Not a bitfield.
Mike Stump11289f42009-09-09 15:08:12 +00008843
Fariborz Jahaniande615832008-04-10 23:32:45 +00008844 // validate II.
Mike Stump11289f42009-09-09 15:08:12 +00008845
Fariborz Jahaniande615832008-04-10 23:32:45 +00008846 }
Fariborz Jahanian0103d672010-04-26 22:07:03 +00008847 if (T->isReferenceType()) {
8848 Diag(Loc, diag::err_ivar_reference_type);
8849 D.setInvalidType();
8850 }
Fariborz Jahaniande615832008-04-10 23:32:45 +00008851 // C99 6.7.2.1p8: A member of a structure or union may have any type other
8852 // than a variably modified type.
Fariborz Jahanian0103d672010-04-26 22:07:03 +00008853 else if (T->isVariablyModifiedType()) {
Anders Carlsson0d8f0ba2008-12-07 00:20:55 +00008854 Diag(Loc, diag::err_typecheck_ivar_variable_size);
Chris Lattnerf6d1c9c2009-04-25 08:06:05 +00008855 D.setInvalidType();
Fariborz Jahaniande615832008-04-10 23:32:45 +00008856 }
Mike Stump11289f42009-09-09 15:08:12 +00008857
Ted Kremenek73295fa2008-07-23 18:04:17 +00008858 // Get the visibility (access control) for this ivar.
Mike Stump11289f42009-09-09 15:08:12 +00008859 ObjCIvarDecl::AccessControl ac =
Ted Kremenek73295fa2008-07-23 18:04:17 +00008860 Visibility != tok::objc_not_keyword ? TranslateIvarVisibility(Visibility)
8861 : ObjCIvarDecl::None;
Fariborz Jahanian68453832009-06-05 18:16:35 +00008862 // Must set ivar's DeclContext to its enclosing interface.
Fariborz Jahanian8d382dc2011-08-22 15:54:49 +00008863 ObjCContainerDecl *EnclosingDecl = cast<ObjCContainerDecl>(CurContext);
Daniel Dunbar229385c2010-04-02 18:29:09 +00008864 ObjCContainerDecl *EnclosingContext;
Mike Stump11289f42009-09-09 15:08:12 +00008865 if (ObjCImplementationDecl *IMPDecl =
Fariborz Jahanian68453832009-06-05 18:16:35 +00008866 dyn_cast<ObjCImplementationDecl>(EnclosingDecl)) {
Fariborz Jahanianbf9294f2010-08-23 18:51:39 +00008867 if (!LangOpts.ObjCNonFragileABI2) {
Fariborz Jahanian68453832009-06-05 18:16:35 +00008868 // Case of ivar declared in an implementation. Context is that of its class.
Fariborz Jahanianbf9294f2010-08-23 18:51:39 +00008869 EnclosingContext = IMPDecl->getClassInterface();
8870 assert(EnclosingContext && "Implementation has no class interface!");
8871 }
8872 else
8873 EnclosingContext = EnclosingDecl;
Fariborz Jahanian6a0a2e02010-04-06 22:43:48 +00008874 } else {
8875 if (ObjCCategoryDecl *CDecl =
8876 dyn_cast<ObjCCategoryDecl>(EnclosingDecl)) {
8877 if (!LangOpts.ObjCNonFragileABI2 || !CDecl->IsClassExtension()) {
8878 Diag(Loc, diag::err_misplaced_ivar) << CDecl->IsClassExtension();
John McCall48871652010-08-21 09:40:31 +00008879 return 0;
Fariborz Jahanian6a0a2e02010-04-06 22:43:48 +00008880 }
8881 }
Daniel Dunbar229385c2010-04-02 18:29:09 +00008882 EnclosingContext = EnclosingDecl;
Fariborz Jahanian6a0a2e02010-04-06 22:43:48 +00008883 }
Mike Stump11289f42009-09-09 15:08:12 +00008884
Ted Kremenek73295fa2008-07-23 18:04:17 +00008885 // Construct the decl.
Abramo Bagnaradff19302011-03-08 08:55:46 +00008886 ObjCIvarDecl *NewID = ObjCIvarDecl::Create(Context, EnclosingContext,
8887 DeclStart, Loc, II, T,
John McCallbcd03502009-12-07 02:54:59 +00008888 TInfo, ac, (Expr *)BitfieldWidth);
Mike Stump11289f42009-09-09 15:08:12 +00008889
Douglas Gregor82ac25e2009-01-08 20:45:30 +00008890 if (II) {
Douglas Gregorb2ccf012010-04-15 22:33:43 +00008891 NamedDecl *PrevDecl = LookupSingleName(S, II, Loc, LookupMemberName,
John McCall5cebab12009-11-18 07:57:50 +00008892 ForRedeclaration);
Fariborz Jahanian68453832009-06-05 18:16:35 +00008893 if (PrevDecl && isDeclInScope(PrevDecl, EnclosingContext, S)
Douglas Gregor82ac25e2009-01-08 20:45:30 +00008894 && !isa<TagDecl>(PrevDecl)) {
8895 Diag(Loc, diag::err_duplicate_member) << II;
8896 Diag(PrevDecl->getLocation(), diag::note_previous_declaration);
8897 NewID->setInvalidDecl();
8898 }
8899 }
8900
Ted Kremenek73295fa2008-07-23 18:04:17 +00008901 // Process attributes attached to the ivar.
Douglas Gregor758a8692009-06-17 21:51:59 +00008902 ProcessDeclAttributes(S, NewID, D);
Mike Stump11289f42009-09-09 15:08:12 +00008903
Chris Lattnerf6d1c9c2009-04-25 08:06:05 +00008904 if (D.isInvalidType())
Fariborz Jahaniande615832008-04-10 23:32:45 +00008905 NewID->setInvalidDecl();
Ted Kremenek73295fa2008-07-23 18:04:17 +00008906
John McCall31168b02011-06-15 23:02:42 +00008907 // In ARC, infer 'retaining' for ivars of retainable type.
8908 if (getLangOptions().ObjCAutoRefCount && inferObjCARCLifetime(NewID))
8909 NewID->setInvalidDecl();
8910
Douglas Gregor3baa6702011-09-12 16:11:24 +00008911 if (D.getDeclSpec().isModulePrivateSpecified())
8912 NewID->setModulePrivate();
8913
Douglas Gregor82ac25e2009-01-08 20:45:30 +00008914 if (II) {
8915 // FIXME: When interfaces are DeclContexts, we'll need to add
8916 // these to the interface.
John McCall48871652010-08-21 09:40:31 +00008917 S->AddDecl(NewID);
Douglas Gregor82ac25e2009-01-08 20:45:30 +00008918 IdResolver.AddDecl(NewID);
8919 }
8920
John McCall48871652010-08-21 09:40:31 +00008921 return NewID;
Fariborz Jahaniande615832008-04-10 23:32:45 +00008922}
8923
Fariborz Jahanian616d3e72010-08-23 22:46:52 +00008924/// ActOnLastBitfield - This routine handles synthesized bitfields rules for
8925/// class and class extensions. For every class @interface and class
8926/// extension @interface, if the last ivar is a bitfield of any type,
8927/// then add an implicit `char :0` ivar to the end of that interface.
Fariborz Jahanian8d382dc2011-08-22 15:54:49 +00008928void Sema::ActOnLastBitfield(SourceLocation DeclLoc,
Chris Lattner0e62c1c2011-07-23 10:55:15 +00008929 SmallVectorImpl<Decl *> &AllIvarDecls) {
Fariborz Jahanian616d3e72010-08-23 22:46:52 +00008930 if (!LangOpts.ObjCNonFragileABI2 || AllIvarDecls.empty())
8931 return;
8932
8933 Decl *ivarDecl = AllIvarDecls[AllIvarDecls.size()-1];
8934 ObjCIvarDecl *Ivar = cast<ObjCIvarDecl>(ivarDecl);
8935
Richard Smithcaf33902011-10-10 18:28:20 +00008936 if (!Ivar->isBitField() || Ivar->getBitWidthValue(Context) == 0)
Fariborz Jahanian616d3e72010-08-23 22:46:52 +00008937 return;
Fariborz Jahanian8d382dc2011-08-22 15:54:49 +00008938 ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(CurContext);
Fariborz Jahanian616d3e72010-08-23 22:46:52 +00008939 if (!ID) {
Fariborz Jahanian8d382dc2011-08-22 15:54:49 +00008940 if (ObjCCategoryDecl *CD = dyn_cast<ObjCCategoryDecl>(CurContext)) {
Fariborz Jahanian616d3e72010-08-23 22:46:52 +00008941 if (!CD->IsClassExtension())
8942 return;
8943 }
8944 // No need to add this to end of @implementation.
8945 else
8946 return;
8947 }
8948 // All conditions are met. Add a new bitfield to the tail end of ivars.
Douglas Gregor1d394802011-08-03 16:26:46 +00008949 llvm::APInt Zero(Context.getTypeSize(Context.IntTy), 0);
8950 Expr * BW = IntegerLiteral::Create(Context, Zero, Context.IntTy, DeclLoc);
Fariborz Jahanian616d3e72010-08-23 22:46:52 +00008951
Fariborz Jahanian8d382dc2011-08-22 15:54:49 +00008952 Ivar = ObjCIvarDecl::Create(Context, cast<ObjCContainerDecl>(CurContext),
Abramo Bagnaradff19302011-03-08 08:55:46 +00008953 DeclLoc, DeclLoc, 0,
Fariborz Jahanian616d3e72010-08-23 22:46:52 +00008954 Context.CharTy,
Douglas Gregor1d394802011-08-03 16:26:46 +00008955 Context.getTrivialTypeSourceInfo(Context.CharTy,
8956 DeclLoc),
Fariborz Jahanian616d3e72010-08-23 22:46:52 +00008957 ObjCIvarDecl::Private, BW,
8958 true);
8959 AllIvarDecls.push_back(Ivar);
8960}
8961
Fariborz Jahanian343f7092007-09-29 00:54:24 +00008962void Sema::ActOnFields(Scope* S,
John McCall48871652010-08-21 09:40:31 +00008963 SourceLocation RecLoc, Decl *EnclosingDecl,
David Blaikie751c5582011-09-22 02:58:26 +00008964 llvm::ArrayRef<Decl *> Fields,
Daniel Dunbar15619c72008-10-03 02:03:53 +00008965 SourceLocation LBrac, SourceLocation RBrac,
Daniel Dunbar325601a2008-10-03 17:33:35 +00008966 AttributeList *Attr) {
Steve Naroffdb47ee22007-09-14 22:20:54 +00008967 assert(EnclosingDecl && "missing record or interface decl");
Mike Stump11289f42009-09-09 15:08:12 +00008968
Chris Lattnerd13b8b52009-02-23 22:00:08 +00008969 // If the decl this is being inserted into is invalid, then it may be a
8970 // redeclaration or some other bogus case. Don't try to add fields to it.
Douglas Gregor7bfedd62011-09-12 18:58:37 +00008971 if (EnclosingDecl->isInvalidDecl())
Chris Lattnerd13b8b52009-02-23 22:00:08 +00008972 return;
Mike Stump11289f42009-09-09 15:08:12 +00008973
Chris Lattnerbdf8b8d2007-01-24 02:11:17 +00008974 // Verify that all the fields are okay.
Chris Lattner82625602007-01-24 02:26:21 +00008975 unsigned NumNamedMembers = 0;
Chris Lattner0e62c1c2011-07-23 10:55:15 +00008976 SmallVector<FieldDecl*, 32> RecFields;
Douglas Gregorf4d33272009-01-07 19:46:03 +00008977
Chris Lattnerd13b8b52009-02-23 22:00:08 +00008978 RecordDecl *Record = dyn_cast<RecordDecl>(EnclosingDecl);
John McCall31168b02011-06-15 23:02:42 +00008979 bool ARCErrReported = false;
David Blaikie751c5582011-09-22 02:58:26 +00008980 for (llvm::ArrayRef<Decl *>::iterator i = Fields.begin(), end = Fields.end();
8981 i != end; ++i) {
8982 FieldDecl *FD = cast<FieldDecl>(*i);
Mike Stump11289f42009-09-09 15:08:12 +00008983
Chris Lattner720a0542007-01-25 00:44:24 +00008984 // Get the type for the field.
John McCall424cec92011-01-19 06:33:43 +00008985 const Type *FDTy = FD->getType().getTypePtr();
Douglas Gregorf4d33272009-01-07 19:46:03 +00008986
Douglas Gregor82ac25e2009-01-08 20:45:30 +00008987 if (!FD->isAnonymousStructOrUnion()) {
Douglas Gregorf4d33272009-01-07 19:46:03 +00008988 // Remember all fields written by the user.
8989 RecFields.push_back(FD);
8990 }
Mike Stump11289f42009-09-09 15:08:12 +00008991
Chris Lattner73bf7b42009-03-05 22:45:59 +00008992 // If the field is already invalid for some reason, don't emit more
8993 // diagnostics about it.
Eli Friedmand0e8de22009-12-07 00:22:08 +00008994 if (FD->isInvalidDecl()) {
8995 EnclosingDecl->setInvalidDecl();
Chris Lattner73bf7b42009-03-05 22:45:59 +00008996 continue;
Eli Friedmand0e8de22009-12-07 00:22:08 +00008997 }
Mike Stump11289f42009-09-09 15:08:12 +00008998
Douglas Gregorac1fb652009-03-24 19:52:54 +00008999 // C99 6.7.2.1p2:
9000 // A structure or union shall not contain a member with
9001 // incomplete or function type (hence, a structure shall not
9002 // contain an instance of itself, but may contain a pointer to
9003 // an instance of itself), except that the last member of a
9004 // structure with more than one named member may have incomplete
9005 // array type; such a structure (and any union containing,
9006 // possibly recursively, a member that is such a structure)
9007 // shall not be a member of a structure or an element of an
9008 // array.
Chris Lattner0fd893e2007-07-31 21:33:24 +00009009 if (FDTy->isFunctionType()) {
Douglas Gregorac1fb652009-03-24 19:52:54 +00009010 // Field declared as a function.
Chris Lattner651d42d2008-11-20 06:38:18 +00009011 Diag(FD->getLocation(), diag::err_field_declared_as_function)
Chris Lattnerf3d3fae2008-11-24 05:29:24 +00009012 << FD->getDeclName();
Steve Naroffdb47ee22007-09-14 22:20:54 +00009013 FD->setInvalidDecl();
9014 EnclosingDecl->setInvalidDecl();
Chris Lattnerbdf8b8d2007-01-24 02:11:17 +00009015 continue;
Francois Pichetf657b632010-09-15 00:14:08 +00009016 } else if (FDTy->isIncompleteArrayType() && Record &&
David Blaikie751c5582011-09-22 02:58:26 +00009017 ((i + 1 == Fields.end() && !Record->isUnion()) ||
Francois Pichet0706d202011-09-17 17:15:52 +00009018 ((getLangOptions().MicrosoftExt ||
9019 getLangOptions().CPlusPlus) &&
David Blaikie751c5582011-09-22 02:58:26 +00009020 (i + 1 == Fields.end() || Record->isUnion())))) {
Douglas Gregorac1fb652009-03-24 19:52:54 +00009021 // Flexible array member.
Argyrios Kyrtzidis7e25a952011-03-07 20:04:04 +00009022 // Microsoft and g++ is more permissive regarding flexible array.
Francois Pichetf657b632010-09-15 00:14:08 +00009023 // It will accept flexible array in union and also
Anders Carlsson0ea10472010-10-17 23:36:12 +00009024 // as the sole element of a struct/class.
Francois Pichet0706d202011-09-17 17:15:52 +00009025 if (getLangOptions().MicrosoftExt) {
Francois Pichetf657b632010-09-15 00:14:08 +00009026 if (Record->isUnion())
Argyrios Kyrtzidis7e25a952011-03-07 20:04:04 +00009027 Diag(FD->getLocation(), diag::ext_flexible_array_union_ms)
Francois Pichetf657b632010-09-15 00:14:08 +00009028 << FD->getDeclName();
David Blaikie751c5582011-09-22 02:58:26 +00009029 else if (Fields.size() == 1)
Argyrios Kyrtzidis7e25a952011-03-07 20:04:04 +00009030 Diag(FD->getLocation(), diag::ext_flexible_array_empty_aggregate_ms)
Francois Pichetf657b632010-09-15 00:14:08 +00009031 << FD->getDeclName() << Record->getTagKind();
Argyrios Kyrtzidis7e25a952011-03-07 20:04:04 +00009032 } else if (getLangOptions().CPlusPlus) {
9033 if (Record->isUnion())
9034 Diag(FD->getLocation(), diag::ext_flexible_array_union_gnu)
9035 << FD->getDeclName();
David Blaikie751c5582011-09-22 02:58:26 +00009036 else if (Fields.size() == 1)
Argyrios Kyrtzidis7e25a952011-03-07 20:04:04 +00009037 Diag(FD->getLocation(), diag::ext_flexible_array_empty_aggregate_gnu)
9038 << FD->getDeclName() << Record->getTagKind();
9039 } else if (NumNamedMembers < 1) {
Chris Lattner651d42d2008-11-20 06:38:18 +00009040 Diag(FD->getLocation(), diag::err_flexible_array_empty_struct)
Chris Lattnerf3d3fae2008-11-24 05:29:24 +00009041 << FD->getDeclName();
Steve Naroffdb47ee22007-09-14 22:20:54 +00009042 FD->setInvalidDecl();
9043 EnclosingDecl->setInvalidDecl();
Chris Lattner82625602007-01-24 02:26:21 +00009044 continue;
9045 }
Fariborz Jahanian1138ba62010-05-26 20:19:07 +00009046 if (!FD->getType()->isDependentType() &&
John McCall31168b02011-06-15 23:02:42 +00009047 !Context.getBaseElementType(FD->getType()).isPODType(Context)) {
Fariborz Jahanian1138ba62010-05-26 20:19:07 +00009048 Diag(FD->getLocation(), diag::err_flexible_array_has_nonpod_type)
Fariborz Jahanianb0e28472010-05-26 20:46:24 +00009049 << FD->getDeclName() << FD->getType();
Fariborz Jahanian1138ba62010-05-26 20:19:07 +00009050 FD->setInvalidDecl();
9051 EnclosingDecl->setInvalidDecl();
9052 continue;
9053 }
Chris Lattner720a0542007-01-25 00:44:24 +00009054 // Okay, we have a legal flexible array member at the end of the struct.
Fariborz Jahanianaefb2302007-09-14 16:27:55 +00009055 if (Record)
9056 Record->setHasFlexibleArrayMember(true);
Douglas Gregorac1fb652009-03-24 19:52:54 +00009057 } else if (!FDTy->isDependentType() &&
Mike Stump11289f42009-09-09 15:08:12 +00009058 RequireCompleteType(FD->getLocation(), FD->getType(),
Douglas Gregorac1fb652009-03-24 19:52:54 +00009059 diag::err_field_incomplete)) {
9060 // Incomplete type
9061 FD->setInvalidDecl();
9062 EnclosingDecl->setInvalidDecl();
9063 continue;
Ted Kremenekc23c7e62009-07-29 21:53:49 +00009064 } else if (const RecordType *FDTTy = FDTy->getAs<RecordType>()) {
Chris Lattner720a0542007-01-25 00:44:24 +00009065 if (FDTTy->getDecl()->hasFlexibleArrayMember()) {
9066 // If this is a member of a union, then entire union becomes "flexible".
Argyrios Kyrtzidis554a07b2008-06-09 23:19:58 +00009067 if (Record && Record->isUnion()) {
Chris Lattner41943152007-01-25 04:52:46 +00009068 Record->setHasFlexibleArrayMember(true);
Chris Lattner720a0542007-01-25 00:44:24 +00009069 } else {
9070 // If this is a struct/class and this is not the last element, reject
9071 // it. Note that GCC supports variable sized arrays in the middle of
9072 // structures.
David Blaikie751c5582011-09-22 02:58:26 +00009073 if (i + 1 != Fields.end())
Douglas Gregor3e06dbf2009-03-06 23:41:27 +00009074 Diag(FD->getLocation(), diag::ext_variable_sized_type_in_struct)
Chris Lattnerb28fe9e2009-04-25 18:52:45 +00009075 << FD->getDeclName() << FD->getType();
Douglas Gregor3e06dbf2009-03-06 23:41:27 +00009076 else {
9077 // We support flexible arrays at the end of structs in
9078 // other structs as an extension.
9079 Diag(FD->getLocation(), diag::ext_flexible_array_in_struct)
9080 << FD->getDeclName();
9081 if (Record)
9082 Record->setHasFlexibleArrayMember(true);
Chris Lattner720a0542007-01-25 00:44:24 +00009083 }
Chris Lattner720a0542007-01-25 00:44:24 +00009084 }
9085 }
Fariborz Jahanian5f21d2f2009-07-08 01:18:33 +00009086 if (Record && FDTTy->getDecl()->hasObjectMember())
9087 Record->setHasObjectMember(true);
John McCall8b07ec22010-05-15 11:32:37 +00009088 } else if (FDTy->isObjCObjectType()) {
Douglas Gregorac1fb652009-03-24 19:52:54 +00009089 /// A field cannot be an Objective-c object
Fariborz Jahanian6507135e2011-07-26 17:58:54 +00009090 Diag(FD->getLocation(), diag::err_statically_allocated_object)
9091 << FixItHint::CreateInsertion(FD->getLocation(), "*");
9092 QualType T = Context.getObjCObjectPointerType(FD->getType());
9093 FD->setType(T);
John McCall31168b02011-06-15 23:02:42 +00009094 }
9095 else if (!getLangOptions().CPlusPlus) {
9096 if (getLangOptions().ObjCAutoRefCount && Record && !ARCErrReported) {
9097 // It's an error in ARC if a field has lifetime.
9098 // We don't want to report this in a system header, though,
9099 // so we just make the field unavailable.
9100 // FIXME: that's really not sufficient; we need to make the type
9101 // itself invalid to, say, initialize or copy.
9102 QualType T = FD->getType();
9103 Qualifiers::ObjCLifetime lifetime = T.getObjCLifetime();
9104 if (lifetime && lifetime != Qualifiers::OCL_ExplicitNone) {
9105 SourceLocation loc = FD->getLocation();
9106 if (getSourceManager().isInSystemHeader(loc)) {
9107 if (!FD->hasAttr<UnavailableAttr>()) {
9108 FD->addAttr(new (Context) UnavailableAttr(loc, Context,
Argyrios Kyrtzidiscff00d92011-06-24 00:08:59 +00009109 "this system field has retaining ownership"));
John McCall31168b02011-06-15 23:02:42 +00009110 }
9111 } else {
9112 Diag(FD->getLocation(), diag::err_arc_objc_object_in_struct);
9113 }
9114 ARCErrReported = true;
9115 }
9116 }
9117 else if (getLangOptions().ObjC1 &&
Douglas Gregor79a91412011-09-13 17:21:33 +00009118 getLangOptions().getGC() != LangOptions::NonGC &&
John McCall31168b02011-06-15 23:02:42 +00009119 Record && !Record->hasObjectMember()) {
9120 if (FD->getType()->isObjCObjectPointerType() ||
9121 FD->getType().isObjCGCStrong())
9122 Record->setHasObjectMember(true);
9123 else if (Context.getAsArrayType(FD->getType())) {
9124 QualType BaseType = Context.getBaseElementType(FD->getType());
9125 if (BaseType->isRecordType() &&
9126 BaseType->getAs<RecordType>()->getDecl()->hasObjectMember())
9127 Record->setHasObjectMember(true);
9128 else if (BaseType->isObjCObjectPointerType() ||
9129 BaseType.isObjCGCStrong())
9130 Record->setHasObjectMember(true);
9131 }
9132 }
Fariborz Jahanian021510e2010-06-15 22:44:06 +00009133 }
Chris Lattner82625602007-01-24 02:26:21 +00009134 // Keep track of the number of named members.
Douglas Gregor82ac25e2009-01-08 20:45:30 +00009135 if (FD->getIdentifier())
Chris Lattner82625602007-01-24 02:26:21 +00009136 ++NumNamedMembers;
Chris Lattnerbdf8b8d2007-01-24 02:11:17 +00009137 }
Sebastian Redlbaad4e72009-01-05 20:52:13 +00009138
Chris Lattner82625602007-01-24 02:26:21 +00009139 // Okay, we successfully defined 'Record'.
Chris Lattner622c1932008-02-06 00:51:33 +00009140 if (Record) {
Douglas Gregor8fb95122010-09-29 00:15:42 +00009141 bool Completed = false;
9142 if (CXXRecordDecl *CXXRecord = dyn_cast<CXXRecordDecl>(Record)) {
9143 if (!CXXRecord->isInvalidDecl()) {
9144 // Set access bits correctly on the directly-declared conversions.
9145 UnresolvedSetImpl *Convs = CXXRecord->getConversionFunctions();
9146 for (UnresolvedSetIterator I = Convs->begin(), E = Convs->end();
9147 I != E; ++I)
9148 Convs->setAccess(I, (*I)->getAccess());
9149
9150 if (!CXXRecord->isDependentType()) {
John McCall31168b02011-06-15 23:02:42 +00009151 // Objective-C Automatic Reference Counting:
9152 // If a class has a non-static data member of Objective-C pointer
9153 // type (or array thereof), it is a non-POD type and its
9154 // default constructor (if any), copy constructor, copy assignment
9155 // operator, and destructor are non-trivial.
9156 //
9157 // This rule is also handled by CXXRecordDecl::completeDefinition().
9158 // However, here we check whether this particular class is only
9159 // non-POD because of the presence of an Objective-C pointer member.
9160 // If so, objects of this type cannot be shared between code compiled
9161 // with instant objects and code compiled with manual retain/release.
9162 if (getLangOptions().ObjCAutoRefCount &&
9163 CXXRecord->hasObjectMember() &&
9164 CXXRecord->getLinkage() == ExternalLinkage) {
9165 if (CXXRecord->isPOD()) {
9166 Diag(CXXRecord->getLocation(),
9167 diag::warn_arc_non_pod_class_with_object_member)
9168 << CXXRecord;
9169 } else {
9170 // FIXME: Fix-Its would be nice here, but finding a good location
9171 // for them is going to be tricky.
9172 if (CXXRecord->hasTrivialCopyConstructor())
9173 Diag(CXXRecord->getLocation(),
9174 diag::warn_arc_trivial_member_function_with_object_member)
9175 << CXXRecord << 0;
9176 if (CXXRecord->hasTrivialCopyAssignment())
9177 Diag(CXXRecord->getLocation(),
9178 diag::warn_arc_trivial_member_function_with_object_member)
9179 << CXXRecord << 1;
9180 if (CXXRecord->hasTrivialDestructor())
9181 Diag(CXXRecord->getLocation(),
9182 diag::warn_arc_trivial_member_function_with_object_member)
9183 << CXXRecord << 2;
9184 }
9185 }
9186
Sebastian Redl623ea822011-05-19 05:13:44 +00009187 // Adjust user-defined destructor exception spec.
9188 if (getLangOptions().CPlusPlus0x &&
9189 CXXRecord->hasUserDeclaredDestructor())
9190 AdjustDestructorExceptionSpec(CXXRecord,CXXRecord->getDestructor());
9191
Douglas Gregor8fb95122010-09-29 00:15:42 +00009192 // Add any implicitly-declared members to this class.
9193 AddImplicitlyDeclaredMembersToClass(CXXRecord);
9194
9195 // If we have virtual base classes, we may end up finding multiple
9196 // final overriders for a given virtual function. Check for this
9197 // problem now.
9198 if (CXXRecord->getNumVBases()) {
9199 CXXFinalOverriderMap FinalOverriders;
9200 CXXRecord->getFinalOverriders(FinalOverriders);
9201
9202 for (CXXFinalOverriderMap::iterator M = FinalOverriders.begin(),
9203 MEnd = FinalOverriders.end();
9204 M != MEnd; ++M) {
9205 for (OverridingMethods::iterator SO = M->second.begin(),
9206 SOEnd = M->second.end();
9207 SO != SOEnd; ++SO) {
9208 assert(SO->second.size() > 0 &&
9209 "Virtual function without overridding functions?");
9210 if (SO->second.size() == 1)
9211 continue;
9212
9213 // C++ [class.virtual]p2:
9214 // In a derived class, if a virtual member function of a base
9215 // class subobject has more than one final overrider the
9216 // program is ill-formed.
9217 Diag(Record->getLocation(), diag::err_multiple_final_overriders)
9218 << (NamedDecl *)M->first << Record;
9219 Diag(M->first->getLocation(),
9220 diag::note_overridden_virtual_function);
9221 for (OverridingMethods::overriding_iterator
9222 OM = SO->second.begin(),
9223 OMEnd = SO->second.end();
9224 OM != OMEnd; ++OM)
9225 Diag(OM->Method->getLocation(), diag::note_final_overrider)
9226 << (NamedDecl *)M->first << OM->Method->getParent();
9227
9228 Record->setInvalidDecl();
9229 }
9230 }
9231 CXXRecord->completeDefinition(&FinalOverriders);
9232 Completed = true;
9233 }
9234 }
9235 }
9236 }
9237
9238 if (!Completed)
9239 Record->completeDefinition();
Sebastian Redl623ea822011-05-19 05:13:44 +00009240
9241 // Now that the record is complete, do any delayed exception spec checks
9242 // we were missing.
Richard Smith938f40b2011-06-11 17:19:42 +00009243 while (!DelayedDestructorExceptionSpecChecks.empty()) {
Sebastian Redl623ea822011-05-19 05:13:44 +00009244 const CXXDestructorDecl *Dtor =
9245 DelayedDestructorExceptionSpecChecks.back().first;
Richard Smith938f40b2011-06-11 17:19:42 +00009246 if (Dtor->getParent() != Record)
9247 break;
9248
9249 assert(!Dtor->getParent()->isDependentType() &&
9250 "Should not ever add destructors of templates into the list.");
9251 CheckOverridingFunctionExceptionSpec(Dtor,
9252 DelayedDestructorExceptionSpecChecks.back().second);
9253 DelayedDestructorExceptionSpecChecks.pop_back();
Sebastian Redl623ea822011-05-19 05:13:44 +00009254 }
9255
Chris Lattner622c1932008-02-06 00:51:33 +00009256 } else {
Jay Foad7d0479f2009-05-21 09:52:38 +00009257 ObjCIvarDecl **ClsFields =
9258 reinterpret_cast<ObjCIvarDecl**>(RecFields.data());
Fariborz Jahanian02225532008-12-13 20:28:25 +00009259 if (ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(EnclosingDecl)) {
Chris Lattner22298722009-02-20 21:35:13 +00009260 ID->setLocEnd(RBrac);
Fariborz Jahanian68453832009-06-05 18:16:35 +00009261 // Add ivar's to class's DeclContext.
9262 for (unsigned i = 0, e = RecFields.size(); i != e; ++i) {
9263 ClsFields[i]->setLexicalDeclContext(ID);
Argyrios Kyrtzidiscfbfe782009-06-30 02:36:12 +00009264 ID->addDecl(ClsFields[i]);
Fariborz Jahanian68453832009-06-05 18:16:35 +00009265 }
Fariborz Jahaniana599c132008-12-16 01:08:35 +00009266 // Must enforce the rule that ivars in the base classes may not be
9267 // duplicates.
Fariborz Jahanian545643c2010-02-23 23:41:11 +00009268 if (ID->getSuperClass())
9269 DiagnoseDuplicateIvars(ID, ID->getSuperClass());
Mike Stump11289f42009-09-09 15:08:12 +00009270 } else if (ObjCImplementationDecl *IMPDecl =
Chris Lattnerd13b8b52009-02-23 22:00:08 +00009271 dyn_cast<ObjCImplementationDecl>(EnclosingDecl)) {
Ted Kremenek1b0ea822008-01-07 19:49:32 +00009272 assert(IMPDecl && "ActOnFields - missing ObjCImplementationDecl");
Fariborz Jahanian68453832009-06-05 18:16:35 +00009273 for (unsigned I = 0, N = RecFields.size(); I != N; ++I)
9274 // Ivar declared in @implementation never belongs to the implementation.
9275 // Only it is in implementation's lexical context.
Douglas Gregor5f662052009-04-23 03:23:08 +00009276 ClsFields[I]->setLexicalDeclContext(IMPDecl);
Fariborz Jahanian95b60762007-10-31 18:48:14 +00009277 CheckImplementationIvars(IMPDecl, ClsFields, RecFields.size(), RBrac);
Fariborz Jahanian4c172c62010-02-22 23:04:20 +00009278 } else if (ObjCCategoryDecl *CDecl =
9279 dyn_cast<ObjCCategoryDecl>(EnclosingDecl)) {
Fariborz Jahanian6a0a2e02010-04-06 22:43:48 +00009280 // case of ivars in class extension; all other cases have been
9281 // reported as errors elsewhere.
9282 // FIXME. Class extension does not have a LocEnd field.
9283 // CDecl->setLocEnd(RBrac);
9284 // Add ivar's to class extension's DeclContext.
9285 for (unsigned i = 0, e = RecFields.size(); i != e; ++i) {
9286 ClsFields[i]->setLexicalDeclContext(CDecl);
9287 CDecl->addDecl(ClsFields[i]);
Fariborz Jahanian4c172c62010-02-22 23:04:20 +00009288 }
Fariborz Jahanian2a4dd312007-09-26 18:27:25 +00009289 }
Fariborz Jahanianf3287bf2007-09-14 21:08:27 +00009290 }
Daniel Dunbar325601a2008-10-03 17:33:35 +00009291
9292 if (Attr)
Douglas Gregor758a8692009-06-17 21:51:59 +00009293 ProcessDeclAttributeList(S, Record, Attr);
Eli Friedman570024a2010-08-05 06:57:20 +00009294
9295 // If there's a #pragma GCC visibility in scope, and this isn't a subclass,
9296 // set the visibility of this record.
9297 if (Record && !Record->getDeclContext()->isRecord())
9298 AddPushedVisibilityAttribute(Record);
Chris Lattner1300fb92007-01-23 23:42:53 +00009299}
9300
Douglas Gregor6791a0d2010-02-01 23:36:03 +00009301/// \brief Determine whether the given integral value is representable within
9302/// the given type T.
9303static bool isRepresentableIntegerValue(ASTContext &Context,
9304 llvm::APSInt &Value,
9305 QualType T) {
Douglas Gregor6972a622010-06-16 00:35:25 +00009306 assert(T->isIntegralType(Context) && "Integral type required!");
Douglas Gregorc1cf8142010-04-15 15:53:31 +00009307 unsigned BitWidth = Context.getIntWidth(T);
Douglas Gregor6791a0d2010-02-01 23:36:03 +00009308
Douglas Gregor0bf31402010-10-08 23:50:27 +00009309 if (Value.isUnsigned() || Value.isNonNegative()) {
Douglas Gregor6ab2fa82011-05-20 16:38:50 +00009310 if (T->isSignedIntegerOrEnumerationType())
Douglas Gregor0bf31402010-10-08 23:50:27 +00009311 --BitWidth;
9312 return Value.getActiveBits() <= BitWidth;
9313 }
Douglas Gregor6791a0d2010-02-01 23:36:03 +00009314 return Value.getMinSignedBits() <= BitWidth;
9315}
9316
9317// \brief Given an integral type, return the next larger integral type
9318// (or a NULL type of no such type exists).
9319static QualType getNextLargerIntegralType(ASTContext &Context, QualType T) {
9320 // FIXME: Int128/UInt128 support, which also needs to be introduced into
9321 // enum checking below.
Douglas Gregor6972a622010-06-16 00:35:25 +00009322 assert(T->isIntegralType(Context) && "Integral type required!");
Douglas Gregor6791a0d2010-02-01 23:36:03 +00009323 const unsigned NumTypes = 4;
9324 QualType SignedIntegralTypes[NumTypes] = {
9325 Context.ShortTy, Context.IntTy, Context.LongTy, Context.LongLongTy
9326 };
9327 QualType UnsignedIntegralTypes[NumTypes] = {
9328 Context.UnsignedShortTy, Context.UnsignedIntTy, Context.UnsignedLongTy,
9329 Context.UnsignedLongLongTy
9330 };
9331
9332 unsigned BitWidth = Context.getTypeSize(T);
Douglas Gregor6ab2fa82011-05-20 16:38:50 +00009333 QualType *Types = T->isSignedIntegerOrEnumerationType()? SignedIntegralTypes
9334 : UnsignedIntegralTypes;
Douglas Gregor6791a0d2010-02-01 23:36:03 +00009335 for (unsigned I = 0; I != NumTypes; ++I)
9336 if (Context.getTypeSize(Types[I]) > BitWidth)
9337 return Types[I];
9338
9339 return QualType();
9340}
9341
Douglas Gregor954f6b272009-03-17 19:05:46 +00009342EnumConstantDecl *Sema::CheckEnumConstant(EnumDecl *Enum,
9343 EnumConstantDecl *LastEnumConst,
9344 SourceLocation IdLoc,
9345 IdentifierInfo *Id,
John McCallb268a282010-08-23 23:25:46 +00009346 Expr *Val) {
Douglas Gregore8bbc122011-09-02 00:18:52 +00009347 unsigned IntWidth = Context.getTargetInfo().getIntWidth();
Douglas Gregor6791a0d2010-02-01 23:36:03 +00009348 llvm::APSInt EnumVal(IntWidth);
Douglas Gregor954f6b272009-03-17 19:05:46 +00009349 QualType EltTy;
Douglas Gregor2b988fd2010-12-16 00:24:44 +00009350
9351 if (Val && DiagnoseUnexpandedParameterPack(Val, UPPC_EnumeratorValue))
9352 Val = 0;
9353
Douglas Gregorb2186fe2009-11-06 00:03:12 +00009354 if (Val) {
Douglas Gregordc70c3a2010-03-02 17:53:14 +00009355 if (Enum->isDependentType() || Val->isTypeDependent())
Douglas Gregorb2186fe2009-11-06 00:03:12 +00009356 EltTy = Context.DependentTy;
9357 else {
Douglas Gregorb2186fe2009-11-06 00:03:12 +00009358 // C99 6.7.2.2p2: Make sure we have an integer constant expression.
9359 SourceLocation ExpLoc;
Douglas Gregordc70c3a2010-03-02 17:53:14 +00009360 if (!Val->isValueDependent() &&
9361 VerifyIntegerConstantExpression(Val, &EnumVal)) {
Douglas Gregorb2186fe2009-11-06 00:03:12 +00009362 Val = 0;
Douglas Gregor6791a0d2010-02-01 23:36:03 +00009363 } else {
9364 if (!getLangOptions().CPlusPlus) {
9365 // C99 6.7.2.2p2:
9366 // The expression that defines the value of an enumeration constant
9367 // shall be an integer constant expression that has a value
9368 // representable as an int.
9369
9370 // Complain if the value is not representable in an int.
9371 if (!isRepresentableIntegerValue(Context, EnumVal, Context.IntTy))
9372 Diag(IdLoc, diag::ext_enum_value_not_int)
9373 << EnumVal.toString(10) << Val->getSourceRange()
Douglas Gregorc0b8c812010-02-17 22:40:11 +00009374 << (EnumVal.isUnsigned() || EnumVal.isNonNegative());
Douglas Gregor6791a0d2010-02-01 23:36:03 +00009375 else if (!Context.hasSameType(Val->getType(), Context.IntTy)) {
9376 // Force the type of the expression to 'int'.
John Wiegley01296292011-04-08 18:41:53 +00009377 Val = ImpCastExprToType(Val, Context.IntTy, CK_IntegralCast).take();
Douglas Gregor6791a0d2010-02-01 23:36:03 +00009378 }
9379 }
9380
Douglas Gregor0bf31402010-10-08 23:50:27 +00009381 if (Enum->isFixed()) {
9382 EltTy = Enum->getIntegerType();
9383
9384 // C++0x [dcl.enum]p5:
9385 // ... if the initializing value of an enumerator cannot be
9386 // represented by the underlying type, the program is ill-formed.
Francois Picheta3108062010-10-18 15:01:13 +00009387 if (!isRepresentableIntegerValue(Context, EnumVal, EltTy)) {
Francois Pichet0706d202011-09-17 17:15:52 +00009388 if (getLangOptions().MicrosoftExt) {
Francois Picheta3108062010-10-18 15:01:13 +00009389 Diag(IdLoc, diag::ext_enumerator_too_large) << EltTy;
John Wiegley01296292011-04-08 18:41:53 +00009390 Val = ImpCastExprToType(Val, EltTy, CK_IntegralCast).take();
Francois Picheta3108062010-10-18 15:01:13 +00009391 } else
9392 Diag(IdLoc, diag::err_enumerator_too_large)
9393 << EltTy;
9394 } else
John Wiegley01296292011-04-08 18:41:53 +00009395 Val = ImpCastExprToType(Val, EltTy, CK_IntegralCast).take();
Douglas Gregor0bf31402010-10-08 23:50:27 +00009396 }
9397 else {
9398 // C++0x [dcl.enum]p5:
9399 // If the underlying type is not fixed, the type of each enumerator
9400 // is the type of its initializing value:
9401 // - If an initializer is specified for an enumerator, the
9402 // initializing value has the same type as the expression.
9403 EltTy = Val->getType();
9404 }
Douglas Gregorb2186fe2009-11-06 00:03:12 +00009405 }
Douglas Gregor954f6b272009-03-17 19:05:46 +00009406 }
9407 }
Mike Stump11289f42009-09-09 15:08:12 +00009408
Douglas Gregor954f6b272009-03-17 19:05:46 +00009409 if (!Val) {
Eli Friedmand0e60972009-12-11 01:34:50 +00009410 if (Enum->isDependentType())
9411 EltTy = Context.DependentTy;
Douglas Gregor6791a0d2010-02-01 23:36:03 +00009412 else if (!LastEnumConst) {
9413 // C++0x [dcl.enum]p5:
9414 // If the underlying type is not fixed, the type of each enumerator
9415 // is the type of its initializing value:
9416 // - If no initializer is specified for the first enumerator, the
9417 // initializing value has an unspecified integral type.
9418 //
9419 // GCC uses 'int' for its unspecified integral type, as does
9420 // C99 6.7.2.2p3.
Douglas Gregor0bf31402010-10-08 23:50:27 +00009421 if (Enum->isFixed()) {
9422 EltTy = Enum->getIntegerType();
9423 }
9424 else {
9425 EltTy = Context.IntTy;
9426 }
Douglas Gregor6791a0d2010-02-01 23:36:03 +00009427 } else {
Douglas Gregor954f6b272009-03-17 19:05:46 +00009428 // Assign the last value + 1.
9429 EnumVal = LastEnumConst->getInitVal();
9430 ++EnumVal;
Douglas Gregor6791a0d2010-02-01 23:36:03 +00009431 EltTy = LastEnumConst->getType();
Douglas Gregor954f6b272009-03-17 19:05:46 +00009432
9433 // Check for overflow on increment.
Douglas Gregor6791a0d2010-02-01 23:36:03 +00009434 if (EnumVal < LastEnumConst->getInitVal()) {
9435 // C++0x [dcl.enum]p5:
9436 // If the underlying type is not fixed, the type of each enumerator
9437 // is the type of its initializing value:
9438 //
9439 // - Otherwise the type of the initializing value is the same as
9440 // the type of the initializing value of the preceding enumerator
9441 // unless the incremented value is not representable in that type,
9442 // in which case the type is an unspecified integral type
9443 // sufficient to contain the incremented value. If no such type
9444 // exists, the program is ill-formed.
9445 QualType T = getNextLargerIntegralType(Context, EltTy);
Douglas Gregor0bf31402010-10-08 23:50:27 +00009446 if (T.isNull() || Enum->isFixed()) {
Douglas Gregor6791a0d2010-02-01 23:36:03 +00009447 // There is no integral type larger enough to represent this
9448 // value. Complain, then allow the value to wrap around.
9449 EnumVal = LastEnumConst->getInitVal();
Jay Foad6d4db0c2010-12-07 08:25:34 +00009450 EnumVal = EnumVal.zext(EnumVal.getBitWidth() * 2);
Douglas Gregor0bf31402010-10-08 23:50:27 +00009451 ++EnumVal;
9452 if (Enum->isFixed())
9453 // When the underlying type is fixed, this is ill-formed.
9454 Diag(IdLoc, diag::err_enumerator_wrapped)
9455 << EnumVal.toString(10)
9456 << EltTy;
9457 else
9458 Diag(IdLoc, diag::warn_enumerator_too_large)
9459 << EnumVal.toString(10);
Douglas Gregor6791a0d2010-02-01 23:36:03 +00009460 } else {
9461 EltTy = T;
9462 }
9463
9464 // Retrieve the last enumerator's value, extent that type to the
9465 // type that is supposed to be large enough to represent the incremented
9466 // value, then increment.
9467 EnumVal = LastEnumConst->getInitVal();
Douglas Gregor6ab2fa82011-05-20 16:38:50 +00009468 EnumVal.setIsSigned(EltTy->isSignedIntegerOrEnumerationType());
Jay Foad6d4db0c2010-12-07 08:25:34 +00009469 EnumVal = EnumVal.zextOrTrunc(Context.getIntWidth(EltTy));
Douglas Gregor6791a0d2010-02-01 23:36:03 +00009470 ++EnumVal;
9471
9472 // If we're not in C++, diagnose the overflow of enumerator values,
9473 // which in C99 means that the enumerator value is not representable in
9474 // an int (C99 6.7.2.2p2). However, we support GCC's extension that
9475 // permits enumerator values that are representable in some larger
9476 // integral type.
9477 if (!getLangOptions().CPlusPlus && !T.isNull())
9478 Diag(IdLoc, diag::warn_enum_value_overflow);
9479 } else if (!getLangOptions().CPlusPlus &&
9480 !isRepresentableIntegerValue(Context, EnumVal, EltTy)) {
9481 // Enforce C99 6.7.2.2p2 even when we compute the next value.
9482 Diag(IdLoc, diag::ext_enum_value_not_int)
9483 << EnumVal.toString(10) << 1;
9484 }
Douglas Gregor954f6b272009-03-17 19:05:46 +00009485 }
9486 }
Mike Stump11289f42009-09-09 15:08:12 +00009487
Douglas Gregordc70c3a2010-03-02 17:53:14 +00009488 if (!EltTy->isDependentType()) {
Douglas Gregor6791a0d2010-02-01 23:36:03 +00009489 // Make the enumerator value match the signedness and size of the
9490 // enumerator's type.
Jay Foad6d4db0c2010-12-07 08:25:34 +00009491 EnumVal = EnumVal.zextOrTrunc(Context.getIntWidth(EltTy));
Douglas Gregor6ab2fa82011-05-20 16:38:50 +00009492 EnumVal.setIsSigned(EltTy->isSignedIntegerOrEnumerationType());
Douglas Gregor6791a0d2010-02-01 23:36:03 +00009493 }
Douglas Gregorb2186fe2009-11-06 00:03:12 +00009494
Douglas Gregor954f6b272009-03-17 19:05:46 +00009495 return EnumConstantDecl::Create(Context, Enum, IdLoc, Id, EltTy,
Mike Stump11289f42009-09-09 15:08:12 +00009496 Val, EnumVal);
Douglas Gregor954f6b272009-03-17 19:05:46 +00009497}
9498
9499
John McCall811a0f52010-10-22 23:36:17 +00009500Decl *Sema::ActOnEnumConstant(Scope *S, Decl *theEnumDecl, Decl *lastEnumConst,
9501 SourceLocation IdLoc, IdentifierInfo *Id,
9502 AttributeList *Attr,
Richard Trieu2bd04012011-09-09 02:00:50 +00009503 SourceLocation EqualLoc, Expr *val) {
John McCall48871652010-08-21 09:40:31 +00009504 EnumDecl *TheEnumDecl = cast<EnumDecl>(theEnumDecl);
Chris Lattner4ef40012007-06-11 01:28:17 +00009505 EnumConstantDecl *LastEnumConst =
John McCall48871652010-08-21 09:40:31 +00009506 cast_or_null<EnumConstantDecl>(lastEnumConst);
Chris Lattner4ef40012007-06-11 01:28:17 +00009507 Expr *Val = static_cast<Expr*>(val);
Chris Lattner8116d1b2007-01-25 22:38:29 +00009508
Chris Lattner1a76a3c2007-08-26 06:24:45 +00009509 // The scope passed in may not be a decl scope. Zip up the scope tree until
9510 // we find one that is.
Douglas Gregor45a33ec2009-01-12 18:45:55 +00009511 S = getNonFieldDeclScope(S);
Mike Stump11289f42009-09-09 15:08:12 +00009512
Chris Lattner8116d1b2007-01-25 22:38:29 +00009513 // Verify that there isn't already something declared with this name in this
9514 // scope.
Douglas Gregorb2ccf012010-04-15 22:33:43 +00009515 NamedDecl *PrevDecl = LookupSingleName(S, Id, IdLoc, LookupOrdinaryName,
Douglas Gregor5204248f2010-01-19 06:06:57 +00009516 ForRedeclaration);
Douglas Gregor5daeee22008-12-08 18:40:42 +00009517 if (PrevDecl && PrevDecl->isTemplateParameter()) {
Douglas Gregor5101c242008-12-05 18:15:24 +00009518 // Maybe we will complain about the shadowed template parameter.
9519 DiagnoseTemplateParameterShadow(IdLoc, PrevDecl);
9520 // Just pretend that we didn't see the previous declaration.
9521 PrevDecl = 0;
9522 }
9523
9524 if (PrevDecl) {
Argyrios Kyrtzidisbd259982008-07-16 21:01:53 +00009525 // When in C++, we may get a TagDecl with the same name; in this case the
9526 // enum constant will 'hide' the tag.
9527 assert((getLangOptions().CPlusPlus || !isa<TagDecl>(PrevDecl)) &&
9528 "Received TagDecl when not in C++!");
Argyrios Kyrtzidis5b144d52008-09-09 21:18:04 +00009529 if (!isa<TagDecl>(PrevDecl) && isDeclInScope(PrevDecl, CurContext, S)) {
Chris Lattner8116d1b2007-01-25 22:38:29 +00009530 if (isa<EnumConstantDecl>(PrevDecl))
Chris Lattner4bd8dd82008-11-19 08:23:25 +00009531 Diag(IdLoc, diag::err_redefinition_of_enumerator) << Id;
Chris Lattner8116d1b2007-01-25 22:38:29 +00009532 else
Chris Lattner4bd8dd82008-11-19 08:23:25 +00009533 Diag(IdLoc, diag::err_redefinition) << Id;
Chris Lattner0369c572008-11-23 23:12:31 +00009534 Diag(PrevDecl->getLocation(), diag::note_previous_definition);
John McCall48871652010-08-21 09:40:31 +00009535 return 0;
Chris Lattner8116d1b2007-01-25 22:38:29 +00009536 }
9537 }
Chris Lattner4ef40012007-06-11 01:28:17 +00009538
Douglas Gregor36c22a22010-10-15 13:21:21 +00009539 // C++ [class.mem]p13:
9540 // If T is the name of a class, then each of the following shall have a
9541 // name different from T:
9542 // - every enumerator of every member of class T that is an enumerated
9543 // type
9544 if (CXXRecordDecl *Record
9545 = dyn_cast<CXXRecordDecl>(
9546 TheEnumDecl->getDeclContext()->getRedeclContext()))
9547 if (Record->getIdentifier() && Record->getIdentifier() == Id)
9548 Diag(IdLoc, diag::err_member_name_of_class) << Id;
9549
John McCall811a0f52010-10-22 23:36:17 +00009550 EnumConstantDecl *New =
9551 CheckEnumConstant(TheEnumDecl, LastEnumConst, IdLoc, Id, Val);
Chris Lattner0515e4b2007-08-27 21:16:18 +00009552
John McCall553c0792010-01-23 00:46:32 +00009553 if (New) {
John McCall811a0f52010-10-22 23:36:17 +00009554 // Process attributes.
9555 if (Attr) ProcessDeclAttributeList(S, New, Attr);
9556
9557 // Register this decl in the current scope stack.
John McCall553c0792010-01-23 00:46:32 +00009558 New->setAccess(TheEnumDecl->getAccess());
Douglas Gregor954f6b272009-03-17 19:05:46 +00009559 PushOnScopeChains(New, S);
John McCall553c0792010-01-23 00:46:32 +00009560 }
Douglas Gregor2f521192008-12-17 02:04:30 +00009561
John McCall48871652010-08-21 09:40:31 +00009562 return New;
Chris Lattnerc1915e22007-01-25 07:29:02 +00009563}
9564
Mike Stump6814d1c2009-05-16 07:06:02 +00009565void Sema::ActOnEnumBody(SourceLocation EnumLoc, SourceLocation LBraceLoc,
John McCall48871652010-08-21 09:40:31 +00009566 SourceLocation RBraceLoc, Decl *EnumDeclX,
9567 Decl **Elements, unsigned NumElements,
Edward O'Callaghanc69169d2009-08-08 14:36:57 +00009568 Scope *S, AttributeList *Attr) {
John McCall48871652010-08-21 09:40:31 +00009569 EnumDecl *Enum = cast<EnumDecl>(EnumDeclX);
Douglas Gregor07665a62009-01-05 19:45:36 +00009570 QualType EnumType = Context.getTypeDeclType(Enum);
Edward O'Callaghanc69169d2009-08-08 14:36:57 +00009571
9572 if (Attr)
9573 ProcessDeclAttributeList(S, Enum, Attr);
Mike Stump11289f42009-09-09 15:08:12 +00009574
Eli Friedmand0e60972009-12-11 01:34:50 +00009575 if (Enum->isDependentType()) {
9576 for (unsigned i = 0; i != NumElements; ++i) {
9577 EnumConstantDecl *ECD =
John McCall48871652010-08-21 09:40:31 +00009578 cast_or_null<EnumConstantDecl>(Elements[i]);
Eli Friedmand0e60972009-12-11 01:34:50 +00009579 if (!ECD) continue;
9580
9581 ECD->setType(EnumType);
9582 }
9583
John McCall9aa35be2010-05-06 08:49:23 +00009584 Enum->completeDefinition(Context.DependentTy, Context.DependentTy, 0, 0);
Eli Friedmand0e60972009-12-11 01:34:50 +00009585 return;
9586 }
9587
Chris Lattner67933c02007-08-28 05:10:31 +00009588 // TODO: If the result value doesn't fit in an int, it must be a long or long
9589 // long value. ISO C does not support this, but GCC does as an extension,
9590 // emit a warning.
Douglas Gregore8bbc122011-09-02 00:18:52 +00009591 unsigned IntWidth = Context.getTargetInfo().getIntWidth();
9592 unsigned CharWidth = Context.getTargetInfo().getCharWidth();
9593 unsigned ShortWidth = Context.getTargetInfo().getShortWidth();
Mike Stump11289f42009-09-09 15:08:12 +00009594
Chris Lattnerb8a501c2007-08-28 06:15:15 +00009595 // Verify that all the values are okay, compute the size of the values, and
9596 // reverse the list.
9597 unsigned NumNegativeBits = 0;
9598 unsigned NumPositiveBits = 0;
Mike Stump11289f42009-09-09 15:08:12 +00009599
Chris Lattnerb8a501c2007-08-28 06:15:15 +00009600 // Keep track of whether all elements have type int.
9601 bool AllElementsInt = true;
Mike Stump11289f42009-09-09 15:08:12 +00009602
Chris Lattnerc1915e22007-01-25 07:29:02 +00009603 for (unsigned i = 0; i != NumElements; ++i) {
9604 EnumConstantDecl *ECD =
John McCall48871652010-08-21 09:40:31 +00009605 cast_or_null<EnumConstantDecl>(Elements[i]);
Chris Lattnerc1915e22007-01-25 07:29:02 +00009606 if (!ECD) continue; // Already issued a diagnostic.
Mike Stump11289f42009-09-09 15:08:12 +00009607
Chris Lattnerbf478cb2007-08-28 05:27:00 +00009608 const llvm::APSInt &InitVal = ECD->getInitVal();
Mike Stump11289f42009-09-09 15:08:12 +00009609
Chris Lattnerb8a501c2007-08-28 06:15:15 +00009610 // Keep track of the size of positive and negative values.
Chris Lattner77683132008-02-26 00:33:57 +00009611 if (InitVal.isUnsigned() || InitVal.isNonNegative())
Chris Lattner49f980c2008-01-14 21:47:29 +00009612 NumPositiveBits = std::max(NumPositiveBits,
9613 (unsigned)InitVal.getActiveBits());
Chris Lattnerb8a501c2007-08-28 06:15:15 +00009614 else
Chris Lattner49f980c2008-01-14 21:47:29 +00009615 NumNegativeBits = std::max(NumNegativeBits,
9616 (unsigned)InitVal.getMinSignedBits());
Chris Lattner4ef40012007-06-11 01:28:17 +00009617
Chris Lattnerb8a501c2007-08-28 06:15:15 +00009618 // Keep track of whether every enum element has type int (very commmon).
9619 if (AllElementsInt)
Mike Stump11289f42009-09-09 15:08:12 +00009620 AllElementsInt = ECD->getType() == Context.IntTy;
Chris Lattnerc1915e22007-01-25 07:29:02 +00009621 }
Mike Stump11289f42009-09-09 15:08:12 +00009622
Chris Lattnerb8a501c2007-08-28 06:15:15 +00009623 // Figure out the type that should be used for this enum.
Chris Lattnerb8a501c2007-08-28 06:15:15 +00009624 QualType BestType;
Chris Lattner3a370bf2007-08-29 17:31:48 +00009625 unsigned BestWidth;
Edward O'Callaghanc69169d2009-08-08 14:36:57 +00009626
John McCall56774992009-12-09 09:09:27 +00009627 // C++0x N3000 [conv.prom]p3:
9628 // An rvalue of an unscoped enumeration type whose underlying
9629 // type is not fixed can be converted to an rvalue of the first
9630 // of the following types that can represent all the values of
9631 // the enumeration: int, unsigned int, long int, unsigned long
9632 // int, long long int, or unsigned long long int.
9633 // C99 6.4.4.3p2:
9634 // An identifier declared as an enumeration constant has type int.
9635 // The C99 rule is modified by a gcc extension
9636 QualType BestPromotionType;
9637
Edward O'Callaghanc69169d2009-08-08 14:36:57 +00009638 bool Packed = Enum->getAttr<PackedAttr>() ? true : false;
Argyrios Kyrtzidis74825bc2010-10-08 00:25:19 +00009639 // -fshort-enums is the equivalent to specifying the packed attribute on all
9640 // enum definitions.
9641 if (LangOpts.ShortEnums)
9642 Packed = true;
Edward O'Callaghanc69169d2009-08-08 14:36:57 +00009643
Douglas Gregor0bf31402010-10-08 23:50:27 +00009644 if (Enum->isFixed()) {
9645 BestType = BestPromotionType = Enum->getIntegerType();
Duncan Sands38b918c2010-10-12 14:07:59 +00009646 // We don't need to set BestWidth, because BestType is going to be the type
9647 // of the enumerators, but we do anyway because otherwise some compilers
9648 // warn that it might be used uninitialized.
9649 BestWidth = CharWidth;
Douglas Gregor0bf31402010-10-08 23:50:27 +00009650 }
9651 else if (NumNegativeBits) {
Mike Stump11289f42009-09-09 15:08:12 +00009652 // If there is a negative value, figure out the smallest integer type (of
Chris Lattnerb8a501c2007-08-28 06:15:15 +00009653 // int/long/longlong) that fits.
Edward O'Callaghanc69169d2009-08-08 14:36:57 +00009654 // If it's packed, check also if it fits a char or a short.
9655 if (Packed && NumNegativeBits <= CharWidth && NumPositiveBits < CharWidth) {
John McCall56774992009-12-09 09:09:27 +00009656 BestType = Context.SignedCharTy;
9657 BestWidth = CharWidth;
Mike Stump11289f42009-09-09 15:08:12 +00009658 } else if (Packed && NumNegativeBits <= ShortWidth &&
Edward O'Callaghanc69169d2009-08-08 14:36:57 +00009659 NumPositiveBits < ShortWidth) {
John McCall56774992009-12-09 09:09:27 +00009660 BestType = Context.ShortTy;
9661 BestWidth = ShortWidth;
9662 } else if (NumNegativeBits <= IntWidth && NumPositiveBits < IntWidth) {
Chris Lattnerb8a501c2007-08-28 06:15:15 +00009663 BestType = Context.IntTy;
Chris Lattner3a370bf2007-08-29 17:31:48 +00009664 BestWidth = IntWidth;
9665 } else {
Douglas Gregore8bbc122011-09-02 00:18:52 +00009666 BestWidth = Context.getTargetInfo().getLongWidth();
Mike Stump11289f42009-09-09 15:08:12 +00009667
John McCall56774992009-12-09 09:09:27 +00009668 if (NumNegativeBits <= BestWidth && NumPositiveBits < BestWidth) {
Chris Lattnerb8a501c2007-08-28 06:15:15 +00009669 BestType = Context.LongTy;
John McCall56774992009-12-09 09:09:27 +00009670 } else {
Douglas Gregore8bbc122011-09-02 00:18:52 +00009671 BestWidth = Context.getTargetInfo().getLongLongWidth();
Mike Stump11289f42009-09-09 15:08:12 +00009672
Chris Lattner3a370bf2007-08-29 17:31:48 +00009673 if (NumNegativeBits > BestWidth || NumPositiveBits >= BestWidth)
Chris Lattnerb8a501c2007-08-28 06:15:15 +00009674 Diag(Enum->getLocation(), diag::warn_enum_too_large);
9675 BestType = Context.LongLongTy;
9676 }
9677 }
John McCall56774992009-12-09 09:09:27 +00009678 BestPromotionType = (BestWidth <= IntWidth ? Context.IntTy : BestType);
Chris Lattnerb8a501c2007-08-28 06:15:15 +00009679 } else {
Douglas Gregora71cc152010-02-02 20:10:50 +00009680 // If there is no negative value, figure out the smallest type that fits
9681 // all of the enumerator values.
Edward O'Callaghanc69169d2009-08-08 14:36:57 +00009682 // If it's packed, check also if it fits a char or a short.
9683 if (Packed && NumPositiveBits <= CharWidth) {
John McCall56774992009-12-09 09:09:27 +00009684 BestType = Context.UnsignedCharTy;
9685 BestPromotionType = Context.IntTy;
9686 BestWidth = CharWidth;
Edward O'Callaghanc69169d2009-08-08 14:36:57 +00009687 } else if (Packed && NumPositiveBits <= ShortWidth) {
John McCall56774992009-12-09 09:09:27 +00009688 BestType = Context.UnsignedShortTy;
9689 BestPromotionType = Context.IntTy;
9690 BestWidth = ShortWidth;
9691 } else if (NumPositiveBits <= IntWidth) {
Chris Lattnerb8a501c2007-08-28 06:15:15 +00009692 BestType = Context.UnsignedIntTy;
Chris Lattner3a370bf2007-08-29 17:31:48 +00009693 BestWidth = IntWidth;
Douglas Gregora71cc152010-02-02 20:10:50 +00009694 BestPromotionType
9695 = (NumPositiveBits == BestWidth || !getLangOptions().CPlusPlus)
9696 ? Context.UnsignedIntTy : Context.IntTy;
Chris Lattner3a370bf2007-08-29 17:31:48 +00009697 } else if (NumPositiveBits <=
Douglas Gregore8bbc122011-09-02 00:18:52 +00009698 (BestWidth = Context.getTargetInfo().getLongWidth())) {
Chris Lattnerb8a501c2007-08-28 06:15:15 +00009699 BestType = Context.UnsignedLongTy;
Douglas Gregora71cc152010-02-02 20:10:50 +00009700 BestPromotionType
9701 = (NumPositiveBits == BestWidth || !getLangOptions().CPlusPlus)
9702 ? Context.UnsignedLongTy : Context.LongTy;
Chris Lattner37e05872008-03-05 18:54:05 +00009703 } else {
Douglas Gregore8bbc122011-09-02 00:18:52 +00009704 BestWidth = Context.getTargetInfo().getLongLongWidth();
Chris Lattner3a370bf2007-08-29 17:31:48 +00009705 assert(NumPositiveBits <= BestWidth &&
Chris Lattnerb8a501c2007-08-28 06:15:15 +00009706 "How could an initializer get larger than ULL?");
9707 BestType = Context.UnsignedLongLongTy;
Douglas Gregora71cc152010-02-02 20:10:50 +00009708 BestPromotionType
9709 = (NumPositiveBits == BestWidth || !getLangOptions().CPlusPlus)
9710 ? Context.UnsignedLongLongTy : Context.LongLongTy;
Chris Lattnerb8a501c2007-08-28 06:15:15 +00009711 }
9712 }
Mike Stump11289f42009-09-09 15:08:12 +00009713
Chris Lattner3a370bf2007-08-29 17:31:48 +00009714 // Loop over all of the enumerator constants, changing their types to match
9715 // the type of the enum if needed.
9716 for (unsigned i = 0; i != NumElements; ++i) {
John McCall48871652010-08-21 09:40:31 +00009717 EnumConstantDecl *ECD = cast_or_null<EnumConstantDecl>(Elements[i]);
Chris Lattner3a370bf2007-08-29 17:31:48 +00009718 if (!ECD) continue; // Already issued a diagnostic.
9719
9720 // Standard C says the enumerators have int type, but we allow, as an
9721 // extension, the enumerators to be larger than int size. If each
9722 // enumerator value fits in an int, type it as an int, otherwise type it the
9723 // same as the enumerator decl itself. This means that in "enum { X = 1U }"
9724 // that X has type 'int', not 'unsigned'.
Chris Lattner3a370bf2007-08-29 17:31:48 +00009725
9726 // Determine whether the value fits into an int.
9727 llvm::APSInt InitVal = ECD->getInitVal();
Chris Lattner3a370bf2007-08-29 17:31:48 +00009728
9729 // If it fits into an integer type, force it. Otherwise force it to match
9730 // the enum decl type.
9731 QualType NewTy;
9732 unsigned NewWidth;
9733 bool NewSign;
Douglas Gregor6791a0d2010-02-01 23:36:03 +00009734 if (!getLangOptions().CPlusPlus &&
9735 isRepresentableIntegerValue(Context, InitVal, Context.IntTy)) {
Chris Lattner3a370bf2007-08-29 17:31:48 +00009736 NewTy = Context.IntTy;
9737 NewWidth = IntWidth;
9738 NewSign = true;
9739 } else if (ECD->getType() == BestType) {
9740 // Already the right type!
Douglas Gregor1d248c52008-12-12 02:00:36 +00009741 if (getLangOptions().CPlusPlus)
9742 // C++ [dcl.enum]p4: Following the closing brace of an
9743 // enum-specifier, each enumerator has the type of its
Mike Stump11289f42009-09-09 15:08:12 +00009744 // enumeration.
Douglas Gregor1d248c52008-12-12 02:00:36 +00009745 ECD->setType(EnumType);
Chris Lattner3a370bf2007-08-29 17:31:48 +00009746 continue;
9747 } else {
9748 NewTy = BestType;
9749 NewWidth = BestWidth;
Douglas Gregor6ab2fa82011-05-20 16:38:50 +00009750 NewSign = BestType->isSignedIntegerOrEnumerationType();
Chris Lattner3a370bf2007-08-29 17:31:48 +00009751 }
9752
9753 // Adjust the APSInt value.
Jay Foad6d4db0c2010-12-07 08:25:34 +00009754 InitVal = InitVal.extOrTrunc(NewWidth);
Chris Lattner3a370bf2007-08-29 17:31:48 +00009755 InitVal.setIsSigned(NewSign);
9756 ECD->setInitVal(InitVal);
Mike Stump11289f42009-09-09 15:08:12 +00009757
Chris Lattner3a370bf2007-08-29 17:31:48 +00009758 // Adjust the Expr initializer and type.
Abramo Bagnara77815432010-12-17 15:49:53 +00009759 if (ECD->getInitExpr() &&
Nick Lewycky0bdf13e2011-07-02 02:05:12 +00009760 !Context.hasSameType(NewTy, ECD->getInitExpr()->getType()))
John McCallcf142162010-08-07 06:22:56 +00009761 ECD->setInitExpr(ImplicitCastExpr::Create(Context, NewTy,
John McCalle3027922010-08-25 11:45:40 +00009762 CK_IntegralCast,
John McCallcf142162010-08-07 06:22:56 +00009763 ECD->getInitExpr(),
9764 /*base paths*/ 0,
John McCall2536c6d2010-08-25 10:28:54 +00009765 VK_RValue));
Douglas Gregor1d248c52008-12-12 02:00:36 +00009766 if (getLangOptions().CPlusPlus)
9767 // C++ [dcl.enum]p4: Following the closing brace of an
9768 // enum-specifier, each enumerator has the type of its
Mike Stump11289f42009-09-09 15:08:12 +00009769 // enumeration.
Douglas Gregor1d248c52008-12-12 02:00:36 +00009770 ECD->setType(EnumType);
9771 else
9772 ECD->setType(NewTy);
Chris Lattner3a370bf2007-08-29 17:31:48 +00009773 }
Mike Stump11289f42009-09-09 15:08:12 +00009774
John McCall9aa35be2010-05-06 08:49:23 +00009775 Enum->completeDefinition(BestType, BestPromotionType,
9776 NumPositiveBits, NumNegativeBits);
Chris Lattnerc1915e22007-01-25 07:29:02 +00009777}
Chris Lattner1300fb92007-01-23 23:42:53 +00009778
Abramo Bagnara348823a2011-03-03 14:20:18 +00009779Decl *Sema::ActOnFileScopeAsmDecl(Expr *expr,
9780 SourceLocation StartLoc,
9781 SourceLocation EndLoc) {
John McCallb268a282010-08-23 23:25:46 +00009782 StringLiteral *AsmString = cast<StringLiteral>(expr);
Sebastian Redlc675bab2008-12-13 16:23:55 +00009783
Douglas Gregor278f52e2009-05-30 00:08:05 +00009784 FileScopeAsmDecl *New = FileScopeAsmDecl::Create(Context, CurContext,
Abramo Bagnara348823a2011-03-03 14:20:18 +00009785 AsmString, StartLoc,
9786 EndLoc);
Argyrios Kyrtzidiscfbfe782009-06-30 02:36:12 +00009787 CurContext->addDecl(New);
John McCall48871652010-08-21 09:40:31 +00009788 return New;
Anders Carlsson5c6c0592008-02-08 00:33:21 +00009789}
Eli Friedman5ed51982009-06-05 02:44:36 +00009790
Douglas Gregor08142532011-08-26 23:56:07 +00009791DeclResult Sema::ActOnModuleImport(SourceLocation ImportLoc,
9792 IdentifierInfo &ModuleName,
9793 SourceLocation ModuleNameLoc) {
9794 ModuleKey Module = PP.getModuleLoader().loadModule(ImportLoc,
9795 ModuleName, ModuleNameLoc);
9796 if (!Module)
9797 return true;
9798
9799 // FIXME: Actually create a declaration to describe the module import.
9800 (void)Module;
9801 return DeclResult((Decl *)0);
9802}
9803
Douglas Gregor2820e692011-09-09 19:05:14 +00009804void
9805Sema::diagnoseModulePrivateRedeclaration(NamedDecl *New, NamedDecl *Old,
9806 SourceLocation ModulePrivateKeyword) {
9807 assert(!Old->isModulePrivate() && "Old is module-private!");
9808
9809 Diag(New->getLocation(), diag::err_module_private_follows_public)
9810 << New->getDeclName() << SourceRange(ModulePrivateKeyword);
9811 Diag(Old->getLocation(), diag::note_previous_declaration)
9812 << Old->getDeclName();
9813
9814 // Drop the __module_private__ from the new declaration, since it's invalid.
9815 New->setModulePrivate(false);
9816}
9817
Eli Friedman5ed51982009-06-05 02:44:36 +00009818void Sema::ActOnPragmaWeakID(IdentifierInfo* Name,
9819 SourceLocation PragmaLoc,
9820 SourceLocation NameLoc) {
Douglas Gregorb2ccf012010-04-15 22:33:43 +00009821 Decl *PrevDecl = LookupSingleName(TUScope, Name, NameLoc, LookupOrdinaryName);
Eli Friedman5ed51982009-06-05 02:44:36 +00009822
Eli Friedman5ed51982009-06-05 02:44:36 +00009823 if (PrevDecl) {
Alexis Huntdcfba7b2010-08-18 23:23:40 +00009824 PrevDecl->addAttr(::new (Context) WeakAttr(PragmaLoc, Context));
Ryan Flynn7d470f32009-07-30 03:15:39 +00009825 } else {
9826 (void)WeakUndeclaredIdentifiers.insert(
9827 std::pair<IdentifierInfo*,WeakInfo>
9828 (Name, WeakInfo((IdentifierInfo*)0, NameLoc)));
Eli Friedman5ed51982009-06-05 02:44:36 +00009829 }
Eli Friedman5ed51982009-06-05 02:44:36 +00009830}
9831
9832void Sema::ActOnPragmaWeakAlias(IdentifierInfo* Name,
9833 IdentifierInfo* AliasName,
9834 SourceLocation PragmaLoc,
9835 SourceLocation NameLoc,
9836 SourceLocation AliasNameLoc) {
Douglas Gregorb2ccf012010-04-15 22:33:43 +00009837 Decl *PrevDecl = LookupSingleName(TUScope, AliasName, AliasNameLoc,
9838 LookupOrdinaryName);
Ryan Flynn7d470f32009-07-30 03:15:39 +00009839 WeakInfo W = WeakInfo(Name, NameLoc);
Eli Friedman5ed51982009-06-05 02:44:36 +00009840
Eli Friedman5ed51982009-06-05 02:44:36 +00009841 if (PrevDecl) {
Ryan Flynn7d470f32009-07-30 03:15:39 +00009842 if (!PrevDecl->hasAttr<AliasAttr>())
9843 if (NamedDecl *ND = dyn_cast<NamedDecl>(PrevDecl))
Ryan Flynnd963a492009-07-31 02:52:19 +00009844 DeclApplyPragmaWeak(TUScope, ND, W);
Ryan Flynn7d470f32009-07-30 03:15:39 +00009845 } else {
9846 (void)WeakUndeclaredIdentifiers.insert(
9847 std::pair<IdentifierInfo*,WeakInfo>(AliasName, W));
Eli Friedman5ed51982009-06-05 02:44:36 +00009848 }
Eli Friedman5ed51982009-06-05 02:44:36 +00009849}
Fariborz Jahanian8d382dc2011-08-22 15:54:49 +00009850
9851Decl *Sema::getObjCDeclContext() const {
9852 return (dyn_cast_or_null<ObjCContainerDecl>(CurContext));
9853}
Argyrios Kyrtzidisc281c962011-10-06 23:23:27 +00009854
9855AvailabilityResult Sema::getCurContextAvailability() const {
9856 const Decl *D = cast<Decl>(getCurLexicalContext());
9857 // A category implicitly has the availability of the interface.
9858 if (const ObjCCategoryDecl *CatD = dyn_cast<ObjCCategoryDecl>(D))
9859 D = CatD->getClassInterface();
9860
9861 return D->getAvailability();
9862}