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   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   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   assert(Range == Builder.getSourceRange() &&
54          "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   assert(Range == Builder.getSourceRange() &&
67          "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   assert(Range == Builder.getSourceRange() &&
80          "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   assert(Range == Builder.getSourceRange() &&
93          "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   assert(Range == Builder.getSourceRange() &&
103          "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   assert(Range == Builder.getSourceRange() &&
115   "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   assert(!(MethodQualifiers && MethodQualifiers->getTypeQualifiers() & DeclSpec::TQ_atomic) &&
177          "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   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     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];
275   }
276 
277   return I;
278 }
279 
280 void Declarator::setDecompositionBindings(
281     SourceLocation LSquareLoc,
282     ArrayRef<DecompositionDeclarator::Binding> Bindings,
283     SourceLocation RSquareLoc) {
284   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 || hasExplicitSpecifier() ||
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(ConstexprSpecKind C) {
568   switch (C) {
569   case CSK_unspecified: return "unspecified";
570   case CSK_constexpr:   return "constexpr";
571   case CSK_consteval:   return "consteval";
572   case CSK_constinit:   return "constinit";
573   }
574   llvm_unreachable("Unknown ConstexprSpecKind");
575 }
576 
577 const char *DeclSpec::getSpecifierName(TQ T) {
578   switch (T) {
579   case DeclSpec::TQ_unspecified: return "unspecified";
580   case DeclSpec::TQ_const:       return "const";
581   case DeclSpec::TQ_restrict:    return "restrict";
582   case DeclSpec::TQ_volatile:    return "volatile";
583   case DeclSpec::TQ_atomic:      return "_Atomic";
584   case DeclSpec::TQ_unaligned:   return "__unaligned";
585   }
586   llvm_unreachable("Unknown typespec!");
587 }
588 
589 bool DeclSpec::SetStorageClassSpec(Sema &S, SCS SC, SourceLocation Loc,
590                                    const char *&PrevSpec,
591                                    unsigned &DiagID,
592                                    const PrintingPolicy &Policy) {
593   // OpenCL v1.1 s6.8g: "The extern, static, auto and register storage-class
594   // specifiers are not supported.
595   // It seems sensible to prohibit private_extern too
596   // The cl_clang_storage_class_specifiers extension enables support for
597   // these storage-class specifiers.
598   // OpenCL v1.2 s6.8 changes this to "The auto and register storage-class
599   // specifiers are not supported."
600   if (S.getLangOpts().OpenCL &&
601       !S.getOpenCLOptions().isEnabled("cl_clang_storage_class_specifiers")) {
602     switch (SC) {
603     case SCS_extern:
604     case SCS_private_extern:
605     case SCS_static:
606       if (S.getLangOpts().OpenCLVersion < 120 &&
607           !S.getLangOpts().OpenCLCPlusPlus) {
608         DiagID = diag::err_opencl_unknown_type_specifier;
609         PrevSpec = getSpecifierName(SC);
610         return true;
611       }
612       break;
613     case SCS_auto:
614     case SCS_register:
615       DiagID   = diag::err_opencl_unknown_type_specifier;
616       PrevSpec = getSpecifierName(SC);
617       return true;
618     default:
619       break;
620     }
621   }
622 
623   if (StorageClassSpec != SCS_unspecified) {
624     // Maybe this is an attempt to use C++11 'auto' outside of C++11 mode.
625     bool isInvalid = true;
626     if (TypeSpecType == TST_unspecified && S.getLangOpts().CPlusPlus) {
627       if (SC == SCS_auto)
628         return SetTypeSpecType(TST_auto, Loc, PrevSpec, DiagID, Policy);
629       if (StorageClassSpec == SCS_auto) {
630         isInvalid = SetTypeSpecType(TST_auto, StorageClassSpecLoc,
631                                     PrevSpec, DiagID, Policy);
632         assert(!isInvalid && "auto SCS -> TST recovery failed");
633       }
634     }
635 
636     // Changing storage class is allowed only if the previous one
637     // was the 'extern' that is part of a linkage specification and
638     // the new storage class is 'typedef'.
639     if (isInvalid &&
640         !(SCS_extern_in_linkage_spec &&
641           StorageClassSpec == SCS_extern &&
642           SC == SCS_typedef))
643       return BadSpecifier(SC, (SCS)StorageClassSpec, PrevSpec, DiagID);
644   }
645   StorageClassSpec = SC;
646   StorageClassSpecLoc = Loc;
647   assert((unsigned)SC == StorageClassSpec && "SCS constants overflow bitfield");
648   return false;
649 }
650 
651 bool DeclSpec::SetStorageClassSpecThread(TSCS TSC, SourceLocation Loc,
652                                          const char *&PrevSpec,
653                                          unsigned &DiagID) {
654   if (ThreadStorageClassSpec != TSCS_unspecified)
655     return BadSpecifier(TSC, (TSCS)ThreadStorageClassSpec, PrevSpec, DiagID);
656 
657   ThreadStorageClassSpec = TSC;
658   ThreadStorageClassSpecLoc = Loc;
659   return false;
660 }
661 
662 /// These methods set the specified attribute of the DeclSpec, but return true
663 /// and ignore the request if invalid (e.g. "extern" then "auto" is
664 /// specified).
665 bool DeclSpec::SetTypeSpecWidth(TSW W, SourceLocation Loc,
666                                 const char *&PrevSpec,
667                                 unsigned &DiagID,
668                                 const PrintingPolicy &Policy) {
669   // Overwrite TSWRange.Begin only if TypeSpecWidth was unspecified, so that
670   // for 'long long' we will keep the source location of the first 'long'.
671   if (TypeSpecWidth == TSW_unspecified)
672     TSWRange.setBegin(Loc);
673   // Allow turning long -> long long.
674   else if (W != TSW_longlong || TypeSpecWidth != TSW_long)
675     return BadSpecifier(W, (TSW)TypeSpecWidth, PrevSpec, DiagID);
676   TypeSpecWidth = W;
677   // Remember location of the last 'long'
678   TSWRange.setEnd(Loc);
679   return false;
680 }
681 
682 bool DeclSpec::SetTypeSpecComplex(TSC C, SourceLocation Loc,
683                                   const char *&PrevSpec,
684                                   unsigned &DiagID) {
685   if (TypeSpecComplex != TSC_unspecified)
686     return BadSpecifier(C, (TSC)TypeSpecComplex, PrevSpec, DiagID);
687   TypeSpecComplex = C;
688   TSCLoc = Loc;
689   return false;
690 }
691 
692 bool DeclSpec::SetTypeSpecSign(TSS S, SourceLocation Loc,
693                                const char *&PrevSpec,
694                                unsigned &DiagID) {
695   if (TypeSpecSign != TSS_unspecified)
696     return BadSpecifier(S, (TSS)TypeSpecSign, PrevSpec, DiagID);
697   TypeSpecSign = S;
698   TSSLoc = Loc;
699   return false;
700 }
701 
702 bool DeclSpec::SetTypeSpecType(TST T, SourceLocation Loc,
703                                const char *&PrevSpec,
704                                unsigned &DiagID,
705                                ParsedType Rep,
706                                const PrintingPolicy &Policy) {
707   return SetTypeSpecType(T, Loc, Loc, PrevSpec, DiagID, Rep, Policy);
708 }
709 
710 bool DeclSpec::SetTypeSpecType(TST T, SourceLocation TagKwLoc,
711                                SourceLocation TagNameLoc,
712                                const char *&PrevSpec,
713                                unsigned &DiagID,
714                                ParsedType Rep,
715                                const PrintingPolicy &Policy) {
716   assert(isTypeRep(T) && "T does not store a type");
717   assert(Rep && "no type provided!");
718   if (TypeSpecType == TST_error)
719     return false;
720   if (TypeSpecType != TST_unspecified) {
721     PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType, Policy);
722     DiagID = diag::err_invalid_decl_spec_combination;
723     return true;
724   }
725   TypeSpecType = T;
726   TypeRep = Rep;
727   TSTLoc = TagKwLoc;
728   TSTNameLoc = TagNameLoc;
729   TypeSpecOwned = false;
730   return false;
731 }
732 
733 bool DeclSpec::SetTypeSpecType(TST T, SourceLocation Loc,
734                                const char *&PrevSpec,
735                                unsigned &DiagID,
736                                Expr *Rep,
737                                const PrintingPolicy &Policy) {
738   assert(isExprRep(T) && "T does not store an expr");
739   assert(Rep && "no expression provided!");
740   if (TypeSpecType == TST_error)
741     return false;
742   if (TypeSpecType != TST_unspecified) {
743     PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType, Policy);
744     DiagID = diag::err_invalid_decl_spec_combination;
745     return true;
746   }
747   TypeSpecType = T;
748   ExprRep = Rep;
749   TSTLoc = Loc;
750   TSTNameLoc = Loc;
751   TypeSpecOwned = false;
752   return false;
753 }
754 
755 bool DeclSpec::SetTypeSpecType(TST T, SourceLocation Loc,
756                                const char *&PrevSpec,
757                                unsigned &DiagID,
758                                Decl *Rep, bool Owned,
759                                const PrintingPolicy &Policy) {
760   return SetTypeSpecType(T, Loc, Loc, PrevSpec, DiagID, Rep, Owned, Policy);
761 }
762 
763 bool DeclSpec::SetTypeSpecType(TST T, SourceLocation TagKwLoc,
764                                SourceLocation TagNameLoc,
765                                const char *&PrevSpec,
766                                unsigned &DiagID,
767                                Decl *Rep, bool Owned,
768                                const PrintingPolicy &Policy) {
769   assert(isDeclRep(T) && "T does not store a decl");
770   // Unlike the other cases, we don't assert that we actually get a decl.
771 
772   if (TypeSpecType == TST_error)
773     return false;
774   if (TypeSpecType != TST_unspecified) {
775     PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType, Policy);
776     DiagID = diag::err_invalid_decl_spec_combination;
777     return true;
778   }
779   TypeSpecType = T;
780   DeclRep = Rep;
781   TSTLoc = TagKwLoc;
782   TSTNameLoc = TagNameLoc;
783   TypeSpecOwned = Owned && Rep != nullptr;
784   return false;
785 }
786 
787 bool DeclSpec::SetTypeSpecType(TST T, SourceLocation Loc, const char *&PrevSpec,
788                                unsigned &DiagID, TemplateIdAnnotation *Rep,
789                                const PrintingPolicy &Policy) {
790   assert(T == TST_auto || T == TST_decltype_auto);
791   ConstrainedAuto = true;
792   TemplateIdRep = Rep;
793   return SetTypeSpecType(T, Loc, PrevSpec, DiagID, Policy);
794 }
795 
796 bool DeclSpec::SetTypeSpecType(TST T, SourceLocation Loc,
797                                const char *&PrevSpec,
798                                unsigned &DiagID,
799                                const PrintingPolicy &Policy) {
800   assert(!isDeclRep(T) && !isTypeRep(T) && !isExprRep(T) &&
801          "rep required for these type-spec kinds!");
802   if (TypeSpecType == TST_error)
803     return false;
804   if (TypeSpecType != TST_unspecified) {
805     PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType, Policy);
806     DiagID = diag::err_invalid_decl_spec_combination;
807     return true;
808   }
809   TSTLoc = Loc;
810   TSTNameLoc = Loc;
811   if (TypeAltiVecVector && (T == TST_bool) && !TypeAltiVecBool) {
812     TypeAltiVecBool = true;
813     return false;
814   }
815   TypeSpecType = T;
816   TypeSpecOwned = false;
817   return false;
818 }
819 
820 bool DeclSpec::SetTypeSpecSat(SourceLocation Loc, const char *&PrevSpec,
821                               unsigned &DiagID) {
822   // Cannot set twice
823   if (TypeSpecSat) {
824     DiagID = diag::warn_duplicate_declspec;
825     PrevSpec = "_Sat";
826     return true;
827   }
828   TypeSpecSat = true;
829   TSSatLoc = Loc;
830   return false;
831 }
832 
833 bool DeclSpec::SetTypeAltiVecVector(bool isAltiVecVector, SourceLocation Loc,
834                           const char *&PrevSpec, unsigned &DiagID,
835                           const PrintingPolicy &Policy) {
836   if (TypeSpecType == TST_error)
837     return false;
838   if (TypeSpecType != TST_unspecified) {
839     PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType, Policy);
840     DiagID = diag::err_invalid_vector_decl_spec_combination;
841     return true;
842   }
843   TypeAltiVecVector = isAltiVecVector;
844   AltiVecLoc = Loc;
845   return false;
846 }
847 
848 bool DeclSpec::SetTypePipe(bool isPipe, SourceLocation Loc,
849                            const char *&PrevSpec, unsigned &DiagID,
850                            const PrintingPolicy &Policy) {
851   if (TypeSpecType == TST_error)
852     return false;
853   if (TypeSpecType != TST_unspecified) {
854     PrevSpec = DeclSpec::getSpecifierName((TST)TypeSpecType, Policy);
855     DiagID = diag::err_invalid_decl_spec_combination;
856     return true;
857   }
858 
859   if (isPipe) {
860     TypeSpecPipe = TSP_pipe;
861   }
862   return false;
863 }
864 
865 bool DeclSpec::SetTypeAltiVecPixel(bool isAltiVecPixel, SourceLocation Loc,
866                           const char *&PrevSpec, unsigned &DiagID,
867                           const PrintingPolicy &Policy) {
868   if (TypeSpecType == TST_error)
869     return false;
870   if (!TypeAltiVecVector || TypeAltiVecPixel ||
871       (TypeSpecType != TST_unspecified)) {
872     PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType, Policy);
873     DiagID = diag::err_invalid_pixel_decl_spec_combination;
874     return true;
875   }
876   TypeAltiVecPixel = isAltiVecPixel;
877   TSTLoc = Loc;
878   TSTNameLoc = Loc;
879   return false;
880 }
881 
882 bool DeclSpec::SetTypeAltiVecBool(bool isAltiVecBool, SourceLocation Loc,
883                                   const char *&PrevSpec, unsigned &DiagID,
884                                   const PrintingPolicy &Policy) {
885   if (TypeSpecType == TST_error)
886     return false;
887   if (!TypeAltiVecVector || TypeAltiVecBool ||
888       (TypeSpecType != TST_unspecified)) {
889     PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType, Policy);
890     DiagID = diag::err_invalid_vector_bool_decl_spec;
891     return true;
892   }
893   TypeAltiVecBool = isAltiVecBool;
894   TSTLoc = Loc;
895   TSTNameLoc = Loc;
896   return false;
897 }
898 
899 bool DeclSpec::SetTypeSpecError() {
900   TypeSpecType = TST_error;
901   TypeSpecOwned = false;
902   TSTLoc = SourceLocation();
903   TSTNameLoc = SourceLocation();
904   return false;
905 }
906 
907 bool DeclSpec::SetTypeQual(TQ T, SourceLocation Loc, const char *&PrevSpec,
908                            unsigned &DiagID, const LangOptions &Lang) {
909   // Duplicates are permitted in C99 onwards, but are not permitted in C89 or
910   // C++.  However, since this is likely not what the user intended, we will
911   // always warn.  We do not need to set the qualifier's location since we
912   // already have it.
913   if (TypeQualifiers & T) {
914     bool IsExtension = true;
915     if (Lang.C99)
916       IsExtension = false;
917     return BadSpecifier(T, T, PrevSpec, DiagID, IsExtension);
918   }
919 
920   return SetTypeQual(T, Loc);
921 }
922 
923 bool DeclSpec::SetTypeQual(TQ T, SourceLocation Loc) {
924   TypeQualifiers |= T;
925 
926   switch (T) {
927   case TQ_unspecified: break;
928   case TQ_const:    TQ_constLoc = Loc; return false;
929   case TQ_restrict: TQ_restrictLoc = Loc; return false;
930   case TQ_volatile: TQ_volatileLoc = Loc; return false;
931   case TQ_unaligned: TQ_unalignedLoc = Loc; return false;
932   case TQ_atomic:   TQ_atomicLoc = Loc; return false;
933   }
934 
935   llvm_unreachable("Unknown type qualifier!");
936 }
937 
938 bool DeclSpec::setFunctionSpecInline(SourceLocation Loc, const char *&PrevSpec,
939                                      unsigned &DiagID) {
940   // 'inline inline' is ok.  However, since this is likely not what the user
941   // intended, we will always warn, similar to duplicates of type qualifiers.
942   if (FS_inline_specified) {
943     DiagID = diag::warn_duplicate_declspec;
944     PrevSpec = "inline";
945     return true;
946   }
947   FS_inline_specified = true;
948   FS_inlineLoc = Loc;
949   return false;
950 }
951 
952 bool DeclSpec::setFunctionSpecForceInline(SourceLocation Loc, const char *&PrevSpec,
953                                           unsigned &DiagID) {
954   if (FS_forceinline_specified) {
955     DiagID = diag::warn_duplicate_declspec;
956     PrevSpec = "__forceinline";
957     return true;
958   }
959   FS_forceinline_specified = true;
960   FS_forceinlineLoc = Loc;
961   return false;
962 }
963 
964 bool DeclSpec::setFunctionSpecVirtual(SourceLocation Loc,
965                                       const char *&PrevSpec,
966                                       unsigned &DiagID) {
967   // 'virtual virtual' is ok, but warn as this is likely not what the user
968   // intended.
969   if (FS_virtual_specified) {
970     DiagID = diag::warn_duplicate_declspec;
971     PrevSpec = "virtual";
972     return true;
973   }
974   FS_virtual_specified = true;
975   FS_virtualLoc = Loc;
976   return false;
977 }
978 
979 bool DeclSpec::setFunctionSpecExplicit(SourceLocation Loc,
980                                        const char *&PrevSpec, unsigned &DiagID,
981                                        ExplicitSpecifier ExplicitSpec,
982                                        SourceLocation CloseParenLoc) {
983   assert((ExplicitSpec.getKind() == ExplicitSpecKind::ResolvedTrue ||
984           ExplicitSpec.getExpr()) &&
985          "invalid ExplicitSpecifier");
986   // 'explicit explicit' is ok, but warn as this is likely not what the user
987   // intended.
988   if (hasExplicitSpecifier()) {
989     DiagID = (ExplicitSpec.getExpr() || FS_explicit_specifier.getExpr())
990                  ? diag::err_duplicate_declspec
991                  : diag::ext_warn_duplicate_declspec;
992     PrevSpec = "explicit";
993     return true;
994   }
995   FS_explicit_specifier = ExplicitSpec;
996   FS_explicitLoc = Loc;
997   FS_explicitCloseParenLoc = CloseParenLoc;
998   return false;
999 }
1000 
1001 bool DeclSpec::setFunctionSpecNoreturn(SourceLocation Loc,
1002                                        const char *&PrevSpec,
1003                                        unsigned &DiagID) {
1004   // '_Noreturn _Noreturn' is ok, but warn as this is likely not what the user
1005   // intended.
1006   if (FS_noreturn_specified) {
1007     DiagID = diag::warn_duplicate_declspec;
1008     PrevSpec = "_Noreturn";
1009     return true;
1010   }
1011   FS_noreturn_specified = true;
1012   FS_noreturnLoc = Loc;
1013   return false;
1014 }
1015 
1016 bool DeclSpec::SetFriendSpec(SourceLocation Loc, const char *&PrevSpec,
1017                              unsigned &DiagID) {
1018   if (Friend_specified) {
1019     PrevSpec = "friend";
1020     // Keep the later location, so that we can later diagnose ill-formed
1021     // declarations like 'friend class X friend;'. Per [class.friend]p3,
1022     // 'friend' must be the first token in a friend declaration that is
1023     // not a function declaration.
1024     FriendLoc = Loc;
1025     DiagID = diag::warn_duplicate_declspec;
1026     return true;
1027   }
1028 
1029   Friend_specified = true;
1030   FriendLoc = Loc;
1031   return false;
1032 }
1033 
1034 bool DeclSpec::setModulePrivateSpec(SourceLocation Loc, const char *&PrevSpec,
1035                                     unsigned &DiagID) {
1036   if (isModulePrivateSpecified()) {
1037     PrevSpec = "__module_private__";
1038     DiagID = diag::ext_warn_duplicate_declspec;
1039     return true;
1040   }
1041 
1042   ModulePrivateLoc = Loc;
1043   return false;
1044 }
1045 
1046 bool DeclSpec::SetConstexprSpec(ConstexprSpecKind ConstexprKind,
1047                                 SourceLocation Loc, const char *&PrevSpec,
1048                                 unsigned &DiagID) {
1049   if (getConstexprSpecifier() != CSK_unspecified)
1050     return BadSpecifier(ConstexprKind, getConstexprSpecifier(), PrevSpec,
1051                         DiagID);
1052   ConstexprSpecifier = ConstexprKind;
1053   ConstexprLoc = Loc;
1054   return false;
1055 }
1056 
1057 void DeclSpec::SaveWrittenBuiltinSpecs() {
1058   writtenBS.Sign = getTypeSpecSign();
1059   writtenBS.Width = getTypeSpecWidth();
1060   writtenBS.Type = getTypeSpecType();
1061   // Search the list of attributes for the presence of a mode attribute.
1062   writtenBS.ModeAttr = getAttributes().hasAttribute(ParsedAttr::AT_Mode);
1063 }
1064 
1065 /// Finish - This does final analysis of the declspec, rejecting things like
1066 /// "_Imaginary" (lacking an FP type).  This returns a diagnostic to issue or
1067 /// diag::NUM_DIAGNOSTICS if there is no error.  After calling this method,
1068 /// DeclSpec is guaranteed self-consistent, even if an error occurred.
1069 void DeclSpec::Finish(Sema &S, const PrintingPolicy &Policy) {
1070   // Before possibly changing their values, save specs as written.
1071   SaveWrittenBuiltinSpecs();
1072 
1073   // Check the type specifier components first. No checking for an invalid
1074   // type.
1075   if (TypeSpecType == TST_error)
1076     return;
1077 
1078   // If decltype(auto) is used, no other type specifiers are permitted.
1079   if (TypeSpecType == TST_decltype_auto &&
1080       (TypeSpecWidth != TSW_unspecified ||
1081        TypeSpecComplex != TSC_unspecified ||
1082        TypeSpecSign != TSS_unspecified ||
1083        TypeAltiVecVector || TypeAltiVecPixel || TypeAltiVecBool ||
1084        TypeQualifiers)) {
1085     const unsigned NumLocs = 9;
1086     SourceLocation ExtraLocs[NumLocs] = {
1087         TSWRange.getBegin(), TSCLoc,       TSSLoc,
1088         AltiVecLoc,          TQ_constLoc,  TQ_restrictLoc,
1089         TQ_volatileLoc,      TQ_atomicLoc, TQ_unalignedLoc};
1090     FixItHint Hints[NumLocs];
1091     SourceLocation FirstLoc;
1092     for (unsigned I = 0; I != NumLocs; ++I) {
1093       if (ExtraLocs[I].isValid()) {
1094         if (FirstLoc.isInvalid() ||
1095             S.getSourceManager().isBeforeInTranslationUnit(ExtraLocs[I],
1096                                                            FirstLoc))
1097           FirstLoc = ExtraLocs[I];
1098         Hints[I] = FixItHint::CreateRemoval(ExtraLocs[I]);
1099       }
1100     }
1101     TypeSpecWidth = TSW_unspecified;
1102     TypeSpecComplex = TSC_unspecified;
1103     TypeSpecSign = TSS_unspecified;
1104     TypeAltiVecVector = TypeAltiVecPixel = TypeAltiVecBool = false;
1105     TypeQualifiers = 0;
1106     S.Diag(TSTLoc, diag::err_decltype_auto_cannot_be_combined)
1107       << Hints[0] << Hints[1] << Hints[2] << Hints[3]
1108       << Hints[4] << Hints[5] << Hints[6] << Hints[7];
1109   }
1110 
1111   // Validate and finalize AltiVec vector declspec.
1112   if (TypeAltiVecVector) {
1113     if (TypeAltiVecBool) {
1114       // Sign specifiers are not allowed with vector bool. (PIM 2.1)
1115       if (TypeSpecSign != TSS_unspecified) {
1116         S.Diag(TSSLoc, diag::err_invalid_vector_bool_decl_spec)
1117           << getSpecifierName((TSS)TypeSpecSign);
1118       }
1119 
1120       // Only char/int are valid with vector bool. (PIM 2.1)
1121       if (((TypeSpecType != TST_unspecified) && (TypeSpecType != TST_char) &&
1122            (TypeSpecType != TST_int)) || TypeAltiVecPixel) {
1123         S.Diag(TSTLoc, diag::err_invalid_vector_bool_decl_spec)
1124           << (TypeAltiVecPixel ? "__pixel" :
1125                                  getSpecifierName((TST)TypeSpecType, Policy));
1126       }
1127 
1128       // Only 'short' and 'long long' are valid with vector bool. (PIM 2.1)
1129       if ((TypeSpecWidth != TSW_unspecified) && (TypeSpecWidth != TSW_short) &&
1130           (TypeSpecWidth != TSW_longlong))
1131         S.Diag(TSWRange.getBegin(), diag::err_invalid_vector_bool_decl_spec)
1132             << getSpecifierName((TSW)TypeSpecWidth);
1133 
1134       // vector bool long long requires VSX support or ZVector.
1135       if ((TypeSpecWidth == TSW_longlong) &&
1136           (!S.Context.getTargetInfo().hasFeature("vsx")) &&
1137           (!S.Context.getTargetInfo().hasFeature("power8-vector")) &&
1138           !S.getLangOpts().ZVector)
1139         S.Diag(TSTLoc, diag::err_invalid_vector_long_long_decl_spec);
1140 
1141       // Elements of vector bool are interpreted as unsigned. (PIM 2.1)
1142       if ((TypeSpecType == TST_char) || (TypeSpecType == TST_int) ||
1143           (TypeSpecWidth != TSW_unspecified))
1144         TypeSpecSign = TSS_unsigned;
1145     } else if (TypeSpecType == TST_double) {
1146       // vector long double and vector long long double are never allowed.
1147       // vector double is OK for Power7 and later, and ZVector.
1148       if (TypeSpecWidth == TSW_long || TypeSpecWidth == TSW_longlong)
1149         S.Diag(TSWRange.getBegin(),
1150                diag::err_invalid_vector_long_double_decl_spec);
1151       else if (!S.Context.getTargetInfo().hasFeature("vsx") &&
1152                !S.getLangOpts().ZVector)
1153         S.Diag(TSTLoc, diag::err_invalid_vector_double_decl_spec);
1154     } else if (TypeSpecType == TST_float) {
1155       // vector float is unsupported for ZVector unless we have the
1156       // vector-enhancements facility 1 (ISA revision 12).
1157       if (S.getLangOpts().ZVector &&
1158           !S.Context.getTargetInfo().hasFeature("arch12"))
1159         S.Diag(TSTLoc, diag::err_invalid_vector_float_decl_spec);
1160     } else if (TypeSpecWidth == TSW_long) {
1161       // vector long is unsupported for ZVector and deprecated for AltiVec.
1162       if (S.getLangOpts().ZVector)
1163         S.Diag(TSWRange.getBegin(), diag::err_invalid_vector_long_decl_spec);
1164       else
1165         S.Diag(TSWRange.getBegin(),
1166                diag::warn_vector_long_decl_spec_combination)
1167             << getSpecifierName((TST)TypeSpecType, Policy);
1168     }
1169 
1170     if (TypeAltiVecPixel) {
1171       //TODO: perform validation
1172       TypeSpecType = TST_int;
1173       TypeSpecSign = TSS_unsigned;
1174       TypeSpecWidth = TSW_short;
1175       TypeSpecOwned = false;
1176     }
1177   }
1178 
1179   bool IsFixedPointType =
1180       TypeSpecType == TST_accum || TypeSpecType == TST_fract;
1181 
1182   // signed/unsigned are only valid with int/char/wchar_t/_Accum.
1183   if (TypeSpecSign != TSS_unspecified) {
1184     if (TypeSpecType == TST_unspecified)
1185       TypeSpecType = TST_int; // unsigned -> unsigned int, signed -> signed int.
1186     else if (TypeSpecType != TST_int && TypeSpecType != TST_int128 &&
1187              TypeSpecType != TST_char && TypeSpecType != TST_wchar &&
1188              !IsFixedPointType) {
1189       S.Diag(TSSLoc, diag::err_invalid_sign_spec)
1190         << getSpecifierName((TST)TypeSpecType, Policy);
1191       // signed double -> double.
1192       TypeSpecSign = TSS_unspecified;
1193     }
1194   }
1195 
1196   // Validate the width of the type.
1197   switch (TypeSpecWidth) {
1198   case TSW_unspecified: break;
1199   case TSW_short:    // short int
1200   case TSW_longlong: // long long int
1201     if (TypeSpecType == TST_unspecified)
1202       TypeSpecType = TST_int; // short -> short int, long long -> long long int.
1203     else if (!(TypeSpecType == TST_int ||
1204                (IsFixedPointType && TypeSpecWidth != TSW_longlong))) {
1205       S.Diag(TSWRange.getBegin(), diag::err_invalid_width_spec)
1206           << (int)TypeSpecWidth << getSpecifierName((TST)TypeSpecType, Policy);
1207       TypeSpecType = TST_int;
1208       TypeSpecSat = false;
1209       TypeSpecOwned = false;
1210     }
1211     break;
1212   case TSW_long:  // long double, long int
1213     if (TypeSpecType == TST_unspecified)
1214       TypeSpecType = TST_int;  // long -> long int.
1215     else if (TypeSpecType != TST_int && TypeSpecType != TST_double &&
1216              !IsFixedPointType) {
1217       S.Diag(TSWRange.getBegin(), diag::err_invalid_width_spec)
1218           << (int)TypeSpecWidth << getSpecifierName((TST)TypeSpecType, Policy);
1219       TypeSpecType = TST_int;
1220       TypeSpecSat = false;
1221       TypeSpecOwned = false;
1222     }
1223     break;
1224   }
1225 
1226   // TODO: if the implementation does not implement _Complex or _Imaginary,
1227   // disallow their use.  Need information about the backend.
1228   if (TypeSpecComplex != TSC_unspecified) {
1229     if (TypeSpecType == TST_unspecified) {
1230       S.Diag(TSCLoc, diag::ext_plain_complex)
1231         << FixItHint::CreateInsertion(
1232                               S.getLocForEndOfToken(getTypeSpecComplexLoc()),
1233                                                  " double");
1234       TypeSpecType = TST_double;   // _Complex -> _Complex double.
1235     } else if (TypeSpecType == TST_int || TypeSpecType == TST_char) {
1236       // Note that this intentionally doesn't include _Complex _Bool.
1237       if (!S.getLangOpts().CPlusPlus)
1238         S.Diag(TSTLoc, diag::ext_integer_complex);
1239     } else if (TypeSpecType != TST_float && TypeSpecType != TST_double) {
1240       S.Diag(TSCLoc, diag::err_invalid_complex_spec)
1241         << getSpecifierName((TST)TypeSpecType, Policy);
1242       TypeSpecComplex = TSC_unspecified;
1243     }
1244   }
1245 
1246   // C11 6.7.1/3, C++11 [dcl.stc]p1, GNU TLS: __thread, thread_local and
1247   // _Thread_local can only appear with the 'static' and 'extern' storage class
1248   // specifiers. We also allow __private_extern__ as an extension.
1249   if (ThreadStorageClassSpec != TSCS_unspecified) {
1250     switch (StorageClassSpec) {
1251     case SCS_unspecified:
1252     case SCS_extern:
1253     case SCS_private_extern:
1254     case SCS_static:
1255       break;
1256     default:
1257       if (S.getSourceManager().isBeforeInTranslationUnit(
1258             getThreadStorageClassSpecLoc(), getStorageClassSpecLoc()))
1259         S.Diag(getStorageClassSpecLoc(),
1260              diag::err_invalid_decl_spec_combination)
1261           << DeclSpec::getSpecifierName(getThreadStorageClassSpec())
1262           << SourceRange(getThreadStorageClassSpecLoc());
1263       else
1264         S.Diag(getThreadStorageClassSpecLoc(),
1265              diag::err_invalid_decl_spec_combination)
1266           << DeclSpec::getSpecifierName(getStorageClassSpec())
1267           << SourceRange(getStorageClassSpecLoc());
1268       // Discard the thread storage class specifier to recover.
1269       ThreadStorageClassSpec = TSCS_unspecified;
1270       ThreadStorageClassSpecLoc = SourceLocation();
1271     }
1272   }
1273 
1274   // If no type specifier was provided and we're parsing a language where
1275   // the type specifier is not optional, but we got 'auto' as a storage
1276   // class specifier, then assume this is an attempt to use C++0x's 'auto'
1277   // type specifier.
1278   if (S.getLangOpts().CPlusPlus &&
1279       TypeSpecType == TST_unspecified && StorageClassSpec == SCS_auto) {
1280     TypeSpecType = TST_auto;
1281     StorageClassSpec = SCS_unspecified;
1282     TSTLoc = TSTNameLoc = StorageClassSpecLoc;
1283     StorageClassSpecLoc = SourceLocation();
1284   }
1285   // Diagnose if we've recovered from an ill-formed 'auto' storage class
1286   // specifier in a pre-C++11 dialect of C++.
1287   if (!S.getLangOpts().CPlusPlus11 && TypeSpecType == TST_auto)
1288     S.Diag(TSTLoc, diag::ext_auto_type_specifier);
1289   if (S.getLangOpts().CPlusPlus && !S.getLangOpts().CPlusPlus11 &&
1290       StorageClassSpec == SCS_auto)
1291     S.Diag(StorageClassSpecLoc, diag::warn_auto_storage_class)
1292       << FixItHint::CreateRemoval(StorageClassSpecLoc);
1293   if (TypeSpecType == TST_char8)
1294     S.Diag(TSTLoc, diag::warn_cxx17_compat_unicode_type);
1295   else if (TypeSpecType == TST_char16 || TypeSpecType == TST_char32)
1296     S.Diag(TSTLoc, diag::warn_cxx98_compat_unicode_type)
1297       << (TypeSpecType == TST_char16 ? "char16_t" : "char32_t");
1298   if (getConstexprSpecifier() == CSK_constexpr)
1299     S.Diag(ConstexprLoc, diag::warn_cxx98_compat_constexpr);
1300   else if (getConstexprSpecifier() == CSK_consteval)
1301     S.Diag(ConstexprLoc, diag::warn_cxx20_compat_consteval);
1302   else if (getConstexprSpecifier() == CSK_constinit)
1303     S.Diag(ConstexprLoc, diag::warn_cxx20_compat_constinit);
1304   // C++ [class.friend]p6:
1305   //   No storage-class-specifier shall appear in the decl-specifier-seq
1306   //   of a friend declaration.
1307   if (isFriendSpecified() &&
1308       (getStorageClassSpec() || getThreadStorageClassSpec())) {
1309     SmallString<32> SpecName;
1310     SourceLocation SCLoc;
1311     FixItHint StorageHint, ThreadHint;
1312 
1313     if (DeclSpec::SCS SC = getStorageClassSpec()) {
1314       SpecName = getSpecifierName(SC);
1315       SCLoc = getStorageClassSpecLoc();
1316       StorageHint = FixItHint::CreateRemoval(SCLoc);
1317     }
1318 
1319     if (DeclSpec::TSCS TSC = getThreadStorageClassSpec()) {
1320       if (!SpecName.empty()) SpecName += " ";
1321       SpecName += getSpecifierName(TSC);
1322       SCLoc = getThreadStorageClassSpecLoc();
1323       ThreadHint = FixItHint::CreateRemoval(SCLoc);
1324     }
1325 
1326     S.Diag(SCLoc, diag::err_friend_decl_spec)
1327       << SpecName << StorageHint << ThreadHint;
1328 
1329     ClearStorageClassSpecs();
1330   }
1331 
1332   // C++11 [dcl.fct.spec]p5:
1333   //   The virtual specifier shall be used only in the initial
1334   //   declaration of a non-static class member function;
1335   // C++11 [dcl.fct.spec]p6:
1336   //   The explicit specifier shall be used only in the declaration of
1337   //   a constructor or conversion function within its class
1338   //   definition;
1339   if (isFriendSpecified() && (isVirtualSpecified() || hasExplicitSpecifier())) {
1340     StringRef Keyword;
1341     FixItHint Hint;
1342     SourceLocation SCLoc;
1343 
1344     if (isVirtualSpecified()) {
1345       Keyword = "virtual";
1346       SCLoc = getVirtualSpecLoc();
1347       Hint = FixItHint::CreateRemoval(SCLoc);
1348     } else {
1349       Keyword = "explicit";
1350       SCLoc = getExplicitSpecLoc();
1351       Hint = FixItHint::CreateRemoval(getExplicitSpecRange());
1352     }
1353 
1354     S.Diag(SCLoc, diag::err_friend_decl_spec)
1355       << Keyword << Hint;
1356 
1357     FS_virtual_specified = false;
1358     FS_explicit_specifier = ExplicitSpecifier();
1359     FS_virtualLoc = FS_explicitLoc = SourceLocation();
1360   }
1361 
1362   assert(!TypeSpecOwned || isDeclRep((TST) TypeSpecType));
1363 
1364   // Okay, now we can infer the real type.
1365 
1366   // TODO: return "auto function" and other bad things based on the real type.
1367 
1368   // 'data definition has no type or storage class'?
1369 }
1370 
1371 bool DeclSpec::isMissingDeclaratorOk() {
1372   TST tst = getTypeSpecType();
1373   return isDeclRep(tst) && getRepAsDecl() != nullptr &&
1374     StorageClassSpec != DeclSpec::SCS_typedef;
1375 }
1376 
1377 void UnqualifiedId::setOperatorFunctionId(SourceLocation OperatorLoc,
1378                                           OverloadedOperatorKind Op,
1379                                           SourceLocation SymbolLocations[3]) {
1380   Kind = UnqualifiedIdKind::IK_OperatorFunctionId;
1381   StartLocation = OperatorLoc;
1382   EndLocation = OperatorLoc;
1383   OperatorFunctionId.Operator = Op;
1384   for (unsigned I = 0; I != 3; ++I) {
1385     OperatorFunctionId.SymbolLocations[I] = SymbolLocations[I].getRawEncoding();
1386 
1387     if (SymbolLocations[I].isValid())
1388       EndLocation = SymbolLocations[I];
1389   }
1390 }
1391 
1392 bool VirtSpecifiers::SetSpecifier(Specifier VS, SourceLocation Loc,
1393                                   const char *&PrevSpec) {
1394   if (!FirstLocation.isValid())
1395     FirstLocation = Loc;
1396   LastLocation = Loc;
1397   LastSpecifier = VS;
1398 
1399   if (Specifiers & VS) {
1400     PrevSpec = getSpecifierName(VS);
1401     return true;
1402   }
1403 
1404   Specifiers |= VS;
1405 
1406   switch (VS) {
1407   default: llvm_unreachable("Unknown specifier!");
1408   case VS_Override: VS_overrideLoc = Loc; break;
1409   case VS_GNU_Final:
1410   case VS_Sealed:
1411   case VS_Final:    VS_finalLoc = Loc; break;
1412   }
1413 
1414   return false;
1415 }
1416 
1417 const char *VirtSpecifiers::getSpecifierName(Specifier VS) {
1418   switch (VS) {
1419   default: llvm_unreachable("Unknown specifier");
1420   case VS_Override: return "override";
1421   case VS_Final: return "final";
1422   case VS_GNU_Final: return "__final";
1423   case VS_Sealed: return "sealed";
1424   }
1425 }
1426