1 //===--- DeclSpec.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/DeclCXX.h"
17 #include "clang/AST/Expr.h"
18 #include "clang/AST/LocInfoType.h"
19 #include "clang/AST/TypeLoc.h"
20 #include "clang/Basic/LangOptions.h"
21 #include "clang/Basic/TargetInfo.h"
22 #include "clang/Sema/ParsedTemplate.h"
23 #include "clang/Sema/Sema.h"
24 #include "clang/Sema/SemaDiagnostic.h"
25 #include "llvm/ADT/STLExtras.h"
26 #include "llvm/ADT/SmallString.h"
27 #include <cstring>
28 using namespace clang;
29 
30 
31 void UnqualifiedId::setTemplateId(TemplateIdAnnotation *TemplateId) {
32   assert(TemplateId && "NULL template-id annotation?");
33   Kind = IK_TemplateId;
34   this->TemplateId = TemplateId;
35   StartLocation = TemplateId->TemplateNameLoc;
36   EndLocation = TemplateId->RAngleLoc;
37 }
38 
39 void UnqualifiedId::setConstructorTemplateId(TemplateIdAnnotation *TemplateId) {
40   assert(TemplateId && "NULL template-id annotation?");
41   Kind = IK_ConstructorTemplateId;
42   this->TemplateId = TemplateId;
43   StartLocation = TemplateId->TemplateNameLoc;
44   EndLocation = TemplateId->RAngleLoc;
45 }
46 
47 void CXXScopeSpec::Extend(ASTContext &Context, SourceLocation TemplateKWLoc,
48                           TypeLoc TL, SourceLocation ColonColonLoc) {
49   Builder.Extend(Context, TemplateKWLoc, TL, ColonColonLoc);
50   if (Range.getBegin().isInvalid())
51     Range.setBegin(TL.getBeginLoc());
52   Range.setEnd(ColonColonLoc);
53 
54   assert(Range == Builder.getSourceRange() &&
55          "NestedNameSpecifierLoc range computation incorrect");
56 }
57 
58 void CXXScopeSpec::Extend(ASTContext &Context, IdentifierInfo *Identifier,
59                           SourceLocation IdentifierLoc,
60                           SourceLocation ColonColonLoc) {
61   Builder.Extend(Context, Identifier, IdentifierLoc, ColonColonLoc);
62 
63   if (Range.getBegin().isInvalid())
64     Range.setBegin(IdentifierLoc);
65   Range.setEnd(ColonColonLoc);
66 
67   assert(Range == Builder.getSourceRange() &&
68          "NestedNameSpecifierLoc range computation incorrect");
69 }
70 
71 void CXXScopeSpec::Extend(ASTContext &Context, NamespaceDecl *Namespace,
72                           SourceLocation NamespaceLoc,
73                           SourceLocation ColonColonLoc) {
74   Builder.Extend(Context, Namespace, NamespaceLoc, ColonColonLoc);
75 
76   if (Range.getBegin().isInvalid())
77     Range.setBegin(NamespaceLoc);
78   Range.setEnd(ColonColonLoc);
79 
80   assert(Range == Builder.getSourceRange() &&
81          "NestedNameSpecifierLoc range computation incorrect");
82 }
83 
84 void CXXScopeSpec::Extend(ASTContext &Context, NamespaceAliasDecl *Alias,
85                           SourceLocation AliasLoc,
86                           SourceLocation ColonColonLoc) {
87   Builder.Extend(Context, Alias, AliasLoc, ColonColonLoc);
88 
89   if (Range.getBegin().isInvalid())
90     Range.setBegin(AliasLoc);
91   Range.setEnd(ColonColonLoc);
92 
93   assert(Range == Builder.getSourceRange() &&
94          "NestedNameSpecifierLoc range computation incorrect");
95 }
96 
97 void CXXScopeSpec::MakeGlobal(ASTContext &Context,
98                               SourceLocation ColonColonLoc) {
99   Builder.MakeGlobal(Context, ColonColonLoc);
100 
101   Range = SourceRange(ColonColonLoc);
102 
103   assert(Range == Builder.getSourceRange() &&
104          "NestedNameSpecifierLoc range computation incorrect");
105 }
106 
107 void CXXScopeSpec::MakeSuper(ASTContext &Context, CXXRecordDecl *RD,
108                              SourceLocation SuperLoc,
109                              SourceLocation ColonColonLoc) {
110   Builder.MakeSuper(Context, RD, SuperLoc, ColonColonLoc);
111 
112   Range.setBegin(SuperLoc);
113   Range.setEnd(ColonColonLoc);
114 
115   assert(Range == Builder.getSourceRange() &&
116   "NestedNameSpecifierLoc range computation incorrect");
117 }
118 
119 void CXXScopeSpec::MakeTrivial(ASTContext &Context,
120                                NestedNameSpecifier *Qualifier, SourceRange R) {
121   Builder.MakeTrivial(Context, Qualifier, R);
122   Range = R;
123 }
124 
125 void CXXScopeSpec::Adopt(NestedNameSpecifierLoc Other) {
126   if (!Other) {
127     Range = SourceRange();
128     Builder.Clear();
129     return;
130   }
131 
132   Range = Other.getSourceRange();
133   Builder.Adopt(Other);
134 }
135 
136 SourceLocation CXXScopeSpec::getLastQualifierNameLoc() const {
137   if (!Builder.getRepresentation())
138     return SourceLocation();
139   return Builder.getTemporary().getLocalBeginLoc();
140 }
141 
142 NestedNameSpecifierLoc
143 CXXScopeSpec::getWithLocInContext(ASTContext &Context) const {
144   if (!Builder.getRepresentation())
145     return NestedNameSpecifierLoc();
146 
147   return Builder.getWithLocInContext(Context);
148 }
149 
150 /// DeclaratorChunk::getFunction - Return a DeclaratorChunk for a function.
151 /// "TheDeclarator" is the declarator that this will be added to.
152 DeclaratorChunk DeclaratorChunk::getFunction(bool hasProto,
153                                              bool isAmbiguous,
154                                              SourceLocation LParenLoc,
155                                              ParamInfo *Params,
156                                              unsigned NumParams,
157                                              SourceLocation EllipsisLoc,
158                                              SourceLocation RParenLoc,
159                                              unsigned TypeQuals,
160                                              bool RefQualifierIsLvalueRef,
161                                              SourceLocation RefQualifierLoc,
162                                              SourceLocation ConstQualifierLoc,
163                                              SourceLocation
164                                                  VolatileQualifierLoc,
165                                              SourceLocation
166                                                  RestrictQualifierLoc,
167                                              SourceLocation MutableLoc,
168                                              ExceptionSpecificationType
169                                                  ESpecType,
170                                              SourceRange ESpecRange,
171                                              ParsedType *Exceptions,
172                                              SourceRange *ExceptionRanges,
173                                              unsigned NumExceptions,
174                                              Expr *NoexceptExpr,
175                                              CachedTokens *ExceptionSpecTokens,
176                                              SourceLocation LocalRangeBegin,
177                                              SourceLocation LocalRangeEnd,
178                                              Declarator &TheDeclarator,
179                                              TypeResult TrailingReturnType) {
180   assert(!(TypeQuals & DeclSpec::TQ_atomic) &&
181          "function cannot have _Atomic qualifier");
182 
183   DeclaratorChunk I;
184   I.Kind                        = Function;
185   I.Loc                         = LocalRangeBegin;
186   I.EndLoc                      = LocalRangeEnd;
187   I.Fun.AttrList                = nullptr;
188   I.Fun.hasPrototype            = hasProto;
189   I.Fun.isVariadic              = EllipsisLoc.isValid();
190   I.Fun.isAmbiguous             = isAmbiguous;
191   I.Fun.LParenLoc               = LParenLoc.getRawEncoding();
192   I.Fun.EllipsisLoc             = EllipsisLoc.getRawEncoding();
193   I.Fun.RParenLoc               = RParenLoc.getRawEncoding();
194   I.Fun.DeleteParams            = false;
195   I.Fun.TypeQuals               = TypeQuals;
196   I.Fun.NumParams               = NumParams;
197   I.Fun.Params                  = nullptr;
198   I.Fun.RefQualifierIsLValueRef = RefQualifierIsLvalueRef;
199   I.Fun.RefQualifierLoc         = RefQualifierLoc.getRawEncoding();
200   I.Fun.ConstQualifierLoc       = ConstQualifierLoc.getRawEncoding();
201   I.Fun.VolatileQualifierLoc    = VolatileQualifierLoc.getRawEncoding();
202   I.Fun.RestrictQualifierLoc    = RestrictQualifierLoc.getRawEncoding();
203   I.Fun.MutableLoc              = MutableLoc.getRawEncoding();
204   I.Fun.ExceptionSpecType       = ESpecType;
205   I.Fun.ExceptionSpecLocBeg     = ESpecRange.getBegin().getRawEncoding();
206   I.Fun.ExceptionSpecLocEnd     = ESpecRange.getEnd().getRawEncoding();
207   I.Fun.NumExceptions           = 0;
208   I.Fun.Exceptions              = nullptr;
209   I.Fun.NoexceptExpr            = nullptr;
210   I.Fun.HasTrailingReturnType   = TrailingReturnType.isUsable() ||
211                                   TrailingReturnType.isInvalid();
212   I.Fun.TrailingReturnType      = TrailingReturnType.get();
213 
214   assert(I.Fun.TypeQuals == TypeQuals && "bitfield overflow");
215   assert(I.Fun.ExceptionSpecType == ESpecType && "bitfield overflow");
216 
217   // new[] a parameter array if needed.
218   if (NumParams) {
219     // If the 'InlineParams' in Declarator is unused and big enough, put our
220     // parameter list there (in an effort to avoid new/delete traffic).  If it
221     // is already used (consider a function returning a function pointer) or too
222     // small (function with too many parameters), go to the heap.
223     if (!TheDeclarator.InlineStorageUsed &&
224         NumParams <= llvm::array_lengthof(TheDeclarator.InlineParams)) {
225       I.Fun.Params = TheDeclarator.InlineParams;
226       I.Fun.DeleteParams = false;
227       TheDeclarator.InlineStorageUsed = true;
228     } else {
229       I.Fun.Params = new DeclaratorChunk::ParamInfo[NumParams];
230       I.Fun.DeleteParams = true;
231     }
232     memcpy(I.Fun.Params, Params, sizeof(Params[0]) * NumParams);
233   }
234 
235   // Check what exception specification information we should actually store.
236   switch (ESpecType) {
237   default: break; // By default, save nothing.
238   case EST_Dynamic:
239     // new[] an exception array if needed
240     if (NumExceptions) {
241       I.Fun.NumExceptions = NumExceptions;
242       I.Fun.Exceptions = new DeclaratorChunk::TypeAndRange[NumExceptions];
243       for (unsigned i = 0; i != NumExceptions; ++i) {
244         I.Fun.Exceptions[i].Ty = Exceptions[i];
245         I.Fun.Exceptions[i].Range = ExceptionRanges[i];
246       }
247     }
248     break;
249 
250   case EST_ComputedNoexcept:
251     I.Fun.NoexceptExpr = NoexceptExpr;
252     break;
253 
254   case EST_Unparsed:
255     I.Fun.ExceptionSpecTokens = ExceptionSpecTokens;
256     break;
257   }
258   return I;
259 }
260 
261 void Declarator::setDecompositionBindings(
262     SourceLocation LSquareLoc,
263     ArrayRef<DecompositionDeclarator::Binding> Bindings,
264     SourceLocation RSquareLoc) {
265   assert(!hasName() && "declarator given multiple names!");
266 
267   BindingGroup.LSquareLoc = LSquareLoc;
268   BindingGroup.RSquareLoc = RSquareLoc;
269   BindingGroup.NumBindings = Bindings.size();
270   Range.setEnd(RSquareLoc);
271 
272   // We're now past the identifier.
273   SetIdentifier(nullptr, LSquareLoc);
274   Name.EndLocation = RSquareLoc;
275 
276   // Allocate storage for bindings and stash them away.
277   if (Bindings.size()) {
278     if (!InlineStorageUsed &&
279         Bindings.size() <= llvm::array_lengthof(InlineBindings)) {
280       BindingGroup.Bindings = InlineBindings;
281       BindingGroup.DeleteBindings = false;
282       InlineStorageUsed = true;
283     } else {
284       BindingGroup.Bindings =
285           new DecompositionDeclarator::Binding[Bindings.size()];
286       BindingGroup.DeleteBindings = true;
287     }
288     std::uninitialized_copy(Bindings.begin(), Bindings.end(),
289                             BindingGroup.Bindings);
290   }
291 }
292 
293 bool Declarator::isDeclarationOfFunction() const {
294   for (unsigned i = 0, i_end = DeclTypeInfo.size(); i < i_end; ++i) {
295     switch (DeclTypeInfo[i].Kind) {
296     case DeclaratorChunk::Function:
297       return true;
298     case DeclaratorChunk::Paren:
299       continue;
300     case DeclaratorChunk::Pointer:
301     case DeclaratorChunk::Reference:
302     case DeclaratorChunk::Array:
303     case DeclaratorChunk::BlockPointer:
304     case DeclaratorChunk::MemberPointer:
305     case DeclaratorChunk::Pipe:
306       return false;
307     }
308     llvm_unreachable("Invalid type chunk");
309   }
310 
311   switch (DS.getTypeSpecType()) {
312     case TST_atomic:
313     case TST_auto:
314     case TST_auto_type:
315     case TST_bool:
316     case TST_char:
317     case TST_char16:
318     case TST_char32:
319     case TST_class:
320     case TST_decimal128:
321     case TST_decimal32:
322     case TST_decimal64:
323     case TST_double:
324     case TST_float128:
325     case TST_enum:
326     case TST_error:
327     case TST_float:
328     case TST_half:
329     case TST_int:
330     case TST_int128:
331     case TST_struct:
332     case TST_interface:
333     case TST_union:
334     case TST_unknown_anytype:
335     case TST_unspecified:
336     case TST_void:
337     case TST_wchar:
338 #define GENERIC_IMAGE_TYPE(ImgType, Id) case TST_##ImgType##_t:
339 #include "clang/Basic/OpenCLImageTypes.def"
340       return false;
341 
342     case TST_decltype_auto:
343       // This must have an initializer, so can't be a function declaration,
344       // even if the initializer has function type.
345       return false;
346 
347     case TST_decltype:
348     case TST_typeofExpr:
349       if (Expr *E = DS.getRepAsExpr())
350         return E->getType()->isFunctionType();
351       return false;
352 
353     case TST_underlyingType:
354     case TST_typename:
355     case TST_typeofType: {
356       QualType QT = DS.getRepAsType().get();
357       if (QT.isNull())
358         return false;
359 
360       if (const LocInfoType *LIT = dyn_cast<LocInfoType>(QT))
361         QT = LIT->getType();
362 
363       if (QT.isNull())
364         return false;
365 
366       return QT->isFunctionType();
367     }
368   }
369 
370   llvm_unreachable("Invalid TypeSpecType!");
371 }
372 
373 bool Declarator::isStaticMember() {
374   assert(getContext() == MemberContext);
375   return getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_static ||
376          (getName().Kind == UnqualifiedId::IK_OperatorFunctionId &&
377           CXXMethodDecl::isStaticOverloadedOperator(
378               getName().OperatorFunctionId.Operator));
379 }
380 
381 bool Declarator::isCtorOrDtor() {
382   return (getName().getKind() == UnqualifiedId::IK_ConstructorName) ||
383          (getName().getKind() == UnqualifiedId::IK_DestructorName);
384 }
385 
386 bool DeclSpec::hasTagDefinition() const {
387   if (!TypeSpecOwned)
388     return false;
389   return cast<TagDecl>(getRepAsDecl())->isCompleteDefinition();
390 }
391 
392 /// getParsedSpecifiers - Return a bitmask of which flavors of specifiers this
393 /// declaration specifier includes.
394 ///
395 unsigned DeclSpec::getParsedSpecifiers() const {
396   unsigned Res = 0;
397   if (StorageClassSpec != SCS_unspecified ||
398       ThreadStorageClassSpec != TSCS_unspecified)
399     Res |= PQ_StorageClassSpecifier;
400 
401   if (TypeQualifiers != TQ_unspecified)
402     Res |= PQ_TypeQualifier;
403 
404   if (hasTypeSpecifier())
405     Res |= PQ_TypeSpecifier;
406 
407   if (FS_inline_specified || FS_virtual_specified || FS_explicit_specified ||
408       FS_noreturn_specified || FS_forceinline_specified)
409     Res |= PQ_FunctionSpecifier;
410   return Res;
411 }
412 
413 template <class T> static bool BadSpecifier(T TNew, T TPrev,
414                                             const char *&PrevSpec,
415                                             unsigned &DiagID,
416                                             bool IsExtension = true) {
417   PrevSpec = DeclSpec::getSpecifierName(TPrev);
418   if (TNew != TPrev)
419     DiagID = diag::err_invalid_decl_spec_combination;
420   else
421     DiagID = IsExtension ? diag::ext_duplicate_declspec :
422                            diag::warn_duplicate_declspec;
423   return true;
424 }
425 
426 const char *DeclSpec::getSpecifierName(DeclSpec::SCS S) {
427   switch (S) {
428   case DeclSpec::SCS_unspecified: return "unspecified";
429   case DeclSpec::SCS_typedef:     return "typedef";
430   case DeclSpec::SCS_extern:      return "extern";
431   case DeclSpec::SCS_static:      return "static";
432   case DeclSpec::SCS_auto:        return "auto";
433   case DeclSpec::SCS_register:    return "register";
434   case DeclSpec::SCS_private_extern: return "__private_extern__";
435   case DeclSpec::SCS_mutable:     return "mutable";
436   }
437   llvm_unreachable("Unknown typespec!");
438 }
439 
440 const char *DeclSpec::getSpecifierName(DeclSpec::TSCS S) {
441   switch (S) {
442   case DeclSpec::TSCS_unspecified:   return "unspecified";
443   case DeclSpec::TSCS___thread:      return "__thread";
444   case DeclSpec::TSCS_thread_local:  return "thread_local";
445   case DeclSpec::TSCS__Thread_local: return "_Thread_local";
446   }
447   llvm_unreachable("Unknown typespec!");
448 }
449 
450 const char *DeclSpec::getSpecifierName(TSW W) {
451   switch (W) {
452   case TSW_unspecified: return "unspecified";
453   case TSW_short:       return "short";
454   case TSW_long:        return "long";
455   case TSW_longlong:    return "long long";
456   }
457   llvm_unreachable("Unknown typespec!");
458 }
459 
460 const char *DeclSpec::getSpecifierName(TSC C) {
461   switch (C) {
462   case TSC_unspecified: return "unspecified";
463   case TSC_imaginary:   return "imaginary";
464   case TSC_complex:     return "complex";
465   }
466   llvm_unreachable("Unknown typespec!");
467 }
468 
469 
470 const char *DeclSpec::getSpecifierName(TSS S) {
471   switch (S) {
472   case TSS_unspecified: return "unspecified";
473   case TSS_signed:      return "signed";
474   case TSS_unsigned:    return "unsigned";
475   }
476   llvm_unreachable("Unknown typespec!");
477 }
478 
479 const char *DeclSpec::getSpecifierName(DeclSpec::TST T,
480                                        const PrintingPolicy &Policy) {
481   switch (T) {
482   case DeclSpec::TST_unspecified: return "unspecified";
483   case DeclSpec::TST_void:        return "void";
484   case DeclSpec::TST_char:        return "char";
485   case DeclSpec::TST_wchar:       return Policy.MSWChar ? "__wchar_t" : "wchar_t";
486   case DeclSpec::TST_char16:      return "char16_t";
487   case DeclSpec::TST_char32:      return "char32_t";
488   case DeclSpec::TST_int:         return "int";
489   case DeclSpec::TST_int128:      return "__int128";
490   case DeclSpec::TST_half:        return "half";
491   case DeclSpec::TST_float:       return "float";
492   case DeclSpec::TST_double:      return "double";
493   case DeclSpec::TST_float128:    return "__float128";
494   case DeclSpec::TST_bool:        return Policy.Bool ? "bool" : "_Bool";
495   case DeclSpec::TST_decimal32:   return "_Decimal32";
496   case DeclSpec::TST_decimal64:   return "_Decimal64";
497   case DeclSpec::TST_decimal128:  return "_Decimal128";
498   case DeclSpec::TST_enum:        return "enum";
499   case DeclSpec::TST_class:       return "class";
500   case DeclSpec::TST_union:       return "union";
501   case DeclSpec::TST_struct:      return "struct";
502   case DeclSpec::TST_interface:   return "__interface";
503   case DeclSpec::TST_typename:    return "type-name";
504   case DeclSpec::TST_typeofType:
505   case DeclSpec::TST_typeofExpr:  return "typeof";
506   case DeclSpec::TST_auto:        return "auto";
507   case DeclSpec::TST_auto_type:   return "__auto_type";
508   case DeclSpec::TST_decltype:    return "(decltype)";
509   case DeclSpec::TST_decltype_auto: return "decltype(auto)";
510   case DeclSpec::TST_underlyingType: return "__underlying_type";
511   case DeclSpec::TST_unknown_anytype: return "__unknown_anytype";
512   case DeclSpec::TST_atomic: return "_Atomic";
513 #define GENERIC_IMAGE_TYPE(ImgType, Id) \
514   case DeclSpec::TST_##ImgType##_t: \
515     return #ImgType "_t";
516 #include "clang/Basic/OpenCLImageTypes.def"
517   case DeclSpec::TST_error:       return "(error)";
518   }
519   llvm_unreachable("Unknown typespec!");
520 }
521 
522 const char *DeclSpec::getSpecifierName(TQ T) {
523   switch (T) {
524   case DeclSpec::TQ_unspecified: return "unspecified";
525   case DeclSpec::TQ_const:       return "const";
526   case DeclSpec::TQ_restrict:    return "restrict";
527   case DeclSpec::TQ_volatile:    return "volatile";
528   case DeclSpec::TQ_atomic:      return "_Atomic";
529   case DeclSpec::TQ_unaligned:   return "__unaligned";
530   }
531   llvm_unreachable("Unknown typespec!");
532 }
533 
534 bool DeclSpec::SetStorageClassSpec(Sema &S, SCS SC, SourceLocation Loc,
535                                    const char *&PrevSpec,
536                                    unsigned &DiagID,
537                                    const PrintingPolicy &Policy) {
538   // OpenCL v1.1 s6.8g: "The extern, static, auto and register storage-class
539   // specifiers are not supported.
540   // It seems sensible to prohibit private_extern too
541   // The cl_clang_storage_class_specifiers extension enables support for
542   // these storage-class specifiers.
543   // OpenCL v1.2 s6.8 changes this to "The auto and register storage-class
544   // specifiers are not supported."
545   if (S.getLangOpts().OpenCL &&
546       !S.getOpenCLOptions().cl_clang_storage_class_specifiers) {
547     switch (SC) {
548     case SCS_extern:
549     case SCS_private_extern:
550     case SCS_static:
551       if (S.getLangOpts().OpenCLVersion < 120) {
552         DiagID   = diag::err_opencl_unknown_type_specifier;
553         PrevSpec = getSpecifierName(SC);
554         return true;
555       }
556       break;
557     case SCS_auto:
558     case SCS_register:
559       DiagID   = diag::err_opencl_unknown_type_specifier;
560       PrevSpec = getSpecifierName(SC);
561       return true;
562     default:
563       break;
564     }
565   }
566 
567   if (StorageClassSpec != SCS_unspecified) {
568     // Maybe this is an attempt to use C++11 'auto' outside of C++11 mode.
569     bool isInvalid = true;
570     if (TypeSpecType == TST_unspecified && S.getLangOpts().CPlusPlus) {
571       if (SC == SCS_auto)
572         return SetTypeSpecType(TST_auto, Loc, PrevSpec, DiagID, Policy);
573       if (StorageClassSpec == SCS_auto) {
574         isInvalid = SetTypeSpecType(TST_auto, StorageClassSpecLoc,
575                                     PrevSpec, DiagID, Policy);
576         assert(!isInvalid && "auto SCS -> TST recovery failed");
577       }
578     }
579 
580     // Changing storage class is allowed only if the previous one
581     // was the 'extern' that is part of a linkage specification and
582     // the new storage class is 'typedef'.
583     if (isInvalid &&
584         !(SCS_extern_in_linkage_spec &&
585           StorageClassSpec == SCS_extern &&
586           SC == SCS_typedef))
587       return BadSpecifier(SC, (SCS)StorageClassSpec, PrevSpec, DiagID);
588   }
589   StorageClassSpec = SC;
590   StorageClassSpecLoc = Loc;
591   assert((unsigned)SC == StorageClassSpec && "SCS constants overflow bitfield");
592   return false;
593 }
594 
595 bool DeclSpec::SetStorageClassSpecThread(TSCS TSC, SourceLocation Loc,
596                                          const char *&PrevSpec,
597                                          unsigned &DiagID) {
598   if (ThreadStorageClassSpec != TSCS_unspecified)
599     return BadSpecifier(TSC, (TSCS)ThreadStorageClassSpec, PrevSpec, DiagID);
600 
601   ThreadStorageClassSpec = TSC;
602   ThreadStorageClassSpecLoc = Loc;
603   return false;
604 }
605 
606 /// These methods set the specified attribute of the DeclSpec, but return true
607 /// and ignore the request if invalid (e.g. "extern" then "auto" is
608 /// specified).
609 bool DeclSpec::SetTypeSpecWidth(TSW W, SourceLocation Loc,
610                                 const char *&PrevSpec,
611                                 unsigned &DiagID,
612                                 const PrintingPolicy &Policy) {
613   // Overwrite TSWRange.Begin only if TypeSpecWidth was unspecified, so that
614   // for 'long long' we will keep the source location of the first 'long'.
615   if (TypeSpecWidth == TSW_unspecified)
616     TSWRange.setBegin(Loc);
617   // Allow turning long -> long long.
618   else if (W != TSW_longlong || TypeSpecWidth != TSW_long)
619     return BadSpecifier(W, (TSW)TypeSpecWidth, PrevSpec, DiagID);
620   TypeSpecWidth = W;
621   // Remember location of the last 'long'
622   TSWRange.setEnd(Loc);
623   return false;
624 }
625 
626 bool DeclSpec::SetTypeSpecComplex(TSC C, SourceLocation Loc,
627                                   const char *&PrevSpec,
628                                   unsigned &DiagID) {
629   if (TypeSpecComplex != TSC_unspecified)
630     return BadSpecifier(C, (TSC)TypeSpecComplex, PrevSpec, DiagID);
631   TypeSpecComplex = C;
632   TSCLoc = Loc;
633   return false;
634 }
635 
636 bool DeclSpec::SetTypeSpecSign(TSS S, SourceLocation Loc,
637                                const char *&PrevSpec,
638                                unsigned &DiagID) {
639   if (TypeSpecSign != TSS_unspecified)
640     return BadSpecifier(S, (TSS)TypeSpecSign, PrevSpec, DiagID);
641   TypeSpecSign = S;
642   TSSLoc = Loc;
643   return false;
644 }
645 
646 bool DeclSpec::SetTypeSpecType(TST T, SourceLocation Loc,
647                                const char *&PrevSpec,
648                                unsigned &DiagID,
649                                ParsedType Rep,
650                                const PrintingPolicy &Policy) {
651   return SetTypeSpecType(T, Loc, Loc, PrevSpec, DiagID, Rep, Policy);
652 }
653 
654 bool DeclSpec::SetTypeSpecType(TST T, SourceLocation TagKwLoc,
655                                SourceLocation TagNameLoc,
656                                const char *&PrevSpec,
657                                unsigned &DiagID,
658                                ParsedType Rep,
659                                const PrintingPolicy &Policy) {
660   assert(isTypeRep(T) && "T does not store a type");
661   assert(Rep && "no type provided!");
662   if (TypeSpecType != TST_unspecified) {
663     PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType, Policy);
664     DiagID = diag::err_invalid_decl_spec_combination;
665     return true;
666   }
667   TypeSpecType = T;
668   TypeRep = Rep;
669   TSTLoc = TagKwLoc;
670   TSTNameLoc = TagNameLoc;
671   TypeSpecOwned = false;
672   return false;
673 }
674 
675 bool DeclSpec::SetTypeSpecType(TST T, SourceLocation Loc,
676                                const char *&PrevSpec,
677                                unsigned &DiagID,
678                                Expr *Rep,
679                                const PrintingPolicy &Policy) {
680   assert(isExprRep(T) && "T does not store an expr");
681   assert(Rep && "no expression provided!");
682   if (TypeSpecType != TST_unspecified) {
683     PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType, Policy);
684     DiagID = diag::err_invalid_decl_spec_combination;
685     return true;
686   }
687   TypeSpecType = T;
688   ExprRep = Rep;
689   TSTLoc = Loc;
690   TSTNameLoc = Loc;
691   TypeSpecOwned = false;
692   return false;
693 }
694 
695 bool DeclSpec::SetTypeSpecType(TST T, SourceLocation Loc,
696                                const char *&PrevSpec,
697                                unsigned &DiagID,
698                                Decl *Rep, bool Owned,
699                                const PrintingPolicy &Policy) {
700   return SetTypeSpecType(T, Loc, Loc, PrevSpec, DiagID, Rep, Owned, Policy);
701 }
702 
703 bool DeclSpec::SetTypeSpecType(TST T, SourceLocation TagKwLoc,
704                                SourceLocation TagNameLoc,
705                                const char *&PrevSpec,
706                                unsigned &DiagID,
707                                Decl *Rep, bool Owned,
708                                const PrintingPolicy &Policy) {
709   assert(isDeclRep(T) && "T does not store a decl");
710   // Unlike the other cases, we don't assert that we actually get a decl.
711 
712   if (TypeSpecType != TST_unspecified) {
713     PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType, Policy);
714     DiagID = diag::err_invalid_decl_spec_combination;
715     return true;
716   }
717   TypeSpecType = T;
718   DeclRep = Rep;
719   TSTLoc = TagKwLoc;
720   TSTNameLoc = TagNameLoc;
721   TypeSpecOwned = Owned && Rep != nullptr;
722   return false;
723 }
724 
725 bool DeclSpec::SetTypeSpecType(TST T, SourceLocation Loc,
726                                const char *&PrevSpec,
727                                unsigned &DiagID,
728                                const PrintingPolicy &Policy) {
729   assert(!isDeclRep(T) && !isTypeRep(T) && !isExprRep(T) &&
730          "rep required for these type-spec kinds!");
731   if (TypeSpecType != TST_unspecified) {
732     PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType, Policy);
733     DiagID = diag::err_invalid_decl_spec_combination;
734     return true;
735   }
736   TSTLoc = Loc;
737   TSTNameLoc = Loc;
738   if (TypeAltiVecVector && (T == TST_bool) && !TypeAltiVecBool) {
739     TypeAltiVecBool = true;
740     return false;
741   }
742   TypeSpecType = T;
743   TypeSpecOwned = false;
744   return false;
745 }
746 
747 bool DeclSpec::SetTypeAltiVecVector(bool isAltiVecVector, SourceLocation Loc,
748                           const char *&PrevSpec, unsigned &DiagID,
749                           const PrintingPolicy &Policy) {
750   if (TypeSpecType != TST_unspecified) {
751     PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType, Policy);
752     DiagID = diag::err_invalid_vector_decl_spec_combination;
753     return true;
754   }
755   TypeAltiVecVector = isAltiVecVector;
756   AltiVecLoc = Loc;
757   return false;
758 }
759 
760 bool DeclSpec::SetTypePipe(bool isPipe, SourceLocation Loc,
761                            const char *&PrevSpec, unsigned &DiagID,
762                            const PrintingPolicy &Policy) {
763 
764   if (TypeSpecType != TST_unspecified) {
765     PrevSpec = DeclSpec::getSpecifierName((TST)TypeSpecType, Policy);
766     DiagID = diag::err_invalid_decl_spec_combination;
767     return true;
768   }
769 
770   if (isPipe) {
771     TypeSpecPipe = TSP_pipe;
772   }
773   return false;
774 }
775 
776 bool DeclSpec::SetTypeAltiVecPixel(bool isAltiVecPixel, SourceLocation Loc,
777                           const char *&PrevSpec, unsigned &DiagID,
778                           const PrintingPolicy &Policy) {
779   if (!TypeAltiVecVector || TypeAltiVecPixel ||
780       (TypeSpecType != TST_unspecified)) {
781     PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType, Policy);
782     DiagID = diag::err_invalid_pixel_decl_spec_combination;
783     return true;
784   }
785   TypeAltiVecPixel = isAltiVecPixel;
786   TSTLoc = Loc;
787   TSTNameLoc = Loc;
788   return false;
789 }
790 
791 bool DeclSpec::SetTypeAltiVecBool(bool isAltiVecBool, SourceLocation Loc,
792                                   const char *&PrevSpec, unsigned &DiagID,
793                                   const PrintingPolicy &Policy) {
794   if (!TypeAltiVecVector || TypeAltiVecBool ||
795       (TypeSpecType != TST_unspecified)) {
796     PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType, Policy);
797     DiagID = diag::err_invalid_vector_bool_decl_spec;
798     return true;
799   }
800   TypeAltiVecBool = isAltiVecBool;
801   TSTLoc = Loc;
802   TSTNameLoc = Loc;
803   return false;
804 }
805 
806 bool DeclSpec::SetTypeSpecError() {
807   TypeSpecType = TST_error;
808   TypeSpecOwned = false;
809   TSTLoc = SourceLocation();
810   TSTNameLoc = SourceLocation();
811   return false;
812 }
813 
814 bool DeclSpec::SetTypeQual(TQ T, SourceLocation Loc, const char *&PrevSpec,
815                            unsigned &DiagID, const LangOptions &Lang) {
816   // Duplicates are permitted in C99 onwards, but are not permitted in C89 or
817   // C++.  However, since this is likely not what the user intended, we will
818   // always warn.  We do not need to set the qualifier's location since we
819   // already have it.
820   if (TypeQualifiers & T) {
821     bool IsExtension = true;
822     if (Lang.C99)
823       IsExtension = false;
824     return BadSpecifier(T, T, PrevSpec, DiagID, IsExtension);
825   }
826   TypeQualifiers |= T;
827 
828   switch (T) {
829   case TQ_unspecified: break;
830   case TQ_const:    TQ_constLoc = Loc; return false;
831   case TQ_restrict: TQ_restrictLoc = Loc; return false;
832   case TQ_volatile: TQ_volatileLoc = Loc; return false;
833   case TQ_unaligned: TQ_unalignedLoc = Loc; return false;
834   case TQ_atomic:   TQ_atomicLoc = Loc; return false;
835   }
836 
837   llvm_unreachable("Unknown type qualifier!");
838 }
839 
840 bool DeclSpec::setFunctionSpecInline(SourceLocation Loc, const char *&PrevSpec,
841                                      unsigned &DiagID) {
842   // 'inline inline' is ok.  However, since this is likely not what the user
843   // intended, we will always warn, similar to duplicates of type qualifiers.
844   if (FS_inline_specified) {
845     DiagID = diag::warn_duplicate_declspec;
846     PrevSpec = "inline";
847     return true;
848   }
849   FS_inline_specified = true;
850   FS_inlineLoc = Loc;
851   return false;
852 }
853 
854 bool DeclSpec::setFunctionSpecForceInline(SourceLocation Loc, const char *&PrevSpec,
855                                           unsigned &DiagID) {
856   if (FS_forceinline_specified) {
857     DiagID = diag::warn_duplicate_declspec;
858     PrevSpec = "__forceinline";
859     return true;
860   }
861   FS_forceinline_specified = true;
862   FS_forceinlineLoc = Loc;
863   return false;
864 }
865 
866 bool DeclSpec::setFunctionSpecVirtual(SourceLocation Loc,
867                                       const char *&PrevSpec,
868                                       unsigned &DiagID) {
869   // 'virtual virtual' is ok, but warn as this is likely not what the user
870   // intended.
871   if (FS_virtual_specified) {
872     DiagID = diag::warn_duplicate_declspec;
873     PrevSpec = "virtual";
874     return true;
875   }
876   FS_virtual_specified = true;
877   FS_virtualLoc = Loc;
878   return false;
879 }
880 
881 bool DeclSpec::setFunctionSpecExplicit(SourceLocation Loc,
882                                        const char *&PrevSpec,
883                                        unsigned &DiagID) {
884   // 'explicit explicit' is ok, but warn as this is likely not what the user
885   // intended.
886   if (FS_explicit_specified) {
887     DiagID = diag::warn_duplicate_declspec;
888     PrevSpec = "explicit";
889     return true;
890   }
891   FS_explicit_specified = true;
892   FS_explicitLoc = Loc;
893   return false;
894 }
895 
896 bool DeclSpec::setFunctionSpecNoreturn(SourceLocation Loc,
897                                        const char *&PrevSpec,
898                                        unsigned &DiagID) {
899   // '_Noreturn _Noreturn' is ok, but warn as this is likely not what the user
900   // intended.
901   if (FS_noreturn_specified) {
902     DiagID = diag::warn_duplicate_declspec;
903     PrevSpec = "_Noreturn";
904     return true;
905   }
906   FS_noreturn_specified = true;
907   FS_noreturnLoc = Loc;
908   return false;
909 }
910 
911 bool DeclSpec::SetFriendSpec(SourceLocation Loc, const char *&PrevSpec,
912                              unsigned &DiagID) {
913   if (Friend_specified) {
914     PrevSpec = "friend";
915     // Keep the later location, so that we can later diagnose ill-formed
916     // declarations like 'friend class X friend;'. Per [class.friend]p3,
917     // 'friend' must be the first token in a friend declaration that is
918     // not a function declaration.
919     FriendLoc = Loc;
920     DiagID = diag::warn_duplicate_declspec;
921     return true;
922   }
923 
924   Friend_specified = true;
925   FriendLoc = Loc;
926   return false;
927 }
928 
929 bool DeclSpec::setModulePrivateSpec(SourceLocation Loc, const char *&PrevSpec,
930                                     unsigned &DiagID) {
931   if (isModulePrivateSpecified()) {
932     PrevSpec = "__module_private__";
933     DiagID = diag::ext_duplicate_declspec;
934     return true;
935   }
936 
937   ModulePrivateLoc = Loc;
938   return false;
939 }
940 
941 bool DeclSpec::SetConstexprSpec(SourceLocation Loc, const char *&PrevSpec,
942                                 unsigned &DiagID) {
943   // 'constexpr constexpr' is ok, but warn as this is likely not what the user
944   // intended.
945   if (Constexpr_specified) {
946     DiagID = diag::warn_duplicate_declspec;
947     PrevSpec = "constexpr";
948     return true;
949   }
950   Constexpr_specified = true;
951   ConstexprLoc = Loc;
952   return false;
953 }
954 
955 bool DeclSpec::SetConceptSpec(SourceLocation Loc, const char *&PrevSpec,
956                               unsigned &DiagID) {
957   if (Concept_specified) {
958     DiagID = diag::ext_duplicate_declspec;
959     PrevSpec = "concept";
960     return true;
961   }
962   Concept_specified = true;
963   ConceptLoc = Loc;
964   return false;
965 }
966 
967 void DeclSpec::SaveWrittenBuiltinSpecs() {
968   writtenBS.Sign = getTypeSpecSign();
969   writtenBS.Width = getTypeSpecWidth();
970   writtenBS.Type = getTypeSpecType();
971   // Search the list of attributes for the presence of a mode attribute.
972   writtenBS.ModeAttr = false;
973   AttributeList* attrs = getAttributes().getList();
974   while (attrs) {
975     if (attrs->getKind() == AttributeList::AT_Mode) {
976       writtenBS.ModeAttr = true;
977       break;
978     }
979     attrs = attrs->getNext();
980   }
981 }
982 
983 /// Finish - This does final analysis of the declspec, rejecting things like
984 /// "_Imaginary" (lacking an FP type).  This returns a diagnostic to issue or
985 /// diag::NUM_DIAGNOSTICS if there is no error.  After calling this method,
986 /// DeclSpec is guaranteed self-consistent, even if an error occurred.
987 void DeclSpec::Finish(Sema &S, const PrintingPolicy &Policy) {
988   // Before possibly changing their values, save specs as written.
989   SaveWrittenBuiltinSpecs();
990 
991   // Check the type specifier components first.
992 
993   // If decltype(auto) is used, no other type specifiers are permitted.
994   if (TypeSpecType == TST_decltype_auto &&
995       (TypeSpecWidth != TSW_unspecified ||
996        TypeSpecComplex != TSC_unspecified ||
997        TypeSpecSign != TSS_unspecified ||
998        TypeAltiVecVector || TypeAltiVecPixel || TypeAltiVecBool ||
999        TypeQualifiers)) {
1000     const unsigned NumLocs = 9;
1001     SourceLocation ExtraLocs[NumLocs] = {
1002         TSWRange.getBegin(), TSCLoc,       TSSLoc,
1003         AltiVecLoc,          TQ_constLoc,  TQ_restrictLoc,
1004         TQ_volatileLoc,      TQ_atomicLoc, TQ_unalignedLoc};
1005     FixItHint Hints[NumLocs];
1006     SourceLocation FirstLoc;
1007     for (unsigned I = 0; I != NumLocs; ++I) {
1008       if (ExtraLocs[I].isValid()) {
1009         if (FirstLoc.isInvalid() ||
1010             S.getSourceManager().isBeforeInTranslationUnit(ExtraLocs[I],
1011                                                            FirstLoc))
1012           FirstLoc = ExtraLocs[I];
1013         Hints[I] = FixItHint::CreateRemoval(ExtraLocs[I]);
1014       }
1015     }
1016     TypeSpecWidth = TSW_unspecified;
1017     TypeSpecComplex = TSC_unspecified;
1018     TypeSpecSign = TSS_unspecified;
1019     TypeAltiVecVector = TypeAltiVecPixel = TypeAltiVecBool = false;
1020     TypeQualifiers = 0;
1021     S.Diag(TSTLoc, diag::err_decltype_auto_cannot_be_combined)
1022       << Hints[0] << Hints[1] << Hints[2] << Hints[3]
1023       << Hints[4] << Hints[5] << Hints[6] << Hints[7];
1024   }
1025 
1026   // Validate and finalize AltiVec vector declspec.
1027   if (TypeAltiVecVector) {
1028     if (TypeAltiVecBool) {
1029       // Sign specifiers are not allowed with vector bool. (PIM 2.1)
1030       if (TypeSpecSign != TSS_unspecified) {
1031         S.Diag(TSSLoc, diag::err_invalid_vector_bool_decl_spec)
1032           << getSpecifierName((TSS)TypeSpecSign);
1033       }
1034 
1035       // Only char/int are valid with vector bool. (PIM 2.1)
1036       if (((TypeSpecType != TST_unspecified) && (TypeSpecType != TST_char) &&
1037            (TypeSpecType != TST_int)) || TypeAltiVecPixel) {
1038         S.Diag(TSTLoc, diag::err_invalid_vector_bool_decl_spec)
1039           << (TypeAltiVecPixel ? "__pixel" :
1040                                  getSpecifierName((TST)TypeSpecType, Policy));
1041       }
1042 
1043       // Only 'short' and 'long long' are valid with vector bool. (PIM 2.1)
1044       if ((TypeSpecWidth != TSW_unspecified) && (TypeSpecWidth != TSW_short) &&
1045           (TypeSpecWidth != TSW_longlong))
1046         S.Diag(TSWRange.getBegin(), diag::err_invalid_vector_bool_decl_spec)
1047             << getSpecifierName((TSW)TypeSpecWidth);
1048 
1049       // vector bool long long requires VSX support or ZVector.
1050       if ((TypeSpecWidth == TSW_longlong) &&
1051           (!S.Context.getTargetInfo().hasFeature("vsx")) &&
1052           (!S.Context.getTargetInfo().hasFeature("power8-vector")) &&
1053           !S.getLangOpts().ZVector)
1054         S.Diag(TSTLoc, diag::err_invalid_vector_long_long_decl_spec);
1055 
1056       // Elements of vector bool are interpreted as unsigned. (PIM 2.1)
1057       if ((TypeSpecType == TST_char) || (TypeSpecType == TST_int) ||
1058           (TypeSpecWidth != TSW_unspecified))
1059         TypeSpecSign = TSS_unsigned;
1060     } else if (TypeSpecType == TST_double) {
1061       // vector long double and vector long long double are never allowed.
1062       // vector double is OK for Power7 and later, and ZVector.
1063       if (TypeSpecWidth == TSW_long || TypeSpecWidth == TSW_longlong)
1064         S.Diag(TSWRange.getBegin(),
1065                diag::err_invalid_vector_long_double_decl_spec);
1066       else if (!S.Context.getTargetInfo().hasFeature("vsx") &&
1067                !S.getLangOpts().ZVector)
1068         S.Diag(TSTLoc, diag::err_invalid_vector_double_decl_spec);
1069     } else if (TypeSpecType == TST_float) {
1070       // vector float is unsupported for ZVector.
1071       if (S.getLangOpts().ZVector)
1072         S.Diag(TSTLoc, diag::err_invalid_vector_float_decl_spec);
1073     } else if (TypeSpecWidth == TSW_long) {
1074       // vector long is unsupported for ZVector and deprecated for AltiVec.
1075       if (S.getLangOpts().ZVector)
1076         S.Diag(TSWRange.getBegin(), diag::err_invalid_vector_long_decl_spec);
1077       else
1078         S.Diag(TSWRange.getBegin(),
1079                diag::warn_vector_long_decl_spec_combination)
1080             << getSpecifierName((TST)TypeSpecType, Policy);
1081     }
1082 
1083     if (TypeAltiVecPixel) {
1084       //TODO: perform validation
1085       TypeSpecType = TST_int;
1086       TypeSpecSign = TSS_unsigned;
1087       TypeSpecWidth = TSW_short;
1088       TypeSpecOwned = false;
1089     }
1090   }
1091 
1092   // signed/unsigned are only valid with int/char/wchar_t.
1093   if (TypeSpecSign != TSS_unspecified) {
1094     if (TypeSpecType == TST_unspecified)
1095       TypeSpecType = TST_int; // unsigned -> unsigned int, signed -> signed int.
1096     else if (TypeSpecType != TST_int  && TypeSpecType != TST_int128 &&
1097              TypeSpecType != TST_char && TypeSpecType != TST_wchar) {
1098       S.Diag(TSSLoc, diag::err_invalid_sign_spec)
1099         << getSpecifierName((TST)TypeSpecType, Policy);
1100       // signed double -> double.
1101       TypeSpecSign = TSS_unspecified;
1102     }
1103   }
1104 
1105   // Validate the width of the type.
1106   switch (TypeSpecWidth) {
1107   case TSW_unspecified: break;
1108   case TSW_short:    // short int
1109   case TSW_longlong: // long long int
1110     if (TypeSpecType == TST_unspecified)
1111       TypeSpecType = TST_int; // short -> short int, long long -> long long int.
1112     else if (TypeSpecType != TST_int) {
1113       S.Diag(TSWRange.getBegin(), diag::err_invalid_width_spec)
1114           << (int)TypeSpecWidth << getSpecifierName((TST)TypeSpecType, Policy);
1115       TypeSpecType = TST_int;
1116       TypeSpecOwned = false;
1117     }
1118     break;
1119   case TSW_long:  // long double, long int
1120     if (TypeSpecType == TST_unspecified)
1121       TypeSpecType = TST_int;  // long -> long int.
1122     else if (TypeSpecType != TST_int && TypeSpecType != TST_double) {
1123       S.Diag(TSWRange.getBegin(), diag::err_invalid_width_spec)
1124           << (int)TypeSpecWidth << getSpecifierName((TST)TypeSpecType, Policy);
1125       TypeSpecType = TST_int;
1126       TypeSpecOwned = false;
1127     }
1128     break;
1129   }
1130 
1131   // TODO: if the implementation does not implement _Complex or _Imaginary,
1132   // disallow their use.  Need information about the backend.
1133   if (TypeSpecComplex != TSC_unspecified) {
1134     if (TypeSpecType == TST_unspecified) {
1135       S.Diag(TSCLoc, diag::ext_plain_complex)
1136         << FixItHint::CreateInsertion(
1137                               S.getLocForEndOfToken(getTypeSpecComplexLoc()),
1138                                                  " double");
1139       TypeSpecType = TST_double;   // _Complex -> _Complex double.
1140     } else if (TypeSpecType == TST_int || TypeSpecType == TST_char) {
1141       // Note that this intentionally doesn't include _Complex _Bool.
1142       if (!S.getLangOpts().CPlusPlus)
1143         S.Diag(TSTLoc, diag::ext_integer_complex);
1144     } else if (TypeSpecType != TST_float && TypeSpecType != TST_double) {
1145       S.Diag(TSCLoc, diag::err_invalid_complex_spec)
1146         << getSpecifierName((TST)TypeSpecType, Policy);
1147       TypeSpecComplex = TSC_unspecified;
1148     }
1149   }
1150 
1151   // C11 6.7.1/3, C++11 [dcl.stc]p1, GNU TLS: __thread, thread_local and
1152   // _Thread_local can only appear with the 'static' and 'extern' storage class
1153   // specifiers. We also allow __private_extern__ as an extension.
1154   if (ThreadStorageClassSpec != TSCS_unspecified) {
1155     switch (StorageClassSpec) {
1156     case SCS_unspecified:
1157     case SCS_extern:
1158     case SCS_private_extern:
1159     case SCS_static:
1160       break;
1161     default:
1162       if (S.getSourceManager().isBeforeInTranslationUnit(
1163             getThreadStorageClassSpecLoc(), getStorageClassSpecLoc()))
1164         S.Diag(getStorageClassSpecLoc(),
1165              diag::err_invalid_decl_spec_combination)
1166           << DeclSpec::getSpecifierName(getThreadStorageClassSpec())
1167           << SourceRange(getThreadStorageClassSpecLoc());
1168       else
1169         S.Diag(getThreadStorageClassSpecLoc(),
1170              diag::err_invalid_decl_spec_combination)
1171           << DeclSpec::getSpecifierName(getStorageClassSpec())
1172           << SourceRange(getStorageClassSpecLoc());
1173       // Discard the thread storage class specifier to recover.
1174       ThreadStorageClassSpec = TSCS_unspecified;
1175       ThreadStorageClassSpecLoc = SourceLocation();
1176     }
1177   }
1178 
1179   // If no type specifier was provided and we're parsing a language where
1180   // the type specifier is not optional, but we got 'auto' as a storage
1181   // class specifier, then assume this is an attempt to use C++0x's 'auto'
1182   // type specifier.
1183   if (S.getLangOpts().CPlusPlus &&
1184       TypeSpecType == TST_unspecified && StorageClassSpec == SCS_auto) {
1185     TypeSpecType = TST_auto;
1186     StorageClassSpec = SCS_unspecified;
1187     TSTLoc = TSTNameLoc = StorageClassSpecLoc;
1188     StorageClassSpecLoc = SourceLocation();
1189   }
1190   // Diagnose if we've recovered from an ill-formed 'auto' storage class
1191   // specifier in a pre-C++11 dialect of C++.
1192   if (!S.getLangOpts().CPlusPlus11 && TypeSpecType == TST_auto)
1193     S.Diag(TSTLoc, diag::ext_auto_type_specifier);
1194   if (S.getLangOpts().CPlusPlus && !S.getLangOpts().CPlusPlus11 &&
1195       StorageClassSpec == SCS_auto)
1196     S.Diag(StorageClassSpecLoc, diag::warn_auto_storage_class)
1197       << FixItHint::CreateRemoval(StorageClassSpecLoc);
1198   if (TypeSpecType == TST_char16 || TypeSpecType == TST_char32)
1199     S.Diag(TSTLoc, diag::warn_cxx98_compat_unicode_type)
1200       << (TypeSpecType == TST_char16 ? "char16_t" : "char32_t");
1201   if (Constexpr_specified)
1202     S.Diag(ConstexprLoc, diag::warn_cxx98_compat_constexpr);
1203 
1204   // C++ [class.friend]p6:
1205   //   No storage-class-specifier shall appear in the decl-specifier-seq
1206   //   of a friend declaration.
1207   if (isFriendSpecified() &&
1208       (getStorageClassSpec() || getThreadStorageClassSpec())) {
1209     SmallString<32> SpecName;
1210     SourceLocation SCLoc;
1211     FixItHint StorageHint, ThreadHint;
1212 
1213     if (DeclSpec::SCS SC = getStorageClassSpec()) {
1214       SpecName = getSpecifierName(SC);
1215       SCLoc = getStorageClassSpecLoc();
1216       StorageHint = FixItHint::CreateRemoval(SCLoc);
1217     }
1218 
1219     if (DeclSpec::TSCS TSC = getThreadStorageClassSpec()) {
1220       if (!SpecName.empty()) SpecName += " ";
1221       SpecName += getSpecifierName(TSC);
1222       SCLoc = getThreadStorageClassSpecLoc();
1223       ThreadHint = FixItHint::CreateRemoval(SCLoc);
1224     }
1225 
1226     S.Diag(SCLoc, diag::err_friend_decl_spec)
1227       << SpecName << StorageHint << ThreadHint;
1228 
1229     ClearStorageClassSpecs();
1230   }
1231 
1232   // C++11 [dcl.fct.spec]p5:
1233   //   The virtual specifier shall be used only in the initial
1234   //   declaration of a non-static class member function;
1235   // C++11 [dcl.fct.spec]p6:
1236   //   The explicit specifier shall be used only in the declaration of
1237   //   a constructor or conversion function within its class
1238   //   definition;
1239   if (isFriendSpecified() && (isVirtualSpecified() || isExplicitSpecified())) {
1240     StringRef Keyword;
1241     SourceLocation SCLoc;
1242 
1243     if (isVirtualSpecified()) {
1244       Keyword = "virtual";
1245       SCLoc = getVirtualSpecLoc();
1246     } else {
1247       Keyword = "explicit";
1248       SCLoc = getExplicitSpecLoc();
1249     }
1250 
1251     FixItHint Hint = FixItHint::CreateRemoval(SCLoc);
1252     S.Diag(SCLoc, diag::err_friend_decl_spec)
1253       << Keyword << Hint;
1254 
1255     FS_virtual_specified = FS_explicit_specified = false;
1256     FS_virtualLoc = FS_explicitLoc = SourceLocation();
1257   }
1258 
1259   assert(!TypeSpecOwned || isDeclRep((TST) TypeSpecType));
1260 
1261   // Okay, now we can infer the real type.
1262 
1263   // TODO: return "auto function" and other bad things based on the real type.
1264 
1265   // 'data definition has no type or storage class'?
1266 }
1267 
1268 bool DeclSpec::isMissingDeclaratorOk() {
1269   TST tst = getTypeSpecType();
1270   return isDeclRep(tst) && getRepAsDecl() != nullptr &&
1271     StorageClassSpec != DeclSpec::SCS_typedef;
1272 }
1273 
1274 void UnqualifiedId::setOperatorFunctionId(SourceLocation OperatorLoc,
1275                                           OverloadedOperatorKind Op,
1276                                           SourceLocation SymbolLocations[3]) {
1277   Kind = IK_OperatorFunctionId;
1278   StartLocation = OperatorLoc;
1279   EndLocation = OperatorLoc;
1280   OperatorFunctionId.Operator = Op;
1281   for (unsigned I = 0; I != 3; ++I) {
1282     OperatorFunctionId.SymbolLocations[I] = SymbolLocations[I].getRawEncoding();
1283 
1284     if (SymbolLocations[I].isValid())
1285       EndLocation = SymbolLocations[I];
1286   }
1287 }
1288 
1289 bool VirtSpecifiers::SetSpecifier(Specifier VS, SourceLocation Loc,
1290                                   const char *&PrevSpec) {
1291   if (!FirstLocation.isValid())
1292     FirstLocation = Loc;
1293   LastLocation = Loc;
1294   LastSpecifier = VS;
1295 
1296   if (Specifiers & VS) {
1297     PrevSpec = getSpecifierName(VS);
1298     return true;
1299   }
1300 
1301   Specifiers |= VS;
1302 
1303   switch (VS) {
1304   default: llvm_unreachable("Unknown specifier!");
1305   case VS_Override: VS_overrideLoc = Loc; break;
1306   case VS_GNU_Final:
1307   case VS_Sealed:
1308   case VS_Final:    VS_finalLoc = Loc; break;
1309   }
1310 
1311   return false;
1312 }
1313 
1314 const char *VirtSpecifiers::getSpecifierName(Specifier VS) {
1315   switch (VS) {
1316   default: llvm_unreachable("Unknown specifier");
1317   case VS_Override: return "override";
1318   case VS_Final: return "final";
1319   case VS_GNU_Final: return "__final";
1320   case VS_Sealed: return "sealed";
1321   }
1322 }
1323