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