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