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