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