1 //===--- DeclSpec.cpp - Declaration Specifier Semantic Analysis -----------===//
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
7 //===----------------------------------------------------------------------===//
9 // This file implements semantic analysis for declaration specifiers.
11 //===----------------------------------------------------------------------===//
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"
27 using namespace clang;
30 void UnqualifiedId::setTemplateId(TemplateIdAnnotation *TemplateId) {
31 assert(TemplateId && "NULL template-id annotation?");
32 Kind = UnqualifiedIdKind::IK_TemplateId;
33 this->TemplateId = TemplateId;
34 StartLocation = TemplateId->TemplateNameLoc;
35 EndLocation = TemplateId->RAngleLoc;
38 void UnqualifiedId::setConstructorTemplateId(TemplateIdAnnotation *TemplateId) {
39 assert(TemplateId && "NULL template-id annotation?");
40 Kind = UnqualifiedIdKind::IK_ConstructorTemplateId;
41 this->TemplateId = TemplateId;
42 StartLocation = TemplateId->TemplateNameLoc;
43 EndLocation = TemplateId->RAngleLoc;
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);
53 assert(Range == Builder.getSourceRange() &&
54 "NestedNameSpecifierLoc range computation incorrect");
57 void CXXScopeSpec::Extend(ASTContext &Context, IdentifierInfo *Identifier,
58 SourceLocation IdentifierLoc,
59 SourceLocation ColonColonLoc) {
60 Builder.Extend(Context, Identifier, IdentifierLoc, ColonColonLoc);
62 if (Range.getBegin().isInvalid())
63 Range.setBegin(IdentifierLoc);
64 Range.setEnd(ColonColonLoc);
66 assert(Range == Builder.getSourceRange() &&
67 "NestedNameSpecifierLoc range computation incorrect");
70 void CXXScopeSpec::Extend(ASTContext &Context, NamespaceDecl *Namespace,
71 SourceLocation NamespaceLoc,
72 SourceLocation ColonColonLoc) {
73 Builder.Extend(Context, Namespace, NamespaceLoc, ColonColonLoc);
75 if (Range.getBegin().isInvalid())
76 Range.setBegin(NamespaceLoc);
77 Range.setEnd(ColonColonLoc);
79 assert(Range == Builder.getSourceRange() &&
80 "NestedNameSpecifierLoc range computation incorrect");
83 void CXXScopeSpec::Extend(ASTContext &Context, NamespaceAliasDecl *Alias,
84 SourceLocation AliasLoc,
85 SourceLocation ColonColonLoc) {
86 Builder.Extend(Context, Alias, AliasLoc, ColonColonLoc);
88 if (Range.getBegin().isInvalid())
89 Range.setBegin(AliasLoc);
90 Range.setEnd(ColonColonLoc);
92 assert(Range == Builder.getSourceRange() &&
93 "NestedNameSpecifierLoc range computation incorrect");
96 void CXXScopeSpec::MakeGlobal(ASTContext &Context,
97 SourceLocation ColonColonLoc) {
98 Builder.MakeGlobal(Context, ColonColonLoc);
100 Range = SourceRange(ColonColonLoc);
102 assert(Range == Builder.getSourceRange() &&
103 "NestedNameSpecifierLoc range computation incorrect");
106 void CXXScopeSpec::MakeSuper(ASTContext &Context, CXXRecordDecl *RD,
107 SourceLocation SuperLoc,
108 SourceLocation ColonColonLoc) {
109 Builder.MakeSuper(Context, RD, SuperLoc, ColonColonLoc);
111 Range.setBegin(SuperLoc);
112 Range.setEnd(ColonColonLoc);
114 assert(Range == Builder.getSourceRange() &&
115 "NestedNameSpecifierLoc range computation incorrect");
118 void CXXScopeSpec::MakeTrivial(ASTContext &Context,
119 NestedNameSpecifier *Qualifier, SourceRange R) {
120 Builder.MakeTrivial(Context, Qualifier, R);
124 void CXXScopeSpec::Adopt(NestedNameSpecifierLoc Other) {
126 Range = SourceRange();
131 Range = Other.getSourceRange();
132 Builder.Adopt(Other);
135 SourceLocation CXXScopeSpec::getLastQualifierNameLoc() const {
136 if (!Builder.getRepresentation())
137 return SourceLocation();
138 return Builder.getTemporary().getLocalBeginLoc();
141 NestedNameSpecifierLoc
142 CXXScopeSpec::getWithLocInContext(ASTContext &Context) const {
143 if (!Builder.getRepresentation())
144 return NestedNameSpecifierLoc();
146 return Builder.getWithLocInContext(Context);
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,
153 SourceLocation LParenLoc,
156 SourceLocation EllipsisLoc,
157 SourceLocation RParenLoc,
158 bool RefQualifierIsLvalueRef,
159 SourceLocation RefQualifierLoc,
160 SourceLocation MutableLoc,
161 ExceptionSpecificationType
163 SourceRange ESpecRange,
164 ParsedType *Exceptions,
165 SourceRange *ExceptionRanges,
166 unsigned NumExceptions,
168 CachedTokens *ExceptionSpecTokens,
171 SourceLocation LocalRangeBegin,
172 SourceLocation LocalRangeEnd,
173 Declarator &TheDeclarator,
174 TypeResult TrailingReturnType,
175 DeclSpec *MethodQualifiers) {
176 assert(!(MethodQualifiers && MethodQualifiers->getTypeQualifiers() & DeclSpec::TQ_atomic) &&
177 "function cannot have _Atomic qualifier");
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;
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);
215 I.Fun.MethodQualifiers->getAttributes().takeAllFrom(attrs);
216 I.Fun.MethodQualifiers->getAttributePool().takeAllFrom(attrs.getPool());
219 assert(I.Fun.ExceptionSpecType == ESpecType && "bitfield overflow");
221 // new[] a parameter array if needed.
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;
234 I.Fun.Params = new DeclaratorChunk::ParamInfo[NumParams];
235 I.Fun.DeleteParams = true;
237 for (unsigned i = 0; i < NumParams; i++)
238 I.Fun.Params[i] = std::move(Params[i]);
241 // Check what exception specification information we should actually store.
243 default: break; // By default, save nothing.
245 // new[] an exception array if needed
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];
256 case EST_DependentNoexcept:
257 case EST_NoexceptFalse:
258 case EST_NoexceptTrue:
259 I.Fun.NoexceptExpr = NoexceptExpr;
263 I.Fun.ExceptionSpecTokens = ExceptionSpecTokens;
267 if (!DeclsInPrototype.empty()) {
268 assert(ESpecType == EST_None && NumExceptions == 0 &&
269 "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];
280 void Declarator::setDecompositionBindings(
281 SourceLocation LSquareLoc,
282 ArrayRef<DecompositionDeclarator::Binding> Bindings,
283 SourceLocation RSquareLoc) {
284 assert(!hasName() && "declarator given multiple names!");
286 BindingGroup.LSquareLoc = LSquareLoc;
287 BindingGroup.RSquareLoc = RSquareLoc;
288 BindingGroup.NumBindings = Bindings.size();
289 Range.setEnd(RSquareLoc);
291 // We're now past the identifier.
292 SetIdentifier(nullptr, LSquareLoc);
293 Name.EndLocation = RSquareLoc;
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;
303 BindingGroup.Bindings =
304 new DecompositionDeclarator::Binding[Bindings.size()];
305 BindingGroup.DeleteBindings = true;
307 std::uninitialized_copy(Bindings.begin(), Bindings.end(),
308 BindingGroup.Bindings);
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:
317 case DeclaratorChunk::Paren:
319 case DeclaratorChunk::Pointer:
320 case DeclaratorChunk::Reference:
321 case DeclaratorChunk::Array:
322 case DeclaratorChunk::BlockPointer:
323 case DeclaratorChunk::MemberPointer:
324 case DeclaratorChunk::Pipe:
327 llvm_unreachable("Invalid type chunk");
330 switch (DS.getTypeSpecType()) {
357 case TST_unknown_anytype:
358 case TST_unspecified:
361 #define GENERIC_IMAGE_TYPE(ImgType, Id) case TST_##ImgType##_t:
362 #include "clang/Basic/OpenCLImageTypes.def"
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.
372 if (Expr *E = DS.getRepAsExpr())
373 return E->getType()->isFunctionType();
376 case TST_underlyingType:
378 case TST_typeofType: {
379 QualType QT = DS.getRepAsType().get();
383 if (const LocInfoType *LIT = dyn_cast<LocInfoType>(QT))
389 return QT->isFunctionType();
393 llvm_unreachable("Invalid TypeSpecType!");
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));
404 bool Declarator::isCtorOrDtor() {
405 return (getName().getKind() == UnqualifiedIdKind::IK_ConstructorName) ||
406 (getName().getKind() == UnqualifiedIdKind::IK_DestructorName);
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);
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.
427 bool DeclSpec::hasTagDefinition() const {
430 return cast<TagDecl>(getRepAsDecl())->isCompleteDefinition();
433 /// getParsedSpecifiers - Return a bitmask of which flavors of specifiers this
434 /// declaration specifier includes.
436 unsigned DeclSpec::getParsedSpecifiers() const {
438 if (StorageClassSpec != SCS_unspecified ||
439 ThreadStorageClassSpec != TSCS_unspecified)
440 Res |= PQ_StorageClassSpecifier;
442 if (TypeQualifiers != TQ_unspecified)
443 Res |= PQ_TypeQualifier;
445 if (hasTypeSpecifier())
446 Res |= PQ_TypeSpecifier;
448 if (FS_inline_specified || FS_virtual_specified || hasExplicitSpecifier() ||
449 FS_noreturn_specified || FS_forceinline_specified)
450 Res |= PQ_FunctionSpecifier;
454 template <class T> static bool BadSpecifier(T TNew, T TPrev,
455 const char *&PrevSpec,
457 bool IsExtension = true) {
458 PrevSpec = DeclSpec::getSpecifierName(TPrev);
460 DiagID = diag::err_invalid_decl_spec_combination;
462 DiagID = IsExtension ? diag::ext_warn_duplicate_declspec :
463 diag::warn_duplicate_declspec;
467 const char *DeclSpec::getSpecifierName(DeclSpec::SCS 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";
478 llvm_unreachable("Unknown typespec!");
481 const char *DeclSpec::getSpecifierName(DeclSpec::TSCS 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";
488 llvm_unreachable("Unknown typespec!");
491 const char *DeclSpec::getSpecifierName(TSW 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";
498 llvm_unreachable("Unknown typespec!");
501 const char *DeclSpec::getSpecifierName(TSC C) {
503 case TSC_unspecified: return "unspecified";
504 case TSC_imaginary: return "imaginary";
505 case TSC_complex: return "complex";
507 llvm_unreachable("Unknown typespec!");
511 const char *DeclSpec::getSpecifierName(TSS S) {
513 case TSS_unspecified: return "unspecified";
514 case TSS_signed: return "signed";
515 case TSS_unsigned: return "unsigned";
517 llvm_unreachable("Unknown typespec!");
520 const char *DeclSpec::getSpecifierName(DeclSpec::TST T,
521 const PrintingPolicy &Policy) {
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)";
564 llvm_unreachable("Unknown typespec!");
567 const char *DeclSpec::getSpecifierName(ConstexprSpecKind C) {
569 case CSK_unspecified: return "unspecified";
570 case CSK_constexpr: return "constexpr";
571 case CSK_consteval: return "consteval";
573 llvm_unreachable("Unknown ConstexprSpecKind");
576 const char *DeclSpec::getSpecifierName(TQ T) {
578 case DeclSpec::TQ_unspecified: return "unspecified";
579 case DeclSpec::TQ_const: return "const";
580 case DeclSpec::TQ_restrict: return "restrict";
581 case DeclSpec::TQ_volatile: return "volatile";
582 case DeclSpec::TQ_atomic: return "_Atomic";
583 case DeclSpec::TQ_unaligned: return "__unaligned";
585 llvm_unreachable("Unknown typespec!");
588 bool DeclSpec::SetStorageClassSpec(Sema &S, SCS SC, SourceLocation Loc,
589 const char *&PrevSpec,
591 const PrintingPolicy &Policy) {
592 // OpenCL v1.1 s6.8g: "The extern, static, auto and register storage-class
593 // specifiers are not supported.
594 // It seems sensible to prohibit private_extern too
595 // The cl_clang_storage_class_specifiers extension enables support for
596 // these storage-class specifiers.
597 // OpenCL v1.2 s6.8 changes this to "The auto and register storage-class
598 // specifiers are not supported."
599 if (S.getLangOpts().OpenCL &&
600 !S.getOpenCLOptions().isEnabled("cl_clang_storage_class_specifiers")) {
603 case SCS_private_extern:
605 if (S.getLangOpts().OpenCLVersion < 120 &&
606 !S.getLangOpts().OpenCLCPlusPlus) {
607 DiagID = diag::err_opencl_unknown_type_specifier;
608 PrevSpec = getSpecifierName(SC);
614 DiagID = diag::err_opencl_unknown_type_specifier;
615 PrevSpec = getSpecifierName(SC);
622 if (StorageClassSpec != SCS_unspecified) {
623 // Maybe this is an attempt to use C++11 'auto' outside of C++11 mode.
624 bool isInvalid = true;
625 if (TypeSpecType == TST_unspecified && S.getLangOpts().CPlusPlus) {
627 return SetTypeSpecType(TST_auto, Loc, PrevSpec, DiagID, Policy);
628 if (StorageClassSpec == SCS_auto) {
629 isInvalid = SetTypeSpecType(TST_auto, StorageClassSpecLoc,
630 PrevSpec, DiagID, Policy);
631 assert(!isInvalid && "auto SCS -> TST recovery failed");
635 // Changing storage class is allowed only if the previous one
636 // was the 'extern' that is part of a linkage specification and
637 // the new storage class is 'typedef'.
639 !(SCS_extern_in_linkage_spec &&
640 StorageClassSpec == SCS_extern &&
642 return BadSpecifier(SC, (SCS)StorageClassSpec, PrevSpec, DiagID);
644 StorageClassSpec = SC;
645 StorageClassSpecLoc = Loc;
646 assert((unsigned)SC == StorageClassSpec && "SCS constants overflow bitfield");
650 bool DeclSpec::SetStorageClassSpecThread(TSCS TSC, SourceLocation Loc,
651 const char *&PrevSpec,
653 if (ThreadStorageClassSpec != TSCS_unspecified)
654 return BadSpecifier(TSC, (TSCS)ThreadStorageClassSpec, PrevSpec, DiagID);
656 ThreadStorageClassSpec = TSC;
657 ThreadStorageClassSpecLoc = Loc;
661 /// These methods set the specified attribute of the DeclSpec, but return true
662 /// and ignore the request if invalid (e.g. "extern" then "auto" is
664 bool DeclSpec::SetTypeSpecWidth(TSW W, SourceLocation Loc,
665 const char *&PrevSpec,
667 const PrintingPolicy &Policy) {
668 // Overwrite TSWRange.Begin only if TypeSpecWidth was unspecified, so that
669 // for 'long long' we will keep the source location of the first 'long'.
670 if (TypeSpecWidth == TSW_unspecified)
671 TSWRange.setBegin(Loc);
672 // Allow turning long -> long long.
673 else if (W != TSW_longlong || TypeSpecWidth != TSW_long)
674 return BadSpecifier(W, (TSW)TypeSpecWidth, PrevSpec, DiagID);
676 // Remember location of the last 'long'
677 TSWRange.setEnd(Loc);
681 bool DeclSpec::SetTypeSpecComplex(TSC C, SourceLocation Loc,
682 const char *&PrevSpec,
684 if (TypeSpecComplex != TSC_unspecified)
685 return BadSpecifier(C, (TSC)TypeSpecComplex, PrevSpec, DiagID);
691 bool DeclSpec::SetTypeSpecSign(TSS S, SourceLocation Loc,
692 const char *&PrevSpec,
694 if (TypeSpecSign != TSS_unspecified)
695 return BadSpecifier(S, (TSS)TypeSpecSign, PrevSpec, DiagID);
701 bool DeclSpec::SetTypeSpecType(TST T, SourceLocation Loc,
702 const char *&PrevSpec,
705 const PrintingPolicy &Policy) {
706 return SetTypeSpecType(T, Loc, Loc, PrevSpec, DiagID, Rep, Policy);
709 bool DeclSpec::SetTypeSpecType(TST T, SourceLocation TagKwLoc,
710 SourceLocation TagNameLoc,
711 const char *&PrevSpec,
714 const PrintingPolicy &Policy) {
715 assert(isTypeRep(T) && "T does not store a type");
716 assert(Rep && "no type provided!");
717 if (TypeSpecType == TST_error)
719 if (TypeSpecType != TST_unspecified) {
720 PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType, Policy);
721 DiagID = diag::err_invalid_decl_spec_combination;
727 TSTNameLoc = TagNameLoc;
728 TypeSpecOwned = false;
732 bool DeclSpec::SetTypeSpecType(TST T, SourceLocation Loc,
733 const char *&PrevSpec,
736 const PrintingPolicy &Policy) {
737 assert(isExprRep(T) && "T does not store an expr");
738 assert(Rep && "no expression provided!");
739 if (TypeSpecType == TST_error)
741 if (TypeSpecType != TST_unspecified) {
742 PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType, Policy);
743 DiagID = diag::err_invalid_decl_spec_combination;
750 TypeSpecOwned = false;
754 bool DeclSpec::SetTypeSpecType(TST T, SourceLocation Loc,
755 const char *&PrevSpec,
757 Decl *Rep, bool Owned,
758 const PrintingPolicy &Policy) {
759 return SetTypeSpecType(T, Loc, Loc, PrevSpec, DiagID, Rep, Owned, Policy);
762 bool DeclSpec::SetTypeSpecType(TST T, SourceLocation TagKwLoc,
763 SourceLocation TagNameLoc,
764 const char *&PrevSpec,
766 Decl *Rep, bool Owned,
767 const PrintingPolicy &Policy) {
768 assert(isDeclRep(T) && "T does not store a decl");
769 // Unlike the other cases, we don't assert that we actually get a decl.
771 if (TypeSpecType == TST_error)
773 if (TypeSpecType != TST_unspecified) {
774 PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType, Policy);
775 DiagID = diag::err_invalid_decl_spec_combination;
781 TSTNameLoc = TagNameLoc;
782 TypeSpecOwned = Owned && Rep != nullptr;
786 bool DeclSpec::SetTypeSpecType(TST T, SourceLocation Loc,
787 const char *&PrevSpec,
789 const PrintingPolicy &Policy) {
790 assert(!isDeclRep(T) && !isTypeRep(T) && !isExprRep(T) &&
791 "rep required for these type-spec kinds!");
792 if (TypeSpecType == TST_error)
794 if (TypeSpecType != TST_unspecified) {
795 PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType, Policy);
796 DiagID = diag::err_invalid_decl_spec_combination;
801 if (TypeAltiVecVector && (T == TST_bool) && !TypeAltiVecBool) {
802 TypeAltiVecBool = true;
806 TypeSpecOwned = false;
810 bool DeclSpec::SetTypeSpecSat(SourceLocation Loc, const char *&PrevSpec,
814 DiagID = diag::warn_duplicate_declspec;
823 bool DeclSpec::SetTypeAltiVecVector(bool isAltiVecVector, SourceLocation Loc,
824 const char *&PrevSpec, unsigned &DiagID,
825 const PrintingPolicy &Policy) {
826 if (TypeSpecType == TST_error)
828 if (TypeSpecType != TST_unspecified) {
829 PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType, Policy);
830 DiagID = diag::err_invalid_vector_decl_spec_combination;
833 TypeAltiVecVector = isAltiVecVector;
838 bool DeclSpec::SetTypePipe(bool isPipe, SourceLocation Loc,
839 const char *&PrevSpec, unsigned &DiagID,
840 const PrintingPolicy &Policy) {
841 if (TypeSpecType == TST_error)
843 if (TypeSpecType != TST_unspecified) {
844 PrevSpec = DeclSpec::getSpecifierName((TST)TypeSpecType, Policy);
845 DiagID = diag::err_invalid_decl_spec_combination;
850 TypeSpecPipe = TSP_pipe;
855 bool DeclSpec::SetTypeAltiVecPixel(bool isAltiVecPixel, SourceLocation Loc,
856 const char *&PrevSpec, unsigned &DiagID,
857 const PrintingPolicy &Policy) {
858 if (TypeSpecType == TST_error)
860 if (!TypeAltiVecVector || TypeAltiVecPixel ||
861 (TypeSpecType != TST_unspecified)) {
862 PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType, Policy);
863 DiagID = diag::err_invalid_pixel_decl_spec_combination;
866 TypeAltiVecPixel = isAltiVecPixel;
872 bool DeclSpec::SetTypeAltiVecBool(bool isAltiVecBool, SourceLocation Loc,
873 const char *&PrevSpec, unsigned &DiagID,
874 const PrintingPolicy &Policy) {
875 if (TypeSpecType == TST_error)
877 if (!TypeAltiVecVector || TypeAltiVecBool ||
878 (TypeSpecType != TST_unspecified)) {
879 PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType, Policy);
880 DiagID = diag::err_invalid_vector_bool_decl_spec;
883 TypeAltiVecBool = isAltiVecBool;
889 bool DeclSpec::SetTypeSpecError() {
890 TypeSpecType = TST_error;
891 TypeSpecOwned = false;
892 TSTLoc = SourceLocation();
893 TSTNameLoc = SourceLocation();
897 bool DeclSpec::SetTypeQual(TQ T, SourceLocation Loc, const char *&PrevSpec,
898 unsigned &DiagID, const LangOptions &Lang) {
899 // Duplicates are permitted in C99 onwards, but are not permitted in C89 or
900 // C++. However, since this is likely not what the user intended, we will
901 // always warn. We do not need to set the qualifier's location since we
903 if (TypeQualifiers & T) {
904 bool IsExtension = true;
907 return BadSpecifier(T, T, PrevSpec, DiagID, IsExtension);
910 return SetTypeQual(T, Loc);
913 bool DeclSpec::SetTypeQual(TQ T, SourceLocation Loc) {
917 case TQ_unspecified: break;
918 case TQ_const: TQ_constLoc = Loc; return false;
919 case TQ_restrict: TQ_restrictLoc = Loc; return false;
920 case TQ_volatile: TQ_volatileLoc = Loc; return false;
921 case TQ_unaligned: TQ_unalignedLoc = Loc; return false;
922 case TQ_atomic: TQ_atomicLoc = Loc; return false;
925 llvm_unreachable("Unknown type qualifier!");
928 bool DeclSpec::setFunctionSpecInline(SourceLocation Loc, const char *&PrevSpec,
930 // 'inline inline' is ok. However, since this is likely not what the user
931 // intended, we will always warn, similar to duplicates of type qualifiers.
932 if (FS_inline_specified) {
933 DiagID = diag::warn_duplicate_declspec;
937 FS_inline_specified = true;
942 bool DeclSpec::setFunctionSpecForceInline(SourceLocation Loc, const char *&PrevSpec,
944 if (FS_forceinline_specified) {
945 DiagID = diag::warn_duplicate_declspec;
946 PrevSpec = "__forceinline";
949 FS_forceinline_specified = true;
950 FS_forceinlineLoc = Loc;
954 bool DeclSpec::setFunctionSpecVirtual(SourceLocation Loc,
955 const char *&PrevSpec,
957 // 'virtual virtual' is ok, but warn as this is likely not what the user
959 if (FS_virtual_specified) {
960 DiagID = diag::warn_duplicate_declspec;
961 PrevSpec = "virtual";
964 FS_virtual_specified = true;
969 bool DeclSpec::setFunctionSpecExplicit(SourceLocation Loc,
970 const char *&PrevSpec, unsigned &DiagID,
971 ExplicitSpecifier ExplicitSpec,
972 SourceLocation CloseParenLoc) {
973 assert((ExplicitSpec.getKind() == ExplicitSpecKind::ResolvedTrue ||
974 ExplicitSpec.getExpr()) &&
975 "invalid ExplicitSpecifier");
976 // 'explicit explicit' is ok, but warn as this is likely not what the user
978 if (hasExplicitSpecifier()) {
979 DiagID = (ExplicitSpec.getExpr() || FS_explicit_specifier.getExpr())
980 ? diag::err_duplicate_declspec
981 : diag::ext_warn_duplicate_declspec;
982 PrevSpec = "explicit";
985 FS_explicit_specifier = ExplicitSpec;
986 FS_explicitLoc = Loc;
987 FS_explicitCloseParenLoc = CloseParenLoc;
991 bool DeclSpec::setFunctionSpecNoreturn(SourceLocation Loc,
992 const char *&PrevSpec,
994 // '_Noreturn _Noreturn' is ok, but warn as this is likely not what the user
996 if (FS_noreturn_specified) {
997 DiagID = diag::warn_duplicate_declspec;
998 PrevSpec = "_Noreturn";
1001 FS_noreturn_specified = true;
1002 FS_noreturnLoc = Loc;
1006 bool DeclSpec::SetFriendSpec(SourceLocation Loc, const char *&PrevSpec,
1008 if (Friend_specified) {
1009 PrevSpec = "friend";
1010 // Keep the later location, so that we can later diagnose ill-formed
1011 // declarations like 'friend class X friend;'. Per [class.friend]p3,
1012 // 'friend' must be the first token in a friend declaration that is
1013 // not a function declaration.
1015 DiagID = diag::warn_duplicate_declspec;
1019 Friend_specified = true;
1024 bool DeclSpec::setModulePrivateSpec(SourceLocation Loc, const char *&PrevSpec,
1026 if (isModulePrivateSpecified()) {
1027 PrevSpec = "__module_private__";
1028 DiagID = diag::ext_warn_duplicate_declspec;
1032 ModulePrivateLoc = Loc;
1036 bool DeclSpec::SetConstexprSpec(ConstexprSpecKind ConstexprKind,
1037 SourceLocation Loc, const char *&PrevSpec,
1039 if (getConstexprSpecifier() != CSK_unspecified) {
1040 if (getConstexprSpecifier() == CSK_consteval || ConstexprKind == CSK_consteval)
1041 return BadSpecifier(ConstexprKind, getConstexprSpecifier(), PrevSpec, DiagID);
1042 DiagID = diag::warn_duplicate_declspec;
1043 PrevSpec = "constexpr";
1046 ConstexprSpecifier = ConstexprKind;
1051 void DeclSpec::SaveWrittenBuiltinSpecs() {
1052 writtenBS.Sign = getTypeSpecSign();
1053 writtenBS.Width = getTypeSpecWidth();
1054 writtenBS.Type = getTypeSpecType();
1055 // Search the list of attributes for the presence of a mode attribute.
1056 writtenBS.ModeAttr = getAttributes().hasAttribute(ParsedAttr::AT_Mode);
1059 /// Finish - This does final analysis of the declspec, rejecting things like
1060 /// "_Imaginary" (lacking an FP type). This returns a diagnostic to issue or
1061 /// diag::NUM_DIAGNOSTICS if there is no error. After calling this method,
1062 /// DeclSpec is guaranteed self-consistent, even if an error occurred.
1063 void DeclSpec::Finish(Sema &S, const PrintingPolicy &Policy) {
1064 // Before possibly changing their values, save specs as written.
1065 SaveWrittenBuiltinSpecs();
1067 // Check the type specifier components first. No checking for an invalid
1069 if (TypeSpecType == TST_error)
1072 // If decltype(auto) is used, no other type specifiers are permitted.
1073 if (TypeSpecType == TST_decltype_auto &&
1074 (TypeSpecWidth != TSW_unspecified ||
1075 TypeSpecComplex != TSC_unspecified ||
1076 TypeSpecSign != TSS_unspecified ||
1077 TypeAltiVecVector || TypeAltiVecPixel || TypeAltiVecBool ||
1079 const unsigned NumLocs = 9;
1080 SourceLocation ExtraLocs[NumLocs] = {
1081 TSWRange.getBegin(), TSCLoc, TSSLoc,
1082 AltiVecLoc, TQ_constLoc, TQ_restrictLoc,
1083 TQ_volatileLoc, TQ_atomicLoc, TQ_unalignedLoc};
1084 FixItHint Hints[NumLocs];
1085 SourceLocation FirstLoc;
1086 for (unsigned I = 0; I != NumLocs; ++I) {
1087 if (ExtraLocs[I].isValid()) {
1088 if (FirstLoc.isInvalid() ||
1089 S.getSourceManager().isBeforeInTranslationUnit(ExtraLocs[I],
1091 FirstLoc = ExtraLocs[I];
1092 Hints[I] = FixItHint::CreateRemoval(ExtraLocs[I]);
1095 TypeSpecWidth = TSW_unspecified;
1096 TypeSpecComplex = TSC_unspecified;
1097 TypeSpecSign = TSS_unspecified;
1098 TypeAltiVecVector = TypeAltiVecPixel = TypeAltiVecBool = false;
1100 S.Diag(TSTLoc, diag::err_decltype_auto_cannot_be_combined)
1101 << Hints[0] << Hints[1] << Hints[2] << Hints[3]
1102 << Hints[4] << Hints[5] << Hints[6] << Hints[7];
1105 // Validate and finalize AltiVec vector declspec.
1106 if (TypeAltiVecVector) {
1107 if (TypeAltiVecBool) {
1108 // Sign specifiers are not allowed with vector bool. (PIM 2.1)
1109 if (TypeSpecSign != TSS_unspecified) {
1110 S.Diag(TSSLoc, diag::err_invalid_vector_bool_decl_spec)
1111 << getSpecifierName((TSS)TypeSpecSign);
1114 // Only char/int are valid with vector bool. (PIM 2.1)
1115 if (((TypeSpecType != TST_unspecified) && (TypeSpecType != TST_char) &&
1116 (TypeSpecType != TST_int)) || TypeAltiVecPixel) {
1117 S.Diag(TSTLoc, diag::err_invalid_vector_bool_decl_spec)
1118 << (TypeAltiVecPixel ? "__pixel" :
1119 getSpecifierName((TST)TypeSpecType, Policy));
1122 // Only 'short' and 'long long' are valid with vector bool. (PIM 2.1)
1123 if ((TypeSpecWidth != TSW_unspecified) && (TypeSpecWidth != TSW_short) &&
1124 (TypeSpecWidth != TSW_longlong))
1125 S.Diag(TSWRange.getBegin(), diag::err_invalid_vector_bool_decl_spec)
1126 << getSpecifierName((TSW)TypeSpecWidth);
1128 // vector bool long long requires VSX support or ZVector.
1129 if ((TypeSpecWidth == TSW_longlong) &&
1130 (!S.Context.getTargetInfo().hasFeature("vsx")) &&
1131 (!S.Context.getTargetInfo().hasFeature("power8-vector")) &&
1132 !S.getLangOpts().ZVector)
1133 S.Diag(TSTLoc, diag::err_invalid_vector_long_long_decl_spec);
1135 // Elements of vector bool are interpreted as unsigned. (PIM 2.1)
1136 if ((TypeSpecType == TST_char) || (TypeSpecType == TST_int) ||
1137 (TypeSpecWidth != TSW_unspecified))
1138 TypeSpecSign = TSS_unsigned;
1139 } else if (TypeSpecType == TST_double) {
1140 // vector long double and vector long long double are never allowed.
1141 // vector double is OK for Power7 and later, and ZVector.
1142 if (TypeSpecWidth == TSW_long || TypeSpecWidth == TSW_longlong)
1143 S.Diag(TSWRange.getBegin(),
1144 diag::err_invalid_vector_long_double_decl_spec);
1145 else if (!S.Context.getTargetInfo().hasFeature("vsx") &&
1146 !S.getLangOpts().ZVector)
1147 S.Diag(TSTLoc, diag::err_invalid_vector_double_decl_spec);
1148 } else if (TypeSpecType == TST_float) {
1149 // vector float is unsupported for ZVector unless we have the
1150 // vector-enhancements facility 1 (ISA revision 12).
1151 if (S.getLangOpts().ZVector &&
1152 !S.Context.getTargetInfo().hasFeature("arch12"))
1153 S.Diag(TSTLoc, diag::err_invalid_vector_float_decl_spec);
1154 } else if (TypeSpecWidth == TSW_long) {
1155 // vector long is unsupported for ZVector and deprecated for AltiVec.
1156 if (S.getLangOpts().ZVector)
1157 S.Diag(TSWRange.getBegin(), diag::err_invalid_vector_long_decl_spec);
1159 S.Diag(TSWRange.getBegin(),
1160 diag::warn_vector_long_decl_spec_combination)
1161 << getSpecifierName((TST)TypeSpecType, Policy);
1164 if (TypeAltiVecPixel) {
1165 //TODO: perform validation
1166 TypeSpecType = TST_int;
1167 TypeSpecSign = TSS_unsigned;
1168 TypeSpecWidth = TSW_short;
1169 TypeSpecOwned = false;
1173 bool IsFixedPointType =
1174 TypeSpecType == TST_accum || TypeSpecType == TST_fract;
1176 // signed/unsigned are only valid with int/char/wchar_t/_Accum.
1177 if (TypeSpecSign != TSS_unspecified) {
1178 if (TypeSpecType == TST_unspecified)
1179 TypeSpecType = TST_int; // unsigned -> unsigned int, signed -> signed int.
1180 else if (TypeSpecType != TST_int && TypeSpecType != TST_int128 &&
1181 TypeSpecType != TST_char && TypeSpecType != TST_wchar &&
1182 !IsFixedPointType) {
1183 S.Diag(TSSLoc, diag::err_invalid_sign_spec)
1184 << getSpecifierName((TST)TypeSpecType, Policy);
1185 // signed double -> double.
1186 TypeSpecSign = TSS_unspecified;
1190 // Validate the width of the type.
1191 switch (TypeSpecWidth) {
1192 case TSW_unspecified: break;
1193 case TSW_short: // short int
1194 case TSW_longlong: // long long int
1195 if (TypeSpecType == TST_unspecified)
1196 TypeSpecType = TST_int; // short -> short int, long long -> long long int.
1197 else if (!(TypeSpecType == TST_int ||
1198 (IsFixedPointType && TypeSpecWidth != TSW_longlong))) {
1199 S.Diag(TSWRange.getBegin(), diag::err_invalid_width_spec)
1200 << (int)TypeSpecWidth << getSpecifierName((TST)TypeSpecType, Policy);
1201 TypeSpecType = TST_int;
1202 TypeSpecSat = false;
1203 TypeSpecOwned = false;
1206 case TSW_long: // long double, long int
1207 if (TypeSpecType == TST_unspecified)
1208 TypeSpecType = TST_int; // long -> long int.
1209 else if (TypeSpecType != TST_int && TypeSpecType != TST_double &&
1210 !IsFixedPointType) {
1211 S.Diag(TSWRange.getBegin(), diag::err_invalid_width_spec)
1212 << (int)TypeSpecWidth << getSpecifierName((TST)TypeSpecType, Policy);
1213 TypeSpecType = TST_int;
1214 TypeSpecSat = false;
1215 TypeSpecOwned = false;
1220 // TODO: if the implementation does not implement _Complex or _Imaginary,
1221 // disallow their use. Need information about the backend.
1222 if (TypeSpecComplex != TSC_unspecified) {
1223 if (TypeSpecType == TST_unspecified) {
1224 S.Diag(TSCLoc, diag::ext_plain_complex)
1225 << FixItHint::CreateInsertion(
1226 S.getLocForEndOfToken(getTypeSpecComplexLoc()),
1228 TypeSpecType = TST_double; // _Complex -> _Complex double.
1229 } else if (TypeSpecType == TST_int || TypeSpecType == TST_char) {
1230 // Note that this intentionally doesn't include _Complex _Bool.
1231 if (!S.getLangOpts().CPlusPlus)
1232 S.Diag(TSTLoc, diag::ext_integer_complex);
1233 } else if (TypeSpecType != TST_float && TypeSpecType != TST_double) {
1234 S.Diag(TSCLoc, diag::err_invalid_complex_spec)
1235 << getSpecifierName((TST)TypeSpecType, Policy);
1236 TypeSpecComplex = TSC_unspecified;
1240 // C11 6.7.1/3, C++11 [dcl.stc]p1, GNU TLS: __thread, thread_local and
1241 // _Thread_local can only appear with the 'static' and 'extern' storage class
1242 // specifiers. We also allow __private_extern__ as an extension.
1243 if (ThreadStorageClassSpec != TSCS_unspecified) {
1244 switch (StorageClassSpec) {
1245 case SCS_unspecified:
1247 case SCS_private_extern:
1251 if (S.getSourceManager().isBeforeInTranslationUnit(
1252 getThreadStorageClassSpecLoc(), getStorageClassSpecLoc()))
1253 S.Diag(getStorageClassSpecLoc(),
1254 diag::err_invalid_decl_spec_combination)
1255 << DeclSpec::getSpecifierName(getThreadStorageClassSpec())
1256 << SourceRange(getThreadStorageClassSpecLoc());
1258 S.Diag(getThreadStorageClassSpecLoc(),
1259 diag::err_invalid_decl_spec_combination)
1260 << DeclSpec::getSpecifierName(getStorageClassSpec())
1261 << SourceRange(getStorageClassSpecLoc());
1262 // Discard the thread storage class specifier to recover.
1263 ThreadStorageClassSpec = TSCS_unspecified;
1264 ThreadStorageClassSpecLoc = SourceLocation();
1268 // If no type specifier was provided and we're parsing a language where
1269 // the type specifier is not optional, but we got 'auto' as a storage
1270 // class specifier, then assume this is an attempt to use C++0x's 'auto'
1272 if (S.getLangOpts().CPlusPlus &&
1273 TypeSpecType == TST_unspecified && StorageClassSpec == SCS_auto) {
1274 TypeSpecType = TST_auto;
1275 StorageClassSpec = SCS_unspecified;
1276 TSTLoc = TSTNameLoc = StorageClassSpecLoc;
1277 StorageClassSpecLoc = SourceLocation();
1279 // Diagnose if we've recovered from an ill-formed 'auto' storage class
1280 // specifier in a pre-C++11 dialect of C++.
1281 if (!S.getLangOpts().CPlusPlus11 && TypeSpecType == TST_auto)
1282 S.Diag(TSTLoc, diag::ext_auto_type_specifier);
1283 if (S.getLangOpts().CPlusPlus && !S.getLangOpts().CPlusPlus11 &&
1284 StorageClassSpec == SCS_auto)
1285 S.Diag(StorageClassSpecLoc, diag::warn_auto_storage_class)
1286 << FixItHint::CreateRemoval(StorageClassSpecLoc);
1287 if (TypeSpecType == TST_char8)
1288 S.Diag(TSTLoc, diag::warn_cxx17_compat_unicode_type);
1289 else if (TypeSpecType == TST_char16 || TypeSpecType == TST_char32)
1290 S.Diag(TSTLoc, diag::warn_cxx98_compat_unicode_type)
1291 << (TypeSpecType == TST_char16 ? "char16_t" : "char32_t");
1292 if (getConstexprSpecifier() == CSK_constexpr)
1293 S.Diag(ConstexprLoc, diag::warn_cxx98_compat_constexpr);
1294 if (getConstexprSpecifier() == CSK_consteval)
1295 S.Diag(ConstexprLoc, diag::warn_cxx20_compat_consteval);
1296 // C++ [class.friend]p6:
1297 // No storage-class-specifier shall appear in the decl-specifier-seq
1298 // of a friend declaration.
1299 if (isFriendSpecified() &&
1300 (getStorageClassSpec() || getThreadStorageClassSpec())) {
1301 SmallString<32> SpecName;
1302 SourceLocation SCLoc;
1303 FixItHint StorageHint, ThreadHint;
1305 if (DeclSpec::SCS SC = getStorageClassSpec()) {
1306 SpecName = getSpecifierName(SC);
1307 SCLoc = getStorageClassSpecLoc();
1308 StorageHint = FixItHint::CreateRemoval(SCLoc);
1311 if (DeclSpec::TSCS TSC = getThreadStorageClassSpec()) {
1312 if (!SpecName.empty()) SpecName += " ";
1313 SpecName += getSpecifierName(TSC);
1314 SCLoc = getThreadStorageClassSpecLoc();
1315 ThreadHint = FixItHint::CreateRemoval(SCLoc);
1318 S.Diag(SCLoc, diag::err_friend_decl_spec)
1319 << SpecName << StorageHint << ThreadHint;
1321 ClearStorageClassSpecs();
1324 // C++11 [dcl.fct.spec]p5:
1325 // The virtual specifier shall be used only in the initial
1326 // declaration of a non-static class member function;
1327 // C++11 [dcl.fct.spec]p6:
1328 // The explicit specifier shall be used only in the declaration of
1329 // a constructor or conversion function within its class
1331 if (isFriendSpecified() && (isVirtualSpecified() || hasExplicitSpecifier())) {
1334 SourceLocation SCLoc;
1336 if (isVirtualSpecified()) {
1337 Keyword = "virtual";
1338 SCLoc = getVirtualSpecLoc();
1339 Hint = FixItHint::CreateRemoval(SCLoc);
1341 Keyword = "explicit";
1342 SCLoc = getExplicitSpecLoc();
1343 Hint = FixItHint::CreateRemoval(getExplicitSpecRange());
1346 S.Diag(SCLoc, diag::err_friend_decl_spec)
1349 FS_virtual_specified = false;
1350 FS_explicit_specifier = ExplicitSpecifier();
1351 FS_virtualLoc = FS_explicitLoc = SourceLocation();
1354 assert(!TypeSpecOwned || isDeclRep((TST) TypeSpecType));
1356 // Okay, now we can infer the real type.
1358 // TODO: return "auto function" and other bad things based on the real type.
1360 // 'data definition has no type or storage class'?
1363 bool DeclSpec::isMissingDeclaratorOk() {
1364 TST tst = getTypeSpecType();
1365 return isDeclRep(tst) && getRepAsDecl() != nullptr &&
1366 StorageClassSpec != DeclSpec::SCS_typedef;
1369 void UnqualifiedId::setOperatorFunctionId(SourceLocation OperatorLoc,
1370 OverloadedOperatorKind Op,
1371 SourceLocation SymbolLocations[3]) {
1372 Kind = UnqualifiedIdKind::IK_OperatorFunctionId;
1373 StartLocation = OperatorLoc;
1374 EndLocation = OperatorLoc;
1375 OperatorFunctionId.Operator = Op;
1376 for (unsigned I = 0; I != 3; ++I) {
1377 OperatorFunctionId.SymbolLocations[I] = SymbolLocations[I].getRawEncoding();
1379 if (SymbolLocations[I].isValid())
1380 EndLocation = SymbolLocations[I];
1384 bool VirtSpecifiers::SetSpecifier(Specifier VS, SourceLocation Loc,
1385 const char *&PrevSpec) {
1386 if (!FirstLocation.isValid())
1387 FirstLocation = Loc;
1391 if (Specifiers & VS) {
1392 PrevSpec = getSpecifierName(VS);
1399 default: llvm_unreachable("Unknown specifier!");
1400 case VS_Override: VS_overrideLoc = Loc; break;
1403 case VS_Final: VS_finalLoc = Loc; break;
1409 const char *VirtSpecifiers::getSpecifierName(Specifier VS) {
1411 default: llvm_unreachable("Unknown specifier");
1412 case VS_Override: return "override";
1413 case VS_Final: return "final";
1414 case VS_GNU_Final: return "__final";
1415 case VS_Sealed: return "sealed";