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