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