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