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>
32using namespace clang;
33
34
35static DiagnosticBuilder Diag(DiagnosticsEngine &D, SourceLocation Loc,
36                              unsigned DiagID) {
37  return D.Report(Loc, DiagID);
38}
39
40
41void 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
49void 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
57void 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
68void 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
81void 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
94void 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
107void 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
117void 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
129void CXXScopeSpec::MakeTrivial(ASTContext &Context,
130                               NestedNameSpecifier *Qualifier, SourceRange R) {
131  Builder.MakeTrivial(Context, Qualifier, R);
132  Range = R;
133}
134
135void 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
146SourceLocation CXXScopeSpec::getLastQualifierNameLoc() const {
147  if (!Builder.getRepresentation())
148    return SourceLocation();
149  return Builder.getTemporary().getLocalBeginLoc();
150}
151
152NestedNameSpecifierLoc
153CXXScopeSpec::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.
162DeclaratorChunk 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
270bool 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
345bool 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
353bool 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///
362unsigned 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
380template <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
393const 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
407const 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
417const 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
427const 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
437const 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
446const 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
483const 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
494bool 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
555bool 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).
569bool 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
584bool 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
594bool 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
604bool 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
612bool 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
633bool 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
653bool 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
661bool 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
683bool 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
705bool 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
718bool 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
733bool 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
748bool DeclSpec::SetTypeSpecError() {
749  TypeSpecType = TST_error;
750  TypeSpecOwned = false;
751  TSTLoc = SourceLocation();
752  TSTNameLoc = SourceLocation();
753  return false;
754}
755
756bool 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
781bool 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
795bool 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
807bool 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
822bool 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
837bool 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
852bool 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
870bool 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
882bool 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
896void DeclSpec::setProtocolQualifiers(Decl * const *Protos,
897                                     unsigned NP,
898                                     SourceLocation *ProtoLocs,
899                                     SourceLocation LAngleLoc) {
900  if (NP == 0) return;
901  Decl **ProtoQuals = new Decl*[NP];
902  memcpy(ProtoQuals, Protos, sizeof(Decl*)*NP);
903  ProtocolQualifiers = ProtoQuals;
904  ProtocolLocs = new SourceLocation[NP];
905  memcpy(ProtocolLocs, ProtoLocs, sizeof(SourceLocation)*NP);
906  NumProtocolQualifiers = NP;
907  ProtocolLAngleLoc = LAngleLoc;
908}
909
910void DeclSpec::SaveWrittenBuiltinSpecs() {
911  writtenBS.Sign = getTypeSpecSign();
912  writtenBS.Width = getTypeSpecWidth();
913  writtenBS.Type = getTypeSpecType();
914  // Search the list of attributes for the presence of a mode attribute.
915  writtenBS.ModeAttr = false;
916  AttributeList* attrs = getAttributes().getList();
917  while (attrs) {
918    if (attrs->getKind() == AttributeList::AT_Mode) {
919      writtenBS.ModeAttr = true;
920      break;
921    }
922    attrs = attrs->getNext();
923  }
924}
925
926/// Finish - This does final analysis of the declspec, rejecting things like
927/// "_Imaginary" (lacking an FP type).  This returns a diagnostic to issue or
928/// diag::NUM_DIAGNOSTICS if there is no error.  After calling this method,
929/// DeclSpec is guaranteed self-consistent, even if an error occurred.
930void DeclSpec::Finish(DiagnosticsEngine &D, Preprocessor &PP, const PrintingPolicy &Policy) {
931  // Before possibly changing their values, save specs as written.
932  SaveWrittenBuiltinSpecs();
933
934  // Check the type specifier components first.
935
936  // If decltype(auto) is used, no other type specifiers are permitted.
937  if (TypeSpecType == TST_decltype_auto &&
938      (TypeSpecWidth != TSW_unspecified ||
939       TypeSpecComplex != TSC_unspecified ||
940       TypeSpecSign != TSS_unspecified ||
941       TypeAltiVecVector || TypeAltiVecPixel || TypeAltiVecBool ||
942       TypeQualifiers)) {
943    const unsigned NumLocs = 8;
944    SourceLocation ExtraLocs[NumLocs] = {
945      TSWLoc, TSCLoc, TSSLoc, AltiVecLoc,
946      TQ_constLoc, TQ_restrictLoc, TQ_volatileLoc, TQ_atomicLoc
947    };
948    FixItHint Hints[NumLocs];
949    SourceLocation FirstLoc;
950    for (unsigned I = 0; I != NumLocs; ++I) {
951      if (!ExtraLocs[I].isInvalid()) {
952        if (FirstLoc.isInvalid() ||
953            PP.getSourceManager().isBeforeInTranslationUnit(ExtraLocs[I],
954                                                            FirstLoc))
955          FirstLoc = ExtraLocs[I];
956        Hints[I] = FixItHint::CreateRemoval(ExtraLocs[I]);
957      }
958    }
959    TypeSpecWidth = TSW_unspecified;
960    TypeSpecComplex = TSC_unspecified;
961    TypeSpecSign = TSS_unspecified;
962    TypeAltiVecVector = TypeAltiVecPixel = TypeAltiVecBool = false;
963    TypeQualifiers = 0;
964    Diag(D, TSTLoc, diag::err_decltype_auto_cannot_be_combined)
965      << Hints[0] << Hints[1] << Hints[2] << Hints[3]
966      << Hints[4] << Hints[5] << Hints[6] << Hints[7];
967  }
968
969  // Validate and finalize AltiVec vector declspec.
970  if (TypeAltiVecVector) {
971    if (TypeAltiVecBool) {
972      // Sign specifiers are not allowed with vector bool. (PIM 2.1)
973      if (TypeSpecSign != TSS_unspecified) {
974        Diag(D, TSSLoc, diag::err_invalid_vector_bool_decl_spec)
975          << getSpecifierName((TSS)TypeSpecSign);
976      }
977
978      // Only char/int are valid with vector bool. (PIM 2.1)
979      if (((TypeSpecType != TST_unspecified) && (TypeSpecType != TST_char) &&
980           (TypeSpecType != TST_int)) || TypeAltiVecPixel) {
981        Diag(D, TSTLoc, diag::err_invalid_vector_bool_decl_spec)
982          << (TypeAltiVecPixel ? "__pixel" :
983                                 getSpecifierName((TST)TypeSpecType, Policy));
984      }
985
986      // Only 'short' and 'long long' are valid with vector bool. (PIM 2.1)
987      if ((TypeSpecWidth != TSW_unspecified) && (TypeSpecWidth != TSW_short) &&
988          (TypeSpecWidth != TSW_longlong))
989        Diag(D, TSWLoc, diag::err_invalid_vector_bool_decl_spec)
990          << getSpecifierName((TSW)TypeSpecWidth);
991
992      // vector bool long long requires VSX support.
993      if ((TypeSpecWidth == TSW_longlong) &&
994          (!PP.getTargetInfo().hasFeature("vsx")) &&
995          (!PP.getTargetInfo().hasFeature("power8-vector")))
996        Diag(D, TSTLoc, diag::err_invalid_vector_long_long_decl_spec);
997
998      // Elements of vector bool are interpreted as unsigned. (PIM 2.1)
999      if ((TypeSpecType == TST_char) || (TypeSpecType == TST_int) ||
1000          (TypeSpecWidth != TSW_unspecified))
1001        TypeSpecSign = TSS_unsigned;
1002    } else if (TypeSpecType == TST_double) {
1003      // vector long double and vector long long double are never allowed.
1004      // vector double is OK for Power7 and later.
1005      if (TypeSpecWidth == TSW_long || TypeSpecWidth == TSW_longlong)
1006        Diag(D, TSWLoc, diag::err_invalid_vector_long_double_decl_spec);
1007      else if (!PP.getTargetInfo().hasFeature("vsx"))
1008        Diag(D, TSTLoc, diag::err_invalid_vector_double_decl_spec);
1009    } else if (TypeSpecWidth == TSW_long) {
1010      Diag(D, TSWLoc, diag::warn_vector_long_decl_spec_combination)
1011        << getSpecifierName((TST)TypeSpecType, Policy);
1012    }
1013
1014    if (TypeAltiVecPixel) {
1015      //TODO: perform validation
1016      TypeSpecType = TST_int;
1017      TypeSpecSign = TSS_unsigned;
1018      TypeSpecWidth = TSW_short;
1019      TypeSpecOwned = false;
1020    }
1021  }
1022
1023  // signed/unsigned are only valid with int/char/wchar_t.
1024  if (TypeSpecSign != TSS_unspecified) {
1025    if (TypeSpecType == TST_unspecified)
1026      TypeSpecType = TST_int; // unsigned -> unsigned int, signed -> signed int.
1027    else if (TypeSpecType != TST_int  && TypeSpecType != TST_int128 &&
1028             TypeSpecType != TST_char && TypeSpecType != TST_wchar) {
1029      Diag(D, TSSLoc, diag::err_invalid_sign_spec)
1030        << getSpecifierName((TST)TypeSpecType, Policy);
1031      // signed double -> double.
1032      TypeSpecSign = TSS_unspecified;
1033    }
1034  }
1035
1036  // Validate the width of the type.
1037  switch (TypeSpecWidth) {
1038  case TSW_unspecified: break;
1039  case TSW_short:    // short int
1040  case TSW_longlong: // long long int
1041    if (TypeSpecType == TST_unspecified)
1042      TypeSpecType = TST_int; // short -> short int, long long -> long long int.
1043    else if (TypeSpecType != TST_int) {
1044      Diag(D, TSWLoc,
1045           TypeSpecWidth == TSW_short ? diag::err_invalid_short_spec
1046                                      : diag::err_invalid_longlong_spec)
1047        <<  getSpecifierName((TST)TypeSpecType, Policy);
1048      TypeSpecType = TST_int;
1049      TypeSpecOwned = false;
1050    }
1051    break;
1052  case TSW_long:  // long double, long int
1053    if (TypeSpecType == TST_unspecified)
1054      TypeSpecType = TST_int;  // long -> long int.
1055    else if (TypeSpecType != TST_int && TypeSpecType != TST_double) {
1056      Diag(D, TSWLoc, diag::err_invalid_long_spec)
1057        << getSpecifierName((TST)TypeSpecType, Policy);
1058      TypeSpecType = TST_int;
1059      TypeSpecOwned = false;
1060    }
1061    break;
1062  }
1063
1064  // TODO: if the implementation does not implement _Complex or _Imaginary,
1065  // disallow their use.  Need information about the backend.
1066  if (TypeSpecComplex != TSC_unspecified) {
1067    if (TypeSpecType == TST_unspecified) {
1068      Diag(D, TSCLoc, diag::ext_plain_complex)
1069        << FixItHint::CreateInsertion(
1070                              PP.getLocForEndOfToken(getTypeSpecComplexLoc()),
1071                                                 " double");
1072      TypeSpecType = TST_double;   // _Complex -> _Complex double.
1073    } else if (TypeSpecType == TST_int || TypeSpecType == TST_char) {
1074      // Note that this intentionally doesn't include _Complex _Bool.
1075      if (!PP.getLangOpts().CPlusPlus)
1076        Diag(D, TSTLoc, diag::ext_integer_complex);
1077    } else if (TypeSpecType != TST_float && TypeSpecType != TST_double) {
1078      Diag(D, TSCLoc, diag::err_invalid_complex_spec)
1079        << getSpecifierName((TST)TypeSpecType, Policy);
1080      TypeSpecComplex = TSC_unspecified;
1081    }
1082  }
1083
1084  // C11 6.7.1/3, C++11 [dcl.stc]p1, GNU TLS: __thread, thread_local and
1085  // _Thread_local can only appear with the 'static' and 'extern' storage class
1086  // specifiers. We also allow __private_extern__ as an extension.
1087  if (ThreadStorageClassSpec != TSCS_unspecified) {
1088    switch (StorageClassSpec) {
1089    case SCS_unspecified:
1090    case SCS_extern:
1091    case SCS_private_extern:
1092    case SCS_static:
1093      break;
1094    default:
1095      if (PP.getSourceManager().isBeforeInTranslationUnit(
1096            getThreadStorageClassSpecLoc(), getStorageClassSpecLoc()))
1097        Diag(D, getStorageClassSpecLoc(),
1098             diag::err_invalid_decl_spec_combination)
1099          << DeclSpec::getSpecifierName(getThreadStorageClassSpec())
1100          << SourceRange(getThreadStorageClassSpecLoc());
1101      else
1102        Diag(D, getThreadStorageClassSpecLoc(),
1103             diag::err_invalid_decl_spec_combination)
1104          << DeclSpec::getSpecifierName(getStorageClassSpec())
1105          << SourceRange(getStorageClassSpecLoc());
1106      // Discard the thread storage class specifier to recover.
1107      ThreadStorageClassSpec = TSCS_unspecified;
1108      ThreadStorageClassSpecLoc = SourceLocation();
1109    }
1110  }
1111
1112  // If no type specifier was provided and we're parsing a language where
1113  // the type specifier is not optional, but we got 'auto' as a storage
1114  // class specifier, then assume this is an attempt to use C++0x's 'auto'
1115  // type specifier.
1116  if (PP.getLangOpts().CPlusPlus &&
1117      TypeSpecType == TST_unspecified && StorageClassSpec == SCS_auto) {
1118    TypeSpecType = TST_auto;
1119    StorageClassSpec = SCS_unspecified;
1120    TSTLoc = TSTNameLoc = StorageClassSpecLoc;
1121    StorageClassSpecLoc = SourceLocation();
1122  }
1123  // Diagnose if we've recovered from an ill-formed 'auto' storage class
1124  // specifier in a pre-C++11 dialect of C++.
1125  if (!PP.getLangOpts().CPlusPlus11 && TypeSpecType == TST_auto)
1126    Diag(D, TSTLoc, diag::ext_auto_type_specifier);
1127  if (PP.getLangOpts().CPlusPlus && !PP.getLangOpts().CPlusPlus11 &&
1128      StorageClassSpec == SCS_auto)
1129    Diag(D, StorageClassSpecLoc, diag::warn_auto_storage_class)
1130      << FixItHint::CreateRemoval(StorageClassSpecLoc);
1131  if (TypeSpecType == TST_char16 || TypeSpecType == TST_char32)
1132    Diag(D, TSTLoc, diag::warn_cxx98_compat_unicode_type)
1133      << (TypeSpecType == TST_char16 ? "char16_t" : "char32_t");
1134  if (Constexpr_specified)
1135    Diag(D, ConstexprLoc, diag::warn_cxx98_compat_constexpr);
1136
1137  // C++ [class.friend]p6:
1138  //   No storage-class-specifier shall appear in the decl-specifier-seq
1139  //   of a friend declaration.
1140  if (isFriendSpecified() &&
1141      (getStorageClassSpec() || getThreadStorageClassSpec())) {
1142    SmallString<32> SpecName;
1143    SourceLocation SCLoc;
1144    FixItHint StorageHint, ThreadHint;
1145
1146    if (DeclSpec::SCS SC = getStorageClassSpec()) {
1147      SpecName = getSpecifierName(SC);
1148      SCLoc = getStorageClassSpecLoc();
1149      StorageHint = FixItHint::CreateRemoval(SCLoc);
1150    }
1151
1152    if (DeclSpec::TSCS TSC = getThreadStorageClassSpec()) {
1153      if (!SpecName.empty()) SpecName += " ";
1154      SpecName += getSpecifierName(TSC);
1155      SCLoc = getThreadStorageClassSpecLoc();
1156      ThreadHint = FixItHint::CreateRemoval(SCLoc);
1157    }
1158
1159    Diag(D, SCLoc, diag::err_friend_decl_spec)
1160      << SpecName << StorageHint << ThreadHint;
1161
1162    ClearStorageClassSpecs();
1163  }
1164
1165  // C++11 [dcl.fct.spec]p5:
1166  //   The virtual specifier shall be used only in the initial
1167  //   declaration of a non-static class member function;
1168  // C++11 [dcl.fct.spec]p6:
1169  //   The explicit specifier shall be used only in the declaration of
1170  //   a constructor or conversion function within its class
1171  //   definition;
1172  if (isFriendSpecified() && (isVirtualSpecified() || isExplicitSpecified())) {
1173    StringRef Keyword;
1174    SourceLocation SCLoc;
1175
1176    if (isVirtualSpecified()) {
1177      Keyword = "virtual";
1178      SCLoc = getVirtualSpecLoc();
1179    } else {
1180      Keyword = "explicit";
1181      SCLoc = getExplicitSpecLoc();
1182    }
1183
1184    FixItHint Hint = FixItHint::CreateRemoval(SCLoc);
1185    Diag(D, SCLoc, diag::err_friend_decl_spec)
1186      << Keyword << Hint;
1187
1188    FS_virtual_specified = FS_explicit_specified = false;
1189    FS_virtualLoc = FS_explicitLoc = SourceLocation();
1190  }
1191
1192  assert(!TypeSpecOwned || isDeclRep((TST) TypeSpecType));
1193
1194  // Okay, now we can infer the real type.
1195
1196  // TODO: return "auto function" and other bad things based on the real type.
1197
1198  // 'data definition has no type or storage class'?
1199}
1200
1201bool DeclSpec::isMissingDeclaratorOk() {
1202  TST tst = getTypeSpecType();
1203  return isDeclRep(tst) && getRepAsDecl() != nullptr &&
1204    StorageClassSpec != DeclSpec::SCS_typedef;
1205}
1206
1207void UnqualifiedId::setOperatorFunctionId(SourceLocation OperatorLoc,
1208                                          OverloadedOperatorKind Op,
1209                                          SourceLocation SymbolLocations[3]) {
1210  Kind = IK_OperatorFunctionId;
1211  StartLocation = OperatorLoc;
1212  EndLocation = OperatorLoc;
1213  OperatorFunctionId.Operator = Op;
1214  for (unsigned I = 0; I != 3; ++I) {
1215    OperatorFunctionId.SymbolLocations[I] = SymbolLocations[I].getRawEncoding();
1216
1217    if (SymbolLocations[I].isValid())
1218      EndLocation = SymbolLocations[I];
1219  }
1220}
1221
1222bool VirtSpecifiers::SetSpecifier(Specifier VS, SourceLocation Loc,
1223                                  const char *&PrevSpec) {
1224  if (!FirstLocation.isValid())
1225    FirstLocation = Loc;
1226  LastLocation = Loc;
1227  LastSpecifier = VS;
1228
1229  if (Specifiers & VS) {
1230    PrevSpec = getSpecifierName(VS);
1231    return true;
1232  }
1233
1234  Specifiers |= VS;
1235
1236  switch (VS) {
1237  default: llvm_unreachable("Unknown specifier!");
1238  case VS_Override: VS_overrideLoc = Loc; break;
1239  case VS_Sealed:
1240  case VS_Final:    VS_finalLoc = Loc; break;
1241  }
1242
1243  return false;
1244}
1245
1246const char *VirtSpecifiers::getSpecifierName(Specifier VS) {
1247  switch (VS) {
1248  default: llvm_unreachable("Unknown specifier");
1249  case VS_Override: return "override";
1250  case VS_Final: return "final";
1251  case VS_Sealed: return "sealed";
1252  }
1253}
1254