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