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