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>
31using namespace clang;
32
33
34static DiagnosticBuilder Diag(DiagnosticsEngine &D, SourceLocation Loc,
35                              unsigned DiagID) {
36  return D.Report(Loc, DiagID);
37}
38
39
40void 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
48void 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
56void 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
67void 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
80void 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
93void 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
106void 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
116void CXXScopeSpec::MakeTrivial(ASTContext &Context,
117                               NestedNameSpecifier *Qualifier, SourceRange R) {
118  Builder.MakeTrivial(Context, Qualifier, R);
119  Range = R;
120}
121
122void 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
133SourceLocation CXXScopeSpec::getLastQualifierNameLoc() const {
134  if (!Builder.getRepresentation())
135    return SourceLocation();
136  return Builder.getTemporary().getLocalBeginLoc();
137}
138
139NestedNameSpecifierLoc
140CXXScopeSpec::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.
149DeclaratorChunk 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
246bool 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
321bool Declarator::isStaticMember() {
322  assert(getContext() == MemberContext);
323  return getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_static ||
324         CXXMethodDecl::isStaticOverloadedOperator(
325             getName().OperatorFunctionId.Operator);
326}
327
328bool 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///
337unsigned 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
355template <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
368const 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
382const 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
392const 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
402const 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
412const 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
421const 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
458const 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
469bool 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
530bool 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).
544bool 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
565bool 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
575bool 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
585bool 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
593bool 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
614bool 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
634bool 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
642bool 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
664bool 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
691bool 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
704bool 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
719bool 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
734bool DeclSpec::SetTypeSpecError() {
735  TypeSpecType = TST_error;
736  TypeSpecOwned = false;
737  TSTLoc = SourceLocation();
738  TSTNameLoc = SourceLocation();
739  return false;
740}
741
742bool 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
767bool 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
781bool 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
793bool 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
808bool 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
823bool 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
838bool 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
856bool 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
868bool 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
882void 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
896void 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.
916void 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
1170bool DeclSpec::isMissingDeclaratorOk() {
1171  TST tst = getTypeSpecType();
1172  return isDeclRep(tst) && getRepAsDecl() != nullptr &&
1173    StorageClassSpec != DeclSpec::SCS_typedef;
1174}
1175
1176void 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
1191bool 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
1212const 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