contrib/llvm/tools/clang/lib/Sema/DeclSpec.cpp

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