blob: 98db0c7b5ae0e4e3d19478d252b8d9bc913357c1 [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
Richard Smithca40f9b2014-08-10 02:20:15 +00001799/// Typedef declarations don't have linkage, but they still denote the same
1800/// entity if their types are the same.
1801/// FIXME: This is notionally doing the same thing as ASTReaderDecl's
1802/// isSameEntity.
Richard Smith42413142015-05-15 20:05:43 +00001803static void filterNonConflictingPreviousTypedefDecls(Sema &S,
Richard Smithca40f9b2014-08-10 02:20:15 +00001804 TypedefNameDecl *Decl,
1805 LookupResult &Previous) {
1806 // This is only interesting when modules are enabled.
Richard Smith00be6d02015-06-11 03:05:39 +00001807 if (!S.getLangOpts().Modules && !S.getLangOpts().ModulesLocalVisibility)
Richard Smithca40f9b2014-08-10 02:20:15 +00001808 return;
1809
1810 // Empty sets are uninteresting.
1811 if (Previous.empty())
1812 return;
1813
1814 LookupResult::Filter Filter = Previous.makeFilter();
1815 while (Filter.hasNext()) {
1816 NamedDecl *Old = Filter.next();
1817
1818 // Non-hidden declarations are never ignored.
Richard Smith42413142015-05-15 20:05:43 +00001819 if (S.isVisible(Old))
Richard Smithca40f9b2014-08-10 02:20:15 +00001820 continue;
1821
1822 // Declarations of the same entity are not ignored, even if they have
1823 // different linkages.
Richard Smitha5230222015-03-27 01:37:43 +00001824 if (auto *OldTD = dyn_cast<TypedefNameDecl>(Old)) {
Richard Smith42413142015-05-15 20:05:43 +00001825 if (S.Context.hasSameType(OldTD->getUnderlyingType(),
1826 Decl->getUnderlyingType()))
Richard Smithca40f9b2014-08-10 02:20:15 +00001827 continue;
1828
Richard Smitha5230222015-03-27 01:37:43 +00001829 // If both declarations give a tag declaration a typedef name for linkage
1830 // purposes, then they declare the same entity.
Richard Smith42413142015-05-15 20:05:43 +00001831 if (OldTD->getAnonDeclWithTypedefName(/*AnyRedecl*/true) &&
Richard Smitha5230222015-03-27 01:37:43 +00001832 Decl->getAnonDeclWithTypedefName())
1833 continue;
1834 }
1835
Richard Smithca40f9b2014-08-10 02:20:15 +00001836 if (!Old->isExternallyVisible())
1837 Filter.erase();
1838 }
1839
1840 Filter.done();
1841}
1842
Rafael Espindolacde2c8f2011-12-26 22:42:47 +00001843bool Sema::isIncompatibleTypedef(TypeDecl *Old, TypedefNameDecl *New) {
1844 QualType OldType;
1845 if (TypedefNameDecl *OldTypedef = dyn_cast<TypedefNameDecl>(Old))
1846 OldType = OldTypedef->getUnderlyingType();
1847 else
1848 OldType = Context.getTypeDeclType(Old);
1849 QualType NewType = New->getUnderlyingType();
1850
Douglas Gregoraab36982012-01-11 22:33:48 +00001851 if (NewType->isVariablyModifiedType()) {
1852 // Must not redefine a typedef with a variably-modified type.
1853 int Kind = isa<TypeAliasDecl>(Old) ? 1 : 0;
1854 Diag(New->getLocation(), diag::err_redefinition_variably_modified_typedef)
1855 << Kind << NewType;
1856 if (Old->getLocation().isValid())
1857 Diag(Old->getLocation(), diag::note_previous_definition);
1858 New->setInvalidDecl();
1859 return true;
1860 }
1861
Rafael Espindolacde2c8f2011-12-26 22:42:47 +00001862 if (OldType != NewType &&
1863 !OldType->isDependentType() &&
1864 !NewType->isDependentType() &&
Douglas Gregoraab36982012-01-11 22:33:48 +00001865 !Context.hasSameType(OldType, NewType)) {
Rafael Espindolacde2c8f2011-12-26 22:42:47 +00001866 int Kind = isa<TypeAliasDecl>(Old) ? 1 : 0;
1867 Diag(New->getLocation(), diag::err_redefinition_different_typedef)
1868 << Kind << NewType << OldType;
1869 if (Old->getLocation().isValid())
1870 Diag(Old->getLocation(), diag::note_previous_definition);
1871 New->setInvalidDecl();
1872 return true;
1873 }
1874 return false;
1875}
1876
Richard Smithdda56e42011-04-15 14:24:37 +00001877/// MergeTypedefNameDecl - We just parsed a typedef 'New' which has the
Douglas Gregor75a45ba2009-02-16 17:45:42 +00001878/// same name and scope as a previous declaration 'Old'. Figure out
1879/// how to resolve this situation, merging decls or emitting
Chris Lattnerf6d1c9c2009-04-25 08:06:05 +00001880/// diagnostics as appropriate. If there was an error, set New to be invalid.
Chris Lattner01564d92007-01-27 19:27:06 +00001881///
Richard Smithdda56e42011-04-15 14:24:37 +00001882void Sema::MergeTypedefNameDecl(TypedefNameDecl *New, LookupResult &OldDecls) {
John McCall1f82f242009-11-18 22:49:29 +00001883 // If the new decl is known invalid already, don't bother doing any
1884 // merging checks.
1885 if (New->isInvalidDecl()) return;
Mike Stump11289f42009-09-09 15:08:12 +00001886
Steve Naroff44cfcb62008-09-09 14:32:20 +00001887 // Allow multiple definitions for ObjC built-in typedefs.
1888 // FIXME: Verify the underlying types are equivalent!
David Blaikiebbafb8a2012-03-11 07:00:24 +00001889 if (getLangOpts().ObjC1) {
Chris Lattner66e32812008-11-20 05:41:43 +00001890 const IdentifierInfo *TypeID = New->getIdentifier();
1891 switch (TypeID->getLength()) {
1892 default: break;
Mike Stump11289f42009-09-09 15:08:12 +00001893 case 2:
Fariborz Jahanian16d71bb2012-05-14 22:48:56 +00001894 {
1895 if (!TypeID->isStr("id"))
1896 break;
1897 QualType T = New->getUnderlyingType();
1898 if (!T->isPointerType())
1899 break;
1900 if (!T->isVoidPointerType()) {
1901 QualType PT = T->getAs<PointerType>()->getPointeeType();
1902 if (!PT->isStructureType())
1903 break;
1904 }
1905 Context.setObjCIdRedefinitionType(T);
1906 // Install the built-in type for 'id', ignoring the current definition.
1907 New->setTypeForDecl(Context.getObjCIdType().getTypePtr());
1908 return;
1909 }
Chris Lattner66e32812008-11-20 05:41:43 +00001910 case 5:
1911 if (!TypeID->isStr("Class"))
1912 break;
Douglas Gregor97673472011-08-11 20:58:55 +00001913 Context.setObjCClassRedefinitionType(New->getUnderlyingType());
Steve Naroff7cae42b2009-07-10 23:34:53 +00001914 // Install the built-in type for 'Class', ignoring the current definition.
1915 New->setTypeForDecl(Context.getObjCClassType().getTypePtr());
Chris Lattnerf6d1c9c2009-04-25 08:06:05 +00001916 return;
Chris Lattner66e32812008-11-20 05:41:43 +00001917 case 3:
1918 if (!TypeID->isStr("SEL"))
1919 break;
Douglas Gregor97673472011-08-11 20:58:55 +00001920 Context.setObjCSelRedefinitionType(New->getUnderlyingType());
Fariborz Jahanian252ba5f2009-11-21 19:53:08 +00001921 // Install the built-in type for 'SEL', ignoring the current definition.
1922 New->setTypeForDecl(Context.getObjCSelType().getTypePtr());
Chris Lattnerf6d1c9c2009-04-25 08:06:05 +00001923 return;
Steve Naroff44cfcb62008-09-09 14:32:20 +00001924 }
1925 // Fall through - the typedef name was not a builtin type.
1926 }
John McCall1f82f242009-11-18 22:49:29 +00001927
Douglas Gregorfb034662009-01-28 17:15:10 +00001928 // Verify the old decl was also a type.
John McCall91f1a022009-12-30 00:31:22 +00001929 TypeDecl *Old = OldDecls.getAsSingle<TypeDecl>();
1930 if (!Old) {
Mike Stump11289f42009-09-09 15:08:12 +00001931 Diag(New->getLocation(), diag::err_redefinition_different_kind)
Chris Lattnere3d20d92008-11-23 21:45:46 +00001932 << New->getDeclName();
John McCall1f82f242009-11-18 22:49:29 +00001933
1934 NamedDecl *OldD = OldDecls.getRepresentativeDecl();
Chris Lattnerf6d1c9c2009-04-25 08:06:05 +00001935 if (OldD->getLocation().isValid())
Fariborz Jahanian1778f4b2009-01-16 19:58:32 +00001936 Diag(OldD->getLocation(), diag::note_previous_definition);
John McCall1f82f242009-11-18 22:49:29 +00001937
Chris Lattnerf6d1c9c2009-04-25 08:06:05 +00001938 return New->setInvalidDecl();
Chris Lattnerc511efb2007-01-27 19:32:14 +00001939 }
Douglas Gregorfb034662009-01-28 17:15:10 +00001940
John McCall1f82f242009-11-18 22:49:29 +00001941 // If the old declaration is invalid, just give up here.
1942 if (Old->isInvalidDecl())
1943 return New->setInvalidDecl();
1944
Richard Smitha5230222015-03-27 01:37:43 +00001945 if (auto *OldTD = dyn_cast<TypedefNameDecl>(Old)) {
Richard Smith42413142015-05-15 20:05:43 +00001946 auto *OldTag = OldTD->getAnonDeclWithTypedefName(/*AnyRedecl*/true);
Richard Smitha5230222015-03-27 01:37:43 +00001947 auto *NewTag = New->getAnonDeclWithTypedefName();
1948 NamedDecl *Hidden = nullptr;
1949 if (getLangOpts().CPlusPlus && OldTag && NewTag &&
1950 OldTag->getCanonicalDecl() != NewTag->getCanonicalDecl() &&
1951 !hasVisibleDefinition(OldTag, &Hidden)) {
1952 // There is a definition of this tag, but it is not visible. Use it
1953 // instead of our tag.
1954 New->setTypeForDecl(OldTD->getTypeForDecl());
1955 if (OldTD->isModed())
1956 New->setModedTypeSourceInfo(OldTD->getTypeSourceInfo(),
1957 OldTD->getUnderlyingType());
1958 else
1959 New->setTypeSourceInfo(OldTD->getTypeSourceInfo());
1960
1961 // Make the old tag definition visible.
Richard Smithd9ba2242015-05-07 03:54:19 +00001962 makeMergedDefinitionVisible(Hidden, NewTag->getLocation());
Richard Smitha5230222015-03-27 01:37:43 +00001963 }
1964 }
1965
Chris Lattnerf9c49e52008-07-25 18:44:27 +00001966 // If the typedef types are not identical, reject them in all languages and
1967 // with any extensions enabled.
Rafael Espindolacde2c8f2011-12-26 22:42:47 +00001968 if (isIncompatibleTypedef(Old, New))
1969 return;
Mike Stump11289f42009-09-09 15:08:12 +00001970
Justin Bogner84ff5ee2013-10-08 00:19:09 +00001971 // The types match. Link up the redeclaration chain and merge attributes if
1972 // the old declaration was a typedef.
1973 if (TypedefNameDecl *Typedef = dyn_cast<TypedefNameDecl>(Old)) {
Rafael Espindola8db352d2013-10-17 15:37:26 +00001974 New->setPreviousDecl(Typedef);
Justin Bogner84ff5ee2013-10-08 00:19:09 +00001975 mergeDeclAttributes(New, Old);
1976 }
Eli Friedmane7b8aa92013-07-16 02:07:49 +00001977
David Blaikiebbafb8a2012-03-11 07:00:24 +00001978 if (getLangOpts().MicrosoftExt)
Chris Lattnerf6d1c9c2009-04-25 08:06:05 +00001979 return;
Eli Friedman61b529f2008-06-11 06:20:39 +00001980
David Blaikiebbafb8a2012-03-11 07:00:24 +00001981 if (getLangOpts().CPlusPlus) {
Douglas Gregor9dd13ab2010-01-11 21:54:40 +00001982 // C++ [dcl.typedef]p2:
1983 // In a given non-class scope, a typedef specifier can be used to
1984 // redefine the name of any type declared in that scope to refer
1985 // to the type to which it already refers.
Chris Lattner2581fc32009-04-17 22:04:20 +00001986 if (!isa<CXXRecordDecl>(CurContext))
Chris Lattnerf6d1c9c2009-04-25 08:06:05 +00001987 return;
Douglas Gregor9dd13ab2010-01-11 21:54:40 +00001988
1989 // C++0x [dcl.typedef]p4:
1990 // In a given class scope, a typedef specifier can be used to redefine
1991 // any class-name declared in that scope that is not also a typedef-name
1992 // to refer to the type to which it already refers.
1993 //
1994 // This wording came in via DR424, which was a correction to the
1995 // wording in DR56, which accidentally banned code like:
1996 //
1997 // struct S {
1998 // typedef struct A { } A;
1999 // };
2000 //
2001 // in the C++03 standard. We implement the C++0x semantics, which
2002 // allow the above but disallow
2003 //
2004 // struct S {
2005 // typedef int I;
2006 // typedef int I;
2007 // };
2008 //
2009 // since that was the intent of DR56.
Richard Smithdda56e42011-04-15 14:24:37 +00002010 if (!isa<TypedefNameDecl>(Old))
Douglas Gregor9dd13ab2010-01-11 21:54:40 +00002011 return;
2012
Chris Lattner2581fc32009-04-17 22:04:20 +00002013 Diag(New->getLocation(), diag::err_redefinition)
2014 << New->getDeclName();
2015 Diag(Old->getLocation(), diag::note_previous_definition);
Chris Lattnerf6d1c9c2009-04-25 08:06:05 +00002016 return New->setInvalidDecl();
Daniel Dunbar84b70f72008-09-12 18:10:20 +00002017 }
Eli Friedman61b529f2008-06-11 06:20:39 +00002018
Douglas Gregor7363fb02012-01-11 04:25:01 +00002019 // Modules always permit redefinition of typedefs, as does C11.
David Blaikiebbafb8a2012-03-11 07:00:24 +00002020 if (getLangOpts().Modules || getLangOpts().C11)
Douglas Gregordbd93bf2012-01-09 15:36:04 +00002021 return;
2022
Chris Lattner2581fc32009-04-17 22:04:20 +00002023 // If we have a redefinition of a typedef in C, emit a warning. This warning
2024 // is normally mapped to an error, but can be controlled with
Eli Friedman319ce952009-06-04 23:03:07 +00002025 // -Wtypedef-redefinition. If either the original or the redefinition is
2026 // in a system header, don't emit this for compatibility with GCC.
Chris Lattner30d0cfd2010-03-01 20:59:53 +00002027 if (getDiagnostics().getSuppressSystemWarnings() &&
Eli Friedman319ce952009-06-04 23:03:07 +00002028 (Context.getSourceManager().isInSystemHeader(Old->getLocation()) ||
2029 Context.getSourceManager().isInSystemHeader(New->getLocation())))
Chris Lattner9a845892009-04-27 01:46:12 +00002030 return;
Mike Stump11289f42009-09-09 15:08:12 +00002031
Richard Smith1b98ccc2014-07-19 01:39:17 +00002032 Diag(New->getLocation(), diag::ext_redefinition_of_typedef)
Chris Lattner2581fc32009-04-17 22:04:20 +00002033 << New->getDeclName();
Chris Lattner0369c572008-11-23 23:12:31 +00002034 Diag(Old->getLocation(), diag::note_previous_definition);
Chris Lattner01564d92007-01-27 19:27:06 +00002035}
2036
Chris Lattner2c6fcf52008-06-26 18:38:35 +00002037/// DeclhasAttr - returns true if decl Declaration already has the target
2038/// attribute.
Aaron Ballmanb9023ed2014-01-20 18:07:09 +00002039static bool DeclHasAttr(const Decl *D, const Attr *A) {
Alexis Huntdcfba7b2010-08-18 23:23:40 +00002040 const OwnershipAttr *OA = dyn_cast<OwnershipAttr>(A);
Julien Lerouge5a6b6982011-09-09 22:41:49 +00002041 const AnnotateAttr *Ann = dyn_cast<AnnotateAttr>(A);
Aaron Ballmanb97112e2014-03-08 22:19:01 +00002042 for (const auto *i : D->attrs())
2043 if (i->getKind() == A->getKind()) {
Julien Lerouge5a6b6982011-09-09 22:41:49 +00002044 if (Ann) {
Aaron Ballmanb97112e2014-03-08 22:19:01 +00002045 if (Ann->getAnnotation() == cast<AnnotateAttr>(i)->getAnnotation())
Julien Lerouge5a6b6982011-09-09 22:41:49 +00002046 return true;
2047 continue;
2048 }
Alexis Huntdcfba7b2010-08-18 23:23:40 +00002049 // FIXME: Don't hardcode this check
Aaron Ballmanb97112e2014-03-08 22:19:01 +00002050 if (OA && isa<OwnershipAttr>(i))
2051 return OA->getOwnKind() == cast<OwnershipAttr>(i)->getOwnKind();
Chris Lattner84966392008-03-03 03:28:21 +00002052 return true;
Alexis Huntdcfba7b2010-08-18 23:23:40 +00002053 }
Chris Lattner84966392008-03-03 03:28:21 +00002054
2055 return false;
2056}
2057
Richard Smithbc8caaf2013-02-22 04:55:39 +00002058static bool isAttributeTargetADefinition(Decl *D) {
2059 if (VarDecl *VD = dyn_cast<VarDecl>(D))
2060 return VD->isThisDeclarationADefinition();
2061 if (TagDecl *TD = dyn_cast<TagDecl>(D))
2062 return TD->isCompleteDefinition() || TD->isBeingDefined();
2063 return true;
2064}
2065
2066/// Merge alignment attributes from \p Old to \p New, taking into account the
2067/// special semantics of C11's _Alignas specifier and C++11's alignas attribute.
2068///
2069/// \return \c true if any attributes were added to \p New.
2070static bool mergeAlignedAttrs(Sema &S, NamedDecl *New, Decl *Old) {
2071 // Look for alignas attributes on Old, and pick out whichever attribute
2072 // specifies the strictest alignment requirement.
Craig Topperc3ec1492014-05-26 06:22:03 +00002073 AlignedAttr *OldAlignasAttr = nullptr;
2074 AlignedAttr *OldStrictestAlignAttr = nullptr;
Richard Smithbc8caaf2013-02-22 04:55:39 +00002075 unsigned OldAlign = 0;
Aaron Ballmanbe22bcb2014-03-10 17:08:28 +00002076 for (auto *I : Old->specific_attrs<AlignedAttr>()) {
Richard Smithbc8caaf2013-02-22 04:55:39 +00002077 // FIXME: We have no way of representing inherited dependent alignments
2078 // in a case like:
2079 // template<int A, int B> struct alignas(A) X;
2080 // template<int A, int B> struct alignas(B) X {};
2081 // For now, we just ignore any alignas attributes which are not on the
2082 // definition in such a case.
2083 if (I->isAlignmentDependent())
2084 return false;
2085
2086 if (I->isAlignas())
Aaron Ballmanbe22bcb2014-03-10 17:08:28 +00002087 OldAlignasAttr = I;
Richard Smithbc8caaf2013-02-22 04:55:39 +00002088
2089 unsigned Align = I->getAlignment(S.Context);
2090 if (Align > OldAlign) {
2091 OldAlign = Align;
Aaron Ballmanbe22bcb2014-03-10 17:08:28 +00002092 OldStrictestAlignAttr = I;
Richard Smithbc8caaf2013-02-22 04:55:39 +00002093 }
2094 }
2095
2096 // Look for alignas attributes on New.
Craig Topperc3ec1492014-05-26 06:22:03 +00002097 AlignedAttr *NewAlignasAttr = nullptr;
Richard Smithbc8caaf2013-02-22 04:55:39 +00002098 unsigned NewAlign = 0;
Aaron Ballmanbe22bcb2014-03-10 17:08:28 +00002099 for (auto *I : New->specific_attrs<AlignedAttr>()) {
Richard Smithbc8caaf2013-02-22 04:55:39 +00002100 if (I->isAlignmentDependent())
2101 return false;
2102
2103 if (I->isAlignas())
Aaron Ballmanbe22bcb2014-03-10 17:08:28 +00002104 NewAlignasAttr = I;
Richard Smithbc8caaf2013-02-22 04:55:39 +00002105
2106 unsigned Align = I->getAlignment(S.Context);
2107 if (Align > NewAlign)
2108 NewAlign = Align;
2109 }
2110
2111 if (OldAlignasAttr && NewAlignasAttr && OldAlign != NewAlign) {
2112 // Both declarations have 'alignas' attributes. We require them to match.
2113 // C++11 [dcl.align]p6 and C11 6.7.5/7 both come close to saying this, but
2114 // fall short. (If two declarations both have alignas, they must both match
2115 // every definition, and so must match each other if there is a definition.)
2116
2117 // If either declaration only contains 'alignas(0)' specifiers, then it
2118 // specifies the natural alignment for the type.
2119 if (OldAlign == 0 || NewAlign == 0) {
2120 QualType Ty;
2121 if (ValueDecl *VD = dyn_cast<ValueDecl>(New))
2122 Ty = VD->getType();
2123 else
2124 Ty = S.Context.getTagDeclType(cast<TagDecl>(New));
2125
2126 if (OldAlign == 0)
2127 OldAlign = S.Context.getTypeAlign(Ty);
2128 if (NewAlign == 0)
2129 NewAlign = S.Context.getTypeAlign(Ty);
2130 }
2131
2132 if (OldAlign != NewAlign) {
2133 S.Diag(NewAlignasAttr->getLocation(), diag::err_alignas_mismatch)
2134 << (unsigned)S.Context.toCharUnitsFromBits(OldAlign).getQuantity()
2135 << (unsigned)S.Context.toCharUnitsFromBits(NewAlign).getQuantity();
2136 S.Diag(OldAlignasAttr->getLocation(), diag::note_previous_declaration);
2137 }
2138 }
2139
2140 if (OldAlignasAttr && !NewAlignasAttr && isAttributeTargetADefinition(New)) {
2141 // C++11 [dcl.align]p6:
2142 // if any declaration of an entity has an alignment-specifier,
2143 // every defining declaration of that entity shall specify an
2144 // equivalent alignment.
2145 // C11 6.7.5/7:
2146 // If the definition of an object does not have an alignment
2147 // specifier, any other declaration of that object shall also
2148 // have no alignment specifier.
2149 S.Diag(New->getLocation(), diag::err_alignas_missing_on_definition)
Aaron Ballman3d216a52014-01-02 23:39:11 +00002150 << OldAlignasAttr;
Richard Smithbc8caaf2013-02-22 04:55:39 +00002151 S.Diag(OldAlignasAttr->getLocation(), diag::note_alignas_on_declaration)
Aaron Ballman3d216a52014-01-02 23:39:11 +00002152 << OldAlignasAttr;
Richard Smithbc8caaf2013-02-22 04:55:39 +00002153 }
2154
2155 bool AnyAdded = false;
2156
2157 // Ensure we have an attribute representing the strictest alignment.
2158 if (OldAlign > NewAlign) {
2159 AlignedAttr *Clone = OldStrictestAlignAttr->clone(S.Context);
2160 Clone->setInherited(true);
2161 New->addAttr(Clone);
2162 AnyAdded = true;
2163 }
2164
2165 // Ensure we have an alignas attribute if the old declaration had one.
2166 if (OldAlignasAttr && !NewAlignasAttr &&
2167 !(AnyAdded && OldStrictestAlignAttr->isAlignas())) {
2168 AlignedAttr *Clone = OldAlignasAttr->clone(S.Context);
2169 Clone->setInherited(true);
2170 New->addAttr(Clone);
2171 AnyAdded = true;
2172 }
2173
2174 return AnyAdded;
2175}
2176
Aaron Ballman7a2fb5f2014-04-17 20:08:36 +00002177static bool mergeDeclAttribute(Sema &S, NamedDecl *D,
2178 const InheritableAttr *Attr, bool Override) {
2179 InheritableAttr *NewAttr = nullptr;
Michael Han99315932013-01-24 16:46:58 +00002180 unsigned AttrSpellingListIndex = Attr->getSpellingListIndex();
Aaron Ballman7a2fb5f2014-04-17 20:08:36 +00002181 if (const auto *AA = dyn_cast<AvailabilityAttr>(Attr))
Richard Smithbc8caaf2013-02-22 04:55:39 +00002182 NewAttr = S.mergeAvailabilityAttr(D, AA->getRange(), AA->getPlatform(),
2183 AA->getIntroduced(), AA->getDeprecated(),
2184 AA->getObsoleted(), AA->getUnavailable(),
2185 AA->getMessage(), Override,
John McCalld041a9b2013-02-20 01:54:26 +00002186 AttrSpellingListIndex);
Aaron Ballman7a2fb5f2014-04-17 20:08:36 +00002187 else if (const auto *VA = dyn_cast<VisibilityAttr>(Attr))
Richard Smithbc8caaf2013-02-22 04:55:39 +00002188 NewAttr = S.mergeVisibilityAttr(D, VA->getRange(), VA->getVisibility(),
2189 AttrSpellingListIndex);
Aaron Ballman7a2fb5f2014-04-17 20:08:36 +00002190 else if (const auto *VA = dyn_cast<TypeVisibilityAttr>(Attr))
Richard Smithbc8caaf2013-02-22 04:55:39 +00002191 NewAttr = S.mergeTypeVisibilityAttr(D, VA->getRange(), VA->getVisibility(),
2192 AttrSpellingListIndex);
Aaron Ballman7a2fb5f2014-04-17 20:08:36 +00002193 else if (const auto *ImportA = dyn_cast<DLLImportAttr>(Attr))
Richard Smithbc8caaf2013-02-22 04:55:39 +00002194 NewAttr = S.mergeDLLImportAttr(D, ImportA->getRange(),
2195 AttrSpellingListIndex);
Aaron Ballman7a2fb5f2014-04-17 20:08:36 +00002196 else if (const auto *ExportA = dyn_cast<DLLExportAttr>(Attr))
Richard Smithbc8caaf2013-02-22 04:55:39 +00002197 NewAttr = S.mergeDLLExportAttr(D, ExportA->getRange(),
2198 AttrSpellingListIndex);
Aaron Ballman7a2fb5f2014-04-17 20:08:36 +00002199 else if (const auto *FA = dyn_cast<FormatAttr>(Attr))
Richard Smithbc8caaf2013-02-22 04:55:39 +00002200 NewAttr = S.mergeFormatAttr(D, FA->getRange(), FA->getType(),
2201 FA->getFormatIdx(), FA->getFirstArg(),
2202 AttrSpellingListIndex);
Aaron Ballman7a2fb5f2014-04-17 20:08:36 +00002203 else if (const auto *SA = dyn_cast<SectionAttr>(Attr))
Richard Smithbc8caaf2013-02-22 04:55:39 +00002204 NewAttr = S.mergeSectionAttr(D, SA->getRange(), SA->getName(),
2205 AttrSpellingListIndex);
Aaron Ballman7a2fb5f2014-04-17 20:08:36 +00002206 else if (const auto *IA = dyn_cast<MSInheritanceAttr>(Attr))
David Majnemer4bb09802014-02-10 19:50:15 +00002207 NewAttr = S.mergeMSInheritanceAttr(D, IA->getRange(), IA->getBestCase(),
2208 AttrSpellingListIndex,
David Majnemer2c4e00a2014-01-29 22:07:36 +00002209 IA->getSemanticSpelling());
Paul Robinson30e41fb2014-12-15 18:57:28 +00002210 else if (const auto *AA = dyn_cast<AlwaysInlineAttr>(Attr))
Paul Robinson080b1f32015-01-13 18:34:56 +00002211 NewAttr = S.mergeAlwaysInlineAttr(D, AA->getRange(),
2212 &S.Context.Idents.get(AA->getSpelling()),
2213 AttrSpellingListIndex);
Paul Robinson30e41fb2014-12-15 18:57:28 +00002214 else if (const auto *MA = dyn_cast<MinSizeAttr>(Attr))
2215 NewAttr = S.mergeMinSizeAttr(D, MA->getRange(), AttrSpellingListIndex);
2216 else if (const auto *OA = dyn_cast<OptimizeNoneAttr>(Attr))
2217 NewAttr = S.mergeOptimizeNoneAttr(D, OA->getRange(), AttrSpellingListIndex);
Richard Smithbc8caaf2013-02-22 04:55:39 +00002218 else if (isa<AlignedAttr>(Attr))
2219 // AlignedAttrs are handled separately, because we need to handle all
2220 // such attributes on a declaration at the same time.
Aaron Ballman7a2fb5f2014-04-17 20:08:36 +00002221 NewAttr = nullptr;
Fariborz Jahanianb93355e2014-07-17 17:05:04 +00002222 else if (isa<DeprecatedAttr>(Attr) && Override)
2223 NewAttr = nullptr;
Aaron Ballmanb9023ed2014-01-20 18:07:09 +00002224 else if (Attr->duplicatesAllowed() || !DeclHasAttr(D, Attr))
Richard Smithbc8caaf2013-02-22 04:55:39 +00002225 NewAttr = cast<InheritableAttr>(Attr->clone(S.Context));
Rafael Espindolac67f2232012-05-10 02:50:16 +00002226
Rafael Espindolae200f1c2012-05-13 03:25:18 +00002227 if (NewAttr) {
Rafael Espindolac67f2232012-05-10 02:50:16 +00002228 NewAttr->setInherited(true);
2229 D->addAttr(NewAttr);
2230 return true;
2231 }
2232
2233 return false;
2234}
2235
Rafael Espindolaa5bba702012-07-15 01:05:36 +00002236static const Decl *getDefinition(const Decl *D) {
2237 if (const TagDecl *TD = dyn_cast<TagDecl>(D))
Rafael Espindola36191042012-05-18 01:47:00 +00002238 return TD->getDefinition();
Rafael Espindolad53ffa02013-10-22 21:39:03 +00002239 if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
2240 const VarDecl *Def = VD->getDefinition();
2241 if (Def)
2242 return Def;
2243 return VD->getActingDefinition();
2244 }
Rafael Espindolaa5bba702012-07-15 01:05:36 +00002245 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
Rafael Espindola36191042012-05-18 01:47:00 +00002246 const FunctionDecl* Def;
Rafael Espindolad53ffa02013-10-22 21:39:03 +00002247 if (FD->isDefined(Def))
Rafael Espindola36191042012-05-18 01:47:00 +00002248 return Def;
2249 }
Craig Topperc3ec1492014-05-26 06:22:03 +00002250 return nullptr;
Rafael Espindola36191042012-05-18 01:47:00 +00002251}
2252
Rafael Espindolafaf556b2012-07-15 01:33:40 +00002253static bool hasAttribute(const Decl *D, attr::Kind Kind) {
Aaron Ballmanb97112e2014-03-08 22:19:01 +00002254 for (const auto *Attribute : D->attrs())
Rafael Espindolafaf556b2012-07-15 01:33:40 +00002255 if (Attribute->getKind() == Kind)
2256 return true;
Rafael Espindolafaf556b2012-07-15 01:33:40 +00002257 return false;
2258}
2259
2260/// checkNewAttributesAfterDef - If we already have a definition, check that
2261/// there are no new attributes in this declaration.
2262static void checkNewAttributesAfterDef(Sema &S, Decl *New, const Decl *Old) {
2263 if (!New->hasAttrs())
2264 return;
2265
2266 const Decl *Def = getDefinition(Old);
2267 if (!Def || Def == New)
2268 return;
2269
2270 AttrVec &NewAttributes = New->getAttrs();
2271 for (unsigned I = 0, E = NewAttributes.size(); I != E;) {
2272 const Attr *NewAttribute = NewAttributes[I];
Rafael Espindolad53ffa02013-10-22 21:39:03 +00002273
2274 if (isa<AliasAttr>(NewAttribute)) {
David Majnemer6b903562015-01-19 10:21:22 +00002275 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(New))
2276 S.CheckForFunctionRedefinition(FD, cast<FunctionDecl>(Def));
2277 else {
2278 VarDecl *VD = cast<VarDecl>(New);
David Majnemer290d3472015-01-21 01:30:40 +00002279 unsigned Diag = cast<VarDecl>(Def)->isThisDeclarationADefinition() ==
2280 VarDecl::TentativeDefinition
2281 ? diag::err_alias_after_tentative
2282 : diag::err_redefinition;
2283 S.Diag(VD->getLocation(), Diag) << VD->getDeclName();
David Majnemer6b903562015-01-19 10:21:22 +00002284 S.Diag(Def->getLocation(), diag::note_previous_definition);
2285 VD->setInvalidDecl();
2286 }
Rafael Espindolad53ffa02013-10-22 21:39:03 +00002287 ++I;
2288 continue;
2289 }
2290
2291 if (const VarDecl *VD = dyn_cast<VarDecl>(Def)) {
2292 // Tentative definitions are only interesting for the alias check above.
2293 if (VD->isThisDeclarationADefinition() != VarDecl::Definition) {
2294 ++I;
2295 continue;
2296 }
2297 }
2298
Rafael Espindolafaf556b2012-07-15 01:33:40 +00002299 if (hasAttribute(Def, NewAttribute->getKind())) {
2300 ++I;
2301 continue; // regular attr merging will take care of validating this.
2302 }
Richard Smithbc8caaf2013-02-22 04:55:39 +00002303
Richard Smithdebc59d2013-01-30 05:45:05 +00002304 if (isa<C11NoReturnAttr>(NewAttribute)) {
Richard Smithbc8caaf2013-02-22 04:55:39 +00002305 // C's _Noreturn is allowed to be added to a function after it is defined.
Richard Smithdebc59d2013-01-30 05:45:05 +00002306 ++I;
2307 continue;
Richard Smithbc8caaf2013-02-22 04:55:39 +00002308 } else if (const AlignedAttr *AA = dyn_cast<AlignedAttr>(NewAttribute)) {
2309 if (AA->isAlignas()) {
2310 // C++11 [dcl.align]p6:
2311 // if any declaration of an entity has an alignment-specifier,
2312 // every defining declaration of that entity shall specify an
2313 // equivalent alignment.
2314 // C11 6.7.5/7:
2315 // If the definition of an object does not have an alignment
2316 // specifier, any other declaration of that object shall also
2317 // have no alignment specifier.
2318 S.Diag(Def->getLocation(), diag::err_alignas_missing_on_definition)
Aaron Ballman3d216a52014-01-02 23:39:11 +00002319 << AA;
Richard Smithbc8caaf2013-02-22 04:55:39 +00002320 S.Diag(NewAttribute->getLocation(), diag::note_alignas_on_declaration)
Aaron Ballman3d216a52014-01-02 23:39:11 +00002321 << AA;
Richard Smithbc8caaf2013-02-22 04:55:39 +00002322 NewAttributes.erase(NewAttributes.begin() + I);
2323 --E;
2324 continue;
2325 }
Richard Smithdebc59d2013-01-30 05:45:05 +00002326 }
Richard Smithbc8caaf2013-02-22 04:55:39 +00002327
Rafael Espindolafaf556b2012-07-15 01:33:40 +00002328 S.Diag(NewAttribute->getLocation(),
2329 diag::warn_attribute_precede_definition);
2330 S.Diag(Def->getLocation(), diag::note_previous_definition);
2331 NewAttributes.erase(NewAttributes.begin() + I);
2332 --E;
2333 }
2334}
2335
John McCallf79e87d2011-03-02 04:00:57 +00002336/// mergeDeclAttributes - Copy attributes from the Old decl to the New one.
Rafael Espindolaa3aea432013-01-08 22:04:34 +00002337void Sema::mergeDeclAttributes(NamedDecl *New, Decl *Old,
Douglas Gregor66a8ca02013-01-15 22:43:08 +00002338 AvailabilityMergeKind AMK) {
Rafael Espindolab0938852013-10-25 01:28:12 +00002339 if (UsedAttr *OldAttr = Old->getMostRecentDecl()->getAttr<UsedAttr>()) {
2340 UsedAttr *NewAttr = OldAttr->clone(Context);
2341 NewAttr->setInherited(true);
2342 New->addAttr(NewAttr);
2343 }
2344
Richard Smithe233fbf2013-01-28 22:42:45 +00002345 if (!Old->hasAttrs() && !New->hasAttrs())
2346 return;
2347
Rafael Espindola36191042012-05-18 01:47:00 +00002348 // attributes declared post-definition are currently ignored
Rafael Espindolafaf556b2012-07-15 01:33:40 +00002349 checkNewAttributesAfterDef(*this, New, Old);
Rafael Espindola36191042012-05-18 01:47:00 +00002350
Douglas Gregor32c17572012-01-01 20:30:41 +00002351 if (!Old->hasAttrs())
Alexis Huntdcfba7b2010-08-18 23:23:40 +00002352 return;
John McCallf79e87d2011-03-02 04:00:57 +00002353
Douglas Gregor32c17572012-01-01 20:30:41 +00002354 bool foundAny = New->hasAttrs();
John McCallf79e87d2011-03-02 04:00:57 +00002355
Alexis Huntdcfba7b2010-08-18 23:23:40 +00002356 // Ensure that any moving of objects within the allocated map is done before
2357 // we process them.
Douglas Gregor32c17572012-01-01 20:30:41 +00002358 if (!foundAny) New->setAttrs(AttrVec());
John McCallf79e87d2011-03-02 04:00:57 +00002359
Aaron Ballmanbe22bcb2014-03-10 17:08:28 +00002360 for (auto *I : Old->specific_attrs<InheritableAttr>()) {
Douglas Gregor66a8ca02013-01-15 22:43:08 +00002361 bool Override = false;
Douglas Gregorb1fa1482011-09-23 20:23:42 +00002362 // Ignore deprecated/unavailable/availability attributes if requested.
Aaron Ballmanbe22bcb2014-03-10 17:08:28 +00002363 if (isa<DeprecatedAttr>(I) ||
2364 isa<UnavailableAttr>(I) ||
2365 isa<AvailabilityAttr>(I)) {
Douglas Gregor66a8ca02013-01-15 22:43:08 +00002366 switch (AMK) {
2367 case AMK_None:
2368 continue;
John McCalld2930c22011-07-22 02:45:48 +00002369
Douglas Gregor66a8ca02013-01-15 22:43:08 +00002370 case AMK_Redeclaration:
2371 break;
2372
2373 case AMK_Override:
2374 Override = true;
2375 break;
2376 }
2377 }
2378
Rafael Espindolab0938852013-10-25 01:28:12 +00002379 // Already handled.
Aaron Ballmanbe22bcb2014-03-10 17:08:28 +00002380 if (isa<UsedAttr>(I))
Rafael Espindolab0938852013-10-25 01:28:12 +00002381 continue;
2382
Aaron Ballmanbe22bcb2014-03-10 17:08:28 +00002383 if (mergeDeclAttribute(*this, New, I, Override))
John McCallf79e87d2011-03-02 04:00:57 +00002384 foundAny = true;
Chris Lattner84966392008-03-03 03:28:21 +00002385 }
John McCallf79e87d2011-03-02 04:00:57 +00002386
Richard Smithbc8caaf2013-02-22 04:55:39 +00002387 if (mergeAlignedAttrs(*this, New, Old))
2388 foundAny = true;
2389
Douglas Gregor32c17572012-01-01 20:30:41 +00002390 if (!foundAny) New->dropAttrs();
John McCallf79e87d2011-03-02 04:00:57 +00002391}
2392
2393/// mergeParamDeclAttributes - Copy attributes from the old parameter
2394/// to the new one.
2395static void mergeParamDeclAttributes(ParmVarDecl *newDecl,
2396 const ParmVarDecl *oldDecl,
Richard Smithe233fbf2013-01-28 22:42:45 +00002397 Sema &S) {
2398 // C++11 [dcl.attr.depend]p2:
2399 // The first declaration of a function shall specify the
2400 // carries_dependency attribute for its declarator-id if any declaration
2401 // of the function specifies the carries_dependency attribute.
Aaron Ballmancf3b4832013-12-19 13:36:16 +00002402 const CarriesDependencyAttr *CDA = newDecl->getAttr<CarriesDependencyAttr>();
2403 if (CDA && !oldDecl->hasAttr<CarriesDependencyAttr>()) {
2404 S.Diag(CDA->getLocation(),
Richard Smithe233fbf2013-01-28 22:42:45 +00002405 diag::err_carries_dependency_missing_on_first_decl) << 1/*Param*/;
2406 // Find the first declaration of the parameter.
2407 // FIXME: Should we build redeclaration chains for function parameters?
2408 const FunctionDecl *FirstFD =
Rafael Espindola8db352d2013-10-17 15:37:26 +00002409 cast<FunctionDecl>(oldDecl->getDeclContext())->getFirstDecl();
Richard Smithe233fbf2013-01-28 22:42:45 +00002410 const ParmVarDecl *FirstVD =
2411 FirstFD->getParamDecl(oldDecl->getFunctionScopeIndex());
2412 S.Diag(FirstVD->getLocation(),
2413 diag::note_carries_dependency_missing_first_decl) << 1/*Param*/;
2414 }
2415
John McCallf79e87d2011-03-02 04:00:57 +00002416 if (!oldDecl->hasAttrs())
2417 return;
2418
2419 bool foundAny = newDecl->hasAttrs();
2420
2421 // Ensure that any moving of objects within the allocated map is
2422 // done before we process them.
2423 if (!foundAny) newDecl->setAttrs(AttrVec());
2424
Aaron Ballmanbe22bcb2014-03-10 17:08:28 +00002425 for (const auto *I : oldDecl->specific_attrs<InheritableParamAttr>()) {
2426 if (!DeclHasAttr(newDecl, I)) {
Richard Smithe233fbf2013-01-28 22:42:45 +00002427 InheritableAttr *newAttr =
Aaron Ballmanbe22bcb2014-03-10 17:08:28 +00002428 cast<InheritableParamAttr>(I->clone(S.Context));
John McCallf79e87d2011-03-02 04:00:57 +00002429 newAttr->setInherited(true);
2430 newDecl->addAttr(newAttr);
2431 foundAny = true;
2432 }
2433 }
2434
2435 if (!foundAny) newDecl->dropAttrs();
Chris Lattner84966392008-03-03 03:28:21 +00002436}
2437
Douglas Gregor261a89b2015-06-19 17:51:05 +00002438static void mergeParamDeclTypes(ParmVarDecl *NewParam,
2439 const ParmVarDecl *OldParam,
2440 Sema &S) {
2441 if (auto Oldnullability = OldParam->getType()->getNullability(S.Context)) {
2442 if (auto Newnullability = NewParam->getType()->getNullability(S.Context)) {
2443 if (*Oldnullability != *Newnullability) {
2444 S.Diag(NewParam->getLocation(), diag::warn_mismatched_nullability_attr)
Douglas Gregoraea7afd2015-06-24 22:02:08 +00002445 << DiagNullabilityKind(
2446 *Newnullability,
2447 ((NewParam->getObjCDeclQualifier() & Decl::OBJC_TQ_CSNullability)
2448 != 0))
2449 << DiagNullabilityKind(
2450 *Oldnullability,
2451 ((OldParam->getObjCDeclQualifier() & Decl::OBJC_TQ_CSNullability)
2452 != 0));
Douglas Gregor261a89b2015-06-19 17:51:05 +00002453 S.Diag(OldParam->getLocation(), diag::note_previous_declaration);
2454 }
Douglas Gregor83e32982015-06-22 17:19:03 +00002455 } else {
Douglas Gregor261a89b2015-06-19 17:51:05 +00002456 QualType NewT = NewParam->getType();
2457 NewT = S.Context.getAttributedType(
2458 AttributedType::getNullabilityAttrKind(*Oldnullability),
2459 NewT, NewT);
2460 NewParam->setType(NewT);
2461 }
2462 }
2463}
2464
Dan Gohman28ade552010-07-26 21:25:24 +00002465namespace {
2466
Douglas Gregora74a2972009-03-06 22:43:54 +00002467/// Used in MergeFunctionDecl to keep track of function parameters in
2468/// C.
2469struct GNUCompatibleParamWarning {
2470 ParmVarDecl *OldParm;
2471 ParmVarDecl *NewParm;
2472 QualType PromotedType;
2473};
2474
Alexander Kornienkoab9db512015-06-22 23:07:51 +00002475}
Anders Carlsson1f78b2b2009-12-04 22:33:25 +00002476
2477/// getSpecialMember - get the special member enum for a method.
Anders Carlsson05bf0092010-04-22 05:40:53 +00002478Sema::CXXSpecialMember Sema::getSpecialMember(const CXXMethodDecl *MD) {
Anders Carlsson1f78b2b2009-12-04 22:33:25 +00002479 if (const CXXConstructorDecl *Ctor = dyn_cast<CXXConstructorDecl>(MD)) {
Alexis Hunt80f00ff2011-05-10 19:08:14 +00002480 if (Ctor->isDefaultConstructor())
2481 return Sema::CXXDefaultConstructor;
Alexis Huntd051b872011-05-26 01:26:05 +00002482
2483 if (Ctor->isCopyConstructor())
2484 return Sema::CXXCopyConstructor;
2485
2486 if (Ctor->isMoveConstructor())
2487 return Sema::CXXMoveConstructor;
Alexis Hunt119c10e2011-05-25 23:16:36 +00002488 } else if (isa<CXXDestructorDecl>(MD)) {
Anders Carlsson1f78b2b2009-12-04 22:33:25 +00002489 return Sema::CXXDestructor;
Alexis Hunt119c10e2011-05-25 23:16:36 +00002490 } else if (MD->isCopyAssignmentOperator()) {
Alexis Hunt80f00ff2011-05-10 19:08:14 +00002491 return Sema::CXXCopyAssignment;
Sebastian Redle9c4e842011-09-04 18:14:28 +00002492 } else if (MD->isMoveAssignmentOperator()) {
2493 return Sema::CXXMoveAssignment;
Alexis Hunt119c10e2011-05-25 23:16:36 +00002494 }
Alexis Hunt80f00ff2011-05-10 19:08:14 +00002495
Alexis Hunt80f00ff2011-05-10 19:08:14 +00002496 return Sema::CXXInvalid;
Anders Carlsson1f78b2b2009-12-04 22:33:25 +00002497}
2498
David Majnemer5b63fa02014-06-18 23:26:25 +00002499// Determine whether the previous declaration was a definition, implicit
2500// declaration, or a declaration.
2501template <typename T>
2502static std::pair<diag::kind, SourceLocation>
2503getNoteDiagForInvalidRedeclaration(const T *Old, const T *New) {
2504 diag::kind PrevDiag;
2505 SourceLocation OldLocation = Old->getLocation();
2506 if (Old->isThisDeclarationADefinition())
2507 PrevDiag = diag::note_previous_definition;
2508 else if (Old->isImplicit()) {
2509 PrevDiag = diag::note_previous_implicit_declaration;
2510 if (OldLocation.isInvalid())
2511 OldLocation = New->getLocation();
2512 } else
2513 PrevDiag = diag::note_previous_declaration;
2514 return std::make_pair(PrevDiag, OldLocation);
2515}
2516
Sebastian Redl243d9052010-06-09 21:17:41 +00002517/// canRedefineFunction - checks if a function can be redefined. Currently,
Charles Davisfea48452010-02-18 02:00:42 +00002518/// only extern inline functions can be redefined, and even then only in
2519/// GNU89 mode.
2520static bool canRedefineFunction(const FunctionDecl *FD,
2521 const LangOptions& LangOpts) {
Eli Friedman51dd0182011-06-13 23:56:42 +00002522 return ((FD->hasAttr<GNUInlineAttr>() || LangOpts.GNUInline) &&
2523 !LangOpts.CPlusPlus &&
Charles Davisfea48452010-02-18 02:00:42 +00002524 FD->isInlineSpecified() &&
John McCall8e7d6562010-08-26 03:08:43 +00002525 FD->getStorageClass() == SC_Extern);
Charles Davisfea48452010-02-18 02:00:42 +00002526}
2527
Reid Kleckner78af0702013-08-27 23:08:25 +00002528const AttributedType *Sema::getCallingConvAttributedType(QualType T) const {
2529 const AttributedType *AT = T->getAs<AttributedType>();
2530 while (AT && !AT->isCallingConv())
2531 AT = AT->getModifiedType()->getAs<AttributedType>();
2532 return AT;
John McCalla5f46fb2012-08-25 02:00:03 +00002533}
2534
Benjamin Kramer3e350262013-02-15 12:30:38 +00002535template <typename T>
2536static bool haveIncompatibleLanguageLinkages(const T *Old, const T *New) {
Rafael Espindolaf4187652013-02-14 01:18:37 +00002537 const DeclContext *DC = Old->getDeclContext();
2538 if (DC->isRecord())
2539 return false;
2540
2541 LanguageLinkage OldLinkage = Old->getLanguageLinkage();
Rafael Espindola593537a2013-05-05 20:15:21 +00002542 if (OldLinkage == CXXLanguageLinkage && New->isInExternCContext())
Rafael Espindolaf4187652013-02-14 01:18:37 +00002543 return true;
Rafael Espindola593537a2013-05-05 20:15:21 +00002544 if (OldLinkage == CLanguageLinkage && New->isInExternCXXContext())
Rafael Espindolaf4187652013-02-14 01:18:37 +00002545 return true;
2546 return false;
2547}
2548
Richard Smithfc805ca2015-07-06 04:43:58 +00002549template<typename T> static bool isExternC(T *D) { return D->isExternC(); }
2550static bool isExternC(VarTemplateDecl *) { return false; }
2551
2552/// \brief Check whether a redeclaration of an entity introduced by a
2553/// using-declaration is valid, given that we know it's not an overload
2554/// (nor a hidden tag declaration).
2555template<typename ExpectedDecl>
2556static bool checkUsingShadowRedecl(Sema &S, UsingShadowDecl *OldS,
2557 ExpectedDecl *New) {
2558 // C++11 [basic.scope.declarative]p4:
2559 // Given a set of declarations in a single declarative region, each of
2560 // which specifies the same unqualified name,
2561 // -- they shall all refer to the same entity, or all refer to functions
2562 // and function templates; or
2563 // -- exactly one declaration shall declare a class name or enumeration
2564 // name that is not a typedef name and the other declarations shall all
2565 // refer to the same variable or enumerator, or all refer to functions
2566 // and function templates; in this case the class name or enumeration
2567 // name is hidden (3.3.10).
2568
2569 // C++11 [namespace.udecl]p14:
2570 // If a function declaration in namespace scope or block scope has the
2571 // same name and the same parameter-type-list as a function introduced
2572 // by a using-declaration, and the declarations do not declare the same
2573 // function, the program is ill-formed.
2574
2575 auto *Old = dyn_cast<ExpectedDecl>(OldS->getTargetDecl());
2576 if (Old &&
2577 !Old->getDeclContext()->getRedeclContext()->Equals(
2578 New->getDeclContext()->getRedeclContext()) &&
2579 !(isExternC(Old) && isExternC(New)))
2580 Old = nullptr;
2581
2582 if (!Old) {
2583 S.Diag(New->getLocation(), diag::err_using_decl_conflict_reverse);
2584 S.Diag(OldS->getTargetDecl()->getLocation(), diag::note_using_decl_target);
2585 S.Diag(OldS->getUsingDecl()->getLocation(), diag::note_using_decl) << 0;
2586 return true;
2587 }
2588 return false;
2589}
2590
Chris Lattneraa9c7ae2008-04-08 04:40:51 +00002591/// MergeFunctionDecl - We just parsed a function 'New' from
2592/// declarator D which has the same name and scope as a previous
2593/// declaration 'Old'. Figure out how to resolve this situation,
2594/// merging decls or emitting diagnostics as appropriate.
Douglas Gregor5251f1b2008-10-21 16:13:35 +00002595///
2596/// In C++, New and Old must be declarations that are not
2597/// overloaded. Use IsOverload to determine whether New and Old are
2598/// overloaded, and to select the Old declaration that New should be
2599/// merged with.
Douglas Gregor75a45ba2009-02-16 17:45:42 +00002600///
2601/// Returns true if there was an error, false otherwise.
Richard Smith18819302014-02-06 01:31:33 +00002602bool Sema::MergeFunctionDecl(FunctionDecl *New, NamedDecl *&OldD,
2603 Scope *S, bool MergeTypeWithOld) {
Chris Lattnerc511efb2007-01-27 19:32:14 +00002604 // Verify the old decl was also a function.
Alp Tokera2794f92014-01-22 07:29:52 +00002605 FunctionDecl *Old = OldD->getAsFunction();
Chris Lattnerc511efb2007-01-27 19:32:14 +00002606 if (!Old) {
John McCalle29c5cd2009-12-10 19:51:03 +00002607 if (UsingShadowDecl *Shadow = dyn_cast<UsingShadowDecl>(OldD)) {
John McCallc70fca62013-04-03 21:19:47 +00002608 if (New->getFriendObjectKind()) {
2609 Diag(New->getLocation(), diag::err_using_decl_friend);
2610 Diag(Shadow->getTargetDecl()->getLocation(),
2611 diag::note_using_decl_target);
2612 Diag(Shadow->getUsingDecl()->getLocation(),
2613 diag::note_using_decl) << 0;
2614 return true;
2615 }
2616
Richard Smith18819302014-02-06 01:31:33 +00002617 // Check whether the two declarations might declare the same function.
Richard Smithfc805ca2015-07-06 04:43:58 +00002618 if (checkUsingShadowRedecl<FunctionDecl>(*this, Shadow, New))
Richard Smith18819302014-02-06 01:31:33 +00002619 return true;
Richard Smithfc805ca2015-07-06 04:43:58 +00002620 OldD = Old = cast<FunctionDecl>(Shadow->getTargetDecl());
Richard Smith18819302014-02-06 01:31:33 +00002621 } else {
2622 Diag(New->getLocation(), diag::err_redefinition_different_kind)
2623 << New->getDeclName();
2624 Diag(OldD->getLocation(), diag::note_previous_definition);
John McCalle29c5cd2009-12-10 19:51:03 +00002625 return true;
2626 }
Chris Lattnerc511efb2007-01-27 19:32:14 +00002627 }
Douglas Gregor5251f1b2008-10-21 16:13:35 +00002628
David Majnemerea5092a2013-07-07 23:49:50 +00002629 // If the old declaration is invalid, just give up here.
2630 if (Old->isInvalidDecl())
2631 return true;
2632
Douglas Gregor5251f1b2008-10-21 16:13:35 +00002633 diag::kind PrevDiag;
David Majnemer5b63fa02014-06-18 23:26:25 +00002634 SourceLocation OldLocation;
2635 std::tie(PrevDiag, OldLocation) =
2636 getNoteDiagForInvalidRedeclaration(Old, New);
Mike Stump11289f42009-09-09 15:08:12 +00002637
Charles Davisfea48452010-02-18 02:00:42 +00002638 // Don't complain about this if we're in GNU89 mode and the old function
2639 // is an extern inline function.
Rafael Espindola6ae7e502013-04-03 19:27:57 +00002640 // Don't complain about specializations. They are not supposed to have
2641 // storage classes.
Douglas Gregore62c0a42009-02-24 01:23:02 +00002642 if (!isa<CXXMethodDecl>(New) && !isa<CXXMethodDecl>(Old) &&
John McCall8e7d6562010-08-26 03:08:43 +00002643 New->getStorageClass() == SC_Static &&
Rafael Espindola3ae00052013-05-13 00:12:11 +00002644 Old->hasExternalFormalLinkage() &&
Rafael Espindola6ae7e502013-04-03 19:27:57 +00002645 !New->getTemplateSpecializationInfo() &&
David Blaikiebbafb8a2012-03-11 07:00:24 +00002646 !canRedefineFunction(Old, getLangOpts())) {
2647 if (getLangOpts().MicrosoftExt) {
David Majnemer5b63fa02014-06-18 23:26:25 +00002648 Diag(New->getLocation(), diag::ext_static_non_static) << New;
Richard Smithbdd14642014-02-04 01:14:30 +00002649 Diag(OldLocation, PrevDiag);
Francois Pichet6841a122011-04-22 19:50:06 +00002650 } else {
2651 Diag(New->getLocation(), diag::err_static_non_static) << New;
Richard Smithbdd14642014-02-04 01:14:30 +00002652 Diag(OldLocation, PrevDiag);
Francois Pichet6841a122011-04-22 19:50:06 +00002653 return true;
2654 }
Douglas Gregore62c0a42009-02-24 01:23:02 +00002655 }
2656
Reid Kleckner78af0702013-08-27 23:08:25 +00002657
2658 // If a function is first declared with a calling convention, but is later
2659 // declared or defined without one, all following decls assume the calling
2660 // convention of the first.
John McCallcddbad02010-02-04 05:44:44 +00002661 //
John McCalla5f46fb2012-08-25 02:00:03 +00002662 // It's OK if a function is first declared without a calling convention,
2663 // but is later declared or defined with the default calling convention.
2664 //
Reid Kleckner78af0702013-08-27 23:08:25 +00002665 // To test if either decl has an explicit calling convention, we look for
2666 // AttributedType sugar nodes on the type as written. If they are missing or
2667 // were canonicalized away, we assume the calling convention was implicit.
John McCallcddbad02010-02-04 05:44:44 +00002668 //
2669 // Note also that we DO NOT return at this point, because we still have
2670 // other tests to run.
Reid Kleckner78af0702013-08-27 23:08:25 +00002671 QualType OldQType = Context.getCanonicalType(Old->getType());
2672 QualType NewQType = Context.getCanonicalType(New->getType());
John McCall4f5019e2010-12-19 02:44:49 +00002673 const FunctionType *OldType = cast<FunctionType>(OldQType);
Reid Kleckner78af0702013-08-27 23:08:25 +00002674 const FunctionType *NewType = cast<FunctionType>(NewQType);
John McCall4f5019e2010-12-19 02:44:49 +00002675 FunctionType::ExtInfo OldTypeInfo = OldType->getExtInfo();
2676 FunctionType::ExtInfo NewTypeInfo = NewType->getExtInfo();
2677 bool RequiresAdjustment = false;
John McCalla5f46fb2012-08-25 02:00:03 +00002678
Reid Kleckner78af0702013-08-27 23:08:25 +00002679 if (OldTypeInfo.getCC() != NewTypeInfo.getCC()) {
Rafael Espindola8db352d2013-10-17 15:37:26 +00002680 FunctionDecl *First = Old->getFirstDecl();
Reid Kleckner78af0702013-08-27 23:08:25 +00002681 const FunctionType *FT =
2682 First->getType().getCanonicalType()->castAs<FunctionType>();
2683 FunctionType::ExtInfo FI = FT->getExtInfo();
2684 bool NewCCExplicit = getCallingConvAttributedType(New->getType());
2685 if (!NewCCExplicit) {
2686 // Inherit the CC from the previous declaration if it was specified
2687 // there but not here.
2688 NewTypeInfo = NewTypeInfo.withCallingConv(OldTypeInfo.getCC());
2689 RequiresAdjustment = true;
2690 } else {
2691 // Calling conventions aren't compatible, so complain.
2692 bool FirstCCExplicit = getCallingConvAttributedType(First->getType());
2693 Diag(New->getLocation(), diag::err_cconv_change)
2694 << FunctionType::getNameForCallConv(NewTypeInfo.getCC())
2695 << !FirstCCExplicit
2696 << (!FirstCCExplicit ? "" :
2697 FunctionType::getNameForCallConv(FI.getCC()));
John McCalla5f46fb2012-08-25 02:00:03 +00002698
Reid Kleckner78af0702013-08-27 23:08:25 +00002699 // Put the note on the first decl, since it is the one that matters.
2700 Diag(First->getLocation(), diag::note_previous_declaration);
2701 return true;
2702 }
John McCallcddbad02010-02-04 05:44:44 +00002703 }
2704
John McCallab26cfa2010-02-05 21:31:56 +00002705 // FIXME: diagnose the other way around?
John McCall4f5019e2010-12-19 02:44:49 +00002706 if (OldTypeInfo.getNoReturn() && !NewTypeInfo.getNoReturn()) {
2707 NewTypeInfo = NewTypeInfo.withNoReturn(true);
2708 RequiresAdjustment = true;
John McCallab26cfa2010-02-05 21:31:56 +00002709 }
2710
Douglas Gregor77e274f2010-06-18 21:30:25 +00002711 // Merge regparm attribute.
Eli Friedmanc5b20b52011-04-09 08:18:08 +00002712 if (OldTypeInfo.getHasRegParm() != NewTypeInfo.getHasRegParm() ||
2713 OldTypeInfo.getRegParm() != NewTypeInfo.getRegParm()) {
2714 if (NewTypeInfo.getHasRegParm()) {
Douglas Gregor77e274f2010-06-18 21:30:25 +00002715 Diag(New->getLocation(), diag::err_regparm_mismatch)
2716 << NewType->getRegParmType()
2717 << OldType->getRegParmType();
Richard Smithbdd14642014-02-04 01:14:30 +00002718 Diag(OldLocation, diag::note_previous_declaration);
Douglas Gregor77e274f2010-06-18 21:30:25 +00002719 return true;
2720 }
John McCall4f5019e2010-12-19 02:44:49 +00002721
2722 NewTypeInfo = NewTypeInfo.withRegParm(OldTypeInfo.getRegParm());
2723 RequiresAdjustment = true;
2724 }
2725
Douglas Gregorf1404d72011-10-14 15:55:40 +00002726 // Merge ns_returns_retained attribute.
2727 if (OldTypeInfo.getProducesResult() != NewTypeInfo.getProducesResult()) {
2728 if (NewTypeInfo.getProducesResult()) {
2729 Diag(New->getLocation(), diag::err_returns_retained_mismatch);
Richard Smithbdd14642014-02-04 01:14:30 +00002730 Diag(OldLocation, diag::note_previous_declaration);
Douglas Gregorf1404d72011-10-14 15:55:40 +00002731 return true;
2732 }
2733
2734 NewTypeInfo = NewTypeInfo.withProducesResult(true);
2735 RequiresAdjustment = true;
2736 }
2737
John McCall4f5019e2010-12-19 02:44:49 +00002738 if (RequiresAdjustment) {
Eli Friedmane934af82013-09-06 21:09:09 +00002739 const FunctionType *AdjustedType = New->getType()->getAs<FunctionType>();
2740 AdjustedType = Context.adjustFunctionType(AdjustedType, NewTypeInfo);
2741 New->setType(QualType(AdjustedType, 0));
John McCall4f5019e2010-12-19 02:44:49 +00002742 NewQType = Context.getCanonicalType(New->getType());
Eli Friedmane934af82013-09-06 21:09:09 +00002743 NewType = cast<FunctionType>(NewQType);
Douglas Gregor77e274f2010-06-18 21:30:25 +00002744 }
Nick Lewycky9c7eb1d2013-02-01 08:13:20 +00002745
2746 // If this redeclaration makes the function inline, we may need to add it to
2747 // UndefinedButUsed.
2748 if (!Old->isInlined() && New->isInlined() &&
2749 !New->hasAttr<GNUInlineAttr>() &&
Peter Collingbourne470d9422015-05-13 22:07:22 +00002750 !getLangOpts().GNUInline &&
Nick Lewycky9c7eb1d2013-02-01 08:13:20 +00002751 Old->isUsed(false) &&
2752 !Old->isDefined() && !New->isThisDeclarationADefinition())
2753 UndefinedButUsed.insert(std::make_pair(Old->getCanonicalDecl(),
2754 SourceLocation()));
2755
2756 // If this redeclaration makes it newly gnu_inline, we don't want to warn
2757 // about it.
2758 if (New->hasAttr<GNUInlineAttr>() &&
2759 Old->isInlined() && !Old->hasAttr<GNUInlineAttr>()) {
2760 UndefinedButUsed.erase(Old->getCanonicalDecl());
2761 }
Douglas Gregor77e274f2010-06-18 21:30:25 +00002762
David Blaikiebbafb8a2012-03-11 07:00:24 +00002763 if (getLangOpts().CPlusPlus) {
Douglas Gregor5251f1b2008-10-21 16:13:35 +00002764 // (C++98 13.1p2):
2765 // Certain function declarations cannot be overloaded:
Mike Stump11289f42009-09-09 15:08:12 +00002766 // -- Function declarations that differ only in the return type
Douglas Gregor5251f1b2008-10-21 16:13:35 +00002767 // cannot be overloaded.
Richard Smith2a7d4812013-05-04 07:00:32 +00002768
2769 // Go back to the type source info to compare the declared return types,
Richard Smithc58f38f2013-08-14 20:16:31 +00002770 // per C++1y [dcl.type.auto]p13:
Richard Smith2a7d4812013-05-04 07:00:32 +00002771 // Redeclarations or specializations of a function or function template
2772 // with a declared return type that uses a placeholder type shall also
2773 // use that placeholder, not a deduced type.
Alp Toker314cc812014-01-25 16:55:45 +00002774 QualType OldDeclaredReturnType =
2775 (Old->getTypeSourceInfo()
2776 ? Old->getTypeSourceInfo()->getType()->castAs<FunctionType>()
2777 : OldType)->getReturnType();
2778 QualType NewDeclaredReturnType =
2779 (New->getTypeSourceInfo()
2780 ? New->getTypeSourceInfo()->getType()->castAs<FunctionType>()
2781 : NewType)->getReturnType();
Fariborz Jahanianf633ebd2010-05-19 21:37:30 +00002782 QualType ResQT;
Richard Smith541b38b2013-09-20 01:15:31 +00002783 if (!Context.hasSameType(OldDeclaredReturnType, NewDeclaredReturnType) &&
2784 !((NewQType->isDependentType() || OldQType->isDependentType()) &&
2785 New->isLocalExternDecl())) {
Richard Smith2a7d4812013-05-04 07:00:32 +00002786 if (NewDeclaredReturnType->isObjCObjectPointerType() &&
2787 OldDeclaredReturnType->isObjCObjectPointerType())
Fariborz Jahanianf633ebd2010-05-19 21:37:30 +00002788 ResQT = Context.mergeObjCGCQualifiers(NewQType, OldQType);
2789 if (ResQT.isNull()) {
Argyrios Kyrtzidis3d320862011-02-05 05:54:49 +00002790 if (New->isCXXClassMember() && New->isOutOfLine())
Alp Tokerd0787eb2014-07-02 01:47:15 +00002791 Diag(New->getLocation(), diag::err_member_def_does_not_match_ret_type)
2792 << New << New->getReturnTypeSourceRange();
Argyrios Kyrtzidis3d320862011-02-05 05:54:49 +00002793 else
Alp Tokerd0787eb2014-07-02 01:47:15 +00002794 Diag(New->getLocation(), diag::err_ovl_diff_return_type)
2795 << New->getReturnTypeSourceRange();
2796 Diag(OldLocation, PrevDiag) << Old << Old->getType()
2797 << Old->getReturnTypeSourceRange();
Fariborz Jahanianf633ebd2010-05-19 21:37:30 +00002798 return true;
2799 }
2800 else
2801 NewQType = ResQT;
Douglas Gregor5251f1b2008-10-21 16:13:35 +00002802 }
2803
Alp Toker314cc812014-01-25 16:55:45 +00002804 QualType OldReturnType = OldType->getReturnType();
2805 QualType NewReturnType = cast<FunctionType>(NewQType)->getReturnType();
Richard Smith2a7d4812013-05-04 07:00:32 +00002806 if (OldReturnType != NewReturnType) {
2807 // If this function has a deduced return type and has already been
2808 // defined, copy the deduced value from the old declaration.
Alp Toker314cc812014-01-25 16:55:45 +00002809 AutoType *OldAT = Old->getReturnType()->getContainedAutoType();
Richard Smith2a7d4812013-05-04 07:00:32 +00002810 if (OldAT && OldAT->isDeduced()) {
Richard Smithc58f38f2013-08-14 20:16:31 +00002811 New->setType(
2812 SubstAutoType(New->getType(),
2813 OldAT->isDependentType() ? Context.DependentTy
2814 : OldAT->getDeducedType()));
Richard Smith2a7d4812013-05-04 07:00:32 +00002815 NewQType = Context.getCanonicalType(
Richard Smithc58f38f2013-08-14 20:16:31 +00002816 SubstAutoType(NewQType,
2817 OldAT->isDependentType() ? Context.DependentTy
2818 : OldAT->getDeducedType()));
Richard Smith2a7d4812013-05-04 07:00:32 +00002819 }
2820 }
2821
2822 const CXXMethodDecl *OldMethod = dyn_cast<CXXMethodDecl>(Old);
2823 CXXMethodDecl *NewMethod = dyn_cast<CXXMethodDecl>(New);
Anders Carlsson1f78b2b2009-12-04 22:33:25 +00002824 if (OldMethod && NewMethod) {
John McCall43314ab2010-04-13 07:45:41 +00002825 // Preserve triviality.
2826 NewMethod->setTrivial(OldMethod->isTrivial());
Francois Pichetc2fac712011-05-14 19:17:07 +00002827
Francois Pichet00c7e6c2011-08-14 03:52:19 +00002828 // MSVC allows explicit template specialization at class scope:
Alp Toker8db6e7a2014-01-05 06:38:57 +00002829 // 2 CXXMethodDecls referring to the same function will be injected.
2830 // We don't want a redeclaration error.
Francois Pichet00c7e6c2011-08-14 03:52:19 +00002831 bool IsClassScopeExplicitSpecialization =
2832 OldMethod->isFunctionTemplateSpecialization() &&
2833 NewMethod->isFunctionTemplateSpecialization();
John McCall43314ab2010-04-13 07:45:41 +00002834 bool isFriend = NewMethod->getFriendObjectKind();
2835
Francois Pichet00c7e6c2011-08-14 03:52:19 +00002836 if (!isFriend && NewMethod->getLexicalDeclContext()->isRecord() &&
2837 !IsClassScopeExplicitSpecialization) {
Anders Carlsson1f78b2b2009-12-04 22:33:25 +00002838 // -- Member function declarations with the same name and the
2839 // same parameter types cannot be overloaded if any of them
2840 // is a static member function declaration.
Eli Friedmanf26b81b2013-06-19 22:43:55 +00002841 if (OldMethod->isStatic() != NewMethod->isStatic()) {
Anders Carlsson1f78b2b2009-12-04 22:33:25 +00002842 Diag(New->getLocation(), diag::err_ovl_static_nonstatic_member);
Richard Smithbdd14642014-02-04 01:14:30 +00002843 Diag(OldLocation, PrevDiag) << Old << Old->getType();
Anders Carlsson1f78b2b2009-12-04 22:33:25 +00002844 return true;
2845 }
Richard Smith57e7ff92012-07-13 04:12:04 +00002846
Anders Carlsson1f78b2b2009-12-04 22:33:25 +00002847 // C++ [class.mem]p1:
2848 // [...] A member shall not be declared twice in the
2849 // member-specification, except that a nested class or member
2850 // class template can be declared and then later defined.
Richard Smith57e7ff92012-07-13 04:12:04 +00002851 if (ActiveTemplateInstantiations.empty()) {
2852 unsigned NewDiag;
2853 if (isa<CXXConstructorDecl>(OldMethod))
2854 NewDiag = diag::err_constructor_redeclared;
2855 else if (isa<CXXDestructorDecl>(NewMethod))
2856 NewDiag = diag::err_destructor_redeclared;
2857 else if (isa<CXXConversionDecl>(NewMethod))
2858 NewDiag = diag::err_conv_function_redeclared;
2859 else
2860 NewDiag = diag::err_member_redeclared;
Anders Carlsson1f78b2b2009-12-04 22:33:25 +00002861
Richard Smith57e7ff92012-07-13 04:12:04 +00002862 Diag(New->getLocation(), NewDiag);
2863 } else {
2864 Diag(New->getLocation(), diag::err_member_redeclared_in_instantiation)
2865 << New << New->getType();
2866 }
Richard Smithbdd14642014-02-04 01:14:30 +00002867 Diag(OldLocation, PrevDiag) << Old << Old->getType();
Nico Weber71e377d2015-01-17 02:33:17 +00002868 return true;
John McCall43314ab2010-04-13 07:45:41 +00002869
2870 // Complain if this is an explicit declaration of a special
2871 // member that was initially declared implicitly.
2872 //
2873 // As an exception, it's okay to befriend such methods in order
2874 // to permit the implicit constructor/destructor/operator calls.
2875 } else if (OldMethod->isImplicit()) {
2876 if (isFriend) {
2877 NewMethod->setImplicit();
2878 } else {
Anders Carlsson1f78b2b2009-12-04 22:33:25 +00002879 Diag(NewMethod->getLocation(),
2880 diag::err_definition_of_implicitly_declared_member)
Anders Carlsson05bf0092010-04-22 05:40:53 +00002881 << New << getSpecialMember(OldMethod);
Anders Carlsson1f78b2b2009-12-04 22:33:25 +00002882 return true;
2883 }
Richard Smith337a5a12012-06-08 01:30:54 +00002884 } else if (OldMethod->isExplicitlyDefaulted() && !isFriend) {
Alexis Hunt6d5b96c2011-05-10 00:49:42 +00002885 Diag(NewMethod->getLocation(),
2886 diag::err_definition_of_explicitly_defaulted_member)
2887 << getSpecialMember(OldMethod);
2888 return true;
Douglas Gregor5251f1b2008-10-21 16:13:35 +00002889 }
2890 }
2891
Richard Smith10876ef2013-01-17 01:30:42 +00002892 // C++11 [dcl.attr.noreturn]p1:
2893 // The first declaration of a function shall specify the noreturn
2894 // attribute if any declaration of that function specifies the noreturn
2895 // attribute.
Aaron Ballmancf3b4832013-12-19 13:36:16 +00002896 const CXX11NoReturnAttr *NRA = New->getAttr<CXX11NoReturnAttr>();
2897 if (NRA && !Old->hasAttr<CXX11NoReturnAttr>()) {
2898 Diag(NRA->getLocation(), diag::err_noreturn_missing_on_first_decl);
Rafael Espindola8db352d2013-10-17 15:37:26 +00002899 Diag(Old->getFirstDecl()->getLocation(),
Richard Smith10876ef2013-01-17 01:30:42 +00002900 diag::note_noreturn_missing_first_decl);
2901 }
2902
Richard Smithe233fbf2013-01-28 22:42:45 +00002903 // C++11 [dcl.attr.depend]p2:
2904 // The first declaration of a function shall specify the
2905 // carries_dependency attribute for its declarator-id if any declaration
2906 // of the function specifies the carries_dependency attribute.
Aaron Ballmancf3b4832013-12-19 13:36:16 +00002907 const CarriesDependencyAttr *CDA = New->getAttr<CarriesDependencyAttr>();
2908 if (CDA && !Old->hasAttr<CarriesDependencyAttr>()) {
2909 Diag(CDA->getLocation(),
Richard Smithe233fbf2013-01-28 22:42:45 +00002910 diag::err_carries_dependency_missing_on_first_decl) << 0/*Function*/;
Rafael Espindola8db352d2013-10-17 15:37:26 +00002911 Diag(Old->getFirstDecl()->getLocation(),
Richard Smithe233fbf2013-01-28 22:42:45 +00002912 diag::note_carries_dependency_missing_first_decl) << 0/*Function*/;
2913 }
2914
Douglas Gregor5251f1b2008-10-21 16:13:35 +00002915 // (C++98 8.3.5p3):
2916 // All declarations for a function shall agree exactly in both the
2917 // return type and the parameter-type-list.
John McCall4f5019e2010-12-19 02:44:49 +00002918 // We also want to respect all the extended bits except noreturn.
2919
2920 // noreturn should now match unless the old type info didn't have it.
2921 QualType OldQTypeForComparison = OldQType;
2922 if (!OldTypeInfo.getNoReturn() && NewTypeInfo.getNoReturn()) {
2923 assert(OldQType == QualType(OldType, 0));
2924 const FunctionType *OldTypeForComparison
2925 = Context.adjustFunctionType(OldType, OldTypeInfo.withNoReturn(true));
2926 OldQTypeForComparison = QualType(OldTypeForComparison, 0);
2927 assert(OldQTypeForComparison.isCanonical());
2928 }
2929
Rafael Espindolaf4187652013-02-14 01:18:37 +00002930 if (haveIncompatibleLanguageLinkages(Old, New)) {
Alp Tokerdd551fc2013-10-22 22:53:01 +00002931 // As a special case, retain the language linkage from previous
2932 // declarations of a friend function as an extension.
2933 //
2934 // This liberal interpretation of C++ [class.friend]p3 matches GCC/MSVC
2935 // and is useful because there's otherwise no way to specify language
2936 // linkage within class scope.
2937 //
2938 // Check cautiously as the friend object kind isn't yet complete.
2939 if (New->getFriendObjectKind() != Decl::FOK_None) {
2940 Diag(New->getLocation(), diag::ext_retained_language_linkage) << New;
Richard Smithbdd14642014-02-04 01:14:30 +00002941 Diag(OldLocation, PrevDiag);
Alp Tokerdd551fc2013-10-22 22:53:01 +00002942 } else {
2943 Diag(New->getLocation(), diag::err_different_language_linkage) << New;
Richard Smithbdd14642014-02-04 01:14:30 +00002944 Diag(OldLocation, PrevDiag);
Alp Tokerdd551fc2013-10-22 22:53:01 +00002945 return true;
2946 }
Rafael Espindolacffa95d2012-12-27 03:56:20 +00002947 }
2948
John McCall4f5019e2010-12-19 02:44:49 +00002949 if (OldQTypeForComparison == NewQType)
Richard Smith1c34fb72013-08-13 18:18:50 +00002950 return MergeCompatibleFunctionDecls(New, Old, S, MergeTypeWithOld);
Douglas Gregor5251f1b2008-10-21 16:13:35 +00002951
Richard Smith541b38b2013-09-20 01:15:31 +00002952 if ((NewQType->isDependentType() || OldQType->isDependentType()) &&
2953 New->isLocalExternDecl()) {
2954 // It's OK if we couldn't merge types for a local function declaraton
2955 // if either the old or new type is dependent. We'll merge the types
2956 // when we instantiate the function.
2957 return false;
2958 }
2959
Douglas Gregor5251f1b2008-10-21 16:13:35 +00002960 // Fall through for conflicting redeclarations and redefinitions.
Douglas Gregor89f238c2008-04-21 02:02:58 +00002961 }
Chris Lattneraa9c7ae2008-04-08 04:40:51 +00002962
2963 // C: Function types need to be compatible, not identical. This handles
Steve Naroff012484d2008-01-14 20:51:29 +00002964 // duplicate function decls like "void f(int); void f(enum X);" properly.
David Blaikiebbafb8a2012-03-11 07:00:24 +00002965 if (!getLangOpts().CPlusPlus &&
Eli Friedman47f77112008-08-22 00:56:42 +00002966 Context.typesAreCompatible(OldQType, NewQType)) {
John McCall9dd450b2009-09-21 23:43:11 +00002967 const FunctionType *OldFuncType = OldQType->getAs<FunctionType>();
2968 const FunctionType *NewFuncType = NewQType->getAs<FunctionType>();
Craig Topperc3ec1492014-05-26 06:22:03 +00002969 const FunctionProtoType *OldProto = nullptr;
Richard Smith1c34fb72013-08-13 18:18:50 +00002970 if (MergeTypeWithOld && isa<FunctionNoProtoType>(NewFuncType) &&
Douglas Gregora74a2972009-03-06 22:43:54 +00002971 (OldProto = dyn_cast<FunctionProtoType>(OldFuncType))) {
Douglas Gregorbcbf8632009-02-16 18:20:44 +00002972 // The old declaration provided a function prototype, but the
2973 // new declaration does not. Merge in the prototype.
Sebastian Redl5068f77ac2009-05-27 22:11:52 +00002974 assert(!OldProto->hasExceptionSpec() && "Exception spec in C");
Aaron Ballman40bd0aa2014-03-17 15:23:01 +00002975 SmallVector<QualType, 16> ParamTypes(OldProto->param_types());
Alp Toker314cc812014-01-25 16:55:45 +00002976 NewQType =
2977 Context.getFunctionType(NewFuncType->getReturnType(), ParamTypes,
2978 OldProto->getExtProtoInfo());
Douglas Gregorbcbf8632009-02-16 18:20:44 +00002979 New->setType(NewQType);
Anders Carlssone0dd1d52009-05-14 21:46:00 +00002980 New->setHasInheritedPrototype();
Douglas Gregorbfdd6072009-02-16 20:58:07 +00002981
Alp Toker4284c6e2014-05-11 16:05:55 +00002982 // Synthesize parameters with the same types.
Chris Lattner0e62c1c2011-07-23 10:55:15 +00002983 SmallVector<ParmVarDecl*, 16> Params;
Aaron Ballman40bd0aa2014-03-17 15:23:01 +00002984 for (const auto &ParamType : OldProto->param_types()) {
2985 ParmVarDecl *Param = ParmVarDecl::Create(Context, New, SourceLocation(),
Craig Topperc3ec1492014-05-26 06:22:03 +00002986 SourceLocation(), nullptr,
2987 ParamType, /*TInfo=*/nullptr,
2988 SC_None, nullptr);
John McCall8fb0d9d2011-05-01 22:35:37 +00002989 Param->setScopeInfo(0, Params.size());
Douglas Gregorbfdd6072009-02-16 20:58:07 +00002990 Param->setImplicit();
2991 Params.push_back(Param);
2992 }
2993
David Blaikie9c70e042011-09-21 18:16:56 +00002994 New->setParams(Params);
Mike Stump11289f42009-09-09 15:08:12 +00002995 }
Douglas Gregorbcbf8632009-02-16 18:20:44 +00002996
Richard Smith1c34fb72013-08-13 18:18:50 +00002997 return MergeCompatibleFunctionDecls(New, Old, S, MergeTypeWithOld);
Chris Lattneraa9c7ae2008-04-08 04:40:51 +00002998 }
Chris Lattner45d561a2007-11-06 06:07:26 +00002999
Douglas Gregora74a2972009-03-06 22:43:54 +00003000 // GNU C permits a K&R definition to follow a prototype declaration
3001 // if the declared types of the parameters in the K&R definition
3002 // match the types in the prototype declaration, even when the
3003 // promoted types of the parameters from the K&R definition differ
3004 // from the types in the prototype. GCC then keeps the types from
3005 // the prototype.
Eli Friedmanfcbf7d22009-06-01 09:24:59 +00003006 //
3007 // If a variadic prototype is followed by a non-variadic K&R definition,
3008 // the K&R definition becomes variadic. This is sort of an edge case, but
3009 // it's legal per the standard depending on how you read C99 6.7.5.3p15 and
3010 // C99 6.9.1p8.
David Blaikiebbafb8a2012-03-11 07:00:24 +00003011 if (!getLangOpts().CPlusPlus &&
Douglas Gregora74a2972009-03-06 22:43:54 +00003012 Old->hasPrototype() && !New->hasPrototype() &&
John McCall9dd450b2009-09-21 23:43:11 +00003013 New->getType()->getAs<FunctionProtoType>() &&
Douglas Gregora74a2972009-03-06 22:43:54 +00003014 Old->getNumParams() == New->getNumParams()) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003015 SmallVector<QualType, 16> ArgTypes;
3016 SmallVector<GNUCompatibleParamWarning, 16> Warnings;
Mike Stump11289f42009-09-09 15:08:12 +00003017 const FunctionProtoType *OldProto
John McCall9dd450b2009-09-21 23:43:11 +00003018 = Old->getType()->getAs<FunctionProtoType>();
Mike Stump11289f42009-09-09 15:08:12 +00003019 const FunctionProtoType *NewProto
John McCall9dd450b2009-09-21 23:43:11 +00003020 = New->getType()->getAs<FunctionProtoType>();
Mike Stump11289f42009-09-09 15:08:12 +00003021
Douglas Gregora74a2972009-03-06 22:43:54 +00003022 // Determine whether this is the GNU C extension.
Alp Toker314cc812014-01-25 16:55:45 +00003023 QualType MergedReturn = Context.mergeTypes(OldProto->getReturnType(),
3024 NewProto->getReturnType());
Eli Friedmanfcbf7d22009-06-01 09:24:59 +00003025 bool LooseCompatible = !MergedReturn.isNull();
Mike Stump11289f42009-09-09 15:08:12 +00003026 for (unsigned Idx = 0, End = Old->getNumParams();
Eli Friedmanfcbf7d22009-06-01 09:24:59 +00003027 LooseCompatible && Idx != End; ++Idx) {
Douglas Gregora74a2972009-03-06 22:43:54 +00003028 ParmVarDecl *OldParm = Old->getParamDecl(Idx);
3029 ParmVarDecl *NewParm = New->getParamDecl(Idx);
Mike Stump11289f42009-09-09 15:08:12 +00003030 if (Context.typesAreCompatible(OldParm->getType(),
Alp Toker9cacbab2014-01-20 20:26:09 +00003031 NewProto->getParamType(Idx))) {
Douglas Gregora74a2972009-03-06 22:43:54 +00003032 ArgTypes.push_back(NewParm->getType());
3033 } else if (Context.typesAreCompatible(OldParm->getType(),
Douglas Gregor17ea3f52010-07-29 15:18:02 +00003034 NewParm->getType(),
3035 /*CompareUnqualified=*/true)) {
Alp Toker9cacbab2014-01-20 20:26:09 +00003036 GNUCompatibleParamWarning Warn = { OldParm, NewParm,
3037 NewProto->getParamType(Idx) };
Douglas Gregora74a2972009-03-06 22:43:54 +00003038 Warnings.push_back(Warn);
3039 ArgTypes.push_back(NewParm->getType());
3040 } else
Eli Friedmanfcbf7d22009-06-01 09:24:59 +00003041 LooseCompatible = false;
Douglas Gregora74a2972009-03-06 22:43:54 +00003042 }
3043
Eli Friedmanfcbf7d22009-06-01 09:24:59 +00003044 if (LooseCompatible) {
Douglas Gregora74a2972009-03-06 22:43:54 +00003045 for (unsigned Warn = 0; Warn < Warnings.size(); ++Warn) {
3046 Diag(Warnings[Warn].NewParm->getLocation(),
3047 diag::ext_param_promoted_not_compatible_with_prototype)
3048 << Warnings[Warn].PromotedType
3049 << Warnings[Warn].OldParm->getType();
Douglas Gregor17ea3f52010-07-29 15:18:02 +00003050 if (Warnings[Warn].OldParm->getLocation().isValid())
3051 Diag(Warnings[Warn].OldParm->getLocation(),
3052 diag::note_previous_declaration);
Douglas Gregora74a2972009-03-06 22:43:54 +00003053 }
3054
Richard Smith1c34fb72013-08-13 18:18:50 +00003055 if (MergeTypeWithOld)
3056 New->setType(Context.getFunctionType(MergedReturn, ArgTypes,
3057 OldProto->getExtProtoInfo()));
3058 return MergeCompatibleFunctionDecls(New, Old, S, MergeTypeWithOld);
Douglas Gregora74a2972009-03-06 22:43:54 +00003059 }
3060
3061 // Fall through to diagnose conflicting types.
3062 }
3063
John McCallad327cd2013-04-14 08:50:55 +00003064 // A function that has already been declared has been redeclared or
3065 // defined with a different type; show an appropriate diagnostic.
3066
3067 // If the previous declaration was an implicitly-generated builtin
3068 // declaration, then at the very least we should use a specialized note.
3069 unsigned BuiltinID;
3070 if (Old->isImplicit() && (BuiltinID = Old->getBuiltinID())) {
3071 // If it's actually a library-defined builtin function like 'malloc'
3072 // or 'printf', just warn about the incompatible redeclaration.
Douglas Gregor75a45ba2009-02-16 17:45:42 +00003073 if (Context.BuiltinInfo.isPredefinedLibFunction(BuiltinID)) {
Douglas Gregor75a45ba2009-02-16 17:45:42 +00003074 Diag(New->getLocation(), diag::warn_redecl_library_builtin) << New;
Richard Smithbdd14642014-02-04 01:14:30 +00003075 Diag(OldLocation, diag::note_previous_builtin_declaration)
Douglas Gregor75a45ba2009-02-16 17:45:42 +00003076 << Old << Old->getType();
John McCallad327cd2013-04-14 08:50:55 +00003077
3078 // If this is a global redeclaration, just forget hereafter
3079 // about the "builtin-ness" of the function.
3080 //
3081 // Doing this for local extern declarations is problematic. If
3082 // the builtin declaration remains visible, a second invalid
3083 // local declaration will produce a hard error; if it doesn't
3084 // remain visible, a single bogus local redeclaration (which is
3085 // actually only a warning) could break all the downstream code.
Richard Smith541b38b2013-09-20 01:15:31 +00003086 if (!New->getLexicalDeclContext()->isFunctionOrMethod())
Richard Smith9c254182015-07-19 21:41:12 +00003087 New->getIdentifier()->revertBuiltin();
John McCallad327cd2013-04-14 08:50:55 +00003088
Douglas Gregor893c2c92009-03-23 17:47:24 +00003089 return false;
Douglas Gregor75a45ba2009-02-16 17:45:42 +00003090 }
Steve Naroff17832a42008-01-16 15:01:34 +00003091
Douglas Gregor75a45ba2009-02-16 17:45:42 +00003092 PrevDiag = diag::note_previous_builtin_declaration;
3093 }
3094
Chris Lattnerf3d3fae2008-11-24 05:29:24 +00003095 Diag(New->getLocation(), diag::err_conflicting_types) << New->getDeclName();
Richard Smithbdd14642014-02-04 01:14:30 +00003096 Diag(OldLocation, PrevDiag) << Old << Old->getType();
Douglas Gregor75a45ba2009-02-16 17:45:42 +00003097 return true;
Chris Lattner01564d92007-01-27 19:27:06 +00003098}
3099
Douglas Gregore62c0a42009-02-24 01:23:02 +00003100/// \brief Completes the merge of two function declarations that are
Mike Stump11289f42009-09-09 15:08:12 +00003101/// known to be compatible.
Douglas Gregore62c0a42009-02-24 01:23:02 +00003102///
3103/// This routine handles the merging of attributes and other
Alp Toker5f6b8ac2013-10-22 09:00:49 +00003104/// properties of function declarations from the old declaration to
Douglas Gregore62c0a42009-02-24 01:23:02 +00003105/// the new declaration, once we know that New is in fact a
3106/// redeclaration of Old.
3107///
3108/// \returns false
James Molloye9430032012-03-13 08:55:35 +00003109bool Sema::MergeCompatibleFunctionDecls(FunctionDecl *New, FunctionDecl *Old,
Richard Smith1c34fb72013-08-13 18:18:50 +00003110 Scope *S, bool MergeTypeWithOld) {
Douglas Gregore62c0a42009-02-24 01:23:02 +00003111 // Merge the attributes
Douglas Gregor32c17572012-01-01 20:30:41 +00003112 mergeDeclAttributes(New, Old);
Douglas Gregore62c0a42009-02-24 01:23:02 +00003113
Douglas Gregore62c0a42009-02-24 01:23:02 +00003114 // Merge "pure" flag.
3115 if (Old->isPure())
3116 New->setPure();
3117
Rafael Espindolabefe1302012-11-25 14:07:59 +00003118 // Merge "used" flag.
Rafael Espindolae4865d22013-10-23 16:46:34 +00003119 if (Old->getMostRecentDecl()->isUsed(false))
3120 New->setIsUsed();
Rafael Espindolabefe1302012-11-25 14:07:59 +00003121
John McCallf79e87d2011-03-02 04:00:57 +00003122 // Merge attributes from the parameters. These can mismatch with K&R
3123 // declarations.
3124 if (New->getNumParams() == Old->getNumParams())
Douglas Gregor261a89b2015-06-19 17:51:05 +00003125 for (unsigned i = 0, e = New->getNumParams(); i != e; ++i) {
3126 ParmVarDecl *NewParam = New->getParamDecl(i);
3127 ParmVarDecl *OldParam = Old->getParamDecl(i);
3128 mergeParamDeclAttributes(NewParam, OldParam, *this);
3129 mergeParamDeclTypes(NewParam, OldParam, *this);
3130 }
John McCallf79e87d2011-03-02 04:00:57 +00003131
David Blaikiebbafb8a2012-03-11 07:00:24 +00003132 if (getLangOpts().CPlusPlus)
James Molloye9430032012-03-13 08:55:35 +00003133 return MergeCXXFunctionDecl(New, Old, S);
Douglas Gregore62c0a42009-02-24 01:23:02 +00003134
Rafael Espindola8778c282012-11-29 16:09:03 +00003135 // Merge the function types so the we get the composite types for the return
Richard Smith1c34fb72013-08-13 18:18:50 +00003136 // and argument types. Per C11 6.2.7/4, only update the type if the old decl
3137 // was visible.
Rafael Espindola8778c282012-11-29 16:09:03 +00003138 QualType Merged = Context.mergeTypes(Old->getType(), New->getType());
Richard Smith1c34fb72013-08-13 18:18:50 +00003139 if (!Merged.isNull() && MergeTypeWithOld)
Rafael Espindola8778c282012-11-29 16:09:03 +00003140 New->setType(Merged);
3141
Douglas Gregore62c0a42009-02-24 01:23:02 +00003142 return false;
3143}
3144
John McCall31168b02011-06-15 23:02:42 +00003145
John McCallf79e87d2011-03-02 04:00:57 +00003146void Sema::mergeObjCMethodDecls(ObjCMethodDecl *newMethod,
Douglas Gregor32c17572012-01-01 20:30:41 +00003147 ObjCMethodDecl *oldMethod) {
John McCalld2930c22011-07-22 02:45:48 +00003148
Fariborz Jahanian3da28f82012-06-05 21:14:46 +00003149 // Merge the attributes, including deprecated/unavailable
Ted Kremenekb5445722013-04-06 00:34:27 +00003150 AvailabilityMergeKind MergeKind =
3151 isa<ObjCImplDecl>(newMethod->getDeclContext()) ? AMK_Redeclaration
3152 : AMK_Override;
3153 mergeDeclAttributes(newMethod, oldMethod, MergeKind);
John McCallf79e87d2011-03-02 04:00:57 +00003154
3155 // Merge attributes from the parameters.
Douglas Gregor0bf70f42012-05-17 23:13:29 +00003156 ObjCMethodDecl::param_const_iterator oi = oldMethod->param_begin(),
3157 oe = oldMethod->param_end();
Argyrios Kyrtzidisb8c3aaf2011-10-03 06:37:04 +00003158 for (ObjCMethodDecl::param_iterator
John McCallf79e87d2011-03-02 04:00:57 +00003159 ni = newMethod->param_begin(), ne = newMethod->param_end();
Douglas Gregor0bf70f42012-05-17 23:13:29 +00003160 ni != ne && oi != oe; ++ni, ++oi)
Richard Smithe233fbf2013-01-28 22:42:45 +00003161 mergeParamDeclAttributes(*ni, *oi, *this);
John McCalld2930c22011-07-22 02:45:48 +00003162
Douglas Gregor66a8ca02013-01-15 22:43:08 +00003163 CheckObjCMethodOverride(newMethod, oldMethod);
John McCallf79e87d2011-03-02 04:00:57 +00003164}
3165
Sebastian Redlfa453cf2011-03-12 11:50:43 +00003166/// MergeVarDeclTypes - We parsed a variable 'New' which has the same name and
3167/// scope as a previous declaration 'Old'. Figure out how to merge their types,
Richard Smith30482bc2011-02-20 03:19:35 +00003168/// emitting diagnostics as appropriate.
3169///
3170/// Declarations using the auto type specifier (C++ [decl.spec.auto]) call back
Sebastian Redla9351792012-02-11 23:51:47 +00003171/// to here in AddInitializerToDecl. We can't check them before the initializer
3172/// is attached.
Richard Smith1c34fb72013-08-13 18:18:50 +00003173void Sema::MergeVarDeclTypes(VarDecl *New, VarDecl *Old,
3174 bool MergeTypeWithOld) {
Richard Smith30482bc2011-02-20 03:19:35 +00003175 if (New->isInvalidDecl() || Old->isInvalidDecl())
3176 return;
3177
3178 QualType MergedT;
David Blaikiebbafb8a2012-03-11 07:00:24 +00003179 if (getLangOpts().CPlusPlus) {
Richard Smith27d807c2013-04-30 13:56:41 +00003180 if (New->getType()->isUndeducedType()) {
Richard Smith30482bc2011-02-20 03:19:35 +00003181 // We don't know what the new type is until the initializer is attached.
3182 return;
Sebastian Redlfa453cf2011-03-12 11:50:43 +00003183 } else if (Context.hasSameType(New->getType(), Old->getType())) {
3184 // These could still be something that needs exception specs checked.
3185 return MergeVarDeclExceptionSpecs(New, Old);
3186 }
Richard Smith30482bc2011-02-20 03:19:35 +00003187 // C++ [basic.link]p10:
3188 // [...] the types specified by all declarations referring to a given
3189 // object or function shall be identical, except that declarations for an
3190 // array object can specify array types that differ by the presence or
3191 // absence of a major array bound (8.3.4).
3192 else if (Old->getType()->isIncompleteArrayType() &&
3193 New->getType()->isArrayType()) {
Eli Friedman07bab732012-12-13 01:43:21 +00003194 const ArrayType *OldArray = Context.getAsArrayType(Old->getType());
3195 const ArrayType *NewArray = Context.getAsArrayType(New->getType());
3196 if (Context.hasSameType(OldArray->getElementType(),
3197 NewArray->getElementType()))
Richard Smith30482bc2011-02-20 03:19:35 +00003198 MergedT = New->getType();
3199 } else if (Old->getType()->isArrayType() &&
Richard Smith541b38b2013-09-20 01:15:31 +00003200 New->getType()->isIncompleteArrayType()) {
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 = Old->getType();
Richard Smith541b38b2013-09-20 01:15:31 +00003206 } else if (New->getType()->isObjCObjectPointerType() &&
3207 Old->getType()->isObjCObjectPointerType()) {
3208 MergedT = Context.mergeObjCGCQualifiers(New->getType(),
3209 Old->getType());
Richard Smith30482bc2011-02-20 03:19:35 +00003210 }
3211 } else {
Richard Smith541b38b2013-09-20 01:15:31 +00003212 // C 6.2.7p2:
3213 // All declarations that refer to the same object or function shall have
3214 // compatible type.
Richard Smith30482bc2011-02-20 03:19:35 +00003215 MergedT = Context.mergeTypes(New->getType(), Old->getType());
3216 }
3217 if (MergedT.isNull()) {
Richard Smith1c34fb72013-08-13 18:18:50 +00003218 // It's OK if we couldn't merge types if either type is dependent, for a
3219 // block-scope variable. In other cases (static data members of class
3220 // templates, variable templates, ...), we require the types to be
3221 // equivalent.
3222 // FIXME: The C++ standard doesn't say anything about this.
3223 if ((New->getType()->isDependentType() ||
3224 Old->getType()->isDependentType()) && New->isLocalVarDecl()) {
3225 // If the old type was dependent, we can't merge with it, so the new type
3226 // becomes dependent for now. We'll reproduce the original type when we
3227 // instantiate the TypeSourceInfo for the variable.
3228 if (!New->getType()->isDependentType() && MergeTypeWithOld)
3229 New->setType(Context.DependentTy);
3230 return;
3231 }
3232
3233 // FIXME: Even if this merging succeeds, some other non-visible declaration
3234 // of this variable might have an incompatible type. For instance:
3235 //
3236 // extern int arr[];
3237 // void f() { extern int arr[2]; }
3238 // void g() { extern int arr[3]; }
3239 //
3240 // Neither C nor C++ requires a diagnostic for this, but we should still try
3241 // to diagnose it.
David Majnemer38a50c02015-07-14 20:08:49 +00003242 Diag(New->getLocation(), New->isThisDeclarationADefinition()
3243 ? diag::err_redefinition_different_type
3244 : diag::err_redeclaration_different_type)
3245 << New->getDeclName() << New->getType() << Old->getType();
3246
3247 diag::kind PrevDiag;
3248 SourceLocation OldLocation;
3249 std::tie(PrevDiag, OldLocation) =
3250 getNoteDiagForInvalidRedeclaration(Old, New);
3251 Diag(OldLocation, PrevDiag);
Richard Smith30482bc2011-02-20 03:19:35 +00003252 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 Smithfc805ca2015-07-06 04:43:58 +00003312
3313 if (auto *Shadow =
3314 dyn_cast<UsingShadowDecl>(Previous.getRepresentativeDecl()))
3315 if (checkUsingShadowRedecl<VarTemplateDecl>(*this, Shadow, NewTemplate))
3316 return New->setInvalidDecl();
3317 } else {
Richard Smithbeef3452014-01-16 23:39:20 +00003318 Old = dyn_cast<VarDecl>(Previous.getFoundDecl());
Richard Smithfc805ca2015-07-06 04:43:58 +00003319
3320 if (auto *Shadow =
3321 dyn_cast<UsingShadowDecl>(Previous.getRepresentativeDecl()))
3322 if (checkUsingShadowRedecl<VarDecl>(*this, Shadow, New))
3323 return New->setInvalidDecl();
3324 }
Larisse Voufod8dd97c2013-08-14 03:09:19 +00003325 }
3326 if (!Old) {
Chris Lattner651d42d2008-11-20 06:38:18 +00003327 Diag(New->getLocation(), diag::err_redefinition_different_kind)
Chris Lattnere3d20d92008-11-23 21:45:46 +00003328 << New->getDeclName();
John McCall1f82f242009-11-18 22:49:29 +00003329 Diag(Previous.getRepresentativeDecl()->getLocation(),
3330 diag::note_previous_definition);
Chris Lattnerf6d1c9c2009-04-25 08:06:05 +00003331 return New->setInvalidDecl();
Chris Lattnerc511efb2007-01-27 19:32:14 +00003332 }
Chris Lattner84966392008-03-03 03:28:21 +00003333
Rafael Espindola5bddd6a2013-04-15 12:49:13 +00003334 if (!shouldLinkPossiblyHiddenDecl(Old, New))
3335 return;
3336
Richard Smithbeef3452014-01-16 23:39:20 +00003337 // Ensure the template parameters are compatible.
3338 if (NewTemplate &&
3339 !TemplateParameterListsAreEqual(NewTemplate->getTemplateParameters(),
3340 OldTemplate->getTemplateParameters(),
3341 /*Complain=*/true, TPL_TemplateMatch))
3342 return;
3343
Douglas Gregor2c7d9292010-08-30 14:32:14 +00003344 // C++ [class.mem]p1:
3345 // A member shall not be declared twice in the member-specification [...]
3346 //
3347 // Here, we need only consider static data members.
3348 if (Old->isStaticDataMember() && !New->isOutOfLine()) {
3349 Diag(New->getLocation(), diag::err_duplicate_member)
3350 << New->getIdentifier();
3351 Diag(Old->getLocation(), diag::note_previous_declaration);
3352 New->setInvalidDecl();
3353 }
3354
Douglas Gregor32c17572012-01-01 20:30:41 +00003355 mergeDeclAttributes(New, Old);
David Blaikie30d15442011-10-19 22:56:21 +00003356 // Warn if an already-declared variable is made a weak_import in a subsequent
3357 // declaration
Aaron Ballman9ead1242013-12-19 02:39:40 +00003358 if (New->hasAttr<WeakImportAttr>() &&
Fariborz Jahanianab578bf2011-06-20 17:50:03 +00003359 Old->getStorageClass() == SC_None &&
Aaron Ballman9ead1242013-12-19 02:39:40 +00003360 !Old->hasAttr<WeakImportAttr>()) {
Fariborz Jahanian33e02262011-06-22 22:08:50 +00003361 Diag(New->getLocation(), diag::warn_weak_import) << New->getDeclName();
3362 Diag(Old->getLocation(), diag::note_previous_definition);
3363 // Remove weak_import attribute on new declaration.
Fariborz Jahanian0dfc9502011-06-23 17:50:10 +00003364 New->dropAttr<WeakImportAttr>();
Fariborz Jahanian33e02262011-06-22 22:08:50 +00003365 }
Chris Lattner84966392008-03-03 03:28:21 +00003366
Richard Smith30482bc2011-02-20 03:19:35 +00003367 // Merge the types.
David Majnemerce12ed22015-01-14 02:27:38 +00003368 VarDecl *MostRecent = Old->getMostRecentDecl();
3369 if (MostRecent != Old) {
3370 MergeVarDeclTypes(New, MostRecent,
3371 mergeTypeWithPrevious(*this, New, MostRecent, Previous));
3372 if (New->isInvalidDecl())
3373 return;
3374 }
Richard Smith3c785782013-09-03 21:00:58 +00003375
David Majnemerce12ed22015-01-14 02:27:38 +00003376 MergeVarDeclTypes(New, Old, mergeTypeWithPrevious(*this, New, Old, Previous));
Richard Smith30482bc2011-02-20 03:19:35 +00003377 if (New->isInvalidDecl())
3378 return;
Douglas Gregor04e9a032009-03-11 23:52:16 +00003379
David Majnemer5b63fa02014-06-18 23:26:25 +00003380 diag::kind PrevDiag;
3381 SourceLocation OldLocation;
3382 std::tie(PrevDiag, OldLocation) =
3383 getNoteDiagForInvalidRedeclaration(Old, New);
3384
Rafael Espindola8ac2f592013-04-04 21:21:25 +00003385 // [dcl.stc]p8: Check if we have a non-static decl followed by a static.
John McCall8e7d6562010-08-26 03:08:43 +00003386 if (New->getStorageClass() == SC_Static &&
Rafael Espindola8ac2f592013-04-04 21:21:25 +00003387 !New->isStaticDataMember() &&
Rafael Espindola3ae00052013-05-13 00:12:11 +00003388 Old->hasExternalFormalLinkage()) {
David Majnemer5b63fa02014-06-18 23:26:25 +00003389 if (getLangOpts().MicrosoftExt) {
3390 Diag(New->getLocation(), diag::ext_static_non_static)
3391 << New->getDeclName();
3392 Diag(OldLocation, PrevDiag);
3393 } else {
3394 Diag(New->getLocation(), diag::err_static_non_static)
3395 << New->getDeclName();
3396 Diag(OldLocation, PrevDiag);
3397 return New->setInvalidDecl();
3398 }
Steve Naroff1e787362008-01-30 00:44:01 +00003399 }
Mike Stump11289f42009-09-09 15:08:12 +00003400 // C99 6.2.2p4:
Douglas Gregor37311622009-03-19 22:01:50 +00003401 // For an identifier declared with the storage-class specifier
3402 // extern in a scope in which a prior declaration of that
3403 // identifier is visible,23) if the prior declaration specifies
3404 // internal or external linkage, the linkage of the identifier at
3405 // the later declaration is the same as the linkage specified at
3406 // the prior declaration. If no prior declaration is visible, or
3407 // if the prior declaration specifies no linkage, then the
3408 // identifier has external linkage.
Douglas Gregord4eca012009-03-23 16:17:01 +00003409 if (New->hasExternalStorage() && Old->hasLinkage())
Douglas Gregor37311622009-03-19 22:01:50 +00003410 /* Okay */;
Rafael Espindola6ae7e502013-04-03 19:27:57 +00003411 else if (New->getCanonicalDecl()->getStorageClass() != SC_Static &&
Rafael Espindola8ac2f592013-04-04 21:21:25 +00003412 !New->isStaticDataMember() &&
Rafael Espindola6ae7e502013-04-03 19:27:57 +00003413 Old->getCanonicalDecl()->getStorageClass() == SC_Static) {
Chris Lattnerf3d3fae2008-11-24 05:29:24 +00003414 Diag(New->getLocation(), diag::err_non_static_static) << New->getDeclName();
David Majnemer5b63fa02014-06-18 23:26:25 +00003415 Diag(OldLocation, PrevDiag);
Chris Lattnerf6d1c9c2009-04-25 08:06:05 +00003416 return New->setInvalidDecl();
Steve Naroff1e787362008-01-30 00:44:01 +00003417 }
Daniel Dunbar0ca16602009-04-14 02:25:56 +00003418
Argyrios Kyrtzidis819f6102011-01-31 07:04:46 +00003419 // Check if extern is followed by non-extern and vice-versa.
David Majnemercdf8a712015-01-13 10:14:57 +00003420 if (New->hasExternalStorage() &&
David Majnemera3b04ce2015-01-14 00:31:13 +00003421 !Old->hasLinkage() && Old->isLocalVarDeclOrParm()) {
Argyrios Kyrtzidis819f6102011-01-31 07:04:46 +00003422 Diag(New->getLocation(), diag::err_extern_non_extern) << New->getDeclName();
David Majnemer5b63fa02014-06-18 23:26:25 +00003423 Diag(OldLocation, PrevDiag);
Argyrios Kyrtzidis819f6102011-01-31 07:04:46 +00003424 return New->setInvalidDecl();
3425 }
David Majnemera3b04ce2015-01-14 00:31:13 +00003426 if (Old->hasLinkage() && New->isLocalVarDeclOrParm() &&
David Majnemercdf8a712015-01-13 10:14:57 +00003427 !New->hasExternalStorage()) {
Argyrios Kyrtzidis819f6102011-01-31 07:04:46 +00003428 Diag(New->getLocation(), diag::err_non_extern_extern) << New->getDeclName();
David Majnemer5b63fa02014-06-18 23:26:25 +00003429 Diag(OldLocation, PrevDiag);
Argyrios Kyrtzidis819f6102011-01-31 07:04:46 +00003430 return New->setInvalidDecl();
3431 }
3432
Steve Naroffa5629372008-09-17 14:05:40 +00003433 // Variables with external linkage are analyzed in FinalizeDeclaratorGroup.
Mike Stump11289f42009-09-09 15:08:12 +00003434
Daniel Dunbar0ca16602009-04-14 02:25:56 +00003435 // FIXME: The test for external storage here seems wrong? We still
3436 // need to check for mismatches.
3437 if (!New->hasExternalStorage() && !New->isFileVarDecl() &&
Douglas Gregor04e9a032009-03-11 23:52:16 +00003438 // Don't complain about out-of-line definitions of static members.
3439 !(Old->getLexicalDeclContext()->isRecord() &&
3440 !New->getLexicalDeclContext()->isRecord())) {
Chris Lattnere3d20d92008-11-23 21:45:46 +00003441 Diag(New->getLocation(), diag::err_redefinition) << New->getDeclName();
David Majnemer5b63fa02014-06-18 23:26:25 +00003442 Diag(OldLocation, PrevDiag);
Chris Lattnerf6d1c9c2009-04-25 08:06:05 +00003443 return New->setInvalidDecl();
Steve Naroff6fbf0dc2007-03-16 00:33:25 +00003444 }
Douglas Gregor0760fa12009-03-10 23:43:53 +00003445
Richard Smithfd3834f2013-04-13 02:43:54 +00003446 if (New->getTLSKind() != Old->getTLSKind()) {
3447 if (!Old->getTLSKind()) {
3448 Diag(New->getLocation(), diag::err_thread_non_thread) << New->getDeclName();
David Majnemer5b63fa02014-06-18 23:26:25 +00003449 Diag(OldLocation, PrevDiag);
Richard Smithfd3834f2013-04-13 02:43:54 +00003450 } else if (!New->getTLSKind()) {
3451 Diag(New->getLocation(), diag::err_non_thread_thread) << New->getDeclName();
David Majnemer5b63fa02014-06-18 23:26:25 +00003452 Diag(OldLocation, PrevDiag);
Richard Smithfd3834f2013-04-13 02:43:54 +00003453 } else {
3454 // Do not allow redeclaration to change the variable between requiring
3455 // static and dynamic initialization.
3456 // FIXME: GCC allows this, but uses the TLS keyword on the first
3457 // declaration to determine the kind. Do we need to be compatible here?
3458 Diag(New->getLocation(), diag::err_thread_thread_different_kind)
3459 << New->getDeclName() << (New->getTLSKind() == VarDecl::TLS_Dynamic);
David Majnemer5b63fa02014-06-18 23:26:25 +00003460 Diag(OldLocation, PrevDiag);
Richard Smithfd3834f2013-04-13 02:43:54 +00003461 }
Eli Friedmand5c0eed2009-04-19 20:27:55 +00003462 }
3463
Sebastian Redlf1842912010-02-02 18:35:11 +00003464 // C++ doesn't have tentative definitions, so go right ahead and check here.
Richard Smith82e57fb2015-05-19 00:49:29 +00003465 VarDecl *Def;
David Blaikiebbafb8a2012-03-11 07:00:24 +00003466 if (getLangOpts().CPlusPlus &&
Sebastian Redld85be0c2010-02-03 02:08:48 +00003467 New->isThisDeclarationADefinition() == VarDecl::Definition &&
Sebastian Redlf1842912010-02-02 18:35:11 +00003468 (Def = Old->getDefinition())) {
Richard Smith82e57fb2015-05-19 00:49:29 +00003469 NamedDecl *Hidden = nullptr;
Richard Smith529ecb22015-06-22 21:15:01 +00003470 if (!hasVisibleDefinition(Def, &Hidden) &&
3471 (New->getFormalLinkage() == InternalLinkage ||
3472 New->getDescribedVarTemplate() ||
Richard Smith82e57fb2015-05-19 00:49:29 +00003473 New->getNumTemplateParameterLists() ||
3474 New->getDeclContext()->isDependentContext())) {
3475 // The previous definition is hidden, and multiple definitions are
3476 // permitted (in separate TUs). Form another definition of it.
3477 } else {
3478 Diag(New->getLocation(), diag::err_redefinition) << New;
3479 Diag(Def->getLocation(), diag::note_previous_definition);
3480 New->setInvalidDecl();
3481 return;
3482 }
Sebastian Redlf1842912010-02-02 18:35:11 +00003483 }
Rafael Espindolacffa95d2012-12-27 03:56:20 +00003484
Rafael Espindolaf4187652013-02-14 01:18:37 +00003485 if (haveIncompatibleLanguageLinkages(Old, New)) {
Rafael Espindolacffa95d2012-12-27 03:56:20 +00003486 Diag(New->getLocation(), diag::err_different_language_linkage) << New;
David Majnemer5b63fa02014-06-18 23:26:25 +00003487 Diag(OldLocation, PrevDiag);
Rafael Espindolacffa95d2012-12-27 03:56:20 +00003488 New->setInvalidDecl();
3489 return;
3490 }
3491
Rafael Espindolabefe1302012-11-25 14:07:59 +00003492 // Merge "used" flag.
Rafael Espindolae4865d22013-10-23 16:46:34 +00003493 if (Old->getMostRecentDecl()->isUsed(false))
3494 New->setIsUsed();
Rafael Espindolabefe1302012-11-25 14:07:59 +00003495
Douglas Gregor0760fa12009-03-10 23:43:53 +00003496 // Keep a chain of previous declarations.
Rafael Espindola8db352d2013-10-17 15:37:26 +00003497 New->setPreviousDecl(Old);
Richard Smithbeef3452014-01-16 23:39:20 +00003498 if (NewTemplate)
3499 NewTemplate->setPreviousDecl(OldTemplate);
John McCall401982f2010-01-20 21:53:11 +00003500
3501 // Inherit access appropriately.
3502 New->setAccess(Old->getAccess());
Richard Smithbeef3452014-01-16 23:39:20 +00003503 if (NewTemplate)
3504 NewTemplate->setAccess(New->getAccess());
Chris Lattner01564d92007-01-27 19:27:06 +00003505}
3506
Chris Lattnerb6738ec2007-01-28 00:38:24 +00003507/// ParsedFreeStandingDeclSpec - This method is invoked when a declspec with
3508/// no declarator (e.g. "struct foo;") is parsed.
John McCall48871652010-08-21 09:40:31 +00003509Decl *Sema::ParsedFreeStandingDeclSpec(Scope *S, AccessSpecifier AS,
John McCallaa017372011-03-22 23:00:04 +00003510 DeclSpec &DS) {
Benjamin Kramercc4c49d2012-08-23 23:38:35 +00003511 return ParsedFreeStandingDeclSpec(S, AS, DS, MultiTemplateParamsArg());
Chandler Carruth7c9856d2011-05-03 18:35:10 +00003512}
3513
David Majnemera7f8c462015-03-19 21:54:30 +00003514// The MS ABI changed between VS2013 and VS2015 with regard to numbers used to
3515// disambiguate entities defined in different scopes.
3516// While the VS2015 ABI fixes potential miscompiles, it is also breaks
3517// compatibility.
3518// We will pick our mangling number depending on which version of MSVC is being
3519// targeted.
3520static unsigned getMSManglingNumber(const LangOptions &LO, Scope *S) {
David Majnemerb710a932015-05-11 03:57:49 +00003521 return LO.isCompatibleWithMSVC(LangOptions::MSVC2015)
3522 ? S->getMSCurManglingNumber()
3523 : S->getMSLastManglingNumber();
David Majnemera7f8c462015-03-19 21:54:30 +00003524}
3525
David Majnemerf9bde282015-03-11 06:45:39 +00003526void Sema::handleTagNumbering(const TagDecl *Tag, Scope *TagScope) {
3527 if (!Context.getLangOpts().CPlusPlus)
Reid Klecknerd8110b62013-09-10 20:14:30 +00003528 return;
3529
Eli Friedman3b7d46c2013-07-10 00:30:46 +00003530 if (isa<CXXRecordDecl>(Tag->getParent())) {
3531 // If this tag is the direct child of a class, number it if
3532 // it is anonymous.
3533 if (!Tag->getName().empty() || Tag->getTypedefNameForAnonDecl())
3534 return;
3535 MangleNumberingContext &MCtx =
David Majnemerf9bde282015-03-11 06:45:39 +00003536 Context.getManglingNumberContext(Tag->getParent());
3537 Context.setManglingNumber(
David Majnemera7f8c462015-03-19 21:54:30 +00003538 Tag, MCtx.getManglingNumber(
3539 Tag, getMSManglingNumber(getLangOpts(), TagScope)));
Eli Friedman3b7d46c2013-07-10 00:30:46 +00003540 return;
3541 }
3542
3543 // If this tag isn't a direct child of a class, number it if it is local.
3544 Decl *ManglingContextDecl;
David Majnemerf9bde282015-03-11 06:45:39 +00003545 if (MangleNumberingContext *MCtx = getCurrentMangleNumberContext(
3546 Tag->getDeclContext(), ManglingContextDecl)) {
3547 Context.setManglingNumber(
David Majnemera7f8c462015-03-19 21:54:30 +00003548 Tag, MCtx->getManglingNumber(
3549 Tag, getMSManglingNumber(getLangOpts(), TagScope)));
Eli Friedman3b7d46c2013-07-10 00:30:46 +00003550 }
3551}
3552
David Majnemerf9bde282015-03-11 06:45:39 +00003553void Sema::setTagNameForLinkagePurposes(TagDecl *TagFromDeclSpec,
3554 TypedefNameDecl *NewTD) {
3555 // Do nothing if the tag is not anonymous or already has an
3556 // associated typedef (from an earlier typedef in this decl group).
3557 if (TagFromDeclSpec->getIdentifier())
3558 return;
3559 if (TagFromDeclSpec->getTypedefNameForAnonDecl())
3560 return;
3561
3562 // A well-formed anonymous tag must always be a TUK_Definition.
3563 assert(TagFromDeclSpec->isThisDeclarationADefinition());
3564
3565 // The type must match the tag exactly; no qualifiers allowed.
3566 if (!Context.hasSameType(NewTD->getUnderlyingType(),
3567 Context.getTagDeclType(TagFromDeclSpec)))
3568 return;
3569
3570 // If we've already computed linkage for the anonymous tag, then
3571 // adding a typedef name for the anonymous decl can change that
3572 // linkage, which might be a serious problem. Diagnose this as
3573 // unsupported and ignore the typedef name. TODO: we should
3574 // pursue this as a language defect and establish a formal rule
3575 // for how to handle it.
3576 if (TagFromDeclSpec->hasLinkageBeenComputed()) {
3577 Diag(NewTD->getLocation(), diag::err_typedef_changes_linkage);
3578
3579 SourceLocation tagLoc = TagFromDeclSpec->getInnerLocStart();
3580 tagLoc = getLocForEndOfToken(tagLoc);
3581
3582 llvm::SmallString<40> textToInsert;
3583 textToInsert += ' ';
3584 textToInsert += NewTD->getIdentifier()->getName();
3585 Diag(tagLoc, diag::note_typedef_changes_linkage)
3586 << FixItHint::CreateInsertion(tagLoc, textToInsert);
3587 return;
3588 }
3589
3590 // Otherwise, set this is the anon-decl typedef for the tag.
3591 TagFromDeclSpec->setTypedefNameForAnonDecl(NewTD);
3592}
3593
Saleem Abdulrasool2e08f502015-06-21 23:05:52 +00003594static unsigned GetDiagnosticTypeSpecifierID(DeclSpec::TST T) {
3595 switch (T) {
3596 case DeclSpec::TST_class:
3597 return 0;
3598 case DeclSpec::TST_struct:
3599 return 1;
3600 case DeclSpec::TST_interface:
3601 return 2;
3602 case DeclSpec::TST_union:
3603 return 3;
3604 case DeclSpec::TST_enum:
3605 return 4;
3606 default:
3607 llvm_unreachable("unexpected type specifier");
3608 }
3609}
3610
Chandler Carruth7c9856d2011-05-03 18:35:10 +00003611/// ParsedFreeStandingDeclSpec - This method is invoked when a declspec with
Richard Smithb1402ae2013-03-18 22:52:47 +00003612/// no declarator (e.g. "struct foo;") is parsed. It also accepts template
Chandler Carruth7c9856d2011-05-03 18:35:10 +00003613/// parameters to cope with template friend declarations.
3614Decl *Sema::ParsedFreeStandingDeclSpec(Scope *S, AccessSpecifier AS,
3615 DeclSpec &DS,
Richard Smithb1402ae2013-03-18 22:52:47 +00003616 MultiTemplateParamsArg TemplateParams,
3617 bool IsExplicitInstantiation) {
Craig Topperc3ec1492014-05-26 06:22:03 +00003618 Decl *TagD = nullptr;
3619 TagDecl *Tag = nullptr;
Douglas Gregor9817f4a2009-02-09 15:09:02 +00003620 if (DS.getTypeSpecType() == DeclSpec::TST_class ||
3621 DS.getTypeSpecType() == DeclSpec::TST_struct ||
Joao Matosdc86f942012-08-31 18:45:21 +00003622 DS.getTypeSpecType() == DeclSpec::TST_interface ||
Douglas Gregor9817f4a2009-02-09 15:09:02 +00003623 DS.getTypeSpecType() == DeclSpec::TST_union ||
Douglas Gregor1b57ff32009-05-12 23:25:50 +00003624 DS.getTypeSpecType() == DeclSpec::TST_enum) {
John McCallba7bf592010-08-24 05:47:05 +00003625 TagD = DS.getRepAsDecl();
John McCallc3987482009-10-07 23:34:25 +00003626
3627 if (!TagD) // We probably had an error
Craig Topperc3ec1492014-05-26 06:22:03 +00003628 return nullptr;
Douglas Gregor1b57ff32009-05-12 23:25:50 +00003629
John McCall07e91c02009-08-06 02:15:43 +00003630 // Note that the above type specs guarantee that the
3631 // type rep is a Decl, whereas in many of the others
3632 // it's a Type.
Peter Collingbournee109a2c2011-10-23 17:07:16 +00003633 if (isa<TagDecl>(TagD))
3634 Tag = cast<TagDecl>(TagD);
3635 else if (ClassTemplateDecl *CTD = dyn_cast<ClassTemplateDecl>(TagD))
3636 Tag = CTD->getTemplatedDecl();
Douglas Gregor1b57ff32009-05-12 23:25:50 +00003637 }
Douglas Gregor9817f4a2009-02-09 15:09:02 +00003638
Argyrios Kyrtzidis25596292012-03-09 20:10:30 +00003639 if (Tag) {
David Majnemerf9bde282015-03-11 06:45:39 +00003640 handleTagNumbering(Tag, S);
Argyrios Kyrtzidis201d3772011-09-30 22:11:31 +00003641 Tag->setFreeStanding();
Argyrios Kyrtzidis25596292012-03-09 20:10:30 +00003642 if (Tag->isInvalidDecl())
3643 return Tag;
3644 }
Argyrios Kyrtzidis201d3772011-09-30 22:11:31 +00003645
Nuno Lopese9823fa2009-12-17 11:35:26 +00003646 if (unsigned TypeQuals = DS.getTypeQualifiers()) {
3647 // Enforce C99 6.7.3p2: "Types other than pointer types derived from object
3648 // or incomplete types shall not be restrict-qualified."
3649 if (TypeQuals & DeclSpec::TQ_restrict)
3650 Diag(DS.getRestrictSpecLoc(),
3651 diag::err_typecheck_invalid_restrict_not_pointer_noarg)
3652 << DS.getSourceRange();
3653 }
3654
Richard Smitha77a0a62011-08-15 21:04:07 +00003655 if (DS.isConstexprSpecified()) {
3656 // C++0x [dcl.constexpr]p1: constexpr can only be applied to declarations
3657 // and definitions of functions and variables.
3658 if (Tag)
3659 Diag(DS.getConstexprSpecLoc(), diag::err_constexpr_tag)
Saleem Abdulrasool2e08f502015-06-21 23:05:52 +00003660 << GetDiagnosticTypeSpecifierID(DS.getTypeSpecType());
Richard Smitha77a0a62011-08-15 21:04:07 +00003661 else
3662 Diag(DS.getConstexprSpecLoc(), diag::err_constexpr_no_declarators);
3663 // Don't emit warnings after this error.
3664 return TagD;
3665 }
3666
Richard Smithb1402ae2013-03-18 22:52:47 +00003667 DiagnoseFunctionSpecifiers(DS);
3668
Douglas Gregor3dad8422009-09-26 06:47:28 +00003669 if (DS.isFriendSpecified()) {
John McCallace48cd2010-10-19 01:40:49 +00003670 // If we're dealing with a decl but not a TagDecl, assume that
3671 // whatever routines created it handled the friendship aspect.
3672 if (TagD && !Tag)
Craig Topperc3ec1492014-05-26 06:22:03 +00003673 return nullptr;
Chandler Carruth7c9856d2011-05-03 18:35:10 +00003674 return ActOnFriendTypeDecl(S, DS, TemplateParams);
Douglas Gregor3dad8422009-09-26 06:47:28 +00003675 }
John McCallaa017372011-03-22 23:00:04 +00003676
Nico Weber4d1bed82015-02-14 05:47:01 +00003677 const CXXScopeSpec &SS = DS.getTypeSpecScope();
Richard Smithb1402ae2013-03-18 22:52:47 +00003678 bool IsExplicitSpecialization =
3679 !TemplateParams.empty() && TemplateParams.back()->size() == 0;
3680 if (Tag && SS.isNotEmpty() && !Tag->isCompleteDefinition() &&
3681 !IsExplicitInstantiation && !IsExplicitSpecialization) {
3682 // Per C++ [dcl.type.elab]p1, a class declaration cannot have a
3683 // nested-name-specifier unless it is an explicit instantiation
3684 // or an explicit specialization.
3685 // Per C++ [dcl.enum]p1, an opaque-enum-declaration can't either.
3686 Diag(SS.getBeginLoc(), diag::err_standalone_class_nested_name_specifier)
Saleem Abdulrasool2e08f502015-06-21 23:05:52 +00003687 << GetDiagnosticTypeSpecifierID(DS.getTypeSpecType()) << SS.getRange();
Craig Topperc3ec1492014-05-26 06:22:03 +00003688 return nullptr;
Richard Smithb1402ae2013-03-18 22:52:47 +00003689 }
3690
3691 // Track whether this decl-specifier declares anything.
3692 bool DeclaresAnything = true;
3693
3694 // Handle anonymous struct definitions.
Douglas Gregorc6f58fe2009-01-12 22:49:06 +00003695 if (RecordDecl *Record = dyn_cast_or_null<RecordDecl>(Tag)) {
John McCallf937c022011-10-07 06:10:15 +00003696 if (!Record->getDeclName() && Record->isCompleteDefinition() &&
Douglas Gregor2e7cba62009-03-06 23:06:59 +00003697 DS.getStorageClassSpec() != DeclSpec::SCS_typedef) {
David Blaikiebbafb8a2012-03-11 07:00:24 +00003698 if (getLangOpts().CPlusPlus ||
Douglas Gregor2e7cba62009-03-06 23:06:59 +00003699 Record->getDeclContext()->isRecord())
Nico Weber01a46ad2015-02-15 06:15:40 +00003700 return BuildAnonymousStructOrUnion(S, DS, AS, Record,
3701 Context.getPrintingPolicy());
Douglas Gregor2e7cba62009-03-06 23:06:59 +00003702
Richard Smithb1402ae2013-03-18 22:52:47 +00003703 DeclaresAnything = false;
Douglas Gregor2e7cba62009-03-06 23:06:59 +00003704 }
Francois Pichet0c71f6c2010-11-23 06:07:27 +00003705 }
Douglas Gregorc6f58fe2009-01-12 22:49:06 +00003706
David Majnemer8f0ed912014-08-11 07:29:54 +00003707 // C11 6.7.2.1p2:
3708 // A struct-declaration that does not declare an anonymous structure or
3709 // anonymous union shall contain a struct-declarator-list.
Richard Smith04d3b3e2014-08-26 21:51:57 +00003710 //
3711 // This rule also existed in C89 and C99; the grammar for struct-declaration
3712 // did not permit a struct-declaration without a struct-declarator-list.
Fariborz Jahanianffc120a2014-08-26 21:10:47 +00003713 if (!getLangOpts().CPlusPlus && CurContext->isRecord() &&
Francois Pichet0c71f6c2010-11-23 06:07:27 +00003714 DS.getStorageClassSpec() == DeclSpec::SCS_unspecified) {
David Majnemer8f0ed912014-08-11 07:29:54 +00003715 // Check for Microsoft C extension: anonymous struct/union member.
3716 // Handle 2 kinds of anonymous struct/union:
Francois Pichet0c71f6c2010-11-23 06:07:27 +00003717 // struct STRUCT;
David Majnemer8f0ed912014-08-11 07:29:54 +00003718 // union UNION;
Francois Pichet0c71f6c2010-11-23 06:07:27 +00003719 // and
3720 // STRUCT_TYPE; <- where STRUCT_TYPE is a typedef struct.
David Majnemer8f0ed912014-08-11 07:29:54 +00003721 // UNION_TYPE; <- where UNION_TYPE is a typedef union.
3722 if ((Tag && Tag->getDeclName()) ||
3723 DS.getTypeSpecType() == DeclSpec::TST_typename) {
3724 RecordDecl *Record = nullptr;
3725 if (Tag)
3726 Record = dyn_cast<RecordDecl>(Tag);
3727 else if (const RecordType *RT =
3728 DS.getRepAsType().get()->getAsStructureType())
3729 Record = RT->getDecl();
3730 else if (const RecordType *UT = DS.getRepAsType().get()->getAsUnionType())
3731 Record = UT->getDecl();
3732
3733 if (Record && getLangOpts().MicrosoftExt) {
3734 Diag(DS.getLocStart(), diag::ext_ms_anonymous_record)
3735 << Record->isUnion() << DS.getSourceRange();
3736 return BuildMicrosoftCAnonymousStruct(S, DS, Record);
3737 }
3738
3739 DeclaresAnything = false;
Francois Pichet0c71f6c2010-11-23 06:07:27 +00003740 }
Douglas Gregorc6f58fe2009-01-12 22:49:06 +00003741 }
Richard Smithb1402ae2013-03-18 22:52:47 +00003742
3743 // Skip all the checks below if we have a type error.
3744 if (DS.getTypeSpecType() == DeclSpec::TST_error ||
3745 (TagD && TagD->isInvalidDecl()))
3746 return TagD;
3747
3748 if (getLangOpts().CPlusPlus &&
Douglas Gregoraa8c9722010-07-13 06:24:26 +00003749 DS.getStorageClassSpec() != DeclSpec::SCS_typedef)
3750 if (EnumDecl *Enum = dyn_cast_or_null<EnumDecl>(Tag))
3751 if (Enum->enumerator_begin() == Enum->enumerator_end() &&
Richard Smithb1402ae2013-03-18 22:52:47 +00003752 !Enum->getIdentifier() && !Enum->isInvalidDecl())
3753 DeclaresAnything = false;
John McCallaa017372011-03-22 23:00:04 +00003754
John McCallaa017372011-03-22 23:00:04 +00003755 if (!DS.isMissingDeclaratorOk()) {
Richard Smithb1402ae2013-03-18 22:52:47 +00003756 // Customize diagnostic for a typedef missing a name.
3757 if (DS.getStorageClassSpec() == DeclSpec::SCS_typedef)
Daniel Dunbar62ee6412012-03-09 18:35:03 +00003758 Diag(DS.getLocStart(), diag::ext_typedef_without_a_name)
Douglas Gregor3a8e0d72010-07-16 15:40:40 +00003759 << DS.getSourceRange();
Richard Smithb1402ae2013-03-18 22:52:47 +00003760 else
3761 DeclaresAnything = false;
Sebastian Redla2b5e312008-12-28 15:28:59 +00003762 }
Mike Stump11289f42009-09-09 15:08:12 +00003763
Richard Smithb1402ae2013-03-18 22:52:47 +00003764 if (DS.isModulePrivateSpecified() &&
Douglas Gregor41866812011-09-12 18:37:38 +00003765 Tag && Tag->getDeclContext()->isFunctionOrMethod())
3766 Diag(DS.getModulePrivateSpecLoc(), diag::err_module_private_local_class)
3767 << Tag->getTagKind()
3768 << FixItHint::CreateRemoval(DS.getModulePrivateSpecLoc());
3769
Richard Smithb1402ae2013-03-18 22:52:47 +00003770 ActOnDocumentableDecl(TagD);
3771
3772 // C 6.7/2:
3773 // A declaration [...] shall declare at least a declarator [...], a tag,
3774 // or the members of an enumeration.
3775 // C++ [dcl.dcl]p3:
3776 // [If there are no declarators], and except for the declaration of an
3777 // unnamed bit-field, the decl-specifier-seq shall introduce one or more
3778 // names into the program, or shall redeclare a name introduced by a
3779 // previous declaration.
3780 if (!DeclaresAnything) {
3781 // In C, we allow this as a (popular) extension / bug. Don't bother
3782 // producing further diagnostics for redundant qualifiers after this.
3783 Diag(DS.getLocStart(), diag::ext_no_declarators) << DS.getSourceRange();
3784 return TagD;
3785 }
3786
3787 // C++ [dcl.stc]p1:
3788 // If a storage-class-specifier appears in a decl-specifier-seq, [...] the
3789 // init-declarator-list of the declaration shall not be empty.
3790 // C++ [dcl.fct.spec]p1:
3791 // If a cv-qualifier appears in a decl-specifier-seq, the
3792 // init-declarator-list of the declaration shall not be empty.
3793 //
3794 // Spurious qualifiers here appear to be valid in C.
3795 unsigned DiagID = diag::warn_standalone_specifier;
3796 if (getLangOpts().CPlusPlus)
3797 DiagID = diag::ext_standalone_specifier;
3798
3799 // Note that a linkage-specification sets a storage class, but
3800 // 'extern "C" struct foo;' is actually valid and not theoretically
3801 // useless.
Aaron Ballman5a1ef6b2014-05-26 17:03:54 +00003802 if (DeclSpec::SCS SCS = DS.getStorageClassSpec()) {
3803 if (SCS == DeclSpec::SCS_mutable)
3804 // Since mutable is not a viable storage class specifier in C, there is
3805 // no reason to treat it as an extension. Instead, diagnose as an error.
3806 Diag(DS.getStorageClassSpecLoc(), diag::err_mutable_nonmember);
3807 else if (!DS.isExternInLinkageSpec() && SCS != DeclSpec::SCS_typedef)
Richard Smithb1402ae2013-03-18 22:52:47 +00003808 Diag(DS.getStorageClassSpecLoc(), DiagID)
3809 << DeclSpec::getSpecifierName(SCS);
Aaron Ballman5a1ef6b2014-05-26 17:03:54 +00003810 }
Richard Smithb1402ae2013-03-18 22:52:47 +00003811
Richard Smithb4a9e862013-04-12 22:46:28 +00003812 if (DeclSpec::TSCS TSCS = DS.getThreadStorageClassSpec())
3813 Diag(DS.getThreadStorageClassSpecLoc(), DiagID)
3814 << DeclSpec::getSpecifierName(TSCS);
Richard Smithb1402ae2013-03-18 22:52:47 +00003815 if (DS.getTypeQualifiers()) {
3816 if (DS.getTypeQualifiers() & DeclSpec::TQ_const)
3817 Diag(DS.getConstSpecLoc(), DiagID) << "const";
3818 if (DS.getTypeQualifiers() & DeclSpec::TQ_volatile)
3819 Diag(DS.getConstSpecLoc(), DiagID) << "volatile";
3820 // Restrict is covered above.
Richard Smith8e1ac332013-03-28 01:55:44 +00003821 if (DS.getTypeQualifiers() & DeclSpec::TQ_atomic)
3822 Diag(DS.getAtomicSpecLoc(), DiagID) << "_Atomic";
Richard Smithb1402ae2013-03-18 22:52:47 +00003823 }
3824
Eli Friedmane3217952011-12-17 00:36:09 +00003825 // Warn about ignored type attributes, for example:
3826 // __attribute__((aligned)) struct A;
Bill Wendling44426052012-12-20 19:22:21 +00003827 // Attributes should be placed after tag to apply to type declaration.
Eli Friedmane3217952011-12-17 00:36:09 +00003828 if (!DS.getAttributes().empty()) {
3829 DeclSpec::TST TypeSpecType = DS.getTypeSpecType();
3830 if (TypeSpecType == DeclSpec::TST_class ||
3831 TypeSpecType == DeclSpec::TST_struct ||
Joao Matosdc86f942012-08-31 18:45:21 +00003832 TypeSpecType == DeclSpec::TST_interface ||
Eli Friedmane3217952011-12-17 00:36:09 +00003833 TypeSpecType == DeclSpec::TST_union ||
3834 TypeSpecType == DeclSpec::TST_enum) {
Saleem Abdulrasool3f31bd62015-06-21 18:20:01 +00003835 for (AttributeList* attrs = DS.getAttributes().getList(); attrs;
Saleem Abdulrasool2e08f502015-06-21 23:05:52 +00003836 attrs = attrs->getNext())
Michael Han360d2252012-10-04 16:42:52 +00003837 Diag(attrs->getLoc(), diag::warn_declspec_attribute_ignored)
Saleem Abdulrasool2e08f502015-06-21 23:05:52 +00003838 << attrs->getName() << GetDiagnosticTypeSpecifierID(TypeSpecType);
Eli Friedmane3217952011-12-17 00:36:09 +00003839 }
3840 }
John McCallaa017372011-03-22 23:00:04 +00003841
John McCall48871652010-08-21 09:40:31 +00003842 return TagD;
Douglas Gregor9ac7a072009-01-07 00:43:41 +00003843}
3844
John McCallea305ed2009-12-18 10:40:03 +00003845/// We are trying to inject an anonymous member into the given scope;
John McCall1f82f242009-11-18 22:49:29 +00003846/// check if there's an existing declaration that can't be overloaded.
3847///
3848/// \return true if this is a forbidden redeclaration
John McCallea305ed2009-12-18 10:40:03 +00003849static bool CheckAnonMemberRedeclaration(Sema &SemaRef,
3850 Scope *S,
Fariborz Jahanian53967e22010-01-22 18:30:17 +00003851 DeclContext *Owner,
John McCallea305ed2009-12-18 10:40:03 +00003852 DeclarationName Name,
3853 SourceLocation NameLoc,
3854 unsigned diagnostic) {
3855 LookupResult R(SemaRef, Name, NameLoc, Sema::LookupMemberName,
3856 Sema::ForRedeclaration);
3857 if (!SemaRef.LookupName(R, S)) return false;
John McCall1f82f242009-11-18 22:49:29 +00003858
John McCallea305ed2009-12-18 10:40:03 +00003859 if (R.getAsSingle<TagDecl>())
John McCall1f82f242009-11-18 22:49:29 +00003860 return false;
3861
3862 // Pick a representative declaration.
John McCallea305ed2009-12-18 10:40:03 +00003863 NamedDecl *PrevDecl = R.getRepresentativeDecl()->getUnderlyingDecl();
Argyrios Kyrtzidise619e992010-09-23 14:26:01 +00003864 assert(PrevDecl && "Expected a non-null Decl");
3865
3866 if (!SemaRef.isDeclInScope(PrevDecl, Owner, S))
3867 return false;
John McCall1f82f242009-11-18 22:49:29 +00003868
John McCallea305ed2009-12-18 10:40:03 +00003869 SemaRef.Diag(NameLoc, diagnostic) << Name;
3870 SemaRef.Diag(PrevDecl->getLocation(), diag::note_previous_declaration);
John McCall1f82f242009-11-18 22:49:29 +00003871
3872 return true;
3873}
3874
Douglas Gregor9ac7a072009-01-07 00:43:41 +00003875/// InjectAnonymousStructOrUnionMembers - Inject the members of the
3876/// anonymous struct or union AnonRecord into the owning context Owner
3877/// and scope S. This routine will be invoked just after we realize
3878/// that an unnamed union or struct is actually an anonymous union or
3879/// struct, e.g.,
3880///
3881/// @code
3882/// union {
3883/// int i;
3884/// float f;
3885/// }; // InjectAnonymousStructOrUnionMembers called here to inject i and
3886/// // f into the surrounding scope.x
3887/// @endcode
3888///
3889/// This routine is recursive, injecting the names of nested anonymous
3890/// structs/unions into the owning context and scope as well.
John McCallb54367d2010-05-21 20:45:30 +00003891static bool InjectAnonymousStructOrUnionMembers(Sema &SemaRef, Scope *S,
Craig Topper5603df42013-07-05 19:34:19 +00003892 DeclContext *Owner,
3893 RecordDecl *AnonRecord,
3894 AccessSpecifier AS,
3895 SmallVectorImpl<NamedDecl *> &Chaining,
3896 bool MSAnonStruct) {
John McCall1f82f242009-11-18 22:49:29 +00003897 unsigned diagKind
3898 = AnonRecord->isUnion() ? diag::err_anonymous_union_member_redecl
3899 : diag::err_anonymous_struct_member_redecl;
3900
Douglas Gregor9ac7a072009-01-07 00:43:41 +00003901 bool Invalid = false;
Francois Pichet0c71f6c2010-11-23 06:07:27 +00003902
3903 // Look every FieldDecl and IndirectFieldDecl with a name.
Aaron Ballman629afae2014-03-07 19:56:05 +00003904 for (auto *D : AnonRecord->decls()) {
3905 if ((isa<FieldDecl>(D) || isa<IndirectFieldDecl>(D)) &&
3906 cast<NamedDecl>(D)->getDeclName()) {
3907 ValueDecl *VD = cast<ValueDecl>(D);
Francois Pichet0c71f6c2010-11-23 06:07:27 +00003908 if (CheckAnonMemberRedeclaration(SemaRef, S, Owner, VD->getDeclName(),
3909 VD->getLocation(), diagKind)) {
Douglas Gregor9ac7a072009-01-07 00:43:41 +00003910 // C++ [class.union]p2:
3911 // The names of the members of an anonymous union shall be
3912 // distinct from the names of any other entity in the
3913 // scope in which the anonymous union is declared.
Douglas Gregor9ac7a072009-01-07 00:43:41 +00003914 Invalid = true;
3915 } else {
3916 // C++ [class.union]p2:
3917 // For the purpose of name lookup, after the anonymous union
3918 // definition, the members of the anonymous union are
3919 // considered to have been defined in the scope in which the
3920 // anonymous union is declared.
Francois Pichet0c71f6c2010-11-23 06:07:27 +00003921 unsigned OldChainingSize = Chaining.size();
3922 if (IndirectFieldDecl *IF = dyn_cast<IndirectFieldDecl>(VD))
Benjamin Kramerf9890422015-02-17 16:48:30 +00003923 Chaining.append(IF->chain_begin(), IF->chain_end());
Francois Pichet0c71f6c2010-11-23 06:07:27 +00003924 else
3925 Chaining.push_back(VD);
3926
Francois Pichet783dd6e2010-11-21 06:08:52 +00003927 assert(Chaining.size() >= 2);
3928 NamedDecl **NamedChain =
3929 new (SemaRef.Context)NamedDecl*[Chaining.size()];
3930 for (unsigned i = 0; i < Chaining.size(); i++)
3931 NamedChain[i] = Chaining[i];
3932
Aaron Ballman260995b2014-10-15 16:58:18 +00003933 IndirectFieldDecl *IndirectField = IndirectFieldDecl::Create(
3934 SemaRef.Context, Owner, VD->getLocation(), VD->getIdentifier(),
3935 VD->getType(), NamedChain, Chaining.size());
3936
3937 for (const auto *Attr : VD->attrs())
3938 IndirectField->addAttr(Attr->clone(SemaRef.Context));
Francois Pichet783dd6e2010-11-21 06:08:52 +00003939
3940 IndirectField->setAccess(AS);
3941 IndirectField->setImplicit();
3942 SemaRef.PushOnScopeChains(IndirectField, S);
John McCallb54367d2010-05-21 20:45:30 +00003943
3944 // That includes picking up the appropriate access specifier.
Francois Pichet0c71f6c2010-11-23 06:07:27 +00003945 if (AS != AS_none) IndirectField->setAccess(AS);
Francois Pichet783dd6e2010-11-21 06:08:52 +00003946
Francois Pichet0c71f6c2010-11-23 06:07:27 +00003947 Chaining.resize(OldChainingSize);
Douglas Gregor9ac7a072009-01-07 00:43:41 +00003948 }
Douglas Gregor9ac7a072009-01-07 00:43:41 +00003949 }
3950 }
3951
3952 return Invalid;
3953}
3954
Douglas Gregorc4df4072010-04-19 22:54:31 +00003955/// StorageClassSpecToVarDeclStorageClass - Maps a DeclSpec::SCS to
3956/// a VarDecl::StorageClass. Any error reporting is up to the caller:
John McCall8e7d6562010-08-26 03:08:43 +00003957/// illegal input values are mapped to SC_None.
3958static StorageClass
Rafael Espindolabff59562013-04-25 12:11:36 +00003959StorageClassSpecToVarDeclStorageClass(const DeclSpec &DS) {
3960 DeclSpec::SCS StorageClassSpec = DS.getStorageClassSpec();
3961 assert(StorageClassSpec != DeclSpec::SCS_typedef &&
3962 "Parser allowed 'typedef' as storage class VarDecl.");
Douglas Gregorc4df4072010-04-19 22:54:31 +00003963 switch (StorageClassSpec) {
John McCall8e7d6562010-08-26 03:08:43 +00003964 case DeclSpec::SCS_unspecified: return SC_None;
Rafael Espindolabff59562013-04-25 12:11:36 +00003965 case DeclSpec::SCS_extern:
3966 if (DS.isExternInLinkageSpec())
3967 return SC_None;
3968 return SC_Extern;
John McCall8e7d6562010-08-26 03:08:43 +00003969 case DeclSpec::SCS_static: return SC_Static;
3970 case DeclSpec::SCS_auto: return SC_Auto;
3971 case DeclSpec::SCS_register: return SC_Register;
3972 case DeclSpec::SCS_private_extern: return SC_PrivateExtern;
Douglas Gregorc4df4072010-04-19 22:54:31 +00003973 // Illegal SCSs map to None: error reporting is up to the caller.
3974 case DeclSpec::SCS_mutable: // Fall through.
John McCall8e7d6562010-08-26 03:08:43 +00003975 case DeclSpec::SCS_typedef: return SC_None;
Douglas Gregorc4df4072010-04-19 22:54:31 +00003976 }
3977 llvm_unreachable("unknown storage class specifier");
3978}
3979
Richard Smithab44d5b2013-12-10 08:25:00 +00003980static SourceLocation findDefaultInitializer(const CXXRecordDecl *Record) {
3981 assert(Record->hasInClassInitializer());
3982
Aaron Ballman629afae2014-03-07 19:56:05 +00003983 for (const auto *I : Record->decls()) {
3984 const auto *FD = dyn_cast<FieldDecl>(I);
3985 if (const auto *IFD = dyn_cast<IndirectFieldDecl>(I))
Richard Smithab44d5b2013-12-10 08:25:00 +00003986 FD = IFD->getAnonField();
3987 if (FD && FD->hasInClassInitializer())
3988 return FD->getLocation();
3989 }
3990
3991 llvm_unreachable("couldn't find in-class initializer");
3992}
3993
3994static void checkDuplicateDefaultInit(Sema &S, CXXRecordDecl *Parent,
3995 SourceLocation DefaultInitLoc) {
3996 if (!Parent->isUnion() || !Parent->hasInClassInitializer())
3997 return;
3998
3999 S.Diag(DefaultInitLoc, diag::err_multiple_mem_union_initialization);
4000 S.Diag(findDefaultInitializer(Parent), diag::note_previous_initializer) << 0;
4001}
4002
4003static void checkDuplicateDefaultInit(Sema &S, CXXRecordDecl *Parent,
4004 CXXRecordDecl *AnonUnion) {
4005 if (!Parent->isUnion() || !Parent->hasInClassInitializer())
4006 return;
4007
4008 checkDuplicateDefaultInit(S, Parent, findDefaultInitializer(AnonUnion));
4009}
4010
Francois Pichet0c71f6c2010-11-23 06:07:27 +00004011/// BuildAnonymousStructOrUnion - Handle the declaration of an
Douglas Gregor9ac7a072009-01-07 00:43:41 +00004012/// anonymous structure or union. Anonymous unions are a C++ feature
Hans Wennborgb64a1fa2012-02-03 15:47:04 +00004013/// (C++ [class.union]) and a C11 feature; anonymous structures
4014/// are a C11 feature and GNU C++ extension.
John McCall48871652010-08-21 09:40:31 +00004015Decl *Sema::BuildAnonymousStructOrUnion(Scope *S, DeclSpec &DS,
Erik Verbruggen888d52a2014-01-15 09:15:43 +00004016 AccessSpecifier AS,
4017 RecordDecl *Record,
4018 const PrintingPolicy &Policy) {
Douglas Gregor9ac7a072009-01-07 00:43:41 +00004019 DeclContext *Owner = Record->getDeclContext();
4020
4021 // Diagnose whether this anonymous struct/union is an extension.
David Blaikiebbafb8a2012-03-11 07:00:24 +00004022 if (Record->isUnion() && !getLangOpts().CPlusPlus && !getLangOpts().C11)
Douglas Gregor9ac7a072009-01-07 00:43:41 +00004023 Diag(Record->getLocation(), diag::ext_anonymous_union);
David Blaikiebbafb8a2012-03-11 07:00:24 +00004024 else if (!Record->isUnion() && getLangOpts().CPlusPlus)
Hans Wennborgb64a1fa2012-02-03 15:47:04 +00004025 Diag(Record->getLocation(), diag::ext_gnu_anonymous_struct);
David Blaikiebbafb8a2012-03-11 07:00:24 +00004026 else if (!Record->isUnion() && !getLangOpts().C11)
Hans Wennborgb64a1fa2012-02-03 15:47:04 +00004027 Diag(Record->getLocation(), diag::ext_c11_anonymous_struct);
Mike Stump11289f42009-09-09 15:08:12 +00004028
Douglas Gregor9ac7a072009-01-07 00:43:41 +00004029 // C and C++ require different kinds of checks for anonymous
4030 // structs/unions.
4031 bool Invalid = false;
David Blaikiebbafb8a2012-03-11 07:00:24 +00004032 if (getLangOpts().CPlusPlus) {
Craig Topperc3ec1492014-05-26 06:22:03 +00004033 const char *PrevSpec = nullptr;
John McCall49bfce42009-08-03 20:12:06 +00004034 unsigned DiagID;
David Blaikie0a8e8992011-10-19 22:43:29 +00004035 if (Record->isUnion()) {
4036 // C++ [class.union]p6:
4037 // Anonymous unions declared in a named namespace or in the
4038 // global namespace shall be declared static.
4039 if (DS.getStorageClassSpec() != DeclSpec::SCS_static &&
4040 (isa<TranslationUnitDecl>(Owner) ||
4041 (isa<NamespaceDecl>(Owner) &&
4042 cast<NamespaceDecl>(Owner)->getDeclName()))) {
David Blaikie733f7bb2011-10-20 02:49:08 +00004043 Diag(Record->getLocation(), diag::err_anonymous_union_not_static)
4044 << FixItHint::CreateInsertion(Record->getLocation(), "static ");
David Blaikie0a8e8992011-10-19 22:43:29 +00004045
4046 // Recover by adding 'static'.
4047 DS.SetStorageClassSpec(*this, DeclSpec::SCS_static, SourceLocation(),
Erik Verbruggen888d52a2014-01-15 09:15:43 +00004048 PrevSpec, DiagID, Policy);
David Blaikie0a8e8992011-10-19 22:43:29 +00004049 }
4050 // C++ [class.union]p6:
4051 // A storage class is not allowed in a declaration of an
4052 // anonymous union in a class scope.
4053 else if (DS.getStorageClassSpec() != DeclSpec::SCS_unspecified &&
4054 isa<RecordDecl>(Owner)) {
4055 Diag(DS.getStorageClassSpecLoc(),
David Blaikie6f686fc2011-10-20 02:10:55 +00004056 diag::err_anonymous_union_with_storage_spec)
4057 << FixItHint::CreateRemoval(DS.getStorageClassSpecLoc());
David Blaikie0a8e8992011-10-19 22:43:29 +00004058
4059 // Recover by removing the storage specifier.
David Blaikie30d15442011-10-19 22:56:21 +00004060 DS.SetStorageClassSpec(*this, DeclSpec::SCS_unspecified,
4061 SourceLocation(),
Erik Verbruggen888d52a2014-01-15 09:15:43 +00004062 PrevSpec, DiagID, Context.getPrintingPolicy());
David Blaikie0a8e8992011-10-19 22:43:29 +00004063 }
Douglas Gregor9ac7a072009-01-07 00:43:41 +00004064 }
Douglas Gregorf4d33272009-01-07 19:46:03 +00004065
Douglas Gregor0f8bc972011-05-09 23:05:33 +00004066 // Ignore const/volatile/restrict qualifiers.
4067 if (DS.getTypeQualifiers()) {
4068 if (DS.getTypeQualifiers() & DeclSpec::TQ_const)
4069 Diag(DS.getConstSpecLoc(), diag::ext_anonymous_struct_union_qualified)
Richard Smith8e1ac332013-03-28 01:55:44 +00004070 << Record->isUnion() << "const"
Douglas Gregor0f8bc972011-05-09 23:05:33 +00004071 << FixItHint::CreateRemoval(DS.getConstSpecLoc());
4072 if (DS.getTypeQualifiers() & DeclSpec::TQ_volatile)
Richard Smith8e1ac332013-03-28 01:55:44 +00004073 Diag(DS.getVolatileSpecLoc(),
David Blaikie30d15442011-10-19 22:56:21 +00004074 diag::ext_anonymous_struct_union_qualified)
Richard Smith8e1ac332013-03-28 01:55:44 +00004075 << Record->isUnion() << "volatile"
Douglas Gregor0f8bc972011-05-09 23:05:33 +00004076 << FixItHint::CreateRemoval(DS.getVolatileSpecLoc());
4077 if (DS.getTypeQualifiers() & DeclSpec::TQ_restrict)
Richard Smith8e1ac332013-03-28 01:55:44 +00004078 Diag(DS.getRestrictSpecLoc(),
David Blaikie30d15442011-10-19 22:56:21 +00004079 diag::ext_anonymous_struct_union_qualified)
Richard Smith8e1ac332013-03-28 01:55:44 +00004080 << Record->isUnion() << "restrict"
Douglas Gregor0f8bc972011-05-09 23:05:33 +00004081 << FixItHint::CreateRemoval(DS.getRestrictSpecLoc());
Richard Smith8e1ac332013-03-28 01:55:44 +00004082 if (DS.getTypeQualifiers() & DeclSpec::TQ_atomic)
4083 Diag(DS.getAtomicSpecLoc(),
4084 diag::ext_anonymous_struct_union_qualified)
4085 << Record->isUnion() << "_Atomic"
4086 << FixItHint::CreateRemoval(DS.getAtomicSpecLoc());
Douglas Gregor0f8bc972011-05-09 23:05:33 +00004087
4088 DS.ClearTypeQualifiers();
4089 }
4090
Mike Stump11289f42009-09-09 15:08:12 +00004091 // C++ [class.union]p2:
Douglas Gregorf4d33272009-01-07 19:46:03 +00004092 // The member-specification of an anonymous union shall only
4093 // define non-static data members. [Note: nested types and
4094 // functions cannot be declared within an anonymous union. ]
Aaron Ballman629afae2014-03-07 19:56:05 +00004095 for (auto *Mem : Record->decls()) {
4096 if (auto *FD = dyn_cast<FieldDecl>(Mem)) {
Douglas Gregorf4d33272009-01-07 19:46:03 +00004097 // C++ [class.union]p3:
4098 // An anonymous union shall not have private or protected
4099 // members (clause 11).
John McCallb54367d2010-05-21 20:45:30 +00004100 assert(FD->getAccess() != AS_none);
4101 if (FD->getAccess() != AS_public) {
Douglas Gregorf4d33272009-01-07 19:46:03 +00004102 Diag(FD->getLocation(), diag::err_anonymous_record_nonpublic_member)
4103 << (int)Record->isUnion() << (int)(FD->getAccess() == AS_protected);
4104 Invalid = true;
4105 }
Argyrios Kyrtzidis33aee392010-08-16 17:27:08 +00004106
Alexis Hunt97ab5542011-05-16 22:41:40 +00004107 // C++ [class.union]p1
4108 // An object of a class with a non-trivial constructor, a non-trivial
4109 // copy constructor, a non-trivial destructor, or a non-trivial copy
4110 // assignment operator cannot be a member of a union, nor can an
4111 // array of such objects.
Richard Smithf720df02011-10-19 20:41:51 +00004112 if (CheckNontrivialField(FD))
Argyrios Kyrtzidis33aee392010-08-16 17:27:08 +00004113 Invalid = true;
Aaron Ballman629afae2014-03-07 19:56:05 +00004114 } else if (Mem->isImplicit()) {
Douglas Gregorf4d33272009-01-07 19:46:03 +00004115 // Any implicit members are fine.
Aaron Ballman629afae2014-03-07 19:56:05 +00004116 } else if (isa<TagDecl>(Mem) && Mem->getDeclContext() != Record) {
Douglas Gregor8761da52009-02-03 00:34:39 +00004117 // This is a type that showed up in an
4118 // elaborated-type-specifier inside the anonymous struct or
4119 // union, but which actually declares a type outside of the
4120 // anonymous struct or union. It's okay.
Aaron Ballman629afae2014-03-07 19:56:05 +00004121 } else if (auto *MemRecord = dyn_cast<RecordDecl>(Mem)) {
Douglas Gregorf4d33272009-01-07 19:46:03 +00004122 if (!MemRecord->isAnonymousStructOrUnion() &&
4123 MemRecord->getDeclName()) {
Francois Pichet4ad4b582010-09-08 11:32:25 +00004124 // Visual C++ allows type definition in anonymous struct or union.
David Blaikiebbafb8a2012-03-11 07:00:24 +00004125 if (getLangOpts().MicrosoftExt)
Francois Pichet4ad4b582010-09-08 11:32:25 +00004126 Diag(MemRecord->getLocation(), diag::ext_anonymous_record_with_type)
4127 << (int)Record->isUnion();
4128 else {
4129 // This is a nested type declaration.
4130 Diag(MemRecord->getLocation(), diag::err_anonymous_record_with_type)
4131 << (int)Record->isUnion();
4132 Invalid = true;
4133 }
Richard Smith254d2662013-01-28 00:54:05 +00004134 } else {
4135 // This is an anonymous type definition within another anonymous type.
4136 // This is a popular extension, provided by Plan9, MSVC and GCC, but
4137 // not part of standard C++.
4138 Diag(MemRecord->getLocation(),
Richard Smithd2029242013-01-31 03:11:12 +00004139 diag::ext_anonymous_record_with_anonymous_type)
4140 << (int)Record->isUnion();
Douglas Gregorf4d33272009-01-07 19:46:03 +00004141 }
Aaron Ballman629afae2014-03-07 19:56:05 +00004142 } else if (isa<AccessSpecDecl>(Mem)) {
Abramo Bagnarad7340582010-06-05 05:09:32 +00004143 // Any access specifier is fine.
Aaron Ballmanf93ef4e2014-06-24 16:22:41 +00004144 } else if (isa<StaticAssertDecl>(Mem)) {
4145 // In C++1z, static_assert declarations are also fine.
Douglas Gregorf4d33272009-01-07 19:46:03 +00004146 } else {
4147 // We have something that isn't a non-static data
4148 // member. Complain about it.
4149 unsigned DK = diag::err_anonymous_record_bad_member;
Aaron Ballman629afae2014-03-07 19:56:05 +00004150 if (isa<TypeDecl>(Mem))
Douglas Gregorf4d33272009-01-07 19:46:03 +00004151 DK = diag::err_anonymous_record_with_type;
Aaron Ballman629afae2014-03-07 19:56:05 +00004152 else if (isa<FunctionDecl>(Mem))
Douglas Gregorf4d33272009-01-07 19:46:03 +00004153 DK = diag::err_anonymous_record_with_function;
Aaron Ballman629afae2014-03-07 19:56:05 +00004154 else if (isa<VarDecl>(Mem))
Douglas Gregorf4d33272009-01-07 19:46:03 +00004155 DK = diag::err_anonymous_record_with_static;
Francois Pichet4ad4b582010-09-08 11:32:25 +00004156
4157 // Visual C++ allows type definition in anonymous struct or union.
David Blaikiebbafb8a2012-03-11 07:00:24 +00004158 if (getLangOpts().MicrosoftExt &&
Francois Pichet4ad4b582010-09-08 11:32:25 +00004159 DK == diag::err_anonymous_record_with_type)
Aaron Ballman629afae2014-03-07 19:56:05 +00004160 Diag(Mem->getLocation(), diag::ext_anonymous_record_with_type)
Douglas Gregorf4d33272009-01-07 19:46:03 +00004161 << (int)Record->isUnion();
Francois Pichet4ad4b582010-09-08 11:32:25 +00004162 else {
Aaron Ballman629afae2014-03-07 19:56:05 +00004163 Diag(Mem->getLocation(), DK)
Francois Pichet4ad4b582010-09-08 11:32:25 +00004164 << (int)Record->isUnion();
Douglas Gregorf4d33272009-01-07 19:46:03 +00004165 Invalid = true;
Francois Pichet4ad4b582010-09-08 11:32:25 +00004166 }
Douglas Gregorf4d33272009-01-07 19:46:03 +00004167 }
4168 }
Richard Smithab44d5b2013-12-10 08:25:00 +00004169
4170 // C++11 [class.union]p8 (DR1460):
4171 // At most one variant member of a union may have a
4172 // brace-or-equal-initializer.
4173 if (cast<CXXRecordDecl>(Record)->hasInClassInitializer() &&
4174 Owner->isRecord())
4175 checkDuplicateDefaultInit(*this, cast<CXXRecordDecl>(Owner),
4176 cast<CXXRecordDecl>(Record));
Mike Stump11289f42009-09-09 15:08:12 +00004177 }
Douglas Gregor9ac7a072009-01-07 00:43:41 +00004178
4179 if (!Record->isUnion() && !Owner->isRecord()) {
Douglas Gregorc6f58fe2009-01-12 22:49:06 +00004180 Diag(Record->getLocation(), diag::err_anonymous_struct_not_member)
David Blaikiebbafb8a2012-03-11 07:00:24 +00004181 << (int)getLangOpts().CPlusPlus;
Douglas Gregor9ac7a072009-01-07 00:43:41 +00004182 Invalid = true;
4183 }
4184
John McCallfa2d6922009-10-22 23:31:08 +00004185 // Mock up a declarator.
Argyrios Kyrtzidis7baa0af2011-06-28 03:01:18 +00004186 Declarator Dc(DS, Declarator::MemberContext);
John McCall8cb7bdf2010-06-04 23:28:52 +00004187 TypeSourceInfo *TInfo = GetTypeForDeclarator(Dc, S);
John McCallbcd03502009-12-07 02:54:59 +00004188 assert(TInfo && "couldn't build declarator info for anonymous struct/union");
John McCallfa2d6922009-10-22 23:31:08 +00004189
Mike Stump11289f42009-09-09 15:08:12 +00004190 // Create a declaration for this anonymous struct/union.
Craig Topperc3ec1492014-05-26 06:22:03 +00004191 NamedDecl *Anon = nullptr;
Douglas Gregor9ac7a072009-01-07 00:43:41 +00004192 if (RecordDecl *OwningClass = dyn_cast<RecordDecl>(Owner)) {
Abramo Bagnaradff19302011-03-08 08:55:46 +00004193 Anon = FieldDecl::Create(Context, OwningClass,
Daniel Dunbar62ee6412012-03-09 18:35:03 +00004194 DS.getLocStart(),
Abramo Bagnaradff19302011-03-08 08:55:46 +00004195 Record->getLocation(),
Craig Topperc3ec1492014-05-26 06:22:03 +00004196 /*IdentifierInfo=*/nullptr,
Argyrios Kyrtzidis6032ef12009-08-21 00:31:54 +00004197 Context.getTypeDeclType(Record),
John McCallbcd03502009-12-07 02:54:59 +00004198 TInfo,
Craig Topperc3ec1492014-05-26 06:22:03 +00004199 /*BitWidth=*/nullptr, /*Mutable=*/false,
Richard Smith2b013182012-06-10 03:12:00 +00004200 /*InitStyle=*/ICIS_NoInit);
John McCallb54367d2010-05-21 20:45:30 +00004201 Anon->setAccess(AS);
David Blaikiebbafb8a2012-03-11 07:00:24 +00004202 if (getLangOpts().CPlusPlus)
Douglas Gregorf4d33272009-01-07 19:46:03 +00004203 FieldCollector->Add(cast<FieldDecl>(Anon));
Douglas Gregor9ac7a072009-01-07 00:43:41 +00004204 } else {
Douglas Gregorc4df4072010-04-19 22:54:31 +00004205 DeclSpec::SCS SCSpec = DS.getStorageClassSpec();
Craig Topperc79e5e32014-10-31 06:57:13 +00004206 StorageClass SC = StorageClassSpecToVarDeclStorageClass(DS);
Douglas Gregorc4df4072010-04-19 22:54:31 +00004207 if (SCSpec == DeclSpec::SCS_mutable) {
Douglas Gregor9ac7a072009-01-07 00:43:41 +00004208 // mutable can only appear on non-static class members, so it's always
4209 // an error here
4210 Diag(Record->getLocation(), diag::err_mutable_nonmember);
4211 Invalid = true;
John McCall8e7d6562010-08-26 03:08:43 +00004212 SC = SC_None;
Douglas Gregor9ac7a072009-01-07 00:43:41 +00004213 }
4214
Abramo Bagnaradff19302011-03-08 08:55:46 +00004215 Anon = VarDecl::Create(Context, Owner,
Daniel Dunbar62ee6412012-03-09 18:35:03 +00004216 DS.getLocStart(),
Craig Topperc3ec1492014-05-26 06:22:03 +00004217 Record->getLocation(), /*IdentifierInfo=*/nullptr,
Argyrios Kyrtzidis6032ef12009-08-21 00:31:54 +00004218 Context.getTypeDeclType(Record),
Rafael Espindola6ae7e502013-04-03 19:27:57 +00004219 TInfo, SC);
Richard Smith40372352011-09-18 00:06:34 +00004220
4221 // Default-initialize the implicit variable. This initialization will be
4222 // trivial in almost all cases, except if a union member has an in-class
4223 // initializer:
4224 // union { int n = 0; };
4225 ActOnUninitializedDecl(Anon, /*TypeMayContainAuto=*/false);
Douglas Gregor9ac7a072009-01-07 00:43:41 +00004226 }
Douglas Gregorf4d33272009-01-07 19:46:03 +00004227 Anon->setImplicit();
Douglas Gregor9ac7a072009-01-07 00:43:41 +00004228
Richard Smithab44d5b2013-12-10 08:25:00 +00004229 // Mark this as an anonymous struct/union type.
4230 Record->setAnonymousStructOrUnion(true);
4231
Douglas Gregor9ac7a072009-01-07 00:43:41 +00004232 // Add the anonymous struct/union object to the current
4233 // context. We'll be referencing this object when we refer to one of
4234 // its members.
Argyrios Kyrtzidiscfbfe782009-06-30 02:36:12 +00004235 Owner->addDecl(Anon);
Richard Smithab44d5b2013-12-10 08:25:00 +00004236
Douglas Gregor9ac7a072009-01-07 00:43:41 +00004237 // Inject the members of the anonymous struct/union into the owning
4238 // context and into the identifier resolver chain for name lookup
4239 // purposes.
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004240 SmallVector<NamedDecl*, 2> Chain;
Francois Pichet783dd6e2010-11-21 06:08:52 +00004241 Chain.push_back(Anon);
4242
Francois Pichet0c71f6c2010-11-23 06:07:27 +00004243 if (InjectAnonymousStructOrUnionMembers(*this, S, Owner, Record, AS,
4244 Chain, false))
Douglas Gregorc6f58fe2009-01-12 22:49:06 +00004245 Invalid = true;
Douglas Gregor9ac7a072009-01-07 00:43:41 +00004246
David Majnemer2206bf52014-03-05 08:57:59 +00004247 if (VarDecl *NewVD = dyn_cast<VarDecl>(Anon)) {
4248 if (getLangOpts().CPlusPlus && NewVD->isStaticLocal()) {
4249 Decl *ManglingContextDecl;
David Majnemera7f8c462015-03-19 21:54:30 +00004250 if (MangleNumberingContext *MCtx = getCurrentMangleNumberContext(
4251 NewVD->getDeclContext(), ManglingContextDecl)) {
4252 Context.setManglingNumber(
4253 NewVD, MCtx->getManglingNumber(
4254 NewVD, getMSManglingNumber(getLangOpts(), S)));
David Majnemer2206bf52014-03-05 08:57:59 +00004255 Context.setStaticLocalNumber(NewVD, MCtx->getStaticLocalNumber(NewVD));
4256 }
4257 }
4258 }
4259
Douglas Gregor9ac7a072009-01-07 00:43:41 +00004260 if (Invalid)
4261 Anon->setInvalidDecl();
4262
John McCall48871652010-08-21 09:40:31 +00004263 return Anon;
Chris Lattnerb6738ec2007-01-28 00:38:24 +00004264}
4265
Francois Pichet0c71f6c2010-11-23 06:07:27 +00004266/// BuildMicrosoftCAnonymousStruct - Handle the declaration of an
4267/// Microsoft C anonymous structure.
4268/// Ref: http://msdn.microsoft.com/en-us/library/z2cx9y4f.aspx
4269/// Example:
4270///
4271/// struct A { int a; };
4272/// struct B { struct A; int b; };
4273///
4274/// void foo() {
4275/// B var;
David Majnemer8f0ed912014-08-11 07:29:54 +00004276/// var.a = 3;
Francois Pichet0c71f6c2010-11-23 06:07:27 +00004277/// }
4278///
4279Decl *Sema::BuildMicrosoftCAnonymousStruct(Scope *S, DeclSpec &DS,
4280 RecordDecl *Record) {
David Majnemer8f0ed912014-08-11 07:29:54 +00004281 assert(Record && "expected a record!");
Francois Pichet0c71f6c2010-11-23 06:07:27 +00004282
4283 // Mock up a declarator.
4284 Declarator Dc(DS, Declarator::TypeNameContext);
4285 TypeSourceInfo *TInfo = GetTypeForDeclarator(Dc, S);
4286 assert(TInfo && "couldn't build declarator info for anonymous struct");
4287
David Majnemerd8e366b2014-09-18 00:42:05 +00004288 auto *ParentDecl = cast<RecordDecl>(CurContext);
4289 QualType RecTy = Context.getTypeDeclType(Record);
4290
Francois Pichet0c71f6c2010-11-23 06:07:27 +00004291 // Create a declaration for this anonymous struct.
Craig Topperc3ec1492014-05-26 06:22:03 +00004292 NamedDecl *Anon = FieldDecl::Create(Context,
David Majnemerd8e366b2014-09-18 00:42:05 +00004293 ParentDecl,
Daniel Dunbar62ee6412012-03-09 18:35:03 +00004294 DS.getLocStart(),
4295 DS.getLocStart(),
Craig Topperc3ec1492014-05-26 06:22:03 +00004296 /*IdentifierInfo=*/nullptr,
David Majnemerd8e366b2014-09-18 00:42:05 +00004297 RecTy,
Francois Pichet0c71f6c2010-11-23 06:07:27 +00004298 TInfo,
Craig Topperc3ec1492014-05-26 06:22:03 +00004299 /*BitWidth=*/nullptr, /*Mutable=*/false,
Richard Smith2b013182012-06-10 03:12:00 +00004300 /*InitStyle=*/ICIS_NoInit);
Francois Pichet0c71f6c2010-11-23 06:07:27 +00004301 Anon->setImplicit();
4302
4303 // Add the anonymous struct object to the current context.
4304 CurContext->addDecl(Anon);
4305
4306 // Inject the members of the anonymous struct into the current
4307 // context and into the identifier resolver chain for name lookup
4308 // purposes.
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004309 SmallVector<NamedDecl*, 2> Chain;
Francois Pichet0c71f6c2010-11-23 06:07:27 +00004310 Chain.push_back(Anon);
4311
Nico Weberf8bb3de2012-02-01 00:41:00 +00004312 RecordDecl *RecordDef = Record->getDefinition();
David Majnemerd8e366b2014-09-18 00:42:05 +00004313 if (RequireCompleteType(Anon->getLocation(), RecTy,
4314 diag::err_field_incomplete) ||
4315 InjectAnonymousStructOrUnionMembers(*this, S, CurContext, RecordDef,
4316 AS_none, Chain, true)) {
Francois Pichet0c71f6c2010-11-23 06:07:27 +00004317 Anon->setInvalidDecl();
David Majnemerd8e366b2014-09-18 00:42:05 +00004318 ParentDecl->setInvalidDecl();
4319 }
Francois Pichet0c71f6c2010-11-23 06:07:27 +00004320
4321 return Anon;
4322}
Steve Naroff2fea1392007-09-02 02:04:30 +00004323
Douglas Gregor92751d42008-11-17 22:58:34 +00004324/// GetNameForDeclarator - Determine the full declaration name for the
4325/// given Declarator.
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00004326DeclarationNameInfo Sema::GetNameForDeclarator(Declarator &D) {
Douglas Gregora121b752009-11-03 16:56:39 +00004327 return GetNameFromUnqualifiedId(D.getName());
4328}
4329
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00004330/// \brief Retrieves the declaration name from a parsed unqualified-id.
4331DeclarationNameInfo
4332Sema::GetNameFromUnqualifiedId(const UnqualifiedId &Name) {
4333 DeclarationNameInfo NameInfo;
4334 NameInfo.setLoc(Name.StartLocation);
4335
Douglas Gregor7861a802009-11-03 01:35:08 +00004336 switch (Name.getKind()) {
Alexis Hunt34458502009-11-28 04:44:28 +00004337
Fariborz Jahanian7f4427f2011-07-12 17:16:56 +00004338 case UnqualifiedId::IK_ImplicitSelfParam:
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00004339 case UnqualifiedId::IK_Identifier:
4340 NameInfo.setName(Name.Identifier);
4341 NameInfo.setLoc(Name.StartLocation);
4342 return NameInfo;
Alexis Hunt34458502009-11-28 04:44:28 +00004343
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00004344 case UnqualifiedId::IK_OperatorFunctionId:
4345 NameInfo.setName(Context.DeclarationNames.getCXXOperatorName(
4346 Name.OperatorFunctionId.Operator));
4347 NameInfo.setLoc(Name.StartLocation);
4348 NameInfo.getInfo().CXXOperatorName.BeginOpNameLoc
4349 = Name.OperatorFunctionId.SymbolLocations[0];
4350 NameInfo.getInfo().CXXOperatorName.EndOpNameLoc
4351 = Name.EndLocation.getRawEncoding();
4352 return NameInfo;
Douglas Gregor9de54ea2010-01-13 17:31:36 +00004353
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00004354 case UnqualifiedId::IK_LiteralOperatorId:
4355 NameInfo.setName(Context.DeclarationNames.getCXXLiteralOperatorName(
4356 Name.Identifier));
4357 NameInfo.setLoc(Name.StartLocation);
4358 NameInfo.setCXXLiteralOperatorNameLoc(Name.EndLocation);
4359 return NameInfo;
Douglas Gregor9de54ea2010-01-13 17:31:36 +00004360
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00004361 case UnqualifiedId::IK_ConversionFunctionId: {
4362 TypeSourceInfo *TInfo;
4363 QualType Ty = GetTypeFromParser(Name.ConversionFunctionId, &TInfo);
4364 if (Ty.isNull())
4365 return DeclarationNameInfo();
4366 NameInfo.setName(Context.DeclarationNames.getCXXConversionFunctionName(
4367 Context.getCanonicalType(Ty)));
4368 NameInfo.setLoc(Name.StartLocation);
4369 NameInfo.setNamedTypeInfo(TInfo);
4370 return NameInfo;
Douglas Gregord90fd522009-09-25 21:45:23 +00004371 }
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00004372
4373 case UnqualifiedId::IK_ConstructorName: {
4374 TypeSourceInfo *TInfo;
4375 QualType Ty = GetTypeFromParser(Name.ConstructorName, &TInfo);
4376 if (Ty.isNull())
4377 return DeclarationNameInfo();
4378 NameInfo.setName(Context.DeclarationNames.getCXXConstructorName(
4379 Context.getCanonicalType(Ty)));
4380 NameInfo.setLoc(Name.StartLocation);
4381 NameInfo.setNamedTypeInfo(TInfo);
4382 return NameInfo;
4383 }
4384
4385 case UnqualifiedId::IK_ConstructorTemplateId: {
4386 // In well-formed code, we can only have a constructor
4387 // template-id that refers to the current context, so go there
4388 // to find the actual type being constructed.
4389 CXXRecordDecl *CurClass = dyn_cast<CXXRecordDecl>(CurContext);
4390 if (!CurClass || CurClass->getIdentifier() != Name.TemplateId->Name)
4391 return DeclarationNameInfo();
4392
4393 // Determine the type of the class being constructed.
4394 QualType CurClassType = Context.getTypeDeclType(CurClass);
4395
4396 // FIXME: Check two things: that the template-id names the same type as
4397 // CurClassType, and that the template-id does not occur when the name
4398 // was qualified.
4399
4400 NameInfo.setName(Context.DeclarationNames.getCXXConstructorName(
4401 Context.getCanonicalType(CurClassType)));
4402 NameInfo.setLoc(Name.StartLocation);
4403 // FIXME: should we retrieve TypeSourceInfo?
Craig Topperc3ec1492014-05-26 06:22:03 +00004404 NameInfo.setNamedTypeInfo(nullptr);
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00004405 return NameInfo;
4406 }
4407
4408 case UnqualifiedId::IK_DestructorName: {
4409 TypeSourceInfo *TInfo;
4410 QualType Ty = GetTypeFromParser(Name.DestructorName, &TInfo);
4411 if (Ty.isNull())
4412 return DeclarationNameInfo();
4413 NameInfo.setName(Context.DeclarationNames.getCXXDestructorName(
4414 Context.getCanonicalType(Ty)));
4415 NameInfo.setLoc(Name.StartLocation);
4416 NameInfo.setNamedTypeInfo(TInfo);
4417 return NameInfo;
4418 }
4419
4420 case UnqualifiedId::IK_TemplateId: {
John McCall3e56fd42010-08-23 07:28:44 +00004421 TemplateName TName = Name.TemplateId->Template.get();
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00004422 SourceLocation TNameLoc = Name.TemplateId->TemplateNameLoc;
4423 return Context.getNameForTemplate(TName, TNameLoc);
4424 }
4425
4426 } // switch (Name.getKind())
4427
David Blaikie83d382b2011-09-23 05:06:16 +00004428 llvm_unreachable("Unknown name kind");
Douglas Gregor92751d42008-11-17 22:58:34 +00004429}
4430
Kaelyn Uhrain7d9bc632011-08-04 17:40:00 +00004431static QualType getCoreType(QualType Ty) {
4432 do {
4433 if (Ty->isPointerType() || Ty->isReferenceType())
4434 Ty = Ty->getPointeeType();
4435 else if (Ty->isArrayType())
4436 Ty = Ty->castAsArrayTypeUnsafe()->getElementType();
4437 else
4438 return Ty.withoutLocalFastQualifiers();
4439 } while (true);
4440}
4441
Kaelyn Uhrain0a32fca2011-10-11 00:28:39 +00004442/// hasSimilarParameters - Determine whether the C++ functions Declaration
4443/// and Definition have "nearly" matching parameters. This heuristic is
4444/// used to improve diagnostics in the case where an out-of-line function
4445/// definition doesn't match any declaration within the class or namespace.
4446/// Also sets Params to the list of indices to the parameters that differ
4447/// between the declaration and the definition. If hasSimilarParameters
4448/// returns true and Params is empty, then all of the parameters match.
4449static bool hasSimilarParameters(ASTContext &Context,
Douglas Gregor8af63e42009-02-06 17:46:57 +00004450 FunctionDecl *Declaration,
Kaelyn Uhrain7d9bc632011-08-04 17:40:00 +00004451 FunctionDecl *Definition,
Dmitri Gribenkof8579502013-01-12 19:30:44 +00004452 SmallVectorImpl<unsigned> &Params) {
Kaelyn Uhrain7d9bc632011-08-04 17:40:00 +00004453 Params.clear();
Douglas Gregorad590502008-12-15 23:53:10 +00004454 if (Declaration->param_size() != Definition->param_size())
4455 return false;
4456 for (unsigned Idx = 0; Idx < Declaration->param_size(); ++Idx) {
4457 QualType DeclParamTy = Declaration->getParamDecl(Idx)->getType();
4458 QualType DefParamTy = Definition->getParamDecl(Idx)->getType();
4459
Kaelyn Uhrain7d9bc632011-08-04 17:40:00 +00004460 // The parameter types are identical
Matt Beaumont-Gay56381b82011-08-23 01:35:51 +00004461 if (Context.hasSameType(DefParamTy, DeclParamTy))
Kaelyn Uhrain7d9bc632011-08-04 17:40:00 +00004462 continue;
4463
4464 QualType DeclParamBaseTy = getCoreType(DeclParamTy);
4465 QualType DefParamBaseTy = getCoreType(DefParamTy);
4466 const IdentifierInfo *DeclTyName = DeclParamBaseTy.getBaseTypeIdentifier();
4467 const IdentifierInfo *DefTyName = DefParamBaseTy.getBaseTypeIdentifier();
4468
4469 if (Context.hasSameUnqualifiedType(DeclParamBaseTy, DefParamBaseTy) ||
4470 (DeclTyName && DeclTyName == DefTyName))
4471 Params.push_back(Idx);
4472 else // The two parameters aren't even close
Douglas Gregorad590502008-12-15 23:53:10 +00004473 return false;
4474 }
4475
4476 return true;
4477}
4478
John McCall99b2fe52010-04-29 23:50:39 +00004479/// NeedsRebuildingInCurrentInstantiation - Checks whether the given
4480/// declarator needs to be rebuilt in the current instantiation.
4481/// Any bits of declarator which appear before the name are valid for
4482/// consideration here. That's specifically the type in the decl spec
4483/// and the base type in any member-pointer chunks.
4484static bool RebuildDeclaratorInCurrentInstantiation(Sema &S, Declarator &D,
4485 DeclarationName Name) {
4486 // The types we specifically need to rebuild are:
4487 // - typenames, typeofs, and decltypes
4488 // - types which will become injected class names
4489 // Of course, we also need to rebuild any type referencing such a
4490 // type. It's safest to just say "dependent", but we call out a
4491 // few cases here.
4492
4493 DeclSpec &DS = D.getMutableDeclSpec();
4494 switch (DS.getTypeSpecType()) {
4495 case DeclSpec::TST_typename:
4496 case DeclSpec::TST_typeofType:
Eli Friedman0dfb8892011-10-06 23:00:33 +00004497 case DeclSpec::TST_underlyingType:
4498 case DeclSpec::TST_atomic: {
John McCall99b2fe52010-04-29 23:50:39 +00004499 // Grab the type from the parser.
Craig Topperc3ec1492014-05-26 06:22:03 +00004500 TypeSourceInfo *TSI = nullptr;
John McCallba7bf592010-08-24 05:47:05 +00004501 QualType T = S.GetTypeFromParser(DS.getRepAsType(), &TSI);
John McCall99b2fe52010-04-29 23:50:39 +00004502 if (T.isNull() || !T->isDependentType()) break;
4503
4504 // Make sure there's a type source info. This isn't really much
4505 // of a waste; most dependent types should have type source info
4506 // attached already.
4507 if (!TSI)
4508 TSI = S.Context.getTrivialTypeSourceInfo(T, DS.getTypeSpecTypeLoc());
4509
4510 // Rebuild the type in the current instantiation.
4511 TSI = S.RebuildTypeInCurrentInstantiation(TSI, D.getIdentifierLoc(), Name);
4512 if (!TSI) return true;
4513
4514 // Store the new type back in the decl spec.
John McCallba7bf592010-08-24 05:47:05 +00004515 ParsedType LocType = S.CreateParsedType(TSI->getType(), TSI);
4516 DS.UpdateTypeRep(LocType);
4517 break;
4518 }
4519
Richard Smith1620ebd2012-10-01 20:35:07 +00004520 case DeclSpec::TST_decltype:
John McCallba7bf592010-08-24 05:47:05 +00004521 case DeclSpec::TST_typeofExpr: {
4522 Expr *E = DS.getRepAsExpr();
John McCalldadc5752010-08-24 06:29:42 +00004523 ExprResult Result = S.RebuildExprInCurrentInstantiation(E);
John McCallba7bf592010-08-24 05:47:05 +00004524 if (Result.isInvalid()) return true;
4525 DS.UpdateExprRep(Result.get());
John McCall99b2fe52010-04-29 23:50:39 +00004526 break;
4527 }
4528
4529 default:
4530 // Nothing to do for these decl specs.
4531 break;
4532 }
4533
4534 // It doesn't matter what order we do this in.
4535 for (unsigned I = 0, E = D.getNumTypeObjects(); I != E; ++I) {
4536 DeclaratorChunk &Chunk = D.getTypeObject(I);
4537
4538 // The only type information in the declarator which can come
4539 // before the declaration name is the base type of a member
4540 // pointer.
4541 if (Chunk.Kind != DeclaratorChunk::MemberPointer)
4542 continue;
4543
4544 // Rebuild the scope specifier in-place.
4545 CXXScopeSpec &SS = Chunk.Mem.Scope();
4546 if (S.RebuildNestedNameSpecifierInCurrentInstantiation(SS))
4547 return true;
4548 }
4549
4550 return false;
4551}
4552
Anders Carlsson1052fd72011-07-04 16:28:17 +00004553Decl *Sema::ActOnDeclarator(Scope *S, Declarator &D) {
Douglas Gregor5d1b4e32011-11-07 20:56:01 +00004554 D.setFunctionDefinitionKind(FDK_Declaration);
Benjamin Kramercc4c49d2012-08-23 23:38:35 +00004555 Decl *Dcl = HandleDeclarator(S, D, MultiTemplateParamsArg());
Argyrios Kyrtzidis8ad3bab2011-11-23 20:27:36 +00004556
4557 if (OriginalLexicalContext && OriginalLexicalContext->isObjCContainer() &&
Douglas Gregor205b0682012-04-30 18:13:01 +00004558 Dcl && Dcl->getDeclContext()->isFileContext())
Argyrios Kyrtzidis8ad3bab2011-11-23 20:27:36 +00004559 Dcl->setTopLevelDeclInObjCContainer();
4560
4561 return Dcl;
John McCallde6836a2010-08-24 07:21:54 +00004562}
4563
Richard Smithdda56e42011-04-15 14:24:37 +00004564/// DiagnoseClassNameShadow - Implement C++ [class.mem]p13:
4565/// If T is the name of a class, then each of the following shall have a
4566/// name different from T:
4567/// - every static data member of class T;
4568/// - every member function of class T
4569/// - every member of class T that is itself a type;
4570/// \returns true if the declaration name violates these rules.
4571bool Sema::DiagnoseClassNameShadow(DeclContext *DC,
4572 DeclarationNameInfo NameInfo) {
4573 DeclarationName Name = NameInfo.getName();
4574
4575 if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(DC))
4576 if (Record->getIdentifier() && Record->getDeclName() == Name) {
4577 Diag(NameInfo.getLoc(), diag::err_member_name_of_class) << Name;
4578 return true;
4579 }
4580
4581 return false;
4582}
Douglas Gregor31feb332012-03-17 23:06:31 +00004583
Douglas Gregorb7d17dd2012-03-28 16:01:27 +00004584/// \brief Diagnose a declaration whose declarator-id has the given
4585/// nested-name-specifier.
4586///
4587/// \param SS The nested-name-specifier of the declarator-id.
4588///
4589/// \param DC The declaration context to which the nested-name-specifier
4590/// resolves.
4591///
4592/// \param Name The name of the entity being declared.
4593///
4594/// \param Loc The location of the name of the entity being declared.
Douglas Gregor31feb332012-03-17 23:06:31 +00004595///
4596/// \returns true if we cannot safely recover from this error, false otherwise.
Douglas Gregorb7d17dd2012-03-28 16:01:27 +00004597bool Sema::diagnoseQualifiedDeclaration(CXXScopeSpec &SS, DeclContext *DC,
Douglas Gregor31feb332012-03-17 23:06:31 +00004598 DeclarationName Name,
Richard Smitha2302242013-12-05 07:51:02 +00004599 SourceLocation Loc) {
Douglas Gregorb7d17dd2012-03-28 16:01:27 +00004600 DeclContext *Cur = CurContext;
Eli Friedmane2358c12013-08-12 21:54:01 +00004601 while (isa<LinkageSpecDecl>(Cur) || isa<CapturedDecl>(Cur))
Douglas Gregorb7d17dd2012-03-28 16:01:27 +00004602 Cur = Cur->getParent();
Richard Smitha2302242013-12-05 07:51:02 +00004603
4604 // If the user provided a superfluous scope specifier that refers back to the
4605 // class in which the entity is already declared, diagnose and ignore it.
Douglas Gregor31feb332012-03-17 23:06:31 +00004606 //
4607 // class X {
4608 // void X::f();
4609 // };
Richard Smitha2302242013-12-05 07:51:02 +00004610 //
4611 // Note, it was once ill-formed to give redundant qualification in all
4612 // contexts, but that rule was removed by DR482.
Douglas Gregorb7d17dd2012-03-28 16:01:27 +00004613 if (Cur->Equals(DC)) {
Richard Smitha2302242013-12-05 07:51:02 +00004614 if (Cur->isRecord()) {
4615 Diag(Loc, LangOpts.MicrosoftExt ? diag::warn_member_extra_qualification
4616 : diag::err_member_extra_qualification)
4617 << Name << FixItHint::CreateRemoval(SS.getRange());
4618 SS.clear();
4619 } else {
4620 Diag(Loc, diag::warn_namespace_member_extra_qualification) << Name;
4621 }
Douglas Gregor31feb332012-03-17 23:06:31 +00004622 return false;
Richard Smitha2302242013-12-05 07:51:02 +00004623 }
Douglas Gregorb7d17dd2012-03-28 16:01:27 +00004624
4625 // Check whether the qualifying scope encloses the scope of the original
4626 // declaration.
4627 if (!Cur->Encloses(DC)) {
4628 if (Cur->isRecord())
4629 Diag(Loc, diag::err_member_qualification)
4630 << Name << SS.getRange();
4631 else if (isa<TranslationUnitDecl>(DC))
4632 Diag(Loc, diag::err_invalid_declarator_global_scope)
4633 << Name << SS.getRange();
4634 else if (isa<FunctionDecl>(Cur))
4635 Diag(Loc, diag::err_invalid_declarator_in_function)
4636 << Name << SS.getRange();
Eli Friedmane2358c12013-08-12 21:54:01 +00004637 else if (isa<BlockDecl>(Cur))
4638 Diag(Loc, diag::err_invalid_declarator_in_block)
4639 << Name << SS.getRange();
Douglas Gregorb7d17dd2012-03-28 16:01:27 +00004640 else
4641 Diag(Loc, diag::err_invalid_declarator_scope)
Richard Smith82269842012-04-13 04:07:40 +00004642 << Name << cast<NamedDecl>(Cur) << cast<NamedDecl>(DC) << SS.getRange();
Douglas Gregorb7d17dd2012-03-28 16:01:27 +00004643
Douglas Gregor31feb332012-03-17 23:06:31 +00004644 return true;
Douglas Gregorb7d17dd2012-03-28 16:01:27 +00004645 }
4646
4647 if (Cur->isRecord()) {
4648 // Cannot qualify members within a class.
4649 Diag(Loc, diag::err_member_qualification)
4650 << Name << SS.getRange();
4651 SS.clear();
4652
4653 // C++ constructors and destructors with incorrect scopes can break
4654 // our AST invariants by having the wrong underlying types. If
4655 // that's the case, then drop this declaration entirely.
4656 if ((Name.getNameKind() == DeclarationName::CXXConstructorName ||
4657 Name.getNameKind() == DeclarationName::CXXDestructorName) &&
4658 !Context.hasSameType(Name.getCXXNameType(),
4659 Context.getTypeDeclType(cast<CXXRecordDecl>(Cur))))
4660 return true;
4661
4662 return false;
4663 }
Douglas Gregor31feb332012-03-17 23:06:31 +00004664
Douglas Gregorb7d17dd2012-03-28 16:01:27 +00004665 // C++11 [dcl.meaning]p1:
4666 // [...] "The nested-name-specifier of the qualified declarator-id shall
4667 // not begin with a decltype-specifer"
4668 NestedNameSpecifierLoc SpecLoc(SS.getScopeRep(), SS.location_data());
4669 while (SpecLoc.getPrefix())
4670 SpecLoc = SpecLoc.getPrefix();
4671 if (dyn_cast_or_null<DecltypeType>(
4672 SpecLoc.getNestedNameSpecifier()->getAsType()))
4673 Diag(Loc, diag::err_decltype_in_declarator)
4674 << SpecLoc.getTypeLoc().getSourceRange();
4675
Douglas Gregor31feb332012-03-17 23:06:31 +00004676 return false;
4677}
4678
Rafael Espindola0a67e2f2013-01-08 20:44:06 +00004679NamedDecl *Sema::HandleDeclarator(Scope *S, Declarator &D,
4680 MultiTemplateParamsArg TemplateParamLists) {
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00004681 // TODO: consider using NameInfo for diagnostic.
4682 DeclarationNameInfo NameInfo = GetNameForDeclarator(D);
4683 DeclarationName Name = NameInfo.getName();
Douglas Gregor92751d42008-11-17 22:58:34 +00004684
Chris Lattner02c04392007-07-25 00:24:17 +00004685 // All of these full declarators require an identifier. If it doesn't have
4686 // one, the ParsedFreeStandingDeclSpec action should be used.
Douglas Gregor92751d42008-11-17 22:58:34 +00004687 if (!Name) {
Chris Lattnerf6d1c9c2009-04-25 08:06:05 +00004688 if (!D.isInvalidType()) // Reject this if we think it is valid.
Daniel Dunbar62ee6412012-03-09 18:35:03 +00004689 Diag(D.getDeclSpec().getLocStart(),
Chris Lattner3b054132008-11-19 05:08:23 +00004690 diag::err_declarator_need_ident)
4691 << D.getDeclSpec().getSourceRange() << D.getSourceRange();
Craig Topperc3ec1492014-05-26 06:22:03 +00004692 return nullptr;
Douglas Gregorc4356532010-12-16 00:46:58 +00004693 } else if (DiagnoseUnexpandedParameterPack(NameInfo, UPPC_DeclarationType))
Craig Topperc3ec1492014-05-26 06:22:03 +00004694 return nullptr;
Mike Stump11289f42009-09-09 15:08:12 +00004695
Chris Lattner1a76a3c2007-08-26 06:24:45 +00004696 // The scope passed in may not be a decl scope. Zip up the scope tree until
4697 // we find one that is.
Douglas Gregor91f84212008-12-11 16:49:14 +00004698 while ((S->getFlags() & Scope::DeclScope) == 0 ||
Douglas Gregorded2d7b2009-02-04 19:02:06 +00004699 (S->getFlags() & Scope::TemplateParamScope) != 0)
Chris Lattner1a76a3c2007-08-26 06:24:45 +00004700 S = S->getParent();
Mike Stump11289f42009-09-09 15:08:12 +00004701
John McCall99b2fe52010-04-29 23:50:39 +00004702 DeclContext *DC = CurContext;
4703 if (D.getCXXScopeSpec().isInvalid())
4704 D.setInvalidType();
4705 else if (D.getCXXScopeSpec().isSet()) {
Douglas Gregor6c110f32010-12-16 01:14:37 +00004706 if (DiagnoseUnexpandedParameterPack(D.getCXXScopeSpec(),
4707 UPPC_DeclarationQualifier))
Craig Topperc3ec1492014-05-26 06:22:03 +00004708 return nullptr;
Douglas Gregor6c110f32010-12-16 01:14:37 +00004709
John McCall99b2fe52010-04-29 23:50:39 +00004710 bool EnteringContext = !D.getDeclSpec().isFriendSpecified();
4711 DC = computeDeclContext(D.getCXXScopeSpec(), EnteringContext);
Richard Smith8ac1c922013-11-25 21:30:29 +00004712 if (!DC || isa<EnumDecl>(DC)) {
John McCall99b2fe52010-04-29 23:50:39 +00004713 // If we could not compute the declaration context, it's because the
4714 // declaration context is dependent but does not refer to a class,
4715 // class template, or class template partial specialization. Complain
4716 // and return early, to avoid the coming semantic disaster.
4717 Diag(D.getIdentifierLoc(),
4718 diag::err_template_qualified_declarator_no_match)
Aaron Ballman4a979672014-01-03 13:56:08 +00004719 << D.getCXXScopeSpec().getScopeRep()
John McCall99b2fe52010-04-29 23:50:39 +00004720 << D.getCXXScopeSpec().getRange();
Craig Topperc3ec1492014-05-26 06:22:03 +00004721 return nullptr;
John McCall99b2fe52010-04-29 23:50:39 +00004722 }
John McCall99b2fe52010-04-29 23:50:39 +00004723 bool IsDependentContext = DC->isDependentContext();
John McCall4d6d6132009-12-19 09:35:56 +00004724
John McCall99b2fe52010-04-29 23:50:39 +00004725 if (!IsDependentContext &&
John McCall0b66eb32010-05-01 00:40:08 +00004726 RequireCompleteDeclContext(D.getCXXScopeSpec(), DC))
Craig Topperc3ec1492014-05-26 06:22:03 +00004727 return nullptr;
John McCall99b2fe52010-04-29 23:50:39 +00004728
Serge Pavlov47ebb752015-06-10 19:06:59 +00004729 // If a class is incomplete, do not parse entities inside it.
Douglas Gregorb7d17dd2012-03-28 16:01:27 +00004730 if (isa<CXXRecordDecl>(DC) && !cast<CXXRecordDecl>(DC)->hasDefinition()) {
4731 Diag(D.getIdentifierLoc(),
4732 diag::err_member_def_undefined_record)
4733 << Name << DC << D.getCXXScopeSpec().getRange();
Serge Pavlov47ebb752015-06-10 19:06:59 +00004734 return nullptr;
4735 }
4736 if (!D.getDeclSpec().isFriendSpecified()) {
Douglas Gregorb7d17dd2012-03-28 16:01:27 +00004737 if (diagnoseQualifiedDeclaration(D.getCXXScopeSpec(), DC,
4738 Name, D.getIdentifierLoc())) {
4739 if (DC->isRecord())
Craig Topperc3ec1492014-05-26 06:22:03 +00004740 return nullptr;
4741
Douglas Gregorb7d17dd2012-03-28 16:01:27 +00004742 D.setInvalidType();
Douglas Gregora007d362010-10-13 22:19:53 +00004743 }
John McCall99b2fe52010-04-29 23:50:39 +00004744 }
4745
4746 // Check whether we need to rebuild the type of the given
4747 // declaration in the current instantiation.
4748 if (EnteringContext && IsDependentContext &&
4749 TemplateParamLists.size() != 0) {
4750 ContextRAII SavedContext(*this, DC);
4751 if (RebuildDeclaratorInCurrentInstantiation(*this, D, Name))
4752 D.setInvalidType();
Douglas Gregor15acfb92009-08-06 16:20:37 +00004753 }
4754 }
Richard Smithdda56e42011-04-15 14:24:37 +00004755
John McCall8cb7bdf2010-06-04 23:28:52 +00004756 TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S);
4757 QualType R = TInfo->getType();
Douglas Gregoreddf4332009-02-24 20:03:32 +00004758
Richard Smitha60a6db2015-07-06 01:04:39 +00004759 if (!R->isFunctionType() && DiagnoseClassNameShadow(DC, NameInfo))
4760 // If this is a typedef, we'll end up spewing multiple diagnostics.
4761 // Just return early; it's safer. If this is a function, let the
4762 // "constructor cannot have a return type" diagnostic handle it.
4763 if (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_typedef)
4764 return nullptr;
4765
Douglas Gregor506bd562010-12-13 22:49:22 +00004766 if (DiagnoseUnexpandedParameterPack(D.getIdentifierLoc(), TInfo,
4767 UPPC_DeclarationType))
4768 D.setInvalidType();
4769
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00004770 LookupResult Previous(*this, NameInfo, LookupOrdinaryName,
John McCall1f82f242009-11-18 22:49:29 +00004771 ForRedeclaration);
4772
Richard Smitha534a312015-07-21 23:54:07 +00004773 // If we're hiding internal-linkage symbols in modules from redeclaration
4774 // lookup, let name lookup know.
4775 if ((getLangOpts().Modules || getLangOpts().ModulesLocalVisibility) &&
4776 getLangOpts().ModulesHideInternalLinkage &&
4777 D.getDeclSpec().getStorageClassSpec() != DeclSpec::SCS_typedef)
4778 Previous.setAllowHiddenInternal(false);
4779
Argyrios Kyrtzidis16ac9be2008-11-08 17:17:31 +00004780 // See if this is a redefinition of a variable in the same scope.
John McCall99b2fe52010-04-29 23:50:39 +00004781 if (!D.getCXXScopeSpec().isSet()) {
John McCall1f82f242009-11-18 22:49:29 +00004782 bool IsLinkageLookup = false;
Richard Smith1c34fb72013-08-13 18:18:50 +00004783 bool CreateBuiltins = false;
Douglas Gregoreddf4332009-02-24 20:03:32 +00004784
4785 // If the declaration we're planning to build will be a function
4786 // or object with linkage, then look for another declaration with
4787 // linkage (C99 6.2.2p4-5 and C++ [basic.link]p6).
Richard Smith1c34fb72013-08-13 18:18:50 +00004788 //
4789 // If the declaration we're planning to build will be declared with
4790 // external linkage in the translation unit, create any builtin with
4791 // the same name.
Douglas Gregoreddf4332009-02-24 20:03:32 +00004792 if (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_typedef)
4793 /* Do nothing*/;
Richard Smith1c34fb72013-08-13 18:18:50 +00004794 else if (CurContext->isFunctionOrMethod() &&
4795 (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_extern ||
4796 R->isFunctionType())) {
John McCall1f82f242009-11-18 22:49:29 +00004797 IsLinkageLookup = true;
Richard Smith1c34fb72013-08-13 18:18:50 +00004798 CreateBuiltins =
4799 CurContext->getEnclosingNamespaceContext()->isTranslationUnit();
4800 } else if (CurContext->getRedeclContext()->isTranslationUnit() &&
4801 D.getDeclSpec().getStorageClassSpec() != DeclSpec::SCS_static)
4802 CreateBuiltins = true;
John McCall1f82f242009-11-18 22:49:29 +00004803
4804 if (IsLinkageLookup)
4805 Previous.clear(LookupRedeclarationWithLinkage);
Douglas Gregoreddf4332009-02-24 20:03:32 +00004806
Richard Smith1c34fb72013-08-13 18:18:50 +00004807 LookupName(Previous, S, CreateBuiltins);
Argyrios Kyrtzidis16ac9be2008-11-08 17:17:31 +00004808 } else { // Something like "int foo::x;"
John McCall1f82f242009-11-18 22:49:29 +00004809 LookupQualifiedName(Previous, DC);
4810
Douglas Gregorb7d17dd2012-03-28 16:01:27 +00004811 // C++ [dcl.meaning]p1:
4812 // When the declarator-id is qualified, the declaration shall refer to a
4813 // previously declared member of the class or namespace to which the
4814 // qualifier refers (or, in the case of a namespace, of an element of the
4815 // inline namespace set of that namespace (7.3.1)) or to a specialization
4816 // thereof; [...]
Argyrios Kyrtzidis16ac9be2008-11-08 17:17:31 +00004817 //
Douglas Gregorb7d17dd2012-03-28 16:01:27 +00004818 // Note that we already checked the context above, and that we do not have
4819 // enough information to make sure that Previous contains the declaration
4820 // we want to match. For example, given:
Douglas Gregorad590502008-12-15 23:53:10 +00004821 //
Douglas Gregor4287b372008-12-12 08:25:50 +00004822 // class X {
4823 // void f();
Douglas Gregorad590502008-12-15 23:53:10 +00004824 // void f(float);
Douglas Gregor4287b372008-12-12 08:25:50 +00004825 // };
4826 //
Douglas Gregorad590502008-12-15 23:53:10 +00004827 // void X::f(int) { } // ill-formed
4828 //
Douglas Gregorb7d17dd2012-03-28 16:01:27 +00004829 // In this case, Previous will point to the overload set
Douglas Gregorad590502008-12-15 23:53:10 +00004830 // containing the two f's declared in X, but neither of them
Mike Stump11289f42009-09-09 15:08:12 +00004831 // matches.
Douglas Gregorb7d17dd2012-03-28 16:01:27 +00004832
4833 // C++ [dcl.meaning]p1:
4834 // [...] the member shall not merely have been introduced by a
4835 // using-declaration in the scope of the class or namespace nominated by
4836 // the nested-name-specifier of the declarator-id.
4837 RemoveUsingDecls(Previous);
Argyrios Kyrtzidis16ac9be2008-11-08 17:17:31 +00004838 }
4839
John McCall1f82f242009-11-18 22:49:29 +00004840 if (Previous.isSingleResult() &&
4841 Previous.getFoundDecl()->isTemplateParameter()) {
Douglas Gregor5101c242008-12-05 18:15:24 +00004842 // Maybe we will complain about the shadowed template parameter.
Mike Stump11289f42009-09-09 15:08:12 +00004843 if (!D.isInvalidType())
Douglas Gregorf4ef4d22011-10-20 17:58:49 +00004844 DiagnoseTemplateParameterShadow(D.getIdentifierLoc(),
4845 Previous.getFoundDecl());
Mike Stump11289f42009-09-09 15:08:12 +00004846
Douglas Gregor5101c242008-12-05 18:15:24 +00004847 // Just pretend that we didn't see the previous declaration.
John McCall1f82f242009-11-18 22:49:29 +00004848 Previous.clear();
Douglas Gregor5101c242008-12-05 18:15:24 +00004849 }
4850
Douglas Gregor83a586e2008-04-13 21:07:44 +00004851 // In C++, the previous declaration we find might be a tag type
4852 // (class or enum). In this case, the new declaration will hide the
Douglas Gregorfb034662009-01-28 17:15:10 +00004853 // tag type. Note that this does does not apply if we're declaring a
4854 // typedef (C++ [dcl.typedef]p4).
John McCall1f82f242009-11-18 22:49:29 +00004855 if (Previous.isSingleTagDecl() &&
Kaelyn Uhrain5dfc94b2013-12-16 19:25:47 +00004856 D.getDeclSpec().getStorageClassSpec() != DeclSpec::SCS_typedef)
John McCall1f82f242009-11-18 22:49:29 +00004857 Previous.clear();
Douglas Gregor83a586e2008-04-13 21:07:44 +00004858
Richard Smith5afcdf3f2013-03-06 01:37:38 +00004859 // Check that there are no default arguments other than in the parameters
4860 // of a function declaration (C++ only).
4861 if (getLangOpts().CPlusPlus)
4862 CheckExtraCXXDefaultArguments(D);
4863
Hubert Tong27f06972015-07-22 13:32:36 +00004864 if (D.getDeclSpec().isConceptSpecified()) {
4865 // C++ Concepts TS [dcl.spec.concept]p1: The concept specifier shall be
4866 // applied only to the definition of a function template or variable
4867 // template, declared in namespace scope
4868 if (!DC->getRedeclContext()->isFileContext()) {
4869 Diag(D.getIdentifierLoc(),
4870 diag::err_concept_decls_may_only_appear_in_namespace_scope);
4871 return nullptr;
4872 }
4873 }
4874
Nico Webercb4c7f42012-12-23 00:40:46 +00004875 NamedDecl *New;
4876
Francois Pichet00c7e6c2011-08-14 03:52:19 +00004877 bool AddToScope = true;
Chris Lattner01a7c532007-01-25 23:09:03 +00004878 if (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_typedef) {
Douglas Gregorb52fabb2009-06-23 23:11:28 +00004879 if (TemplateParamLists.size()) {
4880 Diag(D.getIdentifierLoc(), diag::err_template_typedef);
Craig Topperc3ec1492014-05-26 06:22:03 +00004881 return nullptr;
Douglas Gregorb52fabb2009-06-23 23:11:28 +00004882 }
Mike Stump11289f42009-09-09 15:08:12 +00004883
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00004884 New = ActOnTypedefDeclarator(S, D, DC, TInfo, Previous);
Douglas Gregoreddf4332009-02-24 20:03:32 +00004885 } else if (R->isFunctionType()) {
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00004886 New = ActOnFunctionDeclarator(S, D, DC, TInfo, Previous,
Benjamin Kramer62b95d82012-08-23 21:35:17 +00004887 TemplateParamLists,
Francois Pichet00c7e6c2011-08-14 03:52:19 +00004888 AddToScope);
Chris Lattner01a7c532007-01-25 23:09:03 +00004889 } else {
Larisse Voufo39a1e502013-08-06 01:03:05 +00004890 New = ActOnVariableDeclarator(S, D, DC, TInfo, Previous, TemplateParamLists,
4891 AddToScope);
Chris Lattner01a7c532007-01-25 23:09:03 +00004892 }
Zhongxing Xubece5d62009-01-16 01:13:29 +00004893
Craig Topperc3ec1492014-05-26 06:22:03 +00004894 if (!New)
4895 return nullptr;
Mike Stump11289f42009-09-09 15:08:12 +00004896
Douglas Gregor3a923c2d2009-09-24 23:14:47 +00004897 // If this has an identifier and is not an invalid redeclaration or
4898 // function template specialization, add it to the scope stack.
Francois Pichet00c7e6c2011-08-14 03:52:19 +00004899 if (New->getDeclName() && AddToScope &&
Richard Smith541b38b2013-09-20 01:15:31 +00004900 !(D.isRedeclaration() && New->isInvalidDecl())) {
4901 // Only make a locally-scoped extern declaration visible if it is the first
4902 // declaration of this entity. Qualified lookup for such an entity should
4903 // only find this declaration if there is no visible declaration of it.
4904 bool AddToContext = !D.isRedeclaration() || !New->isLocalExternDecl();
4905 PushOnScopeChains(New, S, AddToContext);
4906 if (!AddToContext)
4907 CurContext->addHiddenDecl(New);
4908 }
Mike Stump11289f42009-09-09 15:08:12 +00004909
John McCall48871652010-08-21 09:40:31 +00004910 return New;
Chris Lattnere168f762006-11-10 05:29:30 +00004911}
4912
Abramo Bagnaraad9f2e22012-11-08 16:27:30 +00004913/// Helper method to turn variable array types into constant array
4914/// types in certain situations which would otherwise be errors (for
4915/// GCC compatibility).
Eli Friedmana3b1d032009-02-21 00:44:51 +00004916static QualType TryToFixInvalidVariablyModifiedType(QualType T,
4917 ASTContext &Context,
Douglas Gregorcaa1bf42010-08-18 00:39:00 +00004918 bool &SizeIsNegative,
4919 llvm::APSInt &Oversized) {
Eli Friedmana3b1d032009-02-21 00:44:51 +00004920 // This method tries to turn a variable array into a constant
4921 // array even when the size isn't an ICE. This is necessary
4922 // for compatibility with code that depends on gcc's buggy
4923 // constant expression folding, like struct {char x[(int)(char*)2];}
4924 SizeIsNegative = false;
Douglas Gregorcaa1bf42010-08-18 00:39:00 +00004925 Oversized = 0;
4926
4927 if (T->isDependentType())
4928 return QualType();
4929
John McCall8ccfcb52009-09-24 19:53:00 +00004930 QualifierCollector Qs;
4931 const Type *Ty = Qs.strip(T);
4932
4933 if (const PointerType* PTy = dyn_cast<PointerType>(Ty)) {
Eli Friedmana3b1d032009-02-21 00:44:51 +00004934 QualType Pointee = PTy->getPointeeType();
4935 QualType FixedType =
Douglas Gregorcaa1bf42010-08-18 00:39:00 +00004936 TryToFixInvalidVariablyModifiedType(Pointee, Context, SizeIsNegative,
4937 Oversized);
Eli Friedmana3b1d032009-02-21 00:44:51 +00004938 if (FixedType.isNull()) return FixedType;
Eli Friedman44c0f2a2009-02-21 00:58:02 +00004939 FixedType = Context.getPointerType(FixedType);
John McCall717d9b02010-12-10 11:01:00 +00004940 return Qs.apply(Context, FixedType);
Eli Friedmana3b1d032009-02-21 00:44:51 +00004941 }
Abramo Bagnara924a8f32010-12-10 16:29:40 +00004942 if (const ParenType* PTy = dyn_cast<ParenType>(Ty)) {
4943 QualType Inner = PTy->getInnerType();
4944 QualType FixedType =
4945 TryToFixInvalidVariablyModifiedType(Inner, Context, SizeIsNegative,
4946 Oversized);
4947 if (FixedType.isNull()) return FixedType;
4948 FixedType = Context.getParenType(FixedType);
4949 return Qs.apply(Context, FixedType);
4950 }
Eli Friedmana3b1d032009-02-21 00:44:51 +00004951
4952 const VariableArrayType* VLATy = dyn_cast<VariableArrayType>(T);
Eli Friedmanadf40d42009-02-26 03:58:54 +00004953 if (!VLATy)
4954 return QualType();
4955 // FIXME: We should probably handle this case
4956 if (VLATy->getElementType()->isVariablyModifiedType())
4957 return QualType();
Mike Stump11289f42009-09-09 15:08:12 +00004958
Richard Smith42d3af92011-12-07 00:43:50 +00004959 llvm::APSInt Res;
Eli Friedmana3b1d032009-02-21 00:44:51 +00004960 if (!VLATy->getSizeExpr() ||
Richard Smith42d3af92011-12-07 00:43:50 +00004961 !VLATy->getSizeExpr()->EvaluateAsInt(Res, Context))
Eli Friedmana3b1d032009-02-21 00:44:51 +00004962 return QualType();
Eli Friedmanadf40d42009-02-26 03:58:54 +00004963
Douglas Gregorcaa1bf42010-08-18 00:39:00 +00004964 // Check whether the array size is negative.
Douglas Gregorcaa1bf42010-08-18 00:39:00 +00004965 if (Res.isSigned() && Res.isNegative()) {
4966 SizeIsNegative = true;
4967 return QualType();
Douglas Gregor04318252009-07-06 15:59:29 +00004968 }
Eli Friedmana3b1d032009-02-21 00:44:51 +00004969
Douglas Gregorcaa1bf42010-08-18 00:39:00 +00004970 // Check whether the array is too large to be addressed.
4971 unsigned ActiveSizeBits
4972 = ConstantArrayType::getNumAddressingBits(Context, VLATy->getElementType(),
4973 Res);
4974 if (ActiveSizeBits > ConstantArrayType::getMaxSizeBits(Context)) {
4975 Oversized = Res;
4976 return QualType();
4977 }
4978
4979 return Context.getConstantArrayType(VLATy->getElementType(),
4980 Res, ArrayType::Normal, 0);
Eli Friedmana3b1d032009-02-21 00:44:51 +00004981}
4982
Abramo Bagnara341ab732012-11-08 14:44:42 +00004983static void
4984FixInvalidVariablyModifiedTypeLoc(TypeLoc SrcTL, TypeLoc DstTL) {
David Majnemerbc4cc142015-04-18 04:55:51 +00004985 SrcTL = SrcTL.getUnqualifiedLoc();
4986 DstTL = DstTL.getUnqualifiedLoc();
David Blaikie6adc78e2013-02-18 22:06:02 +00004987 if (PointerTypeLoc SrcPTL = SrcTL.getAs<PointerTypeLoc>()) {
4988 PointerTypeLoc DstPTL = DstTL.castAs<PointerTypeLoc>();
4989 FixInvalidVariablyModifiedTypeLoc(SrcPTL.getPointeeLoc(),
4990 DstPTL.getPointeeLoc());
4991 DstPTL.setStarLoc(SrcPTL.getStarLoc());
Abramo Bagnara341ab732012-11-08 14:44:42 +00004992 return;
4993 }
David Blaikie6adc78e2013-02-18 22:06:02 +00004994 if (ParenTypeLoc SrcPTL = SrcTL.getAs<ParenTypeLoc>()) {
4995 ParenTypeLoc DstPTL = DstTL.castAs<ParenTypeLoc>();
4996 FixInvalidVariablyModifiedTypeLoc(SrcPTL.getInnerLoc(),
4997 DstPTL.getInnerLoc());
4998 DstPTL.setLParenLoc(SrcPTL.getLParenLoc());
4999 DstPTL.setRParenLoc(SrcPTL.getRParenLoc());
Abramo Bagnara341ab732012-11-08 14:44:42 +00005000 return;
5001 }
David Blaikie6adc78e2013-02-18 22:06:02 +00005002 ArrayTypeLoc SrcATL = SrcTL.castAs<ArrayTypeLoc>();
5003 ArrayTypeLoc DstATL = DstTL.castAs<ArrayTypeLoc>();
5004 TypeLoc SrcElemTL = SrcATL.getElementLoc();
5005 TypeLoc DstElemTL = DstATL.getElementLoc();
Abramo Bagnara341ab732012-11-08 14:44:42 +00005006 DstElemTL.initializeFullCopy(SrcElemTL);
David Blaikie6adc78e2013-02-18 22:06:02 +00005007 DstATL.setLBracketLoc(SrcATL.getLBracketLoc());
5008 DstATL.setSizeExpr(SrcATL.getSizeExpr());
5009 DstATL.setRBracketLoc(SrcATL.getRBracketLoc());
Abramo Bagnara341ab732012-11-08 14:44:42 +00005010}
5011
Abramo Bagnaraad9f2e22012-11-08 16:27:30 +00005012/// Helper method to turn variable array types into constant array
5013/// types in certain situations which would otherwise be errors (for
5014/// GCC compatibility).
Abramo Bagnara341ab732012-11-08 14:44:42 +00005015static TypeSourceInfo*
5016TryToFixInvalidVariablyModifiedTypeSourceInfo(TypeSourceInfo *TInfo,
5017 ASTContext &Context,
5018 bool &SizeIsNegative,
5019 llvm::APSInt &Oversized) {
5020 QualType FixedTy
5021 = TryToFixInvalidVariablyModifiedType(TInfo->getType(), Context,
5022 SizeIsNegative, Oversized);
5023 if (FixedTy.isNull())
Craig Topperc3ec1492014-05-26 06:22:03 +00005024 return nullptr;
Abramo Bagnara341ab732012-11-08 14:44:42 +00005025 TypeSourceInfo *FixedTInfo = Context.getTrivialTypeSourceInfo(FixedTy);
5026 FixInvalidVariablyModifiedTypeLoc(TInfo->getTypeLoc(),
5027 FixedTInfo->getTypeLoc());
5028 return FixedTInfo;
5029}
5030
Richard Smith78165b52013-01-10 23:43:47 +00005031/// \brief Register the given locally-scoped extern "C" declaration so
Richard Smith39b79682013-06-18 20:15:12 +00005032/// that it can be found later for redeclarations. We include any extern "C"
5033/// declaration that is not visible in the translation unit here, not just
5034/// function-scope declarations.
Mike Stump11289f42009-09-09 15:08:12 +00005035void
Richard Smith39b79682013-06-18 20:15:12 +00005036Sema::RegisterLocallyScopedExternCDecl(NamedDecl *ND, Scope *S) {
Richard Smithac974a32013-06-30 09:48:50 +00005037 if (!getLangOpts().CPlusPlus &&
5038 ND->getLexicalDeclContext()->getRedeclContext()->isTranslationUnit())
5039 // Don't need to track declarations in the TU in C.
5040 return;
5041
Douglas Gregor5a80bd12009-03-02 00:19:53 +00005042 // Note that we have a locally-scoped external with this name.
Richard Smithf19e1272015-03-07 00:04:49 +00005043 Context.getExternCContextDecl()->makeDeclVisibleInContext(ND);
Douglas Gregor5a80bd12009-03-02 00:19:53 +00005044}
5045
Richard Smith39b79682013-06-18 20:15:12 +00005046NamedDecl *Sema::findLocallyScopedExternCDecl(DeclarationName Name) {
Richard Smithf19e1272015-03-07 00:04:49 +00005047 // FIXME: We can have multiple results via __attribute__((overloadable)).
5048 auto Result = Context.getExternCContextDecl()->lookup(Name);
5049 return Result.empty() ? nullptr : *Result.begin();
Douglas Gregordc5c9582011-07-28 14:20:37 +00005050}
5051
Eli Friedman574c7452009-04-07 19:37:57 +00005052/// \brief Diagnose function specifiers on a declaration of an identifier that
5053/// does not identify a function.
Richard Smithb1402ae2013-03-18 22:52:47 +00005054void Sema::DiagnoseFunctionSpecifiers(const DeclSpec &DS) {
Eli Friedman574c7452009-04-07 19:37:57 +00005055 // FIXME: We should probably indicate the identifier in question to avoid
5056 // confusion for constructs like "inline int a(), b;"
Richard Smithb1402ae2013-03-18 22:52:47 +00005057 if (DS.isInlineSpecified())
5058 Diag(DS.getInlineSpecLoc(),
Eli Friedman574c7452009-04-07 19:37:57 +00005059 diag::err_inline_non_function);
5060
Richard Smithb1402ae2013-03-18 22:52:47 +00005061 if (DS.isVirtualSpecified())
5062 Diag(DS.getVirtualSpecLoc(),
Eli Friedman574c7452009-04-07 19:37:57 +00005063 diag::err_virtual_non_function);
5064
Richard Smithb1402ae2013-03-18 22:52:47 +00005065 if (DS.isExplicitSpecified())
5066 Diag(DS.getExplicitSpecLoc(),
Eli Friedman574c7452009-04-07 19:37:57 +00005067 diag::err_explicit_non_function);
Richard Smith0015f092013-01-17 22:16:11 +00005068
Richard Smithb1402ae2013-03-18 22:52:47 +00005069 if (DS.isNoreturnSpecified())
5070 Diag(DS.getNoreturnSpecLoc(),
Richard Smith0015f092013-01-17 22:16:11 +00005071 diag::err_noreturn_non_function);
Eli Friedman574c7452009-04-07 19:37:57 +00005072}
5073
Douglas Gregor6e6ad602009-01-20 01:17:11 +00005074NamedDecl*
Zhongxing Xuac8ef9e2009-01-16 03:34:13 +00005075Sema::ActOnTypedefDeclarator(Scope* S, Declarator& D, DeclContext* DC,
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00005076 TypeSourceInfo *TInfo, LookupResult &Previous) {
Zhongxing Xuac8ef9e2009-01-16 03:34:13 +00005077 // Typedef declarators cannot be qualified (C++ [dcl.meaning]p1).
5078 if (D.getCXXScopeSpec().isSet()) {
5079 Diag(D.getIdentifierLoc(), diag::err_qualified_typedef_declarator)
5080 << D.getCXXScopeSpec().getRange();
Chris Lattnerf6d1c9c2009-04-25 08:06:05 +00005081 D.setInvalidType();
Zhongxing Xuac8ef9e2009-01-16 03:34:13 +00005082 // Pretend we didn't see the scope specifier.
Douglas Gregorb525ef82010-03-23 15:26:55 +00005083 DC = CurContext;
5084 Previous.clear();
Zhongxing Xuac8ef9e2009-01-16 03:34:13 +00005085 }
5086
Richard Smithb1402ae2013-03-18 22:52:47 +00005087 DiagnoseFunctionSpecifiers(D.getDeclSpec());
Eli Friedman574c7452009-04-07 19:37:57 +00005088
Richard Smitha77a0a62011-08-15 21:04:07 +00005089 if (D.getDeclSpec().isConstexprSpecified())
5090 Diag(D.getDeclSpec().getConstexprSpecLoc(), diag::err_invalid_constexpr)
5091 << 1;
Eli Friedmand5c0eed2009-04-19 20:27:55 +00005092
Douglas Gregord8f446f2010-07-13 06:37:01 +00005093 if (D.getName().Kind != UnqualifiedId::IK_Identifier) {
5094 Diag(D.getName().StartLocation, diag::err_typedef_not_identifier)
5095 << D.getName().getSourceRange();
Craig Topperc3ec1492014-05-26 06:22:03 +00005096 return nullptr;
Douglas Gregord8f446f2010-07-13 06:37:01 +00005097 }
5098
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00005099 TypedefDecl *NewTD = ParseTypedefDecl(S, D, TInfo->getType(), TInfo);
Craig Topperc3ec1492014-05-26 06:22:03 +00005100 if (!NewTD) return nullptr;
Mike Stump11289f42009-09-09 15:08:12 +00005101
Zhongxing Xuac8ef9e2009-01-16 03:34:13 +00005102 // Handle attributes prior to checking for duplicates in MergeVarDecl
Douglas Gregor758a8692009-06-17 21:51:59 +00005103 ProcessDeclAttributes(S, NewTD, D);
John McCall1f82f242009-11-18 22:49:29 +00005104
Richard Smith3f1b5d02011-05-05 21:57:07 +00005105 CheckTypedefForVariablyModifiedType(S, NewTD);
5106
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00005107 bool Redeclaration = D.isRedeclaration();
5108 NamedDecl *ND = ActOnTypedefNameDecl(S, DC, NewTD, Previous, Redeclaration);
5109 D.setRedeclaration(Redeclaration);
5110 return ND;
Richard Smithdda56e42011-04-15 14:24:37 +00005111}
5112
Richard Smith3f1b5d02011-05-05 21:57:07 +00005113void
5114Sema::CheckTypedefForVariablyModifiedType(Scope *S, TypedefNameDecl *NewTD) {
Chris Lattner9fecd742009-04-19 05:21:20 +00005115 // C99 6.7.7p2: If a typedef name specifies a variably modified type
5116 // then it shall have block scope.
Eli Friedman88f4ed92010-08-10 03:13:15 +00005117 // Note that variably modified types must be fixed before merging the decl so
5118 // that redeclarations will match.
Abramo Bagnara341ab732012-11-08 14:44:42 +00005119 TypeSourceInfo *TInfo = NewTD->getTypeSourceInfo();
5120 QualType T = TInfo->getType();
Chris Lattner9fecd742009-04-19 05:21:20 +00005121 if (T->isVariablyModifiedType()) {
John McCallaab3e412010-08-25 08:40:02 +00005122 getCurFunction()->setHasBranchProtectedScope();
Mike Stump11289f42009-09-09 15:08:12 +00005123
Craig Topperc3ec1492014-05-26 06:22:03 +00005124 if (S->getFnParent() == nullptr) {
Eli Friedmana3b1d032009-02-21 00:44:51 +00005125 bool SizeIsNegative;
Douglas Gregorcaa1bf42010-08-18 00:39:00 +00005126 llvm::APSInt Oversized;
Abramo Bagnara341ab732012-11-08 14:44:42 +00005127 TypeSourceInfo *FixedTInfo =
5128 TryToFixInvalidVariablyModifiedTypeSourceInfo(TInfo, Context,
5129 SizeIsNegative,
5130 Oversized);
5131 if (FixedTInfo) {
Richard Smithdda56e42011-04-15 14:24:37 +00005132 Diag(NewTD->getLocation(), diag::warn_illegal_constant_array_size);
Abramo Bagnara341ab732012-11-08 14:44:42 +00005133 NewTD->setTypeSourceInfo(FixedTInfo);
Eli Friedmana3b1d032009-02-21 00:44:51 +00005134 } else {
5135 if (SizeIsNegative)
Richard Smithdda56e42011-04-15 14:24:37 +00005136 Diag(NewTD->getLocation(), diag::err_typecheck_negative_array_size);
Eli Friedmana3b1d032009-02-21 00:44:51 +00005137 else if (T->isVariableArrayType())
Richard Smithdda56e42011-04-15 14:24:37 +00005138 Diag(NewTD->getLocation(), diag::err_vla_decl_in_file_scope);
Douglas Gregorcaa1bf42010-08-18 00:39:00 +00005139 else if (Oversized.getBoolValue())
David Blaikie30d15442011-10-19 22:56:21 +00005140 Diag(NewTD->getLocation(), diag::err_array_too_large)
5141 << Oversized.toString(10);
Eli Friedmana3b1d032009-02-21 00:44:51 +00005142 else
Richard Smithdda56e42011-04-15 14:24:37 +00005143 Diag(NewTD->getLocation(), diag::err_vm_decl_in_file_scope);
Chris Lattnerf6d1c9c2009-04-25 08:06:05 +00005144 NewTD->setInvalidDecl();
Eli Friedmana3b1d032009-02-21 00:44:51 +00005145 }
Zhongxing Xuac8ef9e2009-01-16 03:34:13 +00005146 }
5147 }
Richard Smith3f1b5d02011-05-05 21:57:07 +00005148}
Douglas Gregor27821ce2009-07-07 16:35:42 +00005149
Richard Smith3f1b5d02011-05-05 21:57:07 +00005150
5151/// ActOnTypedefNameDecl - Perform semantic checking for a declaration which
5152/// declares a typedef-name, either using the 'typedef' type specifier or via
5153/// a C++0x [dcl.typedef]p2 alias-declaration: 'using T = A;'.
5154NamedDecl*
5155Sema::ActOnTypedefNameDecl(Scope *S, DeclContext *DC, TypedefNameDecl *NewTD,
5156 LookupResult &Previous, bool &Redeclaration) {
Eli Friedman88f4ed92010-08-10 03:13:15 +00005157 // Merge the decl with the existing one if appropriate. If the decl is
5158 // in an outer scope, it isn't the same thing.
Richard Smith72bcaec2013-12-05 04:30:04 +00005159 FilterLookupForScope(Previous, DC, S, /*ConsiderLinkage*/false,
5160 /*AllowInlineNamespace*/false);
Richard Smith42413142015-05-15 20:05:43 +00005161 filterNonConflictingPreviousTypedefDecls(*this, NewTD, Previous);
Eli Friedman88f4ed92010-08-10 03:13:15 +00005162 if (!Previous.empty()) {
5163 Redeclaration = true;
Richard Smithdda56e42011-04-15 14:24:37 +00005164 MergeTypedefNameDecl(NewTD, Previous);
Eli Friedman88f4ed92010-08-10 03:13:15 +00005165 }
5166
Douglas Gregor27821ce2009-07-07 16:35:42 +00005167 // If this is the C FILE type, notify the AST context.
5168 if (IdentifierInfo *II = NewTD->getIdentifier())
5169 if (!NewTD->isInvalidDecl() &&
Sebastian Redl50c68252010-08-31 00:36:30 +00005170 NewTD->getDeclContext()->getRedeclContext()->isTranslationUnit()) {
Mike Stumpa4de80b2009-07-28 02:25:19 +00005171 if (II->isStr("FILE"))
5172 Context.setFILEDecl(NewTD);
5173 else if (II->isStr("jmp_buf"))
5174 Context.setjmp_bufDecl(NewTD);
5175 else if (II->isStr("sigjmp_buf"))
5176 Context.setsigjmp_bufDecl(NewTD);
Rafael Espindola6cfa82b2011-11-13 21:51:09 +00005177 else if (II->isStr("ucontext_t"))
5178 Context.setucontext_tDecl(NewTD);
Mike Stumpa4de80b2009-07-28 02:25:19 +00005179 }
5180
Zhongxing Xuac8ef9e2009-01-16 03:34:13 +00005181 return NewTD;
5182}
5183
Douglas Gregor5d68a202009-02-24 19:23:27 +00005184/// \brief Determines whether the given declaration is an out-of-scope
5185/// previous declaration.
5186///
5187/// This routine should be invoked when name lookup has found a
5188/// previous declaration (PrevDecl) that is not in the scope where a
5189/// new declaration by the same name is being introduced. If the new
5190/// declaration occurs in a local scope, previous declarations with
5191/// linkage may still be considered previous declarations (C99
5192/// 6.2.2p4-5, C++ [basic.link]p6).
5193///
5194/// \param PrevDecl the previous declaration found by name
5195/// lookup
Mike Stump11289f42009-09-09 15:08:12 +00005196///
Douglas Gregor5d68a202009-02-24 19:23:27 +00005197/// \param DC the context in which the new declaration is being
5198/// declared.
5199///
5200/// \returns true if PrevDecl is an out-of-scope previous declaration
5201/// for a new delcaration with the same name.
Mike Stump11289f42009-09-09 15:08:12 +00005202static bool
Douglas Gregor5d68a202009-02-24 19:23:27 +00005203isOutOfScopePreviousDeclaration(NamedDecl *PrevDecl, DeclContext *DC,
5204 ASTContext &Context) {
5205 if (!PrevDecl)
Sebastian Redl50c68252010-08-31 00:36:30 +00005206 return false;
Douglas Gregor5d68a202009-02-24 19:23:27 +00005207
Douglas Gregoreddf4332009-02-24 20:03:32 +00005208 if (!PrevDecl->hasLinkage())
5209 return false;
Douglas Gregor5d68a202009-02-24 19:23:27 +00005210
David Blaikiebbafb8a2012-03-11 07:00:24 +00005211 if (Context.getLangOpts().CPlusPlus) {
Douglas Gregor5d68a202009-02-24 19:23:27 +00005212 // C++ [basic.link]p6:
5213 // If there is a visible declaration of an entity with linkage
5214 // having the same name and type, ignoring entities declared
5215 // outside the innermost enclosing namespace scope, the block
5216 // scope declaration declares that same entity and receives the
5217 // linkage of the previous declaration.
Sebastian Redl50c68252010-08-31 00:36:30 +00005218 DeclContext *OuterContext = DC->getRedeclContext();
Douglas Gregor5d68a202009-02-24 19:23:27 +00005219 if (!OuterContext->isFunctionOrMethod())
5220 // This rule only applies to block-scope declarations.
5221 return false;
Douglas Gregorfcee9462010-08-27 22:55:10 +00005222
5223 DeclContext *PrevOuterContext = PrevDecl->getDeclContext();
5224 if (PrevOuterContext->isRecord())
5225 // We found a member function: ignore it.
5226 return false;
5227
5228 // Find the innermost enclosing namespace for the new and
5229 // previous declarations.
Sebastian Redl50c68252010-08-31 00:36:30 +00005230 OuterContext = OuterContext->getEnclosingNamespaceContext();
5231 PrevOuterContext = PrevOuterContext->getEnclosingNamespaceContext();
Mike Stump11289f42009-09-09 15:08:12 +00005232
Douglas Gregorfcee9462010-08-27 22:55:10 +00005233 // The previous declaration is in a different namespace, so it
5234 // isn't the same function.
5235 if (!OuterContext->Equals(PrevOuterContext))
5236 return false;
Douglas Gregor5d68a202009-02-24 19:23:27 +00005237 }
5238
Douglas Gregor5d68a202009-02-24 19:23:27 +00005239 return true;
5240}
5241
John McCall3e11ebe2010-03-15 10:12:16 +00005242static void SetNestedNameSpecifier(DeclaratorDecl *DD, Declarator &D) {
5243 CXXScopeSpec &SS = D.getCXXScopeSpec();
5244 if (!SS.isSet()) return;
Douglas Gregor14454802011-02-25 02:25:35 +00005245 DD->setQualifierInfo(SS.getWithLocInContext(DD->getASTContext()));
John McCall3e11ebe2010-03-15 10:12:16 +00005246}
5247
John McCall31168b02011-06-15 23:02:42 +00005248bool Sema::inferObjCARCLifetime(ValueDecl *decl) {
5249 QualType type = decl->getType();
5250 Qualifiers::ObjCLifetime lifetime = type.getObjCLifetime();
5251 if (lifetime == Qualifiers::OCL_Autoreleasing) {
5252 // Various kinds of declaration aren't allowed to be __autoreleasing.
5253 unsigned kind = -1U;
5254 if (VarDecl *var = dyn_cast<VarDecl>(decl)) {
5255 if (var->hasAttr<BlocksAttr>())
5256 kind = 0; // __block
5257 else if (!var->hasLocalStorage())
5258 kind = 1; // global
5259 } else if (isa<ObjCIvarDecl>(decl)) {
5260 kind = 3; // ivar
5261 } else if (isa<FieldDecl>(decl)) {
5262 kind = 2; // field
5263 }
5264
5265 if (kind != -1U) {
5266 Diag(decl->getLocation(), diag::err_arc_autoreleasing_var)
5267 << kind;
5268 }
5269 } else if (lifetime == Qualifiers::OCL_None) {
5270 // Try to infer lifetime.
5271 if (!type->isObjCLifetimeType())
5272 return false;
5273
5274 lifetime = type->getObjCARCImplicitLifetime();
5275 type = Context.getLifetimeQualifiedType(type, lifetime);
5276 decl->setType(type);
5277 }
5278
5279 if (VarDecl *var = dyn_cast<VarDecl>(decl)) {
5280 // Thread-local variables cannot have lifetime.
5281 if (lifetime && lifetime != Qualifiers::OCL_ExplicitNone &&
Richard Smithfd3834f2013-04-13 02:43:54 +00005282 var->getTLSKind()) {
Argyrios Kyrtzidiscff00d92011-06-24 00:08:59 +00005283 Diag(var->getLocation(), diag::err_arc_thread_ownership)
John McCall31168b02011-06-15 23:02:42 +00005284 << var->getType();
5285 return true;
5286 }
5287 }
5288
5289 return false;
5290}
5291
Rafael Espindolaf1d2f0e2013-01-16 23:11:15 +00005292static void checkAttributesAfterMerging(Sema &S, NamedDecl &ND) {
Nico Rieckf8e8b5f2014-01-21 23:54:36 +00005293 // Ensure that an auto decl is deduced otherwise the checks below might cache
5294 // the wrong linkage.
5295 assert(S.ParsingInitForAutoVars.count(&ND) == 0);
5296
Rafael Espindolaf1d2f0e2013-01-16 23:11:15 +00005297 // 'weak' only applies to declarations with external linkage.
Rafael Espindolab3069002013-01-16 23:49:06 +00005298 if (WeakAttr *Attr = ND.getAttr<WeakAttr>()) {
Rafael Espindola3ae00052013-05-13 00:12:11 +00005299 if (!ND.isExternallyVisible()) {
Rafael Espindolab3069002013-01-16 23:49:06 +00005300 S.Diag(Attr->getLocation(), diag::err_attribute_weak_static);
5301 ND.dropAttr<WeakAttr>();
5302 }
5303 }
5304 if (WeakRefAttr *Attr = ND.getAttr<WeakRefAttr>()) {
Rafael Espindola3ae00052013-05-13 00:12:11 +00005305 if (ND.isExternallyVisible()) {
Rafael Espindolab3069002013-01-16 23:49:06 +00005306 S.Diag(Attr->getLocation(), diag::err_attribute_weakref_not_static);
5307 ND.dropAttr<WeakRefAttr>();
David Majnemer2dc81462015-01-19 09:00:28 +00005308 ND.dropAttr<AliasAttr>();
5309 }
5310 }
5311
5312 if (auto *VD = dyn_cast<VarDecl>(&ND)) {
5313 if (VD->hasInit()) {
5314 if (const auto *Attr = VD->getAttr<AliasAttr>()) {
5315 assert(VD->isThisDeclarationADefinition() &&
5316 !VD->isExternallyVisible() && "Broken AliasAttr handled late!");
5317 S.Diag(Attr->getLocation(), diag::err_alias_is_definition) << VD;
5318 VD->dropAttr<AliasAttr>();
5319 }
Rafael Espindolab3069002013-01-16 23:49:06 +00005320 }
Rafael Espindolaf1d2f0e2013-01-16 23:11:15 +00005321 }
Reid Klecknerb144d362013-05-20 14:02:37 +00005322
Nico Weber38267342015-04-22 03:44:51 +00005323 // 'selectany' only applies to externally visible variable declarations.
Reid Klecknerb144d362013-05-20 14:02:37 +00005324 // It does not apply to functions.
5325 if (SelectAnyAttr *Attr = ND.getAttr<SelectAnyAttr>()) {
5326 if (isa<FunctionDecl>(ND) || !ND.isExternallyVisible()) {
Nico Weber38267342015-04-22 03:44:51 +00005327 S.Diag(Attr->getLocation(),
5328 diag::err_attribute_selectany_non_extern_data);
Reid Klecknerb144d362013-05-20 14:02:37 +00005329 ND.dropAttr<SelectAnyAttr>();
5330 }
5331 }
Nico Rieck8ca0bfc2014-03-31 14:56:58 +00005332
5333 // dll attributes require external linkage.
David Majnemer7656f412014-10-04 06:16:45 +00005334 if (const InheritableAttr *Attr = getDLLAttr(&ND)) {
Nico Rieck8ca0bfc2014-03-31 14:56:58 +00005335 if (!ND.isExternallyVisible()) {
5336 S.Diag(ND.getLocation(), diag::err_attribute_dll_not_extern)
5337 << &ND << Attr;
5338 ND.setInvalidDecl();
5339 }
5340 }
Rafael Espindolaf1d2f0e2013-01-16 23:11:15 +00005341}
5342
Nico Rieck82f0b062014-03-31 14:56:15 +00005343static void checkDLLAttributeRedeclaration(Sema &S, NamedDecl *OldDecl,
5344 NamedDecl *NewDecl,
5345 bool IsSpecialization) {
5346 if (TemplateDecl *OldTD = dyn_cast<TemplateDecl>(OldDecl))
5347 OldDecl = OldTD->getTemplatedDecl();
5348 if (TemplateDecl *NewTD = dyn_cast<TemplateDecl>(NewDecl))
5349 NewDecl = NewTD->getTemplatedDecl();
5350
5351 if (!OldDecl || !NewDecl)
Hans Wennborgdd96db22014-08-27 21:27:40 +00005352 return;
Nico Rieck82f0b062014-03-31 14:56:15 +00005353
5354 const DLLImportAttr *OldImportAttr = OldDecl->getAttr<DLLImportAttr>();
5355 const DLLExportAttr *OldExportAttr = OldDecl->getAttr<DLLExportAttr>();
5356 const DLLImportAttr *NewImportAttr = NewDecl->getAttr<DLLImportAttr>();
5357 const DLLExportAttr *NewExportAttr = NewDecl->getAttr<DLLExportAttr>();
5358
5359 // dllimport and dllexport are inheritable attributes so we have to exclude
5360 // inherited attribute instances.
5361 bool HasNewAttr = (NewImportAttr && !NewImportAttr->isInherited()) ||
5362 (NewExportAttr && !NewExportAttr->isInherited());
5363
5364 // A redeclaration is not allowed to add a dllimport or dllexport attribute,
5365 // the only exception being explicit specializations.
5366 // Implicitly generated declarations are also excluded for now because there
5367 // is no other way to switch these to use dllimport or dllexport.
5368 bool AddsAttr = !(OldImportAttr || OldExportAttr) && HasNewAttr;
Hans Wennborgdd96db22014-08-27 21:27:40 +00005369
Nico Rieck82f0b062014-03-31 14:56:15 +00005370 if (AddsAttr && !IsSpecialization && !OldDecl->isImplicit()) {
Hans Wennborg01064792015-07-22 23:54:51 +00005371 // Allow with a warning for free functions and global variables.
Hans Wennborgdd96db22014-08-27 21:27:40 +00005372 bool JustWarn = false;
Hans Wennborg01064792015-07-22 23:54:51 +00005373 if (!OldDecl->isCXXClassMember()) {
Hans Wennborgdd96db22014-08-27 21:27:40 +00005374 auto *VD = dyn_cast<VarDecl>(OldDecl);
5375 if (VD && !VD->getDescribedVarTemplate())
5376 JustWarn = true;
5377 auto *FD = dyn_cast<FunctionDecl>(OldDecl);
5378 if (FD && FD->getTemplatedKind() == FunctionDecl::TK_NonTemplate)
5379 JustWarn = true;
5380 }
5381
Hans Wennborg01064792015-07-22 23:54:51 +00005382 // We cannot change a declaration that's been used because IR has already
5383 // been emitted. Dllimported functions will still work though (modulo
5384 // address equality) as they can use the thunk.
5385 if (OldDecl->isUsed())
5386 if (!isa<FunctionDecl>(OldDecl) || !NewImportAttr)
5387 JustWarn = false;
5388
Hans Wennborgdd96db22014-08-27 21:27:40 +00005389 unsigned DiagID = JustWarn ? diag::warn_attribute_dll_redeclaration
5390 : diag::err_attribute_dll_redeclaration;
5391 S.Diag(NewDecl->getLocation(), DiagID)
5392 << NewDecl
5393 << (NewImportAttr ? (const Attr *)NewImportAttr : NewExportAttr);
Nico Rieck82f0b062014-03-31 14:56:15 +00005394 S.Diag(OldDecl->getLocation(), diag::note_previous_declaration);
Hans Wennborgdd96db22014-08-27 21:27:40 +00005395 if (!JustWarn) {
5396 NewDecl->setInvalidDecl();
5397 return;
5398 }
Nico Rieck82f0b062014-03-31 14:56:15 +00005399 }
5400
5401 // A redeclaration is not allowed to drop a dllimport attribute, the only
Hans Wennborg7c4851e2014-08-04 20:54:39 +00005402 // exceptions being inline function definitions, local extern declarations,
5403 // and qualified friend declarations.
Nico Rieck82f0b062014-03-31 14:56:15 +00005404 // NB: MSVC converts such a declaration to dllexport.
Hans Wennborg7c4851e2014-08-04 20:54:39 +00005405 bool IsInline = false, IsStaticDataMember = false, IsQualifiedFriend = false;
Nico Rieck078d2f82014-05-29 16:50:20 +00005406 if (const auto *VD = dyn_cast<VarDecl>(NewDecl))
5407 // Ignore static data because out-of-line definitions are diagnosed
5408 // separately.
5409 IsStaticDataMember = VD->isStaticDataMember();
Hans Wennborg7c4851e2014-08-04 20:54:39 +00005410 else if (const auto *FD = dyn_cast<FunctionDecl>(NewDecl)) {
Nico Rieck078d2f82014-05-29 16:50:20 +00005411 IsInline = FD->isInlined();
Hans Wennborg7c4851e2014-08-04 20:54:39 +00005412 IsQualifiedFriend = FD->getQualifier() &&
5413 FD->getFriendObjectKind() == Decl::FOK_Declared;
5414 }
Hans Wennborgf436b282014-05-22 15:46:15 +00005415
Hans Wennborgf51dc3b2014-07-31 19:29:39 +00005416 if (OldImportAttr && !HasNewAttr && !IsInline && !IsStaticDataMember &&
Hans Wennborg7c4851e2014-08-04 20:54:39 +00005417 !NewDecl->isLocalExternDecl() && !IsQualifiedFriend) {
Nico Rieck82f0b062014-03-31 14:56:15 +00005418 S.Diag(NewDecl->getLocation(),
5419 diag::warn_redeclaration_without_attribute_prev_attribute_ignored)
5420 << NewDecl << OldImportAttr;
5421 S.Diag(OldDecl->getLocation(), diag::note_previous_declaration);
5422 S.Diag(OldImportAttr->getLocation(), diag::note_previous_attribute);
5423 OldDecl->dropAttr<DLLImportAttr>();
5424 NewDecl->dropAttr<DLLImportAttr>();
Hans Wennborg606bd6d2014-11-03 14:24:45 +00005425 } else if (IsInline && OldImportAttr &&
5426 !S.Context.getTargetInfo().getCXXABI().isMicrosoft()) {
5427 // In MinGW, seeing a function declared inline drops the dllimport attribute.
5428 OldDecl->dropAttr<DLLImportAttr>();
5429 NewDecl->dropAttr<DLLImportAttr>();
5430 S.Diag(NewDecl->getLocation(),
5431 diag::warn_dllimport_dropped_from_inline_function)
5432 << NewDecl << OldImportAttr;
Nico Rieck82f0b062014-03-31 14:56:15 +00005433 }
5434}
5435
John McCallc87d9722013-04-02 02:48:58 +00005436/// Given that we are within the definition of the given function,
5437/// will that definition behave like C99's 'inline', where the
5438/// definition is discarded except for optimization purposes?
5439static bool isFunctionDefinitionDiscarded(Sema &S, FunctionDecl *FD) {
5440 // Try to avoid calling GetGVALinkageForFunction.
5441
5442 // All cases of this require the 'inline' keyword.
5443 if (!FD->isInlined()) return false;
5444
5445 // This is only possible in C++ with the gnu_inline attribute.
5446 if (S.getLangOpts().CPlusPlus && !FD->hasAttr<GNUInlineAttr>())
5447 return false;
5448
5449 // Okay, go ahead and call the relatively-more-expensive function.
5450
5451#ifndef NDEBUG
5452 // AST quite reasonably asserts that it's working on a function
5453 // definition. We don't really have a way to tell it that we're
5454 // currently defining the function, so just lie to it in +Asserts
5455 // builds. This is an awful hack.
5456 FD->setLazyBody(1);
5457#endif
5458
David Majnemer27d69db2014-04-28 22:17:59 +00005459 bool isC99Inline =
5460 S.Context.GetGVALinkageForFunction(FD) == GVA_AvailableExternally;
John McCallc87d9722013-04-02 02:48:58 +00005461
5462#ifndef NDEBUG
5463 FD->setLazyBody(0);
5464#endif
5465
5466 return isC99Inline;
5467}
5468
Richard Smithac974a32013-06-30 09:48:50 +00005469/// Determine whether a variable is extern "C" prior to attaching
5470/// an initializer. We can't just call isExternC() here, because that
5471/// will also compute and cache whether the declaration is externally
5472/// visible, which might change when we attach the initializer.
5473///
5474/// This can only be used if the declaration is known to not be a
5475/// redeclaration of an internal linkage declaration.
5476///
5477/// For instance:
5478///
5479/// auto x = []{};
5480///
5481/// Attaching the initializer here makes this declaration not externally
5482/// visible, because its type has internal linkage.
5483///
5484/// FIXME: This is a hack.
5485template<typename T>
5486static bool isIncompleteDeclExternC(Sema &S, const T *D) {
5487 if (S.getLangOpts().CPlusPlus) {
5488 // In C++, the overloadable attribute negates the effects of extern "C".
5489 if (!D->isInExternCContext() || D->template hasAttr<OverloadableAttr>())
5490 return false;
5491 }
5492 return D->isExternC();
5493}
5494
Rafael Espindola0e0d0092013-03-14 03:07:35 +00005495static bool shouldConsiderLinkage(const VarDecl *VD) {
5496 const DeclContext *DC = VD->getDeclContext()->getRedeclContext();
5497 if (DC->isFunctionOrMethod())
Rafael Espindola6ae7e502013-04-03 19:27:57 +00005498 return VD->hasExternalStorage();
Rafael Espindola0e0d0092013-03-14 03:07:35 +00005499 if (DC->isFileContext())
5500 return true;
5501 if (DC->isRecord())
5502 return false;
5503 llvm_unreachable("Unexpected context");
5504}
5505
5506static bool shouldConsiderLinkage(const FunctionDecl *FD) {
5507 const DeclContext *DC = FD->getDeclContext()->getRedeclContext();
5508 if (DC->isFileContext() || DC->isFunctionOrMethod())
5509 return true;
5510 if (DC->isRecord())
5511 return false;
5512 llvm_unreachable("Unexpected context");
5513}
5514
Nico Riecke84f8db2014-03-23 21:24:01 +00005515static bool hasParsedAttr(Scope *S, const AttributeList *AttrList,
5516 AttributeList::Kind Kind) {
5517 for (const AttributeList *L = AttrList; L; L = L->getNext())
5518 if (L->getKind() == Kind)
5519 return true;
5520 return false;
5521}
5522
5523static bool hasParsedAttr(Scope *S, const Declarator &PD,
5524 AttributeList::Kind Kind) {
5525 // Check decl attributes on the DeclSpec.
5526 if (hasParsedAttr(S, PD.getDeclSpec().getAttributes().getList(), Kind))
5527 return true;
5528
5529 // Walk the declarator structure, checking decl attributes that were in a type
5530 // position to the decl itself.
5531 for (unsigned I = 0, E = PD.getNumTypeObjects(); I != E; ++I) {
5532 if (hasParsedAttr(S, PD.getTypeObject(I).getAttrs(), Kind))
5533 return true;
5534 }
5535
5536 // Finally, check attributes on the decl itself.
5537 return hasParsedAttr(S, PD.getAttributes(), Kind);
5538}
5539
Richard Smith541b38b2013-09-20 01:15:31 +00005540/// Adjust the \c DeclContext for a function or variable that might be a
5541/// function-local external declaration.
5542bool Sema::adjustContextForLocalExternDecl(DeclContext *&DC) {
5543 if (!DC->isFunctionOrMethod())
5544 return false;
5545
5546 // If this is a local extern function or variable declared within a function
5547 // template, don't add it into the enclosing namespace scope until it is
5548 // instantiated; it might have a dependent type right now.
5549 if (DC->isDependentContext())
5550 return true;
5551
5552 // C++11 [basic.link]p7:
5553 // When a block scope declaration of an entity with linkage is not found to
5554 // refer to some other declaration, then that entity is a member of the
5555 // innermost enclosing namespace.
5556 //
5557 // Per C++11 [namespace.def]p6, the innermost enclosing namespace is a
5558 // semantically-enclosing namespace, not a lexically-enclosing one.
5559 while (!DC->isFileContext() && !isa<LinkageSpecDecl>(DC))
5560 DC = DC->getParent();
5561 return true;
5562}
5563
Aaron Ballman7572e582015-07-16 17:06:53 +00005564/// \brief Returns true if given declaration has external C language linkage.
5565static bool isDeclExternC(const Decl *D) {
5566 if (const auto *FD = dyn_cast<FunctionDecl>(D))
5567 return FD->isExternC();
5568 if (const auto *VD = dyn_cast<VarDecl>(D))
5569 return VD->isExternC();
Aaron Ballman9ec96a22015-06-25 15:37:16 +00005570
5571 llvm_unreachable("Unknown type of decl!");
5572}
5573
Larisse Voufo39a1e502013-08-06 01:03:05 +00005574NamedDecl *
Chris Lattner88fdea82010-10-10 18:16:20 +00005575Sema::ActOnVariableDeclarator(Scope *S, Declarator &D, DeclContext *DC,
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00005576 TypeSourceInfo *TInfo, LookupResult &Previous,
Larisse Voufo39a1e502013-08-06 01:03:05 +00005577 MultiTemplateParamsArg TemplateParamLists,
5578 bool &AddToScope) {
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00005579 QualType R = TInfo->getType();
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00005580 DeclarationName Name = GetNameForDeclarator(D).getName();
Zhongxing Xu9b7714d2009-01-16 02:36:34 +00005581
Douglas Gregorc4df4072010-04-19 22:54:31 +00005582 DeclSpec::SCS SCSpec = D.getDeclSpec().getStorageClassSpec();
Craig Topperc79e5e32014-10-31 06:57:13 +00005583 StorageClass SC = StorageClassSpecToVarDeclStorageClass(D.getDeclSpec());
Joey Goulydd7f4562013-01-23 11:56:20 +00005584
Nico Riecke84f8db2014-03-23 21:24:01 +00005585 // dllimport globals without explicit storage class are treated as extern. We
5586 // have to change the storage class this early to get the right DeclContext.
5587 if (SC == SC_None && !DC->isRecord() &&
Nico Rieck755a36f2014-05-25 10:34:16 +00005588 hasParsedAttr(S, D, AttributeList::AT_DLLImport) &&
5589 !hasParsedAttr(S, D, AttributeList::AT_DLLExport))
Nico Riecke84f8db2014-03-23 21:24:01 +00005590 SC = SC_Extern;
5591
Richard Smith541b38b2013-09-20 01:15:31 +00005592 DeclContext *OriginalDC = DC;
5593 bool IsLocalExternDecl = SC == SC_Extern &&
5594 adjustContextForLocalExternDecl(DC);
5595
Pekka Jaaskelainen8690a682014-02-20 13:52:08 +00005596 if (getLangOpts().OpenCL) {
5597 // OpenCL v1.0 s6.8.a.3: Pointers to functions are not allowed.
5598 QualType NR = R;
5599 while (NR->isPointerType()) {
5600 if (NR->isFunctionPointerType()) {
5601 Diag(D.getIdentifierLoc(), diag::err_opencl_function_pointer_variable);
5602 D.setInvalidType();
5603 break;
5604 }
5605 NR = NR->getPointeeType();
5606 }
5607
5608 if (!getOpenCLOptions().cl_khr_fp16) {
5609 // OpenCL v1.2 s6.1.1.1: reject declaring variables of the half and
5610 // half array type (unless the cl_khr_fp16 extension is enabled).
5611 if (Context.getBaseElementType(R)->isHalfType()) {
5612 Diag(D.getIdentifierLoc(), diag::err_opencl_half_declaration) << R;
5613 D.setInvalidType();
5614 }
Joey Goulydd7f4562013-01-23 11:56:20 +00005615 }
5616 }
5617
Douglas Gregorc4df4072010-04-19 22:54:31 +00005618 if (SCSpec == DeclSpec::SCS_mutable) {
Zhongxing Xu9b7714d2009-01-16 02:36:34 +00005619 // mutable can only appear on non-static class members, so it's always
5620 // an error here
5621 Diag(D.getIdentifierLoc(), diag::err_mutable_nonmember);
Chris Lattnerf6d1c9c2009-04-25 08:06:05 +00005622 D.setInvalidType();
John McCall8e7d6562010-08-26 03:08:43 +00005623 SC = SC_None;
Zhongxing Xu9b7714d2009-01-16 02:36:34 +00005624 }
John McCallc87d9722013-04-02 02:48:58 +00005625
Richard Smithf2c9afc2013-06-17 01:34:01 +00005626 if (getLangOpts().CPlusPlus11 && SCSpec == DeclSpec::SCS_register &&
5627 !D.getAsmLabel() && !getSourceManager().isInSystemMacro(
5628 D.getDeclSpec().getStorageClassSpecLoc())) {
5629 // In C++11, the 'register' storage class specifier is deprecated.
5630 // Suppress the warning in system macros, it's used in macros in some
5631 // popular C system headers, such as in glibc's htonl() macro.
5632 Diag(D.getDeclSpec().getStorageClassSpecLoc(),
5633 diag::warn_deprecated_register)
5634 << FixItHint::CreateRemoval(D.getDeclSpec().getStorageClassSpecLoc());
5635 }
5636
Zhongxing Xu9b7714d2009-01-16 02:36:34 +00005637 IdentifierInfo *II = Name.getAsIdentifierInfo();
5638 if (!II) {
5639 Diag(D.getIdentifierLoc(), diag::err_bad_variable_name)
Douglas Gregorbb64afc2011-10-09 18:55:59 +00005640 << Name;
Craig Topperc3ec1492014-05-26 06:22:03 +00005641 return nullptr;
Zhongxing Xu9b7714d2009-01-16 02:36:34 +00005642 }
5643
Richard Smithb1402ae2013-03-18 22:52:47 +00005644 DiagnoseFunctionSpecifiers(D.getDeclSpec());
Douglas Gregor0c880302009-03-11 23:00:04 +00005645
Craig Topperc3ec1492014-05-26 06:22:03 +00005646 if (!DC->isRecord() && S->getFnParent() == nullptr) {
Douglas Gregor212cab32009-03-11 20:22:50 +00005647 // C99 6.9p2: The storage-class specifiers auto and register shall not
5648 // appear in the declaration specifiers in an external declaration.
Renato Golin230c5eb2014-05-19 18:15:42 +00005649 // Global Register+Asm is a GNU extension we support.
5650 if (SC == SC_Auto || (SC == SC_Register && !D.getAsmLabel())) {
5651 Diag(D.getIdentifierLoc(), diag::err_typecheck_sclass_fscope);
Chris Lattnerf6d1c9c2009-04-25 08:06:05 +00005652 D.setInvalidType();
Zhongxing Xu9b7714d2009-01-16 02:36:34 +00005653 }
Zhongxing Xu9b7714d2009-01-16 02:36:34 +00005654 }
Richard Smithf2c9afc2013-06-17 01:34:01 +00005655
David Blaikiebbafb8a2012-03-11 07:00:24 +00005656 if (getLangOpts().OpenCL) {
Peter Collingbourne2dbb7082011-09-19 21:14:35 +00005657 // Set up the special work-group-local storage class for variables in the
5658 // OpenCL __local address space.
Rafael Espindola2be6b722012-12-21 01:21:33 +00005659 if (R.getAddressSpace() == LangAS::opencl_local) {
Peter Collingbourne2dbb7082011-09-19 21:14:35 +00005660 SC = SC_OpenCLWorkGroupLocal;
Rafael Espindola2be6b722012-12-21 01:21:33 +00005661 }
Guy Benyei1b4fb3e2013-01-20 12:31:11 +00005662
Guy Benyei61054192013-02-07 10:55:47 +00005663 // OpenCL v1.2 s6.9.b p4:
5664 // The sampler type cannot be used with the __local and __global address
5665 // space qualifiers.
5666 if (R->isSamplerT() && (R.getAddressSpace() == LangAS::opencl_local ||
5667 R.getAddressSpace() == LangAS::opencl_global)) {
5668 Diag(D.getIdentifierLoc(), diag::err_wrong_sampler_addressspace);
5669 }
5670
Guy Benyei1b4fb3e2013-01-20 12:31:11 +00005671 // OpenCL 1.2 spec, p6.9 r:
5672 // The event type cannot be used to declare a program scope variable.
5673 // The event type cannot be used with the __local, __constant and __global
5674 // address space qualifiers.
5675 if (R->isEventT()) {
Craig Topperc3ec1492014-05-26 06:22:03 +00005676 if (S->getParent() == nullptr) {
Guy Benyei1b4fb3e2013-01-20 12:31:11 +00005677 Diag(D.getLocStart(), diag::err_event_t_global_var);
5678 D.setInvalidType();
5679 }
5680
5681 if (R.getAddressSpace()) {
5682 Diag(D.getLocStart(), diag::err_event_t_addr_space_qual);
5683 D.setInvalidType();
5684 }
5685 }
Peter Collingbourne2dbb7082011-09-19 21:14:35 +00005686 }
5687
Larisse Voufo39a1e502013-08-06 01:03:05 +00005688 bool IsExplicitSpecialization = false;
5689 bool IsVariableTemplateSpecialization = false;
5690 bool IsPartialSpecialization = false;
Larisse Voufod8dd97c2013-08-14 03:09:19 +00005691 bool IsVariableTemplate = false;
Craig Topperc3ec1492014-05-26 06:22:03 +00005692 VarDecl *NewVD = nullptr;
5693 VarTemplateDecl *NewTemplate = nullptr;
5694 TemplateParameterList *TemplateParams = nullptr;
David Blaikiebbafb8a2012-03-11 07:00:24 +00005695 if (!getLangOpts().CPlusPlus) {
Daniel Dunbar62ee6412012-03-09 18:35:03 +00005696 NewVD = VarDecl::Create(Context, DC, D.getLocStart(),
Abramo Bagnaradff19302011-03-08 08:55:46 +00005697 D.getIdentifierLoc(), II,
Rafael Espindola6ae7e502013-04-03 19:27:57 +00005698 R, TInfo, SC);
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00005699
5700 if (D.isInvalidType())
5701 NewVD->setInvalidDecl();
5702 } else {
Larisse Voufo72caf2b2013-08-22 00:59:14 +00005703 bool Invalid = false;
5704
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00005705 if (DC->isRecord() && !CurContext->isRecord()) {
5706 // This is an out-of-line definition of a static data member.
Rafael Espindola45f96f82013-06-19 13:41:54 +00005707 switch (SC) {
5708 case SC_None:
5709 break;
5710 case SC_Static:
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00005711 Diag(D.getDeclSpec().getStorageClassSpecLoc(),
5712 diag::err_static_out_of_line)
5713 << FixItHint::CreateRemoval(D.getDeclSpec().getStorageClassSpecLoc());
Rafael Espindola45f96f82013-06-19 13:41:54 +00005714 break;
5715 case SC_Auto:
5716 case SC_Register:
5717 case SC_Extern:
5718 // [dcl.stc] p2: The auto or register specifiers shall be applied only
5719 // to names of variables declared in a block or to function parameters.
5720 // [dcl.stc] p6: The extern specifier cannot be used in the declaration
5721 // of class members
5722
5723 Diag(D.getDeclSpec().getStorageClassSpecLoc(),
5724 diag::err_storage_class_for_static_member)
5725 << FixItHint::CreateRemoval(D.getDeclSpec().getStorageClassSpecLoc());
5726 break;
5727 case SC_PrivateExtern:
5728 llvm_unreachable("C storage class in c++!");
5729 case SC_OpenCLWorkGroupLocal:
5730 llvm_unreachable("OpenCL storage class in c++!");
Rafael Espindola8ac2f592013-04-04 21:21:25 +00005731 }
Larisse Voufo21de36b2013-08-06 03:43:07 +00005732 }
5733
Richard Smith42973752012-02-16 20:41:22 +00005734 if (SC == SC_Static && CurContext->isRecord()) {
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00005735 if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(DC)) {
5736 if (RD->isLocalClass())
5737 Diag(D.getIdentifierLoc(),
5738 diag::err_static_data_member_not_allowed_in_local_class)
5739 << Name << RD->getDeclName();
Mike Stump11289f42009-09-09 15:08:12 +00005740
Richard Smith42973752012-02-16 20:41:22 +00005741 // C++98 [class.union]p1: If a union contains a static data member,
5742 // the program is ill-formed. C++11 drops this restriction.
5743 if (RD->isUnion())
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00005744 Diag(D.getIdentifierLoc(),
Richard Smith2bf7fdb2013-01-02 11:42:31 +00005745 getLangOpts().CPlusPlus11
Richard Smith42973752012-02-16 20:41:22 +00005746 ? diag::warn_cxx98_compat_static_data_member_in_union
5747 : diag::ext_static_data_member_in_union) << Name;
5748 // We conservatively disallow static data members in anonymous structs.
5749 else if (!RD->getDeclName())
5750 Diag(D.getIdentifierLoc(),
5751 diag::err_static_data_member_not_allowed_in_anon_struct)
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00005752 << Name << RD->isUnion();
5753 }
5754 }
5755
5756 // Match up the template parameter lists with the scope specifier, then
5757 // determine whether we have a template or a template specialization.
Richard Smithbeef3452014-01-16 23:39:20 +00005758 TemplateParams = MatchTemplateParametersToScopeSpecifier(
5759 D.getDeclSpec().getLocStart(), D.getIdentifierLoc(),
Richard Smith4b55a9c2014-04-17 03:29:33 +00005760 D.getCXXScopeSpec(),
5761 D.getName().getKind() == UnqualifiedId::IK_TemplateId
5762 ? D.getName().TemplateId
Craig Topperc3ec1492014-05-26 06:22:03 +00005763 : nullptr,
Richard Smith4b55a9c2014-04-17 03:29:33 +00005764 TemplateParamLists,
Richard Smithbeef3452014-01-16 23:39:20 +00005765 /*never a friend*/ false, IsExplicitSpecialization, Invalid);
Larisse Voufo39a1e502013-08-06 01:03:05 +00005766
Richard Smithbeef3452014-01-16 23:39:20 +00005767 if (TemplateParams) {
5768 if (!TemplateParams->size() &&
5769 D.getName().getKind() != UnqualifiedId::IK_TemplateId) {
5770 // There is an extraneous 'template<>' for this variable. Complain
5771 // about it, but allow the declaration of the variable.
5772 Diag(TemplateParams->getTemplateLoc(),
5773 diag::err_template_variable_noparams)
5774 << II
5775 << SourceRange(TemplateParams->getTemplateLoc(),
5776 TemplateParams->getRAngleLoc());
Craig Topperc3ec1492014-05-26 06:22:03 +00005777 TemplateParams = nullptr;
Richard Smithbeef3452014-01-16 23:39:20 +00005778 } else {
Richard Smithbeef3452014-01-16 23:39:20 +00005779 if (D.getName().getKind() == UnqualifiedId::IK_TemplateId) {
5780 // This is an explicit specialization or a partial specialization.
5781 // FIXME: Check that we can declare a specialization here.
5782 IsVariableTemplateSpecialization = true;
5783 IsPartialSpecialization = TemplateParams->size() > 0;
5784 } else { // if (TemplateParams->size() > 0)
5785 // This is a template declaration.
5786 IsVariableTemplate = true;
5787
5788 // Check that we can declare a template here.
5789 if (CheckTemplateDeclScope(S, TemplateParams))
Craig Topperc3ec1492014-05-26 06:22:03 +00005790 return nullptr;
Richard Smith0d963d62014-04-17 02:56:49 +00005791
5792 // Only C++1y supports variable templates (N3651).
5793 Diag(D.getIdentifierLoc(),
Aaron Ballmandd69ef32014-08-19 15:55:55 +00005794 getLangOpts().CPlusPlus14
Richard Smith0d963d62014-04-17 02:56:49 +00005795 ? diag::warn_cxx11_compat_variable_template
5796 : diag::ext_variable_template);
Richard Smithbeef3452014-01-16 23:39:20 +00005797 }
5798 }
Richard Smith4b55a9c2014-04-17 03:29:33 +00005799 } else {
Nico Weber9cc795c2015-01-30 01:48:49 +00005800 assert(
5801 (Invalid || D.getName().getKind() != UnqualifiedId::IK_TemplateId) &&
5802 "should have a 'template<>' for this decl");
Douglas Gregorb09f3d82009-07-22 17:18:37 +00005803 }
Mike Stump11289f42009-09-09 15:08:12 +00005804
Larisse Voufo39a1e502013-08-06 01:03:05 +00005805 if (IsVariableTemplateSpecialization) {
Larisse Voufo39a1e502013-08-06 01:03:05 +00005806 SourceLocation TemplateKWLoc =
5807 TemplateParamLists.size() > 0
5808 ? TemplateParamLists[0]->getTemplateLoc()
5809 : SourceLocation();
5810 DeclResult Res = ActOnVarTemplateSpecialization(
Richard Smithbeef3452014-01-16 23:39:20 +00005811 S, D, TInfo, TemplateKWLoc, TemplateParams, SC,
Larisse Voufo39a1e502013-08-06 01:03:05 +00005812 IsPartialSpecialization);
5813 if (Res.isInvalid())
Craig Topperc3ec1492014-05-26 06:22:03 +00005814 return nullptr;
Larisse Voufo39a1e502013-08-06 01:03:05 +00005815 NewVD = cast<VarDecl>(Res.get());
5816 AddToScope = false;
5817 } else
5818 NewVD = VarDecl::Create(Context, DC, D.getLocStart(),
5819 D.getIdentifierLoc(), II, R, TInfo, SC);
Eli Friedmand5c0eed2009-04-19 20:27:55 +00005820
Larisse Voufo72caf2b2013-08-22 00:59:14 +00005821 // If this is supposed to be a variable template, create it as such.
5822 if (IsVariableTemplate) {
5823 NewTemplate =
5824 VarTemplateDecl::Create(Context, DC, D.getIdentifierLoc(), Name,
Richard Smithbeef3452014-01-16 23:39:20 +00005825 TemplateParams, NewVD);
Larisse Voufo72caf2b2013-08-22 00:59:14 +00005826 NewVD->setDescribedVarTemplate(NewTemplate);
5827 }
5828
Richard Smithb2bc2e62011-02-21 20:05:19 +00005829 // If this decl has an auto type in need of deduction, make a note of the
5830 // Decl so we can diagnose uses of it in its own initializer.
Richard Smith74aeef52013-04-26 16:15:35 +00005831 if (D.getDeclSpec().containsPlaceholderType() && R->getContainedAutoType())
Richard Smithb2bc2e62011-02-21 20:05:19 +00005832 ParsingInitForAutoVars.insert(NewVD);
Richard Smith30482bc2011-02-20 03:19:35 +00005833
Larisse Voufo72caf2b2013-08-22 00:59:14 +00005834 if (D.isInvalidType() || Invalid) {
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00005835 NewVD->setInvalidDecl();
Larisse Voufo72caf2b2013-08-22 00:59:14 +00005836 if (NewTemplate)
5837 NewTemplate->setInvalidDecl();
5838 }
Mike Stump11289f42009-09-09 15:08:12 +00005839
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00005840 SetNestedNameSpecifier(NewVD, D);
John McCall3e11ebe2010-03-15 10:12:16 +00005841
Richard Smith72db5632014-01-25 21:32:06 +00005842 // If we have any template parameter lists that don't directly belong to
5843 // the variable (matching the scope specifier), store them.
5844 unsigned VDTemplateParamLists = TemplateParams ? 1 : 0;
5845 if (TemplateParamLists.size() > VDTemplateParamLists)
Larisse Voufo39a1e502013-08-06 01:03:05 +00005846 NewVD->setTemplateParameterListsInfo(
Richard Smith72db5632014-01-25 21:32:06 +00005847 Context, TemplateParamLists.size() - VDTemplateParamLists,
5848 TemplateParamLists.data());
Richard Smitha77a0a62011-08-15 21:04:07 +00005849
Richard Smith6331c402012-02-13 22:16:19 +00005850 if (D.getDeclSpec().isConstexprSpecified())
Richard Smithf0215fe2011-12-25 21:17:58 +00005851 NewVD->setConstexpr(true);
Abramo Bagnarada41d0c2010-06-12 08:15:14 +00005852 }
5853
Douglas Gregor41866812011-09-12 18:37:38 +00005854 // Set the lexical context. If the declarator has a C++ scope specifier, the
5855 // lexical context will be different from the semantic context.
5856 NewVD->setLexicalDeclContext(CurContext);
Larisse Voufo72caf2b2013-08-22 00:59:14 +00005857 if (NewTemplate)
5858 NewTemplate->setLexicalDeclContext(CurContext);
Douglas Gregor41866812011-09-12 18:37:38 +00005859
Richard Smith541b38b2013-09-20 01:15:31 +00005860 if (IsLocalExternDecl)
5861 NewVD->setLocalExternDecl();
5862
Artem Belevichfa62ad42015-04-27 19:37:53 +00005863 bool EmitTLSUnsupportedError = false;
Richard Smithb4a9e862013-04-12 22:46:28 +00005864 if (DeclSpec::TSCS TSCS = D.getDeclSpec().getThreadStorageClassSpec()) {
Bob Wilsond8f41652014-11-21 06:52:52 +00005865 // C++11 [dcl.stc]p4:
5866 // When thread_local is applied to a variable of block scope the
5867 // storage-class-specifier static is implied if it does not appear
5868 // explicitly.
5869 // Core issue: 'static' is not implied if the variable is declared
5870 // 'extern'.
5871 if (NewVD->hasLocalStorage() &&
5872 (SCSpec != DeclSpec::SCS_unspecified ||
5873 TSCS != DeclSpec::TSCS_thread_local ||
5874 !DC->isFunctionOrMethod()))
5875 Diag(D.getDeclSpec().getThreadStorageClassSpecLoc(),
5876 diag::err_thread_non_global)
5877 << DeclSpec::getSpecifierName(TSCS);
Artem Belevichfa62ad42015-04-27 19:37:53 +00005878 else if (!Context.getTargetInfo().isTLSSupported()) {
Artem Belevicha0473a52015-04-28 20:31:49 +00005879 if (getLangOpts().CUDA) {
Artem Belevichfa62ad42015-04-27 19:37:53 +00005880 // Postpone error emission until we've collected attributes required to
5881 // figure out whether it's a host or device variable and whether the
5882 // error should be ignored.
5883 EmitTLSUnsupportedError = true;
Artem Belevicha0473a52015-04-28 20:31:49 +00005884 // We still need to mark the variable as TLS so it shows up in AST with
5885 // proper storage class for other tools to use even if we're not going
5886 // to emit any code for it.
5887 NewVD->setTSCSpec(TSCS);
5888 } else
Artem Belevichfa62ad42015-04-27 19:37:53 +00005889 Diag(D.getDeclSpec().getThreadStorageClassSpecLoc(),
5890 diag::err_thread_unsupported);
5891 } else
Enea Zaffanellaacb8ecd2013-05-04 08:27:07 +00005892 NewVD->setTSCSpec(TSCS);
Eli Friedmand5c0eed2009-04-19 20:27:55 +00005893 }
Douglas Gregor6e6ad602009-01-20 01:17:11 +00005894
John McCallc87d9722013-04-02 02:48:58 +00005895 // C99 6.7.4p3
5896 // An inline definition of a function with external linkage shall
5897 // not contain a definition of a modifiable object with static or
5898 // thread storage duration...
5899 // We only apply this when the function is required to be defined
5900 // elsewhere, i.e. when the function is not 'extern inline'. Note
5901 // that a local variable with thread storage duration still has to
5902 // be marked 'static'. Also note that it's possible to get these
5903 // semantics in C++ using __attribute__((gnu_inline)).
Craig Topperc3ec1492014-05-26 06:22:03 +00005904 if (SC == SC_Static && S->getFnParent() != nullptr &&
John McCallc87d9722013-04-02 02:48:58 +00005905 !NewVD->getType().isConstQualified()) {
5906 FunctionDecl *CurFD = getCurFunctionDecl();
5907 if (CurFD && isFunctionDefinitionDiscarded(*this, CurFD)) {
5908 Diag(D.getDeclSpec().getStorageClassSpecLoc(),
5909 diag::warn_static_local_in_extern_inline);
5910 MaybeSuggestAddingStaticToDecl(CurFD);
5911 }
5912 }
5913
Douglas Gregor3c7cd6a2011-09-09 20:53:38 +00005914 if (D.getDeclSpec().isModulePrivateSpecified()) {
Larisse Voufo39a1e502013-08-06 01:03:05 +00005915 if (IsVariableTemplateSpecialization)
5916 Diag(NewVD->getLocation(), diag::err_module_private_specialization)
5917 << (IsPartialSpecialization ? 1 : 0)
5918 << FixItHint::CreateRemoval(
5919 D.getDeclSpec().getModulePrivateSpecLoc());
5920 else if (IsExplicitSpecialization)
Douglas Gregor3c7cd6a2011-09-09 20:53:38 +00005921 Diag(NewVD->getLocation(), diag::err_module_private_specialization)
5922 << 2
5923 << FixItHint::CreateRemoval(D.getDeclSpec().getModulePrivateSpecLoc());
Douglas Gregor41866812011-09-12 18:37:38 +00005924 else if (NewVD->hasLocalStorage())
5925 Diag(NewVD->getLocation(), diag::err_module_private_local)
5926 << 0 << NewVD->getDeclName()
5927 << SourceRange(D.getDeclSpec().getModulePrivateSpecLoc())
5928 << FixItHint::CreateRemoval(D.getDeclSpec().getModulePrivateSpecLoc());
Larisse Voufo72caf2b2013-08-22 00:59:14 +00005929 else {
Douglas Gregor3c7cd6a2011-09-09 20:53:38 +00005930 NewVD->setModulePrivate();
Larisse Voufo72caf2b2013-08-22 00:59:14 +00005931 if (NewTemplate)
5932 NewTemplate->setModulePrivate();
5933 }
Douglas Gregor3c7cd6a2011-09-09 20:53:38 +00005934 }
Douglas Gregor26701a42011-09-09 02:06:17 +00005935
Zhongxing Xu9b7714d2009-01-16 02:36:34 +00005936 // Handle attributes prior to checking for duplicates in MergeVarDecl
Douglas Gregor758a8692009-06-17 21:51:59 +00005937 ProcessDeclAttributes(S, NewVD, D);
Zhongxing Xu9b7714d2009-01-16 02:36:34 +00005938
Peter Collingbournec6b08572012-08-28 20:37:50 +00005939 if (getLangOpts().CUDA) {
Artem Belevichfa62ad42015-04-27 19:37:53 +00005940 if (EmitTLSUnsupportedError && DeclAttrsMatchCUDAMode(getLangOpts(), NewVD))
5941 Diag(D.getDeclSpec().getThreadStorageClassSpecLoc(),
5942 diag::err_thread_unsupported);
Peter Collingbournec6b08572012-08-28 20:37:50 +00005943 // CUDA B.2.5: "__shared__ and __constant__ variables have implied static
5944 // storage [duration]."
Craig Topperc3ec1492014-05-26 06:22:03 +00005945 if (SC == SC_None && S->getFnParent() != nullptr &&
Rafael Espindola2be6b722012-12-21 01:21:33 +00005946 (NewVD->hasAttr<CUDASharedAttr>() ||
5947 NewVD->hasAttr<CUDAConstantAttr>())) {
Peter Collingbournec6b08572012-08-28 20:37:50 +00005948 NewVD->setStorageClass(SC_Static);
Rafael Espindola2be6b722012-12-21 01:21:33 +00005949 }
Peter Collingbournec6b08572012-08-28 20:37:50 +00005950 }
5951
Nico Riecke84f8db2014-03-23 21:24:01 +00005952 // Ensure that dllimport globals without explicit storage class are treated as
5953 // extern. The storage class is set above using parsed attributes. Now we can
5954 // check the VarDecl itself.
5955 assert(!NewVD->hasAttr<DLLImportAttr>() ||
5956 NewVD->getAttr<DLLImportAttr>()->isInherited() ||
5957 NewVD->isStaticDataMember() || NewVD->getStorageClass() != SC_None);
5958
John McCall31168b02011-06-15 23:02:42 +00005959 // In auto-retain/release, infer strong retension for variables of
5960 // retainable type.
David Blaikiebbafb8a2012-03-11 07:00:24 +00005961 if (getLangOpts().ObjCAutoRefCount && inferObjCARCLifetime(NewVD))
John McCall31168b02011-06-15 23:02:42 +00005962 NewVD->setInvalidDecl();
5963
Zhongxing Xu9b7714d2009-01-16 02:36:34 +00005964 // Handle GNU asm-label extension (encoded as an attribute).
Chris Lattner88fdea82010-10-10 18:16:20 +00005965 if (Expr *E = (Expr*)D.getAsmLabel()) {
Zhongxing Xu9b7714d2009-01-16 02:36:34 +00005966 // The parser guarantees this is a string.
Mike Stump11289f42009-09-09 15:08:12 +00005967 StringLiteral *SE = cast<StringLiteral>(E);
Chris Lattner0e62c1c2011-07-23 10:55:15 +00005968 StringRef Label = SE->getString();
Craig Topperc3ec1492014-05-26 06:22:03 +00005969 if (S->getFnParent() != nullptr) {
Abramo Bagnara13392232011-01-11 15:16:52 +00005970 switch (SC) {
5971 case SC_None:
5972 case SC_Auto:
5973 Diag(E->getExprLoc(), diag::warn_asm_label_on_auto_decl) << Label;
5974 break;
5975 case SC_Register:
Renato Golin230c5eb2014-05-19 18:15:42 +00005976 // Local Named register
Douglas Gregore8bbc122011-09-02 00:18:52 +00005977 if (!Context.getTargetInfo().isValidGCCRegisterName(Label))
Abramo Bagnara13392232011-01-11 15:16:52 +00005978 Diag(E->getExprLoc(), diag::err_asm_unknown_register_name) << Label;
5979 break;
5980 case SC_Static:
5981 case SC_Extern:
5982 case SC_PrivateExtern:
Peter Collingbourne2dbb7082011-09-19 21:14:35 +00005983 case SC_OpenCLWorkGroupLocal:
Abramo Bagnara13392232011-01-11 15:16:52 +00005984 break;
5985 }
Renato Golin230c5eb2014-05-19 18:15:42 +00005986 } else if (SC == SC_Register) {
5987 // Global Named register
5988 if (!Context.getTargetInfo().isValidGCCRegisterName(Label))
5989 Diag(E->getExprLoc(), diag::err_asm_unknown_register_name) << Label;
Renato Golin2e31e4e2014-06-05 16:45:22 +00005990 if (!R->isIntegralType(Context) && !R->isPointerType()) {
5991 Diag(D.getLocStart(), diag::err_asm_bad_register_type);
5992 NewVD->setInvalidDecl(true);
5993 }
Abramo Bagnara13392232011-01-11 15:16:52 +00005994 }
5995
5996 NewVD->addAttr(::new (Context) AsmLabelAttr(SE->getStrTokenLoc(0),
Aaron Ballman36a53502014-01-16 13:03:14 +00005997 Context, Label, 0));
Aaron Ballman7572e582015-07-16 17:06:53 +00005998 } else if (!ExtnameUndeclaredIdentifiers.empty()) {
David Chisnall0867d9c2012-02-18 16:12:34 +00005999 llvm::DenseMap<IdentifierInfo*,AsmLabelAttr*>::iterator I =
6000 ExtnameUndeclaredIdentifiers.find(NewVD->getIdentifier());
6001 if (I != ExtnameUndeclaredIdentifiers.end()) {
Aaron Ballman7572e582015-07-16 17:06:53 +00006002 if (isDeclExternC(NewVD)) {
6003 NewVD->addAttr(I->second);
6004 ExtnameUndeclaredIdentifiers.erase(I);
6005 } else
6006 Diag(NewVD->getLocation(), diag::warn_redefine_extname_not_applied)
6007 << /*Variable*/1 << NewVD;
David Chisnall0867d9c2012-02-18 16:12:34 +00006008 }
Zhongxing Xu9b7714d2009-01-16 02:36:34 +00006009 }
6010
John McCalla2a3f7d2010-03-16 21:48:18 +00006011 // Diagnose shadowed variables before filtering for scope.
Richard Smith72bcaec2013-12-05 04:30:04 +00006012 if (D.getCXXScopeSpec().isEmpty())
John McCalldf8b37c2010-03-22 09:20:08 +00006013 CheckShadow(S, NewVD, Previous);
John McCalla2a3f7d2010-03-16 21:48:18 +00006014
John McCall1f82f242009-11-18 22:49:29 +00006015 // Don't consider existing declarations that are in a different
6016 // scope and are out-of-semantic-context declarations (if the new
6017 // declaration has linkage).
Richard Smith72bcaec2013-12-05 04:30:04 +00006018 FilterLookupForScope(Previous, OriginalDC, S, shouldConsiderLinkage(NewVD),
6019 D.getCXXScopeSpec().isNotEmpty() ||
6020 IsExplicitSpecialization ||
6021 IsVariableTemplateSpecialization);
Larisse Voufo39a1e502013-08-06 01:03:05 +00006022
Richard Smith1c34fb72013-08-13 18:18:50 +00006023 // Check whether the previous declaration is in the same block scope. This
6024 // affects whether we merge types with it, per C++11 [dcl.array]p3.
6025 if (getLangOpts().CPlusPlus &&
6026 NewVD->isLocalVarDecl() && NewVD->hasExternalStorage())
6027 NewVD->setPreviousDeclInSameBlockScope(
6028 Previous.isSingleResult() && !Previous.isShadowed() &&
Richard Smith541b38b2013-09-20 01:15:31 +00006029 isDeclInScope(Previous.getFoundDecl(), OriginalDC, S, false));
Richard Smith1c34fb72013-08-13 18:18:50 +00006030
David Blaikiebbafb8a2012-03-11 07:00:24 +00006031 if (!getLangOpts().CPlusPlus) {
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00006032 D.setRedeclaration(CheckVariableDeclaration(NewVD, Previous));
6033 } else {
Richard Smithbeef3452014-01-16 23:39:20 +00006034 // If this is an explicit specialization of a static data member, check it.
6035 if (IsExplicitSpecialization && !NewVD->isInvalidDecl() &&
6036 CheckMemberSpecialization(NewVD, Previous))
6037 NewVD->setInvalidDecl();
6038
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00006039 // Merge the decl with the existing one if appropriate.
6040 if (!Previous.empty()) {
6041 if (Previous.isSingleResult() &&
6042 isa<FieldDecl>(Previous.getFoundDecl()) &&
6043 D.getCXXScopeSpec().isSet()) {
6044 // The user tried to define a non-static data member
6045 // out-of-line (C++ [dcl.meaning]p1).
6046 Diag(NewVD->getLocation(), diag::err_nonstatic_member_out_of_line)
6047 << D.getCXXScopeSpec().getRange();
6048 Previous.clear();
6049 NewVD->setInvalidDecl();
6050 }
6051 } else if (D.getCXXScopeSpec().isSet()) {
6052 // No previous declaration in the qualifying scope.
6053 Diag(D.getIdentifierLoc(), diag::err_no_member)
6054 << Name << computeDeclContext(D.getCXXScopeSpec(), true)
Douglas Gregoref1a09a2009-03-25 23:32:15 +00006055 << D.getCXXScopeSpec().getRange();
Chris Lattnerf6d1c9c2009-04-25 08:06:05 +00006056 NewVD->setInvalidDecl();
Douglas Gregoref1a09a2009-03-25 23:32:15 +00006057 }
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00006058
Richard Smithbeef3452014-01-16 23:39:20 +00006059 if (!IsVariableTemplateSpecialization)
6060 D.setRedeclaration(CheckVariableDeclaration(NewVD, Previous));
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00006061
Richard Smithbeef3452014-01-16 23:39:20 +00006062 if (NewTemplate) {
6063 VarTemplateDecl *PrevVarTemplate =
6064 NewVD->getPreviousDecl()
6065 ? NewVD->getPreviousDecl()->getDescribedVarTemplate()
Craig Topperc3ec1492014-05-26 06:22:03 +00006066 : nullptr;
Richard Smithbeef3452014-01-16 23:39:20 +00006067
6068 // Check the template parameter list of this declaration, possibly
6069 // merging in the template parameter list from the previous variable
6070 // template declaration.
6071 if (CheckTemplateParameterList(
6072 TemplateParams,
6073 PrevVarTemplate ? PrevVarTemplate->getTemplateParameters()
Craig Topperc3ec1492014-05-26 06:22:03 +00006074 : nullptr,
Richard Smithbeef3452014-01-16 23:39:20 +00006075 (D.getCXXScopeSpec().isSet() && DC && DC->isRecord() &&
6076 DC->isDependentContext())
6077 ? TPC_ClassTemplateMember
6078 : TPC_VarTemplate))
6079 NewVD->setInvalidDecl();
6080
6081 // If we are providing an explicit specialization of a static variable
6082 // template, make a note of that.
6083 if (PrevVarTemplate &&
6084 PrevVarTemplate->getInstantiatedFromMemberTemplate())
6085 PrevVarTemplate->setMemberSpecialization();
6086 }
Douglas Gregoref1a09a2009-03-25 23:32:15 +00006087 }
Ryan Flynne5dc8592009-07-25 22:29:44 +00006088
Rafael Espindolade6a39f2013-03-02 21:41:48 +00006089 ProcessPragmaWeak(S, NewVD);
Rafael Espindolaf1d2f0e2013-01-16 23:11:15 +00006090
Richard Smithac974a32013-06-30 09:48:50 +00006091 // If this is the first declaration of an extern C variable, update
6092 // the map of such variables.
Rafael Espindola3f9e4442013-10-19 02:13:21 +00006093 if (NewVD->isFirstDecl() && !NewVD->isInvalidDecl() &&
Richard Smithac974a32013-06-30 09:48:50 +00006094 isIncompleteDeclExternC(*this, NewVD))
Richard Smith39b79682013-06-18 20:15:12 +00006095 RegisterLocallyScopedExternCDecl(NewVD, S);
Douglas Gregoref1a09a2009-03-25 23:32:15 +00006096
Reid Klecknerd8110b62013-09-10 20:14:30 +00006097 if (getLangOpts().CPlusPlus && NewVD->isStaticLocal()) {
Eli Friedman3b7d46c2013-07-10 00:30:46 +00006098 Decl *ManglingContextDecl;
David Majnemera7f8c462015-03-19 21:54:30 +00006099 if (MangleNumberingContext *MCtx = getCurrentMangleNumberContext(
6100 NewVD->getDeclContext(), ManglingContextDecl)) {
David Majnemerf27217f2014-03-05 18:55:38 +00006101 Context.setManglingNumber(
David Majnemera7f8c462015-03-19 21:54:30 +00006102 NewVD, MCtx->getManglingNumber(
6103 NewVD, getMSManglingNumber(getLangOpts(), S)));
David Majnemer2206bf52014-03-05 08:57:59 +00006104 Context.setStaticLocalNumber(NewVD, MCtx->getStaticLocalNumber(NewVD));
Eli Friedman3b7d46c2013-07-10 00:30:46 +00006105 }
6106 }
6107
Nico Rieck82f0b062014-03-31 14:56:15 +00006108 if (D.isRedeclaration() && !Previous.empty()) {
6109 checkDLLAttributeRedeclaration(
6110 *this, dyn_cast<NamedDecl>(Previous.getRepresentativeDecl()), NewVD,
6111 IsExplicitSpecialization);
6112 }
6113
Larisse Voufo72caf2b2013-08-22 00:59:14 +00006114 if (NewTemplate) {
Richard Smithbeef3452014-01-16 23:39:20 +00006115 if (NewVD->isInvalidDecl())
6116 NewTemplate->setInvalidDecl();
Larisse Voufo72caf2b2013-08-22 00:59:14 +00006117 ActOnDocumentableDecl(NewTemplate);
6118 return NewTemplate;
Larisse Voufo39a1e502013-08-06 01:03:05 +00006119 }
6120
Larisse Voufo72caf2b2013-08-22 00:59:14 +00006121 return NewVD;
Douglas Gregoref1a09a2009-03-25 23:32:15 +00006122}
6123
John McCalldf8b37c2010-03-22 09:20:08 +00006124/// \brief Diagnose variable or built-in function shadowing. Implements
6125/// -Wshadow.
John McCalla2a3f7d2010-03-16 21:48:18 +00006126///
John McCalldf8b37c2010-03-22 09:20:08 +00006127/// This method is called whenever a VarDecl is added to a "useful"
6128/// scope.
John McCalla2a3f7d2010-03-16 21:48:18 +00006129///
John McCall2d8c7602010-03-20 04:12:52 +00006130/// \param S the scope in which the shadowing name is being declared
6131/// \param R the lookup of the name
John McCalla2a3f7d2010-03-16 21:48:18 +00006132///
John McCalldf8b37c2010-03-22 09:20:08 +00006133void Sema::CheckShadow(Scope *S, VarDecl *D, const LookupResult& R) {
John McCalla2a3f7d2010-03-16 21:48:18 +00006134 // Return if warning is ignored.
Alp Tokerd4a3f0e2014-06-15 23:30:39 +00006135 if (Diags.isIgnored(diag::warn_decl_shadow, R.getNameLoc()))
John McCalla2a3f7d2010-03-16 21:48:18 +00006136 return;
6137
Argyrios Kyrtzidis898fdbf2011-02-08 18:21:25 +00006138 // Don't diagnose declarations at file scope.
Argyrios Kyrtzidisbd0a3fe2011-04-25 21:39:50 +00006139 if (D->hasGlobalStorage())
John McCalla2a3f7d2010-03-16 21:48:18 +00006140 return;
Argyrios Kyrtzidisbd0a3fe2011-04-25 21:39:50 +00006141
6142 DeclContext *NewDC = D->getDeclContext();
6143
John McCall2d8c7602010-03-20 04:12:52 +00006144 // Only diagnose if we're shadowing an unambiguous field or variable.
Douglas Gregor319aa6c2010-03-17 16:03:44 +00006145 if (R.getResultKind() != LookupResult::Found)
John McCalla2a3f7d2010-03-16 21:48:18 +00006146 return;
John McCalla2a3f7d2010-03-16 21:48:18 +00006147
John McCalla2a3f7d2010-03-16 21:48:18 +00006148 NamedDecl* ShadowedDecl = R.getFoundDecl();
6149 if (!isa<VarDecl>(ShadowedDecl) && !isa<FieldDecl>(ShadowedDecl))
6150 return;
6151
Argyrios Kyrtzidisf46cc652011-01-31 07:04:54 +00006152 // Fields are not shadowed by variables in C++ static methods.
6153 if (isa<FieldDecl>(ShadowedDecl))
6154 if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(NewDC))
6155 if (MD->isStatic())
6156 return;
6157
Argyrios Kyrtzidis857dd062011-01-31 07:04:50 +00006158 if (VarDecl *shadowedVar = dyn_cast<VarDecl>(ShadowedDecl))
6159 if (shadowedVar->isExternC()) {
Argyrios Kyrtzidis857dd062011-01-31 07:04:50 +00006160 // For shadowing external vars, make sure that we point to the global
6161 // declaration, not a locally scoped extern declaration.
Aaron Ballman86c93902014-03-06 23:45:36 +00006162 for (auto I : shadowedVar->redecls())
Argyrios Kyrtzidis857dd062011-01-31 07:04:50 +00006163 if (I->isFileVarDecl()) {
Aaron Ballman86c93902014-03-06 23:45:36 +00006164 ShadowedDecl = I;
Argyrios Kyrtzidis857dd062011-01-31 07:04:50 +00006165 break;
6166 }
6167 }
6168
6169 DeclContext *OldDC = ShadowedDecl->getDeclContext();
6170
John McCall2d8c7602010-03-20 04:12:52 +00006171 // Only warn about certain kinds of shadowing for class members.
6172 if (NewDC && NewDC->isRecord()) {
6173 // In particular, don't warn about shadowing non-class members.
6174 if (!OldDC->isRecord())
6175 return;
6176
6177 // TODO: should we warn about static data members shadowing
6178 // static data members from base classes?
6179
6180 // TODO: don't diagnose for inaccessible shadowed members.
6181 // This is hard to do perfectly because we might friend the
6182 // shadowing context, but that's just a false negative.
6183 }
6184
6185 // Determine what kind of declaration we're shadowing.
John McCalla2a3f7d2010-03-16 21:48:18 +00006186 unsigned Kind;
John McCall2d8c7602010-03-20 04:12:52 +00006187 if (isa<RecordDecl>(OldDC)) {
John McCalla2a3f7d2010-03-16 21:48:18 +00006188 if (isa<FieldDecl>(ShadowedDecl))
6189 Kind = 3; // field
6190 else
6191 Kind = 2; // static data member
John McCall2d8c7602010-03-20 04:12:52 +00006192 } else if (OldDC->isFileContext())
John McCalla2a3f7d2010-03-16 21:48:18 +00006193 Kind = 1; // global
6194 else
6195 Kind = 0; // local
6196
John McCall2d8c7602010-03-20 04:12:52 +00006197 DeclarationName Name = R.getLookupName();
6198
John McCalla2a3f7d2010-03-16 21:48:18 +00006199 // Emit warning and note.
Alp Toker15ab3732013-12-12 12:47:48 +00006200 if (getSourceManager().isInSystemMacro(R.getNameLoc()))
6201 return;
John McCall2d8c7602010-03-20 04:12:52 +00006202 Diag(R.getNameLoc(), diag::warn_decl_shadow) << Name << Kind << OldDC;
John McCalla2a3f7d2010-03-16 21:48:18 +00006203 Diag(ShadowedDecl->getLocation(), diag::note_previous_declaration);
6204}
6205
John McCalldf8b37c2010-03-22 09:20:08 +00006206/// \brief Check -Wshadow without the advantage of a previous lookup.
6207void Sema::CheckShadow(Scope *S, VarDecl *D) {
Alp Tokerd4a3f0e2014-06-15 23:30:39 +00006208 if (Diags.isIgnored(diag::warn_decl_shadow, D->getLocation()))
Argyrios Kyrtzidis1cb0de12010-12-15 18:44:22 +00006209 return;
6210
John McCalldf8b37c2010-03-22 09:20:08 +00006211 LookupResult R(*this, D->getDeclName(), D->getLocation(),
6212 Sema::LookupOrdinaryName, Sema::ForRedeclaration);
6213 LookupName(R, S);
6214 CheckShadow(S, D, R);
6215}
6216
Richard Smithac974a32013-06-30 09:48:50 +00006217/// Check for conflict between this global or extern "C" declaration and
6218/// previous global or extern "C" declarations. This is only used in C++.
Rafael Espindola46afb352013-01-11 19:34:23 +00006219template<typename T>
Richard Smithac974a32013-06-30 09:48:50 +00006220static bool checkGlobalOrExternCConflict(
6221 Sema &S, const T *ND, bool IsGlobal, LookupResult &Previous) {
6222 assert(S.getLangOpts().CPlusPlus && "only C++ has extern \"C\"");
6223 NamedDecl *Prev = S.findLocallyScopedExternCDecl(ND->getDeclName());
Rafael Espindola0e0d0092013-03-14 03:07:35 +00006224
Richard Smithac974a32013-06-30 09:48:50 +00006225 if (!Prev && IsGlobal && !isIncompleteDeclExternC(S, ND)) {
6226 // The common case: this global doesn't conflict with any extern "C"
6227 // declaration.
6228 return false;
6229 }
6230
6231 if (Prev) {
6232 if (!IsGlobal || isIncompleteDeclExternC(S, ND)) {
6233 // Both the old and new declarations have C language linkage. This is a
6234 // redeclaration.
6235 Previous.clear();
6236 Previous.addDecl(Prev);
6237 return true;
6238 }
6239
6240 // This is a global, non-extern "C" declaration, and there is a previous
6241 // non-global extern "C" declaration. Diagnose if this is a variable
6242 // declaration.
6243 if (!isa<VarDecl>(ND))
6244 return false;
6245 } else {
6246 // The declaration is extern "C". Check for any declaration in the
6247 // translation unit which might conflict.
6248 if (IsGlobal) {
6249 // We have already performed the lookup into the translation unit.
6250 IsGlobal = false;
6251 for (LookupResult::iterator I = Previous.begin(), E = Previous.end();
6252 I != E; ++I) {
6253 if (isa<VarDecl>(*I)) {
6254 Prev = *I;
6255 break;
6256 }
6257 }
6258 } else {
6259 DeclContext::lookup_result R =
6260 S.Context.getTranslationUnitDecl()->lookup(ND->getDeclName());
6261 for (DeclContext::lookup_result::iterator I = R.begin(), E = R.end();
6262 I != E; ++I) {
6263 if (isa<VarDecl>(*I)) {
6264 Prev = *I;
6265 break;
6266 }
6267 // FIXME: If we have any other entity with this name in global scope,
6268 // the declaration is ill-formed, but that is a defect: it breaks the
6269 // 'stat' hack, for instance. Only variables can have mangled name
6270 // clashes with extern "C" declarations, so only they deserve a
6271 // diagnostic.
6272 }
6273 }
6274
6275 if (!Prev)
Rafael Espindola0e0d0092013-03-14 03:07:35 +00006276 return false;
6277 }
6278
Richard Smithac974a32013-06-30 09:48:50 +00006279 // Use the first declaration's location to ensure we point at something which
6280 // is lexically inside an extern "C" linkage-spec.
6281 assert(Prev && "should have found a previous declaration to diagnose");
6282 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(Prev))
Rafael Espindola8db352d2013-10-17 15:37:26 +00006283 Prev = FD->getFirstDecl();
Richard Smithac974a32013-06-30 09:48:50 +00006284 else
Rafael Espindola8db352d2013-10-17 15:37:26 +00006285 Prev = cast<VarDecl>(Prev)->getFirstDecl();
Richard Smithac974a32013-06-30 09:48:50 +00006286
6287 S.Diag(ND->getLocation(), diag::err_extern_c_global_conflict)
6288 << IsGlobal << ND;
6289 S.Diag(Prev->getLocation(), diag::note_extern_c_global_conflict)
6290 << IsGlobal;
6291 return false;
6292}
6293
6294/// Apply special rules for handling extern "C" declarations. Returns \c true
6295/// if we have found that this is a redeclaration of some prior entity.
6296///
6297/// Per C++ [dcl.link]p6:
6298/// Two declarations [for a function or variable] with C language linkage
6299/// with the same name that appear in different scopes refer to the same
6300/// [entity]. An entity with C language linkage shall not be declared with
6301/// the same name as an entity in global scope.
6302template<typename T>
6303static bool checkForConflictWithNonVisibleExternC(Sema &S, const T *ND,
6304 LookupResult &Previous) {
6305 if (!S.getLangOpts().CPlusPlus) {
6306 // In C, when declaring a global variable, look for a corresponding 'extern'
Richard Smith541b38b2013-09-20 01:15:31 +00006307 // variable declared in function scope. We don't need this in C++, because
6308 // we find local extern decls in the surrounding file-scope DeclContext.
Richard Smithac974a32013-06-30 09:48:50 +00006309 if (ND->getDeclContext()->getRedeclContext()->isTranslationUnit()) {
6310 if (NamedDecl *Prev = S.findLocallyScopedExternCDecl(ND->getDeclName())) {
6311 Previous.clear();
6312 Previous.addDecl(Prev);
6313 return true;
6314 }
6315 }
6316 return false;
6317 }
6318
6319 // A declaration in the translation unit can conflict with an extern "C"
6320 // declaration.
6321 if (ND->getDeclContext()->getRedeclContext()->isTranslationUnit())
6322 return checkGlobalOrExternCConflict(S, ND, /*IsGlobal*/true, Previous);
6323
6324 // An extern "C" declaration can conflict with a declaration in the
6325 // translation unit or can be a redeclaration of an extern "C" declaration
6326 // in another scope.
6327 if (isIncompleteDeclExternC(S,ND))
6328 return checkGlobalOrExternCConflict(S, ND, /*IsGlobal*/false, Previous);
6329
6330 // Neither global nor extern "C": nothing to do.
6331 return false;
Rafael Espindola46afb352013-01-11 19:34:23 +00006332}
6333
Richard Smith27d807c2013-04-30 13:56:41 +00006334void Sema::CheckVariableDeclarationType(VarDecl *NewVD) {
Chris Lattnerf6d1c9c2009-04-25 08:06:05 +00006335 // If the decl is already known invalid, don't check it.
6336 if (NewVD->isInvalidDecl())
Richard Smith27d807c2013-04-30 13:56:41 +00006337 return;
Mike Stump11289f42009-09-09 15:08:12 +00006338
Abramo Bagnara341ab732012-11-08 14:44:42 +00006339 TypeSourceInfo *TInfo = NewVD->getTypeSourceInfo();
6340 QualType T = TInfo->getType();
Douglas Gregoref1a09a2009-03-25 23:32:15 +00006341
Richard Smith27d807c2013-04-30 13:56:41 +00006342 // Defer checking an 'auto' type until its initializer is attached.
6343 if (T->isUndeducedType())
6344 return;
6345
Richard Smithdc4ccaa2014-03-27 01:22:48 +00006346 if (NewVD->hasAttrs())
6347 CheckAlignasUnderalignment(NewVD);
6348
John McCall8b07ec22010-05-15 11:32:37 +00006349 if (T->isObjCObjectType()) {
Fariborz Jahanian9a14c212011-07-25 21:12:27 +00006350 Diag(NewVD->getLocation(), diag::err_statically_allocated_object)
6351 << FixItHint::CreateInsertion(NewVD->getLocation(), "*");
Fariborz Jahanian6507135e2011-07-26 17:58:54 +00006352 T = Context.getObjCObjectPointerType(T);
6353 NewVD->setType(T);
Douglas Gregoref1a09a2009-03-25 23:32:15 +00006354 }
Mike Stump11289f42009-09-09 15:08:12 +00006355
Zhongxing Xu9b7714d2009-01-16 02:36:34 +00006356 // Emit an error if an address space was applied to decl with local storage.
6357 // This includes arrays of objects with address space qualifiers, but not
6358 // automatic variables that point to other address spaces.
6359 // ISO/IEC TR 18037 S5.1.2
Chris Lattner88fdea82010-10-10 18:16:20 +00006360 if (NewVD->hasLocalStorage() && T.getAddressSpace() != 0) {
Douglas Gregoref1a09a2009-03-25 23:32:15 +00006361 Diag(NewVD->getLocation(), diag::err_as_qualified_auto_decl);
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00006362 NewVD->setInvalidDecl();
Richard Smith27d807c2013-04-30 13:56:41 +00006363 return;
Zhongxing Xu9b7714d2009-01-16 02:36:34 +00006364 }
Fariborz Jahanian0c9404e2009-02-21 19:44:02 +00006365
Tanya Lattner713eef42013-04-05 20:14:50 +00006366 // OpenCL v1.2 s6.5 - All program scope variables must be declared in the
6367 // __constant address space.
6368 if (getLangOpts().OpenCL && NewVD->isFileVarDecl()
6369 && T.getAddressSpace() != LangAS::opencl_constant
6370 && !T->isSamplerT()){
6371 Diag(NewVD->getLocation(), diag::err_opencl_global_invalid_addr_space);
6372 NewVD->setInvalidDecl();
Richard Smith27d807c2013-04-30 13:56:41 +00006373 return;
Tanya Lattner713eef42013-04-05 20:14:50 +00006374 }
6375
Tanya Lattner4fdce3f2012-06-19 23:09:52 +00006376 // OpenCL v1.2 s6.8 -- The static qualifier is valid only in program
6377 // scope.
6378 if ((getLangOpts().OpenCLVersion >= 120)
6379 && NewVD->isStaticLocal()) {
6380 Diag(NewVD->getLocation(), diag::err_static_function_scope);
6381 NewVD->setInvalidDecl();
Richard Smith27d807c2013-04-30 13:56:41 +00006382 return;
Tanya Lattner4fdce3f2012-06-19 23:09:52 +00006383 }
6384
Mike Stumpca5ae662009-04-14 00:57:29 +00006385 if (NewVD->hasLocalStorage() && T.isObjCGCWeak()
Fariborz Jahanianc32830c2011-06-07 20:15:46 +00006386 && !NewVD->hasAttr<BlocksAttr>()) {
David Blaikiebbafb8a2012-03-11 07:00:24 +00006387 if (getLangOpts().getGC() != LangOptions::NonGC)
Fariborz Jahanianc32830c2011-06-07 20:15:46 +00006388 Diag(NewVD->getLocation(), diag::warn_gc_attribute_weak_on_local);
Ted Kremenek2f88c402012-10-02 05:36:02 +00006389 else {
6390 assert(!getLangOpts().ObjCAutoRefCount);
Fariborz Jahanianc32830c2011-06-07 20:15:46 +00006391 Diag(NewVD->getLocation(), diag::warn_attribute_weak_on_local);
Ted Kremenek2f88c402012-10-02 05:36:02 +00006392 }
Fariborz Jahanianc32830c2011-06-07 20:15:46 +00006393 }
Chris Lattner88fdea82010-10-10 18:16:20 +00006394
Chris Lattner9fecd742009-04-19 05:21:20 +00006395 bool isVM = T->isVariablyModifiedType();
Chris Lattner9662cd32009-07-19 20:17:11 +00006396 if (isVM || NewVD->hasAttr<CleanupAttr>() ||
John McCalld4e1b762010-08-01 01:24:59 +00006397 NewVD->hasAttr<BlocksAttr>())
John McCallaab3e412010-08-25 08:40:02 +00006398 getCurFunction()->setHasBranchProtectedScope();
Mike Stump11289f42009-09-09 15:08:12 +00006399
Chris Lattner9fecd742009-04-19 05:21:20 +00006400 if ((isVM && NewVD->hasLinkage()) ||
6401 (T->isVariableArrayType() && NewVD->hasGlobalStorage())) {
Anders Carlsson6c885802009-02-28 21:56:50 +00006402 bool SizeIsNegative;
Douglas Gregorcaa1bf42010-08-18 00:39:00 +00006403 llvm::APSInt Oversized;
Abramo Bagnara341ab732012-11-08 14:44:42 +00006404 TypeSourceInfo *FixedTInfo =
6405 TryToFixInvalidVariablyModifiedTypeSourceInfo(TInfo, Context,
6406 SizeIsNegative, Oversized);
Craig Topperc3ec1492014-05-26 06:22:03 +00006407 if (!FixedTInfo && T->isVariableArrayType()) {
Douglas Gregoref1a09a2009-03-25 23:32:15 +00006408 const VariableArrayType *VAT = Context.getAsVariableArrayType(T);
Mike Stump11289f42009-09-09 15:08:12 +00006409 // FIXME: This won't give the correct result for
6410 // int a[10][n];
Anders Carlsson6c885802009-02-28 21:56:50 +00006411 SourceRange SizeRange = VAT->getSizeExpr()->getSourceRange();
Mike Stump11289f42009-09-09 15:08:12 +00006412
Anders Carlsson6c885802009-02-28 21:56:50 +00006413 if (NewVD->isFileVarDecl())
6414 Diag(NewVD->getLocation(), diag::err_vla_decl_in_file_scope)
Chris Lattnerf6d1c9c2009-04-25 08:06:05 +00006415 << SizeRange;
Enea Zaffanella28f36ba2013-05-10 20:34:44 +00006416 else if (NewVD->isStaticLocal())
Anders Carlsson6c885802009-02-28 21:56:50 +00006417 Diag(NewVD->getLocation(), diag::err_vla_decl_has_static_storage)
Chris Lattnerf6d1c9c2009-04-25 08:06:05 +00006418 << SizeRange;
Anders Carlsson6c885802009-02-28 21:56:50 +00006419 else
6420 Diag(NewVD->getLocation(), diag::err_vla_decl_has_extern_linkage)
Chris Lattnerf6d1c9c2009-04-25 08:06:05 +00006421 << SizeRange;
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00006422 NewVD->setInvalidDecl();
Richard Smith27d807c2013-04-30 13:56:41 +00006423 return;
Mike Stump11289f42009-09-09 15:08:12 +00006424 }
6425
Craig Topperc3ec1492014-05-26 06:22:03 +00006426 if (!FixedTInfo) {
Anders Carlsson6c885802009-02-28 21:56:50 +00006427 if (NewVD->isFileVarDecl())
6428 Diag(NewVD->getLocation(), diag::err_vm_decl_in_file_scope);
6429 else
6430 Diag(NewVD->getLocation(), diag::err_vm_decl_has_extern_linkage);
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00006431 NewVD->setInvalidDecl();
Richard Smith27d807c2013-04-30 13:56:41 +00006432 return;
Anders Carlsson6c885802009-02-28 21:56:50 +00006433 }
Mike Stump11289f42009-09-09 15:08:12 +00006434
Chris Lattnerf6d1c9c2009-04-25 08:06:05 +00006435 Diag(NewVD->getLocation(), diag::warn_illegal_constant_array_size);
Abramo Bagnara3b8a9e52012-11-08 16:01:51 +00006436 NewVD->setType(FixedTInfo->getType());
Abramo Bagnara341ab732012-11-08 14:44:42 +00006437 NewVD->setTypeSourceInfo(FixedTInfo);
Anders Carlsson6c885802009-02-28 21:56:50 +00006438 }
6439
David Majnemer0ffa3312013-05-29 00:56:45 +00006440 if (T->isVoidType()) {
6441 // C++98 [dcl.stc]p5: The extern specifier can be applied only to the names
6442 // of objects and functions.
6443 if (NewVD->isThisDeclarationADefinition() || getLangOpts().CPlusPlus) {
6444 Diag(NewVD->getLocation(), diag::err_typecheck_decl_incomplete_type)
6445 << T;
6446 NewVD->setInvalidDecl();
6447 return;
6448 }
Richard Smith27d807c2013-04-30 13:56:41 +00006449 }
6450
6451 if (!NewVD->hasLocalStorage() && NewVD->hasAttr<BlocksAttr>()) {
6452 Diag(NewVD->getLocation(), diag::err_block_on_nonlocal);
6453 NewVD->setInvalidDecl();
6454 return;
6455 }
6456
6457 if (isVM && NewVD->hasAttr<BlocksAttr>()) {
6458 Diag(NewVD->getLocation(), diag::err_block_on_vm);
6459 NewVD->setInvalidDecl();
6460 return;
6461 }
6462
6463 if (NewVD->isConstexpr() && !T->isDependentType() &&
6464 RequireLiteralType(NewVD->getLocation(), T,
6465 diag::err_constexpr_var_non_literal)) {
Richard Smith27d807c2013-04-30 13:56:41 +00006466 NewVD->setInvalidDecl();
6467 return;
6468 }
6469}
6470
6471/// \brief Perform semantic checking on a newly-created variable
6472/// declaration.
6473///
6474/// This routine performs all of the type-checking required for a
6475/// variable declaration once it has been built. It is used both to
6476/// check variables after they have been parsed and their declarators
6477/// have been translated into a declaration, and to check variables
6478/// that have been instantiated from a template.
6479///
6480/// Sets NewVD->isInvalidDecl() if an error was encountered.
6481///
6482/// Returns true if the variable declaration is a redeclaration.
Larisse Voufo72caf2b2013-08-22 00:59:14 +00006483bool Sema::CheckVariableDeclaration(VarDecl *NewVD, LookupResult &Previous) {
Richard Smith27d807c2013-04-30 13:56:41 +00006484 CheckVariableDeclarationType(NewVD);
6485
6486 // If the decl is already known invalid, don't check it.
6487 if (NewVD->isInvalidDecl())
6488 return false;
6489
John McCallb65e8fe2013-04-01 18:34:28 +00006490 // If we did not find anything by this name, look for a non-visible
6491 // extern "C" declaration with the same name.
Richard Smith1c34fb72013-08-13 18:18:50 +00006492 if (Previous.empty() &&
6493 checkForConflictWithNonVisibleExternC(*this, NewVD, Previous))
Richard Smith3c785782013-09-03 21:00:58 +00006494 Previous.setShadowed();
Douglas Gregor5a80bd12009-03-02 00:19:53 +00006495
John McCall1f82f242009-11-18 22:49:29 +00006496 if (!Previous.empty()) {
Richard Smith3c785782013-09-03 21:00:58 +00006497 MergeVarDecl(NewVD, Previous);
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00006498 return true;
Zhongxing Xu9b7714d2009-01-16 02:36:34 +00006499 }
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00006500 return false;
Zhongxing Xu9b7714d2009-01-16 02:36:34 +00006501}
6502
Benjamin Kramer6e4f6e12015-07-25 15:07:25 +00006503namespace {
6504struct FindOverriddenMethod {
Douglas Gregor36d1b142009-10-06 17:59:45 +00006505 Sema *S;
6506 CXXMethodDecl *Method;
Benjamin Kramer6e4f6e12015-07-25 15:07:25 +00006507
6508 /// Member lookup function that determines whether a given C++
6509 /// method overrides a method in a base class, to be used with
6510 /// CXXRecordDecl::lookupInBases().
6511 bool operator()(const CXXBaseSpecifier *Specifier, CXXBasePath &Path) {
6512 RecordDecl *BaseRecord =
6513 Specifier->getType()->getAs<RecordType>()->getDecl();
6514
6515 DeclarationName Name = Method->getDeclName();
6516
6517 // FIXME: Do we care about other names here too?
6518 if (Name.getNameKind() == DeclarationName::CXXDestructorName) {
6519 // We really want to find the base class destructor here.
6520 QualType T = S->Context.getTypeDeclType(BaseRecord);
6521 CanQualType CT = S->Context.getCanonicalType(T);
6522
6523 Name = S->Context.DeclarationNames.getCXXDestructorName(CT);
6524 }
6525
6526 for (Path.Decls = BaseRecord->lookup(Name); !Path.Decls.empty();
6527 Path.Decls = Path.Decls.slice(1)) {
6528 NamedDecl *D = Path.Decls.front();
6529 if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(D)) {
6530 if (MD->isVirtual() && !S->IsOverload(Method, MD, false))
6531 return true;
6532 }
6533 }
6534
6535 return false;
6536 }
Douglas Gregor36d1b142009-10-06 17:59:45 +00006537};
6538
Benjamin Kramer6e4f6e12015-07-25 15:07:25 +00006539enum OverrideErrorKind { OEK_All, OEK_NonDeleted, OEK_Deleted };
6540} // end anonymous namespace
Anders Carlssone985fae2009-11-26 20:50:40 +00006541
David Blaikie7e414262012-10-17 00:47:58 +00006542/// \brief Report an error regarding overriding, along with any relevant
6543/// overriden methods.
6544///
6545/// \param DiagID the primary error to report.
6546/// \param MD the overriding method.
6547/// \param OEK which overrides to include as notes.
6548static void ReportOverrides(Sema& S, unsigned DiagID, const CXXMethodDecl *MD,
6549 OverrideErrorKind OEK = OEK_All) {
6550 S.Diag(MD->getLocation(), DiagID) << MD->getDeclName();
6551 for (CXXMethodDecl::method_iterator I = MD->begin_overridden_methods(),
6552 E = MD->end_overridden_methods();
6553 I != E; ++I) {
6554 // This check (& the OEK parameter) could be replaced by a predicate, but
6555 // without lambdas that would be overkill. This is still nicer than writing
6556 // out the diag loop 3 times.
6557 if ((OEK == OEK_All) ||
6558 (OEK == OEK_NonDeleted && !(*I)->isDeleted()) ||
6559 (OEK == OEK_Deleted && (*I)->isDeleted()))
6560 S.Diag((*I)->getLocation(), diag::note_overridden_virtual_function);
6561 }
6562}
6563
Sebastian Redld5b24532009-11-18 21:51:29 +00006564/// AddOverriddenMethods - See if a method overrides any in the base classes,
6565/// and if so, check that it's a valid override and remember it.
Douglas Gregor5a2bb5b2010-10-13 22:55:32 +00006566bool Sema::AddOverriddenMethods(CXXRecordDecl *DC, CXXMethodDecl *MD) {
David Blaikie1cbb9712014-11-14 19:09:44 +00006567 // Look for methods in base classes that this method might override.
Sebastian Redld5b24532009-11-18 21:51:29 +00006568 CXXBasePaths Paths;
Benjamin Kramer6e4f6e12015-07-25 15:07:25 +00006569 FindOverriddenMethod FOM;
6570 FOM.Method = MD;
6571 FOM.S = this;
David Blaikie7e414262012-10-17 00:47:58 +00006572 bool hasDeletedOverridenMethods = false;
6573 bool hasNonDeletedOverridenMethods = false;
Douglas Gregor5a2bb5b2010-10-13 22:55:32 +00006574 bool AddedAny = false;
Benjamin Kramer6e4f6e12015-07-25 15:07:25 +00006575 if (DC->lookupInBases(FOM, Paths)) {
Aaron Ballmane6f465e2014-03-14 21:38:48 +00006576 for (auto *I : Paths.found_decls()) {
6577 if (CXXMethodDecl *OldMD = dyn_cast<CXXMethodDecl>(I)) {
Richard Trieu95d88092011-07-01 20:02:53 +00006578 MD->addOverriddenMethod(OldMD->getCanonicalDecl());
Sebastian Redld5b24532009-11-18 21:51:29 +00006579 if (!CheckOverridingFunctionReturnType(MD, OldMD) &&
Aaron Ballman02df2e02012-12-09 17:45:41 +00006580 !CheckOverridingFunctionAttributes(MD, OldMD) &&
Richard Smithd3b5c9082012-07-27 04:22:15 +00006581 !CheckOverridingFunctionExceptionSpec(MD, OldMD) &&
Anders Carlsson3f610c72011-01-20 16:25:36 +00006582 !CheckIfOverriddenFunctionIsMarkedFinal(MD, OldMD)) {
David Blaikie7e414262012-10-17 00:47:58 +00006583 hasDeletedOverridenMethods |= OldMD->isDeleted();
6584 hasNonDeletedOverridenMethods |= !OldMD->isDeleted();
Douglas Gregor5a2bb5b2010-10-13 22:55:32 +00006585 AddedAny = true;
6586 }
Sebastian Redld5b24532009-11-18 21:51:29 +00006587 }
6588 }
6589 }
David Blaikie7e414262012-10-17 00:47:58 +00006590
6591 if (hasDeletedOverridenMethods && !MD->isDeleted()) {
6592 ReportOverrides(*this, diag::err_non_deleted_override, MD, OEK_Deleted);
6593 }
6594 if (hasNonDeletedOverridenMethods && MD->isDeleted()) {
6595 ReportOverrides(*this, diag::err_deleted_override, MD, OEK_NonDeleted);
6596 }
6597
Douglas Gregor5a2bb5b2010-10-13 22:55:32 +00006598 return AddedAny;
Sebastian Redld5b24532009-11-18 21:51:29 +00006599}
6600
Kaelyn Uhrain0a32fca2011-10-11 00:28:39 +00006601namespace {
6602 // Struct for holding all of the extra arguments needed by
6603 // DiagnoseInvalidRedeclaration to call Sema::ActOnFunctionDeclarator.
6604 struct ActOnFDArgs {
6605 Scope *S;
6606 Declarator &D;
Kaelyn Uhrain0a32fca2011-10-11 00:28:39 +00006607 MultiTemplateParamsArg TemplateParamLists;
Kaelyn Uhrain0a32fca2011-10-11 00:28:39 +00006608 bool AddToScope;
6609 };
6610}
6611
Kaelyn Uhrainb1378402012-01-18 21:41:41 +00006612namespace {
6613
6614// Callback to only accept typo corrections that have a non-zero edit distance.
Kaelyn Uhrain7c019172012-02-16 22:40:59 +00006615// Also only accept corrections that have the same parent decl.
Kaelyn Uhrainb1378402012-01-18 21:41:41 +00006616class DifferentNameValidatorCCC : public CorrectionCandidateCallback {
6617 public:
Kaelyn Uhrain389e9c22012-06-07 23:57:08 +00006618 DifferentNameValidatorCCC(ASTContext &Context, FunctionDecl *TypoFD,
6619 CXXRecordDecl *Parent)
6620 : Context(Context), OriginalFD(TypoFD),
Craig Topperc3ec1492014-05-26 06:22:03 +00006621 ExpectedParent(Parent ? Parent->getCanonicalDecl() : nullptr) {}
Kaelyn Uhrain7c019172012-02-16 22:40:59 +00006622
Craig Toppere14c0f82014-03-12 04:55:44 +00006623 bool ValidateCandidate(const TypoCorrection &candidate) override {
Kaelyn Uhrain7c019172012-02-16 22:40:59 +00006624 if (candidate.getEditDistance() == 0)
6625 return false;
6626
Dmitri Gribenkof8579502013-01-12 19:30:44 +00006627 SmallVector<unsigned, 1> MismatchedParams;
Kaelyn Uhrain389e9c22012-06-07 23:57:08 +00006628 for (TypoCorrection::const_decl_iterator CDecl = candidate.begin(),
6629 CDeclEnd = candidate.end();
6630 CDecl != CDeclEnd; ++CDecl) {
6631 FunctionDecl *FD = dyn_cast<FunctionDecl>(*CDecl);
6632
6633 if (FD && !FD->hasBody() &&
6634 hasSimilarParameters(Context, FD, OriginalFD, MismatchedParams)) {
6635 if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) {
6636 CXXRecordDecl *Parent = MD->getParent();
6637 if (Parent && Parent->getCanonicalDecl() == ExpectedParent)
6638 return true;
6639 } else if (!ExpectedParent) {
6640 return true;
6641 }
6642 }
Kaelyn Uhrain7c019172012-02-16 22:40:59 +00006643 }
6644
Kaelyn Uhrain389e9c22012-06-07 23:57:08 +00006645 return false;
Kaelyn Uhrainb1378402012-01-18 21:41:41 +00006646 }
Kaelyn Uhrain7c019172012-02-16 22:40:59 +00006647
6648 private:
Kaelyn Uhrain389e9c22012-06-07 23:57:08 +00006649 ASTContext &Context;
6650 FunctionDecl *OriginalFD;
Kaelyn Uhrain7c019172012-02-16 22:40:59 +00006651 CXXRecordDecl *ExpectedParent;
Kaelyn Uhrainb1378402012-01-18 21:41:41 +00006652};
6653
Alexander Kornienkoab9db512015-06-22 23:07:51 +00006654}
Kaelyn Uhrainb1378402012-01-18 21:41:41 +00006655
Kaelyn Uhrain0a32fca2011-10-11 00:28:39 +00006656/// \brief Generate diagnostics for an invalid function redeclaration.
6657///
6658/// This routine handles generating the diagnostic messages for an invalid
6659/// function redeclaration, including finding possible similar declarations
6660/// or performing typo correction if there are no previous declarations with
6661/// the same name.
6662///
Sylvestre Ledru33b5baf2012-09-27 10:16:10 +00006663/// Returns a NamedDecl iff typo correction was performed and substituting in
Kaelyn Uhrain0a32fca2011-10-11 00:28:39 +00006664/// the new declaration name does not cause new errors.
Richard Smith114394f2013-08-09 04:35:01 +00006665static NamedDecl *DiagnoseInvalidRedeclaration(
Kaelyn Uhrain8af2c9f2011-10-11 00:28:52 +00006666 Sema &SemaRef, LookupResult &Previous, FunctionDecl *NewFD,
Richard Smith114394f2013-08-09 04:35:01 +00006667 ActOnFDArgs &ExtraArgs, bool IsLocalFriend, Scope *S) {
Kaelyn Uhrainfd81a352011-08-18 18:19:12 +00006668 DeclarationName Name = NewFD->getDeclName();
Kaelyn Uhrain0a32fca2011-10-11 00:28:39 +00006669 DeclContext *NewDC = NewFD->getDeclContext();
Dmitri Gribenkof8579502013-01-12 19:30:44 +00006670 SmallVector<unsigned, 1> MismatchedParams;
6671 SmallVector<std::pair<FunctionDecl *, unsigned>, 1> NearMatches;
Kaelyn Uhrainfd81a352011-08-18 18:19:12 +00006672 TypoCorrection Correction;
Richard Smithf9b15102013-08-17 00:46:16 +00006673 bool IsDefinition = ExtraArgs.D.isFunctionDefinition();
Richard Smith114394f2013-08-09 04:35:01 +00006674 unsigned DiagMsg = IsLocalFriend ? diag::err_no_matching_local_friend
6675 : diag::err_member_decl_does_not_match;
6676 LookupResult Prev(SemaRef, Name, NewFD->getLocation(),
6677 IsLocalFriend ? Sema::LookupLocalFriendName
6678 : Sema::LookupOrdinaryName,
6679 Sema::ForRedeclaration);
Kaelyn Uhrainfd81a352011-08-18 18:19:12 +00006680
6681 NewFD->setInvalidDecl();
Richard Smith114394f2013-08-09 04:35:01 +00006682 if (IsLocalFriend)
6683 SemaRef.LookupName(Prev, S);
6684 else
6685 SemaRef.LookupQualifiedName(Prev, NewDC);
John McCallf7cfb222010-10-13 05:45:15 +00006686 assert(!Prev.isAmbiguous() &&
6687 "Cannot have an ambiguity in previous-declaration lookup");
Kaelyn Uhrain7c019172012-02-16 22:40:59 +00006688 CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(NewFD);
Kaelyn Uhrainfd81a352011-08-18 18:19:12 +00006689 if (!Prev.empty()) {
6690 for (LookupResult::iterator Func = Prev.begin(), FuncEnd = Prev.end();
6691 Func != FuncEnd; ++Func) {
6692 FunctionDecl *FD = dyn_cast<FunctionDecl>(*Func);
Kaelyn Uhrain8af2c9f2011-10-11 00:28:52 +00006693 if (FD &&
6694 hasSimilarParameters(SemaRef.Context, FD, NewFD, MismatchedParams)) {
Kaelyn Uhrainfd81a352011-08-18 18:19:12 +00006695 // Add 1 to the index so that 0 can mean the mismatch didn't
6696 // involve a parameter
6697 unsigned ParamNum =
6698 MismatchedParams.empty() ? 0 : MismatchedParams.front() + 1;
6699 NearMatches.push_back(std::make_pair(FD, ParamNum));
6700 }
Kaelyn Uhrain7d9bc632011-08-04 17:40:00 +00006701 }
Kaelyn Uhrainfd81a352011-08-18 18:19:12 +00006702 // If the qualified name lookup yielded nothing, try typo correction
Richard Smith114394f2013-08-09 04:35:01 +00006703 } else if ((Correction = SemaRef.CorrectTypo(
Kaelyn Takata89c881b2014-10-27 18:07:29 +00006704 Prev.getLookupNameInfo(), Prev.getLookupKind(), S,
6705 &ExtraArgs.D.getCXXScopeSpec(),
6706 llvm::make_unique<DifferentNameValidatorCCC>(
6707 SemaRef.Context, NewFD, MD ? MD->getParent() : nullptr),
6708 Sema::CTK_ErrorRecovery, IsLocalFriend ? nullptr : NewDC))) {
Kaelyn Uhrain0a32fca2011-10-11 00:28:39 +00006709 // Set up everything for the call to ActOnFunctionDeclarator
6710 ExtraArgs.D.SetIdentifier(Correction.getCorrectionAsIdentifierInfo(),
6711 ExtraArgs.D.getIdentifierLoc());
6712 Previous.clear();
6713 Previous.setLookupName(Correction.getCorrection());
Kaelyn Uhrainfd81a352011-08-18 18:19:12 +00006714 for (TypoCorrection::decl_iterator CDecl = Correction.begin(),
6715 CDeclEnd = Correction.end();
6716 CDecl != CDeclEnd; ++CDecl) {
6717 FunctionDecl *FD = dyn_cast<FunctionDecl>(*CDecl);
Kaelyn Uhrain389e9c22012-06-07 23:57:08 +00006718 if (FD && !FD->hasBody() &&
6719 hasSimilarParameters(SemaRef.Context, FD, NewFD, MismatchedParams)) {
Kaelyn Uhrain0a32fca2011-10-11 00:28:39 +00006720 Previous.addDecl(FD);
Kaelyn Uhrainfd81a352011-08-18 18:19:12 +00006721 }
6722 }
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00006723 bool wasRedeclaration = ExtraArgs.D.isRedeclaration();
Richard Smithf9b15102013-08-17 00:46:16 +00006724
6725 NamedDecl *Result;
6726 // Retry building the function declaration with the new previous
6727 // declarations, and with errors suppressed.
6728 {
6729 // Trap errors.
6730 Sema::SFINAETrap Trap(SemaRef);
6731
6732 // TODO: Refactor ActOnFunctionDeclarator so that we can call only the
6733 // pieces need to verify the typo-corrected C++ declaration and hopefully
6734 // eliminate the need for the parameter pack ExtraArgs.
6735 Result = SemaRef.ActOnFunctionDeclarator(
6736 ExtraArgs.S, ExtraArgs.D,
6737 Correction.getCorrectionDecl()->getDeclContext(),
6738 NewFD->getTypeSourceInfo(), Previous, ExtraArgs.TemplateParamLists,
6739 ExtraArgs.AddToScope);
6740
6741 if (Trap.hasErrorOccurred())
Craig Topperc3ec1492014-05-26 06:22:03 +00006742 Result = nullptr;
Kaelyn Uhrain0a32fca2011-10-11 00:28:39 +00006743 }
Richard Smithf9b15102013-08-17 00:46:16 +00006744
6745 if (Result) {
6746 // Determine which correction we picked.
6747 Decl *Canonical = Result->getCanonicalDecl();
6748 for (LookupResult::iterator I = Previous.begin(), E = Previous.end();
6749 I != E; ++I)
6750 if ((*I)->getCanonicalDecl() == Canonical)
6751 Correction.setCorrectionDecl(*I);
6752
6753 SemaRef.diagnoseTypo(
6754 Correction,
6755 SemaRef.PDiag(IsLocalFriend
6756 ? diag::err_no_matching_local_friend_suggest
6757 : diag::err_member_decl_does_not_match_suggest)
6758 << Name << NewDC << IsDefinition);
6759 return Result;
Kaelyn Uhrain0a32fca2011-10-11 00:28:39 +00006760 }
Richard Smithf9b15102013-08-17 00:46:16 +00006761
6762 // Pretend the typo correction never occurred
6763 ExtraArgs.D.SetIdentifier(Name.getAsIdentifierInfo(),
6764 ExtraArgs.D.getIdentifierLoc());
6765 ExtraArgs.D.setRedeclaration(wasRedeclaration);
6766 Previous.clear();
6767 Previous.setLookupName(Name);
Kaelyn Uhrainfd81a352011-08-18 18:19:12 +00006768 }
6769
Richard Smithf9b15102013-08-17 00:46:16 +00006770 SemaRef.Diag(NewFD->getLocation(), DiagMsg)
6771 << Name << NewDC << IsDefinition << NewFD->getLocation();
Kaelyn Uhrainfd81a352011-08-18 18:19:12 +00006772
Kaelyn Uhrain1a6eb992011-10-10 18:01:37 +00006773 bool NewFDisConst = false;
6774 if (CXXMethodDecl *NewMD = dyn_cast<CXXMethodDecl>(NewFD))
David Blaikief5697e52012-08-10 00:55:35 +00006775 NewFDisConst = NewMD->isConst();
Kaelyn Uhrain1a6eb992011-10-10 18:01:37 +00006776
Craig Topperaf6bd1b2013-07-04 03:15:42 +00006777 for (SmallVectorImpl<std::pair<FunctionDecl *, unsigned> >::iterator
Kaelyn Uhrainfd81a352011-08-18 18:19:12 +00006778 NearMatch = NearMatches.begin(), NearMatchEnd = NearMatches.end();
6779 NearMatch != NearMatchEnd; ++NearMatch) {
6780 FunctionDecl *FD = NearMatch->first;
Richard Smith114394f2013-08-09 04:35:01 +00006781 CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD);
6782 bool FDisConst = MD && MD->isConst();
6783 bool IsMember = MD || !IsLocalFriend;
Kaelyn Uhrainfd81a352011-08-18 18:19:12 +00006784
Richard Smith541b38b2013-09-20 01:15:31 +00006785 // FIXME: These notes are poorly worded for the local friend case.
Kaelyn Uhrainfd81a352011-08-18 18:19:12 +00006786 if (unsigned Idx = NearMatch->second) {
6787 ParmVarDecl *FDParam = FD->getParamDecl(Idx-1);
Richard Smithcf8ec8d2012-04-02 18:40:40 +00006788 SourceLocation Loc = FDParam->getTypeSpecStartLoc();
6789 if (Loc.isInvalid()) Loc = FD->getLocation();
Richard Smith114394f2013-08-09 04:35:01 +00006790 SemaRef.Diag(Loc, IsMember ? diag::note_member_def_close_param_match
6791 : diag::note_local_decl_close_param_match)
6792 << Idx << FDParam->getType()
6793 << NewFD->getParamDecl(Idx - 1)->getType();
Kaelyn Uhrain1a6eb992011-10-10 18:01:37 +00006794 } else if (FDisConst != NewFDisConst) {
Kaelyn Uhrain8af2c9f2011-10-11 00:28:52 +00006795 SemaRef.Diag(FD->getLocation(), diag::note_member_def_close_const_match)
Kaelyn Uhrain1a6eb992011-10-10 18:01:37 +00006796 << NewFDisConst << FD->getSourceRange().getEnd();
Kaelyn Uhrainfd81a352011-08-18 18:19:12 +00006797 } else
Richard Smith114394f2013-08-09 04:35:01 +00006798 SemaRef.Diag(FD->getLocation(),
6799 IsMember ? diag::note_member_def_close_match
6800 : diag::note_local_decl_close_match);
John McCallf7cfb222010-10-13 05:45:15 +00006801 }
Craig Topperc3ec1492014-05-26 06:22:03 +00006802 return nullptr;
John McCallf7cfb222010-10-13 05:45:15 +00006803}
6804
Craig Topperc79e5e32014-10-31 06:57:13 +00006805static StorageClass getFunctionStorageClass(Sema &SemaRef, Declarator &D) {
Kaelyn Uhraine1a9ff72011-10-11 00:28:49 +00006806 switch (D.getDeclSpec().getStorageClassSpec()) {
6807 default: llvm_unreachable("Unknown storage class!");
6808 case DeclSpec::SCS_auto:
6809 case DeclSpec::SCS_register:
6810 case DeclSpec::SCS_mutable:
6811 SemaRef.Diag(D.getDeclSpec().getStorageClassSpecLoc(),
6812 diag::err_typecheck_sclass_func);
6813 D.setInvalidType();
6814 break;
6815 case DeclSpec::SCS_unspecified: break;
Rafael Espindolabff59562013-04-25 12:11:36 +00006816 case DeclSpec::SCS_extern:
6817 if (D.getDeclSpec().isExternInLinkageSpec())
6818 return SC_None;
6819 return SC_Extern;
Kaelyn Uhraine1a9ff72011-10-11 00:28:49 +00006820 case DeclSpec::SCS_static: {
6821 if (SemaRef.CurContext->getRedeclContext()->isFunctionOrMethod()) {
6822 // C99 6.7.1p5:
6823 // The declaration of an identifier for a function that has
6824 // block scope shall have no explicit storage-class specifier
6825 // other than extern
6826 // See also (C++ [dcl.stc]p4).
6827 SemaRef.Diag(D.getDeclSpec().getStorageClassSpecLoc(),
6828 diag::err_static_block_func);
6829 break;
6830 } else
6831 return SC_Static;
6832 }
6833 case DeclSpec::SCS_private_extern: return SC_PrivateExtern;
6834 }
6835
6836 // No explicit storage class has already been returned
6837 return SC_None;
6838}
6839
6840static FunctionDecl* CreateNewFunctionDecl(Sema &SemaRef, Declarator &D,
6841 DeclContext *DC, QualType &R,
6842 TypeSourceInfo *TInfo,
Craig Topperc79e5e32014-10-31 06:57:13 +00006843 StorageClass SC,
Kaelyn Uhraine1a9ff72011-10-11 00:28:49 +00006844 bool &IsVirtualOkay) {
6845 DeclarationNameInfo NameInfo = SemaRef.GetNameForDeclarator(D);
6846 DeclarationName Name = NameInfo.getName();
6847
Craig Topperc3ec1492014-05-26 06:22:03 +00006848 FunctionDecl *NewFD = nullptr;
Kaelyn Uhraine1a9ff72011-10-11 00:28:49 +00006849 bool isInline = D.getDeclSpec().isInlineSpecified();
Kaelyn Uhraine1a9ff72011-10-11 00:28:49 +00006850
David Blaikiebbafb8a2012-03-11 07:00:24 +00006851 if (!SemaRef.getLangOpts().CPlusPlus) {
Kaelyn Uhraine1a9ff72011-10-11 00:28:49 +00006852 // Determine whether the function was written with a
6853 // prototype. This true when:
6854 // - there is a prototype in the declarator, or
6855 // - the type R of the function is some kind of typedef or other reference
6856 // to a type name (which eventually refers to a function type).
6857 bool HasPrototype =
6858 (D.isFunctionDeclarator() && D.getFunctionTypeInfo().hasPrototype) ||
6859 (!isa<FunctionType>(R.getTypePtr()) && R->isFunctionProtoType());
6860
David Blaikie30d15442011-10-19 22:56:21 +00006861 NewFD = FunctionDecl::Create(SemaRef.Context, DC,
Daniel Dunbar62ee6412012-03-09 18:35:03 +00006862 D.getLocStart(), NameInfo, R,
Rafael Espindola6ae7e502013-04-03 19:27:57 +00006863 TInfo, SC, isInline,
6864 HasPrototype, false);
Kaelyn Uhraine1a9ff72011-10-11 00:28:49 +00006865 if (D.isInvalidType())
6866 NewFD->setInvalidDecl();
6867
Kaelyn Uhraine1a9ff72011-10-11 00:28:49 +00006868 return NewFD;
6869 }
6870
6871 bool isExplicit = D.getDeclSpec().isExplicitSpecified();
6872 bool isConstexpr = D.getDeclSpec().isConstexprSpecified();
6873
6874 // Check that the return type is not an abstract class type.
6875 // For record types, this is done by the AbstractClassUsageDiagnoser once
6876 // the class has been completely parsed.
6877 if (!DC->isRecord() &&
Alp Toker314cc812014-01-25 16:55:45 +00006878 SemaRef.RequireNonAbstractType(
6879 D.getIdentifierLoc(), R->getAs<FunctionType>()->getReturnType(),
6880 diag::err_abstract_type_in_decl, SemaRef.AbstractReturnType))
Kaelyn Uhraine1a9ff72011-10-11 00:28:49 +00006881 D.setInvalidType();
6882
6883 if (Name.getNameKind() == DeclarationName::CXXConstructorName) {
6884 // This is a C++ constructor declaration.
6885 assert(DC->isRecord() &&
6886 "Constructors can only be declared in a member context");
6887
6888 R = SemaRef.CheckConstructorDeclarator(D, R, SC);
6889 return CXXConstructorDecl::Create(SemaRef.Context, cast<CXXRecordDecl>(DC),
Daniel Dunbar62ee6412012-03-09 18:35:03 +00006890 D.getLocStart(), NameInfo,
Kaelyn Uhraine1a9ff72011-10-11 00:28:49 +00006891 R, TInfo, isExplicit, isInline,
6892 /*isImplicitlyDeclared=*/false,
6893 isConstexpr);
6894
6895 } else if (Name.getNameKind() == DeclarationName::CXXDestructorName) {
6896 // This is a C++ destructor declaration.
6897 if (DC->isRecord()) {
6898 R = SemaRef.CheckDestructorDeclarator(D, R, SC);
6899 CXXRecordDecl *Record = cast<CXXRecordDecl>(DC);
6900 CXXDestructorDecl *NewDD = CXXDestructorDecl::Create(
6901 SemaRef.Context, Record,
Daniel Dunbar62ee6412012-03-09 18:35:03 +00006902 D.getLocStart(),
Kaelyn Uhraine1a9ff72011-10-11 00:28:49 +00006903 NameInfo, R, TInfo, isInline,
6904 /*isImplicitlyDeclared=*/false);
6905
6906 // If the class is complete, then we now create the implicit exception
6907 // specification. If the class is incomplete or dependent, we can't do
6908 // it yet.
Richard Smith2bf7fdb2013-01-02 11:42:31 +00006909 if (SemaRef.getLangOpts().CPlusPlus11 && !Record->isDependentType() &&
Kaelyn Uhraine1a9ff72011-10-11 00:28:49 +00006910 Record->getDefinition() && !Record->isBeingDefined() &&
6911 R->getAs<FunctionProtoType>()->getExceptionSpecType() == EST_None) {
6912 SemaRef.AdjustDestructorExceptionSpec(Record, NewDD);
6913 }
6914
6915 IsVirtualOkay = true;
6916 return NewDD;
6917
6918 } else {
6919 SemaRef.Diag(D.getIdentifierLoc(), diag::err_destructor_not_member);
6920 D.setInvalidType();
6921
6922 // Create a FunctionDecl to satisfy the function definition parsing
6923 // code path.
6924 return FunctionDecl::Create(SemaRef.Context, DC,
Daniel Dunbar62ee6412012-03-09 18:35:03 +00006925 D.getLocStart(),
Kaelyn Uhraine1a9ff72011-10-11 00:28:49 +00006926 D.getIdentifierLoc(), Name, R, TInfo,
Rafael Espindola6ae7e502013-04-03 19:27:57 +00006927 SC, isInline,
Kaelyn Uhraine1a9ff72011-10-11 00:28:49 +00006928 /*hasPrototype=*/true, isConstexpr);
6929 }
6930
6931 } else if (Name.getNameKind() == DeclarationName::CXXConversionFunctionName) {
6932 if (!DC->isRecord()) {
6933 SemaRef.Diag(D.getIdentifierLoc(),
6934 diag::err_conv_function_not_member);
Craig Topperc3ec1492014-05-26 06:22:03 +00006935 return nullptr;
Kaelyn Uhraine1a9ff72011-10-11 00:28:49 +00006936 }
6937
6938 SemaRef.CheckConversionDeclarator(D, R, SC);
6939 IsVirtualOkay = true;
6940 return CXXConversionDecl::Create(SemaRef.Context, cast<CXXRecordDecl>(DC),
Daniel Dunbar62ee6412012-03-09 18:35:03 +00006941 D.getLocStart(), NameInfo,
Kaelyn Uhraine1a9ff72011-10-11 00:28:49 +00006942 R, TInfo, isInline, isExplicit,
6943 isConstexpr, SourceLocation());
6944
6945 } else if (DC->isRecord()) {
6946 // If the name of the function is the same as the name of the record,
6947 // then this must be an invalid constructor that has a return type.
6948 // (The parser checks for a return type and makes the declarator a
6949 // constructor if it has no return type).
6950 if (Name.getAsIdentifierInfo() &&
6951 Name.getAsIdentifierInfo() == cast<CXXRecordDecl>(DC)->getIdentifier()){
6952 SemaRef.Diag(D.getIdentifierLoc(), diag::err_constructor_return_type)
6953 << SourceRange(D.getDeclSpec().getTypeSpecTypeLoc())
6954 << SourceRange(D.getIdentifierLoc());
Craig Topperc3ec1492014-05-26 06:22:03 +00006955 return nullptr;
Kaelyn Uhraine1a9ff72011-10-11 00:28:49 +00006956 }
6957
Kaelyn Uhraine1a9ff72011-10-11 00:28:49 +00006958 // This is a C++ method declaration.
Rafael Espindola6ae7e502013-04-03 19:27:57 +00006959 CXXMethodDecl *Ret = CXXMethodDecl::Create(SemaRef.Context,
6960 cast<CXXRecordDecl>(DC),
6961 D.getLocStart(), NameInfo, R,
6962 TInfo, SC, isInline,
6963 isConstexpr, SourceLocation());
6964 IsVirtualOkay = !Ret->isStatic();
6965 return Ret;
Kaelyn Uhraine1a9ff72011-10-11 00:28:49 +00006966 } else {
David Majnemeraa30dd72015-01-09 07:36:13 +00006967 bool isFriend =
6968 SemaRef.getLangOpts().CPlusPlus && D.getDeclSpec().isFriendSpecified();
6969 if (!isFriend && SemaRef.CurContext->isRecord())
6970 return nullptr;
6971
Kaelyn Uhraine1a9ff72011-10-11 00:28:49 +00006972 // Determine whether the function was written with a
6973 // prototype. This true when:
6974 // - we're in C++ (where every function has a prototype),
6975 return FunctionDecl::Create(SemaRef.Context, DC,
Daniel Dunbar62ee6412012-03-09 18:35:03 +00006976 D.getLocStart(),
Rafael Espindola6ae7e502013-04-03 19:27:57 +00006977 NameInfo, R, TInfo, SC, isInline,
Kaelyn Uhraine1a9ff72011-10-11 00:28:49 +00006978 true/*HasPrototype*/, isConstexpr);
6979 }
6980}
6981
Matt Arsenaultefb38192013-07-23 01:23:36 +00006982enum OpenCLParamType {
6983 ValidKernelParam,
6984 PtrPtrKernelParam,
6985 PtrKernelParam,
David Tweedababa8f2014-03-27 16:34:11 +00006986 PrivatePtrKernelParam,
Matt Arsenaultefb38192013-07-23 01:23:36 +00006987 InvalidKernelParam,
6988 RecordKernelParam
6989};
6990
6991static OpenCLParamType getOpenCLKernelParameterType(QualType PT) {
6992 if (PT->isPointerType()) {
6993 QualType PointeeType = PT->getPointeeType();
David Tweedababa8f2014-03-27 16:34:11 +00006994 if (PointeeType->isPointerType())
6995 return PtrPtrKernelParam;
6996 return PointeeType.getAddressSpace() == 0 ? PrivatePtrKernelParam
6997 : PtrKernelParam;
Matt Arsenaultefb38192013-07-23 01:23:36 +00006998 }
6999
7000 // TODO: Forbid the other integer types (size_t, ptrdiff_t...) when they can
7001 // be used as builtin types.
7002
7003 if (PT->isImageType())
7004 return PtrKernelParam;
7005
7006 if (PT->isBooleanType())
7007 return InvalidKernelParam;
7008
7009 if (PT->isEventT())
7010 return InvalidKernelParam;
7011
7012 if (PT->isHalfType())
7013 return InvalidKernelParam;
7014
7015 if (PT->isRecordType())
7016 return RecordKernelParam;
7017
7018 return ValidKernelParam;
7019}
7020
7021static void checkIsValidOpenCLKernelParameter(
7022 Sema &S,
7023 Declarator &D,
7024 ParmVarDecl *Param,
Craig Topper4dd9b432014-08-17 23:49:53 +00007025 llvm::SmallPtrSetImpl<const Type *> &ValidTypes) {
Matt Arsenaultefb38192013-07-23 01:23:36 +00007026 QualType PT = Param->getType();
7027
7028 // Cache the valid types we encounter to avoid rechecking structs that are
7029 // used again
7030 if (ValidTypes.count(PT.getTypePtr()))
7031 return;
7032
7033 switch (getOpenCLKernelParameterType(PT)) {
7034 case PtrPtrKernelParam:
7035 // OpenCL v1.2 s6.9.a:
7036 // A kernel function argument cannot be declared as a
7037 // pointer to a pointer type.
7038 S.Diag(Param->getLocation(), diag::err_opencl_ptrptr_kernel_param);
7039 D.setInvalidType();
7040 return;
7041
David Tweedababa8f2014-03-27 16:34:11 +00007042 case PrivatePtrKernelParam:
7043 // OpenCL v1.2 s6.9.a:
7044 // A kernel function argument cannot be declared as a
7045 // pointer to the private address space.
7046 S.Diag(Param->getLocation(), diag::err_opencl_private_ptr_kernel_param);
7047 D.setInvalidType();
7048 return;
7049
Matt Arsenaultefb38192013-07-23 01:23:36 +00007050 // OpenCL v1.2 s6.9.k:
7051 // Arguments to kernel functions in a program cannot be declared with the
7052 // built-in scalar types bool, half, size_t, ptrdiff_t, intptr_t, and
7053 // uintptr_t or a struct and/or union that contain fields declared to be
7054 // one of these built-in scalar types.
7055
7056 case InvalidKernelParam:
7057 // OpenCL v1.2 s6.8 n:
7058 // A kernel function argument cannot be declared
7059 // of event_t type.
7060 S.Diag(Param->getLocation(), diag::err_bad_kernel_param_type) << PT;
7061 D.setInvalidType();
7062 return;
7063
7064 case PtrKernelParam:
7065 case ValidKernelParam:
7066 ValidTypes.insert(PT.getTypePtr());
7067 return;
7068
7069 case RecordKernelParam:
7070 break;
7071 }
7072
7073 // Track nested structs we will inspect
7074 SmallVector<const Decl *, 4> VisitStack;
7075
7076 // Track where we are in the nested structs. Items will migrate from
7077 // VisitStack to HistoryStack as we do the DFS for bad field.
7078 SmallVector<const FieldDecl *, 4> HistoryStack;
Craig Topperc3ec1492014-05-26 06:22:03 +00007079 HistoryStack.push_back(nullptr);
Matt Arsenaultefb38192013-07-23 01:23:36 +00007080
7081 const RecordDecl *PD = PT->castAs<RecordType>()->getDecl();
7082 VisitStack.push_back(PD);
7083
7084 assert(VisitStack.back() && "First decl null?");
7085
7086 do {
7087 const Decl *Next = VisitStack.pop_back_val();
7088 if (!Next) {
7089 assert(!HistoryStack.empty());
7090 // Found a marker, we have gone up a level
7091 if (const FieldDecl *Hist = HistoryStack.pop_back_val())
7092 ValidTypes.insert(Hist->getType().getTypePtr());
7093
7094 continue;
7095 }
7096
7097 // Adds everything except the original parameter declaration (which is not a
7098 // field itself) to the history stack.
7099 const RecordDecl *RD;
7100 if (const FieldDecl *Field = dyn_cast<FieldDecl>(Next)) {
7101 HistoryStack.push_back(Field);
7102 RD = Field->getType()->castAs<RecordType>()->getDecl();
7103 } else {
7104 RD = cast<RecordDecl>(Next);
7105 }
7106
7107 // Add a null marker so we know when we've gone back up a level
Craig Topperc3ec1492014-05-26 06:22:03 +00007108 VisitStack.push_back(nullptr);
Matt Arsenaultefb38192013-07-23 01:23:36 +00007109
Aaron Ballmane8a8bae2014-03-08 20:12:42 +00007110 for (const auto *FD : RD->fields()) {
Matt Arsenaultefb38192013-07-23 01:23:36 +00007111 QualType QT = FD->getType();
7112
7113 if (ValidTypes.count(QT.getTypePtr()))
7114 continue;
7115
7116 OpenCLParamType ParamType = getOpenCLKernelParameterType(QT);
7117 if (ParamType == ValidKernelParam)
7118 continue;
7119
7120 if (ParamType == RecordKernelParam) {
7121 VisitStack.push_back(FD);
7122 continue;
7123 }
7124
7125 // OpenCL v1.2 s6.9.p:
7126 // Arguments to kernel functions that are declared to be a struct or union
7127 // do not allow OpenCL objects to be passed as elements of the struct or
7128 // union.
David Tweedababa8f2014-03-27 16:34:11 +00007129 if (ParamType == PtrKernelParam || ParamType == PtrPtrKernelParam ||
7130 ParamType == PrivatePtrKernelParam) {
Matt Arsenaultefb38192013-07-23 01:23:36 +00007131 S.Diag(Param->getLocation(),
7132 diag::err_record_with_pointers_kernel_param)
7133 << PT->isUnionType()
7134 << PT;
7135 } else {
7136 S.Diag(Param->getLocation(), diag::err_bad_kernel_param_type) << PT;
7137 }
7138
7139 S.Diag(PD->getLocation(), diag::note_within_field_of_type)
7140 << PD->getDeclName();
7141
7142 // We have an error, now let's go back up through history and show where
7143 // the offending field came from
Nico Weber6b05f382015-02-18 04:53:03 +00007144 for (ArrayRef<const FieldDecl *>::const_iterator
7145 I = HistoryStack.begin() + 1,
7146 E = HistoryStack.end();
7147 I != E; ++I) {
Matt Arsenaultefb38192013-07-23 01:23:36 +00007148 const FieldDecl *OuterField = *I;
7149 S.Diag(OuterField->getLocation(), diag::note_within_field_of_type)
7150 << OuterField->getType();
7151 }
7152
7153 S.Diag(FD->getLocation(), diag::note_illegal_field_declared_here)
7154 << QT->isPointerType()
7155 << QT;
7156 D.setInvalidType();
7157 return;
7158 }
7159 } while (!VisitStack.empty());
7160}
7161
Mike Stump11289f42009-09-09 15:08:12 +00007162NamedDecl*
Nick Lewycky0bdf13e2011-07-02 02:05:12 +00007163Sema::ActOnFunctionDeclarator(Scope *S, Declarator &D, DeclContext *DC,
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00007164 TypeSourceInfo *TInfo, LookupResult &Previous,
Douglas Gregorb52fabb2009-06-23 23:11:28 +00007165 MultiTemplateParamsArg TemplateParamLists,
Francois Pichet00c7e6c2011-08-14 03:52:19 +00007166 bool &AddToScope) {
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00007167 QualType R = TInfo->getType();
7168
Zhongxing Xubece5d62009-01-16 01:13:29 +00007169 assert(R.getTypePtr()->isFunctionType());
7170
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00007171 // TODO: consider using NameInfo for diagnostic.
7172 DeclarationNameInfo NameInfo = GetNameForDeclarator(D);
7173 DeclarationName Name = NameInfo.getName();
Craig Topperc79e5e32014-10-31 06:57:13 +00007174 StorageClass SC = getFunctionStorageClass(*this, D);
Zhongxing Xubece5d62009-01-16 01:13:29 +00007175
Richard Smithb4a9e862013-04-12 22:46:28 +00007176 if (DeclSpec::TSCS TSCS = D.getDeclSpec().getThreadStorageClassSpec())
7177 Diag(D.getDeclSpec().getThreadStorageClassSpecLoc(),
7178 diag::err_invalid_thread)
7179 << DeclSpec::getSpecifierName(TSCS);
Eli Friedmand5c0eed2009-04-19 20:27:55 +00007180
Reid Kleckner9a7f3e62013-10-08 00:58:57 +00007181 if (D.isFirstDeclarationOfMember())
7182 adjustMemberFunctionCC(R, D.isStaticMember());
Reid Kleckner78af0702013-08-27 23:08:25 +00007183
Douglas Gregor513e63c2010-12-10 19:28:19 +00007184 bool isFriend = false;
Craig Topperc3ec1492014-05-26 06:22:03 +00007185 FunctionTemplateDecl *FunctionTemplate = nullptr;
Douglas Gregor513e63c2010-12-10 19:28:19 +00007186 bool isExplicitSpecialization = false;
7187 bool isFunctionTemplateSpecialization = false;
Nico Weber7b5a7162012-06-25 17:21:05 +00007188
Francois Pichet00c7e6c2011-08-14 03:52:19 +00007189 bool isDependentClassScopeExplicitSpecialization = false;
Nico Weber7b5a7162012-06-25 17:21:05 +00007190 bool HasExplicitTemplateArgs = false;
7191 TemplateArgumentListInfo TemplateArgs;
7192
Kaelyn Uhraine1a9ff72011-10-11 00:28:49 +00007193 bool isVirtualOkay = false;
Abramo Bagnara60804e12011-03-18 15:16:37 +00007194
Richard Smith541b38b2013-09-20 01:15:31 +00007195 DeclContext *OriginalDC = DC;
7196 bool IsLocalExternDecl = adjustContextForLocalExternDecl(DC);
7197
Kaelyn Uhraine1a9ff72011-10-11 00:28:49 +00007198 FunctionDecl *NewFD = CreateNewFunctionDecl(*this, D, DC, R, TInfo, SC,
7199 isVirtualOkay);
Craig Topperc3ec1492014-05-26 06:22:03 +00007200 if (!NewFD) return nullptr;
Kaelyn Uhraine1a9ff72011-10-11 00:28:49 +00007201
Argyrios Kyrtzidis8ad3bab2011-11-23 20:27:36 +00007202 if (OriginalLexicalContext && OriginalLexicalContext->isObjCContainer())
7203 NewFD->setTopLevelDeclInObjCContainer();
7204
Richard Smith541b38b2013-09-20 01:15:31 +00007205 // Set the lexical context. If this is a function-scope declaration, or has a
7206 // C++ scope specifier, or is the object of a friend declaration, the lexical
7207 // context will be different from the semantic context.
7208 NewFD->setLexicalDeclContext(CurContext);
7209
7210 if (IsLocalExternDecl)
7211 NewFD->setLocalExternDecl();
7212
David Blaikiebbafb8a2012-03-11 07:00:24 +00007213 if (getLangOpts().CPlusPlus) {
Kaelyn Uhraine1a9ff72011-10-11 00:28:49 +00007214 bool isInline = D.getDeclSpec().isInlineSpecified();
Douglas Gregor513e63c2010-12-10 19:28:19 +00007215 bool isVirtual = D.getDeclSpec().isVirtualSpecified();
7216 bool isExplicit = D.getDeclSpec().isExplicitSpecified();
Richard Smitha77a0a62011-08-15 21:04:07 +00007217 bool isConstexpr = D.getDeclSpec().isConstexprSpecified();
Hubert Tong27f06972015-07-22 13:32:36 +00007218 bool isConcept = D.getDeclSpec().isConceptSpecified();
Kaelyn Uhraine1a9ff72011-10-11 00:28:49 +00007219 isFriend = D.getDeclSpec().isFriendSpecified();
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00007220 if (isFriend && !isInline && D.isFunctionDefinition()) {
Abramo Bagnaraa3088e62011-03-18 15:21:59 +00007221 // C++ [class.friend]p5
7222 // A function can be defined in a friend declaration of a
7223 // class . . . . Such a function is implicitly inline.
7224 NewFD->setImplicitlyInline();
7225 }
7226
John McCalldb632ac2012-09-25 07:32:39 +00007227 // If this is a method defined in an __interface, and is not a constructor
7228 // or an overloaded operator, then set the pure flag (isVirtual will already
7229 // return true).
7230 if (const CXXRecordDecl *Parent =
7231 dyn_cast<CXXRecordDecl>(NewFD->getDeclContext())) {
7232 if (Parent->isInterface() && cast<CXXMethodDecl>(NewFD)->isUserProvided())
Joao Matosdc86f942012-08-31 18:45:21 +00007233 NewFD->setPure(true);
Davide Italiano43899d42015-06-27 19:18:55 +00007234
7235 // C++ [class.union]p2
7236 // A union can have member functions, but not virtual functions.
7237 if (isVirtual && Parent->isUnion())
7238 Diag(D.getDeclSpec().getVirtualSpecLoc(), diag::err_virtual_in_union);
Joao Matosdc86f942012-08-31 18:45:21 +00007239 }
7240
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00007241 SetNestedNameSpecifier(NewFD, D);
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00007242 isExplicitSpecialization = false;
7243 isFunctionTemplateSpecialization = false;
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00007244 if (D.isInvalidType())
7245 NewFD->setInvalidDecl();
Richard Smith541b38b2013-09-20 01:15:31 +00007246
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00007247 // Match up the template parameter lists with the scope specifier, then
7248 // determine whether we have a template or a template specialization.
7249 bool Invalid = false;
Robert Wilhelmf2d2e8f2013-07-21 15:20:44 +00007250 if (TemplateParameterList *TemplateParams =
7251 MatchTemplateParametersToScopeSpecifier(
7252 D.getDeclSpec().getLocStart(), D.getIdentifierLoc(),
Richard Smith4b55a9c2014-04-17 03:29:33 +00007253 D.getCXXScopeSpec(),
7254 D.getName().getKind() == UnqualifiedId::IK_TemplateId
7255 ? D.getName().TemplateId
Craig Topperc3ec1492014-05-26 06:22:03 +00007256 : nullptr,
Richard Smith4b55a9c2014-04-17 03:29:33 +00007257 TemplateParamLists, isFriend, isExplicitSpecialization,
7258 Invalid)) {
Abramo Bagnara60804e12011-03-18 15:16:37 +00007259 if (TemplateParams->size() > 0) {
7260 // This is a function template
Abramo Bagnarada41d0c2010-06-12 08:15:14 +00007261
Abramo Bagnara60804e12011-03-18 15:16:37 +00007262 // Check that we can declare a template here.
7263 if (CheckTemplateDeclScope(S, TemplateParams))
David Majnemer8e1a9132015-01-15 07:04:38 +00007264 NewFD->setInvalidDecl();
Mike Stump11289f42009-09-09 15:08:12 +00007265
Abramo Bagnara60804e12011-03-18 15:16:37 +00007266 // A destructor cannot be a template.
7267 if (Name.getNameKind() == DeclarationName::CXXDestructorName) {
7268 Diag(NewFD->getLocation(), diag::err_destructor_template);
David Majnemer8e1a9132015-01-15 07:04:38 +00007269 NewFD->setInvalidDecl();
John McCall1f0479e2010-03-24 08:27:58 +00007270 }
Douglas Gregor041b0842011-10-14 15:31:12 +00007271
7272 // If we're adding a template to a dependent context, we may need to
David Blaikie30d15442011-10-19 22:56:21 +00007273 // rebuilding some of the types used within the template parameter list,
Douglas Gregor041b0842011-10-14 15:31:12 +00007274 // now that we know what the current instantiation is.
7275 if (DC->isDependentContext()) {
7276 ContextRAII SavedContext(*this, DC);
7277 if (RebuildTemplateParamsInCurrentInstantiation(TemplateParams))
7278 Invalid = true;
7279 }
7280
John McCall1f0479e2010-03-24 08:27:58 +00007281
Abramo Bagnara60804e12011-03-18 15:16:37 +00007282 FunctionTemplate = FunctionTemplateDecl::Create(Context, DC,
7283 NewFD->getLocation(),
7284 Name, TemplateParams,
7285 NewFD);
7286 FunctionTemplate->setLexicalDeclContext(CurContext);
7287 NewFD->setDescribedFunctionTemplate(FunctionTemplate);
7288
7289 // For source fidelity, store the other template param lists.
7290 if (TemplateParamLists.size() > 1) {
7291 NewFD->setTemplateParameterListsInfo(Context,
7292 TemplateParamLists.size() - 1,
Benjamin Kramercc4c49d2012-08-23 23:38:35 +00007293 TemplateParamLists.data());
Abramo Bagnara60804e12011-03-18 15:16:37 +00007294 }
7295 } else {
7296 // This is a function template specialization.
7297 isFunctionTemplateSpecialization = true;
7298 // For source fidelity, store all the template param lists.
Richard Smith4b55a9c2014-04-17 03:29:33 +00007299 if (TemplateParamLists.size() > 0)
7300 NewFD->setTemplateParameterListsInfo(Context,
7301 TemplateParamLists.size(),
7302 TemplateParamLists.data());
Abramo Bagnara60804e12011-03-18 15:16:37 +00007303
7304 // C++0x [temp.expl.spec]p20 forbids "template<> friend void foo(int);".
7305 if (isFriend) {
7306 // We want to remove the "template<>", found here.
7307 SourceRange RemoveRange = TemplateParams->getSourceRange();
7308
7309 // If we remove the template<> and the name is not a
7310 // template-id, we're actually silently creating a problem:
7311 // the friend declaration will refer to an untemplated decl,
7312 // and clearly the user wants a template specialization. So
7313 // we need to insert '<>' after the name.
7314 SourceLocation InsertLoc;
7315 if (D.getName().getKind() != UnqualifiedId::IK_TemplateId) {
7316 InsertLoc = D.getName().getSourceRange().getEnd();
Alp Tokerb6cc5922014-05-03 03:45:55 +00007317 InsertLoc = getLocForEndOfToken(InsertLoc);
Abramo Bagnara60804e12011-03-18 15:16:37 +00007318 }
7319
7320 Diag(D.getIdentifierLoc(), diag::err_template_spec_decl_friend)
7321 << Name << RemoveRange
7322 << FixItHint::CreateRemoval(RemoveRange)
7323 << FixItHint::CreateInsertion(InsertLoc, "<>");
7324 }
7325 }
7326 }
7327 else {
7328 // All template param lists were matched against the scope specifier:
7329 // this is NOT (an explicit specialization of) a template.
7330 if (TemplateParamLists.size() > 0)
7331 // For source fidelity, store all the template param lists.
7332 NewFD->setTemplateParameterListsInfo(Context,
7333 TemplateParamLists.size(),
Benjamin Kramercc4c49d2012-08-23 23:38:35 +00007334 TemplateParamLists.data());
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00007335 }
7336
7337 if (Invalid) {
7338 NewFD->setInvalidDecl();
7339 if (FunctionTemplate)
7340 FunctionTemplate->setInvalidDecl();
7341 }
Kaelyn Uhraine1a9ff72011-10-11 00:28:49 +00007342
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00007343 // C++ [dcl.fct.spec]p5:
7344 // The virtual specifier shall only be used in declarations of
7345 // nonstatic class member functions that appear within a
7346 // member-specification of a class declaration; see 10.3.
7347 //
7348 if (isVirtual && !NewFD->isInvalidDecl()) {
7349 if (!isVirtualOkay) {
7350 Diag(D.getDeclSpec().getVirtualSpecLoc(),
7351 diag::err_virtual_non_function);
7352 } else if (!CurContext->isRecord()) {
7353 // 'virtual' was specified outside of the class.
Anders Carlssone9738992011-01-22 14:43:56 +00007354 Diag(D.getDeclSpec().getVirtualSpecLoc(),
7355 diag::err_virtual_out_of_class)
7356 << FixItHint::CreateRemoval(D.getDeclSpec().getVirtualSpecLoc());
7357 } else if (NewFD->getDescribedFunctionTemplate()) {
7358 // C++ [temp.mem]p3:
7359 // A member function template shall not be virtual.
7360 Diag(D.getDeclSpec().getVirtualSpecLoc(),
7361 diag::err_virtual_member_function_template)
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00007362 << FixItHint::CreateRemoval(D.getDeclSpec().getVirtualSpecLoc());
7363 } else {
7364 // Okay: Add virtual to the method.
7365 NewFD->setVirtualAsWritten(true);
John McCall816d75b2010-03-24 07:46:06 +00007366 }
Richard Smith2a7d4812013-05-04 07:00:32 +00007367
Aaron Ballmandd69ef32014-08-19 15:55:55 +00007368 if (getLangOpts().CPlusPlus14 &&
Alp Toker314cc812014-01-25 16:55:45 +00007369 NewFD->getReturnType()->isUndeducedType())
Richard Smith2a7d4812013-05-04 07:00:32 +00007370 Diag(D.getDeclSpec().getVirtualSpecLoc(), diag::err_auto_fn_virtual);
Douglas Gregorc1da0f02009-06-24 00:23:40 +00007371 }
Abramo Bagnarada41d0c2010-06-12 08:15:14 +00007372
Aaron Ballmandd69ef32014-08-19 15:55:55 +00007373 if (getLangOpts().CPlusPlus14 &&
Richard Smithc1564702013-11-15 02:58:23 +00007374 (NewFD->isDependentContext() ||
7375 (isFriend && CurContext->isDependentContext())) &&
Alp Toker314cc812014-01-25 16:55:45 +00007376 NewFD->getReturnType()->isUndeducedType()) {
Richard Smithc58f38f2013-08-14 20:16:31 +00007377 // If the function template is referenced directly (for instance, as a
7378 // member of the current instantiation), pretend it has a dependent type.
7379 // This is not really justified by the standard, but is the only sane
7380 // thing to do.
Richard Smithc1564702013-11-15 02:58:23 +00007381 // FIXME: For a friend function, we have not marked the function as being
7382 // a friend yet, so 'isDependentContext' on the FD doesn't work.
Richard Smithc58f38f2013-08-14 20:16:31 +00007383 const FunctionProtoType *FPT =
7384 NewFD->getType()->castAs<FunctionProtoType>();
Alp Toker314cc812014-01-25 16:55:45 +00007385 QualType Result =
7386 SubstAutoType(FPT->getReturnType(), Context.DependentTy);
Alp Toker9cacbab2014-01-20 20:26:09 +00007387 NewFD->setType(Context.getFunctionType(Result, FPT->getParamTypes(),
Richard Smithc58f38f2013-08-14 20:16:31 +00007388 FPT->getExtProtoInfo()));
7389 }
7390
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00007391 // C++ [dcl.fct.spec]p3:
David Blaikie30d15442011-10-19 22:56:21 +00007392 // The inline specifier shall not appear on a block scope function
7393 // declaration.
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00007394 if (isInline && !NewFD->isInvalidDecl()) {
7395 if (CurContext->isFunctionOrMethod()) {
7396 // 'inline' is not allowed on block scope function declaration.
7397 Diag(D.getDeclSpec().getInlineSpecLoc(),
7398 diag::err_inline_declaration_block_scope) << Name
7399 << FixItHint::CreateRemoval(D.getDeclSpec().getInlineSpecLoc());
7400 }
7401 }
Kaelyn Uhraine1a9ff72011-10-11 00:28:49 +00007402
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00007403 // C++ [dcl.fct.spec]p6:
7404 // The explicit specifier shall be used only in the declaration of a
David Blaikie30d15442011-10-19 22:56:21 +00007405 // constructor or conversion function within its class definition;
7406 // see 12.3.1 and 12.3.2.
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00007407 if (isExplicit && !NewFD->isInvalidDecl()) {
7408 if (!CurContext->isRecord()) {
7409 // 'explicit' was specified outside of the class.
7410 Diag(D.getDeclSpec().getExplicitSpecLoc(),
7411 diag::err_explicit_out_of_class)
7412 << FixItHint::CreateRemoval(D.getDeclSpec().getExplicitSpecLoc());
7413 } else if (!isa<CXXConstructorDecl>(NewFD) &&
7414 !isa<CXXConversionDecl>(NewFD)) {
7415 // 'explicit' was specified on a function that wasn't a constructor
7416 // or conversion function.
7417 Diag(D.getDeclSpec().getExplicitSpecLoc(),
7418 diag::err_explicit_non_ctor_or_conv_function)
7419 << FixItHint::CreateRemoval(D.getDeclSpec().getExplicitSpecLoc());
7420 }
7421 }
Abramo Bagnarada41d0c2010-06-12 08:15:14 +00007422
Richard Smitha77a0a62011-08-15 21:04:07 +00007423 if (isConstexpr) {
Richard Smith574f4f62013-01-14 05:37:29 +00007424 // C++11 [dcl.constexpr]p2: constexpr functions and constexpr constructors
Richard Smitha77a0a62011-08-15 21:04:07 +00007425 // are implicitly inline.
7426 NewFD->setImplicitlyInline();
7427
Richard Smith574f4f62013-01-14 05:37:29 +00007428 // C++11 [dcl.constexpr]p3: functions declared constexpr are required to
Richard Smitha77a0a62011-08-15 21:04:07 +00007429 // be either constructors or to return a literal type. Therefore,
7430 // destructors cannot be declared constexpr.
7431 if (isa<CXXDestructorDecl>(NewFD))
Richard Smitheb3c10c2011-10-01 02:31:28 +00007432 Diag(D.getDeclSpec().getConstexprSpecLoc(), diag::err_constexpr_dtor);
Richard Smitha77a0a62011-08-15 21:04:07 +00007433 }
7434
Hubert Tong27f06972015-07-22 13:32:36 +00007435 if (isConcept) {
7436 // C++ Concepts TS [dcl.spec.concept]p1: The concept specifier shall be
7437 // applied only to the definition of a function template...
7438 if (!D.isFunctionDefinition()) {
7439 Diag(D.getDeclSpec().getConceptSpecLoc(),
7440 diag::err_function_concept_not_defined);
7441 NewFD->setInvalidDecl();
7442 }
7443
7444 // C++ Concepts TS [dcl.spec.concept]p2: Every concept definition is
7445 // implicity defined to be a constexpr declaration (implicitly inline)
7446 NewFD->setImplicitlyInline();
7447 }
7448
Douglas Gregor26701a42011-09-09 02:06:17 +00007449 // If __module_private__ was specified, mark the function accordingly.
7450 if (D.getDeclSpec().isModulePrivateSpecified()) {
Douglas Gregor3c7cd6a2011-09-09 20:53:38 +00007451 if (isFunctionTemplateSpecialization) {
7452 SourceLocation ModulePrivateLoc
7453 = D.getDeclSpec().getModulePrivateSpecLoc();
7454 Diag(ModulePrivateLoc, diag::err_module_private_specialization)
7455 << 0
7456 << FixItHint::CreateRemoval(ModulePrivateLoc);
7457 } else {
7458 NewFD->setModulePrivate();
7459 if (FunctionTemplate)
7460 FunctionTemplate->setModulePrivate();
7461 }
Douglas Gregor26701a42011-09-09 02:06:17 +00007462 }
Richard Smitha77a0a62011-08-15 21:04:07 +00007463
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00007464 if (isFriend) {
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00007465 if (FunctionTemplate) {
Richard Smith64017682013-07-17 23:53:16 +00007466 FunctionTemplate->setObjectOfFriendDecl();
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00007467 FunctionTemplate->setAccess(AS_public);
7468 }
Richard Smith64017682013-07-17 23:53:16 +00007469 NewFD->setObjectOfFriendDecl();
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00007470 NewFD->setAccess(AS_public);
7471 }
7472
Douglas Gregor5d1b4e32011-11-07 20:56:01 +00007473 // If a function is defined as defaulted or deleted, mark it as such now.
Richard Smithb63b6ee2014-01-22 01:43:19 +00007474 // FIXME: Does this ever happen? ActOnStartOfFunctionDef forces the function
7475 // definition kind to FDK_Definition.
Douglas Gregor5d1b4e32011-11-07 20:56:01 +00007476 switch (D.getFunctionDefinitionKind()) {
7477 case FDK_Declaration:
7478 case FDK_Definition:
7479 break;
7480
7481 case FDK_Defaulted:
7482 NewFD->setDefaulted();
7483 break;
7484
7485 case FDK_Deleted:
7486 NewFD->setDeletedAsWritten();
7487 break;
7488 }
7489
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00007490 if (isa<CXXMethodDecl>(NewFD) && DC == CurContext &&
7491 D.isFunctionDefinition()) {
Douglas Gregor5d1b4e32011-11-07 20:56:01 +00007492 // C++ [class.mfct]p2:
7493 // A member function may be defined (8.4) in its class definition, in
7494 // which case it is an inline member function (7.1.2)
John McCall357d0f32010-12-15 04:00:32 +00007495 NewFD->setImplicitlyInline();
7496 }
7497
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00007498 if (SC == SC_Static && isa<CXXMethodDecl>(NewFD) &&
7499 !CurContext->isRecord()) {
7500 // C++ [class.static]p1:
7501 // A data or function member of a class may be declared static
7502 // in a class definition, in which case it is a static member of
7503 // the class.
7504
7505 // Complain about the 'static' specifier if it's on an out-of-line
7506 // member function definition.
7507 Diag(D.getDeclSpec().getStorageClassSpecLoc(),
7508 diag::err_static_out_of_line)
7509 << FixItHint::CreateRemoval(D.getDeclSpec().getStorageClassSpecLoc());
7510 }
Richard Smith66f3ac92012-10-20 08:26:51 +00007511
7512 // C++11 [except.spec]p15:
7513 // A deallocation function with no exception-specification is treated
7514 // as if it were specified with noexcept(true).
7515 const FunctionProtoType *FPT = R->getAs<FunctionProtoType>();
7516 if ((Name.getCXXOverloadedOperator() == OO_Delete ||
7517 Name.getCXXOverloadedOperator() == OO_Array_Delete) &&
Richard Smith8acb4282014-07-31 21:57:55 +00007518 getLangOpts().CPlusPlus11 && FPT && !FPT->hasExceptionSpec())
7519 NewFD->setType(Context.getFunctionType(
7520 FPT->getReturnType(), FPT->getParamTypes(),
7521 FPT->getExtProtoInfo().withExceptionSpec(EST_BasicNoexcept)));
Douglas Gregor5f0e2522010-07-14 23:14:12 +00007522 }
Kaelyn Uhraine1a9ff72011-10-11 00:28:49 +00007523
7524 // Filter out previous declarations that don't match the scope.
Richard Smith541b38b2013-09-20 01:15:31 +00007525 FilterLookupForScope(Previous, OriginalDC, S, shouldConsiderLinkage(NewFD),
Richard Smith72bcaec2013-12-05 04:30:04 +00007526 D.getCXXScopeSpec().isNotEmpty() ||
Kaelyn Uhraine1a9ff72011-10-11 00:28:49 +00007527 isExplicitSpecialization ||
7528 isFunctionTemplateSpecialization);
Richard Smith1c34fb72013-08-13 18:18:50 +00007529
Zhongxing Xubece5d62009-01-16 01:13:29 +00007530 // Handle GNU asm-label extension (encoded as an attribute).
7531 if (Expr *E = (Expr*) D.getAsmLabel()) {
7532 // The parser guarantees this is a string.
Mike Stump11289f42009-09-09 15:08:12 +00007533 StringLiteral *SE = cast<StringLiteral>(E);
Alexis Huntdcfba7b2010-08-18 23:23:40 +00007534 NewFD->addAttr(::new (Context) AsmLabelAttr(SE->getStrTokenLoc(0), Context,
Aaron Ballman36a53502014-01-16 13:03:14 +00007535 SE->getString(), 0));
Aaron Ballman7572e582015-07-16 17:06:53 +00007536 } else if (!ExtnameUndeclaredIdentifiers.empty()) {
David Chisnall0867d9c2012-02-18 16:12:34 +00007537 llvm::DenseMap<IdentifierInfo*,AsmLabelAttr*>::iterator I =
7538 ExtnameUndeclaredIdentifiers.find(NewFD->getIdentifier());
7539 if (I != ExtnameUndeclaredIdentifiers.end()) {
Aaron Ballman7572e582015-07-16 17:06:53 +00007540 if (isDeclExternC(NewFD)) {
7541 NewFD->addAttr(I->second);
7542 ExtnameUndeclaredIdentifiers.erase(I);
7543 } else
7544 Diag(NewFD->getLocation(), diag::warn_redefine_extname_not_applied)
7545 << /*Variable*/0 << NewFD;
David Chisnall0867d9c2012-02-18 16:12:34 +00007546 }
Zhongxing Xubece5d62009-01-16 01:13:29 +00007547 }
7548
Chris Lattner9af40c12009-04-25 06:12:16 +00007549 // Copy the parameter declarations from the declarator D to the function
7550 // declaration NewFD, if they are available. First scavenge them into Params.
Chris Lattner0e62c1c2011-07-23 10:55:15 +00007551 SmallVector<ParmVarDecl*, 16> Params;
Abramo Bagnara6d810632010-12-14 22:11:44 +00007552 if (D.isFunctionDeclarator()) {
Abramo Bagnara924a8f32010-12-10 16:29:40 +00007553 DeclaratorChunk::FunctionTypeInfo &FTI = D.getFunctionTypeInfo();
Zhongxing Xubece5d62009-01-16 01:13:29 +00007554
Zhongxing Xubece5d62009-01-16 01:13:29 +00007555 // Check for C99 6.7.5.3p10 - foo(void) is a non-varargs
7556 // function that takes no arguments, not a function that takes a
7557 // single void argument.
7558 // We let through "const void" here because Sema::GetTypeForDeclarator
7559 // already checks for that case.
Alp Toker4284c6e2014-05-11 16:05:55 +00007560 if (FTIHasNonVoidParameters(FTI) && FTI.Params[0].Param) {
Alp Tokerc5350722014-02-26 22:27:52 +00007561 for (unsigned i = 0, e = FTI.NumParams; i != e; ++i) {
7562 ParmVarDecl *Param = cast<ParmVarDecl>(FTI.Params[i].Param);
Argyrios Kyrtzidis11a846a2009-07-14 03:18:53 +00007563 assert(Param->getDeclContext() != NewFD && "Was set before ?");
7564 Param->setDeclContext(NewFD);
7565 Params.push_back(Param);
John McCallb7238602010-04-14 01:27:20 +00007566
7567 if (Param->isInvalidDecl())
7568 NewFD->setInvalidDecl();
Argyrios Kyrtzidis11a846a2009-07-14 03:18:53 +00007569 }
Zhongxing Xubece5d62009-01-16 01:13:29 +00007570 }
Mike Stump11289f42009-09-09 15:08:12 +00007571
John McCall9dd450b2009-09-21 23:43:11 +00007572 } else if (const FunctionProtoType *FT = R->getAs<FunctionProtoType>()) {
Chris Lattner47c0d002009-04-25 06:03:53 +00007573 // When we're declaring a function with a typedef, typeof, etc as in the
Zhongxing Xubece5d62009-01-16 01:13:29 +00007574 // following example, we'll need to synthesize (unnamed)
7575 // parameters for use in the declaration.
7576 //
7577 // @code
7578 // typedef void fn(int);
7579 // fn f;
7580 // @endcode
Mike Stump11289f42009-09-09 15:08:12 +00007581
Chris Lattner47c0d002009-04-25 06:03:53 +00007582 // Synthesize a parameter for each argument type.
Aaron Ballman40bd0aa2014-03-17 15:23:01 +00007583 for (const auto &AI : FT->param_types()) {
John McCalla3ccba02010-06-04 11:21:44 +00007584 ParmVarDecl *Param =
Aaron Ballman40bd0aa2014-03-17 15:23:01 +00007585 BuildParmVarDeclForTypedef(NewFD, D.getIdentifierLoc(), AI);
John McCall8fb0d9d2011-05-01 22:35:37 +00007586 Param->setScopeInfo(0, Params.size());
Chris Lattner47c0d002009-04-25 06:03:53 +00007587 Params.push_back(Param);
Zhongxing Xubece5d62009-01-16 01:13:29 +00007588 }
Chris Lattner49303b22009-04-25 18:38:18 +00007589 } else {
7590 assert(R->isFunctionNoProtoType() && NewFD->getNumParams() == 0 &&
7591 "Should not need args for typedef of non-prototype fn");
Zhongxing Xubece5d62009-01-16 01:13:29 +00007592 }
Anton Korobeynikovf0c267e2011-10-14 23:23:15 +00007593
Chris Lattner9af40c12009-04-25 06:12:16 +00007594 // Finally, we know we have the right number of parameters, install them.
David Blaikie9c70e042011-09-21 18:16:56 +00007595 NewFD->setParams(Params);
Mike Stump11289f42009-09-09 15:08:12 +00007596
James Molloy6f8780b2012-02-29 10:24:19 +00007597 // Find all anonymous symbols defined during the declaration of this function
7598 // and add to NewFD. This lets us track decls such 'enum Y' in:
7599 //
7600 // void f(enum Y {AA} x) {}
7601 //
7602 // which would otherwise incorrectly end up in the translation unit scope.
7603 NewFD->setDeclsInPrototypeScope(DeclsInPrototypeScope);
7604 DeclsInPrototypeScope.clear();
7605
Richard Smithdebc59d2013-01-30 05:45:05 +00007606 if (D.getDeclSpec().isNoreturnSpecified())
7607 NewFD->addAttr(
7608 ::new(Context) C11NoReturnAttr(D.getDeclSpec().getNoreturnSpecLoc(),
Aaron Ballman36a53502014-01-16 13:03:14 +00007609 Context, 0));
Richard Smithdebc59d2013-01-30 05:45:05 +00007610
Richard Smith84208dc2012-03-13 05:56:40 +00007611 // Functions returning a variably modified type violate C99 6.7.5.2p2
7612 // because all functions have linkage.
7613 if (!NewFD->isInvalidDecl() &&
Alp Toker314cc812014-01-25 16:55:45 +00007614 NewFD->getReturnType()->isVariablyModifiedType()) {
Richard Smith84208dc2012-03-13 05:56:40 +00007615 Diag(NewFD->getLocation(), diag::err_vm_func_decl);
7616 NewFD->setInvalidDecl();
7617 }
7618
Reid Kleckner2a133222015-03-04 23:39:17 +00007619 // Apply an implicit SectionAttr if #pragma code_seg is active.
7620 if (CodeSegStack.CurrentValue && D.isFunctionDefinition() &&
Warren Huntc3b18962014-04-08 22:30:47 +00007621 !NewFD->hasAttr<SectionAttr>()) {
7622 NewFD->addAttr(
7623 SectionAttr::CreateImplicit(Context, SectionAttr::Declspec_allocate,
7624 CodeSegStack.CurrentValue->getString(),
7625 CodeSegStack.CurrentPragmaLocation));
7626 if (UnifySection(CodeSegStack.CurrentValue->getString(),
Hans Wennborg899ded92014-10-16 20:52:46 +00007627 ASTContext::PSF_Implicit | ASTContext::PSF_Execute |
7628 ASTContext::PSF_Read,
7629 NewFD))
Warren Huntc3b18962014-04-08 22:30:47 +00007630 NewFD->dropAttr<SectionAttr>();
7631 }
7632
Rafael Espindolac67f2232012-05-10 02:50:16 +00007633 // Handle attributes.
Richard Smithf8a75c32013-08-29 00:47:48 +00007634 ProcessDeclAttributes(S, NewFD, D);
Rafael Espindolac67f2232012-05-10 02:50:16 +00007635
Joey Gouly16cb99d2014-01-06 11:26:18 +00007636 if (getLangOpts().OpenCL) {
7637 // OpenCL v1.1 s6.5: Using an address space qualifier in a function return
7638 // type declaration will generate a compilation error.
Kaelyn Takata0a2e84c2015-04-09 19:43:04 +00007639 unsigned AddressSpace = NewFD->getReturnType().getAddressSpace();
Joey Gouly16cb99d2014-01-06 11:26:18 +00007640 if (AddressSpace == LangAS::opencl_local ||
7641 AddressSpace == LangAS::opencl_global ||
7642 AddressSpace == LangAS::opencl_constant) {
7643 Diag(NewFD->getLocation(),
7644 diag::err_opencl_return_value_with_address_space);
7645 NewFD->setInvalidDecl();
7646 }
7647 }
7648
David Blaikiebbafb8a2012-03-11 07:00:24 +00007649 if (!getLangOpts().CPlusPlus) {
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00007650 // Perform semantic checking on the function declaration.
Douglas Gregor522d5eb2011-06-06 15:22:55 +00007651 bool isExplicitSpecialization=false;
David Majnemer027f9c42013-07-06 02:13:46 +00007652 if (!NewFD->isInvalidDecl() && NewFD->isMain())
7653 CheckMain(NewFD, D.getDeclSpec());
7654
David Majnemerc729b0b2013-09-16 22:44:20 +00007655 if (!NewFD->isInvalidDecl() && NewFD->isMSVCRTEntryPoint())
7656 CheckMSVCRTEntryPoint(NewFD);
7657
Reid Kleckner899baf32014-11-03 21:56:03 +00007658 if (!NewFD->isInvalidDecl())
7659 D.setRedeclaration(CheckFunctionDeclaration(S, NewFD, Previous,
7660 isExplicitSpecialization));
7661 else if (!Previous.empty())
Nico Weber4486d612015-02-18 05:19:40 +00007662 // Recover gracefully from an invalid redeclaration.
Reid Kleckner899baf32014-11-03 21:56:03 +00007663 D.setRedeclaration(true);
7664 assert((NewFD->isInvalidDecl() || !D.isRedeclaration() ||
7665 Previous.getResultKind() != LookupResult::FoundOverloaded) &&
7666 "previous declaration set still overloaded");
7667
Reid Kleckner1eaa8442014-11-03 21:24:50 +00007668 // Diagnose no-prototype function declarations with calling conventions that
Reid Kleckner899baf32014-11-03 21:56:03 +00007669 // don't support variadic calls. Only do this in C and do it after merging
7670 // possibly prototyped redeclarations.
7671 const FunctionType *FT = NewFD->getType()->castAs<FunctionType>();
7672 if (isa<FunctionNoProtoType>(FT) && !D.isFunctionDefinition()) {
Reid Kleckner1eaa8442014-11-03 21:24:50 +00007673 CallingConv CC = FT->getExtInfo().getCC();
7674 if (!supportsVariadicCall(CC)) {
7675 // Windows system headers sometimes accidentally use stdcall without
7676 // (void) parameters, so we relax this to a warning.
7677 int DiagID =
7678 CC == CC_X86StdCall ? diag::warn_cconv_knr : diag::err_cconv_knr;
7679 Diag(NewFD->getLocation(), DiagID)
7680 << FunctionType::getNameForCallConv(CC);
7681 }
7682 }
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00007683 } else {
Richard Smithfa27bc42013-11-16 01:57:09 +00007684 // C++11 [replacement.functions]p3:
7685 // The program's definitions shall not be specified as inline.
7686 //
7687 // N.B. We diagnose declarations instead of definitions per LWG issue 2340.
7688 //
7689 // Suppress the diagnostic if the function is __attribute__((used)), since
7690 // that forces an external definition to be emitted.
7691 if (D.getDeclSpec().isInlineSpecified() &&
7692 NewFD->isReplaceableGlobalAllocationFunction() &&
7693 !NewFD->hasAttr<UsedAttr>())
7694 Diag(D.getDeclSpec().getInlineSpecLoc(),
7695 diag::ext_operator_new_delete_declared_inline)
7696 << NewFD->getDeclName();
7697
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00007698 // If the declarator is a template-id, translate the parser's template
7699 // argument list into our AST format.
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00007700 if (D.getName().getKind() == UnqualifiedId::IK_TemplateId) {
7701 TemplateIdAnnotation *TemplateId = D.getName().TemplateId;
7702 TemplateArgs.setLAngleLoc(TemplateId->LAngleLoc);
7703 TemplateArgs.setRAngleLoc(TemplateId->RAngleLoc);
Benjamin Kramercc4c49d2012-08-23 23:38:35 +00007704 ASTTemplateArgsPtr TemplateArgsPtr(TemplateId->getTemplateArgs(),
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00007705 TemplateId->NumArgs);
7706 translateTemplateArguments(TemplateArgsPtr,
7707 TemplateArgs);
Douglas Gregor0e876e02009-09-25 23:53:26 +00007708
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00007709 HasExplicitTemplateArgs = true;
Douglas Gregor0e876e02009-09-25 23:53:26 +00007710
Douglas Gregor522d5eb2011-06-06 15:22:55 +00007711 if (NewFD->isInvalidDecl()) {
7712 HasExplicitTemplateArgs = false;
7713 } else if (FunctionTemplate) {
Douglas Gregora5f6f9c2011-01-24 18:54:39 +00007714 // Function template with explicit template arguments.
7715 Diag(D.getIdentifierLoc(), diag::err_function_template_partial_spec)
7716 << SourceRange(TemplateId->LAngleLoc, TemplateId->RAngleLoc);
7717
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00007718 HasExplicitTemplateArgs = false;
John McCallf7cfb222010-10-13 05:45:15 +00007719 } else {
Richard Smith4b55a9c2014-04-17 03:29:33 +00007720 assert((isFunctionTemplateSpecialization ||
7721 D.getDeclSpec().isFriendSpecified()) &&
7722 "should have a 'template<>' for this decl");
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00007723 // "friend void foo<>(int);" is an implicit specialization decl.
7724 isFunctionTemplateSpecialization = true;
Francois Pichet6d76e6c2010-10-01 21:19:28 +00007725 }
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00007726 } else if (isFriend && isFunctionTemplateSpecialization) {
7727 // This combination is only possible in a recovery case; the user
7728 // wrote something like:
7729 // template <> friend void foo(int);
7730 // which we're recovering from as if the user had written:
7731 // friend void foo<>(int);
7732 // Go ahead and fake up a template id.
7733 HasExplicitTemplateArgs = true;
Richard Smith4b55a9c2014-04-17 03:29:33 +00007734 TemplateArgs.setLAngleLoc(D.getIdentifierLoc());
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00007735 TemplateArgs.setRAngleLoc(D.getIdentifierLoc());
Douglas Gregorf4f296d2009-03-23 23:06:20 +00007736 }
John McCallf7cfb222010-10-13 05:45:15 +00007737
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00007738 // If it's a friend (and only if it's a friend), it's possible
7739 // that either the specialized function type or the specialized
7740 // template is dependent, and therefore matching will fail. In
7741 // this case, don't check the specialization yet.
Douglas Gregore9d075e2011-10-09 20:59:17 +00007742 bool InstantiationDependent = false;
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00007743 if (isFunctionTemplateSpecialization && isFriend &&
Douglas Gregore9d075e2011-10-09 20:59:17 +00007744 (NewFD->getType()->isDependentType() || DC->isDependentContext() ||
7745 TemplateSpecializationType::anyDependentTemplateArguments(
7746 TemplateArgs.getArgumentArray(), TemplateArgs.size(),
7747 InstantiationDependent))) {
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00007748 assert(HasExplicitTemplateArgs &&
7749 "friend function specialization without template args");
7750 if (CheckDependentFunctionTemplateSpecialization(NewFD, TemplateArgs,
7751 Previous))
7752 NewFD->setInvalidDecl();
7753 } else if (isFunctionTemplateSpecialization) {
Douglas Gregor63fab342011-03-16 19:27:09 +00007754 if (CurContext->isDependentContext() && CurContext->isRecord()
Francois Pichetb5037052011-06-03 13:59:45 +00007755 && !isFriend) {
David Majnemeraa30dd72015-01-09 07:36:13 +00007756 isDependentClassScopeExplicitSpecialization = true;
David Blaikiebbafb8a2012-03-11 07:00:24 +00007757 Diag(NewFD->getLocation(), getLangOpts().MicrosoftExt ?
Francois Pichet00c7e6c2011-08-14 03:52:19 +00007758 diag::ext_function_specialization_in_class :
7759 diag::err_function_specialization_in_class)
Douglas Gregor63fab342011-03-16 19:27:09 +00007760 << NewFD->getDeclName();
Douglas Gregor63fab342011-03-16 19:27:09 +00007761 } else if (CheckFunctionTemplateSpecialization(NewFD,
Craig Topperc3ec1492014-05-26 06:22:03 +00007762 (HasExplicitTemplateArgs ? &TemplateArgs
7763 : nullptr),
Douglas Gregor63fab342011-03-16 19:27:09 +00007764 Previous))
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00007765 NewFD->setInvalidDecl();
Douglas Gregor781ba6e2011-05-21 18:53:30 +00007766
7767 // C++ [dcl.stc]p1:
7768 // A storage-class-specifier shall not be specified in an explicit
7769 // specialization (14.7.3)
Richard Trieub48e62f2013-05-16 02:14:08 +00007770 FunctionTemplateSpecializationInfo *Info =
7771 NewFD->getTemplateSpecializationInfo();
7772 if (Info && SC != SC_None) {
7773 if (SC != Info->getTemplate()->getTemplatedDecl()->getStorageClass())
Douglas Gregor84265a02011-06-17 05:09:08 +00007774 Diag(NewFD->getLocation(),
7775 diag::err_explicit_specialization_inconsistent_storage_class)
7776 << SC
7777 << FixItHint::CreateRemoval(
7778 D.getDeclSpec().getStorageClassSpecLoc());
7779
7780 else
7781 Diag(NewFD->getLocation(),
7782 diag::ext_explicit_specialization_storage_class)
7783 << FixItHint::CreateRemoval(
7784 D.getDeclSpec().getStorageClassSpecLoc());
Douglas Gregor781ba6e2011-05-21 18:53:30 +00007785 }
7786
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00007787 } else if (isExplicitSpecialization && isa<CXXMethodDecl>(NewFD)) {
7788 if (CheckMemberSpecialization(NewFD, Previous))
7789 NewFD->setInvalidDecl();
7790 }
Douglas Gregorf4f296d2009-03-23 23:06:20 +00007791
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00007792 // Perform semantic checking on the function declaration.
David Blaikied937bf12011-09-08 06:33:04 +00007793 if (!isDependentClassScopeExplicitSpecialization) {
David Majnemer027f9c42013-07-06 02:13:46 +00007794 if (!NewFD->isInvalidDecl() && NewFD->isMain())
7795 CheckMain(NewFD, D.getDeclSpec());
7796
David Majnemerc729b0b2013-09-16 22:44:20 +00007797 if (!NewFD->isInvalidDecl() && NewFD->isMSVCRTEntryPoint())
7798 CheckMSVCRTEntryPoint(NewFD);
7799
Nico Weber7607fce2013-12-21 00:49:51 +00007800 if (!NewFD->isInvalidDecl())
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00007801 D.setRedeclaration(CheckFunctionDeclaration(S, NewFD, Previous,
7802 isExplicitSpecialization));
Nico Weber4486d612015-02-18 05:19:40 +00007803 else if (!Previous.empty())
7804 // Recover gracefully from an invalid redeclaration.
7805 D.setRedeclaration(true);
David Blaikied937bf12011-09-08 06:33:04 +00007806 }
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00007807
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00007808 assert((NewFD->isInvalidDecl() || !D.isRedeclaration() ||
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00007809 Previous.getResultKind() != LookupResult::FoundOverloaded) &&
7810 "previous declaration set still overloaded");
7811
7812 NamedDecl *PrincipalDecl = (FunctionTemplate
7813 ? cast<NamedDecl>(FunctionTemplate)
7814 : NewFD);
7815
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00007816 if (isFriend && D.isRedeclaration()) {
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00007817 AccessSpecifier Access = AS_public;
7818 if (!NewFD->isInvalidDecl())
Douglas Gregorec9fd132012-01-14 16:38:05 +00007819 Access = NewFD->getPreviousDecl()->getAccess();
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00007820
7821 NewFD->setAccess(Access);
7822 if (FunctionTemplate) FunctionTemplate->setAccess(Access);
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00007823 }
7824
7825 if (NewFD->isOverloadedOperator() && !DC->isRecord() &&
7826 PrincipalDecl->isInIdentifierNamespace(Decl::IDNS_Ordinary))
7827 PrincipalDecl->setNonMemberOperator();
7828
7829 // If we have a function template, check the template parameter
7830 // list. This will check and merge default template arguments.
7831 if (FunctionTemplate) {
David Blaikie30d15442011-10-19 22:56:21 +00007832 FunctionTemplateDecl *PrevTemplate =
Douglas Gregorec9fd132012-01-14 16:38:05 +00007833 FunctionTemplate->getPreviousDecl();
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00007834 CheckTemplateParameterList(FunctionTemplate->getTemplateParameters(),
Craig Topperc3ec1492014-05-26 06:22:03 +00007835 PrevTemplate ? PrevTemplate->getTemplateParameters()
7836 : nullptr,
Douglas Gregora99fb4c2011-02-04 04:20:44 +00007837 D.getDeclSpec().isFriendSpecified()
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00007838 ? (D.isFunctionDefinition()
Douglas Gregora99fb4c2011-02-04 04:20:44 +00007839 ? TPC_FriendFunctionTemplateDefinition
7840 : TPC_FriendFunctionTemplate)
7841 : (D.getCXXScopeSpec().isSet() &&
Douglas Gregor4d5c2972011-02-04 12:22:53 +00007842 DC && DC->isRecord() &&
7843 DC->isDependentContext())
Douglas Gregora99fb4c2011-02-04 04:20:44 +00007844 ? TPC_ClassTemplateMember
7845 : TPC_FunctionTemplate);
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00007846 }
7847
7848 if (NewFD->isInvalidDecl()) {
7849 // Ignore all the rest of this.
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00007850 } else if (!D.isRedeclaration()) {
Kaelyn Uhrain8af2c9f2011-10-11 00:28:52 +00007851 struct ActOnFDArgs ExtraArgs = { S, D, TemplateParamLists,
Kaelyn Uhrain0a32fca2011-10-11 00:28:39 +00007852 AddToScope };
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00007853 // Fake up an access specifier if it's supposed to be a class member.
7854 if (isa<CXXRecordDecl>(NewFD->getDeclContext()))
7855 NewFD->setAccess(AS_public);
7856
7857 // Qualified decls generally require a previous declaration.
7858 if (D.getCXXScopeSpec().isSet()) {
7859 // ...with the major exception of templated-scope or
7860 // dependent-scope friend declarations.
7861
7862 // TODO: we currently also suppress this check in dependent
7863 // contexts because (1) the parameter depth will be off when
7864 // matching friend templates and (2) we might actually be
7865 // selecting a friend based on a dependent factor. But there
7866 // are situations where these conditions don't apply and we
7867 // can actually do this check immediately.
7868 if (isFriend &&
Abramo Bagnara60804e12011-03-18 15:16:37 +00007869 (TemplateParamLists.size() ||
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00007870 D.getCXXScopeSpec().getScopeRep()->isDependent() ||
7871 CurContext->isDependentContext())) {
Chandler Carruthf8b554f2011-08-19 01:38:33 +00007872 // ignore these
7873 } else {
7874 // The user tried to provide an out-of-line definition for a
7875 // function that is a member of a class or namespace, but there
7876 // was no such member function declared (C++ [class.mfct]p2,
7877 // C++ [namespace.memdef]p2). For example:
7878 //
7879 // class X {
7880 // void f() const;
7881 // };
7882 //
7883 // void X::f() { } // ill-formed
7884 //
7885 // Complain about this problem, and attempt to suggest close
7886 // matches (e.g., those that differ only in cv-qualifiers and
7887 // whether the parameter types are references).
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00007888
Richard Smith114394f2013-08-09 04:35:01 +00007889 if (NamedDecl *Result = DiagnoseInvalidRedeclaration(
Craig Topperc3ec1492014-05-26 06:22:03 +00007890 *this, Previous, NewFD, ExtraArgs, false, nullptr)) {
Kaelyn Uhrain0a32fca2011-10-11 00:28:39 +00007891 AddToScope = ExtraArgs.AddToScope;
7892 return Result;
7893 }
Chandler Carruthf8b554f2011-08-19 01:38:33 +00007894 }
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00007895
7896 // Unqualified local friend declarations are required to resolve
7897 // to something.
Chandler Carruthe92e42f2011-08-19 01:40:11 +00007898 } else if (isFriend && cast<CXXRecordDecl>(CurContext)->isLocalClass()) {
Richard Smith114394f2013-08-09 04:35:01 +00007899 if (NamedDecl *Result = DiagnoseInvalidRedeclaration(
7900 *this, Previous, NewFD, ExtraArgs, true, S)) {
Kaelyn Uhrain0a32fca2011-10-11 00:28:39 +00007901 AddToScope = ExtraArgs.AddToScope;
7902 return Result;
7903 }
Chandler Carruthe92e42f2011-08-19 01:40:11 +00007904 }
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00007905
Richard Smitha2302242013-12-05 07:51:02 +00007906 } else if (!D.isFunctionDefinition() &&
7907 isa<CXXMethodDecl>(NewFD) && NewFD->isOutOfLine() &&
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00007908 !isFriend && !isFunctionTemplateSpecialization &&
Alexis Hunt5a7fa252011-05-12 06:15:49 +00007909 !isExplicitSpecialization) {
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00007910 // An out-of-line member function declaration must also be a
Richard Smitha2302242013-12-05 07:51:02 +00007911 // definition (C++ [class.mfct]p2).
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00007912 // Note that this is not the case for explicit specializations of
7913 // function templates or member functions of class templates, per
David Blaikie30d15442011-10-19 22:56:21 +00007914 // C++ [temp.expl.spec]p2. We also allow these declarations as an
7915 // extension for compatibility with old SWIG code which likes to
7916 // generate them.
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00007917 Diag(NewFD->getLocation(), diag::ext_out_of_line_declaration)
7918 << D.getCXXScopeSpec().getRange();
7919 }
7920 }
Ryan Flynne5dc8592009-07-25 22:29:44 +00007921
Rafael Espindolade6a39f2013-03-02 21:41:48 +00007922 ProcessPragmaWeak(S, NewFD);
Rafael Espindolaf1d2f0e2013-01-16 23:11:15 +00007923 checkAttributesAfterMerging(*this, *NewFD);
7924
Douglas Gregorf4f296d2009-03-23 23:06:20 +00007925 AddKnownFunctionAttributes(NewFD);
7926
Douglas Gregor72609052010-08-06 13:50:58 +00007927 if (NewFD->hasAttr<OverloadableAttr>() &&
7928 !NewFD->getType()->getAs<FunctionProtoType>()) {
7929 Diag(NewFD->getLocation(),
7930 diag::err_attribute_overloadable_no_prototype)
7931 << NewFD;
7932
7933 // Turn this into a variadic function with no parameters.
7934 const FunctionType *FT = NewFD->getType()->getAs<FunctionType>();
Reid Kleckner78af0702013-08-27 23:08:25 +00007935 FunctionProtoType::ExtProtoInfo EPI(
7936 Context.getDefaultCallingConvention(true, false));
John McCalldb40c7f2010-12-14 08:05:40 +00007937 EPI.Variadic = true;
7938 EPI.ExtInfo = FT->getExtInfo();
7939
Alp Toker314cc812014-01-25 16:55:45 +00007940 QualType R = Context.getFunctionType(FT->getReturnType(), None, EPI);
Douglas Gregor72609052010-08-06 13:50:58 +00007941 NewFD->setType(R);
7942 }
7943
Eli Friedman570024a2010-08-05 06:57:20 +00007944 // If there's a #pragma GCC visibility in scope, and this isn't a class
7945 // member, set the visibility of this function.
Rafael Espindola3ae00052013-05-13 00:12:11 +00007946 if (!DC->isRecord() && NewFD->isExternallyVisible())
Eli Friedman570024a2010-08-05 06:57:20 +00007947 AddPushedVisibilityAttribute(NewFD);
7948
John McCall32f5fe12011-09-30 05:12:12 +00007949 // If there's a #pragma clang arc_cf_code_audited in scope, consider
7950 // marking the function.
7951 AddCFAuditedAttribute(NewFD);
7952
Dario Domizioli13a0a382014-05-23 12:13:25 +00007953 // If this is a function definition, check if we have to apply optnone due to
7954 // a pragma.
7955 if(D.isFunctionDefinition())
7956 AddRangeBasedOptnone(NewFD);
7957
Richard Smithac974a32013-06-30 09:48:50 +00007958 // If this is the first declaration of an extern C variable, update
7959 // the map of such variables.
Rafael Espindola3f9e4442013-10-19 02:13:21 +00007960 if (NewFD->isFirstDecl() && !NewFD->isInvalidDecl() &&
Richard Smithac974a32013-06-30 09:48:50 +00007961 isIncompleteDeclExternC(*this, NewFD))
Richard Smith39b79682013-06-18 20:15:12 +00007962 RegisterLocallyScopedExternCDecl(NewFD, S);
Douglas Gregorf4f296d2009-03-23 23:06:20 +00007963
Argyrios Kyrtzidis16eecc42009-06-25 18:22:24 +00007964 // Set this FunctionDecl's range up to the right paren.
Abramo Bagnaraea947882011-03-08 16:41:52 +00007965 NewFD->setRangeEnd(D.getSourceRange().getEnd());
Argyrios Kyrtzidis16eecc42009-06-25 18:22:24 +00007966
Nico Rieck82f0b062014-03-31 14:56:15 +00007967 if (D.isRedeclaration() && !Previous.empty()) {
7968 checkDLLAttributeRedeclaration(
7969 *this, dyn_cast<NamedDecl>(Previous.getRepresentativeDecl()), NewFD,
7970 isExplicitSpecialization || isFunctionTemplateSpecialization);
7971 }
7972
David Blaikiebbafb8a2012-03-11 07:00:24 +00007973 if (getLangOpts().CPlusPlus) {
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00007974 if (FunctionTemplate) {
7975 if (NewFD->isInvalidDecl())
7976 FunctionTemplate->setInvalidDecl();
7977 return FunctionTemplate;
7978 }
Fariborz Jahanian31d6d842010-12-09 23:11:32 +00007979 }
Mike Stump11289f42009-09-09 15:08:12 +00007980
Guy Benyei1b4fb3e2013-01-20 12:31:11 +00007981 if (NewFD->hasAttr<OpenCLKernelAttr>()) {
Guy Benyei1b4fb3e2013-01-20 12:31:11 +00007982 // OpenCL v1.2 s6.8 static is invalid for kernel functions.
7983 if ((getLangOpts().OpenCLVersion >= 120)
7984 && (SC == SC_Static)) {
7985 Diag(D.getIdentifierLoc(), diag::err_static_kernel);
7986 D.setInvalidType();
7987 }
Tanya Lattner0f864332013-01-30 19:48:52 +00007988
7989 // OpenCL v1.2, s6.9 -- Kernels can only have return type void.
Alp Toker314cc812014-01-25 16:55:45 +00007990 if (!NewFD->getReturnType()->isVoidType()) {
Alp Tokerd0787eb2014-07-02 01:47:15 +00007991 SourceRange RTRange = NewFD->getReturnTypeSourceRange();
7992 Diag(D.getIdentifierLoc(), diag::err_expected_kernel_void_return_type)
7993 << (RTRange.isValid() ? FixItHint::CreateReplacement(RTRange, "void")
7994 : FixItHint());
Tanya Lattner0f864332013-01-30 19:48:52 +00007995 D.setInvalidType();
7996 }
Matt Arsenaultefb38192013-07-23 01:23:36 +00007997
7998 llvm::SmallPtrSet<const Type *, 16> ValidTypes;
Aaron Ballmanf6bf62e2014-03-07 15:12:56 +00007999 for (auto Param : NewFD->params())
Matt Arsenaultefb38192013-07-23 01:23:36 +00008000 checkIsValidOpenCLKernelParameter(*this, D, Param, ValidTypes);
Tanya Lattner4fdce3f2012-06-19 23:09:52 +00008001 }
8002
Argyrios Kyrtzidis1b30d9c2010-08-15 01:15:20 +00008003 MarkUnusedFileScopedDecl(NewFD);
Peter Collingbourne9e2c81f2011-02-09 21:04:32 +00008004
David Blaikiebbafb8a2012-03-11 07:00:24 +00008005 if (getLangOpts().CUDA)
Peter Collingbourne9e2c81f2011-02-09 21:04:32 +00008006 if (IdentifierInfo *II = NewFD->getIdentifier())
8007 if (!NewFD->isInvalidDecl() &&
8008 NewFD->getDeclContext()->getRedeclContext()->isTranslationUnit()) {
8009 if (II->isStr("cudaConfigureCall")) {
Alp Toker314cc812014-01-25 16:55:45 +00008010 if (!R->getAs<FunctionType>()->getReturnType()->isScalarType())
Peter Collingbourne9e2c81f2011-02-09 21:04:32 +00008011 Diag(NewFD->getLocation(), diag::err_config_scalar_return);
8012
8013 Context.setcudaConfigureCallDecl(NewFD);
8014 }
8015 }
Francois Pichet00c7e6c2011-08-14 03:52:19 +00008016
8017 // Here we have an function template explicit specialization at class scope.
8018 // The actually specialization will be postponed to template instatiation
8019 // time via the ClassScopeFunctionSpecializationDecl node.
8020 if (isDependentClassScopeExplicitSpecialization) {
8021 ClassScopeFunctionSpecializationDecl *NewSpec =
8022 ClassScopeFunctionSpecializationDecl::Create(
Nico Weber7b5a7162012-06-25 17:21:05 +00008023 Context, CurContext, SourceLocation(),
8024 cast<CXXMethodDecl>(NewFD),
8025 HasExplicitTemplateArgs, TemplateArgs);
Francois Pichet00c7e6c2011-08-14 03:52:19 +00008026 CurContext->addDecl(NewSpec);
8027 AddToScope = false;
8028 }
Peter Collingbourne9e2c81f2011-02-09 21:04:32 +00008029
Douglas Gregorf4f296d2009-03-23 23:06:20 +00008030 return NewFD;
8031}
8032
8033/// \brief Perform semantic checking of a new function declaration.
8034///
8035/// Performs semantic analysis of the new function declaration
8036/// NewFD. This routine performs all semantic checking that does not
8037/// require the actual declarator involved in the declaration, and is
8038/// used both for the declaration of functions as they are parsed
8039/// (called via ActOnDeclarator) and for the declaration of functions
8040/// that have been instantiated via C++ template instantiation (called
8041/// via InstantiateDecl).
8042///
James Dennettffad8b72012-06-22 08:10:18 +00008043/// \param IsExplicitSpecialization whether this new function declaration is
Douglas Gregorcf915552009-10-13 16:30:37 +00008044/// an explicit specialization of the previous declaration.
8045///
Chris Lattnerf6d1c9c2009-04-25 08:06:05 +00008046/// This sets NewFD->isInvalidDecl() to true if there was an error.
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00008047///
James Dennettffad8b72012-06-22 08:10:18 +00008048/// \returns true if the function declaration is a redeclaration.
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00008049bool Sema::CheckFunctionDeclaration(Scope *S, FunctionDecl *NewFD,
John McCall1f82f242009-11-18 22:49:29 +00008050 LookupResult &Previous,
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00008051 bool IsExplicitSpecialization) {
Alp Toker314cc812014-01-25 16:55:45 +00008052 assert(!NewFD->getReturnType()->isVariablyModifiedType() &&
8053 "Variably modified return types are not handled here");
John McCalld9baf6a2009-07-24 03:03:21 +00008054
Richard Smith1c34fb72013-08-13 18:18:50 +00008055 // Determine whether the type of this function should be merged with
8056 // a previous visible declaration. This never happens for functions in C++,
8057 // and always happens in C if the previous declaration was visible.
8058 bool MergeTypeWithPrevious = !getLangOpts().CPlusPlus &&
8059 !Previous.isShadowed();
8060
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00008061 bool Redeclaration = false;
Craig Topperc3ec1492014-05-26 06:22:03 +00008062 NamedDecl *OldDecl = nullptr;
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00008063
Douglas Gregore62c0a42009-02-24 01:23:02 +00008064 // Merge or overload the declaration with an existing declaration of
8065 // the same name, if appropriate.
John McCall1f82f242009-11-18 22:49:29 +00008066 if (!Previous.empty()) {
Douglas Gregor4e5cbdc2009-02-11 23:02:49 +00008067 // Determine whether NewFD is an overload of PrevDecl or
Zhongxing Xubece5d62009-01-16 01:13:29 +00008068 // a declaration that requires merging. If it's an overload,
8069 // there's no more work to do here; we'll just add the new
8070 // function to the scope.
John McCalldaa3d6b2009-12-09 03:35:25 +00008071 if (!AllowOverloadingOfFunction(Previous, Context)) {
Rafael Espindola5bddd6a2013-04-15 12:49:13 +00008072 NamedDecl *Candidate = Previous.getFoundDecl();
8073 if (shouldLinkPossiblyHiddenDecl(Candidate, NewFD)) {
8074 Redeclaration = true;
8075 OldDecl = Candidate;
8076 }
John McCalldaa3d6b2009-12-09 03:35:25 +00008077 } else {
John McCalle9cccd82010-06-16 08:42:20 +00008078 switch (CheckOverload(S, NewFD, Previous, OldDecl,
8079 /*NewIsUsingDecl*/ false)) {
John McCalldaa3d6b2009-12-09 03:35:25 +00008080 case Ovl_Match:
John McCall84d87672009-12-10 09:41:52 +00008081 Redeclaration = true;
John McCalldaa3d6b2009-12-09 03:35:25 +00008082 break;
8083
8084 case Ovl_NonFunction:
8085 Redeclaration = true;
8086 break;
8087
8088 case Ovl_Overload:
8089 Redeclaration = false;
8090 break;
John McCall1f82f242009-11-18 22:49:29 +00008091 }
Peter Collingbourne9f2a9902011-01-21 02:08:54 +00008092
David Blaikiebbafb8a2012-03-11 07:00:24 +00008093 if (!getLangOpts().CPlusPlus && !NewFD->hasAttr<OverloadableAttr>()) {
Peter Collingbourne9f2a9902011-01-21 02:08:54 +00008094 // If a function name is overloadable in C, then every function
8095 // with that name must be marked "overloadable".
8096 Diag(NewFD->getLocation(), diag::err_attribute_overloadable_missing)
8097 << Redeclaration << NewFD;
Craig Topperc3ec1492014-05-26 06:22:03 +00008098 NamedDecl *OverloadedDecl = nullptr;
Peter Collingbourne9f2a9902011-01-21 02:08:54 +00008099 if (Redeclaration)
8100 OverloadedDecl = OldDecl;
8101 else if (!Previous.empty())
8102 OverloadedDecl = Previous.getRepresentativeDecl();
8103 if (OverloadedDecl)
8104 Diag(OverloadedDecl->getLocation(),
8105 diag::note_attribute_overloadable_prev_overload);
Aaron Ballman36a53502014-01-16 13:03:14 +00008106 NewFD->addAttr(OverloadableAttr::CreateImplicit(Context));
Peter Collingbourne9f2a9902011-01-21 02:08:54 +00008107 }
John McCall1f82f242009-11-18 22:49:29 +00008108 }
Richard Smith574f4f62013-01-14 05:37:29 +00008109 }
Zhongxing Xubece5d62009-01-16 01:13:29 +00008110
Richard Smithac974a32013-06-30 09:48:50 +00008111 // Check for a previous extern "C" declaration with this name.
8112 if (!Redeclaration &&
8113 checkForConflictWithNonVisibleExternC(*this, NewFD, Previous)) {
Richard Smithac974a32013-06-30 09:48:50 +00008114 if (!Previous.empty()) {
8115 // This is an extern "C" declaration with the same name as a previous
8116 // declaration, and thus redeclares that entity...
8117 Redeclaration = true;
8118 OldDecl = Previous.getFoundDecl();
Richard Smith1c34fb72013-08-13 18:18:50 +00008119 MergeTypeWithPrevious = false;
Richard Smithac974a32013-06-30 09:48:50 +00008120
8121 // ... except in the presence of __attribute__((overloadable)).
8122 if (OldDecl->hasAttr<OverloadableAttr>()) {
8123 if (!getLangOpts().CPlusPlus && !NewFD->hasAttr<OverloadableAttr>()) {
8124 Diag(NewFD->getLocation(), diag::err_attribute_overloadable_missing)
8125 << Redeclaration << NewFD;
8126 Diag(Previous.getFoundDecl()->getLocation(),
8127 diag::note_attribute_overloadable_prev_overload);
Aaron Ballman36a53502014-01-16 13:03:14 +00008128 NewFD->addAttr(OverloadableAttr::CreateImplicit(Context));
Richard Smithac974a32013-06-30 09:48:50 +00008129 }
8130 if (IsOverload(NewFD, cast<FunctionDecl>(OldDecl), false)) {
8131 Redeclaration = false;
Craig Topperc3ec1492014-05-26 06:22:03 +00008132 OldDecl = nullptr;
Richard Smithac974a32013-06-30 09:48:50 +00008133 }
8134 }
8135 }
8136 }
8137
Richard Smith574f4f62013-01-14 05:37:29 +00008138 // C++11 [dcl.constexpr]p8:
8139 // A constexpr specifier for a non-static member function that is not
8140 // a constructor declares that member function to be const.
8141 //
8142 // This needs to be delayed until we know whether this is an out-of-line
8143 // definition of a static member function.
Richard Smith034185c2013-04-21 01:08:50 +00008144 //
8145 // This rule is not present in C++1y, so we produce a backwards
8146 // compatibility warning whenever it happens in C++11.
Richard Smith574f4f62013-01-14 05:37:29 +00008147 CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(NewFD);
Aaron Ballmandd69ef32014-08-19 15:55:55 +00008148 if (!getLangOpts().CPlusPlus14 && MD && MD->isConstexpr() &&
Richard Smith034185c2013-04-21 01:08:50 +00008149 !MD->isStatic() && !isa<CXXConstructorDecl>(MD) &&
Richard Smith574f4f62013-01-14 05:37:29 +00008150 (MD->getTypeQualifiers() & Qualifiers::Const) == 0) {
Craig Topperc3ec1492014-05-26 06:22:03 +00008151 CXXMethodDecl *OldMD = nullptr;
Alp Tokera2794f92014-01-22 07:29:52 +00008152 if (OldDecl)
David Majnemer0fe3f4d2015-01-09 10:33:23 +00008153 OldMD = dyn_cast_or_null<CXXMethodDecl>(OldDecl->getAsFunction());
Richard Smith574f4f62013-01-14 05:37:29 +00008154 if (!OldMD || !OldMD->isStatic()) {
8155 const FunctionProtoType *FPT =
8156 MD->getType()->castAs<FunctionProtoType>();
8157 FunctionProtoType::ExtProtoInfo EPI = FPT->getExtProtoInfo();
8158 EPI.TypeQuals |= Qualifiers::Const;
Alp Toker314cc812014-01-25 16:55:45 +00008159 MD->setType(Context.getFunctionType(FPT->getReturnType(),
Alp Toker9cacbab2014-01-20 20:26:09 +00008160 FPT->getParamTypes(), EPI));
Richard Smith034185c2013-04-21 01:08:50 +00008161
8162 // Warn that we did this, if we're not performing template instantiation.
8163 // In that case, we'll have warned already when the template was defined.
8164 if (ActiveTemplateInstantiations.empty()) {
8165 SourceLocation AddConstLoc;
8166 if (FunctionTypeLoc FTL = MD->getTypeSourceInfo()->getTypeLoc()
8167 .IgnoreParens().getAs<FunctionTypeLoc>())
Alp Tokerb6cc5922014-05-03 03:45:55 +00008168 AddConstLoc = getLocForEndOfToken(FTL.getRParenLoc());
Richard Smith034185c2013-04-21 01:08:50 +00008169
Aaron Ballmandd69ef32014-08-19 15:55:55 +00008170 Diag(MD->getLocation(), diag::warn_cxx14_compat_constexpr_not_const)
Richard Smith034185c2013-04-21 01:08:50 +00008171 << FixItHint::CreateInsertion(AddConstLoc, " const");
8172 }
Richard Smith574f4f62013-01-14 05:37:29 +00008173 }
8174 }
8175
8176 if (Redeclaration) {
8177 // NewFD and OldDecl represent declarations that need to be
8178 // merged.
Richard Smith1c34fb72013-08-13 18:18:50 +00008179 if (MergeFunctionDecl(NewFD, OldDecl, S, MergeTypeWithPrevious)) {
Richard Smith574f4f62013-01-14 05:37:29 +00008180 NewFD->setInvalidDecl();
8181 return Redeclaration;
8182 }
8183
8184 Previous.clear();
8185 Previous.addDecl(OldDecl);
8186
8187 if (FunctionTemplateDecl *OldTemplateDecl
8188 = dyn_cast<FunctionTemplateDecl>(OldDecl)) {
8189 NewFD->setPreviousDeclaration(OldTemplateDecl->getTemplatedDecl());
8190 FunctionTemplateDecl *NewTemplateDecl
8191 = NewFD->getDescribedFunctionTemplate();
8192 assert(NewTemplateDecl && "Template/non-template mismatch");
8193 if (CXXMethodDecl *Method
8194 = dyn_cast<CXXMethodDecl>(NewTemplateDecl->getTemplatedDecl())) {
8195 Method->setAccess(OldTemplateDecl->getAccess());
8196 NewTemplateDecl->setAccess(OldTemplateDecl->getAccess());
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00008197 }
Richard Smith574f4f62013-01-14 05:37:29 +00008198
8199 // If this is an explicit specialization of a member that is a function
8200 // template, mark it as a member specialization.
8201 if (IsExplicitSpecialization &&
8202 NewTemplateDecl->getInstantiatedFromMemberTemplate()) {
8203 NewTemplateDecl->setMemberSpecialization();
8204 assert(OldTemplateDecl->isMemberSpecialization());
Argyrios Kyrtzidis11a846a2009-07-14 03:18:53 +00008205 }
Richard Smith574f4f62013-01-14 05:37:29 +00008206
8207 } else {
John McCall6bd2a892013-01-25 22:31:03 +00008208 // This needs to happen first so that 'inline' propagates.
Richard Smith574f4f62013-01-14 05:37:29 +00008209 NewFD->setPreviousDeclaration(cast<FunctionDecl>(OldDecl));
John McCall6bd2a892013-01-25 22:31:03 +00008210
Richard Smith91c18de2015-02-28 01:01:56 +00008211 if (isa<CXXMethodDecl>(NewFD))
8212 NewFD->setAccess(OldDecl->getAccess());
Zhongxing Xubece5d62009-01-16 01:13:29 +00008213 }
Douglas Gregor8af63e42009-02-06 17:46:57 +00008214 }
Zhongxing Xubece5d62009-01-16 01:13:29 +00008215
Anders Carlsson1b12ed42009-09-13 21:33:06 +00008216 // Semantic checking for this function declaration (in isolation).
Nico Weberbe39a872014-07-31 17:19:18 +00008217
David Blaikiebbafb8a2012-03-11 07:00:24 +00008218 if (getLangOpts().CPlusPlus) {
Anders Carlsson1b12ed42009-09-13 21:33:06 +00008219 // C++-specific checks.
8220 if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(NewFD)) {
8221 CheckConstructor(Constructor);
Anders Carlsson2a50e952009-11-15 22:49:34 +00008222 } else if (CXXDestructorDecl *Destructor =
8223 dyn_cast<CXXDestructorDecl>(NewFD)) {
8224 CXXRecordDecl *Record = Destructor->getParent();
Anders Carlsson1b12ed42009-09-13 21:33:06 +00008225 QualType ClassType = Context.getTypeDeclType(Record);
Anders Carlsson2a50e952009-11-15 22:49:34 +00008226
Douglas Gregor7454c562010-07-02 20:37:36 +00008227 // FIXME: Shouldn't we be able to perform this check even when the class
Anders Carlsson2a50e952009-11-15 22:49:34 +00008228 // type is dependent? Both gcc and edg can handle that.
Anders Carlsson1b12ed42009-09-13 21:33:06 +00008229 if (!ClassType->isDependentType()) {
8230 DeclarationName Name
8231 = Context.DeclarationNames.getCXXDestructorName(
8232 Context.getCanonicalType(ClassType));
8233 if (NewFD->getDeclName() != Name) {
8234 Diag(NewFD->getLocation(), diag::err_destructor_name);
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00008235 NewFD->setInvalidDecl();
8236 return Redeclaration;
Anders Carlsson1b12ed42009-09-13 21:33:06 +00008237 }
8238 }
Anders Carlsson1b12ed42009-09-13 21:33:06 +00008239 } else if (CXXConversionDecl *Conversion
Douglas Gregor21920e372009-12-01 17:24:26 +00008240 = dyn_cast<CXXConversionDecl>(NewFD)) {
Anders Carlsson1b12ed42009-09-13 21:33:06 +00008241 ActOnConversionDeclarator(Conversion);
Douglas Gregor21920e372009-12-01 17:24:26 +00008242 }
8243
8244 // Find any virtual functions that this function overrides.
Douglas Gregor6be3de32009-12-01 17:35:23 +00008245 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(NewFD)) {
8246 if (!Method->isFunctionTemplateSpecialization() &&
Argyrios Kyrtzidiscc4ca0a2012-10-09 01:23:45 +00008247 !Method->getDescribedFunctionTemplate() &&
8248 Method->isCanonicalDecl()) {
Douglas Gregor5a2bb5b2010-10-13 22:55:32 +00008249 if (AddOverriddenMethods(Method->getParent(), Method)) {
8250 // If the function was marked as "static", we have a problem.
8251 if (NewFD->getStorageClass() == SC_Static) {
David Blaikie7e414262012-10-17 00:47:58 +00008252 ReportOverrides(*this, diag::err_static_overrides_virtual, Method);
Douglas Gregor5a2bb5b2010-10-13 22:55:32 +00008253 }
Argyrios Kyrtzidis7272d9c2011-02-03 18:01:15 +00008254 }
Douglas Gregor5a2bb5b2010-10-13 22:55:32 +00008255 }
Douglas Gregor3024f072012-04-16 07:05:22 +00008256
8257 if (Method->isStatic())
8258 checkThisInStaticMemberFunctionType(Method);
Douglas Gregor6be3de32009-12-01 17:35:23 +00008259 }
Anders Carlsson1b12ed42009-09-13 21:33:06 +00008260
8261 // Extra checking for C++ overloaded operators (C++ [over.oper]).
8262 if (NewFD->isOverloadedOperator() &&
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00008263 CheckOverloadedOperatorDeclaration(NewFD)) {
8264 NewFD->setInvalidDecl();
8265 return Redeclaration;
8266 }
Alexis Huntc88db062010-01-13 09:01:02 +00008267
8268 // Extra checking for C++0x literal operators (C++0x [over.literal]).
8269 if (NewFD->getLiteralIdentifier() &&
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00008270 CheckLiteralOperatorDeclaration(NewFD)) {
8271 NewFD->setInvalidDecl();
8272 return Redeclaration;
8273 }
Alexis Huntc88db062010-01-13 09:01:02 +00008274
Anders Carlsson1b12ed42009-09-13 21:33:06 +00008275 // In C++, check default arguments now that we have merged decls. Unless
8276 // the lexical context is the class, because in this case this is done
8277 // during delayed parsing anyway.
8278 if (!CurContext->isRecord())
8279 CheckCXXDefaultArguments(NewFD);
Warren Hunt445d83e2013-11-01 23:46:51 +00008280
Douglas Gregor9246b682010-12-21 19:47:46 +00008281 // If this function declares a builtin function, check the type of this
8282 // declaration against the expected type for the builtin.
8283 if (unsigned BuiltinID = NewFD->getBuiltinID()) {
8284 ASTContext::GetBuiltinTypeError Error;
Fariborz Jahanianfeb9ae52013-01-05 21:54:55 +00008285 LookupPredefedObjCSuperType(*this, S, NewFD->getIdentifier());
Douglas Gregor9246b682010-12-21 19:47:46 +00008286 QualType T = Context.GetBuiltinType(BuiltinID, Error);
8287 if (!T.isNull() && !Context.hasSameType(T, NewFD->getType())) {
8288 // The type of this function differs from the type of the builtin,
8289 // so forget about the builtin entirely.
8290 Context.BuiltinInfo.ForgetBuiltin(BuiltinID, Context.Idents);
8291 }
8292 }
Warren Hunt445d83e2013-11-01 23:46:51 +00008293
Aaron Ballmanc2a9493a2012-02-09 01:21:34 +00008294 // If this function is declared as being extern "C", then check to see if
8295 // the function returns a UDT (class, struct, or union type) that is not C
8296 // compatible, and if it does, warn the user.
Fariborz Jahanian95236b52013-03-14 23:09:00 +00008297 // But, issue any diagnostic on the first declaration only.
David Majnemerd1091e52015-01-14 08:08:52 +00008298 if (Previous.empty() && NewFD->isExternC()) {
Alp Toker314cc812014-01-25 16:55:45 +00008299 QualType R = NewFD->getReturnType();
Hans Wennborg84ce6062012-07-24 17:59:41 +00008300 if (R->isIncompleteType() && !R->isVoidType())
8301 Diag(NewFD->getLocation(), diag::warn_return_value_udt_incomplete)
8302 << NewFD << R;
Douglas Gregor847cea72012-08-07 06:14:34 +00008303 else if (!R.isPODType(Context) && !R->isVoidType() &&
8304 !R->isObjCObjectPointerType())
Hans Wennborg84ce6062012-07-24 17:59:41 +00008305 Diag(NewFD->getLocation(), diag::warn_return_value_udt) << NewFD << R;
Aaron Ballmanc2a9493a2012-02-09 01:21:34 +00008306 }
Anders Carlsson1b12ed42009-09-13 21:33:06 +00008307 }
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00008308 return Redeclaration;
Zhongxing Xubece5d62009-01-16 01:13:29 +00008309}
8310
David Blaikied937bf12011-09-08 06:33:04 +00008311void Sema::CheckMain(FunctionDecl* FD, const DeclSpec& DS) {
Richard Smithb63b6ee2014-01-22 01:43:19 +00008312 // C++11 [basic.start.main]p3:
8313 // A program that [...] declares main to be inline, static or
8314 // constexpr is ill-formed.
Richard Smith0015f092013-01-17 22:16:11 +00008315 // C11 6.7.4p4: In a hosted environment, no function specifier(s) shall
8316 // appear in a declaration of main.
John McCall02dee0a2009-07-25 04:36:53 +00008317 // static main is not an error under C99, but we should warn about it.
Richard Smith0015f092013-01-17 22:16:11 +00008318 // We accept _Noreturn main as an extension.
David Blaikied937bf12011-09-08 06:33:04 +00008319 if (FD->getStorageClass() == SC_Static)
David Blaikiebbafb8a2012-03-11 07:00:24 +00008320 Diag(DS.getStorageClassSpecLoc(), getLangOpts().CPlusPlus
David Blaikied937bf12011-09-08 06:33:04 +00008321 ? diag::err_static_main : diag::warn_static_main)
8322 << FixItHint::CreateRemoval(DS.getStorageClassSpecLoc());
8323 if (FD->isInlineSpecified())
8324 Diag(DS.getInlineSpecLoc(), diag::err_inline_main)
8325 << FixItHint::CreateRemoval(DS.getInlineSpecLoc());
Dmitri Gribenko7ec6f3d2013-01-21 11:25:03 +00008326 if (DS.isNoreturnSpecified()) {
8327 SourceLocation NoreturnLoc = DS.getNoreturnSpecLoc();
Alp Tokerb6cc5922014-05-03 03:45:55 +00008328 SourceRange NoreturnRange(NoreturnLoc, getLocForEndOfToken(NoreturnLoc));
Dmitri Gribenko7ec6f3d2013-01-21 11:25:03 +00008329 Diag(NoreturnLoc, diag::ext_noreturn_main);
8330 Diag(NoreturnLoc, diag::note_main_remove_noreturn)
8331 << FixItHint::CreateRemoval(NoreturnRange);
8332 }
Richard Smith3f333f22012-02-04 06:10:17 +00008333 if (FD->isConstexpr()) {
8334 Diag(DS.getConstexprSpecLoc(), diag::err_constexpr_main)
8335 << FixItHint::CreateRemoval(DS.getConstexprSpecLoc());
8336 FD->setConstexpr(false);
8337 }
John McCall02dee0a2009-07-25 04:36:53 +00008338
Joey Goulya7310a82013-11-05 12:30:39 +00008339 if (getLangOpts().OpenCL) {
8340 Diag(FD->getLocation(), diag::err_opencl_no_main)
8341 << FD->hasAttr<OpenCLKernelAttr>();
8342 FD->setInvalidDecl();
8343 return;
8344 }
8345
John McCall02dee0a2009-07-25 04:36:53 +00008346 QualType T = FD->getType();
8347 assert(T->isFunctionType() && "function decl is not of function type");
John McCall5ed3caf2012-02-14 19:50:52 +00008348 const FunctionType* FT = T->castAs<FunctionType>();
Mike Stump11289f42009-09-09 15:08:12 +00008349
Alp Toker70fc29c2014-07-02 07:07:20 +00008350 if (getLangOpts().GNUMode && !getLangOpts().CPlusPlus) {
8351 // In C with GNU extensions we allow main() to have non-integer return
8352 // type, but we should warn about the extension, and we disable the
8353 // implicit-return-zero rule.
8354
8355 // GCC in C mode accepts qualified 'int'.
8356 if (Context.hasSameUnqualifiedType(FT->getReturnType(), Context.IntTy))
8357 FD->setHasImplicitReturnZero(true);
8358 else {
8359 Diag(FD->getTypeSpecStartLoc(), diag::ext_main_returns_nonint);
8360 SourceRange RTRange = FD->getReturnTypeSourceRange();
8361 if (RTRange.isValid())
8362 Diag(RTRange.getBegin(), diag::note_main_change_return_type)
8363 << FixItHint::CreateReplacement(RTRange, "int");
8364 }
8365 } else {
John McCall5ed3caf2012-02-14 19:50:52 +00008366 // In C and C++, main magically returns 0 if you fall off the end;
8367 // set the flag which tells us that.
8368 // This is C++ [basic.start.main]p5 and C99 5.1.2.2.3.
John McCall5ed3caf2012-02-14 19:50:52 +00008369
Alp Toker70fc29c2014-07-02 07:07:20 +00008370 // All the standards say that main() should return 'int'.
8371 if (Context.hasSameType(FT->getReturnType(), Context.IntTy))
8372 FD->setHasImplicitReturnZero(true);
8373 else {
8374 // Otherwise, this is just a flat-out error.
8375 SourceRange RTRange = FD->getReturnTypeSourceRange();
8376 Diag(FD->getTypeSpecStartLoc(), diag::err_main_returns_nonint)
8377 << (RTRange.isValid() ? FixItHint::CreateReplacement(RTRange, "int")
8378 : FixItHint());
8379 FD->setInvalidDecl(true);
8380 }
John McCall02dee0a2009-07-25 04:36:53 +00008381 }
8382
8383 // Treat protoless main() as nullary.
8384 if (isa<FunctionNoProtoType>(FT)) return;
8385
8386 const FunctionProtoType* FTP = cast<const FunctionProtoType>(FT);
Alp Toker9cacbab2014-01-20 20:26:09 +00008387 unsigned nparams = FTP->getNumParams();
John McCall02dee0a2009-07-25 04:36:53 +00008388 assert(FD->getNumParams() == nparams);
8389
John McCall0e21fcc2009-12-24 09:58:38 +00008390 bool HasExtraParameters = (nparams > 3);
8391
Aaron Ballman1710cc92015-04-23 16:12:42 +00008392 if (FTP->isVariadic()) {
8393 Diag(FD->getLocation(), diag::ext_variadic_main);
8394 // FIXME: if we had information about the location of the ellipsis, we
8395 // could add a FixIt hint to remove it as a parameter.
8396 }
8397
John McCall0e21fcc2009-12-24 09:58:38 +00008398 // Darwin passes an undocumented fourth argument of type char**. If
8399 // other platforms start sprouting these, the logic below will start
8400 // getting shifty.
Douglas Gregore8bbc122011-09-02 00:18:52 +00008401 if (nparams == 4 && Context.getTargetInfo().getTriple().isOSDarwin())
John McCall0e21fcc2009-12-24 09:58:38 +00008402 HasExtraParameters = false;
8403
8404 if (HasExtraParameters) {
John McCall02dee0a2009-07-25 04:36:53 +00008405 Diag(FD->getLocation(), diag::err_main_surplus_args) << nparams;
8406 FD->setInvalidDecl(true);
8407 nparams = 3;
8408 }
8409
8410 // FIXME: a lot of the following diagnostics would be improved
8411 // if we had some location information about types.
8412
8413 QualType CharPP =
8414 Context.getPointerType(Context.getPointerType(Context.CharTy));
John McCall0e21fcc2009-12-24 09:58:38 +00008415 QualType Expected[] = { Context.IntTy, CharPP, CharPP, CharPP };
John McCall02dee0a2009-07-25 04:36:53 +00008416
8417 for (unsigned i = 0; i < nparams; ++i) {
Alp Toker9cacbab2014-01-20 20:26:09 +00008418 QualType AT = FTP->getParamType(i);
John McCall02dee0a2009-07-25 04:36:53 +00008419
8420 bool mismatch = true;
8421
8422 if (Context.hasSameUnqualifiedType(AT, Expected[i]))
8423 mismatch = false;
8424 else if (Expected[i] == CharPP) {
8425 // As an extension, the following forms are okay:
8426 // char const **
8427 // char const * const *
8428 // char * const *
8429
John McCall8ccfcb52009-09-24 19:53:00 +00008430 QualifierCollector qs;
John McCall02dee0a2009-07-25 04:36:53 +00008431 const PointerType* PT;
Ted Kremenekc23c7e62009-07-29 21:53:49 +00008432 if ((PT = qs.strip(AT)->getAs<PointerType>()) &&
8433 (PT = qs.strip(PT->getPointeeType())->getAs<PointerType>()) &&
Richard Smith685cef62013-01-29 02:49:47 +00008434 Context.hasSameType(QualType(qs.strip(PT->getPointeeType()), 0),
8435 Context.CharTy)) {
John McCall02dee0a2009-07-25 04:36:53 +00008436 qs.removeConst();
8437 mismatch = !qs.empty();
8438 }
8439 }
8440
8441 if (mismatch) {
8442 Diag(FD->getLocation(), diag::err_main_arg_wrong) << i << Expected[i];
8443 // TODO: suggest replacing given type with expected type
8444 FD->setInvalidDecl(true);
8445 }
8446 }
8447
8448 if (nparams == 1 && !FD->isInvalidDecl()) {
8449 Diag(FD->getLocation(), diag::warn_main_one_arg);
8450 }
Douglas Gregorbff62032010-10-21 16:57:46 +00008451
8452 if (!FD->isInvalidDecl() && FD->getDescribedFunctionTemplate()) {
Aaron Ballman6d086d72014-01-03 02:20:27 +00008453 Diag(FD->getLocation(), diag::err_mainlike_template_decl) << FD;
David Majnemerc729b0b2013-09-16 22:44:20 +00008454 FD->setInvalidDecl();
8455 }
8456}
8457
8458void Sema::CheckMSVCRTEntryPoint(FunctionDecl *FD) {
8459 QualType T = FD->getType();
8460 assert(T->isFunctionType() && "function decl is not of function type");
8461 const FunctionType *FT = T->castAs<FunctionType>();
8462
8463 // Set an implicit return of 'zero' if the function can return some integral,
8464 // enumeration, pointer or nullptr type.
Alp Toker314cc812014-01-25 16:55:45 +00008465 if (FT->getReturnType()->isIntegralOrEnumerationType() ||
8466 FT->getReturnType()->isAnyPointerType() ||
8467 FT->getReturnType()->isNullPtrType())
David Majnemerc729b0b2013-09-16 22:44:20 +00008468 // DllMain is exempt because a return value of zero means it failed.
8469 if (FD->getName() != "DllMain")
8470 FD->setHasImplicitReturnZero(true);
8471
8472 if (!FD->isInvalidDecl() && FD->getDescribedFunctionTemplate()) {
Aaron Ballman6d086d72014-01-03 02:20:27 +00008473 Diag(FD->getLocation(), diag::err_mainlike_template_decl) << FD;
Douglas Gregorbff62032010-10-21 16:57:46 +00008474 FD->setInvalidDecl();
8475 }
John McCalld9baf6a2009-07-24 03:03:21 +00008476}
8477
Eli Friedmand5a55bd2008-05-20 13:48:25 +00008478bool Sema::CheckForConstantInitializer(Expr *Init, QualType DclT) {
Eli Friedman2c7bd6b2009-02-27 04:17:12 +00008479 // FIXME: Need strict checking. In C89, we need to check for
8480 // any assignment, increment, decrement, function-calls, or
8481 // commas outside of a sizeof. In C99, it's the same list,
8482 // except that the aforementioned are allowed in unevaluated
8483 // expressions. Everything else falls under the
8484 // "may accept other forms of constant expressions" exception.
8485 // (We never end up here for C++, so the constant expression
8486 // rules there don't matter.)
Abramo Bagnara847c6602014-05-22 19:20:46 +00008487 const Expr *Culprit;
8488 if (Init->isConstantInitializer(Context, false, &Culprit))
Eli Friedman7bfab362009-02-22 06:45:27 +00008489 return false;
Abramo Bagnara847c6602014-05-22 19:20:46 +00008490 Diag(Culprit->getExprLoc(), diag::err_init_element_not_constant)
8491 << Culprit->getSourceRange();
Eli Friedmand5a55bd2008-05-20 13:48:25 +00008492 return true;
Steve Naroff98f72032008-01-10 22:15:12 +00008493}
8494
Chandler Carruth33bf3e72011-03-27 09:46:56 +00008495namespace {
8496 // Visits an initialization expression to see if OrigDecl is evaluated in
8497 // its own initialization and throws a warning if it does.
8498 class SelfReferenceChecker
8499 : public EvaluatedExprVisitor<SelfReferenceChecker> {
8500 Sema &S;
8501 Decl *OrigDecl;
Richard Trieua04ad1a2011-09-01 21:44:13 +00008502 bool isRecordType;
8503 bool isPODType;
Hans Wennborge1fdb052012-08-17 10:12:33 +00008504 bool isReferenceType;
Chandler Carruth33bf3e72011-03-27 09:46:56 +00008505
Richard Trieue396ba62014-09-23 22:52:42 +00008506 bool isInitList;
8507 llvm::SmallVector<unsigned, 4> InitFieldIndex;
Chandler Carruth33bf3e72011-03-27 09:46:56 +00008508 public:
8509 typedef EvaluatedExprVisitor<SelfReferenceChecker> Inherited;
8510
8511 SelfReferenceChecker(Sema &S, Decl *OrigDecl) : Inherited(S.Context),
Richard Trieua04ad1a2011-09-01 21:44:13 +00008512 S(S), OrigDecl(OrigDecl) {
8513 isPODType = false;
8514 isRecordType = false;
Hans Wennborge1fdb052012-08-17 10:12:33 +00008515 isReferenceType = false;
Richard Trieue396ba62014-09-23 22:52:42 +00008516 isInitList = false;
Richard Trieua04ad1a2011-09-01 21:44:13 +00008517 if (ValueDecl *VD = dyn_cast<ValueDecl>(OrigDecl)) {
8518 isPODType = VD->getType().isPODType(S.Context);
8519 isRecordType = VD->getType()->isRecordType();
Hans Wennborge1fdb052012-08-17 10:12:33 +00008520 isReferenceType = VD->getType()->isReferenceType();
Richard Trieua04ad1a2011-09-01 21:44:13 +00008521 }
8522 }
Chandler Carruth33bf3e72011-03-27 09:46:56 +00008523
Richard Trieue396ba62014-09-23 22:52:42 +00008524 // For most expressions, just call the visitor. For initializer lists,
8525 // track the index of the field being initialized since fields are
8526 // initialized in order allowing use of previously initialized fields.
8527 void CheckExpr(Expr *E) {
8528 InitListExpr *InitList = dyn_cast<InitListExpr>(E);
8529 if (!InitList) {
8530 Visit(E);
8531 return;
8532 }
8533
8534 // Track and increment the index here.
8535 isInitList = true;
8536 InitFieldIndex.push_back(0);
8537 for (auto Child : InitList->children()) {
8538 CheckExpr(cast<Expr>(Child));
8539 ++InitFieldIndex.back();
8540 }
8541 InitFieldIndex.pop_back();
8542 }
8543
8544 // Returns true if MemberExpr is checked and no futher checking is needed.
8545 // Returns false if additional checking is required.
8546 bool CheckInitListMemberExpr(MemberExpr *E, bool CheckReference) {
8547 llvm::SmallVector<FieldDecl*, 4> Fields;
8548 Expr *Base = E;
8549 bool ReferenceField = false;
8550
8551 // Get the field memebers used.
8552 while (MemberExpr *ME = dyn_cast<MemberExpr>(Base)) {
8553 FieldDecl *FD = dyn_cast<FieldDecl>(ME->getMemberDecl());
8554 if (!FD)
8555 return false;
8556 Fields.push_back(FD);
8557 if (FD->getType()->isReferenceType())
8558 ReferenceField = true;
8559 Base = ME->getBase()->IgnoreParenImpCasts();
8560 }
8561
8562 // Keep checking only if the base Decl is the same.
8563 DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Base);
8564 if (!DRE || DRE->getDecl() != OrigDecl)
8565 return false;
8566
8567 // A reference field can be bound to an unininitialized field.
8568 if (CheckReference && !ReferenceField)
8569 return true;
8570
8571 // Convert FieldDecls to their index number.
8572 llvm::SmallVector<unsigned, 4> UsedFieldIndex;
Pete Cooper57d3f142015-07-30 17:22:52 +00008573 for (const FieldDecl *I : llvm::reverse(Fields))
8574 UsedFieldIndex.push_back(I->getFieldIndex());
Richard Trieue396ba62014-09-23 22:52:42 +00008575
8576 // See if a warning is needed by checking the first difference in index
8577 // numbers. If field being used has index less than the field being
8578 // initialized, then the use is safe.
8579 for (auto UsedIter = UsedFieldIndex.begin(),
8580 UsedEnd = UsedFieldIndex.end(),
8581 OrigIter = InitFieldIndex.begin(),
8582 OrigEnd = InitFieldIndex.end();
8583 UsedIter != UsedEnd && OrigIter != OrigEnd; ++UsedIter, ++OrigIter) {
8584 if (*UsedIter < *OrigIter)
8585 return true;
8586 if (*UsedIter > *OrigIter)
8587 break;
8588 }
8589
8590 // TODO: Add a different warning which will print the field names.
8591 HandleDeclRefExpr(DRE);
8592 return true;
8593 }
8594
Richard Trieu64c51ab2012-05-09 00:21:34 +00008595 // For most expressions, the cast is directly above the DeclRefExpr.
8596 // For conditional operators, the cast can be outside the conditional
8597 // operator if both expressions are DeclRefExpr's.
8598 void HandleValue(Expr *E) {
Richard Trieuabf6ec42014-08-27 22:15:10 +00008599 E = E->IgnoreParens();
Richard Trieu64c51ab2012-05-09 00:21:34 +00008600 if (DeclRefExpr* DRE = dyn_cast<DeclRefExpr>(E)) {
8601 HandleDeclRefExpr(DRE);
8602 return;
8603 }
8604
8605 if (ConditionalOperator *CO = dyn_cast<ConditionalOperator>(E)) {
Richard Trieu779c6f22014-09-26 23:48:30 +00008606 Visit(CO->getCond());
Richard Trieu64c51ab2012-05-09 00:21:34 +00008607 HandleValue(CO->getTrueExpr());
8608 HandleValue(CO->getFalseExpr());
Richard Trieu742c6ed2012-10-03 00:41:36 +00008609 return;
8610 }
8611
Richard Trieuabf6ec42014-08-27 22:15:10 +00008612 if (BinaryConditionalOperator *BCO =
8613 dyn_cast<BinaryConditionalOperator>(E)) {
Richard Trieu2a07c962014-09-04 23:19:34 +00008614 Visit(BCO->getCond());
Richard Trieuabf6ec42014-08-27 22:15:10 +00008615 HandleValue(BCO->getFalseExpr());
8616 return;
8617 }
8618
8619 if (OpaqueValueExpr *OVE = dyn_cast<OpaqueValueExpr>(E)) {
8620 HandleValue(OVE->getSourceExpr());
8621 return;
8622 }
8623
8624 if (BinaryOperator *BO = dyn_cast<BinaryOperator>(E)) {
Richard Trieu78dd7252014-09-24 03:53:56 +00008625 if (BO->getOpcode() == BO_Comma) {
8626 Visit(BO->getLHS());
Richard Trieuabf6ec42014-08-27 22:15:10 +00008627 HandleValue(BO->getRHS());
Richard Trieu78dd7252014-09-24 03:53:56 +00008628 return;
8629 }
Richard Trieuabf6ec42014-08-27 22:15:10 +00008630 }
8631
Richard Trieu742c6ed2012-10-03 00:41:36 +00008632 if (isa<MemberExpr>(E)) {
Richard Trieue396ba62014-09-23 22:52:42 +00008633 if (isInitList) {
8634 if (CheckInitListMemberExpr(cast<MemberExpr>(E),
8635 false /*CheckReference*/))
8636 return;
8637 }
8638
Richard Trieu742c6ed2012-10-03 00:41:36 +00008639 Expr *Base = E->IgnoreParenImpCasts();
8640 while (MemberExpr *ME = dyn_cast<MemberExpr>(Base)) {
8641 // Check for static member variables and don't warn on them.
8642 if (!isa<FieldDecl>(ME->getMemberDecl()))
8643 return;
8644 Base = ME->getBase()->IgnoreParenImpCasts();
8645 }
8646 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Base))
8647 HandleDeclRefExpr(DRE);
8648 return;
Richard Trieu64c51ab2012-05-09 00:21:34 +00008649 }
Richard Trieu2a07c962014-09-04 23:19:34 +00008650
8651 Visit(E);
Richard Trieu64c51ab2012-05-09 00:21:34 +00008652 }
8653
Richard Trieu2a07c962014-09-04 23:19:34 +00008654 // Reference types not handled in HandleValue are handled here since all
8655 // uses of references are bad, not just r-value uses.
Richard Trieu32673472012-10-01 17:39:51 +00008656 void VisitDeclRefExpr(DeclRefExpr *E) {
8657 if (isReferenceType)
8658 HandleDeclRefExpr(E);
8659 }
8660
Richard Trieu64c51ab2012-05-09 00:21:34 +00008661 void VisitImplicitCastExpr(ImplicitCastExpr *E) {
Richard Trieu9f8509f2014-09-30 23:04:37 +00008662 if (E->getCastKind() == CK_LValueToRValue) {
Richard Trieu64c51ab2012-05-09 00:21:34 +00008663 HandleValue(E->getSubExpr());
Richard Trieu2a07c962014-09-04 23:19:34 +00008664 return;
8665 }
Richard Trieu64c51ab2012-05-09 00:21:34 +00008666
8667 Inherited::VisitImplicitCastExpr(E);
Chandler Carruth33bf3e72011-03-27 09:46:56 +00008668 }
8669
Richard Trieua04ad1a2011-09-01 21:44:13 +00008670 void VisitMemberExpr(MemberExpr *E) {
Richard Trieue396ba62014-09-23 22:52:42 +00008671 if (isInitList) {
8672 if (CheckInitListMemberExpr(E, true /*CheckReference*/))
8673 return;
8674 }
8675
Richard Trieu64c51ab2012-05-09 00:21:34 +00008676 // Don't warn on arrays since they can be treated as pointers.
Richard Trieuaa5e2562011-09-07 00:58:53 +00008677 if (E->getType()->canDecayToPointerType()) return;
Richard Trieu64c51ab2012-05-09 00:21:34 +00008678
Richard Trieu742c6ed2012-10-03 00:41:36 +00008679 // Warn when a non-static method call is followed by non-static member
8680 // field accesses, which is followed by a DeclRefExpr.
8681 CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(E->getMemberDecl());
8682 bool Warn = (MD && !MD->isStatic());
8683 Expr *Base = E->getBase()->IgnoreParenImpCasts();
8684 while (MemberExpr *ME = dyn_cast<MemberExpr>(Base)) {
8685 if (!isa<FieldDecl>(ME->getMemberDecl()))
8686 Warn = false;
8687 Base = ME->getBase()->IgnoreParenImpCasts();
8688 }
Richard Trieua04ad1a2011-09-01 21:44:13 +00008689
Richard Trieu742c6ed2012-10-03 00:41:36 +00008690 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Base)) {
8691 if (Warn)
8692 HandleDeclRefExpr(DRE);
8693 return;
8694 }
8695
8696 // The base of a MemberExpr is not a MemberExpr or a DeclRefExpr.
8697 // Visit that expression.
8698 Visit(Base);
Chandler Carruth33bf3e72011-03-27 09:46:56 +00008699 }
8700
Richard Trieu8fbd91d2013-03-26 03:41:40 +00008701 void VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E) {
Richard Trieud4a01362014-10-31 21:10:22 +00008702 Expr *Callee = E->getCallee();
Richard Trieu8fbd91d2013-03-26 03:41:40 +00008703
Richard Trieud4a01362014-10-31 21:10:22 +00008704 if (isa<UnresolvedLookupExpr>(Callee))
8705 return Inherited::VisitCXXOperatorCallExpr(E);
8706
8707 Visit(Callee);
8708 for (auto Arg: E->arguments())
8709 HandleValue(Arg->IgnoreParenImpCasts());
Richard Trieu8fbd91d2013-03-26 03:41:40 +00008710 }
8711
Richard Trieua04ad1a2011-09-01 21:44:13 +00008712 void VisitUnaryOperator(UnaryOperator *E) {
8713 // For POD record types, addresses of its own members are well-defined.
Richard Trieu742c6ed2012-10-03 00:41:36 +00008714 if (E->getOpcode() == UO_AddrOf && isRecordType &&
8715 isa<MemberExpr>(E->getSubExpr()->IgnoreParens())) {
8716 if (!isPODType)
8717 HandleValue(E->getSubExpr());
8718 return;
8719 }
Richard Trieu52b8b602014-09-25 01:15:40 +00008720
8721 if (E->isIncrementDecrementOp()) {
8722 HandleValue(E->getSubExpr());
8723 return;
8724 }
8725
Richard Trieua04ad1a2011-09-01 21:44:13 +00008726 Inherited::VisitUnaryOperator(E);
Richard Smithfa11fd62013-05-03 19:16:22 +00008727 }
Richard Trieu64c51ab2012-05-09 00:21:34 +00008728
8729 void VisitObjCMessageExpr(ObjCMessageExpr *E) { return; }
8730
Richard Trieu4834ad22014-08-12 21:05:04 +00008731 void VisitCXXConstructExpr(CXXConstructExpr *E) {
8732 if (E->getConstructor()->isCopyConstructor()) {
Richard Trieu9f8509f2014-09-30 23:04:37 +00008733 Expr *ArgExpr = E->getArg(0);
8734 if (InitListExpr *ILE = dyn_cast<InitListExpr>(ArgExpr))
8735 if (ILE->getNumInits() == 1)
8736 ArgExpr = ILE->getInit(0);
8737 if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(ArgExpr))
8738 if (ICE->getCastKind() == CK_NoOp)
8739 ArgExpr = ICE->getSubExpr();
8740 HandleValue(ArgExpr);
8741 return;
Richard Trieu4834ad22014-08-12 21:05:04 +00008742 }
8743 Inherited::VisitCXXConstructExpr(E);
8744 }
8745
Richard Trieu11fd0792014-08-26 04:30:55 +00008746 void VisitCallExpr(CallExpr *E) {
8747 // Treat std::move as a use.
8748 if (E->getNumArgs() == 1) {
8749 if (FunctionDecl *FD = E->getDirectCallee()) {
Richard Trieuc321b932014-11-27 01:29:32 +00008750 if (FD->isInStdNamespace() && FD->getIdentifier() &&
8751 FD->getIdentifier()->isStr("move")) {
Richard Trieuabf6ec42014-08-27 22:15:10 +00008752 HandleValue(E->getArg(0));
Richard Trieu2a07c962014-09-04 23:19:34 +00008753 return;
Richard Trieu11fd0792014-08-26 04:30:55 +00008754 }
8755 }
8756 }
8757
8758 Inherited::VisitCallExpr(E);
8759 }
8760
Richard Trieu52b8b602014-09-25 01:15:40 +00008761 void VisitBinaryOperator(BinaryOperator *E) {
8762 if (E->isCompoundAssignmentOp()) {
8763 HandleValue(E->getLHS());
8764 Visit(E->getRHS());
8765 return;
8766 }
8767
8768 Inherited::VisitBinaryOperator(E);
8769 }
8770
Richard Trieu2a07c962014-09-04 23:19:34 +00008771 // A custom visitor for BinaryConditionalOperator is needed because the
8772 // regular visitor would check the condition and true expression separately
8773 // but both point to the same place giving duplicate diagnostics.
8774 void VisitBinaryConditionalOperator(BinaryConditionalOperator *E) {
8775 Visit(E->getCond());
8776 Visit(E->getFalseExpr());
8777 }
8778
Richard Trieua04ad1a2011-09-01 21:44:13 +00008779 void HandleDeclRefExpr(DeclRefExpr *DRE) {
NAKAMURA Takumi3fef3ef2013-01-19 01:54:35 +00008780 Decl* ReferenceDecl = DRE->getDecl();
Chandler Carruth33bf3e72011-03-27 09:46:56 +00008781 if (OrigDecl != ReferenceDecl) return;
Ted Kremeneka83b4072013-01-19 04:33:14 +00008782 unsigned diag;
8783 if (isReferenceType) {
8784 diag = diag::warn_uninit_self_reference_in_reference_init;
8785 } else if (cast<VarDecl>(OrigDecl)->isStaticLocal()) {
8786 diag = diag::warn_static_self_reference_in_init;
Manuel Klimek27ee25f2015-03-03 14:54:25 +00008787 } else if (isa<TranslationUnitDecl>(OrigDecl->getDeclContext()) ||
8788 isa<NamespaceDecl>(OrigDecl->getDeclContext()) ||
8789 DRE->getDecl()->getType()->isRecordType()) {
Ted Kremeneka83b4072013-01-19 04:33:14 +00008790 diag = diag::warn_uninit_self_reference_in_init;
Manuel Klimek27ee25f2015-03-03 14:54:25 +00008791 } else {
8792 // Local variables will be handled by the CFG analysis.
8793 return;
Ted Kremeneka83b4072013-01-19 04:33:14 +00008794 }
8795
Richard Trieua04ad1a2011-09-01 21:44:13 +00008796 S.DiagRuntimeBehavior(DRE->getLocStart(), DRE,
Hans Wennborgd799a2b2012-08-20 08:52:22 +00008797 S.PDiag(diag)
Hans Wennborg61b2ffa2012-09-21 08:58:33 +00008798 << DRE->getNameInfo().getName()
Douglas Gregorfcafc6e2011-05-24 16:02:01 +00008799 << OrigDecl->getLocation()
Richard Trieua04ad1a2011-09-01 21:44:13 +00008800 << DRE->getSourceRange());
Chandler Carruth33bf3e72011-03-27 09:46:56 +00008801 }
8802 };
Chandler Carruth33bf3e72011-03-27 09:46:56 +00008803
Richard Trieu32673472012-10-01 17:39:51 +00008804 /// CheckSelfReference - Warns if OrigDecl is used in expression E.
8805 static void CheckSelfReference(Sema &S, Decl* OrigDecl, Expr *E,
8806 bool DirectInit) {
8807 // Parameters arguments are occassionially constructed with itself,
8808 // for instance, in recursive functions. Skip them.
8809 if (isa<ParmVarDecl>(OrigDecl))
8810 return;
8811
8812 E = E->IgnoreParens();
8813
8814 // Skip checking T a = a where T is not a record or reference type.
8815 // Doing so is a way to silence uninitialized warnings.
8816 if (!DirectInit && !cast<VarDecl>(OrigDecl)->getType()->isRecordType())
8817 if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E))
8818 if (ICE->getCastKind() == CK_LValueToRValue)
8819 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(ICE->getSubExpr()))
8820 if (DRE->getDecl() == OrigDecl)
8821 return;
8822
Richard Trieue396ba62014-09-23 22:52:42 +00008823 SelfReferenceChecker(S, OrigDecl).CheckExpr(E);
Richard Trieu32673472012-10-01 17:39:51 +00008824 }
Alexander Kornienkoab9db512015-06-22 23:07:51 +00008825}
Richard Trieua04ad1a2011-09-01 21:44:13 +00008826
Douglas Gregor5fb53972009-01-14 15:45:31 +00008827/// AddInitializerToDecl - Adds the initializer Init to the
8828/// declaration dcl. If DirectInit is true, this is C++ direct
8829/// initialization rather than copy initialization.
Richard Smith30482bc2011-02-20 03:19:35 +00008830void Sema::AddInitializerToDecl(Decl *RealDecl, Expr *Init,
8831 bool DirectInit, bool TypeMayContainAuto) {
Chris Lattner8beb9de2007-10-19 20:10:30 +00008832 // If there is no declaration, there was an error parsing it. Just ignore
8833 // the initializer.
Kaelyn Takata42118a92015-01-07 21:16:39 +00008834 if (!RealDecl || RealDecl->isInvalidDecl()) {
Kaelyn Takatab8499f02015-05-05 19:17:03 +00008835 CorrectDelayedTyposInExpr(Init, dyn_cast_or_null<VarDecl>(RealDecl));
Chris Lattner8beb9de2007-10-19 20:10:30 +00008836 return;
Kaelyn Takata42118a92015-01-07 21:16:39 +00008837 }
Mike Stump11289f42009-09-09 15:08:12 +00008838
Douglas Gregor0c880302009-03-11 23:00:04 +00008839 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(RealDecl)) {
Richard Smith9ba0fec2015-06-30 01:28:56 +00008840 // Pure-specifiers are handled in ActOnPureSpecifier.
8841 Diag(Method->getLocation(), diag::err_member_function_initialization)
8842 << Method->getDeclName() << Init->getSourceRange();
8843 Method->setInvalidDecl();
Douglas Gregor0c880302009-03-11 23:00:04 +00008844 return;
8845 }
8846
Steve Naroff437b4d82007-09-12 20:13:48 +00008847 VarDecl *VDecl = dyn_cast<VarDecl>(RealDecl);
8848 if (!VDecl) {
Richard Smith4a4beec2011-06-12 11:43:46 +00008849 assert(!isa<FieldDecl>(RealDecl) && "field init shouldn't get here");
8850 Diag(RealDecl->getLocation(), diag::err_illegal_initializer);
Steve Naroff437b4d82007-09-12 20:13:48 +00008851 RealDecl->setInvalidDecl();
8852 return;
Eli Friedman2c7bd6b2009-02-27 04:17:12 +00008853 }
Sebastian Redla9351792012-02-11 23:51:47 +00008854 ParenListExpr *CXXDirectInit = dyn_cast<ParenListExpr>(Init);
8855
Richard Smith0cc85782011-12-15 19:20:59 +00008856 // C++11 [decl.spec.auto]p6. Deduce the type which 'auto' stands in for.
Richard Smith27d807c2013-04-30 13:56:41 +00008857 if (TypeMayContainAuto && VDecl->getType()->isUndeducedType()) {
Kaelyn Takata3587fff2015-03-17 23:50:12 +00008858 // Attempt typo correction early so that the type of the init expression can
8859 // be deduced based on the chosen correction:if the original init contains a
8860 // TypoExpr.
Kaelyn Takatab8499f02015-05-05 19:17:03 +00008861 ExprResult Res = CorrectDelayedTyposInExpr(Init, VDecl);
Kaelyn Takata3587fff2015-03-17 23:50:12 +00008862 if (!Res.isUsable()) {
8863 RealDecl->setInvalidDecl();
8864 return;
8865 }
Kaelyn Takatab8499f02015-05-05 19:17:03 +00008866
Kaelyn Takata3587fff2015-03-17 23:50:12 +00008867 if (Res.get() != Init) {
8868 Init = Res.get();
8869 if (CXXDirectInit)
8870 CXXDirectInit = dyn_cast<ParenListExpr>(Init);
8871 }
8872
Sebastian Redla9351792012-02-11 23:51:47 +00008873 Expr *DeduceInit = Init;
8874 // Initializer could be a C++ direct-initializer. Deduction only works if it
8875 // contains exactly one expression.
8876 if (CXXDirectInit) {
8877 if (CXXDirectInit->getNumExprs() == 0) {
8878 // It isn't possible to write this directly, but it is possible to
8879 // end up in this situation with "auto x(some_pack...);"
Daniel Dunbar62ee6412012-03-09 18:35:03 +00008880 Diag(CXXDirectInit->getLocStart(),
Richard Smithbb13c9a2013-09-28 04:02:39 +00008881 VDecl->isInitCapture() ? diag::err_init_capture_no_expression
8882 : diag::err_auto_var_init_no_expression)
Sebastian Redla9351792012-02-11 23:51:47 +00008883 << VDecl->getDeclName() << VDecl->getType()
8884 << VDecl->getSourceRange();
8885 RealDecl->setInvalidDecl();
8886 return;
8887 } else if (CXXDirectInit->getNumExprs() > 1) {
Daniel Dunbar62ee6412012-03-09 18:35:03 +00008888 Diag(CXXDirectInit->getExpr(1)->getLocStart(),
Richard Smithbb13c9a2013-09-28 04:02:39 +00008889 VDecl->isInitCapture()
8890 ? diag::err_init_capture_multiple_expressions
8891 : diag::err_auto_var_init_multiple_expressions)
Sebastian Redla9351792012-02-11 23:51:47 +00008892 << VDecl->getDeclName() << VDecl->getType()
8893 << VDecl->getSourceRange();
8894 RealDecl->setInvalidDecl();
8895 return;
8896 } else {
8897 DeduceInit = CXXDirectInit->getExpr(0);
Richard Smith66204ec2014-03-12 17:42:45 +00008898 if (isa<InitListExpr>(DeduceInit))
8899 Diag(CXXDirectInit->getLocStart(),
8900 diag::err_auto_var_init_paren_braces)
8901 << VDecl->getDeclName() << VDecl->getType()
8902 << VDecl->getSourceRange();
Sebastian Redla9351792012-02-11 23:51:47 +00008903 }
8904 }
Douglas Gregorb5af2e92013-03-07 22:57:58 +00008905
8906 // Expressions default to 'id' when we're in a debugger.
8907 bool DefaultedToAuto = false;
8908 if (getLangOpts().DebuggerCastResultToId &&
8909 Init->getType() == Context.UnknownAnyTy) {
8910 ExprResult Result = forceUnknownAnyToType(Init, Context.getObjCIdType());
8911 if (Result.isInvalid()) {
8912 VDecl->setInvalidDecl();
8913 return;
8914 }
Nikola Smiljanic01a75982014-05-29 10:55:11 +00008915 Init = Result.get();
Douglas Gregorb5af2e92013-03-07 22:57:58 +00008916 DefaultedToAuto = true;
8917 }
Richard Smith061f1e22013-04-30 21:23:01 +00008918
8919 QualType DeducedType;
Sebastian Redla9351792012-02-11 23:51:47 +00008920 if (DeduceAutoType(VDecl->getTypeSourceInfo(), DeduceInit, DeducedType) ==
Sebastian Redl09edce02012-01-23 22:09:39 +00008921 DAR_Failed)
Sebastian Redla9351792012-02-11 23:51:47 +00008922 DiagnoseAutoDeductionFailure(VDecl, DeduceInit);
Richard Smith061f1e22013-04-30 21:23:01 +00008923 if (DeducedType.isNull()) {
Richard Smith30482bc2011-02-20 03:19:35 +00008924 RealDecl->setInvalidDecl();
8925 return;
8926 }
Richard Smith061f1e22013-04-30 21:23:01 +00008927 VDecl->setType(DeducedType);
Rafael Espindola0e0d0092013-03-14 03:07:35 +00008928 assert(VDecl->isLinkageValid());
Rafael Espindolabf5c33b2013-03-12 21:06:00 +00008929
John McCall31168b02011-06-15 23:02:42 +00008930 // In ARC, infer lifetime.
David Blaikiebbafb8a2012-03-11 07:00:24 +00008931 if (getLangOpts().ObjCAutoRefCount && inferObjCARCLifetime(VDecl))
John McCall31168b02011-06-15 23:02:42 +00008932 VDecl->setInvalidDecl();
8933
Jordan Rosed8d56692012-06-08 22:46:07 +00008934 // Warn if we deduced 'id'. 'auto' usually implies type-safety, but using
8935 // 'id' instead of a specific object type prevents most of our usual checks.
8936 // We only want to warn outside of template instantiations, though:
8937 // inside a template, the 'id' could have come from a parameter.
Douglas Gregorb5af2e92013-03-07 22:57:58 +00008938 if (ActiveTemplateInstantiations.empty() && !DefaultedToAuto &&
Richard Smith061f1e22013-04-30 21:23:01 +00008939 DeducedType->isObjCIdType()) {
8940 SourceLocation Loc =
8941 VDecl->getTypeSourceInfo()->getTypeLoc().getBeginLoc();
Jordan Rosed8d56692012-06-08 22:46:07 +00008942 Diag(Loc, diag::warn_auto_var_is_id)
8943 << VDecl->getDeclName() << DeduceInit->getSourceRange();
8944 }
8945
Richard Smith30482bc2011-02-20 03:19:35 +00008946 // If this is a redeclaration, check that the type we just deduced matches
8947 // the previously declared type.
Richard Smith1c34fb72013-08-13 18:18:50 +00008948 if (VarDecl *Old = VDecl->getPreviousDecl()) {
8949 // We never need to merge the type, because we cannot form an incomplete
8950 // array of auto, nor deduce such a type.
8951 MergeVarDeclTypes(VDecl, Old, /*MergeTypeWithPrevious*/false);
8952 }
Richard Smith27d807c2013-04-30 13:56:41 +00008953
8954 // Check the deduced type is valid for a variable declaration.
8955 CheckVariableDeclarationType(VDecl);
8956 if (VDecl->isInvalidDecl())
8957 return;
Richard Smith215f4232015-02-11 02:41:33 +00008958
8959 // If all looks well, warn if this is a case that will change meaning when
8960 // we implement N3922.
8961 if (DirectInit && !CXXDirectInit && isa<InitListExpr>(Init)) {
8962 Diag(Init->getLocStart(),
8963 diag::warn_auto_var_direct_list_init)
8964 << FixItHint::CreateInsertion(Init->getLocStart(), "=");
8965 }
Richard Smith30482bc2011-02-20 03:19:35 +00008966 }
Richard Smith0cc85782011-12-15 19:20:59 +00008967
Nico Rieck8e9791f2014-02-26 21:27:13 +00008968 // dllimport cannot be used on variable definitions.
8969 if (VDecl->hasAttr<DLLImportAttr>() && !VDecl->isStaticDataMember()) {
8970 Diag(VDecl->getLocation(), diag::err_attribute_dllimport_data_definition);
8971 VDecl->setInvalidDecl();
8972 return;
8973 }
8974
Richard Smith0cc85782011-12-15 19:20:59 +00008975 if (VDecl->isLocalVarDecl() && VDecl->hasExternalStorage()) {
8976 // C99 6.7.8p5. C++ has no such restriction, but that is a defect.
8977 Diag(VDecl->getLocation(), diag::err_block_extern_cant_init);
8978 VDecl->setInvalidDecl();
8979 return;
8980 }
8981
Sebastian Redla9351792012-02-11 23:51:47 +00008982 if (!VDecl->getType()->isDependentType()) {
8983 // A definition must end up with a complete type, which means it must be
8984 // complete with the restriction that an array type might be completed by
8985 // the initializer; note that later code assumes this restriction.
8986 QualType BaseDeclType = VDecl->getType();
8987 if (const ArrayType *Array = Context.getAsIncompleteArrayType(BaseDeclType))
8988 BaseDeclType = Array->getElementType();
8989 if (RequireCompleteType(VDecl->getLocation(), BaseDeclType,
8990 diag::err_typecheck_decl_incomplete_type)) {
8991 RealDecl->setInvalidDecl();
8992 return;
8993 }
Douglas Gregorf0f83692010-08-24 05:27:49 +00008994
Sebastian Redla9351792012-02-11 23:51:47 +00008995 // The variable can not have an abstract class type.
8996 if (RequireNonAbstractType(VDecl->getLocation(), VDecl->getType(),
8997 diag::err_abstract_type_in_decl,
8998 AbstractVariableType))
8999 VDecl->setInvalidDecl();
Eli Friedman337cd3a2009-04-13 21:28:54 +00009000 }
9001
Richard Smith82e57fb2015-05-19 00:49:29 +00009002 VarDecl *Def;
Sebastian Redl5ca79842010-02-01 20:16:42 +00009003 if ((Def = VDecl->getDefinition()) && Def != VDecl) {
Richard Smith82e57fb2015-05-19 00:49:29 +00009004 NamedDecl *Hidden = nullptr;
9005 if (!hasVisibleDefinition(Def, &Hidden) &&
Richard Smith529ecb22015-06-22 21:15:01 +00009006 (VDecl->getFormalLinkage() == InternalLinkage ||
9007 VDecl->getDescribedVarTemplate() ||
Richard Smith82e57fb2015-05-19 00:49:29 +00009008 VDecl->getNumTemplateParameterLists() ||
9009 VDecl->getDeclContext()->isDependentContext())) {
9010 // The previous definition is hidden, and multiple definitions are
9011 // permitted (in separate TUs). Form another definition of it.
9012 } else {
9013 Diag(VDecl->getLocation(), diag::err_redefinition)
9014 << VDecl->getDeclName();
9015 Diag(Def->getLocation(), diag::note_previous_definition);
9016 VDecl->setInvalidDecl();
9017 return;
9018 }
Douglas Gregor0760fa12009-03-10 23:43:53 +00009019 }
Craig Topperc3ec1492014-05-26 06:22:03 +00009020
David Blaikiebbafb8a2012-03-11 07:00:24 +00009021 if (getLangOpts().CPlusPlus) {
Douglas Gregor71f39c92010-12-16 01:31:22 +00009022 // C++ [class.static.data]p4
9023 // If a static data member is of const integral or const
9024 // enumeration type, its declaration in the class definition can
9025 // specify a constant-initializer which shall be an integral
9026 // constant expression (5.19). In that case, the member can appear
9027 // in integral constant expressions. The member shall still be
9028 // defined in a namespace scope if it is used in the program and the
9029 // namespace scope definition shall not contain an initializer.
9030 //
9031 // We already performed a redefinition check above, but for static
9032 // data members we also need to check whether there was an in-class
9033 // declaration with an initializer.
Richard Smith82e57fb2015-05-19 00:49:29 +00009034 if (VDecl->isStaticDataMember() && VDecl->getCanonicalDecl()->hasInit()) {
Hans Wennborg84fe12d2013-11-21 03:17:44 +00009035 Diag(Init->getExprLoc(), diag::err_static_data_member_reinitialization)
9036 << VDecl->getDeclName();
Richard Smith82e57fb2015-05-19 00:49:29 +00009037 Diag(VDecl->getCanonicalDecl()->getInit()->getExprLoc(),
9038 diag::note_previous_initializer)
9039 << 0;
Douglas Gregor71f39c92010-12-16 01:31:22 +00009040 return;
9041 }
Douglas Gregor0760fa12009-03-10 23:43:53 +00009042
Douglas Gregor71f39c92010-12-16 01:31:22 +00009043 if (VDecl->hasLocalStorage())
9044 getCurFunction()->setHasBranchProtectedScope();
9045
9046 if (DiagnoseUnexpandedParameterPack(Init, UPPC_Initializer)) {
9047 VDecl->setInvalidDecl();
9048 return;
9049 }
9050 }
John McCalld4e1b762010-08-01 01:24:59 +00009051
Peter Collingbourne2dbb7082011-09-19 21:14:35 +00009052 // OpenCL 1.1 6.5.2: "Variables allocated in the __local address space inside
9053 // a kernel function cannot be initialized."
9054 if (VDecl->getStorageClass() == SC_OpenCLWorkGroupLocal) {
9055 Diag(VDecl->getLocation(), diag::err_local_cant_init);
9056 VDecl->setInvalidDecl();
9057 return;
9058 }
9059
Steve Naroff61091402007-09-12 14:07:44 +00009060 // Get the decls type and save a reference for later, since
Steve Naroff98f72032008-01-10 22:15:12 +00009061 // CheckInitializerTypes may change it.
Steve Naroff437b4d82007-09-12 20:13:48 +00009062 QualType DclT = VDecl->getType(), SavT = DclT;
Fariborz Jahanianc8a322a2012-03-09 18:47:16 +00009063
Douglas Gregorb5af2e92013-03-07 22:57:58 +00009064 // Expressions default to 'id' when we're in a debugger
9065 // and we are assigning it to a variable of Objective-C pointer type.
9066 if (getLangOpts().DebuggerCastResultToId && DclT->isObjCObjectPointerType() &&
9067 Init->getType() == Context.UnknownAnyTy) {
9068 ExprResult Result = forceUnknownAnyToType(Init, Context.getObjCIdType());
9069 if (Result.isInvalid()) {
9070 VDecl->setInvalidDecl();
9071 return;
Fariborz Jahanianc8a322a2012-03-09 18:47:16 +00009072 }
Nikola Smiljanic01a75982014-05-29 10:55:11 +00009073 Init = Result.get();
Douglas Gregorb5af2e92013-03-07 22:57:58 +00009074 }
Richard Smith0cc85782011-12-15 19:20:59 +00009075
9076 // Perform the initialization.
9077 if (!VDecl->isInvalidDecl()) {
9078 InitializedEntity Entity = InitializedEntity::InitializeVariable(VDecl);
9079 InitializationKind Kind
Sebastian Redl5a41f682012-02-12 16:37:24 +00009080 = DirectInit ?
9081 CXXDirectInit ? InitializationKind::CreateDirect(VDecl->getLocation(),
9082 Init->getLocStart(),
9083 Init->getLocEnd())
9084 : InitializationKind::CreateDirectList(
9085 VDecl->getLocation())
Richard Smith0cc85782011-12-15 19:20:59 +00009086 : InitializationKind::CreateCopy(VDecl->getLocation(),
9087 Init->getLocStart());
9088
Dmitri Gribenko8f8930f2013-05-03 15:05:50 +00009089 MultiExprArg Args = Init;
9090 if (CXXDirectInit)
9091 Args = MultiExprArg(CXXDirectInit->getExprs(),
9092 CXXDirectInit->getNumExprs());
9093
Kaelyn Takata938204a2014-12-16 23:07:00 +00009094 // Try to correct any TypoExprs in the initialization arguments.
9095 for (size_t Idx = 0; Idx < Args.size(); ++Idx) {
Kaelyn Takatab8499f02015-05-05 19:17:03 +00009096 ExprResult Res = CorrectDelayedTyposInExpr(
9097 Args[Idx], VDecl, [this, Entity, Kind](Expr *E) {
Kaelyn Takata4c3ffc42014-11-21 18:48:00 +00009098 InitializationSequence Init(*this, Entity, Kind, MultiExprArg(E));
9099 return Init.Failed() ? ExprError() : E;
9100 });
9101 if (Res.isInvalid()) {
9102 VDecl->setInvalidDecl();
Kaelyn Takata21a88692015-01-21 00:04:19 +00009103 } else if (Res.get() != Args[Idx]) {
Kaelyn Takata938204a2014-12-16 23:07:00 +00009104 Args[Idx] = Res.get();
Kaelyn Takata21a88692015-01-21 00:04:19 +00009105 }
Kaelyn Takata4c3ffc42014-11-21 18:48:00 +00009106 }
Kaelyn Takata21a88692015-01-21 00:04:19 +00009107 if (VDecl->isInvalidDecl())
9108 return;
Kaelyn Takata4c3ffc42014-11-21 18:48:00 +00009109
Dmitri Gribenko8f8930f2013-05-03 15:05:50 +00009110 InitializationSequence InitSeq(*this, Entity, Kind, Args);
9111 ExprResult Result = InitSeq.Perform(*this, Entity, Kind, Args, &DclT);
Richard Smith0cc85782011-12-15 19:20:59 +00009112 if (Result.isInvalid()) {
Steve Naroff08899ff2008-04-15 22:42:06 +00009113 VDecl->setInvalidDecl();
Richard Smith0cc85782011-12-15 19:20:59 +00009114 return;
Steve Naroff61091402007-09-12 14:07:44 +00009115 }
Richard Smith0cc85782011-12-15 19:20:59 +00009116
Nikola Smiljanic01a75982014-05-29 10:55:11 +00009117 Init = Result.getAs<Expr>();
Richard Smith0cc85782011-12-15 19:20:59 +00009118 }
9119
Richard Trieu32673472012-10-01 17:39:51 +00009120 // Check for self-references within variable initializers.
9121 // Variables declared within a function/method body (except for references)
9122 // are handled by a dataflow analysis.
9123 if (!VDecl->hasLocalStorage() || VDecl->getType()->isRecordType() ||
9124 VDecl->getType()->isReferenceType()) {
9125 CheckSelfReference(*this, RealDecl, Init, DirectInit);
9126 }
9127
Richard Smith0cc85782011-12-15 19:20:59 +00009128 // If the type changed, it means we had an incomplete type that was
9129 // completed by the initializer. For example:
9130 // int ary[] = { 1, 3, 5 };
John McCalla59dc2f2012-01-05 00:13:19 +00009131 // "ary" transitions from an IncompleteArrayType to a ConstantArrayType.
Eli Friedman91f5ae52012-02-23 02:25:10 +00009132 if (!VDecl->isInvalidDecl() && (DclT != SavT))
Richard Smith0cc85782011-12-15 19:20:59 +00009133 VDecl->setType(DclT);
Richard Smith0cc85782011-12-15 19:20:59 +00009134
Jordan Rosefa9e4ba2012-09-15 02:48:31 +00009135 if (!VDecl->isInvalidDecl()) {
Richard Smith0cc85782011-12-15 19:20:59 +00009136 checkUnsafeAssigns(VDecl->getLocation(), VDecl->getType(), Init);
9137
Jordan Rosefa9e4ba2012-09-15 02:48:31 +00009138 if (VDecl->hasAttr<BlocksAttr>())
9139 checkRetainCycles(VDecl, Init);
Jordan Rosed3934582012-09-28 22:21:30 +00009140
9141 // It is safe to assign a weak reference into a strong variable.
9142 // Although this code can still have problems:
9143 // id x = self.weakProp;
9144 // id y = self.weakProp;
9145 // we do not warn to warn spuriously when 'x' and 'y' are on separate
9146 // paths through the function. This should be revisited if
9147 // -Wrepeated-use-of-weak is made flow-sensitive.
Alp Tokerd4a3f0e2014-06-15 23:30:39 +00009148 if (VDecl->getType().getObjCLifetime() == Qualifiers::OCL_Strong &&
9149 !Diags.isIgnored(diag::warn_arc_repeated_use_of_weak,
9150 Init->getLocStart()))
Jordan Rosed3934582012-09-28 22:21:30 +00009151 getCurFunction()->markSafeWeakUse(Init);
Jordan Rosefa9e4ba2012-09-15 02:48:31 +00009152 }
9153
Richard Smith945f8d32013-01-14 22:39:08 +00009154 // The initialization is usually a full-expression.
9155 //
9156 // FIXME: If this is a braced initialization of an aggregate, it is not
9157 // an expression, and each individual field initializer is a separate
9158 // full-expression. For instance, in:
9159 //
9160 // struct Temp { ~Temp(); };
9161 // struct S { S(Temp); };
9162 // struct T { S a, b; } t = { Temp(), Temp() }
9163 //
9164 // we should destroy the first Temp before constructing the second.
Fariborz Jahaniane735ff92013-01-24 22:11:45 +00009165 ExprResult Result = ActOnFinishFullExpr(Init, VDecl->getLocation(),
9166 false,
9167 VDecl->isConstexpr());
Richard Smith945f8d32013-01-14 22:39:08 +00009168 if (Result.isInvalid()) {
9169 VDecl->setInvalidDecl();
9170 return;
9171 }
Nikola Smiljanic01a75982014-05-29 10:55:11 +00009172 Init = Result.get();
Richard Smith945f8d32013-01-14 22:39:08 +00009173
Richard Smith0cc85782011-12-15 19:20:59 +00009174 // Attach the initializer to the decl.
9175 VDecl->setInit(Init);
9176
9177 if (VDecl->isLocalVarDecl()) {
9178 // C99 6.7.8p4: All the expressions in an initializer for an object that has
9179 // static storage duration shall be constant expressions or string literals.
9180 // C++ does not have this restriction.
Enea Zaffanella1aac5462013-07-22 10:58:26 +00009181 if (!getLangOpts().CPlusPlus && !VDecl->isInvalidDecl()) {
Abramo Bagnara847c6602014-05-22 19:20:46 +00009182 const Expr *Culprit;
Enea Zaffanella1aac5462013-07-22 10:58:26 +00009183 if (VDecl->getStorageClass() == SC_Static)
9184 CheckForConstantInitializer(Init, DclT);
9185 // C89 is stricter than C99 for non-static aggregate types.
9186 // C89 6.5.7p3: All the expressions [...] in an initializer list
9187 // for an object that has aggregate or union type shall be
9188 // constant expressions.
9189 else if (!getLangOpts().C99 && VDecl->getType()->isAggregateType() &&
Enea Zaffanellac7cb48c2013-07-22 19:10:20 +00009190 isa<InitListExpr>(Init) &&
Abramo Bagnara847c6602014-05-22 19:20:46 +00009191 !Init->isConstantInitializer(Context, false, &Culprit))
9192 Diag(Culprit->getExprLoc(),
Enea Zaffanella1aac5462013-07-22 10:58:26 +00009193 diag::ext_aggregate_init_not_constant)
Abramo Bagnara847c6602014-05-22 19:20:46 +00009194 << Culprit->getSourceRange();
Enea Zaffanella1aac5462013-07-22 10:58:26 +00009195 }
Mike Stump11289f42009-09-09 15:08:12 +00009196 } else if (VDecl->isStaticDataMember() &&
Douglas Gregor0c880302009-03-11 23:00:04 +00009197 VDecl->getLexicalDeclContext()->isRecord()) {
9198 // This is an in-class initialization for a static data member, e.g.,
9199 //
9200 // struct S {
9201 // static const int value = 17;
9202 // };
9203
Douglas Gregor0c880302009-03-11 23:00:04 +00009204 // C++ [class.mem]p4:
9205 // A member-declarator can contain a constant-initializer only
9206 // if it declares a static member (9.4) of const integral or
9207 // const enumeration type, see 9.4.2.
Richard Smith2316cd82011-09-29 19:11:37 +00009208 //
Richard Smith0cc85782011-12-15 19:20:59 +00009209 // C++11 [class.static.data]p3:
Richard Smith2316cd82011-09-29 19:11:37 +00009210 // If a non-volatile const static data member is of integral or
9211 // enumeration type, its declaration in the class definition can
9212 // specify a brace-or-equal-initializer in which every initalizer-clause
9213 // that is an assignment-expression is a constant expression. A static
9214 // data member of literal type can be declared in the class definition
9215 // with the constexpr specifier; if so, its declaration shall specify a
9216 // brace-or-equal-initializer in which every initializer-clause that is
9217 // an assignment-expression is a constant expression.
John McCalldb768922010-09-10 23:21:22 +00009218
9219 // Do nothing on dependent types.
Richard Smith0cc85782011-12-15 19:20:59 +00009220 if (DclT->isDependentType()) {
John McCalldb768922010-09-10 23:21:22 +00009221
Richard Smith2316cd82011-09-29 19:11:37 +00009222 // Allow any 'static constexpr' members, whether or not they are of literal
Richard Smith3607ffe2012-02-13 03:54:03 +00009223 // type. We separately check that every constexpr variable is of literal
9224 // type.
Richard Smith2316cd82011-09-29 19:11:37 +00009225 } else if (VDecl->isConstexpr()) {
9226
John McCalldb768922010-09-10 23:21:22 +00009227 // Require constness.
Richard Smith0cc85782011-12-15 19:20:59 +00009228 } else if (!DclT.isConstQualified()) {
John McCalldb768922010-09-10 23:21:22 +00009229 Diag(VDecl->getLocation(), diag::err_in_class_initializer_non_const)
9230 << Init->getSourceRange();
Douglas Gregor0c880302009-03-11 23:00:04 +00009231 VDecl->setInvalidDecl();
John McCalldb768922010-09-10 23:21:22 +00009232
9233 // We allow integer constant expressions in all cases.
Richard Smith0cc85782011-12-15 19:20:59 +00009234 } else if (DclT->isIntegralOrEnumerationType()) {
Chris Lattner9925ec82011-06-14 05:46:29 +00009235 // Check whether the expression is a constant expression.
9236 SourceLocation Loc;
Richard Smith2bf7fdb2013-01-02 11:42:31 +00009237 if (getLangOpts().CPlusPlus11 && DclT.isVolatileQualified())
Richard Smith0cc85782011-12-15 19:20:59 +00009238 // In C++11, a non-constexpr const static data member with an
Richard Smithee6311d2011-09-29 21:28:14 +00009239 // in-class initializer cannot be volatile.
9240 Diag(VDecl->getLocation(), diag::err_in_class_initializer_volatile);
9241 else if (Init->isValueDependent())
Chris Lattner9925ec82011-06-14 05:46:29 +00009242 ; // Nothing to check.
9243 else if (Init->isIntegerConstantExpr(Context, &Loc))
9244 ; // Ok, it's an ICE!
9245 else if (Init->isEvaluatable(Context)) {
9246 // If we can constant fold the initializer through heroics, accept it,
9247 // but report this as a use of an extension for -pedantic.
9248 Diag(Loc, diag::ext_in_class_initializer_non_constant)
9249 << Init->getSourceRange();
9250 } else {
9251 // Otherwise, this is some crazy unknown case. Report the issue at the
9252 // location provided by the isIntegerConstantExpr failed check.
9253 Diag(Loc, diag::err_in_class_initializer_non_constant)
9254 << Init->getSourceRange();
9255 VDecl->setInvalidDecl();
John McCalldb768922010-09-10 23:21:22 +00009256 }
9257
Richard Smith0cc85782011-12-15 19:20:59 +00009258 // We allow foldable floating-point constants as an extension.
9259 } else if (DclT->isFloatingType()) { // also permits complex, which is ok
Richard Smithcf656382013-01-25 04:22:16 +00009260 // In C++98, this is a GNU extension. In C++11, it is not, but we support
9261 // it anyway and provide a fixit to add the 'constexpr'.
9262 if (getLangOpts().CPlusPlus11) {
David Blaikie8505c292013-01-29 22:26:08 +00009263 Diag(VDecl->getLocation(),
9264 diag::ext_in_class_initializer_float_type_cxx11)
9265 << DclT << Init->getSourceRange();
9266 Diag(VDecl->getLocStart(),
9267 diag::note_in_class_initializer_float_type_cxx11)
9268 << FixItHint::CreateInsertion(VDecl->getLocStart(), "constexpr ");
Richard Smithcf656382013-01-25 04:22:16 +00009269 } else {
9270 Diag(VDecl->getLocation(), diag::ext_in_class_initializer_float_type)
9271 << DclT << Init->getSourceRange();
John McCalldb768922010-09-10 23:21:22 +00009272
Richard Smithcf656382013-01-25 04:22:16 +00009273 if (!Init->isValueDependent() && !Init->isEvaluatable(Context)) {
9274 Diag(Init->getExprLoc(), diag::err_in_class_initializer_non_constant)
9275 << Init->getSourceRange();
9276 VDecl->setInvalidDecl();
9277 }
Douglas Gregor0c880302009-03-11 23:00:04 +00009278 }
Richard Smith256336d2011-09-29 23:18:34 +00009279
Richard Smith0cc85782011-12-15 19:20:59 +00009280 // Suggest adding 'constexpr' in C++11 for literal types.
Richard Smithd9f663b2013-04-22 15:31:51 +00009281 } else if (getLangOpts().CPlusPlus11 && DclT->isLiteralType(Context)) {
Richard Smith256336d2011-09-29 23:18:34 +00009282 Diag(VDecl->getLocation(), diag::err_in_class_initializer_literal_type)
Richard Smith0cc85782011-12-15 19:20:59 +00009283 << DclT << Init->getSourceRange()
Richard Smith256336d2011-09-29 23:18:34 +00009284 << FixItHint::CreateInsertion(VDecl->getLocStart(), "constexpr ");
9285 VDecl->setConstexpr(true);
9286
Richard Smith2316cd82011-09-29 19:11:37 +00009287 } else {
9288 Diag(VDecl->getLocation(), diag::err_in_class_initializer_bad_type)
Richard Smith0cc85782011-12-15 19:20:59 +00009289 << DclT << Init->getSourceRange();
Richard Smith2316cd82011-09-29 19:11:37 +00009290 VDecl->setInvalidDecl();
Douglas Gregor0c880302009-03-11 23:00:04 +00009291 }
Steve Naroff08899ff2008-04-15 22:42:06 +00009292 } else if (VDecl->isFileVarDecl()) {
Rafael Espindola6ae7e502013-04-03 19:27:57 +00009293 if (VDecl->getStorageClass() == SC_Extern &&
David Blaikiebbafb8a2012-03-11 07:00:24 +00009294 (!getLangOpts().CPlusPlus ||
Rafael Espindola069ab032013-03-29 07:56:05 +00009295 !(Context.getBaseElementType(VDecl->getType()).isConstQualified() ||
Richard Smith8809a0c2013-09-27 20:14:12 +00009296 VDecl->isExternC())) &&
9297 !isTemplateInstantiation(VDecl->getTemplateSpecializationKind()))
Steve Naroff437b4d82007-09-12 20:13:48 +00009298 Diag(VDecl->getLocation(), diag::warn_extern_init);
Eli Friedman463e5232009-12-22 02:10:53 +00009299
Richard Smith0cc85782011-12-15 19:20:59 +00009300 // C99 6.7.8p4. All file scoped initializers need to be constant.
David Blaikiebbafb8a2012-03-11 07:00:24 +00009301 if (!getLangOpts().CPlusPlus && !VDecl->isInvalidDecl())
Anders Carlsson41e08812008-08-22 05:00:02 +00009302 CheckForConstantInitializer(Init, DclT);
Steve Naroff61091402007-09-12 14:07:44 +00009303 }
Douglas Gregorbeecd582009-04-21 17:11:58 +00009304
Sebastian Redla9351792012-02-11 23:51:47 +00009305 // We will represent direct-initialization similarly to copy-initialization:
9306 // int x(1); -as-> int x = 1;
9307 // ClassType x(a,b,c); -as-> ClassType x = ClassType(a,b,c);
9308 //
9309 // Clients that want to distinguish between the two forms, can check for
9310 // direct initializer using VarDecl::getInitStyle().
9311 // A major benefit is that clients that don't particularly care about which
9312 // exactly form was it (like the CodeGen) can handle both cases without
9313 // special case code.
9314
9315 // C++ 8.5p11:
9316 // The form of initialization (using parentheses or '=') is generally
9317 // insignificant, but does matter when the entity being initialized has a
9318 // class type.
9319 if (CXXDirectInit) {
9320 assert(DirectInit && "Call-style initializer must be direct init.");
9321 VDecl->setInitStyle(VarDecl::CallInit);
9322 } else if (DirectInit) {
9323 // This must be list-initialization. No other way is direct-initialization.
9324 VDecl->setInitStyle(VarDecl::ListInit);
9325 }
9326
John McCall8b7fd8f12011-01-19 11:48:09 +00009327 CheckCompleteVariableDeclaration(VDecl);
Steve Naroff61091402007-09-12 14:07:44 +00009328}
9329
John McCalleae5acb2010-03-31 02:13:20 +00009330/// ActOnInitializerError - Given that there was an error parsing an
9331/// initializer for the given declaration, try to return to some form
9332/// of sanity.
John McCall48871652010-08-21 09:40:31 +00009333void Sema::ActOnInitializerError(Decl *D) {
John McCalleae5acb2010-03-31 02:13:20 +00009334 // Our main concern here is re-establishing invariants like "a
9335 // variable's type is either dependent or complete".
John McCalleae5acb2010-03-31 02:13:20 +00009336 if (!D || D->isInvalidDecl()) return;
9337
9338 VarDecl *VD = dyn_cast<VarDecl>(D);
9339 if (!VD) return;
9340
Richard Smith30482bc2011-02-20 03:19:35 +00009341 // Auto types are meaningless if we can't make sense of the initializer.
Richard Smithb2bc2e62011-02-21 20:05:19 +00009342 if (ParsingInitForAutoVars.count(D)) {
9343 D->setInvalidDecl();
Richard Smith30482bc2011-02-20 03:19:35 +00009344 return;
9345 }
9346
John McCalleae5acb2010-03-31 02:13:20 +00009347 QualType Ty = VD->getType();
9348 if (Ty->isDependentType()) return;
9349
9350 // Require a complete type.
9351 if (RequireCompleteType(VD->getLocation(),
9352 Context.getBaseElementType(Ty),
9353 diag::err_typecheck_decl_incomplete_type)) {
9354 VD->setInvalidDecl();
9355 return;
9356 }
9357
Alp Toker48c7e172014-04-15 16:24:50 +00009358 // Require a non-abstract type.
John McCalleae5acb2010-03-31 02:13:20 +00009359 if (RequireNonAbstractType(VD->getLocation(), Ty,
9360 diag::err_abstract_type_in_decl,
9361 AbstractVariableType)) {
9362 VD->setInvalidDecl();
9363 return;
9364 }
9365
9366 // Don't bother complaining about constructors or destructors,
9367 // though.
9368}
9369
John McCall48871652010-08-21 09:40:31 +00009370void Sema::ActOnUninitializedDecl(Decl *RealDecl,
Richard Smith30482bc2011-02-20 03:19:35 +00009371 bool TypeMayContainAuto) {
Argyrios Kyrtzidis6709e7d2008-11-07 13:01:22 +00009372 // If there is no declaration, there was an error parsing it. Just ignore it.
Craig Topperc3ec1492014-05-26 06:22:03 +00009373 if (!RealDecl)
Argyrios Kyrtzidis6709e7d2008-11-07 13:01:22 +00009374 return;
9375
Douglas Gregor8e1cf602008-10-29 00:13:59 +00009376 if (VarDecl *Var = dyn_cast<VarDecl>(RealDecl)) {
9377 QualType Type = Var->getType();
Douglas Gregorbeecd582009-04-21 17:11:58 +00009378
Richard Smithf0215fe2011-12-25 21:17:58 +00009379 // C++11 [dcl.spec.auto]p3
Richard Smith30482bc2011-02-20 03:19:35 +00009380 if (TypeMayContainAuto && Type->getContainedAutoType()) {
Anders Carlssonae019932009-07-11 00:34:39 +00009381 Diag(Var->getLocation(), diag::err_auto_var_requires_init)
9382 << Var->getDeclName() << Type;
9383 Var->setInvalidDecl();
9384 return;
9385 }
Mike Stump11289f42009-09-09 15:08:12 +00009386
Richard Smithf0215fe2011-12-25 21:17:58 +00009387 // C++11 [class.static.data]p3: A static data member can be declared with
Richard Smith2316cd82011-09-29 19:11:37 +00009388 // the constexpr specifier; if so, its declaration shall specify
9389 // a brace-or-equal-initializer.
Richard Smithf0215fe2011-12-25 21:17:58 +00009390 // C++11 [dcl.constexpr]p1: The constexpr specifier shall be applied only to
9391 // the definition of a variable [...] or the declaration of a static data
9392 // member.
9393 if (Var->isConstexpr() && !Var->isThisDeclarationADefinition()) {
9394 if (Var->isStaticDataMember())
9395 Diag(Var->getLocation(),
9396 diag::err_constexpr_static_mem_var_requires_init)
9397 << Var->getDeclName();
9398 else
9399 Diag(Var->getLocation(), diag::err_invalid_constexpr_var_decl);
Richard Smith2316cd82011-09-29 19:11:37 +00009400 Var->setInvalidDecl();
9401 return;
9402 }
9403
Joey Gouly96b94e62014-01-03 14:16:55 +00009404 // OpenCL v1.1 s6.5.3: variables declared in the constant address space must
9405 // be initialized.
9406 if (!Var->isInvalidDecl() &&
9407 Var->getType().getAddressSpace() == LangAS::opencl_constant &&
Pekka Jaaskelainenb3cdee02014-01-23 16:21:02 +00009408 Var->getStorageClass() != SC_Extern && !Var->getInit()) {
Joey Gouly96b94e62014-01-03 14:16:55 +00009409 Diag(Var->getLocation(), diag::err_opencl_constant_no_init);
9410 Var->setInvalidDecl();
9411 return;
9412 }
9413
Douglas Gregore6565622010-02-09 07:26:29 +00009414 switch (Var->isThisDeclarationADefinition()) {
9415 case VarDecl::Definition:
9416 if (!Var->isStaticDataMember() || !Var->getAnyInitializer())
9417 break;
9418
9419 // We have an out-of-line definition of a static data member
9420 // that has an in-class initializer, so we type-check this like
9421 // a declaration.
9422 //
9423 // Fall through
9424
9425 case VarDecl::DeclarationOnly:
9426 // It's only a declaration.
9427
9428 // Block scope. C99 6.7p7: If an identifier for an object is
9429 // declared with no linkage (C99 6.2.2p6), the type for the
9430 // object shall be complete.
John McCall1c9c3fd2010-10-15 04:57:14 +00009431 if (!Type->isDependentType() && Var->isLocalVarDecl() &&
Rafael Espindola3ae00052013-05-13 00:12:11 +00009432 !Var->hasLinkage() && !Var->isInvalidDecl() &&
Douglas Gregore6565622010-02-09 07:26:29 +00009433 RequireCompleteType(Var->getLocation(), Type,
9434 diag::err_typecheck_decl_incomplete_type))
9435 Var->setInvalidDecl();
9436
9437 // Make sure that the type is not abstract.
9438 if (!Type->isDependentType() && !Var->isInvalidDecl() &&
9439 RequireNonAbstractType(Var->getLocation(), Type,
9440 diag::err_abstract_type_in_decl,
9441 AbstractVariableType))
9442 Var->setInvalidDecl();
Fariborz Jahanian05f4e712012-08-15 18:42:26 +00009443 if (!Type->isDependentType() && !Var->isInvalidDecl() &&
Fariborz Jahanianf85f3382012-08-17 21:44:55 +00009444 Var->getStorageClass() == SC_PrivateExtern) {
Fariborz Jahanian05f4e712012-08-15 18:42:26 +00009445 Diag(Var->getLocation(), diag::warn_private_extern);
Fariborz Jahanianf85f3382012-08-17 21:44:55 +00009446 Diag(Var->getLocation(), diag::note_private_extern);
9447 }
Fariborz Jahanian05f4e712012-08-15 18:42:26 +00009448
Douglas Gregore6565622010-02-09 07:26:29 +00009449 return;
9450
9451 case VarDecl::TentativeDefinition:
9452 // File scope. C99 6.9.2p2: A declaration of an identifier for an
9453 // object that has file scope without an initializer, and without a
9454 // storage-class specifier or with the storage-class specifier "static",
9455 // constitutes a tentative definition. Note: A tentative definition with
9456 // external linkage is valid (C99 6.2.2p5).
9457 if (!Var->isInvalidDecl()) {
9458 if (const IncompleteArrayType *ArrayT
9459 = Context.getAsIncompleteArrayType(Type)) {
9460 if (RequireCompleteType(Var->getLocation(),
9461 ArrayT->getElementType(),
9462 diag::err_illegal_decl_array_incomplete_type))
9463 Var->setInvalidDecl();
John McCall8e7d6562010-08-26 03:08:43 +00009464 } else if (Var->getStorageClass() == SC_Static) {
Douglas Gregore6565622010-02-09 07:26:29 +00009465 // C99 6.9.2p3: If the declaration of an identifier for an object is
9466 // a tentative definition and has internal linkage (C99 6.2.2p3), the
9467 // declared type shall not be an incomplete type.
9468 // NOTE: code such as the following
9469 // static struct s;
9470 // struct s { int a; };
9471 // is accepted by gcc. Hence here we issue a warning instead of
9472 // an error and we do not invalidate the static declaration.
9473 // NOTE: to avoid multiple warnings, only check the first declaration.
Rafael Espindola3f9e4442013-10-19 02:13:21 +00009474 if (Var->isFirstDecl())
Douglas Gregore6565622010-02-09 07:26:29 +00009475 RequireCompleteType(Var->getLocation(), Type,
9476 diag::ext_typecheck_decl_incomplete_type);
9477 }
9478 }
9479
9480 // Record the tentative definition; we're done.
9481 if (!Var->isInvalidDecl())
9482 TentativeDefinitions.push_back(Var);
9483 return;
9484 }
9485
9486 // Provide a specific diagnostic for uninitialized variable
9487 // definitions with incomplete array type.
9488 if (Type->isIncompleteArrayType()) {
Sebastian Redl10600672009-11-05 19:47:47 +00009489 Diag(Var->getLocation(),
9490 diag::err_typecheck_incomplete_array_needs_initializer);
9491 Var->setInvalidDecl();
9492 return;
9493 }
9494
John McCalla755f0f2010-08-01 01:25:24 +00009495 // Provide a specific diagnostic for uninitialized variable
9496 // definitions with reference type.
9497 if (Type->isReferenceType()) {
9498 Diag(Var->getLocation(), diag::err_reference_var_requires_init)
9499 << Var->getDeclName()
9500 << SourceRange(Var->getLocation(), Var->getLocation());
9501 Var->setInvalidDecl();
9502 return;
9503 }
Douglas Gregore6565622010-02-09 07:26:29 +00009504
9505 // Do not attempt to type-check the default initializer for a
9506 // variable with dependent type.
9507 if (Type->isDependentType())
Douglas Gregor86d142a2009-10-08 07:24:58 +00009508 return;
Douglas Gregor5d3507d2009-09-09 23:08:42 +00009509
Douglas Gregore6565622010-02-09 07:26:29 +00009510 if (Var->isInvalidDecl())
9511 return;
Douglas Gregorc99f1552009-12-03 18:33:45 +00009512
David Majnemer837d5de2014-07-09 17:15:52 +00009513 if (!Var->hasAttr<AliasAttr>()) {
9514 if (RequireCompleteType(Var->getLocation(),
9515 Context.getBaseElementType(Type),
9516 diag::err_typecheck_decl_incomplete_type)) {
9517 Var->setInvalidDecl();
9518 return;
9519 }
David Majnemere9624ed2015-02-08 10:55:14 +00009520 } else {
9521 return;
Douglas Gregorc28b57d2008-11-03 20:45:27 +00009522 }
Douglas Gregor8e1cf602008-10-29 00:13:59 +00009523
Douglas Gregore6565622010-02-09 07:26:29 +00009524 // The variable can not have an abstract class type.
9525 if (RequireNonAbstractType(Var->getLocation(), Type,
9526 diag::err_abstract_type_in_decl,
9527 AbstractVariableType)) {
9528 Var->setInvalidDecl();
9529 return;
9530 }
9531
Douglas Gregor9574af62011-05-21 17:52:48 +00009532 // Check for jumps past the implicit initializer. C++0x
9533 // clarifies that this applies to a "variable with automatic
9534 // storage duration", not a "local variable".
Richard Smithfe2750d2011-10-20 21:42:12 +00009535 // C++11 [stmt.dcl]p3
Douglas Gregor9574af62011-05-21 17:52:48 +00009536 // A program that jumps from a point where a variable with automatic
9537 // storage duration is not in scope to a point where it is in scope is
9538 // ill-formed unless the variable has scalar type, class type with a
9539 // trivial default constructor and a trivial destructor, a cv-qualified
9540 // version of one of these types, or an array of one of the preceding
9541 // types and is declared without an initializer.
David Blaikiebbafb8a2012-03-11 07:00:24 +00009542 if (getLangOpts().CPlusPlus && Var->hasLocalStorage()) {
Douglas Gregor9574af62011-05-21 17:52:48 +00009543 if (const RecordType *Record
9544 = Context.getBaseElementType(Type)->getAs<RecordType>()) {
Alexis Hunt466627c2011-05-11 22:50:12 +00009545 CXXRecordDecl *CXXRecord = cast<CXXRecordDecl>(Record->getDecl());
Richard Smithfe2750d2011-10-20 21:42:12 +00009546 // Mark the function for further checking even if the looser rules of
9547 // C++11 do not require such checks, so that we can diagnose
9548 // incompatibilities with C++98.
9549 if (!CXXRecord->isPOD())
Alexis Hunt466627c2011-05-11 22:50:12 +00009550 getCurFunction()->setHasBranchProtectedScope();
9551 }
Douglas Gregore6565622010-02-09 07:26:29 +00009552 }
Douglas Gregor9574af62011-05-21 17:52:48 +00009553
9554 // C++03 [dcl.init]p9:
9555 // If no initializer is specified for an object, and the
9556 // object is of (possibly cv-qualified) non-POD class type (or
9557 // array thereof), the object shall be default-initialized; if
9558 // the object is of const-qualified type, the underlying class
9559 // type shall have a user-declared default
9560 // constructor. Otherwise, if no initializer is specified for
9561 // a non- static object, the object and its subobjects, if
9562 // any, have an indeterminate initial value); if the object
9563 // or any of its subobjects are of const-qualified type, the
9564 // program is ill-formed.
9565 // C++0x [dcl.init]p11:
9566 // If no initializer is specified for an object, the object is
9567 // default-initialized; [...].
9568 InitializedEntity Entity = InitializedEntity::InitializeVariable(Var);
9569 InitializationKind Kind
9570 = InitializationKind::CreateDefault(Var->getLocation());
Dmitri Gribenko78852e92013-05-05 20:40:26 +00009571
9572 InitializationSequence InitSeq(*this, Entity, Kind, None);
9573 ExprResult Init = InitSeq.Perform(*this, Entity, Kind, None);
Douglas Gregor9574af62011-05-21 17:52:48 +00009574 if (Init.isInvalid())
9575 Var->setInvalidDecl();
Sebastian Redla9351792012-02-11 23:51:47 +00009576 else if (Init.get()) {
Douglas Gregor9574af62011-05-21 17:52:48 +00009577 Var->setInit(MaybeCreateExprWithCleanups(Init.get()));
Sebastian Redla9351792012-02-11 23:51:47 +00009578 // This is important for template substitution.
9579 Var->setInitStyle(VarDecl::CallInit);
9580 }
Douglas Gregor589973b2010-03-08 02:45:10 +00009581
John McCall8b7fd8f12011-01-19 11:48:09 +00009582 CheckCompleteVariableDeclaration(Var);
Douglas Gregor8e1cf602008-10-29 00:13:59 +00009583 }
9584}
9585
Richard Smith02e85f32011-04-14 22:09:26 +00009586void Sema::ActOnCXXForRangeDecl(Decl *D) {
9587 VarDecl *VD = dyn_cast<VarDecl>(D);
9588 if (!VD) {
9589 Diag(D->getLocation(), diag::err_for_range_decl_must_be_var);
9590 D->setInvalidDecl();
9591 return;
9592 }
9593
9594 VD->setCXXForRangeDecl(true);
9595
9596 // for-range-declaration cannot be given a storage class specifier.
9597 int Error = -1;
Rafael Espindola6ae7e502013-04-03 19:27:57 +00009598 switch (VD->getStorageClass()) {
Richard Smith02e85f32011-04-14 22:09:26 +00009599 case SC_None:
9600 break;
9601 case SC_Extern:
9602 Error = 0;
9603 break;
9604 case SC_Static:
9605 Error = 1;
9606 break;
9607 case SC_PrivateExtern:
9608 Error = 2;
9609 break;
9610 case SC_Auto:
9611 Error = 3;
9612 break;
9613 case SC_Register:
9614 Error = 4;
9615 break;
Peter Collingbourne2dbb7082011-09-19 21:14:35 +00009616 case SC_OpenCLWorkGroupLocal:
Peter Collingbourne9a8f1532011-09-20 12:40:26 +00009617 llvm_unreachable("Unexpected storage class");
Richard Smith02e85f32011-04-14 22:09:26 +00009618 }
Richard Smith02e85f32011-04-14 22:09:26 +00009619 if (Error != -1) {
9620 Diag(VD->getOuterLocStart(), diag::err_for_range_storage_class)
9621 << VD->getDeclName() << Error;
9622 D->setInvalidDecl();
9623 }
9624}
9625
Richard Smith955bf012014-06-19 11:42:00 +00009626StmtResult
9627Sema::ActOnCXXForRangeIdentifier(Scope *S, SourceLocation IdentLoc,
9628 IdentifierInfo *Ident,
9629 ParsedAttributes &Attrs,
9630 SourceLocation AttrEnd) {
9631 // C++1y [stmt.iter]p1:
9632 // A range-based for statement of the form
9633 // for ( for-range-identifier : for-range-initializer ) statement
9634 // is equivalent to
9635 // for ( auto&& for-range-identifier : for-range-initializer ) statement
9636 DeclSpec DS(Attrs.getPool().getFactory());
9637
9638 const char *PrevSpec;
9639 unsigned DiagID;
9640 DS.SetTypeSpecType(DeclSpec::TST_auto, IdentLoc, PrevSpec, DiagID,
9641 getPrintingPolicy());
9642
9643 Declarator D(DS, Declarator::ForContext);
9644 D.SetIdentifier(Ident, IdentLoc);
9645 D.takeAttributes(Attrs, AttrEnd);
9646
9647 ParsedAttributes EmptyAttrs(Attrs.getPool().getFactory());
9648 D.AddTypeInfo(DeclaratorChunk::getReference(0, IdentLoc, /*lvalue*/false),
9649 EmptyAttrs, IdentLoc);
9650 Decl *Var = ActOnDeclarator(S, D);
9651 cast<VarDecl>(Var)->setCXXForRangeDecl(true);
9652 FinalizeDeclaration(Var);
9653 return ActOnDeclStmt(FinalizeDeclaratorGroup(S, DS, Var), IdentLoc,
9654 AttrEnd.isValid() ? AttrEnd : IdentLoc);
9655}
9656
John McCall8b7fd8f12011-01-19 11:48:09 +00009657void Sema::CheckCompleteVariableDeclaration(VarDecl *var) {
9658 if (var->isInvalidDecl()) return;
9659
John McCall31168b02011-06-15 23:02:42 +00009660 // In ARC, don't allow jumps past the implicit initialization of a
9661 // local retaining variable.
David Blaikiebbafb8a2012-03-11 07:00:24 +00009662 if (getLangOpts().ObjCAutoRefCount &&
John McCall31168b02011-06-15 23:02:42 +00009663 var->hasLocalStorage()) {
9664 switch (var->getType().getObjCLifetime()) {
9665 case Qualifiers::OCL_None:
9666 case Qualifiers::OCL_ExplicitNone:
9667 case Qualifiers::OCL_Autoreleasing:
9668 break;
9669
9670 case Qualifiers::OCL_Weak:
9671 case Qualifiers::OCL_Strong:
9672 getCurFunction()->setHasBranchProtectedScope();
9673 break;
9674 }
9675 }
9676
John McCall8a4e2e42014-01-29 08:33:09 +00009677 // Warn about externally-visible variables being defined without a
9678 // prior declaration. We only want to do this for global
9679 // declarations, but we also specifically need to avoid doing it for
9680 // class members because the linkage of an anonymous class can
9681 // change if it's later given a typedef name.
Eli Friedman7d14b3c2012-10-23 20:19:32 +00009682 if (var->isThisDeclarationADefinition() &&
John McCall8a4e2e42014-01-29 08:33:09 +00009683 var->getDeclContext()->getRedeclContext()->isFileContext() &&
Eli Friedman1f5d8882013-09-24 23:10:08 +00009684 var->isExternallyVisible() && var->hasLinkage() &&
Alp Tokerd4a3f0e2014-06-15 23:30:39 +00009685 !getDiagnostics().isIgnored(diag::warn_missing_variable_declarations,
9686 var->getLocation())) {
Eli Friedman7d14b3c2012-10-23 20:19:32 +00009687 // Find a previous declaration that's not a definition.
9688 VarDecl *prev = var->getPreviousDecl();
9689 while (prev && prev->isThisDeclarationADefinition())
9690 prev = prev->getPreviousDecl();
9691
9692 if (!prev)
9693 Diag(var->getLocation(), diag::warn_missing_variable_declarations) << var;
9694 }
9695
Reid Kleckner92fc0172014-04-30 17:10:18 +00009696 if (var->getTLSKind() == VarDecl::TLS_Static) {
Abramo Bagnara847c6602014-05-22 19:20:46 +00009697 const Expr *Culprit;
Reid Kleckner92fc0172014-04-30 17:10:18 +00009698 if (var->getType().isDestructedType()) {
9699 // GNU C++98 edits for __thread, [basic.start.term]p3:
9700 // The type of an object with thread storage duration shall not
9701 // have a non-trivial destructor.
9702 Diag(var->getLocation(), diag::err_thread_nontrivial_dtor);
9703 if (getLangOpts().CPlusPlus11)
9704 Diag(var->getLocation(), diag::note_use_thread_local);
9705 } else if (getLangOpts().CPlusPlus && var->hasInit() &&
9706 !var->getInit()->isConstantInitializer(
Abramo Bagnara847c6602014-05-22 19:20:46 +00009707 Context, var->getType()->isReferenceType(), &Culprit)) {
Reid Kleckner92fc0172014-04-30 17:10:18 +00009708 // GNU C++98 edits for __thread, [basic.start.init]p4:
9709 // An object of thread storage duration shall not require dynamic
9710 // initialization.
9711 // FIXME: Need strict checking here.
Abramo Bagnara847c6602014-05-22 19:20:46 +00009712 Diag(Culprit->getExprLoc(), diag::err_thread_dynamic_init)
9713 << Culprit->getSourceRange();
Reid Kleckner92fc0172014-04-30 17:10:18 +00009714 if (getLangOpts().CPlusPlus11)
9715 Diag(var->getLocation(), diag::note_use_thread_local);
9716 }
9717
Richard Smith6ea1a4d2013-04-14 20:11:31 +00009718 }
9719
Reid Kleckner2a133222015-03-04 23:39:17 +00009720 // Apply section attributes and pragmas to global variables.
9721 bool GlobalStorage = var->hasGlobalStorage();
9722 if (GlobalStorage && var->isThisDeclarationADefinition() &&
Warren Huntc3b18962014-04-08 22:30:47 +00009723 ActiveTemplateInstantiations.empty()) {
9724 PragmaStack<StringLiteral *> *Stack = nullptr;
Hans Wennborg899ded92014-10-16 20:52:46 +00009725 int SectionFlags = ASTContext::PSF_Implicit | ASTContext::PSF_Read;
Warren Huntc3b18962014-04-08 22:30:47 +00009726 if (var->getType().isConstQualified())
9727 Stack = &ConstSegStack;
9728 else if (!var->getInit()) {
9729 Stack = &BSSSegStack;
Hans Wennborg899ded92014-10-16 20:52:46 +00009730 SectionFlags |= ASTContext::PSF_Write;
Warren Huntc3b18962014-04-08 22:30:47 +00009731 } else {
9732 Stack = &DataSegStack;
Hans Wennborg899ded92014-10-16 20:52:46 +00009733 SectionFlags |= ASTContext::PSF_Write;
Warren Huntc3b18962014-04-08 22:30:47 +00009734 }
Reid Kleckner2a133222015-03-04 23:39:17 +00009735 if (Stack->CurrentValue && !var->hasAttr<SectionAttr>()) {
9736 var->addAttr(SectionAttr::CreateImplicit(
9737 Context, SectionAttr::Declspec_allocate,
9738 Stack->CurrentValue->getString(), Stack->CurrentPragmaLocation));
9739 }
Warren Huntc3b18962014-04-08 22:30:47 +00009740 if (const SectionAttr *SA = var->getAttr<SectionAttr>())
9741 if (UnifySection(SA->getName(), SectionFlags, var))
9742 var->dropAttr<SectionAttr>();
Reid Kleckner1a711b12014-07-22 00:53:05 +00009743
9744 // Apply the init_seg attribute if this has an initializer. If the
9745 // initializer turns out to not be dynamic, we'll end up ignoring this
9746 // attribute.
9747 if (CurInitSeg && var->getInit())
9748 var->addAttr(InitSegAttr::CreateImplicit(Context, CurInitSeg->getString(),
9749 CurInitSegLoc));
Warren Huntc3b18962014-04-08 22:30:47 +00009750 }
9751
John McCall8b7fd8f12011-01-19 11:48:09 +00009752 // All the following checks are C++ only.
David Blaikiebbafb8a2012-03-11 07:00:24 +00009753 if (!getLangOpts().CPlusPlus) return;
John McCall8b7fd8f12011-01-19 11:48:09 +00009754
Richard Smithde63d362012-11-09 23:03:14 +00009755 QualType type = var->getType();
9756 if (type->isDependentType()) return;
John McCall8b7fd8f12011-01-19 11:48:09 +00009757
9758 // __block variables might require us to capture a copy-initializer.
9759 if (var->hasAttr<BlocksAttr>()) {
9760 // It's currently invalid to ever have a __block variable with an
9761 // array type; should we diagnose that here?
9762
9763 // Regardless, we don't want to ignore array nesting when
9764 // constructing this copy.
John McCall8b7fd8f12011-01-19 11:48:09 +00009765 if (type->isStructureOrClassType()) {
John McCalleaef89b2013-03-22 02:10:40 +00009766 EnterExpressionEvaluationContext scope(*this, PotentiallyEvaluated);
John McCall8b7fd8f12011-01-19 11:48:09 +00009767 SourceLocation poi = var->getLocation();
John McCall113bee02012-03-10 09:33:50 +00009768 Expr *varRef =new (Context) DeclRefExpr(var, false, type, VK_LValue, poi);
Douglas Gregorca006452013-03-07 22:38:24 +00009769 ExprResult result
9770 = PerformMoveOrCopyInitialization(
9771 InitializedEntity::InitializeBlock(poi, type, false),
9772 var, var->getType(), varRef, /*AllowNRVO=*/true);
John McCall8b7fd8f12011-01-19 11:48:09 +00009773 if (!result.isInvalid()) {
9774 result = MaybeCreateExprWithCleanups(result);
Nikola Smiljanic01a75982014-05-29 10:55:11 +00009775 Expr *init = result.getAs<Expr>();
John McCall8b7fd8f12011-01-19 11:48:09 +00009776 Context.setBlockVarCopyInits(var, init);
9777 }
9778 }
9779 }
9780
Richard Smitheda3c842011-11-07 22:16:17 +00009781 Expr *Init = var->getInit();
Reid Kleckner2a133222015-03-04 23:39:17 +00009782 bool IsGlobal = GlobalStorage && !var->isStaticLocal();
Richard Smithde63d362012-11-09 23:03:14 +00009783 QualType baseType = Context.getBaseElementType(type);
Richard Smitheda3c842011-11-07 22:16:17 +00009784
Richard Smithbf830092012-10-29 18:26:47 +00009785 if (!var->getDeclContext()->isDependentContext() &&
9786 Init && !Init->isValueDependent()) {
Richard Smithd0b4dd62011-12-19 06:19:21 +00009787 if (IsGlobal && !var->isConstexpr() &&
Alp Tokerd4a3f0e2014-06-15 23:30:39 +00009788 !getDiagnostics().isIgnored(diag::warn_global_constructor,
9789 var->getLocation())) {
Eli Friedman4c27ac22013-07-16 22:40:53 +00009790 // Warn about globals which don't have a constant initializer. Don't
9791 // warn about globals with a non-trivial destructor because we already
9792 // warned about them.
9793 CXXRecordDecl *RD = baseType->getAsCXXRecordDecl();
9794 if (!(RD && !RD->hasTrivialDestructor()) &&
9795 !Init->isConstantInitializer(Context, baseType->isReferenceType()))
9796 Diag(var->getLocation(), diag::warn_global_constructor)
9797 << Init->getSourceRange();
9798 }
Richard Smithd0b4dd62011-12-19 06:19:21 +00009799
Richard Smithd0b4dd62011-12-19 06:19:21 +00009800 if (var->isConstexpr()) {
Dmitri Gribenkof8579502013-01-12 19:30:44 +00009801 SmallVector<PartialDiagnosticAt, 8> Notes;
Richard Smithd0b4dd62011-12-19 06:19:21 +00009802 if (!var->evaluateValue(Notes) || !var->isInitICE()) {
9803 SourceLocation DiagLoc = var->getLocation();
9804 // If the note doesn't add any useful information other than a source
9805 // location, fold it into the primary diagnostic.
9806 if (Notes.size() == 1 && Notes[0].second.getDiagID() ==
9807 diag::note_invalid_subexpr_in_const_expr) {
9808 DiagLoc = Notes[0].first;
9809 Notes.clear();
9810 }
9811 Diag(DiagLoc, diag::err_constexpr_var_requires_const_init)
9812 << var << Init->getSourceRange();
9813 for (unsigned I = 0, N = Notes.size(); I != N; ++I)
9814 Diag(Notes[I].first, Notes[I].second);
9815 }
Daniel Dunbar9d355812012-03-09 01:51:51 +00009816 } else if (var->isUsableInConstantExpressions(Context)) {
Richard Smithd0b4dd62011-12-19 06:19:21 +00009817 // Check whether the initializer of a const variable of integral or
9818 // enumeration type is an ICE now, since we can't tell whether it was
9819 // initialized by a constant expression if we check later.
9820 var->checkInitIsICE();
9821 }
Richard Smitheda3c842011-11-07 22:16:17 +00009822 }
John McCall8b7fd8f12011-01-19 11:48:09 +00009823
9824 // Require the destructor.
9825 if (const RecordType *recordType = baseType->getAs<RecordType>())
9826 FinalizeVarWithDestructor(var, recordType);
9827}
9828
Paul Robinsond30e2ee2015-07-14 20:52:32 +00009829/// \brief Determines if a variable's alignment is dependent.
9830static bool hasDependentAlignment(VarDecl *VD) {
9831 if (VD->getType()->isDependentType())
9832 return true;
9833 for (auto *I : VD->specific_attrs<AlignedAttr>())
9834 if (I->isAlignmentDependent())
9835 return true;
9836 return false;
9837}
9838
Richard Smithb2bc2e62011-02-21 20:05:19 +00009839/// FinalizeDeclaration - called by ParseDeclarationAfterDeclarator to perform
9840/// any semantic actions necessary after any initializer has been attached.
9841void
9842Sema::FinalizeDeclaration(Decl *ThisDecl) {
9843 // Note that we are no longer parsing the initializer for this declaration.
9844 ParsingInitForAutoVars.erase(ThisDecl);
Dmitri Gribenkoe4a5a902012-08-17 00:08:38 +00009845
Rafael Espindoladb1a4772013-02-22 17:59:16 +00009846 VarDecl *VD = dyn_cast_or_null<VarDecl>(ThisDecl);
Rafael Espindola60470f12013-01-03 04:05:19 +00009847 if (!VD)
9848 return;
9849
Nico Rieckf8e8b5f2014-01-21 23:54:36 +00009850 checkAttributesAfterMerging(*this, *VD);
9851
Paul Robinsond30e2ee2015-07-14 20:52:32 +00009852 // Perform TLS alignment check here after attributes attached to the variable
9853 // which may affect the alignment have been processed. Only perform the check
9854 // if the target has a maximum TLS alignment (zero means no constraints).
9855 if (unsigned MaxAlign = Context.getTargetInfo().getMaxTLSAlign()) {
9856 // Protect the check so that it's not performed on dependent types and
9857 // dependent alignments (we can't determine the alignment in that case).
9858 if (VD->getTLSKind() && !hasDependentAlignment(VD)) {
9859 CharUnits MaxAlignChars = Context.toCharUnitsFromBits(MaxAlign);
9860 if (Context.getDeclAlign(VD) > MaxAlignChars) {
9861 Diag(VD->getLocation(), diag::err_tls_var_aligned_over_maximum)
9862 << (unsigned)Context.getDeclAlign(VD).getQuantity() << VD
9863 << (unsigned)MaxAlignChars.getQuantity();
9864 }
9865 }
9866 }
9867
Hans Wennborgef2272c2014-06-18 15:55:13 +00009868 // Static locals inherit dll attributes from their function.
9869 if (VD->isStaticLocal()) {
9870 if (FunctionDecl *FD =
Richard Trieuf98341e2014-08-22 01:16:44 +00009871 dyn_cast_or_null<FunctionDecl>(VD->getParentFunctionOrMethod())) {
Hans Wennborgef2272c2014-06-18 15:55:13 +00009872 if (Attr *A = getDLLAttr(FD)) {
9873 auto *NewAttr = cast<InheritableAttr>(A->clone(getASTContext()));
9874 NewAttr->setInherited(true);
9875 VD->addAttr(NewAttr);
9876 }
9877 }
9878 }
9879
David Majnemer5da21da2014-10-04 06:51:54 +00009880 // Grab the dllimport or dllexport attribute off of the VarDecl.
9881 const InheritableAttr *DLLAttr = getDLLAttr(VD);
9882
Nico Rieck078d2f82014-05-29 16:50:20 +00009883 // Imported static data members cannot be defined out-of-line.
David Majnemer5da21da2014-10-04 06:51:54 +00009884 if (const auto *IA = dyn_cast_or_null<DLLImportAttr>(DLLAttr)) {
Nico Rieck078d2f82014-05-29 16:50:20 +00009885 if (VD->isStaticDataMember() && VD->isOutOfLine() &&
9886 VD->isThisDeclarationADefinition()) {
Hans Wennborge9af3162014-06-04 00:18:41 +00009887 // We allow definitions of dllimport class template static data members
9888 // with a warning.
Hans Wennborgcd959222014-06-09 18:30:28 +00009889 CXXRecordDecl *Context =
9890 cast<CXXRecordDecl>(VD->getFirstDecl()->getDeclContext());
Hans Wennborge9af3162014-06-04 00:18:41 +00009891 bool IsClassTemplateMember =
Hans Wennborgcd959222014-06-09 18:30:28 +00009892 isa<ClassTemplatePartialSpecializationDecl>(Context) ||
9893 Context->getDescribedClassTemplate();
Hans Wennborge9af3162014-06-04 00:18:41 +00009894
Nico Rieck078d2f82014-05-29 16:50:20 +00009895 Diag(VD->getLocation(),
Hans Wennborge9af3162014-06-04 00:18:41 +00009896 IsClassTemplateMember
9897 ? diag::warn_attribute_dllimport_static_field_definition
9898 : diag::err_attribute_dllimport_static_field_definition);
Nico Rieck078d2f82014-05-29 16:50:20 +00009899 Diag(IA->getLocation(), diag::note_attribute);
Hans Wennborge9af3162014-06-04 00:18:41 +00009900 if (!IsClassTemplateMember)
9901 VD->setInvalidDecl();
Nico Rieck078d2f82014-05-29 16:50:20 +00009902 }
9903 }
9904
David Majnemer5da21da2014-10-04 06:51:54 +00009905 // dllimport/dllexport variables cannot be thread local, their TLS index
9906 // isn't exported with the variable.
9907 if (DLLAttr && VD->getTLSKind()) {
9908 Diag(VD->getLocation(), diag::err_attribute_dll_thread_local) << VD
9909 << DLLAttr;
9910 VD->setInvalidDecl();
9911 }
9912
Rafael Espindola87198cd2013-08-16 23:18:50 +00009913 if (UsedAttr *Attr = VD->getAttr<UsedAttr>()) {
9914 if (!Attr->isInherited() && !VD->isThisDeclarationADefinition()) {
Aaron Ballman3e424b52013-12-26 18:30:57 +00009915 Diag(Attr->getLocation(), diag::warn_attribute_ignored) << Attr;
Rafael Espindola87198cd2013-08-16 23:18:50 +00009916 VD->dropAttr<UsedAttr>();
9917 }
9918 }
9919
Rafael Espindoladb1a4772013-02-22 17:59:16 +00009920 const DeclContext *DC = VD->getDeclContext();
9921 // If there's a #pragma GCC visibility in scope, and this isn't a class
9922 // member, set the visibility of this variable.
John McCall8a4e2e42014-01-29 08:33:09 +00009923 if (DC->getRedeclContext()->isFileContext() && VD->isExternallyVisible())
Rafael Espindoladb1a4772013-02-22 17:59:16 +00009924 AddPushedVisibilityAttribute(VD);
9925
Richard Smithc3926172014-04-02 18:28:36 +00009926 // FIXME: Warn on unused templates.
Richard Smith6c6ef822014-04-25 19:21:40 +00009927 if (VD->isFileVarDecl() && !VD->getDescribedVarTemplate() &&
9928 !isa<VarTemplatePartialSpecializationDecl>(VD))
Rafael Espindolad2ecc132013-01-03 04:29:20 +00009929 MarkUnusedFileScopedDecl(VD);
9930
Dmitri Gribenkoe4a5a902012-08-17 00:08:38 +00009931 // Now we have parsed the initializer and can update the table of magic
9932 // tag values.
Rafael Espindola60470f12013-01-03 04:05:19 +00009933 if (!VD->hasAttr<TypeTagForDatatypeAttr>() ||
9934 !VD->getType()->isIntegralOrEnumerationType())
9935 return;
9936
Aaron Ballmanbe22bcb2014-03-10 17:08:28 +00009937 for (const auto *I : ThisDecl->specific_attrs<TypeTagForDatatypeAttr>()) {
Rafael Espindola60470f12013-01-03 04:05:19 +00009938 const Expr *MagicValueExpr = VD->getInit();
9939 if (!MagicValueExpr) {
9940 continue;
Dmitri Gribenkoe4a5a902012-08-17 00:08:38 +00009941 }
Rafael Espindola60470f12013-01-03 04:05:19 +00009942 llvm::APSInt MagicValueInt;
9943 if (!MagicValueExpr->isIntegerConstantExpr(MagicValueInt, Context)) {
9944 Diag(I->getRange().getBegin(),
9945 diag::err_type_tag_for_datatype_not_ice)
9946 << LangOpts.CPlusPlus << MagicValueExpr->getSourceRange();
9947 continue;
9948 }
9949 if (MagicValueInt.getActiveBits() > 64) {
9950 Diag(I->getRange().getBegin(),
9951 diag::err_type_tag_for_datatype_too_large)
9952 << LangOpts.CPlusPlus << MagicValueExpr->getSourceRange();
9953 continue;
9954 }
9955 uint64_t MagicValue = MagicValueInt.getZExtValue();
9956 RegisterTypeTagForDatatype(I->getArgumentKind(),
9957 MagicValue,
9958 I->getMatchingCType(),
9959 I->getLayoutCompatible(),
9960 I->getMustBeNull());
Dmitri Gribenkoe4a5a902012-08-17 00:08:38 +00009961 }
Richard Smithb2bc2e62011-02-21 20:05:19 +00009962}
9963
Rafael Espindolaab417692013-07-09 12:05:01 +00009964Sema::DeclGroupPtrTy Sema::FinalizeDeclaratorGroup(Scope *S, const DeclSpec &DS,
9965 ArrayRef<Decl *> Group) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00009966 SmallVector<Decl*, 8> Decls;
Eli Friedman55b9ecb2009-05-29 01:49:24 +00009967
9968 if (DS.isTypeSpecOwned())
John McCallba7bf592010-08-24 05:47:05 +00009969 Decls.push_back(DS.getRepAsDecl());
Eli Friedman55b9ecb2009-05-29 01:49:24 +00009970
Craig Topperc3ec1492014-05-26 06:22:03 +00009971 DeclaratorDecl *FirstDeclaratorInGroup = nullptr;
Rafael Espindolaab417692013-07-09 12:05:01 +00009972 for (unsigned i = 0, e = Group.size(); i != e; ++i)
David Majnemer50ce8352013-09-17 23:57:10 +00009973 if (Decl *D = Group[i]) {
9974 if (DeclaratorDecl *DD = dyn_cast<DeclaratorDecl>(D))
9975 if (!FirstDeclaratorInGroup)
9976 FirstDeclaratorInGroup = DD;
Richard Smith2abf6762011-02-23 00:37:57 +00009977 Decls.push_back(D);
David Majnemer50ce8352013-09-17 23:57:10 +00009978 }
Richard Smith2abf6762011-02-23 00:37:57 +00009979
Eli Friedman3b7d46c2013-07-10 00:30:46 +00009980 if (DeclSpec::isDeclRep(DS.getTypeSpecType())) {
David Majnemer50ce8352013-09-17 23:57:10 +00009981 if (TagDecl *Tag = dyn_cast_or_null<TagDecl>(DS.getRepAsDecl())) {
David Majnemerf9bde282015-03-11 06:45:39 +00009982 handleTagNumbering(Tag, S);
David Majnemer50ce8352013-09-17 23:57:10 +00009983 if (!Tag->hasNameForLinkage() && !Tag->hasDeclaratorForAnonDecl())
9984 Tag->setDeclaratorForAnonDecl(FirstDeclaratorInGroup);
9985 }
Eli Friedman3b7d46c2013-07-10 00:30:46 +00009986 }
David Blaikie095deba2012-11-14 01:52:05 +00009987
Rafael Espindolaab417692013-07-09 12:05:01 +00009988 return BuildDeclaratorGroup(Decls, DS.containsPlaceholderType());
Richard Smith2abf6762011-02-23 00:37:57 +00009989}
9990
9991/// BuildDeclaratorGroup - convert a list of declarations into a declaration
9992/// group, performing any necessary semantic checking.
9993Sema::DeclGroupPtrTy
Craig Toppere3d2ecbe2014-06-28 23:22:33 +00009994Sema::BuildDeclaratorGroup(MutableArrayRef<Decl *> Group,
Richard Smith2abf6762011-02-23 00:37:57 +00009995 bool TypeMayContainAuto) {
Richard Smith30482bc2011-02-20 03:19:35 +00009996 // C++0x [dcl.spec.auto]p7:
9997 // If the type deduced for the template parameter U is not the same in each
9998 // deduction, the program is ill-formed.
9999 // FIXME: When initializer-list support is added, a distinction is needed
10000 // between the deduced type U and the deduced type which 'auto' stands for.
10001 // auto a = 0, b = { 1, 2, 3 };
10002 // is legal because the deduced type U is 'int' in both cases.
Rafael Espindolaab417692013-07-09 12:05:01 +000010003 if (TypeMayContainAuto && Group.size() > 1) {
Richard Smith30482bc2011-02-20 03:19:35 +000010004 QualType Deduced;
10005 CanQualType DeducedCanon;
Craig Topperc3ec1492014-05-26 06:22:03 +000010006 VarDecl *DeducedDecl = nullptr;
Rafael Espindolaab417692013-07-09 12:05:01 +000010007 for (unsigned i = 0, e = Group.size(); i != e; ++i) {
Richard Smith30482bc2011-02-20 03:19:35 +000010008 if (VarDecl *D = dyn_cast<VarDecl>(Group[i])) {
10009 AutoType *AT = D->getType()->getContainedAutoType();
Richard Smith2abf6762011-02-23 00:37:57 +000010010 // Don't reissue diagnostics when instantiating a template.
10011 if (AT && D->isInvalidDecl())
10012 break;
Richard Smith27d807c2013-04-30 13:56:41 +000010013 QualType U = AT ? AT->getDeducedType() : QualType();
10014 if (!U.isNull()) {
Richard Smith30482bc2011-02-20 03:19:35 +000010015 CanQualType UCanon = Context.getCanonicalType(U);
10016 if (Deduced.isNull()) {
10017 Deduced = U;
10018 DeducedCanon = UCanon;
10019 DeducedDecl = D;
10020 } else if (DeducedCanon != UCanon) {
Richard Smith2abf6762011-02-23 00:37:57 +000010021 Diag(D->getTypeSourceInfo()->getTypeLoc().getBeginLoc(),
10022 diag::err_auto_different_deductions)
Richard Smith489e4e02013-05-04 04:19:27 +000010023 << (AT->isDecltypeAuto() ? 1 : 0)
Richard Smith30482bc2011-02-20 03:19:35 +000010024 << Deduced << DeducedDecl->getDeclName()
10025 << U << D->getDeclName()
10026 << DeducedDecl->getInit()->getSourceRange()
10027 << D->getInit()->getSourceRange();
Richard Smith2abf6762011-02-23 00:37:57 +000010028 D->setInvalidDecl();
Richard Smith30482bc2011-02-20 03:19:35 +000010029 break;
10030 }
10031 }
10032 }
10033 }
10034 }
10035
Rafael Espindolaab417692013-07-09 12:05:01 +000010036 ActOnDocumentableDecls(Group);
Dmitri Gribenkof26054f2012-07-11 21:38:39 +000010037
Rafael Espindolaab417692013-07-09 12:05:01 +000010038 return DeclGroupPtrTy::make(
10039 DeclGroupRef::Create(Context, Group.data(), Group.size()));
Chris Lattner776fac82007-06-09 00:53:06 +000010040}
Steve Naroff7e6f7c22007-08-28 03:03:08 +000010041
Dmitri Gribenkof26054f2012-07-11 21:38:39 +000010042void Sema::ActOnDocumentableDecl(Decl *D) {
Rafael Espindolaab417692013-07-09 12:05:01 +000010043 ActOnDocumentableDecls(D);
Dmitri Gribenkof26054f2012-07-11 21:38:39 +000010044}
10045
Rafael Espindolaab417692013-07-09 12:05:01 +000010046void Sema::ActOnDocumentableDecls(ArrayRef<Decl *> Group) {
Dmitri Gribenkof26054f2012-07-11 21:38:39 +000010047 // Don't parse the comment if Doxygen diagnostics are ignored.
Rafael Espindolaab417692013-07-09 12:05:01 +000010048 if (Group.empty() || !Group[0])
Dmitri Gribenko7fe22f62015-03-17 18:03:42 +000010049 return;
Dmitri Gribenkof26054f2012-07-11 21:38:39 +000010050
Dmitri Gribenko7fe22f62015-03-17 18:03:42 +000010051 if (Diags.isIgnored(diag::warn_doc_param_not_found,
10052 Group[0]->getLocation()) &&
10053 Diags.isIgnored(diag::warn_unknown_comment_command_name,
10054 Group[0]->getLocation()))
Dmitri Gribenkof26054f2012-07-11 21:38:39 +000010055 return;
10056
Rafael Espindolaab417692013-07-09 12:05:01 +000010057 if (Group.size() >= 2) {
Dmitri Gribenkof26054f2012-07-11 21:38:39 +000010058 // This is a decl group. Normally it will contain only declarations
Rafael Espindolaab417692013-07-09 12:05:01 +000010059 // produced from declarator list. But in case we have any definitions or
Dmitri Gribenkof26054f2012-07-11 21:38:39 +000010060 // additional declaration references:
10061 // 'typedef struct S {} S;'
10062 // 'typedef struct S *S;'
10063 // 'struct S *pS;'
10064 // FinalizeDeclaratorGroup adds these as separate declarations.
10065 Decl *MaybeTagDecl = Group[0];
10066 if (MaybeTagDecl && isa<TagDecl>(MaybeTagDecl)) {
Rafael Espindolaab417692013-07-09 12:05:01 +000010067 Group = Group.slice(1);
Dmitri Gribenkof26054f2012-07-11 21:38:39 +000010068 }
10069 }
10070
10071 // See if there are any new comments that are not attached to a decl.
10072 ArrayRef<RawComment *> Comments = Context.getRawCommentList().getComments();
10073 if (!Comments.empty() &&
10074 !Comments.back()->isAttached()) {
10075 // There is at least one comment that not attached to a decl.
10076 // Maybe it should be attached to one of these decls?
10077 //
10078 // Note that this way we pick up not only comments that precede the
10079 // declaration, but also comments that *follow* the declaration -- thanks to
10080 // the lookahead in the lexer: we've consumed the semicolon and looked
10081 // ahead through comments.
Rafael Espindolaab417692013-07-09 12:05:01 +000010082 for (unsigned i = 0, e = Group.size(); i != e; ++i)
Dmitri Gribenko6743e042012-09-29 11:40:46 +000010083 Context.getCommentForDecl(Group[i], &PP);
Dmitri Gribenkof26054f2012-07-11 21:38:39 +000010084 }
10085}
Chris Lattner5bbb3c82009-03-29 16:50:03 +000010086
Chris Lattneraa9c7ae2008-04-08 04:40:51 +000010087/// ActOnParamDeclarator - Called from Parser::ParseFunctionDeclarator()
10088/// to introduce parameters into function prototype scope.
John McCall48871652010-08-21 09:40:31 +000010089Decl *Sema::ActOnParamDeclarator(Scope *S, Declarator &D) {
Chris Lattnercf31de32008-06-26 06:49:43 +000010090 const DeclSpec &DS = D.getDeclSpec();
Douglas Gregorad590502008-12-15 23:53:10 +000010091
Chris Lattneraa9c7ae2008-04-08 04:40:51 +000010092 // Verify C99 6.7.5.3p2: The only SCS allowed is 'register'.
Faisal Vali2b391ab2013-09-26 19:54:12 +000010093
Peter Collingbourne99eddc32011-10-21 11:55:09 +000010094 // C++03 [dcl.stc]p2 also permits 'auto'.
Craig Topperc79e5e32014-10-31 06:57:13 +000010095 StorageClass SC = SC_None;
Daniel Dunbar0ff41922008-09-03 21:54:21 +000010096 if (DS.getStorageClassSpec() == DeclSpec::SCS_register) {
Craig Topperc79e5e32014-10-31 06:57:13 +000010097 SC = SC_Register;
David Blaikiebbafb8a2012-03-11 07:00:24 +000010098 } else if (getLangOpts().CPlusPlus &&
Peter Collingbourne99eddc32011-10-21 11:55:09 +000010099 DS.getStorageClassSpec() == DeclSpec::SCS_auto) {
Craig Topperc79e5e32014-10-31 06:57:13 +000010100 SC = SC_Auto;
Daniel Dunbar0ff41922008-09-03 21:54:21 +000010101 } else if (DS.getStorageClassSpec() != DeclSpec::SCS_unspecified) {
Chris Lattneraa9c7ae2008-04-08 04:40:51 +000010102 Diag(DS.getStorageClassSpecLoc(),
10103 diag::err_invalid_storage_class_in_func_decl);
Chris Lattnercf31de32008-06-26 06:49:43 +000010104 D.getMutableDeclSpec().ClearStorageClassSpecs();
Chris Lattneraa9c7ae2008-04-08 04:40:51 +000010105 }
Eli Friedmand5c0eed2009-04-19 20:27:55 +000010106
Richard Smithb4a9e862013-04-12 22:46:28 +000010107 if (DeclSpec::TSCS TSCS = DS.getThreadStorageClassSpec())
10108 Diag(DS.getThreadStorageClassSpecLoc(), diag::err_invalid_thread)
10109 << DeclSpec::getSpecifierName(TSCS);
10110 if (DS.isConstexprSpecified())
10111 Diag(DS.getConstexprSpecLoc(), diag::err_invalid_constexpr)
Richard Smitha77a0a62011-08-15 21:04:07 +000010112 << 0;
Eli Friedmand5c0eed2009-04-19 20:27:55 +000010113
Richard Smithb4a9e862013-04-12 22:46:28 +000010114 DiagnoseFunctionSpecifiers(DS);
Eli Friedman574c7452009-04-07 19:37:57 +000010115
Argyrios Kyrtzidisef7022f2011-06-28 03:01:15 +000010116 TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S);
John McCall8cb7bdf2010-06-04 23:28:52 +000010117 QualType parmDeclType = TInfo->getType();
Mike Stump11289f42009-09-09 15:08:12 +000010118
David Blaikiebbafb8a2012-03-11 07:00:24 +000010119 if (getLangOpts().CPlusPlus) {
Douglas Gregor27b4c162010-12-23 22:44:42 +000010120 // Check that there are no default arguments inside the type of this
10121 // parameter.
10122 CheckExtraCXXDefaultArguments(D);
Douglas Gregor27b4c162010-12-23 22:44:42 +000010123
10124 // Parameter declarators cannot be qualified (C++ [dcl.meaning]p1).
10125 if (D.getCXXScopeSpec().isSet()) {
10126 Diag(D.getIdentifierLoc(), diag::err_qualified_param_declarator)
10127 << D.getCXXScopeSpec().getRange();
10128 D.getCXXScopeSpec().clear();
10129 }
Douglas Gregord6ab8742009-05-28 23:31:59 +000010130 }
10131
Alexis Hunta56cbcc2010-11-03 01:07:06 +000010132 // Ensure we have a valid name
Craig Topperc3ec1492014-05-26 06:22:03 +000010133 IdentifierInfo *II = nullptr;
Alexis Hunta56cbcc2010-11-03 01:07:06 +000010134 if (D.hasName()) {
10135 II = D.getIdentifier();
10136 if (!II) {
10137 Diag(D.getIdentifierLoc(), diag::err_bad_parameter_name)
Aaron Ballmanfee0cd42014-01-03 13:34:55 +000010138 << GetNameForDeclarator(D).getName();
Alexis Hunta56cbcc2010-11-03 01:07:06 +000010139 D.setInvalidType(true);
10140 }
10141 }
10142
Chris Lattnerdd1cb5b2010-02-22 00:40:25 +000010143 // Check for redeclaration of parameters, e.g. int foo(int x, int x);
Chris Lattnerd9773512009-01-21 02:38:50 +000010144 if (II) {
John McCall84f02672010-03-18 06:42:38 +000010145 LookupResult R(*this, II, D.getIdentifierLoc(), LookupOrdinaryName,
10146 ForRedeclaration);
10147 LookupName(R, S);
10148 if (R.isSingleResult()) {
10149 NamedDecl *PrevDecl = R.getFoundDecl();
Chris Lattnerd9773512009-01-21 02:38:50 +000010150 if (PrevDecl->isTemplateParameter()) {
10151 // Maybe we will complain about the shadowed template parameter.
10152 DiagnoseTemplateParameterShadow(D.getIdentifierLoc(), PrevDecl);
10153 // Just pretend that we didn't see the previous declaration.
Craig Topperc3ec1492014-05-26 06:22:03 +000010154 PrevDecl = nullptr;
John McCall48871652010-08-21 09:40:31 +000010155 } else if (S->isDeclScope(PrevDecl)) {
Chris Lattnerd9773512009-01-21 02:38:50 +000010156 Diag(D.getIdentifierLoc(), diag::err_param_redefinition) << II;
Chris Lattnerdd1cb5b2010-02-22 00:40:25 +000010157 Diag(PrevDecl->getLocation(), diag::note_previous_declaration);
Chris Lattneraa9c7ae2008-04-08 04:40:51 +000010158
Chris Lattnerd9773512009-01-21 02:38:50 +000010159 // Recover by removing the name
Craig Topperc3ec1492014-05-26 06:22:03 +000010160 II = nullptr;
10161 D.SetIdentifier(nullptr, D.getIdentifierLoc());
Fariborz Jahanian5ec502e2010-02-12 21:53:14 +000010162 D.setInvalidType(true);
Chris Lattnerd9773512009-01-21 02:38:50 +000010163 }
Chris Lattneraa9c7ae2008-04-08 04:40:51 +000010164 }
Chris Lattnerc5cdf4d2007-01-21 07:42:07 +000010165 }
Steve Naroff773df5c2007-08-07 22:44:21 +000010166
John McCallf7b2fb52010-01-22 00:28:27 +000010167 // Temporarily put parameter variables in the translation unit, not
10168 // the enclosing context. This prevents them from accidentally
10169 // looking like class members in C++.
Douglas Gregor940bca72010-04-12 07:48:19 +000010170 ParmVarDecl *New = CheckParameter(Context.getTranslationUnitDecl(),
Daniel Dunbar62ee6412012-03-09 18:35:03 +000010171 D.getLocStart(),
Abramo Bagnaradff19302011-03-08 08:55:46 +000010172 D.getIdentifierLoc(), II,
10173 parmDeclType, TInfo,
Craig Topperc79e5e32014-10-31 06:57:13 +000010174 SC);
Mike Stump11289f42009-09-09 15:08:12 +000010175
Chris Lattnerf6d1c9c2009-04-25 08:06:05 +000010176 if (D.isInvalidType())
John McCall8fb0d9d2011-05-01 22:35:37 +000010177 New->setInvalidDecl();
10178
10179 assert(S->isFunctionPrototypeScope());
10180 assert(S->getFunctionPrototypeDepth() >= 1);
10181 New->setScopeInfo(S->getFunctionPrototypeDepth() - 1,
10182 S->getNextFunctionPrototypeIndex());
Douglas Gregor940bca72010-04-12 07:48:19 +000010183
Douglas Gregor91f84212008-12-11 16:49:14 +000010184 // Add the parameter declaration into this scope.
John McCall48871652010-08-21 09:40:31 +000010185 S->AddDecl(New);
Argyrios Kyrtzidisb8a49202008-04-12 00:47:19 +000010186 if (II)
Douglas Gregor91f84212008-12-11 16:49:14 +000010187 IdResolver.AddDecl(New);
Nate Begemand8c41562008-02-17 21:20:31 +000010188
Douglas Gregor758a8692009-06-17 21:51:59 +000010189 ProcessDeclAttributes(S, New, D);
Mike Stumpe9efa802009-04-30 00:19:40 +000010190
Douglas Gregor41866812011-09-12 18:37:38 +000010191 if (D.getDeclSpec().isModulePrivateSpecified())
10192 Diag(New->getLocation(), diag::err_module_private_local)
10193 << 1 << New->getDeclName()
10194 << SourceRange(D.getDeclSpec().getModulePrivateSpecLoc())
10195 << FixItHint::CreateRemoval(D.getDeclSpec().getModulePrivateSpecLoc());
10196
Argyrios Kyrtzidisb4b64ca2009-06-30 02:34:44 +000010197 if (New->hasAttr<BlocksAttr>()) {
Mike Stumpe9efa802009-04-30 00:19:40 +000010198 Diag(New->getLocation(), diag::err_block_on_nonlocal);
10199 }
John McCall48871652010-08-21 09:40:31 +000010200 return New;
Chris Lattnerc5cdf4d2007-01-21 07:42:07 +000010201}
Fariborz Jahanian56ff1462007-11-08 23:49:49 +000010202
John McCalla3ccba02010-06-04 11:21:44 +000010203/// \brief Synthesizes a variable for a parameter arising from a
10204/// typedef.
10205ParmVarDecl *Sema::BuildParmVarDeclForTypedef(DeclContext *DC,
10206 SourceLocation Loc,
10207 QualType T) {
Abramo Bagnaradff19302011-03-08 08:55:46 +000010208 /* FIXME: setting StartLoc == Loc.
10209 Would it be worth to modify callers so as to provide proper source
10210 location for the unnamed parameters, embedding the parameter's type? */
Craig Topperc3ec1492014-05-26 06:22:03 +000010211 ParmVarDecl *Param = ParmVarDecl::Create(Context, DC, Loc, Loc, nullptr,
John McCalla3ccba02010-06-04 11:21:44 +000010212 T, Context.getTrivialTypeSourceInfo(T, Loc),
Craig Topperc3ec1492014-05-26 06:22:03 +000010213 SC_None, nullptr);
John McCalla3ccba02010-06-04 11:21:44 +000010214 Param->setImplicit();
10215 return Param;
10216}
10217
John McCallc5990642010-08-24 09:05:15 +000010218void Sema::DiagnoseUnusedParameters(ParmVarDecl * const *Param,
10219 ParmVarDecl * const *ParamEnd) {
John McCallc5990642010-08-24 09:05:15 +000010220 // Don't diagnose unused-parameter errors in template instantiations; we
10221 // will already have done so in the template itself.
10222 if (!ActiveTemplateInstantiations.empty())
10223 return;
10224
10225 for (; Param != ParamEnd; ++Param) {
Eli Friedmanc09e0552012-01-13 23:41:25 +000010226 if (!(*Param)->isReferenced() && (*Param)->getDeclName() &&
John McCallc5990642010-08-24 09:05:15 +000010227 !(*Param)->hasAttr<UnusedAttr>()) {
10228 Diag((*Param)->getLocation(), diag::warn_unused_parameter)
10229 << (*Param)->getDeclName();
10230 }
10231 }
10232}
10233
Argyrios Kyrtzidisaf84ec02010-11-17 23:11:54 +000010234void Sema::DiagnoseSizeOfParametersAndReturnValue(ParmVarDecl * const *Param,
10235 ParmVarDecl * const *ParamEnd,
10236 QualType ReturnTy,
10237 NamedDecl *D) {
Argyrios Kyrtzidisef6c8da2010-11-18 00:20:36 +000010238 if (LangOpts.NumLargeByValueCopy == 0) // No check.
Argyrios Kyrtzidisaf84ec02010-11-17 23:11:54 +000010239 return;
10240
Argyrios Kyrtzidisef6c8da2010-11-18 00:20:36 +000010241 // Warn if the return value is pass-by-value and larger than the specified
10242 // threshold.
Eli Friedman7f21bd72012-01-09 23:46:59 +000010243 if (!ReturnTy->isDependentType() && ReturnTy.isPODType(Context)) {
Argyrios Kyrtzidisaf84ec02010-11-17 23:11:54 +000010244 unsigned Size = Context.getTypeSizeInChars(ReturnTy).getQuantity();
Argyrios Kyrtzidisef6c8da2010-11-18 00:20:36 +000010245 if (Size > LangOpts.NumLargeByValueCopy)
Argyrios Kyrtzidisaf84ec02010-11-17 23:11:54 +000010246 Diag(D->getLocation(), diag::warn_return_value_size)
10247 << D->getDeclName() << Size;
10248 }
10249
Argyrios Kyrtzidisef6c8da2010-11-18 00:20:36 +000010250 // Warn if any parameter is pass-by-value and larger than the specified
10251 // threshold.
Argyrios Kyrtzidisaf84ec02010-11-17 23:11:54 +000010252 for (; Param != ParamEnd; ++Param) {
10253 QualType T = (*Param)->getType();
Eli Friedman7f21bd72012-01-09 23:46:59 +000010254 if (T->isDependentType() || !T.isPODType(Context))
Argyrios Kyrtzidisaf84ec02010-11-17 23:11:54 +000010255 continue;
10256 unsigned Size = Context.getTypeSizeInChars(T).getQuantity();
Argyrios Kyrtzidisef6c8da2010-11-18 00:20:36 +000010257 if (Size > LangOpts.NumLargeByValueCopy)
Argyrios Kyrtzidisaf84ec02010-11-17 23:11:54 +000010258 Diag((*Param)->getLocation(), diag::warn_parameter_size)
10259 << (*Param)->getDeclName() << Size;
10260 }
10261}
10262
Abramo Bagnaradff19302011-03-08 08:55:46 +000010263ParmVarDecl *Sema::CheckParameter(DeclContext *DC, SourceLocation StartLoc,
10264 SourceLocation NameLoc, IdentifierInfo *Name,
10265 QualType T, TypeSourceInfo *TSInfo,
Craig Topperc79e5e32014-10-31 06:57:13 +000010266 StorageClass SC) {
Reid Kleckner17aeeeb2013-06-08 18:19:52 +000010267 // In ARC, infer a lifetime qualifier for appropriate parameter types.
David Blaikiebbafb8a2012-03-11 07:00:24 +000010268 if (getLangOpts().ObjCAutoRefCount &&
John McCall31168b02011-06-15 23:02:42 +000010269 T.getObjCLifetime() == Qualifiers::OCL_None &&
Reid Kleckner17aeeeb2013-06-08 18:19:52 +000010270 T->isObjCLifetimeType()) {
10271
10272 Qualifiers::ObjCLifetime lifetime;
10273
10274 // Special cases for arrays:
10275 // - if it's const, use __unsafe_unretained
10276 // - otherwise, it's an error
10277 if (T->isArrayType()) {
10278 if (!T.isConstQualified()) {
10279 DelayedDiagnostics.add(
10280 sema::DelayedDiagnostic::makeForbiddenType(
Fariborz Jahanianed1933b2011-10-03 22:11:57 +000010281 NameLoc, diag::err_arc_array_param_no_ownership, T, false));
Reid Kleckner17aeeeb2013-06-08 18:19:52 +000010282 }
10283 lifetime = Qualifiers::OCL_ExplicitNone;
10284 } else {
10285 lifetime = T->getObjCARCImplicitLifetime();
10286 }
10287 T = Context.getLifetimeQualifiedType(T, lifetime);
John McCall31168b02011-06-15 23:02:42 +000010288 }
10289
Abramo Bagnaradff19302011-03-08 08:55:46 +000010290 ParmVarDecl *New = ParmVarDecl::Create(Context, DC, StartLoc, NameLoc, Name,
Douglas Gregor84280642011-07-12 04:42:08 +000010291 Context.getAdjustedParameterType(T),
Craig Topperc79e5e32014-10-31 06:57:13 +000010292 TSInfo, SC, nullptr);
Douglas Gregor940bca72010-04-12 07:48:19 +000010293
10294 // Parameters can not be abstract class types.
10295 // For record types, this is done by the AbstractClassUsageDiagnoser once
10296 // the class has been completely parsed.
10297 if (!CurContext->isRecord() &&
10298 RequireNonAbstractType(NameLoc, T, diag::err_abstract_type_in_decl,
10299 AbstractParamType))
10300 New->setInvalidDecl();
10301
10302 // Parameter declarators cannot be interface types. All ObjC objects are
10303 // passed by reference.
John McCall8b07ec22010-05-15 11:32:37 +000010304 if (T->isObjCObjectType()) {
Fariborz Jahanian7a055362012-05-09 21:49:29 +000010305 SourceLocation TypeEndLoc = TSInfo->getTypeLoc().getLocEnd();
Douglas Gregor940bca72010-04-12 07:48:19 +000010306 Diag(NameLoc,
Fariborz Jahanian6507135e2011-07-26 17:58:54 +000010307 diag::err_object_cannot_be_passed_returned_by_value) << 1 << T
Fariborz Jahanian7a055362012-05-09 21:49:29 +000010308 << FixItHint::CreateInsertion(TypeEndLoc, "*");
Fariborz Jahanian6507135e2011-07-26 17:58:54 +000010309 T = Context.getObjCObjectPointerType(T);
10310 New->setType(T);
Douglas Gregor940bca72010-04-12 07:48:19 +000010311 }
10312
10313 // ISO/IEC TR 18037 S6.7.3: "The type of an object with automatic storage
10314 // duration shall not be qualified by an address-space qualifier."
10315 // Since all parameters have automatic store duration, they can not have
10316 // an address space.
10317 if (T.getAddressSpace() != 0) {
Fraser Cormack01648e02014-04-15 11:38:29 +000010318 // OpenCL allows function arguments declared to be an array of a type
10319 // to be qualified with an address space.
10320 if (!(getLangOpts().OpenCL && T->isArrayType())) {
10321 Diag(NameLoc, diag::err_arg_with_address_space);
10322 New->setInvalidDecl();
10323 }
Douglas Gregor940bca72010-04-12 07:48:19 +000010324 }
10325
10326 return New;
10327}
10328
Douglas Gregor170512f2009-04-01 23:51:29 +000010329void Sema::ActOnFinishKNRParamDeclarations(Scope *S, Declarator &D,
10330 SourceLocation LocAfterDecls) {
Abramo Bagnara924a8f32010-12-10 16:29:40 +000010331 DeclaratorChunk::FunctionTypeInfo &FTI = D.getFunctionTypeInfo();
Chris Lattneraa9c7ae2008-04-08 04:40:51 +000010332
Chris Lattner5c5fbcc2006-12-03 08:41:30 +000010333 // Verify 6.9.1p6: 'every identifier in the identifier list shall be declared'
10334 // for a K&R function.
10335 if (!FTI.hasPrototype) {
Alp Tokerc5350722014-02-26 22:27:52 +000010336 for (int i = FTI.NumParams; i != 0; /* decrement in loop */) {
Douglas Gregor862ffb12009-04-02 03:14:12 +000010337 --i;
Craig Topperc3ec1492014-05-26 06:22:03 +000010338 if (FTI.Params[i].Param == nullptr) {
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +000010339 SmallString<256> Code;
Alp Tokerc5350722014-02-26 22:27:52 +000010340 llvm::raw_svector_ostream(Code)
10341 << " int " << FTI.Params[i].Ident->getName() << ";\n";
10342 Diag(FTI.Params[i].IdentLoc, diag::ext_param_not_declared)
10343 << FTI.Params[i].Ident
Yaron Keren92e1b622015-03-18 10:17:07 +000010344 << FixItHint::CreateInsertion(LocAfterDecls, Code);
Douglas Gregor170512f2009-04-01 23:51:29 +000010345
Chris Lattner5c5fbcc2006-12-03 08:41:30 +000010346 // Implicitly declare the argument as type 'int' for lack of a better
10347 // type.
John McCall084e83d2011-03-24 11:26:52 +000010348 AttributeFactory attrs;
10349 DeclSpec DS(attrs);
Chris Lattneraa9c7ae2008-04-08 04:40:51 +000010350 const char* PrevSpec; // unused
John McCall49bfce42009-08-03 20:12:06 +000010351 unsigned DiagID; // unused
Alp Tokerc5350722014-02-26 22:27:52 +000010352 DS.SetTypeSpecType(DeclSpec::TST_int, FTI.Params[i].IdentLoc, PrevSpec,
10353 DiagID, Context.getPrintingPolicy());
Abramo Bagnara71f32c12012-10-04 21:38:29 +000010354 // Use the identifier location for the type source range.
Alp Tokerc5350722014-02-26 22:27:52 +000010355 DS.SetRangeStart(FTI.Params[i].IdentLoc);
10356 DS.SetRangeEnd(FTI.Params[i].IdentLoc);
Chris Lattneraa9c7ae2008-04-08 04:40:51 +000010357 Declarator ParamD(DS, Declarator::KNRTypeListContext);
Alp Tokerc5350722014-02-26 22:27:52 +000010358 ParamD.SetIdentifier(FTI.Params[i].Ident, FTI.Params[i].IdentLoc);
10359 FTI.Params[i].Param = ActOnParamDeclarator(S, ParamD);
Chris Lattner5c5fbcc2006-12-03 08:41:30 +000010360 }
10361 }
Mike Stump11289f42009-09-09 15:08:12 +000010362 }
Douglas Gregor9aa89042009-01-23 16:23:13 +000010363}
10364
Richard Smith79a52e52012-04-17 22:30:01 +000010365Decl *Sema::ActOnStartOfFunctionDef(Scope *FnBodyScope, Declarator &D) {
Craig Topperc3ec1492014-05-26 06:22:03 +000010366 assert(getCurFunctionDecl() == nullptr && "Function parsing confused");
Abramo Bagnara924a8f32010-12-10 16:29:40 +000010367 assert(D.isFunctionDeclarator() && "Not a function declarator!");
Douglas Gregorad590502008-12-15 23:53:10 +000010368 Scope *ParentScope = FnBodyScope->getParent();
Steve Naroff012484d2008-01-14 20:51:29 +000010369
Douglas Gregor5d1b4e32011-11-07 20:56:01 +000010370 D.setFunctionDefinitionKind(FDK_Definition);
Benjamin Kramercc4c49d2012-08-23 23:38:35 +000010371 Decl *DP = HandleDeclarator(ParentScope, D, MultiTemplateParamsArg());
Chris Lattner5bbb3c82009-03-29 16:50:03 +000010372 return ActOnStartOfFunctionDef(FnBodyScope, DP);
Argyrios Kyrtzidised983422008-07-01 10:37:29 +000010373}
10374
Hans Wennborga926d842014-05-23 20:37:38 +000010375void Sema::ActOnFinishInlineMethodDef(CXXMethodDecl *D) {
10376 Consumer.HandleInlineMethodDefinition(D);
10377}
10378
Anders Carlsson2a45e402012-12-18 01:29:20 +000010379static bool ShouldWarnAboutMissingPrototype(const FunctionDecl *FD,
10380 const FunctionDecl*& PossibleZeroParamPrototype) {
Anders Carlsson31c7e882009-12-09 03:30:09 +000010381 // Don't warn about invalid declarations.
10382 if (FD->isInvalidDecl())
10383 return false;
Anders Carlssona0388252009-12-09 03:44:46 +000010384
Anders Carlsson31c7e882009-12-09 03:30:09 +000010385 // Or declarations that aren't global.
10386 if (!FD->isGlobal())
10387 return false;
Anders Carlssona0388252009-12-09 03:44:46 +000010388
Anders Carlsson31c7e882009-12-09 03:30:09 +000010389 // Don't warn about C++ member functions.
10390 if (isa<CXXMethodDecl>(FD))
10391 return false;
Anders Carlssona0388252009-12-09 03:44:46 +000010392
Anders Carlsson31c7e882009-12-09 03:30:09 +000010393 // Don't warn about 'main'.
10394 if (FD->isMain())
10395 return false;
Anders Carlssona0388252009-12-09 03:44:46 +000010396
Anders Carlsson31c7e882009-12-09 03:30:09 +000010397 // Don't warn about inline functions.
John McCall30cd20a2011-03-22 07:16:37 +000010398 if (FD->isInlined())
Anders Carlsson31c7e882009-12-09 03:30:09 +000010399 return false;
Anders Carlssona0388252009-12-09 03:44:46 +000010400
10401 // Don't warn about function templates.
10402 if (FD->getDescribedFunctionTemplate())
10403 return false;
10404
10405 // Don't warn about function template specializations.
10406 if (FD->isFunctionTemplateSpecialization())
10407 return false;
10408
Tanya Lattner4bfc3552012-07-26 00:08:28 +000010409 // Don't warn for OpenCL kernels.
10410 if (FD->hasAttr<OpenCLKernelAttr>())
10411 return false;
Richard Smith541b38b2013-09-20 01:15:31 +000010412
Benjamin Kramer8610cae2015-03-12 14:28:47 +000010413 // Don't warn on explicitly deleted functions.
10414 if (FD->isDeleted())
10415 return false;
10416
Anders Carlsson31c7e882009-12-09 03:30:09 +000010417 bool MissingPrototype = true;
Douglas Gregorec9fd132012-01-14 16:38:05 +000010418 for (const FunctionDecl *Prev = FD->getPreviousDecl();
10419 Prev; Prev = Prev->getPreviousDecl()) {
Anders Carlsson31c7e882009-12-09 03:30:09 +000010420 // Ignore any declarations that occur in function or method
10421 // scope, because they aren't visible from the header.
Richard Smith541b38b2013-09-20 01:15:31 +000010422 if (Prev->getLexicalDeclContext()->isFunctionOrMethod())
Anders Carlsson31c7e882009-12-09 03:30:09 +000010423 continue;
Richard Smith541b38b2013-09-20 01:15:31 +000010424
Anders Carlsson31c7e882009-12-09 03:30:09 +000010425 MissingPrototype = !Prev->getType()->isFunctionProtoType();
Anders Carlsson2a45e402012-12-18 01:29:20 +000010426 if (FD->getNumParams() == 0)
10427 PossibleZeroParamPrototype = Prev;
Anders Carlsson31c7e882009-12-09 03:30:09 +000010428 break;
10429 }
Richard Smith541b38b2013-09-20 01:15:31 +000010430
Anders Carlsson31c7e882009-12-09 03:30:09 +000010431 return MissingPrototype;
10432}
10433
Rafael Espindolad53ffa02013-10-22 21:39:03 +000010434void
10435Sema::CheckForFunctionRedefinition(FunctionDecl *FD,
10436 const FunctionDecl *EffectiveDefinition) {
Francois Pichetdcb3ebe2011-04-22 23:20:44 +000010437 // Don't complain if we're in GNU89 mode and the previous definition
10438 // was an extern inline function.
Rafael Espindolad53ffa02013-10-22 21:39:03 +000010439 const FunctionDecl *Definition = EffectiveDefinition;
10440 if (!Definition)
10441 if (!FD->isDefined(Definition))
10442 return;
10443
10444 if (canRedefineFunction(Definition, getLangOpts()))
Rafael Espindola69f53102013-10-22 15:18:22 +000010445 return;
10446
Richard Smithd6aab592015-03-27 21:57:41 +000010447 // If we don't have a visible definition of the function, and it's inline or
10448 // a template, it's OK to form another definition of it.
Richard Smith9a71c992015-03-27 20:16:58 +000010449 //
10450 // FIXME: Should we skip the body of the function and use the old definition
10451 // in this case? That may be necessary for functions that return local types
10452 // through a deduced return type, or instantiate templates with local types.
Richard Smithd6aab592015-03-27 21:57:41 +000010453 if (!hasVisibleDefinition(Definition) &&
Richard Smith529ecb22015-06-22 21:15:01 +000010454 (Definition->getFormalLinkage() == InternalLinkage ||
Richard Smith76553812015-07-01 07:24:18 +000010455 Definition->isInlined() ||
Richard Smithd6aab592015-03-27 21:57:41 +000010456 Definition->getDescribedFunctionTemplate() ||
10457 Definition->getNumTemplateParameterLists()))
Richard Smith9a71c992015-03-27 20:16:58 +000010458 return;
10459
Rafael Espindola69f53102013-10-22 15:18:22 +000010460 if (getLangOpts().GNUMode && Definition->isInlineSpecified() &&
10461 Definition->getStorageClass() == SC_Extern)
10462 Diag(FD->getLocation(), diag::err_redefinition_extern_inline)
David Blaikiebbafb8a2012-03-11 07:00:24 +000010463 << FD->getDeclName() << getLangOpts().CPlusPlus;
Rafael Espindola69f53102013-10-22 15:18:22 +000010464 else
10465 Diag(FD->getLocation(), diag::err_redefinition) << FD->getDeclName();
10466
10467 Diag(Definition->getLocation(), diag::note_previous_definition);
10468 FD->setInvalidDecl();
Francois Pichetdcb3ebe2011-04-22 23:20:44 +000010469}
Faisal Valia17d19f2013-11-07 05:17:06 +000010470
10471
Faisal Valic1a6dc42013-10-23 16:10:50 +000010472static void RebuildLambdaScopeInfo(CXXMethodDecl *CallOperator,
10473 Sema &S) {
10474 CXXRecordDecl *const LambdaClass = CallOperator->getParent();
Faisal Vali524ca282013-11-12 01:40:44 +000010475
10476 LambdaScopeInfo *LSI = S.PushLambdaScope();
Faisal Valic1a6dc42013-10-23 16:10:50 +000010477 LSI->CallOperator = CallOperator;
10478 LSI->Lambda = LambdaClass;
Alp Toker314cc812014-01-25 16:55:45 +000010479 LSI->ReturnType = CallOperator->getReturnType();
Faisal Valic1a6dc42013-10-23 16:10:50 +000010480 const LambdaCaptureDefault LCD = LambdaClass->getLambdaCaptureDefault();
10481
10482 if (LCD == LCD_None)
10483 LSI->ImpCaptureStyle = CapturingScopeInfo::ImpCap_None;
10484 else if (LCD == LCD_ByCopy)
10485 LSI->ImpCaptureStyle = CapturingScopeInfo::ImpCap_LambdaByval;
10486 else if (LCD == LCD_ByRef)
10487 LSI->ImpCaptureStyle = CapturingScopeInfo::ImpCap_LambdaByref;
10488 DeclarationNameInfo DNI = CallOperator->getNameInfo();
10489
10490 LSI->IntroducerRange = DNI.getCXXOperatorNameRange();
10491 LSI->Mutable = !CallOperator->isConst();
10492
Faisal Valia17d19f2013-11-07 05:17:06 +000010493 // Add the captures to the LSI so they can be noted as already
10494 // captured within tryCaptureVar.
Alexey Bataev39c81e22014-08-28 04:28:19 +000010495 auto I = LambdaClass->field_begin();
Aaron Ballman6def98a2014-03-13 17:08:33 +000010496 for (const auto &C : LambdaClass->captures()) {
10497 if (C.capturesVariable()) {
10498 VarDecl *VD = C.getCapturedVar();
Faisal Valia17d19f2013-11-07 05:17:06 +000010499 if (VD->isInitCapture())
10500 S.CurrentInstantiationScope->InstantiatedLocal(VD, VD);
10501 QualType CaptureType = VD->getType();
Aaron Ballman6def98a2014-03-13 17:08:33 +000010502 const bool ByRef = C.getCaptureKind() == LCK_ByRef;
Faisal Valia17d19f2013-11-07 05:17:06 +000010503 LSI->addCapture(VD, /*IsBlock*/false, ByRef,
Alexey Bataev19acc3d2015-01-12 10:17:46 +000010504 /*RefersToEnclosingVariableOrCapture*/true, C.getLocation(),
Aaron Ballman6def98a2014-03-13 17:08:33 +000010505 /*EllipsisLoc*/C.isPackExpansion()
10506 ? C.getEllipsisLoc() : SourceLocation(),
Craig Topperc3ec1492014-05-26 06:22:03 +000010507 CaptureType, /*Expr*/ nullptr);
10508
Aaron Ballman6def98a2014-03-13 17:08:33 +000010509 } else if (C.capturesThis()) {
10510 LSI->addThisCapture(/*Nested*/ false, C.getLocation(),
Craig Topperc3ec1492014-05-26 06:22:03 +000010511 S.getCurrentThisType(), /*Expr*/ nullptr);
Alexey Bataev39c81e22014-08-28 04:28:19 +000010512 } else {
10513 LSI->addVLATypeCapture(C.getLocation(), I->getType());
Faisal Valia17d19f2013-11-07 05:17:06 +000010514 }
Alexey Bataev39c81e22014-08-28 04:28:19 +000010515 ++I;
Faisal Valia17d19f2013-11-07 05:17:06 +000010516 }
Faisal Valic1a6dc42013-10-23 16:10:50 +000010517}
Francois Pichetdcb3ebe2011-04-22 23:20:44 +000010518
John McCall48871652010-08-21 09:40:31 +000010519Decl *Sema::ActOnStartOfFunctionDef(Scope *FnBodyScope, Decl *D) {
Anders Carlsson561f7932009-10-29 15:46:07 +000010520 // Clear the last template instantiation error context.
10521 LastTemplateInstantiationErrorContext = ActiveTemplateInstantiation();
10522
Douglas Gregor17a7c122009-06-24 00:54:41 +000010523 if (!D)
10524 return D;
Craig Topperc3ec1492014-05-26 06:22:03 +000010525 FunctionDecl *FD = nullptr;
Mike Stump11289f42009-09-09 15:08:12 +000010526
John McCall48871652010-08-21 09:40:31 +000010527 if (FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(D))
Douglas Gregorc45a40a2009-08-22 00:34:47 +000010528 FD = FunTmpl->getTemplatedDecl();
10529 else
John McCall48871652010-08-21 09:40:31 +000010530 FD = cast<FunctionDecl>(D);
Faisal Vali2b391ab2013-09-26 19:54:12 +000010531 // If we are instantiating a generic lambda call operator, push
10532 // a LambdaScopeInfo onto the function stack. But use the information
Faisal Valic1a6dc42013-10-23 16:10:50 +000010533 // that's already been calculated (ActOnLambdaExpr) to prime the current
10534 // LambdaScopeInfo.
10535 // When the template operator is being specialized, the LambdaScopeInfo,
10536 // has to be properly restored so that tryCaptureVariable doesn't try
10537 // and capture any new variables. In addition when calculating potential
10538 // captures during transformation of nested lambdas, it is necessary to
10539 // have the LSI properly restored.
Faisal Valif9a9af32013-09-29 20:15:45 +000010540 if (isGenericLambdaCallOperatorSpecialization(FD)) {
Faisal Vali2b391ab2013-09-26 19:54:12 +000010541 assert(ActiveTemplateInstantiations.size() &&
10542 "There should be an active template instantiation on the stack "
10543 "when instantiating a generic lambda!");
Faisal Valic1a6dc42013-10-23 16:10:50 +000010544 RebuildLambdaScopeInfo(cast<CXXMethodDecl>(D), *this);
Faisal Vali2b391ab2013-09-26 19:54:12 +000010545 }
10546 else
10547 // Enter a new function scope
10548 PushFunctionScope();
Mike Stump11289f42009-09-09 15:08:12 +000010549
Douglas Gregorcad304ba2008-10-29 15:10:40 +000010550 // See if this is a redefinition.
Francois Pichetdcb3ebe2011-04-22 23:20:44 +000010551 if (!FD->isLateTemplateParsed())
10552 CheckForFunctionRedefinition(FD);
Douglas Gregorcad304ba2008-10-29 15:10:40 +000010553
Douglas Gregor75a45ba2009-02-16 17:45:42 +000010554 // Builtin functions cannot be defined.
Douglas Gregor15fc9562009-09-12 00:22:50 +000010555 if (unsigned BuiltinID = FD->getBuiltinID()) {
Rafael Espindola3b3a1662013-06-13 18:34:17 +000010556 if (!Context.BuiltinInfo.isPredefinedLibFunction(BuiltinID) &&
10557 !Context.BuiltinInfo.isPredefinedRuntimeFunction(BuiltinID)) {
Douglas Gregor75a45ba2009-02-16 17:45:42 +000010558 Diag(FD->getLocation(), diag::err_builtin_definition) << FD;
Douglas Gregor7a0febe2009-02-17 16:03:01 +000010559 FD->setInvalidDecl();
10560 }
Douglas Gregor75a45ba2009-02-16 17:45:42 +000010561 }
10562
Eli Friedman9ad72442009-03-04 07:30:59 +000010563 // The return type of a function definition must be complete
Douglas Gregorac1fb652009-03-24 19:52:54 +000010564 // (C99 6.9.1p3, C++ [dcl.fct]p6).
Alp Toker314cc812014-01-25 16:55:45 +000010565 QualType ResultType = FD->getReturnType();
Douglas Gregorac1fb652009-03-24 19:52:54 +000010566 if (!ResultType->isDependentType() && !ResultType->isVoidType() &&
Chris Lattner0f94c5a2009-04-29 05:12:23 +000010567 !FD->isInvalidDecl() &&
Douglas Gregorac1fb652009-03-24 19:52:54 +000010568 RequireCompleteType(FD->getLocation(), ResultType,
10569 diag::err_func_def_incomplete_result))
Eli Friedman9ad72442009-03-04 07:30:59 +000010570 FD->setInvalidDecl();
Eli Friedman9ad72442009-03-04 07:30:59 +000010571
Douglas Gregor67da0d92009-05-15 17:59:04 +000010572 if (FnBodyScope)
10573 PushDeclContext(FnBodyScope, FD);
Anton Korobeynikovd72f47a2008-12-26 00:52:02 +000010574
Chris Lattneraa9c7ae2008-04-08 04:40:51 +000010575 // Check the validity of our function parameters
Douglas Gregorb524d902010-11-01 18:37:59 +000010576 CheckParmsForFunctionDef(FD->param_begin(), FD->param_end(),
10577 /*CheckParameterNames=*/true);
Chris Lattneraa9c7ae2008-04-08 04:40:51 +000010578
10579 // Introduce our parameters into the function scope
Aaron Ballmanf6bf62e2014-03-07 15:12:56 +000010580 for (auto Param : FD->params()) {
Douglas Gregorc72e6452009-01-09 18:51:29 +000010581 Param->setOwningFunction(FD);
10582
Chris Lattneraa9c7ae2008-04-08 04:40:51 +000010583 // If this has an identifier, add it to the scope stack.
John McCalldf8b37c2010-03-22 09:20:08 +000010584 if (Param->getIdentifier() && FnBodyScope) {
Argyrios Kyrtzidis1cb0de12010-12-15 18:44:22 +000010585 CheckShadow(FnBodyScope, Param);
John McCalldf8b37c2010-03-22 09:20:08 +000010586
Argyrios Kyrtzidisb8a49202008-04-12 00:47:19 +000010587 PushOnScopeChains(Param, FnBodyScope);
John McCalldf8b37c2010-03-22 09:20:08 +000010588 }
Chris Lattnerf61c8a82007-01-21 19:04:43 +000010589 }
Chris Lattneraa9c7ae2008-04-08 04:40:51 +000010590
James Molloy6f8780b2012-02-29 10:24:19 +000010591 // If we had any tags defined in the function prototype,
10592 // introduce them into the function scope.
10593 if (FnBodyScope) {
Robert Wilhelm16e94b92013-08-09 18:02:13 +000010594 for (ArrayRef<NamedDecl *>::iterator
10595 I = FD->getDeclsInPrototypeScope().begin(),
10596 E = FD->getDeclsInPrototypeScope().end();
10597 I != E; ++I) {
James Molloy6f8780b2012-02-29 10:24:19 +000010598 NamedDecl *D = *I;
10599
Nico Weber620660c2015-03-09 02:33:32 +000010600 // Some of these decls (like enums) may have been pinned to the
10601 // translation unit for lack of a real context earlier. If so, remove
10602 // from the translation unit and reattach to the current context.
James Molloy6f8780b2012-02-29 10:24:19 +000010603 if (D->getLexicalDeclContext() == Context.getTranslationUnitDecl()) {
10604 // Is the decl actually in the context?
Aaron Ballman629afae2014-03-07 19:56:05 +000010605 for (const auto *DI : Context.getTranslationUnitDecl()->decls()) {
10606 if (DI == D) {
James Molloy6f8780b2012-02-29 10:24:19 +000010607 Context.getTranslationUnitDecl()->removeDecl(D);
10608 break;
10609 }
10610 }
10611 // Either way, reassign the lexical decl context to our FunctionDecl.
10612 D->setLexicalDeclContext(CurContext);
10613 }
10614
10615 // If the decl has a non-null name, make accessible in the current scope.
10616 if (!D->getName().empty())
10617 PushOnScopeChains(D, FnBodyScope, /*AddToContext=*/false);
10618
10619 // Similarly, dive into enums and fish their constants out, making them
10620 // accessible in this scope.
Aaron Ballman23a6dcb2014-03-08 18:45:14 +000010621 if (auto *ED = dyn_cast<EnumDecl>(D)) {
10622 for (auto *EI : ED->enumerators())
10623 PushOnScopeChains(EI, FnBodyScope, /*AddToContext=*/false);
James Molloy6f8780b2012-02-29 10:24:19 +000010624 }
10625 }
10626 }
10627
Richard Smith79a52e52012-04-17 22:30:01 +000010628 // Ensure that the function's exception specification is instantiated.
10629 if (const FunctionProtoType *FPT = FD->getType()->getAs<FunctionProtoType>())
10630 ResolveExceptionSpec(D->getLocation(), FPT);
10631
Hans Wennborgb0f2f142014-05-15 22:07:49 +000010632 // dllimport cannot be applied to non-inline function definitions.
Hans Wennborg7f26fa62014-05-19 20:14:13 +000010633 if (FD->hasAttr<DLLImportAttr>() && !FD->isInlined() &&
10634 !FD->isTemplateInstantiation()) {
Hans Wennborgb0f2f142014-05-15 22:07:49 +000010635 assert(!FD->hasAttr<DLLExportAttr>());
10636 Diag(FD->getLocation(), diag::err_attribute_dllimport_function_definition);
10637 FD->setInvalidDecl();
10638 return D;
Anton Korobeynikovd72f47a2008-12-26 00:52:02 +000010639 }
Dmitri Gribenkob2610882012-08-14 17:17:18 +000010640 // We want to attach documentation to original Decl (which might be
10641 // a function template).
10642 ActOnDocumentableDecl(D);
Fariborz Jahanian3451df82014-05-28 17:02:35 +000010643 if (getCurLexicalContext()->isObjCContainer() &&
10644 getCurLexicalContext()->getDeclKind() != Decl::ObjCCategoryImpl &&
10645 getCurLexicalContext()->getDeclKind() != Decl::ObjCImplementation)
10646 Diag(FD->getLocation(), diag::warn_function_def_in_objc_container);
10647
Argyrios Kyrtzidis26444c52012-12-14 06:54:03 +000010648 return D;
Chris Lattnere168f762006-11-10 05:29:30 +000010649}
10650
Douglas Gregor6fd1b182010-05-15 06:01:05 +000010651/// \brief Given the set of return statements within a function body,
10652/// compute the variables that are subject to the named return value
10653/// optimization.
10654///
10655/// Each of the variables that is subject to the named return value
10656/// optimization will be marked as NRVO variables in the AST, and any
10657/// return statement that has a marked NRVO variable as its NRVO candidate can
10658/// use the named return value optimization.
10659///
10660/// This function applies a very simplistic algorithm for NRVO: if every return
Nick Lewyckyd78f92f2014-05-03 00:41:18 +000010661/// statement in the scope of a variable has the same NRVO candidate, that
10662/// candidate is an NRVO variable.
Douglas Gregor49695f02011-09-06 20:46:03 +000010663void Sema::computeNRVO(Stmt *Body, FunctionScopeInfo *Scope) {
John McCallaab3e412010-08-25 08:40:02 +000010664 ReturnStmt **Returns = Scope->Returns.data();
10665
John McCallaab3e412010-08-25 08:40:02 +000010666 for (unsigned I = 0, E = Scope->Returns.size(); I != E; ++I) {
Nick Lewyckyd78f92f2014-05-03 00:41:18 +000010667 if (const VarDecl *NRVOCandidate = Returns[I]->getNRVOCandidate()) {
10668 if (!NRVOCandidate->isNRVOVariable())
10669 Returns[I]->setNRVOCandidate(nullptr);
10670 }
Douglas Gregor6fd1b182010-05-15 06:01:05 +000010671 }
Douglas Gregor6fd1b182010-05-15 06:01:05 +000010672}
10673
Richard Smith8e6002f2014-03-12 23:14:33 +000010674bool Sema::canDelayFunctionBody(const Declarator &D) {
10675 // We can't delay parsing the body of a constexpr function template (yet).
10676 if (D.getDeclSpec().isConstexprSpecified())
10677 return false;
10678
10679 // We can't delay parsing the body of a function template with a deduced
10680 // return type (yet).
10681 if (D.getDeclSpec().containsPlaceholderType()) {
10682 // If the placeholder introduces a non-deduced trailing return type,
10683 // we can still delay parsing it.
10684 if (D.getNumTypeObjects()) {
10685 const auto &Outer = D.getTypeObject(D.getNumTypeObjects() - 1);
10686 if (Outer.Kind == DeclaratorChunk::Function &&
10687 Outer.Fun.hasTrailingReturnType()) {
10688 QualType Ty = GetTypeFromParser(Outer.Fun.getTrailingReturnType());
10689 return Ty.isNull() || !Ty->isUndeducedType();
10690 }
10691 }
10692 return false;
10693 }
10694
10695 return true;
10696}
10697
Richard Smith1ab34b32012-11-19 21:13:18 +000010698bool Sema::canSkipFunctionBody(Decl *D) {
Richard Smith1ab34b32012-11-19 21:13:18 +000010699 // We cannot skip the body of a function (or function template) which is
10700 // constexpr, since we may need to evaluate its body in order to parse the
10701 // rest of the file.
Richard Smith7500ab22013-05-10 04:31:10 +000010702 // We cannot skip the body of a function with an undeduced return type,
10703 // because any callers of that function need to know the type.
Alp Tokera2794f92014-01-22 07:29:52 +000010704 if (const FunctionDecl *FD = D->getAsFunction())
Alp Toker314cc812014-01-25 16:55:45 +000010705 if (FD->isConstexpr() || FD->getReturnType()->isUndeducedType())
Alp Tokera2794f92014-01-22 07:29:52 +000010706 return false;
10707 return Consumer.shouldSkipFunctionBody(D);
Richard Smith1ab34b32012-11-19 21:13:18 +000010708}
10709
Argyrios Kyrtzidis1eb71a12012-12-06 18:59:10 +000010710Decl *Sema::ActOnSkippedFunctionBody(Decl *Decl) {
Argyrios Kyrtzidis44319182013-02-22 04:11:06 +000010711 if (FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(Decl))
Argyrios Kyrtzidis1eb71a12012-12-06 18:59:10 +000010712 FD->setHasSkippedBody();
Argyrios Kyrtzidis44319182013-02-22 04:11:06 +000010713 else if (ObjCMethodDecl *MD = dyn_cast_or_null<ObjCMethodDecl>(Decl))
Argyrios Kyrtzidis1eb71a12012-12-06 18:59:10 +000010714 MD->setHasSkippedBody();
Craig Topperc3ec1492014-05-26 06:22:03 +000010715 return ActOnFinishFunctionBody(Decl, nullptr);
Argyrios Kyrtzidis1eb71a12012-12-06 18:59:10 +000010716}
10717
John McCallfaf5fb42010-08-26 23:41:50 +000010718Decl *Sema::ActOnFinishFunctionBody(Decl *D, Stmt *BodyArg) {
Benjamin Kramer62b95d82012-08-23 21:35:17 +000010719 return ActOnFinishFunctionBody(D, BodyArg, false);
Douglas Gregor67da0d92009-05-15 17:59:04 +000010720}
10721
John McCallb268a282010-08-23 23:25:46 +000010722Decl *Sema::ActOnFinishFunctionBody(Decl *dcl, Stmt *Body,
10723 bool IsInstantiation) {
Craig Topperc3ec1492014-05-26 06:22:03 +000010724 FunctionDecl *FD = dcl ? dcl->getAsFunction() : nullptr;
Douglas Gregorc45a40a2009-08-22 00:34:47 +000010725
Ted Kremenek0b405322010-03-23 00:13:23 +000010726 sema::AnalysisBasedWarnings::Policy WP = AnalysisWarnings.getDefaultPolicy();
Craig Topperc3ec1492014-05-26 06:22:03 +000010727 sema::AnalysisBasedWarnings::Policy *ActivePolicy = nullptr;
Ted Kremenek918fe842010-03-20 21:06:02 +000010728
Douglas Gregorc45a40a2009-08-22 00:34:47 +000010729 if (FD) {
Chris Lattner960cc522009-04-18 09:36:27 +000010730 FD->setBody(Body);
John McCall5ed3caf2012-02-14 19:50:52 +000010731
Aaron Ballmandd69ef32014-08-19 15:55:55 +000010732 if (getLangOpts().CPlusPlus14 && !FD->isInvalidDecl() && Body &&
Alp Toker314cc812014-01-25 16:55:45 +000010733 !FD->isDependentContext() && FD->getReturnType()->isUndeducedType()) {
Richard Smith7500ab22013-05-10 04:31:10 +000010734 // If the function has a deduced result type but contains no 'return'
10735 // statements, the result type as written must be exactly 'auto', and
10736 // the deduced result type is 'void'.
Alp Toker314cc812014-01-25 16:55:45 +000010737 if (!FD->getReturnType()->getAs<AutoType>()) {
Richard Smith7500ab22013-05-10 04:31:10 +000010738 Diag(dcl->getLocation(), diag::err_auto_fn_no_return_but_not_auto)
Alp Toker314cc812014-01-25 16:55:45 +000010739 << FD->getReturnType();
Richard Smith7500ab22013-05-10 04:31:10 +000010740 FD->setInvalidDecl();
10741 } else {
10742 // Substitute 'void' for the 'auto' in the type.
Saleem Abdulrasool374b5aa2014-10-16 22:42:53 +000010743 TypeLoc ResultType = getReturnTypeLoc(FD);
Richard Smith7500ab22013-05-10 04:31:10 +000010744 Context.adjustDeducedFunctionResultType(
10745 FD, SubstAutoType(ResultType.getType(), Context.VoidTy));
Richard Smith2a7d4812013-05-04 07:00:32 +000010746 }
Richard Smithc38498f2015-04-27 21:27:54 +000010747 } else if (getLangOpts().CPlusPlus11 && isLambdaCallOperator(FD)) {
10748 auto *LSI = getCurLambda();
10749 if (LSI->HasImplicitReturnType) {
10750 deduceClosureReturnType(*LSI);
10751
10752 // C++11 [expr.prim.lambda]p4:
10753 // [...] if there are no return statements in the compound-statement
10754 // [the deduced type is] the type void
10755 QualType RetType =
10756 LSI->ReturnType.isNull() ? Context.VoidTy : LSI->ReturnType;
10757
10758 // Update the return type to the deduced type.
10759 const FunctionProtoType *Proto =
10760 FD->getType()->getAs<FunctionProtoType>();
10761 FD->setType(Context.getFunctionType(RetType, Proto->getParamTypes(),
10762 Proto->getExtProtoInfo()));
10763 }
Richard Smith2a7d4812013-05-04 07:00:32 +000010764 }
10765
Nick Lewycky9c7eb1d2013-02-01 08:13:20 +000010766 // The only way to be included in UndefinedButUsed is if there is an
10767 // ODR use before the definition. Avoid the expensive map lookup if this
Nick Lewyckyf0f56162013-01-31 03:23:57 +000010768 // is the first declaration.
Rafael Espindola3f9e4442013-10-19 02:13:21 +000010769 if (!FD->isFirstDecl() && FD->getPreviousDecl()->isUsed()) {
Rafael Espindola3ae00052013-05-13 00:12:11 +000010770 if (!FD->isExternallyVisible())
Nick Lewycky9c7eb1d2013-02-01 08:13:20 +000010771 UndefinedButUsed.erase(FD);
10772 else if (FD->isInlined() &&
Peter Collingbourne470d9422015-05-13 22:07:22 +000010773 !LangOpts.GNUInline &&
Nick Lewycky9c7eb1d2013-02-01 08:13:20 +000010774 (!FD->getPreviousDecl()->hasAttr<GNUInlineAttr>()))
10775 UndefinedButUsed.erase(FD);
10776 }
Nick Lewyckyf0f56162013-01-31 03:23:57 +000010777
John McCall5ed3caf2012-02-14 19:50:52 +000010778 // If the function implicitly returns zero (like 'main') or is naked,
10779 // don't complain about missing return statements.
10780 if (FD->hasImplicitReturnZero() || FD->hasAttr<NakedAttr>())
Ted Kremenek0b405322010-03-23 00:13:23 +000010781 WP.disableCheckFallThrough();
Mike Stump11289f42009-09-09 15:08:12 +000010782
Francois Pichet3abc9b82011-05-11 02:14:46 +000010783 // MSVC permits the use of pure specifier (=0) on function definition,
Alp Tokerd4733632013-12-05 04:47:09 +000010784 // defined at class scope, warn about this non-standard construct.
Reid Klecknerbe7a4462013-10-08 22:45:29 +000010785 if (getLangOpts().MicrosoftExt && FD->isPure() && FD->isCanonicalDecl())
Richard Smith1b98ccc2014-07-19 01:39:17 +000010786 Diag(FD->getLocation(), diag::ext_pure_function_definition);
Francois Pichet3abc9b82011-05-11 02:14:46 +000010787
Douglas Gregor88d292c2010-05-13 16:44:06 +000010788 if (!FD->isInvalidDecl()) {
Reid Kleckner121b1a12014-04-30 16:31:28 +000010789 // Don't diagnose unused parameters of defaulted or deleted functions.
Benjamin Kramer8610cae2015-03-12 14:28:47 +000010790 if (!FD->isDeleted() && !FD->isDefaulted())
Reid Kleckner121b1a12014-04-30 16:31:28 +000010791 DiagnoseUnusedParameters(FD->param_begin(), FD->param_end());
Argyrios Kyrtzidisaf84ec02010-11-17 23:11:54 +000010792 DiagnoseSizeOfParametersAndReturnValue(FD->param_begin(), FD->param_end(),
Alp Toker314cc812014-01-25 16:55:45 +000010793 FD->getReturnType(), FD);
10794
Nico Weber8b51ae92015-01-13 03:52:11 +000010795 // If this is a structor, we need a vtable.
Douglas Gregor88d292c2010-05-13 16:44:06 +000010796 if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(FD))
10797 MarkVTableUsed(FD->getLocation(), Constructor->getParent());
Nico Weber8b51ae92015-01-13 03:52:11 +000010798 else if (CXXDestructorDecl *Destructor = dyn_cast<CXXDestructorDecl>(FD))
10799 MarkVTableUsed(FD->getLocation(), Destructor->getParent());
Douglas Gregor6fd1b182010-05-15 06:01:05 +000010800
Jordan Rosed39e5f12012-07-02 21:19:23 +000010801 // Try to apply the named return value optimization. We have to check
10802 // if we can do this here because lambdas keep return statements around
10803 // to deduce an implicit return type.
Alp Toker314cc812014-01-25 16:55:45 +000010804 if (getLangOpts().CPlusPlus && FD->getReturnType()->isRecordType() &&
Jordan Rosed39e5f12012-07-02 21:19:23 +000010805 !FD->isDependentContext())
10806 computeNRVO(Body, getCurFunction());
Douglas Gregor88d292c2010-05-13 16:44:06 +000010807 }
Richard Smith91c18de2015-02-28 01:01:56 +000010808
Benjamin Kramer8610cae2015-03-12 14:28:47 +000010809 // GNU warning -Wmissing-prototypes:
10810 // Warn if a global function is defined without a previous
10811 // prototype declaration. This warning is issued even if the
10812 // definition itself provides a prototype. The aim is to detect
10813 // global functions that fail to be declared in header files.
10814 const FunctionDecl *PossibleZeroParamPrototype = nullptr;
10815 if (ShouldWarnAboutMissingPrototype(FD, PossibleZeroParamPrototype)) {
10816 Diag(FD->getLocation(), diag::warn_missing_prototype) << FD;
10817
10818 if (PossibleZeroParamPrototype) {
10819 // We found a declaration that is not a prototype,
10820 // but that could be a zero-parameter prototype
10821 if (TypeSourceInfo *TI =
10822 PossibleZeroParamPrototype->getTypeSourceInfo()) {
10823 TypeLoc TL = TI->getTypeLoc();
10824 if (FunctionNoProtoTypeLoc FTL = TL.getAs<FunctionNoProtoTypeLoc>())
10825 Diag(PossibleZeroParamPrototype->getLocation(),
10826 diag::note_declaration_not_a_prototype)
10827 << PossibleZeroParamPrototype
10828 << FixItHint::CreateInsertion(FTL.getRParenLoc(), "void");
10829 }
10830 }
10831 }
10832
Richard Smith91c18de2015-02-28 01:01:56 +000010833 if (auto *MD = dyn_cast<CXXMethodDecl>(FD)) {
10834 const CXXMethodDecl *KeyFunction;
10835 if (MD->isOutOfLine() && (MD = MD->getCanonicalDecl()) &&
10836 MD->isVirtual() &&
10837 (KeyFunction = Context.getCurrentKeyFunction(MD->getParent())) &&
10838 MD == KeyFunction->getCanonicalDecl()) {
10839 // Update the key-function state if necessary for this ABI.
10840 if (FD->isInlined() &&
10841 !Context.getTargetInfo().getCXXABI().canKeyFunctionBeInline()) {
10842 Context.setNonKeyFunction(MD);
10843
10844 // If the newly-chosen key function is already defined, then we
10845 // need to mark the vtable as used retroactively.
10846 KeyFunction = Context.getCurrentKeyFunction(MD->getParent());
10847 const FunctionDecl *Definition;
10848 if (KeyFunction && KeyFunction->isDefined(Definition))
10849 MarkVTableUsed(Definition->getLocation(), MD->getParent(), true);
10850 } else {
10851 // We just defined they key function; mark the vtable as used.
10852 MarkVTableUsed(FD->getLocation(), MD->getParent(), true);
10853 }
10854 }
10855 }
10856
Douglas Gregor21f46922012-02-08 20:17:14 +000010857 assert((FD == getCurFunctionDecl() || getCurLambda()->CallOperator == FD) &&
10858 "Function parsing confused");
Steve Naroff542cd5d2008-07-25 17:57:26 +000010859 } else if (ObjCMethodDecl *MD = dyn_cast_or_null<ObjCMethodDecl>(dcl)) {
Chris Lattner1598a3a2009-02-16 19:27:54 +000010860 assert(MD == getCurMethodDecl() && "Method parsing confused");
Chris Lattner960cc522009-04-18 09:36:27 +000010861 MD->setBody(Body);
Argyrios Kyrtzidisaf84ec02010-11-17 23:11:54 +000010862 if (!MD->isInvalidDecl()) {
Douglas Gregorc9c02ed2009-06-19 23:52:42 +000010863 DiagnoseUnusedParameters(MD->param_begin(), MD->param_end());
Argyrios Kyrtzidisaf84ec02010-11-17 23:11:54 +000010864 DiagnoseSizeOfParametersAndReturnValue(MD->param_begin(), MD->param_end(),
Alp Toker314cc812014-01-25 16:55:45 +000010865 MD->getReturnType(), MD);
10866
Douglas Gregore3f3ea02011-09-06 20:33:37 +000010867 if (Body)
Douglas Gregor49695f02011-09-06 20:46:03 +000010868 computeNRVO(Body, getCurFunction());
Argyrios Kyrtzidisaf84ec02010-11-17 23:11:54 +000010869 }
Jordan Rose2afd6612012-10-19 16:05:26 +000010870 if (getCurFunction()->ObjCShouldCallSuper) {
Fariborz Jahanianb05417e2012-09-10 16:51:09 +000010871 Diag(MD->getLocEnd(), diag::warn_objc_missing_super_call)
10872 << MD->getSelector().getAsString();
Jordan Rose2afd6612012-10-19 16:05:26 +000010873 getCurFunction()->ObjCShouldCallSuper = false;
Nico Weber1fb82662011-08-28 22:35:17 +000010874 }
Argyrios Kyrtzidis22bfa2c2013-12-03 21:11:36 +000010875 if (getCurFunction()->ObjCWarnForNoDesignatedInitChain) {
Craig Topperc3ec1492014-05-26 06:22:03 +000010876 const ObjCMethodDecl *InitMethod = nullptr;
Argyrios Kyrtzidisfcded9b2013-12-03 21:11:43 +000010877 bool isDesignated =
10878 MD->isDesignatedInitializerForTheInterface(&InitMethod);
Argyrios Kyrtzidis22bfa2c2013-12-03 21:11:36 +000010879 assert(isDesignated && InitMethod);
10880 (void)isDesignated;
Argyrios Kyrtzidisde103662014-04-16 18:32:51 +000010881
10882 auto superIsNSObject = [&](const ObjCMethodDecl *MD) {
10883 auto IFace = MD->getClassInterface();
10884 if (!IFace)
10885 return false;
10886 auto SuperD = IFace->getSuperClass();
10887 if (!SuperD)
10888 return false;
10889 return SuperD->getIdentifier() ==
10890 NSAPIObj->getNSClassId(NSAPI::ClassId_NSObject);
10891 };
10892 // Don't issue this warning for unavailable inits or direct subclasses
10893 // of NSObject.
10894 if (!MD->isUnavailable() && !superIsNSObject(MD)) {
Fariborz Jahaniane3b5c992014-03-14 23:30:18 +000010895 Diag(MD->getLocation(),
10896 diag::warn_objc_designated_init_missing_super_call);
10897 Diag(InitMethod->getLocation(),
10898 diag::note_objc_designated_init_marked_here);
10899 }
Argyrios Kyrtzidis22bfa2c2013-12-03 21:11:36 +000010900 getCurFunction()->ObjCWarnForNoDesignatedInitChain = false;
10901 }
Argyrios Kyrtzidisb66d3cf2013-12-03 21:11:49 +000010902 if (getCurFunction()->ObjCWarnForNoInitDelegation) {
Fariborz Jahaniane3b5c992014-03-14 23:30:18 +000010903 // Don't issue this warning for unavaialable inits.
10904 if (!MD->isUnavailable())
Nico Weber3b00fdc2015-03-07 19:52:39 +000010905 Diag(MD->getLocation(),
10906 diag::warn_objc_secondary_init_missing_init_call);
Argyrios Kyrtzidisb66d3cf2013-12-03 21:11:49 +000010907 getCurFunction()->ObjCWarnForNoInitDelegation = false;
10908 }
Ted Kremenek5a201952009-02-07 01:47:29 +000010909 } else {
Craig Topperc3ec1492014-05-26 06:22:03 +000010910 return nullptr;
Ted Kremenek5a201952009-02-07 01:47:29 +000010911 }
Douglas Gregor67da0d92009-05-15 17:59:04 +000010912
Jordan Rose2afd6612012-10-19 16:05:26 +000010913 assert(!getCurFunction()->ObjCShouldCallSuper &&
Eli Friedman22be06a2012-08-01 21:02:59 +000010914 "This should only be set for ObjC methods, which should have been "
10915 "handled in the block above.");
Nico Weber715abaf2011-08-22 17:25:57 +000010916
Chris Lattnere2473062007-05-28 06:28:18 +000010917 // Verify and clean out per-function state.
Benjamin Kramer8610cae2015-03-12 14:28:47 +000010918 if (Body && (!FD || !FD->isDefaulted())) {
Douglas Gregor9a28e842010-03-01 23:15:13 +000010919 // C++ constructors that have function-try-blocks can't have return
10920 // statements in the handlers of that block. (C++ [except.handle]p14)
10921 // Verify this.
10922 if (FD && isa<CXXConstructorDecl>(FD) && isa<CXXTryStmt>(Body))
10923 DiagnoseReturnInConstructorExceptionHandler(cast<CXXTryStmt>(Body));
10924
Richard Smithdef8bdb2011-08-12 18:44:32 +000010925 // Verify that gotos and switch cases don't jump into scopes illegally.
John McCallaab3e412010-08-25 08:40:02 +000010926 if (getCurFunction()->NeedsScopeChecking() &&
Douglas Gregor5d944db2012-08-17 05:12:08 +000010927 !PP.isCodeCompletionEnabled())
Douglas Gregor9a28e842010-03-01 23:15:13 +000010928 DiagnoseInvalidJumps(Body);
Mike Stump11289f42009-09-09 15:08:12 +000010929
John McCalldeb646e2010-08-04 01:04:25 +000010930 if (CXXDestructorDecl *Destructor = dyn_cast<CXXDestructorDecl>(dcl)) {
10931 if (!Destructor->getParent()->isDependentType())
10932 CheckDestructor(Destructor);
10933
John McCalla6309952010-03-16 21:39:52 +000010934 MarkBaseAndMemberDestructorsReferenced(Destructor->getLocation(),
10935 Destructor->getParent());
John McCalldeb646e2010-08-04 01:04:25 +000010936 }
Douglas Gregor9a28e842010-03-01 23:15:13 +000010937
10938 // If any errors have occurred, clear out any temporaries that may have
10939 // been leftover. This ensures that these temporaries won't be picked up for
10940 // deletion in some later function.
Alp Tokerb6cc5922014-05-03 03:45:55 +000010941 if (getDiagnostics().hasErrorOccurred() ||
10942 getDiagnostics().getSuppressAllDiagnostics()) {
John McCall28fc7092011-11-10 05:35:25 +000010943 DiscardCleanupsInEvaluationContext();
DeLesley Hutchins8ecd4912012-12-07 22:53:48 +000010944 }
Alp Tokerb6cc5922014-05-03 03:45:55 +000010945 if (!getDiagnostics().hasUncompilableErrorOccurred() &&
DeLesley Hutchins8ecd4912012-12-07 22:53:48 +000010946 !isa<FunctionTemplateDecl>(dcl)) {
Ted Kremenek918fe842010-03-20 21:06:02 +000010947 // Since the body is valid, issue any analysis-based warnings that are
10948 // enabled.
Ted Kremenek1767a272011-02-23 01:51:48 +000010949 ActivePolicy = &WP;
Ted Kremenek918fe842010-03-20 21:06:02 +000010950 }
10951
Richard Smith3607ffe2012-02-13 03:54:03 +000010952 if (!IsInstantiation && FD && FD->isConstexpr() && !FD->isInvalidDecl() &&
10953 (!CheckConstexprFunctionDecl(FD) ||
10954 !CheckConstexprFunctionBody(FD, Body)))
Richard Smitheb3c10c2011-10-01 02:31:28 +000010955 FD->setInvalidDecl();
10956
Hans Wennborgd62cdd2c2014-09-04 22:16:40 +000010957 if (FD && FD->hasAttr<NakedAttr>()) {
10958 for (const Stmt *S : Body->children()) {
Ehsan Akhgari5c00c312014-09-09 02:49:40 +000010959 if (!isa<AsmStmt>(S) && !isa<NullStmt>(S)) {
Hans Wennborgd62cdd2c2014-09-04 22:16:40 +000010960 Diag(S->getLocStart(), diag::err_non_asm_stmt_in_naked_function);
10961 Diag(FD->getAttr<NakedAttr>()->getLocation(), diag::note_attribute);
10962 FD->setInvalidDecl();
10963 break;
10964 }
10965 }
10966 }
10967
Nico Weber3b00fdc2015-03-07 19:52:39 +000010968 assert(ExprCleanupObjects.size() ==
10969 ExprEvalContexts.back().NumCleanupObjects &&
10970 "Leftover temporaries in function");
John McCall31168b02011-06-15 23:02:42 +000010971 assert(!ExprNeedsCleanups && "Unaccounted cleanups in function");
Eli Friedman3bda6b12012-02-02 23:15:15 +000010972 assert(MaybeODRUseExprs.empty() &&
10973 "Leftover expressions for odr-use checking");
Douglas Gregor9a28e842010-03-01 23:15:13 +000010974 }
10975
John McCalle99d5f32010-03-25 22:08:03 +000010976 if (!IsInstantiation)
10977 PopDeclContext();
10978
Eli Friedman71c80552012-01-05 03:35:19 +000010979 PopFunctionScopeInfo(ActivePolicy, dcl);
Douglas Gregora7e3ea32009-11-15 07:07:58 +000010980 // If any errors have occurred, clear out any temporaries that may have
10981 // been leftover. This ensures that these temporaries won't be picked up for
10982 // deletion in some later function.
John McCall31168b02011-06-15 23:02:42 +000010983 if (getDiagnostics().hasErrorOccurred()) {
John McCall28fc7092011-11-10 05:35:25 +000010984 DiscardCleanupsInEvaluationContext();
John McCall31168b02011-06-15 23:02:42 +000010985 }
Argyrios Kyrtzidis35672e72010-08-13 18:42:17 +000010986
John McCall48871652010-08-21 09:40:31 +000010987 return dcl;
Fariborz Jahanian85e1d0d2007-11-10 16:31:34 +000010988}
10989
Caitlin Sadowski9385dd72011-09-08 17:42:22 +000010990
10991/// When we finish delayed parsing of an attribute, we must attach it to the
10992/// relevant Decl.
10993void Sema::ActOnFinishDelayedAttribute(Scope *S, Decl *D,
10994 ParsedAttributes &Attrs) {
DeLesley Hutchinsceec3062012-01-20 22:37:06 +000010995 // Always attach attributes to the underlying decl.
10996 if (TemplateDecl *TD = dyn_cast<TemplateDecl>(D))
10997 D = TD->getTemplatedDecl();
Douglas Gregor3024f072012-04-16 07:05:22 +000010998 ProcessDeclAttributeList(S, D, Attrs.getList());
10999
11000 if (CXXMethodDecl *Method = dyn_cast_or_null<CXXMethodDecl>(D))
11001 if (Method->isStatic())
11002 checkThisInStaticMemberFunctionAttributes(Method);
Caitlin Sadowski9385dd72011-09-08 17:42:22 +000011003}
11004
11005
Chris Lattnerac18be92006-11-20 06:49:47 +000011006/// ImplicitlyDefineFunction - An undeclared identifier was used in a function
11007/// call, forming a call to an implicitly defined function (per C99 6.5.1p2).
Mike Stump11289f42009-09-09 15:08:12 +000011008NamedDecl *Sema::ImplicitlyDefineFunction(SourceLocation Loc,
Douglas Gregor6e6ad602009-01-20 01:17:11 +000011009 IdentifierInfo &II, Scope *S) {
Douglas Gregor5a80bd12009-03-02 00:19:53 +000011010 // Before we produce a declaration for an implicitly defined
11011 // function, see whether there was a locally-scoped declaration of
11012 // this name as a function or variable. If so, use that
11013 // (non-visible) declaration, and complain about it.
Richard Smith39b79682013-06-18 20:15:12 +000011014 if (NamedDecl *ExternCPrev = findLocallyScopedExternCDecl(&II)) {
11015 Diag(Loc, diag::warn_use_out_of_scope_declaration) << ExternCPrev;
11016 Diag(ExternCPrev->getLocation(), diag::note_previous_declaration);
11017 return ExternCPrev;
Douglas Gregor5a80bd12009-03-02 00:19:53 +000011018 }
11019
Chris Lattner00e26072008-05-05 21:18:06 +000011020 // Extension in C99. Legal in C90, but warn about it.
Hans Wennborg70a13242011-12-08 15:56:07 +000011021 unsigned diag_id;
Daniel Dunbar07d07852009-10-18 21:17:35 +000011022 if (II.getName().startswith("__builtin_"))
Abramo Bagnara3732fa52012-01-09 10:05:48 +000011023 diag_id = diag::warn_builtin_unknown;
David Blaikiebbafb8a2012-03-11 07:00:24 +000011024 else if (getLangOpts().C99)
Hans Wennborg70a13242011-12-08 15:56:07 +000011025 diag_id = diag::ext_implicit_function_decl;
Chris Lattner00e26072008-05-05 21:18:06 +000011026 else
Hans Wennborg70a13242011-12-08 15:56:07 +000011027 diag_id = diag::warn_implicit_function_decl;
11028 Diag(Loc, diag_id) << &II;
Mike Stump11289f42009-09-09 15:08:12 +000011029
Hans Wennborg70a13242011-12-08 15:56:07 +000011030 // Because typo correction is expensive, only do it if the implicit
11031 // function declaration is going to be treated as an error.
11032 if (Diags.getDiagnosticLevel(diag_id, Loc) >= DiagnosticsEngine::Error) {
11033 TypoCorrection Corrected;
Kaelyn Takata89c881b2014-10-27 18:07:29 +000011034 if (S &&
11035 (Corrected = CorrectTypo(
11036 DeclarationNameInfo(&II, Loc), LookupOrdinaryName, S, nullptr,
11037 llvm::make_unique<DeclFilterCCC<FunctionDecl>>(), CTK_NonError)))
Richard Smithf9b15102013-08-17 00:46:16 +000011038 diagnoseTypo(Corrected, PDiag(diag::note_function_suggestion),
11039 /*ErrorRecovery*/false);
Hans Wennborg2fb8b912011-12-06 09:46:12 +000011040 }
11041
Chris Lattnerac18be92006-11-20 06:49:47 +000011042 // Set a Declarator for the implicit definition: int foo();
Chris Lattner353f5742006-11-28 04:50:12 +000011043 const char *Dummy;
John McCall084e83d2011-03-24 11:26:52 +000011044 AttributeFactory attrFactory;
11045 DeclSpec DS(attrFactory);
John McCall49bfce42009-08-03 20:12:06 +000011046 unsigned DiagID;
Erik Verbruggen888d52a2014-01-15 09:15:43 +000011047 bool Error = DS.SetTypeSpecType(DeclSpec::TST_int, Loc, Dummy, DiagID,
11048 Context.getPrintingPolicy());
Jeffrey Yasskinb3321532010-12-23 01:01:28 +000011049 (void)Error; // Silence warning.
Chris Lattner353f5742006-11-28 04:50:12 +000011050 assert(!Error && "Error setting up implicit decl!");
Abramo Bagnaraaeeb9892012-10-04 21:42:10 +000011051 SourceLocation NoLoc;
Chris Lattnerac18be92006-11-20 06:49:47 +000011052 Declarator D(DS, Declarator::BlockContext);
Abramo Bagnaraaeeb9892012-10-04 21:42:10 +000011053 D.AddTypeInfo(DeclaratorChunk::getFunction(/*HasProto=*/false,
11054 /*IsAmbiguous=*/false,
Richard Smith151b8a32014-04-07 15:16:58 +000011055 /*LParenLoc=*/NoLoc,
Craig Topperc3ec1492014-05-26 06:22:03 +000011056 /*Params=*/nullptr,
Richard Smith151b8a32014-04-07 15:16:58 +000011057 /*NumParams=*/0,
Abramo Bagnaraaeeb9892012-10-04 21:42:10 +000011058 /*EllipsisLoc=*/NoLoc,
11059 /*RParenLoc=*/NoLoc,
11060 /*TypeQuals=*/0,
11061 /*RefQualifierIsLvalueRef=*/true,
11062 /*RefQualifierLoc=*/NoLoc,
11063 /*ConstQualifierLoc=*/NoLoc,
11064 /*VolatileQualifierLoc=*/NoLoc,
Hal Finkel23a07392014-10-20 17:32:04 +000011065 /*RestrictQualifierLoc=*/NoLoc,
Abramo Bagnaraaeeb9892012-10-04 21:42:10 +000011066 /*MutableLoc=*/NoLoc,
11067 EST_None,
11068 /*ESpecLoc=*/NoLoc,
Craig Topperc3ec1492014-05-26 06:22:03 +000011069 /*Exceptions=*/nullptr,
11070 /*ExceptionRanges=*/nullptr,
Abramo Bagnaraaeeb9892012-10-04 21:42:10 +000011071 /*NumExceptions=*/0,
Craig Topperc3ec1492014-05-26 06:22:03 +000011072 /*NoexceptExpr=*/nullptr,
Richard Smith0b3a4622014-11-13 20:01:57 +000011073 /*ExceptionSpecTokens=*/nullptr,
Abramo Bagnaraaeeb9892012-10-04 21:42:10 +000011074 Loc, Loc, D),
John McCall084e83d2011-03-24 11:26:52 +000011075 DS.getAttributes(),
Sebastian Redlf6591ca2009-02-09 18:23:29 +000011076 SourceLocation());
Chris Lattnerac18be92006-11-20 06:49:47 +000011077 D.SetIdentifier(&II, Loc);
Sebastian Redlf6591ca2009-02-09 18:23:29 +000011078
Argyrios Kyrtzidis694dda12008-05-01 21:04:16 +000011079 // Insert this function into translation-unit scope.
11080
11081 DeclContext *PrevDC = CurContext;
11082 CurContext = Context.getTranslationUnitDecl();
Mike Stump11289f42009-09-09 15:08:12 +000011083
Jordan Rosed03d99d2013-03-05 01:27:54 +000011084 FunctionDecl *FD = cast<FunctionDecl>(ActOnDeclarator(TUScope, D));
Steve Naroff3913ea42008-04-04 14:32:09 +000011085 FD->setImplicit();
Argyrios Kyrtzidis694dda12008-05-01 21:04:16 +000011086
11087 CurContext = PrevDC;
11088
Douglas Gregore711f702009-02-14 18:57:46 +000011089 AddKnownFunctionAttributes(FD);
11090
Steve Naroff3913ea42008-04-04 14:32:09 +000011091 return FD;
Chris Lattnerac18be92006-11-20 06:49:47 +000011092}
11093
Douglas Gregore711f702009-02-14 18:57:46 +000011094/// \brief Adds any function attributes that we know a priori based on
11095/// the declaration of this function.
11096///
11097/// These attributes can apply both to implicitly-declared builtins
11098/// (like __builtin___printf_chk) or to library-declared functions
11099/// like NSLog or printf.
Douglas Gregor88336832011-06-15 05:45:11 +000011100///
11101/// We need to check for duplicate attributes both here and where user-written
11102/// attributes are applied to declarations.
Douglas Gregore711f702009-02-14 18:57:46 +000011103void Sema::AddKnownFunctionAttributes(FunctionDecl *FD) {
11104 if (FD->isInvalidDecl())
11105 return;
11106
11107 // If this is a built-in function, map its builtin attributes to
11108 // actual attributes.
Douglas Gregor15fc9562009-09-12 00:22:50 +000011109 if (unsigned BuiltinID = FD->getBuiltinID()) {
Douglas Gregore711f702009-02-14 18:57:46 +000011110 // Handle printf-formatting attributes.
11111 unsigned FormatIdx;
11112 bool HasVAListArg;
11113 if (Context.BuiltinInfo.isPrintfLike(BuiltinID, FormatIdx, HasVAListArg)) {
Aaron Ballman9ead1242013-12-19 02:39:40 +000011114 if (!FD->hasAttr<FormatAttr>()) {
Jean-Daniel Dupas78536ae2012-01-24 22:32:46 +000011115 const char *fmt = "printf";
11116 unsigned int NumParams = FD->getNumParams();
11117 if (FormatIdx < NumParams && // NumParams may be 0 (e.g. vfprintf)
11118 FD->getParamDecl(FormatIdx)->getType()->isObjCObjectPointerType())
11119 fmt = "NSString";
Aaron Ballman36a53502014-01-16 13:03:14 +000011120 FD->addAttr(FormatAttr::CreateImplicit(Context,
Aaron Ballmanf58070b2013-09-03 21:02:22 +000011121 &Context.Idents.get(fmt),
11122 FormatIdx+1,
Aaron Ballman36a53502014-01-16 13:03:14 +000011123 HasVAListArg ? 0 : FormatIdx+2,
11124 FD->getLocation()));
Jean-Daniel Dupas78536ae2012-01-24 22:32:46 +000011125 }
Douglas Gregore711f702009-02-14 18:57:46 +000011126 }
Ted Kremenek5932c352010-07-16 02:11:15 +000011127 if (Context.BuiltinInfo.isScanfLike(BuiltinID, FormatIdx,
11128 HasVAListArg)) {
Aaron Ballman9ead1242013-12-19 02:39:40 +000011129 if (!FD->hasAttr<FormatAttr>())
Aaron Ballman36a53502014-01-16 13:03:14 +000011130 FD->addAttr(FormatAttr::CreateImplicit(Context,
Aaron Ballmanf58070b2013-09-03 21:02:22 +000011131 &Context.Idents.get("scanf"),
11132 FormatIdx+1,
Aaron Ballman36a53502014-01-16 13:03:14 +000011133 HasVAListArg ? 0 : FormatIdx+2,
11134 FD->getLocation()));
Ted Kremenek5932c352010-07-16 02:11:15 +000011135 }
Daniel Dunbar8eb018a2009-02-16 22:43:43 +000011136
11137 // Mark const if we don't care about errno and that is the only
11138 // thing preventing the function from being const. This allows
11139 // IRgen to use LLVM intrinsics for such functions.
David Blaikiebbafb8a2012-03-11 07:00:24 +000011140 if (!getLangOpts().MathErrno &&
Daniel Dunbar8eb018a2009-02-16 22:43:43 +000011141 Context.BuiltinInfo.isConstWithoutErrno(BuiltinID)) {
Aaron Ballman9ead1242013-12-19 02:39:40 +000011142 if (!FD->hasAttr<ConstAttr>())
Aaron Ballman36a53502014-01-16 13:03:14 +000011143 FD->addAttr(ConstAttr::CreateImplicit(Context, FD->getLocation()));
Daniel Dunbar8eb018a2009-02-16 22:43:43 +000011144 }
Mike Stumpca6c8752009-07-27 19:14:18 +000011145
Rafael Espindola2d21ab02011-10-12 19:51:18 +000011146 if (Context.BuiltinInfo.isReturnsTwice(BuiltinID) &&
Aaron Ballman9ead1242013-12-19 02:39:40 +000011147 !FD->hasAttr<ReturnsTwiceAttr>())
Aaron Ballman36a53502014-01-16 13:03:14 +000011148 FD->addAttr(ReturnsTwiceAttr::CreateImplicit(Context,
11149 FD->getLocation()));
Aaron Ballman9ead1242013-12-19 02:39:40 +000011150 if (Context.BuiltinInfo.isNoThrow(BuiltinID) && !FD->hasAttr<NoThrowAttr>())
Aaron Ballman36a53502014-01-16 13:03:14 +000011151 FD->addAttr(NoThrowAttr::CreateImplicit(Context, FD->getLocation()));
Aaron Ballman9ead1242013-12-19 02:39:40 +000011152 if (Context.BuiltinInfo.isConst(BuiltinID) && !FD->hasAttr<ConstAttr>())
Aaron Ballman36a53502014-01-16 13:03:14 +000011153 FD->addAttr(ConstAttr::CreateImplicit(Context, FD->getLocation()));
Douglas Gregore711f702009-02-14 18:57:46 +000011154 }
11155
11156 IdentifierInfo *Name = FD->getIdentifier();
11157 if (!Name)
11158 return;
David Blaikiebbafb8a2012-03-11 07:00:24 +000011159 if ((!getLangOpts().CPlusPlus &&
Douglas Gregore711f702009-02-14 18:57:46 +000011160 FD->getDeclContext()->isTranslationUnit()) ||
11161 (isa<LinkageSpecDecl>(FD->getDeclContext()) &&
Mike Stump11289f42009-09-09 15:08:12 +000011162 cast<LinkageSpecDecl>(FD->getDeclContext())->getLanguage() ==
Douglas Gregore711f702009-02-14 18:57:46 +000011163 LinkageSpecDecl::lang_c)) {
11164 // Okay: this could be a libc/libm/Objective-C function we know
11165 // about.
11166 } else
11167 return;
11168
Jean-Daniel Dupas78536ae2012-01-24 22:32:46 +000011169 if (Name->isStr("asprintf") || Name->isStr("vasprintf")) {
Mike Stump82a9e442009-07-28 00:07:08 +000011170 // FIXME: asprintf and vasprintf aren't C99 functions. Should they be
Mike Stump11289f42009-09-09 15:08:12 +000011171 // target-specific builtins, perhaps?
Aaron Ballman9ead1242013-12-19 02:39:40 +000011172 if (!FD->hasAttr<FormatAttr>())
Aaron Ballman36a53502014-01-16 13:03:14 +000011173 FD->addAttr(FormatAttr::CreateImplicit(Context,
Aaron Ballmanf58070b2013-09-03 21:02:22 +000011174 &Context.Idents.get("printf"), 2,
Aaron Ballman36a53502014-01-16 13:03:14 +000011175 Name->isStr("vasprintf") ? 0 : 3,
11176 FD->getLocation()));
Mike Stumpa4de80b2009-07-28 02:25:19 +000011177 }
Jordan Rose742c6072012-08-08 21:17:31 +000011178
11179 if (Name->isStr("__CFStringMakeConstantString")) {
11180 // We already have a __builtin___CFStringMakeConstantString,
11181 // but builds that use -fno-constant-cfstrings don't go through that.
Aaron Ballman9ead1242013-12-19 02:39:40 +000011182 if (!FD->hasAttr<FormatArgAttr>())
Aaron Ballman36a53502014-01-16 13:03:14 +000011183 FD->addAttr(FormatArgAttr::CreateImplicit(Context, 1,
11184 FD->getLocation()));
Jordan Rose742c6072012-08-08 21:17:31 +000011185 }
Douglas Gregore711f702009-02-14 18:57:46 +000011186}
Chris Lattner302b4be2006-11-19 02:31:38 +000011187
John McCall703a3f82009-10-24 08:00:42 +000011188TypedefDecl *Sema::ParseTypedefDecl(Scope *S, Declarator &D, QualType T,
John McCallbcd03502009-12-07 02:54:59 +000011189 TypeSourceInfo *TInfo) {
Chris Lattner776fac82007-06-09 00:53:06 +000011190 assert(D.getIdentifier() && "Wrong callback for declspec without declarator");
Steve Narofff93b6722007-08-28 20:14:24 +000011191 assert(!T.isNull() && "GetTypeForDeclarator() returned null type");
Mike Stump11289f42009-09-09 15:08:12 +000011192
John McCallbcd03502009-12-07 02:54:59 +000011193 if (!TInfo) {
John McCall703a3f82009-10-24 08:00:42 +000011194 assert(D.isInvalidType() && "no declarator info for valid type");
John McCallbcd03502009-12-07 02:54:59 +000011195 TInfo = Context.getTrivialTypeSourceInfo(T);
John McCall703a3f82009-10-24 08:00:42 +000011196 }
11197
Chris Lattner18b19622007-01-22 07:39:13 +000011198 // Scope manipulation handled by caller.
Chris Lattnerc5ffed42008-04-04 06:12:32 +000011199 TypedefDecl *NewTD = TypedefDecl::Create(Context, CurContext,
Daniel Dunbar62ee6412012-03-09 18:35:03 +000011200 D.getLocStart(),
Chris Lattnerc5ffed42008-04-04 06:12:32 +000011201 D.getIdentifierLoc(),
Mike Stump11289f42009-09-09 15:08:12 +000011202 D.getIdentifier(),
John McCallbcd03502009-12-07 02:54:59 +000011203 TInfo);
Mike Stump11289f42009-09-09 15:08:12 +000011204
John McCall04fcd0d2011-02-01 08:20:08 +000011205 // Bail out immediately if we have an invalid declaration.
11206 if (D.isInvalidType()) {
11207 NewTD->setInvalidDecl();
11208 return NewTD;
Anders Carlsson02751152009-03-10 17:07:44 +000011209 }
Fariborz Jahaniandb3d8552013-11-19 00:09:48 +000011210
Douglas Gregor41866812011-09-12 18:37:38 +000011211 if (D.getDeclSpec().isModulePrivateSpecified()) {
11212 if (CurContext->isFunctionOrMethod())
11213 Diag(NewTD->getLocation(), diag::err_module_private_local)
11214 << 2 << NewTD->getDeclName()
11215 << SourceRange(D.getDeclSpec().getModulePrivateSpecLoc())
11216 << FixItHint::CreateRemoval(D.getDeclSpec().getModulePrivateSpecLoc());
11217 else
11218 NewTD->setModulePrivate();
11219 }
Douglas Gregor26701a42011-09-09 02:06:17 +000011220
John McCall04fcd0d2011-02-01 08:20:08 +000011221 // C++ [dcl.typedef]p8:
11222 // If the typedef declaration defines an unnamed class (or
11223 // enum), the first typedef-name declared by the declaration
11224 // to be that class type (or enum type) is used to denote the
11225 // class type (or enum type) for linkage purposes only.
11226 // We need to check whether the type was declared in the declaration.
11227 switch (D.getDeclSpec().getTypeSpecType()) {
11228 case TST_enum:
11229 case TST_struct:
Joao Matosdc86f942012-08-31 18:45:21 +000011230 case TST_interface:
John McCall04fcd0d2011-02-01 08:20:08 +000011231 case TST_union:
11232 case TST_class: {
11233 TagDecl *tagFromDeclSpec = cast<TagDecl>(D.getDeclSpec().getRepAsDecl());
David Majnemerf9bde282015-03-11 06:45:39 +000011234 setTagNameForLinkagePurposes(tagFromDeclSpec, NewTD);
John McCall04fcd0d2011-02-01 08:20:08 +000011235 break;
11236 }
David Majnemerf9bde282015-03-11 06:45:39 +000011237
John McCall04fcd0d2011-02-01 08:20:08 +000011238 default:
11239 break;
11240 }
11241
Steve Narofff93b6722007-08-28 20:14:24 +000011242 return NewTD;
Chris Lattnere168f762006-11-10 05:29:30 +000011243}
11244
Douglas Gregord9034f02009-05-14 16:41:31 +000011245
Richard Smith4b38ded2012-03-14 23:13:10 +000011246/// \brief Check that this is a valid underlying type for an enum declaration.
11247bool Sema::CheckEnumUnderlyingType(TypeSourceInfo *TI) {
11248 SourceLocation UnderlyingLoc = TI->getTypeLoc().getBeginLoc();
11249 QualType T = TI->getType();
11250
Eli Friedman52f32b92012-12-18 02:37:32 +000011251 if (T->isDependentType())
Richard Smith4b38ded2012-03-14 23:13:10 +000011252 return false;
11253
Eli Friedman52f32b92012-12-18 02:37:32 +000011254 if (const BuiltinType *BT = T->getAs<BuiltinType>())
11255 if (BT->isInteger())
11256 return false;
11257
Richard Smith4b38ded2012-03-14 23:13:10 +000011258 Diag(UnderlyingLoc, diag::err_enum_invalid_underlying) << T;
11259 return true;
11260}
11261
11262/// Check whether this is a valid redeclaration of a previous enumeration.
11263/// \return true if the redeclaration was invalid.
11264bool Sema::CheckEnumRedeclaration(SourceLocation EnumLoc, bool IsScoped,
11265 QualType EnumUnderlyingTy,
11266 const EnumDecl *Prev) {
11267 bool IsFixed = !EnumUnderlyingTy.isNull();
11268
11269 if (IsScoped != Prev->isScoped()) {
11270 Diag(EnumLoc, diag::err_enum_redeclare_scoped_mismatch)
11271 << Prev->isScoped();
Alp Toker8c44db52014-01-06 11:31:06 +000011272 Diag(Prev->getLocation(), diag::note_previous_declaration);
Richard Smith4b38ded2012-03-14 23:13:10 +000011273 return true;
11274 }
11275
11276 if (IsFixed && Prev->isFixed()) {
Richard Smith258a7442012-03-26 04:08:46 +000011277 if (!EnumUnderlyingTy->isDependentType() &&
11278 !Prev->getIntegerType()->isDependentType() &&
11279 !Context.hasSameUnqualifiedType(EnumUnderlyingTy,
Richard Smith4b38ded2012-03-14 23:13:10 +000011280 Prev->getIntegerType())) {
Alp Tokerb9fa5122014-01-06 11:31:18 +000011281 // TODO: Highlight the underlying type of the redeclaration.
Richard Smith4b38ded2012-03-14 23:13:10 +000011282 Diag(EnumLoc, diag::err_enum_redeclare_type_mismatch)
11283 << EnumUnderlyingTy << Prev->getIntegerType();
Alp Tokerb9fa5122014-01-06 11:31:18 +000011284 Diag(Prev->getLocation(), diag::note_previous_declaration)
11285 << Prev->getIntegerTypeRange();
Richard Smith4b38ded2012-03-14 23:13:10 +000011286 return true;
11287 }
11288 } else if (IsFixed != Prev->isFixed()) {
11289 Diag(EnumLoc, diag::err_enum_redeclare_fixed_mismatch)
11290 << Prev->isFixed();
Alp Toker8c44db52014-01-06 11:31:06 +000011291 Diag(Prev->getLocation(), diag::note_previous_declaration);
Richard Smith4b38ded2012-03-14 23:13:10 +000011292 return true;
11293 }
11294
11295 return false;
11296}
11297
Joao Matosdc86f942012-08-31 18:45:21 +000011298/// \brief Get diagnostic %select index for tag kind for
11299/// redeclaration diagnostic message.
11300/// WARNING: Indexes apply to particular diagnostics only!
11301///
11302/// \returns diagnostic %select index.
Joao Matosa5c42e92012-09-01 00:13:24 +000011303static unsigned getRedeclDiagFromTagKind(TagTypeKind Tag) {
Joao Matosdc86f942012-08-31 18:45:21 +000011304 switch (Tag) {
Joao Matosa5c42e92012-09-01 00:13:24 +000011305 case TTK_Struct: return 0;
11306 case TTK_Interface: return 1;
11307 case TTK_Class: return 2;
11308 default: llvm_unreachable("Invalid tag kind for redecl diagnostic!");
Joao Matosdc86f942012-08-31 18:45:21 +000011309 }
Joao Matosdc86f942012-08-31 18:45:21 +000011310}
11311
11312/// \brief Determine if tag kind is a class-key compatible with
11313/// class for redeclaration (class, struct, or __interface).
11314///
Sylvestre Ledru33b5baf2012-09-27 10:16:10 +000011315/// \returns true iff the tag kind is compatible.
Joao Matosdc86f942012-08-31 18:45:21 +000011316static bool isClassCompatTagKind(TagTypeKind Tag)
11317{
11318 return Tag == TTK_Struct || Tag == TTK_Class || Tag == TTK_Interface;
11319}
11320
Douglas Gregord9034f02009-05-14 16:41:31 +000011321/// \brief Determine whether a tag with a given kind is acceptable
11322/// as a redeclaration of the given tag declaration.
11323///
11324/// \returns true if the new tag kind is acceptable, false otherwise.
Mike Stump11289f42009-09-09 15:08:12 +000011325bool Sema::isAcceptableTagRedeclaration(const TagDecl *Previous,
Richard Trieucaa33d32011-06-10 03:11:26 +000011326 TagTypeKind NewTag, bool isDefinition,
Douglas Gregord9034f02009-05-14 16:41:31 +000011327 SourceLocation NewTagLoc,
Justin Bognerc6ecb7c2015-07-10 23:05:47 +000011328 const IdentifierInfo *Name) {
Douglas Gregord9034f02009-05-14 16:41:31 +000011329 // C++ [dcl.type.elab]p3:
11330 // The class-key or enum keyword present in the
11331 // elaborated-type-specifier shall agree in kind with the
Abramo Bagnara6150c882010-05-11 21:36:43 +000011332 // declaration to which the name in the elaborated-type-specifier
Douglas Gregord9034f02009-05-14 16:41:31 +000011333 // refers. This rule also applies to the form of
11334 // elaborated-type-specifier that declares a class-name or
11335 // friend class since it can be construed as referring to the
11336 // definition of the class. Thus, in any
11337 // elaborated-type-specifier, the enum keyword shall be used to
Abramo Bagnara6150c882010-05-11 21:36:43 +000011338 // refer to an enumeration (7.2), the union class-key shall be
Douglas Gregord9034f02009-05-14 16:41:31 +000011339 // used to refer to a union (clause 9), and either the class or
11340 // struct class-key shall be used to refer to a class (clause 9)
11341 // declared using the class or struct class-key.
Abramo Bagnara6150c882010-05-11 21:36:43 +000011342 TagTypeKind OldTag = Previous->getTagKind();
Joao Matosdc86f942012-08-31 18:45:21 +000011343 if (!isDefinition || !isClassCompatTagKind(NewTag))
Richard Trieucaa33d32011-06-10 03:11:26 +000011344 if (OldTag == NewTag)
11345 return true;
Mike Stump11289f42009-09-09 15:08:12 +000011346
Joao Matosdc86f942012-08-31 18:45:21 +000011347 if (isClassCompatTagKind(OldTag) && isClassCompatTagKind(NewTag)) {
Douglas Gregord9034f02009-05-14 16:41:31 +000011348 // Warn about the struct/class tag mismatch.
11349 bool isTemplate = false;
11350 if (const CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(Previous))
11351 isTemplate = Record->getDescribedClassTemplate();
11352
Richard Trieucaa33d32011-06-10 03:11:26 +000011353 if (!ActiveTemplateInstantiations.empty()) {
11354 // In a template instantiation, do not offer fix-its for tag mismatches
11355 // since they usually mess up the template instead of fixing the problem.
11356 Diag(NewTagLoc, diag::warn_struct_class_tag_mismatch)
Justin Bognerc6ecb7c2015-07-10 23:05:47 +000011357 << getRedeclDiagFromTagKind(NewTag) << isTemplate << Name
Joao Matosdc86f942012-08-31 18:45:21 +000011358 << getRedeclDiagFromTagKind(OldTag);
Richard Trieucaa33d32011-06-10 03:11:26 +000011359 return true;
11360 }
11361
11362 if (isDefinition) {
11363 // On definitions, check previous tags and issue a fix-it for each
11364 // one that doesn't match the current tag.
11365 if (Previous->getDefinition()) {
11366 // Don't suggest fix-its for redefinitions.
11367 return true;
11368 }
11369
11370 bool previousMismatch = false;
Aaron Ballman86c93902014-03-06 23:45:36 +000011371 for (auto I : Previous->redecls()) {
Richard Trieucaa33d32011-06-10 03:11:26 +000011372 if (I->getTagKind() != NewTag) {
11373 if (!previousMismatch) {
11374 previousMismatch = true;
11375 Diag(NewTagLoc, diag::warn_struct_class_previous_tag_mismatch)
Justin Bognerc6ecb7c2015-07-10 23:05:47 +000011376 << getRedeclDiagFromTagKind(NewTag) << isTemplate << Name
Joao Matosdc86f942012-08-31 18:45:21 +000011377 << getRedeclDiagFromTagKind(I->getTagKind());
Richard Trieucaa33d32011-06-10 03:11:26 +000011378 }
11379 Diag(I->getInnerLocStart(), diag::note_struct_class_suggestion)
Joao Matosdc86f942012-08-31 18:45:21 +000011380 << getRedeclDiagFromTagKind(NewTag)
Richard Trieucaa33d32011-06-10 03:11:26 +000011381 << FixItHint::CreateReplacement(I->getInnerLocStart(),
Joao Matosdc86f942012-08-31 18:45:21 +000011382 TypeWithKeyword::getTagTypeKindName(NewTag));
Richard Trieucaa33d32011-06-10 03:11:26 +000011383 }
11384 }
11385 return true;
11386 }
11387
11388 // Check for a previous definition. If current tag and definition
11389 // are same type, do nothing. If no definition, but disagree with
11390 // with previous tag type, give a warning, but no fix-it.
11391 const TagDecl *Redecl = Previous->getDefinition() ?
11392 Previous->getDefinition() : Previous;
11393 if (Redecl->getTagKind() == NewTag) {
11394 return true;
11395 }
11396
Douglas Gregord9034f02009-05-14 16:41:31 +000011397 Diag(NewTagLoc, diag::warn_struct_class_tag_mismatch)
Justin Bognerc6ecb7c2015-07-10 23:05:47 +000011398 << getRedeclDiagFromTagKind(NewTag) << isTemplate << Name
Joao Matosdc86f942012-08-31 18:45:21 +000011399 << getRedeclDiagFromTagKind(OldTag);
Richard Trieucaa33d32011-06-10 03:11:26 +000011400 Diag(Redecl->getLocation(), diag::note_previous_use);
11401
Alp Tokerf6a24ce2013-12-05 16:25:25 +000011402 // If there is a previous definition, suggest a fix-it.
Richard Trieucaa33d32011-06-10 03:11:26 +000011403 if (Previous->getDefinition()) {
11404 Diag(NewTagLoc, diag::note_struct_class_suggestion)
Joao Matosdc86f942012-08-31 18:45:21 +000011405 << getRedeclDiagFromTagKind(Redecl->getTagKind())
Richard Trieucaa33d32011-06-10 03:11:26 +000011406 << FixItHint::CreateReplacement(SourceRange(NewTagLoc),
Joao Matosdc86f942012-08-31 18:45:21 +000011407 TypeWithKeyword::getTagTypeKindName(Redecl->getTagKind()));
Richard Trieucaa33d32011-06-10 03:11:26 +000011408 }
11409
Douglas Gregord9034f02009-05-14 16:41:31 +000011410 return true;
11411 }
11412 return false;
11413}
11414
Reid Kleckner0902a512014-07-10 23:44:52 +000011415/// Add a minimal nested name specifier fixit hint to allow lookup of a tag name
11416/// from an outer enclosing namespace or file scope inside a friend declaration.
11417/// This should provide the commented out code in the following snippet:
11418/// namespace N {
11419/// struct X;
11420/// namespace M {
11421/// struct Y { friend struct /*N::*/ X; };
11422/// }
11423/// }
Reid Kleckner675d4382014-07-11 00:16:51 +000011424static FixItHint createFriendTagNNSFixIt(Sema &SemaRef, NamedDecl *ND, Scope *S,
11425 SourceLocation NameLoc) {
Reid Kleckner0902a512014-07-10 23:44:52 +000011426 // While the decl is in a namespace, do repeated lookup of that name and see
11427 // if we get the same namespace back. If we do not, continue until
11428 // translation unit scope, at which point we have a fully qualified NNS.
11429 SmallVector<IdentifierInfo *, 4> Namespaces;
11430 DeclContext *DC = ND->getDeclContext()->getRedeclContext();
11431 for (; !DC->isTranslationUnit(); DC = DC->getParent()) {
11432 // This tag should be declared in a namespace, which can only be enclosed by
11433 // other namespaces. Bail if there's an anonymous namespace in the chain.
11434 NamespaceDecl *Namespace = dyn_cast<NamespaceDecl>(DC);
11435 if (!Namespace || Namespace->isAnonymousNamespace())
Reid Kleckner675d4382014-07-11 00:16:51 +000011436 return FixItHint();
Reid Kleckner0902a512014-07-10 23:44:52 +000011437 IdentifierInfo *II = Namespace->getIdentifier();
11438 Namespaces.push_back(II);
11439 NamedDecl *Lookup = SemaRef.LookupSingleName(
11440 S, II, NameLoc, Sema::LookupNestedNameSpecifierName);
11441 if (Lookup == Namespace)
11442 break;
11443 }
11444
11445 // Once we have all the namespaces, reverse them to go outermost first, and
11446 // build an NNS.
11447 SmallString<64> Insertion;
11448 llvm::raw_svector_ostream OS(Insertion);
11449 if (DC->isTranslationUnit())
11450 OS << "::";
11451 std::reverse(Namespaces.begin(), Namespaces.end());
11452 for (auto *II : Namespaces)
11453 OS << II->getName() << "::";
11454 OS.flush();
Reid Kleckner675d4382014-07-11 00:16:51 +000011455 return FixItHint::CreateInsertion(NameLoc, Insertion);
Reid Kleckner0902a512014-07-10 23:44:52 +000011456}
11457
Richard Smithe869b752015-07-06 22:56:29 +000011458/// \brief Determine whether a tag originally declared in context \p OldDC can
11459/// be redeclared with an unqualfied name in \p NewDC (assuming name lookup
11460/// found a declaration in \p OldDC as a previous decl, perhaps through a
11461/// using-declaration).
11462static bool isAcceptableTagRedeclContext(Sema &S, DeclContext *OldDC,
11463 DeclContext *NewDC) {
11464 OldDC = OldDC->getRedeclContext();
11465 NewDC = NewDC->getRedeclContext();
11466
11467 if (OldDC->Equals(NewDC))
11468 return true;
11469
11470 // In MSVC mode, we allow a redeclaration if the contexts are related (either
11471 // encloses the other).
11472 if (S.getLangOpts().MSVCCompat &&
11473 (OldDC->Encloses(NewDC) || NewDC->Encloses(OldDC)))
11474 return true;
11475
11476 return false;
11477}
11478
Richard Smith65ebb4a2015-03-26 04:09:53 +000011479/// \brief This is invoked when we see 'struct foo' or 'struct {'. In the
Chris Lattner1300fb92007-01-23 23:42:53 +000011480/// former case, Name will be non-null. In the later case, Name will be null.
John McCall9bb74a52009-07-31 02:45:11 +000011481/// TagSpec indicates what kind of tag this is. TUK indicates whether this is a
Chris Lattner1300fb92007-01-23 23:42:53 +000011482/// reference/declaration/definition of a tag.
Richard Smith649c7b062014-01-08 00:56:48 +000011483///
Richard Smith65ebb4a2015-03-26 04:09:53 +000011484/// \param IsTypeSpecifier \c true if this is a type-specifier (or
Richard Smith649c7b062014-01-08 00:56:48 +000011485/// trailing-type-specifier) other than one in an alias-declaration.
Richard Smith65ebb4a2015-03-26 04:09:53 +000011486///
Richard Smithd9ba2242015-05-07 03:54:19 +000011487/// \param SkipBody If non-null, will be set to indicate if the caller should
11488/// skip the definition of this tag and treat it as if it were a declaration.
John McCall48871652010-08-21 09:40:31 +000011489Decl *Sema::ActOnTag(Scope *S, unsigned TagSpec, TagUseKind TUK,
Douglas Gregor009f6992010-09-16 23:58:57 +000011490 SourceLocation KWLoc, CXXScopeSpec &SS,
11491 IdentifierInfo *Name, SourceLocation NameLoc,
11492 AttributeList *Attr, AccessSpecifier AS,
Douglas Gregor2820e692011-09-09 19:05:14 +000011493 SourceLocation ModulePrivateLoc,
Douglas Gregor009f6992010-09-16 23:58:57 +000011494 MultiTemplateParamsArg TemplateParameterLists,
Abramo Bagnara0e05e242010-12-03 18:54:17 +000011495 bool &OwnedDecl, bool &IsDependent,
Richard Smith0f8ee222012-01-10 01:33:14 +000011496 SourceLocation ScopedEnumKWLoc,
11497 bool ScopedEnumUsesClassTag,
Richard Smith649c7b062014-01-08 00:56:48 +000011498 TypeResult UnderlyingType,
Richard Smithd9ba2242015-05-07 03:54:19 +000011499 bool IsTypeSpecifier, SkipBodyInfo *SkipBody) {
Douglas Gregorc811d8f2008-12-15 16:32:14 +000011500 // If this is not a definition, it must have a name.
Douglas Gregorb7d17dd2012-03-28 16:01:27 +000011501 IdentifierInfo *OrigName = Name;
Craig Topperc3ec1492014-05-26 06:22:03 +000011502 assert((Name != nullptr || TUK == TUK_Definition) &&
Chris Lattner7b9ace62007-01-23 20:11:08 +000011503 "Nameless record must be a definition!");
John McCallace48cd2010-10-19 01:40:49 +000011504 assert(TemplateParameterLists.size() == 0 || TUK != TUK_Reference);
Douglas Gregorded2d7b2009-02-04 19:02:06 +000011505
Douglas Gregord6ab8742009-05-28 23:31:59 +000011506 OwnedDecl = false;
Abramo Bagnara6150c882010-05-11 21:36:43 +000011507 TagTypeKind Kind = TypeWithKeyword::getTagTypeKindForTypeSpec(TagSpec);
Richard Smith0f8ee222012-01-10 01:33:14 +000011508 bool ScopedEnum = ScopedEnumKWLoc.isValid();
Mike Stump11289f42009-09-09 15:08:12 +000011509
Douglas Gregor5c0405d2009-10-07 22:35:40 +000011510 // FIXME: Check explicit specializations more carefully.
11511 bool isExplicitSpecialization = false;
Douglas Gregor5f0e2522010-07-14 23:14:12 +000011512 bool Invalid = false;
John McCallace48cd2010-10-19 01:40:49 +000011513
11514 // We only need to do this matching if we have template parameters
11515 // or a scope specifier, which also conveniently avoids this work
11516 // for non-C++ cases.
Abramo Bagnara60804e12011-03-18 15:16:37 +000011517 if (TemplateParameterLists.size() > 0 ||
John McCallace48cd2010-10-19 01:40:49 +000011518 (SS.isNotEmpty() && TUK != TUK_Reference)) {
Robert Wilhelmf2d2e8f2013-07-21 15:20:44 +000011519 if (TemplateParameterList *TemplateParams =
11520 MatchTemplateParametersToScopeSpecifier(
Craig Topperc3ec1492014-05-26 06:22:03 +000011521 KWLoc, NameLoc, SS, nullptr, TemplateParameterLists,
Richard Smith4b55a9c2014-04-17 03:29:33 +000011522 TUK == TUK_Friend, isExplicitSpecialization, Invalid)) {
Richard Smith1d4b2e12013-04-01 21:43:41 +000011523 if (Kind == TTK_Enum) {
11524 Diag(KWLoc, diag::err_enum_template);
Craig Topperc3ec1492014-05-26 06:22:03 +000011525 return nullptr;
Richard Smith1d4b2e12013-04-01 21:43:41 +000011526 }
11527
Douglas Gregor3dad8422009-09-26 06:47:28 +000011528 if (TemplateParams->size() > 0) {
Douglas Gregore93e46c2009-07-22 23:48:44 +000011529 // This is a declaration or definition of a class template (which may
11530 // be a member of another template).
Abramo Bagnara60804e12011-03-18 15:16:37 +000011531
Douglas Gregor5f0e2522010-07-14 23:14:12 +000011532 if (Invalid)
Craig Topperc3ec1492014-05-26 06:22:03 +000011533 return nullptr;
Abramo Bagnara0adf29a2011-03-10 13:28:31 +000011534
Douglas Gregore93e46c2009-07-22 23:48:44 +000011535 OwnedDecl = false;
John McCall9bb74a52009-07-31 02:45:11 +000011536 DeclResult Result = CheckClassTemplate(S, TagSpec, TUK, KWLoc,
Douglas Gregore93e46c2009-07-22 23:48:44 +000011537 SS, Name, NameLoc, Attr,
Abramo Bagnara0adf29a2011-03-10 13:28:31 +000011538 TemplateParams, AS,
Douglas Gregor2820e692011-09-09 19:05:14 +000011539 ModulePrivateLoc,
Nikola Smiljanic4fc91532014-07-17 01:59:34 +000011540 /*FriendLoc*/SourceLocation(),
Benjamin Kramer62b95d82012-08-23 21:35:17 +000011541 TemplateParameterLists.size()-1,
Richard Smithbe3980b2015-03-27 00:41:57 +000011542 TemplateParameterLists.data(),
11543 SkipBody);
Douglas Gregore93e46c2009-07-22 23:48:44 +000011544 return Result.get();
11545 } else {
Douglas Gregorbbe8f462009-10-08 15:14:33 +000011546 // The "template<>" header is extraneous.
11547 Diag(TemplateParams->getTemplateLoc(), diag::err_template_tag_noparams)
Abramo Bagnara6150c882010-05-11 21:36:43 +000011548 << TypeWithKeyword::getTagTypeKindName(Kind) << Name;
Douglas Gregorbbe8f462009-10-08 15:14:33 +000011549 isExplicitSpecialization = true;
Douglas Gregore93e46c2009-07-22 23:48:44 +000011550 }
Mike Stump11289f42009-09-09 15:08:12 +000011551 }
11552 }
11553
Douglas Gregor0bf31402010-10-08 23:50:27 +000011554 // Figure out the underlying type if this a enum declaration. We need to do
11555 // this early, because it's needed to detect if this is an incompatible
11556 // redeclaration.
11557 llvm::PointerUnion<const Type*, TypeSourceInfo*> EnumUnderlying;
11558
11559 if (Kind == TTK_Enum) {
11560 if (UnderlyingType.isInvalid() || (!UnderlyingType.get() && ScopedEnum))
11561 // No underlying type explicitly specified, or we failed to parse the
11562 // type, default to int.
11563 EnumUnderlying = Context.IntTy.getTypePtr();
11564 else if (UnderlyingType.get()) {
11565 // C++0x 7.2p2: The type-specifier-seq of an enum-base shall name an
11566 // integral type; any cv-qualification is ignored.
Craig Topperc3ec1492014-05-26 06:22:03 +000011567 TypeSourceInfo *TI = nullptr;
Richard Smitheece8c32012-03-15 00:22:18 +000011568 GetTypeFromParser(UnderlyingType.get(), &TI);
Douglas Gregor0bf31402010-10-08 23:50:27 +000011569 EnumUnderlying = TI;
11570
Richard Smith4b38ded2012-03-14 23:13:10 +000011571 if (CheckEnumUnderlyingType(TI))
Douglas Gregor0bf31402010-10-08 23:50:27 +000011572 // Recover by falling back to int.
11573 EnumUnderlying = Context.IntTy.getTypePtr();
Douglas Gregor2b988fd2010-12-16 00:24:44 +000011574
Richard Smith4b38ded2012-03-14 23:13:10 +000011575 if (DiagnoseUnexpandedParameterPack(TI->getTypeLoc().getBeginLoc(), TI,
Douglas Gregor2b988fd2010-12-16 00:24:44 +000011576 UPPC_FixedUnderlyingType))
11577 EnumUnderlying = Context.IntTy.getTypePtr();
11578
Alp Tokerbfa39342014-01-14 12:51:41 +000011579 } else if (getLangOpts().MSVCCompat)
Francois Picheta3108062010-10-18 15:01:13 +000011580 // Microsoft enums are always of int type.
11581 EnumUnderlying = Context.IntTy.getTypePtr();
Douglas Gregor0bf31402010-10-08 23:50:27 +000011582 }
11583
Douglas Gregorc6f58fe2009-01-12 22:49:06 +000011584 DeclContext *SearchDC = CurContext;
Argyrios Kyrtzidis8ad00b22008-11-09 22:53:32 +000011585 DeclContext *DC = CurContext;
Douglas Gregor87f54062009-09-15 22:30:29 +000011586 bool isStdBadAlloc = false;
Douglas Gregordee1be82009-01-17 00:42:38 +000011587
Chandler Carrutha419dbb2010-03-01 21:17:36 +000011588 RedeclarationKind Redecl = ForRedeclaration;
11589 if (TUK == TUK_Friend || TUK == TUK_Reference)
11590 Redecl = NotForRedeclaration;
John McCall1f82f242009-11-18 22:49:29 +000011591
11592 LookupResult Previous(*this, Name, NameLoc, LookupTagName, Redecl);
Argyrios Kyrtzidise02eb2b2008-11-09 22:09:58 +000011593 if (Name && SS.isNotEmpty()) {
11594 // We have a nested-name tag ('struct foo::bar').
11595
11596 // Check for invalid 'foo::'.
Argyrios Kyrtzidis8ad00b22008-11-09 22:53:32 +000011597 if (SS.isInvalid()) {
Craig Topperc3ec1492014-05-26 06:22:03 +000011598 Name = nullptr;
Argyrios Kyrtzidise02eb2b2008-11-09 22:09:58 +000011599 goto CreateNewDecl;
11600 }
11601
John McCall7f41d982009-09-11 04:59:25 +000011602 // If this is a friend or a reference to a class in a dependent
11603 // context, don't try to make a decl for it.
11604 if (TUK == TUK_Friend || TUK == TUK_Reference) {
11605 DC = computeDeclContext(SS, false);
11606 if (!DC) {
11607 IsDependent = true;
Craig Topperc3ec1492014-05-26 06:22:03 +000011608 return nullptr;
John McCall7f41d982009-09-11 04:59:25 +000011609 }
John McCall0b66eb32010-05-01 00:40:08 +000011610 } else {
11611 DC = computeDeclContext(SS, true);
11612 if (!DC) {
11613 Diag(SS.getRange().getBegin(), diag::err_dependent_nested_name_spec)
11614 << SS.getRange();
Craig Topperc3ec1492014-05-26 06:22:03 +000011615 return nullptr;
John McCall0b66eb32010-05-01 00:40:08 +000011616 }
John McCall7f41d982009-09-11 04:59:25 +000011617 }
11618
John McCall0b66eb32010-05-01 00:40:08 +000011619 if (RequireCompleteDeclContext(SS, DC))
Craig Topperc3ec1492014-05-26 06:22:03 +000011620 return nullptr;
Douglas Gregor2ec748c2009-05-14 00:28:11 +000011621
Douglas Gregor8761da52009-02-03 00:34:39 +000011622 SearchDC = DC;
Argyrios Kyrtzidis8ad00b22008-11-09 22:53:32 +000011623 // Look-up name inside 'foo::'.
John McCall1f82f242009-11-18 22:49:29 +000011624 LookupQualifiedName(Previous, DC);
John McCall6538c932009-10-10 05:48:19 +000011625
John McCall1f82f242009-11-18 22:49:29 +000011626 if (Previous.isAmbiguous())
Craig Topperc3ec1492014-05-26 06:22:03 +000011627 return nullptr;
John McCall6538c932009-10-10 05:48:19 +000011628
John McCall1f82f242009-11-18 22:49:29 +000011629 if (Previous.empty()) {
Douglas Gregord2e6a452010-01-14 17:47:39 +000011630 // Name lookup did not find anything. However, if the
11631 // nested-name-specifier refers to the current instantiation,
11632 // and that current instantiation has any dependent base
11633 // classes, we might find something at instantiation time: treat
11634 // this as a dependent elaborated-type-specifier.
John McCallace48cd2010-10-19 01:40:49 +000011635 // But this only makes any sense for reference-like lookups.
11636 if (Previous.wasNotFoundInCurrentInstantiation() &&
11637 (TUK == TUK_Reference || TUK == TUK_Friend)) {
Douglas Gregord2e6a452010-01-14 17:47:39 +000011638 IsDependent = true;
Craig Topperc3ec1492014-05-26 06:22:03 +000011639 return nullptr;
Douglas Gregord2e6a452010-01-14 17:47:39 +000011640 }
11641
11642 // A tag 'foo::bar' must already exist.
Douglas Gregorf5af3582010-03-31 23:17:41 +000011643 Diag(NameLoc, diag::err_not_tag_in_scope)
11644 << Kind << Name << DC << SS.getRange();
Craig Topperc3ec1492014-05-26 06:22:03 +000011645 Name = nullptr;
Douglas Gregorb8006faf2009-05-27 17:30:49 +000011646 Invalid = true;
Argyrios Kyrtzidise02eb2b2008-11-09 22:09:58 +000011647 goto CreateNewDecl;
11648 }
Chris Lattnerd9773512009-01-21 02:38:50 +000011649 } else if (Name) {
Richard Smith88fe69c2015-07-06 01:45:27 +000011650 // C++14 [class.mem]p14:
11651 // If T is the name of a class, then each of the following shall have a
11652 // name different from T:
11653 // -- every member of class T that is itself a type
11654 if (TUK != TUK_Reference && TUK != TUK_Friend &&
11655 DiagnoseClassNameShadow(SearchDC, DeclarationNameInfo(Name, NameLoc)))
11656 return nullptr;
11657
Argyrios Kyrtzidise02eb2b2008-11-09 22:09:58 +000011658 // If this is a named struct, check to see if there was a previous forward
11659 // declaration or definition.
Douglas Gregor889ceb72009-02-03 19:21:40 +000011660 // FIXME: We're looking into outer scopes here, even when we
11661 // shouldn't be. Doing so can result in ambiguities that we
11662 // shouldn't be diagnosing.
John McCall1f82f242009-11-18 22:49:29 +000011663 LookupName(Previous, S);
11664
John McCall3c581bf2013-03-20 01:53:00 +000011665 // When declaring or defining a tag, ignore ambiguities introduced
11666 // by types using'ed into this scope.
Douglas Gregor5d1d9e32011-05-09 21:46:33 +000011667 if (Previous.isAmbiguous() &&
11668 (TUK == TUK_Definition || TUK == TUK_Declaration)) {
Douglas Gregored8a29b2011-05-04 00:25:33 +000011669 LookupResult::Filter F = Previous.makeFilter();
11670 while (F.hasNext()) {
11671 NamedDecl *ND = F.next();
11672 if (ND->getDeclContext()->getRedeclContext() != SearchDC)
11673 F.erase();
11674 }
11675 F.done();
Douglas Gregored8a29b2011-05-04 00:25:33 +000011676 }
John McCall3c581bf2013-03-20 01:53:00 +000011677
11678 // C++11 [namespace.memdef]p3:
11679 // If the name in a friend declaration is neither qualified nor
11680 // a template-id and the declaration is a function or an
11681 // elaborated-type-specifier, the lookup to determine whether
11682 // the entity has been previously declared shall not consider
11683 // any scopes outside the innermost enclosing namespace.
11684 //
Reid Kleckner0902a512014-07-10 23:44:52 +000011685 // MSVC doesn't implement the above rule for types, so a friend tag
11686 // declaration may be a redeclaration of a type declared in an enclosing
11687 // scope. They do implement this rule for friend functions.
11688 //
John McCall3c581bf2013-03-20 01:53:00 +000011689 // Does it matter that this should be by scope instead of by
11690 // semantic context?
11691 if (!Previous.empty() && TUK == TUK_Friend) {
11692 DeclContext *EnclosingNS = SearchDC->getEnclosingNamespaceContext();
11693 LookupResult::Filter F = Previous.makeFilter();
Reid Kleckner0902a512014-07-10 23:44:52 +000011694 bool FriendSawTagOutsideEnclosingNamespace = false;
John McCall3c581bf2013-03-20 01:53:00 +000011695 while (F.hasNext()) {
11696 NamedDecl *ND = F.next();
11697 DeclContext *DC = ND->getDeclContext()->getRedeclContext();
Douglas Gregorf83b4ea2013-06-27 20:42:30 +000011698 if (DC->isFileContext() &&
11699 !EnclosingNS->Encloses(ND->getDeclContext())) {
Reid Kleckner0902a512014-07-10 23:44:52 +000011700 if (getLangOpts().MSVCCompat)
11701 FriendSawTagOutsideEnclosingNamespace = true;
11702 else
11703 F.erase();
Douglas Gregorf83b4ea2013-06-27 20:42:30 +000011704 }
John McCall3c581bf2013-03-20 01:53:00 +000011705 }
11706 F.done();
Reid Kleckner0902a512014-07-10 23:44:52 +000011707
11708 // Diagnose this MSVC extension in the easy case where lookup would have
11709 // unambiguously found something outside the enclosing namespace.
11710 if (Previous.isSingleResult() && FriendSawTagOutsideEnclosingNamespace) {
11711 NamedDecl *ND = Previous.getFoundDecl();
Reid Kleckner675d4382014-07-11 00:16:51 +000011712 Diag(NameLoc, diag::ext_friend_tag_redecl_outside_namespace)
11713 << createFriendTagNNSFixIt(*this, ND, S, NameLoc);
Reid Kleckner0902a512014-07-10 23:44:52 +000011714 }
John McCall3c581bf2013-03-20 01:53:00 +000011715 }
Reid Kleckner0902a512014-07-10 23:44:52 +000011716
John McCall1f82f242009-11-18 22:49:29 +000011717 // Note: there used to be some attempt at recovery here.
11718 if (Previous.isAmbiguous())
Craig Topperc3ec1492014-05-26 06:22:03 +000011719 return nullptr;
Douglas Gregor82ac25e2009-01-08 20:45:30 +000011720
David Blaikiebbafb8a2012-03-11 07:00:24 +000011721 if (!getLangOpts().CPlusPlus && TUK != TUK_Reference) {
Douglas Gregor82ac25e2009-01-08 20:45:30 +000011722 // FIXME: This makes sure that we ignore the contexts associated
11723 // with C structs, unions, and enums when looking for a matching
11724 // tag declaration or definition. See the similar lookup tweak
Douglas Gregored8f2882009-01-30 01:04:22 +000011725 // in Sema::LookupName; is there a better way to deal with this?
Douglas Gregorc6f58fe2009-01-12 22:49:06 +000011726 while (isa<RecordDecl>(SearchDC) || isa<EnumDecl>(SearchDC))
11727 SearchDC = SearchDC->getParent();
Douglas Gregor82ac25e2009-01-08 20:45:30 +000011728 }
Argyrios Kyrtzidise02eb2b2008-11-09 22:09:58 +000011729 }
11730
John McCall1f82f242009-11-18 22:49:29 +000011731 if (Previous.isSingleResult() &&
11732 Previous.getFoundDecl()->isTemplateParameter()) {
Douglas Gregor5101c242008-12-05 18:15:24 +000011733 // Maybe we will complain about the shadowed template parameter.
John McCall1f82f242009-11-18 22:49:29 +000011734 DiagnoseTemplateParameterShadow(NameLoc, Previous.getFoundDecl());
Douglas Gregor5101c242008-12-05 18:15:24 +000011735 // Just pretend that we didn't see the previous declaration.
John McCall1f82f242009-11-18 22:49:29 +000011736 Previous.clear();
Douglas Gregor5101c242008-12-05 18:15:24 +000011737 }
11738
David Blaikiebbafb8a2012-03-11 07:00:24 +000011739 if (getLangOpts().CPlusPlus && Name && DC && StdNamespace &&
Argyrios Kyrtzidis2d688102010-08-02 07:14:54 +000011740 DC->Equals(getStdNamespace()) && Name->isStr("bad_alloc")) {
Douglas Gregor87f54062009-09-15 22:30:29 +000011741 // This is a declaration of or a reference to "std::bad_alloc".
11742 isStdBadAlloc = true;
11743
John McCall1f82f242009-11-18 22:49:29 +000011744 if (Previous.empty() && StdBadAlloc) {
Douglas Gregor87f54062009-09-15 22:30:29 +000011745 // std::bad_alloc has been implicitly declared (but made invisible to
11746 // name lookup). Fill in this implicit declaration as the previous
11747 // declaration, so that the declarations get chained appropriately.
Argyrios Kyrtzidis2d688102010-08-02 07:14:54 +000011748 Previous.addDecl(getStdBadAlloc());
Douglas Gregor87f54062009-09-15 22:30:29 +000011749 }
11750 }
John McCall1f82f242009-11-18 22:49:29 +000011751
John McCalle9eaf8e2010-03-25 21:28:06 +000011752 // If we didn't find a previous declaration, and this is a reference
11753 // (or friend reference), move to the correct scope. In C++, we
11754 // also need to do a redeclaration lookup there, just in case
11755 // there's a shadow friend decl.
11756 if (Name && Previous.empty() &&
11757 (TUK == TUK_Reference || TUK == TUK_Friend)) {
11758 if (Invalid) goto CreateNewDecl;
11759 assert(SS.isEmpty());
11760
11761 if (TUK == TUK_Reference) {
11762 // C++ [basic.scope.pdecl]p5:
11763 // -- for an elaborated-type-specifier of the form
11764 //
11765 // class-key identifier
11766 //
11767 // if the elaborated-type-specifier is used in the
11768 // decl-specifier-seq or parameter-declaration-clause of a
11769 // function defined in namespace scope, the identifier is
11770 // declared as a class-name in the namespace that contains
11771 // the declaration; otherwise, except as a friend
11772 // declaration, the identifier is declared in the smallest
11773 // non-class, non-function-prototype scope that contains the
11774 // declaration.
11775 //
11776 // C99 6.7.2.3p8 has a similar (but not identical!) provision for
11777 // C structs and unions.
11778 //
11779 // It is an error in C++ to declare (rather than define) an enum
11780 // type, including via an elaborated type specifier. We'll
11781 // diagnose that later; for now, declare the enum in the same
11782 // scope as we would have picked for any other tag type.
11783 //
11784 // GNU C also supports this behavior as part of its incomplete
11785 // enum types extension, while GNU C++ does not.
11786 //
11787 // Find the context where we'll be declaring the tag.
11788 // FIXME: We would like to maintain the current DeclContext as the
11789 // lexical context,
Nick Lewyckyf6042122012-03-10 07:47:07 +000011790 while (!SearchDC->isFileContext() && !SearchDC->isFunctionOrMethod())
John McCalle9eaf8e2010-03-25 21:28:06 +000011791 SearchDC = SearchDC->getParent();
11792
11793 // Find the scope where we'll be declaring the tag.
11794 while (S->isClassScope() ||
David Blaikiebbafb8a2012-03-11 07:00:24 +000011795 (getLangOpts().CPlusPlus &&
John McCalle9eaf8e2010-03-25 21:28:06 +000011796 S->isFunctionPrototypeScope()) ||
11797 ((S->getFlags() & Scope::DeclScope) == 0) ||
Ted Kremenekc37877d2013-10-08 17:08:03 +000011798 (S->getEntity() && S->getEntity()->isTransparentContext()))
John McCalle9eaf8e2010-03-25 21:28:06 +000011799 S = S->getParent();
11800 } else {
11801 assert(TUK == TUK_Friend);
11802 // C++ [namespace.memdef]p3:
11803 // If a friend declaration in a non-local class first declares a
11804 // class or function, the friend class or function is a member of
11805 // the innermost enclosing namespace.
11806 SearchDC = SearchDC->getEnclosingNamespaceContext();
John McCalle9eaf8e2010-03-25 21:28:06 +000011807 }
11808
John McCalle87beb22010-04-23 18:46:30 +000011809 // In C++, we need to do a redeclaration lookup to properly
11810 // diagnose some problems.
David Blaikiebbafb8a2012-03-11 07:00:24 +000011811 if (getLangOpts().CPlusPlus) {
John McCalle9eaf8e2010-03-25 21:28:06 +000011812 Previous.setRedeclarationKind(ForRedeclaration);
11813 LookupQualifiedName(Previous, SearchDC);
11814 }
11815 }
11816
Richard Smithd9ba2242015-05-07 03:54:19 +000011817 // If we have a known previous declaration to use, then use it.
11818 if (Previous.empty() && SkipBody && SkipBody->Previous)
11819 Previous.addDecl(SkipBody->Previous);
11820
John McCall1f82f242009-11-18 22:49:29 +000011821 if (!Previous.empty()) {
Alp Toker0abb0572014-01-18 00:59:32 +000011822 NamedDecl *PrevDecl = Previous.getFoundDecl();
Richard Smithfc805ca2015-07-06 04:43:58 +000011823 NamedDecl *DirectPrevDecl = Previous.getRepresentativeDecl();
John McCalle87beb22010-04-23 18:46:30 +000011824
11825 // It's okay to have a tag decl in the same scope as a typedef
11826 // which hides a tag decl in the same scope. Finding this
11827 // insanity with a redeclaration lookup can only actually happen
11828 // in C++.
11829 //
11830 // This is also okay for elaborated-type-specifiers, which is
11831 // technically forbidden by the current standard but which is
11832 // okay according to the likely resolution of an open issue;
11833 // see http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#407
David Blaikiebbafb8a2012-03-11 07:00:24 +000011834 if (getLangOpts().CPlusPlus) {
Richard Smithdda56e42011-04-15 14:24:37 +000011835 if (TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(PrevDecl)) {
John McCalle87beb22010-04-23 18:46:30 +000011836 if (const TagType *TT = TD->getUnderlyingType()->getAs<TagType>()) {
11837 TagDecl *Tag = TT->getDecl();
11838 if (Tag->getDeclName() == Name &&
Sebastian Redl50c68252010-08-31 00:36:30 +000011839 Tag->getDeclContext()->getRedeclContext()
11840 ->Equals(TD->getDeclContext()->getRedeclContext())) {
John McCalle87beb22010-04-23 18:46:30 +000011841 PrevDecl = Tag;
11842 Previous.clear();
11843 Previous.addDecl(Tag);
Douglas Gregorfcee9462010-08-27 22:55:10 +000011844 Previous.resolveKind();
John McCalle87beb22010-04-23 18:46:30 +000011845 }
11846 }
11847 }
11848 }
11849
Richard Smithfc805ca2015-07-06 04:43:58 +000011850 // If this is a redeclaration of a using shadow declaration, it must
11851 // declare a tag in the same context. In MSVC mode, we allow a
11852 // redefinition if either context is within the other.
11853 if (auto *Shadow = dyn_cast<UsingShadowDecl>(DirectPrevDecl)) {
11854 auto *OldTag = dyn_cast<TagDecl>(PrevDecl);
11855 if (SS.isEmpty() && TUK != TUK_Reference && TUK != TUK_Friend &&
11856 isDeclInScope(Shadow, SearchDC, S, isExplicitSpecialization) &&
Richard Smithe869b752015-07-06 22:56:29 +000011857 !(OldTag && isAcceptableTagRedeclContext(
11858 *this, OldTag->getDeclContext(), SearchDC))) {
Richard Smithfc805ca2015-07-06 04:43:58 +000011859 Diag(KWLoc, diag::err_using_decl_conflict_reverse);
11860 Diag(Shadow->getTargetDecl()->getLocation(),
11861 diag::note_using_decl_target);
11862 Diag(Shadow->getUsingDecl()->getLocation(), diag::note_using_decl)
11863 << 0;
11864 // Recover by ignoring the old declaration.
11865 Previous.clear();
11866 goto CreateNewDecl;
11867 }
11868 }
11869
Argyrios Kyrtzidis08114892008-04-27 13:50:30 +000011870 if (TagDecl *PrevTagDecl = dyn_cast<TagDecl>(PrevDecl)) {
Chris Lattner9ff58d72008-07-03 03:30:58 +000011871 // If this is a use of a previous tag, or if the tag is already declared
11872 // in the same scope (so that the definition/declaration completes or
Argyrios Kyrtzidis08114892008-04-27 13:50:30 +000011873 // rementions the tag), reuse the decl.
John McCall07e91c02009-08-06 02:15:43 +000011874 if (TUK == TUK_Reference || TUK == TUK_Friend ||
Alp Toker320374c2014-01-17 12:57:21 +000011875 isDeclInScope(DirectPrevDecl, SearchDC, S,
Richard Smith72bcaec2013-12-05 04:30:04 +000011876 SS.isNotEmpty() || isExplicitSpecialization)) {
Chris Lattner9ff58d72008-07-03 03:30:58 +000011877 // Make sure that this wasn't declared as an enum and now used as a
11878 // struct or something similar.
Richard Trieucaa33d32011-06-10 03:11:26 +000011879 if (!isAcceptableTagRedeclaration(PrevTagDecl, Kind,
11880 TUK == TUK_Definition, KWLoc,
Justin Bognerc6ecb7c2015-07-10 23:05:47 +000011881 Name)) {
Mike Stump11289f42009-09-09 15:08:12 +000011882 bool SafeToContinue
Abramo Bagnara6150c882010-05-11 21:36:43 +000011883 = (PrevTagDecl->getTagKind() != TTK_Enum &&
11884 Kind != TTK_Enum);
Douglas Gregor170512f2009-04-01 23:51:29 +000011885 if (SafeToContinue)
Mike Stump11289f42009-09-09 15:08:12 +000011886 Diag(KWLoc, diag::err_use_with_wrong_tag)
Douglas Gregor170512f2009-04-01 23:51:29 +000011887 << Name
Douglas Gregora771f462010-03-31 17:46:05 +000011888 << FixItHint::CreateReplacement(SourceRange(KWLoc),
11889 PrevTagDecl->getKindName());
Douglas Gregor170512f2009-04-01 23:51:29 +000011890 else
11891 Diag(KWLoc, diag::err_use_with_wrong_tag) << Name;
John McCall1f82f242009-11-18 22:49:29 +000011892 Diag(PrevTagDecl->getLocation(), diag::note_previous_use);
Douglas Gregor170512f2009-04-01 23:51:29 +000011893
Mike Stump11289f42009-09-09 15:08:12 +000011894 if (SafeToContinue)
Douglas Gregor170512f2009-04-01 23:51:29 +000011895 Kind = PrevTagDecl->getTagKind();
11896 else {
11897 // Recover by making this an anonymous redefinition.
Craig Topperc3ec1492014-05-26 06:22:03 +000011898 Name = nullptr;
John McCall1f82f242009-11-18 22:49:29 +000011899 Previous.clear();
Douglas Gregor170512f2009-04-01 23:51:29 +000011900 Invalid = true;
11901 }
11902 }
11903
Douglas Gregor0bf31402010-10-08 23:50:27 +000011904 if (Kind == TTK_Enum && PrevTagDecl->getTagKind() == TTK_Enum) {
11905 const EnumDecl *PrevEnum = cast<EnumDecl>(PrevTagDecl);
11906
Richard Smith0f8ee222012-01-10 01:33:14 +000011907 // If this is an elaborated-type-specifier for a scoped enumeration,
11908 // the 'class' keyword is not necessary and not permitted.
11909 if (TUK == TUK_Reference || TUK == TUK_Friend) {
11910 if (ScopedEnum)
11911 Diag(ScopedEnumKWLoc, diag::err_enum_class_reference)
11912 << PrevEnum->isScoped()
11913 << FixItHint::CreateRemoval(ScopedEnumKWLoc);
11914 return PrevTagDecl;
11915 }
11916
Richard Smith4b38ded2012-03-14 23:13:10 +000011917 QualType EnumUnderlyingTy;
11918 if (TypeSourceInfo *TI = EnumUnderlying.dyn_cast<TypeSourceInfo*>())
Richard Smith8bcc0862014-01-08 01:16:19 +000011919 EnumUnderlyingTy = TI->getType().getUnqualifiedType();
Richard Smith4b38ded2012-03-14 23:13:10 +000011920 else if (const Type *T = EnumUnderlying.dyn_cast<const Type*>())
11921 EnumUnderlyingTy = QualType(T, 0);
11922
Douglas Gregor0bf31402010-10-08 23:50:27 +000011923 // All conflicts with previous declarations are recovered by
Richard Smithb66d7772012-03-23 23:09:08 +000011924 // returning the previous declaration, unless this is a definition,
11925 // in which case we want the caller to bail out.
Richard Smith4b38ded2012-03-14 23:13:10 +000011926 if (CheckEnumRedeclaration(NameLoc.isValid() ? NameLoc : KWLoc,
11927 ScopedEnum, EnumUnderlyingTy, PrevEnum))
Craig Topperc3ec1492014-05-26 06:22:03 +000011928 return TUK == TUK_Declaration ? PrevTagDecl : nullptr;
Douglas Gregor0bf31402010-10-08 23:50:27 +000011929 }
11930
David Majnemer55890bf2013-06-11 03:51:23 +000011931 // C++11 [class.mem]p1:
David Majnemerbfce6642013-06-11 06:19:45 +000011932 // A member shall not be declared twice in the member-specification,
David Majnemer55890bf2013-06-11 03:51:23 +000011933 // except that a nested class or member class template can be declared
11934 // and then later defined.
11935 if (TUK == TUK_Declaration && PrevDecl->isCXXClassMember() &&
11936 S->isDeclScope(PrevDecl)) {
11937 Diag(NameLoc, diag::ext_member_redeclared);
11938 Diag(PrevTagDecl->getLocation(), diag::note_previous_declaration);
11939 }
11940
Douglas Gregor170512f2009-04-01 23:51:29 +000011941 if (!Invalid) {
John McCall2976f8b2014-05-14 07:54:17 +000011942 // If this is a use, just return the declaration we found, unless
11943 // we have attributes.
Chris Lattner9ff58d72008-07-03 03:30:58 +000011944
Douglas Gregorc811d8f2008-12-15 16:32:14 +000011945 // FIXME: In the future, return a variant or some other clue
11946 // for the consumer of this Decl to know it doesn't own it.
11947 // For our current ASTs this shouldn't be a problem, but will
11948 // need to be changed with DeclGroups.
John McCall2976f8b2014-05-14 07:54:17 +000011949 if (!Attr &&
11950 ((TUK == TUK_Reference &&
11951 (!PrevTagDecl->getFriendObjectKind() || getLangOpts().MicrosoftExt))
11952 || TUK == TUK_Friend))
John McCall48871652010-08-21 09:40:31 +000011953 return PrevTagDecl;
Douglas Gregorded2d7b2009-02-04 19:02:06 +000011954
Douglas Gregorc811d8f2008-12-15 16:32:14 +000011955 // Diagnose attempts to redefine a tag.
John McCall9bb74a52009-07-31 02:45:11 +000011956 if (TUK == TUK_Definition) {
Richard Smith65ebb4a2015-03-26 04:09:53 +000011957 if (NamedDecl *Def = PrevTagDecl->getDefinition()) {
Douglas Gregor06db9f52009-10-12 20:18:28 +000011958 // If we're defining a specialization and the previous definition
11959 // is from an implicit instantiation, don't emit an error
11960 // here; we'll catch this in the general case below.
Richard Smith7d137e32012-03-23 03:33:32 +000011961 bool IsExplicitSpecializationAfterInstantiation = false;
11962 if (isExplicitSpecialization) {
11963 if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(Def))
11964 IsExplicitSpecializationAfterInstantiation =
11965 RD->getTemplateSpecializationKind() !=
11966 TSK_ExplicitSpecialization;
11967 else if (EnumDecl *ED = dyn_cast<EnumDecl>(Def))
11968 IsExplicitSpecializationAfterInstantiation =
11969 ED->getTemplateSpecializationKind() !=
11970 TSK_ExplicitSpecialization;
11971 }
11972
Richard Smithbe3980b2015-03-27 00:41:57 +000011973 NamedDecl *Hidden = nullptr;
Richard Smith65ebb4a2015-03-26 04:09:53 +000011974 if (SkipBody && getLangOpts().CPlusPlus &&
Richard Smithbe3980b2015-03-27 00:41:57 +000011975 !hasVisibleDefinition(Def, &Hidden)) {
Richard Smith65ebb4a2015-03-26 04:09:53 +000011976 // There is a definition of this tag, but it is not visible. We
11977 // explicitly make use of C++'s one definition rule here, and
11978 // assume that this definition is identical to the hidden one
11979 // we already have. Make the existing definition visible and
11980 // use it in place of this one.
Richard Smithd9ba2242015-05-07 03:54:19 +000011981 SkipBody->ShouldSkip = true;
11982 makeMergedDefinitionVisible(Hidden, KWLoc);
Richard Smith65ebb4a2015-03-26 04:09:53 +000011983 return Def;
11984 } else if (!IsExplicitSpecializationAfterInstantiation) {
James Molloy6f8780b2012-02-29 10:24:19 +000011985 // A redeclaration in function prototype scope in C isn't
11986 // visible elsewhere, so merely issue a warning.
David Blaikiebbafb8a2012-03-11 07:00:24 +000011987 if (!getLangOpts().CPlusPlus && S->containedInPrototypeScope())
James Molloy6f8780b2012-02-29 10:24:19 +000011988 Diag(NameLoc, diag::warn_redefinition_in_param_list) << Name;
11989 else
11990 Diag(NameLoc, diag::err_redefinition) << Name;
Douglas Gregor06db9f52009-10-12 20:18:28 +000011991 Diag(Def->getLocation(), diag::note_previous_definition);
11992 // If this is a redefinition, recover by making this
11993 // struct be anonymous, which will make any later
11994 // references get the previous definition.
Craig Topperc3ec1492014-05-26 06:22:03 +000011995 Name = nullptr;
John McCall1f82f242009-11-18 22:49:29 +000011996 Previous.clear();
Douglas Gregor06db9f52009-10-12 20:18:28 +000011997 Invalid = true;
11998 }
Douglas Gregordee1be82009-01-17 00:42:38 +000011999 } else {
12000 // If the type is currently being defined, complain
12001 // about a nested redefinition.
David Majnemer738e5872014-12-28 09:18:54 +000012002 auto *TD = Context.getTagDeclType(PrevTagDecl)->getAsTagDecl();
12003 if (TD->isBeingDefined()) {
Douglas Gregordee1be82009-01-17 00:42:38 +000012004 Diag(NameLoc, diag::err_nested_redefinition) << Name;
Mike Stump11289f42009-09-09 15:08:12 +000012005 Diag(PrevTagDecl->getLocation(),
Douglas Gregordee1be82009-01-17 00:42:38 +000012006 diag::note_previous_definition);
Craig Topperc3ec1492014-05-26 06:22:03 +000012007 Name = nullptr;
John McCall1f82f242009-11-18 22:49:29 +000012008 Previous.clear();
Douglas Gregordee1be82009-01-17 00:42:38 +000012009 Invalid = true;
12010 }
Douglas Gregorc811d8f2008-12-15 16:32:14 +000012011 }
Douglas Gregordee1be82009-01-17 00:42:38 +000012012
Douglas Gregorc811d8f2008-12-15 16:32:14 +000012013 // Okay, this is definition of a previously declared or referenced
John McCalla16fc892014-05-14 18:31:48 +000012014 // tag. We're going to create a new Decl for it.
12015 }
12016
12017 // Okay, we're going to make a redeclaration. If this is some kind
12018 // of reference, make sure we build the redeclaration in the same DC
12019 // as the original, and ignore the current access specifier.
12020 if (TUK == TUK_Friend || TUK == TUK_Reference) {
12021 SearchDC = PrevTagDecl->getDeclContext();
12022 AS = AS_none;
Douglas Gregordee1be82009-01-17 00:42:38 +000012023 }
Argyrios Kyrtzidis08114892008-04-27 13:50:30 +000012024 }
Douglas Gregorc811d8f2008-12-15 16:32:14 +000012025 // If we get here we have (another) forward declaration or we
John McCall07e91c02009-08-06 02:15:43 +000012026 // have a definition. Just create a new decl.
12027
Douglas Gregorc811d8f2008-12-15 16:32:14 +000012028 } else {
12029 // If we get here, this is a definition of a new tag type in a nested
Mike Stump11289f42009-09-09 15:08:12 +000012030 // scope, e.g. "struct foo; void bar() { struct foo; }", just create a
Douglas Gregorc811d8f2008-12-15 16:32:14 +000012031 // new decl/type. We set PrevDecl to NULL so that the entities
12032 // have distinct types.
John McCall1f82f242009-11-18 22:49:29 +000012033 Previous.clear();
Chris Lattner7b9ace62007-01-23 20:11:08 +000012034 }
Douglas Gregorc811d8f2008-12-15 16:32:14 +000012035 // If we get here, we're going to create a new Decl. If PrevDecl
12036 // is non-NULL, it's a definition of the tag declared by
12037 // PrevDecl. If it's NULL, we have a new definition.
John McCalle87beb22010-04-23 18:46:30 +000012038
12039
12040 // Otherwise, PrevDecl is not a tag, but was found with tag
12041 // lookup. This is only actually possible in C++, where a few
12042 // things like templates still live in the tag namespace.
Argyrios Kyrtzidis08114892008-04-27 13:50:30 +000012043 } else {
John McCalle87beb22010-04-23 18:46:30 +000012044 // Use a better diagnostic if an elaborated-type-specifier
12045 // found the wrong kind of type on the first
12046 // (non-redeclaration) lookup.
12047 if ((TUK == TUK_Reference || TUK == TUK_Friend) &&
12048 !Previous.isForRedeclaration()) {
12049 unsigned Kind = 0;
12050 if (isa<TypedefDecl>(PrevDecl)) Kind = 1;
Richard Smithdda56e42011-04-15 14:24:37 +000012051 else if (isa<TypeAliasDecl>(PrevDecl)) Kind = 2;
12052 else if (isa<ClassTemplateDecl>(PrevDecl)) Kind = 3;
John McCalle87beb22010-04-23 18:46:30 +000012053 Diag(NameLoc, diag::err_tag_reference_non_tag) << Kind;
12054 Diag(PrevDecl->getLocation(), diag::note_declared_at);
12055 Invalid = true;
12056
12057 // Otherwise, only diagnose if the declaration is in scope.
Richard Smithfc805ca2015-07-06 04:43:58 +000012058 } else if (!isDeclInScope(DirectPrevDecl, SearchDC, S,
Richard Smith72bcaec2013-12-05 04:30:04 +000012059 SS.isNotEmpty() || isExplicitSpecialization)) {
John McCalle87beb22010-04-23 18:46:30 +000012060 // do nothing
12061
12062 // Diagnose implicit declarations introduced by elaborated types.
12063 } else if (TUK == TUK_Reference || TUK == TUK_Friend) {
12064 unsigned Kind = 0;
12065 if (isa<TypedefDecl>(PrevDecl)) Kind = 1;
Richard Smithdda56e42011-04-15 14:24:37 +000012066 else if (isa<TypeAliasDecl>(PrevDecl)) Kind = 2;
12067 else if (isa<ClassTemplateDecl>(PrevDecl)) Kind = 3;
John McCalle87beb22010-04-23 18:46:30 +000012068 Diag(NameLoc, diag::err_tag_reference_conflict) << Kind;
12069 Diag(PrevDecl->getLocation(), diag::note_previous_decl) << PrevDecl;
12070 Invalid = true;
12071
12072 // Otherwise it's a declaration. Call out a particularly common
12073 // case here.
Richard Smithdda56e42011-04-15 14:24:37 +000012074 } else if (TypedefNameDecl *TND = dyn_cast<TypedefNameDecl>(PrevDecl)) {
12075 unsigned Kind = 0;
12076 if (isa<TypeAliasDecl>(PrevDecl)) Kind = 1;
John McCalle87beb22010-04-23 18:46:30 +000012077 Diag(NameLoc, diag::err_tag_definition_of_typedef)
Richard Smithdda56e42011-04-15 14:24:37 +000012078 << Name << Kind << TND->getUnderlyingType();
John McCalle87beb22010-04-23 18:46:30 +000012079 Diag(PrevDecl->getLocation(), diag::note_previous_decl) << PrevDecl;
12080 Invalid = true;
12081
12082 // Otherwise, diagnose.
12083 } else {
12084 // The tag name clashes with something else in the target scope,
12085 // issue an error and recover by making this tag be anonymous.
Chris Lattner4bd8dd82008-11-19 08:23:25 +000012086 Diag(NameLoc, diag::err_redefinition_different_kind) << Name;
Chris Lattner0369c572008-11-23 23:12:31 +000012087 Diag(PrevDecl->getLocation(), diag::note_previous_definition);
Craig Topperc3ec1492014-05-26 06:22:03 +000012088 Name = nullptr;
Douglas Gregordee1be82009-01-17 00:42:38 +000012089 Invalid = true;
Argyrios Kyrtzidis7da34d02008-07-16 07:45:46 +000012090 }
John McCalle87beb22010-04-23 18:46:30 +000012091
12092 // The existing declaration isn't relevant to us; we're in a
12093 // new scope, so clear out the previous declaration.
12094 Previous.clear();
Chris Lattner8799cf22007-01-23 01:57:16 +000012095 }
Chris Lattner18b19622007-01-22 07:39:13 +000012096 }
Argyrios Kyrtzidis16ac9be2008-11-08 17:17:31 +000012097
Chris Lattner438e5012008-12-17 07:13:27 +000012098CreateNewDecl:
Mike Stump11289f42009-09-09 15:08:12 +000012099
Craig Topperc3ec1492014-05-26 06:22:03 +000012100 TagDecl *PrevDecl = nullptr;
John McCall1f82f242009-11-18 22:49:29 +000012101 if (Previous.isSingleResult())
12102 PrevDecl = cast<TagDecl>(Previous.getFoundDecl());
12103
Chris Lattnerbf0b7982007-01-23 04:27:41 +000012104 // If there is an identifier, use the location of the identifier as the
12105 // location of the decl, otherwise use the location of the struct/union
12106 // keyword.
12107 SourceLocation Loc = NameLoc.isValid() ? NameLoc : KWLoc;
Mike Stump11289f42009-09-09 15:08:12 +000012108
Douglas Gregorc811d8f2008-12-15 16:32:14 +000012109 // Otherwise, create a new declaration. If there is a previous
12110 // declaration of the same entity, the two will be linked via
12111 // PrevDecl.
Chris Lattner7b9ace62007-01-23 20:11:08 +000012112 TagDecl *New;
Douglas Gregor9ac7a072009-01-07 00:43:41 +000012113
Douglas Gregor0bf31402010-10-08 23:50:27 +000012114 bool IsForwardReference = false;
Abramo Bagnara6150c882010-05-11 21:36:43 +000012115 if (Kind == TTK_Enum) {
Chris Lattner776fac82007-06-09 00:53:06 +000012116 // FIXME: Tag decls should be chained to any simultaneous vardecls, e.g.:
12117 // enum X { A, B, C } D; D should chain to X.
Abramo Bagnara29c2d462011-03-09 14:09:51 +000012118 New = EnumDecl::Create(Context, SearchDC, KWLoc, Loc, Name,
Douglas Gregor0bf31402010-10-08 23:50:27 +000012119 cast_or_null<EnumDecl>(PrevDecl), ScopedEnum,
Abramo Bagnara0e05e242010-12-03 18:54:17 +000012120 ScopedEnumUsesClassTag, !EnumUnderlying.isNull());
Chris Lattner5f521502007-01-25 06:27:24 +000012121 // If this is an undefined enum, warn.
Douglas Gregorc9ea2d52010-06-22 14:26:35 +000012122 if (TUK != TUK_Definition && !Invalid) {
12123 TagDecl *Def;
Douglas Gregor780420e2013-03-25 22:22:35 +000012124 if ((getLangOpts().CPlusPlus11 || getLangOpts().ObjC2) &&
12125 cast<EnumDecl>(New)->isFixed()) {
Douglas Gregor0bf31402010-10-08 23:50:27 +000012126 // C++0x: 7.2p2: opaque-enum-declaration.
12127 // Conflicts are diagnosed above. Do nothing.
12128 }
12129 else if (PrevDecl && (Def = cast<EnumDecl>(PrevDecl)->getDefinition())) {
Douglas Gregorc9ea2d52010-06-22 14:26:35 +000012130 Diag(Loc, diag::ext_forward_ref_enum_def)
12131 << New;
12132 Diag(Def->getLocation(), diag::note_previous_definition);
12133 } else {
Francois Pichet488b4a72010-09-12 05:06:55 +000012134 unsigned DiagID = diag::ext_forward_ref_enum;
Alp Tokerbfa39342014-01-14 12:51:41 +000012135 if (getLangOpts().MSVCCompat)
Francois Pichet488b4a72010-09-12 05:06:55 +000012136 DiagID = diag::ext_ms_forward_ref_enum;
David Blaikiebbafb8a2012-03-11 07:00:24 +000012137 else if (getLangOpts().CPlusPlus)
Francois Pichet488b4a72010-09-12 05:06:55 +000012138 DiagID = diag::err_forward_ref_enum;
12139 Diag(Loc, DiagID);
Douglas Gregor0bf31402010-10-08 23:50:27 +000012140
12141 // If this is a forward-declared reference to an enumeration, make a
12142 // note of it; we won't actually be introducing the declaration into
12143 // the declaration context.
12144 if (TUK == TUK_Reference)
12145 IsForwardReference = true;
Douglas Gregorc9ea2d52010-06-22 14:26:35 +000012146 }
Douglas Gregord45b93b2009-03-06 18:34:03 +000012147 }
Douglas Gregor0bf31402010-10-08 23:50:27 +000012148
12149 if (EnumUnderlying) {
12150 EnumDecl *ED = cast<EnumDecl>(New);
12151 if (TypeSourceInfo *TI = EnumUnderlying.dyn_cast<TypeSourceInfo*>())
12152 ED->setIntegerTypeSourceInfo(TI);
12153 else
12154 ED->setIntegerType(QualType(EnumUnderlying.get<const Type*>(), 0));
12155 ED->setPromotionType(ED->getIntegerType());
12156 }
12157
Argyrios Kyrtzidis554a07b2008-06-09 23:19:58 +000012158 } else {
12159 // struct/union/class
12160
Chris Lattner776fac82007-06-09 00:53:06 +000012161 // FIXME: Tag decls should be chained to any simultaneous vardecls, e.g.:
12162 // struct X { int A; } D; D should chain to X.
David Blaikiebbafb8a2012-03-11 07:00:24 +000012163 if (getLangOpts().CPlusPlus) {
Ted Kremenek6ddf53e2008-09-05 17:39:33 +000012164 // FIXME: Look for a way to use RecordDecl for simple structs.
Abramo Bagnara29c2d462011-03-09 14:09:51 +000012165 New = CXXRecordDecl::Create(Context, Kind, SearchDC, KWLoc, Loc, Name,
Douglas Gregorc811d8f2008-12-15 16:32:14 +000012166 cast_or_null<CXXRecordDecl>(PrevDecl));
Abramo Bagnara29c2d462011-03-09 14:09:51 +000012167
Argyrios Kyrtzidis2d688102010-08-02 07:14:54 +000012168 if (isStdBadAlloc && (!StdBadAlloc || getStdBadAlloc()->isImplicit()))
Douglas Gregor87f54062009-09-15 22:30:29 +000012169 StdBadAlloc = cast<CXXRecordDecl>(New);
12170 } else
Abramo Bagnara29c2d462011-03-09 14:09:51 +000012171 New = RecordDecl::Create(Context, Kind, SearchDC, KWLoc, Loc, Name,
Douglas Gregorc811d8f2008-12-15 16:32:14 +000012172 cast_or_null<RecordDecl>(PrevDecl));
Argyrios Kyrtzidised983422008-07-01 10:37:29 +000012173 }
Douglas Gregorc811d8f2008-12-15 16:32:14 +000012174
Richard Smith649c7b062014-01-08 00:56:48 +000012175 // C++11 [dcl.type]p3:
12176 // A type-specifier-seq shall not define a class or enumeration [...].
12177 if (getLangOpts().CPlusPlus && IsTypeSpecifier && TUK == TUK_Definition) {
12178 Diag(New->getLocation(), diag::err_type_defined_in_type_specifier)
12179 << Context.getTagDeclType(New);
12180 Invalid = true;
12181 }
12182
John McCall3e11ebe2010-03-15 10:12:16 +000012183 // Maybe add qualifier info.
12184 if (SS.isNotEmpty()) {
Fariborz Jahanian862fac92010-05-14 21:35:02 +000012185 if (SS.isSet()) {
Douglas Gregorb7d17dd2012-03-28 16:01:27 +000012186 // If this is either a declaration or a definition, check the
12187 // nested-name-specifier against the current context. We don't do this
12188 // for explicit specializations, because they have similar checking
12189 // (with more specific diagnostics) in the call to
12190 // CheckMemberSpecialization, below.
12191 if (!isExplicitSpecialization &&
12192 (TUK == TUK_Definition || TUK == TUK_Declaration) &&
David Majnemerbe4c4372014-12-29 05:17:46 +000012193 diagnoseQualifiedDeclaration(SS, DC, OrigName, Loc))
Douglas Gregorb7d17dd2012-03-28 16:01:27 +000012194 Invalid = true;
12195
Douglas Gregor14454802011-02-25 02:25:35 +000012196 New->setQualifierInfo(SS.getWithLocInContext(Context));
Abramo Bagnara60804e12011-03-18 15:16:37 +000012197 if (TemplateParameterLists.size() > 0) {
Douglas Gregor20527e22010-06-15 17:44:38 +000012198 New->setTemplateParameterListsInfo(Context,
Abramo Bagnara60804e12011-03-18 15:16:37 +000012199 TemplateParameterLists.size(),
Benjamin Kramercc4c49d2012-08-23 23:38:35 +000012200 TemplateParameterLists.data());
Abramo Bagnarada41d0c2010-06-12 08:15:14 +000012201 }
Fariborz Jahanian862fac92010-05-14 21:35:02 +000012202 }
12203 else
12204 Invalid = true;
John McCall3e11ebe2010-03-15 10:12:16 +000012205 }
12206
Daniel Dunbar8804f2e2010-05-27 01:53:40 +000012207 if (RecordDecl *RD = dyn_cast<RecordDecl>(New)) {
12208 // Add alignment attributes if necessary; these attributes are checked when
12209 // the ASTContext lays out the structure.
Douglas Gregorc811d8f2008-12-15 16:32:14 +000012210 //
12211 // It is important for implementing the correct semantics that this
12212 // happen here (in act on tag decl). The #pragma pack stack is
12213 // maintained as a result of parser callbacks which can occur at
12214 // many points during the parsing of a struct declaration (because
12215 // the #pragma tokens are effectively skipped over during the
12216 // parsing of the struct).
Eli Friedman0415f3e12012-08-08 21:08:34 +000012217 if (TUK == TUK_Definition) {
12218 AddAlignmentAttributesForRecord(RD);
12219 AddMsStructLayoutForRecord(RD);
12220 }
Douglas Gregorc811d8f2008-12-15 16:32:14 +000012221 }
12222
Douglas Gregor21823bf2011-12-20 18:11:52 +000012223 if (ModulePrivateLoc.isValid()) {
Douglas Gregor3c7cd6a2011-09-09 20:53:38 +000012224 if (isExplicitSpecialization)
12225 Diag(New->getLocation(), diag::err_module_private_specialization)
12226 << 2
12227 << FixItHint::CreateRemoval(ModulePrivateLoc);
Douglas Gregor41866812011-09-12 18:37:38 +000012228 // __module_private__ does not apply to local classes. However, we only
12229 // diagnose this as an error when the declaration specifiers are
12230 // freestanding. Here, we just ignore the __module_private__.
Douglas Gregor41866812011-09-12 18:37:38 +000012231 else if (!SearchDC->isFunctionOrMethod())
Douglas Gregor2820e692011-09-09 19:05:14 +000012232 New->setModulePrivate();
12233 }
Serge Pavlova8261472014-06-25 17:09:41 +000012234
Douglas Gregorbbe8f462009-10-08 15:14:33 +000012235 // If this is a specialization of a member class (of a class template),
12236 // check the specialization.
John McCall1f82f242009-11-18 22:49:29 +000012237 if (isExplicitSpecialization && CheckMemberSpecialization(New, Previous))
Douglas Gregorbbe8f462009-10-08 15:14:33 +000012238 Invalid = true;
Serge Pavlova8261472014-06-25 17:09:41 +000012239
12240 // If we're declaring or defining a tag in function prototype scope in C,
12241 // note that this type can only be used within the function and add it to
12242 // the list of decls to inject into the function definition scope.
12243 if ((Name || Kind == TTK_Enum) &&
12244 getNonFieldDeclScope(S)->isFunctionPrototypeScope()) {
12245 if (getLangOpts().CPlusPlus) {
12246 // C++ [dcl.fct]p6:
12247 // Types shall not be defined in return or parameter types.
12248 if (TUK == TUK_Definition && !IsTypeSpecifier) {
12249 Diag(Loc, diag::err_type_defined_in_param_type)
12250 << Name;
12251 Invalid = true;
12252 }
12253 } else {
12254 Diag(Loc, diag::warn_decl_in_param_list) << Context.getTagDeclType(New);
12255 }
12256 DeclsInPrototypeScope.push_back(New);
12257 }
12258
Douglas Gregordee1be82009-01-17 00:42:38 +000012259 if (Invalid)
12260 New->setInvalidDecl();
12261
Douglas Gregorc811d8f2008-12-15 16:32:14 +000012262 if (Attr)
Douglas Gregor758a8692009-06-17 21:51:59 +000012263 ProcessDeclAttributeList(S, New, Attr);
Douglas Gregorc811d8f2008-12-15 16:32:14 +000012264
12265 // Set the lexical context. If the tag has a C++ scope specifier, the
12266 // lexical context will be different from the semantic context.
Douglas Gregor8761da52009-02-03 00:34:39 +000012267 New->setLexicalDeclContext(CurContext);
Douglas Gregordee1be82009-01-17 00:42:38 +000012268
John McCallaa74a0c2009-08-28 07:59:38 +000012269 // Mark this as a friend decl if applicable.
Francois Pichete37eeba2011-06-01 04:14:20 +000012270 // In Microsoft mode, a friend declaration also acts as a forward
12271 // declaration so we always pass true to setObjectOfFriendDecl to make
12272 // the tag name visible.
John McCallaa74a0c2009-08-28 07:59:38 +000012273 if (TUK == TUK_Friend)
Reid Kleckner0902a512014-07-10 23:44:52 +000012274 New->setObjectOfFriendDecl(getLangOpts().MSVCCompat);
John McCallaa74a0c2009-08-28 07:59:38 +000012275
Anders Carlsson5558ca12009-03-26 01:19:02 +000012276 // Set the access specifier.
John McCalle9eaf8e2010-03-25 21:28:06 +000012277 if (!Invalid && SearchDC->isRecord())
Douglas Gregorb8006faf2009-05-27 17:30:49 +000012278 SetMemberAccessSpecifier(New, PrevDecl, AS);
Douglas Gregor6c2adff2009-03-25 22:00:53 +000012279
John McCall9bb74a52009-07-31 02:45:11 +000012280 if (TUK == TUK_Definition)
Douglas Gregordee1be82009-01-17 00:42:38 +000012281 New->startDefinition();
Mike Stump11289f42009-09-09 15:08:12 +000012282
Chris Lattner18b19622007-01-22 07:39:13 +000012283 // If this has an identifier, add it to the scope stack.
John McCall2dc078f2009-09-02 00:55:30 +000012284 if (TUK == TUK_Friend) {
John McCallf8bd8612009-09-02 19:32:14 +000012285 // We might be replacing an existing declaration in the lookup tables;
12286 // if so, borrow its access specifier.
12287 if (PrevDecl)
12288 New->setAccess(PrevDecl->getAccess());
12289
Sebastian Redl50c68252010-08-31 00:36:30 +000012290 DeclContext *DC = New->getDeclContext()->getRedeclContext();
Richard Smith05afe5e2012-03-13 03:12:56 +000012291 DC->makeDeclVisibleInContext(New);
John McCalle9eaf8e2010-03-25 21:28:06 +000012292 if (Name) // can be null along some error paths
John McCall2dc078f2009-09-02 00:55:30 +000012293 if (Scope *EnclosingScope = getScopeForDeclContext(S, DC))
12294 PushOnScopeChains(New, EnclosingScope, /* AddToContext = */ false);
John McCall2dc078f2009-09-02 00:55:30 +000012295 } else if (Name) {
Douglas Gregor45a33ec2009-01-12 18:45:55 +000012296 S = getNonFieldDeclScope(S);
Douglas Gregor0bf31402010-10-08 23:50:27 +000012297 PushOnScopeChains(New, S, !IsForwardReference);
12298 if (IsForwardReference)
Richard Smith05afe5e2012-03-13 03:12:56 +000012299 SearchDC->makeDeclVisibleInContext(New);
Douglas Gregor0bf31402010-10-08 23:50:27 +000012300
Douglas Gregorc6f58fe2009-01-12 22:49:06 +000012301 } else {
Argyrios Kyrtzidiscfbfe782009-06-30 02:36:12 +000012302 CurContext->addDecl(New);
Chris Lattner18b19622007-01-22 07:39:13 +000012303 }
Argyrios Kyrtzidis9e59b572008-11-09 23:41:00 +000012304
Douglas Gregor27821ce2009-07-07 16:35:42 +000012305 // If this is the C FILE type, notify the AST context.
12306 if (IdentifierInfo *II = New->getIdentifier())
12307 if (!New->isInvalidDecl() &&
Sebastian Redl50c68252010-08-31 00:36:30 +000012308 New->getDeclContext()->getRedeclContext()->isTranslationUnit() &&
Douglas Gregor27821ce2009-07-07 16:35:42 +000012309 II->isStr("FILE"))
12310 Context.setFILEDecl(New);
Mike Stump11289f42009-09-09 15:08:12 +000012311
Rafael Espindolac67f2232012-05-10 02:50:16 +000012312 if (PrevDecl)
12313 mergeDeclAttributes(New, PrevDecl);
12314
Rafael Espindolae3a14bb2012-07-17 15:14:47 +000012315 // If there's a #pragma GCC visibility in scope, set the visibility of this
12316 // record.
12317 AddPushedVisibilityAttribute(New);
12318
Douglas Gregord6ab8742009-05-28 23:31:59 +000012319 OwnedDecl = true;
Richard Smith3e284692012-12-05 11:34:06 +000012320 // In C++, don't return an invalid declaration. We can't recover well from
12321 // the cases where we make the type anonymous.
Craig Topperc3ec1492014-05-26 06:22:03 +000012322 return (Invalid && getLangOpts().CPlusPlus) ? nullptr : New;
Chris Lattner18b19622007-01-22 07:39:13 +000012323}
Chris Lattner1300fb92007-01-23 23:42:53 +000012324
John McCall48871652010-08-21 09:40:31 +000012325void Sema::ActOnTagStartDefinition(Scope *S, Decl *TagD) {
Douglas Gregorded2d7b2009-02-04 19:02:06 +000012326 AdjustDeclIfTemplate(TagD);
John McCall48871652010-08-21 09:40:31 +000012327 TagDecl *Tag = cast<TagDecl>(TagD);
Douglas Gregorba41d012010-04-24 16:38:41 +000012328
Douglas Gregor82ac25e2009-01-08 20:45:30 +000012329 // Enter the tag context.
12330 PushDeclContext(S, Tag);
Dmitri Gribenkof26054f2012-07-11 21:38:39 +000012331
12332 ActOnDocumentableDecl(TagD);
Rafael Espindola4dedd0c2012-07-12 04:47:34 +000012333
12334 // If there's a #pragma GCC visibility in scope, set the visibility of this
12335 // record.
12336 AddPushedVisibilityAttribute(Tag);
John McCall1c7e6ec2009-12-20 07:58:13 +000012337}
Douglas Gregor82ac25e2009-01-08 20:45:30 +000012338
Argyrios Kyrtzidis9321ad32011-10-06 23:23:20 +000012339Decl *Sema::ActOnObjCContainerStartDefinition(Decl *IDecl) {
Fariborz Jahanian8d382dc2011-08-22 15:54:49 +000012340 assert(isa<ObjCContainerDecl>(IDecl) &&
12341 "ActOnObjCContainerStartDefinition - Not ObjCContainerDecl");
12342 DeclContext *OCD = cast<DeclContext>(IDecl);
12343 assert(getContainingDC(OCD) == CurContext &&
12344 "The next DeclContext should be lexically contained in the current one.");
12345 CurContext = OCD;
Argyrios Kyrtzidis9321ad32011-10-06 23:23:20 +000012346 return IDecl;
Fariborz Jahanian8d382dc2011-08-22 15:54:49 +000012347}
12348
John McCall48871652010-08-21 09:40:31 +000012349void Sema::ActOnStartCXXMemberDeclarations(Scope *S, Decl *TagD,
Anders Carlsson30f29442011-03-25 14:31:08 +000012350 SourceLocation FinalLoc,
David Majnemera5433082013-10-18 00:33:31 +000012351 bool IsFinalSpelledSealed,
John McCall1c7e6ec2009-12-20 07:58:13 +000012352 SourceLocation LBraceLoc) {
12353 AdjustDeclIfTemplate(TagD);
John McCall48871652010-08-21 09:40:31 +000012354 CXXRecordDecl *Record = cast<CXXRecordDecl>(TagD);
Douglas Gregor82ac25e2009-01-08 20:45:30 +000012355
John McCall1c7e6ec2009-12-20 07:58:13 +000012356 FieldCollector->StartClass();
12357
12358 if (!Record->getIdentifier())
12359 return;
12360
Anders Carlsson30f29442011-03-25 14:31:08 +000012361 if (FinalLoc.isValid())
David Majnemera5433082013-10-18 00:33:31 +000012362 Record->addAttr(new (Context)
12363 FinalAttr(FinalLoc, Context, IsFinalSpelledSealed));
12364
John McCall1c7e6ec2009-12-20 07:58:13 +000012365 // C++ [class]p2:
12366 // [...] The class-name is also inserted into the scope of the
12367 // class itself; this is known as the injected-class-name. For
12368 // purposes of access checking, the injected-class-name is treated
12369 // as if it were a public member name.
12370 CXXRecordDecl *InjectedClassName
Abramo Bagnara29c2d462011-03-09 14:09:51 +000012371 = CXXRecordDecl::Create(Context, Record->getTagKind(), CurContext,
12372 Record->getLocStart(), Record->getLocation(),
John McCall1c7e6ec2009-12-20 07:58:13 +000012373 Record->getIdentifier(),
Craig Topperc3ec1492014-05-26 06:22:03 +000012374 /*PrevDecl=*/nullptr,
Argyrios Kyrtzidis470c4542010-10-14 20:14:21 +000012375 /*DelayTypeCreation=*/true);
12376 Context.getTypeDeclType(InjectedClassName, Record);
John McCall1c7e6ec2009-12-20 07:58:13 +000012377 InjectedClassName->setImplicit();
12378 InjectedClassName->setAccess(AS_public);
12379 if (ClassTemplateDecl *Template = Record->getDescribedClassTemplate())
12380 InjectedClassName->setDescribedClassTemplate(Template);
12381 PushOnScopeChains(InjectedClassName, S);
12382 assert(InjectedClassName->isInjectedClassName() &&
12383 "Broken injected-class-name");
Douglas Gregor82ac25e2009-01-08 20:45:30 +000012384}
12385
John McCall48871652010-08-21 09:40:31 +000012386void Sema::ActOnTagFinishDefinition(Scope *S, Decl *TagD,
Argyrios Kyrtzidis23e1f1d2009-07-14 03:17:52 +000012387 SourceLocation RBraceLoc) {
Douglas Gregorded2d7b2009-02-04 19:02:06 +000012388 AdjustDeclIfTemplate(TagD);
John McCall48871652010-08-21 09:40:31 +000012389 TagDecl *Tag = cast<TagDecl>(TagD);
Argyrios Kyrtzidis23e1f1d2009-07-14 03:17:52 +000012390 Tag->setRBraceLoc(RBraceLoc);
Douglas Gregor82ac25e2009-01-08 20:45:30 +000012391
Argyrios Kyrtzidis25596292012-03-09 20:10:30 +000012392 // Make sure we "complete" the definition even it is invalid.
12393 if (Tag->isBeingDefined()) {
12394 assert(Tag->isInvalidDecl() && "We should already have completed it");
12395 if (RecordDecl *RD = dyn_cast<RecordDecl>(Tag))
12396 RD->completeDefinition();
12397 }
12398
Reid Klecknerbba3cb92015-03-17 19:00:50 +000012399 if (isa<CXXRecordDecl>(Tag))
Douglas Gregor82ac25e2009-01-08 20:45:30 +000012400 FieldCollector->FinishClass();
12401
12402 // Exit this scope of this tag's definition.
12403 PopDeclContext();
Argyrios Kyrtzidisc821f732013-01-29 18:00:54 +000012404
12405 if (getCurLexicalContext()->isObjCContainer() &&
12406 Tag->getDeclContext()->isFileContext())
12407 Tag->setTopLevelDeclInObjCContainer();
12408
Douglas Gregor82ac25e2009-01-08 20:45:30 +000012409 // Notify the consumer that we've defined a tag.
Serge Pavlovfb73ec82013-07-02 17:31:56 +000012410 if (!Tag->isInvalidDecl())
12411 Consumer.HandleTagDeclDefinition(Tag);
Douglas Gregor82ac25e2009-01-08 20:45:30 +000012412}
Chris Lattner535b8302008-06-21 19:39:06 +000012413
Fariborz Jahanian4327b322011-08-29 17:33:12 +000012414void Sema::ActOnObjCContainerFinishDefinition() {
Fariborz Jahanian8d382dc2011-08-22 15:54:49 +000012415 // Exit this scope of this interface definition.
12416 PopDeclContext();
12417}
Argyrios Kyrtzidis9321ad32011-10-06 23:23:20 +000012418
Argyrios Kyrtzidisa9aabf72011-10-27 00:09:34 +000012419void Sema::ActOnObjCTemporaryExitContainerContext(DeclContext *DC) {
Argyrios Kyrtzidis67f914d2011-10-27 00:53:06 +000012420 assert(DC == CurContext && "Mismatch of container contexts");
12421 OriginalLexicalContext = DC;
Argyrios Kyrtzidis9321ad32011-10-06 23:23:20 +000012422 ActOnObjCContainerFinishDefinition();
12423}
12424
Argyrios Kyrtzidisa9aabf72011-10-27 00:09:34 +000012425void Sema::ActOnObjCReenterContainerContext(DeclContext *DC) {
12426 ActOnObjCContainerStartDefinition(cast<Decl>(DC));
Craig Topperc3ec1492014-05-26 06:22:03 +000012427 OriginalLexicalContext = nullptr;
Argyrios Kyrtzidis9321ad32011-10-06 23:23:20 +000012428}
12429
John McCall48871652010-08-21 09:40:31 +000012430void Sema::ActOnTagDefinitionError(Scope *S, Decl *TagD) {
John McCall2ff380a2010-03-17 00:38:33 +000012431 AdjustDeclIfTemplate(TagD);
John McCall48871652010-08-21 09:40:31 +000012432 TagDecl *Tag = cast<TagDecl>(TagD);
John McCall2ff380a2010-03-17 00:38:33 +000012433 Tag->setInvalidDecl();
12434
Argyrios Kyrtzidis25596292012-03-09 20:10:30 +000012435 // Make sure we "complete" the definition even it is invalid.
12436 if (Tag->isBeingDefined()) {
12437 if (RecordDecl *RD = dyn_cast<RecordDecl>(Tag))
12438 RD->completeDefinition();
12439 }
12440
John McCall71ba5f22010-03-17 19:25:57 +000012441 // We're undoing ActOnTagStartDefinition here, not
12442 // ActOnStartCXXMemberDeclarations, so we don't have to mess with
12443 // the FieldCollector.
John McCall2ff380a2010-03-17 00:38:33 +000012444
12445 PopDeclContext();
12446}
12447
Chris Lattnerf9b00eb2009-04-20 17:29:38 +000012448// Note that FieldName may be null for anonymous bitfields.
Richard Smithf4c51d92012-02-04 09:53:13 +000012449ExprResult Sema::VerifyBitField(SourceLocation FieldLoc,
12450 IdentifierInfo *FieldName,
Reid Kleckner736bc982013-07-17 20:46:03 +000012451 QualType FieldTy, bool IsMsStruct,
12452 Expr *BitWidth, bool *ZeroWidth) {
Eli Friedmanc96d4962009-08-15 21:55:26 +000012453 // Default to true; that shouldn't confuse checks for emptiness
12454 if (ZeroWidth)
12455 *ZeroWidth = true;
12456
Chris Lattner73bf7b42009-03-05 22:45:59 +000012457 // C99 6.7.2.1p4 - verify the field type.
Chris Lattnerd26760a2009-03-05 23:01:03 +000012458 // C++ 9.6p3: A bit-field shall have integral or enumeration type.
Douglas Gregorb90df602010-06-16 00:17:44 +000012459 if (!FieldTy->isDependentType() && !FieldTy->isIntegralOrEnumerationType()) {
Chris Lattner73bf7b42009-03-05 22:45:59 +000012460 // Handle incomplete types with specific error.
Douglas Gregor81457422009-03-10 21:58:27 +000012461 if (RequireCompleteType(FieldLoc, FieldTy, diag::err_field_incomplete))
Richard Smithf4c51d92012-02-04 09:53:13 +000012462 return ExprError();
Chris Lattnerf9b00eb2009-04-20 17:29:38 +000012463 if (FieldName)
12464 return Diag(FieldLoc, diag::err_not_integral_type_bitfield)
12465 << FieldName << FieldTy << BitWidth->getSourceRange();
12466 return Diag(FieldLoc, diag::err_not_integral_type_anon_bitfield)
12467 << FieldTy << BitWidth->getSourceRange();
Douglas Gregora02a72a2010-12-15 23:18:36 +000012468 } else if (DiagnoseUnexpandedParameterPack(const_cast<Expr *>(BitWidth),
12469 UPPC_BitFieldWidth))
Richard Smithf4c51d92012-02-04 09:53:13 +000012470 return ExprError();
Douglas Gregor1efa4372009-03-11 18:59:21 +000012471
12472 // If the bit-width is type- or value-dependent, don't try to check
12473 // it now.
12474 if (BitWidth->isValueDependent() || BitWidth->isTypeDependent())
Nikola Smiljanic03ff2592014-05-29 14:05:12 +000012475 return BitWidth;
Douglas Gregor1efa4372009-03-11 18:59:21 +000012476
Anders Carlsson5df391e2008-12-06 20:33:04 +000012477 llvm::APSInt Value;
Richard Smithf4c51d92012-02-04 09:53:13 +000012478 ExprResult ICE = VerifyIntegerConstantExpression(BitWidth, &Value);
12479 if (ICE.isInvalid())
12480 return ICE;
Nikola Smiljanic01a75982014-05-29 10:55:11 +000012481 BitWidth = ICE.get();
Anders Carlsson5df391e2008-12-06 20:33:04 +000012482
Eli Friedmanc96d4962009-08-15 21:55:26 +000012483 if (Value != 0 && ZeroWidth)
12484 *ZeroWidth = false;
12485
Chris Lattner81ed6802008-12-12 04:56:04 +000012486 // Zero-width bitfield is ok for anonymous field.
12487 if (Value == 0 && FieldName)
12488 return Diag(FieldLoc, diag::err_bitfield_has_zero_width) << FieldName;
Mike Stump11289f42009-09-09 15:08:12 +000012489
Chris Lattnerf9b00eb2009-04-20 17:29:38 +000012490 if (Value.isSigned() && Value.isNegative()) {
12491 if (FieldName)
Mike Stump11289f42009-09-09 15:08:12 +000012492 return Diag(FieldLoc, diag::err_bitfield_has_negative_width)
Chris Lattnerf9b00eb2009-04-20 17:29:38 +000012493 << FieldName << Value.toString(10);
12494 return Diag(FieldLoc, diag::err_anon_bitfield_has_negative_width)
12495 << Value.toString(10);
12496 }
Anders Carlsson5df391e2008-12-06 20:33:04 +000012497
Douglas Gregor1efa4372009-03-11 18:59:21 +000012498 if (!FieldTy->isDependentType()) {
12499 uint64_t TypeSize = Context.getTypeSize(FieldTy);
Chris Lattnerf9b00eb2009-04-20 17:29:38 +000012500 if (Value.getZExtValue() > TypeSize) {
Warren Hunt96afec12013-12-12 23:23:28 +000012501 if (!getLangOpts().CPlusPlus || IsMsStruct ||
12502 Context.getTargetInfo().getCXXABI().isMicrosoft()) {
Anders Carlssond5635fe2010-04-16 15:16:32 +000012503 if (FieldName)
12504 return Diag(FieldLoc, diag::err_bitfield_width_exceeds_type_size)
12505 << FieldName << (unsigned)Value.getZExtValue()
12506 << (unsigned)TypeSize;
12507
12508 return Diag(FieldLoc, diag::err_anon_bitfield_width_exceeds_type_size)
12509 << (unsigned)Value.getZExtValue() << (unsigned)TypeSize;
12510 }
12511
Chris Lattnerf9b00eb2009-04-20 17:29:38 +000012512 if (FieldName)
Anders Carlssond5635fe2010-04-16 15:16:32 +000012513 Diag(FieldLoc, diag::warn_bitfield_width_exceeds_type_size)
12514 << FieldName << (unsigned)Value.getZExtValue()
12515 << (unsigned)TypeSize;
12516 else
12517 Diag(FieldLoc, diag::warn_anon_bitfield_width_exceeds_type_size)
12518 << (unsigned)Value.getZExtValue() << (unsigned)TypeSize;
Chris Lattnerf9b00eb2009-04-20 17:29:38 +000012519 }
Douglas Gregor1efa4372009-03-11 18:59:21 +000012520 }
Anders Carlsson5df391e2008-12-06 20:33:04 +000012521
Nikola Smiljanic03ff2592014-05-29 14:05:12 +000012522 return BitWidth;
Anders Carlsson5df391e2008-12-06 20:33:04 +000012523}
12524
Richard Smith938f40b2011-06-11 17:19:42 +000012525/// ActOnField - Each field of a C struct/union is passed into this in order
Chris Lattner1300fb92007-01-23 23:42:53 +000012526/// to create a FieldDecl object for it.
Richard Smith938f40b2011-06-11 17:19:42 +000012527Decl *Sema::ActOnField(Scope *S, Decl *TagD, SourceLocation DeclStart,
Richard Trieu2bd04012011-09-09 02:00:50 +000012528 Declarator &D, Expr *BitfieldWidth) {
John McCall48871652010-08-21 09:40:31 +000012529 FieldDecl *Res = HandleField(S, cast_or_null<RecordDecl>(TagD),
Chris Lattner83f095c2009-03-28 19:18:32 +000012530 DeclStart, D, static_cast<Expr*>(BitfieldWidth),
Richard Smith2b013182012-06-10 03:12:00 +000012531 /*InitStyle=*/ICIS_NoInit, AS_public);
John McCall48871652010-08-21 09:40:31 +000012532 return Res;
Chris Lattner73bf7b42009-03-05 22:45:59 +000012533}
12534
12535/// HandleField - Analyze a field of a C struct or a C++ data member.
12536///
12537FieldDecl *Sema::HandleField(Scope *S, RecordDecl *Record,
12538 SourceLocation DeclStart,
Richard Smith2b013182012-06-10 03:12:00 +000012539 Declarator &D, Expr *BitWidth,
12540 InClassInitStyle InitStyle,
Douglas Gregor4261e4c2009-03-11 20:50:30 +000012541 AccessSpecifier AS) {
Chris Lattner1300fb92007-01-23 23:42:53 +000012542 IdentifierInfo *II = D.getIdentifier();
Chris Lattner1300fb92007-01-23 23:42:53 +000012543 SourceLocation Loc = DeclStart;
12544 if (II) Loc = D.getIdentifierLoc();
Mike Stump11289f42009-09-09 15:08:12 +000012545
John McCall8cb7bdf2010-06-04 23:28:52 +000012546 TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S);
12547 QualType T = TInfo->getType();
David Blaikiebbafb8a2012-03-11 07:00:24 +000012548 if (getLangOpts().CPlusPlus) {
Douglas Gregor1efa4372009-03-11 18:59:21 +000012549 CheckExtraCXXDefaultArguments(D);
Douglas Gregor0c880302009-03-11 23:00:04 +000012550
Douglas Gregora02a72a2010-12-15 23:18:36 +000012551 if (DiagnoseUnexpandedParameterPack(D.getIdentifierLoc(), TInfo,
12552 UPPC_DataMemberType)) {
12553 D.setInvalidType();
12554 T = Context.IntTy;
12555 TInfo = Context.getTrivialTypeSourceInfo(T, Loc);
12556 }
12557 }
12558
Matt Arsenault376f7202013-02-26 21:16:00 +000012559 // TR 18037 does not allow fields to be declared with address spaces.
12560 if (T.getQualifiers().hasAddressSpace()) {
12561 Diag(Loc, diag::err_field_with_address_space);
12562 D.setInvalidType();
12563 }
12564
Guy Benyei1b4fb3e2013-01-20 12:31:11 +000012565 // OpenCL 1.2 spec, s6.9 r:
12566 // The event type cannot be used to declare a structure or union field.
12567 if (LangOpts.OpenCL && T->isEventT()) {
12568 Diag(Loc, diag::err_event_t_struct_field);
12569 D.setInvalidType();
12570 }
12571
Richard Smithb1402ae2013-03-18 22:52:47 +000012572 DiagnoseFunctionSpecifiers(D.getDeclSpec());
Eli Friedman574c7452009-04-07 19:37:57 +000012573
Richard Smithb4a9e862013-04-12 22:46:28 +000012574 if (DeclSpec::TSCS TSCS = D.getDeclSpec().getThreadStorageClassSpec())
12575 Diag(D.getDeclSpec().getThreadStorageClassSpecLoc(),
12576 diag::err_invalid_thread)
12577 << DeclSpec::getSpecifierName(TSCS);
Matt Arsenault376f7202013-02-26 21:16:00 +000012578
Douglas Gregor2c7d9292010-08-30 14:32:14 +000012579 // Check to see if this name was declared as a member previously
Craig Topperc3ec1492014-05-26 06:22:03 +000012580 NamedDecl *PrevDecl = nullptr;
Douglas Gregor2c7d9292010-08-30 14:32:14 +000012581 LookupResult Previous(*this, II, Loc, LookupMemberName, ForRedeclaration);
12582 LookupName(Previous, S);
Douglas Gregorfbf87522011-10-21 15:47:52 +000012583 switch (Previous.getResultKind()) {
12584 case LookupResult::Found:
12585 case LookupResult::FoundUnresolvedValue:
12586 PrevDecl = Previous.getAsSingle<NamedDecl>();
12587 break;
12588
12589 case LookupResult::FoundOverloaded:
12590 PrevDecl = Previous.getRepresentativeDecl();
12591 break;
12592
12593 case LookupResult::NotFound:
12594 case LookupResult::NotFoundInCurrentInstantiation:
12595 case LookupResult::Ambiguous:
12596 break;
12597 }
12598 Previous.suppressDiagnostics();
Douglas Gregorf187420f2009-06-17 23:37:01 +000012599
12600 if (PrevDecl && PrevDecl->isTemplateParameter()) {
12601 // Maybe we will complain about the shadowed template parameter.
12602 DiagnoseTemplateParameterShadow(D.getIdentifierLoc(), PrevDecl);
12603 // Just pretend that we didn't see the previous declaration.
Craig Topperc3ec1492014-05-26 06:22:03 +000012604 PrevDecl = nullptr;
Douglas Gregorf187420f2009-06-17 23:37:01 +000012605 }
12606
Douglas Gregor1efa4372009-03-11 18:59:21 +000012607 if (PrevDecl && !isDeclInScope(PrevDecl, Record, S))
Craig Topperc3ec1492014-05-26 06:22:03 +000012608 PrevDecl = nullptr;
Douglas Gregor1efa4372009-03-11 18:59:21 +000012609
Steve Naroff5ec6ff72009-07-14 14:58:18 +000012610 bool Mutable
12611 = (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_mutable);
Daniel Dunbar62ee6412012-03-09 18:35:03 +000012612 SourceLocation TSSL = D.getLocStart();
Steve Naroff5ec6ff72009-07-14 14:58:18 +000012613 FieldDecl *NewFD
Richard Smith2b013182012-06-10 03:12:00 +000012614 = CheckFieldDecl(II, T, TInfo, Record, Loc, Mutable, BitWidth, InitStyle,
Richard Smith938f40b2011-06-11 17:19:42 +000012615 TSSL, AS, PrevDecl, &D);
Rafael Espindola568586f2010-03-21 22:56:43 +000012616
12617 if (NewFD->isInvalidDecl())
12618 Record->setInvalidDecl();
12619
Douglas Gregor3baa6702011-09-12 16:11:24 +000012620 if (D.getDeclSpec().isModulePrivateSpecified())
12621 NewFD->setModulePrivate();
12622
Douglas Gregor1efa4372009-03-11 18:59:21 +000012623 if (NewFD->isInvalidDecl() && PrevDecl) {
12624 // Don't introduce NewFD into scope; there's already something
12625 // with the same name in the same scope.
12626 } else if (II) {
12627 PushOnScopeChains(NewFD, S);
12628 } else
Argyrios Kyrtzidiscfbfe782009-06-30 02:36:12 +000012629 Record->addDecl(NewFD);
Douglas Gregor1efa4372009-03-11 18:59:21 +000012630
12631 return NewFD;
12632}
12633
12634/// \brief Build a new FieldDecl and check its well-formedness.
12635///
12636/// This routine builds a new FieldDecl given the fields name, type,
12637/// record, etc. \p PrevDecl should refer to any previous declaration
12638/// with the same name and in the same scope as the field to be
12639/// created.
12640///
12641/// \returns a new FieldDecl.
12642///
Mike Stump11289f42009-09-09 15:08:12 +000012643/// \todo The Declarator argument is a hack. It will be removed once
Argyrios Kyrtzidis60ed5602009-08-19 01:27:57 +000012644FieldDecl *Sema::CheckFieldDecl(DeclarationName Name, QualType T,
John McCallbcd03502009-12-07 02:54:59 +000012645 TypeSourceInfo *TInfo,
Douglas Gregor1efa4372009-03-11 18:59:21 +000012646 RecordDecl *Record, SourceLocation Loc,
Richard Smith2b013182012-06-10 03:12:00 +000012647 bool Mutable, Expr *BitWidth,
12648 InClassInitStyle InitStyle,
Steve Naroff5ec6ff72009-07-14 14:58:18 +000012649 SourceLocation TSSL,
Douglas Gregor4261e4c2009-03-11 20:50:30 +000012650 AccessSpecifier AS, NamedDecl *PrevDecl,
Douglas Gregor1efa4372009-03-11 18:59:21 +000012651 Declarator *D) {
12652 IdentifierInfo *II = Name.getAsIdentifierInfo();
Steve Narofff93b6722007-08-28 20:14:24 +000012653 bool InvalidDecl = false;
Chris Lattnerf6d1c9c2009-04-25 08:06:05 +000012654 if (D) InvalidDecl = D->isInvalidType();
Sebastian Redlbaad4e72009-01-05 20:52:13 +000012655
Douglas Gregor1efa4372009-03-11 18:59:21 +000012656 // If we receive a broken type, recover by assuming 'int' and
12657 // marking this declaration as invalid.
12658 if (T.isNull()) {
12659 InvalidDecl = true;
12660 T = Context.IntTy;
12661 }
12662
Eli Friedmand0e8de22009-12-07 00:22:08 +000012663 QualType EltTy = Context.getBaseElementType(T);
Argyrios Kyrtzidis25596292012-03-09 20:10:30 +000012664 if (!EltTy->isDependentType()) {
12665 if (RequireCompleteType(Loc, EltTy, diag::err_field_incomplete)) {
12666 // Fields of incomplete type force their record to be invalid.
12667 Record->setInvalidDecl();
12668 InvalidDecl = true;
12669 } else {
12670 NamedDecl *Def;
12671 EltTy->isIncompleteType(&Def);
12672 if (Def && Def->isInvalidDecl()) {
12673 Record->setInvalidDecl();
12674 InvalidDecl = true;
12675 }
12676 }
John McCall2677e102010-08-16 23:42:35 +000012677 }
Eli Friedmand0e8de22009-12-07 00:22:08 +000012678
Joey Gouly1d58cdb2013-01-17 17:35:00 +000012679 // OpenCL v1.2 s6.9.c: bitfields are not supported.
12680 if (BitWidth && getLangOpts().OpenCL) {
12681 Diag(Loc, diag::err_opencl_bitfields);
12682 InvalidDecl = true;
12683 }
12684
Steve Naroff8eeeb132007-05-08 21:09:37 +000012685 // C99 6.7.2.1p8: A member of a structure or union may have any type other
12686 // than a variably modified type.
Eli Friedmand0e8de22009-12-07 00:22:08 +000012687 if (!InvalidDecl && T->isVariablyModifiedType()) {
Eli Friedmana3b1d032009-02-21 00:44:51 +000012688 bool SizeIsNegative;
Douglas Gregorcaa1bf42010-08-18 00:39:00 +000012689 llvm::APSInt Oversized;
Abramo Bagnara341ab732012-11-08 14:44:42 +000012690
12691 TypeSourceInfo *FixedTInfo =
12692 TryToFixInvalidVariablyModifiedTypeSourceInfo(TInfo, Context,
12693 SizeIsNegative,
12694 Oversized);
12695 if (FixedTInfo) {
Eli Friedmana3b1d032009-02-21 00:44:51 +000012696 Diag(Loc, diag::warn_illegal_constant_array_size);
Abramo Bagnara341ab732012-11-08 14:44:42 +000012697 TInfo = FixedTInfo;
12698 T = FixedTInfo->getType();
Eli Friedmana3b1d032009-02-21 00:44:51 +000012699 } else {
12700 if (SizeIsNegative)
12701 Diag(Loc, diag::err_typecheck_negative_array_size);
Douglas Gregorcaa1bf42010-08-18 00:39:00 +000012702 else if (Oversized.getBoolValue())
12703 Diag(Loc, diag::err_array_too_large)
12704 << Oversized.toString(10);
Eli Friedmana3b1d032009-02-21 00:44:51 +000012705 else
12706 Diag(Loc, diag::err_typecheck_field_variable_size);
Eli Friedmana3b1d032009-02-21 00:44:51 +000012707 InvalidDecl = true;
12708 }
Steve Naroff8eeeb132007-05-08 21:09:37 +000012709 }
Mike Stump11289f42009-09-09 15:08:12 +000012710
Anders Carlsson576cc6f2009-03-22 20:18:17 +000012711 // Fields can not have abstract class types
Eli Friedmand0e8de22009-12-07 00:22:08 +000012712 if (!InvalidDecl && RequireNonAbstractType(Loc, T,
12713 diag::err_abstract_type_in_decl,
12714 AbstractFieldType))
Anders Carlsson576cc6f2009-03-22 20:18:17 +000012715 InvalidDecl = true;
Mike Stump11289f42009-09-09 15:08:12 +000012716
Eli Friedmanc96d4962009-08-15 21:55:26 +000012717 bool ZeroWidth = false;
David Majnemer8702b522015-04-26 04:58:18 +000012718 if (InvalidDecl)
12719 BitWidth = nullptr;
Douglas Gregor1efa4372009-03-11 18:59:21 +000012720 // If this is declared as a bit-field, check the bit-field.
David Majnemer8702b522015-04-26 04:58:18 +000012721 if (BitWidth) {
Reid Kleckner736bc982013-07-17 20:46:03 +000012722 BitWidth = VerifyBitField(Loc, II, T, Record->isMsStruct(Context), BitWidth,
Nikola Smiljanic01a75982014-05-29 10:55:11 +000012723 &ZeroWidth).get();
Richard Smithf4c51d92012-02-04 09:53:13 +000012724 if (!BitWidth) {
12725 InvalidDecl = true;
Craig Topperc3ec1492014-05-26 06:22:03 +000012726 BitWidth = nullptr;
Richard Smithf4c51d92012-02-04 09:53:13 +000012727 ZeroWidth = false;
12728 }
Anders Carlsson5df391e2008-12-06 20:33:04 +000012729 }
Mike Stump11289f42009-09-09 15:08:12 +000012730
John McCallb1cd7da2010-06-04 08:34:12 +000012731 // Check that 'mutable' is consistent with the type of the declaration.
12732 if (!InvalidDecl && Mutable) {
12733 unsigned DiagID = 0;
12734 if (T->isReferenceType())
Alexey Bataev8f01bb92015-02-04 04:45:32 +000012735 DiagID = getLangOpts().MSVCCompat ? diag::ext_mutable_reference
12736 : diag::err_mutable_reference;
John McCallb1cd7da2010-06-04 08:34:12 +000012737 else if (T.isConstQualified())
12738 DiagID = diag::err_mutable_const;
12739
12740 if (DiagID) {
12741 SourceLocation ErrLoc = Loc;
12742 if (D && D->getDeclSpec().getStorageClassSpecLoc().isValid())
12743 ErrLoc = D->getDeclSpec().getStorageClassSpecLoc();
12744 Diag(ErrLoc, DiagID);
Alexey Bataev8f01bb92015-02-04 04:45:32 +000012745 if (DiagID != diag::ext_mutable_reference) {
12746 Mutable = false;
12747 InvalidDecl = true;
12748 }
John McCallb1cd7da2010-06-04 08:34:12 +000012749 }
12750 }
12751
Richard Smithab44d5b2013-12-10 08:25:00 +000012752 // C++11 [class.union]p8 (DR1460):
12753 // At most one variant member of a union may have a
12754 // brace-or-equal-initializer.
12755 if (InitStyle != ICIS_NoInit)
12756 checkDuplicateDefaultInit(*this, cast<CXXRecordDecl>(Record), Loc);
12757
Abramo Bagnaradff19302011-03-08 08:55:46 +000012758 FieldDecl *NewFD = FieldDecl::Create(Context, Record, TSSL, Loc, II, T, TInfo,
Richard Smith2b013182012-06-10 03:12:00 +000012759 BitWidth, Mutable, InitStyle);
Chris Lattnerf6d1c9c2009-04-25 08:06:05 +000012760 if (InvalidDecl)
12761 NewFD->setInvalidDecl();
Douglas Gregor91f84212008-12-11 16:49:14 +000012762
Douglas Gregor1efa4372009-03-11 18:59:21 +000012763 if (PrevDecl && !isa<TagDecl>(PrevDecl)) {
12764 Diag(Loc, diag::err_duplicate_member) << II;
12765 Diag(PrevDecl->getLocation(), diag::note_previous_declaration);
12766 NewFD->setInvalidDecl();
Douglas Gregor82ac25e2009-01-08 20:45:30 +000012767 }
12768
David Blaikiebbafb8a2012-03-11 07:00:24 +000012769 if (!InvalidDecl && getLangOpts().CPlusPlus) {
Anders Carlsson2ceb3472010-11-07 19:13:55 +000012770 if (Record->isUnion()) {
12771 if (const RecordType *RT = EltTy->getAs<RecordType>()) {
12772 CXXRecordDecl* RDecl = cast<CXXRecordDecl>(RT->getDecl());
12773 if (RDecl->getDefinition()) {
12774 // C++ [class.union]p1: An object of a class with a non-trivial
12775 // constructor, a non-trivial copy constructor, a non-trivial
12776 // destructor, or a non-trivial copy assignment operator
12777 // cannot be a member of a union, nor can an array of such
12778 // objects.
Richard Smithf720df02011-10-19 20:41:51 +000012779 if (CheckNontrivialField(NewFD))
Anders Carlsson2ceb3472010-11-07 19:13:55 +000012780 NewFD->setInvalidDecl();
12781 }
12782 }
12783
12784 // C++ [class.union]p1: If a union contains a member of reference type,
Aaron Ballmaned0ae1d2013-05-30 16:20:00 +000012785 // the program is ill-formed, except when compiling with MSVC extensions
12786 // enabled.
Anders Carlsson2ceb3472010-11-07 19:13:55 +000012787 if (EltTy->isReferenceType()) {
Aaron Ballmaned0ae1d2013-05-30 16:20:00 +000012788 Diag(NewFD->getLocation(), getLangOpts().MicrosoftExt ?
12789 diag::ext_union_member_of_reference_type :
12790 diag::err_union_member_of_reference_type)
Anders Carlsson2ceb3472010-11-07 19:13:55 +000012791 << NewFD->getDeclName() << EltTy;
Aaron Ballmaned0ae1d2013-05-30 16:20:00 +000012792 if (!getLangOpts().MicrosoftExt)
12793 NewFD->setInvalidDecl();
Douglas Gregor8a273912009-07-22 18:25:24 +000012794 }
12795 }
12796 }
12797
Douglas Gregor1efa4372009-03-11 18:59:21 +000012798 // FIXME: We need to pass in the attributes given an AST
12799 // representation, not a parser representation.
Richard Smith848e1f12013-02-01 08:12:08 +000012800 if (D) {
Douglas Gregord2472d42013-05-02 23:25:32 +000012801 // FIXME: The current scope is almost... but not entirely... correct here.
12802 ProcessDeclAttributes(getCurScope(), NewFD, *D);
Douglas Gregor1efa4372009-03-11 18:59:21 +000012803
Richard Smith848e1f12013-02-01 08:12:08 +000012804 if (NewFD->hasAttrs())
12805 CheckAlignasUnderalignment(NewFD);
12806 }
12807
John McCall31168b02011-06-15 23:02:42 +000012808 // In auto-retain/release, infer strong retension for fields of
12809 // retainable type.
David Blaikiebbafb8a2012-03-11 07:00:24 +000012810 if (getLangOpts().ObjCAutoRefCount && inferObjCARCLifetime(NewFD))
John McCall31168b02011-06-15 23:02:42 +000012811 NewFD->setInvalidDecl();
12812
Fariborz Jahaniand29fecd2009-02-19 00:22:47 +000012813 if (T.isObjCGCWeak())
Fariborz Jahaniand35c7922009-02-18 18:14:41 +000012814 Diag(Loc, diag::warn_attribute_weak_on_field);
Anders Carlsson28e71082008-02-16 00:29:18 +000012815
Douglas Gregor4261e4c2009-03-11 20:50:30 +000012816 NewFD->setAccess(AS);
Steve Narofff93b6722007-08-28 20:14:24 +000012817 return NewFD;
Chris Lattner1300fb92007-01-23 23:42:53 +000012818}
12819
Argyrios Kyrtzidis33aee392010-08-16 17:27:08 +000012820bool Sema::CheckNontrivialField(FieldDecl *FD) {
12821 assert(FD);
David Blaikiebbafb8a2012-03-11 07:00:24 +000012822 assert(getLangOpts().CPlusPlus && "valid check only for C++");
Argyrios Kyrtzidis33aee392010-08-16 17:27:08 +000012823
Nick Lewycky7a2a4792013-06-25 23:22:23 +000012824 if (FD->isInvalidDecl() || FD->getType()->isDependentType())
12825 return false;
Argyrios Kyrtzidis33aee392010-08-16 17:27:08 +000012826
12827 QualType EltTy = Context.getBaseElementType(FD->getType());
12828 if (const RecordType *RT = EltTy->getAs<RecordType>()) {
Richard Smith92f241f2012-12-08 02:53:02 +000012829 CXXRecordDecl *RDecl = cast<CXXRecordDecl>(RT->getDecl());
Argyrios Kyrtzidis33aee392010-08-16 17:27:08 +000012830 if (RDecl->getDefinition()) {
12831 // We check for copy constructors before constructors
12832 // because otherwise we'll never get complaints about
12833 // copy constructors.
12834
12835 CXXSpecialMember member = CXXInvalid;
Richard Smith16488472012-11-16 00:53:38 +000012836 // We're required to check for any non-trivial constructors. Since the
12837 // implicit default constructor is suppressed if there are any
12838 // user-declared constructors, we just need to check that there is a
12839 // trivial default constructor and a trivial copy constructor. (We don't
12840 // worry about move constructors here, since this is a C++98 check.)
12841 if (RDecl->hasNonTrivialCopyConstructor())
Argyrios Kyrtzidis33aee392010-08-16 17:27:08 +000012842 member = CXXCopyConstructor;
Alexis Huntf479f1b2011-05-09 18:22:59 +000012843 else if (!RDecl->hasTrivialDefaultConstructor())
Alexis Hunt80f00ff2011-05-10 19:08:14 +000012844 member = CXXDefaultConstructor;
Richard Smith16488472012-11-16 00:53:38 +000012845 else if (RDecl->hasNonTrivialCopyAssignment())
Argyrios Kyrtzidis33aee392010-08-16 17:27:08 +000012846 member = CXXCopyAssignment;
Richard Smith16488472012-11-16 00:53:38 +000012847 else if (RDecl->hasNonTrivialDestructor())
Argyrios Kyrtzidis33aee392010-08-16 17:27:08 +000012848 member = CXXDestructor;
12849
12850 if (member != CXXInvalid) {
Richard Smith2bf7fdb2013-01-02 11:42:31 +000012851 if (!getLangOpts().CPlusPlus11 &&
David Blaikiebbafb8a2012-03-11 07:00:24 +000012852 getLangOpts().ObjCAutoRefCount && RDecl->hasObjectMember()) {
John McCall31168b02011-06-15 23:02:42 +000012853 // Objective-C++ ARC: it is an error to have a non-trivial field of
12854 // a union. However, system headers in Objective-C programs
12855 // occasionally have Objective-C lifetime objects within unions,
12856 // and rather than cause the program to fail, we make those
12857 // members unavailable.
12858 SourceLocation Loc = FD->getLocation();
12859 if (getSourceManager().isInSystemHeader(Loc)) {
12860 if (!FD->hasAttr<UnavailableAttr>())
Aaron Ballman36a53502014-01-16 13:03:14 +000012861 FD->addAttr(UnavailableAttr::CreateImplicit(Context,
12862 "this system field has retaining ownership",
12863 Loc));
John McCall31168b02011-06-15 23:02:42 +000012864 return false;
12865 }
12866 }
Richard Smithf720df02011-10-19 20:41:51 +000012867
Richard Smith2bf7fdb2013-01-02 11:42:31 +000012868 Diag(FD->getLocation(), getLangOpts().CPlusPlus11 ?
Richard Smithf720df02011-10-19 20:41:51 +000012869 diag::warn_cxx98_compat_nontrivial_union_or_anon_struct_member :
12870 diag::err_illegal_union_or_anon_struct_member)
12871 << (int)FD->getParent()->isUnion() << FD->getDeclName() << member;
Richard Smith92f241f2012-12-08 02:53:02 +000012872 DiagnoseNontrivial(RDecl, member);
Richard Smith2bf7fdb2013-01-02 11:42:31 +000012873 return !getLangOpts().CPlusPlus11;
Argyrios Kyrtzidis33aee392010-08-16 17:27:08 +000012874 }
12875 }
12876 }
Richard Smith92f241f2012-12-08 02:53:02 +000012877
Argyrios Kyrtzidis33aee392010-08-16 17:27:08 +000012878 return false;
12879}
12880
Mike Stump11289f42009-09-09 15:08:12 +000012881/// TranslateIvarVisibility - Translate visibility from a token ID to an
Fariborz Jahanianf26702eb2007-10-01 16:53:59 +000012882/// AST enum value.
Ted Kremenek1b0ea822008-01-07 19:49:32 +000012883static ObjCIvarDecl::AccessControl
Fariborz Jahanianf26702eb2007-10-01 16:53:59 +000012884TranslateIvarVisibility(tok::ObjCKeywordKind ivarVisibility) {
Steve Naroff2e688fd2007-09-14 23:09:53 +000012885 switch (ivarVisibility) {
David Blaikie83d382b2011-09-23 05:06:16 +000012886 default: llvm_unreachable("Unknown visitibility kind");
Chris Lattner79ef8432008-10-12 00:28:42 +000012887 case tok::objc_private: return ObjCIvarDecl::Private;
12888 case tok::objc_public: return ObjCIvarDecl::Public;
12889 case tok::objc_protected: return ObjCIvarDecl::Protected;
12890 case tok::objc_package: return ObjCIvarDecl::Package;
Steve Naroff2e688fd2007-09-14 23:09:53 +000012891 }
12892}
12893
Mike Stump11289f42009-09-09 15:08:12 +000012894/// ActOnIvar - Each ivar field of an objective-c class is passed into this
Fariborz Jahanian96376742008-04-11 16:55:42 +000012895/// in order to create an IvarDecl object for it.
John McCall48871652010-08-21 09:40:31 +000012896Decl *Sema::ActOnIvar(Scope *S,
Mike Stump11289f42009-09-09 15:08:12 +000012897 SourceLocation DeclStart,
Richard Trieu2bd04012011-09-09 02:00:50 +000012898 Declarator &D, Expr *BitfieldWidth,
Chris Lattner83f095c2009-03-28 19:18:32 +000012899 tok::ObjCKeywordKind Visibility) {
Mike Stump11289f42009-09-09 15:08:12 +000012900
Fariborz Jahaniande615832008-04-10 23:32:45 +000012901 IdentifierInfo *II = D.getIdentifier();
12902 Expr *BitWidth = (Expr*)BitfieldWidth;
12903 SourceLocation Loc = DeclStart;
12904 if (II) Loc = D.getIdentifierLoc();
Mike Stump11289f42009-09-09 15:08:12 +000012905
Fariborz Jahaniande615832008-04-10 23:32:45 +000012906 // FIXME: Unnamed fields can be handled in various different ways, for
12907 // example, unnamed unions inject all members into the struct namespace!
Mike Stump11289f42009-09-09 15:08:12 +000012908
John McCall8cb7bdf2010-06-04 23:28:52 +000012909 TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S);
12910 QualType T = TInfo->getType();
Mike Stump11289f42009-09-09 15:08:12 +000012911
Fariborz Jahaniande615832008-04-10 23:32:45 +000012912 if (BitWidth) {
Steve Naroff17b2f5d2009-02-20 17:57:11 +000012913 // 6.7.2.1p3, 6.7.2.1p4
Nikola Smiljanic01a75982014-05-29 10:55:11 +000012914 BitWidth = VerifyBitField(Loc, II, T, /*IsMsStruct*/false, BitWidth).get();
Richard Smithf4c51d92012-02-04 09:53:13 +000012915 if (!BitWidth)
Chris Lattnerf6d1c9c2009-04-25 08:06:05 +000012916 D.setInvalidType();
Fariborz Jahaniande615832008-04-10 23:32:45 +000012917 } else {
12918 // Not a bitfield.
Mike Stump11289f42009-09-09 15:08:12 +000012919
Fariborz Jahaniande615832008-04-10 23:32:45 +000012920 // validate II.
Mike Stump11289f42009-09-09 15:08:12 +000012921
Fariborz Jahaniande615832008-04-10 23:32:45 +000012922 }
Fariborz Jahanian0103d672010-04-26 22:07:03 +000012923 if (T->isReferenceType()) {
12924 Diag(Loc, diag::err_ivar_reference_type);
12925 D.setInvalidType();
12926 }
Fariborz Jahaniande615832008-04-10 23:32:45 +000012927 // C99 6.7.2.1p8: A member of a structure or union may have any type other
12928 // than a variably modified type.
Fariborz Jahanian0103d672010-04-26 22:07:03 +000012929 else if (T->isVariablyModifiedType()) {
Anders Carlsson0d8f0ba2008-12-07 00:20:55 +000012930 Diag(Loc, diag::err_typecheck_ivar_variable_size);
Chris Lattnerf6d1c9c2009-04-25 08:06:05 +000012931 D.setInvalidType();
Fariborz Jahaniande615832008-04-10 23:32:45 +000012932 }
Mike Stump11289f42009-09-09 15:08:12 +000012933
Ted Kremenek73295fa2008-07-23 18:04:17 +000012934 // Get the visibility (access control) for this ivar.
Mike Stump11289f42009-09-09 15:08:12 +000012935 ObjCIvarDecl::AccessControl ac =
Ted Kremenek73295fa2008-07-23 18:04:17 +000012936 Visibility != tok::objc_not_keyword ? TranslateIvarVisibility(Visibility)
12937 : ObjCIvarDecl::None;
Fariborz Jahanian68453832009-06-05 18:16:35 +000012938 // Must set ivar's DeclContext to its enclosing interface.
Fariborz Jahanian8d382dc2011-08-22 15:54:49 +000012939 ObjCContainerDecl *EnclosingDecl = cast<ObjCContainerDecl>(CurContext);
Fariborz Jahanian17612b12012-02-02 00:49:12 +000012940 if (!EnclosingDecl || EnclosingDecl->isInvalidDecl())
Craig Topperc3ec1492014-05-26 06:22:03 +000012941 return nullptr;
Daniel Dunbar229385c2010-04-02 18:29:09 +000012942 ObjCContainerDecl *EnclosingContext;
Mike Stump11289f42009-09-09 15:08:12 +000012943 if (ObjCImplementationDecl *IMPDecl =
Fariborz Jahanian68453832009-06-05 18:16:35 +000012944 dyn_cast<ObjCImplementationDecl>(EnclosingDecl)) {
John McCall5fb5df92012-06-20 06:18:46 +000012945 if (LangOpts.ObjCRuntime.isFragile()) {
Fariborz Jahanian68453832009-06-05 18:16:35 +000012946 // Case of ivar declared in an implementation. Context is that of its class.
Fariborz Jahanianbf9294f2010-08-23 18:51:39 +000012947 EnclosingContext = IMPDecl->getClassInterface();
12948 assert(EnclosingContext && "Implementation has no class interface!");
12949 }
12950 else
12951 EnclosingContext = EnclosingDecl;
Fariborz Jahanian6a0a2e02010-04-06 22:43:48 +000012952 } else {
12953 if (ObjCCategoryDecl *CDecl =
12954 dyn_cast<ObjCCategoryDecl>(EnclosingDecl)) {
John McCall5fb5df92012-06-20 06:18:46 +000012955 if (LangOpts.ObjCRuntime.isFragile() || !CDecl->IsClassExtension()) {
Fariborz Jahanian6a0a2e02010-04-06 22:43:48 +000012956 Diag(Loc, diag::err_misplaced_ivar) << CDecl->IsClassExtension();
Craig Topperc3ec1492014-05-26 06:22:03 +000012957 return nullptr;
Fariborz Jahanian6a0a2e02010-04-06 22:43:48 +000012958 }
12959 }
Daniel Dunbar229385c2010-04-02 18:29:09 +000012960 EnclosingContext = EnclosingDecl;
Fariborz Jahanian6a0a2e02010-04-06 22:43:48 +000012961 }
Mike Stump11289f42009-09-09 15:08:12 +000012962
Ted Kremenek73295fa2008-07-23 18:04:17 +000012963 // Construct the decl.
Abramo Bagnaradff19302011-03-08 08:55:46 +000012964 ObjCIvarDecl *NewID = ObjCIvarDecl::Create(Context, EnclosingContext,
12965 DeclStart, Loc, II, T,
John McCallbcd03502009-12-07 02:54:59 +000012966 TInfo, ac, (Expr *)BitfieldWidth);
Mike Stump11289f42009-09-09 15:08:12 +000012967
Douglas Gregor82ac25e2009-01-08 20:45:30 +000012968 if (II) {
Douglas Gregorb2ccf012010-04-15 22:33:43 +000012969 NamedDecl *PrevDecl = LookupSingleName(S, II, Loc, LookupMemberName,
John McCall5cebab12009-11-18 07:57:50 +000012970 ForRedeclaration);
Fariborz Jahanian68453832009-06-05 18:16:35 +000012971 if (PrevDecl && isDeclInScope(PrevDecl, EnclosingContext, S)
Douglas Gregor82ac25e2009-01-08 20:45:30 +000012972 && !isa<TagDecl>(PrevDecl)) {
12973 Diag(Loc, diag::err_duplicate_member) << II;
12974 Diag(PrevDecl->getLocation(), diag::note_previous_declaration);
12975 NewID->setInvalidDecl();
12976 }
12977 }
12978
Ted Kremenek73295fa2008-07-23 18:04:17 +000012979 // Process attributes attached to the ivar.
Douglas Gregor758a8692009-06-17 21:51:59 +000012980 ProcessDeclAttributes(S, NewID, D);
Mike Stump11289f42009-09-09 15:08:12 +000012981
Chris Lattnerf6d1c9c2009-04-25 08:06:05 +000012982 if (D.isInvalidType())
Fariborz Jahaniande615832008-04-10 23:32:45 +000012983 NewID->setInvalidDecl();
Ted Kremenek73295fa2008-07-23 18:04:17 +000012984
John McCall31168b02011-06-15 23:02:42 +000012985 // In ARC, infer 'retaining' for ivars of retainable type.
David Blaikiebbafb8a2012-03-11 07:00:24 +000012986 if (getLangOpts().ObjCAutoRefCount && inferObjCARCLifetime(NewID))
John McCall31168b02011-06-15 23:02:42 +000012987 NewID->setInvalidDecl();
12988
Douglas Gregor3baa6702011-09-12 16:11:24 +000012989 if (D.getDeclSpec().isModulePrivateSpecified())
12990 NewID->setModulePrivate();
12991
Douglas Gregor82ac25e2009-01-08 20:45:30 +000012992 if (II) {
12993 // FIXME: When interfaces are DeclContexts, we'll need to add
12994 // these to the interface.
John McCall48871652010-08-21 09:40:31 +000012995 S->AddDecl(NewID);
Douglas Gregor82ac25e2009-01-08 20:45:30 +000012996 IdResolver.AddDecl(NewID);
12997 }
Fariborz Jahanian80297b12012-05-15 16:33:04 +000012998
John McCall5fb5df92012-06-20 06:18:46 +000012999 if (LangOpts.ObjCRuntime.isNonFragile() &&
Fariborz Jahanian80297b12012-05-15 16:33:04 +000013000 !NewID->isInvalidDecl() && isa<ObjCInterfaceDecl>(EnclosingDecl))
Fariborz Jahaniane1ada582012-05-15 17:43:16 +000013001 Diag(Loc, diag::warn_ivars_in_interface);
Fariborz Jahanian80297b12012-05-15 16:33:04 +000013002
John McCall48871652010-08-21 09:40:31 +000013003 return NewID;
Fariborz Jahaniande615832008-04-10 23:32:45 +000013004}
13005
Fariborz Jahanian616d3e72010-08-23 22:46:52 +000013006/// ActOnLastBitfield - This routine handles synthesized bitfields rules for
Jordan Rosea0e9d392013-04-03 01:39:23 +000013007/// class and class extensions. For every class \@interface and class
13008/// extension \@interface, if the last ivar is a bitfield of any type,
Fariborz Jahanian616d3e72010-08-23 22:46:52 +000013009/// then add an implicit `char :0` ivar to the end of that interface.
Fariborz Jahanian8d382dc2011-08-22 15:54:49 +000013010void Sema::ActOnLastBitfield(SourceLocation DeclLoc,
Chris Lattner0e62c1c2011-07-23 10:55:15 +000013011 SmallVectorImpl<Decl *> &AllIvarDecls) {
John McCall5fb5df92012-06-20 06:18:46 +000013012 if (LangOpts.ObjCRuntime.isFragile() || AllIvarDecls.empty())
Fariborz Jahanian616d3e72010-08-23 22:46:52 +000013013 return;
13014
13015 Decl *ivarDecl = AllIvarDecls[AllIvarDecls.size()-1];
13016 ObjCIvarDecl *Ivar = cast<ObjCIvarDecl>(ivarDecl);
13017
Richard Smithcaf33902011-10-10 18:28:20 +000013018 if (!Ivar->isBitField() || Ivar->getBitWidthValue(Context) == 0)
Fariborz Jahanian616d3e72010-08-23 22:46:52 +000013019 return;
Fariborz Jahanian8d382dc2011-08-22 15:54:49 +000013020 ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(CurContext);
Fariborz Jahanian616d3e72010-08-23 22:46:52 +000013021 if (!ID) {
Fariborz Jahanian8d382dc2011-08-22 15:54:49 +000013022 if (ObjCCategoryDecl *CD = dyn_cast<ObjCCategoryDecl>(CurContext)) {
Fariborz Jahanian616d3e72010-08-23 22:46:52 +000013023 if (!CD->IsClassExtension())
13024 return;
13025 }
13026 // No need to add this to end of @implementation.
13027 else
13028 return;
13029 }
13030 // All conditions are met. Add a new bitfield to the tail end of ivars.
Douglas Gregor1d394802011-08-03 16:26:46 +000013031 llvm::APInt Zero(Context.getTypeSize(Context.IntTy), 0);
13032 Expr * BW = IntegerLiteral::Create(Context, Zero, Context.IntTy, DeclLoc);
Fariborz Jahanian616d3e72010-08-23 22:46:52 +000013033
Fariborz Jahanian8d382dc2011-08-22 15:54:49 +000013034 Ivar = ObjCIvarDecl::Create(Context, cast<ObjCContainerDecl>(CurContext),
Craig Topperc3ec1492014-05-26 06:22:03 +000013035 DeclLoc, DeclLoc, nullptr,
Fariborz Jahanian616d3e72010-08-23 22:46:52 +000013036 Context.CharTy,
Douglas Gregor1d394802011-08-03 16:26:46 +000013037 Context.getTrivialTypeSourceInfo(Context.CharTy,
13038 DeclLoc),
Fariborz Jahanian616d3e72010-08-23 22:46:52 +000013039 ObjCIvarDecl::Private, BW,
13040 true);
13041 AllIvarDecls.push_back(Ivar);
13042}
13043
Robert Wilhelm16e94b92013-08-09 18:02:13 +000013044void Sema::ActOnFields(Scope *S, SourceLocation RecLoc, Decl *EnclosingDecl,
13045 ArrayRef<Decl *> Fields, SourceLocation LBrac,
13046 SourceLocation RBrac, AttributeList *Attr) {
Steve Naroffdb47ee22007-09-14 22:20:54 +000013047 assert(EnclosingDecl && "missing record or interface decl");
Mike Stump11289f42009-09-09 15:08:12 +000013048
Eric Christopher7457aaf2012-07-19 22:22:51 +000013049 // If this is an Objective-C @implementation or category and we have
13050 // new fields here we should reset the layout of the interface since
13051 // it will now change.
13052 if (!Fields.empty() && isa<ObjCContainerDecl>(EnclosingDecl)) {
13053 ObjCContainerDecl *DC = cast<ObjCContainerDecl>(EnclosingDecl);
13054 switch (DC->getKind()) {
13055 default: break;
13056 case Decl::ObjCCategory:
13057 Context.ResetObjCLayout(cast<ObjCCategoryDecl>(DC)->getClassInterface());
13058 break;
13059 case Decl::ObjCImplementation:
13060 Context.
13061 ResetObjCLayout(cast<ObjCImplementationDecl>(DC)->getClassInterface());
13062 break;
13063 }
13064 }
13065
Eli Friedmana7679412012-02-07 05:00:47 +000013066 RecordDecl *Record = dyn_cast<RecordDecl>(EnclosingDecl);
13067
13068 // Start counting up the number of named members; make sure to include
13069 // members of anonymous structs and unions in the total.
Chris Lattner82625602007-01-24 02:26:21 +000013070 unsigned NumNamedMembers = 0;
Eli Friedmana7679412012-02-07 05:00:47 +000013071 if (Record) {
Aaron Ballman629afae2014-03-07 19:56:05 +000013072 for (const auto *I : Record->decls()) {
13073 if (const auto *IFD = dyn_cast<IndirectFieldDecl>(I))
Eli Friedmana7679412012-02-07 05:00:47 +000013074 if (IFD->getDeclName())
13075 ++NumNamedMembers;
13076 }
13077 }
13078
13079 // Verify that all the fields are okay.
Chris Lattner0e62c1c2011-07-23 10:55:15 +000013080 SmallVector<FieldDecl*, 32> RecFields;
Douglas Gregorf4d33272009-01-07 19:46:03 +000013081
John McCall31168b02011-06-15 23:02:42 +000013082 bool ARCErrReported = false;
Robert Wilhelm16e94b92013-08-09 18:02:13 +000013083 for (ArrayRef<Decl *>::iterator i = Fields.begin(), end = Fields.end();
David Blaikie751c5582011-09-22 02:58:26 +000013084 i != end; ++i) {
13085 FieldDecl *FD = cast<FieldDecl>(*i);
Mike Stump11289f42009-09-09 15:08:12 +000013086
Chris Lattner720a0542007-01-25 00:44:24 +000013087 // Get the type for the field.
John McCall424cec92011-01-19 06:33:43 +000013088 const Type *FDTy = FD->getType().getTypePtr();
Douglas Gregorf4d33272009-01-07 19:46:03 +000013089
Douglas Gregor82ac25e2009-01-08 20:45:30 +000013090 if (!FD->isAnonymousStructOrUnion()) {
Douglas Gregorf4d33272009-01-07 19:46:03 +000013091 // Remember all fields written by the user.
13092 RecFields.push_back(FD);
13093 }
Mike Stump11289f42009-09-09 15:08:12 +000013094
Chris Lattner73bf7b42009-03-05 22:45:59 +000013095 // If the field is already invalid for some reason, don't emit more
13096 // diagnostics about it.
Eli Friedmand0e8de22009-12-07 00:22:08 +000013097 if (FD->isInvalidDecl()) {
13098 EnclosingDecl->setInvalidDecl();
Chris Lattner73bf7b42009-03-05 22:45:59 +000013099 continue;
Eli Friedmand0e8de22009-12-07 00:22:08 +000013100 }
Mike Stump11289f42009-09-09 15:08:12 +000013101
Douglas Gregorac1fb652009-03-24 19:52:54 +000013102 // C99 6.7.2.1p2:
13103 // A structure or union shall not contain a member with
13104 // incomplete or function type (hence, a structure shall not
13105 // contain an instance of itself, but may contain a pointer to
13106 // an instance of itself), except that the last member of a
13107 // structure with more than one named member may have incomplete
13108 // array type; such a structure (and any union containing,
13109 // possibly recursively, a member that is such a structure)
13110 // shall not be a member of a structure or an element of an
13111 // array.
Chris Lattner0fd893e2007-07-31 21:33:24 +000013112 if (FDTy->isFunctionType()) {
Douglas Gregorac1fb652009-03-24 19:52:54 +000013113 // Field declared as a function.
Chris Lattner651d42d2008-11-20 06:38:18 +000013114 Diag(FD->getLocation(), diag::err_field_declared_as_function)
Chris Lattnerf3d3fae2008-11-24 05:29:24 +000013115 << FD->getDeclName();
Steve Naroffdb47ee22007-09-14 22:20:54 +000013116 FD->setInvalidDecl();
13117 EnclosingDecl->setInvalidDecl();
Chris Lattnerbdf8b8d2007-01-24 02:11:17 +000013118 continue;
Francois Pichetf657b632010-09-15 00:14:08 +000013119 } else if (FDTy->isIncompleteArrayType() && Record &&
David Blaikie751c5582011-09-22 02:58:26 +000013120 ((i + 1 == Fields.end() && !Record->isUnion()) ||
David Blaikiebbafb8a2012-03-11 07:00:24 +000013121 ((getLangOpts().MicrosoftExt ||
13122 getLangOpts().CPlusPlus) &&
David Blaikie751c5582011-09-22 02:58:26 +000013123 (i + 1 == Fields.end() || Record->isUnion())))) {
Douglas Gregorac1fb652009-03-24 19:52:54 +000013124 // Flexible array member.
Argyrios Kyrtzidis7e25a952011-03-07 20:04:04 +000013125 // Microsoft and g++ is more permissive regarding flexible array.
Francois Pichetf657b632010-09-15 00:14:08 +000013126 // It will accept flexible array in union and also
Anders Carlsson0ea10472010-10-17 23:36:12 +000013127 // as the sole element of a struct/class.
David Majnemer41016212013-11-02 10:38:05 +000013128 unsigned DiagID = 0;
13129 if (Record->isUnion())
13130 DiagID = getLangOpts().MicrosoftExt
13131 ? diag::ext_flexible_array_union_ms
13132 : getLangOpts().CPlusPlus
13133 ? diag::ext_flexible_array_union_gnu
13134 : diag::err_flexible_array_union;
13135 else if (Fields.size() == 1)
13136 DiagID = getLangOpts().MicrosoftExt
13137 ? diag::ext_flexible_array_empty_aggregate_ms
13138 : getLangOpts().CPlusPlus
13139 ? diag::ext_flexible_array_empty_aggregate_gnu
13140 : NumNamedMembers < 1
13141 ? diag::err_flexible_array_empty_aggregate
13142 : 0;
13143
13144 if (DiagID)
13145 Diag(FD->getLocation(), DiagID) << FD->getDeclName()
13146 << Record->getTagKind();
David Majnemer08cd7602013-11-02 11:19:13 +000013147 // While the layout of types that contain virtual bases is not specified
13148 // by the C++ standard, both the Itanium and Microsoft C++ ABIs place
13149 // virtual bases after the derived members. This would make a flexible
13150 // array member declared at the end of an object not adjacent to the end
13151 // of the type.
13152 if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(Record))
13153 if (RD->getNumVBases() != 0)
13154 Diag(FD->getLocation(), diag::err_flexible_array_virtual_base)
13155 << FD->getDeclName() << Record->getTagKind();
David Majnemer41016212013-11-02 10:38:05 +000013156 if (!getLangOpts().C99)
13157 Diag(FD->getLocation(), diag::ext_c99_flexible_array_member)
13158 << FD->getDeclName() << Record->getTagKind();
13159
Richard Smith6fa28ff2014-01-11 00:53:35 +000013160 // If the element type has a non-trivial destructor, we would not
13161 // implicitly destroy the elements, so disallow it for now.
13162 //
13163 // FIXME: GCC allows this. We should probably either implicitly delete
13164 // the destructor of the containing class, or just allow this.
13165 QualType BaseElem = Context.getBaseElementType(FD->getType());
13166 if (!BaseElem->isDependentType() && BaseElem.isDestructedType()) {
13167 Diag(FD->getLocation(), diag::err_flexible_array_has_nontrivial_dtor)
Fariborz Jahanianb0e28472010-05-26 20:46:24 +000013168 << FD->getDeclName() << FD->getType();
Fariborz Jahanian1138ba62010-05-26 20:19:07 +000013169 FD->setInvalidDecl();
13170 EnclosingDecl->setInvalidDecl();
13171 continue;
13172 }
Chris Lattner720a0542007-01-25 00:44:24 +000013173 // Okay, we have a legal flexible array member at the end of the struct.
David Majnemerac0b30e2014-09-24 11:04:09 +000013174 Record->setHasFlexibleArrayMember(true);
Douglas Gregorac1fb652009-03-24 19:52:54 +000013175 } else if (!FDTy->isDependentType() &&
Mike Stump11289f42009-09-09 15:08:12 +000013176 RequireCompleteType(FD->getLocation(), FD->getType(),
Douglas Gregorac1fb652009-03-24 19:52:54 +000013177 diag::err_field_incomplete)) {
13178 // Incomplete type
13179 FD->setInvalidDecl();
13180 EnclosingDecl->setInvalidDecl();
13181 continue;
Ted Kremenekc23c7e62009-07-29 21:53:49 +000013182 } else if (const RecordType *FDTTy = FDTy->getAs<RecordType>()) {
David Majnemerac0b30e2014-09-24 11:04:09 +000013183 if (Record && FDTTy->getDecl()->hasFlexibleArrayMember()) {
13184 // A type which contains a flexible array member is considered to be a
13185 // flexible array member.
13186 Record->setHasFlexibleArrayMember(true);
13187 if (!Record->isUnion()) {
Chris Lattner720a0542007-01-25 00:44:24 +000013188 // If this is a struct/class and this is not the last element, reject
13189 // it. Note that GCC supports variable sized arrays in the middle of
13190 // structures.
David Blaikie751c5582011-09-22 02:58:26 +000013191 if (i + 1 != Fields.end())
Douglas Gregor3e06dbf2009-03-06 23:41:27 +000013192 Diag(FD->getLocation(), diag::ext_variable_sized_type_in_struct)
Chris Lattnerb28fe9e2009-04-25 18:52:45 +000013193 << FD->getDeclName() << FD->getType();
Douglas Gregor3e06dbf2009-03-06 23:41:27 +000013194 else {
13195 // We support flexible arrays at the end of structs in
13196 // other structs as an extension.
13197 Diag(FD->getLocation(), diag::ext_flexible_array_in_struct)
13198 << FD->getDeclName();
Chris Lattner720a0542007-01-25 00:44:24 +000013199 }
Chris Lattner720a0542007-01-25 00:44:24 +000013200 }
13201 }
Fariborz Jahanian78f565b2012-08-16 22:38:41 +000013202 if (isa<ObjCContainerDecl>(EnclosingDecl) &&
13203 RequireNonAbstractType(FD->getLocation(), FD->getType(),
13204 diag::err_abstract_type_in_decl,
13205 AbstractIvarType)) {
13206 // Ivars can not have abstract class types
13207 FD->setInvalidDecl();
13208 }
Fariborz Jahanian5f21d2f2009-07-08 01:18:33 +000013209 if (Record && FDTTy->getDecl()->hasObjectMember())
13210 Record->setHasObjectMember(true);
Fariborz Jahanian78652202013-01-25 23:57:05 +000013211 if (Record && FDTTy->getDecl()->hasVolatileMember())
13212 Record->setHasVolatileMember(true);
John McCall8b07ec22010-05-15 11:32:37 +000013213 } else if (FDTy->isObjCObjectType()) {
Douglas Gregorac1fb652009-03-24 19:52:54 +000013214 /// A field cannot be an Objective-c object
Fariborz Jahanian6507135e2011-07-26 17:58:54 +000013215 Diag(FD->getLocation(), diag::err_statically_allocated_object)
13216 << FixItHint::CreateInsertion(FD->getLocation(), "*");
13217 QualType T = Context.getObjCObjectPointerType(FD->getType());
13218 FD->setType(T);
Douglas Gregore6c3fa02013-01-28 19:08:09 +000013219 } else if (getLangOpts().ObjCAutoRefCount && Record && !ARCErrReported &&
13220 (!getLangOpts().CPlusPlus || Record->isUnion())) {
13221 // It's an error in ARC if a field has lifetime.
13222 // We don't want to report this in a system header, though,
13223 // so we just make the field unavailable.
13224 // FIXME: that's really not sufficient; we need to make the type
13225 // itself invalid to, say, initialize or copy.
13226 QualType T = FD->getType();
13227 Qualifiers::ObjCLifetime lifetime = T.getObjCLifetime();
13228 if (lifetime && lifetime != Qualifiers::OCL_ExplicitNone) {
13229 SourceLocation loc = FD->getLocation();
13230 if (getSourceManager().isInSystemHeader(loc)) {
13231 if (!FD->hasAttr<UnavailableAttr>()) {
Aaron Ballman36a53502014-01-16 13:03:14 +000013232 FD->addAttr(UnavailableAttr::CreateImplicit(Context,
13233 "this system field has retaining ownership",
13234 loc));
John McCall31168b02011-06-15 23:02:42 +000013235 }
Douglas Gregore6c3fa02013-01-28 19:08:09 +000013236 } else {
13237 Diag(FD->getLocation(), diag::err_arc_objc_object_in_tag)
Douglas Gregor0ad84b42013-01-28 20:13:44 +000013238 << T->isBlockPointerType() << Record->getTagKind();
John McCall31168b02011-06-15 23:02:42 +000013239 }
Douglas Gregore6c3fa02013-01-28 19:08:09 +000013240 ARCErrReported = true;
John McCall31168b02011-06-15 23:02:42 +000013241 }
Douglas Gregore6c3fa02013-01-28 19:08:09 +000013242 } else if (getLangOpts().ObjC1 &&
David Blaikiebbafb8a2012-03-11 07:00:24 +000013243 getLangOpts().getGC() != LangOptions::NonGC &&
John McCall31168b02011-06-15 23:02:42 +000013244 Record && !Record->hasObjectMember()) {
Douglas Gregore6c3fa02013-01-28 19:08:09 +000013245 if (FD->getType()->isObjCObjectPointerType() ||
13246 FD->getType().isObjCGCStrong())
13247 Record->setHasObjectMember(true);
13248 else if (Context.getAsArrayType(FD->getType())) {
13249 QualType BaseType = Context.getBaseElementType(FD->getType());
13250 if (BaseType->isRecordType() &&
13251 BaseType->getAs<RecordType>()->getDecl()->hasObjectMember())
John McCall31168b02011-06-15 23:02:42 +000013252 Record->setHasObjectMember(true);
Douglas Gregore6c3fa02013-01-28 19:08:09 +000013253 else if (BaseType->isObjCObjectPointerType() ||
13254 BaseType.isObjCGCStrong())
13255 Record->setHasObjectMember(true);
John McCall31168b02011-06-15 23:02:42 +000013256 }
Fariborz Jahanian021510e2010-06-15 22:44:06 +000013257 }
Fariborz Jahanian78652202013-01-25 23:57:05 +000013258 if (Record && FD->getType().isVolatileQualified())
13259 Record->setHasVolatileMember(true);
Chris Lattner82625602007-01-24 02:26:21 +000013260 // Keep track of the number of named members.
Douglas Gregor82ac25e2009-01-08 20:45:30 +000013261 if (FD->getIdentifier())
Chris Lattner82625602007-01-24 02:26:21 +000013262 ++NumNamedMembers;
Chris Lattnerbdf8b8d2007-01-24 02:11:17 +000013263 }
Sebastian Redlbaad4e72009-01-05 20:52:13 +000013264
Chris Lattner82625602007-01-24 02:26:21 +000013265 // Okay, we successfully defined 'Record'.
Chris Lattner622c1932008-02-06 00:51:33 +000013266 if (Record) {
Douglas Gregor8fb95122010-09-29 00:15:42 +000013267 bool Completed = false;
13268 if (CXXRecordDecl *CXXRecord = dyn_cast<CXXRecordDecl>(Record)) {
13269 if (!CXXRecord->isInvalidDecl()) {
13270 // Set access bits correctly on the directly-declared conversions.
Argyrios Kyrtzidisa6567c42012-11-28 03:56:09 +000013271 for (CXXRecordDecl::conversion_iterator
13272 I = CXXRecord->conversion_begin(),
13273 E = CXXRecord->conversion_end(); I != E; ++I)
13274 I.setAccess((*I)->getAccess());
Douglas Gregor8fb95122010-09-29 00:15:42 +000013275
13276 if (!CXXRecord->isDependentType()) {
Peter Collingbourneb289fe62013-05-20 14:12:25 +000013277 if (CXXRecord->hasUserDeclaredDestructor()) {
13278 // Adjust user-defined destructor exception spec.
13279 if (getLangOpts().CPlusPlus11)
13280 AdjustDestructorExceptionSpec(CXXRecord,
13281 CXXRecord->getDestructor());
Peter Collingbourneb289fe62013-05-20 14:12:25 +000013282 }
Sebastian Redl623ea822011-05-19 05:13:44 +000013283
Douglas Gregor8fb95122010-09-29 00:15:42 +000013284 // Add any implicitly-declared members to this class.
13285 AddImplicitlyDeclaredMembersToClass(CXXRecord);
13286
13287 // If we have virtual base classes, we may end up finding multiple
13288 // final overriders for a given virtual function. Check for this
13289 // problem now.
13290 if (CXXRecord->getNumVBases()) {
13291 CXXFinalOverriderMap FinalOverriders;
13292 CXXRecord->getFinalOverriders(FinalOverriders);
13293
13294 for (CXXFinalOverriderMap::iterator M = FinalOverriders.begin(),
13295 MEnd = FinalOverriders.end();
13296 M != MEnd; ++M) {
13297 for (OverridingMethods::iterator SO = M->second.begin(),
13298 SOEnd = M->second.end();
13299 SO != SOEnd; ++SO) {
13300 assert(SO->second.size() > 0 &&
13301 "Virtual function without overridding functions?");
13302 if (SO->second.size() == 1)
13303 continue;
13304
13305 // C++ [class.virtual]p2:
13306 // In a derived class, if a virtual member function of a base
13307 // class subobject has more than one final overrider the
13308 // program is ill-formed.
13309 Diag(Record->getLocation(), diag::err_multiple_final_overriders)
Roman Divackye6377112012-09-06 15:59:27 +000013310 << (const NamedDecl *)M->first << Record;
Douglas Gregor8fb95122010-09-29 00:15:42 +000013311 Diag(M->first->getLocation(),
13312 diag::note_overridden_virtual_function);
13313 for (OverridingMethods::overriding_iterator
13314 OM = SO->second.begin(),
13315 OMEnd = SO->second.end();
13316 OM != OMEnd; ++OM)
13317 Diag(OM->Method->getLocation(), diag::note_final_overrider)
Roman Divackye6377112012-09-06 15:59:27 +000013318 << (const NamedDecl *)M->first << OM->Method->getParent();
Douglas Gregor8fb95122010-09-29 00:15:42 +000013319
13320 Record->setInvalidDecl();
13321 }
13322 }
13323 CXXRecord->completeDefinition(&FinalOverriders);
13324 Completed = true;
13325 }
13326 }
13327 }
13328 }
13329
13330 if (!Completed)
13331 Record->completeDefinition();
Sebastian Redl623ea822011-05-19 05:13:44 +000013332
David Majnemer2c4e00a2014-01-29 22:07:36 +000013333 if (Record->hasAttrs()) {
Richard Smith848e1f12013-02-01 08:12:08 +000013334 CheckAlignasUnderalignment(Record);
Serge Pavlov89578fd2013-06-08 13:29:58 +000013335
David Majnemer98c9ee22014-02-07 00:43:07 +000013336 if (const MSInheritanceAttr *IA = Record->getAttr<MSInheritanceAttr>())
David Majnemer2c4e00a2014-01-29 22:07:36 +000013337 checkMSInheritanceAttrOnDefinition(cast<CXXRecordDecl>(Record),
David Majnemer4bb09802014-02-10 19:50:15 +000013338 IA->getRange(), IA->getBestCase(),
David Majnemer2c4e00a2014-01-29 22:07:36 +000013339 IA->getSemanticSpelling());
13340 }
13341
Serge Pavlov3cb80222013-11-14 02:13:03 +000013342 // Check if the structure/union declaration is a type that can have zero
13343 // size in C. For C this is a language extension, for C++ it may cause
13344 // compatibility problems.
13345 bool CheckForZeroSize;
Serge Pavlov89578fd2013-06-08 13:29:58 +000013346 if (!getLangOpts().CPlusPlus) {
Serge Pavlov3cb80222013-11-14 02:13:03 +000013347 CheckForZeroSize = true;
13348 } else {
13349 // For C++ filter out types that cannot be referenced in C code.
13350 CXXRecordDecl *CXXRecord = cast<CXXRecordDecl>(Record);
13351 CheckForZeroSize =
13352 CXXRecord->getLexicalDeclContext()->isExternCContext() &&
13353 !CXXRecord->isDependentType() &&
13354 CXXRecord->isCLike();
13355 }
13356 if (CheckForZeroSize) {
Serge Pavlov89578fd2013-06-08 13:29:58 +000013357 bool ZeroSize = true;
Serge Pavlovf7c1a212013-06-17 17:18:51 +000013358 bool IsEmpty = true;
13359 unsigned NonBitFields = 0;
Serge Pavlov89578fd2013-06-08 13:29:58 +000013360 for (RecordDecl::field_iterator I = Record->field_begin(),
Serge Pavlovf7c1a212013-06-17 17:18:51 +000013361 E = Record->field_end();
13362 (NonBitFields == 0 || ZeroSize) && I != E; ++I) {
13363 IsEmpty = false;
Serge Pavlov89578fd2013-06-08 13:29:58 +000013364 if (I->isUnnamedBitfield()) {
Serge Pavlov89578fd2013-06-08 13:29:58 +000013365 if (I->getBitWidthValue(Context) > 0)
13366 ZeroSize = false;
13367 } else {
Serge Pavlovf7c1a212013-06-17 17:18:51 +000013368 ++NonBitFields;
13369 QualType FieldType = I->getType();
13370 if (FieldType->isIncompleteType() ||
13371 !Context.getTypeSizeInChars(FieldType).isZero())
13372 ZeroSize = false;
Serge Pavlov89578fd2013-06-08 13:29:58 +000013373 }
13374 }
13375
Serge Pavlov3cb80222013-11-14 02:13:03 +000013376 // Empty structs are an extension in C (C99 6.7.2.1p7). They are
13377 // allowed in C++, but warn if its declaration is inside
13378 // extern "C" block.
13379 if (ZeroSize) {
13380 Diag(RecLoc, getLangOpts().CPlusPlus ?
13381 diag::warn_zero_size_struct_union_in_extern_c :
13382 diag::warn_zero_size_struct_union_compat)
13383 << IsEmpty << Record->isUnion() << (NonBitFields > 1);
13384 }
Serge Pavlov89578fd2013-06-08 13:29:58 +000013385
Serge Pavlov3cb80222013-11-14 02:13:03 +000013386 // Structs without named members are extension in C (C99 6.7.2.1p7),
13387 // but are accepted by GCC.
13388 if (NonBitFields == 0 && !getLangOpts().CPlusPlus) {
13389 Diag(RecLoc, IsEmpty ? diag::ext_empty_struct_union :
13390 diag::ext_no_named_members_in_struct_union)
13391 << Record->isUnion();
Serge Pavlov89578fd2013-06-08 13:29:58 +000013392 }
13393 }
Chris Lattner622c1932008-02-06 00:51:33 +000013394 } else {
Jay Foad7d0479f2009-05-21 09:52:38 +000013395 ObjCIvarDecl **ClsFields =
13396 reinterpret_cast<ObjCIvarDecl**>(RecFields.data());
Fariborz Jahanian02225532008-12-13 20:28:25 +000013397 if (ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(EnclosingDecl)) {
Douglas Gregor16408322011-12-15 22:34:59 +000013398 ID->setEndOfDefinitionLoc(RBrac);
Fariborz Jahanian68453832009-06-05 18:16:35 +000013399 // Add ivar's to class's DeclContext.
13400 for (unsigned i = 0, e = RecFields.size(); i != e; ++i) {
13401 ClsFields[i]->setLexicalDeclContext(ID);
Argyrios Kyrtzidiscfbfe782009-06-30 02:36:12 +000013402 ID->addDecl(ClsFields[i]);
Fariborz Jahanian68453832009-06-05 18:16:35 +000013403 }
Fariborz Jahaniana599c132008-12-16 01:08:35 +000013404 // Must enforce the rule that ivars in the base classes may not be
13405 // duplicates.
Fariborz Jahanian545643c2010-02-23 23:41:11 +000013406 if (ID->getSuperClass())
13407 DiagnoseDuplicateIvars(ID, ID->getSuperClass());
Mike Stump11289f42009-09-09 15:08:12 +000013408 } else if (ObjCImplementationDecl *IMPDecl =
Chris Lattnerd13b8b52009-02-23 22:00:08 +000013409 dyn_cast<ObjCImplementationDecl>(EnclosingDecl)) {
Ted Kremenek1b0ea822008-01-07 19:49:32 +000013410 assert(IMPDecl && "ActOnFields - missing ObjCImplementationDecl");
Fariborz Jahanian68453832009-06-05 18:16:35 +000013411 for (unsigned I = 0, N = RecFields.size(); I != N; ++I)
13412 // Ivar declared in @implementation never belongs to the implementation.
13413 // Only it is in implementation's lexical context.
Douglas Gregor5f662052009-04-23 03:23:08 +000013414 ClsFields[I]->setLexicalDeclContext(IMPDecl);
Fariborz Jahanian95b60762007-10-31 18:48:14 +000013415 CheckImplementationIvars(IMPDecl, ClsFields, RecFields.size(), RBrac);
Fariborz Jahaniana7765fe2012-02-20 20:09:20 +000013416 IMPDecl->setIvarLBraceLoc(LBrac);
13417 IMPDecl->setIvarRBraceLoc(RBrac);
Fariborz Jahanian4c172c62010-02-22 23:04:20 +000013418 } else if (ObjCCategoryDecl *CDecl =
13419 dyn_cast<ObjCCategoryDecl>(EnclosingDecl)) {
Fariborz Jahanian6a0a2e02010-04-06 22:43:48 +000013420 // case of ivars in class extension; all other cases have been
13421 // reported as errors elsewhere.
13422 // FIXME. Class extension does not have a LocEnd field.
13423 // CDecl->setLocEnd(RBrac);
13424 // Add ivar's to class extension's DeclContext.
Fariborz Jahanian25127472011-10-21 18:03:52 +000013425 // Diagnose redeclaration of private ivars.
13426 ObjCInterfaceDecl *IDecl = CDecl->getClassInterface();
Fariborz Jahanian6a0a2e02010-04-06 22:43:48 +000013427 for (unsigned i = 0, e = RecFields.size(); i != e; ++i) {
Fariborz Jahanian25127472011-10-21 18:03:52 +000013428 if (IDecl) {
13429 if (const ObjCIvarDecl *ClsIvar =
13430 IDecl->getIvarDecl(ClsFields[i]->getIdentifier())) {
13431 Diag(ClsFields[i]->getLocation(),
13432 diag::err_duplicate_ivar_declaration);
13433 Diag(ClsIvar->getLocation(), diag::note_previous_definition);
13434 continue;
13435 }
Aaron Ballmanb4a53452014-03-13 21:57:01 +000013436 for (const auto *Ext : IDecl->known_extensions()) {
Douglas Gregor048fbfa2013-01-16 23:00:23 +000013437 if (const ObjCIvarDecl *ClsExtIvar
13438 = Ext->getIvarDecl(ClsFields[i]->getIdentifier())) {
Fariborz Jahanian25127472011-10-21 18:03:52 +000013439 Diag(ClsFields[i]->getLocation(),
13440 diag::err_duplicate_ivar_declaration);
13441 Diag(ClsExtIvar->getLocation(), diag::note_previous_definition);
13442 continue;
13443 }
13444 }
13445 }
Fariborz Jahanian6a0a2e02010-04-06 22:43:48 +000013446 ClsFields[i]->setLexicalDeclContext(CDecl);
13447 CDecl->addDecl(ClsFields[i]);
Fariborz Jahanian4c172c62010-02-22 23:04:20 +000013448 }
Fariborz Jahaniana7765fe2012-02-20 20:09:20 +000013449 CDecl->setIvarLBraceLoc(LBrac);
13450 CDecl->setIvarRBraceLoc(RBrac);
Fariborz Jahanian2a4dd312007-09-26 18:27:25 +000013451 }
Fariborz Jahanianf3287bf2007-09-14 21:08:27 +000013452 }
Daniel Dunbar325601a2008-10-03 17:33:35 +000013453
13454 if (Attr)
Douglas Gregor758a8692009-06-17 21:51:59 +000013455 ProcessDeclAttributeList(S, Record, Attr);
Chris Lattner1300fb92007-01-23 23:42:53 +000013456}
13457
Douglas Gregor6791a0d2010-02-01 23:36:03 +000013458/// \brief Determine whether the given integral value is representable within
13459/// the given type T.
13460static bool isRepresentableIntegerValue(ASTContext &Context,
13461 llvm::APSInt &Value,
13462 QualType T) {
Douglas Gregor6972a622010-06-16 00:35:25 +000013463 assert(T->isIntegralType(Context) && "Integral type required!");
Douglas Gregorc1cf8142010-04-15 15:53:31 +000013464 unsigned BitWidth = Context.getIntWidth(T);
Douglas Gregor6791a0d2010-02-01 23:36:03 +000013465
Douglas Gregor0bf31402010-10-08 23:50:27 +000013466 if (Value.isUnsigned() || Value.isNonNegative()) {
Douglas Gregor6ab2fa82011-05-20 16:38:50 +000013467 if (T->isSignedIntegerOrEnumerationType())
Douglas Gregor0bf31402010-10-08 23:50:27 +000013468 --BitWidth;
13469 return Value.getActiveBits() <= BitWidth;
13470 }
Douglas Gregor6791a0d2010-02-01 23:36:03 +000013471 return Value.getMinSignedBits() <= BitWidth;
13472}
13473
13474// \brief Given an integral type, return the next larger integral type
13475// (or a NULL type of no such type exists).
13476static QualType getNextLargerIntegralType(ASTContext &Context, QualType T) {
13477 // FIXME: Int128/UInt128 support, which also needs to be introduced into
13478 // enum checking below.
Douglas Gregor6972a622010-06-16 00:35:25 +000013479 assert(T->isIntegralType(Context) && "Integral type required!");
Douglas Gregor6791a0d2010-02-01 23:36:03 +000013480 const unsigned NumTypes = 4;
13481 QualType SignedIntegralTypes[NumTypes] = {
13482 Context.ShortTy, Context.IntTy, Context.LongTy, Context.LongLongTy
13483 };
13484 QualType UnsignedIntegralTypes[NumTypes] = {
13485 Context.UnsignedShortTy, Context.UnsignedIntTy, Context.UnsignedLongTy,
13486 Context.UnsignedLongLongTy
13487 };
13488
13489 unsigned BitWidth = Context.getTypeSize(T);
Douglas Gregor6ab2fa82011-05-20 16:38:50 +000013490 QualType *Types = T->isSignedIntegerOrEnumerationType()? SignedIntegralTypes
13491 : UnsignedIntegralTypes;
Douglas Gregor6791a0d2010-02-01 23:36:03 +000013492 for (unsigned I = 0; I != NumTypes; ++I)
13493 if (Context.getTypeSize(Types[I]) > BitWidth)
13494 return Types[I];
13495
13496 return QualType();
13497}
13498
Douglas Gregor954f6b272009-03-17 19:05:46 +000013499EnumConstantDecl *Sema::CheckEnumConstant(EnumDecl *Enum,
13500 EnumConstantDecl *LastEnumConst,
13501 SourceLocation IdLoc,
13502 IdentifierInfo *Id,
John McCallb268a282010-08-23 23:25:46 +000013503 Expr *Val) {
Douglas Gregore8bbc122011-09-02 00:18:52 +000013504 unsigned IntWidth = Context.getTargetInfo().getIntWidth();
Douglas Gregor6791a0d2010-02-01 23:36:03 +000013505 llvm::APSInt EnumVal(IntWidth);
Douglas Gregor954f6b272009-03-17 19:05:46 +000013506 QualType EltTy;
Douglas Gregor2b988fd2010-12-16 00:24:44 +000013507
13508 if (Val && DiagnoseUnexpandedParameterPack(Val, UPPC_EnumeratorValue))
Craig Topperc3ec1492014-05-26 06:22:03 +000013509 Val = nullptr;
Douglas Gregor2b988fd2010-12-16 00:24:44 +000013510
Eli Friedman7c6515a2011-12-06 00:10:34 +000013511 if (Val)
Nikola Smiljanic01a75982014-05-29 10:55:11 +000013512 Val = DefaultLvalueConversion(Val).get();
Eli Friedman7c6515a2011-12-06 00:10:34 +000013513
Douglas Gregorb2186fe2009-11-06 00:03:12 +000013514 if (Val) {
Douglas Gregordc70c3a2010-03-02 17:53:14 +000013515 if (Enum->isDependentType() || Val->isTypeDependent())
Douglas Gregorb2186fe2009-11-06 00:03:12 +000013516 EltTy = Context.DependentTy;
13517 else {
Douglas Gregorb2186fe2009-11-06 00:03:12 +000013518 SourceLocation ExpLoc;
Richard Smith2bf7fdb2013-01-02 11:42:31 +000013519 if (getLangOpts().CPlusPlus11 && Enum->isFixed() &&
Alp Tokerbfa39342014-01-14 12:51:41 +000013520 !getLangOpts().MSVCCompat) {
Richard Smithf8379a02012-01-18 23:55:52 +000013521 // C++11 [dcl.enum]p5: If the underlying type is fixed, [...] the
13522 // constant-expression in the enumerator-definition shall be a converted
13523 // constant expression of the underlying type.
13524 EltTy = Enum->getIntegerType();
13525 ExprResult Converted =
13526 CheckConvertedConstantExpression(Val, EltTy, EnumVal,
13527 CCEK_Enumerator);
13528 if (Converted.isInvalid())
Craig Topperc3ec1492014-05-26 06:22:03 +000013529 Val = nullptr;
Richard Smithf8379a02012-01-18 23:55:52 +000013530 else
Nikola Smiljanic01a75982014-05-29 10:55:11 +000013531 Val = Converted.get();
Richard Smithf8379a02012-01-18 23:55:52 +000013532 } else if (!Val->isValueDependent() &&
Richard Smithf4c51d92012-02-04 09:53:13 +000013533 !(Val = VerifyIntegerConstantExpression(Val,
Nikola Smiljanic01a75982014-05-29 10:55:11 +000013534 &EnumVal).get())) {
Richard Smithf8379a02012-01-18 23:55:52 +000013535 // C99 6.7.2.2p2: Make sure we have an integer constant expression.
Richard Smithf8379a02012-01-18 23:55:52 +000013536 } else {
Douglas Gregor0bf31402010-10-08 23:50:27 +000013537 if (Enum->isFixed()) {
13538 EltTy = Enum->getIntegerType();
13539
Richard Smithf8379a02012-01-18 23:55:52 +000013540 // In Obj-C and Microsoft mode, require the enumeration value to be
13541 // representable in the underlying type of the enumeration. In C++11,
13542 // we perform a non-narrowing conversion as part of converted constant
13543 // expression checking.
Francois Picheta3108062010-10-18 15:01:13 +000013544 if (!isRepresentableIntegerValue(Context, EnumVal, EltTy)) {
Alp Tokerbfa39342014-01-14 12:51:41 +000013545 if (getLangOpts().MSVCCompat) {
Francois Picheta3108062010-10-18 15:01:13 +000013546 Diag(IdLoc, diag::ext_enumerator_too_large) << EltTy;
Nikola Smiljanic01a75982014-05-29 10:55:11 +000013547 Val = ImpCastExprToType(Val, EltTy, CK_IntegralCast).get();
Richard Smithf8379a02012-01-18 23:55:52 +000013548 } else
13549 Diag(IdLoc, diag::err_enumerator_too_large) << EltTy;
Francois Picheta3108062010-10-18 15:01:13 +000013550 } else
Nikola Smiljanic01a75982014-05-29 10:55:11 +000013551 Val = ImpCastExprToType(Val, EltTy, CK_IntegralCast).get();
David Blaikiebbafb8a2012-03-11 07:00:24 +000013552 } else if (getLangOpts().CPlusPlus) {
Richard Smithf8379a02012-01-18 23:55:52 +000013553 // C++11 [dcl.enum]p5:
Douglas Gregor0bf31402010-10-08 23:50:27 +000013554 // If the underlying type is not fixed, the type of each enumerator
13555 // is the type of its initializing value:
13556 // - If an initializer is specified for an enumerator, the
13557 // initializing value has the same type as the expression.
13558 EltTy = Val->getType();
Eli Friedman2beed112012-02-07 04:34:38 +000013559 } else {
13560 // C99 6.7.2.2p2:
13561 // The expression that defines the value of an enumeration constant
13562 // shall be an integer constant expression that has a value
13563 // representable as an int.
13564
13565 // Complain if the value is not representable in an int.
13566 if (!isRepresentableIntegerValue(Context, EnumVal, Context.IntTy))
13567 Diag(IdLoc, diag::ext_enum_value_not_int)
13568 << EnumVal.toString(10) << Val->getSourceRange()
13569 << (EnumVal.isUnsigned() || EnumVal.isNonNegative());
13570 else if (!Context.hasSameType(Val->getType(), Context.IntTy)) {
13571 // Force the type of the expression to 'int'.
Nikola Smiljanic01a75982014-05-29 10:55:11 +000013572 Val = ImpCastExprToType(Val, Context.IntTy, CK_IntegralCast).get();
Eli Friedman2beed112012-02-07 04:34:38 +000013573 }
13574 EltTy = Val->getType();
Douglas Gregor0bf31402010-10-08 23:50:27 +000013575 }
Douglas Gregorb2186fe2009-11-06 00:03:12 +000013576 }
Douglas Gregor954f6b272009-03-17 19:05:46 +000013577 }
13578 }
Mike Stump11289f42009-09-09 15:08:12 +000013579
Douglas Gregor954f6b272009-03-17 19:05:46 +000013580 if (!Val) {
Eli Friedmand0e60972009-12-11 01:34:50 +000013581 if (Enum->isDependentType())
13582 EltTy = Context.DependentTy;
Douglas Gregor6791a0d2010-02-01 23:36:03 +000013583 else if (!LastEnumConst) {
13584 // C++0x [dcl.enum]p5:
13585 // If the underlying type is not fixed, the type of each enumerator
13586 // is the type of its initializing value:
13587 // - If no initializer is specified for the first enumerator, the
13588 // initializing value has an unspecified integral type.
13589 //
13590 // GCC uses 'int' for its unspecified integral type, as does
13591 // C99 6.7.2.2p3.
Douglas Gregor0bf31402010-10-08 23:50:27 +000013592 if (Enum->isFixed()) {
13593 EltTy = Enum->getIntegerType();
13594 }
13595 else {
13596 EltTy = Context.IntTy;
13597 }
Douglas Gregor6791a0d2010-02-01 23:36:03 +000013598 } else {
Douglas Gregor954f6b272009-03-17 19:05:46 +000013599 // Assign the last value + 1.
13600 EnumVal = LastEnumConst->getInitVal();
13601 ++EnumVal;
Douglas Gregor6791a0d2010-02-01 23:36:03 +000013602 EltTy = LastEnumConst->getType();
Douglas Gregor954f6b272009-03-17 19:05:46 +000013603
13604 // Check for overflow on increment.
Douglas Gregor6791a0d2010-02-01 23:36:03 +000013605 if (EnumVal < LastEnumConst->getInitVal()) {
13606 // C++0x [dcl.enum]p5:
13607 // If the underlying type is not fixed, the type of each enumerator
13608 // is the type of its initializing value:
13609 //
13610 // - Otherwise the type of the initializing value is the same as
13611 // the type of the initializing value of the preceding enumerator
13612 // unless the incremented value is not representable in that type,
13613 // in which case the type is an unspecified integral type
13614 // sufficient to contain the incremented value. If no such type
13615 // exists, the program is ill-formed.
13616 QualType T = getNextLargerIntegralType(Context, EltTy);
Douglas Gregor0bf31402010-10-08 23:50:27 +000013617 if (T.isNull() || Enum->isFixed()) {
Douglas Gregor6791a0d2010-02-01 23:36:03 +000013618 // There is no integral type larger enough to represent this
13619 // value. Complain, then allow the value to wrap around.
13620 EnumVal = LastEnumConst->getInitVal();
Jay Foad6d4db0c2010-12-07 08:25:34 +000013621 EnumVal = EnumVal.zext(EnumVal.getBitWidth() * 2);
Douglas Gregor0bf31402010-10-08 23:50:27 +000013622 ++EnumVal;
13623 if (Enum->isFixed())
13624 // When the underlying type is fixed, this is ill-formed.
13625 Diag(IdLoc, diag::err_enumerator_wrapped)
13626 << EnumVal.toString(10)
13627 << EltTy;
13628 else
Richard Smithfaf156a2014-03-05 22:54:58 +000013629 Diag(IdLoc, diag::ext_enumerator_increment_too_large)
Douglas Gregor0bf31402010-10-08 23:50:27 +000013630 << EnumVal.toString(10);
Douglas Gregor6791a0d2010-02-01 23:36:03 +000013631 } else {
13632 EltTy = T;
13633 }
13634
13635 // Retrieve the last enumerator's value, extent that type to the
13636 // type that is supposed to be large enough to represent the incremented
13637 // value, then increment.
13638 EnumVal = LastEnumConst->getInitVal();
Douglas Gregor6ab2fa82011-05-20 16:38:50 +000013639 EnumVal.setIsSigned(EltTy->isSignedIntegerOrEnumerationType());
Jay Foad6d4db0c2010-12-07 08:25:34 +000013640 EnumVal = EnumVal.zextOrTrunc(Context.getIntWidth(EltTy));
Douglas Gregor6791a0d2010-02-01 23:36:03 +000013641 ++EnumVal;
13642
13643 // If we're not in C++, diagnose the overflow of enumerator values,
13644 // which in C99 means that the enumerator value is not representable in
13645 // an int (C99 6.7.2.2p2). However, we support GCC's extension that
13646 // permits enumerator values that are representable in some larger
13647 // integral type.
David Blaikiebbafb8a2012-03-11 07:00:24 +000013648 if (!getLangOpts().CPlusPlus && !T.isNull())
Douglas Gregor6791a0d2010-02-01 23:36:03 +000013649 Diag(IdLoc, diag::warn_enum_value_overflow);
David Blaikiebbafb8a2012-03-11 07:00:24 +000013650 } else if (!getLangOpts().CPlusPlus &&
Douglas Gregor6791a0d2010-02-01 23:36:03 +000013651 !isRepresentableIntegerValue(Context, EnumVal, EltTy)) {
13652 // Enforce C99 6.7.2.2p2 even when we compute the next value.
13653 Diag(IdLoc, diag::ext_enum_value_not_int)
13654 << EnumVal.toString(10) << 1;
13655 }
Douglas Gregor954f6b272009-03-17 19:05:46 +000013656 }
13657 }
Mike Stump11289f42009-09-09 15:08:12 +000013658
Douglas Gregordc70c3a2010-03-02 17:53:14 +000013659 if (!EltTy->isDependentType()) {
Douglas Gregor6791a0d2010-02-01 23:36:03 +000013660 // Make the enumerator value match the signedness and size of the
13661 // enumerator's type.
Eli Friedman2beed112012-02-07 04:34:38 +000013662 EnumVal = EnumVal.extOrTrunc(Context.getIntWidth(EltTy));
Douglas Gregor6ab2fa82011-05-20 16:38:50 +000013663 EnumVal.setIsSigned(EltTy->isSignedIntegerOrEnumerationType());
Douglas Gregor6791a0d2010-02-01 23:36:03 +000013664 }
Douglas Gregorb2186fe2009-11-06 00:03:12 +000013665
Douglas Gregor954f6b272009-03-17 19:05:46 +000013666 return EnumConstantDecl::Create(Context, Enum, IdLoc, Id, EltTy,
Mike Stump11289f42009-09-09 15:08:12 +000013667 Val, EnumVal);
Douglas Gregor954f6b272009-03-17 19:05:46 +000013668}
13669
Richard Smithd9ba2242015-05-07 03:54:19 +000013670Sema::SkipBodyInfo Sema::shouldSkipAnonEnumBody(Scope *S, IdentifierInfo *II,
13671 SourceLocation IILoc) {
Richard Smith00be6d02015-06-11 03:05:39 +000013672 if (!(getLangOpts().Modules || getLangOpts().ModulesLocalVisibility) ||
13673 !getLangOpts().CPlusPlus)
Richard Smithd9ba2242015-05-07 03:54:19 +000013674 return SkipBodyInfo();
13675
13676 // We have an anonymous enum definition. Look up the first enumerator to
13677 // determine if we should merge the definition with an existing one and
13678 // skip the body.
13679 NamedDecl *PrevDecl = LookupSingleName(S, II, IILoc, LookupOrdinaryName,
13680 ForRedeclaration);
13681 auto *PrevECD = dyn_cast_or_null<EnumConstantDecl>(PrevDecl);
13682 NamedDecl *Hidden;
13683 if (PrevECD &&
13684 !hasVisibleDefinition(cast<NamedDecl>(PrevECD->getDeclContext()),
13685 &Hidden)) {
13686 SkipBodyInfo Skip;
Richard Smithd9ba2242015-05-07 03:54:19 +000013687 Skip.Previous = Hidden;
13688 return Skip;
13689 }
13690
13691 return SkipBodyInfo();
13692}
Douglas Gregor954f6b272009-03-17 19:05:46 +000013693
John McCall811a0f52010-10-22 23:36:17 +000013694Decl *Sema::ActOnEnumConstant(Scope *S, Decl *theEnumDecl, Decl *lastEnumConst,
13695 SourceLocation IdLoc, IdentifierInfo *Id,
13696 AttributeList *Attr,
Richard Smithf8379a02012-01-18 23:55:52 +000013697 SourceLocation EqualLoc, Expr *Val) {
John McCall48871652010-08-21 09:40:31 +000013698 EnumDecl *TheEnumDecl = cast<EnumDecl>(theEnumDecl);
Chris Lattner4ef40012007-06-11 01:28:17 +000013699 EnumConstantDecl *LastEnumConst =
John McCall48871652010-08-21 09:40:31 +000013700 cast_or_null<EnumConstantDecl>(lastEnumConst);
Chris Lattner8116d1b2007-01-25 22:38:29 +000013701
Chris Lattner1a76a3c2007-08-26 06:24:45 +000013702 // The scope passed in may not be a decl scope. Zip up the scope tree until
13703 // we find one that is.
Douglas Gregor45a33ec2009-01-12 18:45:55 +000013704 S = getNonFieldDeclScope(S);
Mike Stump11289f42009-09-09 15:08:12 +000013705
Chris Lattner8116d1b2007-01-25 22:38:29 +000013706 // Verify that there isn't already something declared with this name in this
13707 // scope.
Douglas Gregorb2ccf012010-04-15 22:33:43 +000013708 NamedDecl *PrevDecl = LookupSingleName(S, Id, IdLoc, LookupOrdinaryName,
Douglas Gregor5204248f2010-01-19 06:06:57 +000013709 ForRedeclaration);
Douglas Gregor5daeee22008-12-08 18:40:42 +000013710 if (PrevDecl && PrevDecl->isTemplateParameter()) {
Douglas Gregor5101c242008-12-05 18:15:24 +000013711 // Maybe we will complain about the shadowed template parameter.
13712 DiagnoseTemplateParameterShadow(IdLoc, PrevDecl);
13713 // Just pretend that we didn't see the previous declaration.
Craig Topperc3ec1492014-05-26 06:22:03 +000013714 PrevDecl = nullptr;
Douglas Gregor5101c242008-12-05 18:15:24 +000013715 }
13716
13717 if (PrevDecl) {
Argyrios Kyrtzidisbd259982008-07-16 21:01:53 +000013718 // When in C++, we may get a TagDecl with the same name; in this case the
13719 // enum constant will 'hide' the tag.
David Blaikiebbafb8a2012-03-11 07:00:24 +000013720 assert((getLangOpts().CPlusPlus || !isa<TagDecl>(PrevDecl)) &&
Argyrios Kyrtzidisbd259982008-07-16 21:01:53 +000013721 "Received TagDecl when not in C++!");
Argyrios Kyrtzidis5b144d52008-09-09 21:18:04 +000013722 if (!isa<TagDecl>(PrevDecl) && isDeclInScope(PrevDecl, CurContext, S)) {
Chris Lattner8116d1b2007-01-25 22:38:29 +000013723 if (isa<EnumConstantDecl>(PrevDecl))
Chris Lattner4bd8dd82008-11-19 08:23:25 +000013724 Diag(IdLoc, diag::err_redefinition_of_enumerator) << Id;
Chris Lattner8116d1b2007-01-25 22:38:29 +000013725 else
Chris Lattner4bd8dd82008-11-19 08:23:25 +000013726 Diag(IdLoc, diag::err_redefinition) << Id;
Chris Lattner0369c572008-11-23 23:12:31 +000013727 Diag(PrevDecl->getLocation(), diag::note_previous_definition);
Craig Topperc3ec1492014-05-26 06:22:03 +000013728 return nullptr;
Chris Lattner8116d1b2007-01-25 22:38:29 +000013729 }
13730 }
Chris Lattner4ef40012007-06-11 01:28:17 +000013731
Aaron Ballman24a10472012-07-19 03:12:23 +000013732 // C++ [class.mem]p15:
13733 // If T is the name of a class, then each of the following shall have a name
13734 // different from T:
13735 // - every enumerator of every member of class T that is an unscoped
13736 // enumerated type
Richard Smith88fe69c2015-07-06 01:45:27 +000013737 if (!TheEnumDecl->isScoped())
13738 DiagnoseClassNameShadow(TheEnumDecl->getDeclContext(),
13739 DeclarationNameInfo(Id, IdLoc));
Douglas Gregor36c22a22010-10-15 13:21:21 +000013740
John McCall811a0f52010-10-22 23:36:17 +000013741 EnumConstantDecl *New =
13742 CheckEnumConstant(TheEnumDecl, LastEnumConst, IdLoc, Id, Val);
Chris Lattner0515e4b2007-08-27 21:16:18 +000013743
John McCall553c0792010-01-23 00:46:32 +000013744 if (New) {
John McCall811a0f52010-10-22 23:36:17 +000013745 // Process attributes.
13746 if (Attr) ProcessDeclAttributeList(S, New, Attr);
13747
13748 // Register this decl in the current scope stack.
John McCall553c0792010-01-23 00:46:32 +000013749 New->setAccess(TheEnumDecl->getAccess());
Douglas Gregor954f6b272009-03-17 19:05:46 +000013750 PushOnScopeChains(New, S);
John McCall553c0792010-01-23 00:46:32 +000013751 }
Douglas Gregor2f521192008-12-17 02:04:30 +000013752
Dmitri Gribenkof26054f2012-07-11 21:38:39 +000013753 ActOnDocumentableDecl(New);
13754
John McCall48871652010-08-21 09:40:31 +000013755 return New;
Chris Lattnerc1915e22007-01-25 07:29:02 +000013756}
13757
Ted Kremenek6cae9ec2012-12-22 01:34:09 +000013758// Returns true when the enum initial expression does not trigger the
13759// duplicate enum warning. A few common cases are exempted as follows:
13760// Element2 = Element1
13761// Element2 = Element1 + 1
13762// Element2 = Element1 - 1
13763// Where Element2 and Element1 are from the same enum.
13764static bool ValidDuplicateEnum(EnumConstantDecl *ECD, EnumDecl *Enum) {
13765 Expr *InitExpr = ECD->getInitExpr();
13766 if (!InitExpr)
13767 return true;
13768 InitExpr = InitExpr->IgnoreImpCasts();
13769
13770 if (BinaryOperator *BO = dyn_cast<BinaryOperator>(InitExpr)) {
13771 if (!BO->isAdditiveOp())
13772 return true;
13773 IntegerLiteral *IL = dyn_cast<IntegerLiteral>(BO->getRHS());
13774 if (!IL)
13775 return true;
13776 if (IL->getValue() != 1)
13777 return true;
13778
13779 InitExpr = BO->getLHS();
13780 }
13781
13782 // This checks if the elements are from the same enum.
13783 DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(InitExpr);
13784 if (!DRE)
13785 return true;
13786
13787 EnumConstantDecl *EnumConstant = dyn_cast<EnumConstantDecl>(DRE->getDecl());
13788 if (!EnumConstant)
13789 return true;
13790
13791 if (cast<EnumDecl>(TagDecl::castFromDeclContext(ECD->getDeclContext())) !=
13792 Enum)
13793 return true;
13794
13795 return false;
13796}
13797
13798struct DupKey {
13799 int64_t val;
13800 bool isTombstoneOrEmptyKey;
13801 DupKey(int64_t val, bool isTombstoneOrEmptyKey)
13802 : val(val), isTombstoneOrEmptyKey(isTombstoneOrEmptyKey) {}
13803};
13804
13805static DupKey GetDupKey(const llvm::APSInt& Val) {
13806 return DupKey(Val.isSigned() ? Val.getSExtValue() : Val.getZExtValue(),
13807 false);
13808}
13809
13810struct DenseMapInfoDupKey {
13811 static DupKey getEmptyKey() { return DupKey(0, true); }
13812 static DupKey getTombstoneKey() { return DupKey(1, true); }
13813 static unsigned getHashValue(const DupKey Key) {
13814 return (unsigned)(Key.val * 37);
13815 }
13816 static bool isEqual(const DupKey& LHS, const DupKey& RHS) {
13817 return LHS.isTombstoneOrEmptyKey == RHS.isTombstoneOrEmptyKey &&
13818 LHS.val == RHS.val;
13819 }
13820};
13821
13822// Emits a warning when an element is implicitly set a value that
13823// a previous element has already been set to.
Dmitri Gribenkoe5fde992013-04-27 20:23:52 +000013824static void CheckForDuplicateEnumValues(Sema &S, ArrayRef<Decl *> Elements,
13825 EnumDecl *Enum,
Ted Kremenek6cae9ec2012-12-22 01:34:09 +000013826 QualType EnumType) {
Alp Tokerd4a3f0e2014-06-15 23:30:39 +000013827 if (S.Diags.isIgnored(diag::warn_duplicate_enum_values, Enum->getLocation()))
Ted Kremenek6cae9ec2012-12-22 01:34:09 +000013828 return;
13829 // Avoid anonymous enums
13830 if (!Enum->getIdentifier())
13831 return;
13832
13833 // Only check for small enums.
13834 if (Enum->getNumPositiveBits() > 63 || Enum->getNumNegativeBits() > 64)
13835 return;
13836
Dmitri Gribenkof8579502013-01-12 19:30:44 +000013837 typedef SmallVector<EnumConstantDecl *, 3> ECDVector;
13838 typedef SmallVector<ECDVector *, 3> DuplicatesVector;
Ted Kremenek6cae9ec2012-12-22 01:34:09 +000013839
13840 typedef llvm::PointerUnion<EnumConstantDecl*, ECDVector*> DeclOrVector;
13841 typedef llvm::DenseMap<DupKey, DeclOrVector, DenseMapInfoDupKey>
13842 ValueToVectorMap;
13843
13844 DuplicatesVector DupVector;
13845 ValueToVectorMap EnumMap;
13846
13847 // Populate the EnumMap with all values represented by enum constants without
13848 // an initialier.
Dmitri Gribenkoe5fde992013-04-27 20:23:52 +000013849 for (unsigned i = 0, e = Elements.size(); i != e; ++i) {
Benjamin Kramer5c488ef2013-04-07 14:10:40 +000013850 EnumConstantDecl *ECD = cast_or_null<EnumConstantDecl>(Elements[i]);
Ted Kremenek6cae9ec2012-12-22 01:34:09 +000013851
13852 // Null EnumConstantDecl means a previous diagnostic has been emitted for
13853 // this constant. Skip this enum since it may be ill-formed.
13854 if (!ECD) {
13855 return;
13856 }
13857
13858 if (ECD->getInitExpr())
13859 continue;
13860
13861 DupKey Key = GetDupKey(ECD->getInitVal());
13862 DeclOrVector &Entry = EnumMap[Key];
13863
13864 // First time encountering this value.
13865 if (Entry.isNull())
13866 Entry = ECD;
13867 }
13868
13869 // Create vectors for any values that has duplicates.
Dmitri Gribenkoe5fde992013-04-27 20:23:52 +000013870 for (unsigned i = 0, e = Elements.size(); i != e; ++i) {
Ted Kremenek6cae9ec2012-12-22 01:34:09 +000013871 EnumConstantDecl *ECD = cast<EnumConstantDecl>(Elements[i]);
13872 if (!ValidDuplicateEnum(ECD, Enum))
13873 continue;
13874
13875 DupKey Key = GetDupKey(ECD->getInitVal());
13876
13877 DeclOrVector& Entry = EnumMap[Key];
13878 if (Entry.isNull())
13879 continue;
13880
13881 if (EnumConstantDecl *D = Entry.dyn_cast<EnumConstantDecl*>()) {
13882 // Ensure constants are different.
13883 if (D == ECD)
13884 continue;
13885
13886 // Create new vector and push values onto it.
13887 ECDVector *Vec = new ECDVector();
13888 Vec->push_back(D);
13889 Vec->push_back(ECD);
13890
13891 // Update entry to point to the duplicates vector.
13892 Entry = Vec;
13893
13894 // Store the vector somewhere we can consult later for quick emission of
13895 // diagnostics.
13896 DupVector.push_back(Vec);
13897 continue;
13898 }
13899
13900 ECDVector *Vec = Entry.get<ECDVector*>();
13901 // Make sure constants are not added more than once.
13902 if (*Vec->begin() == ECD)
13903 continue;
13904
13905 Vec->push_back(ECD);
13906 }
13907
13908 // Emit diagnostics.
13909 for (DuplicatesVector::iterator DupVectorIter = DupVector.begin(),
13910 DupVectorEnd = DupVector.end();
13911 DupVectorIter != DupVectorEnd; ++DupVectorIter) {
13912 ECDVector *Vec = *DupVectorIter;
13913 assert(Vec->size() > 1 && "ECDVector should have at least 2 elements.");
13914
13915 // Emit warning for one enum constant.
13916 ECDVector::iterator I = Vec->begin();
13917 S.Diag((*I)->getLocation(), diag::warn_duplicate_enum_values)
13918 << (*I)->getName() << (*I)->getInitVal().toString(10)
13919 << (*I)->getSourceRange();
13920 ++I;
13921
13922 // Emit one note for each of the remaining enum constants with
13923 // the same value.
13924 for (ECDVector::iterator E = Vec->end(); I != E; ++I)
13925 S.Diag((*I)->getLocation(), diag::note_duplicate_element)
13926 << (*I)->getName() << (*I)->getInitVal().toString(10)
13927 << (*I)->getSourceRange();
13928 delete Vec;
13929 }
13930}
13931
Alexis Hunt724f14e2014-11-28 00:53:20 +000013932bool
13933Sema::IsValueInFlagEnum(const EnumDecl *ED, const llvm::APInt &Val,
13934 bool AllowMask) const {
13935 FlagEnumAttr *FEAttr = ED->getAttr<FlagEnumAttr>();
13936 assert(FEAttr && "looking for value in non-flag enum");
13937
13938 llvm::APInt FlagMask = ~FEAttr->getFlagBits();
13939 unsigned Width = FlagMask.getBitWidth();
13940
13941 // We will try a zero-extended value for the regular check first.
13942 llvm::APInt ExtVal = Val.zextOrSelf(Width);
13943
13944 // A value is in a flag enum if either its bits are a subset of the enum's
13945 // flag bits (the first condition) or we are allowing masks and the same is
13946 // true of its complement (the second condition). When masks are allowed, we
13947 // allow the common idiom of ~(enum1 | enum2) to be a valid enum value.
13948 //
13949 // While it's true that any value could be used as a mask, the assumption is
13950 // that a mask will have all of the insignificant bits set. Anything else is
13951 // likely a logic error.
13952 if (!(FlagMask & ExtVal))
13953 return true;
13954
13955 if (AllowMask) {
13956 // Try a one-extended value instead. This can happen if the enum is wider
13957 // than the constant used, in C with extensions to allow for wider enums.
13958 // The mask will still have the correct behaviour, so we give the user the
13959 // benefit of the doubt.
13960 //
13961 // FIXME: This heuristic can cause weird results if the enum was extended
13962 // to a larger type and is signed, because then bit-masks of smaller types
13963 // that get extended will fall out of range (e.g. ~0x1u). We currently don't
13964 // detect that case and will get a false positive for it. In most cases,
13965 // though, it can be fixed by making it a signed type (e.g. ~0x1), so it may
13966 // be fine just to accept this as a warning.
13967 ExtVal |= llvm::APInt::getHighBitsSet(Width, Width - Val.getBitWidth());
13968 if (!(FlagMask & ~ExtVal))
13969 return true;
13970 }
13971
13972 return false;
13973}
13974
Mike Stump6814d1c2009-05-16 07:06:02 +000013975void Sema::ActOnEnumBody(SourceLocation EnumLoc, SourceLocation LBraceLoc,
John McCall48871652010-08-21 09:40:31 +000013976 SourceLocation RBraceLoc, Decl *EnumDeclX,
Dmitri Gribenkoe5fde992013-04-27 20:23:52 +000013977 ArrayRef<Decl *> Elements,
Edward O'Callaghanc69169d2009-08-08 14:36:57 +000013978 Scope *S, AttributeList *Attr) {
John McCall48871652010-08-21 09:40:31 +000013979 EnumDecl *Enum = cast<EnumDecl>(EnumDeclX);
Douglas Gregor07665a62009-01-05 19:45:36 +000013980 QualType EnumType = Context.getTypeDeclType(Enum);
Edward O'Callaghanc69169d2009-08-08 14:36:57 +000013981
13982 if (Attr)
13983 ProcessDeclAttributeList(S, Enum, Attr);
Mike Stump11289f42009-09-09 15:08:12 +000013984
Eli Friedmand0e60972009-12-11 01:34:50 +000013985 if (Enum->isDependentType()) {
Dmitri Gribenkoe5fde992013-04-27 20:23:52 +000013986 for (unsigned i = 0, e = Elements.size(); i != e; ++i) {
Eli Friedmand0e60972009-12-11 01:34:50 +000013987 EnumConstantDecl *ECD =
John McCall48871652010-08-21 09:40:31 +000013988 cast_or_null<EnumConstantDecl>(Elements[i]);
Eli Friedmand0e60972009-12-11 01:34:50 +000013989 if (!ECD) continue;
13990
13991 ECD->setType(EnumType);
13992 }
13993
John McCall9aa35be2010-05-06 08:49:23 +000013994 Enum->completeDefinition(Context.DependentTy, Context.DependentTy, 0, 0);
Eli Friedmand0e60972009-12-11 01:34:50 +000013995 return;
13996 }
13997
Chris Lattner67933c02007-08-28 05:10:31 +000013998 // TODO: If the result value doesn't fit in an int, it must be a long or long
13999 // long value. ISO C does not support this, but GCC does as an extension,
14000 // emit a warning.
Douglas Gregore8bbc122011-09-02 00:18:52 +000014001 unsigned IntWidth = Context.getTargetInfo().getIntWidth();
14002 unsigned CharWidth = Context.getTargetInfo().getCharWidth();
14003 unsigned ShortWidth = Context.getTargetInfo().getShortWidth();
Mike Stump11289f42009-09-09 15:08:12 +000014004
Chris Lattnerb8a501c2007-08-28 06:15:15 +000014005 // Verify that all the values are okay, compute the size of the values, and
14006 // reverse the list.
14007 unsigned NumNegativeBits = 0;
14008 unsigned NumPositiveBits = 0;
Mike Stump11289f42009-09-09 15:08:12 +000014009
Chris Lattnerb8a501c2007-08-28 06:15:15 +000014010 // Keep track of whether all elements have type int.
14011 bool AllElementsInt = true;
Mike Stump11289f42009-09-09 15:08:12 +000014012
Dmitri Gribenkoe5fde992013-04-27 20:23:52 +000014013 for (unsigned i = 0, e = Elements.size(); i != e; ++i) {
Chris Lattnerc1915e22007-01-25 07:29:02 +000014014 EnumConstantDecl *ECD =
John McCall48871652010-08-21 09:40:31 +000014015 cast_or_null<EnumConstantDecl>(Elements[i]);
Chris Lattnerc1915e22007-01-25 07:29:02 +000014016 if (!ECD) continue; // Already issued a diagnostic.
Mike Stump11289f42009-09-09 15:08:12 +000014017
Chris Lattnerbf478cb2007-08-28 05:27:00 +000014018 const llvm::APSInt &InitVal = ECD->getInitVal();
Mike Stump11289f42009-09-09 15:08:12 +000014019
Chris Lattnerb8a501c2007-08-28 06:15:15 +000014020 // Keep track of the size of positive and negative values.
Chris Lattner77683132008-02-26 00:33:57 +000014021 if (InitVal.isUnsigned() || InitVal.isNonNegative())
Chris Lattner49f980c2008-01-14 21:47:29 +000014022 NumPositiveBits = std::max(NumPositiveBits,
14023 (unsigned)InitVal.getActiveBits());
Chris Lattnerb8a501c2007-08-28 06:15:15 +000014024 else
Chris Lattner49f980c2008-01-14 21:47:29 +000014025 NumNegativeBits = std::max(NumNegativeBits,
14026 (unsigned)InitVal.getMinSignedBits());
Chris Lattner4ef40012007-06-11 01:28:17 +000014027
Chris Lattnerb8a501c2007-08-28 06:15:15 +000014028 // Keep track of whether every enum element has type int (very commmon).
14029 if (AllElementsInt)
Mike Stump11289f42009-09-09 15:08:12 +000014030 AllElementsInt = ECD->getType() == Context.IntTy;
Chris Lattnerc1915e22007-01-25 07:29:02 +000014031 }
Mike Stump11289f42009-09-09 15:08:12 +000014032
Chris Lattnerb8a501c2007-08-28 06:15:15 +000014033 // Figure out the type that should be used for this enum.
Chris Lattnerb8a501c2007-08-28 06:15:15 +000014034 QualType BestType;
Chris Lattner3a370bf2007-08-29 17:31:48 +000014035 unsigned BestWidth;
Edward O'Callaghanc69169d2009-08-08 14:36:57 +000014036
John McCall56774992009-12-09 09:09:27 +000014037 // C++0x N3000 [conv.prom]p3:
14038 // An rvalue of an unscoped enumeration type whose underlying
14039 // type is not fixed can be converted to an rvalue of the first
14040 // of the following types that can represent all the values of
14041 // the enumeration: int, unsigned int, long int, unsigned long
14042 // int, long long int, or unsigned long long int.
14043 // C99 6.4.4.3p2:
14044 // An identifier declared as an enumeration constant has type int.
14045 // The C99 rule is modified by a gcc extension
14046 QualType BestPromotionType;
14047
Aaron Ballman9ead1242013-12-19 02:39:40 +000014048 bool Packed = Enum->hasAttr<PackedAttr>();
Argyrios Kyrtzidis74825bc2010-10-08 00:25:19 +000014049 // -fshort-enums is the equivalent to specifying the packed attribute on all
14050 // enum definitions.
14051 if (LangOpts.ShortEnums)
14052 Packed = true;
Edward O'Callaghanc69169d2009-08-08 14:36:57 +000014053
Douglas Gregor0bf31402010-10-08 23:50:27 +000014054 if (Enum->isFixed()) {
Eli Friedman64d95042011-10-26 07:38:19 +000014055 BestType = Enum->getIntegerType();
14056 if (BestType->isPromotableIntegerType())
14057 BestPromotionType = Context.getPromotedIntegerType(BestType);
14058 else
14059 BestPromotionType = BestType;
Alexis Hunt724f14e2014-11-28 00:53:20 +000014060
14061 BestWidth = Context.getIntWidth(BestType);
Douglas Gregor0bf31402010-10-08 23:50:27 +000014062 }
14063 else if (NumNegativeBits) {
Mike Stump11289f42009-09-09 15:08:12 +000014064 // If there is a negative value, figure out the smallest integer type (of
Chris Lattnerb8a501c2007-08-28 06:15:15 +000014065 // int/long/longlong) that fits.
Edward O'Callaghanc69169d2009-08-08 14:36:57 +000014066 // If it's packed, check also if it fits a char or a short.
14067 if (Packed && NumNegativeBits <= CharWidth && NumPositiveBits < CharWidth) {
John McCall56774992009-12-09 09:09:27 +000014068 BestType = Context.SignedCharTy;
14069 BestWidth = CharWidth;
Mike Stump11289f42009-09-09 15:08:12 +000014070 } else if (Packed && NumNegativeBits <= ShortWidth &&
Edward O'Callaghanc69169d2009-08-08 14:36:57 +000014071 NumPositiveBits < ShortWidth) {
John McCall56774992009-12-09 09:09:27 +000014072 BestType = Context.ShortTy;
14073 BestWidth = ShortWidth;
14074 } else if (NumNegativeBits <= IntWidth && NumPositiveBits < IntWidth) {
Chris Lattnerb8a501c2007-08-28 06:15:15 +000014075 BestType = Context.IntTy;
Chris Lattner3a370bf2007-08-29 17:31:48 +000014076 BestWidth = IntWidth;
14077 } else {
Douglas Gregore8bbc122011-09-02 00:18:52 +000014078 BestWidth = Context.getTargetInfo().getLongWidth();
Mike Stump11289f42009-09-09 15:08:12 +000014079
John McCall56774992009-12-09 09:09:27 +000014080 if (NumNegativeBits <= BestWidth && NumPositiveBits < BestWidth) {
Chris Lattnerb8a501c2007-08-28 06:15:15 +000014081 BestType = Context.LongTy;
John McCall56774992009-12-09 09:09:27 +000014082 } else {
Douglas Gregore8bbc122011-09-02 00:18:52 +000014083 BestWidth = Context.getTargetInfo().getLongLongWidth();
Mike Stump11289f42009-09-09 15:08:12 +000014084
Chris Lattner3a370bf2007-08-29 17:31:48 +000014085 if (NumNegativeBits > BestWidth || NumPositiveBits >= BestWidth)
Richard Smithfaf156a2014-03-05 22:54:58 +000014086 Diag(Enum->getLocation(), diag::ext_enum_too_large);
Chris Lattnerb8a501c2007-08-28 06:15:15 +000014087 BestType = Context.LongLongTy;
14088 }
14089 }
John McCall56774992009-12-09 09:09:27 +000014090 BestPromotionType = (BestWidth <= IntWidth ? Context.IntTy : BestType);
Chris Lattnerb8a501c2007-08-28 06:15:15 +000014091 } else {
Douglas Gregora71cc152010-02-02 20:10:50 +000014092 // If there is no negative value, figure out the smallest type that fits
14093 // all of the enumerator values.
Edward O'Callaghanc69169d2009-08-08 14:36:57 +000014094 // If it's packed, check also if it fits a char or a short.
14095 if (Packed && NumPositiveBits <= CharWidth) {
John McCall56774992009-12-09 09:09:27 +000014096 BestType = Context.UnsignedCharTy;
14097 BestPromotionType = Context.IntTy;
14098 BestWidth = CharWidth;
Edward O'Callaghanc69169d2009-08-08 14:36:57 +000014099 } else if (Packed && NumPositiveBits <= ShortWidth) {
John McCall56774992009-12-09 09:09:27 +000014100 BestType = Context.UnsignedShortTy;
14101 BestPromotionType = Context.IntTy;
14102 BestWidth = ShortWidth;
14103 } else if (NumPositiveBits <= IntWidth) {
Chris Lattnerb8a501c2007-08-28 06:15:15 +000014104 BestType = Context.UnsignedIntTy;
Chris Lattner3a370bf2007-08-29 17:31:48 +000014105 BestWidth = IntWidth;
Douglas Gregora71cc152010-02-02 20:10:50 +000014106 BestPromotionType
David Blaikiebbafb8a2012-03-11 07:00:24 +000014107 = (NumPositiveBits == BestWidth || !getLangOpts().CPlusPlus)
Douglas Gregora71cc152010-02-02 20:10:50 +000014108 ? Context.UnsignedIntTy : Context.IntTy;
Chris Lattner3a370bf2007-08-29 17:31:48 +000014109 } else if (NumPositiveBits <=
Douglas Gregore8bbc122011-09-02 00:18:52 +000014110 (BestWidth = Context.getTargetInfo().getLongWidth())) {
Chris Lattnerb8a501c2007-08-28 06:15:15 +000014111 BestType = Context.UnsignedLongTy;
Douglas Gregora71cc152010-02-02 20:10:50 +000014112 BestPromotionType
David Blaikiebbafb8a2012-03-11 07:00:24 +000014113 = (NumPositiveBits == BestWidth || !getLangOpts().CPlusPlus)
Douglas Gregora71cc152010-02-02 20:10:50 +000014114 ? Context.UnsignedLongTy : Context.LongTy;
Chris Lattner37e05872008-03-05 18:54:05 +000014115 } else {
Douglas Gregore8bbc122011-09-02 00:18:52 +000014116 BestWidth = Context.getTargetInfo().getLongLongWidth();
Chris Lattner3a370bf2007-08-29 17:31:48 +000014117 assert(NumPositiveBits <= BestWidth &&
Chris Lattnerb8a501c2007-08-28 06:15:15 +000014118 "How could an initializer get larger than ULL?");
14119 BestType = Context.UnsignedLongLongTy;
Douglas Gregora71cc152010-02-02 20:10:50 +000014120 BestPromotionType
David Blaikiebbafb8a2012-03-11 07:00:24 +000014121 = (NumPositiveBits == BestWidth || !getLangOpts().CPlusPlus)
Douglas Gregora71cc152010-02-02 20:10:50 +000014122 ? Context.UnsignedLongLongTy : Context.LongLongTy;
Chris Lattnerb8a501c2007-08-28 06:15:15 +000014123 }
14124 }
Mike Stump11289f42009-09-09 15:08:12 +000014125
Alexis Hunt724f14e2014-11-28 00:53:20 +000014126 FlagEnumAttr *FEAttr = Enum->getAttr<FlagEnumAttr>();
14127 if (FEAttr)
14128 FEAttr->getFlagBits() = llvm::APInt(BestWidth, 0);
14129
Chris Lattner3a370bf2007-08-29 17:31:48 +000014130 // Loop over all of the enumerator constants, changing their types to match
Alexis Hunt724f14e2014-11-28 00:53:20 +000014131 // the type of the enum if needed. If we have a flag type, we also prepare the
14132 // FlagBits cache.
14133 for (auto *D : Elements) {
14134 auto *ECD = cast_or_null<EnumConstantDecl>(D);
Chris Lattner3a370bf2007-08-29 17:31:48 +000014135 if (!ECD) continue; // Already issued a diagnostic.
14136
14137 // Standard C says the enumerators have int type, but we allow, as an
14138 // extension, the enumerators to be larger than int size. If each
14139 // enumerator value fits in an int, type it as an int, otherwise type it the
14140 // same as the enumerator decl itself. This means that in "enum { X = 1U }"
14141 // that X has type 'int', not 'unsigned'.
Chris Lattner3a370bf2007-08-29 17:31:48 +000014142
14143 // Determine whether the value fits into an int.
14144 llvm::APSInt InitVal = ECD->getInitVal();
Chris Lattner3a370bf2007-08-29 17:31:48 +000014145
14146 // If it fits into an integer type, force it. Otherwise force it to match
14147 // the enum decl type.
14148 QualType NewTy;
14149 unsigned NewWidth;
14150 bool NewSign;
David Blaikiebbafb8a2012-03-11 07:00:24 +000014151 if (!getLangOpts().CPlusPlus &&
Fariborz Jahanian37c64172011-11-04 18:51:24 +000014152 !Enum->isFixed() &&
Douglas Gregor6791a0d2010-02-01 23:36:03 +000014153 isRepresentableIntegerValue(Context, InitVal, Context.IntTy)) {
Chris Lattner3a370bf2007-08-29 17:31:48 +000014154 NewTy = Context.IntTy;
14155 NewWidth = IntWidth;
14156 NewSign = true;
14157 } else if (ECD->getType() == BestType) {
14158 // Already the right type!
David Blaikiebbafb8a2012-03-11 07:00:24 +000014159 if (getLangOpts().CPlusPlus)
Douglas Gregor1d248c52008-12-12 02:00:36 +000014160 // C++ [dcl.enum]p4: Following the closing brace of an
14161 // enum-specifier, each enumerator has the type of its
Mike Stump11289f42009-09-09 15:08:12 +000014162 // enumeration.
Douglas Gregor1d248c52008-12-12 02:00:36 +000014163 ECD->setType(EnumType);
Alexis Hunt724f14e2014-11-28 00:53:20 +000014164 goto flagbits;
Chris Lattner3a370bf2007-08-29 17:31:48 +000014165 } else {
14166 NewTy = BestType;
14167 NewWidth = BestWidth;
Douglas Gregor6ab2fa82011-05-20 16:38:50 +000014168 NewSign = BestType->isSignedIntegerOrEnumerationType();
Chris Lattner3a370bf2007-08-29 17:31:48 +000014169 }
14170
14171 // Adjust the APSInt value.
Jay Foad6d4db0c2010-12-07 08:25:34 +000014172 InitVal = InitVal.extOrTrunc(NewWidth);
Chris Lattner3a370bf2007-08-29 17:31:48 +000014173 InitVal.setIsSigned(NewSign);
14174 ECD->setInitVal(InitVal);
Mike Stump11289f42009-09-09 15:08:12 +000014175
Chris Lattner3a370bf2007-08-29 17:31:48 +000014176 // Adjust the Expr initializer and type.
Abramo Bagnara77815432010-12-17 15:49:53 +000014177 if (ECD->getInitExpr() &&
Nick Lewycky0bdf13e2011-07-02 02:05:12 +000014178 !Context.hasSameType(NewTy, ECD->getInitExpr()->getType()))
John McCallcf142162010-08-07 06:22:56 +000014179 ECD->setInitExpr(ImplicitCastExpr::Create(Context, NewTy,
John McCalle3027922010-08-25 11:45:40 +000014180 CK_IntegralCast,
John McCallcf142162010-08-07 06:22:56 +000014181 ECD->getInitExpr(),
Craig Topperc3ec1492014-05-26 06:22:03 +000014182 /*base paths*/ nullptr,
John McCall2536c6d2010-08-25 10:28:54 +000014183 VK_RValue));
David Blaikiebbafb8a2012-03-11 07:00:24 +000014184 if (getLangOpts().CPlusPlus)
Douglas Gregor1d248c52008-12-12 02:00:36 +000014185 // C++ [dcl.enum]p4: Following the closing brace of an
14186 // enum-specifier, each enumerator has the type of its
Mike Stump11289f42009-09-09 15:08:12 +000014187 // enumeration.
Douglas Gregor1d248c52008-12-12 02:00:36 +000014188 ECD->setType(EnumType);
14189 else
14190 ECD->setType(NewTy);
Alexis Hunt724f14e2014-11-28 00:53:20 +000014191
14192flagbits:
14193 // Check to see if we have a constant with exactly one bit set. Note that x
14194 // & (x - 1) will be nonzero if and only if x has more than one bit set.
14195 if (FEAttr) {
14196 llvm::APInt ExtVal = InitVal.zextOrSelf(BestWidth);
14197 if (ExtVal != 0 && !(ExtVal & (ExtVal - 1))) {
14198 FEAttr->getFlagBits() |= ExtVal;
14199 }
14200 }
Chris Lattner3a370bf2007-08-29 17:31:48 +000014201 }
Mike Stump11289f42009-09-09 15:08:12 +000014202
Alexis Hunt724f14e2014-11-28 00:53:20 +000014203 if (FEAttr) {
14204 for (Decl *D : Elements) {
14205 EnumConstantDecl *ECD = cast_or_null<EnumConstantDecl>(D);
14206 if (!ECD) continue; // Already issued a diagnostic.
14207
14208 llvm::APSInt InitVal = ECD->getInitVal();
14209 if (InitVal != 0 && !IsValueInFlagEnum(Enum, InitVal, true))
14210 Diag(ECD->getLocation(), diag::warn_flag_enum_constant_out_of_range)
14211 << ECD << Enum;
14212 }
14213 }
14214
14215
14216
John McCall9aa35be2010-05-06 08:49:23 +000014217 Enum->completeDefinition(BestType, BestPromotionType,
14218 NumPositiveBits, NumNegativeBits);
James Molloy6f8780b2012-02-29 10:24:19 +000014219
Dmitri Gribenkoe5fde992013-04-27 20:23:52 +000014220 CheckForDuplicateEnumValues(*this, Elements, Enum, EnumType);
Richard Smith848e1f12013-02-01 08:12:08 +000014221
14222 // Now that the enum type is defined, ensure it's not been underaligned.
14223 if (Enum->hasAttrs())
14224 CheckAlignasUnderalignment(Enum);
Chris Lattnerc1915e22007-01-25 07:29:02 +000014225}
Chris Lattner1300fb92007-01-23 23:42:53 +000014226
Abramo Bagnara348823a2011-03-03 14:20:18 +000014227Decl *Sema::ActOnFileScopeAsmDecl(Expr *expr,
14228 SourceLocation StartLoc,
14229 SourceLocation EndLoc) {
John McCallb268a282010-08-23 23:25:46 +000014230 StringLiteral *AsmString = cast<StringLiteral>(expr);
Sebastian Redlc675bab2008-12-13 16:23:55 +000014231
Douglas Gregor278f52e2009-05-30 00:08:05 +000014232 FileScopeAsmDecl *New = FileScopeAsmDecl::Create(Context, CurContext,
Abramo Bagnara348823a2011-03-03 14:20:18 +000014233 AsmString, StartLoc,
14234 EndLoc);
Argyrios Kyrtzidiscfbfe782009-06-30 02:36:12 +000014235 CurContext->addDecl(New);
John McCall48871652010-08-21 09:40:31 +000014236 return New;
Anders Carlsson5c6c0592008-02-08 00:33:21 +000014237}
Eli Friedman5ed51982009-06-05 02:44:36 +000014238
Richard Smith77944862014-03-02 05:58:18 +000014239static void checkModuleImportContext(Sema &S, Module *M,
14240 SourceLocation ImportLoc,
14241 DeclContext *DC) {
14242 if (auto *LSD = dyn_cast<LinkageSpecDecl>(DC)) {
14243 switch (LSD->getLanguage()) {
14244 case LinkageSpecDecl::lang_c:
14245 if (!M->IsExternC) {
14246 S.Diag(ImportLoc, diag::err_module_import_in_extern_c)
14247 << M->getFullModuleName();
14248 S.Diag(LSD->getLocStart(), diag::note_module_import_in_extern_c);
14249 return;
14250 }
14251 break;
14252 case LinkageSpecDecl::lang_cxx:
14253 break;
14254 }
14255 DC = LSD->getParent();
14256 }
14257
14258 while (isa<LinkageSpecDecl>(DC))
14259 DC = DC->getParent();
14260 if (!isa<TranslationUnitDecl>(DC)) {
14261 S.Diag(ImportLoc, diag::err_module_import_not_at_top_level)
14262 << M->getFullModuleName() << DC;
14263 S.Diag(cast<Decl>(DC)->getLocStart(),
14264 diag::note_module_import_not_at_top_level)
14265 << DC;
14266 }
14267}
14268
Douglas Gregor22d09742012-01-03 18:04:46 +000014269DeclResult Sema::ActOnModuleImport(SourceLocation AtLoc,
14270 SourceLocation ImportLoc,
14271 ModuleIdPath Path) {
Alp Tokerb6cc5922014-05-03 03:45:55 +000014272 Module *Mod =
14273 getModuleLoader().loadModule(ImportLoc, Path, Module::AllVisible,
14274 /*IsIncludeDirective=*/false);
Douglas Gregorde3ef502011-11-30 23:21:26 +000014275 if (!Mod)
Douglas Gregor08142532011-08-26 23:56:07 +000014276 return true;
Richard Smith77944862014-03-02 05:58:18 +000014277
Richard Smith42413142015-05-15 20:05:43 +000014278 VisibleModules.setVisible(Mod, ImportLoc);
14279
Richard Smith77944862014-03-02 05:58:18 +000014280 checkModuleImportContext(*this, Mod, ImportLoc, CurContext);
14281
Ben Langmuir527040e2014-05-05 05:31:33 +000014282 // FIXME: we should support importing a submodule within a different submodule
14283 // of the same top-level module. Until we do, make it an error rather than
14284 // silently ignoring the import.
14285 if (Mod->getTopLevelModuleName() == getLangOpts().CurrentModule)
14286 Diag(ImportLoc, diag::err_module_self_import)
14287 << Mod->getFullModuleName() << getLangOpts().CurrentModule;
Ben Langmuirb537a3a2014-07-23 15:30:23 +000014288 else if (Mod->getTopLevelModuleName() == getLangOpts().ImplementationOfModule)
14289 Diag(ImportLoc, diag::err_module_import_in_implementation)
14290 << Mod->getFullModuleName() << getLangOpts().ImplementationOfModule;
Ben Langmuir527040e2014-05-05 05:31:33 +000014291
Dmitri Gribenkof8579502013-01-12 19:30:44 +000014292 SmallVector<SourceLocation, 2> IdentifierLocs;
Douglas Gregorba345522011-12-02 23:23:56 +000014293 Module *ModCheck = Mod;
14294 for (unsigned I = 0, N = Path.size(); I != N; ++I) {
14295 // If we've run out of module parents, just drop the remaining identifiers.
14296 // We need the length to be consistent.
14297 if (!ModCheck)
14298 break;
14299 ModCheck = ModCheck->Parent;
14300
14301 IdentifierLocs.push_back(Path[I].second);
14302 }
14303
14304 ImportDecl *Import = ImportDecl::Create(Context,
14305 Context.getTranslationUnitDecl(),
Douglas Gregor22d09742012-01-03 18:04:46 +000014306 AtLoc.isValid()? AtLoc : ImportLoc,
14307 Mod, IdentifierLocs);
Douglas Gregorba345522011-12-02 23:23:56 +000014308 Context.getTranslationUnitDecl()->addDecl(Import);
14309 return Import;
Douglas Gregor08142532011-08-26 23:56:07 +000014310}
14311
Richard Smithce587f52013-11-15 04:24:58 +000014312void Sema::ActOnModuleInclude(SourceLocation DirectiveLoc, Module *Mod) {
Richard Smith77944862014-03-02 05:58:18 +000014313 checkModuleImportContext(*this, Mod, DirectiveLoc, CurContext);
14314
Richard Smithbca31b72015-05-18 05:35:52 +000014315 // Determine whether we're in the #include buffer for a module. The #includes
14316 // in that buffer do not qualify as module imports; they're just an
14317 // implementation detail of us building the module.
14318 //
14319 // FIXME: Should we even get ActOnModuleInclude calls for those?
14320 bool IsInModuleIncludes =
14321 TUKind == TU_Module &&
14322 getSourceManager().isWrittenInMainFile(DirectiveLoc);
14323
14324 // If this module import was due to an inclusion directive, create an
14325 // implicit import declaration to capture it in the AST.
14326 if (!IsInModuleIncludes) {
14327 TranslationUnitDecl *TU = getASTContext().getTranslationUnitDecl();
14328 ImportDecl *ImportD = ImportDecl::CreateImplicit(getASTContext(), TU,
14329 DirectiveLoc, Mod,
14330 DirectiveLoc);
14331 TU->addDecl(ImportD);
14332 Consumer.HandleImplicitImportDecl(ImportD);
14333 }
14334
Richard Smitha7e2cc62015-05-01 01:53:09 +000014335 getModuleLoader().makeModuleVisible(Mod, Module::AllVisible, DirectiveLoc);
Richard Smith42413142015-05-15 20:05:43 +000014336 VisibleModules.setVisible(Mod, DirectiveLoc);
14337}
14338
14339void Sema::ActOnModuleBegin(SourceLocation DirectiveLoc, Module *Mod) {
14340 checkModuleImportContext(*this, Mod, DirectiveLoc, CurContext);
14341
14342 if (getLangOpts().ModulesLocalVisibility)
14343 VisibleModulesStack.push_back(std::move(VisibleModules));
14344 VisibleModules.setVisible(Mod, DirectiveLoc);
14345}
14346
14347void Sema::ActOnModuleEnd(SourceLocation DirectiveLoc, Module *Mod) {
14348 checkModuleImportContext(*this, Mod, DirectiveLoc, CurContext);
14349
14350 if (getLangOpts().ModulesLocalVisibility) {
14351 VisibleModules = std::move(VisibleModulesStack.back());
14352 VisibleModulesStack.pop_back();
14353 VisibleModules.setVisible(Mod, DirectiveLoc);
14354 }
Richard Smithce587f52013-11-15 04:24:58 +000014355}
14356
Richard Smith3d23c422014-05-07 02:25:43 +000014357void Sema::createImplicitModuleImportForErrorRecovery(SourceLocation Loc,
14358 Module *Mod) {
14359 // Bail if we're not allowed to implicitly import a module here.
14360 if (isSFINAEContext() || !getLangOpts().ModulesErrorRecovery)
14361 return;
14362
Douglas Gregorc147b0b2013-01-12 01:29:50 +000014363 // Create the implicit import declaration.
14364 TranslationUnitDecl *TU = getASTContext().getTranslationUnitDecl();
14365 ImportDecl *ImportD = ImportDecl::CreateImplicit(getASTContext(), TU,
14366 Loc, Mod, Loc);
14367 TU->addDecl(ImportD);
14368 Consumer.HandleImplicitImportDecl(ImportD);
14369
14370 // Make the module visible.
Richard Smitha7e2cc62015-05-01 01:53:09 +000014371 getModuleLoader().makeModuleVisible(Mod, Module::AllVisible, Loc);
Richard Smith42413142015-05-15 20:05:43 +000014372 VisibleModules.setVisible(Mod, Loc);
Douglas Gregorc147b0b2013-01-12 01:29:50 +000014373}
14374
David Chisnall0867d9c2012-02-18 16:12:34 +000014375void Sema::ActOnPragmaRedefineExtname(IdentifierInfo* Name,
14376 IdentifierInfo* AliasName,
14377 SourceLocation PragmaLoc,
14378 SourceLocation NameLoc,
14379 SourceLocation AliasNameLoc) {
Alexander Musman70e9f5f2015-06-10 11:20:26 +000014380 NamedDecl *PrevDecl = LookupSingleName(TUScope, Name, NameLoc,
14381 LookupOrdinaryName);
14382 AsmLabelAttr *Attr =
14383 AsmLabelAttr::CreateImplicit(Context, AliasName->getName(), AliasNameLoc);
David Chisnall0867d9c2012-02-18 16:12:34 +000014384
Alexander Musman70e9f5f2015-06-10 11:20:26 +000014385 // If a declaration that:
14386 // 1) declares a function or a variable
14387 // 2) has external linkage
14388 // already exists, add a label attribute to it.
Aaron Ballman7572e582015-07-16 17:06:53 +000014389 if (PrevDecl && (isa<FunctionDecl>(PrevDecl) || isa<VarDecl>(PrevDecl))) {
14390 if (isDeclExternC(PrevDecl))
14391 PrevDecl->addAttr(Attr);
14392 else
14393 Diag(PrevDecl->getLocation(), diag::warn_redefine_extname_not_applied)
14394 << /*Variable*/(isa<FunctionDecl>(PrevDecl) ? 0 : 1) << PrevDecl;
Alexander Musman70e9f5f2015-06-10 11:20:26 +000014395 // Otherwise, add a label atttibute to ExtnameUndeclaredIdentifiers.
Aaron Ballman7572e582015-07-16 17:06:53 +000014396 } else
Alexander Musman70e9f5f2015-06-10 11:20:26 +000014397 (void)ExtnameUndeclaredIdentifiers.insert(std::make_pair(Name, Attr));
David Chisnall0867d9c2012-02-18 16:12:34 +000014398}
14399
Eli Friedman5ed51982009-06-05 02:44:36 +000014400void Sema::ActOnPragmaWeakID(IdentifierInfo* Name,
14401 SourceLocation PragmaLoc,
14402 SourceLocation NameLoc) {
Douglas Gregorb2ccf012010-04-15 22:33:43 +000014403 Decl *PrevDecl = LookupSingleName(TUScope, Name, NameLoc, LookupOrdinaryName);
Eli Friedman5ed51982009-06-05 02:44:36 +000014404
Eli Friedman5ed51982009-06-05 02:44:36 +000014405 if (PrevDecl) {
Aaron Ballman36a53502014-01-16 13:03:14 +000014406 PrevDecl->addAttr(WeakAttr::CreateImplicit(Context, PragmaLoc));
Ryan Flynn7d470f32009-07-30 03:15:39 +000014407 } else {
14408 (void)WeakUndeclaredIdentifiers.insert(
14409 std::pair<IdentifierInfo*,WeakInfo>
Craig Topperc3ec1492014-05-26 06:22:03 +000014410 (Name, WeakInfo((IdentifierInfo*)nullptr, NameLoc)));
Eli Friedman5ed51982009-06-05 02:44:36 +000014411 }
Eli Friedman5ed51982009-06-05 02:44:36 +000014412}
14413
14414void Sema::ActOnPragmaWeakAlias(IdentifierInfo* Name,
14415 IdentifierInfo* AliasName,
14416 SourceLocation PragmaLoc,
14417 SourceLocation NameLoc,
14418 SourceLocation AliasNameLoc) {
Douglas Gregorb2ccf012010-04-15 22:33:43 +000014419 Decl *PrevDecl = LookupSingleName(TUScope, AliasName, AliasNameLoc,
14420 LookupOrdinaryName);
Ryan Flynn7d470f32009-07-30 03:15:39 +000014421 WeakInfo W = WeakInfo(Name, NameLoc);
Eli Friedman5ed51982009-06-05 02:44:36 +000014422
Eli Friedman5ed51982009-06-05 02:44:36 +000014423 if (PrevDecl) {
Ryan Flynn7d470f32009-07-30 03:15:39 +000014424 if (!PrevDecl->hasAttr<AliasAttr>())
14425 if (NamedDecl *ND = dyn_cast<NamedDecl>(PrevDecl))
Ryan Flynnd963a492009-07-31 02:52:19 +000014426 DeclApplyPragmaWeak(TUScope, ND, W);
Ryan Flynn7d470f32009-07-30 03:15:39 +000014427 } else {
14428 (void)WeakUndeclaredIdentifiers.insert(
14429 std::pair<IdentifierInfo*,WeakInfo>(AliasName, W));
Eli Friedman5ed51982009-06-05 02:44:36 +000014430 }
Eli Friedman5ed51982009-06-05 02:44:36 +000014431}
Fariborz Jahanian8d382dc2011-08-22 15:54:49 +000014432
14433Decl *Sema::getObjCDeclContext() const {
14434 return (dyn_cast_or_null<ObjCContainerDecl>(CurContext));
14435}
Argyrios Kyrtzidisc281c962011-10-06 23:23:27 +000014436
14437AvailabilityResult Sema::getCurContextAvailability() const {
Ben Langmuirc91ac9e2015-01-20 20:41:36 +000014438 const Decl *D = cast_or_null<Decl>(getCurObjCLexicalContext());
14439 if (!D)
14440 return AR_Available;
14441
Ted Kremenekcb42dbe2013-11-20 17:24:03 +000014442 // If we are within an Objective-C method, we should consult
14443 // both the availability of the method as well as the
14444 // enclosing class. If the class is (say) deprecated,
14445 // the entire method is considered deprecated from the
14446 // purpose of checking if the current context is deprecated.
14447 if (const ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D)) {
14448 AvailabilityResult R = MD->getAvailability();
14449 if (R != AR_Available)
14450 return R;
14451 D = MD->getClassInterface();
14452 }
14453 // If we are within an Objective-c @implementation, it
14454 // gets the same availability context as the @interface.
14455 else if (const ObjCImplementationDecl *ID =
14456 dyn_cast<ObjCImplementationDecl>(D)) {
14457 D = ID->getClassInterface();
14458 }
Fariborz Jahanian38c53fb2014-08-21 17:06:57 +000014459 // Recover from user error.
14460 return D ? D->getAvailability() : AR_Available;
Argyrios Kyrtzidisc281c962011-10-06 23:23:27 +000014461}