/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp

Bug Summary

File:	tools/clang/lib/Sema/SemaDecl.cpp
Warning:	line 3197, column 5 Value stored to 'NewType' is never read

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name SemaDecl.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-config-compatibility-mode=true -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -mrelocation-model pic -pic-level 2 -mthread-model posix -relaxed-aliasing -fmath-errno -masm-verbose -mconstructor-aliases -munwind-tables -fuse-init-array -target-cpu x86-64 -dwarf-column-info -debugger-tuning=gdb -momit-leaf-frame-pointer -ffunction-sections -fdata-sections -resource-dir /usr/lib/llvm-8/lib/clang/8.0.0 -D CLANG_VENDOR="Debian " -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-8~svn348900/build-llvm/tools/clang/lib/Sema -I /build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema -I /build/llvm-toolchain-snapshot-8~svn348900/tools/clang/include -I /build/llvm-toolchain-snapshot-8~svn348900/build-llvm/tools/clang/include -I /build/llvm-toolchain-snapshot-8~svn348900/build-llvm/include -I /build/llvm-toolchain-snapshot-8~svn348900/include -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0/backward -internal-isystem /usr/include/clang/8.0.0/include/ -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-8/lib/clang/8.0.0/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-command-line-argument -Wno-unknown-warning-option -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-comment -std=c++11 -fdeprecated-macro -fdebug-compilation-dir /build/llvm-toolchain-snapshot-8~svn348900/build-llvm/tools/clang/lib/Sema -ferror-limit 19 -fmessage-length 0 -fvisibility-inlines-hidden -fobjc-runtime=gcc -fno-common -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -o /tmp/scan-build-2018-12-12-042652-12204-1 -x c++ /build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp -faddrsig

1	//===--- SemaDecl.cpp - Semantic Analysis for Declarations ----------------===//
2	//
3	// The LLVM Compiler Infrastructure
4	//
5	// This file is distributed under the University of Illinois Open Source
6	// License. See LICENSE.TXT for details.
7	//
8	//===----------------------------------------------------------------------===//
9	//
10	// This file implements semantic analysis for declarations.
11	//
12	//===----------------------------------------------------------------------===//
13
14	#include "TypeLocBuilder.h"
15	#include "clang/AST/ASTConsumer.h"
16	#include "clang/AST/ASTContext.h"
17	#include "clang/AST/ASTLambda.h"
18	#include "clang/AST/CXXInheritance.h"
19	#include "clang/AST/CharUnits.h"
20	#include "clang/AST/CommentDiagnostic.h"
21	#include "clang/AST/DeclCXX.h"
22	#include "clang/AST/DeclObjC.h"
23	#include "clang/AST/DeclTemplate.h"
24	#include "clang/AST/EvaluatedExprVisitor.h"
25	#include "clang/AST/ExprCXX.h"
26	#include "clang/AST/StmtCXX.h"
27	#include "clang/Basic/Builtins.h"
28	#include "clang/Basic/PartialDiagnostic.h"
29	#include "clang/Basic/SourceManager.h"
30	#include "clang/Basic/TargetInfo.h"
31	#include "clang/Lex/HeaderSearch.h" // TODO: Sema shouldn't depend on Lex
32	#include "clang/Lex/Lexer.h" // TODO: Extract static functions to fix layering.
33	#include "clang/Lex/ModuleLoader.h" // TODO: Sema shouldn't depend on Lex
34	#include "clang/Lex/Preprocessor.h" // Included for isCodeCompletionEnabled()
35	#include "clang/Sema/CXXFieldCollector.h"
36	#include "clang/Sema/DeclSpec.h"
37	#include "clang/Sema/DelayedDiagnostic.h"
38	#include "clang/Sema/Initialization.h"
39	#include "clang/Sema/Lookup.h"
40	#include "clang/Sema/ParsedTemplate.h"
41	#include "clang/Sema/Scope.h"
42	#include "clang/Sema/ScopeInfo.h"
43	#include "clang/Sema/SemaInternal.h"
44	#include "clang/Sema/Template.h"
45	#include "llvm/ADT/SmallString.h"
46	#include "llvm/ADT/Triple.h"
47	#include <algorithm>
48	#include <cstring>
49	#include <functional>
50
51	using namespace clang;
52	using namespace sema;
53
54	Sema::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
60	return DeclGroupPtrTy::make(DeclGroupRef(Ptr));
61	}
62
63	namespace {
64
65	class TypeNameValidatorCCC : public CorrectionCandidateCallback {
66	public:
67	TypeNameValidatorCCC(bool AllowInvalid, bool WantClass = false,
68	bool AllowTemplates = false,
69	bool AllowNonTemplates = true)
70	: AllowInvalidDecl(AllowInvalid), WantClassName(WantClass),
71	AllowTemplates(AllowTemplates), AllowNonTemplates(AllowNonTemplates) {
72	WantExpressionKeywords = false;
73	WantCXXNamedCasts = false;
74	WantRemainingKeywords = false;
75	}
76
77	bool ValidateCandidate(const TypoCorrection &candidate) override {
78	if (NamedDecl *ND = candidate.getCorrectionDecl()) {
79	if (!AllowInvalidDecl && ND->isInvalidDecl())
80	return false;
81
82	if (getAsTypeTemplateDecl(ND))
83	return AllowTemplates;
84
85	bool IsType = isa<TypeDecl>(ND) \|\| isa<ObjCInterfaceDecl>(ND);
86	if (!IsType)
87	return false;
88
89	if (AllowNonTemplates)
90	return true;
91
92	// An injected-class-name of a class template (specialization) is valid
93	// as a template or as a non-template.
94	if (AllowTemplates) {
95	auto *RD = dyn_cast<CXXRecordDecl>(ND);
96	if (!RD \|\| !RD->isInjectedClassName())
97	return false;
98	RD = cast<CXXRecordDecl>(RD->getDeclContext());
99	return RD->getDescribedClassTemplate() \|\|
100	isa<ClassTemplateSpecializationDecl>(RD);
101	}
102
103	return false;
104	}
105
106	return !WantClassName && candidate.isKeyword();
107	}
108
109	private:
110	bool AllowInvalidDecl;
111	bool WantClassName;
112	bool AllowTemplates;
113	bool AllowNonTemplates;
114	};
115
116	} // end anonymous namespace
117
118	/// Determine whether the token kind starts a simple-type-specifier.
119	bool Sema::isSimpleTypeSpecifier(tok::TokenKind Kind) const {
120	switch (Kind) {
121	// FIXME: Take into account the current language when deciding whether a
122	// token kind is a valid type specifier
123	case tok::kw_short:
124	case tok::kw_long:
125	case tok::kw___int64:
126	case tok::kw___int128:
127	case tok::kw_signed:
128	case tok::kw_unsigned:
129	case tok::kw_void:
130	case tok::kw_char:
131	case tok::kw_int:
132	case tok::kw_half:
133	case tok::kw_float:
134	case tok::kw_double:
135	case tok::kw__Float16:
136	case tok::kw___float128:
137	case tok::kw_wchar_t:
138	case tok::kw_bool:
139	case tok::kw___underlying_type:
140	case tok::kw___auto_type:
141	return true;
142
143	case tok::annot_typename:
144	case tok::kw_char16_t:
145	case tok::kw_char32_t:
146	case tok::kw_typeof:
147	case tok::annot_decltype:
148	case tok::kw_decltype:
149	return getLangOpts().CPlusPlus;
150
151	case tok::kw_char8_t:
152	return getLangOpts().Char8;
153
154	default:
155	break;
156	}
157
158	return false;
159	}
160
161	namespace {
162	enum class UnqualifiedTypeNameLookupResult {
163	NotFound,
164	FoundNonType,
165	FoundType
166	};
167	} // end anonymous namespace
168
169	/// Tries to perform unqualified lookup of the type decls in bases for
170	/// dependent class.
171	/// \return \a NotFound if no any decls is found, \a FoundNotType if found not a
172	/// type decl, \a FoundType if only type decls are found.
173	static UnqualifiedTypeNameLookupResult
174	lookupUnqualifiedTypeNameInBase(Sema &S, const IdentifierInfo &II,
175	SourceLocation NameLoc,
176	const CXXRecordDecl *RD) {
177	if (!RD->hasDefinition())
178	return UnqualifiedTypeNameLookupResult::NotFound;
179	// Look for type decls in base classes.
180	UnqualifiedTypeNameLookupResult FoundTypeDecl =
181	UnqualifiedTypeNameLookupResult::NotFound;
182	for (const auto &Base : RD->bases()) {
183	const CXXRecordDecl *BaseRD = nullptr;
184	if (auto *BaseTT = Base.getType()->getAs<TagType>())
185	BaseRD = BaseTT->getAsCXXRecordDecl();
186	else if (auto *TST = Base.getType()->getAs<TemplateSpecializationType>()) {
187	// Look for type decls in dependent base classes that have known primary
188	// templates.
189	if (!TST \|\| !TST->isDependentType())
190	continue;
191	auto *TD = TST->getTemplateName().getAsTemplateDecl();
192	if (!TD)
193	continue;
194	if (auto *BasePrimaryTemplate =
195	dyn_cast_or_null<CXXRecordDecl>(TD->getTemplatedDecl())) {
196	if (BasePrimaryTemplate->getCanonicalDecl() != RD->getCanonicalDecl())
197	BaseRD = BasePrimaryTemplate;
198	else if (auto *CTD = dyn_cast<ClassTemplateDecl>(TD)) {
199	if (const ClassTemplatePartialSpecializationDecl *PS =
200	CTD->findPartialSpecialization(Base.getType()))
201	if (PS->getCanonicalDecl() != RD->getCanonicalDecl())
202	BaseRD = PS;
203	}
204	}
205	}
206	if (BaseRD) {
207	for (NamedDecl *ND : BaseRD->lookup(&II)) {
208	if (!isa<TypeDecl>(ND))
209	return UnqualifiedTypeNameLookupResult::FoundNonType;
210	FoundTypeDecl = UnqualifiedTypeNameLookupResult::FoundType;
211	}
212	if (FoundTypeDecl == UnqualifiedTypeNameLookupResult::NotFound) {
213	switch (lookupUnqualifiedTypeNameInBase(S, II, NameLoc, BaseRD)) {
214	case UnqualifiedTypeNameLookupResult::FoundNonType:
215	return UnqualifiedTypeNameLookupResult::FoundNonType;
216	case UnqualifiedTypeNameLookupResult::FoundType:
217	FoundTypeDecl = UnqualifiedTypeNameLookupResult::FoundType;
218	break;
219	case UnqualifiedTypeNameLookupResult::NotFound:
220	break;
221	}
222	}
223	}
224	}
225
226	return FoundTypeDecl;
227	}
228
229	static ParsedType recoverFromTypeInKnownDependentBase(Sema &S,
230	const IdentifierInfo &II,
231	SourceLocation NameLoc) {
232	// Lookup in the parent class template context, if any.
233	const CXXRecordDecl *RD = nullptr;
234	UnqualifiedTypeNameLookupResult FoundTypeDecl =
235	UnqualifiedTypeNameLookupResult::NotFound;
236	for (DeclContext *DC = S.CurContext;
237	DC && FoundTypeDecl == UnqualifiedTypeNameLookupResult::NotFound;
238	DC = DC->getParent()) {
239	// Look for type decls in dependent base classes that have known primary
240	// templates.
241	RD = dyn_cast<CXXRecordDecl>(DC);
242	if (RD && RD->getDescribedClassTemplate())
243	FoundTypeDecl = lookupUnqualifiedTypeNameInBase(S, II, NameLoc, RD);
244	}
245	if (FoundTypeDecl != UnqualifiedTypeNameLookupResult::FoundType)
246	return nullptr;
247
248	// We found some types in dependent base classes. Recover as if the user
249	// wrote 'typename MyClass::II' instead of 'II'. We'll fully resolve the
250	// lookup during template instantiation.
251	S.Diag(NameLoc, diag::ext_found_via_dependent_bases_lookup) << &II;
252
253	ASTContext &Context = S.Context;
254	auto *NNS = NestedNameSpecifier::Create(Context, nullptr, false,
255	cast<Type>(Context.getRecordType(RD)));
256	QualType T = Context.getDependentNameType(ETK_Typename, NNS, &II);
257
258	CXXScopeSpec SS;
259	SS.MakeTrivial(Context, NNS, SourceRange(NameLoc));
260
261	TypeLocBuilder Builder;
262	DependentNameTypeLoc DepTL = Builder.push<DependentNameTypeLoc>(T);
263	DepTL.setNameLoc(NameLoc);
264	DepTL.setElaboratedKeywordLoc(SourceLocation());
265	DepTL.setQualifierLoc(SS.getWithLocInContext(Context));
266	return S.CreateParsedType(T, Builder.getTypeSourceInfo(Context, T));
267	}
268
269	/// If the identifier refers to a type name within this scope,
270	/// return the declaration of that type.
271	///
272	/// This routine performs ordinary name lookup of the identifier II
273	/// within the given scope, with optional C++ scope specifier SS, to
274	/// determine whether the name refers to a type. If so, returns an
275	/// opaque pointer (actually a QualType) corresponding to that
276	/// type. Otherwise, returns NULL.
277	ParsedType Sema::getTypeName(const IdentifierInfo &II, SourceLocation NameLoc,
278	Scope S, CXXScopeSpec SS,
279	bool isClassName, bool HasTrailingDot,
280	ParsedType ObjectTypePtr,
281	bool IsCtorOrDtorName,
282	bool WantNontrivialTypeSourceInfo,
283	bool IsClassTemplateDeductionContext,
284	IdentifierInfo **CorrectedII) {
285	// FIXME: Consider allowing this outside C++1z mode as an extension.
286	bool AllowDeducedTemplate = IsClassTemplateDeductionContext &&
287	getLangOpts().CPlusPlus17 && !IsCtorOrDtorName &&
288	!isClassName && !HasTrailingDot;
289
290	// Determine where we will perform name lookup.
291	DeclContext *LookupCtx = nullptr;
292	if (ObjectTypePtr) {
293	QualType ObjectType = ObjectTypePtr.get();
294	if (ObjectType->isRecordType())
295	LookupCtx = computeDeclContext(ObjectType);
296	} else if (SS && SS->isNotEmpty()) {
297	LookupCtx = computeDeclContext(*SS, false);
298
299	if (!LookupCtx) {
300	if (isDependentScopeSpecifier(*SS)) {
301	// C++ [temp.res]p3:
302	// A qualified-id that refers to a type and in which the
303	// nested-name-specifier depends on a template-parameter (14.6.2)
304	// shall be prefixed by the keyword typename to indicate that the
305	// qualified-id denotes a type, forming an
306	// elaborated-type-specifier (7.1.5.3).
307	//
308	// We therefore do not perform any name lookup if the result would
309	// refer to a member of an unknown specialization.
310	if (!isClassName && !IsCtorOrDtorName)
311	return nullptr;
312
313	// We know from the grammar that this name refers to a type,
314	// so build a dependent node to describe the type.
315	if (WantNontrivialTypeSourceInfo)
316	return ActOnTypenameType(S, SourceLocation(), *SS, II, NameLoc).get();
317
318	NestedNameSpecifierLoc QualifierLoc = SS->getWithLocInContext(Context);
319	QualType T = CheckTypenameType(ETK_None, SourceLocation(), QualifierLoc,
320	II, NameLoc);
321	return ParsedType::make(T);
322	}
323
324	return nullptr;
325	}
326
327	if (!LookupCtx->isDependentContext() &&
328	RequireCompleteDeclContext(*SS, LookupCtx))
329	return nullptr;
330	}
331
332	// FIXME: LookupNestedNameSpecifierName isn't the right kind of
333	// lookup for class-names.
334	LookupNameKind Kind = isClassName ? LookupNestedNameSpecifierName :
335	LookupOrdinaryName;
336	LookupResult Result(*this, &II, NameLoc, Kind);
337	if (LookupCtx) {
338	// Perform "qualified" name lookup into the declaration context we
339	// computed, which is either the type of the base of a member access
340	// expression or the declaration context associated with a prior
341	// nested-name-specifier.
342	LookupQualifiedName(Result, LookupCtx);
343
344	if (ObjectTypePtr && Result.empty()) {
345	// C++ [basic.lookup.classref]p3:
346	// If the unqualified-id is ~type-name, the type-name is looked up
347	// in the context of the entire postfix-expression. If the type T of
348	// the object expression is of a class type C, the type-name is also
349	// looked up in the scope of class C. At least one of the lookups shall
350	// find a name that refers to (possibly cv-qualified) T.
351	LookupName(Result, S);
352	}
353	} else {
354	// Perform unqualified name lookup.
355	LookupName(Result, S);
356
357	// For unqualified lookup in a class template in MSVC mode, look into
358	// dependent base classes where the primary class template is known.
359	if (Result.empty() && getLangOpts().MSVCCompat && (!SS \|\| SS->isEmpty())) {
360	if (ParsedType TypeInBase =
361	recoverFromTypeInKnownDependentBase(*this, II, NameLoc))
362	return TypeInBase;
363	}
364	}
365
366	NamedDecl *IIDecl = nullptr;
367	switch (Result.getResultKind()) {
368	case LookupResult::NotFound:
369	case LookupResult::NotFoundInCurrentInstantiation:
370	if (CorrectedII) {
371	TypoCorrection Correction =
372	CorrectTypo(Result.getLookupNameInfo(), Kind, S, SS,
373	llvm::make_unique<TypeNameValidatorCCC>(
374	true, isClassName, AllowDeducedTemplate),
375	CTK_ErrorRecovery);
376	IdentifierInfo *NewII = Correction.getCorrectionAsIdentifierInfo();
377	TemplateTy Template;
378	bool MemberOfUnknownSpecialization;
379	UnqualifiedId TemplateName;
380	TemplateName.setIdentifier(NewII, NameLoc);
381	NestedNameSpecifier *NNS = Correction.getCorrectionSpecifier();
382	CXXScopeSpec NewSS, *NewSSPtr = SS;
383	if (SS && NNS) {
384	NewSS.MakeTrivial(Context, NNS, SourceRange(NameLoc));
385	NewSSPtr = &NewSS;
386	}
387	if (Correction && (NNS \|\| NewII != &II) &&
388	// Ignore a correction to a template type as the to-be-corrected
389	// identifier is not a template (typo correction for template names
390	// is handled elsewhere).
391	!(getLangOpts().CPlusPlus && NewSSPtr &&
392	isTemplateName(S, *NewSSPtr, false, TemplateName, nullptr, false,
393	Template, MemberOfUnknownSpecialization))) {
394	ParsedType Ty = getTypeName(*NewII, NameLoc, S, NewSSPtr,
395	isClassName, HasTrailingDot, ObjectTypePtr,
396	IsCtorOrDtorName,
397	WantNontrivialTypeSourceInfo,
398	IsClassTemplateDeductionContext);
399	if (Ty) {
400	diagnoseTypo(Correction,
401	PDiag(diag::err_unknown_type_or_class_name_suggest)
402	<< Result.getLookupName() << isClassName);
403	if (SS && NNS)
404	SS->MakeTrivial(Context, NNS, SourceRange(NameLoc));
405	*CorrectedII = NewII;
406	return Ty;
407	}
408	}
409	}
410	// If typo correction failed or was not performed, fall through
411	LLVM_FALLTHROUGH[[clang::fallthrough]];
412	case LookupResult::FoundOverloaded:
413	case LookupResult::FoundUnresolvedValue:
414	Result.suppressDiagnostics();
415	return nullptr;
416
417	case LookupResult::Ambiguous:
418	// Recover from type-hiding ambiguities by hiding the type. We'll
419	// do the lookup again when looking for an object, and we can
420	// diagnose the error then. If we don't do this, then the error
421	// about hiding the type will be immediately followed by an error
422	// that only makes sense if the identifier was treated like a type.
423	if (Result.getAmbiguityKind() == LookupResult::AmbiguousTagHiding) {
424	Result.suppressDiagnostics();
425	return nullptr;
426	}
427
428	// Look to see if we have a type anywhere in the list of results.
429	for (LookupResult::iterator Res = Result.begin(), ResEnd = Result.end();
430	Res != ResEnd; ++Res) {
431	if (isa<TypeDecl>(Res) \|\| isa<ObjCInterfaceDecl>(Res) \|\|
432	(AllowDeducedTemplate && getAsTypeTemplateDecl(*Res))) {
433	if (!IIDecl \|\|
434	(*Res)->getLocation().getRawEncoding() <
435	IIDecl->getLocation().getRawEncoding())
436	IIDecl = *Res;
437	}
438	}
439
440	if (!IIDecl) {
441	// None of the entities we found is a type, so there is no way
442	// to even assume that the result is a type. In this case, don't
443	// complain about the ambiguity. The parser will either try to
444	// perform this lookup again (e.g., as an object name), which
445	// will produce the ambiguity, or will complain that it expected
446	// a type name.
447	Result.suppressDiagnostics();
448	return nullptr;
449	}
450
451	// We found a type within the ambiguous lookup; diagnose the
452	// ambiguity and then return that type. This might be the right
453	// answer, or it might not be, but it suppresses any attempt to
454	// perform the name lookup again.
455	break;
456
457	case LookupResult::Found:
458	IIDecl = Result.getFoundDecl();
459	break;
460	}
461
462	assert(IIDecl && "Didn't find decl")((IIDecl && "Didn't find decl") ? static_cast<void > (0) : __assert_fail ("IIDecl && \"Didn't find decl\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 462, __PRETTY_FUNCTION__));
463
464	QualType T;
465	if (TypeDecl *TD = dyn_cast<TypeDecl>(IIDecl)) {
466	// C++ [class.qual]p2: A lookup that would find the injected-class-name
467	// instead names the constructors of the class, except when naming a class.
468	// This is ill-formed when we're not actually forming a ctor or dtor name.
469	auto *LookupRD = dyn_cast_or_null<CXXRecordDecl>(LookupCtx);
470	auto *FoundRD = dyn_cast<CXXRecordDecl>(TD);
471	if (!isClassName && !IsCtorOrDtorName && LookupRD && FoundRD &&
472	FoundRD->isInjectedClassName() &&
473	declaresSameEntity(LookupRD, cast<Decl>(FoundRD->getParent())))
474	Diag(NameLoc, diag::err_out_of_line_qualified_id_type_names_constructor)
475	<< &II << /Type/1;
476
477	DiagnoseUseOfDecl(IIDecl, NameLoc);
478
479	T = Context.getTypeDeclType(TD);
480	MarkAnyDeclReferenced(TD->getLocation(), TD, /OdrUse=/false);
481	} else if (ObjCInterfaceDecl *IDecl = dyn_cast<ObjCInterfaceDecl>(IIDecl)) {
482	(void)DiagnoseUseOfDecl(IDecl, NameLoc);
483	if (!HasTrailingDot)
484	T = Context.getObjCInterfaceType(IDecl);
485	} else if (AllowDeducedTemplate) {
486	if (auto *TD = getAsTypeTemplateDecl(IIDecl))
487	T = Context.getDeducedTemplateSpecializationType(TemplateName(TD),
488	QualType(), false);
489	}
490
491	if (T.isNull()) {
492	// If it's not plausibly a type, suppress diagnostics.
493	Result.suppressDiagnostics();
494	return nullptr;
495	}
496
497	// NOTE: avoid constructing an ElaboratedType(Loc) if this is a
498	// constructor or destructor name (in such a case, the scope specifier
499	// will be attached to the enclosing Expr or Decl node).
500	if (SS && SS->isNotEmpty() && !IsCtorOrDtorName &&
501	!isa<ObjCInterfaceDecl>(IIDecl)) {
502	if (WantNontrivialTypeSourceInfo) {
503	// Construct a type with type-source information.
504	TypeLocBuilder Builder;
505	Builder.pushTypeSpec(T).setNameLoc(NameLoc);
506
507	T = getElaboratedType(ETK_None, *SS, T);
508	ElaboratedTypeLoc ElabTL = Builder.push<ElaboratedTypeLoc>(T);
509	ElabTL.setElaboratedKeywordLoc(SourceLocation());
510	ElabTL.setQualifierLoc(SS->getWithLocInContext(Context));
511	return CreateParsedType(T, Builder.getTypeSourceInfo(Context, T));
512	} else {
513	T = getElaboratedType(ETK_None, *SS, T);
514	}
515	}
516
517	return ParsedType::make(T);
518	}
519
520	// Builds a fake NNS for the given decl context.
521	static NestedNameSpecifier *
522	synthesizeCurrentNestedNameSpecifier(ASTContext &Context, DeclContext *DC) {
523	for (;; DC = DC->getLookupParent()) {
524	DC = DC->getPrimaryContext();
525	auto *ND = dyn_cast<NamespaceDecl>(DC);
526	if (ND && !ND->isInline() && !ND->isAnonymousNamespace())
527	return NestedNameSpecifier::Create(Context, nullptr, ND);
528	else if (auto *RD = dyn_cast<CXXRecordDecl>(DC))
529	return NestedNameSpecifier::Create(Context, nullptr, RD->isTemplateDecl(),
530	RD->getTypeForDecl());
531	else if (isa<TranslationUnitDecl>(DC))
532	return NestedNameSpecifier::GlobalSpecifier(Context);
533	}
534	llvm_unreachable("something isn't in TU scope?")::llvm::llvm_unreachable_internal("something isn't in TU scope?" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 534);
535	}
536
537	/// Find the parent class with dependent bases of the innermost enclosing method
538	/// context. Do not look for enclosing CXXRecordDecls directly, or we will end
539	/// up allowing unqualified dependent type names at class-level, which MSVC
540	/// correctly rejects.
541	static const CXXRecordDecl *
542	findRecordWithDependentBasesOfEnclosingMethod(const DeclContext *DC) {
543	for (; DC && DC->isDependentContext(); DC = DC->getLookupParent()) {
544	DC = DC->getPrimaryContext();
545	if (const auto *MD = dyn_cast<CXXMethodDecl>(DC))
546	if (MD->getParent()->hasAnyDependentBases())
547	return MD->getParent();
548	}
549	return nullptr;
550	}
551
552	ParsedType Sema::ActOnMSVCUnknownTypeName(const IdentifierInfo &II,
553	SourceLocation NameLoc,
554	bool IsTemplateTypeArg) {
555	assert(getLangOpts().MSVCCompat && "shouldn't be called in non-MSVC mode")((getLangOpts().MSVCCompat && "shouldn't be called in non-MSVC mode" ) ? static_cast<void> (0) : __assert_fail ("getLangOpts().MSVCCompat && \"shouldn't be called in non-MSVC mode\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 555, __PRETTY_FUNCTION__));
556
557	NestedNameSpecifier *NNS = nullptr;
558	if (IsTemplateTypeArg && getCurScope()->isTemplateParamScope()) {
559	// If we weren't able to parse a default template argument, delay lookup
560	// until instantiation time by making a non-dependent DependentTypeName. We
561	// pretend we saw a NestedNameSpecifier referring to the current scope, and
562	// lookup is retried.
563	// FIXME: This hurts our diagnostic quality, since we get errors like "no
564	// type named 'Foo' in 'current_namespace'" when the user didn't write any
565	// name specifiers.
566	NNS = synthesizeCurrentNestedNameSpecifier(Context, CurContext);
567	Diag(NameLoc, diag::ext_ms_delayed_template_argument) << &II;
568	} else if (const CXXRecordDecl *RD =
569	findRecordWithDependentBasesOfEnclosingMethod(CurContext)) {
570	// Build a DependentNameType that will perform lookup into RD at
571	// instantiation time.
572	NNS = NestedNameSpecifier::Create(Context, nullptr, RD->isTemplateDecl(),
573	RD->getTypeForDecl());
574
575	// Diagnose that this identifier was undeclared, and retry the lookup during
576	// template instantiation.
577	Diag(NameLoc, diag::ext_undeclared_unqual_id_with_dependent_base) << &II
578	<< RD;
579	} else {
580	// This is not a situation that we should recover from.
581	return ParsedType();
582	}
583
584	QualType T = Context.getDependentNameType(ETK_None, NNS, &II);
585
586	// Build type location information. We synthesized the qualifier, so we have
587	// to build a fake NestedNameSpecifierLoc.
588	NestedNameSpecifierLocBuilder NNSLocBuilder;
589	NNSLocBuilder.MakeTrivial(Context, NNS, SourceRange(NameLoc));
590	NestedNameSpecifierLoc QualifierLoc = NNSLocBuilder.getWithLocInContext(Context);
591
592	TypeLocBuilder Builder;
593	DependentNameTypeLoc DepTL = Builder.push<DependentNameTypeLoc>(T);
594	DepTL.setNameLoc(NameLoc);
595	DepTL.setElaboratedKeywordLoc(SourceLocation());
596	DepTL.setQualifierLoc(QualifierLoc);
597	return CreateParsedType(T, Builder.getTypeSourceInfo(Context, T));
598	}
599
600	/// isTagName() - This method is called for error recovery purposes only
601	/// to determine if the specified name is a valid tag name ("struct foo"). If
602	/// so, this returns the TST for the tag corresponding to it (TST_enum,
603	/// TST_union, TST_struct, TST_interface, TST_class). This is used to diagnose
604	/// cases in C where the user forgot to specify the tag.
605	DeclSpec::TST Sema::isTagName(IdentifierInfo &II, Scope *S) {
606	// Do a tag name lookup in this scope.
607	LookupResult R(*this, &II, SourceLocation(), LookupTagName);
608	LookupName(R, S, false);
609	R.suppressDiagnostics();
610	if (R.getResultKind() == LookupResult::Found)
611	if (const TagDecl *TD = R.getAsSingle<TagDecl>()) {
612	switch (TD->getTagKind()) {
613	case TTK_Struct: return DeclSpec::TST_struct;
614	case TTK_Interface: return DeclSpec::TST_interface;
615	case TTK_Union: return DeclSpec::TST_union;
616	case TTK_Class: return DeclSpec::TST_class;
617	case TTK_Enum: return DeclSpec::TST_enum;
618	}
619	}
620
621	return DeclSpec::TST_unspecified;
622	}
623
624	/// isMicrosoftMissingTypename - In Microsoft mode, within class scope,
625	/// if a CXXScopeSpec's type is equal to the type of one of the base classes
626	/// then downgrade the missing typename error to a warning.
627	/// This is needed for MSVC compatibility; Example:
628	/// @code
629	/// template<class T> class A {
630	/// public:
631	/// typedef int TYPE;
632	/// };
633	/// template<class T> class B : public A<T> {
634	/// public:
635	/// A<T>::TYPE a; // no typename required because A<T> is a base class.
636	/// };
637	/// @endcode
638	bool Sema::isMicrosoftMissingTypename(const CXXScopeSpec SS, Scope S) {
639	if (CurContext->isRecord()) {
640	if (SS->getScopeRep()->getKind() == NestedNameSpecifier::Super)
641	return true;
642
643	const Type *Ty = SS->getScopeRep()->getAsType();
644
645	CXXRecordDecl *RD = cast<CXXRecordDecl>(CurContext);
646	for (const auto &Base : RD->bases())
647	if (Ty && Context.hasSameUnqualifiedType(QualType(Ty, 1), Base.getType()))
648	return true;
649	return S->isFunctionPrototypeScope();
650	}
651	return CurContext->isFunctionOrMethod() \|\| S->isFunctionPrototypeScope();
652	}
653
654	void Sema::DiagnoseUnknownTypeName(IdentifierInfo *&II,
655	SourceLocation IILoc,
656	Scope *S,
657	CXXScopeSpec *SS,
658	ParsedType &SuggestedType,
659	bool IsTemplateName) {
660	// Don't report typename errors for editor placeholders.
661	if (II->isEditorPlaceholder())
662	return;
663	// We don't have anything to suggest (yet).
664	SuggestedType = nullptr;
665
666	// There may have been a typo in the name of the type. Look up typo
667	// results, in case we have something that we can suggest.
668	if (TypoCorrection Corrected =
669	CorrectTypo(DeclarationNameInfo(II, IILoc), LookupOrdinaryName, S, SS,
670	llvm::make_unique<TypeNameValidatorCCC>(
671	false, false, IsTemplateName, !IsTemplateName),
672	CTK_ErrorRecovery)) {
673	// FIXME: Support error recovery for the template-name case.
674	bool CanRecover = !IsTemplateName;
675	if (Corrected.isKeyword()) {
676	// We corrected to a keyword.
677	diagnoseTypo(Corrected,
678	PDiag(IsTemplateName ? diag::err_no_template_suggest
679	: diag::err_unknown_typename_suggest)
680	<< II);
681	II = Corrected.getCorrectionAsIdentifierInfo();
682	} else {
683	// We found a similarly-named type or interface; suggest that.
684	if (!SS \|\| !SS->isSet()) {
685	diagnoseTypo(Corrected,
686	PDiag(IsTemplateName ? diag::err_no_template_suggest
687	: diag::err_unknown_typename_suggest)
688	<< II, CanRecover);
689	} else if (DeclContext DC = computeDeclContext(SS, false)) {
690	std::string CorrectedStr(Corrected.getAsString(getLangOpts()));
691	bool DroppedSpecifier = Corrected.WillReplaceSpecifier() &&
692	II->getName().equals(CorrectedStr);
693	diagnoseTypo(Corrected,
694	PDiag(IsTemplateName
695	? diag::err_no_member_template_suggest
696	: diag::err_unknown_nested_typename_suggest)
697	<< II << DC << DroppedSpecifier << SS->getRange(),
698	CanRecover);
699	} else {
700	llvm_unreachable("could not have corrected a typo here")::llvm::llvm_unreachable_internal("could not have corrected a typo here" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 700);
701	}
702
703	if (!CanRecover)
704	return;
705
706	CXXScopeSpec tmpSS;
707	if (Corrected.getCorrectionSpecifier())
708	tmpSS.MakeTrivial(Context, Corrected.getCorrectionSpecifier(),
709	SourceRange(IILoc));
710	// FIXME: Support class template argument deduction here.
711	SuggestedType =
712	getTypeName(*Corrected.getCorrectionAsIdentifierInfo(), IILoc, S,
713	tmpSS.isSet() ? &tmpSS : SS, false, false, nullptr,
714	/IsCtorOrDtorName=/false,
715	/NonTrivialTypeSourceInfo=/true);
716	}
717	return;
718	}
719
720	if (getLangOpts().CPlusPlus && !IsTemplateName) {
721	// See if II is a class template that the user forgot to pass arguments to.
722	UnqualifiedId Name;
723	Name.setIdentifier(II, IILoc);
724	CXXScopeSpec EmptySS;
725	TemplateTy TemplateResult;
726	bool MemberOfUnknownSpecialization;
727	if (isTemplateName(S, SS ? SS : EmptySS, /hasTemplateKeyword=*/false,
728	Name, nullptr, true, TemplateResult,
729	MemberOfUnknownSpecialization) == TNK_Type_template) {
730	diagnoseMissingTemplateArguments(TemplateResult.get(), IILoc);
731	return;
732	}
733	}
734
735	// FIXME: Should we move the logic that tries to recover from a missing tag
736	// (struct, union, enum) from Parser::ParseImplicitInt here, instead?
737
738	if (!SS \|\| (!SS->isSet() && !SS->isInvalid()))
739	Diag(IILoc, IsTemplateName ? diag::err_no_template
740	: diag::err_unknown_typename)
741	<< II;
742	else if (DeclContext DC = computeDeclContext(SS, false))
743	Diag(IILoc, IsTemplateName ? diag::err_no_member_template
744	: diag::err_typename_nested_not_found)
745	<< II << DC << SS->getRange();
746	else if (isDependentScopeSpecifier(*SS)) {
747	unsigned DiagID = diag::err_typename_missing;
748	if (getLangOpts().MSVCCompat && isMicrosoftMissingTypename(SS, S))
749	DiagID = diag::ext_typename_missing;
750
751	Diag(SS->getRange().getBegin(), DiagID)
752	<< SS->getScopeRep() << II->getName()
753	<< SourceRange(SS->getRange().getBegin(), IILoc)
754	<< FixItHint::CreateInsertion(SS->getRange().getBegin(), "typename ");
755	SuggestedType = ActOnTypenameType(S, SourceLocation(),
756	SS, II, IILoc).get();
757	} else {
758	assert(SS && SS->isInvalid() &&((SS && SS->isInvalid() && "Invalid scope specifier has already been diagnosed" ) ? static_cast<void> (0) : __assert_fail ("SS && SS->isInvalid() && \"Invalid scope specifier has already been diagnosed\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 759, __PRETTY_FUNCTION__))
759	"Invalid scope specifier has already been diagnosed")((SS && SS->isInvalid() && "Invalid scope specifier has already been diagnosed" ) ? static_cast<void> (0) : __assert_fail ("SS && SS->isInvalid() && \"Invalid scope specifier has already been diagnosed\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 759, __PRETTY_FUNCTION__));
760	}
761	}
762
763	/// Determine whether the given result set contains either a type name
764	/// or
765	static bool isResultTypeOrTemplate(LookupResult &R, const Token &NextToken) {
766	bool CheckTemplate = R.getSema().getLangOpts().CPlusPlus &&
767	NextToken.is(tok::less);
768
769	for (LookupResult::iterator I = R.begin(), IEnd = R.end(); I != IEnd; ++I) {
770	if (isa<TypeDecl>(I) \|\| isa<ObjCInterfaceDecl>(I))
771	return true;
772
773	if (CheckTemplate && isa<TemplateDecl>(*I))
774	return true;
775	}
776
777	return false;
778	}
779
780	static bool isTagTypeWithMissingTag(Sema &SemaRef, LookupResult &Result,
781	Scope *S, CXXScopeSpec &SS,
782	IdentifierInfo *&Name,
783	SourceLocation NameLoc) {
784	LookupResult R(SemaRef, Name, NameLoc, Sema::LookupTagName);
785	SemaRef.LookupParsedName(R, S, &SS);
786	if (TagDecl *Tag = R.getAsSingle<TagDecl>()) {
787	StringRef FixItTagName;
788	switch (Tag->getTagKind()) {
789	case TTK_Class:
790	FixItTagName = "class ";
791	break;
792
793	case TTK_Enum:
794	FixItTagName = "enum ";
795	break;
796
797	case TTK_Struct:
798	FixItTagName = "struct ";
799	break;
800
801	case TTK_Interface:
802	FixItTagName = "__interface ";
803	break;
804
805	case TTK_Union:
806	FixItTagName = "union ";
807	break;
808	}
809
810	StringRef TagName = FixItTagName.drop_back();
811	SemaRef.Diag(NameLoc, diag::err_use_of_tag_name_without_tag)
812	<< Name << TagName << SemaRef.getLangOpts().CPlusPlus
813	<< FixItHint::CreateInsertion(NameLoc, FixItTagName);
814
815	for (LookupResult::iterator I = Result.begin(), IEnd = Result.end();
816	I != IEnd; ++I)
817	SemaRef.Diag((*I)->getLocation(), diag::note_decl_hiding_tag_type)
818	<< Name << TagName;
819
820	// Replace lookup results with just the tag decl.
821	Result.clear(Sema::LookupTagName);
822	SemaRef.LookupParsedName(Result, S, &SS);
823	return true;
824	}
825
826	return false;
827	}
828
829	/// Build a ParsedType for a simple-type-specifier with a nested-name-specifier.
830	static ParsedType buildNestedType(Sema &S, CXXScopeSpec &SS,
831	QualType T, SourceLocation NameLoc) {
832	ASTContext &Context = S.Context;
833
834	TypeLocBuilder Builder;
835	Builder.pushTypeSpec(T).setNameLoc(NameLoc);
836
837	T = S.getElaboratedType(ETK_None, SS, T);
838	ElaboratedTypeLoc ElabTL = Builder.push<ElaboratedTypeLoc>(T);
839	ElabTL.setElaboratedKeywordLoc(SourceLocation());
840	ElabTL.setQualifierLoc(SS.getWithLocInContext(Context));
841	return S.CreateParsedType(T, Builder.getTypeSourceInfo(Context, T));
842	}
843
844	Sema::NameClassification
845	Sema::ClassifyName(Scope S, CXXScopeSpec &SS, IdentifierInfo &Name,
846	SourceLocation NameLoc, const Token &NextToken,
847	bool IsAddressOfOperand,
848	std::unique_ptr<CorrectionCandidateCallback> CCC) {
849	DeclarationNameInfo NameInfo(Name, NameLoc);
850	ObjCMethodDecl *CurMethod = getCurMethodDecl();
851
852	if (NextToken.is(tok::coloncolon)) {
853	NestedNameSpecInfo IdInfo(Name, NameLoc, NextToken.getLocation());
854	BuildCXXNestedNameSpecifier(S, IdInfo, false, SS, nullptr, false);
855	} else if (getLangOpts().CPlusPlus && SS.isSet() &&
856	isCurrentClassName(*Name, S, &SS)) {
857	// Per [class.qual]p2, this names the constructors of SS, not the
858	// injected-class-name. We don't have a classification for that.
859	// There's not much point caching this result, since the parser
860	// will reject it later.
861	return NameClassification::Unknown();
862	}
863
864	LookupResult Result(*this, Name, NameLoc, LookupOrdinaryName);
865	LookupParsedName(Result, S, &SS, !CurMethod);
866
867	// For unqualified lookup in a class template in MSVC mode, look into
868	// dependent base classes where the primary class template is known.
869	if (Result.empty() && SS.isEmpty() && getLangOpts().MSVCCompat) {
870	if (ParsedType TypeInBase =
871	recoverFromTypeInKnownDependentBase(this, Name, NameLoc))
872	return TypeInBase;
873	}
874
875	// Perform lookup for Objective-C instance variables (including automatically
876	// synthesized instance variables), if we're in an Objective-C method.
877	// FIXME: This lookup really, really needs to be folded in to the normal
878	// unqualified lookup mechanism.
879	if (!SS.isSet() && CurMethod && !isResultTypeOrTemplate(Result, NextToken)) {
880	ExprResult E = LookupInObjCMethod(Result, S, Name, true);
881	if (E.get() \|\| E.isInvalid())
882	return E;
883	}
884
885	bool SecondTry = false;
886	bool IsFilteredTemplateName = false;
887
888	Corrected:
889	switch (Result.getResultKind()) {
890	case LookupResult::NotFound:
891	// If an unqualified-id is followed by a '(', then we have a function
892	// call.
893	if (!SS.isSet() && NextToken.is(tok::l_paren)) {
894	// In C++, this is an ADL-only call.
895	// FIXME: Reference?
896	if (getLangOpts().CPlusPlus)
897	return BuildDeclarationNameExpr(SS, Result, /ADL=/true);
898
899	// C90 6.3.2.2:
900	// If the expression that precedes the parenthesized argument list in a
901	// function call consists solely of an identifier, and if no
902	// declaration is visible for this identifier, the identifier is
903	// implicitly declared exactly as if, in the innermost block containing
904	// the function call, the declaration
905	//
906	// extern int identifier ();
907	//
908	// appeared.
909	//
910	// We also allow this in C99 as an extension.
911	if (NamedDecl D = ImplicitlyDefineFunction(NameLoc, Name, S)) {
912	Result.addDecl(D);
913	Result.resolveKind();
914	return BuildDeclarationNameExpr(SS, Result, /ADL=/false);
915	}
916	}
917
918	// In C, we first see whether there is a tag type by the same name, in
919	// which case it's likely that the user just forgot to write "enum",
920	// "struct", or "union".
921	if (!getLangOpts().CPlusPlus && !SecondTry &&
922	isTagTypeWithMissingTag(*this, Result, S, SS, Name, NameLoc)) {
923	break;
924	}
925
926	// Perform typo correction to determine if there is another name that is
927	// close to this name.
928	if (!SecondTry && CCC) {
929	SecondTry = true;
930	if (TypoCorrection Corrected = CorrectTypo(Result.getLookupNameInfo(),
931	Result.getLookupKind(), S,
932	&SS, std::move(CCC),
933	CTK_ErrorRecovery)) {
934	unsigned UnqualifiedDiag = diag::err_undeclared_var_use_suggest;
935	unsigned QualifiedDiag = diag::err_no_member_suggest;
936
937	NamedDecl *FirstDecl = Corrected.getFoundDecl();
938	NamedDecl *UnderlyingFirstDecl = Corrected.getCorrectionDecl();
939	if (getLangOpts().CPlusPlus && NextToken.is(tok::less) &&
940	UnderlyingFirstDecl && isa<TemplateDecl>(UnderlyingFirstDecl)) {
941	UnqualifiedDiag = diag::err_no_template_suggest;
942	QualifiedDiag = diag::err_no_member_template_suggest;
943	} else if (UnderlyingFirstDecl &&
944	(isa<TypeDecl>(UnderlyingFirstDecl) \|\|
945	isa<ObjCInterfaceDecl>(UnderlyingFirstDecl) \|\|
946	isa<ObjCCompatibleAliasDecl>(UnderlyingFirstDecl))) {
947	UnqualifiedDiag = diag::err_unknown_typename_suggest;
948	QualifiedDiag = diag::err_unknown_nested_typename_suggest;
949	}
950
951	if (SS.isEmpty()) {
952	diagnoseTypo(Corrected, PDiag(UnqualifiedDiag) << Name);
953	} else {// FIXME: is this even reachable? Test it.
954	std::string CorrectedStr(Corrected.getAsString(getLangOpts()));
955	bool DroppedSpecifier = Corrected.WillReplaceSpecifier() &&
956	Name->getName().equals(CorrectedStr);
957	diagnoseTypo(Corrected, PDiag(QualifiedDiag)
958	<< Name << computeDeclContext(SS, false)
959	<< DroppedSpecifier << SS.getRange());
960	}
961
962	// Update the name, so that the caller has the new name.
963	Name = Corrected.getCorrectionAsIdentifierInfo();
964
965	// Typo correction corrected to a keyword.
966	if (Corrected.isKeyword())
967	return Name;
968
969	// Also update the LookupResult...
970	// FIXME: This should probably go away at some point
971	Result.clear();
972	Result.setLookupName(Corrected.getCorrection());
973	if (FirstDecl)
974	Result.addDecl(FirstDecl);
975
976	// If we found an Objective-C instance variable, let
977	// LookupInObjCMethod build the appropriate expression to
978	// reference the ivar.
979	// FIXME: This is a gross hack.
980	if (ObjCIvarDecl *Ivar = Result.getAsSingle<ObjCIvarDecl>()) {
981	Result.clear();
982	ExprResult E(LookupInObjCMethod(Result, S, Ivar->getIdentifier()));
983	return E;
984	}
985
986	goto Corrected;
987	}
988	}
989
990	// We failed to correct; just fall through and let the parser deal with it.
991	Result.suppressDiagnostics();
992	return NameClassification::Unknown();
993
994	case LookupResult::NotFoundInCurrentInstantiation: {
995	// We performed name lookup into the current instantiation, and there were
996	// dependent bases, so we treat this result the same way as any other
997	// dependent nested-name-specifier.
998
999	// C++ [temp.res]p2:
1000	// A name used in a template declaration or definition and that is
1001	// dependent on a template-parameter is assumed not to name a type
1002	// unless the applicable name lookup finds a type name or the name is
1003	// qualified by the keyword typename.
1004	//
1005	// FIXME: If the next token is '<', we might want to ask the parser to
1006	// perform some heroics to see if we actually have a
1007	// template-argument-list, which would indicate a missing 'template'
1008	// keyword here.
1009	return ActOnDependentIdExpression(SS, /TemplateKWLoc=/SourceLocation(),
1010	NameInfo, IsAddressOfOperand,
1011	/TemplateArgs=/nullptr);
1012	}
1013
1014	case LookupResult::Found:
1015	case LookupResult::FoundOverloaded:
1016	case LookupResult::FoundUnresolvedValue:
1017	break;
1018
1019	case LookupResult::Ambiguous:
1020	if (getLangOpts().CPlusPlus && NextToken.is(tok::less) &&
1021	hasAnyAcceptableTemplateNames(Result)) {
1022	// C++ [temp.local]p3:
1023	// A lookup that finds an injected-class-name (10.2) can result in an
1024	// ambiguity in certain cases (for example, if it is found in more than
1025	// one base class). If all of the injected-class-names that are found
1026	// refer to specializations of the same class template, and if the name
1027	// is followed by a template-argument-list, the reference refers to the
1028	// class template itself and not a specialization thereof, and is not
1029	// ambiguous.
1030	//
1031	// This filtering can make an ambiguous result into an unambiguous one,
1032	// so try again after filtering out template names.
1033	FilterAcceptableTemplateNames(Result);
1034	if (!Result.isAmbiguous()) {
1035	IsFilteredTemplateName = true;
1036	break;
1037	}
1038	}
1039
1040	// Diagnose the ambiguity and return an error.
1041	return NameClassification::Error();
1042	}
1043
1044	if (getLangOpts().CPlusPlus && NextToken.is(tok::less) &&
1045	(IsFilteredTemplateName \|\| hasAnyAcceptableTemplateNames(Result))) {
1046	// C++ [temp.names]p3:
1047	// After name lookup (3.4) finds that a name is a template-name or that
1048	// an operator-function-id or a literal- operator-id refers to a set of
1049	// overloaded functions any member of which is a function template if
1050	// this is followed by a <, the < is always taken as the delimiter of a
1051	// template-argument-list and never as the less-than operator.
1052	if (!IsFilteredTemplateName)
1053	FilterAcceptableTemplateNames(Result);
1054
1055	if (!Result.empty()) {
1056	bool IsFunctionTemplate;
1057	bool IsVarTemplate;
1058	TemplateName Template;
1059	if (Result.end() - Result.begin() > 1) {
1060	IsFunctionTemplate = true;
1061	Template = Context.getOverloadedTemplateName(Result.begin(),
1062	Result.end());
1063	} else {
1064	TemplateDecl *TD
1065	= cast<TemplateDecl>((*Result.begin())->getUnderlyingDecl());
1066	IsFunctionTemplate = isa<FunctionTemplateDecl>(TD);
1067	IsVarTemplate = isa<VarTemplateDecl>(TD);
1068
1069	if (SS.isSet() && !SS.isInvalid())
1070	Template = Context.getQualifiedTemplateName(SS.getScopeRep(),
1071	/TemplateKeyword=/false,
1072	TD);
1073	else
1074	Template = TemplateName(TD);
1075	}
1076
1077	if (IsFunctionTemplate) {
1078	// Function templates always go through overload resolution, at which
1079	// point we'll perform the various checks (e.g., accessibility) we need
1080	// to based on which function we selected.
1081	Result.suppressDiagnostics();
1082
1083	return NameClassification::FunctionTemplate(Template);
1084	}
1085
1086	return IsVarTemplate ? NameClassification::VarTemplate(Template)
1087	: NameClassification::TypeTemplate(Template);
1088	}
1089	}
1090
1091	NamedDecl FirstDecl = (Result.begin())->getUnderlyingDecl();
1092	if (TypeDecl *Type = dyn_cast<TypeDecl>(FirstDecl)) {
1093	DiagnoseUseOfDecl(Type, NameLoc);
1094	MarkAnyDeclReferenced(Type->getLocation(), Type, /OdrUse=/false);
1095	QualType T = Context.getTypeDeclType(Type);
1096	if (SS.isNotEmpty())
1097	return buildNestedType(*this, SS, T, NameLoc);
1098	return ParsedType::make(T);
1099	}
1100
1101	ObjCInterfaceDecl *Class = dyn_cast<ObjCInterfaceDecl>(FirstDecl);
1102	if (!Class) {
1103	// FIXME: It's unfortunate that we don't have a Type node for handling this.
1104	if (ObjCCompatibleAliasDecl *Alias =
1105	dyn_cast<ObjCCompatibleAliasDecl>(FirstDecl))
1106	Class = Alias->getClassInterface();
1107	}
1108
1109	if (Class) {
1110	DiagnoseUseOfDecl(Class, NameLoc);
1111
1112	if (NextToken.is(tok::period)) {
1113	// Interface. <something> is parsed as a property reference expression.
1114	// Just return "unknown" as a fall-through for now.
1115	Result.suppressDiagnostics();
1116	return NameClassification::Unknown();
1117	}
1118
1119	QualType T = Context.getObjCInterfaceType(Class);
1120	return ParsedType::make(T);
1121	}
1122
1123	// We can have a type template here if we're classifying a template argument.
1124	if (isa<TemplateDecl>(FirstDecl) && !isa<FunctionTemplateDecl>(FirstDecl) &&
1125	!isa<VarTemplateDecl>(FirstDecl))
1126	return NameClassification::TypeTemplate(
1127	TemplateName(cast<TemplateDecl>(FirstDecl)));
1128
1129	// Check for a tag type hidden by a non-type decl in a few cases where it
1130	// seems likely a type is wanted instead of the non-type that was found.
1131	bool NextIsOp = NextToken.isOneOf(tok::amp, tok::star);
1132	if ((NextToken.is(tok::identifier) \|\|
1133	(NextIsOp &&
1134	FirstDecl->getUnderlyingDecl()->isFunctionOrFunctionTemplate())) &&
1135	isTagTypeWithMissingTag(*this, Result, S, SS, Name, NameLoc)) {
1136	TypeDecl *Type = Result.getAsSingle<TypeDecl>();
1137	DiagnoseUseOfDecl(Type, NameLoc);
1138	QualType T = Context.getTypeDeclType(Type);
1139	if (SS.isNotEmpty())
1140	return buildNestedType(*this, SS, T, NameLoc);
1141	return ParsedType::make(T);
1142	}
1143
1144	if (FirstDecl->isCXXClassMember())
1145	return BuildPossibleImplicitMemberExpr(SS, SourceLocation(), Result,
1146	nullptr, S);
1147
1148	bool ADL = UseArgumentDependentLookup(SS, Result, NextToken.is(tok::l_paren));
1149	return BuildDeclarationNameExpr(SS, Result, ADL);
1150	}
1151
1152	Sema::TemplateNameKindForDiagnostics
1153	Sema::getTemplateNameKindForDiagnostics(TemplateName Name) {
1154	auto *TD = Name.getAsTemplateDecl();
1155	if (!TD)
1156	return TemplateNameKindForDiagnostics::DependentTemplate;
1157	if (isa<ClassTemplateDecl>(TD))
1158	return TemplateNameKindForDiagnostics::ClassTemplate;
1159	if (isa<FunctionTemplateDecl>(TD))
1160	return TemplateNameKindForDiagnostics::FunctionTemplate;
1161	if (isa<VarTemplateDecl>(TD))
1162	return TemplateNameKindForDiagnostics::VarTemplate;
1163	if (isa<TypeAliasTemplateDecl>(TD))
1164	return TemplateNameKindForDiagnostics::AliasTemplate;
1165	if (isa<TemplateTemplateParmDecl>(TD))
1166	return TemplateNameKindForDiagnostics::TemplateTemplateParam;
1167	return TemplateNameKindForDiagnostics::DependentTemplate;
1168	}
1169
1170	// Determines the context to return to after temporarily entering a
1171	// context. This depends in an unnecessarily complicated way on the
1172	// exact ordering of callbacks from the parser.
1173	DeclContext Sema::getContainingDC(DeclContext DC) {
1174
1175	// Functions defined inline within classes aren't parsed until we've
1176	// finished parsing the top-level class, so the top-level class is
1177	// the context we'll need to return to.
1178	// A Lambda call operator whose parent is a class must not be treated
1179	// as an inline member function. A Lambda can be used legally
1180	// either as an in-class member initializer or a default argument. These
1181	// are parsed once the class has been marked complete and so the containing
1182	// context would be the nested class (when the lambda is defined in one);
1183	// If the class is not complete, then the lambda is being used in an
1184	// ill-formed fashion (such as to specify the width of a bit-field, or
1185	// in an array-bound) - in which case we still want to return the
1186	// lexically containing DC (which could be a nested class).
1187	if (isa<FunctionDecl>(DC) && !isLambdaCallOperator(DC)) {
1188	DC = DC->getLexicalParent();
1189
1190	// A function not defined within a class will always return to its
1191	// lexical context.
1192	if (!isa<CXXRecordDecl>(DC))
1193	return DC;
1194
1195	// A C++ inline method/friend is parsed after the topmost class
1196	// it was declared in is fully parsed ("complete"); the topmost
1197	// class is the context we need to return to.
1198	while (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(DC->getLexicalParent()))
1199	DC = RD;
1200
1201	// Return the declaration context of the topmost class the inline method is
1202	// declared in.
1203	return DC;
1204	}
1205
1206	return DC->getLexicalParent();
1207	}
1208
1209	void Sema::PushDeclContext(Scope S, DeclContext DC) {
1210	assert(getContainingDC(DC) == CurContext &&((getContainingDC(DC) == CurContext && "The next DeclContext should be lexically contained in the current one." ) ? static_cast<void> (0) : __assert_fail ("getContainingDC(DC) == CurContext && \"The next DeclContext should be lexically contained in the current one.\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 1211, __PRETTY_FUNCTION__))
1211	"The next DeclContext should be lexically contained in the current one.")((getContainingDC(DC) == CurContext && "The next DeclContext should be lexically contained in the current one." ) ? static_cast<void> (0) : __assert_fail ("getContainingDC(DC) == CurContext && \"The next DeclContext should be lexically contained in the current one.\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 1211, __PRETTY_FUNCTION__));
1212	CurContext = DC;
1213	S->setEntity(DC);
1214	}
1215
1216	void Sema::PopDeclContext() {
1217	assert(CurContext && "DeclContext imbalance!")((CurContext && "DeclContext imbalance!") ? static_cast <void> (0) : __assert_fail ("CurContext && \"DeclContext imbalance!\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 1217, __PRETTY_FUNCTION__));
1218
1219	CurContext = getContainingDC(CurContext);
1220	assert(CurContext && "Popped translation unit!")((CurContext && "Popped translation unit!") ? static_cast <void> (0) : __assert_fail ("CurContext && \"Popped translation unit!\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 1220, __PRETTY_FUNCTION__));
1221	}
1222
1223	Sema::SkippedDefinitionContext Sema::ActOnTagStartSkippedDefinition(Scope *S,
1224	Decl *D) {
1225	// Unlike PushDeclContext, the context to which we return is not necessarily
1226	// the containing DC of TD, because the new context will be some pre-existing
1227	// TagDecl definition instead of a fresh one.
1228	auto Result = static_cast<SkippedDefinitionContext>(CurContext);
1229	CurContext = cast<TagDecl>(D)->getDefinition();
1230	assert(CurContext && "skipping definition of undefined tag")((CurContext && "skipping definition of undefined tag" ) ? static_cast<void> (0) : __assert_fail ("CurContext && \"skipping definition of undefined tag\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 1230, __PRETTY_FUNCTION__));
1231	// Start lookups from the parent of the current context; we don't want to look
1232	// into the pre-existing complete definition.
1233	S->setEntity(CurContext->getLookupParent());
1234	return Result;
1235	}
1236
1237	void Sema::ActOnTagFinishSkippedDefinition(SkippedDefinitionContext Context) {
1238	CurContext = static_cast<decltype(CurContext)>(Context);
1239	}
1240
1241	/// EnterDeclaratorContext - Used when we must lookup names in the context
1242	/// of a declarator's nested name specifier.
1243	///
1244	void Sema::EnterDeclaratorContext(Scope S, DeclContext DC) {
1245	// C++0x [basic.lookup.unqual]p13:
1246	// A name used in the definition of a static data member of class
1247	// X (after the qualified-id of the static member) is looked up as
1248	// if the name was used in a member function of X.
1249	// C++0x [basic.lookup.unqual]p14:
1250	// If a variable member of a namespace is defined outside of the
1251	// scope of its namespace then any name used in the definition of
1252	// the variable member (after the declarator-id) is looked up as
1253	// if the definition of the variable member occurred in its
1254	// namespace.
1255	// Both of these imply that we should push a scope whose context
1256	// is the semantic context of the declaration. We can't use
1257	// PushDeclContext here because that context is not necessarily
1258	// lexically contained in the current context. Fortunately,
1259	// the containing scope should have the appropriate information.
1260
1261	assert(!S->getEntity() && "scope already has entity")((!S->getEntity() && "scope already has entity") ? static_cast<void> (0) : __assert_fail ("!S->getEntity() && \"scope already has entity\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 1261, __PRETTY_FUNCTION__));
1262
1263	#ifndef NDEBUG
1264	Scope *Ancestor = S->getParent();
1265	while (!Ancestor->getEntity()) Ancestor = Ancestor->getParent();
1266	assert(Ancestor->getEntity() == CurContext && "ancestor context mismatch")((Ancestor->getEntity() == CurContext && "ancestor context mismatch" ) ? static_cast<void> (0) : __assert_fail ("Ancestor->getEntity() == CurContext && \"ancestor context mismatch\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 1266, __PRETTY_FUNCTION__));
1267	#endif
1268
1269	CurContext = DC;
1270	S->setEntity(DC);
1271	}
1272
1273	void Sema::ExitDeclaratorContext(Scope *S) {
1274	assert(S->getEntity() == CurContext && "Context imbalance!")((S->getEntity() == CurContext && "Context imbalance!" ) ? static_cast<void> (0) : __assert_fail ("S->getEntity() == CurContext && \"Context imbalance!\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 1274, __PRETTY_FUNCTION__));
1275
1276	// Switch back to the lexical context. The safety of this is
1277	// enforced by an assert in EnterDeclaratorContext.
1278	Scope *Ancestor = S->getParent();
1279	while (!Ancestor->getEntity()) Ancestor = Ancestor->getParent();
1280	CurContext = Ancestor->getEntity();
1281
1282	// We don't need to do anything with the scope, which is going to
1283	// disappear.
1284	}
1285
1286	void Sema::ActOnReenterFunctionContext(Scope* S, Decl *D) {
1287	// We assume that the caller has already called
1288	// ActOnReenterTemplateScope so getTemplatedDecl() works.
1289	FunctionDecl *FD = D->getAsFunction();
1290	if (!FD)
1291	return;
1292
1293	// Same implementation as PushDeclContext, but enters the context
1294	// from the lexical parent, rather than the top-level class.
1295	assert(CurContext == FD->getLexicalParent() &&((CurContext == FD->getLexicalParent() && "The next DeclContext should be lexically contained in the current one." ) ? static_cast<void> (0) : __assert_fail ("CurContext == FD->getLexicalParent() && \"The next DeclContext should be lexically contained in the current one.\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 1296, __PRETTY_FUNCTION__))
1296	"The next DeclContext should be lexically contained in the current one.")((CurContext == FD->getLexicalParent() && "The next DeclContext should be lexically contained in the current one." ) ? static_cast<void> (0) : __assert_fail ("CurContext == FD->getLexicalParent() && \"The next DeclContext should be lexically contained in the current one.\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 1296, __PRETTY_FUNCTION__));
1297	CurContext = FD;
1298	S->setEntity(CurContext);
1299
1300	for (unsigned P = 0, NumParams = FD->getNumParams(); P < NumParams; ++P) {
1301	ParmVarDecl *Param = FD->getParamDecl(P);
1302	// If the parameter has an identifier, then add it to the scope
1303	if (Param->getIdentifier()) {
1304	S->AddDecl(Param);
1305	IdResolver.AddDecl(Param);
1306	}
1307	}
1308	}
1309
1310	void Sema::ActOnExitFunctionContext() {
1311	// Same implementation as PopDeclContext, but returns to the lexical parent,
1312	// rather than the top-level class.
1313	assert(CurContext && "DeclContext imbalance!")((CurContext && "DeclContext imbalance!") ? static_cast <void> (0) : __assert_fail ("CurContext && \"DeclContext imbalance!\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 1313, __PRETTY_FUNCTION__));
1314	CurContext = CurContext->getLexicalParent();
1315	assert(CurContext && "Popped translation unit!")((CurContext && "Popped translation unit!") ? static_cast <void> (0) : __assert_fail ("CurContext && \"Popped translation unit!\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 1315, __PRETTY_FUNCTION__));
1316	}
1317
1318	/// Determine whether we allow overloading of the function
1319	/// PrevDecl with another declaration.
1320	///
1321	/// This routine determines whether overloading is possible, not
1322	/// whether some new function is actually an overload. It will return
1323	/// true in C++ (where we can always provide overloads) or, as an
1324	/// extension, in C when the previous function is already an
1325	/// overloaded function declaration or has the "overloadable"
1326	/// attribute.
1327	static bool AllowOverloadingOfFunction(LookupResult &Previous,
1328	ASTContext &Context,
1329	const FunctionDecl *New) {
1330	if (Context.getLangOpts().CPlusPlus)
1331	return true;
1332
1333	if (Previous.getResultKind() == LookupResult::FoundOverloaded)
1334	return true;
1335
1336	return Previous.getResultKind() == LookupResult::Found &&
1337	(Previous.getFoundDecl()->hasAttr<OverloadableAttr>() \|\|
1338	New->hasAttr<OverloadableAttr>());
1339	}
1340
1341	/// Add this decl to the scope shadowed decl chains.
1342	void Sema::PushOnScopeChains(NamedDecl D, Scope S, bool AddToContext) {
1343	// Move up the scope chain until we find the nearest enclosing
1344	// non-transparent context. The declaration will be introduced into this
1345	// scope.
1346	while (S->getEntity() && S->getEntity()->isTransparentContext())
1347	S = S->getParent();
1348
1349	// Add scoped declarations into their context, so that they can be
1350	// found later. Declarations without a context won't be inserted
1351	// into any context.
1352	if (AddToContext)
1353	CurContext->addDecl(D);
1354
1355	// Out-of-line definitions shouldn't be pushed into scope in C++, unless they
1356	// are function-local declarations.
1357	if (getLangOpts().CPlusPlus && D->isOutOfLine() &&
1358	!D->getDeclContext()->getRedeclContext()->Equals(
1359	D->getLexicalDeclContext()->getRedeclContext()) &&
1360	!D->getLexicalDeclContext()->isFunctionOrMethod())
1361	return;
1362
1363	// Template instantiations should also not be pushed into scope.
1364	if (isa<FunctionDecl>(D) &&
1365	cast<FunctionDecl>(D)->isFunctionTemplateSpecialization())
1366	return;
1367
1368	// If this replaces anything in the current scope,
1369	IdentifierResolver::iterator I = IdResolver.begin(D->getDeclName()),
1370	IEnd = IdResolver.end();
1371	for (; I != IEnd; ++I) {
1372	if (S->isDeclScope(I) && D->declarationReplaces(I)) {
1373	S->RemoveDecl(*I);
1374	IdResolver.RemoveDecl(*I);
1375
1376	// Should only need to replace one decl.
1377	break;
1378	}
1379	}
1380
1381	S->AddDecl(D);
1382
1383	if (isa<LabelDecl>(D) && !cast<LabelDecl>(D)->isGnuLocal()) {
1384	// Implicitly-generated labels may end up getting generated in an order that
1385	// isn't strictly lexical, which breaks name lookup. Be careful to insert
1386	// the label at the appropriate place in the identifier chain.
1387	for (I = IdResolver.begin(D->getDeclName()); I != IEnd; ++I) {
1388	DeclContext IDC = (I)->getLexicalDeclContext()->getRedeclContext();
1389	if (IDC == CurContext) {
1390	if (!S->isDeclScope(*I))
1391	continue;
1392	} else if (IDC->Encloses(CurContext))
1393	break;
1394	}
1395
1396	IdResolver.InsertDeclAfter(I, D);
1397	} else {
1398	IdResolver.AddDecl(D);
1399	}
1400	}
1401
1402	void Sema::pushExternalDeclIntoScope(NamedDecl *D, DeclarationName Name) {
1403	if (IdResolver.tryAddTopLevelDecl(D, Name) && TUScope)
1404	TUScope->AddDecl(D);
1405	}
1406
1407	bool Sema::isDeclInScope(NamedDecl D, DeclContext Ctx, Scope *S,
1408	bool AllowInlineNamespace) {
1409	return IdResolver.isDeclInScope(D, Ctx, S, AllowInlineNamespace);
1410	}
1411
1412	Scope Sema::getScopeForDeclContext(Scope S, DeclContext *DC) {
1413	DeclContext *TargetDC = DC->getPrimaryContext();
1414	do {
1415	if (DeclContext *ScopeDC = S->getEntity())
1416	if (ScopeDC->getPrimaryContext() == TargetDC)
1417	return S;
1418	} while ((S = S->getParent()));
1419
1420	return nullptr;
1421	}
1422
1423	static bool isOutOfScopePreviousDeclaration(NamedDecl *,
1424	DeclContext*,
1425	ASTContext&);
1426
1427	/// Filters out lookup results that don't fall within the given scope
1428	/// as determined by isDeclInScope.
1429	void Sema::FilterLookupForScope(LookupResult &R, DeclContext Ctx, Scope S,
1430	bool ConsiderLinkage,
1431	bool AllowInlineNamespace) {
1432	LookupResult::Filter F = R.makeFilter();
1433	while (F.hasNext()) {
1434	NamedDecl *D = F.next();
1435
1436	if (isDeclInScope(D, Ctx, S, AllowInlineNamespace))
1437	continue;
1438
1439	if (ConsiderLinkage && isOutOfScopePreviousDeclaration(D, Ctx, Context))
1440	continue;
1441
1442	F.erase();
1443	}
1444
1445	F.done();
1446	}
1447
1448	/// We've determined that \p New is a redeclaration of \p Old. Check that they
1449	/// have compatible owning modules.
1450	bool Sema::CheckRedeclarationModuleOwnership(NamedDecl New, NamedDecl Old) {
1451	// FIXME: The Modules TS is not clear about how friend declarations are
1452	// to be treated. It's not meaningful to have different owning modules for
1453	// linkage in redeclarations of the same entity, so for now allow the
1454	// redeclaration and change the owning modules to match.
1455	if (New->getFriendObjectKind() &&
1456	Old->getOwningModuleForLinkage() != New->getOwningModuleForLinkage()) {
1457	New->setLocalOwningModule(Old->getOwningModule());
1458	makeMergedDefinitionVisible(New);
1459	return false;
1460	}
1461
1462	Module *NewM = New->getOwningModule();
1463	Module *OldM = Old->getOwningModule();
1464	if (NewM == OldM)
1465	return false;
1466
1467	// FIXME: Check proclaimed-ownership-declarations here too.
1468	bool NewIsModuleInterface = NewM && NewM->Kind == Module::ModuleInterfaceUnit;
1469	bool OldIsModuleInterface = OldM && OldM->Kind == Module::ModuleInterfaceUnit;
1470	if (NewIsModuleInterface \|\| OldIsModuleInterface) {
1471	// C++ Modules TS [basic.def.odr] 6.2/6.7 [sic]:
1472	// if a declaration of D [...] appears in the purview of a module, all
1473	// other such declarations shall appear in the purview of the same module
1474	Diag(New->getLocation(), diag::err_mismatched_owning_module)
1475	<< New
1476	<< NewIsModuleInterface
1477	<< (NewIsModuleInterface ? NewM->getFullModuleName() : "")
1478	<< OldIsModuleInterface
1479	<< (OldIsModuleInterface ? OldM->getFullModuleName() : "");
1480	Diag(Old->getLocation(), diag::note_previous_declaration);
1481	New->setInvalidDecl();
1482	return true;
1483	}
1484
1485	return false;
1486	}
1487
1488	static bool isUsingDecl(NamedDecl *D) {
1489	return isa<UsingShadowDecl>(D) \|\|
1490	isa<UnresolvedUsingTypenameDecl>(D) \|\|
1491	isa<UnresolvedUsingValueDecl>(D);
1492	}
1493
1494	/// Removes using shadow declarations from the lookup results.
1495	static void RemoveUsingDecls(LookupResult &R) {
1496	LookupResult::Filter F = R.makeFilter();
1497	while (F.hasNext())
1498	if (isUsingDecl(F.next()))
1499	F.erase();
1500
1501	F.done();
1502	}
1503
1504	/// Check for this common pattern:
1505	/// @code
1506	/// class S {
1507	/// S(const S&); // DO NOT IMPLEMENT
1508	/// void operator=(const S&); // DO NOT IMPLEMENT
1509	/// };
1510	/// @endcode
1511	static bool IsDisallowedCopyOrAssign(const CXXMethodDecl *D) {
1512	// FIXME: Should check for private access too but access is set after we get
1513	// the decl here.
1514	if (D->doesThisDeclarationHaveABody())
1515	return false;
1516
1517	if (const CXXConstructorDecl *CD = dyn_cast<CXXConstructorDecl>(D))
1518	return CD->isCopyConstructor();
1519	return D->isCopyAssignmentOperator();
1520	}
1521
1522	// We need this to handle
1523	//
1524	// typedef struct {
1525	// void *foo() { return 0; }
1526	// } A;
1527	//
1528	// When we see foo we don't know if after the typedef we will get 'A' or '*A'
1529	// for example. If 'A', foo will have external linkage. If we have '*A',
1530	// foo will have no linkage. Since we can't know until we get to the end
1531	// of the typedef, this function finds out if D might have non-external linkage.
1532	// Callers should verify at the end of the TU if it D has external linkage or
1533	// not.
1534	bool Sema::mightHaveNonExternalLinkage(const DeclaratorDecl *D) {
1535	const DeclContext *DC = D->getDeclContext();
1536	while (!DC->isTranslationUnit()) {
1537	if (const RecordDecl *RD = dyn_cast<RecordDecl>(DC)){
1538	if (!RD->hasNameForLinkage())
1539	return true;
1540	}
1541	DC = DC->getParent();
1542	}
1543
1544	return !D->isExternallyVisible();
1545	}
1546
1547	// FIXME: This needs to be refactored; some other isInMainFile users want
1548	// these semantics.
1549	static bool isMainFileLoc(const Sema &S, SourceLocation Loc) {
1550	if (S.TUKind != TU_Complete)
1551	return false;
1552	return S.SourceMgr.isInMainFile(Loc);
1553	}
1554
1555	bool Sema::ShouldWarnIfUnusedFileScopedDecl(const DeclaratorDecl *D) const {
1556	assert(D)((D) ? static_cast<void> (0) : __assert_fail ("D", "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 1556, __PRETTY_FUNCTION__));
1557
1558	if (D->isInvalidDecl() \|\| D->isUsed() \|\| D->hasAttr<UnusedAttr>())
1559	return false;
1560
1561	// Ignore all entities declared within templates, and out-of-line definitions
1562	// of members of class templates.
1563	if (D->getDeclContext()->isDependentContext() \|\|
1564	D->getLexicalDeclContext()->isDependentContext())
1565	return false;
1566
1567	if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
1568	if (FD->getTemplateSpecializationKind() == TSK_ImplicitInstantiation)
1569	return false;
1570	// A non-out-of-line declaration of a member specialization was implicitly
1571	// instantiated; it's the out-of-line declaration that we're interested in.
1572	if (FD->getTemplateSpecializationKind() == TSK_ExplicitSpecialization &&
1573	FD->getMemberSpecializationInfo() && !FD->isOutOfLine())
1574	return false;
1575
1576	if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) {
1577	if (MD->isVirtual() \|\| IsDisallowedCopyOrAssign(MD))
1578	return false;
1579	} else {
1580	// 'static inline' functions are defined in headers; don't warn.
1581	if (FD->isInlined() && !isMainFileLoc(*this, FD->getLocation()))
1582	return false;
1583	}
1584
1585	if (FD->doesThisDeclarationHaveABody() &&
1586	Context.DeclMustBeEmitted(FD))
1587	return false;
1588	} else if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
1589	// Constants and utility variables are defined in headers with internal
1590	// linkage; don't warn. (Unlike functions, there isn't a convenient marker
1591	// like "inline".)
1592	if (!isMainFileLoc(*this, VD->getLocation()))
1593	return false;
1594
1595	if (Context.DeclMustBeEmitted(VD))
1596	return false;
1597
1598	if (VD->isStaticDataMember() &&
1599	VD->getTemplateSpecializationKind() == TSK_ImplicitInstantiation)
1600	return false;
1601	if (VD->isStaticDataMember() &&
1602	VD->getTemplateSpecializationKind() == TSK_ExplicitSpecialization &&
1603	VD->getMemberSpecializationInfo() && !VD->isOutOfLine())
1604	return false;
1605
1606	if (VD->isInline() && !isMainFileLoc(*this, VD->getLocation()))
1607	return false;
1608	} else {
1609	return false;
1610	}
1611
1612	// Only warn for unused decls internal to the translation unit.
1613	// FIXME: This seems like a bogus check; it suppresses -Wunused-function
1614	// for inline functions defined in the main source file, for instance.
1615	return mightHaveNonExternalLinkage(D);
1616	}
1617
1618	void Sema::MarkUnusedFileScopedDecl(const DeclaratorDecl *D) {
1619	if (!D)
1620	return;
1621
1622	if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
1623	const FunctionDecl *First = FD->getFirstDecl();
1624	if (FD != First && ShouldWarnIfUnusedFileScopedDecl(First))
1625	return; // First should already be in the vector.
1626	}
1627
1628	if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
1629	const VarDecl *First = VD->getFirstDecl();
1630	if (VD != First && ShouldWarnIfUnusedFileScopedDecl(First))
1631	return; // First should already be in the vector.
1632	}
1633
1634	if (ShouldWarnIfUnusedFileScopedDecl(D))
1635	UnusedFileScopedDecls.push_back(D);
1636	}
1637
1638	static bool ShouldDiagnoseUnusedDecl(const NamedDecl *D) {
1639	if (D->isInvalidDecl())
1640	return false;
1641
1642	bool Referenced = false;
1643	if (auto *DD = dyn_cast<DecompositionDecl>(D)) {
1644	// For a decomposition declaration, warn if none of the bindings are
1645	// referenced, instead of if the variable itself is referenced (which
1646	// it is, by the bindings' expressions).
1647	for (auto *BD : DD->bindings()) {
1648	if (BD->isReferenced()) {
1649	Referenced = true;
1650	break;
1651	}
1652	}
1653	} else if (!D->getDeclName()) {
1654	return false;
1655	} else if (D->isReferenced() \|\| D->isUsed()) {
1656	Referenced = true;
1657	}
1658
1659	if (Referenced \|\| D->hasAttr<UnusedAttr>() \|\|
1660	D->hasAttr<ObjCPreciseLifetimeAttr>())
1661	return false;
1662
1663	if (isa<LabelDecl>(D))
1664	return true;
1665
1666	// Except for labels, we only care about unused decls that are local to
1667	// functions.
1668	bool WithinFunction = D->getDeclContext()->isFunctionOrMethod();
1669	if (const auto *R = dyn_cast<CXXRecordDecl>(D->getDeclContext()))
1670	// For dependent types, the diagnostic is deferred.
1671	WithinFunction =
1672	WithinFunction \|\| (R->isLocalClass() && !R->isDependentType());
1673	if (!WithinFunction)
1674	return false;
1675
1676	if (isa<TypedefNameDecl>(D))
1677	return true;
1678
1679	// White-list anything that isn't a local variable.
1680	if (!isa<VarDecl>(D) \|\| isa<ParmVarDecl>(D) \|\| isa<ImplicitParamDecl>(D))
1681	return false;
1682
1683	// Types of valid local variables should be complete, so this should succeed.
1684	if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
1685
1686	// White-list anything with an __attribute__((unused)) type.
1687	const auto *Ty = VD->getType().getTypePtr();
1688
1689	// Only look at the outermost level of typedef.
1690	if (const TypedefType *TT = Ty->getAs<TypedefType>()) {
1691	if (TT->getDecl()->hasAttr<UnusedAttr>())
1692	return false;
1693	}
1694
1695	// If we failed to complete the type for some reason, or if the type is
1696	// dependent, don't diagnose the variable.
1697	if (Ty->isIncompleteType() \|\| Ty->isDependentType())
1698	return false;
1699
1700	// Look at the element type to ensure that the warning behaviour is
1701	// consistent for both scalars and arrays.
1702	Ty = Ty->getBaseElementTypeUnsafe();
1703
1704	if (const TagType *TT = Ty->getAs<TagType>()) {
1705	const TagDecl *Tag = TT->getDecl();
1706	if (Tag->hasAttr<UnusedAttr>())
1707	return false;
1708
1709	if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(Tag)) {
1710	if (!RD->hasTrivialDestructor() && !RD->hasAttr<WarnUnusedAttr>())
1711	return false;
1712
1713	if (const Expr *Init = VD->getInit()) {
1714	if (const ExprWithCleanups *Cleanups =
1715	dyn_cast<ExprWithCleanups>(Init))
1716	Init = Cleanups->getSubExpr();
1717	const CXXConstructExpr *Construct =
1718	dyn_cast<CXXConstructExpr>(Init);
1719	if (Construct && !Construct->isElidable()) {
1720	CXXConstructorDecl *CD = Construct->getConstructor();
1721	if (!CD->isTrivial() && !RD->hasAttr<WarnUnusedAttr>() &&
1722	(VD->getInit()->isValueDependent() \|\| !VD->evaluateValue()))
1723	return false;
1724	}
1725	}
1726	}
1727	}
1728
1729	// TODO: __attribute__((unused)) templates?
1730	}
1731
1732	return true;
1733	}
1734
1735	static void GenerateFixForUnusedDecl(const NamedDecl *D, ASTContext &Ctx,
1736	FixItHint &Hint) {
1737	if (isa<LabelDecl>(D)) {
1738	SourceLocation AfterColon = Lexer::findLocationAfterToken(
1739	D->getEndLoc(), tok::colon, Ctx.getSourceManager(), Ctx.getLangOpts(),
1740	true);
1741	if (AfterColon.isInvalid())
1742	return;
1743	Hint = FixItHint::CreateRemoval(
1744	CharSourceRange::getCharRange(D->getBeginLoc(), AfterColon));
1745	}
1746	}
1747
1748	void Sema::DiagnoseUnusedNestedTypedefs(const RecordDecl *D) {
1749	if (D->getTypeForDecl()->isDependentType())
1750	return;
1751
1752	for (auto *TmpD : D->decls()) {
1753	if (const auto *T = dyn_cast<TypedefNameDecl>(TmpD))
1754	DiagnoseUnusedDecl(T);
1755	else if(const auto *R = dyn_cast<RecordDecl>(TmpD))
1756	DiagnoseUnusedNestedTypedefs(R);
1757	}
1758	}
1759
1760	/// DiagnoseUnusedDecl - Emit warnings about declarations that are not used
1761	/// unless they are marked attr(unused).
1762	void Sema::DiagnoseUnusedDecl(const NamedDecl *D) {
1763	if (!ShouldDiagnoseUnusedDecl(D))
1764	return;
1765
1766	if (auto *TD = dyn_cast<TypedefNameDecl>(D)) {
1767	// typedefs can be referenced later on, so the diagnostics are emitted
1768	// at end-of-translation-unit.
1769	UnusedLocalTypedefNameCandidates.insert(TD);
1770	return;
1771	}
1772
1773	FixItHint Hint;
1774	GenerateFixForUnusedDecl(D, Context, Hint);
1775
1776	unsigned DiagID;
1777	if (isa<VarDecl>(D) && cast<VarDecl>(D)->isExceptionVariable())
1778	DiagID = diag::warn_unused_exception_param;
1779	else if (isa<LabelDecl>(D))
1780	DiagID = diag::warn_unused_label;
1781	else
1782	DiagID = diag::warn_unused_variable;
1783
1784	Diag(D->getLocation(), DiagID) << D << Hint;
1785	}
1786
1787	static void CheckPoppedLabel(LabelDecl *L, Sema &S) {
1788	// Verify that we have no forward references left. If so, there was a goto
1789	// or address of a label taken, but no definition of it. Label fwd
1790	// definitions are indicated with a null substmt which is also not a resolved
1791	// MS inline assembly label name.
1792	bool Diagnose = false;
1793	if (L->isMSAsmLabel())
1794	Diagnose = !L->isResolvedMSAsmLabel();
1795	else
1796	Diagnose = L->getStmt() == nullptr;
1797	if (Diagnose)
1798	S.Diag(L->getLocation(), diag::err_undeclared_label_use) <<L->getDeclName();
1799	}
1800
1801	void Sema::ActOnPopScope(SourceLocation Loc, Scope *S) {
1802	S->mergeNRVOIntoParent();
1803
1804	if (S->decl_empty()) return;
1805	assert((S->getFlags() & (Scope::DeclScope \| Scope::TemplateParamScope)) &&(((S->getFlags() & (Scope::DeclScope \| Scope::TemplateParamScope )) && "Scope shouldn't contain decls!") ? static_cast <void> (0) : __assert_fail ("(S->getFlags() & (Scope::DeclScope \| Scope::TemplateParamScope)) && \"Scope shouldn't contain decls!\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 1806, __PRETTY_FUNCTION__))
1806	"Scope shouldn't contain decls!")(((S->getFlags() & (Scope::DeclScope \| Scope::TemplateParamScope )) && "Scope shouldn't contain decls!") ? static_cast <void> (0) : __assert_fail ("(S->getFlags() & (Scope::DeclScope \| Scope::TemplateParamScope)) && \"Scope shouldn't contain decls!\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 1806, __PRETTY_FUNCTION__));
1807
1808	for (auto *TmpD : S->decls()) {
1809	assert(TmpD && "This decl didn't get pushed??")((TmpD && "This decl didn't get pushed??") ? static_cast <void> (0) : __assert_fail ("TmpD && \"This decl didn't get pushed??\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 1809, __PRETTY_FUNCTION__));
1810
1811	assert(isa<NamedDecl>(TmpD) && "Decl isn't NamedDecl?")((isa<NamedDecl>(TmpD) && "Decl isn't NamedDecl?" ) ? static_cast<void> (0) : __assert_fail ("isa<NamedDecl>(TmpD) && \"Decl isn't NamedDecl?\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 1811, __PRETTY_FUNCTION__));
1812	NamedDecl *D = cast<NamedDecl>(TmpD);
1813
1814	// Diagnose unused variables in this scope.
1815	if (!S->hasUnrecoverableErrorOccurred()) {
1816	DiagnoseUnusedDecl(D);
1817	if (const auto *RD = dyn_cast<RecordDecl>(D))
1818	DiagnoseUnusedNestedTypedefs(RD);
1819	}
1820
1821	if (!D->getDeclName()) continue;
1822
1823	// If this was a forward reference to a label, verify it was defined.
1824	if (LabelDecl *LD = dyn_cast<LabelDecl>(D))
1825	CheckPoppedLabel(LD, *this);
1826
1827	// Remove this name from our lexical scope, and warn on it if we haven't
1828	// already.
1829	IdResolver.RemoveDecl(D);
1830	auto ShadowI = ShadowingDecls.find(D);
1831	if (ShadowI != ShadowingDecls.end()) {
1832	if (const auto *FD = dyn_cast<FieldDecl>(ShadowI->second)) {
1833	Diag(D->getLocation(), diag::warn_ctor_parm_shadows_field)
1834	<< D << FD << FD->getParent();
1835	Diag(FD->getLocation(), diag::note_previous_declaration);
1836	}
1837	ShadowingDecls.erase(ShadowI);
1838	}
1839	}
1840	}
1841
1842	/// Look for an Objective-C class in the translation unit.
1843	///
1844	/// \param Id The name of the Objective-C class we're looking for. If
1845	/// typo-correction fixes this name, the Id will be updated
1846	/// to the fixed name.
1847	///
1848	/// \param IdLoc The location of the name in the translation unit.
1849	///
1850	/// \param DoTypoCorrection If true, this routine will attempt typo correction
1851	/// if there is no class with the given name.
1852	///
1853	/// \returns The declaration of the named Objective-C class, or NULL if the
1854	/// class could not be found.
1855	ObjCInterfaceDecl Sema::getObjCInterfaceDecl(IdentifierInfo &Id,
1856	SourceLocation IdLoc,
1857	bool DoTypoCorrection) {
1858	// The third "scope" argument is 0 since we aren't enabling lazy built-in
1859	// creation from this context.
1860	NamedDecl *IDecl = LookupSingleName(TUScope, Id, IdLoc, LookupOrdinaryName);
1861
1862	if (!IDecl && DoTypoCorrection) {
1863	// Perform typo correction at the given location, but only if we
1864	// find an Objective-C class name.
1865	if (TypoCorrection C = CorrectTypo(
1866	DeclarationNameInfo(Id, IdLoc), LookupOrdinaryName, TUScope, nullptr,
1867	llvm::make_unique<DeclFilterCCC<ObjCInterfaceDecl>>(),
1868	CTK_ErrorRecovery)) {
1869	diagnoseTypo(C, PDiag(diag::err_undef_interface_suggest) << Id);
1870	IDecl = C.getCorrectionDeclAs<ObjCInterfaceDecl>();
1871	Id = IDecl->getIdentifier();
1872	}
1873	}
1874	ObjCInterfaceDecl *Def = dyn_cast_or_null<ObjCInterfaceDecl>(IDecl);
1875	// This routine must always return a class definition, if any.
1876	if (Def && Def->getDefinition())
1877	Def = Def->getDefinition();
1878	return Def;
1879	}
1880
1881	/// getNonFieldDeclScope - Retrieves the innermost scope, starting
1882	/// from S, where a non-field would be declared. This routine copes
1883	/// with the difference between C and C++ scoping rules in structs and
1884	/// unions. For example, the following code is well-formed in C but
1885	/// ill-formed in C++:
1886	/// @code
1887	/// struct S6 {
1888	/// enum { BAR } e;
1889	/// };
1890	///
1891	/// void test_S6() {
1892	/// struct S6 a;
1893	/// a.e = BAR;
1894	/// }
1895	/// @endcode
1896	/// For the declaration of BAR, this routine will return a different
1897	/// scope. The scope S will be the scope of the unnamed enumeration
1898	/// within S6. In C++, this routine will return the scope associated
1899	/// with S6, because the enumeration's scope is a transparent
1900	/// context but structures can contain non-field names. In C, this
1901	/// routine will return the translation unit scope, since the
1902	/// enumeration's scope is a transparent context and structures cannot
1903	/// contain non-field names.
1904	Scope Sema::getNonFieldDeclScope(Scope S) {
1905	while (((S->getFlags() & Scope::DeclScope) == 0) \|\|
1906	(S->getEntity() && S->getEntity()->isTransparentContext()) \|\|
1907	(S->isClassScope() && !getLangOpts().CPlusPlus))
1908	S = S->getParent();
1909	return S;
1910	}
1911
1912	/// Looks up the declaration of "struct objc_super" and
1913	/// saves it for later use in building builtin declaration of
1914	/// objc_msgSendSuper and objc_msgSendSuper_stret. If no such
1915	/// pre-existing declaration exists no action takes place.
1916	static void LookupPredefedObjCSuperType(Sema &ThisSema, Scope *S,
1917	IdentifierInfo *II) {
1918	if (!II->isStr("objc_msgSendSuper"))
1919	return;
1920	ASTContext &Context = ThisSema.Context;
1921
1922	LookupResult Result(ThisSema, &Context.Idents.get("objc_super"),
1923	SourceLocation(), Sema::LookupTagName);
1924	ThisSema.LookupName(Result, S);
1925	if (Result.getResultKind() == LookupResult::Found)
1926	if (const TagDecl *TD = Result.getAsSingle<TagDecl>())
1927	Context.setObjCSuperType(Context.getTagDeclType(TD));
1928	}
1929
1930	static StringRef getHeaderName(ASTContext::GetBuiltinTypeError Error) {
1931	switch (Error) {
1932	case ASTContext::GE_None:
1933	return "";
1934	case ASTContext::GE_Missing_stdio:
1935	return "stdio.h";
1936	case ASTContext::GE_Missing_setjmp:
1937	return "setjmp.h";
1938	case ASTContext::GE_Missing_ucontext:
1939	return "ucontext.h";
1940	}
1941	llvm_unreachable("unhandled error kind")::llvm::llvm_unreachable_internal("unhandled error kind", "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 1941);
1942	}
1943
1944	/// LazilyCreateBuiltin - The specified Builtin-ID was first used at
1945	/// file scope. lazily create a decl for it. ForRedeclaration is true
1946	/// if we're creating this built-in in anticipation of redeclaring the
1947	/// built-in.
1948	NamedDecl Sema::LazilyCreateBuiltin(IdentifierInfo II, unsigned ID,
1949	Scope *S, bool ForRedeclaration,
1950	SourceLocation Loc) {
1951	LookupPredefedObjCSuperType(*this, S, II);
1952
1953	ASTContext::GetBuiltinTypeError Error;
1954	QualType R = Context.GetBuiltinType(ID, Error);
1955	if (Error) {
1956	if (ForRedeclaration)
1957	Diag(Loc, diag::warn_implicit_decl_requires_sysheader)
1958	<< getHeaderName(Error) << Context.BuiltinInfo.getName(ID);
1959	return nullptr;
1960	}
1961
1962	if (!ForRedeclaration &&
1963	(Context.BuiltinInfo.isPredefinedLibFunction(ID) \|\|
1964	Context.BuiltinInfo.isHeaderDependentFunction(ID))) {
1965	Diag(Loc, diag::ext_implicit_lib_function_decl)
1966	<< Context.BuiltinInfo.getName(ID) << R;
1967	if (Context.BuiltinInfo.getHeaderName(ID) &&
1968	!Diags.isIgnored(diag::ext_implicit_lib_function_decl, Loc))
1969	Diag(Loc, diag::note_include_header_or_declare)
1970	<< Context.BuiltinInfo.getHeaderName(ID)
1971	<< Context.BuiltinInfo.getName(ID);
1972	}
1973
1974	if (R.isNull())
1975	return nullptr;
1976
1977	DeclContext *Parent = Context.getTranslationUnitDecl();
1978	if (getLangOpts().CPlusPlus) {
1979	LinkageSpecDecl *CLinkageDecl =
1980	LinkageSpecDecl::Create(Context, Parent, Loc, Loc,
1981	LinkageSpecDecl::lang_c, false);
1982	CLinkageDecl->setImplicit();
1983	Parent->addDecl(CLinkageDecl);
1984	Parent = CLinkageDecl;
1985	}
1986
1987	FunctionDecl *New = FunctionDecl::Create(Context,
1988	Parent,
1989	Loc, Loc, II, R, /TInfo=/nullptr,
1990	SC_Extern,
1991	false,
1992	R->isFunctionProtoType());
1993	New->setImplicit();
1994
1995	// Create Decl objects for each parameter, adding them to the
1996	// FunctionDecl.
1997	if (const FunctionProtoType *FT = dyn_cast<FunctionProtoType>(R)) {
1998	SmallVector<ParmVarDecl*, 16> Params;
1999	for (unsigned i = 0, e = FT->getNumParams(); i != e; ++i) {
2000	ParmVarDecl *parm =
2001	ParmVarDecl::Create(Context, New, SourceLocation(), SourceLocation(),
2002	nullptr, FT->getParamType(i), /TInfo=/nullptr,
2003	SC_None, nullptr);
2004	parm->setScopeInfo(0, i);
2005	Params.push_back(parm);
2006	}
2007	New->setParams(Params);
2008	}
2009
2010	AddKnownFunctionAttributes(New);
2011	RegisterLocallyScopedExternCDecl(New, S);
2012
2013	// TUScope is the translation-unit scope to insert this function into.
2014	// FIXME: This is hideous. We need to teach PushOnScopeChains to
2015	// relate Scopes to DeclContexts, and probably eliminate CurContext
2016	// entirely, but we're not there yet.
2017	DeclContext *SavedContext = CurContext;
2018	CurContext = Parent;
2019	PushOnScopeChains(New, TUScope);
2020	CurContext = SavedContext;
2021	return New;
2022	}
2023
2024	/// Typedef declarations don't have linkage, but they still denote the same
2025	/// entity if their types are the same.
2026	/// FIXME: This is notionally doing the same thing as ASTReaderDecl's
2027	/// isSameEntity.
2028	static void filterNonConflictingPreviousTypedefDecls(Sema &S,
2029	TypedefNameDecl *Decl,
2030	LookupResult &Previous) {
2031	// This is only interesting when modules are enabled.
2032	if (!S.getLangOpts().Modules && !S.getLangOpts().ModulesLocalVisibility)
2033	return;
2034
2035	// Empty sets are uninteresting.
2036	if (Previous.empty())
2037	return;
2038
2039	LookupResult::Filter Filter = Previous.makeFilter();
2040	while (Filter.hasNext()) {
2041	NamedDecl *Old = Filter.next();
2042
2043	// Non-hidden declarations are never ignored.
2044	if (S.isVisible(Old))
2045	continue;
2046
2047	// Declarations of the same entity are not ignored, even if they have
2048	// different linkages.
2049	if (auto *OldTD = dyn_cast<TypedefNameDecl>(Old)) {
2050	if (S.Context.hasSameType(OldTD->getUnderlyingType(),
2051	Decl->getUnderlyingType()))
2052	continue;
2053
2054	// If both declarations give a tag declaration a typedef name for linkage
2055	// purposes, then they declare the same entity.
2056	if (OldTD->getAnonDeclWithTypedefName(/AnyRedecl/true) &&
2057	Decl->getAnonDeclWithTypedefName())
2058	continue;
2059	}
2060
2061	Filter.erase();
2062	}
2063
2064	Filter.done();
2065	}
2066
2067	bool Sema::isIncompatibleTypedef(TypeDecl Old, TypedefNameDecl New) {
2068	QualType OldType;
2069	if (TypedefNameDecl *OldTypedef = dyn_cast<TypedefNameDecl>(Old))
2070	OldType = OldTypedef->getUnderlyingType();
2071	else
2072	OldType = Context.getTypeDeclType(Old);
2073	QualType NewType = New->getUnderlyingType();
2074
2075	if (NewType->isVariablyModifiedType()) {
2076	// Must not redefine a typedef with a variably-modified type.
2077	int Kind = isa<TypeAliasDecl>(Old) ? 1 : 0;
2078	Diag(New->getLocation(), diag::err_redefinition_variably_modified_typedef)
2079	<< Kind << NewType;
2080	if (Old->getLocation().isValid())
2081	notePreviousDefinition(Old, New->getLocation());
2082	New->setInvalidDecl();
2083	return true;
2084	}
2085
2086	if (OldType != NewType &&
2087	!OldType->isDependentType() &&
2088	!NewType->isDependentType() &&
2089	!Context.hasSameType(OldType, NewType)) {
2090	int Kind = isa<TypeAliasDecl>(Old) ? 1 : 0;
2091	Diag(New->getLocation(), diag::err_redefinition_different_typedef)
2092	<< Kind << NewType << OldType;
2093	if (Old->getLocation().isValid())
2094	notePreviousDefinition(Old, New->getLocation());
2095	New->setInvalidDecl();
2096	return true;
2097	}
2098	return false;
2099	}
2100
2101	/// MergeTypedefNameDecl - We just parsed a typedef 'New' which has the
2102	/// same name and scope as a previous declaration 'Old'. Figure out
2103	/// how to resolve this situation, merging decls or emitting
2104	/// diagnostics as appropriate. If there was an error, set New to be invalid.
2105	///
2106	void Sema::MergeTypedefNameDecl(Scope S, TypedefNameDecl New,
2107	LookupResult &OldDecls) {
2108	// If the new decl is known invalid already, don't bother doing any
2109	// merging checks.
2110	if (New->isInvalidDecl()) return;
2111
2112	// Allow multiple definitions for ObjC built-in typedefs.
2113	// FIXME: Verify the underlying types are equivalent!
2114	if (getLangOpts().ObjC) {
2115	const IdentifierInfo *TypeID = New->getIdentifier();
2116	switch (TypeID->getLength()) {
2117	default: break;
2118	case 2:
2119	{
2120	if (!TypeID->isStr("id"))
2121	break;
2122	QualType T = New->getUnderlyingType();
2123	if (!T->isPointerType())
2124	break;
2125	if (!T->isVoidPointerType()) {
2126	QualType PT = T->getAs<PointerType>()->getPointeeType();
2127	if (!PT->isStructureType())
2128	break;
2129	}
2130	Context.setObjCIdRedefinitionType(T);
2131	// Install the built-in type for 'id', ignoring the current definition.
2132	New->setTypeForDecl(Context.getObjCIdType().getTypePtr());
2133	return;
2134	}
2135	case 5:
2136	if (!TypeID->isStr("Class"))
2137	break;
2138	Context.setObjCClassRedefinitionType(New->getUnderlyingType());
2139	// Install the built-in type for 'Class', ignoring the current definition.
2140	New->setTypeForDecl(Context.getObjCClassType().getTypePtr());
2141	return;
2142	case 3:
2143	if (!TypeID->isStr("SEL"))
2144	break;
2145	Context.setObjCSelRedefinitionType(New->getUnderlyingType());
2146	// Install the built-in type for 'SEL', ignoring the current definition.
2147	New->setTypeForDecl(Context.getObjCSelType().getTypePtr());
2148	return;
2149	}
2150	// Fall through - the typedef name was not a builtin type.
2151	}
2152
2153	// Verify the old decl was also a type.
2154	TypeDecl *Old = OldDecls.getAsSingle<TypeDecl>();
2155	if (!Old) {
2156	Diag(New->getLocation(), diag::err_redefinition_different_kind)
2157	<< New->getDeclName();
2158
2159	NamedDecl *OldD = OldDecls.getRepresentativeDecl();
2160	if (OldD->getLocation().isValid())
2161	notePreviousDefinition(OldD, New->getLocation());
2162
2163	return New->setInvalidDecl();
2164	}
2165
2166	// If the old declaration is invalid, just give up here.
2167	if (Old->isInvalidDecl())
2168	return New->setInvalidDecl();
2169
2170	if (auto *OldTD = dyn_cast<TypedefNameDecl>(Old)) {
2171	auto OldTag = OldTD->getAnonDeclWithTypedefName(/AnyRedecl*/true);
2172	auto *NewTag = New->getAnonDeclWithTypedefName();
2173	NamedDecl *Hidden = nullptr;
2174	if (OldTag && NewTag &&
2175	OldTag->getCanonicalDecl() != NewTag->getCanonicalDecl() &&
2176	!hasVisibleDefinition(OldTag, &Hidden)) {
2177	// There is a definition of this tag, but it is not visible. Use it
2178	// instead of our tag.
2179	New->setTypeForDecl(OldTD->getTypeForDecl());
2180	if (OldTD->isModed())
2181	New->setModedTypeSourceInfo(OldTD->getTypeSourceInfo(),
2182	OldTD->getUnderlyingType());
2183	else
2184	New->setTypeSourceInfo(OldTD->getTypeSourceInfo());
2185
2186	// Make the old tag definition visible.
2187	makeMergedDefinitionVisible(Hidden);
2188
2189	// If this was an unscoped enumeration, yank all of its enumerators
2190	// out of the scope.
2191	if (isa<EnumDecl>(NewTag)) {
2192	Scope *EnumScope = getNonFieldDeclScope(S);
2193	for (auto *D : NewTag->decls()) {
2194	auto *ED = cast<EnumConstantDecl>(D);
2195	assert(EnumScope->isDeclScope(ED))((EnumScope->isDeclScope(ED)) ? static_cast<void> (0 ) : __assert_fail ("EnumScope->isDeclScope(ED)", "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 2195, __PRETTY_FUNCTION__));
2196	EnumScope->RemoveDecl(ED);
2197	IdResolver.RemoveDecl(ED);
2198	ED->getLexicalDeclContext()->removeDecl(ED);
2199	}
2200	}
2201	}
2202	}
2203
2204	// If the typedef types are not identical, reject them in all languages and
2205	// with any extensions enabled.
2206	if (isIncompatibleTypedef(Old, New))
2207	return;
2208
2209	// The types match. Link up the redeclaration chain and merge attributes if
2210	// the old declaration was a typedef.
2211	if (TypedefNameDecl *Typedef = dyn_cast<TypedefNameDecl>(Old)) {
2212	New->setPreviousDecl(Typedef);
2213	mergeDeclAttributes(New, Old);
2214	}
2215
2216	if (getLangOpts().MicrosoftExt)
2217	return;
2218
2219	if (getLangOpts().CPlusPlus) {
2220	// C++ [dcl.typedef]p2:
2221	// In a given non-class scope, a typedef specifier can be used to
2222	// redefine the name of any type declared in that scope to refer
2223	// to the type to which it already refers.
2224	if (!isa<CXXRecordDecl>(CurContext))
2225	return;
2226
2227	// C++0x [dcl.typedef]p4:
2228	// In a given class scope, a typedef specifier can be used to redefine
2229	// any class-name declared in that scope that is not also a typedef-name
2230	// to refer to the type to which it already refers.
2231	//
2232	// This wording came in via DR424, which was a correction to the
2233	// wording in DR56, which accidentally banned code like:
2234	//
2235	// struct S {
2236	// typedef struct A { } A;
2237	// };
2238	//
2239	// in the C++03 standard. We implement the C++0x semantics, which
2240	// allow the above but disallow
2241	//
2242	// struct S {
2243	// typedef int I;
2244	// typedef int I;
2245	// };
2246	//
2247	// since that was the intent of DR56.
2248	if (!isa<TypedefNameDecl>(Old))
2249	return;
2250
2251	Diag(New->getLocation(), diag::err_redefinition)
2252	<< New->getDeclName();
2253	notePreviousDefinition(Old, New->getLocation());
2254	return New->setInvalidDecl();
2255	}
2256
2257	// Modules always permit redefinition of typedefs, as does C11.
2258	if (getLangOpts().Modules \|\| getLangOpts().C11)
2259	return;
2260
2261	// If we have a redefinition of a typedef in C, emit a warning. This warning
2262	// is normally mapped to an error, but can be controlled with
2263	// -Wtypedef-redefinition. If either the original or the redefinition is
2264	// in a system header, don't emit this for compatibility with GCC.
2265	if (getDiagnostics().getSuppressSystemWarnings() &&
2266	// Some standard types are defined implicitly in Clang (e.g. OpenCL).
2267	(Old->isImplicit() \|\|
2268	Context.getSourceManager().isInSystemHeader(Old->getLocation()) \|\|
2269	Context.getSourceManager().isInSystemHeader(New->getLocation())))
2270	return;
2271
2272	Diag(New->getLocation(), diag::ext_redefinition_of_typedef)
2273	<< New->getDeclName();
2274	notePreviousDefinition(Old, New->getLocation());
2275	}
2276
2277	/// DeclhasAttr - returns true if decl Declaration already has the target
2278	/// attribute.
2279	static bool DeclHasAttr(const Decl D, const Attr A) {
2280	const OwnershipAttr *OA = dyn_cast<OwnershipAttr>(A);
2281	const AnnotateAttr *Ann = dyn_cast<AnnotateAttr>(A);
2282	for (const auto *i : D->attrs())
2283	if (i->getKind() == A->getKind()) {
2284	if (Ann) {
2285	if (Ann->getAnnotation() == cast<AnnotateAttr>(i)->getAnnotation())
2286	return true;
2287	continue;
2288	}
2289	// FIXME: Don't hardcode this check
2290	if (OA && isa<OwnershipAttr>(i))
2291	return OA->getOwnKind() == cast<OwnershipAttr>(i)->getOwnKind();
2292	return true;
2293	}
2294
2295	return false;
2296	}
2297
2298	static bool isAttributeTargetADefinition(Decl *D) {
2299	if (VarDecl *VD = dyn_cast<VarDecl>(D))
2300	return VD->isThisDeclarationADefinition();
2301	if (TagDecl *TD = dyn_cast<TagDecl>(D))
2302	return TD->isCompleteDefinition() \|\| TD->isBeingDefined();
2303	return true;
2304	}
2305
2306	/// Merge alignment attributes from \p Old to \p New, taking into account the
2307	/// special semantics of C11's _Alignas specifier and C++11's alignas attribute.
2308	///
2309	/// \return \c true if any attributes were added to \p New.
2310	static bool mergeAlignedAttrs(Sema &S, NamedDecl New, Decl Old) {
2311	// Look for alignas attributes on Old, and pick out whichever attribute
2312	// specifies the strictest alignment requirement.
2313	AlignedAttr *OldAlignasAttr = nullptr;
2314	AlignedAttr *OldStrictestAlignAttr = nullptr;
2315	unsigned OldAlign = 0;
2316	for (auto *I : Old->specific_attrs<AlignedAttr>()) {
2317	// FIXME: We have no way of representing inherited dependent alignments
2318	// in a case like:
2319	// template<int A, int B> struct alignas(A) X;
2320	// template<int A, int B> struct alignas(B) X {};
2321	// For now, we just ignore any alignas attributes which are not on the
2322	// definition in such a case.
2323	if (I->isAlignmentDependent())
2324	return false;
2325
2326	if (I->isAlignas())
2327	OldAlignasAttr = I;
2328
2329	unsigned Align = I->getAlignment(S.Context);
2330	if (Align > OldAlign) {
2331	OldAlign = Align;
2332	OldStrictestAlignAttr = I;
2333	}
2334	}
2335
2336	// Look for alignas attributes on New.
2337	AlignedAttr *NewAlignasAttr = nullptr;
2338	unsigned NewAlign = 0;
2339	for (auto *I : New->specific_attrs<AlignedAttr>()) {
2340	if (I->isAlignmentDependent())
2341	return false;
2342
2343	if (I->isAlignas())
2344	NewAlignasAttr = I;
2345
2346	unsigned Align = I->getAlignment(S.Context);
2347	if (Align > NewAlign)
2348	NewAlign = Align;
2349	}
2350
2351	if (OldAlignasAttr && NewAlignasAttr && OldAlign != NewAlign) {
2352	// Both declarations have 'alignas' attributes. We require them to match.
2353	// C++11 [dcl.align]p6 and C11 6.7.5/7 both come close to saying this, but
2354	// fall short. (If two declarations both have alignas, they must both match
2355	// every definition, and so must match each other if there is a definition.)
2356
2357	// If either declaration only contains 'alignas(0)' specifiers, then it
2358	// specifies the natural alignment for the type.
2359	if (OldAlign == 0 \|\| NewAlign == 0) {
2360	QualType Ty;
2361	if (ValueDecl *VD = dyn_cast<ValueDecl>(New))
2362	Ty = VD->getType();
2363	else
2364	Ty = S.Context.getTagDeclType(cast<TagDecl>(New));
2365
2366	if (OldAlign == 0)
2367	OldAlign = S.Context.getTypeAlign(Ty);
2368	if (NewAlign == 0)
2369	NewAlign = S.Context.getTypeAlign(Ty);
2370	}
2371
2372	if (OldAlign != NewAlign) {
2373	S.Diag(NewAlignasAttr->getLocation(), diag::err_alignas_mismatch)
2374	<< (unsigned)S.Context.toCharUnitsFromBits(OldAlign).getQuantity()
2375	<< (unsigned)S.Context.toCharUnitsFromBits(NewAlign).getQuantity();
2376	S.Diag(OldAlignasAttr->getLocation(), diag::note_previous_declaration);
2377	}
2378	}
2379
2380	if (OldAlignasAttr && !NewAlignasAttr && isAttributeTargetADefinition(New)) {
2381	// C++11 [dcl.align]p6:
2382	// if any declaration of an entity has an alignment-specifier,
2383	// every defining declaration of that entity shall specify an
2384	// equivalent alignment.
2385	// C11 6.7.5/7:
2386	// If the definition of an object does not have an alignment
2387	// specifier, any other declaration of that object shall also
2388	// have no alignment specifier.
2389	S.Diag(New->getLocation(), diag::err_alignas_missing_on_definition)
2390	<< OldAlignasAttr;
2391	S.Diag(OldAlignasAttr->getLocation(), diag::note_alignas_on_declaration)
2392	<< OldAlignasAttr;
2393	}
2394
2395	bool AnyAdded = false;
2396
2397	// Ensure we have an attribute representing the strictest alignment.
2398	if (OldAlign > NewAlign) {
2399	AlignedAttr *Clone = OldStrictestAlignAttr->clone(S.Context);
2400	Clone->setInherited(true);
2401	New->addAttr(Clone);
2402	AnyAdded = true;
2403	}
2404
2405	// Ensure we have an alignas attribute if the old declaration had one.
2406	if (OldAlignasAttr && !NewAlignasAttr &&
2407	!(AnyAdded && OldStrictestAlignAttr->isAlignas())) {
2408	AlignedAttr *Clone = OldAlignasAttr->clone(S.Context);
2409	Clone->setInherited(true);
2410	New->addAttr(Clone);
2411	AnyAdded = true;
2412	}
2413
2414	return AnyAdded;
2415	}
2416
2417	static bool mergeDeclAttribute(Sema &S, NamedDecl *D,
2418	const InheritableAttr *Attr,
2419	Sema::AvailabilityMergeKind AMK) {
2420	// This function copies an attribute Attr from a previous declaration to the
2421	// new declaration D if the new declaration doesn't itself have that attribute
2422	// yet or if that attribute allows duplicates.
2423	// If you're adding a new attribute that requires logic different from
2424	// "use explicit attribute on decl if present, else use attribute from
2425	// previous decl", for example if the attribute needs to be consistent
2426	// between redeclarations, you need to call a custom merge function here.
2427	InheritableAttr *NewAttr = nullptr;
2428	unsigned AttrSpellingListIndex = Attr->getSpellingListIndex();
2429	if (const auto *AA = dyn_cast<AvailabilityAttr>(Attr))
2430	NewAttr = S.mergeAvailabilityAttr(D, AA->getRange(), AA->getPlatform(),
2431	AA->isImplicit(), AA->getIntroduced(),
2432	AA->getDeprecated(),
2433	AA->getObsoleted(), AA->getUnavailable(),
2434	AA->getMessage(), AA->getStrict(),
2435	AA->getReplacement(), AMK,
2436	AttrSpellingListIndex);
2437	else if (const auto *VA = dyn_cast<VisibilityAttr>(Attr))
2438	NewAttr = S.mergeVisibilityAttr(D, VA->getRange(), VA->getVisibility(),
2439	AttrSpellingListIndex);
2440	else if (const auto *VA = dyn_cast<TypeVisibilityAttr>(Attr))
2441	NewAttr = S.mergeTypeVisibilityAttr(D, VA->getRange(), VA->getVisibility(),
2442	AttrSpellingListIndex);
2443	else if (const auto *ImportA = dyn_cast<DLLImportAttr>(Attr))
2444	NewAttr = S.mergeDLLImportAttr(D, ImportA->getRange(),
2445	AttrSpellingListIndex);
2446	else if (const auto *ExportA = dyn_cast<DLLExportAttr>(Attr))
2447	NewAttr = S.mergeDLLExportAttr(D, ExportA->getRange(),
2448	AttrSpellingListIndex);
2449	else if (const auto *FA = dyn_cast<FormatAttr>(Attr))
2450	NewAttr = S.mergeFormatAttr(D, FA->getRange(), FA->getType(),
2451	FA->getFormatIdx(), FA->getFirstArg(),
2452	AttrSpellingListIndex);
2453	else if (const auto *SA = dyn_cast<SectionAttr>(Attr))
2454	NewAttr = S.mergeSectionAttr(D, SA->getRange(), SA->getName(),
2455	AttrSpellingListIndex);
2456	else if (const auto *CSA = dyn_cast<CodeSegAttr>(Attr))
2457	NewAttr = S.mergeCodeSegAttr(D, CSA->getRange(), CSA->getName(),
2458	AttrSpellingListIndex);
2459	else if (const auto *IA = dyn_cast<MSInheritanceAttr>(Attr))
2460	NewAttr = S.mergeMSInheritanceAttr(D, IA->getRange(), IA->getBestCase(),
2461	AttrSpellingListIndex,
2462	IA->getSemanticSpelling());
2463	else if (const auto *AA = dyn_cast<AlwaysInlineAttr>(Attr))
2464	NewAttr = S.mergeAlwaysInlineAttr(D, AA->getRange(),
2465	&S.Context.Idents.get(AA->getSpelling()),
2466	AttrSpellingListIndex);
2467	else if (S.getLangOpts().CUDA && isa<FunctionDecl>(D) &&
2468	(isa<CUDAHostAttr>(Attr) \|\| isa<CUDADeviceAttr>(Attr) \|\|
2469	isa<CUDAGlobalAttr>(Attr))) {
2470	// CUDA target attributes are part of function signature for
2471	// overloading purposes and must not be merged.
2472	return false;
2473	} else if (const auto *MA = dyn_cast<MinSizeAttr>(Attr))
2474	NewAttr = S.mergeMinSizeAttr(D, MA->getRange(), AttrSpellingListIndex);
2475	else if (const auto *OA = dyn_cast<OptimizeNoneAttr>(Attr))
2476	NewAttr = S.mergeOptimizeNoneAttr(D, OA->getRange(), AttrSpellingListIndex);
2477	else if (const auto *InternalLinkageA = dyn_cast<InternalLinkageAttr>(Attr))
2478	NewAttr = S.mergeInternalLinkageAttr(D, *InternalLinkageA);
2479	else if (const auto *CommonA = dyn_cast<CommonAttr>(Attr))
2480	NewAttr = S.mergeCommonAttr(D, *CommonA);
2481	else if (isa<AlignedAttr>(Attr))
2482	// AlignedAttrs are handled separately, because we need to handle all
2483	// such attributes on a declaration at the same time.
2484	NewAttr = nullptr;
2485	else if ((isa<DeprecatedAttr>(Attr) \|\| isa<UnavailableAttr>(Attr)) &&
2486	(AMK == Sema::AMK_Override \|\|
2487	AMK == Sema::AMK_ProtocolImplementation))
2488	NewAttr = nullptr;
2489	else if (const auto *UA = dyn_cast<UuidAttr>(Attr))
2490	NewAttr = S.mergeUuidAttr(D, UA->getRange(), AttrSpellingListIndex,
2491	UA->getGuid());
2492	else if (Attr->shouldInheritEvenIfAlreadyPresent() \|\| !DeclHasAttr(D, Attr))
2493	NewAttr = cast<InheritableAttr>(Attr->clone(S.Context));
2494
2495	if (NewAttr) {
2496	NewAttr->setInherited(true);
2497	D->addAttr(NewAttr);
2498	if (isa<MSInheritanceAttr>(NewAttr))
2499	S.Consumer.AssignInheritanceModel(cast<CXXRecordDecl>(D));
2500	return true;
2501	}
2502
2503	return false;
2504	}
2505
2506	static const NamedDecl getDefinition(const Decl D) {
2507	if (const TagDecl *TD = dyn_cast<TagDecl>(D))
2508	return TD->getDefinition();
2509	if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
2510	const VarDecl *Def = VD->getDefinition();
2511	if (Def)
2512	return Def;
2513	return VD->getActingDefinition();
2514	}
2515	if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D))
2516	return FD->getDefinition();
2517	return nullptr;
2518	}
2519
2520	static bool hasAttribute(const Decl *D, attr::Kind Kind) {
2521	for (const auto *Attribute : D->attrs())
2522	if (Attribute->getKind() == Kind)
2523	return true;
2524	return false;
2525	}
2526
2527	/// checkNewAttributesAfterDef - If we already have a definition, check that
2528	/// there are no new attributes in this declaration.
2529	static void checkNewAttributesAfterDef(Sema &S, Decl New, const Decl Old) {
2530	if (!New->hasAttrs())
2531	return;
2532
2533	const NamedDecl *Def = getDefinition(Old);
2534	if (!Def \|\| Def == New)
2535	return;
2536
2537	AttrVec &NewAttributes = New->getAttrs();
2538	for (unsigned I = 0, E = NewAttributes.size(); I != E;) {
2539	const Attr *NewAttribute = NewAttributes[I];
2540
2541	if (isa<AliasAttr>(NewAttribute) \|\| isa<IFuncAttr>(NewAttribute)) {
2542	if (FunctionDecl *FD = dyn_cast<FunctionDecl>(New)) {
2543	Sema::SkipBodyInfo SkipBody;
2544	S.CheckForFunctionRedefinition(FD, cast<FunctionDecl>(Def), &SkipBody);
2545
2546	// If we're skipping this definition, drop the "alias" attribute.
2547	if (SkipBody.ShouldSkip) {
2548	NewAttributes.erase(NewAttributes.begin() + I);
2549	--E;
2550	continue;
2551	}
2552	} else {
2553	VarDecl *VD = cast<VarDecl>(New);
2554	unsigned Diag = cast<VarDecl>(Def)->isThisDeclarationADefinition() ==
2555	VarDecl::TentativeDefinition
2556	? diag::err_alias_after_tentative
2557	: diag::err_redefinition;
2558	S.Diag(VD->getLocation(), Diag) << VD->getDeclName();
2559	if (Diag == diag::err_redefinition)
2560	S.notePreviousDefinition(Def, VD->getLocation());
2561	else
2562	S.Diag(Def->getLocation(), diag::note_previous_definition);
2563	VD->setInvalidDecl();
2564	}
2565	++I;
2566	continue;
2567	}
2568
2569	if (const VarDecl *VD = dyn_cast<VarDecl>(Def)) {
2570	// Tentative definitions are only interesting for the alias check above.
2571	if (VD->isThisDeclarationADefinition() != VarDecl::Definition) {
2572	++I;
2573	continue;
2574	}
2575	}
2576
2577	if (hasAttribute(Def, NewAttribute->getKind())) {
2578	++I;
2579	continue; // regular attr merging will take care of validating this.
2580	}
2581
2582	if (isa<C11NoReturnAttr>(NewAttribute)) {
2583	// C's _Noreturn is allowed to be added to a function after it is defined.
2584	++I;
2585	continue;
2586	} else if (const AlignedAttr *AA = dyn_cast<AlignedAttr>(NewAttribute)) {
2587	if (AA->isAlignas()) {
2588	// C++11 [dcl.align]p6:
2589	// if any declaration of an entity has an alignment-specifier,
2590	// every defining declaration of that entity shall specify an
2591	// equivalent alignment.
2592	// C11 6.7.5/7:
2593	// If the definition of an object does not have an alignment
2594	// specifier, any other declaration of that object shall also
2595	// have no alignment specifier.
2596	S.Diag(Def->getLocation(), diag::err_alignas_missing_on_definition)
2597	<< AA;
2598	S.Diag(NewAttribute->getLocation(), diag::note_alignas_on_declaration)
2599	<< AA;
2600	NewAttributes.erase(NewAttributes.begin() + I);
2601	--E;
2602	continue;
2603	}
2604	}
2605
2606	S.Diag(NewAttribute->getLocation(),
2607	diag::warn_attribute_precede_definition);
2608	S.Diag(Def->getLocation(), diag::note_previous_definition);
2609	NewAttributes.erase(NewAttributes.begin() + I);
2610	--E;
2611	}
2612	}
2613
2614	/// mergeDeclAttributes - Copy attributes from the Old decl to the New one.
2615	void Sema::mergeDeclAttributes(NamedDecl New, Decl Old,
2616	AvailabilityMergeKind AMK) {
2617	if (UsedAttr *OldAttr = Old->getMostRecentDecl()->getAttr<UsedAttr>()) {
2618	UsedAttr *NewAttr = OldAttr->clone(Context);
2619	NewAttr->setInherited(true);
2620	New->addAttr(NewAttr);
2621	}
2622
2623	if (!Old->hasAttrs() && !New->hasAttrs())
2624	return;
2625
2626	// Attributes declared post-definition are currently ignored.
2627	checkNewAttributesAfterDef(*this, New, Old);
2628
2629	if (AsmLabelAttr *NewA = New->getAttr<AsmLabelAttr>()) {
2630	if (AsmLabelAttr *OldA = Old->getAttr<AsmLabelAttr>()) {
2631	if (OldA->getLabel() != NewA->getLabel()) {
2632	// This redeclaration changes __asm__ label.
2633	Diag(New->getLocation(), diag::err_different_asm_label);
2634	Diag(OldA->getLocation(), diag::note_previous_declaration);
2635	}
2636	} else if (Old->isUsed()) {
2637	// This redeclaration adds an __asm__ label to a declaration that has
2638	// already been ODR-used.
2639	Diag(New->getLocation(), diag::err_late_asm_label_name)
2640	<< isa<FunctionDecl>(Old) << New->getAttr<AsmLabelAttr>()->getRange();
2641	}
2642	}
2643
2644	// Re-declaration cannot add abi_tag's.
2645	if (const auto *NewAbiTagAttr = New->getAttr<AbiTagAttr>()) {
2646	if (const auto *OldAbiTagAttr = Old->getAttr<AbiTagAttr>()) {
2647	for (const auto &NewTag : NewAbiTagAttr->tags()) {
2648	if (std::find(OldAbiTagAttr->tags_begin(), OldAbiTagAttr->tags_end(),
2649	NewTag) == OldAbiTagAttr->tags_end()) {
2650	Diag(NewAbiTagAttr->getLocation(),
2651	diag::err_new_abi_tag_on_redeclaration)
2652	<< NewTag;
2653	Diag(OldAbiTagAttr->getLocation(), diag::note_previous_declaration);
2654	}
2655	}
2656	} else {
2657	Diag(NewAbiTagAttr->getLocation(), diag::err_abi_tag_on_redeclaration);
2658	Diag(Old->getLocation(), diag::note_previous_declaration);
2659	}
2660	}
2661
2662	// This redeclaration adds a section attribute.
2663	if (New->hasAttr<SectionAttr>() && !Old->hasAttr<SectionAttr>()) {
2664	if (auto *VD = dyn_cast<VarDecl>(New)) {
2665	if (VD->isThisDeclarationADefinition() == VarDecl::DeclarationOnly) {
2666	Diag(New->getLocation(), diag::warn_attribute_section_on_redeclaration);
2667	Diag(Old->getLocation(), diag::note_previous_declaration);
2668	}
2669	}
2670	}
2671
2672	// Redeclaration adds code-seg attribute.
2673	const auto *NewCSA = New->getAttr<CodeSegAttr>();
2674	if (NewCSA && !Old->hasAttr<CodeSegAttr>() &&
2675	!NewCSA->isImplicit() && isa<CXXMethodDecl>(New)) {
2676	Diag(New->getLocation(), diag::warn_mismatched_section)
2677	<< 0 /codeseg/;
2678	Diag(Old->getLocation(), diag::note_previous_declaration);
2679	}
2680
2681	if (!Old->hasAttrs())
2682	return;
2683
2684	bool foundAny = New->hasAttrs();
2685
2686	// Ensure that any moving of objects within the allocated map is done before
2687	// we process them.
2688	if (!foundAny) New->setAttrs(AttrVec());
2689
2690	for (auto *I : Old->specific_attrs<InheritableAttr>()) {
2691	// Ignore deprecated/unavailable/availability attributes if requested.
2692	AvailabilityMergeKind LocalAMK = AMK_None;
2693	if (isa<DeprecatedAttr>(I) \|\|
2694	isa<UnavailableAttr>(I) \|\|
2695	isa<AvailabilityAttr>(I)) {
2696	switch (AMK) {
2697	case AMK_None:
2698	continue;
2699
2700	case AMK_Redeclaration:
2701	case AMK_Override:
2702	case AMK_ProtocolImplementation:
2703	LocalAMK = AMK;
2704	break;
2705	}
2706	}
2707
2708	// Already handled.
2709	if (isa<UsedAttr>(I))
2710	continue;
2711
2712	if (mergeDeclAttribute(*this, New, I, LocalAMK))
2713	foundAny = true;
2714	}
2715
2716	if (mergeAlignedAttrs(*this, New, Old))
2717	foundAny = true;
2718
2719	if (!foundAny) New->dropAttrs();
2720	}
2721
2722	/// mergeParamDeclAttributes - Copy attributes from the old parameter
2723	/// to the new one.
2724	static void mergeParamDeclAttributes(ParmVarDecl *newDecl,
2725	const ParmVarDecl *oldDecl,
2726	Sema &S) {
2727	// C++11 [dcl.attr.depend]p2:
2728	// The first declaration of a function shall specify the
2729	// carries_dependency attribute for its declarator-id if any declaration
2730	// of the function specifies the carries_dependency attribute.
2731	const CarriesDependencyAttr *CDA = newDecl->getAttr<CarriesDependencyAttr>();
2732	if (CDA && !oldDecl->hasAttr<CarriesDependencyAttr>()) {
2733	S.Diag(CDA->getLocation(),
2734	diag::err_carries_dependency_missing_on_first_decl) << 1/Param/;
2735	// Find the first declaration of the parameter.
2736	// FIXME: Should we build redeclaration chains for function parameters?
2737	const FunctionDecl *FirstFD =
2738	cast<FunctionDecl>(oldDecl->getDeclContext())->getFirstDecl();
2739	const ParmVarDecl *FirstVD =
2740	FirstFD->getParamDecl(oldDecl->getFunctionScopeIndex());
2741	S.Diag(FirstVD->getLocation(),
2742	diag::note_carries_dependency_missing_first_decl) << 1/Param/;
2743	}
2744
2745	if (!oldDecl->hasAttrs())
2746	return;
2747
2748	bool foundAny = newDecl->hasAttrs();
2749
2750	// Ensure that any moving of objects within the allocated map is
2751	// done before we process them.
2752	if (!foundAny) newDecl->setAttrs(AttrVec());
2753
2754	for (const auto *I : oldDecl->specific_attrs<InheritableParamAttr>()) {
2755	if (!DeclHasAttr(newDecl, I)) {
2756	InheritableAttr *newAttr =
2757	cast<InheritableParamAttr>(I->clone(S.Context));
2758	newAttr->setInherited(true);
2759	newDecl->addAttr(newAttr);
2760	foundAny = true;
2761	}
2762	}
2763
2764	if (!foundAny) newDecl->dropAttrs();
2765	}
2766
2767	static void mergeParamDeclTypes(ParmVarDecl *NewParam,
2768	const ParmVarDecl *OldParam,
2769	Sema &S) {
2770	if (auto Oldnullability = OldParam->getType()->getNullability(S.Context)) {
2771	if (auto Newnullability = NewParam->getType()->getNullability(S.Context)) {
2772	if (Oldnullability != Newnullability) {
2773	S.Diag(NewParam->getLocation(), diag::warn_mismatched_nullability_attr)
2774	<< DiagNullabilityKind(
2775	*Newnullability,
2776	((NewParam->getObjCDeclQualifier() & Decl::OBJC_TQ_CSNullability)
2777	!= 0))
2778	<< DiagNullabilityKind(
2779	*Oldnullability,
2780	((OldParam->getObjCDeclQualifier() & Decl::OBJC_TQ_CSNullability)
2781	!= 0));
2782	S.Diag(OldParam->getLocation(), diag::note_previous_declaration);
2783	}
2784	} else {
2785	QualType NewT = NewParam->getType();
2786	NewT = S.Context.getAttributedType(
2787	AttributedType::getNullabilityAttrKind(*Oldnullability),
2788	NewT, NewT);
2789	NewParam->setType(NewT);
2790	}
2791	}
2792	}
2793
2794	namespace {
2795
2796	/// Used in MergeFunctionDecl to keep track of function parameters in
2797	/// C.
2798	struct GNUCompatibleParamWarning {
2799	ParmVarDecl *OldParm;
2800	ParmVarDecl *NewParm;
2801	QualType PromotedType;
2802	};
2803
2804	} // end anonymous namespace
2805
2806	/// getSpecialMember - get the special member enum for a method.
2807	Sema::CXXSpecialMember Sema::getSpecialMember(const CXXMethodDecl *MD) {
2808	if (const CXXConstructorDecl *Ctor = dyn_cast<CXXConstructorDecl>(MD)) {
2809	if (Ctor->isDefaultConstructor())
2810	return Sema::CXXDefaultConstructor;
2811
2812	if (Ctor->isCopyConstructor())
2813	return Sema::CXXCopyConstructor;
2814
2815	if (Ctor->isMoveConstructor())
2816	return Sema::CXXMoveConstructor;
2817	} else if (isa<CXXDestructorDecl>(MD)) {
2818	return Sema::CXXDestructor;
2819	} else if (MD->isCopyAssignmentOperator()) {
2820	return Sema::CXXCopyAssignment;
2821	} else if (MD->isMoveAssignmentOperator()) {
2822	return Sema::CXXMoveAssignment;
2823	}
2824
2825	return Sema::CXXInvalid;
2826	}
2827
2828	// Determine whether the previous declaration was a definition, implicit
2829	// declaration, or a declaration.
2830	template <typename T>
2831	static std::pair<diag::kind, SourceLocation>
2832	getNoteDiagForInvalidRedeclaration(const T Old, const T New) {
2833	diag::kind PrevDiag;
2834	SourceLocation OldLocation = Old->getLocation();
2835	if (Old->isThisDeclarationADefinition())
2836	PrevDiag = diag::note_previous_definition;
2837	else if (Old->isImplicit()) {
2838	PrevDiag = diag::note_previous_implicit_declaration;
2839	if (OldLocation.isInvalid())
2840	OldLocation = New->getLocation();
2841	} else
2842	PrevDiag = diag::note_previous_declaration;
2843	return std::make_pair(PrevDiag, OldLocation);
2844	}
2845
2846	/// canRedefineFunction - checks if a function can be redefined. Currently,
2847	/// only extern inline functions can be redefined, and even then only in
2848	/// GNU89 mode.
2849	static bool canRedefineFunction(const FunctionDecl *FD,
2850	const LangOptions& LangOpts) {
2851	return ((FD->hasAttr<GNUInlineAttr>() \|\| LangOpts.GNUInline) &&
2852	!LangOpts.CPlusPlus &&
2853	FD->isInlineSpecified() &&
2854	FD->getStorageClass() == SC_Extern);
2855	}
2856
2857	const AttributedType *Sema::getCallingConvAttributedType(QualType T) const {
2858	const AttributedType *AT = T->getAs<AttributedType>();
2859	while (AT && !AT->isCallingConv())
2860	AT = AT->getModifiedType()->getAs<AttributedType>();
2861	return AT;
2862	}
2863
2864	template <typename T>
2865	static bool haveIncompatibleLanguageLinkages(const T Old, const T New) {
2866	const DeclContext *DC = Old->getDeclContext();
2867	if (DC->isRecord())
2868	return false;
2869
2870	LanguageLinkage OldLinkage = Old->getLanguageLinkage();
2871	if (OldLinkage == CXXLanguageLinkage && New->isInExternCContext())
2872	return true;
2873	if (OldLinkage == CLanguageLinkage && New->isInExternCXXContext())
2874	return true;
2875	return false;
2876	}
2877
2878	template<typename T> static bool isExternC(T *D) { return D->isExternC(); }
2879	static bool isExternC(VarTemplateDecl *) { return false; }
2880
2881	/// Check whether a redeclaration of an entity introduced by a
2882	/// using-declaration is valid, given that we know it's not an overload
2883	/// (nor a hidden tag declaration).
2884	template<typename ExpectedDecl>
2885	static bool checkUsingShadowRedecl(Sema &S, UsingShadowDecl *OldS,
2886	ExpectedDecl *New) {
2887	// C++11 [basic.scope.declarative]p4:
2888	// Given a set of declarations in a single declarative region, each of
2889	// which specifies the same unqualified name,
2890	// -- they shall all refer to the same entity, or all refer to functions
2891	// and function templates; or
2892	// -- exactly one declaration shall declare a class name or enumeration
2893	// name that is not a typedef name and the other declarations shall all
2894	// refer to the same variable or enumerator, or all refer to functions
2895	// and function templates; in this case the class name or enumeration
2896	// name is hidden (3.3.10).
2897
2898	// C++11 [namespace.udecl]p14:
2899	// If a function declaration in namespace scope or block scope has the
2900	// same name and the same parameter-type-list as a function introduced
2901	// by a using-declaration, and the declarations do not declare the same
2902	// function, the program is ill-formed.
2903
2904	auto *Old = dyn_cast<ExpectedDecl>(OldS->getTargetDecl());
2905	if (Old &&
2906	!Old->getDeclContext()->getRedeclContext()->Equals(
2907	New->getDeclContext()->getRedeclContext()) &&
2908	!(isExternC(Old) && isExternC(New)))
2909	Old = nullptr;
2910
2911	if (!Old) {
2912	S.Diag(New->getLocation(), diag::err_using_decl_conflict_reverse);
2913	S.Diag(OldS->getTargetDecl()->getLocation(), diag::note_using_decl_target);
2914	S.Diag(OldS->getUsingDecl()->getLocation(), diag::note_using_decl) << 0;
2915	return true;
2916	}
2917	return false;
2918	}
2919
2920	static bool hasIdenticalPassObjectSizeAttrs(const FunctionDecl *A,
2921	const FunctionDecl *B) {
2922	assert(A->getNumParams() == B->getNumParams())((A->getNumParams() == B->getNumParams()) ? static_cast <void> (0) : __assert_fail ("A->getNumParams() == B->getNumParams()" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 2922, __PRETTY_FUNCTION__));
2923
2924	auto AttrEq = [](const ParmVarDecl A, const ParmVarDecl B) {
2925	const auto *AttrA = A->getAttr<PassObjectSizeAttr>();
2926	const auto *AttrB = B->getAttr<PassObjectSizeAttr>();
2927	if (AttrA == AttrB)
2928	return true;
2929	return AttrA && AttrB && AttrA->getType() == AttrB->getType();
2930	};
2931
2932	return std::equal(A->param_begin(), A->param_end(), B->param_begin(), AttrEq);
2933	}
2934
2935	/// If necessary, adjust the semantic declaration context for a qualified
2936	/// declaration to name the correct inline namespace within the qualifier.
2937	static void adjustDeclContextForDeclaratorDecl(DeclaratorDecl *NewD,
2938	DeclaratorDecl *OldD) {
2939	// The only case where we need to update the DeclContext is when
2940	// redeclaration lookup for a qualified name finds a declaration
2941	// in an inline namespace within the context named by the qualifier:
2942	//
2943	// inline namespace N { int f(); }
2944	// int ::f(); // Sema DC needs adjusting from :: to N::.
2945	//
2946	// For unqualified declarations, the semantic context can change
2947	// along the redeclaration chain (for local extern declarations,
2948	// extern "C" declarations, and friend declarations in particular).
2949	if (!NewD->getQualifier())
2950	return;
2951
2952	// NewD is probably already in the right context.
2953	auto *NamedDC = NewD->getDeclContext()->getRedeclContext();
2954	auto *SemaDC = OldD->getDeclContext()->getRedeclContext();
2955	if (NamedDC->Equals(SemaDC))
2956	return;
2957
2958	assert((NamedDC->InEnclosingNamespaceSetOf(SemaDC) \|\|(((NamedDC->InEnclosingNamespaceSetOf(SemaDC) \|\| NewD-> isInvalidDecl() \|\| OldD->isInvalidDecl()) && "unexpected context for redeclaration" ) ? static_cast<void> (0) : __assert_fail ("(NamedDC->InEnclosingNamespaceSetOf(SemaDC) \|\| NewD->isInvalidDecl() \|\| OldD->isInvalidDecl()) && \"unexpected context for redeclaration\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 2960, __PRETTY_FUNCTION__))
2959	NewD->isInvalidDecl() \|\| OldD->isInvalidDecl()) &&(((NamedDC->InEnclosingNamespaceSetOf(SemaDC) \|\| NewD-> isInvalidDecl() \|\| OldD->isInvalidDecl()) && "unexpected context for redeclaration" ) ? static_cast<void> (0) : __assert_fail ("(NamedDC->InEnclosingNamespaceSetOf(SemaDC) \|\| NewD->isInvalidDecl() \|\| OldD->isInvalidDecl()) && \"unexpected context for redeclaration\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 2960, __PRETTY_FUNCTION__))
2960	"unexpected context for redeclaration")(((NamedDC->InEnclosingNamespaceSetOf(SemaDC) \|\| NewD-> isInvalidDecl() \|\| OldD->isInvalidDecl()) && "unexpected context for redeclaration" ) ? static_cast<void> (0) : __assert_fail ("(NamedDC->InEnclosingNamespaceSetOf(SemaDC) \|\| NewD->isInvalidDecl() \|\| OldD->isInvalidDecl()) && \"unexpected context for redeclaration\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 2960, __PRETTY_FUNCTION__));
2961
2962	auto *LexDC = NewD->getLexicalDeclContext();
2963	auto FixSemaDC = [=](NamedDecl *D) {
2964	if (!D)
2965	return;
2966	D->setDeclContext(SemaDC);
2967	D->setLexicalDeclContext(LexDC);
2968	};
2969
2970	FixSemaDC(NewD);
2971	if (auto *FD = dyn_cast<FunctionDecl>(NewD))
2972	FixSemaDC(FD->getDescribedFunctionTemplate());
2973	else if (auto *VD = dyn_cast<VarDecl>(NewD))
2974	FixSemaDC(VD->getDescribedVarTemplate());
2975	}
2976
2977	/// MergeFunctionDecl - We just parsed a function 'New' from
2978	/// declarator D which has the same name and scope as a previous
2979	/// declaration 'Old'. Figure out how to resolve this situation,
2980	/// merging decls or emitting diagnostics as appropriate.
2981	///
2982	/// In C++, New and Old must be declarations that are not
2983	/// overloaded. Use IsOverload to determine whether New and Old are
2984	/// overloaded, and to select the Old declaration that New should be
2985	/// merged with.
2986	///
2987	/// Returns true if there was an error, false otherwise.
2988	bool Sema::MergeFunctionDecl(FunctionDecl New, NamedDecl &OldD,
2989	Scope *S, bool MergeTypeWithOld) {
2990	// Verify the old decl was also a function.
2991	FunctionDecl *Old = OldD->getAsFunction();
2992	if (!Old) {
2993	if (UsingShadowDecl *Shadow = dyn_cast<UsingShadowDecl>(OldD)) {
2994	if (New->getFriendObjectKind()) {
2995	Diag(New->getLocation(), diag::err_using_decl_friend);
2996	Diag(Shadow->getTargetDecl()->getLocation(),
2997	diag::note_using_decl_target);
2998	Diag(Shadow->getUsingDecl()->getLocation(),
2999	diag::note_using_decl) << 0;
3000	return true;
3001	}
3002
3003	// Check whether the two declarations might declare the same function.
3004	if (checkUsingShadowRedecl<FunctionDecl>(*this, Shadow, New))
3005	return true;
3006	OldD = Old = cast<FunctionDecl>(Shadow->getTargetDecl());
3007	} else {
3008	Diag(New->getLocation(), diag::err_redefinition_different_kind)
3009	<< New->getDeclName();
3010	notePreviousDefinition(OldD, New->getLocation());
3011	return true;
3012	}
3013	}
3014
3015	// If the old declaration is invalid, just give up here.
3016	if (Old->isInvalidDecl())
3017	return true;
3018
3019	// Disallow redeclaration of some builtins.
3020	if (!getASTContext().canBuiltinBeRedeclared(Old)) {
3021	Diag(New->getLocation(), diag::err_builtin_redeclare) << Old->getDeclName();
3022	Diag(Old->getLocation(), diag::note_previous_builtin_declaration)
3023	<< Old << Old->getType();
3024	return true;
3025	}
3026
3027	diag::kind PrevDiag;
3028	SourceLocation OldLocation;
3029	std::tie(PrevDiag, OldLocation) =
3030	getNoteDiagForInvalidRedeclaration(Old, New);
3031
3032	// Don't complain about this if we're in GNU89 mode and the old function
3033	// is an extern inline function.
3034	// Don't complain about specializations. They are not supposed to have
3035	// storage classes.
3036	if (!isa<CXXMethodDecl>(New) && !isa<CXXMethodDecl>(Old) &&
3037	New->getStorageClass() == SC_Static &&
3038	Old->hasExternalFormalLinkage() &&
3039	!New->getTemplateSpecializationInfo() &&
3040	!canRedefineFunction(Old, getLangOpts())) {
3041	if (getLangOpts().MicrosoftExt) {
3042	Diag(New->getLocation(), diag::ext_static_non_static) << New;
3043	Diag(OldLocation, PrevDiag);
3044	} else {
3045	Diag(New->getLocation(), diag::err_static_non_static) << New;
3046	Diag(OldLocation, PrevDiag);
3047	return true;
3048	}
3049	}
3050
3051	if (New->hasAttr<InternalLinkageAttr>() &&
3052	!Old->hasAttr<InternalLinkageAttr>()) {
3053	Diag(New->getLocation(), diag::err_internal_linkage_redeclaration)
3054	<< New->getDeclName();
3055	notePreviousDefinition(Old, New->getLocation());
3056	New->dropAttr<InternalLinkageAttr>();
3057	}
3058
3059	if (CheckRedeclarationModuleOwnership(New, Old))
3060	return true;
3061
3062	if (!getLangOpts().CPlusPlus) {
3063	bool OldOvl = Old->hasAttr<OverloadableAttr>();
3064	if (OldOvl != New->hasAttr<OverloadableAttr>() && !Old->isImplicit()) {
3065	Diag(New->getLocation(), diag::err_attribute_overloadable_mismatch)
3066	<< New << OldOvl;
3067
3068	// Try our best to find a decl that actually has the overloadable
3069	// attribute for the note. In most cases (e.g. programs with only one
3070	// broken declaration/definition), this won't matter.
3071	//
3072	// FIXME: We could do this if we juggled some extra state in
3073	// OverloadableAttr, rather than just removing it.
3074	const Decl *DiagOld = Old;
3075	if (OldOvl) {
3076	auto OldIter = llvm::find_if(Old->redecls(), [](const Decl *D) {
3077	const auto *A = D->getAttr<OverloadableAttr>();
3078	return A && !A->isImplicit();
3079	});
3080	// If we've implicitly added all of the overloadable attrs to this
3081	// chain, emitting a "previous redecl" note is pointless.
3082	DiagOld = OldIter == Old->redecls_end() ? nullptr : *OldIter;
3083	}
3084
3085	if (DiagOld)
3086	Diag(DiagOld->getLocation(),
3087	diag::note_attribute_overloadable_prev_overload)
3088	<< OldOvl;
3089
3090	if (OldOvl)
3091	New->addAttr(OverloadableAttr::CreateImplicit(Context));
3092	else
3093	New->dropAttr<OverloadableAttr>();
3094	}
3095	}
3096
3097	// If a function is first declared with a calling convention, but is later
3098	// declared or defined without one, all following decls assume the calling
3099	// convention of the first.
3100	//
3101	// It's OK if a function is first declared without a calling convention,
3102	// but is later declared or defined with the default calling convention.
3103	//
3104	// To test if either decl has an explicit calling convention, we look for
3105	// AttributedType sugar nodes on the type as written. If they are missing or
3106	// were canonicalized away, we assume the calling convention was implicit.
3107	//
3108	// Note also that we DO NOT return at this point, because we still have
3109	// other tests to run.
3110	QualType OldQType = Context.getCanonicalType(Old->getType());
3111	QualType NewQType = Context.getCanonicalType(New->getType());
3112	const FunctionType *OldType = cast<FunctionType>(OldQType);
3113	const FunctionType *NewType = cast<FunctionType>(NewQType);
3114	FunctionType::ExtInfo OldTypeInfo = OldType->getExtInfo();
3115	FunctionType::ExtInfo NewTypeInfo = NewType->getExtInfo();
3116	bool RequiresAdjustment = false;
3117
3118	if (OldTypeInfo.getCC() != NewTypeInfo.getCC()) {
3119	FunctionDecl *First = Old->getFirstDecl();
3120	const FunctionType *FT =
3121	First->getType().getCanonicalType()->castAs<FunctionType>();
3122	FunctionType::ExtInfo FI = FT->getExtInfo();
3123	bool NewCCExplicit = getCallingConvAttributedType(New->getType());
3124	if (!NewCCExplicit) {
3125	// Inherit the CC from the previous declaration if it was specified
3126	// there but not here.
3127	NewTypeInfo = NewTypeInfo.withCallingConv(OldTypeInfo.getCC());
3128	RequiresAdjustment = true;
3129	} else {
3130	// Calling conventions aren't compatible, so complain.
3131	bool FirstCCExplicit = getCallingConvAttributedType(First->getType());
3132	Diag(New->getLocation(), diag::err_cconv_change)
3133	<< FunctionType::getNameForCallConv(NewTypeInfo.getCC())
3134	<< !FirstCCExplicit
3135	<< (!FirstCCExplicit ? "" :
3136	FunctionType::getNameForCallConv(FI.getCC()));
3137
3138	// Put the note on the first decl, since it is the one that matters.
3139	Diag(First->getLocation(), diag::note_previous_declaration);
3140	return true;
3141	}
3142	}
3143
3144	// FIXME: diagnose the other way around?
3145	if (OldTypeInfo.getNoReturn() && !NewTypeInfo.getNoReturn()) {
3146	NewTypeInfo = NewTypeInfo.withNoReturn(true);
3147	RequiresAdjustment = true;
3148	}
3149
3150	// Merge regparm attribute.
3151	if (OldTypeInfo.getHasRegParm() != NewTypeInfo.getHasRegParm() \|\|
3152	OldTypeInfo.getRegParm() != NewTypeInfo.getRegParm()) {
3153	if (NewTypeInfo.getHasRegParm()) {
3154	Diag(New->getLocation(), diag::err_regparm_mismatch)
3155	<< NewType->getRegParmType()
3156	<< OldType->getRegParmType();
3157	Diag(OldLocation, diag::note_previous_declaration);
3158	return true;
3159	}
3160
3161	NewTypeInfo = NewTypeInfo.withRegParm(OldTypeInfo.getRegParm());
3162	RequiresAdjustment = true;
3163	}
3164
3165	// Merge ns_returns_retained attribute.
3166	if (OldTypeInfo.getProducesResult() != NewTypeInfo.getProducesResult()) {
3167	if (NewTypeInfo.getProducesResult()) {
3168	Diag(New->getLocation(), diag::err_function_attribute_mismatch)
3169	<< "'ns_returns_retained'";
3170	Diag(OldLocation, diag::note_previous_declaration);
3171	return true;
3172	}
3173
3174	NewTypeInfo = NewTypeInfo.withProducesResult(true);
3175	RequiresAdjustment = true;
3176	}
3177
3178	if (OldTypeInfo.getNoCallerSavedRegs() !=
3179	NewTypeInfo.getNoCallerSavedRegs()) {
3180	if (NewTypeInfo.getNoCallerSavedRegs()) {
3181	AnyX86NoCallerSavedRegistersAttr *Attr =
3182	New->getAttr<AnyX86NoCallerSavedRegistersAttr>();
3183	Diag(New->getLocation(), diag::err_function_attribute_mismatch) << Attr;
3184	Diag(OldLocation, diag::note_previous_declaration);
3185	return true;
3186	}
3187
3188	NewTypeInfo = NewTypeInfo.withNoCallerSavedRegs(true);
3189	RequiresAdjustment = true;
3190	}
3191
3192	if (RequiresAdjustment) {
3193	const FunctionType *AdjustedType = New->getType()->getAs<FunctionType>();
3194	AdjustedType = Context.adjustFunctionType(AdjustedType, NewTypeInfo);
3195	New->setType(QualType(AdjustedType, 0));
3196	NewQType = Context.getCanonicalType(New->getType());
3197	NewType = cast<FunctionType>(NewQType);
	Value stored to 'NewType' is never read
3198	}
3199
3200	// If this redeclaration makes the function inline, we may need to add it to
3201	// UndefinedButUsed.
3202	if (!Old->isInlined() && New->isInlined() &&
3203	!New->hasAttr<GNUInlineAttr>() &&
3204	!getLangOpts().GNUInline &&
3205	Old->isUsed(false) &&
3206	!Old->isDefined() && !New->isThisDeclarationADefinition())
3207	UndefinedButUsed.insert(std::make_pair(Old->getCanonicalDecl(),
3208	SourceLocation()));
3209
3210	// If this redeclaration makes it newly gnu_inline, we don't want to warn
3211	// about it.
3212	if (New->hasAttr<GNUInlineAttr>() &&
3213	Old->isInlined() && !Old->hasAttr<GNUInlineAttr>()) {
3214	UndefinedButUsed.erase(Old->getCanonicalDecl());
3215	}
3216
3217	// If pass_object_size params don't match up perfectly, this isn't a valid
3218	// redeclaration.
3219	if (Old->getNumParams() > 0 && Old->getNumParams() == New->getNumParams() &&
3220	!hasIdenticalPassObjectSizeAttrs(Old, New)) {
3221	Diag(New->getLocation(), diag::err_different_pass_object_size_params)
3222	<< New->getDeclName();
3223	Diag(OldLocation, PrevDiag) << Old << Old->getType();
3224	return true;
3225	}
3226
3227	if (getLangOpts().CPlusPlus) {
3228	// C++1z [over.load]p2
3229	// Certain function declarations cannot be overloaded:
3230	// -- Function declarations that differ only in the return type,
3231	// the exception specification, or both cannot be overloaded.
3232
3233	// Check the exception specifications match. This may recompute the type of
3234	// both Old and New if it resolved exception specifications, so grab the
3235	// types again after this. Because this updates the type, we do this before
3236	// any of the other checks below, which may update the "de facto" NewQType
3237	// but do not necessarily update the type of New.
3238	if (CheckEquivalentExceptionSpec(Old, New))
3239	return true;
3240	OldQType = Context.getCanonicalType(Old->getType());
3241	NewQType = Context.getCanonicalType(New->getType());
3242
3243	// Go back to the type source info to compare the declared return types,
3244	// per C++1y [dcl.type.auto]p13:
3245	// Redeclarations or specializations of a function or function template
3246	// with a declared return type that uses a placeholder type shall also
3247	// use that placeholder, not a deduced type.
3248	QualType OldDeclaredReturnType = Old->getDeclaredReturnType();
3249	QualType NewDeclaredReturnType = New->getDeclaredReturnType();
3250	if (!Context.hasSameType(OldDeclaredReturnType, NewDeclaredReturnType) &&
3251	canFullyTypeCheckRedeclaration(New, Old, NewDeclaredReturnType,
3252	OldDeclaredReturnType)) {
3253	QualType ResQT;
3254	if (NewDeclaredReturnType->isObjCObjectPointerType() &&
3255	OldDeclaredReturnType->isObjCObjectPointerType())
3256	// FIXME: This does the wrong thing for a deduced return type.
3257	ResQT = Context.mergeObjCGCQualifiers(NewQType, OldQType);
3258	if (ResQT.isNull()) {
3259	if (New->isCXXClassMember() && New->isOutOfLine())
3260	Diag(New->getLocation(), diag::err_member_def_does_not_match_ret_type)
3261	<< New << New->getReturnTypeSourceRange();
3262	else
3263	Diag(New->getLocation(), diag::err_ovl_diff_return_type)
3264	<< New->getReturnTypeSourceRange();
3265	Diag(OldLocation, PrevDiag) << Old << Old->getType()
3266	<< Old->getReturnTypeSourceRange();
3267	return true;
3268	}
3269	else
3270	NewQType = ResQT;
3271	}
3272
3273	QualType OldReturnType = OldType->getReturnType();
3274	QualType NewReturnType = cast<FunctionType>(NewQType)->getReturnType();
3275	if (OldReturnType != NewReturnType) {
3276	// If this function has a deduced return type and has already been
3277	// defined, copy the deduced value from the old declaration.
3278	AutoType *OldAT = Old->getReturnType()->getContainedAutoType();
3279	if (OldAT && OldAT->isDeduced()) {
3280	New->setType(
3281	SubstAutoType(New->getType(),
3282	OldAT->isDependentType() ? Context.DependentTy
3283	: OldAT->getDeducedType()));
3284	NewQType = Context.getCanonicalType(
3285	SubstAutoType(NewQType,
3286	OldAT->isDependentType() ? Context.DependentTy
3287	: OldAT->getDeducedType()));
3288	}
3289	}
3290
3291	const CXXMethodDecl *OldMethod = dyn_cast<CXXMethodDecl>(Old);
3292	CXXMethodDecl *NewMethod = dyn_cast<CXXMethodDecl>(New);
3293	if (OldMethod && NewMethod) {
3294	// Preserve triviality.
3295	NewMethod->setTrivial(OldMethod->isTrivial());
3296
3297	// MSVC allows explicit template specialization at class scope:
3298	// 2 CXXMethodDecls referring to the same function will be injected.
3299	// We don't want a redeclaration error.
3300	bool IsClassScopeExplicitSpecialization =
3301	OldMethod->isFunctionTemplateSpecialization() &&
3302	NewMethod->isFunctionTemplateSpecialization();
3303	bool isFriend = NewMethod->getFriendObjectKind();
3304
3305	if (!isFriend && NewMethod->getLexicalDeclContext()->isRecord() &&
3306	!IsClassScopeExplicitSpecialization) {
3307	// -- Member function declarations with the same name and the
3308	// same parameter types cannot be overloaded if any of them
3309	// is a static member function declaration.
3310	if (OldMethod->isStatic() != NewMethod->isStatic()) {
3311	Diag(New->getLocation(), diag::err_ovl_static_nonstatic_member);
3312	Diag(OldLocation, PrevDiag) << Old << Old->getType();
3313	return true;
3314	}
3315
3316	// C++ [class.mem]p1:
3317	// [...] A member shall not be declared twice in the
3318	// member-specification, except that a nested class or member
3319	// class template can be declared and then later defined.
3320	if (!inTemplateInstantiation()) {
3321	unsigned NewDiag;
3322	if (isa<CXXConstructorDecl>(OldMethod))
3323	NewDiag = diag::err_constructor_redeclared;
3324	else if (isa<CXXDestructorDecl>(NewMethod))
3325	NewDiag = diag::err_destructor_redeclared;
3326	else if (isa<CXXConversionDecl>(NewMethod))
3327	NewDiag = diag::err_conv_function_redeclared;
3328	else
3329	NewDiag = diag::err_member_redeclared;
3330
3331	Diag(New->getLocation(), NewDiag);
3332	} else {
3333	Diag(New->getLocation(), diag::err_member_redeclared_in_instantiation)
3334	<< New << New->getType();
3335	}
3336	Diag(OldLocation, PrevDiag) << Old << Old->getType();
3337	return true;
3338
3339	// Complain if this is an explicit declaration of a special
3340	// member that was initially declared implicitly.
3341	//
3342	// As an exception, it's okay to befriend such methods in order
3343	// to permit the implicit constructor/destructor/operator calls.
3344	} else if (OldMethod->isImplicit()) {
3345	if (isFriend) {
3346	NewMethod->setImplicit();
3347	} else {
3348	Diag(NewMethod->getLocation(),
3349	diag::err_definition_of_implicitly_declared_member)
3350	<< New << getSpecialMember(OldMethod);
3351	return true;
3352	}
3353	} else if (OldMethod->getFirstDecl()->isExplicitlyDefaulted() && !isFriend) {
3354	Diag(NewMethod->getLocation(),
3355	diag::err_definition_of_explicitly_defaulted_member)
3356	<< getSpecialMember(OldMethod);
3357	return true;
3358	}
3359	}
3360
3361	// C++11 [dcl.attr.noreturn]p1:
3362	// The first declaration of a function shall specify the noreturn
3363	// attribute if any declaration of that function specifies the noreturn
3364	// attribute.
3365	const CXX11NoReturnAttr *NRA = New->getAttr<CXX11NoReturnAttr>();
3366	if (NRA && !Old->hasAttr<CXX11NoReturnAttr>()) {
3367	Diag(NRA->getLocation(), diag::err_noreturn_missing_on_first_decl);
3368	Diag(Old->getFirstDecl()->getLocation(),
3369	diag::note_noreturn_missing_first_decl);
3370	}
3371
3372	// C++11 [dcl.attr.depend]p2:
3373	// The first declaration of a function shall specify the
3374	// carries_dependency attribute for its declarator-id if any declaration
3375	// of the function specifies the carries_dependency attribute.
3376	const CarriesDependencyAttr *CDA = New->getAttr<CarriesDependencyAttr>();
3377	if (CDA && !Old->hasAttr<CarriesDependencyAttr>()) {
3378	Diag(CDA->getLocation(),
3379	diag::err_carries_dependency_missing_on_first_decl) << 0/Function/;
3380	Diag(Old->getFirstDecl()->getLocation(),
3381	diag::note_carries_dependency_missing_first_decl) << 0/Function/;
3382	}
3383
3384	// (C++98 8.3.5p3):
3385	// All declarations for a function shall agree exactly in both the
3386	// return type and the parameter-type-list.
3387	// We also want to respect all the extended bits except noreturn.
3388
3389	// noreturn should now match unless the old type info didn't have it.
3390	QualType OldQTypeForComparison = OldQType;
3391	if (!OldTypeInfo.getNoReturn() && NewTypeInfo.getNoReturn()) {
3392	auto *OldType = OldQType->castAs<FunctionProtoType>();
3393	const FunctionType *OldTypeForComparison
3394	= Context.adjustFunctionType(OldType, OldTypeInfo.withNoReturn(true));
3395	OldQTypeForComparison = QualType(OldTypeForComparison, 0);
3396	assert(OldQTypeForComparison.isCanonical())((OldQTypeForComparison.isCanonical()) ? static_cast<void> (0) : __assert_fail ("OldQTypeForComparison.isCanonical()", "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 3396, __PRETTY_FUNCTION__));
3397	}
3398
3399	if (haveIncompatibleLanguageLinkages(Old, New)) {
3400	// As a special case, retain the language linkage from previous
3401	// declarations of a friend function as an extension.
3402	//
3403	// This liberal interpretation of C++ [class.friend]p3 matches GCC/MSVC
3404	// and is useful because there's otherwise no way to specify language
3405	// linkage within class scope.
3406	//
3407	// Check cautiously as the friend object kind isn't yet complete.
3408	if (New->getFriendObjectKind() != Decl::FOK_None) {
3409	Diag(New->getLocation(), diag::ext_retained_language_linkage) << New;
3410	Diag(OldLocation, PrevDiag);
3411	} else {
3412	Diag(New->getLocation(), diag::err_different_language_linkage) << New;
3413	Diag(OldLocation, PrevDiag);
3414	return true;
3415	}
3416	}
3417
3418	if (OldQTypeForComparison == NewQType)
3419	return MergeCompatibleFunctionDecls(New, Old, S, MergeTypeWithOld);
3420
3421	// If the types are imprecise (due to dependent constructs in friends or
3422	// local extern declarations), it's OK if they differ. We'll check again
3423	// during instantiation.
3424	if (!canFullyTypeCheckRedeclaration(New, Old, NewQType, OldQType))
3425	return false;
3426
3427	// Fall through for conflicting redeclarations and redefinitions.
3428	}
3429
3430	// C: Function types need to be compatible, not identical. This handles
3431	// duplicate function decls like "void f(int); void f(enum X);" properly.
3432	if (!getLangOpts().CPlusPlus &&
3433	Context.typesAreCompatible(OldQType, NewQType)) {
3434	const FunctionType *OldFuncType = OldQType->getAs<FunctionType>();
3435	const FunctionType *NewFuncType = NewQType->getAs<FunctionType>();
3436	const FunctionProtoType *OldProto = nullptr;
3437	if (MergeTypeWithOld && isa<FunctionNoProtoType>(NewFuncType) &&
3438	(OldProto = dyn_cast<FunctionProtoType>(OldFuncType))) {
3439	// The old declaration provided a function prototype, but the
3440	// new declaration does not. Merge in the prototype.
3441	assert(!OldProto->hasExceptionSpec() && "Exception spec in C")((!OldProto->hasExceptionSpec() && "Exception spec in C" ) ? static_cast<void> (0) : __assert_fail ("!OldProto->hasExceptionSpec() && \"Exception spec in C\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 3441, __PRETTY_FUNCTION__));
3442	SmallVector<QualType, 16> ParamTypes(OldProto->param_types());
3443	NewQType =
3444	Context.getFunctionType(NewFuncType->getReturnType(), ParamTypes,
3445	OldProto->getExtProtoInfo());
3446	New->setType(NewQType);
3447	New->setHasInheritedPrototype();
3448
3449	// Synthesize parameters with the same types.
3450	SmallVector<ParmVarDecl*, 16> Params;
3451	for (const auto &ParamType : OldProto->param_types()) {
3452	ParmVarDecl *Param = ParmVarDecl::Create(Context, New, SourceLocation(),
3453	SourceLocation(), nullptr,
3454	ParamType, /TInfo=/nullptr,
3455	SC_None, nullptr);
3456	Param->setScopeInfo(0, Params.size());
3457	Param->setImplicit();
3458	Params.push_back(Param);
3459	}
3460
3461	New->setParams(Params);
3462	}
3463
3464	return MergeCompatibleFunctionDecls(New, Old, S, MergeTypeWithOld);
3465	}
3466
3467	// GNU C permits a K&R definition to follow a prototype declaration
3468	// if the declared types of the parameters in the K&R definition
3469	// match the types in the prototype declaration, even when the
3470	// promoted types of the parameters from the K&R definition differ
3471	// from the types in the prototype. GCC then keeps the types from
3472	// the prototype.
3473	//
3474	// If a variadic prototype is followed by a non-variadic K&R definition,
3475	// the K&R definition becomes variadic. This is sort of an edge case, but
3476	// it's legal per the standard depending on how you read C99 6.7.5.3p15 and
3477	// C99 6.9.1p8.
3478	if (!getLangOpts().CPlusPlus &&
3479	Old->hasPrototype() && !New->hasPrototype() &&
3480	New->getType()->getAs<FunctionProtoType>() &&
3481	Old->getNumParams() == New->getNumParams()) {
3482	SmallVector<QualType, 16> ArgTypes;
3483	SmallVector<GNUCompatibleParamWarning, 16> Warnings;
3484	const FunctionProtoType *OldProto
3485	= Old->getType()->getAs<FunctionProtoType>();
3486	const FunctionProtoType *NewProto
3487	= New->getType()->getAs<FunctionProtoType>();
3488
3489	// Determine whether this is the GNU C extension.
3490	QualType MergedReturn = Context.mergeTypes(OldProto->getReturnType(),
3491	NewProto->getReturnType());
3492	bool LooseCompatible = !MergedReturn.isNull();
3493	for (unsigned Idx = 0, End = Old->getNumParams();
3494	LooseCompatible && Idx != End; ++Idx) {
3495	ParmVarDecl *OldParm = Old->getParamDecl(Idx);
3496	ParmVarDecl *NewParm = New->getParamDecl(Idx);
3497	if (Context.typesAreCompatible(OldParm->getType(),
3498	NewProto->getParamType(Idx))) {
3499	ArgTypes.push_back(NewParm->getType());
3500	} else if (Context.typesAreCompatible(OldParm->getType(),
3501	NewParm->getType(),
3502	/CompareUnqualified=/true)) {
3503	GNUCompatibleParamWarning Warn = { OldParm, NewParm,
3504	NewProto->getParamType(Idx) };
3505	Warnings.push_back(Warn);
3506	ArgTypes.push_back(NewParm->getType());
3507	} else
3508	LooseCompatible = false;
3509	}
3510
3511	if (LooseCompatible) {
3512	for (unsigned Warn = 0; Warn < Warnings.size(); ++Warn) {
3513	Diag(Warnings[Warn].NewParm->getLocation(),
3514	diag::ext_param_promoted_not_compatible_with_prototype)
3515	<< Warnings[Warn].PromotedType
3516	<< Warnings[Warn].OldParm->getType();
3517	if (Warnings[Warn].OldParm->getLocation().isValid())
3518	Diag(Warnings[Warn].OldParm->getLocation(),
3519	diag::note_previous_declaration);
3520	}
3521
3522	if (MergeTypeWithOld)
3523	New->setType(Context.getFunctionType(MergedReturn, ArgTypes,
3524	OldProto->getExtProtoInfo()));
3525	return MergeCompatibleFunctionDecls(New, Old, S, MergeTypeWithOld);
3526	}
3527
3528	// Fall through to diagnose conflicting types.
3529	}
3530
3531	// A function that has already been declared has been redeclared or
3532	// defined with a different type; show an appropriate diagnostic.
3533
3534	// If the previous declaration was an implicitly-generated builtin
3535	// declaration, then at the very least we should use a specialized note.
3536	unsigned BuiltinID;
3537	if (Old->isImplicit() && (BuiltinID = Old->getBuiltinID())) {
3538	// If it's actually a library-defined builtin function like 'malloc'
3539	// or 'printf', just warn about the incompatible redeclaration.
3540	if (Context.BuiltinInfo.isPredefinedLibFunction(BuiltinID)) {
3541	Diag(New->getLocation(), diag::warn_redecl_library_builtin) << New;
3542	Diag(OldLocation, diag::note_previous_builtin_declaration)
3543	<< Old << Old->getType();
3544
3545	// If this is a global redeclaration, just forget hereafter
3546	// about the "builtin-ness" of the function.
3547	//
3548	// Doing this for local extern declarations is problematic. If
3549	// the builtin declaration remains visible, a second invalid
3550	// local declaration will produce a hard error; if it doesn't
3551	// remain visible, a single bogus local redeclaration (which is
3552	// actually only a warning) could break all the downstream code.
3553	if (!New->getLexicalDeclContext()->isFunctionOrMethod())
3554	New->getIdentifier()->revertBuiltin();
3555
3556	return false;
3557	}
3558
3559	PrevDiag = diag::note_previous_builtin_declaration;
3560	}
3561
3562	Diag(New->getLocation(), diag::err_conflicting_types) << New->getDeclName();
3563	Diag(OldLocation, PrevDiag) << Old << Old->getType();
3564	return true;
3565	}
3566
3567	/// Completes the merge of two function declarations that are
3568	/// known to be compatible.
3569	///
3570	/// This routine handles the merging of attributes and other
3571	/// properties of function declarations from the old declaration to
3572	/// the new declaration, once we know that New is in fact a
3573	/// redeclaration of Old.
3574	///
3575	/// \returns false
3576	bool Sema::MergeCompatibleFunctionDecls(FunctionDecl New, FunctionDecl Old,
3577	Scope *S, bool MergeTypeWithOld) {
3578	// Merge the attributes
3579	mergeDeclAttributes(New, Old);
3580
3581	// Merge "pure" flag.
3582	if (Old->isPure())
3583	New->setPure();
3584
3585	// Merge "used" flag.
3586	if (Old->getMostRecentDecl()->isUsed(false))
3587	New->setIsUsed();
3588
3589	// Merge attributes from the parameters. These can mismatch with K&R
3590	// declarations.
3591	if (New->getNumParams() == Old->getNumParams())
3592	for (unsigned i = 0, e = New->getNumParams(); i != e; ++i) {
3593	ParmVarDecl *NewParam = New->getParamDecl(i);
3594	ParmVarDecl *OldParam = Old->getParamDecl(i);
3595	mergeParamDeclAttributes(NewParam, OldParam, *this);
3596	mergeParamDeclTypes(NewParam, OldParam, *this);
3597	}
3598
3599	if (getLangOpts().CPlusPlus)
3600	return MergeCXXFunctionDecl(New, Old, S);
3601
3602	// Merge the function types so the we get the composite types for the return
3603	// and argument types. Per C11 6.2.7/4, only update the type if the old decl
3604	// was visible.
3605	QualType Merged = Context.mergeTypes(Old->getType(), New->getType());
3606	if (!Merged.isNull() && MergeTypeWithOld)
3607	New->setType(Merged);
3608
3609	return false;
3610	}
3611
3612	void Sema::mergeObjCMethodDecls(ObjCMethodDecl *newMethod,
3613	ObjCMethodDecl *oldMethod) {
3614	// Merge the attributes, including deprecated/unavailable
3615	AvailabilityMergeKind MergeKind =
3616	isa<ObjCProtocolDecl>(oldMethod->getDeclContext())
3617	? AMK_ProtocolImplementation
3618	: isa<ObjCImplDecl>(newMethod->getDeclContext()) ? AMK_Redeclaration
3619	: AMK_Override;
3620
3621	mergeDeclAttributes(newMethod, oldMethod, MergeKind);
3622
3623	// Merge attributes from the parameters.
3624	ObjCMethodDecl::param_const_iterator oi = oldMethod->param_begin(),
3625	oe = oldMethod->param_end();
3626	for (ObjCMethodDecl::param_iterator
3627	ni = newMethod->param_begin(), ne = newMethod->param_end();
3628	ni != ne && oi != oe; ++ni, ++oi)
3629	mergeParamDeclAttributes(ni, oi, *this);
3630
3631	CheckObjCMethodOverride(newMethod, oldMethod);
3632	}
3633
3634	static void diagnoseVarDeclTypeMismatch(Sema &S, VarDecl New, VarDecl Old) {
3635	assert(!S.Context.hasSameType(New->getType(), Old->getType()))((!S.Context.hasSameType(New->getType(), Old->getType() )) ? static_cast<void> (0) : __assert_fail ("!S.Context.hasSameType(New->getType(), Old->getType())" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 3635, __PRETTY_FUNCTION__));
3636
3637	S.Diag(New->getLocation(), New->isThisDeclarationADefinition()
3638	? diag::err_redefinition_different_type
3639	: diag::err_redeclaration_different_type)
3640	<< New->getDeclName() << New->getType() << Old->getType();
3641
3642	diag::kind PrevDiag;
3643	SourceLocation OldLocation;
3644	std::tie(PrevDiag, OldLocation)
3645	= getNoteDiagForInvalidRedeclaration(Old, New);
3646	S.Diag(OldLocation, PrevDiag);
3647	New->setInvalidDecl();
3648	}
3649
3650	/// MergeVarDeclTypes - We parsed a variable 'New' which has the same name and
3651	/// scope as a previous declaration 'Old'. Figure out how to merge their types,
3652	/// emitting diagnostics as appropriate.
3653	///
3654	/// Declarations using the auto type specifier (C++ [decl.spec.auto]) call back
3655	/// to here in AddInitializerToDecl. We can't check them before the initializer
3656	/// is attached.
3657	void Sema::MergeVarDeclTypes(VarDecl New, VarDecl Old,
3658	bool MergeTypeWithOld) {
3659	if (New->isInvalidDecl() \|\| Old->isInvalidDecl())
3660	return;
3661
3662	QualType MergedT;
3663	if (getLangOpts().CPlusPlus) {
3664	if (New->getType()->isUndeducedType()) {
3665	// We don't know what the new type is until the initializer is attached.
3666	return;
3667	} else if (Context.hasSameType(New->getType(), Old->getType())) {
3668	// These could still be something that needs exception specs checked.
3669	return MergeVarDeclExceptionSpecs(New, Old);
3670	}
3671	// C++ [basic.link]p10:
3672	// [...] the types specified by all declarations referring to a given
3673	// object or function shall be identical, except that declarations for an
3674	// array object can specify array types that differ by the presence or
3675	// absence of a major array bound (8.3.4).
3676	else if (Old->getType()->isArrayType() && New->getType()->isArrayType()) {
3677	const ArrayType *OldArray = Context.getAsArrayType(Old->getType());
3678	const ArrayType *NewArray = Context.getAsArrayType(New->getType());
3679
3680	// We are merging a variable declaration New into Old. If it has an array
3681	// bound, and that bound differs from Old's bound, we should diagnose the
3682	// mismatch.
3683	if (!NewArray->isIncompleteArrayType() && !NewArray->isDependentType()) {
3684	for (VarDecl *PrevVD = Old->getMostRecentDecl(); PrevVD;
3685	PrevVD = PrevVD->getPreviousDecl()) {
3686	const ArrayType *PrevVDTy = Context.getAsArrayType(PrevVD->getType());
3687	if (PrevVDTy->isIncompleteArrayType() \|\| PrevVDTy->isDependentType())
3688	continue;
3689
3690	if (!Context.hasSameType(NewArray, PrevVDTy))
3691	return diagnoseVarDeclTypeMismatch(*this, New, PrevVD);
3692	}
3693	}
3694
3695	if (OldArray->isIncompleteArrayType() && NewArray->isArrayType()) {
3696	if (Context.hasSameType(OldArray->getElementType(),
3697	NewArray->getElementType()))
3698	MergedT = New->getType();
3699	}
3700	// FIXME: Check visibility. New is hidden but has a complete type. If New
3701	// has no array bound, it should not inherit one from Old, if Old is not
3702	// visible.
3703	else if (OldArray->isArrayType() && NewArray->isIncompleteArrayType()) {
3704	if (Context.hasSameType(OldArray->getElementType(),
3705	NewArray->getElementType()))
3706	MergedT = Old->getType();
3707	}
3708	}
3709	else if (New->getType()->isObjCObjectPointerType() &&
3710	Old->getType()->isObjCObjectPointerType()) {
3711	MergedT = Context.mergeObjCGCQualifiers(New->getType(),
3712	Old->getType());
3713	}
3714	} else {
3715	// C 6.2.7p2:
3716	// All declarations that refer to the same object or function shall have
3717	// compatible type.
3718	MergedT = Context.mergeTypes(New->getType(), Old->getType());
3719	}
3720	if (MergedT.isNull()) {
3721	// It's OK if we couldn't merge types if either type is dependent, for a
3722	// block-scope variable. In other cases (static data members of class
3723	// templates, variable templates, ...), we require the types to be
3724	// equivalent.
3725	// FIXME: The C++ standard doesn't say anything about this.
3726	if ((New->getType()->isDependentType() \|\|
3727	Old->getType()->isDependentType()) && New->isLocalVarDecl()) {
3728	// If the old type was dependent, we can't merge with it, so the new type
3729	// becomes dependent for now. We'll reproduce the original type when we
3730	// instantiate the TypeSourceInfo for the variable.
3731	if (!New->getType()->isDependentType() && MergeTypeWithOld)
3732	New->setType(Context.DependentTy);
3733	return;
3734	}
3735	return diagnoseVarDeclTypeMismatch(*this, New, Old);
3736	}
3737
3738	// Don't actually update the type on the new declaration if the old
3739	// declaration was an extern declaration in a different scope.
3740	if (MergeTypeWithOld)
3741	New->setType(MergedT);
3742	}
3743
3744	static bool mergeTypeWithPrevious(Sema &S, VarDecl NewVD, VarDecl OldVD,
3745	LookupResult &Previous) {
3746	// C11 6.2.7p4:
3747	// For an identifier with internal or external linkage declared
3748	// in a scope in which a prior declaration of that identifier is
3749	// visible, if the prior declaration specifies internal or
3750	// external linkage, the type of the identifier at the later
3751	// declaration becomes the composite type.
3752	//
3753	// If the variable isn't visible, we do not merge with its type.
3754	if (Previous.isShadowed())
3755	return false;
3756
3757	if (S.getLangOpts().CPlusPlus) {
3758	// C++11 [dcl.array]p3:
3759	// If there is a preceding declaration of the entity in the same
3760	// scope in which the bound was specified, an omitted array bound
3761	// is taken to be the same as in that earlier declaration.
3762	return NewVD->isPreviousDeclInSameBlockScope() \|\|
3763	(!OldVD->getLexicalDeclContext()->isFunctionOrMethod() &&
3764	!NewVD->getLexicalDeclContext()->isFunctionOrMethod());
3765	} else {
3766	// If the old declaration was function-local, don't merge with its
3767	// type unless we're in the same function.
3768	return !OldVD->getLexicalDeclContext()->isFunctionOrMethod() \|\|
3769	OldVD->getLexicalDeclContext() == NewVD->getLexicalDeclContext();
3770	}
3771	}
3772
3773	/// MergeVarDecl - We just parsed a variable 'New' which has the same name
3774	/// and scope as a previous declaration 'Old'. Figure out how to resolve this
3775	/// situation, merging decls or emitting diagnostics as appropriate.
3776	///
3777	/// Tentative definition rules (C99 6.9.2p2) are checked by
3778	/// FinalizeDeclaratorGroup. Unfortunately, we can't analyze tentative
3779	/// definitions here, since the initializer hasn't been attached.
3780	///
3781	void Sema::MergeVarDecl(VarDecl *New, LookupResult &Previous) {
3782	// If the new decl is already invalid, don't do any other checking.
3783	if (New->isInvalidDecl())
3784	return;
3785
3786	if (!shouldLinkPossiblyHiddenDecl(Previous, New))
3787	return;
3788
3789	VarTemplateDecl *NewTemplate = New->getDescribedVarTemplate();
3790
3791	// Verify the old decl was also a variable or variable template.
3792	VarDecl *Old = nullptr;
3793	VarTemplateDecl *OldTemplate = nullptr;
3794	if (Previous.isSingleResult()) {
3795	if (NewTemplate) {
3796	OldTemplate = dyn_cast<VarTemplateDecl>(Previous.getFoundDecl());
3797	Old = OldTemplate ? OldTemplate->getTemplatedDecl() : nullptr;
3798
3799	if (auto *Shadow =
3800	dyn_cast<UsingShadowDecl>(Previous.getRepresentativeDecl()))
3801	if (checkUsingShadowRedecl<VarTemplateDecl>(*this, Shadow, NewTemplate))
3802	return New->setInvalidDecl();
3803	} else {
3804	Old = dyn_cast<VarDecl>(Previous.getFoundDecl());
3805
3806	if (auto *Shadow =
3807	dyn_cast<UsingShadowDecl>(Previous.getRepresentativeDecl()))
3808	if (checkUsingShadowRedecl<VarDecl>(*this, Shadow, New))
3809	return New->setInvalidDecl();
3810	}
3811	}
3812	if (!Old) {
3813	Diag(New->getLocation(), diag::err_redefinition_different_kind)
3814	<< New->getDeclName();
3815	notePreviousDefinition(Previous.getRepresentativeDecl(),
3816	New->getLocation());
3817	return New->setInvalidDecl();
3818	}
3819
3820	// Ensure the template parameters are compatible.
3821	if (NewTemplate &&
3822	!TemplateParameterListsAreEqual(NewTemplate->getTemplateParameters(),
3823	OldTemplate->getTemplateParameters(),
3824	/Complain=/true, TPL_TemplateMatch))
3825	return New->setInvalidDecl();
3826
3827	// C++ [class.mem]p1:
3828	// A member shall not be declared twice in the member-specification [...]
3829	//
3830	// Here, we need only consider static data members.
3831	if (Old->isStaticDataMember() && !New->isOutOfLine()) {
3832	Diag(New->getLocation(), diag::err_duplicate_member)
3833	<< New->getIdentifier();
3834	Diag(Old->getLocation(), diag::note_previous_declaration);
3835	New->setInvalidDecl();
3836	}
3837
3838	mergeDeclAttributes(New, Old);
3839	// Warn if an already-declared variable is made a weak_import in a subsequent
3840	// declaration
3841	if (New->hasAttr<WeakImportAttr>() &&
3842	Old->getStorageClass() == SC_None &&
3843	!Old->hasAttr<WeakImportAttr>()) {
3844	Diag(New->getLocation(), diag::warn_weak_import) << New->getDeclName();
3845	notePreviousDefinition(Old, New->getLocation());
3846	// Remove weak_import attribute on new declaration.
3847	New->dropAttr<WeakImportAttr>();
3848	}
3849
3850	if (New->hasAttr<InternalLinkageAttr>() &&
3851	!Old->hasAttr<InternalLinkageAttr>()) {
3852	Diag(New->getLocation(), diag::err_internal_linkage_redeclaration)
3853	<< New->getDeclName();
3854	notePreviousDefinition(Old, New->getLocation());
3855	New->dropAttr<InternalLinkageAttr>();
3856	}
3857
3858	// Merge the types.
3859	VarDecl *MostRecent = Old->getMostRecentDecl();
3860	if (MostRecent != Old) {
3861	MergeVarDeclTypes(New, MostRecent,
3862	mergeTypeWithPrevious(*this, New, MostRecent, Previous));
3863	if (New->isInvalidDecl())
3864	return;
3865	}
3866
3867	MergeVarDeclTypes(New, Old, mergeTypeWithPrevious(*this, New, Old, Previous));
3868	if (New->isInvalidDecl())
3869	return;
3870
3871	diag::kind PrevDiag;
3872	SourceLocation OldLocation;
3873	std::tie(PrevDiag, OldLocation) =
3874	getNoteDiagForInvalidRedeclaration(Old, New);
3875
3876	// [dcl.stc]p8: Check if we have a non-static decl followed by a static.
3877	if (New->getStorageClass() == SC_Static &&
3878	!New->isStaticDataMember() &&
3879	Old->hasExternalFormalLinkage()) {
3880	if (getLangOpts().MicrosoftExt) {
3881	Diag(New->getLocation(), diag::ext_static_non_static)
3882	<< New->getDeclName();
3883	Diag(OldLocation, PrevDiag);
3884	} else {
3885	Diag(New->getLocation(), diag::err_static_non_static)
3886	<< New->getDeclName();
3887	Diag(OldLocation, PrevDiag);
3888	return New->setInvalidDecl();
3889	}
3890	}
3891	// C99 6.2.2p4:
3892	// For an identifier declared with the storage-class specifier
3893	// extern in a scope in which a prior declaration of that
3894	// identifier is visible,23) if the prior declaration specifies
3895	// internal or external linkage, the linkage of the identifier at
3896	// the later declaration is the same as the linkage specified at
3897	// the prior declaration. If no prior declaration is visible, or
3898	// if the prior declaration specifies no linkage, then the
3899	// identifier has external linkage.
3900	if (New->hasExternalStorage() && Old->hasLinkage())
3901	/* Okay */;
3902	else if (New->getCanonicalDecl()->getStorageClass() != SC_Static &&
3903	!New->isStaticDataMember() &&
3904	Old->getCanonicalDecl()->getStorageClass() == SC_Static) {
3905	Diag(New->getLocation(), diag::err_non_static_static) << New->getDeclName();
3906	Diag(OldLocation, PrevDiag);
3907	return New->setInvalidDecl();
3908	}
3909
3910	// Check if extern is followed by non-extern and vice-versa.
3911	if (New->hasExternalStorage() &&
3912	!Old->hasLinkage() && Old->isLocalVarDeclOrParm()) {
3913	Diag(New->getLocation(), diag::err_extern_non_extern) << New->getDeclName();
3914	Diag(OldLocation, PrevDiag);
3915	return New->setInvalidDecl();
3916	}
3917	if (Old->hasLinkage() && New->isLocalVarDeclOrParm() &&
3918	!New->hasExternalStorage()) {
3919	Diag(New->getLocation(), diag::err_non_extern_extern) << New->getDeclName();
3920	Diag(OldLocation, PrevDiag);
3921	return New->setInvalidDecl();
3922	}
3923
3924	if (CheckRedeclarationModuleOwnership(New, Old))
3925	return;
3926
3927	// Variables with external linkage are analyzed in FinalizeDeclaratorGroup.
3928
3929	// FIXME: The test for external storage here seems wrong? We still
3930	// need to check for mismatches.
3931	if (!New->hasExternalStorage() && !New->isFileVarDecl() &&
3932	// Don't complain about out-of-line definitions of static members.
3933	!(Old->getLexicalDeclContext()->isRecord() &&
3934	!New->getLexicalDeclContext()->isRecord())) {
3935	Diag(New->getLocation(), diag::err_redefinition) << New->getDeclName();
3936	Diag(OldLocation, PrevDiag);
3937	return New->setInvalidDecl();
3938	}
3939
3940	if (New->isInline() && !Old->getMostRecentDecl()->isInline()) {
3941	if (VarDecl *Def = Old->getDefinition()) {
3942	// C++1z [dcl.fcn.spec]p4:
3943	// If the definition of a variable appears in a translation unit before
3944	// its first declaration as inline, the program is ill-formed.
3945	Diag(New->getLocation(), diag::err_inline_decl_follows_def) << New;
3946	Diag(Def->getLocation(), diag::note_previous_definition);
3947	}
3948	}
3949
3950	// If this redeclaration makes the variable inline, we may need to add it to
3951	// UndefinedButUsed.
3952	if (!Old->isInline() && New->isInline() && Old->isUsed(false) &&
3953	!Old->getDefinition() && !New->isThisDeclarationADefinition())
3954	UndefinedButUsed.insert(std::make_pair(Old->getCanonicalDecl(),
3955	SourceLocation()));
3956
3957	if (New->getTLSKind() != Old->getTLSKind()) {
3958	if (!Old->getTLSKind()) {
3959	Diag(New->getLocation(), diag::err_thread_non_thread) << New->getDeclName();
3960	Diag(OldLocation, PrevDiag);
3961	} else if (!New->getTLSKind()) {
3962	Diag(New->getLocation(), diag::err_non_thread_thread) << New->getDeclName();
3963	Diag(OldLocation, PrevDiag);
3964	} else {
3965	// Do not allow redeclaration to change the variable between requiring
3966	// static and dynamic initialization.
3967	// FIXME: GCC allows this, but uses the TLS keyword on the first
3968	// declaration to determine the kind. Do we need to be compatible here?
3969	Diag(New->getLocation(), diag::err_thread_thread_different_kind)
3970	<< New->getDeclName() << (New->getTLSKind() == VarDecl::TLS_Dynamic);
3971	Diag(OldLocation, PrevDiag);
3972	}
3973	}
3974
3975	// C++ doesn't have tentative definitions, so go right ahead and check here.
3976	if (getLangOpts().CPlusPlus &&
3977	New->isThisDeclarationADefinition() == VarDecl::Definition) {
3978	if (Old->isStaticDataMember() && Old->getCanonicalDecl()->isInline() &&
3979	Old->getCanonicalDecl()->isConstexpr()) {
3980	// This definition won't be a definition any more once it's been merged.
3981	Diag(New->getLocation(),
3982	diag::warn_deprecated_redundant_constexpr_static_def);
3983	} else if (VarDecl *Def = Old->getDefinition()) {
3984	if (checkVarDeclRedefinition(Def, New))
3985	return;
3986	}
3987	}
3988
3989	if (haveIncompatibleLanguageLinkages(Old, New)) {
3990	Diag(New->getLocation(), diag::err_different_language_linkage) << New;
3991	Diag(OldLocation, PrevDiag);
3992	New->setInvalidDecl();
3993	return;
3994	}
3995
3996	// Merge "used" flag.
3997	if (Old->getMostRecentDecl()->isUsed(false))
3998	New->setIsUsed();
3999
4000	// Keep a chain of previous declarations.
4001	New->setPreviousDecl(Old);
4002	if (NewTemplate)
4003	NewTemplate->setPreviousDecl(OldTemplate);
4004	adjustDeclContextForDeclaratorDecl(New, Old);
4005
4006	// Inherit access appropriately.
4007	New->setAccess(Old->getAccess());
4008	if (NewTemplate)
4009	NewTemplate->setAccess(New->getAccess());
4010
4011	if (Old->isInline())
4012	New->setImplicitlyInline();
4013	}
4014
4015	void Sema::notePreviousDefinition(const NamedDecl *Old, SourceLocation New) {
4016	SourceManager &SrcMgr = getSourceManager();
4017	auto FNewDecLoc = SrcMgr.getDecomposedLoc(New);
4018	auto FOldDecLoc = SrcMgr.getDecomposedLoc(Old->getLocation());
4019	auto *FNew = SrcMgr.getFileEntryForID(FNewDecLoc.first);
4020	auto *FOld = SrcMgr.getFileEntryForID(FOldDecLoc.first);
4021	auto &HSI = PP.getHeaderSearchInfo();
4022	StringRef HdrFilename =
4023	SrcMgr.getFilename(SrcMgr.getSpellingLoc(Old->getLocation()));
4024
4025	auto noteFromModuleOrInclude = [&](Module *Mod,
4026	SourceLocation IncLoc) -> bool {
4027	// Redefinition errors with modules are common with non modular mapped
4028	// headers, example: a non-modular header H in module A that also gets
4029	// included directly in a TU. Pointing twice to the same header/definition
4030	// is confusing, try to get better diagnostics when modules is on.
4031	if (IncLoc.isValid()) {
4032	if (Mod) {
4033	Diag(IncLoc, diag::note_redefinition_modules_same_file)
4034	<< HdrFilename.str() << Mod->getFullModuleName();
4035	if (!Mod->DefinitionLoc.isInvalid())
4036	Diag(Mod->DefinitionLoc, diag::note_defined_here)
4037	<< Mod->getFullModuleName();
4038	} else {
4039	Diag(IncLoc, diag::note_redefinition_include_same_file)
4040	<< HdrFilename.str();
4041	}
4042	return true;
4043	}
4044
4045	return false;
4046	};
4047
4048	// Is it the same file and same offset? Provide more information on why
4049	// this leads to a redefinition error.
4050	bool EmittedDiag = false;
4051	if (FNew == FOld && FNewDecLoc.second == FOldDecLoc.second) {
4052	SourceLocation OldIncLoc = SrcMgr.getIncludeLoc(FOldDecLoc.first);
4053	SourceLocation NewIncLoc = SrcMgr.getIncludeLoc(FNewDecLoc.first);
4054	EmittedDiag = noteFromModuleOrInclude(Old->getOwningModule(), OldIncLoc);
4055	EmittedDiag \|= noteFromModuleOrInclude(getCurrentModule(), NewIncLoc);
4056
4057	// If the header has no guards, emit a note suggesting one.
4058	if (FOld && !HSI.isFileMultipleIncludeGuarded(FOld))
4059	Diag(Old->getLocation(), diag::note_use_ifdef_guards);
4060
4061	if (EmittedDiag)
4062	return;
4063	}
4064
4065	// Redefinition coming from different files or couldn't do better above.
4066	if (Old->getLocation().isValid())
4067	Diag(Old->getLocation(), diag::note_previous_definition);
4068	}
4069
4070	/// We've just determined that \p Old and \p New both appear to be definitions
4071	/// of the same variable. Either diagnose or fix the problem.
4072	bool Sema::checkVarDeclRedefinition(VarDecl Old, VarDecl New) {
4073	if (!hasVisibleDefinition(Old) &&
4074	(New->getFormalLinkage() == InternalLinkage \|\|
4075	New->isInline() \|\|
4076	New->getDescribedVarTemplate() \|\|
4077	New->getNumTemplateParameterLists() \|\|
4078	New->getDeclContext()->isDependentContext())) {
4079	// The previous definition is hidden, and multiple definitions are
4080	// permitted (in separate TUs). Demote this to a declaration.
4081	New->demoteThisDefinitionToDeclaration();
4082
4083	// Make the canonical definition visible.
4084	if (auto *OldTD = Old->getDescribedVarTemplate())
4085	makeMergedDefinitionVisible(OldTD);
4086	makeMergedDefinitionVisible(Old);
4087	return false;
4088	} else {
4089	Diag(New->getLocation(), diag::err_redefinition) << New;
4090	notePreviousDefinition(Old, New->getLocation());
4091	New->setInvalidDecl();
4092	return true;
4093	}
4094	}
4095
4096	/// ParsedFreeStandingDeclSpec - This method is invoked when a declspec with
4097	/// no declarator (e.g. "struct foo;") is parsed.
4098	Decl *
4099	Sema::ParsedFreeStandingDeclSpec(Scope *S, AccessSpecifier AS, DeclSpec &DS,
4100	RecordDecl *&AnonRecord) {
4101	return ParsedFreeStandingDeclSpec(S, AS, DS, MultiTemplateParamsArg(), false,
4102	AnonRecord);
4103	}
4104
4105	// The MS ABI changed between VS2013 and VS2015 with regard to numbers used to
4106	// disambiguate entities defined in different scopes.
4107	// While the VS2015 ABI fixes potential miscompiles, it is also breaks
4108	// compatibility.
4109	// We will pick our mangling number depending on which version of MSVC is being
4110	// targeted.
4111	static unsigned getMSManglingNumber(const LangOptions &LO, Scope *S) {
4112	return LO.isCompatibleWithMSVC(LangOptions::MSVC2015)
4113	? S->getMSCurManglingNumber()
4114	: S->getMSLastManglingNumber();
4115	}
4116
4117	void Sema::handleTagNumbering(const TagDecl Tag, Scope TagScope) {
4118	if (!Context.getLangOpts().CPlusPlus)
4119	return;
4120
4121	if (isa<CXXRecordDecl>(Tag->getParent())) {
4122	// If this tag is the direct child of a class, number it if
4123	// it is anonymous.
4124	if (!Tag->getName().empty() \|\| Tag->getTypedefNameForAnonDecl())
4125	return;
4126	MangleNumberingContext &MCtx =
4127	Context.getManglingNumberContext(Tag->getParent());
4128	Context.setManglingNumber(
4129	Tag, MCtx.getManglingNumber(
4130	Tag, getMSManglingNumber(getLangOpts(), TagScope)));
4131	return;
4132	}
4133
4134	// If this tag isn't a direct child of a class, number it if it is local.
4135	Decl *ManglingContextDecl;
4136	if (MangleNumberingContext *MCtx = getCurrentMangleNumberContext(
4137	Tag->getDeclContext(), ManglingContextDecl)) {
4138	Context.setManglingNumber(
4139	Tag, MCtx->getManglingNumber(
4140	Tag, getMSManglingNumber(getLangOpts(), TagScope)));
4141	}
4142	}
4143
4144	void Sema::setTagNameForLinkagePurposes(TagDecl *TagFromDeclSpec,
4145	TypedefNameDecl *NewTD) {
4146	if (TagFromDeclSpec->isInvalidDecl())
4147	return;
4148
4149	// Do nothing if the tag already has a name for linkage purposes.
4150	if (TagFromDeclSpec->hasNameForLinkage())
4151	return;
4152
4153	// A well-formed anonymous tag must always be a TUK_Definition.
4154	assert(TagFromDeclSpec->isThisDeclarationADefinition())((TagFromDeclSpec->isThisDeclarationADefinition()) ? static_cast <void> (0) : __assert_fail ("TagFromDeclSpec->isThisDeclarationADefinition()" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 4154, __PRETTY_FUNCTION__));
4155
4156	// The type must match the tag exactly; no qualifiers allowed.
4157	if (!Context.hasSameType(NewTD->getUnderlyingType(),
4158	Context.getTagDeclType(TagFromDeclSpec))) {
4159	if (getLangOpts().CPlusPlus)
4160	Context.addTypedefNameForUnnamedTagDecl(TagFromDeclSpec, NewTD);
4161	return;
4162	}
4163
4164	// If we've already computed linkage for the anonymous tag, then
4165	// adding a typedef name for the anonymous decl can change that
4166	// linkage, which might be a serious problem. Diagnose this as
4167	// unsupported and ignore the typedef name. TODO: we should
4168	// pursue this as a language defect and establish a formal rule
4169	// for how to handle it.
4170	if (TagFromDeclSpec->hasLinkageBeenComputed()) {
4171	Diag(NewTD->getLocation(), diag::err_typedef_changes_linkage);
4172
4173	SourceLocation tagLoc = TagFromDeclSpec->getInnerLocStart();
4174	tagLoc = getLocForEndOfToken(tagLoc);
4175
4176	llvm::SmallString<40> textToInsert;
4177	textToInsert += ' ';
4178	textToInsert += NewTD->getIdentifier()->getName();
4179	Diag(tagLoc, diag::note_typedef_changes_linkage)
4180	<< FixItHint::CreateInsertion(tagLoc, textToInsert);
4181	return;
4182	}
4183
4184	// Otherwise, set this is the anon-decl typedef for the tag.
4185	TagFromDeclSpec->setTypedefNameForAnonDecl(NewTD);
4186	}
4187
4188	static unsigned GetDiagnosticTypeSpecifierID(DeclSpec::TST T) {
4189	switch (T) {
4190	case DeclSpec::TST_class:
4191	return 0;
4192	case DeclSpec::TST_struct:
4193	return 1;
4194	case DeclSpec::TST_interface:
4195	return 2;
4196	case DeclSpec::TST_union:
4197	return 3;
4198	case DeclSpec::TST_enum:
4199	return 4;
4200	default:
4201	llvm_unreachable("unexpected type specifier")::llvm::llvm_unreachable_internal("unexpected type specifier" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 4201);
4202	}
4203	}
4204
4205	/// ParsedFreeStandingDeclSpec - This method is invoked when a declspec with
4206	/// no declarator (e.g. "struct foo;") is parsed. It also accepts template
4207	/// parameters to cope with template friend declarations.
4208	Decl *
4209	Sema::ParsedFreeStandingDeclSpec(Scope *S, AccessSpecifier AS, DeclSpec &DS,
4210	MultiTemplateParamsArg TemplateParams,
4211	bool IsExplicitInstantiation,
4212	RecordDecl *&AnonRecord) {
4213	Decl *TagD = nullptr;
4214	TagDecl *Tag = nullptr;
4215	if (DS.getTypeSpecType() == DeclSpec::TST_class \|\|
4216	DS.getTypeSpecType() == DeclSpec::TST_struct \|\|
4217	DS.getTypeSpecType() == DeclSpec::TST_interface \|\|
4218	DS.getTypeSpecType() == DeclSpec::TST_union \|\|
4219	DS.getTypeSpecType() == DeclSpec::TST_enum) {
4220	TagD = DS.getRepAsDecl();
4221
4222	if (!TagD) // We probably had an error
4223	return nullptr;
4224
4225	// Note that the above type specs guarantee that the
4226	// type rep is a Decl, whereas in many of the others
4227	// it's a Type.
4228	if (isa<TagDecl>(TagD))
4229	Tag = cast<TagDecl>(TagD);
4230	else if (ClassTemplateDecl *CTD = dyn_cast<ClassTemplateDecl>(TagD))
4231	Tag = CTD->getTemplatedDecl();
4232	}
4233
4234	if (Tag) {
4235	handleTagNumbering(Tag, S);
4236	Tag->setFreeStanding();
4237	if (Tag->isInvalidDecl())
4238	return Tag;
4239	}
4240
4241	if (unsigned TypeQuals = DS.getTypeQualifiers()) {
4242	// Enforce C99 6.7.3p2: "Types other than pointer types derived from object
4243	// or incomplete types shall not be restrict-qualified."
4244	if (TypeQuals & DeclSpec::TQ_restrict)
4245	Diag(DS.getRestrictSpecLoc(),
4246	diag::err_typecheck_invalid_restrict_not_pointer_noarg)
4247	<< DS.getSourceRange();
4248	}
4249
4250	if (DS.isInlineSpecified())
4251	Diag(DS.getInlineSpecLoc(), diag::err_inline_non_function)
4252	<< getLangOpts().CPlusPlus17;
4253
4254	if (DS.isConstexprSpecified()) {
4255	// C++0x [dcl.constexpr]p1: constexpr can only be applied to declarations
4256	// and definitions of functions and variables.
4257	if (Tag)
4258	Diag(DS.getConstexprSpecLoc(), diag::err_constexpr_tag)
4259	<< GetDiagnosticTypeSpecifierID(DS.getTypeSpecType());
4260	else
4261	Diag(DS.getConstexprSpecLoc(), diag::err_constexpr_no_declarators);
4262	// Don't emit warnings after this error.
4263	return TagD;
4264	}
4265
4266	DiagnoseFunctionSpecifiers(DS);
4267
4268	if (DS.isFriendSpecified()) {
4269	// If we're dealing with a decl but not a TagDecl, assume that
4270	// whatever routines created it handled the friendship aspect.
4271	if (TagD && !Tag)
4272	return nullptr;
4273	return ActOnFriendTypeDecl(S, DS, TemplateParams);
4274	}
4275
4276	const CXXScopeSpec &SS = DS.getTypeSpecScope();
4277	bool IsExplicitSpecialization =
4278	!TemplateParams.empty() && TemplateParams.back()->size() == 0;
4279	if (Tag && SS.isNotEmpty() && !Tag->isCompleteDefinition() &&
4280	!IsExplicitInstantiation && !IsExplicitSpecialization &&
4281	!isa<ClassTemplatePartialSpecializationDecl>(Tag)) {
4282	// Per C++ [dcl.type.elab]p1, a class declaration cannot have a
4283	// nested-name-specifier unless it is an explicit instantiation
4284	// or an explicit specialization.
4285	//
4286	// FIXME: We allow class template partial specializations here too, per the
4287	// obvious intent of DR1819.
4288	//
4289	// Per C++ [dcl.enum]p1, an opaque-enum-declaration can't either.
4290	Diag(SS.getBeginLoc(), diag::err_standalone_class_nested_name_specifier)
4291	<< GetDiagnosticTypeSpecifierID(DS.getTypeSpecType()) << SS.getRange();
4292	return nullptr;
4293	}
4294
4295	// Track whether this decl-specifier declares anything.
4296	bool DeclaresAnything = true;
4297
4298	// Handle anonymous struct definitions.
4299	if (RecordDecl *Record = dyn_cast_or_null<RecordDecl>(Tag)) {
4300	if (!Record->getDeclName() && Record->isCompleteDefinition() &&
4301	DS.getStorageClassSpec() != DeclSpec::SCS_typedef) {
4302	if (getLangOpts().CPlusPlus \|\|
4303	Record->getDeclContext()->isRecord()) {
4304	// If CurContext is a DeclContext that can contain statements,
4305	// RecursiveASTVisitor won't visit the decls that
4306	// BuildAnonymousStructOrUnion() will put into CurContext.
4307	// Also store them here so that they can be part of the
4308	// DeclStmt that gets created in this case.
4309	// FIXME: Also return the IndirectFieldDecls created by
4310	// BuildAnonymousStructOr union, for the same reason?
4311	if (CurContext->isFunctionOrMethod())
4312	AnonRecord = Record;
4313	return BuildAnonymousStructOrUnion(S, DS, AS, Record,
4314	Context.getPrintingPolicy());
4315	}
4316
4317	DeclaresAnything = false;
4318	}
4319	}
4320
4321	// C11 6.7.2.1p2:
4322	// A struct-declaration that does not declare an anonymous structure or
4323	// anonymous union shall contain a struct-declarator-list.
4324	//
4325	// This rule also existed in C89 and C99; the grammar for struct-declaration
4326	// did not permit a struct-declaration without a struct-declarator-list.
4327	if (!getLangOpts().CPlusPlus && CurContext->isRecord() &&
4328	DS.getStorageClassSpec() == DeclSpec::SCS_unspecified) {
4329	// Check for Microsoft C extension: anonymous struct/union member.
4330	// Handle 2 kinds of anonymous struct/union:
4331	// struct STRUCT;
4332	// union UNION;
4333	// and
4334	// STRUCT_TYPE; <- where STRUCT_TYPE is a typedef struct.
4335	// UNION_TYPE; <- where UNION_TYPE is a typedef union.
4336	if ((Tag && Tag->getDeclName()) \|\|
4337	DS.getTypeSpecType() == DeclSpec::TST_typename) {
4338	RecordDecl *Record = nullptr;
4339	if (Tag)
4340	Record = dyn_cast<RecordDecl>(Tag);
4341	else if (const RecordType *RT =
4342	DS.getRepAsType().get()->getAsStructureType())
4343	Record = RT->getDecl();
4344	else if (const RecordType *UT = DS.getRepAsType().get()->getAsUnionType())
4345	Record = UT->getDecl();
4346
4347	if (Record && getLangOpts().MicrosoftExt) {
4348	Diag(DS.getBeginLoc(), diag::ext_ms_anonymous_record)
4349	<< Record->isUnion() << DS.getSourceRange();
4350	return BuildMicrosoftCAnonymousStruct(S, DS, Record);
4351	}
4352
4353	DeclaresAnything = false;
4354	}
4355	}
4356
4357	// Skip all the checks below if we have a type error.
4358	if (DS.getTypeSpecType() == DeclSpec::TST_error \|\|
4359	(TagD && TagD->isInvalidDecl()))
4360	return TagD;
4361
4362	if (getLangOpts().CPlusPlus &&
4363	DS.getStorageClassSpec() != DeclSpec::SCS_typedef)
4364	if (EnumDecl *Enum = dyn_cast_or_null<EnumDecl>(Tag))
4365	if (Enum->enumerator_begin() == Enum->enumerator_end() &&
4366	!Enum->getIdentifier() && !Enum->isInvalidDecl())
4367	DeclaresAnything = false;
4368
4369	if (!DS.isMissingDeclaratorOk()) {
4370	// Customize diagnostic for a typedef missing a name.
4371	if (DS.getStorageClassSpec() == DeclSpec::SCS_typedef)
4372	Diag(DS.getBeginLoc(), diag::ext_typedef_without_a_name)
4373	<< DS.getSourceRange();
4374	else
4375	DeclaresAnything = false;
4376	}
4377
4378	if (DS.isModulePrivateSpecified() &&
4379	Tag && Tag->getDeclContext()->isFunctionOrMethod())
4380	Diag(DS.getModulePrivateSpecLoc(), diag::err_module_private_local_class)
4381	<< Tag->getTagKind()
4382	<< FixItHint::CreateRemoval(DS.getModulePrivateSpecLoc());
4383
4384	ActOnDocumentableDecl(TagD);
4385
4386	// C 6.7/2:
4387	// A declaration [...] shall declare at least a declarator [...], a tag,
4388	// or the members of an enumeration.
4389	// C++ [dcl.dcl]p3:
4390	// [If there are no declarators], and except for the declaration of an
4391	// unnamed bit-field, the decl-specifier-seq shall introduce one or more
4392	// names into the program, or shall redeclare a name introduced by a
4393	// previous declaration.
4394	if (!DeclaresAnything) {
4395	// In C, we allow this as a (popular) extension / bug. Don't bother
4396	// producing further diagnostics for redundant qualifiers after this.
4397	Diag(DS.getBeginLoc(), diag::ext_no_declarators) << DS.getSourceRange();
4398	return TagD;
4399	}
4400
4401	// C++ [dcl.stc]p1:
4402	// If a storage-class-specifier appears in a decl-specifier-seq, [...] the
4403	// init-declarator-list of the declaration shall not be empty.
4404	// C++ [dcl.fct.spec]p1:
4405	// If a cv-qualifier appears in a decl-specifier-seq, the
4406	// init-declarator-list of the declaration shall not be empty.
4407	//
4408	// Spurious qualifiers here appear to be valid in C.
4409	unsigned DiagID = diag::warn_standalone_specifier;
4410	if (getLangOpts().CPlusPlus)
4411	DiagID = diag::ext_standalone_specifier;
4412
4413	// Note that a linkage-specification sets a storage class, but
4414	// 'extern "C" struct foo;' is actually valid and not theoretically
4415	// useless.
4416	if (DeclSpec::SCS SCS = DS.getStorageClassSpec()) {
4417	if (SCS == DeclSpec::SCS_mutable)
4418	// Since mutable is not a viable storage class specifier in C, there is
4419	// no reason to treat it as an extension. Instead, diagnose as an error.
4420	Diag(DS.getStorageClassSpecLoc(), diag::err_mutable_nonmember);
4421	else if (!DS.isExternInLinkageSpec() && SCS != DeclSpec::SCS_typedef)
4422	Diag(DS.getStorageClassSpecLoc(), DiagID)
4423	<< DeclSpec::getSpecifierName(SCS);
4424	}
4425
4426	if (DeclSpec::TSCS TSCS = DS.getThreadStorageClassSpec())
4427	Diag(DS.getThreadStorageClassSpecLoc(), DiagID)
4428	<< DeclSpec::getSpecifierName(TSCS);
4429	if (DS.getTypeQualifiers()) {
4430	if (DS.getTypeQualifiers() & DeclSpec::TQ_const)
4431	Diag(DS.getConstSpecLoc(), DiagID) << "const";
4432	if (DS.getTypeQualifiers() & DeclSpec::TQ_volatile)
4433	Diag(DS.getConstSpecLoc(), DiagID) << "volatile";
4434	// Restrict is covered above.
4435	if (DS.getTypeQualifiers() & DeclSpec::TQ_atomic)
4436	Diag(DS.getAtomicSpecLoc(), DiagID) << "_Atomic";
4437	if (DS.getTypeQualifiers() & DeclSpec::TQ_unaligned)
4438	Diag(DS.getUnalignedSpecLoc(), DiagID) << "__unaligned";
4439	}
4440
4441	// Warn about ignored type attributes, for example:
4442	// __attribute__((aligned)) struct A;
4443	// Attributes should be placed after tag to apply to type declaration.
4444	if (!DS.getAttributes().empty()) {
4445	DeclSpec::TST TypeSpecType = DS.getTypeSpecType();
4446	if (TypeSpecType == DeclSpec::TST_class \|\|
4447	TypeSpecType == DeclSpec::TST_struct \|\|
4448	TypeSpecType == DeclSpec::TST_interface \|\|
4449	TypeSpecType == DeclSpec::TST_union \|\|
4450	TypeSpecType == DeclSpec::TST_enum) {
4451	for (const ParsedAttr &AL : DS.getAttributes())
4452	Diag(AL.getLoc(), diag::warn_declspec_attribute_ignored)
4453	<< AL.getName() << GetDiagnosticTypeSpecifierID(TypeSpecType);
4454	}
4455	}
4456
4457	return TagD;
4458	}
4459
4460	/// We are trying to inject an anonymous member into the given scope;
4461	/// check if there's an existing declaration that can't be overloaded.
4462	///
4463	/// \return true if this is a forbidden redeclaration
4464	static bool CheckAnonMemberRedeclaration(Sema &SemaRef,
4465	Scope *S,
4466	DeclContext *Owner,
4467	DeclarationName Name,
4468	SourceLocation NameLoc,
4469	bool IsUnion) {
4470	LookupResult R(SemaRef, Name, NameLoc, Sema::LookupMemberName,
4471	Sema::ForVisibleRedeclaration);
4472	if (!SemaRef.LookupName(R, S)) return false;
4473
4474	// Pick a representative declaration.
4475	NamedDecl *PrevDecl = R.getRepresentativeDecl()->getUnderlyingDecl();
4476	assert(PrevDecl && "Expected a non-null Decl")((PrevDecl && "Expected a non-null Decl") ? static_cast <void> (0) : __assert_fail ("PrevDecl && \"Expected a non-null Decl\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 4476, __PRETTY_FUNCTION__));
4477
4478	if (!SemaRef.isDeclInScope(PrevDecl, Owner, S))
4479	return false;
4480
4481	SemaRef.Diag(NameLoc, diag::err_anonymous_record_member_redecl)
4482	<< IsUnion << Name;
4483	SemaRef.Diag(PrevDecl->getLocation(), diag::note_previous_declaration);
4484
4485	return true;
4486	}
4487
4488	/// InjectAnonymousStructOrUnionMembers - Inject the members of the
4489	/// anonymous struct or union AnonRecord into the owning context Owner
4490	/// and scope S. This routine will be invoked just after we realize
4491	/// that an unnamed union or struct is actually an anonymous union or
4492	/// struct, e.g.,
4493	///
4494	/// @code
4495	/// union {
4496	/// int i;
4497	/// float f;
4498	/// }; // InjectAnonymousStructOrUnionMembers called here to inject i and
4499	/// // f into the surrounding scope.x
4500	/// @endcode
4501	///
4502	/// This routine is recursive, injecting the names of nested anonymous
4503	/// structs/unions into the owning context and scope as well.
4504	static bool
4505	InjectAnonymousStructOrUnionMembers(Sema &SemaRef, Scope S, DeclContext Owner,
4506	RecordDecl *AnonRecord, AccessSpecifier AS,
4507	SmallVectorImpl<NamedDecl *> &Chaining) {
4508	bool Invalid = false;
4509
4510	// Look every FieldDecl and IndirectFieldDecl with a name.
4511	for (auto *D : AnonRecord->decls()) {
4512	if ((isa<FieldDecl>(D) \|\| isa<IndirectFieldDecl>(D)) &&
4513	cast<NamedDecl>(D)->getDeclName()) {
4514	ValueDecl *VD = cast<ValueDecl>(D);
4515	if (CheckAnonMemberRedeclaration(SemaRef, S, Owner, VD->getDeclName(),
4516	VD->getLocation(),
4517	AnonRecord->isUnion())) {
4518	// C++ [class.union]p2:
4519	// The names of the members of an anonymous union shall be
4520	// distinct from the names of any other entity in the
4521	// scope in which the anonymous union is declared.
4522	Invalid = true;
4523	} else {
4524	// C++ [class.union]p2:
4525	// For the purpose of name lookup, after the anonymous union
4526	// definition, the members of the anonymous union are
4527	// considered to have been defined in the scope in which the
4528	// anonymous union is declared.
4529	unsigned OldChainingSize = Chaining.size();
4530	if (IndirectFieldDecl *IF = dyn_cast<IndirectFieldDecl>(VD))
4531	Chaining.append(IF->chain_begin(), IF->chain_end());
4532	else
4533	Chaining.push_back(VD);
4534
4535	assert(Chaining.size() >= 2)((Chaining.size() >= 2) ? static_cast<void> (0) : __assert_fail ("Chaining.size() >= 2", "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 4535, __PRETTY_FUNCTION__));
4536	NamedDecl **NamedChain =
4537	new (SemaRef.Context)NamedDecl*[Chaining.size()];
4538	for (unsigned i = 0; i < Chaining.size(); i++)
4539	NamedChain[i] = Chaining[i];
4540
4541	IndirectFieldDecl *IndirectField = IndirectFieldDecl::Create(
4542	SemaRef.Context, Owner, VD->getLocation(), VD->getIdentifier(),
4543	VD->getType(), {NamedChain, Chaining.size()});
4544
4545	for (const auto *Attr : VD->attrs())
4546	IndirectField->addAttr(Attr->clone(SemaRef.Context));
4547
4548	IndirectField->setAccess(AS);
4549	IndirectField->setImplicit();
4550	SemaRef.PushOnScopeChains(IndirectField, S);
4551
4552	// That includes picking up the appropriate access specifier.
4553	if (AS != AS_none) IndirectField->setAccess(AS);
4554
4555	Chaining.resize(OldChainingSize);
4556	}
4557	}
4558	}
4559
4560	return Invalid;
4561	}
4562
4563	/// StorageClassSpecToVarDeclStorageClass - Maps a DeclSpec::SCS to
4564	/// a VarDecl::StorageClass. Any error reporting is up to the caller:
4565	/// illegal input values are mapped to SC_None.
4566	static StorageClass
4567	StorageClassSpecToVarDeclStorageClass(const DeclSpec &DS) {
4568	DeclSpec::SCS StorageClassSpec = DS.getStorageClassSpec();
4569	assert(StorageClassSpec != DeclSpec::SCS_typedef &&((StorageClassSpec != DeclSpec::SCS_typedef && "Parser allowed 'typedef' as storage class VarDecl." ) ? static_cast<void> (0) : __assert_fail ("StorageClassSpec != DeclSpec::SCS_typedef && \"Parser allowed 'typedef' as storage class VarDecl.\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 4570, __PRETTY_FUNCTION__))
4570	"Parser allowed 'typedef' as storage class VarDecl.")((StorageClassSpec != DeclSpec::SCS_typedef && "Parser allowed 'typedef' as storage class VarDecl." ) ? static_cast<void> (0) : __assert_fail ("StorageClassSpec != DeclSpec::SCS_typedef && \"Parser allowed 'typedef' as storage class VarDecl.\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 4570, __PRETTY_FUNCTION__));
4571	switch (StorageClassSpec) {
4572	case DeclSpec::SCS_unspecified: return SC_None;
4573	case DeclSpec::SCS_extern:
4574	if (DS.isExternInLinkageSpec())
4575	return SC_None;
4576	return SC_Extern;
4577	case DeclSpec::SCS_static: return SC_Static;
4578	case DeclSpec::SCS_auto: return SC_Auto;
4579	case DeclSpec::SCS_register: return SC_Register;
4580	case DeclSpec::SCS_private_extern: return SC_PrivateExtern;
4581	// Illegal SCSs map to None: error reporting is up to the caller.
4582	case DeclSpec::SCS_mutable: // Fall through.
4583	case DeclSpec::SCS_typedef: return SC_None;
4584	}
4585	llvm_unreachable("unknown storage class specifier")::llvm::llvm_unreachable_internal("unknown storage class specifier" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 4585);
4586	}
4587
4588	static SourceLocation findDefaultInitializer(const CXXRecordDecl *Record) {
4589	assert(Record->hasInClassInitializer())((Record->hasInClassInitializer()) ? static_cast<void> (0) : __assert_fail ("Record->hasInClassInitializer()", "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 4589, __PRETTY_FUNCTION__));
4590
4591	for (const auto *I : Record->decls()) {
4592	const auto *FD = dyn_cast<FieldDecl>(I);
4593	if (const auto *IFD = dyn_cast<IndirectFieldDecl>(I))
4594	FD = IFD->getAnonField();
4595	if (FD && FD->hasInClassInitializer())
4596	return FD->getLocation();
4597	}
4598
4599	llvm_unreachable("couldn't find in-class initializer")::llvm::llvm_unreachable_internal("couldn't find in-class initializer" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 4599);
4600	}
4601
4602	static void checkDuplicateDefaultInit(Sema &S, CXXRecordDecl *Parent,
4603	SourceLocation DefaultInitLoc) {
4604	if (!Parent->isUnion() \|\| !Parent->hasInClassInitializer())
4605	return;
4606
4607	S.Diag(DefaultInitLoc, diag::err_multiple_mem_union_initialization);
4608	S.Diag(findDefaultInitializer(Parent), diag::note_previous_initializer) << 0;
4609	}
4610
4611	static void checkDuplicateDefaultInit(Sema &S, CXXRecordDecl *Parent,
4612	CXXRecordDecl *AnonUnion) {
4613	if (!Parent->isUnion() \|\| !Parent->hasInClassInitializer())
4614	return;
4615
4616	checkDuplicateDefaultInit(S, Parent, findDefaultInitializer(AnonUnion));
4617	}
4618
4619	/// BuildAnonymousStructOrUnion - Handle the declaration of an
4620	/// anonymous structure or union. Anonymous unions are a C++ feature
4621	/// (C++ [class.union]) and a C11 feature; anonymous structures
4622	/// are a C11 feature and GNU C++ extension.
4623	Decl Sema::BuildAnonymousStructOrUnion(Scope S, DeclSpec &DS,
4624	AccessSpecifier AS,
4625	RecordDecl *Record,
4626	const PrintingPolicy &Policy) {
4627	DeclContext *Owner = Record->getDeclContext();
4628
4629	// Diagnose whether this anonymous struct/union is an extension.
4630	if (Record->isUnion() && !getLangOpts().CPlusPlus && !getLangOpts().C11)
4631	Diag(Record->getLocation(), diag::ext_anonymous_union);
4632	else if (!Record->isUnion() && getLangOpts().CPlusPlus)
4633	Diag(Record->getLocation(), diag::ext_gnu_anonymous_struct);
4634	else if (!Record->isUnion() && !getLangOpts().C11)
4635	Diag(Record->getLocation(), diag::ext_c11_anonymous_struct);
4636
4637	// C and C++ require different kinds of checks for anonymous
4638	// structs/unions.
4639	bool Invalid = false;
4640	if (getLangOpts().CPlusPlus) {
4641	const char *PrevSpec = nullptr;
4642	unsigned DiagID;
4643	if (Record->isUnion()) {
4644	// C++ [class.union]p6:
4645	// C++17 [class.union.anon]p2:
4646	// Anonymous unions declared in a named namespace or in the
4647	// global namespace shall be declared static.
4648	DeclContext *OwnerScope = Owner->getRedeclContext();
4649	if (DS.getStorageClassSpec() != DeclSpec::SCS_static &&
4650	(OwnerScope->isTranslationUnit() \|\|
4651	(OwnerScope->isNamespace() &&
4652	!cast<NamespaceDecl>(OwnerScope)->isAnonymousNamespace()))) {
4653	Diag(Record->getLocation(), diag::err_anonymous_union_not_static)
4654	<< FixItHint::CreateInsertion(Record->getLocation(), "static ");
4655
4656	// Recover by adding 'static'.
4657	DS.SetStorageClassSpec(*this, DeclSpec::SCS_static, SourceLocation(),
4658	PrevSpec, DiagID, Policy);
4659	}
4660	// C++ [class.union]p6:
4661	// A storage class is not allowed in a declaration of an
4662	// anonymous union in a class scope.
4663	else if (DS.getStorageClassSpec() != DeclSpec::SCS_unspecified &&
4664	isa<RecordDecl>(Owner)) {
4665	Diag(DS.getStorageClassSpecLoc(),
4666	diag::err_anonymous_union_with_storage_spec)
4667	<< FixItHint::CreateRemoval(DS.getStorageClassSpecLoc());
4668
4669	// Recover by removing the storage specifier.
4670	DS.SetStorageClassSpec(*this, DeclSpec::SCS_unspecified,
4671	SourceLocation(),
4672	PrevSpec, DiagID, Context.getPrintingPolicy());
4673	}
4674	}
4675
4676	// Ignore const/volatile/restrict qualifiers.
4677	if (DS.getTypeQualifiers()) {
4678	if (DS.getTypeQualifiers() & DeclSpec::TQ_const)
4679	Diag(DS.getConstSpecLoc(), diag::ext_anonymous_struct_union_qualified)
4680	<< Record->isUnion() << "const"
4681	<< FixItHint::CreateRemoval(DS.getConstSpecLoc());
4682	if (DS.getTypeQualifiers() & DeclSpec::TQ_volatile)
4683	Diag(DS.getVolatileSpecLoc(),
4684	diag::ext_anonymous_struct_union_qualified)
4685	<< Record->isUnion() << "volatile"
4686	<< FixItHint::CreateRemoval(DS.getVolatileSpecLoc());
4687	if (DS.getTypeQualifiers() & DeclSpec::TQ_restrict)
4688	Diag(DS.getRestrictSpecLoc(),
4689	diag::ext_anonymous_struct_union_qualified)
4690	<< Record->isUnion() << "restrict"
4691	<< FixItHint::CreateRemoval(DS.getRestrictSpecLoc());
4692	if (DS.getTypeQualifiers() & DeclSpec::TQ_atomic)
4693	Diag(DS.getAtomicSpecLoc(),
4694	diag::ext_anonymous_struct_union_qualified)
4695	<< Record->isUnion() << "_Atomic"
4696	<< FixItHint::CreateRemoval(DS.getAtomicSpecLoc());
4697	if (DS.getTypeQualifiers() & DeclSpec::TQ_unaligned)
4698	Diag(DS.getUnalignedSpecLoc(),
4699	diag::ext_anonymous_struct_union_qualified)
4700	<< Record->isUnion() << "__unaligned"
4701	<< FixItHint::CreateRemoval(DS.getUnalignedSpecLoc());
4702
4703	DS.ClearTypeQualifiers();
4704	}
4705
4706	// C++ [class.union]p2:
4707	// The member-specification of an anonymous union shall only
4708	// define non-static data members. [Note: nested types and
4709	// functions cannot be declared within an anonymous union. ]
4710	for (auto *Mem : Record->decls()) {
4711	if (auto *FD = dyn_cast<FieldDecl>(Mem)) {
4712	// C++ [class.union]p3:
4713	// An anonymous union shall not have private or protected
4714	// members (clause 11).
4715	assert(FD->getAccess() != AS_none)((FD->getAccess() != AS_none) ? static_cast<void> (0 ) : __assert_fail ("FD->getAccess() != AS_none", "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 4715, __PRETTY_FUNCTION__));
4716	if (FD->getAccess() != AS_public) {
4717	Diag(FD->getLocation(), diag::err_anonymous_record_nonpublic_member)
4718	<< Record->isUnion() << (FD->getAccess() == AS_protected);
4719	Invalid = true;
4720	}
4721
4722	// C++ [class.union]p1
4723	// An object of a class with a non-trivial constructor, a non-trivial
4724	// copy constructor, a non-trivial destructor, or a non-trivial copy
4725	// assignment operator cannot be a member of a union, nor can an
4726	// array of such objects.
4727	if (CheckNontrivialField(FD))
4728	Invalid = true;
4729	} else if (Mem->isImplicit()) {
4730	// Any implicit members are fine.
4731	} else if (isa<TagDecl>(Mem) && Mem->getDeclContext() != Record) {
4732	// This is a type that showed up in an
4733	// elaborated-type-specifier inside the anonymous struct or
4734	// union, but which actually declares a type outside of the
4735	// anonymous struct or union. It's okay.
4736	} else if (auto *MemRecord = dyn_cast<RecordDecl>(Mem)) {
4737	if (!MemRecord->isAnonymousStructOrUnion() &&
4738	MemRecord->getDeclName()) {
4739	// Visual C++ allows type definition in anonymous struct or union.
4740	if (getLangOpts().MicrosoftExt)
4741	Diag(MemRecord->getLocation(), diag::ext_anonymous_record_with_type)
4742	<< Record->isUnion();
4743	else {
4744	// This is a nested type declaration.
4745	Diag(MemRecord->getLocation(), diag::err_anonymous_record_with_type)
4746	<< Record->isUnion();
4747	Invalid = true;
4748	}
4749	} else {
4750	// This is an anonymous type definition within another anonymous type.
4751	// This is a popular extension, provided by Plan9, MSVC and GCC, but
4752	// not part of standard C++.
4753	Diag(MemRecord->getLocation(),
4754	diag::ext_anonymous_record_with_anonymous_type)
4755	<< Record->isUnion();
4756	}
4757	} else if (isa<AccessSpecDecl>(Mem)) {
4758	// Any access specifier is fine.
4759	} else if (isa<StaticAssertDecl>(Mem)) {
4760	// In C++1z, static_assert declarations are also fine.
4761	} else {
4762	// We have something that isn't a non-static data
4763	// member. Complain about it.
4764	unsigned DK = diag::err_anonymous_record_bad_member;
4765	if (isa<TypeDecl>(Mem))
4766	DK = diag::err_anonymous_record_with_type;
4767	else if (isa<FunctionDecl>(Mem))
4768	DK = diag::err_anonymous_record_with_function;
4769	else if (isa<VarDecl>(Mem))
4770	DK = diag::err_anonymous_record_with_static;
4771
4772	// Visual C++ allows type definition in anonymous struct or union.
4773	if (getLangOpts().MicrosoftExt &&
4774	DK == diag::err_anonymous_record_with_type)
4775	Diag(Mem->getLocation(), diag::ext_anonymous_record_with_type)
4776	<< Record->isUnion();
4777	else {
4778	Diag(Mem->getLocation(), DK) << Record->isUnion();
4779	Invalid = true;
4780	}
4781	}
4782	}
4783
4784	// C++11 [class.union]p8 (DR1460):
4785	// At most one variant member of a union may have a
4786	// brace-or-equal-initializer.
4787	if (cast<CXXRecordDecl>(Record)->hasInClassInitializer() &&
4788	Owner->isRecord())
4789	checkDuplicateDefaultInit(*this, cast<CXXRecordDecl>(Owner),
4790	cast<CXXRecordDecl>(Record));
4791	}
4792
4793	if (!Record->isUnion() && !Owner->isRecord()) {
4794	Diag(Record->getLocation(), diag::err_anonymous_struct_not_member)
4795	<< getLangOpts().CPlusPlus;
4796	Invalid = true;
4797	}
4798
4799	// Mock up a declarator.
4800	Declarator Dc(DS, DeclaratorContext::MemberContext);
4801	TypeSourceInfo *TInfo = GetTypeForDeclarator(Dc, S);
4802	assert(TInfo && "couldn't build declarator info for anonymous struct/union")((TInfo && "couldn't build declarator info for anonymous struct/union" ) ? static_cast<void> (0) : __assert_fail ("TInfo && \"couldn't build declarator info for anonymous struct/union\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 4802, __PRETTY_FUNCTION__));
4803
4804	// Create a declaration for this anonymous struct/union.
4805	NamedDecl *Anon = nullptr;
4806	if (RecordDecl *OwningClass = dyn_cast<RecordDecl>(Owner)) {
4807	Anon = FieldDecl::Create(
4808	Context, OwningClass, DS.getBeginLoc(), Record->getLocation(),
4809	/IdentifierInfo=/nullptr, Context.getTypeDeclType(Record), TInfo,
4810	/BitWidth=/nullptr, /Mutable=/false,
4811	/InitStyle=/ICIS_NoInit);
4812	Anon->setAccess(AS);
4813	if (getLangOpts().CPlusPlus)
4814	FieldCollector->Add(cast<FieldDecl>(Anon));
4815	} else {
4816	DeclSpec::SCS SCSpec = DS.getStorageClassSpec();
4817	StorageClass SC = StorageClassSpecToVarDeclStorageClass(DS);
4818	if (SCSpec == DeclSpec::SCS_mutable) {
4819	// mutable can only appear on non-static class members, so it's always
4820	// an error here
4821	Diag(Record->getLocation(), diag::err_mutable_nonmember);
4822	Invalid = true;
4823	SC = SC_None;
4824	}
4825
4826	Anon = VarDecl::Create(Context, Owner, DS.getBeginLoc(),
4827	Record->getLocation(), /IdentifierInfo=/nullptr,
4828	Context.getTypeDeclType(Record), TInfo, SC);
4829
4830	// Default-initialize the implicit variable. This initialization will be
4831	// trivial in almost all cases, except if a union member has an in-class
4832	// initializer:
4833	// union { int n = 0; };
4834	ActOnUninitializedDecl(Anon);
4835	}
4836	Anon->setImplicit();
4837
4838	// Mark this as an anonymous struct/union type.
4839	Record->setAnonymousStructOrUnion(true);
4840
4841	// Add the anonymous struct/union object to the current
4842	// context. We'll be referencing this object when we refer to one of
4843	// its members.
4844	Owner->addDecl(Anon);
4845
4846	// Inject the members of the anonymous struct/union into the owning
4847	// context and into the identifier resolver chain for name lookup
4848	// purposes.
4849	SmallVector<NamedDecl*, 2> Chain;
4850	Chain.push_back(Anon);
4851
4852	if (InjectAnonymousStructOrUnionMembers(*this, S, Owner, Record, AS, Chain))
4853	Invalid = true;
4854
4855	if (VarDecl *NewVD = dyn_cast<VarDecl>(Anon)) {
4856	if (getLangOpts().CPlusPlus && NewVD->isStaticLocal()) {
4857	Decl *ManglingContextDecl;
4858	if (MangleNumberingContext *MCtx = getCurrentMangleNumberContext(
4859	NewVD->getDeclContext(), ManglingContextDecl)) {
4860	Context.setManglingNumber(
4861	NewVD, MCtx->getManglingNumber(
4862	NewVD, getMSManglingNumber(getLangOpts(), S)));
4863	Context.setStaticLocalNumber(NewVD, MCtx->getStaticLocalNumber(NewVD));
4864	}
4865	}
4866	}
4867
4868	if (Invalid)
4869	Anon->setInvalidDecl();
4870
4871	return Anon;
4872	}
4873
4874	/// BuildMicrosoftCAnonymousStruct - Handle the declaration of an
4875	/// Microsoft C anonymous structure.
4876	/// Ref: http://msdn.microsoft.com/en-us/library/z2cx9y4f.aspx
4877	/// Example:
4878	///
4879	/// struct A { int a; };
4880	/// struct B { struct A; int b; };
4881	///
4882	/// void foo() {
4883	/// B var;
4884	/// var.a = 3;
4885	/// }
4886	///
4887	Decl Sema::BuildMicrosoftCAnonymousStruct(Scope S, DeclSpec &DS,
4888	RecordDecl *Record) {
4889	assert(Record && "expected a record!")((Record && "expected a record!") ? static_cast<void > (0) : __assert_fail ("Record && \"expected a record!\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 4889, __PRETTY_FUNCTION__));
4890
4891	// Mock up a declarator.
4892	Declarator Dc(DS, DeclaratorContext::TypeNameContext);
4893	TypeSourceInfo *TInfo = GetTypeForDeclarator(Dc, S);
4894	assert(TInfo && "couldn't build declarator info for anonymous struct")((TInfo && "couldn't build declarator info for anonymous struct" ) ? static_cast<void> (0) : __assert_fail ("TInfo && \"couldn't build declarator info for anonymous struct\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 4894, __PRETTY_FUNCTION__));
4895
4896	auto *ParentDecl = cast<RecordDecl>(CurContext);
4897	QualType RecTy = Context.getTypeDeclType(Record);
4898
4899	// Create a declaration for this anonymous struct.
4900	NamedDecl *Anon =
4901	FieldDecl::Create(Context, ParentDecl, DS.getBeginLoc(), DS.getBeginLoc(),
4902	/IdentifierInfo=/nullptr, RecTy, TInfo,
4903	/BitWidth=/nullptr, /Mutable=/false,
4904	/InitStyle=/ICIS_NoInit);
4905	Anon->setImplicit();
4906
4907	// Add the anonymous struct object to the current context.
4908	CurContext->addDecl(Anon);
4909
4910	// Inject the members of the anonymous struct into the current
4911	// context and into the identifier resolver chain for name lookup
4912	// purposes.
4913	SmallVector<NamedDecl*, 2> Chain;
4914	Chain.push_back(Anon);
4915
4916	RecordDecl *RecordDef = Record->getDefinition();
4917	if (RequireCompleteType(Anon->getLocation(), RecTy,
4918	diag::err_field_incomplete) \|\|
4919	InjectAnonymousStructOrUnionMembers(*this, S, CurContext, RecordDef,
4920	AS_none, Chain)) {
4921	Anon->setInvalidDecl();
4922	ParentDecl->setInvalidDecl();
4923	}
4924
4925	return Anon;
4926	}
4927
4928	/// GetNameForDeclarator - Determine the full declaration name for the
4929	/// given Declarator.
4930	DeclarationNameInfo Sema::GetNameForDeclarator(Declarator &D) {
4931	return GetNameFromUnqualifiedId(D.getName());
4932	}
4933
4934	/// Retrieves the declaration name from a parsed unqualified-id.
4935	DeclarationNameInfo
4936	Sema::GetNameFromUnqualifiedId(const UnqualifiedId &Name) {
4937	DeclarationNameInfo NameInfo;
4938	NameInfo.setLoc(Name.StartLocation);
4939
4940	switch (Name.getKind()) {
4941
4942	case UnqualifiedIdKind::IK_ImplicitSelfParam:
4943	case UnqualifiedIdKind::IK_Identifier:
4944	NameInfo.setName(Name.Identifier);
4945	return NameInfo;
4946
4947	case UnqualifiedIdKind::IK_DeductionGuideName: {
4948	// C++ [temp.deduct.guide]p3:
4949	// The simple-template-id shall name a class template specialization.
4950	// The template-name shall be the same identifier as the template-name
4951	// of the simple-template-id.
4952	// These together intend to imply that the template-name shall name a
4953	// class template.
4954	// FIXME: template<typename T> struct X {};
4955	// template<typename T> using Y = X<T>;
4956	// Y(int) -> Y<int>;
4957	// satisfies these rules but does not name a class template.
4958	TemplateName TN = Name.TemplateName.get().get();
4959	auto *Template = TN.getAsTemplateDecl();
4960	if (!Template \|\| !isa<ClassTemplateDecl>(Template)) {
4961	Diag(Name.StartLocation,
4962	diag::err_deduction_guide_name_not_class_template)
4963	<< (int)getTemplateNameKindForDiagnostics(TN) << TN;
4964	if (Template)
4965	Diag(Template->getLocation(), diag::note_template_decl_here);
4966	return DeclarationNameInfo();
4967	}
4968
4969	NameInfo.setName(
4970	Context.DeclarationNames.getCXXDeductionGuideName(Template));
4971	return NameInfo;
4972	}
4973
4974	case UnqualifiedIdKind::IK_OperatorFunctionId:
4975	NameInfo.setName(Context.DeclarationNames.getCXXOperatorName(
4976	Name.OperatorFunctionId.Operator));
4977	NameInfo.getInfo().CXXOperatorName.BeginOpNameLoc
4978	= Name.OperatorFunctionId.SymbolLocations[0];
4979	NameInfo.getInfo().CXXOperatorName.EndOpNameLoc
4980	= Name.EndLocation.getRawEncoding();
4981	return NameInfo;
4982
4983	case UnqualifiedIdKind::IK_LiteralOperatorId:
4984	NameInfo.setName(Context.DeclarationNames.getCXXLiteralOperatorName(
4985	Name.Identifier));
4986	NameInfo.setCXXLiteralOperatorNameLoc(Name.EndLocation);
4987	return NameInfo;
4988
4989	case UnqualifiedIdKind::IK_ConversionFunctionId: {
4990	TypeSourceInfo *TInfo;
4991	QualType Ty = GetTypeFromParser(Name.ConversionFunctionId, &TInfo);
4992	if (Ty.isNull())
4993	return DeclarationNameInfo();
4994	NameInfo.setName(Context.DeclarationNames.getCXXConversionFunctionName(
4995	Context.getCanonicalType(Ty)));
4996	NameInfo.setNamedTypeInfo(TInfo);
4997	return NameInfo;
4998	}
4999
5000	case UnqualifiedIdKind::IK_ConstructorName: {
5001	TypeSourceInfo *TInfo;
5002	QualType Ty = GetTypeFromParser(Name.ConstructorName, &TInfo);
5003	if (Ty.isNull())
5004	return DeclarationNameInfo();
5005	NameInfo.setName(Context.DeclarationNames.getCXXConstructorName(
5006	Context.getCanonicalType(Ty)));
5007	NameInfo.setNamedTypeInfo(TInfo);
5008	return NameInfo;
5009	}
5010
5011	case UnqualifiedIdKind::IK_ConstructorTemplateId: {
5012	// In well-formed code, we can only have a constructor
5013	// template-id that refers to the current context, so go there
5014	// to find the actual type being constructed.
5015	CXXRecordDecl *CurClass = dyn_cast<CXXRecordDecl>(CurContext);
5016	if (!CurClass \|\| CurClass->getIdentifier() != Name.TemplateId->Name)
5017	return DeclarationNameInfo();
5018
5019	// Determine the type of the class being constructed.
5020	QualType CurClassType = Context.getTypeDeclType(CurClass);
5021
5022	// FIXME: Check two things: that the template-id names the same type as
5023	// CurClassType, and that the template-id does not occur when the name
5024	// was qualified.
5025
5026	NameInfo.setName(Context.DeclarationNames.getCXXConstructorName(
5027	Context.getCanonicalType(CurClassType)));
5028	// FIXME: should we retrieve TypeSourceInfo?
5029	NameInfo.setNamedTypeInfo(nullptr);
5030	return NameInfo;
5031	}
5032
5033	case UnqualifiedIdKind::IK_DestructorName: {
5034	TypeSourceInfo *TInfo;
5035	QualType Ty = GetTypeFromParser(Name.DestructorName, &TInfo);
5036	if (Ty.isNull())
5037	return DeclarationNameInfo();
5038	NameInfo.setName(Context.DeclarationNames.getCXXDestructorName(
5039	Context.getCanonicalType(Ty)));
5040	NameInfo.setNamedTypeInfo(TInfo);
5041	return NameInfo;
5042	}
5043
5044	case UnqualifiedIdKind::IK_TemplateId: {
5045	TemplateName TName = Name.TemplateId->Template.get();
5046	SourceLocation TNameLoc = Name.TemplateId->TemplateNameLoc;
5047	return Context.getNameForTemplate(TName, TNameLoc);
5048	}
5049
5050	} // switch (Name.getKind())
5051
5052	llvm_unreachable("Unknown name kind")::llvm::llvm_unreachable_internal("Unknown name kind", "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 5052);
5053	}
5054
5055	static QualType getCoreType(QualType Ty) {
5056	do {
5057	if (Ty->isPointerType() \|\| Ty->isReferenceType())
5058	Ty = Ty->getPointeeType();
5059	else if (Ty->isArrayType())
5060	Ty = Ty->castAsArrayTypeUnsafe()->getElementType();
5061	else
5062	return Ty.withoutLocalFastQualifiers();
5063	} while (true);
5064	}
5065
5066	/// hasSimilarParameters - Determine whether the C++ functions Declaration
5067	/// and Definition have "nearly" matching parameters. This heuristic is
5068	/// used to improve diagnostics in the case where an out-of-line function
5069	/// definition doesn't match any declaration within the class or namespace.
5070	/// Also sets Params to the list of indices to the parameters that differ
5071	/// between the declaration and the definition. If hasSimilarParameters
5072	/// returns true and Params is empty, then all of the parameters match.
5073	static bool hasSimilarParameters(ASTContext &Context,
5074	FunctionDecl *Declaration,
5075	FunctionDecl *Definition,
5076	SmallVectorImpl<unsigned> &Params) {
5077	Params.clear();
5078	if (Declaration->param_size() != Definition->param_size())
5079	return false;
5080	for (unsigned Idx = 0; Idx < Declaration->param_size(); ++Idx) {
5081	QualType DeclParamTy = Declaration->getParamDecl(Idx)->getType();
5082	QualType DefParamTy = Definition->getParamDecl(Idx)->getType();
5083
5084	// The parameter types are identical
5085	if (Context.hasSameType(DefParamTy, DeclParamTy))
5086	continue;
5087
5088	QualType DeclParamBaseTy = getCoreType(DeclParamTy);
5089	QualType DefParamBaseTy = getCoreType(DefParamTy);
5090	const IdentifierInfo *DeclTyName = DeclParamBaseTy.getBaseTypeIdentifier();
5091	const IdentifierInfo *DefTyName = DefParamBaseTy.getBaseTypeIdentifier();
5092
5093	if (Context.hasSameUnqualifiedType(DeclParamBaseTy, DefParamBaseTy) \|\|
5094	(DeclTyName && DeclTyName == DefTyName))
5095	Params.push_back(Idx);
5096	else // The two parameters aren't even close
5097	return false;
5098	}
5099
5100	return true;
5101	}
5102
5103	/// NeedsRebuildingInCurrentInstantiation - Checks whether the given
5104	/// declarator needs to be rebuilt in the current instantiation.
5105	/// Any bits of declarator which appear before the name are valid for
5106	/// consideration here. That's specifically the type in the decl spec
5107	/// and the base type in any member-pointer chunks.
5108	static bool RebuildDeclaratorInCurrentInstantiation(Sema &S, Declarator &D,
5109	DeclarationName Name) {
5110	// The types we specifically need to rebuild are:
5111	// - typenames, typeofs, and decltypes
5112	// - types which will become injected class names
5113	// Of course, we also need to rebuild any type referencing such a
5114	// type. It's safest to just say "dependent", but we call out a
5115	// few cases here.
5116
5117	DeclSpec &DS = D.getMutableDeclSpec();
5118	switch (DS.getTypeSpecType()) {
5119	case DeclSpec::TST_typename:
5120	case DeclSpec::TST_typeofType:
5121	case DeclSpec::TST_underlyingType:
5122	case DeclSpec::TST_atomic: {
5123	// Grab the type from the parser.
5124	TypeSourceInfo *TSI = nullptr;
5125	QualType T = S.GetTypeFromParser(DS.getRepAsType(), &TSI);
5126	if (T.isNull() \|\| !T->isDependentType()) break;
5127
5128	// Make sure there's a type source info. This isn't really much
5129	// of a waste; most dependent types should have type source info
5130	// attached already.
5131	if (!TSI)
5132	TSI = S.Context.getTrivialTypeSourceInfo(T, DS.getTypeSpecTypeLoc());
5133
5134	// Rebuild the type in the current instantiation.
5135	TSI = S.RebuildTypeInCurrentInstantiation(TSI, D.getIdentifierLoc(), Name);
5136	if (!TSI) return true;
5137
5138	// Store the new type back in the decl spec.
5139	ParsedType LocType = S.CreateParsedType(TSI->getType(), TSI);
5140	DS.UpdateTypeRep(LocType);
5141	break;
5142	}
5143
5144	case DeclSpec::TST_decltype:
5145	case DeclSpec::TST_typeofExpr: {
5146	Expr *E = DS.getRepAsExpr();
5147	ExprResult Result = S.RebuildExprInCurrentInstantiation(E);
5148	if (Result.isInvalid()) return true;
5149	DS.UpdateExprRep(Result.get());
5150	break;
5151	}
5152
5153	default:
5154	// Nothing to do for these decl specs.
5155	break;
5156	}
5157
5158	// It doesn't matter what order we do this in.
5159	for (unsigned I = 0, E = D.getNumTypeObjects(); I != E; ++I) {
5160	DeclaratorChunk &Chunk = D.getTypeObject(I);
5161
5162	// The only type information in the declarator which can come
5163	// before the declaration name is the base type of a member
5164	// pointer.
5165	if (Chunk.Kind != DeclaratorChunk::MemberPointer)
5166	continue;
5167
5168	// Rebuild the scope specifier in-place.
5169	CXXScopeSpec &SS = Chunk.Mem.Scope();
5170	if (S.RebuildNestedNameSpecifierInCurrentInstantiation(SS))
5171	return true;
5172	}
5173
5174	return false;
5175	}
5176
5177	Decl Sema::ActOnDeclarator(Scope S, Declarator &D) {
5178	D.setFunctionDefinitionKind(FDK_Declaration);
5179	Decl *Dcl = HandleDeclarator(S, D, MultiTemplateParamsArg());
5180
5181	if (OriginalLexicalContext && OriginalLexicalContext->isObjCContainer() &&
5182	Dcl && Dcl->getDeclContext()->isFileContext())
5183	Dcl->setTopLevelDeclInObjCContainer();
5184
5185	if (getLangOpts().OpenCL)
5186	setCurrentOpenCLExtensionForDecl(Dcl);
5187
5188	return Dcl;
5189	}
5190
5191	/// DiagnoseClassNameShadow - Implement C++ [class.mem]p13:
5192	/// If T is the name of a class, then each of the following shall have a
5193	/// name different from T:
5194	/// - every static data member of class T;
5195	/// - every member function of class T
5196	/// - every member of class T that is itself a type;
5197	/// \returns true if the declaration name violates these rules.
5198	bool Sema::DiagnoseClassNameShadow(DeclContext *DC,
5199	DeclarationNameInfo NameInfo) {
5200	DeclarationName Name = NameInfo.getName();
5201
5202	CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(DC);
5203	while (Record && Record->isAnonymousStructOrUnion())
5204	Record = dyn_cast<CXXRecordDecl>(Record->getParent());
5205	if (Record && Record->getIdentifier() && Record->getDeclName() == Name) {
5206	Diag(NameInfo.getLoc(), diag::err_member_name_of_class) << Name;
5207	return true;
5208	}
5209
5210	return false;
5211	}
5212
5213	/// Diagnose a declaration whose declarator-id has the given
5214	/// nested-name-specifier.
5215	///
5216	/// \param SS The nested-name-specifier of the declarator-id.
5217	///
5218	/// \param DC The declaration context to which the nested-name-specifier
5219	/// resolves.
5220	///
5221	/// \param Name The name of the entity being declared.
5222	///
5223	/// \param Loc The location of the name of the entity being declared.
5224	///
5225	/// \param IsTemplateId Whether the name is a (simple-)template-id, and thus
5226	/// we're declaring an explicit / partial specialization / instantiation.
5227	///
5228	/// \returns true if we cannot safely recover from this error, false otherwise.
5229	bool Sema::diagnoseQualifiedDeclaration(CXXScopeSpec &SS, DeclContext *DC,
5230	DeclarationName Name,
5231	SourceLocation Loc, bool IsTemplateId) {
5232	DeclContext *Cur = CurContext;
5233	while (isa<LinkageSpecDecl>(Cur) \|\| isa<CapturedDecl>(Cur))
5234	Cur = Cur->getParent();
5235
5236	// If the user provided a superfluous scope specifier that refers back to the
5237	// class in which the entity is already declared, diagnose and ignore it.
5238	//
5239	// class X {
5240	// void X::f();
5241	// };
5242	//
5243	// Note, it was once ill-formed to give redundant qualification in all
5244	// contexts, but that rule was removed by DR482.
5245	if (Cur->Equals(DC)) {
5246	if (Cur->isRecord()) {
5247	Diag(Loc, LangOpts.MicrosoftExt ? diag::warn_member_extra_qualification
5248	: diag::err_member_extra_qualification)
5249	<< Name << FixItHint::CreateRemoval(SS.getRange());
5250	SS.clear();
5251	} else {
5252	Diag(Loc, diag::warn_namespace_member_extra_qualification) << Name;
5253	}
5254	return false;
5255	}
5256
5257	// Check whether the qualifying scope encloses the scope of the original
5258	// declaration. For a template-id, we perform the checks in
5259	// CheckTemplateSpecializationScope.
5260	if (!Cur->Encloses(DC) && !IsTemplateId) {
5261	if (Cur->isRecord())
5262	Diag(Loc, diag::err_member_qualification)
5263	<< Name << SS.getRange();
5264	else if (isa<TranslationUnitDecl>(DC))
5265	Diag(Loc, diag::err_invalid_declarator_global_scope)
5266	<< Name << SS.getRange();
5267	else if (isa<FunctionDecl>(Cur))
5268	Diag(Loc, diag::err_invalid_declarator_in_function)
5269	<< Name << SS.getRange();
5270	else if (isa<BlockDecl>(Cur))
5271	Diag(Loc, diag::err_invalid_declarator_in_block)
5272	<< Name << SS.getRange();
5273	else
5274	Diag(Loc, diag::err_invalid_declarator_scope)
5275	<< Name << cast<NamedDecl>(Cur) << cast<NamedDecl>(DC) << SS.getRange();
5276
5277	return true;
5278	}
5279
5280	if (Cur->isRecord()) {
5281	// Cannot qualify members within a class.
5282	Diag(Loc, diag::err_member_qualification)
5283	<< Name << SS.getRange();
5284	SS.clear();
5285
5286	// C++ constructors and destructors with incorrect scopes can break
5287	// our AST invariants by having the wrong underlying types. If
5288	// that's the case, then drop this declaration entirely.
5289	if ((Name.getNameKind() == DeclarationName::CXXConstructorName \|\|
5290	Name.getNameKind() == DeclarationName::CXXDestructorName) &&
5291	!Context.hasSameType(Name.getCXXNameType(),
5292	Context.getTypeDeclType(cast<CXXRecordDecl>(Cur))))
5293	return true;
5294
5295	return false;
5296	}
5297
5298	// C++11 [dcl.meaning]p1:
5299	// [...] "The nested-name-specifier of the qualified declarator-id shall
5300	// not begin with a decltype-specifer"
5301	NestedNameSpecifierLoc SpecLoc(SS.getScopeRep(), SS.location_data());
5302	while (SpecLoc.getPrefix())
5303	SpecLoc = SpecLoc.getPrefix();
5304	if (dyn_cast_or_null<DecltypeType>(
5305	SpecLoc.getNestedNameSpecifier()->getAsType()))
5306	Diag(Loc, diag::err_decltype_in_declarator)
5307	<< SpecLoc.getTypeLoc().getSourceRange();
5308
5309	return false;
5310	}
5311
5312	NamedDecl Sema::HandleDeclarator(Scope S, Declarator &D,
5313	MultiTemplateParamsArg TemplateParamLists) {
5314	// TODO: consider using NameInfo for diagnostic.
5315	DeclarationNameInfo NameInfo = GetNameForDeclarator(D);
5316	DeclarationName Name = NameInfo.getName();
5317
5318	// All of these full declarators require an identifier. If it doesn't have
5319	// one, the ParsedFreeStandingDeclSpec action should be used.
5320	if (D.isDecompositionDeclarator()) {
5321	return ActOnDecompositionDeclarator(S, D, TemplateParamLists);
5322	} else if (!Name) {
5323	if (!D.isInvalidType()) // Reject this if we think it is valid.
5324	Diag(D.getDeclSpec().getBeginLoc(), diag::err_declarator_need_ident)
5325	<< D.getDeclSpec().getSourceRange() << D.getSourceRange();
5326	return nullptr;
5327	} else if (DiagnoseUnexpandedParameterPack(NameInfo, UPPC_DeclarationType))
5328	return nullptr;
5329
5330	// The scope passed in may not be a decl scope. Zip up the scope tree until
5331	// we find one that is.
5332	while ((S->getFlags() & Scope::DeclScope) == 0 \|\|
5333	(S->getFlags() & Scope::TemplateParamScope) != 0)
5334	S = S->getParent();
5335
5336	DeclContext *DC = CurContext;
5337	if (D.getCXXScopeSpec().isInvalid())
5338	D.setInvalidType();
5339	else if (D.getCXXScopeSpec().isSet()) {
5340	if (DiagnoseUnexpandedParameterPack(D.getCXXScopeSpec(),
5341	UPPC_DeclarationQualifier))
5342	return nullptr;
5343
5344	bool EnteringContext = !D.getDeclSpec().isFriendSpecified();
5345	DC = computeDeclContext(D.getCXXScopeSpec(), EnteringContext);
5346	if (!DC \|\| isa<EnumDecl>(DC)) {
5347	// If we could not compute the declaration context, it's because the
5348	// declaration context is dependent but does not refer to a class,
5349	// class template, or class template partial specialization. Complain
5350	// and return early, to avoid the coming semantic disaster.
5351	Diag(D.getIdentifierLoc(),
5352	diag::err_template_qualified_declarator_no_match)
5353	<< D.getCXXScopeSpec().getScopeRep()
5354	<< D.getCXXScopeSpec().getRange();
5355	return nullptr;
5356	}
5357	bool IsDependentContext = DC->isDependentContext();
5358
5359	if (!IsDependentContext &&
5360	RequireCompleteDeclContext(D.getCXXScopeSpec(), DC))
5361	return nullptr;
5362
5363	// If a class is incomplete, do not parse entities inside it.
5364	if (isa<CXXRecordDecl>(DC) && !cast<CXXRecordDecl>(DC)->hasDefinition()) {
5365	Diag(D.getIdentifierLoc(),
5366	diag::err_member_def_undefined_record)
5367	<< Name << DC << D.getCXXScopeSpec().getRange();
5368	return nullptr;
5369	}
5370	if (!D.getDeclSpec().isFriendSpecified()) {
5371	if (diagnoseQualifiedDeclaration(
5372	D.getCXXScopeSpec(), DC, Name, D.getIdentifierLoc(),
5373	D.getName().getKind() == UnqualifiedIdKind::IK_TemplateId)) {
5374	if (DC->isRecord())
5375	return nullptr;
5376
5377	D.setInvalidType();
5378	}
5379	}
5380
5381	// Check whether we need to rebuild the type of the given
5382	// declaration in the current instantiation.
5383	if (EnteringContext && IsDependentContext &&
5384	TemplateParamLists.size() != 0) {
5385	ContextRAII SavedContext(*this, DC);
5386	if (RebuildDeclaratorInCurrentInstantiation(*this, D, Name))
5387	D.setInvalidType();
5388	}
5389	}
5390
5391	TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S);
5392	QualType R = TInfo->getType();
5393
5394	if (DiagnoseUnexpandedParameterPack(D.getIdentifierLoc(), TInfo,
5395	UPPC_DeclarationType))
5396	D.setInvalidType();
5397
5398	LookupResult Previous(*this, NameInfo, LookupOrdinaryName,
5399	forRedeclarationInCurContext());
5400
5401	// See if this is a redefinition of a variable in the same scope.
5402	if (!D.getCXXScopeSpec().isSet()) {
5403	bool IsLinkageLookup = false;
5404	bool CreateBuiltins = false;
5405
5406	// If the declaration we're planning to build will be a function
5407	// or object with linkage, then look for another declaration with
5408	// linkage (C99 6.2.2p4-5 and C++ [basic.link]p6).
5409	//
5410	// If the declaration we're planning to build will be declared with
5411	// external linkage in the translation unit, create any builtin with
5412	// the same name.
5413	if (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_typedef)
5414	/* Do nothing*/;
5415	else if (CurContext->isFunctionOrMethod() &&
5416	(D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_extern \|\|
5417	R->isFunctionType())) {
5418	IsLinkageLookup = true;
5419	CreateBuiltins =
5420	CurContext->getEnclosingNamespaceContext()->isTranslationUnit();
5421	} else if (CurContext->getRedeclContext()->isTranslationUnit() &&
5422	D.getDeclSpec().getStorageClassSpec() != DeclSpec::SCS_static)
5423	CreateBuiltins = true;
5424
5425	if (IsLinkageLookup) {
5426	Previous.clear(LookupRedeclarationWithLinkage);
5427	Previous.setRedeclarationKind(ForExternalRedeclaration);
5428	}
5429
5430	LookupName(Previous, S, CreateBuiltins);
5431	} else { // Something like "int foo::x;"
5432	LookupQualifiedName(Previous, DC);
5433
5434	// C++ [dcl.meaning]p1:
5435	// When the declarator-id is qualified, the declaration shall refer to a
5436	// previously declared member of the class or namespace to which the
5437	// qualifier refers (or, in the case of a namespace, of an element of the
5438	// inline namespace set of that namespace (7.3.1)) or to a specialization
5439	// thereof; [...]
5440	//
5441	// Note that we already checked the context above, and that we do not have
5442	// enough information to make sure that Previous contains the declaration
5443	// we want to match. For example, given:
5444	//
5445	// class X {
5446	// void f();
5447	// void f(float);
5448	// };
5449	//
5450	// void X::f(int) { } // ill-formed
5451	//
5452	// In this case, Previous will point to the overload set
5453	// containing the two f's declared in X, but neither of them
5454	// matches.
5455
5456	// C++ [dcl.meaning]p1:
5457	// [...] the member shall not merely have been introduced by a
5458	// using-declaration in the scope of the class or namespace nominated by
5459	// the nested-name-specifier of the declarator-id.
5460	RemoveUsingDecls(Previous);
5461	}
5462
5463	if (Previous.isSingleResult() &&
5464	Previous.getFoundDecl()->isTemplateParameter()) {
5465	// Maybe we will complain about the shadowed template parameter.
5466	if (!D.isInvalidType())
5467	DiagnoseTemplateParameterShadow(D.getIdentifierLoc(),
5468	Previous.getFoundDecl());
5469
5470	// Just pretend that we didn't see the previous declaration.
5471	Previous.clear();
5472	}
5473
5474	if (!R->isFunctionType() && DiagnoseClassNameShadow(DC, NameInfo))
5475	// Forget that the previous declaration is the injected-class-name.
5476	Previous.clear();
5477
5478	// In C++, the previous declaration we find might be a tag type
5479	// (class or enum). In this case, the new declaration will hide the
5480	// tag type. Note that this applies to functions, function templates, and
5481	// variables, but not to typedefs (C++ [dcl.typedef]p4) or variable templates.
5482	if (Previous.isSingleTagDecl() &&
5483	D.getDeclSpec().getStorageClassSpec() != DeclSpec::SCS_typedef &&
5484	(TemplateParamLists.size() == 0 \|\| R->isFunctionType()))
5485	Previous.clear();
5486
5487	// Check that there are no default arguments other than in the parameters
5488	// of a function declaration (C++ only).
5489	if (getLangOpts().CPlusPlus)
5490	CheckExtraCXXDefaultArguments(D);
5491
5492	NamedDecl *New;
5493
5494	bool AddToScope = true;
5495	if (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_typedef) {
5496	if (TemplateParamLists.size()) {
5497	Diag(D.getIdentifierLoc(), diag::err_template_typedef);
5498	return nullptr;
5499	}
5500
5501	New = ActOnTypedefDeclarator(S, D, DC, TInfo, Previous);
5502	} else if (R->isFunctionType()) {
5503	New = ActOnFunctionDeclarator(S, D, DC, TInfo, Previous,
5504	TemplateParamLists,
5505	AddToScope);
5506	} else {
5507	New = ActOnVariableDeclarator(S, D, DC, TInfo, Previous, TemplateParamLists,
5508	AddToScope);
5509	}
5510
5511	if (!New)
5512	return nullptr;
5513
5514	// If this has an identifier and is not a function template specialization,
5515	// add it to the scope stack.
5516	if (New->getDeclName() && AddToScope) {
5517	// Only make a locally-scoped extern declaration visible if it is the first
5518	// declaration of this entity. Qualified lookup for such an entity should
5519	// only find this declaration if there is no visible declaration of it.
5520	bool AddToContext = !D.isRedeclaration() \|\| !New->isLocalExternDecl();
5521	PushOnScopeChains(New, S, AddToContext);
5522	if (!AddToContext)
5523	CurContext->addHiddenDecl(New);
5524	}
5525
5526	if (isInOpenMPDeclareTargetContext())
5527	checkDeclIsAllowedInOpenMPTarget(nullptr, New);
5528
5529	return New;
5530	}
5531
5532	/// Helper method to turn variable array types into constant array
5533	/// types in certain situations which would otherwise be errors (for
5534	/// GCC compatibility).
5535	static QualType TryToFixInvalidVariablyModifiedType(QualType T,
5536	ASTContext &Context,
5537	bool &SizeIsNegative,
5538	llvm::APSInt &Oversized) {
5539	// This method tries to turn a variable array into a constant
5540	// array even when the size isn't an ICE. This is necessary
5541	// for compatibility with code that depends on gcc's buggy
5542	// constant expression folding, like struct {char x[(int)(char*)2];}
5543	SizeIsNegative = false;
5544	Oversized = 0;
5545
5546	if (T->isDependentType())
5547	return QualType();
5548
5549	QualifierCollector Qs;
5550	const Type *Ty = Qs.strip(T);
5551
5552	if (const PointerType* PTy = dyn_cast<PointerType>(Ty)) {
5553	QualType Pointee = PTy->getPointeeType();
5554	QualType FixedType =
5555	TryToFixInvalidVariablyModifiedType(Pointee, Context, SizeIsNegative,
5556	Oversized);
5557	if (FixedType.isNull()) return FixedType;
5558	FixedType = Context.getPointerType(FixedType);
5559	return Qs.apply(Context, FixedType);
5560	}
5561	if (const ParenType* PTy = dyn_cast<ParenType>(Ty)) {
5562	QualType Inner = PTy->getInnerType();
5563	QualType FixedType =
5564	TryToFixInvalidVariablyModifiedType(Inner, Context, SizeIsNegative,
5565	Oversized);
5566	if (FixedType.isNull()) return FixedType;
5567	FixedType = Context.getParenType(FixedType);
5568	return Qs.apply(Context, FixedType);
5569	}
5570
5571	const VariableArrayType* VLATy = dyn_cast<VariableArrayType>(T);
5572	if (!VLATy)
5573	return QualType();
5574	// FIXME: We should probably handle this case
5575	if (VLATy->getElementType()->isVariablyModifiedType())
5576	return QualType();
5577
5578	Expr::EvalResult Result;
5579	if (!VLATy->getSizeExpr() \|\|
5580	!VLATy->getSizeExpr()->EvaluateAsInt(Result, Context))
5581	return QualType();
5582
5583	llvm::APSInt Res = Result.Val.getInt();
5584
5585	// Check whether the array size is negative.
5586	if (Res.isSigned() && Res.isNegative()) {
5587	SizeIsNegative = true;
5588	return QualType();
5589	}
5590
5591	// Check whether the array is too large to be addressed.
5592	unsigned ActiveSizeBits
5593	= ConstantArrayType::getNumAddressingBits(Context, VLATy->getElementType(),
5594	Res);
5595	if (ActiveSizeBits > ConstantArrayType::getMaxSizeBits(Context)) {
5596	Oversized = Res;
5597	return QualType();
5598	}
5599
5600	return Context.getConstantArrayType(VLATy->getElementType(),
5601	Res, ArrayType::Normal, 0);
5602	}
5603
5604	static void
5605	FixInvalidVariablyModifiedTypeLoc(TypeLoc SrcTL, TypeLoc DstTL) {
5606	SrcTL = SrcTL.getUnqualifiedLoc();
5607	DstTL = DstTL.getUnqualifiedLoc();
5608	if (PointerTypeLoc SrcPTL = SrcTL.getAs<PointerTypeLoc>()) {
5609	PointerTypeLoc DstPTL = DstTL.castAs<PointerTypeLoc>();
5610	FixInvalidVariablyModifiedTypeLoc(SrcPTL.getPointeeLoc(),
5611	DstPTL.getPointeeLoc());
5612	DstPTL.setStarLoc(SrcPTL.getStarLoc());
5613	return;
5614	}
5615	if (ParenTypeLoc SrcPTL = SrcTL.getAs<ParenTypeLoc>()) {
5616	ParenTypeLoc DstPTL = DstTL.castAs<ParenTypeLoc>();
5617	FixInvalidVariablyModifiedTypeLoc(SrcPTL.getInnerLoc(),
5618	DstPTL.getInnerLoc());
5619	DstPTL.setLParenLoc(SrcPTL.getLParenLoc());
5620	DstPTL.setRParenLoc(SrcPTL.getRParenLoc());
5621	return;
5622	}
5623	ArrayTypeLoc SrcATL = SrcTL.castAs<ArrayTypeLoc>();
5624	ArrayTypeLoc DstATL = DstTL.castAs<ArrayTypeLoc>();
5625	TypeLoc SrcElemTL = SrcATL.getElementLoc();
5626	TypeLoc DstElemTL = DstATL.getElementLoc();
5627	DstElemTL.initializeFullCopy(SrcElemTL);
5628	DstATL.setLBracketLoc(SrcATL.getLBracketLoc());
5629	DstATL.setSizeExpr(SrcATL.getSizeExpr());
5630	DstATL.setRBracketLoc(SrcATL.getRBracketLoc());
5631	}
5632
5633	/// Helper method to turn variable array types into constant array
5634	/// types in certain situations which would otherwise be errors (for
5635	/// GCC compatibility).
5636	static TypeSourceInfo*
5637	TryToFixInvalidVariablyModifiedTypeSourceInfo(TypeSourceInfo *TInfo,
5638	ASTContext &Context,
5639	bool &SizeIsNegative,
5640	llvm::APSInt &Oversized) {
5641	QualType FixedTy
5642	= TryToFixInvalidVariablyModifiedType(TInfo->getType(), Context,
5643	SizeIsNegative, Oversized);
5644	if (FixedTy.isNull())
5645	return nullptr;
5646	TypeSourceInfo *FixedTInfo = Context.getTrivialTypeSourceInfo(FixedTy);
5647	FixInvalidVariablyModifiedTypeLoc(TInfo->getTypeLoc(),
5648	FixedTInfo->getTypeLoc());
5649	return FixedTInfo;
5650	}
5651
5652	/// Register the given locally-scoped extern "C" declaration so
5653	/// that it can be found later for redeclarations. We include any extern "C"
5654	/// declaration that is not visible in the translation unit here, not just
5655	/// function-scope declarations.
5656	void
5657	Sema::RegisterLocallyScopedExternCDecl(NamedDecl ND, Scope S) {
5658	if (!getLangOpts().CPlusPlus &&
5659	ND->getLexicalDeclContext()->getRedeclContext()->isTranslationUnit())
5660	// Don't need to track declarations in the TU in C.
5661	return;
5662
5663	// Note that we have a locally-scoped external with this name.
5664	Context.getExternCContextDecl()->makeDeclVisibleInContext(ND);
5665	}
5666
5667	NamedDecl *Sema::findLocallyScopedExternCDecl(DeclarationName Name) {
5668	// FIXME: We can have multiple results via __attribute__((overloadable)).
5669	auto Result = Context.getExternCContextDecl()->lookup(Name);
5670	return Result.empty() ? nullptr : *Result.begin();
5671	}
5672
5673	/// Diagnose function specifiers on a declaration of an identifier that
5674	/// does not identify a function.
5675	void Sema::DiagnoseFunctionSpecifiers(const DeclSpec &DS) {
5676	// FIXME: We should probably indicate the identifier in question to avoid
5677	// confusion for constructs like "virtual int a(), b;"
5678	if (DS.isVirtualSpecified())
5679	Diag(DS.getVirtualSpecLoc(),
5680	diag::err_virtual_non_function);
5681
5682	if (DS.isExplicitSpecified())
5683	Diag(DS.getExplicitSpecLoc(),
5684	diag::err_explicit_non_function);
5685
5686	if (DS.isNoreturnSpecified())
5687	Diag(DS.getNoreturnSpecLoc(),
5688	diag::err_noreturn_non_function);
5689	}
5690
5691	NamedDecl*
5692	Sema::ActOnTypedefDeclarator(Scope* S, Declarator& D, DeclContext* DC,
5693	TypeSourceInfo *TInfo, LookupResult &Previous) {
5694	// Typedef declarators cannot be qualified (C++ [dcl.meaning]p1).
5695	if (D.getCXXScopeSpec().isSet()) {
5696	Diag(D.getIdentifierLoc(), diag::err_qualified_typedef_declarator)
5697	<< D.getCXXScopeSpec().getRange();
5698	D.setInvalidType();
5699	// Pretend we didn't see the scope specifier.
5700	DC = CurContext;
5701	Previous.clear();
5702	}
5703
5704	DiagnoseFunctionSpecifiers(D.getDeclSpec());
5705
5706	if (D.getDeclSpec().isInlineSpecified())
5707	Diag(D.getDeclSpec().getInlineSpecLoc(), diag::err_inline_non_function)
5708	<< getLangOpts().CPlusPlus17;
5709	if (D.getDeclSpec().isConstexprSpecified())
5710	Diag(D.getDeclSpec().getConstexprSpecLoc(), diag::err_invalid_constexpr)
5711	<< 1;
5712
5713	if (D.getName().Kind != UnqualifiedIdKind::IK_Identifier) {
5714	if (D.getName().Kind == UnqualifiedIdKind::IK_DeductionGuideName)
5715	Diag(D.getName().StartLocation,
5716	diag::err_deduction_guide_invalid_specifier)
5717	<< "typedef";
5718	else
5719	Diag(D.getName().StartLocation, diag::err_typedef_not_identifier)
5720	<< D.getName().getSourceRange();
5721	return nullptr;
5722	}
5723
5724	TypedefDecl *NewTD = ParseTypedefDecl(S, D, TInfo->getType(), TInfo);
5725	if (!NewTD) return nullptr;
5726
5727	// Handle attributes prior to checking for duplicates in MergeVarDecl
5728	ProcessDeclAttributes(S, NewTD, D);
5729
5730	CheckTypedefForVariablyModifiedType(S, NewTD);
5731
5732	bool Redeclaration = D.isRedeclaration();
5733	NamedDecl *ND = ActOnTypedefNameDecl(S, DC, NewTD, Previous, Redeclaration);
5734	D.setRedeclaration(Redeclaration);
5735	return ND;
5736	}
5737
5738	void
5739	Sema::CheckTypedefForVariablyModifiedType(Scope S, TypedefNameDecl NewTD) {
5740	// C99 6.7.7p2: If a typedef name specifies a variably modified type
5741	// then it shall have block scope.
5742	// Note that variably modified types must be fixed before merging the decl so
5743	// that redeclarations will match.
5744	TypeSourceInfo *TInfo = NewTD->getTypeSourceInfo();
5745	QualType T = TInfo->getType();
5746	if (T->isVariablyModifiedType()) {
5747	setFunctionHasBranchProtectedScope();
5748
5749	if (S->getFnParent() == nullptr) {
5750	bool SizeIsNegative;
5751	llvm::APSInt Oversized;
5752	TypeSourceInfo *FixedTInfo =
5753	TryToFixInvalidVariablyModifiedTypeSourceInfo(TInfo, Context,
5754	SizeIsNegative,
5755	Oversized);
5756	if (FixedTInfo) {
5757	Diag(NewTD->getLocation(), diag::warn_illegal_constant_array_size);
5758	NewTD->setTypeSourceInfo(FixedTInfo);
5759	} else {
5760	if (SizeIsNegative)
5761	Diag(NewTD->getLocation(), diag::err_typecheck_negative_array_size);
5762	else if (T->isVariableArrayType())
5763	Diag(NewTD->getLocation(), diag::err_vla_decl_in_file_scope);
5764	else if (Oversized.getBoolValue())
5765	Diag(NewTD->getLocation(), diag::err_array_too_large)
5766	<< Oversized.toString(10);
5767	else
5768	Diag(NewTD->getLocation(), diag::err_vm_decl_in_file_scope);
5769	NewTD->setInvalidDecl();
5770	}
5771	}
5772	}
5773	}
5774
5775	/// ActOnTypedefNameDecl - Perform semantic checking for a declaration which
5776	/// declares a typedef-name, either using the 'typedef' type specifier or via
5777	/// a C++0x [dcl.typedef]p2 alias-declaration: 'using T = A;'.
5778	NamedDecl*
5779	Sema::ActOnTypedefNameDecl(Scope S, DeclContext DC, TypedefNameDecl *NewTD,
5780	LookupResult &Previous, bool &Redeclaration) {
5781
5782	// Find the shadowed declaration before filtering for scope.
5783	NamedDecl *ShadowedDecl = getShadowedDeclaration(NewTD, Previous);
5784
5785	// Merge the decl with the existing one if appropriate. If the decl is
5786	// in an outer scope, it isn't the same thing.
5787	FilterLookupForScope(Previous, DC, S, /ConsiderLinkage/false,
5788	/AllowInlineNamespace/false);
5789	filterNonConflictingPreviousTypedefDecls(*this, NewTD, Previous);
5790	if (!Previous.empty()) {
5791	Redeclaration = true;
5792	MergeTypedefNameDecl(S, NewTD, Previous);
5793	}
5794
5795	if (ShadowedDecl && !Redeclaration)
5796	CheckShadow(NewTD, ShadowedDecl, Previous);
5797
5798	// If this is the C FILE type, notify the AST context.
5799	if (IdentifierInfo *II = NewTD->getIdentifier())
5800	if (!NewTD->isInvalidDecl() &&
5801	NewTD->getDeclContext()->getRedeclContext()->isTranslationUnit()) {
5802	if (II->isStr("FILE"))
5803	Context.setFILEDecl(NewTD);
5804	else if (II->isStr("jmp_buf"))
5805	Context.setjmp_bufDecl(NewTD);
5806	else if (II->isStr("sigjmp_buf"))
5807	Context.setsigjmp_bufDecl(NewTD);
5808	else if (II->isStr("ucontext_t"))
5809	Context.setucontext_tDecl(NewTD);
5810	}
5811
5812	return NewTD;
5813	}
5814
5815	/// Determines whether the given declaration is an out-of-scope
5816	/// previous declaration.
5817	///
5818	/// This routine should be invoked when name lookup has found a
5819	/// previous declaration (PrevDecl) that is not in the scope where a
5820	/// new declaration by the same name is being introduced. If the new
5821	/// declaration occurs in a local scope, previous declarations with
5822	/// linkage may still be considered previous declarations (C99
5823	/// 6.2.2p4-5, C++ [basic.link]p6).
5824	///
5825	/// \param PrevDecl the previous declaration found by name
5826	/// lookup
5827	///
5828	/// \param DC the context in which the new declaration is being
5829	/// declared.
5830	///
5831	/// \returns true if PrevDecl is an out-of-scope previous declaration
5832	/// for a new delcaration with the same name.
5833	static bool
5834	isOutOfScopePreviousDeclaration(NamedDecl PrevDecl, DeclContext DC,
5835	ASTContext &Context) {
5836	if (!PrevDecl)
5837	return false;
5838
5839	if (!PrevDecl->hasLinkage())
5840	return false;
5841
5842	if (Context.getLangOpts().CPlusPlus) {
5843	// C++ [basic.link]p6:
5844	// If there is a visible declaration of an entity with linkage
5845	// having the same name and type, ignoring entities declared
5846	// outside the innermost enclosing namespace scope, the block
5847	// scope declaration declares that same entity and receives the
5848	// linkage of the previous declaration.
5849	DeclContext *OuterContext = DC->getRedeclContext();
5850	if (!OuterContext->isFunctionOrMethod())
5851	// This rule only applies to block-scope declarations.
5852	return false;
5853
5854	DeclContext *PrevOuterContext = PrevDecl->getDeclContext();
5855	if (PrevOuterContext->isRecord())
5856	// We found a member function: ignore it.
5857	return false;
5858
5859	// Find the innermost enclosing namespace for the new and
5860	// previous declarations.
5861	OuterContext = OuterContext->getEnclosingNamespaceContext();
5862	PrevOuterContext = PrevOuterContext->getEnclosingNamespaceContext();
5863
5864	// The previous declaration is in a different namespace, so it
5865	// isn't the same function.
5866	if (!OuterContext->Equals(PrevOuterContext))
5867	return false;
5868	}
5869
5870	return true;
5871	}
5872
5873	static void SetNestedNameSpecifier(DeclaratorDecl *DD, Declarator &D) {
5874	CXXScopeSpec &SS = D.getCXXScopeSpec();
5875	if (!SS.isSet()) return;
5876	DD->setQualifierInfo(SS.getWithLocInContext(DD->getASTContext()));
5877	}
5878
5879	bool Sema::inferObjCARCLifetime(ValueDecl *decl) {
5880	QualType type = decl->getType();
5881	Qualifiers::ObjCLifetime lifetime = type.getObjCLifetime();
5882	if (lifetime == Qualifiers::OCL_Autoreleasing) {
5883	// Various kinds of declaration aren't allowed to be __autoreleasing.
5884	unsigned kind = -1U;
5885	if (VarDecl *var = dyn_cast<VarDecl>(decl)) {
5886	if (var->hasAttr<BlocksAttr>())
5887	kind = 0; // __block
5888	else if (!var->hasLocalStorage())
5889	kind = 1; // global
5890	} else if (isa<ObjCIvarDecl>(decl)) {
5891	kind = 3; // ivar
5892	} else if (isa<FieldDecl>(decl)) {
5893	kind = 2; // field
5894	}
5895
5896	if (kind != -1U) {
5897	Diag(decl->getLocation(), diag::err_arc_autoreleasing_var)
5898	<< kind;
5899	}
5900	} else if (lifetime == Qualifiers::OCL_None) {
5901	// Try to infer lifetime.
5902	if (!type->isObjCLifetimeType())
5903	return false;
5904
5905	lifetime = type->getObjCARCImplicitLifetime();
5906	type = Context.getLifetimeQualifiedType(type, lifetime);
5907	decl->setType(type);
5908	}
5909
5910	if (VarDecl *var = dyn_cast<VarDecl>(decl)) {
5911	// Thread-local variables cannot have lifetime.
5912	if (lifetime && lifetime != Qualifiers::OCL_ExplicitNone &&
5913	var->getTLSKind()) {
5914	Diag(var->getLocation(), diag::err_arc_thread_ownership)
5915	<< var->getType();
5916	return true;
5917	}
5918	}
5919
5920	return false;
5921	}
5922
5923	static void checkAttributesAfterMerging(Sema &S, NamedDecl &ND) {
5924	// Ensure that an auto decl is deduced otherwise the checks below might cache
5925	// the wrong linkage.
5926	assert(S.ParsingInitForAutoVars.count(&ND) == 0)((S.ParsingInitForAutoVars.count(&ND) == 0) ? static_cast <void> (0) : __assert_fail ("S.ParsingInitForAutoVars.count(&ND) == 0" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 5926, __PRETTY_FUNCTION__));
5927
5928	// 'weak' only applies to declarations with external linkage.
5929	if (WeakAttr *Attr = ND.getAttr<WeakAttr>()) {
5930	if (!ND.isExternallyVisible()) {
5931	S.Diag(Attr->getLocation(), diag::err_attribute_weak_static);
5932	ND.dropAttr<WeakAttr>();
5933	}
5934	}
5935	if (WeakRefAttr *Attr = ND.getAttr<WeakRefAttr>()) {
5936	if (ND.isExternallyVisible()) {
5937	S.Diag(Attr->getLocation(), diag::err_attribute_weakref_not_static);
5938	ND.dropAttr<WeakRefAttr>();
5939	ND.dropAttr<AliasAttr>();
5940	}
5941	}
5942
5943	if (auto *VD = dyn_cast<VarDecl>(&ND)) {
5944	if (VD->hasInit()) {
5945	if (const auto *Attr = VD->getAttr<AliasAttr>()) {
5946	assert(VD->isThisDeclarationADefinition() &&((VD->isThisDeclarationADefinition() && !VD->isExternallyVisible () && "Broken AliasAttr handled late!") ? static_cast <void> (0) : __assert_fail ("VD->isThisDeclarationADefinition() && !VD->isExternallyVisible() && \"Broken AliasAttr handled late!\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 5947, __PRETTY_FUNCTION__))
5947	!VD->isExternallyVisible() && "Broken AliasAttr handled late!")((VD->isThisDeclarationADefinition() && !VD->isExternallyVisible () && "Broken AliasAttr handled late!") ? static_cast <void> (0) : __assert_fail ("VD->isThisDeclarationADefinition() && !VD->isExternallyVisible() && \"Broken AliasAttr handled late!\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 5947, __PRETTY_FUNCTION__));
5948	S.Diag(Attr->getLocation(), diag::err_alias_is_definition) << VD << 0;
5949	VD->dropAttr<AliasAttr>();
5950	}
5951	}
5952	}
5953
5954	// 'selectany' only applies to externally visible variable declarations.
5955	// It does not apply to functions.
5956	if (SelectAnyAttr *Attr = ND.getAttr<SelectAnyAttr>()) {
5957	if (isa<FunctionDecl>(ND) \|\| !ND.isExternallyVisible()) {
5958	S.Diag(Attr->getLocation(),
5959	diag::err_attribute_selectany_non_extern_data);
5960	ND.dropAttr<SelectAnyAttr>();
5961	}
5962	}
5963
5964	if (const InheritableAttr *Attr = getDLLAttr(&ND)) {
5965	// dll attributes require external linkage. Static locals may have external
5966	// linkage but still cannot be explicitly imported or exported.
5967	auto *VD = dyn_cast<VarDecl>(&ND);
5968	if (!ND.isExternallyVisible() \|\| (VD && VD->isStaticLocal())) {
5969	S.Diag(ND.getLocation(), diag::err_attribute_dll_not_extern)
5970	<< &ND << Attr;
5971	ND.setInvalidDecl();
5972	}
5973	}
5974
5975	// Virtual functions cannot be marked as 'notail'.
5976	if (auto *Attr = ND.getAttr<NotTailCalledAttr>())
5977	if (auto *MD = dyn_cast<CXXMethodDecl>(&ND))
5978	if (MD->isVirtual()) {
5979	S.Diag(ND.getLocation(),
5980	diag::err_invalid_attribute_on_virtual_function)
5981	<< Attr;
5982	ND.dropAttr<NotTailCalledAttr>();
5983	}
5984
5985	// Check the attributes on the function type, if any.
5986	if (const auto *FD = dyn_cast<FunctionDecl>(&ND)) {
5987	// Don't declare this variable in the second operand of the for-statement;
5988	// GCC miscompiles that by ending its lifetime before evaluating the
5989	// third operand. See gcc.gnu.org/PR86769.
5990	AttributedTypeLoc ATL;
5991	for (TypeLoc TL = FD->getTypeSourceInfo()->getTypeLoc();
5992	(ATL = TL.getAsAdjusted<AttributedTypeLoc>());
5993	TL = ATL.getModifiedLoc()) {
5994	// The [[lifetimebound]] attribute can be applied to the implicit object
5995	// parameter of a non-static member function (other than a ctor or dtor)
5996	// by applying it to the function type.
5997	if (const auto *A = ATL.getAttrAs<LifetimeBoundAttr>()) {
5998	const auto *MD = dyn_cast<CXXMethodDecl>(FD);
5999	if (!MD \|\| MD->isStatic()) {
6000	S.Diag(A->getLocation(), diag::err_lifetimebound_no_object_param)
6001	<< !MD << A->getRange();
6002	} else if (isa<CXXConstructorDecl>(MD) \|\| isa<CXXDestructorDecl>(MD)) {
6003	S.Diag(A->getLocation(), diag::err_lifetimebound_ctor_dtor)
6004	<< isa<CXXDestructorDecl>(MD) << A->getRange();
6005	}
6006	}
6007	}
6008	}
6009	}
6010
6011	static void checkDLLAttributeRedeclaration(Sema &S, NamedDecl *OldDecl,
6012	NamedDecl *NewDecl,
6013	bool IsSpecialization,
6014	bool IsDefinition) {
6015	if (OldDecl->isInvalidDecl() \|\| NewDecl->isInvalidDecl())
6016	return;
6017
6018	bool IsTemplate = false;
6019	if (TemplateDecl *OldTD = dyn_cast<TemplateDecl>(OldDecl)) {
6020	OldDecl = OldTD->getTemplatedDecl();
6021	IsTemplate = true;
6022	if (!IsSpecialization)
6023	IsDefinition = false;
6024	}
6025	if (TemplateDecl *NewTD = dyn_cast<TemplateDecl>(NewDecl)) {
6026	NewDecl = NewTD->getTemplatedDecl();
6027	IsTemplate = true;
6028	}
6029
6030	if (!OldDecl \|\| !NewDecl)
6031	return;
6032
6033	const DLLImportAttr *OldImportAttr = OldDecl->getAttr<DLLImportAttr>();
6034	const DLLExportAttr *OldExportAttr = OldDecl->getAttr<DLLExportAttr>();
6035	const DLLImportAttr *NewImportAttr = NewDecl->getAttr<DLLImportAttr>();
6036	const DLLExportAttr *NewExportAttr = NewDecl->getAttr<DLLExportAttr>();
6037
6038	// dllimport and dllexport are inheritable attributes so we have to exclude
6039	// inherited attribute instances.
6040	bool HasNewAttr = (NewImportAttr && !NewImportAttr->isInherited()) \|\|
6041	(NewExportAttr && !NewExportAttr->isInherited());
6042
6043	// A redeclaration is not allowed to add a dllimport or dllexport attribute,
6044	// the only exception being explicit specializations.
6045	// Implicitly generated declarations are also excluded for now because there
6046	// is no other way to switch these to use dllimport or dllexport.
6047	bool AddsAttr = !(OldImportAttr \|\| OldExportAttr) && HasNewAttr;
6048
6049	if (AddsAttr && !IsSpecialization && !OldDecl->isImplicit()) {
6050	// Allow with a warning for free functions and global variables.
6051	bool JustWarn = false;
6052	if (!OldDecl->isCXXClassMember()) {
6053	auto *VD = dyn_cast<VarDecl>(OldDecl);
6054	if (VD && !VD->getDescribedVarTemplate())
6055	JustWarn = true;
6056	auto *FD = dyn_cast<FunctionDecl>(OldDecl);
6057	if (FD && FD->getTemplatedKind() == FunctionDecl::TK_NonTemplate)
6058	JustWarn = true;
6059	}
6060
6061	// We cannot change a declaration that's been used because IR has already
6062	// been emitted. Dllimported functions will still work though (modulo
6063	// address equality) as they can use the thunk.
6064	if (OldDecl->isUsed())
6065	if (!isa<FunctionDecl>(OldDecl) \|\| !NewImportAttr)
6066	JustWarn = false;
6067
6068	unsigned DiagID = JustWarn ? diag::warn_attribute_dll_redeclaration
6069	: diag::err_attribute_dll_redeclaration;
6070	S.Diag(NewDecl->getLocation(), DiagID)
6071	<< NewDecl
6072	<< (NewImportAttr ? (const Attr *)NewImportAttr : NewExportAttr);
6073	S.Diag(OldDecl->getLocation(), diag::note_previous_declaration);
6074	if (!JustWarn) {
6075	NewDecl->setInvalidDecl();
6076	return;
6077	}
6078	}
6079
6080	// A redeclaration is not allowed to drop a dllimport attribute, the only
6081	// exceptions being inline function definitions (except for function
6082	// templates), local extern declarations, qualified friend declarations or
6083	// special MSVC extension: in the last case, the declaration is treated as if
6084	// it were marked dllexport.
6085	bool IsInline = false, IsStaticDataMember = false, IsQualifiedFriend = false;
6086	bool IsMicrosoft = S.Context.getTargetInfo().getCXXABI().isMicrosoft();
6087	if (const auto *VD = dyn_cast<VarDecl>(NewDecl)) {
6088	// Ignore static data because out-of-line definitions are diagnosed
6089	// separately.
6090	IsStaticDataMember = VD->isStaticDataMember();
6091	IsDefinition = VD->isThisDeclarationADefinition(S.Context) !=
6092	VarDecl::DeclarationOnly;
6093	} else if (const auto *FD = dyn_cast<FunctionDecl>(NewDecl)) {
6094	IsInline = FD->isInlined();
6095	IsQualifiedFriend = FD->getQualifier() &&
6096	FD->getFriendObjectKind() == Decl::FOK_Declared;
6097	}
6098
6099	if (OldImportAttr && !HasNewAttr &&
6100	(!IsInline \|\| (IsMicrosoft && IsTemplate)) && !IsStaticDataMember &&
6101	!NewDecl->isLocalExternDecl() && !IsQualifiedFriend) {
6102	if (IsMicrosoft && IsDefinition) {
6103	S.Diag(NewDecl->getLocation(),
6104	diag::warn_redeclaration_without_import_attribute)
6105	<< NewDecl;
6106	S.Diag(OldDecl->getLocation(), diag::note_previous_declaration);
6107	NewDecl->dropAttr<DLLImportAttr>();
6108	NewDecl->addAttr(::new (S.Context) DLLExportAttr(
6109	NewImportAttr->getRange(), S.Context,
6110	NewImportAttr->getSpellingListIndex()));
6111	} else {
6112	S.Diag(NewDecl->getLocation(),
6113	diag::warn_redeclaration_without_attribute_prev_attribute_ignored)
6114	<< NewDecl << OldImportAttr;
6115	S.Diag(OldDecl->getLocation(), diag::note_previous_declaration);
6116	S.Diag(OldImportAttr->getLocation(), diag::note_previous_attribute);
6117	OldDecl->dropAttr<DLLImportAttr>();
6118	NewDecl->dropAttr<DLLImportAttr>();
6119	}
6120	} else if (IsInline && OldImportAttr && !IsMicrosoft) {
6121	// In MinGW, seeing a function declared inline drops the dllimport
6122	// attribute.
6123	OldDecl->dropAttr<DLLImportAttr>();
6124	NewDecl->dropAttr<DLLImportAttr>();
6125	S.Diag(NewDecl->getLocation(),
6126	diag::warn_dllimport_dropped_from_inline_function)
6127	<< NewDecl << OldImportAttr;
6128	}
6129
6130	// A specialization of a class template member function is processed here
6131	// since it's a redeclaration. If the parent class is dllexport, the
6132	// specialization inherits that attribute. This doesn't happen automatically
6133	// since the parent class isn't instantiated until later.
6134	if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(NewDecl)) {
6135	if (MD->getTemplatedKind() == FunctionDecl::TK_MemberSpecialization &&
6136	!NewImportAttr && !NewExportAttr) {
6137	if (const DLLExportAttr *ParentExportAttr =
6138	MD->getParent()->getAttr<DLLExportAttr>()) {
6139	DLLExportAttr *NewAttr = ParentExportAttr->clone(S.Context);
6140	NewAttr->setInherited(true);
6141	NewDecl->addAttr(NewAttr);
6142	}
6143	}
6144	}
6145	}
6146
6147	/// Given that we are within the definition of the given function,
6148	/// will that definition behave like C99's 'inline', where the
6149	/// definition is discarded except for optimization purposes?
6150	static bool isFunctionDefinitionDiscarded(Sema &S, FunctionDecl *FD) {
6151	// Try to avoid calling GetGVALinkageForFunction.
6152
6153	// All cases of this require the 'inline' keyword.
6154	if (!FD->isInlined()) return false;
6155
6156	// This is only possible in C++ with the gnu_inline attribute.
6157	if (S.getLangOpts().CPlusPlus && !FD->hasAttr<GNUInlineAttr>())
6158	return false;
6159
6160	// Okay, go ahead and call the relatively-more-expensive function.
6161	return S.Context.GetGVALinkageForFunction(FD) == GVA_AvailableExternally;
6162	}
6163
6164	/// Determine whether a variable is extern "C" prior to attaching
6165	/// an initializer. We can't just call isExternC() here, because that
6166	/// will also compute and cache whether the declaration is externally
6167	/// visible, which might change when we attach the initializer.
6168	///
6169	/// This can only be used if the declaration is known to not be a
6170	/// redeclaration of an internal linkage declaration.
6171	///
6172	/// For instance:
6173	///
6174	/// auto x = []{};
6175	///
6176	/// Attaching the initializer here makes this declaration not externally
6177	/// visible, because its type has internal linkage.
6178	///
6179	/// FIXME: This is a hack.
6180	template<typename T>
6181	static bool isIncompleteDeclExternC(Sema &S, const T *D) {
6182	if (S.getLangOpts().CPlusPlus) {
6183	// In C++, the overloadable attribute negates the effects of extern "C".
6184	if (!D->isInExternCContext() \|\| D->template hasAttr<OverloadableAttr>())
6185	return false;
6186
6187	// So do CUDA's host/device attributes.
6188	if (S.getLangOpts().CUDA && (D->template hasAttr<CUDADeviceAttr>() \|\|
6189	D->template hasAttr<CUDAHostAttr>()))
6190	return false;
6191	}
6192	return D->isExternC();
6193	}
6194
6195	static bool shouldConsiderLinkage(const VarDecl *VD) {
6196	const DeclContext *DC = VD->getDeclContext()->getRedeclContext();
6197	if (DC->isFunctionOrMethod() \|\| isa<OMPDeclareReductionDecl>(DC))
6198	return VD->hasExternalStorage();
6199	if (DC->isFileContext())
6200	return true;
6201	if (DC->isRecord())
6202	return false;
6203	llvm_unreachable("Unexpected context")::llvm::llvm_unreachable_internal("Unexpected context", "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 6203);
6204	}
6205
6206	static bool shouldConsiderLinkage(const FunctionDecl *FD) {
6207	const DeclContext *DC = FD->getDeclContext()->getRedeclContext();
6208	if (DC->isFileContext() \|\| DC->isFunctionOrMethod() \|\|
6209	isa<OMPDeclareReductionDecl>(DC))
6210	return true;
6211	if (DC->isRecord())
6212	return false;
6213	llvm_unreachable("Unexpected context")::llvm::llvm_unreachable_internal("Unexpected context", "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 6213);
6214	}
6215
6216	static bool hasParsedAttr(Scope *S, const Declarator &PD,
6217	ParsedAttr::Kind Kind) {
6218	// Check decl attributes on the DeclSpec.
6219	if (PD.getDeclSpec().getAttributes().hasAttribute(Kind))
6220	return true;
6221
6222	// Walk the declarator structure, checking decl attributes that were in a type
6223	// position to the decl itself.
6224	for (unsigned I = 0, E = PD.getNumTypeObjects(); I != E; ++I) {
6225	if (PD.getTypeObject(I).getAttrs().hasAttribute(Kind))
6226	return true;
6227	}
6228
6229	// Finally, check attributes on the decl itself.
6230	return PD.getAttributes().hasAttribute(Kind);
6231	}
6232
6233	/// Adjust the \c DeclContext for a function or variable that might be a
6234	/// function-local external declaration.
6235	bool Sema::adjustContextForLocalExternDecl(DeclContext *&DC) {
6236	if (!DC->isFunctionOrMethod())
6237	return false;
6238
6239	// If this is a local extern function or variable declared within a function
6240	// template, don't add it into the enclosing namespace scope until it is
6241	// instantiated; it might have a dependent type right now.
6242	if (DC->isDependentContext())
6243	return true;
6244
6245	// C++11 [basic.link]p7:
6246	// When a block scope declaration of an entity with linkage is not found to
6247	// refer to some other declaration, then that entity is a member of the
6248	// innermost enclosing namespace.
6249	//
6250	// Per C++11 [namespace.def]p6, the innermost enclosing namespace is a
6251	// semantically-enclosing namespace, not a lexically-enclosing one.
6252	while (!DC->isFileContext() && !isa<LinkageSpecDecl>(DC))
6253	DC = DC->getParent();
6254	return true;
6255	}
6256
6257	/// Returns true if given declaration has external C language linkage.
6258	static bool isDeclExternC(const Decl *D) {
6259	if (const auto *FD = dyn_cast<FunctionDecl>(D))
6260	return FD->isExternC();
6261	if (const auto *VD = dyn_cast<VarDecl>(D))
6262	return VD->isExternC();
6263
6264	llvm_unreachable("Unknown type of decl!")::llvm::llvm_unreachable_internal("Unknown type of decl!", "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 6264);
6265	}
6266
6267	NamedDecl *Sema::ActOnVariableDeclarator(
6268	Scope S, Declarator &D, DeclContext DC, TypeSourceInfo *TInfo,
6269	LookupResult &Previous, MultiTemplateParamsArg TemplateParamLists,
6270	bool &AddToScope, ArrayRef<BindingDecl *> Bindings) {
6271	QualType R = TInfo->getType();
6272	DeclarationName Name = GetNameForDeclarator(D).getName();
6273
6274	IdentifierInfo *II = Name.getAsIdentifierInfo();
6275
6276	if (D.isDecompositionDeclarator()) {
6277	// Take the name of the first declarator as our name for diagnostic
6278	// purposes.
6279	auto &Decomp = D.getDecompositionDeclarator();
6280	if (!Decomp.bindings().empty()) {
6281	II = Decomp.bindings()[0].Name;
6282	Name = II;
6283	}
6284	} else if (!II) {
6285	Diag(D.getIdentifierLoc(), diag::err_bad_variable_name) << Name;
6286	return nullptr;
6287	}
6288
6289	if (getLangOpts().OpenCL) {
6290	// OpenCL v2.0 s6.9.b - Image type can only be used as a function argument.
6291	// OpenCL v2.0 s6.13.16.1 - Pipe type can only be used as a function
6292	// argument.
6293	if (R->isImageType() \|\| R->isPipeType()) {
6294	Diag(D.getIdentifierLoc(),
6295	diag::err_opencl_type_can_only_be_used_as_function_parameter)
6296	<< R;
6297	D.setInvalidType();
6298	return nullptr;
6299	}
6300
6301	// OpenCL v1.2 s6.9.r:
6302	// The event type cannot be used to declare a program scope variable.
6303	// OpenCL v2.0 s6.9.q:
6304	// The clk_event_t and reserve_id_t types cannot be declared in program scope.
6305	if (NULL__null == S->getParent()) {
6306	if (R->isReserveIDT() \|\| R->isClkEventT() \|\| R->isEventT()) {
6307	Diag(D.getIdentifierLoc(),
6308	diag::err_invalid_type_for_program_scope_var) << R;
6309	D.setInvalidType();
6310	return nullptr;
6311	}
6312	}
6313
6314	// OpenCL v1.0 s6.8.a.3: Pointers to functions are not allowed.
6315	QualType NR = R;
6316	while (NR->isPointerType()) {
6317	if (NR->isFunctionPointerType()) {
6318	Diag(D.getIdentifierLoc(), diag::err_opencl_function_pointer);
6319	D.setInvalidType();
6320	break;
6321	}
6322	NR = NR->getPointeeType();
6323	}
6324
6325	if (!getOpenCLOptions().isEnabled("cl_khr_fp16")) {
6326	// OpenCL v1.2 s6.1.1.1: reject declaring variables of the half and
6327	// half array type (unless the cl_khr_fp16 extension is enabled).
6328	if (Context.getBaseElementType(R)->isHalfType()) {
6329	Diag(D.getIdentifierLoc(), diag::err_opencl_half_declaration) << R;
6330	D.setInvalidType();
6331	}
6332	}
6333
6334	if (R->isSamplerT()) {
6335	// OpenCL v1.2 s6.9.b p4:
6336	// The sampler type cannot be used with the __local and __global address
6337	// space qualifiers.
6338	if (R.getAddressSpace() == LangAS::opencl_local \|\|
6339	R.getAddressSpace() == LangAS::opencl_global) {
6340	Diag(D.getIdentifierLoc(), diag::err_wrong_sampler_addressspace);
6341	}
6342
6343	// OpenCL v1.2 s6.12.14.1:
6344	// A global sampler must be declared with either the constant address
6345	// space qualifier or with the const qualifier.
6346	if (DC->isTranslationUnit() &&
6347	!(R.getAddressSpace() == LangAS::opencl_constant \|\|
6348	R.isConstQualified())) {
6349	Diag(D.getIdentifierLoc(), diag::err_opencl_nonconst_global_sampler);
6350	D.setInvalidType();
6351	}
6352	}
6353
6354	// OpenCL v1.2 s6.9.r:
6355	// The event type cannot be used with the __local, __constant and __global
6356	// address space qualifiers.
6357	if (R->isEventT()) {
6358	if (R.getAddressSpace() != LangAS::opencl_private) {
6359	Diag(D.getBeginLoc(), diag::err_event_t_addr_space_qual);
6360	D.setInvalidType();
6361	}
6362	}
6363
6364	// OpenCL C++ 1.0 s2.9: the thread_local storage qualifier is not
6365	// supported. OpenCL C does not support thread_local either, and
6366	// also reject all other thread storage class specifiers.
6367	DeclSpec::TSCS TSC = D.getDeclSpec().getThreadStorageClassSpec();
6368	if (TSC != TSCS_unspecified) {
6369	bool IsCXX = getLangOpts().OpenCLCPlusPlus;
6370	Diag(D.getDeclSpec().getThreadStorageClassSpecLoc(),
6371	diag::err_opencl_unknown_type_specifier)
6372	<< IsCXX << getLangOpts().getOpenCLVersionTuple().getAsString()
6373	<< DeclSpec::getSpecifierName(TSC) << 1;
6374	D.setInvalidType();
6375	return nullptr;
6376	}
6377	}
6378
6379	DeclSpec::SCS SCSpec = D.getDeclSpec().getStorageClassSpec();
6380	StorageClass SC = StorageClassSpecToVarDeclStorageClass(D.getDeclSpec());
6381
6382	// dllimport globals without explicit storage class are treated as extern. We
6383	// have to change the storage class this early to get the right DeclContext.
6384	if (SC == SC_None && !DC->isRecord() &&
6385	hasParsedAttr(S, D, ParsedAttr::AT_DLLImport) &&
6386	!hasParsedAttr(S, D, ParsedAttr::AT_DLLExport))
6387	SC = SC_Extern;
6388
6389	DeclContext *OriginalDC = DC;
6390	bool IsLocalExternDecl = SC == SC_Extern &&
6391	adjustContextForLocalExternDecl(DC);
6392
6393	if (SCSpec == DeclSpec::SCS_mutable) {
6394	// mutable can only appear on non-static class members, so it's always
6395	// an error here
6396	Diag(D.getIdentifierLoc(), diag::err_mutable_nonmember);
6397	D.setInvalidType();
6398	SC = SC_None;
6399	}
6400
6401	if (getLangOpts().CPlusPlus11 && SCSpec == DeclSpec::SCS_register &&
6402	!D.getAsmLabel() && !getSourceManager().isInSystemMacro(
6403	D.getDeclSpec().getStorageClassSpecLoc())) {
6404	// In C++11, the 'register' storage class specifier is deprecated.
6405	// Suppress the warning in system macros, it's used in macros in some
6406	// popular C system headers, such as in glibc's htonl() macro.
6407	Diag(D.getDeclSpec().getStorageClassSpecLoc(),
6408	getLangOpts().CPlusPlus17 ? diag::ext_register_storage_class
6409	: diag::warn_deprecated_register)
6410	<< FixItHint::CreateRemoval(D.getDeclSpec().getStorageClassSpecLoc());
6411	}
6412
6413	DiagnoseFunctionSpecifiers(D.getDeclSpec());
6414
6415	if (!DC->isRecord() && S->getFnParent() == nullptr) {
6416	// C99 6.9p2: The storage-class specifiers auto and register shall not
6417	// appear in the declaration specifiers in an external declaration.
6418	// Global Register+Asm is a GNU extension we support.
6419	if (SC == SC_Auto \|\| (SC == SC_Register && !D.getAsmLabel())) {
6420	Diag(D.getIdentifierLoc(), diag::err_typecheck_sclass_fscope);
6421	D.setInvalidType();
6422	}
6423	}
6424
6425	bool IsMemberSpecialization = false;
6426	bool IsVariableTemplateSpecialization = false;
6427	bool IsPartialSpecialization = false;
6428	bool IsVariableTemplate = false;
6429	VarDecl *NewVD = nullptr;
6430	VarTemplateDecl *NewTemplate = nullptr;
6431	TemplateParameterList *TemplateParams = nullptr;
6432	if (!getLangOpts().CPlusPlus) {
6433	NewVD = VarDecl::Create(Context, DC, D.getBeginLoc(), D.getIdentifierLoc(),
6434	II, R, TInfo, SC);
6435
6436	if (R->getContainedDeducedType())
6437	ParsingInitForAutoVars.insert(NewVD);
6438
6439	if (D.isInvalidType())
6440	NewVD->setInvalidDecl();
6441	} else {
6442	bool Invalid = false;
6443
6444	if (DC->isRecord() && !CurContext->isRecord()) {
6445	// This is an out-of-line definition of a static data member.
6446	switch (SC) {
6447	case SC_None:
6448	break;
6449	case SC_Static:
6450	Diag(D.getDeclSpec().getStorageClassSpecLoc(),
6451	diag::err_static_out_of_line)
6452	<< FixItHint::CreateRemoval(D.getDeclSpec().getStorageClassSpecLoc());
6453	break;
6454	case SC_Auto:
6455	case SC_Register:
6456	case SC_Extern:
6457	// [dcl.stc] p2: The auto or register specifiers shall be applied only
6458	// to names of variables declared in a block or to function parameters.
6459	// [dcl.stc] p6: The extern specifier cannot be used in the declaration
6460	// of class members
6461
6462	Diag(D.getDeclSpec().getStorageClassSpecLoc(),
6463	diag::err_storage_class_for_static_member)
6464	<< FixItHint::CreateRemoval(D.getDeclSpec().getStorageClassSpecLoc());
6465	break;
6466	case SC_PrivateExtern:
6467	llvm_unreachable("C storage class in c++!")::llvm::llvm_unreachable_internal("C storage class in c++!", "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 6467);
6468	}
6469	}
6470
6471	if (SC == SC_Static && CurContext->isRecord()) {
6472	if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(DC)) {
6473	if (RD->isLocalClass())
6474	Diag(D.getIdentifierLoc(),
6475	diag::err_static_data_member_not_allowed_in_local_class)
6476	<< Name << RD->getDeclName();
6477
6478	// C++98 [class.union]p1: If a union contains a static data member,
6479	// the program is ill-formed. C++11 drops this restriction.
6480	if (RD->isUnion())
6481	Diag(D.getIdentifierLoc(),
6482	getLangOpts().CPlusPlus11
6483	? diag::warn_cxx98_compat_static_data_member_in_union
6484	: diag::ext_static_data_member_in_union) << Name;
6485	// We conservatively disallow static data members in anonymous structs.
6486	else if (!RD->getDeclName())
6487	Diag(D.getIdentifierLoc(),
6488	diag::err_static_data_member_not_allowed_in_anon_struct)
6489	<< Name << RD->isUnion();
6490	}
6491	}
6492
6493	// Match up the template parameter lists with the scope specifier, then
6494	// determine whether we have a template or a template specialization.
6495	TemplateParams = MatchTemplateParametersToScopeSpecifier(
6496	D.getDeclSpec().getBeginLoc(), D.getIdentifierLoc(),
6497	D.getCXXScopeSpec(),
6498	D.getName().getKind() == UnqualifiedIdKind::IK_TemplateId
6499	? D.getName().TemplateId
6500	: nullptr,
6501	TemplateParamLists,
6502	/never a friend/ false, IsMemberSpecialization, Invalid);
6503
6504	if (TemplateParams) {
6505	if (!TemplateParams->size() &&
6506	D.getName().getKind() != UnqualifiedIdKind::IK_TemplateId) {
6507	// There is an extraneous 'template<>' for this variable. Complain
6508	// about it, but allow the declaration of the variable.
6509	Diag(TemplateParams->getTemplateLoc(),
6510	diag::err_template_variable_noparams)
6511	<< II
6512	<< SourceRange(TemplateParams->getTemplateLoc(),
6513	TemplateParams->getRAngleLoc());
6514	TemplateParams = nullptr;
6515	} else {
6516	if (D.getName().getKind() == UnqualifiedIdKind::IK_TemplateId) {
6517	// This is an explicit specialization or a partial specialization.
6518	// FIXME: Check that we can declare a specialization here.
6519	IsVariableTemplateSpecialization = true;
6520	IsPartialSpecialization = TemplateParams->size() > 0;
6521	} else { // if (TemplateParams->size() > 0)
6522	// This is a template declaration.
6523	IsVariableTemplate = true;
6524
6525	// Check that we can declare a template here.
6526	if (CheckTemplateDeclScope(S, TemplateParams))
6527	return nullptr;
6528
6529	// Only C++1y supports variable templates (N3651).
6530	Diag(D.getIdentifierLoc(),
6531	getLangOpts().CPlusPlus14
6532	? diag::warn_cxx11_compat_variable_template
6533	: diag::ext_variable_template);
6534	}
6535	}
6536	} else {
6537	assert((Invalid \|\|(((Invalid \|\| D.getName().getKind() != UnqualifiedIdKind::IK_TemplateId ) && "should have a 'template<>' for this decl" ) ? static_cast<void> (0) : __assert_fail ("(Invalid \|\| D.getName().getKind() != UnqualifiedIdKind::IK_TemplateId) && \"should have a 'template<>' for this decl\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 6539, __PRETTY_FUNCTION__))
6538	D.getName().getKind() != UnqualifiedIdKind::IK_TemplateId) &&(((Invalid \|\| D.getName().getKind() != UnqualifiedIdKind::IK_TemplateId ) && "should have a 'template<>' for this decl" ) ? static_cast<void> (0) : __assert_fail ("(Invalid \|\| D.getName().getKind() != UnqualifiedIdKind::IK_TemplateId) && \"should have a 'template<>' for this decl\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 6539, __PRETTY_FUNCTION__))
6539	"should have a 'template<>' for this decl")(((Invalid \|\| D.getName().getKind() != UnqualifiedIdKind::IK_TemplateId ) && "should have a 'template<>' for this decl" ) ? static_cast<void> (0) : __assert_fail ("(Invalid \|\| D.getName().getKind() != UnqualifiedIdKind::IK_TemplateId) && \"should have a 'template<>' for this decl\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 6539, __PRETTY_FUNCTION__));
6540	}
6541
6542	if (IsVariableTemplateSpecialization) {
6543	SourceLocation TemplateKWLoc =
6544	TemplateParamLists.size() > 0
6545	? TemplateParamLists[0]->getTemplateLoc()
6546	: SourceLocation();
6547	DeclResult Res = ActOnVarTemplateSpecialization(
6548	S, D, TInfo, TemplateKWLoc, TemplateParams, SC,
6549	IsPartialSpecialization);
6550	if (Res.isInvalid())
6551	return nullptr;
6552	NewVD = cast<VarDecl>(Res.get());
6553	AddToScope = false;
6554	} else if (D.isDecompositionDeclarator()) {
6555	NewVD = DecompositionDecl::Create(Context, DC, D.getBeginLoc(),
6556	D.getIdentifierLoc(), R, TInfo, SC,
6557	Bindings);
6558	} else
6559	NewVD = VarDecl::Create(Context, DC, D.getBeginLoc(),
6560	D.getIdentifierLoc(), II, R, TInfo, SC);
6561
6562	// If this is supposed to be a variable template, create it as such.
6563	if (IsVariableTemplate) {
6564	NewTemplate =
6565	VarTemplateDecl::Create(Context, DC, D.getIdentifierLoc(), Name,
6566	TemplateParams, NewVD);
6567	NewVD->setDescribedVarTemplate(NewTemplate);
6568	}
6569
6570	// If this decl has an auto type in need of deduction, make a note of the
6571	// Decl so we can diagnose uses of it in its own initializer.
6572	if (R->getContainedDeducedType())
6573	ParsingInitForAutoVars.insert(NewVD);
6574
6575	if (D.isInvalidType() \|\| Invalid) {
6576	NewVD->setInvalidDecl();
6577	if (NewTemplate)
6578	NewTemplate->setInvalidDecl();
6579	}
6580
6581	SetNestedNameSpecifier(NewVD, D);
6582
6583	// If we have any template parameter lists that don't directly belong to
6584	// the variable (matching the scope specifier), store them.
6585	unsigned VDTemplateParamLists = TemplateParams ? 1 : 0;
6586	if (TemplateParamLists.size() > VDTemplateParamLists)
6587	NewVD->setTemplateParameterListsInfo(
6588	Context, TemplateParamLists.drop_back(VDTemplateParamLists));
6589
6590	if (D.getDeclSpec().isConstexprSpecified()) {
6591	NewVD->setConstexpr(true);
6592	// C++1z [dcl.spec.constexpr]p1:
6593	// A static data member declared with the constexpr specifier is
6594	// implicitly an inline variable.
6595	if (NewVD->isStaticDataMember() && getLangOpts().CPlusPlus17)
6596	NewVD->setImplicitlyInline();
6597	}
6598	}
6599
6600	if (D.getDeclSpec().isInlineSpecified()) {
6601	if (!getLangOpts().CPlusPlus) {
6602	Diag(D.getDeclSpec().getInlineSpecLoc(), diag::err_inline_non_function)
6603	<< 0;
6604	} else if (CurContext->isFunctionOrMethod()) {
6605	// 'inline' is not allowed on block scope variable declaration.
6606	Diag(D.getDeclSpec().getInlineSpecLoc(),
6607	diag::err_inline_declaration_block_scope) << Name
6608	<< FixItHint::CreateRemoval(D.getDeclSpec().getInlineSpecLoc());
6609	} else {
6610	Diag(D.getDeclSpec().getInlineSpecLoc(),
6611	getLangOpts().CPlusPlus17 ? diag::warn_cxx14_compat_inline_variable
6612	: diag::ext_inline_variable);
6613	NewVD->setInlineSpecified();
6614	}
6615	}
6616
6617	// Set the lexical context. If the declarator has a C++ scope specifier, the
6618	// lexical context will be different from the semantic context.
6619	NewVD->setLexicalDeclContext(CurContext);
6620	if (NewTemplate)
6621	NewTemplate->setLexicalDeclContext(CurContext);
6622
6623	if (IsLocalExternDecl) {
6624	if (D.isDecompositionDeclarator())
6625	for (auto *B : Bindings)
6626	B->setLocalExternDecl();
6627	else
6628	NewVD->setLocalExternDecl();
6629	}
6630
6631	bool EmitTLSUnsupportedError = false;
6632	if (DeclSpec::TSCS TSCS = D.getDeclSpec().getThreadStorageClassSpec()) {
6633	// C++11 [dcl.stc]p4:
6634	// When thread_local is applied to a variable of block scope the
6635	// storage-class-specifier static is implied if it does not appear
6636	// explicitly.
6637	// Core issue: 'static' is not implied if the variable is declared
6638	// 'extern'.
6639	if (NewVD->hasLocalStorage() &&
6640	(SCSpec != DeclSpec::SCS_unspecified \|\|
6641	TSCS != DeclSpec::TSCS_thread_local \|\|
6642	!DC->isFunctionOrMethod()))
6643	Diag(D.getDeclSpec().getThreadStorageClassSpecLoc(),
6644	diag::err_thread_non_global)
6645	<< DeclSpec::getSpecifierName(TSCS);
6646	else if (!Context.getTargetInfo().isTLSSupported()) {
6647	if (getLangOpts().CUDA \|\| getLangOpts().OpenMPIsDevice) {
6648	// Postpone error emission until we've collected attributes required to
6649	// figure out whether it's a host or device variable and whether the
6650	// error should be ignored.
6651	EmitTLSUnsupportedError = true;
6652	// We still need to mark the variable as TLS so it shows up in AST with
6653	// proper storage class for other tools to use even if we're not going
6654	// to emit any code for it.
6655	NewVD->setTSCSpec(TSCS);
6656	} else
6657	Diag(D.getDeclSpec().getThreadStorageClassSpecLoc(),
6658	diag::err_thread_unsupported);
6659	} else
6660	NewVD->setTSCSpec(TSCS);
6661	}
6662
6663	// C99 6.7.4p3
6664	// An inline definition of a function with external linkage shall
6665	// not contain a definition of a modifiable object with static or
6666	// thread storage duration...
6667	// We only apply this when the function is required to be defined
6668	// elsewhere, i.e. when the function is not 'extern inline'. Note
6669	// that a local variable with thread storage duration still has to
6670	// be marked 'static'. Also note that it's possible to get these
6671	// semantics in C++ using __attribute__((gnu_inline)).
6672	if (SC == SC_Static && S->getFnParent() != nullptr &&
6673	!NewVD->getType().isConstQualified()) {
6674	FunctionDecl *CurFD = getCurFunctionDecl();
6675	if (CurFD && isFunctionDefinitionDiscarded(*this, CurFD)) {
6676	Diag(D.getDeclSpec().getStorageClassSpecLoc(),
6677	diag::warn_static_local_in_extern_inline);
6678	MaybeSuggestAddingStaticToDecl(CurFD);
6679	}
6680	}
6681
6682	if (D.getDeclSpec().isModulePrivateSpecified()) {
6683	if (IsVariableTemplateSpecialization)
6684	Diag(NewVD->getLocation(), diag::err_module_private_specialization)
6685	<< (IsPartialSpecialization ? 1 : 0)
6686	<< FixItHint::CreateRemoval(
6687	D.getDeclSpec().getModulePrivateSpecLoc());
6688	else if (IsMemberSpecialization)
6689	Diag(NewVD->getLocation(), diag::err_module_private_specialization)
6690	<< 2
6691	<< FixItHint::CreateRemoval(D.getDeclSpec().getModulePrivateSpecLoc());
6692	else if (NewVD->hasLocalStorage())
6693	Diag(NewVD->getLocation(), diag::err_module_private_local)
6694	<< 0 << NewVD->getDeclName()
6695	<< SourceRange(D.getDeclSpec().getModulePrivateSpecLoc())
6696	<< FixItHint::CreateRemoval(D.getDeclSpec().getModulePrivateSpecLoc());
6697	else {
6698	NewVD->setModulePrivate();
6699	if (NewTemplate)
6700	NewTemplate->setModulePrivate();
6701	for (auto *B : Bindings)
6702	B->setModulePrivate();
6703	}
6704	}
6705
6706	// Handle attributes prior to checking for duplicates in MergeVarDecl
6707	ProcessDeclAttributes(S, NewVD, D);
6708
6709	if (getLangOpts().CUDA \|\| getLangOpts().OpenMPIsDevice) {
6710	if (EmitTLSUnsupportedError &&
6711	((getLangOpts().CUDA && DeclAttrsMatchCUDAMode(getLangOpts(), NewVD)) \|\|
6712	(getLangOpts().OpenMPIsDevice &&
6713	NewVD->hasAttr<OMPDeclareTargetDeclAttr>())))
6714	Diag(D.getDeclSpec().getThreadStorageClassSpecLoc(),
6715	diag::err_thread_unsupported);
6716	// CUDA B.2.5: "__shared__ and __constant__ variables have implied static
6717	// storage [duration]."
6718	if (SC == SC_None && S->getFnParent() != nullptr &&
6719	(NewVD->hasAttr<CUDASharedAttr>() \|\|
6720	NewVD->hasAttr<CUDAConstantAttr>())) {
6721	NewVD->setStorageClass(SC_Static);
6722	}
6723	}
6724
6725	// Ensure that dllimport globals without explicit storage class are treated as
6726	// extern. The storage class is set above using parsed attributes. Now we can
6727	// check the VarDecl itself.
6728	assert(!NewVD->hasAttr<DLLImportAttr>() \|\|((!NewVD->hasAttr<DLLImportAttr>() \|\| NewVD->getAttr <DLLImportAttr>()->isInherited() \|\| NewVD->isStaticDataMember () \|\| NewVD->getStorageClass() != SC_None) ? static_cast< void> (0) : __assert_fail ("!NewVD->hasAttr<DLLImportAttr>() \|\| NewVD->getAttr<DLLImportAttr>()->isInherited() \|\| NewVD->isStaticDataMember() \|\| NewVD->getStorageClass() != SC_None" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 6730, __PRETTY_FUNCTION__))
6729	NewVD->getAttr<DLLImportAttr>()->isInherited() \|\|((!NewVD->hasAttr<DLLImportAttr>() \|\| NewVD->getAttr <DLLImportAttr>()->isInherited() \|\| NewVD->isStaticDataMember () \|\| NewVD->getStorageClass() != SC_None) ? static_cast< void> (0) : __assert_fail ("!NewVD->hasAttr<DLLImportAttr>() \|\| NewVD->getAttr<DLLImportAttr>()->isInherited() \|\| NewVD->isStaticDataMember() \|\| NewVD->getStorageClass() != SC_None" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 6730, __PRETTY_FUNCTION__))
6730	NewVD->isStaticDataMember() \|\| NewVD->getStorageClass() != SC_None)((!NewVD->hasAttr<DLLImportAttr>() \|\| NewVD->getAttr <DLLImportAttr>()->isInherited() \|\| NewVD->isStaticDataMember () \|\| NewVD->getStorageClass() != SC_None) ? static_cast< void> (0) : __assert_fail ("!NewVD->hasAttr<DLLImportAttr>() \|\| NewVD->getAttr<DLLImportAttr>()->isInherited() \|\| NewVD->isStaticDataMember() \|\| NewVD->getStorageClass() != SC_None" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 6730, __PRETTY_FUNCTION__));
6731
6732	// In auto-retain/release, infer strong retension for variables of
6733	// retainable type.
6734	if (getLangOpts().ObjCAutoRefCount && inferObjCARCLifetime(NewVD))
6735	NewVD->setInvalidDecl();
6736
6737	// Handle GNU asm-label extension (encoded as an attribute).
6738	if (Expr E = (Expr)D.getAsmLabel()) {
6739	// The parser guarantees this is a string.
6740	StringLiteral *SE = cast<StringLiteral>(E);
6741	StringRef Label = SE->getString();
6742	if (S->getFnParent() != nullptr) {
6743	switch (SC) {
6744	case SC_None:
6745	case SC_Auto:
6746	Diag(E->getExprLoc(), diag::warn_asm_label_on_auto_decl) << Label;
6747	break;
6748	case SC_Register:
6749	// Local Named register
6750	if (!Context.getTargetInfo().isValidGCCRegisterName(Label) &&
6751	DeclAttrsMatchCUDAMode(getLangOpts(), getCurFunctionDecl()))
6752	Diag(E->getExprLoc(), diag::err_asm_unknown_register_name) << Label;
6753	break;
6754	case SC_Static:
6755	case SC_Extern:
6756	case SC_PrivateExtern:
6757	break;
6758	}
6759	} else if (SC == SC_Register) {
6760	// Global Named register
6761	if (DeclAttrsMatchCUDAMode(getLangOpts(), NewVD)) {
6762	const auto &TI = Context.getTargetInfo();
6763	bool HasSizeMismatch;
6764
6765	if (!TI.isValidGCCRegisterName(Label))
6766	Diag(E->getExprLoc(), diag::err_asm_unknown_register_name) << Label;
6767	else if (!TI.validateGlobalRegisterVariable(Label,
6768	Context.getTypeSize(R),
6769	HasSizeMismatch))
6770	Diag(E->getExprLoc(), diag::err_asm_invalid_global_var_reg) << Label;
6771	else if (HasSizeMismatch)
6772	Diag(E->getExprLoc(), diag::err_asm_register_size_mismatch) << Label;
6773	}
6774
6775	if (!R->isIntegralType(Context) && !R->isPointerType()) {
6776	Diag(D.getBeginLoc(), diag::err_asm_bad_register_type);
6777	NewVD->setInvalidDecl(true);
6778	}
6779	}
6780
6781	NewVD->addAttr(::new (Context) AsmLabelAttr(SE->getStrTokenLoc(0),
6782	Context, Label, 0));
6783	} else if (!ExtnameUndeclaredIdentifiers.empty()) {
6784	llvm::DenseMap<IdentifierInfo,AsmLabelAttr>::iterator I =
6785	ExtnameUndeclaredIdentifiers.find(NewVD->getIdentifier());
6786	if (I != ExtnameUndeclaredIdentifiers.end()) {
6787	if (isDeclExternC(NewVD)) {
6788	NewVD->addAttr(I->second);
6789	ExtnameUndeclaredIdentifiers.erase(I);
6790	} else
6791	Diag(NewVD->getLocation(), diag::warn_redefine_extname_not_applied)
6792	<< /Variable/1 << NewVD;
6793	}
6794	}
6795
6796	// Find the shadowed declaration before filtering for scope.
6797	NamedDecl *ShadowedDecl = D.getCXXScopeSpec().isEmpty()
6798	? getShadowedDeclaration(NewVD, Previous)
6799	: nullptr;
6800
6801	// Don't consider existing declarations that are in a different
6802	// scope and are out-of-semantic-context declarations (if the new
6803	// declaration has linkage).
6804	FilterLookupForScope(Previous, OriginalDC, S, shouldConsiderLinkage(NewVD),
6805	D.getCXXScopeSpec().isNotEmpty() \|\|
6806	IsMemberSpecialization \|\|
6807	IsVariableTemplateSpecialization);
6808
6809	// Check whether the previous declaration is in the same block scope. This
6810	// affects whether we merge types with it, per C++11 [dcl.array]p3.
6811	if (getLangOpts().CPlusPlus &&
6812	NewVD->isLocalVarDecl() && NewVD->hasExternalStorage())
6813	NewVD->setPreviousDeclInSameBlockScope(
6814	Previous.isSingleResult() && !Previous.isShadowed() &&
6815	isDeclInScope(Previous.getFoundDecl(), OriginalDC, S, false));
6816
6817	if (!getLangOpts().CPlusPlus) {
6818	D.setRedeclaration(CheckVariableDeclaration(NewVD, Previous));
6819	} else {
6820	// If this is an explicit specialization of a static data member, check it.
6821	if (IsMemberSpecialization && !NewVD->isInvalidDecl() &&
6822	CheckMemberSpecialization(NewVD, Previous))
6823	NewVD->setInvalidDecl();
6824
6825	// Merge the decl with the existing one if appropriate.
6826	if (!Previous.empty()) {
6827	if (Previous.isSingleResult() &&
6828	isa<FieldDecl>(Previous.getFoundDecl()) &&
6829	D.getCXXScopeSpec().isSet()) {
6830	// The user tried to define a non-static data member
6831	// out-of-line (C++ [dcl.meaning]p1).
6832	Diag(NewVD->getLocation(), diag::err_nonstatic_member_out_of_line)
6833	<< D.getCXXScopeSpec().getRange();
6834	Previous.clear();
6835	NewVD->setInvalidDecl();
6836	}
6837	} else if (D.getCXXScopeSpec().isSet()) {
6838	// No previous declaration in the qualifying scope.
6839	Diag(D.getIdentifierLoc(), diag::err_no_member)
6840	<< Name << computeDeclContext(D.getCXXScopeSpec(), true)
6841	<< D.getCXXScopeSpec().getRange();
6842	NewVD->setInvalidDecl();
6843	}
6844
6845	if (!IsVariableTemplateSpecialization)
6846	D.setRedeclaration(CheckVariableDeclaration(NewVD, Previous));
6847
6848	if (NewTemplate) {
6849	VarTemplateDecl *PrevVarTemplate =
6850	NewVD->getPreviousDecl()
6851	? NewVD->getPreviousDecl()->getDescribedVarTemplate()
6852	: nullptr;
6853
6854	// Check the template parameter list of this declaration, possibly
6855	// merging in the template parameter list from the previous variable
6856	// template declaration.
6857	if (CheckTemplateParameterList(
6858	TemplateParams,
6859	PrevVarTemplate ? PrevVarTemplate->getTemplateParameters()
6860	: nullptr,
6861	(D.getCXXScopeSpec().isSet() && DC && DC->isRecord() &&
6862	DC->isDependentContext())
6863	? TPC_ClassTemplateMember
6864	: TPC_VarTemplate))
6865	NewVD->setInvalidDecl();
6866
6867	// If we are providing an explicit specialization of a static variable
6868	// template, make a note of that.
6869	if (PrevVarTemplate &&
6870	PrevVarTemplate->getInstantiatedFromMemberTemplate())
6871	PrevVarTemplate->setMemberSpecialization();
6872	}
6873	}
6874
6875	// Diagnose shadowed variables iff this isn't a redeclaration.
6876	if (ShadowedDecl && !D.isRedeclaration())
6877	CheckShadow(NewVD, ShadowedDecl, Previous);
6878
6879	ProcessPragmaWeak(S, NewVD);
6880
6881	// If this is the first declaration of an extern C variable, update
6882	// the map of such variables.
6883	if (NewVD->isFirstDecl() && !NewVD->isInvalidDecl() &&
6884	isIncompleteDeclExternC(*this, NewVD))
6885	RegisterLocallyScopedExternCDecl(NewVD, S);
6886
6887	if (getLangOpts().CPlusPlus && NewVD->isStaticLocal()) {
6888	Decl *ManglingContextDecl;
6889	if (MangleNumberingContext *MCtx = getCurrentMangleNumberContext(
6890	NewVD->getDeclContext(), ManglingContextDecl)) {
6891	Context.setManglingNumber(
6892	NewVD, MCtx->getManglingNumber(
6893	NewVD, getMSManglingNumber(getLangOpts(), S)));
6894	Context.setStaticLocalNumber(NewVD, MCtx->getStaticLocalNumber(NewVD));
6895	}
6896	}
6897
6898	// Special handling of variable named 'main'.
6899	if (Name.getAsIdentifierInfo() && Name.getAsIdentifierInfo()->isStr("main") &&
6900	NewVD->getDeclContext()->getRedeclContext()->isTranslationUnit() &&
6901	!getLangOpts().Freestanding && !NewVD->getDescribedVarTemplate()) {
6902
6903	// C++ [basic.start.main]p3
6904	// A program that declares a variable main at global scope is ill-formed.
6905	if (getLangOpts().CPlusPlus)
6906	Diag(D.getBeginLoc(), diag::err_main_global_variable);
6907
6908	// In C, and external-linkage variable named main results in undefined
6909	// behavior.
6910	else if (NewVD->hasExternalFormalLinkage())
6911	Diag(D.getBeginLoc(), diag::warn_main_redefined);
6912	}
6913
6914	if (D.isRedeclaration() && !Previous.empty()) {
6915	NamedDecl *Prev = Previous.getRepresentativeDecl();
6916	checkDLLAttributeRedeclaration(*this, Prev, NewVD, IsMemberSpecialization,
6917	D.isFunctionDefinition());
6918	}
6919
6920	if (NewTemplate) {
6921	if (NewVD->isInvalidDecl())
6922	NewTemplate->setInvalidDecl();
6923	ActOnDocumentableDecl(NewTemplate);
6924	return NewTemplate;
6925	}
6926
6927	if (IsMemberSpecialization && !NewVD->isInvalidDecl())
6928	CompleteMemberSpecialization(NewVD, Previous);
6929
6930	return NewVD;
6931	}
6932
6933	/// Enum describing the %select options in diag::warn_decl_shadow.
6934	enum ShadowedDeclKind {
6935	SDK_Local,
6936	SDK_Global,
6937	SDK_StaticMember,
6938	SDK_Field,
6939	SDK_Typedef,
6940	SDK_Using
6941	};
6942
6943	/// Determine what kind of declaration we're shadowing.
6944	static ShadowedDeclKind computeShadowedDeclKind(const NamedDecl *ShadowedDecl,
6945	const DeclContext *OldDC) {
6946	if (isa<TypeAliasDecl>(ShadowedDecl))
6947	return SDK_Using;
6948	else if (isa<TypedefDecl>(ShadowedDecl))
6949	return SDK_Typedef;
6950	else if (isa<RecordDecl>(OldDC))
6951	return isa<FieldDecl>(ShadowedDecl) ? SDK_Field : SDK_StaticMember;
6952
6953	return OldDC->isFileContext() ? SDK_Global : SDK_Local;
6954	}
6955
6956	/// Return the location of the capture if the given lambda captures the given
6957	/// variable \p VD, or an invalid source location otherwise.
6958	static SourceLocation getCaptureLocation(const LambdaScopeInfo *LSI,
6959	const VarDecl *VD) {
6960	for (const Capture &Capture : LSI->Captures) {
6961	if (Capture.isVariableCapture() && Capture.getVariable() == VD)
6962	return Capture.getLocation();
6963	}
6964	return SourceLocation();
6965	}
6966
6967	static bool shouldWarnIfShadowedDecl(const DiagnosticsEngine &Diags,
6968	const LookupResult &R) {
6969	// Only diagnose if we're shadowing an unambiguous field or variable.
6970	if (R.getResultKind() != LookupResult::Found)
6971	return false;
6972
6973	// Return false if warning is ignored.
6974	return !Diags.isIgnored(diag::warn_decl_shadow, R.getNameLoc());
6975	}
6976
6977	/// Return the declaration shadowed by the given variable \p D, or null
6978	/// if it doesn't shadow any declaration or shadowing warnings are disabled.
6979	NamedDecl Sema::getShadowedDeclaration(const VarDecl D,
6980	const LookupResult &R) {
6981	if (!shouldWarnIfShadowedDecl(Diags, R))
6982	return nullptr;
6983
6984	// Don't diagnose declarations at file scope.
6985	if (D->hasGlobalStorage())
6986	return nullptr;
6987
6988	NamedDecl *ShadowedDecl = R.getFoundDecl();
6989	return isa<VarDecl>(ShadowedDecl) \|\| isa<FieldDecl>(ShadowedDecl)
6990	? ShadowedDecl
6991	: nullptr;
6992	}
6993
6994	/// Return the declaration shadowed by the given typedef \p D, or null
6995	/// if it doesn't shadow any declaration or shadowing warnings are disabled.
6996	NamedDecl Sema::getShadowedDeclaration(const TypedefNameDecl D,
6997	const LookupResult &R) {
6998	// Don't warn if typedef declaration is part of a class
6999	if (D->getDeclContext()->isRecord())
7000	return nullptr;
7001
7002	if (!shouldWarnIfShadowedDecl(Diags, R))
7003	return nullptr;
7004
7005	NamedDecl *ShadowedDecl = R.getFoundDecl();
7006	return isa<TypedefNameDecl>(ShadowedDecl) ? ShadowedDecl : nullptr;
7007	}
7008
7009	/// Diagnose variable or built-in function shadowing. Implements
7010	/// -Wshadow.
7011	///
7012	/// This method is called whenever a VarDecl is added to a "useful"
7013	/// scope.
7014	///
7015	/// \param ShadowedDecl the declaration that is shadowed by the given variable
7016	/// \param R the lookup of the name
7017	///
7018	void Sema::CheckShadow(NamedDecl D, NamedDecl ShadowedDecl,
7019	const LookupResult &R) {
7020	DeclContext *NewDC = D->getDeclContext();
7021
7022	if (FieldDecl *FD = dyn_cast<FieldDecl>(ShadowedDecl)) {
7023	// Fields are not shadowed by variables in C++ static methods.
7024	if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(NewDC))
7025	if (MD->isStatic())
7026	return;
7027
7028	// Fields shadowed by constructor parameters are a special case. Usually
7029	// the constructor initializes the field with the parameter.
7030	if (isa<CXXConstructorDecl>(NewDC))
7031	if (const auto PVD = dyn_cast<ParmVarDecl>(D)) {
7032	// Remember that this was shadowed so we can either warn about its
7033	// modification or its existence depending on warning settings.
7034	ShadowingDecls.insert({PVD->getCanonicalDecl(), FD});
7035	return;
7036	}
7037	}
7038
7039	if (VarDecl *shadowedVar = dyn_cast<VarDecl>(ShadowedDecl))
7040	if (shadowedVar->isExternC()) {
7041	// For shadowing external vars, make sure that we point to the global
7042	// declaration, not a locally scoped extern declaration.
7043	for (auto I : shadowedVar->redecls())
7044	if (I->isFileVarDecl()) {
7045	ShadowedDecl = I;
7046	break;
7047	}
7048	}
7049
7050	DeclContext *OldDC = ShadowedDecl->getDeclContext()->getRedeclContext();
7051
7052	unsigned WarningDiag = diag::warn_decl_shadow;
7053	SourceLocation CaptureLoc;
7054	if (isa<VarDecl>(D) && isa<VarDecl>(ShadowedDecl) && NewDC &&
7055	isa<CXXMethodDecl>(NewDC)) {
7056	if (const auto *RD = dyn_cast<CXXRecordDecl>(NewDC->getParent())) {
7057	if (RD->isLambda() && OldDC->Encloses(NewDC->getLexicalParent())) {
7058	if (RD->getLambdaCaptureDefault() == LCD_None) {
7059	// Try to avoid warnings for lambdas with an explicit capture list.
7060	const auto *LSI = cast<LambdaScopeInfo>(getCurFunction());
7061	// Warn only when the lambda captures the shadowed decl explicitly.
7062	CaptureLoc = getCaptureLocation(LSI, cast<VarDecl>(ShadowedDecl));
7063	if (CaptureLoc.isInvalid())
7064	WarningDiag = diag::warn_decl_shadow_uncaptured_local;
7065	} else {
7066	// Remember that this was shadowed so we can avoid the warning if the
7067	// shadowed decl isn't captured and the warning settings allow it.
7068	cast<LambdaScopeInfo>(getCurFunction())
7069	->ShadowingDecls.push_back(
7070	{cast<VarDecl>(D), cast<VarDecl>(ShadowedDecl)});
7071	return;
7072	}
7073	}
7074
7075	if (cast<VarDecl>(ShadowedDecl)->hasLocalStorage()) {
7076	// A variable can't shadow a local variable in an enclosing scope, if
7077	// they are separated by a non-capturing declaration context.
7078	for (DeclContext *ParentDC = NewDC;
7079	ParentDC && !ParentDC->Equals(OldDC);
7080	ParentDC = getLambdaAwareParentOfDeclContext(ParentDC)) {
7081	// Only block literals, captured statements, and lambda expressions
7082	// can capture; other scopes don't.
7083	if (!isa<BlockDecl>(ParentDC) && !isa<CapturedDecl>(ParentDC) &&
7084	!isLambdaCallOperator(ParentDC)) {
7085	return;
7086	}
7087	}
7088	}
7089	}
7090	}
7091
7092	// Only warn about certain kinds of shadowing for class members.
7093	if (NewDC && NewDC->isRecord()) {
7094	// In particular, don't warn about shadowing non-class members.
7095	if (!OldDC->isRecord())
7096	return;
7097
7098	// TODO: should we warn about static data members shadowing
7099	// static data members from base classes?
7100
7101	// TODO: don't diagnose for inaccessible shadowed members.
7102	// This is hard to do perfectly because we might friend the
7103	// shadowing context, but that's just a false negative.
7104	}
7105
7106
7107	DeclarationName Name = R.getLookupName();
7108
7109	// Emit warning and note.
7110	if (getSourceManager().isInSystemMacro(R.getNameLoc()))
7111	return;
7112	ShadowedDeclKind Kind = computeShadowedDeclKind(ShadowedDecl, OldDC);
7113	Diag(R.getNameLoc(), WarningDiag) << Name << Kind << OldDC;
7114	if (!CaptureLoc.isInvalid())
7115	Diag(CaptureLoc, diag::note_var_explicitly_captured_here)
7116	<< Name << /explicitly/ 1;
7117	Diag(ShadowedDecl->getLocation(), diag::note_previous_declaration);
7118	}
7119
7120	/// Diagnose shadowing for variables shadowed in the lambda record \p LambdaRD
7121	/// when these variables are captured by the lambda.
7122	void Sema::DiagnoseShadowingLambdaDecls(const LambdaScopeInfo *LSI) {
7123	for (const auto &Shadow : LSI->ShadowingDecls) {
7124	const VarDecl *ShadowedDecl = Shadow.ShadowedDecl;
7125	// Try to avoid the warning when the shadowed decl isn't captured.
7126	SourceLocation CaptureLoc = getCaptureLocation(LSI, ShadowedDecl);
7127	const DeclContext *OldDC = ShadowedDecl->getDeclContext();
7128	Diag(Shadow.VD->getLocation(), CaptureLoc.isInvalid()
7129	? diag::warn_decl_shadow_uncaptured_local
7130	: diag::warn_decl_shadow)
7131	<< Shadow.VD->getDeclName()
7132	<< computeShadowedDeclKind(ShadowedDecl, OldDC) << OldDC;
7133	if (!CaptureLoc.isInvalid())
7134	Diag(CaptureLoc, diag::note_var_explicitly_captured_here)
7135	<< Shadow.VD->getDeclName() << /explicitly/ 0;
7136	Diag(ShadowedDecl->getLocation(), diag::note_previous_declaration);
7137	}
7138	}
7139
7140	/// Check -Wshadow without the advantage of a previous lookup.
7141	void Sema::CheckShadow(Scope S, VarDecl D) {
7142	if (Diags.isIgnored(diag::warn_decl_shadow, D->getLocation()))
7143	return;
7144
7145	LookupResult R(*this, D->getDeclName(), D->getLocation(),
7146	Sema::LookupOrdinaryName, Sema::ForVisibleRedeclaration);
7147	LookupName(R, S);
7148	if (NamedDecl *ShadowedDecl = getShadowedDeclaration(D, R))
7149	CheckShadow(D, ShadowedDecl, R);
7150	}
7151
7152	/// Check if 'E', which is an expression that is about to be modified, refers
7153	/// to a constructor parameter that shadows a field.
7154	void Sema::CheckShadowingDeclModification(Expr *E, SourceLocation Loc) {
7155	// Quickly ignore expressions that can't be shadowing ctor parameters.
7156	if (!getLangOpts().CPlusPlus \|\| ShadowingDecls.empty())
7157	return;
7158	E = E->IgnoreParenImpCasts();
7159	auto *DRE = dyn_cast<DeclRefExpr>(E);
7160	if (!DRE)
7161	return;
7162	const NamedDecl *D = cast<NamedDecl>(DRE->getDecl()->getCanonicalDecl());
7163	auto I = ShadowingDecls.find(D);
7164	if (I == ShadowingDecls.end())
7165	return;
7166	const NamedDecl *ShadowedDecl = I->second;
7167	const DeclContext *OldDC = ShadowedDecl->getDeclContext();
7168	Diag(Loc, diag::warn_modifying_shadowing_decl) << D << OldDC;
7169	Diag(D->getLocation(), diag::note_var_declared_here) << D;
7170	Diag(ShadowedDecl->getLocation(), diag::note_previous_declaration);
7171
7172	// Avoid issuing multiple warnings about the same decl.
7173	ShadowingDecls.erase(I);
7174	}
7175
7176	/// Check for conflict between this global or extern "C" declaration and
7177	/// previous global or extern "C" declarations. This is only used in C++.
7178	template<typename T>
7179	static bool checkGlobalOrExternCConflict(
7180	Sema &S, const T *ND, bool IsGlobal, LookupResult &Previous) {
7181	assert(S.getLangOpts().CPlusPlus && "only C++ has extern \"C\"")((S.getLangOpts().CPlusPlus && "only C++ has extern \"C\"" ) ? static_cast<void> (0) : __assert_fail ("S.getLangOpts().CPlusPlus && \"only C++ has extern \\\"C\\\"\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 7181, __PRETTY_FUNCTION__));
7182	NamedDecl *Prev = S.findLocallyScopedExternCDecl(ND->getDeclName());
7183
7184	if (!Prev && IsGlobal && !isIncompleteDeclExternC(S, ND)) {
7185	// The common case: this global doesn't conflict with any extern "C"
7186	// declaration.
7187	return false;
7188	}
7189
7190	if (Prev) {
7191	if (!IsGlobal \|\| isIncompleteDeclExternC(S, ND)) {
7192	// Both the old and new declarations have C language linkage. This is a
7193	// redeclaration.
7194	Previous.clear();
7195	Previous.addDecl(Prev);
7196	return true;
7197	}
7198
7199	// This is a global, non-extern "C" declaration, and there is a previous
7200	// non-global extern "C" declaration. Diagnose if this is a variable
7201	// declaration.
7202	if (!isa<VarDecl>(ND))
7203	return false;
7204	} else {
7205	// The declaration is extern "C". Check for any declaration in the
7206	// translation unit which might conflict.
7207	if (IsGlobal) {
7208	// We have already performed the lookup into the translation unit.
7209	IsGlobal = false;
7210	for (LookupResult::iterator I = Previous.begin(), E = Previous.end();
7211	I != E; ++I) {
7212	if (isa<VarDecl>(*I)) {
7213	Prev = *I;
7214	break;
7215	}
7216	}
7217	} else {
7218	DeclContext::lookup_result R =
7219	S.Context.getTranslationUnitDecl()->lookup(ND->getDeclName());
7220	for (DeclContext::lookup_result::iterator I = R.begin(), E = R.end();
7221	I != E; ++I) {
7222	if (isa<VarDecl>(*I)) {
7223	Prev = *I;
7224	break;
7225	}
7226	// FIXME: If we have any other entity with this name in global scope,
7227	// the declaration is ill-formed, but that is a defect: it breaks the
7228	// 'stat' hack, for instance. Only variables can have mangled name
7229	// clashes with extern "C" declarations, so only they deserve a
7230	// diagnostic.
7231	}
7232	}
7233
7234	if (!Prev)
7235	return false;
7236	}
7237
7238	// Use the first declaration's location to ensure we point at something which
7239	// is lexically inside an extern "C" linkage-spec.
7240	assert(Prev && "should have found a previous declaration to diagnose")((Prev && "should have found a previous declaration to diagnose" ) ? static_cast<void> (0) : __assert_fail ("Prev && \"should have found a previous declaration to diagnose\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 7240, __PRETTY_FUNCTION__));
7241	if (FunctionDecl *FD = dyn_cast<FunctionDecl>(Prev))
7242	Prev = FD->getFirstDecl();
7243	else
7244	Prev = cast<VarDecl>(Prev)->getFirstDecl();
7245
7246	S.Diag(ND->getLocation(), diag::err_extern_c_global_conflict)
7247	<< IsGlobal << ND;
7248	S.Diag(Prev->getLocation(), diag::note_extern_c_global_conflict)
7249	<< IsGlobal;
7250	return false;
7251	}
7252
7253	/// Apply special rules for handling extern "C" declarations. Returns \c true
7254	/// if we have found that this is a redeclaration of some prior entity.
7255	///
7256	/// Per C++ [dcl.link]p6:
7257	/// Two declarations [for a function or variable] with C language linkage
7258	/// with the same name that appear in different scopes refer to the same
7259	/// [entity]. An entity with C language linkage shall not be declared with
7260	/// the same name as an entity in global scope.
7261	template<typename T>
7262	static bool checkForConflictWithNonVisibleExternC(Sema &S, const T *ND,
7263	LookupResult &Previous) {
7264	if (!S.getLangOpts().CPlusPlus) {
7265	// In C, when declaring a global variable, look for a corresponding 'extern'
7266	// variable declared in function scope. We don't need this in C++, because
7267	// we find local extern decls in the surrounding file-scope DeclContext.
7268	if (ND->getDeclContext()->getRedeclContext()->isTranslationUnit()) {
7269	if (NamedDecl *Prev = S.findLocallyScopedExternCDecl(ND->getDeclName())) {
7270	Previous.clear();
7271	Previous.addDecl(Prev);
7272	return true;
7273	}
7274	}
7275	return false;
7276	}
7277
7278	// A declaration in the translation unit can conflict with an extern "C"
7279	// declaration.
7280	if (ND->getDeclContext()->getRedeclContext()->isTranslationUnit())
7281	return checkGlobalOrExternCConflict(S, ND, /IsGlobal/true, Previous);
7282
7283	// An extern "C" declaration can conflict with a declaration in the
7284	// translation unit or can be a redeclaration of an extern "C" declaration
7285	// in another scope.
7286	if (isIncompleteDeclExternC(S,ND))
7287	return checkGlobalOrExternCConflict(S, ND, /IsGlobal/false, Previous);
7288
7289	// Neither global nor extern "C": nothing to do.
7290	return false;
7291	}
7292
7293	void Sema::CheckVariableDeclarationType(VarDecl *NewVD) {
7294	// If the decl is already known invalid, don't check it.
7295	if (NewVD->isInvalidDecl())
7296	return;
7297
7298	QualType T = NewVD->getType();
7299
7300	// Defer checking an 'auto' type until its initializer is attached.
7301	if (T->isUndeducedType())
7302	return;
7303
7304	if (NewVD->hasAttrs())
7305	CheckAlignasUnderalignment(NewVD);
7306
7307	if (T->isObjCObjectType()) {
7308	Diag(NewVD->getLocation(), diag::err_statically_allocated_object)
7309	<< FixItHint::CreateInsertion(NewVD->getLocation(), "*");
7310	T = Context.getObjCObjectPointerType(T);
7311	NewVD->setType(T);
7312	}
7313
7314	// Emit an error if an address space was applied to decl with local storage.
7315	// This includes arrays of objects with address space qualifiers, but not
7316	// automatic variables that point to other address spaces.
7317	// ISO/IEC TR 18037 S5.1.2
7318	if (!getLangOpts().OpenCL && NewVD->hasLocalStorage() &&
7319	T.getAddressSpace() != LangAS::Default) {
7320	Diag(NewVD->getLocation(), diag::err_as_qualified_auto_decl) << 0;
7321	NewVD->setInvalidDecl();
7322	return;
7323	}
7324
7325	// OpenCL v1.2 s6.8 - The static qualifier is valid only in program
7326	// scope.
7327	if (getLangOpts().OpenCLVersion == 120 &&
7328	!getOpenCLOptions().isEnabled("cl_clang_storage_class_specifiers") &&
7329	NewVD->isStaticLocal()) {
7330	Diag(NewVD->getLocation(), diag::err_static_function_scope);
7331	NewVD->setInvalidDecl();
7332	return;
7333	}
7334
7335	if (getLangOpts().OpenCL) {
7336	// OpenCL v2.0 s6.12.5 - The __block storage type is not supported.
7337	if (NewVD->hasAttr<BlocksAttr>()) {
7338	Diag(NewVD->getLocation(), diag::err_opencl_block_storage_type);
7339	return;
7340	}
7341
7342	if (T->isBlockPointerType()) {
7343	// OpenCL v2.0 s6.12.5 - Any block declaration must be const qualified and
7344	// can't use 'extern' storage class.
7345	if (!T.isConstQualified()) {
7346	Diag(NewVD->getLocation(), diag::err_opencl_invalid_block_declaration)
7347	<< 0 /const/;
7348	NewVD->setInvalidDecl();
7349	return;
7350	}
7351	if (NewVD->hasExternalStorage()) {
7352	Diag(NewVD->getLocation(), diag::err_opencl_extern_block_declaration);
7353	NewVD->setInvalidDecl();
7354	return;
7355	}
7356	}
7357	// OpenCL C v1.2 s6.5 - All program scope variables must be declared in the
7358	// __constant address space.
7359	// OpenCL C v2.0 s6.5.1 - Variables defined at program scope and static
7360	// variables inside a function can also be declared in the global
7361	// address space.
7362	// OpenCL C++ v1.0 s2.5 inherits rule from OpenCL C v2.0 and allows local
7363	// address space additionally.
7364	// FIXME: Add local AS for OpenCL C++.
7365	if (NewVD->isFileVarDecl() \|\| NewVD->isStaticLocal() \|\|
7366	NewVD->hasExternalStorage()) {
7367	if (!T->isSamplerT() &&
7368	!(T.getAddressSpace() == LangAS::opencl_constant \|\|
7369	(T.getAddressSpace() == LangAS::opencl_global &&
7370	(getLangOpts().OpenCLVersion == 200 \|\|
7371	getLangOpts().OpenCLCPlusPlus)))) {
7372	int Scope = NewVD->isStaticLocal() \| NewVD->hasExternalStorage() << 1;
7373	if (getLangOpts().OpenCLVersion == 200 \|\| getLangOpts().OpenCLCPlusPlus)
7374	Diag(NewVD->getLocation(), diag::err_opencl_global_invalid_addr_space)
7375	<< Scope << "global or constant";
7376	else
7377	Diag(NewVD->getLocation(), diag::err_opencl_global_invalid_addr_space)
7378	<< Scope << "constant";
7379	NewVD->setInvalidDecl();
7380	return;
7381	}
7382	} else {
7383	if (T.getAddressSpace() == LangAS::opencl_global) {
7384	Diag(NewVD->getLocation(), diag::err_opencl_function_variable)
7385	<< 1 /is any function/ << "global";
7386	NewVD->setInvalidDecl();
7387	return;
7388	}
7389	if (T.getAddressSpace() == LangAS::opencl_constant \|\|
7390	T.getAddressSpace() == LangAS::opencl_local) {
7391	FunctionDecl *FD = getCurFunctionDecl();
7392	// OpenCL v1.1 s6.5.2 and s6.5.3: no local or constant variables
7393	// in functions.
7394	if (FD && !FD->hasAttr<OpenCLKernelAttr>()) {
7395	if (T.getAddressSpace() == LangAS::opencl_constant)
7396	Diag(NewVD->getLocation(), diag::err_opencl_function_variable)
7397	<< 0 /non-kernel only/ << "constant";
7398	else
7399	Diag(NewVD->getLocation(), diag::err_opencl_function_variable)
7400	<< 0 /non-kernel only/ << "local";
7401	NewVD->setInvalidDecl();
7402	return;
7403	}
7404	// OpenCL v2.0 s6.5.2 and s6.5.3: local and constant variables must be
7405	// in the outermost scope of a kernel function.
7406	if (FD && FD->hasAttr<OpenCLKernelAttr>()) {
7407	if (!getCurScope()->isFunctionScope()) {
7408	if (T.getAddressSpace() == LangAS::opencl_constant)
7409	Diag(NewVD->getLocation(), diag::err_opencl_addrspace_scope)
7410	<< "constant";
7411	else
7412	Diag(NewVD->getLocation(), diag::err_opencl_addrspace_scope)
7413	<< "local";
7414	NewVD->setInvalidDecl();
7415	return;
7416	}
7417	}
7418	} else if (T.getAddressSpace() != LangAS::opencl_private) {
7419	// Do not allow other address spaces on automatic variable.
7420	Diag(NewVD->getLocation(), diag::err_as_qualified_auto_decl) << 1;
7421	NewVD->setInvalidDecl();
7422	return;
7423	}
7424	}
7425	}
7426
7427	if (NewVD->hasLocalStorage() && T.isObjCGCWeak()
7428	&& !NewVD->hasAttr<BlocksAttr>()) {
7429	if (getLangOpts().getGC() != LangOptions::NonGC)
7430	Diag(NewVD->getLocation(), diag::warn_gc_attribute_weak_on_local);
7431	else {
7432	assert(!getLangOpts().ObjCAutoRefCount)((!getLangOpts().ObjCAutoRefCount) ? static_cast<void> ( 0) : __assert_fail ("!getLangOpts().ObjCAutoRefCount", "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 7432, __PRETTY_FUNCTION__));
7433	Diag(NewVD->getLocation(), diag::warn_attribute_weak_on_local);
7434	}
7435	}
7436
7437	bool isVM = T->isVariablyModifiedType();
7438	if (isVM \|\| NewVD->hasAttr<CleanupAttr>() \|\|
7439	NewVD->hasAttr<BlocksAttr>())
7440	setFunctionHasBranchProtectedScope();
7441
7442	if ((isVM && NewVD->hasLinkage()) \|\|
7443	(T->isVariableArrayType() && NewVD->hasGlobalStorage())) {
7444	bool SizeIsNegative;
7445	llvm::APSInt Oversized;
7446	TypeSourceInfo *FixedTInfo = TryToFixInvalidVariablyModifiedTypeSourceInfo(
7447	NewVD->getTypeSourceInfo(), Context, SizeIsNegative, Oversized);
7448	QualType FixedT;
7449	if (FixedTInfo && T == NewVD->getTypeSourceInfo()->getType())
7450	FixedT = FixedTInfo->getType();
7451	else if (FixedTInfo) {
7452	// Type and type-as-written are canonically different. We need to fix up
7453	// both types separately.
7454	FixedT = TryToFixInvalidVariablyModifiedType(T, Context, SizeIsNegative,
7455	Oversized);
7456	}
7457	if ((!FixedTInfo \|\| FixedT.isNull()) && T->isVariableArrayType()) {
7458	const VariableArrayType *VAT = Context.getAsVariableArrayType(T);
7459	// FIXME: This won't give the correct result for
7460	// int a[10][n];
7461	SourceRange SizeRange = VAT->getSizeExpr()->getSourceRange();
7462
7463	if (NewVD->isFileVarDecl())
7464	Diag(NewVD->getLocation(), diag::err_vla_decl_in_file_scope)
7465	<< SizeRange;
7466	else if (NewVD->isStaticLocal())
7467	Diag(NewVD->getLocation(), diag::err_vla_decl_has_static_storage)
7468	<< SizeRange;
7469	else
7470	Diag(NewVD->getLocation(), diag::err_vla_decl_has_extern_linkage)
7471	<< SizeRange;
7472	NewVD->setInvalidDecl();
7473	return;
7474	}
7475
7476	if (!FixedTInfo) {
7477	if (NewVD->isFileVarDecl())
7478	Diag(NewVD->getLocation(), diag::err_vm_decl_in_file_scope);
7479	else
7480	Diag(NewVD->getLocation(), diag::err_vm_decl_has_extern_linkage);
7481	NewVD->setInvalidDecl();
7482	return;
7483	}
7484
7485	Diag(NewVD->getLocation(), diag::warn_illegal_constant_array_size);
7486	NewVD->setType(FixedT);
7487	NewVD->setTypeSourceInfo(FixedTInfo);
7488	}
7489
7490	if (T->isVoidType()) {
7491	// C++98 [dcl.stc]p5: The extern specifier can be applied only to the names
7492	// of objects and functions.
7493	if (NewVD->isThisDeclarationADefinition() \|\| getLangOpts().CPlusPlus) {
7494	Diag(NewVD->getLocation(), diag::err_typecheck_decl_incomplete_type)
7495	<< T;
7496	NewVD->setInvalidDecl();
7497	return;
7498	}
7499	}
7500
7501	if (!NewVD->hasLocalStorage() && NewVD->hasAttr<BlocksAttr>()) {
7502	Diag(NewVD->getLocation(), diag::err_block_on_nonlocal);
7503	NewVD->setInvalidDecl();
7504	return;
7505	}
7506
7507	if (isVM && NewVD->hasAttr<BlocksAttr>()) {
7508	Diag(NewVD->getLocation(), diag::err_block_on_vm);
7509	NewVD->setInvalidDecl();
7510	return;
7511	}
7512
7513	if (NewVD->isConstexpr() && !T->isDependentType() &&
7514	RequireLiteralType(NewVD->getLocation(), T,
7515	diag::err_constexpr_var_non_literal)) {
7516	NewVD->setInvalidDecl();
7517	return;
7518	}
7519	}
7520
7521	/// Perform semantic checking on a newly-created variable
7522	/// declaration.
7523	///
7524	/// This routine performs all of the type-checking required for a
7525	/// variable declaration once it has been built. It is used both to
7526	/// check variables after they have been parsed and their declarators
7527	/// have been translated into a declaration, and to check variables
7528	/// that have been instantiated from a template.
7529	///
7530	/// Sets NewVD->isInvalidDecl() if an error was encountered.
7531	///
7532	/// Returns true if the variable declaration is a redeclaration.
7533	bool Sema::CheckVariableDeclaration(VarDecl *NewVD, LookupResult &Previous) {
7534	CheckVariableDeclarationType(NewVD);
7535
7536	// If the decl is already known invalid, don't check it.
7537	if (NewVD->isInvalidDecl())
7538	return false;
7539
7540	// If we did not find anything by this name, look for a non-visible
7541	// extern "C" declaration with the same name.
7542	if (Previous.empty() &&
7543	checkForConflictWithNonVisibleExternC(*this, NewVD, Previous))
7544	Previous.setShadowed();
7545
7546	if (!Previous.empty()) {
7547	MergeVarDecl(NewVD, Previous);
7548	return true;
7549	}
7550	return false;
7551	}
7552
7553	namespace {
7554	struct FindOverriddenMethod {
7555	Sema *S;
7556	CXXMethodDecl *Method;
7557
7558	/// Member lookup function that determines whether a given C++
7559	/// method overrides a method in a base class, to be used with
7560	/// CXXRecordDecl::lookupInBases().
7561	bool operator()(const CXXBaseSpecifier *Specifier, CXXBasePath &Path) {
7562	RecordDecl *BaseRecord =
7563	Specifier->getType()->getAs<RecordType>()->getDecl();
7564
7565	DeclarationName Name = Method->getDeclName();
7566
7567	// FIXME: Do we care about other names here too?
7568	if (Name.getNameKind() == DeclarationName::CXXDestructorName) {
7569	// We really want to find the base class destructor here.
7570	QualType T = S->Context.getTypeDeclType(BaseRecord);
7571	CanQualType CT = S->Context.getCanonicalType(T);
7572
7573	Name = S->Context.DeclarationNames.getCXXDestructorName(CT);
7574	}
7575
7576	for (Path.Decls = BaseRecord->lookup(Name); !Path.Decls.empty();
7577	Path.Decls = Path.Decls.slice(1)) {
7578	NamedDecl *D = Path.Decls.front();
7579	if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(D)) {
7580	if (MD->isVirtual() && !S->IsOverload(Method, MD, false))
7581	return true;
7582	}
7583	}
7584
7585	return false;
7586	}
7587	};
7588
7589	enum OverrideErrorKind { OEK_All, OEK_NonDeleted, OEK_Deleted };
7590	} // end anonymous namespace
7591
7592	/// Report an error regarding overriding, along with any relevant
7593	/// overridden methods.
7594	///
7595	/// \param DiagID the primary error to report.
7596	/// \param MD the overriding method.
7597	/// \param OEK which overrides to include as notes.
7598	static void ReportOverrides(Sema& S, unsigned DiagID, const CXXMethodDecl *MD,
7599	OverrideErrorKind OEK = OEK_All) {
7600	S.Diag(MD->getLocation(), DiagID) << MD->getDeclName();
7601	for (const CXXMethodDecl *O : MD->overridden_methods()) {
7602	// This check (& the OEK parameter) could be replaced by a predicate, but
7603	// without lambdas that would be overkill. This is still nicer than writing
7604	// out the diag loop 3 times.
7605	if ((OEK == OEK_All) \|\|
7606	(OEK == OEK_NonDeleted && !O->isDeleted()) \|\|
7607	(OEK == OEK_Deleted && O->isDeleted()))
7608	S.Diag(O->getLocation(), diag::note_overridden_virtual_function);
7609	}
7610	}
7611
7612	/// AddOverriddenMethods - See if a method overrides any in the base classes,
7613	/// and if so, check that it's a valid override and remember it.
7614	bool Sema::AddOverriddenMethods(CXXRecordDecl DC, CXXMethodDecl MD) {
7615	// Look for methods in base classes that this method might override.
7616	CXXBasePaths Paths;
7617	FindOverriddenMethod FOM;
7618	FOM.Method = MD;
7619	FOM.S = this;
7620	bool hasDeletedOverridenMethods = false;
7621	bool hasNonDeletedOverridenMethods = false;
7622	bool AddedAny = false;
7623	if (DC->lookupInBases(FOM, Paths)) {
7624	for (auto *I : Paths.found_decls()) {
7625	if (CXXMethodDecl *OldMD = dyn_cast<CXXMethodDecl>(I)) {
7626	MD->addOverriddenMethod(OldMD->getCanonicalDecl());
7627	if (!CheckOverridingFunctionReturnType(MD, OldMD) &&
7628	!CheckOverridingFunctionAttributes(MD, OldMD) &&
7629	!CheckOverridingFunctionExceptionSpec(MD, OldMD) &&
7630	!CheckIfOverriddenFunctionIsMarkedFinal(MD, OldMD)) {
7631	hasDeletedOverridenMethods \|= OldMD->isDeleted();
7632	hasNonDeletedOverridenMethods \|= !OldMD->isDeleted();
7633	AddedAny = true;
7634	}
7635	}
7636	}
7637	}
7638
7639	if (hasDeletedOverridenMethods && !MD->isDeleted()) {
7640	ReportOverrides(*this, diag::err_non_deleted_override, MD, OEK_Deleted);
7641	}
7642	if (hasNonDeletedOverridenMethods && MD->isDeleted()) {
7643	ReportOverrides(*this, diag::err_deleted_override, MD, OEK_NonDeleted);
7644	}
7645
7646	return AddedAny;
7647	}
7648
7649	namespace {
7650	// Struct for holding all of the extra arguments needed by
7651	// DiagnoseInvalidRedeclaration to call Sema::ActOnFunctionDeclarator.
7652	struct ActOnFDArgs {
7653	Scope *S;
7654	Declarator &D;
7655	MultiTemplateParamsArg TemplateParamLists;
7656	bool AddToScope;
7657	};
7658	} // end anonymous namespace
7659
7660	namespace {
7661
7662	// Callback to only accept typo corrections that have a non-zero edit distance.
7663	// Also only accept corrections that have the same parent decl.
7664	class DifferentNameValidatorCCC : public CorrectionCandidateCallback {
7665	public:
7666	DifferentNameValidatorCCC(ASTContext &Context, FunctionDecl *TypoFD,
7667	CXXRecordDecl *Parent)
7668	: Context(Context), OriginalFD(TypoFD),
7669	ExpectedParent(Parent ? Parent->getCanonicalDecl() : nullptr) {}
7670
7671	bool ValidateCandidate(const TypoCorrection &candidate) override {
7672	if (candidate.getEditDistance() == 0)
7673	return false;
7674
7675	SmallVector<unsigned, 1> MismatchedParams;
7676	for (TypoCorrection::const_decl_iterator CDecl = candidate.begin(),
7677	CDeclEnd = candidate.end();
7678	CDecl != CDeclEnd; ++CDecl) {
7679	FunctionDecl FD = dyn_cast<FunctionDecl>(CDecl);
7680
7681	if (FD && !FD->hasBody() &&
7682	hasSimilarParameters(Context, FD, OriginalFD, MismatchedParams)) {
7683	if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) {
7684	CXXRecordDecl *Parent = MD->getParent();
7685	if (Parent && Parent->getCanonicalDecl() == ExpectedParent)
7686	return true;
7687	} else if (!ExpectedParent) {
7688	return true;
7689	}
7690	}
7691	}
7692
7693	return false;
7694	}
7695
7696	private:
7697	ASTContext &Context;
7698	FunctionDecl *OriginalFD;
7699	CXXRecordDecl *ExpectedParent;
7700	};
7701
7702	} // end anonymous namespace
7703
7704	void Sema::MarkTypoCorrectedFunctionDefinition(const NamedDecl *F) {
7705	TypoCorrectedFunctionDefinitions.insert(F);
7706	}
7707
7708	/// Generate diagnostics for an invalid function redeclaration.
7709	///
7710	/// This routine handles generating the diagnostic messages for an invalid
7711	/// function redeclaration, including finding possible similar declarations
7712	/// or performing typo correction if there are no previous declarations with
7713	/// the same name.
7714	///
7715	/// Returns a NamedDecl iff typo correction was performed and substituting in
7716	/// the new declaration name does not cause new errors.
7717	static NamedDecl *DiagnoseInvalidRedeclaration(
7718	Sema &SemaRef, LookupResult &Previous, FunctionDecl *NewFD,
7719	ActOnFDArgs &ExtraArgs, bool IsLocalFriend, Scope *S) {
7720	DeclarationName Name = NewFD->getDeclName();
7721	DeclContext *NewDC = NewFD->getDeclContext();
7722	SmallVector<unsigned, 1> MismatchedParams;
7723	SmallVector<std::pair<FunctionDecl *, unsigned>, 1> NearMatches;
7724	TypoCorrection Correction;
7725	bool IsDefinition = ExtraArgs.D.isFunctionDefinition();
7726	unsigned DiagMsg = IsLocalFriend ? diag::err_no_matching_local_friend
7727	: diag::err_member_decl_does_not_match;
7728	LookupResult Prev(SemaRef, Name, NewFD->getLocation(),
7729	IsLocalFriend ? Sema::LookupLocalFriendName
7730	: Sema::LookupOrdinaryName,
7731	Sema::ForVisibleRedeclaration);
7732
7733	NewFD->setInvalidDecl();
7734	if (IsLocalFriend)
7735	SemaRef.LookupName(Prev, S);
7736	else
7737	SemaRef.LookupQualifiedName(Prev, NewDC);
7738	assert(!Prev.isAmbiguous() &&((!Prev.isAmbiguous() && "Cannot have an ambiguity in previous-declaration lookup" ) ? static_cast<void> (0) : __assert_fail ("!Prev.isAmbiguous() && \"Cannot have an ambiguity in previous-declaration lookup\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 7739, __PRETTY_FUNCTION__))
7739	"Cannot have an ambiguity in previous-declaration lookup")((!Prev.isAmbiguous() && "Cannot have an ambiguity in previous-declaration lookup" ) ? static_cast<void> (0) : __assert_fail ("!Prev.isAmbiguous() && \"Cannot have an ambiguity in previous-declaration lookup\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 7739, __PRETTY_FUNCTION__));
7740	CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(NewFD);
7741	if (!Prev.empty()) {
7742	for (LookupResult::iterator Func = Prev.begin(), FuncEnd = Prev.end();
7743	Func != FuncEnd; ++Func) {
7744	FunctionDecl FD = dyn_cast<FunctionDecl>(Func);
7745	if (FD &&
7746	hasSimilarParameters(SemaRef.Context, FD, NewFD, MismatchedParams)) {
7747	// Add 1 to the index so that 0 can mean the mismatch didn't
7748	// involve a parameter
7749	unsigned ParamNum =
7750	MismatchedParams.empty() ? 0 : MismatchedParams.front() + 1;
7751	NearMatches.push_back(std::make_pair(FD, ParamNum));
7752	}
7753	}
7754	// If the qualified name lookup yielded nothing, try typo correction
7755	} else if ((Correction = SemaRef.CorrectTypo(
7756	Prev.getLookupNameInfo(), Prev.getLookupKind(), S,
7757	&ExtraArgs.D.getCXXScopeSpec(),
7758	llvm::make_unique<DifferentNameValidatorCCC>(
7759	SemaRef.Context, NewFD, MD ? MD->getParent() : nullptr),
7760	Sema::CTK_ErrorRecovery, IsLocalFriend ? nullptr : NewDC))) {
7761	// Set up everything for the call to ActOnFunctionDeclarator
7762	ExtraArgs.D.SetIdentifier(Correction.getCorrectionAsIdentifierInfo(),
7763	ExtraArgs.D.getIdentifierLoc());
7764	Previous.clear();
7765	Previous.setLookupName(Correction.getCorrection());
7766	for (TypoCorrection::decl_iterator CDecl = Correction.begin(),
7767	CDeclEnd = Correction.end();
7768	CDecl != CDeclEnd; ++CDecl) {
7769	FunctionDecl FD = dyn_cast<FunctionDecl>(CDecl);
7770	if (FD && !FD->hasBody() &&
7771	hasSimilarParameters(SemaRef.Context, FD, NewFD, MismatchedParams)) {
7772	Previous.addDecl(FD);
7773	}
7774	}
7775	bool wasRedeclaration = ExtraArgs.D.isRedeclaration();
7776
7777	NamedDecl *Result;
7778	// Retry building the function declaration with the new previous
7779	// declarations, and with errors suppressed.
7780	{
7781	// Trap errors.
7782	Sema::SFINAETrap Trap(SemaRef);
7783
7784	// TODO: Refactor ActOnFunctionDeclarator so that we can call only the
7785	// pieces need to verify the typo-corrected C++ declaration and hopefully
7786	// eliminate the need for the parameter pack ExtraArgs.
7787	Result = SemaRef.ActOnFunctionDeclarator(
7788	ExtraArgs.S, ExtraArgs.D,
7789	Correction.getCorrectionDecl()->getDeclContext(),
7790	NewFD->getTypeSourceInfo(), Previous, ExtraArgs.TemplateParamLists,
7791	ExtraArgs.AddToScope);
7792
7793	if (Trap.hasErrorOccurred())
7794	Result = nullptr;
7795	}
7796
7797	if (Result) {
7798	// Determine which correction we picked.
7799	Decl *Canonical = Result->getCanonicalDecl();
7800	for (LookupResult::iterator I = Previous.begin(), E = Previous.end();
7801	I != E; ++I)
7802	if ((*I)->getCanonicalDecl() == Canonical)
7803	Correction.setCorrectionDecl(*I);
7804
7805	// Let Sema know about the correction.
7806	SemaRef.MarkTypoCorrectedFunctionDefinition(Result);
7807	SemaRef.diagnoseTypo(
7808	Correction,
7809	SemaRef.PDiag(IsLocalFriend
7810	? diag::err_no_matching_local_friend_suggest
7811	: diag::err_member_decl_does_not_match_suggest)
7812	<< Name << NewDC << IsDefinition);
7813	return Result;
7814	}
7815
7816	// Pretend the typo correction never occurred
7817	ExtraArgs.D.SetIdentifier(Name.getAsIdentifierInfo(),
7818	ExtraArgs.D.getIdentifierLoc());
7819	ExtraArgs.D.setRedeclaration(wasRedeclaration);
7820	Previous.clear();
7821	Previous.setLookupName(Name);
7822	}
7823
7824	SemaRef.Diag(NewFD->getLocation(), DiagMsg)
7825	<< Name << NewDC << IsDefinition << NewFD->getLocation();
7826
7827	bool NewFDisConst = false;
7828	if (CXXMethodDecl *NewMD = dyn_cast<CXXMethodDecl>(NewFD))
7829	NewFDisConst = NewMD->isConst();
7830
7831	for (SmallVectorImpl<std::pair<FunctionDecl *, unsigned> >::iterator
7832	NearMatch = NearMatches.begin(), NearMatchEnd = NearMatches.end();
7833	NearMatch != NearMatchEnd; ++NearMatch) {
7834	FunctionDecl *FD = NearMatch->first;
7835	CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD);
7836	bool FDisConst = MD && MD->isConst();
7837	bool IsMember = MD \|\| !IsLocalFriend;
7838
7839	// FIXME: These notes are poorly worded for the local friend case.
7840	if (unsigned Idx = NearMatch->second) {
7841	ParmVarDecl *FDParam = FD->getParamDecl(Idx-1);
7842	SourceLocation Loc = FDParam->getTypeSpecStartLoc();
7843	if (Loc.isInvalid()) Loc = FD->getLocation();
7844	SemaRef.Diag(Loc, IsMember ? diag::note_member_def_close_param_match
7845	: diag::note_local_decl_close_param_match)
7846	<< Idx << FDParam->getType()
7847	<< NewFD->getParamDecl(Idx - 1)->getType();
7848	} else if (FDisConst != NewFDisConst) {
7849	SemaRef.Diag(FD->getLocation(), diag::note_member_def_close_const_match)
7850	<< NewFDisConst << FD->getSourceRange().getEnd();
7851	} else
7852	SemaRef.Diag(FD->getLocation(),
7853	IsMember ? diag::note_member_def_close_match
7854	: diag::note_local_decl_close_match);
7855	}
7856	return nullptr;
7857	}
7858
7859	static StorageClass getFunctionStorageClass(Sema &SemaRef, Declarator &D) {
7860	switch (D.getDeclSpec().getStorageClassSpec()) {
7861	default: llvm_unreachable("Unknown storage class!")::llvm::llvm_unreachable_internal("Unknown storage class!", "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 7861);
7862	case DeclSpec::SCS_auto:
7863	case DeclSpec::SCS_register:
7864	case DeclSpec::SCS_mutable:
7865	SemaRef.Diag(D.getDeclSpec().getStorageClassSpecLoc(),
7866	diag::err_typecheck_sclass_func);
7867	D.getMutableDeclSpec().ClearStorageClassSpecs();
7868	D.setInvalidType();
7869	break;
7870	case DeclSpec::SCS_unspecified: break;
7871	case DeclSpec::SCS_extern:
7872	if (D.getDeclSpec().isExternInLinkageSpec())
7873	return SC_None;
7874	return SC_Extern;
7875	case DeclSpec::SCS_static: {
7876	if (SemaRef.CurContext->getRedeclContext()->isFunctionOrMethod()) {
7877	// C99 6.7.1p5:
7878	// The declaration of an identifier for a function that has
7879	// block scope shall have no explicit storage-class specifier
7880	// other than extern
7881	// See also (C++ [dcl.stc]p4).
7882	SemaRef.Diag(D.getDeclSpec().getStorageClassSpecLoc(),
7883	diag::err_static_block_func);
7884	break;
7885	} else
7886	return SC_Static;
7887	}
7888	case DeclSpec::SCS_private_extern: return SC_PrivateExtern;
7889	}
7890
7891	// No explicit storage class has already been returned
7892	return SC_None;
7893	}
7894
7895	static FunctionDecl* CreateNewFunctionDecl(Sema &SemaRef, Declarator &D,
7896	DeclContext *DC, QualType &R,
7897	TypeSourceInfo *TInfo,
7898	StorageClass SC,
7899	bool &IsVirtualOkay) {
7900	DeclarationNameInfo NameInfo = SemaRef.GetNameForDeclarator(D);
7901	DeclarationName Name = NameInfo.getName();
7902
7903	FunctionDecl *NewFD = nullptr;
7904	bool isInline = D.getDeclSpec().isInlineSpecified();
7905
7906	if (!SemaRef.getLangOpts().CPlusPlus) {
7907	// Determine whether the function was written with a
7908	// prototype. This true when:
7909	// - there is a prototype in the declarator, or
7910	// - the type R of the function is some kind of typedef or other non-
7911	// attributed reference to a type name (which eventually refers to a
7912	// function type).
7913	bool HasPrototype =
7914	(D.isFunctionDeclarator() && D.getFunctionTypeInfo().hasPrototype) \|\|
7915	(!R->getAsAdjusted<FunctionType>() && R->isFunctionProtoType());
7916
7917	NewFD = FunctionDecl::Create(SemaRef.Context, DC, D.getBeginLoc(), NameInfo,
7918	R, TInfo, SC, isInline, HasPrototype, false);
7919	if (D.isInvalidType())
7920	NewFD->setInvalidDecl();
7921
7922	return NewFD;
7923	}
7924
7925	bool isExplicit = D.getDeclSpec().isExplicitSpecified();
7926	bool isConstexpr = D.getDeclSpec().isConstexprSpecified();
7927
7928	// Check that the return type is not an abstract class type.
7929	// For record types, this is done by the AbstractClassUsageDiagnoser once
7930	// the class has been completely parsed.
7931	if (!DC->isRecord() &&
7932	SemaRef.RequireNonAbstractType(
7933	D.getIdentifierLoc(), R->getAs<FunctionType>()->getReturnType(),
7934	diag::err_abstract_type_in_decl, SemaRef.AbstractReturnType))
7935	D.setInvalidType();
7936
7937	if (Name.getNameKind() == DeclarationName::CXXConstructorName) {
7938	// This is a C++ constructor declaration.
7939	assert(DC->isRecord() &&((DC->isRecord() && "Constructors can only be declared in a member context" ) ? static_cast<void> (0) : __assert_fail ("DC->isRecord() && \"Constructors can only be declared in a member context\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 7940, __PRETTY_FUNCTION__))
7940	"Constructors can only be declared in a member context")((DC->isRecord() && "Constructors can only be declared in a member context" ) ? static_cast<void> (0) : __assert_fail ("DC->isRecord() && \"Constructors can only be declared in a member context\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 7940, __PRETTY_FUNCTION__));
7941
7942	R = SemaRef.CheckConstructorDeclarator(D, R, SC);
7943	return CXXConstructorDecl::Create(
7944	SemaRef.Context, cast<CXXRecordDecl>(DC), D.getBeginLoc(), NameInfo, R,
7945	TInfo, isExplicit, isInline,
7946	/isImplicitlyDeclared=/false, isConstexpr);
7947
7948	} else if (Name.getNameKind() == DeclarationName::CXXDestructorName) {
7949	// This is a C++ destructor declaration.
7950	if (DC->isRecord()) {
7951	R = SemaRef.CheckDestructorDeclarator(D, R, SC);
7952	CXXRecordDecl *Record = cast<CXXRecordDecl>(DC);
7953	CXXDestructorDecl *NewDD =
7954	CXXDestructorDecl::Create(SemaRef.Context, Record, D.getBeginLoc(),
7955	NameInfo, R, TInfo, isInline,
7956	/isImplicitlyDeclared=/false);
7957
7958	// If the destructor needs an implicit exception specification, set it
7959	// now. FIXME: It'd be nice to be able to create the right type to start
7960	// with, but the type needs to reference the destructor declaration.
7961	if (SemaRef.getLangOpts().CPlusPlus11)
7962	SemaRef.AdjustDestructorExceptionSpec(NewDD);
7963
7964	IsVirtualOkay = true;
7965	return NewDD;
7966
7967	} else {
7968	SemaRef.Diag(D.getIdentifierLoc(), diag::err_destructor_not_member);
7969	D.setInvalidType();
7970
7971	// Create a FunctionDecl to satisfy the function definition parsing
7972	// code path.
7973	return FunctionDecl::Create(SemaRef.Context, DC, D.getBeginLoc(),
7974	D.getIdentifierLoc(), Name, R, TInfo, SC,
7975	isInline,
7976	/hasPrototype=/true, isConstexpr);
7977	}
7978
7979	} else if (Name.getNameKind() == DeclarationName::CXXConversionFunctionName) {
7980	if (!DC->isRecord()) {
7981	SemaRef.Diag(D.getIdentifierLoc(),
7982	diag::err_conv_function_not_member);
7983	return nullptr;
7984	}
7985
7986	SemaRef.CheckConversionDeclarator(D, R, SC);
7987	IsVirtualOkay = true;
7988	return CXXConversionDecl::Create(
7989	SemaRef.Context, cast<CXXRecordDecl>(DC), D.getBeginLoc(), NameInfo, R,
7990	TInfo, isInline, isExplicit, isConstexpr, SourceLocation());
7991
7992	} else if (Name.getNameKind() == DeclarationName::CXXDeductionGuideName) {
7993	SemaRef.CheckDeductionGuideDeclarator(D, R, SC);
7994
7995	return CXXDeductionGuideDecl::Create(SemaRef.Context, DC, D.getBeginLoc(),
7996	isExplicit, NameInfo, R, TInfo,
7997	D.getEndLoc());
7998	} else if (DC->isRecord()) {
7999	// If the name of the function is the same as the name of the record,
8000	// then this must be an invalid constructor that has a return type.
8001	// (The parser checks for a return type and makes the declarator a
8002	// constructor if it has no return type).
8003	if (Name.getAsIdentifierInfo() &&
8004	Name.getAsIdentifierInfo() == cast<CXXRecordDecl>(DC)->getIdentifier()){
8005	SemaRef.Diag(D.getIdentifierLoc(), diag::err_constructor_return_type)
8006	<< SourceRange(D.getDeclSpec().getTypeSpecTypeLoc())
8007	<< SourceRange(D.getIdentifierLoc());
8008	return nullptr;
8009	}
8010
8011	// This is a C++ method declaration.
8012	CXXMethodDecl *Ret = CXXMethodDecl::Create(
8013	SemaRef.Context, cast<CXXRecordDecl>(DC), D.getBeginLoc(), NameInfo, R,
8014	TInfo, SC, isInline, isConstexpr, SourceLocation());
8015	IsVirtualOkay = !Ret->isStatic();
8016	return Ret;
8017	} else {
8018	bool isFriend =
8019	SemaRef.getLangOpts().CPlusPlus && D.getDeclSpec().isFriendSpecified();
8020	if (!isFriend && SemaRef.CurContext->isRecord())
8021	return nullptr;
8022
8023	// Determine whether the function was written with a
8024	// prototype. This true when:
8025	// - we're in C++ (where every function has a prototype),
8026	return FunctionDecl::Create(SemaRef.Context, DC, D.getBeginLoc(), NameInfo,
8027	R, TInfo, SC, isInline, true /HasPrototype/,
8028	isConstexpr);
8029	}
8030	}
8031
8032	enum OpenCLParamType {
8033	ValidKernelParam,
8034	PtrPtrKernelParam,
8035	PtrKernelParam,
8036	InvalidAddrSpacePtrKernelParam,
8037	InvalidKernelParam,
8038	RecordKernelParam
8039	};
8040
8041	static bool isOpenCLSizeDependentType(ASTContext &C, QualType Ty) {
8042	// Size dependent types are just typedefs to normal integer types
8043	// (e.g. unsigned long), so we cannot distinguish them from other typedefs to
8044	// integers other than by their names.
8045	StringRef SizeTypeNames[] = {"size_t", "intptr_t", "uintptr_t", "ptrdiff_t"};
8046
8047	// Remove typedefs one by one until we reach a typedef
8048	// for a size dependent type.
8049	QualType DesugaredTy = Ty;
8050	do {
8051	ArrayRef<StringRef> Names(SizeTypeNames);
8052	auto Match =
8053	std::find(Names.begin(), Names.end(), DesugaredTy.getAsString());
8054	if (Names.end() != Match)
8055	return true;
8056
8057	Ty = DesugaredTy;
8058	DesugaredTy = Ty.getSingleStepDesugaredType(C);
8059	} while (DesugaredTy != Ty);
8060
8061	return false;
8062	}
8063
8064	static OpenCLParamType getOpenCLKernelParameterType(Sema &S, QualType PT) {
8065	if (PT->isPointerType()) {
8066	QualType PointeeType = PT->getPointeeType();
8067	if (PointeeType->isPointerType())
8068	return PtrPtrKernelParam;
8069	if (PointeeType.getAddressSpace() == LangAS::opencl_generic \|\|
8070	PointeeType.getAddressSpace() == LangAS::opencl_private \|\|
8071	PointeeType.getAddressSpace() == LangAS::Default)
8072	return InvalidAddrSpacePtrKernelParam;
8073	return PtrKernelParam;
8074	}
8075
8076	// OpenCL v1.2 s6.9.k:
8077	// Arguments to kernel functions in a program cannot be declared with the
8078	// built-in scalar types bool, half, size_t, ptrdiff_t, intptr_t, and
8079	// uintptr_t or a struct and/or union that contain fields declared to be one
8080	// of these built-in scalar types.
8081	if (isOpenCLSizeDependentType(S.getASTContext(), PT))
8082	return InvalidKernelParam;
8083
8084	if (PT->isImageType())
8085	return PtrKernelParam;
8086
8087	if (PT->isBooleanType() \|\| PT->isEventT() \|\| PT->isReserveIDT())
8088	return InvalidKernelParam;
8089
8090	// OpenCL extension spec v1.2 s9.5:
8091	// This extension adds support for half scalar and vector types as built-in
8092	// types that can be used for arithmetic operations, conversions etc.
8093	if (!S.getOpenCLOptions().isEnabled("cl_khr_fp16") && PT->isHalfType())
8094	return InvalidKernelParam;
8095
8096	if (PT->isRecordType())
8097	return RecordKernelParam;
8098
8099	// Look into an array argument to check if it has a forbidden type.
8100	if (PT->isArrayType()) {
8101	const Type *UnderlyingTy = PT->getPointeeOrArrayElementType();
8102	// Call ourself to check an underlying type of an array. Since the
8103	// getPointeeOrArrayElementType returns an innermost type which is not an
8104	// array, this recursive call only happens once.
8105	return getOpenCLKernelParameterType(S, QualType(UnderlyingTy, 0));
8106	}
8107
8108	return ValidKernelParam;
8109	}
8110
8111	static void checkIsValidOpenCLKernelParameter(
8112	Sema &S,
8113	Declarator &D,
8114	ParmVarDecl *Param,
8115	llvm::SmallPtrSetImpl<const Type *> &ValidTypes) {
8116	QualType PT = Param->getType();
8117
8118	// Cache the valid types we encounter to avoid rechecking structs that are
8119	// used again
8120	if (ValidTypes.count(PT.getTypePtr()))
8121	return;
8122
8123	switch (getOpenCLKernelParameterType(S, PT)) {
8124	case PtrPtrKernelParam:
8125	// OpenCL v1.2 s6.9.a:
8126	// A kernel function argument cannot be declared as a
8127	// pointer to a pointer type.
8128	S.Diag(Param->getLocation(), diag::err_opencl_ptrptr_kernel_param);
8129	D.setInvalidType();
8130	return;
8131
8132	case InvalidAddrSpacePtrKernelParam:
8133	// OpenCL v1.0 s6.5:
8134	// __kernel function arguments declared to be a pointer of a type can point
8135	// to one of the following address spaces only : __global, __local or
8136	// __constant.
8137	S.Diag(Param->getLocation(), diag::err_kernel_arg_address_space);
8138	D.setInvalidType();
8139	return;
8140
8141	// OpenCL v1.2 s6.9.k:
8142	// Arguments to kernel functions in a program cannot be declared with the
8143	// built-in scalar types bool, half, size_t, ptrdiff_t, intptr_t, and
8144	// uintptr_t or a struct and/or union that contain fields declared to be
8145	// one of these built-in scalar types.
8146
8147	case InvalidKernelParam:
8148	// OpenCL v1.2 s6.8 n:
8149	// A kernel function argument cannot be declared
8150	// of event_t type.
8151	// Do not diagnose half type since it is diagnosed as invalid argument
8152	// type for any function elsewhere.
8153	if (!PT->isHalfType()) {
8154	S.Diag(Param->getLocation(), diag::err_bad_kernel_param_type) << PT;
8155
8156	// Explain what typedefs are involved.
8157	const TypedefType *Typedef = nullptr;
8158	while ((Typedef = PT->getAs<TypedefType>())) {
8159	SourceLocation Loc = Typedef->getDecl()->getLocation();
8160	// SourceLocation may be invalid for a built-in type.
8161	if (Loc.isValid())
8162	S.Diag(Loc, diag::note_entity_declared_at) << PT;
8163	PT = Typedef->desugar();
8164	}
8165	}
8166
8167	D.setInvalidType();
8168	return;
8169
8170	case PtrKernelParam:
8171	case ValidKernelParam:
8172	ValidTypes.insert(PT.getTypePtr());
8173	return;
8174
8175	case RecordKernelParam:
8176	break;
8177	}
8178
8179	// Track nested structs we will inspect
8180	SmallVector<const Decl *, 4> VisitStack;
8181
8182	// Track where we are in the nested structs. Items will migrate from
8183	// VisitStack to HistoryStack as we do the DFS for bad field.
8184	SmallVector<const FieldDecl *, 4> HistoryStack;
8185	HistoryStack.push_back(nullptr);
8186
8187	// At this point we already handled everything except of a RecordType or
8188	// an ArrayType of a RecordType.
8189	assert((PT->isArrayType() \|\| PT->isRecordType()) && "Unexpected type.")(((PT->isArrayType() \|\| PT->isRecordType()) && "Unexpected type." ) ? static_cast<void> (0) : __assert_fail ("(PT->isArrayType() \|\| PT->isRecordType()) && \"Unexpected type.\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 8189, __PRETTY_FUNCTION__));
8190	const RecordType *RecTy =
8191	PT->getPointeeOrArrayElementType()->getAs<RecordType>();
8192	const RecordDecl *OrigRecDecl = RecTy->getDecl();
8193
8194	VisitStack.push_back(RecTy->getDecl());
8195	assert(VisitStack.back() && "First decl null?")((VisitStack.back() && "First decl null?") ? static_cast <void> (0) : __assert_fail ("VisitStack.back() && \"First decl null?\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 8195, __PRETTY_FUNCTION__));
8196
8197	do {
8198	const Decl *Next = VisitStack.pop_back_val();
8199	if (!Next) {
8200	assert(!HistoryStack.empty())((!HistoryStack.empty()) ? static_cast<void> (0) : __assert_fail ("!HistoryStack.empty()", "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 8200, __PRETTY_FUNCTION__));
8201	// Found a marker, we have gone up a level
8202	if (const FieldDecl *Hist = HistoryStack.pop_back_val())
8203	ValidTypes.insert(Hist->getType().getTypePtr());
8204
8205	continue;
8206	}
8207
8208	// Adds everything except the original parameter declaration (which is not a
8209	// field itself) to the history stack.
8210	const RecordDecl *RD;
8211	if (const FieldDecl *Field = dyn_cast<FieldDecl>(Next)) {
8212	HistoryStack.push_back(Field);
8213
8214	QualType FieldTy = Field->getType();
8215	// Other field types (known to be valid or invalid) are handled while we
8216	// walk around RecordDecl::fields().
8217	assert((FieldTy->isArrayType() \|\| FieldTy->isRecordType()) &&(((FieldTy->isArrayType() \|\| FieldTy->isRecordType()) && "Unexpected type.") ? static_cast<void> (0) : __assert_fail ("(FieldTy->isArrayType() \|\| FieldTy->isRecordType()) && \"Unexpected type.\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 8218, __PRETTY_FUNCTION__))
8218	"Unexpected type.")(((FieldTy->isArrayType() \|\| FieldTy->isRecordType()) && "Unexpected type.") ? static_cast<void> (0) : __assert_fail ("(FieldTy->isArrayType() \|\| FieldTy->isRecordType()) && \"Unexpected type.\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 8218, __PRETTY_FUNCTION__));
8219	const Type *FieldRecTy = FieldTy->getPointeeOrArrayElementType();
8220
8221	RD = FieldRecTy->castAs<RecordType>()->getDecl();
8222	} else {
8223	RD = cast<RecordDecl>(Next);
8224	}
8225
8226	// Add a null marker so we know when we've gone back up a level
8227	VisitStack.push_back(nullptr);
8228
8229	for (const auto *FD : RD->fields()) {
8230	QualType QT = FD->getType();
8231
8232	if (ValidTypes.count(QT.getTypePtr()))
8233	continue;
8234
8235	OpenCLParamType ParamType = getOpenCLKernelParameterType(S, QT);
8236	if (ParamType == ValidKernelParam)
8237	continue;
8238
8239	if (ParamType == RecordKernelParam) {
8240	VisitStack.push_back(FD);
8241	continue;
8242	}
8243
8244	// OpenCL v1.2 s6.9.p:
8245	// Arguments to kernel functions that are declared to be a struct or union
8246	// do not allow OpenCL objects to be passed as elements of the struct or
8247	// union.
8248	if (ParamType == PtrKernelParam \|\| ParamType == PtrPtrKernelParam \|\|
8249	ParamType == InvalidAddrSpacePtrKernelParam) {
8250	S.Diag(Param->getLocation(),
8251	diag::err_record_with_pointers_kernel_param)
8252	<< PT->isUnionType()
8253	<< PT;
8254	} else {
8255	S.Diag(Param->getLocation(), diag::err_bad_kernel_param_type) << PT;
8256	}
8257
8258	S.Diag(OrigRecDecl->getLocation(), diag::note_within_field_of_type)
8259	<< OrigRecDecl->getDeclName();
8260
8261	// We have an error, now let's go back up through history and show where
8262	// the offending field came from
8263	for (ArrayRef<const FieldDecl *>::const_iterator
8264	I = HistoryStack.begin() + 1,
8265	E = HistoryStack.end();
8266	I != E; ++I) {
8267	const FieldDecl OuterField = I;
8268	S.Diag(OuterField->getLocation(), diag::note_within_field_of_type)
8269	<< OuterField->getType();
8270	}
8271
8272	S.Diag(FD->getLocation(), diag::note_illegal_field_declared_here)
8273	<< QT->isPointerType()
8274	<< QT;
8275	D.setInvalidType();
8276	return;
8277	}
8278	} while (!VisitStack.empty());
8279	}
8280
8281	/// Find the DeclContext in which a tag is implicitly declared if we see an
8282	/// elaborated type specifier in the specified context, and lookup finds
8283	/// nothing.
8284	static DeclContext getTagInjectionContext(DeclContext DC) {
8285	while (!DC->isFileContext() && !DC->isFunctionOrMethod())
8286	DC = DC->getParent();
8287	return DC;
8288	}
8289
8290	/// Find the Scope in which a tag is implicitly declared if we see an
8291	/// elaborated type specifier in the specified context, and lookup finds
8292	/// nothing.
8293	static Scope getTagInjectionScope(Scope S, const LangOptions &LangOpts) {
8294	while (S->isClassScope() \|\|
8295	(LangOpts.CPlusPlus &&
8296	S->isFunctionPrototypeScope()) \|\|
8297	((S->getFlags() & Scope::DeclScope) == 0) \|\|
8298	(S->getEntity() && S->getEntity()->isTransparentContext()))
8299	S = S->getParent();
8300	return S;
8301	}
8302
8303	NamedDecl*
8304	Sema::ActOnFunctionDeclarator(Scope S, Declarator &D, DeclContext DC,
8305	TypeSourceInfo *TInfo, LookupResult &Previous,
8306	MultiTemplateParamsArg TemplateParamLists,
8307	bool &AddToScope) {
8308	QualType R = TInfo->getType();
8309
8310	assert(R->isFunctionType())((R->isFunctionType()) ? static_cast<void> (0) : __assert_fail ("R->isFunctionType()", "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 8310, __PRETTY_FUNCTION__));
8311
8312	// TODO: consider using NameInfo for diagnostic.
8313	DeclarationNameInfo NameInfo = GetNameForDeclarator(D);
8314	DeclarationName Name = NameInfo.getName();
8315	StorageClass SC = getFunctionStorageClass(*this, D);
8316
8317	if (DeclSpec::TSCS TSCS = D.getDeclSpec().getThreadStorageClassSpec())
8318	Diag(D.getDeclSpec().getThreadStorageClassSpecLoc(),
8319	diag::err_invalid_thread)
8320	<< DeclSpec::getSpecifierName(TSCS);
8321
8322	if (D.isFirstDeclarationOfMember())
8323	adjustMemberFunctionCC(R, D.isStaticMember(), D.isCtorOrDtor(),
8324	D.getIdentifierLoc());
8325
8326	bool isFriend = false;
8327	FunctionTemplateDecl *FunctionTemplate = nullptr;
8328	bool isMemberSpecialization = false;
8329	bool isFunctionTemplateSpecialization = false;
8330
8331	bool isDependentClassScopeExplicitSpecialization = false;
8332	bool HasExplicitTemplateArgs = false;
8333	TemplateArgumentListInfo TemplateArgs;
8334
8335	bool isVirtualOkay = false;
8336
8337	DeclContext *OriginalDC = DC;
8338	bool IsLocalExternDecl = adjustContextForLocalExternDecl(DC);
8339
8340	FunctionDecl NewFD = CreateNewFunctionDecl(this, D, DC, R, TInfo, SC,
8341	isVirtualOkay);
8342	if (!NewFD) return nullptr;
8343
8344	if (OriginalLexicalContext && OriginalLexicalContext->isObjCContainer())
8345	NewFD->setTopLevelDeclInObjCContainer();
8346
8347	// Set the lexical context. If this is a function-scope declaration, or has a
8348	// C++ scope specifier, or is the object of a friend declaration, the lexical
8349	// context will be different from the semantic context.
8350	NewFD->setLexicalDeclContext(CurContext);
8351
8352	if (IsLocalExternDecl)
8353	NewFD->setLocalExternDecl();
8354
8355	if (getLangOpts().CPlusPlus) {
8356	bool isInline = D.getDeclSpec().isInlineSpecified();
8357	bool isVirtual = D.getDeclSpec().isVirtualSpecified();
8358	bool isExplicit = D.getDeclSpec().isExplicitSpecified();
8359	bool isConstexpr = D.getDeclSpec().isConstexprSpecified();
8360	isFriend = D.getDeclSpec().isFriendSpecified();
8361	if (isFriend && !isInline && D.isFunctionDefinition()) {
8362	// C++ [class.friend]p5
8363	// A function can be defined in a friend declaration of a
8364	// class . . . . Such a function is implicitly inline.
8365	NewFD->setImplicitlyInline();
8366	}
8367
8368	// If this is a method defined in an __interface, and is not a constructor
8369	// or an overloaded operator, then set the pure flag (isVirtual will already
8370	// return true).
8371	if (const CXXRecordDecl *Parent =
8372	dyn_cast<CXXRecordDecl>(NewFD->getDeclContext())) {
8373	if (Parent->isInterface() && cast<CXXMethodDecl>(NewFD)->isUserProvided())
8374	NewFD->setPure(true);
8375
8376	// C++ [class.union]p2
8377	// A union can have member functions, but not virtual functions.
8378	if (isVirtual && Parent->isUnion())
8379	Diag(D.getDeclSpec().getVirtualSpecLoc(), diag::err_virtual_in_union);
8380	}
8381
8382	SetNestedNameSpecifier(NewFD, D);
8383	isMemberSpecialization = false;
8384	isFunctionTemplateSpecialization = false;
8385	if (D.isInvalidType())
8386	NewFD->setInvalidDecl();
8387
8388	// Match up the template parameter lists with the scope specifier, then
8389	// determine whether we have a template or a template specialization.
8390	bool Invalid = false;
8391	if (TemplateParameterList *TemplateParams =
8392	MatchTemplateParametersToScopeSpecifier(
8393	D.getDeclSpec().getBeginLoc(), D.getIdentifierLoc(),
8394	D.getCXXScopeSpec(),
8395	D.getName().getKind() == UnqualifiedIdKind::IK_TemplateId
8396	? D.getName().TemplateId
8397	: nullptr,
8398	TemplateParamLists, isFriend, isMemberSpecialization,
8399	Invalid)) {
8400	if (TemplateParams->size() > 0) {
8401	// This is a function template
8402
8403	// Check that we can declare a template here.
8404	if (CheckTemplateDeclScope(S, TemplateParams))
8405	NewFD->setInvalidDecl();
8406
8407	// A destructor cannot be a template.
8408	if (Name.getNameKind() == DeclarationName::CXXDestructorName) {
8409	Diag(NewFD->getLocation(), diag::err_destructor_template);
8410	NewFD->setInvalidDecl();
8411	}
8412
8413	// If we're adding a template to a dependent context, we may need to
8414	// rebuilding some of the types used within the template parameter list,
8415	// now that we know what the current instantiation is.
8416	if (DC->isDependentContext()) {
8417	ContextRAII SavedContext(*this, DC);
8418	if (RebuildTemplateParamsInCurrentInstantiation(TemplateParams))
8419	Invalid = true;
8420	}
8421
8422	FunctionTemplate = FunctionTemplateDecl::Create(Context, DC,
8423	NewFD->getLocation(),
8424	Name, TemplateParams,
8425	NewFD);
8426	FunctionTemplate->setLexicalDeclContext(CurContext);
8427	NewFD->setDescribedFunctionTemplate(FunctionTemplate);
8428
8429	// For source fidelity, store the other template param lists.
8430	if (TemplateParamLists.size() > 1) {
8431	NewFD->setTemplateParameterListsInfo(Context,
8432	TemplateParamLists.drop_back(1));
8433	}
8434	} else {
8435	// This is a function template specialization.
8436	isFunctionTemplateSpecialization = true;
8437	// For source fidelity, store all the template param lists.
8438	if (TemplateParamLists.size() > 0)
8439	NewFD->setTemplateParameterListsInfo(Context, TemplateParamLists);
8440
8441	// C++0x [temp.expl.spec]p20 forbids "template<> friend void foo(int);".
8442	if (isFriend) {
8443	// We want to remove the "template<>", found here.
8444	SourceRange RemoveRange = TemplateParams->getSourceRange();
8445
8446	// If we remove the template<> and the name is not a
8447	// template-id, we're actually silently creating a problem:
8448	// the friend declaration will refer to an untemplated decl,
8449	// and clearly the user wants a template specialization. So
8450	// we need to insert '<>' after the name.
8451	SourceLocation InsertLoc;
8452	if (D.getName().getKind() != UnqualifiedIdKind::IK_TemplateId) {
8453	InsertLoc = D.getName().getSourceRange().getEnd();
8454	InsertLoc = getLocForEndOfToken(InsertLoc);
8455	}
8456
8457	Diag(D.getIdentifierLoc(), diag::err_template_spec_decl_friend)
8458	<< Name << RemoveRange
8459	<< FixItHint::CreateRemoval(RemoveRange)
8460	<< FixItHint::CreateInsertion(InsertLoc, "<>");
8461	}
8462	}
8463	} else {
8464	// All template param lists were matched against the scope specifier:
8465	// this is NOT (an explicit specialization of) a template.
8466	if (TemplateParamLists.size() > 0)
8467	// For source fidelity, store all the template param lists.
8468	NewFD->setTemplateParameterListsInfo(Context, TemplateParamLists);
8469	}
8470
8471	if (Invalid) {
8472	NewFD->setInvalidDecl();
8473	if (FunctionTemplate)
8474	FunctionTemplate->setInvalidDecl();
8475	}
8476
8477	// C++ [dcl.fct.spec]p5:
8478	// The virtual specifier shall only be used in declarations of
8479	// nonstatic class member functions that appear within a
8480	// member-specification of a class declaration; see 10.3.
8481	//
8482	if (isVirtual && !NewFD->isInvalidDecl()) {
8483	if (!isVirtualOkay) {
8484	Diag(D.getDeclSpec().getVirtualSpecLoc(),
8485	diag::err_virtual_non_function);
8486	} else if (!CurContext->isRecord()) {
8487	// 'virtual' was specified outside of the class.
8488	Diag(D.getDeclSpec().getVirtualSpecLoc(),
8489	diag::err_virtual_out_of_class)
8490	<< FixItHint::CreateRemoval(D.getDeclSpec().getVirtualSpecLoc());
8491	} else if (NewFD->getDescribedFunctionTemplate()) {
8492	// C++ [temp.mem]p3:
8493	// A member function template shall not be virtual.
8494	Diag(D.getDeclSpec().getVirtualSpecLoc(),
8495	diag::err_virtual_member_function_template)
8496	<< FixItHint::CreateRemoval(D.getDeclSpec().getVirtualSpecLoc());
8497	} else {
8498	// Okay: Add virtual to the method.
8499	NewFD->setVirtualAsWritten(true);
8500	}
8501
8502	if (getLangOpts().CPlusPlus14 &&
8503	NewFD->getReturnType()->isUndeducedType())
8504	Diag(D.getDeclSpec().getVirtualSpecLoc(), diag::err_auto_fn_virtual);
8505	}
8506
8507	if (getLangOpts().CPlusPlus14 &&
8508	(NewFD->isDependentContext() \|\|
8509	(isFriend && CurContext->isDependentContext())) &&
8510	NewFD->getReturnType()->isUndeducedType()) {
8511	// If the function template is referenced directly (for instance, as a
8512	// member of the current instantiation), pretend it has a dependent type.
8513	// This is not really justified by the standard, but is the only sane
8514	// thing to do.
8515	// FIXME: For a friend function, we have not marked the function as being
8516	// a friend yet, so 'isDependentContext' on the FD doesn't work.
8517	const FunctionProtoType *FPT =
8518	NewFD->getType()->castAs<FunctionProtoType>();
8519	QualType Result =
8520	SubstAutoType(FPT->getReturnType(), Context.DependentTy);
8521	NewFD->setType(Context.getFunctionType(Result, FPT->getParamTypes(),
8522	FPT->getExtProtoInfo()));
8523	}
8524
8525	// C++ [dcl.fct.spec]p3:
8526	// The inline specifier shall not appear on a block scope function
8527	// declaration.
8528	if (isInline && !NewFD->isInvalidDecl()) {
8529	if (CurContext->isFunctionOrMethod()) {
8530	// 'inline' is not allowed on block scope function declaration.
8531	Diag(D.getDeclSpec().getInlineSpecLoc(),
8532	diag::err_inline_declaration_block_scope) << Name
8533	<< FixItHint::CreateRemoval(D.getDeclSpec().getInlineSpecLoc());
8534	}
8535	}
8536
8537	// C++ [dcl.fct.spec]p6:
8538	// The explicit specifier shall be used only in the declaration of a
8539	// constructor or conversion function within its class definition;
8540	// see 12.3.1 and 12.3.2.
8541	if (isExplicit && !NewFD->isInvalidDecl() &&
8542	!isa<CXXDeductionGuideDecl>(NewFD)) {
8543	if (!CurContext->isRecord()) {
8544	// 'explicit' was specified outside of the class.
8545	Diag(D.getDeclSpec().getExplicitSpecLoc(),
8546	diag::err_explicit_out_of_class)
8547	<< FixItHint::CreateRemoval(D.getDeclSpec().getExplicitSpecLoc());
8548	} else if (!isa<CXXConstructorDecl>(NewFD) &&
8549	!isa<CXXConversionDecl>(NewFD)) {
8550	// 'explicit' was specified on a function that wasn't a constructor
8551	// or conversion function.
8552	Diag(D.getDeclSpec().getExplicitSpecLoc(),
8553	diag::err_explicit_non_ctor_or_conv_function)
8554	<< FixItHint::CreateRemoval(D.getDeclSpec().getExplicitSpecLoc());
8555	}
8556	}
8557
8558	if (isConstexpr) {
8559	// C++11 [dcl.constexpr]p2: constexpr functions and constexpr constructors
8560	// are implicitly inline.
8561	NewFD->setImplicitlyInline();
8562
8563	// C++11 [dcl.constexpr]p3: functions declared constexpr are required to
8564	// be either constructors or to return a literal type. Therefore,
8565	// destructors cannot be declared constexpr.
8566	if (isa<CXXDestructorDecl>(NewFD))
8567	Diag(D.getDeclSpec().getConstexprSpecLoc(), diag::err_constexpr_dtor);
8568	}
8569
8570	// If __module_private__ was specified, mark the function accordingly.
8571	if (D.getDeclSpec().isModulePrivateSpecified()) {
8572	if (isFunctionTemplateSpecialization) {
8573	SourceLocation ModulePrivateLoc
8574	= D.getDeclSpec().getModulePrivateSpecLoc();
8575	Diag(ModulePrivateLoc, diag::err_module_private_specialization)
8576	<< 0
8577	<< FixItHint::CreateRemoval(ModulePrivateLoc);
8578	} else {
8579	NewFD->setModulePrivate();
8580	if (FunctionTemplate)
8581	FunctionTemplate->setModulePrivate();
8582	}
8583	}
8584
8585	if (isFriend) {
8586	if (FunctionTemplate) {
8587	FunctionTemplate->setObjectOfFriendDecl();
8588	FunctionTemplate->setAccess(AS_public);
8589	}
8590	NewFD->setObjectOfFriendDecl();
8591	NewFD->setAccess(AS_public);
8592	}
8593
8594	// If a function is defined as defaulted or deleted, mark it as such now.
8595	// FIXME: Does this ever happen? ActOnStartOfFunctionDef forces the function
8596	// definition kind to FDK_Definition.
8597	switch (D.getFunctionDefinitionKind()) {
8598	case FDK_Declaration:
8599	case FDK_Definition:
8600	break;
8601
8602	case FDK_Defaulted:
8603	NewFD->setDefaulted();
8604	break;
8605
8606	case FDK_Deleted:
8607	NewFD->setDeletedAsWritten();
8608	break;
8609	}
8610
8611	if (isa<CXXMethodDecl>(NewFD) && DC == CurContext &&
8612	D.isFunctionDefinition()) {
8613	// C++ [class.mfct]p2:
8614	// A member function may be defined (8.4) in its class definition, in
8615	// which case it is an inline member function (7.1.2)
8616	NewFD->setImplicitlyInline();
8617	}
8618
8619	if (SC == SC_Static && isa<CXXMethodDecl>(NewFD) &&
8620	!CurContext->isRecord()) {
8621	// C++ [class.static]p1:
8622	// A data or function member of a class may be declared static
8623	// in a class definition, in which case it is a static member of
8624	// the class.
8625
8626	// Complain about the 'static' specifier if it's on an out-of-line
8627	// member function definition.
8628	Diag(D.getDeclSpec().getStorageClassSpecLoc(),
8629	diag::err_static_out_of_line)
8630	<< FixItHint::CreateRemoval(D.getDeclSpec().getStorageClassSpecLoc());
8631	}
8632
8633	// C++11 [except.spec]p15:
8634	// A deallocation function with no exception-specification is treated
8635	// as if it were specified with noexcept(true).
8636	const FunctionProtoType *FPT = R->getAs<FunctionProtoType>();
8637	if ((Name.getCXXOverloadedOperator() == OO_Delete \|\|
8638	Name.getCXXOverloadedOperator() == OO_Array_Delete) &&
8639	getLangOpts().CPlusPlus11 && FPT && !FPT->hasExceptionSpec())
8640	NewFD->setType(Context.getFunctionType(
8641	FPT->getReturnType(), FPT->getParamTypes(),
8642	FPT->getExtProtoInfo().withExceptionSpec(EST_BasicNoexcept)));
8643	}
8644
8645	// Filter out previous declarations that don't match the scope.
8646	FilterLookupForScope(Previous, OriginalDC, S, shouldConsiderLinkage(NewFD),
8647	D.getCXXScopeSpec().isNotEmpty() \|\|
8648	isMemberSpecialization \|\|
8649	isFunctionTemplateSpecialization);
8650
8651	// Handle GNU asm-label extension (encoded as an attribute).
8652	if (Expr E = (Expr) D.getAsmLabel()) {
8653	// The parser guarantees this is a string.
8654	StringLiteral *SE = cast<StringLiteral>(E);
8655	NewFD->addAttr(::new (Context) AsmLabelAttr(SE->getStrTokenLoc(0), Context,
8656	SE->getString(), 0));
8657	} else if (!ExtnameUndeclaredIdentifiers.empty()) {
8658	llvm::DenseMap<IdentifierInfo,AsmLabelAttr>::iterator I =
8659	ExtnameUndeclaredIdentifiers.find(NewFD->getIdentifier());
8660	if (I != ExtnameUndeclaredIdentifiers.end()) {
8661	if (isDeclExternC(NewFD)) {
8662	NewFD->addAttr(I->second);
8663	ExtnameUndeclaredIdentifiers.erase(I);
8664	} else
8665	Diag(NewFD->getLocation(), diag::warn_redefine_extname_not_applied)
8666	<< /Variable/0 << NewFD;
8667	}
8668	}
8669
8670	// Copy the parameter declarations from the declarator D to the function
8671	// declaration NewFD, if they are available. First scavenge them into Params.
8672	SmallVector<ParmVarDecl*, 16> Params;
8673	unsigned FTIIdx;
8674	if (D.isFunctionDeclarator(FTIIdx)) {
8675	DeclaratorChunk::FunctionTypeInfo &FTI = D.getTypeObject(FTIIdx).Fun;
8676
8677	// Check for C99 6.7.5.3p10 - foo(void) is a non-varargs
8678	// function that takes no arguments, not a function that takes a
8679	// single void argument.
8680	// We let through "const void" here because Sema::GetTypeForDeclarator
8681	// already checks for that case.
8682	if (FTIHasNonVoidParameters(FTI) && FTI.Params[0].Param) {
8683	for (unsigned i = 0, e = FTI.NumParams; i != e; ++i) {
8684	ParmVarDecl *Param = cast<ParmVarDecl>(FTI.Params[i].Param);
8685	assert(Param->getDeclContext() != NewFD && "Was set before ?")((Param->getDeclContext() != NewFD && "Was set before ?" ) ? static_cast<void> (0) : __assert_fail ("Param->getDeclContext() != NewFD && \"Was set before ?\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 8685, __PRETTY_FUNCTION__));
8686	Param->setDeclContext(NewFD);
8687	Params.push_back(Param);
8688
8689	if (Param->isInvalidDecl())
8690	NewFD->setInvalidDecl();
8691	}
8692	}
8693
8694	if (!getLangOpts().CPlusPlus) {
8695	// In C, find all the tag declarations from the prototype and move them
8696	// into the function DeclContext. Remove them from the surrounding tag
8697	// injection context of the function, which is typically but not always
8698	// the TU.
8699	DeclContext *PrototypeTagContext =
8700	getTagInjectionContext(NewFD->getLexicalDeclContext());
8701	for (NamedDecl *NonParmDecl : FTI.getDeclsInPrototype()) {
8702	auto *TD = dyn_cast<TagDecl>(NonParmDecl);
8703
8704	// We don't want to reparent enumerators. Look at their parent enum
8705	// instead.
8706	if (!TD) {
8707	if (auto *ECD = dyn_cast<EnumConstantDecl>(NonParmDecl))
8708	TD = cast<EnumDecl>(ECD->getDeclContext());
8709	}
8710	if (!TD)
8711	continue;
8712	DeclContext *TagDC = TD->getLexicalDeclContext();
8713	if (!TagDC->containsDecl(TD))
8714	continue;
8715	TagDC->removeDecl(TD);
8716	TD->setDeclContext(NewFD);
8717	NewFD->addDecl(TD);
8718
8719	// Preserve the lexical DeclContext if it is not the surrounding tag
8720	// injection context of the FD. In this example, the semantic context of
8721	// E will be f and the lexical context will be S, while both the
8722	// semantic and lexical contexts of S will be f:
8723	// void f(struct S { enum E { a } f; } s);
8724	if (TagDC != PrototypeTagContext)
8725	TD->setLexicalDeclContext(TagDC);
8726	}
8727	}
8728	} else if (const FunctionProtoType *FT = R->getAs<FunctionProtoType>()) {
8729	// When we're declaring a function with a typedef, typeof, etc as in the
8730	// following example, we'll need to synthesize (unnamed)
8731	// parameters for use in the declaration.
8732	//
8733	// @code
8734	// typedef void fn(int);
8735	// fn f;
8736	// @endcode
8737
8738	// Synthesize a parameter for each argument type.
8739	for (const auto &AI : FT->param_types()) {
8740	ParmVarDecl *Param =
8741	BuildParmVarDeclForTypedef(NewFD, D.getIdentifierLoc(), AI);
8742	Param->setScopeInfo(0, Params.size());
8743	Params.push_back(Param);
8744	}
8745	} else {
8746	assert(R->isFunctionNoProtoType() && NewFD->getNumParams() == 0 &&((R->isFunctionNoProtoType() && NewFD->getNumParams () == 0 && "Should not need args for typedef of non-prototype fn" ) ? static_cast<void> (0) : __assert_fail ("R->isFunctionNoProtoType() && NewFD->getNumParams() == 0 && \"Should not need args for typedef of non-prototype fn\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 8747, __PRETTY_FUNCTION__))
8747	"Should not need args for typedef of non-prototype fn")((R->isFunctionNoProtoType() && NewFD->getNumParams () == 0 && "Should not need args for typedef of non-prototype fn" ) ? static_cast<void> (0) : __assert_fail ("R->isFunctionNoProtoType() && NewFD->getNumParams() == 0 && \"Should not need args for typedef of non-prototype fn\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 8747, __PRETTY_FUNCTION__));
8748	}
8749
8750	// Finally, we know we have the right number of parameters, install them.
8751	NewFD->setParams(Params);
8752
8753	if (D.getDeclSpec().isNoreturnSpecified())
8754	NewFD->addAttr(
8755	::new(Context) C11NoReturnAttr(D.getDeclSpec().getNoreturnSpecLoc(),
8756	Context, 0));
8757
8758	// Functions returning a variably modified type violate C99 6.7.5.2p2
8759	// because all functions have linkage.
8760	if (!NewFD->isInvalidDecl() &&
8761	NewFD->getReturnType()->isVariablyModifiedType()) {
8762	Diag(NewFD->getLocation(), diag::err_vm_func_decl);
8763	NewFD->setInvalidDecl();
8764	}
8765
8766	// Apply an implicit SectionAttr if '#pragma clang section text' is active
8767	if (PragmaClangTextSection.Valid && D.isFunctionDefinition() &&
8768	!NewFD->hasAttr<SectionAttr>()) {
8769	NewFD->addAttr(PragmaClangTextSectionAttr::CreateImplicit(Context,
8770	PragmaClangTextSection.SectionName,
8771	PragmaClangTextSection.PragmaLocation));
8772	}
8773
8774	// Apply an implicit SectionAttr if #pragma code_seg is active.
8775	if (CodeSegStack.CurrentValue && D.isFunctionDefinition() &&
8776	!NewFD->hasAttr<SectionAttr>()) {
8777	NewFD->addAttr(
8778	SectionAttr::CreateImplicit(Context, SectionAttr::Declspec_allocate,
8779	CodeSegStack.CurrentValue->getString(),
8780	CodeSegStack.CurrentPragmaLocation));
8781	if (UnifySection(CodeSegStack.CurrentValue->getString(),
8782	ASTContext::PSF_Implicit \| ASTContext::PSF_Execute \|
8783	ASTContext::PSF_Read,
8784	NewFD))
8785	NewFD->dropAttr<SectionAttr>();
8786	}
8787
8788	// Apply an implicit CodeSegAttr from class declspec or
8789	// apply an implicit SectionAttr from #pragma code_seg if active.
8790	if (!NewFD->hasAttr<CodeSegAttr>()) {
8791	if (Attr *SAttr = getImplicitCodeSegOrSectionAttrForFunction(NewFD,
8792	D.isFunctionDefinition())) {
8793	NewFD->addAttr(SAttr);
8794	}
8795	}
8796
8797	// Handle attributes.
8798	ProcessDeclAttributes(S, NewFD, D);
8799
8800	if (getLangOpts().OpenCL) {
8801	// OpenCL v1.1 s6.5: Using an address space qualifier in a function return
8802	// type declaration will generate a compilation error.
8803	LangAS AddressSpace = NewFD->getReturnType().getAddressSpace();
8804	if (AddressSpace != LangAS::Default) {
8805	Diag(NewFD->getLocation(),
8806	diag::err_opencl_return_value_with_address_space);
8807	NewFD->setInvalidDecl();
8808	}
8809	}
8810
8811	if (!getLangOpts().CPlusPlus) {
8812	// Perform semantic checking on the function declaration.
8813	if (!NewFD->isInvalidDecl() && NewFD->isMain())
8814	CheckMain(NewFD, D.getDeclSpec());
8815
8816	if (!NewFD->isInvalidDecl() && NewFD->isMSVCRTEntryPoint())
8817	CheckMSVCRTEntryPoint(NewFD);
8818
8819	if (!NewFD->isInvalidDecl())
8820	D.setRedeclaration(CheckFunctionDeclaration(S, NewFD, Previous,
8821	isMemberSpecialization));
8822	else if (!Previous.empty())
8823	// Recover gracefully from an invalid redeclaration.
8824	D.setRedeclaration(true);
8825	assert((NewFD->isInvalidDecl() \|\| !D.isRedeclaration() \|\|(((NewFD->isInvalidDecl() \|\| !D.isRedeclaration() \|\| Previous .getResultKind() != LookupResult::FoundOverloaded) && "previous declaration set still overloaded") ? static_cast< void> (0) : __assert_fail ("(NewFD->isInvalidDecl() \|\| !D.isRedeclaration() \|\| Previous.getResultKind() != LookupResult::FoundOverloaded) && \"previous declaration set still overloaded\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 8827, __PRETTY_FUNCTION__))
8826	Previous.getResultKind() != LookupResult::FoundOverloaded) &&(((NewFD->isInvalidDecl() \|\| !D.isRedeclaration() \|\| Previous .getResultKind() != LookupResult::FoundOverloaded) && "previous declaration set still overloaded") ? static_cast< void> (0) : __assert_fail ("(NewFD->isInvalidDecl() \|\| !D.isRedeclaration() \|\| Previous.getResultKind() != LookupResult::FoundOverloaded) && \"previous declaration set still overloaded\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 8827, __PRETTY_FUNCTION__))
8827	"previous declaration set still overloaded")(((NewFD->isInvalidDecl() \|\| !D.isRedeclaration() \|\| Previous .getResultKind() != LookupResult::FoundOverloaded) && "previous declaration set still overloaded") ? static_cast< void> (0) : __assert_fail ("(NewFD->isInvalidDecl() \|\| !D.isRedeclaration() \|\| Previous.getResultKind() != LookupResult::FoundOverloaded) && \"previous declaration set still overloaded\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 8827, __PRETTY_FUNCTION__));
8828
8829	// Diagnose no-prototype function declarations with calling conventions that
8830	// don't support variadic calls. Only do this in C and do it after merging
8831	// possibly prototyped redeclarations.
8832	const FunctionType *FT = NewFD->getType()->castAs<FunctionType>();
8833	if (isa<FunctionNoProtoType>(FT) && !D.isFunctionDefinition()) {
8834	CallingConv CC = FT->getExtInfo().getCC();
8835	if (!supportsVariadicCall(CC)) {
8836	// Windows system headers sometimes accidentally use stdcall without
8837	// (void) parameters, so we relax this to a warning.
8838	int DiagID =
8839	CC == CC_X86StdCall ? diag::warn_cconv_knr : diag::err_cconv_knr;
8840	Diag(NewFD->getLocation(), DiagID)
8841	<< FunctionType::getNameForCallConv(CC);
8842	}
8843	}
8844	} else {
8845	// C++11 [replacement.functions]p3:
8846	// The program's definitions shall not be specified as inline.
8847	//
8848	// N.B. We diagnose declarations instead of definitions per LWG issue 2340.
8849	//
8850	// Suppress the diagnostic if the function is __attribute__((used)), since
8851	// that forces an external definition to be emitted.
8852	if (D.getDeclSpec().isInlineSpecified() &&
8853	NewFD->isReplaceableGlobalAllocationFunction() &&
8854	!NewFD->hasAttr<UsedAttr>())
8855	Diag(D.getDeclSpec().getInlineSpecLoc(),
8856	diag::ext_operator_new_delete_declared_inline)
8857	<< NewFD->getDeclName();
8858
8859	// If the declarator is a template-id, translate the parser's template
8860	// argument list into our AST format.
8861	if (D.getName().getKind() == UnqualifiedIdKind::IK_TemplateId) {
8862	TemplateIdAnnotation *TemplateId = D.getName().TemplateId;
8863	TemplateArgs.setLAngleLoc(TemplateId->LAngleLoc);
8864	TemplateArgs.setRAngleLoc(TemplateId->RAngleLoc);
8865	ASTTemplateArgsPtr TemplateArgsPtr(TemplateId->getTemplateArgs(),
8866	TemplateId->NumArgs);
8867	translateTemplateArguments(TemplateArgsPtr,
8868	TemplateArgs);
8869
8870	HasExplicitTemplateArgs = true;
8871
8872	if (NewFD->isInvalidDecl()) {
8873	HasExplicitTemplateArgs = false;
8874	} else if (FunctionTemplate) {
8875	// Function template with explicit template arguments.
8876	Diag(D.getIdentifierLoc(), diag::err_function_template_partial_spec)
8877	<< SourceRange(TemplateId->LAngleLoc, TemplateId->RAngleLoc);
8878
8879	HasExplicitTemplateArgs = false;
8880	} else {
8881	assert((isFunctionTemplateSpecialization \|\|(((isFunctionTemplateSpecialization \|\| D.getDeclSpec().isFriendSpecified ()) && "should have a 'template<>' for this decl" ) ? static_cast<void> (0) : __assert_fail ("(isFunctionTemplateSpecialization \|\| D.getDeclSpec().isFriendSpecified()) && \"should have a 'template<>' for this decl\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 8883, __PRETTY_FUNCTION__))
8882	D.getDeclSpec().isFriendSpecified()) &&(((isFunctionTemplateSpecialization \|\| D.getDeclSpec().isFriendSpecified ()) && "should have a 'template<>' for this decl" ) ? static_cast<void> (0) : __assert_fail ("(isFunctionTemplateSpecialization \|\| D.getDeclSpec().isFriendSpecified()) && \"should have a 'template<>' for this decl\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 8883, __PRETTY_FUNCTION__))
8883	"should have a 'template<>' for this decl")(((isFunctionTemplateSpecialization \|\| D.getDeclSpec().isFriendSpecified ()) && "should have a 'template<>' for this decl" ) ? static_cast<void> (0) : __assert_fail ("(isFunctionTemplateSpecialization \|\| D.getDeclSpec().isFriendSpecified()) && \"should have a 'template<>' for this decl\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 8883, __PRETTY_FUNCTION__));
8884	// "friend void foo<>(int);" is an implicit specialization decl.
8885	isFunctionTemplateSpecialization = true;
8886	}
8887	} else if (isFriend && isFunctionTemplateSpecialization) {
8888	// This combination is only possible in a recovery case; the user
8889	// wrote something like:
8890	// template <> friend void foo(int);
8891	// which we're recovering from as if the user had written:
8892	// friend void foo<>(int);
8893	// Go ahead and fake up a template id.
8894	HasExplicitTemplateArgs = true;
8895	TemplateArgs.setLAngleLoc(D.getIdentifierLoc());
8896	TemplateArgs.setRAngleLoc(D.getIdentifierLoc());
8897	}
8898
8899	// We do not add HD attributes to specializations here because
8900	// they may have different constexpr-ness compared to their
8901	// templates and, after maybeAddCUDAHostDeviceAttrs() is applied,
8902	// may end up with different effective targets. Instead, a
8903	// specialization inherits its target attributes from its template
8904	// in the CheckFunctionTemplateSpecialization() call below.
8905	if (getLangOpts().CUDA & !isFunctionTemplateSpecialization)
8906	maybeAddCUDAHostDeviceAttrs(NewFD, Previous);
8907
8908	// If it's a friend (and only if it's a friend), it's possible
8909	// that either the specialized function type or the specialized
8910	// template is dependent, and therefore matching will fail. In
8911	// this case, don't check the specialization yet.
8912	bool InstantiationDependent = false;
8913	if (isFunctionTemplateSpecialization && isFriend &&
8914	(NewFD->getType()->isDependentType() \|\| DC->isDependentContext() \|\|
8915	TemplateSpecializationType::anyDependentTemplateArguments(
8916	TemplateArgs,
8917	InstantiationDependent))) {
8918	assert(HasExplicitTemplateArgs &&((HasExplicitTemplateArgs && "friend function specialization without template args" ) ? static_cast<void> (0) : __assert_fail ("HasExplicitTemplateArgs && \"friend function specialization without template args\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 8919, __PRETTY_FUNCTION__))
8919	"friend function specialization without template args")((HasExplicitTemplateArgs && "friend function specialization without template args" ) ? static_cast<void> (0) : __assert_fail ("HasExplicitTemplateArgs && \"friend function specialization without template args\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 8919, __PRETTY_FUNCTION__));
8920	if (CheckDependentFunctionTemplateSpecialization(NewFD, TemplateArgs,
8921	Previous))
8922	NewFD->setInvalidDecl();
8923	} else if (isFunctionTemplateSpecialization) {
8924	if (CurContext->isDependentContext() && CurContext->isRecord()
8925	&& !isFriend) {
8926	isDependentClassScopeExplicitSpecialization = true;
8927	} else if (!NewFD->isInvalidDecl() &&
8928	CheckFunctionTemplateSpecialization(
8929	NewFD, (HasExplicitTemplateArgs ? &TemplateArgs : nullptr),
8930	Previous))
8931	NewFD->setInvalidDecl();
8932
8933	// C++ [dcl.stc]p1:
8934	// A storage-class-specifier shall not be specified in an explicit
8935	// specialization (14.7.3)
8936	FunctionTemplateSpecializationInfo *Info =
8937	NewFD->getTemplateSpecializationInfo();
8938	if (Info && SC != SC_None) {
8939	if (SC != Info->getTemplate()->getTemplatedDecl()->getStorageClass())
8940	Diag(NewFD->getLocation(),
8941	diag::err_explicit_specialization_inconsistent_storage_class)
8942	<< SC
8943	<< FixItHint::CreateRemoval(
8944	D.getDeclSpec().getStorageClassSpecLoc());
8945
8946	else
8947	Diag(NewFD->getLocation(),
8948	diag::ext_explicit_specialization_storage_class)
8949	<< FixItHint::CreateRemoval(
8950	D.getDeclSpec().getStorageClassSpecLoc());
8951	}
8952	} else if (isMemberSpecialization && isa<CXXMethodDecl>(NewFD)) {
8953	if (CheckMemberSpecialization(NewFD, Previous))
8954	NewFD->setInvalidDecl();
8955	}
8956
8957	// Perform semantic checking on the function declaration.
8958	if (!isDependentClassScopeExplicitSpecialization) {
8959	if (!NewFD->isInvalidDecl() && NewFD->isMain())
8960	CheckMain(NewFD, D.getDeclSpec());
8961
8962	if (!NewFD->isInvalidDecl() && NewFD->isMSVCRTEntryPoint())
8963	CheckMSVCRTEntryPoint(NewFD);
8964
8965	if (!NewFD->isInvalidDecl())
8966	D.setRedeclaration(CheckFunctionDeclaration(S, NewFD, Previous,
8967	isMemberSpecialization));
8968	else if (!Previous.empty())
8969	// Recover gracefully from an invalid redeclaration.
8970	D.setRedeclaration(true);
8971	}
8972
8973	assert((NewFD->isInvalidDecl() \|\| !D.isRedeclaration() \|\|(((NewFD->isInvalidDecl() \|\| !D.isRedeclaration() \|\| Previous .getResultKind() != LookupResult::FoundOverloaded) && "previous declaration set still overloaded") ? static_cast< void> (0) : __assert_fail ("(NewFD->isInvalidDecl() \|\| !D.isRedeclaration() \|\| Previous.getResultKind() != LookupResult::FoundOverloaded) && \"previous declaration set still overloaded\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 8975, __PRETTY_FUNCTION__))
8974	Previous.getResultKind() != LookupResult::FoundOverloaded) &&(((NewFD->isInvalidDecl() \|\| !D.isRedeclaration() \|\| Previous .getResultKind() != LookupResult::FoundOverloaded) && "previous declaration set still overloaded") ? static_cast< void> (0) : __assert_fail ("(NewFD->isInvalidDecl() \|\| !D.isRedeclaration() \|\| Previous.getResultKind() != LookupResult::FoundOverloaded) && \"previous declaration set still overloaded\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 8975, __PRETTY_FUNCTION__))
8975	"previous declaration set still overloaded")(((NewFD->isInvalidDecl() \|\| !D.isRedeclaration() \|\| Previous .getResultKind() != LookupResult::FoundOverloaded) && "previous declaration set still overloaded") ? static_cast< void> (0) : __assert_fail ("(NewFD->isInvalidDecl() \|\| !D.isRedeclaration() \|\| Previous.getResultKind() != LookupResult::FoundOverloaded) && \"previous declaration set still overloaded\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 8975, __PRETTY_FUNCTION__));
8976
8977	NamedDecl *PrincipalDecl = (FunctionTemplate
8978	? cast<NamedDecl>(FunctionTemplate)
8979	: NewFD);
8980
8981	if (isFriend && NewFD->getPreviousDecl()) {
8982	AccessSpecifier Access = AS_public;
8983	if (!NewFD->isInvalidDecl())
8984	Access = NewFD->getPreviousDecl()->getAccess();
8985
8986	NewFD->setAccess(Access);
8987	if (FunctionTemplate) FunctionTemplate->setAccess(Access);
8988	}
8989
8990	if (NewFD->isOverloadedOperator() && !DC->isRecord() &&
8991	PrincipalDecl->isInIdentifierNamespace(Decl::IDNS_Ordinary))
8992	PrincipalDecl->setNonMemberOperator();
8993
8994	// If we have a function template, check the template parameter
8995	// list. This will check and merge default template arguments.
8996	if (FunctionTemplate) {
8997	FunctionTemplateDecl *PrevTemplate =
8998	FunctionTemplate->getPreviousDecl();
8999	CheckTemplateParameterList(FunctionTemplate->getTemplateParameters(),
9000	PrevTemplate ? PrevTemplate->getTemplateParameters()
9001	: nullptr,
9002	D.getDeclSpec().isFriendSpecified()
9003	? (D.isFunctionDefinition()
9004	? TPC_FriendFunctionTemplateDefinition
9005	: TPC_FriendFunctionTemplate)
9006	: (D.getCXXScopeSpec().isSet() &&
9007	DC && DC->isRecord() &&
9008	DC->isDependentContext())
9009	? TPC_ClassTemplateMember
9010	: TPC_FunctionTemplate);
9011	}
9012
9013	if (NewFD->isInvalidDecl()) {
9014	// Ignore all the rest of this.
9015	} else if (!D.isRedeclaration()) {
9016	struct ActOnFDArgs ExtraArgs = { S, D, TemplateParamLists,
9017	AddToScope };
9018	// Fake up an access specifier if it's supposed to be a class member.
9019	if (isa<CXXRecordDecl>(NewFD->getDeclContext()))
9020	NewFD->setAccess(AS_public);
9021
9022	// Qualified decls generally require a previous declaration.
9023	if (D.getCXXScopeSpec().isSet()) {
9024	// ...with the major exception of templated-scope or
9025	// dependent-scope friend declarations.
9026
9027	// TODO: we currently also suppress this check in dependent
9028	// contexts because (1) the parameter depth will be off when
9029	// matching friend templates and (2) we might actually be
9030	// selecting a friend based on a dependent factor. But there
9031	// are situations where these conditions don't apply and we
9032	// can actually do this check immediately.
9033	if (isFriend &&
9034	(TemplateParamLists.size() \|\|
9035	D.getCXXScopeSpec().getScopeRep()->isDependent() \|\|
9036	CurContext->isDependentContext())) {
9037	// ignore these
9038	} else {
9039	// The user tried to provide an out-of-line definition for a
9040	// function that is a member of a class or namespace, but there
9041	// was no such member function declared (C++ [class.mfct]p2,
9042	// C++ [namespace.memdef]p2). For example:
9043	//
9044	// class X {
9045	// void f() const;
9046	// };
9047	//
9048	// void X::f() { } // ill-formed
9049	//
9050	// Complain about this problem, and attempt to suggest close
9051	// matches (e.g., those that differ only in cv-qualifiers and
9052	// whether the parameter types are references).
9053
9054	if (NamedDecl *Result = DiagnoseInvalidRedeclaration(
9055	*this, Previous, NewFD, ExtraArgs, false, nullptr)) {
9056	AddToScope = ExtraArgs.AddToScope;
9057	return Result;
9058	}
9059	}
9060
9061	// Unqualified local friend declarations are required to resolve
9062	// to something.
9063	} else if (isFriend && cast<CXXRecordDecl>(CurContext)->isLocalClass()) {
9064	if (NamedDecl *Result = DiagnoseInvalidRedeclaration(
9065	*this, Previous, NewFD, ExtraArgs, true, S)) {
9066	AddToScope = ExtraArgs.AddToScope;
9067	return Result;
9068	}
9069	}
9070	} else if (!D.isFunctionDefinition() &&
9071	isa<CXXMethodDecl>(NewFD) && NewFD->isOutOfLine() &&
9072	!isFriend && !isFunctionTemplateSpecialization &&
9073	!isMemberSpecialization) {
9074	// An out-of-line member function declaration must also be a
9075	// definition (C++ [class.mfct]p2).
9076	// Note that this is not the case for explicit specializations of
9077	// function templates or member functions of class templates, per
9078	// C++ [temp.expl.spec]p2. We also allow these declarations as an
9079	// extension for compatibility with old SWIG code which likes to
9080	// generate them.
9081	Diag(NewFD->getLocation(), diag::ext_out_of_line_declaration)
9082	<< D.getCXXScopeSpec().getRange();
9083	}
9084	}
9085
9086	ProcessPragmaWeak(S, NewFD);
9087	checkAttributesAfterMerging(this, NewFD);
9088
9089	AddKnownFunctionAttributes(NewFD);
9090
9091	if (NewFD->hasAttr<OverloadableAttr>() &&
9092	!NewFD->getType()->getAs<FunctionProtoType>()) {
9093	Diag(NewFD->getLocation(),
9094	diag::err_attribute_overloadable_no_prototype)
9095	<< NewFD;
9096
9097	// Turn this into a variadic function with no parameters.
9098	const FunctionType *FT = NewFD->getType()->getAs<FunctionType>();
9099	FunctionProtoType::ExtProtoInfo EPI(
9100	Context.getDefaultCallingConvention(true, false));
9101	EPI.Variadic = true;
9102	EPI.ExtInfo = FT->getExtInfo();
9103
9104	QualType R = Context.getFunctionType(FT->getReturnType(), None, EPI);
9105	NewFD->setType(R);
9106	}
9107
9108	// If there's a #pragma GCC visibility in scope, and this isn't a class
9109	// member, set the visibility of this function.
9110	if (!DC->isRecord() && NewFD->isExternallyVisible())
9111	AddPushedVisibilityAttribute(NewFD);
9112
9113	// If there's a #pragma clang arc_cf_code_audited in scope, consider
9114	// marking the function.
9115	AddCFAuditedAttribute(NewFD);
9116
9117	// If this is a function definition, check if we have to apply optnone due to
9118	// a pragma.
9119	if(D.isFunctionDefinition())
9120	AddRangeBasedOptnone(NewFD);
9121
9122	// If this is the first declaration of an extern C variable, update
9123	// the map of such variables.
9124	if (NewFD->isFirstDecl() && !NewFD->isInvalidDecl() &&
9125	isIncompleteDeclExternC(*this, NewFD))
9126	RegisterLocallyScopedExternCDecl(NewFD, S);
9127
9128	// Set this FunctionDecl's range up to the right paren.
9129	NewFD->setRangeEnd(D.getSourceRange().getEnd());
9130
9131	if (D.isRedeclaration() && !Previous.empty()) {
9132	NamedDecl *Prev = Previous.getRepresentativeDecl();
9133	checkDLLAttributeRedeclaration(*this, Prev, NewFD,
9134	isMemberSpecialization \|\|
9135	isFunctionTemplateSpecialization,
9136	D.isFunctionDefinition());
9137	}
9138
9139	if (getLangOpts().CUDA) {
9140	IdentifierInfo *II = NewFD->getIdentifier();
9141	if (II &&
9142	II->isStr(getLangOpts().HIP ? "hipConfigureCall"
9143	: "cudaConfigureCall") &&
9144	!NewFD->isInvalidDecl() &&
9145	NewFD->getDeclContext()->getRedeclContext()->isTranslationUnit()) {
9146	if (!R->getAs<FunctionType>()->getReturnType()->isScalarType())
9147	Diag(NewFD->getLocation(), diag::err_config_scalar_return);
9148	Context.setcudaConfigureCallDecl(NewFD);
9149	}
9150
9151	// Variadic functions, other than a declaration of printf, are not allowed
9152	// in device-side CUDA code, unless someone passed
9153	// -fcuda-allow-variadic-functions.
9154	if (!getLangOpts().CUDAAllowVariadicFunctions && NewFD->isVariadic() &&
9155	(NewFD->hasAttr<CUDADeviceAttr>() \|\|
9156	NewFD->hasAttr<CUDAGlobalAttr>()) &&
9157	!(II && II->isStr("printf") && NewFD->isExternC() &&
9158	!D.isFunctionDefinition())) {
9159	Diag(NewFD->getLocation(), diag::err_variadic_device_fn);
9160	}
9161	}
9162
9163	MarkUnusedFileScopedDecl(NewFD);
9164
9165	if (getLangOpts().CPlusPlus) {
9166	if (FunctionTemplate) {
9167	if (NewFD->isInvalidDecl())
9168	FunctionTemplate->setInvalidDecl();
9169	return FunctionTemplate;
9170	}
9171
9172	if (isMemberSpecialization && !NewFD->isInvalidDecl())
9173	CompleteMemberSpecialization(NewFD, Previous);
9174	}
9175
9176	if (NewFD->hasAttr<OpenCLKernelAttr>()) {
9177	// OpenCL v1.2 s6.8 static is invalid for kernel functions.
9178	if ((getLangOpts().OpenCLVersion >= 120)
9179	&& (SC == SC_Static)) {
9180	Diag(D.getIdentifierLoc(), diag::err_static_kernel);
9181	D.setInvalidType();
9182	}
9183
9184	// OpenCL v1.2, s6.9 -- Kernels can only have return type void.
9185	if (!NewFD->getReturnType()->isVoidType()) {
9186	SourceRange RTRange = NewFD->getReturnTypeSourceRange();
9187	Diag(D.getIdentifierLoc(), diag::err_expected_kernel_void_return_type)
9188	<< (RTRange.isValid() ? FixItHint::CreateReplacement(RTRange, "void")
9189	: FixItHint());
9190	D.setInvalidType();
9191	}
9192
9193	llvm::SmallPtrSet<const Type *, 16> ValidTypes;
9194	for (auto Param : NewFD->parameters())
9195	checkIsValidOpenCLKernelParameter(*this, D, Param, ValidTypes);
9196	}
9197	for (const ParmVarDecl *Param : NewFD->parameters()) {
9198	QualType PT = Param->getType();
9199
9200	// OpenCL 2.0 pipe restrictions forbids pipe packet types to be non-value
9201	// types.
9202	if (getLangOpts().OpenCLVersion >= 200) {
9203	if(const PipeType *PipeTy = PT->getAs<PipeType>()) {
9204	QualType ElemTy = PipeTy->getElementType();
9205	if (ElemTy->isReferenceType() \|\| ElemTy->isPointerType()) {
9206	Diag(Param->getTypeSpecStartLoc(), diag::err_reference_pipe_type );
9207	D.setInvalidType();
9208	}
9209	}
9210	}
9211	}
9212
9213	// Here we have an function template explicit specialization at class scope.
9214	// The actual specialization will be postponed to template instatiation
9215	// time via the ClassScopeFunctionSpecializationDecl node.
9216	if (isDependentClassScopeExplicitSpecialization) {
9217	ClassScopeFunctionSpecializationDecl *NewSpec =
9218	ClassScopeFunctionSpecializationDecl::Create(
9219	Context, CurContext, NewFD->getLocation(),
9220	cast<CXXMethodDecl>(NewFD),
9221	HasExplicitTemplateArgs, TemplateArgs);
9222	CurContext->addDecl(NewSpec);
9223	AddToScope = false;
9224	}
9225
9226	// Diagnose availability attributes. Availability cannot be used on functions
9227	// that are run during load/unload.
9228	if (const auto *attr = NewFD->getAttr<AvailabilityAttr>()) {
9229	if (NewFD->hasAttr<ConstructorAttr>()) {
9230	Diag(attr->getLocation(), diag::warn_availability_on_static_initializer)
9231	<< 1;
9232	NewFD->dropAttr<AvailabilityAttr>();
9233	}
9234	if (NewFD->hasAttr<DestructorAttr>()) {
9235	Diag(attr->getLocation(), diag::warn_availability_on_static_initializer)
9236	<< 2;
9237	NewFD->dropAttr<AvailabilityAttr>();
9238	}
9239	}
9240
9241	return NewFD;
9242	}
9243
9244	/// Return a CodeSegAttr from a containing class. The Microsoft docs say
9245	/// when __declspec(code_seg) "is applied to a class, all member functions of
9246	/// the class and nested classes -- this includes compiler-generated special
9247	/// member functions -- are put in the specified segment."
9248	/// The actual behavior is a little more complicated. The Microsoft compiler
9249	/// won't check outer classes if there is an active value from #pragma code_seg.
9250	/// The CodeSeg is always applied from the direct parent but only from outer
9251	/// classes when the #pragma code_seg stack is empty. See:
9252	/// https://reviews.llvm.org/D22931, the Microsoft feedback page is no longer
9253	/// available since MS has removed the page.
9254	static Attr getImplicitCodeSegAttrFromClass(Sema &S, const FunctionDecl FD) {
9255	const auto *Method = dyn_cast<CXXMethodDecl>(FD);
9256	if (!Method)
9257	return nullptr;
9258	const CXXRecordDecl *Parent = Method->getParent();
9259	if (const auto *SAttr = Parent->getAttr<CodeSegAttr>()) {
9260	Attr *NewAttr = SAttr->clone(S.getASTContext());
9261	NewAttr->setImplicit(true);
9262	return NewAttr;
9263	}
9264
9265	// The Microsoft compiler won't check outer classes for the CodeSeg
9266	// when the #pragma code_seg stack is active.
9267	if (S.CodeSegStack.CurrentValue)
9268	return nullptr;
9269
9270	while ((Parent = dyn_cast<CXXRecordDecl>(Parent->getParent()))) {
9271	if (const auto *SAttr = Parent->getAttr<CodeSegAttr>()) {
9272	Attr *NewAttr = SAttr->clone(S.getASTContext());
9273	NewAttr->setImplicit(true);
9274	return NewAttr;
9275	}
9276	}
9277	return nullptr;
9278	}
9279
9280	/// Returns an implicit CodeSegAttr if a __declspec(code_seg) is found on a
9281	/// containing class. Otherwise it will return implicit SectionAttr if the
9282	/// function is a definition and there is an active value on CodeSegStack
9283	/// (from the current #pragma code-seg value).
9284	///
9285	/// \param FD Function being declared.
9286	/// \param IsDefinition Whether it is a definition or just a declarartion.
9287	/// \returns A CodeSegAttr or SectionAttr to apply to the function or
9288	/// nullptr if no attribute should be added.
9289	Attr Sema::getImplicitCodeSegOrSectionAttrForFunction(const FunctionDecl FD,
9290	bool IsDefinition) {
9291	if (Attr A = getImplicitCodeSegAttrFromClass(this, FD))
9292	return A;
9293	if (!FD->hasAttr<SectionAttr>() && IsDefinition &&
9294	CodeSegStack.CurrentValue) {
9295	return SectionAttr::CreateImplicit(getASTContext(),
9296	SectionAttr::Declspec_allocate,
9297	CodeSegStack.CurrentValue->getString(),
9298	CodeSegStack.CurrentPragmaLocation);
9299	}
9300	return nullptr;
9301	}
9302
9303	/// Determines if we can perform a correct type check for \p D as a
9304	/// redeclaration of \p PrevDecl. If not, we can generally still perform a
9305	/// best-effort check.
9306	///
9307	/// \param NewD The new declaration.
9308	/// \param OldD The old declaration.
9309	/// \param NewT The portion of the type of the new declaration to check.
9310	/// \param OldT The portion of the type of the old declaration to check.
9311	bool Sema::canFullyTypeCheckRedeclaration(ValueDecl NewD, ValueDecl OldD,
9312	QualType NewT, QualType OldT) {
9313	if (!NewD->getLexicalDeclContext()->isDependentContext())
9314	return true;
9315
9316	// For dependently-typed local extern declarations and friends, we can't
9317	// perform a correct type check in general until instantiation:
9318	//
9319	// int f();
9320	// template<typename T> void g() { T f(); }
9321	//
9322	// (valid if g() is only instantiated with T = int).
9323	if (NewT->isDependentType() &&
9324	(NewD->isLocalExternDecl() \|\| NewD->getFriendObjectKind()))
9325	return false;
9326
9327	// Similarly, if the previous declaration was a dependent local extern
9328	// declaration, we don't really know its type yet.
9329	if (OldT->isDependentType() && OldD->isLocalExternDecl())
9330	return false;
9331
9332	return true;
9333	}
9334
9335	/// Checks if the new declaration declared in dependent context must be
9336	/// put in the same redeclaration chain as the specified declaration.
9337	///
9338	/// \param D Declaration that is checked.
9339	/// \param PrevDecl Previous declaration found with proper lookup method for the
9340	/// same declaration name.
9341	/// \returns True if D must be added to the redeclaration chain which PrevDecl
9342	/// belongs to.
9343	///
9344	bool Sema::shouldLinkDependentDeclWithPrevious(Decl D, Decl PrevDecl) {
9345	if (!D->getLexicalDeclContext()->isDependentContext())
9346	return true;
9347
9348	// Don't chain dependent friend function definitions until instantiation, to
9349	// permit cases like
9350	//
9351	// void func();
9352	// template<typename T> class C1 { friend void func() {} };
9353	// template<typename T> class C2 { friend void func() {} };
9354	//
9355	// ... which is valid if only one of C1 and C2 is ever instantiated.
9356	//
9357	// FIXME: This need only apply to function definitions. For now, we proxy
9358	// this by checking for a file-scope function. We do not want this to apply
9359	// to friend declarations nominating member functions, because that gets in
9360	// the way of access checks.
9361	if (D->getFriendObjectKind() && D->getDeclContext()->isFileContext())
9362	return false;
9363
9364	auto *VD = dyn_cast<ValueDecl>(D);
9365	auto *PrevVD = dyn_cast<ValueDecl>(PrevDecl);
9366	return !VD \|\| !PrevVD \|\|
9367	canFullyTypeCheckRedeclaration(VD, PrevVD, VD->getType(),
9368	PrevVD->getType());
9369	}
9370
9371	/// Check the target attribute of the function for MultiVersion
9372	/// validity.
9373	///
9374	/// Returns true if there was an error, false otherwise.
9375	static bool CheckMultiVersionValue(Sema &S, const FunctionDecl *FD) {
9376	const auto *TA = FD->getAttr<TargetAttr>();
9377	assert(TA && "MultiVersion Candidate requires a target attribute")((TA && "MultiVersion Candidate requires a target attribute" ) ? static_cast<void> (0) : __assert_fail ("TA && \"MultiVersion Candidate requires a target attribute\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 9377, __PRETTY_FUNCTION__));
9378	TargetAttr::ParsedTargetAttr ParseInfo = TA->parse();
9379	const TargetInfo &TargetInfo = S.Context.getTargetInfo();
9380	enum ErrType { Feature = 0, Architecture = 1 };
9381
9382	if (!ParseInfo.Architecture.empty() &&
9383	!TargetInfo.validateCpuIs(ParseInfo.Architecture)) {
9384	S.Diag(FD->getLocation(), diag::err_bad_multiversion_option)
9385	<< Architecture << ParseInfo.Architecture;
9386	return true;
9387	}
9388
9389	for (const auto &Feat : ParseInfo.Features) {
9390	auto BareFeat = StringRef{Feat}.substr(1);
9391	if (Feat[0] == '-') {
9392	S.Diag(FD->getLocation(), diag::err_bad_multiversion_option)
9393	<< Feature << ("no-" + BareFeat).str();
9394	return true;
9395	}
9396
9397	if (!TargetInfo.validateCpuSupports(BareFeat) \|\|
9398	!TargetInfo.isValidFeatureName(BareFeat)) {
9399	S.Diag(FD->getLocation(), diag::err_bad_multiversion_option)
9400	<< Feature << BareFeat;
9401	return true;
9402	}
9403	}
9404	return false;
9405	}
9406
9407	static bool HasNonMultiVersionAttributes(const FunctionDecl *FD,
9408	MultiVersionKind MVType) {
9409	for (const Attr *A : FD->attrs()) {
9410	switch (A->getKind()) {
9411	case attr::CPUDispatch:
9412	case attr::CPUSpecific:
9413	if (MVType != MultiVersionKind::CPUDispatch &&
9414	MVType != MultiVersionKind::CPUSpecific)
9415	return true;
9416	break;
9417	case attr::Target:
9418	if (MVType != MultiVersionKind::Target)
9419	return true;
9420	break;
9421	default:
9422	return true;
9423	}
9424	}
9425	return false;
9426	}
9427
9428	static bool CheckMultiVersionAdditionalRules(Sema &S, const FunctionDecl *OldFD,
9429	const FunctionDecl *NewFD,
9430	bool CausesMV,
9431	MultiVersionKind MVType) {
9432	enum DoesntSupport {
9433	FuncTemplates = 0,
9434	VirtFuncs = 1,
9435	DeducedReturn = 2,
9436	Constructors = 3,
9437	Destructors = 4,
9438	DeletedFuncs = 5,
9439	DefaultedFuncs = 6,
9440	ConstexprFuncs = 7,
9441	};
9442	enum Different {
9443	CallingConv = 0,
9444	ReturnType = 1,
9445	ConstexprSpec = 2,
9446	InlineSpec = 3,
9447	StorageClass = 4,
9448	Linkage = 5
9449	};
9450
9451	bool IsCPUSpecificCPUDispatchMVType =
9452	MVType == MultiVersionKind::CPUDispatch \|\|
9453	MVType == MultiVersionKind::CPUSpecific;
9454
9455	if (OldFD && !OldFD->getType()->getAs<FunctionProtoType>()) {
9456	S.Diag(OldFD->getLocation(), diag::err_multiversion_noproto);
9457	S.Diag(NewFD->getLocation(), diag::note_multiversioning_caused_here);
9458	return true;
9459	}
9460
9461	if (!NewFD->getType()->getAs<FunctionProtoType>())
9462	return S.Diag(NewFD->getLocation(), diag::err_multiversion_noproto);
9463
9464	if (!S.getASTContext().getTargetInfo().supportsMultiVersioning()) {
9465	S.Diag(NewFD->getLocation(), diag::err_multiversion_not_supported);
9466	if (OldFD)
9467	S.Diag(OldFD->getLocation(), diag::note_previous_declaration);
9468	return true;
9469	}
9470
9471	// For now, disallow all other attributes. These should be opt-in, but
9472	// an analysis of all of them is a future FIXME.
9473	if (CausesMV && OldFD && HasNonMultiVersionAttributes(OldFD, MVType)) {
9474	S.Diag(OldFD->getLocation(), diag::err_multiversion_no_other_attrs)
9475	<< IsCPUSpecificCPUDispatchMVType;
9476	S.Diag(NewFD->getLocation(), diag::note_multiversioning_caused_here);
9477	return true;
9478	}
9479
9480	if (HasNonMultiVersionAttributes(NewFD, MVType))
9481	return S.Diag(NewFD->getLocation(), diag::err_multiversion_no_other_attrs)
9482	<< IsCPUSpecificCPUDispatchMVType;
9483
9484	if (NewFD->getTemplatedKind() == FunctionDecl::TK_FunctionTemplate)
9485	return S.Diag(NewFD->getLocation(), diag::err_multiversion_doesnt_support)
9486	<< IsCPUSpecificCPUDispatchMVType << FuncTemplates;
9487
9488	if (const auto *NewCXXFD = dyn_cast<CXXMethodDecl>(NewFD)) {
9489	if (NewCXXFD->isVirtual())
9490	return S.Diag(NewCXXFD->getLocation(),
9491	diag::err_multiversion_doesnt_support)
9492	<< IsCPUSpecificCPUDispatchMVType << VirtFuncs;
9493
9494	if (const auto *NewCXXCtor = dyn_cast<CXXConstructorDecl>(NewFD))
9495	return S.Diag(NewCXXCtor->getLocation(),
9496	diag::err_multiversion_doesnt_support)
9497	<< IsCPUSpecificCPUDispatchMVType << Constructors;
9498
9499	if (const auto *NewCXXDtor = dyn_cast<CXXDestructorDecl>(NewFD))
9500	return S.Diag(NewCXXDtor->getLocation(),
9501	diag::err_multiversion_doesnt_support)
9502	<< IsCPUSpecificCPUDispatchMVType << Destructors;
9503	}
9504
9505	if (NewFD->isDeleted())
9506	return S.Diag(NewFD->getLocation(), diag::err_multiversion_doesnt_support)
9507	<< IsCPUSpecificCPUDispatchMVType << DeletedFuncs;
9508
9509	if (NewFD->isDefaulted())
9510	return S.Diag(NewFD->getLocation(), diag::err_multiversion_doesnt_support)
9511	<< IsCPUSpecificCPUDispatchMVType << DefaultedFuncs;
9512
9513	if (NewFD->isConstexpr() && (MVType == MultiVersionKind::CPUDispatch \|\|
9514	MVType == MultiVersionKind::CPUSpecific))
9515	return S.Diag(NewFD->getLocation(), diag::err_multiversion_doesnt_support)
9516	<< IsCPUSpecificCPUDispatchMVType << ConstexprFuncs;
9517
9518	QualType NewQType = S.getASTContext().getCanonicalType(NewFD->getType());
9519	const auto *NewType = cast<FunctionType>(NewQType);
9520	QualType NewReturnType = NewType->getReturnType();
9521
9522	if (NewReturnType->isUndeducedType())
9523	return S.Diag(NewFD->getLocation(), diag::err_multiversion_doesnt_support)
9524	<< IsCPUSpecificCPUDispatchMVType << DeducedReturn;
9525
9526	// Only allow transition to MultiVersion if it hasn't been used.
9527	if (OldFD && CausesMV && OldFD->isUsed(false))
9528	return S.Diag(NewFD->getLocation(), diag::err_multiversion_after_used);
9529
9530	// Ensure the return type is identical.
9531	if (OldFD) {
9532	QualType OldQType = S.getASTContext().getCanonicalType(OldFD->getType());
9533	const auto *OldType = cast<FunctionType>(OldQType);
9534	FunctionType::ExtInfo OldTypeInfo = OldType->getExtInfo();
9535	FunctionType::ExtInfo NewTypeInfo = NewType->getExtInfo();
9536
9537	if (OldTypeInfo.getCC() != NewTypeInfo.getCC())
9538	return S.Diag(NewFD->getLocation(), diag::err_multiversion_diff)
9539	<< CallingConv;
9540
9541	QualType OldReturnType = OldType->getReturnType();
9542
9543	if (OldReturnType != NewReturnType)
9544	return S.Diag(NewFD->getLocation(), diag::err_multiversion_diff)
9545	<< ReturnType;
9546
9547	if (OldFD->isConstexpr() != NewFD->isConstexpr())
9548	return S.Diag(NewFD->getLocation(), diag::err_multiversion_diff)
9549	<< ConstexprSpec;
9550
9551	if (OldFD->isInlineSpecified() != NewFD->isInlineSpecified())
9552	return S.Diag(NewFD->getLocation(), diag::err_multiversion_diff)
9553	<< InlineSpec;
9554
9555	if (OldFD->getStorageClass() != NewFD->getStorageClass())
9556	return S.Diag(NewFD->getLocation(), diag::err_multiversion_diff)
9557	<< StorageClass;
9558
9559	if (OldFD->isExternC() != NewFD->isExternC())
9560	return S.Diag(NewFD->getLocation(), diag::err_multiversion_diff)
9561	<< Linkage;
9562
9563	if (S.CheckEquivalentExceptionSpec(
9564	OldFD->getType()->getAs<FunctionProtoType>(), OldFD->getLocation(),
9565	NewFD->getType()->getAs<FunctionProtoType>(), NewFD->getLocation()))
9566	return true;
9567	}
9568	return false;
9569	}
9570
9571	/// Check the validity of a multiversion function declaration that is the
9572	/// first of its kind. Also sets the multiversion'ness' of the function itself.
9573	///
9574	/// This sets NewFD->isInvalidDecl() to true if there was an error.
9575	///
9576	/// Returns true if there was an error, false otherwise.
9577	static bool CheckMultiVersionFirstFunction(Sema &S, FunctionDecl *FD,
9578	MultiVersionKind MVType,
9579	const TargetAttr *TA,
9580	const CPUDispatchAttr *CPUDisp,
9581	const CPUSpecificAttr *CPUSpec) {
9582	assert(MVType != MultiVersionKind::None &&((MVType != MultiVersionKind::None && "Function lacks multiversion attribute" ) ? static_cast<void> (0) : __assert_fail ("MVType != MultiVersionKind::None && \"Function lacks multiversion attribute\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 9583, __PRETTY_FUNCTION__))
9583	"Function lacks multiversion attribute")((MVType != MultiVersionKind::None && "Function lacks multiversion attribute" ) ? static_cast<void> (0) : __assert_fail ("MVType != MultiVersionKind::None && \"Function lacks multiversion attribute\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 9583, __PRETTY_FUNCTION__));
9584
9585	// Target only causes MV if it is default, otherwise this is a normal
9586	// function.
9587	if (MVType == MultiVersionKind::Target && !TA->isDefaultVersion())
9588	return false;
9589
9590	if (MVType == MultiVersionKind::Target && CheckMultiVersionValue(S, FD)) {
9591	FD->setInvalidDecl();
9592	return true;
9593	}
9594
9595	if (CheckMultiVersionAdditionalRules(S, nullptr, FD, true, MVType)) {
9596	FD->setInvalidDecl();
9597	return true;
9598	}
9599
9600	FD->setIsMultiVersion();
9601	return false;
9602	}
9603
9604	static bool PreviousDeclsHaveMultiVersionAttribute(const FunctionDecl *FD) {
9605	for (const Decl *D = FD->getPreviousDecl(); D; D = D->getPreviousDecl()) {
9606	if (D->getAsFunction()->getMultiVersionKind() != MultiVersionKind::None)
9607	return true;
9608	}
9609
9610	return false;
9611	}
9612
9613	static bool CheckTargetCausesMultiVersioning(
9614	Sema &S, FunctionDecl OldFD, FunctionDecl NewFD, const TargetAttr *NewTA,
9615	bool &Redeclaration, NamedDecl *&OldDecl, bool &MergeTypeWithPrevious,
9616	LookupResult &Previous) {
9617	const auto *OldTA = OldFD->getAttr<TargetAttr>();
9618	TargetAttr::ParsedTargetAttr NewParsed = NewTA->parse();
9619	// Sort order doesn't matter, it just needs to be consistent.
9620	llvm::sort(NewParsed.Features);
9621
9622	// If the old decl is NOT MultiVersioned yet, and we don't cause that
9623	// to change, this is a simple redeclaration.
9624	if (!NewTA->isDefaultVersion() &&
9625	(!OldTA \|\| OldTA->getFeaturesStr() == NewTA->getFeaturesStr()))
9626	return false;
9627
9628	// Otherwise, this decl causes MultiVersioning.
9629	if (!S.getASTContext().getTargetInfo().supportsMultiVersioning()) {
9630	S.Diag(NewFD->getLocation(), diag::err_multiversion_not_supported);
9631	S.Diag(OldFD->getLocation(), diag::note_previous_declaration);
9632	NewFD->setInvalidDecl();
9633	return true;
9634	}
9635
9636	if (CheckMultiVersionAdditionalRules(S, OldFD, NewFD, true,
9637	MultiVersionKind::Target)) {
9638	NewFD->setInvalidDecl();
9639	return true;
9640	}
9641
9642	if (CheckMultiVersionValue(S, NewFD)) {
9643	NewFD->setInvalidDecl();
9644	return true;
9645	}
9646
9647	// If this is 'default', permit the forward declaration.
9648	if (!OldFD->isMultiVersion() && !OldTA && NewTA->isDefaultVersion()) {
9649	Redeclaration = true;
9650	OldDecl = OldFD;
9651	OldFD->setIsMultiVersion();
9652	NewFD->setIsMultiVersion();
9653	return false;
9654	}
9655
9656	if (CheckMultiVersionValue(S, OldFD)) {
9657	S.Diag(NewFD->getLocation(), diag::note_multiversioning_caused_here);
9658	NewFD->setInvalidDecl();
9659	return true;
9660	}
9661
9662	TargetAttr::ParsedTargetAttr OldParsed =
9663	OldTA->parse(std::less<std::string>());
9664
9665	if (OldParsed == NewParsed) {
9666	S.Diag(NewFD->getLocation(), diag::err_multiversion_duplicate);
9667	S.Diag(OldFD->getLocation(), diag::note_previous_declaration);
9668	NewFD->setInvalidDecl();
9669	return true;
9670	}
9671
9672	for (const auto *FD : OldFD->redecls()) {
9673	const auto *CurTA = FD->getAttr<TargetAttr>();
9674	// We allow forward declarations before ANY multiversioning attributes, but
9675	// nothing after the fact.
9676	if (PreviousDeclsHaveMultiVersionAttribute(FD) &&
9677	(!CurTA \|\| CurTA->isInherited())) {
9678	S.Diag(FD->getLocation(), diag::err_multiversion_required_in_redecl)
9679	<< 0;
9680	S.Diag(NewFD->getLocation(), diag::note_multiversioning_caused_here);
9681	NewFD->setInvalidDecl();
9682	return true;
9683	}
9684	}
9685
9686	OldFD->setIsMultiVersion();
9687	NewFD->setIsMultiVersion();
9688	Redeclaration = false;
9689	MergeTypeWithPrevious = false;
9690	OldDecl = nullptr;
9691	Previous.clear();
9692	return false;
9693	}
9694
9695	/// Check the validity of a new function declaration being added to an existing
9696	/// multiversioned declaration collection.
9697	static bool CheckMultiVersionAdditionalDecl(
9698	Sema &S, FunctionDecl OldFD, FunctionDecl NewFD,
9699	MultiVersionKind NewMVType, const TargetAttr *NewTA,
9700	const CPUDispatchAttr NewCPUDisp, const CPUSpecificAttr NewCPUSpec,
9701	bool &Redeclaration, NamedDecl *&OldDecl, bool &MergeTypeWithPrevious,
9702	LookupResult &Previous) {
9703
9704	MultiVersionKind OldMVType = OldFD->getMultiVersionKind();
9705	// Disallow mixing of multiversioning types.
9706	if ((OldMVType == MultiVersionKind::Target &&
9707	NewMVType != MultiVersionKind::Target) \|\|
9708	(NewMVType == MultiVersionKind::Target &&
9709	OldMVType != MultiVersionKind::Target)) {
9710	S.Diag(NewFD->getLocation(), diag::err_multiversion_types_mixed);
9711	S.Diag(OldFD->getLocation(), diag::note_previous_declaration);
9712	NewFD->setInvalidDecl();
9713	return true;
9714	}
9715
9716	TargetAttr::ParsedTargetAttr NewParsed;
9717	if (NewTA) {
9718	NewParsed = NewTA->parse();
9719	llvm::sort(NewParsed.Features);
9720	}
9721
9722	bool UseMemberUsingDeclRules =
9723	S.CurContext->isRecord() && !NewFD->getFriendObjectKind();
9724
9725	// Next, check ALL non-overloads to see if this is a redeclaration of a
9726	// previous member of the MultiVersion set.
9727	for (NamedDecl *ND : Previous) {
9728	FunctionDecl *CurFD = ND->getAsFunction();
9729	if (!CurFD)
9730	continue;
9731	if (S.IsOverload(NewFD, CurFD, UseMemberUsingDeclRules))
9732	continue;
9733
9734	if (NewMVType == MultiVersionKind::Target) {
9735	const auto *CurTA = CurFD->getAttr<TargetAttr>();
9736	if (CurTA->getFeaturesStr() == NewTA->getFeaturesStr()) {
9737	NewFD->setIsMultiVersion();
9738	Redeclaration = true;
9739	OldDecl = ND;
9740	return false;
9741	}
9742
9743	TargetAttr::ParsedTargetAttr CurParsed =
9744	CurTA->parse(std::less<std::string>());
9745	if (CurParsed == NewParsed) {
9746	S.Diag(NewFD->getLocation(), diag::err_multiversion_duplicate);
9747	S.Diag(CurFD->getLocation(), diag::note_previous_declaration);
9748	NewFD->setInvalidDecl();
9749	return true;
9750	}
9751	} else {
9752	const auto *CurCPUSpec = CurFD->getAttr<CPUSpecificAttr>();
9753	const auto *CurCPUDisp = CurFD->getAttr<CPUDispatchAttr>();
9754	// Handle CPUDispatch/CPUSpecific versions.
9755	// Only 1 CPUDispatch function is allowed, this will make it go through
9756	// the redeclaration errors.
9757	if (NewMVType == MultiVersionKind::CPUDispatch &&
9758	CurFD->hasAttr<CPUDispatchAttr>()) {
9759	if (CurCPUDisp->cpus_size() == NewCPUDisp->cpus_size() &&
9760	std::equal(
9761	CurCPUDisp->cpus_begin(), CurCPUDisp->cpus_end(),
9762	NewCPUDisp->cpus_begin(),
9763	[](const IdentifierInfo Cur, const IdentifierInfo New) {
9764	return Cur->getName() == New->getName();
9765	})) {
9766	NewFD->setIsMultiVersion();
9767	Redeclaration = true;
9768	OldDecl = ND;
9769	return false;
9770	}
9771
9772	// If the declarations don't match, this is an error condition.
9773	S.Diag(NewFD->getLocation(), diag::err_cpu_dispatch_mismatch);
9774	S.Diag(CurFD->getLocation(), diag::note_previous_declaration);
9775	NewFD->setInvalidDecl();
9776	return true;
9777	}
9778	if (NewMVType == MultiVersionKind::CPUSpecific && CurCPUSpec) {
9779
9780	if (CurCPUSpec->cpus_size() == NewCPUSpec->cpus_size() &&
9781	std::equal(
9782	CurCPUSpec->cpus_begin(), CurCPUSpec->cpus_end(),
9783	NewCPUSpec->cpus_begin(),
9784	[](const IdentifierInfo Cur, const IdentifierInfo New) {
9785	return Cur->getName() == New->getName();
9786	})) {
9787	NewFD->setIsMultiVersion();
9788	Redeclaration = true;
9789	OldDecl = ND;
9790	return false;
9791	}
9792
9793	// Only 1 version of CPUSpecific is allowed for each CPU.
9794	for (const IdentifierInfo *CurII : CurCPUSpec->cpus()) {
9795	for (const IdentifierInfo *NewII : NewCPUSpec->cpus()) {
9796	if (CurII == NewII) {
9797	S.Diag(NewFD->getLocation(), diag::err_cpu_specific_multiple_defs)
9798	<< NewII;
9799	S.Diag(CurFD->getLocation(), diag::note_previous_declaration);
9800	NewFD->setInvalidDecl();
9801	return true;
9802	}
9803	}
9804	}
9805	}
9806	// If the two decls aren't the same MVType, there is no possible error
9807	// condition.
9808	}
9809	}
9810
9811	// Else, this is simply a non-redecl case. Checking the 'value' is only
9812	// necessary in the Target case, since The CPUSpecific/Dispatch cases are
9813	// handled in the attribute adding step.
9814	if (NewMVType == MultiVersionKind::Target &&
9815	CheckMultiVersionValue(S, NewFD)) {
9816	NewFD->setInvalidDecl();
9817	return true;
9818	}
9819
9820	if (CheckMultiVersionAdditionalRules(S, OldFD, NewFD, false, NewMVType)) {
9821	NewFD->setInvalidDecl();
9822	return true;
9823	}
9824
9825	// Permit forward declarations in the case where these two are compatible.
9826	if (!OldFD->isMultiVersion()) {
9827	OldFD->setIsMultiVersion();
9828	NewFD->setIsMultiVersion();
9829	Redeclaration = true;
9830	OldDecl = OldFD;
9831	return false;
9832	}
9833
9834	NewFD->setIsMultiVersion();
9835	Redeclaration = false;
9836	MergeTypeWithPrevious = false;
9837	OldDecl = nullptr;
9838	Previous.clear();
9839	return false;
9840	}
9841
9842
9843	/// Check the validity of a mulitversion function declaration.
9844	/// Also sets the multiversion'ness' of the function itself.
9845	///
9846	/// This sets NewFD->isInvalidDecl() to true if there was an error.
9847	///
9848	/// Returns true if there was an error, false otherwise.
9849	static bool CheckMultiVersionFunction(Sema &S, FunctionDecl *NewFD,
9850	bool &Redeclaration, NamedDecl *&OldDecl,
9851	bool &MergeTypeWithPrevious,
9852	LookupResult &Previous) {
9853	const auto *NewTA = NewFD->getAttr<TargetAttr>();
9854	const auto *NewCPUDisp = NewFD->getAttr<CPUDispatchAttr>();
9855	const auto *NewCPUSpec = NewFD->getAttr<CPUSpecificAttr>();
9856
9857	// Mixing Multiversioning types is prohibited.
9858	if ((NewTA && NewCPUDisp) \|\| (NewTA && NewCPUSpec) \|\|
9859	(NewCPUDisp && NewCPUSpec)) {
9860	S.Diag(NewFD->getLocation(), diag::err_multiversion_types_mixed);
9861	NewFD->setInvalidDecl();
9862	return true;
9863	}
9864
9865	MultiVersionKind MVType = NewFD->getMultiVersionKind();
9866
9867	// Main isn't allowed to become a multiversion function, however it IS
9868	// permitted to have 'main' be marked with the 'target' optimization hint.
9869	if (NewFD->isMain()) {
9870	if ((MVType == MultiVersionKind::Target && NewTA->isDefaultVersion()) \|\|
9871	MVType == MultiVersionKind::CPUDispatch \|\|
9872	MVType == MultiVersionKind::CPUSpecific) {
9873	S.Diag(NewFD->getLocation(), diag::err_multiversion_not_allowed_on_main);
9874	NewFD->setInvalidDecl();
9875	return true;
9876	}
9877	return false;
9878	}
9879
9880	if (!OldDecl \|\| !OldDecl->getAsFunction() \|\|
9881	OldDecl->getDeclContext()->getRedeclContext() !=
9882	NewFD->getDeclContext()->getRedeclContext()) {
9883	// If there's no previous declaration, AND this isn't attempting to cause
9884	// multiversioning, this isn't an error condition.
9885	if (MVType == MultiVersionKind::None)
9886	return false;
9887	return CheckMultiVersionFirstFunction(S, NewFD, MVType, NewTA, NewCPUDisp,
9888	NewCPUSpec);
9889	}
9890
9891	FunctionDecl *OldFD = OldDecl->getAsFunction();
9892
9893	if (!OldFD->isMultiVersion() && MVType == MultiVersionKind::None)
9894	return false;
9895
9896	if (OldFD->isMultiVersion() && MVType == MultiVersionKind::None) {
9897	S.Diag(NewFD->getLocation(), diag::err_multiversion_required_in_redecl)
9898	<< (OldFD->getMultiVersionKind() != MultiVersionKind::Target);
9899	NewFD->setInvalidDecl();
9900	return true;
9901	}
9902
9903	// Handle the target potentially causes multiversioning case.
9904	if (!OldFD->isMultiVersion() && MVType == MultiVersionKind::Target)
9905	return CheckTargetCausesMultiVersioning(S, OldFD, NewFD, NewTA,
9906	Redeclaration, OldDecl,
9907	MergeTypeWithPrevious, Previous);
9908
9909	// At this point, we have a multiversion function decl (in OldFD) AND an
9910	// appropriate attribute in the current function decl. Resolve that these are
9911	// still compatible with previous declarations.
9912	return CheckMultiVersionAdditionalDecl(
9913	S, OldFD, NewFD, MVType, NewTA, NewCPUDisp, NewCPUSpec, Redeclaration,
9914	OldDecl, MergeTypeWithPrevious, Previous);
9915	}
9916
9917	/// Perform semantic checking of a new function declaration.
9918	///
9919	/// Performs semantic analysis of the new function declaration
9920	/// NewFD. This routine performs all semantic checking that does not
9921	/// require the actual declarator involved in the declaration, and is
9922	/// used both for the declaration of functions as they are parsed
9923	/// (called via ActOnDeclarator) and for the declaration of functions
9924	/// that have been instantiated via C++ template instantiation (called
9925	/// via InstantiateDecl).
9926	///
9927	/// \param IsMemberSpecialization whether this new function declaration is
9928	/// a member specialization (that replaces any definition provided by the
9929	/// previous declaration).
9930	///
9931	/// This sets NewFD->isInvalidDecl() to true if there was an error.
9932	///
9933	/// \returns true if the function declaration is a redeclaration.
9934	bool Sema::CheckFunctionDeclaration(Scope S, FunctionDecl NewFD,
9935	LookupResult &Previous,
9936	bool IsMemberSpecialization) {
9937	assert(!NewFD->getReturnType()->isVariablyModifiedType() &&((!NewFD->getReturnType()->isVariablyModifiedType() && "Variably modified return types are not handled here") ? static_cast <void> (0) : __assert_fail ("!NewFD->getReturnType()->isVariablyModifiedType() && \"Variably modified return types are not handled here\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 9938, __PRETTY_FUNCTION__))
9938	"Variably modified return types are not handled here")((!NewFD->getReturnType()->isVariablyModifiedType() && "Variably modified return types are not handled here") ? static_cast <void> (0) : __assert_fail ("!NewFD->getReturnType()->isVariablyModifiedType() && \"Variably modified return types are not handled here\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 9938, __PRETTY_FUNCTION__));
9939
9940	// Determine whether the type of this function should be merged with
9941	// a previous visible declaration. This never happens for functions in C++,
9942	// and always happens in C if the previous declaration was visible.
9943	bool MergeTypeWithPrevious = !getLangOpts().CPlusPlus &&
9944	!Previous.isShadowed();
9945
9946	bool Redeclaration = false;
9947	NamedDecl *OldDecl = nullptr;
9948	bool MayNeedOverloadableChecks = false;
9949
9950	// Merge or overload the declaration with an existing declaration of
9951	// the same name, if appropriate.
9952	if (!Previous.empty()) {
9953	// Determine whether NewFD is an overload of PrevDecl or
9954	// a declaration that requires merging. If it's an overload,
9955	// there's no more work to do here; we'll just add the new
9956	// function to the scope.
9957	if (!AllowOverloadingOfFunction(Previous, Context, NewFD)) {
9958	NamedDecl *Candidate = Previous.getRepresentativeDecl();
9959	if (shouldLinkPossiblyHiddenDecl(Candidate, NewFD)) {
9960	Redeclaration = true;
9961	OldDecl = Candidate;
9962	}
9963	} else {
9964	MayNeedOverloadableChecks = true;
9965	switch (CheckOverload(S, NewFD, Previous, OldDecl,
9966	/NewIsUsingDecl/ false)) {
9967	case Ovl_Match:
9968	Redeclaration = true;
9969	break;
9970
9971	case Ovl_NonFunction:
9972	Redeclaration = true;
9973	break;
9974
9975	case Ovl_Overload:
9976	Redeclaration = false;
9977	break;
9978	}
9979	}
9980	}
9981
9982	// Check for a previous extern "C" declaration with this name.
9983	if (!Redeclaration &&
9984	checkForConflictWithNonVisibleExternC(*this, NewFD, Previous)) {
9985	if (!Previous.empty()) {
9986	// This is an extern "C" declaration with the same name as a previous
9987	// declaration, and thus redeclares that entity...
9988	Redeclaration = true;
9989	OldDecl = Previous.getFoundDecl();
9990	MergeTypeWithPrevious = false;
9991
9992	// ... except in the presence of __attribute__((overloadable)).
9993	if (OldDecl->hasAttr<OverloadableAttr>() \|\|
9994	NewFD->hasAttr<OverloadableAttr>()) {
9995	if (IsOverload(NewFD, cast<FunctionDecl>(OldDecl), false)) {
9996	MayNeedOverloadableChecks = true;
9997	Redeclaration = false;
9998	OldDecl = nullptr;
9999	}
10000	}
10001	}
10002	}
10003
10004	if (CheckMultiVersionFunction(*this, NewFD, Redeclaration, OldDecl,
10005	MergeTypeWithPrevious, Previous))
10006	return Redeclaration;
10007
10008	// C++11 [dcl.constexpr]p8:
10009	// A constexpr specifier for a non-static member function that is not
10010	// a constructor declares that member function to be const.
10011	//
10012	// This needs to be delayed until we know whether this is an out-of-line
10013	// definition of a static member function.
10014	//
10015	// This rule is not present in C++1y, so we produce a backwards
10016	// compatibility warning whenever it happens in C++11.
10017	CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(NewFD);
10018	if (!getLangOpts().CPlusPlus14 && MD && MD->isConstexpr() &&
10019	!MD->isStatic() && !isa<CXXConstructorDecl>(MD) &&
10020	(MD->getTypeQualifiers() & Qualifiers::Const) == 0) {
10021	CXXMethodDecl *OldMD = nullptr;
10022	if (OldDecl)
10023	OldMD = dyn_cast_or_null<CXXMethodDecl>(OldDecl->getAsFunction());
10024	if (!OldMD \|\| !OldMD->isStatic()) {
10025	const FunctionProtoType *FPT =
10026	MD->getType()->castAs<FunctionProtoType>();
10027	FunctionProtoType::ExtProtoInfo EPI = FPT->getExtProtoInfo();
10028	EPI.TypeQuals \|= Qualifiers::Const;
10029	MD->setType(Context.getFunctionType(FPT->getReturnType(),
10030	FPT->getParamTypes(), EPI));
10031
10032	// Warn that we did this, if we're not performing template instantiation.
10033	// In that case, we'll have warned already when the template was defined.
10034	if (!inTemplateInstantiation()) {
10035	SourceLocation AddConstLoc;
10036	if (FunctionTypeLoc FTL = MD->getTypeSourceInfo()->getTypeLoc()
10037	.IgnoreParens().getAs<FunctionTypeLoc>())
10038	AddConstLoc = getLocForEndOfToken(FTL.getRParenLoc());
10039
10040	Diag(MD->getLocation(), diag::warn_cxx14_compat_constexpr_not_const)
10041	<< FixItHint::CreateInsertion(AddConstLoc, " const");
10042	}
10043	}
10044	}
10045
10046	if (Redeclaration) {
10047	// NewFD and OldDecl represent declarations that need to be
10048	// merged.
10049	if (MergeFunctionDecl(NewFD, OldDecl, S, MergeTypeWithPrevious)) {
10050	NewFD->setInvalidDecl();
10051	return Redeclaration;
10052	}
10053
10054	Previous.clear();
10055	Previous.addDecl(OldDecl);
10056
10057	if (FunctionTemplateDecl *OldTemplateDecl =
10058	dyn_cast<FunctionTemplateDecl>(OldDecl)) {
10059	auto *OldFD = OldTemplateDecl->getTemplatedDecl();
10060	FunctionTemplateDecl *NewTemplateDecl
10061	= NewFD->getDescribedFunctionTemplate();
10062	assert(NewTemplateDecl && "Template/non-template mismatch")((NewTemplateDecl && "Template/non-template mismatch" ) ? static_cast<void> (0) : __assert_fail ("NewTemplateDecl && \"Template/non-template mismatch\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 10062, __PRETTY_FUNCTION__));
10063
10064	// The call to MergeFunctionDecl above may have created some state in
10065	// NewTemplateDecl that needs to be merged with OldTemplateDecl before we
10066	// can add it as a redeclaration.
10067	NewTemplateDecl->mergePrevDecl(OldTemplateDecl);
10068
10069	NewFD->setPreviousDeclaration(OldFD);
10070	adjustDeclContextForDeclaratorDecl(NewFD, OldFD);
10071	if (NewFD->isCXXClassMember()) {
10072	NewFD->setAccess(OldTemplateDecl->getAccess());
10073	NewTemplateDecl->setAccess(OldTemplateDecl->getAccess());
10074	}
10075
10076	// If this is an explicit specialization of a member that is a function
10077	// template, mark it as a member specialization.
10078	if (IsMemberSpecialization &&
10079	NewTemplateDecl->getInstantiatedFromMemberTemplate()) {
10080	NewTemplateDecl->setMemberSpecialization();
10081	assert(OldTemplateDecl->isMemberSpecialization())((OldTemplateDecl->isMemberSpecialization()) ? static_cast <void> (0) : __assert_fail ("OldTemplateDecl->isMemberSpecialization()" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 10081, __PRETTY_FUNCTION__));
10082	// Explicit specializations of a member template do not inherit deleted
10083	// status from the parent member template that they are specializing.
10084	if (OldFD->isDeleted()) {
10085	// FIXME: This assert will not hold in the presence of modules.
10086	assert(OldFD->getCanonicalDecl() == OldFD)((OldFD->getCanonicalDecl() == OldFD) ? static_cast<void > (0) : __assert_fail ("OldFD->getCanonicalDecl() == OldFD" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 10086, __PRETTY_FUNCTION__));
10087	// FIXME: We need an update record for this AST mutation.
10088	OldFD->setDeletedAsWritten(false);
10089	}
10090	}
10091
10092	} else {
10093	if (shouldLinkDependentDeclWithPrevious(NewFD, OldDecl)) {
10094	auto *OldFD = cast<FunctionDecl>(OldDecl);
10095	// This needs to happen first so that 'inline' propagates.
10096	NewFD->setPreviousDeclaration(OldFD);
10097	adjustDeclContextForDeclaratorDecl(NewFD, OldFD);
10098	if (NewFD->isCXXClassMember())
10099	NewFD->setAccess(OldFD->getAccess());
10100	}
10101	}
10102	} else if (!getLangOpts().CPlusPlus && MayNeedOverloadableChecks &&
10103	!NewFD->getAttr<OverloadableAttr>()) {
10104	assert((Previous.empty() \|\|(((Previous.empty() \|\| llvm::any_of(Previous, [](const NamedDecl ND) { return ND->hasAttr<OverloadableAttr>(); })) && "Non-redecls shouldn't happen without overloadable present") ? static_cast<void> (0) : __assert_fail ("(Previous.empty() \|\| llvm::any_of(Previous, [](const NamedDecl ND) { return ND->hasAttr<OverloadableAttr>(); })) && \"Non-redecls shouldn't happen without overloadable present\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 10109, __PRETTY_FUNCTION__))
10105	llvm::any_of(Previous,(((Previous.empty() \|\| llvm::any_of(Previous, [](const NamedDecl ND) { return ND->hasAttr<OverloadableAttr>(); })) && "Non-redecls shouldn't happen without overloadable present") ? static_cast<void> (0) : __assert_fail ("(Previous.empty() \|\| llvm::any_of(Previous, [](const NamedDecl ND) { return ND->hasAttr<OverloadableAttr>(); })) && \"Non-redecls shouldn't happen without overloadable present\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 10109, __PRETTY_FUNCTION__))
10106	[](const NamedDecl ND) {(((Previous.empty() \|\| llvm::any_of(Previous, [](const NamedDecl ND) { return ND->hasAttr<OverloadableAttr>(); })) && "Non-redecls shouldn't happen without overloadable present") ? static_cast<void> (0) : __assert_fail ("(Previous.empty() \|\| llvm::any_of(Previous, [](const NamedDecl *ND) { return ND->hasAttr<OverloadableAttr>(); })) && \"Non-redecls shouldn't happen without overloadable present\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 10109, __PRETTY_FUNCTION__))
10107	return ND->hasAttr<OverloadableAttr>();(((Previous.empty() \|\| llvm::any_of(Previous, [](const NamedDecl ND) { return ND->hasAttr<OverloadableAttr>(); })) && "Non-redecls shouldn't happen without overloadable present") ? static_cast<void> (0) : __assert_fail ("(Previous.empty() \|\| llvm::any_of(Previous, [](const NamedDecl ND) { return ND->hasAttr<OverloadableAttr>(); })) && \"Non-redecls shouldn't happen without overloadable present\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 10109, __PRETTY_FUNCTION__))
10108	})) &&(((Previous.empty() \|\| llvm::any_of(Previous, [](const NamedDecl ND) { return ND->hasAttr<OverloadableAttr>(); })) && "Non-redecls shouldn't happen without overloadable present") ? static_cast<void> (0) : __assert_fail ("(Previous.empty() \|\| llvm::any_of(Previous, [](const NamedDecl ND) { return ND->hasAttr<OverloadableAttr>(); })) && \"Non-redecls shouldn't happen without overloadable present\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 10109, __PRETTY_FUNCTION__))
10109	"Non-redecls shouldn't happen without overloadable present")(((Previous.empty() \|\| llvm::any_of(Previous, [](const NamedDecl ND) { return ND->hasAttr<OverloadableAttr>(); })) && "Non-redecls shouldn't happen without overloadable present") ? static_cast<void> (0) : __assert_fail ("(Previous.empty() \|\| llvm::any_of(Previous, [](const NamedDecl ND) { return ND->hasAttr<OverloadableAttr>(); })) && \"Non-redecls shouldn't happen without overloadable present\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 10109, __PRETTY_FUNCTION__));
10110
10111	auto OtherUnmarkedIter = llvm::find_if(Previous, [](const NamedDecl *ND) {
10112	const auto *FD = dyn_cast<FunctionDecl>(ND);
10113	return FD && !FD->hasAttr<OverloadableAttr>();
10114	});
10115
10116	if (OtherUnmarkedIter != Previous.end()) {
10117	Diag(NewFD->getLocation(),
10118	diag::err_attribute_overloadable_multiple_unmarked_overloads);
10119	Diag((*OtherUnmarkedIter)->getLocation(),
10120	diag::note_attribute_overloadable_prev_overload)
10121	<< false;
10122
10123	NewFD->addAttr(OverloadableAttr::CreateImplicit(Context));
10124	}
10125	}
10126
10127	// Semantic checking for this function declaration (in isolation).
10128
10129	if (getLangOpts().CPlusPlus) {
10130	// C++-specific checks.
10131	if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(NewFD)) {
10132	CheckConstructor(Constructor);
10133	} else if (CXXDestructorDecl *Destructor =
10134	dyn_cast<CXXDestructorDecl>(NewFD)) {
10135	CXXRecordDecl *Record = Destructor->getParent();
10136	QualType ClassType = Context.getTypeDeclType(Record);
10137
10138	// FIXME: Shouldn't we be able to perform this check even when the class
10139	// type is dependent? Both gcc and edg can handle that.
10140	if (!ClassType->isDependentType()) {
10141	DeclarationName Name
10142	= Context.DeclarationNames.getCXXDestructorName(
10143	Context.getCanonicalType(ClassType));
10144	if (NewFD->getDeclName() != Name) {
10145	Diag(NewFD->getLocation(), diag::err_destructor_name);
10146	NewFD->setInvalidDecl();
10147	return Redeclaration;
10148	}
10149	}
10150	} else if (CXXConversionDecl *Conversion
10151	= dyn_cast<CXXConversionDecl>(NewFD)) {
10152	ActOnConversionDeclarator(Conversion);
10153	} else if (auto *Guide = dyn_cast<CXXDeductionGuideDecl>(NewFD)) {
10154	if (auto *TD = Guide->getDescribedFunctionTemplate())
10155	CheckDeductionGuideTemplate(TD);
10156
10157	// A deduction guide is not on the list of entities that can be
10158	// explicitly specialized.
10159	if (Guide->getTemplateSpecializationKind() == TSK_ExplicitSpecialization)
10160	Diag(Guide->getBeginLoc(), diag::err_deduction_guide_specialized)
10161	<< /explicit specialization/ 1;
10162	}
10163
10164	// Find any virtual functions that this function overrides.
10165	if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(NewFD)) {
10166	if (!Method->isFunctionTemplateSpecialization() &&
10167	!Method->getDescribedFunctionTemplate() &&
10168	Method->isCanonicalDecl()) {
10169	if (AddOverriddenMethods(Method->getParent(), Method)) {
10170	// If the function was marked as "static", we have a problem.
10171	if (NewFD->getStorageClass() == SC_Static) {
10172	ReportOverrides(*this, diag::err_static_overrides_virtual, Method);
10173	}
10174	}
10175	}
10176
10177	if (Method->isStatic())
10178	checkThisInStaticMemberFunctionType(Method);
10179	}
10180
10181	// Extra checking for C++ overloaded operators (C++ [over.oper]).
10182	if (NewFD->isOverloadedOperator() &&
10183	CheckOverloadedOperatorDeclaration(NewFD)) {
10184	NewFD->setInvalidDecl();
10185	return Redeclaration;
10186	}
10187
10188	// Extra checking for C++0x literal operators (C++0x [over.literal]).
10189	if (NewFD->getLiteralIdentifier() &&
10190	CheckLiteralOperatorDeclaration(NewFD)) {
10191	NewFD->setInvalidDecl();
10192	return Redeclaration;
10193	}
10194
10195	// In C++, check default arguments now that we have merged decls. Unless
10196	// the lexical context is the class, because in this case this is done
10197	// during delayed parsing anyway.
10198	if (!CurContext->isRecord())
10199	CheckCXXDefaultArguments(NewFD);
10200
10201	// If this function declares a builtin function, check the type of this
10202	// declaration against the expected type for the builtin.
10203	if (unsigned BuiltinID = NewFD->getBuiltinID()) {
10204	ASTContext::GetBuiltinTypeError Error;
10205	LookupPredefedObjCSuperType(*this, S, NewFD->getIdentifier());
10206	QualType T = Context.GetBuiltinType(BuiltinID, Error);
10207	// If the type of the builtin differs only in its exception
10208	// specification, that's OK.
10209	// FIXME: If the types do differ in this way, it would be better to
10210	// retain the 'noexcept' form of the type.
10211	if (!T.isNull() &&
10212	!Context.hasSameFunctionTypeIgnoringExceptionSpec(T,
10213	NewFD->getType()))
10214	// The type of this function differs from the type of the builtin,
10215	// so forget about the builtin entirely.
10216	Context.BuiltinInfo.forgetBuiltin(BuiltinID, Context.Idents);
10217	}
10218
10219	// If this function is declared as being extern "C", then check to see if
10220	// the function returns a UDT (class, struct, or union type) that is not C
10221	// compatible, and if it does, warn the user.
10222	// But, issue any diagnostic on the first declaration only.
10223	if (Previous.empty() && NewFD->isExternC()) {
10224	QualType R = NewFD->getReturnType();
10225	if (R->isIncompleteType() && !R->isVoidType())
10226	Diag(NewFD->getLocation(), diag::warn_return_value_udt_incomplete)
10227	<< NewFD << R;
10228	else if (!R.isPODType(Context) && !R->isVoidType() &&
10229	!R->isObjCObjectPointerType())
10230	Diag(NewFD->getLocation(), diag::warn_return_value_udt) << NewFD << R;
10231	}
10232
10233	// C++1z [dcl.fct]p6:
10234	// [...] whether the function has a non-throwing exception-specification
10235	// [is] part of the function type
10236	//
10237	// This results in an ABI break between C++14 and C++17 for functions whose
10238	// declared type includes an exception-specification in a parameter or
10239	// return type. (Exception specifications on the function itself are OK in
10240	// most cases, and exception specifications are not permitted in most other
10241	// contexts where they could make it into a mangling.)
10242	if (!getLangOpts().CPlusPlus17 && !NewFD->getPrimaryTemplate()) {
10243	auto HasNoexcept = [&](QualType T) -> bool {
10244	// Strip off declarator chunks that could be between us and a function
10245	// type. We don't need to look far, exception specifications are very
10246	// restricted prior to C++17.
10247	if (auto *RT = T->getAs<ReferenceType>())
10248	T = RT->getPointeeType();
10249	else if (T->isAnyPointerType())
10250	T = T->getPointeeType();
10251	else if (auto *MPT = T->getAs<MemberPointerType>())
10252	T = MPT->getPointeeType();
10253	if (auto *FPT = T->getAs<FunctionProtoType>())
10254	if (FPT->isNothrow())
10255	return true;
10256	return false;
10257	};
10258
10259	auto *FPT = NewFD->getType()->castAs<FunctionProtoType>();
10260	bool AnyNoexcept = HasNoexcept(FPT->getReturnType());
10261	for (QualType T : FPT->param_types())
10262	AnyNoexcept \|= HasNoexcept(T);
10263	if (AnyNoexcept)
10264	Diag(NewFD->getLocation(),
10265	diag::warn_cxx17_compat_exception_spec_in_signature)
10266	<< NewFD;
10267	}
10268
10269	if (!Redeclaration && LangOpts.CUDA)
10270	checkCUDATargetOverload(NewFD, Previous);
10271	}
10272	return Redeclaration;
10273	}
10274
10275	void Sema::CheckMain(FunctionDecl* FD, const DeclSpec& DS) {
10276	// C++11 [basic.start.main]p3:
10277	// A program that [...] declares main to be inline, static or
10278	// constexpr is ill-formed.
10279	// C11 6.7.4p4: In a hosted environment, no function specifier(s) shall
10280	// appear in a declaration of main.
10281	// static main is not an error under C99, but we should warn about it.
10282	// We accept _Noreturn main as an extension.
10283	if (FD->getStorageClass() == SC_Static)
10284	Diag(DS.getStorageClassSpecLoc(), getLangOpts().CPlusPlus
10285	? diag::err_static_main : diag::warn_static_main)
10286	<< FixItHint::CreateRemoval(DS.getStorageClassSpecLoc());
10287	if (FD->isInlineSpecified())
10288	Diag(DS.getInlineSpecLoc(), diag::err_inline_main)
10289	<< FixItHint::CreateRemoval(DS.getInlineSpecLoc());
10290	if (DS.isNoreturnSpecified()) {
10291	SourceLocation NoreturnLoc = DS.getNoreturnSpecLoc();
10292	SourceRange NoreturnRange(NoreturnLoc, getLocForEndOfToken(NoreturnLoc));
10293	Diag(NoreturnLoc, diag::ext_noreturn_main);
10294	Diag(NoreturnLoc, diag::note_main_remove_noreturn)
10295	<< FixItHint::CreateRemoval(NoreturnRange);
10296	}
10297	if (FD->isConstexpr()) {
10298	Diag(DS.getConstexprSpecLoc(), diag::err_constexpr_main)
10299	<< FixItHint::CreateRemoval(DS.getConstexprSpecLoc());
10300	FD->setConstexpr(false);
10301	}
10302
10303	if (getLangOpts().OpenCL) {
10304	Diag(FD->getLocation(), diag::err_opencl_no_main)
10305	<< FD->hasAttr<OpenCLKernelAttr>();
10306	FD->setInvalidDecl();
10307	return;
10308	}
10309
10310	QualType T = FD->getType();
10311	assert(T->isFunctionType() && "function decl is not of function type")((T->isFunctionType() && "function decl is not of function type" ) ? static_cast<void> (0) : __assert_fail ("T->isFunctionType() && \"function decl is not of function type\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 10311, __PRETTY_FUNCTION__));
10312	const FunctionType* FT = T->castAs<FunctionType>();
10313
10314	// Set default calling convention for main()
10315	if (FT->getCallConv() != CC_C) {
10316	FT = Context.adjustFunctionType(FT, FT->getExtInfo().withCallingConv(CC_C));
10317	FD->setType(QualType(FT, 0));
10318	T = Context.getCanonicalType(FD->getType());
10319	}
10320
10321	if (getLangOpts().GNUMode && !getLangOpts().CPlusPlus) {
10322	// In C with GNU extensions we allow main() to have non-integer return
10323	// type, but we should warn about the extension, and we disable the
10324	// implicit-return-zero rule.
10325
10326	// GCC in C mode accepts qualified 'int'.
10327	if (Context.hasSameUnqualifiedType(FT->getReturnType(), Context.IntTy))
10328	FD->setHasImplicitReturnZero(true);
10329	else {
10330	Diag(FD->getTypeSpecStartLoc(), diag::ext_main_returns_nonint);
10331	SourceRange RTRange = FD->getReturnTypeSourceRange();
10332	if (RTRange.isValid())
10333	Diag(RTRange.getBegin(), diag::note_main_change_return_type)
10334	<< FixItHint::CreateReplacement(RTRange, "int");
10335	}
10336	} else {
10337	// In C and C++, main magically returns 0 if you fall off the end;
10338	// set the flag which tells us that.
10339	// This is C++ [basic.start.main]p5 and C99 5.1.2.2.3.
10340
10341	// All the standards say that main() should return 'int'.
10342	if (Context.hasSameType(FT->getReturnType(), Context.IntTy))
10343	FD->setHasImplicitReturnZero(true);
10344	else {
10345	// Otherwise, this is just a flat-out error.
10346	SourceRange RTRange = FD->getReturnTypeSourceRange();
10347	Diag(FD->getTypeSpecStartLoc(), diag::err_main_returns_nonint)
10348	<< (RTRange.isValid() ? FixItHint::CreateReplacement(RTRange, "int")
10349	: FixItHint());
10350	FD->setInvalidDecl(true);
10351	}
10352	}
10353
10354	// Treat protoless main() as nullary.
10355	if (isa<FunctionNoProtoType>(FT)) return;
10356
10357	const FunctionProtoType* FTP = cast<const FunctionProtoType>(FT);
10358	unsigned nparams = FTP->getNumParams();
10359	assert(FD->getNumParams() == nparams)((FD->getNumParams() == nparams) ? static_cast<void> (0) : __assert_fail ("FD->getNumParams() == nparams", "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 10359, __PRETTY_FUNCTION__));
10360
10361	bool HasExtraParameters = (nparams > 3);
10362
10363	if (FTP->isVariadic()) {
10364	Diag(FD->getLocation(), diag::ext_variadic_main);
10365	// FIXME: if we had information about the location of the ellipsis, we
10366	// could add a FixIt hint to remove it as a parameter.
10367	}
10368
10369	// Darwin passes an undocumented fourth argument of type char**. If
10370	// other platforms start sprouting these, the logic below will start
10371	// getting shifty.
10372	if (nparams == 4 && Context.getTargetInfo().getTriple().isOSDarwin())
10373	HasExtraParameters = false;
10374
10375	if (HasExtraParameters) {
10376	Diag(FD->getLocation(), diag::err_main_surplus_args) << nparams;
10377	FD->setInvalidDecl(true);
10378	nparams = 3;
10379	}
10380
10381	// FIXME: a lot of the following diagnostics would be improved
10382	// if we had some location information about types.
10383
10384	QualType CharPP =
10385	Context.getPointerType(Context.getPointerType(Context.CharTy));
10386	QualType Expected[] = { Context.IntTy, CharPP, CharPP, CharPP };
10387
10388	for (unsigned i = 0; i < nparams; ++i) {
10389	QualType AT = FTP->getParamType(i);
10390
10391	bool mismatch = true;
10392
10393	if (Context.hasSameUnqualifiedType(AT, Expected[i]))
10394	mismatch = false;
10395	else if (Expected[i] == CharPP) {
10396	// As an extension, the following forms are okay:
10397	// char const **
10398	// char const * const *
10399	// char * const *
10400
10401	QualifierCollector qs;
10402	const PointerType* PT;
10403	if ((PT = qs.strip(AT)->getAs<PointerType>()) &&
10404	(PT = qs.strip(PT->getPointeeType())->getAs<PointerType>()) &&
10405	Context.hasSameType(QualType(qs.strip(PT->getPointeeType()), 0),
10406	Context.CharTy)) {
10407	qs.removeConst();
10408	mismatch = !qs.empty();
10409	}
10410	}
10411
10412	if (mismatch) {
10413	Diag(FD->getLocation(), diag::err_main_arg_wrong) << i << Expected[i];
10414	// TODO: suggest replacing given type with expected type
10415	FD->setInvalidDecl(true);
10416	}
10417	}
10418
10419	if (nparams == 1 && !FD->isInvalidDecl()) {
10420	Diag(FD->getLocation(), diag::warn_main_one_arg);
10421	}
10422
10423	if (!FD->isInvalidDecl() && FD->getDescribedFunctionTemplate()) {
10424	Diag(FD->getLocation(), diag::err_mainlike_template_decl) << FD;
10425	FD->setInvalidDecl();
10426	}
10427	}
10428
10429	void Sema::CheckMSVCRTEntryPoint(FunctionDecl *FD) {
10430	QualType T = FD->getType();
10431	assert(T->isFunctionType() && "function decl is not of function type")((T->isFunctionType() && "function decl is not of function type" ) ? static_cast<void> (0) : __assert_fail ("T->isFunctionType() && \"function decl is not of function type\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 10431, __PRETTY_FUNCTION__));
10432	const FunctionType *FT = T->castAs<FunctionType>();
10433
10434	// Set an implicit return of 'zero' if the function can return some integral,
10435	// enumeration, pointer or nullptr type.
10436	if (FT->getReturnType()->isIntegralOrEnumerationType() \|\|
10437	FT->getReturnType()->isAnyPointerType() \|\|
10438	FT->getReturnType()->isNullPtrType())
10439	// DllMain is exempt because a return value of zero means it failed.
10440	if (FD->getName() != "DllMain")
10441	FD->setHasImplicitReturnZero(true);
10442
10443	if (!FD->isInvalidDecl() && FD->getDescribedFunctionTemplate()) {
10444	Diag(FD->getLocation(), diag::err_mainlike_template_decl) << FD;
10445	FD->setInvalidDecl();
10446	}
10447	}
10448
10449	bool Sema::CheckForConstantInitializer(Expr *Init, QualType DclT) {
10450	// FIXME: Need strict checking. In C89, we need to check for
10451	// any assignment, increment, decrement, function-calls, or
10452	// commas outside of a sizeof. In C99, it's the same list,
10453	// except that the aforementioned are allowed in unevaluated
10454	// expressions. Everything else falls under the
10455	// "may accept other forms of constant expressions" exception.
10456	// (We never end up here for C++, so the constant expression
10457	// rules there don't matter.)
10458	const Expr *Culprit;
10459	if (Init->isConstantInitializer(Context, false, &Culprit))
10460	return false;
10461	Diag(Culprit->getExprLoc(), diag::err_init_element_not_constant)
10462	<< Culprit->getSourceRange();
10463	return true;
10464	}
10465
10466	namespace {
10467	// Visits an initialization expression to see if OrigDecl is evaluated in
10468	// its own initialization and throws a warning if it does.
10469	class SelfReferenceChecker
10470	: public EvaluatedExprVisitor<SelfReferenceChecker> {
10471	Sema &S;
10472	Decl *OrigDecl;
10473	bool isRecordType;
10474	bool isPODType;
10475	bool isReferenceType;
10476
10477	bool isInitList;
10478	llvm::SmallVector<unsigned, 4> InitFieldIndex;
10479
10480	public:
10481	typedef EvaluatedExprVisitor<SelfReferenceChecker> Inherited;
10482
10483	SelfReferenceChecker(Sema &S, Decl *OrigDecl) : Inherited(S.Context),
10484	S(S), OrigDecl(OrigDecl) {
10485	isPODType = false;
10486	isRecordType = false;
10487	isReferenceType = false;
10488	isInitList = false;
10489	if (ValueDecl *VD = dyn_cast<ValueDecl>(OrigDecl)) {
10490	isPODType = VD->getType().isPODType(S.Context);
10491	isRecordType = VD->getType()->isRecordType();
10492	isReferenceType = VD->getType()->isReferenceType();
10493	}
10494	}
10495
10496	// For most expressions, just call the visitor. For initializer lists,
10497	// track the index of the field being initialized since fields are
10498	// initialized in order allowing use of previously initialized fields.
10499	void CheckExpr(Expr *E) {
10500	InitListExpr *InitList = dyn_cast<InitListExpr>(E);
10501	if (!InitList) {
10502	Visit(E);
10503	return;
10504	}
10505
10506	// Track and increment the index here.
10507	isInitList = true;
10508	InitFieldIndex.push_back(0);
10509	for (auto Child : InitList->children()) {
10510	CheckExpr(cast<Expr>(Child));
10511	++InitFieldIndex.back();
10512	}
10513	InitFieldIndex.pop_back();
10514	}
10515
10516	// Returns true if MemberExpr is checked and no further checking is needed.
10517	// Returns false if additional checking is required.
10518	bool CheckInitListMemberExpr(MemberExpr *E, bool CheckReference) {
10519	llvm::SmallVector<FieldDecl*, 4> Fields;
10520	Expr *Base = E;
10521	bool ReferenceField = false;
10522
10523	// Get the field members used.
10524	while (MemberExpr *ME = dyn_cast<MemberExpr>(Base)) {
10525	FieldDecl *FD = dyn_cast<FieldDecl>(ME->getMemberDecl());
10526	if (!FD)
10527	return false;
10528	Fields.push_back(FD);
10529	if (FD->getType()->isReferenceType())
10530	ReferenceField = true;
10531	Base = ME->getBase()->IgnoreParenImpCasts();
10532	}
10533
10534	// Keep checking only if the base Decl is the same.
10535	DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Base);
10536	if (!DRE \|\| DRE->getDecl() != OrigDecl)
10537	return false;
10538
10539	// A reference field can be bound to an unininitialized field.
10540	if (CheckReference && !ReferenceField)
10541	return true;
10542
10543	// Convert FieldDecls to their index number.
10544	llvm::SmallVector<unsigned, 4> UsedFieldIndex;
10545	for (const FieldDecl *I : llvm::reverse(Fields))
10546	UsedFieldIndex.push_back(I->getFieldIndex());
10547
10548	// See if a warning is needed by checking the first difference in index
10549	// numbers. If field being used has index less than the field being
10550	// initialized, then the use is safe.
10551	for (auto UsedIter = UsedFieldIndex.begin(),
10552	UsedEnd = UsedFieldIndex.end(),
10553	OrigIter = InitFieldIndex.begin(),
10554	OrigEnd = InitFieldIndex.end();
10555	UsedIter != UsedEnd && OrigIter != OrigEnd; ++UsedIter, ++OrigIter) {
10556	if (UsedIter < OrigIter)
10557	return true;
10558	if (UsedIter > OrigIter)
10559	break;
10560	}
10561
10562	// TODO: Add a different warning which will print the field names.
10563	HandleDeclRefExpr(DRE);
10564	return true;
10565	}
10566
10567	// For most expressions, the cast is directly above the DeclRefExpr.
10568	// For conditional operators, the cast can be outside the conditional
10569	// operator if both expressions are DeclRefExpr's.
10570	void HandleValue(Expr *E) {
10571	E = E->IgnoreParens();
10572	if (DeclRefExpr* DRE = dyn_cast<DeclRefExpr>(E)) {
10573	HandleDeclRefExpr(DRE);
10574	return;
10575	}
10576
10577	if (ConditionalOperator *CO = dyn_cast<ConditionalOperator>(E)) {
10578	Visit(CO->getCond());
10579	HandleValue(CO->getTrueExpr());
10580	HandleValue(CO->getFalseExpr());
10581	return;
10582	}
10583
10584	if (BinaryConditionalOperator *BCO =
10585	dyn_cast<BinaryConditionalOperator>(E)) {
10586	Visit(BCO->getCond());
10587	HandleValue(BCO->getFalseExpr());
10588	return;
10589	}
10590
10591	if (OpaqueValueExpr *OVE = dyn_cast<OpaqueValueExpr>(E)) {
10592	HandleValue(OVE->getSourceExpr());
10593	return;
10594	}
10595
10596	if (BinaryOperator *BO = dyn_cast<BinaryOperator>(E)) {
10597	if (BO->getOpcode() == BO_Comma) {
10598	Visit(BO->getLHS());
10599	HandleValue(BO->getRHS());
10600	return;
10601	}
10602	}
10603
10604	if (isa<MemberExpr>(E)) {
10605	if (isInitList) {
10606	if (CheckInitListMemberExpr(cast<MemberExpr>(E),
10607	false /CheckReference/))
10608	return;
10609	}
10610
10611	Expr *Base = E->IgnoreParenImpCasts();
10612	while (MemberExpr *ME = dyn_cast<MemberExpr>(Base)) {
10613	// Check for static member variables and don't warn on them.
10614	if (!isa<FieldDecl>(ME->getMemberDecl()))
10615	return;
10616	Base = ME->getBase()->IgnoreParenImpCasts();
10617	}
10618	if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Base))
10619	HandleDeclRefExpr(DRE);
10620	return;
10621	}
10622
10623	Visit(E);
10624	}
10625
10626	// Reference types not handled in HandleValue are handled here since all
10627	// uses of references are bad, not just r-value uses.
10628	void VisitDeclRefExpr(DeclRefExpr *E) {
10629	if (isReferenceType)
10630	HandleDeclRefExpr(E);
10631	}
10632
10633	void VisitImplicitCastExpr(ImplicitCastExpr *E) {
10634	if (E->getCastKind() == CK_LValueToRValue) {
10635	HandleValue(E->getSubExpr());
10636	return;
10637	}
10638
10639	Inherited::VisitImplicitCastExpr(E);
10640	}
10641
10642	void VisitMemberExpr(MemberExpr *E) {
10643	if (isInitList) {
10644	if (CheckInitListMemberExpr(E, true /CheckReference/))
10645	return;
10646	}
10647
10648	// Don't warn on arrays since they can be treated as pointers.
10649	if (E->getType()->canDecayToPointerType()) return;
10650
10651	// Warn when a non-static method call is followed by non-static member
10652	// field accesses, which is followed by a DeclRefExpr.
10653	CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(E->getMemberDecl());
10654	bool Warn = (MD && !MD->isStatic());
10655	Expr *Base = E->getBase()->IgnoreParenImpCasts();
10656	while (MemberExpr *ME = dyn_cast<MemberExpr>(Base)) {
10657	if (!isa<FieldDecl>(ME->getMemberDecl()))
10658	Warn = false;
10659	Base = ME->getBase()->IgnoreParenImpCasts();
10660	}
10661
10662	if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Base)) {
10663	if (Warn)
10664	HandleDeclRefExpr(DRE);
10665	return;
10666	}
10667
10668	// The base of a MemberExpr is not a MemberExpr or a DeclRefExpr.
10669	// Visit that expression.
10670	Visit(Base);
10671	}
10672
10673	void VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E) {
10674	Expr *Callee = E->getCallee();
10675
10676	if (isa<UnresolvedLookupExpr>(Callee))
10677	return Inherited::VisitCXXOperatorCallExpr(E);
10678
10679	Visit(Callee);
10680	for (auto Arg: E->arguments())
10681	HandleValue(Arg->IgnoreParenImpCasts());
10682	}
10683
10684	void VisitUnaryOperator(UnaryOperator *E) {
10685	// For POD record types, addresses of its own members are well-defined.
10686	if (E->getOpcode() == UO_AddrOf && isRecordType &&
10687	isa<MemberExpr>(E->getSubExpr()->IgnoreParens())) {
10688	if (!isPODType)
10689	HandleValue(E->getSubExpr());
10690	return;
10691	}
10692
10693	if (E->isIncrementDecrementOp()) {
10694	HandleValue(E->getSubExpr());
10695	return;
10696	}
10697
10698	Inherited::VisitUnaryOperator(E);
10699	}
10700
10701	void VisitObjCMessageExpr(ObjCMessageExpr *E) {}
10702
10703	void VisitCXXConstructExpr(CXXConstructExpr *E) {
10704	if (E->getConstructor()->isCopyConstructor()) {
10705	Expr *ArgExpr = E->getArg(0);
10706	if (InitListExpr *ILE = dyn_cast<InitListExpr>(ArgExpr))
10707	if (ILE->getNumInits() == 1)
10708	ArgExpr = ILE->getInit(0);
10709	if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(ArgExpr))
10710	if (ICE->getCastKind() == CK_NoOp)
10711	ArgExpr = ICE->getSubExpr();
10712	HandleValue(ArgExpr);
10713	return;
10714	}
10715	Inherited::VisitCXXConstructExpr(E);
10716	}
10717
10718	void VisitCallExpr(CallExpr *E) {
10719	// Treat std::move as a use.
10720	if (E->isCallToStdMove()) {
10721	HandleValue(E->getArg(0));
10722	return;
10723	}
10724
10725	Inherited::VisitCallExpr(E);
10726	}
10727
10728	void VisitBinaryOperator(BinaryOperator *E) {
10729	if (E->isCompoundAssignmentOp()) {
10730	HandleValue(E->getLHS());
10731	Visit(E->getRHS());
10732	return;
10733	}
10734
10735	Inherited::VisitBinaryOperator(E);
10736	}
10737
10738	// A custom visitor for BinaryConditionalOperator is needed because the
10739	// regular visitor would check the condition and true expression separately
10740	// but both point to the same place giving duplicate diagnostics.
10741	void VisitBinaryConditionalOperator(BinaryConditionalOperator *E) {
10742	Visit(E->getCond());
10743	Visit(E->getFalseExpr());
10744	}
10745
10746	void HandleDeclRefExpr(DeclRefExpr *DRE) {
10747	Decl* ReferenceDecl = DRE->getDecl();
10748	if (OrigDecl != ReferenceDecl) return;
10749	unsigned diag;
10750	if (isReferenceType) {
10751	diag = diag::warn_uninit_self_reference_in_reference_init;
10752	} else if (cast<VarDecl>(OrigDecl)->isStaticLocal()) {
10753	diag = diag::warn_static_self_reference_in_init;
10754	} else if (isa<TranslationUnitDecl>(OrigDecl->getDeclContext()) \|\|
10755	isa<NamespaceDecl>(OrigDecl->getDeclContext()) \|\|
10756	DRE->getDecl()->getType()->isRecordType()) {
10757	diag = diag::warn_uninit_self_reference_in_init;
10758	} else {
10759	// Local variables will be handled by the CFG analysis.
10760	return;
10761	}
10762
10763	S.DiagRuntimeBehavior(DRE->getBeginLoc(), DRE,
10764	S.PDiag(diag)
10765	<< DRE->getDecl() << OrigDecl->getLocation()
10766	<< DRE->getSourceRange());
10767	}
10768	};
10769
10770	/// CheckSelfReference - Warns if OrigDecl is used in expression E.
10771	static void CheckSelfReference(Sema &S, Decl* OrigDecl, Expr *E,
10772	bool DirectInit) {
10773	// Parameters arguments are occassionially constructed with itself,
10774	// for instance, in recursive functions. Skip them.
10775	if (isa<ParmVarDecl>(OrigDecl))
10776	return;
10777
10778	E = E->IgnoreParens();
10779
10780	// Skip checking T a = a where T is not a record or reference type.
10781	// Doing so is a way to silence uninitialized warnings.
10782	if (!DirectInit && !cast<VarDecl>(OrigDecl)->getType()->isRecordType())
10783	if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E))
10784	if (ICE->getCastKind() == CK_LValueToRValue)
10785	if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(ICE->getSubExpr()))
10786	if (DRE->getDecl() == OrigDecl)
10787	return;
10788
10789	SelfReferenceChecker(S, OrigDecl).CheckExpr(E);
10790	}
10791	} // end anonymous namespace
10792
10793	namespace {
10794	// Simple wrapper to add the name of a variable or (if no variable is
10795	// available) a DeclarationName into a diagnostic.
10796	struct VarDeclOrName {
10797	VarDecl *VDecl;
10798	DeclarationName Name;
10799
10800	friend const Sema::SemaDiagnosticBuilder &
10801	operator<<(const Sema::SemaDiagnosticBuilder &Diag, VarDeclOrName VN) {
10802	return VN.VDecl ? Diag << VN.VDecl : Diag << VN.Name;
10803	}
10804	};
10805	} // end anonymous namespace
10806
10807	QualType Sema::deduceVarTypeFromInitializer(VarDecl *VDecl,
10808	DeclarationName Name, QualType Type,
10809	TypeSourceInfo *TSI,
10810	SourceRange Range, bool DirectInit,
10811	Expr *Init) {
10812	bool IsInitCapture = !VDecl;
10813	assert((!VDecl \|\| !VDecl->isInitCapture()) &&(((!VDecl \|\| !VDecl->isInitCapture()) && "init captures are expected to be deduced prior to initialization" ) ? static_cast<void> (0) : __assert_fail ("(!VDecl \|\| !VDecl->isInitCapture()) && \"init captures are expected to be deduced prior to initialization\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 10814, __PRETTY_FUNCTION__))
10814	"init captures are expected to be deduced prior to initialization")(((!VDecl \|\| !VDecl->isInitCapture()) && "init captures are expected to be deduced prior to initialization" ) ? static_cast<void> (0) : __assert_fail ("(!VDecl \|\| !VDecl->isInitCapture()) && \"init captures are expected to be deduced prior to initialization\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 10814, __PRETTY_FUNCTION__));
10815
10816	VarDeclOrName VN{VDecl, Name};
10817
10818	DeducedType *Deduced = Type->getContainedDeducedType();
10819	assert(Deduced && "deduceVarTypeFromInitializer for non-deduced type")((Deduced && "deduceVarTypeFromInitializer for non-deduced type" ) ? static_cast<void> (0) : __assert_fail ("Deduced && \"deduceVarTypeFromInitializer for non-deduced type\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 10819, __PRETTY_FUNCTION__));
10820
10821	// C++11 [dcl.spec.auto]p3
10822	if (!Init) {
10823	assert(VDecl && "no init for init capture deduction?")((VDecl && "no init for init capture deduction?") ? static_cast <void> (0) : __assert_fail ("VDecl && \"no init for init capture deduction?\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 10823, __PRETTY_FUNCTION__));
10824
10825	// Except for class argument deduction, and then for an initializing
10826	// declaration only, i.e. no static at class scope or extern.
10827	if (!isa<DeducedTemplateSpecializationType>(Deduced) \|\|
10828	VDecl->hasExternalStorage() \|\|
10829	VDecl->isStaticDataMember()) {
10830	Diag(VDecl->getLocation(), diag::err_auto_var_requires_init)
10831	<< VDecl->getDeclName() << Type;
10832	return QualType();
10833	}
10834	}
10835
10836	ArrayRef<Expr*> DeduceInits;
10837	if (Init)
10838	DeduceInits = Init;
10839
10840	if (DirectInit) {
10841	if (auto *PL = dyn_cast_or_null<ParenListExpr>(Init))
10842	DeduceInits = PL->exprs();
10843	}
10844
10845	if (isa<DeducedTemplateSpecializationType>(Deduced)) {
10846	assert(VDecl && "non-auto type for init capture deduction?")((VDecl && "non-auto type for init capture deduction?" ) ? static_cast<void> (0) : __assert_fail ("VDecl && \"non-auto type for init capture deduction?\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 10846, __PRETTY_FUNCTION__));
10847	InitializedEntity Entity = InitializedEntity::InitializeVariable(VDecl);
10848	InitializationKind Kind = InitializationKind::CreateForInit(
10849	VDecl->getLocation(), DirectInit, Init);
10850	// FIXME: Initialization should not be taking a mutable list of inits.
10851	SmallVector<Expr*, 8> InitsCopy(DeduceInits.begin(), DeduceInits.end());
10852	return DeduceTemplateSpecializationFromInitializer(TSI, Entity, Kind,
10853	InitsCopy);
10854	}
10855
10856	if (DirectInit) {
10857	if (auto *IL = dyn_cast<InitListExpr>(Init))
10858	DeduceInits = IL->inits();
10859	}
10860
10861	// Deduction only works if we have exactly one source expression.
10862	if (DeduceInits.empty()) {
10863	// It isn't possible to write this directly, but it is possible to
10864	// end up in this situation with "auto x(some_pack...);"
10865	Diag(Init->getBeginLoc(), IsInitCapture
10866	? diag::err_init_capture_no_expression
10867	: diag::err_auto_var_init_no_expression)
10868	<< VN << Type << Range;
10869	return QualType();
10870	}
10871
10872	if (DeduceInits.size() > 1) {
10873	Diag(DeduceInits[1]->getBeginLoc(),
10874	IsInitCapture ? diag::err_init_capture_multiple_expressions
10875	: diag::err_auto_var_init_multiple_expressions)
10876	<< VN << Type << Range;
10877	return QualType();
10878	}
10879
10880	Expr *DeduceInit = DeduceInits[0];
10881	if (DirectInit && isa<InitListExpr>(DeduceInit)) {
10882	Diag(Init->getBeginLoc(), IsInitCapture
10883	? diag::err_init_capture_paren_braces
10884	: diag::err_auto_var_init_paren_braces)
10885	<< isa<InitListExpr>(Init) << VN << Type << Range;
10886	return QualType();
10887	}
10888
10889	// Expressions default to 'id' when we're in a debugger.
10890	bool DefaultedAnyToId = false;
10891	if (getLangOpts().DebuggerCastResultToId &&
10892	Init->getType() == Context.UnknownAnyTy && !IsInitCapture) {
10893	ExprResult Result = forceUnknownAnyToType(Init, Context.getObjCIdType());
10894	if (Result.isInvalid()) {
10895	return QualType();
10896	}
10897	Init = Result.get();
10898	DefaultedAnyToId = true;
10899	}
10900
10901	// C++ [dcl.decomp]p1:
10902	// If the assignment-expression [...] has array type A and no ref-qualifier
10903	// is present, e has type cv A
10904	if (VDecl && isa<DecompositionDecl>(VDecl) &&
10905	Context.hasSameUnqualifiedType(Type, Context.getAutoDeductType()) &&
10906	DeduceInit->getType()->isConstantArrayType())
10907	return Context.getQualifiedType(DeduceInit->getType(),
10908	Type.getQualifiers());
10909
10910	QualType DeducedType;
10911	if (DeduceAutoType(TSI, DeduceInit, DeducedType) == DAR_Failed) {
10912	if (!IsInitCapture)
10913	DiagnoseAutoDeductionFailure(VDecl, DeduceInit);
10914	else if (isa<InitListExpr>(Init))
10915	Diag(Range.getBegin(),
10916	diag::err_init_capture_deduction_failure_from_init_list)
10917	<< VN
10918	<< (DeduceInit->getType().isNull() ? TSI->getType()
10919	: DeduceInit->getType())
10920	<< DeduceInit->getSourceRange();
10921	else
10922	Diag(Range.getBegin(), diag::err_init_capture_deduction_failure)
10923	<< VN << TSI->getType()
10924	<< (DeduceInit->getType().isNull() ? TSI->getType()
10925	: DeduceInit->getType())
10926	<< DeduceInit->getSourceRange();
10927	}
10928
10929	// Warn if we deduced 'id'. 'auto' usually implies type-safety, but using
10930	// 'id' instead of a specific object type prevents most of our usual
10931	// checks.
10932	// We only want to warn outside of template instantiations, though:
10933	// inside a template, the 'id' could have come from a parameter.
10934	if (!inTemplateInstantiation() && !DefaultedAnyToId && !IsInitCapture &&
10935	!DeducedType.isNull() && DeducedType->isObjCIdType()) {
10936	SourceLocation Loc = TSI->getTypeLoc().getBeginLoc();
10937	Diag(Loc, diag::warn_auto_var_is_id) << VN << Range;
10938	}
10939
10940	return DeducedType;
10941	}
10942
10943	bool Sema::DeduceVariableDeclarationType(VarDecl *VDecl, bool DirectInit,
10944	Expr *Init) {
10945	QualType DeducedType = deduceVarTypeFromInitializer(
10946	VDecl, VDecl->getDeclName(), VDecl->getType(), VDecl->getTypeSourceInfo(),
10947	VDecl->getSourceRange(), DirectInit, Init);
10948	if (DeducedType.isNull()) {
10949	VDecl->setInvalidDecl();
10950	return true;
10951	}
10952
10953	VDecl->setType(DeducedType);
10954	assert(VDecl->isLinkageValid())((VDecl->isLinkageValid()) ? static_cast<void> (0) : __assert_fail ("VDecl->isLinkageValid()", "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 10954, __PRETTY_FUNCTION__));
10955
10956	// In ARC, infer lifetime.
10957	if (getLangOpts().ObjCAutoRefCount && inferObjCARCLifetime(VDecl))
10958	VDecl->setInvalidDecl();
10959
10960	// If this is a redeclaration, check that the type we just deduced matches
10961	// the previously declared type.
10962	if (VarDecl *Old = VDecl->getPreviousDecl()) {
10963	// We never need to merge the type, because we cannot form an incomplete
10964	// array of auto, nor deduce such a type.
10965	MergeVarDeclTypes(VDecl, Old, /MergeTypeWithPrevious/ false);
10966	}
10967
10968	// Check the deduced type is valid for a variable declaration.
10969	CheckVariableDeclarationType(VDecl);
10970	return VDecl->isInvalidDecl();
10971	}
10972
10973	/// AddInitializerToDecl - Adds the initializer Init to the
10974	/// declaration dcl. If DirectInit is true, this is C++ direct
10975	/// initialization rather than copy initialization.
10976	void Sema::AddInitializerToDecl(Decl RealDecl, Expr Init, bool DirectInit) {
10977	// If there is no declaration, there was an error parsing it. Just ignore
10978	// the initializer.
10979	if (!RealDecl \|\| RealDecl->isInvalidDecl()) {
10980	CorrectDelayedTyposInExpr(Init, dyn_cast_or_null<VarDecl>(RealDecl));
10981	return;
10982	}
10983
10984	if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(RealDecl)) {
10985	// Pure-specifiers are handled in ActOnPureSpecifier.
10986	Diag(Method->getLocation(), diag::err_member_function_initialization)
10987	<< Method->getDeclName() << Init->getSourceRange();
10988	Method->setInvalidDecl();
10989	return;
10990	}
10991
10992	VarDecl *VDecl = dyn_cast<VarDecl>(RealDecl);
10993	if (!VDecl) {
10994	assert(!isa<FieldDecl>(RealDecl) && "field init shouldn't get here")((!isa<FieldDecl>(RealDecl) && "field init shouldn't get here" ) ? static_cast<void> (0) : __assert_fail ("!isa<FieldDecl>(RealDecl) && \"field init shouldn't get here\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 10994, __PRETTY_FUNCTION__));
10995	Diag(RealDecl->getLocation(), diag::err_illegal_initializer);
10996	RealDecl->setInvalidDecl();
10997	return;
10998	}
10999
11000	// C++11 [decl.spec.auto]p6. Deduce the type which 'auto' stands in for.
11001	if (VDecl->getType()->isUndeducedType()) {
11002	// Attempt typo correction early so that the type of the init expression can
11003	// be deduced based on the chosen correction if the original init contains a
11004	// TypoExpr.
11005	ExprResult Res = CorrectDelayedTyposInExpr(Init, VDecl);
11006	if (!Res.isUsable()) {
11007	RealDecl->setInvalidDecl();
11008	return;
11009	}
11010	Init = Res.get();
11011
11012	if (DeduceVariableDeclarationType(VDecl, DirectInit, Init))
11013	return;
11014	}
11015
11016	// dllimport cannot be used on variable definitions.
11017	if (VDecl->hasAttr<DLLImportAttr>() && !VDecl->isStaticDataMember()) {
11018	Diag(VDecl->getLocation(), diag::err_attribute_dllimport_data_definition);
11019	VDecl->setInvalidDecl();
11020	return;
11021	}
11022
11023	if (VDecl->isLocalVarDecl() && VDecl->hasExternalStorage()) {
11024	// C99 6.7.8p5. C++ has no such restriction, but that is a defect.
11025	Diag(VDecl->getLocation(), diag::err_block_extern_cant_init);
11026	VDecl->setInvalidDecl();
11027	return;
11028	}
11029
11030	if (!VDecl->getType()->isDependentType()) {
11031	// A definition must end up with a complete type, which means it must be
11032	// complete with the restriction that an array type might be completed by
11033	// the initializer; note that later code assumes this restriction.
11034	QualType BaseDeclType = VDecl->getType();
11035	if (const ArrayType *Array = Context.getAsIncompleteArrayType(BaseDeclType))
11036	BaseDeclType = Array->getElementType();
11037	if (RequireCompleteType(VDecl->getLocation(), BaseDeclType,
11038	diag::err_typecheck_decl_incomplete_type)) {
11039	RealDecl->setInvalidDecl();
11040	return;
11041	}
11042
11043	// The variable can not have an abstract class type.
11044	if (RequireNonAbstractType(VDecl->getLocation(), VDecl->getType(),
11045	diag::err_abstract_type_in_decl,
11046	AbstractVariableType))
11047	VDecl->setInvalidDecl();
11048	}
11049
11050	// If adding the initializer will turn this declaration into a definition,
11051	// and we already have a definition for this variable, diagnose or otherwise
11052	// handle the situation.
11053	VarDecl *Def;
11054	if ((Def = VDecl->getDefinition()) && Def != VDecl &&
11055	(!VDecl->isStaticDataMember() \|\| VDecl->isOutOfLine()) &&
11056	!VDecl->isThisDeclarationADemotedDefinition() &&
11057	checkVarDeclRedefinition(Def, VDecl))
11058	return;
11059
11060	if (getLangOpts().CPlusPlus) {
11061	// C++ [class.static.data]p4
11062	// If a static data member is of const integral or const
11063	// enumeration type, its declaration in the class definition can
11064	// specify a constant-initializer which shall be an integral
11065	// constant expression (5.19). In that case, the member can appear
11066	// in integral constant expressions. The member shall still be
11067	// defined in a namespace scope if it is used in the program and the
11068	// namespace scope definition shall not contain an initializer.
11069	//
11070	// We already performed a redefinition check above, but for static
11071	// data members we also need to check whether there was an in-class
11072	// declaration with an initializer.
11073	if (VDecl->isStaticDataMember() && VDecl->getCanonicalDecl()->hasInit()) {
11074	Diag(Init->getExprLoc(), diag::err_static_data_member_reinitialization)
11075	<< VDecl->getDeclName();
11076	Diag(VDecl->getCanonicalDecl()->getInit()->getExprLoc(),
11077	diag::note_previous_initializer)
11078	<< 0;
11079	return;
11080	}
11081
11082	if (VDecl->hasLocalStorage())
11083	setFunctionHasBranchProtectedScope();
11084
11085	if (DiagnoseUnexpandedParameterPack(Init, UPPC_Initializer)) {
11086	VDecl->setInvalidDecl();
11087	return;
11088	}
11089	}
11090
11091	// OpenCL 1.1 6.5.2: "Variables allocated in the __local address space inside
11092	// a kernel function cannot be initialized."
11093	if (VDecl->getType().getAddressSpace() == LangAS::opencl_local) {
11094	Diag(VDecl->getLocation(), diag::err_local_cant_init);
11095	VDecl->setInvalidDecl();
11096	return;
11097	}
11098
11099	// Get the decls type and save a reference for later, since
11100	// CheckInitializerTypes may change it.
11101	QualType DclT = VDecl->getType(), SavT = DclT;
11102
11103	// Expressions default to 'id' when we're in a debugger
11104	// and we are assigning it to a variable of Objective-C pointer type.
11105	if (getLangOpts().DebuggerCastResultToId && DclT->isObjCObjectPointerType() &&
11106	Init->getType() == Context.UnknownAnyTy) {
11107	ExprResult Result = forceUnknownAnyToType(Init, Context.getObjCIdType());
11108	if (Result.isInvalid()) {
11109	VDecl->setInvalidDecl();
11110	return;
11111	}
11112	Init = Result.get();
11113	}
11114
11115	// Perform the initialization.
11116	ParenListExpr *CXXDirectInit = dyn_cast<ParenListExpr>(Init);
11117	if (!VDecl->isInvalidDecl()) {
11118	InitializedEntity Entity = InitializedEntity::InitializeVariable(VDecl);
11119	InitializationKind Kind = InitializationKind::CreateForInit(
11120	VDecl->getLocation(), DirectInit, Init);
11121
11122	MultiExprArg Args = Init;
11123	if (CXXDirectInit)
11124	Args = MultiExprArg(CXXDirectInit->getExprs(),
11125	CXXDirectInit->getNumExprs());
11126
11127	// Try to correct any TypoExprs in the initialization arguments.
11128	for (size_t Idx = 0; Idx < Args.size(); ++Idx) {
11129	ExprResult Res = CorrectDelayedTyposInExpr(
11130	Args[Idx], VDecl, [this, Entity, Kind](Expr *E) {
11131	InitializationSequence Init(*this, Entity, Kind, MultiExprArg(E));
11132	return Init.Failed() ? ExprError() : E;
11133	});
11134	if (Res.isInvalid()) {
11135	VDecl->setInvalidDecl();
11136	} else if (Res.get() != Args[Idx]) {
11137	Args[Idx] = Res.get();
11138	}
11139	}
11140	if (VDecl->isInvalidDecl())
11141	return;
11142
11143	InitializationSequence InitSeq(*this, Entity, Kind, Args,
11144	/TopLevelOfInitList=/false,
11145	/TreatUnavailableAsInvalid=/false);
11146	ExprResult Result = InitSeq.Perform(*this, Entity, Kind, Args, &DclT);
11147	if (Result.isInvalid()) {
11148	VDecl->setInvalidDecl();
11149	return;
11150	}
11151
11152	Init = Result.getAs<Expr>();
11153	}
11154
11155	// Check for self-references within variable initializers.
11156	// Variables declared within a function/method body (except for references)
11157	// are handled by a dataflow analysis.
11158	if (!VDecl->hasLocalStorage() \|\| VDecl->getType()->isRecordType() \|\|
11159	VDecl->getType()->isReferenceType()) {
11160	CheckSelfReference(*this, RealDecl, Init, DirectInit);
11161	}
11162
11163	// If the type changed, it means we had an incomplete type that was
11164	// completed by the initializer. For example:
11165	// int ary[] = { 1, 3, 5 };
11166	// "ary" transitions from an IncompleteArrayType to a ConstantArrayType.
11167	if (!VDecl->isInvalidDecl() && (DclT != SavT))
11168	VDecl->setType(DclT);
11169
11170	if (!VDecl->isInvalidDecl()) {
11171	checkUnsafeAssigns(VDecl->getLocation(), VDecl->getType(), Init);
11172
11173	if (VDecl->hasAttr<BlocksAttr>())
11174	checkRetainCycles(VDecl, Init);
11175
11176	// It is safe to assign a weak reference into a strong variable.
11177	// Although this code can still have problems:
11178	// id x = self.weakProp;
11179	// id y = self.weakProp;
11180	// we do not warn to warn spuriously when 'x' and 'y' are on separate
11181	// paths through the function. This should be revisited if
11182	// -Wrepeated-use-of-weak is made flow-sensitive.
11183	if (FunctionScopeInfo *FSI = getCurFunction())
11184	if ((VDecl->getType().getObjCLifetime() == Qualifiers::OCL_Strong \|\|
11185	VDecl->getType().isNonWeakInMRRWithObjCWeak(Context)) &&
11186	!Diags.isIgnored(diag::warn_arc_repeated_use_of_weak,
11187	Init->getBeginLoc()))
11188	FSI->markSafeWeakUse(Init);
11189	}
11190
11191	// The initialization is usually a full-expression.
11192	//
11193	// FIXME: If this is a braced initialization of an aggregate, it is not
11194	// an expression, and each individual field initializer is a separate
11195	// full-expression. For instance, in:
11196	//
11197	// struct Temp { ~Temp(); };
11198	// struct S { S(Temp); };
11199	// struct T { S a, b; } t = { Temp(), Temp() }
11200	//
11201	// we should destroy the first Temp before constructing the second.
11202	ExprResult Result = ActOnFinishFullExpr(Init, VDecl->getLocation(),
11203	false,
11204	VDecl->isConstexpr());
11205	if (Result.isInvalid()) {
11206	VDecl->setInvalidDecl();
11207	return;
11208	}
11209	Init = Result.get();
11210
11211	// Attach the initializer to the decl.
11212	VDecl->setInit(Init);
11213
11214	if (VDecl->isLocalVarDecl()) {
11215	// Don't check the initializer if the declaration is malformed.
11216	if (VDecl->isInvalidDecl()) {
11217	// do nothing
11218
11219	// OpenCL v1.2 s6.5.3: __constant locals must be constant-initialized.
11220	// This is true even in OpenCL C++.
11221	} else if (VDecl->getType().getAddressSpace() == LangAS::opencl_constant) {
11222	CheckForConstantInitializer(Init, DclT);
11223
11224	// Otherwise, C++ does not restrict the initializer.
11225	} else if (getLangOpts().CPlusPlus) {
11226	// do nothing
11227
11228	// C99 6.7.8p4: All the expressions in an initializer for an object that has
11229	// static storage duration shall be constant expressions or string literals.
11230	} else if (VDecl->getStorageClass() == SC_Static) {
11231	CheckForConstantInitializer(Init, DclT);
11232
11233	// C89 is stricter than C99 for aggregate initializers.
11234	// C89 6.5.7p3: All the expressions [...] in an initializer list
11235	// for an object that has aggregate or union type shall be
11236	// constant expressions.
11237	} else if (!getLangOpts().C99 && VDecl->getType()->isAggregateType() &&
11238	isa<InitListExpr>(Init)) {
11239	const Expr *Culprit;
11240	if (!Init->isConstantInitializer(Context, false, &Culprit)) {
11241	Diag(Culprit->getExprLoc(),
11242	diag::ext_aggregate_init_not_constant)
11243	<< Culprit->getSourceRange();
11244	}
11245	}
11246	} else if (VDecl->isStaticDataMember() && !VDecl->isInline() &&
11247	VDecl->getLexicalDeclContext()->isRecord()) {
11248	// This is an in-class initialization for a static data member, e.g.,
11249	//
11250	// struct S {
11251	// static const int value = 17;
11252	// };
11253
11254	// C++ [class.mem]p4:
11255	// A member-declarator can contain a constant-initializer only
11256	// if it declares a static member (9.4) of const integral or
11257	// const enumeration type, see 9.4.2.
11258	//
11259	// C++11 [class.static.data]p3:
11260	// If a non-volatile non-inline const static data member is of integral
11261	// or enumeration type, its declaration in the class definition can
11262	// specify a brace-or-equal-initializer in which every initializer-clause
11263	// that is an assignment-expression is a constant expression. A static
11264	// data member of literal type can be declared in the class definition
11265	// with the constexpr specifier; if so, its declaration shall specify a
11266	// brace-or-equal-initializer in which every initializer-clause that is
11267	// an assignment-expression is a constant expression.
11268
11269	// Do nothing on dependent types.
11270	if (DclT->isDependentType()) {
11271
11272	// Allow any 'static constexpr' members, whether or not they are of literal
11273	// type. We separately check that every constexpr variable is of literal
11274	// type.
11275	} else if (VDecl->isConstexpr()) {
11276
11277	// Require constness.
11278	} else if (!DclT.isConstQualified()) {
11279	Diag(VDecl->getLocation(), diag::err_in_class_initializer_non_const)
11280	<< Init->getSourceRange();
11281	VDecl->setInvalidDecl();
11282
11283	// We allow integer constant expressions in all cases.
11284	} else if (DclT->isIntegralOrEnumerationType()) {
11285	// Check whether the expression is a constant expression.
11286	SourceLocation Loc;
11287	if (getLangOpts().CPlusPlus11 && DclT.isVolatileQualified())
11288	// In C++11, a non-constexpr const static data member with an
11289	// in-class initializer cannot be volatile.
11290	Diag(VDecl->getLocation(), diag::err_in_class_initializer_volatile);
11291	else if (Init->isValueDependent())
11292	; // Nothing to check.
11293	else if (Init->isIntegerConstantExpr(Context, &Loc))
11294	; // Ok, it's an ICE!
11295	else if (Init->getType()->isScopedEnumeralType() &&
11296	Init->isCXX11ConstantExpr(Context))
11297	; // Ok, it is a scoped-enum constant expression.
11298	else if (Init->isEvaluatable(Context)) {
11299	// If we can constant fold the initializer through heroics, accept it,
11300	// but report this as a use of an extension for -pedantic.
11301	Diag(Loc, diag::ext_in_class_initializer_non_constant)
11302	<< Init->getSourceRange();
11303	} else {
11304	// Otherwise, this is some crazy unknown case. Report the issue at the
11305	// location provided by the isIntegerConstantExpr failed check.
11306	Diag(Loc, diag::err_in_class_initializer_non_constant)
11307	<< Init->getSourceRange();
11308	VDecl->setInvalidDecl();
11309	}
11310
11311	// We allow foldable floating-point constants as an extension.
11312	} else if (DclT->isFloatingType()) { // also permits complex, which is ok
11313	// In C++98, this is a GNU extension. In C++11, it is not, but we support
11314	// it anyway and provide a fixit to add the 'constexpr'.
11315	if (getLangOpts().CPlusPlus11) {
11316	Diag(VDecl->getLocation(),
11317	diag::ext_in_class_initializer_float_type_cxx11)
11318	<< DclT << Init->getSourceRange();
11319	Diag(VDecl->getBeginLoc(),
11320	diag::note_in_class_initializer_float_type_cxx11)
11321	<< FixItHint::CreateInsertion(VDecl->getBeginLoc(), "constexpr ");
11322	} else {
11323	Diag(VDecl->getLocation(), diag::ext_in_class_initializer_float_type)
11324	<< DclT << Init->getSourceRange();
11325
11326	if (!Init->isValueDependent() && !Init->isEvaluatable(Context)) {
11327	Diag(Init->getExprLoc(), diag::err_in_class_initializer_non_constant)
11328	<< Init->getSourceRange();
11329	VDecl->setInvalidDecl();
11330	}
11331	}
11332
11333	// Suggest adding 'constexpr' in C++11 for literal types.
11334	} else if (getLangOpts().CPlusPlus11 && DclT->isLiteralType(Context)) {
11335	Diag(VDecl->getLocation(), diag::err_in_class_initializer_literal_type)
11336	<< DclT << Init->getSourceRange()
11337	<< FixItHint::CreateInsertion(VDecl->getBeginLoc(), "constexpr ");
11338	VDecl->setConstexpr(true);
11339
11340	} else {
11341	Diag(VDecl->getLocation(), diag::err_in_class_initializer_bad_type)
11342	<< DclT << Init->getSourceRange();
11343	VDecl->setInvalidDecl();
11344	}
11345	} else if (VDecl->isFileVarDecl()) {
11346	// In C, extern is typically used to avoid tentative definitions when
11347	// declaring variables in headers, but adding an intializer makes it a
11348	// definition. This is somewhat confusing, so GCC and Clang both warn on it.
11349	// In C++, extern is often used to give implictly static const variables
11350	// external linkage, so don't warn in that case. If selectany is present,
11351	// this might be header code intended for C and C++ inclusion, so apply the
11352	// C++ rules.
11353	if (VDecl->getStorageClass() == SC_Extern &&
11354	((!getLangOpts().CPlusPlus && !VDecl->hasAttr<SelectAnyAttr>()) \|\|
11355	!Context.getBaseElementType(VDecl->getType()).isConstQualified()) &&
11356	!(getLangOpts().CPlusPlus && VDecl->isExternC()) &&
11357	!isTemplateInstantiation(VDecl->getTemplateSpecializationKind()))
11358	Diag(VDecl->getLocation(), diag::warn_extern_init);
11359
11360	// C99 6.7.8p4. All file scoped initializers need to be constant.
11361	if (!getLangOpts().CPlusPlus && !VDecl->isInvalidDecl())
11362	CheckForConstantInitializer(Init, DclT);
11363	}
11364
11365	// We will represent direct-initialization similarly to copy-initialization:
11366	// int x(1); -as-> int x = 1;
11367	// ClassType x(a,b,c); -as-> ClassType x = ClassType(a,b,c);
11368	//
11369	// Clients that want to distinguish between the two forms, can check for
11370	// direct initializer using VarDecl::getInitStyle().
11371	// A major benefit is that clients that don't particularly care about which
11372	// exactly form was it (like the CodeGen) can handle both cases without
11373	// special case code.
11374
11375	// C++ 8.5p11:
11376	// The form of initialization (using parentheses or '=') is generally
11377	// insignificant, but does matter when the entity being initialized has a
11378	// class type.
11379	if (CXXDirectInit) {
11380	assert(DirectInit && "Call-style initializer must be direct init.")((DirectInit && "Call-style initializer must be direct init." ) ? static_cast<void> (0) : __assert_fail ("DirectInit && \"Call-style initializer must be direct init.\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 11380, __PRETTY_FUNCTION__));
11381	VDecl->setInitStyle(VarDecl::CallInit);
11382	} else if (DirectInit) {
11383	// This must be list-initialization. No other way is direct-initialization.
11384	VDecl->setInitStyle(VarDecl::ListInit);
11385	}
11386
11387	CheckCompleteVariableDeclaration(VDecl);
11388	}
11389
11390	/// ActOnInitializerError - Given that there was an error parsing an
11391	/// initializer for the given declaration, try to return to some form
11392	/// of sanity.
11393	void Sema::ActOnInitializerError(Decl *D) {
11394	// Our main concern here is re-establishing invariants like "a
11395	// variable's type is either dependent or complete".
11396	if (!D \|\| D->isInvalidDecl()) return;
11397
11398	VarDecl *VD = dyn_cast<VarDecl>(D);
11399	if (!VD) return;
11400
11401	// Bindings are not usable if we can't make sense of the initializer.
11402	if (auto *DD = dyn_cast<DecompositionDecl>(D))
11403	for (auto *BD : DD->bindings())
11404	BD->setInvalidDecl();
11405
11406	// Auto types are meaningless if we can't make sense of the initializer.
11407	if (ParsingInitForAutoVars.count(D)) {
11408	D->setInvalidDecl();
11409	return;
11410	}
11411
11412	QualType Ty = VD->getType();
11413	if (Ty->isDependentType()) return;
11414
11415	// Require a complete type.
11416	if (RequireCompleteType(VD->getLocation(),
11417	Context.getBaseElementType(Ty),
11418	diag::err_typecheck_decl_incomplete_type)) {
11419	VD->setInvalidDecl();
11420	return;
11421	}
11422
11423	// Require a non-abstract type.
11424	if (RequireNonAbstractType(VD->getLocation(), Ty,
11425	diag::err_abstract_type_in_decl,
11426	AbstractVariableType)) {
11427	VD->setInvalidDecl();
11428	return;
11429	}
11430
11431	// Don't bother complaining about constructors or destructors,
11432	// though.
11433	}
11434
11435	void Sema::ActOnUninitializedDecl(Decl *RealDecl) {
11436	// If there is no declaration, there was an error parsing it. Just ignore it.
11437	if (!RealDecl)
11438	return;
11439
11440	if (VarDecl *Var = dyn_cast<VarDecl>(RealDecl)) {
11441	QualType Type = Var->getType();
11442
11443	// C++1z [dcl.dcl]p1 grammar implies that an initializer is mandatory.
11444	if (isa<DecompositionDecl>(RealDecl)) {
11445	Diag(Var->getLocation(), diag::err_decomp_decl_requires_init) << Var;
11446	Var->setInvalidDecl();
11447	return;
11448	}
11449
11450	if (Type->isUndeducedType() &&
11451	DeduceVariableDeclarationType(Var, false, nullptr))
11452	return;
11453
11454	// C++11 [class.static.data]p3: A static data member can be declared with
11455	// the constexpr specifier; if so, its declaration shall specify
11456	// a brace-or-equal-initializer.
11457	// C++11 [dcl.constexpr]p1: The constexpr specifier shall be applied only to
11458	// the definition of a variable [...] or the declaration of a static data
11459	// member.
11460	if (Var->isConstexpr() && !Var->isThisDeclarationADefinition() &&
11461	!Var->isThisDeclarationADemotedDefinition()) {
11462	if (Var->isStaticDataMember()) {
11463	// C++1z removes the relevant rule; the in-class declaration is always
11464	// a definition there.
11465	if (!getLangOpts().CPlusPlus17) {
11466	Diag(Var->getLocation(),
11467	diag::err_constexpr_static_mem_var_requires_init)
11468	<< Var->getDeclName();
11469	Var->setInvalidDecl();
11470	return;
11471	}
11472	} else {
11473	Diag(Var->getLocation(), diag::err_invalid_constexpr_var_decl);
11474	Var->setInvalidDecl();
11475	return;
11476	}
11477	}
11478
11479	// OpenCL v1.1 s6.5.3: variables declared in the constant address space must
11480	// be initialized.
11481	if (!Var->isInvalidDecl() &&
11482	Var->getType().getAddressSpace() == LangAS::opencl_constant &&
11483	Var->getStorageClass() != SC_Extern && !Var->getInit()) {
11484	Diag(Var->getLocation(), diag::err_opencl_constant_no_init);
11485	Var->setInvalidDecl();
11486	return;
11487	}
11488
11489	switch (Var->isThisDeclarationADefinition()) {
11490	case VarDecl::Definition:
11491	if (!Var->isStaticDataMember() \|\| !Var->getAnyInitializer())
11492	break;
11493
11494	// We have an out-of-line definition of a static data member
11495	// that has an in-class initializer, so we type-check this like
11496	// a declaration.
11497	//
11498	LLVM_FALLTHROUGH[[clang::fallthrough]];
11499
11500	case VarDecl::DeclarationOnly:
11501	// It's only a declaration.
11502
11503	// Block scope. C99 6.7p7: If an identifier for an object is
11504	// declared with no linkage (C99 6.2.2p6), the type for the
11505	// object shall be complete.
11506	if (!Type->isDependentType() && Var->isLocalVarDecl() &&
11507	!Var->hasLinkage() && !Var->isInvalidDecl() &&
11508	RequireCompleteType(Var->getLocation(), Type,
11509	diag::err_typecheck_decl_incomplete_type))
11510	Var->setInvalidDecl();
11511
11512	// Make sure that the type is not abstract.
11513	if (!Type->isDependentType() && !Var->isInvalidDecl() &&
11514	RequireNonAbstractType(Var->getLocation(), Type,
11515	diag::err_abstract_type_in_decl,
11516	AbstractVariableType))
11517	Var->setInvalidDecl();
11518	if (!Type->isDependentType() && !Var->isInvalidDecl() &&
11519	Var->getStorageClass() == SC_PrivateExtern) {
11520	Diag(Var->getLocation(), diag::warn_private_extern);
11521	Diag(Var->getLocation(), diag::note_private_extern);
11522	}
11523
11524	return;
11525
11526	case VarDecl::TentativeDefinition:
11527	// File scope. C99 6.9.2p2: A declaration of an identifier for an
11528	// object that has file scope without an initializer, and without a
11529	// storage-class specifier or with the storage-class specifier "static",
11530	// constitutes a tentative definition. Note: A tentative definition with
11531	// external linkage is valid (C99 6.2.2p5).
11532	if (!Var->isInvalidDecl()) {
11533	if (const IncompleteArrayType *ArrayT
11534	= Context.getAsIncompleteArrayType(Type)) {
11535	if (RequireCompleteType(Var->getLocation(),
11536	ArrayT->getElementType(),
11537	diag::err_illegal_decl_array_incomplete_type))
11538	Var->setInvalidDecl();
11539	} else if (Var->getStorageClass() == SC_Static) {
11540	// C99 6.9.2p3: If the declaration of an identifier for an object is
11541	// a tentative definition and has internal linkage (C99 6.2.2p3), the
11542	// declared type shall not be an incomplete type.
11543	// NOTE: code such as the following
11544	// static struct s;
11545	// struct s { int a; };
11546	// is accepted by gcc. Hence here we issue a warning instead of
11547	// an error and we do not invalidate the static declaration.
11548	// NOTE: to avoid multiple warnings, only check the first declaration.
11549	if (Var->isFirstDecl())
11550	RequireCompleteType(Var->getLocation(), Type,
11551	diag::ext_typecheck_decl_incomplete_type);
11552	}
11553	}
11554
11555	// Record the tentative definition; we're done.
11556	if (!Var->isInvalidDecl())
11557	TentativeDefinitions.push_back(Var);
11558	return;
11559	}
11560
11561	// Provide a specific diagnostic for uninitialized variable
11562	// definitions with incomplete array type.
11563	if (Type->isIncompleteArrayType()) {
11564	Diag(Var->getLocation(),
11565	diag::err_typecheck_incomplete_array_needs_initializer);
11566	Var->setInvalidDecl();
11567	return;
11568	}
11569
11570	// Provide a specific diagnostic for uninitialized variable
11571	// definitions with reference type.
11572	if (Type->isReferenceType()) {
11573	Diag(Var->getLocation(), diag::err_reference_var_requires_init)
11574	<< Var->getDeclName()
11575	<< SourceRange(Var->getLocation(), Var->getLocation());
11576	Var->setInvalidDecl();
11577	return;
11578	}
11579
11580	// Do not attempt to type-check the default initializer for a
11581	// variable with dependent type.
11582	if (Type->isDependentType())
11583	return;
11584
11585	if (Var->isInvalidDecl())
11586	return;
11587
11588	if (!Var->hasAttr<AliasAttr>()) {
11589	if (RequireCompleteType(Var->getLocation(),
11590	Context.getBaseElementType(Type),
11591	diag::err_typecheck_decl_incomplete_type)) {
11592	Var->setInvalidDecl();
11593	return;
11594	}
11595	} else {
11596	return;
11597	}
11598
11599	// The variable can not have an abstract class type.
11600	if (RequireNonAbstractType(Var->getLocation(), Type,
11601	diag::err_abstract_type_in_decl,
11602	AbstractVariableType)) {
11603	Var->setInvalidDecl();
11604	return;
11605	}
11606
11607	// Check for jumps past the implicit initializer. C++0x
11608	// clarifies that this applies to a "variable with automatic
11609	// storage duration", not a "local variable".
11610	// C++11 [stmt.dcl]p3
11611	// A program that jumps from a point where a variable with automatic
11612	// storage duration is not in scope to a point where it is in scope is
11613	// ill-formed unless the variable has scalar type, class type with a
11614	// trivial default constructor and a trivial destructor, a cv-qualified
11615	// version of one of these types, or an array of one of the preceding
11616	// types and is declared without an initializer.
11617	if (getLangOpts().CPlusPlus && Var->hasLocalStorage()) {
11618	if (const RecordType *Record
11619	= Context.getBaseElementType(Type)->getAs<RecordType>()) {
11620	CXXRecordDecl *CXXRecord = cast<CXXRecordDecl>(Record->getDecl());
11621	// Mark the function (if we're in one) for further checking even if the
11622	// looser rules of C++11 do not require such checks, so that we can
11623	// diagnose incompatibilities with C++98.
11624	if (!CXXRecord->isPOD())
11625	setFunctionHasBranchProtectedScope();
11626	}
11627	}
11628
11629	// C++03 [dcl.init]p9:
11630	// If no initializer is specified for an object, and the
11631	// object is of (possibly cv-qualified) non-POD class type (or
11632	// array thereof), the object shall be default-initialized; if
11633	// the object is of const-qualified type, the underlying class
11634	// type shall have a user-declared default
11635	// constructor. Otherwise, if no initializer is specified for
11636	// a non- static object, the object and its subobjects, if
11637	// any, have an indeterminate initial value); if the object
11638	// or any of its subobjects are of const-qualified type, the
11639	// program is ill-formed.
11640	// C++0x [dcl.init]p11:
11641	// If no initializer is specified for an object, the object is
11642	// default-initialized; [...].
11643	InitializedEntity Entity = InitializedEntity::InitializeVariable(Var);
11644	InitializationKind Kind
11645	= InitializationKind::CreateDefault(Var->getLocation());
11646
11647	InitializationSequence InitSeq(*this, Entity, Kind, None);
11648	ExprResult Init = InitSeq.Perform(*this, Entity, Kind, None);
11649	if (Init.isInvalid())
11650	Var->setInvalidDecl();
11651	else if (Init.get()) {
11652	Var->setInit(MaybeCreateExprWithCleanups(Init.get()));
11653	// This is important for template substitution.
11654	Var->setInitStyle(VarDecl::CallInit);
11655	}
11656
11657	CheckCompleteVariableDeclaration(Var);
11658	}
11659	}
11660
11661	void Sema::ActOnCXXForRangeDecl(Decl *D) {
11662	// If there is no declaration, there was an error parsing it. Ignore it.
11663	if (!D)
11664	return;
11665
11666	VarDecl *VD = dyn_cast<VarDecl>(D);
11667	if (!VD) {
11668	Diag(D->getLocation(), diag::err_for_range_decl_must_be_var);
11669	D->setInvalidDecl();
11670	return;
11671	}
11672
11673	VD->setCXXForRangeDecl(true);
11674
11675	// for-range-declaration cannot be given a storage class specifier.
11676	int Error = -1;
11677	switch (VD->getStorageClass()) {
11678	case SC_None:
11679	break;
11680	case SC_Extern:
11681	Error = 0;
11682	break;
11683	case SC_Static:
11684	Error = 1;
11685	break;
11686	case SC_PrivateExtern:
11687	Error = 2;
11688	break;
11689	case SC_Auto:
11690	Error = 3;
11691	break;
11692	case SC_Register:
11693	Error = 4;
11694	break;
11695	}
11696	if (Error != -1) {
11697	Diag(VD->getOuterLocStart(), diag::err_for_range_storage_class)
11698	<< VD->getDeclName() << Error;
11699	D->setInvalidDecl();
11700	}
11701	}
11702
11703	StmtResult
11704	Sema::ActOnCXXForRangeIdentifier(Scope *S, SourceLocation IdentLoc,
11705	IdentifierInfo *Ident,
11706	ParsedAttributes &Attrs,
11707	SourceLocation AttrEnd) {
11708	// C++1y [stmt.iter]p1:
11709	// A range-based for statement of the form
11710	// for ( for-range-identifier : for-range-initializer ) statement
11711	// is equivalent to
11712	// for ( auto&& for-range-identifier : for-range-initializer ) statement
11713	DeclSpec DS(Attrs.getPool().getFactory());
11714
11715	const char *PrevSpec;
11716	unsigned DiagID;
11717	DS.SetTypeSpecType(DeclSpec::TST_auto, IdentLoc, PrevSpec, DiagID,
11718	getPrintingPolicy());
11719
11720	Declarator D(DS, DeclaratorContext::ForContext);
11721	D.SetIdentifier(Ident, IdentLoc);
11722	D.takeAttributes(Attrs, AttrEnd);
11723
11724	ParsedAttributes EmptyAttrs(Attrs.getPool().getFactory());
11725	D.AddTypeInfo(DeclaratorChunk::getReference(0, IdentLoc, /lvalue/ false),
11726	IdentLoc);
11727	Decl *Var = ActOnDeclarator(S, D);
11728	cast<VarDecl>(Var)->setCXXForRangeDecl(true);
11729	FinalizeDeclaration(Var);
11730	return ActOnDeclStmt(FinalizeDeclaratorGroup(S, DS, Var), IdentLoc,
11731	AttrEnd.isValid() ? AttrEnd : IdentLoc);
11732	}
11733
11734	void Sema::CheckCompleteVariableDeclaration(VarDecl *var) {
11735	if (var->isInvalidDecl()) return;
11736
11737	if (getLangOpts().OpenCL) {
11738	// OpenCL v2.0 s6.12.5 - Every block variable declaration must have an
11739	// initialiser
11740	if (var->getTypeSourceInfo()->getType()->isBlockPointerType() &&
11741	!var->hasInit()) {
11742	Diag(var->getLocation(), diag::err_opencl_invalid_block_declaration)
11743	<< 1 /Init/;
11744	var->setInvalidDecl();
11745	return;
11746	}
11747	}
11748
11749	// In Objective-C, don't allow jumps past the implicit initialization of a
11750	// local retaining variable.
11751	if (getLangOpts().ObjC &&
11752	var->hasLocalStorage()) {
11753	switch (var->getType().getObjCLifetime()) {
11754	case Qualifiers::OCL_None:
11755	case Qualifiers::OCL_ExplicitNone:
11756	case Qualifiers::OCL_Autoreleasing:
11757	break;
11758
11759	case Qualifiers::OCL_Weak:
11760	case Qualifiers::OCL_Strong:
11761	setFunctionHasBranchProtectedScope();
11762	break;
11763	}
11764	}
11765
11766	if (var->hasLocalStorage() &&
11767	var->getType().isDestructedType() == QualType::DK_nontrivial_c_struct)
11768	setFunctionHasBranchProtectedScope();
11769
11770	// Warn about externally-visible variables being defined without a
11771	// prior declaration. We only want to do this for global
11772	// declarations, but we also specifically need to avoid doing it for
11773	// class members because the linkage of an anonymous class can
11774	// change if it's later given a typedef name.
11775	if (var->isThisDeclarationADefinition() &&
11776	var->getDeclContext()->getRedeclContext()->isFileContext() &&
11777	var->isExternallyVisible() && var->hasLinkage() &&
11778	!var->isInline() && !var->getDescribedVarTemplate() &&
11779	!isTemplateInstantiation(var->getTemplateSpecializationKind()) &&
11780	!getDiagnostics().isIgnored(diag::warn_missing_variable_declarations,
11781	var->getLocation())) {
11782	// Find a previous declaration that's not a definition.
11783	VarDecl *prev = var->getPreviousDecl();
11784	while (prev && prev->isThisDeclarationADefinition())
11785	prev = prev->getPreviousDecl();
11786
11787	if (!prev)
11788	Diag(var->getLocation(), diag::warn_missing_variable_declarations) << var;
11789	}
11790
11791	// Cache the result of checking for constant initialization.
11792	Optional<bool> CacheHasConstInit;
11793	const Expr *CacheCulprit;
11794	auto checkConstInit = [&]() mutable {
11795	if (!CacheHasConstInit)
11796	CacheHasConstInit = var->getInit()->isConstantInitializer(
11797	Context, var->getType()->isReferenceType(), &CacheCulprit);
11798	return *CacheHasConstInit;
11799	};
11800
11801	if (var->getTLSKind() == VarDecl::TLS_Static) {
11802	if (var->getType().isDestructedType()) {
11803	// GNU C++98 edits for __thread, [basic.start.term]p3:
11804	// The type of an object with thread storage duration shall not
11805	// have a non-trivial destructor.
11806	Diag(var->getLocation(), diag::err_thread_nontrivial_dtor);
11807	if (getLangOpts().CPlusPlus11)
11808	Diag(var->getLocation(), diag::note_use_thread_local);
11809	} else if (getLangOpts().CPlusPlus && var->hasInit()) {
11810	if (!checkConstInit()) {
11811	// GNU C++98 edits for __thread, [basic.start.init]p4:
11812	// An object of thread storage duration shall not require dynamic
11813	// initialization.
11814	// FIXME: Need strict checking here.
11815	Diag(CacheCulprit->getExprLoc(), diag::err_thread_dynamic_init)
11816	<< CacheCulprit->getSourceRange();
11817	if (getLangOpts().CPlusPlus11)
11818	Diag(var->getLocation(), diag::note_use_thread_local);
11819	}
11820	}
11821	}
11822
11823	// Apply section attributes and pragmas to global variables.
11824	bool GlobalStorage = var->hasGlobalStorage();
11825	if (GlobalStorage && var->isThisDeclarationADefinition() &&
11826	!inTemplateInstantiation()) {
11827	PragmaStack<StringLiteral > Stack = nullptr;
11828	int SectionFlags = ASTContext::PSF_Implicit \| ASTContext::PSF_Read;
11829	if (var->getType().isConstQualified())
11830	Stack = &ConstSegStack;
11831	else if (!var->getInit()) {
11832	Stack = &BSSSegStack;
11833	SectionFlags \|= ASTContext::PSF_Write;
11834	} else {
11835	Stack = &DataSegStack;
11836	SectionFlags \|= ASTContext::PSF_Write;
11837	}
11838	if (Stack->CurrentValue && !var->hasAttr<SectionAttr>()) {
11839	var->addAttr(SectionAttr::CreateImplicit(
11840	Context, SectionAttr::Declspec_allocate,
11841	Stack->CurrentValue->getString(), Stack->CurrentPragmaLocation));
11842	}
11843	if (const SectionAttr *SA = var->getAttr<SectionAttr>())
11844	if (UnifySection(SA->getName(), SectionFlags, var))
11845	var->dropAttr<SectionAttr>();
11846
11847	// Apply the init_seg attribute if this has an initializer. If the
11848	// initializer turns out to not be dynamic, we'll end up ignoring this
11849	// attribute.
11850	if (CurInitSeg && var->getInit())
11851	var->addAttr(InitSegAttr::CreateImplicit(Context, CurInitSeg->getString(),
11852	CurInitSegLoc));
11853	}
11854
11855	// All the following checks are C++ only.
11856	if (!getLangOpts().CPlusPlus) {
11857	// If this variable must be emitted, add it as an initializer for the
11858	// current module.
11859	if (Context.DeclMustBeEmitted(var) && !ModuleScopes.empty())
11860	Context.addModuleInitializer(ModuleScopes.back().Module, var);
11861	return;
11862	}
11863
11864	if (auto *DD = dyn_cast<DecompositionDecl>(var))
11865	CheckCompleteDecompositionDeclaration(DD);
11866
11867	QualType type = var->getType();
11868	if (type->isDependentType()) return;
11869
11870	if (var->hasAttr<BlocksAttr>())
11871	getCurFunction()->addByrefBlockVar(var);
11872
11873	Expr *Init = var->getInit();
11874	bool IsGlobal = GlobalStorage && !var->isStaticLocal();
11875	QualType baseType = Context.getBaseElementType(type);
11876
11877	if (Init && !Init->isValueDependent()) {
11878	if (var->isConstexpr()) {
11879	SmallVector<PartialDiagnosticAt, 8> Notes;
11880	if (!var->evaluateValue(Notes) \|\| !var->isInitICE()) {
11881	SourceLocation DiagLoc = var->getLocation();
11882	// If the note doesn't add any useful information other than a source
11883	// location, fold it into the primary diagnostic.
11884	if (Notes.size() == 1 && Notes[0].second.getDiagID() ==
11885	diag::note_invalid_subexpr_in_const_expr) {
11886	DiagLoc = Notes[0].first;
11887	Notes.clear();
11888	}
11889	Diag(DiagLoc, diag::err_constexpr_var_requires_const_init)
11890	<< var << Init->getSourceRange();
11891	for (unsigned I = 0, N = Notes.size(); I != N; ++I)
11892	Diag(Notes[I].first, Notes[I].second);
11893	}
11894	} else if (var->isUsableInConstantExpressions(Context)) {
11895	// Check whether the initializer of a const variable of integral or
11896	// enumeration type is an ICE now, since we can't tell whether it was
11897	// initialized by a constant expression if we check later.
11898	var->checkInitIsICE();
11899	}
11900
11901	// Don't emit further diagnostics about constexpr globals since they
11902	// were just diagnosed.
11903	if (!var->isConstexpr() && GlobalStorage &&
11904	var->hasAttr<RequireConstantInitAttr>()) {
11905	// FIXME: Need strict checking in C++03 here.
11906	bool DiagErr = getLangOpts().CPlusPlus11
11907	? !var->checkInitIsICE() : !checkConstInit();
11908	if (DiagErr) {
11909	auto attr = var->getAttr<RequireConstantInitAttr>();
11910	Diag(var->getLocation(), diag::err_require_constant_init_failed)
11911	<< Init->getSourceRange();
11912	Diag(attr->getLocation(), diag::note_declared_required_constant_init_here)
11913	<< attr->getRange();
11914	if (getLangOpts().CPlusPlus11) {
11915	APValue Value;
11916	SmallVector<PartialDiagnosticAt, 8> Notes;
11917	Init->EvaluateAsInitializer(Value, getASTContext(), var, Notes);
11918	for (auto &it : Notes)
11919	Diag(it.first, it.second);
11920	} else {
11921	Diag(CacheCulprit->getExprLoc(),
11922	diag::note_invalid_subexpr_in_const_expr)
11923	<< CacheCulprit->getSourceRange();
11924	}
11925	}
11926	}
11927	else if (!var->isConstexpr() && IsGlobal &&
11928	!getDiagnostics().isIgnored(diag::warn_global_constructor,
11929	var->getLocation())) {
11930	// Warn about globals which don't have a constant initializer. Don't
11931	// warn about globals with a non-trivial destructor because we already
11932	// warned about them.
11933	CXXRecordDecl *RD = baseType->getAsCXXRecordDecl();
11934	if (!(RD && !RD->hasTrivialDestructor())) {
11935	if (!checkConstInit())
11936	Diag(var->getLocation(), diag::warn_global_constructor)
11937	<< Init->getSourceRange();
11938	}
11939	}
11940	}
11941
11942	// Require the destructor.
11943	if (const RecordType *recordType = baseType->getAs<RecordType>())
11944	FinalizeVarWithDestructor(var, recordType);
11945
11946	// If this variable must be emitted, add it as an initializer for the current
11947	// module.
11948	if (Context.DeclMustBeEmitted(var) && !ModuleScopes.empty())
11949	Context.addModuleInitializer(ModuleScopes.back().Module, var);
11950	}
11951
11952	/// Determines if a variable's alignment is dependent.
11953	static bool hasDependentAlignment(VarDecl *VD) {
11954	if (VD->getType()->isDependentType())
11955	return true;
11956	for (auto *I : VD->specific_attrs<AlignedAttr>())
11957	if (I->isAlignmentDependent())
11958	return true;
11959	return false;
11960	}
11961
11962	/// Check if VD needs to be dllexport/dllimport due to being in a
11963	/// dllexport/import function.
11964	void Sema::CheckStaticLocalForDllExport(VarDecl *VD) {
11965	assert(VD->isStaticLocal())((VD->isStaticLocal()) ? static_cast<void> (0) : __assert_fail ("VD->isStaticLocal()", "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 11965, __PRETTY_FUNCTION__));
11966
11967	auto *FD = dyn_cast_or_null<FunctionDecl>(VD->getParentFunctionOrMethod());
11968
11969	// Find outermost function when VD is in lambda function.
11970	while (FD && !getDLLAttr(FD) &&
11971	!FD->hasAttr<DLLExportStaticLocalAttr>() &&
11972	!FD->hasAttr<DLLImportStaticLocalAttr>()) {
11973	FD = dyn_cast_or_null<FunctionDecl>(FD->getParentFunctionOrMethod());
11974	}
11975
11976	if (!FD)
11977	return;
11978
11979	// Static locals inherit dll attributes from their function.
11980	if (Attr *A = getDLLAttr(FD)) {
11981	auto *NewAttr = cast<InheritableAttr>(A->clone(getASTContext()));
11982	NewAttr->setInherited(true);
11983	VD->addAttr(NewAttr);
11984	} else if (Attr *A = FD->getAttr<DLLExportStaticLocalAttr>()) {
11985	auto *NewAttr = ::new (getASTContext()) DLLExportAttr(A->getRange(),
11986	getASTContext(),
11987	A->getSpellingListIndex());
11988	NewAttr->setInherited(true);
11989	VD->addAttr(NewAttr);
11990
11991	// Export this function to enforce exporting this static variable even
11992	// if it is not used in this compilation unit.
11993	if (!FD->hasAttr<DLLExportAttr>())
11994	FD->addAttr(NewAttr);
11995
11996	} else if (Attr *A = FD->getAttr<DLLImportStaticLocalAttr>()) {
11997	auto *NewAttr = ::new (getASTContext()) DLLImportAttr(A->getRange(),
11998	getASTContext(),
11999	A->getSpellingListIndex());
12000	NewAttr->setInherited(true);
12001	VD->addAttr(NewAttr);
12002	}
12003	}
12004
12005	/// FinalizeDeclaration - called by ParseDeclarationAfterDeclarator to perform
12006	/// any semantic actions necessary after any initializer has been attached.
12007	void Sema::FinalizeDeclaration(Decl *ThisDecl) {
12008	// Note that we are no longer parsing the initializer for this declaration.
12009	ParsingInitForAutoVars.erase(ThisDecl);
12010
12011	VarDecl *VD = dyn_cast_or_null<VarDecl>(ThisDecl);
12012	if (!VD)
12013	return;
12014
12015	// Apply an implicit SectionAttr if '#pragma clang section bss\|data\|rodata' is active
12016	if (VD->hasGlobalStorage() && VD->isThisDeclarationADefinition() &&
12017	!inTemplateInstantiation() && !VD->hasAttr<SectionAttr>()) {
12018	if (PragmaClangBSSSection.Valid)
12019	VD->addAttr(PragmaClangBSSSectionAttr::CreateImplicit(Context,
12020	PragmaClangBSSSection.SectionName,
12021	PragmaClangBSSSection.PragmaLocation));
12022	if (PragmaClangDataSection.Valid)
12023	VD->addAttr(PragmaClangDataSectionAttr::CreateImplicit(Context,
12024	PragmaClangDataSection.SectionName,
12025	PragmaClangDataSection.PragmaLocation));
12026	if (PragmaClangRodataSection.Valid)
12027	VD->addAttr(PragmaClangRodataSectionAttr::CreateImplicit(Context,
12028	PragmaClangRodataSection.SectionName,
12029	PragmaClangRodataSection.PragmaLocation));
12030	}
12031
12032	if (auto *DD = dyn_cast<DecompositionDecl>(ThisDecl)) {
12033	for (auto *BD : DD->bindings()) {
12034	FinalizeDeclaration(BD);
12035	}
12036	}
12037
12038	checkAttributesAfterMerging(this, VD);
12039
12040	// Perform TLS alignment check here after attributes attached to the variable
12041	// which may affect the alignment have been processed. Only perform the check
12042	// if the target has a maximum TLS alignment (zero means no constraints).
12043	if (unsigned MaxAlign = Context.getTargetInfo().getMaxTLSAlign()) {
12044	// Protect the check so that it's not performed on dependent types and
12045	// dependent alignments (we can't determine the alignment in that case).
12046	if (VD->getTLSKind() && !hasDependentAlignment(VD) &&
12047	!VD->isInvalidDecl()) {
12048	CharUnits MaxAlignChars = Context.toCharUnitsFromBits(MaxAlign);
12049	if (Context.getDeclAlign(VD) > MaxAlignChars) {
12050	Diag(VD->getLocation(), diag::err_tls_var_aligned_over_maximum)
12051	<< (unsigned)Context.getDeclAlign(VD).getQuantity() << VD
12052	<< (unsigned)MaxAlignChars.getQuantity();
12053	}
12054	}
12055	}
12056
12057	if (VD->isStaticLocal()) {
12058	CheckStaticLocalForDllExport(VD);
12059
12060	if (dyn_cast_or_null<FunctionDecl>(VD->getParentFunctionOrMethod())) {
12061	// CUDA 8.0 E.3.9.4: Within the body of a __device__ or __global__
12062	// function, only __shared__ variables or variables without any device
12063	// memory qualifiers may be declared with static storage class.
12064	// Note: It is unclear how a function-scope non-const static variable
12065	// without device memory qualifier is implemented, therefore only static
12066	// const variable without device memory qualifier is allowed.
12067	[&]() {
12068	if (!getLangOpts().CUDA)
12069	return;
12070	if (VD->hasAttr<CUDASharedAttr>())
12071	return;
12072	if (VD->getType().isConstQualified() &&
12073	!(VD->hasAttr<CUDADeviceAttr>() \|\| VD->hasAttr<CUDAConstantAttr>()))
12074	return;
12075	if (CUDADiagIfDeviceCode(VD->getLocation(),
12076	diag::err_device_static_local_var)
12077	<< CurrentCUDATarget())
12078	VD->setInvalidDecl();
12079	}();
12080	}
12081	}
12082
12083	// Perform check for initializers of device-side global variables.
12084	// CUDA allows empty constructors as initializers (see E.2.3.1, CUDA
12085	// 7.5). We must also apply the same checks to all __shared__
12086	// variables whether they are local or not. CUDA also allows
12087	// constant initializers for __constant__ and __device__ variables.
12088	if (getLangOpts().CUDA)
12089	checkAllowedCUDAInitializer(VD);
12090
12091	// Grab the dllimport or dllexport attribute off of the VarDecl.
12092	const InheritableAttr *DLLAttr = getDLLAttr(VD);
12093
12094	// Imported static data members cannot be defined out-of-line.
12095	if (const auto *IA = dyn_cast_or_null<DLLImportAttr>(DLLAttr)) {
12096	if (VD->isStaticDataMember() && VD->isOutOfLine() &&
12097	VD->isThisDeclarationADefinition()) {
12098	// We allow definitions of dllimport class template static data members
12099	// with a warning.
12100	CXXRecordDecl *Context =
12101	cast<CXXRecordDecl>(VD->getFirstDecl()->getDeclContext());
12102	bool IsClassTemplateMember =
12103	isa<ClassTemplatePartialSpecializationDecl>(Context) \|\|
12104	Context->getDescribedClassTemplate();
12105
12106	Diag(VD->getLocation(),
12107	IsClassTemplateMember
12108	? diag::warn_attribute_dllimport_static_field_definition
12109	: diag::err_attribute_dllimport_static_field_definition);
12110	Diag(IA->getLocation(), diag::note_attribute);
12111	if (!IsClassTemplateMember)
12112	VD->setInvalidDecl();
12113	}
12114	}
12115
12116	// dllimport/dllexport variables cannot be thread local, their TLS index
12117	// isn't exported with the variable.
12118	if (DLLAttr && VD->getTLSKind()) {
12119	auto *F = dyn_cast_or_null<FunctionDecl>(VD->getParentFunctionOrMethod());
12120	if (F && getDLLAttr(F)) {
12121	assert(VD->isStaticLocal())((VD->isStaticLocal()) ? static_cast<void> (0) : __assert_fail ("VD->isStaticLocal()", "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 12121, __PRETTY_FUNCTION__));
12122	// But if this is a static local in a dlimport/dllexport function, the
12123	// function will never be inlined, which means the var would never be
12124	// imported, so having it marked import/export is safe.
12125	} else {
12126	Diag(VD->getLocation(), diag::err_attribute_dll_thread_local) << VD
12127	<< DLLAttr;
12128	VD->setInvalidDecl();
12129	}
12130	}
12131
12132	if (UsedAttr *Attr = VD->getAttr<UsedAttr>()) {
12133	if (!Attr->isInherited() && !VD->isThisDeclarationADefinition()) {
12134	Diag(Attr->getLocation(), diag::warn_attribute_ignored) << Attr;
12135	VD->dropAttr<UsedAttr>();
12136	}
12137	}
12138
12139	const DeclContext *DC = VD->getDeclContext();
12140	// If there's a #pragma GCC visibility in scope, and this isn't a class
12141	// member, set the visibility of this variable.
12142	if (DC->getRedeclContext()->isFileContext() && VD->isExternallyVisible())
12143	AddPushedVisibilityAttribute(VD);
12144
12145	// FIXME: Warn on unused var template partial specializations.
12146	if (VD->isFileVarDecl() && !isa<VarTemplatePartialSpecializationDecl>(VD))
12147	MarkUnusedFileScopedDecl(VD);
12148
12149	// Now we have parsed the initializer and can update the table of magic
12150	// tag values.
12151	if (!VD->hasAttr<TypeTagForDatatypeAttr>() \|\|
12152	!VD->getType()->isIntegralOrEnumerationType())
12153	return;
12154
12155	for (const auto *I : ThisDecl->specific_attrs<TypeTagForDatatypeAttr>()) {
12156	const Expr *MagicValueExpr = VD->getInit();
12157	if (!MagicValueExpr) {
12158	continue;
12159	}
12160	llvm::APSInt MagicValueInt;
12161	if (!MagicValueExpr->isIntegerConstantExpr(MagicValueInt, Context)) {
12162	Diag(I->getRange().getBegin(),
12163	diag::err_type_tag_for_datatype_not_ice)
12164	<< LangOpts.CPlusPlus << MagicValueExpr->getSourceRange();
12165	continue;
12166	}
12167	if (MagicValueInt.getActiveBits() > 64) {
12168	Diag(I->getRange().getBegin(),
12169	diag::err_type_tag_for_datatype_too_large)
12170	<< LangOpts.CPlusPlus << MagicValueExpr->getSourceRange();
12171	continue;
12172	}
12173	uint64_t MagicValue = MagicValueInt.getZExtValue();
12174	RegisterTypeTagForDatatype(I->getArgumentKind(),
12175	MagicValue,
12176	I->getMatchingCType(),
12177	I->getLayoutCompatible(),
12178	I->getMustBeNull());
12179	}
12180	}
12181
12182	static bool hasDeducedAuto(DeclaratorDecl *DD) {
12183	auto *VD = dyn_cast<VarDecl>(DD);
12184	return VD && !VD->getType()->hasAutoForTrailingReturnType();
12185	}
12186
12187	Sema::DeclGroupPtrTy Sema::FinalizeDeclaratorGroup(Scope *S, const DeclSpec &DS,
12188	ArrayRef<Decl *> Group) {
12189	SmallVector<Decl*, 8> Decls;
12190
12191	if (DS.isTypeSpecOwned())
12192	Decls.push_back(DS.getRepAsDecl());
12193
12194	DeclaratorDecl *FirstDeclaratorInGroup = nullptr;
12195	DecompositionDecl *FirstDecompDeclaratorInGroup = nullptr;
12196	bool DiagnosedMultipleDecomps = false;
12197	DeclaratorDecl *FirstNonDeducedAutoInGroup = nullptr;
12198	bool DiagnosedNonDeducedAuto = false;
12199
12200	for (unsigned i = 0, e = Group.size(); i != e; ++i) {
12201	if (Decl *D = Group[i]) {
12202	// For declarators, there are some additional syntactic-ish checks we need
12203	// to perform.
12204	if (auto *DD = dyn_cast<DeclaratorDecl>(D)) {
12205	if (!FirstDeclaratorInGroup)
12206	FirstDeclaratorInGroup = DD;
12207	if (!FirstDecompDeclaratorInGroup)
12208	FirstDecompDeclaratorInGroup = dyn_cast<DecompositionDecl>(D);
12209	if (!FirstNonDeducedAutoInGroup && DS.hasAutoTypeSpec() &&
12210	!hasDeducedAuto(DD))
12211	FirstNonDeducedAutoInGroup = DD;
12212
12213	if (FirstDeclaratorInGroup != DD) {
12214	// A decomposition declaration cannot be combined with any other
12215	// declaration in the same group.
12216	if (FirstDecompDeclaratorInGroup && !DiagnosedMultipleDecomps) {
12217	Diag(FirstDecompDeclaratorInGroup->getLocation(),
12218	diag::err_decomp_decl_not_alone)
12219	<< FirstDeclaratorInGroup->getSourceRange()
12220	<< DD->getSourceRange();
12221	DiagnosedMultipleDecomps = true;
12222	}
12223
12224	// A declarator that uses 'auto' in any way other than to declare a
12225	// variable with a deduced type cannot be combined with any other
12226	// declarator in the same group.
12227	if (FirstNonDeducedAutoInGroup && !DiagnosedNonDeducedAuto) {
12228	Diag(FirstNonDeducedAutoInGroup->getLocation(),
12229	diag::err_auto_non_deduced_not_alone)
12230	<< FirstNonDeducedAutoInGroup->getType()
12231	->hasAutoForTrailingReturnType()
12232	<< FirstDeclaratorInGroup->getSourceRange()
12233	<< DD->getSourceRange();
12234	DiagnosedNonDeducedAuto = true;
12235	}
12236	}
12237	}
12238
12239	Decls.push_back(D);
12240	}
12241	}
12242
12243	if (DeclSpec::isDeclRep(DS.getTypeSpecType())) {
12244	if (TagDecl *Tag = dyn_cast_or_null<TagDecl>(DS.getRepAsDecl())) {
12245	handleTagNumbering(Tag, S);
12246	if (FirstDeclaratorInGroup && !Tag->hasNameForLinkage() &&
12247	getLangOpts().CPlusPlus)
12248	Context.addDeclaratorForUnnamedTagDecl(Tag, FirstDeclaratorInGroup);
12249	}
12250	}
12251
12252	return BuildDeclaratorGroup(Decls);
12253	}
12254
12255	/// BuildDeclaratorGroup - convert a list of declarations into a declaration
12256	/// group, performing any necessary semantic checking.
12257	Sema::DeclGroupPtrTy
12258	Sema::BuildDeclaratorGroup(MutableArrayRef<Decl *> Group) {
12259	// C++14 [dcl.spec.auto]p7: (DR1347)
12260	// If the type that replaces the placeholder type is not the same in each
12261	// deduction, the program is ill-formed.
12262	if (Group.size() > 1) {
12263	QualType Deduced;
12264	VarDecl *DeducedDecl = nullptr;
12265	for (unsigned i = 0, e = Group.size(); i != e; ++i) {
12266	VarDecl *D = dyn_cast<VarDecl>(Group[i]);
12267	if (!D \|\| D->isInvalidDecl())
12268	break;
12269	DeducedType *DT = D->getType()->getContainedDeducedType();
12270	if (!DT \|\| DT->getDeducedType().isNull())
12271	continue;
12272	if (Deduced.isNull()) {
12273	Deduced = DT->getDeducedType();
12274	DeducedDecl = D;
12275	} else if (!Context.hasSameType(DT->getDeducedType(), Deduced)) {
12276	auto *AT = dyn_cast<AutoType>(DT);
12277	Diag(D->getTypeSourceInfo()->getTypeLoc().getBeginLoc(),
12278	diag::err_auto_different_deductions)
12279	<< (AT ? (unsigned)AT->getKeyword() : 3)
12280	<< Deduced << DeducedDecl->getDeclName()
12281	<< DT->getDeducedType() << D->getDeclName()
12282	<< DeducedDecl->getInit()->getSourceRange()
12283	<< D->getInit()->getSourceRange();
12284	D->setInvalidDecl();
12285	break;
12286	}
12287	}
12288	}
12289
12290	ActOnDocumentableDecls(Group);
12291
12292	return DeclGroupPtrTy::make(
12293	DeclGroupRef::Create(Context, Group.data(), Group.size()));
12294	}
12295
12296	void Sema::ActOnDocumentableDecl(Decl *D) {
12297	ActOnDocumentableDecls(D);
12298	}
12299
12300	void Sema::ActOnDocumentableDecls(ArrayRef<Decl *> Group) {
12301	// Don't parse the comment if Doxygen diagnostics are ignored.
12302	if (Group.empty() \|\| !Group[0])
12303	return;
12304
12305	if (Diags.isIgnored(diag::warn_doc_param_not_found,
12306	Group[0]->getLocation()) &&
12307	Diags.isIgnored(diag::warn_unknown_comment_command_name,
12308	Group[0]->getLocation()))
12309	return;
12310
12311	if (Group.size() >= 2) {
12312	// This is a decl group. Normally it will contain only declarations
12313	// produced from declarator list. But in case we have any definitions or
12314	// additional declaration references:
12315	// 'typedef struct S {} S;'
12316	// 'typedef struct S *S;'
12317	// 'struct S *pS;'
12318	// FinalizeDeclaratorGroup adds these as separate declarations.
12319	Decl *MaybeTagDecl = Group[0];
12320	if (MaybeTagDecl && isa<TagDecl>(MaybeTagDecl)) {
12321	Group = Group.slice(1);
12322	}
12323	}
12324
12325	// See if there are any new comments that are not attached to a decl.
12326	ArrayRef<RawComment *> Comments = Context.getRawCommentList().getComments();
12327	if (!Comments.empty() &&
12328	!Comments.back()->isAttached()) {
12329	// There is at least one comment that not attached to a decl.
12330	// Maybe it should be attached to one of these decls?
12331	//
12332	// Note that this way we pick up not only comments that precede the
12333	// declaration, but also comments that follow the declaration -- thanks to
12334	// the lookahead in the lexer: we've consumed the semicolon and looked
12335	// ahead through comments.
12336	for (unsigned i = 0, e = Group.size(); i != e; ++i)
12337	Context.getCommentForDecl(Group[i], &PP);
12338	}
12339	}
12340
12341	/// ActOnParamDeclarator - Called from Parser::ParseFunctionDeclarator()
12342	/// to introduce parameters into function prototype scope.
12343	Decl Sema::ActOnParamDeclarator(Scope S, Declarator &D) {
12344	const DeclSpec &DS = D.getDeclSpec();
12345
12346	// Verify C99 6.7.5.3p2: The only SCS allowed is 'register'.
12347
12348	// C++03 [dcl.stc]p2 also permits 'auto'.
12349	StorageClass SC = SC_None;
12350	if (DS.getStorageClassSpec() == DeclSpec::SCS_register) {
12351	SC = SC_Register;
12352	// In C++11, the 'register' storage class specifier is deprecated.
12353	// In C++17, it is not allowed, but we tolerate it as an extension.
12354	if (getLangOpts().CPlusPlus11) {
12355	Diag(DS.getStorageClassSpecLoc(),
12356	getLangOpts().CPlusPlus17 ? diag::ext_register_storage_class
12357	: diag::warn_deprecated_register)
12358	<< FixItHint::CreateRemoval(DS.getStorageClassSpecLoc());
12359	}
12360	} else if (getLangOpts().CPlusPlus &&
12361	DS.getStorageClassSpec() == DeclSpec::SCS_auto) {
12362	SC = SC_Auto;
12363	} else if (DS.getStorageClassSpec() != DeclSpec::SCS_unspecified) {
12364	Diag(DS.getStorageClassSpecLoc(),
12365	diag::err_invalid_storage_class_in_func_decl);
12366	D.getMutableDeclSpec().ClearStorageClassSpecs();
12367	}
12368
12369	if (DeclSpec::TSCS TSCS = DS.getThreadStorageClassSpec())
12370	Diag(DS.getThreadStorageClassSpecLoc(), diag::err_invalid_thread)
12371	<< DeclSpec::getSpecifierName(TSCS);
12372	if (DS.isInlineSpecified())
12373	Diag(DS.getInlineSpecLoc(), diag::err_inline_non_function)
12374	<< getLangOpts().CPlusPlus17;
12375	if (DS.isConstexprSpecified())
12376	Diag(DS.getConstexprSpecLoc(), diag::err_invalid_constexpr)
12377	<< 0;
12378
12379	DiagnoseFunctionSpecifiers(DS);
12380
12381	TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S);
12382	QualType parmDeclType = TInfo->getType();
12383
12384	if (getLangOpts().CPlusPlus) {
12385	// Check that there are no default arguments inside the type of this
12386	// parameter.
12387	CheckExtraCXXDefaultArguments(D);
12388
12389	// Parameter declarators cannot be qualified (C++ [dcl.meaning]p1).
12390	if (D.getCXXScopeSpec().isSet()) {
12391	Diag(D.getIdentifierLoc(), diag::err_qualified_param_declarator)
12392	<< D.getCXXScopeSpec().getRange();
12393	D.getCXXScopeSpec().clear();
12394	}
12395	}
12396
12397	// Ensure we have a valid name
12398	IdentifierInfo *II = nullptr;
12399	if (D.hasName()) {
12400	II = D.getIdentifier();
12401	if (!II) {
12402	Diag(D.getIdentifierLoc(), diag::err_bad_parameter_name)
12403	<< GetNameForDeclarator(D).getName();
12404	D.setInvalidType(true);
12405	}
12406	}
12407
12408	// Check for redeclaration of parameters, e.g. int foo(int x, int x);
12409	if (II) {
12410	LookupResult R(*this, II, D.getIdentifierLoc(), LookupOrdinaryName,
12411	ForVisibleRedeclaration);
12412	LookupName(R, S);
12413	if (R.isSingleResult()) {
12414	NamedDecl *PrevDecl = R.getFoundDecl();
12415	if (PrevDecl->isTemplateParameter()) {
12416	// Maybe we will complain about the shadowed template parameter.
12417	DiagnoseTemplateParameterShadow(D.getIdentifierLoc(), PrevDecl);
12418	// Just pretend that we didn't see the previous declaration.
12419	PrevDecl = nullptr;
12420	} else if (S->isDeclScope(PrevDecl)) {
12421	Diag(D.getIdentifierLoc(), diag::err_param_redefinition) << II;
12422	Diag(PrevDecl->getLocation(), diag::note_previous_declaration);
12423
12424	// Recover by removing the name
12425	II = nullptr;
12426	D.SetIdentifier(nullptr, D.getIdentifierLoc());
12427	D.setInvalidType(true);
12428	}
12429	}
12430	}
12431
12432	// Temporarily put parameter variables in the translation unit, not
12433	// the enclosing context. This prevents them from accidentally
12434	// looking like class members in C++.
12435	ParmVarDecl *New =
12436	CheckParameter(Context.getTranslationUnitDecl(), D.getBeginLoc(),
12437	D.getIdentifierLoc(), II, parmDeclType, TInfo, SC);
12438
12439	if (D.isInvalidType())
12440	New->setInvalidDecl();
12441
12442	assert(S->isFunctionPrototypeScope())((S->isFunctionPrototypeScope()) ? static_cast<void> (0) : __assert_fail ("S->isFunctionPrototypeScope()", "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 12442, __PRETTY_FUNCTION__));
12443	assert(S->getFunctionPrototypeDepth() >= 1)((S->getFunctionPrototypeDepth() >= 1) ? static_cast< void> (0) : __assert_fail ("S->getFunctionPrototypeDepth() >= 1" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 12443, __PRETTY_FUNCTION__));
12444	New->setScopeInfo(S->getFunctionPrototypeDepth() - 1,
12445	S->getNextFunctionPrototypeIndex());
12446
12447	// Add the parameter declaration into this scope.
12448	S->AddDecl(New);
12449	if (II)
12450	IdResolver.AddDecl(New);
12451
12452	ProcessDeclAttributes(S, New, D);
12453
12454	if (D.getDeclSpec().isModulePrivateSpecified())
12455	Diag(New->getLocation(), diag::err_module_private_local)
12456	<< 1 << New->getDeclName()
12457	<< SourceRange(D.getDeclSpec().getModulePrivateSpecLoc())
12458	<< FixItHint::CreateRemoval(D.getDeclSpec().getModulePrivateSpecLoc());
12459
12460	if (New->hasAttr<BlocksAttr>()) {
12461	Diag(New->getLocation(), diag::err_block_on_nonlocal);
12462	}
12463	return New;
12464	}
12465
12466	/// Synthesizes a variable for a parameter arising from a
12467	/// typedef.
12468	ParmVarDecl Sema::BuildParmVarDeclForTypedef(DeclContext DC,
12469	SourceLocation Loc,
12470	QualType T) {
12471	/* FIXME: setting StartLoc == Loc.
12472	Would it be worth to modify callers so as to provide proper source
12473	location for the unnamed parameters, embedding the parameter's type? */
12474	ParmVarDecl *Param = ParmVarDecl::Create(Context, DC, Loc, Loc, nullptr,
12475	T, Context.getTrivialTypeSourceInfo(T, Loc),
12476	SC_None, nullptr);
12477	Param->setImplicit();
12478	return Param;
12479	}
12480
12481	void Sema::DiagnoseUnusedParameters(ArrayRef<ParmVarDecl *> Parameters) {
12482	// Don't diagnose unused-parameter errors in template instantiations; we
12483	// will already have done so in the template itself.
12484	if (inTemplateInstantiation())
12485	return;
12486
12487	for (const ParmVarDecl *Parameter : Parameters) {
12488	if (!Parameter->isReferenced() && Parameter->getDeclName() &&
12489	!Parameter->hasAttr<UnusedAttr>()) {
12490	Diag(Parameter->getLocation(), diag::warn_unused_parameter)
12491	<< Parameter->getDeclName();
12492	}
12493	}
12494	}
12495
12496	void Sema::DiagnoseSizeOfParametersAndReturnValue(
12497	ArrayRef<ParmVarDecl > Parameters, QualType ReturnTy, NamedDecl D) {
12498	if (LangOpts.NumLargeByValueCopy == 0) // No check.
12499	return;
12500
12501	// Warn if the return value is pass-by-value and larger than the specified
12502	// threshold.
12503	if (!ReturnTy->isDependentType() && ReturnTy.isPODType(Context)) {
12504	unsigned Size = Context.getTypeSizeInChars(ReturnTy).getQuantity();
12505	if (Size > LangOpts.NumLargeByValueCopy)
12506	Diag(D->getLocation(), diag::warn_return_value_size)
12507	<< D->getDeclName() << Size;
12508	}
12509
12510	// Warn if any parameter is pass-by-value and larger than the specified
12511	// threshold.
12512	for (const ParmVarDecl *Parameter : Parameters) {
12513	QualType T = Parameter->getType();
12514	if (T->isDependentType() \|\| !T.isPODType(Context))
12515	continue;
12516	unsigned Size = Context.getTypeSizeInChars(T).getQuantity();
12517	if (Size > LangOpts.NumLargeByValueCopy)
12518	Diag(Parameter->getLocation(), diag::warn_parameter_size)
12519	<< Parameter->getDeclName() << Size;
12520	}
12521	}
12522
12523	ParmVarDecl Sema::CheckParameter(DeclContext DC, SourceLocation StartLoc,
12524	SourceLocation NameLoc, IdentifierInfo *Name,
12525	QualType T, TypeSourceInfo *TSInfo,
12526	StorageClass SC) {
12527	// In ARC, infer a lifetime qualifier for appropriate parameter types.
12528	if (getLangOpts().ObjCAutoRefCount &&
12529	T.getObjCLifetime() == Qualifiers::OCL_None &&
12530	T->isObjCLifetimeType()) {
12531
12532	Qualifiers::ObjCLifetime lifetime;
12533
12534	// Special cases for arrays:
12535	// - if it's const, use __unsafe_unretained
12536	// - otherwise, it's an error
12537	if (T->isArrayType()) {
12538	if (!T.isConstQualified()) {
12539	DelayedDiagnostics.add(
12540	sema::DelayedDiagnostic::makeForbiddenType(
12541	NameLoc, diag::err_arc_array_param_no_ownership, T, false));
12542	}
12543	lifetime = Qualifiers::OCL_ExplicitNone;
12544	} else {
12545	lifetime = T->getObjCARCImplicitLifetime();
12546	}
12547	T = Context.getLifetimeQualifiedType(T, lifetime);
12548	}
12549
12550	ParmVarDecl *New = ParmVarDecl::Create(Context, DC, StartLoc, NameLoc, Name,
12551	Context.getAdjustedParameterType(T),
12552	TSInfo, SC, nullptr);
12553
12554	// Parameters can not be abstract class types.
12555	// For record types, this is done by the AbstractClassUsageDiagnoser once
12556	// the class has been completely parsed.
12557	if (!CurContext->isRecord() &&
12558	RequireNonAbstractType(NameLoc, T, diag::err_abstract_type_in_decl,
12559	AbstractParamType))
12560	New->setInvalidDecl();
12561
12562	// Parameter declarators cannot be interface types. All ObjC objects are
12563	// passed by reference.
12564	if (T->isObjCObjectType()) {
12565	SourceLocation TypeEndLoc =
12566	getLocForEndOfToken(TSInfo->getTypeLoc().getEndLoc());
12567	Diag(NameLoc,
12568	diag::err_object_cannot_be_passed_returned_by_value) << 1 << T
12569	<< FixItHint::CreateInsertion(TypeEndLoc, "*");
12570	T = Context.getObjCObjectPointerType(T);
12571	New->setType(T);
12572	}
12573
12574	// ISO/IEC TR 18037 S6.7.3: "The type of an object with automatic storage
12575	// duration shall not be qualified by an address-space qualifier."
12576	// Since all parameters have automatic store duration, they can not have
12577	// an address space.
12578	if (T.getAddressSpace() != LangAS::Default &&
12579	// OpenCL allows function arguments declared to be an array of a type
12580	// to be qualified with an address space.
12581	!(getLangOpts().OpenCL &&
12582	(T->isArrayType() \|\| T.getAddressSpace() == LangAS::opencl_private))) {
12583	Diag(NameLoc, diag::err_arg_with_address_space);
12584	New->setInvalidDecl();
12585	}
12586
12587	return New;
12588	}
12589
12590	void Sema::ActOnFinishKNRParamDeclarations(Scope *S, Declarator &D,
12591	SourceLocation LocAfterDecls) {
12592	DeclaratorChunk::FunctionTypeInfo &FTI = D.getFunctionTypeInfo();
12593
12594	// Verify 6.9.1p6: 'every identifier in the identifier list shall be declared'
12595	// for a K&R function.
12596	if (!FTI.hasPrototype) {
12597	for (int i = FTI.NumParams; i != 0; /* decrement in loop */) {
12598	--i;
12599	if (FTI.Params[i].Param == nullptr) {
12600	SmallString<256> Code;
12601	llvm::raw_svector_ostream(Code)
12602	<< " int " << FTI.Params[i].Ident->getName() << ";\n";
12603	Diag(FTI.Params[i].IdentLoc, diag::ext_param_not_declared)
12604	<< FTI.Params[i].Ident
12605	<< FixItHint::CreateInsertion(LocAfterDecls, Code);
12606
12607	// Implicitly declare the argument as type 'int' for lack of a better
12608	// type.
12609	AttributeFactory attrs;
12610	DeclSpec DS(attrs);
12611	const char* PrevSpec; // unused
12612	unsigned DiagID; // unused
12613	DS.SetTypeSpecType(DeclSpec::TST_int, FTI.Params[i].IdentLoc, PrevSpec,
12614	DiagID, Context.getPrintingPolicy());
12615	// Use the identifier location for the type source range.
12616	DS.SetRangeStart(FTI.Params[i].IdentLoc);
12617	DS.SetRangeEnd(FTI.Params[i].IdentLoc);
12618	Declarator ParamD(DS, DeclaratorContext::KNRTypeListContext);
12619	ParamD.SetIdentifier(FTI.Params[i].Ident, FTI.Params[i].IdentLoc);
12620	FTI.Params[i].Param = ActOnParamDeclarator(S, ParamD);
12621	}
12622	}
12623	}
12624	}
12625
12626	Decl *
12627	Sema::ActOnStartOfFunctionDef(Scope *FnBodyScope, Declarator &D,
12628	MultiTemplateParamsArg TemplateParameterLists,
12629	SkipBodyInfo *SkipBody) {
12630	assert(getCurFunctionDecl() == nullptr && "Function parsing confused")((getCurFunctionDecl() == nullptr && "Function parsing confused" ) ? static_cast<void> (0) : __assert_fail ("getCurFunctionDecl() == nullptr && \"Function parsing confused\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 12630, __PRETTY_FUNCTION__));
12631	assert(D.isFunctionDeclarator() && "Not a function declarator!")((D.isFunctionDeclarator() && "Not a function declarator!" ) ? static_cast<void> (0) : __assert_fail ("D.isFunctionDeclarator() && \"Not a function declarator!\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 12631, __PRETTY_FUNCTION__));
12632	Scope *ParentScope = FnBodyScope->getParent();
12633
12634	D.setFunctionDefinitionKind(FDK_Definition);
12635	Decl *DP = HandleDeclarator(ParentScope, D, TemplateParameterLists);
12636	return ActOnStartOfFunctionDef(FnBodyScope, DP, SkipBody);
12637	}
12638
12639	void Sema::ActOnFinishInlineFunctionDef(FunctionDecl *D) {
12640	Consumer.HandleInlineFunctionDefinition(D);
12641	}
12642
12643	static bool ShouldWarnAboutMissingPrototype(const FunctionDecl *FD,
12644	const FunctionDecl*& PossibleZeroParamPrototype) {
12645	// Don't warn about invalid declarations.
12646	if (FD->isInvalidDecl())
12647	return false;
12648
12649	// Or declarations that aren't global.
12650	if (!FD->isGlobal())
12651	return false;
12652
12653	// Don't warn about C++ member functions.
12654	if (isa<CXXMethodDecl>(FD))
12655	return false;
12656
12657	// Don't warn about 'main'.
12658	if (FD->isMain())
12659	return false;
12660
12661	// Don't warn about inline functions.
12662	if (FD->isInlined())
12663	return false;
12664
12665	// Don't warn about function templates.
12666	if (FD->getDescribedFunctionTemplate())
12667	return false;
12668
12669	// Don't warn about function template specializations.
12670	if (FD->isFunctionTemplateSpecialization())
12671	return false;
12672
12673	// Don't warn for OpenCL kernels.
12674	if (FD->hasAttr<OpenCLKernelAttr>())
12675	return false;
12676
12677	// Don't warn on explicitly deleted functions.
12678	if (FD->isDeleted())
12679	return false;
12680
12681	bool MissingPrototype = true;
12682	for (const FunctionDecl *Prev = FD->getPreviousDecl();
12683	Prev; Prev = Prev->getPreviousDecl()) {
12684	// Ignore any declarations that occur in function or method
12685	// scope, because they aren't visible from the header.
12686	if (Prev->getLexicalDeclContext()->isFunctionOrMethod())
12687	continue;
12688
12689	MissingPrototype = !Prev->getType()->isFunctionProtoType();
12690	if (FD->getNumParams() == 0)
12691	PossibleZeroParamPrototype = Prev;
12692	break;
12693	}
12694
12695	return MissingPrototype;
12696	}
12697
12698	void
12699	Sema::CheckForFunctionRedefinition(FunctionDecl *FD,
12700	const FunctionDecl *EffectiveDefinition,
12701	SkipBodyInfo *SkipBody) {
12702	const FunctionDecl *Definition = EffectiveDefinition;
12703	if (!Definition && !FD->isDefined(Definition) && !FD->isCXXClassMember()) {
12704	// If this is a friend function defined in a class template, it does not
12705	// have a body until it is used, nevertheless it is a definition, see
12706	// [temp.inst]p2:
12707	//
12708	// ... for the purpose of determining whether an instantiated redeclaration
12709	// is valid according to [basic.def.odr] and [class.mem], a declaration that
12710	// corresponds to a definition in the template is considered to be a
12711	// definition.
12712	//
12713	// The following code must produce redefinition error:
12714	//
12715	// template<typename T> struct C20 { friend void func_20() {} };
12716	// C20<int> c20i;
12717	// void func_20() {}
12718	//
12719	for (auto I : FD->redecls()) {
12720	if (I != FD && !I->isInvalidDecl() &&
12721	I->getFriendObjectKind() != Decl::FOK_None) {
12722	if (FunctionDecl *Original = I->getInstantiatedFromMemberFunction()) {
12723	if (FunctionDecl *OrigFD = FD->getInstantiatedFromMemberFunction()) {
12724	// A merged copy of the same function, instantiated as a member of
12725	// the same class, is OK.
12726	if (declaresSameEntity(OrigFD, Original) &&
12727	declaresSameEntity(cast<Decl>(I->getLexicalDeclContext()),
12728	cast<Decl>(FD->getLexicalDeclContext())))
12729	continue;
12730	}
12731
12732	if (Original->isThisDeclarationADefinition()) {
12733	Definition = I;
12734	break;
12735	}
12736	}
12737	}
12738	}
12739	}
12740
12741	if (!Definition)
12742	// Similar to friend functions a friend function template may be a
12743	// definition and do not have a body if it is instantiated in a class
12744	// template.
12745	if (FunctionTemplateDecl *FTD = FD->getDescribedFunctionTemplate()) {
12746	for (auto I : FTD->redecls()) {
12747	auto D = cast<FunctionTemplateDecl>(I);
12748	if (D != FTD) {
12749	assert(!D->isThisDeclarationADefinition() &&((!D->isThisDeclarationADefinition() && "More than one definition in redeclaration chain" ) ? static_cast<void> (0) : __assert_fail ("!D->isThisDeclarationADefinition() && \"More than one definition in redeclaration chain\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 12750, __PRETTY_FUNCTION__))
12750	"More than one definition in redeclaration chain")((!D->isThisDeclarationADefinition() && "More than one definition in redeclaration chain" ) ? static_cast<void> (0) : __assert_fail ("!D->isThisDeclarationADefinition() && \"More than one definition in redeclaration chain\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 12750, __PRETTY_FUNCTION__));
12751	if (D->getFriendObjectKind() != Decl::FOK_None)
12752	if (FunctionTemplateDecl *FT =
12753	D->getInstantiatedFromMemberTemplate()) {
12754	if (FT->isThisDeclarationADefinition()) {
12755	Definition = D->getTemplatedDecl();
12756	break;
12757	}
12758	}
12759	}
12760	}
12761	}
12762
12763	if (!Definition)
12764	return;
12765
12766	if (canRedefineFunction(Definition, getLangOpts()))
12767	return;
12768
12769	// Don't emit an error when this is redefinition of a typo-corrected
12770	// definition.
12771	if (TypoCorrectedFunctionDefinitions.count(Definition))
12772	return;
12773
12774	// If we don't have a visible definition of the function, and it's inline or
12775	// a template, skip the new definition.
12776	if (SkipBody && !hasVisibleDefinition(Definition) &&
12777	(Definition->getFormalLinkage() == InternalLinkage \|\|
12778	Definition->isInlined() \|\|
12779	Definition->getDescribedFunctionTemplate() \|\|
12780	Definition->getNumTemplateParameterLists())) {
12781	SkipBody->ShouldSkip = true;
12782	SkipBody->Previous = const_cast<FunctionDecl*>(Definition);
12783	if (auto *TD = Definition->getDescribedFunctionTemplate())
12784	makeMergedDefinitionVisible(TD);
12785	makeMergedDefinitionVisible(const_cast<FunctionDecl*>(Definition));
12786	return;
12787	}
12788
12789	if (getLangOpts().GNUMode && Definition->isInlineSpecified() &&
12790	Definition->getStorageClass() == SC_Extern)
12791	Diag(FD->getLocation(), diag::err_redefinition_extern_inline)
12792	<< FD->getDeclName() << getLangOpts().CPlusPlus;
12793	else
12794	Diag(FD->getLocation(), diag::err_redefinition) << FD->getDeclName();
12795
12796	Diag(Definition->getLocation(), diag::note_previous_definition);
12797	FD->setInvalidDecl();
12798	}
12799
12800	static void RebuildLambdaScopeInfo(CXXMethodDecl *CallOperator,
12801	Sema &S) {
12802	CXXRecordDecl *const LambdaClass = CallOperator->getParent();
12803
12804	LambdaScopeInfo *LSI = S.PushLambdaScope();
12805	LSI->CallOperator = CallOperator;
12806	LSI->Lambda = LambdaClass;
12807	LSI->ReturnType = CallOperator->getReturnType();
12808	const LambdaCaptureDefault LCD = LambdaClass->getLambdaCaptureDefault();
12809
12810	if (LCD == LCD_None)
12811	LSI->ImpCaptureStyle = CapturingScopeInfo::ImpCap_None;
12812	else if (LCD == LCD_ByCopy)
12813	LSI->ImpCaptureStyle = CapturingScopeInfo::ImpCap_LambdaByval;
12814	else if (LCD == LCD_ByRef)
12815	LSI->ImpCaptureStyle = CapturingScopeInfo::ImpCap_LambdaByref;
12816	DeclarationNameInfo DNI = CallOperator->getNameInfo();
12817
12818	LSI->IntroducerRange = DNI.getCXXOperatorNameRange();
12819	LSI->Mutable = !CallOperator->isConst();
12820
12821	// Add the captures to the LSI so they can be noted as already
12822	// captured within tryCaptureVar.
12823	auto I = LambdaClass->field_begin();
12824	for (const auto &C : LambdaClass->captures()) {
12825	if (C.capturesVariable()) {
12826	VarDecl *VD = C.getCapturedVar();
12827	if (VD->isInitCapture())
12828	S.CurrentInstantiationScope->InstantiatedLocal(VD, VD);
12829	QualType CaptureType = VD->getType();
12830	const bool ByRef = C.getCaptureKind() == LCK_ByRef;
12831	LSI->addCapture(VD, /IsBlock/false, ByRef,
12832	/RefersToEnclosingVariableOrCapture/true, C.getLocation(),
12833	/EllipsisLoc/C.isPackExpansion()
12834	? C.getEllipsisLoc() : SourceLocation(),
12835	CaptureType, /Expr/ nullptr);
12836
12837	} else if (C.capturesThis()) {
12838	LSI->addThisCapture(/Nested/ false, C.getLocation(),
12839	/Expr/ nullptr,
12840	C.getCaptureKind() == LCK_StarThis);
12841	} else {
12842	LSI->addVLATypeCapture(C.getLocation(), I->getType());
12843	}
12844	++I;
12845	}
12846	}
12847
12848	Decl Sema::ActOnStartOfFunctionDef(Scope FnBodyScope, Decl *D,
12849	SkipBodyInfo *SkipBody) {
12850	if (!D) {
12851	// Parsing the function declaration failed in some way. Push on a fake scope
12852	// anyway so we can try to parse the function body.
12853	PushFunctionScope();
12854	PushExpressionEvaluationContext(ExprEvalContexts.back().Context);
12855	return D;
12856	}
12857
12858	FunctionDecl *FD = nullptr;
12859
12860	if (FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(D))
12861	FD = FunTmpl->getTemplatedDecl();
12862	else
12863	FD = cast<FunctionDecl>(D);
12864
12865	// Do not push if it is a lambda because one is already pushed when building
12866	// the lambda in ActOnStartOfLambdaDefinition().
12867	if (!isLambdaCallOperator(FD))
12868	PushExpressionEvaluationContext(ExprEvalContexts.back().Context);
12869
12870	// Check for defining attributes before the check for redefinition.
12871	if (const auto *Attr = FD->getAttr<AliasAttr>()) {
12872	Diag(Attr->getLocation(), diag::err_alias_is_definition) << FD << 0;
12873	FD->dropAttr<AliasAttr>();
12874	FD->setInvalidDecl();
12875	}
12876	if (const auto *Attr = FD->getAttr<IFuncAttr>()) {
12877	Diag(Attr->getLocation(), diag::err_alias_is_definition) << FD << 1;
12878	FD->dropAttr<IFuncAttr>();
12879	FD->setInvalidDecl();
12880	}
12881
12882	// See if this is a redefinition. If 'will have body' is already set, then
12883	// these checks were already performed when it was set.
12884	if (!FD->willHaveBody() && !FD->isLateTemplateParsed()) {
12885	CheckForFunctionRedefinition(FD, nullptr, SkipBody);
12886
12887	// If we're skipping the body, we're done. Don't enter the scope.
12888	if (SkipBody && SkipBody->ShouldSkip)
12889	return D;
12890	}
12891
12892	// Mark this function as "will have a body eventually". This lets users to
12893	// call e.g. isInlineDefinitionExternallyVisible while we're still parsing
12894	// this function.
12895	FD->setWillHaveBody();
12896
12897	// If we are instantiating a generic lambda call operator, push
12898	// a LambdaScopeInfo onto the function stack. But use the information
12899	// that's already been calculated (ActOnLambdaExpr) to prime the current
12900	// LambdaScopeInfo.
12901	// When the template operator is being specialized, the LambdaScopeInfo,
12902	// has to be properly restored so that tryCaptureVariable doesn't try
12903	// and capture any new variables. In addition when calculating potential
12904	// captures during transformation of nested lambdas, it is necessary to
12905	// have the LSI properly restored.
12906	if (isGenericLambdaCallOperatorSpecialization(FD)) {
12907	assert(inTemplateInstantiation() &&((inTemplateInstantiation() && "There should be an active template instantiation on the stack " "when instantiating a generic lambda!") ? static_cast<void > (0) : __assert_fail ("inTemplateInstantiation() && \"There should be an active template instantiation on the stack \" \"when instantiating a generic lambda!\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 12909, __PRETTY_FUNCTION__))
12908	"There should be an active template instantiation on the stack "((inTemplateInstantiation() && "There should be an active template instantiation on the stack " "when instantiating a generic lambda!") ? static_cast<void > (0) : __assert_fail ("inTemplateInstantiation() && \"There should be an active template instantiation on the stack \" \"when instantiating a generic lambda!\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 12909, __PRETTY_FUNCTION__))
12909	"when instantiating a generic lambda!")((inTemplateInstantiation() && "There should be an active template instantiation on the stack " "when instantiating a generic lambda!") ? static_cast<void > (0) : __assert_fail ("inTemplateInstantiation() && \"There should be an active template instantiation on the stack \" \"when instantiating a generic lambda!\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 12909, __PRETTY_FUNCTION__));
12910	RebuildLambdaScopeInfo(cast<CXXMethodDecl>(D), *this);
12911	} else {
12912	// Enter a new function scope
12913	PushFunctionScope();
12914	}
12915
12916	// Builtin functions cannot be defined.
12917	if (unsigned BuiltinID = FD->getBuiltinID()) {
12918	if (!Context.BuiltinInfo.isPredefinedLibFunction(BuiltinID) &&
12919	!Context.BuiltinInfo.isPredefinedRuntimeFunction(BuiltinID)) {
12920	Diag(FD->getLocation(), diag::err_builtin_definition) << FD;
12921	FD->setInvalidDecl();
12922	}
12923	}
12924
12925	// The return type of a function definition must be complete
12926	// (C99 6.9.1p3, C++ [dcl.fct]p6).
12927	QualType ResultType = FD->getReturnType();
12928	if (!ResultType->isDependentType() && !ResultType->isVoidType() &&
12929	!FD->isInvalidDecl() &&
12930	RequireCompleteType(FD->getLocation(), ResultType,
12931	diag::err_func_def_incomplete_result))
12932	FD->setInvalidDecl();
12933
12934	if (FnBodyScope)
12935	PushDeclContext(FnBodyScope, FD);
12936
12937	// Check the validity of our function parameters
12938	CheckParmsForFunctionDef(FD->parameters(),
12939	/CheckParameterNames=/true);
12940
12941	// Add non-parameter declarations already in the function to the current
12942	// scope.
12943	if (FnBodyScope) {
12944	for (Decl *NPD : FD->decls()) {
12945	auto *NonParmDecl = dyn_cast<NamedDecl>(NPD);
12946	if (!NonParmDecl)
12947	continue;
12948	assert(!isa<ParmVarDecl>(NonParmDecl) &&((!isa<ParmVarDecl>(NonParmDecl) && "parameters should not be in newly created FD yet" ) ? static_cast<void> (0) : __assert_fail ("!isa<ParmVarDecl>(NonParmDecl) && \"parameters should not be in newly created FD yet\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 12949, __PRETTY_FUNCTION__))
12949	"parameters should not be in newly created FD yet")((!isa<ParmVarDecl>(NonParmDecl) && "parameters should not be in newly created FD yet" ) ? static_cast<void> (0) : __assert_fail ("!isa<ParmVarDecl>(NonParmDecl) && \"parameters should not be in newly created FD yet\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 12949, __PRETTY_FUNCTION__));
12950
12951	// If the decl has a name, make it accessible in the current scope.
12952	if (NonParmDecl->getDeclName())
12953	PushOnScopeChains(NonParmDecl, FnBodyScope, /AddToContext=/false);
12954
12955	// Similarly, dive into enums and fish their constants out, making them
12956	// accessible in this scope.
12957	if (auto *ED = dyn_cast<EnumDecl>(NonParmDecl)) {
12958	for (auto *EI : ED->enumerators())
12959	PushOnScopeChains(EI, FnBodyScope, /AddToContext=/false);
12960	}
12961	}
12962	}
12963
12964	// Introduce our parameters into the function scope
12965	for (auto Param : FD->parameters()) {
12966	Param->setOwningFunction(FD);
12967
12968	// If this has an identifier, add it to the scope stack.
12969	if (Param->getIdentifier() && FnBodyScope) {
12970	CheckShadow(FnBodyScope, Param);
12971
12972	PushOnScopeChains(Param, FnBodyScope);
12973	}
12974	}
12975
12976	// Ensure that the function's exception specification is instantiated.
12977	if (const FunctionProtoType *FPT = FD->getType()->getAs<FunctionProtoType>())
12978	ResolveExceptionSpec(D->getLocation(), FPT);
12979
12980	// dllimport cannot be applied to non-inline function definitions.
12981	if (FD->hasAttr<DLLImportAttr>() && !FD->isInlined() &&
12982	!FD->isTemplateInstantiation()) {
12983	assert(!FD->hasAttr<DLLExportAttr>())((!FD->hasAttr<DLLExportAttr>()) ? static_cast<void > (0) : __assert_fail ("!FD->hasAttr<DLLExportAttr>()" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 12983, __PRETTY_FUNCTION__));
12984	Diag(FD->getLocation(), diag::err_attribute_dllimport_function_definition);
12985	FD->setInvalidDecl();
12986	return D;
12987	}
12988	// We want to attach documentation to original Decl (which might be
12989	// a function template).
12990	ActOnDocumentableDecl(D);
12991	if (getCurLexicalContext()->isObjCContainer() &&
12992	getCurLexicalContext()->getDeclKind() != Decl::ObjCCategoryImpl &&
12993	getCurLexicalContext()->getDeclKind() != Decl::ObjCImplementation)
12994	Diag(FD->getLocation(), diag::warn_function_def_in_objc_container);
12995
12996	return D;
12997	}
12998
12999	/// Given the set of return statements within a function body,
13000	/// compute the variables that are subject to the named return value
13001	/// optimization.
13002	///
13003	/// Each of the variables that is subject to the named return value
13004	/// optimization will be marked as NRVO variables in the AST, and any
13005	/// return statement that has a marked NRVO variable as its NRVO candidate can
13006	/// use the named return value optimization.
13007	///
13008	/// This function applies a very simplistic algorithm for NRVO: if every return
13009	/// statement in the scope of a variable has the same NRVO candidate, that
13010	/// candidate is an NRVO variable.
13011	void Sema::computeNRVO(Stmt Body, FunctionScopeInfo Scope) {
13012	ReturnStmt **Returns = Scope->Returns.data();
13013
13014	for (unsigned I = 0, E = Scope->Returns.size(); I != E; ++I) {
13015	if (const VarDecl *NRVOCandidate = Returns[I]->getNRVOCandidate()) {
13016	if (!NRVOCandidate->isNRVOVariable())
13017	Returns[I]->setNRVOCandidate(nullptr);
13018	}
13019	}
13020	}
13021
13022	bool Sema::canDelayFunctionBody(const Declarator &D) {
13023	// We can't delay parsing the body of a constexpr function template (yet).
13024	if (D.getDeclSpec().isConstexprSpecified())
13025	return false;
13026
13027	// We can't delay parsing the body of a function template with a deduced
13028	// return type (yet).
13029	if (D.getDeclSpec().hasAutoTypeSpec()) {
13030	// If the placeholder introduces a non-deduced trailing return type,
13031	// we can still delay parsing it.
13032	if (D.getNumTypeObjects()) {
13033	const auto &Outer = D.getTypeObject(D.getNumTypeObjects() - 1);
13034	if (Outer.Kind == DeclaratorChunk::Function &&
13035	Outer.Fun.hasTrailingReturnType()) {
13036	QualType Ty = GetTypeFromParser(Outer.Fun.getTrailingReturnType());
13037	return Ty.isNull() \|\| !Ty->isUndeducedType();
13038	}
13039	}
13040	return false;
13041	}
13042
13043	return true;
13044	}
13045
13046	bool Sema::canSkipFunctionBody(Decl *D) {
13047	// We cannot skip the body of a function (or function template) which is
13048	// constexpr, since we may need to evaluate its body in order to parse the
13049	// rest of the file.
13050	// We cannot skip the body of a function with an undeduced return type,
13051	// because any callers of that function need to know the type.
13052	if (const FunctionDecl *FD = D->getAsFunction()) {
13053	if (FD->isConstexpr())
13054	return false;
13055	// We can't simply call Type::isUndeducedType here, because inside template
13056	// auto can be deduced to a dependent type, which is not considered
13057	// "undeduced".
13058	if (FD->getReturnType()->getContainedDeducedType())
13059	return false;
13060	}
13061	return Consumer.shouldSkipFunctionBody(D);
13062	}
13063
13064	Decl Sema::ActOnSkippedFunctionBody(Decl Decl) {
13065	if (!Decl)
13066	return nullptr;
13067	if (FunctionDecl *FD = Decl->getAsFunction())
13068	FD->setHasSkippedBody();
13069	else if (ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(Decl))
13070	MD->setHasSkippedBody();
13071	return Decl;
13072	}
13073
13074	Decl Sema::ActOnFinishFunctionBody(Decl D, Stmt *BodyArg) {
13075	return ActOnFinishFunctionBody(D, BodyArg, false);
13076	}
13077
13078	/// RAII object that pops an ExpressionEvaluationContext when exiting a function
13079	/// body.
13080	class ExitFunctionBodyRAII {
13081	public:
13082	ExitFunctionBodyRAII(Sema &S, bool IsLambda) : S(S), IsLambda(IsLambda) {}
13083	~ExitFunctionBodyRAII() {
13084	if (!IsLambda)
13085	S.PopExpressionEvaluationContext();
13086	}
13087
13088	private:
13089	Sema &S;
13090	bool IsLambda = false;
13091	};
13092
13093	Decl Sema::ActOnFinishFunctionBody(Decl dcl, Stmt *Body,
13094	bool IsInstantiation) {
13095	FunctionDecl *FD = dcl ? dcl->getAsFunction() : nullptr;
13096
13097	sema::AnalysisBasedWarnings::Policy WP = AnalysisWarnings.getDefaultPolicy();
13098	sema::AnalysisBasedWarnings::Policy *ActivePolicy = nullptr;
13099
13100	if (getLangOpts().CoroutinesTS && getCurFunction()->isCoroutine())
13101	CheckCompletedCoroutineBody(FD, Body);
13102
13103	// Do not call PopExpressionEvaluationContext() if it is a lambda because one
13104	// is already popped when finishing the lambda in BuildLambdaExpr(). This is
13105	// meant to pop the context added in ActOnStartOfFunctionDef().
13106	ExitFunctionBodyRAII ExitRAII(*this, isLambdaCallOperator(FD));
13107
13108	if (FD) {
13109	FD->setBody(Body);
13110	FD->setWillHaveBody(false);
13111
13112	if (getLangOpts().CPlusPlus14) {
13113	if (!FD->isInvalidDecl() && Body && !FD->isDependentContext() &&
13114	FD->getReturnType()->isUndeducedType()) {
13115	// If the function has a deduced result type but contains no 'return'
13116	// statements, the result type as written must be exactly 'auto', and
13117	// the deduced result type is 'void'.
13118	if (!FD->getReturnType()->getAs<AutoType>()) {
13119	Diag(dcl->getLocation(), diag::err_auto_fn_no_return_but_not_auto)
13120	<< FD->getReturnType();
13121	FD->setInvalidDecl();
13122	} else {
13123	// Substitute 'void' for the 'auto' in the type.
13124	TypeLoc ResultType = getReturnTypeLoc(FD);
13125	Context.adjustDeducedFunctionResultType(
13126	FD, SubstAutoType(ResultType.getType(), Context.VoidTy));
13127	}
13128	}
13129	} else if (getLangOpts().CPlusPlus11 && isLambdaCallOperator(FD)) {
13130	// In C++11, we don't use 'auto' deduction rules for lambda call
13131	// operators because we don't support return type deduction.
13132	auto *LSI = getCurLambda();
13133	if (LSI->HasImplicitReturnType) {
13134	deduceClosureReturnType(*LSI);
13135
13136	// C++11 [expr.prim.lambda]p4:
13137	// [...] if there are no return statements in the compound-statement
13138	// [the deduced type is] the type void
13139	QualType RetType =
13140	LSI->ReturnType.isNull() ? Context.VoidTy : LSI->ReturnType;
13141
13142	// Update the return type to the deduced type.
13143	const FunctionProtoType *Proto =
13144	FD->getType()->getAs<FunctionProtoType>();
13145	FD->setType(Context.getFunctionType(RetType, Proto->getParamTypes(),
13146	Proto->getExtProtoInfo()));
13147	}
13148	}
13149
13150	// If the function implicitly returns zero (like 'main') or is naked,
13151	// don't complain about missing return statements.
13152	if (FD->hasImplicitReturnZero() \|\| FD->hasAttr<NakedAttr>())
13153	WP.disableCheckFallThrough();
13154
13155	// MSVC permits the use of pure specifier (=0) on function definition,
13156	// defined at class scope, warn about this non-standard construct.
13157	if (getLangOpts().MicrosoftExt && FD->isPure() && FD->isCanonicalDecl())
13158	Diag(FD->getLocation(), diag::ext_pure_function_definition);
13159
13160	if (!FD->isInvalidDecl()) {
13161	// Don't diagnose unused parameters of defaulted or deleted functions.
13162	if (!FD->isDeleted() && !FD->isDefaulted() && !FD->hasSkippedBody())
13163	DiagnoseUnusedParameters(FD->parameters());
13164	DiagnoseSizeOfParametersAndReturnValue(FD->parameters(),
13165	FD->getReturnType(), FD);
13166
13167	// If this is a structor, we need a vtable.
13168	if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(FD))
13169	MarkVTableUsed(FD->getLocation(), Constructor->getParent());
13170	else if (CXXDestructorDecl *Destructor = dyn_cast<CXXDestructorDecl>(FD))
13171	MarkVTableUsed(FD->getLocation(), Destructor->getParent());
13172
13173	// Try to apply the named return value optimization. We have to check
13174	// if we can do this here because lambdas keep return statements around
13175	// to deduce an implicit return type.
13176	if (FD->getReturnType()->isRecordType() &&
13177	(!getLangOpts().CPlusPlus \|\| !FD->isDependentContext()))
13178	computeNRVO(Body, getCurFunction());
13179	}
13180
13181	// GNU warning -Wmissing-prototypes:
13182	// Warn if a global function is defined without a previous
13183	// prototype declaration. This warning is issued even if the
13184	// definition itself provides a prototype. The aim is to detect
13185	// global functions that fail to be declared in header files.
13186	const FunctionDecl *PossibleZeroParamPrototype = nullptr;
13187	if (ShouldWarnAboutMissingPrototype(FD, PossibleZeroParamPrototype)) {
13188	Diag(FD->getLocation(), diag::warn_missing_prototype) << FD;
13189
13190	if (PossibleZeroParamPrototype) {
13191	// We found a declaration that is not a prototype,
13192	// but that could be a zero-parameter prototype
13193	if (TypeSourceInfo *TI =
13194	PossibleZeroParamPrototype->getTypeSourceInfo()) {
13195	TypeLoc TL = TI->getTypeLoc();
13196	if (FunctionNoProtoTypeLoc FTL = TL.getAs<FunctionNoProtoTypeLoc>())
13197	Diag(PossibleZeroParamPrototype->getLocation(),
13198	diag::note_declaration_not_a_prototype)
13199	<< PossibleZeroParamPrototype
13200	<< FixItHint::CreateInsertion(FTL.getRParenLoc(), "void");
13201	}
13202	}
13203
13204	// GNU warning -Wstrict-prototypes
13205	// Warn if K&R function is defined without a previous declaration.
13206	// This warning is issued only if the definition itself does not provide
13207	// a prototype. Only K&R definitions do not provide a prototype.
13208	// An empty list in a function declarator that is part of a definition
13209	// of that function specifies that the function has no parameters
13210	// (C99 6.7.5.3p14)
13211	if (!FD->hasWrittenPrototype() && FD->getNumParams() > 0 &&
13212	!LangOpts.CPlusPlus) {
13213	TypeSourceInfo *TI = FD->getTypeSourceInfo();
13214	TypeLoc TL = TI->getTypeLoc();
13215	FunctionTypeLoc FTL = TL.getAsAdjusted<FunctionTypeLoc>();
13216	Diag(FTL.getLParenLoc(), diag::warn_strict_prototypes) << 2;
13217	}
13218	}
13219
13220	// Warn on CPUDispatch with an actual body.
13221	if (FD->isMultiVersion() && FD->hasAttr<CPUDispatchAttr>() && Body)
13222	if (const auto *CmpndBody = dyn_cast<CompoundStmt>(Body))
13223	if (!CmpndBody->body_empty())
13224	Diag(CmpndBody->body_front()->getBeginLoc(),
13225	diag::warn_dispatch_body_ignored);
13226
13227	if (auto *MD = dyn_cast<CXXMethodDecl>(FD)) {
13228	const CXXMethodDecl *KeyFunction;
13229	if (MD->isOutOfLine() && (MD = MD->getCanonicalDecl()) &&
13230	MD->isVirtual() &&
13231	(KeyFunction = Context.getCurrentKeyFunction(MD->getParent())) &&
13232	MD == KeyFunction->getCanonicalDecl()) {
13233	// Update the key-function state if necessary for this ABI.
13234	if (FD->isInlined() &&
13235	!Context.getTargetInfo().getCXXABI().canKeyFunctionBeInline()) {
13236	Context.setNonKeyFunction(MD);
13237
13238	// If the newly-chosen key function is already defined, then we
13239	// need to mark the vtable as used retroactively.
13240	KeyFunction = Context.getCurrentKeyFunction(MD->getParent());
13241	const FunctionDecl *Definition;
13242	if (KeyFunction && KeyFunction->isDefined(Definition))
13243	MarkVTableUsed(Definition->getLocation(), MD->getParent(), true);
13244	} else {
13245	// We just defined they key function; mark the vtable as used.
13246	MarkVTableUsed(FD->getLocation(), MD->getParent(), true);
13247	}
13248	}
13249	}
13250
13251	assert((FD == getCurFunctionDecl() \|\| getCurLambda()->CallOperator == FD) &&(((FD == getCurFunctionDecl() \|\| getCurLambda()->CallOperator == FD) && "Function parsing confused") ? static_cast <void> (0) : __assert_fail ("(FD == getCurFunctionDecl() \|\| getCurLambda()->CallOperator == FD) && \"Function parsing confused\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 13252, __PRETTY_FUNCTION__))
13252	"Function parsing confused")(((FD == getCurFunctionDecl() \|\| getCurLambda()->CallOperator == FD) && "Function parsing confused") ? static_cast <void> (0) : __assert_fail ("(FD == getCurFunctionDecl() \|\| getCurLambda()->CallOperator == FD) && \"Function parsing confused\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 13252, __PRETTY_FUNCTION__));
13253	} else if (ObjCMethodDecl *MD = dyn_cast_or_null<ObjCMethodDecl>(dcl)) {
13254	assert(MD == getCurMethodDecl() && "Method parsing confused")((MD == getCurMethodDecl() && "Method parsing confused" ) ? static_cast<void> (0) : __assert_fail ("MD == getCurMethodDecl() && \"Method parsing confused\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 13254, __PRETTY_FUNCTION__));
13255	MD->setBody(Body);
13256	if (!MD->isInvalidDecl()) {
13257	if (!MD->hasSkippedBody())
13258	DiagnoseUnusedParameters(MD->parameters());
13259	DiagnoseSizeOfParametersAndReturnValue(MD->parameters(),
13260	MD->getReturnType(), MD);
13261
13262	if (Body)
13263	computeNRVO(Body, getCurFunction());
13264	}
13265	if (getCurFunction()->ObjCShouldCallSuper) {
13266	Diag(MD->getEndLoc(), diag::warn_objc_missing_super_call)
13267	<< MD->getSelector().getAsString();
13268	getCurFunction()->ObjCShouldCallSuper = false;
13269	}
13270	if (getCurFunction()->ObjCWarnForNoDesignatedInitChain) {
13271	const ObjCMethodDecl *InitMethod = nullptr;
13272	bool isDesignated =
13273	MD->isDesignatedInitializerForTheInterface(&InitMethod);
13274	assert(isDesignated && InitMethod)((isDesignated && InitMethod) ? static_cast<void> (0) : __assert_fail ("isDesignated && InitMethod", "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 13274, __PRETTY_FUNCTION__));
13275	(void)isDesignated;
13276
13277	auto superIsNSObject = [&](const ObjCMethodDecl *MD) {
13278	auto IFace = MD->getClassInterface();
13279	if (!IFace)
13280	return false;
13281	auto SuperD = IFace->getSuperClass();
13282	if (!SuperD)
13283	return false;
13284	return SuperD->getIdentifier() ==
13285	NSAPIObj->getNSClassId(NSAPI::ClassId_NSObject);
13286	};
13287	// Don't issue this warning for unavailable inits or direct subclasses
13288	// of NSObject.
13289	if (!MD->isUnavailable() && !superIsNSObject(MD)) {
13290	Diag(MD->getLocation(),
13291	diag::warn_objc_designated_init_missing_super_call);
13292	Diag(InitMethod->getLocation(),
13293	diag::note_objc_designated_init_marked_here);
13294	}
13295	getCurFunction()->ObjCWarnForNoDesignatedInitChain = false;
13296	}
13297	if (getCurFunction()->ObjCWarnForNoInitDelegation) {
13298	// Don't issue this warning for unavaialable inits.
13299	if (!MD->isUnavailable())
13300	Diag(MD->getLocation(),
13301	diag::warn_objc_secondary_init_missing_init_call);
13302	getCurFunction()->ObjCWarnForNoInitDelegation = false;
13303	}
13304	} else {
13305	// Parsing the function declaration failed in some way. Pop the fake scope
13306	// we pushed on.
13307	PopFunctionScopeInfo(ActivePolicy, dcl);
13308	return nullptr;
13309	}
13310
13311	if (Body && getCurFunction()->HasPotentialAvailabilityViolations)
13312	DiagnoseUnguardedAvailabilityViolations(dcl);
13313
13314	assert(!getCurFunction()->ObjCShouldCallSuper &&((!getCurFunction()->ObjCShouldCallSuper && "This should only be set for ObjC methods, which should have been " "handled in the block above.") ? static_cast<void> (0) : __assert_fail ("!getCurFunction()->ObjCShouldCallSuper && \"This should only be set for ObjC methods, which should have been \" \"handled in the block above.\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 13316, __PRETTY_FUNCTION__))
13315	"This should only be set for ObjC methods, which should have been "((!getCurFunction()->ObjCShouldCallSuper && "This should only be set for ObjC methods, which should have been " "handled in the block above.") ? static_cast<void> (0) : __assert_fail ("!getCurFunction()->ObjCShouldCallSuper && \"This should only be set for ObjC methods, which should have been \" \"handled in the block above.\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 13316, __PRETTY_FUNCTION__))
13316	"handled in the block above.")((!getCurFunction()->ObjCShouldCallSuper && "This should only be set for ObjC methods, which should have been " "handled in the block above.") ? static_cast<void> (0) : __assert_fail ("!getCurFunction()->ObjCShouldCallSuper && \"This should only be set for ObjC methods, which should have been \" \"handled in the block above.\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 13316, __PRETTY_FUNCTION__));
13317
13318	// Verify and clean out per-function state.
13319	if (Body && (!FD \|\| !FD->isDefaulted())) {
13320	// C++ constructors that have function-try-blocks can't have return
13321	// statements in the handlers of that block. (C++ [except.handle]p14)
13322	// Verify this.
13323	if (FD && isa<CXXConstructorDecl>(FD) && isa<CXXTryStmt>(Body))
13324	DiagnoseReturnInConstructorExceptionHandler(cast<CXXTryStmt>(Body));
13325
13326	// Verify that gotos and switch cases don't jump into scopes illegally.
13327	if (getCurFunction()->NeedsScopeChecking() &&
13328	!PP.isCodeCompletionEnabled())
13329	DiagnoseInvalidJumps(Body);
13330
13331	if (CXXDestructorDecl *Destructor = dyn_cast<CXXDestructorDecl>(dcl)) {
13332	if (!Destructor->getParent()->isDependentType())
13333	CheckDestructor(Destructor);
13334
13335	MarkBaseAndMemberDestructorsReferenced(Destructor->getLocation(),
13336	Destructor->getParent());
13337	}
13338
13339	// If any errors have occurred, clear out any temporaries that may have
13340	// been leftover. This ensures that these temporaries won't be picked up for
13341	// deletion in some later function.
13342	if (getDiagnostics().hasErrorOccurred() \|\|
13343	getDiagnostics().getSuppressAllDiagnostics()) {
13344	DiscardCleanupsInEvaluationContext();
13345	}
13346	if (!getDiagnostics().hasUncompilableErrorOccurred() &&
13347	!isa<FunctionTemplateDecl>(dcl)) {
13348	// Since the body is valid, issue any analysis-based warnings that are
13349	// enabled.
13350	ActivePolicy = &WP;
13351	}
13352
13353	if (!IsInstantiation && FD && FD->isConstexpr() && !FD->isInvalidDecl() &&
13354	(!CheckConstexprFunctionDecl(FD) \|\|
13355	!CheckConstexprFunctionBody(FD, Body)))
13356	FD->setInvalidDecl();
13357
13358	if (FD && FD->hasAttr<NakedAttr>()) {
13359	for (const Stmt *S : Body->children()) {
13360	// Allow local register variables without initializer as they don't
13361	// require prologue.
13362	bool RegisterVariables = false;
13363	if (auto *DS = dyn_cast<DeclStmt>(S)) {
13364	for (const auto *Decl : DS->decls()) {
13365	if (const auto *Var = dyn_cast<VarDecl>(Decl)) {
13366	RegisterVariables =
13367	Var->hasAttr<AsmLabelAttr>() && !Var->hasInit();
13368	if (!RegisterVariables)
13369	break;
13370	}
13371	}
13372	}
13373	if (RegisterVariables)
13374	continue;
13375	if (!isa<AsmStmt>(S) && !isa<NullStmt>(S)) {
13376	Diag(S->getBeginLoc(), diag::err_non_asm_stmt_in_naked_function);
13377	Diag(FD->getAttr<NakedAttr>()->getLocation(), diag::note_attribute);
13378	FD->setInvalidDecl();
13379	break;
13380	}
13381	}
13382	}
13383
13384	assert(ExprCleanupObjects.size() ==((ExprCleanupObjects.size() == ExprEvalContexts.back().NumCleanupObjects && "Leftover temporaries in function") ? static_cast <void> (0) : __assert_fail ("ExprCleanupObjects.size() == ExprEvalContexts.back().NumCleanupObjects && \"Leftover temporaries in function\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 13386, __PRETTY_FUNCTION__))
13385	ExprEvalContexts.back().NumCleanupObjects &&((ExprCleanupObjects.size() == ExprEvalContexts.back().NumCleanupObjects && "Leftover temporaries in function") ? static_cast <void> (0) : __assert_fail ("ExprCleanupObjects.size() == ExprEvalContexts.back().NumCleanupObjects && \"Leftover temporaries in function\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 13386, __PRETTY_FUNCTION__))
13386	"Leftover temporaries in function")((ExprCleanupObjects.size() == ExprEvalContexts.back().NumCleanupObjects && "Leftover temporaries in function") ? static_cast <void> (0) : __assert_fail ("ExprCleanupObjects.size() == ExprEvalContexts.back().NumCleanupObjects && \"Leftover temporaries in function\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 13386, __PRETTY_FUNCTION__));
13387	assert(!Cleanup.exprNeedsCleanups() && "Unaccounted cleanups in function")((!Cleanup.exprNeedsCleanups() && "Unaccounted cleanups in function" ) ? static_cast<void> (0) : __assert_fail ("!Cleanup.exprNeedsCleanups() && \"Unaccounted cleanups in function\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 13387, __PRETTY_FUNCTION__));
13388	assert(MaybeODRUseExprs.empty() &&((MaybeODRUseExprs.empty() && "Leftover expressions for odr-use checking" ) ? static_cast<void> (0) : __assert_fail ("MaybeODRUseExprs.empty() && \"Leftover expressions for odr-use checking\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 13389, __PRETTY_FUNCTION__))
13389	"Leftover expressions for odr-use checking")((MaybeODRUseExprs.empty() && "Leftover expressions for odr-use checking" ) ? static_cast<void> (0) : __assert_fail ("MaybeODRUseExprs.empty() && \"Leftover expressions for odr-use checking\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 13389, __PRETTY_FUNCTION__));
13390	}
13391
13392	if (!IsInstantiation)
13393	PopDeclContext();
13394
13395	PopFunctionScopeInfo(ActivePolicy, dcl);
13396	// If any errors have occurred, clear out any temporaries that may have
13397	// been leftover. This ensures that these temporaries won't be picked up for
13398	// deletion in some later function.
13399	if (getDiagnostics().hasErrorOccurred()) {
13400	DiscardCleanupsInEvaluationContext();
13401	}
13402
13403	return dcl;
13404	}
13405
13406	/// When we finish delayed parsing of an attribute, we must attach it to the
13407	/// relevant Decl.
13408	void Sema::ActOnFinishDelayedAttribute(Scope S, Decl D,
13409	ParsedAttributes &Attrs) {
13410	// Always attach attributes to the underlying decl.
13411	if (TemplateDecl *TD = dyn_cast<TemplateDecl>(D))
13412	D = TD->getTemplatedDecl();
13413	ProcessDeclAttributeList(S, D, Attrs);
13414
13415	if (CXXMethodDecl *Method = dyn_cast_or_null<CXXMethodDecl>(D))
13416	if (Method->isStatic())
13417	checkThisInStaticMemberFunctionAttributes(Method);
13418	}
13419
13420	/// ImplicitlyDefineFunction - An undeclared identifier was used in a function
13421	/// call, forming a call to an implicitly defined function (per C99 6.5.1p2).
13422	NamedDecl *Sema::ImplicitlyDefineFunction(SourceLocation Loc,
13423	IdentifierInfo &II, Scope *S) {
13424	// Find the scope in which the identifier is injected and the corresponding
13425	// DeclContext.
13426	// FIXME: C89 does not say what happens if there is no enclosing block scope.
13427	// In that case, we inject the declaration into the translation unit scope
13428	// instead.
13429	Scope *BlockScope = S;
13430	while (!BlockScope->isCompoundStmtScope() && BlockScope->getParent())
13431	BlockScope = BlockScope->getParent();
13432
13433	Scope *ContextScope = BlockScope;
13434	while (!ContextScope->getEntity())
13435	ContextScope = ContextScope->getParent();
13436	ContextRAII SavedContext(*this, ContextScope->getEntity());
13437
13438	// Before we produce a declaration for an implicitly defined
13439	// function, see whether there was a locally-scoped declaration of
13440	// this name as a function or variable. If so, use that
13441	// (non-visible) declaration, and complain about it.
13442	NamedDecl *ExternCPrev = findLocallyScopedExternCDecl(&II);
13443	if (ExternCPrev) {
13444	// We still need to inject the function into the enclosing block scope so
13445	// that later (non-call) uses can see it.
13446	PushOnScopeChains(ExternCPrev, BlockScope, /AddToContext/false);
13447
13448	// C89 footnote 38:
13449	// If in fact it is not defined as having type "function returning int",
13450	// the behavior is undefined.
13451	if (!isa<FunctionDecl>(ExternCPrev) \|\|
13452	!Context.typesAreCompatible(
13453	cast<FunctionDecl>(ExternCPrev)->getType(),
13454	Context.getFunctionNoProtoType(Context.IntTy))) {
13455	Diag(Loc, diag::ext_use_out_of_scope_declaration)
13456	<< ExternCPrev << !getLangOpts().C99;
13457	Diag(ExternCPrev->getLocation(), diag::note_previous_declaration);
13458	return ExternCPrev;
13459	}
13460	}
13461
13462	// Extension in C99. Legal in C90, but warn about it.
13463	unsigned diag_id;
13464	if (II.getName().startswith("__builtin_"))
13465	diag_id = diag::warn_builtin_unknown;
13466	// OpenCL v2.0 s6.9.u - Implicit function declaration is not supported.
13467	else if (getLangOpts().OpenCL)
13468	diag_id = diag::err_opencl_implicit_function_decl;
13469	else if (getLangOpts().C99)
13470	diag_id = diag::ext_implicit_function_decl;
13471	else
13472	diag_id = diag::warn_implicit_function_decl;
13473	Diag(Loc, diag_id) << &II;
13474
13475	// If we found a prior declaration of this function, don't bother building
13476	// another one. We've already pushed that one into scope, so there's nothing
13477	// more to do.
13478	if (ExternCPrev)
13479	return ExternCPrev;
13480
13481	// Because typo correction is expensive, only do it if the implicit
13482	// function declaration is going to be treated as an error.
13483	if (Diags.getDiagnosticLevel(diag_id, Loc) >= DiagnosticsEngine::Error) {
13484	TypoCorrection Corrected;
13485	if (S &&
13486	(Corrected = CorrectTypo(
13487	DeclarationNameInfo(&II, Loc), LookupOrdinaryName, S, nullptr,
13488	llvm::make_unique<DeclFilterCCC<FunctionDecl>>(), CTK_NonError)))
13489	diagnoseTypo(Corrected, PDiag(diag::note_function_suggestion),
13490	/ErrorRecovery/false);
13491	}
13492
13493	// Set a Declarator for the implicit definition: int foo();
13494	const char *Dummy;
13495	AttributeFactory attrFactory;
13496	DeclSpec DS(attrFactory);
13497	unsigned DiagID;
13498	bool Error = DS.SetTypeSpecType(DeclSpec::TST_int, Loc, Dummy, DiagID,
13499	Context.getPrintingPolicy());
13500	(void)Error; // Silence warning.
13501	assert(!Error && "Error setting up implicit decl!")((!Error && "Error setting up implicit decl!") ? static_cast <void> (0) : __assert_fail ("!Error && \"Error setting up implicit decl!\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 13501, __PRETTY_FUNCTION__));
13502	SourceLocation NoLoc;
13503	Declarator D(DS, DeclaratorContext::BlockContext);
13504	D.AddTypeInfo(DeclaratorChunk::getFunction(/HasProto=/false,
13505	/IsAmbiguous=/false,
13506	/LParenLoc=/NoLoc,
13507	/Params=/nullptr,
13508	/NumParams=/0,
13509	/EllipsisLoc=/NoLoc,
13510	/RParenLoc=/NoLoc,
13511	/TypeQuals=/0,
13512	/RefQualifierIsLvalueRef=/true,
13513	/RefQualifierLoc=/NoLoc,
13514	/ConstQualifierLoc=/NoLoc,
13515	/VolatileQualifierLoc=/NoLoc,
13516	/RestrictQualifierLoc=/NoLoc,
13517	/MutableLoc=/NoLoc, EST_None,
13518	/ESpecRange=/SourceRange(),
13519	/Exceptions=/nullptr,
13520	/ExceptionRanges=/nullptr,
13521	/NumExceptions=/0,
13522	/NoexceptExpr=/nullptr,
13523	/ExceptionSpecTokens=/nullptr,
13524	/DeclsInPrototype=/None, Loc,
13525	Loc, D),
13526	std::move(DS.getAttributes()), SourceLocation());
13527	D.SetIdentifier(&II, Loc);
13528
13529	// Insert this function into the enclosing block scope.
13530	FunctionDecl *FD = cast<FunctionDecl>(ActOnDeclarator(BlockScope, D));
13531	FD->setImplicit();
13532
13533	AddKnownFunctionAttributes(FD);
13534
13535	return FD;
13536	}
13537
13538	/// Adds any function attributes that we know a priori based on
13539	/// the declaration of this function.
13540	///
13541	/// These attributes can apply both to implicitly-declared builtins
13542	/// (like __builtin___printf_chk) or to library-declared functions
13543	/// like NSLog or printf.
13544	///
13545	/// We need to check for duplicate attributes both here and where user-written
13546	/// attributes are applied to declarations.
13547	void Sema::AddKnownFunctionAttributes(FunctionDecl *FD) {
13548	if (FD->isInvalidDecl())
13549	return;
13550
13551	// If this is a built-in function, map its builtin attributes to
13552	// actual attributes.
13553	if (unsigned BuiltinID = FD->getBuiltinID()) {
13554	// Handle printf-formatting attributes.
13555	unsigned FormatIdx;
13556	bool HasVAListArg;
13557	if (Context.BuiltinInfo.isPrintfLike(BuiltinID, FormatIdx, HasVAListArg)) {
13558	if (!FD->hasAttr<FormatAttr>()) {
13559	const char *fmt = "printf";
13560	unsigned int NumParams = FD->getNumParams();
13561	if (FormatIdx < NumParams && // NumParams may be 0 (e.g. vfprintf)
13562	FD->getParamDecl(FormatIdx)->getType()->isObjCObjectPointerType())
13563	fmt = "NSString";
13564	FD->addAttr(FormatAttr::CreateImplicit(Context,
13565	&Context.Idents.get(fmt),
13566	FormatIdx+1,
13567	HasVAListArg ? 0 : FormatIdx+2,
13568	FD->getLocation()));
13569	}
13570	}
13571	if (Context.BuiltinInfo.isScanfLike(BuiltinID, FormatIdx,
13572	HasVAListArg)) {
13573	if (!FD->hasAttr<FormatAttr>())
13574	FD->addAttr(FormatAttr::CreateImplicit(Context,
13575	&Context.Idents.get("scanf"),
13576	FormatIdx+1,
13577	HasVAListArg ? 0 : FormatIdx+2,
13578	FD->getLocation()));
13579	}
13580
13581	// Mark const if we don't care about errno and that is the only thing
13582	// preventing the function from being const. This allows IRgen to use LLVM
13583	// intrinsics for such functions.
13584	if (!getLangOpts().MathErrno && !FD->hasAttr<ConstAttr>() &&
13585	Context.BuiltinInfo.isConstWithoutErrno(BuiltinID))
13586	FD->addAttr(ConstAttr::CreateImplicit(Context, FD->getLocation()));
13587
13588	// We make "fma" on some platforms const because we know it does not set
13589	// errno in those environments even though it could set errno based on the
13590	// C standard.
13591	const llvm::Triple &Trip = Context.getTargetInfo().getTriple();
13592	if ((Trip.isGNUEnvironment() \|\| Trip.isAndroid() \|\| Trip.isOSMSVCRT()) &&
13593	!FD->hasAttr<ConstAttr>()) {
13594	switch (BuiltinID) {
13595	case Builtin::BI__builtin_fma:
13596	case Builtin::BI__builtin_fmaf:
13597	case Builtin::BI__builtin_fmal:
13598	case Builtin::BIfma:
13599	case Builtin::BIfmaf:
13600	case Builtin::BIfmal:
13601	FD->addAttr(ConstAttr::CreateImplicit(Context, FD->getLocation()));
13602	break;
13603	default:
13604	break;
13605	}
13606	}
13607
13608	if (Context.BuiltinInfo.isReturnsTwice(BuiltinID) &&
13609	!FD->hasAttr<ReturnsTwiceAttr>())
13610	FD->addAttr(ReturnsTwiceAttr::CreateImplicit(Context,
13611	FD->getLocation()));
13612	if (Context.BuiltinInfo.isNoThrow(BuiltinID) && !FD->hasAttr<NoThrowAttr>())
13613	FD->addAttr(NoThrowAttr::CreateImplicit(Context, FD->getLocation()));
13614	if (Context.BuiltinInfo.isPure(BuiltinID) && !FD->hasAttr<PureAttr>())
13615	FD->addAttr(PureAttr::CreateImplicit(Context, FD->getLocation()));
13616	if (Context.BuiltinInfo.isConst(BuiltinID) && !FD->hasAttr<ConstAttr>())
13617	FD->addAttr(ConstAttr::CreateImplicit(Context, FD->getLocation()));
13618	if (getLangOpts().CUDA && Context.BuiltinInfo.isTSBuiltin(BuiltinID) &&
13619	!FD->hasAttr<CUDADeviceAttr>() && !FD->hasAttr<CUDAHostAttr>()) {
13620	// Add the appropriate attribute, depending on the CUDA compilation mode
13621	// and which target the builtin belongs to. For example, during host
13622	// compilation, aux builtins are __device__, while the rest are __host__.
13623	if (getLangOpts().CUDAIsDevice !=
13624	Context.BuiltinInfo.isAuxBuiltinID(BuiltinID))
13625	FD->addAttr(CUDADeviceAttr::CreateImplicit(Context, FD->getLocation()));
13626	else
13627	FD->addAttr(CUDAHostAttr::CreateImplicit(Context, FD->getLocation()));
13628	}
13629	}
13630
13631	// If C++ exceptions are enabled but we are told extern "C" functions cannot
13632	// throw, add an implicit nothrow attribute to any extern "C" function we come
13633	// across.
13634	if (getLangOpts().CXXExceptions && getLangOpts().ExternCNoUnwind &&
13635	FD->isExternC() && !FD->hasAttr<NoThrowAttr>()) {
13636	const auto *FPT = FD->getType()->getAs<FunctionProtoType>();
13637	if (!FPT \|\| FPT->getExceptionSpecType() == EST_None)
13638	FD->addAttr(NoThrowAttr::CreateImplicit(Context, FD->getLocation()));
13639	}
13640
13641	IdentifierInfo *Name = FD->getIdentifier();
13642	if (!Name)
13643	return;
13644	if ((!getLangOpts().CPlusPlus &&
13645	FD->getDeclContext()->isTranslationUnit()) \|\|
13646	(isa<LinkageSpecDecl>(FD->getDeclContext()) &&
13647	cast<LinkageSpecDecl>(FD->getDeclContext())->getLanguage() ==
13648	LinkageSpecDecl::lang_c)) {
13649	// Okay: this could be a libc/libm/Objective-C function we know
13650	// about.
13651	} else
13652	return;
13653
13654	if (Name->isStr("asprintf") \|\| Name->isStr("vasprintf")) {
13655	// FIXME: asprintf and vasprintf aren't C99 functions. Should they be
13656	// target-specific builtins, perhaps?
13657	if (!FD->hasAttr<FormatAttr>())
13658	FD->addAttr(FormatAttr::CreateImplicit(Context,
13659	&Context.Idents.get("printf"), 2,
13660	Name->isStr("vasprintf") ? 0 : 3,
13661	FD->getLocation()));
13662	}
13663
13664	if (Name->isStr("__CFStringMakeConstantString")) {
13665	// We already have a __builtin___CFStringMakeConstantString,
13666	// but builds that use -fno-constant-cfstrings don't go through that.
13667	if (!FD->hasAttr<FormatArgAttr>())
13668	FD->addAttr(FormatArgAttr::CreateImplicit(Context, ParamIdx(1, FD),
13669	FD->getLocation()));
13670	}
13671	}
13672
13673	TypedefDecl Sema::ParseTypedefDecl(Scope S, Declarator &D, QualType T,
13674	TypeSourceInfo *TInfo) {
13675	assert(D.getIdentifier() && "Wrong callback for declspec without declarator")((D.getIdentifier() && "Wrong callback for declspec without declarator" ) ? static_cast<void> (0) : __assert_fail ("D.getIdentifier() && \"Wrong callback for declspec without declarator\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 13675, __PRETTY_FUNCTION__));
13676	assert(!T.isNull() && "GetTypeForDeclarator() returned null type")((!T.isNull() && "GetTypeForDeclarator() returned null type" ) ? static_cast<void> (0) : __assert_fail ("!T.isNull() && \"GetTypeForDeclarator() returned null type\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 13676, __PRETTY_FUNCTION__));
13677
13678	if (!TInfo) {
13679	assert(D.isInvalidType() && "no declarator info for valid type")((D.isInvalidType() && "no declarator info for valid type" ) ? static_cast<void> (0) : __assert_fail ("D.isInvalidType() && \"no declarator info for valid type\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 13679, __PRETTY_FUNCTION__));
13680	TInfo = Context.getTrivialTypeSourceInfo(T);
13681	}
13682
13683	// Scope manipulation handled by caller.
13684	TypedefDecl *NewTD =
13685	TypedefDecl::Create(Context, CurContext, D.getBeginLoc(),
13686	D.getIdentifierLoc(), D.getIdentifier(), TInfo);
13687
13688	// Bail out immediately if we have an invalid declaration.
13689	if (D.isInvalidType()) {
13690	NewTD->setInvalidDecl();
13691	return NewTD;
13692	}
13693
13694	if (D.getDeclSpec().isModulePrivateSpecified()) {
13695	if (CurContext->isFunctionOrMethod())
13696	Diag(NewTD->getLocation(), diag::err_module_private_local)
13697	<< 2 << NewTD->getDeclName()
13698	<< SourceRange(D.getDeclSpec().getModulePrivateSpecLoc())
13699	<< FixItHint::CreateRemoval(D.getDeclSpec().getModulePrivateSpecLoc());
13700	else
13701	NewTD->setModulePrivate();
13702	}
13703
13704	// C++ [dcl.typedef]p8:
13705	// If the typedef declaration defines an unnamed class (or
13706	// enum), the first typedef-name declared by the declaration
13707	// to be that class type (or enum type) is used to denote the
13708	// class type (or enum type) for linkage purposes only.
13709	// We need to check whether the type was declared in the declaration.
13710	switch (D.getDeclSpec().getTypeSpecType()) {
13711	case TST_enum:
13712	case TST_struct:
13713	case TST_interface:
13714	case TST_union:
13715	case TST_class: {
13716	TagDecl *tagFromDeclSpec = cast<TagDecl>(D.getDeclSpec().getRepAsDecl());
13717	setTagNameForLinkagePurposes(tagFromDeclSpec, NewTD);
13718	break;
13719	}
13720
13721	default:
13722	break;
13723	}
13724
13725	return NewTD;
13726	}
13727
13728	/// Check that this is a valid underlying type for an enum declaration.
13729	bool Sema::CheckEnumUnderlyingType(TypeSourceInfo *TI) {
13730	SourceLocation UnderlyingLoc = TI->getTypeLoc().getBeginLoc();
13731	QualType T = TI->getType();
13732
13733	if (T->isDependentType())
13734	return false;
13735
13736	if (const BuiltinType *BT = T->getAs<BuiltinType>())
13737	if (BT->isInteger())
13738	return false;
13739
13740	Diag(UnderlyingLoc, diag::err_enum_invalid_underlying) << T;
13741	return true;
13742	}
13743
13744	/// Check whether this is a valid redeclaration of a previous enumeration.
13745	/// \return true if the redeclaration was invalid.
13746	bool Sema::CheckEnumRedeclaration(SourceLocation EnumLoc, bool IsScoped,
13747	QualType EnumUnderlyingTy, bool IsFixed,
13748	const EnumDecl *Prev) {
13749	if (IsScoped != Prev->isScoped()) {
13750	Diag(EnumLoc, diag::err_enum_redeclare_scoped_mismatch)
13751	<< Prev->isScoped();
13752	Diag(Prev->getLocation(), diag::note_previous_declaration);
13753	return true;
13754	}
13755
13756	if (IsFixed && Prev->isFixed()) {
13757	if (!EnumUnderlyingTy->isDependentType() &&
13758	!Prev->getIntegerType()->isDependentType() &&
13759	!Context.hasSameUnqualifiedType(EnumUnderlyingTy,
13760	Prev->getIntegerType())) {
13761	// TODO: Highlight the underlying type of the redeclaration.
13762	Diag(EnumLoc, diag::err_enum_redeclare_type_mismatch)
13763	<< EnumUnderlyingTy << Prev->getIntegerType();
13764	Diag(Prev->getLocation(), diag::note_previous_declaration)
13765	<< Prev->getIntegerTypeRange();
13766	return true;
13767	}
13768	} else if (IsFixed != Prev->isFixed()) {
13769	Diag(EnumLoc, diag::err_enum_redeclare_fixed_mismatch)
13770	<< Prev->isFixed();
13771	Diag(Prev->getLocation(), diag::note_previous_declaration);
13772	return true;
13773	}
13774
13775	return false;
13776	}
13777
13778	/// Get diagnostic %select index for tag kind for
13779	/// redeclaration diagnostic message.
13780	/// WARNING: Indexes apply to particular diagnostics only!
13781	///
13782	/// \returns diagnostic %select index.
13783	static unsigned getRedeclDiagFromTagKind(TagTypeKind Tag) {
13784	switch (Tag) {
13785	case TTK_Struct: return 0;
13786	case TTK_Interface: return 1;
13787	case TTK_Class: return 2;
13788	default: llvm_unreachable("Invalid tag kind for redecl diagnostic!")::llvm::llvm_unreachable_internal("Invalid tag kind for redecl diagnostic!" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 13788);
13789	}
13790	}
13791
13792	/// Determine if tag kind is a class-key compatible with
13793	/// class for redeclaration (class, struct, or __interface).
13794	///
13795	/// \returns true iff the tag kind is compatible.
13796	static bool isClassCompatTagKind(TagTypeKind Tag)
13797	{
13798	return Tag == TTK_Struct \|\| Tag == TTK_Class \|\| Tag == TTK_Interface;
13799	}
13800
13801	Sema::NonTagKind Sema::getNonTagTypeDeclKind(const Decl *PrevDecl,
13802	TagTypeKind TTK) {
13803	if (isa<TypedefDecl>(PrevDecl))
13804	return NTK_Typedef;
13805	else if (isa<TypeAliasDecl>(PrevDecl))
13806	return NTK_TypeAlias;
13807	else if (isa<ClassTemplateDecl>(PrevDecl))
13808	return NTK_Template;
13809	else if (isa<TypeAliasTemplateDecl>(PrevDecl))
13810	return NTK_TypeAliasTemplate;
13811	else if (isa<TemplateTemplateParmDecl>(PrevDecl))
13812	return NTK_TemplateTemplateArgument;
13813	switch (TTK) {
13814	case TTK_Struct:
13815	case TTK_Interface:
13816	case TTK_Class:
13817	return getLangOpts().CPlusPlus ? NTK_NonClass : NTK_NonStruct;
13818	case TTK_Union:
13819	return NTK_NonUnion;
13820	case TTK_Enum:
13821	return NTK_NonEnum;
13822	}
13823	llvm_unreachable("invalid TTK")::llvm::llvm_unreachable_internal("invalid TTK", "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 13823);
13824	}
13825
13826	/// Determine whether a tag with a given kind is acceptable
13827	/// as a redeclaration of the given tag declaration.
13828	///
13829	/// \returns true if the new tag kind is acceptable, false otherwise.
13830	bool Sema::isAcceptableTagRedeclaration(const TagDecl *Previous,
13831	TagTypeKind NewTag, bool isDefinition,
13832	SourceLocation NewTagLoc,
13833	const IdentifierInfo *Name) {
13834	// C++ [dcl.type.elab]p3:
13835	// The class-key or enum keyword present in the
13836	// elaborated-type-specifier shall agree in kind with the
13837	// declaration to which the name in the elaborated-type-specifier
13838	// refers. This rule also applies to the form of
13839	// elaborated-type-specifier that declares a class-name or
13840	// friend class since it can be construed as referring to the
13841	// definition of the class. Thus, in any
13842	// elaborated-type-specifier, the enum keyword shall be used to
13843	// refer to an enumeration (7.2), the union class-key shall be
13844	// used to refer to a union (clause 9), and either the class or
13845	// struct class-key shall be used to refer to a class (clause 9)
13846	// declared using the class or struct class-key.
13847	TagTypeKind OldTag = Previous->getTagKind();
13848	if (OldTag != NewTag &&
13849	!(isClassCompatTagKind(OldTag) && isClassCompatTagKind(NewTag)))
13850	return false;
13851
13852	// Tags are compatible, but we might still want to warn on mismatched tags.
13853	// Non-class tags can't be mismatched at this point.
13854	if (!isClassCompatTagKind(NewTag))
13855	return true;
13856
13857	// Declarations for which -Wmismatched-tags is disabled are entirely ignored
13858	// by our warning analysis. We don't want to warn about mismatches with (eg)
13859	// declarations in system headers that are designed to be specialized, but if
13860	// a user asks us to warn, we should warn if their code contains mismatched
13861	// declarations.
13862	auto IsIgnoredLoc = [&](SourceLocation Loc) {
13863	return getDiagnostics().isIgnored(diag::warn_struct_class_tag_mismatch,
13864	Loc);
13865	};
13866	if (IsIgnoredLoc(NewTagLoc))
13867	return true;
13868
13869	auto IsIgnored = [&](const TagDecl *Tag) {
13870	return IsIgnoredLoc(Tag->getLocation());
13871	};
13872	while (IsIgnored(Previous)) {
13873	Previous = Previous->getPreviousDecl();
13874	if (!Previous)
13875	return true;
13876	OldTag = Previous->getTagKind();
13877	}
13878
13879	bool isTemplate = false;
13880	if (const CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(Previous))
13881	isTemplate = Record->getDescribedClassTemplate();
13882
13883	if (inTemplateInstantiation()) {
13884	if (OldTag != NewTag) {
13885	// In a template instantiation, do not offer fix-its for tag mismatches
13886	// since they usually mess up the template instead of fixing the problem.
13887	Diag(NewTagLoc, diag::warn_struct_class_tag_mismatch)
13888	<< getRedeclDiagFromTagKind(NewTag) << isTemplate << Name
13889	<< getRedeclDiagFromTagKind(OldTag);
13890	// FIXME: Note previous location?
13891	}
13892	return true;
13893	}
13894
13895	if (isDefinition) {
13896	// On definitions, check all previous tags and issue a fix-it for each
13897	// one that doesn't match the current tag.
13898	if (Previous->getDefinition()) {
13899	// Don't suggest fix-its for redefinitions.
13900	return true;
13901	}
13902
13903	bool previousMismatch = false;
13904	for (const TagDecl *I : Previous->redecls()) {
13905	if (I->getTagKind() != NewTag) {
13906	// Ignore previous declarations for which the warning was disabled.
13907	if (IsIgnored(I))
13908	continue;
13909
13910	if (!previousMismatch) {
13911	previousMismatch = true;
13912	Diag(NewTagLoc, diag::warn_struct_class_previous_tag_mismatch)
13913	<< getRedeclDiagFromTagKind(NewTag) << isTemplate << Name
13914	<< getRedeclDiagFromTagKind(I->getTagKind());
13915	}
13916	Diag(I->getInnerLocStart(), diag::note_struct_class_suggestion)
13917	<< getRedeclDiagFromTagKind(NewTag)
13918	<< FixItHint::CreateReplacement(I->getInnerLocStart(),
13919	TypeWithKeyword::getTagTypeKindName(NewTag));
13920	}
13921	}
13922	return true;
13923	}
13924
13925	// Identify the prevailing tag kind: this is the kind of the definition (if
13926	// there is a non-ignored definition), or otherwise the kind of the prior
13927	// (non-ignored) declaration.
13928	const TagDecl *PrevDef = Previous->getDefinition();
13929	if (PrevDef && IsIgnored(PrevDef))
13930	PrevDef = nullptr;
13931	const TagDecl *Redecl = PrevDef ? PrevDef : Previous;
13932	if (Redecl->getTagKind() != NewTag) {
13933	Diag(NewTagLoc, diag::warn_struct_class_tag_mismatch)
13934	<< getRedeclDiagFromTagKind(NewTag) << isTemplate << Name
13935	<< getRedeclDiagFromTagKind(OldTag);
13936	Diag(Redecl->getLocation(), diag::note_previous_use);
13937
13938	// If there is a previous definition, suggest a fix-it.
13939	if (PrevDef) {
13940	Diag(NewTagLoc, diag::note_struct_class_suggestion)
13941	<< getRedeclDiagFromTagKind(Redecl->getTagKind())
13942	<< FixItHint::CreateReplacement(SourceRange(NewTagLoc),
13943	TypeWithKeyword::getTagTypeKindName(Redecl->getTagKind()));
13944	}
13945	}
13946
13947	return true;
13948	}
13949
13950	/// Add a minimal nested name specifier fixit hint to allow lookup of a tag name
13951	/// from an outer enclosing namespace or file scope inside a friend declaration.
13952	/// This should provide the commented out code in the following snippet:
13953	/// namespace N {
13954	/// struct X;
13955	/// namespace M {
13956	/// struct Y { friend struct /N::/ X; };
13957	/// }
13958	/// }
13959	static FixItHint createFriendTagNNSFixIt(Sema &SemaRef, NamedDecl ND, Scope S,
13960	SourceLocation NameLoc) {
13961	// While the decl is in a namespace, do repeated lookup of that name and see
13962	// if we get the same namespace back. If we do not, continue until
13963	// translation unit scope, at which point we have a fully qualified NNS.
13964	SmallVector<IdentifierInfo *, 4> Namespaces;
13965	DeclContext *DC = ND->getDeclContext()->getRedeclContext();
13966	for (; !DC->isTranslationUnit(); DC = DC->getParent()) {
13967	// This tag should be declared in a namespace, which can only be enclosed by
13968	// other namespaces. Bail if there's an anonymous namespace in the chain.
13969	NamespaceDecl *Namespace = dyn_cast<NamespaceDecl>(DC);
13970	if (!Namespace \|\| Namespace->isAnonymousNamespace())
13971	return FixItHint();
13972	IdentifierInfo *II = Namespace->getIdentifier();
13973	Namespaces.push_back(II);
13974	NamedDecl *Lookup = SemaRef.LookupSingleName(
13975	S, II, NameLoc, Sema::LookupNestedNameSpecifierName);
13976	if (Lookup == Namespace)
13977	break;
13978	}
13979
13980	// Once we have all the namespaces, reverse them to go outermost first, and
13981	// build an NNS.
13982	SmallString<64> Insertion;
13983	llvm::raw_svector_ostream OS(Insertion);
13984	if (DC->isTranslationUnit())
13985	OS << "::";
13986	std::reverse(Namespaces.begin(), Namespaces.end());
13987	for (auto *II : Namespaces)
13988	OS << II->getName() << "::";
13989	return FixItHint::CreateInsertion(NameLoc, Insertion);
13990	}
13991
13992	/// Determine whether a tag originally declared in context \p OldDC can
13993	/// be redeclared with an unqualified name in \p NewDC (assuming name lookup
13994	/// found a declaration in \p OldDC as a previous decl, perhaps through a
13995	/// using-declaration).
13996	static bool isAcceptableTagRedeclContext(Sema &S, DeclContext *OldDC,
13997	DeclContext *NewDC) {
13998	OldDC = OldDC->getRedeclContext();
13999	NewDC = NewDC->getRedeclContext();
14000
14001	if (OldDC->Equals(NewDC))
14002	return true;
14003
14004	// In MSVC mode, we allow a redeclaration if the contexts are related (either
14005	// encloses the other).
14006	if (S.getLangOpts().MSVCCompat &&
14007	(OldDC->Encloses(NewDC) \|\| NewDC->Encloses(OldDC)))
14008	return true;
14009
14010	return false;
14011	}
14012
14013	/// This is invoked when we see 'struct foo' or 'struct {'. In the
14014	/// former case, Name will be non-null. In the later case, Name will be null.
14015	/// TagSpec indicates what kind of tag this is. TUK indicates whether this is a
14016	/// reference/declaration/definition of a tag.
14017	///
14018	/// \param IsTypeSpecifier \c true if this is a type-specifier (or
14019	/// trailing-type-specifier) other than one in an alias-declaration.
14020	///
14021	/// \param SkipBody If non-null, will be set to indicate if the caller should
14022	/// skip the definition of this tag and treat it as if it were a declaration.
14023	Decl Sema::ActOnTag(Scope S, unsigned TagSpec, TagUseKind TUK,
14024	SourceLocation KWLoc, CXXScopeSpec &SS,
14025	IdentifierInfo *Name, SourceLocation NameLoc,
14026	const ParsedAttributesView &Attrs, AccessSpecifier AS,
14027	SourceLocation ModulePrivateLoc,
14028	MultiTemplateParamsArg TemplateParameterLists,
14029	bool &OwnedDecl, bool &IsDependent,
14030	SourceLocation ScopedEnumKWLoc,
14031	bool ScopedEnumUsesClassTag, TypeResult UnderlyingType,
14032	bool IsTypeSpecifier, bool IsTemplateParamOrArg,
14033	SkipBodyInfo *SkipBody) {
14034	// If this is not a definition, it must have a name.
14035	IdentifierInfo *OrigName = Name;
14036	assert((Name != nullptr \|\| TUK == TUK_Definition) &&(((Name != nullptr \|\| TUK == TUK_Definition) && "Nameless record must be a definition!" ) ? static_cast<void> (0) : __assert_fail ("(Name != nullptr \|\| TUK == TUK_Definition) && \"Nameless record must be a definition!\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 14037, __PRETTY_FUNCTION__))
14037	"Nameless record must be a definition!")(((Name != nullptr \|\| TUK == TUK_Definition) && "Nameless record must be a definition!" ) ? static_cast<void> (0) : __assert_fail ("(Name != nullptr \|\| TUK == TUK_Definition) && \"Nameless record must be a definition!\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 14037, __PRETTY_FUNCTION__));
14038	assert(TemplateParameterLists.size() == 0 \|\| TUK != TUK_Reference)((TemplateParameterLists.size() == 0 \|\| TUK != TUK_Reference) ? static_cast<void> (0) : __assert_fail ("TemplateParameterLists.size() == 0 \|\| TUK != TUK_Reference" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 14038, __PRETTY_FUNCTION__));
14039
14040	OwnedDecl = false;
14041	TagTypeKind Kind = TypeWithKeyword::getTagTypeKindForTypeSpec(TagSpec);
14042	bool ScopedEnum = ScopedEnumKWLoc.isValid();
14043
14044	// FIXME: Check member specializations more carefully.
14045	bool isMemberSpecialization = false;
14046	bool Invalid = false;
14047
14048	// We only need to do this matching if we have template parameters
14049	// or a scope specifier, which also conveniently avoids this work
14050	// for non-C++ cases.
14051	if (TemplateParameterLists.size() > 0 \|\|
14052	(SS.isNotEmpty() && TUK != TUK_Reference)) {
14053	if (TemplateParameterList *TemplateParams =
14054	MatchTemplateParametersToScopeSpecifier(
14055	KWLoc, NameLoc, SS, nullptr, TemplateParameterLists,
14056	TUK == TUK_Friend, isMemberSpecialization, Invalid)) {
14057	if (Kind == TTK_Enum) {
14058	Diag(KWLoc, diag::err_enum_template);
14059	return nullptr;
14060	}
14061
14062	if (TemplateParams->size() > 0) {
14063	// This is a declaration or definition of a class template (which may
14064	// be a member of another template).
14065
14066	if (Invalid)
14067	return nullptr;
14068
14069	OwnedDecl = false;
14070	DeclResult Result = CheckClassTemplate(
14071	S, TagSpec, TUK, KWLoc, SS, Name, NameLoc, Attrs, TemplateParams,
14072	AS, ModulePrivateLoc,
14073	/FriendLoc/ SourceLocation(), TemplateParameterLists.size() - 1,
14074	TemplateParameterLists.data(), SkipBody);
14075	return Result.get();
14076	} else {
14077	// The "template<>" header is extraneous.
14078	Diag(TemplateParams->getTemplateLoc(), diag::err_template_tag_noparams)
14079	<< TypeWithKeyword::getTagTypeKindName(Kind) << Name;
14080	isMemberSpecialization = true;
14081	}
14082	}
14083	}
14084
14085	// Figure out the underlying type if this a enum declaration. We need to do
14086	// this early, because it's needed to detect if this is an incompatible
14087	// redeclaration.
14088	llvm::PointerUnion<const Type, TypeSourceInfo> EnumUnderlying;
14089	bool IsFixed = !UnderlyingType.isUnset() \|\| ScopedEnum;
14090
14091	if (Kind == TTK_Enum) {
14092	if (UnderlyingType.isInvalid() \|\| (!UnderlyingType.get() && ScopedEnum)) {
14093	// No underlying type explicitly specified, or we failed to parse the
14094	// type, default to int.
14095	EnumUnderlying = Context.IntTy.getTypePtr();
14096	} else if (UnderlyingType.get()) {
14097	// C++0x 7.2p2: The type-specifier-seq of an enum-base shall name an
14098	// integral type; any cv-qualification is ignored.
14099	TypeSourceInfo *TI = nullptr;
14100	GetTypeFromParser(UnderlyingType.get(), &TI);
14101	EnumUnderlying = TI;
14102
14103	if (CheckEnumUnderlyingType(TI))
14104	// Recover by falling back to int.
14105	EnumUnderlying = Context.IntTy.getTypePtr();
14106
14107	if (DiagnoseUnexpandedParameterPack(TI->getTypeLoc().getBeginLoc(), TI,
14108	UPPC_FixedUnderlyingType))
14109	EnumUnderlying = Context.IntTy.getTypePtr();
14110
14111	} else if (Context.getTargetInfo().getCXXABI().isMicrosoft()) {
14112	// For MSVC ABI compatibility, unfixed enums must use an underlying type
14113	// of 'int'. However, if this is an unfixed forward declaration, don't set
14114	// the underlying type unless the user enables -fms-compatibility. This
14115	// makes unfixed forward declared enums incomplete and is more conforming.
14116	if (TUK == TUK_Definition \|\| getLangOpts().MSVCCompat)
14117	EnumUnderlying = Context.IntTy.getTypePtr();
14118	}
14119	}
14120
14121	DeclContext *SearchDC = CurContext;
14122	DeclContext *DC = CurContext;
14123	bool isStdBadAlloc = false;
14124	bool isStdAlignValT = false;
14125
14126	RedeclarationKind Redecl = forRedeclarationInCurContext();
14127	if (TUK == TUK_Friend \|\| TUK == TUK_Reference)
14128	Redecl = NotForRedeclaration;
14129
14130	/// Create a new tag decl in C/ObjC. Since the ODR-like semantics for ObjC/C
14131	/// implemented asks for structural equivalence checking, the returned decl
14132	/// here is passed back to the parser, allowing the tag body to be parsed.
14133	auto createTagFromNewDecl = [&]() -> TagDecl * {
14134	assert(!getLangOpts().CPlusPlus && "not meant for C++ usage")((!getLangOpts().CPlusPlus && "not meant for C++ usage" ) ? static_cast<void> (0) : __assert_fail ("!getLangOpts().CPlusPlus && \"not meant for C++ usage\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 14134, __PRETTY_FUNCTION__));
14135	// If there is an identifier, use the location of the identifier as the
14136	// location of the decl, otherwise use the location of the struct/union
14137	// keyword.
14138	SourceLocation Loc = NameLoc.isValid() ? NameLoc : KWLoc;
14139	TagDecl *New = nullptr;
14140
14141	if (Kind == TTK_Enum) {
14142	New = EnumDecl::Create(Context, SearchDC, KWLoc, Loc, Name, nullptr,
14143	ScopedEnum, ScopedEnumUsesClassTag, IsFixed);
14144	// If this is an undefined enum, bail.
14145	if (TUK != TUK_Definition && !Invalid)
14146	return nullptr;
14147	if (EnumUnderlying) {
14148	EnumDecl *ED = cast<EnumDecl>(New);
14149	if (TypeSourceInfo TI = EnumUnderlying.dyn_cast<TypeSourceInfo >())
14150	ED->setIntegerTypeSourceInfo(TI);
14151	else
14152	ED->setIntegerType(QualType(EnumUnderlying.get<const Type *>(), 0));
14153	ED->setPromotionType(ED->getIntegerType());
14154	}
14155	} else { // struct/union
14156	New = RecordDecl::Create(Context, Kind, SearchDC, KWLoc, Loc, Name,
14157	nullptr);
14158	}
14159
14160	if (RecordDecl *RD = dyn_cast<RecordDecl>(New)) {
14161	// Add alignment attributes if necessary; these attributes are checked
14162	// when the ASTContext lays out the structure.
14163	//
14164	// It is important for implementing the correct semantics that this
14165	// happen here (in ActOnTag). The #pragma pack stack is
14166	// maintained as a result of parser callbacks which can occur at
14167	// many points during the parsing of a struct declaration (because
14168	// the #pragma tokens are effectively skipped over during the
14169	// parsing of the struct).
14170	if (TUK == TUK_Definition && (!SkipBody \|\| !SkipBody->ShouldSkip)) {
14171	AddAlignmentAttributesForRecord(RD);
14172	AddMsStructLayoutForRecord(RD);
14173	}
14174	}
14175	New->setLexicalDeclContext(CurContext);
14176	return New;
14177	};
14178
14179	LookupResult Previous(*this, Name, NameLoc, LookupTagName, Redecl);
14180	if (Name && SS.isNotEmpty()) {
14181	// We have a nested-name tag ('struct foo::bar').
14182
14183	// Check for invalid 'foo::'.
14184	if (SS.isInvalid()) {
14185	Name = nullptr;
14186	goto CreateNewDecl;
14187	}
14188
14189	// If this is a friend or a reference to a class in a dependent
14190	// context, don't try to make a decl for it.
14191	if (TUK == TUK_Friend \|\| TUK == TUK_Reference) {
14192	DC = computeDeclContext(SS, false);
14193	if (!DC) {
14194	IsDependent = true;
14195	return nullptr;
14196	}
14197	} else {
14198	DC = computeDeclContext(SS, true);
14199	if (!DC) {
14200	Diag(SS.getRange().getBegin(), diag::err_dependent_nested_name_spec)
14201	<< SS.getRange();
14202	return nullptr;
14203	}
14204	}
14205
14206	if (RequireCompleteDeclContext(SS, DC))
14207	return nullptr;
14208
14209	SearchDC = DC;
14210	// Look-up name inside 'foo::'.
14211	LookupQualifiedName(Previous, DC);
14212
14213	if (Previous.isAmbiguous())
14214	return nullptr;
14215
14216	if (Previous.empty()) {
14217	// Name lookup did not find anything. However, if the
14218	// nested-name-specifier refers to the current instantiation,
14219	// and that current instantiation has any dependent base
14220	// classes, we might find something at instantiation time: treat
14221	// this as a dependent elaborated-type-specifier.
14222	// But this only makes any sense for reference-like lookups.
14223	if (Previous.wasNotFoundInCurrentInstantiation() &&
14224	(TUK == TUK_Reference \|\| TUK == TUK_Friend)) {
14225	IsDependent = true;
14226	return nullptr;
14227	}
14228
14229	// A tag 'foo::bar' must already exist.
14230	Diag(NameLoc, diag::err_not_tag_in_scope)
14231	<< Kind << Name << DC << SS.getRange();
14232	Name = nullptr;
14233	Invalid = true;
14234	goto CreateNewDecl;
14235	}
14236	} else if (Name) {
14237	// C++14 [class.mem]p14:
14238	// If T is the name of a class, then each of the following shall have a
14239	// name different from T:
14240	// -- every member of class T that is itself a type
14241	if (TUK != TUK_Reference && TUK != TUK_Friend &&
14242	DiagnoseClassNameShadow(SearchDC, DeclarationNameInfo(Name, NameLoc)))
14243	return nullptr;
14244
14245	// If this is a named struct, check to see if there was a previous forward
14246	// declaration or definition.
14247	// FIXME: We're looking into outer scopes here, even when we
14248	// shouldn't be. Doing so can result in ambiguities that we
14249	// shouldn't be diagnosing.
14250	LookupName(Previous, S);
14251
14252	// When declaring or defining a tag, ignore ambiguities introduced
14253	// by types using'ed into this scope.
14254	if (Previous.isAmbiguous() &&
14255	(TUK == TUK_Definition \|\| TUK == TUK_Declaration)) {
14256	LookupResult::Filter F = Previous.makeFilter();
14257	while (F.hasNext()) {
14258	NamedDecl *ND = F.next();
14259	if (!ND->getDeclContext()->getRedeclContext()->Equals(
14260	SearchDC->getRedeclContext()))
14261	F.erase();
14262	}
14263	F.done();
14264	}
14265
14266	// C++11 [namespace.memdef]p3:
14267	// If the name in a friend declaration is neither qualified nor
14268	// a template-id and the declaration is a function or an
14269	// elaborated-type-specifier, the lookup to determine whether
14270	// the entity has been previously declared shall not consider
14271	// any scopes outside the innermost enclosing namespace.
14272	//
14273	// MSVC doesn't implement the above rule for types, so a friend tag
14274	// declaration may be a redeclaration of a type declared in an enclosing
14275	// scope. They do implement this rule for friend functions.
14276	//
14277	// Does it matter that this should be by scope instead of by
14278	// semantic context?
14279	if (!Previous.empty() && TUK == TUK_Friend) {
14280	DeclContext *EnclosingNS = SearchDC->getEnclosingNamespaceContext();
14281	LookupResult::Filter F = Previous.makeFilter();
14282	bool FriendSawTagOutsideEnclosingNamespace = false;
14283	while (F.hasNext()) {
14284	NamedDecl *ND = F.next();
14285	DeclContext *DC = ND->getDeclContext()->getRedeclContext();
14286	if (DC->isFileContext() &&
14287	!EnclosingNS->Encloses(ND->getDeclContext())) {
14288	if (getLangOpts().MSVCCompat)
14289	FriendSawTagOutsideEnclosingNamespace = true;
14290	else
14291	F.erase();
14292	}
14293	}
14294	F.done();
14295
14296	// Diagnose this MSVC extension in the easy case where lookup would have
14297	// unambiguously found something outside the enclosing namespace.
14298	if (Previous.isSingleResult() && FriendSawTagOutsideEnclosingNamespace) {
14299	NamedDecl *ND = Previous.getFoundDecl();
14300	Diag(NameLoc, diag::ext_friend_tag_redecl_outside_namespace)
14301	<< createFriendTagNNSFixIt(*this, ND, S, NameLoc);
14302	}
14303	}
14304
14305	// Note: there used to be some attempt at recovery here.
14306	if (Previous.isAmbiguous())
14307	return nullptr;
14308
14309	if (!getLangOpts().CPlusPlus && TUK != TUK_Reference) {
14310	// FIXME: This makes sure that we ignore the contexts associated
14311	// with C structs, unions, and enums when looking for a matching
14312	// tag declaration or definition. See the similar lookup tweak
14313	// in Sema::LookupName; is there a better way to deal with this?
14314	while (isa<RecordDecl>(SearchDC) \|\| isa<EnumDecl>(SearchDC))
14315	SearchDC = SearchDC->getParent();
14316	}
14317	}
14318
14319	if (Previous.isSingleResult() &&
14320	Previous.getFoundDecl()->isTemplateParameter()) {
14321	// Maybe we will complain about the shadowed template parameter.
14322	DiagnoseTemplateParameterShadow(NameLoc, Previous.getFoundDecl());
14323	// Just pretend that we didn't see the previous declaration.
14324	Previous.clear();
14325	}
14326
14327	if (getLangOpts().CPlusPlus && Name && DC && StdNamespace &&
14328	DC->Equals(getStdNamespace())) {
14329	if (Name->isStr("bad_alloc")) {
14330	// This is a declaration of or a reference to "std::bad_alloc".
14331	isStdBadAlloc = true;
14332
14333	// If std::bad_alloc has been implicitly declared (but made invisible to
14334	// name lookup), fill in this implicit declaration as the previous
14335	// declaration, so that the declarations get chained appropriately.
14336	if (Previous.empty() && StdBadAlloc)
14337	Previous.addDecl(getStdBadAlloc());
14338	} else if (Name->isStr("align_val_t")) {
14339	isStdAlignValT = true;
14340	if (Previous.empty() && StdAlignValT)
14341	Previous.addDecl(getStdAlignValT());
14342	}
14343	}
14344
14345	// If we didn't find a previous declaration, and this is a reference
14346	// (or friend reference), move to the correct scope. In C++, we
14347	// also need to do a redeclaration lookup there, just in case
14348	// there's a shadow friend decl.
14349	if (Name && Previous.empty() &&
14350	(TUK == TUK_Reference \|\| TUK == TUK_Friend \|\| IsTemplateParamOrArg)) {
14351	if (Invalid) goto CreateNewDecl;
14352	assert(SS.isEmpty())((SS.isEmpty()) ? static_cast<void> (0) : __assert_fail ("SS.isEmpty()", "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 14352, __PRETTY_FUNCTION__));
14353
14354	if (TUK == TUK_Reference \|\| IsTemplateParamOrArg) {
14355	// C++ [basic.scope.pdecl]p5:
14356	// -- for an elaborated-type-specifier of the form
14357	//
14358	// class-key identifier
14359	//
14360	// if the elaborated-type-specifier is used in the
14361	// decl-specifier-seq or parameter-declaration-clause of a
14362	// function defined in namespace scope, the identifier is
14363	// declared as a class-name in the namespace that contains
14364	// the declaration; otherwise, except as a friend
14365	// declaration, the identifier is declared in the smallest
14366	// non-class, non-function-prototype scope that contains the
14367	// declaration.
14368	//
14369	// C99 6.7.2.3p8 has a similar (but not identical!) provision for
14370	// C structs and unions.
14371	//
14372	// It is an error in C++ to declare (rather than define) an enum
14373	// type, including via an elaborated type specifier. We'll
14374	// diagnose that later; for now, declare the enum in the same
14375	// scope as we would have picked for any other tag type.
14376	//
14377	// GNU C also supports this behavior as part of its incomplete
14378	// enum types extension, while GNU C++ does not.
14379	//
14380	// Find the context where we'll be declaring the tag.
14381	// FIXME: We would like to maintain the current DeclContext as the
14382	// lexical context,
14383	SearchDC = getTagInjectionContext(SearchDC);
14384
14385	// Find the scope where we'll be declaring the tag.
14386	S = getTagInjectionScope(S, getLangOpts());
14387	} else {
14388	assert(TUK == TUK_Friend)((TUK == TUK_Friend) ? static_cast<void> (0) : __assert_fail ("TUK == TUK_Friend", "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 14388, __PRETTY_FUNCTION__));
14389	// C++ [namespace.memdef]p3:
14390	// If a friend declaration in a non-local class first declares a
14391	// class or function, the friend class or function is a member of
14392	// the innermost enclosing namespace.
14393	SearchDC = SearchDC->getEnclosingNamespaceContext();
14394	}
14395
14396	// In C++, we need to do a redeclaration lookup to properly
14397	// diagnose some problems.
14398	// FIXME: redeclaration lookup is also used (with and without C++) to find a
14399	// hidden declaration so that we don't get ambiguity errors when using a
14400	// type declared by an elaborated-type-specifier. In C that is not correct
14401	// and we should instead merge compatible types found by lookup.
14402	if (getLangOpts().CPlusPlus) {
14403	Previous.setRedeclarationKind(forRedeclarationInCurContext());
14404	LookupQualifiedName(Previous, SearchDC);
14405	} else {
14406	Previous.setRedeclarationKind(forRedeclarationInCurContext());
14407	LookupName(Previous, S);
14408	}
14409	}
14410
14411	// If we have a known previous declaration to use, then use it.
14412	if (Previous.empty() && SkipBody && SkipBody->Previous)
14413	Previous.addDecl(SkipBody->Previous);
14414
14415	if (!Previous.empty()) {
14416	NamedDecl *PrevDecl = Previous.getFoundDecl();
14417	NamedDecl *DirectPrevDecl = Previous.getRepresentativeDecl();
14418
14419	// It's okay to have a tag decl in the same scope as a typedef
14420	// which hides a tag decl in the same scope. Finding this
14421	// insanity with a redeclaration lookup can only actually happen
14422	// in C++.
14423	//
14424	// This is also okay for elaborated-type-specifiers, which is
14425	// technically forbidden by the current standard but which is
14426	// okay according to the likely resolution of an open issue;
14427	// see http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#407
14428	if (getLangOpts().CPlusPlus) {
14429	if (TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(PrevDecl)) {
14430	if (const TagType *TT = TD->getUnderlyingType()->getAs<TagType>()) {
14431	TagDecl *Tag = TT->getDecl();
14432	if (Tag->getDeclName() == Name &&
14433	Tag->getDeclContext()->getRedeclContext()
14434	->Equals(TD->getDeclContext()->getRedeclContext())) {
14435	PrevDecl = Tag;
14436	Previous.clear();
14437	Previous.addDecl(Tag);
14438	Previous.resolveKind();
14439	}
14440	}
14441	}
14442	}
14443
14444	// If this is a redeclaration of a using shadow declaration, it must
14445	// declare a tag in the same context. In MSVC mode, we allow a
14446	// redefinition if either context is within the other.
14447	if (auto *Shadow = dyn_cast<UsingShadowDecl>(DirectPrevDecl)) {
14448	auto *OldTag = dyn_cast<TagDecl>(PrevDecl);
14449	if (SS.isEmpty() && TUK != TUK_Reference && TUK != TUK_Friend &&
14450	isDeclInScope(Shadow, SearchDC, S, isMemberSpecialization) &&
14451	!(OldTag && isAcceptableTagRedeclContext(
14452	*this, OldTag->getDeclContext(), SearchDC))) {
14453	Diag(KWLoc, diag::err_using_decl_conflict_reverse);
14454	Diag(Shadow->getTargetDecl()->getLocation(),
14455	diag::note_using_decl_target);
14456	Diag(Shadow->getUsingDecl()->getLocation(), diag::note_using_decl)
14457	<< 0;
14458	// Recover by ignoring the old declaration.
14459	Previous.clear();
14460	goto CreateNewDecl;
14461	}
14462	}
14463
14464	if (TagDecl *PrevTagDecl = dyn_cast<TagDecl>(PrevDecl)) {
14465	// If this is a use of a previous tag, or if the tag is already declared
14466	// in the same scope (so that the definition/declaration completes or
14467	// rementions the tag), reuse the decl.
14468	if (TUK == TUK_Reference \|\| TUK == TUK_Friend \|\|
14469	isDeclInScope(DirectPrevDecl, SearchDC, S,
14470	SS.isNotEmpty() \|\| isMemberSpecialization)) {
14471	// Make sure that this wasn't declared as an enum and now used as a
14472	// struct or something similar.
14473	if (!isAcceptableTagRedeclaration(PrevTagDecl, Kind,
14474	TUK == TUK_Definition, KWLoc,
14475	Name)) {
14476	bool SafeToContinue
14477	= (PrevTagDecl->getTagKind() != TTK_Enum &&
14478	Kind != TTK_Enum);
14479	if (SafeToContinue)
14480	Diag(KWLoc, diag::err_use_with_wrong_tag)
14481	<< Name
14482	<< FixItHint::CreateReplacement(SourceRange(KWLoc),
14483	PrevTagDecl->getKindName());
14484	else
14485	Diag(KWLoc, diag::err_use_with_wrong_tag) << Name;
14486	Diag(PrevTagDecl->getLocation(), diag::note_previous_use);
14487
14488	if (SafeToContinue)
14489	Kind = PrevTagDecl->getTagKind();
14490	else {
14491	// Recover by making this an anonymous redefinition.
14492	Name = nullptr;
14493	Previous.clear();
14494	Invalid = true;
14495	}
14496	}
14497
14498	if (Kind == TTK_Enum && PrevTagDecl->getTagKind() == TTK_Enum) {
14499	const EnumDecl *PrevEnum = cast<EnumDecl>(PrevTagDecl);
14500
14501	// If this is an elaborated-type-specifier for a scoped enumeration,
14502	// the 'class' keyword is not necessary and not permitted.
14503	if (TUK == TUK_Reference \|\| TUK == TUK_Friend) {
14504	if (ScopedEnum)
14505	Diag(ScopedEnumKWLoc, diag::err_enum_class_reference)
14506	<< PrevEnum->isScoped()
14507	<< FixItHint::CreateRemoval(ScopedEnumKWLoc);
14508	return PrevTagDecl;
14509	}
14510
14511	QualType EnumUnderlyingTy;
14512	if (TypeSourceInfo TI = EnumUnderlying.dyn_cast<TypeSourceInfo>())
14513	EnumUnderlyingTy = TI->getType().getUnqualifiedType();
14514	else if (const Type T = EnumUnderlying.dyn_cast<const Type>())
14515	EnumUnderlyingTy = QualType(T, 0);
14516
14517	// All conflicts with previous declarations are recovered by
14518	// returning the previous declaration, unless this is a definition,
14519	// in which case we want the caller to bail out.
14520	if (CheckEnumRedeclaration(NameLoc.isValid() ? NameLoc : KWLoc,
14521	ScopedEnum, EnumUnderlyingTy,
14522	IsFixed, PrevEnum))
14523	return TUK == TUK_Declaration ? PrevTagDecl : nullptr;
14524	}
14525
14526	// C++11 [class.mem]p1:
14527	// A member shall not be declared twice in the member-specification,
14528	// except that a nested class or member class template can be declared
14529	// and then later defined.
14530	if (TUK == TUK_Declaration && PrevDecl->isCXXClassMember() &&
14531	S->isDeclScope(PrevDecl)) {
14532	Diag(NameLoc, diag::ext_member_redeclared);
14533	Diag(PrevTagDecl->getLocation(), diag::note_previous_declaration);
14534	}
14535
14536	if (!Invalid) {
14537	// If this is a use, just return the declaration we found, unless
14538	// we have attributes.
14539	if (TUK == TUK_Reference \|\| TUK == TUK_Friend) {
14540	if (!Attrs.empty()) {
14541	// FIXME: Diagnose these attributes. For now, we create a new
14542	// declaration to hold them.
14543	} else if (TUK == TUK_Reference &&
14544	(PrevTagDecl->getFriendObjectKind() ==
14545	Decl::FOK_Undeclared \|\|
14546	PrevDecl->getOwningModule() != getCurrentModule()) &&
14547	SS.isEmpty()) {
14548	// This declaration is a reference to an existing entity, but
14549	// has different visibility from that entity: it either makes
14550	// a friend visible or it makes a type visible in a new module.
14551	// In either case, create a new declaration. We only do this if
14552	// the declaration would have meant the same thing if no prior
14553	// declaration were found, that is, if it was found in the same
14554	// scope where we would have injected a declaration.
14555	if (!getTagInjectionContext(CurContext)->getRedeclContext()
14556	->Equals(PrevDecl->getDeclContext()->getRedeclContext()))
14557	return PrevTagDecl;
14558	// This is in the injected scope, create a new declaration in
14559	// that scope.
14560	S = getTagInjectionScope(S, getLangOpts());
14561	} else {
14562	return PrevTagDecl;
14563	}
14564	}
14565
14566	// Diagnose attempts to redefine a tag.
14567	if (TUK == TUK_Definition) {
14568	if (NamedDecl *Def = PrevTagDecl->getDefinition()) {
14569	// If we're defining a specialization and the previous definition
14570	// is from an implicit instantiation, don't emit an error
14571	// here; we'll catch this in the general case below.
14572	bool IsExplicitSpecializationAfterInstantiation = false;
14573	if (isMemberSpecialization) {
14574	if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(Def))
14575	IsExplicitSpecializationAfterInstantiation =
14576	RD->getTemplateSpecializationKind() !=
14577	TSK_ExplicitSpecialization;
14578	else if (EnumDecl *ED = dyn_cast<EnumDecl>(Def))
14579	IsExplicitSpecializationAfterInstantiation =
14580	ED->getTemplateSpecializationKind() !=
14581	TSK_ExplicitSpecialization;
14582	}
14583
14584	// Note that clang allows ODR-like semantics for ObjC/C, i.e., do
14585	// not keep more that one definition around (merge them). However,
14586	// ensure the decl passes the structural compatibility check in
14587	// C11 6.2.7/1 (or 6.1.2.6/1 in C89).
14588	NamedDecl *Hidden = nullptr;
14589	if (SkipBody && !hasVisibleDefinition(Def, &Hidden)) {
14590	// There is a definition of this tag, but it is not visible. We
14591	// explicitly make use of C++'s one definition rule here, and
14592	// assume that this definition is identical to the hidden one
14593	// we already have. Make the existing definition visible and
14594	// use it in place of this one.
14595	if (!getLangOpts().CPlusPlus) {
14596	// Postpone making the old definition visible until after we
14597	// complete parsing the new one and do the structural
14598	// comparison.
14599	SkipBody->CheckSameAsPrevious = true;
14600	SkipBody->New = createTagFromNewDecl();
14601	SkipBody->Previous = Def;
14602	return Def;
14603	} else {
14604	SkipBody->ShouldSkip = true;
14605	SkipBody->Previous = Def;
14606	makeMergedDefinitionVisible(Hidden);
14607	// Carry on and handle it like a normal definition. We'll
14608	// skip starting the definitiion later.
14609	}
14610	} else if (!IsExplicitSpecializationAfterInstantiation) {
14611	// A redeclaration in function prototype scope in C isn't
14612	// visible elsewhere, so merely issue a warning.
14613	if (!getLangOpts().CPlusPlus && S->containedInPrototypeScope())
14614	Diag(NameLoc, diag::warn_redefinition_in_param_list) << Name;
14615	else
14616	Diag(NameLoc, diag::err_redefinition) << Name;
14617	notePreviousDefinition(Def,
14618	NameLoc.isValid() ? NameLoc : KWLoc);
14619	// If this is a redefinition, recover by making this
14620	// struct be anonymous, which will make any later
14621	// references get the previous definition.
14622	Name = nullptr;
14623	Previous.clear();
14624	Invalid = true;
14625	}
14626	} else {
14627	// If the type is currently being defined, complain
14628	// about a nested redefinition.
14629	auto *TD = Context.getTagDeclType(PrevTagDecl)->getAsTagDecl();
14630	if (TD->isBeingDefined()) {
14631	Diag(NameLoc, diag::err_nested_redefinition) << Name;
14632	Diag(PrevTagDecl->getLocation(),
14633	diag::note_previous_definition);
14634	Name = nullptr;
14635	Previous.clear();
14636	Invalid = true;
14637	}
14638	}
14639
14640	// Okay, this is definition of a previously declared or referenced
14641	// tag. We're going to create a new Decl for it.
14642	}
14643
14644	// Okay, we're going to make a redeclaration. If this is some kind
14645	// of reference, make sure we build the redeclaration in the same DC
14646	// as the original, and ignore the current access specifier.
14647	if (TUK == TUK_Friend \|\| TUK == TUK_Reference) {
14648	SearchDC = PrevTagDecl->getDeclContext();
14649	AS = AS_none;
14650	}
14651	}
14652	// If we get here we have (another) forward declaration or we
14653	// have a definition. Just create a new decl.
14654
14655	} else {
14656	// If we get here, this is a definition of a new tag type in a nested
14657	// scope, e.g. "struct foo; void bar() { struct foo; }", just create a
14658	// new decl/type. We set PrevDecl to NULL so that the entities
14659	// have distinct types.
14660	Previous.clear();
14661	}
14662	// If we get here, we're going to create a new Decl. If PrevDecl
14663	// is non-NULL, it's a definition of the tag declared by
14664	// PrevDecl. If it's NULL, we have a new definition.
14665
14666	// Otherwise, PrevDecl is not a tag, but was found with tag
14667	// lookup. This is only actually possible in C++, where a few
14668	// things like templates still live in the tag namespace.
14669	} else {
14670	// Use a better diagnostic if an elaborated-type-specifier
14671	// found the wrong kind of type on the first
14672	// (non-redeclaration) lookup.
14673	if ((TUK == TUK_Reference \|\| TUK == TUK_Friend) &&
14674	!Previous.isForRedeclaration()) {
14675	NonTagKind NTK = getNonTagTypeDeclKind(PrevDecl, Kind);
14676	Diag(NameLoc, diag::err_tag_reference_non_tag) << PrevDecl << NTK
14677	<< Kind;
14678	Diag(PrevDecl->getLocation(), diag::note_declared_at);
14679	Invalid = true;
14680
14681	// Otherwise, only diagnose if the declaration is in scope.
14682	} else if (!isDeclInScope(DirectPrevDecl, SearchDC, S,
14683	SS.isNotEmpty() \|\| isMemberSpecialization)) {
14684	// do nothing
14685
14686	// Diagnose implicit declarations introduced by elaborated types.
14687	} else if (TUK == TUK_Reference \|\| TUK == TUK_Friend) {
14688	NonTagKind NTK = getNonTagTypeDeclKind(PrevDecl, Kind);
14689	Diag(NameLoc, diag::err_tag_reference_conflict) << NTK;
14690	Diag(PrevDecl->getLocation(), diag::note_previous_decl) << PrevDecl;
14691	Invalid = true;
14692
14693	// Otherwise it's a declaration. Call out a particularly common
14694	// case here.
14695	} else if (TypedefNameDecl *TND = dyn_cast<TypedefNameDecl>(PrevDecl)) {
14696	unsigned Kind = 0;
14697	if (isa<TypeAliasDecl>(PrevDecl)) Kind = 1;
14698	Diag(NameLoc, diag::err_tag_definition_of_typedef)
14699	<< Name << Kind << TND->getUnderlyingType();
14700	Diag(PrevDecl->getLocation(), diag::note_previous_decl) << PrevDecl;
14701	Invalid = true;
14702
14703	// Otherwise, diagnose.
14704	} else {
14705	// The tag name clashes with something else in the target scope,
14706	// issue an error and recover by making this tag be anonymous.
14707	Diag(NameLoc, diag::err_redefinition_different_kind) << Name;
14708	notePreviousDefinition(PrevDecl, NameLoc);
14709	Name = nullptr;
14710	Invalid = true;
14711	}
14712
14713	// The existing declaration isn't relevant to us; we're in a
14714	// new scope, so clear out the previous declaration.
14715	Previous.clear();
14716	}
14717	}
14718
14719	CreateNewDecl:
14720
14721	TagDecl *PrevDecl = nullptr;
14722	if (Previous.isSingleResult())
14723	PrevDecl = cast<TagDecl>(Previous.getFoundDecl());
14724
14725	// If there is an identifier, use the location of the identifier as the
14726	// location of the decl, otherwise use the location of the struct/union
14727	// keyword.
14728	SourceLocation Loc = NameLoc.isValid() ? NameLoc : KWLoc;
14729
14730	// Otherwise, create a new declaration. If there is a previous
14731	// declaration of the same entity, the two will be linked via
14732	// PrevDecl.
14733	TagDecl *New;
14734
14735	if (Kind == TTK_Enum) {
14736	// FIXME: Tag decls should be chained to any simultaneous vardecls, e.g.:
14737	// enum X { A, B, C } D; D should chain to X.
14738	New = EnumDecl::Create(Context, SearchDC, KWLoc, Loc, Name,
14739	cast_or_null<EnumDecl>(PrevDecl), ScopedEnum,
14740	ScopedEnumUsesClassTag, IsFixed);
14741
14742	if (isStdAlignValT && (!StdAlignValT \|\| getStdAlignValT()->isImplicit()))
14743	StdAlignValT = cast<EnumDecl>(New);
14744
14745	// If this is an undefined enum, warn.
14746	if (TUK != TUK_Definition && !Invalid) {
14747	TagDecl *Def;
14748	if (IsFixed && (getLangOpts().CPlusPlus11 \|\| getLangOpts().ObjC) &&
14749	cast<EnumDecl>(New)->isFixed()) {
14750	// C++0x: 7.2p2: opaque-enum-declaration.
14751	// Conflicts are diagnosed above. Do nothing.
14752	}
14753	else if (PrevDecl && (Def = cast<EnumDecl>(PrevDecl)->getDefinition())) {
14754	Diag(Loc, diag::ext_forward_ref_enum_def)
14755	<< New;
14756	Diag(Def->getLocation(), diag::note_previous_definition);
14757	} else {
14758	unsigned DiagID = diag::ext_forward_ref_enum;
14759	if (getLangOpts().MSVCCompat)
14760	DiagID = diag::ext_ms_forward_ref_enum;
14761	else if (getLangOpts().CPlusPlus)
14762	DiagID = diag::err_forward_ref_enum;
14763	Diag(Loc, DiagID);
14764	}
14765	}
14766
14767	if (EnumUnderlying) {
14768	EnumDecl *ED = cast<EnumDecl>(New);
14769	if (TypeSourceInfo TI = EnumUnderlying.dyn_cast<TypeSourceInfo>())
14770	ED->setIntegerTypeSourceInfo(TI);
14771	else
14772	ED->setIntegerType(QualType(EnumUnderlying.get<const Type*>(), 0));
14773	ED->setPromotionType(ED->getIntegerType());
14774	assert(ED->isComplete() && "enum with type should be complete")((ED->isComplete() && "enum with type should be complete" ) ? static_cast<void> (0) : __assert_fail ("ED->isComplete() && \"enum with type should be complete\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 14774, __PRETTY_FUNCTION__));
14775	}
14776	} else {
14777	// struct/union/class
14778
14779	// FIXME: Tag decls should be chained to any simultaneous vardecls, e.g.:
14780	// struct X { int A; } D; D should chain to X.
14781	if (getLangOpts().CPlusPlus) {
14782	// FIXME: Look for a way to use RecordDecl for simple structs.
14783	New = CXXRecordDecl::Create(Context, Kind, SearchDC, KWLoc, Loc, Name,
14784	cast_or_null<CXXRecordDecl>(PrevDecl));
14785
14786	if (isStdBadAlloc && (!StdBadAlloc \|\| getStdBadAlloc()->isImplicit()))
14787	StdBadAlloc = cast<CXXRecordDecl>(New);
14788	} else
14789	New = RecordDecl::Create(Context, Kind, SearchDC, KWLoc, Loc, Name,
14790	cast_or_null<RecordDecl>(PrevDecl));
14791	}
14792
14793	// C++11 [dcl.type]p3:
14794	// A type-specifier-seq shall not define a class or enumeration [...].
14795	if (getLangOpts().CPlusPlus && (IsTypeSpecifier \|\| IsTemplateParamOrArg) &&
14796	TUK == TUK_Definition) {
14797	Diag(New->getLocation(), diag::err_type_defined_in_type_specifier)
14798	<< Context.getTagDeclType(New);
14799	Invalid = true;
14800	}
14801
14802	if (!Invalid && getLangOpts().CPlusPlus && TUK == TUK_Definition &&
14803	DC->getDeclKind() == Decl::Enum) {
14804	Diag(New->getLocation(), diag::err_type_defined_in_enum)
14805	<< Context.getTagDeclType(New);
14806	Invalid = true;
14807	}
14808
14809	// Maybe add qualifier info.
14810	if (SS.isNotEmpty()) {
14811	if (SS.isSet()) {
14812	// If this is either a declaration or a definition, check the
14813	// nested-name-specifier against the current context.
14814	if ((TUK == TUK_Definition \|\| TUK == TUK_Declaration) &&
14815	diagnoseQualifiedDeclaration(SS, DC, OrigName, Loc,
14816	isMemberSpecialization))
14817	Invalid = true;
14818
14819	New->setQualifierInfo(SS.getWithLocInContext(Context));
14820	if (TemplateParameterLists.size() > 0) {
14821	New->setTemplateParameterListsInfo(Context, TemplateParameterLists);
14822	}
14823	}
14824	else
14825	Invalid = true;
14826	}
14827
14828	if (RecordDecl *RD = dyn_cast<RecordDecl>(New)) {
14829	// Add alignment attributes if necessary; these attributes are checked when
14830	// the ASTContext lays out the structure.
14831	//
14832	// It is important for implementing the correct semantics that this
14833	// happen here (in ActOnTag). The #pragma pack stack is
14834	// maintained as a result of parser callbacks which can occur at
14835	// many points during the parsing of a struct declaration (because
14836	// the #pragma tokens are effectively skipped over during the
14837	// parsing of the struct).
14838	if (TUK == TUK_Definition && (!SkipBody \|\| !SkipBody->ShouldSkip)) {
14839	AddAlignmentAttributesForRecord(RD);
14840	AddMsStructLayoutForRecord(RD);
14841	}
14842	}
14843
14844	if (ModulePrivateLoc.isValid()) {
14845	if (isMemberSpecialization)
14846	Diag(New->getLocation(), diag::err_module_private_specialization)
14847	<< 2
14848	<< FixItHint::CreateRemoval(ModulePrivateLoc);
14849	// __module_private__ does not apply to local classes. However, we only
14850	// diagnose this as an error when the declaration specifiers are
14851	// freestanding. Here, we just ignore the __module_private__.
14852	else if (!SearchDC->isFunctionOrMethod())
14853	New->setModulePrivate();
14854	}
14855
14856	// If this is a specialization of a member class (of a class template),
14857	// check the specialization.
14858	if (isMemberSpecialization && CheckMemberSpecialization(New, Previous))
14859	Invalid = true;
14860
14861	// If we're declaring or defining a tag in function prototype scope in C,
14862	// note that this type can only be used within the function and add it to
14863	// the list of decls to inject into the function definition scope.
14864	if ((Name \|\| Kind == TTK_Enum) &&
14865	getNonFieldDeclScope(S)->isFunctionPrototypeScope()) {
14866	if (getLangOpts().CPlusPlus) {
14867	// C++ [dcl.fct]p6:
14868	// Types shall not be defined in return or parameter types.
14869	if (TUK == TUK_Definition && !IsTypeSpecifier) {
14870	Diag(Loc, diag::err_type_defined_in_param_type)
14871	<< Name;
14872	Invalid = true;
14873	}
14874	} else if (!PrevDecl) {
14875	Diag(Loc, diag::warn_decl_in_param_list) << Context.getTagDeclType(New);
14876	}
14877	}
14878
14879	if (Invalid)
14880	New->setInvalidDecl();
14881
14882	// Set the lexical context. If the tag has a C++ scope specifier, the
14883	// lexical context will be different from the semantic context.
14884	New->setLexicalDeclContext(CurContext);
14885
14886	// Mark this as a friend decl if applicable.
14887	// In Microsoft mode, a friend declaration also acts as a forward
14888	// declaration so we always pass true to setObjectOfFriendDecl to make
14889	// the tag name visible.
14890	if (TUK == TUK_Friend)
14891	New->setObjectOfFriendDecl(getLangOpts().MSVCCompat);
14892
14893	// Set the access specifier.
14894	if (!Invalid && SearchDC->isRecord())
14895	SetMemberAccessSpecifier(New, PrevDecl, AS);
14896
14897	if (PrevDecl)
14898	CheckRedeclarationModuleOwnership(New, PrevDecl);
14899
14900	if (TUK == TUK_Definition && (!SkipBody \|\| !SkipBody->ShouldSkip))
14901	New->startDefinition();
14902
14903	ProcessDeclAttributeList(S, New, Attrs);
14904	AddPragmaAttributes(S, New);
14905
14906	// If this has an identifier, add it to the scope stack.
14907	if (TUK == TUK_Friend) {
14908	// We might be replacing an existing declaration in the lookup tables;
14909	// if so, borrow its access specifier.
14910	if (PrevDecl)
14911	New->setAccess(PrevDecl->getAccess());
14912
14913	DeclContext *DC = New->getDeclContext()->getRedeclContext();
14914	DC->makeDeclVisibleInContext(New);
14915	if (Name) // can be null along some error paths
14916	if (Scope *EnclosingScope = getScopeForDeclContext(S, DC))
14917	PushOnScopeChains(New, EnclosingScope, /* AddToContext = */ false);
14918	} else if (Name) {
14919	S = getNonFieldDeclScope(S);
14920	PushOnScopeChains(New, S, true);
14921	} else {
14922	CurContext->addDecl(New);
14923	}
14924
14925	// If this is the C FILE type, notify the AST context.
14926	if (IdentifierInfo *II = New->getIdentifier())
14927	if (!New->isInvalidDecl() &&
14928	New->getDeclContext()->getRedeclContext()->isTranslationUnit() &&
14929	II->isStr("FILE"))
14930	Context.setFILEDecl(New);
14931
14932	if (PrevDecl)
14933	mergeDeclAttributes(New, PrevDecl);
14934
14935	// If there's a #pragma GCC visibility in scope, set the visibility of this
14936	// record.
14937	AddPushedVisibilityAttribute(New);
14938
14939	if (isMemberSpecialization && !New->isInvalidDecl())
14940	CompleteMemberSpecialization(New, Previous);
14941
14942	OwnedDecl = true;
14943	// In C++, don't return an invalid declaration. We can't recover well from
14944	// the cases where we make the type anonymous.
14945	if (Invalid && getLangOpts().CPlusPlus) {
14946	if (New->isBeingDefined())
14947	if (auto RD = dyn_cast<RecordDecl>(New))
14948	RD->completeDefinition();
14949	return nullptr;
14950	} else if (SkipBody && SkipBody->ShouldSkip) {
14951	return SkipBody->Previous;
14952	} else {
14953	return New;
14954	}
14955	}
14956
14957	void Sema::ActOnTagStartDefinition(Scope S, Decl TagD) {
14958	AdjustDeclIfTemplate(TagD);
14959	TagDecl *Tag = cast<TagDecl>(TagD);
14960
14961	// Enter the tag context.
14962	PushDeclContext(S, Tag);
14963
14964	ActOnDocumentableDecl(TagD);
14965
14966	// If there's a #pragma GCC visibility in scope, set the visibility of this
14967	// record.
14968	AddPushedVisibilityAttribute(Tag);
14969	}
14970
14971	bool Sema::ActOnDuplicateDefinition(DeclSpec &DS, Decl *Prev,
14972	SkipBodyInfo &SkipBody) {
14973	if (!hasStructuralCompatLayout(Prev, SkipBody.New))
14974	return false;
14975
14976	// Make the previous decl visible.
14977	makeMergedDefinitionVisible(SkipBody.Previous);
14978	return true;
14979	}
14980
14981	Decl Sema::ActOnObjCContainerStartDefinition(Decl IDecl) {
14982	assert(isa<ObjCContainerDecl>(IDecl) &&((isa<ObjCContainerDecl>(IDecl) && "ActOnObjCContainerStartDefinition - Not ObjCContainerDecl" ) ? static_cast<void> (0) : __assert_fail ("isa<ObjCContainerDecl>(IDecl) && \"ActOnObjCContainerStartDefinition - Not ObjCContainerDecl\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 14983, __PRETTY_FUNCTION__))
14983	"ActOnObjCContainerStartDefinition - Not ObjCContainerDecl")((isa<ObjCContainerDecl>(IDecl) && "ActOnObjCContainerStartDefinition - Not ObjCContainerDecl" ) ? static_cast<void> (0) : __assert_fail ("isa<ObjCContainerDecl>(IDecl) && \"ActOnObjCContainerStartDefinition - Not ObjCContainerDecl\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 14983, __PRETTY_FUNCTION__));
14984	DeclContext *OCD = cast<DeclContext>(IDecl);
14985	assert(getContainingDC(OCD) == CurContext &&((getContainingDC(OCD) == CurContext && "The next DeclContext should be lexically contained in the current one." ) ? static_cast<void> (0) : __assert_fail ("getContainingDC(OCD) == CurContext && \"The next DeclContext should be lexically contained in the current one.\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 14986, __PRETTY_FUNCTION__))
14986	"The next DeclContext should be lexically contained in the current one.")((getContainingDC(OCD) == CurContext && "The next DeclContext should be lexically contained in the current one." ) ? static_cast<void> (0) : __assert_fail ("getContainingDC(OCD) == CurContext && \"The next DeclContext should be lexically contained in the current one.\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 14986, __PRETTY_FUNCTION__));
14987	CurContext = OCD;
14988	return IDecl;
14989	}
14990
14991	void Sema::ActOnStartCXXMemberDeclarations(Scope S, Decl TagD,
14992	SourceLocation FinalLoc,
14993	bool IsFinalSpelledSealed,
14994	SourceLocation LBraceLoc) {
14995	AdjustDeclIfTemplate(TagD);
14996	CXXRecordDecl *Record = cast<CXXRecordDecl>(TagD);
14997
14998	FieldCollector->StartClass();
14999
15000	if (!Record->getIdentifier())
15001	return;
15002
15003	if (FinalLoc.isValid())
15004	Record->addAttr(new (Context)
15005	FinalAttr(FinalLoc, Context, IsFinalSpelledSealed));
15006
15007	// C++ [class]p2:
15008	// [...] The class-name is also inserted into the scope of the
15009	// class itself; this is known as the injected-class-name. For
15010	// purposes of access checking, the injected-class-name is treated
15011	// as if it were a public member name.
15012	CXXRecordDecl *InjectedClassName = CXXRecordDecl::Create(
15013	Context, Record->getTagKind(), CurContext, Record->getBeginLoc(),
15014	Record->getLocation(), Record->getIdentifier(),
15015	/PrevDecl=/nullptr,
15016	/DelayTypeCreation=/true);
15017	Context.getTypeDeclType(InjectedClassName, Record);
15018	InjectedClassName->setImplicit();
15019	InjectedClassName->setAccess(AS_public);
15020	if (ClassTemplateDecl *Template = Record->getDescribedClassTemplate())
15021	InjectedClassName->setDescribedClassTemplate(Template);
15022	PushOnScopeChains(InjectedClassName, S);
15023	assert(InjectedClassName->isInjectedClassName() &&((InjectedClassName->isInjectedClassName() && "Broken injected-class-name" ) ? static_cast<void> (0) : __assert_fail ("InjectedClassName->isInjectedClassName() && \"Broken injected-class-name\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 15024, __PRETTY_FUNCTION__))
15024	"Broken injected-class-name")((InjectedClassName->isInjectedClassName() && "Broken injected-class-name" ) ? static_cast<void> (0) : __assert_fail ("InjectedClassName->isInjectedClassName() && \"Broken injected-class-name\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 15024, __PRETTY_FUNCTION__));
15025	}
15026
15027	void Sema::ActOnTagFinishDefinition(Scope S, Decl TagD,
15028	SourceRange BraceRange) {
15029	AdjustDeclIfTemplate(TagD);
15030	TagDecl *Tag = cast<TagDecl>(TagD);
15031	Tag->setBraceRange(BraceRange);
15032
15033	// Make sure we "complete" the definition even it is invalid.
15034	if (Tag->isBeingDefined()) {
15035	assert(Tag->isInvalidDecl() && "We should already have completed it")((Tag->isInvalidDecl() && "We should already have completed it" ) ? static_cast<void> (0) : __assert_fail ("Tag->isInvalidDecl() && \"We should already have completed it\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 15035, __PRETTY_FUNCTION__));
15036	if (RecordDecl *RD = dyn_cast<RecordDecl>(Tag))
15037	RD->completeDefinition();
15038	}
15039
15040	if (isa<CXXRecordDecl>(Tag)) {
15041	FieldCollector->FinishClass();
15042	}
15043
15044	// Exit this scope of this tag's definition.
15045	PopDeclContext();
15046
15047	if (getCurLexicalContext()->isObjCContainer() &&
15048	Tag->getDeclContext()->isFileContext())
15049	Tag->setTopLevelDeclInObjCContainer();
15050
15051	// Notify the consumer that we've defined a tag.
15052	if (!Tag->isInvalidDecl())
15053	Consumer.HandleTagDeclDefinition(Tag);
15054	}
15055
15056	void Sema::ActOnObjCContainerFinishDefinition() {
15057	// Exit this scope of this interface definition.
15058	PopDeclContext();
15059	}
15060
15061	void Sema::ActOnObjCTemporaryExitContainerContext(DeclContext *DC) {
15062	assert(DC == CurContext && "Mismatch of container contexts")((DC == CurContext && "Mismatch of container contexts" ) ? static_cast<void> (0) : __assert_fail ("DC == CurContext && \"Mismatch of container contexts\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 15062, __PRETTY_FUNCTION__));
15063	OriginalLexicalContext = DC;
15064	ActOnObjCContainerFinishDefinition();
15065	}
15066
15067	void Sema::ActOnObjCReenterContainerContext(DeclContext *DC) {
15068	ActOnObjCContainerStartDefinition(cast<Decl>(DC));
15069	OriginalLexicalContext = nullptr;
15070	}
15071
15072	void Sema::ActOnTagDefinitionError(Scope S, Decl TagD) {
15073	AdjustDeclIfTemplate(TagD);
15074	TagDecl *Tag = cast<TagDecl>(TagD);
15075	Tag->setInvalidDecl();
15076
15077	// Make sure we "complete" the definition even it is invalid.
15078	if (Tag->isBeingDefined()) {
15079	if (RecordDecl *RD = dyn_cast<RecordDecl>(Tag))
15080	RD->completeDefinition();
15081	}
15082
15083	// We're undoing ActOnTagStartDefinition here, not
15084	// ActOnStartCXXMemberDeclarations, so we don't have to mess with
15085	// the FieldCollector.
15086
15087	PopDeclContext();
15088	}
15089
15090	// Note that FieldName may be null for anonymous bitfields.
15091	ExprResult Sema::VerifyBitField(SourceLocation FieldLoc,
15092	IdentifierInfo *FieldName,
15093	QualType FieldTy, bool IsMsStruct,
15094	Expr BitWidth, bool ZeroWidth) {
15095	// Default to true; that shouldn't confuse checks for emptiness
15096	if (ZeroWidth)
15097	*ZeroWidth = true;
15098
15099	// C99 6.7.2.1p4 - verify the field type.
15100	// C++ 9.6p3: A bit-field shall have integral or enumeration type.
15101	if (!FieldTy->isDependentType() && !FieldTy->isIntegralOrEnumerationType()) {
15102	// Handle incomplete types with specific error.
15103	if (RequireCompleteType(FieldLoc, FieldTy, diag::err_field_incomplete))
15104	return ExprError();
15105	if (FieldName)
15106	return Diag(FieldLoc, diag::err_not_integral_type_bitfield)
15107	<< FieldName << FieldTy << BitWidth->getSourceRange();
15108	return Diag(FieldLoc, diag::err_not_integral_type_anon_bitfield)
15109	<< FieldTy << BitWidth->getSourceRange();
15110	} else if (DiagnoseUnexpandedParameterPack(const_cast<Expr *>(BitWidth),
15111	UPPC_BitFieldWidth))
15112	return ExprError();
15113
15114	// If the bit-width is type- or value-dependent, don't try to check
15115	// it now.
15116	if (BitWidth->isValueDependent() \|\| BitWidth->isTypeDependent())
15117	return BitWidth;
15118
15119	llvm::APSInt Value;
15120	ExprResult ICE = VerifyIntegerConstantExpression(BitWidth, &Value);
15121	if (ICE.isInvalid())
15122	return ICE;
15123	BitWidth = ICE.get();
15124
15125	if (Value != 0 && ZeroWidth)
15126	*ZeroWidth = false;
15127
15128	// Zero-width bitfield is ok for anonymous field.
15129	if (Value == 0 && FieldName)
15130	return Diag(FieldLoc, diag::err_bitfield_has_zero_width) << FieldName;
15131
15132	if (Value.isSigned() && Value.isNegative()) {
15133	if (FieldName)
15134	return Diag(FieldLoc, diag::err_bitfield_has_negative_width)
15135	<< FieldName << Value.toString(10);
15136	return Diag(FieldLoc, diag::err_anon_bitfield_has_negative_width)
15137	<< Value.toString(10);
15138	}
15139
15140	if (!FieldTy->isDependentType()) {
15141	uint64_t TypeStorageSize = Context.getTypeSize(FieldTy);
15142	uint64_t TypeWidth = Context.getIntWidth(FieldTy);
15143	bool BitfieldIsOverwide = Value.ugt(TypeWidth);
15144
15145	// Over-wide bitfields are an error in C or when using the MSVC bitfield
15146	// ABI.
15147	bool CStdConstraintViolation =
15148	BitfieldIsOverwide && !getLangOpts().CPlusPlus;
15149	bool MSBitfieldViolation =
15150	Value.ugt(TypeStorageSize) &&
15151	(IsMsStruct \|\| Context.getTargetInfo().getCXXABI().isMicrosoft());
15152	if (CStdConstraintViolation \|\| MSBitfieldViolation) {
15153	unsigned DiagWidth =
15154	CStdConstraintViolation ? TypeWidth : TypeStorageSize;
15155	if (FieldName)
15156	return Diag(FieldLoc, diag::err_bitfield_width_exceeds_type_width)
15157	<< FieldName << (unsigned)Value.getZExtValue()
15158	<< !CStdConstraintViolation << DiagWidth;
15159
15160	return Diag(FieldLoc, diag::err_anon_bitfield_width_exceeds_type_width)
15161	<< (unsigned)Value.getZExtValue() << !CStdConstraintViolation
15162	<< DiagWidth;
15163	}
15164
15165	// Warn on types where the user might conceivably expect to get all
15166	// specified bits as value bits: that's all integral types other than
15167	// 'bool'.
15168	if (BitfieldIsOverwide && !FieldTy->isBooleanType()) {
15169	if (FieldName)
15170	Diag(FieldLoc, diag::warn_bitfield_width_exceeds_type_width)
15171	<< FieldName << (unsigned)Value.getZExtValue()
15172	<< (unsigned)TypeWidth;
15173	else
15174	Diag(FieldLoc, diag::warn_anon_bitfield_width_exceeds_type_width)
15175	<< (unsigned)Value.getZExtValue() << (unsigned)TypeWidth;
15176	}
15177	}
15178
15179	return BitWidth;
15180	}
15181
15182	/// ActOnField - Each field of a C struct/union is passed into this in order
15183	/// to create a FieldDecl object for it.
15184	Decl Sema::ActOnField(Scope S, Decl *TagD, SourceLocation DeclStart,
15185	Declarator &D, Expr *BitfieldWidth) {
15186	FieldDecl *Res = HandleField(S, cast_or_null<RecordDecl>(TagD),
15187	DeclStart, D, static_cast<Expr*>(BitfieldWidth),
15188	/InitStyle=/ICIS_NoInit, AS_public);
15189	return Res;
15190	}
15191
15192	/// HandleField - Analyze a field of a C struct or a C++ data member.
15193	///
15194	FieldDecl Sema::HandleField(Scope S, RecordDecl *Record,
15195	SourceLocation DeclStart,
15196	Declarator &D, Expr *BitWidth,
15197	InClassInitStyle InitStyle,
15198	AccessSpecifier AS) {
15199	if (D.isDecompositionDeclarator()) {
15200	const DecompositionDeclarator &Decomp = D.getDecompositionDeclarator();
15201	Diag(Decomp.getLSquareLoc(), diag::err_decomp_decl_context)
15202	<< Decomp.getSourceRange();
15203	return nullptr;
15204	}
15205
15206	IdentifierInfo *II = D.getIdentifier();
15207	SourceLocation Loc = DeclStart;
15208	if (II) Loc = D.getIdentifierLoc();
15209
15210	TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S);
15211	QualType T = TInfo->getType();
15212	if (getLangOpts().CPlusPlus) {
15213	CheckExtraCXXDefaultArguments(D);
15214
15215	if (DiagnoseUnexpandedParameterPack(D.getIdentifierLoc(), TInfo,
15216	UPPC_DataMemberType)) {
15217	D.setInvalidType();
15218	T = Context.IntTy;
15219	TInfo = Context.getTrivialTypeSourceInfo(T, Loc);
15220	}
15221	}
15222
15223	DiagnoseFunctionSpecifiers(D.getDeclSpec());
15224
15225	if (D.getDeclSpec().isInlineSpecified())
15226	Diag(D.getDeclSpec().getInlineSpecLoc(), diag::err_inline_non_function)
15227	<< getLangOpts().CPlusPlus17;
15228	if (DeclSpec::TSCS TSCS = D.getDeclSpec().getThreadStorageClassSpec())
15229	Diag(D.getDeclSpec().getThreadStorageClassSpecLoc(),
15230	diag::err_invalid_thread)
15231	<< DeclSpec::getSpecifierName(TSCS);
15232
15233	// Check to see if this name was declared as a member previously
15234	NamedDecl *PrevDecl = nullptr;
15235	LookupResult Previous(*this, II, Loc, LookupMemberName,
15236	ForVisibleRedeclaration);
15237	LookupName(Previous, S);
15238	switch (Previous.getResultKind()) {
15239	case LookupResult::Found:
15240	case LookupResult::FoundUnresolvedValue:
15241	PrevDecl = Previous.getAsSingle<NamedDecl>();
15242	break;
15243
15244	case LookupResult::FoundOverloaded:
15245	PrevDecl = Previous.getRepresentativeDecl();
15246	break;
15247
15248	case LookupResult::NotFound:
15249	case LookupResult::NotFoundInCurrentInstantiation:
15250	case LookupResult::Ambiguous:
15251	break;
15252	}
15253	Previous.suppressDiagnostics();
15254
15255	if (PrevDecl && PrevDecl->isTemplateParameter()) {
15256	// Maybe we will complain about the shadowed template parameter.
15257	DiagnoseTemplateParameterShadow(D.getIdentifierLoc(), PrevDecl);
15258	// Just pretend that we didn't see the previous declaration.
15259	PrevDecl = nullptr;
15260	}
15261
15262	if (PrevDecl && !isDeclInScope(PrevDecl, Record, S))
15263	PrevDecl = nullptr;
15264
15265	bool Mutable
15266	= (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_mutable);
15267	SourceLocation TSSL = D.getBeginLoc();
15268	FieldDecl *NewFD
15269	= CheckFieldDecl(II, T, TInfo, Record, Loc, Mutable, BitWidth, InitStyle,
15270	TSSL, AS, PrevDecl, &D);
15271
15272	if (NewFD->isInvalidDecl())
15273	Record->setInvalidDecl();
15274
15275	if (D.getDeclSpec().isModulePrivateSpecified())
15276	NewFD->setModulePrivate();
15277
15278	if (NewFD->isInvalidDecl() && PrevDecl) {
15279	// Don't introduce NewFD into scope; there's already something
15280	// with the same name in the same scope.
15281	} else if (II) {
15282	PushOnScopeChains(NewFD, S);
15283	} else
15284	Record->addDecl(NewFD);
15285
15286	return NewFD;
15287	}
15288
15289	/// Build a new FieldDecl and check its well-formedness.
15290	///
15291	/// This routine builds a new FieldDecl given the fields name, type,
15292	/// record, etc. \p PrevDecl should refer to any previous declaration
15293	/// with the same name and in the same scope as the field to be
15294	/// created.
15295	///
15296	/// \returns a new FieldDecl.
15297	///
15298	/// \todo The Declarator argument is a hack. It will be removed once
15299	FieldDecl *Sema::CheckFieldDecl(DeclarationName Name, QualType T,
15300	TypeSourceInfo *TInfo,
15301	RecordDecl *Record, SourceLocation Loc,
15302	bool Mutable, Expr *BitWidth,
15303	InClassInitStyle InitStyle,
15304	SourceLocation TSSL,
15305	AccessSpecifier AS, NamedDecl *PrevDecl,
15306	Declarator *D) {
15307	IdentifierInfo *II = Name.getAsIdentifierInfo();
15308	bool InvalidDecl = false;
15309	if (D) InvalidDecl = D->isInvalidType();
15310
15311	// If we receive a broken type, recover by assuming 'int' and
15312	// marking this declaration as invalid.
15313	if (T.isNull()) {
15314	InvalidDecl = true;
15315	T = Context.IntTy;
15316	}
15317
15318	QualType EltTy = Context.getBaseElementType(T);
15319	if (!EltTy->isDependentType()) {
15320	if (RequireCompleteType(Loc, EltTy, diag::err_field_incomplete)) {
15321	// Fields of incomplete type force their record to be invalid.
15322	Record->setInvalidDecl();
15323	InvalidDecl = true;
15324	} else {
15325	NamedDecl *Def;
15326	EltTy->isIncompleteType(&Def);
15327	if (Def && Def->isInvalidDecl()) {
15328	Record->setInvalidDecl();
15329	InvalidDecl = true;
15330	}
15331	}
15332	}
15333
15334	// TR 18037 does not allow fields to be declared with address space
15335	if (T.getQualifiers().hasAddressSpace() \|\| T->isDependentAddressSpaceType() \|\|
15336	T->getBaseElementTypeUnsafe()->isDependentAddressSpaceType()) {
15337	Diag(Loc, diag::err_field_with_address_space);
15338	Record->setInvalidDecl();
15339	InvalidDecl = true;
15340	}
15341
15342	if (LangOpts.OpenCL) {
15343	// OpenCL v1.2 s6.9b,r & OpenCL v2.0 s6.12.5 - The following types cannot be
15344	// used as structure or union field: image, sampler, event or block types.
15345	if (T->isEventT() \|\| T->isImageType() \|\| T->isSamplerT() \|\|
15346	T->isBlockPointerType()) {
15347	Diag(Loc, diag::err_opencl_type_struct_or_union_field) << T;
15348	Record->setInvalidDecl();
15349	InvalidDecl = true;
15350	}
15351	// OpenCL v1.2 s6.9.c: bitfields are not supported.
15352	if (BitWidth) {
15353	Diag(Loc, diag::err_opencl_bitfields);
15354	InvalidDecl = true;
15355	}
15356	}
15357
15358	// Anonymous bit-fields cannot be cv-qualified (CWG 2229).
15359	if (!InvalidDecl && getLangOpts().CPlusPlus && !II && BitWidth &&
15360	T.hasQualifiers()) {
15361	InvalidDecl = true;
15362	Diag(Loc, diag::err_anon_bitfield_qualifiers);
15363	}
15364
15365	// C99 6.7.2.1p8: A member of a structure or union may have any type other
15366	// than a variably modified type.
15367	if (!InvalidDecl && T->isVariablyModifiedType()) {
15368	bool SizeIsNegative;
15369	llvm::APSInt Oversized;
15370
15371	TypeSourceInfo *FixedTInfo =
15372	TryToFixInvalidVariablyModifiedTypeSourceInfo(TInfo, Context,
15373	SizeIsNegative,
15374	Oversized);
15375	if (FixedTInfo) {
15376	Diag(Loc, diag::warn_illegal_constant_array_size);
15377	TInfo = FixedTInfo;
15378	T = FixedTInfo->getType();
15379	} else {
15380	if (SizeIsNegative)
15381	Diag(Loc, diag::err_typecheck_negative_array_size);
15382	else if (Oversized.getBoolValue())
15383	Diag(Loc, diag::err_array_too_large)
15384	<< Oversized.toString(10);
15385	else
15386	Diag(Loc, diag::err_typecheck_field_variable_size);
15387	InvalidDecl = true;
15388	}
15389	}
15390
15391	// Fields can not have abstract class types
15392	if (!InvalidDecl && RequireNonAbstractType(Loc, T,
15393	diag::err_abstract_type_in_decl,
15394	AbstractFieldType))
15395	InvalidDecl = true;
15396
15397	bool ZeroWidth = false;
15398	if (InvalidDecl)
15399	BitWidth = nullptr;
15400	// If this is declared as a bit-field, check the bit-field.
15401	if (BitWidth) {
15402	BitWidth = VerifyBitField(Loc, II, T, Record->isMsStruct(Context), BitWidth,
15403	&ZeroWidth).get();
15404	if (!BitWidth) {
15405	InvalidDecl = true;
15406	BitWidth = nullptr;
15407	ZeroWidth = false;
15408	}
15409	}
15410
15411	// Check that 'mutable' is consistent with the type of the declaration.
15412	if (!InvalidDecl && Mutable) {
15413	unsigned DiagID = 0;
15414	if (T->isReferenceType())
15415	DiagID = getLangOpts().MSVCCompat ? diag::ext_mutable_reference
15416	: diag::err_mutable_reference;
15417	else if (T.isConstQualified())
15418	DiagID = diag::err_mutable_const;
15419
15420	if (DiagID) {
15421	SourceLocation ErrLoc = Loc;
15422	if (D && D->getDeclSpec().getStorageClassSpecLoc().isValid())
15423	ErrLoc = D->getDeclSpec().getStorageClassSpecLoc();
15424	Diag(ErrLoc, DiagID);
15425	if (DiagID != diag::ext_mutable_reference) {
15426	Mutable = false;
15427	InvalidDecl = true;
15428	}
15429	}
15430	}
15431
15432	// C++11 [class.union]p8 (DR1460):
15433	// At most one variant member of a union may have a
15434	// brace-or-equal-initializer.
15435	if (InitStyle != ICIS_NoInit)
15436	checkDuplicateDefaultInit(*this, cast<CXXRecordDecl>(Record), Loc);
15437
15438	FieldDecl *NewFD = FieldDecl::Create(Context, Record, TSSL, Loc, II, T, TInfo,
15439	BitWidth, Mutable, InitStyle);
15440	if (InvalidDecl)
15441	NewFD->setInvalidDecl();
15442
15443	if (PrevDecl && !isa<TagDecl>(PrevDecl)) {
15444	Diag(Loc, diag::err_duplicate_member) << II;
15445	Diag(PrevDecl->getLocation(), diag::note_previous_declaration);
15446	NewFD->setInvalidDecl();
15447	}
15448
15449	if (!InvalidDecl && getLangOpts().CPlusPlus) {
15450	if (Record->isUnion()) {
15451	if (const RecordType *RT = EltTy->getAs<RecordType>()) {
15452	CXXRecordDecl* RDecl = cast<CXXRecordDecl>(RT->getDecl());
15453	if (RDecl->getDefinition()) {
15454	// C++ [class.union]p1: An object of a class with a non-trivial
15455	// constructor, a non-trivial copy constructor, a non-trivial
15456	// destructor, or a non-trivial copy assignment operator
15457	// cannot be a member of a union, nor can an array of such
15458	// objects.
15459	if (CheckNontrivialField(NewFD))
15460	NewFD->setInvalidDecl();
15461	}
15462	}
15463
15464	// C++ [class.union]p1: If a union contains a member of reference type,
15465	// the program is ill-formed, except when compiling with MSVC extensions
15466	// enabled.
15467	if (EltTy->isReferenceType()) {
15468	Diag(NewFD->getLocation(), getLangOpts().MicrosoftExt ?
15469	diag::ext_union_member_of_reference_type :
15470	diag::err_union_member_of_reference_type)
15471	<< NewFD->getDeclName() << EltTy;
15472	if (!getLangOpts().MicrosoftExt)
15473	NewFD->setInvalidDecl();
15474	}
15475	}
15476	}
15477
15478	// FIXME: We need to pass in the attributes given an AST
15479	// representation, not a parser representation.
15480	if (D) {
15481	// FIXME: The current scope is almost... but not entirely... correct here.
15482	ProcessDeclAttributes(getCurScope(), NewFD, *D);
15483
15484	if (NewFD->hasAttrs())
15485	CheckAlignasUnderalignment(NewFD);
15486	}
15487
15488	// In auto-retain/release, infer strong retension for fields of
15489	// retainable type.
15490	if (getLangOpts().ObjCAutoRefCount && inferObjCARCLifetime(NewFD))
15491	NewFD->setInvalidDecl();
15492
15493	if (T.isObjCGCWeak())
15494	Diag(Loc, diag::warn_attribute_weak_on_field);
15495
15496	NewFD->setAccess(AS);
15497	return NewFD;
15498	}
15499
15500	bool Sema::CheckNontrivialField(FieldDecl *FD) {
15501	assert(FD)((FD) ? static_cast<void> (0) : __assert_fail ("FD", "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 15501, __PRETTY_FUNCTION__));
15502	assert(getLangOpts().CPlusPlus && "valid check only for C++")((getLangOpts().CPlusPlus && "valid check only for C++" ) ? static_cast<void> (0) : __assert_fail ("getLangOpts().CPlusPlus && \"valid check only for C++\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 15502, __PRETTY_FUNCTION__));
15503
15504	if (FD->isInvalidDecl() \|\| FD->getType()->isDependentType())
15505	return false;
15506
15507	QualType EltTy = Context.getBaseElementType(FD->getType());
15508	if (const RecordType *RT = EltTy->getAs<RecordType>()) {
15509	CXXRecordDecl *RDecl = cast<CXXRecordDecl>(RT->getDecl());
15510	if (RDecl->getDefinition()) {
15511	// We check for copy constructors before constructors
15512	// because otherwise we'll never get complaints about
15513	// copy constructors.
15514
15515	CXXSpecialMember member = CXXInvalid;
15516	// We're required to check for any non-trivial constructors. Since the
15517	// implicit default constructor is suppressed if there are any
15518	// user-declared constructors, we just need to check that there is a
15519	// trivial default constructor and a trivial copy constructor. (We don't
15520	// worry about move constructors here, since this is a C++98 check.)
15521	if (RDecl->hasNonTrivialCopyConstructor())
15522	member = CXXCopyConstructor;
15523	else if (!RDecl->hasTrivialDefaultConstructor())
15524	member = CXXDefaultConstructor;
15525	else if (RDecl->hasNonTrivialCopyAssignment())
15526	member = CXXCopyAssignment;
15527	else if (RDecl->hasNonTrivialDestructor())
15528	member = CXXDestructor;
15529
15530	if (member != CXXInvalid) {
15531	if (!getLangOpts().CPlusPlus11 &&
15532	getLangOpts().ObjCAutoRefCount && RDecl->hasObjectMember()) {
15533	// Objective-C++ ARC: it is an error to have a non-trivial field of
15534	// a union. However, system headers in Objective-C programs
15535	// occasionally have Objective-C lifetime objects within unions,
15536	// and rather than cause the program to fail, we make those
15537	// members unavailable.
15538	SourceLocation Loc = FD->getLocation();
15539	if (getSourceManager().isInSystemHeader(Loc)) {
15540	if (!FD->hasAttr<UnavailableAttr>())
15541	FD->addAttr(UnavailableAttr::CreateImplicit(Context, "",
15542	UnavailableAttr::IR_ARCFieldWithOwnership, Loc));
15543	return false;
15544	}
15545	}
15546
15547	Diag(FD->getLocation(), getLangOpts().CPlusPlus11 ?
15548	diag::warn_cxx98_compat_nontrivial_union_or_anon_struct_member :
15549	diag::err_illegal_union_or_anon_struct_member)
15550	<< FD->getParent()->isUnion() << FD->getDeclName() << member;
15551	DiagnoseNontrivial(RDecl, member);
15552	return !getLangOpts().CPlusPlus11;
15553	}
15554	}
15555	}
15556
15557	return false;
15558	}
15559
15560	/// TranslateIvarVisibility - Translate visibility from a token ID to an
15561	/// AST enum value.
15562	static ObjCIvarDecl::AccessControl
15563	TranslateIvarVisibility(tok::ObjCKeywordKind ivarVisibility) {
15564	switch (ivarVisibility) {
15565	default: llvm_unreachable("Unknown visitibility kind")::llvm::llvm_unreachable_internal("Unknown visitibility kind" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 15565);
15566	case tok::objc_private: return ObjCIvarDecl::Private;
15567	case tok::objc_public: return ObjCIvarDecl::Public;
15568	case tok::objc_protected: return ObjCIvarDecl::Protected;
15569	case tok::objc_package: return ObjCIvarDecl::Package;
15570	}
15571	}
15572
15573	/// ActOnIvar - Each ivar field of an objective-c class is passed into this
15574	/// in order to create an IvarDecl object for it.
15575	Decl Sema::ActOnIvar(Scope S,
15576	SourceLocation DeclStart,
15577	Declarator &D, Expr *BitfieldWidth,
15578	tok::ObjCKeywordKind Visibility) {
15579
15580	IdentifierInfo *II = D.getIdentifier();
15581	Expr BitWidth = (Expr)BitfieldWidth;
15582	SourceLocation Loc = DeclStart;
15583	if (II) Loc = D.getIdentifierLoc();
15584
15585	// FIXME: Unnamed fields can be handled in various different ways, for
15586	// example, unnamed unions inject all members into the struct namespace!
15587
15588	TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S);
15589	QualType T = TInfo->getType();
15590
15591	if (BitWidth) {
15592	// 6.7.2.1p3, 6.7.2.1p4
15593	BitWidth = VerifyBitField(Loc, II, T, /IsMsStruct/false, BitWidth).get();
15594	if (!BitWidth)
15595	D.setInvalidType();
15596	} else {
15597	// Not a bitfield.
15598
15599	// validate II.
15600
15601	}
15602	if (T->isReferenceType()) {
15603	Diag(Loc, diag::err_ivar_reference_type);
15604	D.setInvalidType();
15605	}
15606	// C99 6.7.2.1p8: A member of a structure or union may have any type other
15607	// than a variably modified type.
15608	else if (T->isVariablyModifiedType()) {
15609	Diag(Loc, diag::err_typecheck_ivar_variable_size);
15610	D.setInvalidType();
15611	}
15612
15613	// Get the visibility (access control) for this ivar.
15614	ObjCIvarDecl::AccessControl ac =
15615	Visibility != tok::objc_not_keyword ? TranslateIvarVisibility(Visibility)
15616	: ObjCIvarDecl::None;
15617	// Must set ivar's DeclContext to its enclosing interface.
15618	ObjCContainerDecl *EnclosingDecl = cast<ObjCContainerDecl>(CurContext);
15619	if (!EnclosingDecl \|\| EnclosingDecl->isInvalidDecl())
15620	return nullptr;
15621	ObjCContainerDecl *EnclosingContext;
15622	if (ObjCImplementationDecl *IMPDecl =
15623	dyn_cast<ObjCImplementationDecl>(EnclosingDecl)) {
15624	if (LangOpts.ObjCRuntime.isFragile()) {
15625	// Case of ivar declared in an implementation. Context is that of its class.
15626	EnclosingContext = IMPDecl->getClassInterface();
15627	assert(EnclosingContext && "Implementation has no class interface!")((EnclosingContext && "Implementation has no class interface!" ) ? static_cast<void> (0) : __assert_fail ("EnclosingContext && \"Implementation has no class interface!\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 15627, __PRETTY_FUNCTION__));
15628	}
15629	else
15630	EnclosingContext = EnclosingDecl;
15631	} else {
15632	if (ObjCCategoryDecl *CDecl =
15633	dyn_cast<ObjCCategoryDecl>(EnclosingDecl)) {
15634	if (LangOpts.ObjCRuntime.isFragile() \|\| !CDecl->IsClassExtension()) {
15635	Diag(Loc, diag::err_misplaced_ivar) << CDecl->IsClassExtension();
15636	return nullptr;
15637	}
15638	}
15639	EnclosingContext = EnclosingDecl;
15640	}
15641
15642	// Construct the decl.
15643	ObjCIvarDecl *NewID = ObjCIvarDecl::Create(Context, EnclosingContext,
15644	DeclStart, Loc, II, T,
15645	TInfo, ac, (Expr *)BitfieldWidth);
15646
15647	if (II) {
15648	NamedDecl *PrevDecl = LookupSingleName(S, II, Loc, LookupMemberName,
15649	ForVisibleRedeclaration);
15650	if (PrevDecl && isDeclInScope(PrevDecl, EnclosingContext, S)
15651	&& !isa<TagDecl>(PrevDecl)) {
15652	Diag(Loc, diag::err_duplicate_member) << II;
15653	Diag(PrevDecl->getLocation(), diag::note_previous_declaration);
15654	NewID->setInvalidDecl();
15655	}
15656	}
15657
15658	// Process attributes attached to the ivar.
15659	ProcessDeclAttributes(S, NewID, D);
15660
15661	if (D.isInvalidType())
15662	NewID->setInvalidDecl();
15663
15664	// In ARC, infer 'retaining' for ivars of retainable type.
15665	if (getLangOpts().ObjCAutoRefCount && inferObjCARCLifetime(NewID))
15666	NewID->setInvalidDecl();
15667
15668	if (D.getDeclSpec().isModulePrivateSpecified())
15669	NewID->setModulePrivate();
15670
15671	if (II) {
15672	// FIXME: When interfaces are DeclContexts, we'll need to add
15673	// these to the interface.
15674	S->AddDecl(NewID);
15675	IdResolver.AddDecl(NewID);
15676	}
15677
15678	if (LangOpts.ObjCRuntime.isNonFragile() &&
15679	!NewID->isInvalidDecl() && isa<ObjCInterfaceDecl>(EnclosingDecl))
15680	Diag(Loc, diag::warn_ivars_in_interface);
15681
15682	return NewID;
15683	}
15684
15685	/// ActOnLastBitfield - This routine handles synthesized bitfields rules for
15686	/// class and class extensions. For every class \@interface and class
15687	/// extension \@interface, if the last ivar is a bitfield of any type,
15688	/// then add an implicit `char :0` ivar to the end of that interface.
15689	void Sema::ActOnLastBitfield(SourceLocation DeclLoc,
15690	SmallVectorImpl<Decl *> &AllIvarDecls) {
15691	if (LangOpts.ObjCRuntime.isFragile() \|\| AllIvarDecls.empty())
15692	return;
15693
15694	Decl *ivarDecl = AllIvarDecls[AllIvarDecls.size()-1];
15695	ObjCIvarDecl *Ivar = cast<ObjCIvarDecl>(ivarDecl);
15696
15697	if (!Ivar->isBitField() \|\| Ivar->isZeroLengthBitField(Context))
15698	return;
15699	ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(CurContext);
15700	if (!ID) {
15701	if (ObjCCategoryDecl *CD = dyn_cast<ObjCCategoryDecl>(CurContext)) {
15702	if (!CD->IsClassExtension())
15703	return;
15704	}
15705	// No need to add this to end of @implementation.
15706	else
15707	return;
15708	}
15709	// All conditions are met. Add a new bitfield to the tail end of ivars.
15710	llvm::APInt Zero(Context.getTypeSize(Context.IntTy), 0);
15711	Expr * BW = IntegerLiteral::Create(Context, Zero, Context.IntTy, DeclLoc);
15712
15713	Ivar = ObjCIvarDecl::Create(Context, cast<ObjCContainerDecl>(CurContext),
15714	DeclLoc, DeclLoc, nullptr,
15715	Context.CharTy,
15716	Context.getTrivialTypeSourceInfo(Context.CharTy,
15717	DeclLoc),
15718	ObjCIvarDecl::Private, BW,
15719	true);
15720	AllIvarDecls.push_back(Ivar);
15721	}
15722
15723	void Sema::ActOnFields(Scope S, SourceLocation RecLoc, Decl EnclosingDecl,
15724	ArrayRef<Decl *> Fields, SourceLocation LBrac,
15725	SourceLocation RBrac,
15726	const ParsedAttributesView &Attrs) {
15727	assert(EnclosingDecl && "missing record or interface decl")((EnclosingDecl && "missing record or interface decl" ) ? static_cast<void> (0) : __assert_fail ("EnclosingDecl && \"missing record or interface decl\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 15727, __PRETTY_FUNCTION__));
15728
15729	// If this is an Objective-C @implementation or category and we have
15730	// new fields here we should reset the layout of the interface since
15731	// it will now change.
15732	if (!Fields.empty() && isa<ObjCContainerDecl>(EnclosingDecl)) {
15733	ObjCContainerDecl *DC = cast<ObjCContainerDecl>(EnclosingDecl);
15734	switch (DC->getKind()) {
15735	default: break;
15736	case Decl::ObjCCategory:
15737	Context.ResetObjCLayout(cast<ObjCCategoryDecl>(DC)->getClassInterface());
15738	break;
15739	case Decl::ObjCImplementation:
15740	Context.
15741	ResetObjCLayout(cast<ObjCImplementationDecl>(DC)->getClassInterface());
15742	break;
15743	}
15744	}
15745
15746	RecordDecl *Record = dyn_cast<RecordDecl>(EnclosingDecl);
15747	CXXRecordDecl *CXXRecord = dyn_cast<CXXRecordDecl>(EnclosingDecl);
15748
15749	// Start counting up the number of named members; make sure to include
15750	// members of anonymous structs and unions in the total.
15751	unsigned NumNamedMembers = 0;
15752	if (Record) {
15753	for (const auto *I : Record->decls()) {
15754	if (const auto *IFD = dyn_cast<IndirectFieldDecl>(I))
15755	if (IFD->getDeclName())
15756	++NumNamedMembers;
15757	}
15758	}
15759
15760	// Verify that all the fields are okay.
15761	SmallVector<FieldDecl*, 32> RecFields;
15762
15763	bool ObjCFieldLifetimeErrReported = false;
15764	for (ArrayRef<Decl *>::iterator i = Fields.begin(), end = Fields.end();
15765	i != end; ++i) {
15766	FieldDecl FD = cast<FieldDecl>(i);
15767
15768	// Get the type for the field.
15769	const Type *FDTy = FD->getType().getTypePtr();
15770
15771	if (!FD->isAnonymousStructOrUnion()) {
15772	// Remember all fields written by the user.
15773	RecFields.push_back(FD);
15774	}
15775
15776	// If the field is already invalid for some reason, don't emit more
15777	// diagnostics about it.
15778	if (FD->isInvalidDecl()) {
15779	EnclosingDecl->setInvalidDecl();
15780	continue;
15781	}
15782
15783	// C99 6.7.2.1p2:
15784	// A structure or union shall not contain a member with
15785	// incomplete or function type (hence, a structure shall not
15786	// contain an instance of itself, but may contain a pointer to
15787	// an instance of itself), except that the last member of a
15788	// structure with more than one named member may have incomplete
15789	// array type; such a structure (and any union containing,
15790	// possibly recursively, a member that is such a structure)
15791	// shall not be a member of a structure or an element of an
15792	// array.
15793	bool IsLastField = (i + 1 == Fields.end());
15794	if (FDTy->isFunctionType()) {
15795	// Field declared as a function.
15796	Diag(FD->getLocation(), diag::err_field_declared_as_function)
15797	<< FD->getDeclName();
15798	FD->setInvalidDecl();
15799	EnclosingDecl->setInvalidDecl();
15800	continue;
15801	} else if (FDTy->isIncompleteArrayType() &&
15802	(Record \|\| isa<ObjCContainerDecl>(EnclosingDecl))) {
15803	if (Record) {
15804	// Flexible array member.
15805	// Microsoft and g++ is more permissive regarding flexible array.
15806	// It will accept flexible array in union and also
15807	// as the sole element of a struct/class.
15808	unsigned DiagID = 0;
15809	if (!Record->isUnion() && !IsLastField) {
15810	Diag(FD->getLocation(), diag::err_flexible_array_not_at_end)
15811	<< FD->getDeclName() << FD->getType() << Record->getTagKind();
15812	Diag((*(i + 1))->getLocation(), diag::note_next_field_declaration);
15813	FD->setInvalidDecl();
15814	EnclosingDecl->setInvalidDecl();
15815	continue;
15816	} else if (Record->isUnion())
15817	DiagID = getLangOpts().MicrosoftExt
15818	? diag::ext_flexible_array_union_ms
15819	: getLangOpts().CPlusPlus
15820	? diag::ext_flexible_array_union_gnu
15821	: diag::err_flexible_array_union;
15822	else if (NumNamedMembers < 1)
15823	DiagID = getLangOpts().MicrosoftExt
15824	? diag::ext_flexible_array_empty_aggregate_ms
15825	: getLangOpts().CPlusPlus
15826	? diag::ext_flexible_array_empty_aggregate_gnu
15827	: diag::err_flexible_array_empty_aggregate;
15828
15829	if (DiagID)
15830	Diag(FD->getLocation(), DiagID) << FD->getDeclName()
15831	<< Record->getTagKind();
15832	// While the layout of types that contain virtual bases is not specified
15833	// by the C++ standard, both the Itanium and Microsoft C++ ABIs place
15834	// virtual bases after the derived members. This would make a flexible
15835	// array member declared at the end of an object not adjacent to the end
15836	// of the type.
15837	if (CXXRecord && CXXRecord->getNumVBases() != 0)
15838	Diag(FD->getLocation(), diag::err_flexible_array_virtual_base)
15839	<< FD->getDeclName() << Record->getTagKind();
15840	if (!getLangOpts().C99)
15841	Diag(FD->getLocation(), diag::ext_c99_flexible_array_member)
15842	<< FD->getDeclName() << Record->getTagKind();
15843
15844	// If the element type has a non-trivial destructor, we would not
15845	// implicitly destroy the elements, so disallow it for now.
15846	//
15847	// FIXME: GCC allows this. We should probably either implicitly delete
15848	// the destructor of the containing class, or just allow this.
15849	QualType BaseElem = Context.getBaseElementType(FD->getType());
15850	if (!BaseElem->isDependentType() && BaseElem.isDestructedType()) {
15851	Diag(FD->getLocation(), diag::err_flexible_array_has_nontrivial_dtor)
15852	<< FD->getDeclName() << FD->getType();
15853	FD->setInvalidDecl();
15854	EnclosingDecl->setInvalidDecl();
15855	continue;
15856	}
15857	// Okay, we have a legal flexible array member at the end of the struct.
15858	Record->setHasFlexibleArrayMember(true);
15859	} else {
15860	// In ObjCContainerDecl ivars with incomplete array type are accepted,
15861	// unless they are followed by another ivar. That check is done
15862	// elsewhere, after synthesized ivars are known.
15863	}
15864	} else if (!FDTy->isDependentType() &&
15865	RequireCompleteType(FD->getLocation(), FD->getType(),
15866	diag::err_field_incomplete)) {
15867	// Incomplete type
15868	FD->setInvalidDecl();
15869	EnclosingDecl->setInvalidDecl();
15870	continue;
15871	} else if (const RecordType *FDTTy = FDTy->getAs<RecordType>()) {
15872	if (Record && FDTTy->getDecl()->hasFlexibleArrayMember()) {
15873	// A type which contains a flexible array member is considered to be a
15874	// flexible array member.
15875	Record->setHasFlexibleArrayMember(true);
15876	if (!Record->isUnion()) {
15877	// If this is a struct/class and this is not the last element, reject
15878	// it. Note that GCC supports variable sized arrays in the middle of
15879	// structures.
15880	if (!IsLastField)
15881	Diag(FD->getLocation(), diag::ext_variable_sized_type_in_struct)
15882	<< FD->getDeclName() << FD->getType();
15883	else {
15884	// We support flexible arrays at the end of structs in
15885	// other structs as an extension.
15886	Diag(FD->getLocation(), diag::ext_flexible_array_in_struct)
15887	<< FD->getDeclName();
15888	}
15889	}
15890	}
15891	if (isa<ObjCContainerDecl>(EnclosingDecl) &&
15892	RequireNonAbstractType(FD->getLocation(), FD->getType(),
15893	diag::err_abstract_type_in_decl,
15894	AbstractIvarType)) {
15895	// Ivars can not have abstract class types
15896	FD->setInvalidDecl();
15897	}
15898	if (Record && FDTTy->getDecl()->hasObjectMember())
15899	Record->setHasObjectMember(true);
15900	if (Record && FDTTy->getDecl()->hasVolatileMember())
15901	Record->setHasVolatileMember(true);
15902	} else if (FDTy->isObjCObjectType()) {
15903	/// A field cannot be an Objective-c object
15904	Diag(FD->getLocation(), diag::err_statically_allocated_object)
15905	<< FixItHint::CreateInsertion(FD->getLocation(), "*");
15906	QualType T = Context.getObjCObjectPointerType(FD->getType());
15907	FD->setType(T);
15908	} else if (getLangOpts().allowsNonTrivialObjCLifetimeQualifiers() &&
15909	Record && !ObjCFieldLifetimeErrReported && Record->isUnion()) {
15910	// It's an error in ARC or Weak if a field has lifetime.
15911	// We don't want to report this in a system header, though,
15912	// so we just make the field unavailable.
15913	// FIXME: that's really not sufficient; we need to make the type
15914	// itself invalid to, say, initialize or copy.
15915	QualType T = FD->getType();
15916	if (T.hasNonTrivialObjCLifetime()) {
15917	SourceLocation loc = FD->getLocation();
15918	if (getSourceManager().isInSystemHeader(loc)) {
15919	if (!FD->hasAttr<UnavailableAttr>()) {
15920	FD->addAttr(UnavailableAttr::CreateImplicit(Context, "",
15921	UnavailableAttr::IR_ARCFieldWithOwnership, loc));
15922	}
15923	} else {
15924	Diag(FD->getLocation(), diag::err_arc_objc_object_in_tag)
15925	<< T->isBlockPointerType() << Record->getTagKind();
15926	}
15927	ObjCFieldLifetimeErrReported = true;
15928	}
15929	} else if (getLangOpts().ObjC &&
15930	getLangOpts().getGC() != LangOptions::NonGC &&
15931	Record && !Record->hasObjectMember()) {
15932	if (FD->getType()->isObjCObjectPointerType() \|\|
15933	FD->getType().isObjCGCStrong())
15934	Record->setHasObjectMember(true);
15935	else if (Context.getAsArrayType(FD->getType())) {
15936	QualType BaseType = Context.getBaseElementType(FD->getType());
15937	if (BaseType->isRecordType() &&
15938	BaseType->getAs<RecordType>()->getDecl()->hasObjectMember())
15939	Record->setHasObjectMember(true);
15940	else if (BaseType->isObjCObjectPointerType() \|\|
15941	BaseType.isObjCGCStrong())
15942	Record->setHasObjectMember(true);
15943	}
15944	}
15945
15946	if (Record && !getLangOpts().CPlusPlus && !FD->hasAttr<UnavailableAttr>()) {
15947	QualType FT = FD->getType();
15948	if (FT.isNonTrivialToPrimitiveDefaultInitialize())
15949	Record->setNonTrivialToPrimitiveDefaultInitialize(true);
15950	QualType::PrimitiveCopyKind PCK = FT.isNonTrivialToPrimitiveCopy();
15951	if (PCK != QualType::PCK_Trivial && PCK != QualType::PCK_VolatileTrivial)
15952	Record->setNonTrivialToPrimitiveCopy(true);
15953	if (FT.isDestructedType()) {
15954	Record->setNonTrivialToPrimitiveDestroy(true);
15955	Record->setParamDestroyedInCallee(true);
15956	}
15957
15958	if (const auto *RT = FT->getAs<RecordType>()) {
15959	if (RT->getDecl()->getArgPassingRestrictions() ==
15960	RecordDecl::APK_CanNeverPassInRegs)
15961	Record->setArgPassingRestrictions(RecordDecl::APK_CanNeverPassInRegs);
15962	} else if (FT.getQualifiers().getObjCLifetime() == Qualifiers::OCL_Weak)
15963	Record->setArgPassingRestrictions(RecordDecl::APK_CanNeverPassInRegs);
15964	}
15965
15966	if (Record && FD->getType().isVolatileQualified())
15967	Record->setHasVolatileMember(true);
15968	// Keep track of the number of named members.
15969	if (FD->getIdentifier())
15970	++NumNamedMembers;
15971	}
15972
15973	// Okay, we successfully defined 'Record'.
15974	if (Record) {
15975	bool Completed = false;
15976	if (CXXRecord) {
15977	if (!CXXRecord->isInvalidDecl()) {
15978	// Set access bits correctly on the directly-declared conversions.
15979	for (CXXRecordDecl::conversion_iterator
15980	I = CXXRecord->conversion_begin(),
15981	E = CXXRecord->conversion_end(); I != E; ++I)
15982	I.setAccess((*I)->getAccess());
15983	}
15984
15985	if (!CXXRecord->isDependentType()) {
15986	// Add any implicitly-declared members to this class.
15987	AddImplicitlyDeclaredMembersToClass(CXXRecord);
15988
15989	if (!CXXRecord->isInvalidDecl()) {
15990	// If we have virtual base classes, we may end up finding multiple
15991	// final overriders for a given virtual function. Check for this
15992	// problem now.
15993	if (CXXRecord->getNumVBases()) {
15994	CXXFinalOverriderMap FinalOverriders;
15995	CXXRecord->getFinalOverriders(FinalOverriders);
15996
15997	for (CXXFinalOverriderMap::iterator M = FinalOverriders.begin(),
15998	MEnd = FinalOverriders.end();
15999	M != MEnd; ++M) {
16000	for (OverridingMethods::iterator SO = M->second.begin(),
16001	SOEnd = M->second.end();
16002	SO != SOEnd; ++SO) {
16003	assert(SO->second.size() > 0 &&((SO->second.size() > 0 && "Virtual function without overriding functions?" ) ? static_cast<void> (0) : __assert_fail ("SO->second.size() > 0 && \"Virtual function without overriding functions?\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 16004, __PRETTY_FUNCTION__))
16004	"Virtual function without overriding functions?")((SO->second.size() > 0 && "Virtual function without overriding functions?" ) ? static_cast<void> (0) : __assert_fail ("SO->second.size() > 0 && \"Virtual function without overriding functions?\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 16004, __PRETTY_FUNCTION__));
16005	if (SO->second.size() == 1)
16006	continue;
16007
16008	// C++ [class.virtual]p2:
16009	// In a derived class, if a virtual member function of a base
16010	// class subobject has more than one final overrider the
16011	// program is ill-formed.
16012	Diag(Record->getLocation(), diag::err_multiple_final_overriders)
16013	<< (const NamedDecl *)M->first << Record;
16014	Diag(M->first->getLocation(),
16015	diag::note_overridden_virtual_function);
16016	for (OverridingMethods::overriding_iterator
16017	OM = SO->second.begin(),
16018	OMEnd = SO->second.end();
16019	OM != OMEnd; ++OM)
16020	Diag(OM->Method->getLocation(), diag::note_final_overrider)
16021	<< (const NamedDecl *)M->first << OM->Method->getParent();
16022
16023	Record->setInvalidDecl();
16024	}
16025	}
16026	CXXRecord->completeDefinition(&FinalOverriders);
16027	Completed = true;
16028	}
16029	}
16030	}
16031	}
16032
16033	if (!Completed)
16034	Record->completeDefinition();
16035
16036	// Handle attributes before checking the layout.
16037	ProcessDeclAttributeList(S, Record, Attrs);
16038
16039	// We may have deferred checking for a deleted destructor. Check now.
16040	if (CXXRecord) {
16041	auto *Dtor = CXXRecord->getDestructor();
16042	if (Dtor && Dtor->isImplicit() &&
16043	ShouldDeleteSpecialMember(Dtor, CXXDestructor)) {
16044	CXXRecord->setImplicitDestructorIsDeleted();
16045	SetDeclDeleted(Dtor, CXXRecord->getLocation());
16046	}
16047	}
16048
16049	if (Record->hasAttrs()) {
16050	CheckAlignasUnderalignment(Record);
16051
16052	if (const MSInheritanceAttr *IA = Record->getAttr<MSInheritanceAttr>())
16053	checkMSInheritanceAttrOnDefinition(cast<CXXRecordDecl>(Record),
16054	IA->getRange(), IA->getBestCase(),
16055	IA->getSemanticSpelling());
16056	}
16057
16058	// Check if the structure/union declaration is a type that can have zero
16059	// size in C. For C this is a language extension, for C++ it may cause
16060	// compatibility problems.
16061	bool CheckForZeroSize;
16062	if (!getLangOpts().CPlusPlus) {
16063	CheckForZeroSize = true;
16064	} else {
16065	// For C++ filter out types that cannot be referenced in C code.
16066	CXXRecordDecl *CXXRecord = cast<CXXRecordDecl>(Record);
16067	CheckForZeroSize =
16068	CXXRecord->getLexicalDeclContext()->isExternCContext() &&
16069	!CXXRecord->isDependentType() &&
16070	CXXRecord->isCLike();
16071	}
16072	if (CheckForZeroSize) {
16073	bool ZeroSize = true;
16074	bool IsEmpty = true;
16075	unsigned NonBitFields = 0;
16076	for (RecordDecl::field_iterator I = Record->field_begin(),
16077	E = Record->field_end();
16078	(NonBitFields == 0 \|\| ZeroSize) && I != E; ++I) {
16079	IsEmpty = false;
16080	if (I->isUnnamedBitfield()) {
16081	if (!I->isZeroLengthBitField(Context))
16082	ZeroSize = false;
16083	} else {
16084	++NonBitFields;
16085	QualType FieldType = I->getType();
16086	if (FieldType->isIncompleteType() \|\|
16087	!Context.getTypeSizeInChars(FieldType).isZero())
16088	ZeroSize = false;
16089	}
16090	}
16091
16092	// Empty structs are an extension in C (C99 6.7.2.1p7). They are
16093	// allowed in C++, but warn if its declaration is inside
16094	// extern "C" block.
16095	if (ZeroSize) {
16096	Diag(RecLoc, getLangOpts().CPlusPlus ?
16097	diag::warn_zero_size_struct_union_in_extern_c :
16098	diag::warn_zero_size_struct_union_compat)
16099	<< IsEmpty << Record->isUnion() << (NonBitFields > 1);
16100	}
16101
16102	// Structs without named members are extension in C (C99 6.7.2.1p7),
16103	// but are accepted by GCC.
16104	if (NonBitFields == 0 && !getLangOpts().CPlusPlus) {
16105	Diag(RecLoc, IsEmpty ? diag::ext_empty_struct_union :
16106	diag::ext_no_named_members_in_struct_union)
16107	<< Record->isUnion();
16108	}
16109	}
16110	} else {
16111	ObjCIvarDecl **ClsFields =
16112	reinterpret_cast<ObjCIvarDecl**>(RecFields.data());
16113	if (ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(EnclosingDecl)) {
16114	ID->setEndOfDefinitionLoc(RBrac);
16115	// Add ivar's to class's DeclContext.
16116	for (unsigned i = 0, e = RecFields.size(); i != e; ++i) {
16117	ClsFields[i]->setLexicalDeclContext(ID);
16118	ID->addDecl(ClsFields[i]);
16119	}
16120	// Must enforce the rule that ivars in the base classes may not be
16121	// duplicates.
16122	if (ID->getSuperClass())
16123	DiagnoseDuplicateIvars(ID, ID->getSuperClass());
16124	} else if (ObjCImplementationDecl *IMPDecl =
16125	dyn_cast<ObjCImplementationDecl>(EnclosingDecl)) {
16126	assert(IMPDecl && "ActOnFields - missing ObjCImplementationDecl")((IMPDecl && "ActOnFields - missing ObjCImplementationDecl" ) ? static_cast<void> (0) : __assert_fail ("IMPDecl && \"ActOnFields - missing ObjCImplementationDecl\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 16126, __PRETTY_FUNCTION__));
16127	for (unsigned I = 0, N = RecFields.size(); I != N; ++I)
16128	// Ivar declared in @implementation never belongs to the implementation.
16129	// Only it is in implementation's lexical context.
16130	ClsFields[I]->setLexicalDeclContext(IMPDecl);
16131	CheckImplementationIvars(IMPDecl, ClsFields, RecFields.size(), RBrac);
16132	IMPDecl->setIvarLBraceLoc(LBrac);
16133	IMPDecl->setIvarRBraceLoc(RBrac);
16134	} else if (ObjCCategoryDecl *CDecl =
16135	dyn_cast<ObjCCategoryDecl>(EnclosingDecl)) {
16136	// case of ivars in class extension; all other cases have been
16137	// reported as errors elsewhere.
16138	// FIXME. Class extension does not have a LocEnd field.
16139	// CDecl->setLocEnd(RBrac);
16140	// Add ivar's to class extension's DeclContext.
16141	// Diagnose redeclaration of private ivars.
16142	ObjCInterfaceDecl *IDecl = CDecl->getClassInterface();
16143	for (unsigned i = 0, e = RecFields.size(); i != e; ++i) {
16144	if (IDecl) {
16145	if (const ObjCIvarDecl *ClsIvar =
16146	IDecl->getIvarDecl(ClsFields[i]->getIdentifier())) {
16147	Diag(ClsFields[i]->getLocation(),
16148	diag::err_duplicate_ivar_declaration);
16149	Diag(ClsIvar->getLocation(), diag::note_previous_definition);
16150	continue;
16151	}
16152	for (const auto *Ext : IDecl->known_extensions()) {
16153	if (const ObjCIvarDecl *ClsExtIvar
16154	= Ext->getIvarDecl(ClsFields[i]->getIdentifier())) {
16155	Diag(ClsFields[i]->getLocation(),
16156	diag::err_duplicate_ivar_declaration);
16157	Diag(ClsExtIvar->getLocation(), diag::note_previous_definition);
16158	continue;
16159	}
16160	}
16161	}
16162	ClsFields[i]->setLexicalDeclContext(CDecl);
16163	CDecl->addDecl(ClsFields[i]);
16164	}
16165	CDecl->setIvarLBraceLoc(LBrac);
16166	CDecl->setIvarRBraceLoc(RBrac);
16167	}
16168	}
16169	}
16170
16171	/// Determine whether the given integral value is representable within
16172	/// the given type T.
16173	static bool isRepresentableIntegerValue(ASTContext &Context,
16174	llvm::APSInt &Value,
16175	QualType T) {
16176	assert((T->isIntegralType(Context) \|\| T->isEnumeralType()) &&(((T->isIntegralType(Context) \|\| T->isEnumeralType()) && "Integral type required!") ? static_cast<void> (0) : __assert_fail ("(T->isIntegralType(Context) \|\| T->isEnumeralType()) && \"Integral type required!\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 16177, __PRETTY_FUNCTION__))
16177	"Integral type required!")(((T->isIntegralType(Context) \|\| T->isEnumeralType()) && "Integral type required!") ? static_cast<void> (0) : __assert_fail ("(T->isIntegralType(Context) \|\| T->isEnumeralType()) && \"Integral type required!\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 16177, __PRETTY_FUNCTION__));
16178	unsigned BitWidth = Context.getIntWidth(T);
16179
16180	if (Value.isUnsigned() \|\| Value.isNonNegative()) {
16181	if (T->isSignedIntegerOrEnumerationType())
16182	--BitWidth;
16183	return Value.getActiveBits() <= BitWidth;
16184	}
16185	return Value.getMinSignedBits() <= BitWidth;
16186	}
16187
16188	// Given an integral type, return the next larger integral type
16189	// (or a NULL type of no such type exists).
16190	static QualType getNextLargerIntegralType(ASTContext &Context, QualType T) {
16191	// FIXME: Int128/UInt128 support, which also needs to be introduced into
16192	// enum checking below.
16193	assert((T->isIntegralType(Context) \|\|(((T->isIntegralType(Context) \|\| T->isEnumeralType()) && "Integral type required!") ? static_cast<void> (0) : __assert_fail ("(T->isIntegralType(Context) \|\| T->isEnumeralType()) && \"Integral type required!\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 16194, __PRETTY_FUNCTION__))
16194	T->isEnumeralType()) && "Integral type required!")(((T->isIntegralType(Context) \|\| T->isEnumeralType()) && "Integral type required!") ? static_cast<void> (0) : __assert_fail ("(T->isIntegralType(Context) \|\| T->isEnumeralType()) && \"Integral type required!\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 16194, __PRETTY_FUNCTION__));
16195	const unsigned NumTypes = 4;
16196	QualType SignedIntegralTypes[NumTypes] = {
16197	Context.ShortTy, Context.IntTy, Context.LongTy, Context.LongLongTy
16198	};
16199	QualType UnsignedIntegralTypes[NumTypes] = {
16200	Context.UnsignedShortTy, Context.UnsignedIntTy, Context.UnsignedLongTy,
16201	Context.UnsignedLongLongTy
16202	};
16203
16204	unsigned BitWidth = Context.getTypeSize(T);
16205	QualType *Types = T->isSignedIntegerOrEnumerationType()? SignedIntegralTypes
16206	: UnsignedIntegralTypes;
16207	for (unsigned I = 0; I != NumTypes; ++I)
16208	if (Context.getTypeSize(Types[I]) > BitWidth)
16209	return Types[I];
16210
16211	return QualType();
16212	}
16213
16214	EnumConstantDecl Sema::CheckEnumConstant(EnumDecl Enum,
16215	EnumConstantDecl *LastEnumConst,
16216	SourceLocation IdLoc,
16217	IdentifierInfo *Id,
16218	Expr *Val) {
16219	unsigned IntWidth = Context.getTargetInfo().getIntWidth();
16220	llvm::APSInt EnumVal(IntWidth);
16221	QualType EltTy;
16222
16223	if (Val && DiagnoseUnexpandedParameterPack(Val, UPPC_EnumeratorValue))
16224	Val = nullptr;
16225
16226	if (Val)
16227	Val = DefaultLvalueConversion(Val).get();
16228
16229	if (Val) {
16230	if (Enum->isDependentType() \|\| Val->isTypeDependent())
16231	EltTy = Context.DependentTy;
16232	else {
16233	if (getLangOpts().CPlusPlus11 && Enum->isFixed() &&
16234	!getLangOpts().MSVCCompat) {
16235	// C++11 [dcl.enum]p5: If the underlying type is fixed, [...] the
16236	// constant-expression in the enumerator-definition shall be a converted
16237	// constant expression of the underlying type.
16238	EltTy = Enum->getIntegerType();
16239	ExprResult Converted =
16240	CheckConvertedConstantExpression(Val, EltTy, EnumVal,
16241	CCEK_Enumerator);
16242	if (Converted.isInvalid())
16243	Val = nullptr;
16244	else
16245	Val = Converted.get();
16246	} else if (!Val->isValueDependent() &&
16247	!(Val = VerifyIntegerConstantExpression(Val,
16248	&EnumVal).get())) {
16249	// C99 6.7.2.2p2: Make sure we have an integer constant expression.
16250	} else {
16251	if (Enum->isComplete()) {
16252	EltTy = Enum->getIntegerType();
16253
16254	// In Obj-C and Microsoft mode, require the enumeration value to be
16255	// representable in the underlying type of the enumeration. In C++11,
16256	// we perform a non-narrowing conversion as part of converted constant
16257	// expression checking.
16258	if (!isRepresentableIntegerValue(Context, EnumVal, EltTy)) {
16259	if (getLangOpts().MSVCCompat) {
16260	Diag(IdLoc, diag::ext_enumerator_too_large) << EltTy;
16261	Val = ImpCastExprToType(Val, EltTy, CK_IntegralCast).get();
16262	} else
16263	Diag(IdLoc, diag::err_enumerator_too_large) << EltTy;
16264	} else
16265	Val = ImpCastExprToType(Val, EltTy,
16266	EltTy->isBooleanType() ?
16267	CK_IntegralToBoolean : CK_IntegralCast)
16268	.get();
16269	} else if (getLangOpts().CPlusPlus) {
16270	// C++11 [dcl.enum]p5:
16271	// If the underlying type is not fixed, the type of each enumerator
16272	// is the type of its initializing value:
16273	// - If an initializer is specified for an enumerator, the
16274	// initializing value has the same type as the expression.
16275	EltTy = Val->getType();
16276	} else {
16277	// C99 6.7.2.2p2:
16278	// The expression that defines the value of an enumeration constant
16279	// shall be an integer constant expression that has a value
16280	// representable as an int.
16281
16282	// Complain if the value is not representable in an int.
16283	if (!isRepresentableIntegerValue(Context, EnumVal, Context.IntTy))
16284	Diag(IdLoc, diag::ext_enum_value_not_int)
16285	<< EnumVal.toString(10) << Val->getSourceRange()
16286	<< (EnumVal.isUnsigned() \|\| EnumVal.isNonNegative());
16287	else if (!Context.hasSameType(Val->getType(), Context.IntTy)) {
16288	// Force the type of the expression to 'int'.
16289	Val = ImpCastExprToType(Val, Context.IntTy, CK_IntegralCast).get();
16290	}
16291	EltTy = Val->getType();
16292	}
16293	}
16294	}
16295	}
16296
16297	if (!Val) {
16298	if (Enum->isDependentType())
16299	EltTy = Context.DependentTy;
16300	else if (!LastEnumConst) {
16301	// C++0x [dcl.enum]p5:
16302	// If the underlying type is not fixed, the type of each enumerator
16303	// is the type of its initializing value:
16304	// - If no initializer is specified for the first enumerator, the
16305	// initializing value has an unspecified integral type.
16306	//
16307	// GCC uses 'int' for its unspecified integral type, as does
16308	// C99 6.7.2.2p3.
16309	if (Enum->isFixed()) {
16310	EltTy = Enum->getIntegerType();
16311	}
16312	else {
16313	EltTy = Context.IntTy;
16314	}
16315	} else {
16316	// Assign the last value + 1.
16317	EnumVal = LastEnumConst->getInitVal();
16318	++EnumVal;
16319	EltTy = LastEnumConst->getType();
16320
16321	// Check for overflow on increment.
16322	if (EnumVal < LastEnumConst->getInitVal()) {
16323	// C++0x [dcl.enum]p5:
16324	// If the underlying type is not fixed, the type of each enumerator
16325	// is the type of its initializing value:
16326	//
16327	// - Otherwise the type of the initializing value is the same as
16328	// the type of the initializing value of the preceding enumerator
16329	// unless the incremented value is not representable in that type,
16330	// in which case the type is an unspecified integral type
16331	// sufficient to contain the incremented value. If no such type
16332	// exists, the program is ill-formed.
16333	QualType T = getNextLargerIntegralType(Context, EltTy);
16334	if (T.isNull() \|\| Enum->isFixed()) {
16335	// There is no integral type larger enough to represent this
16336	// value. Complain, then allow the value to wrap around.
16337	EnumVal = LastEnumConst->getInitVal();
16338	EnumVal = EnumVal.zext(EnumVal.getBitWidth() * 2);
16339	++EnumVal;
16340	if (Enum->isFixed())
16341	// When the underlying type is fixed, this is ill-formed.
16342	Diag(IdLoc, diag::err_enumerator_wrapped)
16343	<< EnumVal.toString(10)
16344	<< EltTy;
16345	else
16346	Diag(IdLoc, diag::ext_enumerator_increment_too_large)
16347	<< EnumVal.toString(10);
16348	} else {
16349	EltTy = T;
16350	}
16351
16352	// Retrieve the last enumerator's value, extent that type to the
16353	// type that is supposed to be large enough to represent the incremented
16354	// value, then increment.
16355	EnumVal = LastEnumConst->getInitVal();
16356	EnumVal.setIsSigned(EltTy->isSignedIntegerOrEnumerationType());
16357	EnumVal = EnumVal.zextOrTrunc(Context.getIntWidth(EltTy));
16358	++EnumVal;
16359
16360	// If we're not in C++, diagnose the overflow of enumerator values,
16361	// which in C99 means that the enumerator value is not representable in
16362	// an int (C99 6.7.2.2p2). However, we support GCC's extension that
16363	// permits enumerator values that are representable in some larger
16364	// integral type.
16365	if (!getLangOpts().CPlusPlus && !T.isNull())
16366	Diag(IdLoc, diag::warn_enum_value_overflow);
16367	} else if (!getLangOpts().CPlusPlus &&
16368	!isRepresentableIntegerValue(Context, EnumVal, EltTy)) {
16369	// Enforce C99 6.7.2.2p2 even when we compute the next value.
16370	Diag(IdLoc, diag::ext_enum_value_not_int)
16371	<< EnumVal.toString(10) << 1;
16372	}
16373	}
16374	}
16375
16376	if (!EltTy->isDependentType()) {
16377	// Make the enumerator value match the signedness and size of the
16378	// enumerator's type.
16379	EnumVal = EnumVal.extOrTrunc(Context.getIntWidth(EltTy));
16380	EnumVal.setIsSigned(EltTy->isSignedIntegerOrEnumerationType());
16381	}
16382
16383	return EnumConstantDecl::Create(Context, Enum, IdLoc, Id, EltTy,
16384	Val, EnumVal);
16385	}
16386
16387	Sema::SkipBodyInfo Sema::shouldSkipAnonEnumBody(Scope S, IdentifierInfo II,
16388	SourceLocation IILoc) {
16389	if (!(getLangOpts().Modules \|\| getLangOpts().ModulesLocalVisibility) \|\|
16390	!getLangOpts().CPlusPlus)
16391	return SkipBodyInfo();
16392
16393	// We have an anonymous enum definition. Look up the first enumerator to
16394	// determine if we should merge the definition with an existing one and
16395	// skip the body.
16396	NamedDecl *PrevDecl = LookupSingleName(S, II, IILoc, LookupOrdinaryName,
16397	forRedeclarationInCurContext());
16398	auto *PrevECD = dyn_cast_or_null<EnumConstantDecl>(PrevDecl);
16399	if (!PrevECD)
16400	return SkipBodyInfo();
16401
16402	EnumDecl *PrevED = cast<EnumDecl>(PrevECD->getDeclContext());
16403	NamedDecl *Hidden;
16404	if (!PrevED->getDeclName() && !hasVisibleDefinition(PrevED, &Hidden)) {
16405	SkipBodyInfo Skip;
16406	Skip.Previous = Hidden;
16407	return Skip;
16408	}
16409
16410	return SkipBodyInfo();
16411	}
16412
16413	Decl Sema::ActOnEnumConstant(Scope S, Decl theEnumDecl, Decl lastEnumConst,
16414	SourceLocation IdLoc, IdentifierInfo *Id,
16415	const ParsedAttributesView &Attrs,
16416	SourceLocation EqualLoc, Expr *Val) {
16417	EnumDecl *TheEnumDecl = cast<EnumDecl>(theEnumDecl);
16418	EnumConstantDecl *LastEnumConst =
16419	cast_or_null<EnumConstantDecl>(lastEnumConst);
16420
16421	// The scope passed in may not be a decl scope. Zip up the scope tree until
16422	// we find one that is.
16423	S = getNonFieldDeclScope(S);
16424
16425	// Verify that there isn't already something declared with this name in this
16426	// scope.
16427	LookupResult R(*this, Id, IdLoc, LookupOrdinaryName, ForVisibleRedeclaration);
16428	LookupName(R, S);
16429	NamedDecl *PrevDecl = R.getAsSingle<NamedDecl>();
16430
16431	if (PrevDecl && PrevDecl->isTemplateParameter()) {
16432	// Maybe we will complain about the shadowed template parameter.
16433	DiagnoseTemplateParameterShadow(IdLoc, PrevDecl);
16434	// Just pretend that we didn't see the previous declaration.
16435	PrevDecl = nullptr;
16436	}
16437
16438	// C++ [class.mem]p15:
16439	// If T is the name of a class, then each of the following shall have a name
16440	// different from T:
16441	// - every enumerator of every member of class T that is an unscoped
16442	// enumerated type
16443	if (getLangOpts().CPlusPlus && !TheEnumDecl->isScoped())
16444	DiagnoseClassNameShadow(TheEnumDecl->getDeclContext(),
16445	DeclarationNameInfo(Id, IdLoc));
16446
16447	EnumConstantDecl *New =
16448	CheckEnumConstant(TheEnumDecl, LastEnumConst, IdLoc, Id, Val);
16449	if (!New)
16450	return nullptr;
16451
16452	if (PrevDecl) {
16453	if (!TheEnumDecl->isScoped() && isa<ValueDecl>(PrevDecl)) {
16454	// Check for other kinds of shadowing not already handled.
16455	CheckShadow(New, PrevDecl, R);
16456	}
16457
16458	// When in C++, we may get a TagDecl with the same name; in this case the
16459	// enum constant will 'hide' the tag.
16460	assert((getLangOpts().CPlusPlus \|\| !isa<TagDecl>(PrevDecl)) &&(((getLangOpts().CPlusPlus \|\| !isa<TagDecl>(PrevDecl)) && "Received TagDecl when not in C++!") ? static_cast<void> (0) : __assert_fail ("(getLangOpts().CPlusPlus \|\| !isa<TagDecl>(PrevDecl)) && \"Received TagDecl when not in C++!\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 16461, __PRETTY_FUNCTION__))
16461	"Received TagDecl when not in C++!")(((getLangOpts().CPlusPlus \|\| !isa<TagDecl>(PrevDecl)) && "Received TagDecl when not in C++!") ? static_cast<void> (0) : __assert_fail ("(getLangOpts().CPlusPlus \|\| !isa<TagDecl>(PrevDecl)) && \"Received TagDecl when not in C++!\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 16461, __PRETTY_FUNCTION__));
16462	if (!isa<TagDecl>(PrevDecl) && isDeclInScope(PrevDecl, CurContext, S)) {
16463	if (isa<EnumConstantDecl>(PrevDecl))
16464	Diag(IdLoc, diag::err_redefinition_of_enumerator) << Id;
16465	else
16466	Diag(IdLoc, diag::err_redefinition) << Id;
16467	notePreviousDefinition(PrevDecl, IdLoc);
16468	return nullptr;
16469	}
16470	}
16471
16472	// Process attributes.
16473	ProcessDeclAttributeList(S, New, Attrs);
16474	AddPragmaAttributes(S, New);
16475
16476	// Register this decl in the current scope stack.
16477	New->setAccess(TheEnumDecl->getAccess());
16478	PushOnScopeChains(New, S);
16479
16480	ActOnDocumentableDecl(New);
16481
16482	return New;
16483	}
16484
16485	// Returns true when the enum initial expression does not trigger the
16486	// duplicate enum warning. A few common cases are exempted as follows:
16487	// Element2 = Element1
16488	// Element2 = Element1 + 1
16489	// Element2 = Element1 - 1
16490	// Where Element2 and Element1 are from the same enum.
16491	static bool ValidDuplicateEnum(EnumConstantDecl ECD, EnumDecl Enum) {
16492	Expr *InitExpr = ECD->getInitExpr();
16493	if (!InitExpr)
16494	return true;
16495	InitExpr = InitExpr->IgnoreImpCasts();
16496
16497	if (BinaryOperator *BO = dyn_cast<BinaryOperator>(InitExpr)) {
16498	if (!BO->isAdditiveOp())
16499	return true;
16500	IntegerLiteral *IL = dyn_cast<IntegerLiteral>(BO->getRHS());
16501	if (!IL)
16502	return true;
16503	if (IL->getValue() != 1)
16504	return true;
16505
16506	InitExpr = BO->getLHS();
16507	}
16508
16509	// This checks if the elements are from the same enum.
16510	DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(InitExpr);
16511	if (!DRE)
16512	return true;
16513
16514	EnumConstantDecl *EnumConstant = dyn_cast<EnumConstantDecl>(DRE->getDecl());
16515	if (!EnumConstant)
16516	return true;
16517
16518	if (cast<EnumDecl>(TagDecl::castFromDeclContext(ECD->getDeclContext())) !=
16519	Enum)
16520	return true;
16521
16522	return false;
16523	}
16524
16525	// Emits a warning when an element is implicitly set a value that
16526	// a previous element has already been set to.
16527	static void CheckForDuplicateEnumValues(Sema &S, ArrayRef<Decl *> Elements,
16528	EnumDecl *Enum, QualType EnumType) {
16529	// Avoid anonymous enums
16530	if (!Enum->getIdentifier())
16531	return;
16532
16533	// Only check for small enums.
16534	if (Enum->getNumPositiveBits() > 63 \|\| Enum->getNumNegativeBits() > 64)
16535	return;
16536
16537	if (S.Diags.isIgnored(diag::warn_duplicate_enum_values, Enum->getLocation()))
16538	return;
16539
16540	typedef SmallVector<EnumConstantDecl *, 3> ECDVector;
16541	typedef SmallVector<std::unique_ptr<ECDVector>, 3> DuplicatesVector;
16542
16543	typedef llvm::PointerUnion<EnumConstantDecl, ECDVector> DeclOrVector;
16544	typedef std::unordered_map<int64_t, DeclOrVector> ValueToVectorMap;
16545
16546	// Use int64_t as a key to avoid needing special handling for DenseMap keys.
16547	auto EnumConstantToKey = [](const EnumConstantDecl *D) {
16548	llvm::APSInt Val = D->getInitVal();
16549	return Val.isSigned() ? Val.getSExtValue() : Val.getZExtValue();
16550	};
16551
16552	DuplicatesVector DupVector;
16553	ValueToVectorMap EnumMap;
16554
16555	// Populate the EnumMap with all values represented by enum constants without
16556	// an initializer.
16557	for (auto *Element : Elements) {
16558	EnumConstantDecl *ECD = cast_or_null<EnumConstantDecl>(Element);
16559
16560	// Null EnumConstantDecl means a previous diagnostic has been emitted for
16561	// this constant. Skip this enum since it may be ill-formed.
16562	if (!ECD) {
16563	return;
16564	}
16565
16566	// Constants with initalizers are handled in the next loop.
16567	if (ECD->getInitExpr())
16568	continue;
16569
16570	// Duplicate values are handled in the next loop.
16571	EnumMap.insert({EnumConstantToKey(ECD), ECD});
16572	}
16573
16574	if (EnumMap.size() == 0)
16575	return;
16576
16577	// Create vectors for any values that has duplicates.
16578	for (auto *Element : Elements) {
16579	// The last loop returned if any constant was null.
16580	EnumConstantDecl *ECD = cast<EnumConstantDecl>(Element);
16581	if (!ValidDuplicateEnum(ECD, Enum))
16582	continue;
16583
16584	auto Iter = EnumMap.find(EnumConstantToKey(ECD));
16585	if (Iter == EnumMap.end())
16586	continue;
16587
16588	DeclOrVector& Entry = Iter->second;
16589	if (EnumConstantDecl D = Entry.dyn_cast<EnumConstantDecl>()) {
16590	// Ensure constants are different.
16591	if (D == ECD)
16592	continue;
16593
16594	// Create new vector and push values onto it.
16595	auto Vec = llvm::make_unique<ECDVector>();
16596	Vec->push_back(D);
16597	Vec->push_back(ECD);
16598
16599	// Update entry to point to the duplicates vector.
16600	Entry = Vec.get();
16601
16602	// Store the vector somewhere we can consult later for quick emission of
16603	// diagnostics.
16604	DupVector.emplace_back(std::move(Vec));
16605	continue;
16606	}
16607
16608	ECDVector Vec = Entry.get<ECDVector>();
16609	// Make sure constants are not added more than once.
16610	if (*Vec->begin() == ECD)
16611	continue;
16612
16613	Vec->push_back(ECD);
16614	}
16615
16616	// Emit diagnostics.
16617	for (const auto &Vec : DupVector) {
16618	assert(Vec->size() > 1 && "ECDVector should have at least 2 elements.")((Vec->size() > 1 && "ECDVector should have at least 2 elements." ) ? static_cast<void> (0) : __assert_fail ("Vec->size() > 1 && \"ECDVector should have at least 2 elements.\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 16618, __PRETTY_FUNCTION__));
16619
16620	// Emit warning for one enum constant.
16621	auto *FirstECD = Vec->front();
16622	S.Diag(FirstECD->getLocation(), diag::warn_duplicate_enum_values)
16623	<< FirstECD << FirstECD->getInitVal().toString(10)
16624	<< FirstECD->getSourceRange();
16625
16626	// Emit one note for each of the remaining enum constants with
16627	// the same value.
16628	for (auto *ECD : llvm::make_range(Vec->begin() + 1, Vec->end()))
16629	S.Diag(ECD->getLocation(), diag::note_duplicate_element)
16630	<< ECD << ECD->getInitVal().toString(10)
16631	<< ECD->getSourceRange();
16632	}
16633	}
16634
16635	bool Sema::IsValueInFlagEnum(const EnumDecl *ED, const llvm::APInt &Val,
16636	bool AllowMask) const {
16637	assert(ED->isClosedFlag() && "looking for value in non-flag or open enum")((ED->isClosedFlag() && "looking for value in non-flag or open enum" ) ? static_cast<void> (0) : __assert_fail ("ED->isClosedFlag() && \"looking for value in non-flag or open enum\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 16637, __PRETTY_FUNCTION__));
16638	assert(ED->isCompleteDefinition() && "expected enum definition")((ED->isCompleteDefinition() && "expected enum definition" ) ? static_cast<void> (0) : __assert_fail ("ED->isCompleteDefinition() && \"expected enum definition\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 16638, __PRETTY_FUNCTION__));
16639
16640	auto R = FlagBitsCache.insert(std::make_pair(ED, llvm::APInt()));
16641	llvm::APInt &FlagBits = R.first->second;
16642
16643	if (R.second) {
16644	for (auto *E : ED->enumerators()) {
16645	const auto &EVal = E->getInitVal();
16646	// Only single-bit enumerators introduce new flag values.
16647	if (EVal.isPowerOf2())
16648	FlagBits = FlagBits.zextOrSelf(EVal.getBitWidth()) \| EVal;
16649	}
16650	}
16651
16652	// A value is in a flag enum if either its bits are a subset of the enum's
16653	// flag bits (the first condition) or we are allowing masks and the same is
16654	// true of its complement (the second condition). When masks are allowed, we
16655	// allow the common idiom of ~(enum1 \| enum2) to be a valid enum value.
16656	//
16657	// While it's true that any value could be used as a mask, the assumption is
16658	// that a mask will have all of the insignificant bits set. Anything else is
16659	// likely a logic error.
16660	llvm::APInt FlagMask = ~FlagBits.zextOrTrunc(Val.getBitWidth());
16661	return !(FlagMask & Val) \|\| (AllowMask && !(FlagMask & ~Val));
16662	}
16663
16664	void Sema::ActOnEnumBody(SourceLocation EnumLoc, SourceRange BraceRange,
16665	Decl EnumDeclX, ArrayRef<Decl > Elements, Scope *S,
16666	const ParsedAttributesView &Attrs) {
16667	EnumDecl *Enum = cast<EnumDecl>(EnumDeclX);
16668	QualType EnumType = Context.getTypeDeclType(Enum);
16669
16670	ProcessDeclAttributeList(S, Enum, Attrs);
16671
16672	if (Enum->isDependentType()) {
16673	for (unsigned i = 0, e = Elements.size(); i != e; ++i) {
16674	EnumConstantDecl *ECD =
16675	cast_or_null<EnumConstantDecl>(Elements[i]);
16676	if (!ECD) continue;
16677
16678	ECD->setType(EnumType);
16679	}
16680
16681	Enum->completeDefinition(Context.DependentTy, Context.DependentTy, 0, 0);
16682	return;
16683	}
16684
16685	// TODO: If the result value doesn't fit in an int, it must be a long or long
16686	// long value. ISO C does not support this, but GCC does as an extension,
16687	// emit a warning.
16688	unsigned IntWidth = Context.getTargetInfo().getIntWidth();
16689	unsigned CharWidth = Context.getTargetInfo().getCharWidth();
16690	unsigned ShortWidth = Context.getTargetInfo().getShortWidth();
16691
16692	// Verify that all the values are okay, compute the size of the values, and
16693	// reverse the list.
16694	unsigned NumNegativeBits = 0;
16695	unsigned NumPositiveBits = 0;
16696
16697	// Keep track of whether all elements have type int.
16698	bool AllElementsInt = true;
16699
16700	for (unsigned i = 0, e = Elements.size(); i != e; ++i) {
16701	EnumConstantDecl *ECD =
16702	cast_or_null<EnumConstantDecl>(Elements[i]);
16703	if (!ECD) continue; // Already issued a diagnostic.
16704
16705	const llvm::APSInt &InitVal = ECD->getInitVal();
16706
16707	// Keep track of the size of positive and negative values.
16708	if (InitVal.isUnsigned() \|\| InitVal.isNonNegative())
16709	NumPositiveBits = std::max(NumPositiveBits,
16710	(unsigned)InitVal.getActiveBits());
16711	else
16712	NumNegativeBits = std::max(NumNegativeBits,
16713	(unsigned)InitVal.getMinSignedBits());
16714
16715	// Keep track of whether every enum element has type int (very common).
16716	if (AllElementsInt)
16717	AllElementsInt = ECD->getType() == Context.IntTy;
16718	}
16719
16720	// Figure out the type that should be used for this enum.
16721	QualType BestType;
16722	unsigned BestWidth;
16723
16724	// C++0x N3000 [conv.prom]p3:
16725	// An rvalue of an unscoped enumeration type whose underlying
16726	// type is not fixed can be converted to an rvalue of the first
16727	// of the following types that can represent all the values of
16728	// the enumeration: int, unsigned int, long int, unsigned long
16729	// int, long long int, or unsigned long long int.
16730	// C99 6.4.4.3p2:
16731	// An identifier declared as an enumeration constant has type int.
16732	// The C99 rule is modified by a gcc extension
16733	QualType BestPromotionType;
16734
16735	bool Packed = Enum->hasAttr<PackedAttr>();
16736	// -fshort-enums is the equivalent to specifying the packed attribute on all
16737	// enum definitions.
16738	if (LangOpts.ShortEnums)
16739	Packed = true;
16740
16741	// If the enum already has a type because it is fixed or dictated by the
16742	// target, promote that type instead of analyzing the enumerators.
16743	if (Enum->isComplete()) {
16744	BestType = Enum->getIntegerType();
16745	if (BestType->isPromotableIntegerType())
16746	BestPromotionType = Context.getPromotedIntegerType(BestType);
16747	else
16748	BestPromotionType = BestType;
16749
16750	BestWidth = Context.getIntWidth(BestType);
16751	}
16752	else if (NumNegativeBits) {
16753	// If there is a negative value, figure out the smallest integer type (of
16754	// int/long/longlong) that fits.
16755	// If it's packed, check also if it fits a char or a short.
16756	if (Packed && NumNegativeBits <= CharWidth && NumPositiveBits < CharWidth) {
16757	BestType = Context.SignedCharTy;
16758	BestWidth = CharWidth;
16759	} else if (Packed && NumNegativeBits <= ShortWidth &&
16760	NumPositiveBits < ShortWidth) {
16761	BestType = Context.ShortTy;
16762	BestWidth = ShortWidth;
16763	} else if (NumNegativeBits <= IntWidth && NumPositiveBits < IntWidth) {
16764	BestType = Context.IntTy;
16765	BestWidth = IntWidth;
16766	} else {
16767	BestWidth = Context.getTargetInfo().getLongWidth();
16768
16769	if (NumNegativeBits <= BestWidth && NumPositiveBits < BestWidth) {
16770	BestType = Context.LongTy;
16771	} else {
16772	BestWidth = Context.getTargetInfo().getLongLongWidth();
16773
16774	if (NumNegativeBits > BestWidth \|\| NumPositiveBits >= BestWidth)
16775	Diag(Enum->getLocation(), diag::ext_enum_too_large);
16776	BestType = Context.LongLongTy;
16777	}
16778	}
16779	BestPromotionType = (BestWidth <= IntWidth ? Context.IntTy : BestType);
16780	} else {
16781	// If there is no negative value, figure out the smallest type that fits
16782	// all of the enumerator values.
16783	// If it's packed, check also if it fits a char or a short.
16784	if (Packed && NumPositiveBits <= CharWidth) {
16785	BestType = Context.UnsignedCharTy;
16786	BestPromotionType = Context.IntTy;
16787	BestWidth = CharWidth;
16788	} else if (Packed && NumPositiveBits <= ShortWidth) {
16789	BestType = Context.UnsignedShortTy;
16790	BestPromotionType = Context.IntTy;
16791	BestWidth = ShortWidth;
16792	} else if (NumPositiveBits <= IntWidth) {
16793	BestType = Context.UnsignedIntTy;
16794	BestWidth = IntWidth;
16795	BestPromotionType
16796	= (NumPositiveBits == BestWidth \|\| !getLangOpts().CPlusPlus)
16797	? Context.UnsignedIntTy : Context.IntTy;
16798	} else if (NumPositiveBits <=
16799	(BestWidth = Context.getTargetInfo().getLongWidth())) {
16800	BestType = Context.UnsignedLongTy;
16801	BestPromotionType
16802	= (NumPositiveBits == BestWidth \|\| !getLangOpts().CPlusPlus)
16803	? Context.UnsignedLongTy : Context.LongTy;
16804	} else {
16805	BestWidth = Context.getTargetInfo().getLongLongWidth();
16806	assert(NumPositiveBits <= BestWidth &&((NumPositiveBits <= BestWidth && "How could an initializer get larger than ULL?" ) ? static_cast<void> (0) : __assert_fail ("NumPositiveBits <= BestWidth && \"How could an initializer get larger than ULL?\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 16807, __PRETTY_FUNCTION__))
16807	"How could an initializer get larger than ULL?")((NumPositiveBits <= BestWidth && "How could an initializer get larger than ULL?" ) ? static_cast<void> (0) : __assert_fail ("NumPositiveBits <= BestWidth && \"How could an initializer get larger than ULL?\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 16807, __PRETTY_FUNCTION__));
16808	BestType = Context.UnsignedLongLongTy;
16809	BestPromotionType
16810	= (NumPositiveBits == BestWidth \|\| !getLangOpts().CPlusPlus)
16811	? Context.UnsignedLongLongTy : Context.LongLongTy;
16812	}
16813	}
16814
16815	// Loop over all of the enumerator constants, changing their types to match
16816	// the type of the enum if needed.
16817	for (auto *D : Elements) {
16818	auto *ECD = cast_or_null<EnumConstantDecl>(D);
16819	if (!ECD) continue; // Already issued a diagnostic.
16820
16821	// Standard C says the enumerators have int type, but we allow, as an
16822	// extension, the enumerators to be larger than int size. If each
16823	// enumerator value fits in an int, type it as an int, otherwise type it the
16824	// same as the enumerator decl itself. This means that in "enum { X = 1U }"
16825	// that X has type 'int', not 'unsigned'.
16826
16827	// Determine whether the value fits into an int.
16828	llvm::APSInt InitVal = ECD->getInitVal();
16829
16830	// If it fits into an integer type, force it. Otherwise force it to match
16831	// the enum decl type.
16832	QualType NewTy;
16833	unsigned NewWidth;
16834	bool NewSign;
16835	if (!getLangOpts().CPlusPlus &&
16836	!Enum->isFixed() &&
16837	isRepresentableIntegerValue(Context, InitVal, Context.IntTy)) {
16838	NewTy = Context.IntTy;
16839	NewWidth = IntWidth;
16840	NewSign = true;
16841	} else if (ECD->getType() == BestType) {
16842	// Already the right type!
16843	if (getLangOpts().CPlusPlus)
16844	// C++ [dcl.enum]p4: Following the closing brace of an
16845	// enum-specifier, each enumerator has the type of its
16846	// enumeration.
16847	ECD->setType(EnumType);
16848	continue;
16849	} else {
16850	NewTy = BestType;
16851	NewWidth = BestWidth;
16852	NewSign = BestType->isSignedIntegerOrEnumerationType();
16853	}
16854
16855	// Adjust the APSInt value.
16856	InitVal = InitVal.extOrTrunc(NewWidth);
16857	InitVal.setIsSigned(NewSign);
16858	ECD->setInitVal(InitVal);
16859
16860	// Adjust the Expr initializer and type.
16861	if (ECD->getInitExpr() &&
16862	!Context.hasSameType(NewTy, ECD->getInitExpr()->getType()))
16863	ECD->setInitExpr(ImplicitCastExpr::Create(Context, NewTy,
16864	CK_IntegralCast,
16865	ECD->getInitExpr(),
16866	/base paths/ nullptr,
16867	VK_RValue));
16868	if (getLangOpts().CPlusPlus)
16869	// C++ [dcl.enum]p4: Following the closing brace of an
16870	// enum-specifier, each enumerator has the type of its
16871	// enumeration.
16872	ECD->setType(EnumType);
16873	else
16874	ECD->setType(NewTy);
16875	}
16876
16877	Enum->completeDefinition(BestType, BestPromotionType,
16878	NumPositiveBits, NumNegativeBits);
16879
16880	CheckForDuplicateEnumValues(*this, Elements, Enum, EnumType);
16881
16882	if (Enum->isClosedFlag()) {
16883	for (Decl *D : Elements) {
16884	EnumConstantDecl *ECD = cast_or_null<EnumConstantDecl>(D);
16885	if (!ECD) continue; // Already issued a diagnostic.
16886
16887	llvm::APSInt InitVal = ECD->getInitVal();
16888	if (InitVal != 0 && !InitVal.isPowerOf2() &&
16889	!IsValueInFlagEnum(Enum, InitVal, true))
16890	Diag(ECD->getLocation(), diag::warn_flag_enum_constant_out_of_range)
16891	<< ECD << Enum;
16892	}
16893	}
16894
16895	// Now that the enum type is defined, ensure it's not been underaligned.
16896	if (Enum->hasAttrs())
16897	CheckAlignasUnderalignment(Enum);
16898	}
16899
16900	Decl Sema::ActOnFileScopeAsmDecl(Expr expr,
16901	SourceLocation StartLoc,
16902	SourceLocation EndLoc) {
16903	StringLiteral *AsmString = cast<StringLiteral>(expr);
16904
16905	FileScopeAsmDecl *New = FileScopeAsmDecl::Create(Context, CurContext,
16906	AsmString, StartLoc,
16907	EndLoc);
16908	CurContext->addDecl(New);
16909	return New;
16910	}
16911
16912	static void checkModuleImportContext(Sema &S, Module *M,
16913	SourceLocation ImportLoc, DeclContext *DC,
16914	bool FromInclude = false) {
16915	SourceLocation ExternCLoc;
16916
16917	if (auto *LSD = dyn_cast<LinkageSpecDecl>(DC)) {
16918	switch (LSD->getLanguage()) {
16919	case LinkageSpecDecl::lang_c:
16920	if (ExternCLoc.isInvalid())
16921	ExternCLoc = LSD->getBeginLoc();
16922	break;
16923	case LinkageSpecDecl::lang_cxx:
16924	break;
16925	}
16926	DC = LSD->getParent();
16927	}
16928
16929	while (isa<LinkageSpecDecl>(DC) \|\| isa<ExportDecl>(DC))
16930	DC = DC->getParent();
16931
16932	if (!isa<TranslationUnitDecl>(DC)) {
16933	S.Diag(ImportLoc, (FromInclude && S.isModuleVisible(M))
16934	? diag::ext_module_import_not_at_top_level_noop
16935	: diag::err_module_import_not_at_top_level_fatal)
16936	<< M->getFullModuleName() << DC;
16937	S.Diag(cast<Decl>(DC)->getBeginLoc(),
16938	diag::note_module_import_not_at_top_level)
16939	<< DC;
16940	} else if (!M->IsExternC && ExternCLoc.isValid()) {
16941	S.Diag(ImportLoc, diag::ext_module_import_in_extern_c)
16942	<< M->getFullModuleName();
16943	S.Diag(ExternCLoc, diag::note_extern_c_begins_here);
16944	}
16945	}
16946
16947	Sema::DeclGroupPtrTy Sema::ActOnModuleDecl(SourceLocation StartLoc,
16948	SourceLocation ModuleLoc,
16949	ModuleDeclKind MDK,
16950	ModuleIdPath Path) {
16951	assert(getLangOpts().ModulesTS &&((getLangOpts().ModulesTS && "should only have module decl in modules TS" ) ? static_cast<void> (0) : __assert_fail ("getLangOpts().ModulesTS && \"should only have module decl in modules TS\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 16952, __PRETTY_FUNCTION__))
16952	"should only have module decl in modules TS")((getLangOpts().ModulesTS && "should only have module decl in modules TS" ) ? static_cast<void> (0) : __assert_fail ("getLangOpts().ModulesTS && \"should only have module decl in modules TS\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 16952, __PRETTY_FUNCTION__));
16953
16954	// A module implementation unit requires that we are not compiling a module
16955	// of any kind. A module interface unit requires that we are not compiling a
16956	// module map.
16957	switch (getLangOpts().getCompilingModule()) {
16958	case LangOptions::CMK_None:
16959	// It's OK to compile a module interface as a normal translation unit.
16960	break;
16961
16962	case LangOptions::CMK_ModuleInterface:
16963	if (MDK != ModuleDeclKind::Implementation)
16964	break;
16965
16966	// We were asked to compile a module interface unit but this is a module
16967	// implementation unit. That indicates the 'export' is missing.
16968	Diag(ModuleLoc, diag::err_module_interface_implementation_mismatch)
16969	<< FixItHint::CreateInsertion(ModuleLoc, "export ");
16970	MDK = ModuleDeclKind::Interface;
16971	break;
16972
16973	case LangOptions::CMK_ModuleMap:
16974	Diag(ModuleLoc, diag::err_module_decl_in_module_map_module);
16975	return nullptr;
16976
16977	case LangOptions::CMK_HeaderModule:
16978	Diag(ModuleLoc, diag::err_module_decl_in_header_module);
16979	return nullptr;
16980	}
16981
16982	assert(ModuleScopes.size() == 1 && "expected to be at global module scope")((ModuleScopes.size() == 1 && "expected to be at global module scope" ) ? static_cast<void> (0) : __assert_fail ("ModuleScopes.size() == 1 && \"expected to be at global module scope\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 16982, __PRETTY_FUNCTION__));
16983
16984	// FIXME: Most of this work should be done by the preprocessor rather than
16985	// here, in order to support macro import.
16986
16987	// Only one module-declaration is permitted per source file.
16988	if (ModuleScopes.back().Module->Kind == Module::ModuleInterfaceUnit) {
16989	Diag(ModuleLoc, diag::err_module_redeclaration);
16990	Diag(VisibleModules.getImportLoc(ModuleScopes.back().Module),
16991	diag::note_prev_module_declaration);
16992	return nullptr;
16993	}
16994
16995	// Flatten the dots in a module name. Unlike Clang's hierarchical module map
16996	// modules, the dots here are just another character that can appear in a
16997	// module name.
16998	std::string ModuleName;
16999	for (auto &Piece : Path) {
17000	if (!ModuleName.empty())
17001	ModuleName += ".";
17002	ModuleName += Piece.first->getName();
17003	}
17004
17005	// If a module name was explicitly specified on the command line, it must be
17006	// correct.
17007	if (!getLangOpts().CurrentModule.empty() &&
17008	getLangOpts().CurrentModule != ModuleName) {
17009	Diag(Path.front().second, diag::err_current_module_name_mismatch)
17010	<< SourceRange(Path.front().second, Path.back().second)
17011	<< getLangOpts().CurrentModule;
17012	return nullptr;
17013	}
17014	const_cast<LangOptions&>(getLangOpts()).CurrentModule = ModuleName;
17015
17016	auto &Map = PP.getHeaderSearchInfo().getModuleMap();
17017	Module *Mod;
17018
17019	switch (MDK) {
17020	case ModuleDeclKind::Interface: {
17021	// We can't have parsed or imported a definition of this module or parsed a
17022	// module map defining it already.
17023	if (auto *M = Map.findModule(ModuleName)) {
17024	Diag(Path[0].second, diag::err_module_redefinition) << ModuleName;
17025	if (M->DefinitionLoc.isValid())
17026	Diag(M->DefinitionLoc, diag::note_prev_module_definition);
17027	else if (const auto *FE = M->getASTFile())
17028	Diag(M->DefinitionLoc, diag::note_prev_module_definition_from_ast_file)
17029	<< FE->getName();
17030	Mod = M;
17031	break;
17032	}
17033
17034	// Create a Module for the module that we're defining.
17035	Mod = Map.createModuleForInterfaceUnit(ModuleLoc, ModuleName,
17036	ModuleScopes.front().Module);
17037	assert(Mod && "module creation should not fail")((Mod && "module creation should not fail") ? static_cast <void> (0) : __assert_fail ("Mod && \"module creation should not fail\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 17037, __PRETTY_FUNCTION__));
17038	break;
17039	}
17040
17041	case ModuleDeclKind::Partition:
17042	// FIXME: Check we are in a submodule of the named module.
17043	return nullptr;
17044
17045	case ModuleDeclKind::Implementation:
17046	std::pair<IdentifierInfo *, SourceLocation> ModuleNameLoc(
17047	PP.getIdentifierInfo(ModuleName), Path[0].second);
17048	Mod = getModuleLoader().loadModule(ModuleLoc, {ModuleNameLoc},
17049	Module::AllVisible,
17050	/IsIncludeDirective=/false);
17051	if (!Mod) {
17052	Diag(ModuleLoc, diag::err_module_not_defined) << ModuleName;
17053	// Create an empty module interface unit for error recovery.
17054	Mod = Map.createModuleForInterfaceUnit(ModuleLoc, ModuleName,
17055	ModuleScopes.front().Module);
17056	}
17057	break;
17058	}
17059
17060	// Switch from the global module to the named module.
17061	ModuleScopes.back().Module = Mod;
17062	ModuleScopes.back().ModuleInterface = MDK != ModuleDeclKind::Implementation;
17063	VisibleModules.setVisible(Mod, ModuleLoc);
17064
17065	// From now on, we have an owning module for all declarations we see.
17066	// However, those declarations are module-private unless explicitly
17067	// exported.
17068	auto *TU = Context.getTranslationUnitDecl();
17069	TU->setModuleOwnershipKind(Decl::ModuleOwnershipKind::ModulePrivate);
17070	TU->setLocalOwningModule(Mod);
17071
17072	// FIXME: Create a ModuleDecl.
17073	return nullptr;
17074	}
17075
17076	DeclResult Sema::ActOnModuleImport(SourceLocation StartLoc,
17077	SourceLocation ImportLoc,
17078	ModuleIdPath Path) {
17079	// Flatten the module path for a Modules TS module name.
17080	std::pair<IdentifierInfo *, SourceLocation> ModuleNameLoc;
17081	if (getLangOpts().ModulesTS) {
17082	std::string ModuleName;
17083	for (auto &Piece : Path) {
17084	if (!ModuleName.empty())
17085	ModuleName += ".";
17086	ModuleName += Piece.first->getName();
17087	}
17088	ModuleNameLoc = {PP.getIdentifierInfo(ModuleName), Path[0].second};
17089	Path = ModuleIdPath(ModuleNameLoc);
17090	}
17091
17092	Module *Mod =
17093	getModuleLoader().loadModule(ImportLoc, Path, Module::AllVisible,
17094	/IsIncludeDirective=/false);
17095	if (!Mod)
17096	return true;
17097
17098	VisibleModules.setVisible(Mod, ImportLoc);
17099
17100	checkModuleImportContext(*this, Mod, ImportLoc, CurContext);
17101
17102	// FIXME: we should support importing a submodule within a different submodule
17103	// of the same top-level module. Until we do, make it an error rather than
17104	// silently ignoring the import.
17105	// Import-from-implementation is valid in the Modules TS. FIXME: Should we
17106	// warn on a redundant import of the current module?
17107	if (Mod->getTopLevelModuleName() == getLangOpts().CurrentModule &&
17108	(getLangOpts().isCompilingModule() \|\| !getLangOpts().ModulesTS))
17109	Diag(ImportLoc, getLangOpts().isCompilingModule()
17110	? diag::err_module_self_import
17111	: diag::err_module_import_in_implementation)
17112	<< Mod->getFullModuleName() << getLangOpts().CurrentModule;
17113
17114	SmallVector<SourceLocation, 2> IdentifierLocs;
17115	Module *ModCheck = Mod;
17116	for (unsigned I = 0, N = Path.size(); I != N; ++I) {
17117	// If we've run out of module parents, just drop the remaining identifiers.
17118	// We need the length to be consistent.
17119	if (!ModCheck)
17120	break;
17121	ModCheck = ModCheck->Parent;
17122
17123	IdentifierLocs.push_back(Path[I].second);
17124	}
17125
17126	ImportDecl *Import = ImportDecl::Create(Context, CurContext, StartLoc,
17127	Mod, IdentifierLocs);
17128	if (!ModuleScopes.empty())
17129	Context.addModuleInitializer(ModuleScopes.back().Module, Import);
17130	CurContext->addDecl(Import);
17131
17132	// Re-export the module if needed.
17133	if (Import->isExported() &&
17134	!ModuleScopes.empty() && ModuleScopes.back().ModuleInterface)
17135	getCurrentModule()->Exports.emplace_back(Mod, false);
17136
17137	return Import;
17138	}
17139
17140	void Sema::ActOnModuleInclude(SourceLocation DirectiveLoc, Module *Mod) {
17141	checkModuleImportContext(*this, Mod, DirectiveLoc, CurContext, true);
17142	BuildModuleInclude(DirectiveLoc, Mod);
17143	}
17144
17145	void Sema::BuildModuleInclude(SourceLocation DirectiveLoc, Module *Mod) {
17146	// Determine whether we're in the #include buffer for a module. The #includes
17147	// in that buffer do not qualify as module imports; they're just an
17148	// implementation detail of us building the module.
17149	//
17150	// FIXME: Should we even get ActOnModuleInclude calls for those?
17151	bool IsInModuleIncludes =
17152	TUKind == TU_Module &&
17153	getSourceManager().isWrittenInMainFile(DirectiveLoc);
17154
17155	bool ShouldAddImport = !IsInModuleIncludes;
17156
17157	// If this module import was due to an inclusion directive, create an
17158	// implicit import declaration to capture it in the AST.
17159	if (ShouldAddImport) {
17160	TranslationUnitDecl *TU = getASTContext().getTranslationUnitDecl();
17161	ImportDecl *ImportD = ImportDecl::CreateImplicit(getASTContext(), TU,
17162	DirectiveLoc, Mod,
17163	DirectiveLoc);
17164	if (!ModuleScopes.empty())
17165	Context.addModuleInitializer(ModuleScopes.back().Module, ImportD);
17166	TU->addDecl(ImportD);
17167	Consumer.HandleImplicitImportDecl(ImportD);
17168	}
17169
17170	getModuleLoader().makeModuleVisible(Mod, Module::AllVisible, DirectiveLoc);
17171	VisibleModules.setVisible(Mod, DirectiveLoc);
17172	}
17173
17174	void Sema::ActOnModuleBegin(SourceLocation DirectiveLoc, Module *Mod) {
17175	checkModuleImportContext(*this, Mod, DirectiveLoc, CurContext, true);
17176
17177	ModuleScopes.push_back({});
17178	ModuleScopes.back().Module = Mod;
17179	if (getLangOpts().ModulesLocalVisibility)
17180	ModuleScopes.back().OuterVisibleModules = std::move(VisibleModules);
17181
17182	VisibleModules.setVisible(Mod, DirectiveLoc);
17183
17184	// The enclosing context is now part of this module.
17185	// FIXME: Consider creating a child DeclContext to hold the entities
17186	// lexically within the module.
17187	if (getLangOpts().trackLocalOwningModule()) {
17188	for (auto *DC = CurContext; DC; DC = DC->getLexicalParent()) {
17189	cast<Decl>(DC)->setModuleOwnershipKind(
17190	getLangOpts().ModulesLocalVisibility
17191	? Decl::ModuleOwnershipKind::VisibleWhenImported
17192	: Decl::ModuleOwnershipKind::Visible);
17193	cast<Decl>(DC)->setLocalOwningModule(Mod);
17194	}
17195	}
17196	}
17197
17198	void Sema::ActOnModuleEnd(SourceLocation EomLoc, Module *Mod) {
17199	if (getLangOpts().ModulesLocalVisibility) {
17200	VisibleModules = std::move(ModuleScopes.back().OuterVisibleModules);
17201	// Leaving a module hides namespace names, so our visible namespace cache
17202	// is now out of date.
17203	VisibleNamespaceCache.clear();
17204	}
17205
17206	assert(!ModuleScopes.empty() && ModuleScopes.back().Module == Mod &&((!ModuleScopes.empty() && ModuleScopes.back().Module == Mod && "left the wrong module scope") ? static_cast <void> (0) : __assert_fail ("!ModuleScopes.empty() && ModuleScopes.back().Module == Mod && \"left the wrong module scope\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 17207, __PRETTY_FUNCTION__))
17207	"left the wrong module scope")((!ModuleScopes.empty() && ModuleScopes.back().Module == Mod && "left the wrong module scope") ? static_cast <void> (0) : __assert_fail ("!ModuleScopes.empty() && ModuleScopes.back().Module == Mod && \"left the wrong module scope\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 17207, __PRETTY_FUNCTION__));
17208	ModuleScopes.pop_back();
17209
17210	// We got to the end of processing a local module. Create an
17211	// ImportDecl as we would for an imported module.
17212	FileID File = getSourceManager().getFileID(EomLoc);
17213	SourceLocation DirectiveLoc;
17214	if (EomLoc == getSourceManager().getLocForEndOfFile(File)) {
17215	// We reached the end of a #included module header. Use the #include loc.
17216	assert(File != getSourceManager().getMainFileID() &&((File != getSourceManager().getMainFileID() && "end of submodule in main source file" ) ? static_cast<void> (0) : __assert_fail ("File != getSourceManager().getMainFileID() && \"end of submodule in main source file\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 17217, __PRETTY_FUNCTION__))
17217	"end of submodule in main source file")((File != getSourceManager().getMainFileID() && "end of submodule in main source file" ) ? static_cast<void> (0) : __assert_fail ("File != getSourceManager().getMainFileID() && \"end of submodule in main source file\"" , "/build/llvm-toolchain-snapshot-8~svn348900/tools/clang/lib/Sema/SemaDecl.cpp" , 17217, __PRETTY_FUNCTION__));
17218	DirectiveLoc = getSourceManager().getIncludeLoc(File);
17219	} else {
17220	// We reached an EOM pragma. Use the pragma location.
17221	DirectiveLoc = EomLoc;
17222	}
17223	BuildModuleInclude(DirectiveLoc, Mod);
17224
17225	// Any further declarations are in whatever module we returned to.
17226	if (getLangOpts().trackLocalOwningModule()) {
17227	// The parser guarantees that this is the same context that we entered
17228	// the module within.
17229	for (auto *DC = CurContext; DC; DC = DC->getLexicalParent()) {
17230	cast<Decl>(DC)->setLocalOwningModule(getCurrentModule());
17231	if (!getCurrentModule())
17232	cast<Decl>(DC)->setModuleOwnershipKind(
17233	Decl::ModuleOwnershipKind::Unowned);
17234	}
17235	}
17236	}
17237
17238	void Sema::createImplicitModuleImportForErrorRecovery(SourceLocation Loc,
17239	Module *Mod) {
17240	// Bail if we're not allowed to implicitly import a module here.
17241	if (isSFINAEContext() \|\| !getLangOpts().ModulesErrorRecovery \|\|
17242	VisibleModules.isVisible(Mod))
17243	return;
17244
17245	// Create the implicit import declaration.
17246	TranslationUnitDecl *TU = getASTContext().getTranslationUnitDecl();
17247	ImportDecl *ImportD = ImportDecl::CreateImplicit(getASTContext(), TU,
17248	Loc, Mod, Loc);
17249	TU->addDecl(ImportD);
17250	Consumer.HandleImplicitImportDecl(ImportD);
17251
17252	// Make the module visible.
17253	getModuleLoader().makeModuleVisible(Mod, Module::AllVisible, Loc);
17254	VisibleModules.setVisible(Mod, Loc);
17255	}
17256
17257	/// We have parsed the start of an export declaration, including the '{'
17258	/// (if present).
17259	Decl Sema::ActOnStartExportDecl(Scope S, SourceLocation ExportLoc,
17260	SourceLocation LBraceLoc) {
17261	ExportDecl *D = ExportDecl::Create(Context, CurContext, ExportLoc);
17262
17263	// C++ Modules TS draft:
17264	// An export-declaration shall appear in the purview of a module other than
17265	// the global module.
17266	if (ModuleScopes.empty() \|\| !ModuleScopes.back().ModuleInterface)
17267	Diag(ExportLoc, diag::err_export_not_in_module_interface);
17268
17269	// An export-declaration [...] shall not contain more than one
17270	// export keyword.
17271	//
17272	// The intent here is that an export-declaration cannot appear within another
17273	// export-declaration.
17274	if (D->isExported())
17275	Diag(ExportLoc, diag::err_export_within_export);
17276
17277	CurContext->addDecl(D);
17278	PushDeclContext(S, D);
17279	D->setModuleOwnershipKind(Decl::ModuleOwnershipKind::VisibleWhenImported);
17280	return D;
17281	}
17282
17283	/// Complete the definition of an export declaration.
17284	Decl Sema::ActOnFinishExportDecl(Scope S, Decl *D, SourceLocation RBraceLoc) {
17285	auto *ED = cast<ExportDecl>(D);
17286	if (RBraceLoc.isValid())
17287	ED->setRBraceLoc(RBraceLoc);
17288
17289	// FIXME: Diagnose export of internal-linkage declaration (including
17290	// anonymous namespace).
17291
17292	PopDeclContext();
17293	return D;
17294	}
17295
17296	void Sema::ActOnPragmaRedefineExtname(IdentifierInfo* Name,
17297	IdentifierInfo* AliasName,
17298	SourceLocation PragmaLoc,
17299	SourceLocation NameLoc,
17300	SourceLocation AliasNameLoc) {
17301	NamedDecl *PrevDecl = LookupSingleName(TUScope, Name, NameLoc,
17302	LookupOrdinaryName);
17303	AsmLabelAttr *Attr =
17304	AsmLabelAttr::CreateImplicit(Context, AliasName->getName(), AliasNameLoc);
17305
17306	// If a declaration that:
17307	// 1) declares a function or a variable
17308	// 2) has external linkage
17309	// already exists, add a label attribute to it.
17310	if (PrevDecl && (isa<FunctionDecl>(PrevDecl) \|\| isa<VarDecl>(PrevDecl))) {
17311	if (isDeclExternC(PrevDecl))
17312	PrevDecl->addAttr(Attr);
17313	else
17314	Diag(PrevDecl->getLocation(), diag::warn_redefine_extname_not_applied)
17315	<< /Variable/(isa<FunctionDecl>(PrevDecl) ? 0 : 1) << PrevDecl;
17316	// Otherwise, add a label atttibute to ExtnameUndeclaredIdentifiers.
17317	} else
17318	(void)ExtnameUndeclaredIdentifiers.insert(std::make_pair(Name, Attr));
17319	}
17320
17321	void Sema::ActOnPragmaWeakID(IdentifierInfo* Name,
17322	SourceLocation PragmaLoc,
17323	SourceLocation NameLoc) {
17324	Decl *PrevDecl = LookupSingleName(TUScope, Name, NameLoc, LookupOrdinaryName);
17325
17326	if (PrevDecl) {
17327	PrevDecl->addAttr(WeakAttr::CreateImplicit(Context, PragmaLoc));
17328	} else {
17329	(void)WeakUndeclaredIdentifiers.insert(
17330	std::pair<IdentifierInfo*,WeakInfo>
17331	(Name, WeakInfo((IdentifierInfo*)nullptr, NameLoc)));
17332	}
17333	}
17334
17335	void Sema::ActOnPragmaWeakAlias(IdentifierInfo* Name,
17336	IdentifierInfo* AliasName,
17337	SourceLocation PragmaLoc,
17338	SourceLocation NameLoc,
17339	SourceLocation AliasNameLoc) {
17340	Decl *PrevDecl = LookupSingleName(TUScope, AliasName, AliasNameLoc,
17341	LookupOrdinaryName);
17342	WeakInfo W = WeakInfo(Name, NameLoc);
17343
17344	if (PrevDecl && (isa<FunctionDecl>(PrevDecl) \|\| isa<VarDecl>(PrevDecl))) {
17345	if (!PrevDecl->hasAttr<AliasAttr>())
17346	if (NamedDecl *ND = dyn_cast<NamedDecl>(PrevDecl))
17347	DeclApplyPragmaWeak(TUScope, ND, W);
17348	} else {
17349	(void)WeakUndeclaredIdentifiers.insert(
17350	std::pair<IdentifierInfo*,WeakInfo>(AliasName, W));
17351	}
17352	}
17353
17354	Decl *Sema::getObjCDeclContext() const {
17355	return (dyn_cast_or_null<ObjCContainerDecl>(CurContext));
17356	}