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