contrib/llvm-project/clang/lib/Sema/DeclSpec.cpp

   1 //===--- DeclSpec.cpp - Declaration Specifier Semantic Analysis -----------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 //
   9 //  This file implements semantic analysis for declaration specifiers.
  10 //
  11 //===----------------------------------------------------------------------===//
  12
  13 #include "clang/Sema/DeclSpec.h"
  14 #include "clang/AST/ASTContext.h"
  15 #include "clang/AST/DeclCXX.h"
  16 #include "clang/AST/Expr.h"
  17 #include "clang/AST/LocInfoType.h"
  18 #include "clang/AST/TypeLoc.h"
  19 #include "clang/Basic/LangOptions.h"
  20 #include "clang/Basic/TargetInfo.h"
  21 #include "clang/Sema/ParsedTemplate.h"
  22 #include "clang/Sema/Sema.h"
  23 #include "clang/Sema/SemaDiagnostic.h"
  24 #include "llvm/ADT/STLExtras.h"
  25 #include "llvm/ADT/SmallString.h"
  26 #include <cstring>
  27 using namespace clang;
  28
  29
  30 void UnqualifiedId::setTemplateId(TemplateIdAnnotation *TemplateId) {
  31   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,
 788                                const char *&PrevSpec,
 789                                unsigned &DiagID,
 790                                const PrintingPolicy &Policy) {
 791   assert(!isDeclRep(T) && !isTypeRep(T) && !isExprRep(T) &&
 792          "rep required for these type-spec kinds!");
 793   if (TypeSpecType == TST_error)
 794     return false;
 795   if (TypeSpecType != TST_unspecified) {
 796     PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType, Policy);
 797     DiagID = diag::err_invalid_decl_spec_combination;
 798     return true;
 799   }
 800   TSTLoc = Loc;
 801   TSTNameLoc = Loc;
 802   if (TypeAltiVecVector && (T == TST_bool) && !TypeAltiVecBool) {
 803     TypeAltiVecBool = true;
 804     return false;
 805   }
 806   TypeSpecType = T;
 807   TypeSpecOwned = false;
 808   return false;
 809 }
 810
 811 bool DeclSpec::SetTypeSpecSat(SourceLocation Loc, const char *&PrevSpec,
 812                               unsigned &DiagID) {
 813   // Cannot set twice
 814   if (TypeSpecSat) {
 815     DiagID = diag::warn_duplicate_declspec;
 816     PrevSpec = "_Sat";
 817     return true;
 818   }
 819   TypeSpecSat = true;
 820   TSSatLoc = Loc;
 821   return false;
 822 }
 823
 824 bool DeclSpec::SetTypeAltiVecVector(bool isAltiVecVector, SourceLocation Loc,
 825                           const char *&PrevSpec, unsigned &DiagID,
 826                           const PrintingPolicy &Policy) {
 827   if (TypeSpecType == TST_error)
 828     return false;
 829   if (TypeSpecType != TST_unspecified) {
 830     PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType, Policy);
 831     DiagID = diag::err_invalid_vector_decl_spec_combination;
 832     return true;
 833   }
 834   TypeAltiVecVector = isAltiVecVector;
 835   AltiVecLoc = Loc;
 836   return false;
 837 }
 838
 839 bool DeclSpec::SetTypePipe(bool isPipe, SourceLocation Loc,
 840                            const char *&PrevSpec, unsigned &DiagID,
 841                            const PrintingPolicy &Policy) {
 842   if (TypeSpecType == TST_error)
 843     return false;
 844   if (TypeSpecType != TST_unspecified) {
 845     PrevSpec = DeclSpec::getSpecifierName((TST)TypeSpecType, Policy);
 846     DiagID = diag::err_invalid_decl_spec_combination;
 847     return true;
 848   }
 849
 850   if (isPipe) {
 851     TypeSpecPipe = TSP_pipe;
 852   }
 853   return false;
 854 }
 855
 856 bool DeclSpec::SetTypeAltiVecPixel(bool isAltiVecPixel, SourceLocation Loc,
 857                           const char *&PrevSpec, unsigned &DiagID,
 858                           const PrintingPolicy &Policy) {
 859   if (TypeSpecType == TST_error)
 860     return false;
 861   if (!TypeAltiVecVector || TypeAltiVecPixel ||
 862       (TypeSpecType != TST_unspecified)) {
 863     PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType, Policy);
 864     DiagID = diag::err_invalid_pixel_decl_spec_combination;
 865     return true;
 866   }
 867   TypeAltiVecPixel = isAltiVecPixel;
 868   TSTLoc = Loc;
 869   TSTNameLoc = Loc;
 870   return false;
 871 }
 872
 873 bool DeclSpec::SetTypeAltiVecBool(bool isAltiVecBool, SourceLocation Loc,
 874                                   const char *&PrevSpec, unsigned &DiagID,
 875                                   const PrintingPolicy &Policy) {
 876   if (TypeSpecType == TST_error)
 877     return false;
 878   if (!TypeAltiVecVector || TypeAltiVecBool ||
 879       (TypeSpecType != TST_unspecified)) {
 880     PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType, Policy);
 881     DiagID = diag::err_invalid_vector_bool_decl_spec;
 882     return true;
 883   }
 884   TypeAltiVecBool = isAltiVecBool;
 885   TSTLoc = Loc;
 886   TSTNameLoc = Loc;
 887   return false;
 888 }
 889
 890 bool DeclSpec::SetTypeSpecError() {
 891   TypeSpecType = TST_error;
 892   TypeSpecOwned = false;
 893   TSTLoc = SourceLocation();
 894   TSTNameLoc = SourceLocation();
 895   return false;
 896 }
 897
 898 bool DeclSpec::SetTypeQual(TQ T, SourceLocation Loc, const char *&PrevSpec,
 899                            unsigned &DiagID, const LangOptions &Lang) {
 900   // Duplicates are permitted in C99 onwards, but are not permitted in C89 or
 901   // C++.  However, since this is likely not what the user intended, we will
 902   // always warn.  We do not need to set the qualifier's location since we
 903   // already have it.
 904   if (TypeQualifiers & T) {
 905     bool IsExtension = true;
 906     if (Lang.C99)
 907       IsExtension = false;
 908     return BadSpecifier(T, T, PrevSpec, DiagID, IsExtension);
 909   }
 910
 911   return SetTypeQual(T, Loc);
 912 }
 913
 914 bool DeclSpec::SetTypeQual(TQ T, SourceLocation Loc) {
 915   TypeQualifiers |= T;
 916
 917   switch (T) {
 918   case TQ_unspecified: break;
 919   case TQ_const:    TQ_constLoc = Loc; return false;
 920   case TQ_restrict: TQ_restrictLoc = Loc; return false;
 921   case TQ_volatile: TQ_volatileLoc = Loc; return false;
 922   case TQ_unaligned: TQ_unalignedLoc = Loc; return false;
 923   case TQ_atomic:   TQ_atomicLoc = Loc; return false;
 924   }
 925
 926   llvm_unreachable("Unknown type qualifier!");
 927 }
 928
 929 bool DeclSpec::setFunctionSpecInline(SourceLocation Loc, const char *&PrevSpec,
 930                                      unsigned &DiagID) {
 931   // 'inline inline' is ok.  However, since this is likely not what the user
 932   // intended, we will always warn, similar to duplicates of type qualifiers.
 933   if (FS_inline_specified) {
 934     DiagID = diag::warn_duplicate_declspec;
 935     PrevSpec = "inline";
 936     return true;
 937   }
 938   FS_inline_specified = true;
 939   FS_inlineLoc = Loc;
 940   return false;
 941 }
 942
 943 bool DeclSpec::setFunctionSpecForceInline(SourceLocation Loc, const char *&PrevSpec,
 944                                           unsigned &DiagID) {
 945   if (FS_forceinline_specified) {
 946     DiagID = diag::warn_duplicate_declspec;
 947     PrevSpec = "__forceinline";
 948     return true;
 949   }
 950   FS_forceinline_specified = true;
 951   FS_forceinlineLoc = Loc;
 952   return false;
 953 }
 954
 955 bool DeclSpec::setFunctionSpecVirtual(SourceLocation Loc,
 956                                       const char *&PrevSpec,
 957                                       unsigned &DiagID) {
 958   // 'virtual virtual' is ok, but warn as this is likely not what the user
 959   // intended.
 960   if (FS_virtual_specified) {
 961     DiagID = diag::warn_duplicate_declspec;
 962     PrevSpec = "virtual";
 963     return true;
 964   }
 965   FS_virtual_specified = true;
 966   FS_virtualLoc = Loc;
 967   return false;
 968 }
 969
 970 bool DeclSpec::setFunctionSpecExplicit(SourceLocation Loc,
 971                                        const char *&PrevSpec, unsigned &DiagID,
 972                                        ExplicitSpecifier ExplicitSpec,
 973                                        SourceLocation CloseParenLoc) {
 974   assert((ExplicitSpec.getKind() == ExplicitSpecKind::ResolvedTrue ||
 975           ExplicitSpec.getExpr()) &&
 976          "invalid ExplicitSpecifier");
 977   // 'explicit explicit' is ok, but warn as this is likely not what the user
 978   // intended.
 979   if (hasExplicitSpecifier()) {
 980     DiagID = (ExplicitSpec.getExpr() || FS_explicit_specifier.getExpr())
 981                  ? diag::err_duplicate_declspec
 982                  : diag::ext_warn_duplicate_declspec;
 983     PrevSpec = "explicit";
 984     return true;
 985   }
 986   FS_explicit_specifier = ExplicitSpec;
 987   FS_explicitLoc = Loc;
 988   FS_explicitCloseParenLoc = CloseParenLoc;
 989   return false;
 990 }
 991
 992 bool DeclSpec::setFunctionSpecNoreturn(SourceLocation Loc,
 993                                        const char *&PrevSpec,
 994                                        unsigned &DiagID) {
 995   // '_Noreturn _Noreturn' is ok, but warn as this is likely not what the user
 996   // intended.
 997   if (FS_noreturn_specified) {
 998     DiagID = diag::warn_duplicate_declspec;
 999     PrevSpec = "_Noreturn";
1000     return true;
1001   }
1002   FS_noreturn_specified = true;
1003   FS_noreturnLoc = Loc;
1004   return false;
1005 }
1006
1007 bool DeclSpec::SetFriendSpec(SourceLocation Loc, const char *&PrevSpec,
1008                              unsigned &DiagID) {
1009   if (Friend_specified) {
1010     PrevSpec = "friend";
1011     // Keep the later location, so that we can later diagnose ill-formed
1012     // declarations like 'friend class X friend;'. Per [class.friend]p3,
1013     // 'friend' must be the first token in a friend declaration that is
1014     // not a function declaration.
1015     FriendLoc = Loc;
1016     DiagID = diag::warn_duplicate_declspec;
1017     return true;
1018   }
1019
1020   Friend_specified = true;
1021   FriendLoc = Loc;
1022   return false;
1023 }
1024
1025 bool DeclSpec::setModulePrivateSpec(SourceLocation Loc, const char *&PrevSpec,
1026                                     unsigned &DiagID) {
1027   if (isModulePrivateSpecified()) {
1028     PrevSpec = "__module_private__";
1029     DiagID = diag::ext_warn_duplicate_declspec;
1030     return true;
1031   }
1032
1033   ModulePrivateLoc = Loc;
1034   return false;
1035 }
1036
1037 bool DeclSpec::SetConstexprSpec(ConstexprSpecKind ConstexprKind,
1038                                 SourceLocation Loc, const char *&PrevSpec,
1039                                 unsigned &DiagID) {
1040   if (getConstexprSpecifier() != CSK_unspecified)
1041     return BadSpecifier(ConstexprKind, getConstexprSpecifier(), PrevSpec,
1042                         DiagID);
1043   ConstexprSpecifier = ConstexprKind;
1044   ConstexprLoc = Loc;
1045   return false;
1046 }
1047
1048 void DeclSpec::SaveWrittenBuiltinSpecs() {
1049   writtenBS.Sign = getTypeSpecSign();
1050   writtenBS.Width = getTypeSpecWidth();
1051   writtenBS.Type = getTypeSpecType();
1052   // Search the list of attributes for the presence of a mode attribute.
1053   writtenBS.ModeAttr = getAttributes().hasAttribute(ParsedAttr::AT_Mode);
1054 }
1055
1056 /// Finish - This does final analysis of the declspec, rejecting things like
1057 /// "_Imaginary" (lacking an FP type).  This returns a diagnostic to issue or
1058 /// diag::NUM_DIAGNOSTICS if there is no error.  After calling this method,
1059 /// DeclSpec is guaranteed self-consistent, even if an error occurred.
1060 void DeclSpec::Finish(Sema &S, const PrintingPolicy &Policy) {
1061   // Before possibly changing their values, save specs as written.
1062   SaveWrittenBuiltinSpecs();
1063
1064   // Check the type specifier components first. No checking for an invalid
1065   // type.
1066   if (TypeSpecType == TST_error)
1067     return;
1068
1069   // If decltype(auto) is used, no other type specifiers are permitted.
1070   if (TypeSpecType == TST_decltype_auto &&
1071       (TypeSpecWidth != TSW_unspecified ||
1072        TypeSpecComplex != TSC_unspecified ||
1073        TypeSpecSign != TSS_unspecified ||
1074        TypeAltiVecVector || TypeAltiVecPixel || TypeAltiVecBool ||
1075        TypeQualifiers)) {
1076     const unsigned NumLocs = 9;
1077     SourceLocation ExtraLocs[NumLocs] = {
1078         TSWRange.getBegin(), TSCLoc,       TSSLoc,
1079         AltiVecLoc,          TQ_constLoc,  TQ_restrictLoc,
1080         TQ_volatileLoc,      TQ_atomicLoc, TQ_unalignedLoc};
1081     FixItHint Hints[NumLocs];
1082     SourceLocation FirstLoc;
1083     for (unsigned I = 0; I != NumLocs; ++I) {
1084       if (ExtraLocs[I].isValid()) {
1085         if (FirstLoc.isInvalid() ||
1086             S.getSourceManager().isBeforeInTranslationUnit(ExtraLocs[I],
1087                                                            FirstLoc))
1088           FirstLoc = ExtraLocs[I];
1089         Hints[I] = FixItHint::CreateRemoval(ExtraLocs[I]);
1090       }
1091     }
1092     TypeSpecWidth = TSW_unspecified;
1093     TypeSpecComplex = TSC_unspecified;
1094     TypeSpecSign = TSS_unspecified;
1095     TypeAltiVecVector = TypeAltiVecPixel = TypeAltiVecBool = false;
1096     TypeQualifiers = 0;
1097     S.Diag(TSTLoc, diag::err_decltype_auto_cannot_be_combined)
1098       << Hints[0] << Hints[1] << Hints[2] << Hints[3]
1099       << Hints[4] << Hints[5] << Hints[6] << Hints[7];
1100   }
1101
1102   // Validate and finalize AltiVec vector declspec.
1103   if (TypeAltiVecVector) {
1104     if (TypeAltiVecBool) {
1105       // Sign specifiers are not allowed with vector bool. (PIM 2.1)
1106       if (TypeSpecSign != TSS_unspecified) {
1107         S.Diag(TSSLoc, diag::err_invalid_vector_bool_decl_spec)
1108           << getSpecifierName((TSS)TypeSpecSign);
1109       }
1110
1111       // Only char/int are valid with vector bool. (PIM 2.1)
1112       if (((TypeSpecType != TST_unspecified) && (TypeSpecType != TST_char) &&
1113            (TypeSpecType != TST_int)) || TypeAltiVecPixel) {
1114         S.Diag(TSTLoc, diag::err_invalid_vector_bool_decl_spec)
1115           << (TypeAltiVecPixel ? "__pixel" :
1116                                  getSpecifierName((TST)TypeSpecType, Policy));
1117       }
1118
1119       // Only 'short' and 'long long' are valid with vector bool. (PIM 2.1)
1120       if ((TypeSpecWidth != TSW_unspecified) && (TypeSpecWidth != TSW_short) &&
1121           (TypeSpecWidth != TSW_longlong))
1122         S.Diag(TSWRange.getBegin(), diag::err_invalid_vector_bool_decl_spec)
1123             << getSpecifierName((TSW)TypeSpecWidth);
1124
1125       // vector bool long long requires VSX support or ZVector.
1126       if ((TypeSpecWidth == TSW_longlong) &&
1127           (!S.Context.getTargetInfo().hasFeature("vsx")) &&
1128           (!S.Context.getTargetInfo().hasFeature("power8-vector")) &&
1129           !S.getLangOpts().ZVector)
1130         S.Diag(TSTLoc, diag::err_invalid_vector_long_long_decl_spec);
1131
1132       // Elements of vector bool are interpreted as unsigned. (PIM 2.1)
1133       if ((TypeSpecType == TST_char) || (TypeSpecType == TST_int) ||
1134           (TypeSpecWidth != TSW_unspecified))
1135         TypeSpecSign = TSS_unsigned;
1136     } else if (TypeSpecType == TST_double) {
1137       // vector long double and vector long long double are never allowed.
1138       // vector double is OK for Power7 and later, and ZVector.
1139       if (TypeSpecWidth == TSW_long || TypeSpecWidth == TSW_longlong)
1140         S.Diag(TSWRange.getBegin(),
1141                diag::err_invalid_vector_long_double_decl_spec);
1142       else if (!S.Context.getTargetInfo().hasFeature("vsx") &&
1143                !S.getLangOpts().ZVector)
1144         S.Diag(TSTLoc, diag::err_invalid_vector_double_decl_spec);
1145     } else if (TypeSpecType == TST_float) {
1146       // vector float is unsupported for ZVector unless we have the
1147       // vector-enhancements facility 1 (ISA revision 12).
1148       if (S.getLangOpts().ZVector &&
1149           !S.Context.getTargetInfo().hasFeature("arch12"))
1150         S.Diag(TSTLoc, diag::err_invalid_vector_float_decl_spec);
1151     } else if (TypeSpecWidth == TSW_long) {
1152       // vector long is unsupported for ZVector and deprecated for AltiVec.
1153       if (S.getLangOpts().ZVector)
1154         S.Diag(TSWRange.getBegin(), diag::err_invalid_vector_long_decl_spec);
1155       else
1156         S.Diag(TSWRange.getBegin(),
1157                diag::warn_vector_long_decl_spec_combination)
1158             << getSpecifierName((TST)TypeSpecType, Policy);
1159     }
1160
1161     if (TypeAltiVecPixel) {
1162       //TODO: perform validation
1163       TypeSpecType = TST_int;
1164       TypeSpecSign = TSS_unsigned;
1165       TypeSpecWidth = TSW_short;
1166       TypeSpecOwned = false;
1167     }
1168   }
1169
1170   bool IsFixedPointType =
1171       TypeSpecType == TST_accum || TypeSpecType == TST_fract;
1172
1173   // signed/unsigned are only valid with int/char/wchar_t/_Accum.
1174   if (TypeSpecSign != TSS_unspecified) {
1175     if (TypeSpecType == TST_unspecified)
1176       TypeSpecType = TST_int; // unsigned -> unsigned int, signed -> signed int.
1177     else if (TypeSpecType != TST_int && TypeSpecType != TST_int128 &&
1178              TypeSpecType != TST_char && TypeSpecType != TST_wchar &&
1179              !IsFixedPointType) {
1180       S.Diag(TSSLoc, diag::err_invalid_sign_spec)
1181         << getSpecifierName((TST)TypeSpecType, Policy);
1182       // signed double -> double.
1183       TypeSpecSign = TSS_unspecified;
1184     }
1185   }
1186
1187   // Validate the width of the type.
1188   switch (TypeSpecWidth) {
1189   case TSW_unspecified: break;
1190   case TSW_short:    // short int
1191   case TSW_longlong: // long long int
1192     if (TypeSpecType == TST_unspecified)
1193       TypeSpecType = TST_int; // short -> short int, long long -> long long int.
1194     else if (!(TypeSpecType == TST_int ||
1195                (IsFixedPointType && TypeSpecWidth != TSW_longlong))) {
1196       S.Diag(TSWRange.getBegin(), diag::err_invalid_width_spec)
1197           << (int)TypeSpecWidth << getSpecifierName((TST)TypeSpecType, Policy);
1198       TypeSpecType = TST_int;
1199       TypeSpecSat = false;
1200       TypeSpecOwned = false;
1201     }
1202     break;
1203   case TSW_long:  // long double, long int
1204     if (TypeSpecType == TST_unspecified)
1205       TypeSpecType = TST_int;  // long -> long int.
1206     else if (TypeSpecType != TST_int && TypeSpecType != TST_double &&
1207              !IsFixedPointType) {
1208       S.Diag(TSWRange.getBegin(), diag::err_invalid_width_spec)
1209           << (int)TypeSpecWidth << getSpecifierName((TST)TypeSpecType, Policy);
1210       TypeSpecType = TST_int;
1211       TypeSpecSat = false;
1212       TypeSpecOwned = false;
1213     }
1214     break;
1215   }
1216
1217   // TODO: if the implementation does not implement _Complex or _Imaginary,
1218   // disallow their use.  Need information about the backend.
1219   if (TypeSpecComplex != TSC_unspecified) {
1220     if (TypeSpecType == TST_unspecified) {
1221       S.Diag(TSCLoc, diag::ext_plain_complex)
1222         << FixItHint::CreateInsertion(
1223                               S.getLocForEndOfToken(getTypeSpecComplexLoc()),
1224                                                  " double");
1225       TypeSpecType = TST_double;   // _Complex -> _Complex double.
1226     } else if (TypeSpecType == TST_int || TypeSpecType == TST_char) {
1227       // Note that this intentionally doesn't include _Complex _Bool.
1228       if (!S.getLangOpts().CPlusPlus)
1229         S.Diag(TSTLoc, diag::ext_integer_complex);
1230     } else if (TypeSpecType != TST_float && TypeSpecType != TST_double) {
1231       S.Diag(TSCLoc, diag::err_invalid_complex_spec)
1232         << getSpecifierName((TST)TypeSpecType, Policy);
1233       TypeSpecComplex = TSC_unspecified;
1234     }
1235   }
1236
1237   // C11 6.7.1/3, C++11 [dcl.stc]p1, GNU TLS: __thread, thread_local and
1238   // _Thread_local can only appear with the 'static' and 'extern' storage class
1239   // specifiers. We also allow __private_extern__ as an extension.
1240   if (ThreadStorageClassSpec != TSCS_unspecified) {
1241     switch (StorageClassSpec) {
1242     case SCS_unspecified:
1243     case SCS_extern:
1244     case SCS_private_extern:
1245     case SCS_static:
1246       break;
1247     default:
1248       if (S.getSourceManager().isBeforeInTranslationUnit(
1249             getThreadStorageClassSpecLoc(), getStorageClassSpecLoc()))
1250         S.Diag(getStorageClassSpecLoc(),
1251              diag::err_invalid_decl_spec_combination)
1252           << DeclSpec::getSpecifierName(getThreadStorageClassSpec())
1253           << SourceRange(getThreadStorageClassSpecLoc());
1254       else
1255         S.Diag(getThreadStorageClassSpecLoc(),
1256              diag::err_invalid_decl_spec_combination)
1257           << DeclSpec::getSpecifierName(getStorageClassSpec())
1258           << SourceRange(getStorageClassSpecLoc());
1259       // Discard the thread storage class specifier to recover.
1260       ThreadStorageClassSpec = TSCS_unspecified;
1261       ThreadStorageClassSpecLoc = SourceLocation();
1262     }
1263   }
1264
1265   // If no type specifier was provided and we're parsing a language where
1266   // the type specifier is not optional, but we got 'auto' as a storage
1267   // class specifier, then assume this is an attempt to use C++0x's 'auto'
1268   // type specifier.
1269   if (S.getLangOpts().CPlusPlus &&
1270       TypeSpecType == TST_unspecified && StorageClassSpec == SCS_auto) {
1271     TypeSpecType = TST_auto;
1272     StorageClassSpec = SCS_unspecified;
1273     TSTLoc = TSTNameLoc = StorageClassSpecLoc;
1274     StorageClassSpecLoc = SourceLocation();
1275   }
1276   // Diagnose if we've recovered from an ill-formed 'auto' storage class
1277   // specifier in a pre-C++11 dialect of C++.
1278   if (!S.getLangOpts().CPlusPlus11 && TypeSpecType == TST_auto)
1279     S.Diag(TSTLoc, diag::ext_auto_type_specifier);
1280   if (S.getLangOpts().CPlusPlus && !S.getLangOpts().CPlusPlus11 &&
1281       StorageClassSpec == SCS_auto)
1282     S.Diag(StorageClassSpecLoc, diag::warn_auto_storage_class)
1283       << FixItHint::CreateRemoval(StorageClassSpecLoc);
1284   if (TypeSpecType == TST_char8)
1285     S.Diag(TSTLoc, diag::warn_cxx17_compat_unicode_type);
1286   else if (TypeSpecType == TST_char16 || TypeSpecType == TST_char32)
1287     S.Diag(TSTLoc, diag::warn_cxx98_compat_unicode_type)
1288       << (TypeSpecType == TST_char16 ? "char16_t" : "char32_t");
1289   if (getConstexprSpecifier() == CSK_constexpr)
1290     S.Diag(ConstexprLoc, diag::warn_cxx98_compat_constexpr);
1291   else if (getConstexprSpecifier() == CSK_consteval)
1292     S.Diag(ConstexprLoc, diag::warn_cxx20_compat_consteval);
1293   else if (getConstexprSpecifier() == CSK_constinit)
1294     S.Diag(ConstexprLoc, diag::warn_cxx20_compat_constinit);
1295   // C++ [class.friend]p6:
1296   //   No storage-class-specifier shall appear in the decl-specifier-seq
1297   //   of a friend declaration.
1298   if (isFriendSpecified() &&
1299       (getStorageClassSpec() || getThreadStorageClassSpec())) {
1300     SmallString<32> SpecName;
1301     SourceLocation SCLoc;
1302     FixItHint StorageHint, ThreadHint;
1303
1304     if (DeclSpec::SCS SC = getStorageClassSpec()) {
1305       SpecName = getSpecifierName(SC);
1306       SCLoc = getStorageClassSpecLoc();
1307       StorageHint = FixItHint::CreateRemoval(SCLoc);
1308     }
1309
1310     if (DeclSpec::TSCS TSC = getThreadStorageClassSpec()) {
1311       if (!SpecName.empty()) SpecName += " ";
1312       SpecName += getSpecifierName(TSC);
1313       SCLoc = getThreadStorageClassSpecLoc();
1314       ThreadHint = FixItHint::CreateRemoval(SCLoc);
1315     }
1316
1317     S.Diag(SCLoc, diag::err_friend_decl_spec)
1318       << SpecName << StorageHint << ThreadHint;
1319
1320     ClearStorageClassSpecs();
1321   }
1322
1323   // C++11 [dcl.fct.spec]p5:
1324   //   The virtual specifier shall be used only in the initial
1325   //   declaration of a non-static class member function;
1326   // C++11 [dcl.fct.spec]p6:
1327   //   The explicit specifier shall be used only in the declaration of
1328   //   a constructor or conversion function within its class
1329   //   definition;
1330   if (isFriendSpecified() && (isVirtualSpecified() || hasExplicitSpecifier())) {
1331     StringRef Keyword;
1332     FixItHint Hint;
1333     SourceLocation SCLoc;
1334
1335     if (isVirtualSpecified()) {
1336       Keyword = "virtual";
1337       SCLoc = getVirtualSpecLoc();
1338       Hint = FixItHint::CreateRemoval(SCLoc);
1339     } else {
1340       Keyword = "explicit";
1341       SCLoc = getExplicitSpecLoc();
1342       Hint = FixItHint::CreateRemoval(getExplicitSpecRange());
1343     }
1344
1345     S.Diag(SCLoc, diag::err_friend_decl_spec)
1346       << Keyword << Hint;
1347
1348     FS_virtual_specified = false;
1349     FS_explicit_specifier = ExplicitSpecifier();
1350     FS_virtualLoc = FS_explicitLoc = SourceLocation();
1351   }
1352
1353   assert(!TypeSpecOwned || isDeclRep((TST) TypeSpecType));
1354
1355   // Okay, now we can infer the real type.
1356
1357   // TODO: return "auto function" and other bad things based on the real type.
1358
1359   // 'data definition has no type or storage class'?
1360 }
1361
1362 bool DeclSpec::isMissingDeclaratorOk() {
1363   TST tst = getTypeSpecType();
1364   return isDeclRep(tst) && getRepAsDecl() != nullptr &&
1365     StorageClassSpec != DeclSpec::SCS_typedef;
1366 }
1367
1368 void UnqualifiedId::setOperatorFunctionId(SourceLocation OperatorLoc,
1369                                           OverloadedOperatorKind Op,
1370                                           SourceLocation SymbolLocations[3]) {
1371   Kind = UnqualifiedIdKind::IK_OperatorFunctionId;
1372   StartLocation = OperatorLoc;
1373   EndLocation = OperatorLoc;
1374   OperatorFunctionId.Operator = Op;
1375   for (unsigned I = 0; I != 3; ++I) {
1376     OperatorFunctionId.SymbolLocations[I] = SymbolLocations[I].getRawEncoding();
1377
1378     if (SymbolLocations[I].isValid())
1379       EndLocation = SymbolLocations[I];
1380   }
1381 }
1382
1383 bool VirtSpecifiers::SetSpecifier(Specifier VS, SourceLocation Loc,
1384                                   const char *&PrevSpec) {
1385   if (!FirstLocation.isValid())
1386     FirstLocation = Loc;
1387   LastLocation = Loc;
1388   LastSpecifier = VS;
1389
1390   if (Specifiers & VS) {
1391     PrevSpec = getSpecifierName(VS);
1392     return true;
1393   }
1394
1395   Specifiers |= VS;
1396
1397   switch (VS) {
1398   default: llvm_unreachable("Unknown specifier!");
1399   case VS_Override: VS_overrideLoc = Loc; break;
1400   case VS_GNU_Final:
1401   case VS_Sealed:
1402   case VS_Final:    VS_finalLoc = Loc; break;
1403   }
1404
1405   return false;
1406 }
1407
1408 const char *VirtSpecifiers::getSpecifierName(Specifier VS) {
1409   switch (VS) {
1410   default: llvm_unreachable("Unknown specifier");
1411   case VS_Override: return "override";
1412   case VS_Final: return "final";
1413   case VS_GNU_Final: return "__final";
1414   case VS_Sealed: return "sealed";
1415   }
1416 }