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