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