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