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