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