DeclSpec.cpp source code [clang_source_code/lib/Sema/DeclSpec.cpp]

1	//===--- DeclSpec.cpp - Declaration Specifier Semantic Analysis -----------===//
2	//
3	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4	// See https://llvm.org/LICENSE.txt for license information.
5	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6	//
7	//===----------------------------------------------------------------------===//
8	//
9	// This file implements semantic analysis for declaration specifiers.
10	//
11	//===----------------------------------------------------------------------===//
12
13	#include "clang/Sema/DeclSpec.h"
14	#include "clang/AST/ASTContext.h"
15	#include "clang/AST/DeclCXX.h"
16	#include "clang/AST/Expr.h"
17	#include "clang/AST/LocInfoType.h"
18	#include "clang/AST/TypeLoc.h"
19	#include "clang/Basic/LangOptions.h"
20	#include "clang/Basic/TargetInfo.h"
21	#include "clang/Sema/ParsedTemplate.h"
22	#include "clang/Sema/Sema.h"
23	#include "clang/Sema/SemaDiagnostic.h"
24	#include "llvm/ADT/STLExtras.h"
25	#include "llvm/ADT/SmallString.h"
26	#include <cstring>
27	using namespace clang;
28
29
30	void UnqualifiedId::setTemplateId(TemplateIdAnnotation *TemplateId) {
31	(0) . __assert_fail ("TemplateId && \"NULL template-id annotation?\"", "/home/seafit/code_projects/clang_source/clang/lib/Sema/DeclSpec.cpp", 31, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true">assert(TemplateId && "NULL template-id annotation?");
32	Kind = UnqualifiedIdKind::IK_TemplateId;
33	this->TemplateId = TemplateId;
34	StartLocation = TemplateId->TemplateNameLoc;
35	EndLocation = TemplateId->RAngleLoc;
36	}
37
38	void UnqualifiedId::setConstructorTemplateId(TemplateIdAnnotation *TemplateId) {
39	(0) . __assert_fail ("TemplateId && \"NULL template-id annotation?\"", "/home/seafit/code_projects/clang_source/clang/lib/Sema/DeclSpec.cpp", 39, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true">assert(TemplateId && "NULL template-id annotation?");
40	Kind = UnqualifiedIdKind::IK_ConstructorTemplateId;
41	this->TemplateId = TemplateId;
42	StartLocation = TemplateId->TemplateNameLoc;
43	EndLocation = TemplateId->RAngleLoc;
44	}
45
46	void CXXScopeSpec::Extend(ASTContext &Context, SourceLocation TemplateKWLoc,
47	TypeLoc TL, SourceLocation ColonColonLoc) {
48	Builder.Extend(Context, TemplateKWLoc, TL, ColonColonLoc);
49	if (Range.getBegin().isInvalid())
50	Range.setBegin(TL.getBeginLoc());
51	Range.setEnd(ColonColonLoc);
52
53	(0) . __assert_fail ("Range == Builder.getSourceRange() && \"NestedNameSpecifierLoc range computation incorrect\"", "/home/seafit/code_projects/clang_source/clang/lib/Sema/DeclSpec.cpp", 54, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true">assert(Range == Builder.getSourceRange() &&
54	(0) . __assert_fail ("Range == Builder.getSourceRange() && \"NestedNameSpecifierLoc range computation incorrect\"", "/home/seafit/code_projects/clang_source/clang/lib/Sema/DeclSpec.cpp", 54, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true"> "NestedNameSpecifierLoc range computation incorrect");
55	}
56
57	void CXXScopeSpec::Extend(ASTContext &Context, IdentifierInfo *Identifier,
58	SourceLocation IdentifierLoc,
59	SourceLocation ColonColonLoc) {
60	Builder.Extend(Context, Identifier, IdentifierLoc, ColonColonLoc);
61
62	if (Range.getBegin().isInvalid())
63	Range.setBegin(IdentifierLoc);
64	Range.setEnd(ColonColonLoc);
65
66	(0) . __assert_fail ("Range == Builder.getSourceRange() && \"NestedNameSpecifierLoc range computation incorrect\"", "/home/seafit/code_projects/clang_source/clang/lib/Sema/DeclSpec.cpp", 67, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true">assert(Range == Builder.getSourceRange() &&
67	(0) . __assert_fail ("Range == Builder.getSourceRange() && \"NestedNameSpecifierLoc range computation incorrect\"", "/home/seafit/code_projects/clang_source/clang/lib/Sema/DeclSpec.cpp", 67, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true"> "NestedNameSpecifierLoc range computation incorrect");
68	}
69
70	void CXXScopeSpec::Extend(ASTContext &Context, NamespaceDecl *Namespace,
71	SourceLocation NamespaceLoc,
72	SourceLocation ColonColonLoc) {
73	Builder.Extend(Context, Namespace, NamespaceLoc, ColonColonLoc);
74
75	if (Range.getBegin().isInvalid())
76	Range.setBegin(NamespaceLoc);
77	Range.setEnd(ColonColonLoc);
78
79	(0) . __assert_fail ("Range == Builder.getSourceRange() && \"NestedNameSpecifierLoc range computation incorrect\"", "/home/seafit/code_projects/clang_source/clang/lib/Sema/DeclSpec.cpp", 80, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true">assert(Range == Builder.getSourceRange() &&
80	(0) . __assert_fail ("Range == Builder.getSourceRange() && \"NestedNameSpecifierLoc range computation incorrect\"", "/home/seafit/code_projects/clang_source/clang/lib/Sema/DeclSpec.cpp", 80, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true"> "NestedNameSpecifierLoc range computation incorrect");
81	}
82
83	void CXXScopeSpec::Extend(ASTContext &Context, NamespaceAliasDecl *Alias,
84	SourceLocation AliasLoc,
85	SourceLocation ColonColonLoc) {
86	Builder.Extend(Context, Alias, AliasLoc, ColonColonLoc);
87
88	if (Range.getBegin().isInvalid())
89	Range.setBegin(AliasLoc);
90	Range.setEnd(ColonColonLoc);
91
92	(0) . __assert_fail ("Range == Builder.getSourceRange() && \"NestedNameSpecifierLoc range computation incorrect\"", "/home/seafit/code_projects/clang_source/clang/lib/Sema/DeclSpec.cpp", 93, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true">assert(Range == Builder.getSourceRange() &&
93	(0) . __assert_fail ("Range == Builder.getSourceRange() && \"NestedNameSpecifierLoc range computation incorrect\"", "/home/seafit/code_projects/clang_source/clang/lib/Sema/DeclSpec.cpp", 93, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true"> "NestedNameSpecifierLoc range computation incorrect");
94	}
95
96	void CXXScopeSpec::MakeGlobal(ASTContext &Context,
97	SourceLocation ColonColonLoc) {
98	Builder.MakeGlobal(Context, ColonColonLoc);
99
100	Range = SourceRange(ColonColonLoc);
101
102	(0) . __assert_fail ("Range == Builder.getSourceRange() && \"NestedNameSpecifierLoc range computation incorrect\"", "/home/seafit/code_projects/clang_source/clang/lib/Sema/DeclSpec.cpp", 103, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true">assert(Range == Builder.getSourceRange() &&
103	(0) . __assert_fail ("Range == Builder.getSourceRange() && \"NestedNameSpecifierLoc range computation incorrect\"", "/home/seafit/code_projects/clang_source/clang/lib/Sema/DeclSpec.cpp", 103, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true"> "NestedNameSpecifierLoc range computation incorrect");
104	}
105
106	void CXXScopeSpec::MakeSuper(ASTContext &Context, CXXRecordDecl *RD,
107	SourceLocation SuperLoc,
108	SourceLocation ColonColonLoc) {
109	Builder.MakeSuper(Context, RD, SuperLoc, ColonColonLoc);
110
111	Range.setBegin(SuperLoc);
112	Range.setEnd(ColonColonLoc);
113
114	(0) . __assert_fail ("Range == Builder.getSourceRange() && \"NestedNameSpecifierLoc range computation incorrect\"", "/home/seafit/code_projects/clang_source/clang/lib/Sema/DeclSpec.cpp", 115, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true">assert(Range == Builder.getSourceRange() &&
115	(0) . __assert_fail ("Range == Builder.getSourceRange() && \"NestedNameSpecifierLoc range computation incorrect\"", "/home/seafit/code_projects/clang_source/clang/lib/Sema/DeclSpec.cpp", 115, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true"> "NestedNameSpecifierLoc range computation incorrect");
116	}
117
118	void CXXScopeSpec::MakeTrivial(ASTContext &Context,
119	NestedNameSpecifier *Qualifier, SourceRange R) {
120	Builder.MakeTrivial(Context, Qualifier, R);
121	Range = R;
122	}
123
124	void CXXScopeSpec::Adopt(NestedNameSpecifierLoc Other) {
125	if (!Other) {
126	Range = SourceRange();
127	Builder.Clear();
128	return;
129	}
130
131	Range = Other.getSourceRange();
132	Builder.Adopt(Other);
133	}
134
135	SourceLocation CXXScopeSpec::getLastQualifierNameLoc() const {
136	if (!Builder.getRepresentation())
137	return SourceLocation();
138	return Builder.getTemporary().getLocalBeginLoc();
139	}
140
141	NestedNameSpecifierLoc
142	CXXScopeSpec::getWithLocInContext(ASTContext &Context) const {
143	if (!Builder.getRepresentation())
144	return NestedNameSpecifierLoc();
145
146	return Builder.getWithLocInContext(Context);
147	}
148
149	/// DeclaratorChunk::getFunction - Return a DeclaratorChunk for a function.
150	/// "TheDeclarator" is the declarator that this will be added to.
151	DeclaratorChunk DeclaratorChunk::getFunction(bool hasProto,
152	bool isAmbiguous,
153	SourceLocation LParenLoc,
154	ParamInfo *Params,
155	unsigned NumParams,
156	SourceLocation EllipsisLoc,
157	SourceLocation RParenLoc,
158	bool RefQualifierIsLvalueRef,
159	SourceLocation RefQualifierLoc,
160	SourceLocation MutableLoc,
161	ExceptionSpecificationType
162	ESpecType,
163	SourceRange ESpecRange,
164	ParsedType *Exceptions,
165	SourceRange *ExceptionRanges,
166	unsigned NumExceptions,
167	Expr *NoexceptExpr,
168	CachedTokens *ExceptionSpecTokens,
169	ArrayRef<NamedDecl*>
170	DeclsInPrototype,
171	SourceLocation LocalRangeBegin,
172	SourceLocation LocalRangeEnd,
173	Declarator &TheDeclarator,
174	TypeResult TrailingReturnType,
175	DeclSpec *MethodQualifiers) {
176	(0) . __assert_fail ("!(MethodQualifiers && MethodQualifiers->getTypeQualifiers() & DeclSpec..TQ_atomic) && \"function cannot have _Atomic qualifier\"", "/home/seafit/code_projects/clang_source/clang/lib/Sema/DeclSpec.cpp", 177, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true">assert(!(MethodQualifiers && MethodQualifiers->getTypeQualifiers() & DeclSpec::TQ_atomic) &&
177	(0) . __assert_fail ("!(MethodQualifiers && MethodQualifiers->getTypeQualifiers() & DeclSpec..TQ_atomic) && \"function cannot have _Atomic qualifier\"", "/home/seafit/code_projects/clang_source/clang/lib/Sema/DeclSpec.cpp", 177, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true"> "function cannot have _Atomic qualifier");
178
179	DeclaratorChunk I;
180	I.Kind = Function;
181	I.Loc = LocalRangeBegin;
182	I.EndLoc = LocalRangeEnd;
183	I.Fun.hasPrototype = hasProto;
184	I.Fun.isVariadic = EllipsisLoc.isValid();
185	I.Fun.isAmbiguous = isAmbiguous;
186	I.Fun.LParenLoc = LParenLoc.getRawEncoding();
187	I.Fun.EllipsisLoc = EllipsisLoc.getRawEncoding();
188	I.Fun.RParenLoc = RParenLoc.getRawEncoding();
189	I.Fun.DeleteParams = false;
190	I.Fun.NumParams = NumParams;
191	I.Fun.Params = nullptr;
192	I.Fun.RefQualifierIsLValueRef = RefQualifierIsLvalueRef;
193	I.Fun.RefQualifierLoc = RefQualifierLoc.getRawEncoding();
194	I.Fun.MutableLoc = MutableLoc.getRawEncoding();
195	I.Fun.ExceptionSpecType = ESpecType;
196	I.Fun.ExceptionSpecLocBeg = ESpecRange.getBegin().getRawEncoding();
197	I.Fun.ExceptionSpecLocEnd = ESpecRange.getEnd().getRawEncoding();
198	I.Fun.NumExceptionsOrDecls = 0;
199	I.Fun.Exceptions = nullptr;
200	I.Fun.NoexceptExpr = nullptr;
201	I.Fun.HasTrailingReturnType = TrailingReturnType.isUsable() \|\|
202	TrailingReturnType.isInvalid();
203	I.Fun.TrailingReturnType = TrailingReturnType.get();
204	I.Fun.MethodQualifiers = nullptr;
205	I.Fun.QualAttrFactory = nullptr;
206
207	if (MethodQualifiers && (MethodQualifiers->getTypeQualifiers() \|\|
208	MethodQualifiers->getAttributes().size())) {
209	auto &attrs = MethodQualifiers->getAttributes();
210	I.Fun.MethodQualifiers = new DeclSpec(attrs.getPool().getFactory());
211	MethodQualifiers->forEachCVRUQualifier(
212	[&](DeclSpec::TQ TypeQual, StringRef PrintName, SourceLocation SL) {
213	I.Fun.MethodQualifiers->SetTypeQual(TypeQual, SL);
214	});
215	I.Fun.MethodQualifiers->getAttributes().takeAllFrom(attrs);
216	I.Fun.MethodQualifiers->getAttributePool().takeAllFrom(attrs.getPool());
217	}
218
219	(0) . __assert_fail ("I.Fun.ExceptionSpecType == ESpecType && \"bitfield overflow\"", "/home/seafit/code_projects/clang_source/clang/lib/Sema/DeclSpec.cpp", 219, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true">assert(I.Fun.ExceptionSpecType == ESpecType && "bitfield overflow");
220
221	// new[] a parameter array if needed.
222	if (NumParams) {
223	// If the 'InlineParams' in Declarator is unused and big enough, put our
224	// parameter list there (in an effort to avoid new/delete traffic). If it
225	// is already used (consider a function returning a function pointer) or too
226	// small (function with too many parameters), go to the heap.
227	if (!TheDeclarator.InlineStorageUsed &&
228	NumParams <= llvm::array_lengthof(TheDeclarator.InlineParams)) {
229	I.Fun.Params = TheDeclarator.InlineParams;
230	new (I.Fun.Params) ParamInfo[NumParams];
231	I.Fun.DeleteParams = false;
232	TheDeclarator.InlineStorageUsed = true;
233	} else {
234	I.Fun.Params = new DeclaratorChunk::ParamInfo[NumParams];
235	I.Fun.DeleteParams = true;
236	}
237	for (unsigned i = 0; i < NumParams; i++)
238	I.Fun.Params[i] = std::move(Params[i]);
239	}
240
241	// Check what exception specification information we should actually store.
242	switch (ESpecType) {
243	default: break; // By default, save nothing.
244	case EST_Dynamic:
245	// new[] an exception array if needed
246	if (NumExceptions) {
247	I.Fun.NumExceptionsOrDecls = NumExceptions;
248	I.Fun.Exceptions = new DeclaratorChunk::TypeAndRange[NumExceptions];
249	for (unsigned i = 0; i != NumExceptions; ++i) {
250	I.Fun.Exceptions[i].Ty = Exceptions[i];
251	I.Fun.Exceptions[i].Range = ExceptionRanges[i];
252	}
253	}
254	break;
255
256	case EST_DependentNoexcept:
257	case EST_NoexceptFalse:
258	case EST_NoexceptTrue:
259	I.Fun.NoexceptExpr = NoexceptExpr;
260	break;
261
262	case EST_Unparsed:
263	I.Fun.ExceptionSpecTokens = ExceptionSpecTokens;
264	break;
265	}
266
267	if (!DeclsInPrototype.empty()) {
268	(0) . __assert_fail ("ESpecType == EST_None && NumExceptions == 0 && \"cannot have exception specifiers and decls in prototype\"", "/home/seafit/code_projects/clang_source/clang/lib/Sema/DeclSpec.cpp", 269, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true">assert(ESpecType == EST_None && NumExceptions == 0 &&
269	(0) . __assert_fail ("ESpecType == EST_None && NumExceptions == 0 && \"cannot have exception specifiers and decls in prototype\"", "/home/seafit/code_projects/clang_source/clang/lib/Sema/DeclSpec.cpp", 269, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true"> "cannot have exception specifiers and decls in prototype");
270	I.Fun.NumExceptionsOrDecls = DeclsInPrototype.size();
271	// Copy the array of decls into stable heap storage.
272	I.Fun.DeclsInPrototype = new NamedDecl *[DeclsInPrototype.size()];
273	for (size_t J = 0; J < DeclsInPrototype.size(); ++J)
274	I.Fun.DeclsInPrototype[J] = DeclsInPrototype[J];
275	}
276
277	return I;
278	}
279
280	void Declarator::setDecompositionBindings(
281	SourceLocation LSquareLoc,
282	ArrayRef<DecompositionDeclarator::Binding> Bindings,
283	SourceLocation RSquareLoc) {
284	(0) . __assert_fail ("!hasName() && \"declarator given multiple names!\"", "/home/seafit/code_projects/clang_source/clang/lib/Sema/DeclSpec.cpp", 284, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true">assert(!hasName() && "declarator given multiple names!");
285
286	BindingGroup.LSquareLoc = LSquareLoc;
287	BindingGroup.RSquareLoc = RSquareLoc;
288	BindingGroup.NumBindings = Bindings.size();
289	Range.setEnd(RSquareLoc);
290
291	// We're now past the identifier.
292	SetIdentifier(nullptr, LSquareLoc);
293	Name.EndLocation = RSquareLoc;
294
295	// Allocate storage for bindings and stash them away.
296	if (Bindings.size()) {
297	if (!InlineStorageUsed &&
298	Bindings.size() <= llvm::array_lengthof(InlineBindings)) {
299	BindingGroup.Bindings = InlineBindings;
300	BindingGroup.DeleteBindings = false;
301	InlineStorageUsed = true;
302	} else {
303	BindingGroup.Bindings =
304	new DecompositionDeclarator::Binding[Bindings.size()];
305	BindingGroup.DeleteBindings = true;
306	}
307	std::uninitialized_copy(Bindings.begin(), Bindings.end(),
308	BindingGroup.Bindings);
309	}
310	}
311
312	bool Declarator::isDeclarationOfFunction() const {
313	for (unsigned i = 0, i_end = DeclTypeInfo.size(); i < i_end; ++i) {
314	switch (DeclTypeInfo[i].Kind) {
315	case DeclaratorChunk::Function:
316	return true;
317	case DeclaratorChunk::Paren:
318	continue;
319	case DeclaratorChunk::Pointer:
320	case DeclaratorChunk::Reference:
321	case DeclaratorChunk::Array:
322	case DeclaratorChunk::BlockPointer:
323	case DeclaratorChunk::MemberPointer:
324	case DeclaratorChunk::Pipe:
325	return false;
326	}
327	llvm_unreachable("Invalid type chunk");
328	}
329
330	switch (DS.getTypeSpecType()) {
331	case TST_atomic:
332	case TST_auto:
333	case TST_auto_type:
334	case TST_bool:
335	case TST_char:
336	case TST_char8:
337	case TST_char16:
338	case TST_char32:
339	case TST_class:
340	case TST_decimal128:
341	case TST_decimal32:
342	case TST_decimal64:
343	case TST_double:
344	case TST_Accum:
345	case TST_Fract:
346	case TST_Float16:
347	case TST_float128:
348	case TST_enum:
349	case TST_error:
350	case TST_float:
351	case TST_half:
352	case TST_int:
353	case TST_int128:
354	case TST_struct:
355	case TST_interface:
356	case TST_union:
357	case TST_unknown_anytype:
358	case TST_unspecified:
359	case TST_void:
360	case TST_wchar:
361	#define GENERIC_IMAGE_TYPE(ImgType, Id) case TST_##ImgType##_t:
362	#include "clang/Basic/OpenCLImageTypes.def"
363	return false;
364
365	case TST_decltype_auto:
366	// This must have an initializer, so can't be a function declaration,
367	// even if the initializer has function type.
368	return false;
369
370	case TST_decltype:
371	case TST_typeofExpr:
372	if (Expr *E = DS.getRepAsExpr())
373	return E->getType()->isFunctionType();
374	return false;
375
376	case TST_underlyingType:
377	case TST_typename:
378	case TST_typeofType: {
379	QualType QT = DS.getRepAsType().get();
380	if (QT.isNull())
381	return false;
382
383	if (const LocInfoType *LIT = dyn_cast<LocInfoType>(QT))
384	QT = LIT->getType();
385
386	if (QT.isNull())
387	return false;
388
389	return QT->isFunctionType();
390	}
391	}
392
393	llvm_unreachable("Invalid TypeSpecType!");
394	}
395
396	bool Declarator::isStaticMember() {
397	assert(getContext() == DeclaratorContext::MemberContext);
398	return getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_static \|\|
399	(getName().Kind == UnqualifiedIdKind::IK_OperatorFunctionId &&
400	CXXMethodDecl::isStaticOverloadedOperator(
401	getName().OperatorFunctionId.Operator));
402	}
403
404	bool Declarator::isCtorOrDtor() {
405	return (getName().getKind() == UnqualifiedIdKind::IK_ConstructorName) \|\|
406	(getName().getKind() == UnqualifiedIdKind::IK_DestructorName);
407	}
408
409	void DeclSpec::forEachCVRUQualifier(
410	llvm::function_ref<void(TQ, StringRef, SourceLocation)> Handle) {
411	if (TypeQualifiers & TQ_const)
412	Handle(TQ_const, "const", TQ_constLoc);
413	if (TypeQualifiers & TQ_volatile)
414	Handle(TQ_volatile, "volatile", TQ_volatileLoc);
415	if (TypeQualifiers & TQ_restrict)
416	Handle(TQ_restrict, "restrict", TQ_restrictLoc);
417	if (TypeQualifiers & TQ_unaligned)
418	Handle(TQ_unaligned, "unaligned", TQ_unalignedLoc);
419	}
420
421	void DeclSpec::forEachQualifier(
422	llvm::function_ref<void(TQ, StringRef, SourceLocation)> Handle) {
423	forEachCVRUQualifier(Handle);
424	// FIXME: Add code below to iterate through the attributes and call Handle.
425	}
426
427	bool DeclSpec::hasTagDefinition() const {
428	if (!TypeSpecOwned)
429	return false;
430	return cast<TagDecl>(getRepAsDecl())->isCompleteDefinition();
431	}
432
433	/// getParsedSpecifiers - Return a bitmask of which flavors of specifiers this
434	/// declaration specifier includes.
435	///
436	unsigned DeclSpec::getParsedSpecifiers() const {
437	unsigned Res = 0;
438	if (StorageClassSpec != SCS_unspecified \|\|
439	ThreadStorageClassSpec != TSCS_unspecified)
440	Res \|= PQ_StorageClassSpecifier;
441
442	if (TypeQualifiers != TQ_unspecified)
443	Res \|= PQ_TypeQualifier;
444
445	if (hasTypeSpecifier())
446	Res \|= PQ_TypeSpecifier;
447
448	if (FS_inline_specified \|\| FS_virtual_specified \|\| FS_explicit_specified \|\|
449	FS_noreturn_specified \|\| FS_forceinline_specified)
450	Res \|= PQ_FunctionSpecifier;
451	return Res;
452	}
453
454	template <class T> static bool BadSpecifier(T TNew, T TPrev,
455	const char *&PrevSpec,
456	unsigned &DiagID,
457	bool IsExtension = true) {
458	PrevSpec = DeclSpec::getSpecifierName(TPrev);
459	if (TNew != TPrev)
460	DiagID = diag::err_invalid_decl_spec_combination;
461	else
462	DiagID = IsExtension ? diag::ext_warn_duplicate_declspec :
463	diag::warn_duplicate_declspec;
464	return true;
465	}
466
467	const char *DeclSpec::getSpecifierName(DeclSpec::SCS S) {
468	switch (S) {
469	case DeclSpec::SCS_unspecified: return "unspecified";
470	case DeclSpec::SCS_typedef: return "typedef";
471	case DeclSpec::SCS_extern: return "extern";
472	case DeclSpec::SCS_static: return "static";
473	case DeclSpec::SCS_auto: return "auto";
474	case DeclSpec::SCS_register: return "register";
475	case DeclSpec::SCS_private_extern: return "__private_extern__";
476	case DeclSpec::SCS_mutable: return "mutable";
477	}
478	llvm_unreachable("Unknown typespec!");
479	}
480
481	const char *DeclSpec::getSpecifierName(DeclSpec::TSCS S) {
482	switch (S) {
483	case DeclSpec::TSCS_unspecified: return "unspecified";
484	case DeclSpec::TSCS___thread: return "__thread";
485	case DeclSpec::TSCS_thread_local: return "thread_local";
486	case DeclSpec::TSCS__Thread_local: return "_Thread_local";
487	}
488	llvm_unreachable("Unknown typespec!");
489	}
490
491	const char *DeclSpec::getSpecifierName(TSW W) {
492	switch (W) {
493	case TSW_unspecified: return "unspecified";
494	case TSW_short: return "short";
495	case TSW_long: return "long";
496	case TSW_longlong: return "long long";
497	}
498	llvm_unreachable("Unknown typespec!");
499	}
500
501	const char *DeclSpec::getSpecifierName(TSC C) {
502	switch (C) {
503	case TSC_unspecified: return "unspecified";
504	case TSC_imaginary: return "imaginary";
505	case TSC_complex: return "complex";
506	}
507	llvm_unreachable("Unknown typespec!");
508	}
509
510
511	const char *DeclSpec::getSpecifierName(TSS S) {
512	switch (S) {
513	case TSS_unspecified: return "unspecified";
514	case TSS_signed: return "signed";
515	case TSS_unsigned: return "unsigned";
516	}
517	llvm_unreachable("Unknown typespec!");
518	}
519
520	const char *DeclSpec::getSpecifierName(DeclSpec::TST T,
521	const PrintingPolicy &Policy) {
522	switch (T) {
523	case DeclSpec::TST_unspecified: return "unspecified";
524	case DeclSpec::TST_void: return "void";
525	case DeclSpec::TST_char: return "char";
526	case DeclSpec::TST_wchar: return Policy.MSWChar ? "__wchar_t" : "wchar_t";
527	case DeclSpec::TST_char8: return "char8_t";
528	case DeclSpec::TST_char16: return "char16_t";
529	case DeclSpec::TST_char32: return "char32_t";
530	case DeclSpec::TST_int: return "int";
531	case DeclSpec::TST_int128: return "__int128";
532	case DeclSpec::TST_half: return "half";
533	case DeclSpec::TST_float: return "float";
534	case DeclSpec::TST_double: return "double";
535	case DeclSpec::TST_accum: return "_Accum";
536	case DeclSpec::TST_fract: return "_Fract";
537	case DeclSpec::TST_float16: return "_Float16";
538	case DeclSpec::TST_float128: return "__float128";
539	case DeclSpec::TST_bool: return Policy.Bool ? "bool" : "_Bool";
540	case DeclSpec::TST_decimal32: return "_Decimal32";
541	case DeclSpec::TST_decimal64: return "_Decimal64";
542	case DeclSpec::TST_decimal128: return "_Decimal128";
543	case DeclSpec::TST_enum: return "enum";
544	case DeclSpec::TST_class: return "class";
545	case DeclSpec::TST_union: return "union";
546	case DeclSpec::TST_struct: return "struct";
547	case DeclSpec::TST_interface: return "__interface";
548	case DeclSpec::TST_typename: return "type-name";
549	case DeclSpec::TST_typeofType:
550	case DeclSpec::TST_typeofExpr: return "typeof";
551	case DeclSpec::TST_auto: return "auto";
552	case DeclSpec::TST_auto_type: return "__auto_type";
553	case DeclSpec::TST_decltype: return "(decltype)";
554	case DeclSpec::TST_decltype_auto: return "decltype(auto)";
555	case DeclSpec::TST_underlyingType: return "__underlying_type";
556	case DeclSpec::TST_unknown_anytype: return "__unknown_anytype";
557	case DeclSpec::TST_atomic: return "_Atomic";
558	#define GENERIC_IMAGE_TYPE(ImgType, Id) \
559	case DeclSpec::TST_##ImgType##_t: \
560	return #ImgType "_t";
561	#include "clang/Basic/OpenCLImageTypes.def"
562	case DeclSpec::TST_error: return "(error)";
563	}
564	llvm_unreachable("Unknown typespec!");
565	}
566
567	const char *DeclSpec::getSpecifierName(TQ T) {
568	switch (T) {
569	case DeclSpec::TQ_unspecified: return "unspecified";
570	case DeclSpec::TQ_const: return "const";
571	case DeclSpec::TQ_restrict: return "restrict";
572	case DeclSpec::TQ_volatile: return "volatile";
573	case DeclSpec::TQ_atomic: return "_Atomic";
574	case DeclSpec::TQ_unaligned: return "__unaligned";
575	}
576	llvm_unreachable("Unknown typespec!");
577	}
578
579	bool DeclSpec::SetStorageClassSpec(Sema &S, SCS SC, SourceLocation Loc,
580	const char *&PrevSpec,
581	unsigned &DiagID,
582	const PrintingPolicy &Policy) {
583	// OpenCL v1.1 s6.8g: "The extern, static, auto and register storage-class
584	// specifiers are not supported.
585	// It seems sensible to prohibit private_extern too
586	// The cl_clang_storage_class_specifiers extension enables support for
587	// these storage-class specifiers.
588	// OpenCL v1.2 s6.8 changes this to "The auto and register storage-class
589	// specifiers are not supported."
590	// OpenCL C++ v1.0 s2.9 restricts register.
591	if (S.getLangOpts().OpenCL &&
592	!S.getOpenCLOptions().isEnabled("cl_clang_storage_class_specifiers")) {
593	switch (SC) {
594	case SCS_extern:
595	case SCS_private_extern:
596	case SCS_static:
597	if (S.getLangOpts().OpenCLVersion < 120 &&
598	!S.getLangOpts().OpenCLCPlusPlus) {
599	DiagID = diag::err_opencl_unknown_type_specifier;
600	PrevSpec = getSpecifierName(SC);
601	return true;
602	}
603	break;
604	case SCS_auto:
605	case SCS_register:
606	DiagID = diag::err_opencl_unknown_type_specifier;
607	PrevSpec = getSpecifierName(SC);
608	return true;
609	default:
610	break;
611	}
612	}
613
614	if (StorageClassSpec != SCS_unspecified) {
615	// Maybe this is an attempt to use C++11 'auto' outside of C++11 mode.
616	bool isInvalid = true;
617	if (TypeSpecType == TST_unspecified && S.getLangOpts().CPlusPlus) {
618	if (SC == SCS_auto)
619	return SetTypeSpecType(TST_auto, Loc, PrevSpec, DiagID, Policy);
620	if (StorageClassSpec == SCS_auto) {
621	isInvalid = SetTypeSpecType(TST_auto, StorageClassSpecLoc,
622	PrevSpec, DiagID, Policy);
623	TST recovery failed") ? static_cast (0) . __assert_fail ("!isInvalid && \"auto SCS -> TST recovery failed\"", "/home/seafit/code_projects/clang_source/clang/lib/Sema/DeclSpec.cpp", 623, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true">assert(!isInvalid && "auto SCS -> TST recovery failed");
624	}
625	}
626
627	// Changing storage class is allowed only if the previous one
628	// was the 'extern' that is part of a linkage specification and
629	// the new storage class is 'typedef'.
630	if (isInvalid &&
631	!(SCS_extern_in_linkage_spec &&
632	StorageClassSpec == SCS_extern &&
633	SC == SCS_typedef))
634	return BadSpecifier(SC, (SCS)StorageClassSpec, PrevSpec, DiagID);
635	}
636	StorageClassSpec = SC;
637	StorageClassSpecLoc = Loc;
638	(0) . __assert_fail ("(unsigned)SC == StorageClassSpec && \"SCS constants overflow bitfield\"", "/home/seafit/code_projects/clang_source/clang/lib/Sema/DeclSpec.cpp", 638, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true">assert((unsigned)SC == StorageClassSpec && "SCS constants overflow bitfield");
639	return false;
640	}
641
642	bool DeclSpec::SetStorageClassSpecThread(TSCS TSC, SourceLocation Loc,
643	const char *&PrevSpec,
644	unsigned &DiagID) {
645	if (ThreadStorageClassSpec != TSCS_unspecified)
646	return BadSpecifier(TSC, (TSCS)ThreadStorageClassSpec, PrevSpec, DiagID);
647
648	ThreadStorageClassSpec = TSC;
649	ThreadStorageClassSpecLoc = Loc;
650	return false;
651	}
652
653	/// These methods set the specified attribute of the DeclSpec, but return true
654	/// and ignore the request if invalid (e.g. "extern" then "auto" is
655	/// specified).
656	bool DeclSpec::SetTypeSpecWidth(TSW W, SourceLocation Loc,
657	const char *&PrevSpec,
658	unsigned &DiagID,
659	const PrintingPolicy &Policy) {
660	// Overwrite TSWRange.Begin only if TypeSpecWidth was unspecified, so that
661	// for 'long long' we will keep the source location of the first 'long'.
662	if (TypeSpecWidth == TSW_unspecified)
663	TSWRange.setBegin(Loc);
664	// Allow turning long -> long long.
665	else if (W != TSW_longlong \|\| TypeSpecWidth != TSW_long)
666	return BadSpecifier(W, (TSW)TypeSpecWidth, PrevSpec, DiagID);
667	TypeSpecWidth = W;
668	// Remember location of the last 'long'
669	TSWRange.setEnd(Loc);
670	return false;
671	}
672
673	bool DeclSpec::SetTypeSpecComplex(TSC C, SourceLocation Loc,
674	const char *&PrevSpec,
675	unsigned &DiagID) {
676	if (TypeSpecComplex != TSC_unspecified)
677	return BadSpecifier(C, (TSC)TypeSpecComplex, PrevSpec, DiagID);
678	TypeSpecComplex = C;
679	TSCLoc = Loc;
680	return false;
681	}
682
683	bool DeclSpec::SetTypeSpecSign(TSS S, SourceLocation Loc,
684	const char *&PrevSpec,
685	unsigned &DiagID) {
686	if (TypeSpecSign != TSS_unspecified)
687	return BadSpecifier(S, (TSS)TypeSpecSign, PrevSpec, DiagID);
688	TypeSpecSign = S;
689	TSSLoc = Loc;
690	return false;
691	}
692
693	bool DeclSpec::SetTypeSpecType(TST T, SourceLocation Loc,
694	const char *&PrevSpec,
695	unsigned &DiagID,
696	ParsedType Rep,
697	const PrintingPolicy &Policy) {
698	return SetTypeSpecType(T, Loc, Loc, PrevSpec, DiagID, Rep, Policy);
699	}
700
701	bool DeclSpec::SetTypeSpecType(TST T, SourceLocation TagKwLoc,
702	SourceLocation TagNameLoc,
703	const char *&PrevSpec,
704	unsigned &DiagID,
705	ParsedType Rep,
706	const PrintingPolicy &Policy) {
707	(0) . __assert_fail ("isTypeRep(T) && \"T does not store a type\"", "/home/seafit/code_projects/clang_source/clang/lib/Sema/DeclSpec.cpp", 707, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true">assert(isTypeRep(T) && "T does not store a type");
708	(0) . __assert_fail ("Rep && \"no type provided!\"", "/home/seafit/code_projects/clang_source/clang/lib/Sema/DeclSpec.cpp", 708, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true">assert(Rep && "no type provided!");
709	if (TypeSpecType != TST_unspecified) {
710	PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType, Policy);
711	DiagID = diag::err_invalid_decl_spec_combination;
712	return true;
713	}
714	TypeSpecType = T;
715	TypeRep = Rep;
716	TSTLoc = TagKwLoc;
717	TSTNameLoc = TagNameLoc;
718	TypeSpecOwned = false;
719	return false;
720	}
721
722	bool DeclSpec::SetTypeSpecType(TST T, SourceLocation Loc,
723	const char *&PrevSpec,
724	unsigned &DiagID,
725	Expr *Rep,
726	const PrintingPolicy &Policy) {
727	(0) . __assert_fail ("isExprRep(T) && \"T does not store an expr\"", "/home/seafit/code_projects/clang_source/clang/lib/Sema/DeclSpec.cpp", 727, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true">assert(isExprRep(T) && "T does not store an expr");
728	(0) . __assert_fail ("Rep && \"no expression provided!\"", "/home/seafit/code_projects/clang_source/clang/lib/Sema/DeclSpec.cpp", 728, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true">assert(Rep && "no expression provided!");
729	if (TypeSpecType != TST_unspecified) {
730	PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType, Policy);
731	DiagID = diag::err_invalid_decl_spec_combination;
732	return true;
733	}
734	TypeSpecType = T;
735	ExprRep = Rep;
736	TSTLoc = Loc;
737	TSTNameLoc = Loc;
738	TypeSpecOwned = false;
739	return false;
740	}
741
742	bool DeclSpec::SetTypeSpecType(TST T, SourceLocation Loc,
743	const char *&PrevSpec,
744	unsigned &DiagID,
745	Decl *Rep, bool Owned,
746	const PrintingPolicy &Policy) {
747	return SetTypeSpecType(T, Loc, Loc, PrevSpec, DiagID, Rep, Owned, Policy);
748	}
749
750	bool DeclSpec::SetTypeSpecType(TST T, SourceLocation TagKwLoc,
751	SourceLocation TagNameLoc,
752	const char *&PrevSpec,
753	unsigned &DiagID,
754	Decl *Rep, bool Owned,
755	const PrintingPolicy &Policy) {
756	(0) . __assert_fail ("isDeclRep(T) && \"T does not store a decl\"", "/home/seafit/code_projects/clang_source/clang/lib/Sema/DeclSpec.cpp", 756, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true">assert(isDeclRep(T) && "T does not store a decl");
757	// Unlike the other cases, we don't assert that we actually get a decl.
758
759	if (TypeSpecType != TST_unspecified) {
760	PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType, Policy);
761	DiagID = diag::err_invalid_decl_spec_combination;
762	return true;
763	}
764	TypeSpecType = T;
765	DeclRep = Rep;
766	TSTLoc = TagKwLoc;
767	TSTNameLoc = TagNameLoc;
768	TypeSpecOwned = Owned && Rep != nullptr;
769	return false;
770	}
771
772	bool DeclSpec::SetTypeSpecType(TST T, SourceLocation Loc,
773	const char *&PrevSpec,
774	unsigned &DiagID,
775	const PrintingPolicy &Policy) {
776	(0) . __assert_fail ("!isDeclRep(T) && !isTypeRep(T) && !isExprRep(T) && \"rep required for these type-spec kinds!\"", "/home/seafit/code_projects/clang_source/clang/lib/Sema/DeclSpec.cpp", 777, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true">assert(!isDeclRep(T) && !isTypeRep(T) && !isExprRep(T) &&
777	(0) . __assert_fail ("!isDeclRep(T) && !isTypeRep(T) && !isExprRep(T) && \"rep required for these type-spec kinds!\"", "/home/seafit/code_projects/clang_source/clang/lib/Sema/DeclSpec.cpp", 777, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true"> "rep required for these type-spec kinds!");
778	if (TypeSpecType != TST_unspecified) {
779	PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType, Policy);
780	DiagID = diag::err_invalid_decl_spec_combination;
781	return true;
782	}
783	TSTLoc = Loc;
784	TSTNameLoc = Loc;
785	if (TypeAltiVecVector && (T == TST_bool) && !TypeAltiVecBool) {
786	TypeAltiVecBool = true;
787	return false;
788	}
789	TypeSpecType = T;
790	TypeSpecOwned = false;
791	return false;
792	}
793
794	bool DeclSpec::SetTypeSpecSat(SourceLocation Loc, const char *&PrevSpec,
795	unsigned &DiagID) {
796	// Cannot set twice
797	if (TypeSpecSat) {
798	DiagID = diag::warn_duplicate_declspec;
799	PrevSpec = "_Sat";
800	return true;
801	}
802	TypeSpecSat = true;
803	TSSatLoc = Loc;
804	return false;
805	}
806
807	bool DeclSpec::SetTypeAltiVecVector(bool isAltiVecVector, SourceLocation Loc,
808	const char *&PrevSpec, unsigned &DiagID,
809	const PrintingPolicy &Policy) {
810	if (TypeSpecType != TST_unspecified) {
811	PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType, Policy);
812	DiagID = diag::err_invalid_vector_decl_spec_combination;
813	return true;
814	}
815	TypeAltiVecVector = isAltiVecVector;
816	AltiVecLoc = Loc;
817	return false;
818	}
819
820	bool DeclSpec::SetTypePipe(bool isPipe, SourceLocation Loc,
821	const char *&PrevSpec, unsigned &DiagID,
822	const PrintingPolicy &Policy) {
823
824	if (TypeSpecType != TST_unspecified) {
825	PrevSpec = DeclSpec::getSpecifierName((TST)TypeSpecType, Policy);
826	DiagID = diag::err_invalid_decl_spec_combination;
827	return true;
828	}
829
830	if (isPipe) {
831	TypeSpecPipe = TSP_pipe;
832	}
833	return false;
834	}
835
836	bool DeclSpec::SetTypeAltiVecPixel(bool isAltiVecPixel, SourceLocation Loc,
837	const char *&PrevSpec, unsigned &DiagID,
838	const PrintingPolicy &Policy) {
839	if (!TypeAltiVecVector \|\| TypeAltiVecPixel \|\|
840	(TypeSpecType != TST_unspecified)) {
841	PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType, Policy);
842	DiagID = diag::err_invalid_pixel_decl_spec_combination;
843	return true;
844	}
845	TypeAltiVecPixel = isAltiVecPixel;
846	TSTLoc = Loc;
847	TSTNameLoc = Loc;
848	return false;
849	}
850
851	bool DeclSpec::SetTypeAltiVecBool(bool isAltiVecBool, SourceLocation Loc,
852	const char *&PrevSpec, unsigned &DiagID,
853	const PrintingPolicy &Policy) {
854	if (!TypeAltiVecVector \|\| TypeAltiVecBool \|\|
855	(TypeSpecType != TST_unspecified)) {
856	PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType, Policy);
857	DiagID = diag::err_invalid_vector_bool_decl_spec;
858	return true;
859	}
860	TypeAltiVecBool = isAltiVecBool;
861	TSTLoc = Loc;
862	TSTNameLoc = Loc;
863	return false;
864	}
865
866	bool DeclSpec::SetTypeSpecError() {
867	TypeSpecType = TST_error;
868	TypeSpecOwned = false;
869	TSTLoc = SourceLocation();
870	TSTNameLoc = SourceLocation();
871	return false;
872	}
873
874	bool DeclSpec::SetTypeQual(TQ T, SourceLocation Loc, const char *&PrevSpec,
875	unsigned &DiagID, const LangOptions &Lang) {
876	// Duplicates are permitted in C99 onwards, but are not permitted in C89 or
877	// C++. However, since this is likely not what the user intended, we will
878	// always warn. We do not need to set the qualifier's location since we
879	// already have it.
880	if (TypeQualifiers & T) {
881	bool IsExtension = true;
882	if (Lang.C99)
883	IsExtension = false;
884	return BadSpecifier(T, T, PrevSpec, DiagID, IsExtension);
885	}
886
887	return SetTypeQual(T, Loc);
888	}
889
890	bool DeclSpec::SetTypeQual(TQ T, SourceLocation Loc) {
891	TypeQualifiers \|= T;
892
893	switch (T) {
894	case TQ_unspecified: break;
895	case TQ_const: TQ_constLoc = Loc; return false;
896	case TQ_restrict: TQ_restrictLoc = Loc; return false;
897	case TQ_volatile: TQ_volatileLoc = Loc; return false;
898	case TQ_unaligned: TQ_unalignedLoc = Loc; return false;
899	case TQ_atomic: TQ_atomicLoc = Loc; return false;
900	}
901
902	llvm_unreachable("Unknown type qualifier!");
903	}
904
905	bool DeclSpec::setFunctionSpecInline(SourceLocation Loc, const char *&PrevSpec,
906	unsigned &DiagID) {
907	// 'inline inline' is ok. However, since this is likely not what the user
908	// intended, we will always warn, similar to duplicates of type qualifiers.
909	if (FS_inline_specified) {
910	DiagID = diag::warn_duplicate_declspec;
911	PrevSpec = "inline";
912	return true;
913	}
914	FS_inline_specified = true;
915	FS_inlineLoc = Loc;
916	return false;
917	}
918
919	bool DeclSpec::setFunctionSpecForceInline(SourceLocation Loc, const char *&PrevSpec,
920	unsigned &DiagID) {
921	if (FS_forceinline_specified) {
922	DiagID = diag::warn_duplicate_declspec;
923	PrevSpec = "__forceinline";
924	return true;
925	}
926	FS_forceinline_specified = true;
927	FS_forceinlineLoc = Loc;
928	return false;
929	}
930
931	bool DeclSpec::setFunctionSpecVirtual(SourceLocation Loc,
932	const char *&PrevSpec,
933	unsigned &DiagID) {
934	// 'virtual virtual' is ok, but warn as this is likely not what the user
935	// intended.
936	if (FS_virtual_specified) {
937	DiagID = diag::warn_duplicate_declspec;
938	PrevSpec = "virtual";
939	return true;
940	}
941	FS_virtual_specified = true;
942	FS_virtualLoc = Loc;
943	return false;
944	}
945
946	bool DeclSpec::setFunctionSpecExplicit(SourceLocation Loc,
947	const char *&PrevSpec,
948	unsigned &DiagID) {
949	// 'explicit explicit' is ok, but warn as this is likely not what the user
950	// intended.
951	if (FS_explicit_specified) {
952	DiagID = diag::warn_duplicate_declspec;
953	PrevSpec = "explicit";
954	return true;
955	}
956	FS_explicit_specified = true;
957	FS_explicitLoc = Loc;
958	return false;
959	}
960
961	bool DeclSpec::setFunctionSpecNoreturn(SourceLocation Loc,
962	const char *&PrevSpec,
963	unsigned &DiagID) {
964	// '_Noreturn _Noreturn' is ok, but warn as this is likely not what the user
965	// intended.
966	if (FS_noreturn_specified) {
967	DiagID = diag::warn_duplicate_declspec;
968	PrevSpec = "_Noreturn";
969	return true;
970	}
971	FS_noreturn_specified = true;
972	FS_noreturnLoc = Loc;
973	return false;
974	}
975
976	bool DeclSpec::SetFriendSpec(SourceLocation Loc, const char *&PrevSpec,
977	unsigned &DiagID) {
978	if (Friend_specified) {
979	PrevSpec = "friend";
980	// Keep the later location, so that we can later diagnose ill-formed
981	// declarations like 'friend class X friend;'. Per [class.friend]p3,
982	// 'friend' must be the first token in a friend declaration that is
983	// not a function declaration.
984	FriendLoc = Loc;
985	DiagID = diag::warn_duplicate_declspec;
986	return true;
987	}
988
989	Friend_specified = true;
990	FriendLoc = Loc;
991	return false;
992	}
993
994	bool DeclSpec::setModulePrivateSpec(SourceLocation Loc, const char *&PrevSpec,
995	unsigned &DiagID) {
996	if (isModulePrivateSpecified()) {
997	PrevSpec = "__module_private__";
998	DiagID = diag::ext_warn_duplicate_declspec;
999	return true;
1000	}
1001
1002	ModulePrivateLoc = Loc;
1003	return false;
1004	}
1005
1006	bool DeclSpec::SetConstexprSpec(SourceLocation Loc, const char *&PrevSpec,
1007	unsigned &DiagID) {
1008	// 'constexpr constexpr' is ok, but warn as this is likely not what the user
1009	// intended.
1010	if (Constexpr_specified) {
1011	DiagID = diag::warn_duplicate_declspec;
1012	PrevSpec = "constexpr";
1013	return true;
1014	}
1015	Constexpr_specified = true;
1016	ConstexprLoc = Loc;
1017	return false;
1018	}
1019
1020	void DeclSpec::SaveWrittenBuiltinSpecs() {
1021	writtenBS.Sign = getTypeSpecSign();
1022	writtenBS.Width = getTypeSpecWidth();
1023	writtenBS.Type = getTypeSpecType();
1024	// Search the list of attributes for the presence of a mode attribute.
1025	writtenBS.ModeAttr = getAttributes().hasAttribute(ParsedAttr::AT_Mode);
1026	}
1027
1028	/// Finish - This does final analysis of the declspec, rejecting things like
1029	/// "_Imaginary" (lacking an FP type). This returns a diagnostic to issue or
1030	/// diag::NUM_DIAGNOSTICS if there is no error. After calling this method,
1031	/// DeclSpec is guaranteed self-consistent, even if an error occurred.
1032	void DeclSpec::Finish(Sema &S, const PrintingPolicy &Policy) {
1033	// Before possibly changing their values, save specs as written.
1034	SaveWrittenBuiltinSpecs();
1035
1036	// Check the type specifier components first.
1037
1038	// If decltype(auto) is used, no other type specifiers are permitted.
1039	if (TypeSpecType == TST_decltype_auto &&
1040	(TypeSpecWidth != TSW_unspecified \|\|
1041	TypeSpecComplex != TSC_unspecified \|\|
1042	TypeSpecSign != TSS_unspecified \|\|
1043	TypeAltiVecVector \|\| TypeAltiVecPixel \|\| TypeAltiVecBool \|\|
1044	TypeQualifiers)) {
1045	const unsigned NumLocs = 9;
1046	SourceLocation ExtraLocs[NumLocs] = {
1047	TSWRange.getBegin(), TSCLoc, TSSLoc,
1048	AltiVecLoc, TQ_constLoc, TQ_restrictLoc,
1049	TQ_volatileLoc, TQ_atomicLoc, TQ_unalignedLoc};
1050	FixItHint Hints[NumLocs];
1051	SourceLocation FirstLoc;
1052	for (unsigned I = 0; I != NumLocs; ++I) {
1053	if (ExtraLocs[I].isValid()) {
1054	if (FirstLoc.isInvalid() \|\|
1055	S.getSourceManager().isBeforeInTranslationUnit(ExtraLocs[I],
1056	FirstLoc))
1057	FirstLoc = ExtraLocs[I];
1058	Hints[I] = FixItHint::CreateRemoval(ExtraLocs[I]);
1059	}
1060	}
1061	TypeSpecWidth = TSW_unspecified;
1062	TypeSpecComplex = TSC_unspecified;
1063	TypeSpecSign = TSS_unspecified;
1064	TypeAltiVecVector = TypeAltiVecPixel = TypeAltiVecBool = false;
1065	TypeQualifiers = 0;
1066	S.Diag(TSTLoc, diag::err_decltype_auto_cannot_be_combined)
1067	<< Hints[0] << Hints[1] << Hints[2] << Hints[3]
1068	<< Hints[4] << Hints[5] << Hints[6] << Hints[7];
1069	}
1070
1071	// Validate and finalize AltiVec vector declspec.
1072	if (TypeAltiVecVector) {
1073	if (TypeAltiVecBool) {
1074	// Sign specifiers are not allowed with vector bool. (PIM 2.1)
1075	if (TypeSpecSign != TSS_unspecified) {
1076	S.Diag(TSSLoc, diag::err_invalid_vector_bool_decl_spec)
1077	<< getSpecifierName((TSS)TypeSpecSign);
1078	}
1079
1080	// Only char/int are valid with vector bool. (PIM 2.1)
1081	if (((TypeSpecType != TST_unspecified) && (TypeSpecType != TST_char) &&
1082	(TypeSpecType != TST_int)) \|\| TypeAltiVecPixel) {
1083	S.Diag(TSTLoc, diag::err_invalid_vector_bool_decl_spec)
1084	<< (TypeAltiVecPixel ? "__pixel" :
1085	getSpecifierName((TST)TypeSpecType, Policy));
1086	}
1087
1088	// Only 'short' and 'long long' are valid with vector bool. (PIM 2.1)
1089	if ((TypeSpecWidth != TSW_unspecified) && (TypeSpecWidth != TSW_short) &&
1090	(TypeSpecWidth != TSW_longlong))
1091	S.Diag(TSWRange.getBegin(), diag::err_invalid_vector_bool_decl_spec)
1092	<< getSpecifierName((TSW)TypeSpecWidth);
1093
1094	// vector bool long long requires VSX support or ZVector.
1095	if ((TypeSpecWidth == TSW_longlong) &&
1096	(!S.Context.getTargetInfo().hasFeature("vsx")) &&
1097	(!S.Context.getTargetInfo().hasFeature("power8-vector")) &&
1098	!S.getLangOpts().ZVector)
1099	S.Diag(TSTLoc, diag::err_invalid_vector_long_long_decl_spec);
1100
1101	// Elements of vector bool are interpreted as unsigned. (PIM 2.1)
1102	if ((TypeSpecType == TST_char) \|\| (TypeSpecType == TST_int) \|\|
1103	(TypeSpecWidth != TSW_unspecified))
1104	TypeSpecSign = TSS_unsigned;
1105	} else if (TypeSpecType == TST_double) {
1106	// vector long double and vector long long double are never allowed.
1107	// vector double is OK for Power7 and later, and ZVector.
1108	if (TypeSpecWidth == TSW_long \|\| TypeSpecWidth == TSW_longlong)
1109	S.Diag(TSWRange.getBegin(),
1110	diag::err_invalid_vector_long_double_decl_spec);
1111	else if (!S.Context.getTargetInfo().hasFeature("vsx") &&
1112	!S.getLangOpts().ZVector)
1113	S.Diag(TSTLoc, diag::err_invalid_vector_double_decl_spec);
1114	} else if (TypeSpecType == TST_float) {
1115	// vector float is unsupported for ZVector unless we have the
1116	// vector-enhancements facility 1 (ISA revision 12).
1117	if (S.getLangOpts().ZVector &&
1118	!S.Context.getTargetInfo().hasFeature("arch12"))
1119	S.Diag(TSTLoc, diag::err_invalid_vector_float_decl_spec);
1120	} else if (TypeSpecWidth == TSW_long) {
1121	// vector long is unsupported for ZVector and deprecated for AltiVec.
1122	if (S.getLangOpts().ZVector)
1123	S.Diag(TSWRange.getBegin(), diag::err_invalid_vector_long_decl_spec);
1124	else
1125	S.Diag(TSWRange.getBegin(),
1126	diag::warn_vector_long_decl_spec_combination)
1127	<< getSpecifierName((TST)TypeSpecType, Policy);
1128	}
1129
1130	if (TypeAltiVecPixel) {
1131	//TODO: perform validation
1132	TypeSpecType = TST_int;
1133	TypeSpecSign = TSS_unsigned;
1134	TypeSpecWidth = TSW_short;
1135	TypeSpecOwned = false;
1136	}
1137	}
1138
1139	bool IsFixedPointType =
1140	TypeSpecType == TST_accum \|\| TypeSpecType == TST_fract;
1141
1142	// signed/unsigned are only valid with int/char/wchar_t/_Accum.
1143	if (TypeSpecSign != TSS_unspecified) {
1144	if (TypeSpecType == TST_unspecified)
1145	TypeSpecType = TST_int; // unsigned -> unsigned int, signed -> signed int.
1146	else if (TypeSpecType != TST_int && TypeSpecType != TST_int128 &&
1147	TypeSpecType != TST_char && TypeSpecType != TST_wchar &&
1148	!IsFixedPointType) {
1149	S.Diag(TSSLoc, diag::err_invalid_sign_spec)
1150	<< getSpecifierName((TST)TypeSpecType, Policy);
1151	// signed double -> double.
1152	TypeSpecSign = TSS_unspecified;
1153	}
1154	}
1155
1156	// Validate the width of the type.
1157	switch (TypeSpecWidth) {
1158	case TSW_unspecified: break;
1159	case TSW_short: // short int
1160	case TSW_longlong: // long long int
1161	if (TypeSpecType == TST_unspecified)
1162	TypeSpecType = TST_int; // short -> short int, long long -> long long int.
1163	else if (!(TypeSpecType == TST_int \|\|
1164	(IsFixedPointType && TypeSpecWidth != TSW_longlong))) {
1165	S.Diag(TSWRange.getBegin(), diag::err_invalid_width_spec)
1166	<< (int)TypeSpecWidth << getSpecifierName((TST)TypeSpecType, Policy);
1167	TypeSpecType = TST_int;
1168	TypeSpecSat = false;
1169	TypeSpecOwned = false;
1170	}
1171	break;
1172	case TSW_long: // long double, long int
1173	if (TypeSpecType == TST_unspecified)
1174	TypeSpecType = TST_int; // long -> long int.
1175	else if (TypeSpecType != TST_int && TypeSpecType != TST_double &&
1176	!IsFixedPointType) {
1177	S.Diag(TSWRange.getBegin(), diag::err_invalid_width_spec)
1178	<< (int)TypeSpecWidth << getSpecifierName((TST)TypeSpecType, Policy);
1179	TypeSpecType = TST_int;
1180	TypeSpecSat = false;
1181	TypeSpecOwned = false;
1182	}
1183	break;
1184	}
1185
1186	// TODO: if the implementation does not implement _Complex or _Imaginary,
1187	// disallow their use. Need information about the backend.
1188	if (TypeSpecComplex != TSC_unspecified) {
1189	if (TypeSpecType == TST_unspecified) {
1190	S.Diag(TSCLoc, diag::ext_plain_complex)
1191	<< FixItHint::CreateInsertion(
1192	S.getLocForEndOfToken(getTypeSpecComplexLoc()),
1193	" double");
1194	TypeSpecType = TST_double; // _Complex -> _Complex double.
1195	} else if (TypeSpecType == TST_int \|\| TypeSpecType == TST_char) {
1196	// Note that this intentionally doesn't include _Complex _Bool.
1197	if (!S.getLangOpts().CPlusPlus)
1198	S.Diag(TSTLoc, diag::ext_integer_complex);
1199	} else if (TypeSpecType != TST_float && TypeSpecType != TST_double) {
1200	S.Diag(TSCLoc, diag::err_invalid_complex_spec)
1201	<< getSpecifierName((TST)TypeSpecType, Policy);
1202	TypeSpecComplex = TSC_unspecified;
1203	}
1204	}
1205
1206	// C11 6.7.1/3, C++11 [dcl.stc]p1, GNU TLS: __thread, thread_local and
1207	// _Thread_local can only appear with the 'static' and 'extern' storage class
1208	// specifiers. We also allow __private_extern__ as an extension.
1209	if (ThreadStorageClassSpec != TSCS_unspecified) {
1210	switch (StorageClassSpec) {
1211	case SCS_unspecified:
1212	case SCS_extern:
1213	case SCS_private_extern:
1214	case SCS_static:
1215	break;
1216	default:
1217	if (S.getSourceManager().isBeforeInTranslationUnit(
1218	getThreadStorageClassSpecLoc(), getStorageClassSpecLoc()))
1219	S.Diag(getStorageClassSpecLoc(),
1220	diag::err_invalid_decl_spec_combination)
1221	<< DeclSpec::getSpecifierName(getThreadStorageClassSpec())
1222	<< SourceRange(getThreadStorageClassSpecLoc());
1223	else
1224	S.Diag(getThreadStorageClassSpecLoc(),
1225	diag::err_invalid_decl_spec_combination)
1226	<< DeclSpec::getSpecifierName(getStorageClassSpec())
1227	<< SourceRange(getStorageClassSpecLoc());
1228	// Discard the thread storage class specifier to recover.
1229	ThreadStorageClassSpec = TSCS_unspecified;
1230	ThreadStorageClassSpecLoc = SourceLocation();
1231	}
1232	}
1233
1234	// If no type specifier was provided and we're parsing a language where
1235	// the type specifier is not optional, but we got 'auto' as a storage
1236	// class specifier, then assume this is an attempt to use C++0x's 'auto'
1237	// type specifier.
1238	if (S.getLangOpts().CPlusPlus &&
1239	TypeSpecType == TST_unspecified && StorageClassSpec == SCS_auto) {
1240	TypeSpecType = TST_auto;
1241	StorageClassSpec = SCS_unspecified;
1242	TSTLoc = TSTNameLoc = StorageClassSpecLoc;
1243	StorageClassSpecLoc = SourceLocation();
1244	}
1245	// Diagnose if we've recovered from an ill-formed 'auto' storage class
1246	// specifier in a pre-C++11 dialect of C++.
1247	if (!S.getLangOpts().CPlusPlus11 && TypeSpecType == TST_auto)
1248	S.Diag(TSTLoc, diag::ext_auto_type_specifier);
1249	if (S.getLangOpts().CPlusPlus && !S.getLangOpts().CPlusPlus11 &&
1250	StorageClassSpec == SCS_auto)
1251	S.Diag(StorageClassSpecLoc, diag::warn_auto_storage_class)
1252	<< FixItHint::CreateRemoval(StorageClassSpecLoc);
1253	if (TypeSpecType == TST_char8)
1254	S.Diag(TSTLoc, diag::warn_cxx17_compat_unicode_type);
1255	else if (TypeSpecType == TST_char16 \|\| TypeSpecType == TST_char32)
1256	S.Diag(TSTLoc, diag::warn_cxx98_compat_unicode_type)
1257	<< (TypeSpecType == TST_char16 ? "char16_t" : "char32_t");
1258	if (Constexpr_specified)
1259	S.Diag(ConstexprLoc, diag::warn_cxx98_compat_constexpr);
1260
1261	// C++ [class.friend]p6:
1262	// No storage-class-specifier shall appear in the decl-specifier-seq
1263	// of a friend declaration.
1264	if (isFriendSpecified() &&
1265	(getStorageClassSpec() \|\| getThreadStorageClassSpec())) {
1266	SmallString<32> SpecName;
1267	SourceLocation SCLoc;
1268	FixItHint StorageHint, ThreadHint;
1269
1270	if (DeclSpec::SCS SC = getStorageClassSpec()) {
1271	SpecName = getSpecifierName(SC);
1272	SCLoc = getStorageClassSpecLoc();
1273	StorageHint = FixItHint::CreateRemoval(SCLoc);
1274	}
1275
1276	if (DeclSpec::TSCS TSC = getThreadStorageClassSpec()) {
1277	if (!SpecName.empty()) SpecName += " ";
1278	SpecName += getSpecifierName(TSC);
1279	SCLoc = getThreadStorageClassSpecLoc();
1280	ThreadHint = FixItHint::CreateRemoval(SCLoc);
1281	}
1282
1283	S.Diag(SCLoc, diag::err_friend_decl_spec)
1284	<< SpecName << StorageHint << ThreadHint;
1285
1286	ClearStorageClassSpecs();
1287	}
1288
1289	// C++11 [dcl.fct.spec]p5:
1290	// The virtual specifier shall be used only in the initial
1291	// declaration of a non-static class member function;
1292	// C++11 [dcl.fct.spec]p6:
1293	// The explicit specifier shall be used only in the declaration of
1294	// a constructor or conversion function within its class
1295	// definition;
1296	if (isFriendSpecified() && (isVirtualSpecified() \|\| isExplicitSpecified())) {
1297	StringRef Keyword;
1298	SourceLocation SCLoc;
1299
1300	if (isVirtualSpecified()) {
1301	Keyword = "virtual";
1302	SCLoc = getVirtualSpecLoc();
1303	} else {
1304	Keyword = "explicit";
1305	SCLoc = getExplicitSpecLoc();
1306	}
1307
1308	FixItHint Hint = FixItHint::CreateRemoval(SCLoc);
1309	S.Diag(SCLoc, diag::err_friend_decl_spec)
1310	<< Keyword << Hint;
1311
1312	FS_virtual_specified = FS_explicit_specified = false;
1313	FS_virtualLoc = FS_explicitLoc = SourceLocation();
1314	}
1315
1316	assert(!TypeSpecOwned \|\| isDeclRep((TST) TypeSpecType));
1317
1318	// Okay, now we can infer the real type.
1319
1320	// TODO: return "auto function" and other bad things based on the real type.
1321
1322	// 'data definition has no type or storage class'?
1323	}
1324
1325	bool DeclSpec::isMissingDeclaratorOk() {
1326	TST tst = getTypeSpecType();
1327	return isDeclRep(tst) && getRepAsDecl() != nullptr &&
1328	StorageClassSpec != DeclSpec::SCS_typedef;
1329	}
1330
1331	void UnqualifiedId::setOperatorFunctionId(SourceLocation OperatorLoc,
1332	OverloadedOperatorKind Op,
1333	SourceLocation SymbolLocations[3]) {
1334	Kind = UnqualifiedIdKind::IK_OperatorFunctionId;
1335	StartLocation = OperatorLoc;
1336	EndLocation = OperatorLoc;
1337	OperatorFunctionId.Operator = Op;
1338	for (unsigned I = 0; I != 3; ++I) {
1339	OperatorFunctionId.SymbolLocations[I] = SymbolLocations[I].getRawEncoding();
1340
1341	if (SymbolLocations[I].isValid())
1342	EndLocation = SymbolLocations[I];
1343	}
1344	}
1345
1346	bool VirtSpecifiers::SetSpecifier(Specifier VS, SourceLocation Loc,
1347	const char *&PrevSpec) {
1348	if (!FirstLocation.isValid())
1349	FirstLocation = Loc;
1350	LastLocation = Loc;
1351	LastSpecifier = VS;
1352
1353	if (Specifiers & VS) {
1354	PrevSpec = getSpecifierName(VS);
1355	return true;
1356	}
1357
1358	Specifiers \|= VS;
1359
1360	switch (VS) {
1361	default: llvm_unreachable("Unknown specifier!");
1362	case VS_Override: VS_overrideLoc = Loc; break;
1363	case VS_GNU_Final:
1364	case VS_Sealed:
1365	case VS_Final: VS_finalLoc = Loc; break;
1366	}
1367
1368	return false;
1369	}
1370
1371	const char *VirtSpecifiers::getSpecifierName(Specifier VS) {
1372	switch (VS) {
1373	default: llvm_unreachable("Unknown specifier");
1374	case VS_Override: return "override";
1375	case VS_Final: return "final";
1376	case VS_GNU_Final: return "__final";
1377	case VS_Sealed: return "sealed";
1378	}
1379	}
1380

clang::UnqualifiedId::setTemplateId

clang::UnqualifiedId::setConstructorTemplateId

clang::CXXScopeSpec::Extend

clang::CXXScopeSpec::MakeGlobal

clang::CXXScopeSpec::MakeSuper

clang::CXXScopeSpec::MakeTrivial

clang::CXXScopeSpec::Adopt

clang::CXXScopeSpec::getLastQualifierNameLoc

clang::CXXScopeSpec::getWithLocInContext

clang::DeclaratorChunk::getFunction

clang::Declarator::setDecompositionBindings

clang::Declarator::isDeclarationOfFunction

clang::Declarator::isStaticMember

clang::Declarator::isCtorOrDtor

Clang Project