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