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