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