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