blob: bce0a3744603dcbee3aba801173d68107ec5aaec [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 Gregor844cb502011-03-01 18:12:44 +000015#include "TypeLocBuilder.h"
Chris Lattner622c1932008-02-06 00:51:33 +000016#include "clang/AST/ASTConsumer.h"
Chris Lattner5c5fbcc2006-12-03 08:41:30 +000017#include "clang/AST/ASTContext.h"
Faisal Vali2b391ab2013-09-26 19:54:12 +000018#include "clang/AST/ASTLambda.h"
Douglas Gregor36d1b142009-10-06 17:59:45 +000019#include "clang/AST/CXXInheritance.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000020#include "clang/AST/CharUnits.h"
Dmitri Gribenkof26054f2012-07-11 21:38:39 +000021#include "clang/AST/CommentDiagnostic.h"
John McCall28a0cf72010-08-25 07:42:41 +000022#include "clang/AST/DeclCXX.h"
John McCallde6836a2010-08-24 07:21:54 +000023#include "clang/AST/DeclObjC.h"
Douglas Gregorded2d7b2009-02-04 19:02:06 +000024#include "clang/AST/DeclTemplate.h"
Chandler Carruth33bf3e72011-03-27 09:46:56 +000025#include "clang/AST/EvaluatedExprVisitor.h"
Chris Lattner2c6fcf52008-06-26 18:38:35 +000026#include "clang/AST/ExprCXX.h"
Sebastian Redla7b98a72009-04-26 20:35:05 +000027#include "clang/AST/StmtCXX.h"
Alp Tokerb6cc5922014-05-03 03:45:55 +000028#include "clang/Basic/Builtins.h"
Anders Carlssond624e162009-08-26 23:45:07 +000029#include "clang/Basic/PartialDiagnostic.h"
Steve Naroffe101f952008-01-30 23:46:05 +000030#include "clang/Basic/SourceManager.h"
Anders Carlssond624e162009-08-26 23:45:07 +000031#include "clang/Basic/TargetInfo.h"
Alp Tokerb6cc5922014-05-03 03:45:55 +000032#include "clang/Lex/HeaderSearch.h" // TODO: Sema shouldn't depend on Lex
33#include "clang/Lex/Lexer.h" // TODO: Extract static functions to fix layering.
34#include "clang/Lex/ModuleLoader.h" // TODO: Sema shouldn't depend on Lex
35#include "clang/Lex/Preprocessor.h" // Included for isCodeCompletionEnabled()
Chandler Carruth3a022472012-12-04 09:13:33 +000036#include "clang/Parse/ParseDiagnostic.h"
37#include "clang/Sema/CXXFieldCollector.h"
38#include "clang/Sema/DeclSpec.h"
39#include "clang/Sema/DelayedDiagnostic.h"
40#include "clang/Sema/Initialization.h"
41#include "clang/Sema/Lookup.h"
42#include "clang/Sema/ParsedTemplate.h"
43#include "clang/Sema/Scope.h"
44#include "clang/Sema/ScopeInfo.h"
Faisal Valia17d19f2013-11-07 05:17:06 +000045#include "clang/Sema/Template.h"
Benjamin Kramer49038022012-02-04 13:45:25 +000046#include "llvm/ADT/SmallString.h"
John McCall0e21fcc2009-12-24 09:58:38 +000047#include "llvm/ADT/Triple.h"
Douglas Gregor8b9ccca2008-12-23 21:05:05 +000048#include <algorithm>
Douglas Gregor56fbc372009-09-28 21:14:19 +000049#include <cstring>
Douglas Gregor8b9ccca2008-12-23 21:05:05 +000050#include <functional>
Chris Lattner697e5d62006-11-09 06:32:27 +000051using namespace clang;
John McCallaab3e412010-08-25 08:40:02 +000052using namespace sema;
Chris Lattner697e5d62006-11-09 06:32:27 +000053
Richard Smithcd1c0552011-07-01 19:46:12 +000054Sema::DeclGroupPtrTy Sema::ConvertDeclToDeclGroup(Decl *Ptr, Decl *OwnedType) {
55 if (OwnedType) {
56 Decl *Group[2] = { OwnedType, Ptr };
57 return DeclGroupPtrTy::make(DeclGroupRef::Create(Context, Group, 2));
58 }
59
John McCall48871652010-08-21 09:40:31 +000060 return DeclGroupPtrTy::make(DeclGroupRef(Ptr));
Chris Lattner5bbb3c82009-03-29 16:50:03 +000061}
62
Kaelyn Uhrainb1378402012-01-18 21:41:41 +000063namespace {
64
65class TypeNameValidatorCCC : public CorrectionCandidateCallback {
66 public:
Kaelyn Uhrain67b44c92014-02-13 20:14:07 +000067 TypeNameValidatorCCC(bool AllowInvalid, bool WantClass=false,
68 bool AllowTemplates=false)
69 : AllowInvalidDecl(AllowInvalid), WantClassName(WantClass),
70 AllowClassTemplates(AllowTemplates) {
Kaelyn Uhrainb1378402012-01-18 21:41:41 +000071 WantExpressionKeywords = false;
72 WantCXXNamedCasts = false;
73 WantRemainingKeywords = false;
74 }
75
Craig Toppere14c0f82014-03-12 04:55:44 +000076 bool ValidateCandidate(const TypoCorrection &candidate) override {
Kaelyn Uhrain67b44c92014-02-13 20:14:07 +000077 if (NamedDecl *ND = candidate.getCorrectionDecl()) {
78 bool IsType = isa<TypeDecl>(ND) || isa<ObjCInterfaceDecl>(ND);
79 bool AllowedTemplate = AllowClassTemplates && isa<ClassTemplateDecl>(ND);
80 return (IsType || AllowedTemplate) &&
81 (AllowInvalidDecl || !ND->isInvalidDecl());
82 }
83 return !WantClassName && candidate.isKeyword();
Kaelyn Uhrainb1378402012-01-18 21:41:41 +000084 }
85
86 private:
87 bool AllowInvalidDecl;
Kaelyn Uhrain9cb8e9f2012-06-22 23:37:05 +000088 bool WantClassName;
Kaelyn Uhrain67b44c92014-02-13 20:14:07 +000089 bool AllowClassTemplates;
Kaelyn Uhrainb1378402012-01-18 21:41:41 +000090};
91
Alexander Kornienkoab9db512015-06-22 23:07:51 +000092}
Kaelyn Uhrainb1378402012-01-18 21:41:41 +000093
Kaelyn Uhrain237c7d32012-06-15 23:45:51 +000094/// \brief Determine whether the token kind starts a simple-type-specifier.
95bool Sema::isSimpleTypeSpecifier(tok::TokenKind Kind) const {
96 switch (Kind) {
97 // FIXME: Take into account the current language when deciding whether a
98 // token kind is a valid type specifier
99 case tok::kw_short:
100 case tok::kw_long:
101 case tok::kw___int64:
102 case tok::kw___int128:
103 case tok::kw_signed:
104 case tok::kw_unsigned:
105 case tok::kw_void:
106 case tok::kw_char:
107 case tok::kw_int:
108 case tok::kw_half:
109 case tok::kw_float:
110 case tok::kw_double:
111 case tok::kw_wchar_t:
112 case tok::kw_bool:
113 case tok::kw___underlying_type:
114 return true;
115
116 case tok::annot_typename:
117 case tok::kw_char16_t:
118 case tok::kw_char32_t:
119 case tok::kw_typeof:
David Majnemera5e92552013-09-22 01:24:26 +0000120 case tok::annot_decltype:
Kaelyn Uhrain237c7d32012-06-15 23:45:51 +0000121 case tok::kw_decltype:
122 return getLangOpts().CPlusPlus;
123
124 default:
125 break;
126 }
127
128 return false;
129}
130
Alexey Bataev054829b2015-02-19 04:28:23 +0000131namespace {
132enum class UnqualifiedTypeNameLookupResult {
133 NotFound,
134 FoundNonType,
135 FoundType
136};
137} // namespace
138
139/// \brief Tries to perform unqualified lookup of the type decls in bases for
140/// dependent class.
141/// \return \a NotFound if no any decls is found, \a FoundNotType if found not a
142/// type decl, \a FoundType if only type decls are found.
143static UnqualifiedTypeNameLookupResult
144lookupUnqualifiedTypeNameInBase(Sema &S, const IdentifierInfo &II,
145 SourceLocation NameLoc,
146 const CXXRecordDecl *RD) {
147 if (!RD->hasDefinition())
148 return UnqualifiedTypeNameLookupResult::NotFound;
149 // Look for type decls in base classes.
150 UnqualifiedTypeNameLookupResult FoundTypeDecl =
151 UnqualifiedTypeNameLookupResult::NotFound;
152 for (const auto &Base : RD->bases()) {
153 const CXXRecordDecl *BaseRD = nullptr;
154 if (auto *BaseTT = Base.getType()->getAs<TagType>())
155 BaseRD = BaseTT->getAsCXXRecordDecl();
156 else if (auto *TST = Base.getType()->getAs<TemplateSpecializationType>()) {
157 // Look for type decls in dependent base classes that have known primary
158 // templates.
159 if (!TST || !TST->isDependentType())
160 continue;
161 auto *TD = TST->getTemplateName().getAsTemplateDecl();
162 if (!TD)
163 continue;
164 auto *BasePrimaryTemplate =
165 dyn_cast_or_null<CXXRecordDecl>(TD->getTemplatedDecl());
166 if (!BasePrimaryTemplate)
167 continue;
168 BaseRD = BasePrimaryTemplate;
169 }
170 if (BaseRD) {
171 for (NamedDecl *ND : BaseRD->lookup(&II)) {
172 if (!isa<TypeDecl>(ND))
173 return UnqualifiedTypeNameLookupResult::FoundNonType;
174 FoundTypeDecl = UnqualifiedTypeNameLookupResult::FoundType;
175 }
176 if (FoundTypeDecl == UnqualifiedTypeNameLookupResult::NotFound) {
177 switch (lookupUnqualifiedTypeNameInBase(S, II, NameLoc, BaseRD)) {
178 case UnqualifiedTypeNameLookupResult::FoundNonType:
179 return UnqualifiedTypeNameLookupResult::FoundNonType;
180 case UnqualifiedTypeNameLookupResult::FoundType:
181 FoundTypeDecl = UnqualifiedTypeNameLookupResult::FoundType;
182 break;
183 case UnqualifiedTypeNameLookupResult::NotFound:
184 break;
185 }
186 }
187 }
188 }
189
190 return FoundTypeDecl;
191}
192
Reid Kleckner1ba38f82014-07-08 20:05:48 +0000193static ParsedType recoverFromTypeInKnownDependentBase(Sema &S,
194 const IdentifierInfo &II,
195 SourceLocation NameLoc) {
Alexey Bataev054829b2015-02-19 04:28:23 +0000196 // Lookup in the parent class template context, if any.
Reid Klecknerfd068272014-07-08 21:35:03 +0000197 const CXXRecordDecl *RD = nullptr;
Alexey Bataev054829b2015-02-19 04:28:23 +0000198 UnqualifiedTypeNameLookupResult FoundTypeDecl =
199 UnqualifiedTypeNameLookupResult::NotFound;
200 for (DeclContext *DC = S.CurContext;
201 DC && FoundTypeDecl == UnqualifiedTypeNameLookupResult::NotFound;
202 DC = DC->getParent()) {
203 // Look for type decls in dependent base classes that have known primary
204 // templates.
Reid Klecknerfd068272014-07-08 21:35:03 +0000205 RD = dyn_cast<CXXRecordDecl>(DC);
206 if (RD && RD->getDescribedClassTemplate())
Alexey Bataev054829b2015-02-19 04:28:23 +0000207 FoundTypeDecl = lookupUnqualifiedTypeNameInBase(S, II, NameLoc, RD);
Reid Klecknerfd068272014-07-08 21:35:03 +0000208 }
Alexey Bataev054829b2015-02-19 04:28:23 +0000209 if (FoundTypeDecl != UnqualifiedTypeNameLookupResult::FoundType)
Reid Kleckner1ba38f82014-07-08 20:05:48 +0000210 return ParsedType();
211
212 // We found some types in dependent base classes. Recover as if the user
213 // wrote 'typename MyClass::II' instead of 'II'. We'll fully resolve the
214 // lookup during template instantiation.
215 S.Diag(NameLoc, diag::ext_found_via_dependent_bases_lookup) << &II;
216
217 ASTContext &Context = S.Context;
218 auto *NNS = NestedNameSpecifier::Create(Context, nullptr, false,
219 cast<Type>(Context.getRecordType(RD)));
220 QualType T = Context.getDependentNameType(ETK_Typename, NNS, &II);
221
222 CXXScopeSpec SS;
223 SS.MakeTrivial(Context, NNS, SourceRange(NameLoc));
224
225 TypeLocBuilder Builder;
226 DependentNameTypeLoc DepTL = Builder.push<DependentNameTypeLoc>(T);
227 DepTL.setNameLoc(NameLoc);
228 DepTL.setElaboratedKeywordLoc(SourceLocation());
229 DepTL.setQualifierLoc(SS.getWithLocInContext(Context));
230 return S.CreateParsedType(T, Builder.getTypeSourceInfo(Context, T));
231}
232
Douglas Gregorec6e1892009-02-04 19:16:12 +0000233/// \brief If the identifier refers to a type name within this scope,
234/// return the declaration of that type.
235///
236/// This routine performs ordinary name lookup of the identifier II
237/// within the given scope, with optional C++ scope specifier SS, to
Douglas Gregor9817f4a2009-02-09 15:09:02 +0000238/// determine whether the name refers to a type. If so, returns an
239/// opaque pointer (actually a QualType) corresponding to that
240/// type. Otherwise, returns NULL.
Dmitri Gribenko5267fdf2013-05-03 13:12:11 +0000241ParsedType Sema::getTypeName(const IdentifierInfo &II, SourceLocation NameLoc,
John McCallba7bf592010-08-24 05:47:05 +0000242 Scope *S, CXXScopeSpec *SS,
Fariborz Jahanian87967422011-02-08 18:05:59 +0000243 bool isClassName, bool HasTrailingDot,
Douglas Gregor844cb502011-03-01 18:12:44 +0000244 ParsedType ObjectTypePtr,
Abramo Bagnara4244b432012-01-27 08:46:19 +0000245 bool IsCtorOrDtorName,
Kaelyn Uhrain85308c62011-10-11 01:02:41 +0000246 bool WantNontrivialTypeSourceInfo,
247 IdentifierInfo **CorrectedII) {
Douglas Gregora25d65d2009-11-20 22:03:38 +0000248 // Determine where we will perform name lookup.
Craig Topperc3ec1492014-05-26 06:22:03 +0000249 DeclContext *LookupCtx = nullptr;
Douglas Gregora25d65d2009-11-20 22:03:38 +0000250 if (ObjectTypePtr) {
John McCallba7bf592010-08-24 05:47:05 +0000251 QualType ObjectType = ObjectTypePtr.get();
Douglas Gregora25d65d2009-11-20 22:03:38 +0000252 if (ObjectType->isRecordType())
253 LookupCtx = computeDeclContext(ObjectType);
Jeffrey Yasskin4e150f82010-04-07 23:29:58 +0000254 } else if (SS && SS->isNotEmpty()) {
Douglas Gregora25d65d2009-11-20 22:03:38 +0000255 LookupCtx = computeDeclContext(*SS, false);
256
257 if (!LookupCtx) {
258 if (isDependentScopeSpecifier(*SS)) {
259 // C++ [temp.res]p3:
260 // A qualified-id that refers to a type and in which the
261 // nested-name-specifier depends on a template-parameter (14.6.2)
262 // shall be prefixed by the keyword typename to indicate that the
263 // qualified-id denotes a type, forming an
264 // elaborated-type-specifier (7.1.5.3).
265 //
266 // We therefore do not perform any name lookup if the result would
267 // refer to a member of an unknown specialization.
Richard Smith23d55872012-04-02 01:30:27 +0000268 if (!isClassName && !IsCtorOrDtorName)
John McCallba7bf592010-08-24 05:47:05 +0000269 return ParsedType();
Douglas Gregora25d65d2009-11-20 22:03:38 +0000270
John McCallc392f372010-06-11 00:33:02 +0000271 // We know from the grammar that this name refers to a type,
272 // so build a dependent node to describe the type.
Douglas Gregor844cb502011-03-01 18:12:44 +0000273 if (WantNontrivialTypeSourceInfo)
274 return ActOnTypenameType(S, SourceLocation(), *SS, II, NameLoc).get();
275
276 NestedNameSpecifierLoc QualifierLoc = SS->getWithLocInContext(Context);
Nico Weberdfc59202014-05-03 22:07:35 +0000277 QualType T = CheckTypenameType(ETK_None, SourceLocation(), QualifierLoc,
278 II, NameLoc);
279 return ParsedType::make(T);
Douglas Gregora25d65d2009-11-20 22:03:38 +0000280 }
281
John McCallba7bf592010-08-24 05:47:05 +0000282 return ParsedType();
Douglas Gregora25d65d2009-11-20 22:03:38 +0000283 }
284
John McCall0b66eb32010-05-01 00:40:08 +0000285 if (!LookupCtx->isDependentContext() &&
286 RequireCompleteDeclContext(*SS, LookupCtx))
John McCallba7bf592010-08-24 05:47:05 +0000287 return ParsedType();
Douglas Gregor5e0962f2009-08-26 18:27:52 +0000288 }
Eli Friedman9025ec22009-12-21 01:42:38 +0000289
290 // FIXME: LookupNestedNameSpecifierName isn't the right kind of
291 // lookup for class-names.
292 LookupNameKind Kind = isClassName ? LookupNestedNameSpecifierName :
293 LookupOrdinaryName;
294 LookupResult Result(*this, &II, NameLoc, Kind);
Douglas Gregora25d65d2009-11-20 22:03:38 +0000295 if (LookupCtx) {
296 // Perform "qualified" name lookup into the declaration context we
297 // computed, which is either the type of the base of a member access
298 // expression or the declaration context associated with a prior
299 // nested-name-specifier.
300 LookupQualifiedName(Result, LookupCtx);
Douglas Gregorc9f9b862009-05-11 19:58:34 +0000301
Douglas Gregora25d65d2009-11-20 22:03:38 +0000302 if (ObjectTypePtr && Result.empty()) {
303 // C++ [basic.lookup.classref]p3:
304 // If the unqualified-id is ~type-name, the type-name is looked up
305 // in the context of the entire postfix-expression. If the type T of
306 // the object expression is of a class type C, the type-name is also
307 // looked up in the scope of class C. At least one of the lookups shall
308 // find a name that refers to (possibly cv-qualified) T.
309 LookupName(Result, S);
310 }
311 } else {
312 // Perform unqualified name lookup.
313 LookupName(Result, S);
Reid Kleckner1ba38f82014-07-08 20:05:48 +0000314
315 // For unqualified lookup in a class template in MSVC mode, look into
316 // dependent base classes where the primary class template is known.
317 if (Result.empty() && getLangOpts().MSVCCompat && (!SS || SS->isEmpty())) {
318 if (ParsedType TypeInBase =
319 recoverFromTypeInKnownDependentBase(*this, II, NameLoc))
320 return TypeInBase;
321 }
Douglas Gregora25d65d2009-11-20 22:03:38 +0000322 }
Craig Topperc3ec1492014-05-26 06:22:03 +0000323
324 NamedDecl *IIDecl = nullptr;
John McCall27b18f82009-11-17 02:14:36 +0000325 switch (Result.getResultKind()) {
Chris Lattnera3778332009-02-16 22:07:16 +0000326 case LookupResult::NotFound:
Douglas Gregord0d2ee02010-01-15 01:44:47 +0000327 case LookupResult::NotFoundInCurrentInstantiation:
Kaelyn Uhrain85308c62011-10-11 01:02:41 +0000328 if (CorrectedII) {
Kaelyn Takata89c881b2014-10-27 18:07:29 +0000329 TypoCorrection Correction = CorrectTypo(
330 Result.getLookupNameInfo(), Kind, S, SS,
331 llvm::make_unique<TypeNameValidatorCCC>(true, isClassName),
332 CTK_ErrorRecovery);
Kaelyn Uhrain85308c62011-10-11 01:02:41 +0000333 IdentifierInfo *NewII = Correction.getCorrectionAsIdentifierInfo();
334 TemplateTy Template;
335 bool MemberOfUnknownSpecialization;
336 UnqualifiedId TemplateName;
337 TemplateName.setIdentifier(NewII, NameLoc);
338 NestedNameSpecifier *NNS = Correction.getCorrectionSpecifier();
339 CXXScopeSpec NewSS, *NewSSPtr = SS;
340 if (SS && NNS) {
341 NewSS.MakeTrivial(Context, NNS, SourceRange(NameLoc));
342 NewSSPtr = &NewSS;
343 }
344 if (Correction && (NNS || NewII != &II) &&
345 // Ignore a correction to a template type as the to-be-corrected
346 // identifier is not a template (typo correction for template names
347 // is handled elsewhere).
David Blaikiebbafb8a2012-03-11 07:00:24 +0000348 !(getLangOpts().CPlusPlus && NewSSPtr &&
Kaelyn Uhrain85308c62011-10-11 01:02:41 +0000349 isTemplateName(S, *NewSSPtr, false, TemplateName, ParsedType(),
350 false, Template, MemberOfUnknownSpecialization))) {
351 ParsedType Ty = getTypeName(*NewII, NameLoc, S, NewSSPtr,
352 isClassName, HasTrailingDot, ObjectTypePtr,
Abramo Bagnara4244b432012-01-27 08:46:19 +0000353 IsCtorOrDtorName,
Kaelyn Uhrain85308c62011-10-11 01:02:41 +0000354 WantNontrivialTypeSourceInfo);
355 if (Ty) {
Richard Smithf9b15102013-08-17 00:46:16 +0000356 diagnoseTypo(Correction,
357 PDiag(diag::err_unknown_type_or_class_name_suggest)
358 << Result.getLookupName() << isClassName);
Kaelyn Uhrain85308c62011-10-11 01:02:41 +0000359 if (SS && NNS)
360 SS->MakeTrivial(Context, NNS, SourceRange(NameLoc));
361 *CorrectedII = NewII;
362 return Ty;
363 }
364 }
365 }
366 // If typo correction failed or was not performed, fall through
Chris Lattnera3778332009-02-16 22:07:16 +0000367 case LookupResult::FoundOverloaded:
John McCalle61f2ba2009-11-18 02:36:19 +0000368 case LookupResult::FoundUnresolvedValue:
John McCall58cc69d2010-01-27 01:50:18 +0000369 Result.suppressDiagnostics();
John McCallba7bf592010-08-24 05:47:05 +0000370 return ParsedType();
Douglas Gregor8a6be5e2009-02-04 17:00:24 +0000371
Chris Lattnere40853a2009-10-25 22:09:09 +0000372 case LookupResult::Ambiguous:
John McCall6538c932009-10-10 05:48:19 +0000373 // Recover from type-hiding ambiguities by hiding the type. We'll
374 // do the lookup again when looking for an object, and we can
375 // diagnose the error then. If we don't do this, then the error
376 // about hiding the type will be immediately followed by an error
377 // that only makes sense if the identifier was treated like a type.
John McCall27b18f82009-11-17 02:14:36 +0000378 if (Result.getAmbiguityKind() == LookupResult::AmbiguousTagHiding) {
379 Result.suppressDiagnostics();
John McCallba7bf592010-08-24 05:47:05 +0000380 return ParsedType();
John McCall27b18f82009-11-17 02:14:36 +0000381 }
John McCall6538c932009-10-10 05:48:19 +0000382
Douglas Gregorfe3d7d02009-04-01 21:51:26 +0000383 // Look to see if we have a type anywhere in the list of results.
384 for (LookupResult::iterator Res = Result.begin(), ResEnd = Result.end();
385 Res != ResEnd; ++Res) {
386 if (isa<TypeDecl>(*Res) || isa<ObjCInterfaceDecl>(*Res)) {
Mike Stump11289f42009-09-09 15:08:12 +0000387 if (!IIDecl ||
388 (*Res)->getLocation().getRawEncoding() <
Douglas Gregor712a3512009-04-13 15:14:38 +0000389 IIDecl->getLocation().getRawEncoding())
390 IIDecl = *Res;
Douglas Gregorfe3d7d02009-04-01 21:51:26 +0000391 }
392 }
393
394 if (!IIDecl) {
395 // None of the entities we found is a type, so there is no way
396 // to even assume that the result is a type. In this case, don't
397 // complain about the ambiguity. The parser will either try to
398 // perform this lookup again (e.g., as an object name), which
399 // will produce the ambiguity, or will complain that it expected
400 // a type name.
John McCall27b18f82009-11-17 02:14:36 +0000401 Result.suppressDiagnostics();
John McCallba7bf592010-08-24 05:47:05 +0000402 return ParsedType();
Douglas Gregorfe3d7d02009-04-01 21:51:26 +0000403 }
404
405 // We found a type within the ambiguous lookup; diagnose the
406 // ambiguity and then return that type. This might be the right
407 // answer, or it might not be, but it suppresses any attempt to
408 // perform the name lookup again.
Douglas Gregorfe3d7d02009-04-01 21:51:26 +0000409 break;
Douglas Gregor8a6be5e2009-02-04 17:00:24 +0000410
Chris Lattnera3778332009-02-16 22:07:16 +0000411 case LookupResult::Found:
John McCall9f3059a2009-10-09 21:13:30 +0000412 IIDecl = Result.getFoundDecl();
Chris Lattnera3778332009-02-16 22:07:16 +0000413 break;
Douglas Gregor960b5bc2009-01-15 00:26:24 +0000414 }
415
Chris Lattner17e15f12009-10-25 17:16:46 +0000416 assert(IIDecl && "Didn't find decl");
John McCall28a6aea2009-11-04 02:18:39 +0000417
Chris Lattner17e15f12009-10-25 17:16:46 +0000418 QualType T;
419 if (TypeDecl *TD = dyn_cast<TypeDecl>(IIDecl)) {
John McCall28a6aea2009-11-04 02:18:39 +0000420 DiagnoseUseOfDecl(IIDecl, NameLoc);
John McCall27b18f82009-11-17 02:14:36 +0000421
Nico Weberdfc59202014-05-03 22:07:35 +0000422 T = Context.getTypeDeclType(TD);
Nico Weber72889432014-09-06 01:25:55 +0000423 MarkAnyDeclReferenced(TD->getLocation(), TD, /*OdrUse=*/false);
Abramo Bagnara4244b432012-01-27 08:46:19 +0000424
425 // NOTE: avoid constructing an ElaboratedType(Loc) if this is a
426 // constructor or destructor name (in such a case, the scope specifier
427 // will be attached to the enclosing Expr or Decl node).
428 if (SS && SS->isNotEmpty() && !IsCtorOrDtorName) {
Douglas Gregor844cb502011-03-01 18:12:44 +0000429 if (WantNontrivialTypeSourceInfo) {
430 // Construct a type with type-source information.
431 TypeLocBuilder Builder;
432 Builder.pushTypeSpec(T).setNameLoc(NameLoc);
433
434 T = getElaboratedType(ETK_None, *SS, T);
435 ElaboratedTypeLoc ElabTL = Builder.push<ElaboratedTypeLoc>(T);
Abramo Bagnara9033e2b2012-02-06 19:09:27 +0000436 ElabTL.setElaboratedKeywordLoc(SourceLocation());
Douglas Gregor844cb502011-03-01 18:12:44 +0000437 ElabTL.setQualifierLoc(SS->getWithLocInContext(Context));
438 return CreateParsedType(T, Builder.getTypeSourceInfo(Context, T));
439 } else {
440 T = getElaboratedType(ETK_None, *SS, T);
441 }
442 }
Chris Lattner17e15f12009-10-25 17:16:46 +0000443 } else if (ObjCInterfaceDecl *IDecl = dyn_cast<ObjCInterfaceDecl>(IIDecl)) {
Fariborz Jahanian08891f52011-03-08 19:12:46 +0000444 (void)DiagnoseUseOfDecl(IDecl, NameLoc);
Fariborz Jahanian87967422011-02-08 18:05:59 +0000445 if (!HasTrailingDot)
446 T = Context.getObjCInterfaceType(IDecl);
447 }
448
449 if (T.isNull()) {
John McCall27b18f82009-11-17 02:14:36 +0000450 // If it's not plausibly a type, suppress diagnostics.
451 Result.suppressDiagnostics();
John McCallba7bf592010-08-24 05:47:05 +0000452 return ParsedType();
John McCall27b18f82009-11-17 02:14:36 +0000453 }
John McCallba7bf592010-08-24 05:47:05 +0000454 return ParsedType::make(T);
Chris Lattnere168f762006-11-10 05:29:30 +0000455}
456
Reid Klecknerdf6e4a02014-06-06 22:36:36 +0000457// Builds a fake NNS for the given decl context.
458static NestedNameSpecifier *
459synthesizeCurrentNestedNameSpecifier(ASTContext &Context, DeclContext *DC) {
460 for (;; DC = DC->getLookupParent()) {
461 DC = DC->getPrimaryContext();
462 auto *ND = dyn_cast<NamespaceDecl>(DC);
463 if (ND && !ND->isInline() && !ND->isAnonymousNamespace())
464 return NestedNameSpecifier::Create(Context, nullptr, ND);
465 else if (auto *RD = dyn_cast<CXXRecordDecl>(DC))
466 return NestedNameSpecifier::Create(Context, nullptr, RD->isTemplateDecl(),
467 RD->getTypeForDecl());
468 else if (isa<TranslationUnitDecl>(DC))
469 return NestedNameSpecifier::GlobalSpecifier(Context);
470 }
471 llvm_unreachable("something isn't in TU scope?");
472}
473
474ParsedType Sema::ActOnDelayedDefaultTemplateArg(const IdentifierInfo &II,
475 SourceLocation NameLoc) {
476 // Accepting an undeclared identifier as a default argument for a template
477 // type parameter is a Microsoft extension.
478 Diag(NameLoc, diag::ext_ms_delayed_template_argument) << &II;
479
480 // Build a fake DependentNameType that will perform lookup into CurContext at
481 // instantiation time. The name specifier isn't dependent, so template
482 // instantiation won't transform it. It will retry the lookup, however.
483 NestedNameSpecifier *NNS =
484 synthesizeCurrentNestedNameSpecifier(Context, CurContext);
485 QualType T = Context.getDependentNameType(ETK_None, NNS, &II);
486
487 // Build type location information. We synthesized the qualifier, so we have
488 // to build a fake NestedNameSpecifierLoc.
489 NestedNameSpecifierLocBuilder NNSLocBuilder;
490 NNSLocBuilder.MakeTrivial(Context, NNS, SourceRange(NameLoc));
491 NestedNameSpecifierLoc QualifierLoc = NNSLocBuilder.getWithLocInContext(Context);
492
493 TypeLocBuilder Builder;
494 DependentNameTypeLoc DepTL = Builder.push<DependentNameTypeLoc>(T);
495 DepTL.setNameLoc(NameLoc);
496 DepTL.setElaboratedKeywordLoc(SourceLocation());
497 DepTL.setQualifierLoc(QualifierLoc);
498 return CreateParsedType(T, Builder.getTypeSourceInfo(Context, T));
499}
500
Chris Lattnerffaa0e62009-04-12 21:49:30 +0000501/// isTagName() - This method is called *for error recovery purposes only*
502/// to determine if the specified name is a valid tag name ("struct foo"). If
503/// so, this returns the TST for the tag corresponding to it (TST_enum,
Joao Matosdc86f942012-08-31 18:45:21 +0000504/// TST_union, TST_struct, TST_interface, TST_class). This is used to diagnose
505/// cases in C where the user forgot to specify the tag.
Chris Lattnerffaa0e62009-04-12 21:49:30 +0000506DeclSpec::TST Sema::isTagName(IdentifierInfo &II, Scope *S) {
507 // Do a tag name lookup in this scope.
John McCall27b18f82009-11-17 02:14:36 +0000508 LookupResult R(*this, &II, SourceLocation(), LookupTagName);
509 LookupName(R, S, false);
510 R.suppressDiagnostics();
511 if (R.getResultKind() == LookupResult::Found)
John McCall67c00872009-12-02 08:25:40 +0000512 if (const TagDecl *TD = R.getAsSingle<TagDecl>()) {
Chris Lattnerffaa0e62009-04-12 21:49:30 +0000513 switch (TD->getTagKind()) {
Abramo Bagnara6150c882010-05-11 21:36:43 +0000514 case TTK_Struct: return DeclSpec::TST_struct;
Joao Matosdc86f942012-08-31 18:45:21 +0000515 case TTK_Interface: return DeclSpec::TST_interface;
Abramo Bagnara6150c882010-05-11 21:36:43 +0000516 case TTK_Union: return DeclSpec::TST_union;
517 case TTK_Class: return DeclSpec::TST_class;
518 case TTK_Enum: return DeclSpec::TST_enum;
Chris Lattnerffaa0e62009-04-12 21:49:30 +0000519 }
520 }
Mike Stump11289f42009-09-09 15:08:12 +0000521
Chris Lattnerffaa0e62009-04-12 21:49:30 +0000522 return DeclSpec::TST_unspecified;
523}
524
Francois Pichet48c946e2011-04-13 02:38:49 +0000525/// isMicrosoftMissingTypename - In Microsoft mode, within class scope,
526/// if a CXXScopeSpec's type is equal to the type of one of the base classes
527/// then downgrade the missing typename error to a warning.
528/// This is needed for MSVC compatibility; Example:
529/// @code
530/// template<class T> class A {
531/// public:
532/// typedef int TYPE;
533/// };
534/// template<class T> class B : public A<T> {
535/// public:
536/// A<T>::TYPE a; // no typename required because A<T> is a base class.
537/// };
538/// @endcode
Francois Pichet9a57fb52011-10-11 01:50:09 +0000539bool Sema::isMicrosoftMissingTypename(const CXXScopeSpec *SS, Scope *S) {
Francois Pichet48c946e2011-04-13 02:38:49 +0000540 if (CurContext->isRecord()) {
Nikola Smiljanic67860242014-09-26 00:28:20 +0000541 if (SS->getScopeRep()->getKind() == NestedNameSpecifier::Super)
542 return true;
543
Francois Pichetefc283c2011-04-13 02:44:57 +0000544 const Type *Ty = SS->getScopeRep()->getAsType();
Francois Pichet48c946e2011-04-13 02:38:49 +0000545
546 CXXRecordDecl *RD = cast<CXXRecordDecl>(CurContext);
Aaron Ballman574705e2014-03-13 15:41:46 +0000547 for (const auto &Base : RD->bases())
548 if (Context.hasSameUnqualifiedType(QualType(Ty, 1), Base.getType()))
Francois Pichet48c946e2011-04-13 02:38:49 +0000549 return true;
Francois Pichet9a57fb52011-10-11 01:50:09 +0000550 return S->isFunctionPrototypeScope();
Francois Pichet48c946e2011-04-13 02:38:49 +0000551 }
Francois Pichet9a57fb52011-10-11 01:50:09 +0000552 return CurContext->isFunctionOrMethod() || S->isFunctionPrototypeScope();
Francois Pichet48c946e2011-04-13 02:38:49 +0000553}
554
Reid Klecknerc05ca5e2014-06-19 01:23:22 +0000555void Sema::DiagnoseUnknownTypeName(IdentifierInfo *&II,
Douglas Gregor15e56022009-10-13 23:27:22 +0000556 SourceLocation IILoc,
557 Scope *S,
Jeffrey Yasskinc76498d2010-04-08 16:38:48 +0000558 CXXScopeSpec *SS,
Kaelyn Uhrain67b44c92014-02-13 20:14:07 +0000559 ParsedType &SuggestedType,
560 bool AllowClassTemplates) {
Douglas Gregor15e56022009-10-13 23:27:22 +0000561 // We don't have anything to suggest (yet).
John McCallba7bf592010-08-24 05:47:05 +0000562 SuggestedType = ParsedType();
Douglas Gregor15e56022009-10-13 23:27:22 +0000563
Douglas Gregor2d435302009-12-30 17:04:44 +0000564 // There may have been a typo in the name of the type. Look up typo
565 // results, in case we have something that we can suggest.
Kaelyn Takata89c881b2014-10-27 18:07:29 +0000566 if (TypoCorrection Corrected =
567 CorrectTypo(DeclarationNameInfo(II, IILoc), LookupOrdinaryName, S, SS,
568 llvm::make_unique<TypeNameValidatorCCC>(
569 false, false, AllowClassTemplates),
570 CTK_ErrorRecovery)) {
Douglas Gregorc2fa1692011-06-28 16:20:02 +0000571 if (Corrected.isKeyword()) {
572 // We corrected to a keyword.
Richard Smithf9b15102013-08-17 00:46:16 +0000573 diagnoseTypo(Corrected, PDiag(diag::err_unknown_typename_suggest) << II);
574 II = Corrected.getCorrectionAsIdentifierInfo();
Douglas Gregorc2fa1692011-06-28 16:20:02 +0000575 } else {
Kaelyn Uhrainb1378402012-01-18 21:41:41 +0000576 // We found a similarly-named type or interface; suggest that.
Kaelyn Uhrain10413a42013-07-02 23:47:44 +0000577 if (!SS || !SS->isSet()) {
Richard Smithf9b15102013-08-17 00:46:16 +0000578 diagnoseTypo(Corrected,
579 PDiag(diag::err_unknown_typename_suggest) << II);
Kaelyn Uhrain10413a42013-07-02 23:47:44 +0000580 } else if (DeclContext *DC = computeDeclContext(*SS, false)) {
Richard Smithf9b15102013-08-17 00:46:16 +0000581 std::string CorrectedStr(Corrected.getAsString(getLangOpts()));
582 bool DroppedSpecifier = Corrected.WillReplaceSpecifier() &&
Kaelyn Uhrain10413a42013-07-02 23:47:44 +0000583 II->getName().equals(CorrectedStr);
Richard Smithf9b15102013-08-17 00:46:16 +0000584 diagnoseTypo(Corrected,
585 PDiag(diag::err_unknown_nested_typename_suggest)
586 << II << DC << DroppedSpecifier << SS->getRange());
587 } else {
Kaelyn Uhrainb1378402012-01-18 21:41:41 +0000588 llvm_unreachable("could not have corrected a typo here");
Kaelyn Uhrain10413a42013-07-02 23:47:44 +0000589 }
Douglas Gregor2d435302009-12-30 17:04:44 +0000590
Kaelyn Uhrainf7343012013-09-26 21:13:05 +0000591 CXXScopeSpec tmpSS;
592 if (Corrected.getCorrectionSpecifier())
593 tmpSS.MakeTrivial(Context, Corrected.getCorrectionSpecifier(),
594 SourceRange(IILoc));
Richard Smithf9b15102013-08-17 00:46:16 +0000595 SuggestedType = getTypeName(*Corrected.getCorrectionAsIdentifierInfo(),
Kaelyn Uhrainf7343012013-09-26 21:13:05 +0000596 IILoc, S, tmpSS.isSet() ? &tmpSS : SS, false,
597 false, ParsedType(),
Abramo Bagnara4244b432012-01-27 08:46:19 +0000598 /*IsCtorOrDtorName=*/false,
Kaelyn Uhrainb1378402012-01-18 21:41:41 +0000599 /*NonTrivialTypeSourceInfo=*/true);
Douglas Gregor2d435302009-12-30 17:04:44 +0000600 }
Reid Klecknerc05ca5e2014-06-19 01:23:22 +0000601 return;
Douglas Gregor2d435302009-12-30 17:04:44 +0000602 }
603
David Blaikiebbafb8a2012-03-11 07:00:24 +0000604 if (getLangOpts().CPlusPlus) {
Jeffrey Yasskin54eba422010-04-08 21:04:54 +0000605 // See if II is a class template that the user forgot to pass arguments to.
606 UnqualifiedId Name;
Kaelyn Uhrainb5b17fe2012-06-15 23:45:58 +0000607 Name.setIdentifier(II, IILoc);
Jeffrey Yasskin54eba422010-04-08 21:04:54 +0000608 CXXScopeSpec EmptySS;
609 TemplateTy TemplateResult;
Douglas Gregor786123d2010-05-21 23:18:07 +0000610 bool MemberOfUnknownSpecialization;
Abramo Bagnara7c5dee42010-08-06 12:11:11 +0000611 if (isTemplateName(S, SS ? *SS : EmptySS, /*hasTemplateKeyword=*/false,
John McCallba7bf592010-08-24 05:47:05 +0000612 Name, ParsedType(), true, TemplateResult,
Douglas Gregor786123d2010-05-21 23:18:07 +0000613 MemberOfUnknownSpecialization) == TNK_Type_template) {
Serge Pavlov9ddb76e2013-08-27 13:15:56 +0000614 TemplateName TplName = TemplateResult.get();
Jeffrey Yasskin54eba422010-04-08 21:04:54 +0000615 Diag(IILoc, diag::err_template_missing_args) << TplName;
616 if (TemplateDecl *TplDecl = TplName.getAsTemplateDecl()) {
617 Diag(TplDecl->getLocation(), diag::note_template_decl_here)
618 << TplDecl->getTemplateParameters()->getSourceRange();
619 }
Reid Klecknerc05ca5e2014-06-19 01:23:22 +0000620 return;
Jeffrey Yasskin54eba422010-04-08 21:04:54 +0000621 }
622 }
623
Douglas Gregor15e56022009-10-13 23:27:22 +0000624 // FIXME: Should we move the logic that tries to recover from a missing tag
625 // (struct, union, enum) from Parser::ParseImplicitInt here, instead?
626
Douglas Gregor2d435302009-12-30 17:04:44 +0000627 if (!SS || (!SS->isSet() && !SS->isInvalid()))
Kaelyn Uhrainb5b17fe2012-06-15 23:45:58 +0000628 Diag(IILoc, diag::err_unknown_typename) << II;
Douglas Gregor15e56022009-10-13 23:27:22 +0000629 else if (DeclContext *DC = computeDeclContext(*SS, false))
630 Diag(IILoc, diag::err_typename_nested_not_found)
Kaelyn Uhrainb5b17fe2012-06-15 23:45:58 +0000631 << II << DC << SS->getRange();
Douglas Gregor15e56022009-10-13 23:27:22 +0000632 else if (isDependentScopeSpecifier(*SS)) {
Francois Pichet48c946e2011-04-13 02:38:49 +0000633 unsigned DiagID = diag::err_typename_missing;
Alp Tokerbfa39342014-01-14 12:51:41 +0000634 if (getLangOpts().MSVCCompat && isMicrosoftMissingTypename(SS, S))
Reid Kleckner32506ed2014-06-12 23:03:48 +0000635 DiagID = diag::ext_typename_missing;
Francois Pichet48c946e2011-04-13 02:38:49 +0000636
637 Diag(SS->getRange().getBegin(), DiagID)
Aaron Ballman691e2272014-01-03 14:48:20 +0000638 << SS->getScopeRep() << II->getName()
Douglas Gregor15e56022009-10-13 23:27:22 +0000639 << SourceRange(SS->getRange().getBegin(), IILoc)
Douglas Gregora771f462010-03-31 17:46:05 +0000640 << FixItHint::CreateInsertion(SS->getRange().getBegin(), "typename ");
Kaelyn Uhrainb5b17fe2012-06-15 23:45:58 +0000641 SuggestedType = ActOnTypenameType(S, SourceLocation(),
642 *SS, *II, IILoc).get();
Douglas Gregor15e56022009-10-13 23:27:22 +0000643 } else {
644 assert(SS && SS->isInvalid() &&
645 "Invalid scope specifier has already been diagnosed");
646 }
Douglas Gregor15e56022009-10-13 23:27:22 +0000647}
Chris Lattnerffaa0e62009-04-12 21:49:30 +0000648
Douglas Gregor0e7dde52011-04-24 05:37:28 +0000649/// \brief Determine whether the given result set contains either a type name
650/// or
651static bool isResultTypeOrTemplate(LookupResult &R, const Token &NextToken) {
David Blaikiebbafb8a2012-03-11 07:00:24 +0000652 bool CheckTemplate = R.getSema().getLangOpts().CPlusPlus &&
Douglas Gregor0e7dde52011-04-24 05:37:28 +0000653 NextToken.is(tok::less);
654
655 for (LookupResult::iterator I = R.begin(), IEnd = R.end(); I != IEnd; ++I) {
656 if (isa<TypeDecl>(*I) || isa<ObjCInterfaceDecl>(*I))
657 return true;
658
659 if (CheckTemplate && isa<TemplateDecl>(*I))
660 return true;
661 }
662
663 return false;
664}
665
Kaelyn Uhrain71792052012-05-02 00:11:40 +0000666static bool isTagTypeWithMissingTag(Sema &SemaRef, LookupResult &Result,
667 Scope *S, CXXScopeSpec &SS,
668 IdentifierInfo *&Name,
669 SourceLocation NameLoc) {
Richard Smithaa31b4b2012-09-06 01:37:56 +0000670 LookupResult R(SemaRef, Name, NameLoc, Sema::LookupTagName);
671 SemaRef.LookupParsedName(R, S, &SS);
672 if (TagDecl *Tag = R.getAsSingle<TagDecl>()) {
Alp Toker68837432014-05-20 22:03:47 +0000673 StringRef FixItTagName;
Kaelyn Uhrain71792052012-05-02 00:11:40 +0000674 switch (Tag->getTagKind()) {
675 case TTK_Class:
Kaelyn Uhrain71792052012-05-02 00:11:40 +0000676 FixItTagName = "class ";
677 break;
678
679 case TTK_Enum:
Kaelyn Uhrain71792052012-05-02 00:11:40 +0000680 FixItTagName = "enum ";
681 break;
682
683 case TTK_Struct:
Kaelyn Uhrain71792052012-05-02 00:11:40 +0000684 FixItTagName = "struct ";
685 break;
686
Joao Matosdc86f942012-08-31 18:45:21 +0000687 case TTK_Interface:
Joao Matosdc86f942012-08-31 18:45:21 +0000688 FixItTagName = "__interface ";
689 break;
690
Kaelyn Uhrain71792052012-05-02 00:11:40 +0000691 case TTK_Union:
Kaelyn Uhrain71792052012-05-02 00:11:40 +0000692 FixItTagName = "union ";
693 break;
694 }
695
Alp Toker68837432014-05-20 22:03:47 +0000696 StringRef TagName = FixItTagName.drop_back();
Kaelyn Uhrain71792052012-05-02 00:11:40 +0000697 SemaRef.Diag(NameLoc, diag::err_use_of_tag_name_without_tag)
698 << Name << TagName << SemaRef.getLangOpts().CPlusPlus
699 << FixItHint::CreateInsertion(NameLoc, FixItTagName);
700
Richard Smithaa31b4b2012-09-06 01:37:56 +0000701 for (LookupResult::iterator I = Result.begin(), IEnd = Result.end();
702 I != IEnd; ++I)
703 SemaRef.Diag((*I)->getLocation(), diag::note_decl_hiding_tag_type)
704 << Name << TagName;
705
706 // Replace lookup results with just the tag decl.
707 Result.clear(Sema::LookupTagName);
708 SemaRef.LookupParsedName(Result, S, &SS);
Kaelyn Uhrain71792052012-05-02 00:11:40 +0000709 return true;
710 }
711
Kaelyn Uhrain71792052012-05-02 00:11:40 +0000712 return false;
713}
714
Richard Smith4f605af2012-08-18 00:55:03 +0000715/// Build a ParsedType for a simple-type-specifier with a nested-name-specifier.
716static ParsedType buildNestedType(Sema &S, CXXScopeSpec &SS,
717 QualType T, SourceLocation NameLoc) {
718 ASTContext &Context = S.Context;
719
720 TypeLocBuilder Builder;
721 Builder.pushTypeSpec(T).setNameLoc(NameLoc);
722
723 T = S.getElaboratedType(ETK_None, SS, T);
724 ElaboratedTypeLoc ElabTL = Builder.push<ElaboratedTypeLoc>(T);
725 ElabTL.setElaboratedKeywordLoc(SourceLocation());
726 ElabTL.setQualifierLoc(SS.getWithLocInContext(Context));
727 return S.CreateParsedType(T, Builder.getTypeSourceInfo(Context, T));
728}
729
Kaelyn Takata89c881b2014-10-27 18:07:29 +0000730Sema::NameClassification
731Sema::ClassifyName(Scope *S, CXXScopeSpec &SS, IdentifierInfo *&Name,
732 SourceLocation NameLoc, const Token &NextToken,
733 bool IsAddressOfOperand,
734 std::unique_ptr<CorrectionCandidateCallback> CCC) {
Douglas Gregor0e7dde52011-04-24 05:37:28 +0000735 DeclarationNameInfo NameInfo(Name, NameLoc);
736 ObjCMethodDecl *CurMethod = getCurMethodDecl();
Serge Pavlov6a7ffbe2014-04-13 16:52:03 +0000737
Douglas Gregor0e7dde52011-04-24 05:37:28 +0000738 if (NextToken.is(tok::coloncolon)) {
739 BuildCXXNestedNameSpecifier(S, *Name, NameLoc, NextToken.getLocation(),
Craig Topperc3ec1492014-05-26 06:22:03 +0000740 QualType(), false, SS, nullptr, false);
Douglas Gregor0e7dde52011-04-24 05:37:28 +0000741 }
Serge Pavlov6a7ffbe2014-04-13 16:52:03 +0000742
Douglas Gregor0e7dde52011-04-24 05:37:28 +0000743 LookupResult Result(*this, Name, NameLoc, LookupOrdinaryName);
Nikola Smiljanic905bfda2014-10-04 10:17:57 +0000744 LookupParsedName(Result, S, &SS, !CurMethod);
Serge Pavlov6a7ffbe2014-04-13 16:52:03 +0000745
Reid Kleckner1ba38f82014-07-08 20:05:48 +0000746 // For unqualified lookup in a class template in MSVC mode, look into
747 // dependent base classes where the primary class template is known.
748 if (Result.empty() && SS.isEmpty() && getLangOpts().MSVCCompat) {
749 if (ParsedType TypeInBase =
750 recoverFromTypeInKnownDependentBase(*this, *Name, NameLoc))
751 return TypeInBase;
752 }
753
Douglas Gregor0e7dde52011-04-24 05:37:28 +0000754 // Perform lookup for Objective-C instance variables (including automatically
755 // synthesized instance variables), if we're in an Objective-C method.
756 // FIXME: This lookup really, really needs to be folded in to the normal
757 // unqualified lookup mechanism.
758 if (!SS.isSet() && CurMethod && !isResultTypeOrTemplate(Result, NextToken)) {
759 ExprResult E = LookupInObjCMethod(Result, S, Name, true);
Douglas Gregorb90f5182011-04-25 15:05:41 +0000760 if (E.get() || E.isInvalid())
Douglas Gregor0e7dde52011-04-24 05:37:28 +0000761 return E;
Douglas Gregor0e7dde52011-04-24 05:37:28 +0000762 }
763
764 bool SecondTry = false;
765 bool IsFilteredTemplateName = false;
766
767Corrected:
768 switch (Result.getResultKind()) {
769 case LookupResult::NotFound:
770 // If an unqualified-id is followed by a '(', then we have a function
771 // call.
772 if (!SS.isSet() && NextToken.is(tok::l_paren)) {
773 // In C++, this is an ADL-only call.
774 // FIXME: Reference?
David Blaikiebbafb8a2012-03-11 07:00:24 +0000775 if (getLangOpts().CPlusPlus)
Douglas Gregor0e7dde52011-04-24 05:37:28 +0000776 return BuildDeclarationNameExpr(SS, Result, /*ADL=*/true);
777
778 // C90 6.3.2.2:
779 // If the expression that precedes the parenthesized argument list in a
780 // function call consists solely of an identifier, and if no
781 // declaration is visible for this identifier, the identifier is
782 // implicitly declared exactly as if, in the innermost block containing
783 // the function call, the declaration
784 //
785 // extern int identifier ();
786 //
787 // appeared.
788 //
789 // We also allow this in C99 as an extension.
790 if (NamedDecl *D = ImplicitlyDefineFunction(NameLoc, *Name, S)) {
791 Result.addDecl(D);
792 Result.resolveKind();
793 return BuildDeclarationNameExpr(SS, Result, /*ADL=*/false);
794 }
795 }
796
797 // In C, we first see whether there is a tag type by the same name, in
798 // which case it's likely that the user just forget to write "enum",
799 // "struct", or "union".
Kaelyn Uhrain71792052012-05-02 00:11:40 +0000800 if (!getLangOpts().CPlusPlus && !SecondTry &&
801 isTagTypeWithMissingTag(*this, Result, S, SS, Name, NameLoc)) {
802 break;
Douglas Gregor0e7dde52011-04-24 05:37:28 +0000803 }
804
805 // Perform typo correction to determine if there is another name that is
806 // close to this name.
Richard Smith4f605af2012-08-18 00:55:03 +0000807 if (!SecondTry && CCC) {
Douglas Gregor5cf0e152011-07-14 04:54:23 +0000808 SecondTry = true;
Douglas Gregorc2fa1692011-06-28 16:20:02 +0000809 if (TypoCorrection Corrected = CorrectTypo(Result.getLookupNameInfo(),
David Blaikie30d15442011-10-19 22:56:21 +0000810 Result.getLookupKind(), S,
Kaelyn Takata89c881b2014-10-27 18:07:29 +0000811 &SS, std::move(CCC),
John Thompson2255f2c2014-04-23 12:57:01 +0000812 CTK_ErrorRecovery)) {
Douglas Gregor5e16c162011-04-27 03:47:06 +0000813 unsigned UnqualifiedDiag = diag::err_undeclared_var_use_suggest;
814 unsigned QualifiedDiag = diag::err_no_member_suggest;
Richard Smithf9b15102013-08-17 00:46:16 +0000815
Douglas Gregorc2fa1692011-06-28 16:20:02 +0000816 NamedDecl *FirstDecl = Corrected.getCorrectionDecl();
Douglas Gregor8b02cd02011-04-27 04:48:22 +0000817 NamedDecl *UnderlyingFirstDecl
Craig Topperc3ec1492014-05-26 06:22:03 +0000818 = FirstDecl? FirstDecl->getUnderlyingDecl() : nullptr;
David Blaikiebbafb8a2012-03-11 07:00:24 +0000819 if (getLangOpts().CPlusPlus && NextToken.is(tok::less) &&
Douglas Gregor8b02cd02011-04-27 04:48:22 +0000820 UnderlyingFirstDecl && isa<TemplateDecl>(UnderlyingFirstDecl)) {
Douglas Gregor5e16c162011-04-27 03:47:06 +0000821 UnqualifiedDiag = diag::err_no_template_suggest;
822 QualifiedDiag = diag::err_no_member_template_suggest;
Douglas Gregor8b02cd02011-04-27 04:48:22 +0000823 } else if (UnderlyingFirstDecl &&
824 (isa<TypeDecl>(UnderlyingFirstDecl) ||
825 isa<ObjCInterfaceDecl>(UnderlyingFirstDecl) ||
826 isa<ObjCCompatibleAliasDecl>(UnderlyingFirstDecl))) {
David Blaikie9db06042013-03-21 21:35:15 +0000827 UnqualifiedDiag = diag::err_unknown_typename_suggest;
828 QualifiedDiag = diag::err_unknown_nested_typename_suggest;
829 }
Douglas Gregorc2fa1692011-06-28 16:20:02 +0000830
Kaelyn Uhrain10413a42013-07-02 23:47:44 +0000831 if (SS.isEmpty()) {
Richard Smithf9b15102013-08-17 00:46:16 +0000832 diagnoseTypo(Corrected, PDiag(UnqualifiedDiag) << Name);
Kaelyn Uhrain10413a42013-07-02 23:47:44 +0000833 } else {// FIXME: is this even reachable? Test it.
Richard Smithf9b15102013-08-17 00:46:16 +0000834 std::string CorrectedStr(Corrected.getAsString(getLangOpts()));
835 bool DroppedSpecifier = Corrected.WillReplaceSpecifier() &&
Kaelyn Uhrain10413a42013-07-02 23:47:44 +0000836 Name->getName().equals(CorrectedStr);
Richard Smithf9b15102013-08-17 00:46:16 +0000837 diagnoseTypo(Corrected, PDiag(QualifiedDiag)
838 << Name << computeDeclContext(SS, false)
839 << DroppedSpecifier << SS.getRange());
Kaelyn Uhrain10413a42013-07-02 23:47:44 +0000840 }
Douglas Gregor0e7dde52011-04-24 05:37:28 +0000841
842 // Update the name, so that the caller has the new name.
Douglas Gregorc2fa1692011-06-28 16:20:02 +0000843 Name = Corrected.getCorrectionAsIdentifierInfo();
Richard Smithf9b15102013-08-17 00:46:16 +0000844
Kaelyn Uhrain9ce58bd2012-01-24 19:45:35 +0000845 // Typo correction corrected to a keyword.
846 if (Corrected.isKeyword())
Richard Smithf9b15102013-08-17 00:46:16 +0000847 return Name;
Kaelyn Uhrain9ce58bd2012-01-24 19:45:35 +0000848
Douglas Gregorc2fa1692011-06-28 16:20:02 +0000849 // Also update the LookupResult...
850 // FIXME: This should probably go away at some point
851 Result.clear();
852 Result.setLookupName(Corrected.getCorrection());
Richard Smithf9b15102013-08-17 00:46:16 +0000853 if (FirstDecl)
Kaelyn Uhrain9ce58bd2012-01-24 19:45:35 +0000854 Result.addDecl(FirstDecl);
Douglas Gregor0e7dde52011-04-24 05:37:28 +0000855
856 // If we found an Objective-C instance variable, let
857 // LookupInObjCMethod build the appropriate expression to
858 // reference the ivar.
859 // FIXME: This is a gross hack.
860 if (ObjCIvarDecl *Ivar = Result.getAsSingle<ObjCIvarDecl>()) {
861 Result.clear();
862 ExprResult E(LookupInObjCMethod(Result, S, Ivar->getIdentifier()));
Benjamin Kramer62b95d82012-08-23 21:35:17 +0000863 return E;
Douglas Gregor0e7dde52011-04-24 05:37:28 +0000864 }
865
866 goto Corrected;
867 }
868 }
869
870 // We failed to correct; just fall through and let the parser deal with it.
871 Result.suppressDiagnostics();
872 return NameClassification::Unknown();
873
Abramo Bagnara7945c982012-01-27 09:46:47 +0000874 case LookupResult::NotFoundInCurrentInstantiation: {
Douglas Gregor0e7dde52011-04-24 05:37:28 +0000875 // We performed name lookup into the current instantiation, and there were
876 // dependent bases, so we treat this result the same way as any other
877 // dependent nested-name-specifier.
878
879 // C++ [temp.res]p2:
880 // A name used in a template declaration or definition and that is
881 // dependent on a template-parameter is assumed not to name a type
882 // unless the applicable name lookup finds a type name or the name is
883 // qualified by the keyword typename.
884 //
885 // FIXME: If the next token is '<', we might want to ask the parser to
886 // perform some heroics to see if we actually have a
887 // template-argument-list, which would indicate a missing 'template'
888 // keyword here.
Richard Smith4f605af2012-08-18 00:55:03 +0000889 return ActOnDependentIdExpression(SS, /*TemplateKWLoc=*/SourceLocation(),
890 NameInfo, IsAddressOfOperand,
Craig Topperc3ec1492014-05-26 06:22:03 +0000891 /*TemplateArgs=*/nullptr);
Abramo Bagnara7945c982012-01-27 09:46:47 +0000892 }
Douglas Gregor0e7dde52011-04-24 05:37:28 +0000893
894 case LookupResult::Found:
895 case LookupResult::FoundOverloaded:
896 case LookupResult::FoundUnresolvedValue:
897 break;
898
899 case LookupResult::Ambiguous:
David Blaikiebbafb8a2012-03-11 07:00:24 +0000900 if (getLangOpts().CPlusPlus && NextToken.is(tok::less) &&
Douglas Gregor8b02cd02011-04-27 04:48:22 +0000901 hasAnyAcceptableTemplateNames(Result)) {
Douglas Gregor0e7dde52011-04-24 05:37:28 +0000902 // C++ [temp.local]p3:
903 // A lookup that finds an injected-class-name (10.2) can result in an
904 // ambiguity in certain cases (for example, if it is found in more than
905 // one base class). If all of the injected-class-names that are found
906 // refer to specializations of the same class template, and if the name
907 // is followed by a template-argument-list, the reference refers to the
908 // class template itself and not a specialization thereof, and is not
909 // ambiguous.
910 //
911 // This filtering can make an ambiguous result into an unambiguous one,
912 // so try again after filtering out template names.
913 FilterAcceptableTemplateNames(Result);
914 if (!Result.isAmbiguous()) {
915 IsFilteredTemplateName = true;
916 break;
917 }
918 }
919
920 // Diagnose the ambiguity and return an error.
921 return NameClassification::Error();
922 }
923
David Blaikiebbafb8a2012-03-11 07:00:24 +0000924 if (getLangOpts().CPlusPlus && NextToken.is(tok::less) &&
Douglas Gregor0e7dde52011-04-24 05:37:28 +0000925 (IsFilteredTemplateName || hasAnyAcceptableTemplateNames(Result))) {
926 // C++ [temp.names]p3:
927 // After name lookup (3.4) finds that a name is a template-name or that
928 // an operator-function-id or a literal- operator-id refers to a set of
929 // overloaded functions any member of which is a function template if
930 // this is followed by a <, the < is always taken as the delimiter of a
931 // template-argument-list and never as the less-than operator.
932 if (!IsFilteredTemplateName)
933 FilterAcceptableTemplateNames(Result);
934
Douglas Gregor8b02cd02011-04-27 04:48:22 +0000935 if (!Result.empty()) {
936 bool IsFunctionTemplate;
Larisse Voufo39a1e502013-08-06 01:03:05 +0000937 bool IsVarTemplate;
Douglas Gregor8b02cd02011-04-27 04:48:22 +0000938 TemplateName Template;
939 if (Result.end() - Result.begin() > 1) {
940 IsFunctionTemplate = true;
941 Template = Context.getOverloadedTemplateName(Result.begin(),
942 Result.end());
943 } else {
944 TemplateDecl *TD
945 = cast<TemplateDecl>((*Result.begin())->getUnderlyingDecl());
946 IsFunctionTemplate = isa<FunctionTemplateDecl>(TD);
Larisse Voufo39a1e502013-08-06 01:03:05 +0000947 IsVarTemplate = isa<VarTemplateDecl>(TD);
948
Douglas Gregor8b02cd02011-04-27 04:48:22 +0000949 if (SS.isSet() && !SS.isInvalid())
950 Template = Context.getQualifiedTemplateName(SS.getScopeRep(),
Douglas Gregor0e7dde52011-04-24 05:37:28 +0000951 /*TemplateKeyword=*/false,
Douglas Gregor8b02cd02011-04-27 04:48:22 +0000952 TD);
953 else
954 Template = TemplateName(TD);
955 }
Douglas Gregor0e7dde52011-04-24 05:37:28 +0000956
Douglas Gregor8b02cd02011-04-27 04:48:22 +0000957 if (IsFunctionTemplate) {
958 // Function templates always go through overload resolution, at which
959 // point we'll perform the various checks (e.g., accessibility) we need
960 // to based on which function we selected.
961 Result.suppressDiagnostics();
962
963 return NameClassification::FunctionTemplate(Template);
964 }
Larisse Voufo39a1e502013-08-06 01:03:05 +0000965
966 return IsVarTemplate ? NameClassification::VarTemplate(Template)
967 : NameClassification::TypeTemplate(Template);
Douglas Gregor0e7dde52011-04-24 05:37:28 +0000968 }
Douglas Gregor0e7dde52011-04-24 05:37:28 +0000969 }
Richard Smith4f605af2012-08-18 00:55:03 +0000970
Douglas Gregor8b02cd02011-04-27 04:48:22 +0000971 NamedDecl *FirstDecl = (*Result.begin())->getUnderlyingDecl();
Douglas Gregor0e7dde52011-04-24 05:37:28 +0000972 if (TypeDecl *Type = dyn_cast<TypeDecl>(FirstDecl)) {
973 DiagnoseUseOfDecl(Type, NameLoc);
Nico Weber72889432014-09-06 01:25:55 +0000974 MarkAnyDeclReferenced(Type->getLocation(), Type, /*OdrUse=*/false);
Douglas Gregor0e7dde52011-04-24 05:37:28 +0000975 QualType T = Context.getTypeDeclType(Type);
Richard Smith4f605af2012-08-18 00:55:03 +0000976 if (SS.isNotEmpty())
977 return buildNestedType(*this, SS, T, NameLoc);
Kaelyn Uhrain71792052012-05-02 00:11:40 +0000978 return ParsedType::make(T);
Douglas Gregor0e7dde52011-04-24 05:37:28 +0000979 }
Richard Smith4f605af2012-08-18 00:55:03 +0000980
Douglas Gregor0e7dde52011-04-24 05:37:28 +0000981 ObjCInterfaceDecl *Class = dyn_cast<ObjCInterfaceDecl>(FirstDecl);
982 if (!Class) {
983 // FIXME: It's unfortunate that we don't have a Type node for handling this.
Nico Weberdfc59202014-05-03 22:07:35 +0000984 if (ObjCCompatibleAliasDecl *Alias =
985 dyn_cast<ObjCCompatibleAliasDecl>(FirstDecl))
Douglas Gregor0e7dde52011-04-24 05:37:28 +0000986 Class = Alias->getClassInterface();
987 }
988
989 if (Class) {
990 DiagnoseUseOfDecl(Class, NameLoc);
991
992 if (NextToken.is(tok::period)) {
993 // Interface. <something> is parsed as a property reference expression.
994 // Just return "unknown" as a fall-through for now.
995 Result.suppressDiagnostics();
996 return NameClassification::Unknown();
997 }
998
999 QualType T = Context.getObjCInterfaceType(Class);
1000 return ParsedType::make(T);
1001 }
Kaelyn Uhrain71792052012-05-02 00:11:40 +00001002
Richard Smith4f605af2012-08-18 00:55:03 +00001003 // We can have a type template here if we're classifying a template argument.
1004 if (isa<TemplateDecl>(FirstDecl) && !isa<FunctionTemplateDecl>(FirstDecl))
1005 return NameClassification::TypeTemplate(
1006 TemplateName(cast<TemplateDecl>(FirstDecl)));
1007
Kaelyn Uhrain71792052012-05-02 00:11:40 +00001008 // Check for a tag type hidden by a non-type decl in a few cases where it
1009 // seems likely a type is wanted instead of the non-type that was found.
Daniel Marjamakie59f8d72015-06-18 10:59:26 +00001010 bool NextIsOp = NextToken.isOneOf(tok::amp, tok::star);
Argyrios Kyrtzidisc64c0292013-05-07 19:54:28 +00001011 if ((NextToken.is(tok::identifier) ||
Alp Tokera2794f92014-01-22 07:29:52 +00001012 (NextIsOp &&
1013 FirstDecl->getUnderlyingDecl()->isFunctionOrFunctionTemplate())) &&
Argyrios Kyrtzidisc64c0292013-05-07 19:54:28 +00001014 isTagTypeWithMissingTag(*this, Result, S, SS, Name, NameLoc)) {
1015 TypeDecl *Type = Result.getAsSingle<TypeDecl>();
1016 DiagnoseUseOfDecl(Type, NameLoc);
1017 QualType T = Context.getTypeDeclType(Type);
1018 if (SS.isNotEmpty())
1019 return buildNestedType(*this, SS, T, NameLoc);
1020 return ParsedType::make(T);
Kaelyn Uhrain71792052012-05-02 00:11:40 +00001021 }
Douglas Gregor0e7dde52011-04-24 05:37:28 +00001022
Richard Smith4f605af2012-08-18 00:55:03 +00001023 if (FirstDecl->isCXXClassMember())
Craig Topperc3ec1492014-05-26 06:22:03 +00001024 return BuildPossibleImplicitMemberExpr(SS, SourceLocation(), Result,
1025 nullptr);
Douglas Gregor8b02cd02011-04-27 04:48:22 +00001026
Douglas Gregor0e7dde52011-04-24 05:37:28 +00001027 bool ADL = UseArgumentDependentLookup(SS, Result, NextToken.is(tok::l_paren));
1028 return BuildDeclarationNameExpr(SS, Result, ADL);
1029}
1030
John McCall5ed6e8f2009-08-18 00:00:49 +00001031// Determines the context to return to after temporarily entering a
1032// context. This depends in an unnecessarily complicated way on the
1033// exact ordering of callbacks from the parser.
Argyrios Kyrtzidis16ac9be2008-11-08 17:17:31 +00001034DeclContext *Sema::getContainingDC(DeclContext *DC) {
Argyrios Kyrtzidis16ac9be2008-11-08 17:17:31 +00001035
John McCall5ed6e8f2009-08-18 00:00:49 +00001036 // Functions defined inline within classes aren't parsed until we've
1037 // finished parsing the top-level class, so the top-level class is
1038 // the context we'll need to return to.
Faisal Valibb9071e2013-12-04 22:43:08 +00001039 // A Lambda call operator whose parent is a class must not be treated
1040 // as an inline member function. A Lambda can be used legally
1041 // either as an in-class member initializer or a default argument. These
1042 // are parsed once the class has been marked complete and so the containing
1043 // context would be the nested class (when the lambda is defined in one);
1044 // If the class is not complete, then the lambda is being used in an
1045 // ill-formed fashion (such as to specify the width of a bit-field, or
1046 // in an array-bound) - in which case we still want to return the
1047 // lexically containing DC (which could be a nested class).
1048 if (isa<FunctionDecl>(DC) && !isLambdaCallOperator(DC)) {
John McCall5ed6e8f2009-08-18 00:00:49 +00001049 DC = DC->getLexicalParent();
1050
1051 // A function not defined within a class will always return to its
1052 // lexical context.
1053 if (!isa<CXXRecordDecl>(DC))
1054 return DC;
1055
1056 // A C++ inline method/friend is parsed *after* the topmost class
1057 // it was declared in is fully parsed ("complete"); the topmost
1058 // class is the context we need to return to.
Argyrios Kyrtzidis0d09c492008-11-19 18:01:13 +00001059 while (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(DC->getLexicalParent()))
Argyrios Kyrtzidised983422008-07-01 10:37:29 +00001060 DC = RD;
1061
1062 // Return the declaration context of the topmost class the inline method is
1063 // declared in.
1064 return DC;
1065 }
1066
Argyrios Kyrtzidis0d09c492008-11-19 18:01:13 +00001067 return DC->getLexicalParent();
Argyrios Kyrtzidised983422008-07-01 10:37:29 +00001068}
1069
Douglas Gregor91f84212008-12-11 16:49:14 +00001070void Sema::PushDeclContext(Scope *S, DeclContext *DC) {
Argyrios Kyrtzidis16ac9be2008-11-08 17:17:31 +00001071 assert(getContainingDC(DC) == CurContext &&
Zhongxing Xu17a37eb2008-12-08 07:14:51 +00001072 "The next DeclContext should be lexically contained in the current one.");
Chris Lattnerbec41342008-04-22 18:39:57 +00001073 CurContext = DC;
Douglas Gregor91f84212008-12-11 16:49:14 +00001074 S->setEntity(DC);
Chris Lattnerc5ffed42008-04-04 06:12:32 +00001075}
1076
Chris Lattner0a5ff0d2008-04-06 04:47:34 +00001077void Sema::PopDeclContext() {
1078 assert(CurContext && "DeclContext imbalance!");
Douglas Gregor91f84212008-12-11 16:49:14 +00001079
Argyrios Kyrtzidis16ac9be2008-11-08 17:17:31 +00001080 CurContext = getContainingDC(CurContext);
John McCalldd762d12010-07-23 22:45:07 +00001081 assert(CurContext && "Popped translation unit!");
Chris Lattnerc5ffed42008-04-04 06:12:32 +00001082}
1083
Richard Smith0f192e82015-06-11 22:48:25 +00001084Sema::SkippedDefinitionContext Sema::ActOnTagStartSkippedDefinition(Scope *S,
1085 Decl *D) {
1086 // Unlike PushDeclContext, the context to which we return is not necessarily
1087 // the containing DC of TD, because the new context will be some pre-existing
1088 // TagDecl definition instead of a fresh one.
1089 auto Result = static_cast<SkippedDefinitionContext>(CurContext);
1090 CurContext = cast<TagDecl>(D)->getDefinition();
1091 assert(CurContext && "skipping definition of undefined tag");
1092 S->setEntity(CurContext);
1093 return Result;
1094}
1095
1096void Sema::ActOnTagFinishSkippedDefinition(SkippedDefinitionContext Context) {
1097 CurContext = static_cast<decltype(CurContext)>(Context);
1098}
1099
Argyrios Kyrtzidis9941a4d2009-06-17 23:19:02 +00001100/// EnterDeclaratorContext - Used when we must lookup names in the context
1101/// of a declarator's nested name specifier.
John McCall6df5fef2009-12-19 10:49:29 +00001102///
Argyrios Kyrtzidis7bcce492009-06-17 23:15:40 +00001103void Sema::EnterDeclaratorContext(Scope *S, DeclContext *DC) {
John McCall6df5fef2009-12-19 10:49:29 +00001104 // C++0x [basic.lookup.unqual]p13:
1105 // A name used in the definition of a static data member of class
1106 // X (after the qualified-id of the static member) is looked up as
1107 // if the name was used in a member function of X.
1108 // C++0x [basic.lookup.unqual]p14:
1109 // If a variable member of a namespace is defined outside of the
1110 // scope of its namespace then any name used in the definition of
1111 // the variable member (after the declarator-id) is looked up as
1112 // if the definition of the variable member occurred in its
1113 // namespace.
1114 // Both of these imply that we should push a scope whose context
1115 // is the semantic context of the declaration. We can't use
1116 // PushDeclContext here because that context is not necessarily
1117 // lexically contained in the current context. Fortunately,
1118 // the containing scope should have the appropriate information.
1119
1120 assert(!S->getEntity() && "scope already has entity");
1121
1122#ifndef NDEBUG
1123 Scope *Ancestor = S->getParent();
1124 while (!Ancestor->getEntity()) Ancestor = Ancestor->getParent();
1125 assert(Ancestor->getEntity() == CurContext && "ancestor context mismatch");
1126#endif
1127
Argyrios Kyrtzidis7bcce492009-06-17 23:15:40 +00001128 CurContext = DC;
John McCall6df5fef2009-12-19 10:49:29 +00001129 S->setEntity(DC);
Argyrios Kyrtzidis7bcce492009-06-17 23:15:40 +00001130}
1131
Argyrios Kyrtzidis7bcce492009-06-17 23:15:40 +00001132void Sema::ExitDeclaratorContext(Scope *S) {
John McCall6df5fef2009-12-19 10:49:29 +00001133 assert(S->getEntity() == CurContext && "Context imbalance!");
Argyrios Kyrtzidis7bcce492009-06-17 23:15:40 +00001134
John McCall6df5fef2009-12-19 10:49:29 +00001135 // Switch back to the lexical context. The safety of this is
1136 // enforced by an assert in EnterDeclaratorContext.
1137 Scope *Ancestor = S->getParent();
1138 while (!Ancestor->getEntity()) Ancestor = Ancestor->getParent();
Ted Kremenekc37877d2013-10-08 17:08:03 +00001139 CurContext = Ancestor->getEntity();
John McCall6df5fef2009-12-19 10:49:29 +00001140
1141 // We don't need to do anything with the scope, which is going to
1142 // disappear.
Argyrios Kyrtzidis7bcce492009-06-17 23:15:40 +00001143}
1144
Caitlin Sadowski990d5712011-09-08 17:42:31 +00001145
1146void Sema::ActOnReenterFunctionContext(Scope* S, Decl *D) {
Alp Tokera2794f92014-01-22 07:29:52 +00001147 // We assume that the caller has already called
1148 // ActOnReenterTemplateScope so getTemplatedDecl() works.
1149 FunctionDecl *FD = D->getAsFunction();
Caitlin Sadowski990d5712011-09-08 17:42:31 +00001150 if (!FD)
1151 return;
1152
DeLesley Hutchins6f860042012-04-06 15:10:17 +00001153 // Same implementation as PushDeclContext, but enters the context
1154 // from the lexical parent, rather than the top-level class.
1155 assert(CurContext == FD->getLexicalParent() &&
1156 "The next DeclContext should be lexically contained in the current one.");
1157 CurContext = FD;
1158 S->setEntity(CurContext);
1159
Caitlin Sadowski990d5712011-09-08 17:42:31 +00001160 for (unsigned P = 0, NumParams = FD->getNumParams(); P < NumParams; ++P) {
1161 ParmVarDecl *Param = FD->getParamDecl(P);
1162 // If the parameter has an identifier, then add it to the scope
1163 if (Param->getIdentifier()) {
1164 S->AddDecl(Param);
1165 IdResolver.AddDecl(Param);
1166 }
1167 }
1168}
1169
1170
DeLesley Hutchins6f860042012-04-06 15:10:17 +00001171void Sema::ActOnExitFunctionContext() {
1172 // Same implementation as PopDeclContext, but returns to the lexical parent,
1173 // rather than the top-level class.
1174 assert(CurContext && "DeclContext imbalance!");
1175 CurContext = CurContext->getLexicalParent();
1176 assert(CurContext && "Popped translation unit!");
1177}
1178
1179
Douglas Gregor4e5cbdc2009-02-11 23:02:49 +00001180/// \brief Determine whether we allow overloading of the function
1181/// PrevDecl with another declaration.
1182///
1183/// This routine determines whether overloading is possible, not
1184/// whether some new function is actually an overload. It will return
1185/// true in C++ (where we can always provide overloads) or, as an
1186/// extension, in C when the previous function is already an
1187/// overloaded function declaration or has the "overloadable"
1188/// attribute.
John McCall1f82f242009-11-18 22:49:29 +00001189static bool AllowOverloadingOfFunction(LookupResult &Previous,
1190 ASTContext &Context) {
David Blaikiebbafb8a2012-03-11 07:00:24 +00001191 if (Context.getLangOpts().CPlusPlus)
Douglas Gregor4e5cbdc2009-02-11 23:02:49 +00001192 return true;
1193
John McCall1f82f242009-11-18 22:49:29 +00001194 if (Previous.getResultKind() == LookupResult::FoundOverloaded)
Douglas Gregor4e5cbdc2009-02-11 23:02:49 +00001195 return true;
1196
John McCall1f82f242009-11-18 22:49:29 +00001197 return (Previous.getResultKind() == LookupResult::Found
1198 && Previous.getFoundDecl()->hasAttr<OverloadableAttr>());
Douglas Gregor4e5cbdc2009-02-11 23:02:49 +00001199}
1200
Argyrios Kyrtzidisb8a49202008-04-12 00:47:19 +00001201/// Add this decl to the scope shadowed decl chains.
John McCall759e32b2009-08-31 22:39:49 +00001202void Sema::PushOnScopeChains(NamedDecl *D, Scope *S, bool AddToContext) {
Douglas Gregor07665a62009-01-05 19:45:36 +00001203 // Move up the scope chain until we find the nearest enclosing
1204 // non-transparent context. The declaration will be introduced into this
1205 // scope.
Ted Kremenekc37877d2013-10-08 17:08:03 +00001206 while (S->getEntity() && S->getEntity()->isTransparentContext())
Douglas Gregor07665a62009-01-05 19:45:36 +00001207 S = S->getParent();
1208
Douglas Gregor8b9ccca2008-12-23 21:05:05 +00001209 // Add scoped declarations into their context, so that they can be
1210 // found later. Declarations without a context won't be inserted
1211 // into any context.
John McCall759e32b2009-08-31 22:39:49 +00001212 if (AddToContext)
1213 CurContext->addDecl(D);
Douglas Gregor8b9ccca2008-12-23 21:05:05 +00001214
Richard Smith541b38b2013-09-20 01:15:31 +00001215 // Out-of-line definitions shouldn't be pushed into scope in C++, unless they
1216 // are function-local declarations.
1217 if (getLangOpts().CPlusPlus && D->isOutOfLine() &&
Douglas Gregorf7b98952011-10-09 22:57:49 +00001218 !D->getDeclContext()->getRedeclContext()->Equals(
Richard Smith541b38b2013-09-20 01:15:31 +00001219 D->getLexicalDeclContext()->getRedeclContext()) &&
1220 !D->getLexicalDeclContext()->isFunctionOrMethod())
Chandler Carruthf50ef6e2010-02-21 07:08:09 +00001221 return;
1222
1223 // Template instantiations should also not be pushed into scope.
1224 if (isa<FunctionDecl>(D) &&
1225 cast<FunctionDecl>(D)->isFunctionTemplateSpecialization())
Douglas Gregor5ad7c542009-09-28 18:41:37 +00001226 return;
1227
John McCall9f3059a2009-10-09 21:13:30 +00001228 // If this replaces anything in the current scope,
1229 IdentifierResolver::iterator I = IdResolver.begin(D->getDeclName()),
1230 IEnd = IdResolver.end();
1231 for (; I != IEnd; ++I) {
John McCall48871652010-08-21 09:40:31 +00001232 if (S->isDeclScope(*I) && D->declarationReplaces(*I)) {
1233 S->RemoveDecl(*I);
John McCall9f3059a2009-10-09 21:13:30 +00001234 IdResolver.RemoveDecl(*I);
Argyrios Kyrtzidisfa8e15b2008-05-09 23:39:43 +00001235
John McCall9f3059a2009-10-09 21:13:30 +00001236 // Should only need to replace one decl.
1237 break;
Douglas Gregor38feed82009-04-24 02:57:34 +00001238 }
Argyrios Kyrtzidisfa8e15b2008-05-09 23:39:43 +00001239 }
Douglas Gregor5251f1b2008-10-21 16:13:35 +00001240
John McCall48871652010-08-21 09:40:31 +00001241 S->AddDecl(D);
Douglas Gregor88764cf2011-03-14 21:19:51 +00001242
1243 if (isa<LabelDecl>(D) && !cast<LabelDecl>(D)->isGnuLocal()) {
1244 // Implicitly-generated labels may end up getting generated in an order that
1245 // isn't strictly lexical, which breaks name lookup. Be careful to insert
1246 // the label at the appropriate place in the identifier chain.
1247 for (I = IdResolver.begin(D->getDeclName()); I != IEnd; ++I) {
Douglas Gregord7d7e0d2011-03-24 14:35:16 +00001248 DeclContext *IDC = (*I)->getLexicalDeclContext()->getRedeclContext();
Douglas Gregor46c04e72011-03-16 16:39:03 +00001249 if (IDC == CurContext) {
1250 if (!S->isDeclScope(*I))
1251 continue;
1252 } else if (IDC->Encloses(CurContext))
Douglas Gregor88764cf2011-03-14 21:19:51 +00001253 break;
1254 }
1255
Douglas Gregor46c04e72011-03-16 16:39:03 +00001256 IdResolver.InsertDeclAfter(I, D);
Douglas Gregor88764cf2011-03-14 21:19:51 +00001257 } else {
1258 IdResolver.AddDecl(D);
1259 }
Argyrios Kyrtzidisb8a49202008-04-12 00:47:19 +00001260}
1261
Douglas Gregor935bc7a22011-10-27 09:33:13 +00001262void Sema::pushExternalDeclIntoScope(NamedDecl *D, DeclarationName Name) {
1263 if (IdResolver.tryAddTopLevelDecl(D, Name) && TUScope)
1264 TUScope->AddDecl(D);
1265}
1266
Richard Smith1c34fb72013-08-13 18:18:50 +00001267bool Sema::isDeclInScope(NamedDecl *D, DeclContext *Ctx, Scope *S,
Richard Smith72bcaec2013-12-05 04:30:04 +00001268 bool AllowInlineNamespace) {
1269 return IdResolver.isDeclInScope(D, Ctx, S, AllowInlineNamespace);
Douglas Gregor505ad492009-09-28 00:47:05 +00001270}
1271
John McCallcc14d1f2010-08-24 08:50:51 +00001272Scope *Sema::getScopeForDeclContext(Scope *S, DeclContext *DC) {
1273 DeclContext *TargetDC = DC->getPrimaryContext();
1274 do {
Ted Kremenekc37877d2013-10-08 17:08:03 +00001275 if (DeclContext *ScopeDC = S->getEntity())
John McCallcc14d1f2010-08-24 08:50:51 +00001276 if (ScopeDC->getPrimaryContext() == TargetDC)
1277 return S;
1278 } while ((S = S->getParent()));
1279
Craig Topperc3ec1492014-05-26 06:22:03 +00001280 return nullptr;
John McCallcc14d1f2010-08-24 08:50:51 +00001281}
1282
John McCall1f82f242009-11-18 22:49:29 +00001283static bool isOutOfScopePreviousDeclaration(NamedDecl *,
1284 DeclContext*,
1285 ASTContext&);
1286
1287/// Filters out lookup results that don't fall within the given scope
1288/// as determined by isDeclInScope.
Richard Smith72bcaec2013-12-05 04:30:04 +00001289void Sema::FilterLookupForScope(LookupResult &R, DeclContext *Ctx, Scope *S,
Richard Smith3f1b5d02011-05-05 21:57:07 +00001290 bool ConsiderLinkage,
Richard Smith72bcaec2013-12-05 04:30:04 +00001291 bool AllowInlineNamespace) {
John McCall1f82f242009-11-18 22:49:29 +00001292 LookupResult::Filter F = R.makeFilter();
1293 while (F.hasNext()) {
1294 NamedDecl *D = F.next();
1295
Richard Smith72bcaec2013-12-05 04:30:04 +00001296 if (isDeclInScope(D, Ctx, S, AllowInlineNamespace))
John McCall1f82f242009-11-18 22:49:29 +00001297 continue;
1298
Richard Smith72bcaec2013-12-05 04:30:04 +00001299 if (ConsiderLinkage && isOutOfScopePreviousDeclaration(D, Ctx, Context))
John McCall1f82f242009-11-18 22:49:29 +00001300 continue;
Richard Smith72bcaec2013-12-05 04:30:04 +00001301
John McCall1f82f242009-11-18 22:49:29 +00001302 F.erase();
1303 }
1304
1305 F.done();
1306}
1307
1308static bool isUsingDecl(NamedDecl *D) {
1309 return isa<UsingShadowDecl>(D) ||
1310 isa<UnresolvedUsingTypenameDecl>(D) ||
1311 isa<UnresolvedUsingValueDecl>(D);
1312}
1313
1314/// Removes using shadow declarations from the lookup results.
1315static void RemoveUsingDecls(LookupResult &R) {
1316 LookupResult::Filter F = R.makeFilter();
1317 while (F.hasNext())
1318 if (isUsingDecl(F.next()))
1319 F.erase();
1320
1321 F.done();
1322}
1323
Argyrios Kyrtzidis04c7fa02010-08-15 10:17:33 +00001324/// \brief Check for this common pattern:
1325/// @code
1326/// class S {
1327/// S(const S&); // DO NOT IMPLEMENT
1328/// void operator=(const S&); // DO NOT IMPLEMENT
1329/// };
1330/// @endcode
1331static bool IsDisallowedCopyOrAssign(const CXXMethodDecl *D) {
1332 // FIXME: Should check for private access too but access is set after we get
1333 // the decl here.
Alexis Hunt4a8ea102011-05-06 20:44:56 +00001334 if (D->doesThisDeclarationHaveABody())
Argyrios Kyrtzidis04c7fa02010-08-15 10:17:33 +00001335 return false;
1336
1337 if (const CXXConstructorDecl *CD = dyn_cast<CXXConstructorDecl>(D))
1338 return CD->isCopyConstructor();
Douglas Gregora1ce1f82010-09-27 22:06:20 +00001339 if (const CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D))
1340 return Method->isCopyAssignmentOperator();
1341 return false;
Argyrios Kyrtzidis04c7fa02010-08-15 10:17:33 +00001342}
1343
Rafael Espindola0e0d0092013-03-14 03:07:35 +00001344// We need this to handle
1345//
1346// typedef struct {
1347// void *foo() { return 0; }
1348// } A;
1349//
1350// When we see foo we don't know if after the typedef we will get 'A' or '*A'
1351// for example. If 'A', foo will have external linkage. If we have '*A',
Alp Tokerf6a24ce2013-12-05 16:25:25 +00001352// foo will have no linkage. Since we can't know until we get to the end
Alp Tokerd4733632013-12-05 04:47:09 +00001353// of the typedef, this function finds out if D might have non-external linkage.
Rafael Espindola0e0d0092013-03-14 03:07:35 +00001354// Callers should verify at the end of the TU if it D has external linkage or
1355// not.
1356bool Sema::mightHaveNonExternalLinkage(const DeclaratorDecl *D) {
1357 const DeclContext *DC = D->getDeclContext();
1358 while (!DC->isTranslationUnit()) {
1359 if (const RecordDecl *RD = dyn_cast<RecordDecl>(DC)){
1360 if (!RD->hasNameForLinkage())
1361 return true;
1362 }
1363 DC = DC->getParent();
1364 }
1365
Rafael Espindola3ae00052013-05-13 00:12:11 +00001366 return !D->isExternallyVisible();
Rafael Espindola0e0d0092013-03-14 03:07:35 +00001367}
1368
Eli Friedman5ef21752013-09-10 03:05:56 +00001369// FIXME: This needs to be refactored; some other isInMainFile users want
1370// these semantics.
1371static bool isMainFileLoc(const Sema &S, SourceLocation Loc) {
1372 if (S.TUKind != TU_Complete)
1373 return false;
1374 return S.SourceMgr.isInMainFile(Loc);
1375}
1376
Argyrios Kyrtzidis1b30d9c2010-08-15 01:15:20 +00001377bool Sema::ShouldWarnIfUnusedFileScopedDecl(const DeclaratorDecl *D) const {
1378 assert(D);
Argyrios Kyrtzidis540bc012010-08-13 18:42:29 +00001379
Argyrios Kyrtzidis1b30d9c2010-08-15 01:15:20 +00001380 if (D->isInvalidDecl() || D->isUsed() || D->hasAttr<UnusedAttr>())
1381 return false;
1382
Richard Smithc3926172014-04-02 18:28:36 +00001383 // Ignore all entities declared within templates, and out-of-line definitions
1384 // of members of class templates.
Chandler Carruth8e666512011-01-03 19:27:19 +00001385 if (D->getDeclContext()->isDependentContext() ||
1386 D->getLexicalDeclContext()->isDependentContext())
Argyrios Kyrtzidis1b30d9c2010-08-15 01:15:20 +00001387 return false;
1388
Argyrios Kyrtzidis1b30d9c2010-08-15 01:15:20 +00001389 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
Argyrios Kyrtzidis04c7fa02010-08-15 10:17:33 +00001390 if (FD->getTemplateSpecializationKind() == TSK_ImplicitInstantiation)
1391 return false;
Argyrios Kyrtzidis1b30d9c2010-08-15 01:15:20 +00001392
Argyrios Kyrtzidis04c7fa02010-08-15 10:17:33 +00001393 if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) {
1394 if (MD->isVirtual() || IsDisallowedCopyOrAssign(MD))
1395 return false;
1396 } else {
Eli Friedman5ef21752013-09-10 03:05:56 +00001397 // 'static inline' functions are defined in headers; don't warn.
Richard Smitha90ee352014-05-11 21:25:24 +00001398 if (FD->isInlined() && !isMainFileLoc(*this, FD->getLocation()))
Argyrios Kyrtzidis04c7fa02010-08-15 10:17:33 +00001399 return false;
1400 }
Argyrios Kyrtzidis1b30d9c2010-08-15 01:15:20 +00001401
Alexis Hunt4a8ea102011-05-06 20:44:56 +00001402 if (FD->doesThisDeclarationHaveABody() &&
John McCalld37d35b2010-10-27 01:41:35 +00001403 Context.DeclMustBeEmitted(FD))
1404 return false;
John McCalld37d35b2010-10-27 01:41:35 +00001405 } else if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
Eli Friedman5ef21752013-09-10 03:05:56 +00001406 // Constants and utility variables are defined in headers with internal
1407 // linkage; don't warn. (Unlike functions, there isn't a convenient marker
1408 // like "inline".)
1409 if (!isMainFileLoc(*this, VD->getLocation()))
1410 return false;
1411
Eli Friedman5ef21752013-09-10 03:05:56 +00001412 if (Context.DeclMustBeEmitted(VD))
John McCalld37d35b2010-10-27 01:41:35 +00001413 return false;
1414
Argyrios Kyrtzidis1b30d9c2010-08-15 01:15:20 +00001415 if (VD->isStaticDataMember() &&
1416 VD->getTemplateSpecializationKind() == TSK_ImplicitInstantiation)
1417 return false;
John McCalld37d35b2010-10-27 01:41:35 +00001418 } else {
1419 return false;
Argyrios Kyrtzidis1b30d9c2010-08-15 01:15:20 +00001420 }
1421
John McCalld37d35b2010-10-27 01:41:35 +00001422 // Only warn for unused decls internal to the translation unit.
Richard Smitha90ee352014-05-11 21:25:24 +00001423 // FIXME: This seems like a bogus check; it suppresses -Wunused-function
1424 // for inline functions defined in the main source file, for instance.
Rafael Espindola0e0d0092013-03-14 03:07:35 +00001425 return mightHaveNonExternalLinkage(D);
John McCalld37d35b2010-10-27 01:41:35 +00001426}
1427
1428void Sema::MarkUnusedFileScopedDecl(const DeclaratorDecl *D) {
Argyrios Kyrtzidis1b30d9c2010-08-15 01:15:20 +00001429 if (!D)
1430 return;
1431
1432 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
Rafael Espindola8db352d2013-10-17 15:37:26 +00001433 const FunctionDecl *First = FD->getFirstDecl();
Argyrios Kyrtzidis1b30d9c2010-08-15 01:15:20 +00001434 if (FD != First && ShouldWarnIfUnusedFileScopedDecl(First))
1435 return; // First should already be in the vector.
1436 }
1437
1438 if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
Rafael Espindola8db352d2013-10-17 15:37:26 +00001439 const VarDecl *First = VD->getFirstDecl();
Argyrios Kyrtzidis1b30d9c2010-08-15 01:15:20 +00001440 if (VD != First && ShouldWarnIfUnusedFileScopedDecl(First))
1441 return; // First should already be in the vector.
1442 }
1443
David Blaikie3d8edc22012-05-26 05:35:39 +00001444 if (ShouldWarnIfUnusedFileScopedDecl(D))
1445 UnusedFileScopedDecls.push_back(D);
1446}
Argyrios Kyrtzidis35672e72010-08-13 18:42:17 +00001447
Anders Carlsson2889e0e2009-11-07 07:18:14 +00001448static bool ShouldDiagnoseUnusedDecl(const NamedDecl *D) {
John McCall67da35c2010-02-04 22:26:26 +00001449 if (D->isInvalidDecl())
1450 return false;
1451
Ted Kremenekce0e3f82014-01-09 20:19:45 +00001452 if (D->isReferenced() || D->isUsed() || D->hasAttr<UnusedAttr>() ||
1453 D->hasAttr<ObjCPreciseLifetimeAttr>())
Anders Carlssonf5dc6fa2009-11-07 07:26:56 +00001454 return false;
John McCall67da35c2010-02-04 22:26:26 +00001455
Chris Lattnercab02a62011-02-17 20:34:02 +00001456 if (isa<LabelDecl>(D))
1457 return true;
Nico Weber72889432014-09-06 01:25:55 +00001458
1459 // Except for labels, we only care about unused decls that are local to
1460 // functions.
1461 bool WithinFunction = D->getDeclContext()->isFunctionOrMethod();
1462 if (const auto *R = dyn_cast<CXXRecordDecl>(D->getDeclContext()))
1463 // For dependent types, the diagnostic is deferred.
1464 WithinFunction =
1465 WithinFunction || (R->isLocalClass() && !R->isDependentType());
1466 if (!WithinFunction)
1467 return false;
1468
1469 if (isa<TypedefNameDecl>(D))
1470 return true;
Chris Lattnercab02a62011-02-17 20:34:02 +00001471
John McCall67da35c2010-02-04 22:26:26 +00001472 // White-list anything that isn't a local variable.
Nico Weber72889432014-09-06 01:25:55 +00001473 if (!isa<VarDecl>(D) || isa<ParmVarDecl>(D) || isa<ImplicitParamDecl>(D))
John McCall67da35c2010-02-04 22:26:26 +00001474 return false;
1475
1476 // Types of valid local variables should be complete, so this should succeed.
Rafael Espindola7c23b082012-01-06 04:54:01 +00001477 if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
John McCallcef15822010-03-31 02:47:45 +00001478
1479 // White-list anything with an __attribute__((unused)) type.
1480 QualType Ty = VD->getType();
1481
1482 // Only look at the outermost level of typedef.
Douglas Gregor5c65f622012-09-14 05:10:40 +00001483 if (const TypedefType *TT = Ty->getAs<TypedefType>()) {
John McCallcef15822010-03-31 02:47:45 +00001484 if (TT->getDecl()->hasAttr<UnusedAttr>())
1485 return false;
1486 }
1487
Douglas Gregor14f232e2010-05-08 23:05:03 +00001488 // If we failed to complete the type for some reason, or if the type is
1489 // dependent, don't diagnose the variable.
1490 if (Ty->isIncompleteType() || Ty->isDependentType())
Douglas Gregor19defcd2010-04-27 16:20:13 +00001491 return false;
1492
John McCallcef15822010-03-31 02:47:45 +00001493 if (const TagType *TT = Ty->getAs<TagType>()) {
1494 const TagDecl *Tag = TT->getDecl();
1495 if (Tag->hasAttr<UnusedAttr>())
1496 return false;
1497
1498 if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(Tag)) {
Lubos Lunakedc13882013-07-20 15:05:36 +00001499 if (!RD->hasTrivialDestructor() && !RD->hasAttr<WarnUnusedAttr>())
Anders Carlssonf5dc6fa2009-11-07 07:26:56 +00001500 return false;
Rafael Espindola7c23b082012-01-06 04:54:01 +00001501
1502 if (const Expr *Init = VD->getInit()) {
Nico Weberdfc59202014-05-03 22:07:35 +00001503 if (const ExprWithCleanups *Cleanups =
1504 dyn_cast<ExprWithCleanups>(Init))
David Blaikiea9d4a932012-10-24 21:29:06 +00001505 Init = Cleanups->getSubExpr();
Rafael Espindola7c23b082012-01-06 04:54:01 +00001506 const CXXConstructExpr *Construct =
1507 dyn_cast<CXXConstructExpr>(Init);
1508 if (Construct && !Construct->isElidable()) {
1509 CXXConstructorDecl *CD = Construct->getConstructor();
Lubos Lunakedc13882013-07-20 15:05:36 +00001510 if (!CD->isTrivial() && !RD->hasAttr<WarnUnusedAttr>())
Rafael Espindola7c23b082012-01-06 04:54:01 +00001511 return false;
1512 }
1513 }
Anders Carlssonf5dc6fa2009-11-07 07:26:56 +00001514 }
1515 }
John McCallcef15822010-03-31 02:47:45 +00001516
1517 // TODO: __attribute__((unused)) templates?
Anders Carlssonf5dc6fa2009-11-07 07:26:56 +00001518 }
1519
John McCall67da35c2010-02-04 22:26:26 +00001520 return true;
Anders Carlsson2889e0e2009-11-07 07:18:14 +00001521}
1522
Anna Zaks964f4c62011-07-28 20:52:06 +00001523static void GenerateFixForUnusedDecl(const NamedDecl *D, ASTContext &Ctx,
1524 FixItHint &Hint) {
1525 if (isa<LabelDecl>(D)) {
1526 SourceLocation AfterColon = Lexer::findLocationAfterToken(D->getLocEnd(),
David Blaikiebbafb8a2012-03-11 07:00:24 +00001527 tok::colon, Ctx.getSourceManager(), Ctx.getLangOpts(), true);
Anna Zaks964f4c62011-07-28 20:52:06 +00001528 if (AfterColon.isInvalid())
1529 return;
1530 Hint = FixItHint::CreateRemoval(CharSourceRange::
1531 getCharRange(D->getLocStart(), AfterColon));
1532 }
1533 return;
1534}
1535
Nico Weber72889432014-09-06 01:25:55 +00001536void Sema::DiagnoseUnusedNestedTypedefs(const RecordDecl *D) {
1537 if (D->getTypeForDecl()->isDependentType())
1538 return;
1539
1540 for (auto *TmpD : D->decls()) {
1541 if (const auto *T = dyn_cast<TypedefNameDecl>(TmpD))
1542 DiagnoseUnusedDecl(T);
1543 else if(const auto *R = dyn_cast<RecordDecl>(TmpD))
1544 DiagnoseUnusedNestedTypedefs(R);
1545 }
1546}
1547
Chris Lattnerebb5c6c2011-02-18 01:27:55 +00001548/// DiagnoseUnusedDecl - Emit warnings about declarations that are not used
1549/// unless they are marked attr(unused).
Douglas Gregor14f232e2010-05-08 23:05:03 +00001550void Sema::DiagnoseUnusedDecl(const NamedDecl *D) {
1551 if (!ShouldDiagnoseUnusedDecl(D))
1552 return;
Nico Weber72889432014-09-06 01:25:55 +00001553
1554 if (auto *TD = dyn_cast<TypedefNameDecl>(D)) {
1555 // typedefs can be referenced later on, so the diagnostics are emitted
1556 // at end-of-translation-unit.
1557 UnusedLocalTypedefNameCandidates.insert(TD);
1558 return;
1559 }
Douglas Gregor14f232e2010-05-08 23:05:03 +00001560
Nico Weberdfc59202014-05-03 22:07:35 +00001561 FixItHint Hint;
Anna Zaks964f4c62011-07-28 20:52:06 +00001562 GenerateFixForUnusedDecl(D, Context, Hint);
1563
Chris Lattnercab02a62011-02-17 20:34:02 +00001564 unsigned DiagID;
Douglas Gregor14f232e2010-05-08 23:05:03 +00001565 if (isa<VarDecl>(D) && cast<VarDecl>(D)->isExceptionVariable())
Chris Lattnercab02a62011-02-17 20:34:02 +00001566 DiagID = diag::warn_unused_exception_param;
1567 else if (isa<LabelDecl>(D))
1568 DiagID = diag::warn_unused_label;
Douglas Gregor14f232e2010-05-08 23:05:03 +00001569 else
Chris Lattnercab02a62011-02-17 20:34:02 +00001570 DiagID = diag::warn_unused_variable;
1571
Anna Zaks964f4c62011-07-28 20:52:06 +00001572 Diag(D->getLocation(), DiagID) << D->getDeclName() << Hint;
Douglas Gregor14f232e2010-05-08 23:05:03 +00001573}
1574
Chris Lattnerebb5c6c2011-02-18 01:27:55 +00001575static void CheckPoppedLabel(LabelDecl *L, Sema &S) {
1576 // Verify that we have no forward references left. If so, there was a goto
1577 // or address of a label taken, but no definition of it. Label fwd
Ehsan Akhgari31097582014-09-22 02:21:54 +00001578 // definitions are indicated with a null substmt which is also not a resolved
1579 // MS inline assembly label name.
1580 bool Diagnose = false;
1581 if (L->isMSAsmLabel())
1582 Diagnose = !L->isResolvedMSAsmLabel();
1583 else
1584 Diagnose = L->getStmt() == nullptr;
1585 if (Diagnose)
Chris Lattnerebb5c6c2011-02-18 01:27:55 +00001586 S.Diag(L->getLocation(), diag::err_undeclared_label_use) <<L->getDeclName();
1587}
1588
Steve Naroffc62adb62007-10-09 22:01:59 +00001589void Sema::ActOnPopScope(SourceLocation Loc, Scope *S) {
Nick Lewyckyd78f92f2014-05-03 00:41:18 +00001590 S->mergeNRVOIntoParent();
1591
Chris Lattner1a76a3c2007-08-26 06:24:45 +00001592 if (S->decl_empty()) return;
Douglas Gregor5101c242008-12-05 18:15:24 +00001593 assert((S->getFlags() & (Scope::DeclScope | Scope::TemplateParamScope)) &&
Mike Stump11289f42009-09-09 15:08:12 +00001594 "Scope shouldn't contain decls!");
Argyrios Kyrtzidisfa8e15b2008-05-09 23:39:43 +00001595
Aaron Ballman35c54952014-03-17 16:55:25 +00001596 for (auto *TmpD : S->decls()) {
Steve Naroff9324db12007-09-13 18:10:37 +00001597 assert(TmpD && "This decl didn't get pushed??");
Argyrios Kyrtzidis406fb232008-06-10 01:32:09 +00001598
Douglas Gregor91f84212008-12-11 16:49:14 +00001599 assert(isa<NamedDecl>(TmpD) && "Decl isn't NamedDecl?");
1600 NamedDecl *D = cast<NamedDecl>(TmpD);
Argyrios Kyrtzidis406fb232008-06-10 01:32:09 +00001601
Douglas Gregor91f84212008-12-11 16:49:14 +00001602 if (!D->getDeclName()) continue;
Chris Lattnerc5c95b52008-04-11 07:00:53 +00001603
Douglas Gregor3beaf9b2009-10-08 21:35:42 +00001604 // Diagnose unused variables in this scope.
Nico Weber72889432014-09-06 01:25:55 +00001605 if (!S->hasUnrecoverableErrorOccurred()) {
Douglas Gregor14f232e2010-05-08 23:05:03 +00001606 DiagnoseUnusedDecl(D);
Nico Weber72889432014-09-06 01:25:55 +00001607 if (const auto *RD = dyn_cast<RecordDecl>(D))
1608 DiagnoseUnusedNestedTypedefs(RD);
1609 }
Douglas Gregor14f232e2010-05-08 23:05:03 +00001610
Chris Lattnerebb5c6c2011-02-18 01:27:55 +00001611 // If this was a forward reference to a label, verify it was defined.
1612 if (LabelDecl *LD = dyn_cast<LabelDecl>(D))
1613 CheckPoppedLabel(LD, *this);
1614
Douglas Gregor91f84212008-12-11 16:49:14 +00001615 // Remove this name from our lexical scope.
1616 IdResolver.RemoveDecl(D);
Chris Lattner302b4be2006-11-19 02:31:38 +00001617 }
1618}
1619
Douglas Gregor1c283312010-08-11 12:19:30 +00001620/// \brief Look for an Objective-C class in the translation unit.
1621///
1622/// \param Id The name of the Objective-C class we're looking for. If
1623/// typo-correction fixes this name, the Id will be updated
1624/// to the fixed name.
1625///
1626/// \param IdLoc The location of the name in the translation unit.
1627///
James Dennett41725122012-06-22 10:16:05 +00001628/// \param DoTypoCorrection If true, this routine will attempt typo correction
Douglas Gregor1c283312010-08-11 12:19:30 +00001629/// if there is no class with the given name.
1630///
1631/// \returns The declaration of the named Objective-C class, or NULL if the
1632/// class could not be found.
1633ObjCInterfaceDecl *Sema::getObjCInterfaceDecl(IdentifierInfo *&Id,
1634 SourceLocation IdLoc,
Douglas Gregorc2fa1692011-06-28 16:20:02 +00001635 bool DoTypoCorrection) {
Douglas Gregor1c283312010-08-11 12:19:30 +00001636 // The third "scope" argument is 0 since we aren't enabling lazy built-in
1637 // creation from this context.
1638 NamedDecl *IDecl = LookupSingleName(TUScope, Id, IdLoc, LookupOrdinaryName);
1639
Douglas Gregorc2fa1692011-06-28 16:20:02 +00001640 if (!IDecl && DoTypoCorrection) {
Douglas Gregor1c283312010-08-11 12:19:30 +00001641 // Perform typo correction at the given location, but only if we
1642 // find an Objective-C class name.
Kaelyn Takata89c881b2014-10-27 18:07:29 +00001643 if (TypoCorrection C = CorrectTypo(
1644 DeclarationNameInfo(Id, IdLoc), LookupOrdinaryName, TUScope, nullptr,
1645 llvm::make_unique<DeclFilterCCC<ObjCInterfaceDecl>>(),
1646 CTK_ErrorRecovery)) {
Richard Smithf9b15102013-08-17 00:46:16 +00001647 diagnoseTypo(C, PDiag(diag::err_undef_interface_suggest) << Id);
Kaelyn Uhrainb1378402012-01-18 21:41:41 +00001648 IDecl = C.getCorrectionDeclAs<ObjCInterfaceDecl>();
Douglas Gregor1c283312010-08-11 12:19:30 +00001649 Id = IDecl->getIdentifier();
1650 }
1651 }
Fariborz Jahanian4f8cb1e2012-01-12 00:18:35 +00001652 ObjCInterfaceDecl *Def = dyn_cast_or_null<ObjCInterfaceDecl>(IDecl);
1653 // This routine must always return a class definition, if any.
1654 if (Def && Def->getDefinition())
1655 Def = Def->getDefinition();
1656 return Def;
Douglas Gregor1c283312010-08-11 12:19:30 +00001657}
1658
Douglas Gregor45a33ec2009-01-12 18:45:55 +00001659/// getNonFieldDeclScope - Retrieves the innermost scope, starting
1660/// from S, where a non-field would be declared. This routine copes
1661/// with the difference between C and C++ scoping rules in structs and
1662/// unions. For example, the following code is well-formed in C but
1663/// ill-formed in C++:
1664/// @code
1665/// struct S6 {
1666/// enum { BAR } e;
1667/// };
Mike Stump11289f42009-09-09 15:08:12 +00001668///
Douglas Gregor45a33ec2009-01-12 18:45:55 +00001669/// void test_S6() {
1670/// struct S6 a;
1671/// a.e = BAR;
1672/// }
1673/// @endcode
1674/// For the declaration of BAR, this routine will return a different
1675/// scope. The scope S will be the scope of the unnamed enumeration
1676/// within S6. In C++, this routine will return the scope associated
1677/// with S6, because the enumeration's scope is a transparent
1678/// context but structures can contain non-field names. In C, this
1679/// routine will return the translation unit scope, since the
1680/// enumeration's scope is a transparent context and structures cannot
1681/// contain non-field names.
1682Scope *Sema::getNonFieldDeclScope(Scope *S) {
1683 while (((S->getFlags() & Scope::DeclScope) == 0) ||
Ted Kremenekc37877d2013-10-08 17:08:03 +00001684 (S->getEntity() && S->getEntity()->isTransparentContext()) ||
David Blaikiebbafb8a2012-03-11 07:00:24 +00001685 (S->isClassScope() && !getLangOpts().CPlusPlus))
Douglas Gregor45a33ec2009-01-12 18:45:55 +00001686 S = S->getParent();
1687 return S;
1688}
1689
Fariborz Jahaniancb6c8672013-01-04 18:45:40 +00001690/// \brief Looks up the declaration of "struct objc_super" and
1691/// saves it for later use in building builtin declaration of
1692/// objc_msgSendSuper and objc_msgSendSuper_stret. If no such
1693/// pre-existing declaration exists no action takes place.
1694static void LookupPredefedObjCSuperType(Sema &ThisSema, Scope *S,
1695 IdentifierInfo *II) {
1696 if (!II->isStr("objc_msgSendSuper"))
1697 return;
1698 ASTContext &Context = ThisSema.Context;
1699
1700 LookupResult Result(ThisSema, &Context.Idents.get("objc_super"),
1701 SourceLocation(), Sema::LookupTagName);
1702 ThisSema.LookupName(Result, S);
1703 if (Result.getResultKind() == LookupResult::Found)
1704 if (const TagDecl *TD = Result.getAsSingle<TagDecl>())
1705 Context.setObjCSuperType(Context.getTagDeclType(TD));
1706}
1707
Alp Toker5d96e0a2014-07-11 20:53:51 +00001708static StringRef getHeaderName(ASTContext::GetBuiltinTypeError Error) {
1709 switch (Error) {
1710 case ASTContext::GE_None:
1711 return "";
1712 case ASTContext::GE_Missing_stdio:
1713 return "stdio.h";
1714 case ASTContext::GE_Missing_setjmp:
1715 return "setjmp.h";
1716 case ASTContext::GE_Missing_ucontext:
1717 return "ucontext.h";
1718 }
1719 llvm_unreachable("unhandled error kind");
1720}
1721
Douglas Gregorb9063fc2009-02-13 23:20:09 +00001722/// LazilyCreateBuiltin - The specified Builtin-ID was first used at
1723/// file scope. lazily create a decl for it. ForRedeclaration is true
1724/// if we're creating this built-in in anticipation of redeclaring the
1725/// built-in.
Alexey Samsonov75bb28e2014-08-28 23:34:32 +00001726NamedDecl *Sema::LazilyCreateBuiltin(IdentifierInfo *II, unsigned ID,
Douglas Gregorb9063fc2009-02-13 23:20:09 +00001727 Scope *S, bool ForRedeclaration,
1728 SourceLocation Loc) {
Fariborz Jahaniancb6c8672013-01-04 18:45:40 +00001729 LookupPredefedObjCSuperType(*this, S, II);
Chris Lattner9561a0b2007-01-28 08:20:04 +00001730
Chris Lattnerecd79c62009-06-14 00:45:47 +00001731 ASTContext::GetBuiltinTypeError Error;
Alexey Samsonov75bb28e2014-08-28 23:34:32 +00001732 QualType R = Context.GetBuiltinType(ID, Error);
Alp Toker5d96e0a2014-07-11 20:53:51 +00001733 if (Error) {
Douglas Gregor538c3d82009-02-14 01:52:53 +00001734 if (ForRedeclaration)
Alp Toker5d96e0a2014-07-11 20:53:51 +00001735 Diag(Loc, diag::warn_implicit_decl_requires_sysheader)
1736 << getHeaderName(Error)
Alexey Samsonov75bb28e2014-08-28 23:34:32 +00001737 << Context.BuiltinInfo.GetName(ID);
Craig Topperc3ec1492014-05-26 06:22:03 +00001738 return nullptr;
Douglas Gregor538c3d82009-02-14 01:52:53 +00001739 }
Douglas Gregorb9063fc2009-02-13 23:20:09 +00001740
Alexey Samsonov75bb28e2014-08-28 23:34:32 +00001741 if (!ForRedeclaration && Context.BuiltinInfo.isPredefinedLibFunction(ID)) {
Douglas Gregorb9063fc2009-02-13 23:20:09 +00001742 Diag(Loc, diag::ext_implicit_lib_function_decl)
Alexey Samsonov75bb28e2014-08-28 23:34:32 +00001743 << Context.BuiltinInfo.GetName(ID)
Douglas Gregorb9063fc2009-02-13 23:20:09 +00001744 << R;
Alexey Samsonov75bb28e2014-08-28 23:34:32 +00001745 if (Context.BuiltinInfo.getHeaderName(ID) &&
Alp Tokerd4a3f0e2014-06-15 23:30:39 +00001746 !Diags.isIgnored(diag::ext_implicit_lib_function_decl, Loc))
Alp Toker5d96e0a2014-07-11 20:53:51 +00001747 Diag(Loc, diag::note_include_header_or_declare)
Alexey Samsonov75bb28e2014-08-28 23:34:32 +00001748 << Context.BuiltinInfo.getHeaderName(ID)
1749 << Context.BuiltinInfo.GetName(ID);
Douglas Gregorb9063fc2009-02-13 23:20:09 +00001750 }
1751
Warren Hunt445d83e2013-11-01 23:46:51 +00001752 DeclContext *Parent = Context.getTranslationUnitDecl();
1753 if (getLangOpts().CPlusPlus) {
1754 LinkageSpecDecl *CLinkageDecl =
1755 LinkageSpecDecl::Create(Context, Parent, Loc, Loc,
1756 LinkageSpecDecl::lang_c, false);
Enea Zaffanellad8430922013-11-20 15:41:05 +00001757 CLinkageDecl->setImplicit();
Warren Hunt445d83e2013-11-01 23:46:51 +00001758 Parent->addDecl(CLinkageDecl);
1759 Parent = CLinkageDecl;
1760 }
1761
Argyrios Kyrtzidis6d053032008-04-17 14:47:13 +00001762 FunctionDecl *New = FunctionDecl::Create(Context,
Warren Hunt445d83e2013-11-01 23:46:51 +00001763 Parent,
Craig Topperc3ec1492014-05-26 06:22:03 +00001764 Loc, Loc, II, R, /*TInfo=*/nullptr,
John McCall8e7d6562010-08-26 03:08:43 +00001765 SC_Extern,
Rafael Espindola6ae7e502013-04-03 19:27:57 +00001766 false,
Davide Italiano3c613d62015-04-25 20:20:04 +00001767 R->isFunctionProtoType());
Douglas Gregorb9063fc2009-02-13 23:20:09 +00001768 New->setImplicit();
1769
Chris Lattner4dd27102008-05-05 22:18:14 +00001770 // Create Decl objects for each parameter, adding them to the
1771 // FunctionDecl.
John McCall424cec92011-01-19 06:33:43 +00001772 if (const FunctionProtoType *FT = dyn_cast<FunctionProtoType>(R)) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001773 SmallVector<ParmVarDecl*, 16> Params;
Alp Toker9cacbab2014-01-20 20:26:09 +00001774 for (unsigned i = 0, e = FT->getNumParams(); i != e; ++i) {
John McCall8fb0d9d2011-05-01 22:35:37 +00001775 ParmVarDecl *parm =
Alp Toker9cacbab2014-01-20 20:26:09 +00001776 ParmVarDecl::Create(Context, New, SourceLocation(), SourceLocation(),
Craig Topperc3ec1492014-05-26 06:22:03 +00001777 nullptr, FT->getParamType(i), /*TInfo=*/nullptr,
1778 SC_None, nullptr);
John McCall8fb0d9d2011-05-01 22:35:37 +00001779 parm->setScopeInfo(0, i);
1780 Params.push_back(parm);
1781 }
David Blaikie9c70e042011-09-21 18:16:56 +00001782 New->setParams(Params);
Chris Lattner4dd27102008-05-05 22:18:14 +00001783 }
Mike Stump11289f42009-09-09 15:08:12 +00001784
1785 AddKnownFunctionAttributes(New);
Warren Hunt445d83e2013-11-01 23:46:51 +00001786 RegisterLocallyScopedExternCDecl(New, S);
Mike Stump11289f42009-09-09 15:08:12 +00001787
Chris Lattnerc5c95b52008-04-11 07:00:53 +00001788 // TUScope is the translation-unit scope to insert this function into.
Douglas Gregorc72e6452009-01-09 18:51:29 +00001789 // FIXME: This is hideous. We need to teach PushOnScopeChains to
1790 // relate Scopes to DeclContexts, and probably eliminate CurContext
1791 // entirely, but we're not there yet.
1792 DeclContext *SavedContext = CurContext;
Warren Hunt445d83e2013-11-01 23:46:51 +00001793 CurContext = Parent;
Argyrios Kyrtzidisfa8e15b2008-05-09 23:39:43 +00001794 PushOnScopeChains(New, TUScope);
Douglas Gregorc72e6452009-01-09 18:51:29 +00001795 CurContext = SavedContext;
Chris Lattner9561a0b2007-01-28 08:20:04 +00001796 return New;
1797}
1798
Douglas Gregor3552dab2013-01-09 00:47:56 +00001799/// \brief Filter out any previous declarations that the given declaration
1800/// should not consider because they are not permitted to conflict, e.g.,
1801/// because they come from hidden sub-modules and do not refer to the same
1802/// entity.
Richard Smith42413142015-05-15 20:05:43 +00001803static void filterNonConflictingPreviousDecls(Sema &S,
Douglas Gregor3552dab2013-01-09 00:47:56 +00001804 NamedDecl *decl,
1805 LookupResult &previous){
1806 // This is only interesting when modules are enabled.
Richard Smith529ecb22015-06-22 21:15:01 +00001807 if ((!S.getLangOpts().Modules && !S.getLangOpts().ModulesLocalVisibility) ||
1808 !S.getLangOpts().ModulesHideInternalLinkage)
Douglas Gregor3552dab2013-01-09 00:47:56 +00001809 return;
1810
1811 // Empty sets are uninteresting.
1812 if (previous.empty())
1813 return;
1814
Douglas Gregor3552dab2013-01-09 00:47:56 +00001815 LookupResult::Filter filter = previous.makeFilter();
1816 while (filter.hasNext()) {
1817 NamedDecl *old = filter.next();
1818
1819 // Non-hidden declarations are never ignored.
Richard Smith42413142015-05-15 20:05:43 +00001820 if (S.isVisible(old))
Douglas Gregor3552dab2013-01-09 00:47:56 +00001821 continue;
1822
Rafael Espindola3ae00052013-05-13 00:12:11 +00001823 if (!old->isExternallyVisible())
Douglas Gregor3552dab2013-01-09 00:47:56 +00001824 filter.erase();
1825 }
1826
1827 filter.done();
1828}
1829
Richard Smithca40f9b2014-08-10 02:20:15 +00001830/// Typedef declarations don't have linkage, but they still denote the same
1831/// entity if their types are the same.
1832/// FIXME: This is notionally doing the same thing as ASTReaderDecl's
1833/// isSameEntity.
Richard Smith42413142015-05-15 20:05:43 +00001834static void filterNonConflictingPreviousTypedefDecls(Sema &S,
Richard Smithca40f9b2014-08-10 02:20:15 +00001835 TypedefNameDecl *Decl,
1836 LookupResult &Previous) {
1837 // This is only interesting when modules are enabled.
Richard Smith00be6d02015-06-11 03:05:39 +00001838 if (!S.getLangOpts().Modules && !S.getLangOpts().ModulesLocalVisibility)
Richard Smithca40f9b2014-08-10 02:20:15 +00001839 return;
1840
1841 // Empty sets are uninteresting.
1842 if (Previous.empty())
1843 return;
1844
1845 LookupResult::Filter Filter = Previous.makeFilter();
1846 while (Filter.hasNext()) {
1847 NamedDecl *Old = Filter.next();
1848
1849 // Non-hidden declarations are never ignored.
Richard Smith42413142015-05-15 20:05:43 +00001850 if (S.isVisible(Old))
Richard Smithca40f9b2014-08-10 02:20:15 +00001851 continue;
1852
1853 // Declarations of the same entity are not ignored, even if they have
1854 // different linkages.
Richard Smitha5230222015-03-27 01:37:43 +00001855 if (auto *OldTD = dyn_cast<TypedefNameDecl>(Old)) {
Richard Smith42413142015-05-15 20:05:43 +00001856 if (S.Context.hasSameType(OldTD->getUnderlyingType(),
1857 Decl->getUnderlyingType()))
Richard Smithca40f9b2014-08-10 02:20:15 +00001858 continue;
1859
Richard Smitha5230222015-03-27 01:37:43 +00001860 // If both declarations give a tag declaration a typedef name for linkage
1861 // purposes, then they declare the same entity.
Richard Smith42413142015-05-15 20:05:43 +00001862 if (OldTD->getAnonDeclWithTypedefName(/*AnyRedecl*/true) &&
Richard Smitha5230222015-03-27 01:37:43 +00001863 Decl->getAnonDeclWithTypedefName())
1864 continue;
1865 }
1866
Richard Smithca40f9b2014-08-10 02:20:15 +00001867 if (!Old->isExternallyVisible())
1868 Filter.erase();
1869 }
1870
1871 Filter.done();
1872}
1873
Rafael Espindolacde2c8f2011-12-26 22:42:47 +00001874bool Sema::isIncompatibleTypedef(TypeDecl *Old, TypedefNameDecl *New) {
1875 QualType OldType;
1876 if (TypedefNameDecl *OldTypedef = dyn_cast<TypedefNameDecl>(Old))
1877 OldType = OldTypedef->getUnderlyingType();
1878 else
1879 OldType = Context.getTypeDeclType(Old);
1880 QualType NewType = New->getUnderlyingType();
1881
Douglas Gregoraab36982012-01-11 22:33:48 +00001882 if (NewType->isVariablyModifiedType()) {
1883 // Must not redefine a typedef with a variably-modified type.
1884 int Kind = isa<TypeAliasDecl>(Old) ? 1 : 0;
1885 Diag(New->getLocation(), diag::err_redefinition_variably_modified_typedef)
1886 << Kind << NewType;
1887 if (Old->getLocation().isValid())
1888 Diag(Old->getLocation(), diag::note_previous_definition);
1889 New->setInvalidDecl();
1890 return true;
1891 }
1892
Rafael Espindolacde2c8f2011-12-26 22:42:47 +00001893 if (OldType != NewType &&
1894 !OldType->isDependentType() &&
1895 !NewType->isDependentType() &&
Douglas Gregoraab36982012-01-11 22:33:48 +00001896 !Context.hasSameType(OldType, NewType)) {
Rafael Espindolacde2c8f2011-12-26 22:42:47 +00001897 int Kind = isa<TypeAliasDecl>(Old) ? 1 : 0;
1898 Diag(New->getLocation(), diag::err_redefinition_different_typedef)
1899 << Kind << NewType << OldType;
1900 if (Old->getLocation().isValid())
1901 Diag(Old->getLocation(), diag::note_previous_definition);
1902 New->setInvalidDecl();
1903 return true;
1904 }
1905 return false;
1906}
1907
Richard Smithdda56e42011-04-15 14:24:37 +00001908/// MergeTypedefNameDecl - We just parsed a typedef 'New' which has the
Douglas Gregor75a45ba2009-02-16 17:45:42 +00001909/// same name and scope as a previous declaration 'Old'. Figure out
1910/// how to resolve this situation, merging decls or emitting
Chris Lattnerf6d1c9c2009-04-25 08:06:05 +00001911/// diagnostics as appropriate. If there was an error, set New to be invalid.
Chris Lattner01564d92007-01-27 19:27:06 +00001912///
Richard Smithdda56e42011-04-15 14:24:37 +00001913void Sema::MergeTypedefNameDecl(TypedefNameDecl *New, LookupResult &OldDecls) {
John McCall1f82f242009-11-18 22:49:29 +00001914 // If the new decl is known invalid already, don't bother doing any
1915 // merging checks.
1916 if (New->isInvalidDecl()) return;
Mike Stump11289f42009-09-09 15:08:12 +00001917
Steve Naroff44cfcb62008-09-09 14:32:20 +00001918 // Allow multiple definitions for ObjC built-in typedefs.
1919 // FIXME: Verify the underlying types are equivalent!
David Blaikiebbafb8a2012-03-11 07:00:24 +00001920 if (getLangOpts().ObjC1) {
Chris Lattner66e32812008-11-20 05:41:43 +00001921 const IdentifierInfo *TypeID = New->getIdentifier();
1922 switch (TypeID->getLength()) {
1923 default: break;
Mike Stump11289f42009-09-09 15:08:12 +00001924 case 2:
Fariborz Jahanian16d71bb2012-05-14 22:48:56 +00001925 {
1926 if (!TypeID->isStr("id"))
1927 break;
1928 QualType T = New->getUnderlyingType();
1929 if (!T->isPointerType())
1930 break;
1931 if (!T->isVoidPointerType()) {
1932 QualType PT = T->getAs<PointerType>()->getPointeeType();
1933 if (!PT->isStructureType())
1934 break;
1935 }
1936 Context.setObjCIdRedefinitionType(T);
1937 // Install the built-in type for 'id', ignoring the current definition.
1938 New->setTypeForDecl(Context.getObjCIdType().getTypePtr());
1939 return;
1940 }
Chris Lattner66e32812008-11-20 05:41:43 +00001941 case 5:
1942 if (!TypeID->isStr("Class"))
1943 break;
Douglas Gregor97673472011-08-11 20:58:55 +00001944 Context.setObjCClassRedefinitionType(New->getUnderlyingType());
Steve Naroff7cae42b2009-07-10 23:34:53 +00001945 // Install the built-in type for 'Class', ignoring the current definition.
1946 New->setTypeForDecl(Context.getObjCClassType().getTypePtr());
Chris Lattnerf6d1c9c2009-04-25 08:06:05 +00001947 return;
Chris Lattner66e32812008-11-20 05:41:43 +00001948 case 3:
1949 if (!TypeID->isStr("SEL"))
1950 break;
Douglas Gregor97673472011-08-11 20:58:55 +00001951 Context.setObjCSelRedefinitionType(New->getUnderlyingType());
Fariborz Jahanian252ba5f2009-11-21 19:53:08 +00001952 // Install the built-in type for 'SEL', ignoring the current definition.
1953 New->setTypeForDecl(Context.getObjCSelType().getTypePtr());
Chris Lattnerf6d1c9c2009-04-25 08:06:05 +00001954 return;
Steve Naroff44cfcb62008-09-09 14:32:20 +00001955 }
1956 // Fall through - the typedef name was not a builtin type.
1957 }
John McCall1f82f242009-11-18 22:49:29 +00001958
Douglas Gregorfb034662009-01-28 17:15:10 +00001959 // Verify the old decl was also a type.
John McCall91f1a022009-12-30 00:31:22 +00001960 TypeDecl *Old = OldDecls.getAsSingle<TypeDecl>();
1961 if (!Old) {
Mike Stump11289f42009-09-09 15:08:12 +00001962 Diag(New->getLocation(), diag::err_redefinition_different_kind)
Chris Lattnere3d20d92008-11-23 21:45:46 +00001963 << New->getDeclName();
John McCall1f82f242009-11-18 22:49:29 +00001964
1965 NamedDecl *OldD = OldDecls.getRepresentativeDecl();
Chris Lattnerf6d1c9c2009-04-25 08:06:05 +00001966 if (OldD->getLocation().isValid())
Fariborz Jahanian1778f4b2009-01-16 19:58:32 +00001967 Diag(OldD->getLocation(), diag::note_previous_definition);
John McCall1f82f242009-11-18 22:49:29 +00001968
Chris Lattnerf6d1c9c2009-04-25 08:06:05 +00001969 return New->setInvalidDecl();
Chris Lattnerc511efb2007-01-27 19:32:14 +00001970 }
Douglas Gregorfb034662009-01-28 17:15:10 +00001971
John McCall1f82f242009-11-18 22:49:29 +00001972 // If the old declaration is invalid, just give up here.
1973 if (Old->isInvalidDecl())
1974 return New->setInvalidDecl();
1975
Richard Smitha5230222015-03-27 01:37:43 +00001976 if (auto *OldTD = dyn_cast<TypedefNameDecl>(Old)) {
Richard Smith42413142015-05-15 20:05:43 +00001977 auto *OldTag = OldTD->getAnonDeclWithTypedefName(/*AnyRedecl*/true);
Richard Smitha5230222015-03-27 01:37:43 +00001978 auto *NewTag = New->getAnonDeclWithTypedefName();
1979 NamedDecl *Hidden = nullptr;
1980 if (getLangOpts().CPlusPlus && OldTag && NewTag &&
1981 OldTag->getCanonicalDecl() != NewTag->getCanonicalDecl() &&
1982 !hasVisibleDefinition(OldTag, &Hidden)) {
1983 // There is a definition of this tag, but it is not visible. Use it
1984 // instead of our tag.
1985 New->setTypeForDecl(OldTD->getTypeForDecl());
1986 if (OldTD->isModed())
1987 New->setModedTypeSourceInfo(OldTD->getTypeSourceInfo(),
1988 OldTD->getUnderlyingType());
1989 else
1990 New->setTypeSourceInfo(OldTD->getTypeSourceInfo());
1991
1992 // Make the old tag definition visible.
Richard Smithd9ba2242015-05-07 03:54:19 +00001993 makeMergedDefinitionVisible(Hidden, NewTag->getLocation());
Richard Smitha5230222015-03-27 01:37:43 +00001994 }
1995 }
1996
Chris Lattnerf9c49e52008-07-25 18:44:27 +00001997 // If the typedef types are not identical, reject them in all languages and
1998 // with any extensions enabled.
Rafael Espindolacde2c8f2011-12-26 22:42:47 +00001999 if (isIncompatibleTypedef(Old, New))
2000 return;
Mike Stump11289f42009-09-09 15:08:12 +00002001
Justin Bogner84ff5ee2013-10-08 00:19:09 +00002002 // The types match. Link up the redeclaration chain and merge attributes if
2003 // the old declaration was a typedef.
2004 if (TypedefNameDecl *Typedef = dyn_cast<TypedefNameDecl>(Old)) {
Rafael Espindola8db352d2013-10-17 15:37:26 +00002005 New->setPreviousDecl(Typedef);
Justin Bogner84ff5ee2013-10-08 00:19:09 +00002006 mergeDeclAttributes(New, Old);
2007 }
Eli Friedmane7b8aa92013-07-16 02:07:49 +00002008
David Blaikiebbafb8a2012-03-11 07:00:24 +00002009 if (getLangOpts().MicrosoftExt)
Chris Lattnerf6d1c9c2009-04-25 08:06:05 +00002010 return;
Eli Friedman61b529f2008-06-11 06:20:39 +00002011
David Blaikiebbafb8a2012-03-11 07:00:24 +00002012 if (getLangOpts().CPlusPlus) {
Douglas Gregor9dd13ab2010-01-11 21:54:40 +00002013 // C++ [dcl.typedef]p2:
2014 // In a given non-class scope, a typedef specifier can be used to
2015 // redefine the name of any type declared in that scope to refer
2016 // to the type to which it already refers.
Chris Lattner2581fc32009-04-17 22:04:20 +00002017 if (!isa<CXXRecordDecl>(CurContext))
Chris Lattnerf6d1c9c2009-04-25 08:06:05 +00002018 return;
Douglas Gregor9dd13ab2010-01-11 21:54:40 +00002019
2020 // C++0x [dcl.typedef]p4:
2021 // In a given class scope, a typedef specifier can be used to redefine
2022 // any class-name declared in that scope that is not also a typedef-name
2023 // to refer to the type to which it already refers.
2024 //
2025 // This wording came in via DR424, which was a correction to the
2026 // wording in DR56, which accidentally banned code like:
2027 //
2028 // struct S {
2029 // typedef struct A { } A;
2030 // };
2031 //
2032 // in the C++03 standard. We implement the C++0x semantics, which
2033 // allow the above but disallow
2034 //
2035 // struct S {
2036 // typedef int I;
2037 // typedef int I;
2038 // };
2039 //
2040 // since that was the intent of DR56.
Richard Smithdda56e42011-04-15 14:24:37 +00002041 if (!isa<TypedefNameDecl>(Old))
Douglas Gregor9dd13ab2010-01-11 21:54:40 +00002042 return;
2043
Chris Lattner2581fc32009-04-17 22:04:20 +00002044 Diag(New->getLocation(), diag::err_redefinition)
2045 << New->getDeclName();
2046 Diag(Old->getLocation(), diag::note_previous_definition);
Chris Lattnerf6d1c9c2009-04-25 08:06:05 +00002047 return New->setInvalidDecl();
Daniel Dunbar84b70f72008-09-12 18:10:20 +00002048 }
Eli Friedman61b529f2008-06-11 06:20:39 +00002049
Douglas Gregor7363fb02012-01-11 04:25:01 +00002050 // Modules always permit redefinition of typedefs, as does C11.
David Blaikiebbafb8a2012-03-11 07:00:24 +00002051 if (getLangOpts().Modules || getLangOpts().C11)
Douglas Gregordbd93bf2012-01-09 15:36:04 +00002052 return;
2053
Chris Lattner2581fc32009-04-17 22:04:20 +00002054 // If we have a redefinition of a typedef in C, emit a warning. This warning
2055 // is normally mapped to an error, but can be controlled with
Eli Friedman319ce952009-06-04 23:03:07 +00002056 // -Wtypedef-redefinition. If either the original or the redefinition is
2057 // in a system header, don't emit this for compatibility with GCC.
Chris Lattner30d0cfd2010-03-01 20:59:53 +00002058 if (getDiagnostics().getSuppressSystemWarnings() &&
Eli Friedman319ce952009-06-04 23:03:07 +00002059 (Context.getSourceManager().isInSystemHeader(Old->getLocation()) ||
2060 Context.getSourceManager().isInSystemHeader(New->getLocation())))
Chris Lattner9a845892009-04-27 01:46:12 +00002061 return;
Mike Stump11289f42009-09-09 15:08:12 +00002062
Richard Smith1b98ccc2014-07-19 01:39:17 +00002063 Diag(New->getLocation(), diag::ext_redefinition_of_typedef)
Chris Lattner2581fc32009-04-17 22:04:20 +00002064 << New->getDeclName();
Chris Lattner0369c572008-11-23 23:12:31 +00002065 Diag(Old->getLocation(), diag::note_previous_definition);
Chris Lattner01564d92007-01-27 19:27:06 +00002066}
2067
Chris Lattner2c6fcf52008-06-26 18:38:35 +00002068/// DeclhasAttr - returns true if decl Declaration already has the target
2069/// attribute.
Aaron Ballmanb9023ed2014-01-20 18:07:09 +00002070static bool DeclHasAttr(const Decl *D, const Attr *A) {
Alexis Huntdcfba7b2010-08-18 23:23:40 +00002071 const OwnershipAttr *OA = dyn_cast<OwnershipAttr>(A);
Julien Lerouge5a6b6982011-09-09 22:41:49 +00002072 const AnnotateAttr *Ann = dyn_cast<AnnotateAttr>(A);
Aaron Ballmanb97112e2014-03-08 22:19:01 +00002073 for (const auto *i : D->attrs())
2074 if (i->getKind() == A->getKind()) {
Julien Lerouge5a6b6982011-09-09 22:41:49 +00002075 if (Ann) {
Aaron Ballmanb97112e2014-03-08 22:19:01 +00002076 if (Ann->getAnnotation() == cast<AnnotateAttr>(i)->getAnnotation())
Julien Lerouge5a6b6982011-09-09 22:41:49 +00002077 return true;
2078 continue;
2079 }
Alexis Huntdcfba7b2010-08-18 23:23:40 +00002080 // FIXME: Don't hardcode this check
Aaron Ballmanb97112e2014-03-08 22:19:01 +00002081 if (OA && isa<OwnershipAttr>(i))
2082 return OA->getOwnKind() == cast<OwnershipAttr>(i)->getOwnKind();
Chris Lattner84966392008-03-03 03:28:21 +00002083 return true;
Alexis Huntdcfba7b2010-08-18 23:23:40 +00002084 }
Chris Lattner84966392008-03-03 03:28:21 +00002085
2086 return false;
2087}
2088
Richard Smithbc8caaf2013-02-22 04:55:39 +00002089static bool isAttributeTargetADefinition(Decl *D) {
2090 if (VarDecl *VD = dyn_cast<VarDecl>(D))
2091 return VD->isThisDeclarationADefinition();
2092 if (TagDecl *TD = dyn_cast<TagDecl>(D))
2093 return TD->isCompleteDefinition() || TD->isBeingDefined();
2094 return true;
2095}
2096
2097/// Merge alignment attributes from \p Old to \p New, taking into account the
2098/// special semantics of C11's _Alignas specifier and C++11's alignas attribute.
2099///
2100/// \return \c true if any attributes were added to \p New.
2101static bool mergeAlignedAttrs(Sema &S, NamedDecl *New, Decl *Old) {
2102 // Look for alignas attributes on Old, and pick out whichever attribute
2103 // specifies the strictest alignment requirement.
Craig Topperc3ec1492014-05-26 06:22:03 +00002104 AlignedAttr *OldAlignasAttr = nullptr;
2105 AlignedAttr *OldStrictestAlignAttr = nullptr;
Richard Smithbc8caaf2013-02-22 04:55:39 +00002106 unsigned OldAlign = 0;
Aaron Ballmanbe22bcb2014-03-10 17:08:28 +00002107 for (auto *I : Old->specific_attrs<AlignedAttr>()) {
Richard Smithbc8caaf2013-02-22 04:55:39 +00002108 // FIXME: We have no way of representing inherited dependent alignments
2109 // in a case like:
2110 // template<int A, int B> struct alignas(A) X;
2111 // template<int A, int B> struct alignas(B) X {};
2112 // For now, we just ignore any alignas attributes which are not on the
2113 // definition in such a case.
2114 if (I->isAlignmentDependent())
2115 return false;
2116
2117 if (I->isAlignas())
Aaron Ballmanbe22bcb2014-03-10 17:08:28 +00002118 OldAlignasAttr = I;
Richard Smithbc8caaf2013-02-22 04:55:39 +00002119
2120 unsigned Align = I->getAlignment(S.Context);
2121 if (Align > OldAlign) {
2122 OldAlign = Align;
Aaron Ballmanbe22bcb2014-03-10 17:08:28 +00002123 OldStrictestAlignAttr = I;
Richard Smithbc8caaf2013-02-22 04:55:39 +00002124 }
2125 }
2126
2127 // Look for alignas attributes on New.
Craig Topperc3ec1492014-05-26 06:22:03 +00002128 AlignedAttr *NewAlignasAttr = nullptr;
Richard Smithbc8caaf2013-02-22 04:55:39 +00002129 unsigned NewAlign = 0;
Aaron Ballmanbe22bcb2014-03-10 17:08:28 +00002130 for (auto *I : New->specific_attrs<AlignedAttr>()) {
Richard Smithbc8caaf2013-02-22 04:55:39 +00002131 if (I->isAlignmentDependent())
2132 return false;
2133
2134 if (I->isAlignas())
Aaron Ballmanbe22bcb2014-03-10 17:08:28 +00002135 NewAlignasAttr = I;
Richard Smithbc8caaf2013-02-22 04:55:39 +00002136
2137 unsigned Align = I->getAlignment(S.Context);
2138 if (Align > NewAlign)
2139 NewAlign = Align;
2140 }
2141
2142 if (OldAlignasAttr && NewAlignasAttr && OldAlign != NewAlign) {
2143 // Both declarations have 'alignas' attributes. We require them to match.
2144 // C++11 [dcl.align]p6 and C11 6.7.5/7 both come close to saying this, but
2145 // fall short. (If two declarations both have alignas, they must both match
2146 // every definition, and so must match each other if there is a definition.)
2147
2148 // If either declaration only contains 'alignas(0)' specifiers, then it
2149 // specifies the natural alignment for the type.
2150 if (OldAlign == 0 || NewAlign == 0) {
2151 QualType Ty;
2152 if (ValueDecl *VD = dyn_cast<ValueDecl>(New))
2153 Ty = VD->getType();
2154 else
2155 Ty = S.Context.getTagDeclType(cast<TagDecl>(New));
2156
2157 if (OldAlign == 0)
2158 OldAlign = S.Context.getTypeAlign(Ty);
2159 if (NewAlign == 0)
2160 NewAlign = S.Context.getTypeAlign(Ty);
2161 }
2162
2163 if (OldAlign != NewAlign) {
2164 S.Diag(NewAlignasAttr->getLocation(), diag::err_alignas_mismatch)
2165 << (unsigned)S.Context.toCharUnitsFromBits(OldAlign).getQuantity()
2166 << (unsigned)S.Context.toCharUnitsFromBits(NewAlign).getQuantity();
2167 S.Diag(OldAlignasAttr->getLocation(), diag::note_previous_declaration);
2168 }
2169 }
2170
2171 if (OldAlignasAttr && !NewAlignasAttr && isAttributeTargetADefinition(New)) {
2172 // C++11 [dcl.align]p6:
2173 // if any declaration of an entity has an alignment-specifier,
2174 // every defining declaration of that entity shall specify an
2175 // equivalent alignment.
2176 // C11 6.7.5/7:
2177 // If the definition of an object does not have an alignment
2178 // specifier, any other declaration of that object shall also
2179 // have no alignment specifier.
2180 S.Diag(New->getLocation(), diag::err_alignas_missing_on_definition)
Aaron Ballman3d216a52014-01-02 23:39:11 +00002181 << OldAlignasAttr;
Richard Smithbc8caaf2013-02-22 04:55:39 +00002182 S.Diag(OldAlignasAttr->getLocation(), diag::note_alignas_on_declaration)
Aaron Ballman3d216a52014-01-02 23:39:11 +00002183 << OldAlignasAttr;
Richard Smithbc8caaf2013-02-22 04:55:39 +00002184 }
2185
2186 bool AnyAdded = false;
2187
2188 // Ensure we have an attribute representing the strictest alignment.
2189 if (OldAlign > NewAlign) {
2190 AlignedAttr *Clone = OldStrictestAlignAttr->clone(S.Context);
2191 Clone->setInherited(true);
2192 New->addAttr(Clone);
2193 AnyAdded = true;
2194 }
2195
2196 // Ensure we have an alignas attribute if the old declaration had one.
2197 if (OldAlignasAttr && !NewAlignasAttr &&
2198 !(AnyAdded && OldStrictestAlignAttr->isAlignas())) {
2199 AlignedAttr *Clone = OldAlignasAttr->clone(S.Context);
2200 Clone->setInherited(true);
2201 New->addAttr(Clone);
2202 AnyAdded = true;
2203 }
2204
2205 return AnyAdded;
2206}
2207
Aaron Ballman7a2fb5f2014-04-17 20:08:36 +00002208static bool mergeDeclAttribute(Sema &S, NamedDecl *D,
2209 const InheritableAttr *Attr, bool Override) {
2210 InheritableAttr *NewAttr = nullptr;
Michael Han99315932013-01-24 16:46:58 +00002211 unsigned AttrSpellingListIndex = Attr->getSpellingListIndex();
Aaron Ballman7a2fb5f2014-04-17 20:08:36 +00002212 if (const auto *AA = dyn_cast<AvailabilityAttr>(Attr))
Richard Smithbc8caaf2013-02-22 04:55:39 +00002213 NewAttr = S.mergeAvailabilityAttr(D, AA->getRange(), AA->getPlatform(),
2214 AA->getIntroduced(), AA->getDeprecated(),
2215 AA->getObsoleted(), AA->getUnavailable(),
2216 AA->getMessage(), Override,
John McCalld041a9b2013-02-20 01:54:26 +00002217 AttrSpellingListIndex);
Aaron Ballman7a2fb5f2014-04-17 20:08:36 +00002218 else if (const auto *VA = dyn_cast<VisibilityAttr>(Attr))
Richard Smithbc8caaf2013-02-22 04:55:39 +00002219 NewAttr = S.mergeVisibilityAttr(D, VA->getRange(), VA->getVisibility(),
2220 AttrSpellingListIndex);
Aaron Ballman7a2fb5f2014-04-17 20:08:36 +00002221 else if (const auto *VA = dyn_cast<TypeVisibilityAttr>(Attr))
Richard Smithbc8caaf2013-02-22 04:55:39 +00002222 NewAttr = S.mergeTypeVisibilityAttr(D, VA->getRange(), VA->getVisibility(),
2223 AttrSpellingListIndex);
Aaron Ballman7a2fb5f2014-04-17 20:08:36 +00002224 else if (const auto *ImportA = dyn_cast<DLLImportAttr>(Attr))
Richard Smithbc8caaf2013-02-22 04:55:39 +00002225 NewAttr = S.mergeDLLImportAttr(D, ImportA->getRange(),
2226 AttrSpellingListIndex);
Aaron Ballman7a2fb5f2014-04-17 20:08:36 +00002227 else if (const auto *ExportA = dyn_cast<DLLExportAttr>(Attr))
Richard Smithbc8caaf2013-02-22 04:55:39 +00002228 NewAttr = S.mergeDLLExportAttr(D, ExportA->getRange(),
2229 AttrSpellingListIndex);
Aaron Ballman7a2fb5f2014-04-17 20:08:36 +00002230 else if (const auto *FA = dyn_cast<FormatAttr>(Attr))
Richard Smithbc8caaf2013-02-22 04:55:39 +00002231 NewAttr = S.mergeFormatAttr(D, FA->getRange(), FA->getType(),
2232 FA->getFormatIdx(), FA->getFirstArg(),
2233 AttrSpellingListIndex);
Aaron Ballman7a2fb5f2014-04-17 20:08:36 +00002234 else if (const auto *SA = dyn_cast<SectionAttr>(Attr))
Richard Smithbc8caaf2013-02-22 04:55:39 +00002235 NewAttr = S.mergeSectionAttr(D, SA->getRange(), SA->getName(),
2236 AttrSpellingListIndex);
Aaron Ballman7a2fb5f2014-04-17 20:08:36 +00002237 else if (const auto *IA = dyn_cast<MSInheritanceAttr>(Attr))
David Majnemer4bb09802014-02-10 19:50:15 +00002238 NewAttr = S.mergeMSInheritanceAttr(D, IA->getRange(), IA->getBestCase(),
2239 AttrSpellingListIndex,
David Majnemer2c4e00a2014-01-29 22:07:36 +00002240 IA->getSemanticSpelling());
Paul Robinson30e41fb2014-12-15 18:57:28 +00002241 else if (const auto *AA = dyn_cast<AlwaysInlineAttr>(Attr))
Paul Robinson080b1f32015-01-13 18:34:56 +00002242 NewAttr = S.mergeAlwaysInlineAttr(D, AA->getRange(),
2243 &S.Context.Idents.get(AA->getSpelling()),
2244 AttrSpellingListIndex);
Paul Robinson30e41fb2014-12-15 18:57:28 +00002245 else if (const auto *MA = dyn_cast<MinSizeAttr>(Attr))
2246 NewAttr = S.mergeMinSizeAttr(D, MA->getRange(), AttrSpellingListIndex);
2247 else if (const auto *OA = dyn_cast<OptimizeNoneAttr>(Attr))
2248 NewAttr = S.mergeOptimizeNoneAttr(D, OA->getRange(), AttrSpellingListIndex);
Richard Smithbc8caaf2013-02-22 04:55:39 +00002249 else if (isa<AlignedAttr>(Attr))
2250 // AlignedAttrs are handled separately, because we need to handle all
2251 // such attributes on a declaration at the same time.
Aaron Ballman7a2fb5f2014-04-17 20:08:36 +00002252 NewAttr = nullptr;
Fariborz Jahanianb93355e2014-07-17 17:05:04 +00002253 else if (isa<DeprecatedAttr>(Attr) && Override)
2254 NewAttr = nullptr;
Aaron Ballmanb9023ed2014-01-20 18:07:09 +00002255 else if (Attr->duplicatesAllowed() || !DeclHasAttr(D, Attr))
Richard Smithbc8caaf2013-02-22 04:55:39 +00002256 NewAttr = cast<InheritableAttr>(Attr->clone(S.Context));
Rafael Espindolac67f2232012-05-10 02:50:16 +00002257
Rafael Espindolae200f1c2012-05-13 03:25:18 +00002258 if (NewAttr) {
Rafael Espindolac67f2232012-05-10 02:50:16 +00002259 NewAttr->setInherited(true);
2260 D->addAttr(NewAttr);
2261 return true;
2262 }
2263
2264 return false;
2265}
2266
Rafael Espindolaa5bba702012-07-15 01:05:36 +00002267static const Decl *getDefinition(const Decl *D) {
2268 if (const TagDecl *TD = dyn_cast<TagDecl>(D))
Rafael Espindola36191042012-05-18 01:47:00 +00002269 return TD->getDefinition();
Rafael Espindolad53ffa02013-10-22 21:39:03 +00002270 if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
2271 const VarDecl *Def = VD->getDefinition();
2272 if (Def)
2273 return Def;
2274 return VD->getActingDefinition();
2275 }
Rafael Espindolaa5bba702012-07-15 01:05:36 +00002276 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
Rafael Espindola36191042012-05-18 01:47:00 +00002277 const FunctionDecl* Def;
Rafael Espindolad53ffa02013-10-22 21:39:03 +00002278 if (FD->isDefined(Def))
Rafael Espindola36191042012-05-18 01:47:00 +00002279 return Def;
2280 }
Craig Topperc3ec1492014-05-26 06:22:03 +00002281 return nullptr;
Rafael Espindola36191042012-05-18 01:47:00 +00002282}
2283
Rafael Espindolafaf556b2012-07-15 01:33:40 +00002284static bool hasAttribute(const Decl *D, attr::Kind Kind) {
Aaron Ballmanb97112e2014-03-08 22:19:01 +00002285 for (const auto *Attribute : D->attrs())
Rafael Espindolafaf556b2012-07-15 01:33:40 +00002286 if (Attribute->getKind() == Kind)
2287 return true;
Rafael Espindolafaf556b2012-07-15 01:33:40 +00002288 return false;
2289}
2290
2291/// checkNewAttributesAfterDef - If we already have a definition, check that
2292/// there are no new attributes in this declaration.
2293static void checkNewAttributesAfterDef(Sema &S, Decl *New, const Decl *Old) {
2294 if (!New->hasAttrs())
2295 return;
2296
2297 const Decl *Def = getDefinition(Old);
2298 if (!Def || Def == New)
2299 return;
2300
2301 AttrVec &NewAttributes = New->getAttrs();
2302 for (unsigned I = 0, E = NewAttributes.size(); I != E;) {
2303 const Attr *NewAttribute = NewAttributes[I];
Rafael Espindolad53ffa02013-10-22 21:39:03 +00002304
2305 if (isa<AliasAttr>(NewAttribute)) {
David Majnemer6b903562015-01-19 10:21:22 +00002306 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(New))
2307 S.CheckForFunctionRedefinition(FD, cast<FunctionDecl>(Def));
2308 else {
2309 VarDecl *VD = cast<VarDecl>(New);
David Majnemer290d3472015-01-21 01:30:40 +00002310 unsigned Diag = cast<VarDecl>(Def)->isThisDeclarationADefinition() ==
2311 VarDecl::TentativeDefinition
2312 ? diag::err_alias_after_tentative
2313 : diag::err_redefinition;
2314 S.Diag(VD->getLocation(), Diag) << VD->getDeclName();
David Majnemer6b903562015-01-19 10:21:22 +00002315 S.Diag(Def->getLocation(), diag::note_previous_definition);
2316 VD->setInvalidDecl();
2317 }
Rafael Espindolad53ffa02013-10-22 21:39:03 +00002318 ++I;
2319 continue;
2320 }
2321
2322 if (const VarDecl *VD = dyn_cast<VarDecl>(Def)) {
2323 // Tentative definitions are only interesting for the alias check above.
2324 if (VD->isThisDeclarationADefinition() != VarDecl::Definition) {
2325 ++I;
2326 continue;
2327 }
2328 }
2329
Rafael Espindolafaf556b2012-07-15 01:33:40 +00002330 if (hasAttribute(Def, NewAttribute->getKind())) {
2331 ++I;
2332 continue; // regular attr merging will take care of validating this.
2333 }
Richard Smithbc8caaf2013-02-22 04:55:39 +00002334
Richard Smithdebc59d2013-01-30 05:45:05 +00002335 if (isa<C11NoReturnAttr>(NewAttribute)) {
Richard Smithbc8caaf2013-02-22 04:55:39 +00002336 // C's _Noreturn is allowed to be added to a function after it is defined.
Richard Smithdebc59d2013-01-30 05:45:05 +00002337 ++I;
2338 continue;
Richard Smithbc8caaf2013-02-22 04:55:39 +00002339 } else if (const AlignedAttr *AA = dyn_cast<AlignedAttr>(NewAttribute)) {
2340 if (AA->isAlignas()) {
2341 // C++11 [dcl.align]p6:
2342 // if any declaration of an entity has an alignment-specifier,
2343 // every defining declaration of that entity shall specify an
2344 // equivalent alignment.
2345 // C11 6.7.5/7:
2346 // If the definition of an object does not have an alignment
2347 // specifier, any other declaration of that object shall also
2348 // have no alignment specifier.
2349 S.Diag(Def->getLocation(), diag::err_alignas_missing_on_definition)
Aaron Ballman3d216a52014-01-02 23:39:11 +00002350 << AA;
Richard Smithbc8caaf2013-02-22 04:55:39 +00002351 S.Diag(NewAttribute->getLocation(), diag::note_alignas_on_declaration)
Aaron Ballman3d216a52014-01-02 23:39:11 +00002352 << AA;
Richard Smithbc8caaf2013-02-22 04:55:39 +00002353 NewAttributes.erase(NewAttributes.begin() + I);
2354 --E;
2355 continue;
2356 }
Richard Smithdebc59d2013-01-30 05:45:05 +00002357 }
Richard Smithbc8caaf2013-02-22 04:55:39 +00002358
Rafael Espindolafaf556b2012-07-15 01:33:40 +00002359 S.Diag(NewAttribute->getLocation(),
2360 diag::warn_attribute_precede_definition);
2361 S.Diag(Def->getLocation(), diag::note_previous_definition);
2362 NewAttributes.erase(NewAttributes.begin() + I);
2363 --E;
2364 }
2365}
2366
John McCallf79e87d2011-03-02 04:00:57 +00002367/// mergeDeclAttributes - Copy attributes from the Old decl to the New one.
Rafael Espindolaa3aea432013-01-08 22:04:34 +00002368void Sema::mergeDeclAttributes(NamedDecl *New, Decl *Old,
Douglas Gregor66a8ca02013-01-15 22:43:08 +00002369 AvailabilityMergeKind AMK) {
Rafael Espindolab0938852013-10-25 01:28:12 +00002370 if (UsedAttr *OldAttr = Old->getMostRecentDecl()->getAttr<UsedAttr>()) {
2371 UsedAttr *NewAttr = OldAttr->clone(Context);
2372 NewAttr->setInherited(true);
2373 New->addAttr(NewAttr);
2374 }
2375
Richard Smithe233fbf2013-01-28 22:42:45 +00002376 if (!Old->hasAttrs() && !New->hasAttrs())
2377 return;
2378
Rafael Espindola36191042012-05-18 01:47:00 +00002379 // attributes declared post-definition are currently ignored
Rafael Espindolafaf556b2012-07-15 01:33:40 +00002380 checkNewAttributesAfterDef(*this, New, Old);
Rafael Espindola36191042012-05-18 01:47:00 +00002381
Douglas Gregor32c17572012-01-01 20:30:41 +00002382 if (!Old->hasAttrs())
Alexis Huntdcfba7b2010-08-18 23:23:40 +00002383 return;
John McCallf79e87d2011-03-02 04:00:57 +00002384
Douglas Gregor32c17572012-01-01 20:30:41 +00002385 bool foundAny = New->hasAttrs();
John McCallf79e87d2011-03-02 04:00:57 +00002386
Alexis Huntdcfba7b2010-08-18 23:23:40 +00002387 // Ensure that any moving of objects within the allocated map is done before
2388 // we process them.
Douglas Gregor32c17572012-01-01 20:30:41 +00002389 if (!foundAny) New->setAttrs(AttrVec());
John McCallf79e87d2011-03-02 04:00:57 +00002390
Aaron Ballmanbe22bcb2014-03-10 17:08:28 +00002391 for (auto *I : Old->specific_attrs<InheritableAttr>()) {
Douglas Gregor66a8ca02013-01-15 22:43:08 +00002392 bool Override = false;
Douglas Gregorb1fa1482011-09-23 20:23:42 +00002393 // Ignore deprecated/unavailable/availability attributes if requested.
Aaron Ballmanbe22bcb2014-03-10 17:08:28 +00002394 if (isa<DeprecatedAttr>(I) ||
2395 isa<UnavailableAttr>(I) ||
2396 isa<AvailabilityAttr>(I)) {
Douglas Gregor66a8ca02013-01-15 22:43:08 +00002397 switch (AMK) {
2398 case AMK_None:
2399 continue;
John McCalld2930c22011-07-22 02:45:48 +00002400
Douglas Gregor66a8ca02013-01-15 22:43:08 +00002401 case AMK_Redeclaration:
2402 break;
2403
2404 case AMK_Override:
2405 Override = true;
2406 break;
2407 }
2408 }
2409
Rafael Espindolab0938852013-10-25 01:28:12 +00002410 // Already handled.
Aaron Ballmanbe22bcb2014-03-10 17:08:28 +00002411 if (isa<UsedAttr>(I))
Rafael Espindolab0938852013-10-25 01:28:12 +00002412 continue;
2413
Aaron Ballmanbe22bcb2014-03-10 17:08:28 +00002414 if (mergeDeclAttribute(*this, New, I, Override))
John McCallf79e87d2011-03-02 04:00:57 +00002415 foundAny = true;
Chris Lattner84966392008-03-03 03:28:21 +00002416 }
John McCallf79e87d2011-03-02 04:00:57 +00002417
Richard Smithbc8caaf2013-02-22 04:55:39 +00002418 if (mergeAlignedAttrs(*this, New, Old))
2419 foundAny = true;
2420
Douglas Gregor32c17572012-01-01 20:30:41 +00002421 if (!foundAny) New->dropAttrs();
John McCallf79e87d2011-03-02 04:00:57 +00002422}
2423
2424/// mergeParamDeclAttributes - Copy attributes from the old parameter
2425/// to the new one.
2426static void mergeParamDeclAttributes(ParmVarDecl *newDecl,
2427 const ParmVarDecl *oldDecl,
Richard Smithe233fbf2013-01-28 22:42:45 +00002428 Sema &S) {
2429 // C++11 [dcl.attr.depend]p2:
2430 // The first declaration of a function shall specify the
2431 // carries_dependency attribute for its declarator-id if any declaration
2432 // of the function specifies the carries_dependency attribute.
Aaron Ballmancf3b4832013-12-19 13:36:16 +00002433 const CarriesDependencyAttr *CDA = newDecl->getAttr<CarriesDependencyAttr>();
2434 if (CDA && !oldDecl->hasAttr<CarriesDependencyAttr>()) {
2435 S.Diag(CDA->getLocation(),
Richard Smithe233fbf2013-01-28 22:42:45 +00002436 diag::err_carries_dependency_missing_on_first_decl) << 1/*Param*/;
2437 // Find the first declaration of the parameter.
2438 // FIXME: Should we build redeclaration chains for function parameters?
2439 const FunctionDecl *FirstFD =
Rafael Espindola8db352d2013-10-17 15:37:26 +00002440 cast<FunctionDecl>(oldDecl->getDeclContext())->getFirstDecl();
Richard Smithe233fbf2013-01-28 22:42:45 +00002441 const ParmVarDecl *FirstVD =
2442 FirstFD->getParamDecl(oldDecl->getFunctionScopeIndex());
2443 S.Diag(FirstVD->getLocation(),
2444 diag::note_carries_dependency_missing_first_decl) << 1/*Param*/;
2445 }
2446
John McCallf79e87d2011-03-02 04:00:57 +00002447 if (!oldDecl->hasAttrs())
2448 return;
2449
2450 bool foundAny = newDecl->hasAttrs();
2451
2452 // Ensure that any moving of objects within the allocated map is
2453 // done before we process them.
2454 if (!foundAny) newDecl->setAttrs(AttrVec());
2455
Aaron Ballmanbe22bcb2014-03-10 17:08:28 +00002456 for (const auto *I : oldDecl->specific_attrs<InheritableParamAttr>()) {
2457 if (!DeclHasAttr(newDecl, I)) {
Richard Smithe233fbf2013-01-28 22:42:45 +00002458 InheritableAttr *newAttr =
Aaron Ballmanbe22bcb2014-03-10 17:08:28 +00002459 cast<InheritableParamAttr>(I->clone(S.Context));
John McCallf79e87d2011-03-02 04:00:57 +00002460 newAttr->setInherited(true);
2461 newDecl->addAttr(newAttr);
2462 foundAny = true;
2463 }
2464 }
2465
2466 if (!foundAny) newDecl->dropAttrs();
Chris Lattner84966392008-03-03 03:28:21 +00002467}
2468
Douglas Gregor261a89b2015-06-19 17:51:05 +00002469static void mergeParamDeclTypes(ParmVarDecl *NewParam,
2470 const ParmVarDecl *OldParam,
2471 Sema &S) {
2472 if (auto Oldnullability = OldParam->getType()->getNullability(S.Context)) {
2473 if (auto Newnullability = NewParam->getType()->getNullability(S.Context)) {
2474 if (*Oldnullability != *Newnullability) {
2475 S.Diag(NewParam->getLocation(), diag::warn_mismatched_nullability_attr)
Douglas Gregoraea7afd2015-06-24 22:02:08 +00002476 << DiagNullabilityKind(
2477 *Newnullability,
2478 ((NewParam->getObjCDeclQualifier() & Decl::OBJC_TQ_CSNullability)
2479 != 0))
2480 << DiagNullabilityKind(
2481 *Oldnullability,
2482 ((OldParam->getObjCDeclQualifier() & Decl::OBJC_TQ_CSNullability)
2483 != 0));
Douglas Gregor261a89b2015-06-19 17:51:05 +00002484 S.Diag(OldParam->getLocation(), diag::note_previous_declaration);
2485 }
Douglas Gregor83e32982015-06-22 17:19:03 +00002486 } else {
Douglas Gregor261a89b2015-06-19 17:51:05 +00002487 QualType NewT = NewParam->getType();
2488 NewT = S.Context.getAttributedType(
2489 AttributedType::getNullabilityAttrKind(*Oldnullability),
2490 NewT, NewT);
2491 NewParam->setType(NewT);
2492 }
2493 }
2494}
2495
Dan Gohman28ade552010-07-26 21:25:24 +00002496namespace {
2497
Douglas Gregora74a2972009-03-06 22:43:54 +00002498/// Used in MergeFunctionDecl to keep track of function parameters in
2499/// C.
2500struct GNUCompatibleParamWarning {
2501 ParmVarDecl *OldParm;
2502 ParmVarDecl *NewParm;
2503 QualType PromotedType;
2504};
2505
Alexander Kornienkoab9db512015-06-22 23:07:51 +00002506}
Anders Carlsson1f78b2b2009-12-04 22:33:25 +00002507
2508/// getSpecialMember - get the special member enum for a method.
Anders Carlsson05bf0092010-04-22 05:40:53 +00002509Sema::CXXSpecialMember Sema::getSpecialMember(const CXXMethodDecl *MD) {
Anders Carlsson1f78b2b2009-12-04 22:33:25 +00002510 if (const CXXConstructorDecl *Ctor = dyn_cast<CXXConstructorDecl>(MD)) {
Alexis Hunt80f00ff2011-05-10 19:08:14 +00002511 if (Ctor->isDefaultConstructor())
2512 return Sema::CXXDefaultConstructor;
Alexis Huntd051b872011-05-26 01:26:05 +00002513
2514 if (Ctor->isCopyConstructor())
2515 return Sema::CXXCopyConstructor;
2516
2517 if (Ctor->isMoveConstructor())
2518 return Sema::CXXMoveConstructor;
Alexis Hunt119c10e2011-05-25 23:16:36 +00002519 } else if (isa<CXXDestructorDecl>(MD)) {
Anders Carlsson1f78b2b2009-12-04 22:33:25 +00002520 return Sema::CXXDestructor;
Alexis Hunt119c10e2011-05-25 23:16:36 +00002521 } else if (MD->isCopyAssignmentOperator()) {
Alexis Hunt80f00ff2011-05-10 19:08:14 +00002522 return Sema::CXXCopyAssignment;
Sebastian Redle9c4e842011-09-04 18:14:28 +00002523 } else if (MD->isMoveAssignmentOperator()) {
2524 return Sema::CXXMoveAssignment;
Alexis Hunt119c10e2011-05-25 23:16:36 +00002525 }
Alexis Hunt80f00ff2011-05-10 19:08:14 +00002526
Alexis Hunt80f00ff2011-05-10 19:08:14 +00002527 return Sema::CXXInvalid;
Anders Carlsson1f78b2b2009-12-04 22:33:25 +00002528}
2529
David Majnemer5b63fa02014-06-18 23:26:25 +00002530// Determine whether the previous declaration was a definition, implicit
2531// declaration, or a declaration.
2532template <typename T>
2533static std::pair<diag::kind, SourceLocation>
2534getNoteDiagForInvalidRedeclaration(const T *Old, const T *New) {
2535 diag::kind PrevDiag;
2536 SourceLocation OldLocation = Old->getLocation();
2537 if (Old->isThisDeclarationADefinition())
2538 PrevDiag = diag::note_previous_definition;
2539 else if (Old->isImplicit()) {
2540 PrevDiag = diag::note_previous_implicit_declaration;
2541 if (OldLocation.isInvalid())
2542 OldLocation = New->getLocation();
2543 } else
2544 PrevDiag = diag::note_previous_declaration;
2545 return std::make_pair(PrevDiag, OldLocation);
2546}
2547
Sebastian Redl243d9052010-06-09 21:17:41 +00002548/// canRedefineFunction - checks if a function can be redefined. Currently,
Charles Davisfea48452010-02-18 02:00:42 +00002549/// only extern inline functions can be redefined, and even then only in
2550/// GNU89 mode.
2551static bool canRedefineFunction(const FunctionDecl *FD,
2552 const LangOptions& LangOpts) {
Eli Friedman51dd0182011-06-13 23:56:42 +00002553 return ((FD->hasAttr<GNUInlineAttr>() || LangOpts.GNUInline) &&
2554 !LangOpts.CPlusPlus &&
Charles Davisfea48452010-02-18 02:00:42 +00002555 FD->isInlineSpecified() &&
John McCall8e7d6562010-08-26 03:08:43 +00002556 FD->getStorageClass() == SC_Extern);
Charles Davisfea48452010-02-18 02:00:42 +00002557}
2558
Reid Kleckner78af0702013-08-27 23:08:25 +00002559const AttributedType *Sema::getCallingConvAttributedType(QualType T) const {
2560 const AttributedType *AT = T->getAs<AttributedType>();
2561 while (AT && !AT->isCallingConv())
2562 AT = AT->getModifiedType()->getAs<AttributedType>();
2563 return AT;
John McCalla5f46fb2012-08-25 02:00:03 +00002564}
2565
Benjamin Kramer3e350262013-02-15 12:30:38 +00002566template <typename T>
2567static bool haveIncompatibleLanguageLinkages(const T *Old, const T *New) {
Rafael Espindolaf4187652013-02-14 01:18:37 +00002568 const DeclContext *DC = Old->getDeclContext();
2569 if (DC->isRecord())
2570 return false;
2571
2572 LanguageLinkage OldLinkage = Old->getLanguageLinkage();
Rafael Espindola593537a2013-05-05 20:15:21 +00002573 if (OldLinkage == CXXLanguageLinkage && New->isInExternCContext())
Rafael Espindolaf4187652013-02-14 01:18:37 +00002574 return true;
Rafael Espindola593537a2013-05-05 20:15:21 +00002575 if (OldLinkage == CLanguageLinkage && New->isInExternCXXContext())
Rafael Espindolaf4187652013-02-14 01:18:37 +00002576 return true;
2577 return false;
2578}
2579
Chris Lattneraa9c7ae2008-04-08 04:40:51 +00002580/// MergeFunctionDecl - We just parsed a function 'New' from
2581/// declarator D which has the same name and scope as a previous
2582/// declaration 'Old'. Figure out how to resolve this situation,
2583/// merging decls or emitting diagnostics as appropriate.
Douglas Gregor5251f1b2008-10-21 16:13:35 +00002584///
2585/// In C++, New and Old must be declarations that are not
2586/// overloaded. Use IsOverload to determine whether New and Old are
2587/// overloaded, and to select the Old declaration that New should be
2588/// merged with.
Douglas Gregor75a45ba2009-02-16 17:45:42 +00002589///
2590/// Returns true if there was an error, false otherwise.
Richard Smith18819302014-02-06 01:31:33 +00002591bool Sema::MergeFunctionDecl(FunctionDecl *New, NamedDecl *&OldD,
2592 Scope *S, bool MergeTypeWithOld) {
Chris Lattnerc511efb2007-01-27 19:32:14 +00002593 // Verify the old decl was also a function.
Alp Tokera2794f92014-01-22 07:29:52 +00002594 FunctionDecl *Old = OldD->getAsFunction();
Chris Lattnerc511efb2007-01-27 19:32:14 +00002595 if (!Old) {
John McCalle29c5cd2009-12-10 19:51:03 +00002596 if (UsingShadowDecl *Shadow = dyn_cast<UsingShadowDecl>(OldD)) {
John McCallc70fca62013-04-03 21:19:47 +00002597 if (New->getFriendObjectKind()) {
2598 Diag(New->getLocation(), diag::err_using_decl_friend);
2599 Diag(Shadow->getTargetDecl()->getLocation(),
2600 diag::note_using_decl_target);
2601 Diag(Shadow->getUsingDecl()->getLocation(),
2602 diag::note_using_decl) << 0;
2603 return true;
2604 }
2605
Richard Smith18819302014-02-06 01:31:33 +00002606 // C++11 [namespace.udecl]p14:
2607 // If a function declaration in namespace scope or block scope has the
2608 // same name and the same parameter-type-list as a function introduced
2609 // by a using-declaration, and the declarations do not declare the same
2610 // function, the program is ill-formed.
2611
2612 // Check whether the two declarations might declare the same function.
2613 Old = dyn_cast<FunctionDecl>(Shadow->getTargetDecl());
2614 if (Old &&
2615 !Old->getDeclContext()->getRedeclContext()->Equals(
2616 New->getDeclContext()->getRedeclContext()) &&
2617 !(Old->isExternC() && New->isExternC()))
Craig Topperc3ec1492014-05-26 06:22:03 +00002618 Old = nullptr;
Richard Smith18819302014-02-06 01:31:33 +00002619
2620 if (!Old) {
2621 Diag(New->getLocation(), diag::err_using_decl_conflict_reverse);
2622 Diag(Shadow->getTargetDecl()->getLocation(),
2623 diag::note_using_decl_target);
2624 Diag(Shadow->getUsingDecl()->getLocation(), diag::note_using_decl) << 0;
2625 return true;
2626 }
2627 OldD = Old;
2628 } else {
2629 Diag(New->getLocation(), diag::err_redefinition_different_kind)
2630 << New->getDeclName();
2631 Diag(OldD->getLocation(), diag::note_previous_definition);
John McCalle29c5cd2009-12-10 19:51:03 +00002632 return true;
2633 }
Chris Lattnerc511efb2007-01-27 19:32:14 +00002634 }
Douglas Gregor5251f1b2008-10-21 16:13:35 +00002635
David Majnemerea5092a2013-07-07 23:49:50 +00002636 // If the old declaration is invalid, just give up here.
2637 if (Old->isInvalidDecl())
2638 return true;
2639
Douglas Gregor5251f1b2008-10-21 16:13:35 +00002640 diag::kind PrevDiag;
David Majnemer5b63fa02014-06-18 23:26:25 +00002641 SourceLocation OldLocation;
2642 std::tie(PrevDiag, OldLocation) =
2643 getNoteDiagForInvalidRedeclaration(Old, New);
Mike Stump11289f42009-09-09 15:08:12 +00002644
Charles Davisfea48452010-02-18 02:00:42 +00002645 // Don't complain about this if we're in GNU89 mode and the old function
2646 // is an extern inline function.
Rafael Espindola6ae7e502013-04-03 19:27:57 +00002647 // Don't complain about specializations. They are not supposed to have
2648 // storage classes.
Douglas Gregore62c0a42009-02-24 01:23:02 +00002649 if (!isa<CXXMethodDecl>(New) && !isa<CXXMethodDecl>(Old) &&
John McCall8e7d6562010-08-26 03:08:43 +00002650 New->getStorageClass() == SC_Static &&
Rafael Espindola3ae00052013-05-13 00:12:11 +00002651 Old->hasExternalFormalLinkage() &&
Rafael Espindola6ae7e502013-04-03 19:27:57 +00002652 !New->getTemplateSpecializationInfo() &&
David Blaikiebbafb8a2012-03-11 07:00:24 +00002653 !canRedefineFunction(Old, getLangOpts())) {
2654 if (getLangOpts().MicrosoftExt) {
David Majnemer5b63fa02014-06-18 23:26:25 +00002655 Diag(New->getLocation(), diag::ext_static_non_static) << New;
Richard Smithbdd14642014-02-04 01:14:30 +00002656 Diag(OldLocation, PrevDiag);
Francois Pichet6841a122011-04-22 19:50:06 +00002657 } else {
2658 Diag(New->getLocation(), diag::err_static_non_static) << New;
Richard Smithbdd14642014-02-04 01:14:30 +00002659 Diag(OldLocation, PrevDiag);
Francois Pichet6841a122011-04-22 19:50:06 +00002660 return true;
2661 }
Douglas Gregore62c0a42009-02-24 01:23:02 +00002662 }
2663
Reid Kleckner78af0702013-08-27 23:08:25 +00002664
2665 // If a function is first declared with a calling convention, but is later
2666 // declared or defined without one, all following decls assume the calling
2667 // convention of the first.
John McCallcddbad02010-02-04 05:44:44 +00002668 //
John McCalla5f46fb2012-08-25 02:00:03 +00002669 // It's OK if a function is first declared without a calling convention,
2670 // but is later declared or defined with the default calling convention.
2671 //
Reid Kleckner78af0702013-08-27 23:08:25 +00002672 // To test if either decl has an explicit calling convention, we look for
2673 // AttributedType sugar nodes on the type as written. If they are missing or
2674 // were canonicalized away, we assume the calling convention was implicit.
John McCallcddbad02010-02-04 05:44:44 +00002675 //
2676 // Note also that we DO NOT return at this point, because we still have
2677 // other tests to run.
Reid Kleckner78af0702013-08-27 23:08:25 +00002678 QualType OldQType = Context.getCanonicalType(Old->getType());
2679 QualType NewQType = Context.getCanonicalType(New->getType());
John McCall4f5019e2010-12-19 02:44:49 +00002680 const FunctionType *OldType = cast<FunctionType>(OldQType);
Reid Kleckner78af0702013-08-27 23:08:25 +00002681 const FunctionType *NewType = cast<FunctionType>(NewQType);
John McCall4f5019e2010-12-19 02:44:49 +00002682 FunctionType::ExtInfo OldTypeInfo = OldType->getExtInfo();
2683 FunctionType::ExtInfo NewTypeInfo = NewType->getExtInfo();
2684 bool RequiresAdjustment = false;
John McCalla5f46fb2012-08-25 02:00:03 +00002685
Reid Kleckner78af0702013-08-27 23:08:25 +00002686 if (OldTypeInfo.getCC() != NewTypeInfo.getCC()) {
Rafael Espindola8db352d2013-10-17 15:37:26 +00002687 FunctionDecl *First = Old->getFirstDecl();
Reid Kleckner78af0702013-08-27 23:08:25 +00002688 const FunctionType *FT =
2689 First->getType().getCanonicalType()->castAs<FunctionType>();
2690 FunctionType::ExtInfo FI = FT->getExtInfo();
2691 bool NewCCExplicit = getCallingConvAttributedType(New->getType());
2692 if (!NewCCExplicit) {
2693 // Inherit the CC from the previous declaration if it was specified
2694 // there but not here.
2695 NewTypeInfo = NewTypeInfo.withCallingConv(OldTypeInfo.getCC());
2696 RequiresAdjustment = true;
2697 } else {
2698 // Calling conventions aren't compatible, so complain.
2699 bool FirstCCExplicit = getCallingConvAttributedType(First->getType());
2700 Diag(New->getLocation(), diag::err_cconv_change)
2701 << FunctionType::getNameForCallConv(NewTypeInfo.getCC())
2702 << !FirstCCExplicit
2703 << (!FirstCCExplicit ? "" :
2704 FunctionType::getNameForCallConv(FI.getCC()));
John McCalla5f46fb2012-08-25 02:00:03 +00002705
Reid Kleckner78af0702013-08-27 23:08:25 +00002706 // Put the note on the first decl, since it is the one that matters.
2707 Diag(First->getLocation(), diag::note_previous_declaration);
2708 return true;
2709 }
John McCallcddbad02010-02-04 05:44:44 +00002710 }
2711
John McCallab26cfa2010-02-05 21:31:56 +00002712 // FIXME: diagnose the other way around?
John McCall4f5019e2010-12-19 02:44:49 +00002713 if (OldTypeInfo.getNoReturn() && !NewTypeInfo.getNoReturn()) {
2714 NewTypeInfo = NewTypeInfo.withNoReturn(true);
2715 RequiresAdjustment = true;
John McCallab26cfa2010-02-05 21:31:56 +00002716 }
2717
Douglas Gregor77e274f2010-06-18 21:30:25 +00002718 // Merge regparm attribute.
Eli Friedmanc5b20b52011-04-09 08:18:08 +00002719 if (OldTypeInfo.getHasRegParm() != NewTypeInfo.getHasRegParm() ||
2720 OldTypeInfo.getRegParm() != NewTypeInfo.getRegParm()) {
2721 if (NewTypeInfo.getHasRegParm()) {
Douglas Gregor77e274f2010-06-18 21:30:25 +00002722 Diag(New->getLocation(), diag::err_regparm_mismatch)
2723 << NewType->getRegParmType()
2724 << OldType->getRegParmType();
Richard Smithbdd14642014-02-04 01:14:30 +00002725 Diag(OldLocation, diag::note_previous_declaration);
Douglas Gregor77e274f2010-06-18 21:30:25 +00002726 return true;
2727 }
John McCall4f5019e2010-12-19 02:44:49 +00002728
2729 NewTypeInfo = NewTypeInfo.withRegParm(OldTypeInfo.getRegParm());
2730 RequiresAdjustment = true;
2731 }
2732
Douglas Gregorf1404d72011-10-14 15:55:40 +00002733 // Merge ns_returns_retained attribute.
2734 if (OldTypeInfo.getProducesResult() != NewTypeInfo.getProducesResult()) {
2735 if (NewTypeInfo.getProducesResult()) {
2736 Diag(New->getLocation(), diag::err_returns_retained_mismatch);
Richard Smithbdd14642014-02-04 01:14:30 +00002737 Diag(OldLocation, diag::note_previous_declaration);
Douglas Gregorf1404d72011-10-14 15:55:40 +00002738 return true;
2739 }
2740
2741 NewTypeInfo = NewTypeInfo.withProducesResult(true);
2742 RequiresAdjustment = true;
2743 }
2744
John McCall4f5019e2010-12-19 02:44:49 +00002745 if (RequiresAdjustment) {
Eli Friedmane934af82013-09-06 21:09:09 +00002746 const FunctionType *AdjustedType = New->getType()->getAs<FunctionType>();
2747 AdjustedType = Context.adjustFunctionType(AdjustedType, NewTypeInfo);
2748 New->setType(QualType(AdjustedType, 0));
John McCall4f5019e2010-12-19 02:44:49 +00002749 NewQType = Context.getCanonicalType(New->getType());
Eli Friedmane934af82013-09-06 21:09:09 +00002750 NewType = cast<FunctionType>(NewQType);
Douglas Gregor77e274f2010-06-18 21:30:25 +00002751 }
Nick Lewycky9c7eb1d2013-02-01 08:13:20 +00002752
2753 // If this redeclaration makes the function inline, we may need to add it to
2754 // UndefinedButUsed.
2755 if (!Old->isInlined() && New->isInlined() &&
2756 !New->hasAttr<GNUInlineAttr>() &&
Peter Collingbourne470d9422015-05-13 22:07:22 +00002757 !getLangOpts().GNUInline &&
Nick Lewycky9c7eb1d2013-02-01 08:13:20 +00002758 Old->isUsed(false) &&
2759 !Old->isDefined() && !New->isThisDeclarationADefinition())
2760 UndefinedButUsed.insert(std::make_pair(Old->getCanonicalDecl(),
2761 SourceLocation()));
2762
2763 // If this redeclaration makes it newly gnu_inline, we don't want to warn
2764 // about it.
2765 if (New->hasAttr<GNUInlineAttr>() &&
2766 Old->isInlined() && !Old->hasAttr<GNUInlineAttr>()) {
2767 UndefinedButUsed.erase(Old->getCanonicalDecl());
2768 }
Douglas Gregor77e274f2010-06-18 21:30:25 +00002769
David Blaikiebbafb8a2012-03-11 07:00:24 +00002770 if (getLangOpts().CPlusPlus) {
Douglas Gregor5251f1b2008-10-21 16:13:35 +00002771 // (C++98 13.1p2):
2772 // Certain function declarations cannot be overloaded:
Mike Stump11289f42009-09-09 15:08:12 +00002773 // -- Function declarations that differ only in the return type
Douglas Gregor5251f1b2008-10-21 16:13:35 +00002774 // cannot be overloaded.
Richard Smith2a7d4812013-05-04 07:00:32 +00002775
2776 // Go back to the type source info to compare the declared return types,
Richard Smithc58f38f2013-08-14 20:16:31 +00002777 // per C++1y [dcl.type.auto]p13:
Richard Smith2a7d4812013-05-04 07:00:32 +00002778 // Redeclarations or specializations of a function or function template
2779 // with a declared return type that uses a placeholder type shall also
2780 // use that placeholder, not a deduced type.
Alp Toker314cc812014-01-25 16:55:45 +00002781 QualType OldDeclaredReturnType =
2782 (Old->getTypeSourceInfo()
2783 ? Old->getTypeSourceInfo()->getType()->castAs<FunctionType>()
2784 : OldType)->getReturnType();
2785 QualType NewDeclaredReturnType =
2786 (New->getTypeSourceInfo()
2787 ? New->getTypeSourceInfo()->getType()->castAs<FunctionType>()
2788 : NewType)->getReturnType();
Fariborz Jahanianf633ebd2010-05-19 21:37:30 +00002789 QualType ResQT;
Richard Smith541b38b2013-09-20 01:15:31 +00002790 if (!Context.hasSameType(OldDeclaredReturnType, NewDeclaredReturnType) &&
2791 !((NewQType->isDependentType() || OldQType->isDependentType()) &&
2792 New->isLocalExternDecl())) {
Richard Smith2a7d4812013-05-04 07:00:32 +00002793 if (NewDeclaredReturnType->isObjCObjectPointerType() &&
2794 OldDeclaredReturnType->isObjCObjectPointerType())
Fariborz Jahanianf633ebd2010-05-19 21:37:30 +00002795 ResQT = Context.mergeObjCGCQualifiers(NewQType, OldQType);
2796 if (ResQT.isNull()) {
Argyrios Kyrtzidis3d320862011-02-05 05:54:49 +00002797 if (New->isCXXClassMember() && New->isOutOfLine())
Alp Tokerd0787eb2014-07-02 01:47:15 +00002798 Diag(New->getLocation(), diag::err_member_def_does_not_match_ret_type)
2799 << New << New->getReturnTypeSourceRange();
Argyrios Kyrtzidis3d320862011-02-05 05:54:49 +00002800 else
Alp Tokerd0787eb2014-07-02 01:47:15 +00002801 Diag(New->getLocation(), diag::err_ovl_diff_return_type)
2802 << New->getReturnTypeSourceRange();
2803 Diag(OldLocation, PrevDiag) << Old << Old->getType()
2804 << Old->getReturnTypeSourceRange();
Fariborz Jahanianf633ebd2010-05-19 21:37:30 +00002805 return true;
2806 }
2807 else
2808 NewQType = ResQT;
Douglas Gregor5251f1b2008-10-21 16:13:35 +00002809 }
2810
Alp Toker314cc812014-01-25 16:55:45 +00002811 QualType OldReturnType = OldType->getReturnType();
2812 QualType NewReturnType = cast<FunctionType>(NewQType)->getReturnType();
Richard Smith2a7d4812013-05-04 07:00:32 +00002813 if (OldReturnType != NewReturnType) {
2814 // If this function has a deduced return type and has already been
2815 // defined, copy the deduced value from the old declaration.
Alp Toker314cc812014-01-25 16:55:45 +00002816 AutoType *OldAT = Old->getReturnType()->getContainedAutoType();
Richard Smith2a7d4812013-05-04 07:00:32 +00002817 if (OldAT && OldAT->isDeduced()) {
Richard Smithc58f38f2013-08-14 20:16:31 +00002818 New->setType(
2819 SubstAutoType(New->getType(),
2820 OldAT->isDependentType() ? Context.DependentTy
2821 : OldAT->getDeducedType()));
Richard Smith2a7d4812013-05-04 07:00:32 +00002822 NewQType = Context.getCanonicalType(
Richard Smithc58f38f2013-08-14 20:16:31 +00002823 SubstAutoType(NewQType,
2824 OldAT->isDependentType() ? Context.DependentTy
2825 : OldAT->getDeducedType()));
Richard Smith2a7d4812013-05-04 07:00:32 +00002826 }
2827 }
2828
2829 const CXXMethodDecl *OldMethod = dyn_cast<CXXMethodDecl>(Old);
2830 CXXMethodDecl *NewMethod = dyn_cast<CXXMethodDecl>(New);
Anders Carlsson1f78b2b2009-12-04 22:33:25 +00002831 if (OldMethod && NewMethod) {
John McCall43314ab2010-04-13 07:45:41 +00002832 // Preserve triviality.
2833 NewMethod->setTrivial(OldMethod->isTrivial());
Francois Pichetc2fac712011-05-14 19:17:07 +00002834
Francois Pichet00c7e6c2011-08-14 03:52:19 +00002835 // MSVC allows explicit template specialization at class scope:
Alp Toker8db6e7a2014-01-05 06:38:57 +00002836 // 2 CXXMethodDecls referring to the same function will be injected.
2837 // We don't want a redeclaration error.
Francois Pichet00c7e6c2011-08-14 03:52:19 +00002838 bool IsClassScopeExplicitSpecialization =
2839 OldMethod->isFunctionTemplateSpecialization() &&
2840 NewMethod->isFunctionTemplateSpecialization();
John McCall43314ab2010-04-13 07:45:41 +00002841 bool isFriend = NewMethod->getFriendObjectKind();
2842
Francois Pichet00c7e6c2011-08-14 03:52:19 +00002843 if (!isFriend && NewMethod->getLexicalDeclContext()->isRecord() &&
2844 !IsClassScopeExplicitSpecialization) {
Anders Carlsson1f78b2b2009-12-04 22:33:25 +00002845 // -- Member function declarations with the same name and the
2846 // same parameter types cannot be overloaded if any of them
2847 // is a static member function declaration.
Eli Friedmanf26b81b2013-06-19 22:43:55 +00002848 if (OldMethod->isStatic() != NewMethod->isStatic()) {
Anders Carlsson1f78b2b2009-12-04 22:33:25 +00002849 Diag(New->getLocation(), diag::err_ovl_static_nonstatic_member);
Richard Smithbdd14642014-02-04 01:14:30 +00002850 Diag(OldLocation, PrevDiag) << Old << Old->getType();
Anders Carlsson1f78b2b2009-12-04 22:33:25 +00002851 return true;
2852 }
Richard Smith57e7ff92012-07-13 04:12:04 +00002853
Anders Carlsson1f78b2b2009-12-04 22:33:25 +00002854 // C++ [class.mem]p1:
2855 // [...] A member shall not be declared twice in the
2856 // member-specification, except that a nested class or member
2857 // class template can be declared and then later defined.
Richard Smith57e7ff92012-07-13 04:12:04 +00002858 if (ActiveTemplateInstantiations.empty()) {
2859 unsigned NewDiag;
2860 if (isa<CXXConstructorDecl>(OldMethod))
2861 NewDiag = diag::err_constructor_redeclared;
2862 else if (isa<CXXDestructorDecl>(NewMethod))
2863 NewDiag = diag::err_destructor_redeclared;
2864 else if (isa<CXXConversionDecl>(NewMethod))
2865 NewDiag = diag::err_conv_function_redeclared;
2866 else
2867 NewDiag = diag::err_member_redeclared;
Anders Carlsson1f78b2b2009-12-04 22:33:25 +00002868
Richard Smith57e7ff92012-07-13 04:12:04 +00002869 Diag(New->getLocation(), NewDiag);
2870 } else {
2871 Diag(New->getLocation(), diag::err_member_redeclared_in_instantiation)
2872 << New << New->getType();
2873 }
Richard Smithbdd14642014-02-04 01:14:30 +00002874 Diag(OldLocation, PrevDiag) << Old << Old->getType();
Nico Weber71e377d2015-01-17 02:33:17 +00002875 return true;
John McCall43314ab2010-04-13 07:45:41 +00002876
2877 // Complain if this is an explicit declaration of a special
2878 // member that was initially declared implicitly.
2879 //
2880 // As an exception, it's okay to befriend such methods in order
2881 // to permit the implicit constructor/destructor/operator calls.
2882 } else if (OldMethod->isImplicit()) {
2883 if (isFriend) {
2884 NewMethod->setImplicit();
2885 } else {
Anders Carlsson1f78b2b2009-12-04 22:33:25 +00002886 Diag(NewMethod->getLocation(),
2887 diag::err_definition_of_implicitly_declared_member)
Anders Carlsson05bf0092010-04-22 05:40:53 +00002888 << New << getSpecialMember(OldMethod);
Anders Carlsson1f78b2b2009-12-04 22:33:25 +00002889 return true;
2890 }
Richard Smith337a5a12012-06-08 01:30:54 +00002891 } else if (OldMethod->isExplicitlyDefaulted() && !isFriend) {
Alexis Hunt6d5b96c2011-05-10 00:49:42 +00002892 Diag(NewMethod->getLocation(),
2893 diag::err_definition_of_explicitly_defaulted_member)
2894 << getSpecialMember(OldMethod);
2895 return true;
Douglas Gregor5251f1b2008-10-21 16:13:35 +00002896 }
2897 }
2898
Richard Smith10876ef2013-01-17 01:30:42 +00002899 // C++11 [dcl.attr.noreturn]p1:
2900 // The first declaration of a function shall specify the noreturn
2901 // attribute if any declaration of that function specifies the noreturn
2902 // attribute.
Aaron Ballmancf3b4832013-12-19 13:36:16 +00002903 const CXX11NoReturnAttr *NRA = New->getAttr<CXX11NoReturnAttr>();
2904 if (NRA && !Old->hasAttr<CXX11NoReturnAttr>()) {
2905 Diag(NRA->getLocation(), diag::err_noreturn_missing_on_first_decl);
Rafael Espindola8db352d2013-10-17 15:37:26 +00002906 Diag(Old->getFirstDecl()->getLocation(),
Richard Smith10876ef2013-01-17 01:30:42 +00002907 diag::note_noreturn_missing_first_decl);
2908 }
2909
Richard Smithe233fbf2013-01-28 22:42:45 +00002910 // C++11 [dcl.attr.depend]p2:
2911 // The first declaration of a function shall specify the
2912 // carries_dependency attribute for its declarator-id if any declaration
2913 // of the function specifies the carries_dependency attribute.
Aaron Ballmancf3b4832013-12-19 13:36:16 +00002914 const CarriesDependencyAttr *CDA = New->getAttr<CarriesDependencyAttr>();
2915 if (CDA && !Old->hasAttr<CarriesDependencyAttr>()) {
2916 Diag(CDA->getLocation(),
Richard Smithe233fbf2013-01-28 22:42:45 +00002917 diag::err_carries_dependency_missing_on_first_decl) << 0/*Function*/;
Rafael Espindola8db352d2013-10-17 15:37:26 +00002918 Diag(Old->getFirstDecl()->getLocation(),
Richard Smithe233fbf2013-01-28 22:42:45 +00002919 diag::note_carries_dependency_missing_first_decl) << 0/*Function*/;
2920 }
2921
Douglas Gregor5251f1b2008-10-21 16:13:35 +00002922 // (C++98 8.3.5p3):
2923 // All declarations for a function shall agree exactly in both the
2924 // return type and the parameter-type-list.
John McCall4f5019e2010-12-19 02:44:49 +00002925 // We also want to respect all the extended bits except noreturn.
2926
2927 // noreturn should now match unless the old type info didn't have it.
2928 QualType OldQTypeForComparison = OldQType;
2929 if (!OldTypeInfo.getNoReturn() && NewTypeInfo.getNoReturn()) {
2930 assert(OldQType == QualType(OldType, 0));
2931 const FunctionType *OldTypeForComparison
2932 = Context.adjustFunctionType(OldType, OldTypeInfo.withNoReturn(true));
2933 OldQTypeForComparison = QualType(OldTypeForComparison, 0);
2934 assert(OldQTypeForComparison.isCanonical());
2935 }
2936
Rafael Espindolaf4187652013-02-14 01:18:37 +00002937 if (haveIncompatibleLanguageLinkages(Old, New)) {
Alp Tokerdd551fc2013-10-22 22:53:01 +00002938 // As a special case, retain the language linkage from previous
2939 // declarations of a friend function as an extension.
2940 //
2941 // This liberal interpretation of C++ [class.friend]p3 matches GCC/MSVC
2942 // and is useful because there's otherwise no way to specify language
2943 // linkage within class scope.
2944 //
2945 // Check cautiously as the friend object kind isn't yet complete.
2946 if (New->getFriendObjectKind() != Decl::FOK_None) {
2947 Diag(New->getLocation(), diag::ext_retained_language_linkage) << New;
Richard Smithbdd14642014-02-04 01:14:30 +00002948 Diag(OldLocation, PrevDiag);
Alp Tokerdd551fc2013-10-22 22:53:01 +00002949 } else {
2950 Diag(New->getLocation(), diag::err_different_language_linkage) << New;
Richard Smithbdd14642014-02-04 01:14:30 +00002951 Diag(OldLocation, PrevDiag);
Alp Tokerdd551fc2013-10-22 22:53:01 +00002952 return true;
2953 }
Rafael Espindolacffa95d2012-12-27 03:56:20 +00002954 }
2955
John McCall4f5019e2010-12-19 02:44:49 +00002956 if (OldQTypeForComparison == NewQType)
Richard Smith1c34fb72013-08-13 18:18:50 +00002957 return MergeCompatibleFunctionDecls(New, Old, S, MergeTypeWithOld);
Douglas Gregor5251f1b2008-10-21 16:13:35 +00002958
Richard Smith541b38b2013-09-20 01:15:31 +00002959 if ((NewQType->isDependentType() || OldQType->isDependentType()) &&
2960 New->isLocalExternDecl()) {
2961 // It's OK if we couldn't merge types for a local function declaraton
2962 // if either the old or new type is dependent. We'll merge the types
2963 // when we instantiate the function.
2964 return false;
2965 }
2966
Douglas Gregor5251f1b2008-10-21 16:13:35 +00002967 // Fall through for conflicting redeclarations and redefinitions.
Douglas Gregor89f238c2008-04-21 02:02:58 +00002968 }
Chris Lattneraa9c7ae2008-04-08 04:40:51 +00002969
2970 // C: Function types need to be compatible, not identical. This handles
Steve Naroff012484d2008-01-14 20:51:29 +00002971 // duplicate function decls like "void f(int); void f(enum X);" properly.
David Blaikiebbafb8a2012-03-11 07:00:24 +00002972 if (!getLangOpts().CPlusPlus &&
Eli Friedman47f77112008-08-22 00:56:42 +00002973 Context.typesAreCompatible(OldQType, NewQType)) {
John McCall9dd450b2009-09-21 23:43:11 +00002974 const FunctionType *OldFuncType = OldQType->getAs<FunctionType>();
2975 const FunctionType *NewFuncType = NewQType->getAs<FunctionType>();
Craig Topperc3ec1492014-05-26 06:22:03 +00002976 const FunctionProtoType *OldProto = nullptr;
Richard Smith1c34fb72013-08-13 18:18:50 +00002977 if (MergeTypeWithOld && isa<FunctionNoProtoType>(NewFuncType) &&
Douglas Gregora74a2972009-03-06 22:43:54 +00002978 (OldProto = dyn_cast<FunctionProtoType>(OldFuncType))) {
Douglas Gregorbcbf8632009-02-16 18:20:44 +00002979 // The old declaration provided a function prototype, but the
2980 // new declaration does not. Merge in the prototype.
Sebastian Redl5068f77ac2009-05-27 22:11:52 +00002981 assert(!OldProto->hasExceptionSpec() && "Exception spec in C");
Aaron Ballman40bd0aa2014-03-17 15:23:01 +00002982 SmallVector<QualType, 16> ParamTypes(OldProto->param_types());
Alp Toker314cc812014-01-25 16:55:45 +00002983 NewQType =
2984 Context.getFunctionType(NewFuncType->getReturnType(), ParamTypes,
2985 OldProto->getExtProtoInfo());
Douglas Gregorbcbf8632009-02-16 18:20:44 +00002986 New->setType(NewQType);
Anders Carlssone0dd1d52009-05-14 21:46:00 +00002987 New->setHasInheritedPrototype();
Douglas Gregorbfdd6072009-02-16 20:58:07 +00002988
Alp Toker4284c6e2014-05-11 16:05:55 +00002989 // Synthesize parameters with the same types.
Chris Lattner0e62c1c2011-07-23 10:55:15 +00002990 SmallVector<ParmVarDecl*, 16> Params;
Aaron Ballman40bd0aa2014-03-17 15:23:01 +00002991 for (const auto &ParamType : OldProto->param_types()) {
2992 ParmVarDecl *Param = ParmVarDecl::Create(Context, New, SourceLocation(),
Craig Topperc3ec1492014-05-26 06:22:03 +00002993 SourceLocation(), nullptr,
2994 ParamType, /*TInfo=*/nullptr,
2995 SC_None, nullptr);
John McCall8fb0d9d2011-05-01 22:35:37 +00002996 Param->setScopeInfo(0, Params.size());
Douglas Gregorbfdd6072009-02-16 20:58:07 +00002997 Param->setImplicit();
2998 Params.push_back(Param);
2999 }
3000
David Blaikie9c70e042011-09-21 18:16:56 +00003001 New->setParams(Params);
Mike Stump11289f42009-09-09 15:08:12 +00003002 }
Douglas Gregorbcbf8632009-02-16 18:20:44 +00003003
Richard Smith1c34fb72013-08-13 18:18:50 +00003004 return MergeCompatibleFunctionDecls(New, Old, S, MergeTypeWithOld);
Chris Lattneraa9c7ae2008-04-08 04:40:51 +00003005 }
Chris Lattner45d561a2007-11-06 06:07:26 +00003006
Douglas Gregora74a2972009-03-06 22:43:54 +00003007 // GNU C permits a K&R definition to follow a prototype declaration
3008 // if the declared types of the parameters in the K&R definition
3009 // match the types in the prototype declaration, even when the
3010 // promoted types of the parameters from the K&R definition differ
3011 // from the types in the prototype. GCC then keeps the types from
3012 // the prototype.
Eli Friedmanfcbf7d22009-06-01 09:24:59 +00003013 //
3014 // If a variadic prototype is followed by a non-variadic K&R definition,
3015 // the K&R definition becomes variadic. This is sort of an edge case, but
3016 // it's legal per the standard depending on how you read C99 6.7.5.3p15 and
3017 // C99 6.9.1p8.
David Blaikiebbafb8a2012-03-11 07:00:24 +00003018 if (!getLangOpts().CPlusPlus &&
Douglas Gregora74a2972009-03-06 22:43:54 +00003019 Old->hasPrototype() && !New->hasPrototype() &&
John McCall9dd450b2009-09-21 23:43:11 +00003020 New->getType()->getAs<FunctionProtoType>() &&
Douglas Gregora74a2972009-03-06 22:43:54 +00003021 Old->getNumParams() == New->getNumParams()) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003022 SmallVector<QualType, 16> ArgTypes;
3023 SmallVector<GNUCompatibleParamWarning, 16> Warnings;
Mike Stump11289f42009-09-09 15:08:12 +00003024 const FunctionProtoType *OldProto
John McCall9dd450b2009-09-21 23:43:11 +00003025 = Old->getType()->getAs<FunctionProtoType>();
Mike Stump11289f42009-09-09 15:08:12 +00003026 const FunctionProtoType *NewProto
John McCall9dd450b2009-09-21 23:43:11 +00003027 = New->getType()->getAs<FunctionProtoType>();
Mike Stump11289f42009-09-09 15:08:12 +00003028
Douglas Gregora74a2972009-03-06 22:43:54 +00003029 // Determine whether this is the GNU C extension.
Alp Toker314cc812014-01-25 16:55:45 +00003030 QualType MergedReturn = Context.mergeTypes(OldProto->getReturnType(),
3031 NewProto->getReturnType());
Eli Friedmanfcbf7d22009-06-01 09:24:59 +00003032 bool LooseCompatible = !MergedReturn.isNull();
Mike Stump11289f42009-09-09 15:08:12 +00003033 for (unsigned Idx = 0, End = Old->getNumParams();
Eli Friedmanfcbf7d22009-06-01 09:24:59 +00003034 LooseCompatible && Idx != End; ++Idx) {
Douglas Gregora74a2972009-03-06 22:43:54 +00003035 ParmVarDecl *OldParm = Old->getParamDecl(Idx);
3036 ParmVarDecl *NewParm = New->getParamDecl(Idx);
Mike Stump11289f42009-09-09 15:08:12 +00003037 if (Context.typesAreCompatible(OldParm->getType(),
Alp Toker9cacbab2014-01-20 20:26:09 +00003038 NewProto->getParamType(Idx))) {
Douglas Gregora74a2972009-03-06 22:43:54 +00003039 ArgTypes.push_back(NewParm->getType());
3040 } else if (Context.typesAreCompatible(OldParm->getType(),
Douglas Gregor17ea3f52010-07-29 15:18:02 +00003041 NewParm->getType(),
3042 /*CompareUnqualified=*/true)) {
Alp Toker9cacbab2014-01-20 20:26:09 +00003043 GNUCompatibleParamWarning Warn = { OldParm, NewParm,
3044 NewProto->getParamType(Idx) };
Douglas Gregora74a2972009-03-06 22:43:54 +00003045 Warnings.push_back(Warn);
3046 ArgTypes.push_back(NewParm->getType());
3047 } else
Eli Friedmanfcbf7d22009-06-01 09:24:59 +00003048 LooseCompatible = false;
Douglas Gregora74a2972009-03-06 22:43:54 +00003049 }
3050
Eli Friedmanfcbf7d22009-06-01 09:24:59 +00003051 if (LooseCompatible) {
Douglas Gregora74a2972009-03-06 22:43:54 +00003052 for (unsigned Warn = 0; Warn < Warnings.size(); ++Warn) {
3053 Diag(Warnings[Warn].NewParm->getLocation(),
3054 diag::ext_param_promoted_not_compatible_with_prototype)
3055 << Warnings[Warn].PromotedType
3056 << Warnings[Warn].OldParm->getType();
Douglas Gregor17ea3f52010-07-29 15:18:02 +00003057 if (Warnings[Warn].OldParm->getLocation().isValid())
3058 Diag(Warnings[Warn].OldParm->getLocation(),
3059 diag::note_previous_declaration);
Douglas Gregora74a2972009-03-06 22:43:54 +00003060 }
3061
Richard Smith1c34fb72013-08-13 18:18:50 +00003062 if (MergeTypeWithOld)
3063 New->setType(Context.getFunctionType(MergedReturn, ArgTypes,
3064 OldProto->getExtProtoInfo()));
3065 return MergeCompatibleFunctionDecls(New, Old, S, MergeTypeWithOld);
Douglas Gregora74a2972009-03-06 22:43:54 +00003066 }
3067
3068 // Fall through to diagnose conflicting types.
3069 }
3070
John McCallad327cd2013-04-14 08:50:55 +00003071 // A function that has already been declared has been redeclared or
3072 // defined with a different type; show an appropriate diagnostic.
3073
3074 // If the previous declaration was an implicitly-generated builtin
3075 // declaration, then at the very least we should use a specialized note.
3076 unsigned BuiltinID;
3077 if (Old->isImplicit() && (BuiltinID = Old->getBuiltinID())) {
3078 // If it's actually a library-defined builtin function like 'malloc'
3079 // or 'printf', just warn about the incompatible redeclaration.
Douglas Gregor75a45ba2009-02-16 17:45:42 +00003080 if (Context.BuiltinInfo.isPredefinedLibFunction(BuiltinID)) {
Douglas Gregor75a45ba2009-02-16 17:45:42 +00003081 Diag(New->getLocation(), diag::warn_redecl_library_builtin) << New;
Richard Smithbdd14642014-02-04 01:14:30 +00003082 Diag(OldLocation, diag::note_previous_builtin_declaration)
Douglas Gregor75a45ba2009-02-16 17:45:42 +00003083 << Old << Old->getType();
John McCallad327cd2013-04-14 08:50:55 +00003084
3085 // If this is a global redeclaration, just forget hereafter
3086 // about the "builtin-ness" of the function.
3087 //
3088 // Doing this for local extern declarations is problematic. If
3089 // the builtin declaration remains visible, a second invalid
3090 // local declaration will produce a hard error; if it doesn't
3091 // remain visible, a single bogus local redeclaration (which is
3092 // actually only a warning) could break all the downstream code.
Richard Smith541b38b2013-09-20 01:15:31 +00003093 if (!New->getLexicalDeclContext()->isFunctionOrMethod())
John McCallad327cd2013-04-14 08:50:55 +00003094 New->getIdentifier()->setBuiltinID(Builtin::NotBuiltin);
3095
Douglas Gregor893c2c92009-03-23 17:47:24 +00003096 return false;
Douglas Gregor75a45ba2009-02-16 17:45:42 +00003097 }
Steve Naroff17832a42008-01-16 15:01:34 +00003098
Douglas Gregor75a45ba2009-02-16 17:45:42 +00003099 PrevDiag = diag::note_previous_builtin_declaration;
3100 }
3101
Chris Lattnerf3d3fae2008-11-24 05:29:24 +00003102 Diag(New->getLocation(), diag::err_conflicting_types) << New->getDeclName();
Richard Smithbdd14642014-02-04 01:14:30 +00003103 Diag(OldLocation, PrevDiag) << Old << Old->getType();
Douglas Gregor75a45ba2009-02-16 17:45:42 +00003104 return true;
Chris Lattner01564d92007-01-27 19:27:06 +00003105}
3106
Douglas Gregore62c0a42009-02-24 01:23:02 +00003107/// \brief Completes the merge of two function declarations that are
Mike Stump11289f42009-09-09 15:08:12 +00003108/// known to be compatible.
Douglas Gregore62c0a42009-02-24 01:23:02 +00003109///
3110/// This routine handles the merging of attributes and other
Alp Toker5f6b8ac2013-10-22 09:00:49 +00003111/// properties of function declarations from the old declaration to
Douglas Gregore62c0a42009-02-24 01:23:02 +00003112/// the new declaration, once we know that New is in fact a
3113/// redeclaration of Old.
3114///
3115/// \returns false
James Molloye9430032012-03-13 08:55:35 +00003116bool Sema::MergeCompatibleFunctionDecls(FunctionDecl *New, FunctionDecl *Old,
Richard Smith1c34fb72013-08-13 18:18:50 +00003117 Scope *S, bool MergeTypeWithOld) {
Douglas Gregore62c0a42009-02-24 01:23:02 +00003118 // Merge the attributes
Douglas Gregor32c17572012-01-01 20:30:41 +00003119 mergeDeclAttributes(New, Old);
Douglas Gregore62c0a42009-02-24 01:23:02 +00003120
Douglas Gregore62c0a42009-02-24 01:23:02 +00003121 // Merge "pure" flag.
3122 if (Old->isPure())
3123 New->setPure();
3124
Rafael Espindolabefe1302012-11-25 14:07:59 +00003125 // Merge "used" flag.
Rafael Espindolae4865d22013-10-23 16:46:34 +00003126 if (Old->getMostRecentDecl()->isUsed(false))
3127 New->setIsUsed();
Rafael Espindolabefe1302012-11-25 14:07:59 +00003128
John McCallf79e87d2011-03-02 04:00:57 +00003129 // Merge attributes from the parameters. These can mismatch with K&R
3130 // declarations.
3131 if (New->getNumParams() == Old->getNumParams())
Douglas Gregor261a89b2015-06-19 17:51:05 +00003132 for (unsigned i = 0, e = New->getNumParams(); i != e; ++i) {
3133 ParmVarDecl *NewParam = New->getParamDecl(i);
3134 ParmVarDecl *OldParam = Old->getParamDecl(i);
3135 mergeParamDeclAttributes(NewParam, OldParam, *this);
3136 mergeParamDeclTypes(NewParam, OldParam, *this);
3137 }
John McCallf79e87d2011-03-02 04:00:57 +00003138
David Blaikiebbafb8a2012-03-11 07:00:24 +00003139 if (getLangOpts().CPlusPlus)
James Molloye9430032012-03-13 08:55:35 +00003140 return MergeCXXFunctionDecl(New, Old, S);
Douglas Gregore62c0a42009-02-24 01:23:02 +00003141
Rafael Espindola8778c282012-11-29 16:09:03 +00003142 // Merge the function types so the we get the composite types for the return
Richard Smith1c34fb72013-08-13 18:18:50 +00003143 // and argument types. Per C11 6.2.7/4, only update the type if the old decl
3144 // was visible.
Rafael Espindola8778c282012-11-29 16:09:03 +00003145 QualType Merged = Context.mergeTypes(Old->getType(), New->getType());
Richard Smith1c34fb72013-08-13 18:18:50 +00003146 if (!Merged.isNull() && MergeTypeWithOld)
Rafael Espindola8778c282012-11-29 16:09:03 +00003147 New->setType(Merged);
3148
Douglas Gregore62c0a42009-02-24 01:23:02 +00003149 return false;
3150}
3151
John McCall31168b02011-06-15 23:02:42 +00003152
John McCallf79e87d2011-03-02 04:00:57 +00003153void Sema::mergeObjCMethodDecls(ObjCMethodDecl *newMethod,
Douglas Gregor32c17572012-01-01 20:30:41 +00003154 ObjCMethodDecl *oldMethod) {
John McCalld2930c22011-07-22 02:45:48 +00003155
Fariborz Jahanian3da28f82012-06-05 21:14:46 +00003156 // Merge the attributes, including deprecated/unavailable
Ted Kremenekb5445722013-04-06 00:34:27 +00003157 AvailabilityMergeKind MergeKind =
3158 isa<ObjCImplDecl>(newMethod->getDeclContext()) ? AMK_Redeclaration
3159 : AMK_Override;
3160 mergeDeclAttributes(newMethod, oldMethod, MergeKind);
John McCallf79e87d2011-03-02 04:00:57 +00003161
3162 // Merge attributes from the parameters.
Douglas Gregor0bf70f42012-05-17 23:13:29 +00003163 ObjCMethodDecl::param_const_iterator oi = oldMethod->param_begin(),
3164 oe = oldMethod->param_end();
Argyrios Kyrtzidisb8c3aaf2011-10-03 06:37:04 +00003165 for (ObjCMethodDecl::param_iterator
John McCallf79e87d2011-03-02 04:00:57 +00003166 ni = newMethod->param_begin(), ne = newMethod->param_end();
Douglas Gregor0bf70f42012-05-17 23:13:29 +00003167 ni != ne && oi != oe; ++ni, ++oi)
Richard Smithe233fbf2013-01-28 22:42:45 +00003168 mergeParamDeclAttributes(*ni, *oi, *this);
John McCalld2930c22011-07-22 02:45:48 +00003169
Douglas Gregor66a8ca02013-01-15 22:43:08 +00003170 CheckObjCMethodOverride(newMethod, oldMethod);
John McCallf79e87d2011-03-02 04:00:57 +00003171}
3172
Sebastian Redlfa453cf2011-03-12 11:50:43 +00003173/// MergeVarDeclTypes - We parsed a variable 'New' which has the same name and
3174/// scope as a previous declaration 'Old'. Figure out how to merge their types,
Richard Smith30482bc2011-02-20 03:19:35 +00003175/// emitting diagnostics as appropriate.
3176///
3177/// Declarations using the auto type specifier (C++ [decl.spec.auto]) call back
Sebastian Redla9351792012-02-11 23:51:47 +00003178/// to here in AddInitializerToDecl. We can't check them before the initializer
3179/// is attached.
Richard Smith1c34fb72013-08-13 18:18:50 +00003180void Sema::MergeVarDeclTypes(VarDecl *New, VarDecl *Old,
3181 bool MergeTypeWithOld) {
Richard Smith30482bc2011-02-20 03:19:35 +00003182 if (New->isInvalidDecl() || Old->isInvalidDecl())
3183 return;
3184
3185 QualType MergedT;
David Blaikiebbafb8a2012-03-11 07:00:24 +00003186 if (getLangOpts().CPlusPlus) {
Richard Smith27d807c2013-04-30 13:56:41 +00003187 if (New->getType()->isUndeducedType()) {
Richard Smith30482bc2011-02-20 03:19:35 +00003188 // We don't know what the new type is until the initializer is attached.
3189 return;
Sebastian Redlfa453cf2011-03-12 11:50:43 +00003190 } else if (Context.hasSameType(New->getType(), Old->getType())) {
3191 // These could still be something that needs exception specs checked.
3192 return MergeVarDeclExceptionSpecs(New, Old);
3193 }
Richard Smith30482bc2011-02-20 03:19:35 +00003194 // C++ [basic.link]p10:
3195 // [...] the types specified by all declarations referring to a given
3196 // object or function shall be identical, except that declarations for an
3197 // array object can specify array types that differ by the presence or
3198 // absence of a major array bound (8.3.4).
3199 else if (Old->getType()->isIncompleteArrayType() &&
3200 New->getType()->isArrayType()) {
Eli Friedman07bab732012-12-13 01:43:21 +00003201 const ArrayType *OldArray = Context.getAsArrayType(Old->getType());
3202 const ArrayType *NewArray = Context.getAsArrayType(New->getType());
3203 if (Context.hasSameType(OldArray->getElementType(),
3204 NewArray->getElementType()))
Richard Smith30482bc2011-02-20 03:19:35 +00003205 MergedT = New->getType();
3206 } else if (Old->getType()->isArrayType() &&
Richard Smith541b38b2013-09-20 01:15:31 +00003207 New->getType()->isIncompleteArrayType()) {
Eli Friedman07bab732012-12-13 01:43:21 +00003208 const ArrayType *OldArray = Context.getAsArrayType(Old->getType());
3209 const ArrayType *NewArray = Context.getAsArrayType(New->getType());
3210 if (Context.hasSameType(OldArray->getElementType(),
3211 NewArray->getElementType()))
Richard Smith30482bc2011-02-20 03:19:35 +00003212 MergedT = Old->getType();
Richard Smith541b38b2013-09-20 01:15:31 +00003213 } else if (New->getType()->isObjCObjectPointerType() &&
3214 Old->getType()->isObjCObjectPointerType()) {
3215 MergedT = Context.mergeObjCGCQualifiers(New->getType(),
3216 Old->getType());
Richard Smith30482bc2011-02-20 03:19:35 +00003217 }
3218 } else {
Richard Smith541b38b2013-09-20 01:15:31 +00003219 // C 6.2.7p2:
3220 // All declarations that refer to the same object or function shall have
3221 // compatible type.
Richard Smith30482bc2011-02-20 03:19:35 +00003222 MergedT = Context.mergeTypes(New->getType(), Old->getType());
3223 }
3224 if (MergedT.isNull()) {
Richard Smith1c34fb72013-08-13 18:18:50 +00003225 // It's OK if we couldn't merge types if either type is dependent, for a
3226 // block-scope variable. In other cases (static data members of class
3227 // templates, variable templates, ...), we require the types to be
3228 // equivalent.
3229 // FIXME: The C++ standard doesn't say anything about this.
3230 if ((New->getType()->isDependentType() ||
3231 Old->getType()->isDependentType()) && New->isLocalVarDecl()) {
3232 // If the old type was dependent, we can't merge with it, so the new type
3233 // becomes dependent for now. We'll reproduce the original type when we
3234 // instantiate the TypeSourceInfo for the variable.
3235 if (!New->getType()->isDependentType() && MergeTypeWithOld)
3236 New->setType(Context.DependentTy);
3237 return;
3238 }
3239
3240 // FIXME: Even if this merging succeeds, some other non-visible declaration
3241 // of this variable might have an incompatible type. For instance:
3242 //
3243 // extern int arr[];
3244 // void f() { extern int arr[2]; }
3245 // void g() { extern int arr[3]; }
3246 //
3247 // Neither C nor C++ requires a diagnostic for this, but we should still try
3248 // to diagnose it.
Richard Smith30482bc2011-02-20 03:19:35 +00003249 Diag(New->getLocation(), diag::err_redefinition_different_type)
David Blaikie65902202012-09-20 18:38:57 +00003250 << New->getDeclName() << New->getType() << Old->getType();
Richard Smith30482bc2011-02-20 03:19:35 +00003251 Diag(Old->getLocation(), diag::note_previous_definition);
3252 return New->setInvalidDecl();
3253 }
John McCallb65e8fe2013-04-01 18:34:28 +00003254
3255 // Don't actually update the type on the new declaration if the old
Richard Smith3c785782013-09-03 21:00:58 +00003256 // declaration was an extern declaration in a different scope.
Richard Smith1c34fb72013-08-13 18:18:50 +00003257 if (MergeTypeWithOld)
John McCallb65e8fe2013-04-01 18:34:28 +00003258 New->setType(MergedT);
Richard Smith30482bc2011-02-20 03:19:35 +00003259}
3260
Richard Smith3c785782013-09-03 21:00:58 +00003261static bool mergeTypeWithPrevious(Sema &S, VarDecl *NewVD, VarDecl *OldVD,
3262 LookupResult &Previous) {
3263 // C11 6.2.7p4:
3264 // For an identifier with internal or external linkage declared
3265 // in a scope in which a prior declaration of that identifier is
3266 // visible, if the prior declaration specifies internal or
3267 // external linkage, the type of the identifier at the later
3268 // declaration becomes the composite type.
3269 //
3270 // If the variable isn't visible, we do not merge with its type.
3271 if (Previous.isShadowed())
3272 return false;
3273
3274 if (S.getLangOpts().CPlusPlus) {
3275 // C++11 [dcl.array]p3:
3276 // If there is a preceding declaration of the entity in the same
3277 // scope in which the bound was specified, an omitted array bound
3278 // is taken to be the same as in that earlier declaration.
3279 return NewVD->isPreviousDeclInSameBlockScope() ||
3280 (!OldVD->getLexicalDeclContext()->isFunctionOrMethod() &&
3281 !NewVD->getLexicalDeclContext()->isFunctionOrMethod());
3282 } else {
3283 // If the old declaration was function-local, don't merge with its
3284 // type unless we're in the same function.
3285 return !OldVD->getLexicalDeclContext()->isFunctionOrMethod() ||
3286 OldVD->getLexicalDeclContext() == NewVD->getLexicalDeclContext();
3287 }
3288}
3289
Chris Lattner01564d92007-01-27 19:27:06 +00003290/// MergeVarDecl - We just parsed a variable 'New' which has the same name
3291/// and scope as a previous declaration 'Old'. Figure out how to resolve this
3292/// situation, merging decls or emitting diagnostics as appropriate.
3293///
Mike Stump11289f42009-09-09 15:08:12 +00003294/// Tentative definition rules (C99 6.9.2p2) are checked by
3295/// FinalizeDeclaratorGroup. Unfortunately, we can't analyze tentative
Steve Naroff5bb8f222008-08-08 17:50:35 +00003296/// definitions here, since the initializer hasn't been attached.
Mike Stump11289f42009-09-09 15:08:12 +00003297///
Richard Smith3c785782013-09-03 21:00:58 +00003298void Sema::MergeVarDecl(VarDecl *New, LookupResult &Previous) {
John McCall1f82f242009-11-18 22:49:29 +00003299 // If the new decl is already invalid, don't do any other checking.
3300 if (New->isInvalidDecl())
3301 return;
Mike Stump11289f42009-09-09 15:08:12 +00003302
Richard Smithbeef3452014-01-16 23:39:20 +00003303 VarTemplateDecl *NewTemplate = New->getDescribedVarTemplate();
3304
Larisse Voufod8dd97c2013-08-14 03:09:19 +00003305 // Verify the old decl was also a variable or variable template.
Craig Topperc3ec1492014-05-26 06:22:03 +00003306 VarDecl *Old = nullptr;
3307 VarTemplateDecl *OldTemplate = nullptr;
Richard Smithbeef3452014-01-16 23:39:20 +00003308 if (Previous.isSingleResult()) {
3309 if (NewTemplate) {
3310 OldTemplate = dyn_cast<VarTemplateDecl>(Previous.getFoundDecl());
Craig Topperc3ec1492014-05-26 06:22:03 +00003311 Old = OldTemplate ? OldTemplate->getTemplatedDecl() : nullptr;
Richard Smithbeef3452014-01-16 23:39:20 +00003312 } else
3313 Old = dyn_cast<VarDecl>(Previous.getFoundDecl());
Larisse Voufod8dd97c2013-08-14 03:09:19 +00003314 }
3315 if (!Old) {
Chris Lattner651d42d2008-11-20 06:38:18 +00003316 Diag(New->getLocation(), diag::err_redefinition_different_kind)
Chris Lattnere3d20d92008-11-23 21:45:46 +00003317 << New->getDeclName();
John McCall1f82f242009-11-18 22:49:29 +00003318 Diag(Previous.getRepresentativeDecl()->getLocation(),
3319 diag::note_previous_definition);
Chris Lattnerf6d1c9c2009-04-25 08:06:05 +00003320 return New->setInvalidDecl();
Chris Lattnerc511efb2007-01-27 19:32:14 +00003321 }
Chris Lattner84966392008-03-03 03:28:21 +00003322
Rafael Espindola5bddd6a2013-04-15 12:49:13 +00003323 if (!shouldLinkPossiblyHiddenDecl(Old, New))
3324 return;
3325
Richard Smithbeef3452014-01-16 23:39:20 +00003326 // Ensure the template parameters are compatible.
3327 if (NewTemplate &&
3328 !TemplateParameterListsAreEqual(NewTemplate->getTemplateParameters(),
3329 OldTemplate->getTemplateParameters(),
3330 /*Complain=*/true, TPL_TemplateMatch))
3331 return;
3332
Douglas Gregor2c7d9292010-08-30 14:32:14 +00003333 // C++ [class.mem]p1:
3334 // A member shall not be declared twice in the member-specification [...]
3335 //
3336 // Here, we need only consider static data members.
3337 if (Old->isStaticDataMember() && !New->isOutOfLine()) {
3338 Diag(New->getLocation(), diag::err_duplicate_member)
3339 << New->getIdentifier();
3340 Diag(Old->getLocation(), diag::note_previous_declaration);
3341 New->setInvalidDecl();
3342 }
3343
Douglas Gregor32c17572012-01-01 20:30:41 +00003344 mergeDeclAttributes(New, Old);
David Blaikie30d15442011-10-19 22:56:21 +00003345 // Warn if an already-declared variable is made a weak_import in a subsequent
3346 // declaration
Aaron Ballman9ead1242013-12-19 02:39:40 +00003347 if (New->hasAttr<WeakImportAttr>() &&
Fariborz Jahanianab578bf2011-06-20 17:50:03 +00003348 Old->getStorageClass() == SC_None &&
Aaron Ballman9ead1242013-12-19 02:39:40 +00003349 !Old->hasAttr<WeakImportAttr>()) {
Fariborz Jahanian33e02262011-06-22 22:08:50 +00003350 Diag(New->getLocation(), diag::warn_weak_import) << New->getDeclName();
3351 Diag(Old->getLocation(), diag::note_previous_definition);
3352 // Remove weak_import attribute on new declaration.
Fariborz Jahanian0dfc9502011-06-23 17:50:10 +00003353 New->dropAttr<WeakImportAttr>();
Fariborz Jahanian33e02262011-06-22 22:08:50 +00003354 }
Chris Lattner84966392008-03-03 03:28:21 +00003355
Richard Smith30482bc2011-02-20 03:19:35 +00003356 // Merge the types.
David Majnemerce12ed22015-01-14 02:27:38 +00003357 VarDecl *MostRecent = Old->getMostRecentDecl();
3358 if (MostRecent != Old) {
3359 MergeVarDeclTypes(New, MostRecent,
3360 mergeTypeWithPrevious(*this, New, MostRecent, Previous));
3361 if (New->isInvalidDecl())
3362 return;
3363 }
Richard Smith3c785782013-09-03 21:00:58 +00003364
David Majnemerce12ed22015-01-14 02:27:38 +00003365 MergeVarDeclTypes(New, Old, mergeTypeWithPrevious(*this, New, Old, Previous));
Richard Smith30482bc2011-02-20 03:19:35 +00003366 if (New->isInvalidDecl())
3367 return;
Douglas Gregor04e9a032009-03-11 23:52:16 +00003368
David Majnemer5b63fa02014-06-18 23:26:25 +00003369 diag::kind PrevDiag;
3370 SourceLocation OldLocation;
3371 std::tie(PrevDiag, OldLocation) =
3372 getNoteDiagForInvalidRedeclaration(Old, New);
3373
Rafael Espindola8ac2f592013-04-04 21:21:25 +00003374 // [dcl.stc]p8: Check if we have a non-static decl followed by a static.
John McCall8e7d6562010-08-26 03:08:43 +00003375 if (New->getStorageClass() == SC_Static &&
Rafael Espindola8ac2f592013-04-04 21:21:25 +00003376 !New->isStaticDataMember() &&
Rafael Espindola3ae00052013-05-13 00:12:11 +00003377 Old->hasExternalFormalLinkage()) {
David Majnemer5b63fa02014-06-18 23:26:25 +00003378 if (getLangOpts().MicrosoftExt) {
3379 Diag(New->getLocation(), diag::ext_static_non_static)
3380 << New->getDeclName();
3381 Diag(OldLocation, PrevDiag);
3382 } else {
3383 Diag(New->getLocation(), diag::err_static_non_static)
3384 << New->getDeclName();
3385 Diag(OldLocation, PrevDiag);
3386 return New->setInvalidDecl();
3387 }
Steve Naroff1e787362008-01-30 00:44:01 +00003388 }
Mike Stump11289f42009-09-09 15:08:12 +00003389 // C99 6.2.2p4:
Douglas Gregor37311622009-03-19 22:01:50 +00003390 // For an identifier declared with the storage-class specifier
3391 // extern in a scope in which a prior declaration of that
3392 // identifier is visible,23) if the prior declaration specifies
3393 // internal or external linkage, the linkage of the identifier at
3394 // the later declaration is the same as the linkage specified at
3395 // the prior declaration. If no prior declaration is visible, or
3396 // if the prior declaration specifies no linkage, then the
3397 // identifier has external linkage.
Douglas Gregord4eca012009-03-23 16:17:01 +00003398 if (New->hasExternalStorage() && Old->hasLinkage())
Douglas Gregor37311622009-03-19 22:01:50 +00003399 /* Okay */;
Rafael Espindola6ae7e502013-04-03 19:27:57 +00003400 else if (New->getCanonicalDecl()->getStorageClass() != SC_Static &&
Rafael Espindola8ac2f592013-04-04 21:21:25 +00003401 !New->isStaticDataMember() &&
Rafael Espindola6ae7e502013-04-03 19:27:57 +00003402 Old->getCanonicalDecl()->getStorageClass() == SC_Static) {
Chris Lattnerf3d3fae2008-11-24 05:29:24 +00003403 Diag(New->getLocation(), diag::err_non_static_static) << New->getDeclName();
David Majnemer5b63fa02014-06-18 23:26:25 +00003404 Diag(OldLocation, PrevDiag);
Chris Lattnerf6d1c9c2009-04-25 08:06:05 +00003405 return New->setInvalidDecl();
Steve Naroff1e787362008-01-30 00:44:01 +00003406 }
Daniel Dunbar0ca16602009-04-14 02:25:56 +00003407
Argyrios Kyrtzidis819f6102011-01-31 07:04:46 +00003408 // Check if extern is followed by non-extern and vice-versa.
David Majnemercdf8a712015-01-13 10:14:57 +00003409 if (New->hasExternalStorage() &&
David Majnemera3b04ce2015-01-14 00:31:13 +00003410 !Old->hasLinkage() && Old->isLocalVarDeclOrParm()) {
Argyrios Kyrtzidis819f6102011-01-31 07:04:46 +00003411 Diag(New->getLocation(), diag::err_extern_non_extern) << New->getDeclName();
David Majnemer5b63fa02014-06-18 23:26:25 +00003412 Diag(OldLocation, PrevDiag);
Argyrios Kyrtzidis819f6102011-01-31 07:04:46 +00003413 return New->setInvalidDecl();
3414 }
David Majnemera3b04ce2015-01-14 00:31:13 +00003415 if (Old->hasLinkage() && New->isLocalVarDeclOrParm() &&
David Majnemercdf8a712015-01-13 10:14:57 +00003416 !New->hasExternalStorage()) {
Argyrios Kyrtzidis819f6102011-01-31 07:04:46 +00003417 Diag(New->getLocation(), diag::err_non_extern_extern) << New->getDeclName();
David Majnemer5b63fa02014-06-18 23:26:25 +00003418 Diag(OldLocation, PrevDiag);
Argyrios Kyrtzidis819f6102011-01-31 07:04:46 +00003419 return New->setInvalidDecl();
3420 }
3421
Steve Naroffa5629372008-09-17 14:05:40 +00003422 // Variables with external linkage are analyzed in FinalizeDeclaratorGroup.
Mike Stump11289f42009-09-09 15:08:12 +00003423
Daniel Dunbar0ca16602009-04-14 02:25:56 +00003424 // FIXME: The test for external storage here seems wrong? We still
3425 // need to check for mismatches.
3426 if (!New->hasExternalStorage() && !New->isFileVarDecl() &&
Douglas Gregor04e9a032009-03-11 23:52:16 +00003427 // Don't complain about out-of-line definitions of static members.
3428 !(Old->getLexicalDeclContext()->isRecord() &&
3429 !New->getLexicalDeclContext()->isRecord())) {
Chris Lattnere3d20d92008-11-23 21:45:46 +00003430 Diag(New->getLocation(), diag::err_redefinition) << New->getDeclName();
David Majnemer5b63fa02014-06-18 23:26:25 +00003431 Diag(OldLocation, PrevDiag);
Chris Lattnerf6d1c9c2009-04-25 08:06:05 +00003432 return New->setInvalidDecl();
Steve Naroff6fbf0dc2007-03-16 00:33:25 +00003433 }
Douglas Gregor0760fa12009-03-10 23:43:53 +00003434
Richard Smithfd3834f2013-04-13 02:43:54 +00003435 if (New->getTLSKind() != Old->getTLSKind()) {
3436 if (!Old->getTLSKind()) {
3437 Diag(New->getLocation(), diag::err_thread_non_thread) << New->getDeclName();
David Majnemer5b63fa02014-06-18 23:26:25 +00003438 Diag(OldLocation, PrevDiag);
Richard Smithfd3834f2013-04-13 02:43:54 +00003439 } else if (!New->getTLSKind()) {
3440 Diag(New->getLocation(), diag::err_non_thread_thread) << New->getDeclName();
David Majnemer5b63fa02014-06-18 23:26:25 +00003441 Diag(OldLocation, PrevDiag);
Richard Smithfd3834f2013-04-13 02:43:54 +00003442 } else {
3443 // Do not allow redeclaration to change the variable between requiring
3444 // static and dynamic initialization.
3445 // FIXME: GCC allows this, but uses the TLS keyword on the first
3446 // declaration to determine the kind. Do we need to be compatible here?
3447 Diag(New->getLocation(), diag::err_thread_thread_different_kind)
3448 << New->getDeclName() << (New->getTLSKind() == VarDecl::TLS_Dynamic);
David Majnemer5b63fa02014-06-18 23:26:25 +00003449 Diag(OldLocation, PrevDiag);
Richard Smithfd3834f2013-04-13 02:43:54 +00003450 }
Eli Friedmand5c0eed2009-04-19 20:27:55 +00003451 }
3452
Sebastian Redlf1842912010-02-02 18:35:11 +00003453 // C++ doesn't have tentative definitions, so go right ahead and check here.
Richard Smith82e57fb2015-05-19 00:49:29 +00003454 VarDecl *Def;
David Blaikiebbafb8a2012-03-11 07:00:24 +00003455 if (getLangOpts().CPlusPlus &&
Sebastian Redld85be0c2010-02-03 02:08:48 +00003456 New->isThisDeclarationADefinition() == VarDecl::Definition &&
Sebastian Redlf1842912010-02-02 18:35:11 +00003457 (Def = Old->getDefinition())) {
Richard Smith82e57fb2015-05-19 00:49:29 +00003458 NamedDecl *Hidden = nullptr;
Richard Smith529ecb22015-06-22 21:15:01 +00003459 if (!hasVisibleDefinition(Def, &Hidden) &&
3460 (New->getFormalLinkage() == InternalLinkage ||
3461 New->getDescribedVarTemplate() ||
Richard Smith82e57fb2015-05-19 00:49:29 +00003462 New->getNumTemplateParameterLists() ||
3463 New->getDeclContext()->isDependentContext())) {
3464 // The previous definition is hidden, and multiple definitions are
3465 // permitted (in separate TUs). Form another definition of it.
3466 } else {
3467 Diag(New->getLocation(), diag::err_redefinition) << New;
3468 Diag(Def->getLocation(), diag::note_previous_definition);
3469 New->setInvalidDecl();
3470 return;
3471 }
Sebastian Redlf1842912010-02-02 18:35:11 +00003472 }
Rafael Espindolacffa95d2012-12-27 03:56:20 +00003473
Rafael Espindolaf4187652013-02-14 01:18:37 +00003474 if (haveIncompatibleLanguageLinkages(Old, New)) {
Rafael Espindolacffa95d2012-12-27 03:56:20 +00003475 Diag(New->getLocation(), diag::err_different_language_linkage) << New;
David Majnemer5b63fa02014-06-18 23:26:25 +00003476 Diag(OldLocation, PrevDiag);
Rafael Espindolacffa95d2012-12-27 03:56:20 +00003477 New->setInvalidDecl();
3478 return;
3479 }
3480
Rafael Espindolabefe1302012-11-25 14:07:59 +00003481 // Merge "used" flag.
Rafael Espindolae4865d22013-10-23 16:46:34 +00003482 if (Old->getMostRecentDecl()->isUsed(false))
3483 New->setIsUsed();
Rafael Espindolabefe1302012-11-25 14:07:59 +00003484
Douglas Gregor0760fa12009-03-10 23:43:53 +00003485 // Keep a chain of previous declarations.
Rafael Espindola8db352d2013-10-17 15:37:26 +00003486 New->setPreviousDecl(Old);
Richard Smithbeef3452014-01-16 23:39:20 +00003487 if (NewTemplate)
3488 NewTemplate->setPreviousDecl(OldTemplate);
John McCall401982f2010-01-20 21:53:11 +00003489
3490 // Inherit access appropriately.
3491 New->setAccess(Old->getAccess());
Richard Smithbeef3452014-01-16 23:39:20 +00003492 if (NewTemplate)
3493 NewTemplate->setAccess(New->getAccess());
Chris Lattner01564d92007-01-27 19:27:06 +00003494}
3495
Chris Lattnerb6738ec2007-01-28 00:38:24 +00003496/// ParsedFreeStandingDeclSpec - This method is invoked when a declspec with
3497/// no declarator (e.g. "struct foo;") is parsed.
John McCall48871652010-08-21 09:40:31 +00003498Decl *Sema::ParsedFreeStandingDeclSpec(Scope *S, AccessSpecifier AS,
John McCallaa017372011-03-22 23:00:04 +00003499 DeclSpec &DS) {
Benjamin Kramercc4c49d2012-08-23 23:38:35 +00003500 return ParsedFreeStandingDeclSpec(S, AS, DS, MultiTemplateParamsArg());
Chandler Carruth7c9856d2011-05-03 18:35:10 +00003501}
3502
David Majnemera7f8c462015-03-19 21:54:30 +00003503// The MS ABI changed between VS2013 and VS2015 with regard to numbers used to
3504// disambiguate entities defined in different scopes.
3505// While the VS2015 ABI fixes potential miscompiles, it is also breaks
3506// compatibility.
3507// We will pick our mangling number depending on which version of MSVC is being
3508// targeted.
3509static unsigned getMSManglingNumber(const LangOptions &LO, Scope *S) {
David Majnemerb710a932015-05-11 03:57:49 +00003510 return LO.isCompatibleWithMSVC(LangOptions::MSVC2015)
3511 ? S->getMSCurManglingNumber()
3512 : S->getMSLastManglingNumber();
David Majnemera7f8c462015-03-19 21:54:30 +00003513}
3514
David Majnemerf9bde282015-03-11 06:45:39 +00003515void Sema::handleTagNumbering(const TagDecl *Tag, Scope *TagScope) {
3516 if (!Context.getLangOpts().CPlusPlus)
Reid Klecknerd8110b62013-09-10 20:14:30 +00003517 return;
3518
Eli Friedman3b7d46c2013-07-10 00:30:46 +00003519 if (isa<CXXRecordDecl>(Tag->getParent())) {
3520 // If this tag is the direct child of a class, number it if
3521 // it is anonymous.
3522 if (!Tag->getName().empty() || Tag->getTypedefNameForAnonDecl())
3523 return;
3524 MangleNumberingContext &MCtx =
David Majnemerf9bde282015-03-11 06:45:39 +00003525 Context.getManglingNumberContext(Tag->getParent());
3526 Context.setManglingNumber(
David Majnemera7f8c462015-03-19 21:54:30 +00003527 Tag, MCtx.getManglingNumber(
3528 Tag, getMSManglingNumber(getLangOpts(), TagScope)));
Eli Friedman3b7d46c2013-07-10 00:30:46 +00003529 return;
3530 }
3531
3532 // If this tag isn't a direct child of a class, number it if it is local.
3533 Decl *ManglingContextDecl;
David Majnemerf9bde282015-03-11 06:45:39 +00003534 if (MangleNumberingContext *MCtx = getCurrentMangleNumberContext(
3535 Tag->getDeclContext(), ManglingContextDecl)) {
3536 Context.setManglingNumber(
David Majnemera7f8c462015-03-19 21:54:30 +00003537 Tag, MCtx->getManglingNumber(
3538 Tag, getMSManglingNumber(getLangOpts(), TagScope)));
Eli Friedman3b7d46c2013-07-10 00:30:46 +00003539 }
3540}
3541
David Majnemerf9bde282015-03-11 06:45:39 +00003542void Sema::setTagNameForLinkagePurposes(TagDecl *TagFromDeclSpec,
3543 TypedefNameDecl *NewTD) {
3544 // Do nothing if the tag is not anonymous or already has an
3545 // associated typedef (from an earlier typedef in this decl group).
3546 if (TagFromDeclSpec->getIdentifier())
3547 return;
3548 if (TagFromDeclSpec->getTypedefNameForAnonDecl())
3549 return;
3550
3551 // A well-formed anonymous tag must always be a TUK_Definition.
3552 assert(TagFromDeclSpec->isThisDeclarationADefinition());
3553
3554 // The type must match the tag exactly; no qualifiers allowed.
3555 if (!Context.hasSameType(NewTD->getUnderlyingType(),
3556 Context.getTagDeclType(TagFromDeclSpec)))
3557 return;
3558
3559 // If we've already computed linkage for the anonymous tag, then
3560 // adding a typedef name for the anonymous decl can change that
3561 // linkage, which might be a serious problem. Diagnose this as
3562 // unsupported and ignore the typedef name. TODO: we should
3563 // pursue this as a language defect and establish a formal rule
3564 // for how to handle it.
3565 if (TagFromDeclSpec->hasLinkageBeenComputed()) {
3566 Diag(NewTD->getLocation(), diag::err_typedef_changes_linkage);
3567
3568 SourceLocation tagLoc = TagFromDeclSpec->getInnerLocStart();
3569 tagLoc = getLocForEndOfToken(tagLoc);
3570
3571 llvm::SmallString<40> textToInsert;
3572 textToInsert += ' ';
3573 textToInsert += NewTD->getIdentifier()->getName();
3574 Diag(tagLoc, diag::note_typedef_changes_linkage)
3575 << FixItHint::CreateInsertion(tagLoc, textToInsert);
3576 return;
3577 }
3578
3579 // Otherwise, set this is the anon-decl typedef for the tag.
3580 TagFromDeclSpec->setTypedefNameForAnonDecl(NewTD);
3581}
3582
Saleem Abdulrasool2e08f502015-06-21 23:05:52 +00003583static unsigned GetDiagnosticTypeSpecifierID(DeclSpec::TST T) {
3584 switch (T) {
3585 case DeclSpec::TST_class:
3586 return 0;
3587 case DeclSpec::TST_struct:
3588 return 1;
3589 case DeclSpec::TST_interface:
3590 return 2;
3591 case DeclSpec::TST_union:
3592 return 3;
3593 case DeclSpec::TST_enum:
3594 return 4;
3595 default:
3596 llvm_unreachable("unexpected type specifier");
3597 }
3598}
3599
Chandler Carruth7c9856d2011-05-03 18:35:10 +00003600/// ParsedFreeStandingDeclSpec - This method is invoked when a declspec with
Richard Smithb1402ae2013-03-18 22:52:47 +00003601/// no declarator (e.g. "struct foo;") is parsed. It also accepts template
Chandler Carruth7c9856d2011-05-03 18:35:10 +00003602/// parameters to cope with template friend declarations.
3603Decl *Sema::ParsedFreeStandingDeclSpec(Scope *S, AccessSpecifier AS,
3604 DeclSpec &DS,
Richard Smithb1402ae2013-03-18 22:52:47 +00003605 MultiTemplateParamsArg TemplateParams,
3606 bool IsExplicitInstantiation) {
Craig Topperc3ec1492014-05-26 06:22:03 +00003607 Decl *TagD = nullptr;
3608 TagDecl *Tag = nullptr;
Douglas Gregor9817f4a2009-02-09 15:09:02 +00003609 if (DS.getTypeSpecType() == DeclSpec::TST_class ||
3610 DS.getTypeSpecType() == DeclSpec::TST_struct ||
Joao Matosdc86f942012-08-31 18:45:21 +00003611 DS.getTypeSpecType() == DeclSpec::TST_interface ||
Douglas Gregor9817f4a2009-02-09 15:09:02 +00003612 DS.getTypeSpecType() == DeclSpec::TST_union ||
Douglas Gregor1b57ff32009-05-12 23:25:50 +00003613 DS.getTypeSpecType() == DeclSpec::TST_enum) {
John McCallba7bf592010-08-24 05:47:05 +00003614 TagD = DS.getRepAsDecl();
John McCallc3987482009-10-07 23:34:25 +00003615
3616 if (!TagD) // We probably had an error
Craig Topperc3ec1492014-05-26 06:22:03 +00003617 return nullptr;
Douglas Gregor1b57ff32009-05-12 23:25:50 +00003618
John McCall07e91c02009-08-06 02:15:43 +00003619 // Note that the above type specs guarantee that the
3620 // type rep is a Decl, whereas in many of the others
3621 // it's a Type.
Peter Collingbournee109a2c2011-10-23 17:07:16 +00003622 if (isa<TagDecl>(TagD))
3623 Tag = cast<TagDecl>(TagD);
3624 else if (ClassTemplateDecl *CTD = dyn_cast<ClassTemplateDecl>(TagD))
3625 Tag = CTD->getTemplatedDecl();
Douglas Gregor1b57ff32009-05-12 23:25:50 +00003626 }
Douglas Gregor9817f4a2009-02-09 15:09:02 +00003627
Argyrios Kyrtzidis25596292012-03-09 20:10:30 +00003628 if (Tag) {
David Majnemerf9bde282015-03-11 06:45:39 +00003629 handleTagNumbering(Tag, S);
Argyrios Kyrtzidis201d3772011-09-30 22:11:31 +00003630 Tag->setFreeStanding();
Argyrios Kyrtzidis25596292012-03-09 20:10:30 +00003631 if (Tag->isInvalidDecl())
3632 return Tag;
3633 }
Argyrios Kyrtzidis201d3772011-09-30 22:11:31 +00003634
Nuno Lopese9823fa2009-12-17 11:35:26 +00003635 if (unsigned TypeQuals = DS.getTypeQualifiers()) {
3636 // Enforce C99 6.7.3p2: "Types other than pointer types derived from object
3637 // or incomplete types shall not be restrict-qualified."
3638 if (TypeQuals & DeclSpec::TQ_restrict)
3639 Diag(DS.getRestrictSpecLoc(),
3640 diag::err_typecheck_invalid_restrict_not_pointer_noarg)
3641 << DS.getSourceRange();
3642 }
3643
Richard Smitha77a0a62011-08-15 21:04:07 +00003644 if (DS.isConstexprSpecified()) {
3645 // C++0x [dcl.constexpr]p1: constexpr can only be applied to declarations
3646 // and definitions of functions and variables.
3647 if (Tag)
3648 Diag(DS.getConstexprSpecLoc(), diag::err_constexpr_tag)
Saleem Abdulrasool2e08f502015-06-21 23:05:52 +00003649 << GetDiagnosticTypeSpecifierID(DS.getTypeSpecType());
Richard Smitha77a0a62011-08-15 21:04:07 +00003650 else
3651 Diag(DS.getConstexprSpecLoc(), diag::err_constexpr_no_declarators);
3652 // Don't emit warnings after this error.
3653 return TagD;
3654 }
3655
Richard Smithb1402ae2013-03-18 22:52:47 +00003656 DiagnoseFunctionSpecifiers(DS);
3657
Douglas Gregor3dad8422009-09-26 06:47:28 +00003658 if (DS.isFriendSpecified()) {
John McCallace48cd2010-10-19 01:40:49 +00003659 // If we're dealing with a decl but not a TagDecl, assume that
3660 // whatever routines created it handled the friendship aspect.
3661 if (TagD && !Tag)
Craig Topperc3ec1492014-05-26 06:22:03 +00003662 return nullptr;
Chandler Carruth7c9856d2011-05-03 18:35:10 +00003663 return ActOnFriendTypeDecl(S, DS, TemplateParams);
Douglas Gregor3dad8422009-09-26 06:47:28 +00003664 }
John McCallaa017372011-03-22 23:00:04 +00003665
Nico Weber4d1bed82015-02-14 05:47:01 +00003666 const CXXScopeSpec &SS = DS.getTypeSpecScope();
Richard Smithb1402ae2013-03-18 22:52:47 +00003667 bool IsExplicitSpecialization =
3668 !TemplateParams.empty() && TemplateParams.back()->size() == 0;
3669 if (Tag && SS.isNotEmpty() && !Tag->isCompleteDefinition() &&
3670 !IsExplicitInstantiation && !IsExplicitSpecialization) {
3671 // Per C++ [dcl.type.elab]p1, a class declaration cannot have a
3672 // nested-name-specifier unless it is an explicit instantiation
3673 // or an explicit specialization.
3674 // Per C++ [dcl.enum]p1, an opaque-enum-declaration can't either.
3675 Diag(SS.getBeginLoc(), diag::err_standalone_class_nested_name_specifier)
Saleem Abdulrasool2e08f502015-06-21 23:05:52 +00003676 << GetDiagnosticTypeSpecifierID(DS.getTypeSpecType()) << SS.getRange();
Craig Topperc3ec1492014-05-26 06:22:03 +00003677 return nullptr;
Richard Smithb1402ae2013-03-18 22:52:47 +00003678 }
3679
3680 // Track whether this decl-specifier declares anything.
3681 bool DeclaresAnything = true;
3682
3683 // Handle anonymous struct definitions.
Douglas Gregorc6f58fe2009-01-12 22:49:06 +00003684 if (RecordDecl *Record = dyn_cast_or_null<RecordDecl>(Tag)) {
John McCallf937c022011-10-07 06:10:15 +00003685 if (!Record->getDeclName() && Record->isCompleteDefinition() &&
Douglas Gregor2e7cba62009-03-06 23:06:59 +00003686 DS.getStorageClassSpec() != DeclSpec::SCS_typedef) {
David Blaikiebbafb8a2012-03-11 07:00:24 +00003687 if (getLangOpts().CPlusPlus ||
Douglas Gregor2e7cba62009-03-06 23:06:59 +00003688 Record->getDeclContext()->isRecord())
Nico Weber01a46ad2015-02-15 06:15:40 +00003689 return BuildAnonymousStructOrUnion(S, DS, AS, Record,
3690 Context.getPrintingPolicy());
Douglas Gregor2e7cba62009-03-06 23:06:59 +00003691
Richard Smithb1402ae2013-03-18 22:52:47 +00003692 DeclaresAnything = false;
Douglas Gregor2e7cba62009-03-06 23:06:59 +00003693 }
Francois Pichet0c71f6c2010-11-23 06:07:27 +00003694 }
Douglas Gregorc6f58fe2009-01-12 22:49:06 +00003695
David Majnemer8f0ed912014-08-11 07:29:54 +00003696 // C11 6.7.2.1p2:
3697 // A struct-declaration that does not declare an anonymous structure or
3698 // anonymous union shall contain a struct-declarator-list.
Richard Smith04d3b3e2014-08-26 21:51:57 +00003699 //
3700 // This rule also existed in C89 and C99; the grammar for struct-declaration
3701 // did not permit a struct-declaration without a struct-declarator-list.
Fariborz Jahanianffc120a2014-08-26 21:10:47 +00003702 if (!getLangOpts().CPlusPlus && CurContext->isRecord() &&
Francois Pichet0c71f6c2010-11-23 06:07:27 +00003703 DS.getStorageClassSpec() == DeclSpec::SCS_unspecified) {
David Majnemer8f0ed912014-08-11 07:29:54 +00003704 // Check for Microsoft C extension: anonymous struct/union member.
3705 // Handle 2 kinds of anonymous struct/union:
Francois Pichet0c71f6c2010-11-23 06:07:27 +00003706 // struct STRUCT;
David Majnemer8f0ed912014-08-11 07:29:54 +00003707 // union UNION;
Francois Pichet0c71f6c2010-11-23 06:07:27 +00003708 // and
3709 // STRUCT_TYPE; <- where STRUCT_TYPE is a typedef struct.
David Majnemer8f0ed912014-08-11 07:29:54 +00003710 // UNION_TYPE; <- where UNION_TYPE is a typedef union.
3711 if ((Tag && Tag->getDeclName()) ||
3712 DS.getTypeSpecType() == DeclSpec::TST_typename) {
3713 RecordDecl *Record = nullptr;
3714 if (Tag)
3715 Record = dyn_cast<RecordDecl>(Tag);
3716 else if (const RecordType *RT =
3717 DS.getRepAsType().get()->getAsStructureType())
3718 Record = RT->getDecl();
3719 else if (const RecordType *UT = DS.getRepAsType().get()->getAsUnionType())
3720 Record = UT->getDecl();
3721
3722 if (Record && getLangOpts().MicrosoftExt) {
3723 Diag(DS.getLocStart(), diag::ext_ms_anonymous_record)
3724 << Record->isUnion() << DS.getSourceRange();
3725 return BuildMicrosoftCAnonymousStruct(S, DS, Record);
3726 }
3727
3728 DeclaresAnything = false;
Francois Pichet0c71f6c2010-11-23 06:07:27 +00003729 }
Douglas Gregorc6f58fe2009-01-12 22:49:06 +00003730 }
Richard Smithb1402ae2013-03-18 22:52:47 +00003731
3732 // Skip all the checks below if we have a type error.
3733 if (DS.getTypeSpecType() == DeclSpec::TST_error ||
3734 (TagD && TagD->isInvalidDecl()))
3735 return TagD;
3736
3737 if (getLangOpts().CPlusPlus &&
Douglas Gregoraa8c9722010-07-13 06:24:26 +00003738 DS.getStorageClassSpec() != DeclSpec::SCS_typedef)
3739 if (EnumDecl *Enum = dyn_cast_or_null<EnumDecl>(Tag))
3740 if (Enum->enumerator_begin() == Enum->enumerator_end() &&
Richard Smithb1402ae2013-03-18 22:52:47 +00003741 !Enum->getIdentifier() && !Enum->isInvalidDecl())
3742 DeclaresAnything = false;
John McCallaa017372011-03-22 23:00:04 +00003743
John McCallaa017372011-03-22 23:00:04 +00003744 if (!DS.isMissingDeclaratorOk()) {
Richard Smithb1402ae2013-03-18 22:52:47 +00003745 // Customize diagnostic for a typedef missing a name.
3746 if (DS.getStorageClassSpec() == DeclSpec::SCS_typedef)
Daniel Dunbar62ee6412012-03-09 18:35:03 +00003747 Diag(DS.getLocStart(), diag::ext_typedef_without_a_name)
Douglas Gregor3a8e0d72010-07-16 15:40:40 +00003748 << DS.getSourceRange();
Richard Smithb1402ae2013-03-18 22:52:47 +00003749 else
3750 DeclaresAnything = false;
Sebastian Redla2b5e312008-12-28 15:28:59 +00003751 }
Mike Stump11289f42009-09-09 15:08:12 +00003752
Richard Smithb1402ae2013-03-18 22:52:47 +00003753 if (DS.isModulePrivateSpecified() &&
Douglas Gregor41866812011-09-12 18:37:38 +00003754 Tag && Tag->getDeclContext()->isFunctionOrMethod())
3755 Diag(DS.getModulePrivateSpecLoc(), diag::err_module_private_local_class)
3756 << Tag->getTagKind()
3757 << FixItHint::CreateRemoval(DS.getModulePrivateSpecLoc());
3758
Richard Smithb1402ae2013-03-18 22:52:47 +00003759 ActOnDocumentableDecl(TagD);
3760
3761 // C 6.7/2:
3762 // A declaration [...] shall declare at least a declarator [...], a tag,
3763 // or the members of an enumeration.
3764 // C++ [dcl.dcl]p3:
3765 // [If there are no declarators], and except for the declaration of an
3766 // unnamed bit-field, the decl-specifier-seq shall introduce one or more
3767 // names into the program, or shall redeclare a name introduced by a
3768 // previous declaration.
3769 if (!DeclaresAnything) {
3770 // In C, we allow this as a (popular) extension / bug. Don't bother
3771 // producing further diagnostics for redundant qualifiers after this.
3772 Diag(DS.getLocStart(), diag::ext_no_declarators) << DS.getSourceRange();
3773 return TagD;
3774 }
3775
3776 // C++ [dcl.stc]p1:
3777 // If a storage-class-specifier appears in a decl-specifier-seq, [...] the
3778 // init-declarator-list of the declaration shall not be empty.
3779 // C++ [dcl.fct.spec]p1:
3780 // If a cv-qualifier appears in a decl-specifier-seq, the
3781 // init-declarator-list of the declaration shall not be empty.
3782 //
3783 // Spurious qualifiers here appear to be valid in C.
3784 unsigned DiagID = diag::warn_standalone_specifier;
3785 if (getLangOpts().CPlusPlus)
3786 DiagID = diag::ext_standalone_specifier;
3787
3788 // Note that a linkage-specification sets a storage class, but
3789 // 'extern "C" struct foo;' is actually valid and not theoretically
3790 // useless.
Aaron Ballman5a1ef6b2014-05-26 17:03:54 +00003791 if (DeclSpec::SCS SCS = DS.getStorageClassSpec()) {
3792 if (SCS == DeclSpec::SCS_mutable)
3793 // Since mutable is not a viable storage class specifier in C, there is
3794 // no reason to treat it as an extension. Instead, diagnose as an error.
3795 Diag(DS.getStorageClassSpecLoc(), diag::err_mutable_nonmember);
3796 else if (!DS.isExternInLinkageSpec() && SCS != DeclSpec::SCS_typedef)
Richard Smithb1402ae2013-03-18 22:52:47 +00003797 Diag(DS.getStorageClassSpecLoc(), DiagID)
3798 << DeclSpec::getSpecifierName(SCS);
Aaron Ballman5a1ef6b2014-05-26 17:03:54 +00003799 }
Richard Smithb1402ae2013-03-18 22:52:47 +00003800
Richard Smithb4a9e862013-04-12 22:46:28 +00003801 if (DeclSpec::TSCS TSCS = DS.getThreadStorageClassSpec())
3802 Diag(DS.getThreadStorageClassSpecLoc(), DiagID)
3803 << DeclSpec::getSpecifierName(TSCS);
Richard Smithb1402ae2013-03-18 22:52:47 +00003804 if (DS.getTypeQualifiers()) {
3805 if (DS.getTypeQualifiers() & DeclSpec::TQ_const)
3806 Diag(DS.getConstSpecLoc(), DiagID) << "const";
3807 if (DS.getTypeQualifiers() & DeclSpec::TQ_volatile)
3808 Diag(DS.getConstSpecLoc(), DiagID) << "volatile";
3809 // Restrict is covered above.
Richard Smith8e1ac332013-03-28 01:55:44 +00003810 if (DS.getTypeQualifiers() & DeclSpec::TQ_atomic)
3811 Diag(DS.getAtomicSpecLoc(), DiagID) << "_Atomic";
Richard Smithb1402ae2013-03-18 22:52:47 +00003812 }
3813
Eli Friedmane3217952011-12-17 00:36:09 +00003814 // Warn about ignored type attributes, for example:
3815 // __attribute__((aligned)) struct A;
Bill Wendling44426052012-12-20 19:22:21 +00003816 // Attributes should be placed after tag to apply to type declaration.
Eli Friedmane3217952011-12-17 00:36:09 +00003817 if (!DS.getAttributes().empty()) {
3818 DeclSpec::TST TypeSpecType = DS.getTypeSpecType();
3819 if (TypeSpecType == DeclSpec::TST_class ||
3820 TypeSpecType == DeclSpec::TST_struct ||
Joao Matosdc86f942012-08-31 18:45:21 +00003821 TypeSpecType == DeclSpec::TST_interface ||
Eli Friedmane3217952011-12-17 00:36:09 +00003822 TypeSpecType == DeclSpec::TST_union ||
3823 TypeSpecType == DeclSpec::TST_enum) {
Saleem Abdulrasool3f31bd62015-06-21 18:20:01 +00003824 for (AttributeList* attrs = DS.getAttributes().getList(); attrs;
Saleem Abdulrasool2e08f502015-06-21 23:05:52 +00003825 attrs = attrs->getNext())
Michael Han360d2252012-10-04 16:42:52 +00003826 Diag(attrs->getLoc(), diag::warn_declspec_attribute_ignored)
Saleem Abdulrasool2e08f502015-06-21 23:05:52 +00003827 << attrs->getName() << GetDiagnosticTypeSpecifierID(TypeSpecType);
Eli Friedmane3217952011-12-17 00:36:09 +00003828 }
3829 }
John McCallaa017372011-03-22 23:00:04 +00003830
John McCall48871652010-08-21 09:40:31 +00003831 return TagD;
Douglas Gregor9ac7a072009-01-07 00:43:41 +00003832}
3833
John McCallea305ed2009-12-18 10:40:03 +00003834/// We are trying to inject an anonymous member into the given scope;
John McCall1f82f242009-11-18 22:49:29 +00003835/// check if there's an existing declaration that can't be overloaded.
3836///
3837/// \return true if this is a forbidden redeclaration
John McCallea305ed2009-12-18 10:40:03 +00003838static bool CheckAnonMemberRedeclaration(Sema &SemaRef,
3839 Scope *S,
Fariborz Jahanian53967e22010-01-22 18:30:17 +00003840 DeclContext *Owner,
John McCallea305ed2009-12-18 10:40:03 +00003841 DeclarationName Name,
3842 SourceLocation NameLoc,
3843 unsigned diagnostic) {
3844 LookupResult R(SemaRef, Name, NameLoc, Sema::LookupMemberName,
3845 Sema::ForRedeclaration);
3846 if (!SemaRef.LookupName(R, S)) return false;
John McCall1f82f242009-11-18 22:49:29 +00003847
John McCallea305ed2009-12-18 10:40:03 +00003848 if (R.getAsSingle<TagDecl>())
John McCall1f82f242009-11-18 22:49:29 +00003849 return false;
3850
3851 // Pick a representative declaration.
John McCallea305ed2009-12-18 10:40:03 +00003852 NamedDecl *PrevDecl = R.getRepresentativeDecl()->getUnderlyingDecl();
Argyrios Kyrtzidise619e992010-09-23 14:26:01 +00003853 assert(PrevDecl && "Expected a non-null Decl");
3854
3855 if (!SemaRef.isDeclInScope(PrevDecl, Owner, S))
3856 return false;
John McCall1f82f242009-11-18 22:49:29 +00003857
John McCallea305ed2009-12-18 10:40:03 +00003858 SemaRef.Diag(NameLoc, diagnostic) << Name;
3859 SemaRef.Diag(PrevDecl->getLocation(), diag::note_previous_declaration);
John McCall1f82f242009-11-18 22:49:29 +00003860
3861 return true;
3862}
3863
Douglas Gregor9ac7a072009-01-07 00:43:41 +00003864/// InjectAnonymousStructOrUnionMembers - Inject the members of the
3865/// anonymous struct or union AnonRecord into the owning context Owner
3866/// and scope S. This routine will be invoked just after we realize
3867/// that an unnamed union or struct is actually an anonymous union or
3868/// struct, e.g.,
3869///
3870/// @code
3871/// union {
3872/// int i;
3873/// float f;
3874/// }; // InjectAnonymousStructOrUnionMembers called here to inject i and
3875/// // f into the surrounding scope.x
3876/// @endcode
3877///
3878/// This routine is recursive, injecting the names of nested anonymous
3879/// structs/unions into the owning context and scope as well.
John McCallb54367d2010-05-21 20:45:30 +00003880static bool InjectAnonymousStructOrUnionMembers(Sema &SemaRef, Scope *S,
Craig Topper5603df42013-07-05 19:34:19 +00003881 DeclContext *Owner,
3882 RecordDecl *AnonRecord,
3883 AccessSpecifier AS,
3884 SmallVectorImpl<NamedDecl *> &Chaining,
3885 bool MSAnonStruct) {
John McCall1f82f242009-11-18 22:49:29 +00003886 unsigned diagKind
3887 = AnonRecord->isUnion() ? diag::err_anonymous_union_member_redecl
3888 : diag::err_anonymous_struct_member_redecl;
3889
Douglas Gregor9ac7a072009-01-07 00:43:41 +00003890 bool Invalid = false;
Francois Pichet0c71f6c2010-11-23 06:07:27 +00003891
3892 // Look every FieldDecl and IndirectFieldDecl with a name.
Aaron Ballman629afae2014-03-07 19:56:05 +00003893 for (auto *D : AnonRecord->decls()) {
3894 if ((isa<FieldDecl>(D) || isa<IndirectFieldDecl>(D)) &&
3895 cast<NamedDecl>(D)->getDeclName()) {
3896 ValueDecl *VD = cast<ValueDecl>(D);
Francois Pichet0c71f6c2010-11-23 06:07:27 +00003897 if (CheckAnonMemberRedeclaration(SemaRef, S, Owner, VD->getDeclName(),
3898 VD->getLocation(), diagKind)) {
Douglas Gregor9ac7a072009-01-07 00:43:41 +00003899 // C++ [class.union]p2:
3900 // The names of the members of an anonymous union shall be
3901 // distinct from the names of any other entity in the
3902 // scope in which the anonymous union is declared.
Douglas Gregor9ac7a072009-01-07 00:43:41 +00003903 Invalid = true;
3904 } else {
3905 // C++ [class.union]p2:
3906 // For the purpose of name lookup, after the anonymous union
3907 // definition, the members of the anonymous union are
3908 // considered to have been defined in the scope in which the
3909 // anonymous union is declared.
Francois Pichet0c71f6c2010-11-23 06:07:27 +00003910 unsigned OldChainingSize = Chaining.size();
3911 if (IndirectFieldDecl *IF = dyn_cast<IndirectFieldDecl>(VD))
Benjamin Kramerf9890422015-02-17 16:48:30 +00003912 Chaining.append(IF->chain_begin(), IF->chain_end());
Francois Pichet0c71f6c2010-11-23 06:07:27 +00003913 else
3914 Chaining.push_back(VD);
3915
Francois Pichet783dd6e2010-11-21 06:08:52 +00003916 assert(Chaining.size() >= 2);
3917 NamedDecl **NamedChain =
3918 new (SemaRef.Context)NamedDecl*[Chaining.size()];
3919 for (unsigned i = 0; i < Chaining.size(); i++)
3920 NamedChain[i] = Chaining[i];
3921
Aaron Ballman260995b2014-10-15 16:58:18 +00003922 IndirectFieldDecl *IndirectField = IndirectFieldDecl::Create(
3923 SemaRef.Context, Owner, VD->getLocation(), VD->getIdentifier(),
3924 VD->getType(), NamedChain, Chaining.size());
3925
3926 for (const auto *Attr : VD->attrs())
3927 IndirectField->addAttr(Attr->clone(SemaRef.Context));
Francois Pichet783dd6e2010-11-21 06:08:52 +00003928
3929 IndirectField->setAccess(AS);
3930 IndirectField->setImplicit();
3931 SemaRef.PushOnScopeChains(IndirectField, S);
John McCallb54367d2010-05-21 20:45:30 +00003932
3933 // That includes picking up the appropriate access specifier.
Francois Pichet0c71f6c2010-11-23 06:07:27 +00003934 if (AS != AS_none) IndirectField->setAccess(AS);
Francois Pichet783dd6e2010-11-21 06:08:52 +00003935
Francois Pichet0c71f6c2010-11-23 06:07:27 +00003936 Chaining.resize(OldChainingSize);
Douglas Gregor9ac7a072009-01-07 00:43:41 +00003937 }
Douglas Gregor9ac7a072009-01-07 00:43:41 +00003938 }
3939 }
3940
3941 return Invalid;
3942}
3943
Douglas Gregorc4df4072010-04-19 22:54:31 +00003944/// StorageClassSpecToVarDeclStorageClass - Maps a DeclSpec::SCS to
3945/// a VarDecl::StorageClass. Any error reporting is up to the caller:
John McCall8e7d6562010-08-26 03:08:43 +00003946/// illegal input values are mapped to SC_None.
3947static StorageClass
Rafael Espindolabff59562013-04-25 12:11:36 +00003948StorageClassSpecToVarDeclStorageClass(const DeclSpec &DS) {
3949 DeclSpec::SCS StorageClassSpec = DS.getStorageClassSpec();
3950 assert(StorageClassSpec != DeclSpec::SCS_typedef &&
3951 "Parser allowed 'typedef' as storage class VarDecl.");
Douglas Gregorc4df4072010-04-19 22:54:31 +00003952 switch (StorageClassSpec) {
John McCall8e7d6562010-08-26 03:08:43 +00003953 case DeclSpec::SCS_unspecified: return SC_None;
Rafael Espindolabff59562013-04-25 12:11:36 +00003954 case DeclSpec::SCS_extern:
3955 if (DS.isExternInLinkageSpec())
3956 return SC_None;
3957 return SC_Extern;
John McCall8e7d6562010-08-26 03:08:43 +00003958 case DeclSpec::SCS_static: return SC_Static;
3959 case DeclSpec::SCS_auto: return SC_Auto;
3960 case DeclSpec::SCS_register: return SC_Register;
3961 case DeclSpec::SCS_private_extern: return SC_PrivateExtern;
Douglas Gregorc4df4072010-04-19 22:54:31 +00003962 // Illegal SCSs map to None: error reporting is up to the caller.
3963 case DeclSpec::SCS_mutable: // Fall through.
John McCall8e7d6562010-08-26 03:08:43 +00003964 case DeclSpec::SCS_typedef: return SC_None;
Douglas Gregorc4df4072010-04-19 22:54:31 +00003965 }
3966 llvm_unreachable("unknown storage class specifier");
3967}
3968
Richard Smithab44d5b2013-12-10 08:25:00 +00003969static SourceLocation findDefaultInitializer(const CXXRecordDecl *Record) {
3970 assert(Record->hasInClassInitializer());
3971
Aaron Ballman629afae2014-03-07 19:56:05 +00003972 for (const auto *I : Record->decls()) {
3973 const auto *FD = dyn_cast<FieldDecl>(I);
3974 if (const auto *IFD = dyn_cast<IndirectFieldDecl>(I))
Richard Smithab44d5b2013-12-10 08:25:00 +00003975 FD = IFD->getAnonField();
3976 if (FD && FD->hasInClassInitializer())
3977 return FD->getLocation();
3978 }
3979
3980 llvm_unreachable("couldn't find in-class initializer");
3981}
3982
3983static void checkDuplicateDefaultInit(Sema &S, CXXRecordDecl *Parent,
3984 SourceLocation DefaultInitLoc) {
3985 if (!Parent->isUnion() || !Parent->hasInClassInitializer())
3986 return;
3987
3988 S.Diag(DefaultInitLoc, diag::err_multiple_mem_union_initialization);
3989 S.Diag(findDefaultInitializer(Parent), diag::note_previous_initializer) << 0;
3990}
3991
3992static void checkDuplicateDefaultInit(Sema &S, CXXRecordDecl *Parent,
3993 CXXRecordDecl *AnonUnion) {
3994 if (!Parent->isUnion() || !Parent->hasInClassInitializer())
3995 return;
3996
3997 checkDuplicateDefaultInit(S, Parent, findDefaultInitializer(AnonUnion));
3998}
3999
Francois Pichet0c71f6c2010-11-23 06:07:27 +00004000/// BuildAnonymousStructOrUnion - Handle the declaration of an
Douglas Gregor9ac7a072009-01-07 00:43:41 +00004001/// anonymous structure or union. Anonymous unions are a C++ feature
Hans Wennborgb64a1fa2012-02-03 15:47:04 +00004002/// (C++ [class.union]) and a C11 feature; anonymous structures
4003/// are a C11 feature and GNU C++ extension.
John McCall48871652010-08-21 09:40:31 +00004004Decl *Sema::BuildAnonymousStructOrUnion(Scope *S, DeclSpec &DS,
Erik Verbruggen888d52a2014-01-15 09:15:43 +00004005 AccessSpecifier AS,
4006 RecordDecl *Record,
4007 const PrintingPolicy &Policy) {
Douglas Gregor9ac7a072009-01-07 00:43:41 +00004008 DeclContext *Owner = Record->getDeclContext();
4009
4010 // Diagnose whether this anonymous struct/union is an extension.
David Blaikiebbafb8a2012-03-11 07:00:24 +00004011 if (Record->isUnion() && !getLangOpts().CPlusPlus && !getLangOpts().C11)
Douglas Gregor9ac7a072009-01-07 00:43:41 +00004012 Diag(Record->getLocation(), diag::ext_anonymous_union);
David Blaikiebbafb8a2012-03-11 07:00:24 +00004013 else if (!Record->isUnion() && getLangOpts().CPlusPlus)
Hans Wennborgb64a1fa2012-02-03 15:47:04 +00004014 Diag(Record->getLocation(), diag::ext_gnu_anonymous_struct);
David Blaikiebbafb8a2012-03-11 07:00:24 +00004015 else if (!Record->isUnion() && !getLangOpts().C11)
Hans Wennborgb64a1fa2012-02-03 15:47:04 +00004016 Diag(Record->getLocation(), diag::ext_c11_anonymous_struct);
Mike Stump11289f42009-09-09 15:08:12 +00004017
Douglas Gregor9ac7a072009-01-07 00:43:41 +00004018 // C and C++ require different kinds of checks for anonymous
4019 // structs/unions.
4020 bool Invalid = false;
David Blaikiebbafb8a2012-03-11 07:00:24 +00004021 if (getLangOpts().CPlusPlus) {
Craig Topperc3ec1492014-05-26 06:22:03 +00004022 const char *PrevSpec = nullptr;
John McCall49bfce42009-08-03 20:12:06 +00004023 unsigned DiagID;
David Blaikie0a8e8992011-10-19 22:43:29 +00004024 if (Record->isUnion()) {
4025 // C++ [class.union]p6:
4026 // Anonymous unions declared in a named namespace or in the
4027 // global namespace shall be declared static.
4028 if (DS.getStorageClassSpec() != DeclSpec::SCS_static &&
4029 (isa<TranslationUnitDecl>(Owner) ||
4030 (isa<NamespaceDecl>(Owner) &&
4031 cast<NamespaceDecl>(Owner)->getDeclName()))) {
David Blaikie733f7bb2011-10-20 02:49:08 +00004032 Diag(Record->getLocation(), diag::err_anonymous_union_not_static)
4033 << FixItHint::CreateInsertion(Record->getLocation(), "static ");
David Blaikie0a8e8992011-10-19 22:43:29 +00004034
4035 // Recover by adding 'static'.
4036 DS.SetStorageClassSpec(*this, DeclSpec::SCS_static, SourceLocation(),
Erik Verbruggen888d52a2014-01-15 09:15:43 +00004037 PrevSpec, DiagID, Policy);
David Blaikie0a8e8992011-10-19 22:43:29 +00004038 }
4039 // C++ [class.union]p6:
4040 // A storage class is not allowed in a declaration of an
4041 // anonymous union in a class scope.
4042 else if (DS.getStorageClassSpec() != DeclSpec::SCS_unspecified &&
4043 isa<RecordDecl>(Owner)) {
4044 Diag(DS.getStorageClassSpecLoc(),
David Blaikie6f686fc2011-10-20 02:10:55 +00004045 diag::err_anonymous_union_with_storage_spec)
4046 << FixItHint::CreateRemoval(DS.getStorageClassSpecLoc());
David Blaikie0a8e8992011-10-19 22:43:29 +00004047
4048 // Recover by removing the storage specifier.
David Blaikie30d15442011-10-19 22:56:21 +00004049 DS.SetStorageClassSpec(*this, DeclSpec::SCS_unspecified,
4050 SourceLocation(),
Erik Verbruggen888d52a2014-01-15 09:15:43 +00004051 PrevSpec, DiagID, Context.getPrintingPolicy());
David Blaikie0a8e8992011-10-19 22:43:29 +00004052 }
Douglas Gregor9ac7a072009-01-07 00:43:41 +00004053 }
Douglas Gregorf4d33272009-01-07 19:46:03 +00004054
Douglas Gregor0f8bc972011-05-09 23:05:33 +00004055 // Ignore const/volatile/restrict qualifiers.
4056 if (DS.getTypeQualifiers()) {
4057 if (DS.getTypeQualifiers() & DeclSpec::TQ_const)
4058 Diag(DS.getConstSpecLoc(), diag::ext_anonymous_struct_union_qualified)
Richard Smith8e1ac332013-03-28 01:55:44 +00004059 << Record->isUnion() << "const"
Douglas Gregor0f8bc972011-05-09 23:05:33 +00004060 << FixItHint::CreateRemoval(DS.getConstSpecLoc());
4061 if (DS.getTypeQualifiers() & DeclSpec::TQ_volatile)
Richard Smith8e1ac332013-03-28 01:55:44 +00004062 Diag(DS.getVolatileSpecLoc(),
David Blaikie30d15442011-10-19 22:56:21 +00004063 diag::ext_anonymous_struct_union_qualified)
Richard Smith8e1ac332013-03-28 01:55:44 +00004064 << Record->isUnion() << "volatile"
Douglas Gregor0f8bc972011-05-09 23:05:33 +00004065 << FixItHint::CreateRemoval(DS.getVolatileSpecLoc());
4066 if (DS.getTypeQualifiers() & DeclSpec::TQ_restrict)
Richard Smith8e1ac332013-03-28 01:55:44 +00004067 Diag(DS.getRestrictSpecLoc(),
David Blaikie30d15442011-10-19 22:56:21 +00004068 diag::ext_anonymous_struct_union_qualified)
Richard Smith8e1ac332013-03-28 01:55:44 +00004069 << Record->isUnion() << "restrict"
Douglas Gregor0f8bc972011-05-09 23:05:33 +00004070 << FixItHint::CreateRemoval(DS.getRestrictSpecLoc());
Richard Smith8e1ac332013-03-28 01:55:44 +00004071 if (DS.getTypeQualifiers() & DeclSpec::TQ_atomic)
4072 Diag(DS.getAtomicSpecLoc(),
4073 diag::ext_anonymous_struct_union_qualified)
4074 << Record->isUnion() << "_Atomic"
4075 << FixItHint::CreateRemoval(DS.getAtomicSpecLoc());
Douglas Gregor0f8bc972011-05-09 23:05:33 +00004076
4077 DS.ClearTypeQualifiers();
4078 }
4079
Mike Stump11289f42009-09-09 15:08:12 +00004080 // C++ [class.union]p2:
Douglas Gregorf4d33272009-01-07 19:46:03 +00004081 // The member-specification of an anonymous union shall only
4082 // define non-static data members. [Note: nested types and
4083 // functions cannot be declared within an anonymous union. ]
Aaron Ballman629afae2014-03-07 19:56:05 +00004084 for (auto *Mem : Record->decls()) {
4085 if (auto *FD = dyn_cast<FieldDecl>(Mem)) {
Douglas Gregorf4d33272009-01-07 19:46:03 +00004086 // C++ [class.union]p3:
4087 // An anonymous union shall not have private or protected
4088 // members (clause 11).
John McCallb54367d2010-05-21 20:45:30 +00004089 assert(FD->getAccess() != AS_none);
4090 if (FD->getAccess() != AS_public) {
Douglas Gregorf4d33272009-01-07 19:46:03 +00004091 Diag(FD->getLocation(), diag::err_anonymous_record_nonpublic_member)
4092 << (int)Record->isUnion() << (int)(FD->getAccess() == AS_protected);
4093 Invalid = true;
4094 }
Argyrios Kyrtzidis33aee392010-08-16 17:27:08 +00004095
Alexis Hunt97ab5542011-05-16 22:41:40 +00004096 // C++ [class.union]p1
4097 // An object of a class with a non-trivial constructor, a non-trivial
4098 // copy constructor, a non-trivial destructor, or a non-trivial copy
4099 // assignment operator cannot be a member of a union, nor can an
4100 // array of such objects.
Richard Smithf720df02011-10-19 20:41:51 +00004101 if (CheckNontrivialField(FD))
Argyrios Kyrtzidis33aee392010-08-16 17:27:08 +00004102 Invalid = true;
Aaron Ballman629afae2014-03-07 19:56:05 +00004103 } else if (Mem->isImplicit()) {
Douglas Gregorf4d33272009-01-07 19:46:03 +00004104 // Any implicit members are fine.
Aaron Ballman629afae2014-03-07 19:56:05 +00004105 } else if (isa<TagDecl>(Mem) && Mem->getDeclContext() != Record) {
Douglas Gregor8761da52009-02-03 00:34:39 +00004106 // This is a type that showed up in an
4107 // elaborated-type-specifier inside the anonymous struct or
4108 // union, but which actually declares a type outside of the
4109 // anonymous struct or union. It's okay.
Aaron Ballman629afae2014-03-07 19:56:05 +00004110 } else if (auto *MemRecord = dyn_cast<RecordDecl>(Mem)) {
Douglas Gregorf4d33272009-01-07 19:46:03 +00004111 if (!MemRecord->isAnonymousStructOrUnion() &&
4112 MemRecord->getDeclName()) {
Francois Pichet4ad4b582010-09-08 11:32:25 +00004113 // Visual C++ allows type definition in anonymous struct or union.
David Blaikiebbafb8a2012-03-11 07:00:24 +00004114 if (getLangOpts().MicrosoftExt)
Francois Pichet4ad4b582010-09-08 11:32:25 +00004115 Diag(MemRecord->getLocation(), diag::ext_anonymous_record_with_type)
4116 << (int)Record->isUnion();
4117 else {
4118 // This is a nested type declaration.
4119 Diag(MemRecord->getLocation(), diag::err_anonymous_record_with_type)
4120 << (int)Record->isUnion();
4121 Invalid = true;
4122 }
Richard Smith254d2662013-01-28 00:54:05 +00004123 } else {
4124 // This is an anonymous type definition within another anonymous type.
4125 // This is a popular extension, provided by Plan9, MSVC and GCC, but
4126 // not part of standard C++.
4127 Diag(MemRecord->getLocation(),
Richard Smithd2029242013-01-31 03:11:12 +00004128 diag::ext_anonymous_record_with_anonymous_type)
4129 << (int)Record->isUnion();
Douglas Gregorf4d33272009-01-07 19:46:03 +00004130 }
Aaron Ballman629afae2014-03-07 19:56:05 +00004131 } else if (isa<AccessSpecDecl>(Mem)) {
Abramo Bagnarad7340582010-06-05 05:09:32 +00004132 // Any access specifier is fine.
Aaron Ballmanf93ef4e2014-06-24 16:22:41 +00004133 } else if (isa<StaticAssertDecl>(Mem)) {
4134 // In C++1z, static_assert declarations are also fine.
Douglas Gregorf4d33272009-01-07 19:46:03 +00004135 } else {
4136 // We have something that isn't a non-static data
4137 // member. Complain about it.
4138 unsigned DK = diag::err_anonymous_record_bad_member;
Aaron Ballman629afae2014-03-07 19:56:05 +00004139 if (isa<TypeDecl>(Mem))
Douglas Gregorf4d33272009-01-07 19:46:03 +00004140 DK = diag::err_anonymous_record_with_type;
Aaron Ballman629afae2014-03-07 19:56:05 +00004141 else if (isa<FunctionDecl>(Mem))
Douglas Gregorf4d33272009-01-07 19:46:03 +00004142 DK = diag::err_anonymous_record_with_function;
Aaron Ballman629afae2014-03-07 19:56:05 +00004143 else if (isa<VarDecl>(Mem))
Douglas Gregorf4d33272009-01-07 19:46:03 +00004144 DK = diag::err_anonymous_record_with_static;
Francois Pichet4ad4b582010-09-08 11:32:25 +00004145
4146 // Visual C++ allows type definition in anonymous struct or union.
David Blaikiebbafb8a2012-03-11 07:00:24 +00004147 if (getLangOpts().MicrosoftExt &&
Francois Pichet4ad4b582010-09-08 11:32:25 +00004148 DK == diag::err_anonymous_record_with_type)
Aaron Ballman629afae2014-03-07 19:56:05 +00004149 Diag(Mem->getLocation(), diag::ext_anonymous_record_with_type)
Douglas Gregorf4d33272009-01-07 19:46:03 +00004150 << (int)Record->isUnion();
Francois Pichet4ad4b582010-09-08 11:32:25 +00004151 else {
Aaron Ballman629afae2014-03-07 19:56:05 +00004152 Diag(Mem->getLocation(), DK)
Francois Pichet4ad4b582010-09-08 11:32:25 +00004153 << (int)Record->isUnion();
Douglas Gregorf4d33272009-01-07 19:46:03 +00004154 Invalid = true;
Francois Pichet4ad4b582010-09-08 11:32:25 +00004155 }
Douglas Gregorf4d33272009-01-07 19:46:03 +00004156 }
4157 }
Richard Smithab44d5b2013-12-10 08:25:00 +00004158
4159 // C++11 [class.union]p8 (DR1460):
4160 // At most one variant member of a union may have a
4161 // brace-or-equal-initializer.
4162 if (cast<CXXRecordDecl>(Record)->hasInClassInitializer() &&
4163 Owner->isRecord())
4164 checkDuplicateDefaultInit(*this, cast<CXXRecordDecl>(Owner),
4165 cast<CXXRecordDecl>(Record));
Mike Stump11289f42009-09-09 15:08:12 +00004166 }
Douglas Gregor9ac7a072009-01-07 00:43:41 +00004167
4168 if (!Record->isUnion() && !Owner->isRecord()) {
Douglas Gregorc6f58fe2009-01-12 22:49:06 +00004169 Diag(Record->getLocation(), diag::err_anonymous_struct_not_member)
David Blaikiebbafb8a2012-03-11 07:00:24 +00004170 << (int)getLangOpts().CPlusPlus;
Douglas Gregor9ac7a072009-01-07 00:43:41 +00004171 Invalid = true;
4172 }
4173
John McCallfa2d6922009-10-22 23:31:08 +00004174 // Mock up a declarator.
Argyrios Kyrtzidis7baa0af2011-06-28 03:01:18 +00004175 Declarator Dc(DS, Declarator::MemberContext);
John McCall8cb7bdf2010-06-04 23:28:52 +00004176 TypeSourceInfo *TInfo = GetTypeForDeclarator(Dc, S);
John McCallbcd03502009-12-07 02:54:59 +00004177 assert(TInfo && "couldn't build declarator info for anonymous struct/union");
John McCallfa2d6922009-10-22 23:31:08 +00004178
Mike Stump11289f42009-09-09 15:08:12 +00004179 // Create a declaration for this anonymous struct/union.
Craig Topperc3ec1492014-05-26 06:22:03 +00004180 NamedDecl *Anon = nullptr;
Douglas Gregor9ac7a072009-01-07 00:43:41 +00004181 if (RecordDecl *OwningClass = dyn_cast<RecordDecl>(Owner)) {
Abramo Bagnaradff19302011-03-08 08:55:46 +00004182 Anon = FieldDecl::Create(Context, OwningClass,
Daniel Dunbar62ee6412012-03-09 18:35:03 +00004183 DS.getLocStart(),
Abramo Bagnaradff19302011-03-08 08:55:46 +00004184 Record->getLocation(),
Craig Topperc3ec1492014-05-26 06:22:03 +00004185 /*IdentifierInfo=*/nullptr,
Argyrios Kyrtzidis6032ef12009-08-21 00:31:54 +00004186 Context.getTypeDeclType(Record),
John McCallbcd03502009-12-07 02:54:59 +00004187 TInfo,
Craig Topperc3ec1492014-05-26 06:22:03 +00004188 /*BitWidth=*/nullptr, /*Mutable=*/false,
Richard Smith2b013182012-06-10 03:12:00 +00004189 /*InitStyle=*/ICIS_NoInit);
John McCallb54367d2010-05-21 20:45:30 +00004190 Anon->setAccess(AS);
David Blaikiebbafb8a2012-03-11 07:00:24 +00004191 if (getLangOpts().CPlusPlus)
Douglas Gregorf4d33272009-01-07 19:46:03 +00004192 FieldCollector->Add(cast<FieldDecl>(Anon));
Douglas Gregor9ac7a072009-01-07 00:43:41 +00004193 } else {
Douglas Gregorc4df4072010-04-19 22:54:31 +00004194 DeclSpec::SCS SCSpec = DS.getStorageClassSpec();
Craig Topperc79e5e32014-10-31 06:57:13 +00004195 StorageClass SC = StorageClassSpecToVarDeclStorageClass(DS);
Douglas Gregorc4df4072010-04-19 22:54:31 +00004196 if (SCSpec == DeclSpec::SCS_mutable) {
Douglas Gregor9ac7a072009-01-07 00:43:41 +00004197 // mutable can only appear on non-static class members, so it's always
4198 // an error here
4199 Diag(Record->getLocation(), diag::err_mutable_nonmember);
4200 Invalid = true;
John McCall8e7d6562010-08-26 03:08:43 +00004201 SC = SC_None;
Douglas Gregor9ac7a072009-01-07 00:43:41 +00004202 }
4203
Abramo Bagnaradff19302011-03-08 08:55:46 +00004204 Anon = VarDecl::Create(Context, Owner,
Daniel Dunbar62ee6412012-03-09 18:35:03 +00004205 DS.getLocStart(),
Craig Topperc3ec1492014-05-26 06:22:03 +00004206 Record->getLocation(), /*IdentifierInfo=*/nullptr,
Argyrios Kyrtzidis6032ef12009-08-21 00:31:54 +00004207 Context.getTypeDeclType(Record),
Rafael Espindola6ae7e502013-04-03 19:27:57 +00004208 TInfo, SC);
Richard Smith40372352011-09-18 00:06:34 +00004209
4210 // Default-initialize the implicit variable. This initialization will be
4211 // trivial in almost all cases, except if a union member has an in-class
4212 // initializer:
4213 // union { int n = 0; };
4214 ActOnUninitializedDecl(Anon, /*TypeMayContainAuto=*/false);
Douglas Gregor9ac7a072009-01-07 00:43:41 +00004215 }
Douglas Gregorf4d33272009-01-07 19:46:03 +00004216 Anon->setImplicit();
Douglas Gregor9ac7a072009-01-07 00:43:41 +00004217
Richard Smithab44d5b2013-12-10 08:25:00 +00004218 // Mark this as an anonymous struct/union type.
4219 Record->setAnonymousStructOrUnion(true);
4220
Douglas Gregor9ac7a072009-01-07 00:43:41 +00004221 // Add the anonymous struct/union object to the current
4222 // context. We'll be referencing this object when we refer to one of
4223 // its members.
Argyrios Kyrtzidiscfbfe782009-06-30 02:36:12 +00004224 Owner->addDecl(Anon);
Richard Smithab44d5b2013-12-10 08:25:00 +00004225
Douglas Gregor9ac7a072009-01-07 00:43:41 +00004226 // Inject the members of the anonymous struct/union into the owning
4227 // context and into the identifier resolver chain for name lookup
4228 // purposes.
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004229 SmallVector<NamedDecl*, 2> Chain;
Francois Pichet783dd6e2010-11-21 06:08:52 +00004230 Chain.push_back(Anon);
4231
Francois Pichet0c71f6c2010-11-23 06:07:27 +00004232 if (InjectAnonymousStructOrUnionMembers(*this, S, Owner, Record, AS,
4233 Chain, false))
Douglas Gregorc6f58fe2009-01-12 22:49:06 +00004234 Invalid = true;
Douglas Gregor9ac7a072009-01-07 00:43:41 +00004235
David Majnemer2206bf52014-03-05 08:57:59 +00004236 if (VarDecl *NewVD = dyn_cast<VarDecl>(Anon)) {
4237 if (getLangOpts().CPlusPlus && NewVD->isStaticLocal()) {
4238 Decl *ManglingContextDecl;
David Majnemera7f8c462015-03-19 21:54:30 +00004239 if (MangleNumberingContext *MCtx = getCurrentMangleNumberContext(
4240 NewVD->getDeclContext(), ManglingContextDecl)) {
4241 Context.setManglingNumber(
4242 NewVD, MCtx->getManglingNumber(
4243 NewVD, getMSManglingNumber(getLangOpts(), S)));
David Majnemer2206bf52014-03-05 08:57:59 +00004244 Context.setStaticLocalNumber(NewVD, MCtx->getStaticLocalNumber(NewVD));
4245 }
4246 }
4247 }
4248
Douglas Gregor9ac7a072009-01-07 00:43:41 +00004249 if (Invalid)
4250 Anon->setInvalidDecl();
4251
John McCall48871652010-08-21 09:40:31 +00004252 return Anon;
Chris Lattnerb6738ec2007-01-28 00:38:24 +00004253}
4254
Francois Pichet0c71f6c2010-11-23 06:07:27 +00004255/// BuildMicrosoftCAnonymousStruct - Handle the declaration of an
4256/// Microsoft C anonymous structure.
4257/// Ref: http://msdn.microsoft.com/en-us/library/z2cx9y4f.aspx
4258/// Example:
4259///
4260/// struct A { int a; };
4261/// struct B { struct A; int b; };
4262///
4263/// void foo() {
4264/// B var;
David Majnemer8f0ed912014-08-11 07:29:54 +00004265/// var.a = 3;
Francois Pichet0c71f6c2010-11-23 06:07:27 +00004266/// }
4267///
4268Decl *Sema::BuildMicrosoftCAnonymousStruct(Scope *S, DeclSpec &DS,
4269 RecordDecl *Record) {
David Majnemer8f0ed912014-08-11 07:29:54 +00004270 assert(Record && "expected a record!");
Francois Pichet0c71f6c2010-11-23 06:07:27 +00004271
4272 // Mock up a declarator.
4273 Declarator Dc(DS, Declarator::TypeNameContext);
4274 TypeSourceInfo *TInfo = GetTypeForDeclarator(Dc, S);
4275 assert(TInfo && "couldn't build declarator info for anonymous struct");
4276
David Majnemerd8e366b2014-09-18 00:42:05 +00004277 auto *ParentDecl = cast<RecordDecl>(CurContext);
4278 QualType RecTy = Context.getTypeDeclType(Record);
4279
Francois Pichet0c71f6c2010-11-23 06:07:27 +00004280 // Create a declaration for this anonymous struct.
Craig Topperc3ec1492014-05-26 06:22:03 +00004281 NamedDecl *Anon = FieldDecl::Create(Context,
David Majnemerd8e366b2014-09-18 00:42:05 +00004282 ParentDecl,
Daniel Dunbar62ee6412012-03-09 18:35:03 +00004283 DS.getLocStart(),
4284 DS.getLocStart(),
Craig Topperc3ec1492014-05-26 06:22:03 +00004285 /*IdentifierInfo=*/nullptr,
David Majnemerd8e366b2014-09-18 00:42:05 +00004286 RecTy,
Francois Pichet0c71f6c2010-11-23 06:07:27 +00004287 TInfo,
Craig Topperc3ec1492014-05-26 06:22:03 +00004288 /*BitWidth=*/nullptr, /*Mutable=*/false,
Richard Smith2b013182012-06-10 03:12:00 +00004289 /*InitStyle=*/ICIS_NoInit);
Francois Pichet0c71f6c2010-11-23 06:07:27 +00004290 Anon->setImplicit();
4291
4292 // Add the anonymous struct object to the current context.
4293 CurContext->addDecl(Anon);
4294
4295 // Inject the members of the anonymous struct into the current
4296 // context and into the identifier resolver chain for name lookup
4297 // purposes.
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004298 SmallVector<NamedDecl*, 2> Chain;
Francois Pichet0c71f6c2010-11-23 06:07:27 +00004299 Chain.push_back(Anon);
4300
Nico Weberf8bb3de2012-02-01 00:41:00 +00004301 RecordDecl *RecordDef = Record->getDefinition();
David Majnemerd8e366b2014-09-18 00:42:05 +00004302 if (RequireCompleteType(Anon->getLocation(), RecTy,
4303 diag::err_field_incomplete) ||
4304 InjectAnonymousStructOrUnionMembers(*this, S, CurContext, RecordDef,
4305 AS_none, Chain, true)) {
Francois Pichet0c71f6c2010-11-23 06:07:27 +00004306 Anon->setInvalidDecl();
David Majnemerd8e366b2014-09-18 00:42:05 +00004307 ParentDecl->setInvalidDecl();
4308 }
Francois Pichet0c71f6c2010-11-23 06:07:27 +00004309
4310 return Anon;
4311}
Steve Naroff2fea1392007-09-02 02:04:30 +00004312
Douglas Gregor92751d42008-11-17 22:58:34 +00004313/// GetNameForDeclarator - Determine the full declaration name for the
4314/// given Declarator.
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00004315DeclarationNameInfo Sema::GetNameForDeclarator(Declarator &D) {
Douglas Gregora121b752009-11-03 16:56:39 +00004316 return GetNameFromUnqualifiedId(D.getName());
4317}
4318
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00004319/// \brief Retrieves the declaration name from a parsed unqualified-id.
4320DeclarationNameInfo
4321Sema::GetNameFromUnqualifiedId(const UnqualifiedId &Name) {
4322 DeclarationNameInfo NameInfo;
4323 NameInfo.setLoc(Name.StartLocation);
4324
Douglas Gregor7861a802009-11-03 01:35:08 +00004325 switch (Name.getKind()) {
Alexis Hunt34458502009-11-28 04:44:28 +00004326
Fariborz Jahanian7f4427f2011-07-12 17:16:56 +00004327 case UnqualifiedId::IK_ImplicitSelfParam:
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00004328 case UnqualifiedId::IK_Identifier:
4329 NameInfo.setName(Name.Identifier);
4330 NameInfo.setLoc(Name.StartLocation);
4331 return NameInfo;
Alexis Hunt34458502009-11-28 04:44:28 +00004332
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00004333 case UnqualifiedId::IK_OperatorFunctionId:
4334 NameInfo.setName(Context.DeclarationNames.getCXXOperatorName(
4335 Name.OperatorFunctionId.Operator));
4336 NameInfo.setLoc(Name.StartLocation);
4337 NameInfo.getInfo().CXXOperatorName.BeginOpNameLoc
4338 = Name.OperatorFunctionId.SymbolLocations[0];
4339 NameInfo.getInfo().CXXOperatorName.EndOpNameLoc
4340 = Name.EndLocation.getRawEncoding();
4341 return NameInfo;
Douglas Gregor9de54ea2010-01-13 17:31:36 +00004342
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00004343 case UnqualifiedId::IK_LiteralOperatorId:
4344 NameInfo.setName(Context.DeclarationNames.getCXXLiteralOperatorName(
4345 Name.Identifier));
4346 NameInfo.setLoc(Name.StartLocation);
4347 NameInfo.setCXXLiteralOperatorNameLoc(Name.EndLocation);
4348 return NameInfo;
Douglas Gregor9de54ea2010-01-13 17:31:36 +00004349
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00004350 case UnqualifiedId::IK_ConversionFunctionId: {
4351 TypeSourceInfo *TInfo;
4352 QualType Ty = GetTypeFromParser(Name.ConversionFunctionId, &TInfo);
4353 if (Ty.isNull())
4354 return DeclarationNameInfo();
4355 NameInfo.setName(Context.DeclarationNames.getCXXConversionFunctionName(
4356 Context.getCanonicalType(Ty)));
4357 NameInfo.setLoc(Name.StartLocation);
4358 NameInfo.setNamedTypeInfo(TInfo);
4359 return NameInfo;
Douglas Gregord90fd522009-09-25 21:45:23 +00004360 }
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00004361
4362 case UnqualifiedId::IK_ConstructorName: {
4363 TypeSourceInfo *TInfo;
4364 QualType Ty = GetTypeFromParser(Name.ConstructorName, &TInfo);
4365 if (Ty.isNull())
4366 return DeclarationNameInfo();
4367 NameInfo.setName(Context.DeclarationNames.getCXXConstructorName(
4368 Context.getCanonicalType(Ty)));
4369 NameInfo.setLoc(Name.StartLocation);
4370 NameInfo.setNamedTypeInfo(TInfo);
4371 return NameInfo;
4372 }
4373
4374 case UnqualifiedId::IK_ConstructorTemplateId: {
4375 // In well-formed code, we can only have a constructor
4376 // template-id that refers to the current context, so go there
4377 // to find the actual type being constructed.
4378 CXXRecordDecl *CurClass = dyn_cast<CXXRecordDecl>(CurContext);
4379 if (!CurClass || CurClass->getIdentifier() != Name.TemplateId->Name)
4380 return DeclarationNameInfo();
4381
4382 // Determine the type of the class being constructed.
4383 QualType CurClassType = Context.getTypeDeclType(CurClass);
4384
4385 // FIXME: Check two things: that the template-id names the same type as
4386 // CurClassType, and that the template-id does not occur when the name
4387 // was qualified.
4388
4389 NameInfo.setName(Context.DeclarationNames.getCXXConstructorName(
4390 Context.getCanonicalType(CurClassType)));
4391 NameInfo.setLoc(Name.StartLocation);
4392 // FIXME: should we retrieve TypeSourceInfo?
Craig Topperc3ec1492014-05-26 06:22:03 +00004393 NameInfo.setNamedTypeInfo(nullptr);
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00004394 return NameInfo;
4395 }
4396
4397 case UnqualifiedId::IK_DestructorName: {
4398 TypeSourceInfo *TInfo;
4399 QualType Ty = GetTypeFromParser(Name.DestructorName, &TInfo);
4400 if (Ty.isNull())
4401 return DeclarationNameInfo();
4402 NameInfo.setName(Context.DeclarationNames.getCXXDestructorName(
4403 Context.getCanonicalType(Ty)));
4404 NameInfo.setLoc(Name.StartLocation);
4405 NameInfo.setNamedTypeInfo(TInfo);
4406 return NameInfo;
4407 }
4408
4409 case UnqualifiedId::IK_TemplateId: {
John McCall3e56fd42010-08-23 07:28:44 +00004410 TemplateName TName = Name.TemplateId->Template.get();
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00004411 SourceLocation TNameLoc = Name.TemplateId->TemplateNameLoc;
4412 return Context.getNameForTemplate(TName, TNameLoc);
4413 }
4414
4415 } // switch (Name.getKind())
4416
David Blaikie83d382b2011-09-23 05:06:16 +00004417 llvm_unreachable("Unknown name kind");
Douglas Gregor92751d42008-11-17 22:58:34 +00004418}
4419
Kaelyn Uhrain7d9bc632011-08-04 17:40:00 +00004420static QualType getCoreType(QualType Ty) {
4421 do {
4422 if (Ty->isPointerType() || Ty->isReferenceType())
4423 Ty = Ty->getPointeeType();
4424 else if (Ty->isArrayType())
4425 Ty = Ty->castAsArrayTypeUnsafe()->getElementType();
4426 else
4427 return Ty.withoutLocalFastQualifiers();
4428 } while (true);
4429}
4430
Kaelyn Uhrain0a32fca2011-10-11 00:28:39 +00004431/// hasSimilarParameters - Determine whether the C++ functions Declaration
4432/// and Definition have "nearly" matching parameters. This heuristic is
4433/// used to improve diagnostics in the case where an out-of-line function
4434/// definition doesn't match any declaration within the class or namespace.
4435/// Also sets Params to the list of indices to the parameters that differ
4436/// between the declaration and the definition. If hasSimilarParameters
4437/// returns true and Params is empty, then all of the parameters match.
4438static bool hasSimilarParameters(ASTContext &Context,
Douglas Gregor8af63e42009-02-06 17:46:57 +00004439 FunctionDecl *Declaration,
Kaelyn Uhrain7d9bc632011-08-04 17:40:00 +00004440 FunctionDecl *Definition,
Dmitri Gribenkof8579502013-01-12 19:30:44 +00004441 SmallVectorImpl<unsigned> &Params) {
Kaelyn Uhrain7d9bc632011-08-04 17:40:00 +00004442 Params.clear();
Douglas Gregorad590502008-12-15 23:53:10 +00004443 if (Declaration->param_size() != Definition->param_size())
4444 return false;
4445 for (unsigned Idx = 0; Idx < Declaration->param_size(); ++Idx) {
4446 QualType DeclParamTy = Declaration->getParamDecl(Idx)->getType();
4447 QualType DefParamTy = Definition->getParamDecl(Idx)->getType();
4448
Kaelyn Uhrain7d9bc632011-08-04 17:40:00 +00004449 // The parameter types are identical
Matt Beaumont-Gay56381b82011-08-23 01:35:51 +00004450 if (Context.hasSameType(DefParamTy, DeclParamTy))
Kaelyn Uhrain7d9bc632011-08-04 17:40:00 +00004451 continue;
4452
4453 QualType DeclParamBaseTy = getCoreType(DeclParamTy);
4454 QualType DefParamBaseTy = getCoreType(DefParamTy);
4455 const IdentifierInfo *DeclTyName = DeclParamBaseTy.getBaseTypeIdentifier();
4456 const IdentifierInfo *DefTyName = DefParamBaseTy.getBaseTypeIdentifier();
4457
4458 if (Context.hasSameUnqualifiedType(DeclParamBaseTy, DefParamBaseTy) ||
4459 (DeclTyName && DeclTyName == DefTyName))
4460 Params.push_back(Idx);
4461 else // The two parameters aren't even close
Douglas Gregorad590502008-12-15 23:53:10 +00004462 return false;
4463 }
4464
4465 return true;
4466}
4467
John McCall99b2fe52010-04-29 23:50:39 +00004468/// NeedsRebuildingInCurrentInstantiation - Checks whether the given
4469/// declarator needs to be rebuilt in the current instantiation.
4470/// Any bits of declarator which appear before the name are valid for
4471/// consideration here. That's specifically the type in the decl spec
4472/// and the base type in any member-pointer chunks.
4473static bool RebuildDeclaratorInCurrentInstantiation(Sema &S, Declarator &D,
4474 DeclarationName Name) {
4475 // The types we specifically need to rebuild are:
4476 // - typenames, typeofs, and decltypes
4477 // - types which will become injected class names
4478 // Of course, we also need to rebuild any type referencing such a
4479 // type. It's safest to just say "dependent", but we call out a
4480 // few cases here.
4481
4482 DeclSpec &DS = D.getMutableDeclSpec();
4483 switch (DS.getTypeSpecType()) {
4484 case DeclSpec::TST_typename:
4485 case DeclSpec::TST_typeofType:
Eli Friedman0dfb8892011-10-06 23:00:33 +00004486 case DeclSpec::TST_underlyingType:
4487 case DeclSpec::TST_atomic: {
John McCall99b2fe52010-04-29 23:50:39 +00004488 // Grab the type from the parser.
Craig Topperc3ec1492014-05-26 06:22:03 +00004489 TypeSourceInfo *TSI = nullptr;
John McCallba7bf592010-08-24 05:47:05 +00004490 QualType T = S.GetTypeFromParser(DS.getRepAsType(), &TSI);
John McCall99b2fe52010-04-29 23:50:39 +00004491 if (T.isNull() || !T->isDependentType()) break;
4492
4493 // Make sure there's a type source info. This isn't really much
4494 // of a waste; most dependent types should have type source info
4495 // attached already.
4496 if (!TSI)
4497 TSI = S.Context.getTrivialTypeSourceInfo(T, DS.getTypeSpecTypeLoc());
4498
4499 // Rebuild the type in the current instantiation.
4500 TSI = S.RebuildTypeInCurrentInstantiation(TSI, D.getIdentifierLoc(), Name);
4501 if (!TSI) return true;
4502
4503 // Store the new type back in the decl spec.
John McCallba7bf592010-08-24 05:47:05 +00004504 ParsedType LocType = S.CreateParsedType(TSI->getType(), TSI);
4505 DS.UpdateTypeRep(LocType);
4506 break;
4507 }
4508
Richard Smith1620ebd2012-10-01 20:35:07 +00004509 case DeclSpec::TST_decltype:
John McCallba7bf592010-08-24 05:47:05 +00004510 case DeclSpec::TST_typeofExpr: {
4511 Expr *E = DS.getRepAsExpr();
John McCalldadc5752010-08-24 06:29:42 +00004512 ExprResult Result = S.RebuildExprInCurrentInstantiation(E);
John McCallba7bf592010-08-24 05:47:05 +00004513 if (Result.isInvalid()) return true;
4514 DS.UpdateExprRep(Result.get());
John McCall99b2fe52010-04-29 23:50:39 +00004515 break;
4516 }
4517
4518 default:
4519 // Nothing to do for these decl specs.
4520 break;
4521 }
4522
4523 // It doesn't matter what order we do this in.
4524 for (unsigned I = 0, E = D.getNumTypeObjects(); I != E; ++I) {
4525 DeclaratorChunk &Chunk = D.getTypeObject(I);
4526
4527 // The only type information in the declarator which can come
4528 // before the declaration name is the base type of a member
4529 // pointer.
4530 if (Chunk.Kind != DeclaratorChunk::MemberPointer)
4531 continue;
4532
4533 // Rebuild the scope specifier in-place.
4534 CXXScopeSpec &SS = Chunk.Mem.Scope();
4535 if (S.RebuildNestedNameSpecifierInCurrentInstantiation(SS))
4536 return true;
4537 }
4538
4539 return false;
4540}
4541
Anders Carlsson1052fd72011-07-04 16:28:17 +00004542Decl *Sema::ActOnDeclarator(Scope *S, Declarator &D) {
Douglas Gregor5d1b4e32011-11-07 20:56:01 +00004543 D.setFunctionDefinitionKind(FDK_Declaration);
Benjamin Kramercc4c49d2012-08-23 23:38:35 +00004544 Decl *Dcl = HandleDeclarator(S, D, MultiTemplateParamsArg());
Argyrios Kyrtzidis8ad3bab2011-11-23 20:27:36 +00004545
4546 if (OriginalLexicalContext && OriginalLexicalContext->isObjCContainer() &&
Douglas Gregor205b0682012-04-30 18:13:01 +00004547 Dcl && Dcl->getDeclContext()->isFileContext())
Argyrios Kyrtzidis8ad3bab2011-11-23 20:27:36 +00004548 Dcl->setTopLevelDeclInObjCContainer();
4549
4550 return Dcl;
John McCallde6836a2010-08-24 07:21:54 +00004551}
4552
Richard Smithdda56e42011-04-15 14:24:37 +00004553/// DiagnoseClassNameShadow - Implement C++ [class.mem]p13:
4554/// If T is the name of a class, then each of the following shall have a
4555/// name different from T:
4556/// - every static data member of class T;
4557/// - every member function of class T
4558/// - every member of class T that is itself a type;
4559/// \returns true if the declaration name violates these rules.
4560bool Sema::DiagnoseClassNameShadow(DeclContext *DC,
4561 DeclarationNameInfo NameInfo) {
4562 DeclarationName Name = NameInfo.getName();
4563
4564 if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(DC))
4565 if (Record->getIdentifier() && Record->getDeclName() == Name) {
4566 Diag(NameInfo.getLoc(), diag::err_member_name_of_class) << Name;
4567 return true;
4568 }
4569
4570 return false;
4571}
Douglas Gregor31feb332012-03-17 23:06:31 +00004572
Douglas Gregorb7d17dd2012-03-28 16:01:27 +00004573/// \brief Diagnose a declaration whose declarator-id has the given
4574/// nested-name-specifier.
4575///
4576/// \param SS The nested-name-specifier of the declarator-id.
4577///
4578/// \param DC The declaration context to which the nested-name-specifier
4579/// resolves.
4580///
4581/// \param Name The name of the entity being declared.
4582///
4583/// \param Loc The location of the name of the entity being declared.
Douglas Gregor31feb332012-03-17 23:06:31 +00004584///
4585/// \returns true if we cannot safely recover from this error, false otherwise.
Douglas Gregorb7d17dd2012-03-28 16:01:27 +00004586bool Sema::diagnoseQualifiedDeclaration(CXXScopeSpec &SS, DeclContext *DC,
Douglas Gregor31feb332012-03-17 23:06:31 +00004587 DeclarationName Name,
Richard Smitha2302242013-12-05 07:51:02 +00004588 SourceLocation Loc) {
Douglas Gregorb7d17dd2012-03-28 16:01:27 +00004589 DeclContext *Cur = CurContext;
Eli Friedmane2358c12013-08-12 21:54:01 +00004590 while (isa<LinkageSpecDecl>(Cur) || isa<CapturedDecl>(Cur))
Douglas Gregorb7d17dd2012-03-28 16:01:27 +00004591 Cur = Cur->getParent();
Richard Smitha2302242013-12-05 07:51:02 +00004592
4593 // If the user provided a superfluous scope specifier that refers back to the
4594 // class in which the entity is already declared, diagnose and ignore it.
Douglas Gregor31feb332012-03-17 23:06:31 +00004595 //
4596 // class X {
4597 // void X::f();
4598 // };
Richard Smitha2302242013-12-05 07:51:02 +00004599 //
4600 // Note, it was once ill-formed to give redundant qualification in all
4601 // contexts, but that rule was removed by DR482.
Douglas Gregorb7d17dd2012-03-28 16:01:27 +00004602 if (Cur->Equals(DC)) {
Richard Smitha2302242013-12-05 07:51:02 +00004603 if (Cur->isRecord()) {
4604 Diag(Loc, LangOpts.MicrosoftExt ? diag::warn_member_extra_qualification
4605 : diag::err_member_extra_qualification)
4606 << Name << FixItHint::CreateRemoval(SS.getRange());
4607 SS.clear();
4608 } else {
4609 Diag(Loc, diag::warn_namespace_member_extra_qualification) << Name;
4610 }
Douglas Gregor31feb332012-03-17 23:06:31 +00004611 return false;
Richard Smitha2302242013-12-05 07:51:02 +00004612 }
Douglas Gregorb7d17dd2012-03-28 16:01:27 +00004613
4614 // Check whether the qualifying scope encloses the scope of the original
4615 // declaration.
4616 if (!Cur->Encloses(DC)) {
4617 if (Cur->isRecord())
4618 Diag(Loc, diag::err_member_qualification)
4619 << Name << SS.getRange();
4620 else if (isa<TranslationUnitDecl>(DC))
4621 Diag(Loc, diag::err_invalid_declarator_global_scope)
4622 << Name << SS.getRange();
4623 else if (isa<FunctionDecl>(Cur))
4624 Diag(Loc, diag::err_invalid_declarator_in_function)
4625 << Name << SS.getRange();
Eli Friedmane2358c12013-08-12 21:54:01 +00004626 else if (isa<BlockDecl>(Cur))
4627 Diag(Loc, diag::err_invalid_declarator_in_block)
4628 << Name << SS.getRange();
Douglas Gregorb7d17dd2012-03-28 16:01:27 +00004629 else
4630 Diag(Loc, diag::err_invalid_declarator_scope)
Richard Smith82269842012-04-13 04:07:40 +00004631 << Name << cast<NamedDecl>(Cur) << cast<NamedDecl>(DC) << SS.getRange();
Douglas Gregorb7d17dd2012-03-28 16:01:27 +00004632
Douglas Gregor31feb332012-03-17 23:06:31 +00004633 return true;
Douglas Gregorb7d17dd2012-03-28 16:01:27 +00004634 }
4635
4636 if (Cur->isRecord()) {
4637 // Cannot qualify members within a class.
4638 Diag(Loc, diag::err_member_qualification)
4639 << Name << SS.getRange();
4640 SS.clear();
4641
4642 // C++ constructors and destructors with incorrect scopes can break
4643 // our AST invariants by having the wrong underlying types. If
4644 // that's the case, then drop this declaration entirely.
4645 if ((Name.getNameKind() == DeclarationName::CXXConstructorName ||
4646 Name.getNameKind() == DeclarationName::CXXDestructorName) &&
4647 !Context.hasSameType(Name.getCXXNameType(),
4648 Context.getTypeDeclType(cast<CXXRecordDecl>(Cur))))
4649 return true;
4650
4651 return false;
4652 }
Douglas Gregor31feb332012-03-17 23:06:31 +00004653
Douglas Gregorb7d17dd2012-03-28 16:01:27 +00004654 // C++11 [dcl.meaning]p1:
4655 // [...] "The nested-name-specifier of the qualified declarator-id shall
4656 // not begin with a decltype-specifer"
4657 NestedNameSpecifierLoc SpecLoc(SS.getScopeRep(), SS.location_data());
4658 while (SpecLoc.getPrefix())
4659 SpecLoc = SpecLoc.getPrefix();
4660 if (dyn_cast_or_null<DecltypeType>(
4661 SpecLoc.getNestedNameSpecifier()->getAsType()))
4662 Diag(Loc, diag::err_decltype_in_declarator)
4663 << SpecLoc.getTypeLoc().getSourceRange();
4664
Douglas Gregor31feb332012-03-17 23:06:31 +00004665 return false;
4666}
4667
Rafael Espindola0a67e2f2013-01-08 20:44:06 +00004668NamedDecl *Sema::HandleDeclarator(Scope *S, Declarator &D,
4669 MultiTemplateParamsArg TemplateParamLists) {
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00004670 // TODO: consider using NameInfo for diagnostic.
4671 DeclarationNameInfo NameInfo = GetNameForDeclarator(D);
4672 DeclarationName Name = NameInfo.getName();
Douglas Gregor92751d42008-11-17 22:58:34 +00004673
Chris Lattner02c04392007-07-25 00:24:17 +00004674 // All of these full declarators require an identifier. If it doesn't have
4675 // one, the ParsedFreeStandingDeclSpec action should be used.
Douglas Gregor92751d42008-11-17 22:58:34 +00004676 if (!Name) {
Chris Lattnerf6d1c9c2009-04-25 08:06:05 +00004677 if (!D.isInvalidType()) // Reject this if we think it is valid.
Daniel Dunbar62ee6412012-03-09 18:35:03 +00004678 Diag(D.getDeclSpec().getLocStart(),
Chris Lattner3b054132008-11-19 05:08:23 +00004679 diag::err_declarator_need_ident)
4680 << D.getDeclSpec().getSourceRange() << D.getSourceRange();
Craig Topperc3ec1492014-05-26 06:22:03 +00004681 return nullptr;
Douglas Gregorc4356532010-12-16 00:46:58 +00004682 } else if (DiagnoseUnexpandedParameterPack(NameInfo, UPPC_DeclarationType))
Craig Topperc3ec1492014-05-26 06:22:03 +00004683 return nullptr;
Mike Stump11289f42009-09-09 15:08:12 +00004684
Chris Lattner1a76a3c2007-08-26 06:24:45 +00004685 // The scope passed in may not be a decl scope. Zip up the scope tree until
4686 // we find one that is.
Douglas Gregor91f84212008-12-11 16:49:14 +00004687 while ((S->getFlags() & Scope::DeclScope) == 0 ||
Douglas Gregorded2d7b2009-02-04 19:02:06 +00004688 (S->getFlags() & Scope::TemplateParamScope) != 0)
Chris Lattner1a76a3c2007-08-26 06:24:45 +00004689 S = S->getParent();
Mike Stump11289f42009-09-09 15:08:12 +00004690
John McCall99b2fe52010-04-29 23:50:39 +00004691 DeclContext *DC = CurContext;
4692 if (D.getCXXScopeSpec().isInvalid())
4693 D.setInvalidType();
4694 else if (D.getCXXScopeSpec().isSet()) {
Douglas Gregor6c110f32010-12-16 01:14:37 +00004695 if (DiagnoseUnexpandedParameterPack(D.getCXXScopeSpec(),
4696 UPPC_DeclarationQualifier))
Craig Topperc3ec1492014-05-26 06:22:03 +00004697 return nullptr;
Douglas Gregor6c110f32010-12-16 01:14:37 +00004698
John McCall99b2fe52010-04-29 23:50:39 +00004699 bool EnteringContext = !D.getDeclSpec().isFriendSpecified();
4700 DC = computeDeclContext(D.getCXXScopeSpec(), EnteringContext);
Richard Smith8ac1c922013-11-25 21:30:29 +00004701 if (!DC || isa<EnumDecl>(DC)) {
John McCall99b2fe52010-04-29 23:50:39 +00004702 // If we could not compute the declaration context, it's because the
4703 // declaration context is dependent but does not refer to a class,
4704 // class template, or class template partial specialization. Complain
4705 // and return early, to avoid the coming semantic disaster.
4706 Diag(D.getIdentifierLoc(),
4707 diag::err_template_qualified_declarator_no_match)
Aaron Ballman4a979672014-01-03 13:56:08 +00004708 << D.getCXXScopeSpec().getScopeRep()
John McCall99b2fe52010-04-29 23:50:39 +00004709 << D.getCXXScopeSpec().getRange();
Craig Topperc3ec1492014-05-26 06:22:03 +00004710 return nullptr;
John McCall99b2fe52010-04-29 23:50:39 +00004711 }
John McCall99b2fe52010-04-29 23:50:39 +00004712 bool IsDependentContext = DC->isDependentContext();
John McCall4d6d6132009-12-19 09:35:56 +00004713
John McCall99b2fe52010-04-29 23:50:39 +00004714 if (!IsDependentContext &&
John McCall0b66eb32010-05-01 00:40:08 +00004715 RequireCompleteDeclContext(D.getCXXScopeSpec(), DC))
Craig Topperc3ec1492014-05-26 06:22:03 +00004716 return nullptr;
John McCall99b2fe52010-04-29 23:50:39 +00004717
Serge Pavlov47ebb752015-06-10 19:06:59 +00004718 // If a class is incomplete, do not parse entities inside it.
Douglas Gregorb7d17dd2012-03-28 16:01:27 +00004719 if (isa<CXXRecordDecl>(DC) && !cast<CXXRecordDecl>(DC)->hasDefinition()) {
4720 Diag(D.getIdentifierLoc(),
4721 diag::err_member_def_undefined_record)
4722 << Name << DC << D.getCXXScopeSpec().getRange();
Serge Pavlov47ebb752015-06-10 19:06:59 +00004723 return nullptr;
4724 }
4725 if (!D.getDeclSpec().isFriendSpecified()) {
Douglas Gregorb7d17dd2012-03-28 16:01:27 +00004726 if (diagnoseQualifiedDeclaration(D.getCXXScopeSpec(), DC,
4727 Name, D.getIdentifierLoc())) {
4728 if (DC->isRecord())
Craig Topperc3ec1492014-05-26 06:22:03 +00004729 return nullptr;
4730
Douglas Gregorb7d17dd2012-03-28 16:01:27 +00004731 D.setInvalidType();
Douglas Gregora007d362010-10-13 22:19:53 +00004732 }
John McCall99b2fe52010-04-29 23:50:39 +00004733 }
4734
4735 // Check whether we need to rebuild the type of the given
4736 // declaration in the current instantiation.
4737 if (EnteringContext && IsDependentContext &&
4738 TemplateParamLists.size() != 0) {
4739 ContextRAII SavedContext(*this, DC);
4740 if (RebuildDeclaratorInCurrentInstantiation(*this, D, Name))
4741 D.setInvalidType();
Douglas Gregor15acfb92009-08-06 16:20:37 +00004742 }
4743 }
Richard Smithdda56e42011-04-15 14:24:37 +00004744
4745 if (DiagnoseClassNameShadow(DC, NameInfo))
4746 // If this is a typedef, we'll end up spewing multiple diagnostics.
4747 // Just return early; it's safer.
4748 if (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_typedef)
Craig Topperc3ec1492014-05-26 06:22:03 +00004749 return nullptr;
4750
John McCall8cb7bdf2010-06-04 23:28:52 +00004751 TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S);
4752 QualType R = TInfo->getType();
Douglas Gregoreddf4332009-02-24 20:03:32 +00004753
Douglas Gregor506bd562010-12-13 22:49:22 +00004754 if (DiagnoseUnexpandedParameterPack(D.getIdentifierLoc(), TInfo,
4755 UPPC_DeclarationType))
4756 D.setInvalidType();
4757
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00004758 LookupResult Previous(*this, NameInfo, LookupOrdinaryName,
John McCall1f82f242009-11-18 22:49:29 +00004759 ForRedeclaration);
4760
Argyrios Kyrtzidis16ac9be2008-11-08 17:17:31 +00004761 // See if this is a redefinition of a variable in the same scope.
John McCall99b2fe52010-04-29 23:50:39 +00004762 if (!D.getCXXScopeSpec().isSet()) {
John McCall1f82f242009-11-18 22:49:29 +00004763 bool IsLinkageLookup = false;
Richard Smith1c34fb72013-08-13 18:18:50 +00004764 bool CreateBuiltins = false;
Douglas Gregoreddf4332009-02-24 20:03:32 +00004765
4766 // If the declaration we're planning to build will be a function
4767 // or object with linkage, then look for another declaration with
4768 // linkage (C99 6.2.2p4-5 and C++ [basic.link]p6).
Richard Smith1c34fb72013-08-13 18:18:50 +00004769 //
4770 // If the declaration we're planning to build will be declared with
4771 // external linkage in the translation unit, create any builtin with
4772 // the same name.
Douglas Gregoreddf4332009-02-24 20:03:32 +00004773 if (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_typedef)
4774 /* Do nothing*/;
Richard Smith1c34fb72013-08-13 18:18:50 +00004775 else if (CurContext->isFunctionOrMethod() &&
4776 (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_extern ||
4777 R->isFunctionType())) {
John McCall1f82f242009-11-18 22:49:29 +00004778 IsLinkageLookup = true;
Richard Smith1c34fb72013-08-13 18:18:50 +00004779 CreateBuiltins =
4780 CurContext->getEnclosingNamespaceContext()->isTranslationUnit();
4781 } else if (CurContext->getRedeclContext()->isTranslationUnit() &&
4782 D.getDeclSpec().getStorageClassSpec() != DeclSpec::SCS_static)
4783 CreateBuiltins = true;
John McCall1f82f242009-11-18 22:49:29 +00004784
4785 if (IsLinkageLookup)
4786 Previous.clear(LookupRedeclarationWithLinkage);
Douglas Gregoreddf4332009-02-24 20:03:32 +00004787
Richard Smith1c34fb72013-08-13 18:18:50 +00004788 LookupName(Previous, S, CreateBuiltins);
Argyrios Kyrtzidis16ac9be2008-11-08 17:17:31 +00004789 } else { // Something like "int foo::x;"
John McCall1f82f242009-11-18 22:49:29 +00004790 LookupQualifiedName(Previous, DC);
4791
Douglas Gregorb7d17dd2012-03-28 16:01:27 +00004792 // C++ [dcl.meaning]p1:
4793 // When the declarator-id is qualified, the declaration shall refer to a
4794 // previously declared member of the class or namespace to which the
4795 // qualifier refers (or, in the case of a namespace, of an element of the
4796 // inline namespace set of that namespace (7.3.1)) or to a specialization
4797 // thereof; [...]
Argyrios Kyrtzidis16ac9be2008-11-08 17:17:31 +00004798 //
Douglas Gregorb7d17dd2012-03-28 16:01:27 +00004799 // Note that we already checked the context above, and that we do not have
4800 // enough information to make sure that Previous contains the declaration
4801 // we want to match. For example, given:
Douglas Gregorad590502008-12-15 23:53:10 +00004802 //
Douglas Gregor4287b372008-12-12 08:25:50 +00004803 // class X {
4804 // void f();
Douglas Gregorad590502008-12-15 23:53:10 +00004805 // void f(float);
Douglas Gregor4287b372008-12-12 08:25:50 +00004806 // };
4807 //
Douglas Gregorad590502008-12-15 23:53:10 +00004808 // void X::f(int) { } // ill-formed
4809 //
Douglas Gregorb7d17dd2012-03-28 16:01:27 +00004810 // In this case, Previous will point to the overload set
Douglas Gregorad590502008-12-15 23:53:10 +00004811 // containing the two f's declared in X, but neither of them
Mike Stump11289f42009-09-09 15:08:12 +00004812 // matches.
Douglas Gregorb7d17dd2012-03-28 16:01:27 +00004813
4814 // C++ [dcl.meaning]p1:
4815 // [...] the member shall not merely have been introduced by a
4816 // using-declaration in the scope of the class or namespace nominated by
4817 // the nested-name-specifier of the declarator-id.
4818 RemoveUsingDecls(Previous);
Argyrios Kyrtzidis16ac9be2008-11-08 17:17:31 +00004819 }
4820
John McCall1f82f242009-11-18 22:49:29 +00004821 if (Previous.isSingleResult() &&
4822 Previous.getFoundDecl()->isTemplateParameter()) {
Douglas Gregor5101c242008-12-05 18:15:24 +00004823 // Maybe we will complain about the shadowed template parameter.
Mike Stump11289f42009-09-09 15:08:12 +00004824 if (!D.isInvalidType())
Douglas Gregorf4ef4d22011-10-20 17:58:49 +00004825 DiagnoseTemplateParameterShadow(D.getIdentifierLoc(),
4826 Previous.getFoundDecl());
Mike Stump11289f42009-09-09 15:08:12 +00004827
Douglas Gregor5101c242008-12-05 18:15:24 +00004828 // Just pretend that we didn't see the previous declaration.
John McCall1f82f242009-11-18 22:49:29 +00004829 Previous.clear();
Douglas Gregor5101c242008-12-05 18:15:24 +00004830 }
4831
Douglas Gregor83a586e2008-04-13 21:07:44 +00004832 // In C++, the previous declaration we find might be a tag type
4833 // (class or enum). In this case, the new declaration will hide the
Douglas Gregorfb034662009-01-28 17:15:10 +00004834 // tag type. Note that this does does not apply if we're declaring a
4835 // typedef (C++ [dcl.typedef]p4).
John McCall1f82f242009-11-18 22:49:29 +00004836 if (Previous.isSingleTagDecl() &&
Kaelyn Uhrain5dfc94b2013-12-16 19:25:47 +00004837 D.getDeclSpec().getStorageClassSpec() != DeclSpec::SCS_typedef)
John McCall1f82f242009-11-18 22:49:29 +00004838 Previous.clear();
Douglas Gregor83a586e2008-04-13 21:07:44 +00004839
Richard Smith5afcdf3f2013-03-06 01:37:38 +00004840 // Check that there are no default arguments other than in the parameters
4841 // of a function declaration (C++ only).
4842 if (getLangOpts().CPlusPlus)
4843 CheckExtraCXXDefaultArguments(D);
4844
Nico Webercb4c7f42012-12-23 00:40:46 +00004845 NamedDecl *New;
4846
Francois Pichet00c7e6c2011-08-14 03:52:19 +00004847 bool AddToScope = true;
Chris Lattner01a7c532007-01-25 23:09:03 +00004848 if (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_typedef) {
Douglas Gregorb52fabb2009-06-23 23:11:28 +00004849 if (TemplateParamLists.size()) {
4850 Diag(D.getIdentifierLoc(), diag::err_template_typedef);
Craig Topperc3ec1492014-05-26 06:22:03 +00004851 return nullptr;
Douglas Gregorb52fabb2009-06-23 23:11:28 +00004852 }
Mike Stump11289f42009-09-09 15:08:12 +00004853
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00004854 New = ActOnTypedefDeclarator(S, D, DC, TInfo, Previous);
Douglas Gregoreddf4332009-02-24 20:03:32 +00004855 } else if (R->isFunctionType()) {
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00004856 New = ActOnFunctionDeclarator(S, D, DC, TInfo, Previous,
Benjamin Kramer62b95d82012-08-23 21:35:17 +00004857 TemplateParamLists,
Francois Pichet00c7e6c2011-08-14 03:52:19 +00004858 AddToScope);
Chris Lattner01a7c532007-01-25 23:09:03 +00004859 } else {
Larisse Voufo39a1e502013-08-06 01:03:05 +00004860 New = ActOnVariableDeclarator(S, D, DC, TInfo, Previous, TemplateParamLists,
4861 AddToScope);
Chris Lattner01a7c532007-01-25 23:09:03 +00004862 }
Zhongxing Xubece5d62009-01-16 01:13:29 +00004863
Craig Topperc3ec1492014-05-26 06:22:03 +00004864 if (!New)
4865 return nullptr;
Mike Stump11289f42009-09-09 15:08:12 +00004866
Douglas Gregor3a923c2d2009-09-24 23:14:47 +00004867 // If this has an identifier and is not an invalid redeclaration or
4868 // function template specialization, add it to the scope stack.
Francois Pichet00c7e6c2011-08-14 03:52:19 +00004869 if (New->getDeclName() && AddToScope &&
Richard Smith541b38b2013-09-20 01:15:31 +00004870 !(D.isRedeclaration() && New->isInvalidDecl())) {
4871 // Only make a locally-scoped extern declaration visible if it is the first
4872 // declaration of this entity. Qualified lookup for such an entity should
4873 // only find this declaration if there is no visible declaration of it.
4874 bool AddToContext = !D.isRedeclaration() || !New->isLocalExternDecl();
4875 PushOnScopeChains(New, S, AddToContext);
4876 if (!AddToContext)
4877 CurContext->addHiddenDecl(New);
4878 }
Mike Stump11289f42009-09-09 15:08:12 +00004879
John McCall48871652010-08-21 09:40:31 +00004880 return New;
Chris Lattnere168f762006-11-10 05:29:30 +00004881}
4882
Abramo Bagnaraad9f2e22012-11-08 16:27:30 +00004883/// Helper method to turn variable array types into constant array
4884/// types in certain situations which would otherwise be errors (for
4885/// GCC compatibility).
Eli Friedmana3b1d032009-02-21 00:44:51 +00004886static QualType TryToFixInvalidVariablyModifiedType(QualType T,
4887 ASTContext &Context,
Douglas Gregorcaa1bf42010-08-18 00:39:00 +00004888 bool &SizeIsNegative,
4889 llvm::APSInt &Oversized) {
Eli Friedmana3b1d032009-02-21 00:44:51 +00004890 // This method tries to turn a variable array into a constant
4891 // array even when the size isn't an ICE. This is necessary
4892 // for compatibility with code that depends on gcc's buggy
4893 // constant expression folding, like struct {char x[(int)(char*)2];}
4894 SizeIsNegative = false;
Douglas Gregorcaa1bf42010-08-18 00:39:00 +00004895 Oversized = 0;
4896
4897 if (T->isDependentType())
4898 return QualType();
4899
John McCall8ccfcb52009-09-24 19:53:00 +00004900 QualifierCollector Qs;
4901 const Type *Ty = Qs.strip(T);
4902
4903 if (const PointerType* PTy = dyn_cast<PointerType>(Ty)) {
Eli Friedmana3b1d032009-02-21 00:44:51 +00004904 QualType Pointee = PTy->getPointeeType();
4905 QualType FixedType =
Douglas Gregorcaa1bf42010-08-18 00:39:00 +00004906 TryToFixInvalidVariablyModifiedType(Pointee, Context, SizeIsNegative,
4907 Oversized);
Eli Friedmana3b1d032009-02-21 00:44:51 +00004908 if (FixedType.isNull()) return FixedType;
Eli Friedman44c0f2a2009-02-21 00:58:02 +00004909 FixedType = Context.getPointerType(FixedType);
John McCall717d9b02010-12-10 11:01:00 +00004910 return Qs.apply(Context, FixedType);
Eli Friedmana3b1d032009-02-21 00:44:51 +00004911 }
Abramo Bagnara924a8f32010-12-10 16:29:40 +00004912 if (const ParenType* PTy = dyn_cast<ParenType>(Ty)) {
4913 QualType Inner = PTy->getInnerType();
4914 QualType FixedType =
4915 TryToFixInvalidVariablyModifiedType(Inner, Context, SizeIsNegative,
4916 Oversized);
4917 if (FixedType.isNull()) return FixedType;
4918 FixedType = Context.getParenType(FixedType);
4919 return Qs.apply(Context, FixedType);
4920 }
Eli Friedmana3b1d032009-02-21 00:44:51 +00004921
4922 const VariableArrayType* VLATy = dyn_cast<VariableArrayType>(T);
Eli Friedmanadf40d42009-02-26 03:58:54 +00004923 if (!VLATy)
4924 return QualType();
4925 // FIXME: We should probably handle this case
4926 if (VLATy->getElementType()->isVariablyModifiedType())
4927 return QualType();
Mike Stump11289f42009-09-09 15:08:12 +00004928
Richard Smith42d3af92011-12-07 00:43:50 +00004929 llvm::APSInt Res;
Eli Friedmana3b1d032009-02-21 00:44:51 +00004930 if (!VLATy->getSizeExpr() ||
Richard Smith42d3af92011-12-07 00:43:50 +00004931 !VLATy->getSizeExpr()->EvaluateAsInt(Res, Context))
Eli Friedmana3b1d032009-02-21 00:44:51 +00004932 return QualType();
Eli Friedmanadf40d42009-02-26 03:58:54 +00004933
Douglas Gregorcaa1bf42010-08-18 00:39:00 +00004934 // Check whether the array size is negative.
Douglas Gregorcaa1bf42010-08-18 00:39:00 +00004935 if (Res.isSigned() && Res.isNegative()) {
4936 SizeIsNegative = true;
4937 return QualType();
Douglas Gregor04318252009-07-06 15:59:29 +00004938 }
Eli Friedmana3b1d032009-02-21 00:44:51 +00004939
Douglas Gregorcaa1bf42010-08-18 00:39:00 +00004940 // Check whether the array is too large to be addressed.
4941 unsigned ActiveSizeBits
4942 = ConstantArrayType::getNumAddressingBits(Context, VLATy->getElementType(),
4943 Res);
4944 if (ActiveSizeBits > ConstantArrayType::getMaxSizeBits(Context)) {
4945 Oversized = Res;
4946 return QualType();
4947 }
4948
4949 return Context.getConstantArrayType(VLATy->getElementType(),
4950 Res, ArrayType::Normal, 0);
Eli Friedmana3b1d032009-02-21 00:44:51 +00004951}
4952
Abramo Bagnara341ab732012-11-08 14:44:42 +00004953static void
4954FixInvalidVariablyModifiedTypeLoc(TypeLoc SrcTL, TypeLoc DstTL) {
David Majnemerbc4cc142015-04-18 04:55:51 +00004955 SrcTL = SrcTL.getUnqualifiedLoc();
4956 DstTL = DstTL.getUnqualifiedLoc();
David Blaikie6adc78e2013-02-18 22:06:02 +00004957 if (PointerTypeLoc SrcPTL = SrcTL.getAs<PointerTypeLoc>()) {
4958 PointerTypeLoc DstPTL = DstTL.castAs<PointerTypeLoc>();
4959 FixInvalidVariablyModifiedTypeLoc(SrcPTL.getPointeeLoc(),
4960 DstPTL.getPointeeLoc());
4961 DstPTL.setStarLoc(SrcPTL.getStarLoc());
Abramo Bagnara341ab732012-11-08 14:44:42 +00004962 return;
4963 }
David Blaikie6adc78e2013-02-18 22:06:02 +00004964 if (ParenTypeLoc SrcPTL = SrcTL.getAs<ParenTypeLoc>()) {
4965 ParenTypeLoc DstPTL = DstTL.castAs<ParenTypeLoc>();
4966 FixInvalidVariablyModifiedTypeLoc(SrcPTL.getInnerLoc(),
4967 DstPTL.getInnerLoc());
4968 DstPTL.setLParenLoc(SrcPTL.getLParenLoc());
4969 DstPTL.setRParenLoc(SrcPTL.getRParenLoc());
Abramo Bagnara341ab732012-11-08 14:44:42 +00004970 return;
4971 }
David Blaikie6adc78e2013-02-18 22:06:02 +00004972 ArrayTypeLoc SrcATL = SrcTL.castAs<ArrayTypeLoc>();
4973 ArrayTypeLoc DstATL = DstTL.castAs<ArrayTypeLoc>();
4974 TypeLoc SrcElemTL = SrcATL.getElementLoc();
4975 TypeLoc DstElemTL = DstATL.getElementLoc();
Abramo Bagnara341ab732012-11-08 14:44:42 +00004976 DstElemTL.initializeFullCopy(SrcElemTL);
David Blaikie6adc78e2013-02-18 22:06:02 +00004977 DstATL.setLBracketLoc(SrcATL.getLBracketLoc());
4978 DstATL.setSizeExpr(SrcATL.getSizeExpr());
4979 DstATL.setRBracketLoc(SrcATL.getRBracketLoc());
Abramo Bagnara341ab732012-11-08 14:44:42 +00004980}
4981
Abramo Bagnaraad9f2e22012-11-08 16:27:30 +00004982/// Helper method to turn variable array types into constant array
4983/// types in certain situations which would otherwise be errors (for
4984/// GCC compatibility).
Abramo Bagnara341ab732012-11-08 14:44:42 +00004985static TypeSourceInfo*
4986TryToFixInvalidVariablyModifiedTypeSourceInfo(TypeSourceInfo *TInfo,
4987 ASTContext &Context,
4988 bool &SizeIsNegative,
4989 llvm::APSInt &Oversized) {
4990 QualType FixedTy
4991 = TryToFixInvalidVariablyModifiedType(TInfo->getType(), Context,
4992 SizeIsNegative, Oversized);
4993 if (FixedTy.isNull())
Craig Topperc3ec1492014-05-26 06:22:03 +00004994 return nullptr;
Abramo Bagnara341ab732012-11-08 14:44:42 +00004995 TypeSourceInfo *FixedTInfo = Context.getTrivialTypeSourceInfo(FixedTy);
4996 FixInvalidVariablyModifiedTypeLoc(TInfo->getTypeLoc(),
4997 FixedTInfo->getTypeLoc());
4998 return FixedTInfo;
4999}
5000
Richard Smith78165b52013-01-10 23:43:47 +00005001/// \brief Register the given locally-scoped extern "C" declaration so
Richard Smith39b79682013-06-18 20:15:12 +00005002/// that it can be found later for redeclarations. We include any extern "C"
5003/// declaration that is not visible in the translation unit here, not just
5004/// function-scope declarations.
Mike Stump11289f42009-09-09 15:08:12 +00005005void
Richard Smith39b79682013-06-18 20:15:12 +00005006Sema::RegisterLocallyScopedExternCDecl(NamedDecl *ND, Scope *S) {
Richard Smithac974a32013-06-30 09:48:50 +00005007 if (!getLangOpts().CPlusPlus &&
5008 ND->getLexicalDeclContext()->getRedeclContext()->isTranslationUnit())
5009 // Don't need to track declarations in the TU in C.
5010 return;
5011
Douglas Gregor5a80bd12009-03-02 00:19:53 +00005012 // Note that we have a locally-scoped external with this name.
Richard Smithf19e1272015-03-07 00:04:49 +00005013 Context.getExternCContextDecl()->makeDeclVisibleInContext(ND);
Douglas Gregor5a80bd12009-03-02 00:19:53 +00005014}
5015
Richard Smith39b79682013-06-18 20:15:12 +00005016NamedDecl *Sema::findLocallyScopedExternCDecl(DeclarationName Name) {
Richard Smithf19e1272015-03-07 00:04:49 +00005017 // FIXME: We can have multiple results via __attribute__((overloadable)).
5018 auto Result = Context.getExternCContextDecl()->lookup(Name);
5019 return Result.empty() ? nullptr : *Result.begin();
Douglas Gregordc5c9582011-07-28 14:20:37 +00005020}
5021
Eli Friedman574c7452009-04-07 19:37:57 +00005022/// \brief Diagnose function specifiers on a declaration of an identifier that
5023/// does not identify a function.
Richard Smithb1402ae2013-03-18 22:52:47 +00005024void Sema::DiagnoseFunctionSpecifiers(const DeclSpec &DS) {
Eli Friedman574c7452009-04-07 19:37:57 +00005025 // FIXME: We should probably indicate the identifier in question to avoid
5026 // confusion for constructs like "inline int a(), b;"
Richard Smithb1402ae2013-03-18 22:52:47 +00005027 if (DS.isInlineSpecified())
5028 Diag(DS.getInlineSpecLoc(),
Eli Friedman574c7452009-04-07 19:37:57 +00005029 diag::err_inline_non_function);
5030
Richard Smithb1402ae2013-03-18 22:52:47 +00005031 if (DS.isVirtualSpecified())
5032 Diag(DS.getVirtualSpecLoc(),
Eli Friedman574c7452009-04-07 19:37:57 +00005033 diag::err_virtual_non_function);
5034
Richard Smithb1402ae2013-03-18 22:52:47 +00005035 if (DS.isExplicitSpecified())
5036 Diag(DS.getExplicitSpecLoc(),
Eli Friedman574c7452009-04-07 19:37:57 +00005037 diag::err_explicit_non_function);
Richard Smith0015f092013-01-17 22:16:11 +00005038
Richard Smithb1402ae2013-03-18 22:52:47 +00005039 if (DS.isNoreturnSpecified())
5040 Diag(DS.getNoreturnSpecLoc(),
Richard Smith0015f092013-01-17 22:16:11 +00005041 diag::err_noreturn_non_function);
Eli Friedman574c7452009-04-07 19:37:57 +00005042}
5043
Douglas Gregor6e6ad602009-01-20 01:17:11 +00005044NamedDecl*
Zhongxing Xuac8ef9e2009-01-16 03:34:13 +00005045Sema::ActOnTypedefDeclarator(Scope* S, Declarator& D, DeclContext* DC,
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00005046 TypeSourceInfo *TInfo, LookupResult &Previous) {
Zhongxing Xuac8ef9e2009-01-16 03:34:13 +00005047 // Typedef declarators cannot be qualified (C++ [dcl.meaning]p1).
5048 if (D.getCXXScopeSpec().isSet()) {
5049 Diag(D.getIdentifierLoc(), diag::err_qualified_typedef_declarator)
5050 << D.getCXXScopeSpec().getRange();
Chris Lattnerf6d1c9c2009-04-25 08:06:05 +00005051 D.setInvalidType();
Zhongxing Xuac8ef9e2009-01-16 03:34:13 +00005052 // Pretend we didn't see the scope specifier.
Douglas Gregorb525ef82010-03-23 15:26:55 +00005053 DC = CurContext;
5054 Previous.clear();
Zhongxing Xuac8ef9e2009-01-16 03:34:13 +00005055 }
5056
Richard Smithb1402ae2013-03-18 22:52:47 +00005057 DiagnoseFunctionSpecifiers(D.getDeclSpec());
Eli Friedman574c7452009-04-07 19:37:57 +00005058
Richard Smitha77a0a62011-08-15 21:04:07 +00005059 if (D.getDeclSpec().isConstexprSpecified())
5060 Diag(D.getDeclSpec().getConstexprSpecLoc(), diag::err_invalid_constexpr)
5061 << 1;
Eli Friedmand5c0eed2009-04-19 20:27:55 +00005062
Douglas Gregord8f446f2010-07-13 06:37:01 +00005063 if (D.getName().Kind != UnqualifiedId::IK_Identifier) {
5064 Diag(D.getName().StartLocation, diag::err_typedef_not_identifier)
5065 << D.getName().getSourceRange();
Craig Topperc3ec1492014-05-26 06:22:03 +00005066 return nullptr;
Douglas Gregord8f446f2010-07-13 06:37:01 +00005067 }
5068
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00005069 TypedefDecl *NewTD = ParseTypedefDecl(S, D, TInfo->getType(), TInfo);
Craig Topperc3ec1492014-05-26 06:22:03 +00005070 if (!NewTD) return nullptr;
Mike Stump11289f42009-09-09 15:08:12 +00005071
Zhongxing Xuac8ef9e2009-01-16 03:34:13 +00005072 // Handle attributes prior to checking for duplicates in MergeVarDecl
Douglas Gregor758a8692009-06-17 21:51:59 +00005073 ProcessDeclAttributes(S, NewTD, D);
John McCall1f82f242009-11-18 22:49:29 +00005074
Richard Smith3f1b5d02011-05-05 21:57:07 +00005075 CheckTypedefForVariablyModifiedType(S, NewTD);
5076
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00005077 bool Redeclaration = D.isRedeclaration();
5078 NamedDecl *ND = ActOnTypedefNameDecl(S, DC, NewTD, Previous, Redeclaration);
5079 D.setRedeclaration(Redeclaration);
5080 return ND;
Richard Smithdda56e42011-04-15 14:24:37 +00005081}
5082
Richard Smith3f1b5d02011-05-05 21:57:07 +00005083void
5084Sema::CheckTypedefForVariablyModifiedType(Scope *S, TypedefNameDecl *NewTD) {
Chris Lattner9fecd742009-04-19 05:21:20 +00005085 // C99 6.7.7p2: If a typedef name specifies a variably modified type
5086 // then it shall have block scope.
Eli Friedman88f4ed92010-08-10 03:13:15 +00005087 // Note that variably modified types must be fixed before merging the decl so
5088 // that redeclarations will match.
Abramo Bagnara341ab732012-11-08 14:44:42 +00005089 TypeSourceInfo *TInfo = NewTD->getTypeSourceInfo();
5090 QualType T = TInfo->getType();
Chris Lattner9fecd742009-04-19 05:21:20 +00005091 if (T->isVariablyModifiedType()) {
John McCallaab3e412010-08-25 08:40:02 +00005092 getCurFunction()->setHasBranchProtectedScope();
Mike Stump11289f42009-09-09 15:08:12 +00005093
Craig Topperc3ec1492014-05-26 06:22:03 +00005094 if (S->getFnParent() == nullptr) {
Eli Friedmana3b1d032009-02-21 00:44:51 +00005095 bool SizeIsNegative;
Douglas Gregorcaa1bf42010-08-18 00:39:00 +00005096 llvm::APSInt Oversized;
Abramo Bagnara341ab732012-11-08 14:44:42 +00005097 TypeSourceInfo *FixedTInfo =
5098 TryToFixInvalidVariablyModifiedTypeSourceInfo(TInfo, Context,
5099 SizeIsNegative,
5100 Oversized);
5101 if (FixedTInfo) {
Richard Smithdda56e42011-04-15 14:24:37 +00005102 Diag(NewTD->getLocation(), diag::warn_illegal_constant_array_size);
Abramo Bagnara341ab732012-11-08 14:44:42 +00005103 NewTD->setTypeSourceInfo(FixedTInfo);
Eli Friedmana3b1d032009-02-21 00:44:51 +00005104 } else {
5105 if (SizeIsNegative)
Richard Smithdda56e42011-04-15 14:24:37 +00005106 Diag(NewTD->getLocation(), diag::err_typecheck_negative_array_size);
Eli Friedmana3b1d032009-02-21 00:44:51 +00005107 else if (T->isVariableArrayType())
Richard Smithdda56e42011-04-15 14:24:37 +00005108 Diag(NewTD->getLocation(), diag::err_vla_decl_in_file_scope);
Douglas Gregorcaa1bf42010-08-18 00:39:00 +00005109 else if (Oversized.getBoolValue())
David Blaikie30d15442011-10-19 22:56:21 +00005110 Diag(NewTD->getLocation(), diag::err_array_too_large)
5111 << Oversized.toString(10);
Eli Friedmana3b1d032009-02-21 00:44:51 +00005112 else
Richard Smithdda56e42011-04-15 14:24:37 +00005113 Diag(NewTD->getLocation(), diag::err_vm_decl_in_file_scope);
Chris Lattnerf6d1c9c2009-04-25 08:06:05 +00005114 NewTD->setInvalidDecl();
Eli Friedmana3b1d032009-02-21 00:44:51 +00005115 }
Zhongxing Xuac8ef9e2009-01-16 03:34:13 +00005116 }
5117 }
Richard Smith3f1b5d02011-05-05 21:57:07 +00005118}
Douglas Gregor27821ce2009-07-07 16:35:42 +00005119
Richard Smith3f1b5d02011-05-05 21:57:07 +00005120
5121/// ActOnTypedefNameDecl - Perform semantic checking for a declaration which
5122/// declares a typedef-name, either using the 'typedef' type specifier or via
5123/// a C++0x [dcl.typedef]p2 alias-declaration: 'using T = A;'.
5124NamedDecl*
5125Sema::ActOnTypedefNameDecl(Scope *S, DeclContext *DC, TypedefNameDecl *NewTD,
5126 LookupResult &Previous, bool &Redeclaration) {
Eli Friedman88f4ed92010-08-10 03:13:15 +00005127 // Merge the decl with the existing one if appropriate. If the decl is
5128 // in an outer scope, it isn't the same thing.
Richard Smith72bcaec2013-12-05 04:30:04 +00005129 FilterLookupForScope(Previous, DC, S, /*ConsiderLinkage*/false,
5130 /*AllowInlineNamespace*/false);
Richard Smith42413142015-05-15 20:05:43 +00005131 filterNonConflictingPreviousTypedefDecls(*this, NewTD, Previous);
Eli Friedman88f4ed92010-08-10 03:13:15 +00005132 if (!Previous.empty()) {
5133 Redeclaration = true;
Richard Smithdda56e42011-04-15 14:24:37 +00005134 MergeTypedefNameDecl(NewTD, Previous);
Eli Friedman88f4ed92010-08-10 03:13:15 +00005135 }
5136
Douglas Gregor27821ce2009-07-07 16:35:42 +00005137 // If this is the C FILE type, notify the AST context.
5138 if (IdentifierInfo *II = NewTD->getIdentifier())
5139 if (!NewTD->isInvalidDecl() &&
Sebastian Redl50c68252010-08-31 00:36:30 +00005140 NewTD->getDeclContext()->getRedeclContext()->isTranslationUnit()) {
Mike Stumpa4de80b2009-07-28 02:25:19 +00005141 if (II->isStr("FILE"))
5142 Context.setFILEDecl(NewTD);
5143 else if (II->isStr("jmp_buf"))
5144 Context.setjmp_bufDecl(NewTD);
5145 else if (II->isStr("sigjmp_buf"))
5146 Context.setsigjmp_bufDecl(NewTD);
Rafael Espindola6cfa82b2011-11-13 21:51:09 +00005147 else if (II->isStr("ucontext_t"))
5148 Context.setucontext_tDecl(NewTD);
Mike Stumpa4de80b2009-07-28 02:25:19 +00005149 }
5150
Zhongxing Xuac8ef9e2009-01-16 03:34:13 +00005151 return NewTD;
5152}
5153
Douglas Gregor5d68a202009-02-24 19:23:27 +00005154/// \brief Determines whether the given declaration is an out-of-scope
5155/// previous declaration.
5156///
5157/// This routine should be invoked when name lookup has found a
5158/// previous declaration (PrevDecl) that is not in the scope where a
5159/// new declaration by the same name is being introduced. If the new
5160/// declaration occurs in a local scope, previous declarations with
5161/// linkage may still be considered previous declarations (C99
5162/// 6.2.2p4-5, C++ [basic.link]p6).
5163///
5164/// \param PrevDecl the previous declaration found by name
5165/// lookup
Mike Stump11289f42009-09-09 15:08:12 +00005166///
Douglas Gregor5d68a202009-02-24 19:23:27 +00005167/// \param DC the context in which the new declaration is being
5168/// declared.
5169///
5170/// \returns true if PrevDecl is an out-of-scope previous declaration
5171/// for a new delcaration with the same name.
Mike Stump11289f42009-09-09 15:08:12 +00005172static bool
Douglas Gregor5d68a202009-02-24 19:23:27 +00005173isOutOfScopePreviousDeclaration(NamedDecl *PrevDecl, DeclContext *DC,
5174 ASTContext &Context) {
5175 if (!PrevDecl)
Sebastian Redl50c68252010-08-31 00:36:30 +00005176 return false;
Douglas Gregor5d68a202009-02-24 19:23:27 +00005177
Douglas Gregoreddf4332009-02-24 20:03:32 +00005178 if (!PrevDecl->hasLinkage())
5179 return false;
Douglas Gregor5d68a202009-02-24 19:23:27 +00005180
David Blaikiebbafb8a2012-03-11 07:00:24 +00005181 if (Context.getLangOpts().CPlusPlus) {
Douglas Gregor5d68a202009-02-24 19:23:27 +00005182 // C++ [basic.link]p6:
5183 // If there is a visible declaration of an entity with linkage
5184 // having the same name and type, ignoring entities declared
5185 // outside the innermost enclosing namespace scope, the block
5186 // scope declaration declares that same entity and receives the
5187 // linkage of the previous declaration.
Sebastian Redl50c68252010-08-31 00:36:30 +00005188 DeclContext *OuterContext = DC->getRedeclContext();
Douglas Gregor5d68a202009-02-24 19:23:27 +00005189 if (!OuterContext->isFunctionOrMethod())
5190 // This rule only applies to block-scope declarations.
5191 return false;
Douglas Gregorfcee9462010-08-27 22:55:10 +00005192
5193 DeclContext *PrevOuterContext = PrevDecl->getDeclContext();
5194 if (PrevOuterContext->isRecord())
5195 // We found a member function: ignore it.
5196 return false;
5197
5198 // Find the innermost enclosing namespace for the new and
5199 // previous declarations.
Sebastian Redl50c68252010-08-31 00:36:30 +00005200 OuterContext = OuterContext->getEnclosingNamespaceContext();
5201 PrevOuterContext = PrevOuterContext->getEnclosingNamespaceContext();
Mike Stump11289f42009-09-09 15:08:12 +00005202
Douglas Gregorfcee9462010-08-27 22:55:10 +00005203 // The previous declaration is in a different namespace, so it
5204 // isn't the same function.
5205 if (!OuterContext->Equals(PrevOuterContext))
5206 return false;
Douglas Gregor5d68a202009-02-24 19:23:27 +00005207 }
5208
Douglas Gregor5d68a202009-02-24 19:23:27 +00005209 return true;
5210}
5211
John McCall3e11ebe2010-03-15 10:12:16 +00005212static void SetNestedNameSpecifier(DeclaratorDecl *DD, Declarator &D) {
5213 CXXScopeSpec &SS = D.getCXXScopeSpec();
5214 if (!SS.isSet()) return;
Douglas Gregor14454802011-02-25 02:25:35 +00005215 DD->setQualifierInfo(SS.getWithLocInContext(DD->getASTContext()));
John McCall3e11ebe2010-03-15 10:12:16 +00005216}
5217
John McCall31168b02011-06-15 23:02:42 +00005218bool Sema::inferObjCARCLifetime(ValueDecl *decl) {
5219 QualType type = decl->getType();
5220 Qualifiers::ObjCLifetime lifetime = type.getObjCLifetime();
5221 if (lifetime == Qualifiers::OCL_Autoreleasing) {
5222 // Various kinds of declaration aren't allowed to be __autoreleasing.
5223 unsigned kind = -1U;
5224 if (VarDecl *var = dyn_cast<VarDecl>(decl)) {
5225 if (var->hasAttr<BlocksAttr>())
5226 kind = 0; // __block
5227 else if (!var->hasLocalStorage())
5228 kind = 1; // global
5229 } else if (isa<ObjCIvarDecl>(decl)) {
5230 kind = 3; // ivar
5231 } else if (isa<FieldDecl>(decl)) {
5232 kind = 2; // field
5233 }
5234
5235 if (kind != -1U) {
5236 Diag(decl->getLocation(), diag::err_arc_autoreleasing_var)
5237 << kind;
5238 }
5239 } else if (lifetime == Qualifiers::OCL_None) {
5240 // Try to infer lifetime.
5241 if (!type->isObjCLifetimeType())
5242 return false;
5243
5244 lifetime = type->getObjCARCImplicitLifetime();
5245 type = Context.getLifetimeQualifiedType(type, lifetime);
5246 decl->setType(type);
5247 }
5248
5249 if (VarDecl *var = dyn_cast<VarDecl>(decl)) {
5250 // Thread-local variables cannot have lifetime.
5251 if (lifetime && lifetime != Qualifiers::OCL_ExplicitNone &&
Richard Smithfd3834f2013-04-13 02:43:54 +00005252 var->getTLSKind()) {
Argyrios Kyrtzidiscff00d92011-06-24 00:08:59 +00005253 Diag(var->getLocation(), diag::err_arc_thread_ownership)
John McCall31168b02011-06-15 23:02:42 +00005254 << var->getType();
5255 return true;
5256 }
5257 }
5258
5259 return false;
5260}
5261
Rafael Espindolaf1d2f0e2013-01-16 23:11:15 +00005262static void checkAttributesAfterMerging(Sema &S, NamedDecl &ND) {
Nico Rieckf8e8b5f2014-01-21 23:54:36 +00005263 // Ensure that an auto decl is deduced otherwise the checks below might cache
5264 // the wrong linkage.
5265 assert(S.ParsingInitForAutoVars.count(&ND) == 0);
5266
Rafael Espindolaf1d2f0e2013-01-16 23:11:15 +00005267 // 'weak' only applies to declarations with external linkage.
Rafael Espindolab3069002013-01-16 23:49:06 +00005268 if (WeakAttr *Attr = ND.getAttr<WeakAttr>()) {
Rafael Espindola3ae00052013-05-13 00:12:11 +00005269 if (!ND.isExternallyVisible()) {
Rafael Espindolab3069002013-01-16 23:49:06 +00005270 S.Diag(Attr->getLocation(), diag::err_attribute_weak_static);
5271 ND.dropAttr<WeakAttr>();
5272 }
5273 }
5274 if (WeakRefAttr *Attr = ND.getAttr<WeakRefAttr>()) {
Rafael Espindola3ae00052013-05-13 00:12:11 +00005275 if (ND.isExternallyVisible()) {
Rafael Espindolab3069002013-01-16 23:49:06 +00005276 S.Diag(Attr->getLocation(), diag::err_attribute_weakref_not_static);
5277 ND.dropAttr<WeakRefAttr>();
David Majnemer2dc81462015-01-19 09:00:28 +00005278 ND.dropAttr<AliasAttr>();
5279 }
5280 }
5281
5282 if (auto *VD = dyn_cast<VarDecl>(&ND)) {
5283 if (VD->hasInit()) {
5284 if (const auto *Attr = VD->getAttr<AliasAttr>()) {
5285 assert(VD->isThisDeclarationADefinition() &&
5286 !VD->isExternallyVisible() && "Broken AliasAttr handled late!");
5287 S.Diag(Attr->getLocation(), diag::err_alias_is_definition) << VD;
5288 VD->dropAttr<AliasAttr>();
5289 }
Rafael Espindolab3069002013-01-16 23:49:06 +00005290 }
Rafael Espindolaf1d2f0e2013-01-16 23:11:15 +00005291 }
Reid Klecknerb144d362013-05-20 14:02:37 +00005292
Nico Weber38267342015-04-22 03:44:51 +00005293 // 'selectany' only applies to externally visible variable declarations.
Reid Klecknerb144d362013-05-20 14:02:37 +00005294 // It does not apply to functions.
5295 if (SelectAnyAttr *Attr = ND.getAttr<SelectAnyAttr>()) {
5296 if (isa<FunctionDecl>(ND) || !ND.isExternallyVisible()) {
Nico Weber38267342015-04-22 03:44:51 +00005297 S.Diag(Attr->getLocation(),
5298 diag::err_attribute_selectany_non_extern_data);
Reid Klecknerb144d362013-05-20 14:02:37 +00005299 ND.dropAttr<SelectAnyAttr>();
5300 }
5301 }
Nico Rieck8ca0bfc2014-03-31 14:56:58 +00005302
5303 // dll attributes require external linkage.
David Majnemer7656f412014-10-04 06:16:45 +00005304 if (const InheritableAttr *Attr = getDLLAttr(&ND)) {
Nico Rieck8ca0bfc2014-03-31 14:56:58 +00005305 if (!ND.isExternallyVisible()) {
5306 S.Diag(ND.getLocation(), diag::err_attribute_dll_not_extern)
5307 << &ND << Attr;
5308 ND.setInvalidDecl();
5309 }
5310 }
Rafael Espindolaf1d2f0e2013-01-16 23:11:15 +00005311}
5312
Nico Rieck82f0b062014-03-31 14:56:15 +00005313static void checkDLLAttributeRedeclaration(Sema &S, NamedDecl *OldDecl,
5314 NamedDecl *NewDecl,
5315 bool IsSpecialization) {
5316 if (TemplateDecl *OldTD = dyn_cast<TemplateDecl>(OldDecl))
5317 OldDecl = OldTD->getTemplatedDecl();
5318 if (TemplateDecl *NewTD = dyn_cast<TemplateDecl>(NewDecl))
5319 NewDecl = NewTD->getTemplatedDecl();
5320
5321 if (!OldDecl || !NewDecl)
Hans Wennborgdd96db22014-08-27 21:27:40 +00005322 return;
Nico Rieck82f0b062014-03-31 14:56:15 +00005323
5324 const DLLImportAttr *OldImportAttr = OldDecl->getAttr<DLLImportAttr>();
5325 const DLLExportAttr *OldExportAttr = OldDecl->getAttr<DLLExportAttr>();
5326 const DLLImportAttr *NewImportAttr = NewDecl->getAttr<DLLImportAttr>();
5327 const DLLExportAttr *NewExportAttr = NewDecl->getAttr<DLLExportAttr>();
5328
5329 // dllimport and dllexport are inheritable attributes so we have to exclude
5330 // inherited attribute instances.
5331 bool HasNewAttr = (NewImportAttr && !NewImportAttr->isInherited()) ||
5332 (NewExportAttr && !NewExportAttr->isInherited());
5333
5334 // A redeclaration is not allowed to add a dllimport or dllexport attribute,
5335 // the only exception being explicit specializations.
5336 // Implicitly generated declarations are also excluded for now because there
5337 // is no other way to switch these to use dllimport or dllexport.
5338 bool AddsAttr = !(OldImportAttr || OldExportAttr) && HasNewAttr;
Hans Wennborgdd96db22014-08-27 21:27:40 +00005339
Nico Rieck82f0b062014-03-31 14:56:15 +00005340 if (AddsAttr && !IsSpecialization && !OldDecl->isImplicit()) {
Hans Wennborgdd96db22014-08-27 21:27:40 +00005341 // If the declaration hasn't been used yet, allow with a warning for
5342 // free functions and global variables.
5343 bool JustWarn = false;
Hans Wennborgac6073b2014-10-29 21:20:57 +00005344 if (!OldDecl->isUsed() && !OldDecl->isCXXClassMember()) {
Hans Wennborgdd96db22014-08-27 21:27:40 +00005345 auto *VD = dyn_cast<VarDecl>(OldDecl);
5346 if (VD && !VD->getDescribedVarTemplate())
5347 JustWarn = true;
5348 auto *FD = dyn_cast<FunctionDecl>(OldDecl);
5349 if (FD && FD->getTemplatedKind() == FunctionDecl::TK_NonTemplate)
5350 JustWarn = true;
5351 }
5352
5353 unsigned DiagID = JustWarn ? diag::warn_attribute_dll_redeclaration
5354 : diag::err_attribute_dll_redeclaration;
5355 S.Diag(NewDecl->getLocation(), DiagID)
5356 << NewDecl
5357 << (NewImportAttr ? (const Attr *)NewImportAttr : NewExportAttr);
Nico Rieck82f0b062014-03-31 14:56:15 +00005358 S.Diag(OldDecl->getLocation(), diag::note_previous_declaration);
Hans Wennborgdd96db22014-08-27 21:27:40 +00005359 if (!JustWarn) {
5360 NewDecl->setInvalidDecl();
5361 return;
5362 }
Nico Rieck82f0b062014-03-31 14:56:15 +00005363 }
5364
5365 // A redeclaration is not allowed to drop a dllimport attribute, the only
Hans Wennborg7c4851e2014-08-04 20:54:39 +00005366 // exceptions being inline function definitions, local extern declarations,
5367 // and qualified friend declarations.
Nico Rieck82f0b062014-03-31 14:56:15 +00005368 // NB: MSVC converts such a declaration to dllexport.
Hans Wennborg7c4851e2014-08-04 20:54:39 +00005369 bool IsInline = false, IsStaticDataMember = false, IsQualifiedFriend = false;
Nico Rieck078d2f82014-05-29 16:50:20 +00005370 if (const auto *VD = dyn_cast<VarDecl>(NewDecl))
5371 // Ignore static data because out-of-line definitions are diagnosed
5372 // separately.
5373 IsStaticDataMember = VD->isStaticDataMember();
Hans Wennborg7c4851e2014-08-04 20:54:39 +00005374 else if (const auto *FD = dyn_cast<FunctionDecl>(NewDecl)) {
Nico Rieck078d2f82014-05-29 16:50:20 +00005375 IsInline = FD->isInlined();
Hans Wennborg7c4851e2014-08-04 20:54:39 +00005376 IsQualifiedFriend = FD->getQualifier() &&
5377 FD->getFriendObjectKind() == Decl::FOK_Declared;
5378 }
Hans Wennborgf436b282014-05-22 15:46:15 +00005379
Hans Wennborgf51dc3b2014-07-31 19:29:39 +00005380 if (OldImportAttr && !HasNewAttr && !IsInline && !IsStaticDataMember &&
Hans Wennborg7c4851e2014-08-04 20:54:39 +00005381 !NewDecl->isLocalExternDecl() && !IsQualifiedFriend) {
Nico Rieck82f0b062014-03-31 14:56:15 +00005382 S.Diag(NewDecl->getLocation(),
5383 diag::warn_redeclaration_without_attribute_prev_attribute_ignored)
5384 << NewDecl << OldImportAttr;
5385 S.Diag(OldDecl->getLocation(), diag::note_previous_declaration);
5386 S.Diag(OldImportAttr->getLocation(), diag::note_previous_attribute);
5387 OldDecl->dropAttr<DLLImportAttr>();
5388 NewDecl->dropAttr<DLLImportAttr>();
Hans Wennborg606bd6d2014-11-03 14:24:45 +00005389 } else if (IsInline && OldImportAttr &&
5390 !S.Context.getTargetInfo().getCXXABI().isMicrosoft()) {
5391 // In MinGW, seeing a function declared inline drops the dllimport attribute.
5392 OldDecl->dropAttr<DLLImportAttr>();
5393 NewDecl->dropAttr<DLLImportAttr>();
5394 S.Diag(NewDecl->getLocation(),
5395 diag::warn_dllimport_dropped_from_inline_function)
5396 << NewDecl << OldImportAttr;
Nico Rieck82f0b062014-03-31 14:56:15 +00005397 }
5398}
5399
John McCallc87d9722013-04-02 02:48:58 +00005400/// Given that we are within the definition of the given function,
5401/// will that definition behave like C99's 'inline', where the
5402/// definition is discarded except for optimization purposes?
5403static bool isFunctionDefinitionDiscarded(Sema &S, FunctionDecl *FD) {
5404 // Try to avoid calling GetGVALinkageForFunction.
5405
5406 // All cases of this require the 'inline' keyword.
5407 if (!FD->isInlined()) return false;
5408
5409 // This is only possible in C++ with the gnu_inline attribute.
5410 if (S.getLangOpts().CPlusPlus && !FD->hasAttr<GNUInlineAttr>())
5411 return false;
5412
5413 // Okay, go ahead and call the relatively-more-expensive function.
5414
5415#ifndef NDEBUG
5416 // AST quite reasonably asserts that it's working on a function
5417 // definition. We don't really have a way to tell it that we're
5418 // currently defining the function, so just lie to it in +Asserts
5419 // builds. This is an awful hack.
5420 FD->setLazyBody(1);
5421#endif
5422
David Majnemer27d69db2014-04-28 22:17:59 +00005423 bool isC99Inline =
5424 S.Context.GetGVALinkageForFunction(FD) == GVA_AvailableExternally;
John McCallc87d9722013-04-02 02:48:58 +00005425
5426#ifndef NDEBUG
5427 FD->setLazyBody(0);
5428#endif
5429
5430 return isC99Inline;
5431}
5432
Richard Smithac974a32013-06-30 09:48:50 +00005433/// Determine whether a variable is extern "C" prior to attaching
5434/// an initializer. We can't just call isExternC() here, because that
5435/// will also compute and cache whether the declaration is externally
5436/// visible, which might change when we attach the initializer.
5437///
5438/// This can only be used if the declaration is known to not be a
5439/// redeclaration of an internal linkage declaration.
5440///
5441/// For instance:
5442///
5443/// auto x = []{};
5444///
5445/// Attaching the initializer here makes this declaration not externally
5446/// visible, because its type has internal linkage.
5447///
5448/// FIXME: This is a hack.
5449template<typename T>
5450static bool isIncompleteDeclExternC(Sema &S, const T *D) {
5451 if (S.getLangOpts().CPlusPlus) {
5452 // In C++, the overloadable attribute negates the effects of extern "C".
5453 if (!D->isInExternCContext() || D->template hasAttr<OverloadableAttr>())
5454 return false;
5455 }
5456 return D->isExternC();
5457}
5458
Rafael Espindola0e0d0092013-03-14 03:07:35 +00005459static bool shouldConsiderLinkage(const VarDecl *VD) {
5460 const DeclContext *DC = VD->getDeclContext()->getRedeclContext();
5461 if (DC->isFunctionOrMethod())
Rafael Espindola6ae7e502013-04-03 19:27:57 +00005462 return VD->hasExternalStorage();
Rafael Espindola0e0d0092013-03-14 03:07:35 +00005463 if (DC->isFileContext())
5464 return true;
5465 if (DC->isRecord())
5466 return false;
5467 llvm_unreachable("Unexpected context");
5468}
5469
5470static bool shouldConsiderLinkage(const FunctionDecl *FD) {
5471 const DeclContext *DC = FD->getDeclContext()->getRedeclContext();
5472 if (DC->isFileContext() || DC->isFunctionOrMethod())
5473 return true;
5474 if (DC->isRecord())
5475 return false;
5476 llvm_unreachable("Unexpected context");
5477}
5478
Nico Riecke84f8db2014-03-23 21:24:01 +00005479static bool hasParsedAttr(Scope *S, const AttributeList *AttrList,
5480 AttributeList::Kind Kind) {
5481 for (const AttributeList *L = AttrList; L; L = L->getNext())
5482 if (L->getKind() == Kind)
5483 return true;
5484 return false;
5485}
5486
5487static bool hasParsedAttr(Scope *S, const Declarator &PD,
5488 AttributeList::Kind Kind) {
5489 // Check decl attributes on the DeclSpec.
5490 if (hasParsedAttr(S, PD.getDeclSpec().getAttributes().getList(), Kind))
5491 return true;
5492
5493 // Walk the declarator structure, checking decl attributes that were in a type
5494 // position to the decl itself.
5495 for (unsigned I = 0, E = PD.getNumTypeObjects(); I != E; ++I) {
5496 if (hasParsedAttr(S, PD.getTypeObject(I).getAttrs(), Kind))
5497 return true;
5498 }
5499
5500 // Finally, check attributes on the decl itself.
5501 return hasParsedAttr(S, PD.getAttributes(), Kind);
5502}
5503
Richard Smith541b38b2013-09-20 01:15:31 +00005504/// Adjust the \c DeclContext for a function or variable that might be a
5505/// function-local external declaration.
5506bool Sema::adjustContextForLocalExternDecl(DeclContext *&DC) {
5507 if (!DC->isFunctionOrMethod())
5508 return false;
5509
5510 // If this is a local extern function or variable declared within a function
5511 // template, don't add it into the enclosing namespace scope until it is
5512 // instantiated; it might have a dependent type right now.
5513 if (DC->isDependentContext())
5514 return true;
5515
5516 // C++11 [basic.link]p7:
5517 // When a block scope declaration of an entity with linkage is not found to
5518 // refer to some other declaration, then that entity is a member of the
5519 // innermost enclosing namespace.
5520 //
5521 // Per C++11 [namespace.def]p6, the innermost enclosing namespace is a
5522 // semantically-enclosing namespace, not a lexically-enclosing one.
5523 while (!DC->isFileContext() && !isa<LinkageSpecDecl>(DC))
5524 DC = DC->getParent();
5525 return true;
5526}
5527
Aaron Ballman9ec96a22015-06-25 15:37:16 +00005528/// \brief Returns true if given declaration is TU-scoped and externally
5529/// visible.
5530static bool isDeclTUScopedExternallyVisible(const Decl *D) {
5531 if (auto *FD = dyn_cast<FunctionDecl>(D))
5532 return (FD->getDeclContext()->isTranslationUnit() || FD->isExternC()) &&
5533 FD->hasExternalFormalLinkage();
5534 else if (auto *VD = dyn_cast<VarDecl>(D))
5535 return (VD->getDeclContext()->isTranslationUnit() || VD->isExternC()) &&
5536 VD->hasExternalFormalLinkage();
5537
5538 llvm_unreachable("Unknown type of decl!");
5539}
5540
Larisse Voufo39a1e502013-08-06 01:03:05 +00005541NamedDecl *
Chris Lattner88fdea82010-10-10 18:16:20 +00005542Sema::ActOnVariableDeclarator(Scope *S, Declarator &D, DeclContext *DC,
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00005543 TypeSourceInfo *TInfo, LookupResult &Previous,
Larisse Voufo39a1e502013-08-06 01:03:05 +00005544 MultiTemplateParamsArg TemplateParamLists,
5545 bool &AddToScope) {
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00005546 QualType R = TInfo->getType();
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00005547 DeclarationName Name = GetNameForDeclarator(D).getName();
Zhongxing Xu9b7714d2009-01-16 02:36:34 +00005548
Douglas Gregorc4df4072010-04-19 22:54:31 +00005549 DeclSpec::SCS SCSpec = D.getDeclSpec().getStorageClassSpec();
Craig Topperc79e5e32014-10-31 06:57:13 +00005550 StorageClass SC = StorageClassSpecToVarDeclStorageClass(D.getDeclSpec());
Joey Goulydd7f4562013-01-23 11:56:20 +00005551
Nico Riecke84f8db2014-03-23 21:24:01 +00005552 // dllimport globals without explicit storage class are treated as extern. We
5553 // have to change the storage class this early to get the right DeclContext.
5554 if (SC == SC_None && !DC->isRecord() &&
Nico Rieck755a36f2014-05-25 10:34:16 +00005555 hasParsedAttr(S, D, AttributeList::AT_DLLImport) &&
5556 !hasParsedAttr(S, D, AttributeList::AT_DLLExport))
Nico Riecke84f8db2014-03-23 21:24:01 +00005557 SC = SC_Extern;
5558
Richard Smith541b38b2013-09-20 01:15:31 +00005559 DeclContext *OriginalDC = DC;
5560 bool IsLocalExternDecl = SC == SC_Extern &&
5561 adjustContextForLocalExternDecl(DC);
5562
Pekka Jaaskelainen8690a682014-02-20 13:52:08 +00005563 if (getLangOpts().OpenCL) {
5564 // OpenCL v1.0 s6.8.a.3: Pointers to functions are not allowed.
5565 QualType NR = R;
5566 while (NR->isPointerType()) {
5567 if (NR->isFunctionPointerType()) {
5568 Diag(D.getIdentifierLoc(), diag::err_opencl_function_pointer_variable);
5569 D.setInvalidType();
5570 break;
5571 }
5572 NR = NR->getPointeeType();
5573 }
5574
5575 if (!getOpenCLOptions().cl_khr_fp16) {
5576 // OpenCL v1.2 s6.1.1.1: reject declaring variables of the half and
5577 // half array type (unless the cl_khr_fp16 extension is enabled).
5578 if (Context.getBaseElementType(R)->isHalfType()) {
5579 Diag(D.getIdentifierLoc(), diag::err_opencl_half_declaration) << R;
5580 D.setInvalidType();
5581 }
Joey Goulydd7f4562013-01-23 11:56:20 +00005582 }
5583 }
5584
Douglas Gregorc4df4072010-04-19 22:54:31 +00005585 if (SCSpec == DeclSpec::SCS_mutable) {
Zhongxing Xu9b7714d2009-01-16 02:36:34 +00005586 // mutable can only appear on non-static class members, so it's always
5587 // an error here
5588 Diag(D.getIdentifierLoc(), diag::err_mutable_nonmember);
Chris Lattnerf6d1c9c2009-04-25 08:06:05 +00005589 D.setInvalidType();
John McCall8e7d6562010-08-26 03:08:43 +00005590 SC = SC_None;
Zhongxing Xu9b7714d2009-01-16 02:36:34 +00005591 }
John McCallc87d9722013-04-02 02:48:58 +00005592
Richard Smithf2c9afc2013-06-17 01:34:01 +00005593 if (getLangOpts().CPlusPlus11 && SCSpec == DeclSpec::SCS_register &&
5594 !D.getAsmLabel() && !getSourceManager().isInSystemMacro(
5595 D.getDeclSpec().getStorageClassSpecLoc())) {
5596 // In C++11, the 'register' storage class specifier is deprecated.
5597 // Suppress the warning in system macros, it's used in macros in some
5598 // popular C system headers, such as in glibc's htonl() macro.
5599 Diag(D.getDeclSpec().getStorageClassSpecLoc(),
5600 diag::warn_deprecated_register)
5601 << FixItHint::CreateRemoval(D.getDeclSpec().getStorageClassSpecLoc());
5602 }
5603
Zhongxing Xu9b7714d2009-01-16 02:36:34 +00005604 IdentifierInfo *II = Name.getAsIdentifierInfo();
5605 if (!II) {
5606 Diag(D.getIdentifierLoc(), diag::err_bad_variable_name)
Douglas Gregorbb64afc2011-10-09 18:55:59 +00005607 << Name;
Craig Topperc3ec1492014-05-26 06:22:03 +00005608 return nullptr;
Zhongxing Xu9b7714d2009-01-16 02:36:34 +00005609 }
5610
Richard Smithb1402ae2013-03-18 22:52:47 +00005611 DiagnoseFunctionSpecifiers(D.getDeclSpec());
Douglas Gregor0c880302009-03-11 23:00:04 +00005612
Craig Topperc3ec1492014-05-26 06:22:03 +00005613 if (!DC->isRecord() && S->getFnParent() == nullptr) {
Douglas Gregor212cab32009-03-11 20:22:50 +00005614 // C99 6.9p2: The storage-class specifiers auto and register shall not
5615 // appear in the declaration specifiers in an external declaration.
Renato Golin230c5eb2014-05-19 18:15:42 +00005616 // Global Register+Asm is a GNU extension we support.
5617 if (SC == SC_Auto || (SC == SC_Register && !D.getAsmLabel())) {
5618 Diag(D.getIdentifierLoc(), diag::err_typecheck_sclass_fscope);
Chris Lattnerf6d1c9c2009-04-25 08:06:05 +00005619 D.setInvalidType();
Zhongxing Xu9b7714d2009-01-16 02:36:34 +00005620 }
Zhongxing Xu9b7714d2009-01-16 02:36:34 +00005621 }
Richard Smithf2c9afc2013-06-17 01:34:01 +00005622
David Blaikiebbafb8a2012-03-11 07:00:24 +00005623 if (getLangOpts().OpenCL) {
Peter Collingbourne2dbb7082011-09-19 21:14:35 +00005624 // Set up the special work-group-local storage class for variables in the
5625 // OpenCL __local address space.
Rafael Espindola2be6b722012-12-21 01:21:33 +00005626 if (R.getAddressSpace() == LangAS::opencl_local) {
Peter Collingbourne2dbb7082011-09-19 21:14:35 +00005627 SC = SC_OpenCLWorkGroupLocal;
Rafael Espindola2be6b722012-12-21 01:21:33 +00005628 }
Guy Benyei1b4fb3e2013-01-20 12:31:11 +00005629
Guy Benyei61054192013-02-07 10:55:47 +00005630 // OpenCL v1.2 s6.9.b p4:
5631 // The sampler type cannot be used with the __local and __global address
5632 // space qualifiers.
5633 if (R->isSamplerT() && (R.getAddressSpace() == LangAS::opencl_local ||
5634 R.getAddressSpace() == LangAS::opencl_global)) {
5635 Diag(D.getIdentifierLoc(), diag::err_wrong_sampler_addressspace);
5636 }
5637
Guy Benyei1b4fb3e2013-01-20 12:31:11 +00005638 // OpenCL 1.2 spec, p6.9 r:
5639 // The event type cannot be used to declare a program scope variable.
5640 // The event type cannot be used with the __local, __constant and __global
5641 // address space qualifiers.
5642 if (R->isEventT()) {
Craig Topperc3ec1492014-05-26 06:22:03 +00005643 if (S->getParent() == nullptr) {
Guy Benyei1b4fb3e2013-01-20 12:31:11 +00005644 Diag(D.getLocStart(), diag::err_event_t_global_var);
5645 D.setInvalidType();
5646 }
5647
5648 if (R.getAddressSpace()) {
5649 Diag(D.getLocStart(), diag::err_event_t_addr_space_qual);
5650 D.setInvalidType();
5651 }
5652 }
Peter Collingbourne2dbb7082011-09-19 21:14:35 +00005653 }
5654
Larisse Voufo39a1e502013-08-06 01:03:05 +00005655 bool IsExplicitSpecialization = false;
5656 bool IsVariableTemplateSpecialization = false;
5657 bool IsPartialSpecialization = false;
Larisse Voufod8dd97c2013-08-14 03:09:19 +00005658 bool IsVariableTemplate = false;
Craig Topperc3ec1492014-05-26 06:22:03 +00005659 VarDecl *NewVD = nullptr;
5660 VarTemplateDecl *NewTemplate = nullptr;
5661 TemplateParameterList *TemplateParams = nullptr;
David Blaikiebbafb8a2012-03-11 07:00:24 +00005662 if (!getLangOpts().CPlusPlus) {
Daniel Dunbar62ee6412012-03-09 18:35:03 +00005663 NewVD = VarDecl::Create(Context, DC, D.getLocStart(),
Abramo Bagnaradff19302011-03-08 08:55:46 +00005664 D.getIdentifierLoc(), II,
Rafael Espindola6ae7e502013-04-03 19:27:57 +00005665 R, TInfo, SC);
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00005666
5667 if (D.isInvalidType())
5668 NewVD->setInvalidDecl();
5669 } else {
Larisse Voufo72caf2b2013-08-22 00:59:14 +00005670 bool Invalid = false;
5671
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00005672 if (DC->isRecord() && !CurContext->isRecord()) {
5673 // This is an out-of-line definition of a static data member.
Rafael Espindola45f96f82013-06-19 13:41:54 +00005674 switch (SC) {
5675 case SC_None:
5676 break;
5677 case SC_Static:
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00005678 Diag(D.getDeclSpec().getStorageClassSpecLoc(),
5679 diag::err_static_out_of_line)
5680 << FixItHint::CreateRemoval(D.getDeclSpec().getStorageClassSpecLoc());
Rafael Espindola45f96f82013-06-19 13:41:54 +00005681 break;
5682 case SC_Auto:
5683 case SC_Register:
5684 case SC_Extern:
5685 // [dcl.stc] p2: The auto or register specifiers shall be applied only
5686 // to names of variables declared in a block or to function parameters.
5687 // [dcl.stc] p6: The extern specifier cannot be used in the declaration
5688 // of class members
5689
5690 Diag(D.getDeclSpec().getStorageClassSpecLoc(),
5691 diag::err_storage_class_for_static_member)
5692 << FixItHint::CreateRemoval(D.getDeclSpec().getStorageClassSpecLoc());
5693 break;
5694 case SC_PrivateExtern:
5695 llvm_unreachable("C storage class in c++!");
5696 case SC_OpenCLWorkGroupLocal:
5697 llvm_unreachable("OpenCL storage class in c++!");
Rafael Espindola8ac2f592013-04-04 21:21:25 +00005698 }
Larisse Voufo21de36b2013-08-06 03:43:07 +00005699 }
5700
Richard Smith42973752012-02-16 20:41:22 +00005701 if (SC == SC_Static && CurContext->isRecord()) {
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00005702 if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(DC)) {
5703 if (RD->isLocalClass())
5704 Diag(D.getIdentifierLoc(),
5705 diag::err_static_data_member_not_allowed_in_local_class)
5706 << Name << RD->getDeclName();
Mike Stump11289f42009-09-09 15:08:12 +00005707
Richard Smith42973752012-02-16 20:41:22 +00005708 // C++98 [class.union]p1: If a union contains a static data member,
5709 // the program is ill-formed. C++11 drops this restriction.
5710 if (RD->isUnion())
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00005711 Diag(D.getIdentifierLoc(),
Richard Smith2bf7fdb2013-01-02 11:42:31 +00005712 getLangOpts().CPlusPlus11
Richard Smith42973752012-02-16 20:41:22 +00005713 ? diag::warn_cxx98_compat_static_data_member_in_union
5714 : diag::ext_static_data_member_in_union) << Name;
5715 // We conservatively disallow static data members in anonymous structs.
5716 else if (!RD->getDeclName())
5717 Diag(D.getIdentifierLoc(),
5718 diag::err_static_data_member_not_allowed_in_anon_struct)
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00005719 << Name << RD->isUnion();
5720 }
5721 }
5722
5723 // Match up the template parameter lists with the scope specifier, then
5724 // determine whether we have a template or a template specialization.
Richard Smithbeef3452014-01-16 23:39:20 +00005725 TemplateParams = MatchTemplateParametersToScopeSpecifier(
5726 D.getDeclSpec().getLocStart(), D.getIdentifierLoc(),
Richard Smith4b55a9c2014-04-17 03:29:33 +00005727 D.getCXXScopeSpec(),
5728 D.getName().getKind() == UnqualifiedId::IK_TemplateId
5729 ? D.getName().TemplateId
Craig Topperc3ec1492014-05-26 06:22:03 +00005730 : nullptr,
Richard Smith4b55a9c2014-04-17 03:29:33 +00005731 TemplateParamLists,
Richard Smithbeef3452014-01-16 23:39:20 +00005732 /*never a friend*/ false, IsExplicitSpecialization, Invalid);
Larisse Voufo39a1e502013-08-06 01:03:05 +00005733
Richard Smithbeef3452014-01-16 23:39:20 +00005734 if (TemplateParams) {
5735 if (!TemplateParams->size() &&
5736 D.getName().getKind() != UnqualifiedId::IK_TemplateId) {
5737 // There is an extraneous 'template<>' for this variable. Complain
5738 // about it, but allow the declaration of the variable.
5739 Diag(TemplateParams->getTemplateLoc(),
5740 diag::err_template_variable_noparams)
5741 << II
5742 << SourceRange(TemplateParams->getTemplateLoc(),
5743 TemplateParams->getRAngleLoc());
Craig Topperc3ec1492014-05-26 06:22:03 +00005744 TemplateParams = nullptr;
Richard Smithbeef3452014-01-16 23:39:20 +00005745 } else {
Richard Smithbeef3452014-01-16 23:39:20 +00005746 if (D.getName().getKind() == UnqualifiedId::IK_TemplateId) {
5747 // This is an explicit specialization or a partial specialization.
5748 // FIXME: Check that we can declare a specialization here.
5749 IsVariableTemplateSpecialization = true;
5750 IsPartialSpecialization = TemplateParams->size() > 0;
5751 } else { // if (TemplateParams->size() > 0)
5752 // This is a template declaration.
5753 IsVariableTemplate = true;
5754
5755 // Check that we can declare a template here.
5756 if (CheckTemplateDeclScope(S, TemplateParams))
Craig Topperc3ec1492014-05-26 06:22:03 +00005757 return nullptr;
Richard Smith0d963d62014-04-17 02:56:49 +00005758
5759 // Only C++1y supports variable templates (N3651).
5760 Diag(D.getIdentifierLoc(),
Aaron Ballmandd69ef32014-08-19 15:55:55 +00005761 getLangOpts().CPlusPlus14
Richard Smith0d963d62014-04-17 02:56:49 +00005762 ? diag::warn_cxx11_compat_variable_template
5763 : diag::ext_variable_template);
Richard Smithbeef3452014-01-16 23:39:20 +00005764 }
5765 }
Richard Smith4b55a9c2014-04-17 03:29:33 +00005766 } else {
Nico Weber9cc795c2015-01-30 01:48:49 +00005767 assert(
5768 (Invalid || D.getName().getKind() != UnqualifiedId::IK_TemplateId) &&
5769 "should have a 'template<>' for this decl");
Douglas Gregorb09f3d82009-07-22 17:18:37 +00005770 }
Mike Stump11289f42009-09-09 15:08:12 +00005771
Larisse Voufo39a1e502013-08-06 01:03:05 +00005772 if (IsVariableTemplateSpecialization) {
Larisse Voufo39a1e502013-08-06 01:03:05 +00005773 SourceLocation TemplateKWLoc =
5774 TemplateParamLists.size() > 0
5775 ? TemplateParamLists[0]->getTemplateLoc()
5776 : SourceLocation();
5777 DeclResult Res = ActOnVarTemplateSpecialization(
Richard Smithbeef3452014-01-16 23:39:20 +00005778 S, D, TInfo, TemplateKWLoc, TemplateParams, SC,
Larisse Voufo39a1e502013-08-06 01:03:05 +00005779 IsPartialSpecialization);
5780 if (Res.isInvalid())
Craig Topperc3ec1492014-05-26 06:22:03 +00005781 return nullptr;
Larisse Voufo39a1e502013-08-06 01:03:05 +00005782 NewVD = cast<VarDecl>(Res.get());
5783 AddToScope = false;
5784 } else
5785 NewVD = VarDecl::Create(Context, DC, D.getLocStart(),
5786 D.getIdentifierLoc(), II, R, TInfo, SC);
Eli Friedmand5c0eed2009-04-19 20:27:55 +00005787
Larisse Voufo72caf2b2013-08-22 00:59:14 +00005788 // If this is supposed to be a variable template, create it as such.
5789 if (IsVariableTemplate) {
5790 NewTemplate =
5791 VarTemplateDecl::Create(Context, DC, D.getIdentifierLoc(), Name,
Richard Smithbeef3452014-01-16 23:39:20 +00005792 TemplateParams, NewVD);
Larisse Voufo72caf2b2013-08-22 00:59:14 +00005793 NewVD->setDescribedVarTemplate(NewTemplate);
5794 }
5795
Richard Smithb2bc2e62011-02-21 20:05:19 +00005796 // If this decl has an auto type in need of deduction, make a note of the
5797 // Decl so we can diagnose uses of it in its own initializer.
Richard Smith74aeef52013-04-26 16:15:35 +00005798 if (D.getDeclSpec().containsPlaceholderType() && R->getContainedAutoType())
Richard Smithb2bc2e62011-02-21 20:05:19 +00005799 ParsingInitForAutoVars.insert(NewVD);
Richard Smith30482bc2011-02-20 03:19:35 +00005800
Larisse Voufo72caf2b2013-08-22 00:59:14 +00005801 if (D.isInvalidType() || Invalid) {
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00005802 NewVD->setInvalidDecl();
Larisse Voufo72caf2b2013-08-22 00:59:14 +00005803 if (NewTemplate)
5804 NewTemplate->setInvalidDecl();
5805 }
Mike Stump11289f42009-09-09 15:08:12 +00005806
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00005807 SetNestedNameSpecifier(NewVD, D);
John McCall3e11ebe2010-03-15 10:12:16 +00005808
Richard Smith72db5632014-01-25 21:32:06 +00005809 // If we have any template parameter lists that don't directly belong to
5810 // the variable (matching the scope specifier), store them.
5811 unsigned VDTemplateParamLists = TemplateParams ? 1 : 0;
5812 if (TemplateParamLists.size() > VDTemplateParamLists)
Larisse Voufo39a1e502013-08-06 01:03:05 +00005813 NewVD->setTemplateParameterListsInfo(
Richard Smith72db5632014-01-25 21:32:06 +00005814 Context, TemplateParamLists.size() - VDTemplateParamLists,
5815 TemplateParamLists.data());
Richard Smitha77a0a62011-08-15 21:04:07 +00005816
Richard Smith6331c402012-02-13 22:16:19 +00005817 if (D.getDeclSpec().isConstexprSpecified())
Richard Smithf0215fe2011-12-25 21:17:58 +00005818 NewVD->setConstexpr(true);
Abramo Bagnarada41d0c2010-06-12 08:15:14 +00005819 }
5820
Douglas Gregor41866812011-09-12 18:37:38 +00005821 // Set the lexical context. If the declarator has a C++ scope specifier, the
5822 // lexical context will be different from the semantic context.
5823 NewVD->setLexicalDeclContext(CurContext);
Larisse Voufo72caf2b2013-08-22 00:59:14 +00005824 if (NewTemplate)
5825 NewTemplate->setLexicalDeclContext(CurContext);
Douglas Gregor41866812011-09-12 18:37:38 +00005826
Richard Smith541b38b2013-09-20 01:15:31 +00005827 if (IsLocalExternDecl)
5828 NewVD->setLocalExternDecl();
5829
Artem Belevichfa62ad42015-04-27 19:37:53 +00005830 bool EmitTLSUnsupportedError = false;
Richard Smithb4a9e862013-04-12 22:46:28 +00005831 if (DeclSpec::TSCS TSCS = D.getDeclSpec().getThreadStorageClassSpec()) {
Bob Wilsond8f41652014-11-21 06:52:52 +00005832 // C++11 [dcl.stc]p4:
5833 // When thread_local is applied to a variable of block scope the
5834 // storage-class-specifier static is implied if it does not appear
5835 // explicitly.
5836 // Core issue: 'static' is not implied if the variable is declared
5837 // 'extern'.
5838 if (NewVD->hasLocalStorage() &&
5839 (SCSpec != DeclSpec::SCS_unspecified ||
5840 TSCS != DeclSpec::TSCS_thread_local ||
5841 !DC->isFunctionOrMethod()))
5842 Diag(D.getDeclSpec().getThreadStorageClassSpecLoc(),
5843 diag::err_thread_non_global)
5844 << DeclSpec::getSpecifierName(TSCS);
Artem Belevichfa62ad42015-04-27 19:37:53 +00005845 else if (!Context.getTargetInfo().isTLSSupported()) {
Artem Belevicha0473a52015-04-28 20:31:49 +00005846 if (getLangOpts().CUDA) {
Artem Belevichfa62ad42015-04-27 19:37:53 +00005847 // Postpone error emission until we've collected attributes required to
5848 // figure out whether it's a host or device variable and whether the
5849 // error should be ignored.
5850 EmitTLSUnsupportedError = true;
Artem Belevicha0473a52015-04-28 20:31:49 +00005851 // We still need to mark the variable as TLS so it shows up in AST with
5852 // proper storage class for other tools to use even if we're not going
5853 // to emit any code for it.
5854 NewVD->setTSCSpec(TSCS);
5855 } else
Artem Belevichfa62ad42015-04-27 19:37:53 +00005856 Diag(D.getDeclSpec().getThreadStorageClassSpecLoc(),
5857 diag::err_thread_unsupported);
5858 } else
Enea Zaffanellaacb8ecd2013-05-04 08:27:07 +00005859 NewVD->setTSCSpec(TSCS);
Eli Friedmand5c0eed2009-04-19 20:27:55 +00005860 }
Douglas Gregor6e6ad602009-01-20 01:17:11 +00005861
John McCallc87d9722013-04-02 02:48:58 +00005862 // C99 6.7.4p3
5863 // An inline definition of a function with external linkage shall
5864 // not contain a definition of a modifiable object with static or
5865 // thread storage duration...
5866 // We only apply this when the function is required to be defined
5867 // elsewhere, i.e. when the function is not 'extern inline'. Note
5868 // that a local variable with thread storage duration still has to
5869 // be marked 'static'. Also note that it's possible to get these
5870 // semantics in C++ using __attribute__((gnu_inline)).
Craig Topperc3ec1492014-05-26 06:22:03 +00005871 if (SC == SC_Static && S->getFnParent() != nullptr &&
John McCallc87d9722013-04-02 02:48:58 +00005872 !NewVD->getType().isConstQualified()) {
5873 FunctionDecl *CurFD = getCurFunctionDecl();
5874 if (CurFD && isFunctionDefinitionDiscarded(*this, CurFD)) {
5875 Diag(D.getDeclSpec().getStorageClassSpecLoc(),
5876 diag::warn_static_local_in_extern_inline);
5877 MaybeSuggestAddingStaticToDecl(CurFD);
5878 }
5879 }
5880
Douglas Gregor3c7cd6a2011-09-09 20:53:38 +00005881 if (D.getDeclSpec().isModulePrivateSpecified()) {
Larisse Voufo39a1e502013-08-06 01:03:05 +00005882 if (IsVariableTemplateSpecialization)
5883 Diag(NewVD->getLocation(), diag::err_module_private_specialization)
5884 << (IsPartialSpecialization ? 1 : 0)
5885 << FixItHint::CreateRemoval(
5886 D.getDeclSpec().getModulePrivateSpecLoc());
5887 else if (IsExplicitSpecialization)
Douglas Gregor3c7cd6a2011-09-09 20:53:38 +00005888 Diag(NewVD->getLocation(), diag::err_module_private_specialization)
5889 << 2
5890 << FixItHint::CreateRemoval(D.getDeclSpec().getModulePrivateSpecLoc());
Douglas Gregor41866812011-09-12 18:37:38 +00005891 else if (NewVD->hasLocalStorage())
5892 Diag(NewVD->getLocation(), diag::err_module_private_local)
5893 << 0 << NewVD->getDeclName()
5894 << SourceRange(D.getDeclSpec().getModulePrivateSpecLoc())
5895 << FixItHint::CreateRemoval(D.getDeclSpec().getModulePrivateSpecLoc());
Larisse Voufo72caf2b2013-08-22 00:59:14 +00005896 else {
Douglas Gregor3c7cd6a2011-09-09 20:53:38 +00005897 NewVD->setModulePrivate();
Larisse Voufo72caf2b2013-08-22 00:59:14 +00005898 if (NewTemplate)
5899 NewTemplate->setModulePrivate();
5900 }
Douglas Gregor3c7cd6a2011-09-09 20:53:38 +00005901 }
Douglas Gregor26701a42011-09-09 02:06:17 +00005902
Zhongxing Xu9b7714d2009-01-16 02:36:34 +00005903 // Handle attributes prior to checking for duplicates in MergeVarDecl
Douglas Gregor758a8692009-06-17 21:51:59 +00005904 ProcessDeclAttributes(S, NewVD, D);
Zhongxing Xu9b7714d2009-01-16 02:36:34 +00005905
Peter Collingbournec6b08572012-08-28 20:37:50 +00005906 if (getLangOpts().CUDA) {
Artem Belevichfa62ad42015-04-27 19:37:53 +00005907 if (EmitTLSUnsupportedError && DeclAttrsMatchCUDAMode(getLangOpts(), NewVD))
5908 Diag(D.getDeclSpec().getThreadStorageClassSpecLoc(),
5909 diag::err_thread_unsupported);
Peter Collingbournec6b08572012-08-28 20:37:50 +00005910 // CUDA B.2.5: "__shared__ and __constant__ variables have implied static
5911 // storage [duration]."
Craig Topperc3ec1492014-05-26 06:22:03 +00005912 if (SC == SC_None && S->getFnParent() != nullptr &&
Rafael Espindola2be6b722012-12-21 01:21:33 +00005913 (NewVD->hasAttr<CUDASharedAttr>() ||
5914 NewVD->hasAttr<CUDAConstantAttr>())) {
Peter Collingbournec6b08572012-08-28 20:37:50 +00005915 NewVD->setStorageClass(SC_Static);
Rafael Espindola2be6b722012-12-21 01:21:33 +00005916 }
Peter Collingbournec6b08572012-08-28 20:37:50 +00005917 }
5918
Nico Riecke84f8db2014-03-23 21:24:01 +00005919 // Ensure that dllimport globals without explicit storage class are treated as
5920 // extern. The storage class is set above using parsed attributes. Now we can
5921 // check the VarDecl itself.
5922 assert(!NewVD->hasAttr<DLLImportAttr>() ||
5923 NewVD->getAttr<DLLImportAttr>()->isInherited() ||
5924 NewVD->isStaticDataMember() || NewVD->getStorageClass() != SC_None);
5925
John McCall31168b02011-06-15 23:02:42 +00005926 // In auto-retain/release, infer strong retension for variables of
5927 // retainable type.
David Blaikiebbafb8a2012-03-11 07:00:24 +00005928 if (getLangOpts().ObjCAutoRefCount && inferObjCARCLifetime(NewVD))
John McCall31168b02011-06-15 23:02:42 +00005929 NewVD->setInvalidDecl();
5930
Zhongxing Xu9b7714d2009-01-16 02:36:34 +00005931 // Handle GNU asm-label extension (encoded as an attribute).
Chris Lattner88fdea82010-10-10 18:16:20 +00005932 if (Expr *E = (Expr*)D.getAsmLabel()) {
Zhongxing Xu9b7714d2009-01-16 02:36:34 +00005933 // The parser guarantees this is a string.
Mike Stump11289f42009-09-09 15:08:12 +00005934 StringLiteral *SE = cast<StringLiteral>(E);
Chris Lattner0e62c1c2011-07-23 10:55:15 +00005935 StringRef Label = SE->getString();
Craig Topperc3ec1492014-05-26 06:22:03 +00005936 if (S->getFnParent() != nullptr) {
Abramo Bagnara13392232011-01-11 15:16:52 +00005937 switch (SC) {
5938 case SC_None:
5939 case SC_Auto:
5940 Diag(E->getExprLoc(), diag::warn_asm_label_on_auto_decl) << Label;
5941 break;
5942 case SC_Register:
Renato Golin230c5eb2014-05-19 18:15:42 +00005943 // Local Named register
Douglas Gregore8bbc122011-09-02 00:18:52 +00005944 if (!Context.getTargetInfo().isValidGCCRegisterName(Label))
Abramo Bagnara13392232011-01-11 15:16:52 +00005945 Diag(E->getExprLoc(), diag::err_asm_unknown_register_name) << Label;
5946 break;
5947 case SC_Static:
5948 case SC_Extern:
5949 case SC_PrivateExtern:
Peter Collingbourne2dbb7082011-09-19 21:14:35 +00005950 case SC_OpenCLWorkGroupLocal:
Abramo Bagnara13392232011-01-11 15:16:52 +00005951 break;
5952 }
Renato Golin230c5eb2014-05-19 18:15:42 +00005953 } else if (SC == SC_Register) {
5954 // Global Named register
5955 if (!Context.getTargetInfo().isValidGCCRegisterName(Label))
5956 Diag(E->getExprLoc(), diag::err_asm_unknown_register_name) << Label;
Renato Golin2e31e4e2014-06-05 16:45:22 +00005957 if (!R->isIntegralType(Context) && !R->isPointerType()) {
5958 Diag(D.getLocStart(), diag::err_asm_bad_register_type);
5959 NewVD->setInvalidDecl(true);
5960 }
Abramo Bagnara13392232011-01-11 15:16:52 +00005961 }
5962
5963 NewVD->addAttr(::new (Context) AsmLabelAttr(SE->getStrTokenLoc(0),
Aaron Ballman36a53502014-01-16 13:03:14 +00005964 Context, Label, 0));
Aaron Ballman9ec96a22015-06-25 15:37:16 +00005965 } else if (!ExtnameUndeclaredIdentifiers.empty() &&
5966 isDeclTUScopedExternallyVisible(NewVD)) {
David Chisnall0867d9c2012-02-18 16:12:34 +00005967 llvm::DenseMap<IdentifierInfo*,AsmLabelAttr*>::iterator I =
5968 ExtnameUndeclaredIdentifiers.find(NewVD->getIdentifier());
5969 if (I != ExtnameUndeclaredIdentifiers.end()) {
5970 NewVD->addAttr(I->second);
5971 ExtnameUndeclaredIdentifiers.erase(I);
5972 }
Zhongxing Xu9b7714d2009-01-16 02:36:34 +00005973 }
5974
John McCalla2a3f7d2010-03-16 21:48:18 +00005975 // Diagnose shadowed variables before filtering for scope.
Richard Smith72bcaec2013-12-05 04:30:04 +00005976 if (D.getCXXScopeSpec().isEmpty())
John McCalldf8b37c2010-03-22 09:20:08 +00005977 CheckShadow(S, NewVD, Previous);
John McCalla2a3f7d2010-03-16 21:48:18 +00005978
John McCall1f82f242009-11-18 22:49:29 +00005979 // Don't consider existing declarations that are in a different
5980 // scope and are out-of-semantic-context declarations (if the new
5981 // declaration has linkage).
Richard Smith72bcaec2013-12-05 04:30:04 +00005982 FilterLookupForScope(Previous, OriginalDC, S, shouldConsiderLinkage(NewVD),
5983 D.getCXXScopeSpec().isNotEmpty() ||
5984 IsExplicitSpecialization ||
5985 IsVariableTemplateSpecialization);
Larisse Voufo39a1e502013-08-06 01:03:05 +00005986
Richard Smith1c34fb72013-08-13 18:18:50 +00005987 // Check whether the previous declaration is in the same block scope. This
5988 // affects whether we merge types with it, per C++11 [dcl.array]p3.
5989 if (getLangOpts().CPlusPlus &&
5990 NewVD->isLocalVarDecl() && NewVD->hasExternalStorage())
5991 NewVD->setPreviousDeclInSameBlockScope(
5992 Previous.isSingleResult() && !Previous.isShadowed() &&
Richard Smith541b38b2013-09-20 01:15:31 +00005993 isDeclInScope(Previous.getFoundDecl(), OriginalDC, S, false));
Richard Smith1c34fb72013-08-13 18:18:50 +00005994
David Blaikiebbafb8a2012-03-11 07:00:24 +00005995 if (!getLangOpts().CPlusPlus) {
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00005996 D.setRedeclaration(CheckVariableDeclaration(NewVD, Previous));
5997 } else {
Richard Smithbeef3452014-01-16 23:39:20 +00005998 // If this is an explicit specialization of a static data member, check it.
5999 if (IsExplicitSpecialization && !NewVD->isInvalidDecl() &&
6000 CheckMemberSpecialization(NewVD, Previous))
6001 NewVD->setInvalidDecl();
6002
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00006003 // Merge the decl with the existing one if appropriate.
6004 if (!Previous.empty()) {
6005 if (Previous.isSingleResult() &&
6006 isa<FieldDecl>(Previous.getFoundDecl()) &&
6007 D.getCXXScopeSpec().isSet()) {
6008 // The user tried to define a non-static data member
6009 // out-of-line (C++ [dcl.meaning]p1).
6010 Diag(NewVD->getLocation(), diag::err_nonstatic_member_out_of_line)
6011 << D.getCXXScopeSpec().getRange();
6012 Previous.clear();
6013 NewVD->setInvalidDecl();
6014 }
6015 } else if (D.getCXXScopeSpec().isSet()) {
6016 // No previous declaration in the qualifying scope.
6017 Diag(D.getIdentifierLoc(), diag::err_no_member)
6018 << Name << computeDeclContext(D.getCXXScopeSpec(), true)
Douglas Gregoref1a09a2009-03-25 23:32:15 +00006019 << D.getCXXScopeSpec().getRange();
Chris Lattnerf6d1c9c2009-04-25 08:06:05 +00006020 NewVD->setInvalidDecl();
Douglas Gregoref1a09a2009-03-25 23:32:15 +00006021 }
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00006022
Richard Smithbeef3452014-01-16 23:39:20 +00006023 if (!IsVariableTemplateSpecialization)
6024 D.setRedeclaration(CheckVariableDeclaration(NewVD, Previous));
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00006025
Richard Smithbeef3452014-01-16 23:39:20 +00006026 if (NewTemplate) {
6027 VarTemplateDecl *PrevVarTemplate =
6028 NewVD->getPreviousDecl()
6029 ? NewVD->getPreviousDecl()->getDescribedVarTemplate()
Craig Topperc3ec1492014-05-26 06:22:03 +00006030 : nullptr;
Richard Smithbeef3452014-01-16 23:39:20 +00006031
6032 // Check the template parameter list of this declaration, possibly
6033 // merging in the template parameter list from the previous variable
6034 // template declaration.
6035 if (CheckTemplateParameterList(
6036 TemplateParams,
6037 PrevVarTemplate ? PrevVarTemplate->getTemplateParameters()
Craig Topperc3ec1492014-05-26 06:22:03 +00006038 : nullptr,
Richard Smithbeef3452014-01-16 23:39:20 +00006039 (D.getCXXScopeSpec().isSet() && DC && DC->isRecord() &&
6040 DC->isDependentContext())
6041 ? TPC_ClassTemplateMember
6042 : TPC_VarTemplate))
6043 NewVD->setInvalidDecl();
6044
6045 // If we are providing an explicit specialization of a static variable
6046 // template, make a note of that.
6047 if (PrevVarTemplate &&
6048 PrevVarTemplate->getInstantiatedFromMemberTemplate())
6049 PrevVarTemplate->setMemberSpecialization();
6050 }
Douglas Gregoref1a09a2009-03-25 23:32:15 +00006051 }
Ryan Flynne5dc8592009-07-25 22:29:44 +00006052
Rafael Espindolade6a39f2013-03-02 21:41:48 +00006053 ProcessPragmaWeak(S, NewVD);
Rafael Espindolaf1d2f0e2013-01-16 23:11:15 +00006054
Richard Smithac974a32013-06-30 09:48:50 +00006055 // If this is the first declaration of an extern C variable, update
6056 // the map of such variables.
Rafael Espindola3f9e4442013-10-19 02:13:21 +00006057 if (NewVD->isFirstDecl() && !NewVD->isInvalidDecl() &&
Richard Smithac974a32013-06-30 09:48:50 +00006058 isIncompleteDeclExternC(*this, NewVD))
Richard Smith39b79682013-06-18 20:15:12 +00006059 RegisterLocallyScopedExternCDecl(NewVD, S);
Douglas Gregoref1a09a2009-03-25 23:32:15 +00006060
Reid Klecknerd8110b62013-09-10 20:14:30 +00006061 if (getLangOpts().CPlusPlus && NewVD->isStaticLocal()) {
Eli Friedman3b7d46c2013-07-10 00:30:46 +00006062 Decl *ManglingContextDecl;
David Majnemera7f8c462015-03-19 21:54:30 +00006063 if (MangleNumberingContext *MCtx = getCurrentMangleNumberContext(
6064 NewVD->getDeclContext(), ManglingContextDecl)) {
David Majnemerf27217f2014-03-05 18:55:38 +00006065 Context.setManglingNumber(
David Majnemera7f8c462015-03-19 21:54:30 +00006066 NewVD, MCtx->getManglingNumber(
6067 NewVD, getMSManglingNumber(getLangOpts(), S)));
David Majnemer2206bf52014-03-05 08:57:59 +00006068 Context.setStaticLocalNumber(NewVD, MCtx->getStaticLocalNumber(NewVD));
Eli Friedman3b7d46c2013-07-10 00:30:46 +00006069 }
6070 }
6071
Nico Rieck82f0b062014-03-31 14:56:15 +00006072 if (D.isRedeclaration() && !Previous.empty()) {
6073 checkDLLAttributeRedeclaration(
6074 *this, dyn_cast<NamedDecl>(Previous.getRepresentativeDecl()), NewVD,
6075 IsExplicitSpecialization);
6076 }
6077
Larisse Voufo72caf2b2013-08-22 00:59:14 +00006078 if (NewTemplate) {
Richard Smithbeef3452014-01-16 23:39:20 +00006079 if (NewVD->isInvalidDecl())
6080 NewTemplate->setInvalidDecl();
Larisse Voufo72caf2b2013-08-22 00:59:14 +00006081 ActOnDocumentableDecl(NewTemplate);
6082 return NewTemplate;
Larisse Voufo39a1e502013-08-06 01:03:05 +00006083 }
6084
Larisse Voufo72caf2b2013-08-22 00:59:14 +00006085 return NewVD;
Douglas Gregoref1a09a2009-03-25 23:32:15 +00006086}
6087
John McCalldf8b37c2010-03-22 09:20:08 +00006088/// \brief Diagnose variable or built-in function shadowing. Implements
6089/// -Wshadow.
John McCalla2a3f7d2010-03-16 21:48:18 +00006090///
John McCalldf8b37c2010-03-22 09:20:08 +00006091/// This method is called whenever a VarDecl is added to a "useful"
6092/// scope.
John McCalla2a3f7d2010-03-16 21:48:18 +00006093///
John McCall2d8c7602010-03-20 04:12:52 +00006094/// \param S the scope in which the shadowing name is being declared
6095/// \param R the lookup of the name
John McCalla2a3f7d2010-03-16 21:48:18 +00006096///
John McCalldf8b37c2010-03-22 09:20:08 +00006097void Sema::CheckShadow(Scope *S, VarDecl *D, const LookupResult& R) {
John McCalla2a3f7d2010-03-16 21:48:18 +00006098 // Return if warning is ignored.
Alp Tokerd4a3f0e2014-06-15 23:30:39 +00006099 if (Diags.isIgnored(diag::warn_decl_shadow, R.getNameLoc()))
John McCalla2a3f7d2010-03-16 21:48:18 +00006100 return;
6101
Argyrios Kyrtzidis898fdbf2011-02-08 18:21:25 +00006102 // Don't diagnose declarations at file scope.
Argyrios Kyrtzidisbd0a3fe2011-04-25 21:39:50 +00006103 if (D->hasGlobalStorage())
John McCalla2a3f7d2010-03-16 21:48:18 +00006104 return;
Argyrios Kyrtzidisbd0a3fe2011-04-25 21:39:50 +00006105
6106 DeclContext *NewDC = D->getDeclContext();
6107
John McCall2d8c7602010-03-20 04:12:52 +00006108 // Only diagnose if we're shadowing an unambiguous field or variable.
Douglas Gregor319aa6c2010-03-17 16:03:44 +00006109 if (R.getResultKind() != LookupResult::Found)
John McCalla2a3f7d2010-03-16 21:48:18 +00006110 return;
John McCalla2a3f7d2010-03-16 21:48:18 +00006111
John McCalla2a3f7d2010-03-16 21:48:18 +00006112 NamedDecl* ShadowedDecl = R.getFoundDecl();
6113 if (!isa<VarDecl>(ShadowedDecl) && !isa<FieldDecl>(ShadowedDecl))
6114 return;
6115
Argyrios Kyrtzidisf46cc652011-01-31 07:04:54 +00006116 // Fields are not shadowed by variables in C++ static methods.
6117 if (isa<FieldDecl>(ShadowedDecl))
6118 if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(NewDC))
6119 if (MD->isStatic())
6120 return;
6121
Argyrios Kyrtzidis857dd062011-01-31 07:04:50 +00006122 if (VarDecl *shadowedVar = dyn_cast<VarDecl>(ShadowedDecl))
6123 if (shadowedVar->isExternC()) {
Argyrios Kyrtzidis857dd062011-01-31 07:04:50 +00006124 // For shadowing external vars, make sure that we point to the global
6125 // declaration, not a locally scoped extern declaration.
Aaron Ballman86c93902014-03-06 23:45:36 +00006126 for (auto I : shadowedVar->redecls())
Argyrios Kyrtzidis857dd062011-01-31 07:04:50 +00006127 if (I->isFileVarDecl()) {
Aaron Ballman86c93902014-03-06 23:45:36 +00006128 ShadowedDecl = I;
Argyrios Kyrtzidis857dd062011-01-31 07:04:50 +00006129 break;
6130 }
6131 }
6132
6133 DeclContext *OldDC = ShadowedDecl->getDeclContext();
6134
John McCall2d8c7602010-03-20 04:12:52 +00006135 // Only warn about certain kinds of shadowing for class members.
6136 if (NewDC && NewDC->isRecord()) {
6137 // In particular, don't warn about shadowing non-class members.
6138 if (!OldDC->isRecord())
6139 return;
6140
6141 // TODO: should we warn about static data members shadowing
6142 // static data members from base classes?
6143
6144 // TODO: don't diagnose for inaccessible shadowed members.
6145 // This is hard to do perfectly because we might friend the
6146 // shadowing context, but that's just a false negative.
6147 }
6148
6149 // Determine what kind of declaration we're shadowing.
John McCalla2a3f7d2010-03-16 21:48:18 +00006150 unsigned Kind;
John McCall2d8c7602010-03-20 04:12:52 +00006151 if (isa<RecordDecl>(OldDC)) {
John McCalla2a3f7d2010-03-16 21:48:18 +00006152 if (isa<FieldDecl>(ShadowedDecl))
6153 Kind = 3; // field
6154 else
6155 Kind = 2; // static data member
John McCall2d8c7602010-03-20 04:12:52 +00006156 } else if (OldDC->isFileContext())
John McCalla2a3f7d2010-03-16 21:48:18 +00006157 Kind = 1; // global
6158 else
6159 Kind = 0; // local
6160
John McCall2d8c7602010-03-20 04:12:52 +00006161 DeclarationName Name = R.getLookupName();
6162
John McCalla2a3f7d2010-03-16 21:48:18 +00006163 // Emit warning and note.
Alp Toker15ab3732013-12-12 12:47:48 +00006164 if (getSourceManager().isInSystemMacro(R.getNameLoc()))
6165 return;
John McCall2d8c7602010-03-20 04:12:52 +00006166 Diag(R.getNameLoc(), diag::warn_decl_shadow) << Name << Kind << OldDC;
John McCalla2a3f7d2010-03-16 21:48:18 +00006167 Diag(ShadowedDecl->getLocation(), diag::note_previous_declaration);
6168}
6169
John McCalldf8b37c2010-03-22 09:20:08 +00006170/// \brief Check -Wshadow without the advantage of a previous lookup.
6171void Sema::CheckShadow(Scope *S, VarDecl *D) {
Alp Tokerd4a3f0e2014-06-15 23:30:39 +00006172 if (Diags.isIgnored(diag::warn_decl_shadow, D->getLocation()))
Argyrios Kyrtzidis1cb0de12010-12-15 18:44:22 +00006173 return;
6174
John McCalldf8b37c2010-03-22 09:20:08 +00006175 LookupResult R(*this, D->getDeclName(), D->getLocation(),
6176 Sema::LookupOrdinaryName, Sema::ForRedeclaration);
6177 LookupName(R, S);
6178 CheckShadow(S, D, R);
6179}
6180
Richard Smithac974a32013-06-30 09:48:50 +00006181/// Check for conflict between this global or extern "C" declaration and
6182/// previous global or extern "C" declarations. This is only used in C++.
Rafael Espindola46afb352013-01-11 19:34:23 +00006183template<typename T>
Richard Smithac974a32013-06-30 09:48:50 +00006184static bool checkGlobalOrExternCConflict(
6185 Sema &S, const T *ND, bool IsGlobal, LookupResult &Previous) {
6186 assert(S.getLangOpts().CPlusPlus && "only C++ has extern \"C\"");
6187 NamedDecl *Prev = S.findLocallyScopedExternCDecl(ND->getDeclName());
Rafael Espindola0e0d0092013-03-14 03:07:35 +00006188
Richard Smithac974a32013-06-30 09:48:50 +00006189 if (!Prev && IsGlobal && !isIncompleteDeclExternC(S, ND)) {
6190 // The common case: this global doesn't conflict with any extern "C"
6191 // declaration.
6192 return false;
6193 }
6194
6195 if (Prev) {
6196 if (!IsGlobal || isIncompleteDeclExternC(S, ND)) {
6197 // Both the old and new declarations have C language linkage. This is a
6198 // redeclaration.
6199 Previous.clear();
6200 Previous.addDecl(Prev);
6201 return true;
6202 }
6203
6204 // This is a global, non-extern "C" declaration, and there is a previous
6205 // non-global extern "C" declaration. Diagnose if this is a variable
6206 // declaration.
6207 if (!isa<VarDecl>(ND))
6208 return false;
6209 } else {
6210 // The declaration is extern "C". Check for any declaration in the
6211 // translation unit which might conflict.
6212 if (IsGlobal) {
6213 // We have already performed the lookup into the translation unit.
6214 IsGlobal = false;
6215 for (LookupResult::iterator I = Previous.begin(), E = Previous.end();
6216 I != E; ++I) {
6217 if (isa<VarDecl>(*I)) {
6218 Prev = *I;
6219 break;
6220 }
6221 }
6222 } else {
6223 DeclContext::lookup_result R =
6224 S.Context.getTranslationUnitDecl()->lookup(ND->getDeclName());
6225 for (DeclContext::lookup_result::iterator I = R.begin(), E = R.end();
6226 I != E; ++I) {
6227 if (isa<VarDecl>(*I)) {
6228 Prev = *I;
6229 break;
6230 }
6231 // FIXME: If we have any other entity with this name in global scope,
6232 // the declaration is ill-formed, but that is a defect: it breaks the
6233 // 'stat' hack, for instance. Only variables can have mangled name
6234 // clashes with extern "C" declarations, so only they deserve a
6235 // diagnostic.
6236 }
6237 }
6238
6239 if (!Prev)
Rafael Espindola0e0d0092013-03-14 03:07:35 +00006240 return false;
6241 }
6242
Richard Smithac974a32013-06-30 09:48:50 +00006243 // Use the first declaration's location to ensure we point at something which
6244 // is lexically inside an extern "C" linkage-spec.
6245 assert(Prev && "should have found a previous declaration to diagnose");
6246 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(Prev))
Rafael Espindola8db352d2013-10-17 15:37:26 +00006247 Prev = FD->getFirstDecl();
Richard Smithac974a32013-06-30 09:48:50 +00006248 else
Rafael Espindola8db352d2013-10-17 15:37:26 +00006249 Prev = cast<VarDecl>(Prev)->getFirstDecl();
Richard Smithac974a32013-06-30 09:48:50 +00006250
6251 S.Diag(ND->getLocation(), diag::err_extern_c_global_conflict)
6252 << IsGlobal << ND;
6253 S.Diag(Prev->getLocation(), diag::note_extern_c_global_conflict)
6254 << IsGlobal;
6255 return false;
6256}
6257
6258/// Apply special rules for handling extern "C" declarations. Returns \c true
6259/// if we have found that this is a redeclaration of some prior entity.
6260///
6261/// Per C++ [dcl.link]p6:
6262/// Two declarations [for a function or variable] with C language linkage
6263/// with the same name that appear in different scopes refer to the same
6264/// [entity]. An entity with C language linkage shall not be declared with
6265/// the same name as an entity in global scope.
6266template<typename T>
6267static bool checkForConflictWithNonVisibleExternC(Sema &S, const T *ND,
6268 LookupResult &Previous) {
6269 if (!S.getLangOpts().CPlusPlus) {
6270 // In C, when declaring a global variable, look for a corresponding 'extern'
Richard Smith541b38b2013-09-20 01:15:31 +00006271 // variable declared in function scope. We don't need this in C++, because
6272 // we find local extern decls in the surrounding file-scope DeclContext.
Richard Smithac974a32013-06-30 09:48:50 +00006273 if (ND->getDeclContext()->getRedeclContext()->isTranslationUnit()) {
6274 if (NamedDecl *Prev = S.findLocallyScopedExternCDecl(ND->getDeclName())) {
6275 Previous.clear();
6276 Previous.addDecl(Prev);
6277 return true;
6278 }
6279 }
6280 return false;
6281 }
6282
6283 // A declaration in the translation unit can conflict with an extern "C"
6284 // declaration.
6285 if (ND->getDeclContext()->getRedeclContext()->isTranslationUnit())
6286 return checkGlobalOrExternCConflict(S, ND, /*IsGlobal*/true, Previous);
6287
6288 // An extern "C" declaration can conflict with a declaration in the
6289 // translation unit or can be a redeclaration of an extern "C" declaration
6290 // in another scope.
6291 if (isIncompleteDeclExternC(S,ND))
6292 return checkGlobalOrExternCConflict(S, ND, /*IsGlobal*/false, Previous);
6293
6294 // Neither global nor extern "C": nothing to do.
6295 return false;
Rafael Espindola46afb352013-01-11 19:34:23 +00006296}
6297
Richard Smith27d807c2013-04-30 13:56:41 +00006298void Sema::CheckVariableDeclarationType(VarDecl *NewVD) {
Chris Lattnerf6d1c9c2009-04-25 08:06:05 +00006299 // If the decl is already known invalid, don't check it.
6300 if (NewVD->isInvalidDecl())
Richard Smith27d807c2013-04-30 13:56:41 +00006301 return;
Mike Stump11289f42009-09-09 15:08:12 +00006302
Abramo Bagnara341ab732012-11-08 14:44:42 +00006303 TypeSourceInfo *TInfo = NewVD->getTypeSourceInfo();
6304 QualType T = TInfo->getType();
Douglas Gregoref1a09a2009-03-25 23:32:15 +00006305
Richard Smith27d807c2013-04-30 13:56:41 +00006306 // Defer checking an 'auto' type until its initializer is attached.
6307 if (T->isUndeducedType())
6308 return;
6309
Richard Smithdc4ccaa2014-03-27 01:22:48 +00006310 if (NewVD->hasAttrs())
6311 CheckAlignasUnderalignment(NewVD);
6312
John McCall8b07ec22010-05-15 11:32:37 +00006313 if (T->isObjCObjectType()) {
Fariborz Jahanian9a14c212011-07-25 21:12:27 +00006314 Diag(NewVD->getLocation(), diag::err_statically_allocated_object)
6315 << FixItHint::CreateInsertion(NewVD->getLocation(), "*");
Fariborz Jahanian6507135e2011-07-26 17:58:54 +00006316 T = Context.getObjCObjectPointerType(T);
6317 NewVD->setType(T);
Douglas Gregoref1a09a2009-03-25 23:32:15 +00006318 }
Mike Stump11289f42009-09-09 15:08:12 +00006319
Zhongxing Xu9b7714d2009-01-16 02:36:34 +00006320 // Emit an error if an address space was applied to decl with local storage.
6321 // This includes arrays of objects with address space qualifiers, but not
6322 // automatic variables that point to other address spaces.
6323 // ISO/IEC TR 18037 S5.1.2
Chris Lattner88fdea82010-10-10 18:16:20 +00006324 if (NewVD->hasLocalStorage() && T.getAddressSpace() != 0) {
Douglas Gregoref1a09a2009-03-25 23:32:15 +00006325 Diag(NewVD->getLocation(), diag::err_as_qualified_auto_decl);
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00006326 NewVD->setInvalidDecl();
Richard Smith27d807c2013-04-30 13:56:41 +00006327 return;
Zhongxing Xu9b7714d2009-01-16 02:36:34 +00006328 }
Fariborz Jahanian0c9404e2009-02-21 19:44:02 +00006329
Tanya Lattner713eef42013-04-05 20:14:50 +00006330 // OpenCL v1.2 s6.5 - All program scope variables must be declared in the
6331 // __constant address space.
6332 if (getLangOpts().OpenCL && NewVD->isFileVarDecl()
6333 && T.getAddressSpace() != LangAS::opencl_constant
6334 && !T->isSamplerT()){
6335 Diag(NewVD->getLocation(), diag::err_opencl_global_invalid_addr_space);
6336 NewVD->setInvalidDecl();
Richard Smith27d807c2013-04-30 13:56:41 +00006337 return;
Tanya Lattner713eef42013-04-05 20:14:50 +00006338 }
6339
Tanya Lattner4fdce3f2012-06-19 23:09:52 +00006340 // OpenCL v1.2 s6.8 -- The static qualifier is valid only in program
6341 // scope.
6342 if ((getLangOpts().OpenCLVersion >= 120)
6343 && NewVD->isStaticLocal()) {
6344 Diag(NewVD->getLocation(), diag::err_static_function_scope);
6345 NewVD->setInvalidDecl();
Richard Smith27d807c2013-04-30 13:56:41 +00006346 return;
Tanya Lattner4fdce3f2012-06-19 23:09:52 +00006347 }
6348
Mike Stumpca5ae662009-04-14 00:57:29 +00006349 if (NewVD->hasLocalStorage() && T.isObjCGCWeak()
Fariborz Jahanianc32830c2011-06-07 20:15:46 +00006350 && !NewVD->hasAttr<BlocksAttr>()) {
David Blaikiebbafb8a2012-03-11 07:00:24 +00006351 if (getLangOpts().getGC() != LangOptions::NonGC)
Fariborz Jahanianc32830c2011-06-07 20:15:46 +00006352 Diag(NewVD->getLocation(), diag::warn_gc_attribute_weak_on_local);
Ted Kremenek2f88c402012-10-02 05:36:02 +00006353 else {
6354 assert(!getLangOpts().ObjCAutoRefCount);
Fariborz Jahanianc32830c2011-06-07 20:15:46 +00006355 Diag(NewVD->getLocation(), diag::warn_attribute_weak_on_local);
Ted Kremenek2f88c402012-10-02 05:36:02 +00006356 }
Fariborz Jahanianc32830c2011-06-07 20:15:46 +00006357 }
Chris Lattner88fdea82010-10-10 18:16:20 +00006358
Chris Lattner9fecd742009-04-19 05:21:20 +00006359 bool isVM = T->isVariablyModifiedType();
Chris Lattner9662cd32009-07-19 20:17:11 +00006360 if (isVM || NewVD->hasAttr<CleanupAttr>() ||
John McCalld4e1b762010-08-01 01:24:59 +00006361 NewVD->hasAttr<BlocksAttr>())
John McCallaab3e412010-08-25 08:40:02 +00006362 getCurFunction()->setHasBranchProtectedScope();
Mike Stump11289f42009-09-09 15:08:12 +00006363
Chris Lattner9fecd742009-04-19 05:21:20 +00006364 if ((isVM && NewVD->hasLinkage()) ||
6365 (T->isVariableArrayType() && NewVD->hasGlobalStorage())) {
Anders Carlsson6c885802009-02-28 21:56:50 +00006366 bool SizeIsNegative;
Douglas Gregorcaa1bf42010-08-18 00:39:00 +00006367 llvm::APSInt Oversized;
Abramo Bagnara341ab732012-11-08 14:44:42 +00006368 TypeSourceInfo *FixedTInfo =
6369 TryToFixInvalidVariablyModifiedTypeSourceInfo(TInfo, Context,
6370 SizeIsNegative, Oversized);
Craig Topperc3ec1492014-05-26 06:22:03 +00006371 if (!FixedTInfo && T->isVariableArrayType()) {
Douglas Gregoref1a09a2009-03-25 23:32:15 +00006372 const VariableArrayType *VAT = Context.getAsVariableArrayType(T);
Mike Stump11289f42009-09-09 15:08:12 +00006373 // FIXME: This won't give the correct result for
6374 // int a[10][n];
Anders Carlsson6c885802009-02-28 21:56:50 +00006375 SourceRange SizeRange = VAT->getSizeExpr()->getSourceRange();
Mike Stump11289f42009-09-09 15:08:12 +00006376
Anders Carlsson6c885802009-02-28 21:56:50 +00006377 if (NewVD->isFileVarDecl())
6378 Diag(NewVD->getLocation(), diag::err_vla_decl_in_file_scope)
Chris Lattnerf6d1c9c2009-04-25 08:06:05 +00006379 << SizeRange;
Enea Zaffanella28f36ba2013-05-10 20:34:44 +00006380 else if (NewVD->isStaticLocal())
Anders Carlsson6c885802009-02-28 21:56:50 +00006381 Diag(NewVD->getLocation(), diag::err_vla_decl_has_static_storage)
Chris Lattnerf6d1c9c2009-04-25 08:06:05 +00006382 << SizeRange;
Anders Carlsson6c885802009-02-28 21:56:50 +00006383 else
6384 Diag(NewVD->getLocation(), diag::err_vla_decl_has_extern_linkage)
Chris Lattnerf6d1c9c2009-04-25 08:06:05 +00006385 << SizeRange;
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00006386 NewVD->setInvalidDecl();
Richard Smith27d807c2013-04-30 13:56:41 +00006387 return;
Mike Stump11289f42009-09-09 15:08:12 +00006388 }
6389
Craig Topperc3ec1492014-05-26 06:22:03 +00006390 if (!FixedTInfo) {
Anders Carlsson6c885802009-02-28 21:56:50 +00006391 if (NewVD->isFileVarDecl())
6392 Diag(NewVD->getLocation(), diag::err_vm_decl_in_file_scope);
6393 else
6394 Diag(NewVD->getLocation(), diag::err_vm_decl_has_extern_linkage);
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00006395 NewVD->setInvalidDecl();
Richard Smith27d807c2013-04-30 13:56:41 +00006396 return;
Anders Carlsson6c885802009-02-28 21:56:50 +00006397 }
Mike Stump11289f42009-09-09 15:08:12 +00006398
Chris Lattnerf6d1c9c2009-04-25 08:06:05 +00006399 Diag(NewVD->getLocation(), diag::warn_illegal_constant_array_size);
Abramo Bagnara3b8a9e52012-11-08 16:01:51 +00006400 NewVD->setType(FixedTInfo->getType());
Abramo Bagnara341ab732012-11-08 14:44:42 +00006401 NewVD->setTypeSourceInfo(FixedTInfo);
Anders Carlsson6c885802009-02-28 21:56:50 +00006402 }
6403
David Majnemer0ffa3312013-05-29 00:56:45 +00006404 if (T->isVoidType()) {
6405 // C++98 [dcl.stc]p5: The extern specifier can be applied only to the names
6406 // of objects and functions.
6407 if (NewVD->isThisDeclarationADefinition() || getLangOpts().CPlusPlus) {
6408 Diag(NewVD->getLocation(), diag::err_typecheck_decl_incomplete_type)
6409 << T;
6410 NewVD->setInvalidDecl();
6411 return;
6412 }
Richard Smith27d807c2013-04-30 13:56:41 +00006413 }
6414
6415 if (!NewVD->hasLocalStorage() && NewVD->hasAttr<BlocksAttr>()) {
6416 Diag(NewVD->getLocation(), diag::err_block_on_nonlocal);
6417 NewVD->setInvalidDecl();
6418 return;
6419 }
6420
6421 if (isVM && NewVD->hasAttr<BlocksAttr>()) {
6422 Diag(NewVD->getLocation(), diag::err_block_on_vm);
6423 NewVD->setInvalidDecl();
6424 return;
6425 }
6426
6427 if (NewVD->isConstexpr() && !T->isDependentType() &&
6428 RequireLiteralType(NewVD->getLocation(), T,
6429 diag::err_constexpr_var_non_literal)) {
Richard Smith27d807c2013-04-30 13:56:41 +00006430 NewVD->setInvalidDecl();
6431 return;
6432 }
6433}
6434
6435/// \brief Perform semantic checking on a newly-created variable
6436/// declaration.
6437///
6438/// This routine performs all of the type-checking required for a
6439/// variable declaration once it has been built. It is used both to
6440/// check variables after they have been parsed and their declarators
6441/// have been translated into a declaration, and to check variables
6442/// that have been instantiated from a template.
6443///
6444/// Sets NewVD->isInvalidDecl() if an error was encountered.
6445///
6446/// Returns true if the variable declaration is a redeclaration.
Larisse Voufo72caf2b2013-08-22 00:59:14 +00006447bool Sema::CheckVariableDeclaration(VarDecl *NewVD, LookupResult &Previous) {
Richard Smith27d807c2013-04-30 13:56:41 +00006448 CheckVariableDeclarationType(NewVD);
6449
6450 // If the decl is already known invalid, don't check it.
6451 if (NewVD->isInvalidDecl())
6452 return false;
6453
John McCallb65e8fe2013-04-01 18:34:28 +00006454 // If we did not find anything by this name, look for a non-visible
6455 // extern "C" declaration with the same name.
Richard Smith1c34fb72013-08-13 18:18:50 +00006456 if (Previous.empty() &&
6457 checkForConflictWithNonVisibleExternC(*this, NewVD, Previous))
Richard Smith3c785782013-09-03 21:00:58 +00006458 Previous.setShadowed();
Douglas Gregor5a80bd12009-03-02 00:19:53 +00006459
Douglas Gregor3552dab2013-01-09 00:47:56 +00006460 // Filter out any non-conflicting previous declarations.
Richard Smith42413142015-05-15 20:05:43 +00006461 filterNonConflictingPreviousDecls(*this, NewVD, Previous);
Douglas Gregor3552dab2013-01-09 00:47:56 +00006462
John McCall1f82f242009-11-18 22:49:29 +00006463 if (!Previous.empty()) {
Richard Smith3c785782013-09-03 21:00:58 +00006464 MergeVarDecl(NewVD, Previous);
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00006465 return true;
Zhongxing Xu9b7714d2009-01-16 02:36:34 +00006466 }
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00006467 return false;
Zhongxing Xu9b7714d2009-01-16 02:36:34 +00006468}
6469
Douglas Gregor36d1b142009-10-06 17:59:45 +00006470/// \brief Data used with FindOverriddenMethod
6471struct FindOverriddenMethodData {
6472 Sema *S;
6473 CXXMethodDecl *Method;
6474};
6475
6476/// \brief Member lookup function that determines whether a given C++
6477/// method overrides a method in a base class, to be used with
6478/// CXXRecordDecl::lookupInBases().
John McCall84c16cf2009-11-12 03:15:40 +00006479static bool FindOverriddenMethod(const CXXBaseSpecifier *Specifier,
Douglas Gregor36d1b142009-10-06 17:59:45 +00006480 CXXBasePath &Path,
6481 void *UserData) {
6482 RecordDecl *BaseRecord = Specifier->getType()->getAs<RecordType>()->getDecl();
Anders Carlssone985fae2009-11-26 20:50:40 +00006483
Douglas Gregor36d1b142009-10-06 17:59:45 +00006484 FindOverriddenMethodData *Data
6485 = reinterpret_cast<FindOverriddenMethodData*>(UserData);
Anders Carlssone985fae2009-11-26 20:50:40 +00006486
6487 DeclarationName Name = Data->Method->getDeclName();
6488
6489 // FIXME: Do we care about other names here too?
6490 if (Name.getNameKind() == DeclarationName::CXXDestructorName) {
John McCalle9cccd82010-06-16 08:42:20 +00006491 // We really want to find the base class destructor here.
Anders Carlssone985fae2009-11-26 20:50:40 +00006492 QualType T = Data->S->Context.getTypeDeclType(BaseRecord);
6493 CanQualType CT = Data->S->Context.getCanonicalType(T);
6494
Anders Carlsson5a4f7722009-11-27 01:26:58 +00006495 Name = Data->S->Context.DeclarationNames.getCXXDestructorName(CT);
Anders Carlssone985fae2009-11-26 20:50:40 +00006496 }
6497
6498 for (Path.Decls = BaseRecord->lookup(Name);
David Blaikieff7d47a2012-12-19 00:45:41 +00006499 !Path.Decls.empty();
6500 Path.Decls = Path.Decls.slice(1)) {
6501 NamedDecl *D = Path.Decls.front();
John McCalle9cccd82010-06-16 08:42:20 +00006502 if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(D)) {
6503 if (MD->isVirtual() && !Data->S->IsOverload(Data->Method, MD, false))
Douglas Gregor36d1b142009-10-06 17:59:45 +00006504 return true;
6505 }
6506 }
6507
6508 return false;
6509}
6510
David Blaikie7e414262012-10-17 00:47:58 +00006511namespace {
6512 enum OverrideErrorKind { OEK_All, OEK_NonDeleted, OEK_Deleted };
6513}
6514/// \brief Report an error regarding overriding, along with any relevant
6515/// overriden methods.
6516///
6517/// \param DiagID the primary error to report.
6518/// \param MD the overriding method.
6519/// \param OEK which overrides to include as notes.
6520static void ReportOverrides(Sema& S, unsigned DiagID, const CXXMethodDecl *MD,
6521 OverrideErrorKind OEK = OEK_All) {
6522 S.Diag(MD->getLocation(), DiagID) << MD->getDeclName();
6523 for (CXXMethodDecl::method_iterator I = MD->begin_overridden_methods(),
6524 E = MD->end_overridden_methods();
6525 I != E; ++I) {
6526 // This check (& the OEK parameter) could be replaced by a predicate, but
6527 // without lambdas that would be overkill. This is still nicer than writing
6528 // out the diag loop 3 times.
6529 if ((OEK == OEK_All) ||
6530 (OEK == OEK_NonDeleted && !(*I)->isDeleted()) ||
6531 (OEK == OEK_Deleted && (*I)->isDeleted()))
6532 S.Diag((*I)->getLocation(), diag::note_overridden_virtual_function);
6533 }
6534}
6535
Sebastian Redld5b24532009-11-18 21:51:29 +00006536/// AddOverriddenMethods - See if a method overrides any in the base classes,
6537/// and if so, check that it's a valid override and remember it.
Douglas Gregor5a2bb5b2010-10-13 22:55:32 +00006538bool Sema::AddOverriddenMethods(CXXRecordDecl *DC, CXXMethodDecl *MD) {
David Blaikie1cbb9712014-11-14 19:09:44 +00006539 // Look for methods in base classes that this method might override.
Sebastian Redld5b24532009-11-18 21:51:29 +00006540 CXXBasePaths Paths;
6541 FindOverriddenMethodData Data;
6542 Data.Method = MD;
6543 Data.S = this;
David Blaikie7e414262012-10-17 00:47:58 +00006544 bool hasDeletedOverridenMethods = false;
6545 bool hasNonDeletedOverridenMethods = false;
Douglas Gregor5a2bb5b2010-10-13 22:55:32 +00006546 bool AddedAny = false;
Sebastian Redld5b24532009-11-18 21:51:29 +00006547 if (DC->lookupInBases(&FindOverriddenMethod, &Data, Paths)) {
Aaron Ballmane6f465e2014-03-14 21:38:48 +00006548 for (auto *I : Paths.found_decls()) {
6549 if (CXXMethodDecl *OldMD = dyn_cast<CXXMethodDecl>(I)) {
Richard Trieu95d88092011-07-01 20:02:53 +00006550 MD->addOverriddenMethod(OldMD->getCanonicalDecl());
Sebastian Redld5b24532009-11-18 21:51:29 +00006551 if (!CheckOverridingFunctionReturnType(MD, OldMD) &&
Aaron Ballman02df2e02012-12-09 17:45:41 +00006552 !CheckOverridingFunctionAttributes(MD, OldMD) &&
Richard Smithd3b5c9082012-07-27 04:22:15 +00006553 !CheckOverridingFunctionExceptionSpec(MD, OldMD) &&
Anders Carlsson3f610c72011-01-20 16:25:36 +00006554 !CheckIfOverriddenFunctionIsMarkedFinal(MD, OldMD)) {
David Blaikie7e414262012-10-17 00:47:58 +00006555 hasDeletedOverridenMethods |= OldMD->isDeleted();
6556 hasNonDeletedOverridenMethods |= !OldMD->isDeleted();
Douglas Gregor5a2bb5b2010-10-13 22:55:32 +00006557 AddedAny = true;
6558 }
Sebastian Redld5b24532009-11-18 21:51:29 +00006559 }
6560 }
6561 }
David Blaikie7e414262012-10-17 00:47:58 +00006562
6563 if (hasDeletedOverridenMethods && !MD->isDeleted()) {
6564 ReportOverrides(*this, diag::err_non_deleted_override, MD, OEK_Deleted);
6565 }
6566 if (hasNonDeletedOverridenMethods && MD->isDeleted()) {
6567 ReportOverrides(*this, diag::err_deleted_override, MD, OEK_NonDeleted);
6568 }
6569
Douglas Gregor5a2bb5b2010-10-13 22:55:32 +00006570 return AddedAny;
Sebastian Redld5b24532009-11-18 21:51:29 +00006571}
6572
Kaelyn Uhrain0a32fca2011-10-11 00:28:39 +00006573namespace {
6574 // Struct for holding all of the extra arguments needed by
6575 // DiagnoseInvalidRedeclaration to call Sema::ActOnFunctionDeclarator.
6576 struct ActOnFDArgs {
6577 Scope *S;
6578 Declarator &D;
Kaelyn Uhrain0a32fca2011-10-11 00:28:39 +00006579 MultiTemplateParamsArg TemplateParamLists;
Kaelyn Uhrain0a32fca2011-10-11 00:28:39 +00006580 bool AddToScope;
6581 };
6582}
6583
Kaelyn Uhrainb1378402012-01-18 21:41:41 +00006584namespace {
6585
6586// Callback to only accept typo corrections that have a non-zero edit distance.
Kaelyn Uhrain7c019172012-02-16 22:40:59 +00006587// Also only accept corrections that have the same parent decl.
Kaelyn Uhrainb1378402012-01-18 21:41:41 +00006588class DifferentNameValidatorCCC : public CorrectionCandidateCallback {
6589 public:
Kaelyn Uhrain389e9c22012-06-07 23:57:08 +00006590 DifferentNameValidatorCCC(ASTContext &Context, FunctionDecl *TypoFD,
6591 CXXRecordDecl *Parent)
6592 : Context(Context), OriginalFD(TypoFD),
Craig Topperc3ec1492014-05-26 06:22:03 +00006593 ExpectedParent(Parent ? Parent->getCanonicalDecl() : nullptr) {}
Kaelyn Uhrain7c019172012-02-16 22:40:59 +00006594
Craig Toppere14c0f82014-03-12 04:55:44 +00006595 bool ValidateCandidate(const TypoCorrection &candidate) override {
Kaelyn Uhrain7c019172012-02-16 22:40:59 +00006596 if (candidate.getEditDistance() == 0)
6597 return false;
6598
Dmitri Gribenkof8579502013-01-12 19:30:44 +00006599 SmallVector<unsigned, 1> MismatchedParams;
Kaelyn Uhrain389e9c22012-06-07 23:57:08 +00006600 for (TypoCorrection::const_decl_iterator CDecl = candidate.begin(),
6601 CDeclEnd = candidate.end();
6602 CDecl != CDeclEnd; ++CDecl) {
6603 FunctionDecl *FD = dyn_cast<FunctionDecl>(*CDecl);
6604
6605 if (FD && !FD->hasBody() &&
6606 hasSimilarParameters(Context, FD, OriginalFD, MismatchedParams)) {
6607 if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) {
6608 CXXRecordDecl *Parent = MD->getParent();
6609 if (Parent && Parent->getCanonicalDecl() == ExpectedParent)
6610 return true;
6611 } else if (!ExpectedParent) {
6612 return true;
6613 }
6614 }
Kaelyn Uhrain7c019172012-02-16 22:40:59 +00006615 }
6616
Kaelyn Uhrain389e9c22012-06-07 23:57:08 +00006617 return false;
Kaelyn Uhrainb1378402012-01-18 21:41:41 +00006618 }
Kaelyn Uhrain7c019172012-02-16 22:40:59 +00006619
6620 private:
Kaelyn Uhrain389e9c22012-06-07 23:57:08 +00006621 ASTContext &Context;
6622 FunctionDecl *OriginalFD;
Kaelyn Uhrain7c019172012-02-16 22:40:59 +00006623 CXXRecordDecl *ExpectedParent;
Kaelyn Uhrainb1378402012-01-18 21:41:41 +00006624};
6625
Alexander Kornienkoab9db512015-06-22 23:07:51 +00006626}
Kaelyn Uhrainb1378402012-01-18 21:41:41 +00006627
Kaelyn Uhrain0a32fca2011-10-11 00:28:39 +00006628/// \brief Generate diagnostics for an invalid function redeclaration.
6629///
6630/// This routine handles generating the diagnostic messages for an invalid
6631/// function redeclaration, including finding possible similar declarations
6632/// or performing typo correction if there are no previous declarations with
6633/// the same name.
6634///
Sylvestre Ledru33b5baf2012-09-27 10:16:10 +00006635/// Returns a NamedDecl iff typo correction was performed and substituting in
Kaelyn Uhrain0a32fca2011-10-11 00:28:39 +00006636/// the new declaration name does not cause new errors.
Richard Smith114394f2013-08-09 04:35:01 +00006637static NamedDecl *DiagnoseInvalidRedeclaration(
Kaelyn Uhrain8af2c9f2011-10-11 00:28:52 +00006638 Sema &SemaRef, LookupResult &Previous, FunctionDecl *NewFD,
Richard Smith114394f2013-08-09 04:35:01 +00006639 ActOnFDArgs &ExtraArgs, bool IsLocalFriend, Scope *S) {
Kaelyn Uhrainfd81a352011-08-18 18:19:12 +00006640 DeclarationName Name = NewFD->getDeclName();
Kaelyn Uhrain0a32fca2011-10-11 00:28:39 +00006641 DeclContext *NewDC = NewFD->getDeclContext();
Dmitri Gribenkof8579502013-01-12 19:30:44 +00006642 SmallVector<unsigned, 1> MismatchedParams;
6643 SmallVector<std::pair<FunctionDecl *, unsigned>, 1> NearMatches;
Kaelyn Uhrainfd81a352011-08-18 18:19:12 +00006644 TypoCorrection Correction;
Richard Smithf9b15102013-08-17 00:46:16 +00006645 bool IsDefinition = ExtraArgs.D.isFunctionDefinition();
Richard Smith114394f2013-08-09 04:35:01 +00006646 unsigned DiagMsg = IsLocalFriend ? diag::err_no_matching_local_friend
6647 : diag::err_member_decl_does_not_match;
6648 LookupResult Prev(SemaRef, Name, NewFD->getLocation(),
6649 IsLocalFriend ? Sema::LookupLocalFriendName
6650 : Sema::LookupOrdinaryName,
6651 Sema::ForRedeclaration);
Kaelyn Uhrainfd81a352011-08-18 18:19:12 +00006652
6653 NewFD->setInvalidDecl();
Richard Smith114394f2013-08-09 04:35:01 +00006654 if (IsLocalFriend)
6655 SemaRef.LookupName(Prev, S);
6656 else
6657 SemaRef.LookupQualifiedName(Prev, NewDC);
John McCallf7cfb222010-10-13 05:45:15 +00006658 assert(!Prev.isAmbiguous() &&
6659 "Cannot have an ambiguity in previous-declaration lookup");
Kaelyn Uhrain7c019172012-02-16 22:40:59 +00006660 CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(NewFD);
Kaelyn Uhrainfd81a352011-08-18 18:19:12 +00006661 if (!Prev.empty()) {
6662 for (LookupResult::iterator Func = Prev.begin(), FuncEnd = Prev.end();
6663 Func != FuncEnd; ++Func) {
6664 FunctionDecl *FD = dyn_cast<FunctionDecl>(*Func);
Kaelyn Uhrain8af2c9f2011-10-11 00:28:52 +00006665 if (FD &&
6666 hasSimilarParameters(SemaRef.Context, FD, NewFD, MismatchedParams)) {
Kaelyn Uhrainfd81a352011-08-18 18:19:12 +00006667 // Add 1 to the index so that 0 can mean the mismatch didn't
6668 // involve a parameter
6669 unsigned ParamNum =
6670 MismatchedParams.empty() ? 0 : MismatchedParams.front() + 1;
6671 NearMatches.push_back(std::make_pair(FD, ParamNum));
6672 }
Kaelyn Uhrain7d9bc632011-08-04 17:40:00 +00006673 }
Kaelyn Uhrainfd81a352011-08-18 18:19:12 +00006674 // If the qualified name lookup yielded nothing, try typo correction
Richard Smith114394f2013-08-09 04:35:01 +00006675 } else if ((Correction = SemaRef.CorrectTypo(
Kaelyn Takata89c881b2014-10-27 18:07:29 +00006676 Prev.getLookupNameInfo(), Prev.getLookupKind(), S,
6677 &ExtraArgs.D.getCXXScopeSpec(),
6678 llvm::make_unique<DifferentNameValidatorCCC>(
6679 SemaRef.Context, NewFD, MD ? MD->getParent() : nullptr),
6680 Sema::CTK_ErrorRecovery, IsLocalFriend ? nullptr : NewDC))) {
Kaelyn Uhrain0a32fca2011-10-11 00:28:39 +00006681 // Set up everything for the call to ActOnFunctionDeclarator
6682 ExtraArgs.D.SetIdentifier(Correction.getCorrectionAsIdentifierInfo(),
6683 ExtraArgs.D.getIdentifierLoc());
6684 Previous.clear();
6685 Previous.setLookupName(Correction.getCorrection());
Kaelyn Uhrainfd81a352011-08-18 18:19:12 +00006686 for (TypoCorrection::decl_iterator CDecl = Correction.begin(),
6687 CDeclEnd = Correction.end();
6688 CDecl != CDeclEnd; ++CDecl) {
6689 FunctionDecl *FD = dyn_cast<FunctionDecl>(*CDecl);
Kaelyn Uhrain389e9c22012-06-07 23:57:08 +00006690 if (FD && !FD->hasBody() &&
6691 hasSimilarParameters(SemaRef.Context, FD, NewFD, MismatchedParams)) {
Kaelyn Uhrain0a32fca2011-10-11 00:28:39 +00006692 Previous.addDecl(FD);
Kaelyn Uhrainfd81a352011-08-18 18:19:12 +00006693 }
6694 }
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00006695 bool wasRedeclaration = ExtraArgs.D.isRedeclaration();
Richard Smithf9b15102013-08-17 00:46:16 +00006696
6697 NamedDecl *Result;
6698 // Retry building the function declaration with the new previous
6699 // declarations, and with errors suppressed.
6700 {
6701 // Trap errors.
6702 Sema::SFINAETrap Trap(SemaRef);
6703
6704 // TODO: Refactor ActOnFunctionDeclarator so that we can call only the
6705 // pieces need to verify the typo-corrected C++ declaration and hopefully
6706 // eliminate the need for the parameter pack ExtraArgs.
6707 Result = SemaRef.ActOnFunctionDeclarator(
6708 ExtraArgs.S, ExtraArgs.D,
6709 Correction.getCorrectionDecl()->getDeclContext(),
6710 NewFD->getTypeSourceInfo(), Previous, ExtraArgs.TemplateParamLists,
6711 ExtraArgs.AddToScope);
6712
6713 if (Trap.hasErrorOccurred())
Craig Topperc3ec1492014-05-26 06:22:03 +00006714 Result = nullptr;
Kaelyn Uhrain0a32fca2011-10-11 00:28:39 +00006715 }
Richard Smithf9b15102013-08-17 00:46:16 +00006716
6717 if (Result) {
6718 // Determine which correction we picked.
6719 Decl *Canonical = Result->getCanonicalDecl();
6720 for (LookupResult::iterator I = Previous.begin(), E = Previous.end();
6721 I != E; ++I)
6722 if ((*I)->getCanonicalDecl() == Canonical)
6723 Correction.setCorrectionDecl(*I);
6724
6725 SemaRef.diagnoseTypo(
6726 Correction,
6727 SemaRef.PDiag(IsLocalFriend
6728 ? diag::err_no_matching_local_friend_suggest
6729 : diag::err_member_decl_does_not_match_suggest)
6730 << Name << NewDC << IsDefinition);
6731 return Result;
Kaelyn Uhrain0a32fca2011-10-11 00:28:39 +00006732 }
Richard Smithf9b15102013-08-17 00:46:16 +00006733
6734 // Pretend the typo correction never occurred
6735 ExtraArgs.D.SetIdentifier(Name.getAsIdentifierInfo(),
6736 ExtraArgs.D.getIdentifierLoc());
6737 ExtraArgs.D.setRedeclaration(wasRedeclaration);
6738 Previous.clear();
6739 Previous.setLookupName(Name);
Kaelyn Uhrainfd81a352011-08-18 18:19:12 +00006740 }
6741
Richard Smithf9b15102013-08-17 00:46:16 +00006742 SemaRef.Diag(NewFD->getLocation(), DiagMsg)
6743 << Name << NewDC << IsDefinition << NewFD->getLocation();
Kaelyn Uhrainfd81a352011-08-18 18:19:12 +00006744
Kaelyn Uhrain1a6eb992011-10-10 18:01:37 +00006745 bool NewFDisConst = false;
6746 if (CXXMethodDecl *NewMD = dyn_cast<CXXMethodDecl>(NewFD))
David Blaikief5697e52012-08-10 00:55:35 +00006747 NewFDisConst = NewMD->isConst();
Kaelyn Uhrain1a6eb992011-10-10 18:01:37 +00006748
Craig Topperaf6bd1b2013-07-04 03:15:42 +00006749 for (SmallVectorImpl<std::pair<FunctionDecl *, unsigned> >::iterator
Kaelyn Uhrainfd81a352011-08-18 18:19:12 +00006750 NearMatch = NearMatches.begin(), NearMatchEnd = NearMatches.end();
6751 NearMatch != NearMatchEnd; ++NearMatch) {
6752 FunctionDecl *FD = NearMatch->first;
Richard Smith114394f2013-08-09 04:35:01 +00006753 CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD);
6754 bool FDisConst = MD && MD->isConst();
6755 bool IsMember = MD || !IsLocalFriend;
Kaelyn Uhrainfd81a352011-08-18 18:19:12 +00006756
Richard Smith541b38b2013-09-20 01:15:31 +00006757 // FIXME: These notes are poorly worded for the local friend case.
Kaelyn Uhrainfd81a352011-08-18 18:19:12 +00006758 if (unsigned Idx = NearMatch->second) {
6759 ParmVarDecl *FDParam = FD->getParamDecl(Idx-1);
Richard Smithcf8ec8d2012-04-02 18:40:40 +00006760 SourceLocation Loc = FDParam->getTypeSpecStartLoc();
6761 if (Loc.isInvalid()) Loc = FD->getLocation();
Richard Smith114394f2013-08-09 04:35:01 +00006762 SemaRef.Diag(Loc, IsMember ? diag::note_member_def_close_param_match
6763 : diag::note_local_decl_close_param_match)
6764 << Idx << FDParam->getType()
6765 << NewFD->getParamDecl(Idx - 1)->getType();
Kaelyn Uhrain1a6eb992011-10-10 18:01:37 +00006766 } else if (FDisConst != NewFDisConst) {
Kaelyn Uhrain8af2c9f2011-10-11 00:28:52 +00006767 SemaRef.Diag(FD->getLocation(), diag::note_member_def_close_const_match)
Kaelyn Uhrain1a6eb992011-10-10 18:01:37 +00006768 << NewFDisConst << FD->getSourceRange().getEnd();
Kaelyn Uhrainfd81a352011-08-18 18:19:12 +00006769 } else
Richard Smith114394f2013-08-09 04:35:01 +00006770 SemaRef.Diag(FD->getLocation(),
6771 IsMember ? diag::note_member_def_close_match
6772 : diag::note_local_decl_close_match);
John McCallf7cfb222010-10-13 05:45:15 +00006773 }
Craig Topperc3ec1492014-05-26 06:22:03 +00006774 return nullptr;
John McCallf7cfb222010-10-13 05:45:15 +00006775}
6776
Craig Topperc79e5e32014-10-31 06:57:13 +00006777static StorageClass getFunctionStorageClass(Sema &SemaRef, Declarator &D) {
Kaelyn Uhraine1a9ff72011-10-11 00:28:49 +00006778 switch (D.getDeclSpec().getStorageClassSpec()) {
6779 default: llvm_unreachable("Unknown storage class!");
6780 case DeclSpec::SCS_auto:
6781 case DeclSpec::SCS_register:
6782 case DeclSpec::SCS_mutable:
6783 SemaRef.Diag(D.getDeclSpec().getStorageClassSpecLoc(),
6784 diag::err_typecheck_sclass_func);
6785 D.setInvalidType();
6786 break;
6787 case DeclSpec::SCS_unspecified: break;
Rafael Espindolabff59562013-04-25 12:11:36 +00006788 case DeclSpec::SCS_extern:
6789 if (D.getDeclSpec().isExternInLinkageSpec())
6790 return SC_None;
6791 return SC_Extern;
Kaelyn Uhraine1a9ff72011-10-11 00:28:49 +00006792 case DeclSpec::SCS_static: {
6793 if (SemaRef.CurContext->getRedeclContext()->isFunctionOrMethod()) {
6794 // C99 6.7.1p5:
6795 // The declaration of an identifier for a function that has
6796 // block scope shall have no explicit storage-class specifier
6797 // other than extern
6798 // See also (C++ [dcl.stc]p4).
6799 SemaRef.Diag(D.getDeclSpec().getStorageClassSpecLoc(),
6800 diag::err_static_block_func);
6801 break;
6802 } else
6803 return SC_Static;
6804 }
6805 case DeclSpec::SCS_private_extern: return SC_PrivateExtern;
6806 }
6807
6808 // No explicit storage class has already been returned
6809 return SC_None;
6810}
6811
6812static FunctionDecl* CreateNewFunctionDecl(Sema &SemaRef, Declarator &D,
6813 DeclContext *DC, QualType &R,
6814 TypeSourceInfo *TInfo,
Craig Topperc79e5e32014-10-31 06:57:13 +00006815 StorageClass SC,
Kaelyn Uhraine1a9ff72011-10-11 00:28:49 +00006816 bool &IsVirtualOkay) {
6817 DeclarationNameInfo NameInfo = SemaRef.GetNameForDeclarator(D);
6818 DeclarationName Name = NameInfo.getName();
6819
Craig Topperc3ec1492014-05-26 06:22:03 +00006820 FunctionDecl *NewFD = nullptr;
Kaelyn Uhraine1a9ff72011-10-11 00:28:49 +00006821 bool isInline = D.getDeclSpec().isInlineSpecified();
Kaelyn Uhraine1a9ff72011-10-11 00:28:49 +00006822
David Blaikiebbafb8a2012-03-11 07:00:24 +00006823 if (!SemaRef.getLangOpts().CPlusPlus) {
Kaelyn Uhraine1a9ff72011-10-11 00:28:49 +00006824 // Determine whether the function was written with a
6825 // prototype. This true when:
6826 // - there is a prototype in the declarator, or
6827 // - the type R of the function is some kind of typedef or other reference
6828 // to a type name (which eventually refers to a function type).
6829 bool HasPrototype =
6830 (D.isFunctionDeclarator() && D.getFunctionTypeInfo().hasPrototype) ||
6831 (!isa<FunctionType>(R.getTypePtr()) && R->isFunctionProtoType());
6832
David Blaikie30d15442011-10-19 22:56:21 +00006833 NewFD = FunctionDecl::Create(SemaRef.Context, DC,
Daniel Dunbar62ee6412012-03-09 18:35:03 +00006834 D.getLocStart(), NameInfo, R,
Rafael Espindola6ae7e502013-04-03 19:27:57 +00006835 TInfo, SC, isInline,
6836 HasPrototype, false);
Kaelyn Uhraine1a9ff72011-10-11 00:28:49 +00006837 if (D.isInvalidType())
6838 NewFD->setInvalidDecl();
6839
Kaelyn Uhraine1a9ff72011-10-11 00:28:49 +00006840 return NewFD;
6841 }
6842
6843 bool isExplicit = D.getDeclSpec().isExplicitSpecified();
6844 bool isConstexpr = D.getDeclSpec().isConstexprSpecified();
6845
6846 // Check that the return type is not an abstract class type.
6847 // For record types, this is done by the AbstractClassUsageDiagnoser once
6848 // the class has been completely parsed.
6849 if (!DC->isRecord() &&
Alp Toker314cc812014-01-25 16:55:45 +00006850 SemaRef.RequireNonAbstractType(
6851 D.getIdentifierLoc(), R->getAs<FunctionType>()->getReturnType(),
6852 diag::err_abstract_type_in_decl, SemaRef.AbstractReturnType))
Kaelyn Uhraine1a9ff72011-10-11 00:28:49 +00006853 D.setInvalidType();
6854
6855 if (Name.getNameKind() == DeclarationName::CXXConstructorName) {
6856 // This is a C++ constructor declaration.
6857 assert(DC->isRecord() &&
6858 "Constructors can only be declared in a member context");
6859
6860 R = SemaRef.CheckConstructorDeclarator(D, R, SC);
6861 return CXXConstructorDecl::Create(SemaRef.Context, cast<CXXRecordDecl>(DC),
Daniel Dunbar62ee6412012-03-09 18:35:03 +00006862 D.getLocStart(), NameInfo,
Kaelyn Uhraine1a9ff72011-10-11 00:28:49 +00006863 R, TInfo, isExplicit, isInline,
6864 /*isImplicitlyDeclared=*/false,
6865 isConstexpr);
6866
6867 } else if (Name.getNameKind() == DeclarationName::CXXDestructorName) {
6868 // This is a C++ destructor declaration.
6869 if (DC->isRecord()) {
6870 R = SemaRef.CheckDestructorDeclarator(D, R, SC);
6871 CXXRecordDecl *Record = cast<CXXRecordDecl>(DC);
6872 CXXDestructorDecl *NewDD = CXXDestructorDecl::Create(
6873 SemaRef.Context, Record,
Daniel Dunbar62ee6412012-03-09 18:35:03 +00006874 D.getLocStart(),
Kaelyn Uhraine1a9ff72011-10-11 00:28:49 +00006875 NameInfo, R, TInfo, isInline,
6876 /*isImplicitlyDeclared=*/false);
6877
6878 // If the class is complete, then we now create the implicit exception
6879 // specification. If the class is incomplete or dependent, we can't do
6880 // it yet.
Richard Smith2bf7fdb2013-01-02 11:42:31 +00006881 if (SemaRef.getLangOpts().CPlusPlus11 && !Record->isDependentType() &&
Kaelyn Uhraine1a9ff72011-10-11 00:28:49 +00006882 Record->getDefinition() && !Record->isBeingDefined() &&
6883 R->getAs<FunctionProtoType>()->getExceptionSpecType() == EST_None) {
6884 SemaRef.AdjustDestructorExceptionSpec(Record, NewDD);
6885 }
6886
6887 IsVirtualOkay = true;
6888 return NewDD;
6889
6890 } else {
6891 SemaRef.Diag(D.getIdentifierLoc(), diag::err_destructor_not_member);
6892 D.setInvalidType();
6893
6894 // Create a FunctionDecl to satisfy the function definition parsing
6895 // code path.
6896 return FunctionDecl::Create(SemaRef.Context, DC,
Daniel Dunbar62ee6412012-03-09 18:35:03 +00006897 D.getLocStart(),
Kaelyn Uhraine1a9ff72011-10-11 00:28:49 +00006898 D.getIdentifierLoc(), Name, R, TInfo,
Rafael Espindola6ae7e502013-04-03 19:27:57 +00006899 SC, isInline,
Kaelyn Uhraine1a9ff72011-10-11 00:28:49 +00006900 /*hasPrototype=*/true, isConstexpr);
6901 }
6902
6903 } else if (Name.getNameKind() == DeclarationName::CXXConversionFunctionName) {
6904 if (!DC->isRecord()) {
6905 SemaRef.Diag(D.getIdentifierLoc(),
6906 diag::err_conv_function_not_member);
Craig Topperc3ec1492014-05-26 06:22:03 +00006907 return nullptr;
Kaelyn Uhraine1a9ff72011-10-11 00:28:49 +00006908 }
6909
6910 SemaRef.CheckConversionDeclarator(D, R, SC);
6911 IsVirtualOkay = true;
6912 return CXXConversionDecl::Create(SemaRef.Context, cast<CXXRecordDecl>(DC),
Daniel Dunbar62ee6412012-03-09 18:35:03 +00006913 D.getLocStart(), NameInfo,
Kaelyn Uhraine1a9ff72011-10-11 00:28:49 +00006914 R, TInfo, isInline, isExplicit,
6915 isConstexpr, SourceLocation());
6916
6917 } else if (DC->isRecord()) {
6918 // If the name of the function is the same as the name of the record,
6919 // then this must be an invalid constructor that has a return type.
6920 // (The parser checks for a return type and makes the declarator a
6921 // constructor if it has no return type).
6922 if (Name.getAsIdentifierInfo() &&
6923 Name.getAsIdentifierInfo() == cast<CXXRecordDecl>(DC)->getIdentifier()){
6924 SemaRef.Diag(D.getIdentifierLoc(), diag::err_constructor_return_type)
6925 << SourceRange(D.getDeclSpec().getTypeSpecTypeLoc())
6926 << SourceRange(D.getIdentifierLoc());
Craig Topperc3ec1492014-05-26 06:22:03 +00006927 return nullptr;
Kaelyn Uhraine1a9ff72011-10-11 00:28:49 +00006928 }
6929
Kaelyn Uhraine1a9ff72011-10-11 00:28:49 +00006930 // This is a C++ method declaration.
Rafael Espindola6ae7e502013-04-03 19:27:57 +00006931 CXXMethodDecl *Ret = CXXMethodDecl::Create(SemaRef.Context,
6932 cast<CXXRecordDecl>(DC),
6933 D.getLocStart(), NameInfo, R,
6934 TInfo, SC, isInline,
6935 isConstexpr, SourceLocation());
6936 IsVirtualOkay = !Ret->isStatic();
6937 return Ret;
Kaelyn Uhraine1a9ff72011-10-11 00:28:49 +00006938 } else {
David Majnemeraa30dd72015-01-09 07:36:13 +00006939 bool isFriend =
6940 SemaRef.getLangOpts().CPlusPlus && D.getDeclSpec().isFriendSpecified();
6941 if (!isFriend && SemaRef.CurContext->isRecord())
6942 return nullptr;
6943
Kaelyn Uhraine1a9ff72011-10-11 00:28:49 +00006944 // Determine whether the function was written with a
6945 // prototype. This true when:
6946 // - we're in C++ (where every function has a prototype),
6947 return FunctionDecl::Create(SemaRef.Context, DC,
Daniel Dunbar62ee6412012-03-09 18:35:03 +00006948 D.getLocStart(),
Rafael Espindola6ae7e502013-04-03 19:27:57 +00006949 NameInfo, R, TInfo, SC, isInline,
Kaelyn Uhraine1a9ff72011-10-11 00:28:49 +00006950 true/*HasPrototype*/, isConstexpr);
6951 }
6952}
6953
Matt Arsenaultefb38192013-07-23 01:23:36 +00006954enum OpenCLParamType {
6955 ValidKernelParam,
6956 PtrPtrKernelParam,
6957 PtrKernelParam,
David Tweedababa8f2014-03-27 16:34:11 +00006958 PrivatePtrKernelParam,
Matt Arsenaultefb38192013-07-23 01:23:36 +00006959 InvalidKernelParam,
6960 RecordKernelParam
6961};
6962
6963static OpenCLParamType getOpenCLKernelParameterType(QualType PT) {
6964 if (PT->isPointerType()) {
6965 QualType PointeeType = PT->getPointeeType();
David Tweedababa8f2014-03-27 16:34:11 +00006966 if (PointeeType->isPointerType())
6967 return PtrPtrKernelParam;
6968 return PointeeType.getAddressSpace() == 0 ? PrivatePtrKernelParam
6969 : PtrKernelParam;
Matt Arsenaultefb38192013-07-23 01:23:36 +00006970 }
6971
6972 // TODO: Forbid the other integer types (size_t, ptrdiff_t...) when they can
6973 // be used as builtin types.
6974
6975 if (PT->isImageType())
6976 return PtrKernelParam;
6977
6978 if (PT->isBooleanType())
6979 return InvalidKernelParam;
6980
6981 if (PT->isEventT())
6982 return InvalidKernelParam;
6983
6984 if (PT->isHalfType())
6985 return InvalidKernelParam;
6986
6987 if (PT->isRecordType())
6988 return RecordKernelParam;
6989
6990 return ValidKernelParam;
6991}
6992
6993static void checkIsValidOpenCLKernelParameter(
6994 Sema &S,
6995 Declarator &D,
6996 ParmVarDecl *Param,
Craig Topper4dd9b432014-08-17 23:49:53 +00006997 llvm::SmallPtrSetImpl<const Type *> &ValidTypes) {
Matt Arsenaultefb38192013-07-23 01:23:36 +00006998 QualType PT = Param->getType();
6999
7000 // Cache the valid types we encounter to avoid rechecking structs that are
7001 // used again
7002 if (ValidTypes.count(PT.getTypePtr()))
7003 return;
7004
7005 switch (getOpenCLKernelParameterType(PT)) {
7006 case PtrPtrKernelParam:
7007 // OpenCL v1.2 s6.9.a:
7008 // A kernel function argument cannot be declared as a
7009 // pointer to a pointer type.
7010 S.Diag(Param->getLocation(), diag::err_opencl_ptrptr_kernel_param);
7011 D.setInvalidType();
7012 return;
7013
David Tweedababa8f2014-03-27 16:34:11 +00007014 case PrivatePtrKernelParam:
7015 // OpenCL v1.2 s6.9.a:
7016 // A kernel function argument cannot be declared as a
7017 // pointer to the private address space.
7018 S.Diag(Param->getLocation(), diag::err_opencl_private_ptr_kernel_param);
7019 D.setInvalidType();
7020 return;
7021
Matt Arsenaultefb38192013-07-23 01:23:36 +00007022 // OpenCL v1.2 s6.9.k:
7023 // Arguments to kernel functions in a program cannot be declared with the
7024 // built-in scalar types bool, half, size_t, ptrdiff_t, intptr_t, and
7025 // uintptr_t or a struct and/or union that contain fields declared to be
7026 // one of these built-in scalar types.
7027
7028 case InvalidKernelParam:
7029 // OpenCL v1.2 s6.8 n:
7030 // A kernel function argument cannot be declared
7031 // of event_t type.
7032 S.Diag(Param->getLocation(), diag::err_bad_kernel_param_type) << PT;
7033 D.setInvalidType();
7034 return;
7035
7036 case PtrKernelParam:
7037 case ValidKernelParam:
7038 ValidTypes.insert(PT.getTypePtr());
7039 return;
7040
7041 case RecordKernelParam:
7042 break;
7043 }
7044
7045 // Track nested structs we will inspect
7046 SmallVector<const Decl *, 4> VisitStack;
7047
7048 // Track where we are in the nested structs. Items will migrate from
7049 // VisitStack to HistoryStack as we do the DFS for bad field.
7050 SmallVector<const FieldDecl *, 4> HistoryStack;
Craig Topperc3ec1492014-05-26 06:22:03 +00007051 HistoryStack.push_back(nullptr);
Matt Arsenaultefb38192013-07-23 01:23:36 +00007052
7053 const RecordDecl *PD = PT->castAs<RecordType>()->getDecl();
7054 VisitStack.push_back(PD);
7055
7056 assert(VisitStack.back() && "First decl null?");
7057
7058 do {
7059 const Decl *Next = VisitStack.pop_back_val();
7060 if (!Next) {
7061 assert(!HistoryStack.empty());
7062 // Found a marker, we have gone up a level
7063 if (const FieldDecl *Hist = HistoryStack.pop_back_val())
7064 ValidTypes.insert(Hist->getType().getTypePtr());
7065
7066 continue;
7067 }
7068
7069 // Adds everything except the original parameter declaration (which is not a
7070 // field itself) to the history stack.
7071 const RecordDecl *RD;
7072 if (const FieldDecl *Field = dyn_cast<FieldDecl>(Next)) {
7073 HistoryStack.push_back(Field);
7074 RD = Field->getType()->castAs<RecordType>()->getDecl();
7075 } else {
7076 RD = cast<RecordDecl>(Next);
7077 }
7078
7079 // Add a null marker so we know when we've gone back up a level
Craig Topperc3ec1492014-05-26 06:22:03 +00007080 VisitStack.push_back(nullptr);
Matt Arsenaultefb38192013-07-23 01:23:36 +00007081
Aaron Ballmane8a8bae2014-03-08 20:12:42 +00007082 for (const auto *FD : RD->fields()) {
Matt Arsenaultefb38192013-07-23 01:23:36 +00007083 QualType QT = FD->getType();
7084
7085 if (ValidTypes.count(QT.getTypePtr()))
7086 continue;
7087
7088 OpenCLParamType ParamType = getOpenCLKernelParameterType(QT);
7089 if (ParamType == ValidKernelParam)
7090 continue;
7091
7092 if (ParamType == RecordKernelParam) {
7093 VisitStack.push_back(FD);
7094 continue;
7095 }
7096
7097 // OpenCL v1.2 s6.9.p:
7098 // Arguments to kernel functions that are declared to be a struct or union
7099 // do not allow OpenCL objects to be passed as elements of the struct or
7100 // union.
David Tweedababa8f2014-03-27 16:34:11 +00007101 if (ParamType == PtrKernelParam || ParamType == PtrPtrKernelParam ||
7102 ParamType == PrivatePtrKernelParam) {
Matt Arsenaultefb38192013-07-23 01:23:36 +00007103 S.Diag(Param->getLocation(),
7104 diag::err_record_with_pointers_kernel_param)
7105 << PT->isUnionType()
7106 << PT;
7107 } else {
7108 S.Diag(Param->getLocation(), diag::err_bad_kernel_param_type) << PT;
7109 }
7110
7111 S.Diag(PD->getLocation(), diag::note_within_field_of_type)
7112 << PD->getDeclName();
7113
7114 // We have an error, now let's go back up through history and show where
7115 // the offending field came from
Nico Weber6b05f382015-02-18 04:53:03 +00007116 for (ArrayRef<const FieldDecl *>::const_iterator
7117 I = HistoryStack.begin() + 1,
7118 E = HistoryStack.end();
7119 I != E; ++I) {
Matt Arsenaultefb38192013-07-23 01:23:36 +00007120 const FieldDecl *OuterField = *I;
7121 S.Diag(OuterField->getLocation(), diag::note_within_field_of_type)
7122 << OuterField->getType();
7123 }
7124
7125 S.Diag(FD->getLocation(), diag::note_illegal_field_declared_here)
7126 << QT->isPointerType()
7127 << QT;
7128 D.setInvalidType();
7129 return;
7130 }
7131 } while (!VisitStack.empty());
7132}
7133
Mike Stump11289f42009-09-09 15:08:12 +00007134NamedDecl*
Nick Lewycky0bdf13e2011-07-02 02:05:12 +00007135Sema::ActOnFunctionDeclarator(Scope *S, Declarator &D, DeclContext *DC,
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00007136 TypeSourceInfo *TInfo, LookupResult &Previous,
Douglas Gregorb52fabb2009-06-23 23:11:28 +00007137 MultiTemplateParamsArg TemplateParamLists,
Francois Pichet00c7e6c2011-08-14 03:52:19 +00007138 bool &AddToScope) {
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00007139 QualType R = TInfo->getType();
7140
Zhongxing Xubece5d62009-01-16 01:13:29 +00007141 assert(R.getTypePtr()->isFunctionType());
7142
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00007143 // TODO: consider using NameInfo for diagnostic.
7144 DeclarationNameInfo NameInfo = GetNameForDeclarator(D);
7145 DeclarationName Name = NameInfo.getName();
Craig Topperc79e5e32014-10-31 06:57:13 +00007146 StorageClass SC = getFunctionStorageClass(*this, D);
Zhongxing Xubece5d62009-01-16 01:13:29 +00007147
Richard Smithb4a9e862013-04-12 22:46:28 +00007148 if (DeclSpec::TSCS TSCS = D.getDeclSpec().getThreadStorageClassSpec())
7149 Diag(D.getDeclSpec().getThreadStorageClassSpecLoc(),
7150 diag::err_invalid_thread)
7151 << DeclSpec::getSpecifierName(TSCS);
Eli Friedmand5c0eed2009-04-19 20:27:55 +00007152
Reid Kleckner9a7f3e62013-10-08 00:58:57 +00007153 if (D.isFirstDeclarationOfMember())
7154 adjustMemberFunctionCC(R, D.isStaticMember());
Reid Kleckner78af0702013-08-27 23:08:25 +00007155
Douglas Gregor513e63c2010-12-10 19:28:19 +00007156 bool isFriend = false;
Craig Topperc3ec1492014-05-26 06:22:03 +00007157 FunctionTemplateDecl *FunctionTemplate = nullptr;
Douglas Gregor513e63c2010-12-10 19:28:19 +00007158 bool isExplicitSpecialization = false;
7159 bool isFunctionTemplateSpecialization = false;
Nico Weber7b5a7162012-06-25 17:21:05 +00007160
Francois Pichet00c7e6c2011-08-14 03:52:19 +00007161 bool isDependentClassScopeExplicitSpecialization = false;
Nico Weber7b5a7162012-06-25 17:21:05 +00007162 bool HasExplicitTemplateArgs = false;
7163 TemplateArgumentListInfo TemplateArgs;
7164
Kaelyn Uhraine1a9ff72011-10-11 00:28:49 +00007165 bool isVirtualOkay = false;
Abramo Bagnara60804e12011-03-18 15:16:37 +00007166
Richard Smith541b38b2013-09-20 01:15:31 +00007167 DeclContext *OriginalDC = DC;
7168 bool IsLocalExternDecl = adjustContextForLocalExternDecl(DC);
7169
Kaelyn Uhraine1a9ff72011-10-11 00:28:49 +00007170 FunctionDecl *NewFD = CreateNewFunctionDecl(*this, D, DC, R, TInfo, SC,
7171 isVirtualOkay);
Craig Topperc3ec1492014-05-26 06:22:03 +00007172 if (!NewFD) return nullptr;
Kaelyn Uhraine1a9ff72011-10-11 00:28:49 +00007173
Argyrios Kyrtzidis8ad3bab2011-11-23 20:27:36 +00007174 if (OriginalLexicalContext && OriginalLexicalContext->isObjCContainer())
7175 NewFD->setTopLevelDeclInObjCContainer();
7176
Richard Smith541b38b2013-09-20 01:15:31 +00007177 // Set the lexical context. If this is a function-scope declaration, or has a
7178 // C++ scope specifier, or is the object of a friend declaration, the lexical
7179 // context will be different from the semantic context.
7180 NewFD->setLexicalDeclContext(CurContext);
7181
7182 if (IsLocalExternDecl)
7183 NewFD->setLocalExternDecl();
7184
David Blaikiebbafb8a2012-03-11 07:00:24 +00007185 if (getLangOpts().CPlusPlus) {
Kaelyn Uhraine1a9ff72011-10-11 00:28:49 +00007186 bool isInline = D.getDeclSpec().isInlineSpecified();
Douglas Gregor513e63c2010-12-10 19:28:19 +00007187 bool isVirtual = D.getDeclSpec().isVirtualSpecified();
7188 bool isExplicit = D.getDeclSpec().isExplicitSpecified();
Richard Smitha77a0a62011-08-15 21:04:07 +00007189 bool isConstexpr = D.getDeclSpec().isConstexprSpecified();
Kaelyn Uhraine1a9ff72011-10-11 00:28:49 +00007190 isFriend = D.getDeclSpec().isFriendSpecified();
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00007191 if (isFriend && !isInline && D.isFunctionDefinition()) {
Abramo Bagnaraa3088e62011-03-18 15:21:59 +00007192 // C++ [class.friend]p5
7193 // A function can be defined in a friend declaration of a
7194 // class . . . . Such a function is implicitly inline.
7195 NewFD->setImplicitlyInline();
7196 }
7197
John McCalldb632ac2012-09-25 07:32:39 +00007198 // If this is a method defined in an __interface, and is not a constructor
7199 // or an overloaded operator, then set the pure flag (isVirtual will already
7200 // return true).
7201 if (const CXXRecordDecl *Parent =
7202 dyn_cast<CXXRecordDecl>(NewFD->getDeclContext())) {
7203 if (Parent->isInterface() && cast<CXXMethodDecl>(NewFD)->isUserProvided())
Joao Matosdc86f942012-08-31 18:45:21 +00007204 NewFD->setPure(true);
Davide Italiano43899d42015-06-27 19:18:55 +00007205
7206 // C++ [class.union]p2
7207 // A union can have member functions, but not virtual functions.
7208 if (isVirtual && Parent->isUnion())
7209 Diag(D.getDeclSpec().getVirtualSpecLoc(), diag::err_virtual_in_union);
Joao Matosdc86f942012-08-31 18:45:21 +00007210 }
7211
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00007212 SetNestedNameSpecifier(NewFD, D);
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00007213 isExplicitSpecialization = false;
7214 isFunctionTemplateSpecialization = false;
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00007215 if (D.isInvalidType())
7216 NewFD->setInvalidDecl();
Richard Smith541b38b2013-09-20 01:15:31 +00007217
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00007218 // Match up the template parameter lists with the scope specifier, then
7219 // determine whether we have a template or a template specialization.
7220 bool Invalid = false;
Robert Wilhelmf2d2e8f2013-07-21 15:20:44 +00007221 if (TemplateParameterList *TemplateParams =
7222 MatchTemplateParametersToScopeSpecifier(
7223 D.getDeclSpec().getLocStart(), D.getIdentifierLoc(),
Richard Smith4b55a9c2014-04-17 03:29:33 +00007224 D.getCXXScopeSpec(),
7225 D.getName().getKind() == UnqualifiedId::IK_TemplateId
7226 ? D.getName().TemplateId
Craig Topperc3ec1492014-05-26 06:22:03 +00007227 : nullptr,
Richard Smith4b55a9c2014-04-17 03:29:33 +00007228 TemplateParamLists, isFriend, isExplicitSpecialization,
7229 Invalid)) {
Abramo Bagnara60804e12011-03-18 15:16:37 +00007230 if (TemplateParams->size() > 0) {
7231 // This is a function template
Abramo Bagnarada41d0c2010-06-12 08:15:14 +00007232
Abramo Bagnara60804e12011-03-18 15:16:37 +00007233 // Check that we can declare a template here.
7234 if (CheckTemplateDeclScope(S, TemplateParams))
David Majnemer8e1a9132015-01-15 07:04:38 +00007235 NewFD->setInvalidDecl();
Mike Stump11289f42009-09-09 15:08:12 +00007236
Abramo Bagnara60804e12011-03-18 15:16:37 +00007237 // A destructor cannot be a template.
7238 if (Name.getNameKind() == DeclarationName::CXXDestructorName) {
7239 Diag(NewFD->getLocation(), diag::err_destructor_template);
David Majnemer8e1a9132015-01-15 07:04:38 +00007240 NewFD->setInvalidDecl();
John McCall1f0479e2010-03-24 08:27:58 +00007241 }
Douglas Gregor041b0842011-10-14 15:31:12 +00007242
7243 // If we're adding a template to a dependent context, we may need to
David Blaikie30d15442011-10-19 22:56:21 +00007244 // rebuilding some of the types used within the template parameter list,
Douglas Gregor041b0842011-10-14 15:31:12 +00007245 // now that we know what the current instantiation is.
7246 if (DC->isDependentContext()) {
7247 ContextRAII SavedContext(*this, DC);
7248 if (RebuildTemplateParamsInCurrentInstantiation(TemplateParams))
7249 Invalid = true;
7250 }
7251
John McCall1f0479e2010-03-24 08:27:58 +00007252
Abramo Bagnara60804e12011-03-18 15:16:37 +00007253 FunctionTemplate = FunctionTemplateDecl::Create(Context, DC,
7254 NewFD->getLocation(),
7255 Name, TemplateParams,
7256 NewFD);
7257 FunctionTemplate->setLexicalDeclContext(CurContext);
7258 NewFD->setDescribedFunctionTemplate(FunctionTemplate);
7259
7260 // For source fidelity, store the other template param lists.
7261 if (TemplateParamLists.size() > 1) {
7262 NewFD->setTemplateParameterListsInfo(Context,
7263 TemplateParamLists.size() - 1,
Benjamin Kramercc4c49d2012-08-23 23:38:35 +00007264 TemplateParamLists.data());
Abramo Bagnara60804e12011-03-18 15:16:37 +00007265 }
7266 } else {
7267 // This is a function template specialization.
7268 isFunctionTemplateSpecialization = true;
7269 // For source fidelity, store all the template param lists.
Richard Smith4b55a9c2014-04-17 03:29:33 +00007270 if (TemplateParamLists.size() > 0)
7271 NewFD->setTemplateParameterListsInfo(Context,
7272 TemplateParamLists.size(),
7273 TemplateParamLists.data());
Abramo Bagnara60804e12011-03-18 15:16:37 +00007274
7275 // C++0x [temp.expl.spec]p20 forbids "template<> friend void foo(int);".
7276 if (isFriend) {
7277 // We want to remove the "template<>", found here.
7278 SourceRange RemoveRange = TemplateParams->getSourceRange();
7279
7280 // If we remove the template<> and the name is not a
7281 // template-id, we're actually silently creating a problem:
7282 // the friend declaration will refer to an untemplated decl,
7283 // and clearly the user wants a template specialization. So
7284 // we need to insert '<>' after the name.
7285 SourceLocation InsertLoc;
7286 if (D.getName().getKind() != UnqualifiedId::IK_TemplateId) {
7287 InsertLoc = D.getName().getSourceRange().getEnd();
Alp Tokerb6cc5922014-05-03 03:45:55 +00007288 InsertLoc = getLocForEndOfToken(InsertLoc);
Abramo Bagnara60804e12011-03-18 15:16:37 +00007289 }
7290
7291 Diag(D.getIdentifierLoc(), diag::err_template_spec_decl_friend)
7292 << Name << RemoveRange
7293 << FixItHint::CreateRemoval(RemoveRange)
7294 << FixItHint::CreateInsertion(InsertLoc, "<>");
7295 }
7296 }
7297 }
7298 else {
7299 // All template param lists were matched against the scope specifier:
7300 // this is NOT (an explicit specialization of) a template.
7301 if (TemplateParamLists.size() > 0)
7302 // For source fidelity, store all the template param lists.
7303 NewFD->setTemplateParameterListsInfo(Context,
7304 TemplateParamLists.size(),
Benjamin Kramercc4c49d2012-08-23 23:38:35 +00007305 TemplateParamLists.data());
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00007306 }
7307
7308 if (Invalid) {
7309 NewFD->setInvalidDecl();
7310 if (FunctionTemplate)
7311 FunctionTemplate->setInvalidDecl();
7312 }
Kaelyn Uhraine1a9ff72011-10-11 00:28:49 +00007313
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00007314 // C++ [dcl.fct.spec]p5:
7315 // The virtual specifier shall only be used in declarations of
7316 // nonstatic class member functions that appear within a
7317 // member-specification of a class declaration; see 10.3.
7318 //
7319 if (isVirtual && !NewFD->isInvalidDecl()) {
7320 if (!isVirtualOkay) {
7321 Diag(D.getDeclSpec().getVirtualSpecLoc(),
7322 diag::err_virtual_non_function);
7323 } else if (!CurContext->isRecord()) {
7324 // 'virtual' was specified outside of the class.
Anders Carlssone9738992011-01-22 14:43:56 +00007325 Diag(D.getDeclSpec().getVirtualSpecLoc(),
7326 diag::err_virtual_out_of_class)
7327 << FixItHint::CreateRemoval(D.getDeclSpec().getVirtualSpecLoc());
7328 } else if (NewFD->getDescribedFunctionTemplate()) {
7329 // C++ [temp.mem]p3:
7330 // A member function template shall not be virtual.
7331 Diag(D.getDeclSpec().getVirtualSpecLoc(),
7332 diag::err_virtual_member_function_template)
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00007333 << FixItHint::CreateRemoval(D.getDeclSpec().getVirtualSpecLoc());
7334 } else {
7335 // Okay: Add virtual to the method.
7336 NewFD->setVirtualAsWritten(true);
John McCall816d75b2010-03-24 07:46:06 +00007337 }
Richard Smith2a7d4812013-05-04 07:00:32 +00007338
Aaron Ballmandd69ef32014-08-19 15:55:55 +00007339 if (getLangOpts().CPlusPlus14 &&
Alp Toker314cc812014-01-25 16:55:45 +00007340 NewFD->getReturnType()->isUndeducedType())
Richard Smith2a7d4812013-05-04 07:00:32 +00007341 Diag(D.getDeclSpec().getVirtualSpecLoc(), diag::err_auto_fn_virtual);
Douglas Gregorc1da0f02009-06-24 00:23:40 +00007342 }
Abramo Bagnarada41d0c2010-06-12 08:15:14 +00007343
Aaron Ballmandd69ef32014-08-19 15:55:55 +00007344 if (getLangOpts().CPlusPlus14 &&
Richard Smithc1564702013-11-15 02:58:23 +00007345 (NewFD->isDependentContext() ||
7346 (isFriend && CurContext->isDependentContext())) &&
Alp Toker314cc812014-01-25 16:55:45 +00007347 NewFD->getReturnType()->isUndeducedType()) {
Richard Smithc58f38f2013-08-14 20:16:31 +00007348 // If the function template is referenced directly (for instance, as a
7349 // member of the current instantiation), pretend it has a dependent type.
7350 // This is not really justified by the standard, but is the only sane
7351 // thing to do.
Richard Smithc1564702013-11-15 02:58:23 +00007352 // FIXME: For a friend function, we have not marked the function as being
7353 // a friend yet, so 'isDependentContext' on the FD doesn't work.
Richard Smithc58f38f2013-08-14 20:16:31 +00007354 const FunctionProtoType *FPT =
7355 NewFD->getType()->castAs<FunctionProtoType>();
Alp Toker314cc812014-01-25 16:55:45 +00007356 QualType Result =
7357 SubstAutoType(FPT->getReturnType(), Context.DependentTy);
Alp Toker9cacbab2014-01-20 20:26:09 +00007358 NewFD->setType(Context.getFunctionType(Result, FPT->getParamTypes(),
Richard Smithc58f38f2013-08-14 20:16:31 +00007359 FPT->getExtProtoInfo()));
7360 }
7361
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00007362 // C++ [dcl.fct.spec]p3:
David Blaikie30d15442011-10-19 22:56:21 +00007363 // The inline specifier shall not appear on a block scope function
7364 // declaration.
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00007365 if (isInline && !NewFD->isInvalidDecl()) {
7366 if (CurContext->isFunctionOrMethod()) {
7367 // 'inline' is not allowed on block scope function declaration.
7368 Diag(D.getDeclSpec().getInlineSpecLoc(),
7369 diag::err_inline_declaration_block_scope) << Name
7370 << FixItHint::CreateRemoval(D.getDeclSpec().getInlineSpecLoc());
7371 }
7372 }
Kaelyn Uhraine1a9ff72011-10-11 00:28:49 +00007373
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00007374 // C++ [dcl.fct.spec]p6:
7375 // The explicit specifier shall be used only in the declaration of a
David Blaikie30d15442011-10-19 22:56:21 +00007376 // constructor or conversion function within its class definition;
7377 // see 12.3.1 and 12.3.2.
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00007378 if (isExplicit && !NewFD->isInvalidDecl()) {
7379 if (!CurContext->isRecord()) {
7380 // 'explicit' was specified outside of the class.
7381 Diag(D.getDeclSpec().getExplicitSpecLoc(),
7382 diag::err_explicit_out_of_class)
7383 << FixItHint::CreateRemoval(D.getDeclSpec().getExplicitSpecLoc());
7384 } else if (!isa<CXXConstructorDecl>(NewFD) &&
7385 !isa<CXXConversionDecl>(NewFD)) {
7386 // 'explicit' was specified on a function that wasn't a constructor
7387 // or conversion function.
7388 Diag(D.getDeclSpec().getExplicitSpecLoc(),
7389 diag::err_explicit_non_ctor_or_conv_function)
7390 << FixItHint::CreateRemoval(D.getDeclSpec().getExplicitSpecLoc());
7391 }
7392 }
Abramo Bagnarada41d0c2010-06-12 08:15:14 +00007393
Richard Smitha77a0a62011-08-15 21:04:07 +00007394 if (isConstexpr) {
Richard Smith574f4f62013-01-14 05:37:29 +00007395 // C++11 [dcl.constexpr]p2: constexpr functions and constexpr constructors
Richard Smitha77a0a62011-08-15 21:04:07 +00007396 // are implicitly inline.
7397 NewFD->setImplicitlyInline();
7398
Richard Smith574f4f62013-01-14 05:37:29 +00007399 // C++11 [dcl.constexpr]p3: functions declared constexpr are required to
Richard Smitha77a0a62011-08-15 21:04:07 +00007400 // be either constructors or to return a literal type. Therefore,
7401 // destructors cannot be declared constexpr.
7402 if (isa<CXXDestructorDecl>(NewFD))
Richard Smitheb3c10c2011-10-01 02:31:28 +00007403 Diag(D.getDeclSpec().getConstexprSpecLoc(), diag::err_constexpr_dtor);
Richard Smitha77a0a62011-08-15 21:04:07 +00007404 }
7405
Douglas Gregor26701a42011-09-09 02:06:17 +00007406 // If __module_private__ was specified, mark the function accordingly.
7407 if (D.getDeclSpec().isModulePrivateSpecified()) {
Douglas Gregor3c7cd6a2011-09-09 20:53:38 +00007408 if (isFunctionTemplateSpecialization) {
7409 SourceLocation ModulePrivateLoc
7410 = D.getDeclSpec().getModulePrivateSpecLoc();
7411 Diag(ModulePrivateLoc, diag::err_module_private_specialization)
7412 << 0
7413 << FixItHint::CreateRemoval(ModulePrivateLoc);
7414 } else {
7415 NewFD->setModulePrivate();
7416 if (FunctionTemplate)
7417 FunctionTemplate->setModulePrivate();
7418 }
Douglas Gregor26701a42011-09-09 02:06:17 +00007419 }
Richard Smitha77a0a62011-08-15 21:04:07 +00007420
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00007421 if (isFriend) {
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00007422 if (FunctionTemplate) {
Richard Smith64017682013-07-17 23:53:16 +00007423 FunctionTemplate->setObjectOfFriendDecl();
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00007424 FunctionTemplate->setAccess(AS_public);
7425 }
Richard Smith64017682013-07-17 23:53:16 +00007426 NewFD->setObjectOfFriendDecl();
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00007427 NewFD->setAccess(AS_public);
7428 }
7429
Douglas Gregor5d1b4e32011-11-07 20:56:01 +00007430 // If a function is defined as defaulted or deleted, mark it as such now.
Richard Smithb63b6ee2014-01-22 01:43:19 +00007431 // FIXME: Does this ever happen? ActOnStartOfFunctionDef forces the function
7432 // definition kind to FDK_Definition.
Douglas Gregor5d1b4e32011-11-07 20:56:01 +00007433 switch (D.getFunctionDefinitionKind()) {
7434 case FDK_Declaration:
7435 case FDK_Definition:
7436 break;
7437
7438 case FDK_Defaulted:
7439 NewFD->setDefaulted();
7440 break;
7441
7442 case FDK_Deleted:
7443 NewFD->setDeletedAsWritten();
7444 break;
7445 }
7446
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00007447 if (isa<CXXMethodDecl>(NewFD) && DC == CurContext &&
7448 D.isFunctionDefinition()) {
Douglas Gregor5d1b4e32011-11-07 20:56:01 +00007449 // C++ [class.mfct]p2:
7450 // A member function may be defined (8.4) in its class definition, in
7451 // which case it is an inline member function (7.1.2)
John McCall357d0f32010-12-15 04:00:32 +00007452 NewFD->setImplicitlyInline();
7453 }
7454
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00007455 if (SC == SC_Static && isa<CXXMethodDecl>(NewFD) &&
7456 !CurContext->isRecord()) {
7457 // C++ [class.static]p1:
7458 // A data or function member of a class may be declared static
7459 // in a class definition, in which case it is a static member of
7460 // the class.
7461
7462 // Complain about the 'static' specifier if it's on an out-of-line
7463 // member function definition.
7464 Diag(D.getDeclSpec().getStorageClassSpecLoc(),
7465 diag::err_static_out_of_line)
7466 << FixItHint::CreateRemoval(D.getDeclSpec().getStorageClassSpecLoc());
7467 }
Richard Smith66f3ac92012-10-20 08:26:51 +00007468
7469 // C++11 [except.spec]p15:
7470 // A deallocation function with no exception-specification is treated
7471 // as if it were specified with noexcept(true).
7472 const FunctionProtoType *FPT = R->getAs<FunctionProtoType>();
7473 if ((Name.getCXXOverloadedOperator() == OO_Delete ||
7474 Name.getCXXOverloadedOperator() == OO_Array_Delete) &&
Richard Smith8acb4282014-07-31 21:57:55 +00007475 getLangOpts().CPlusPlus11 && FPT && !FPT->hasExceptionSpec())
7476 NewFD->setType(Context.getFunctionType(
7477 FPT->getReturnType(), FPT->getParamTypes(),
7478 FPT->getExtProtoInfo().withExceptionSpec(EST_BasicNoexcept)));
Douglas Gregor5f0e2522010-07-14 23:14:12 +00007479 }
Kaelyn Uhraine1a9ff72011-10-11 00:28:49 +00007480
7481 // Filter out previous declarations that don't match the scope.
Richard Smith541b38b2013-09-20 01:15:31 +00007482 FilterLookupForScope(Previous, OriginalDC, S, shouldConsiderLinkage(NewFD),
Richard Smith72bcaec2013-12-05 04:30:04 +00007483 D.getCXXScopeSpec().isNotEmpty() ||
Kaelyn Uhraine1a9ff72011-10-11 00:28:49 +00007484 isExplicitSpecialization ||
7485 isFunctionTemplateSpecialization);
Richard Smith1c34fb72013-08-13 18:18:50 +00007486
Zhongxing Xubece5d62009-01-16 01:13:29 +00007487 // Handle GNU asm-label extension (encoded as an attribute).
7488 if (Expr *E = (Expr*) D.getAsmLabel()) {
7489 // The parser guarantees this is a string.
Mike Stump11289f42009-09-09 15:08:12 +00007490 StringLiteral *SE = cast<StringLiteral>(E);
Alexis Huntdcfba7b2010-08-18 23:23:40 +00007491 NewFD->addAttr(::new (Context) AsmLabelAttr(SE->getStrTokenLoc(0), Context,
Aaron Ballman36a53502014-01-16 13:03:14 +00007492 SE->getString(), 0));
Aaron Ballman9ec96a22015-06-25 15:37:16 +00007493 } else if (!ExtnameUndeclaredIdentifiers.empty() &&
7494 isDeclTUScopedExternallyVisible(NewFD)) {
David Chisnall0867d9c2012-02-18 16:12:34 +00007495 llvm::DenseMap<IdentifierInfo*,AsmLabelAttr*>::iterator I =
7496 ExtnameUndeclaredIdentifiers.find(NewFD->getIdentifier());
7497 if (I != ExtnameUndeclaredIdentifiers.end()) {
7498 NewFD->addAttr(I->second);
7499 ExtnameUndeclaredIdentifiers.erase(I);
7500 }
Zhongxing Xubece5d62009-01-16 01:13:29 +00007501 }
7502
Chris Lattner9af40c12009-04-25 06:12:16 +00007503 // Copy the parameter declarations from the declarator D to the function
7504 // declaration NewFD, if they are available. First scavenge them into Params.
Chris Lattner0e62c1c2011-07-23 10:55:15 +00007505 SmallVector<ParmVarDecl*, 16> Params;
Abramo Bagnara6d810632010-12-14 22:11:44 +00007506 if (D.isFunctionDeclarator()) {
Abramo Bagnara924a8f32010-12-10 16:29:40 +00007507 DeclaratorChunk::FunctionTypeInfo &FTI = D.getFunctionTypeInfo();
Zhongxing Xubece5d62009-01-16 01:13:29 +00007508
Zhongxing Xubece5d62009-01-16 01:13:29 +00007509 // Check for C99 6.7.5.3p10 - foo(void) is a non-varargs
7510 // function that takes no arguments, not a function that takes a
7511 // single void argument.
7512 // We let through "const void" here because Sema::GetTypeForDeclarator
7513 // already checks for that case.
Alp Toker4284c6e2014-05-11 16:05:55 +00007514 if (FTIHasNonVoidParameters(FTI) && FTI.Params[0].Param) {
Alp Tokerc5350722014-02-26 22:27:52 +00007515 for (unsigned i = 0, e = FTI.NumParams; i != e; ++i) {
7516 ParmVarDecl *Param = cast<ParmVarDecl>(FTI.Params[i].Param);
Argyrios Kyrtzidis11a846a2009-07-14 03:18:53 +00007517 assert(Param->getDeclContext() != NewFD && "Was set before ?");
7518 Param->setDeclContext(NewFD);
7519 Params.push_back(Param);
John McCallb7238602010-04-14 01:27:20 +00007520
7521 if (Param->isInvalidDecl())
7522 NewFD->setInvalidDecl();
Argyrios Kyrtzidis11a846a2009-07-14 03:18:53 +00007523 }
Zhongxing Xubece5d62009-01-16 01:13:29 +00007524 }
Mike Stump11289f42009-09-09 15:08:12 +00007525
John McCall9dd450b2009-09-21 23:43:11 +00007526 } else if (const FunctionProtoType *FT = R->getAs<FunctionProtoType>()) {
Chris Lattner47c0d002009-04-25 06:03:53 +00007527 // When we're declaring a function with a typedef, typeof, etc as in the
Zhongxing Xubece5d62009-01-16 01:13:29 +00007528 // following example, we'll need to synthesize (unnamed)
7529 // parameters for use in the declaration.
7530 //
7531 // @code
7532 // typedef void fn(int);
7533 // fn f;
7534 // @endcode
Mike Stump11289f42009-09-09 15:08:12 +00007535
Chris Lattner47c0d002009-04-25 06:03:53 +00007536 // Synthesize a parameter for each argument type.
Aaron Ballman40bd0aa2014-03-17 15:23:01 +00007537 for (const auto &AI : FT->param_types()) {
John McCalla3ccba02010-06-04 11:21:44 +00007538 ParmVarDecl *Param =
Aaron Ballman40bd0aa2014-03-17 15:23:01 +00007539 BuildParmVarDeclForTypedef(NewFD, D.getIdentifierLoc(), AI);
John McCall8fb0d9d2011-05-01 22:35:37 +00007540 Param->setScopeInfo(0, Params.size());
Chris Lattner47c0d002009-04-25 06:03:53 +00007541 Params.push_back(Param);
Zhongxing Xubece5d62009-01-16 01:13:29 +00007542 }
Chris Lattner49303b22009-04-25 18:38:18 +00007543 } else {
7544 assert(R->isFunctionNoProtoType() && NewFD->getNumParams() == 0 &&
7545 "Should not need args for typedef of non-prototype fn");
Zhongxing Xubece5d62009-01-16 01:13:29 +00007546 }
Anton Korobeynikovf0c267e2011-10-14 23:23:15 +00007547
Chris Lattner9af40c12009-04-25 06:12:16 +00007548 // Finally, we know we have the right number of parameters, install them.
David Blaikie9c70e042011-09-21 18:16:56 +00007549 NewFD->setParams(Params);
Mike Stump11289f42009-09-09 15:08:12 +00007550
James Molloy6f8780b2012-02-29 10:24:19 +00007551 // Find all anonymous symbols defined during the declaration of this function
7552 // and add to NewFD. This lets us track decls such 'enum Y' in:
7553 //
7554 // void f(enum Y {AA} x) {}
7555 //
7556 // which would otherwise incorrectly end up in the translation unit scope.
7557 NewFD->setDeclsInPrototypeScope(DeclsInPrototypeScope);
7558 DeclsInPrototypeScope.clear();
7559
Richard Smithdebc59d2013-01-30 05:45:05 +00007560 if (D.getDeclSpec().isNoreturnSpecified())
7561 NewFD->addAttr(
7562 ::new(Context) C11NoReturnAttr(D.getDeclSpec().getNoreturnSpecLoc(),
Aaron Ballman36a53502014-01-16 13:03:14 +00007563 Context, 0));
Richard Smithdebc59d2013-01-30 05:45:05 +00007564
Richard Smith84208dc2012-03-13 05:56:40 +00007565 // Functions returning a variably modified type violate C99 6.7.5.2p2
7566 // because all functions have linkage.
7567 if (!NewFD->isInvalidDecl() &&
Alp Toker314cc812014-01-25 16:55:45 +00007568 NewFD->getReturnType()->isVariablyModifiedType()) {
Richard Smith84208dc2012-03-13 05:56:40 +00007569 Diag(NewFD->getLocation(), diag::err_vm_func_decl);
7570 NewFD->setInvalidDecl();
7571 }
7572
Reid Kleckner2a133222015-03-04 23:39:17 +00007573 // Apply an implicit SectionAttr if #pragma code_seg is active.
7574 if (CodeSegStack.CurrentValue && D.isFunctionDefinition() &&
Warren Huntc3b18962014-04-08 22:30:47 +00007575 !NewFD->hasAttr<SectionAttr>()) {
7576 NewFD->addAttr(
7577 SectionAttr::CreateImplicit(Context, SectionAttr::Declspec_allocate,
7578 CodeSegStack.CurrentValue->getString(),
7579 CodeSegStack.CurrentPragmaLocation));
7580 if (UnifySection(CodeSegStack.CurrentValue->getString(),
Hans Wennborg899ded92014-10-16 20:52:46 +00007581 ASTContext::PSF_Implicit | ASTContext::PSF_Execute |
7582 ASTContext::PSF_Read,
7583 NewFD))
Warren Huntc3b18962014-04-08 22:30:47 +00007584 NewFD->dropAttr<SectionAttr>();
7585 }
7586
Rafael Espindolac67f2232012-05-10 02:50:16 +00007587 // Handle attributes.
Richard Smithf8a75c32013-08-29 00:47:48 +00007588 ProcessDeclAttributes(S, NewFD, D);
Rafael Espindolac67f2232012-05-10 02:50:16 +00007589
Joey Gouly16cb99d2014-01-06 11:26:18 +00007590 if (getLangOpts().OpenCL) {
7591 // OpenCL v1.1 s6.5: Using an address space qualifier in a function return
7592 // type declaration will generate a compilation error.
Kaelyn Takata0a2e84c2015-04-09 19:43:04 +00007593 unsigned AddressSpace = NewFD->getReturnType().getAddressSpace();
Joey Gouly16cb99d2014-01-06 11:26:18 +00007594 if (AddressSpace == LangAS::opencl_local ||
7595 AddressSpace == LangAS::opencl_global ||
7596 AddressSpace == LangAS::opencl_constant) {
7597 Diag(NewFD->getLocation(),
7598 diag::err_opencl_return_value_with_address_space);
7599 NewFD->setInvalidDecl();
7600 }
7601 }
7602
David Blaikiebbafb8a2012-03-11 07:00:24 +00007603 if (!getLangOpts().CPlusPlus) {
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00007604 // Perform semantic checking on the function declaration.
Douglas Gregor522d5eb2011-06-06 15:22:55 +00007605 bool isExplicitSpecialization=false;
David Majnemer027f9c42013-07-06 02:13:46 +00007606 if (!NewFD->isInvalidDecl() && NewFD->isMain())
7607 CheckMain(NewFD, D.getDeclSpec());
7608
David Majnemerc729b0b2013-09-16 22:44:20 +00007609 if (!NewFD->isInvalidDecl() && NewFD->isMSVCRTEntryPoint())
7610 CheckMSVCRTEntryPoint(NewFD);
7611
Reid Kleckner899baf32014-11-03 21:56:03 +00007612 if (!NewFD->isInvalidDecl())
7613 D.setRedeclaration(CheckFunctionDeclaration(S, NewFD, Previous,
7614 isExplicitSpecialization));
7615 else if (!Previous.empty())
Nico Weber4486d612015-02-18 05:19:40 +00007616 // Recover gracefully from an invalid redeclaration.
Reid Kleckner899baf32014-11-03 21:56:03 +00007617 D.setRedeclaration(true);
7618 assert((NewFD->isInvalidDecl() || !D.isRedeclaration() ||
7619 Previous.getResultKind() != LookupResult::FoundOverloaded) &&
7620 "previous declaration set still overloaded");
7621
Reid Kleckner1eaa8442014-11-03 21:24:50 +00007622 // Diagnose no-prototype function declarations with calling conventions that
Reid Kleckner899baf32014-11-03 21:56:03 +00007623 // don't support variadic calls. Only do this in C and do it after merging
7624 // possibly prototyped redeclarations.
7625 const FunctionType *FT = NewFD->getType()->castAs<FunctionType>();
7626 if (isa<FunctionNoProtoType>(FT) && !D.isFunctionDefinition()) {
Reid Kleckner1eaa8442014-11-03 21:24:50 +00007627 CallingConv CC = FT->getExtInfo().getCC();
7628 if (!supportsVariadicCall(CC)) {
7629 // Windows system headers sometimes accidentally use stdcall without
7630 // (void) parameters, so we relax this to a warning.
7631 int DiagID =
7632 CC == CC_X86StdCall ? diag::warn_cconv_knr : diag::err_cconv_knr;
7633 Diag(NewFD->getLocation(), DiagID)
7634 << FunctionType::getNameForCallConv(CC);
7635 }
7636 }
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00007637 } else {
Richard Smithfa27bc42013-11-16 01:57:09 +00007638 // C++11 [replacement.functions]p3:
7639 // The program's definitions shall not be specified as inline.
7640 //
7641 // N.B. We diagnose declarations instead of definitions per LWG issue 2340.
7642 //
7643 // Suppress the diagnostic if the function is __attribute__((used)), since
7644 // that forces an external definition to be emitted.
7645 if (D.getDeclSpec().isInlineSpecified() &&
7646 NewFD->isReplaceableGlobalAllocationFunction() &&
7647 !NewFD->hasAttr<UsedAttr>())
7648 Diag(D.getDeclSpec().getInlineSpecLoc(),
7649 diag::ext_operator_new_delete_declared_inline)
7650 << NewFD->getDeclName();
7651
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00007652 // If the declarator is a template-id, translate the parser's template
7653 // argument list into our AST format.
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00007654 if (D.getName().getKind() == UnqualifiedId::IK_TemplateId) {
7655 TemplateIdAnnotation *TemplateId = D.getName().TemplateId;
7656 TemplateArgs.setLAngleLoc(TemplateId->LAngleLoc);
7657 TemplateArgs.setRAngleLoc(TemplateId->RAngleLoc);
Benjamin Kramercc4c49d2012-08-23 23:38:35 +00007658 ASTTemplateArgsPtr TemplateArgsPtr(TemplateId->getTemplateArgs(),
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00007659 TemplateId->NumArgs);
7660 translateTemplateArguments(TemplateArgsPtr,
7661 TemplateArgs);
Douglas Gregor0e876e02009-09-25 23:53:26 +00007662
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00007663 HasExplicitTemplateArgs = true;
Douglas Gregor0e876e02009-09-25 23:53:26 +00007664
Douglas Gregor522d5eb2011-06-06 15:22:55 +00007665 if (NewFD->isInvalidDecl()) {
7666 HasExplicitTemplateArgs = false;
7667 } else if (FunctionTemplate) {
Douglas Gregora5f6f9c2011-01-24 18:54:39 +00007668 // Function template with explicit template arguments.
7669 Diag(D.getIdentifierLoc(), diag::err_function_template_partial_spec)
7670 << SourceRange(TemplateId->LAngleLoc, TemplateId->RAngleLoc);
7671
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00007672 HasExplicitTemplateArgs = false;
John McCallf7cfb222010-10-13 05:45:15 +00007673 } else {
Richard Smith4b55a9c2014-04-17 03:29:33 +00007674 assert((isFunctionTemplateSpecialization ||
7675 D.getDeclSpec().isFriendSpecified()) &&
7676 "should have a 'template<>' for this decl");
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00007677 // "friend void foo<>(int);" is an implicit specialization decl.
7678 isFunctionTemplateSpecialization = true;
Francois Pichet6d76e6c2010-10-01 21:19:28 +00007679 }
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00007680 } else if (isFriend && isFunctionTemplateSpecialization) {
7681 // This combination is only possible in a recovery case; the user
7682 // wrote something like:
7683 // template <> friend void foo(int);
7684 // which we're recovering from as if the user had written:
7685 // friend void foo<>(int);
7686 // Go ahead and fake up a template id.
7687 HasExplicitTemplateArgs = true;
Richard Smith4b55a9c2014-04-17 03:29:33 +00007688 TemplateArgs.setLAngleLoc(D.getIdentifierLoc());
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00007689 TemplateArgs.setRAngleLoc(D.getIdentifierLoc());
Douglas Gregorf4f296d2009-03-23 23:06:20 +00007690 }
John McCallf7cfb222010-10-13 05:45:15 +00007691
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00007692 // If it's a friend (and only if it's a friend), it's possible
7693 // that either the specialized function type or the specialized
7694 // template is dependent, and therefore matching will fail. In
7695 // this case, don't check the specialization yet.
Douglas Gregore9d075e2011-10-09 20:59:17 +00007696 bool InstantiationDependent = false;
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00007697 if (isFunctionTemplateSpecialization && isFriend &&
Douglas Gregore9d075e2011-10-09 20:59:17 +00007698 (NewFD->getType()->isDependentType() || DC->isDependentContext() ||
7699 TemplateSpecializationType::anyDependentTemplateArguments(
7700 TemplateArgs.getArgumentArray(), TemplateArgs.size(),
7701 InstantiationDependent))) {
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00007702 assert(HasExplicitTemplateArgs &&
7703 "friend function specialization without template args");
7704 if (CheckDependentFunctionTemplateSpecialization(NewFD, TemplateArgs,
7705 Previous))
7706 NewFD->setInvalidDecl();
7707 } else if (isFunctionTemplateSpecialization) {
Douglas Gregor63fab342011-03-16 19:27:09 +00007708 if (CurContext->isDependentContext() && CurContext->isRecord()
Francois Pichetb5037052011-06-03 13:59:45 +00007709 && !isFriend) {
David Majnemeraa30dd72015-01-09 07:36:13 +00007710 isDependentClassScopeExplicitSpecialization = true;
David Blaikiebbafb8a2012-03-11 07:00:24 +00007711 Diag(NewFD->getLocation(), getLangOpts().MicrosoftExt ?
Francois Pichet00c7e6c2011-08-14 03:52:19 +00007712 diag::ext_function_specialization_in_class :
7713 diag::err_function_specialization_in_class)
Douglas Gregor63fab342011-03-16 19:27:09 +00007714 << NewFD->getDeclName();
Douglas Gregor63fab342011-03-16 19:27:09 +00007715 } else if (CheckFunctionTemplateSpecialization(NewFD,
Craig Topperc3ec1492014-05-26 06:22:03 +00007716 (HasExplicitTemplateArgs ? &TemplateArgs
7717 : nullptr),
Douglas Gregor63fab342011-03-16 19:27:09 +00007718 Previous))
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00007719 NewFD->setInvalidDecl();
Douglas Gregor781ba6e2011-05-21 18:53:30 +00007720
7721 // C++ [dcl.stc]p1:
7722 // A storage-class-specifier shall not be specified in an explicit
7723 // specialization (14.7.3)
Richard Trieub48e62f2013-05-16 02:14:08 +00007724 FunctionTemplateSpecializationInfo *Info =
7725 NewFD->getTemplateSpecializationInfo();
7726 if (Info && SC != SC_None) {
7727 if (SC != Info->getTemplate()->getTemplatedDecl()->getStorageClass())
Douglas Gregor84265a02011-06-17 05:09:08 +00007728 Diag(NewFD->getLocation(),
7729 diag::err_explicit_specialization_inconsistent_storage_class)
7730 << SC
7731 << FixItHint::CreateRemoval(
7732 D.getDeclSpec().getStorageClassSpecLoc());
7733
7734 else
7735 Diag(NewFD->getLocation(),
7736 diag::ext_explicit_specialization_storage_class)
7737 << FixItHint::CreateRemoval(
7738 D.getDeclSpec().getStorageClassSpecLoc());
Douglas Gregor781ba6e2011-05-21 18:53:30 +00007739 }
7740
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00007741 } else if (isExplicitSpecialization && isa<CXXMethodDecl>(NewFD)) {
7742 if (CheckMemberSpecialization(NewFD, Previous))
7743 NewFD->setInvalidDecl();
7744 }
Douglas Gregorf4f296d2009-03-23 23:06:20 +00007745
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00007746 // Perform semantic checking on the function declaration.
David Blaikied937bf12011-09-08 06:33:04 +00007747 if (!isDependentClassScopeExplicitSpecialization) {
David Majnemer027f9c42013-07-06 02:13:46 +00007748 if (!NewFD->isInvalidDecl() && NewFD->isMain())
7749 CheckMain(NewFD, D.getDeclSpec());
7750
David Majnemerc729b0b2013-09-16 22:44:20 +00007751 if (!NewFD->isInvalidDecl() && NewFD->isMSVCRTEntryPoint())
7752 CheckMSVCRTEntryPoint(NewFD);
7753
Nico Weber7607fce2013-12-21 00:49:51 +00007754 if (!NewFD->isInvalidDecl())
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00007755 D.setRedeclaration(CheckFunctionDeclaration(S, NewFD, Previous,
7756 isExplicitSpecialization));
Nico Weber4486d612015-02-18 05:19:40 +00007757 else if (!Previous.empty())
7758 // Recover gracefully from an invalid redeclaration.
7759 D.setRedeclaration(true);
David Blaikied937bf12011-09-08 06:33:04 +00007760 }
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00007761
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00007762 assert((NewFD->isInvalidDecl() || !D.isRedeclaration() ||
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00007763 Previous.getResultKind() != LookupResult::FoundOverloaded) &&
7764 "previous declaration set still overloaded");
7765
7766 NamedDecl *PrincipalDecl = (FunctionTemplate
7767 ? cast<NamedDecl>(FunctionTemplate)
7768 : NewFD);
7769
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00007770 if (isFriend && D.isRedeclaration()) {
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00007771 AccessSpecifier Access = AS_public;
7772 if (!NewFD->isInvalidDecl())
Douglas Gregorec9fd132012-01-14 16:38:05 +00007773 Access = NewFD->getPreviousDecl()->getAccess();
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00007774
7775 NewFD->setAccess(Access);
7776 if (FunctionTemplate) FunctionTemplate->setAccess(Access);
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00007777 }
7778
7779 if (NewFD->isOverloadedOperator() && !DC->isRecord() &&
7780 PrincipalDecl->isInIdentifierNamespace(Decl::IDNS_Ordinary))
7781 PrincipalDecl->setNonMemberOperator();
7782
7783 // If we have a function template, check the template parameter
7784 // list. This will check and merge default template arguments.
7785 if (FunctionTemplate) {
David Blaikie30d15442011-10-19 22:56:21 +00007786 FunctionTemplateDecl *PrevTemplate =
Douglas Gregorec9fd132012-01-14 16:38:05 +00007787 FunctionTemplate->getPreviousDecl();
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00007788 CheckTemplateParameterList(FunctionTemplate->getTemplateParameters(),
Craig Topperc3ec1492014-05-26 06:22:03 +00007789 PrevTemplate ? PrevTemplate->getTemplateParameters()
7790 : nullptr,
Douglas Gregora99fb4c2011-02-04 04:20:44 +00007791 D.getDeclSpec().isFriendSpecified()
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00007792 ? (D.isFunctionDefinition()
Douglas Gregora99fb4c2011-02-04 04:20:44 +00007793 ? TPC_FriendFunctionTemplateDefinition
7794 : TPC_FriendFunctionTemplate)
7795 : (D.getCXXScopeSpec().isSet() &&
Douglas Gregor4d5c2972011-02-04 12:22:53 +00007796 DC && DC->isRecord() &&
7797 DC->isDependentContext())
Douglas Gregora99fb4c2011-02-04 04:20:44 +00007798 ? TPC_ClassTemplateMember
7799 : TPC_FunctionTemplate);
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00007800 }
7801
7802 if (NewFD->isInvalidDecl()) {
7803 // Ignore all the rest of this.
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00007804 } else if (!D.isRedeclaration()) {
Kaelyn Uhrain8af2c9f2011-10-11 00:28:52 +00007805 struct ActOnFDArgs ExtraArgs = { S, D, TemplateParamLists,
Kaelyn Uhrain0a32fca2011-10-11 00:28:39 +00007806 AddToScope };
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00007807 // Fake up an access specifier if it's supposed to be a class member.
7808 if (isa<CXXRecordDecl>(NewFD->getDeclContext()))
7809 NewFD->setAccess(AS_public);
7810
7811 // Qualified decls generally require a previous declaration.
7812 if (D.getCXXScopeSpec().isSet()) {
7813 // ...with the major exception of templated-scope or
7814 // dependent-scope friend declarations.
7815
7816 // TODO: we currently also suppress this check in dependent
7817 // contexts because (1) the parameter depth will be off when
7818 // matching friend templates and (2) we might actually be
7819 // selecting a friend based on a dependent factor. But there
7820 // are situations where these conditions don't apply and we
7821 // can actually do this check immediately.
7822 if (isFriend &&
Abramo Bagnara60804e12011-03-18 15:16:37 +00007823 (TemplateParamLists.size() ||
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00007824 D.getCXXScopeSpec().getScopeRep()->isDependent() ||
7825 CurContext->isDependentContext())) {
Chandler Carruthf8b554f2011-08-19 01:38:33 +00007826 // ignore these
7827 } else {
7828 // The user tried to provide an out-of-line definition for a
7829 // function that is a member of a class or namespace, but there
7830 // was no such member function declared (C++ [class.mfct]p2,
7831 // C++ [namespace.memdef]p2). For example:
7832 //
7833 // class X {
7834 // void f() const;
7835 // };
7836 //
7837 // void X::f() { } // ill-formed
7838 //
7839 // Complain about this problem, and attempt to suggest close
7840 // matches (e.g., those that differ only in cv-qualifiers and
7841 // whether the parameter types are references).
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00007842
Richard Smith114394f2013-08-09 04:35:01 +00007843 if (NamedDecl *Result = DiagnoseInvalidRedeclaration(
Craig Topperc3ec1492014-05-26 06:22:03 +00007844 *this, Previous, NewFD, ExtraArgs, false, nullptr)) {
Kaelyn Uhrain0a32fca2011-10-11 00:28:39 +00007845 AddToScope = ExtraArgs.AddToScope;
7846 return Result;
7847 }
Chandler Carruthf8b554f2011-08-19 01:38:33 +00007848 }
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00007849
7850 // Unqualified local friend declarations are required to resolve
7851 // to something.
Chandler Carruthe92e42f2011-08-19 01:40:11 +00007852 } else if (isFriend && cast<CXXRecordDecl>(CurContext)->isLocalClass()) {
Richard Smith114394f2013-08-09 04:35:01 +00007853 if (NamedDecl *Result = DiagnoseInvalidRedeclaration(
7854 *this, Previous, NewFD, ExtraArgs, true, S)) {
Kaelyn Uhrain0a32fca2011-10-11 00:28:39 +00007855 AddToScope = ExtraArgs.AddToScope;
7856 return Result;
7857 }
Chandler Carruthe92e42f2011-08-19 01:40:11 +00007858 }
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00007859
Richard Smitha2302242013-12-05 07:51:02 +00007860 } else if (!D.isFunctionDefinition() &&
7861 isa<CXXMethodDecl>(NewFD) && NewFD->isOutOfLine() &&
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00007862 !isFriend && !isFunctionTemplateSpecialization &&
Alexis Hunt5a7fa252011-05-12 06:15:49 +00007863 !isExplicitSpecialization) {
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00007864 // An out-of-line member function declaration must also be a
Richard Smitha2302242013-12-05 07:51:02 +00007865 // definition (C++ [class.mfct]p2).
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00007866 // Note that this is not the case for explicit specializations of
7867 // function templates or member functions of class templates, per
David Blaikie30d15442011-10-19 22:56:21 +00007868 // C++ [temp.expl.spec]p2. We also allow these declarations as an
7869 // extension for compatibility with old SWIG code which likes to
7870 // generate them.
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00007871 Diag(NewFD->getLocation(), diag::ext_out_of_line_declaration)
7872 << D.getCXXScopeSpec().getRange();
7873 }
7874 }
Ryan Flynne5dc8592009-07-25 22:29:44 +00007875
Rafael Espindolade6a39f2013-03-02 21:41:48 +00007876 ProcessPragmaWeak(S, NewFD);
Rafael Espindolaf1d2f0e2013-01-16 23:11:15 +00007877 checkAttributesAfterMerging(*this, *NewFD);
7878
Douglas Gregorf4f296d2009-03-23 23:06:20 +00007879 AddKnownFunctionAttributes(NewFD);
7880
Douglas Gregor72609052010-08-06 13:50:58 +00007881 if (NewFD->hasAttr<OverloadableAttr>() &&
7882 !NewFD->getType()->getAs<FunctionProtoType>()) {
7883 Diag(NewFD->getLocation(),
7884 diag::err_attribute_overloadable_no_prototype)
7885 << NewFD;
7886
7887 // Turn this into a variadic function with no parameters.
7888 const FunctionType *FT = NewFD->getType()->getAs<FunctionType>();
Reid Kleckner78af0702013-08-27 23:08:25 +00007889 FunctionProtoType::ExtProtoInfo EPI(
7890 Context.getDefaultCallingConvention(true, false));
John McCalldb40c7f2010-12-14 08:05:40 +00007891 EPI.Variadic = true;
7892 EPI.ExtInfo = FT->getExtInfo();
7893
Alp Toker314cc812014-01-25 16:55:45 +00007894 QualType R = Context.getFunctionType(FT->getReturnType(), None, EPI);
Douglas Gregor72609052010-08-06 13:50:58 +00007895 NewFD->setType(R);
7896 }
7897
Eli Friedman570024a2010-08-05 06:57:20 +00007898 // If there's a #pragma GCC visibility in scope, and this isn't a class
7899 // member, set the visibility of this function.
Rafael Espindola3ae00052013-05-13 00:12:11 +00007900 if (!DC->isRecord() && NewFD->isExternallyVisible())
Eli Friedman570024a2010-08-05 06:57:20 +00007901 AddPushedVisibilityAttribute(NewFD);
7902
John McCall32f5fe12011-09-30 05:12:12 +00007903 // If there's a #pragma clang arc_cf_code_audited in scope, consider
7904 // marking the function.
7905 AddCFAuditedAttribute(NewFD);
7906
Dario Domizioli13a0a382014-05-23 12:13:25 +00007907 // If this is a function definition, check if we have to apply optnone due to
7908 // a pragma.
7909 if(D.isFunctionDefinition())
7910 AddRangeBasedOptnone(NewFD);
7911
Richard Smithac974a32013-06-30 09:48:50 +00007912 // If this is the first declaration of an extern C variable, update
7913 // the map of such variables.
Rafael Espindola3f9e4442013-10-19 02:13:21 +00007914 if (NewFD->isFirstDecl() && !NewFD->isInvalidDecl() &&
Richard Smithac974a32013-06-30 09:48:50 +00007915 isIncompleteDeclExternC(*this, NewFD))
Richard Smith39b79682013-06-18 20:15:12 +00007916 RegisterLocallyScopedExternCDecl(NewFD, S);
Douglas Gregorf4f296d2009-03-23 23:06:20 +00007917
Argyrios Kyrtzidis16eecc42009-06-25 18:22:24 +00007918 // Set this FunctionDecl's range up to the right paren.
Abramo Bagnaraea947882011-03-08 16:41:52 +00007919 NewFD->setRangeEnd(D.getSourceRange().getEnd());
Argyrios Kyrtzidis16eecc42009-06-25 18:22:24 +00007920
Nico Rieck82f0b062014-03-31 14:56:15 +00007921 if (D.isRedeclaration() && !Previous.empty()) {
7922 checkDLLAttributeRedeclaration(
7923 *this, dyn_cast<NamedDecl>(Previous.getRepresentativeDecl()), NewFD,
7924 isExplicitSpecialization || isFunctionTemplateSpecialization);
7925 }
7926
David Blaikiebbafb8a2012-03-11 07:00:24 +00007927 if (getLangOpts().CPlusPlus) {
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00007928 if (FunctionTemplate) {
7929 if (NewFD->isInvalidDecl())
7930 FunctionTemplate->setInvalidDecl();
7931 return FunctionTemplate;
7932 }
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00007933 }
Mike Stump11289f42009-09-09 15:08:12 +00007934
Guy Benyei1b4fb3e2013-01-20 12:31:11 +00007935 if (NewFD->hasAttr<OpenCLKernelAttr>()) {
Guy Benyei1b4fb3e2013-01-20 12:31:11 +00007936 // OpenCL v1.2 s6.8 static is invalid for kernel functions.
7937 if ((getLangOpts().OpenCLVersion >= 120)
7938 && (SC == SC_Static)) {
7939 Diag(D.getIdentifierLoc(), diag::err_static_kernel);
7940 D.setInvalidType();
7941 }
Tanya Lattner0f864332013-01-30 19:48:52 +00007942
7943 // OpenCL v1.2, s6.9 -- Kernels can only have return type void.
Alp Toker314cc812014-01-25 16:55:45 +00007944 if (!NewFD->getReturnType()->isVoidType()) {
Alp Tokerd0787eb2014-07-02 01:47:15 +00007945 SourceRange RTRange = NewFD->getReturnTypeSourceRange();
7946 Diag(D.getIdentifierLoc(), diag::err_expected_kernel_void_return_type)
7947 << (RTRange.isValid() ? FixItHint::CreateReplacement(RTRange, "void")
7948 : FixItHint());
Tanya Lattner0f864332013-01-30 19:48:52 +00007949 D.setInvalidType();
7950 }
Matt Arsenaultefb38192013-07-23 01:23:36 +00007951
7952 llvm::SmallPtrSet<const Type *, 16> ValidTypes;
Aaron Ballmanf6bf62e2014-03-07 15:12:56 +00007953 for (auto Param : NewFD->params())
Matt Arsenaultefb38192013-07-23 01:23:36 +00007954 checkIsValidOpenCLKernelParameter(*this, D, Param, ValidTypes);
Tanya Lattner4fdce3f2012-06-19 23:09:52 +00007955 }
7956
Argyrios Kyrtzidis1b30d9c2010-08-15 01:15:20 +00007957 MarkUnusedFileScopedDecl(NewFD);
Peter Collingbourne9e2c81f2011-02-09 21:04:32 +00007958
David Blaikiebbafb8a2012-03-11 07:00:24 +00007959 if (getLangOpts().CUDA)
Peter Collingbourne9e2c81f2011-02-09 21:04:32 +00007960 if (IdentifierInfo *II = NewFD->getIdentifier())
7961 if (!NewFD->isInvalidDecl() &&
7962 NewFD->getDeclContext()->getRedeclContext()->isTranslationUnit()) {
7963 if (II->isStr("cudaConfigureCall")) {
Alp Toker314cc812014-01-25 16:55:45 +00007964 if (!R->getAs<FunctionType>()->getReturnType()->isScalarType())
Peter Collingbourne9e2c81f2011-02-09 21:04:32 +00007965 Diag(NewFD->getLocation(), diag::err_config_scalar_return);
7966
7967 Context.setcudaConfigureCallDecl(NewFD);
7968 }
7969 }
Francois Pichet00c7e6c2011-08-14 03:52:19 +00007970
7971 // Here we have an function template explicit specialization at class scope.
7972 // The actually specialization will be postponed to template instatiation
7973 // time via the ClassScopeFunctionSpecializationDecl node.
7974 if (isDependentClassScopeExplicitSpecialization) {
7975 ClassScopeFunctionSpecializationDecl *NewSpec =
7976 ClassScopeFunctionSpecializationDecl::Create(
Nico Weber7b5a7162012-06-25 17:21:05 +00007977 Context, CurContext, SourceLocation(),
7978 cast<CXXMethodDecl>(NewFD),
7979 HasExplicitTemplateArgs, TemplateArgs);
Francois Pichet00c7e6c2011-08-14 03:52:19 +00007980 CurContext->addDecl(NewSpec);
7981 AddToScope = false;
7982 }
Peter Collingbourne9e2c81f2011-02-09 21:04:32 +00007983
Douglas Gregorf4f296d2009-03-23 23:06:20 +00007984 return NewFD;
7985}
7986
7987/// \brief Perform semantic checking of a new function declaration.
7988///
7989/// Performs semantic analysis of the new function declaration
7990/// NewFD. This routine performs all semantic checking that does not
7991/// require the actual declarator involved in the declaration, and is
7992/// used both for the declaration of functions as they are parsed
7993/// (called via ActOnDeclarator) and for the declaration of functions
7994/// that have been instantiated via C++ template instantiation (called
7995/// via InstantiateDecl).
7996///
James Dennettffad8b72012-06-22 08:10:18 +00007997/// \param IsExplicitSpecialization whether this new function declaration is
Douglas Gregorcf915552009-10-13 16:30:37 +00007998/// an explicit specialization of the previous declaration.
7999///
Chris Lattnerf6d1c9c2009-04-25 08:06:05 +00008000/// This sets NewFD->isInvalidDecl() to true if there was an error.
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00008001///
James Dennettffad8b72012-06-22 08:10:18 +00008002/// \returns true if the function declaration is a redeclaration.
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00008003bool Sema::CheckFunctionDeclaration(Scope *S, FunctionDecl *NewFD,
John McCall1f82f242009-11-18 22:49:29 +00008004 LookupResult &Previous,
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00008005 bool IsExplicitSpecialization) {
Alp Toker314cc812014-01-25 16:55:45 +00008006 assert(!NewFD->getReturnType()->isVariablyModifiedType() &&
8007 "Variably modified return types are not handled here");
John McCalld9baf6a2009-07-24 03:03:21 +00008008
Richard Smith1c34fb72013-08-13 18:18:50 +00008009 // Determine whether the type of this function should be merged with
8010 // a previous visible declaration. This never happens for functions in C++,
8011 // and always happens in C if the previous declaration was visible.
8012 bool MergeTypeWithPrevious = !getLangOpts().CPlusPlus &&
8013 !Previous.isShadowed();
8014
Douglas Gregor3552dab2013-01-09 00:47:56 +00008015 // Filter out any non-conflicting previous declarations.
Richard Smith42413142015-05-15 20:05:43 +00008016 filterNonConflictingPreviousDecls(*this, NewFD, Previous);
Douglas Gregor3552dab2013-01-09 00:47:56 +00008017
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00008018 bool Redeclaration = false;
Craig Topperc3ec1492014-05-26 06:22:03 +00008019 NamedDecl *OldDecl = nullptr;
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00008020
Douglas Gregore62c0a42009-02-24 01:23:02 +00008021 // Merge or overload the declaration with an existing declaration of
8022 // the same name, if appropriate.
John McCall1f82f242009-11-18 22:49:29 +00008023 if (!Previous.empty()) {
Douglas Gregor4e5cbdc2009-02-11 23:02:49 +00008024 // Determine whether NewFD is an overload of PrevDecl or
Zhongxing Xubece5d62009-01-16 01:13:29 +00008025 // a declaration that requires merging. If it's an overload,
8026 // there's no more work to do here; we'll just add the new
8027 // function to the scope.
John McCalldaa3d6b2009-12-09 03:35:25 +00008028 if (!AllowOverloadingOfFunction(Previous, Context)) {
Rafael Espindola5bddd6a2013-04-15 12:49:13 +00008029 NamedDecl *Candidate = Previous.getFoundDecl();
8030 if (shouldLinkPossiblyHiddenDecl(Candidate, NewFD)) {
8031 Redeclaration = true;
8032 OldDecl = Candidate;
8033 }
John McCalldaa3d6b2009-12-09 03:35:25 +00008034 } else {
John McCalle9cccd82010-06-16 08:42:20 +00008035 switch (CheckOverload(S, NewFD, Previous, OldDecl,
8036 /*NewIsUsingDecl*/ false)) {
John McCalldaa3d6b2009-12-09 03:35:25 +00008037 case Ovl_Match:
John McCall84d87672009-12-10 09:41:52 +00008038 Redeclaration = true;
John McCalldaa3d6b2009-12-09 03:35:25 +00008039 break;
8040
8041 case Ovl_NonFunction:
8042 Redeclaration = true;
8043 break;
8044
8045 case Ovl_Overload:
8046 Redeclaration = false;
8047 break;
John McCall1f82f242009-11-18 22:49:29 +00008048 }
Peter Collingbourne9f2a9902011-01-21 02:08:54 +00008049
David Blaikiebbafb8a2012-03-11 07:00:24 +00008050 if (!getLangOpts().CPlusPlus && !NewFD->hasAttr<OverloadableAttr>()) {
Peter Collingbourne9f2a9902011-01-21 02:08:54 +00008051 // If a function name is overloadable in C, then every function
8052 // with that name must be marked "overloadable".
8053 Diag(NewFD->getLocation(), diag::err_attribute_overloadable_missing)
8054 << Redeclaration << NewFD;
Craig Topperc3ec1492014-05-26 06:22:03 +00008055 NamedDecl *OverloadedDecl = nullptr;
Peter Collingbourne9f2a9902011-01-21 02:08:54 +00008056 if (Redeclaration)
8057 OverloadedDecl = OldDecl;
8058 else if (!Previous.empty())
8059 OverloadedDecl = Previous.getRepresentativeDecl();
8060 if (OverloadedDecl)
8061 Diag(OverloadedDecl->getLocation(),
8062 diag::note_attribute_overloadable_prev_overload);
Aaron Ballman36a53502014-01-16 13:03:14 +00008063 NewFD->addAttr(OverloadableAttr::CreateImplicit(Context));
Peter Collingbourne9f2a9902011-01-21 02:08:54 +00008064 }
John McCall1f82f242009-11-18 22:49:29 +00008065 }
Richard Smith574f4f62013-01-14 05:37:29 +00008066 }
Zhongxing Xubece5d62009-01-16 01:13:29 +00008067
Richard Smithac974a32013-06-30 09:48:50 +00008068 // Check for a previous extern "C" declaration with this name.
8069 if (!Redeclaration &&
8070 checkForConflictWithNonVisibleExternC(*this, NewFD, Previous)) {
Richard Smith42413142015-05-15 20:05:43 +00008071 filterNonConflictingPreviousDecls(*this, NewFD, Previous);
Richard Smithac974a32013-06-30 09:48:50 +00008072 if (!Previous.empty()) {
8073 // This is an extern "C" declaration with the same name as a previous
8074 // declaration, and thus redeclares that entity...
8075 Redeclaration = true;
8076 OldDecl = Previous.getFoundDecl();
Richard Smith1c34fb72013-08-13 18:18:50 +00008077 MergeTypeWithPrevious = false;
Richard Smithac974a32013-06-30 09:48:50 +00008078
8079 // ... except in the presence of __attribute__((overloadable)).
8080 if (OldDecl->hasAttr<OverloadableAttr>()) {
8081 if (!getLangOpts().CPlusPlus && !NewFD->hasAttr<OverloadableAttr>()) {
8082 Diag(NewFD->getLocation(), diag::err_attribute_overloadable_missing)
8083 << Redeclaration << NewFD;
8084 Diag(Previous.getFoundDecl()->getLocation(),
8085 diag::note_attribute_overloadable_prev_overload);
Aaron Ballman36a53502014-01-16 13:03:14 +00008086 NewFD->addAttr(OverloadableAttr::CreateImplicit(Context));
Richard Smithac974a32013-06-30 09:48:50 +00008087 }
8088 if (IsOverload(NewFD, cast<FunctionDecl>(OldDecl), false)) {
8089 Redeclaration = false;
Craig Topperc3ec1492014-05-26 06:22:03 +00008090 OldDecl = nullptr;
Richard Smithac974a32013-06-30 09:48:50 +00008091 }
8092 }
8093 }
8094 }
8095
Richard Smith574f4f62013-01-14 05:37:29 +00008096 // C++11 [dcl.constexpr]p8:
8097 // A constexpr specifier for a non-static member function that is not
8098 // a constructor declares that member function to be const.
8099 //
8100 // This needs to be delayed until we know whether this is an out-of-line
8101 // definition of a static member function.
Richard Smith034185c2013-04-21 01:08:50 +00008102 //
8103 // This rule is not present in C++1y, so we produce a backwards
8104 // compatibility warning whenever it happens in C++11.
Richard Smith574f4f62013-01-14 05:37:29 +00008105 CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(NewFD);
Aaron Ballmandd69ef32014-08-19 15:55:55 +00008106 if (!getLangOpts().CPlusPlus14 && MD && MD->isConstexpr() &&
Richard Smith034185c2013-04-21 01:08:50 +00008107 !MD->isStatic() && !isa<CXXConstructorDecl>(MD) &&
Richard Smith574f4f62013-01-14 05:37:29 +00008108 (MD->getTypeQualifiers() & Qualifiers::Const) == 0) {
Craig Topperc3ec1492014-05-26 06:22:03 +00008109 CXXMethodDecl *OldMD = nullptr;
Alp Tokera2794f92014-01-22 07:29:52 +00008110 if (OldDecl)
David Majnemer0fe3f4d2015-01-09 10:33:23 +00008111 OldMD = dyn_cast_or_null<CXXMethodDecl>(OldDecl->getAsFunction());
Richard Smith574f4f62013-01-14 05:37:29 +00008112 if (!OldMD || !OldMD->isStatic()) {
8113 const FunctionProtoType *FPT =
8114 MD->getType()->castAs<FunctionProtoType>();
8115 FunctionProtoType::ExtProtoInfo EPI = FPT->getExtProtoInfo();
8116 EPI.TypeQuals |= Qualifiers::Const;
Alp Toker314cc812014-01-25 16:55:45 +00008117 MD->setType(Context.getFunctionType(FPT->getReturnType(),
Alp Toker9cacbab2014-01-20 20:26:09 +00008118 FPT->getParamTypes(), EPI));
Richard Smith034185c2013-04-21 01:08:50 +00008119
8120 // Warn that we did this, if we're not performing template instantiation.
8121 // In that case, we'll have warned already when the template was defined.
8122 if (ActiveTemplateInstantiations.empty()) {
8123 SourceLocation AddConstLoc;
8124 if (FunctionTypeLoc FTL = MD->getTypeSourceInfo()->getTypeLoc()
8125 .IgnoreParens().getAs<FunctionTypeLoc>())
Alp Tokerb6cc5922014-05-03 03:45:55 +00008126 AddConstLoc = getLocForEndOfToken(FTL.getRParenLoc());
Richard Smith034185c2013-04-21 01:08:50 +00008127
Aaron Ballmandd69ef32014-08-19 15:55:55 +00008128 Diag(MD->getLocation(), diag::warn_cxx14_compat_constexpr_not_const)
Richard Smith034185c2013-04-21 01:08:50 +00008129 << FixItHint::CreateInsertion(AddConstLoc, " const");
8130 }
Richard Smith574f4f62013-01-14 05:37:29 +00008131 }
8132 }
8133
8134 if (Redeclaration) {
8135 // NewFD and OldDecl represent declarations that need to be
8136 // merged.
Richard Smith1c34fb72013-08-13 18:18:50 +00008137 if (MergeFunctionDecl(NewFD, OldDecl, S, MergeTypeWithPrevious)) {
Richard Smith574f4f62013-01-14 05:37:29 +00008138 NewFD->setInvalidDecl();
8139 return Redeclaration;
8140 }
8141
8142 Previous.clear();
8143 Previous.addDecl(OldDecl);
8144
8145 if (FunctionTemplateDecl *OldTemplateDecl
8146 = dyn_cast<FunctionTemplateDecl>(OldDecl)) {
8147 NewFD->setPreviousDeclaration(OldTemplateDecl->getTemplatedDecl());
8148 FunctionTemplateDecl *NewTemplateDecl
8149 = NewFD->getDescribedFunctionTemplate();
8150 assert(NewTemplateDecl && "Template/non-template mismatch");
8151 if (CXXMethodDecl *Method
8152 = dyn_cast<CXXMethodDecl>(NewTemplateDecl->getTemplatedDecl())) {
8153 Method->setAccess(OldTemplateDecl->getAccess());
8154 NewTemplateDecl->setAccess(OldTemplateDecl->getAccess());
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00008155 }
Richard Smith574f4f62013-01-14 05:37:29 +00008156
8157 // If this is an explicit specialization of a member that is a function
8158 // template, mark it as a member specialization.
8159 if (IsExplicitSpecialization &&
8160 NewTemplateDecl->getInstantiatedFromMemberTemplate()) {
8161 NewTemplateDecl->setMemberSpecialization();
8162 assert(OldTemplateDecl->isMemberSpecialization());
Argyrios Kyrtzidis11a846a2009-07-14 03:18:53 +00008163 }
Richard Smith574f4f62013-01-14 05:37:29 +00008164
8165 } else {
John McCall6bd2a892013-01-25 22:31:03 +00008166 // This needs to happen first so that 'inline' propagates.
Richard Smith574f4f62013-01-14 05:37:29 +00008167 NewFD->setPreviousDeclaration(cast<FunctionDecl>(OldDecl));
John McCall6bd2a892013-01-25 22:31:03 +00008168
Richard Smith91c18de2015-02-28 01:01:56 +00008169 if (isa<CXXMethodDecl>(NewFD))
8170 NewFD->setAccess(OldDecl->getAccess());
Zhongxing Xubece5d62009-01-16 01:13:29 +00008171 }
Douglas Gregor8af63e42009-02-06 17:46:57 +00008172 }
Zhongxing Xubece5d62009-01-16 01:13:29 +00008173
Anders Carlsson1b12ed42009-09-13 21:33:06 +00008174 // Semantic checking for this function declaration (in isolation).
Nico Weberbe39a872014-07-31 17:19:18 +00008175
David Blaikiebbafb8a2012-03-11 07:00:24 +00008176 if (getLangOpts().CPlusPlus) {
Anders Carlsson1b12ed42009-09-13 21:33:06 +00008177 // C++-specific checks.
8178 if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(NewFD)) {
8179 CheckConstructor(Constructor);
Anders Carlsson2a50e952009-11-15 22:49:34 +00008180 } else if (CXXDestructorDecl *Destructor =
8181 dyn_cast<CXXDestructorDecl>(NewFD)) {
8182 CXXRecordDecl *Record = Destructor->getParent();
Anders Carlsson1b12ed42009-09-13 21:33:06 +00008183 QualType ClassType = Context.getTypeDeclType(Record);
Anders Carlsson2a50e952009-11-15 22:49:34 +00008184
Douglas Gregor7454c562010-07-02 20:37:36 +00008185 // FIXME: Shouldn't we be able to perform this check even when the class
Anders Carlsson2a50e952009-11-15 22:49:34 +00008186 // type is dependent? Both gcc and edg can handle that.
Anders Carlsson1b12ed42009-09-13 21:33:06 +00008187 if (!ClassType->isDependentType()) {
8188 DeclarationName Name
8189 = Context.DeclarationNames.getCXXDestructorName(
8190 Context.getCanonicalType(ClassType));
8191 if (NewFD->getDeclName() != Name) {
8192 Diag(NewFD->getLocation(), diag::err_destructor_name);
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00008193 NewFD->setInvalidDecl();
8194 return Redeclaration;
Anders Carlsson1b12ed42009-09-13 21:33:06 +00008195 }
8196 }
Anders Carlsson1b12ed42009-09-13 21:33:06 +00008197 } else if (CXXConversionDecl *Conversion
Douglas Gregor21920e372009-12-01 17:24:26 +00008198 = dyn_cast<CXXConversionDecl>(NewFD)) {
Anders Carlsson1b12ed42009-09-13 21:33:06 +00008199 ActOnConversionDeclarator(Conversion);
Douglas Gregor21920e372009-12-01 17:24:26 +00008200 }
8201
8202 // Find any virtual functions that this function overrides.
Douglas Gregor6be3de32009-12-01 17:35:23 +00008203 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(NewFD)) {
8204 if (!Method->isFunctionTemplateSpecialization() &&
Argyrios Kyrtzidiscc4ca0a2012-10-09 01:23:45 +00008205 !Method->getDescribedFunctionTemplate() &&
8206 Method->isCanonicalDecl()) {
Douglas Gregor5a2bb5b2010-10-13 22:55:32 +00008207 if (AddOverriddenMethods(Method->getParent(), Method)) {
8208 // If the function was marked as "static", we have a problem.
8209 if (NewFD->getStorageClass() == SC_Static) {
David Blaikie7e414262012-10-17 00:47:58 +00008210 ReportOverrides(*this, diag::err_static_overrides_virtual, Method);
Douglas Gregor5a2bb5b2010-10-13 22:55:32 +00008211 }
Argyrios Kyrtzidis7272d9c2011-02-03 18:01:15 +00008212 }
Douglas Gregor5a2bb5b2010-10-13 22:55:32 +00008213 }
Douglas Gregor3024f072012-04-16 07:05:22 +00008214
8215 if (Method->isStatic())
8216 checkThisInStaticMemberFunctionType(Method);
Douglas Gregor6be3de32009-12-01 17:35:23 +00008217 }
Anders Carlsson1b12ed42009-09-13 21:33:06 +00008218
8219 // Extra checking for C++ overloaded operators (C++ [over.oper]).
8220 if (NewFD->isOverloadedOperator() &&
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00008221 CheckOverloadedOperatorDeclaration(NewFD)) {
8222 NewFD->setInvalidDecl();
8223 return Redeclaration;
8224 }
Alexis Huntc88db062010-01-13 09:01:02 +00008225
8226 // Extra checking for C++0x literal operators (C++0x [over.literal]).
8227 if (NewFD->getLiteralIdentifier() &&
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00008228 CheckLiteralOperatorDeclaration(NewFD)) {
8229 NewFD->setInvalidDecl();
8230 return Redeclaration;
8231 }
Alexis Huntc88db062010-01-13 09:01:02 +00008232
Anders Carlsson1b12ed42009-09-13 21:33:06 +00008233 // In C++, check default arguments now that we have merged decls. Unless
8234 // the lexical context is the class, because in this case this is done
8235 // during delayed parsing anyway.
8236 if (!CurContext->isRecord())
8237 CheckCXXDefaultArguments(NewFD);
Warren Hunt445d83e2013-11-01 23:46:51 +00008238
Douglas Gregor9246b682010-12-21 19:47:46 +00008239 // If this function declares a builtin function, check the type of this
8240 // declaration against the expected type for the builtin.
8241 if (unsigned BuiltinID = NewFD->getBuiltinID()) {
8242 ASTContext::GetBuiltinTypeError Error;
Fariborz Jahanianfeb9ae52013-01-05 21:54:55 +00008243 LookupPredefedObjCSuperType(*this, S, NewFD->getIdentifier());
Douglas Gregor9246b682010-12-21 19:47:46 +00008244 QualType T = Context.GetBuiltinType(BuiltinID, Error);
8245 if (!T.isNull() && !Context.hasSameType(T, NewFD->getType())) {
8246 // The type of this function differs from the type of the builtin,
8247 // so forget about the builtin entirely.
8248 Context.BuiltinInfo.ForgetBuiltin(BuiltinID, Context.Idents);
8249 }
8250 }
Warren Hunt445d83e2013-11-01 23:46:51 +00008251
Aaron Ballmanc2a9493a2012-02-09 01:21:34 +00008252 // If this function is declared as being extern "C", then check to see if
8253 // the function returns a UDT (class, struct, or union type) that is not C
8254 // compatible, and if it does, warn the user.
Fariborz Jahanian95236b52013-03-14 23:09:00 +00008255 // But, issue any diagnostic on the first declaration only.
David Majnemerd1091e52015-01-14 08:08:52 +00008256 if (Previous.empty() && NewFD->isExternC()) {
Alp Toker314cc812014-01-25 16:55:45 +00008257 QualType R = NewFD->getReturnType();
Hans Wennborg84ce6062012-07-24 17:59:41 +00008258 if (R->isIncompleteType() && !R->isVoidType())
8259 Diag(NewFD->getLocation(), diag::warn_return_value_udt_incomplete)
8260 << NewFD << R;
Douglas Gregor847cea72012-08-07 06:14:34 +00008261 else if (!R.isPODType(Context) && !R->isVoidType() &&
8262 !R->isObjCObjectPointerType())
Hans Wennborg84ce6062012-07-24 17:59:41 +00008263 Diag(NewFD->getLocation(), diag::warn_return_value_udt) << NewFD << R;
Aaron Ballmanc2a9493a2012-02-09 01:21:34 +00008264 }
Anders Carlsson1b12ed42009-09-13 21:33:06 +00008265 }
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00008266 return Redeclaration;
Zhongxing Xubece5d62009-01-16 01:13:29 +00008267}
8268
David Blaikied937bf12011-09-08 06:33:04 +00008269void Sema::CheckMain(FunctionDecl* FD, const DeclSpec& DS) {
Richard Smithb63b6ee2014-01-22 01:43:19 +00008270 // C++11 [basic.start.main]p3:
8271 // A program that [...] declares main to be inline, static or
8272 // constexpr is ill-formed.
Richard Smith0015f092013-01-17 22:16:11 +00008273 // C11 6.7.4p4: In a hosted environment, no function specifier(s) shall
8274 // appear in a declaration of main.
John McCall02dee0a2009-07-25 04:36:53 +00008275 // static main is not an error under C99, but we should warn about it.
Richard Smith0015f092013-01-17 22:16:11 +00008276 // We accept _Noreturn main as an extension.
David Blaikied937bf12011-09-08 06:33:04 +00008277 if (FD->getStorageClass() == SC_Static)
David Blaikiebbafb8a2012-03-11 07:00:24 +00008278 Diag(DS.getStorageClassSpecLoc(), getLangOpts().CPlusPlus
David Blaikied937bf12011-09-08 06:33:04 +00008279 ? diag::err_static_main : diag::warn_static_main)
8280 << FixItHint::CreateRemoval(DS.getStorageClassSpecLoc());
8281 if (FD->isInlineSpecified())
8282 Diag(DS.getInlineSpecLoc(), diag::err_inline_main)
8283 << FixItHint::CreateRemoval(DS.getInlineSpecLoc());
Dmitri Gribenko7ec6f3d2013-01-21 11:25:03 +00008284 if (DS.isNoreturnSpecified()) {
8285 SourceLocation NoreturnLoc = DS.getNoreturnSpecLoc();
Alp Tokerb6cc5922014-05-03 03:45:55 +00008286 SourceRange NoreturnRange(NoreturnLoc, getLocForEndOfToken(NoreturnLoc));
Dmitri Gribenko7ec6f3d2013-01-21 11:25:03 +00008287 Diag(NoreturnLoc, diag::ext_noreturn_main);
8288 Diag(NoreturnLoc, diag::note_main_remove_noreturn)
8289 << FixItHint::CreateRemoval(NoreturnRange);
8290 }
Richard Smith3f333f22012-02-04 06:10:17 +00008291 if (FD->isConstexpr()) {
8292 Diag(DS.getConstexprSpecLoc(), diag::err_constexpr_main)
8293 << FixItHint::CreateRemoval(DS.getConstexprSpecLoc());
8294 FD->setConstexpr(false);
8295 }
John McCall02dee0a2009-07-25 04:36:53 +00008296
Joey Goulya7310a82013-11-05 12:30:39 +00008297 if (getLangOpts().OpenCL) {
8298 Diag(FD->getLocation(), diag::err_opencl_no_main)
8299 << FD->hasAttr<OpenCLKernelAttr>();
8300 FD->setInvalidDecl();
8301 return;
8302 }
8303
John McCall02dee0a2009-07-25 04:36:53 +00008304 QualType T = FD->getType();
8305 assert(T->isFunctionType() && "function decl is not of function type");
John McCall5ed3caf2012-02-14 19:50:52 +00008306 const FunctionType* FT = T->castAs<FunctionType>();
Mike Stump11289f42009-09-09 15:08:12 +00008307
Alp Toker70fc29c2014-07-02 07:07:20 +00008308 if (getLangOpts().GNUMode && !getLangOpts().CPlusPlus) {
8309 // In C with GNU extensions we allow main() to have non-integer return
8310 // type, but we should warn about the extension, and we disable the
8311 // implicit-return-zero rule.
8312
8313 // GCC in C mode accepts qualified 'int'.
8314 if (Context.hasSameUnqualifiedType(FT->getReturnType(), Context.IntTy))
8315 FD->setHasImplicitReturnZero(true);
8316 else {
8317 Diag(FD->getTypeSpecStartLoc(), diag::ext_main_returns_nonint);
8318 SourceRange RTRange = FD->getReturnTypeSourceRange();
8319 if (RTRange.isValid())
8320 Diag(RTRange.getBegin(), diag::note_main_change_return_type)
8321 << FixItHint::CreateReplacement(RTRange, "int");
8322 }
8323 } else {
John McCall5ed3caf2012-02-14 19:50:52 +00008324 // In C and C++, main magically returns 0 if you fall off the end;
8325 // set the flag which tells us that.
8326 // This is C++ [basic.start.main]p5 and C99 5.1.2.2.3.
John McCall5ed3caf2012-02-14 19:50:52 +00008327
Alp Toker70fc29c2014-07-02 07:07:20 +00008328 // All the standards say that main() should return 'int'.
8329 if (Context.hasSameType(FT->getReturnType(), Context.IntTy))
8330 FD->setHasImplicitReturnZero(true);
8331 else {
8332 // Otherwise, this is just a flat-out error.
8333 SourceRange RTRange = FD->getReturnTypeSourceRange();
8334 Diag(FD->getTypeSpecStartLoc(), diag::err_main_returns_nonint)
8335 << (RTRange.isValid() ? FixItHint::CreateReplacement(RTRange, "int")
8336 : FixItHint());
8337 FD->setInvalidDecl(true);
8338 }
John McCall02dee0a2009-07-25 04:36:53 +00008339 }
8340
8341 // Treat protoless main() as nullary.
8342 if (isa<FunctionNoProtoType>(FT)) return;
8343
8344 const FunctionProtoType* FTP = cast<const FunctionProtoType>(FT);
Alp Toker9cacbab2014-01-20 20:26:09 +00008345 unsigned nparams = FTP->getNumParams();
John McCall02dee0a2009-07-25 04:36:53 +00008346 assert(FD->getNumParams() == nparams);
8347
John McCall0e21fcc2009-12-24 09:58:38 +00008348 bool HasExtraParameters = (nparams > 3);
8349
Aaron Ballman1710cc92015-04-23 16:12:42 +00008350 if (FTP->isVariadic()) {
8351 Diag(FD->getLocation(), diag::ext_variadic_main);
8352 // FIXME: if we had information about the location of the ellipsis, we
8353 // could add a FixIt hint to remove it as a parameter.
8354 }
8355
John McCall0e21fcc2009-12-24 09:58:38 +00008356 // Darwin passes an undocumented fourth argument of type char**. If
8357 // other platforms start sprouting these, the logic below will start
8358 // getting shifty.
Douglas Gregore8bbc122011-09-02 00:18:52 +00008359 if (nparams == 4 && Context.getTargetInfo().getTriple().isOSDarwin())
John McCall0e21fcc2009-12-24 09:58:38 +00008360 HasExtraParameters = false;
8361
8362 if (HasExtraParameters) {
John McCall02dee0a2009-07-25 04:36:53 +00008363 Diag(FD->getLocation(), diag::err_main_surplus_args) << nparams;
8364 FD->setInvalidDecl(true);
8365 nparams = 3;
8366 }
8367
8368 // FIXME: a lot of the following diagnostics would be improved
8369 // if we had some location information about types.
8370
8371 QualType CharPP =
8372 Context.getPointerType(Context.getPointerType(Context.CharTy));
John McCall0e21fcc2009-12-24 09:58:38 +00008373 QualType Expected[] = { Context.IntTy, CharPP, CharPP, CharPP };
John McCall02dee0a2009-07-25 04:36:53 +00008374
8375 for (unsigned i = 0; i < nparams; ++i) {
Alp Toker9cacbab2014-01-20 20:26:09 +00008376 QualType AT = FTP->getParamType(i);
John McCall02dee0a2009-07-25 04:36:53 +00008377
8378 bool mismatch = true;
8379
8380 if (Context.hasSameUnqualifiedType(AT, Expected[i]))
8381 mismatch = false;
8382 else if (Expected[i] == CharPP) {
8383 // As an extension, the following forms are okay:
8384 // char const **
8385 // char const * const *
8386 // char * const *
8387
John McCall8ccfcb52009-09-24 19:53:00 +00008388 QualifierCollector qs;
John McCall02dee0a2009-07-25 04:36:53 +00008389 const PointerType* PT;
Ted Kremenekc23c7e62009-07-29 21:53:49 +00008390 if ((PT = qs.strip(AT)->getAs<PointerType>()) &&
8391 (PT = qs.strip(PT->getPointeeType())->getAs<PointerType>()) &&
Richard Smith685cef62013-01-29 02:49:47 +00008392 Context.hasSameType(QualType(qs.strip(PT->getPointeeType()), 0),
8393 Context.CharTy)) {
John McCall02dee0a2009-07-25 04:36:53 +00008394 qs.removeConst();
8395 mismatch = !qs.empty();
8396 }
8397 }
8398
8399 if (mismatch) {
8400 Diag(FD->getLocation(), diag::err_main_arg_wrong) << i << Expected[i];
8401 // TODO: suggest replacing given type with expected type
8402 FD->setInvalidDecl(true);
8403 }
8404 }
8405
8406 if (nparams == 1 && !FD->isInvalidDecl()) {
8407 Diag(FD->getLocation(), diag::warn_main_one_arg);
8408 }
Douglas Gregorbff62032010-10-21 16:57:46 +00008409
8410 if (!FD->isInvalidDecl() && FD->getDescribedFunctionTemplate()) {
Aaron Ballman6d086d72014-01-03 02:20:27 +00008411 Diag(FD->getLocation(), diag::err_mainlike_template_decl) << FD;
David Majnemerc729b0b2013-09-16 22:44:20 +00008412 FD->setInvalidDecl();
8413 }
8414}
8415
8416void Sema::CheckMSVCRTEntryPoint(FunctionDecl *FD) {
8417 QualType T = FD->getType();
8418 assert(T->isFunctionType() && "function decl is not of function type");
8419 const FunctionType *FT = T->castAs<FunctionType>();
8420
8421 // Set an implicit return of 'zero' if the function can return some integral,
8422 // enumeration, pointer or nullptr type.
Alp Toker314cc812014-01-25 16:55:45 +00008423 if (FT->getReturnType()->isIntegralOrEnumerationType() ||
8424 FT->getReturnType()->isAnyPointerType() ||
8425 FT->getReturnType()->isNullPtrType())
David Majnemerc729b0b2013-09-16 22:44:20 +00008426 // DllMain is exempt because a return value of zero means it failed.
8427 if (FD->getName() != "DllMain")
8428 FD->setHasImplicitReturnZero(true);
8429
8430 if (!FD->isInvalidDecl() && FD->getDescribedFunctionTemplate()) {
Aaron Ballman6d086d72014-01-03 02:20:27 +00008431 Diag(FD->getLocation(), diag::err_mainlike_template_decl) << FD;
Douglas Gregorbff62032010-10-21 16:57:46 +00008432 FD->setInvalidDecl();
8433 }
John McCalld9baf6a2009-07-24 03:03:21 +00008434}
8435
Eli Friedmand5a55bd2008-05-20 13:48:25 +00008436bool Sema::CheckForConstantInitializer(Expr *Init, QualType DclT) {
Eli Friedman2c7bd6b2009-02-27 04:17:12 +00008437 // FIXME: Need strict checking. In C89, we need to check for
8438 // any assignment, increment, decrement, function-calls, or
8439 // commas outside of a sizeof. In C99, it's the same list,
8440 // except that the aforementioned are allowed in unevaluated
8441 // expressions. Everything else falls under the
8442 // "may accept other forms of constant expressions" exception.
8443 // (We never end up here for C++, so the constant expression
8444 // rules there don't matter.)
Abramo Bagnara847c6602014-05-22 19:20:46 +00008445 const Expr *Culprit;
8446 if (Init->isConstantInitializer(Context, false, &Culprit))
Eli Friedman7bfab362009-02-22 06:45:27 +00008447 return false;
Abramo Bagnara847c6602014-05-22 19:20:46 +00008448 Diag(Culprit->getExprLoc(), diag::err_init_element_not_constant)
8449 << Culprit->getSourceRange();
Eli Friedmand5a55bd2008-05-20 13:48:25 +00008450 return true;
Steve Naroff98f72032008-01-10 22:15:12 +00008451}
8452
Chandler Carruth33bf3e72011-03-27 09:46:56 +00008453namespace {
8454 // Visits an initialization expression to see if OrigDecl is evaluated in
8455 // its own initialization and throws a warning if it does.
8456 class SelfReferenceChecker
8457 : public EvaluatedExprVisitor<SelfReferenceChecker> {
8458 Sema &S;
8459 Decl *OrigDecl;
Richard Trieua04ad1a2011-09-01 21:44:13 +00008460 bool isRecordType;
8461 bool isPODType;
Hans Wennborge1fdb052012-08-17 10:12:33 +00008462 bool isReferenceType;
Chandler Carruth33bf3e72011-03-27 09:46:56 +00008463
Richard Trieue396ba62014-09-23 22:52:42 +00008464 bool isInitList;
8465 llvm::SmallVector<unsigned, 4> InitFieldIndex;
Chandler Carruth33bf3e72011-03-27 09:46:56 +00008466 public:
8467 typedef EvaluatedExprVisitor<SelfReferenceChecker> Inherited;
8468
8469 SelfReferenceChecker(Sema &S, Decl *OrigDecl) : Inherited(S.Context),
Richard Trieua04ad1a2011-09-01 21:44:13 +00008470 S(S), OrigDecl(OrigDecl) {
8471 isPODType = false;
8472 isRecordType = false;
Hans Wennborge1fdb052012-08-17 10:12:33 +00008473 isReferenceType = false;
Richard Trieue396ba62014-09-23 22:52:42 +00008474 isInitList = false;
Richard Trieua04ad1a2011-09-01 21:44:13 +00008475 if (ValueDecl *VD = dyn_cast<ValueDecl>(OrigDecl)) {
8476 isPODType = VD->getType().isPODType(S.Context);
8477 isRecordType = VD->getType()->isRecordType();
Hans Wennborge1fdb052012-08-17 10:12:33 +00008478 isReferenceType = VD->getType()->isReferenceType();
Richard Trieua04ad1a2011-09-01 21:44:13 +00008479 }
8480 }
Chandler Carruth33bf3e72011-03-27 09:46:56 +00008481
Richard Trieue396ba62014-09-23 22:52:42 +00008482 // For most expressions, just call the visitor. For initializer lists,
8483 // track the index of the field being initialized since fields are
8484 // initialized in order allowing use of previously initialized fields.
8485 void CheckExpr(Expr *E) {
8486 InitListExpr *InitList = dyn_cast<InitListExpr>(E);
8487 if (!InitList) {
8488 Visit(E);
8489 return;
8490 }
8491
8492 // Track and increment the index here.
8493 isInitList = true;
8494 InitFieldIndex.push_back(0);
8495 for (auto Child : InitList->children()) {
8496 CheckExpr(cast<Expr>(Child));
8497 ++InitFieldIndex.back();
8498 }
8499 InitFieldIndex.pop_back();
8500 }
8501
8502 // Returns true if MemberExpr is checked and no futher checking is needed.
8503 // Returns false if additional checking is required.
8504 bool CheckInitListMemberExpr(MemberExpr *E, bool CheckReference) {
8505 llvm::SmallVector<FieldDecl*, 4> Fields;
8506 Expr *Base = E;
8507 bool ReferenceField = false;
8508
8509 // Get the field memebers used.
8510 while (MemberExpr *ME = dyn_cast<MemberExpr>(Base)) {
8511 FieldDecl *FD = dyn_cast<FieldDecl>(ME->getMemberDecl());
8512 if (!FD)
8513 return false;
8514 Fields.push_back(FD);
8515 if (FD->getType()->isReferenceType())
8516 ReferenceField = true;
8517 Base = ME->getBase()->IgnoreParenImpCasts();
8518 }
8519
8520 // Keep checking only if the base Decl is the same.
8521 DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Base);
8522 if (!DRE || DRE->getDecl() != OrigDecl)
8523 return false;
8524
8525 // A reference field can be bound to an unininitialized field.
8526 if (CheckReference && !ReferenceField)
8527 return true;
8528
8529 // Convert FieldDecls to their index number.
8530 llvm::SmallVector<unsigned, 4> UsedFieldIndex;
8531 for (auto I = Fields.rbegin(), E = Fields.rend(); I != E; ++I) {
8532 UsedFieldIndex.push_back((*I)->getFieldIndex());
8533 }
8534
8535 // See if a warning is needed by checking the first difference in index
8536 // numbers. If field being used has index less than the field being
8537 // initialized, then the use is safe.
8538 for (auto UsedIter = UsedFieldIndex.begin(),
8539 UsedEnd = UsedFieldIndex.end(),
8540 OrigIter = InitFieldIndex.begin(),
8541 OrigEnd = InitFieldIndex.end();
8542 UsedIter != UsedEnd && OrigIter != OrigEnd; ++UsedIter, ++OrigIter) {
8543 if (*UsedIter < *OrigIter)
8544 return true;
8545 if (*UsedIter > *OrigIter)
8546 break;
8547 }
8548
8549 // TODO: Add a different warning which will print the field names.
8550 HandleDeclRefExpr(DRE);
8551 return true;
8552 }
8553
Richard Trieu64c51ab2012-05-09 00:21:34 +00008554 // For most expressions, the cast is directly above the DeclRefExpr.
8555 // For conditional operators, the cast can be outside the conditional
8556 // operator if both expressions are DeclRefExpr's.
8557 void HandleValue(Expr *E) {
Richard Trieuabf6ec42014-08-27 22:15:10 +00008558 E = E->IgnoreParens();
Richard Trieu64c51ab2012-05-09 00:21:34 +00008559 if (DeclRefExpr* DRE = dyn_cast<DeclRefExpr>(E)) {
8560 HandleDeclRefExpr(DRE);
8561 return;
8562 }
8563
8564 if (ConditionalOperator *CO = dyn_cast<ConditionalOperator>(E)) {
Richard Trieu779c6f22014-09-26 23:48:30 +00008565 Visit(CO->getCond());
Richard Trieu64c51ab2012-05-09 00:21:34 +00008566 HandleValue(CO->getTrueExpr());
8567 HandleValue(CO->getFalseExpr());
Richard Trieu742c6ed2012-10-03 00:41:36 +00008568 return;
8569 }
8570
Richard Trieuabf6ec42014-08-27 22:15:10 +00008571 if (BinaryConditionalOperator *BCO =
8572 dyn_cast<BinaryConditionalOperator>(E)) {
Richard Trieu2a07c962014-09-04 23:19:34 +00008573 Visit(BCO->getCond());
Richard Trieuabf6ec42014-08-27 22:15:10 +00008574 HandleValue(BCO->getFalseExpr());
8575 return;
8576 }
8577
8578 if (OpaqueValueExpr *OVE = dyn_cast<OpaqueValueExpr>(E)) {
8579 HandleValue(OVE->getSourceExpr());
8580 return;
8581 }
8582
8583 if (BinaryOperator *BO = dyn_cast<BinaryOperator>(E)) {
Richard Trieu78dd7252014-09-24 03:53:56 +00008584 if (BO->getOpcode() == BO_Comma) {
8585 Visit(BO->getLHS());
Richard Trieuabf6ec42014-08-27 22:15:10 +00008586 HandleValue(BO->getRHS());
Richard Trieu78dd7252014-09-24 03:53:56 +00008587 return;
8588 }
Richard Trieuabf6ec42014-08-27 22:15:10 +00008589 }
8590
Richard Trieu742c6ed2012-10-03 00:41:36 +00008591 if (isa<MemberExpr>(E)) {
Richard Trieue396ba62014-09-23 22:52:42 +00008592 if (isInitList) {
8593 if (CheckInitListMemberExpr(cast<MemberExpr>(E),
8594 false /*CheckReference*/))
8595 return;
8596 }
8597
Richard Trieu742c6ed2012-10-03 00:41:36 +00008598 Expr *Base = E->IgnoreParenImpCasts();
8599 while (MemberExpr *ME = dyn_cast<MemberExpr>(Base)) {
8600 // Check for static member variables and don't warn on them.
8601 if (!isa<FieldDecl>(ME->getMemberDecl()))
8602 return;
8603 Base = ME->getBase()->IgnoreParenImpCasts();
8604 }
8605 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Base))
8606 HandleDeclRefExpr(DRE);
8607 return;
Richard Trieu64c51ab2012-05-09 00:21:34 +00008608 }
Richard Trieu2a07c962014-09-04 23:19:34 +00008609
8610 Visit(E);
Richard Trieu64c51ab2012-05-09 00:21:34 +00008611 }
8612
Richard Trieu2a07c962014-09-04 23:19:34 +00008613 // Reference types not handled in HandleValue are handled here since all
8614 // uses of references are bad, not just r-value uses.
Richard Trieu32673472012-10-01 17:39:51 +00008615 void VisitDeclRefExpr(DeclRefExpr *E) {
8616 if (isReferenceType)
8617 HandleDeclRefExpr(E);
8618 }
8619
Richard Trieu64c51ab2012-05-09 00:21:34 +00008620 void VisitImplicitCastExpr(ImplicitCastExpr *E) {
Richard Trieu9f8509f2014-09-30 23:04:37 +00008621 if (E->getCastKind() == CK_LValueToRValue) {
Richard Trieu64c51ab2012-05-09 00:21:34 +00008622 HandleValue(E->getSubExpr());
Richard Trieu2a07c962014-09-04 23:19:34 +00008623 return;
8624 }
Richard Trieu64c51ab2012-05-09 00:21:34 +00008625
8626 Inherited::VisitImplicitCastExpr(E);
Chandler Carruth33bf3e72011-03-27 09:46:56 +00008627 }
8628
Richard Trieua04ad1a2011-09-01 21:44:13 +00008629 void VisitMemberExpr(MemberExpr *E) {
Richard Trieue396ba62014-09-23 22:52:42 +00008630 if (isInitList) {
8631 if (CheckInitListMemberExpr(E, true /*CheckReference*/))
8632 return;
8633 }
8634
Richard Trieu64c51ab2012-05-09 00:21:34 +00008635 // Don't warn on arrays since they can be treated as pointers.
Richard Trieuaa5e2562011-09-07 00:58:53 +00008636 if (E->getType()->canDecayToPointerType()) return;
Richard Trieu64c51ab2012-05-09 00:21:34 +00008637
Richard Trieu742c6ed2012-10-03 00:41:36 +00008638 // Warn when a non-static method call is followed by non-static member
8639 // field accesses, which is followed by a DeclRefExpr.
8640 CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(E->getMemberDecl());
8641 bool Warn = (MD && !MD->isStatic());
8642 Expr *Base = E->getBase()->IgnoreParenImpCasts();
8643 while (MemberExpr *ME = dyn_cast<MemberExpr>(Base)) {
8644 if (!isa<FieldDecl>(ME->getMemberDecl()))
8645 Warn = false;
8646 Base = ME->getBase()->IgnoreParenImpCasts();
8647 }
Richard Trieua04ad1a2011-09-01 21:44:13 +00008648
Richard Trieu742c6ed2012-10-03 00:41:36 +00008649 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Base)) {
8650 if (Warn)
8651 HandleDeclRefExpr(DRE);
8652 return;
8653 }
8654
8655 // The base of a MemberExpr is not a MemberExpr or a DeclRefExpr.
8656 // Visit that expression.
8657 Visit(Base);
Chandler Carruth33bf3e72011-03-27 09:46:56 +00008658 }
8659
Richard Trieu8fbd91d2013-03-26 03:41:40 +00008660 void VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E) {
Richard Trieud4a01362014-10-31 21:10:22 +00008661 Expr *Callee = E->getCallee();
Richard Trieu8fbd91d2013-03-26 03:41:40 +00008662
Richard Trieud4a01362014-10-31 21:10:22 +00008663 if (isa<UnresolvedLookupExpr>(Callee))
8664 return Inherited::VisitCXXOperatorCallExpr(E);
8665
8666 Visit(Callee);
8667 for (auto Arg: E->arguments())
8668 HandleValue(Arg->IgnoreParenImpCasts());
Richard Trieu8fbd91d2013-03-26 03:41:40 +00008669 }
8670
Richard Trieua04ad1a2011-09-01 21:44:13 +00008671 void VisitUnaryOperator(UnaryOperator *E) {
8672 // For POD record types, addresses of its own members are well-defined.
Richard Trieu742c6ed2012-10-03 00:41:36 +00008673 if (E->getOpcode() == UO_AddrOf && isRecordType &&
8674 isa<MemberExpr>(E->getSubExpr()->IgnoreParens())) {
8675 if (!isPODType)
8676 HandleValue(E->getSubExpr());
8677 return;
8678 }
Richard Trieu52b8b602014-09-25 01:15:40 +00008679
8680 if (E->isIncrementDecrementOp()) {
8681 HandleValue(E->getSubExpr());
8682 return;
8683 }
8684
Richard Trieua04ad1a2011-09-01 21:44:13 +00008685 Inherited::VisitUnaryOperator(E);
Richard Smithfa11fd62013-05-03 19:16:22 +00008686 }
Richard Trieu64c51ab2012-05-09 00:21:34 +00008687
8688 void VisitObjCMessageExpr(ObjCMessageExpr *E) { return; }
8689
Richard Trieu4834ad22014-08-12 21:05:04 +00008690 void VisitCXXConstructExpr(CXXConstructExpr *E) {
8691 if (E->getConstructor()->isCopyConstructor()) {
Richard Trieu9f8509f2014-09-30 23:04:37 +00008692 Expr *ArgExpr = E->getArg(0);
8693 if (InitListExpr *ILE = dyn_cast<InitListExpr>(ArgExpr))
8694 if (ILE->getNumInits() == 1)
8695 ArgExpr = ILE->getInit(0);
8696 if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(ArgExpr))
8697 if (ICE->getCastKind() == CK_NoOp)
8698 ArgExpr = ICE->getSubExpr();
8699 HandleValue(ArgExpr);
8700 return;
Richard Trieu4834ad22014-08-12 21:05:04 +00008701 }
8702 Inherited::VisitCXXConstructExpr(E);
8703 }
8704
Richard Trieu11fd0792014-08-26 04:30:55 +00008705 void VisitCallExpr(CallExpr *E) {
8706 // Treat std::move as a use.
8707 if (E->getNumArgs() == 1) {
8708 if (FunctionDecl *FD = E->getDirectCallee()) {
Richard Trieuc321b932014-11-27 01:29:32 +00008709 if (FD->isInStdNamespace() && FD->getIdentifier() &&
8710 FD->getIdentifier()->isStr("move")) {
Richard Trieuabf6ec42014-08-27 22:15:10 +00008711 HandleValue(E->getArg(0));
Richard Trieu2a07c962014-09-04 23:19:34 +00008712 return;
Richard Trieu11fd0792014-08-26 04:30:55 +00008713 }
8714 }
8715 }
8716
8717 Inherited::VisitCallExpr(E);
8718 }
8719
Richard Trieu52b8b602014-09-25 01:15:40 +00008720 void VisitBinaryOperator(BinaryOperator *E) {
8721 if (E->isCompoundAssignmentOp()) {
8722 HandleValue(E->getLHS());
8723 Visit(E->getRHS());
8724 return;
8725 }
8726
8727 Inherited::VisitBinaryOperator(E);
8728 }
8729
Richard Trieu2a07c962014-09-04 23:19:34 +00008730 // A custom visitor for BinaryConditionalOperator is needed because the
8731 // regular visitor would check the condition and true expression separately
8732 // but both point to the same place giving duplicate diagnostics.
8733 void VisitBinaryConditionalOperator(BinaryConditionalOperator *E) {
8734 Visit(E->getCond());
8735 Visit(E->getFalseExpr());
8736 }
8737
Richard Trieua04ad1a2011-09-01 21:44:13 +00008738 void HandleDeclRefExpr(DeclRefExpr *DRE) {
NAKAMURA Takumi3fef3ef2013-01-19 01:54:35 +00008739 Decl* ReferenceDecl = DRE->getDecl();
Chandler Carruth33bf3e72011-03-27 09:46:56 +00008740 if (OrigDecl != ReferenceDecl) return;
Ted Kremeneka83b4072013-01-19 04:33:14 +00008741 unsigned diag;
8742 if (isReferenceType) {
8743 diag = diag::warn_uninit_self_reference_in_reference_init;
8744 } else if (cast<VarDecl>(OrigDecl)->isStaticLocal()) {
8745 diag = diag::warn_static_self_reference_in_init;
Manuel Klimek27ee25f2015-03-03 14:54:25 +00008746 } else if (isa<TranslationUnitDecl>(OrigDecl->getDeclContext()) ||
8747 isa<NamespaceDecl>(OrigDecl->getDeclContext()) ||
8748 DRE->getDecl()->getType()->isRecordType()) {
Ted Kremeneka83b4072013-01-19 04:33:14 +00008749 diag = diag::warn_uninit_self_reference_in_init;
Manuel Klimek27ee25f2015-03-03 14:54:25 +00008750 } else {
8751 // Local variables will be handled by the CFG analysis.
8752 return;
Ted Kremeneka83b4072013-01-19 04:33:14 +00008753 }
8754
Richard Trieua04ad1a2011-09-01 21:44:13 +00008755 S.DiagRuntimeBehavior(DRE->getLocStart(), DRE,
Hans Wennborgd799a2b2012-08-20 08:52:22 +00008756 S.PDiag(diag)
Hans Wennborg61b2ffa2012-09-21 08:58:33 +00008757 << DRE->getNameInfo().getName()
Douglas Gregorfcafc6e2011-05-24 16:02:01 +00008758 << OrigDecl->getLocation()
Richard Trieua04ad1a2011-09-01 21:44:13 +00008759 << DRE->getSourceRange());
Chandler Carruth33bf3e72011-03-27 09:46:56 +00008760 }
8761 };
Chandler Carruth33bf3e72011-03-27 09:46:56 +00008762
Richard Trieu32673472012-10-01 17:39:51 +00008763 /// CheckSelfReference - Warns if OrigDecl is used in expression E.
8764 static void CheckSelfReference(Sema &S, Decl* OrigDecl, Expr *E,
8765 bool DirectInit) {
8766 // Parameters arguments are occassionially constructed with itself,
8767 // for instance, in recursive functions. Skip them.
8768 if (isa<ParmVarDecl>(OrigDecl))
8769 return;
8770
8771 E = E->IgnoreParens();
8772
8773 // Skip checking T a = a where T is not a record or reference type.
8774 // Doing so is a way to silence uninitialized warnings.
8775 if (!DirectInit && !cast<VarDecl>(OrigDecl)->getType()->isRecordType())
8776 if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E))
8777 if (ICE->getCastKind() == CK_LValueToRValue)
8778 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(ICE->getSubExpr()))
8779 if (DRE->getDecl() == OrigDecl)
8780 return;
8781
Richard Trieue396ba62014-09-23 22:52:42 +00008782 SelfReferenceChecker(S, OrigDecl).CheckExpr(E);
Richard Trieu32673472012-10-01 17:39:51 +00008783 }
Alexander Kornienkoab9db512015-06-22 23:07:51 +00008784}
Richard Trieua04ad1a2011-09-01 21:44:13 +00008785
Richard Smith40cdd7a2015-06-29 23:19:23 +00008786/// Determine whether the given expression was formed from the token '0'. This
8787/// test is necessary to determine whether an initializer is really a
8788/// pure-specifier.
8789static bool isZeroToken(Sema &S, Expr *E) {
8790 auto *IL = dyn_cast<IntegerLiteral>(E);
8791 if (!IL || !!IL->getValue() ||
8792 !IL->getType()->isSpecificBuiltinType(BuiltinType::Int))
8793 return false;
8794
8795 SmallString<8> Buffer;
8796 return S.PP.getSpelling(E->getLocStart(), Buffer) == "0";
8797}
8798
Douglas Gregor5fb53972009-01-14 15:45:31 +00008799/// AddInitializerToDecl - Adds the initializer Init to the
8800/// declaration dcl. If DirectInit is true, this is C++ direct
8801/// initialization rather than copy initialization.
Richard Smith30482bc2011-02-20 03:19:35 +00008802void Sema::AddInitializerToDecl(Decl *RealDecl, Expr *Init,
8803 bool DirectInit, bool TypeMayContainAuto) {
Chris Lattner8beb9de2007-10-19 20:10:30 +00008804 // If there is no declaration, there was an error parsing it. Just ignore
8805 // the initializer.
Kaelyn Takata42118a92015-01-07 21:16:39 +00008806 if (!RealDecl || RealDecl->isInvalidDecl()) {
Kaelyn Takatab8499f02015-05-05 19:17:03 +00008807 CorrectDelayedTyposInExpr(Init, dyn_cast_or_null<VarDecl>(RealDecl));
Chris Lattner8beb9de2007-10-19 20:10:30 +00008808 return;
Kaelyn Takata42118a92015-01-07 21:16:39 +00008809 }
Mike Stump11289f42009-09-09 15:08:12 +00008810
Douglas Gregor0c880302009-03-11 23:00:04 +00008811 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(RealDecl)) {
8812 // With declarators parsed the way they are, the parser cannot
8813 // distinguish between a normal initializer and a pure-specifier.
8814 // Thus this grotesque test.
Richard Smith40cdd7a2015-06-29 23:19:23 +00008815 //
8816 // FIXME: The parser should instead treat anything that looks like a
8817 // pure-specifier as a pure-specifier, and Sema should convert it to an
8818 // initializer when necessary, rather than doing things this way around.
8819 if (!DirectInit && isZeroToken(*this, Init))
Douglas Gregor21920e372009-12-01 17:24:26 +00008820 CheckPureMethod(Method, Init->getSourceRange());
8821 else {
Douglas Gregor0c880302009-03-11 23:00:04 +00008822 Diag(Method->getLocation(), diag::err_member_function_initialization)
8823 << Method->getDeclName() << Init->getSourceRange();
8824 Method->setInvalidDecl();
8825 }
8826 return;
8827 }
8828
Steve Naroff437b4d82007-09-12 20:13:48 +00008829 VarDecl *VDecl = dyn_cast<VarDecl>(RealDecl);
8830 if (!VDecl) {
Richard Smith4a4beec2011-06-12 11:43:46 +00008831 assert(!isa<FieldDecl>(RealDecl) && "field init shouldn't get here");
8832 Diag(RealDecl->getLocation(), diag::err_illegal_initializer);
Steve Naroff437b4d82007-09-12 20:13:48 +00008833 RealDecl->setInvalidDecl();
8834 return;
Eli Friedman2c7bd6b2009-02-27 04:17:12 +00008835 }
Sebastian Redla9351792012-02-11 23:51:47 +00008836 ParenListExpr *CXXDirectInit = dyn_cast<ParenListExpr>(Init);
8837
Richard Smith0cc85782011-12-15 19:20:59 +00008838 // C++11 [decl.spec.auto]p6. Deduce the type which 'auto' stands in for.
Richard Smith27d807c2013-04-30 13:56:41 +00008839 if (TypeMayContainAuto && VDecl->getType()->isUndeducedType()) {
Kaelyn Takata3587fff2015-03-17 23:50:12 +00008840 // Attempt typo correction early so that the type of the init expression can
8841 // be deduced based on the chosen correction:if the original init contains a
8842 // TypoExpr.
Kaelyn Takatab8499f02015-05-05 19:17:03 +00008843 ExprResult Res = CorrectDelayedTyposInExpr(Init, VDecl);
Kaelyn Takata3587fff2015-03-17 23:50:12 +00008844 if (!Res.isUsable()) {
8845 RealDecl->setInvalidDecl();
8846 return;
8847 }
Kaelyn Takatab8499f02015-05-05 19:17:03 +00008848
Kaelyn Takata3587fff2015-03-17 23:50:12 +00008849 if (Res.get() != Init) {
8850 Init = Res.get();
8851 if (CXXDirectInit)
8852 CXXDirectInit = dyn_cast<ParenListExpr>(Init);
8853 }
8854
Sebastian Redla9351792012-02-11 23:51:47 +00008855 Expr *DeduceInit = Init;
8856 // Initializer could be a C++ direct-initializer. Deduction only works if it
8857 // contains exactly one expression.
8858 if (CXXDirectInit) {
8859 if (CXXDirectInit->getNumExprs() == 0) {
8860 // It isn't possible to write this directly, but it is possible to
8861 // end up in this situation with "auto x(some_pack...);"
Daniel Dunbar62ee6412012-03-09 18:35:03 +00008862 Diag(CXXDirectInit->getLocStart(),
Richard Smithbb13c9a2013-09-28 04:02:39 +00008863 VDecl->isInitCapture() ? diag::err_init_capture_no_expression
8864 : diag::err_auto_var_init_no_expression)
Sebastian Redla9351792012-02-11 23:51:47 +00008865 << VDecl->getDeclName() << VDecl->getType()
8866 << VDecl->getSourceRange();
8867 RealDecl->setInvalidDecl();
8868 return;
8869 } else if (CXXDirectInit->getNumExprs() > 1) {
Daniel Dunbar62ee6412012-03-09 18:35:03 +00008870 Diag(CXXDirectInit->getExpr(1)->getLocStart(),
Richard Smithbb13c9a2013-09-28 04:02:39 +00008871 VDecl->isInitCapture()
8872 ? diag::err_init_capture_multiple_expressions
8873 : diag::err_auto_var_init_multiple_expressions)
Sebastian Redla9351792012-02-11 23:51:47 +00008874 << VDecl->getDeclName() << VDecl->getType()
8875 << VDecl->getSourceRange();
8876 RealDecl->setInvalidDecl();
8877 return;
8878 } else {
8879 DeduceInit = CXXDirectInit->getExpr(0);
Richard Smith66204ec2014-03-12 17:42:45 +00008880 if (isa<InitListExpr>(DeduceInit))
8881 Diag(CXXDirectInit->getLocStart(),
8882 diag::err_auto_var_init_paren_braces)
8883 << VDecl->getDeclName() << VDecl->getType()
8884 << VDecl->getSourceRange();
Sebastian Redla9351792012-02-11 23:51:47 +00008885 }
8886 }
Douglas Gregorb5af2e92013-03-07 22:57:58 +00008887
8888 // Expressions default to 'id' when we're in a debugger.
8889 bool DefaultedToAuto = false;
8890 if (getLangOpts().DebuggerCastResultToId &&
8891 Init->getType() == Context.UnknownAnyTy) {
8892 ExprResult Result = forceUnknownAnyToType(Init, Context.getObjCIdType());
8893 if (Result.isInvalid()) {
8894 VDecl->setInvalidDecl();
8895 return;
8896 }
Nikola Smiljanic01a75982014-05-29 10:55:11 +00008897 Init = Result.get();
Douglas Gregorb5af2e92013-03-07 22:57:58 +00008898 DefaultedToAuto = true;
8899 }
Richard Smith061f1e22013-04-30 21:23:01 +00008900
8901 QualType DeducedType;
Sebastian Redla9351792012-02-11 23:51:47 +00008902 if (DeduceAutoType(VDecl->getTypeSourceInfo(), DeduceInit, DeducedType) ==
Sebastian Redl09edce02012-01-23 22:09:39 +00008903 DAR_Failed)
Sebastian Redla9351792012-02-11 23:51:47 +00008904 DiagnoseAutoDeductionFailure(VDecl, DeduceInit);
Richard Smith061f1e22013-04-30 21:23:01 +00008905 if (DeducedType.isNull()) {
Richard Smith30482bc2011-02-20 03:19:35 +00008906 RealDecl->setInvalidDecl();
8907 return;
8908 }
Richard Smith061f1e22013-04-30 21:23:01 +00008909 VDecl->setType(DeducedType);
Rafael Espindola0e0d0092013-03-14 03:07:35 +00008910 assert(VDecl->isLinkageValid());
Rafael Espindolabf5c33b2013-03-12 21:06:00 +00008911
John McCall31168b02011-06-15 23:02:42 +00008912 // In ARC, infer lifetime.
David Blaikiebbafb8a2012-03-11 07:00:24 +00008913 if (getLangOpts().ObjCAutoRefCount && inferObjCARCLifetime(VDecl))
John McCall31168b02011-06-15 23:02:42 +00008914 VDecl->setInvalidDecl();
8915
Jordan Rosed8d56692012-06-08 22:46:07 +00008916 // Warn if we deduced 'id'. 'auto' usually implies type-safety, but using
8917 // 'id' instead of a specific object type prevents most of our usual checks.
8918 // We only want to warn outside of template instantiations, though:
8919 // inside a template, the 'id' could have come from a parameter.
Douglas Gregorb5af2e92013-03-07 22:57:58 +00008920 if (ActiveTemplateInstantiations.empty() && !DefaultedToAuto &&
Richard Smith061f1e22013-04-30 21:23:01 +00008921 DeducedType->isObjCIdType()) {
8922 SourceLocation Loc =
8923 VDecl->getTypeSourceInfo()->getTypeLoc().getBeginLoc();
Jordan Rosed8d56692012-06-08 22:46:07 +00008924 Diag(Loc, diag::warn_auto_var_is_id)
8925 << VDecl->getDeclName() << DeduceInit->getSourceRange();
8926 }
8927
Richard Smith30482bc2011-02-20 03:19:35 +00008928 // If this is a redeclaration, check that the type we just deduced matches
8929 // the previously declared type.
Richard Smith1c34fb72013-08-13 18:18:50 +00008930 if (VarDecl *Old = VDecl->getPreviousDecl()) {
8931 // We never need to merge the type, because we cannot form an incomplete
8932 // array of auto, nor deduce such a type.
8933 MergeVarDeclTypes(VDecl, Old, /*MergeTypeWithPrevious*/false);
8934 }
Richard Smith27d807c2013-04-30 13:56:41 +00008935
8936 // Check the deduced type is valid for a variable declaration.
8937 CheckVariableDeclarationType(VDecl);
8938 if (VDecl->isInvalidDecl())
8939 return;
Richard Smith215f4232015-02-11 02:41:33 +00008940
8941 // If all looks well, warn if this is a case that will change meaning when
8942 // we implement N3922.
8943 if (DirectInit && !CXXDirectInit && isa<InitListExpr>(Init)) {
8944 Diag(Init->getLocStart(),
8945 diag::warn_auto_var_direct_list_init)
8946 << FixItHint::CreateInsertion(Init->getLocStart(), "=");
8947 }
Richard Smith30482bc2011-02-20 03:19:35 +00008948 }
Richard Smith0cc85782011-12-15 19:20:59 +00008949
Nico Rieck8e9791f2014-02-26 21:27:13 +00008950 // dllimport cannot be used on variable definitions.
8951 if (VDecl->hasAttr<DLLImportAttr>() && !VDecl->isStaticDataMember()) {
8952 Diag(VDecl->getLocation(), diag::err_attribute_dllimport_data_definition);
8953 VDecl->setInvalidDecl();
8954 return;
8955 }
8956
Richard Smith0cc85782011-12-15 19:20:59 +00008957 if (VDecl->isLocalVarDecl() && VDecl->hasExternalStorage()) {
8958 // C99 6.7.8p5. C++ has no such restriction, but that is a defect.
8959 Diag(VDecl->getLocation(), diag::err_block_extern_cant_init);
8960 VDecl->setInvalidDecl();
8961 return;
8962 }
8963
Sebastian Redla9351792012-02-11 23:51:47 +00008964 if (!VDecl->getType()->isDependentType()) {
8965 // A definition must end up with a complete type, which means it must be
8966 // complete with the restriction that an array type might be completed by
8967 // the initializer; note that later code assumes this restriction.
8968 QualType BaseDeclType = VDecl->getType();
8969 if (const ArrayType *Array = Context.getAsIncompleteArrayType(BaseDeclType))
8970 BaseDeclType = Array->getElementType();
8971 if (RequireCompleteType(VDecl->getLocation(), BaseDeclType,
8972 diag::err_typecheck_decl_incomplete_type)) {
8973 RealDecl->setInvalidDecl();
8974 return;
8975 }
Douglas Gregorf0f83692010-08-24 05:27:49 +00008976
Sebastian Redla9351792012-02-11 23:51:47 +00008977 // The variable can not have an abstract class type.
8978 if (RequireNonAbstractType(VDecl->getLocation(), VDecl->getType(),
8979 diag::err_abstract_type_in_decl,
8980 AbstractVariableType))
8981 VDecl->setInvalidDecl();
Eli Friedman337cd3a2009-04-13 21:28:54 +00008982 }
8983
Richard Smith82e57fb2015-05-19 00:49:29 +00008984 VarDecl *Def;
Sebastian Redl5ca79842010-02-01 20:16:42 +00008985 if ((Def = VDecl->getDefinition()) && Def != VDecl) {
Richard Smith82e57fb2015-05-19 00:49:29 +00008986 NamedDecl *Hidden = nullptr;
8987 if (!hasVisibleDefinition(Def, &Hidden) &&
Richard Smith529ecb22015-06-22 21:15:01 +00008988 (VDecl->getFormalLinkage() == InternalLinkage ||
8989 VDecl->getDescribedVarTemplate() ||
Richard Smith82e57fb2015-05-19 00:49:29 +00008990 VDecl->getNumTemplateParameterLists() ||
8991 VDecl->getDeclContext()->isDependentContext())) {
8992 // The previous definition is hidden, and multiple definitions are
8993 // permitted (in separate TUs). Form another definition of it.
8994 } else {
8995 Diag(VDecl->getLocation(), diag::err_redefinition)
8996 << VDecl->getDeclName();
8997 Diag(Def->getLocation(), diag::note_previous_definition);
8998 VDecl->setInvalidDecl();
8999 return;
9000 }
Douglas Gregor0760fa12009-03-10 23:43:53 +00009001 }
Craig Topperc3ec1492014-05-26 06:22:03 +00009002
David Blaikiebbafb8a2012-03-11 07:00:24 +00009003 if (getLangOpts().CPlusPlus) {
Douglas Gregor71f39c92010-12-16 01:31:22 +00009004 // C++ [class.static.data]p4
9005 // If a static data member is of const integral or const
9006 // enumeration type, its declaration in the class definition can
9007 // specify a constant-initializer which shall be an integral
9008 // constant expression (5.19). In that case, the member can appear
9009 // in integral constant expressions. The member shall still be
9010 // defined in a namespace scope if it is used in the program and the
9011 // namespace scope definition shall not contain an initializer.
9012 //
9013 // We already performed a redefinition check above, but for static
9014 // data members we also need to check whether there was an in-class
9015 // declaration with an initializer.
Richard Smith82e57fb2015-05-19 00:49:29 +00009016 if (VDecl->isStaticDataMember() && VDecl->getCanonicalDecl()->hasInit()) {
Hans Wennborg84fe12d2013-11-21 03:17:44 +00009017 Diag(Init->getExprLoc(), diag::err_static_data_member_reinitialization)
9018 << VDecl->getDeclName();
Richard Smith82e57fb2015-05-19 00:49:29 +00009019 Diag(VDecl->getCanonicalDecl()->getInit()->getExprLoc(),
9020 diag::note_previous_initializer)
9021 << 0;
Douglas Gregor71f39c92010-12-16 01:31:22 +00009022 return;
9023 }
Douglas Gregor0760fa12009-03-10 23:43:53 +00009024
Douglas Gregor71f39c92010-12-16 01:31:22 +00009025 if (VDecl->hasLocalStorage())
9026 getCurFunction()->setHasBranchProtectedScope();
9027
9028 if (DiagnoseUnexpandedParameterPack(Init, UPPC_Initializer)) {
9029 VDecl->setInvalidDecl();
9030 return;
9031 }
9032 }
John McCalld4e1b762010-08-01 01:24:59 +00009033
Peter Collingbourne2dbb7082011-09-19 21:14:35 +00009034 // OpenCL 1.1 6.5.2: "Variables allocated in the __local address space inside
9035 // a kernel function cannot be initialized."
9036 if (VDecl->getStorageClass() == SC_OpenCLWorkGroupLocal) {
9037 Diag(VDecl->getLocation(), diag::err_local_cant_init);
9038 VDecl->setInvalidDecl();
9039 return;
9040 }
9041
Steve Naroff61091402007-09-12 14:07:44 +00009042 // Get the decls type and save a reference for later, since
Steve Naroff98f72032008-01-10 22:15:12 +00009043 // CheckInitializerTypes may change it.
Steve Naroff437b4d82007-09-12 20:13:48 +00009044 QualType DclT = VDecl->getType(), SavT = DclT;
Fariborz Jahanianc8a322a2012-03-09 18:47:16 +00009045
Douglas Gregorb5af2e92013-03-07 22:57:58 +00009046 // Expressions default to 'id' when we're in a debugger
9047 // and we are assigning it to a variable of Objective-C pointer type.
9048 if (getLangOpts().DebuggerCastResultToId && DclT->isObjCObjectPointerType() &&
9049 Init->getType() == Context.UnknownAnyTy) {
9050 ExprResult Result = forceUnknownAnyToType(Init, Context.getObjCIdType());
9051 if (Result.isInvalid()) {
9052 VDecl->setInvalidDecl();
9053 return;
Fariborz Jahanianc8a322a2012-03-09 18:47:16 +00009054 }
Nikola Smiljanic01a75982014-05-29 10:55:11 +00009055 Init = Result.get();
Douglas Gregorb5af2e92013-03-07 22:57:58 +00009056 }
Richard Smith0cc85782011-12-15 19:20:59 +00009057
9058 // Perform the initialization.
9059 if (!VDecl->isInvalidDecl()) {
9060 InitializedEntity Entity = InitializedEntity::InitializeVariable(VDecl);
9061 InitializationKind Kind
Sebastian Redl5a41f682012-02-12 16:37:24 +00009062 = DirectInit ?
9063 CXXDirectInit ? InitializationKind::CreateDirect(VDecl->getLocation(),
9064 Init->getLocStart(),
9065 Init->getLocEnd())
9066 : InitializationKind::CreateDirectList(
9067 VDecl->getLocation())
Richard Smith0cc85782011-12-15 19:20:59 +00009068 : InitializationKind::CreateCopy(VDecl->getLocation(),
9069 Init->getLocStart());
9070
Dmitri Gribenko8f8930f2013-05-03 15:05:50 +00009071 MultiExprArg Args = Init;
9072 if (CXXDirectInit)
9073 Args = MultiExprArg(CXXDirectInit->getExprs(),
9074 CXXDirectInit->getNumExprs());
9075
Kaelyn Takata938204a2014-12-16 23:07:00 +00009076 // Try to correct any TypoExprs in the initialization arguments.
9077 for (size_t Idx = 0; Idx < Args.size(); ++Idx) {
Kaelyn Takatab8499f02015-05-05 19:17:03 +00009078 ExprResult Res = CorrectDelayedTyposInExpr(
9079 Args[Idx], VDecl, [this, Entity, Kind](Expr *E) {
Kaelyn Takata4c3ffc42014-11-21 18:48:00 +00009080 InitializationSequence Init(*this, Entity, Kind, MultiExprArg(E));
9081 return Init.Failed() ? ExprError() : E;
9082 });
9083 if (Res.isInvalid()) {
9084 VDecl->setInvalidDecl();
Kaelyn Takata21a88692015-01-21 00:04:19 +00009085 } else if (Res.get() != Args[Idx]) {
Kaelyn Takata938204a2014-12-16 23:07:00 +00009086 Args[Idx] = Res.get();
Kaelyn Takata21a88692015-01-21 00:04:19 +00009087 }
Kaelyn Takata4c3ffc42014-11-21 18:48:00 +00009088 }
Kaelyn Takata21a88692015-01-21 00:04:19 +00009089 if (VDecl->isInvalidDecl())
9090 return;
Kaelyn Takata4c3ffc42014-11-21 18:48:00 +00009091
Dmitri Gribenko8f8930f2013-05-03 15:05:50 +00009092 InitializationSequence InitSeq(*this, Entity, Kind, Args);
9093 ExprResult Result = InitSeq.Perform(*this, Entity, Kind, Args, &DclT);
Richard Smith0cc85782011-12-15 19:20:59 +00009094 if (Result.isInvalid()) {
Steve Naroff08899ff2008-04-15 22:42:06 +00009095 VDecl->setInvalidDecl();
Richard Smith0cc85782011-12-15 19:20:59 +00009096 return;
Steve Naroff61091402007-09-12 14:07:44 +00009097 }
Richard Smith0cc85782011-12-15 19:20:59 +00009098
Nikola Smiljanic01a75982014-05-29 10:55:11 +00009099 Init = Result.getAs<Expr>();
Richard Smith0cc85782011-12-15 19:20:59 +00009100 }
9101
Richard Trieu32673472012-10-01 17:39:51 +00009102 // Check for self-references within variable initializers.
9103 // Variables declared within a function/method body (except for references)
9104 // are handled by a dataflow analysis.
9105 if (!VDecl->hasLocalStorage() || VDecl->getType()->isRecordType() ||
9106 VDecl->getType()->isReferenceType()) {
9107 CheckSelfReference(*this, RealDecl, Init, DirectInit);
9108 }
9109
Richard Smith0cc85782011-12-15 19:20:59 +00009110 // If the type changed, it means we had an incomplete type that was
9111 // completed by the initializer. For example:
9112 // int ary[] = { 1, 3, 5 };
John McCalla59dc2f2012-01-05 00:13:19 +00009113 // "ary" transitions from an IncompleteArrayType to a ConstantArrayType.
Eli Friedman91f5ae52012-02-23 02:25:10 +00009114 if (!VDecl->isInvalidDecl() && (DclT != SavT))
Richard Smith0cc85782011-12-15 19:20:59 +00009115 VDecl->setType(DclT);
Richard Smith0cc85782011-12-15 19:20:59 +00009116
Jordan Rosefa9e4ba2012-09-15 02:48:31 +00009117 if (!VDecl->isInvalidDecl()) {
Richard Smith0cc85782011-12-15 19:20:59 +00009118 checkUnsafeAssigns(VDecl->getLocation(), VDecl->getType(), Init);
9119
Jordan Rosefa9e4ba2012-09-15 02:48:31 +00009120 if (VDecl->hasAttr<BlocksAttr>())
9121 checkRetainCycles(VDecl, Init);
Jordan Rosed3934582012-09-28 22:21:30 +00009122
9123 // It is safe to assign a weak reference into a strong variable.
9124 // Although this code can still have problems:
9125 // id x = self.weakProp;
9126 // id y = self.weakProp;
9127 // we do not warn to warn spuriously when 'x' and 'y' are on separate
9128 // paths through the function. This should be revisited if
9129 // -Wrepeated-use-of-weak is made flow-sensitive.
Alp Tokerd4a3f0e2014-06-15 23:30:39 +00009130 if (VDecl->getType().getObjCLifetime() == Qualifiers::OCL_Strong &&
9131 !Diags.isIgnored(diag::warn_arc_repeated_use_of_weak,
9132 Init->getLocStart()))
Jordan Rosed3934582012-09-28 22:21:30 +00009133 getCurFunction()->markSafeWeakUse(Init);
Jordan Rosefa9e4ba2012-09-15 02:48:31 +00009134 }
9135
Richard Smith945f8d32013-01-14 22:39:08 +00009136 // The initialization is usually a full-expression.
9137 //
9138 // FIXME: If this is a braced initialization of an aggregate, it is not
9139 // an expression, and each individual field initializer is a separate
9140 // full-expression. For instance, in:
9141 //
9142 // struct Temp { ~Temp(); };
9143 // struct S { S(Temp); };
9144 // struct T { S a, b; } t = { Temp(), Temp() }
9145 //
9146 // we should destroy the first Temp before constructing the second.
Fariborz Jahaniane735ff92013-01-24 22:11:45 +00009147 ExprResult Result = ActOnFinishFullExpr(Init, VDecl->getLocation(),
9148 false,
9149 VDecl->isConstexpr());
Richard Smith945f8d32013-01-14 22:39:08 +00009150 if (Result.isInvalid()) {
9151 VDecl->setInvalidDecl();
9152 return;
9153 }
Nikola Smiljanic01a75982014-05-29 10:55:11 +00009154 Init = Result.get();
Richard Smith945f8d32013-01-14 22:39:08 +00009155
Richard Smith0cc85782011-12-15 19:20:59 +00009156 // Attach the initializer to the decl.
9157 VDecl->setInit(Init);
9158
9159 if (VDecl->isLocalVarDecl()) {
9160 // C99 6.7.8p4: All the expressions in an initializer for an object that has
9161 // static storage duration shall be constant expressions or string literals.
9162 // C++ does not have this restriction.
Enea Zaffanella1aac5462013-07-22 10:58:26 +00009163 if (!getLangOpts().CPlusPlus && !VDecl->isInvalidDecl()) {
Abramo Bagnara847c6602014-05-22 19:20:46 +00009164 const Expr *Culprit;
Enea Zaffanella1aac5462013-07-22 10:58:26 +00009165 if (VDecl->getStorageClass() == SC_Static)
9166 CheckForConstantInitializer(Init, DclT);
9167 // C89 is stricter than C99 for non-static aggregate types.
9168 // C89 6.5.7p3: All the expressions [...] in an initializer list
9169 // for an object that has aggregate or union type shall be
9170 // constant expressions.
9171 else if (!getLangOpts().C99 && VDecl->getType()->isAggregateType() &&
Enea Zaffanellac7cb48c2013-07-22 19:10:20 +00009172 isa<InitListExpr>(Init) &&
Abramo Bagnara847c6602014-05-22 19:20:46 +00009173 !Init->isConstantInitializer(Context, false, &Culprit))
9174 Diag(Culprit->getExprLoc(),
Enea Zaffanella1aac5462013-07-22 10:58:26 +00009175 diag::ext_aggregate_init_not_constant)
Abramo Bagnara847c6602014-05-22 19:20:46 +00009176 << Culprit->getSourceRange();
Enea Zaffanella1aac5462013-07-22 10:58:26 +00009177 }
Mike Stump11289f42009-09-09 15:08:12 +00009178 } else if (VDecl->isStaticDataMember() &&
Douglas Gregor0c880302009-03-11 23:00:04 +00009179 VDecl->getLexicalDeclContext()->isRecord()) {
9180 // This is an in-class initialization for a static data member, e.g.,
9181 //
9182 // struct S {
9183 // static const int value = 17;
9184 // };
9185
Douglas Gregor0c880302009-03-11 23:00:04 +00009186 // C++ [class.mem]p4:
9187 // A member-declarator can contain a constant-initializer only
9188 // if it declares a static member (9.4) of const integral or
9189 // const enumeration type, see 9.4.2.
Richard Smith2316cd82011-09-29 19:11:37 +00009190 //
Richard Smith0cc85782011-12-15 19:20:59 +00009191 // C++11 [class.static.data]p3:
Richard Smith2316cd82011-09-29 19:11:37 +00009192 // If a non-volatile const static data member is of integral or
9193 // enumeration type, its declaration in the class definition can
9194 // specify a brace-or-equal-initializer in which every initalizer-clause
9195 // that is an assignment-expression is a constant expression. A static
9196 // data member of literal type can be declared in the class definition
9197 // with the constexpr specifier; if so, its declaration shall specify a
9198 // brace-or-equal-initializer in which every initializer-clause that is
9199 // an assignment-expression is a constant expression.
John McCalldb768922010-09-10 23:21:22 +00009200
9201 // Do nothing on dependent types.
Richard Smith0cc85782011-12-15 19:20:59 +00009202 if (DclT->isDependentType()) {
John McCalldb768922010-09-10 23:21:22 +00009203
Richard Smith2316cd82011-09-29 19:11:37 +00009204 // Allow any 'static constexpr' members, whether or not they are of literal
Richard Smith3607ffe2012-02-13 03:54:03 +00009205 // type. We separately check that every constexpr variable is of literal
9206 // type.
Richard Smith2316cd82011-09-29 19:11:37 +00009207 } else if (VDecl->isConstexpr()) {
9208
John McCalldb768922010-09-10 23:21:22 +00009209 // Require constness.
Richard Smith0cc85782011-12-15 19:20:59 +00009210 } else if (!DclT.isConstQualified()) {
John McCalldb768922010-09-10 23:21:22 +00009211 Diag(VDecl->getLocation(), diag::err_in_class_initializer_non_const)
9212 << Init->getSourceRange();
Douglas Gregor0c880302009-03-11 23:00:04 +00009213 VDecl->setInvalidDecl();
John McCalldb768922010-09-10 23:21:22 +00009214
9215 // We allow integer constant expressions in all cases.
Richard Smith0cc85782011-12-15 19:20:59 +00009216 } else if (DclT->isIntegralOrEnumerationType()) {
Chris Lattner9925ec82011-06-14 05:46:29 +00009217 // Check whether the expression is a constant expression.
9218 SourceLocation Loc;
Richard Smith2bf7fdb2013-01-02 11:42:31 +00009219 if (getLangOpts().CPlusPlus11 && DclT.isVolatileQualified())
Richard Smith0cc85782011-12-15 19:20:59 +00009220 // In C++11, a non-constexpr const static data member with an
Richard Smithee6311d2011-09-29 21:28:14 +00009221 // in-class initializer cannot be volatile.
9222 Diag(VDecl->getLocation(), diag::err_in_class_initializer_volatile);
9223 else if (Init->isValueDependent())
Chris Lattner9925ec82011-06-14 05:46:29 +00009224 ; // Nothing to check.
9225 else if (Init->isIntegerConstantExpr(Context, &Loc))
9226 ; // Ok, it's an ICE!
9227 else if (Init->isEvaluatable(Context)) {
9228 // If we can constant fold the initializer through heroics, accept it,
9229 // but report this as a use of an extension for -pedantic.
9230 Diag(Loc, diag::ext_in_class_initializer_non_constant)
9231 << Init->getSourceRange();
9232 } else {
9233 // Otherwise, this is some crazy unknown case. Report the issue at the
9234 // location provided by the isIntegerConstantExpr failed check.
9235 Diag(Loc, diag::err_in_class_initializer_non_constant)
9236 << Init->getSourceRange();
9237 VDecl->setInvalidDecl();
John McCalldb768922010-09-10 23:21:22 +00009238 }
9239
Richard Smith0cc85782011-12-15 19:20:59 +00009240 // We allow foldable floating-point constants as an extension.
9241 } else if (DclT->isFloatingType()) { // also permits complex, which is ok
Richard Smithcf656382013-01-25 04:22:16 +00009242 // In C++98, this is a GNU extension. In C++11, it is not, but we support
9243 // it anyway and provide a fixit to add the 'constexpr'.
9244 if (getLangOpts().CPlusPlus11) {
David Blaikie8505c292013-01-29 22:26:08 +00009245 Diag(VDecl->getLocation(),
9246 diag::ext_in_class_initializer_float_type_cxx11)
9247 << DclT << Init->getSourceRange();
9248 Diag(VDecl->getLocStart(),
9249 diag::note_in_class_initializer_float_type_cxx11)
9250 << FixItHint::CreateInsertion(VDecl->getLocStart(), "constexpr ");
Richard Smithcf656382013-01-25 04:22:16 +00009251 } else {
9252 Diag(VDecl->getLocation(), diag::ext_in_class_initializer_float_type)
9253 << DclT << Init->getSourceRange();
John McCalldb768922010-09-10 23:21:22 +00009254
Richard Smithcf656382013-01-25 04:22:16 +00009255 if (!Init->isValueDependent() && !Init->isEvaluatable(Context)) {
9256 Diag(Init->getExprLoc(), diag::err_in_class_initializer_non_constant)
9257 << Init->getSourceRange();
9258 VDecl->setInvalidDecl();
9259 }
Douglas Gregor0c880302009-03-11 23:00:04 +00009260 }
Richard Smith256336d2011-09-29 23:18:34 +00009261
Richard Smith0cc85782011-12-15 19:20:59 +00009262 // Suggest adding 'constexpr' in C++11 for literal types.
Richard Smithd9f663b2013-04-22 15:31:51 +00009263 } else if (getLangOpts().CPlusPlus11 && DclT->isLiteralType(Context)) {
Richard Smith256336d2011-09-29 23:18:34 +00009264 Diag(VDecl->getLocation(), diag::err_in_class_initializer_literal_type)
Richard Smith0cc85782011-12-15 19:20:59 +00009265 << DclT << Init->getSourceRange()
Richard Smith256336d2011-09-29 23:18:34 +00009266 << FixItHint::CreateInsertion(VDecl->getLocStart(), "constexpr ");
9267 VDecl->setConstexpr(true);
9268
Richard Smith2316cd82011-09-29 19:11:37 +00009269 } else {
9270 Diag(VDecl->getLocation(), diag::err_in_class_initializer_bad_type)
Richard Smith0cc85782011-12-15 19:20:59 +00009271 << DclT << Init->getSourceRange();
Richard Smith2316cd82011-09-29 19:11:37 +00009272 VDecl->setInvalidDecl();
Douglas Gregor0c880302009-03-11 23:00:04 +00009273 }
Steve Naroff08899ff2008-04-15 22:42:06 +00009274 } else if (VDecl->isFileVarDecl()) {
Rafael Espindola6ae7e502013-04-03 19:27:57 +00009275 if (VDecl->getStorageClass() == SC_Extern &&
David Blaikiebbafb8a2012-03-11 07:00:24 +00009276 (!getLangOpts().CPlusPlus ||
Rafael Espindola069ab032013-03-29 07:56:05 +00009277 !(Context.getBaseElementType(VDecl->getType()).isConstQualified() ||
Richard Smith8809a0c2013-09-27 20:14:12 +00009278 VDecl->isExternC())) &&
9279 !isTemplateInstantiation(VDecl->getTemplateSpecializationKind()))
Steve Naroff437b4d82007-09-12 20:13:48 +00009280 Diag(VDecl->getLocation(), diag::warn_extern_init);
Eli Friedman463e5232009-12-22 02:10:53 +00009281
Richard Smith0cc85782011-12-15 19:20:59 +00009282 // C99 6.7.8p4. All file scoped initializers need to be constant.
David Blaikiebbafb8a2012-03-11 07:00:24 +00009283 if (!getLangOpts().CPlusPlus && !VDecl->isInvalidDecl())
Anders Carlsson41e08812008-08-22 05:00:02 +00009284 CheckForConstantInitializer(Init, DclT);
Steve Naroff61091402007-09-12 14:07:44 +00009285 }
Douglas Gregorbeecd582009-04-21 17:11:58 +00009286
Sebastian Redla9351792012-02-11 23:51:47 +00009287 // We will represent direct-initialization similarly to copy-initialization:
9288 // int x(1); -as-> int x = 1;
9289 // ClassType x(a,b,c); -as-> ClassType x = ClassType(a,b,c);
9290 //
9291 // Clients that want to distinguish between the two forms, can check for
9292 // direct initializer using VarDecl::getInitStyle().
9293 // A major benefit is that clients that don't particularly care about which
9294 // exactly form was it (like the CodeGen) can handle both cases without
9295 // special case code.
9296
9297 // C++ 8.5p11:
9298 // The form of initialization (using parentheses or '=') is generally
9299 // insignificant, but does matter when the entity being initialized has a
9300 // class type.
9301 if (CXXDirectInit) {
9302 assert(DirectInit && "Call-style initializer must be direct init.");
9303 VDecl->setInitStyle(VarDecl::CallInit);
9304 } else if (DirectInit) {
9305 // This must be list-initialization. No other way is direct-initialization.
9306 VDecl->setInitStyle(VarDecl::ListInit);
9307 }
9308
John McCall8b7fd8f12011-01-19 11:48:09 +00009309 CheckCompleteVariableDeclaration(VDecl);
Steve Naroff61091402007-09-12 14:07:44 +00009310}
9311
John McCalleae5acb2010-03-31 02:13:20 +00009312/// ActOnInitializerError - Given that there was an error parsing an
9313/// initializer for the given declaration, try to return to some form
9314/// of sanity.
John McCall48871652010-08-21 09:40:31 +00009315void Sema::ActOnInitializerError(Decl *D) {
John McCalleae5acb2010-03-31 02:13:20 +00009316 // Our main concern here is re-establishing invariants like "a
9317 // variable's type is either dependent or complete".
John McCalleae5acb2010-03-31 02:13:20 +00009318 if (!D || D->isInvalidDecl()) return;
9319
9320 VarDecl *VD = dyn_cast<VarDecl>(D);
9321 if (!VD) return;
9322
Richard Smith30482bc2011-02-20 03:19:35 +00009323 // Auto types are meaningless if we can't make sense of the initializer.
Richard Smithb2bc2e62011-02-21 20:05:19 +00009324 if (ParsingInitForAutoVars.count(D)) {
9325 D->setInvalidDecl();
Richard Smith30482bc2011-02-20 03:19:35 +00009326 return;
9327 }
9328
John McCalleae5acb2010-03-31 02:13:20 +00009329 QualType Ty = VD->getType();
9330 if (Ty->isDependentType()) return;
9331
9332 // Require a complete type.
9333 if (RequireCompleteType(VD->getLocation(),
9334 Context.getBaseElementType(Ty),
9335 diag::err_typecheck_decl_incomplete_type)) {
9336 VD->setInvalidDecl();
9337 return;
9338 }
9339
Alp Toker48c7e172014-04-15 16:24:50 +00009340 // Require a non-abstract type.
John McCalleae5acb2010-03-31 02:13:20 +00009341 if (RequireNonAbstractType(VD->getLocation(), Ty,
9342 diag::err_abstract_type_in_decl,
9343 AbstractVariableType)) {
9344 VD->setInvalidDecl();
9345 return;
9346 }
9347
9348 // Don't bother complaining about constructors or destructors,
9349 // though.
9350}
9351
John McCall48871652010-08-21 09:40:31 +00009352void Sema::ActOnUninitializedDecl(Decl *RealDecl,
Richard Smith30482bc2011-02-20 03:19:35 +00009353 bool TypeMayContainAuto) {
Argyrios Kyrtzidis6709e7d2008-11-07 13:01:22 +00009354 // If there is no declaration, there was an error parsing it. Just ignore it.
Craig Topperc3ec1492014-05-26 06:22:03 +00009355 if (!RealDecl)
Argyrios Kyrtzidis6709e7d2008-11-07 13:01:22 +00009356 return;
9357
Douglas Gregor8e1cf602008-10-29 00:13:59 +00009358 if (VarDecl *Var = dyn_cast<VarDecl>(RealDecl)) {
9359 QualType Type = Var->getType();
Douglas Gregorbeecd582009-04-21 17:11:58 +00009360
Richard Smithf0215fe2011-12-25 21:17:58 +00009361 // C++11 [dcl.spec.auto]p3
Richard Smith30482bc2011-02-20 03:19:35 +00009362 if (TypeMayContainAuto && Type->getContainedAutoType()) {
Anders Carlssonae019932009-07-11 00:34:39 +00009363 Diag(Var->getLocation(), diag::err_auto_var_requires_init)
9364 << Var->getDeclName() << Type;
9365 Var->setInvalidDecl();
9366 return;
9367 }
Mike Stump11289f42009-09-09 15:08:12 +00009368
Richard Smithf0215fe2011-12-25 21:17:58 +00009369 // C++11 [class.static.data]p3: A static data member can be declared with
Richard Smith2316cd82011-09-29 19:11:37 +00009370 // the constexpr specifier; if so, its declaration shall specify
9371 // a brace-or-equal-initializer.
Richard Smithf0215fe2011-12-25 21:17:58 +00009372 // C++11 [dcl.constexpr]p1: The constexpr specifier shall be applied only to
9373 // the definition of a variable [...] or the declaration of a static data
9374 // member.
9375 if (Var->isConstexpr() && !Var->isThisDeclarationADefinition()) {
9376 if (Var->isStaticDataMember())
9377 Diag(Var->getLocation(),
9378 diag::err_constexpr_static_mem_var_requires_init)
9379 << Var->getDeclName();
9380 else
9381 Diag(Var->getLocation(), diag::err_invalid_constexpr_var_decl);
Richard Smith2316cd82011-09-29 19:11:37 +00009382 Var->setInvalidDecl();
9383 return;
9384 }
9385
Joey Gouly96b94e62014-01-03 14:16:55 +00009386 // OpenCL v1.1 s6.5.3: variables declared in the constant address space must
9387 // be initialized.
9388 if (!Var->isInvalidDecl() &&
9389 Var->getType().getAddressSpace() == LangAS::opencl_constant &&
Pekka Jaaskelainenb3cdee02014-01-23 16:21:02 +00009390 Var->getStorageClass() != SC_Extern && !Var->getInit()) {
Joey Gouly96b94e62014-01-03 14:16:55 +00009391 Diag(Var->getLocation(), diag::err_opencl_constant_no_init);
9392 Var->setInvalidDecl();
9393 return;
9394 }
9395
Douglas Gregore6565622010-02-09 07:26:29 +00009396 switch (Var->isThisDeclarationADefinition()) {
9397 case VarDecl::Definition:
9398 if (!Var->isStaticDataMember() || !Var->getAnyInitializer())
9399 break;
9400
9401 // We have an out-of-line definition of a static data member
9402 // that has an in-class initializer, so we type-check this like
9403 // a declaration.
9404 //
9405 // Fall through
9406
9407 case VarDecl::DeclarationOnly:
9408 // It's only a declaration.
9409
9410 // Block scope. C99 6.7p7: If an identifier for an object is
9411 // declared with no linkage (C99 6.2.2p6), the type for the
9412 // object shall be complete.
John McCall1c9c3fd2010-10-15 04:57:14 +00009413 if (!Type->isDependentType() && Var->isLocalVarDecl() &&
Rafael Espindola3ae00052013-05-13 00:12:11 +00009414 !Var->hasLinkage() && !Var->isInvalidDecl() &&
Douglas Gregore6565622010-02-09 07:26:29 +00009415 RequireCompleteType(Var->getLocation(), Type,
9416 diag::err_typecheck_decl_incomplete_type))
9417 Var->setInvalidDecl();
9418
9419 // Make sure that the type is not abstract.
9420 if (!Type->isDependentType() && !Var->isInvalidDecl() &&
9421 RequireNonAbstractType(Var->getLocation(), Type,
9422 diag::err_abstract_type_in_decl,
9423 AbstractVariableType))
9424 Var->setInvalidDecl();
Fariborz Jahanian05f4e712012-08-15 18:42:26 +00009425 if (!Type->isDependentType() && !Var->isInvalidDecl() &&
Fariborz Jahanianf85f3382012-08-17 21:44:55 +00009426 Var->getStorageClass() == SC_PrivateExtern) {
Fariborz Jahanian05f4e712012-08-15 18:42:26 +00009427 Diag(Var->getLocation(), diag::warn_private_extern);
Fariborz Jahanianf85f3382012-08-17 21:44:55 +00009428 Diag(Var->getLocation(), diag::note_private_extern);
9429 }
Fariborz Jahanian05f4e712012-08-15 18:42:26 +00009430
Douglas Gregore6565622010-02-09 07:26:29 +00009431 return;
9432
9433 case VarDecl::TentativeDefinition:
9434 // File scope. C99 6.9.2p2: A declaration of an identifier for an
9435 // object that has file scope without an initializer, and without a
9436 // storage-class specifier or with the storage-class specifier "static",
9437 // constitutes a tentative definition. Note: A tentative definition with
9438 // external linkage is valid (C99 6.2.2p5).
9439 if (!Var->isInvalidDecl()) {
9440 if (const IncompleteArrayType *ArrayT
9441 = Context.getAsIncompleteArrayType(Type)) {
9442 if (RequireCompleteType(Var->getLocation(),
9443 ArrayT->getElementType(),
9444 diag::err_illegal_decl_array_incomplete_type))
9445 Var->setInvalidDecl();
John McCall8e7d6562010-08-26 03:08:43 +00009446 } else if (Var->getStorageClass() == SC_Static) {
Douglas Gregore6565622010-02-09 07:26:29 +00009447 // C99 6.9.2p3: If the declaration of an identifier for an object is
9448 // a tentative definition and has internal linkage (C99 6.2.2p3), the
9449 // declared type shall not be an incomplete type.
9450 // NOTE: code such as the following
9451 // static struct s;
9452 // struct s { int a; };
9453 // is accepted by gcc. Hence here we issue a warning instead of
9454 // an error and we do not invalidate the static declaration.
9455 // NOTE: to avoid multiple warnings, only check the first declaration.
Rafael Espindola3f9e4442013-10-19 02:13:21 +00009456 if (Var->isFirstDecl())
Douglas Gregore6565622010-02-09 07:26:29 +00009457 RequireCompleteType(Var->getLocation(), Type,
9458 diag::ext_typecheck_decl_incomplete_type);
9459 }
9460 }
9461
9462 // Record the tentative definition; we're done.
9463 if (!Var->isInvalidDecl())
9464 TentativeDefinitions.push_back(Var);
9465 return;
9466 }
9467
9468 // Provide a specific diagnostic for uninitialized variable
9469 // definitions with incomplete array type.
9470 if (Type->isIncompleteArrayType()) {
Sebastian Redl10600672009-11-05 19:47:47 +00009471 Diag(Var->getLocation(),
9472 diag::err_typecheck_incomplete_array_needs_initializer);
9473 Var->setInvalidDecl();
9474 return;
9475 }
9476
John McCalla755f0f2010-08-01 01:25:24 +00009477 // Provide a specific diagnostic for uninitialized variable
9478 // definitions with reference type.
9479 if (Type->isReferenceType()) {
9480 Diag(Var->getLocation(), diag::err_reference_var_requires_init)
9481 << Var->getDeclName()
9482 << SourceRange(Var->getLocation(), Var->getLocation());
9483 Var->setInvalidDecl();
9484 return;
9485 }
Douglas Gregore6565622010-02-09 07:26:29 +00009486
9487 // Do not attempt to type-check the default initializer for a
9488 // variable with dependent type.
9489 if (Type->isDependentType())
Douglas Gregor86d142a2009-10-08 07:24:58 +00009490 return;
Douglas Gregor5d3507d2009-09-09 23:08:42 +00009491
Douglas Gregore6565622010-02-09 07:26:29 +00009492 if (Var->isInvalidDecl())
9493 return;
Douglas Gregorc99f1552009-12-03 18:33:45 +00009494
David Majnemer837d5de2014-07-09 17:15:52 +00009495 if (!Var->hasAttr<AliasAttr>()) {
9496 if (RequireCompleteType(Var->getLocation(),
9497 Context.getBaseElementType(Type),
9498 diag::err_typecheck_decl_incomplete_type)) {
9499 Var->setInvalidDecl();
9500 return;
9501 }
David Majnemere9624ed2015-02-08 10:55:14 +00009502 } else {
9503 return;
Douglas Gregorc28b57d2008-11-03 20:45:27 +00009504 }
Douglas Gregor8e1cf602008-10-29 00:13:59 +00009505
Douglas Gregore6565622010-02-09 07:26:29 +00009506 // The variable can not have an abstract class type.
9507 if (RequireNonAbstractType(Var->getLocation(), Type,
9508 diag::err_abstract_type_in_decl,
9509 AbstractVariableType)) {
9510 Var->setInvalidDecl();
9511 return;
9512 }
9513
Douglas Gregor9574af62011-05-21 17:52:48 +00009514 // Check for jumps past the implicit initializer. C++0x
9515 // clarifies that this applies to a "variable with automatic
9516 // storage duration", not a "local variable".
Richard Smithfe2750d2011-10-20 21:42:12 +00009517 // C++11 [stmt.dcl]p3
Douglas Gregor9574af62011-05-21 17:52:48 +00009518 // A program that jumps from a point where a variable with automatic
9519 // storage duration is not in scope to a point where it is in scope is
9520 // ill-formed unless the variable has scalar type, class type with a
9521 // trivial default constructor and a trivial destructor, a cv-qualified
9522 // version of one of these types, or an array of one of the preceding
9523 // types and is declared without an initializer.
David Blaikiebbafb8a2012-03-11 07:00:24 +00009524 if (getLangOpts().CPlusPlus && Var->hasLocalStorage()) {
Douglas Gregor9574af62011-05-21 17:52:48 +00009525 if (const RecordType *Record
9526 = Context.getBaseElementType(Type)->getAs<RecordType>()) {
Alexis Hunt466627c2011-05-11 22:50:12 +00009527 CXXRecordDecl *CXXRecord = cast<CXXRecordDecl>(Record->getDecl());
Richard Smithfe2750d2011-10-20 21:42:12 +00009528 // Mark the function for further checking even if the looser rules of
9529 // C++11 do not require such checks, so that we can diagnose
9530 // incompatibilities with C++98.
9531 if (!CXXRecord->isPOD())
Alexis Hunt466627c2011-05-11 22:50:12 +00009532 getCurFunction()->setHasBranchProtectedScope();
9533 }
Douglas Gregore6565622010-02-09 07:26:29 +00009534 }
Douglas Gregor9574af62011-05-21 17:52:48 +00009535
9536 // C++03 [dcl.init]p9:
9537 // If no initializer is specified for an object, and the
9538 // object is of (possibly cv-qualified) non-POD class type (or
9539 // array thereof), the object shall be default-initialized; if
9540 // the object is of const-qualified type, the underlying class
9541 // type shall have a user-declared default
9542 // constructor. Otherwise, if no initializer is specified for
9543 // a non- static object, the object and its subobjects, if
9544 // any, have an indeterminate initial value); if the object
9545 // or any of its subobjects are of const-qualified type, the
9546 // program is ill-formed.
9547 // C++0x [dcl.init]p11:
9548 // If no initializer is specified for an object, the object is
9549 // default-initialized; [...].
9550 InitializedEntity Entity = InitializedEntity::InitializeVariable(Var);
9551 InitializationKind Kind
9552 = InitializationKind::CreateDefault(Var->getLocation());
Dmitri Gribenko78852e92013-05-05 20:40:26 +00009553
9554 InitializationSequence InitSeq(*this, Entity, Kind, None);
9555 ExprResult Init = InitSeq.Perform(*this, Entity, Kind, None);
Douglas Gregor9574af62011-05-21 17:52:48 +00009556 if (Init.isInvalid())
9557 Var->setInvalidDecl();
Sebastian Redla9351792012-02-11 23:51:47 +00009558 else if (Init.get()) {
Douglas Gregor9574af62011-05-21 17:52:48 +00009559 Var->setInit(MaybeCreateExprWithCleanups(Init.get()));
Sebastian Redla9351792012-02-11 23:51:47 +00009560 // This is important for template substitution.
9561 Var->setInitStyle(VarDecl::CallInit);
9562 }
Douglas Gregor589973b2010-03-08 02:45:10 +00009563
John McCall8b7fd8f12011-01-19 11:48:09 +00009564 CheckCompleteVariableDeclaration(Var);
Douglas Gregor8e1cf602008-10-29 00:13:59 +00009565 }
9566}
9567
Richard Smith02e85f32011-04-14 22:09:26 +00009568void Sema::ActOnCXXForRangeDecl(Decl *D) {
9569 VarDecl *VD = dyn_cast<VarDecl>(D);
9570 if (!VD) {
9571 Diag(D->getLocation(), diag::err_for_range_decl_must_be_var);
9572 D->setInvalidDecl();
9573 return;
9574 }
9575
9576 VD->setCXXForRangeDecl(true);
9577
9578 // for-range-declaration cannot be given a storage class specifier.
9579 int Error = -1;
Rafael Espindola6ae7e502013-04-03 19:27:57 +00009580 switch (VD->getStorageClass()) {
Richard Smith02e85f32011-04-14 22:09:26 +00009581 case SC_None:
9582 break;
9583 case SC_Extern:
9584 Error = 0;
9585 break;
9586 case SC_Static:
9587 Error = 1;
9588 break;
9589 case SC_PrivateExtern:
9590 Error = 2;
9591 break;
9592 case SC_Auto:
9593 Error = 3;
9594 break;
9595 case SC_Register:
9596 Error = 4;
9597 break;
Peter Collingbourne2dbb7082011-09-19 21:14:35 +00009598 case SC_OpenCLWorkGroupLocal:
Peter Collingbourne9a8f1532011-09-20 12:40:26 +00009599 llvm_unreachable("Unexpected storage class");
Richard Smith02e85f32011-04-14 22:09:26 +00009600 }
Richard Smith02e85f32011-04-14 22:09:26 +00009601 if (Error != -1) {
9602 Diag(VD->getOuterLocStart(), diag::err_for_range_storage_class)
9603 << VD->getDeclName() << Error;
9604 D->setInvalidDecl();
9605 }
9606}
9607
Richard Smith955bf012014-06-19 11:42:00 +00009608StmtResult
9609Sema::ActOnCXXForRangeIdentifier(Scope *S, SourceLocation IdentLoc,
9610 IdentifierInfo *Ident,
9611 ParsedAttributes &Attrs,
9612 SourceLocation AttrEnd) {
9613 // C++1y [stmt.iter]p1:
9614 // A range-based for statement of the form
9615 // for ( for-range-identifier : for-range-initializer ) statement
9616 // is equivalent to
9617 // for ( auto&& for-range-identifier : for-range-initializer ) statement
9618 DeclSpec DS(Attrs.getPool().getFactory());
9619
9620 const char *PrevSpec;
9621 unsigned DiagID;
9622 DS.SetTypeSpecType(DeclSpec::TST_auto, IdentLoc, PrevSpec, DiagID,
9623 getPrintingPolicy());
9624
9625 Declarator D(DS, Declarator::ForContext);
9626 D.SetIdentifier(Ident, IdentLoc);
9627 D.takeAttributes(Attrs, AttrEnd);
9628
9629 ParsedAttributes EmptyAttrs(Attrs.getPool().getFactory());
9630 D.AddTypeInfo(DeclaratorChunk::getReference(0, IdentLoc, /*lvalue*/false),
9631 EmptyAttrs, IdentLoc);
9632 Decl *Var = ActOnDeclarator(S, D);
9633 cast<VarDecl>(Var)->setCXXForRangeDecl(true);
9634 FinalizeDeclaration(Var);
9635 return ActOnDeclStmt(FinalizeDeclaratorGroup(S, DS, Var), IdentLoc,
9636 AttrEnd.isValid() ? AttrEnd : IdentLoc);
9637}
9638
John McCall8b7fd8f12011-01-19 11:48:09 +00009639void Sema::CheckCompleteVariableDeclaration(VarDecl *var) {
9640 if (var->isInvalidDecl()) return;
9641
John McCall31168b02011-06-15 23:02:42 +00009642 // In ARC, don't allow jumps past the implicit initialization of a
9643 // local retaining variable.
David Blaikiebbafb8a2012-03-11 07:00:24 +00009644 if (getLangOpts().ObjCAutoRefCount &&
John McCall31168b02011-06-15 23:02:42 +00009645 var->hasLocalStorage()) {
9646 switch (var->getType().getObjCLifetime()) {
9647 case Qualifiers::OCL_None:
9648 case Qualifiers::OCL_ExplicitNone:
9649 case Qualifiers::OCL_Autoreleasing:
9650 break;
9651
9652 case Qualifiers::OCL_Weak:
9653 case Qualifiers::OCL_Strong:
9654 getCurFunction()->setHasBranchProtectedScope();
9655 break;
9656 }
9657 }
9658
John McCall8a4e2e42014-01-29 08:33:09 +00009659 // Warn about externally-visible variables being defined without a
9660 // prior declaration. We only want to do this for global
9661 // declarations, but we also specifically need to avoid doing it for
9662 // class members because the linkage of an anonymous class can
9663 // change if it's later given a typedef name.
Eli Friedman7d14b3c2012-10-23 20:19:32 +00009664 if (var->isThisDeclarationADefinition() &&
John McCall8a4e2e42014-01-29 08:33:09 +00009665 var->getDeclContext()->getRedeclContext()->isFileContext() &&
Eli Friedman1f5d8882013-09-24 23:10:08 +00009666 var->isExternallyVisible() && var->hasLinkage() &&
Alp Tokerd4a3f0e2014-06-15 23:30:39 +00009667 !getDiagnostics().isIgnored(diag::warn_missing_variable_declarations,
9668 var->getLocation())) {
Eli Friedman7d14b3c2012-10-23 20:19:32 +00009669 // Find a previous declaration that's not a definition.
9670 VarDecl *prev = var->getPreviousDecl();
9671 while (prev && prev->isThisDeclarationADefinition())
9672 prev = prev->getPreviousDecl();
9673
9674 if (!prev)
9675 Diag(var->getLocation(), diag::warn_missing_variable_declarations) << var;
9676 }
9677
Reid Kleckner92fc0172014-04-30 17:10:18 +00009678 if (var->getTLSKind() == VarDecl::TLS_Static) {
Abramo Bagnara847c6602014-05-22 19:20:46 +00009679 const Expr *Culprit;
Reid Kleckner92fc0172014-04-30 17:10:18 +00009680 if (var->getType().isDestructedType()) {
9681 // GNU C++98 edits for __thread, [basic.start.term]p3:
9682 // The type of an object with thread storage duration shall not
9683 // have a non-trivial destructor.
9684 Diag(var->getLocation(), diag::err_thread_nontrivial_dtor);
9685 if (getLangOpts().CPlusPlus11)
9686 Diag(var->getLocation(), diag::note_use_thread_local);
9687 } else if (getLangOpts().CPlusPlus && var->hasInit() &&
9688 !var->getInit()->isConstantInitializer(
Abramo Bagnara847c6602014-05-22 19:20:46 +00009689 Context, var->getType()->isReferenceType(), &Culprit)) {
Reid Kleckner92fc0172014-04-30 17:10:18 +00009690 // GNU C++98 edits for __thread, [basic.start.init]p4:
9691 // An object of thread storage duration shall not require dynamic
9692 // initialization.
9693 // FIXME: Need strict checking here.
Abramo Bagnara847c6602014-05-22 19:20:46 +00009694 Diag(Culprit->getExprLoc(), diag::err_thread_dynamic_init)
9695 << Culprit->getSourceRange();
Reid Kleckner92fc0172014-04-30 17:10:18 +00009696 if (getLangOpts().CPlusPlus11)
9697 Diag(var->getLocation(), diag::note_use_thread_local);
9698 }
9699
Richard Smith6ea1a4d2013-04-14 20:11:31 +00009700 }
9701
Reid Kleckner2a133222015-03-04 23:39:17 +00009702 // Apply section attributes and pragmas to global variables.
9703 bool GlobalStorage = var->hasGlobalStorage();
9704 if (GlobalStorage && var->isThisDeclarationADefinition() &&
Warren Huntc3b18962014-04-08 22:30:47 +00009705 ActiveTemplateInstantiations.empty()) {
9706 PragmaStack<StringLiteral *> *Stack = nullptr;
Hans Wennborg899ded92014-10-16 20:52:46 +00009707 int SectionFlags = ASTContext::PSF_Implicit | ASTContext::PSF_Read;
Warren Huntc3b18962014-04-08 22:30:47 +00009708 if (var->getType().isConstQualified())
9709 Stack = &ConstSegStack;
9710 else if (!var->getInit()) {
9711 Stack = &BSSSegStack;
Hans Wennborg899ded92014-10-16 20:52:46 +00009712 SectionFlags |= ASTContext::PSF_Write;
Warren Huntc3b18962014-04-08 22:30:47 +00009713 } else {
9714 Stack = &DataSegStack;
Hans Wennborg899ded92014-10-16 20:52:46 +00009715 SectionFlags |= ASTContext::PSF_Write;
Warren Huntc3b18962014-04-08 22:30:47 +00009716 }
Reid Kleckner2a133222015-03-04 23:39:17 +00009717 if (Stack->CurrentValue && !var->hasAttr<SectionAttr>()) {
9718 var->addAttr(SectionAttr::CreateImplicit(
9719 Context, SectionAttr::Declspec_allocate,
9720 Stack->CurrentValue->getString(), Stack->CurrentPragmaLocation));
9721 }
Warren Huntc3b18962014-04-08 22:30:47 +00009722 if (const SectionAttr *SA = var->getAttr<SectionAttr>())
9723 if (UnifySection(SA->getName(), SectionFlags, var))
9724 var->dropAttr<SectionAttr>();
Reid Kleckner1a711b12014-07-22 00:53:05 +00009725
9726 // Apply the init_seg attribute if this has an initializer. If the
9727 // initializer turns out to not be dynamic, we'll end up ignoring this
9728 // attribute.
9729 if (CurInitSeg && var->getInit())
9730 var->addAttr(InitSegAttr::CreateImplicit(Context, CurInitSeg->getString(),
9731 CurInitSegLoc));
Warren Huntc3b18962014-04-08 22:30:47 +00009732 }
9733
John McCall8b7fd8f12011-01-19 11:48:09 +00009734 // All the following checks are C++ only.
David Blaikiebbafb8a2012-03-11 07:00:24 +00009735 if (!getLangOpts().CPlusPlus) return;
John McCall8b7fd8f12011-01-19 11:48:09 +00009736
Richard Smithde63d362012-11-09 23:03:14 +00009737 QualType type = var->getType();
9738 if (type->isDependentType()) return;
John McCall8b7fd8f12011-01-19 11:48:09 +00009739
9740 // __block variables might require us to capture a copy-initializer.
9741 if (var->hasAttr<BlocksAttr>()) {
9742 // It's currently invalid to ever have a __block variable with an
9743 // array type; should we diagnose that here?
9744
9745 // Regardless, we don't want to ignore array nesting when
9746 // constructing this copy.
John McCall8b7fd8f12011-01-19 11:48:09 +00009747 if (type->isStructureOrClassType()) {
John McCalleaef89b2013-03-22 02:10:40 +00009748 EnterExpressionEvaluationContext scope(*this, PotentiallyEvaluated);
John McCall8b7fd8f12011-01-19 11:48:09 +00009749 SourceLocation poi = var->getLocation();
John McCall113bee02012-03-10 09:33:50 +00009750 Expr *varRef =new (Context) DeclRefExpr(var, false, type, VK_LValue, poi);
Douglas Gregorca006452013-03-07 22:38:24 +00009751 ExprResult result
9752 = PerformMoveOrCopyInitialization(
9753 InitializedEntity::InitializeBlock(poi, type, false),
9754 var, var->getType(), varRef, /*AllowNRVO=*/true);
John McCall8b7fd8f12011-01-19 11:48:09 +00009755 if (!result.isInvalid()) {
9756 result = MaybeCreateExprWithCleanups(result);
Nikola Smiljanic01a75982014-05-29 10:55:11 +00009757 Expr *init = result.getAs<Expr>();
John McCall8b7fd8f12011-01-19 11:48:09 +00009758 Context.setBlockVarCopyInits(var, init);
9759 }
9760 }
9761 }
9762
Richard Smitheda3c842011-11-07 22:16:17 +00009763 Expr *Init = var->getInit();
Reid Kleckner2a133222015-03-04 23:39:17 +00009764 bool IsGlobal = GlobalStorage && !var->isStaticLocal();
Richard Smithde63d362012-11-09 23:03:14 +00009765 QualType baseType = Context.getBaseElementType(type);
Richard Smitheda3c842011-11-07 22:16:17 +00009766
Richard Smithbf830092012-10-29 18:26:47 +00009767 if (!var->getDeclContext()->isDependentContext() &&
9768 Init && !Init->isValueDependent()) {
Richard Smithd0b4dd62011-12-19 06:19:21 +00009769 if (IsGlobal && !var->isConstexpr() &&
Alp Tokerd4a3f0e2014-06-15 23:30:39 +00009770 !getDiagnostics().isIgnored(diag::warn_global_constructor,
9771 var->getLocation())) {
Eli Friedman4c27ac22013-07-16 22:40:53 +00009772 // Warn about globals which don't have a constant initializer. Don't
9773 // warn about globals with a non-trivial destructor because we already
9774 // warned about them.
9775 CXXRecordDecl *RD = baseType->getAsCXXRecordDecl();
9776 if (!(RD && !RD->hasTrivialDestructor()) &&
9777 !Init->isConstantInitializer(Context, baseType->isReferenceType()))
9778 Diag(var->getLocation(), diag::warn_global_constructor)
9779 << Init->getSourceRange();
9780 }
Richard Smithd0b4dd62011-12-19 06:19:21 +00009781
Richard Smithd0b4dd62011-12-19 06:19:21 +00009782 if (var->isConstexpr()) {
Dmitri Gribenkof8579502013-01-12 19:30:44 +00009783 SmallVector<PartialDiagnosticAt, 8> Notes;
Richard Smithd0b4dd62011-12-19 06:19:21 +00009784 if (!var->evaluateValue(Notes) || !var->isInitICE()) {
9785 SourceLocation DiagLoc = var->getLocation();
9786 // If the note doesn't add any useful information other than a source
9787 // location, fold it into the primary diagnostic.
9788 if (Notes.size() == 1 && Notes[0].second.getDiagID() ==
9789 diag::note_invalid_subexpr_in_const_expr) {
9790 DiagLoc = Notes[0].first;
9791 Notes.clear();
9792 }
9793 Diag(DiagLoc, diag::err_constexpr_var_requires_const_init)
9794 << var << Init->getSourceRange();
9795 for (unsigned I = 0, N = Notes.size(); I != N; ++I)
9796 Diag(Notes[I].first, Notes[I].second);
9797 }
Daniel Dunbar9d355812012-03-09 01:51:51 +00009798 } else if (var->isUsableInConstantExpressions(Context)) {
Richard Smithd0b4dd62011-12-19 06:19:21 +00009799 // Check whether the initializer of a const variable of integral or
9800 // enumeration type is an ICE now, since we can't tell whether it was
9801 // initialized by a constant expression if we check later.
9802 var->checkInitIsICE();
9803 }
Richard Smitheda3c842011-11-07 22:16:17 +00009804 }
John McCall8b7fd8f12011-01-19 11:48:09 +00009805
9806 // Require the destructor.
9807 if (const RecordType *recordType = baseType->getAs<RecordType>())
9808 FinalizeVarWithDestructor(var, recordType);
9809}
9810
Richard Smithb2bc2e62011-02-21 20:05:19 +00009811/// FinalizeDeclaration - called by ParseDeclarationAfterDeclarator to perform
9812/// any semantic actions necessary after any initializer has been attached.
9813void
9814Sema::FinalizeDeclaration(Decl *ThisDecl) {
9815 // Note that we are no longer parsing the initializer for this declaration.
9816 ParsingInitForAutoVars.erase(ThisDecl);
Dmitri Gribenkoe4a5a902012-08-17 00:08:38 +00009817
Rafael Espindoladb1a4772013-02-22 17:59:16 +00009818 VarDecl *VD = dyn_cast_or_null<VarDecl>(ThisDecl);
Rafael Espindola60470f12013-01-03 04:05:19 +00009819 if (!VD)
9820 return;
9821
Nico Rieckf8e8b5f2014-01-21 23:54:36 +00009822 checkAttributesAfterMerging(*this, *VD);
9823
Hans Wennborgef2272c2014-06-18 15:55:13 +00009824 // Static locals inherit dll attributes from their function.
9825 if (VD->isStaticLocal()) {
9826 if (FunctionDecl *FD =
Richard Trieuf98341e2014-08-22 01:16:44 +00009827 dyn_cast_or_null<FunctionDecl>(VD->getParentFunctionOrMethod())) {
Hans Wennborgef2272c2014-06-18 15:55:13 +00009828 if (Attr *A = getDLLAttr(FD)) {
9829 auto *NewAttr = cast<InheritableAttr>(A->clone(getASTContext()));
9830 NewAttr->setInherited(true);
9831 VD->addAttr(NewAttr);
9832 }
9833 }
9834 }
9835
David Majnemer5da21da2014-10-04 06:51:54 +00009836 // Grab the dllimport or dllexport attribute off of the VarDecl.
9837 const InheritableAttr *DLLAttr = getDLLAttr(VD);
9838
Nico Rieck078d2f82014-05-29 16:50:20 +00009839 // Imported static data members cannot be defined out-of-line.
David Majnemer5da21da2014-10-04 06:51:54 +00009840 if (const auto *IA = dyn_cast_or_null<DLLImportAttr>(DLLAttr)) {
Nico Rieck078d2f82014-05-29 16:50:20 +00009841 if (VD->isStaticDataMember() && VD->isOutOfLine() &&
9842 VD->isThisDeclarationADefinition()) {
Hans Wennborge9af3162014-06-04 00:18:41 +00009843 // We allow definitions of dllimport class template static data members
9844 // with a warning.
Hans Wennborgcd959222014-06-09 18:30:28 +00009845 CXXRecordDecl *Context =
9846 cast<CXXRecordDecl>(VD->getFirstDecl()->getDeclContext());
Hans Wennborge9af3162014-06-04 00:18:41 +00009847 bool IsClassTemplateMember =
Hans Wennborgcd959222014-06-09 18:30:28 +00009848 isa<ClassTemplatePartialSpecializationDecl>(Context) ||
9849 Context->getDescribedClassTemplate();
Hans Wennborge9af3162014-06-04 00:18:41 +00009850
Nico Rieck078d2f82014-05-29 16:50:20 +00009851 Diag(VD->getLocation(),
Hans Wennborge9af3162014-06-04 00:18:41 +00009852 IsClassTemplateMember
9853 ? diag::warn_attribute_dllimport_static_field_definition
9854 : diag::err_attribute_dllimport_static_field_definition);
Nico Rieck078d2f82014-05-29 16:50:20 +00009855 Diag(IA->getLocation(), diag::note_attribute);
Hans Wennborge9af3162014-06-04 00:18:41 +00009856 if (!IsClassTemplateMember)
9857 VD->setInvalidDecl();
Nico Rieck078d2f82014-05-29 16:50:20 +00009858 }
9859 }
9860
David Majnemer5da21da2014-10-04 06:51:54 +00009861 // dllimport/dllexport variables cannot be thread local, their TLS index
9862 // isn't exported with the variable.
9863 if (DLLAttr && VD->getTLSKind()) {
9864 Diag(VD->getLocation(), diag::err_attribute_dll_thread_local) << VD
9865 << DLLAttr;
9866 VD->setInvalidDecl();
9867 }
9868
Rafael Espindola87198cd2013-08-16 23:18:50 +00009869 if (UsedAttr *Attr = VD->getAttr<UsedAttr>()) {
9870 if (!Attr->isInherited() && !VD->isThisDeclarationADefinition()) {
Aaron Ballman3e424b52013-12-26 18:30:57 +00009871 Diag(Attr->getLocation(), diag::warn_attribute_ignored) << Attr;
Rafael Espindola87198cd2013-08-16 23:18:50 +00009872 VD->dropAttr<UsedAttr>();
9873 }
9874 }
9875
Rafael Espindoladb1a4772013-02-22 17:59:16 +00009876 const DeclContext *DC = VD->getDeclContext();
9877 // If there's a #pragma GCC visibility in scope, and this isn't a class
9878 // member, set the visibility of this variable.
John McCall8a4e2e42014-01-29 08:33:09 +00009879 if (DC->getRedeclContext()->isFileContext() && VD->isExternallyVisible())
Rafael Espindoladb1a4772013-02-22 17:59:16 +00009880 AddPushedVisibilityAttribute(VD);
9881
Richard Smithc3926172014-04-02 18:28:36 +00009882 // FIXME: Warn on unused templates.
Richard Smith6c6ef822014-04-25 19:21:40 +00009883 if (VD->isFileVarDecl() && !VD->getDescribedVarTemplate() &&
9884 !isa<VarTemplatePartialSpecializationDecl>(VD))
Rafael Espindolad2ecc132013-01-03 04:29:20 +00009885 MarkUnusedFileScopedDecl(VD);
9886
Dmitri Gribenkoe4a5a902012-08-17 00:08:38 +00009887 // Now we have parsed the initializer and can update the table of magic
9888 // tag values.
Rafael Espindola60470f12013-01-03 04:05:19 +00009889 if (!VD->hasAttr<TypeTagForDatatypeAttr>() ||
9890 !VD->getType()->isIntegralOrEnumerationType())
9891 return;
9892
Aaron Ballmanbe22bcb2014-03-10 17:08:28 +00009893 for (const auto *I : ThisDecl->specific_attrs<TypeTagForDatatypeAttr>()) {
Rafael Espindola60470f12013-01-03 04:05:19 +00009894 const Expr *MagicValueExpr = VD->getInit();
9895 if (!MagicValueExpr) {
9896 continue;
Dmitri Gribenkoe4a5a902012-08-17 00:08:38 +00009897 }
Rafael Espindola60470f12013-01-03 04:05:19 +00009898 llvm::APSInt MagicValueInt;
9899 if (!MagicValueExpr->isIntegerConstantExpr(MagicValueInt, Context)) {
9900 Diag(I->getRange().getBegin(),
9901 diag::err_type_tag_for_datatype_not_ice)
9902 << LangOpts.CPlusPlus << MagicValueExpr->getSourceRange();
9903 continue;
9904 }
9905 if (MagicValueInt.getActiveBits() > 64) {
9906 Diag(I->getRange().getBegin(),
9907 diag::err_type_tag_for_datatype_too_large)
9908 << LangOpts.CPlusPlus << MagicValueExpr->getSourceRange();
9909 continue;
9910 }
9911 uint64_t MagicValue = MagicValueInt.getZExtValue();
9912 RegisterTypeTagForDatatype(I->getArgumentKind(),
9913 MagicValue,
9914 I->getMatchingCType(),
9915 I->getLayoutCompatible(),
9916 I->getMustBeNull());
Dmitri Gribenkoe4a5a902012-08-17 00:08:38 +00009917 }
Richard Smithb2bc2e62011-02-21 20:05:19 +00009918}
9919
Rafael Espindolaab417692013-07-09 12:05:01 +00009920Sema::DeclGroupPtrTy Sema::FinalizeDeclaratorGroup(Scope *S, const DeclSpec &DS,
9921 ArrayRef<Decl *> Group) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00009922 SmallVector<Decl*, 8> Decls;
Eli Friedman55b9ecb2009-05-29 01:49:24 +00009923
9924 if (DS.isTypeSpecOwned())
John McCallba7bf592010-08-24 05:47:05 +00009925 Decls.push_back(DS.getRepAsDecl());
Eli Friedman55b9ecb2009-05-29 01:49:24 +00009926
Craig Topperc3ec1492014-05-26 06:22:03 +00009927 DeclaratorDecl *FirstDeclaratorInGroup = nullptr;
Rafael Espindolaab417692013-07-09 12:05:01 +00009928 for (unsigned i = 0, e = Group.size(); i != e; ++i)
David Majnemer50ce8352013-09-17 23:57:10 +00009929 if (Decl *D = Group[i]) {
9930 if (DeclaratorDecl *DD = dyn_cast<DeclaratorDecl>(D))
9931 if (!FirstDeclaratorInGroup)
9932 FirstDeclaratorInGroup = DD;
Richard Smith2abf6762011-02-23 00:37:57 +00009933 Decls.push_back(D);
David Majnemer50ce8352013-09-17 23:57:10 +00009934 }
Richard Smith2abf6762011-02-23 00:37:57 +00009935
Eli Friedman3b7d46c2013-07-10 00:30:46 +00009936 if (DeclSpec::isDeclRep(DS.getTypeSpecType())) {
David Majnemer50ce8352013-09-17 23:57:10 +00009937 if (TagDecl *Tag = dyn_cast_or_null<TagDecl>(DS.getRepAsDecl())) {
David Majnemerf9bde282015-03-11 06:45:39 +00009938 handleTagNumbering(Tag, S);
David Majnemer50ce8352013-09-17 23:57:10 +00009939 if (!Tag->hasNameForLinkage() && !Tag->hasDeclaratorForAnonDecl())
9940 Tag->setDeclaratorForAnonDecl(FirstDeclaratorInGroup);
9941 }
Eli Friedman3b7d46c2013-07-10 00:30:46 +00009942 }
David Blaikie095deba2012-11-14 01:52:05 +00009943
Rafael Espindolaab417692013-07-09 12:05:01 +00009944 return BuildDeclaratorGroup(Decls, DS.containsPlaceholderType());
Richard Smith2abf6762011-02-23 00:37:57 +00009945}
9946
9947/// BuildDeclaratorGroup - convert a list of declarations into a declaration
9948/// group, performing any necessary semantic checking.
9949Sema::DeclGroupPtrTy
Craig Toppere3d2ecbe2014-06-28 23:22:33 +00009950Sema::BuildDeclaratorGroup(MutableArrayRef<Decl *> Group,
Richard Smith2abf6762011-02-23 00:37:57 +00009951 bool TypeMayContainAuto) {
Richard Smith30482bc2011-02-20 03:19:35 +00009952 // C++0x [dcl.spec.auto]p7:
9953 // If the type deduced for the template parameter U is not the same in each
9954 // deduction, the program is ill-formed.
9955 // FIXME: When initializer-list support is added, a distinction is needed
9956 // between the deduced type U and the deduced type which 'auto' stands for.
9957 // auto a = 0, b = { 1, 2, 3 };
9958 // is legal because the deduced type U is 'int' in both cases.
Rafael Espindolaab417692013-07-09 12:05:01 +00009959 if (TypeMayContainAuto && Group.size() > 1) {
Richard Smith30482bc2011-02-20 03:19:35 +00009960 QualType Deduced;
9961 CanQualType DeducedCanon;
Craig Topperc3ec1492014-05-26 06:22:03 +00009962 VarDecl *DeducedDecl = nullptr;
Rafael Espindolaab417692013-07-09 12:05:01 +00009963 for (unsigned i = 0, e = Group.size(); i != e; ++i) {
Richard Smith30482bc2011-02-20 03:19:35 +00009964 if (VarDecl *D = dyn_cast<VarDecl>(Group[i])) {
9965 AutoType *AT = D->getType()->getContainedAutoType();
Richard Smith2abf6762011-02-23 00:37:57 +00009966 // Don't reissue diagnostics when instantiating a template.
9967 if (AT && D->isInvalidDecl())
9968 break;
Richard Smith27d807c2013-04-30 13:56:41 +00009969 QualType U = AT ? AT->getDeducedType() : QualType();
9970 if (!U.isNull()) {
Richard Smith30482bc2011-02-20 03:19:35 +00009971 CanQualType UCanon = Context.getCanonicalType(U);
9972 if (Deduced.isNull()) {
9973 Deduced = U;
9974 DeducedCanon = UCanon;
9975 DeducedDecl = D;
9976 } else if (DeducedCanon != UCanon) {
Richard Smith2abf6762011-02-23 00:37:57 +00009977 Diag(D->getTypeSourceInfo()->getTypeLoc().getBeginLoc(),
9978 diag::err_auto_different_deductions)
Richard Smith489e4e02013-05-04 04:19:27 +00009979 << (AT->isDecltypeAuto() ? 1 : 0)
Richard Smith30482bc2011-02-20 03:19:35 +00009980 << Deduced << DeducedDecl->getDeclName()
9981 << U << D->getDeclName()
9982 << DeducedDecl->getInit()->getSourceRange()
9983 << D->getInit()->getSourceRange();
Richard Smith2abf6762011-02-23 00:37:57 +00009984 D->setInvalidDecl();
Richard Smith30482bc2011-02-20 03:19:35 +00009985 break;
9986 }
9987 }
9988 }
9989 }
9990 }
9991
Rafael Espindolaab417692013-07-09 12:05:01 +00009992 ActOnDocumentableDecls(Group);
Dmitri Gribenkof26054f2012-07-11 21:38:39 +00009993
Rafael Espindolaab417692013-07-09 12:05:01 +00009994 return DeclGroupPtrTy::make(
9995 DeclGroupRef::Create(Context, Group.data(), Group.size()));
Chris Lattner776fac82007-06-09 00:53:06 +00009996}
Steve Naroff7e6f7c22007-08-28 03:03:08 +00009997
Dmitri Gribenkof26054f2012-07-11 21:38:39 +00009998void Sema::ActOnDocumentableDecl(Decl *D) {
Rafael Espindolaab417692013-07-09 12:05:01 +00009999 ActOnDocumentableDecls(D);
Dmitri Gribenkof26054f2012-07-11 21:38:39 +000010000}
10001
Rafael Espindolaab417692013-07-09 12:05:01 +000010002void Sema::ActOnDocumentableDecls(ArrayRef<Decl *> Group) {
Dmitri Gribenkof26054f2012-07-11 21:38:39 +000010003 // Don't parse the comment if Doxygen diagnostics are ignored.
Rafael Espindolaab417692013-07-09 12:05:01 +000010004 if (Group.empty() || !Group[0])
Dmitri Gribenko7fe22f62015-03-17 18:03:42 +000010005 return;
Dmitri Gribenkof26054f2012-07-11 21:38:39 +000010006
Dmitri Gribenko7fe22f62015-03-17 18:03:42 +000010007 if (Diags.isIgnored(diag::warn_doc_param_not_found,
10008 Group[0]->getLocation()) &&
10009 Diags.isIgnored(diag::warn_unknown_comment_command_name,
10010 Group[0]->getLocation()))
Dmitri Gribenkof26054f2012-07-11 21:38:39 +000010011 return;
10012
Rafael Espindolaab417692013-07-09 12:05:01 +000010013 if (Group.size() >= 2) {
Dmitri Gribenkof26054f2012-07-11 21:38:39 +000010014 // This is a decl group. Normally it will contain only declarations
Rafael Espindolaab417692013-07-09 12:05:01 +000010015 // produced from declarator list. But in case we have any definitions or
Dmitri Gribenkof26054f2012-07-11 21:38:39 +000010016 // additional declaration references:
10017 // 'typedef struct S {} S;'
10018 // 'typedef struct S *S;'
10019 // 'struct S *pS;'
10020 // FinalizeDeclaratorGroup adds these as separate declarations.
10021 Decl *MaybeTagDecl = Group[0];
10022 if (MaybeTagDecl && isa<TagDecl>(MaybeTagDecl)) {
Rafael Espindolaab417692013-07-09 12:05:01 +000010023 Group = Group.slice(1);
Dmitri Gribenkof26054f2012-07-11 21:38:39 +000010024 }
10025 }
10026
10027 // See if there are any new comments that are not attached to a decl.
10028 ArrayRef<RawComment *> Comments = Context.getRawCommentList().getComments();
10029 if (!Comments.empty() &&
10030 !Comments.back()->isAttached()) {
10031 // There is at least one comment that not attached to a decl.
10032 // Maybe it should be attached to one of these decls?
10033 //
10034 // Note that this way we pick up not only comments that precede the
10035 // declaration, but also comments that *follow* the declaration -- thanks to
10036 // the lookahead in the lexer: we've consumed the semicolon and looked
10037 // ahead through comments.
Rafael Espindolaab417692013-07-09 12:05:01 +000010038 for (unsigned i = 0, e = Group.size(); i != e; ++i)
Dmitri Gribenko6743e042012-09-29 11:40:46 +000010039 Context.getCommentForDecl(Group[i], &PP);
Dmitri Gribenkof26054f2012-07-11 21:38:39 +000010040 }
10041}
Chris Lattner5bbb3c82009-03-29 16:50:03 +000010042
Chris Lattneraa9c7ae2008-04-08 04:40:51 +000010043/// ActOnParamDeclarator - Called from Parser::ParseFunctionDeclarator()
10044/// to introduce parameters into function prototype scope.
John McCall48871652010-08-21 09:40:31 +000010045Decl *Sema::ActOnParamDeclarator(Scope *S, Declarator &D) {
Chris Lattnercf31de32008-06-26 06:49:43 +000010046 const DeclSpec &DS = D.getDeclSpec();
Douglas Gregorad590502008-12-15 23:53:10 +000010047
Chris Lattneraa9c7ae2008-04-08 04:40:51 +000010048 // Verify C99 6.7.5.3p2: The only SCS allowed is 'register'.
Faisal Vali2b391ab2013-09-26 19:54:12 +000010049
Peter Collingbourne99eddc32011-10-21 11:55:09 +000010050 // C++03 [dcl.stc]p2 also permits 'auto'.
Craig Topperc79e5e32014-10-31 06:57:13 +000010051 StorageClass SC = SC_None;
Daniel Dunbar0ff41922008-09-03 21:54:21 +000010052 if (DS.getStorageClassSpec() == DeclSpec::SCS_register) {
Craig Topperc79e5e32014-10-31 06:57:13 +000010053 SC = SC_Register;
David Blaikiebbafb8a2012-03-11 07:00:24 +000010054 } else if (getLangOpts().CPlusPlus &&
Peter Collingbourne99eddc32011-10-21 11:55:09 +000010055 DS.getStorageClassSpec() == DeclSpec::SCS_auto) {
Craig Topperc79e5e32014-10-31 06:57:13 +000010056 SC = SC_Auto;
Daniel Dunbar0ff41922008-09-03 21:54:21 +000010057 } else if (DS.getStorageClassSpec() != DeclSpec::SCS_unspecified) {
Chris Lattneraa9c7ae2008-04-08 04:40:51 +000010058 Diag(DS.getStorageClassSpecLoc(),
10059 diag::err_invalid_storage_class_in_func_decl);
Chris Lattnercf31de32008-06-26 06:49:43 +000010060 D.getMutableDeclSpec().ClearStorageClassSpecs();
Chris Lattneraa9c7ae2008-04-08 04:40:51 +000010061 }
Eli Friedmand5c0eed2009-04-19 20:27:55 +000010062
Richard Smithb4a9e862013-04-12 22:46:28 +000010063 if (DeclSpec::TSCS TSCS = DS.getThreadStorageClassSpec())
10064 Diag(DS.getThreadStorageClassSpecLoc(), diag::err_invalid_thread)
10065 << DeclSpec::getSpecifierName(TSCS);
10066 if (DS.isConstexprSpecified())
10067 Diag(DS.getConstexprSpecLoc(), diag::err_invalid_constexpr)
Richard Smitha77a0a62011-08-15 21:04:07 +000010068 << 0;
Eli Friedmand5c0eed2009-04-19 20:27:55 +000010069
Richard Smithb4a9e862013-04-12 22:46:28 +000010070 DiagnoseFunctionSpecifiers(DS);
Eli Friedman574c7452009-04-07 19:37:57 +000010071
Argyrios Kyrtzidisef7022f2011-06-28 03:01:15 +000010072 TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S);
John McCall8cb7bdf2010-06-04 23:28:52 +000010073 QualType parmDeclType = TInfo->getType();
Mike Stump11289f42009-09-09 15:08:12 +000010074
David Blaikiebbafb8a2012-03-11 07:00:24 +000010075 if (getLangOpts().CPlusPlus) {
Douglas Gregor27b4c162010-12-23 22:44:42 +000010076 // Check that there are no default arguments inside the type of this
10077 // parameter.
10078 CheckExtraCXXDefaultArguments(D);
Douglas Gregor27b4c162010-12-23 22:44:42 +000010079
10080 // Parameter declarators cannot be qualified (C++ [dcl.meaning]p1).
10081 if (D.getCXXScopeSpec().isSet()) {
10082 Diag(D.getIdentifierLoc(), diag::err_qualified_param_declarator)
10083 << D.getCXXScopeSpec().getRange();
10084 D.getCXXScopeSpec().clear();
10085 }
Douglas Gregord6ab8742009-05-28 23:31:59 +000010086 }
10087
Alexis Hunta56cbcc2010-11-03 01:07:06 +000010088 // Ensure we have a valid name
Craig Topperc3ec1492014-05-26 06:22:03 +000010089 IdentifierInfo *II = nullptr;
Alexis Hunta56cbcc2010-11-03 01:07:06 +000010090 if (D.hasName()) {
10091 II = D.getIdentifier();
10092 if (!II) {
10093 Diag(D.getIdentifierLoc(), diag::err_bad_parameter_name)
Aaron Ballmanfee0cd42014-01-03 13:34:55 +000010094 << GetNameForDeclarator(D).getName();
Alexis Hunta56cbcc2010-11-03 01:07:06 +000010095 D.setInvalidType(true);
10096 }
10097 }
10098
Chris Lattnerdd1cb5b2010-02-22 00:40:25 +000010099 // Check for redeclaration of parameters, e.g. int foo(int x, int x);
Chris Lattnerd9773512009-01-21 02:38:50 +000010100 if (II) {
John McCall84f02672010-03-18 06:42:38 +000010101 LookupResult R(*this, II, D.getIdentifierLoc(), LookupOrdinaryName,
10102 ForRedeclaration);
10103 LookupName(R, S);
10104 if (R.isSingleResult()) {
10105 NamedDecl *PrevDecl = R.getFoundDecl();
Chris Lattnerd9773512009-01-21 02:38:50 +000010106 if (PrevDecl->isTemplateParameter()) {
10107 // Maybe we will complain about the shadowed template parameter.
10108 DiagnoseTemplateParameterShadow(D.getIdentifierLoc(), PrevDecl);
10109 // Just pretend that we didn't see the previous declaration.
Craig Topperc3ec1492014-05-26 06:22:03 +000010110 PrevDecl = nullptr;
John McCall48871652010-08-21 09:40:31 +000010111 } else if (S->isDeclScope(PrevDecl)) {
Chris Lattnerd9773512009-01-21 02:38:50 +000010112 Diag(D.getIdentifierLoc(), diag::err_param_redefinition) << II;
Chris Lattnerdd1cb5b2010-02-22 00:40:25 +000010113 Diag(PrevDecl->getLocation(), diag::note_previous_declaration);
Chris Lattneraa9c7ae2008-04-08 04:40:51 +000010114
Chris Lattnerd9773512009-01-21 02:38:50 +000010115 // Recover by removing the name
Craig Topperc3ec1492014-05-26 06:22:03 +000010116 II = nullptr;
10117 D.SetIdentifier(nullptr, D.getIdentifierLoc());
Fariborz Jahanian5ec502e2010-02-12 21:53:14 +000010118 D.setInvalidType(true);
Chris Lattnerd9773512009-01-21 02:38:50 +000010119 }
Chris Lattneraa9c7ae2008-04-08 04:40:51 +000010120 }
Chris Lattnerc5cdf4d2007-01-21 07:42:07 +000010121 }
Steve Naroff773df5c2007-08-07 22:44:21 +000010122
John McCallf7b2fb52010-01-22 00:28:27 +000010123 // Temporarily put parameter variables in the translation unit, not
10124 // the enclosing context. This prevents them from accidentally
10125 // looking like class members in C++.
Douglas Gregor940bca72010-04-12 07:48:19 +000010126 ParmVarDecl *New = CheckParameter(Context.getTranslationUnitDecl(),
Daniel Dunbar62ee6412012-03-09 18:35:03 +000010127 D.getLocStart(),
Abramo Bagnaradff19302011-03-08 08:55:46 +000010128 D.getIdentifierLoc(), II,
10129 parmDeclType, TInfo,
Craig Topperc79e5e32014-10-31 06:57:13 +000010130 SC);
Mike Stump11289f42009-09-09 15:08:12 +000010131
Chris Lattnerf6d1c9c2009-04-25 08:06:05 +000010132 if (D.isInvalidType())
John McCall8fb0d9d2011-05-01 22:35:37 +000010133 New->setInvalidDecl();
10134
10135 assert(S->isFunctionPrototypeScope());
10136 assert(S->getFunctionPrototypeDepth() >= 1);
10137 New->setScopeInfo(S->getFunctionPrototypeDepth() - 1,
10138 S->getNextFunctionPrototypeIndex());
Douglas Gregor940bca72010-04-12 07:48:19 +000010139
Douglas Gregor91f84212008-12-11 16:49:14 +000010140 // Add the parameter declaration into this scope.
John McCall48871652010-08-21 09:40:31 +000010141 S->AddDecl(New);
Argyrios Kyrtzidisb8a49202008-04-12 00:47:19 +000010142 if (II)
Douglas Gregor91f84212008-12-11 16:49:14 +000010143 IdResolver.AddDecl(New);
Nate Begemand8c41562008-02-17 21:20:31 +000010144
Douglas Gregor758a8692009-06-17 21:51:59 +000010145 ProcessDeclAttributes(S, New, D);
Mike Stumpe9efa802009-04-30 00:19:40 +000010146
Douglas Gregor41866812011-09-12 18:37:38 +000010147 if (D.getDeclSpec().isModulePrivateSpecified())
10148 Diag(New->getLocation(), diag::err_module_private_local)
10149 << 1 << New->getDeclName()
10150 << SourceRange(D.getDeclSpec().getModulePrivateSpecLoc())
10151 << FixItHint::CreateRemoval(D.getDeclSpec().getModulePrivateSpecLoc());
10152
Argyrios Kyrtzidisb4b64ca2009-06-30 02:34:44 +000010153 if (New->hasAttr<BlocksAttr>()) {
Mike Stumpe9efa802009-04-30 00:19:40 +000010154 Diag(New->getLocation(), diag::err_block_on_nonlocal);
10155 }
John McCall48871652010-08-21 09:40:31 +000010156 return New;
Chris Lattnerc5cdf4d2007-01-21 07:42:07 +000010157}
Fariborz Jahanian56ff1462007-11-08 23:49:49 +000010158
John McCalla3ccba02010-06-04 11:21:44 +000010159/// \brief Synthesizes a variable for a parameter arising from a
10160/// typedef.
10161ParmVarDecl *Sema::BuildParmVarDeclForTypedef(DeclContext *DC,
10162 SourceLocation Loc,
10163 QualType T) {
Abramo Bagnaradff19302011-03-08 08:55:46 +000010164 /* FIXME: setting StartLoc == Loc.
10165 Would it be worth to modify callers so as to provide proper source
10166 location for the unnamed parameters, embedding the parameter's type? */
Craig Topperc3ec1492014-05-26 06:22:03 +000010167 ParmVarDecl *Param = ParmVarDecl::Create(Context, DC, Loc, Loc, nullptr,
John McCalla3ccba02010-06-04 11:21:44 +000010168 T, Context.getTrivialTypeSourceInfo(T, Loc),
Craig Topperc3ec1492014-05-26 06:22:03 +000010169 SC_None, nullptr);
John McCalla3ccba02010-06-04 11:21:44 +000010170 Param->setImplicit();
10171 return Param;
10172}
10173
John McCallc5990642010-08-24 09:05:15 +000010174void Sema::DiagnoseUnusedParameters(ParmVarDecl * const *Param,
10175 ParmVarDecl * const *ParamEnd) {
John McCallc5990642010-08-24 09:05:15 +000010176 // Don't diagnose unused-parameter errors in template instantiations; we
10177 // will already have done so in the template itself.
10178 if (!ActiveTemplateInstantiations.empty())
10179 return;
10180
10181 for (; Param != ParamEnd; ++Param) {
Eli Friedmanc09e0552012-01-13 23:41:25 +000010182 if (!(*Param)->isReferenced() && (*Param)->getDeclName() &&
John McCallc5990642010-08-24 09:05:15 +000010183 !(*Param)->hasAttr<UnusedAttr>()) {
10184 Diag((*Param)->getLocation(), diag::warn_unused_parameter)
10185 << (*Param)->getDeclName();
10186 }
10187 }
10188}
10189
Argyrios Kyrtzidisaf84ec02010-11-17 23:11:54 +000010190void Sema::DiagnoseSizeOfParametersAndReturnValue(ParmVarDecl * const *Param,
10191 ParmVarDecl * const *ParamEnd,
10192 QualType ReturnTy,
10193 NamedDecl *D) {
Argyrios Kyrtzidisef6c8da2010-11-18 00:20:36 +000010194 if (LangOpts.NumLargeByValueCopy == 0) // No check.
Argyrios Kyrtzidisaf84ec02010-11-17 23:11:54 +000010195 return;
10196
Argyrios Kyrtzidisef6c8da2010-11-18 00:20:36 +000010197 // Warn if the return value is pass-by-value and larger than the specified
10198 // threshold.
Eli Friedman7f21bd72012-01-09 23:46:59 +000010199 if (!ReturnTy->isDependentType() && ReturnTy.isPODType(Context)) {
Argyrios Kyrtzidisaf84ec02010-11-17 23:11:54 +000010200 unsigned Size = Context.getTypeSizeInChars(ReturnTy).getQuantity();
Argyrios Kyrtzidisef6c8da2010-11-18 00:20:36 +000010201 if (Size > LangOpts.NumLargeByValueCopy)
Argyrios Kyrtzidisaf84ec02010-11-17 23:11:54 +000010202 Diag(D->getLocation(), diag::warn_return_value_size)
10203 << D->getDeclName() << Size;
10204 }
10205
Argyrios Kyrtzidisef6c8da2010-11-18 00:20:36 +000010206 // Warn if any parameter is pass-by-value and larger than the specified
10207 // threshold.
Argyrios Kyrtzidisaf84ec02010-11-17 23:11:54 +000010208 for (; Param != ParamEnd; ++Param) {
10209 QualType T = (*Param)->getType();
Eli Friedman7f21bd72012-01-09 23:46:59 +000010210 if (T->isDependentType() || !T.isPODType(Context))
Argyrios Kyrtzidisaf84ec02010-11-17 23:11:54 +000010211 continue;
10212 unsigned Size = Context.getTypeSizeInChars(T).getQuantity();
Argyrios Kyrtzidisef6c8da2010-11-18 00:20:36 +000010213 if (Size > LangOpts.NumLargeByValueCopy)
Argyrios Kyrtzidisaf84ec02010-11-17 23:11:54 +000010214 Diag((*Param)->getLocation(), diag::warn_parameter_size)
10215 << (*Param)->getDeclName() << Size;
10216 }
10217}
10218
Abramo Bagnaradff19302011-03-08 08:55:46 +000010219ParmVarDecl *Sema::CheckParameter(DeclContext *DC, SourceLocation StartLoc,
10220 SourceLocation NameLoc, IdentifierInfo *Name,
10221 QualType T, TypeSourceInfo *TSInfo,
Craig Topperc79e5e32014-10-31 06:57:13 +000010222 StorageClass SC) {
Reid Kleckner17aeeeb2013-06-08 18:19:52 +000010223 // In ARC, infer a lifetime qualifier for appropriate parameter types.
David Blaikiebbafb8a2012-03-11 07:00:24 +000010224 if (getLangOpts().ObjCAutoRefCount &&
John McCall31168b02011-06-15 23:02:42 +000010225 T.getObjCLifetime() == Qualifiers::OCL_None &&
Reid Kleckner17aeeeb2013-06-08 18:19:52 +000010226 T->isObjCLifetimeType()) {
10227
10228 Qualifiers::ObjCLifetime lifetime;
10229
10230 // Special cases for arrays:
10231 // - if it's const, use __unsafe_unretained
10232 // - otherwise, it's an error
10233 if (T->isArrayType()) {
10234 if (!T.isConstQualified()) {
10235 DelayedDiagnostics.add(
10236 sema::DelayedDiagnostic::makeForbiddenType(
Fariborz Jahanianed1933b2011-10-03 22:11:57 +000010237 NameLoc, diag::err_arc_array_param_no_ownership, T, false));
Reid Kleckner17aeeeb2013-06-08 18:19:52 +000010238 }
10239 lifetime = Qualifiers::OCL_ExplicitNone;
10240 } else {
10241 lifetime = T->getObjCARCImplicitLifetime();
10242 }
10243 T = Context.getLifetimeQualifiedType(T, lifetime);
John McCall31168b02011-06-15 23:02:42 +000010244 }
10245
Abramo Bagnaradff19302011-03-08 08:55:46 +000010246 ParmVarDecl *New = ParmVarDecl::Create(Context, DC, StartLoc, NameLoc, Name,
Douglas Gregor84280642011-07-12 04:42:08 +000010247 Context.getAdjustedParameterType(T),
Craig Topperc79e5e32014-10-31 06:57:13 +000010248 TSInfo, SC, nullptr);
Douglas Gregor940bca72010-04-12 07:48:19 +000010249
10250 // Parameters can not be abstract class types.
10251 // For record types, this is done by the AbstractClassUsageDiagnoser once
10252 // the class has been completely parsed.
10253 if (!CurContext->isRecord() &&
10254 RequireNonAbstractType(NameLoc, T, diag::err_abstract_type_in_decl,
10255 AbstractParamType))
10256 New->setInvalidDecl();
10257
10258 // Parameter declarators cannot be interface types. All ObjC objects are
10259 // passed by reference.
John McCall8b07ec22010-05-15 11:32:37 +000010260 if (T->isObjCObjectType()) {
Fariborz Jahanian7a055362012-05-09 21:49:29 +000010261 SourceLocation TypeEndLoc = TSInfo->getTypeLoc().getLocEnd();
Douglas Gregor940bca72010-04-12 07:48:19 +000010262 Diag(NameLoc,
Fariborz Jahanian6507135e2011-07-26 17:58:54 +000010263 diag::err_object_cannot_be_passed_returned_by_value) << 1 << T
Fariborz Jahanian7a055362012-05-09 21:49:29 +000010264 << FixItHint::CreateInsertion(TypeEndLoc, "*");
Fariborz Jahanian6507135e2011-07-26 17:58:54 +000010265 T = Context.getObjCObjectPointerType(T);
10266 New->setType(T);
Douglas Gregor940bca72010-04-12 07:48:19 +000010267 }
10268
10269 // ISO/IEC TR 18037 S6.7.3: "The type of an object with automatic storage
10270 // duration shall not be qualified by an address-space qualifier."
10271 // Since all parameters have automatic store duration, they can not have
10272 // an address space.
10273 if (T.getAddressSpace() != 0) {
Fraser Cormack01648e02014-04-15 11:38:29 +000010274 // OpenCL allows function arguments declared to be an array of a type
10275 // to be qualified with an address space.
10276 if (!(getLangOpts().OpenCL && T->isArrayType())) {
10277 Diag(NameLoc, diag::err_arg_with_address_space);
10278 New->setInvalidDecl();
10279 }
Douglas Gregor940bca72010-04-12 07:48:19 +000010280 }
10281
10282 return New;
10283}
10284
Douglas Gregor170512f2009-04-01 23:51:29 +000010285void Sema::ActOnFinishKNRParamDeclarations(Scope *S, Declarator &D,
10286 SourceLocation LocAfterDecls) {
Abramo Bagnara924a8f32010-12-10 16:29:40 +000010287 DeclaratorChunk::FunctionTypeInfo &FTI = D.getFunctionTypeInfo();
Chris Lattneraa9c7ae2008-04-08 04:40:51 +000010288
Chris Lattner5c5fbcc2006-12-03 08:41:30 +000010289 // Verify 6.9.1p6: 'every identifier in the identifier list shall be declared'
10290 // for a K&R function.
10291 if (!FTI.hasPrototype) {
Alp Tokerc5350722014-02-26 22:27:52 +000010292 for (int i = FTI.NumParams; i != 0; /* decrement in loop */) {
Douglas Gregor862ffb12009-04-02 03:14:12 +000010293 --i;
Craig Topperc3ec1492014-05-26 06:22:03 +000010294 if (FTI.Params[i].Param == nullptr) {
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +000010295 SmallString<256> Code;
Alp Tokerc5350722014-02-26 22:27:52 +000010296 llvm::raw_svector_ostream(Code)
10297 << " int " << FTI.Params[i].Ident->getName() << ";\n";
10298 Diag(FTI.Params[i].IdentLoc, diag::ext_param_not_declared)
10299 << FTI.Params[i].Ident
Yaron Keren92e1b622015-03-18 10:17:07 +000010300 << FixItHint::CreateInsertion(LocAfterDecls, Code);
Douglas Gregor170512f2009-04-01 23:51:29 +000010301
Chris Lattner5c5fbcc2006-12-03 08:41:30 +000010302 // Implicitly declare the argument as type 'int' for lack of a better
10303 // type.
John McCall084e83d2011-03-24 11:26:52 +000010304 AttributeFactory attrs;
10305 DeclSpec DS(attrs);
Chris Lattneraa9c7ae2008-04-08 04:40:51 +000010306 const char* PrevSpec; // unused
John McCall49bfce42009-08-03 20:12:06 +000010307 unsigned DiagID; // unused
Alp Tokerc5350722014-02-26 22:27:52 +000010308 DS.SetTypeSpecType(DeclSpec::TST_int, FTI.Params[i].IdentLoc, PrevSpec,
10309 DiagID, Context.getPrintingPolicy());
Abramo Bagnara71f32c12012-10-04 21:38:29 +000010310 // Use the identifier location for the type source range.
Alp Tokerc5350722014-02-26 22:27:52 +000010311 DS.SetRangeStart(FTI.Params[i].IdentLoc);
10312 DS.SetRangeEnd(FTI.Params[i].IdentLoc);
Chris Lattneraa9c7ae2008-04-08 04:40:51 +000010313 Declarator ParamD(DS, Declarator::KNRTypeListContext);
Alp Tokerc5350722014-02-26 22:27:52 +000010314 ParamD.SetIdentifier(FTI.Params[i].Ident, FTI.Params[i].IdentLoc);
10315 FTI.Params[i].Param = ActOnParamDeclarator(S, ParamD);
Chris Lattner5c5fbcc2006-12-03 08:41:30 +000010316 }
10317 }
Mike Stump11289f42009-09-09 15:08:12 +000010318 }
Douglas Gregor9aa89042009-01-23 16:23:13 +000010319}
10320
Richard Smith79a52e52012-04-17 22:30:01 +000010321Decl *Sema::ActOnStartOfFunctionDef(Scope *FnBodyScope, Declarator &D) {
Craig Topperc3ec1492014-05-26 06:22:03 +000010322 assert(getCurFunctionDecl() == nullptr && "Function parsing confused");
Abramo Bagnara924a8f32010-12-10 16:29:40 +000010323 assert(D.isFunctionDeclarator() && "Not a function declarator!");
Douglas Gregorad590502008-12-15 23:53:10 +000010324 Scope *ParentScope = FnBodyScope->getParent();
Steve Naroff012484d2008-01-14 20:51:29 +000010325
Douglas Gregor5d1b4e32011-11-07 20:56:01 +000010326 D.setFunctionDefinitionKind(FDK_Definition);
Benjamin Kramercc4c49d2012-08-23 23:38:35 +000010327 Decl *DP = HandleDeclarator(ParentScope, D, MultiTemplateParamsArg());
Chris Lattner5bbb3c82009-03-29 16:50:03 +000010328 return ActOnStartOfFunctionDef(FnBodyScope, DP);
Argyrios Kyrtzidised983422008-07-01 10:37:29 +000010329}
10330
Hans Wennborga926d842014-05-23 20:37:38 +000010331void Sema::ActOnFinishInlineMethodDef(CXXMethodDecl *D) {
10332 Consumer.HandleInlineMethodDefinition(D);
10333}
10334
Anders Carlsson2a45e402012-12-18 01:29:20 +000010335static bool ShouldWarnAboutMissingPrototype(const FunctionDecl *FD,
10336 const FunctionDecl*& PossibleZeroParamPrototype) {
Anders Carlsson31c7e882009-12-09 03:30:09 +000010337 // Don't warn about invalid declarations.
10338 if (FD->isInvalidDecl())
10339 return false;
Anders Carlssona0388252009-12-09 03:44:46 +000010340
Anders Carlsson31c7e882009-12-09 03:30:09 +000010341 // Or declarations that aren't global.
10342 if (!FD->isGlobal())
10343 return false;
Anders Carlssona0388252009-12-09 03:44:46 +000010344
Anders Carlsson31c7e882009-12-09 03:30:09 +000010345 // Don't warn about C++ member functions.
10346 if (isa<CXXMethodDecl>(FD))
10347 return false;
Anders Carlssona0388252009-12-09 03:44:46 +000010348
Anders Carlsson31c7e882009-12-09 03:30:09 +000010349 // Don't warn about 'main'.
10350 if (FD->isMain())
10351 return false;
Anders Carlssona0388252009-12-09 03:44:46 +000010352
Anders Carlsson31c7e882009-12-09 03:30:09 +000010353 // Don't warn about inline functions.
John McCall30cd20a2011-03-22 07:16:37 +000010354 if (FD->isInlined())
Anders Carlsson31c7e882009-12-09 03:30:09 +000010355 return false;
Anders Carlssona0388252009-12-09 03:44:46 +000010356
10357 // Don't warn about function templates.
10358 if (FD->getDescribedFunctionTemplate())
10359 return false;
10360
10361 // Don't warn about function template specializations.
10362 if (FD->isFunctionTemplateSpecialization())
10363 return false;
10364
Tanya Lattner4bfc3552012-07-26 00:08:28 +000010365 // Don't warn for OpenCL kernels.
10366 if (FD->hasAttr<OpenCLKernelAttr>())
10367 return false;
Richard Smith541b38b2013-09-20 01:15:31 +000010368
Benjamin Kramer8610cae2015-03-12 14:28:47 +000010369 // Don't warn on explicitly deleted functions.
10370 if (FD->isDeleted())
10371 return false;
10372
Anders Carlsson31c7e882009-12-09 03:30:09 +000010373 bool MissingPrototype = true;
Douglas Gregorec9fd132012-01-14 16:38:05 +000010374 for (const FunctionDecl *Prev = FD->getPreviousDecl();
10375 Prev; Prev = Prev->getPreviousDecl()) {
Anders Carlsson31c7e882009-12-09 03:30:09 +000010376 // Ignore any declarations that occur in function or method
10377 // scope, because they aren't visible from the header.
Richard Smith541b38b2013-09-20 01:15:31 +000010378 if (Prev->getLexicalDeclContext()->isFunctionOrMethod())
Anders Carlsson31c7e882009-12-09 03:30:09 +000010379 continue;
Richard Smith541b38b2013-09-20 01:15:31 +000010380
Anders Carlsson31c7e882009-12-09 03:30:09 +000010381 MissingPrototype = !Prev->getType()->isFunctionProtoType();
Anders Carlsson2a45e402012-12-18 01:29:20 +000010382 if (FD->getNumParams() == 0)
10383 PossibleZeroParamPrototype = Prev;
Anders Carlsson31c7e882009-12-09 03:30:09 +000010384 break;
10385 }
Richard Smith541b38b2013-09-20 01:15:31 +000010386
Anders Carlsson31c7e882009-12-09 03:30:09 +000010387 return MissingPrototype;
10388}
10389
Rafael Espindolad53ffa02013-10-22 21:39:03 +000010390void
10391Sema::CheckForFunctionRedefinition(FunctionDecl *FD,
10392 const FunctionDecl *EffectiveDefinition) {
Francois Pichetdcb3ebe2011-04-22 23:20:44 +000010393 // Don't complain if we're in GNU89 mode and the previous definition
10394 // was an extern inline function.
Rafael Espindolad53ffa02013-10-22 21:39:03 +000010395 const FunctionDecl *Definition = EffectiveDefinition;
10396 if (!Definition)
10397 if (!FD->isDefined(Definition))
10398 return;
10399
10400 if (canRedefineFunction(Definition, getLangOpts()))
Rafael Espindola69f53102013-10-22 15:18:22 +000010401 return;
10402
Richard Smithd6aab592015-03-27 21:57:41 +000010403 // If we don't have a visible definition of the function, and it's inline or
10404 // a template, it's OK to form another definition of it.
Richard Smith9a71c992015-03-27 20:16:58 +000010405 //
10406 // FIXME: Should we skip the body of the function and use the old definition
10407 // in this case? That may be necessary for functions that return local types
10408 // through a deduced return type, or instantiate templates with local types.
Richard Smithd6aab592015-03-27 21:57:41 +000010409 if (!hasVisibleDefinition(Definition) &&
Richard Smith529ecb22015-06-22 21:15:01 +000010410 (Definition->getFormalLinkage() == InternalLinkage ||
10411 Definition->isInlineSpecified() ||
Richard Smithd6aab592015-03-27 21:57:41 +000010412 Definition->getDescribedFunctionTemplate() ||
10413 Definition->getNumTemplateParameterLists()))
Richard Smith9a71c992015-03-27 20:16:58 +000010414 return;
10415
Rafael Espindola69f53102013-10-22 15:18:22 +000010416 if (getLangOpts().GNUMode && Definition->isInlineSpecified() &&
10417 Definition->getStorageClass() == SC_Extern)
10418 Diag(FD->getLocation(), diag::err_redefinition_extern_inline)
David Blaikiebbafb8a2012-03-11 07:00:24 +000010419 << FD->getDeclName() << getLangOpts().CPlusPlus;
Rafael Espindola69f53102013-10-22 15:18:22 +000010420 else
10421 Diag(FD->getLocation(), diag::err_redefinition) << FD->getDeclName();
10422
10423 Diag(Definition->getLocation(), diag::note_previous_definition);
10424 FD->setInvalidDecl();
Francois Pichetdcb3ebe2011-04-22 23:20:44 +000010425}
Faisal Valia17d19f2013-11-07 05:17:06 +000010426
10427
Faisal Valic1a6dc42013-10-23 16:10:50 +000010428static void RebuildLambdaScopeInfo(CXXMethodDecl *CallOperator,
10429 Sema &S) {
10430 CXXRecordDecl *const LambdaClass = CallOperator->getParent();
Faisal Vali524ca282013-11-12 01:40:44 +000010431
10432 LambdaScopeInfo *LSI = S.PushLambdaScope();
Faisal Valic1a6dc42013-10-23 16:10:50 +000010433 LSI->CallOperator = CallOperator;
10434 LSI->Lambda = LambdaClass;
Alp Toker314cc812014-01-25 16:55:45 +000010435 LSI->ReturnType = CallOperator->getReturnType();
Faisal Valic1a6dc42013-10-23 16:10:50 +000010436 const LambdaCaptureDefault LCD = LambdaClass->getLambdaCaptureDefault();
10437
10438 if (LCD == LCD_None)
10439 LSI->ImpCaptureStyle = CapturingScopeInfo::ImpCap_None;
10440 else if (LCD == LCD_ByCopy)
10441 LSI->ImpCaptureStyle = CapturingScopeInfo::ImpCap_LambdaByval;
10442 else if (LCD == LCD_ByRef)
10443 LSI->ImpCaptureStyle = CapturingScopeInfo::ImpCap_LambdaByref;
10444 DeclarationNameInfo DNI = CallOperator->getNameInfo();
10445
10446 LSI->IntroducerRange = DNI.getCXXOperatorNameRange();
10447 LSI->Mutable = !CallOperator->isConst();
10448
Faisal Valia17d19f2013-11-07 05:17:06 +000010449 // Add the captures to the LSI so they can be noted as already
10450 // captured within tryCaptureVar.
Alexey Bataev39c81e22014-08-28 04:28:19 +000010451 auto I = LambdaClass->field_begin();
Aaron Ballman6def98a2014-03-13 17:08:33 +000010452 for (const auto &C : LambdaClass->captures()) {
10453 if (C.capturesVariable()) {
10454 VarDecl *VD = C.getCapturedVar();
Faisal Valia17d19f2013-11-07 05:17:06 +000010455 if (VD->isInitCapture())
10456 S.CurrentInstantiationScope->InstantiatedLocal(VD, VD);
10457 QualType CaptureType = VD->getType();
Aaron Ballman6def98a2014-03-13 17:08:33 +000010458 const bool ByRef = C.getCaptureKind() == LCK_ByRef;
Faisal Valia17d19f2013-11-07 05:17:06 +000010459 LSI->addCapture(VD, /*IsBlock*/false, ByRef,
Alexey Bataev19acc3d2015-01-12 10:17:46 +000010460 /*RefersToEnclosingVariableOrCapture*/true, C.getLocation(),
Aaron Ballman6def98a2014-03-13 17:08:33 +000010461 /*EllipsisLoc*/C.isPackExpansion()
10462 ? C.getEllipsisLoc() : SourceLocation(),
Craig Topperc3ec1492014-05-26 06:22:03 +000010463 CaptureType, /*Expr*/ nullptr);
10464
Aaron Ballman6def98a2014-03-13 17:08:33 +000010465 } else if (C.capturesThis()) {
10466 LSI->addThisCapture(/*Nested*/ false, C.getLocation(),
Craig Topperc3ec1492014-05-26 06:22:03 +000010467 S.getCurrentThisType(), /*Expr*/ nullptr);
Alexey Bataev39c81e22014-08-28 04:28:19 +000010468 } else {
10469 LSI->addVLATypeCapture(C.getLocation(), I->getType());
Faisal Valia17d19f2013-11-07 05:17:06 +000010470 }
Alexey Bataev39c81e22014-08-28 04:28:19 +000010471 ++I;
Faisal Valia17d19f2013-11-07 05:17:06 +000010472 }
Faisal Valic1a6dc42013-10-23 16:10:50 +000010473}
Francois Pichetdcb3ebe2011-04-22 23:20:44 +000010474
John McCall48871652010-08-21 09:40:31 +000010475Decl *Sema::ActOnStartOfFunctionDef(Scope *FnBodyScope, Decl *D) {
Anders Carlsson561f7932009-10-29 15:46:07 +000010476 // Clear the last template instantiation error context.
10477 LastTemplateInstantiationErrorContext = ActiveTemplateInstantiation();
10478
Douglas Gregor17a7c122009-06-24 00:54:41 +000010479 if (!D)
10480 return D;
Craig Topperc3ec1492014-05-26 06:22:03 +000010481 FunctionDecl *FD = nullptr;
Mike Stump11289f42009-09-09 15:08:12 +000010482
John McCall48871652010-08-21 09:40:31 +000010483 if (FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(D))
Douglas Gregorc45a40a2009-08-22 00:34:47 +000010484 FD = FunTmpl->getTemplatedDecl();
10485 else
John McCall48871652010-08-21 09:40:31 +000010486 FD = cast<FunctionDecl>(D);
Faisal Vali2b391ab2013-09-26 19:54:12 +000010487 // If we are instantiating a generic lambda call operator, push
10488 // a LambdaScopeInfo onto the function stack. But use the information
Faisal Valic1a6dc42013-10-23 16:10:50 +000010489 // that's already been calculated (ActOnLambdaExpr) to prime the current
10490 // LambdaScopeInfo.
10491 // When the template operator is being specialized, the LambdaScopeInfo,
10492 // has to be properly restored so that tryCaptureVariable doesn't try
10493 // and capture any new variables. In addition when calculating potential
10494 // captures during transformation of nested lambdas, it is necessary to
10495 // have the LSI properly restored.
Faisal Valif9a9af32013-09-29 20:15:45 +000010496 if (isGenericLambdaCallOperatorSpecialization(FD)) {
Faisal Vali2b391ab2013-09-26 19:54:12 +000010497 assert(ActiveTemplateInstantiations.size() &&
10498 "There should be an active template instantiation on the stack "
10499 "when instantiating a generic lambda!");
Faisal Valic1a6dc42013-10-23 16:10:50 +000010500 RebuildLambdaScopeInfo(cast<CXXMethodDecl>(D), *this);
Faisal Vali2b391ab2013-09-26 19:54:12 +000010501 }
10502 else
10503 // Enter a new function scope
10504 PushFunctionScope();
Mike Stump11289f42009-09-09 15:08:12 +000010505
Douglas Gregorcad304ba2008-10-29 15:10:40 +000010506 // See if this is a redefinition.
Francois Pichetdcb3ebe2011-04-22 23:20:44 +000010507 if (!FD->isLateTemplateParsed())
10508 CheckForFunctionRedefinition(FD);
Douglas Gregorcad304ba2008-10-29 15:10:40 +000010509
Douglas Gregor75a45ba2009-02-16 17:45:42 +000010510 // Builtin functions cannot be defined.
Douglas Gregor15fc9562009-09-12 00:22:50 +000010511 if (unsigned BuiltinID = FD->getBuiltinID()) {
Rafael Espindola3b3a1662013-06-13 18:34:17 +000010512 if (!Context.BuiltinInfo.isPredefinedLibFunction(BuiltinID) &&
10513 !Context.BuiltinInfo.isPredefinedRuntimeFunction(BuiltinID)) {
Douglas Gregor75a45ba2009-02-16 17:45:42 +000010514 Diag(FD->getLocation(), diag::err_builtin_definition) << FD;
Douglas Gregor7a0febe2009-02-17 16:03:01 +000010515 FD->setInvalidDecl();
10516 }
Douglas Gregor75a45ba2009-02-16 17:45:42 +000010517 }
10518
Eli Friedman9ad72442009-03-04 07:30:59 +000010519 // The return type of a function definition must be complete
Douglas Gregorac1fb652009-03-24 19:52:54 +000010520 // (C99 6.9.1p3, C++ [dcl.fct]p6).
Alp Toker314cc812014-01-25 16:55:45 +000010521 QualType ResultType = FD->getReturnType();
Douglas Gregorac1fb652009-03-24 19:52:54 +000010522 if (!ResultType->isDependentType() && !ResultType->isVoidType() &&
Chris Lattner0f94c5a2009-04-29 05:12:23 +000010523 !FD->isInvalidDecl() &&
Douglas Gregorac1fb652009-03-24 19:52:54 +000010524 RequireCompleteType(FD->getLocation(), ResultType,
10525 diag::err_func_def_incomplete_result))
Eli Friedman9ad72442009-03-04 07:30:59 +000010526 FD->setInvalidDecl();
Eli Friedman9ad72442009-03-04 07:30:59 +000010527
Douglas Gregor67da0d92009-05-15 17:59:04 +000010528 if (FnBodyScope)
10529 PushDeclContext(FnBodyScope, FD);
Anton Korobeynikovd72f47a2008-12-26 00:52:02 +000010530
Chris Lattneraa9c7ae2008-04-08 04:40:51 +000010531 // Check the validity of our function parameters
Douglas Gregorb524d902010-11-01 18:37:59 +000010532 CheckParmsForFunctionDef(FD->param_begin(), FD->param_end(),
10533 /*CheckParameterNames=*/true);
Chris Lattneraa9c7ae2008-04-08 04:40:51 +000010534
10535 // Introduce our parameters into the function scope
Aaron Ballmanf6bf62e2014-03-07 15:12:56 +000010536 for (auto Param : FD->params()) {
Douglas Gregorc72e6452009-01-09 18:51:29 +000010537 Param->setOwningFunction(FD);
10538
Chris Lattneraa9c7ae2008-04-08 04:40:51 +000010539 // If this has an identifier, add it to the scope stack.
John McCalldf8b37c2010-03-22 09:20:08 +000010540 if (Param->getIdentifier() && FnBodyScope) {
Argyrios Kyrtzidis1cb0de12010-12-15 18:44:22 +000010541 CheckShadow(FnBodyScope, Param);
John McCalldf8b37c2010-03-22 09:20:08 +000010542
Argyrios Kyrtzidisb8a49202008-04-12 00:47:19 +000010543 PushOnScopeChains(Param, FnBodyScope);
John McCalldf8b37c2010-03-22 09:20:08 +000010544 }
Chris Lattnerf61c8a82007-01-21 19:04:43 +000010545 }
Chris Lattneraa9c7ae2008-04-08 04:40:51 +000010546
James Molloy6f8780b2012-02-29 10:24:19 +000010547 // If we had any tags defined in the function prototype,
10548 // introduce them into the function scope.
10549 if (FnBodyScope) {
Robert Wilhelm16e94b92013-08-09 18:02:13 +000010550 for (ArrayRef<NamedDecl *>::iterator
10551 I = FD->getDeclsInPrototypeScope().begin(),
10552 E = FD->getDeclsInPrototypeScope().end();
10553 I != E; ++I) {
James Molloy6f8780b2012-02-29 10:24:19 +000010554 NamedDecl *D = *I;
10555
Nico Weber620660c2015-03-09 02:33:32 +000010556 // Some of these decls (like enums) may have been pinned to the
10557 // translation unit for lack of a real context earlier. If so, remove
10558 // from the translation unit and reattach to the current context.
James Molloy6f8780b2012-02-29 10:24:19 +000010559 if (D->getLexicalDeclContext() == Context.getTranslationUnitDecl()) {
10560 // Is the decl actually in the context?
Aaron Ballman629afae2014-03-07 19:56:05 +000010561 for (const auto *DI : Context.getTranslationUnitDecl()->decls()) {
10562 if (DI == D) {
James Molloy6f8780b2012-02-29 10:24:19 +000010563 Context.getTranslationUnitDecl()->removeDecl(D);
10564 break;
10565 }
10566 }
10567 // Either way, reassign the lexical decl context to our FunctionDecl.
10568 D->setLexicalDeclContext(CurContext);
10569 }
10570
10571 // If the decl has a non-null name, make accessible in the current scope.
10572 if (!D->getName().empty())
10573 PushOnScopeChains(D, FnBodyScope, /*AddToContext=*/false);
10574
10575 // Similarly, dive into enums and fish their constants out, making them
10576 // accessible in this scope.
Aaron Ballman23a6dcb2014-03-08 18:45:14 +000010577 if (auto *ED = dyn_cast<EnumDecl>(D)) {
10578 for (auto *EI : ED->enumerators())
10579 PushOnScopeChains(EI, FnBodyScope, /*AddToContext=*/false);
James Molloy6f8780b2012-02-29 10:24:19 +000010580 }
10581 }
10582 }
10583
Richard Smith79a52e52012-04-17 22:30:01 +000010584 // Ensure that the function's exception specification is instantiated.
10585 if (const FunctionProtoType *FPT = FD->getType()->getAs<FunctionProtoType>())
10586 ResolveExceptionSpec(D->getLocation(), FPT);
10587
Hans Wennborgb0f2f142014-05-15 22:07:49 +000010588 // dllimport cannot be applied to non-inline function definitions.
Hans Wennborg7f26fa62014-05-19 20:14:13 +000010589 if (FD->hasAttr<DLLImportAttr>() && !FD->isInlined() &&
10590 !FD->isTemplateInstantiation()) {
Hans Wennborgb0f2f142014-05-15 22:07:49 +000010591 assert(!FD->hasAttr<DLLExportAttr>());
10592 Diag(FD->getLocation(), diag::err_attribute_dllimport_function_definition);
10593 FD->setInvalidDecl();
10594 return D;
Anton Korobeynikovd72f47a2008-12-26 00:52:02 +000010595 }
Dmitri Gribenkob2610882012-08-14 17:17:18 +000010596 // We want to attach documentation to original Decl (which might be
10597 // a function template).
10598 ActOnDocumentableDecl(D);
Fariborz Jahanian3451df82014-05-28 17:02:35 +000010599 if (getCurLexicalContext()->isObjCContainer() &&
10600 getCurLexicalContext()->getDeclKind() != Decl::ObjCCategoryImpl &&
10601 getCurLexicalContext()->getDeclKind() != Decl::ObjCImplementation)
10602 Diag(FD->getLocation(), diag::warn_function_def_in_objc_container);
10603
Argyrios Kyrtzidis26444c52012-12-14 06:54:03 +000010604 return D;
Chris Lattnere168f762006-11-10 05:29:30 +000010605}
10606
Douglas Gregor6fd1b182010-05-15 06:01:05 +000010607/// \brief Given the set of return statements within a function body,
10608/// compute the variables that are subject to the named return value
10609/// optimization.
10610///
10611/// Each of the variables that is subject to the named return value
10612/// optimization will be marked as NRVO variables in the AST, and any
10613/// return statement that has a marked NRVO variable as its NRVO candidate can
10614/// use the named return value optimization.
10615///
10616/// This function applies a very simplistic algorithm for NRVO: if every return
Nick Lewyckyd78f92f2014-05-03 00:41:18 +000010617/// statement in the scope of a variable has the same NRVO candidate, that
10618/// candidate is an NRVO variable.
Douglas Gregor49695f02011-09-06 20:46:03 +000010619void Sema::computeNRVO(Stmt *Body, FunctionScopeInfo *Scope) {
John McCallaab3e412010-08-25 08:40:02 +000010620 ReturnStmt **Returns = Scope->Returns.data();
10621
John McCallaab3e412010-08-25 08:40:02 +000010622 for (unsigned I = 0, E = Scope->Returns.size(); I != E; ++I) {
Nick Lewyckyd78f92f2014-05-03 00:41:18 +000010623 if (const VarDecl *NRVOCandidate = Returns[I]->getNRVOCandidate()) {
10624 if (!NRVOCandidate->isNRVOVariable())
10625 Returns[I]->setNRVOCandidate(nullptr);
10626 }
Douglas Gregor6fd1b182010-05-15 06:01:05 +000010627 }
Douglas Gregor6fd1b182010-05-15 06:01:05 +000010628}
10629
Richard Smith8e6002f2014-03-12 23:14:33 +000010630bool Sema::canDelayFunctionBody(const Declarator &D) {
10631 // We can't delay parsing the body of a constexpr function template (yet).
10632 if (D.getDeclSpec().isConstexprSpecified())
10633 return false;
10634
10635 // We can't delay parsing the body of a function template with a deduced
10636 // return type (yet).
10637 if (D.getDeclSpec().containsPlaceholderType()) {
10638 // If the placeholder introduces a non-deduced trailing return type,
10639 // we can still delay parsing it.
10640 if (D.getNumTypeObjects()) {
10641 const auto &Outer = D.getTypeObject(D.getNumTypeObjects() - 1);
10642 if (Outer.Kind == DeclaratorChunk::Function &&
10643 Outer.Fun.hasTrailingReturnType()) {
10644 QualType Ty = GetTypeFromParser(Outer.Fun.getTrailingReturnType());
10645 return Ty.isNull() || !Ty->isUndeducedType();
10646 }
10647 }
10648 return false;
10649 }
10650
10651 return true;
10652}
10653
Richard Smith1ab34b32012-11-19 21:13:18 +000010654bool Sema::canSkipFunctionBody(Decl *D) {
Richard Smith1ab34b32012-11-19 21:13:18 +000010655 // We cannot skip the body of a function (or function template) which is
10656 // constexpr, since we may need to evaluate its body in order to parse the
10657 // rest of the file.
Richard Smith7500ab22013-05-10 04:31:10 +000010658 // We cannot skip the body of a function with an undeduced return type,
10659 // because any callers of that function need to know the type.
Alp Tokera2794f92014-01-22 07:29:52 +000010660 if (const FunctionDecl *FD = D->getAsFunction())
Alp Toker314cc812014-01-25 16:55:45 +000010661 if (FD->isConstexpr() || FD->getReturnType()->isUndeducedType())
Alp Tokera2794f92014-01-22 07:29:52 +000010662 return false;
10663 return Consumer.shouldSkipFunctionBody(D);
Richard Smith1ab34b32012-11-19 21:13:18 +000010664}
10665
Argyrios Kyrtzidis1eb71a12012-12-06 18:59:10 +000010666Decl *Sema::ActOnSkippedFunctionBody(Decl *Decl) {
Argyrios Kyrtzidis44319182013-02-22 04:11:06 +000010667 if (FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(Decl))
Argyrios Kyrtzidis1eb71a12012-12-06 18:59:10 +000010668 FD->setHasSkippedBody();
Argyrios Kyrtzidis44319182013-02-22 04:11:06 +000010669 else if (ObjCMethodDecl *MD = dyn_cast_or_null<ObjCMethodDecl>(Decl))
Argyrios Kyrtzidis1eb71a12012-12-06 18:59:10 +000010670 MD->setHasSkippedBody();
Craig Topperc3ec1492014-05-26 06:22:03 +000010671 return ActOnFinishFunctionBody(Decl, nullptr);
Argyrios Kyrtzidis1eb71a12012-12-06 18:59:10 +000010672}
10673
John McCallfaf5fb42010-08-26 23:41:50 +000010674Decl *Sema::ActOnFinishFunctionBody(Decl *D, Stmt *BodyArg) {
Benjamin Kramer62b95d82012-08-23 21:35:17 +000010675 return ActOnFinishFunctionBody(D, BodyArg, false);
Douglas Gregor67da0d92009-05-15 17:59:04 +000010676}
10677
John McCallb268a282010-08-23 23:25:46 +000010678Decl *Sema::ActOnFinishFunctionBody(Decl *dcl, Stmt *Body,
10679 bool IsInstantiation) {
Craig Topperc3ec1492014-05-26 06:22:03 +000010680 FunctionDecl *FD = dcl ? dcl->getAsFunction() : nullptr;
Douglas Gregorc45a40a2009-08-22 00:34:47 +000010681
Ted Kremenek0b405322010-03-23 00:13:23 +000010682 sema::AnalysisBasedWarnings::Policy WP = AnalysisWarnings.getDefaultPolicy();
Craig Topperc3ec1492014-05-26 06:22:03 +000010683 sema::AnalysisBasedWarnings::Policy *ActivePolicy = nullptr;
Ted Kremenek918fe842010-03-20 21:06:02 +000010684
Douglas Gregorc45a40a2009-08-22 00:34:47 +000010685 if (FD) {
Chris Lattner960cc522009-04-18 09:36:27 +000010686 FD->setBody(Body);
John McCall5ed3caf2012-02-14 19:50:52 +000010687
Aaron Ballmandd69ef32014-08-19 15:55:55 +000010688 if (getLangOpts().CPlusPlus14 && !FD->isInvalidDecl() && Body &&
Alp Toker314cc812014-01-25 16:55:45 +000010689 !FD->isDependentContext() && FD->getReturnType()->isUndeducedType()) {
Richard Smith7500ab22013-05-10 04:31:10 +000010690 // If the function has a deduced result type but contains no 'return'
10691 // statements, the result type as written must be exactly 'auto', and
10692 // the deduced result type is 'void'.
Alp Toker314cc812014-01-25 16:55:45 +000010693 if (!FD->getReturnType()->getAs<AutoType>()) {
Richard Smith7500ab22013-05-10 04:31:10 +000010694 Diag(dcl->getLocation(), diag::err_auto_fn_no_return_but_not_auto)
Alp Toker314cc812014-01-25 16:55:45 +000010695 << FD->getReturnType();
Richard Smith7500ab22013-05-10 04:31:10 +000010696 FD->setInvalidDecl();
10697 } else {
10698 // Substitute 'void' for the 'auto' in the type.
Saleem Abdulrasool374b5aa2014-10-16 22:42:53 +000010699 TypeLoc ResultType = getReturnTypeLoc(FD);
Richard Smith7500ab22013-05-10 04:31:10 +000010700 Context.adjustDeducedFunctionResultType(
10701 FD, SubstAutoType(ResultType.getType(), Context.VoidTy));
Richard Smith2a7d4812013-05-04 07:00:32 +000010702 }
Richard Smithc38498f2015-04-27 21:27:54 +000010703 } else if (getLangOpts().CPlusPlus11 && isLambdaCallOperator(FD)) {
10704 auto *LSI = getCurLambda();
10705 if (LSI->HasImplicitReturnType) {
10706 deduceClosureReturnType(*LSI);
10707
10708 // C++11 [expr.prim.lambda]p4:
10709 // [...] if there are no return statements in the compound-statement
10710 // [the deduced type is] the type void
10711 QualType RetType =
10712 LSI->ReturnType.isNull() ? Context.VoidTy : LSI->ReturnType;
10713
10714 // Update the return type to the deduced type.
10715 const FunctionProtoType *Proto =
10716 FD->getType()->getAs<FunctionProtoType>();
10717 FD->setType(Context.getFunctionType(RetType, Proto->getParamTypes(),
10718 Proto->getExtProtoInfo()));
10719 }
Richard Smith2a7d4812013-05-04 07:00:32 +000010720 }
10721
Nick Lewycky9c7eb1d2013-02-01 08:13:20 +000010722 // The only way to be included in UndefinedButUsed is if there is an
10723 // ODR use before the definition. Avoid the expensive map lookup if this
Nick Lewyckyf0f56162013-01-31 03:23:57 +000010724 // is the first declaration.
Rafael Espindola3f9e4442013-10-19 02:13:21 +000010725 if (!FD->isFirstDecl() && FD->getPreviousDecl()->isUsed()) {
Rafael Espindola3ae00052013-05-13 00:12:11 +000010726 if (!FD->isExternallyVisible())
Nick Lewycky9c7eb1d2013-02-01 08:13:20 +000010727 UndefinedButUsed.erase(FD);
10728 else if (FD->isInlined() &&
Peter Collingbourne470d9422015-05-13 22:07:22 +000010729 !LangOpts.GNUInline &&
Nick Lewycky9c7eb1d2013-02-01 08:13:20 +000010730 (!FD->getPreviousDecl()->hasAttr<GNUInlineAttr>()))
10731 UndefinedButUsed.erase(FD);
10732 }
Nick Lewyckyf0f56162013-01-31 03:23:57 +000010733
John McCall5ed3caf2012-02-14 19:50:52 +000010734 // If the function implicitly returns zero (like 'main') or is naked,
10735 // don't complain about missing return statements.
10736 if (FD->hasImplicitReturnZero() || FD->hasAttr<NakedAttr>())
Ted Kremenek0b405322010-03-23 00:13:23 +000010737 WP.disableCheckFallThrough();
Mike Stump11289f42009-09-09 15:08:12 +000010738
Francois Pichet3abc9b82011-05-11 02:14:46 +000010739 // MSVC permits the use of pure specifier (=0) on function definition,
Alp Tokerd4733632013-12-05 04:47:09 +000010740 // defined at class scope, warn about this non-standard construct.
Reid Klecknerbe7a4462013-10-08 22:45:29 +000010741 if (getLangOpts().MicrosoftExt && FD->isPure() && FD->isCanonicalDecl())
Richard Smith1b98ccc2014-07-19 01:39:17 +000010742 Diag(FD->getLocation(), diag::ext_pure_function_definition);
Francois Pichet3abc9b82011-05-11 02:14:46 +000010743
Douglas Gregor88d292c2010-05-13 16:44:06 +000010744 if (!FD->isInvalidDecl()) {
Reid Kleckner121b1a12014-04-30 16:31:28 +000010745 // Don't diagnose unused parameters of defaulted or deleted functions.
Benjamin Kramer8610cae2015-03-12 14:28:47 +000010746 if (!FD->isDeleted() && !FD->isDefaulted())
Reid Kleckner121b1a12014-04-30 16:31:28 +000010747 DiagnoseUnusedParameters(FD->param_begin(), FD->param_end());
Argyrios Kyrtzidisaf84ec02010-11-17 23:11:54 +000010748 DiagnoseSizeOfParametersAndReturnValue(FD->param_begin(), FD->param_end(),
Alp Toker314cc812014-01-25 16:55:45 +000010749 FD->getReturnType(), FD);
10750
Nico Weber8b51ae92015-01-13 03:52:11 +000010751 // If this is a structor, we need a vtable.
Douglas Gregor88d292c2010-05-13 16:44:06 +000010752 if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(FD))
10753 MarkVTableUsed(FD->getLocation(), Constructor->getParent());
Nico Weber8b51ae92015-01-13 03:52:11 +000010754 else if (CXXDestructorDecl *Destructor = dyn_cast<CXXDestructorDecl>(FD))
10755 MarkVTableUsed(FD->getLocation(), Destructor->getParent());
Douglas Gregor6fd1b182010-05-15 06:01:05 +000010756
Jordan Rosed39e5f12012-07-02 21:19:23 +000010757 // Try to apply the named return value optimization. We have to check
10758 // if we can do this here because lambdas keep return statements around
10759 // to deduce an implicit return type.
Alp Toker314cc812014-01-25 16:55:45 +000010760 if (getLangOpts().CPlusPlus && FD->getReturnType()->isRecordType() &&
Jordan Rosed39e5f12012-07-02 21:19:23 +000010761 !FD->isDependentContext())
10762 computeNRVO(Body, getCurFunction());
Douglas Gregor88d292c2010-05-13 16:44:06 +000010763 }
Richard Smith91c18de2015-02-28 01:01:56 +000010764
Benjamin Kramer8610cae2015-03-12 14:28:47 +000010765 // GNU warning -Wmissing-prototypes:
10766 // Warn if a global function is defined without a previous
10767 // prototype declaration. This warning is issued even if the
10768 // definition itself provides a prototype. The aim is to detect
10769 // global functions that fail to be declared in header files.
10770 const FunctionDecl *PossibleZeroParamPrototype = nullptr;
10771 if (ShouldWarnAboutMissingPrototype(FD, PossibleZeroParamPrototype)) {
10772 Diag(FD->getLocation(), diag::warn_missing_prototype) << FD;
10773
10774 if (PossibleZeroParamPrototype) {
10775 // We found a declaration that is not a prototype,
10776 // but that could be a zero-parameter prototype
10777 if (TypeSourceInfo *TI =
10778 PossibleZeroParamPrototype->getTypeSourceInfo()) {
10779 TypeLoc TL = TI->getTypeLoc();
10780 if (FunctionNoProtoTypeLoc FTL = TL.getAs<FunctionNoProtoTypeLoc>())
10781 Diag(PossibleZeroParamPrototype->getLocation(),
10782 diag::note_declaration_not_a_prototype)
10783 << PossibleZeroParamPrototype
10784 << FixItHint::CreateInsertion(FTL.getRParenLoc(), "void");
10785 }
10786 }
10787 }
10788
Richard Smith91c18de2015-02-28 01:01:56 +000010789 if (auto *MD = dyn_cast<CXXMethodDecl>(FD)) {
10790 const CXXMethodDecl *KeyFunction;
10791 if (MD->isOutOfLine() && (MD = MD->getCanonicalDecl()) &&
10792 MD->isVirtual() &&
10793 (KeyFunction = Context.getCurrentKeyFunction(MD->getParent())) &&
10794 MD == KeyFunction->getCanonicalDecl()) {
10795 // Update the key-function state if necessary for this ABI.
10796 if (FD->isInlined() &&
10797 !Context.getTargetInfo().getCXXABI().canKeyFunctionBeInline()) {
10798 Context.setNonKeyFunction(MD);
10799
10800 // If the newly-chosen key function is already defined, then we
10801 // need to mark the vtable as used retroactively.
10802 KeyFunction = Context.getCurrentKeyFunction(MD->getParent());
10803 const FunctionDecl *Definition;
10804 if (KeyFunction && KeyFunction->isDefined(Definition))
10805 MarkVTableUsed(Definition->getLocation(), MD->getParent(), true);
10806 } else {
10807 // We just defined they key function; mark the vtable as used.
10808 MarkVTableUsed(FD->getLocation(), MD->getParent(), true);
10809 }
10810 }
10811 }
10812
Douglas Gregor21f46922012-02-08 20:17:14 +000010813 assert((FD == getCurFunctionDecl() || getCurLambda()->CallOperator == FD) &&
10814 "Function parsing confused");
Steve Naroff542cd5d2008-07-25 17:57:26 +000010815 } else if (ObjCMethodDecl *MD = dyn_cast_or_null<ObjCMethodDecl>(dcl)) {
Chris Lattner1598a3a2009-02-16 19:27:54 +000010816 assert(MD == getCurMethodDecl() && "Method parsing confused");
Chris Lattner960cc522009-04-18 09:36:27 +000010817 MD->setBody(Body);
Argyrios Kyrtzidisaf84ec02010-11-17 23:11:54 +000010818 if (!MD->isInvalidDecl()) {
Douglas Gregorc9c02ed2009-06-19 23:52:42 +000010819 DiagnoseUnusedParameters(MD->param_begin(), MD->param_end());
Argyrios Kyrtzidisaf84ec02010-11-17 23:11:54 +000010820 DiagnoseSizeOfParametersAndReturnValue(MD->param_begin(), MD->param_end(),
Alp Toker314cc812014-01-25 16:55:45 +000010821 MD->getReturnType(), MD);
10822
Douglas Gregore3f3ea02011-09-06 20:33:37 +000010823 if (Body)
Douglas Gregor49695f02011-09-06 20:46:03 +000010824 computeNRVO(Body, getCurFunction());
Argyrios Kyrtzidisaf84ec02010-11-17 23:11:54 +000010825 }
Jordan Rose2afd6612012-10-19 16:05:26 +000010826 if (getCurFunction()->ObjCShouldCallSuper) {
Fariborz Jahanianb05417e2012-09-10 16:51:09 +000010827 Diag(MD->getLocEnd(), diag::warn_objc_missing_super_call)
10828 << MD->getSelector().getAsString();
Jordan Rose2afd6612012-10-19 16:05:26 +000010829 getCurFunction()->ObjCShouldCallSuper = false;
Nico Weber1fb82662011-08-28 22:35:17 +000010830 }
Argyrios Kyrtzidis22bfa2c2013-12-03 21:11:36 +000010831 if (getCurFunction()->ObjCWarnForNoDesignatedInitChain) {
Craig Topperc3ec1492014-05-26 06:22:03 +000010832 const ObjCMethodDecl *InitMethod = nullptr;
Argyrios Kyrtzidisfcded9b2013-12-03 21:11:43 +000010833 bool isDesignated =
10834 MD->isDesignatedInitializerForTheInterface(&InitMethod);
Argyrios Kyrtzidis22bfa2c2013-12-03 21:11:36 +000010835 assert(isDesignated && InitMethod);
10836 (void)isDesignated;
Argyrios Kyrtzidisde103662014-04-16 18:32:51 +000010837
10838 auto superIsNSObject = [&](const ObjCMethodDecl *MD) {
10839 auto IFace = MD->getClassInterface();
10840 if (!IFace)
10841 return false;
10842 auto SuperD = IFace->getSuperClass();
10843 if (!SuperD)
10844 return false;
10845 return SuperD->getIdentifier() ==
10846 NSAPIObj->getNSClassId(NSAPI::ClassId_NSObject);
10847 };
10848 // Don't issue this warning for unavailable inits or direct subclasses
10849 // of NSObject.
10850 if (!MD->isUnavailable() && !superIsNSObject(MD)) {
Fariborz Jahaniane3b5c992014-03-14 23:30:18 +000010851 Diag(MD->getLocation(),
10852 diag::warn_objc_designated_init_missing_super_call);
10853 Diag(InitMethod->getLocation(),
10854 diag::note_objc_designated_init_marked_here);
10855 }
Argyrios Kyrtzidis22bfa2c2013-12-03 21:11:36 +000010856 getCurFunction()->ObjCWarnForNoDesignatedInitChain = false;
10857 }
Argyrios Kyrtzidisb66d3cf2013-12-03 21:11:49 +000010858 if (getCurFunction()->ObjCWarnForNoInitDelegation) {
Fariborz Jahaniane3b5c992014-03-14 23:30:18 +000010859 // Don't issue this warning for unavaialable inits.
10860 if (!MD->isUnavailable())
Nico Weber3b00fdc2015-03-07 19:52:39 +000010861 Diag(MD->getLocation(),
10862 diag::warn_objc_secondary_init_missing_init_call);
Argyrios Kyrtzidisb66d3cf2013-12-03 21:11:49 +000010863 getCurFunction()->ObjCWarnForNoInitDelegation = false;
10864 }
Ted Kremenek5a201952009-02-07 01:47:29 +000010865 } else {
Craig Topperc3ec1492014-05-26 06:22:03 +000010866 return nullptr;
Ted Kremenek5a201952009-02-07 01:47:29 +000010867 }
Douglas Gregor67da0d92009-05-15 17:59:04 +000010868
Jordan Rose2afd6612012-10-19 16:05:26 +000010869 assert(!getCurFunction()->ObjCShouldCallSuper &&
Eli Friedman22be06a2012-08-01 21:02:59 +000010870 "This should only be set for ObjC methods, which should have been "
10871 "handled in the block above.");
Nico Weber715abaf2011-08-22 17:25:57 +000010872
Chris Lattnere2473062007-05-28 06:28:18 +000010873 // Verify and clean out per-function state.
Benjamin Kramer8610cae2015-03-12 14:28:47 +000010874 if (Body && (!FD || !FD->isDefaulted())) {
Douglas Gregor9a28e842010-03-01 23:15:13 +000010875 // C++ constructors that have function-try-blocks can't have return
10876 // statements in the handlers of that block. (C++ [except.handle]p14)
10877 // Verify this.
10878 if (FD && isa<CXXConstructorDecl>(FD) && isa<CXXTryStmt>(Body))
10879 DiagnoseReturnInConstructorExceptionHandler(cast<CXXTryStmt>(Body));
10880
Richard Smithdef8bdb2011-08-12 18:44:32 +000010881 // Verify that gotos and switch cases don't jump into scopes illegally.
John McCallaab3e412010-08-25 08:40:02 +000010882 if (getCurFunction()->NeedsScopeChecking() &&
Douglas Gregor5d944db2012-08-17 05:12:08 +000010883 !PP.isCodeCompletionEnabled())
Douglas Gregor9a28e842010-03-01 23:15:13 +000010884 DiagnoseInvalidJumps(Body);
Mike Stump11289f42009-09-09 15:08:12 +000010885
John McCalldeb646e2010-08-04 01:04:25 +000010886 if (CXXDestructorDecl *Destructor = dyn_cast<CXXDestructorDecl>(dcl)) {
10887 if (!Destructor->getParent()->isDependentType())
10888 CheckDestructor(Destructor);
10889
John McCalla6309952010-03-16 21:39:52 +000010890 MarkBaseAndMemberDestructorsReferenced(Destructor->getLocation(),
10891 Destructor->getParent());
John McCalldeb646e2010-08-04 01:04:25 +000010892 }
Douglas Gregor9a28e842010-03-01 23:15:13 +000010893
10894 // If any errors have occurred, clear out any temporaries that may have
10895 // been leftover. This ensures that these temporaries won't be picked up for
10896 // deletion in some later function.
Alp Tokerb6cc5922014-05-03 03:45:55 +000010897 if (getDiagnostics().hasErrorOccurred() ||
10898 getDiagnostics().getSuppressAllDiagnostics()) {
John McCall28fc7092011-11-10 05:35:25 +000010899 DiscardCleanupsInEvaluationContext();
DeLesley Hutchins8ecd4912012-12-07 22:53:48 +000010900 }
Alp Tokerb6cc5922014-05-03 03:45:55 +000010901 if (!getDiagnostics().hasUncompilableErrorOccurred() &&
DeLesley Hutchins8ecd4912012-12-07 22:53:48 +000010902 !isa<FunctionTemplateDecl>(dcl)) {
Ted Kremenek918fe842010-03-20 21:06:02 +000010903 // Since the body is valid, issue any analysis-based warnings that are
10904 // enabled.
Ted Kremenek1767a272011-02-23 01:51:48 +000010905 ActivePolicy = &WP;
Ted Kremenek918fe842010-03-20 21:06:02 +000010906 }
10907
Richard Smith3607ffe2012-02-13 03:54:03 +000010908 if (!IsInstantiation && FD && FD->isConstexpr() && !FD->isInvalidDecl() &&
10909 (!CheckConstexprFunctionDecl(FD) ||
10910 !CheckConstexprFunctionBody(FD, Body)))
Richard Smitheb3c10c2011-10-01 02:31:28 +000010911 FD->setInvalidDecl();
10912
Hans Wennborgd62cdd2c2014-09-04 22:16:40 +000010913 if (FD && FD->hasAttr<NakedAttr>()) {
10914 for (const Stmt *S : Body->children()) {
Ehsan Akhgari5c00c312014-09-09 02:49:40 +000010915 if (!isa<AsmStmt>(S) && !isa<NullStmt>(S)) {
Hans Wennborgd62cdd2c2014-09-04 22:16:40 +000010916 Diag(S->getLocStart(), diag::err_non_asm_stmt_in_naked_function);
10917 Diag(FD->getAttr<NakedAttr>()->getLocation(), diag::note_attribute);
10918 FD->setInvalidDecl();
10919 break;
10920 }
10921 }
10922 }
10923
Nico Weber3b00fdc2015-03-07 19:52:39 +000010924 assert(ExprCleanupObjects.size() ==
10925 ExprEvalContexts.back().NumCleanupObjects &&
10926 "Leftover temporaries in function");
John McCall31168b02011-06-15 23:02:42 +000010927 assert(!ExprNeedsCleanups && "Unaccounted cleanups in function");
Eli Friedman3bda6b12012-02-02 23:15:15 +000010928 assert(MaybeODRUseExprs.empty() &&
10929 "Leftover expressions for odr-use checking");
Douglas Gregor9a28e842010-03-01 23:15:13 +000010930 }
10931
John McCalle99d5f32010-03-25 22:08:03 +000010932 if (!IsInstantiation)
10933 PopDeclContext();
10934
Eli Friedman71c80552012-01-05 03:35:19 +000010935 PopFunctionScopeInfo(ActivePolicy, dcl);
Douglas Gregora7e3ea32009-11-15 07:07:58 +000010936 // If any errors have occurred, clear out any temporaries that may have
10937 // been leftover. This ensures that these temporaries won't be picked up for
10938 // deletion in some later function.
John McCall31168b02011-06-15 23:02:42 +000010939 if (getDiagnostics().hasErrorOccurred()) {
John McCall28fc7092011-11-10 05:35:25 +000010940 DiscardCleanupsInEvaluationContext();
John McCall31168b02011-06-15 23:02:42 +000010941 }
Argyrios Kyrtzidis35672e72010-08-13 18:42:17 +000010942
John McCall48871652010-08-21 09:40:31 +000010943 return dcl;
Fariborz Jahanian85e1d0d2007-11-10 16:31:34 +000010944}
10945
Caitlin Sadowski9385dd72011-09-08 17:42:22 +000010946
10947/// When we finish delayed parsing of an attribute, we must attach it to the
10948/// relevant Decl.
10949void Sema::ActOnFinishDelayedAttribute(Scope *S, Decl *D,
10950 ParsedAttributes &Attrs) {
DeLesley Hutchinsceec3062012-01-20 22:37:06 +000010951 // Always attach attributes to the underlying decl.
10952 if (TemplateDecl *TD = dyn_cast<TemplateDecl>(D))
10953 D = TD->getTemplatedDecl();
Douglas Gregor3024f072012-04-16 07:05:22 +000010954 ProcessDeclAttributeList(S, D, Attrs.getList());
10955
10956 if (CXXMethodDecl *Method = dyn_cast_or_null<CXXMethodDecl>(D))
10957 if (Method->isStatic())
10958 checkThisInStaticMemberFunctionAttributes(Method);
Caitlin Sadowski9385dd72011-09-08 17:42:22 +000010959}
10960
10961
Chris Lattnerac18be92006-11-20 06:49:47 +000010962/// ImplicitlyDefineFunction - An undeclared identifier was used in a function
10963/// call, forming a call to an implicitly defined function (per C99 6.5.1p2).
Mike Stump11289f42009-09-09 15:08:12 +000010964NamedDecl *Sema::ImplicitlyDefineFunction(SourceLocation Loc,
Douglas Gregor6e6ad602009-01-20 01:17:11 +000010965 IdentifierInfo &II, Scope *S) {
Douglas Gregor5a80bd12009-03-02 00:19:53 +000010966 // Before we produce a declaration for an implicitly defined
10967 // function, see whether there was a locally-scoped declaration of
10968 // this name as a function or variable. If so, use that
10969 // (non-visible) declaration, and complain about it.
Richard Smith39b79682013-06-18 20:15:12 +000010970 if (NamedDecl *ExternCPrev = findLocallyScopedExternCDecl(&II)) {
10971 Diag(Loc, diag::warn_use_out_of_scope_declaration) << ExternCPrev;
10972 Diag(ExternCPrev->getLocation(), diag::note_previous_declaration);
10973 return ExternCPrev;
Douglas Gregor5a80bd12009-03-02 00:19:53 +000010974 }
10975
Chris Lattner00e26072008-05-05 21:18:06 +000010976 // Extension in C99. Legal in C90, but warn about it.
Hans Wennborg70a13242011-12-08 15:56:07 +000010977 unsigned diag_id;
Daniel Dunbar07d07852009-10-18 21:17:35 +000010978 if (II.getName().startswith("__builtin_"))
Abramo Bagnara3732fa52012-01-09 10:05:48 +000010979 diag_id = diag::warn_builtin_unknown;
David Blaikiebbafb8a2012-03-11 07:00:24 +000010980 else if (getLangOpts().C99)
Hans Wennborg70a13242011-12-08 15:56:07 +000010981 diag_id = diag::ext_implicit_function_decl;
Chris Lattner00e26072008-05-05 21:18:06 +000010982 else
Hans Wennborg70a13242011-12-08 15:56:07 +000010983 diag_id = diag::warn_implicit_function_decl;
10984 Diag(Loc, diag_id) << &II;
Mike Stump11289f42009-09-09 15:08:12 +000010985
Hans Wennborg70a13242011-12-08 15:56:07 +000010986 // Because typo correction is expensive, only do it if the implicit
10987 // function declaration is going to be treated as an error.
10988 if (Diags.getDiagnosticLevel(diag_id, Loc) >= DiagnosticsEngine::Error) {
10989 TypoCorrection Corrected;
Kaelyn Takata89c881b2014-10-27 18:07:29 +000010990 if (S &&
10991 (Corrected = CorrectTypo(
10992 DeclarationNameInfo(&II, Loc), LookupOrdinaryName, S, nullptr,
10993 llvm::make_unique<DeclFilterCCC<FunctionDecl>>(), CTK_NonError)))
Richard Smithf9b15102013-08-17 00:46:16 +000010994 diagnoseTypo(Corrected, PDiag(diag::note_function_suggestion),
10995 /*ErrorRecovery*/false);
Hans Wennborg2fb8b912011-12-06 09:46:12 +000010996 }
10997
Chris Lattnerac18be92006-11-20 06:49:47 +000010998 // Set a Declarator for the implicit definition: int foo();
Chris Lattner353f5742006-11-28 04:50:12 +000010999 const char *Dummy;
John McCall084e83d2011-03-24 11:26:52 +000011000 AttributeFactory attrFactory;
11001 DeclSpec DS(attrFactory);
John McCall49bfce42009-08-03 20:12:06 +000011002 unsigned DiagID;
Erik Verbruggen888d52a2014-01-15 09:15:43 +000011003 bool Error = DS.SetTypeSpecType(DeclSpec::TST_int, Loc, Dummy, DiagID,
11004 Context.getPrintingPolicy());
Jeffrey Yasskinb3321532010-12-23 01:01:28 +000011005 (void)Error; // Silence warning.
Chris Lattner353f5742006-11-28 04:50:12 +000011006 assert(!Error && "Error setting up implicit decl!");
Abramo Bagnaraaeeb9892012-10-04 21:42:10 +000011007 SourceLocation NoLoc;
Chris Lattnerac18be92006-11-20 06:49:47 +000011008 Declarator D(DS, Declarator::BlockContext);
Abramo Bagnaraaeeb9892012-10-04 21:42:10 +000011009 D.AddTypeInfo(DeclaratorChunk::getFunction(/*HasProto=*/false,
11010 /*IsAmbiguous=*/false,
Richard Smith151b8a32014-04-07 15:16:58 +000011011 /*LParenLoc=*/NoLoc,
Craig Topperc3ec1492014-05-26 06:22:03 +000011012 /*Params=*/nullptr,
Richard Smith151b8a32014-04-07 15:16:58 +000011013 /*NumParams=*/0,
Abramo Bagnaraaeeb9892012-10-04 21:42:10 +000011014 /*EllipsisLoc=*/NoLoc,
11015 /*RParenLoc=*/NoLoc,
11016 /*TypeQuals=*/0,
11017 /*RefQualifierIsLvalueRef=*/true,
11018 /*RefQualifierLoc=*/NoLoc,
11019 /*ConstQualifierLoc=*/NoLoc,
11020 /*VolatileQualifierLoc=*/NoLoc,
Hal Finkel23a07392014-10-20 17:32:04 +000011021 /*RestrictQualifierLoc=*/NoLoc,
Abramo Bagnaraaeeb9892012-10-04 21:42:10 +000011022 /*MutableLoc=*/NoLoc,
11023 EST_None,
11024 /*ESpecLoc=*/NoLoc,
Craig Topperc3ec1492014-05-26 06:22:03 +000011025 /*Exceptions=*/nullptr,
11026 /*ExceptionRanges=*/nullptr,
Abramo Bagnaraaeeb9892012-10-04 21:42:10 +000011027 /*NumExceptions=*/0,
Craig Topperc3ec1492014-05-26 06:22:03 +000011028 /*NoexceptExpr=*/nullptr,
Richard Smith0b3a4622014-11-13 20:01:57 +000011029 /*ExceptionSpecTokens=*/nullptr,
Abramo Bagnaraaeeb9892012-10-04 21:42:10 +000011030 Loc, Loc, D),
John McCall084e83d2011-03-24 11:26:52 +000011031 DS.getAttributes(),
Sebastian Redlf6591ca2009-02-09 18:23:29 +000011032 SourceLocation());
Chris Lattnerac18be92006-11-20 06:49:47 +000011033 D.SetIdentifier(&II, Loc);
Sebastian Redlf6591ca2009-02-09 18:23:29 +000011034
Argyrios Kyrtzidis694dda12008-05-01 21:04:16 +000011035 // Insert this function into translation-unit scope.
11036
11037 DeclContext *PrevDC = CurContext;
11038 CurContext = Context.getTranslationUnitDecl();
Mike Stump11289f42009-09-09 15:08:12 +000011039
Jordan Rosed03d99d2013-03-05 01:27:54 +000011040 FunctionDecl *FD = cast<FunctionDecl>(ActOnDeclarator(TUScope, D));
Steve Naroff3913ea42008-04-04 14:32:09 +000011041 FD->setImplicit();
Argyrios Kyrtzidis694dda12008-05-01 21:04:16 +000011042
11043 CurContext = PrevDC;
11044
Douglas Gregore711f702009-02-14 18:57:46 +000011045 AddKnownFunctionAttributes(FD);
11046
Steve Naroff3913ea42008-04-04 14:32:09 +000011047 return FD;
Chris Lattnerac18be92006-11-20 06:49:47 +000011048}
11049
Douglas Gregore711f702009-02-14 18:57:46 +000011050/// \brief Adds any function attributes that we know a priori based on
11051/// the declaration of this function.
11052///
11053/// These attributes can apply both to implicitly-declared builtins
11054/// (like __builtin___printf_chk) or to library-declared functions
11055/// like NSLog or printf.
Douglas Gregor88336832011-06-15 05:45:11 +000011056///
11057/// We need to check for duplicate attributes both here and where user-written
11058/// attributes are applied to declarations.
Douglas Gregore711f702009-02-14 18:57:46 +000011059void Sema::AddKnownFunctionAttributes(FunctionDecl *FD) {
11060 if (FD->isInvalidDecl())
11061 return;
11062
11063 // If this is a built-in function, map its builtin attributes to
11064 // actual attributes.
Douglas Gregor15fc9562009-09-12 00:22:50 +000011065 if (unsigned BuiltinID = FD->getBuiltinID()) {
Douglas Gregore711f702009-02-14 18:57:46 +000011066 // Handle printf-formatting attributes.
11067 unsigned FormatIdx;
11068 bool HasVAListArg;
11069 if (Context.BuiltinInfo.isPrintfLike(BuiltinID, FormatIdx, HasVAListArg)) {
Aaron Ballman9ead1242013-12-19 02:39:40 +000011070 if (!FD->hasAttr<FormatAttr>()) {
Jean-Daniel Dupas78536ae2012-01-24 22:32:46 +000011071 const char *fmt = "printf";
11072 unsigned int NumParams = FD->getNumParams();
11073 if (FormatIdx < NumParams && // NumParams may be 0 (e.g. vfprintf)
11074 FD->getParamDecl(FormatIdx)->getType()->isObjCObjectPointerType())
11075 fmt = "NSString";
Aaron Ballman36a53502014-01-16 13:03:14 +000011076 FD->addAttr(FormatAttr::CreateImplicit(Context,
Aaron Ballmanf58070b2013-09-03 21:02:22 +000011077 &Context.Idents.get(fmt),
11078 FormatIdx+1,
Aaron Ballman36a53502014-01-16 13:03:14 +000011079 HasVAListArg ? 0 : FormatIdx+2,
11080 FD->getLocation()));
Jean-Daniel Dupas78536ae2012-01-24 22:32:46 +000011081 }
Douglas Gregore711f702009-02-14 18:57:46 +000011082 }
Ted Kremenek5932c352010-07-16 02:11:15 +000011083 if (Context.BuiltinInfo.isScanfLike(BuiltinID, FormatIdx,
11084 HasVAListArg)) {
Aaron Ballman9ead1242013-12-19 02:39:40 +000011085 if (!FD->hasAttr<FormatAttr>())
Aaron Ballman36a53502014-01-16 13:03:14 +000011086 FD->addAttr(FormatAttr::CreateImplicit(Context,
Aaron Ballmanf58070b2013-09-03 21:02:22 +000011087 &Context.Idents.get("scanf"),
11088 FormatIdx+1,
Aaron Ballman36a53502014-01-16 13:03:14 +000011089 HasVAListArg ? 0 : FormatIdx+2,
11090 FD->getLocation()));
Ted Kremenek5932c352010-07-16 02:11:15 +000011091 }
Daniel Dunbar8eb018a2009-02-16 22:43:43 +000011092
11093 // Mark const if we don't care about errno and that is the only
11094 // thing preventing the function from being const. This allows
11095 // IRgen to use LLVM intrinsics for such functions.
David Blaikiebbafb8a2012-03-11 07:00:24 +000011096 if (!getLangOpts().MathErrno &&
Daniel Dunbar8eb018a2009-02-16 22:43:43 +000011097 Context.BuiltinInfo.isConstWithoutErrno(BuiltinID)) {
Aaron Ballman9ead1242013-12-19 02:39:40 +000011098 if (!FD->hasAttr<ConstAttr>())
Aaron Ballman36a53502014-01-16 13:03:14 +000011099 FD->addAttr(ConstAttr::CreateImplicit(Context, FD->getLocation()));
Daniel Dunbar8eb018a2009-02-16 22:43:43 +000011100 }
Mike Stumpca6c8752009-07-27 19:14:18 +000011101
Rafael Espindola2d21ab02011-10-12 19:51:18 +000011102 if (Context.BuiltinInfo.isReturnsTwice(BuiltinID) &&
Aaron Ballman9ead1242013-12-19 02:39:40 +000011103 !FD->hasAttr<ReturnsTwiceAttr>())
Aaron Ballman36a53502014-01-16 13:03:14 +000011104 FD->addAttr(ReturnsTwiceAttr::CreateImplicit(Context,
11105 FD->getLocation()));
Aaron Ballman9ead1242013-12-19 02:39:40 +000011106 if (Context.BuiltinInfo.isNoThrow(BuiltinID) && !FD->hasAttr<NoThrowAttr>())
Aaron Ballman36a53502014-01-16 13:03:14 +000011107 FD->addAttr(NoThrowAttr::CreateImplicit(Context, FD->getLocation()));
Aaron Ballman9ead1242013-12-19 02:39:40 +000011108 if (Context.BuiltinInfo.isConst(BuiltinID) && !FD->hasAttr<ConstAttr>())
Aaron Ballman36a53502014-01-16 13:03:14 +000011109 FD->addAttr(ConstAttr::CreateImplicit(Context, FD->getLocation()));
Douglas Gregore711f702009-02-14 18:57:46 +000011110 }
11111
11112 IdentifierInfo *Name = FD->getIdentifier();
11113 if (!Name)
11114 return;
David Blaikiebbafb8a2012-03-11 07:00:24 +000011115 if ((!getLangOpts().CPlusPlus &&
Douglas Gregore711f702009-02-14 18:57:46 +000011116 FD->getDeclContext()->isTranslationUnit()) ||
11117 (isa<LinkageSpecDecl>(FD->getDeclContext()) &&
Mike Stump11289f42009-09-09 15:08:12 +000011118 cast<LinkageSpecDecl>(FD->getDeclContext())->getLanguage() ==
Douglas Gregore711f702009-02-14 18:57:46 +000011119 LinkageSpecDecl::lang_c)) {
11120 // Okay: this could be a libc/libm/Objective-C function we know
11121 // about.
11122 } else
11123 return;
11124
Jean-Daniel Dupas78536ae2012-01-24 22:32:46 +000011125 if (Name->isStr("asprintf") || Name->isStr("vasprintf")) {
Mike Stump82a9e442009-07-28 00:07:08 +000011126 // FIXME: asprintf and vasprintf aren't C99 functions. Should they be
Mike Stump11289f42009-09-09 15:08:12 +000011127 // target-specific builtins, perhaps?
Aaron Ballman9ead1242013-12-19 02:39:40 +000011128 if (!FD->hasAttr<FormatAttr>())
Aaron Ballman36a53502014-01-16 13:03:14 +000011129 FD->addAttr(FormatAttr::CreateImplicit(Context,
Aaron Ballmanf58070b2013-09-03 21:02:22 +000011130 &Context.Idents.get("printf"), 2,
Aaron Ballman36a53502014-01-16 13:03:14 +000011131 Name->isStr("vasprintf") ? 0 : 3,
11132 FD->getLocation()));
Mike Stumpa4de80b2009-07-28 02:25:19 +000011133 }
Jordan Rose742c6072012-08-08 21:17:31 +000011134
11135 if (Name->isStr("__CFStringMakeConstantString")) {
11136 // We already have a __builtin___CFStringMakeConstantString,
11137 // but builds that use -fno-constant-cfstrings don't go through that.
Aaron Ballman9ead1242013-12-19 02:39:40 +000011138 if (!FD->hasAttr<FormatArgAttr>())
Aaron Ballman36a53502014-01-16 13:03:14 +000011139 FD->addAttr(FormatArgAttr::CreateImplicit(Context, 1,
11140 FD->getLocation()));
Jordan Rose742c6072012-08-08 21:17:31 +000011141 }
Douglas Gregore711f702009-02-14 18:57:46 +000011142}
Chris Lattner302b4be2006-11-19 02:31:38 +000011143
John McCall703a3f82009-10-24 08:00:42 +000011144TypedefDecl *Sema::ParseTypedefDecl(Scope *S, Declarator &D, QualType T,
John McCallbcd03502009-12-07 02:54:59 +000011145 TypeSourceInfo *TInfo) {
Chris Lattner776fac82007-06-09 00:53:06 +000011146 assert(D.getIdentifier() && "Wrong callback for declspec without declarator");
Steve Narofff93b6722007-08-28 20:14:24 +000011147 assert(!T.isNull() && "GetTypeForDeclarator() returned null type");
Mike Stump11289f42009-09-09 15:08:12 +000011148
John McCallbcd03502009-12-07 02:54:59 +000011149 if (!TInfo) {
John McCall703a3f82009-10-24 08:00:42 +000011150 assert(D.isInvalidType() && "no declarator info for valid type");
John McCallbcd03502009-12-07 02:54:59 +000011151 TInfo = Context.getTrivialTypeSourceInfo(T);
John McCall703a3f82009-10-24 08:00:42 +000011152 }
11153
Chris Lattner18b19622007-01-22 07:39:13 +000011154 // Scope manipulation handled by caller.
Chris Lattnerc5ffed42008-04-04 06:12:32 +000011155 TypedefDecl *NewTD = TypedefDecl::Create(Context, CurContext,
Daniel Dunbar62ee6412012-03-09 18:35:03 +000011156 D.getLocStart(),
Chris Lattnerc5ffed42008-04-04 06:12:32 +000011157 D.getIdentifierLoc(),
Mike Stump11289f42009-09-09 15:08:12 +000011158 D.getIdentifier(),
John McCallbcd03502009-12-07 02:54:59 +000011159 TInfo);
Mike Stump11289f42009-09-09 15:08:12 +000011160
John McCall04fcd0d2011-02-01 08:20:08 +000011161 // Bail out immediately if we have an invalid declaration.
11162 if (D.isInvalidType()) {
11163 NewTD->setInvalidDecl();
11164 return NewTD;
Anders Carlsson02751152009-03-10 17:07:44 +000011165 }
Fariborz Jahaniandb3d8552013-11-19 00:09:48 +000011166
Douglas Gregor41866812011-09-12 18:37:38 +000011167 if (D.getDeclSpec().isModulePrivateSpecified()) {
11168 if (CurContext->isFunctionOrMethod())
11169 Diag(NewTD->getLocation(), diag::err_module_private_local)
11170 << 2 << NewTD->getDeclName()
11171 << SourceRange(D.getDeclSpec().getModulePrivateSpecLoc())
11172 << FixItHint::CreateRemoval(D.getDeclSpec().getModulePrivateSpecLoc());
11173 else
11174 NewTD->setModulePrivate();
11175 }
Douglas Gregor26701a42011-09-09 02:06:17 +000011176
John McCall04fcd0d2011-02-01 08:20:08 +000011177 // C++ [dcl.typedef]p8:
11178 // If the typedef declaration defines an unnamed class (or
11179 // enum), the first typedef-name declared by the declaration
11180 // to be that class type (or enum type) is used to denote the
11181 // class type (or enum type) for linkage purposes only.
11182 // We need to check whether the type was declared in the declaration.
11183 switch (D.getDeclSpec().getTypeSpecType()) {
11184 case TST_enum:
11185 case TST_struct:
Joao Matosdc86f942012-08-31 18:45:21 +000011186 case TST_interface:
John McCall04fcd0d2011-02-01 08:20:08 +000011187 case TST_union:
11188 case TST_class: {
11189 TagDecl *tagFromDeclSpec = cast<TagDecl>(D.getDeclSpec().getRepAsDecl());
David Majnemerf9bde282015-03-11 06:45:39 +000011190 setTagNameForLinkagePurposes(tagFromDeclSpec, NewTD);
John McCall04fcd0d2011-02-01 08:20:08 +000011191 break;
11192 }
David Majnemerf9bde282015-03-11 06:45:39 +000011193
John McCall04fcd0d2011-02-01 08:20:08 +000011194 default:
11195 break;
11196 }
11197
Steve Narofff93b6722007-08-28 20:14:24 +000011198 return NewTD;
Chris Lattnere168f762006-11-10 05:29:30 +000011199}
11200
Douglas Gregord9034f02009-05-14 16:41:31 +000011201
Richard Smith4b38ded2012-03-14 23:13:10 +000011202/// \brief Check that this is a valid underlying type for an enum declaration.
11203bool Sema::CheckEnumUnderlyingType(TypeSourceInfo *TI) {
11204 SourceLocation UnderlyingLoc = TI->getTypeLoc().getBeginLoc();
11205 QualType T = TI->getType();
11206
Eli Friedman52f32b92012-12-18 02:37:32 +000011207 if (T->isDependentType())
Richard Smith4b38ded2012-03-14 23:13:10 +000011208 return false;
11209
Eli Friedman52f32b92012-12-18 02:37:32 +000011210 if (const BuiltinType *BT = T->getAs<BuiltinType>())
11211 if (BT->isInteger())
11212 return false;
11213
Richard Smith4b38ded2012-03-14 23:13:10 +000011214 Diag(UnderlyingLoc, diag::err_enum_invalid_underlying) << T;
11215 return true;
11216}
11217
11218/// Check whether this is a valid redeclaration of a previous enumeration.
11219/// \return true if the redeclaration was invalid.
11220bool Sema::CheckEnumRedeclaration(SourceLocation EnumLoc, bool IsScoped,
11221 QualType EnumUnderlyingTy,
11222 const EnumDecl *Prev) {
11223 bool IsFixed = !EnumUnderlyingTy.isNull();
11224
11225 if (IsScoped != Prev->isScoped()) {
11226 Diag(EnumLoc, diag::err_enum_redeclare_scoped_mismatch)
11227 << Prev->isScoped();
Alp Toker8c44db52014-01-06 11:31:06 +000011228 Diag(Prev->getLocation(), diag::note_previous_declaration);
Richard Smith4b38ded2012-03-14 23:13:10 +000011229 return true;
11230 }
11231
11232 if (IsFixed && Prev->isFixed()) {
Richard Smith258a7442012-03-26 04:08:46 +000011233 if (!EnumUnderlyingTy->isDependentType() &&
11234 !Prev->getIntegerType()->isDependentType() &&
11235 !Context.hasSameUnqualifiedType(EnumUnderlyingTy,
Richard Smith4b38ded2012-03-14 23:13:10 +000011236 Prev->getIntegerType())) {
Alp Tokerb9fa5122014-01-06 11:31:18 +000011237 // TODO: Highlight the underlying type of the redeclaration.
Richard Smith4b38ded2012-03-14 23:13:10 +000011238 Diag(EnumLoc, diag::err_enum_redeclare_type_mismatch)
11239 << EnumUnderlyingTy << Prev->getIntegerType();
Alp Tokerb9fa5122014-01-06 11:31:18 +000011240 Diag(Prev->getLocation(), diag::note_previous_declaration)
11241 << Prev->getIntegerTypeRange();
Richard Smith4b38ded2012-03-14 23:13:10 +000011242 return true;
11243 }
11244 } else if (IsFixed != Prev->isFixed()) {
11245 Diag(EnumLoc, diag::err_enum_redeclare_fixed_mismatch)
11246 << Prev->isFixed();
Alp Toker8c44db52014-01-06 11:31:06 +000011247 Diag(Prev->getLocation(), diag::note_previous_declaration);
Richard Smith4b38ded2012-03-14 23:13:10 +000011248 return true;
11249 }
11250
11251 return false;
11252}
11253
Joao Matosdc86f942012-08-31 18:45:21 +000011254/// \brief Get diagnostic %select index for tag kind for
11255/// redeclaration diagnostic message.
11256/// WARNING: Indexes apply to particular diagnostics only!
11257///
11258/// \returns diagnostic %select index.
Joao Matosa5c42e92012-09-01 00:13:24 +000011259static unsigned getRedeclDiagFromTagKind(TagTypeKind Tag) {
Joao Matosdc86f942012-08-31 18:45:21 +000011260 switch (Tag) {
Joao Matosa5c42e92012-09-01 00:13:24 +000011261 case TTK_Struct: return 0;
11262 case TTK_Interface: return 1;
11263 case TTK_Class: return 2;
11264 default: llvm_unreachable("Invalid tag kind for redecl diagnostic!");
Joao Matosdc86f942012-08-31 18:45:21 +000011265 }
Joao Matosdc86f942012-08-31 18:45:21 +000011266}
11267
11268/// \brief Determine if tag kind is a class-key compatible with
11269/// class for redeclaration (class, struct, or __interface).
11270///
Sylvestre Ledru33b5baf2012-09-27 10:16:10 +000011271/// \returns true iff the tag kind is compatible.
Joao Matosdc86f942012-08-31 18:45:21 +000011272static bool isClassCompatTagKind(TagTypeKind Tag)
11273{
11274 return Tag == TTK_Struct || Tag == TTK_Class || Tag == TTK_Interface;
11275}
11276
Douglas Gregord9034f02009-05-14 16:41:31 +000011277/// \brief Determine whether a tag with a given kind is acceptable
11278/// as a redeclaration of the given tag declaration.
11279///
11280/// \returns true if the new tag kind is acceptable, false otherwise.
Mike Stump11289f42009-09-09 15:08:12 +000011281bool Sema::isAcceptableTagRedeclaration(const TagDecl *Previous,
Richard Trieucaa33d32011-06-10 03:11:26 +000011282 TagTypeKind NewTag, bool isDefinition,
Douglas Gregord9034f02009-05-14 16:41:31 +000011283 SourceLocation NewTagLoc,
11284 const IdentifierInfo &Name) {
11285 // C++ [dcl.type.elab]p3:
11286 // The class-key or enum keyword present in the
11287 // elaborated-type-specifier shall agree in kind with the
Abramo Bagnara6150c882010-05-11 21:36:43 +000011288 // declaration to which the name in the elaborated-type-specifier
Douglas Gregord9034f02009-05-14 16:41:31 +000011289 // refers. This rule also applies to the form of
11290 // elaborated-type-specifier that declares a class-name or
11291 // friend class since it can be construed as referring to the
11292 // definition of the class. Thus, in any
11293 // elaborated-type-specifier, the enum keyword shall be used to
Abramo Bagnara6150c882010-05-11 21:36:43 +000011294 // refer to an enumeration (7.2), the union class-key shall be
Douglas Gregord9034f02009-05-14 16:41:31 +000011295 // used to refer to a union (clause 9), and either the class or
11296 // struct class-key shall be used to refer to a class (clause 9)
11297 // declared using the class or struct class-key.
Abramo Bagnara6150c882010-05-11 21:36:43 +000011298 TagTypeKind OldTag = Previous->getTagKind();
Joao Matosdc86f942012-08-31 18:45:21 +000011299 if (!isDefinition || !isClassCompatTagKind(NewTag))
Richard Trieucaa33d32011-06-10 03:11:26 +000011300 if (OldTag == NewTag)
11301 return true;
Mike Stump11289f42009-09-09 15:08:12 +000011302
Joao Matosdc86f942012-08-31 18:45:21 +000011303 if (isClassCompatTagKind(OldTag) && isClassCompatTagKind(NewTag)) {
Douglas Gregord9034f02009-05-14 16:41:31 +000011304 // Warn about the struct/class tag mismatch.
11305 bool isTemplate = false;
11306 if (const CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(Previous))
11307 isTemplate = Record->getDescribedClassTemplate();
11308
Richard Trieucaa33d32011-06-10 03:11:26 +000011309 if (!ActiveTemplateInstantiations.empty()) {
11310 // In a template instantiation, do not offer fix-its for tag mismatches
11311 // since they usually mess up the template instead of fixing the problem.
11312 Diag(NewTagLoc, diag::warn_struct_class_tag_mismatch)
Joao Matosdc86f942012-08-31 18:45:21 +000011313 << getRedeclDiagFromTagKind(NewTag) << isTemplate << &Name
11314 << getRedeclDiagFromTagKind(OldTag);
Richard Trieucaa33d32011-06-10 03:11:26 +000011315 return true;
11316 }
11317
11318 if (isDefinition) {
11319 // On definitions, check previous tags and issue a fix-it for each
11320 // one that doesn't match the current tag.
11321 if (Previous->getDefinition()) {
11322 // Don't suggest fix-its for redefinitions.
11323 return true;
11324 }
11325
11326 bool previousMismatch = false;
Aaron Ballman86c93902014-03-06 23:45:36 +000011327 for (auto I : Previous->redecls()) {
Richard Trieucaa33d32011-06-10 03:11:26 +000011328 if (I->getTagKind() != NewTag) {
11329 if (!previousMismatch) {
11330 previousMismatch = true;
11331 Diag(NewTagLoc, diag::warn_struct_class_previous_tag_mismatch)
Joao Matosdc86f942012-08-31 18:45:21 +000011332 << getRedeclDiagFromTagKind(NewTag) << isTemplate << &Name
11333 << getRedeclDiagFromTagKind(I->getTagKind());
Richard Trieucaa33d32011-06-10 03:11:26 +000011334 }
11335 Diag(I->getInnerLocStart(), diag::note_struct_class_suggestion)
Joao Matosdc86f942012-08-31 18:45:21 +000011336 << getRedeclDiagFromTagKind(NewTag)
Richard Trieucaa33d32011-06-10 03:11:26 +000011337 << FixItHint::CreateReplacement(I->getInnerLocStart(),
Joao Matosdc86f942012-08-31 18:45:21 +000011338 TypeWithKeyword::getTagTypeKindName(NewTag));
Richard Trieucaa33d32011-06-10 03:11:26 +000011339 }
11340 }
11341 return true;
11342 }
11343
11344 // Check for a previous definition. If current tag and definition
11345 // are same type, do nothing. If no definition, but disagree with
11346 // with previous tag type, give a warning, but no fix-it.
11347 const TagDecl *Redecl = Previous->getDefinition() ?
11348 Previous->getDefinition() : Previous;
11349 if (Redecl->getTagKind() == NewTag) {
11350 return true;
11351 }
11352
Douglas Gregord9034f02009-05-14 16:41:31 +000011353 Diag(NewTagLoc, diag::warn_struct_class_tag_mismatch)
Joao Matosdc86f942012-08-31 18:45:21 +000011354 << getRedeclDiagFromTagKind(NewTag) << isTemplate << &Name
11355 << getRedeclDiagFromTagKind(OldTag);
Richard Trieucaa33d32011-06-10 03:11:26 +000011356 Diag(Redecl->getLocation(), diag::note_previous_use);
11357
Alp Tokerf6a24ce2013-12-05 16:25:25 +000011358 // If there is a previous definition, suggest a fix-it.
Richard Trieucaa33d32011-06-10 03:11:26 +000011359 if (Previous->getDefinition()) {
11360 Diag(NewTagLoc, diag::note_struct_class_suggestion)
Joao Matosdc86f942012-08-31 18:45:21 +000011361 << getRedeclDiagFromTagKind(Redecl->getTagKind())
Richard Trieucaa33d32011-06-10 03:11:26 +000011362 << FixItHint::CreateReplacement(SourceRange(NewTagLoc),
Joao Matosdc86f942012-08-31 18:45:21 +000011363 TypeWithKeyword::getTagTypeKindName(Redecl->getTagKind()));
Richard Trieucaa33d32011-06-10 03:11:26 +000011364 }
11365
Douglas Gregord9034f02009-05-14 16:41:31 +000011366 return true;
11367 }
11368 return false;
11369}
11370
Reid Kleckner0902a512014-07-10 23:44:52 +000011371/// Add a minimal nested name specifier fixit hint to allow lookup of a tag name
11372/// from an outer enclosing namespace or file scope inside a friend declaration.
11373/// This should provide the commented out code in the following snippet:
11374/// namespace N {
11375/// struct X;
11376/// namespace M {
11377/// struct Y { friend struct /*N::*/ X; };
11378/// }
11379/// }
Reid Kleckner675d4382014-07-11 00:16:51 +000011380static FixItHint createFriendTagNNSFixIt(Sema &SemaRef, NamedDecl *ND, Scope *S,
11381 SourceLocation NameLoc) {
Reid Kleckner0902a512014-07-10 23:44:52 +000011382 // While the decl is in a namespace, do repeated lookup of that name and see
11383 // if we get the same namespace back. If we do not, continue until
11384 // translation unit scope, at which point we have a fully qualified NNS.
11385 SmallVector<IdentifierInfo *, 4> Namespaces;
11386 DeclContext *DC = ND->getDeclContext()->getRedeclContext();
11387 for (; !DC->isTranslationUnit(); DC = DC->getParent()) {
11388 // This tag should be declared in a namespace, which can only be enclosed by
11389 // other namespaces. Bail if there's an anonymous namespace in the chain.
11390 NamespaceDecl *Namespace = dyn_cast<NamespaceDecl>(DC);
11391 if (!Namespace || Namespace->isAnonymousNamespace())
Reid Kleckner675d4382014-07-11 00:16:51 +000011392 return FixItHint();
Reid Kleckner0902a512014-07-10 23:44:52 +000011393 IdentifierInfo *II = Namespace->getIdentifier();
11394 Namespaces.push_back(II);
11395 NamedDecl *Lookup = SemaRef.LookupSingleName(
11396 S, II, NameLoc, Sema::LookupNestedNameSpecifierName);
11397 if (Lookup == Namespace)
11398 break;
11399 }
11400
11401 // Once we have all the namespaces, reverse them to go outermost first, and
11402 // build an NNS.
11403 SmallString<64> Insertion;
11404 llvm::raw_svector_ostream OS(Insertion);
11405 if (DC->isTranslationUnit())
11406 OS << "::";
11407 std::reverse(Namespaces.begin(), Namespaces.end());
11408 for (auto *II : Namespaces)
11409 OS << II->getName() << "::";
11410 OS.flush();
Reid Kleckner675d4382014-07-11 00:16:51 +000011411 return FixItHint::CreateInsertion(NameLoc, Insertion);
Reid Kleckner0902a512014-07-10 23:44:52 +000011412}
11413
Richard Smith65ebb4a2015-03-26 04:09:53 +000011414/// \brief This is invoked when we see 'struct foo' or 'struct {'. In the
Chris Lattner1300fb92007-01-23 23:42:53 +000011415/// former case, Name will be non-null. In the later case, Name will be null.
John McCall9bb74a52009-07-31 02:45:11 +000011416/// TagSpec indicates what kind of tag this is. TUK indicates whether this is a
Chris Lattner1300fb92007-01-23 23:42:53 +000011417/// reference/declaration/definition of a tag.
Richard Smith649c7b062014-01-08 00:56:48 +000011418///
Richard Smith65ebb4a2015-03-26 04:09:53 +000011419/// \param IsTypeSpecifier \c true if this is a type-specifier (or
Richard Smith649c7b062014-01-08 00:56:48 +000011420/// trailing-type-specifier) other than one in an alias-declaration.
Richard Smith65ebb4a2015-03-26 04:09:53 +000011421///
Richard Smithd9ba2242015-05-07 03:54:19 +000011422/// \param SkipBody If non-null, will be set to indicate if the caller should
11423/// skip the definition of this tag and treat it as if it were a declaration.
John McCall48871652010-08-21 09:40:31 +000011424Decl *Sema::ActOnTag(Scope *S, unsigned TagSpec, TagUseKind TUK,
Douglas Gregor009f6992010-09-16 23:58:57 +000011425 SourceLocation KWLoc, CXXScopeSpec &SS,
11426 IdentifierInfo *Name, SourceLocation NameLoc,
11427 AttributeList *Attr, AccessSpecifier AS,
Douglas Gregor2820e692011-09-09 19:05:14 +000011428 SourceLocation ModulePrivateLoc,
Douglas Gregor009f6992010-09-16 23:58:57 +000011429 MultiTemplateParamsArg TemplateParameterLists,
Abramo Bagnara0e05e242010-12-03 18:54:17 +000011430 bool &OwnedDecl, bool &IsDependent,
Richard Smith0f8ee222012-01-10 01:33:14 +000011431 SourceLocation ScopedEnumKWLoc,
11432 bool ScopedEnumUsesClassTag,
Richard Smith649c7b062014-01-08 00:56:48 +000011433 TypeResult UnderlyingType,
Richard Smithd9ba2242015-05-07 03:54:19 +000011434 bool IsTypeSpecifier, SkipBodyInfo *SkipBody) {
Douglas Gregorc811d8f2008-12-15 16:32:14 +000011435 // If this is not a definition, it must have a name.
Douglas Gregorb7d17dd2012-03-28 16:01:27 +000011436 IdentifierInfo *OrigName = Name;
Craig Topperc3ec1492014-05-26 06:22:03 +000011437 assert((Name != nullptr || TUK == TUK_Definition) &&
Chris Lattner7b9ace62007-01-23 20:11:08 +000011438 "Nameless record must be a definition!");
John McCallace48cd2010-10-19 01:40:49 +000011439 assert(TemplateParameterLists.size() == 0 || TUK != TUK_Reference);
Douglas Gregorded2d7b2009-02-04 19:02:06 +000011440
Douglas Gregord6ab8742009-05-28 23:31:59 +000011441 OwnedDecl = false;
Abramo Bagnara6150c882010-05-11 21:36:43 +000011442 TagTypeKind Kind = TypeWithKeyword::getTagTypeKindForTypeSpec(TagSpec);
Richard Smith0f8ee222012-01-10 01:33:14 +000011443 bool ScopedEnum = ScopedEnumKWLoc.isValid();
Mike Stump11289f42009-09-09 15:08:12 +000011444
Douglas Gregor5c0405d2009-10-07 22:35:40 +000011445 // FIXME: Check explicit specializations more carefully.
11446 bool isExplicitSpecialization = false;
Douglas Gregor5f0e2522010-07-14 23:14:12 +000011447 bool Invalid = false;
John McCallace48cd2010-10-19 01:40:49 +000011448
11449 // We only need to do this matching if we have template parameters
11450 // or a scope specifier, which also conveniently avoids this work
11451 // for non-C++ cases.
Abramo Bagnara60804e12011-03-18 15:16:37 +000011452 if (TemplateParameterLists.size() > 0 ||
John McCallace48cd2010-10-19 01:40:49 +000011453 (SS.isNotEmpty() && TUK != TUK_Reference)) {
Robert Wilhelmf2d2e8f2013-07-21 15:20:44 +000011454 if (TemplateParameterList *TemplateParams =
11455 MatchTemplateParametersToScopeSpecifier(
Craig Topperc3ec1492014-05-26 06:22:03 +000011456 KWLoc, NameLoc, SS, nullptr, TemplateParameterLists,
Richard Smith4b55a9c2014-04-17 03:29:33 +000011457 TUK == TUK_Friend, isExplicitSpecialization, Invalid)) {
Richard Smith1d4b2e12013-04-01 21:43:41 +000011458 if (Kind == TTK_Enum) {
11459 Diag(KWLoc, diag::err_enum_template);
Craig Topperc3ec1492014-05-26 06:22:03 +000011460 return nullptr;
Richard Smith1d4b2e12013-04-01 21:43:41 +000011461 }
11462
Douglas Gregor3dad8422009-09-26 06:47:28 +000011463 if (TemplateParams->size() > 0) {
Douglas Gregore93e46c2009-07-22 23:48:44 +000011464 // This is a declaration or definition of a class template (which may
11465 // be a member of another template).
Abramo Bagnara60804e12011-03-18 15:16:37 +000011466
Douglas Gregor5f0e2522010-07-14 23:14:12 +000011467 if (Invalid)
Craig Topperc3ec1492014-05-26 06:22:03 +000011468 return nullptr;
Abramo Bagnara0adf29a2011-03-10 13:28:31 +000011469
Douglas Gregore93e46c2009-07-22 23:48:44 +000011470 OwnedDecl = false;
John McCall9bb74a52009-07-31 02:45:11 +000011471 DeclResult Result = CheckClassTemplate(S, TagSpec, TUK, KWLoc,
Douglas Gregore93e46c2009-07-22 23:48:44 +000011472 SS, Name, NameLoc, Attr,
Abramo Bagnara0adf29a2011-03-10 13:28:31 +000011473 TemplateParams, AS,
Douglas Gregor2820e692011-09-09 19:05:14 +000011474 ModulePrivateLoc,
Nikola Smiljanic4fc91532014-07-17 01:59:34 +000011475 /*FriendLoc*/SourceLocation(),
Benjamin Kramer62b95d82012-08-23 21:35:17 +000011476 TemplateParameterLists.size()-1,
Richard Smithbe3980b2015-03-27 00:41:57 +000011477 TemplateParameterLists.data(),
11478 SkipBody);
Douglas Gregore93e46c2009-07-22 23:48:44 +000011479 return Result.get();
11480 } else {
Douglas Gregorbbe8f462009-10-08 15:14:33 +000011481 // The "template<>" header is extraneous.
11482 Diag(TemplateParams->getTemplateLoc(), diag::err_template_tag_noparams)
Abramo Bagnara6150c882010-05-11 21:36:43 +000011483 << TypeWithKeyword::getTagTypeKindName(Kind) << Name;
Douglas Gregorbbe8f462009-10-08 15:14:33 +000011484 isExplicitSpecialization = true;
Douglas Gregore93e46c2009-07-22 23:48:44 +000011485 }
Mike Stump11289f42009-09-09 15:08:12 +000011486 }
11487 }
11488
Douglas Gregor0bf31402010-10-08 23:50:27 +000011489 // Figure out the underlying type if this a enum declaration. We need to do
11490 // this early, because it's needed to detect if this is an incompatible
11491 // redeclaration.
11492 llvm::PointerUnion<const Type*, TypeSourceInfo*> EnumUnderlying;
11493
11494 if (Kind == TTK_Enum) {
11495 if (UnderlyingType.isInvalid() || (!UnderlyingType.get() && ScopedEnum))
11496 // No underlying type explicitly specified, or we failed to parse the
11497 // type, default to int.
11498 EnumUnderlying = Context.IntTy.getTypePtr();
11499 else if (UnderlyingType.get()) {
11500 // C++0x 7.2p2: The type-specifier-seq of an enum-base shall name an
11501 // integral type; any cv-qualification is ignored.
Craig Topperc3ec1492014-05-26 06:22:03 +000011502 TypeSourceInfo *TI = nullptr;
Richard Smitheece8c32012-03-15 00:22:18 +000011503 GetTypeFromParser(UnderlyingType.get(), &TI);
Douglas Gregor0bf31402010-10-08 23:50:27 +000011504 EnumUnderlying = TI;
11505
Richard Smith4b38ded2012-03-14 23:13:10 +000011506 if (CheckEnumUnderlyingType(TI))
Douglas Gregor0bf31402010-10-08 23:50:27 +000011507 // Recover by falling back to int.
11508 EnumUnderlying = Context.IntTy.getTypePtr();
Douglas Gregor2b988fd2010-12-16 00:24:44 +000011509
Richard Smith4b38ded2012-03-14 23:13:10 +000011510 if (DiagnoseUnexpandedParameterPack(TI->getTypeLoc().getBeginLoc(), TI,
Douglas Gregor2b988fd2010-12-16 00:24:44 +000011511 UPPC_FixedUnderlyingType))
11512 EnumUnderlying = Context.IntTy.getTypePtr();
11513
Alp Tokerbfa39342014-01-14 12:51:41 +000011514 } else if (getLangOpts().MSVCCompat)
Francois Picheta3108062010-10-18 15:01:13 +000011515 // Microsoft enums are always of int type.
11516 EnumUnderlying = Context.IntTy.getTypePtr();
Douglas Gregor0bf31402010-10-08 23:50:27 +000011517 }
11518
Douglas Gregorc6f58fe2009-01-12 22:49:06 +000011519 DeclContext *SearchDC = CurContext;
Argyrios Kyrtzidis8ad00b22008-11-09 22:53:32 +000011520 DeclContext *DC = CurContext;
Douglas Gregor87f54062009-09-15 22:30:29 +000011521 bool isStdBadAlloc = false;
Douglas Gregordee1be82009-01-17 00:42:38 +000011522
Chandler Carrutha419dbb2010-03-01 21:17:36 +000011523 RedeclarationKind Redecl = ForRedeclaration;
11524 if (TUK == TUK_Friend || TUK == TUK_Reference)
11525 Redecl = NotForRedeclaration;
John McCall1f82f242009-11-18 22:49:29 +000011526
11527 LookupResult Previous(*this, Name, NameLoc, LookupTagName, Redecl);
Argyrios Kyrtzidise02eb2b2008-11-09 22:09:58 +000011528 if (Name && SS.isNotEmpty()) {
11529 // We have a nested-name tag ('struct foo::bar').
11530
11531 // Check for invalid 'foo::'.
Argyrios Kyrtzidis8ad00b22008-11-09 22:53:32 +000011532 if (SS.isInvalid()) {
Craig Topperc3ec1492014-05-26 06:22:03 +000011533 Name = nullptr;
Argyrios Kyrtzidise02eb2b2008-11-09 22:09:58 +000011534 goto CreateNewDecl;
11535 }
11536
John McCall7f41d982009-09-11 04:59:25 +000011537 // If this is a friend or a reference to a class in a dependent
11538 // context, don't try to make a decl for it.
11539 if (TUK == TUK_Friend || TUK == TUK_Reference) {
11540 DC = computeDeclContext(SS, false);
11541 if (!DC) {
11542 IsDependent = true;
Craig Topperc3ec1492014-05-26 06:22:03 +000011543 return nullptr;
John McCall7f41d982009-09-11 04:59:25 +000011544 }
John McCall0b66eb32010-05-01 00:40:08 +000011545 } else {
11546 DC = computeDeclContext(SS, true);
11547 if (!DC) {
11548 Diag(SS.getRange().getBegin(), diag::err_dependent_nested_name_spec)
11549 << SS.getRange();
Craig Topperc3ec1492014-05-26 06:22:03 +000011550 return nullptr;
John McCall0b66eb32010-05-01 00:40:08 +000011551 }
John McCall7f41d982009-09-11 04:59:25 +000011552 }
11553
John McCall0b66eb32010-05-01 00:40:08 +000011554 if (RequireCompleteDeclContext(SS, DC))
Craig Topperc3ec1492014-05-26 06:22:03 +000011555 return nullptr;
Douglas Gregor2ec748c2009-05-14 00:28:11 +000011556
Douglas Gregor8761da52009-02-03 00:34:39 +000011557 SearchDC = DC;
Argyrios Kyrtzidis8ad00b22008-11-09 22:53:32 +000011558 // Look-up name inside 'foo::'.
John McCall1f82f242009-11-18 22:49:29 +000011559 LookupQualifiedName(Previous, DC);
John McCall6538c932009-10-10 05:48:19 +000011560
John McCall1f82f242009-11-18 22:49:29 +000011561 if (Previous.isAmbiguous())
Craig Topperc3ec1492014-05-26 06:22:03 +000011562 return nullptr;
John McCall6538c932009-10-10 05:48:19 +000011563
John McCall1f82f242009-11-18 22:49:29 +000011564 if (Previous.empty()) {
Douglas Gregord2e6a452010-01-14 17:47:39 +000011565 // Name lookup did not find anything. However, if the
11566 // nested-name-specifier refers to the current instantiation,
11567 // and that current instantiation has any dependent base
11568 // classes, we might find something at instantiation time: treat
11569 // this as a dependent elaborated-type-specifier.
John McCallace48cd2010-10-19 01:40:49 +000011570 // But this only makes any sense for reference-like lookups.
11571 if (Previous.wasNotFoundInCurrentInstantiation() &&
11572 (TUK == TUK_Reference || TUK == TUK_Friend)) {
Douglas Gregord2e6a452010-01-14 17:47:39 +000011573 IsDependent = true;
Craig Topperc3ec1492014-05-26 06:22:03 +000011574 return nullptr;
Douglas Gregord2e6a452010-01-14 17:47:39 +000011575 }
11576
11577 // A tag 'foo::bar' must already exist.
Douglas Gregorf5af3582010-03-31 23:17:41 +000011578 Diag(NameLoc, diag::err_not_tag_in_scope)
11579 << Kind << Name << DC << SS.getRange();
Craig Topperc3ec1492014-05-26 06:22:03 +000011580 Name = nullptr;
Douglas Gregorb8006faf2009-05-27 17:30:49 +000011581 Invalid = true;
Argyrios Kyrtzidise02eb2b2008-11-09 22:09:58 +000011582 goto CreateNewDecl;
11583 }
Chris Lattnerd9773512009-01-21 02:38:50 +000011584 } else if (Name) {
Argyrios Kyrtzidise02eb2b2008-11-09 22:09:58 +000011585 // If this is a named struct, check to see if there was a previous forward
11586 // declaration or definition.
Douglas Gregor889ceb72009-02-03 19:21:40 +000011587 // FIXME: We're looking into outer scopes here, even when we
11588 // shouldn't be. Doing so can result in ambiguities that we
11589 // shouldn't be diagnosing.
John McCall1f82f242009-11-18 22:49:29 +000011590 LookupName(Previous, S);
11591
John McCall3c581bf2013-03-20 01:53:00 +000011592 // When declaring or defining a tag, ignore ambiguities introduced
11593 // by types using'ed into this scope.
Douglas Gregor5d1d9e32011-05-09 21:46:33 +000011594 if (Previous.isAmbiguous() &&
11595 (TUK == TUK_Definition || TUK == TUK_Declaration)) {
Douglas Gregored8a29b2011-05-04 00:25:33 +000011596 LookupResult::Filter F = Previous.makeFilter();
11597 while (F.hasNext()) {
11598 NamedDecl *ND = F.next();
11599 if (ND->getDeclContext()->getRedeclContext() != SearchDC)
11600 F.erase();
11601 }
11602 F.done();
Douglas Gregored8a29b2011-05-04 00:25:33 +000011603 }
John McCall3c581bf2013-03-20 01:53:00 +000011604
11605 // C++11 [namespace.memdef]p3:
11606 // If the name in a friend declaration is neither qualified nor
11607 // a template-id and the declaration is a function or an
11608 // elaborated-type-specifier, the lookup to determine whether
11609 // the entity has been previously declared shall not consider
11610 // any scopes outside the innermost enclosing namespace.
11611 //
Reid Kleckner0902a512014-07-10 23:44:52 +000011612 // MSVC doesn't implement the above rule for types, so a friend tag
11613 // declaration may be a redeclaration of a type declared in an enclosing
11614 // scope. They do implement this rule for friend functions.
11615 //
John McCall3c581bf2013-03-20 01:53:00 +000011616 // Does it matter that this should be by scope instead of by
11617 // semantic context?
11618 if (!Previous.empty() && TUK == TUK_Friend) {
11619 DeclContext *EnclosingNS = SearchDC->getEnclosingNamespaceContext();
11620 LookupResult::Filter F = Previous.makeFilter();
Reid Kleckner0902a512014-07-10 23:44:52 +000011621 bool FriendSawTagOutsideEnclosingNamespace = false;
John McCall3c581bf2013-03-20 01:53:00 +000011622 while (F.hasNext()) {
11623 NamedDecl *ND = F.next();
11624 DeclContext *DC = ND->getDeclContext()->getRedeclContext();
Douglas Gregorf83b4ea2013-06-27 20:42:30 +000011625 if (DC->isFileContext() &&
11626 !EnclosingNS->Encloses(ND->getDeclContext())) {
Reid Kleckner0902a512014-07-10 23:44:52 +000011627 if (getLangOpts().MSVCCompat)
11628 FriendSawTagOutsideEnclosingNamespace = true;
11629 else
11630 F.erase();
Douglas Gregorf83b4ea2013-06-27 20:42:30 +000011631 }
John McCall3c581bf2013-03-20 01:53:00 +000011632 }
11633 F.done();
Reid Kleckner0902a512014-07-10 23:44:52 +000011634
11635 // Diagnose this MSVC extension in the easy case where lookup would have
11636 // unambiguously found something outside the enclosing namespace.
11637 if (Previous.isSingleResult() && FriendSawTagOutsideEnclosingNamespace) {
11638 NamedDecl *ND = Previous.getFoundDecl();
Reid Kleckner675d4382014-07-11 00:16:51 +000011639 Diag(NameLoc, diag::ext_friend_tag_redecl_outside_namespace)
11640 << createFriendTagNNSFixIt(*this, ND, S, NameLoc);
Reid Kleckner0902a512014-07-10 23:44:52 +000011641 }
John McCall3c581bf2013-03-20 01:53:00 +000011642 }
Reid Kleckner0902a512014-07-10 23:44:52 +000011643
John McCall1f82f242009-11-18 22:49:29 +000011644 // Note: there used to be some attempt at recovery here.
11645 if (Previous.isAmbiguous())
Craig Topperc3ec1492014-05-26 06:22:03 +000011646 return nullptr;
Douglas Gregor82ac25e2009-01-08 20:45:30 +000011647
David Blaikiebbafb8a2012-03-11 07:00:24 +000011648 if (!getLangOpts().CPlusPlus && TUK != TUK_Reference) {
Douglas Gregor82ac25e2009-01-08 20:45:30 +000011649 // FIXME: This makes sure that we ignore the contexts associated
11650 // with C structs, unions, and enums when looking for a matching
11651 // tag declaration or definition. See the similar lookup tweak
Douglas Gregored8f2882009-01-30 01:04:22 +000011652 // in Sema::LookupName; is there a better way to deal with this?
Douglas Gregorc6f58fe2009-01-12 22:49:06 +000011653 while (isa<RecordDecl>(SearchDC) || isa<EnumDecl>(SearchDC))
11654 SearchDC = SearchDC->getParent();
Douglas Gregor82ac25e2009-01-08 20:45:30 +000011655 }
Argyrios Kyrtzidise02eb2b2008-11-09 22:09:58 +000011656 }
11657
John McCall1f82f242009-11-18 22:49:29 +000011658 if (Previous.isSingleResult() &&
11659 Previous.getFoundDecl()->isTemplateParameter()) {
Douglas Gregor5101c242008-12-05 18:15:24 +000011660 // Maybe we will complain about the shadowed template parameter.
John McCall1f82f242009-11-18 22:49:29 +000011661 DiagnoseTemplateParameterShadow(NameLoc, Previous.getFoundDecl());
Douglas Gregor5101c242008-12-05 18:15:24 +000011662 // Just pretend that we didn't see the previous declaration.
John McCall1f82f242009-11-18 22:49:29 +000011663 Previous.clear();
Douglas Gregor5101c242008-12-05 18:15:24 +000011664 }
11665
David Blaikiebbafb8a2012-03-11 07:00:24 +000011666 if (getLangOpts().CPlusPlus && Name && DC && StdNamespace &&
Argyrios Kyrtzidis2d688102010-08-02 07:14:54 +000011667 DC->Equals(getStdNamespace()) && Name->isStr("bad_alloc")) {
Douglas Gregor87f54062009-09-15 22:30:29 +000011668 // This is a declaration of or a reference to "std::bad_alloc".
11669 isStdBadAlloc = true;
11670
John McCall1f82f242009-11-18 22:49:29 +000011671 if (Previous.empty() && StdBadAlloc) {
Douglas Gregor87f54062009-09-15 22:30:29 +000011672 // std::bad_alloc has been implicitly declared (but made invisible to
11673 // name lookup). Fill in this implicit declaration as the previous
11674 // declaration, so that the declarations get chained appropriately.
Argyrios Kyrtzidis2d688102010-08-02 07:14:54 +000011675 Previous.addDecl(getStdBadAlloc());
Douglas Gregor87f54062009-09-15 22:30:29 +000011676 }
11677 }
John McCall1f82f242009-11-18 22:49:29 +000011678
John McCalle9eaf8e2010-03-25 21:28:06 +000011679 // If we didn't find a previous declaration, and this is a reference
11680 // (or friend reference), move to the correct scope. In C++, we
11681 // also need to do a redeclaration lookup there, just in case
11682 // there's a shadow friend decl.
11683 if (Name && Previous.empty() &&
11684 (TUK == TUK_Reference || TUK == TUK_Friend)) {
11685 if (Invalid) goto CreateNewDecl;
11686 assert(SS.isEmpty());
11687
11688 if (TUK == TUK_Reference) {
11689 // C++ [basic.scope.pdecl]p5:
11690 // -- for an elaborated-type-specifier of the form
11691 //
11692 // class-key identifier
11693 //
11694 // if the elaborated-type-specifier is used in the
11695 // decl-specifier-seq or parameter-declaration-clause of a
11696 // function defined in namespace scope, the identifier is
11697 // declared as a class-name in the namespace that contains
11698 // the declaration; otherwise, except as a friend
11699 // declaration, the identifier is declared in the smallest
11700 // non-class, non-function-prototype scope that contains the
11701 // declaration.
11702 //
11703 // C99 6.7.2.3p8 has a similar (but not identical!) provision for
11704 // C structs and unions.
11705 //
11706 // It is an error in C++ to declare (rather than define) an enum
11707 // type, including via an elaborated type specifier. We'll
11708 // diagnose that later; for now, declare the enum in the same
11709 // scope as we would have picked for any other tag type.
11710 //
11711 // GNU C also supports this behavior as part of its incomplete
11712 // enum types extension, while GNU C++ does not.
11713 //
11714 // Find the context where we'll be declaring the tag.
11715 // FIXME: We would like to maintain the current DeclContext as the
11716 // lexical context,
Nick Lewyckyf6042122012-03-10 07:47:07 +000011717 while (!SearchDC->isFileContext() && !SearchDC->isFunctionOrMethod())
John McCalle9eaf8e2010-03-25 21:28:06 +000011718 SearchDC = SearchDC->getParent();
11719
11720 // Find the scope where we'll be declaring the tag.
11721 while (S->isClassScope() ||
David Blaikiebbafb8a2012-03-11 07:00:24 +000011722 (getLangOpts().CPlusPlus &&
John McCalle9eaf8e2010-03-25 21:28:06 +000011723 S->isFunctionPrototypeScope()) ||
11724 ((S->getFlags() & Scope::DeclScope) == 0) ||
Ted Kremenekc37877d2013-10-08 17:08:03 +000011725 (S->getEntity() && S->getEntity()->isTransparentContext()))
John McCalle9eaf8e2010-03-25 21:28:06 +000011726 S = S->getParent();
11727 } else {
11728 assert(TUK == TUK_Friend);
11729 // C++ [namespace.memdef]p3:
11730 // If a friend declaration in a non-local class first declares a
11731 // class or function, the friend class or function is a member of
11732 // the innermost enclosing namespace.
11733 SearchDC = SearchDC->getEnclosingNamespaceContext();
John McCalle9eaf8e2010-03-25 21:28:06 +000011734 }
11735
John McCalle87beb22010-04-23 18:46:30 +000011736 // In C++, we need to do a redeclaration lookup to properly
11737 // diagnose some problems.
David Blaikiebbafb8a2012-03-11 07:00:24 +000011738 if (getLangOpts().CPlusPlus) {
John McCalle9eaf8e2010-03-25 21:28:06 +000011739 Previous.setRedeclarationKind(ForRedeclaration);
11740 LookupQualifiedName(Previous, SearchDC);
11741 }
11742 }
11743
Richard Smithd9ba2242015-05-07 03:54:19 +000011744 // If we have a known previous declaration to use, then use it.
11745 if (Previous.empty() && SkipBody && SkipBody->Previous)
11746 Previous.addDecl(SkipBody->Previous);
11747
John McCall1f82f242009-11-18 22:49:29 +000011748 if (!Previous.empty()) {
Alp Toker0abb0572014-01-18 00:59:32 +000011749 NamedDecl *PrevDecl = Previous.getFoundDecl();
11750 NamedDecl *DirectPrevDecl =
11751 getLangOpts().MSVCCompat ? *Previous.begin() : PrevDecl;
John McCalle87beb22010-04-23 18:46:30 +000011752
11753 // It's okay to have a tag decl in the same scope as a typedef
11754 // which hides a tag decl in the same scope. Finding this
11755 // insanity with a redeclaration lookup can only actually happen
11756 // in C++.
11757 //
11758 // This is also okay for elaborated-type-specifiers, which is
11759 // technically forbidden by the current standard but which is
11760 // okay according to the likely resolution of an open issue;
11761 // see http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#407
David Blaikiebbafb8a2012-03-11 07:00:24 +000011762 if (getLangOpts().CPlusPlus) {
Richard Smithdda56e42011-04-15 14:24:37 +000011763 if (TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(PrevDecl)) {
John McCalle87beb22010-04-23 18:46:30 +000011764 if (const TagType *TT = TD->getUnderlyingType()->getAs<TagType>()) {
11765 TagDecl *Tag = TT->getDecl();
11766 if (Tag->getDeclName() == Name &&
Sebastian Redl50c68252010-08-31 00:36:30 +000011767 Tag->getDeclContext()->getRedeclContext()
11768 ->Equals(TD->getDeclContext()->getRedeclContext())) {
John McCalle87beb22010-04-23 18:46:30 +000011769 PrevDecl = Tag;
11770 Previous.clear();
11771 Previous.addDecl(Tag);
Douglas Gregorfcee9462010-08-27 22:55:10 +000011772 Previous.resolveKind();
John McCalle87beb22010-04-23 18:46:30 +000011773 }
11774 }
11775 }
11776 }
11777
Argyrios Kyrtzidis08114892008-04-27 13:50:30 +000011778 if (TagDecl *PrevTagDecl = dyn_cast<TagDecl>(PrevDecl)) {
Chris Lattner9ff58d72008-07-03 03:30:58 +000011779 // If this is a use of a previous tag, or if the tag is already declared
11780 // in the same scope (so that the definition/declaration completes or
Argyrios Kyrtzidis08114892008-04-27 13:50:30 +000011781 // rementions the tag), reuse the decl.
John McCall07e91c02009-08-06 02:15:43 +000011782 if (TUK == TUK_Reference || TUK == TUK_Friend ||
Alp Toker320374c2014-01-17 12:57:21 +000011783 isDeclInScope(DirectPrevDecl, SearchDC, S,
Richard Smith72bcaec2013-12-05 04:30:04 +000011784 SS.isNotEmpty() || isExplicitSpecialization)) {
Chris Lattner9ff58d72008-07-03 03:30:58 +000011785 // Make sure that this wasn't declared as an enum and now used as a
11786 // struct or something similar.
Richard Trieucaa33d32011-06-10 03:11:26 +000011787 if (!isAcceptableTagRedeclaration(PrevTagDecl, Kind,
11788 TUK == TUK_Definition, KWLoc,
11789 *Name)) {
Mike Stump11289f42009-09-09 15:08:12 +000011790 bool SafeToContinue
Abramo Bagnara6150c882010-05-11 21:36:43 +000011791 = (PrevTagDecl->getTagKind() != TTK_Enum &&
11792 Kind != TTK_Enum);
Douglas Gregor170512f2009-04-01 23:51:29 +000011793 if (SafeToContinue)
Mike Stump11289f42009-09-09 15:08:12 +000011794 Diag(KWLoc, diag::err_use_with_wrong_tag)
Douglas Gregor170512f2009-04-01 23:51:29 +000011795 << Name
Douglas Gregora771f462010-03-31 17:46:05 +000011796 << FixItHint::CreateReplacement(SourceRange(KWLoc),
11797 PrevTagDecl->getKindName());
Douglas Gregor170512f2009-04-01 23:51:29 +000011798 else
11799 Diag(KWLoc, diag::err_use_with_wrong_tag) << Name;
John McCall1f82f242009-11-18 22:49:29 +000011800 Diag(PrevTagDecl->getLocation(), diag::note_previous_use);
Douglas Gregor170512f2009-04-01 23:51:29 +000011801
Mike Stump11289f42009-09-09 15:08:12 +000011802 if (SafeToContinue)
Douglas Gregor170512f2009-04-01 23:51:29 +000011803 Kind = PrevTagDecl->getTagKind();
11804 else {
11805 // Recover by making this an anonymous redefinition.
Craig Topperc3ec1492014-05-26 06:22:03 +000011806 Name = nullptr;
John McCall1f82f242009-11-18 22:49:29 +000011807 Previous.clear();
Douglas Gregor170512f2009-04-01 23:51:29 +000011808 Invalid = true;
11809 }
11810 }
11811
Douglas Gregor0bf31402010-10-08 23:50:27 +000011812 if (Kind == TTK_Enum && PrevTagDecl->getTagKind() == TTK_Enum) {
11813 const EnumDecl *PrevEnum = cast<EnumDecl>(PrevTagDecl);
11814
Richard Smith0f8ee222012-01-10 01:33:14 +000011815 // If this is an elaborated-type-specifier for a scoped enumeration,
11816 // the 'class' keyword is not necessary and not permitted.
11817 if (TUK == TUK_Reference || TUK == TUK_Friend) {
11818 if (ScopedEnum)
11819 Diag(ScopedEnumKWLoc, diag::err_enum_class_reference)
11820 << PrevEnum->isScoped()
11821 << FixItHint::CreateRemoval(ScopedEnumKWLoc);
11822 return PrevTagDecl;
11823 }
11824
Richard Smith4b38ded2012-03-14 23:13:10 +000011825 QualType EnumUnderlyingTy;
11826 if (TypeSourceInfo *TI = EnumUnderlying.dyn_cast<TypeSourceInfo*>())
Richard Smith8bcc0862014-01-08 01:16:19 +000011827 EnumUnderlyingTy = TI->getType().getUnqualifiedType();
Richard Smith4b38ded2012-03-14 23:13:10 +000011828 else if (const Type *T = EnumUnderlying.dyn_cast<const Type*>())
11829 EnumUnderlyingTy = QualType(T, 0);
11830
Douglas Gregor0bf31402010-10-08 23:50:27 +000011831 // All conflicts with previous declarations are recovered by
Richard Smithb66d7772012-03-23 23:09:08 +000011832 // returning the previous declaration, unless this is a definition,
11833 // in which case we want the caller to bail out.
Richard Smith4b38ded2012-03-14 23:13:10 +000011834 if (CheckEnumRedeclaration(NameLoc.isValid() ? NameLoc : KWLoc,
11835 ScopedEnum, EnumUnderlyingTy, PrevEnum))
Craig Topperc3ec1492014-05-26 06:22:03 +000011836 return TUK == TUK_Declaration ? PrevTagDecl : nullptr;
Douglas Gregor0bf31402010-10-08 23:50:27 +000011837 }
11838
David Majnemer55890bf2013-06-11 03:51:23 +000011839 // C++11 [class.mem]p1:
David Majnemerbfce6642013-06-11 06:19:45 +000011840 // A member shall not be declared twice in the member-specification,
David Majnemer55890bf2013-06-11 03:51:23 +000011841 // except that a nested class or member class template can be declared
11842 // and then later defined.
11843 if (TUK == TUK_Declaration && PrevDecl->isCXXClassMember() &&
11844 S->isDeclScope(PrevDecl)) {
11845 Diag(NameLoc, diag::ext_member_redeclared);
11846 Diag(PrevTagDecl->getLocation(), diag::note_previous_declaration);
11847 }
11848
Douglas Gregor170512f2009-04-01 23:51:29 +000011849 if (!Invalid) {
John McCall2976f8b2014-05-14 07:54:17 +000011850 // If this is a use, just return the declaration we found, unless
11851 // we have attributes.
Chris Lattner9ff58d72008-07-03 03:30:58 +000011852
Douglas Gregorc811d8f2008-12-15 16:32:14 +000011853 // FIXME: In the future, return a variant or some other clue
11854 // for the consumer of this Decl to know it doesn't own it.
11855 // For our current ASTs this shouldn't be a problem, but will
11856 // need to be changed with DeclGroups.
John McCall2976f8b2014-05-14 07:54:17 +000011857 if (!Attr &&
11858 ((TUK == TUK_Reference &&
11859 (!PrevTagDecl->getFriendObjectKind() || getLangOpts().MicrosoftExt))
11860 || TUK == TUK_Friend))
John McCall48871652010-08-21 09:40:31 +000011861 return PrevTagDecl;
Douglas Gregorded2d7b2009-02-04 19:02:06 +000011862
Douglas Gregorc811d8f2008-12-15 16:32:14 +000011863 // Diagnose attempts to redefine a tag.
John McCall9bb74a52009-07-31 02:45:11 +000011864 if (TUK == TUK_Definition) {
Richard Smith65ebb4a2015-03-26 04:09:53 +000011865 if (NamedDecl *Def = PrevTagDecl->getDefinition()) {
Douglas Gregor06db9f52009-10-12 20:18:28 +000011866 // If we're defining a specialization and the previous definition
11867 // is from an implicit instantiation, don't emit an error
11868 // here; we'll catch this in the general case below.
Richard Smith7d137e32012-03-23 03:33:32 +000011869 bool IsExplicitSpecializationAfterInstantiation = false;
11870 if (isExplicitSpecialization) {
11871 if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(Def))
11872 IsExplicitSpecializationAfterInstantiation =
11873 RD->getTemplateSpecializationKind() !=
11874 TSK_ExplicitSpecialization;
11875 else if (EnumDecl *ED = dyn_cast<EnumDecl>(Def))
11876 IsExplicitSpecializationAfterInstantiation =
11877 ED->getTemplateSpecializationKind() !=
11878 TSK_ExplicitSpecialization;
11879 }
11880
Richard Smithbe3980b2015-03-27 00:41:57 +000011881 NamedDecl *Hidden = nullptr;
Richard Smith65ebb4a2015-03-26 04:09:53 +000011882 if (SkipBody && getLangOpts().CPlusPlus &&
Richard Smithbe3980b2015-03-27 00:41:57 +000011883 !hasVisibleDefinition(Def, &Hidden)) {
Richard Smith65ebb4a2015-03-26 04:09:53 +000011884 // There is a definition of this tag, but it is not visible. We
11885 // explicitly make use of C++'s one definition rule here, and
11886 // assume that this definition is identical to the hidden one
11887 // we already have. Make the existing definition visible and
11888 // use it in place of this one.
Richard Smithd9ba2242015-05-07 03:54:19 +000011889 SkipBody->ShouldSkip = true;
11890 makeMergedDefinitionVisible(Hidden, KWLoc);
Richard Smith65ebb4a2015-03-26 04:09:53 +000011891 return Def;
11892 } else if (!IsExplicitSpecializationAfterInstantiation) {
James Molloy6f8780b2012-02-29 10:24:19 +000011893 // A redeclaration in function prototype scope in C isn't
11894 // visible elsewhere, so merely issue a warning.
David Blaikiebbafb8a2012-03-11 07:00:24 +000011895 if (!getLangOpts().CPlusPlus && S->containedInPrototypeScope())
James Molloy6f8780b2012-02-29 10:24:19 +000011896 Diag(NameLoc, diag::warn_redefinition_in_param_list) << Name;
11897 else
11898 Diag(NameLoc, diag::err_redefinition) << Name;
Douglas Gregor06db9f52009-10-12 20:18:28 +000011899 Diag(Def->getLocation(), diag::note_previous_definition);
11900 // If this is a redefinition, recover by making this
11901 // struct be anonymous, which will make any later
11902 // references get the previous definition.
Craig Topperc3ec1492014-05-26 06:22:03 +000011903 Name = nullptr;
John McCall1f82f242009-11-18 22:49:29 +000011904 Previous.clear();
Douglas Gregor06db9f52009-10-12 20:18:28 +000011905 Invalid = true;
11906 }
Douglas Gregordee1be82009-01-17 00:42:38 +000011907 } else {
11908 // If the type is currently being defined, complain
11909 // about a nested redefinition.
David Majnemer738e5872014-12-28 09:18:54 +000011910 auto *TD = Context.getTagDeclType(PrevTagDecl)->getAsTagDecl();
11911 if (TD->isBeingDefined()) {
Douglas Gregordee1be82009-01-17 00:42:38 +000011912 Diag(NameLoc, diag::err_nested_redefinition) << Name;
Mike Stump11289f42009-09-09 15:08:12 +000011913 Diag(PrevTagDecl->getLocation(),
Douglas Gregordee1be82009-01-17 00:42:38 +000011914 diag::note_previous_definition);
Craig Topperc3ec1492014-05-26 06:22:03 +000011915 Name = nullptr;
John McCall1f82f242009-11-18 22:49:29 +000011916 Previous.clear();
Douglas Gregordee1be82009-01-17 00:42:38 +000011917 Invalid = true;
11918 }
Douglas Gregorc811d8f2008-12-15 16:32:14 +000011919 }
Douglas Gregordee1be82009-01-17 00:42:38 +000011920
Douglas Gregorc811d8f2008-12-15 16:32:14 +000011921 // Okay, this is definition of a previously declared or referenced
John McCalla16fc892014-05-14 18:31:48 +000011922 // tag. We're going to create a new Decl for it.
11923 }
11924
11925 // Okay, we're going to make a redeclaration. If this is some kind
11926 // of reference, make sure we build the redeclaration in the same DC
11927 // as the original, and ignore the current access specifier.
11928 if (TUK == TUK_Friend || TUK == TUK_Reference) {
11929 SearchDC = PrevTagDecl->getDeclContext();
11930 AS = AS_none;
Douglas Gregordee1be82009-01-17 00:42:38 +000011931 }
Argyrios Kyrtzidis08114892008-04-27 13:50:30 +000011932 }
Douglas Gregorc811d8f2008-12-15 16:32:14 +000011933 // If we get here we have (another) forward declaration or we
John McCall07e91c02009-08-06 02:15:43 +000011934 // have a definition. Just create a new decl.
11935
Douglas Gregorc811d8f2008-12-15 16:32:14 +000011936 } else {
11937 // If we get here, this is a definition of a new tag type in a nested
Mike Stump11289f42009-09-09 15:08:12 +000011938 // scope, e.g. "struct foo; void bar() { struct foo; }", just create a
Douglas Gregorc811d8f2008-12-15 16:32:14 +000011939 // new decl/type. We set PrevDecl to NULL so that the entities
11940 // have distinct types.
John McCall1f82f242009-11-18 22:49:29 +000011941 Previous.clear();
Chris Lattner7b9ace62007-01-23 20:11:08 +000011942 }
Douglas Gregorc811d8f2008-12-15 16:32:14 +000011943 // If we get here, we're going to create a new Decl. If PrevDecl
11944 // is non-NULL, it's a definition of the tag declared by
11945 // PrevDecl. If it's NULL, we have a new definition.
John McCalle87beb22010-04-23 18:46:30 +000011946
11947
11948 // Otherwise, PrevDecl is not a tag, but was found with tag
11949 // lookup. This is only actually possible in C++, where a few
11950 // things like templates still live in the tag namespace.
Argyrios Kyrtzidis08114892008-04-27 13:50:30 +000011951 } else {
John McCalle87beb22010-04-23 18:46:30 +000011952 // Use a better diagnostic if an elaborated-type-specifier
11953 // found the wrong kind of type on the first
11954 // (non-redeclaration) lookup.
11955 if ((TUK == TUK_Reference || TUK == TUK_Friend) &&
11956 !Previous.isForRedeclaration()) {
11957 unsigned Kind = 0;
11958 if (isa<TypedefDecl>(PrevDecl)) Kind = 1;
Richard Smithdda56e42011-04-15 14:24:37 +000011959 else if (isa<TypeAliasDecl>(PrevDecl)) Kind = 2;
11960 else if (isa<ClassTemplateDecl>(PrevDecl)) Kind = 3;
John McCalle87beb22010-04-23 18:46:30 +000011961 Diag(NameLoc, diag::err_tag_reference_non_tag) << Kind;
11962 Diag(PrevDecl->getLocation(), diag::note_declared_at);
11963 Invalid = true;
11964
11965 // Otherwise, only diagnose if the declaration is in scope.
Richard Smith72bcaec2013-12-05 04:30:04 +000011966 } else if (!isDeclInScope(PrevDecl, SearchDC, S,
11967 SS.isNotEmpty() || isExplicitSpecialization)) {
John McCalle87beb22010-04-23 18:46:30 +000011968 // do nothing
11969
11970 // Diagnose implicit declarations introduced by elaborated types.
11971 } else if (TUK == TUK_Reference || TUK == TUK_Friend) {
11972 unsigned Kind = 0;
11973 if (isa<TypedefDecl>(PrevDecl)) Kind = 1;
Richard Smithdda56e42011-04-15 14:24:37 +000011974 else if (isa<TypeAliasDecl>(PrevDecl)) Kind = 2;
11975 else if (isa<ClassTemplateDecl>(PrevDecl)) Kind = 3;
John McCalle87beb22010-04-23 18:46:30 +000011976 Diag(NameLoc, diag::err_tag_reference_conflict) << Kind;
11977 Diag(PrevDecl->getLocation(), diag::note_previous_decl) << PrevDecl;
11978 Invalid = true;
11979
11980 // Otherwise it's a declaration. Call out a particularly common
11981 // case here.
Richard Smithdda56e42011-04-15 14:24:37 +000011982 } else if (TypedefNameDecl *TND = dyn_cast<TypedefNameDecl>(PrevDecl)) {
11983 unsigned Kind = 0;
11984 if (isa<TypeAliasDecl>(PrevDecl)) Kind = 1;
John McCalle87beb22010-04-23 18:46:30 +000011985 Diag(NameLoc, diag::err_tag_definition_of_typedef)
Richard Smithdda56e42011-04-15 14:24:37 +000011986 << Name << Kind << TND->getUnderlyingType();
John McCalle87beb22010-04-23 18:46:30 +000011987 Diag(PrevDecl->getLocation(), diag::note_previous_decl) << PrevDecl;
11988 Invalid = true;
11989
11990 // Otherwise, diagnose.
11991 } else {
11992 // The tag name clashes with something else in the target scope,
11993 // issue an error and recover by making this tag be anonymous.
Chris Lattner4bd8dd82008-11-19 08:23:25 +000011994 Diag(NameLoc, diag::err_redefinition_different_kind) << Name;
Chris Lattner0369c572008-11-23 23:12:31 +000011995 Diag(PrevDecl->getLocation(), diag::note_previous_definition);
Craig Topperc3ec1492014-05-26 06:22:03 +000011996 Name = nullptr;
Douglas Gregordee1be82009-01-17 00:42:38 +000011997 Invalid = true;
Argyrios Kyrtzidis7da34d02008-07-16 07:45:46 +000011998 }
John McCalle87beb22010-04-23 18:46:30 +000011999
12000 // The existing declaration isn't relevant to us; we're in a
12001 // new scope, so clear out the previous declaration.
12002 Previous.clear();
Chris Lattner8799cf22007-01-23 01:57:16 +000012003 }
Chris Lattner18b19622007-01-22 07:39:13 +000012004 }
Argyrios Kyrtzidis16ac9be2008-11-08 17:17:31 +000012005
Chris Lattner438e5012008-12-17 07:13:27 +000012006CreateNewDecl:
Mike Stump11289f42009-09-09 15:08:12 +000012007
Craig Topperc3ec1492014-05-26 06:22:03 +000012008 TagDecl *PrevDecl = nullptr;
John McCall1f82f242009-11-18 22:49:29 +000012009 if (Previous.isSingleResult())
12010 PrevDecl = cast<TagDecl>(Previous.getFoundDecl());
12011
Chris Lattnerbf0b7982007-01-23 04:27:41 +000012012 // If there is an identifier, use the location of the identifier as the
12013 // location of the decl, otherwise use the location of the struct/union
12014 // keyword.
12015 SourceLocation Loc = NameLoc.isValid() ? NameLoc : KWLoc;
Mike Stump11289f42009-09-09 15:08:12 +000012016
Douglas Gregorc811d8f2008-12-15 16:32:14 +000012017 // Otherwise, create a new declaration. If there is a previous
12018 // declaration of the same entity, the two will be linked via
12019 // PrevDecl.
Chris Lattner7b9ace62007-01-23 20:11:08 +000012020 TagDecl *New;
Douglas Gregor9ac7a072009-01-07 00:43:41 +000012021
Douglas Gregor0bf31402010-10-08 23:50:27 +000012022 bool IsForwardReference = false;
Abramo Bagnara6150c882010-05-11 21:36:43 +000012023 if (Kind == TTK_Enum) {
Chris Lattner776fac82007-06-09 00:53:06 +000012024 // FIXME: Tag decls should be chained to any simultaneous vardecls, e.g.:
12025 // enum X { A, B, C } D; D should chain to X.
Abramo Bagnara29c2d462011-03-09 14:09:51 +000012026 New = EnumDecl::Create(Context, SearchDC, KWLoc, Loc, Name,
Douglas Gregor0bf31402010-10-08 23:50:27 +000012027 cast_or_null<EnumDecl>(PrevDecl), ScopedEnum,
Abramo Bagnara0e05e242010-12-03 18:54:17 +000012028 ScopedEnumUsesClassTag, !EnumUnderlying.isNull());
Chris Lattner5f521502007-01-25 06:27:24 +000012029 // If this is an undefined enum, warn.
Douglas Gregorc9ea2d52010-06-22 14:26:35 +000012030 if (TUK != TUK_Definition && !Invalid) {
12031 TagDecl *Def;
Douglas Gregor780420e2013-03-25 22:22:35 +000012032 if ((getLangOpts().CPlusPlus11 || getLangOpts().ObjC2) &&
12033 cast<EnumDecl>(New)->isFixed()) {
Douglas Gregor0bf31402010-10-08 23:50:27 +000012034 // C++0x: 7.2p2: opaque-enum-declaration.
12035 // Conflicts are diagnosed above. Do nothing.
12036 }
12037 else if (PrevDecl && (Def = cast<EnumDecl>(PrevDecl)->getDefinition())) {
Douglas Gregorc9ea2d52010-06-22 14:26:35 +000012038 Diag(Loc, diag::ext_forward_ref_enum_def)
12039 << New;
12040 Diag(Def->getLocation(), diag::note_previous_definition);
12041 } else {
Francois Pichet488b4a72010-09-12 05:06:55 +000012042 unsigned DiagID = diag::ext_forward_ref_enum;
Alp Tokerbfa39342014-01-14 12:51:41 +000012043 if (getLangOpts().MSVCCompat)
Francois Pichet488b4a72010-09-12 05:06:55 +000012044 DiagID = diag::ext_ms_forward_ref_enum;
David Blaikiebbafb8a2012-03-11 07:00:24 +000012045 else if (getLangOpts().CPlusPlus)
Francois Pichet488b4a72010-09-12 05:06:55 +000012046 DiagID = diag::err_forward_ref_enum;
12047 Diag(Loc, DiagID);
Douglas Gregor0bf31402010-10-08 23:50:27 +000012048
12049 // If this is a forward-declared reference to an enumeration, make a
12050 // note of it; we won't actually be introducing the declaration into
12051 // the declaration context.
12052 if (TUK == TUK_Reference)
12053 IsForwardReference = true;
Douglas Gregorc9ea2d52010-06-22 14:26:35 +000012054 }
Douglas Gregord45b93b2009-03-06 18:34:03 +000012055 }
Douglas Gregor0bf31402010-10-08 23:50:27 +000012056
12057 if (EnumUnderlying) {
12058 EnumDecl *ED = cast<EnumDecl>(New);
12059 if (TypeSourceInfo *TI = EnumUnderlying.dyn_cast<TypeSourceInfo*>())
12060 ED->setIntegerTypeSourceInfo(TI);
12061 else
12062 ED->setIntegerType(QualType(EnumUnderlying.get<const Type*>(), 0));
12063 ED->setPromotionType(ED->getIntegerType());
12064 }
12065
Argyrios Kyrtzidis554a07b2008-06-09 23:19:58 +000012066 } else {
12067 // struct/union/class
12068
Chris Lattner776fac82007-06-09 00:53:06 +000012069 // FIXME: Tag decls should be chained to any simultaneous vardecls, e.g.:
12070 // struct X { int A; } D; D should chain to X.
David Blaikiebbafb8a2012-03-11 07:00:24 +000012071 if (getLangOpts().CPlusPlus) {
Ted Kremenek6ddf53e2008-09-05 17:39:33 +000012072 // FIXME: Look for a way to use RecordDecl for simple structs.
Abramo Bagnara29c2d462011-03-09 14:09:51 +000012073 New = CXXRecordDecl::Create(Context, Kind, SearchDC, KWLoc, Loc, Name,
Douglas Gregorc811d8f2008-12-15 16:32:14 +000012074 cast_or_null<CXXRecordDecl>(PrevDecl));
Abramo Bagnara29c2d462011-03-09 14:09:51 +000012075
Argyrios Kyrtzidis2d688102010-08-02 07:14:54 +000012076 if (isStdBadAlloc && (!StdBadAlloc || getStdBadAlloc()->isImplicit()))
Douglas Gregor87f54062009-09-15 22:30:29 +000012077 StdBadAlloc = cast<CXXRecordDecl>(New);
12078 } else
Abramo Bagnara29c2d462011-03-09 14:09:51 +000012079 New = RecordDecl::Create(Context, Kind, SearchDC, KWLoc, Loc, Name,
Douglas Gregorc811d8f2008-12-15 16:32:14 +000012080 cast_or_null<RecordDecl>(PrevDecl));
Argyrios Kyrtzidised983422008-07-01 10:37:29 +000012081 }
Douglas Gregorc811d8f2008-12-15 16:32:14 +000012082
Richard Smith649c7b062014-01-08 00:56:48 +000012083 // C++11 [dcl.type]p3:
12084 // A type-specifier-seq shall not define a class or enumeration [...].
12085 if (getLangOpts().CPlusPlus && IsTypeSpecifier && TUK == TUK_Definition) {
12086 Diag(New->getLocation(), diag::err_type_defined_in_type_specifier)
12087 << Context.getTagDeclType(New);
12088 Invalid = true;
12089 }
12090
John McCall3e11ebe2010-03-15 10:12:16 +000012091 // Maybe add qualifier info.
12092 if (SS.isNotEmpty()) {
Fariborz Jahanian862fac92010-05-14 21:35:02 +000012093 if (SS.isSet()) {
Douglas Gregorb7d17dd2012-03-28 16:01:27 +000012094 // If this is either a declaration or a definition, check the
12095 // nested-name-specifier against the current context. We don't do this
12096 // for explicit specializations, because they have similar checking
12097 // (with more specific diagnostics) in the call to
12098 // CheckMemberSpecialization, below.
12099 if (!isExplicitSpecialization &&
12100 (TUK == TUK_Definition || TUK == TUK_Declaration) &&
David Majnemerbe4c4372014-12-29 05:17:46 +000012101 diagnoseQualifiedDeclaration(SS, DC, OrigName, Loc))
Douglas Gregorb7d17dd2012-03-28 16:01:27 +000012102 Invalid = true;
12103
Douglas Gregor14454802011-02-25 02:25:35 +000012104 New->setQualifierInfo(SS.getWithLocInContext(Context));
Abramo Bagnara60804e12011-03-18 15:16:37 +000012105 if (TemplateParameterLists.size() > 0) {
Douglas Gregor20527e22010-06-15 17:44:38 +000012106 New->setTemplateParameterListsInfo(Context,
Abramo Bagnara60804e12011-03-18 15:16:37 +000012107 TemplateParameterLists.size(),
Benjamin Kramercc4c49d2012-08-23 23:38:35 +000012108 TemplateParameterLists.data());
Abramo Bagnarada41d0c2010-06-12 08:15:14 +000012109 }
Fariborz Jahanian862fac92010-05-14 21:35:02 +000012110 }
12111 else
12112 Invalid = true;
John McCall3e11ebe2010-03-15 10:12:16 +000012113 }
12114
Daniel Dunbar8804f2e2010-05-27 01:53:40 +000012115 if (RecordDecl *RD = dyn_cast<RecordDecl>(New)) {
12116 // Add alignment attributes if necessary; these attributes are checked when
12117 // the ASTContext lays out the structure.
Douglas Gregorc811d8f2008-12-15 16:32:14 +000012118 //
12119 // It is important for implementing the correct semantics that this
12120 // happen here (in act on tag decl). The #pragma pack stack is
12121 // maintained as a result of parser callbacks which can occur at
12122 // many points during the parsing of a struct declaration (because
12123 // the #pragma tokens are effectively skipped over during the
12124 // parsing of the struct).
Eli Friedman0415f3e12012-08-08 21:08:34 +000012125 if (TUK == TUK_Definition) {
12126 AddAlignmentAttributesForRecord(RD);
12127 AddMsStructLayoutForRecord(RD);
12128 }
Douglas Gregorc811d8f2008-12-15 16:32:14 +000012129 }
12130
Douglas Gregor21823bf2011-12-20 18:11:52 +000012131 if (ModulePrivateLoc.isValid()) {
Douglas Gregor3c7cd6a2011-09-09 20:53:38 +000012132 if (isExplicitSpecialization)
12133 Diag(New->getLocation(), diag::err_module_private_specialization)
12134 << 2
12135 << FixItHint::CreateRemoval(ModulePrivateLoc);
Douglas Gregor41866812011-09-12 18:37:38 +000012136 // __module_private__ does not apply to local classes. However, we only
12137 // diagnose this as an error when the declaration specifiers are
12138 // freestanding. Here, we just ignore the __module_private__.
Douglas Gregor41866812011-09-12 18:37:38 +000012139 else if (!SearchDC->isFunctionOrMethod())
Douglas Gregor2820e692011-09-09 19:05:14 +000012140 New->setModulePrivate();
12141 }
Serge Pavlova8261472014-06-25 17:09:41 +000012142
Douglas Gregorbbe8f462009-10-08 15:14:33 +000012143 // If this is a specialization of a member class (of a class template),
12144 // check the specialization.
John McCall1f82f242009-11-18 22:49:29 +000012145 if (isExplicitSpecialization && CheckMemberSpecialization(New, Previous))
Douglas Gregorbbe8f462009-10-08 15:14:33 +000012146 Invalid = true;
Serge Pavlova8261472014-06-25 17:09:41 +000012147
12148 // If we're declaring or defining a tag in function prototype scope in C,
12149 // note that this type can only be used within the function and add it to
12150 // the list of decls to inject into the function definition scope.
12151 if ((Name || Kind == TTK_Enum) &&
12152 getNonFieldDeclScope(S)->isFunctionPrototypeScope()) {
12153 if (getLangOpts().CPlusPlus) {
12154 // C++ [dcl.fct]p6:
12155 // Types shall not be defined in return or parameter types.
12156 if (TUK == TUK_Definition && !IsTypeSpecifier) {
12157 Diag(Loc, diag::err_type_defined_in_param_type)
12158 << Name;
12159 Invalid = true;
12160 }
12161 } else {
12162 Diag(Loc, diag::warn_decl_in_param_list) << Context.getTagDeclType(New);
12163 }
12164 DeclsInPrototypeScope.push_back(New);
12165 }
12166
Douglas Gregordee1be82009-01-17 00:42:38 +000012167 if (Invalid)
12168 New->setInvalidDecl();
12169
Douglas Gregorc811d8f2008-12-15 16:32:14 +000012170 if (Attr)
Douglas Gregor758a8692009-06-17 21:51:59 +000012171 ProcessDeclAttributeList(S, New, Attr);
Douglas Gregorc811d8f2008-12-15 16:32:14 +000012172
12173 // Set the lexical context. If the tag has a C++ scope specifier, the
12174 // lexical context will be different from the semantic context.
Douglas Gregor8761da52009-02-03 00:34:39 +000012175 New->setLexicalDeclContext(CurContext);
Douglas Gregordee1be82009-01-17 00:42:38 +000012176
John McCallaa74a0c2009-08-28 07:59:38 +000012177 // Mark this as a friend decl if applicable.
Francois Pichete37eeba2011-06-01 04:14:20 +000012178 // In Microsoft mode, a friend declaration also acts as a forward
12179 // declaration so we always pass true to setObjectOfFriendDecl to make
12180 // the tag name visible.
John McCallaa74a0c2009-08-28 07:59:38 +000012181 if (TUK == TUK_Friend)
Reid Kleckner0902a512014-07-10 23:44:52 +000012182 New->setObjectOfFriendDecl(getLangOpts().MSVCCompat);
John McCallaa74a0c2009-08-28 07:59:38 +000012183
Anders Carlsson5558ca12009-03-26 01:19:02 +000012184 // Set the access specifier.
John McCalle9eaf8e2010-03-25 21:28:06 +000012185 if (!Invalid && SearchDC->isRecord())
Douglas Gregorb8006faf2009-05-27 17:30:49 +000012186 SetMemberAccessSpecifier(New, PrevDecl, AS);
Douglas Gregor6c2adff2009-03-25 22:00:53 +000012187
John McCall9bb74a52009-07-31 02:45:11 +000012188 if (TUK == TUK_Definition)
Douglas Gregordee1be82009-01-17 00:42:38 +000012189 New->startDefinition();
Mike Stump11289f42009-09-09 15:08:12 +000012190
Chris Lattner18b19622007-01-22 07:39:13 +000012191 // If this has an identifier, add it to the scope stack.
John McCall2dc078f2009-09-02 00:55:30 +000012192 if (TUK == TUK_Friend) {
John McCallf8bd8612009-09-02 19:32:14 +000012193 // We might be replacing an existing declaration in the lookup tables;
12194 // if so, borrow its access specifier.
12195 if (PrevDecl)
12196 New->setAccess(PrevDecl->getAccess());
12197
Sebastian Redl50c68252010-08-31 00:36:30 +000012198 DeclContext *DC = New->getDeclContext()->getRedeclContext();
Richard Smith05afe5e2012-03-13 03:12:56 +000012199 DC->makeDeclVisibleInContext(New);
John McCalle9eaf8e2010-03-25 21:28:06 +000012200 if (Name) // can be null along some error paths
John McCall2dc078f2009-09-02 00:55:30 +000012201 if (Scope *EnclosingScope = getScopeForDeclContext(S, DC))
12202 PushOnScopeChains(New, EnclosingScope, /* AddToContext = */ false);
John McCall2dc078f2009-09-02 00:55:30 +000012203 } else if (Name) {
Douglas Gregor45a33ec2009-01-12 18:45:55 +000012204 S = getNonFieldDeclScope(S);
Douglas Gregor0bf31402010-10-08 23:50:27 +000012205 PushOnScopeChains(New, S, !IsForwardReference);
12206 if (IsForwardReference)
Richard Smith05afe5e2012-03-13 03:12:56 +000012207 SearchDC->makeDeclVisibleInContext(New);
Douglas Gregor0bf31402010-10-08 23:50:27 +000012208
Douglas Gregorc6f58fe2009-01-12 22:49:06 +000012209 } else {
Argyrios Kyrtzidiscfbfe782009-06-30 02:36:12 +000012210 CurContext->addDecl(New);
Chris Lattner18b19622007-01-22 07:39:13 +000012211 }
Argyrios Kyrtzidis9e59b572008-11-09 23:41:00 +000012212
Douglas Gregor27821ce2009-07-07 16:35:42 +000012213 // If this is the C FILE type, notify the AST context.
12214 if (IdentifierInfo *II = New->getIdentifier())
12215 if (!New->isInvalidDecl() &&
Sebastian Redl50c68252010-08-31 00:36:30 +000012216 New->getDeclContext()->getRedeclContext()->isTranslationUnit() &&
Douglas Gregor27821ce2009-07-07 16:35:42 +000012217 II->isStr("FILE"))
12218 Context.setFILEDecl(New);
Mike Stump11289f42009-09-09 15:08:12 +000012219
Rafael Espindolac67f2232012-05-10 02:50:16 +000012220 if (PrevDecl)
12221 mergeDeclAttributes(New, PrevDecl);
12222
Rafael Espindolae3a14bb2012-07-17 15:14:47 +000012223 // If there's a #pragma GCC visibility in scope, set the visibility of this
12224 // record.
12225 AddPushedVisibilityAttribute(New);
12226
Douglas Gregord6ab8742009-05-28 23:31:59 +000012227 OwnedDecl = true;
Richard Smith3e284692012-12-05 11:34:06 +000012228 // In C++, don't return an invalid declaration. We can't recover well from
12229 // the cases where we make the type anonymous.
Craig Topperc3ec1492014-05-26 06:22:03 +000012230 return (Invalid && getLangOpts().CPlusPlus) ? nullptr : New;
Chris Lattner18b19622007-01-22 07:39:13 +000012231}
Chris Lattner1300fb92007-01-23 23:42:53 +000012232
John McCall48871652010-08-21 09:40:31 +000012233void Sema::ActOnTagStartDefinition(Scope *S, Decl *TagD) {
Douglas Gregorded2d7b2009-02-04 19:02:06 +000012234 AdjustDeclIfTemplate(TagD);
John McCall48871652010-08-21 09:40:31 +000012235 TagDecl *Tag = cast<TagDecl>(TagD);
Douglas Gregorba41d012010-04-24 16:38:41 +000012236
Douglas Gregor82ac25e2009-01-08 20:45:30 +000012237 // Enter the tag context.
12238 PushDeclContext(S, Tag);
Dmitri Gribenkof26054f2012-07-11 21:38:39 +000012239
12240 ActOnDocumentableDecl(TagD);
Rafael Espindola4dedd0c2012-07-12 04:47:34 +000012241
12242 // If there's a #pragma GCC visibility in scope, set the visibility of this
12243 // record.
12244 AddPushedVisibilityAttribute(Tag);
John McCall1c7e6ec2009-12-20 07:58:13 +000012245}
Douglas Gregor82ac25e2009-01-08 20:45:30 +000012246
Argyrios Kyrtzidis9321ad32011-10-06 23:23:20 +000012247Decl *Sema::ActOnObjCContainerStartDefinition(Decl *IDecl) {
Fariborz Jahanian8d382dc2011-08-22 15:54:49 +000012248 assert(isa<ObjCContainerDecl>(IDecl) &&
12249 "ActOnObjCContainerStartDefinition - Not ObjCContainerDecl");
12250 DeclContext *OCD = cast<DeclContext>(IDecl);
12251 assert(getContainingDC(OCD) == CurContext &&
12252 "The next DeclContext should be lexically contained in the current one.");
12253 CurContext = OCD;
Argyrios Kyrtzidis9321ad32011-10-06 23:23:20 +000012254 return IDecl;
Fariborz Jahanian8d382dc2011-08-22 15:54:49 +000012255}
12256
John McCall48871652010-08-21 09:40:31 +000012257void Sema::ActOnStartCXXMemberDeclarations(Scope *S, Decl *TagD,
Anders Carlsson30f29442011-03-25 14:31:08 +000012258 SourceLocation FinalLoc,
David Majnemera5433082013-10-18 00:33:31 +000012259 bool IsFinalSpelledSealed,
John McCall1c7e6ec2009-12-20 07:58:13 +000012260 SourceLocation LBraceLoc) {
12261 AdjustDeclIfTemplate(TagD);
John McCall48871652010-08-21 09:40:31 +000012262 CXXRecordDecl *Record = cast<CXXRecordDecl>(TagD);
Douglas Gregor82ac25e2009-01-08 20:45:30 +000012263
John McCall1c7e6ec2009-12-20 07:58:13 +000012264 FieldCollector->StartClass();
12265
12266 if (!Record->getIdentifier())
12267 return;
12268
Anders Carlsson30f29442011-03-25 14:31:08 +000012269 if (FinalLoc.isValid())
David Majnemera5433082013-10-18 00:33:31 +000012270 Record->addAttr(new (Context)
12271 FinalAttr(FinalLoc, Context, IsFinalSpelledSealed));
12272
John McCall1c7e6ec2009-12-20 07:58:13 +000012273 // C++ [class]p2:
12274 // [...] The class-name is also inserted into the scope of the
12275 // class itself; this is known as the injected-class-name. For
12276 // purposes of access checking, the injected-class-name is treated
12277 // as if it were a public member name.
12278 CXXRecordDecl *InjectedClassName
Abramo Bagnara29c2d462011-03-09 14:09:51 +000012279 = CXXRecordDecl::Create(Context, Record->getTagKind(), CurContext,
12280 Record->getLocStart(), Record->getLocation(),
John McCall1c7e6ec2009-12-20 07:58:13 +000012281 Record->getIdentifier(),
Craig Topperc3ec1492014-05-26 06:22:03 +000012282 /*PrevDecl=*/nullptr,
Argyrios Kyrtzidis470c4542010-10-14 20:14:21 +000012283 /*DelayTypeCreation=*/true);
12284 Context.getTypeDeclType(InjectedClassName, Record);
John McCall1c7e6ec2009-12-20 07:58:13 +000012285 InjectedClassName->setImplicit();
12286 InjectedClassName->setAccess(AS_public);
12287 if (ClassTemplateDecl *Template = Record->getDescribedClassTemplate())
12288 InjectedClassName->setDescribedClassTemplate(Template);
12289 PushOnScopeChains(InjectedClassName, S);
12290 assert(InjectedClassName->isInjectedClassName() &&
12291 "Broken injected-class-name");
Douglas Gregor82ac25e2009-01-08 20:45:30 +000012292}
12293
John McCall48871652010-08-21 09:40:31 +000012294void Sema::ActOnTagFinishDefinition(Scope *S, Decl *TagD,
Argyrios Kyrtzidis23e1f1d2009-07-14 03:17:52 +000012295 SourceLocation RBraceLoc) {
Douglas Gregorded2d7b2009-02-04 19:02:06 +000012296 AdjustDeclIfTemplate(TagD);
John McCall48871652010-08-21 09:40:31 +000012297 TagDecl *Tag = cast<TagDecl>(TagD);
Argyrios Kyrtzidis23e1f1d2009-07-14 03:17:52 +000012298 Tag->setRBraceLoc(RBraceLoc);
Douglas Gregor82ac25e2009-01-08 20:45:30 +000012299
Argyrios Kyrtzidis25596292012-03-09 20:10:30 +000012300 // Make sure we "complete" the definition even it is invalid.
12301 if (Tag->isBeingDefined()) {
12302 assert(Tag->isInvalidDecl() && "We should already have completed it");
12303 if (RecordDecl *RD = dyn_cast<RecordDecl>(Tag))
12304 RD->completeDefinition();
12305 }
12306
Reid Klecknerbba3cb92015-03-17 19:00:50 +000012307 if (isa<CXXRecordDecl>(Tag))
Douglas Gregor82ac25e2009-01-08 20:45:30 +000012308 FieldCollector->FinishClass();
12309
12310 // Exit this scope of this tag's definition.
12311 PopDeclContext();
Argyrios Kyrtzidisc821f732013-01-29 18:00:54 +000012312
12313 if (getCurLexicalContext()->isObjCContainer() &&
12314 Tag->getDeclContext()->isFileContext())
12315 Tag->setTopLevelDeclInObjCContainer();
12316
Douglas Gregor82ac25e2009-01-08 20:45:30 +000012317 // Notify the consumer that we've defined a tag.
Serge Pavlovfb73ec82013-07-02 17:31:56 +000012318 if (!Tag->isInvalidDecl())
12319 Consumer.HandleTagDeclDefinition(Tag);
Douglas Gregor82ac25e2009-01-08 20:45:30 +000012320}
Chris Lattner535b8302008-06-21 19:39:06 +000012321
Fariborz Jahanian4327b322011-08-29 17:33:12 +000012322void Sema::ActOnObjCContainerFinishDefinition() {
Fariborz Jahanian8d382dc2011-08-22 15:54:49 +000012323 // Exit this scope of this interface definition.
12324 PopDeclContext();
12325}
Argyrios Kyrtzidis9321ad32011-10-06 23:23:20 +000012326
Argyrios Kyrtzidisa9aabf72011-10-27 00:09:34 +000012327void Sema::ActOnObjCTemporaryExitContainerContext(DeclContext *DC) {
Argyrios Kyrtzidis67f914d2011-10-27 00:53:06 +000012328 assert(DC == CurContext && "Mismatch of container contexts");
12329 OriginalLexicalContext = DC;
Argyrios Kyrtzidis9321ad32011-10-06 23:23:20 +000012330 ActOnObjCContainerFinishDefinition();
12331}
12332
Argyrios Kyrtzidisa9aabf72011-10-27 00:09:34 +000012333void Sema::ActOnObjCReenterContainerContext(DeclContext *DC) {
12334 ActOnObjCContainerStartDefinition(cast<Decl>(DC));
Craig Topperc3ec1492014-05-26 06:22:03 +000012335 OriginalLexicalContext = nullptr;
Argyrios Kyrtzidis9321ad32011-10-06 23:23:20 +000012336}
12337
John McCall48871652010-08-21 09:40:31 +000012338void Sema::ActOnTagDefinitionError(Scope *S, Decl *TagD) {
John McCall2ff380a2010-03-17 00:38:33 +000012339 AdjustDeclIfTemplate(TagD);
John McCall48871652010-08-21 09:40:31 +000012340 TagDecl *Tag = cast<TagDecl>(TagD);
John McCall2ff380a2010-03-17 00:38:33 +000012341 Tag->setInvalidDecl();
12342
Argyrios Kyrtzidis25596292012-03-09 20:10:30 +000012343 // Make sure we "complete" the definition even it is invalid.
12344 if (Tag->isBeingDefined()) {
12345 if (RecordDecl *RD = dyn_cast<RecordDecl>(Tag))
12346 RD->completeDefinition();
12347 }
12348
John McCall71ba5f22010-03-17 19:25:57 +000012349 // We're undoing ActOnTagStartDefinition here, not
12350 // ActOnStartCXXMemberDeclarations, so we don't have to mess with
12351 // the FieldCollector.
John McCall2ff380a2010-03-17 00:38:33 +000012352
12353 PopDeclContext();
12354}
12355
Chris Lattnerf9b00eb2009-04-20 17:29:38 +000012356// Note that FieldName may be null for anonymous bitfields.
Richard Smithf4c51d92012-02-04 09:53:13 +000012357ExprResult Sema::VerifyBitField(SourceLocation FieldLoc,
12358 IdentifierInfo *FieldName,
Reid Kleckner736bc982013-07-17 20:46:03 +000012359 QualType FieldTy, bool IsMsStruct,
12360 Expr *BitWidth, bool *ZeroWidth) {
Eli Friedmanc96d4962009-08-15 21:55:26 +000012361 // Default to true; that shouldn't confuse checks for emptiness
12362 if (ZeroWidth)
12363 *ZeroWidth = true;
12364
Chris Lattner73bf7b42009-03-05 22:45:59 +000012365 // C99 6.7.2.1p4 - verify the field type.
Chris Lattnerd26760a2009-03-05 23:01:03 +000012366 // C++ 9.6p3: A bit-field shall have integral or enumeration type.
Douglas Gregorb90df602010-06-16 00:17:44 +000012367 if (!FieldTy->isDependentType() && !FieldTy->isIntegralOrEnumerationType()) {
Chris Lattner73bf7b42009-03-05 22:45:59 +000012368 // Handle incomplete types with specific error.
Douglas Gregor81457422009-03-10 21:58:27 +000012369 if (RequireCompleteType(FieldLoc, FieldTy, diag::err_field_incomplete))
Richard Smithf4c51d92012-02-04 09:53:13 +000012370 return ExprError();
Chris Lattnerf9b00eb2009-04-20 17:29:38 +000012371 if (FieldName)
12372 return Diag(FieldLoc, diag::err_not_integral_type_bitfield)
12373 << FieldName << FieldTy << BitWidth->getSourceRange();
12374 return Diag(FieldLoc, diag::err_not_integral_type_anon_bitfield)
12375 << FieldTy << BitWidth->getSourceRange();
Douglas Gregora02a72a2010-12-15 23:18:36 +000012376 } else if (DiagnoseUnexpandedParameterPack(const_cast<Expr *>(BitWidth),
12377 UPPC_BitFieldWidth))
Richard Smithf4c51d92012-02-04 09:53:13 +000012378 return ExprError();
Douglas Gregor1efa4372009-03-11 18:59:21 +000012379
12380 // If the bit-width is type- or value-dependent, don't try to check
12381 // it now.
12382 if (BitWidth->isValueDependent() || BitWidth->isTypeDependent())
Nikola Smiljanic03ff2592014-05-29 14:05:12 +000012383 return BitWidth;
Douglas Gregor1efa4372009-03-11 18:59:21 +000012384
Anders Carlsson5df391e2008-12-06 20:33:04 +000012385 llvm::APSInt Value;
Richard Smithf4c51d92012-02-04 09:53:13 +000012386 ExprResult ICE = VerifyIntegerConstantExpression(BitWidth, &Value);
12387 if (ICE.isInvalid())
12388 return ICE;
Nikola Smiljanic01a75982014-05-29 10:55:11 +000012389 BitWidth = ICE.get();
Anders Carlsson5df391e2008-12-06 20:33:04 +000012390
Eli Friedmanc96d4962009-08-15 21:55:26 +000012391 if (Value != 0 && ZeroWidth)
12392 *ZeroWidth = false;
12393
Chris Lattner81ed6802008-12-12 04:56:04 +000012394 // Zero-width bitfield is ok for anonymous field.
12395 if (Value == 0 && FieldName)
12396 return Diag(FieldLoc, diag::err_bitfield_has_zero_width) << FieldName;
Mike Stump11289f42009-09-09 15:08:12 +000012397
Chris Lattnerf9b00eb2009-04-20 17:29:38 +000012398 if (Value.isSigned() && Value.isNegative()) {
12399 if (FieldName)
Mike Stump11289f42009-09-09 15:08:12 +000012400 return Diag(FieldLoc, diag::err_bitfield_has_negative_width)
Chris Lattnerf9b00eb2009-04-20 17:29:38 +000012401 << FieldName << Value.toString(10);
12402 return Diag(FieldLoc, diag::err_anon_bitfield_has_negative_width)
12403 << Value.toString(10);
12404 }
Anders Carlsson5df391e2008-12-06 20:33:04 +000012405
Douglas Gregor1efa4372009-03-11 18:59:21 +000012406 if (!FieldTy->isDependentType()) {
12407 uint64_t TypeSize = Context.getTypeSize(FieldTy);
Chris Lattnerf9b00eb2009-04-20 17:29:38 +000012408 if (Value.getZExtValue() > TypeSize) {
Warren Hunt96afec12013-12-12 23:23:28 +000012409 if (!getLangOpts().CPlusPlus || IsMsStruct ||
12410 Context.getTargetInfo().getCXXABI().isMicrosoft()) {
Anders Carlssond5635fe2010-04-16 15:16:32 +000012411 if (FieldName)
12412 return Diag(FieldLoc, diag::err_bitfield_width_exceeds_type_size)
12413 << FieldName << (unsigned)Value.getZExtValue()
12414 << (unsigned)TypeSize;
12415
12416 return Diag(FieldLoc, diag::err_anon_bitfield_width_exceeds_type_size)
12417 << (unsigned)Value.getZExtValue() << (unsigned)TypeSize;
12418 }
12419
Chris Lattnerf9b00eb2009-04-20 17:29:38 +000012420 if (FieldName)
Anders Carlssond5635fe2010-04-16 15:16:32 +000012421 Diag(FieldLoc, diag::warn_bitfield_width_exceeds_type_size)
12422 << FieldName << (unsigned)Value.getZExtValue()
12423 << (unsigned)TypeSize;
12424 else
12425 Diag(FieldLoc, diag::warn_anon_bitfield_width_exceeds_type_size)
12426 << (unsigned)Value.getZExtValue() << (unsigned)TypeSize;
Chris Lattnerf9b00eb2009-04-20 17:29:38 +000012427 }
Douglas Gregor1efa4372009-03-11 18:59:21 +000012428 }
Anders Carlsson5df391e2008-12-06 20:33:04 +000012429
Nikola Smiljanic03ff2592014-05-29 14:05:12 +000012430 return BitWidth;
Anders Carlsson5df391e2008-12-06 20:33:04 +000012431}
12432
Richard Smith938f40b2011-06-11 17:19:42 +000012433/// ActOnField - Each field of a C struct/union is passed into this in order
Chris Lattner1300fb92007-01-23 23:42:53 +000012434/// to create a FieldDecl object for it.
Richard Smith938f40b2011-06-11 17:19:42 +000012435Decl *Sema::ActOnField(Scope *S, Decl *TagD, SourceLocation DeclStart,
Richard Trieu2bd04012011-09-09 02:00:50 +000012436 Declarator &D, Expr *BitfieldWidth) {
John McCall48871652010-08-21 09:40:31 +000012437 FieldDecl *Res = HandleField(S, cast_or_null<RecordDecl>(TagD),
Chris Lattner83f095c2009-03-28 19:18:32 +000012438 DeclStart, D, static_cast<Expr*>(BitfieldWidth),
Richard Smith2b013182012-06-10 03:12:00 +000012439 /*InitStyle=*/ICIS_NoInit, AS_public);
John McCall48871652010-08-21 09:40:31 +000012440 return Res;
Chris Lattner73bf7b42009-03-05 22:45:59 +000012441}
12442
12443/// HandleField - Analyze a field of a C struct or a C++ data member.
12444///
12445FieldDecl *Sema::HandleField(Scope *S, RecordDecl *Record,
12446 SourceLocation DeclStart,
Richard Smith2b013182012-06-10 03:12:00 +000012447 Declarator &D, Expr *BitWidth,
12448 InClassInitStyle InitStyle,
Douglas Gregor4261e4c2009-03-11 20:50:30 +000012449 AccessSpecifier AS) {
Chris Lattner1300fb92007-01-23 23:42:53 +000012450 IdentifierInfo *II = D.getIdentifier();
Chris Lattner1300fb92007-01-23 23:42:53 +000012451 SourceLocation Loc = DeclStart;
12452 if (II) Loc = D.getIdentifierLoc();
Mike Stump11289f42009-09-09 15:08:12 +000012453
John McCall8cb7bdf2010-06-04 23:28:52 +000012454 TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S);
12455 QualType T = TInfo->getType();
David Blaikiebbafb8a2012-03-11 07:00:24 +000012456 if (getLangOpts().CPlusPlus) {
Douglas Gregor1efa4372009-03-11 18:59:21 +000012457 CheckExtraCXXDefaultArguments(D);
Douglas Gregor0c880302009-03-11 23:00:04 +000012458
Douglas Gregora02a72a2010-12-15 23:18:36 +000012459 if (DiagnoseUnexpandedParameterPack(D.getIdentifierLoc(), TInfo,
12460 UPPC_DataMemberType)) {
12461 D.setInvalidType();
12462 T = Context.IntTy;
12463 TInfo = Context.getTrivialTypeSourceInfo(T, Loc);
12464 }
12465 }
12466
Matt Arsenault376f7202013-02-26 21:16:00 +000012467 // TR 18037 does not allow fields to be declared with address spaces.
12468 if (T.getQualifiers().hasAddressSpace()) {
12469 Diag(Loc, diag::err_field_with_address_space);
12470 D.setInvalidType();
12471 }
12472
Guy Benyei1b4fb3e2013-01-20 12:31:11 +000012473 // OpenCL 1.2 spec, s6.9 r:
12474 // The event type cannot be used to declare a structure or union field.
12475 if (LangOpts.OpenCL && T->isEventT()) {
12476 Diag(Loc, diag::err_event_t_struct_field);
12477 D.setInvalidType();
12478 }
12479
Richard Smithb1402ae2013-03-18 22:52:47 +000012480 DiagnoseFunctionSpecifiers(D.getDeclSpec());
Eli Friedman574c7452009-04-07 19:37:57 +000012481
Richard Smithb4a9e862013-04-12 22:46:28 +000012482 if (DeclSpec::TSCS TSCS = D.getDeclSpec().getThreadStorageClassSpec())
12483 Diag(D.getDeclSpec().getThreadStorageClassSpecLoc(),
12484 diag::err_invalid_thread)
12485 << DeclSpec::getSpecifierName(TSCS);
Matt Arsenault376f7202013-02-26 21:16:00 +000012486
Douglas Gregor2c7d9292010-08-30 14:32:14 +000012487 // Check to see if this name was declared as a member previously
Craig Topperc3ec1492014-05-26 06:22:03 +000012488 NamedDecl *PrevDecl = nullptr;
Douglas Gregor2c7d9292010-08-30 14:32:14 +000012489 LookupResult Previous(*this, II, Loc, LookupMemberName, ForRedeclaration);
12490 LookupName(Previous, S);
Douglas Gregorfbf87522011-10-21 15:47:52 +000012491 switch (Previous.getResultKind()) {
12492 case LookupResult::Found:
12493 case LookupResult::FoundUnresolvedValue:
12494 PrevDecl = Previous.getAsSingle<NamedDecl>();
12495 break;
12496
12497 case LookupResult::FoundOverloaded:
12498 PrevDecl = Previous.getRepresentativeDecl();
12499 break;
12500
12501 case LookupResult::NotFound:
12502 case LookupResult::NotFoundInCurrentInstantiation:
12503 case LookupResult::Ambiguous:
12504 break;
12505 }
12506 Previous.suppressDiagnostics();
Douglas Gregorf187420f2009-06-17 23:37:01 +000012507
12508 if (PrevDecl && PrevDecl->isTemplateParameter()) {
12509 // Maybe we will complain about the shadowed template parameter.
12510 DiagnoseTemplateParameterShadow(D.getIdentifierLoc(), PrevDecl);
12511 // Just pretend that we didn't see the previous declaration.
Craig Topperc3ec1492014-05-26 06:22:03 +000012512 PrevDecl = nullptr;
Douglas Gregorf187420f2009-06-17 23:37:01 +000012513 }
12514
Douglas Gregor1efa4372009-03-11 18:59:21 +000012515 if (PrevDecl && !isDeclInScope(PrevDecl, Record, S))
Craig Topperc3ec1492014-05-26 06:22:03 +000012516 PrevDecl = nullptr;
Douglas Gregor1efa4372009-03-11 18:59:21 +000012517
Steve Naroff5ec6ff72009-07-14 14:58:18 +000012518 bool Mutable
12519 = (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_mutable);
Daniel Dunbar62ee6412012-03-09 18:35:03 +000012520 SourceLocation TSSL = D.getLocStart();
Steve Naroff5ec6ff72009-07-14 14:58:18 +000012521 FieldDecl *NewFD
Richard Smith2b013182012-06-10 03:12:00 +000012522 = CheckFieldDecl(II, T, TInfo, Record, Loc, Mutable, BitWidth, InitStyle,
Richard Smith938f40b2011-06-11 17:19:42 +000012523 TSSL, AS, PrevDecl, &D);
Rafael Espindola568586f2010-03-21 22:56:43 +000012524
12525 if (NewFD->isInvalidDecl())
12526 Record->setInvalidDecl();
12527
Douglas Gregor3baa6702011-09-12 16:11:24 +000012528 if (D.getDeclSpec().isModulePrivateSpecified())
12529 NewFD->setModulePrivate();
12530
Douglas Gregor1efa4372009-03-11 18:59:21 +000012531 if (NewFD->isInvalidDecl() && PrevDecl) {
12532 // Don't introduce NewFD into scope; there's already something
12533 // with the same name in the same scope.
12534 } else if (II) {
12535 PushOnScopeChains(NewFD, S);
12536 } else
Argyrios Kyrtzidiscfbfe782009-06-30 02:36:12 +000012537 Record->addDecl(NewFD);
Douglas Gregor1efa4372009-03-11 18:59:21 +000012538
12539 return NewFD;
12540}
12541
12542/// \brief Build a new FieldDecl and check its well-formedness.
12543///
12544/// This routine builds a new FieldDecl given the fields name, type,
12545/// record, etc. \p PrevDecl should refer to any previous declaration
12546/// with the same name and in the same scope as the field to be
12547/// created.
12548///
12549/// \returns a new FieldDecl.
12550///
Mike Stump11289f42009-09-09 15:08:12 +000012551/// \todo The Declarator argument is a hack. It will be removed once
Argyrios Kyrtzidis60ed5602009-08-19 01:27:57 +000012552FieldDecl *Sema::CheckFieldDecl(DeclarationName Name, QualType T,
John McCallbcd03502009-12-07 02:54:59 +000012553 TypeSourceInfo *TInfo,
Douglas Gregor1efa4372009-03-11 18:59:21 +000012554 RecordDecl *Record, SourceLocation Loc,
Richard Smith2b013182012-06-10 03:12:00 +000012555 bool Mutable, Expr *BitWidth,
12556 InClassInitStyle InitStyle,
Steve Naroff5ec6ff72009-07-14 14:58:18 +000012557 SourceLocation TSSL,
Douglas Gregor4261e4c2009-03-11 20:50:30 +000012558 AccessSpecifier AS, NamedDecl *PrevDecl,
Douglas Gregor1efa4372009-03-11 18:59:21 +000012559 Declarator *D) {
12560 IdentifierInfo *II = Name.getAsIdentifierInfo();
Steve Narofff93b6722007-08-28 20:14:24 +000012561 bool InvalidDecl = false;
Chris Lattnerf6d1c9c2009-04-25 08:06:05 +000012562 if (D) InvalidDecl = D->isInvalidType();
Sebastian Redlbaad4e72009-01-05 20:52:13 +000012563
Douglas Gregor1efa4372009-03-11 18:59:21 +000012564 // If we receive a broken type, recover by assuming 'int' and
12565 // marking this declaration as invalid.
12566 if (T.isNull()) {
12567 InvalidDecl = true;
12568 T = Context.IntTy;
12569 }
12570
Eli Friedmand0e8de22009-12-07 00:22:08 +000012571 QualType EltTy = Context.getBaseElementType(T);
Argyrios Kyrtzidis25596292012-03-09 20:10:30 +000012572 if (!EltTy->isDependentType()) {
12573 if (RequireCompleteType(Loc, EltTy, diag::err_field_incomplete)) {
12574 // Fields of incomplete type force their record to be invalid.
12575 Record->setInvalidDecl();
12576 InvalidDecl = true;
12577 } else {
12578 NamedDecl *Def;
12579 EltTy->isIncompleteType(&Def);
12580 if (Def && Def->isInvalidDecl()) {
12581 Record->setInvalidDecl();
12582 InvalidDecl = true;
12583 }
12584 }
John McCall2677e102010-08-16 23:42:35 +000012585 }
Eli Friedmand0e8de22009-12-07 00:22:08 +000012586
Joey Gouly1d58cdb2013-01-17 17:35:00 +000012587 // OpenCL v1.2 s6.9.c: bitfields are not supported.
12588 if (BitWidth && getLangOpts().OpenCL) {
12589 Diag(Loc, diag::err_opencl_bitfields);
12590 InvalidDecl = true;
12591 }
12592
Steve Naroff8eeeb132007-05-08 21:09:37 +000012593 // C99 6.7.2.1p8: A member of a structure or union may have any type other
12594 // than a variably modified type.
Eli Friedmand0e8de22009-12-07 00:22:08 +000012595 if (!InvalidDecl && T->isVariablyModifiedType()) {
Eli Friedmana3b1d032009-02-21 00:44:51 +000012596 bool SizeIsNegative;
Douglas Gregorcaa1bf42010-08-18 00:39:00 +000012597 llvm::APSInt Oversized;
Abramo Bagnara341ab732012-11-08 14:44:42 +000012598
12599 TypeSourceInfo *FixedTInfo =
12600 TryToFixInvalidVariablyModifiedTypeSourceInfo(TInfo, Context,
12601 SizeIsNegative,
12602 Oversized);
12603 if (FixedTInfo) {
Eli Friedmana3b1d032009-02-21 00:44:51 +000012604 Diag(Loc, diag::warn_illegal_constant_array_size);
Abramo Bagnara341ab732012-11-08 14:44:42 +000012605 TInfo = FixedTInfo;
12606 T = FixedTInfo->getType();
Eli Friedmana3b1d032009-02-21 00:44:51 +000012607 } else {
12608 if (SizeIsNegative)
12609 Diag(Loc, diag::err_typecheck_negative_array_size);
Douglas Gregorcaa1bf42010-08-18 00:39:00 +000012610 else if (Oversized.getBoolValue())
12611 Diag(Loc, diag::err_array_too_large)
12612 << Oversized.toString(10);
Eli Friedmana3b1d032009-02-21 00:44:51 +000012613 else
12614 Diag(Loc, diag::err_typecheck_field_variable_size);
Eli Friedmana3b1d032009-02-21 00:44:51 +000012615 InvalidDecl = true;
12616 }
Steve Naroff8eeeb132007-05-08 21:09:37 +000012617 }
Mike Stump11289f42009-09-09 15:08:12 +000012618
Anders Carlsson576cc6f2009-03-22 20:18:17 +000012619 // Fields can not have abstract class types
Eli Friedmand0e8de22009-12-07 00:22:08 +000012620 if (!InvalidDecl && RequireNonAbstractType(Loc, T,
12621 diag::err_abstract_type_in_decl,
12622 AbstractFieldType))
Anders Carlsson576cc6f2009-03-22 20:18:17 +000012623 InvalidDecl = true;
Mike Stump11289f42009-09-09 15:08:12 +000012624
Eli Friedmanc96d4962009-08-15 21:55:26 +000012625 bool ZeroWidth = false;
David Majnemer8702b522015-04-26 04:58:18 +000012626 if (InvalidDecl)
12627 BitWidth = nullptr;
Douglas Gregor1efa4372009-03-11 18:59:21 +000012628 // If this is declared as a bit-field, check the bit-field.
David Majnemer8702b522015-04-26 04:58:18 +000012629 if (BitWidth) {
Reid Kleckner736bc982013-07-17 20:46:03 +000012630 BitWidth = VerifyBitField(Loc, II, T, Record->isMsStruct(Context), BitWidth,
Nikola Smiljanic01a75982014-05-29 10:55:11 +000012631 &ZeroWidth).get();
Richard Smithf4c51d92012-02-04 09:53:13 +000012632 if (!BitWidth) {
12633 InvalidDecl = true;
Craig Topperc3ec1492014-05-26 06:22:03 +000012634 BitWidth = nullptr;
Richard Smithf4c51d92012-02-04 09:53:13 +000012635 ZeroWidth = false;
12636 }
Anders Carlsson5df391e2008-12-06 20:33:04 +000012637 }
Mike Stump11289f42009-09-09 15:08:12 +000012638
John McCallb1cd7da2010-06-04 08:34:12 +000012639 // Check that 'mutable' is consistent with the type of the declaration.
12640 if (!InvalidDecl && Mutable) {
12641 unsigned DiagID = 0;
12642 if (T->isReferenceType())
Alexey Bataev8f01bb92015-02-04 04:45:32 +000012643 DiagID = getLangOpts().MSVCCompat ? diag::ext_mutable_reference
12644 : diag::err_mutable_reference;
John McCallb1cd7da2010-06-04 08:34:12 +000012645 else if (T.isConstQualified())
12646 DiagID = diag::err_mutable_const;
12647
12648 if (DiagID) {
12649 SourceLocation ErrLoc = Loc;
12650 if (D && D->getDeclSpec().getStorageClassSpecLoc().isValid())
12651 ErrLoc = D->getDeclSpec().getStorageClassSpecLoc();
12652 Diag(ErrLoc, DiagID);
Alexey Bataev8f01bb92015-02-04 04:45:32 +000012653 if (DiagID != diag::ext_mutable_reference) {
12654 Mutable = false;
12655 InvalidDecl = true;
12656 }
John McCallb1cd7da2010-06-04 08:34:12 +000012657 }
12658 }
12659
Richard Smithab44d5b2013-12-10 08:25:00 +000012660 // C++11 [class.union]p8 (DR1460):
12661 // At most one variant member of a union may have a
12662 // brace-or-equal-initializer.
12663 if (InitStyle != ICIS_NoInit)
12664 checkDuplicateDefaultInit(*this, cast<CXXRecordDecl>(Record), Loc);
12665
Abramo Bagnaradff19302011-03-08 08:55:46 +000012666 FieldDecl *NewFD = FieldDecl::Create(Context, Record, TSSL, Loc, II, T, TInfo,
Richard Smith2b013182012-06-10 03:12:00 +000012667 BitWidth, Mutable, InitStyle);
Chris Lattnerf6d1c9c2009-04-25 08:06:05 +000012668 if (InvalidDecl)
12669 NewFD->setInvalidDecl();
Douglas Gregor91f84212008-12-11 16:49:14 +000012670
Douglas Gregor1efa4372009-03-11 18:59:21 +000012671 if (PrevDecl && !isa<TagDecl>(PrevDecl)) {
12672 Diag(Loc, diag::err_duplicate_member) << II;
12673 Diag(PrevDecl->getLocation(), diag::note_previous_declaration);
12674 NewFD->setInvalidDecl();
Douglas Gregor82ac25e2009-01-08 20:45:30 +000012675 }
12676
David Blaikiebbafb8a2012-03-11 07:00:24 +000012677 if (!InvalidDecl && getLangOpts().CPlusPlus) {
Anders Carlsson2ceb3472010-11-07 19:13:55 +000012678 if (Record->isUnion()) {
12679 if (const RecordType *RT = EltTy->getAs<RecordType>()) {
12680 CXXRecordDecl* RDecl = cast<CXXRecordDecl>(RT->getDecl());
12681 if (RDecl->getDefinition()) {
12682 // C++ [class.union]p1: An object of a class with a non-trivial
12683 // constructor, a non-trivial copy constructor, a non-trivial
12684 // destructor, or a non-trivial copy assignment operator
12685 // cannot be a member of a union, nor can an array of such
12686 // objects.
Richard Smithf720df02011-10-19 20:41:51 +000012687 if (CheckNontrivialField(NewFD))
Anders Carlsson2ceb3472010-11-07 19:13:55 +000012688 NewFD->setInvalidDecl();
12689 }
12690 }
12691
12692 // C++ [class.union]p1: If a union contains a member of reference type,
Aaron Ballmaned0ae1d2013-05-30 16:20:00 +000012693 // the program is ill-formed, except when compiling with MSVC extensions
12694 // enabled.
Anders Carlsson2ceb3472010-11-07 19:13:55 +000012695 if (EltTy->isReferenceType()) {
Aaron Ballmaned0ae1d2013-05-30 16:20:00 +000012696 Diag(NewFD->getLocation(), getLangOpts().MicrosoftExt ?
12697 diag::ext_union_member_of_reference_type :
12698 diag::err_union_member_of_reference_type)
Anders Carlsson2ceb3472010-11-07 19:13:55 +000012699 << NewFD->getDeclName() << EltTy;
Aaron Ballmaned0ae1d2013-05-30 16:20:00 +000012700 if (!getLangOpts().MicrosoftExt)
12701 NewFD->setInvalidDecl();
Douglas Gregor8a273912009-07-22 18:25:24 +000012702 }
12703 }
12704 }
12705
Douglas Gregor1efa4372009-03-11 18:59:21 +000012706 // FIXME: We need to pass in the attributes given an AST
12707 // representation, not a parser representation.
Richard Smith848e1f12013-02-01 08:12:08 +000012708 if (D) {
Douglas Gregord2472d42013-05-02 23:25:32 +000012709 // FIXME: The current scope is almost... but not entirely... correct here.
12710 ProcessDeclAttributes(getCurScope(), NewFD, *D);
Douglas Gregor1efa4372009-03-11 18:59:21 +000012711
Richard Smith848e1f12013-02-01 08:12:08 +000012712 if (NewFD->hasAttrs())
12713 CheckAlignasUnderalignment(NewFD);
12714 }
12715
John McCall31168b02011-06-15 23:02:42 +000012716 // In auto-retain/release, infer strong retension for fields of
12717 // retainable type.
David Blaikiebbafb8a2012-03-11 07:00:24 +000012718 if (getLangOpts().ObjCAutoRefCount && inferObjCARCLifetime(NewFD))
John McCall31168b02011-06-15 23:02:42 +000012719 NewFD->setInvalidDecl();
12720
Fariborz Jahaniand29fecd2009-02-19 00:22:47 +000012721 if (T.isObjCGCWeak())
Fariborz Jahaniand35c7922009-02-18 18:14:41 +000012722 Diag(Loc, diag::warn_attribute_weak_on_field);
Anders Carlsson28e71082008-02-16 00:29:18 +000012723
Douglas Gregor4261e4c2009-03-11 20:50:30 +000012724 NewFD->setAccess(AS);
Steve Narofff93b6722007-08-28 20:14:24 +000012725 return NewFD;
Chris Lattner1300fb92007-01-23 23:42:53 +000012726}
12727
Argyrios Kyrtzidis33aee392010-08-16 17:27:08 +000012728bool Sema::CheckNontrivialField(FieldDecl *FD) {
12729 assert(FD);
David Blaikiebbafb8a2012-03-11 07:00:24 +000012730 assert(getLangOpts().CPlusPlus && "valid check only for C++");
Argyrios Kyrtzidis33aee392010-08-16 17:27:08 +000012731
Nick Lewycky7a2a4792013-06-25 23:22:23 +000012732 if (FD->isInvalidDecl() || FD->getType()->isDependentType())
12733 return false;
Argyrios Kyrtzidis33aee392010-08-16 17:27:08 +000012734
12735 QualType EltTy = Context.getBaseElementType(FD->getType());
12736 if (const RecordType *RT = EltTy->getAs<RecordType>()) {
Richard Smith92f241f2012-12-08 02:53:02 +000012737 CXXRecordDecl *RDecl = cast<CXXRecordDecl>(RT->getDecl());
Argyrios Kyrtzidis33aee392010-08-16 17:27:08 +000012738 if (RDecl->getDefinition()) {
12739 // We check for copy constructors before constructors
12740 // because otherwise we'll never get complaints about
12741 // copy constructors.
12742
12743 CXXSpecialMember member = CXXInvalid;
Richard Smith16488472012-11-16 00:53:38 +000012744 // We're required to check for any non-trivial constructors. Since the
12745 // implicit default constructor is suppressed if there are any
12746 // user-declared constructors, we just need to check that there is a
12747 // trivial default constructor and a trivial copy constructor. (We don't
12748 // worry about move constructors here, since this is a C++98 check.)
12749 if (RDecl->hasNonTrivialCopyConstructor())
Argyrios Kyrtzidis33aee392010-08-16 17:27:08 +000012750 member = CXXCopyConstructor;
Alexis Huntf479f1b2011-05-09 18:22:59 +000012751 else if (!RDecl->hasTrivialDefaultConstructor())
Alexis Hunt80f00ff2011-05-10 19:08:14 +000012752 member = CXXDefaultConstructor;
Richard Smith16488472012-11-16 00:53:38 +000012753 else if (RDecl->hasNonTrivialCopyAssignment())
Argyrios Kyrtzidis33aee392010-08-16 17:27:08 +000012754 member = CXXCopyAssignment;
Richard Smith16488472012-11-16 00:53:38 +000012755 else if (RDecl->hasNonTrivialDestructor())
Argyrios Kyrtzidis33aee392010-08-16 17:27:08 +000012756 member = CXXDestructor;
12757
12758 if (member != CXXInvalid) {
Richard Smith2bf7fdb2013-01-02 11:42:31 +000012759 if (!getLangOpts().CPlusPlus11 &&
David Blaikiebbafb8a2012-03-11 07:00:24 +000012760 getLangOpts().ObjCAutoRefCount && RDecl->hasObjectMember()) {
John McCall31168b02011-06-15 23:02:42 +000012761 // Objective-C++ ARC: it is an error to have a non-trivial field of
12762 // a union. However, system headers in Objective-C programs
12763 // occasionally have Objective-C lifetime objects within unions,
12764 // and rather than cause the program to fail, we make those
12765 // members unavailable.
12766 SourceLocation Loc = FD->getLocation();
12767 if (getSourceManager().isInSystemHeader(Loc)) {
12768 if (!FD->hasAttr<UnavailableAttr>())
Aaron Ballman36a53502014-01-16 13:03:14 +000012769 FD->addAttr(UnavailableAttr::CreateImplicit(Context,
12770 "this system field has retaining ownership",
12771 Loc));
John McCall31168b02011-06-15 23:02:42 +000012772 return false;
12773 }
12774 }
Richard Smithf720df02011-10-19 20:41:51 +000012775
Richard Smith2bf7fdb2013-01-02 11:42:31 +000012776 Diag(FD->getLocation(), getLangOpts().CPlusPlus11 ?
Richard Smithf720df02011-10-19 20:41:51 +000012777 diag::warn_cxx98_compat_nontrivial_union_or_anon_struct_member :
12778 diag::err_illegal_union_or_anon_struct_member)
12779 << (int)FD->getParent()->isUnion() << FD->getDeclName() << member;
Richard Smith92f241f2012-12-08 02:53:02 +000012780 DiagnoseNontrivial(RDecl, member);
Richard Smith2bf7fdb2013-01-02 11:42:31 +000012781 return !getLangOpts().CPlusPlus11;
Argyrios Kyrtzidis33aee392010-08-16 17:27:08 +000012782 }
12783 }
12784 }
Richard Smith92f241f2012-12-08 02:53:02 +000012785
Argyrios Kyrtzidis33aee392010-08-16 17:27:08 +000012786 return false;
12787}
12788
Mike Stump11289f42009-09-09 15:08:12 +000012789/// TranslateIvarVisibility - Translate visibility from a token ID to an
Fariborz Jahanianf26702eb2007-10-01 16:53:59 +000012790/// AST enum value.
Ted Kremenek1b0ea822008-01-07 19:49:32 +000012791static ObjCIvarDecl::AccessControl
Fariborz Jahanianf26702eb2007-10-01 16:53:59 +000012792TranslateIvarVisibility(tok::ObjCKeywordKind ivarVisibility) {
Steve Naroff2e688fd2007-09-14 23:09:53 +000012793 switch (ivarVisibility) {
David Blaikie83d382b2011-09-23 05:06:16 +000012794 default: llvm_unreachable("Unknown visitibility kind");
Chris Lattner79ef8432008-10-12 00:28:42 +000012795 case tok::objc_private: return ObjCIvarDecl::Private;
12796 case tok::objc_public: return ObjCIvarDecl::Public;
12797 case tok::objc_protected: return ObjCIvarDecl::Protected;
12798 case tok::objc_package: return ObjCIvarDecl::Package;
Steve Naroff2e688fd2007-09-14 23:09:53 +000012799 }
12800}
12801
Mike Stump11289f42009-09-09 15:08:12 +000012802/// ActOnIvar - Each ivar field of an objective-c class is passed into this
Fariborz Jahanian96376742008-04-11 16:55:42 +000012803/// in order to create an IvarDecl object for it.
John McCall48871652010-08-21 09:40:31 +000012804Decl *Sema::ActOnIvar(Scope *S,
Mike Stump11289f42009-09-09 15:08:12 +000012805 SourceLocation DeclStart,
Richard Trieu2bd04012011-09-09 02:00:50 +000012806 Declarator &D, Expr *BitfieldWidth,
Chris Lattner83f095c2009-03-28 19:18:32 +000012807 tok::ObjCKeywordKind Visibility) {
Mike Stump11289f42009-09-09 15:08:12 +000012808
Fariborz Jahaniande615832008-04-10 23:32:45 +000012809 IdentifierInfo *II = D.getIdentifier();
12810 Expr *BitWidth = (Expr*)BitfieldWidth;
12811 SourceLocation Loc = DeclStart;
12812 if (II) Loc = D.getIdentifierLoc();
Mike Stump11289f42009-09-09 15:08:12 +000012813
Fariborz Jahaniande615832008-04-10 23:32:45 +000012814 // FIXME: Unnamed fields can be handled in various different ways, for
12815 // example, unnamed unions inject all members into the struct namespace!
Mike Stump11289f42009-09-09 15:08:12 +000012816
John McCall8cb7bdf2010-06-04 23:28:52 +000012817 TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S);
12818 QualType T = TInfo->getType();
Mike Stump11289f42009-09-09 15:08:12 +000012819
Fariborz Jahaniande615832008-04-10 23:32:45 +000012820 if (BitWidth) {
Steve Naroff17b2f5d2009-02-20 17:57:11 +000012821 // 6.7.2.1p3, 6.7.2.1p4
Nikola Smiljanic01a75982014-05-29 10:55:11 +000012822 BitWidth = VerifyBitField(Loc, II, T, /*IsMsStruct*/false, BitWidth).get();
Richard Smithf4c51d92012-02-04 09:53:13 +000012823 if (!BitWidth)
Chris Lattnerf6d1c9c2009-04-25 08:06:05 +000012824 D.setInvalidType();
Fariborz Jahaniande615832008-04-10 23:32:45 +000012825 } else {
12826 // Not a bitfield.
Mike Stump11289f42009-09-09 15:08:12 +000012827
Fariborz Jahaniande615832008-04-10 23:32:45 +000012828 // validate II.
Mike Stump11289f42009-09-09 15:08:12 +000012829
Fariborz Jahaniande615832008-04-10 23:32:45 +000012830 }
Fariborz Jahanian0103d672010-04-26 22:07:03 +000012831 if (T->isReferenceType()) {
12832 Diag(Loc, diag::err_ivar_reference_type);
12833 D.setInvalidType();
12834 }
Fariborz Jahaniande615832008-04-10 23:32:45 +000012835 // C99 6.7.2.1p8: A member of a structure or union may have any type other
12836 // than a variably modified type.
Fariborz Jahanian0103d672010-04-26 22:07:03 +000012837 else if (T->isVariablyModifiedType()) {
Anders Carlsson0d8f0ba2008-12-07 00:20:55 +000012838 Diag(Loc, diag::err_typecheck_ivar_variable_size);
Chris Lattnerf6d1c9c2009-04-25 08:06:05 +000012839 D.setInvalidType();
Fariborz Jahaniande615832008-04-10 23:32:45 +000012840 }
Mike Stump11289f42009-09-09 15:08:12 +000012841
Ted Kremenek73295fa2008-07-23 18:04:17 +000012842 // Get the visibility (access control) for this ivar.
Mike Stump11289f42009-09-09 15:08:12 +000012843 ObjCIvarDecl::AccessControl ac =
Ted Kremenek73295fa2008-07-23 18:04:17 +000012844 Visibility != tok::objc_not_keyword ? TranslateIvarVisibility(Visibility)
12845 : ObjCIvarDecl::None;
Fariborz Jahanian68453832009-06-05 18:16:35 +000012846 // Must set ivar's DeclContext to its enclosing interface.
Fariborz Jahanian8d382dc2011-08-22 15:54:49 +000012847 ObjCContainerDecl *EnclosingDecl = cast<ObjCContainerDecl>(CurContext);
Fariborz Jahanian17612b12012-02-02 00:49:12 +000012848 if (!EnclosingDecl || EnclosingDecl->isInvalidDecl())
Craig Topperc3ec1492014-05-26 06:22:03 +000012849 return nullptr;
Daniel Dunbar229385c2010-04-02 18:29:09 +000012850 ObjCContainerDecl *EnclosingContext;
Mike Stump11289f42009-09-09 15:08:12 +000012851 if (ObjCImplementationDecl *IMPDecl =
Fariborz Jahanian68453832009-06-05 18:16:35 +000012852 dyn_cast<ObjCImplementationDecl>(EnclosingDecl)) {
John McCall5fb5df92012-06-20 06:18:46 +000012853 if (LangOpts.ObjCRuntime.isFragile()) {
Fariborz Jahanian68453832009-06-05 18:16:35 +000012854 // Case of ivar declared in an implementation. Context is that of its class.
Fariborz Jahanianbf9294f2010-08-23 18:51:39 +000012855 EnclosingContext = IMPDecl->getClassInterface();
12856 assert(EnclosingContext && "Implementation has no class interface!");
12857 }
12858 else
12859 EnclosingContext = EnclosingDecl;
Fariborz Jahanian6a0a2e02010-04-06 22:43:48 +000012860 } else {
12861 if (ObjCCategoryDecl *CDecl =
12862 dyn_cast<ObjCCategoryDecl>(EnclosingDecl)) {
John McCall5fb5df92012-06-20 06:18:46 +000012863 if (LangOpts.ObjCRuntime.isFragile() || !CDecl->IsClassExtension()) {
Fariborz Jahanian6a0a2e02010-04-06 22:43:48 +000012864 Diag(Loc, diag::err_misplaced_ivar) << CDecl->IsClassExtension();
Craig Topperc3ec1492014-05-26 06:22:03 +000012865 return nullptr;
Fariborz Jahanian6a0a2e02010-04-06 22:43:48 +000012866 }
12867 }
Daniel Dunbar229385c2010-04-02 18:29:09 +000012868 EnclosingContext = EnclosingDecl;
Fariborz Jahanian6a0a2e02010-04-06 22:43:48 +000012869 }
Mike Stump11289f42009-09-09 15:08:12 +000012870
Ted Kremenek73295fa2008-07-23 18:04:17 +000012871 // Construct the decl.
Abramo Bagnaradff19302011-03-08 08:55:46 +000012872 ObjCIvarDecl *NewID = ObjCIvarDecl::Create(Context, EnclosingContext,
12873 DeclStart, Loc, II, T,
John McCallbcd03502009-12-07 02:54:59 +000012874 TInfo, ac, (Expr *)BitfieldWidth);
Mike Stump11289f42009-09-09 15:08:12 +000012875
Douglas Gregor82ac25e2009-01-08 20:45:30 +000012876 if (II) {
Douglas Gregorb2ccf012010-04-15 22:33:43 +000012877 NamedDecl *PrevDecl = LookupSingleName(S, II, Loc, LookupMemberName,
John McCall5cebab12009-11-18 07:57:50 +000012878 ForRedeclaration);
Fariborz Jahanian68453832009-06-05 18:16:35 +000012879 if (PrevDecl && isDeclInScope(PrevDecl, EnclosingContext, S)
Douglas Gregor82ac25e2009-01-08 20:45:30 +000012880 && !isa<TagDecl>(PrevDecl)) {
12881 Diag(Loc, diag::err_duplicate_member) << II;
12882 Diag(PrevDecl->getLocation(), diag::note_previous_declaration);
12883 NewID->setInvalidDecl();
12884 }
12885 }
12886
Ted Kremenek73295fa2008-07-23 18:04:17 +000012887 // Process attributes attached to the ivar.
Douglas Gregor758a8692009-06-17 21:51:59 +000012888 ProcessDeclAttributes(S, NewID, D);
Mike Stump11289f42009-09-09 15:08:12 +000012889
Chris Lattnerf6d1c9c2009-04-25 08:06:05 +000012890 if (D.isInvalidType())
Fariborz Jahaniande615832008-04-10 23:32:45 +000012891 NewID->setInvalidDecl();
Ted Kremenek73295fa2008-07-23 18:04:17 +000012892
John McCall31168b02011-06-15 23:02:42 +000012893 // In ARC, infer 'retaining' for ivars of retainable type.
David Blaikiebbafb8a2012-03-11 07:00:24 +000012894 if (getLangOpts().ObjCAutoRefCount && inferObjCARCLifetime(NewID))
John McCall31168b02011-06-15 23:02:42 +000012895 NewID->setInvalidDecl();
12896
Douglas Gregor3baa6702011-09-12 16:11:24 +000012897 if (D.getDeclSpec().isModulePrivateSpecified())
12898 NewID->setModulePrivate();
12899
Douglas Gregor82ac25e2009-01-08 20:45:30 +000012900 if (II) {
12901 // FIXME: When interfaces are DeclContexts, we'll need to add
12902 // these to the interface.
John McCall48871652010-08-21 09:40:31 +000012903 S->AddDecl(NewID);
Douglas Gregor82ac25e2009-01-08 20:45:30 +000012904 IdResolver.AddDecl(NewID);
12905 }
Fariborz Jahanian80297b12012-05-15 16:33:04 +000012906
John McCall5fb5df92012-06-20 06:18:46 +000012907 if (LangOpts.ObjCRuntime.isNonFragile() &&
Fariborz Jahanian80297b12012-05-15 16:33:04 +000012908 !NewID->isInvalidDecl() && isa<ObjCInterfaceDecl>(EnclosingDecl))
Fariborz Jahaniane1ada582012-05-15 17:43:16 +000012909 Diag(Loc, diag::warn_ivars_in_interface);
Fariborz Jahanian80297b12012-05-15 16:33:04 +000012910
John McCall48871652010-08-21 09:40:31 +000012911 return NewID;
Fariborz Jahaniande615832008-04-10 23:32:45 +000012912}
12913
Fariborz Jahanian616d3e72010-08-23 22:46:52 +000012914/// ActOnLastBitfield - This routine handles synthesized bitfields rules for
Jordan Rosea0e9d392013-04-03 01:39:23 +000012915/// class and class extensions. For every class \@interface and class
12916/// extension \@interface, if the last ivar is a bitfield of any type,
Fariborz Jahanian616d3e72010-08-23 22:46:52 +000012917/// then add an implicit `char :0` ivar to the end of that interface.
Fariborz Jahanian8d382dc2011-08-22 15:54:49 +000012918void Sema::ActOnLastBitfield(SourceLocation DeclLoc,
Chris Lattner0e62c1c2011-07-23 10:55:15 +000012919 SmallVectorImpl<Decl *> &AllIvarDecls) {
John McCall5fb5df92012-06-20 06:18:46 +000012920 if (LangOpts.ObjCRuntime.isFragile() || AllIvarDecls.empty())
Fariborz Jahanian616d3e72010-08-23 22:46:52 +000012921 return;
12922
12923 Decl *ivarDecl = AllIvarDecls[AllIvarDecls.size()-1];
12924 ObjCIvarDecl *Ivar = cast<ObjCIvarDecl>(ivarDecl);
12925
Richard Smithcaf33902011-10-10 18:28:20 +000012926 if (!Ivar->isBitField() || Ivar->getBitWidthValue(Context) == 0)
Fariborz Jahanian616d3e72010-08-23 22:46:52 +000012927 return;
Fariborz Jahanian8d382dc2011-08-22 15:54:49 +000012928 ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(CurContext);
Fariborz Jahanian616d3e72010-08-23 22:46:52 +000012929 if (!ID) {
Fariborz Jahanian8d382dc2011-08-22 15:54:49 +000012930 if (ObjCCategoryDecl *CD = dyn_cast<ObjCCategoryDecl>(CurContext)) {
Fariborz Jahanian616d3e72010-08-23 22:46:52 +000012931 if (!CD->IsClassExtension())
12932 return;
12933 }
12934 // No need to add this to end of @implementation.
12935 else
12936 return;
12937 }
12938 // All conditions are met. Add a new bitfield to the tail end of ivars.
Douglas Gregor1d394802011-08-03 16:26:46 +000012939 llvm::APInt Zero(Context.getTypeSize(Context.IntTy), 0);
12940 Expr * BW = IntegerLiteral::Create(Context, Zero, Context.IntTy, DeclLoc);
Fariborz Jahanian616d3e72010-08-23 22:46:52 +000012941
Fariborz Jahanian8d382dc2011-08-22 15:54:49 +000012942 Ivar = ObjCIvarDecl::Create(Context, cast<ObjCContainerDecl>(CurContext),
Craig Topperc3ec1492014-05-26 06:22:03 +000012943 DeclLoc, DeclLoc, nullptr,
Fariborz Jahanian616d3e72010-08-23 22:46:52 +000012944 Context.CharTy,
Douglas Gregor1d394802011-08-03 16:26:46 +000012945 Context.getTrivialTypeSourceInfo(Context.CharTy,
12946 DeclLoc),
Fariborz Jahanian616d3e72010-08-23 22:46:52 +000012947 ObjCIvarDecl::Private, BW,
12948 true);
12949 AllIvarDecls.push_back(Ivar);
12950}
12951
Robert Wilhelm16e94b92013-08-09 18:02:13 +000012952void Sema::ActOnFields(Scope *S, SourceLocation RecLoc, Decl *EnclosingDecl,
12953 ArrayRef<Decl *> Fields, SourceLocation LBrac,
12954 SourceLocation RBrac, AttributeList *Attr) {
Steve Naroffdb47ee22007-09-14 22:20:54 +000012955 assert(EnclosingDecl && "missing record or interface decl");
Mike Stump11289f42009-09-09 15:08:12 +000012956
Eric Christopher7457aaf2012-07-19 22:22:51 +000012957 // If this is an Objective-C @implementation or category and we have
12958 // new fields here we should reset the layout of the interface since
12959 // it will now change.
12960 if (!Fields.empty() && isa<ObjCContainerDecl>(EnclosingDecl)) {
12961 ObjCContainerDecl *DC = cast<ObjCContainerDecl>(EnclosingDecl);
12962 switch (DC->getKind()) {
12963 default: break;
12964 case Decl::ObjCCategory:
12965 Context.ResetObjCLayout(cast<ObjCCategoryDecl>(DC)->getClassInterface());
12966 break;
12967 case Decl::ObjCImplementation:
12968 Context.
12969 ResetObjCLayout(cast<ObjCImplementationDecl>(DC)->getClassInterface());
12970 break;
12971 }
12972 }
12973
Eli Friedmana7679412012-02-07 05:00:47 +000012974 RecordDecl *Record = dyn_cast<RecordDecl>(EnclosingDecl);
12975
12976 // Start counting up the number of named members; make sure to include
12977 // members of anonymous structs and unions in the total.
Chris Lattner82625602007-01-24 02:26:21 +000012978 unsigned NumNamedMembers = 0;
Eli Friedmana7679412012-02-07 05:00:47 +000012979 if (Record) {
Aaron Ballman629afae2014-03-07 19:56:05 +000012980 for (const auto *I : Record->decls()) {
12981 if (const auto *IFD = dyn_cast<IndirectFieldDecl>(I))
Eli Friedmana7679412012-02-07 05:00:47 +000012982 if (IFD->getDeclName())
12983 ++NumNamedMembers;
12984 }
12985 }
12986
12987 // Verify that all the fields are okay.
Chris Lattner0e62c1c2011-07-23 10:55:15 +000012988 SmallVector<FieldDecl*, 32> RecFields;
Douglas Gregorf4d33272009-01-07 19:46:03 +000012989
John McCall31168b02011-06-15 23:02:42 +000012990 bool ARCErrReported = false;
Robert Wilhelm16e94b92013-08-09 18:02:13 +000012991 for (ArrayRef<Decl *>::iterator i = Fields.begin(), end = Fields.end();
David Blaikie751c5582011-09-22 02:58:26 +000012992 i != end; ++i) {
12993 FieldDecl *FD = cast<FieldDecl>(*i);
Mike Stump11289f42009-09-09 15:08:12 +000012994
Chris Lattner720a0542007-01-25 00:44:24 +000012995 // Get the type for the field.
John McCall424cec92011-01-19 06:33:43 +000012996 const Type *FDTy = FD->getType().getTypePtr();
Douglas Gregorf4d33272009-01-07 19:46:03 +000012997
Douglas Gregor82ac25e2009-01-08 20:45:30 +000012998 if (!FD->isAnonymousStructOrUnion()) {
Douglas Gregorf4d33272009-01-07 19:46:03 +000012999 // Remember all fields written by the user.
13000 RecFields.push_back(FD);
13001 }
Mike Stump11289f42009-09-09 15:08:12 +000013002
Chris Lattner73bf7b42009-03-05 22:45:59 +000013003 // If the field is already invalid for some reason, don't emit more
13004 // diagnostics about it.
Eli Friedmand0e8de22009-12-07 00:22:08 +000013005 if (FD->isInvalidDecl()) {
13006 EnclosingDecl->setInvalidDecl();
Chris Lattner73bf7b42009-03-05 22:45:59 +000013007 continue;
Eli Friedmand0e8de22009-12-07 00:22:08 +000013008 }
Mike Stump11289f42009-09-09 15:08:12 +000013009
Douglas Gregorac1fb652009-03-24 19:52:54 +000013010 // C99 6.7.2.1p2:
13011 // A structure or union shall not contain a member with
13012 // incomplete or function type (hence, a structure shall not
13013 // contain an instance of itself, but may contain a pointer to
13014 // an instance of itself), except that the last member of a
13015 // structure with more than one named member may have incomplete
13016 // array type; such a structure (and any union containing,
13017 // possibly recursively, a member that is such a structure)
13018 // shall not be a member of a structure or an element of an
13019 // array.
Chris Lattner0fd893e2007-07-31 21:33:24 +000013020 if (FDTy->isFunctionType()) {
Douglas Gregorac1fb652009-03-24 19:52:54 +000013021 // Field declared as a function.
Chris Lattner651d42d2008-11-20 06:38:18 +000013022 Diag(FD->getLocation(), diag::err_field_declared_as_function)
Chris Lattnerf3d3fae2008-11-24 05:29:24 +000013023 << FD->getDeclName();
Steve Naroffdb47ee22007-09-14 22:20:54 +000013024 FD->setInvalidDecl();
13025 EnclosingDecl->setInvalidDecl();
Chris Lattnerbdf8b8d2007-01-24 02:11:17 +000013026 continue;
Francois Pichetf657b632010-09-15 00:14:08 +000013027 } else if (FDTy->isIncompleteArrayType() && Record &&
David Blaikie751c5582011-09-22 02:58:26 +000013028 ((i + 1 == Fields.end() && !Record->isUnion()) ||
David Blaikiebbafb8a2012-03-11 07:00:24 +000013029 ((getLangOpts().MicrosoftExt ||
13030 getLangOpts().CPlusPlus) &&
David Blaikie751c5582011-09-22 02:58:26 +000013031 (i + 1 == Fields.end() || Record->isUnion())))) {
Douglas Gregorac1fb652009-03-24 19:52:54 +000013032 // Flexible array member.
Argyrios Kyrtzidis7e25a952011-03-07 20:04:04 +000013033 // Microsoft and g++ is more permissive regarding flexible array.
Francois Pichetf657b632010-09-15 00:14:08 +000013034 // It will accept flexible array in union and also
Anders Carlsson0ea10472010-10-17 23:36:12 +000013035 // as the sole element of a struct/class.
David Majnemer41016212013-11-02 10:38:05 +000013036 unsigned DiagID = 0;
13037 if (Record->isUnion())
13038 DiagID = getLangOpts().MicrosoftExt
13039 ? diag::ext_flexible_array_union_ms
13040 : getLangOpts().CPlusPlus
13041 ? diag::ext_flexible_array_union_gnu
13042 : diag::err_flexible_array_union;
13043 else if (Fields.size() == 1)
13044 DiagID = getLangOpts().MicrosoftExt
13045 ? diag::ext_flexible_array_empty_aggregate_ms
13046 : getLangOpts().CPlusPlus
13047 ? diag::ext_flexible_array_empty_aggregate_gnu
13048 : NumNamedMembers < 1
13049 ? diag::err_flexible_array_empty_aggregate
13050 : 0;
13051
13052 if (DiagID)
13053 Diag(FD->getLocation(), DiagID) << FD->getDeclName()
13054 << Record->getTagKind();
David Majnemer08cd7602013-11-02 11:19:13 +000013055 // While the layout of types that contain virtual bases is not specified
13056 // by the C++ standard, both the Itanium and Microsoft C++ ABIs place
13057 // virtual bases after the derived members. This would make a flexible
13058 // array member declared at the end of an object not adjacent to the end
13059 // of the type.
13060 if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(Record))
13061 if (RD->getNumVBases() != 0)
13062 Diag(FD->getLocation(), diag::err_flexible_array_virtual_base)
13063 << FD->getDeclName() << Record->getTagKind();
David Majnemer41016212013-11-02 10:38:05 +000013064 if (!getLangOpts().C99)
13065 Diag(FD->getLocation(), diag::ext_c99_flexible_array_member)
13066 << FD->getDeclName() << Record->getTagKind();
13067
Richard Smith6fa28ff2014-01-11 00:53:35 +000013068 // If the element type has a non-trivial destructor, we would not
13069 // implicitly destroy the elements, so disallow it for now.
13070 //
13071 // FIXME: GCC allows this. We should probably either implicitly delete
13072 // the destructor of the containing class, or just allow this.
13073 QualType BaseElem = Context.getBaseElementType(FD->getType());
13074 if (!BaseElem->isDependentType() && BaseElem.isDestructedType()) {
13075 Diag(FD->getLocation(), diag::err_flexible_array_has_nontrivial_dtor)
Fariborz Jahanianb0e28472010-05-26 20:46:24 +000013076 << FD->getDeclName() << FD->getType();
Fariborz Jahanian1138ba62010-05-26 20:19:07 +000013077 FD->setInvalidDecl();
13078 EnclosingDecl->setInvalidDecl();
13079 continue;
13080 }
Chris Lattner720a0542007-01-25 00:44:24 +000013081 // Okay, we have a legal flexible array member at the end of the struct.
David Majnemerac0b30e2014-09-24 11:04:09 +000013082 Record->setHasFlexibleArrayMember(true);
Douglas Gregorac1fb652009-03-24 19:52:54 +000013083 } else if (!FDTy->isDependentType() &&
Mike Stump11289f42009-09-09 15:08:12 +000013084 RequireCompleteType(FD->getLocation(), FD->getType(),
Douglas Gregorac1fb652009-03-24 19:52:54 +000013085 diag::err_field_incomplete)) {
13086 // Incomplete type
13087 FD->setInvalidDecl();
13088 EnclosingDecl->setInvalidDecl();
13089 continue;
Ted Kremenekc23c7e62009-07-29 21:53:49 +000013090 } else if (const RecordType *FDTTy = FDTy->getAs<RecordType>()) {
David Majnemerac0b30e2014-09-24 11:04:09 +000013091 if (Record && FDTTy->getDecl()->hasFlexibleArrayMember()) {
13092 // A type which contains a flexible array member is considered to be a
13093 // flexible array member.
13094 Record->setHasFlexibleArrayMember(true);
13095 if (!Record->isUnion()) {
Chris Lattner720a0542007-01-25 00:44:24 +000013096 // If this is a struct/class and this is not the last element, reject
13097 // it. Note that GCC supports variable sized arrays in the middle of
13098 // structures.
David Blaikie751c5582011-09-22 02:58:26 +000013099 if (i + 1 != Fields.end())
Douglas Gregor3e06dbf2009-03-06 23:41:27 +000013100 Diag(FD->getLocation(), diag::ext_variable_sized_type_in_struct)
Chris Lattnerb28fe9e2009-04-25 18:52:45 +000013101 << FD->getDeclName() << FD->getType();
Douglas Gregor3e06dbf2009-03-06 23:41:27 +000013102 else {
13103 // We support flexible arrays at the end of structs in
13104 // other structs as an extension.
13105 Diag(FD->getLocation(), diag::ext_flexible_array_in_struct)
13106 << FD->getDeclName();
Chris Lattner720a0542007-01-25 00:44:24 +000013107 }
Chris Lattner720a0542007-01-25 00:44:24 +000013108 }
13109 }
Fariborz Jahanian78f565b2012-08-16 22:38:41 +000013110 if (isa<ObjCContainerDecl>(EnclosingDecl) &&
13111 RequireNonAbstractType(FD->getLocation(), FD->getType(),
13112 diag::err_abstract_type_in_decl,
13113 AbstractIvarType)) {
13114 // Ivars can not have abstract class types
13115 FD->setInvalidDecl();
13116 }
Fariborz Jahanian5f21d2f2009-07-08 01:18:33 +000013117 if (Record && FDTTy->getDecl()->hasObjectMember())
13118 Record->setHasObjectMember(true);
Fariborz Jahanian78652202013-01-25 23:57:05 +000013119 if (Record && FDTTy->getDecl()->hasVolatileMember())
13120 Record->setHasVolatileMember(true);
John McCall8b07ec22010-05-15 11:32:37 +000013121 } else if (FDTy->isObjCObjectType()) {
Douglas Gregorac1fb652009-03-24 19:52:54 +000013122 /// A field cannot be an Objective-c object
Fariborz Jahanian6507135e2011-07-26 17:58:54 +000013123 Diag(FD->getLocation(), diag::err_statically_allocated_object)
13124 << FixItHint::CreateInsertion(FD->getLocation(), "*");
13125 QualType T = Context.getObjCObjectPointerType(FD->getType());
13126 FD->setType(T);
Douglas Gregore6c3fa02013-01-28 19:08:09 +000013127 } else if (getLangOpts().ObjCAutoRefCount && Record && !ARCErrReported &&
13128 (!getLangOpts().CPlusPlus || Record->isUnion())) {
13129 // It's an error in ARC if a field has lifetime.
13130 // We don't want to report this in a system header, though,
13131 // so we just make the field unavailable.
13132 // FIXME: that's really not sufficient; we need to make the type
13133 // itself invalid to, say, initialize or copy.
13134 QualType T = FD->getType();
13135 Qualifiers::ObjCLifetime lifetime = T.getObjCLifetime();
13136 if (lifetime && lifetime != Qualifiers::OCL_ExplicitNone) {
13137 SourceLocation loc = FD->getLocation();
13138 if (getSourceManager().isInSystemHeader(loc)) {
13139 if (!FD->hasAttr<UnavailableAttr>()) {
Aaron Ballman36a53502014-01-16 13:03:14 +000013140 FD->addAttr(UnavailableAttr::CreateImplicit(Context,
13141 "this system field has retaining ownership",
13142 loc));
John McCall31168b02011-06-15 23:02:42 +000013143 }
Douglas Gregore6c3fa02013-01-28 19:08:09 +000013144 } else {
13145 Diag(FD->getLocation(), diag::err_arc_objc_object_in_tag)
Douglas Gregor0ad84b42013-01-28 20:13:44 +000013146 << T->isBlockPointerType() << Record->getTagKind();
John McCall31168b02011-06-15 23:02:42 +000013147 }
Douglas Gregore6c3fa02013-01-28 19:08:09 +000013148 ARCErrReported = true;
John McCall31168b02011-06-15 23:02:42 +000013149 }
Douglas Gregore6c3fa02013-01-28 19:08:09 +000013150 } else if (getLangOpts().ObjC1 &&
David Blaikiebbafb8a2012-03-11 07:00:24 +000013151 getLangOpts().getGC() != LangOptions::NonGC &&
John McCall31168b02011-06-15 23:02:42 +000013152 Record && !Record->hasObjectMember()) {
Douglas Gregore6c3fa02013-01-28 19:08:09 +000013153 if (FD->getType()->isObjCObjectPointerType() ||
13154 FD->getType().isObjCGCStrong())
13155 Record->setHasObjectMember(true);
13156 else if (Context.getAsArrayType(FD->getType())) {
13157 QualType BaseType = Context.getBaseElementType(FD->getType());
13158 if (BaseType->isRecordType() &&
13159 BaseType->getAs<RecordType>()->getDecl()->hasObjectMember())
John McCall31168b02011-06-15 23:02:42 +000013160 Record->setHasObjectMember(true);
Douglas Gregore6c3fa02013-01-28 19:08:09 +000013161 else if (BaseType->isObjCObjectPointerType() ||
13162 BaseType.isObjCGCStrong())
13163 Record->setHasObjectMember(true);
John McCall31168b02011-06-15 23:02:42 +000013164 }
Fariborz Jahanian021510e2010-06-15 22:44:06 +000013165 }
Fariborz Jahanian78652202013-01-25 23:57:05 +000013166 if (Record && FD->getType().isVolatileQualified())
13167 Record->setHasVolatileMember(true);
Chris Lattner82625602007-01-24 02:26:21 +000013168 // Keep track of the number of named members.
Douglas Gregor82ac25e2009-01-08 20:45:30 +000013169 if (FD->getIdentifier())
Chris Lattner82625602007-01-24 02:26:21 +000013170 ++NumNamedMembers;
Chris Lattnerbdf8b8d2007-01-24 02:11:17 +000013171 }
Sebastian Redlbaad4e72009-01-05 20:52:13 +000013172
Chris Lattner82625602007-01-24 02:26:21 +000013173 // Okay, we successfully defined 'Record'.
Chris Lattner622c1932008-02-06 00:51:33 +000013174 if (Record) {
Douglas Gregor8fb95122010-09-29 00:15:42 +000013175 bool Completed = false;
13176 if (CXXRecordDecl *CXXRecord = dyn_cast<CXXRecordDecl>(Record)) {
13177 if (!CXXRecord->isInvalidDecl()) {
13178 // Set access bits correctly on the directly-declared conversions.
Argyrios Kyrtzidisa6567c42012-11-28 03:56:09 +000013179 for (CXXRecordDecl::conversion_iterator
13180 I = CXXRecord->conversion_begin(),
13181 E = CXXRecord->conversion_end(); I != E; ++I)
13182 I.setAccess((*I)->getAccess());
Douglas Gregor8fb95122010-09-29 00:15:42 +000013183
13184 if (!CXXRecord->isDependentType()) {
Peter Collingbourneb289fe62013-05-20 14:12:25 +000013185 if (CXXRecord->hasUserDeclaredDestructor()) {
13186 // Adjust user-defined destructor exception spec.
13187 if (getLangOpts().CPlusPlus11)
13188 AdjustDestructorExceptionSpec(CXXRecord,
13189 CXXRecord->getDestructor());
Peter Collingbourneb289fe62013-05-20 14:12:25 +000013190 }
Sebastian Redl623ea822011-05-19 05:13:44 +000013191
Douglas Gregor8fb95122010-09-29 00:15:42 +000013192 // Add any implicitly-declared members to this class.
13193 AddImplicitlyDeclaredMembersToClass(CXXRecord);
13194
13195 // If we have virtual base classes, we may end up finding multiple
13196 // final overriders for a given virtual function. Check for this
13197 // problem now.
13198 if (CXXRecord->getNumVBases()) {
13199 CXXFinalOverriderMap FinalOverriders;
13200 CXXRecord->getFinalOverriders(FinalOverriders);
13201
13202 for (CXXFinalOverriderMap::iterator M = FinalOverriders.begin(),
13203 MEnd = FinalOverriders.end();
13204 M != MEnd; ++M) {
13205 for (OverridingMethods::iterator SO = M->second.begin(),
13206 SOEnd = M->second.end();
13207 SO != SOEnd; ++SO) {
13208 assert(SO->second.size() > 0 &&
13209 "Virtual function without overridding functions?");
13210 if (SO->second.size() == 1)
13211 continue;
13212
13213 // C++ [class.virtual]p2:
13214 // In a derived class, if a virtual member function of a base
13215 // class subobject has more than one final overrider the
13216 // program is ill-formed.
13217 Diag(Record->getLocation(), diag::err_multiple_final_overriders)
Roman Divackye6377112012-09-06 15:59:27 +000013218 << (const NamedDecl *)M->first << Record;
Douglas Gregor8fb95122010-09-29 00:15:42 +000013219 Diag(M->first->getLocation(),
13220 diag::note_overridden_virtual_function);
13221 for (OverridingMethods::overriding_iterator
13222 OM = SO->second.begin(),
13223 OMEnd = SO->second.end();
13224 OM != OMEnd; ++OM)
13225 Diag(OM->Method->getLocation(), diag::note_final_overrider)
Roman Divackye6377112012-09-06 15:59:27 +000013226 << (const NamedDecl *)M->first << OM->Method->getParent();
Douglas Gregor8fb95122010-09-29 00:15:42 +000013227
13228 Record->setInvalidDecl();
13229 }
13230 }
13231 CXXRecord->completeDefinition(&FinalOverriders);
13232 Completed = true;
13233 }
13234 }
13235 }
13236 }
13237
13238 if (!Completed)
13239 Record->completeDefinition();
Sebastian Redl623ea822011-05-19 05:13:44 +000013240
David Majnemer2c4e00a2014-01-29 22:07:36 +000013241 if (Record->hasAttrs()) {
Richard Smith848e1f12013-02-01 08:12:08 +000013242 CheckAlignasUnderalignment(Record);
Serge Pavlov89578fd2013-06-08 13:29:58 +000013243
David Majnemer98c9ee22014-02-07 00:43:07 +000013244 if (const MSInheritanceAttr *IA = Record->getAttr<MSInheritanceAttr>())
David Majnemer2c4e00a2014-01-29 22:07:36 +000013245 checkMSInheritanceAttrOnDefinition(cast<CXXRecordDecl>(Record),
David Majnemer4bb09802014-02-10 19:50:15 +000013246 IA->getRange(), IA->getBestCase(),
David Majnemer2c4e00a2014-01-29 22:07:36 +000013247 IA->getSemanticSpelling());
13248 }
13249
Serge Pavlov3cb80222013-11-14 02:13:03 +000013250 // Check if the structure/union declaration is a type that can have zero
13251 // size in C. For C this is a language extension, for C++ it may cause
13252 // compatibility problems.
13253 bool CheckForZeroSize;
Serge Pavlov89578fd2013-06-08 13:29:58 +000013254 if (!getLangOpts().CPlusPlus) {
Serge Pavlov3cb80222013-11-14 02:13:03 +000013255 CheckForZeroSize = true;
13256 } else {
13257 // For C++ filter out types that cannot be referenced in C code.
13258 CXXRecordDecl *CXXRecord = cast<CXXRecordDecl>(Record);
13259 CheckForZeroSize =
13260 CXXRecord->getLexicalDeclContext()->isExternCContext() &&
13261 !CXXRecord->isDependentType() &&
13262 CXXRecord->isCLike();
13263 }
13264 if (CheckForZeroSize) {
Serge Pavlov89578fd2013-06-08 13:29:58 +000013265 bool ZeroSize = true;
Serge Pavlovf7c1a212013-06-17 17:18:51 +000013266 bool IsEmpty = true;
13267 unsigned NonBitFields = 0;
Serge Pavlov89578fd2013-06-08 13:29:58 +000013268 for (RecordDecl::field_iterator I = Record->field_begin(),
Serge Pavlovf7c1a212013-06-17 17:18:51 +000013269 E = Record->field_end();
13270 (NonBitFields == 0 || ZeroSize) && I != E; ++I) {
13271 IsEmpty = false;
Serge Pavlov89578fd2013-06-08 13:29:58 +000013272 if (I->isUnnamedBitfield()) {
Serge Pavlov89578fd2013-06-08 13:29:58 +000013273 if (I->getBitWidthValue(Context) > 0)
13274 ZeroSize = false;
13275 } else {
Serge Pavlovf7c1a212013-06-17 17:18:51 +000013276 ++NonBitFields;
13277 QualType FieldType = I->getType();
13278 if (FieldType->isIncompleteType() ||
13279 !Context.getTypeSizeInChars(FieldType).isZero())
13280 ZeroSize = false;
Serge Pavlov89578fd2013-06-08 13:29:58 +000013281 }
13282 }
13283
Serge Pavlov3cb80222013-11-14 02:13:03 +000013284 // Empty structs are an extension in C (C99 6.7.2.1p7). They are
13285 // allowed in C++, but warn if its declaration is inside
13286 // extern "C" block.
13287 if (ZeroSize) {
13288 Diag(RecLoc, getLangOpts().CPlusPlus ?
13289 diag::warn_zero_size_struct_union_in_extern_c :
13290 diag::warn_zero_size_struct_union_compat)
13291 << IsEmpty << Record->isUnion() << (NonBitFields > 1);
13292 }
Serge Pavlov89578fd2013-06-08 13:29:58 +000013293
Serge Pavlov3cb80222013-11-14 02:13:03 +000013294 // Structs without named members are extension in C (C99 6.7.2.1p7),
13295 // but are accepted by GCC.
13296 if (NonBitFields == 0 && !getLangOpts().CPlusPlus) {
13297 Diag(RecLoc, IsEmpty ? diag::ext_empty_struct_union :
13298 diag::ext_no_named_members_in_struct_union)
13299 << Record->isUnion();
Serge Pavlov89578fd2013-06-08 13:29:58 +000013300 }
13301 }
Chris Lattner622c1932008-02-06 00:51:33 +000013302 } else {
Jay Foad7d0479f2009-05-21 09:52:38 +000013303 ObjCIvarDecl **ClsFields =
13304 reinterpret_cast<ObjCIvarDecl**>(RecFields.data());
Fariborz Jahanian02225532008-12-13 20:28:25 +000013305 if (ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(EnclosingDecl)) {
Douglas Gregor16408322011-12-15 22:34:59 +000013306 ID->setEndOfDefinitionLoc(RBrac);
Fariborz Jahanian68453832009-06-05 18:16:35 +000013307 // Add ivar's to class's DeclContext.
13308 for (unsigned i = 0, e = RecFields.size(); i != e; ++i) {
13309 ClsFields[i]->setLexicalDeclContext(ID);
Argyrios Kyrtzidiscfbfe782009-06-30 02:36:12 +000013310 ID->addDecl(ClsFields[i]);
Fariborz Jahanian68453832009-06-05 18:16:35 +000013311 }
Fariborz Jahaniana599c132008-12-16 01:08:35 +000013312 // Must enforce the rule that ivars in the base classes may not be
13313 // duplicates.
Fariborz Jahanian545643c2010-02-23 23:41:11 +000013314 if (ID->getSuperClass())
13315 DiagnoseDuplicateIvars(ID, ID->getSuperClass());
Mike Stump11289f42009-09-09 15:08:12 +000013316 } else if (ObjCImplementationDecl *IMPDecl =
Chris Lattnerd13b8b52009-02-23 22:00:08 +000013317 dyn_cast<ObjCImplementationDecl>(EnclosingDecl)) {
Ted Kremenek1b0ea822008-01-07 19:49:32 +000013318 assert(IMPDecl && "ActOnFields - missing ObjCImplementationDecl");
Fariborz Jahanian68453832009-06-05 18:16:35 +000013319 for (unsigned I = 0, N = RecFields.size(); I != N; ++I)
13320 // Ivar declared in @implementation never belongs to the implementation.
13321 // Only it is in implementation's lexical context.
Douglas Gregor5f662052009-04-23 03:23:08 +000013322 ClsFields[I]->setLexicalDeclContext(IMPDecl);
Fariborz Jahanian95b60762007-10-31 18:48:14 +000013323 CheckImplementationIvars(IMPDecl, ClsFields, RecFields.size(), RBrac);
Fariborz Jahaniana7765fe2012-02-20 20:09:20 +000013324 IMPDecl->setIvarLBraceLoc(LBrac);
13325 IMPDecl->setIvarRBraceLoc(RBrac);
Fariborz Jahanian4c172c62010-02-22 23:04:20 +000013326 } else if (ObjCCategoryDecl *CDecl =
13327 dyn_cast<ObjCCategoryDecl>(EnclosingDecl)) {
Fariborz Jahanian6a0a2e02010-04-06 22:43:48 +000013328 // case of ivars in class extension; all other cases have been
13329 // reported as errors elsewhere.
13330 // FIXME. Class extension does not have a LocEnd field.
13331 // CDecl->setLocEnd(RBrac);
13332 // Add ivar's to class extension's DeclContext.
Fariborz Jahanian25127472011-10-21 18:03:52 +000013333 // Diagnose redeclaration of private ivars.
13334 ObjCInterfaceDecl *IDecl = CDecl->getClassInterface();
Fariborz Jahanian6a0a2e02010-04-06 22:43:48 +000013335 for (unsigned i = 0, e = RecFields.size(); i != e; ++i) {
Fariborz Jahanian25127472011-10-21 18:03:52 +000013336 if (IDecl) {
13337 if (const ObjCIvarDecl *ClsIvar =
13338 IDecl->getIvarDecl(ClsFields[i]->getIdentifier())) {
13339 Diag(ClsFields[i]->getLocation(),
13340 diag::err_duplicate_ivar_declaration);
13341 Diag(ClsIvar->getLocation(), diag::note_previous_definition);
13342 continue;
13343 }
Aaron Ballmanb4a53452014-03-13 21:57:01 +000013344 for (const auto *Ext : IDecl->known_extensions()) {
Douglas Gregor048fbfa2013-01-16 23:00:23 +000013345 if (const ObjCIvarDecl *ClsExtIvar
13346 = Ext->getIvarDecl(ClsFields[i]->getIdentifier())) {
Fariborz Jahanian25127472011-10-21 18:03:52 +000013347 Diag(ClsFields[i]->getLocation(),
13348 diag::err_duplicate_ivar_declaration);
13349 Diag(ClsExtIvar->getLocation(), diag::note_previous_definition);
13350 continue;
13351 }
13352 }
13353 }
Fariborz Jahanian6a0a2e02010-04-06 22:43:48 +000013354 ClsFields[i]->setLexicalDeclContext(CDecl);
13355 CDecl->addDecl(ClsFields[i]);
Fariborz Jahanian4c172c62010-02-22 23:04:20 +000013356 }
Fariborz Jahaniana7765fe2012-02-20 20:09:20 +000013357 CDecl->setIvarLBraceLoc(LBrac);
13358 CDecl->setIvarRBraceLoc(RBrac);
Fariborz Jahanian2a4dd312007-09-26 18:27:25 +000013359 }
Fariborz Jahanianf3287bf2007-09-14 21:08:27 +000013360 }
Daniel Dunbar325601a2008-10-03 17:33:35 +000013361
13362 if (Attr)
Douglas Gregor758a8692009-06-17 21:51:59 +000013363 ProcessDeclAttributeList(S, Record, Attr);
Chris Lattner1300fb92007-01-23 23:42:53 +000013364}
13365
Douglas Gregor6791a0d2010-02-01 23:36:03 +000013366/// \brief Determine whether the given integral value is representable within
13367/// the given type T.
13368static bool isRepresentableIntegerValue(ASTContext &Context,
13369 llvm::APSInt &Value,
13370 QualType T) {
Douglas Gregor6972a622010-06-16 00:35:25 +000013371 assert(T->isIntegralType(Context) && "Integral type required!");
Douglas Gregorc1cf8142010-04-15 15:53:31 +000013372 unsigned BitWidth = Context.getIntWidth(T);
Douglas Gregor6791a0d2010-02-01 23:36:03 +000013373
Douglas Gregor0bf31402010-10-08 23:50:27 +000013374 if (Value.isUnsigned() || Value.isNonNegative()) {
Douglas Gregor6ab2fa82011-05-20 16:38:50 +000013375 if (T->isSignedIntegerOrEnumerationType())
Douglas Gregor0bf31402010-10-08 23:50:27 +000013376 --BitWidth;
13377 return Value.getActiveBits() <= BitWidth;
13378 }
Douglas Gregor6791a0d2010-02-01 23:36:03 +000013379 return Value.getMinSignedBits() <= BitWidth;
13380}
13381
13382// \brief Given an integral type, return the next larger integral type
13383// (or a NULL type of no such type exists).
13384static QualType getNextLargerIntegralType(ASTContext &Context, QualType T) {
13385 // FIXME: Int128/UInt128 support, which also needs to be introduced into
13386 // enum checking below.
Douglas Gregor6972a622010-06-16 00:35:25 +000013387 assert(T->isIntegralType(Context) && "Integral type required!");
Douglas Gregor6791a0d2010-02-01 23:36:03 +000013388 const unsigned NumTypes = 4;
13389 QualType SignedIntegralTypes[NumTypes] = {
13390 Context.ShortTy, Context.IntTy, Context.LongTy, Context.LongLongTy
13391 };
13392 QualType UnsignedIntegralTypes[NumTypes] = {
13393 Context.UnsignedShortTy, Context.UnsignedIntTy, Context.UnsignedLongTy,
13394 Context.UnsignedLongLongTy
13395 };
13396
13397 unsigned BitWidth = Context.getTypeSize(T);
Douglas Gregor6ab2fa82011-05-20 16:38:50 +000013398 QualType *Types = T->isSignedIntegerOrEnumerationType()? SignedIntegralTypes
13399 : UnsignedIntegralTypes;
Douglas Gregor6791a0d2010-02-01 23:36:03 +000013400 for (unsigned I = 0; I != NumTypes; ++I)
13401 if (Context.getTypeSize(Types[I]) > BitWidth)
13402 return Types[I];
13403
13404 return QualType();
13405}
13406
Douglas Gregor954f6b272009-03-17 19:05:46 +000013407EnumConstantDecl *Sema::CheckEnumConstant(EnumDecl *Enum,
13408 EnumConstantDecl *LastEnumConst,
13409 SourceLocation IdLoc,
13410 IdentifierInfo *Id,
John McCallb268a282010-08-23 23:25:46 +000013411 Expr *Val) {
Douglas Gregore8bbc122011-09-02 00:18:52 +000013412 unsigned IntWidth = Context.getTargetInfo().getIntWidth();
Douglas Gregor6791a0d2010-02-01 23:36:03 +000013413 llvm::APSInt EnumVal(IntWidth);
Douglas Gregor954f6b272009-03-17 19:05:46 +000013414 QualType EltTy;
Douglas Gregor2b988fd2010-12-16 00:24:44 +000013415
13416 if (Val && DiagnoseUnexpandedParameterPack(Val, UPPC_EnumeratorValue))
Craig Topperc3ec1492014-05-26 06:22:03 +000013417 Val = nullptr;
Douglas Gregor2b988fd2010-12-16 00:24:44 +000013418
Eli Friedman7c6515a2011-12-06 00:10:34 +000013419 if (Val)
Nikola Smiljanic01a75982014-05-29 10:55:11 +000013420 Val = DefaultLvalueConversion(Val).get();
Eli Friedman7c6515a2011-12-06 00:10:34 +000013421
Douglas Gregorb2186fe2009-11-06 00:03:12 +000013422 if (Val) {
Douglas Gregordc70c3a2010-03-02 17:53:14 +000013423 if (Enum->isDependentType() || Val->isTypeDependent())
Douglas Gregorb2186fe2009-11-06 00:03:12 +000013424 EltTy = Context.DependentTy;
13425 else {
Douglas Gregorb2186fe2009-11-06 00:03:12 +000013426 SourceLocation ExpLoc;
Richard Smith2bf7fdb2013-01-02 11:42:31 +000013427 if (getLangOpts().CPlusPlus11 && Enum->isFixed() &&
Alp Tokerbfa39342014-01-14 12:51:41 +000013428 !getLangOpts().MSVCCompat) {
Richard Smithf8379a02012-01-18 23:55:52 +000013429 // C++11 [dcl.enum]p5: If the underlying type is fixed, [...] the
13430 // constant-expression in the enumerator-definition shall be a converted
13431 // constant expression of the underlying type.
13432 EltTy = Enum->getIntegerType();
13433 ExprResult Converted =
13434 CheckConvertedConstantExpression(Val, EltTy, EnumVal,
13435 CCEK_Enumerator);
13436 if (Converted.isInvalid())
Craig Topperc3ec1492014-05-26 06:22:03 +000013437 Val = nullptr;
Richard Smithf8379a02012-01-18 23:55:52 +000013438 else
Nikola Smiljanic01a75982014-05-29 10:55:11 +000013439 Val = Converted.get();
Richard Smithf8379a02012-01-18 23:55:52 +000013440 } else if (!Val->isValueDependent() &&
Richard Smithf4c51d92012-02-04 09:53:13 +000013441 !(Val = VerifyIntegerConstantExpression(Val,
Nikola Smiljanic01a75982014-05-29 10:55:11 +000013442 &EnumVal).get())) {
Richard Smithf8379a02012-01-18 23:55:52 +000013443 // C99 6.7.2.2p2: Make sure we have an integer constant expression.
Richard Smithf8379a02012-01-18 23:55:52 +000013444 } else {
Douglas Gregor0bf31402010-10-08 23:50:27 +000013445 if (Enum->isFixed()) {
13446 EltTy = Enum->getIntegerType();
13447
Richard Smithf8379a02012-01-18 23:55:52 +000013448 // In Obj-C and Microsoft mode, require the enumeration value to be
13449 // representable in the underlying type of the enumeration. In C++11,
13450 // we perform a non-narrowing conversion as part of converted constant
13451 // expression checking.
Francois Picheta3108062010-10-18 15:01:13 +000013452 if (!isRepresentableIntegerValue(Context, EnumVal, EltTy)) {
Alp Tokerbfa39342014-01-14 12:51:41 +000013453 if (getLangOpts().MSVCCompat) {
Francois Picheta3108062010-10-18 15:01:13 +000013454 Diag(IdLoc, diag::ext_enumerator_too_large) << EltTy;
Nikola Smiljanic01a75982014-05-29 10:55:11 +000013455 Val = ImpCastExprToType(Val, EltTy, CK_IntegralCast).get();
Richard Smithf8379a02012-01-18 23:55:52 +000013456 } else
13457 Diag(IdLoc, diag::err_enumerator_too_large) << EltTy;
Francois Picheta3108062010-10-18 15:01:13 +000013458 } else
Nikola Smiljanic01a75982014-05-29 10:55:11 +000013459 Val = ImpCastExprToType(Val, EltTy, CK_IntegralCast).get();
David Blaikiebbafb8a2012-03-11 07:00:24 +000013460 } else if (getLangOpts().CPlusPlus) {
Richard Smithf8379a02012-01-18 23:55:52 +000013461 // C++11 [dcl.enum]p5:
Douglas Gregor0bf31402010-10-08 23:50:27 +000013462 // If the underlying type is not fixed, the type of each enumerator
13463 // is the type of its initializing value:
13464 // - If an initializer is specified for an enumerator, the
13465 // initializing value has the same type as the expression.
13466 EltTy = Val->getType();
Eli Friedman2beed112012-02-07 04:34:38 +000013467 } else {
13468 // C99 6.7.2.2p2:
13469 // The expression that defines the value of an enumeration constant
13470 // shall be an integer constant expression that has a value
13471 // representable as an int.
13472
13473 // Complain if the value is not representable in an int.
13474 if (!isRepresentableIntegerValue(Context, EnumVal, Context.IntTy))
13475 Diag(IdLoc, diag::ext_enum_value_not_int)
13476 << EnumVal.toString(10) << Val->getSourceRange()
13477 << (EnumVal.isUnsigned() || EnumVal.isNonNegative());
13478 else if (!Context.hasSameType(Val->getType(), Context.IntTy)) {
13479 // Force the type of the expression to 'int'.
Nikola Smiljanic01a75982014-05-29 10:55:11 +000013480 Val = ImpCastExprToType(Val, Context.IntTy, CK_IntegralCast).get();
Eli Friedman2beed112012-02-07 04:34:38 +000013481 }
13482 EltTy = Val->getType();
Douglas Gregor0bf31402010-10-08 23:50:27 +000013483 }
Douglas Gregorb2186fe2009-11-06 00:03:12 +000013484 }
Douglas Gregor954f6b272009-03-17 19:05:46 +000013485 }
13486 }
Mike Stump11289f42009-09-09 15:08:12 +000013487
Douglas Gregor954f6b272009-03-17 19:05:46 +000013488 if (!Val) {
Eli Friedmand0e60972009-12-11 01:34:50 +000013489 if (Enum->isDependentType())
13490 EltTy = Context.DependentTy;
Douglas Gregor6791a0d2010-02-01 23:36:03 +000013491 else if (!LastEnumConst) {
13492 // C++0x [dcl.enum]p5:
13493 // If the underlying type is not fixed, the type of each enumerator
13494 // is the type of its initializing value:
13495 // - If no initializer is specified for the first enumerator, the
13496 // initializing value has an unspecified integral type.
13497 //
13498 // GCC uses 'int' for its unspecified integral type, as does
13499 // C99 6.7.2.2p3.
Douglas Gregor0bf31402010-10-08 23:50:27 +000013500 if (Enum->isFixed()) {
13501 EltTy = Enum->getIntegerType();
13502 }
13503 else {
13504 EltTy = Context.IntTy;
13505 }
Douglas Gregor6791a0d2010-02-01 23:36:03 +000013506 } else {
Douglas Gregor954f6b272009-03-17 19:05:46 +000013507 // Assign the last value + 1.
13508 EnumVal = LastEnumConst->getInitVal();
13509 ++EnumVal;
Douglas Gregor6791a0d2010-02-01 23:36:03 +000013510 EltTy = LastEnumConst->getType();
Douglas Gregor954f6b272009-03-17 19:05:46 +000013511
13512 // Check for overflow on increment.
Douglas Gregor6791a0d2010-02-01 23:36:03 +000013513 if (EnumVal < LastEnumConst->getInitVal()) {
13514 // C++0x [dcl.enum]p5:
13515 // If the underlying type is not fixed, the type of each enumerator
13516 // is the type of its initializing value:
13517 //
13518 // - Otherwise the type of the initializing value is the same as
13519 // the type of the initializing value of the preceding enumerator
13520 // unless the incremented value is not representable in that type,
13521 // in which case the type is an unspecified integral type
13522 // sufficient to contain the incremented value. If no such type
13523 // exists, the program is ill-formed.
13524 QualType T = getNextLargerIntegralType(Context, EltTy);
Douglas Gregor0bf31402010-10-08 23:50:27 +000013525 if (T.isNull() || Enum->isFixed()) {
Douglas Gregor6791a0d2010-02-01 23:36:03 +000013526 // There is no integral type larger enough to represent this
13527 // value. Complain, then allow the value to wrap around.
13528 EnumVal = LastEnumConst->getInitVal();
Jay Foad6d4db0c2010-12-07 08:25:34 +000013529 EnumVal = EnumVal.zext(EnumVal.getBitWidth() * 2);
Douglas Gregor0bf31402010-10-08 23:50:27 +000013530 ++EnumVal;
13531 if (Enum->isFixed())
13532 // When the underlying type is fixed, this is ill-formed.
13533 Diag(IdLoc, diag::err_enumerator_wrapped)
13534 << EnumVal.toString(10)
13535 << EltTy;
13536 else
Richard Smithfaf156a2014-03-05 22:54:58 +000013537 Diag(IdLoc, diag::ext_enumerator_increment_too_large)
Douglas Gregor0bf31402010-10-08 23:50:27 +000013538 << EnumVal.toString(10);
Douglas Gregor6791a0d2010-02-01 23:36:03 +000013539 } else {
13540 EltTy = T;
13541 }
13542
13543 // Retrieve the last enumerator's value, extent that type to the
13544 // type that is supposed to be large enough to represent the incremented
13545 // value, then increment.
13546 EnumVal = LastEnumConst->getInitVal();
Douglas Gregor6ab2fa82011-05-20 16:38:50 +000013547 EnumVal.setIsSigned(EltTy->isSignedIntegerOrEnumerationType());
Jay Foad6d4db0c2010-12-07 08:25:34 +000013548 EnumVal = EnumVal.zextOrTrunc(Context.getIntWidth(EltTy));
Douglas Gregor6791a0d2010-02-01 23:36:03 +000013549 ++EnumVal;
13550
13551 // If we're not in C++, diagnose the overflow of enumerator values,
13552 // which in C99 means that the enumerator value is not representable in
13553 // an int (C99 6.7.2.2p2). However, we support GCC's extension that
13554 // permits enumerator values that are representable in some larger
13555 // integral type.
David Blaikiebbafb8a2012-03-11 07:00:24 +000013556 if (!getLangOpts().CPlusPlus && !T.isNull())
Douglas Gregor6791a0d2010-02-01 23:36:03 +000013557 Diag(IdLoc, diag::warn_enum_value_overflow);
David Blaikiebbafb8a2012-03-11 07:00:24 +000013558 } else if (!getLangOpts().CPlusPlus &&
Douglas Gregor6791a0d2010-02-01 23:36:03 +000013559 !isRepresentableIntegerValue(Context, EnumVal, EltTy)) {
13560 // Enforce C99 6.7.2.2p2 even when we compute the next value.
13561 Diag(IdLoc, diag::ext_enum_value_not_int)
13562 << EnumVal.toString(10) << 1;
13563 }
Douglas Gregor954f6b272009-03-17 19:05:46 +000013564 }
13565 }
Mike Stump11289f42009-09-09 15:08:12 +000013566
Douglas Gregordc70c3a2010-03-02 17:53:14 +000013567 if (!EltTy->isDependentType()) {
Douglas Gregor6791a0d2010-02-01 23:36:03 +000013568 // Make the enumerator value match the signedness and size of the
13569 // enumerator's type.
Eli Friedman2beed112012-02-07 04:34:38 +000013570 EnumVal = EnumVal.extOrTrunc(Context.getIntWidth(EltTy));
Douglas Gregor6ab2fa82011-05-20 16:38:50 +000013571 EnumVal.setIsSigned(EltTy->isSignedIntegerOrEnumerationType());
Douglas Gregor6791a0d2010-02-01 23:36:03 +000013572 }
Douglas Gregorb2186fe2009-11-06 00:03:12 +000013573
Douglas Gregor954f6b272009-03-17 19:05:46 +000013574 return EnumConstantDecl::Create(Context, Enum, IdLoc, Id, EltTy,
Mike Stump11289f42009-09-09 15:08:12 +000013575 Val, EnumVal);
Douglas Gregor954f6b272009-03-17 19:05:46 +000013576}
13577
Richard Smithd9ba2242015-05-07 03:54:19 +000013578Sema::SkipBodyInfo Sema::shouldSkipAnonEnumBody(Scope *S, IdentifierInfo *II,
13579 SourceLocation IILoc) {
Richard Smith00be6d02015-06-11 03:05:39 +000013580 if (!(getLangOpts().Modules || getLangOpts().ModulesLocalVisibility) ||
13581 !getLangOpts().CPlusPlus)
Richard Smithd9ba2242015-05-07 03:54:19 +000013582 return SkipBodyInfo();
13583
13584 // We have an anonymous enum definition. Look up the first enumerator to
13585 // determine if we should merge the definition with an existing one and
13586 // skip the body.
13587 NamedDecl *PrevDecl = LookupSingleName(S, II, IILoc, LookupOrdinaryName,
13588 ForRedeclaration);
13589 auto *PrevECD = dyn_cast_or_null<EnumConstantDecl>(PrevDecl);
13590 NamedDecl *Hidden;
13591 if (PrevECD &&
13592 !hasVisibleDefinition(cast<NamedDecl>(PrevECD->getDeclContext()),
13593 &Hidden)) {
13594 SkipBodyInfo Skip;
Richard Smithd9ba2242015-05-07 03:54:19 +000013595 Skip.Previous = Hidden;
13596 return Skip;
13597 }
13598
13599 return SkipBodyInfo();
13600}
Douglas Gregor954f6b272009-03-17 19:05:46 +000013601
John McCall811a0f52010-10-22 23:36:17 +000013602Decl *Sema::ActOnEnumConstant(Scope *S, Decl *theEnumDecl, Decl *lastEnumConst,
13603 SourceLocation IdLoc, IdentifierInfo *Id,
13604 AttributeList *Attr,
Richard Smithf8379a02012-01-18 23:55:52 +000013605 SourceLocation EqualLoc, Expr *Val) {
John McCall48871652010-08-21 09:40:31 +000013606 EnumDecl *TheEnumDecl = cast<EnumDecl>(theEnumDecl);
Chris Lattner4ef40012007-06-11 01:28:17 +000013607 EnumConstantDecl *LastEnumConst =
John McCall48871652010-08-21 09:40:31 +000013608 cast_or_null<EnumConstantDecl>(lastEnumConst);
Chris Lattner8116d1b2007-01-25 22:38:29 +000013609
Chris Lattner1a76a3c2007-08-26 06:24:45 +000013610 // The scope passed in may not be a decl scope. Zip up the scope tree until
13611 // we find one that is.
Douglas Gregor45a33ec2009-01-12 18:45:55 +000013612 S = getNonFieldDeclScope(S);
Mike Stump11289f42009-09-09 15:08:12 +000013613
Chris Lattner8116d1b2007-01-25 22:38:29 +000013614 // Verify that there isn't already something declared with this name in this
13615 // scope.
Douglas Gregorb2ccf012010-04-15 22:33:43 +000013616 NamedDecl *PrevDecl = LookupSingleName(S, Id, IdLoc, LookupOrdinaryName,
Douglas Gregor5204248f2010-01-19 06:06:57 +000013617 ForRedeclaration);
Douglas Gregor5daeee22008-12-08 18:40:42 +000013618 if (PrevDecl && PrevDecl->isTemplateParameter()) {
Douglas Gregor5101c242008-12-05 18:15:24 +000013619 // Maybe we will complain about the shadowed template parameter.
13620 DiagnoseTemplateParameterShadow(IdLoc, PrevDecl);
13621 // Just pretend that we didn't see the previous declaration.
Craig Topperc3ec1492014-05-26 06:22:03 +000013622 PrevDecl = nullptr;
Douglas Gregor5101c242008-12-05 18:15:24 +000013623 }
13624
13625 if (PrevDecl) {
Argyrios Kyrtzidisbd259982008-07-16 21:01:53 +000013626 // When in C++, we may get a TagDecl with the same name; in this case the
13627 // enum constant will 'hide' the tag.
David Blaikiebbafb8a2012-03-11 07:00:24 +000013628 assert((getLangOpts().CPlusPlus || !isa<TagDecl>(PrevDecl)) &&
Argyrios Kyrtzidisbd259982008-07-16 21:01:53 +000013629 "Received TagDecl when not in C++!");
Argyrios Kyrtzidis5b144d52008-09-09 21:18:04 +000013630 if (!isa<TagDecl>(PrevDecl) && isDeclInScope(PrevDecl, CurContext, S)) {
Chris Lattner8116d1b2007-01-25 22:38:29 +000013631 if (isa<EnumConstantDecl>(PrevDecl))
Chris Lattner4bd8dd82008-11-19 08:23:25 +000013632 Diag(IdLoc, diag::err_redefinition_of_enumerator) << Id;
Chris Lattner8116d1b2007-01-25 22:38:29 +000013633 else
Chris Lattner4bd8dd82008-11-19 08:23:25 +000013634 Diag(IdLoc, diag::err_redefinition) << Id;
Chris Lattner0369c572008-11-23 23:12:31 +000013635 Diag(PrevDecl->getLocation(), diag::note_previous_definition);
Craig Topperc3ec1492014-05-26 06:22:03 +000013636 return nullptr;
Chris Lattner8116d1b2007-01-25 22:38:29 +000013637 }
13638 }
Chris Lattner4ef40012007-06-11 01:28:17 +000013639
Aaron Ballman24a10472012-07-19 03:12:23 +000013640 // C++ [class.mem]p15:
13641 // If T is the name of a class, then each of the following shall have a name
13642 // different from T:
13643 // - every enumerator of every member of class T that is an unscoped
13644 // enumerated type
Douglas Gregor36c22a22010-10-15 13:21:21 +000013645 if (CXXRecordDecl *Record
13646 = dyn_cast<CXXRecordDecl>(
13647 TheEnumDecl->getDeclContext()->getRedeclContext()))
Aaron Ballman24a10472012-07-19 03:12:23 +000013648 if (!TheEnumDecl->isScoped() &&
13649 Record->getIdentifier() && Record->getIdentifier() == Id)
Douglas Gregor36c22a22010-10-15 13:21:21 +000013650 Diag(IdLoc, diag::err_member_name_of_class) << Id;
13651
John McCall811a0f52010-10-22 23:36:17 +000013652 EnumConstantDecl *New =
13653 CheckEnumConstant(TheEnumDecl, LastEnumConst, IdLoc, Id, Val);
Chris Lattner0515e4b2007-08-27 21:16:18 +000013654
John McCall553c0792010-01-23 00:46:32 +000013655 if (New) {
John McCall811a0f52010-10-22 23:36:17 +000013656 // Process attributes.
13657 if (Attr) ProcessDeclAttributeList(S, New, Attr);
13658
13659 // Register this decl in the current scope stack.
John McCall553c0792010-01-23 00:46:32 +000013660 New->setAccess(TheEnumDecl->getAccess());
Douglas Gregor954f6b272009-03-17 19:05:46 +000013661 PushOnScopeChains(New, S);
John McCall553c0792010-01-23 00:46:32 +000013662 }
Douglas Gregor2f521192008-12-17 02:04:30 +000013663
Dmitri Gribenkof26054f2012-07-11 21:38:39 +000013664 ActOnDocumentableDecl(New);
13665
John McCall48871652010-08-21 09:40:31 +000013666 return New;
Chris Lattnerc1915e22007-01-25 07:29:02 +000013667}
13668
Ted Kremenek6cae9ec2012-12-22 01:34:09 +000013669// Returns true when the enum initial expression does not trigger the
13670// duplicate enum warning. A few common cases are exempted as follows:
13671// Element2 = Element1
13672// Element2 = Element1 + 1
13673// Element2 = Element1 - 1
13674// Where Element2 and Element1 are from the same enum.
13675static bool ValidDuplicateEnum(EnumConstantDecl *ECD, EnumDecl *Enum) {
13676 Expr *InitExpr = ECD->getInitExpr();
13677 if (!InitExpr)
13678 return true;
13679 InitExpr = InitExpr->IgnoreImpCasts();
13680
13681 if (BinaryOperator *BO = dyn_cast<BinaryOperator>(InitExpr)) {
13682 if (!BO->isAdditiveOp())
13683 return true;
13684 IntegerLiteral *IL = dyn_cast<IntegerLiteral>(BO->getRHS());
13685 if (!IL)
13686 return true;
13687 if (IL->getValue() != 1)
13688 return true;
13689
13690 InitExpr = BO->getLHS();
13691 }
13692
13693 // This checks if the elements are from the same enum.
13694 DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(InitExpr);
13695 if (!DRE)
13696 return true;
13697
13698 EnumConstantDecl *EnumConstant = dyn_cast<EnumConstantDecl>(DRE->getDecl());
13699 if (!EnumConstant)
13700 return true;
13701
13702 if (cast<EnumDecl>(TagDecl::castFromDeclContext(ECD->getDeclContext())) !=
13703 Enum)
13704 return true;
13705
13706 return false;
13707}
13708
13709struct DupKey {
13710 int64_t val;
13711 bool isTombstoneOrEmptyKey;
13712 DupKey(int64_t val, bool isTombstoneOrEmptyKey)
13713 : val(val), isTombstoneOrEmptyKey(isTombstoneOrEmptyKey) {}
13714};
13715
13716static DupKey GetDupKey(const llvm::APSInt& Val) {
13717 return DupKey(Val.isSigned() ? Val.getSExtValue() : Val.getZExtValue(),
13718 false);
13719}
13720
13721struct DenseMapInfoDupKey {
13722 static DupKey getEmptyKey() { return DupKey(0, true); }
13723 static DupKey getTombstoneKey() { return DupKey(1, true); }
13724 static unsigned getHashValue(const DupKey Key) {
13725 return (unsigned)(Key.val * 37);
13726 }
13727 static bool isEqual(const DupKey& LHS, const DupKey& RHS) {
13728 return LHS.isTombstoneOrEmptyKey == RHS.isTombstoneOrEmptyKey &&
13729 LHS.val == RHS.val;
13730 }
13731};
13732
13733// Emits a warning when an element is implicitly set a value that
13734// a previous element has already been set to.
Dmitri Gribenkoe5fde992013-04-27 20:23:52 +000013735static void CheckForDuplicateEnumValues(Sema &S, ArrayRef<Decl *> Elements,
13736 EnumDecl *Enum,
Ted Kremenek6cae9ec2012-12-22 01:34:09 +000013737 QualType EnumType) {
Alp Tokerd4a3f0e2014-06-15 23:30:39 +000013738 if (S.Diags.isIgnored(diag::warn_duplicate_enum_values, Enum->getLocation()))
Ted Kremenek6cae9ec2012-12-22 01:34:09 +000013739 return;
13740 // Avoid anonymous enums
13741 if (!Enum->getIdentifier())
13742 return;
13743
13744 // Only check for small enums.
13745 if (Enum->getNumPositiveBits() > 63 || Enum->getNumNegativeBits() > 64)
13746 return;
13747
Dmitri Gribenkof8579502013-01-12 19:30:44 +000013748 typedef SmallVector<EnumConstantDecl *, 3> ECDVector;
13749 typedef SmallVector<ECDVector *, 3> DuplicatesVector;
Ted Kremenek6cae9ec2012-12-22 01:34:09 +000013750
13751 typedef llvm::PointerUnion<EnumConstantDecl*, ECDVector*> DeclOrVector;
13752 typedef llvm::DenseMap<DupKey, DeclOrVector, DenseMapInfoDupKey>
13753 ValueToVectorMap;
13754
13755 DuplicatesVector DupVector;
13756 ValueToVectorMap EnumMap;
13757
13758 // Populate the EnumMap with all values represented by enum constants without
13759 // an initialier.
Dmitri Gribenkoe5fde992013-04-27 20:23:52 +000013760 for (unsigned i = 0, e = Elements.size(); i != e; ++i) {
Benjamin Kramer5c488ef2013-04-07 14:10:40 +000013761 EnumConstantDecl *ECD = cast_or_null<EnumConstantDecl>(Elements[i]);
Ted Kremenek6cae9ec2012-12-22 01:34:09 +000013762
13763 // Null EnumConstantDecl means a previous diagnostic has been emitted for
13764 // this constant. Skip this enum since it may be ill-formed.
13765 if (!ECD) {
13766 return;
13767 }
13768
13769 if (ECD->getInitExpr())
13770 continue;
13771
13772 DupKey Key = GetDupKey(ECD->getInitVal());
13773 DeclOrVector &Entry = EnumMap[Key];
13774
13775 // First time encountering this value.
13776 if (Entry.isNull())
13777 Entry = ECD;
13778 }
13779
13780 // Create vectors for any values that has duplicates.
Dmitri Gribenkoe5fde992013-04-27 20:23:52 +000013781 for (unsigned i = 0, e = Elements.size(); i != e; ++i) {
Ted Kremenek6cae9ec2012-12-22 01:34:09 +000013782 EnumConstantDecl *ECD = cast<EnumConstantDecl>(Elements[i]);
13783 if (!ValidDuplicateEnum(ECD, Enum))
13784 continue;
13785
13786 DupKey Key = GetDupKey(ECD->getInitVal());
13787
13788 DeclOrVector& Entry = EnumMap[Key];
13789 if (Entry.isNull())
13790 continue;
13791
13792 if (EnumConstantDecl *D = Entry.dyn_cast<EnumConstantDecl*>()) {
13793 // Ensure constants are different.
13794 if (D == ECD)
13795 continue;
13796
13797 // Create new vector and push values onto it.
13798 ECDVector *Vec = new ECDVector();
13799 Vec->push_back(D);
13800 Vec->push_back(ECD);
13801
13802 // Update entry to point to the duplicates vector.
13803 Entry = Vec;
13804
13805 // Store the vector somewhere we can consult later for quick emission of
13806 // diagnostics.
13807 DupVector.push_back(Vec);
13808 continue;
13809 }
13810
13811 ECDVector *Vec = Entry.get<ECDVector*>();
13812 // Make sure constants are not added more than once.
13813 if (*Vec->begin() == ECD)
13814 continue;
13815
13816 Vec->push_back(ECD);
13817 }
13818
13819 // Emit diagnostics.
13820 for (DuplicatesVector::iterator DupVectorIter = DupVector.begin(),
13821 DupVectorEnd = DupVector.end();
13822 DupVectorIter != DupVectorEnd; ++DupVectorIter) {
13823 ECDVector *Vec = *DupVectorIter;
13824 assert(Vec->size() > 1 && "ECDVector should have at least 2 elements.");
13825
13826 // Emit warning for one enum constant.
13827 ECDVector::iterator I = Vec->begin();
13828 S.Diag((*I)->getLocation(), diag::warn_duplicate_enum_values)
13829 << (*I)->getName() << (*I)->getInitVal().toString(10)
13830 << (*I)->getSourceRange();
13831 ++I;
13832
13833 // Emit one note for each of the remaining enum constants with
13834 // the same value.
13835 for (ECDVector::iterator E = Vec->end(); I != E; ++I)
13836 S.Diag((*I)->getLocation(), diag::note_duplicate_element)
13837 << (*I)->getName() << (*I)->getInitVal().toString(10)
13838 << (*I)->getSourceRange();
13839 delete Vec;
13840 }
13841}
13842
Alexis Hunt724f14e2014-11-28 00:53:20 +000013843bool
13844Sema::IsValueInFlagEnum(const EnumDecl *ED, const llvm::APInt &Val,
13845 bool AllowMask) const {
13846 FlagEnumAttr *FEAttr = ED->getAttr<FlagEnumAttr>();
13847 assert(FEAttr && "looking for value in non-flag enum");
13848
13849 llvm::APInt FlagMask = ~FEAttr->getFlagBits();
13850 unsigned Width = FlagMask.getBitWidth();
13851
13852 // We will try a zero-extended value for the regular check first.
13853 llvm::APInt ExtVal = Val.zextOrSelf(Width);
13854
13855 // A value is in a flag enum if either its bits are a subset of the enum's
13856 // flag bits (the first condition) or we are allowing masks and the same is
13857 // true of its complement (the second condition). When masks are allowed, we
13858 // allow the common idiom of ~(enum1 | enum2) to be a valid enum value.
13859 //
13860 // While it's true that any value could be used as a mask, the assumption is
13861 // that a mask will have all of the insignificant bits set. Anything else is
13862 // likely a logic error.
13863 if (!(FlagMask & ExtVal))
13864 return true;
13865
13866 if (AllowMask) {
13867 // Try a one-extended value instead. This can happen if the enum is wider
13868 // than the constant used, in C with extensions to allow for wider enums.
13869 // The mask will still have the correct behaviour, so we give the user the
13870 // benefit of the doubt.
13871 //
13872 // FIXME: This heuristic can cause weird results if the enum was extended
13873 // to a larger type and is signed, because then bit-masks of smaller types
13874 // that get extended will fall out of range (e.g. ~0x1u). We currently don't
13875 // detect that case and will get a false positive for it. In most cases,
13876 // though, it can be fixed by making it a signed type (e.g. ~0x1), so it may
13877 // be fine just to accept this as a warning.
13878 ExtVal |= llvm::APInt::getHighBitsSet(Width, Width - Val.getBitWidth());
13879 if (!(FlagMask & ~ExtVal))
13880 return true;
13881 }
13882
13883 return false;
13884}
13885
Mike Stump6814d1c2009-05-16 07:06:02 +000013886void Sema::ActOnEnumBody(SourceLocation EnumLoc, SourceLocation LBraceLoc,
John McCall48871652010-08-21 09:40:31 +000013887 SourceLocation RBraceLoc, Decl *EnumDeclX,
Dmitri Gribenkoe5fde992013-04-27 20:23:52 +000013888 ArrayRef<Decl *> Elements,
Edward O'Callaghanc69169d2009-08-08 14:36:57 +000013889 Scope *S, AttributeList *Attr) {
John McCall48871652010-08-21 09:40:31 +000013890 EnumDecl *Enum = cast<EnumDecl>(EnumDeclX);
Douglas Gregor07665a62009-01-05 19:45:36 +000013891 QualType EnumType = Context.getTypeDeclType(Enum);
Edward O'Callaghanc69169d2009-08-08 14:36:57 +000013892
13893 if (Attr)
13894 ProcessDeclAttributeList(S, Enum, Attr);
Mike Stump11289f42009-09-09 15:08:12 +000013895
Eli Friedmand0e60972009-12-11 01:34:50 +000013896 if (Enum->isDependentType()) {
Dmitri Gribenkoe5fde992013-04-27 20:23:52 +000013897 for (unsigned i = 0, e = Elements.size(); i != e; ++i) {
Eli Friedmand0e60972009-12-11 01:34:50 +000013898 EnumConstantDecl *ECD =
John McCall48871652010-08-21 09:40:31 +000013899 cast_or_null<EnumConstantDecl>(Elements[i]);
Eli Friedmand0e60972009-12-11 01:34:50 +000013900 if (!ECD) continue;
13901
13902 ECD->setType(EnumType);
13903 }
13904
John McCall9aa35be2010-05-06 08:49:23 +000013905 Enum->completeDefinition(Context.DependentTy, Context.DependentTy, 0, 0);
Eli Friedmand0e60972009-12-11 01:34:50 +000013906 return;
13907 }
13908
Chris Lattner67933c02007-08-28 05:10:31 +000013909 // TODO: If the result value doesn't fit in an int, it must be a long or long
13910 // long value. ISO C does not support this, but GCC does as an extension,
13911 // emit a warning.
Douglas Gregore8bbc122011-09-02 00:18:52 +000013912 unsigned IntWidth = Context.getTargetInfo().getIntWidth();
13913 unsigned CharWidth = Context.getTargetInfo().getCharWidth();
13914 unsigned ShortWidth = Context.getTargetInfo().getShortWidth();
Mike Stump11289f42009-09-09 15:08:12 +000013915
Chris Lattnerb8a501c2007-08-28 06:15:15 +000013916 // Verify that all the values are okay, compute the size of the values, and
13917 // reverse the list.
13918 unsigned NumNegativeBits = 0;
13919 unsigned NumPositiveBits = 0;
Mike Stump11289f42009-09-09 15:08:12 +000013920
Chris Lattnerb8a501c2007-08-28 06:15:15 +000013921 // Keep track of whether all elements have type int.
13922 bool AllElementsInt = true;
Mike Stump11289f42009-09-09 15:08:12 +000013923
Dmitri Gribenkoe5fde992013-04-27 20:23:52 +000013924 for (unsigned i = 0, e = Elements.size(); i != e; ++i) {
Chris Lattnerc1915e22007-01-25 07:29:02 +000013925 EnumConstantDecl *ECD =
John McCall48871652010-08-21 09:40:31 +000013926 cast_or_null<EnumConstantDecl>(Elements[i]);
Chris Lattnerc1915e22007-01-25 07:29:02 +000013927 if (!ECD) continue; // Already issued a diagnostic.
Mike Stump11289f42009-09-09 15:08:12 +000013928
Chris Lattnerbf478cb2007-08-28 05:27:00 +000013929 const llvm::APSInt &InitVal = ECD->getInitVal();
Mike Stump11289f42009-09-09 15:08:12 +000013930
Chris Lattnerb8a501c2007-08-28 06:15:15 +000013931 // Keep track of the size of positive and negative values.
Chris Lattner77683132008-02-26 00:33:57 +000013932 if (InitVal.isUnsigned() || InitVal.isNonNegative())
Chris Lattner49f980c2008-01-14 21:47:29 +000013933 NumPositiveBits = std::max(NumPositiveBits,
13934 (unsigned)InitVal.getActiveBits());
Chris Lattnerb8a501c2007-08-28 06:15:15 +000013935 else
Chris Lattner49f980c2008-01-14 21:47:29 +000013936 NumNegativeBits = std::max(NumNegativeBits,
13937 (unsigned)InitVal.getMinSignedBits());
Chris Lattner4ef40012007-06-11 01:28:17 +000013938
Chris Lattnerb8a501c2007-08-28 06:15:15 +000013939 // Keep track of whether every enum element has type int (very commmon).
13940 if (AllElementsInt)
Mike Stump11289f42009-09-09 15:08:12 +000013941 AllElementsInt = ECD->getType() == Context.IntTy;
Chris Lattnerc1915e22007-01-25 07:29:02 +000013942 }
Mike Stump11289f42009-09-09 15:08:12 +000013943
Chris Lattnerb8a501c2007-08-28 06:15:15 +000013944 // Figure out the type that should be used for this enum.
Chris Lattnerb8a501c2007-08-28 06:15:15 +000013945 QualType BestType;
Chris Lattner3a370bf2007-08-29 17:31:48 +000013946 unsigned BestWidth;
Edward O'Callaghanc69169d2009-08-08 14:36:57 +000013947
John McCall56774992009-12-09 09:09:27 +000013948 // C++0x N3000 [conv.prom]p3:
13949 // An rvalue of an unscoped enumeration type whose underlying
13950 // type is not fixed can be converted to an rvalue of the first
13951 // of the following types that can represent all the values of
13952 // the enumeration: int, unsigned int, long int, unsigned long
13953 // int, long long int, or unsigned long long int.
13954 // C99 6.4.4.3p2:
13955 // An identifier declared as an enumeration constant has type int.
13956 // The C99 rule is modified by a gcc extension
13957 QualType BestPromotionType;
13958
Aaron Ballman9ead1242013-12-19 02:39:40 +000013959 bool Packed = Enum->hasAttr<PackedAttr>();
Argyrios Kyrtzidis74825bc2010-10-08 00:25:19 +000013960 // -fshort-enums is the equivalent to specifying the packed attribute on all
13961 // enum definitions.
13962 if (LangOpts.ShortEnums)
13963 Packed = true;
Edward O'Callaghanc69169d2009-08-08 14:36:57 +000013964
Douglas Gregor0bf31402010-10-08 23:50:27 +000013965 if (Enum->isFixed()) {
Eli Friedman64d95042011-10-26 07:38:19 +000013966 BestType = Enum->getIntegerType();
13967 if (BestType->isPromotableIntegerType())
13968 BestPromotionType = Context.getPromotedIntegerType(BestType);
13969 else
13970 BestPromotionType = BestType;
Alexis Hunt724f14e2014-11-28 00:53:20 +000013971
13972 BestWidth = Context.getIntWidth(BestType);
Douglas Gregor0bf31402010-10-08 23:50:27 +000013973 }
13974 else if (NumNegativeBits) {
Mike Stump11289f42009-09-09 15:08:12 +000013975 // If there is a negative value, figure out the smallest integer type (of
Chris Lattnerb8a501c2007-08-28 06:15:15 +000013976 // int/long/longlong) that fits.
Edward O'Callaghanc69169d2009-08-08 14:36:57 +000013977 // If it's packed, check also if it fits a char or a short.
13978 if (Packed && NumNegativeBits <= CharWidth && NumPositiveBits < CharWidth) {
John McCall56774992009-12-09 09:09:27 +000013979 BestType = Context.SignedCharTy;
13980 BestWidth = CharWidth;
Mike Stump11289f42009-09-09 15:08:12 +000013981 } else if (Packed && NumNegativeBits <= ShortWidth &&
Edward O'Callaghanc69169d2009-08-08 14:36:57 +000013982 NumPositiveBits < ShortWidth) {
John McCall56774992009-12-09 09:09:27 +000013983 BestType = Context.ShortTy;
13984 BestWidth = ShortWidth;
13985 } else if (NumNegativeBits <= IntWidth && NumPositiveBits < IntWidth) {
Chris Lattnerb8a501c2007-08-28 06:15:15 +000013986 BestType = Context.IntTy;
Chris Lattner3a370bf2007-08-29 17:31:48 +000013987 BestWidth = IntWidth;
13988 } else {
Douglas Gregore8bbc122011-09-02 00:18:52 +000013989 BestWidth = Context.getTargetInfo().getLongWidth();
Mike Stump11289f42009-09-09 15:08:12 +000013990
John McCall56774992009-12-09 09:09:27 +000013991 if (NumNegativeBits <= BestWidth && NumPositiveBits < BestWidth) {
Chris Lattnerb8a501c2007-08-28 06:15:15 +000013992 BestType = Context.LongTy;
John McCall56774992009-12-09 09:09:27 +000013993 } else {
Douglas Gregore8bbc122011-09-02 00:18:52 +000013994 BestWidth = Context.getTargetInfo().getLongLongWidth();
Mike Stump11289f42009-09-09 15:08:12 +000013995
Chris Lattner3a370bf2007-08-29 17:31:48 +000013996 if (NumNegativeBits > BestWidth || NumPositiveBits >= BestWidth)
Richard Smithfaf156a2014-03-05 22:54:58 +000013997 Diag(Enum->getLocation(), diag::ext_enum_too_large);
Chris Lattnerb8a501c2007-08-28 06:15:15 +000013998 BestType = Context.LongLongTy;
13999 }
14000 }
John McCall56774992009-12-09 09:09:27 +000014001 BestPromotionType = (BestWidth <= IntWidth ? Context.IntTy : BestType);
Chris Lattnerb8a501c2007-08-28 06:15:15 +000014002 } else {
Douglas Gregora71cc152010-02-02 20:10:50 +000014003 // If there is no negative value, figure out the smallest type that fits
14004 // all of the enumerator values.
Edward O'Callaghanc69169d2009-08-08 14:36:57 +000014005 // If it's packed, check also if it fits a char or a short.
14006 if (Packed && NumPositiveBits <= CharWidth) {
John McCall56774992009-12-09 09:09:27 +000014007 BestType = Context.UnsignedCharTy;
14008 BestPromotionType = Context.IntTy;
14009 BestWidth = CharWidth;
Edward O'Callaghanc69169d2009-08-08 14:36:57 +000014010 } else if (Packed && NumPositiveBits <= ShortWidth) {
John McCall56774992009-12-09 09:09:27 +000014011 BestType = Context.UnsignedShortTy;
14012 BestPromotionType = Context.IntTy;
14013 BestWidth = ShortWidth;
14014 } else if (NumPositiveBits <= IntWidth) {
Chris Lattnerb8a501c2007-08-28 06:15:15 +000014015 BestType = Context.UnsignedIntTy;
Chris Lattner3a370bf2007-08-29 17:31:48 +000014016 BestWidth = IntWidth;
Douglas Gregora71cc152010-02-02 20:10:50 +000014017 BestPromotionType
David Blaikiebbafb8a2012-03-11 07:00:24 +000014018 = (NumPositiveBits == BestWidth || !getLangOpts().CPlusPlus)
Douglas Gregora71cc152010-02-02 20:10:50 +000014019 ? Context.UnsignedIntTy : Context.IntTy;
Chris Lattner3a370bf2007-08-29 17:31:48 +000014020 } else if (NumPositiveBits <=
Douglas Gregore8bbc122011-09-02 00:18:52 +000014021 (BestWidth = Context.getTargetInfo().getLongWidth())) {
Chris Lattnerb8a501c2007-08-28 06:15:15 +000014022 BestType = Context.UnsignedLongTy;
Douglas Gregora71cc152010-02-02 20:10:50 +000014023 BestPromotionType
David Blaikiebbafb8a2012-03-11 07:00:24 +000014024 = (NumPositiveBits == BestWidth || !getLangOpts().CPlusPlus)
Douglas Gregora71cc152010-02-02 20:10:50 +000014025 ? Context.UnsignedLongTy : Context.LongTy;
Chris Lattner37e05872008-03-05 18:54:05 +000014026 } else {
Douglas Gregore8bbc122011-09-02 00:18:52 +000014027 BestWidth = Context.getTargetInfo().getLongLongWidth();
Chris Lattner3a370bf2007-08-29 17:31:48 +000014028 assert(NumPositiveBits <= BestWidth &&
Chris Lattnerb8a501c2007-08-28 06:15:15 +000014029 "How could an initializer get larger than ULL?");
14030 BestType = Context.UnsignedLongLongTy;
Douglas Gregora71cc152010-02-02 20:10:50 +000014031 BestPromotionType
David Blaikiebbafb8a2012-03-11 07:00:24 +000014032 = (NumPositiveBits == BestWidth || !getLangOpts().CPlusPlus)
Douglas Gregora71cc152010-02-02 20:10:50 +000014033 ? Context.UnsignedLongLongTy : Context.LongLongTy;
Chris Lattnerb8a501c2007-08-28 06:15:15 +000014034 }
14035 }
Mike Stump11289f42009-09-09 15:08:12 +000014036
Alexis Hunt724f14e2014-11-28 00:53:20 +000014037 FlagEnumAttr *FEAttr = Enum->getAttr<FlagEnumAttr>();
14038 if (FEAttr)
14039 FEAttr->getFlagBits() = llvm::APInt(BestWidth, 0);
14040
Chris Lattner3a370bf2007-08-29 17:31:48 +000014041 // Loop over all of the enumerator constants, changing their types to match
Alexis Hunt724f14e2014-11-28 00:53:20 +000014042 // the type of the enum if needed. If we have a flag type, we also prepare the
14043 // FlagBits cache.
14044 for (auto *D : Elements) {
14045 auto *ECD = cast_or_null<EnumConstantDecl>(D);
Chris Lattner3a370bf2007-08-29 17:31:48 +000014046 if (!ECD) continue; // Already issued a diagnostic.
14047
14048 // Standard C says the enumerators have int type, but we allow, as an
14049 // extension, the enumerators to be larger than int size. If each
14050 // enumerator value fits in an int, type it as an int, otherwise type it the
14051 // same as the enumerator decl itself. This means that in "enum { X = 1U }"
14052 // that X has type 'int', not 'unsigned'.
Chris Lattner3a370bf2007-08-29 17:31:48 +000014053
14054 // Determine whether the value fits into an int.
14055 llvm::APSInt InitVal = ECD->getInitVal();
Chris Lattner3a370bf2007-08-29 17:31:48 +000014056
14057 // If it fits into an integer type, force it. Otherwise force it to match
14058 // the enum decl type.
14059 QualType NewTy;
14060 unsigned NewWidth;
14061 bool NewSign;
David Blaikiebbafb8a2012-03-11 07:00:24 +000014062 if (!getLangOpts().CPlusPlus &&
Fariborz Jahanian37c64172011-11-04 18:51:24 +000014063 !Enum->isFixed() &&
Douglas Gregor6791a0d2010-02-01 23:36:03 +000014064 isRepresentableIntegerValue(Context, InitVal, Context.IntTy)) {
Chris Lattner3a370bf2007-08-29 17:31:48 +000014065 NewTy = Context.IntTy;
14066 NewWidth = IntWidth;
14067 NewSign = true;
14068 } else if (ECD->getType() == BestType) {
14069 // Already the right type!
David Blaikiebbafb8a2012-03-11 07:00:24 +000014070 if (getLangOpts().CPlusPlus)
Douglas Gregor1d248c52008-12-12 02:00:36 +000014071 // C++ [dcl.enum]p4: Following the closing brace of an
14072 // enum-specifier, each enumerator has the type of its
Mike Stump11289f42009-09-09 15:08:12 +000014073 // enumeration.
Douglas Gregor1d248c52008-12-12 02:00:36 +000014074 ECD->setType(EnumType);
Alexis Hunt724f14e2014-11-28 00:53:20 +000014075 goto flagbits;
Chris Lattner3a370bf2007-08-29 17:31:48 +000014076 } else {
14077 NewTy = BestType;
14078 NewWidth = BestWidth;
Douglas Gregor6ab2fa82011-05-20 16:38:50 +000014079 NewSign = BestType->isSignedIntegerOrEnumerationType();
Chris Lattner3a370bf2007-08-29 17:31:48 +000014080 }
14081
14082 // Adjust the APSInt value.
Jay Foad6d4db0c2010-12-07 08:25:34 +000014083 InitVal = InitVal.extOrTrunc(NewWidth);
Chris Lattner3a370bf2007-08-29 17:31:48 +000014084 InitVal.setIsSigned(NewSign);
14085 ECD->setInitVal(InitVal);
Mike Stump11289f42009-09-09 15:08:12 +000014086
Chris Lattner3a370bf2007-08-29 17:31:48 +000014087 // Adjust the Expr initializer and type.
Abramo Bagnara77815432010-12-17 15:49:53 +000014088 if (ECD->getInitExpr() &&
Nick Lewycky0bdf13e2011-07-02 02:05:12 +000014089 !Context.hasSameType(NewTy, ECD->getInitExpr()->getType()))
John McCallcf142162010-08-07 06:22:56 +000014090 ECD->setInitExpr(ImplicitCastExpr::Create(Context, NewTy,
John McCalle3027922010-08-25 11:45:40 +000014091 CK_IntegralCast,
John McCallcf142162010-08-07 06:22:56 +000014092 ECD->getInitExpr(),
Craig Topperc3ec1492014-05-26 06:22:03 +000014093 /*base paths*/ nullptr,
John McCall2536c6d2010-08-25 10:28:54 +000014094 VK_RValue));
David Blaikiebbafb8a2012-03-11 07:00:24 +000014095 if (getLangOpts().CPlusPlus)
Douglas Gregor1d248c52008-12-12 02:00:36 +000014096 // C++ [dcl.enum]p4: Following the closing brace of an
14097 // enum-specifier, each enumerator has the type of its
Mike Stump11289f42009-09-09 15:08:12 +000014098 // enumeration.
Douglas Gregor1d248c52008-12-12 02:00:36 +000014099 ECD->setType(EnumType);
14100 else
14101 ECD->setType(NewTy);
Alexis Hunt724f14e2014-11-28 00:53:20 +000014102
14103flagbits:
14104 // Check to see if we have a constant with exactly one bit set. Note that x
14105 // & (x - 1) will be nonzero if and only if x has more than one bit set.
14106 if (FEAttr) {
14107 llvm::APInt ExtVal = InitVal.zextOrSelf(BestWidth);
14108 if (ExtVal != 0 && !(ExtVal & (ExtVal - 1))) {
14109 FEAttr->getFlagBits() |= ExtVal;
14110 }
14111 }
Chris Lattner3a370bf2007-08-29 17:31:48 +000014112 }
Mike Stump11289f42009-09-09 15:08:12 +000014113
Alexis Hunt724f14e2014-11-28 00:53:20 +000014114 if (FEAttr) {
14115 for (Decl *D : Elements) {
14116 EnumConstantDecl *ECD = cast_or_null<EnumConstantDecl>(D);
14117 if (!ECD) continue; // Already issued a diagnostic.
14118
14119 llvm::APSInt InitVal = ECD->getInitVal();
14120 if (InitVal != 0 && !IsValueInFlagEnum(Enum, InitVal, true))
14121 Diag(ECD->getLocation(), diag::warn_flag_enum_constant_out_of_range)
14122 << ECD << Enum;
14123 }
14124 }
14125
14126
14127
John McCall9aa35be2010-05-06 08:49:23 +000014128 Enum->completeDefinition(BestType, BestPromotionType,
14129 NumPositiveBits, NumNegativeBits);
James Molloy6f8780b2012-02-29 10:24:19 +000014130
Dmitri Gribenkoe5fde992013-04-27 20:23:52 +000014131 CheckForDuplicateEnumValues(*this, Elements, Enum, EnumType);
Richard Smith848e1f12013-02-01 08:12:08 +000014132
14133 // Now that the enum type is defined, ensure it's not been underaligned.
14134 if (Enum->hasAttrs())
14135 CheckAlignasUnderalignment(Enum);
Chris Lattnerc1915e22007-01-25 07:29:02 +000014136}
Chris Lattner1300fb92007-01-23 23:42:53 +000014137
Abramo Bagnara348823a2011-03-03 14:20:18 +000014138Decl *Sema::ActOnFileScopeAsmDecl(Expr *expr,
14139 SourceLocation StartLoc,
14140 SourceLocation EndLoc) {
John McCallb268a282010-08-23 23:25:46 +000014141 StringLiteral *AsmString = cast<StringLiteral>(expr);
Sebastian Redlc675bab2008-12-13 16:23:55 +000014142
Douglas Gregor278f52e2009-05-30 00:08:05 +000014143 FileScopeAsmDecl *New = FileScopeAsmDecl::Create(Context, CurContext,
Abramo Bagnara348823a2011-03-03 14:20:18 +000014144 AsmString, StartLoc,
14145 EndLoc);
Argyrios Kyrtzidiscfbfe782009-06-30 02:36:12 +000014146 CurContext->addDecl(New);
John McCall48871652010-08-21 09:40:31 +000014147 return New;
Anders Carlsson5c6c0592008-02-08 00:33:21 +000014148}
Eli Friedman5ed51982009-06-05 02:44:36 +000014149
Richard Smith77944862014-03-02 05:58:18 +000014150static void checkModuleImportContext(Sema &S, Module *M,
14151 SourceLocation ImportLoc,
14152 DeclContext *DC) {
14153 if (auto *LSD = dyn_cast<LinkageSpecDecl>(DC)) {
14154 switch (LSD->getLanguage()) {
14155 case LinkageSpecDecl::lang_c:
14156 if (!M->IsExternC) {
14157 S.Diag(ImportLoc, diag::err_module_import_in_extern_c)
14158 << M->getFullModuleName();
14159 S.Diag(LSD->getLocStart(), diag::note_module_import_in_extern_c);
14160 return;
14161 }
14162 break;
14163 case LinkageSpecDecl::lang_cxx:
14164 break;
14165 }
14166 DC = LSD->getParent();
14167 }
14168
14169 while (isa<LinkageSpecDecl>(DC))
14170 DC = DC->getParent();
14171 if (!isa<TranslationUnitDecl>(DC)) {
14172 S.Diag(ImportLoc, diag::err_module_import_not_at_top_level)
14173 << M->getFullModuleName() << DC;
14174 S.Diag(cast<Decl>(DC)->getLocStart(),
14175 diag::note_module_import_not_at_top_level)
14176 << DC;
14177 }
14178}
14179
Douglas Gregor22d09742012-01-03 18:04:46 +000014180DeclResult Sema::ActOnModuleImport(SourceLocation AtLoc,
14181 SourceLocation ImportLoc,
14182 ModuleIdPath Path) {
Alp Tokerb6cc5922014-05-03 03:45:55 +000014183 Module *Mod =
14184 getModuleLoader().loadModule(ImportLoc, Path, Module::AllVisible,
14185 /*IsIncludeDirective=*/false);
Douglas Gregorde3ef502011-11-30 23:21:26 +000014186 if (!Mod)
Douglas Gregor08142532011-08-26 23:56:07 +000014187 return true;
Richard Smith77944862014-03-02 05:58:18 +000014188
Richard Smith42413142015-05-15 20:05:43 +000014189 VisibleModules.setVisible(Mod, ImportLoc);
14190
Richard Smith77944862014-03-02 05:58:18 +000014191 checkModuleImportContext(*this, Mod, ImportLoc, CurContext);
14192
Ben Langmuir527040e2014-05-05 05:31:33 +000014193 // FIXME: we should support importing a submodule within a different submodule
14194 // of the same top-level module. Until we do, make it an error rather than
14195 // silently ignoring the import.
14196 if (Mod->getTopLevelModuleName() == getLangOpts().CurrentModule)
14197 Diag(ImportLoc, diag::err_module_self_import)
14198 << Mod->getFullModuleName() << getLangOpts().CurrentModule;
Ben Langmuirb537a3a2014-07-23 15:30:23 +000014199 else if (Mod->getTopLevelModuleName() == getLangOpts().ImplementationOfModule)
14200 Diag(ImportLoc, diag::err_module_import_in_implementation)
14201 << Mod->getFullModuleName() << getLangOpts().ImplementationOfModule;
Ben Langmuir527040e2014-05-05 05:31:33 +000014202
Dmitri Gribenkof8579502013-01-12 19:30:44 +000014203 SmallVector<SourceLocation, 2> IdentifierLocs;
Douglas Gregorba345522011-12-02 23:23:56 +000014204 Module *ModCheck = Mod;
14205 for (unsigned I = 0, N = Path.size(); I != N; ++I) {
14206 // If we've run out of module parents, just drop the remaining identifiers.
14207 // We need the length to be consistent.
14208 if (!ModCheck)
14209 break;
14210 ModCheck = ModCheck->Parent;
14211
14212 IdentifierLocs.push_back(Path[I].second);
14213 }
14214
14215 ImportDecl *Import = ImportDecl::Create(Context,
14216 Context.getTranslationUnitDecl(),
Douglas Gregor22d09742012-01-03 18:04:46 +000014217 AtLoc.isValid()? AtLoc : ImportLoc,
14218 Mod, IdentifierLocs);
Douglas Gregorba345522011-12-02 23:23:56 +000014219 Context.getTranslationUnitDecl()->addDecl(Import);
14220 return Import;
Douglas Gregor08142532011-08-26 23:56:07 +000014221}
14222
Richard Smithce587f52013-11-15 04:24:58 +000014223void Sema::ActOnModuleInclude(SourceLocation DirectiveLoc, Module *Mod) {
Richard Smith77944862014-03-02 05:58:18 +000014224 checkModuleImportContext(*this, Mod, DirectiveLoc, CurContext);
14225
Richard Smithbca31b72015-05-18 05:35:52 +000014226 // Determine whether we're in the #include buffer for a module. The #includes
14227 // in that buffer do not qualify as module imports; they're just an
14228 // implementation detail of us building the module.
14229 //
14230 // FIXME: Should we even get ActOnModuleInclude calls for those?
14231 bool IsInModuleIncludes =
14232 TUKind == TU_Module &&
14233 getSourceManager().isWrittenInMainFile(DirectiveLoc);
14234
14235 // If this module import was due to an inclusion directive, create an
14236 // implicit import declaration to capture it in the AST.
14237 if (!IsInModuleIncludes) {
14238 TranslationUnitDecl *TU = getASTContext().getTranslationUnitDecl();
14239 ImportDecl *ImportD = ImportDecl::CreateImplicit(getASTContext(), TU,
14240 DirectiveLoc, Mod,
14241 DirectiveLoc);
14242 TU->addDecl(ImportD);
14243 Consumer.HandleImplicitImportDecl(ImportD);
14244 }
14245
Richard Smitha7e2cc62015-05-01 01:53:09 +000014246 getModuleLoader().makeModuleVisible(Mod, Module::AllVisible, DirectiveLoc);
Richard Smith42413142015-05-15 20:05:43 +000014247 VisibleModules.setVisible(Mod, DirectiveLoc);
14248}
14249
14250void Sema::ActOnModuleBegin(SourceLocation DirectiveLoc, Module *Mod) {
14251 checkModuleImportContext(*this, Mod, DirectiveLoc, CurContext);
14252
14253 if (getLangOpts().ModulesLocalVisibility)
14254 VisibleModulesStack.push_back(std::move(VisibleModules));
14255 VisibleModules.setVisible(Mod, DirectiveLoc);
14256}
14257
14258void Sema::ActOnModuleEnd(SourceLocation DirectiveLoc, Module *Mod) {
14259 checkModuleImportContext(*this, Mod, DirectiveLoc, CurContext);
14260
14261 if (getLangOpts().ModulesLocalVisibility) {
14262 VisibleModules = std::move(VisibleModulesStack.back());
14263 VisibleModulesStack.pop_back();
14264 VisibleModules.setVisible(Mod, DirectiveLoc);
14265 }
Richard Smithce587f52013-11-15 04:24:58 +000014266}
14267
Richard Smith3d23c422014-05-07 02:25:43 +000014268void Sema::createImplicitModuleImportForErrorRecovery(SourceLocation Loc,
14269 Module *Mod) {
14270 // Bail if we're not allowed to implicitly import a module here.
14271 if (isSFINAEContext() || !getLangOpts().ModulesErrorRecovery)
14272 return;
14273
Douglas Gregorc147b0b2013-01-12 01:29:50 +000014274 // Create the implicit import declaration.
14275 TranslationUnitDecl *TU = getASTContext().getTranslationUnitDecl();
14276 ImportDecl *ImportD = ImportDecl::CreateImplicit(getASTContext(), TU,
14277 Loc, Mod, Loc);
14278 TU->addDecl(ImportD);
14279 Consumer.HandleImplicitImportDecl(ImportD);
14280
14281 // Make the module visible.
Richard Smitha7e2cc62015-05-01 01:53:09 +000014282 getModuleLoader().makeModuleVisible(Mod, Module::AllVisible, Loc);
Richard Smith42413142015-05-15 20:05:43 +000014283 VisibleModules.setVisible(Mod, Loc);
Douglas Gregorc147b0b2013-01-12 01:29:50 +000014284}
14285
David Chisnall0867d9c2012-02-18 16:12:34 +000014286void Sema::ActOnPragmaRedefineExtname(IdentifierInfo* Name,
14287 IdentifierInfo* AliasName,
14288 SourceLocation PragmaLoc,
14289 SourceLocation NameLoc,
14290 SourceLocation AliasNameLoc) {
Alexander Musman70e9f5f2015-06-10 11:20:26 +000014291 NamedDecl *PrevDecl = LookupSingleName(TUScope, Name, NameLoc,
14292 LookupOrdinaryName);
14293 AsmLabelAttr *Attr =
14294 AsmLabelAttr::CreateImplicit(Context, AliasName->getName(), AliasNameLoc);
David Chisnall0867d9c2012-02-18 16:12:34 +000014295
Alexander Musman70e9f5f2015-06-10 11:20:26 +000014296 // If a declaration that:
14297 // 1) declares a function or a variable
14298 // 2) has external linkage
14299 // already exists, add a label attribute to it.
14300 if (PrevDecl &&
14301 (isa<FunctionDecl>(PrevDecl) || isa<VarDecl>(PrevDecl)) &&
14302 PrevDecl->hasExternalFormalLinkage())
David Chisnall0867d9c2012-02-18 16:12:34 +000014303 PrevDecl->addAttr(Attr);
Alexander Musman70e9f5f2015-06-10 11:20:26 +000014304 // Otherwise, add a label atttibute to ExtnameUndeclaredIdentifiers.
14305 else
14306 (void)ExtnameUndeclaredIdentifiers.insert(std::make_pair(Name, Attr));
David Chisnall0867d9c2012-02-18 16:12:34 +000014307}
14308
Eli Friedman5ed51982009-06-05 02:44:36 +000014309void Sema::ActOnPragmaWeakID(IdentifierInfo* Name,
14310 SourceLocation PragmaLoc,
14311 SourceLocation NameLoc) {
Douglas Gregorb2ccf012010-04-15 22:33:43 +000014312 Decl *PrevDecl = LookupSingleName(TUScope, Name, NameLoc, LookupOrdinaryName);
Eli Friedman5ed51982009-06-05 02:44:36 +000014313
Eli Friedman5ed51982009-06-05 02:44:36 +000014314 if (PrevDecl) {
Aaron Ballman36a53502014-01-16 13:03:14 +000014315 PrevDecl->addAttr(WeakAttr::CreateImplicit(Context, PragmaLoc));
Ryan Flynn7d470f32009-07-30 03:15:39 +000014316 } else {
14317 (void)WeakUndeclaredIdentifiers.insert(
14318 std::pair<IdentifierInfo*,WeakInfo>
Craig Topperc3ec1492014-05-26 06:22:03 +000014319 (Name, WeakInfo((IdentifierInfo*)nullptr, NameLoc)));
Eli Friedman5ed51982009-06-05 02:44:36 +000014320 }
Eli Friedman5ed51982009-06-05 02:44:36 +000014321}
14322
14323void Sema::ActOnPragmaWeakAlias(IdentifierInfo* Name,
14324 IdentifierInfo* AliasName,
14325 SourceLocation PragmaLoc,
14326 SourceLocation NameLoc,
14327 SourceLocation AliasNameLoc) {
Douglas Gregorb2ccf012010-04-15 22:33:43 +000014328 Decl *PrevDecl = LookupSingleName(TUScope, AliasName, AliasNameLoc,
14329 LookupOrdinaryName);
Ryan Flynn7d470f32009-07-30 03:15:39 +000014330 WeakInfo W = WeakInfo(Name, NameLoc);
Eli Friedman5ed51982009-06-05 02:44:36 +000014331
Eli Friedman5ed51982009-06-05 02:44:36 +000014332 if (PrevDecl) {
Ryan Flynn7d470f32009-07-30 03:15:39 +000014333 if (!PrevDecl->hasAttr<AliasAttr>())
14334 if (NamedDecl *ND = dyn_cast<NamedDecl>(PrevDecl))
Ryan Flynnd963a492009-07-31 02:52:19 +000014335 DeclApplyPragmaWeak(TUScope, ND, W);
Ryan Flynn7d470f32009-07-30 03:15:39 +000014336 } else {
14337 (void)WeakUndeclaredIdentifiers.insert(
14338 std::pair<IdentifierInfo*,WeakInfo>(AliasName, W));
Eli Friedman5ed51982009-06-05 02:44:36 +000014339 }
Eli Friedman5ed51982009-06-05 02:44:36 +000014340}
Fariborz Jahanian8d382dc2011-08-22 15:54:49 +000014341
14342Decl *Sema::getObjCDeclContext() const {
14343 return (dyn_cast_or_null<ObjCContainerDecl>(CurContext));
14344}
Argyrios Kyrtzidisc281c962011-10-06 23:23:27 +000014345
14346AvailabilityResult Sema::getCurContextAvailability() const {
Ben Langmuirc91ac9e2015-01-20 20:41:36 +000014347 const Decl *D = cast_or_null<Decl>(getCurObjCLexicalContext());
14348 if (!D)
14349 return AR_Available;
14350
Ted Kremenekcb42dbe2013-11-20 17:24:03 +000014351 // If we are within an Objective-C method, we should consult
14352 // both the availability of the method as well as the
14353 // enclosing class. If the class is (say) deprecated,
14354 // the entire method is considered deprecated from the
14355 // purpose of checking if the current context is deprecated.
14356 if (const ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D)) {
14357 AvailabilityResult R = MD->getAvailability();
14358 if (R != AR_Available)
14359 return R;
14360 D = MD->getClassInterface();
14361 }
14362 // If we are within an Objective-c @implementation, it
14363 // gets the same availability context as the @interface.
14364 else if (const ObjCImplementationDecl *ID =
14365 dyn_cast<ObjCImplementationDecl>(D)) {
14366 D = ID->getClassInterface();
14367 }
Fariborz Jahanian38c53fb2014-08-21 17:06:57 +000014368 // Recover from user error.
14369 return D ? D->getAvailability() : AR_Available;
Argyrios Kyrtzidisc281c962011-10-06 23:23:27 +000014370}