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