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