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