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