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 v1.1 s6.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   // OpenCL v1.2 s6.8 changes this to "The auto and register storage-class
429   // specifiers are not supported."
430   if (S.getLangOpts().OpenCL &&
431       !S.getOpenCLOptions().cl_clang_storage_class_specifiers) {
432     switch (SC) {
433     case SCS_extern:
434     case SCS_private_extern:
435     case SCS_static:
436         if (S.getLangOpts().OpenCLVersion < 120) {
437           DiagID   = diag::err_not_opencl_storage_class_specifier;
438           PrevSpec = getSpecifierName(SC);
439           return true;
440         }
441         break;
442     case SCS_auto:
443     case SCS_register:
444       DiagID   = diag::err_not_opencl_storage_class_specifier;
445       PrevSpec = getSpecifierName(SC);
446       return true;
447     default:
448       break;
449     }
450   }
451 
452   if (StorageClassSpec != SCS_unspecified) {
453     // Maybe this is an attempt to use C++0x 'auto' outside of C++0x mode.
454     bool isInvalid = true;
455     if (TypeSpecType == TST_unspecified && S.getLangOpts().CPlusPlus) {
456       if (SC == SCS_auto)
457         return SetTypeSpecType(TST_auto, Loc, PrevSpec, DiagID);
458       if (StorageClassSpec == SCS_auto) {
459         isInvalid = SetTypeSpecType(TST_auto, StorageClassSpecLoc,
460                                     PrevSpec, DiagID);
461         assert(!isInvalid && "auto SCS -> TST recovery failed");
462       }
463     }
464 
465     // Changing storage class is allowed only if the previous one
466     // was the 'extern' that is part of a linkage specification and
467     // the new storage class is 'typedef'.
468     if (isInvalid &&
469         !(SCS_extern_in_linkage_spec &&
470           StorageClassSpec == SCS_extern &&
471           SC == SCS_typedef))
472       return BadSpecifier(SC, (SCS)StorageClassSpec, PrevSpec, DiagID);
473   }
474   StorageClassSpec = SC;
475   StorageClassSpecLoc = Loc;
476   assert((unsigned)SC == StorageClassSpec && "SCS constants overflow bitfield");
477   return false;
478 }
479 
480 bool DeclSpec::SetStorageClassSpecThread(SourceLocation Loc,
481                                          const char *&PrevSpec,
482                                          unsigned &DiagID) {
483   if (SCS_thread_specified) {
484     PrevSpec = "__thread";
485     DiagID = diag::ext_duplicate_declspec;
486     return true;
487   }
488   SCS_thread_specified = true;
489   SCS_threadLoc = Loc;
490   return false;
491 }
492 
493 /// These methods set the specified attribute of the DeclSpec, but return true
494 /// and ignore the request if invalid (e.g. "extern" then "auto" is
495 /// specified).
496 bool DeclSpec::SetTypeSpecWidth(TSW W, SourceLocation Loc,
497                                 const char *&PrevSpec,
498                                 unsigned &DiagID) {
499   // Overwrite TSWLoc only if TypeSpecWidth was unspecified, so that
500   // for 'long long' we will keep the source location of the first 'long'.
501   if (TypeSpecWidth == TSW_unspecified)
502     TSWLoc = Loc;
503   // Allow turning long -> long long.
504   else if (W != TSW_longlong || TypeSpecWidth != TSW_long)
505     return BadSpecifier(W, (TSW)TypeSpecWidth, PrevSpec, DiagID);
506   TypeSpecWidth = W;
507   if (TypeAltiVecVector && !TypeAltiVecBool &&
508       ((TypeSpecWidth == TSW_long) || (TypeSpecWidth == TSW_longlong))) {
509     PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType);
510     DiagID = diag::warn_vector_long_decl_spec_combination;
511     return true;
512   }
513   return false;
514 }
515 
516 bool DeclSpec::SetTypeSpecComplex(TSC C, SourceLocation Loc,
517                                   const char *&PrevSpec,
518                                   unsigned &DiagID) {
519   if (TypeSpecComplex != TSC_unspecified)
520     return BadSpecifier(C, (TSC)TypeSpecComplex, PrevSpec, DiagID);
521   TypeSpecComplex = C;
522   TSCLoc = Loc;
523   return false;
524 }
525 
526 bool DeclSpec::SetTypeSpecSign(TSS S, SourceLocation Loc,
527                                const char *&PrevSpec,
528                                unsigned &DiagID) {
529   if (TypeSpecSign != TSS_unspecified)
530     return BadSpecifier(S, (TSS)TypeSpecSign, PrevSpec, DiagID);
531   TypeSpecSign = S;
532   TSSLoc = Loc;
533   return false;
534 }
535 
536 bool DeclSpec::SetTypeSpecType(TST T, SourceLocation Loc,
537                                const char *&PrevSpec,
538                                unsigned &DiagID,
539                                ParsedType Rep) {
540   return SetTypeSpecType(T, Loc, Loc, PrevSpec, DiagID, Rep);
541 }
542 
543 bool DeclSpec::SetTypeSpecType(TST T, SourceLocation TagKwLoc,
544                                SourceLocation TagNameLoc,
545                                const char *&PrevSpec,
546                                unsigned &DiagID,
547                                ParsedType Rep) {
548   assert(isTypeRep(T) && "T does not store a type");
549   assert(Rep && "no type provided!");
550   if (TypeSpecType != TST_unspecified) {
551     PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType);
552     DiagID = diag::err_invalid_decl_spec_combination;
553     return true;
554   }
555   TypeSpecType = T;
556   TypeRep = Rep;
557   TSTLoc = TagKwLoc;
558   TSTNameLoc = TagNameLoc;
559   TypeSpecOwned = false;
560   return false;
561 }
562 
563 bool DeclSpec::SetTypeSpecType(TST T, SourceLocation Loc,
564                                const char *&PrevSpec,
565                                unsigned &DiagID,
566                                Expr *Rep) {
567   assert(isExprRep(T) && "T does not store an expr");
568   assert(Rep && "no expression provided!");
569   if (TypeSpecType != TST_unspecified) {
570     PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType);
571     DiagID = diag::err_invalid_decl_spec_combination;
572     return true;
573   }
574   TypeSpecType = T;
575   ExprRep = Rep;
576   TSTLoc = Loc;
577   TSTNameLoc = Loc;
578   TypeSpecOwned = false;
579   return false;
580 }
581 
582 bool DeclSpec::SetTypeSpecType(TST T, SourceLocation Loc,
583                                const char *&PrevSpec,
584                                unsigned &DiagID,
585                                Decl *Rep, bool Owned) {
586   return SetTypeSpecType(T, Loc, Loc, PrevSpec, DiagID, Rep, Owned);
587 }
588 
589 bool DeclSpec::SetTypeSpecType(TST T, SourceLocation TagKwLoc,
590                                SourceLocation TagNameLoc,
591                                const char *&PrevSpec,
592                                unsigned &DiagID,
593                                Decl *Rep, bool Owned) {
594   assert(isDeclRep(T) && "T does not store a decl");
595   // Unlike the other cases, we don't assert that we actually get a decl.
596 
597   if (TypeSpecType != TST_unspecified) {
598     PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType);
599     DiagID = diag::err_invalid_decl_spec_combination;
600     return true;
601   }
602   TypeSpecType = T;
603   DeclRep = Rep;
604   TSTLoc = TagKwLoc;
605   TSTNameLoc = TagNameLoc;
606   TypeSpecOwned = Owned;
607   return false;
608 }
609 
610 bool DeclSpec::SetTypeSpecType(TST T, SourceLocation Loc,
611                                const char *&PrevSpec,
612                                unsigned &DiagID) {
613   assert(!isDeclRep(T) && !isTypeRep(T) && !isExprRep(T) &&
614          "rep required for these type-spec kinds!");
615   if (TypeSpecType != TST_unspecified) {
616     PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType);
617     DiagID = diag::err_invalid_decl_spec_combination;
618     return true;
619   }
620   TSTLoc = Loc;
621   TSTNameLoc = Loc;
622   if (TypeAltiVecVector && (T == TST_bool) && !TypeAltiVecBool) {
623     TypeAltiVecBool = true;
624     return false;
625   }
626   TypeSpecType = T;
627   TypeSpecOwned = false;
628   if (TypeAltiVecVector && !TypeAltiVecBool && (TypeSpecType == TST_double)) {
629     PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType);
630     DiagID = diag::err_invalid_vector_decl_spec;
631     return true;
632   }
633   return false;
634 }
635 
636 bool DeclSpec::SetTypeAltiVecVector(bool isAltiVecVector, SourceLocation Loc,
637                           const char *&PrevSpec, unsigned &DiagID) {
638   if (TypeSpecType != TST_unspecified) {
639     PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType);
640     DiagID = diag::err_invalid_vector_decl_spec_combination;
641     return true;
642   }
643   TypeAltiVecVector = isAltiVecVector;
644   AltiVecLoc = Loc;
645   return false;
646 }
647 
648 bool DeclSpec::SetTypeAltiVecPixel(bool isAltiVecPixel, SourceLocation Loc,
649                           const char *&PrevSpec, unsigned &DiagID) {
650   if (!TypeAltiVecVector || TypeAltiVecPixel ||
651       (TypeSpecType != TST_unspecified)) {
652     PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType);
653     DiagID = diag::err_invalid_pixel_decl_spec_combination;
654     return true;
655   }
656   TypeAltiVecPixel = isAltiVecPixel;
657   TSTLoc = Loc;
658   TSTNameLoc = Loc;
659   return false;
660 }
661 
662 bool DeclSpec::SetTypeSpecError() {
663   TypeSpecType = TST_error;
664   TypeSpecOwned = false;
665   TSTLoc = SourceLocation();
666   TSTNameLoc = SourceLocation();
667   return false;
668 }
669 
670 bool DeclSpec::SetTypeQual(TQ T, SourceLocation Loc, const char *&PrevSpec,
671                            unsigned &DiagID, const LangOptions &Lang) {
672   // Duplicates turn into warnings pre-C99.
673   if ((TypeQualifiers & T) && !Lang.C99)
674     return BadSpecifier(T, T, PrevSpec, DiagID);
675   TypeQualifiers |= T;
676 
677   switch (T) {
678   default: llvm_unreachable("Unknown type qualifier!");
679   case TQ_const:    TQ_constLoc = Loc; break;
680   case TQ_restrict: TQ_restrictLoc = Loc; break;
681   case TQ_volatile: TQ_volatileLoc = Loc; break;
682   }
683   return false;
684 }
685 
686 bool DeclSpec::SetFunctionSpecInline(SourceLocation Loc, const char *&PrevSpec,
687                                      unsigned &DiagID) {
688   // 'inline inline' is ok.
689   FS_inline_specified = true;
690   FS_inlineLoc = Loc;
691   return false;
692 }
693 
694 bool DeclSpec::SetFunctionSpecVirtual(SourceLocation Loc, const char *&PrevSpec,
695                                       unsigned &DiagID) {
696   // 'virtual virtual' is ok.
697   FS_virtual_specified = true;
698   FS_virtualLoc = Loc;
699   return false;
700 }
701 
702 bool DeclSpec::SetFunctionSpecExplicit(SourceLocation Loc, const char *&PrevSpec,
703                                        unsigned &DiagID) {
704   // 'explicit explicit' is ok.
705   FS_explicit_specified = true;
706   FS_explicitLoc = Loc;
707   return false;
708 }
709 
710 bool DeclSpec::SetFriendSpec(SourceLocation Loc, const char *&PrevSpec,
711                              unsigned &DiagID) {
712   if (Friend_specified) {
713     PrevSpec = "friend";
714     DiagID = diag::ext_duplicate_declspec;
715     return true;
716   }
717 
718   Friend_specified = true;
719   FriendLoc = Loc;
720   return false;
721 }
722 
723 bool DeclSpec::setModulePrivateSpec(SourceLocation Loc, const char *&PrevSpec,
724                                     unsigned &DiagID) {
725   if (isModulePrivateSpecified()) {
726     PrevSpec = "__module_private__";
727     DiagID = diag::ext_duplicate_declspec;
728     return true;
729   }
730 
731   ModulePrivateLoc = Loc;
732   return false;
733 }
734 
735 bool DeclSpec::SetConstexprSpec(SourceLocation Loc, const char *&PrevSpec,
736                                 unsigned &DiagID) {
737   // 'constexpr constexpr' is ok.
738   Constexpr_specified = true;
739   ConstexprLoc = Loc;
740   return false;
741 }
742 
743 void DeclSpec::setProtocolQualifiers(Decl * const *Protos,
744                                      unsigned NP,
745                                      SourceLocation *ProtoLocs,
746                                      SourceLocation LAngleLoc) {
747   if (NP == 0) return;
748   ProtocolQualifiers = new Decl*[NP];
749   ProtocolLocs = new SourceLocation[NP];
750   memcpy((void*)ProtocolQualifiers, Protos, sizeof(Decl*)*NP);
751   memcpy(ProtocolLocs, ProtoLocs, sizeof(SourceLocation)*NP);
752   NumProtocolQualifiers = NP;
753   ProtocolLAngleLoc = LAngleLoc;
754 }
755 
756 void DeclSpec::SaveWrittenBuiltinSpecs() {
757   writtenBS.Sign = getTypeSpecSign();
758   writtenBS.Width = getTypeSpecWidth();
759   writtenBS.Type = getTypeSpecType();
760   // Search the list of attributes for the presence of a mode attribute.
761   writtenBS.ModeAttr = false;
762   AttributeList* attrs = getAttributes().getList();
763   while (attrs) {
764     if (attrs->getKind() == AttributeList::AT_Mode) {
765       writtenBS.ModeAttr = true;
766       break;
767     }
768     attrs = attrs->getNext();
769   }
770 }
771 
772 void DeclSpec::SaveStorageSpecifierAsWritten() {
773   if (SCS_extern_in_linkage_spec && StorageClassSpec == SCS_extern)
774     // If 'extern' is part of a linkage specification,
775     // then it is not a storage class "as written".
776     StorageClassSpecAsWritten = SCS_unspecified;
777   else
778     StorageClassSpecAsWritten = StorageClassSpec;
779 }
780 
781 /// Finish - This does final analysis of the declspec, rejecting things like
782 /// "_Imaginary" (lacking an FP type).  This returns a diagnostic to issue or
783 /// diag::NUM_DIAGNOSTICS if there is no error.  After calling this method,
784 /// DeclSpec is guaranteed self-consistent, even if an error occurred.
785 void DeclSpec::Finish(DiagnosticsEngine &D, Preprocessor &PP) {
786   // Before possibly changing their values, save specs as written.
787   SaveWrittenBuiltinSpecs();
788   SaveStorageSpecifierAsWritten();
789 
790   // Check the type specifier components first.
791 
792   // Validate and finalize AltiVec vector declspec.
793   if (TypeAltiVecVector) {
794     if (TypeAltiVecBool) {
795       // Sign specifiers are not allowed with vector bool. (PIM 2.1)
796       if (TypeSpecSign != TSS_unspecified) {
797         Diag(D, TSSLoc, diag::err_invalid_vector_bool_decl_spec)
798           << getSpecifierName((TSS)TypeSpecSign);
799       }
800 
801       // Only char/int are valid with vector bool. (PIM 2.1)
802       if (((TypeSpecType != TST_unspecified) && (TypeSpecType != TST_char) &&
803            (TypeSpecType != TST_int)) || TypeAltiVecPixel) {
804         Diag(D, TSTLoc, diag::err_invalid_vector_bool_decl_spec)
805           << (TypeAltiVecPixel ? "__pixel" :
806                                  getSpecifierName((TST)TypeSpecType));
807       }
808 
809       // Only 'short' is valid with vector bool. (PIM 2.1)
810       if ((TypeSpecWidth != TSW_unspecified) && (TypeSpecWidth != TSW_short))
811         Diag(D, TSWLoc, diag::err_invalid_vector_bool_decl_spec)
812           << getSpecifierName((TSW)TypeSpecWidth);
813 
814       // Elements of vector bool are interpreted as unsigned. (PIM 2.1)
815       if ((TypeSpecType == TST_char) || (TypeSpecType == TST_int) ||
816           (TypeSpecWidth != TSW_unspecified))
817         TypeSpecSign = TSS_unsigned;
818     }
819 
820     if (TypeAltiVecPixel) {
821       //TODO: perform validation
822       TypeSpecType = TST_int;
823       TypeSpecSign = TSS_unsigned;
824       TypeSpecWidth = TSW_short;
825       TypeSpecOwned = false;
826     }
827   }
828 
829   // signed/unsigned are only valid with int/char/wchar_t.
830   if (TypeSpecSign != TSS_unspecified) {
831     if (TypeSpecType == TST_unspecified)
832       TypeSpecType = TST_int; // unsigned -> unsigned int, signed -> signed int.
833     else if (TypeSpecType != TST_int  && TypeSpecType != TST_int128 &&
834              TypeSpecType != TST_char && TypeSpecType != TST_wchar) {
835       Diag(D, TSSLoc, diag::err_invalid_sign_spec)
836         << getSpecifierName((TST)TypeSpecType);
837       // signed double -> double.
838       TypeSpecSign = TSS_unspecified;
839     }
840   }
841 
842   // Validate the width of the type.
843   switch (TypeSpecWidth) {
844   case TSW_unspecified: break;
845   case TSW_short:    // short int
846   case TSW_longlong: // long long int
847     if (TypeSpecType == TST_unspecified)
848       TypeSpecType = TST_int; // short -> short int, long long -> long long int.
849     else if (TypeSpecType != TST_int) {
850       Diag(D, TSWLoc,
851            TypeSpecWidth == TSW_short ? diag::err_invalid_short_spec
852                                       : diag::err_invalid_longlong_spec)
853         <<  getSpecifierName((TST)TypeSpecType);
854       TypeSpecType = TST_int;
855       TypeSpecOwned = false;
856     }
857     break;
858   case TSW_long:  // long double, long int
859     if (TypeSpecType == TST_unspecified)
860       TypeSpecType = TST_int;  // long -> long int.
861     else if (TypeSpecType != TST_int && TypeSpecType != TST_double) {
862       Diag(D, TSWLoc, diag::err_invalid_long_spec)
863         << getSpecifierName((TST)TypeSpecType);
864       TypeSpecType = TST_int;
865       TypeSpecOwned = false;
866     }
867     break;
868   }
869 
870   // TODO: if the implementation does not implement _Complex or _Imaginary,
871   // disallow their use.  Need information about the backend.
872   if (TypeSpecComplex != TSC_unspecified) {
873     if (TypeSpecType == TST_unspecified) {
874       Diag(D, TSCLoc, diag::ext_plain_complex)
875         << FixItHint::CreateInsertion(
876                               PP.getLocForEndOfToken(getTypeSpecComplexLoc()),
877                                                  " double");
878       TypeSpecType = TST_double;   // _Complex -> _Complex double.
879     } else if (TypeSpecType == TST_int || TypeSpecType == TST_char) {
880       // Note that this intentionally doesn't include _Complex _Bool.
881       if (!PP.getLangOpts().CPlusPlus)
882         Diag(D, TSTLoc, diag::ext_integer_complex);
883     } else if (TypeSpecType != TST_float && TypeSpecType != TST_double) {
884       Diag(D, TSCLoc, diag::err_invalid_complex_spec)
885         << getSpecifierName((TST)TypeSpecType);
886       TypeSpecComplex = TSC_unspecified;
887     }
888   }
889 
890   // If no type specifier was provided and we're parsing a language where
891   // the type specifier is not optional, but we got 'auto' as a storage
892   // class specifier, then assume this is an attempt to use C++0x's 'auto'
893   // type specifier.
894   // FIXME: Does Microsoft really support implicit int in C++?
895   if (PP.getLangOpts().CPlusPlus && !PP.getLangOpts().MicrosoftExt &&
896       TypeSpecType == TST_unspecified && StorageClassSpec == SCS_auto) {
897     TypeSpecType = TST_auto;
898     StorageClassSpec = StorageClassSpecAsWritten = SCS_unspecified;
899     TSTLoc = TSTNameLoc = StorageClassSpecLoc;
900     StorageClassSpecLoc = SourceLocation();
901   }
902   // Diagnose if we've recovered from an ill-formed 'auto' storage class
903   // specifier in a pre-C++0x dialect of C++.
904   if (!PP.getLangOpts().CPlusPlus0x && TypeSpecType == TST_auto)
905     Diag(D, TSTLoc, diag::ext_auto_type_specifier);
906   if (PP.getLangOpts().CPlusPlus && !PP.getLangOpts().CPlusPlus0x &&
907       StorageClassSpec == SCS_auto)
908     Diag(D, StorageClassSpecLoc, diag::warn_auto_storage_class)
909       << FixItHint::CreateRemoval(StorageClassSpecLoc);
910   if (TypeSpecType == TST_char16 || TypeSpecType == TST_char32)
911     Diag(D, TSTLoc, diag::warn_cxx98_compat_unicode_type)
912       << (TypeSpecType == TST_char16 ? "char16_t" : "char32_t");
913   if (Constexpr_specified)
914     Diag(D, ConstexprLoc, diag::warn_cxx98_compat_constexpr);
915 
916   // C++ [class.friend]p6:
917   //   No storage-class-specifier shall appear in the decl-specifier-seq
918   //   of a friend declaration.
919   if (isFriendSpecified() && getStorageClassSpec()) {
920     DeclSpec::SCS SC = getStorageClassSpec();
921     const char *SpecName = getSpecifierName(SC);
922 
923     SourceLocation SCLoc = getStorageClassSpecLoc();
924     SourceLocation SCEndLoc = SCLoc.getLocWithOffset(strlen(SpecName));
925 
926     Diag(D, SCLoc, diag::err_friend_storage_spec)
927       << SpecName
928       << FixItHint::CreateRemoval(SourceRange(SCLoc, SCEndLoc));
929 
930     ClearStorageClassSpecs();
931   }
932 
933   assert(!TypeSpecOwned || isDeclRep((TST) TypeSpecType));
934 
935   // Okay, now we can infer the real type.
936 
937   // TODO: return "auto function" and other bad things based on the real type.
938 
939   // 'data definition has no type or storage class'?
940 }
941 
942 bool DeclSpec::isMissingDeclaratorOk() {
943   TST tst = getTypeSpecType();
944   return isDeclRep(tst) && getRepAsDecl() != 0 &&
945     StorageClassSpec != DeclSpec::SCS_typedef;
946 }
947 
948 void UnqualifiedId::setOperatorFunctionId(SourceLocation OperatorLoc,
949                                           OverloadedOperatorKind Op,
950                                           SourceLocation SymbolLocations[3]) {
951   Kind = IK_OperatorFunctionId;
952   StartLocation = OperatorLoc;
953   EndLocation = OperatorLoc;
954   OperatorFunctionId.Operator = Op;
955   for (unsigned I = 0; I != 3; ++I) {
956     OperatorFunctionId.SymbolLocations[I] = SymbolLocations[I].getRawEncoding();
957 
958     if (SymbolLocations[I].isValid())
959       EndLocation = SymbolLocations[I];
960   }
961 }
962 
963 bool VirtSpecifiers::SetSpecifier(Specifier VS, SourceLocation Loc,
964                                   const char *&PrevSpec) {
965   LastLocation = Loc;
966 
967   if (Specifiers & VS) {
968     PrevSpec = getSpecifierName(VS);
969     return true;
970   }
971 
972   Specifiers |= VS;
973 
974   switch (VS) {
975   default: llvm_unreachable("Unknown specifier!");
976   case VS_Override: VS_overrideLoc = Loc; break;
977   case VS_Final:    VS_finalLoc = Loc; break;
978   }
979 
980   return false;
981 }
982 
983 const char *VirtSpecifiers::getSpecifierName(Specifier VS) {
984   switch (VS) {
985   default: llvm_unreachable("Unknown specifier");
986   case VS_Override: return "override";
987   case VS_Final: return "final";
988   }
989 }
990