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