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