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 TSWLoc 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     TSWLoc = 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   return false;
622 }
623 
624 bool DeclSpec::SetTypeSpecComplex(TSC C, SourceLocation Loc,
625                                   const char *&PrevSpec,
626                                   unsigned &DiagID) {
627   if (TypeSpecComplex != TSC_unspecified)
628     return BadSpecifier(C, (TSC)TypeSpecComplex, PrevSpec, DiagID);
629   TypeSpecComplex = C;
630   TSCLoc = Loc;
631   return false;
632 }
633 
634 bool DeclSpec::SetTypeSpecSign(TSS S, SourceLocation Loc,
635                                const char *&PrevSpec,
636                                unsigned &DiagID) {
637   if (TypeSpecSign != TSS_unspecified)
638     return BadSpecifier(S, (TSS)TypeSpecSign, PrevSpec, DiagID);
639   TypeSpecSign = S;
640   TSSLoc = Loc;
641   return false;
642 }
643 
644 bool DeclSpec::SetTypeSpecType(TST T, SourceLocation Loc,
645                                const char *&PrevSpec,
646                                unsigned &DiagID,
647                                ParsedType Rep,
648                                const PrintingPolicy &Policy) {
649   return SetTypeSpecType(T, Loc, Loc, PrevSpec, DiagID, Rep, Policy);
650 }
651 
652 bool DeclSpec::SetTypeSpecType(TST T, SourceLocation TagKwLoc,
653                                SourceLocation TagNameLoc,
654                                const char *&PrevSpec,
655                                unsigned &DiagID,
656                                ParsedType Rep,
657                                const PrintingPolicy &Policy) {
658   assert(isTypeRep(T) && "T does not store a type");
659   assert(Rep && "no type provided!");
660   if (TypeSpecType != TST_unspecified) {
661     PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType, Policy);
662     DiagID = diag::err_invalid_decl_spec_combination;
663     return true;
664   }
665   TypeSpecType = T;
666   TypeRep = Rep;
667   TSTLoc = TagKwLoc;
668   TSTNameLoc = TagNameLoc;
669   TypeSpecOwned = false;
670   return false;
671 }
672 
673 bool DeclSpec::SetTypeSpecType(TST T, SourceLocation Loc,
674                                const char *&PrevSpec,
675                                unsigned &DiagID,
676                                Expr *Rep,
677                                const PrintingPolicy &Policy) {
678   assert(isExprRep(T) && "T does not store an expr");
679   assert(Rep && "no expression provided!");
680   if (TypeSpecType != TST_unspecified) {
681     PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType, Policy);
682     DiagID = diag::err_invalid_decl_spec_combination;
683     return true;
684   }
685   TypeSpecType = T;
686   ExprRep = Rep;
687   TSTLoc = Loc;
688   TSTNameLoc = Loc;
689   TypeSpecOwned = false;
690   return false;
691 }
692 
693 bool DeclSpec::SetTypeSpecType(TST T, SourceLocation Loc,
694                                const char *&PrevSpec,
695                                unsigned &DiagID,
696                                Decl *Rep, bool Owned,
697                                const PrintingPolicy &Policy) {
698   return SetTypeSpecType(T, Loc, Loc, PrevSpec, DiagID, Rep, Owned, Policy);
699 }
700 
701 bool DeclSpec::SetTypeSpecType(TST T, SourceLocation TagKwLoc,
702                                SourceLocation TagNameLoc,
703                                const char *&PrevSpec,
704                                unsigned &DiagID,
705                                Decl *Rep, bool Owned,
706                                const PrintingPolicy &Policy) {
707   assert(isDeclRep(T) && "T does not store a decl");
708   // Unlike the other cases, we don't assert that we actually get a decl.
709 
710   if (TypeSpecType != TST_unspecified) {
711     PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType, Policy);
712     DiagID = diag::err_invalid_decl_spec_combination;
713     return true;
714   }
715   TypeSpecType = T;
716   DeclRep = Rep;
717   TSTLoc = TagKwLoc;
718   TSTNameLoc = TagNameLoc;
719   TypeSpecOwned = Owned && Rep != nullptr;
720   return false;
721 }
722 
723 bool DeclSpec::SetTypeSpecType(TST T, SourceLocation Loc,
724                                const char *&PrevSpec,
725                                unsigned &DiagID,
726                                const PrintingPolicy &Policy) {
727   assert(!isDeclRep(T) && !isTypeRep(T) && !isExprRep(T) &&
728          "rep required for these type-spec kinds!");
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   TSTLoc = Loc;
735   TSTNameLoc = Loc;
736   if (TypeAltiVecVector && (T == TST_bool) && !TypeAltiVecBool) {
737     TypeAltiVecBool = true;
738     return false;
739   }
740   TypeSpecType = T;
741   TypeSpecOwned = false;
742   return false;
743 }
744 
745 bool DeclSpec::SetTypeAltiVecVector(bool isAltiVecVector, SourceLocation Loc,
746                           const char *&PrevSpec, unsigned &DiagID,
747                           const PrintingPolicy &Policy) {
748   if (TypeSpecType != TST_unspecified) {
749     PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType, Policy);
750     DiagID = diag::err_invalid_vector_decl_spec_combination;
751     return true;
752   }
753   TypeAltiVecVector = isAltiVecVector;
754   AltiVecLoc = Loc;
755   return false;
756 }
757 
758 bool DeclSpec::SetTypePipe(bool isPipe, SourceLocation Loc,
759                            const char *&PrevSpec, unsigned &DiagID,
760                            const PrintingPolicy &Policy) {
761 
762   if (TypeSpecType != TST_unspecified) {
763     PrevSpec = DeclSpec::getSpecifierName((TST)TypeSpecType, Policy);
764     DiagID = diag::err_invalid_decl_spec_combination;
765     return true;
766   }
767 
768   if (isPipe) {
769     TypeSpecPipe = TSP_pipe;
770   }
771   return false;
772 }
773 
774 bool DeclSpec::SetTypeAltiVecPixel(bool isAltiVecPixel, SourceLocation Loc,
775                           const char *&PrevSpec, unsigned &DiagID,
776                           const PrintingPolicy &Policy) {
777   if (!TypeAltiVecVector || TypeAltiVecPixel ||
778       (TypeSpecType != TST_unspecified)) {
779     PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType, Policy);
780     DiagID = diag::err_invalid_pixel_decl_spec_combination;
781     return true;
782   }
783   TypeAltiVecPixel = isAltiVecPixel;
784   TSTLoc = Loc;
785   TSTNameLoc = Loc;
786   return false;
787 }
788 
789 bool DeclSpec::SetTypeAltiVecBool(bool isAltiVecBool, SourceLocation Loc,
790                                   const char *&PrevSpec, unsigned &DiagID,
791                                   const PrintingPolicy &Policy) {
792   if (!TypeAltiVecVector || TypeAltiVecBool ||
793       (TypeSpecType != TST_unspecified)) {
794     PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType, Policy);
795     DiagID = diag::err_invalid_vector_bool_decl_spec;
796     return true;
797   }
798   TypeAltiVecBool = isAltiVecBool;
799   TSTLoc = Loc;
800   TSTNameLoc = Loc;
801   return false;
802 }
803 
804 bool DeclSpec::SetTypeSpecError() {
805   TypeSpecType = TST_error;
806   TypeSpecOwned = false;
807   TSTLoc = SourceLocation();
808   TSTNameLoc = SourceLocation();
809   return false;
810 }
811 
812 bool DeclSpec::SetTypeQual(TQ T, SourceLocation Loc, const char *&PrevSpec,
813                            unsigned &DiagID, const LangOptions &Lang) {
814   // Duplicates are permitted in C99 onwards, but are not permitted in C89 or
815   // C++.  However, since this is likely not what the user intended, we will
816   // always warn.  We do not need to set the qualifier's location since we
817   // already have it.
818   if (TypeQualifiers & T) {
819     bool IsExtension = true;
820     if (Lang.C99)
821       IsExtension = false;
822     return BadSpecifier(T, T, PrevSpec, DiagID, IsExtension);
823   }
824   TypeQualifiers |= T;
825 
826   switch (T) {
827   case TQ_unspecified: break;
828   case TQ_const:    TQ_constLoc = Loc; return false;
829   case TQ_restrict: TQ_restrictLoc = Loc; return false;
830   case TQ_volatile: TQ_volatileLoc = Loc; return false;
831   case TQ_unaligned: TQ_unalignedLoc = Loc; return false;
832   case TQ_atomic:   TQ_atomicLoc = Loc; return false;
833   }
834 
835   llvm_unreachable("Unknown type qualifier!");
836 }
837 
838 bool DeclSpec::setFunctionSpecInline(SourceLocation Loc, const char *&PrevSpec,
839                                      unsigned &DiagID) {
840   // 'inline inline' is ok.  However, since this is likely not what the user
841   // intended, we will always warn, similar to duplicates of type qualifiers.
842   if (FS_inline_specified) {
843     DiagID = diag::warn_duplicate_declspec;
844     PrevSpec = "inline";
845     return true;
846   }
847   FS_inline_specified = true;
848   FS_inlineLoc = Loc;
849   return false;
850 }
851 
852 bool DeclSpec::setFunctionSpecForceInline(SourceLocation Loc, const char *&PrevSpec,
853                                           unsigned &DiagID) {
854   if (FS_forceinline_specified) {
855     DiagID = diag::warn_duplicate_declspec;
856     PrevSpec = "__forceinline";
857     return true;
858   }
859   FS_forceinline_specified = true;
860   FS_forceinlineLoc = Loc;
861   return false;
862 }
863 
864 bool DeclSpec::setFunctionSpecVirtual(SourceLocation Loc,
865                                       const char *&PrevSpec,
866                                       unsigned &DiagID) {
867   // 'virtual virtual' is ok, but warn as this is likely not what the user
868   // intended.
869   if (FS_virtual_specified) {
870     DiagID = diag::warn_duplicate_declspec;
871     PrevSpec = "virtual";
872     return true;
873   }
874   FS_virtual_specified = true;
875   FS_virtualLoc = Loc;
876   return false;
877 }
878 
879 bool DeclSpec::setFunctionSpecExplicit(SourceLocation Loc,
880                                        const char *&PrevSpec,
881                                        unsigned &DiagID) {
882   // 'explicit explicit' is ok, but warn as this is likely not what the user
883   // intended.
884   if (FS_explicit_specified) {
885     DiagID = diag::warn_duplicate_declspec;
886     PrevSpec = "explicit";
887     return true;
888   }
889   FS_explicit_specified = true;
890   FS_explicitLoc = Loc;
891   return false;
892 }
893 
894 bool DeclSpec::setFunctionSpecNoreturn(SourceLocation Loc,
895                                        const char *&PrevSpec,
896                                        unsigned &DiagID) {
897   // '_Noreturn _Noreturn' is ok, but warn as this is likely not what the user
898   // intended.
899   if (FS_noreturn_specified) {
900     DiagID = diag::warn_duplicate_declspec;
901     PrevSpec = "_Noreturn";
902     return true;
903   }
904   FS_noreturn_specified = true;
905   FS_noreturnLoc = Loc;
906   return false;
907 }
908 
909 bool DeclSpec::SetFriendSpec(SourceLocation Loc, const char *&PrevSpec,
910                              unsigned &DiagID) {
911   if (Friend_specified) {
912     PrevSpec = "friend";
913     // Keep the later location, so that we can later diagnose ill-formed
914     // declarations like 'friend class X friend;'. Per [class.friend]p3,
915     // 'friend' must be the first token in a friend declaration that is
916     // not a function declaration.
917     FriendLoc = Loc;
918     DiagID = diag::warn_duplicate_declspec;
919     return true;
920   }
921 
922   Friend_specified = true;
923   FriendLoc = Loc;
924   return false;
925 }
926 
927 bool DeclSpec::setModulePrivateSpec(SourceLocation Loc, const char *&PrevSpec,
928                                     unsigned &DiagID) {
929   if (isModulePrivateSpecified()) {
930     PrevSpec = "__module_private__";
931     DiagID = diag::ext_duplicate_declspec;
932     return true;
933   }
934 
935   ModulePrivateLoc = Loc;
936   return false;
937 }
938 
939 bool DeclSpec::SetConstexprSpec(SourceLocation Loc, const char *&PrevSpec,
940                                 unsigned &DiagID) {
941   // 'constexpr constexpr' is ok, but warn as this is likely not what the user
942   // intended.
943   if (Constexpr_specified) {
944     DiagID = diag::warn_duplicate_declspec;
945     PrevSpec = "constexpr";
946     return true;
947   }
948   Constexpr_specified = true;
949   ConstexprLoc = Loc;
950   return false;
951 }
952 
953 bool DeclSpec::SetConceptSpec(SourceLocation Loc, const char *&PrevSpec,
954                               unsigned &DiagID) {
955   if (Concept_specified) {
956     DiagID = diag::ext_duplicate_declspec;
957     PrevSpec = "concept";
958     return true;
959   }
960   Concept_specified = true;
961   ConceptLoc = Loc;
962   return false;
963 }
964 
965 void DeclSpec::SaveWrittenBuiltinSpecs() {
966   writtenBS.Sign = getTypeSpecSign();
967   writtenBS.Width = getTypeSpecWidth();
968   writtenBS.Type = getTypeSpecType();
969   // Search the list of attributes for the presence of a mode attribute.
970   writtenBS.ModeAttr = false;
971   AttributeList* attrs = getAttributes().getList();
972   while (attrs) {
973     if (attrs->getKind() == AttributeList::AT_Mode) {
974       writtenBS.ModeAttr = true;
975       break;
976     }
977     attrs = attrs->getNext();
978   }
979 }
980 
981 /// Finish - This does final analysis of the declspec, rejecting things like
982 /// "_Imaginary" (lacking an FP type).  This returns a diagnostic to issue or
983 /// diag::NUM_DIAGNOSTICS if there is no error.  After calling this method,
984 /// DeclSpec is guaranteed self-consistent, even if an error occurred.
985 void DeclSpec::Finish(Sema &S, const PrintingPolicy &Policy) {
986   // Before possibly changing their values, save specs as written.
987   SaveWrittenBuiltinSpecs();
988 
989   // Check the type specifier components first.
990 
991   // If decltype(auto) is used, no other type specifiers are permitted.
992   if (TypeSpecType == TST_decltype_auto &&
993       (TypeSpecWidth != TSW_unspecified ||
994        TypeSpecComplex != TSC_unspecified ||
995        TypeSpecSign != TSS_unspecified ||
996        TypeAltiVecVector || TypeAltiVecPixel || TypeAltiVecBool ||
997        TypeQualifiers)) {
998     const unsigned NumLocs = 9;
999     SourceLocation ExtraLocs[NumLocs] = {
1000       TSWLoc, TSCLoc, TSSLoc, AltiVecLoc,
1001       TQ_constLoc, TQ_restrictLoc, TQ_volatileLoc, TQ_atomicLoc, TQ_unalignedLoc
1002     };
1003     FixItHint Hints[NumLocs];
1004     SourceLocation FirstLoc;
1005     for (unsigned I = 0; I != NumLocs; ++I) {
1006       if (ExtraLocs[I].isValid()) {
1007         if (FirstLoc.isInvalid() ||
1008             S.getSourceManager().isBeforeInTranslationUnit(ExtraLocs[I],
1009                                                            FirstLoc))
1010           FirstLoc = ExtraLocs[I];
1011         Hints[I] = FixItHint::CreateRemoval(ExtraLocs[I]);
1012       }
1013     }
1014     TypeSpecWidth = TSW_unspecified;
1015     TypeSpecComplex = TSC_unspecified;
1016     TypeSpecSign = TSS_unspecified;
1017     TypeAltiVecVector = TypeAltiVecPixel = TypeAltiVecBool = false;
1018     TypeQualifiers = 0;
1019     S.Diag(TSTLoc, diag::err_decltype_auto_cannot_be_combined)
1020       << Hints[0] << Hints[1] << Hints[2] << Hints[3]
1021       << Hints[4] << Hints[5] << Hints[6] << Hints[7];
1022   }
1023 
1024   // Validate and finalize AltiVec vector declspec.
1025   if (TypeAltiVecVector) {
1026     if (TypeAltiVecBool) {
1027       // Sign specifiers are not allowed with vector bool. (PIM 2.1)
1028       if (TypeSpecSign != TSS_unspecified) {
1029         S.Diag(TSSLoc, diag::err_invalid_vector_bool_decl_spec)
1030           << getSpecifierName((TSS)TypeSpecSign);
1031       }
1032 
1033       // Only char/int are valid with vector bool. (PIM 2.1)
1034       if (((TypeSpecType != TST_unspecified) && (TypeSpecType != TST_char) &&
1035            (TypeSpecType != TST_int)) || TypeAltiVecPixel) {
1036         S.Diag(TSTLoc, diag::err_invalid_vector_bool_decl_spec)
1037           << (TypeAltiVecPixel ? "__pixel" :
1038                                  getSpecifierName((TST)TypeSpecType, Policy));
1039       }
1040 
1041       // Only 'short' and 'long long' are valid with vector bool. (PIM 2.1)
1042       if ((TypeSpecWidth != TSW_unspecified) && (TypeSpecWidth != TSW_short) &&
1043           (TypeSpecWidth != TSW_longlong))
1044         S.Diag(TSWLoc, diag::err_invalid_vector_bool_decl_spec)
1045           << getSpecifierName((TSW)TypeSpecWidth);
1046 
1047       // vector bool long long requires VSX support or ZVector.
1048       if ((TypeSpecWidth == TSW_longlong) &&
1049           (!S.Context.getTargetInfo().hasFeature("vsx")) &&
1050           (!S.Context.getTargetInfo().hasFeature("power8-vector")) &&
1051           !S.getLangOpts().ZVector)
1052         S.Diag(TSTLoc, diag::err_invalid_vector_long_long_decl_spec);
1053 
1054       // Elements of vector bool are interpreted as unsigned. (PIM 2.1)
1055       if ((TypeSpecType == TST_char) || (TypeSpecType == TST_int) ||
1056           (TypeSpecWidth != TSW_unspecified))
1057         TypeSpecSign = TSS_unsigned;
1058     } else if (TypeSpecType == TST_double) {
1059       // vector long double and vector long long double are never allowed.
1060       // vector double is OK for Power7 and later, and ZVector.
1061       if (TypeSpecWidth == TSW_long || TypeSpecWidth == TSW_longlong)
1062         S.Diag(TSWLoc, diag::err_invalid_vector_long_double_decl_spec);
1063       else if (!S.Context.getTargetInfo().hasFeature("vsx") &&
1064                !S.getLangOpts().ZVector)
1065         S.Diag(TSTLoc, diag::err_invalid_vector_double_decl_spec);
1066     } else if (TypeSpecType == TST_float) {
1067       // vector float is unsupported for ZVector.
1068       if (S.getLangOpts().ZVector)
1069         S.Diag(TSTLoc, diag::err_invalid_vector_float_decl_spec);
1070     } else if (TypeSpecWidth == TSW_long) {
1071       // vector long is unsupported for ZVector and deprecated for AltiVec.
1072       if (S.getLangOpts().ZVector)
1073         S.Diag(TSWLoc, diag::err_invalid_vector_long_decl_spec);
1074       else
1075         S.Diag(TSWLoc, diag::warn_vector_long_decl_spec_combination)
1076           << getSpecifierName((TST)TypeSpecType, Policy);
1077     }
1078 
1079     if (TypeAltiVecPixel) {
1080       //TODO: perform validation
1081       TypeSpecType = TST_int;
1082       TypeSpecSign = TSS_unsigned;
1083       TypeSpecWidth = TSW_short;
1084       TypeSpecOwned = false;
1085     }
1086   }
1087 
1088   // signed/unsigned are only valid with int/char/wchar_t.
1089   if (TypeSpecSign != TSS_unspecified) {
1090     if (TypeSpecType == TST_unspecified)
1091       TypeSpecType = TST_int; // unsigned -> unsigned int, signed -> signed int.
1092     else if (TypeSpecType != TST_int  && TypeSpecType != TST_int128 &&
1093              TypeSpecType != TST_char && TypeSpecType != TST_wchar) {
1094       S.Diag(TSSLoc, diag::err_invalid_sign_spec)
1095         << getSpecifierName((TST)TypeSpecType, Policy);
1096       // signed double -> double.
1097       TypeSpecSign = TSS_unspecified;
1098     }
1099   }
1100 
1101   // Validate the width of the type.
1102   switch (TypeSpecWidth) {
1103   case TSW_unspecified: break;
1104   case TSW_short:    // short int
1105   case TSW_longlong: // long long int
1106     if (TypeSpecType == TST_unspecified)
1107       TypeSpecType = TST_int; // short -> short int, long long -> long long int.
1108     else if (TypeSpecType != TST_int) {
1109       S.Diag(TSWLoc, diag::err_invalid_width_spec) << (int)TypeSpecWidth
1110         <<  getSpecifierName((TST)TypeSpecType, Policy);
1111       TypeSpecType = TST_int;
1112       TypeSpecOwned = false;
1113     }
1114     break;
1115   case TSW_long:  // long double, long int
1116     if (TypeSpecType == TST_unspecified)
1117       TypeSpecType = TST_int;  // long -> long int.
1118     else if (TypeSpecType != TST_int && TypeSpecType != TST_double) {
1119       S.Diag(TSWLoc, diag::err_invalid_width_spec) << (int)TypeSpecWidth
1120         << getSpecifierName((TST)TypeSpecType, Policy);
1121       TypeSpecType = TST_int;
1122       TypeSpecOwned = false;
1123     }
1124     break;
1125   }
1126 
1127   // TODO: if the implementation does not implement _Complex or _Imaginary,
1128   // disallow their use.  Need information about the backend.
1129   if (TypeSpecComplex != TSC_unspecified) {
1130     if (TypeSpecType == TST_unspecified) {
1131       S.Diag(TSCLoc, diag::ext_plain_complex)
1132         << FixItHint::CreateInsertion(
1133                               S.getLocForEndOfToken(getTypeSpecComplexLoc()),
1134                                                  " double");
1135       TypeSpecType = TST_double;   // _Complex -> _Complex double.
1136     } else if (TypeSpecType == TST_int || TypeSpecType == TST_char) {
1137       // Note that this intentionally doesn't include _Complex _Bool.
1138       if (!S.getLangOpts().CPlusPlus)
1139         S.Diag(TSTLoc, diag::ext_integer_complex);
1140     } else if (TypeSpecType != TST_float && TypeSpecType != TST_double) {
1141       S.Diag(TSCLoc, diag::err_invalid_complex_spec)
1142         << getSpecifierName((TST)TypeSpecType, Policy);
1143       TypeSpecComplex = TSC_unspecified;
1144     }
1145   }
1146 
1147   // C11 6.7.1/3, C++11 [dcl.stc]p1, GNU TLS: __thread, thread_local and
1148   // _Thread_local can only appear with the 'static' and 'extern' storage class
1149   // specifiers. We also allow __private_extern__ as an extension.
1150   if (ThreadStorageClassSpec != TSCS_unspecified) {
1151     switch (StorageClassSpec) {
1152     case SCS_unspecified:
1153     case SCS_extern:
1154     case SCS_private_extern:
1155     case SCS_static:
1156       break;
1157     default:
1158       if (S.getSourceManager().isBeforeInTranslationUnit(
1159             getThreadStorageClassSpecLoc(), getStorageClassSpecLoc()))
1160         S.Diag(getStorageClassSpecLoc(),
1161              diag::err_invalid_decl_spec_combination)
1162           << DeclSpec::getSpecifierName(getThreadStorageClassSpec())
1163           << SourceRange(getThreadStorageClassSpecLoc());
1164       else
1165         S.Diag(getThreadStorageClassSpecLoc(),
1166              diag::err_invalid_decl_spec_combination)
1167           << DeclSpec::getSpecifierName(getStorageClassSpec())
1168           << SourceRange(getStorageClassSpecLoc());
1169       // Discard the thread storage class specifier to recover.
1170       ThreadStorageClassSpec = TSCS_unspecified;
1171       ThreadStorageClassSpecLoc = SourceLocation();
1172     }
1173   }
1174 
1175   // If no type specifier was provided and we're parsing a language where
1176   // the type specifier is not optional, but we got 'auto' as a storage
1177   // class specifier, then assume this is an attempt to use C++0x's 'auto'
1178   // type specifier.
1179   if (S.getLangOpts().CPlusPlus &&
1180       TypeSpecType == TST_unspecified && StorageClassSpec == SCS_auto) {
1181     TypeSpecType = TST_auto;
1182     StorageClassSpec = SCS_unspecified;
1183     TSTLoc = TSTNameLoc = StorageClassSpecLoc;
1184     StorageClassSpecLoc = SourceLocation();
1185   }
1186   // Diagnose if we've recovered from an ill-formed 'auto' storage class
1187   // specifier in a pre-C++11 dialect of C++.
1188   if (!S.getLangOpts().CPlusPlus11 && TypeSpecType == TST_auto)
1189     S.Diag(TSTLoc, diag::ext_auto_type_specifier);
1190   if (S.getLangOpts().CPlusPlus && !S.getLangOpts().CPlusPlus11 &&
1191       StorageClassSpec == SCS_auto)
1192     S.Diag(StorageClassSpecLoc, diag::warn_auto_storage_class)
1193       << FixItHint::CreateRemoval(StorageClassSpecLoc);
1194   if (TypeSpecType == TST_char16 || TypeSpecType == TST_char32)
1195     S.Diag(TSTLoc, diag::warn_cxx98_compat_unicode_type)
1196       << (TypeSpecType == TST_char16 ? "char16_t" : "char32_t");
1197   if (Constexpr_specified)
1198     S.Diag(ConstexprLoc, diag::warn_cxx98_compat_constexpr);
1199 
1200   // C++ [class.friend]p6:
1201   //   No storage-class-specifier shall appear in the decl-specifier-seq
1202   //   of a friend declaration.
1203   if (isFriendSpecified() &&
1204       (getStorageClassSpec() || getThreadStorageClassSpec())) {
1205     SmallString<32> SpecName;
1206     SourceLocation SCLoc;
1207     FixItHint StorageHint, ThreadHint;
1208 
1209     if (DeclSpec::SCS SC = getStorageClassSpec()) {
1210       SpecName = getSpecifierName(SC);
1211       SCLoc = getStorageClassSpecLoc();
1212       StorageHint = FixItHint::CreateRemoval(SCLoc);
1213     }
1214 
1215     if (DeclSpec::TSCS TSC = getThreadStorageClassSpec()) {
1216       if (!SpecName.empty()) SpecName += " ";
1217       SpecName += getSpecifierName(TSC);
1218       SCLoc = getThreadStorageClassSpecLoc();
1219       ThreadHint = FixItHint::CreateRemoval(SCLoc);
1220     }
1221 
1222     S.Diag(SCLoc, diag::err_friend_decl_spec)
1223       << SpecName << StorageHint << ThreadHint;
1224 
1225     ClearStorageClassSpecs();
1226   }
1227 
1228   // C++11 [dcl.fct.spec]p5:
1229   //   The virtual specifier shall be used only in the initial
1230   //   declaration of a non-static class member function;
1231   // C++11 [dcl.fct.spec]p6:
1232   //   The explicit specifier shall be used only in the declaration of
1233   //   a constructor or conversion function within its class
1234   //   definition;
1235   if (isFriendSpecified() && (isVirtualSpecified() || isExplicitSpecified())) {
1236     StringRef Keyword;
1237     SourceLocation SCLoc;
1238 
1239     if (isVirtualSpecified()) {
1240       Keyword = "virtual";
1241       SCLoc = getVirtualSpecLoc();
1242     } else {
1243       Keyword = "explicit";
1244       SCLoc = getExplicitSpecLoc();
1245     }
1246 
1247     FixItHint Hint = FixItHint::CreateRemoval(SCLoc);
1248     S.Diag(SCLoc, diag::err_friend_decl_spec)
1249       << Keyword << Hint;
1250 
1251     FS_virtual_specified = FS_explicit_specified = false;
1252     FS_virtualLoc = FS_explicitLoc = SourceLocation();
1253   }
1254 
1255   assert(!TypeSpecOwned || isDeclRep((TST) TypeSpecType));
1256 
1257   // Okay, now we can infer the real type.
1258 
1259   // TODO: return "auto function" and other bad things based on the real type.
1260 
1261   // 'data definition has no type or storage class'?
1262 }
1263 
1264 bool DeclSpec::isMissingDeclaratorOk() {
1265   TST tst = getTypeSpecType();
1266   return isDeclRep(tst) && getRepAsDecl() != nullptr &&
1267     StorageClassSpec != DeclSpec::SCS_typedef;
1268 }
1269 
1270 void UnqualifiedId::setOperatorFunctionId(SourceLocation OperatorLoc,
1271                                           OverloadedOperatorKind Op,
1272                                           SourceLocation SymbolLocations[3]) {
1273   Kind = IK_OperatorFunctionId;
1274   StartLocation = OperatorLoc;
1275   EndLocation = OperatorLoc;
1276   OperatorFunctionId.Operator = Op;
1277   for (unsigned I = 0; I != 3; ++I) {
1278     OperatorFunctionId.SymbolLocations[I] = SymbolLocations[I].getRawEncoding();
1279 
1280     if (SymbolLocations[I].isValid())
1281       EndLocation = SymbolLocations[I];
1282   }
1283 }
1284 
1285 bool VirtSpecifiers::SetSpecifier(Specifier VS, SourceLocation Loc,
1286                                   const char *&PrevSpec) {
1287   if (!FirstLocation.isValid())
1288     FirstLocation = Loc;
1289   LastLocation = Loc;
1290   LastSpecifier = VS;
1291 
1292   if (Specifiers & VS) {
1293     PrevSpec = getSpecifierName(VS);
1294     return true;
1295   }
1296 
1297   Specifiers |= VS;
1298 
1299   switch (VS) {
1300   default: llvm_unreachable("Unknown specifier!");
1301   case VS_Override: VS_overrideLoc = Loc; break;
1302   case VS_GNU_Final:
1303   case VS_Sealed:
1304   case VS_Final:    VS_finalLoc = Loc; break;
1305   }
1306 
1307   return false;
1308 }
1309 
1310 const char *VirtSpecifiers::getSpecifierName(Specifier VS) {
1311   switch (VS) {
1312   default: llvm_unreachable("Unknown specifier");
1313   case VS_Override: return "override";
1314   case VS_Final: return "final";
1315   case VS_GNU_Final: return "__final";
1316   case VS_Sealed: return "sealed";
1317   }
1318 }
1319