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     return false;
249   }
250 
251   switch (DS.getTypeSpecType()) {
252     case TST_atomic:
253     case TST_auto:
254     case TST_bool:
255     case TST_char:
256     case TST_char16:
257     case TST_char32:
258     case TST_class:
259     case TST_decimal128:
260     case TST_decimal32:
261     case TST_decimal64:
262     case TST_double:
263     case TST_enum:
264     case TST_error:
265     case TST_float:
266     case TST_half:
267     case TST_int:
268     case TST_struct:
269     case TST_union:
270     case TST_unknown_anytype:
271     case TST_unspecified:
272     case TST_void:
273     case TST_wchar:
274       return false;
275 
276     case TST_decltype:
277     case TST_typeofExpr:
278       if (Expr *E = DS.getRepAsExpr())
279         return E->getType()->isFunctionType();
280       return false;
281 
282     case TST_underlyingType:
283     case TST_typename:
284     case TST_typeofType: {
285       QualType QT = DS.getRepAsType().get();
286       if (QT.isNull())
287         return false;
288 
289       if (const LocInfoType *LIT = dyn_cast<LocInfoType>(QT))
290         QT = LIT->getType();
291 
292       if (QT.isNull())
293         return false;
294 
295       return QT->isFunctionType();
296     }
297   }
298 
299   return false;
300 }
301 
302 /// getParsedSpecifiers - Return a bitmask of which flavors of specifiers this
303 /// declaration specifier includes.
304 ///
305 unsigned DeclSpec::getParsedSpecifiers() const {
306   unsigned Res = 0;
307   if (StorageClassSpec != SCS_unspecified ||
308       SCS_thread_specified)
309     Res |= PQ_StorageClassSpecifier;
310 
311   if (TypeQualifiers != TQ_unspecified)
312     Res |= PQ_TypeQualifier;
313 
314   if (hasTypeSpecifier())
315     Res |= PQ_TypeSpecifier;
316 
317   if (FS_inline_specified || FS_virtual_specified || FS_explicit_specified)
318     Res |= PQ_FunctionSpecifier;
319   return Res;
320 }
321 
322 template <class T> static bool BadSpecifier(T TNew, T TPrev,
323                                             const char *&PrevSpec,
324                                             unsigned &DiagID) {
325   PrevSpec = DeclSpec::getSpecifierName(TPrev);
326   DiagID = (TNew == TPrev ? diag::ext_duplicate_declspec
327             : diag::err_invalid_decl_spec_combination);
328   return true;
329 }
330 
331 const char *DeclSpec::getSpecifierName(DeclSpec::SCS S) {
332   switch (S) {
333   case DeclSpec::SCS_unspecified: return "unspecified";
334   case DeclSpec::SCS_typedef:     return "typedef";
335   case DeclSpec::SCS_extern:      return "extern";
336   case DeclSpec::SCS_static:      return "static";
337   case DeclSpec::SCS_auto:        return "auto";
338   case DeclSpec::SCS_register:    return "register";
339   case DeclSpec::SCS_private_extern: return "__private_extern__";
340   case DeclSpec::SCS_mutable:     return "mutable";
341   }
342   llvm_unreachable("Unknown typespec!");
343 }
344 
345 const char *DeclSpec::getSpecifierName(TSW W) {
346   switch (W) {
347   case TSW_unspecified: return "unspecified";
348   case TSW_short:       return "short";
349   case TSW_long:        return "long";
350   case TSW_longlong:    return "long long";
351   }
352   llvm_unreachable("Unknown typespec!");
353 }
354 
355 const char *DeclSpec::getSpecifierName(TSC C) {
356   switch (C) {
357   case TSC_unspecified: return "unspecified";
358   case TSC_imaginary:   return "imaginary";
359   case TSC_complex:     return "complex";
360   }
361   llvm_unreachable("Unknown typespec!");
362 }
363 
364 
365 const char *DeclSpec::getSpecifierName(TSS S) {
366   switch (S) {
367   case TSS_unspecified: return "unspecified";
368   case TSS_signed:      return "signed";
369   case TSS_unsigned:    return "unsigned";
370   }
371   llvm_unreachable("Unknown typespec!");
372 }
373 
374 const char *DeclSpec::getSpecifierName(DeclSpec::TST T) {
375   switch (T) {
376   case DeclSpec::TST_unspecified: return "unspecified";
377   case DeclSpec::TST_void:        return "void";
378   case DeclSpec::TST_char:        return "char";
379   case DeclSpec::TST_wchar:       return "wchar_t";
380   case DeclSpec::TST_char16:      return "char16_t";
381   case DeclSpec::TST_char32:      return "char32_t";
382   case DeclSpec::TST_int:         return "int";
383   case DeclSpec::TST_half:        return "half";
384   case DeclSpec::TST_float:       return "float";
385   case DeclSpec::TST_double:      return "double";
386   case DeclSpec::TST_bool:        return "_Bool";
387   case DeclSpec::TST_decimal32:   return "_Decimal32";
388   case DeclSpec::TST_decimal64:   return "_Decimal64";
389   case DeclSpec::TST_decimal128:  return "_Decimal128";
390   case DeclSpec::TST_enum:        return "enum";
391   case DeclSpec::TST_class:       return "class";
392   case DeclSpec::TST_union:       return "union";
393   case DeclSpec::TST_struct:      return "struct";
394   case DeclSpec::TST_typename:    return "type-name";
395   case DeclSpec::TST_typeofType:
396   case DeclSpec::TST_typeofExpr:  return "typeof";
397   case DeclSpec::TST_auto:        return "auto";
398   case DeclSpec::TST_decltype:    return "(decltype)";
399   case DeclSpec::TST_underlyingType: return "__underlying_type";
400   case DeclSpec::TST_unknown_anytype: return "__unknown_anytype";
401   case DeclSpec::TST_atomic: return "_Atomic";
402   case DeclSpec::TST_error:       return "(error)";
403   }
404   llvm_unreachable("Unknown typespec!");
405 }
406 
407 const char *DeclSpec::getSpecifierName(TQ T) {
408   switch (T) {
409   case DeclSpec::TQ_unspecified: return "unspecified";
410   case DeclSpec::TQ_const:       return "const";
411   case DeclSpec::TQ_restrict:    return "restrict";
412   case DeclSpec::TQ_volatile:    return "volatile";
413   }
414   llvm_unreachable("Unknown typespec!");
415 }
416 
417 bool DeclSpec::SetStorageClassSpec(Sema &S, SCS SC, SourceLocation Loc,
418                                    const char *&PrevSpec,
419                                    unsigned &DiagID) {
420   // OpenCL 1.1 6.8g: "The extern, static, auto and register storage-class
421   // specifiers are not supported."
422   // It seems sensible to prohibit private_extern too
423   // The cl_clang_storage_class_specifiers extension enables support for
424   // these storage-class specifiers.
425   if (S.getLangOptions().OpenCL &&
426       !S.getOpenCLOptions().cl_clang_storage_class_specifiers) {
427     switch (SC) {
428     case SCS_extern:
429     case SCS_private_extern:
430     case SCS_auto:
431     case SCS_register:
432     case SCS_static:
433       DiagID   = diag::err_not_opencl_storage_class_specifier;
434       PrevSpec = getSpecifierName(SC);
435       return true;
436     default:
437       break;
438     }
439   }
440 
441   if (StorageClassSpec != SCS_unspecified) {
442     // Maybe this is an attempt to use C++0x 'auto' outside of C++0x mode.
443     bool isInvalid = true;
444     if (TypeSpecType == TST_unspecified && S.getLangOptions().CPlusPlus) {
445       if (SC == SCS_auto)
446         return SetTypeSpecType(TST_auto, Loc, PrevSpec, DiagID);
447       if (StorageClassSpec == SCS_auto) {
448         isInvalid = SetTypeSpecType(TST_auto, StorageClassSpecLoc,
449                                     PrevSpec, DiagID);
450         assert(!isInvalid && "auto SCS -> TST recovery failed");
451       }
452     }
453 
454     // Changing storage class is allowed only if the previous one
455     // was the 'extern' that is part of a linkage specification and
456     // the new storage class is 'typedef'.
457     if (isInvalid &&
458         !(SCS_extern_in_linkage_spec &&
459           StorageClassSpec == SCS_extern &&
460           SC == SCS_typedef))
461       return BadSpecifier(SC, (SCS)StorageClassSpec, PrevSpec, DiagID);
462   }
463   StorageClassSpec = SC;
464   StorageClassSpecLoc = Loc;
465   assert((unsigned)SC == StorageClassSpec && "SCS constants overflow bitfield");
466   return false;
467 }
468 
469 bool DeclSpec::SetStorageClassSpecThread(SourceLocation Loc,
470                                          const char *&PrevSpec,
471                                          unsigned &DiagID) {
472   if (SCS_thread_specified) {
473     PrevSpec = "__thread";
474     DiagID = diag::ext_duplicate_declspec;
475     return true;
476   }
477   SCS_thread_specified = true;
478   SCS_threadLoc = Loc;
479   return false;
480 }
481 
482 /// These methods set the specified attribute of the DeclSpec, but return true
483 /// and ignore the request if invalid (e.g. "extern" then "auto" is
484 /// specified).
485 bool DeclSpec::SetTypeSpecWidth(TSW W, SourceLocation Loc,
486                                 const char *&PrevSpec,
487                                 unsigned &DiagID) {
488   // Overwrite TSWLoc only if TypeSpecWidth was unspecified, so that
489   // for 'long long' we will keep the source location of the first 'long'.
490   if (TypeSpecWidth == TSW_unspecified)
491     TSWLoc = Loc;
492   // Allow turning long -> long long.
493   else if (W != TSW_longlong || TypeSpecWidth != TSW_long)
494     return BadSpecifier(W, (TSW)TypeSpecWidth, PrevSpec, DiagID);
495   TypeSpecWidth = W;
496   if (TypeAltiVecVector && !TypeAltiVecBool &&
497       ((TypeSpecWidth == TSW_long) || (TypeSpecWidth == TSW_longlong))) {
498     PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType);
499     DiagID = diag::warn_vector_long_decl_spec_combination;
500     return true;
501   }
502   return false;
503 }
504 
505 bool DeclSpec::SetTypeSpecComplex(TSC C, SourceLocation Loc,
506                                   const char *&PrevSpec,
507                                   unsigned &DiagID) {
508   if (TypeSpecComplex != TSC_unspecified)
509     return BadSpecifier(C, (TSC)TypeSpecComplex, PrevSpec, DiagID);
510   TypeSpecComplex = C;
511   TSCLoc = Loc;
512   return false;
513 }
514 
515 bool DeclSpec::SetTypeSpecSign(TSS S, SourceLocation Loc,
516                                const char *&PrevSpec,
517                                unsigned &DiagID) {
518   if (TypeSpecSign != TSS_unspecified)
519     return BadSpecifier(S, (TSS)TypeSpecSign, PrevSpec, DiagID);
520   TypeSpecSign = S;
521   TSSLoc = Loc;
522   return false;
523 }
524 
525 bool DeclSpec::SetTypeSpecType(TST T, SourceLocation Loc,
526                                const char *&PrevSpec,
527                                unsigned &DiagID,
528                                ParsedType Rep) {
529   return SetTypeSpecType(T, Loc, Loc, PrevSpec, DiagID, Rep);
530 }
531 
532 bool DeclSpec::SetTypeSpecType(TST T, SourceLocation TagKwLoc,
533                                SourceLocation TagNameLoc,
534                                const char *&PrevSpec,
535                                unsigned &DiagID,
536                                ParsedType Rep) {
537   assert(isTypeRep(T) && "T does not store a type");
538   assert(Rep && "no type provided!");
539   if (TypeSpecType != TST_unspecified) {
540     PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType);
541     DiagID = diag::err_invalid_decl_spec_combination;
542     return true;
543   }
544   TypeSpecType = T;
545   TypeRep = Rep;
546   TSTLoc = TagKwLoc;
547   TSTNameLoc = TagNameLoc;
548   TypeSpecOwned = false;
549   return false;
550 }
551 
552 bool DeclSpec::SetTypeSpecType(TST T, SourceLocation Loc,
553                                const char *&PrevSpec,
554                                unsigned &DiagID,
555                                Expr *Rep) {
556   assert(isExprRep(T) && "T does not store an expr");
557   assert(Rep && "no expression provided!");
558   if (TypeSpecType != TST_unspecified) {
559     PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType);
560     DiagID = diag::err_invalid_decl_spec_combination;
561     return true;
562   }
563   TypeSpecType = T;
564   ExprRep = Rep;
565   TSTLoc = Loc;
566   TSTNameLoc = Loc;
567   TypeSpecOwned = false;
568   return false;
569 }
570 
571 bool DeclSpec::SetTypeSpecType(TST T, SourceLocation Loc,
572                                const char *&PrevSpec,
573                                unsigned &DiagID,
574                                Decl *Rep, bool Owned) {
575   return SetTypeSpecType(T, Loc, Loc, PrevSpec, DiagID, Rep, Owned);
576 }
577 
578 bool DeclSpec::SetTypeSpecType(TST T, SourceLocation TagKwLoc,
579                                SourceLocation TagNameLoc,
580                                const char *&PrevSpec,
581                                unsigned &DiagID,
582                                Decl *Rep, bool Owned) {
583   assert(isDeclRep(T) && "T does not store a decl");
584   // Unlike the other cases, we don't assert that we actually get a decl.
585 
586   if (TypeSpecType != TST_unspecified) {
587     PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType);
588     DiagID = diag::err_invalid_decl_spec_combination;
589     return true;
590   }
591   TypeSpecType = T;
592   DeclRep = Rep;
593   TSTLoc = TagKwLoc;
594   TSTNameLoc = TagNameLoc;
595   TypeSpecOwned = Owned;
596   return false;
597 }
598 
599 bool DeclSpec::SetTypeSpecType(TST T, SourceLocation Loc,
600                                const char *&PrevSpec,
601                                unsigned &DiagID) {
602   assert(!isDeclRep(T) && !isTypeRep(T) && !isExprRep(T) &&
603          "rep required for these type-spec kinds!");
604   if (TypeSpecType != TST_unspecified) {
605     PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType);
606     DiagID = diag::err_invalid_decl_spec_combination;
607     return true;
608   }
609   TSTLoc = Loc;
610   TSTNameLoc = Loc;
611   if (TypeAltiVecVector && (T == TST_bool) && !TypeAltiVecBool) {
612     TypeAltiVecBool = true;
613     return false;
614   }
615   TypeSpecType = T;
616   TypeSpecOwned = false;
617   if (TypeAltiVecVector && !TypeAltiVecBool && (TypeSpecType == TST_double)) {
618     PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType);
619     DiagID = diag::err_invalid_vector_decl_spec;
620     return true;
621   }
622   return false;
623 }
624 
625 bool DeclSpec::SetTypeAltiVecVector(bool isAltiVecVector, SourceLocation Loc,
626                           const char *&PrevSpec, unsigned &DiagID) {
627   if (TypeSpecType != TST_unspecified) {
628     PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType);
629     DiagID = diag::err_invalid_vector_decl_spec_combination;
630     return true;
631   }
632   TypeAltiVecVector = isAltiVecVector;
633   AltiVecLoc = Loc;
634   return false;
635 }
636 
637 bool DeclSpec::SetTypeAltiVecPixel(bool isAltiVecPixel, SourceLocation Loc,
638                           const char *&PrevSpec, unsigned &DiagID) {
639   if (!TypeAltiVecVector || TypeAltiVecPixel ||
640       (TypeSpecType != TST_unspecified)) {
641     PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType);
642     DiagID = diag::err_invalid_pixel_decl_spec_combination;
643     return true;
644   }
645   TypeAltiVecPixel = isAltiVecPixel;
646   TSTLoc = Loc;
647   TSTNameLoc = Loc;
648   return false;
649 }
650 
651 bool DeclSpec::SetTypeSpecError() {
652   TypeSpecType = TST_error;
653   TypeSpecOwned = false;
654   TSTLoc = SourceLocation();
655   TSTNameLoc = SourceLocation();
656   return false;
657 }
658 
659 bool DeclSpec::SetTypeQual(TQ T, SourceLocation Loc, const char *&PrevSpec,
660                            unsigned &DiagID, const LangOptions &Lang) {
661   // Duplicates turn into warnings pre-C99.
662   if ((TypeQualifiers & T) && !Lang.C99)
663     return BadSpecifier(T, T, PrevSpec, DiagID);
664   TypeQualifiers |= T;
665 
666   switch (T) {
667   default: llvm_unreachable("Unknown type qualifier!");
668   case TQ_const:    TQ_constLoc = Loc; break;
669   case TQ_restrict: TQ_restrictLoc = Loc; break;
670   case TQ_volatile: TQ_volatileLoc = Loc; break;
671   }
672   return false;
673 }
674 
675 bool DeclSpec::SetFunctionSpecInline(SourceLocation Loc, const char *&PrevSpec,
676                                      unsigned &DiagID) {
677   // 'inline inline' is ok.
678   FS_inline_specified = true;
679   FS_inlineLoc = Loc;
680   return false;
681 }
682 
683 bool DeclSpec::SetFunctionSpecVirtual(SourceLocation Loc, const char *&PrevSpec,
684                                       unsigned &DiagID) {
685   // 'virtual virtual' is ok.
686   FS_virtual_specified = true;
687   FS_virtualLoc = Loc;
688   return false;
689 }
690 
691 bool DeclSpec::SetFunctionSpecExplicit(SourceLocation Loc, const char *&PrevSpec,
692                                        unsigned &DiagID) {
693   // 'explicit explicit' is ok.
694   FS_explicit_specified = true;
695   FS_explicitLoc = Loc;
696   return false;
697 }
698 
699 bool DeclSpec::SetFriendSpec(SourceLocation Loc, const char *&PrevSpec,
700                              unsigned &DiagID) {
701   if (Friend_specified) {
702     PrevSpec = "friend";
703     DiagID = diag::ext_duplicate_declspec;
704     return true;
705   }
706 
707   Friend_specified = true;
708   FriendLoc = Loc;
709   return false;
710 }
711 
712 bool DeclSpec::setModulePrivateSpec(SourceLocation Loc, const char *&PrevSpec,
713                                     unsigned &DiagID) {
714   if (isModulePrivateSpecified()) {
715     PrevSpec = "__module_private__";
716     DiagID = diag::ext_duplicate_declspec;
717     return true;
718   }
719 
720   ModulePrivateLoc = Loc;
721   return false;
722 }
723 
724 bool DeclSpec::SetConstexprSpec(SourceLocation Loc, const char *&PrevSpec,
725                                 unsigned &DiagID) {
726   // 'constexpr constexpr' is ok.
727   Constexpr_specified = true;
728   ConstexprLoc = Loc;
729   return false;
730 }
731 
732 void DeclSpec::setProtocolQualifiers(Decl * const *Protos,
733                                      unsigned NP,
734                                      SourceLocation *ProtoLocs,
735                                      SourceLocation LAngleLoc) {
736   if (NP == 0) return;
737   ProtocolQualifiers = new Decl*[NP];
738   ProtocolLocs = new SourceLocation[NP];
739   memcpy((void*)ProtocolQualifiers, Protos, sizeof(Decl*)*NP);
740   memcpy(ProtocolLocs, ProtoLocs, sizeof(SourceLocation)*NP);
741   NumProtocolQualifiers = NP;
742   ProtocolLAngleLoc = LAngleLoc;
743 }
744 
745 void DeclSpec::SaveWrittenBuiltinSpecs() {
746   writtenBS.Sign = getTypeSpecSign();
747   writtenBS.Width = getTypeSpecWidth();
748   writtenBS.Type = getTypeSpecType();
749   // Search the list of attributes for the presence of a mode attribute.
750   writtenBS.ModeAttr = false;
751   AttributeList* attrs = getAttributes().getList();
752   while (attrs) {
753     if (attrs->getKind() == AttributeList::AT_mode) {
754       writtenBS.ModeAttr = true;
755       break;
756     }
757     attrs = attrs->getNext();
758   }
759 }
760 
761 void DeclSpec::SaveStorageSpecifierAsWritten() {
762   if (SCS_extern_in_linkage_spec && StorageClassSpec == SCS_extern)
763     // If 'extern' is part of a linkage specification,
764     // then it is not a storage class "as written".
765     StorageClassSpecAsWritten = SCS_unspecified;
766   else
767     StorageClassSpecAsWritten = StorageClassSpec;
768 }
769 
770 /// Finish - This does final analysis of the declspec, rejecting things like
771 /// "_Imaginary" (lacking an FP type).  This returns a diagnostic to issue or
772 /// diag::NUM_DIAGNOSTICS if there is no error.  After calling this method,
773 /// DeclSpec is guaranteed self-consistent, even if an error occurred.
774 void DeclSpec::Finish(DiagnosticsEngine &D, Preprocessor &PP) {
775   // Before possibly changing their values, save specs as written.
776   SaveWrittenBuiltinSpecs();
777   SaveStorageSpecifierAsWritten();
778 
779   // Check the type specifier components first.
780 
781   // Validate and finalize AltiVec vector declspec.
782   if (TypeAltiVecVector) {
783     if (TypeAltiVecBool) {
784       // Sign specifiers are not allowed with vector bool. (PIM 2.1)
785       if (TypeSpecSign != TSS_unspecified) {
786         Diag(D, TSSLoc, diag::err_invalid_vector_bool_decl_spec)
787           << getSpecifierName((TSS)TypeSpecSign);
788       }
789 
790       // Only char/int are valid with vector bool. (PIM 2.1)
791       if (((TypeSpecType != TST_unspecified) && (TypeSpecType != TST_char) &&
792            (TypeSpecType != TST_int)) || TypeAltiVecPixel) {
793         Diag(D, TSTLoc, diag::err_invalid_vector_bool_decl_spec)
794           << (TypeAltiVecPixel ? "__pixel" :
795                                  getSpecifierName((TST)TypeSpecType));
796       }
797 
798       // Only 'short' is valid with vector bool. (PIM 2.1)
799       if ((TypeSpecWidth != TSW_unspecified) && (TypeSpecWidth != TSW_short))
800         Diag(D, TSWLoc, diag::err_invalid_vector_bool_decl_spec)
801           << getSpecifierName((TSW)TypeSpecWidth);
802 
803       // Elements of vector bool are interpreted as unsigned. (PIM 2.1)
804       if ((TypeSpecType == TST_char) || (TypeSpecType == TST_int) ||
805           (TypeSpecWidth != TSW_unspecified))
806         TypeSpecSign = TSS_unsigned;
807     }
808 
809     if (TypeAltiVecPixel) {
810       //TODO: perform validation
811       TypeSpecType = TST_int;
812       TypeSpecSign = TSS_unsigned;
813       TypeSpecWidth = TSW_short;
814       TypeSpecOwned = false;
815     }
816   }
817 
818   // signed/unsigned are only valid with int/char/wchar_t.
819   if (TypeSpecSign != TSS_unspecified) {
820     if (TypeSpecType == TST_unspecified)
821       TypeSpecType = TST_int; // unsigned -> unsigned int, signed -> signed int.
822     else if (TypeSpecType != TST_int  &&
823              TypeSpecType != TST_char && TypeSpecType != TST_wchar) {
824       Diag(D, TSSLoc, diag::err_invalid_sign_spec)
825         << getSpecifierName((TST)TypeSpecType);
826       // signed double -> double.
827       TypeSpecSign = TSS_unspecified;
828     }
829   }
830 
831   // Validate the width of the type.
832   switch (TypeSpecWidth) {
833   case TSW_unspecified: break;
834   case TSW_short:    // short int
835   case TSW_longlong: // long long int
836     if (TypeSpecType == TST_unspecified)
837       TypeSpecType = TST_int; // short -> short int, long long -> long long int.
838     else if (TypeSpecType != TST_int) {
839       Diag(D, TSWLoc,
840            TypeSpecWidth == TSW_short ? diag::err_invalid_short_spec
841                                       : diag::err_invalid_longlong_spec)
842         <<  getSpecifierName((TST)TypeSpecType);
843       TypeSpecType = TST_int;
844       TypeSpecOwned = false;
845     }
846     break;
847   case TSW_long:  // long double, long int
848     if (TypeSpecType == TST_unspecified)
849       TypeSpecType = TST_int;  // long -> long int.
850     else if (TypeSpecType != TST_int && TypeSpecType != TST_double) {
851       Diag(D, TSWLoc, diag::err_invalid_long_spec)
852         << getSpecifierName((TST)TypeSpecType);
853       TypeSpecType = TST_int;
854       TypeSpecOwned = false;
855     }
856     break;
857   }
858 
859   // TODO: if the implementation does not implement _Complex or _Imaginary,
860   // disallow their use.  Need information about the backend.
861   if (TypeSpecComplex != TSC_unspecified) {
862     if (TypeSpecType == TST_unspecified) {
863       Diag(D, TSCLoc, diag::ext_plain_complex)
864         << FixItHint::CreateInsertion(
865                               PP.getLocForEndOfToken(getTypeSpecComplexLoc()),
866                                                  " double");
867       TypeSpecType = TST_double;   // _Complex -> _Complex double.
868     } else if (TypeSpecType == TST_int || TypeSpecType == TST_char) {
869       // Note that this intentionally doesn't include _Complex _Bool.
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