clang  10.0.0git
DeclSpec.cpp
Go to the documentation of this file.
1 //===--- DeclSpec.cpp - Declaration Specifier Semantic Analysis -----------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file implements semantic analysis for declaration specifiers.
10 //
11 //===----------------------------------------------------------------------===//
12 
13 #include "clang/Sema/DeclSpec.h"
14 #include "clang/AST/ASTContext.h"
15 #include "clang/AST/DeclCXX.h"
16 #include "clang/AST/Expr.h"
17 #include "clang/AST/LocInfoType.h"
18 #include "clang/AST/TypeLoc.h"
20 #include "clang/Basic/TargetInfo.h"
22 #include "clang/Sema/Sema.h"
24 #include "llvm/ADT/STLExtras.h"
25 #include "llvm/ADT/SmallString.h"
26 #include <cstring>
27 using namespace clang;
28 
29 
31  assert(TemplateId && "NULL template-id annotation?");
33  this->TemplateId = TemplateId;
34  StartLocation = TemplateId->TemplateNameLoc;
35  EndLocation = TemplateId->RAngleLoc;
36 }
37 
39  assert(TemplateId && "NULL template-id annotation?");
41  this->TemplateId = TemplateId;
42  StartLocation = TemplateId->TemplateNameLoc;
43  EndLocation = TemplateId->RAngleLoc;
44 }
45 
46 void CXXScopeSpec::Extend(ASTContext &Context, SourceLocation TemplateKWLoc,
47  TypeLoc TL, SourceLocation ColonColonLoc) {
48  Builder.Extend(Context, TemplateKWLoc, TL, ColonColonLoc);
49  if (Range.getBegin().isInvalid())
50  Range.setBegin(TL.getBeginLoc());
51  Range.setEnd(ColonColonLoc);
52 
53  assert(Range == Builder.getSourceRange() &&
54  "NestedNameSpecifierLoc range computation incorrect");
55 }
56 
59  SourceLocation ColonColonLoc) {
60  Builder.Extend(Context, Identifier, IdentifierLoc, ColonColonLoc);
61 
62  if (Range.getBegin().isInvalid())
63  Range.setBegin(IdentifierLoc);
64  Range.setEnd(ColonColonLoc);
65 
66  assert(Range == Builder.getSourceRange() &&
67  "NestedNameSpecifierLoc range computation incorrect");
68 }
69 
70 void CXXScopeSpec::Extend(ASTContext &Context, NamespaceDecl *Namespace,
71  SourceLocation NamespaceLoc,
72  SourceLocation ColonColonLoc) {
73  Builder.Extend(Context, Namespace, NamespaceLoc, ColonColonLoc);
74 
75  if (Range.getBegin().isInvalid())
76  Range.setBegin(NamespaceLoc);
77  Range.setEnd(ColonColonLoc);
78 
79  assert(Range == Builder.getSourceRange() &&
80  "NestedNameSpecifierLoc range computation incorrect");
81 }
82 
84  SourceLocation AliasLoc,
85  SourceLocation ColonColonLoc) {
86  Builder.Extend(Context, Alias, AliasLoc, ColonColonLoc);
87 
88  if (Range.getBegin().isInvalid())
89  Range.setBegin(AliasLoc);
90  Range.setEnd(ColonColonLoc);
91 
92  assert(Range == Builder.getSourceRange() &&
93  "NestedNameSpecifierLoc range computation incorrect");
94 }
95 
97  SourceLocation ColonColonLoc) {
98  Builder.MakeGlobal(Context, ColonColonLoc);
99 
100  Range = SourceRange(ColonColonLoc);
101 
102  assert(Range == Builder.getSourceRange() &&
103  "NestedNameSpecifierLoc range computation incorrect");
104 }
105 
107  SourceLocation SuperLoc,
108  SourceLocation ColonColonLoc) {
109  Builder.MakeSuper(Context, RD, SuperLoc, ColonColonLoc);
110 
111  Range.setBegin(SuperLoc);
112  Range.setEnd(ColonColonLoc);
113 
114  assert(Range == Builder.getSourceRange() &&
115  "NestedNameSpecifierLoc range computation incorrect");
116 }
117 
119  NestedNameSpecifier *Qualifier, SourceRange R) {
120  Builder.MakeTrivial(Context, Qualifier, R);
121  Range = R;
122 }
123 
125  if (!Other) {
126  Range = SourceRange();
127  Builder.Clear();
128  return;
129  }
130 
131  Range = Other.getSourceRange();
132  Builder.Adopt(Other);
133 }
134 
136  if (!Builder.getRepresentation())
137  return SourceLocation();
138  return Builder.getTemporary().getLocalBeginLoc();
139 }
140 
143  if (!Builder.getRepresentation())
144  return NestedNameSpecifierLoc();
145 
146  return Builder.getWithLocInContext(Context);
147 }
148 
149 /// DeclaratorChunk::getFunction - Return a DeclaratorChunk for a function.
150 /// "TheDeclarator" is the declarator that this will be added to.
152  bool isAmbiguous,
153  SourceLocation LParenLoc,
154  ParamInfo *Params,
155  unsigned NumParams,
156  SourceLocation EllipsisLoc,
157  SourceLocation RParenLoc,
158  bool RefQualifierIsLvalueRef,
159  SourceLocation RefQualifierLoc,
160  SourceLocation MutableLoc,
162  ESpecType,
163  SourceRange ESpecRange,
164  ParsedType *Exceptions,
165  SourceRange *ExceptionRanges,
166  unsigned NumExceptions,
167  Expr *NoexceptExpr,
168  CachedTokens *ExceptionSpecTokens,
170  DeclsInPrototype,
171  SourceLocation LocalRangeBegin,
172  SourceLocation LocalRangeEnd,
173  Declarator &TheDeclarator,
174  TypeResult TrailingReturnType,
175  DeclSpec *MethodQualifiers) {
176  assert(!(MethodQualifiers && MethodQualifiers->getTypeQualifiers() & DeclSpec::TQ_atomic) &&
177  "function cannot have _Atomic qualifier");
178 
179  DeclaratorChunk I;
180  I.Kind = Function;
181  I.Loc = LocalRangeBegin;
182  I.EndLoc = LocalRangeEnd;
183  I.Fun.hasPrototype = hasProto;
184  I.Fun.isVariadic = EllipsisLoc.isValid();
185  I.Fun.isAmbiguous = isAmbiguous;
186  I.Fun.LParenLoc = LParenLoc.getRawEncoding();
187  I.Fun.EllipsisLoc = EllipsisLoc.getRawEncoding();
188  I.Fun.RParenLoc = RParenLoc.getRawEncoding();
189  I.Fun.DeleteParams = false;
190  I.Fun.NumParams = NumParams;
191  I.Fun.Params = nullptr;
192  I.Fun.RefQualifierIsLValueRef = RefQualifierIsLvalueRef;
193  I.Fun.RefQualifierLoc = RefQualifierLoc.getRawEncoding();
194  I.Fun.MutableLoc = MutableLoc.getRawEncoding();
195  I.Fun.ExceptionSpecType = ESpecType;
196  I.Fun.ExceptionSpecLocBeg = ESpecRange.getBegin().getRawEncoding();
197  I.Fun.ExceptionSpecLocEnd = ESpecRange.getEnd().getRawEncoding();
199  I.Fun.Exceptions = nullptr;
200  I.Fun.NoexceptExpr = nullptr;
201  I.Fun.HasTrailingReturnType = TrailingReturnType.isUsable() ||
202  TrailingReturnType.isInvalid();
203  I.Fun.TrailingReturnType = TrailingReturnType.get();
204  I.Fun.MethodQualifiers = nullptr;
205  I.Fun.QualAttrFactory = nullptr;
206 
207  if (MethodQualifiers && (MethodQualifiers->getTypeQualifiers() ||
208  MethodQualifiers->getAttributes().size())) {
209  auto &attrs = MethodQualifiers->getAttributes();
210  I.Fun.MethodQualifiers = new DeclSpec(attrs.getPool().getFactory());
211  MethodQualifiers->forEachCVRUQualifier(
212  [&](DeclSpec::TQ TypeQual, StringRef PrintName, SourceLocation SL) {
213  I.Fun.MethodQualifiers->SetTypeQual(TypeQual, SL);
214  });
216  I.Fun.MethodQualifiers->getAttributePool().takeAllFrom(attrs.getPool());
217  }
218 
219  assert(I.Fun.ExceptionSpecType == ESpecType && "bitfield overflow");
220 
221  // new[] a parameter array if needed.
222  if (NumParams) {
223  // If the 'InlineParams' in Declarator is unused and big enough, put our
224  // parameter list there (in an effort to avoid new/delete traffic). If it
225  // is already used (consider a function returning a function pointer) or too
226  // small (function with too many parameters), go to the heap.
227  if (!TheDeclarator.InlineStorageUsed &&
228  NumParams <= llvm::array_lengthof(TheDeclarator.InlineParams)) {
229  I.Fun.Params = TheDeclarator.InlineParams;
230  new (I.Fun.Params) ParamInfo[NumParams];
231  I.Fun.DeleteParams = false;
232  TheDeclarator.InlineStorageUsed = true;
233  } else {
234  I.Fun.Params = new DeclaratorChunk::ParamInfo[NumParams];
235  I.Fun.DeleteParams = true;
236  }
237  for (unsigned i = 0; i < NumParams; i++)
238  I.Fun.Params[i] = std::move(Params[i]);
239  }
240 
241  // Check what exception specification information we should actually store.
242  switch (ESpecType) {
243  default: break; // By default, save nothing.
244  case EST_Dynamic:
245  // new[] an exception array if needed
246  if (NumExceptions) {
247  I.Fun.NumExceptionsOrDecls = NumExceptions;
248  I.Fun.Exceptions = new DeclaratorChunk::TypeAndRange[NumExceptions];
249  for (unsigned i = 0; i != NumExceptions; ++i) {
250  I.Fun.Exceptions[i].Ty = Exceptions[i];
251  I.Fun.Exceptions[i].Range = ExceptionRanges[i];
252  }
253  }
254  break;
255 
257  case EST_NoexceptFalse:
258  case EST_NoexceptTrue:
259  I.Fun.NoexceptExpr = NoexceptExpr;
260  break;
261 
262  case EST_Unparsed:
263  I.Fun.ExceptionSpecTokens = ExceptionSpecTokens;
264  break;
265  }
266 
267  if (!DeclsInPrototype.empty()) {
268  assert(ESpecType == EST_None && NumExceptions == 0 &&
269  "cannot have exception specifiers and decls in prototype");
270  I.Fun.NumExceptionsOrDecls = DeclsInPrototype.size();
271  // Copy the array of decls into stable heap storage.
272  I.Fun.DeclsInPrototype = new NamedDecl *[DeclsInPrototype.size()];
273  for (size_t J = 0; J < DeclsInPrototype.size(); ++J)
274  I.Fun.DeclsInPrototype[J] = DeclsInPrototype[J];
275  }
276 
277  return I;
278 }
279 
281  SourceLocation LSquareLoc,
283  SourceLocation RSquareLoc) {
284  assert(!hasName() && "declarator given multiple names!");
285 
286  BindingGroup.LSquareLoc = LSquareLoc;
287  BindingGroup.RSquareLoc = RSquareLoc;
288  BindingGroup.NumBindings = Bindings.size();
289  Range.setEnd(RSquareLoc);
290 
291  // We're now past the identifier.
292  SetIdentifier(nullptr, LSquareLoc);
293  Name.EndLocation = RSquareLoc;
294 
295  // Allocate storage for bindings and stash them away.
296  if (Bindings.size()) {
297  if (!InlineStorageUsed &&
298  Bindings.size() <= llvm::array_lengthof(InlineBindings)) {
299  BindingGroup.Bindings = InlineBindings;
300  BindingGroup.DeleteBindings = false;
301  InlineStorageUsed = true;
302  } else {
303  BindingGroup.Bindings =
304  new DecompositionDeclarator::Binding[Bindings.size()];
305  BindingGroup.DeleteBindings = true;
306  }
307  std::uninitialized_copy(Bindings.begin(), Bindings.end(),
308  BindingGroup.Bindings);
309  }
310 }
311 
313  for (unsigned i = 0, i_end = DeclTypeInfo.size(); i < i_end; ++i) {
314  switch (DeclTypeInfo[i].Kind) {
316  return true;
318  continue;
325  return false;
326  }
327  llvm_unreachable("Invalid type chunk");
328  }
329 
330  switch (DS.getTypeSpecType()) {
331  case TST_atomic:
332  case TST_auto:
333  case TST_auto_type:
334  case TST_bool:
335  case TST_char:
336  case TST_char8:
337  case TST_char16:
338  case TST_char32:
339  case TST_class:
340  case TST_decimal128:
341  case TST_decimal32:
342  case TST_decimal64:
343  case TST_double:
344  case TST_Accum:
345  case TST_Fract:
346  case TST_Float16:
347  case TST_float128:
348  case TST_enum:
349  case TST_error:
350  case TST_float:
351  case TST_half:
352  case TST_int:
353  case TST_int128:
354  case TST_struct:
355  case TST_interface:
356  case TST_union:
357  case TST_unknown_anytype:
358  case TST_unspecified:
359  case TST_void:
360  case TST_wchar:
361 #define GENERIC_IMAGE_TYPE(ImgType, Id) case TST_##ImgType##_t:
362 #include "clang/Basic/OpenCLImageTypes.def"
363  return false;
364 
365  case TST_decltype_auto:
366  // This must have an initializer, so can't be a function declaration,
367  // even if the initializer has function type.
368  return false;
369 
370  case TST_decltype:
371  case TST_typeofExpr:
372  if (Expr *E = DS.getRepAsExpr())
373  return E->getType()->isFunctionType();
374  return false;
375 
376  case TST_underlyingType:
377  case TST_typename:
378  case TST_typeofType: {
379  QualType QT = DS.getRepAsType().get();
380  if (QT.isNull())
381  return false;
382 
383  if (const LocInfoType *LIT = dyn_cast<LocInfoType>(QT))
384  QT = LIT->getType();
385 
386  if (QT.isNull())
387  return false;
388 
389  return QT->isFunctionType();
390  }
391  }
392 
393  llvm_unreachable("Invalid TypeSpecType!");
394 }
395 
397  assert(getContext() == DeclaratorContext::MemberContext);
398  return getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_static ||
402 }
403 
407 }
408 
410  llvm::function_ref<void(TQ, StringRef, SourceLocation)> Handle) {
411  if (TypeQualifiers & TQ_const)
412  Handle(TQ_const, "const", TQ_constLoc);
413  if (TypeQualifiers & TQ_volatile)
414  Handle(TQ_volatile, "volatile", TQ_volatileLoc);
415  if (TypeQualifiers & TQ_restrict)
416  Handle(TQ_restrict, "restrict", TQ_restrictLoc);
417  if (TypeQualifiers & TQ_unaligned)
418  Handle(TQ_unaligned, "unaligned", TQ_unalignedLoc);
419 }
420 
422  llvm::function_ref<void(TQ, StringRef, SourceLocation)> Handle) {
423  forEachCVRUQualifier(Handle);
424  // FIXME: Add code below to iterate through the attributes and call Handle.
425 }
426 
428  if (!TypeSpecOwned)
429  return false;
430  return cast<TagDecl>(getRepAsDecl())->isCompleteDefinition();
431 }
432 
433 /// getParsedSpecifiers - Return a bitmask of which flavors of specifiers this
434 /// declaration specifier includes.
435 ///
437  unsigned Res = 0;
438  if (StorageClassSpec != SCS_unspecified ||
439  ThreadStorageClassSpec != TSCS_unspecified)
440  Res |= PQ_StorageClassSpecifier;
441 
442  if (TypeQualifiers != TQ_unspecified)
443  Res |= PQ_TypeQualifier;
444 
445  if (hasTypeSpecifier())
446  Res |= PQ_TypeSpecifier;
447 
448  if (FS_inline_specified || FS_virtual_specified || hasExplicitSpecifier() ||
449  FS_noreturn_specified || FS_forceinline_specified)
450  Res |= PQ_FunctionSpecifier;
451  return Res;
452 }
453 
454 template <class T> static bool BadSpecifier(T TNew, T TPrev,
455  const char *&PrevSpec,
456  unsigned &DiagID,
457  bool IsExtension = true) {
458  PrevSpec = DeclSpec::getSpecifierName(TPrev);
459  if (TNew != TPrev)
460  DiagID = diag::err_invalid_decl_spec_combination;
461  else
462  DiagID = IsExtension ? diag::ext_warn_duplicate_declspec :
463  diag::warn_duplicate_declspec;
464  return true;
465 }
466 
468  switch (S) {
469  case DeclSpec::SCS_unspecified: return "unspecified";
470  case DeclSpec::SCS_typedef: return "typedef";
471  case DeclSpec::SCS_extern: return "extern";
472  case DeclSpec::SCS_static: return "static";
473  case DeclSpec::SCS_auto: return "auto";
474  case DeclSpec::SCS_register: return "register";
475  case DeclSpec::SCS_private_extern: return "__private_extern__";
476  case DeclSpec::SCS_mutable: return "mutable";
477  }
478  llvm_unreachable("Unknown typespec!");
479 }
480 
482  switch (S) {
483  case DeclSpec::TSCS_unspecified: return "unspecified";
484  case DeclSpec::TSCS___thread: return "__thread";
485  case DeclSpec::TSCS_thread_local: return "thread_local";
486  case DeclSpec::TSCS__Thread_local: return "_Thread_local";
487  }
488  llvm_unreachable("Unknown typespec!");
489 }
490 
492  switch (W) {
493  case TSW_unspecified: return "unspecified";
494  case TSW_short: return "short";
495  case TSW_long: return "long";
496  case TSW_longlong: return "long long";
497  }
498  llvm_unreachable("Unknown typespec!");
499 }
500 
502  switch (C) {
503  case TSC_unspecified: return "unspecified";
504  case TSC_imaginary: return "imaginary";
505  case TSC_complex: return "complex";
506  }
507  llvm_unreachable("Unknown typespec!");
508 }
509 
510 
512  switch (S) {
513  case TSS_unspecified: return "unspecified";
514  case TSS_signed: return "signed";
515  case TSS_unsigned: return "unsigned";
516  }
517  llvm_unreachable("Unknown typespec!");
518 }
519 
521  const PrintingPolicy &Policy) {
522  switch (T) {
523  case DeclSpec::TST_unspecified: return "unspecified";
524  case DeclSpec::TST_void: return "void";
525  case DeclSpec::TST_char: return "char";
526  case DeclSpec::TST_wchar: return Policy.MSWChar ? "__wchar_t" : "wchar_t";
527  case DeclSpec::TST_char8: return "char8_t";
528  case DeclSpec::TST_char16: return "char16_t";
529  case DeclSpec::TST_char32: return "char32_t";
530  case DeclSpec::TST_int: return "int";
531  case DeclSpec::TST_int128: return "__int128";
532  case DeclSpec::TST_half: return "half";
533  case DeclSpec::TST_float: return "float";
534  case DeclSpec::TST_double: return "double";
535  case DeclSpec::TST_accum: return "_Accum";
536  case DeclSpec::TST_fract: return "_Fract";
537  case DeclSpec::TST_float16: return "_Float16";
538  case DeclSpec::TST_float128: return "__float128";
539  case DeclSpec::TST_bool: return Policy.Bool ? "bool" : "_Bool";
540  case DeclSpec::TST_decimal32: return "_Decimal32";
541  case DeclSpec::TST_decimal64: return "_Decimal64";
542  case DeclSpec::TST_decimal128: return "_Decimal128";
543  case DeclSpec::TST_enum: return "enum";
544  case DeclSpec::TST_class: return "class";
545  case DeclSpec::TST_union: return "union";
546  case DeclSpec::TST_struct: return "struct";
547  case DeclSpec::TST_interface: return "__interface";
548  case DeclSpec::TST_typename: return "type-name";
550  case DeclSpec::TST_typeofExpr: return "typeof";
551  case DeclSpec::TST_auto: return "auto";
552  case DeclSpec::TST_auto_type: return "__auto_type";
553  case DeclSpec::TST_decltype: return "(decltype)";
554  case DeclSpec::TST_decltype_auto: return "decltype(auto)";
555  case DeclSpec::TST_underlyingType: return "__underlying_type";
556  case DeclSpec::TST_unknown_anytype: return "__unknown_anytype";
557  case DeclSpec::TST_atomic: return "_Atomic";
558 #define GENERIC_IMAGE_TYPE(ImgType, Id) \
559  case DeclSpec::TST_##ImgType##_t: \
560  return #ImgType "_t";
561 #include "clang/Basic/OpenCLImageTypes.def"
562  case DeclSpec::TST_error: return "(error)";
563  }
564  llvm_unreachable("Unknown typespec!");
565 }
566 
568  switch (C) {
569  case CSK_unspecified: return "unspecified";
570  case CSK_constexpr: return "constexpr";
571  case CSK_consteval: return "consteval";
572  case CSK_constinit: return "constinit";
573  }
574  llvm_unreachable("Unknown ConstexprSpecKind");
575 }
576 
578  switch (T) {
579  case DeclSpec::TQ_unspecified: return "unspecified";
580  case DeclSpec::TQ_const: return "const";
581  case DeclSpec::TQ_restrict: return "restrict";
582  case DeclSpec::TQ_volatile: return "volatile";
583  case DeclSpec::TQ_atomic: return "_Atomic";
584  case DeclSpec::TQ_unaligned: return "__unaligned";
585  }
586  llvm_unreachable("Unknown typespec!");
587 }
588 
590  const char *&PrevSpec,
591  unsigned &DiagID,
592  const PrintingPolicy &Policy) {
593  // OpenCL v1.1 s6.8g: "The extern, static, auto and register storage-class
594  // specifiers are not supported.
595  // It seems sensible to prohibit private_extern too
596  // The cl_clang_storage_class_specifiers extension enables support for
597  // these storage-class specifiers.
598  // OpenCL v1.2 s6.8 changes this to "The auto and register storage-class
599  // specifiers are not supported."
600  if (S.getLangOpts().OpenCL &&
601  !S.getOpenCLOptions().isEnabled("cl_clang_storage_class_specifiers")) {
602  switch (SC) {
603  case SCS_extern:
604  case SCS_private_extern:
605  case SCS_static:
606  if (S.getLangOpts().OpenCLVersion < 120 &&
607  !S.getLangOpts().OpenCLCPlusPlus) {
608  DiagID = diag::err_opencl_unknown_type_specifier;
609  PrevSpec = getSpecifierName(SC);
610  return true;
611  }
612  break;
613  case SCS_auto:
614  case SCS_register:
615  DiagID = diag::err_opencl_unknown_type_specifier;
616  PrevSpec = getSpecifierName(SC);
617  return true;
618  default:
619  break;
620  }
621  }
622 
623  if (StorageClassSpec != SCS_unspecified) {
624  // Maybe this is an attempt to use C++11 'auto' outside of C++11 mode.
625  bool isInvalid = true;
626  if (TypeSpecType == TST_unspecified && S.getLangOpts().CPlusPlus) {
627  if (SC == SCS_auto)
628  return SetTypeSpecType(TST_auto, Loc, PrevSpec, DiagID, Policy);
629  if (StorageClassSpec == SCS_auto) {
630  isInvalid = SetTypeSpecType(TST_auto, StorageClassSpecLoc,
631  PrevSpec, DiagID, Policy);
632  assert(!isInvalid && "auto SCS -> TST recovery failed");
633  }
634  }
635 
636  // Changing storage class is allowed only if the previous one
637  // was the 'extern' that is part of a linkage specification and
638  // the new storage class is 'typedef'.
639  if (isInvalid &&
640  !(SCS_extern_in_linkage_spec &&
641  StorageClassSpec == SCS_extern &&
642  SC == SCS_typedef))
643  return BadSpecifier(SC, (SCS)StorageClassSpec, PrevSpec, DiagID);
644  }
645  StorageClassSpec = SC;
646  StorageClassSpecLoc = Loc;
647  assert((unsigned)SC == StorageClassSpec && "SCS constants overflow bitfield");
648  return false;
649 }
650 
652  const char *&PrevSpec,
653  unsigned &DiagID) {
654  if (ThreadStorageClassSpec != TSCS_unspecified)
655  return BadSpecifier(TSC, (TSCS)ThreadStorageClassSpec, PrevSpec, DiagID);
656 
657  ThreadStorageClassSpec = TSC;
658  ThreadStorageClassSpecLoc = Loc;
659  return false;
660 }
661 
662 /// These methods set the specified attribute of the DeclSpec, but return true
663 /// and ignore the request if invalid (e.g. "extern" then "auto" is
664 /// specified).
666  const char *&PrevSpec,
667  unsigned &DiagID,
668  const PrintingPolicy &Policy) {
669  // Overwrite TSWRange.Begin only if TypeSpecWidth was unspecified, so that
670  // for 'long long' we will keep the source location of the first 'long'.
671  if (TypeSpecWidth == TSW_unspecified)
672  TSWRange.setBegin(Loc);
673  // Allow turning long -> long long.
674  else if (W != TSW_longlong || TypeSpecWidth != TSW_long)
675  return BadSpecifier(W, (TSW)TypeSpecWidth, PrevSpec, DiagID);
676  TypeSpecWidth = W;
677  // Remember location of the last 'long'
678  TSWRange.setEnd(Loc);
679  return false;
680 }
681 
683  const char *&PrevSpec,
684  unsigned &DiagID) {
685  if (TypeSpecComplex != TSC_unspecified)
686  return BadSpecifier(C, (TSC)TypeSpecComplex, PrevSpec, DiagID);
687  TypeSpecComplex = C;
688  TSCLoc = Loc;
689  return false;
690 }
691 
693  const char *&PrevSpec,
694  unsigned &DiagID) {
695  if (TypeSpecSign != TSS_unspecified)
696  return BadSpecifier(S, (TSS)TypeSpecSign, PrevSpec, DiagID);
697  TypeSpecSign = S;
698  TSSLoc = Loc;
699  return false;
700 }
701 
703  const char *&PrevSpec,
704  unsigned &DiagID,
705  ParsedType Rep,
706  const PrintingPolicy &Policy) {
707  return SetTypeSpecType(T, Loc, Loc, PrevSpec, DiagID, Rep, Policy);
708 }
709 
711  SourceLocation TagNameLoc,
712  const char *&PrevSpec,
713  unsigned &DiagID,
714  ParsedType Rep,
715  const PrintingPolicy &Policy) {
716  assert(isTypeRep(T) && "T does not store a type");
717  assert(Rep && "no type provided!");
718  if (TypeSpecType == TST_error)
719  return false;
720  if (TypeSpecType != TST_unspecified) {
721  PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType, Policy);
722  DiagID = diag::err_invalid_decl_spec_combination;
723  return true;
724  }
725  TypeSpecType = T;
726  TypeRep = Rep;
727  TSTLoc = TagKwLoc;
728  TSTNameLoc = TagNameLoc;
729  TypeSpecOwned = false;
730  return false;
731 }
732 
734  const char *&PrevSpec,
735  unsigned &DiagID,
736  Expr *Rep,
737  const PrintingPolicy &Policy) {
738  assert(isExprRep(T) && "T does not store an expr");
739  assert(Rep && "no expression provided!");
740  if (TypeSpecType == TST_error)
741  return false;
742  if (TypeSpecType != TST_unspecified) {
743  PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType, Policy);
744  DiagID = diag::err_invalid_decl_spec_combination;
745  return true;
746  }
747  TypeSpecType = T;
748  ExprRep = Rep;
749  TSTLoc = Loc;
750  TSTNameLoc = Loc;
751  TypeSpecOwned = false;
752  return false;
753 }
754 
756  const char *&PrevSpec,
757  unsigned &DiagID,
758  Decl *Rep, bool Owned,
759  const PrintingPolicy &Policy) {
760  return SetTypeSpecType(T, Loc, Loc, PrevSpec, DiagID, Rep, Owned, Policy);
761 }
762 
764  SourceLocation TagNameLoc,
765  const char *&PrevSpec,
766  unsigned &DiagID,
767  Decl *Rep, bool Owned,
768  const PrintingPolicy &Policy) {
769  assert(isDeclRep(T) && "T does not store a decl");
770  // Unlike the other cases, we don't assert that we actually get a decl.
771 
772  if (TypeSpecType == TST_error)
773  return false;
774  if (TypeSpecType != TST_unspecified) {
775  PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType, Policy);
776  DiagID = diag::err_invalid_decl_spec_combination;
777  return true;
778  }
779  TypeSpecType = T;
780  DeclRep = Rep;
781  TSTLoc = TagKwLoc;
782  TSTNameLoc = TagNameLoc;
783  TypeSpecOwned = Owned && Rep != nullptr;
784  return false;
785 }
786 
787 bool DeclSpec::SetTypeSpecType(TST T, SourceLocation Loc, const char *&PrevSpec,
788  unsigned &DiagID, TemplateIdAnnotation *Rep,
789  const PrintingPolicy &Policy) {
790  assert(T == TST_auto || T == TST_decltype_auto);
791  ConstrainedAuto = true;
792  TemplateIdRep = Rep;
793  return SetTypeSpecType(T, Loc, PrevSpec, DiagID, Policy);
794 }
795 
797  const char *&PrevSpec,
798  unsigned &DiagID,
799  const PrintingPolicy &Policy) {
800  assert(!isDeclRep(T) && !isTypeRep(T) && !isExprRep(T) &&
801  "rep required for these type-spec kinds!");
802  if (TypeSpecType == TST_error)
803  return false;
804  if (TypeSpecType != TST_unspecified) {
805  PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType, Policy);
806  DiagID = diag::err_invalid_decl_spec_combination;
807  return true;
808  }
809  TSTLoc = Loc;
810  TSTNameLoc = Loc;
811  if (TypeAltiVecVector && (T == TST_bool) && !TypeAltiVecBool) {
812  TypeAltiVecBool = true;
813  return false;
814  }
815  TypeSpecType = T;
816  TypeSpecOwned = false;
817  return false;
818 }
819 
820 bool DeclSpec::SetTypeSpecSat(SourceLocation Loc, const char *&PrevSpec,
821  unsigned &DiagID) {
822  // Cannot set twice
823  if (TypeSpecSat) {
824  DiagID = diag::warn_duplicate_declspec;
825  PrevSpec = "_Sat";
826  return true;
827  }
828  TypeSpecSat = true;
829  TSSatLoc = Loc;
830  return false;
831 }
832 
833 bool DeclSpec::SetTypeAltiVecVector(bool isAltiVecVector, SourceLocation Loc,
834  const char *&PrevSpec, unsigned &DiagID,
835  const PrintingPolicy &Policy) {
836  if (TypeSpecType == TST_error)
837  return false;
838  if (TypeSpecType != TST_unspecified) {
839  PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType, Policy);
840  DiagID = diag::err_invalid_vector_decl_spec_combination;
841  return true;
842  }
843  TypeAltiVecVector = isAltiVecVector;
844  AltiVecLoc = Loc;
845  return false;
846 }
847 
848 bool DeclSpec::SetTypePipe(bool isPipe, SourceLocation Loc,
849  const char *&PrevSpec, unsigned &DiagID,
850  const PrintingPolicy &Policy) {
851  if (TypeSpecType == TST_error)
852  return false;
853  if (TypeSpecType != TST_unspecified) {
854  PrevSpec = DeclSpec::getSpecifierName((TST)TypeSpecType, Policy);
855  DiagID = diag::err_invalid_decl_spec_combination;
856  return true;
857  }
858 
859  if (isPipe) {
860  TypeSpecPipe = TSP_pipe;
861  }
862  return false;
863 }
864 
865 bool DeclSpec::SetTypeAltiVecPixel(bool isAltiVecPixel, SourceLocation Loc,
866  const char *&PrevSpec, unsigned &DiagID,
867  const PrintingPolicy &Policy) {
868  if (TypeSpecType == TST_error)
869  return false;
870  if (!TypeAltiVecVector || TypeAltiVecPixel ||
871  (TypeSpecType != TST_unspecified)) {
872  PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType, Policy);
873  DiagID = diag::err_invalid_pixel_decl_spec_combination;
874  return true;
875  }
876  TypeAltiVecPixel = isAltiVecPixel;
877  TSTLoc = Loc;
878  TSTNameLoc = Loc;
879  return false;
880 }
881 
882 bool DeclSpec::SetTypeAltiVecBool(bool isAltiVecBool, SourceLocation Loc,
883  const char *&PrevSpec, unsigned &DiagID,
884  const PrintingPolicy &Policy) {
885  if (TypeSpecType == TST_error)
886  return false;
887  if (!TypeAltiVecVector || TypeAltiVecBool ||
888  (TypeSpecType != TST_unspecified)) {
889  PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType, Policy);
890  DiagID = diag::err_invalid_vector_bool_decl_spec;
891  return true;
892  }
893  TypeAltiVecBool = isAltiVecBool;
894  TSTLoc = Loc;
895  TSTNameLoc = Loc;
896  return false;
897 }
898 
900  TypeSpecType = TST_error;
901  TypeSpecOwned = false;
902  TSTLoc = SourceLocation();
903  TSTNameLoc = SourceLocation();
904  return false;
905 }
906 
907 bool DeclSpec::SetTypeQual(TQ T, SourceLocation Loc, const char *&PrevSpec,
908  unsigned &DiagID, const LangOptions &Lang) {
909  // Duplicates are permitted in C99 onwards, but are not permitted in C89 or
910  // C++. However, since this is likely not what the user intended, we will
911  // always warn. We do not need to set the qualifier's location since we
912  // already have it.
913  if (TypeQualifiers & T) {
914  bool IsExtension = true;
915  if (Lang.C99)
916  IsExtension = false;
917  return BadSpecifier(T, T, PrevSpec, DiagID, IsExtension);
918  }
919 
920  return SetTypeQual(T, Loc);
921 }
922 
924  TypeQualifiers |= T;
925 
926  switch (T) {
927  case TQ_unspecified: break;
928  case TQ_const: TQ_constLoc = Loc; return false;
929  case TQ_restrict: TQ_restrictLoc = Loc; return false;
930  case TQ_volatile: TQ_volatileLoc = Loc; return false;
931  case TQ_unaligned: TQ_unalignedLoc = Loc; return false;
932  case TQ_atomic: TQ_atomicLoc = Loc; return false;
933  }
934 
935  llvm_unreachable("Unknown type qualifier!");
936 }
937 
938 bool DeclSpec::setFunctionSpecInline(SourceLocation Loc, const char *&PrevSpec,
939  unsigned &DiagID) {
940  // 'inline inline' is ok. However, since this is likely not what the user
941  // intended, we will always warn, similar to duplicates of type qualifiers.
942  if (FS_inline_specified) {
943  DiagID = diag::warn_duplicate_declspec;
944  PrevSpec = "inline";
945  return true;
946  }
947  FS_inline_specified = true;
948  FS_inlineLoc = Loc;
949  return false;
950 }
951 
952 bool DeclSpec::setFunctionSpecForceInline(SourceLocation Loc, const char *&PrevSpec,
953  unsigned &DiagID) {
954  if (FS_forceinline_specified) {
955  DiagID = diag::warn_duplicate_declspec;
956  PrevSpec = "__forceinline";
957  return true;
958  }
959  FS_forceinline_specified = true;
960  FS_forceinlineLoc = Loc;
961  return false;
962 }
963 
965  const char *&PrevSpec,
966  unsigned &DiagID) {
967  // 'virtual virtual' is ok, but warn as this is likely not what the user
968  // intended.
969  if (FS_virtual_specified) {
970  DiagID = diag::warn_duplicate_declspec;
971  PrevSpec = "virtual";
972  return true;
973  }
974  FS_virtual_specified = true;
975  FS_virtualLoc = Loc;
976  return false;
977 }
978 
980  const char *&PrevSpec, unsigned &DiagID,
981  ExplicitSpecifier ExplicitSpec,
982  SourceLocation CloseParenLoc) {
983  assert((ExplicitSpec.getKind() == ExplicitSpecKind::ResolvedTrue ||
984  ExplicitSpec.getExpr()) &&
985  "invalid ExplicitSpecifier");
986  // 'explicit explicit' is ok, but warn as this is likely not what the user
987  // intended.
988  if (hasExplicitSpecifier()) {
989  DiagID = (ExplicitSpec.getExpr() || FS_explicit_specifier.getExpr())
990  ? diag::err_duplicate_declspec
991  : diag::ext_warn_duplicate_declspec;
992  PrevSpec = "explicit";
993  return true;
994  }
995  FS_explicit_specifier = ExplicitSpec;
996  FS_explicitLoc = Loc;
997  FS_explicitCloseParenLoc = CloseParenLoc;
998  return false;
999 }
1000 
1002  const char *&PrevSpec,
1003  unsigned &DiagID) {
1004  // '_Noreturn _Noreturn' is ok, but warn as this is likely not what the user
1005  // intended.
1006  if (FS_noreturn_specified) {
1007  DiagID = diag::warn_duplicate_declspec;
1008  PrevSpec = "_Noreturn";
1009  return true;
1010  }
1011  FS_noreturn_specified = true;
1012  FS_noreturnLoc = Loc;
1013  return false;
1014 }
1015 
1016 bool DeclSpec::SetFriendSpec(SourceLocation Loc, const char *&PrevSpec,
1017  unsigned &DiagID) {
1018  if (Friend_specified) {
1019  PrevSpec = "friend";
1020  // Keep the later location, so that we can later diagnose ill-formed
1021  // declarations like 'friend class X friend;'. Per [class.friend]p3,
1022  // 'friend' must be the first token in a friend declaration that is
1023  // not a function declaration.
1024  FriendLoc = Loc;
1025  DiagID = diag::warn_duplicate_declspec;
1026  return true;
1027  }
1028 
1029  Friend_specified = true;
1030  FriendLoc = Loc;
1031  return false;
1032 }
1033 
1034 bool DeclSpec::setModulePrivateSpec(SourceLocation Loc, const char *&PrevSpec,
1035  unsigned &DiagID) {
1036  if (isModulePrivateSpecified()) {
1037  PrevSpec = "__module_private__";
1038  DiagID = diag::ext_warn_duplicate_declspec;
1039  return true;
1040  }
1041 
1042  ModulePrivateLoc = Loc;
1043  return false;
1044 }
1045 
1047  SourceLocation Loc, const char *&PrevSpec,
1048  unsigned &DiagID) {
1049  if (getConstexprSpecifier() != CSK_unspecified)
1050  return BadSpecifier(ConstexprKind, getConstexprSpecifier(), PrevSpec,
1051  DiagID);
1052  ConstexprSpecifier = ConstexprKind;
1053  ConstexprLoc = Loc;
1054  return false;
1055 }
1056 
1057 void DeclSpec::SaveWrittenBuiltinSpecs() {
1058  writtenBS.Sign = getTypeSpecSign();
1059  writtenBS.Width = getTypeSpecWidth();
1060  writtenBS.Type = getTypeSpecType();
1061  // Search the list of attributes for the presence of a mode attribute.
1062  writtenBS.ModeAttr = getAttributes().hasAttribute(ParsedAttr::AT_Mode);
1063 }
1064 
1065 /// Finish - This does final analysis of the declspec, rejecting things like
1066 /// "_Imaginary" (lacking an FP type). This returns a diagnostic to issue or
1067 /// diag::NUM_DIAGNOSTICS if there is no error. After calling this method,
1068 /// DeclSpec is guaranteed self-consistent, even if an error occurred.
1069 void DeclSpec::Finish(Sema &S, const PrintingPolicy &Policy) {
1070  // Before possibly changing their values, save specs as written.
1071  SaveWrittenBuiltinSpecs();
1072 
1073  // Check the type specifier components first. No checking for an invalid
1074  // type.
1075  if (TypeSpecType == TST_error)
1076  return;
1077 
1078  // If decltype(auto) is used, no other type specifiers are permitted.
1079  if (TypeSpecType == TST_decltype_auto &&
1080  (TypeSpecWidth != TSW_unspecified ||
1081  TypeSpecComplex != TSC_unspecified ||
1082  TypeSpecSign != TSS_unspecified ||
1083  TypeAltiVecVector || TypeAltiVecPixel || TypeAltiVecBool ||
1084  TypeQualifiers)) {
1085  const unsigned NumLocs = 9;
1086  SourceLocation ExtraLocs[NumLocs] = {
1087  TSWRange.getBegin(), TSCLoc, TSSLoc,
1088  AltiVecLoc, TQ_constLoc, TQ_restrictLoc,
1089  TQ_volatileLoc, TQ_atomicLoc, TQ_unalignedLoc};
1090  FixItHint Hints[NumLocs];
1091  SourceLocation FirstLoc;
1092  for (unsigned I = 0; I != NumLocs; ++I) {
1093  if (ExtraLocs[I].isValid()) {
1094  if (FirstLoc.isInvalid() ||
1096  FirstLoc))
1097  FirstLoc = ExtraLocs[I];
1098  Hints[I] = FixItHint::CreateRemoval(ExtraLocs[I]);
1099  }
1100  }
1101  TypeSpecWidth = TSW_unspecified;
1102  TypeSpecComplex = TSC_unspecified;
1103  TypeSpecSign = TSS_unspecified;
1104  TypeAltiVecVector = TypeAltiVecPixel = TypeAltiVecBool = false;
1105  TypeQualifiers = 0;
1106  S.Diag(TSTLoc, diag::err_decltype_auto_cannot_be_combined)
1107  << Hints[0] << Hints[1] << Hints[2] << Hints[3]
1108  << Hints[4] << Hints[5] << Hints[6] << Hints[7];
1109  }
1110 
1111  // Validate and finalize AltiVec vector declspec.
1112  if (TypeAltiVecVector) {
1113  if (TypeAltiVecBool) {
1114  // Sign specifiers are not allowed with vector bool. (PIM 2.1)
1115  if (TypeSpecSign != TSS_unspecified) {
1116  S.Diag(TSSLoc, diag::err_invalid_vector_bool_decl_spec)
1117  << getSpecifierName((TSS)TypeSpecSign);
1118  }
1119 
1120  // Only char/int are valid with vector bool. (PIM 2.1)
1121  if (((TypeSpecType != TST_unspecified) && (TypeSpecType != TST_char) &&
1122  (TypeSpecType != TST_int)) || TypeAltiVecPixel) {
1123  S.Diag(TSTLoc, diag::err_invalid_vector_bool_decl_spec)
1124  << (TypeAltiVecPixel ? "__pixel" :
1125  getSpecifierName((TST)TypeSpecType, Policy));
1126  }
1127 
1128  // Only 'short' and 'long long' are valid with vector bool. (PIM 2.1)
1129  if ((TypeSpecWidth != TSW_unspecified) && (TypeSpecWidth != TSW_short) &&
1130  (TypeSpecWidth != TSW_longlong))
1131  S.Diag(TSWRange.getBegin(), diag::err_invalid_vector_bool_decl_spec)
1132  << getSpecifierName((TSW)TypeSpecWidth);
1133 
1134  // vector bool long long requires VSX support or ZVector.
1135  if ((TypeSpecWidth == TSW_longlong) &&
1136  (!S.Context.getTargetInfo().hasFeature("vsx")) &&
1137  (!S.Context.getTargetInfo().hasFeature("power8-vector")) &&
1138  !S.getLangOpts().ZVector)
1139  S.Diag(TSTLoc, diag::err_invalid_vector_long_long_decl_spec);
1140 
1141  // Elements of vector bool are interpreted as unsigned. (PIM 2.1)
1142  if ((TypeSpecType == TST_char) || (TypeSpecType == TST_int) ||
1143  (TypeSpecWidth != TSW_unspecified))
1144  TypeSpecSign = TSS_unsigned;
1145  } else if (TypeSpecType == TST_double) {
1146  // vector long double and vector long long double are never allowed.
1147  // vector double is OK for Power7 and later, and ZVector.
1148  if (TypeSpecWidth == TSW_long || TypeSpecWidth == TSW_longlong)
1149  S.Diag(TSWRange.getBegin(),
1150  diag::err_invalid_vector_long_double_decl_spec);
1151  else if (!S.Context.getTargetInfo().hasFeature("vsx") &&
1152  !S.getLangOpts().ZVector)
1153  S.Diag(TSTLoc, diag::err_invalid_vector_double_decl_spec);
1154  } else if (TypeSpecType == TST_float) {
1155  // vector float is unsupported for ZVector unless we have the
1156  // vector-enhancements facility 1 (ISA revision 12).
1157  if (S.getLangOpts().ZVector &&
1158  !S.Context.getTargetInfo().hasFeature("arch12"))
1159  S.Diag(TSTLoc, diag::err_invalid_vector_float_decl_spec);
1160  } else if (TypeSpecWidth == TSW_long) {
1161  // vector long is unsupported for ZVector and deprecated for AltiVec.
1162  if (S.getLangOpts().ZVector)
1163  S.Diag(TSWRange.getBegin(), diag::err_invalid_vector_long_decl_spec);
1164  else
1165  S.Diag(TSWRange.getBegin(),
1166  diag::warn_vector_long_decl_spec_combination)
1167  << getSpecifierName((TST)TypeSpecType, Policy);
1168  }
1169 
1170  if (TypeAltiVecPixel) {
1171  //TODO: perform validation
1172  TypeSpecType = TST_int;
1173  TypeSpecSign = TSS_unsigned;
1174  TypeSpecWidth = TSW_short;
1175  TypeSpecOwned = false;
1176  }
1177  }
1178 
1179  bool IsFixedPointType =
1180  TypeSpecType == TST_accum || TypeSpecType == TST_fract;
1181 
1182  // signed/unsigned are only valid with int/char/wchar_t/_Accum.
1183  if (TypeSpecSign != TSS_unspecified) {
1184  if (TypeSpecType == TST_unspecified)
1185  TypeSpecType = TST_int; // unsigned -> unsigned int, signed -> signed int.
1186  else if (TypeSpecType != TST_int && TypeSpecType != TST_int128 &&
1187  TypeSpecType != TST_char && TypeSpecType != TST_wchar &&
1188  !IsFixedPointType) {
1189  S.Diag(TSSLoc, diag::err_invalid_sign_spec)
1190  << getSpecifierName((TST)TypeSpecType, Policy);
1191  // signed double -> double.
1192  TypeSpecSign = TSS_unspecified;
1193  }
1194  }
1195 
1196  // Validate the width of the type.
1197  switch (TypeSpecWidth) {
1198  case TSW_unspecified: break;
1199  case TSW_short: // short int
1200  case TSW_longlong: // long long int
1201  if (TypeSpecType == TST_unspecified)
1202  TypeSpecType = TST_int; // short -> short int, long long -> long long int.
1203  else if (!(TypeSpecType == TST_int ||
1204  (IsFixedPointType && TypeSpecWidth != TSW_longlong))) {
1205  S.Diag(TSWRange.getBegin(), diag::err_invalid_width_spec)
1206  << (int)TypeSpecWidth << getSpecifierName((TST)TypeSpecType, Policy);
1207  TypeSpecType = TST_int;
1208  TypeSpecSat = false;
1209  TypeSpecOwned = false;
1210  }
1211  break;
1212  case TSW_long: // long double, long int
1213  if (TypeSpecType == TST_unspecified)
1214  TypeSpecType = TST_int; // long -> long int.
1215  else if (TypeSpecType != TST_int && TypeSpecType != TST_double &&
1216  !IsFixedPointType) {
1217  S.Diag(TSWRange.getBegin(), diag::err_invalid_width_spec)
1218  << (int)TypeSpecWidth << getSpecifierName((TST)TypeSpecType, Policy);
1219  TypeSpecType = TST_int;
1220  TypeSpecSat = false;
1221  TypeSpecOwned = false;
1222  }
1223  break;
1224  }
1225 
1226  // TODO: if the implementation does not implement _Complex or _Imaginary,
1227  // disallow their use. Need information about the backend.
1228  if (TypeSpecComplex != TSC_unspecified) {
1229  if (TypeSpecType == TST_unspecified) {
1230  S.Diag(TSCLoc, diag::ext_plain_complex)
1232  S.getLocForEndOfToken(getTypeSpecComplexLoc()),
1233  " double");
1234  TypeSpecType = TST_double; // _Complex -> _Complex double.
1235  } else if (TypeSpecType == TST_int || TypeSpecType == TST_char) {
1236  // Note that this intentionally doesn't include _Complex _Bool.
1237  if (!S.getLangOpts().CPlusPlus)
1238  S.Diag(TSTLoc, diag::ext_integer_complex);
1239  } else if (TypeSpecType != TST_float && TypeSpecType != TST_double) {
1240  S.Diag(TSCLoc, diag::err_invalid_complex_spec)
1241  << getSpecifierName((TST)TypeSpecType, Policy);
1242  TypeSpecComplex = TSC_unspecified;
1243  }
1244  }
1245 
1246  // C11 6.7.1/3, C++11 [dcl.stc]p1, GNU TLS: __thread, thread_local and
1247  // _Thread_local can only appear with the 'static' and 'extern' storage class
1248  // specifiers. We also allow __private_extern__ as an extension.
1249  if (ThreadStorageClassSpec != TSCS_unspecified) {
1250  switch (StorageClassSpec) {
1251  case SCS_unspecified:
1252  case SCS_extern:
1253  case SCS_private_extern:
1254  case SCS_static:
1255  break;
1256  default:
1258  getThreadStorageClassSpecLoc(), getStorageClassSpecLoc()))
1259  S.Diag(getStorageClassSpecLoc(),
1260  diag::err_invalid_decl_spec_combination)
1261  << DeclSpec::getSpecifierName(getThreadStorageClassSpec())
1262  << SourceRange(getThreadStorageClassSpecLoc());
1263  else
1264  S.Diag(getThreadStorageClassSpecLoc(),
1265  diag::err_invalid_decl_spec_combination)
1266  << DeclSpec::getSpecifierName(getStorageClassSpec())
1267  << SourceRange(getStorageClassSpecLoc());
1268  // Discard the thread storage class specifier to recover.
1269  ThreadStorageClassSpec = TSCS_unspecified;
1270  ThreadStorageClassSpecLoc = SourceLocation();
1271  }
1272  }
1273 
1274  // If no type specifier was provided and we're parsing a language where
1275  // the type specifier is not optional, but we got 'auto' as a storage
1276  // class specifier, then assume this is an attempt to use C++0x's 'auto'
1277  // type specifier.
1278  if (S.getLangOpts().CPlusPlus &&
1279  TypeSpecType == TST_unspecified && StorageClassSpec == SCS_auto) {
1280  TypeSpecType = TST_auto;
1281  StorageClassSpec = SCS_unspecified;
1282  TSTLoc = TSTNameLoc = StorageClassSpecLoc;
1283  StorageClassSpecLoc = SourceLocation();
1284  }
1285  // Diagnose if we've recovered from an ill-formed 'auto' storage class
1286  // specifier in a pre-C++11 dialect of C++.
1287  if (!S.getLangOpts().CPlusPlus11 && TypeSpecType == TST_auto)
1288  S.Diag(TSTLoc, diag::ext_auto_type_specifier);
1289  if (S.getLangOpts().CPlusPlus && !S.getLangOpts().CPlusPlus11 &&
1290  StorageClassSpec == SCS_auto)
1291  S.Diag(StorageClassSpecLoc, diag::warn_auto_storage_class)
1292  << FixItHint::CreateRemoval(StorageClassSpecLoc);
1293  if (TypeSpecType == TST_char8)
1294  S.Diag(TSTLoc, diag::warn_cxx17_compat_unicode_type);
1295  else if (TypeSpecType == TST_char16 || TypeSpecType == TST_char32)
1296  S.Diag(TSTLoc, diag::warn_cxx98_compat_unicode_type)
1297  << (TypeSpecType == TST_char16 ? "char16_t" : "char32_t");
1298  if (getConstexprSpecifier() == CSK_constexpr)
1299  S.Diag(ConstexprLoc, diag::warn_cxx98_compat_constexpr);
1300  else if (getConstexprSpecifier() == CSK_consteval)
1301  S.Diag(ConstexprLoc, diag::warn_cxx20_compat_consteval);
1302  else if (getConstexprSpecifier() == CSK_constinit)
1303  S.Diag(ConstexprLoc, diag::warn_cxx20_compat_constinit);
1304  // C++ [class.friend]p6:
1305  // No storage-class-specifier shall appear in the decl-specifier-seq
1306  // of a friend declaration.
1307  if (isFriendSpecified() &&
1308  (getStorageClassSpec() || getThreadStorageClassSpec())) {
1309  SmallString<32> SpecName;
1310  SourceLocation SCLoc;
1311  FixItHint StorageHint, ThreadHint;
1312 
1313  if (DeclSpec::SCS SC = getStorageClassSpec()) {
1314  SpecName = getSpecifierName(SC);
1315  SCLoc = getStorageClassSpecLoc();
1316  StorageHint = FixItHint::CreateRemoval(SCLoc);
1317  }
1318 
1319  if (DeclSpec::TSCS TSC = getThreadStorageClassSpec()) {
1320  if (!SpecName.empty()) SpecName += " ";
1321  SpecName += getSpecifierName(TSC);
1322  SCLoc = getThreadStorageClassSpecLoc();
1323  ThreadHint = FixItHint::CreateRemoval(SCLoc);
1324  }
1325 
1326  S.Diag(SCLoc, diag::err_friend_decl_spec)
1327  << SpecName << StorageHint << ThreadHint;
1328 
1329  ClearStorageClassSpecs();
1330  }
1331 
1332  // C++11 [dcl.fct.spec]p5:
1333  // The virtual specifier shall be used only in the initial
1334  // declaration of a non-static class member function;
1335  // C++11 [dcl.fct.spec]p6:
1336  // The explicit specifier shall be used only in the declaration of
1337  // a constructor or conversion function within its class
1338  // definition;
1339  if (isFriendSpecified() && (isVirtualSpecified() || hasExplicitSpecifier())) {
1340  StringRef Keyword;
1341  FixItHint Hint;
1342  SourceLocation SCLoc;
1343 
1344  if (isVirtualSpecified()) {
1345  Keyword = "virtual";
1346  SCLoc = getVirtualSpecLoc();
1347  Hint = FixItHint::CreateRemoval(SCLoc);
1348  } else {
1349  Keyword = "explicit";
1350  SCLoc = getExplicitSpecLoc();
1351  Hint = FixItHint::CreateRemoval(getExplicitSpecRange());
1352  }
1353 
1354  S.Diag(SCLoc, diag::err_friend_decl_spec)
1355  << Keyword << Hint;
1356 
1357  FS_virtual_specified = false;
1358  FS_explicit_specifier = ExplicitSpecifier();
1359  FS_virtualLoc = FS_explicitLoc = SourceLocation();
1360  }
1361 
1362  assert(!TypeSpecOwned || isDeclRep((TST) TypeSpecType));
1363 
1364  // Okay, now we can infer the real type.
1365 
1366  // TODO: return "auto function" and other bad things based on the real type.
1367 
1368  // 'data definition has no type or storage class'?
1369 }
1370 
1372  TST tst = getTypeSpecType();
1373  return isDeclRep(tst) && getRepAsDecl() != nullptr &&
1374  StorageClassSpec != DeclSpec::SCS_typedef;
1375 }
1376 
1379  SourceLocation SymbolLocations[3]) {
1381  StartLocation = OperatorLoc;
1382  EndLocation = OperatorLoc;
1384  for (unsigned I = 0; I != 3; ++I) {
1385  OperatorFunctionId.SymbolLocations[I] = SymbolLocations[I].getRawEncoding();
1386 
1387  if (SymbolLocations[I].isValid())
1388  EndLocation = SymbolLocations[I];
1389  }
1390 }
1391 
1393  const char *&PrevSpec) {
1394  if (!FirstLocation.isValid())
1395  FirstLocation = Loc;
1396  LastLocation = Loc;
1397  LastSpecifier = VS;
1398 
1399  if (Specifiers & VS) {
1400  PrevSpec = getSpecifierName(VS);
1401  return true;
1402  }
1403 
1404  Specifiers |= VS;
1405 
1406  switch (VS) {
1407  default: llvm_unreachable("Unknown specifier!");
1408  case VS_Override: VS_overrideLoc = Loc; break;
1409  case VS_GNU_Final:
1410  case VS_Sealed:
1411  case VS_Final: VS_finalLoc = Loc; break;
1412  }
1413 
1414  return false;
1415 }
1416 
1418  switch (VS) {
1419  default: llvm_unreachable("Unknown specifier");
1420  case VS_Override: return "override";
1421  case VS_Final: return "final";
1422  case VS_GNU_Final: return "__final";
1423  case VS_Sealed: return "sealed";
1424  }
1425 }
Defines the clang::ASTContext interface.
unsigned MutableLoc
The location of the &#39;mutable&#39; qualifer in a lambda-declarator, if any.
Definition: DeclSpec.h:1328
unsigned RefQualifierIsLValueRef
Whether the ref-qualifier (if any) is an lvalue reference.
Definition: DeclSpec.h:1291
no exception specification
SourceLocation getLastQualifierNameLoc() const
Retrieve the location of the name in the last qualifier in this nested name specifier.
Definition: DeclSpec.cpp:135
unsigned getRawEncoding() const
When a SourceLocation itself cannot be used, this returns an (opaque) 32-bit integer encoding for it...
void MakeSuper(ASTContext &Context, CXXRecordDecl *RD, SourceLocation SuperLoc, SourceLocation ColonColonLoc)
Turns this (empty) nested-name-specifier into &#39;__super&#39; nested-name-specifier.
Definition: DeclSpec.cpp:106
A (possibly-)qualified type.
Definition: Type.h:654
SourceLocation StartLocation
The location of the first token that describes this unqualified-id, which will be the location of the...
Definition: DeclSpec.h:1018
SourceRange getSourceRange() const LLVM_READONLY
Retrieve the source range covering the entirety of this nested-name-specifier.
SizeType size() const
Definition: ParsedAttr.h:734
bool SetTypeQual(TQ T, SourceLocation Loc)
Definition: DeclSpec.cpp:923
static const TST TST_wchar
Definition: DeclSpec.h:275
SourceLocation TemplateNameLoc
TemplateNameLoc - The location of the template name within the source.
IdentifierInfo * Identifier
When Kind == IK_Identifier, the parsed identifier, or when Kind == IK_UserLiteralId, the identifier suffix.
Definition: DeclSpec.h:988
unsigned MSWChar
When true, print the built-in wchar_t type as __wchar_t.
static const TST TST_typeofExpr
Definition: DeclSpec.h:299
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID)
Emit a diagnostic.
Definition: Sema.h:1411
static const TST TST_char16
Definition: DeclSpec.h:277
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:88
unsigned ExceptionSpecLocBeg
The beginning location of the exception specification, if any.
Definition: DeclSpec.h:1331
unsigned EllipsisLoc
When isVariadic is true, the location of the ellipsis in the source.
Definition: DeclSpec.h:1307
bool isBeforeInTranslationUnit(SourceLocation LHS, SourceLocation RHS) const
Determines the order of 2 source locations in the translation unit.
A constructor named via a template-id.
ExplicitSpecKind getKind() const
Definition: DeclCXX.h:1795
One instance of this struct is used for each type in a declarator that is parsed. ...
Definition: DeclSpec.h:1174
Represent a C++ namespace.
Definition: Decl.h:497
SourceLocation EndLoc
EndLoc - If valid, the place where this chunck ends.
Definition: DeclSpec.h:1182
SourceLocation getLocForEndOfToken(SourceLocation Loc, unsigned Offset=0)
Calls Lexer::getLocForEndOfToken()
Definition: Sema.cpp:49
unsigned NumExceptionsOrDecls
NumExceptionsOrDecls - This is the number of types in the dynamic-exception-decl, if the function has...
Definition: DeclSpec.h:1319
NamedDecl ** DeclsInPrototype
Pointer to a new[]&#39;d array of declarations that need to be available for lookup inside the function b...
Definition: DeclSpec.h:1364
static const char * getSpecifierName(DeclSpec::TST T, const PrintingPolicy &Policy)
Turn a type-specifier-type into a string like "_Bool" or "union".
Definition: DeclSpec.cpp:520
const TargetInfo & getTargetInfo() const
Definition: ASTContext.h:707
static const char * getSpecifierName(Specifier VS)
Definition: DeclSpec.cpp:1417
Store information needed for an explicit specifier.
Definition: DeclCXX.h:1787
bool SetTypeAltiVecBool(bool isAltiVecBool, SourceLocation Loc, const char *&PrevSpec, unsigned &DiagID, const PrintingPolicy &Policy)
Definition: DeclSpec.cpp:882
An overloaded operator name, e.g., operator+.
unsigned RefQualifierLoc
The location of the ref-qualifier, if any.
Definition: DeclSpec.h:1324
void Adopt(NestedNameSpecifierLoc Other)
Adopt an existing nested-name-specifier (with source-range information).
Definition: DeclSpec.cpp:124
static const TSCS TSCS_unspecified
Definition: DeclSpec.h:246
static const TST TST_underlyingType
Definition: DeclSpec.h:302
Information about one declarator, including the parsed type information and the identifier.
Definition: DeclSpec.h:1792
unsigned getParsedSpecifiers() const
Return a bitmask of which flavors of specifiers this DeclSpec includes.
Definition: DeclSpec.cpp:436
TypeSpecifierType
Specifies the kind of type.
Definition: Specifiers.h:60
static const TST TST_interface
Definition: DeclSpec.h:295
static const TST TST_char
Definition: DeclSpec.h:274
Describes how types, statements, expressions, and declarations should be printed. ...
Definition: PrettyPrinter.h:47
OpenCLOptions & getOpenCLOptions()
Definition: Sema.h:1325
bool SetConstexprSpec(ConstexprSpecKind ConstexprKind, SourceLocation Loc, const char *&PrevSpec, unsigned &DiagID)
Definition: DeclSpec.cpp:1046
noexcept(expression), value-dependent
Information about a template-id annotation token.
static const TST TST_unknown_anytype
Definition: DeclSpec.h:305
Base wrapper for a particular "section" of type source info.
Definition: TypeLoc.h:58
TemplateIdAnnotation * TemplateId
When Kind == IK_TemplateId or IK_ConstructorTemplateId, the template-id annotation that contains the ...
Definition: DeclSpec.h:1012
Expr * NoexceptExpr
Pointer to the expression in the noexcept-specifier of this function, if it has one.
Definition: DeclSpec.h:1355
One of these records is kept for each identifier that is lexed.
void setConstructorTemplateId(TemplateIdAnnotation *TemplateId)
Specify that this unqualified-id was parsed as a template-id that names a constructor.
Definition: DeclSpec.cpp:38
static const TST TST_decimal32
Definition: DeclSpec.h:289
static const TST TST_char8
Definition: DeclSpec.h:276
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:168
A C++ nested-name-specifier augmented with source location information.
TypeSpecifierSign
Specifies the signedness of a type, e.g., signed or unsigned.
Definition: Specifiers.h:48
static const TST TST_class
Definition: DeclSpec.h:296
bool setFunctionSpecExplicit(SourceLocation Loc, const char *&PrevSpec, unsigned &DiagID, ExplicitSpecifier ExplicitSpec, SourceLocation CloseParenLoc)
Definition: DeclSpec.cpp:979
OverloadedOperatorKind Operator
The kind of overloaded operator.
Definition: DeclSpec.h:971
static const TST TST_double
Definition: DeclSpec.h:283
struct OFI OperatorFunctionId
When Kind == IK_OperatorFunctionId, the overloaded operator that we parsed.
Definition: DeclSpec.h:992
bool setFunctionSpecVirtual(SourceLocation Loc, const char *&PrevSpec, unsigned &DiagID)
Definition: DeclSpec.cpp:964
static const TST TST_error
Definition: DeclSpec.h:310
static const TST TST_enum
Definition: DeclSpec.h:292
bool hasTagDefinition() const
Definition: DeclSpec.cpp:427
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
Definition: LangOptions.h:53
static const TST TST_accum
Definition: DeclSpec.h:285
bool SetTypeAltiVecPixel(bool isAltiVecPixel, SourceLocation Loc, const char *&PrevSpec, unsigned &DiagID, const PrintingPolicy &Policy)
Definition: DeclSpec.cpp:865
PtrTy get() const
Definition: Ownership.h:170
bool setFunctionSpecForceInline(SourceLocation Loc, const char *&PrevSpec, unsigned &DiagID)
Definition: DeclSpec.cpp:952
SCS
storage-class-specifier
Definition: DeclSpec.h:232
void takeAllFrom(ParsedAttributes &attrs)
Definition: ParsedAttr.h:831
unsigned HasTrailingReturnType
HasTrailingReturnType - If this is true, a trailing return type was specified.
Definition: DeclSpec.h:1301
bool SetFriendSpec(SourceLocation Loc, const char *&PrevSpec, unsigned &DiagID)
Definition: DeclSpec.cpp:1016
unsigned RParenLoc
The location of the right parenthesis in the source.
Definition: DeclSpec.h:1310
bool SetTypePipe(bool isPipe, SourceLocation Loc, const char *&PrevSpec, unsigned &DiagID, const PrintingPolicy &Policy)
Definition: DeclSpec.cpp:848
bool setFunctionSpecNoreturn(SourceLocation Loc, const char *&PrevSpec, unsigned &DiagID)
Definition: DeclSpec.cpp:1001
const LangOptions & getLangOpts() const
Definition: Sema.h:1324
void setTemplateId(TemplateIdAnnotation *TemplateId)
Specify that this unqualified-id was parsed as a template-id.
Definition: DeclSpec.cpp:30
NestedNameSpecifierLoc getWithLocInContext(ASTContext &Context) const
Retrieve a nested-name-specifier with location information, copied into the given AST context...
Definition: DeclSpec.cpp:142
static const TST TST_float
Definition: DeclSpec.h:282
Sema - This implements semantic analysis and AST building for C.
Definition: Sema.h:336
static DeclaratorChunk getFunction(bool HasProto, bool IsAmbiguous, SourceLocation LParenLoc, ParamInfo *Params, unsigned NumParams, SourceLocation EllipsisLoc, SourceLocation RParenLoc, bool RefQualifierIsLvalueRef, SourceLocation RefQualifierLoc, SourceLocation MutableLoc, ExceptionSpecificationType ESpecType, SourceRange ESpecRange, ParsedType *Exceptions, SourceRange *ExceptionRanges, unsigned NumExceptions, Expr *NoexceptExpr, CachedTokens *ExceptionSpecTokens, ArrayRef< NamedDecl *> DeclsInPrototype, SourceLocation LocalRangeBegin, SourceLocation LocalRangeEnd, Declarator &TheDeclarator, TypeResult TrailingReturnType=TypeResult(), DeclSpec *MethodQualifiers=nullptr)
DeclaratorChunk::getFunction - Return a DeclaratorChunk for a function.
Definition: DeclSpec.cpp:151
void MakeTrivial(ASTContext &Context, NestedNameSpecifier *Qualifier, SourceRange R)
Make a new nested-name-specifier from incomplete source-location information.
Definition: DeclSpec.cpp:118
Holds a QualType and a TypeSourceInfo* that came out of a declarator parsing.
Definition: LocInfoType.h:28
bool isDeclarationOfFunction() const
Determine whether the declaration that will be produced from this declaration will be a function...
Definition: DeclSpec.cpp:312
DeclSpec * MethodQualifiers
DeclSpec for the function with the qualifier related info.
Definition: DeclSpec.h:1342
unsigned NumParams
NumParams - This is the number of formal parameters specified by the declarator.
Definition: DeclSpec.h:1314
bool isEnabled(llvm::StringRef Ext) const
Definition: OpenCLOptions.h:39
SourceLocation getBeginLoc() const
Get the begin source location.
Definition: TypeLoc.cpp:191
This represents one expression.
Definition: Expr.h:108
Defines the clang::LangOptions interface.
void setDecompositionBindings(SourceLocation LSquareLoc, ArrayRef< DecompositionDeclarator::Binding > Bindings, SourceLocation RSquareLoc)
Set the decomposition bindings for this declarator.
Definition: DeclSpec.cpp:280
unsigned SymbolLocations[3]
The source locations of the individual tokens that name the operator, e.g., the "new", "[", and "]" tokens in operator new [].
Definition: DeclSpec.h:980
This file defines the classes used to store parsed information about declaration-specifiers and decla...
DeclaratorChunk::ParamInfo InlineParams[16]
InlineParams - This is a local array used for the first function decl chunk to avoid going to the hea...
Definition: DeclSpec.h:1863
const Expr * getExpr() const
Definition: DeclCXX.h:1796
static const TST TST_decimal64
Definition: DeclSpec.h:290
Defines the clang::TypeLoc interface and its subclasses.
UnqualifiedIdKind getKind() const
Determine what kind of name we have.
Definition: DeclSpec.h:1042
CachedTokens * ExceptionSpecTokens
Pointer to the cached tokens for an exception-specification that has not yet been parsed...
Definition: DeclSpec.h:1359
SourceLocation Loc
Loc - The place where this type was defined.
Definition: DeclSpec.h:1180
static const TST TST_int
Definition: DeclSpec.h:279
bool isInvalid() const
Definition: Ownership.h:166
SourceLocation getEnd() const
bool SetTypeSpecSign(TSS S, SourceLocation Loc, const char *&PrevSpec, unsigned &DiagID)
Definition: DeclSpec.cpp:692
static const TST TST_half
Definition: DeclSpec.h:281
Wraps an identifier and optional source location for the identifier.
Definition: ParsedAttr.h:95
bool isUsable() const
Definition: Ownership.h:167
static bool BadSpecifier(T TNew, T TPrev, const char *&PrevSpec, unsigned &DiagID, bool IsExtension=true)
Definition: DeclSpec.cpp:454
bool isNull() const
Return true if this QualType doesn&#39;t point to a type yet.
Definition: Type.h:719
bool isValid() const
Determine whether this unqualified-id refers to a valid name.
Definition: DeclSpec.h:1036
UnionParsedType TrailingReturnType
If HasTrailingReturnType is true, this is the trailing return type specified.
Definition: DeclSpec.h:1369
bool SetTypeSpecWidth(TSW W, SourceLocation Loc, const char *&PrevSpec, unsigned &DiagID, const PrintingPolicy &Policy)
These methods set the specified attribute of the DeclSpec, but return true and ignore the request if ...
Definition: DeclSpec.cpp:665
TypeAndRange * Exceptions
Pointer to a new[]&#39;d array of TypeAndRange objects that contain the types in the function&#39;s dynamic e...
Definition: DeclSpec.h:1351
static const TST TST_char32
Definition: DeclSpec.h:278
noexcept(expression), evals to &#39;false&#39;
static const TST TST_fract
Definition: DeclSpec.h:286
unsigned Bool
Whether we can use &#39;bool&#39; rather than &#39;_Bool&#39; (even if the language doesn&#39;t actually have &#39;bool&#39;...
bool isCtorOrDtor()
Returns true if this declares a constructor or a destructor.
Definition: DeclSpec.cpp:404
Kind
ActionResult - This structure is used while parsing/acting on expressions, stmts, etc...
Definition: Ownership.h:153
static const TST TST_float16
Definition: DeclSpec.h:284
Encodes a location in the source.
static const TST TST_auto_type
Definition: DeclSpec.h:304
enum clang::DeclaratorChunk::@219 Kind
FunctionTypeInfo Fun
Definition: DeclSpec.h:1546
static const TST TST_union
Definition: DeclSpec.h:293
bool SetStorageClassSpec(Sema &S, SCS SC, SourceLocation Loc, const char *&PrevSpec, unsigned &DiagID, const PrintingPolicy &Policy)
These methods set the specified attribute of the DeclSpec and return false if there was no error...
Definition: DeclSpec.cpp:589
Represents a C++ nested name specifier, such as "\::std::vector<int>::".
AttributeFactory * QualAttrFactory
AtttibuteFactory for the MethodQualifiers.
Definition: DeclSpec.h:1345
void forEachCVRUQualifier(llvm::function_ref< void(TQ, StringRef, SourceLocation)> Handle)
This method calls the passed in handler on each CVRU qual being set.
Definition: DeclSpec.cpp:409
static const TST TST_typeofType
Definition: DeclSpec.h:298
bool isInvalid() const
Determine whether this unqualified-id refers to an invalid name.
Definition: DeclSpec.h:1039
bool isStaticMember()
Returns true if this declares a static member.
Definition: DeclSpec.cpp:396
bool SetTypeAltiVecVector(bool isAltiVecVector, SourceLocation Loc, const char *&PrevSpec, unsigned &DiagID, const PrintingPolicy &Policy)
Definition: DeclSpec.cpp:833
static const TST TST_decltype_auto
Definition: DeclSpec.h:301
bool setModulePrivateSpec(SourceLocation Loc, const char *&PrevSpec, unsigned &DiagID)
Definition: DeclSpec.cpp:1034
static bool isStaticOverloadedOperator(OverloadedOperatorKind OOK)
Returns true if the given operator is implicitly static in a record context.
Definition: DeclCXX.h:1963
Dataflow Directional Tag Classes.
ConstexprSpecKind
Define the kind of constexpr specifier.
Definition: Specifiers.h:32
bool isValid() const
Return true if this is a valid SourceLocation object.
static std::string getName(const CallEvent &Call)
static const TST TST_decltype
Definition: DeclSpec.h:300
OverloadedOperatorKind
Enumeration specifying the different kinds of C++ overloaded operators.
Definition: OperatorKinds.h:21
static const TST TST_auto
Definition: DeclSpec.h:303
static const TST TST_void
Definition: DeclSpec.h:273
unsigned isVariadic
isVariadic - If this function has a prototype, and if that proto ends with &#39;,...)&#39;, this is true.
Definition: DeclSpec.h:1284
SourceLocation RAngleLoc
The location of the &#39;>&#39; after the template argument list.
static const TST TST_int128
Definition: DeclSpec.h:280
unsigned DeleteParams
DeleteParams - If this is true, we need to delete[] Params.
Definition: DeclSpec.h:1297
bool isMissingDeclaratorOk()
Checks if this DeclSpec can stand alone, without a Declarator.
Definition: DeclSpec.cpp:1371
static FixItHint CreateRemoval(CharSourceRange RemoveRange)
Create a code modification hint that removes the given source range.
Definition: Diagnostic.h:118
void takeAllFrom(AttributePool &pool)
Take the given pool&#39;s allocations and add them to this pool.
Definition: ParsedAttr.h:642
static const TST TST_unspecified
Definition: DeclSpec.h:272
virtual bool hasFeature(StringRef Feature) const
Determine whether the given target has the given feature.
Definition: TargetInfo.h:1143
void forEachQualifier(llvm::function_ref< void(TQ, StringRef, SourceLocation)> Handle)
This method calls the passed in handler on each qual being set.
Definition: DeclSpec.cpp:421
bool SetSpecifier(Specifier VS, SourceLocation Loc, const char *&PrevSpec)
Definition: DeclSpec.cpp:1392
static const TST TST_decimal128
Definition: DeclSpec.h:291
unsigned getTypeQualifiers() const
getTypeQualifiers - Return a set of TQs.
Definition: DeclSpec.h:550
static const TSCS TSCS___thread
Definition: DeclSpec.h:247
unsigned hasPrototype
hasPrototype - This is true if the function had at least one typed parameter.
Definition: DeclSpec.h:1279
unsigned LParenLoc
The location of the left parenthesis in the source.
Definition: DeclSpec.h:1304
bool isFunctionType() const
Definition: Type.h:6500
bool SetStorageClassSpecThread(TSCS TSC, SourceLocation Loc, const char *&PrevSpec, unsigned &DiagID)
Definition: DeclSpec.cpp:651
void setOperatorFunctionId(SourceLocation OperatorLoc, OverloadedOperatorKind Op, SourceLocation SymbolLocations[3])
Specify that this unqualified-id was parsed as an operator-function-id.
Definition: DeclSpec.cpp:1377
static const TST TST_typename
Definition: DeclSpec.h:297
ExceptionSpecificationType
The various types of exception specifications that exist in C++11.
static FixItHint CreateInsertion(SourceLocation InsertionLoc, StringRef Code, bool BeforePreviousInsertions=false)
Create a code modification hint that inserts the given code string at a specific location.
Definition: Diagnostic.h:92
bool SetTypeSpecType(TST T, SourceLocation Loc, const char *&PrevSpec, unsigned &DiagID, const PrintingPolicy &Policy)
Definition: DeclSpec.cpp:796
Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate.h) and friends (in DeclFriend.h).
void Extend(ASTContext &Context, SourceLocation TemplateKWLoc, TypeLoc TL, SourceLocation ColonColonLoc)
Extend the current nested-name-specifier by another nested-name-specifier component of the form &#39;type...
Definition: DeclSpec.cpp:46
unsigned ExceptionSpecType
ExceptionSpecType - An ExceptionSpecificationType value.
Definition: DeclSpec.h:1294
ThreadStorageClassSpecifier
Thread storage-class-specifier.
Definition: Specifiers.h:222
Captures information about "declaration specifiers".
Definition: DeclSpec.h:228
Represents a C++ struct/union/class.
Definition: DeclCXX.h:253
static const TSCS TSCS_thread_local
Definition: DeclSpec.h:248
bool SetTypeSpecSat(SourceLocation Loc, const char *&PrevSpec, unsigned &DiagID)
Definition: DeclSpec.cpp:820
TypeSpecifierWidth
Specifies the width of a type, e.g., short, long, or long long.
Definition: Specifiers.h:40
static const TST TST_float128
Definition: DeclSpec.h:287
internal::Matcher< NamedDecl > hasName(const std::string &Name)
Matches NamedDecl nodes that have the specified name.
Definition: ASTMatchers.h:2649
static const TST TST_bool
Definition: DeclSpec.h:288
void MakeGlobal(ASTContext &Context, SourceLocation ColonColonLoc)
Turn this (empty) nested-name-specifier into the global nested-name-specifier &#39;::&#39;.
Definition: DeclSpec.cpp:96
SourceManager & getSourceManager() const
Definition: Sema.h:1329
A template-id, e.g., f<int>.
void Finish(Sema &S, const PrintingPolicy &Policy)
Finish - This does final analysis of the declspec, issuing diagnostics for things like "_Imaginary" (...
Definition: DeclSpec.cpp:1069
Defines the clang::TargetInfo interface.
static const TST TST_atomic
Definition: DeclSpec.h:306
static const TST TST_struct
Definition: DeclSpec.h:294
Annotates a diagnostic with some code that should be inserted, removed, or replaced to fix the proble...
Definition: Diagnostic.h:66
ParamInfo - An array of paraminfo objects is allocated whenever a function declarator is parsed...
Definition: DeclSpec.h:1250
A trivial tuple used to represent a source range.
ASTContext & Context
Definition: Sema.h:385
bool SetTypeSpecComplex(TSC C, SourceLocation Loc, const char *&PrevSpec, unsigned &DiagID)
Definition: DeclSpec.cpp:682
This represents a decl that may have a name.
Definition: Decl.h:223
bool SetTypeSpecError()
Definition: DeclSpec.cpp:899
unsigned ExceptionSpecLocEnd
The end location of the exception specification, if any.
Definition: DeclSpec.h:1334
Represents a C++ namespace alias.
Definition: DeclCXX.h:2967
SourceLocation EndLocation
The location of the last token that describes this unqualified-id.
Definition: DeclSpec.h:1021
static const TSCS TSCS__Thread_local
Definition: DeclSpec.h:249
AttributePool & getAttributePool() const
Definition: DeclSpec.h:760
SourceLocation getBegin() const
ParamInfo * Params
Params - This is a pointer to a new[]&#39;d array of ParamInfo objects that describe the parameters speci...
Definition: DeclSpec.h:1339
ParsedAttributes & getAttributes()
Definition: DeclSpec.h:787
noexcept(expression), evals to &#39;true&#39;
bool setFunctionSpecInline(SourceLocation Loc, const char *&PrevSpec, unsigned &DiagID)
Definition: DeclSpec.cpp:938
unsigned isAmbiguous
Can this declaration be a constructor-style initializer?
Definition: DeclSpec.h:1287