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