clang  12.0.0git
DeclSpec.h
Go to the documentation of this file.
1 //===--- DeclSpec.h - Parsed declaration specifiers -------------*- C++ -*-===//
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 /// \file
10 /// This file defines the classes used to store parsed information about
11 /// declaration-specifiers and declarators.
12 ///
13 /// \verbatim
14 /// static const int volatile x, *y, *(*(*z)[10])(const void *x);
15 /// ------------------------- - -- ---------------------------
16 /// declaration-specifiers \ | /
17 /// declarators
18 /// \endverbatim
19 ///
20 //===----------------------------------------------------------------------===//
21 
22 #ifndef LLVM_CLANG_SEMA_DECLSPEC_H
23 #define LLVM_CLANG_SEMA_DECLSPEC_H
24 
25 #include "clang/AST/DeclCXX.h"
29 #include "clang/Basic/Lambda.h"
31 #include "clang/Basic/Specifiers.h"
32 #include "clang/Lex/Token.h"
33 #include "clang/Sema/Ownership.h"
34 #include "clang/Sema/ParsedAttr.h"
35 #include "llvm/ADT/SmallVector.h"
36 #include "llvm/Support/Compiler.h"
37 #include "llvm/Support/ErrorHandling.h"
38 
39 namespace clang {
40  class ASTContext;
41  class CXXRecordDecl;
42  class TypeLoc;
43  class LangOptions;
44  class IdentifierInfo;
45  class NamespaceAliasDecl;
46  class NamespaceDecl;
47  class ObjCDeclSpec;
48  class Sema;
49  class Declarator;
50  struct TemplateIdAnnotation;
51 
52 /// Represents a C++ nested-name-specifier or a global scope specifier.
53 ///
54 /// These can be in 3 states:
55 /// 1) Not present, identified by isEmpty()
56 /// 2) Present, identified by isNotEmpty()
57 /// 2.a) Valid, identified by isValid()
58 /// 2.b) Invalid, identified by isInvalid().
59 ///
60 /// isSet() is deprecated because it mostly corresponded to "valid" but was
61 /// often used as if it meant "present".
62 ///
63 /// The actual scope is described by getScopeRep().
64 class CXXScopeSpec {
65  SourceRange Range;
67 
68 public:
69  SourceRange getRange() const { return Range; }
70  void setRange(SourceRange R) { Range = R; }
71  void setBeginLoc(SourceLocation Loc) { Range.setBegin(Loc); }
72  void setEndLoc(SourceLocation Loc) { Range.setEnd(Loc); }
73  SourceLocation getBeginLoc() const { return Range.getBegin(); }
74  SourceLocation getEndLoc() const { return Range.getEnd(); }
75 
76  /// Retrieve the representation of the nested-name-specifier.
78  return Builder.getRepresentation();
79  }
80 
81  /// Extend the current nested-name-specifier by another
82  /// nested-name-specifier component of the form 'type::'.
83  ///
84  /// \param Context The AST context in which this nested-name-specifier
85  /// resides.
86  ///
87  /// \param TemplateKWLoc The location of the 'template' keyword, if present.
88  ///
89  /// \param TL The TypeLoc that describes the type preceding the '::'.
90  ///
91  /// \param ColonColonLoc The location of the trailing '::'.
92  void Extend(ASTContext &Context, SourceLocation TemplateKWLoc, TypeLoc TL,
93  SourceLocation ColonColonLoc);
94 
95  /// Extend the current nested-name-specifier by another
96  /// nested-name-specifier component of the form 'identifier::'.
97  ///
98  /// \param Context The AST context in which this nested-name-specifier
99  /// resides.
100  ///
101  /// \param Identifier The identifier.
102  ///
103  /// \param IdentifierLoc The location of the identifier.
104  ///
105  /// \param ColonColonLoc The location of the trailing '::'.
106  void Extend(ASTContext &Context, IdentifierInfo *Identifier,
108 
109  /// Extend the current nested-name-specifier by another
110  /// nested-name-specifier component of the form 'namespace::'.
111  ///
112  /// \param Context The AST context in which this nested-name-specifier
113  /// resides.
114  ///
115  /// \param Namespace The namespace.
116  ///
117  /// \param NamespaceLoc The location of the namespace name.
118  ///
119  /// \param ColonColonLoc The location of the trailing '::'.
120  void Extend(ASTContext &Context, NamespaceDecl *Namespace,
121  SourceLocation NamespaceLoc, SourceLocation ColonColonLoc);
122 
123  /// Extend the current nested-name-specifier by another
124  /// nested-name-specifier component of the form 'namespace-alias::'.
125  ///
126  /// \param Context The AST context in which this nested-name-specifier
127  /// resides.
128  ///
129  /// \param Alias The namespace alias.
130  ///
131  /// \param AliasLoc The location of the namespace alias
132  /// name.
133  ///
134  /// \param ColonColonLoc The location of the trailing '::'.
135  void Extend(ASTContext &Context, NamespaceAliasDecl *Alias,
136  SourceLocation AliasLoc, SourceLocation ColonColonLoc);
137 
138  /// Turn this (empty) nested-name-specifier into the global
139  /// nested-name-specifier '::'.
140  void MakeGlobal(ASTContext &Context, SourceLocation ColonColonLoc);
141 
142  /// Turns this (empty) nested-name-specifier into '__super'
143  /// nested-name-specifier.
144  ///
145  /// \param Context The AST context in which this nested-name-specifier
146  /// resides.
147  ///
148  /// \param RD The declaration of the class in which nested-name-specifier
149  /// appeared.
150  ///
151  /// \param SuperLoc The location of the '__super' keyword.
152  /// name.
153  ///
154  /// \param ColonColonLoc The location of the trailing '::'.
155  void MakeSuper(ASTContext &Context, CXXRecordDecl *RD,
156  SourceLocation SuperLoc, SourceLocation ColonColonLoc);
157 
158  /// Make a new nested-name-specifier from incomplete source-location
159  /// information.
160  ///
161  /// FIXME: This routine should be used very, very rarely, in cases where we
162  /// need to synthesize a nested-name-specifier. Most code should instead use
163  /// \c Adopt() with a proper \c NestedNameSpecifierLoc.
164  void MakeTrivial(ASTContext &Context, NestedNameSpecifier *Qualifier,
165  SourceRange R);
166 
167  /// Adopt an existing nested-name-specifier (with source-range
168  /// information).
169  void Adopt(NestedNameSpecifierLoc Other);
170 
171  /// Retrieve a nested-name-specifier with location information, copied
172  /// into the given AST context.
173  ///
174  /// \param Context The context into which this nested-name-specifier will be
175  /// copied.
177 
178  /// Retrieve the location of the name in the last qualifier
179  /// in this nested name specifier.
180  ///
181  /// For example, the location of \c bar
182  /// in
183  /// \verbatim
184  /// \::foo::bar<0>::
185  /// ^~~
186  /// \endverbatim
188 
189  /// No scope specifier.
190  bool isEmpty() const { return Range.isInvalid() && getScopeRep() == nullptr; }
191  /// A scope specifier is present, but may be valid or invalid.
192  bool isNotEmpty() const { return !isEmpty(); }
193 
194  /// An error occurred during parsing of the scope specifier.
195  bool isInvalid() const { return Range.isValid() && getScopeRep() == nullptr; }
196  /// A scope specifier is present, and it refers to a real scope.
197  bool isValid() const { return getScopeRep() != nullptr; }
198 
199  /// Indicate that this nested-name-specifier is invalid.
201  assert(R.isValid() && "Must have a valid source range");
202  if (Range.getBegin().isInvalid())
203  Range.setBegin(R.getBegin());
204  Range.setEnd(R.getEnd());
205  Builder.Clear();
206  }
207 
208  /// Deprecated. Some call sites intend isNotEmpty() while others intend
209  /// isValid().
210  bool isSet() const { return getScopeRep() != nullptr; }
211 
212  void clear() {
213  Range = SourceRange();
214  Builder.Clear();
215  }
216 
217  /// Retrieve the data associated with the source-location information.
218  char *location_data() const { return Builder.getBuffer().first; }
219 
220  /// Retrieve the size of the data associated with source-location
221  /// information.
222  unsigned location_size() const { return Builder.getBuffer().second; }
223 };
224 
225 /// Captures information about "declaration specifiers".
226 ///
227 /// "Declaration specifiers" encompasses storage-class-specifiers,
228 /// type-specifiers, type-qualifiers, and function-specifiers.
229 class DeclSpec {
230 public:
231  /// storage-class-specifier
232  /// \note The order of these enumerators is important for diagnostics.
233  enum SCS {
242  };
243 
244  // Import thread storage class specifier enumeration and constants.
245  // These can be combined with SCS_extern and SCS_static.
251 
252  enum TSC {
256  };
257 
258  // Import type specifier type enumeration and constants.
261  static const TST TST_void = clang::TST_void;
262  static const TST TST_char = clang::TST_char;
267  static const TST TST_int = clang::TST_int;
270  static const TST TST_half = clang::TST_half;
278  static const TST TST_bool = clang::TST_bool;
282  static const TST TST_enum = clang::TST_enum;
293  static const TST TST_auto = clang::TST_auto;
297 #define GENERIC_IMAGE_TYPE(ImgType, Id) \
298  static const TST TST_##ImgType##_t = clang::TST_##ImgType##_t;
299 #include "clang/Basic/OpenCLImageTypes.def"
301 
302  // type-qualifiers
303  enum TQ { // NOTE: These flags must be kept in sync with Qualifiers::TQ.
305  TQ_const = 1,
309  // This has no corresponding Qualifiers::TQ value, because it's not treated
310  // as a qualifier in our type system.
312  };
313 
314  /// ParsedSpecifiers - Flags to query which specifiers were applied. This is
315  /// returned by getParsedSpecifiers.
317  PQ_None = 0,
322  // FIXME: Attributes should be included here.
323  };
324 
325 private:
326  // storage-class-specifier
327  /*SCS*/unsigned StorageClassSpec : 3;
328  /*TSCS*/unsigned ThreadStorageClassSpec : 2;
329  unsigned SCS_extern_in_linkage_spec : 1;
330 
331  // type-specifier
332  /*TypeSpecifierWidth*/ unsigned TypeSpecWidth : 2;
333  /*TSC*/unsigned TypeSpecComplex : 2;
334  /*TSS*/unsigned TypeSpecSign : 2;
335  /*TST*/unsigned TypeSpecType : 6;
336  unsigned TypeAltiVecVector : 1;
337  unsigned TypeAltiVecPixel : 1;
338  unsigned TypeAltiVecBool : 1;
339  unsigned TypeSpecOwned : 1;
340  unsigned TypeSpecPipe : 1;
341  unsigned TypeSpecSat : 1;
342  unsigned ConstrainedAuto : 1;
343 
344  // type-qualifiers
345  unsigned TypeQualifiers : 5; // Bitwise OR of TQ.
346 
347  // function-specifier
348  unsigned FS_inline_specified : 1;
349  unsigned FS_forceinline_specified: 1;
350  unsigned FS_virtual_specified : 1;
351  unsigned FS_noreturn_specified : 1;
352 
353  // friend-specifier
354  unsigned Friend_specified : 1;
355 
356  // constexpr-specifier
357  unsigned ConstexprSpecifier : 2;
358 
359  union {
364  };
365 
366  /// ExplicitSpecifier - Store information about explicit spicifer.
367  ExplicitSpecifier FS_explicit_specifier;
368 
369  // attributes.
370  ParsedAttributes Attrs;
371 
372  // Scope specifier for the type spec, if applicable.
373  CXXScopeSpec TypeScope;
374 
375  // SourceLocation info. These are null if the item wasn't specified or if
376  // the setting was synthesized.
377  SourceRange Range;
378 
379  SourceLocation StorageClassSpecLoc, ThreadStorageClassSpecLoc;
380  SourceRange TSWRange;
381  SourceLocation TSCLoc, TSSLoc, TSTLoc, AltiVecLoc, TSSatLoc;
382  /// TSTNameLoc - If TypeSpecType is any of class, enum, struct, union,
383  /// typename, then this is the location of the named type (if present);
384  /// otherwise, it is the same as TSTLoc. Hence, the pair TSTLoc and
385  /// TSTNameLoc provides source range info for tag types.
386  SourceLocation TSTNameLoc;
387  SourceRange TypeofParensRange;
388  SourceLocation TQ_constLoc, TQ_restrictLoc, TQ_volatileLoc, TQ_atomicLoc,
389  TQ_unalignedLoc;
390  SourceLocation FS_inlineLoc, FS_virtualLoc, FS_explicitLoc, FS_noreturnLoc;
391  SourceLocation FS_explicitCloseParenLoc;
392  SourceLocation FS_forceinlineLoc;
393  SourceLocation FriendLoc, ModulePrivateLoc, ConstexprLoc;
394  SourceLocation TQ_pipeLoc;
395 
396  WrittenBuiltinSpecs writtenBS;
397  void SaveWrittenBuiltinSpecs();
398 
399  ObjCDeclSpec *ObjCQualifiers;
400 
401  static bool isTypeRep(TST T) {
402  return (T == TST_typename || T == TST_typeofType ||
403  T == TST_underlyingType || T == TST_atomic);
404  }
405  static bool isExprRep(TST T) {
406  return (T == TST_typeofExpr || T == TST_decltype || T == TST_extint);
407  }
408  static bool isTemplateIdRep(TST T) {
409  return (T == TST_auto || T == TST_decltype_auto);
410  }
411 
412  DeclSpec(const DeclSpec &) = delete;
413  void operator=(const DeclSpec &) = delete;
414 public:
415  static bool isDeclRep(TST T) {
416  return (T == TST_enum || T == TST_struct ||
417  T == TST_interface || T == TST_union ||
418  T == TST_class);
419  }
420 
422  : StorageClassSpec(SCS_unspecified),
423  ThreadStorageClassSpec(TSCS_unspecified),
424  SCS_extern_in_linkage_spec(false),
425  TypeSpecWidth(static_cast<unsigned>(TypeSpecifierWidth::Unspecified)),
426  TypeSpecComplex(TSC_unspecified),
427  TypeSpecSign(static_cast<unsigned>(TypeSpecifierSign::Unspecified)),
428  TypeSpecType(TST_unspecified), TypeAltiVecVector(false),
429  TypeAltiVecPixel(false), TypeAltiVecBool(false), TypeSpecOwned(false),
430  TypeSpecPipe(false), TypeSpecSat(false), ConstrainedAuto(false),
431  TypeQualifiers(TQ_unspecified), FS_inline_specified(false),
432  FS_forceinline_specified(false), FS_virtual_specified(false),
433  FS_noreturn_specified(false), Friend_specified(false),
434  ConstexprSpecifier(
435  static_cast<unsigned>(ConstexprSpecKind::Unspecified)),
436  FS_explicit_specifier(), Attrs(attrFactory), writtenBS(),
437  ObjCQualifiers(nullptr) {}
438 
439  // storage-class-specifier
440  SCS getStorageClassSpec() const { return (SCS)StorageClassSpec; }
442  return (TSCS)ThreadStorageClassSpec;
443  }
444  bool isExternInLinkageSpec() const { return SCS_extern_in_linkage_spec; }
446  SCS_extern_in_linkage_spec = Value;
447  }
448 
449  SourceLocation getStorageClassSpecLoc() const { return StorageClassSpecLoc; }
451  return ThreadStorageClassSpecLoc;
452  }
453 
455  StorageClassSpec = DeclSpec::SCS_unspecified;
456  ThreadStorageClassSpec = DeclSpec::TSCS_unspecified;
457  SCS_extern_in_linkage_spec = false;
458  StorageClassSpecLoc = SourceLocation();
459  ThreadStorageClassSpecLoc = SourceLocation();
460  }
461 
463  TypeSpecType = DeclSpec::TST_unspecified;
464  TypeSpecOwned = false;
465  TSTLoc = SourceLocation();
466  }
467 
468  // type-specifier
470  return static_cast<TypeSpecifierWidth>(TypeSpecWidth);
471  }
472  TSC getTypeSpecComplex() const { return (TSC)TypeSpecComplex; }
474  return static_cast<TypeSpecifierSign>(TypeSpecSign);
475  }
476  TST getTypeSpecType() const { return (TST)TypeSpecType; }
477  bool isTypeAltiVecVector() const { return TypeAltiVecVector; }
478  bool isTypeAltiVecPixel() const { return TypeAltiVecPixel; }
479  bool isTypeAltiVecBool() const { return TypeAltiVecBool; }
480  bool isTypeSpecOwned() const { return TypeSpecOwned; }
481  bool isTypeRep() const { return isTypeRep((TST) TypeSpecType); }
482  bool isTypeSpecPipe() const { return TypeSpecPipe; }
483  bool isTypeSpecSat() const { return TypeSpecSat; }
484  bool isConstrainedAuto() const { return ConstrainedAuto; }
485 
487  assert(isTypeRep((TST) TypeSpecType) && "DeclSpec does not store a type");
488  return TypeRep;
489  }
490  Decl *getRepAsDecl() const {
491  assert(isDeclRep((TST) TypeSpecType) && "DeclSpec does not store a decl");
492  return DeclRep;
493  }
494  Expr *getRepAsExpr() const {
495  assert(isExprRep((TST) TypeSpecType) && "DeclSpec does not store an expr");
496  return ExprRep;
497  }
499  assert(isTemplateIdRep((TST) TypeSpecType) &&
500  "DeclSpec does not store a template id");
501  return TemplateIdRep;
502  }
503  CXXScopeSpec &getTypeSpecScope() { return TypeScope; }
504  const CXXScopeSpec &getTypeSpecScope() const { return TypeScope; }
505 
506  SourceRange getSourceRange() const LLVM_READONLY { return Range; }
507  SourceLocation getBeginLoc() const LLVM_READONLY { return Range.getBegin(); }
508  SourceLocation getEndLoc() const LLVM_READONLY { return Range.getEnd(); }
509 
510  SourceLocation getTypeSpecWidthLoc() const { return TSWRange.getBegin(); }
511  SourceRange getTypeSpecWidthRange() const { return TSWRange; }
512  SourceLocation getTypeSpecComplexLoc() const { return TSCLoc; }
513  SourceLocation getTypeSpecSignLoc() const { return TSSLoc; }
514  SourceLocation getTypeSpecTypeLoc() const { return TSTLoc; }
515  SourceLocation getAltiVecLoc() const { return AltiVecLoc; }
516  SourceLocation getTypeSpecSatLoc() const { return TSSatLoc; }
517 
519  assert(isDeclRep((TST) TypeSpecType) || TypeSpecType == TST_typename);
520  return TSTNameLoc;
521  }
522 
523  SourceRange getTypeofParensRange() const { return TypeofParensRange; }
524  void setTypeofParensRange(SourceRange range) { TypeofParensRange = range; }
525 
526  bool hasAutoTypeSpec() const {
527  return (TypeSpecType == TST_auto || TypeSpecType == TST_auto_type ||
528  TypeSpecType == TST_decltype_auto);
529  }
530 
531  bool hasTagDefinition() const;
532 
533  /// Turn a type-specifier-type into a string like "_Bool" or "union".
534  static const char *getSpecifierName(DeclSpec::TST T,
535  const PrintingPolicy &Policy);
536  static const char *getSpecifierName(DeclSpec::TQ Q);
537  static const char *getSpecifierName(TypeSpecifierSign S);
538  static const char *getSpecifierName(DeclSpec::TSC C);
539  static const char *getSpecifierName(TypeSpecifierWidth W);
540  static const char *getSpecifierName(DeclSpec::SCS S);
541  static const char *getSpecifierName(DeclSpec::TSCS S);
542  static const char *getSpecifierName(ConstexprSpecKind C);
543 
544  // type-qualifiers
545 
546  /// getTypeQualifiers - Return a set of TQs.
547  unsigned getTypeQualifiers() const { return TypeQualifiers; }
548  SourceLocation getConstSpecLoc() const { return TQ_constLoc; }
549  SourceLocation getRestrictSpecLoc() const { return TQ_restrictLoc; }
550  SourceLocation getVolatileSpecLoc() const { return TQ_volatileLoc; }
551  SourceLocation getAtomicSpecLoc() const { return TQ_atomicLoc; }
552  SourceLocation getUnalignedSpecLoc() const { return TQ_unalignedLoc; }
553  SourceLocation getPipeLoc() const { return TQ_pipeLoc; }
554 
555  /// Clear out all of the type qualifiers.
557  TypeQualifiers = 0;
558  TQ_constLoc = SourceLocation();
559  TQ_restrictLoc = SourceLocation();
560  TQ_volatileLoc = SourceLocation();
561  TQ_atomicLoc = SourceLocation();
562  TQ_unalignedLoc = SourceLocation();
563  TQ_pipeLoc = SourceLocation();
564  }
565 
566  // function-specifier
567  bool isInlineSpecified() const {
568  return FS_inline_specified | FS_forceinline_specified;
569  }
571  return FS_inline_specified ? FS_inlineLoc : FS_forceinlineLoc;
572  }
573 
575  return FS_explicit_specifier;
576  }
577 
578  bool isVirtualSpecified() const { return FS_virtual_specified; }
579  SourceLocation getVirtualSpecLoc() const { return FS_virtualLoc; }
580 
581  bool hasExplicitSpecifier() const {
582  return FS_explicit_specifier.isSpecified();
583  }
584  SourceLocation getExplicitSpecLoc() const { return FS_explicitLoc; }
586  return FS_explicit_specifier.getExpr()
587  ? SourceRange(FS_explicitLoc, FS_explicitCloseParenLoc)
588  : SourceRange(FS_explicitLoc);
589  }
590 
591  bool isNoreturnSpecified() const { return FS_noreturn_specified; }
592  SourceLocation getNoreturnSpecLoc() const { return FS_noreturnLoc; }
593 
595  FS_inline_specified = false;
596  FS_inlineLoc = SourceLocation();
597  FS_forceinline_specified = false;
598  FS_forceinlineLoc = SourceLocation();
599  FS_virtual_specified = false;
600  FS_virtualLoc = SourceLocation();
601  FS_explicit_specifier = ExplicitSpecifier();
602  FS_explicitLoc = SourceLocation();
603  FS_explicitCloseParenLoc = SourceLocation();
604  FS_noreturn_specified = false;
605  FS_noreturnLoc = SourceLocation();
606  }
607 
608  /// This method calls the passed in handler on each CVRU qual being
609  /// set.
610  /// Handle - a handler to be invoked.
612  llvm::function_ref<void(TQ, StringRef, SourceLocation)> Handle);
613 
614  /// This method calls the passed in handler on each qual being
615  /// set.
616  /// Handle - a handler to be invoked.
617  void forEachQualifier(
618  llvm::function_ref<void(TQ, StringRef, SourceLocation)> Handle);
619 
620  /// Return true if any type-specifier has been found.
621  bool hasTypeSpecifier() const {
626  }
627 
628  /// Return a bitmask of which flavors of specifiers this
629  /// DeclSpec includes.
630  unsigned getParsedSpecifiers() const;
631 
632  /// isEmpty - Return true if this declaration specifier is completely empty:
633  /// no tokens were parsed in the production of it.
634  bool isEmpty() const {
636  }
637 
638  void SetRangeStart(SourceLocation Loc) { Range.setBegin(Loc); }
639  void SetRangeEnd(SourceLocation Loc) { Range.setEnd(Loc); }
640 
641  /// These methods set the specified attribute of the DeclSpec and
642  /// return false if there was no error. If an error occurs (for
643  /// example, if we tried to set "auto" on a spec with "extern"
644  /// already set), they return true and set PrevSpec and DiagID
645  /// such that
646  /// Diag(Loc, DiagID) << PrevSpec;
647  /// will yield a useful result.
648  ///
649  /// TODO: use a more general approach that still allows these
650  /// diagnostics to be ignored when desired.
651  bool SetStorageClassSpec(Sema &S, SCS SC, SourceLocation Loc,
652  const char *&PrevSpec, unsigned &DiagID,
653  const PrintingPolicy &Policy);
655  const char *&PrevSpec, unsigned &DiagID);
657  const char *&PrevSpec, unsigned &DiagID,
658  const PrintingPolicy &Policy);
659  bool SetTypeSpecComplex(TSC C, SourceLocation Loc, const char *&PrevSpec,
660  unsigned &DiagID);
662  const char *&PrevSpec, unsigned &DiagID);
663  bool SetTypeSpecType(TST T, SourceLocation Loc, const char *&PrevSpec,
664  unsigned &DiagID, const PrintingPolicy &Policy);
665  bool SetTypeSpecType(TST T, SourceLocation Loc, const char *&PrevSpec,
666  unsigned &DiagID, ParsedType Rep,
667  const PrintingPolicy &Policy);
668  bool SetTypeSpecType(TST T, SourceLocation Loc, const char *&PrevSpec,
669  unsigned &DiagID, TypeResult Rep,
670  const PrintingPolicy &Policy) {
671  if (Rep.isInvalid())
672  return SetTypeSpecError();
673  return SetTypeSpecType(T, Loc, PrevSpec, DiagID, Rep.get(), Policy);
674  }
675  bool SetTypeSpecType(TST T, SourceLocation Loc, const char *&PrevSpec,
676  unsigned &DiagID, Decl *Rep, bool Owned,
677  const PrintingPolicy &Policy);
678  bool SetTypeSpecType(TST T, SourceLocation TagKwLoc,
679  SourceLocation TagNameLoc, const char *&PrevSpec,
680  unsigned &DiagID, ParsedType Rep,
681  const PrintingPolicy &Policy);
682  bool SetTypeSpecType(TST T, SourceLocation TagKwLoc,
683  SourceLocation TagNameLoc, const char *&PrevSpec,
684  unsigned &DiagID, Decl *Rep, bool Owned,
685  const PrintingPolicy &Policy);
686  bool SetTypeSpecType(TST T, SourceLocation Loc, const char *&PrevSpec,
687  unsigned &DiagID, TemplateIdAnnotation *Rep,
688  const PrintingPolicy &Policy);
689 
690  bool SetTypeSpecType(TST T, SourceLocation Loc, const char *&PrevSpec,
691  unsigned &DiagID, Expr *Rep,
692  const PrintingPolicy &policy);
693  bool SetTypeAltiVecVector(bool isAltiVecVector, SourceLocation Loc,
694  const char *&PrevSpec, unsigned &DiagID,
695  const PrintingPolicy &Policy);
696  bool SetTypeAltiVecPixel(bool isAltiVecPixel, SourceLocation Loc,
697  const char *&PrevSpec, unsigned &DiagID,
698  const PrintingPolicy &Policy);
699  bool SetTypeAltiVecBool(bool isAltiVecBool, SourceLocation Loc,
700  const char *&PrevSpec, unsigned &DiagID,
701  const PrintingPolicy &Policy);
702  bool SetTypePipe(bool isPipe, SourceLocation Loc,
703  const char *&PrevSpec, unsigned &DiagID,
704  const PrintingPolicy &Policy);
705  bool SetExtIntType(SourceLocation KWLoc, Expr *BitWidth,
706  const char *&PrevSpec, unsigned &DiagID,
707  const PrintingPolicy &Policy);
708  bool SetTypeSpecSat(SourceLocation Loc, const char *&PrevSpec,
709  unsigned &DiagID);
710  bool SetTypeSpecError();
711  void UpdateDeclRep(Decl *Rep) {
712  assert(isDeclRep((TST) TypeSpecType));
713  DeclRep = Rep;
714  }
716  assert(isTypeRep((TST) TypeSpecType));
717  TypeRep = Rep;
718  }
719  void UpdateExprRep(Expr *Rep) {
720  assert(isExprRep((TST) TypeSpecType));
721  ExprRep = Rep;
722  }
723 
724  bool SetTypeQual(TQ T, SourceLocation Loc);
725 
726  bool SetTypeQual(TQ T, SourceLocation Loc, const char *&PrevSpec,
727  unsigned &DiagID, const LangOptions &Lang);
728 
729  bool setFunctionSpecInline(SourceLocation Loc, const char *&PrevSpec,
730  unsigned &DiagID);
731  bool setFunctionSpecForceInline(SourceLocation Loc, const char *&PrevSpec,
732  unsigned &DiagID);
733  bool setFunctionSpecVirtual(SourceLocation Loc, const char *&PrevSpec,
734  unsigned &DiagID);
735  bool setFunctionSpecExplicit(SourceLocation Loc, const char *&PrevSpec,
736  unsigned &DiagID, ExplicitSpecifier ExplicitSpec,
737  SourceLocation CloseParenLoc);
738  bool setFunctionSpecNoreturn(SourceLocation Loc, const char *&PrevSpec,
739  unsigned &DiagID);
740 
741  bool SetFriendSpec(SourceLocation Loc, const char *&PrevSpec,
742  unsigned &DiagID);
743  bool setModulePrivateSpec(SourceLocation Loc, const char *&PrevSpec,
744  unsigned &DiagID);
745  bool SetConstexprSpec(ConstexprSpecKind ConstexprKind, SourceLocation Loc,
746  const char *&PrevSpec, unsigned &DiagID);
747 
748  bool isFriendSpecified() const { return Friend_specified; }
749  SourceLocation getFriendSpecLoc() const { return FriendLoc; }
750 
751  bool isModulePrivateSpecified() const { return ModulePrivateLoc.isValid(); }
752  SourceLocation getModulePrivateSpecLoc() const { return ModulePrivateLoc; }
753 
755  return ConstexprSpecKind(ConstexprSpecifier);
756  }
757 
758  SourceLocation getConstexprSpecLoc() const { return ConstexprLoc; }
759  bool hasConstexprSpecifier() const {
761  }
762 
764  ConstexprSpecifier = static_cast<unsigned>(ConstexprSpecKind::Unspecified);
765  ConstexprLoc = SourceLocation();
766  }
767 
769  return Attrs.getPool();
770  }
771 
772  /// Concatenates two attribute lists.
773  ///
774  /// The GCC attribute syntax allows for the following:
775  ///
776  /// \code
777  /// short __attribute__(( unused, deprecated ))
778  /// int __attribute__(( may_alias, aligned(16) )) var;
779  /// \endcode
780  ///
781  /// This declares 4 attributes using 2 lists. The following syntax is
782  /// also allowed and equivalent to the previous declaration.
783  ///
784  /// \code
785  /// short __attribute__((unused)) __attribute__((deprecated))
786  /// int __attribute__((may_alias)) __attribute__((aligned(16))) var;
787  /// \endcode
788  ///
790  Attrs.addAll(AL.begin(), AL.end());
791  }
792 
793  bool hasAttributes() const { return !Attrs.empty(); }
794 
795  ParsedAttributes &getAttributes() { return Attrs; }
796  const ParsedAttributes &getAttributes() const { return Attrs; }
797 
799  Attrs.takeAllFrom(attrs);
800  }
801 
802  /// Finish - This does final analysis of the declspec, issuing diagnostics for
803  /// things like "_Imaginary" (lacking an FP type). After calling this method,
804  /// DeclSpec is guaranteed self-consistent, even if an error occurred.
805  void Finish(Sema &S, const PrintingPolicy &Policy);
806 
808  return writtenBS;
809  }
810 
811  ObjCDeclSpec *getObjCQualifiers() const { return ObjCQualifiers; }
812  void setObjCQualifiers(ObjCDeclSpec *quals) { ObjCQualifiers = quals; }
813 
814  /// Checks if this DeclSpec can stand alone, without a Declarator.
815  ///
816  /// Only tag declspecs can stand alone.
817  bool isMissingDeclaratorOk();
818 };
819 
820 /// Captures information about "declaration specifiers" specific to
821 /// Objective-C.
823 public:
824  /// ObjCDeclQualifier - Qualifier used on types in method
825  /// declarations. Not all combinations are sensible. Parameters
826  /// can be one of { in, out, inout } with one of { bycopy, byref }.
827  /// Returns can either be { oneway } or not.
828  ///
829  /// This should be kept in sync with Decl::ObjCDeclQualifier.
831  DQ_None = 0x0,
832  DQ_In = 0x1,
833  DQ_Inout = 0x2,
834  DQ_Out = 0x4,
835  DQ_Bycopy = 0x8,
836  DQ_Byref = 0x10,
837  DQ_Oneway = 0x20,
839  };
840 
842  : objcDeclQualifier(DQ_None),
843  PropertyAttributes(ObjCPropertyAttribute::kind_noattr), Nullability(0),
844  GetterName(nullptr), SetterName(nullptr) {}
845 
847  return (ObjCDeclQualifier)objcDeclQualifier;
848  }
850  objcDeclQualifier = (ObjCDeclQualifier) (objcDeclQualifier | DQVal);
851  }
853  objcDeclQualifier = (ObjCDeclQualifier) (objcDeclQualifier & ~DQVal);
854  }
855 
857  return ObjCPropertyAttribute::Kind(PropertyAttributes);
858  }
860  PropertyAttributes =
861  (ObjCPropertyAttribute::Kind)(PropertyAttributes | PRVal);
862  }
863 
865  assert(
868  "Objective-C declspec doesn't have nullability");
869  return static_cast<NullabilityKind>(Nullability);
870  }
871 
873  assert(
876  "Objective-C declspec doesn't have nullability");
877  return NullabilityLoc;
878  }
879 
881  assert(
884  "Set the nullability declspec or property attribute first");
885  Nullability = static_cast<unsigned>(kind);
886  NullabilityLoc = loc;
887  }
888 
889  const IdentifierInfo *getGetterName() const { return GetterName; }
890  IdentifierInfo *getGetterName() { return GetterName; }
891  SourceLocation getGetterNameLoc() const { return GetterNameLoc; }
893  GetterName = name;
894  GetterNameLoc = loc;
895  }
896 
897  const IdentifierInfo *getSetterName() const { return SetterName; }
898  IdentifierInfo *getSetterName() { return SetterName; }
899  SourceLocation getSetterNameLoc() const { return SetterNameLoc; }
901  SetterName = name;
902  SetterNameLoc = loc;
903  }
904 
905 private:
906  // FIXME: These two are unrelated and mutually exclusive. So perhaps
907  // we can put them in a union to reflect their mutual exclusivity
908  // (space saving is negligible).
909  unsigned objcDeclQualifier : 7;
910 
911  // NOTE: VC++ treats enums as signed, avoid using ObjCPropertyAttribute::Kind
912  unsigned PropertyAttributes : NumObjCPropertyAttrsBits;
913 
914  unsigned Nullability : 2;
915 
916  SourceLocation NullabilityLoc;
917 
918  IdentifierInfo *GetterName; // getter name or NULL if no getter
919  IdentifierInfo *SetterName; // setter name or NULL if no setter
920  SourceLocation GetterNameLoc; // location of the getter attribute's value
921  SourceLocation SetterNameLoc; // location of the setter attribute's value
922 
923 };
924 
925 /// Describes the kind of unqualified-id parsed.
926 enum class UnqualifiedIdKind {
927  /// An identifier.
929  /// An overloaded operator name, e.g., operator+.
931  /// A conversion function name, e.g., operator int.
933  /// A user-defined literal name, e.g., operator "" _i.
935  /// A constructor name.
937  /// A constructor named via a template-id.
939  /// A destructor name.
941  /// A template-id, e.g., f<int>.
943  /// An implicit 'self' parameter
945  /// A deduction-guide name (a template-name)
947 };
948 
949 /// Represents a C++ unqualified-id that has been parsed.
951 private:
952  UnqualifiedId(const UnqualifiedId &Other) = delete;
953  const UnqualifiedId &operator=(const UnqualifiedId &) = delete;
954 
955 public:
956  /// Describes the kind of unqualified-id parsed.
958 
959  struct OFI {
960  /// The kind of overloaded operator.
962 
963  /// The source locations of the individual tokens that name
964  /// the operator, e.g., the "new", "[", and "]" tokens in
965  /// operator new [].
966  ///
967  /// Different operators have different numbers of tokens in their name,
968  /// up to three. Any remaining source locations in this array will be
969  /// set to an invalid value for operators with fewer than three tokens.
970  unsigned SymbolLocations[3];
971  };
972 
973  /// Anonymous union that holds extra data associated with the
974  /// parsed unqualified-id.
975  union {
976  /// When Kind == IK_Identifier, the parsed identifier, or when
977  /// Kind == IK_UserLiteralId, the identifier suffix.
979 
980  /// When Kind == IK_OperatorFunctionId, the overloaded operator
981  /// that we parsed.
983 
984  /// When Kind == IK_ConversionFunctionId, the type that the
985  /// conversion function names.
987 
988  /// When Kind == IK_ConstructorName, the class-name of the type
989  /// whose constructor is being referenced.
991 
992  /// When Kind == IK_DestructorName, the type referred to by the
993  /// class-name.
995 
996  /// When Kind == IK_DeductionGuideName, the parsed template-name.
998 
999  /// When Kind == IK_TemplateId or IK_ConstructorTemplateId,
1000  /// the template-id annotation that contains the template name and
1001  /// template arguments.
1003  };
1004 
1005  /// The location of the first token that describes this unqualified-id,
1006  /// which will be the location of the identifier, "operator" keyword,
1007  /// tilde (for a destructor), or the template name of a template-id.
1009 
1010  /// The location of the last token that describes this unqualified-id.
1012 
1015 
1016  /// Clear out this unqualified-id, setting it to default (invalid)
1017  /// state.
1018  void clear() {
1020  Identifier = nullptr;
1023  }
1024 
1025  /// Determine whether this unqualified-id refers to a valid name.
1026  bool isValid() const { return StartLocation.isValid(); }
1027 
1028  /// Determine whether this unqualified-id refers to an invalid name.
1029  bool isInvalid() const { return !isValid(); }
1030 
1031  /// Determine what kind of name we have.
1032  UnqualifiedIdKind getKind() const { return Kind; }
1034 
1035  /// Specify that this unqualified-id was parsed as an identifier.
1036  ///
1037  /// \param Id the parsed identifier.
1038  /// \param IdLoc the location of the parsed identifier.
1041  Identifier = const_cast<IdentifierInfo *>(Id);
1042  StartLocation = EndLocation = IdLoc;
1043  }
1044 
1045  /// Specify that this unqualified-id was parsed as an
1046  /// operator-function-id.
1047  ///
1048  /// \param OperatorLoc the location of the 'operator' keyword.
1049  ///
1050  /// \param Op the overloaded operator.
1051  ///
1052  /// \param SymbolLocations the locations of the individual operator symbols
1053  /// in the operator.
1054  void setOperatorFunctionId(SourceLocation OperatorLoc,
1056  SourceLocation SymbolLocations[3]);
1057 
1058  /// Specify that this unqualified-id was parsed as a
1059  /// conversion-function-id.
1060  ///
1061  /// \param OperatorLoc the location of the 'operator' keyword.
1062  ///
1063  /// \param Ty the type to which this conversion function is converting.
1064  ///
1065  /// \param EndLoc the location of the last token that makes up the type name.
1067  ParsedType Ty,
1068  SourceLocation EndLoc) {
1070  StartLocation = OperatorLoc;
1071  EndLocation = EndLoc;
1072  ConversionFunctionId = Ty;
1073  }
1074 
1075  /// Specific that this unqualified-id was parsed as a
1076  /// literal-operator-id.
1077  ///
1078  /// \param Id the parsed identifier.
1079  ///
1080  /// \param OpLoc the location of the 'operator' keyword.
1081  ///
1082  /// \param IdLoc the location of the identifier.
1084  SourceLocation IdLoc) {
1086  Identifier = const_cast<IdentifierInfo *>(Id);
1087  StartLocation = OpLoc;
1088  EndLocation = IdLoc;
1089  }
1090 
1091  /// Specify that this unqualified-id was parsed as a constructor name.
1092  ///
1093  /// \param ClassType the class type referred to by the constructor name.
1094  ///
1095  /// \param ClassNameLoc the location of the class name.
1096  ///
1097  /// \param EndLoc the location of the last token that makes up the type name.
1099  SourceLocation ClassNameLoc,
1100  SourceLocation EndLoc) {
1102  StartLocation = ClassNameLoc;
1103  EndLocation = EndLoc;
1104  ConstructorName = ClassType;
1105  }
1106 
1107  /// Specify that this unqualified-id was parsed as a
1108  /// template-id that names a constructor.
1109  ///
1110  /// \param TemplateId the template-id annotation that describes the parsed
1111  /// template-id. This UnqualifiedId instance will take ownership of the
1112  /// \p TemplateId and will free it on destruction.
1114 
1115  /// Specify that this unqualified-id was parsed as a destructor name.
1116  ///
1117  /// \param TildeLoc the location of the '~' that introduces the destructor
1118  /// name.
1119  ///
1120  /// \param ClassType the name of the class referred to by the destructor name.
1122  ParsedType ClassType,
1123  SourceLocation EndLoc) {
1125  StartLocation = TildeLoc;
1126  EndLocation = EndLoc;
1127  DestructorName = ClassType;
1128  }
1129 
1130  /// Specify that this unqualified-id was parsed as a template-id.
1131  ///
1132  /// \param TemplateId the template-id annotation that describes the parsed
1133  /// template-id. This UnqualifiedId instance will take ownership of the
1134  /// \p TemplateId and will free it on destruction.
1136 
1137  /// Specify that this unqualified-id was parsed as a template-name for
1138  /// a deduction-guide.
1139  ///
1140  /// \param Template The parsed template-name.
1141  /// \param TemplateLoc The location of the parsed template-name.
1143  SourceLocation TemplateLoc) {
1145  TemplateName = Template;
1146  StartLocation = EndLocation = TemplateLoc;
1147  }
1148 
1149  /// Return the source range that covers this unqualified-id.
1150  SourceRange getSourceRange() const LLVM_READONLY {
1152  }
1153  SourceLocation getBeginLoc() const LLVM_READONLY { return StartLocation; }
1154  SourceLocation getEndLoc() const LLVM_READONLY { return EndLocation; }
1155 };
1156 
1157 /// A set of tokens that has been cached for later parsing.
1159 
1160 /// One instance of this struct is used for each type in a
1161 /// declarator that is parsed.
1162 ///
1163 /// This is intended to be a small value object.
1165  enum {
1167  } Kind;
1168 
1169  /// Loc - The place where this type was defined.
1171  /// EndLoc - If valid, the place where this chunck ends.
1173 
1175  if (EndLoc.isInvalid())
1176  return SourceRange(Loc, Loc);
1177  return SourceRange(Loc, EndLoc);
1178  }
1179 
1181 
1183  /// The type qualifiers: const/volatile/restrict/unaligned/atomic.
1184  unsigned TypeQuals : 5;
1185 
1186  /// The location of the const-qualifier, if any.
1187  unsigned ConstQualLoc;
1188 
1189  /// The location of the volatile-qualifier, if any.
1191 
1192  /// The location of the restrict-qualifier, if any.
1194 
1195  /// The location of the _Atomic-qualifier, if any.
1196  unsigned AtomicQualLoc;
1197 
1198  /// The location of the __unaligned-qualifier, if any.
1200 
1201  void destroy() {
1202  }
1203  };
1204 
1206  /// The type qualifier: restrict. [GNU] C++ extension
1207  bool HasRestrict : 1;
1208  /// True if this is an lvalue reference, false if it's an rvalue reference.
1209  bool LValueRef : 1;
1210  void destroy() {
1211  }
1212  };
1213 
1214  struct ArrayTypeInfo {
1215  /// The type qualifiers for the array:
1216  /// const/volatile/restrict/__unaligned/_Atomic.
1217  unsigned TypeQuals : 5;
1218 
1219  /// True if this dimension included the 'static' keyword.
1220  unsigned hasStatic : 1;
1221 
1222  /// True if this dimension was [*]. In this case, NumElts is null.
1223  unsigned isStar : 1;
1224 
1225  /// This is the size of the array, or null if [] or [*] was specified.
1226  /// Since the parser is multi-purpose, and we don't want to impose a root
1227  /// expression class on all clients, NumElts is untyped.
1229 
1230  void destroy() {}
1231  };
1232 
1233  /// ParamInfo - An array of paraminfo objects is allocated whenever a function
1234  /// declarator is parsed. There are two interesting styles of parameters
1235  /// here:
1236  /// K&R-style identifier lists and parameter type lists. K&R-style identifier
1237  /// lists will have information about the identifier, but no type information.
1238  /// Parameter type lists will have type info (if the actions module provides
1239  /// it), but may have null identifier info: e.g. for 'void foo(int X, int)'.
1240  struct ParamInfo {
1244 
1245  /// DefaultArgTokens - When the parameter's default argument
1246  /// cannot be parsed immediately (because it occurs within the
1247  /// declaration of a member function), it will be stored here as a
1248  /// sequence of tokens to be parsed once the class definition is
1249  /// complete. Non-NULL indicates that there is a default argument.
1250  std::unique_ptr<CachedTokens> DefaultArgTokens;
1251 
1252  ParamInfo() = default;
1254  Decl *param,
1255  std::unique_ptr<CachedTokens> DefArgTokens = nullptr)
1256  : Ident(ident), IdentLoc(iloc), Param(param),
1257  DefaultArgTokens(std::move(DefArgTokens)) {}
1258  };
1259 
1260  struct TypeAndRange {
1263  };
1264 
1266  /// hasPrototype - This is true if the function had at least one typed
1267  /// parameter. If the function is () or (a,b,c), then it has no prototype,
1268  /// and is treated as a K&R-style function.
1269  unsigned hasPrototype : 1;
1270 
1271  /// isVariadic - If this function has a prototype, and if that
1272  /// proto ends with ',...)', this is true. When true, EllipsisLoc
1273  /// contains the location of the ellipsis.
1274  unsigned isVariadic : 1;
1275 
1276  /// Can this declaration be a constructor-style initializer?
1277  unsigned isAmbiguous : 1;
1278 
1279  /// Whether the ref-qualifier (if any) is an lvalue reference.
1280  /// Otherwise, it's an rvalue reference.
1282 
1283  /// ExceptionSpecType - An ExceptionSpecificationType value.
1284  unsigned ExceptionSpecType : 4;
1285 
1286  /// DeleteParams - If this is true, we need to delete[] Params.
1287  unsigned DeleteParams : 1;
1288 
1289  /// HasTrailingReturnType - If this is true, a trailing return type was
1290  /// specified.
1292 
1293  /// The location of the left parenthesis in the source.
1294  unsigned LParenLoc;
1295 
1296  /// When isVariadic is true, the location of the ellipsis in the source.
1297  unsigned EllipsisLoc;
1298 
1299  /// The location of the right parenthesis in the source.
1300  unsigned RParenLoc;
1301 
1302  /// NumParams - This is the number of formal parameters specified by the
1303  /// declarator.
1304  unsigned NumParams;
1305 
1306  /// NumExceptionsOrDecls - This is the number of types in the
1307  /// dynamic-exception-decl, if the function has one. In C, this is the
1308  /// number of declarations in the function prototype.
1310 
1311  /// The location of the ref-qualifier, if any.
1312  ///
1313  /// If this is an invalid location, there is no ref-qualifier.
1315 
1316  /// The location of the 'mutable' qualifer in a lambda-declarator, if
1317  /// any.
1318  unsigned MutableLoc;
1319 
1320  /// The beginning location of the exception specification, if any.
1322 
1323  /// The end location of the exception specification, if any.
1325 
1326  /// Params - This is a pointer to a new[]'d array of ParamInfo objects that
1327  /// describe the parameters specified by this function declarator. null if
1328  /// there are no parameters specified.
1330 
1331  /// DeclSpec for the function with the qualifier related info.
1333 
1334  /// AtttibuteFactory for the MethodQualifiers.
1336 
1337  union {
1338  /// Pointer to a new[]'d array of TypeAndRange objects that
1339  /// contain the types in the function's dynamic exception specification
1340  /// and their locations, if there is one.
1342 
1343  /// Pointer to the expression in the noexcept-specifier of this
1344  /// function, if it has one.
1346 
1347  /// Pointer to the cached tokens for an exception-specification
1348  /// that has not yet been parsed.
1350 
1351  /// Pointer to a new[]'d array of declarations that need to be available
1352  /// for lookup inside the function body, if one exists. Does not exist in
1353  /// C++.
1355  };
1356 
1357  /// If HasTrailingReturnType is true, this is the trailing return
1358  /// type specified.
1360 
1361  /// If HasTrailingReturnType is true, this is the location of the trailing
1362  /// return type.
1364 
1365  /// Reset the parameter list to having zero parameters.
1366  ///
1367  /// This is used in various places for error recovery.
1368  void freeParams() {
1369  for (unsigned I = 0; I < NumParams; ++I)
1370  Params[I].DefaultArgTokens.reset();
1371  if (DeleteParams) {
1372  delete[] Params;
1373  DeleteParams = false;
1374  }
1375  NumParams = 0;
1376  }
1377 
1378  void destroy() {
1379  freeParams();
1380  delete QualAttrFactory;
1381  delete MethodQualifiers;
1382  switch (getExceptionSpecType()) {
1383  default:
1384  break;
1385  case EST_Dynamic:
1386  delete[] Exceptions;
1387  break;
1388  case EST_Unparsed:
1389  delete ExceptionSpecTokens;
1390  break;
1391  case EST_None:
1392  if (NumExceptionsOrDecls != 0)
1393  delete[] DeclsInPrototype;
1394  break;
1395  }
1396  }
1397 
1399  if (!MethodQualifiers) {
1402  }
1403  return *MethodQualifiers;
1404  }
1405 
1406  /// isKNRPrototype - Return true if this is a K&R style identifier list,
1407  /// like "void foo(a,b,c)". In a function definition, this will be followed
1408  /// by the parameter type definitions.
1409  bool isKNRPrototype() const { return !hasPrototype && NumParams != 0; }
1410 
1413  }
1414 
1417  }
1418 
1421  }
1422 
1425  }
1426 
1429  }
1430 
1433  }
1434 
1435  /// Retrieve the location of the ref-qualifier, if any.
1438  }
1439 
1440  /// Retrieve the location of the 'const' qualifier.
1442  assert(MethodQualifiers);
1444  }
1445 
1446  /// Retrieve the location of the 'volatile' qualifier.
1448  assert(MethodQualifiers);
1450  }
1451 
1452  /// Retrieve the location of the 'restrict' qualifier.
1454  assert(MethodQualifiers);
1456  }
1457 
1458  /// Retrieve the location of the 'mutable' qualifier, if any.
1461  }
1462 
1463  /// Determine whether this function declaration contains a
1464  /// ref-qualifier.
1465  bool hasRefQualifier() const { return getRefQualifierLoc().isValid(); }
1466 
1467  /// Determine whether this lambda-declarator contains a 'mutable'
1468  /// qualifier.
1469  bool hasMutableQualifier() const { return getMutableLoc().isValid(); }
1470 
1471  /// Determine whether this method has qualifiers.
1475  }
1476 
1477  /// Get the type of exception specification this function has.
1479  return static_cast<ExceptionSpecificationType>(ExceptionSpecType);
1480  }
1481 
1482  /// Get the number of dynamic exception specifications.
1483  unsigned getNumExceptions() const {
1484  assert(ExceptionSpecType != EST_None);
1485  return NumExceptionsOrDecls;
1486  }
1487 
1488  /// Get the non-parameter decls defined within this function
1489  /// prototype. Typically these are tag declarations.
1491  assert(ExceptionSpecType == EST_None);
1492  return llvm::makeArrayRef(DeclsInPrototype, NumExceptionsOrDecls);
1493  }
1494 
1495  /// Determine whether this function declarator had a
1496  /// trailing-return-type.
1498 
1499  /// Get the trailing-return-type for this function declarator.
1501  assert(HasTrailingReturnType);
1502  return TrailingReturnType;
1503  }
1504 
1505  /// Get the trailing-return-type location for this function declarator.
1507  assert(HasTrailingReturnType);
1509  }
1510  };
1511 
1513  /// For now, sema will catch these as invalid.
1514  /// The type qualifiers: const/volatile/restrict/__unaligned/_Atomic.
1515  unsigned TypeQuals : 5;
1516 
1517  void destroy() {
1518  }
1519  };
1520 
1522  /// The type qualifiers: const/volatile/restrict/__unaligned/_Atomic.
1523  unsigned TypeQuals : 5;
1524  /// Location of the '*' token.
1525  unsigned StarLoc;
1526  // CXXScopeSpec has a constructor, so it can't be a direct member.
1527  // So we need some pointer-aligned storage and a bit of trickery.
1528  alignas(CXXScopeSpec) char ScopeMem[sizeof(CXXScopeSpec)];
1530  return *reinterpret_cast<CXXScopeSpec *>(ScopeMem);
1531  }
1532  const CXXScopeSpec &Scope() const {
1533  return *reinterpret_cast<const CXXScopeSpec *>(ScopeMem);
1534  }
1535  void destroy() {
1536  Scope().~CXXScopeSpec();
1537  }
1538  };
1539 
1540  struct PipeTypeInfo {
1541  /// The access writes.
1542  unsigned AccessWrites : 3;
1543 
1544  void destroy() {}
1545  };
1546 
1547  union {
1555  };
1556 
1557  void destroy() {
1558  switch (Kind) {
1559  case DeclaratorChunk::Function: return Fun.destroy();
1560  case DeclaratorChunk::Pointer: return Ptr.destroy();
1561  case DeclaratorChunk::BlockPointer: return Cls.destroy();
1562  case DeclaratorChunk::Reference: return Ref.destroy();
1563  case DeclaratorChunk::Array: return Arr.destroy();
1565  case DeclaratorChunk::Paren: return;
1566  case DeclaratorChunk::Pipe: return PipeInfo.destroy();
1567  }
1568  }
1569 
1570  /// If there are attributes applied to this declaratorchunk, return
1571  /// them.
1572  const ParsedAttributesView &getAttrs() const { return AttrList; }
1574 
1575  /// Return a DeclaratorChunk for a pointer.
1576  static DeclaratorChunk getPointer(unsigned TypeQuals, SourceLocation Loc,
1577  SourceLocation ConstQualLoc,
1578  SourceLocation VolatileQualLoc,
1579  SourceLocation RestrictQualLoc,
1580  SourceLocation AtomicQualLoc,
1581  SourceLocation UnalignedQualLoc) {
1582  DeclaratorChunk I;
1583  I.Kind = Pointer;
1584  I.Loc = Loc;
1585  I.Ptr.TypeQuals = TypeQuals;
1586  I.Ptr.ConstQualLoc = ConstQualLoc.getRawEncoding();
1587  I.Ptr.VolatileQualLoc = VolatileQualLoc.getRawEncoding();
1588  I.Ptr.RestrictQualLoc = RestrictQualLoc.getRawEncoding();
1589  I.Ptr.AtomicQualLoc = AtomicQualLoc.getRawEncoding();
1590  I.Ptr.UnalignedQualLoc = UnalignedQualLoc.getRawEncoding();
1591  return I;
1592  }
1593 
1594  /// Return a DeclaratorChunk for a reference.
1595  static DeclaratorChunk getReference(unsigned TypeQuals, SourceLocation Loc,
1596  bool lvalue) {
1597  DeclaratorChunk I;
1598  I.Kind = Reference;
1599  I.Loc = Loc;
1600  I.Ref.HasRestrict = (TypeQuals & DeclSpec::TQ_restrict) != 0;
1601  I.Ref.LValueRef = lvalue;
1602  return I;
1603  }
1604 
1605  /// Return a DeclaratorChunk for an array.
1606  static DeclaratorChunk getArray(unsigned TypeQuals,
1607  bool isStatic, bool isStar, Expr *NumElts,
1608  SourceLocation LBLoc, SourceLocation RBLoc) {
1609  DeclaratorChunk I;
1610  I.Kind = Array;
1611  I.Loc = LBLoc;
1612  I.EndLoc = RBLoc;
1613  I.Arr.TypeQuals = TypeQuals;
1614  I.Arr.hasStatic = isStatic;
1615  I.Arr.isStar = isStar;
1616  I.Arr.NumElts = NumElts;
1617  return I;
1618  }
1619 
1620  /// DeclaratorChunk::getFunction - Return a DeclaratorChunk for a function.
1621  /// "TheDeclarator" is the declarator that this will be added to.
1622  static DeclaratorChunk getFunction(bool HasProto,
1623  bool IsAmbiguous,
1624  SourceLocation LParenLoc,
1625  ParamInfo *Params, unsigned NumParams,
1626  SourceLocation EllipsisLoc,
1627  SourceLocation RParenLoc,
1628  bool RefQualifierIsLvalueRef,
1629  SourceLocation RefQualifierLoc,
1630  SourceLocation MutableLoc,
1631  ExceptionSpecificationType ESpecType,
1632  SourceRange ESpecRange,
1633  ParsedType *Exceptions,
1634  SourceRange *ExceptionRanges,
1635  unsigned NumExceptions,
1636  Expr *NoexceptExpr,
1637  CachedTokens *ExceptionSpecTokens,
1638  ArrayRef<NamedDecl *> DeclsInPrototype,
1639  SourceLocation LocalRangeBegin,
1640  SourceLocation LocalRangeEnd,
1641  Declarator &TheDeclarator,
1642  TypeResult TrailingReturnType =
1643  TypeResult(),
1644  SourceLocation TrailingReturnTypeLoc =
1645  SourceLocation(),
1646  DeclSpec *MethodQualifiers = nullptr);
1647 
1648  /// Return a DeclaratorChunk for a block.
1649  static DeclaratorChunk getBlockPointer(unsigned TypeQuals,
1650  SourceLocation Loc) {
1651  DeclaratorChunk I;
1652  I.Kind = BlockPointer;
1653  I.Loc = Loc;
1654  I.Cls.TypeQuals = TypeQuals;
1655  return I;
1656  }
1657 
1658  /// Return a DeclaratorChunk for a block.
1659  static DeclaratorChunk getPipe(unsigned TypeQuals,
1660  SourceLocation Loc) {
1661  DeclaratorChunk I;
1662  I.Kind = Pipe;
1663  I.Loc = Loc;
1664  I.Cls.TypeQuals = TypeQuals;
1665  return I;
1666  }
1667 
1669  unsigned TypeQuals,
1670  SourceLocation StarLoc,
1672  DeclaratorChunk I;
1673  I.Kind = MemberPointer;
1674  I.Loc = SS.getBeginLoc();
1675  I.EndLoc = EndLoc;
1676  I.Mem.StarLoc = StarLoc.getRawEncoding();
1677  I.Mem.TypeQuals = TypeQuals;
1678  new (I.Mem.ScopeMem) CXXScopeSpec(SS);
1679  return I;
1680  }
1681 
1682  /// Return a DeclaratorChunk for a paren.
1684  SourceLocation RParenLoc) {
1685  DeclaratorChunk I;
1686  I.Kind = Paren;
1687  I.Loc = LParenLoc;
1688  I.EndLoc = RParenLoc;
1689  return I;
1690  }
1691 
1692  bool isParen() const {
1693  return Kind == Paren;
1694  }
1695 };
1696 
1697 /// A parsed C++17 decomposition declarator of the form
1698 /// '[' identifier-list ']'
1700 public:
1701  struct Binding {
1704  };
1705 
1706 private:
1707  /// The locations of the '[' and ']' tokens.
1708  SourceLocation LSquareLoc, RSquareLoc;
1709 
1710  /// The bindings.
1711  Binding *Bindings;
1712  unsigned NumBindings : 31;
1713  unsigned DeleteBindings : 1;
1714 
1715  friend class Declarator;
1716 
1717 public:
1719  : Bindings(nullptr), NumBindings(0), DeleteBindings(false) {}
1723  if (DeleteBindings)
1724  delete[] Bindings;
1725  }
1726 
1727  void clear() {
1728  LSquareLoc = RSquareLoc = SourceLocation();
1729  if (DeleteBindings)
1730  delete[] Bindings;
1731  Bindings = nullptr;
1732  NumBindings = 0;
1733  DeleteBindings = false;
1734  }
1735 
1737  return llvm::makeArrayRef(Bindings, NumBindings);
1738  }
1739 
1740  bool isSet() const { return LSquareLoc.isValid(); }
1741 
1742  SourceLocation getLSquareLoc() const { return LSquareLoc; }
1743  SourceLocation getRSquareLoc() const { return RSquareLoc; }
1745  return SourceRange(LSquareLoc, RSquareLoc);
1746  }
1747 };
1748 
1749 /// Described the kind of function definition (if any) provided for
1750 /// a function.
1752  Declaration,
1753  Definition,
1754  Defaulted,
1755  Deleted
1756 };
1757 
1758 enum class DeclaratorContext {
1759  File, // File scope declaration.
1760  Prototype, // Within a function prototype.
1761  ObjCResult, // An ObjC method result type.
1762  ObjCParameter, // An ObjC method parameter type.
1763  KNRTypeList, // K&R type definition list for formals.
1764  TypeName, // Abstract declarator for types.
1765  FunctionalCast, // Type in a C++ functional cast expression.
1766  Member, // Struct/Union field.
1767  Block, // Declaration within a block in a function.
1768  ForInit, // Declaration within first part of a for loop.
1769  SelectionInit, // Declaration within optional init stmt of if/switch.
1770  Condition, // Condition declaration in a C++ if/switch/while/for.
1771  TemplateParam, // Within a template parameter list.
1772  CXXNew, // C++ new-expression.
1773  CXXCatch, // C++ catch exception-declaration
1774  ObjCCatch, // Objective-C catch exception-declaration
1775  BlockLiteral, // Block literal declarator.
1776  LambdaExpr, // Lambda-expression declarator.
1777  LambdaExprParameter, // Lambda-expression parameter declarator.
1778  ConversionId, // C++ conversion-type-id.
1779  TrailingReturn, // C++11 trailing-type-specifier.
1780  TrailingReturnVar, // C++11 trailing-type-specifier for variable.
1781  TemplateArg, // Any template argument (in template argument list).
1782  TemplateTypeArg, // Template type argument (in default argument).
1783  AliasDecl, // C++11 alias-declaration.
1784  AliasTemplate, // C++11 alias-declaration template.
1785  RequiresExpr // C++2a requires-expression.
1786 };
1787 
1788 /// Information about one declarator, including the parsed type
1789 /// information and the identifier.
1790 ///
1791 /// When the declarator is fully formed, this is turned into the appropriate
1792 /// Decl object.
1793 ///
1794 /// Declarators come in two types: normal declarators and abstract declarators.
1795 /// Abstract declarators are used when parsing types, and don't have an
1796 /// identifier. Normal declarators do have ID's.
1797 ///
1798 /// Instances of this class should be a transient object that lives on the
1799 /// stack, not objects that are allocated in large quantities on the heap.
1800 class Declarator {
1801 
1802 private:
1803  const DeclSpec &DS;
1804  CXXScopeSpec SS;
1805  UnqualifiedId Name;
1806  SourceRange Range;
1807 
1808  /// Where we are parsing this declarator.
1809  DeclaratorContext Context;
1810 
1811  /// The C++17 structured binding, if any. This is an alternative to a Name.
1812  DecompositionDeclarator BindingGroup;
1813 
1814  /// DeclTypeInfo - This holds each type that the declarator includes as it is
1815  /// parsed. This is pushed from the identifier out, which means that element
1816  /// #0 will be the most closely bound to the identifier, and
1817  /// DeclTypeInfo.back() will be the least closely bound.
1818  SmallVector<DeclaratorChunk, 8> DeclTypeInfo;
1819 
1820  /// InvalidType - Set by Sema::GetTypeForDeclarator().
1821  unsigned InvalidType : 1;
1822 
1823  /// GroupingParens - Set by Parser::ParseParenDeclarator().
1824  unsigned GroupingParens : 1;
1825 
1826  /// FunctionDefinition - Is this Declarator for a function or member
1827  /// definition and, if so, what kind?
1828  ///
1829  /// Actually a FunctionDefinitionKind.
1830  unsigned FunctionDefinition : 2;
1831 
1832  /// Is this Declarator a redeclaration?
1833  unsigned Redeclaration : 1;
1834 
1835  /// true if the declaration is preceded by \c __extension__.
1836  unsigned Extension : 1;
1837 
1838  /// Indicates whether this is an Objective-C instance variable.
1839  unsigned ObjCIvar : 1;
1840 
1841  /// Indicates whether this is an Objective-C 'weak' property.
1842  unsigned ObjCWeakProperty : 1;
1843 
1844  /// Indicates whether the InlineParams / InlineBindings storage has been used.
1845  unsigned InlineStorageUsed : 1;
1846 
1847  /// Indicates whether this declarator has an initializer.
1848  unsigned HasInitializer : 1;
1849 
1850  /// Attrs - Attributes.
1851  ParsedAttributes Attrs;
1852 
1853  /// The asm label, if specified.
1854  Expr *AsmLabel;
1855 
1856  /// \brief The constraint-expression specified by the trailing
1857  /// requires-clause, or null if no such clause was specified.
1858  Expr *TrailingRequiresClause;
1859 
1860  /// If this declarator declares a template, its template parameter lists.
1861  ArrayRef<TemplateParameterList *> TemplateParameterLists;
1862 
1863  /// If the declarator declares an abbreviated function template, the innermost
1864  /// template parameter list containing the invented and explicit template
1865  /// parameters (if any).
1866  TemplateParameterList *InventedTemplateParameterList;
1867 
1868 #ifndef _MSC_VER
1869  union {
1870 #endif
1871  /// InlineParams - This is a local array used for the first function decl
1872  /// chunk to avoid going to the heap for the common case when we have one
1873  /// function chunk in the declarator.
1876 #ifndef _MSC_VER
1877  };
1878 #endif
1879 
1880  /// If this is the second or subsequent declarator in this declaration,
1881  /// the location of the comma before this declarator.
1882  SourceLocation CommaLoc;
1883 
1884  /// If provided, the source location of the ellipsis used to describe
1885  /// this declarator as a parameter pack.
1886  SourceLocation EllipsisLoc;
1887 
1888  friend struct DeclaratorChunk;
1889 
1890 public:
1892  : DS(ds), Range(ds.getSourceRange()), Context(C),
1893  InvalidType(DS.getTypeSpecType() == DeclSpec::TST_error),
1894  GroupingParens(false), FunctionDefinition(static_cast<unsigned>(
1896  Redeclaration(false), Extension(false), ObjCIvar(false),
1897  ObjCWeakProperty(false), InlineStorageUsed(false),
1898  HasInitializer(false), Attrs(ds.getAttributePool().getFactory()),
1899  AsmLabel(nullptr), TrailingRequiresClause(nullptr),
1900  InventedTemplateParameterList(nullptr) {}
1901 
1903  clear();
1904  }
1905  /// getDeclSpec - Return the declaration-specifier that this declarator was
1906  /// declared with.
1907  const DeclSpec &getDeclSpec() const { return DS; }
1908 
1909  /// getMutableDeclSpec - Return a non-const version of the DeclSpec. This
1910  /// should be used with extreme care: declspecs can often be shared between
1911  /// multiple declarators, so mutating the DeclSpec affects all of the
1912  /// Declarators. This should only be done when the declspec is known to not
1913  /// be shared or when in error recovery etc.
1914  DeclSpec &getMutableDeclSpec() { return const_cast<DeclSpec &>(DS); }
1915 
1917  return Attrs.getPool();
1918  }
1919 
1920  /// getCXXScopeSpec - Return the C++ scope specifier (global scope or
1921  /// nested-name-specifier) that is part of the declarator-id.
1922  const CXXScopeSpec &getCXXScopeSpec() const { return SS; }
1923  CXXScopeSpec &getCXXScopeSpec() { return SS; }
1924 
1925  /// Retrieve the name specified by this declarator.
1926  UnqualifiedId &getName() { return Name; }
1927 
1929  return BindingGroup;
1930  }
1931 
1932  DeclaratorContext getContext() const { return Context; }
1933 
1934  bool isPrototypeContext() const {
1935  return (Context == DeclaratorContext::Prototype ||
1936  Context == DeclaratorContext::ObjCParameter ||
1937  Context == DeclaratorContext::ObjCResult ||
1939  }
1940 
1941  /// Get the source range that spans this declarator.
1942  SourceRange getSourceRange() const LLVM_READONLY { return Range; }
1943  SourceLocation getBeginLoc() const LLVM_READONLY { return Range.getBegin(); }
1944  SourceLocation getEndLoc() const LLVM_READONLY { return Range.getEnd(); }
1945 
1946  void SetSourceRange(SourceRange R) { Range = R; }
1947  /// SetRangeBegin - Set the start of the source range to Loc, unless it's
1948  /// invalid.
1950  if (!Loc.isInvalid())
1951  Range.setBegin(Loc);
1952  }
1953  /// SetRangeEnd - Set the end of the source range to Loc, unless it's invalid.
1955  if (!Loc.isInvalid())
1956  Range.setEnd(Loc);
1957  }
1958  /// ExtendWithDeclSpec - Extend the declarator source range to include the
1959  /// given declspec, unless its location is invalid. Adopts the range start if
1960  /// the current range start is invalid.
1961  void ExtendWithDeclSpec(const DeclSpec &DS) {
1962  SourceRange SR = DS.getSourceRange();
1963  if (Range.getBegin().isInvalid())
1964  Range.setBegin(SR.getBegin());
1965  if (!SR.getEnd().isInvalid())
1966  Range.setEnd(SR.getEnd());
1967  }
1968 
1969  /// Reset the contents of this Declarator.
1970  void clear() {
1971  SS.clear();
1972  Name.clear();
1973  Range = DS.getSourceRange();
1974  BindingGroup.clear();
1975 
1976  for (unsigned i = 0, e = DeclTypeInfo.size(); i != e; ++i)
1977  DeclTypeInfo[i].destroy();
1978  DeclTypeInfo.clear();
1979  Attrs.clear();
1980  AsmLabel = nullptr;
1981  InlineStorageUsed = false;
1982  HasInitializer = false;
1983  ObjCIvar = false;
1984  ObjCWeakProperty = false;
1985  CommaLoc = SourceLocation();
1986  EllipsisLoc = SourceLocation();
1987  }
1988 
1989  /// mayOmitIdentifier - Return true if the identifier is either optional or
1990  /// not allowed. This is true for typenames, prototypes, and template
1991  /// parameter lists.
1992  bool mayOmitIdentifier() const {
1993  switch (Context) {
2001  return false;
2002 
2023  return true;
2024  }
2025  llvm_unreachable("unknown context kind!");
2026  }
2027 
2028  /// mayHaveIdentifier - Return true if the identifier is either optional or
2029  /// required. This is true for normal declarators and prototypes, but not
2030  /// typenames.
2031  bool mayHaveIdentifier() const {
2032  switch (Context) {
2046  return true;
2047 
2062  return false;
2063  }
2064  llvm_unreachable("unknown context kind!");
2065  }
2066 
2067  /// Return true if the context permits a C++17 decomposition declarator.
2069  switch (Context) {
2071  // FIXME: It's not clear that the proposal meant to allow file-scope
2072  // structured bindings, but it does.
2077  return true;
2078 
2083  // Maybe one day...
2084  return false;
2085 
2086  // These contexts don't allow any kind of non-abstract declarator.
2105  return false;
2106  }
2107  llvm_unreachable("unknown context kind!");
2108  }
2109 
2110  /// mayBeFollowedByCXXDirectInit - Return true if the declarator can be
2111  /// followed by a C++ direct initializer, e.g. "int x(1);".
2113  if (hasGroupingParens()) return false;
2114 
2115  if (getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_typedef)
2116  return false;
2117 
2118  if (getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_extern &&
2119  Context != DeclaratorContext::File)
2120  return false;
2121 
2122  // Special names can't have direct initializers.
2123  if (Name.getKind() != UnqualifiedIdKind::IK_Identifier)
2124  return false;
2125 
2126  switch (Context) {
2132  return true;
2133 
2135  // This may not be followed by a direct initializer, but it can't be a
2136  // function declaration either, and we'd prefer to perform a tentative
2137  // parse in order to produce the right diagnostic.
2138  return true;
2139 
2150  case DeclaratorContext::FunctionalCast: // FIXME
2161  return false;
2162  }
2163  llvm_unreachable("unknown context kind!");
2164  }
2165 
2166  /// isPastIdentifier - Return true if we have parsed beyond the point where
2167  /// the name would appear. (This may happen even if we haven't actually parsed
2168  /// a name, perhaps because this context doesn't require one.)
2169  bool isPastIdentifier() const { return Name.isValid(); }
2170 
2171  /// hasName - Whether this declarator has a name, which might be an
2172  /// identifier (accessible via getIdentifier()) or some kind of
2173  /// special C++ name (constructor, destructor, etc.), or a structured
2174  /// binding (which is not exactly a name, but occupies the same position).
2175  bool hasName() const {
2176  return Name.getKind() != UnqualifiedIdKind::IK_Identifier ||
2177  Name.Identifier || isDecompositionDeclarator();
2178  }
2179 
2180  /// Return whether this declarator is a decomposition declarator.
2182  return BindingGroup.isSet();
2183  }
2184 
2186  if (Name.getKind() == UnqualifiedIdKind::IK_Identifier)
2187  return Name.Identifier;
2188 
2189  return nullptr;
2190  }
2191  SourceLocation getIdentifierLoc() const { return Name.StartLocation; }
2192 
2193  /// Set the name of this declarator to be the given identifier.
2195  Name.setIdentifier(Id, IdLoc);
2196  }
2197 
2198  /// Set the decomposition bindings for this declarator.
2199  void
2202  SourceLocation RSquareLoc);
2203 
2204  /// AddTypeInfo - Add a chunk to this declarator. Also extend the range to
2205  /// EndLoc, which should be the last token of the chunk.
2206  /// This function takes attrs by R-Value reference because it takes ownership
2207  /// of those attributes from the parameter.
2209  SourceLocation EndLoc) {
2210  DeclTypeInfo.push_back(TI);
2211  DeclTypeInfo.back().getAttrs().addAll(attrs.begin(), attrs.end());
2212  getAttributePool().takeAllFrom(attrs.getPool());
2213 
2214  if (!EndLoc.isInvalid())
2215  SetRangeEnd(EndLoc);
2216  }
2217 
2218  /// AddTypeInfo - Add a chunk to this declarator. Also extend the range to
2219  /// EndLoc, which should be the last token of the chunk.
2220  void AddTypeInfo(const DeclaratorChunk &TI, SourceLocation EndLoc) {
2221  DeclTypeInfo.push_back(TI);
2222 
2223  if (!EndLoc.isInvalid())
2224  SetRangeEnd(EndLoc);
2225  }
2226 
2227  /// Add a new innermost chunk to this declarator.
2229  DeclTypeInfo.insert(DeclTypeInfo.begin(), TI);
2230  }
2231 
2232  /// Return the number of types applied to this declarator.
2233  unsigned getNumTypeObjects() const { return DeclTypeInfo.size(); }
2234 
2235  /// Return the specified TypeInfo from this declarator. TypeInfo #0 is
2236  /// closest to the identifier.
2237  const DeclaratorChunk &getTypeObject(unsigned i) const {
2238  assert(i < DeclTypeInfo.size() && "Invalid type chunk");
2239  return DeclTypeInfo[i];
2240  }
2242  assert(i < DeclTypeInfo.size() && "Invalid type chunk");
2243  return DeclTypeInfo[i];
2244  }
2245 
2247  typedef llvm::iterator_range<type_object_iterator> type_object_range;
2248 
2249  /// Returns the range of type objects, from the identifier outwards.
2251  return type_object_range(DeclTypeInfo.begin(), DeclTypeInfo.end());
2252  }
2253 
2255  assert(!DeclTypeInfo.empty() && "No type chunks to drop.");
2256  DeclTypeInfo.front().destroy();
2257  DeclTypeInfo.erase(DeclTypeInfo.begin());
2258  }
2259 
2260  /// Return the innermost (closest to the declarator) chunk of this
2261  /// declarator that is not a parens chunk, or null if there are no
2262  /// non-parens chunks.
2264  for (unsigned i = 0, i_end = DeclTypeInfo.size(); i < i_end; ++i) {
2265  if (!DeclTypeInfo[i].isParen())
2266  return &DeclTypeInfo[i];
2267  }
2268  return nullptr;
2269  }
2270 
2271  /// Return the outermost (furthest from the declarator) chunk of
2272  /// this declarator that is not a parens chunk, or null if there are
2273  /// no non-parens chunks.
2275  for (unsigned i = DeclTypeInfo.size(), i_end = 0; i != i_end; --i) {
2276  if (!DeclTypeInfo[i-1].isParen())
2277  return &DeclTypeInfo[i-1];
2278  }
2279  return nullptr;
2280  }
2281 
2282  /// isArrayOfUnknownBound - This method returns true if the declarator
2283  /// is a declarator for an array of unknown bound (looking through
2284  /// parentheses).
2285  bool isArrayOfUnknownBound() const {
2286  const DeclaratorChunk *chunk = getInnermostNonParenChunk();
2287  return (chunk && chunk->Kind == DeclaratorChunk::Array &&
2288  !chunk->Arr.NumElts);
2289  }
2290 
2291  /// isFunctionDeclarator - This method returns true if the declarator
2292  /// is a function declarator (looking through parentheses).
2293  /// If true is returned, then the reference type parameter idx is
2294  /// assigned with the index of the declaration chunk.
2295  bool isFunctionDeclarator(unsigned& idx) const {
2296  for (unsigned i = 0, i_end = DeclTypeInfo.size(); i < i_end; ++i) {
2297  switch (DeclTypeInfo[i].Kind) {
2299  idx = i;
2300  return true;
2302  continue;
2308  case DeclaratorChunk::Pipe:
2309  return false;
2310  }
2311  llvm_unreachable("Invalid type chunk");
2312  }
2313  return false;
2314  }
2315 
2316  /// isFunctionDeclarator - Once this declarator is fully parsed and formed,
2317  /// this method returns true if the identifier is a function declarator
2318  /// (looking through parentheses).
2319  bool isFunctionDeclarator() const {
2320  unsigned index;
2321  return isFunctionDeclarator(index);
2322  }
2323 
2324  /// getFunctionTypeInfo - Retrieves the function type info object
2325  /// (looking through parentheses).
2327  assert(isFunctionDeclarator() && "Not a function declarator!");
2328  unsigned index = 0;
2329  isFunctionDeclarator(index);
2330  return DeclTypeInfo[index].Fun;
2331  }
2332 
2333  /// getFunctionTypeInfo - Retrieves the function type info object
2334  /// (looking through parentheses).
2336  return const_cast<Declarator*>(this)->getFunctionTypeInfo();
2337  }
2338 
2339  /// Determine whether the declaration that will be produced from
2340  /// this declaration will be a function.
2341  ///
2342  /// A declaration can declare a function even if the declarator itself
2343  /// isn't a function declarator, if the type specifier refers to a function
2344  /// type. This routine checks for both cases.
2345  bool isDeclarationOfFunction() const;
2346 
2347  /// Return true if this declaration appears in a context where a
2348  /// function declarator would be a function declaration.
2350  if (getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_typedef)
2351  return false;
2352 
2353  switch (Context) {
2359  return true;
2360 
2383  return false;
2384  }
2385  llvm_unreachable("unknown context kind!");
2386  }
2387 
2388  /// Determine whether this declaration appears in a context where an
2389  /// expression could appear.
2390  bool isExpressionContext() const {
2391  switch (Context) {
2395 
2396  // FIXME: sizeof(...) permits an expression.
2398 
2417  return false;
2418 
2424  return true;
2425  }
2426 
2427  llvm_unreachable("unknown context kind!");
2428  }
2429 
2430  /// Return true if a function declarator at this position would be a
2431  /// function declaration.
2434  return false;
2435 
2436  for (unsigned I = 0, N = getNumTypeObjects(); I != N; ++I)
2438  return false;
2439 
2440  return true;
2441  }
2442 
2443  /// Determine whether a trailing return type was written (at any
2444  /// level) within this declarator.
2445  bool hasTrailingReturnType() const {
2446  for (const auto &Chunk : type_objects())
2447  if (Chunk.Kind == DeclaratorChunk::Function &&
2448  Chunk.Fun.hasTrailingReturnType())
2449  return true;
2450  return false;
2451  }
2452  /// Get the trailing return type appearing (at any level) within this
2453  /// declarator.
2455  for (const auto &Chunk : type_objects())
2456  if (Chunk.Kind == DeclaratorChunk::Function &&
2457  Chunk.Fun.hasTrailingReturnType())
2458  return Chunk.Fun.getTrailingReturnType();
2459  return ParsedType();
2460  }
2461 
2462  /// \brief Sets a trailing requires clause for this declarator.
2464  TrailingRequiresClause = TRC;
2465 
2466  SetRangeEnd(TRC->getEndLoc());
2467  }
2468 
2469  /// \brief Sets a trailing requires clause for this declarator.
2471  return TrailingRequiresClause;
2472  }
2473 
2474  /// \brief Determine whether a trailing requires clause was written in this
2475  /// declarator.
2477  return TrailingRequiresClause != nullptr;
2478  }
2479 
2480  /// Sets the template parameter lists that preceded the declarator.
2482  TemplateParameterLists = TPLs;
2483  }
2484 
2485  /// The template parameter lists that preceded the declarator.
2487  return TemplateParameterLists;
2488  }
2489 
2490  /// Sets the template parameter list generated from the explicit template
2491  /// parameters along with any invented template parameters from
2492  /// placeholder-typed parameters.
2494  InventedTemplateParameterList = Invented;
2495  }
2496 
2497  /// The template parameter list generated from the explicit template
2498  /// parameters along with any invented template parameters from
2499  /// placeholder-typed parameters, if there were any such parameters.
2501  return InventedTemplateParameterList;
2502  }
2503 
2504  /// takeAttributes - Takes attributes from the given parsed-attributes
2505  /// set and add them to this declarator.
2506  ///
2507  /// These examples both add 3 attributes to "var":
2508  /// short int var __attribute__((aligned(16),common,deprecated));
2509  /// short int x, __attribute__((aligned(16)) var
2510  /// __attribute__((common,deprecated));
2511  ///
2512  /// Also extends the range of the declarator.
2514  Attrs.takeAllFrom(attrs);
2515 
2516  if (!lastLoc.isInvalid())
2517  SetRangeEnd(lastLoc);
2518  }
2519 
2520  const ParsedAttributes &getAttributes() const { return Attrs; }
2521  ParsedAttributes &getAttributes() { return Attrs; }
2522 
2523  /// hasAttributes - do we contain any attributes?
2524  bool hasAttributes() const {
2525  if (!getAttributes().empty() || getDeclSpec().hasAttributes())
2526  return true;
2527  for (unsigned i = 0, e = getNumTypeObjects(); i != e; ++i)
2528  if (!getTypeObject(i).getAttrs().empty())
2529  return true;
2530  return false;
2531  }
2532 
2533  /// Return a source range list of C++11 attributes associated
2534  /// with the declarator.
2536  for (const ParsedAttr &AL : Attrs)
2537  if (AL.isCXX11Attribute())
2538  Ranges.push_back(AL.getRange());
2539  }
2540 
2541  void setAsmLabel(Expr *E) { AsmLabel = E; }
2542  Expr *getAsmLabel() const { return AsmLabel; }
2543 
2544  void setExtension(bool Val = true) { Extension = Val; }
2545  bool getExtension() const { return Extension; }
2546 
2547  void setObjCIvar(bool Val = true) { ObjCIvar = Val; }
2548  bool isObjCIvar() const { return ObjCIvar; }
2549 
2550  void setObjCWeakProperty(bool Val = true) { ObjCWeakProperty = Val; }
2551  bool isObjCWeakProperty() const { return ObjCWeakProperty; }
2552 
2553  void setInvalidType(bool Val = true) { InvalidType = Val; }
2554  bool isInvalidType() const {
2555  return InvalidType || DS.getTypeSpecType() == DeclSpec::TST_error;
2556  }
2557 
2558  void setGroupingParens(bool flag) { GroupingParens = flag; }
2559  bool hasGroupingParens() const { return GroupingParens; }
2560 
2561  bool isFirstDeclarator() const { return !CommaLoc.isValid(); }
2562  SourceLocation getCommaLoc() const { return CommaLoc; }
2563  void setCommaLoc(SourceLocation CL) { CommaLoc = CL; }
2564 
2565  bool hasEllipsis() const { return EllipsisLoc.isValid(); }
2566  SourceLocation getEllipsisLoc() const { return EllipsisLoc; }
2567  void setEllipsisLoc(SourceLocation EL) { EllipsisLoc = EL; }
2568 
2570  FunctionDefinition = static_cast<unsigned>(Val);
2571  }
2572 
2573  bool isFunctionDefinition() const {
2575  }
2576 
2578  return (FunctionDefinitionKind)FunctionDefinition;
2579  }
2580 
2581  void setHasInitializer(bool Val = true) { HasInitializer = Val; }
2582  bool hasInitializer() const { return HasInitializer; }
2583 
2584  /// Returns true if this declares a real member and not a friend.
2586  return getContext() == DeclaratorContext::Member &&
2588  }
2589 
2590  /// Returns true if this declares a static member. This cannot be called on a
2591  /// declarator outside of a MemberContext because we won't know until
2592  /// redeclaration time if the decl is static.
2593  bool isStaticMember();
2594 
2595  /// Returns true if this declares a constructor or a destructor.
2596  bool isCtorOrDtor();
2597 
2598  void setRedeclaration(bool Val) { Redeclaration = Val; }
2599  bool isRedeclaration() const { return Redeclaration; }
2600 };
2601 
2602 /// This little struct is used to capture information about
2603 /// structure field declarators, which is basically just a bitfield size.
2607  explicit FieldDeclarator(const DeclSpec &DS)
2608  : D(DS, DeclaratorContext::Member), BitfieldSize(nullptr) {}
2609 };
2610 
2611 /// Represents a C++11 virt-specifier-seq.
2613 public:
2614  enum Specifier {
2615  VS_None = 0,
2619  // Represents the __final keyword, which is legal for gcc in pre-C++11 mode.
2621  };
2622 
2623  VirtSpecifiers() : Specifiers(0), LastSpecifier(VS_None) { }
2624 
2625  bool SetSpecifier(Specifier VS, SourceLocation Loc,
2626  const char *&PrevSpec);
2627 
2628  bool isUnset() const { return Specifiers == 0; }
2629 
2630  bool isOverrideSpecified() const { return Specifiers & VS_Override; }
2631  SourceLocation getOverrideLoc() const { return VS_overrideLoc; }
2632 
2633  bool isFinalSpecified() const { return Specifiers & (VS_Final | VS_Sealed | VS_GNU_Final); }
2634  bool isFinalSpelledSealed() const { return Specifiers & VS_Sealed; }
2635  SourceLocation getFinalLoc() const { return VS_finalLoc; }
2636 
2637  void clear() { Specifiers = 0; }
2638 
2639  static const char *getSpecifierName(Specifier VS);
2640 
2641  SourceLocation getFirstLocation() const { return FirstLocation; }
2642  SourceLocation getLastLocation() const { return LastLocation; }
2643  Specifier getLastSpecifier() const { return LastSpecifier; }
2644 
2645 private:
2646  unsigned Specifiers;
2647  Specifier LastSpecifier;
2648 
2649  SourceLocation VS_overrideLoc, VS_finalLoc;
2650  SourceLocation FirstLocation;
2651  SourceLocation LastLocation;
2652 };
2653 
2655  NoInit, //!< [a]
2656  CopyInit, //!< [a = b], [a = {b}]
2657  DirectInit, //!< [a(b)]
2658  ListInit //!< [a{b}]
2659 };
2660 
2661 /// Represents a complete lambda introducer.
2663  /// An individual capture in a lambda introducer.
2664  struct LambdaCapture {
2673 
2682  };
2683 
2688 
2690  : Default(LCD_None) {}
2691 
2692  /// Append a capture in a lambda introducer.
2694  SourceLocation Loc,
2695  IdentifierInfo* Id,
2696  SourceLocation EllipsisLoc,
2697  LambdaCaptureInitKind InitKind,
2698  ExprResult Init,
2699  ParsedType InitCaptureType,
2700  SourceRange ExplicitRange) {
2701  Captures.push_back(LambdaCapture(Kind, Loc, Id, EllipsisLoc, InitKind, Init,
2702  InitCaptureType, ExplicitRange));
2703  }
2704 };
2705 
2707  /// The number of parameters in the template parameter list that were
2708  /// explicitly specified by the user, as opposed to being invented by use
2709  /// of an auto parameter.
2711 
2712  /// If this is a generic lambda or abbreviated function template, use this
2713  /// as the depth of each 'auto' parameter, during initial AST construction.
2715 
2716  /// Store the list of the template parameters for a generic lambda or an
2717  /// abbreviated function template.
2718  /// If this is a generic lambda or abbreviated function template, this holds
2719  /// the explicit template parameters followed by the auto parameters
2720  /// converted into TemplateTypeParmDecls.
2721  /// It can be used to construct the generic lambda or abbreviated template's
2722  /// template parameter list during initial AST construction.
2724 };
2725 
2726 } // end namespace clang
2727 
2728 #endif // LLVM_CLANG_SEMA_DECLSPEC_H
ParsedType getTrailingReturnType() const
Get the trailing-return-type for this function declarator.
Definition: DeclSpec.h:1500
void ClearFunctionSpecs()
Definition: DeclSpec.h:594
AttributePool & getAttributePool() const
Definition: DeclSpec.h:1916
static DeclaratorChunk getMemberPointer(const CXXScopeSpec &SS, unsigned TypeQuals, SourceLocation StarLoc, SourceLocation EndLoc)
Definition: DeclSpec.h:1668
void setConstructorName(ParsedType ClassType, SourceLocation ClassNameLoc, SourceLocation EndLoc)
Specify that this unqualified-id was parsed as a constructor name.
Definition: DeclSpec.h:1098
unsigned UnalignedQualLoc
The location of the __unaligned-qualifier, if any.
Definition: DeclSpec.h:1199
DeclaratorChunk::FunctionTypeInfo & getFunctionTypeInfo()
getFunctionTypeInfo - Retrieves the function type info object (looking through parentheses).
Definition: DeclSpec.h:2326
unsigned MutableLoc
The location of the 'mutable' qualifer in a lambda-declarator, if any.
Definition: DeclSpec.h:1318
unsigned RefQualifierIsLValueRef
Whether the ref-qualifier (if any) is an lvalue reference.
Definition: DeclSpec.h:1281
StringRef Identifier
Definition: Format.cpp:2078
no exception specification
void setKind(UnqualifiedIdKind kind)
Definition: DeclSpec.h:1033
SourceLocation getLastQualifierNameLoc() const
Retrieve the location of the name in the last qualifier in this nested name specifier.
Definition: DeclSpec.cpp:144
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 '__super' nested-name-specifier.
Definition: DeclSpec.cpp:113
void clear()
Reset the contents of this Declarator.
Definition: DeclSpec.h:1970
bool SetTypeSpecType(TST T, SourceLocation Loc, const char *&PrevSpec, unsigned &DiagID, TypeResult Rep, const PrintingPolicy &Policy)
Definition: DeclSpec.h:668
SourceRange getSourceRange() const LLVM_READONLY
Return the source range that covers this unqualified-id.
Definition: DeclSpec.h:1150
ObjCDeclQualifier getObjCDeclQualifier() const
Definition: DeclSpec.h:846
SourceLocation StartLocation
The location of the first token that describes this unqualified-id, which will be the location of the...
Definition: DeclSpec.h:1008
const DeclaratorChunk & getTypeObject(unsigned i) const
Return the specified TypeInfo from this declarator.
Definition: DeclSpec.h:2237
SizeType size() const
Definition: ParsedAttr.h:824
bool SetTypeQual(TQ T, SourceLocation Loc)
Definition: DeclSpec.cpp:969
static const TST TST_wchar
Definition: DeclSpec.h:263
ThreadStorageClassSpecifier TSCS
Definition: DeclSpec.h:246
IdentifierInfo * Identifier
When Kind == IK_Identifier, the parsed identifier, or when Kind == IK_UserLiteralId,...
Definition: DeclSpec.h:978
NullabilityKind
Describes the nullability of a particular type.
Definition: Specifiers.h:303
UnionParsedType TypeRep
Definition: DeclSpec.h:360
bool isEmpty() const
No scope specifier.
Definition: DeclSpec.h:190
void setEndLoc(SourceLocation Loc)
Definition: DeclSpec.h:72
static const TST TST_typeofExpr
Definition: DeclSpec.h:289
static const TST TST_char16
Definition: DeclSpec.h:265
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:89
unsigned ExceptionSpecLocBeg
The beginning location of the exception specification, if any.
Definition: DeclSpec.h:1321
Captures information about "declaration specifiers" specific to Objective-C.
Definition: DeclSpec.h:822
LambdaCaptureDefault
The default, if any, capture method for a lambda expression.
Definition: Lambda.h:22
unsigned StarLoc
Location of the '*' token.
Definition: DeclSpec.h:1525
unsigned EllipsisLoc
When isVariadic is true, the location of the ellipsis in the source.
Definition: DeclSpec.h:1297
bool isOverrideSpecified() const
Definition: DeclSpec.h:2630
SourceLocation getVolatileQualifierLoc() const
Retrieve the location of the 'volatile' qualifier.
Definition: DeclSpec.h:1447
A constructor named via a template-id.
SourceLocation getLParenLoc() const
Definition: DeclSpec.h:1411
Declarator(const DeclSpec &ds, DeclaratorContext C)
Definition: DeclSpec.h:1891
bool hasTrailingReturnType() const
Determine whether a trailing return type was written (at any level) within this declarator.
Definition: DeclSpec.h:2445
TypeSpecifierType TST
Definition: DeclSpec.h:259
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: DeclSpec.h:1943
One instance of this struct is used for each type in a declarator that is parsed.
Definition: DeclSpec.h:1164
Represent a C++ namespace.
Definition: Decl.h:512
SourceLocation EndLoc
EndLoc - If valid, the place where this chunck ends.
Definition: DeclSpec.h:1172
bool isFunctionDeclarator(unsigned &idx) const
isFunctionDeclarator - This method returns true if the declarator is a function declarator (looking t...
Definition: DeclSpec.h:2295
unsigned NumExceptionsOrDecls
NumExceptionsOrDecls - This is the number of types in the dynamic-exception-decl, if the function has...
Definition: DeclSpec.h:1309
NamedDecl ** DeclsInPrototype
Pointer to a new[]'d array of declarations that need to be available for lookup inside the function b...
Definition: DeclSpec.h:1354
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:540
SourceLocation getEndLoc() const LLVM_READONLY
Definition: DeclSpec.h:1944
LambdaCaptureInitKind InitKind
Definition: DeclSpec.h:2669
bool isTypeSpecSat() const
Definition: DeclSpec.h:483
std::unique_ptr< CachedTokens > DefaultArgTokens
DefaultArgTokens - When the parameter's default argument cannot be parsed immediately (because it occ...
Definition: DeclSpec.h:1250
static const char * getSpecifierName(Specifier VS)
Definition: DeclSpec.cpp:1480
SmallVector< NamedDecl *, 4 > TemplateParams
Store the list of the template parameters for a generic lambda or an abbreviated function template.
Definition: DeclSpec.h:2723
Store information needed for an explicit specifier.
Definition: DeclCXX.h:1782
bool SetTypeAltiVecBool(bool isAltiVecBool, SourceLocation Loc, const char *&PrevSpec, unsigned &DiagID, const PrintingPolicy &Policy)
Definition: DeclSpec.cpp:907
bool hasExplicitSpecifier() const
Definition: DeclSpec.h:581
An overloaded operator name, e.g., operator+.
TSCS getThreadStorageClassSpec() const
Definition: DeclSpec.h:441
unsigned location_size() const
Retrieve the size of the data associated with source-location information.
Definition: DeclSpec.h:222
void SetIdentifier(IdentifierInfo *Id, SourceLocation IdLoc)
Set the name of this declarator to be the given identifier.
Definition: DeclSpec.h:2194
SourceLocation getEndLoc() const
Definition: DeclSpec.h:74
unsigned RefQualifierLoc
The location of the ref-qualifier, if any.
Definition: DeclSpec.h:1314
SourceLocation getEllipsisLoc() const
Definition: DeclSpec.h:1415
const ParsedAttributes & getAttributes() const
Definition: DeclSpec.h:2520
SourceLocation getOverrideLoc() const
Definition: DeclSpec.h:2631
unsigned RestrictQualLoc
The location of the restrict-qualifier, if any.
Definition: DeclSpec.h:1193
bool isKNRPrototype() const
isKNRPrototype - Return true if this is a K&R style identifier list, like "void foo(a,...
Definition: DeclSpec.h:1409
void Adopt(NestedNameSpecifierLoc Other)
Adopt an existing nested-name-specifier (with source-range information).
Definition: DeclSpec.cpp:131
static const TSCS TSCS_unspecified
Definition: DeclSpec.h:247
bool isFunctionDeclarationContext() const
Return true if this declaration appears in a context where a function declarator would be a function ...
Definition: DeclSpec.h:2349
RangeSelector range(RangeSelector Begin, RangeSelector End)
DEPRECATED. Use enclose.
Definition: RangeSelector.h:41
void setObjCQualifiers(ObjCDeclSpec *quals)
Definition: DeclSpec.h:812
unsigned isStar
True if this dimension was [*]. In this case, NumElts is null.
Definition: DeclSpec.h:1223
static const TST TST_underlyingType
Definition: DeclSpec.h:292
Information about one declarator, including the parsed type information and the identifier.
Definition: DeclSpec.h:1800
void setTypeofParensRange(SourceRange range)
Definition: DeclSpec.h:524
ObjCDeclSpec * getObjCQualifiers() const
Definition: DeclSpec.h:811
unsigned getParsedSpecifiers() const
Return a bitmask of which flavors of specifiers this DeclSpec includes.
Definition: DeclSpec.cpp:450
TypeSpecifierType
Specifies the kind of type.
Definition: Specifiers.h:43
TemplateIdAnnotation * TemplateIdRep
Definition: DeclSpec.h:363
Indicates that the nullability of the type was spelled with a property attribute rather than a type q...
void setHasInitializer(bool Val=true)
Definition: DeclSpec.h:2581
static const TST TST_interface
Definition: DeclSpec.h:285
SourceLocation getFinalLoc() const
Definition: DeclSpec.h:2635
static const TST TST_char
Definition: DeclSpec.h:262
Stores a list of template parameters for a TemplateDecl and its derived classes.
Definition: DeclTemplate.h:69
bool hasTypeSpecifier() const
Return true if any type-specifier has been found.
Definition: DeclSpec.h:621
Describes how types, statements, expressions, and declarations should be printed.
Definition: PrettyPrinter.h:49
bool hasMethodTypeQualifiers() const
Determine whether this method has qualifiers.
Definition: DeclSpec.h:1472
unsigned getNumExceptions() const
Get the number of dynamic exception specifications.
Definition: DeclSpec.h:1483
const IdentifierInfo * getSetterName() const
Definition: DeclSpec.h:897
bool SetConstexprSpec(ConstexprSpecKind ConstexprKind, SourceLocation Loc, const char *&PrevSpec, unsigned &DiagID)
Definition: DeclSpec.cpp:1089
void setTrailingRequiresClause(Expr *TRC)
Sets a trailing requires clause for this declarator.
Definition: DeclSpec.h:2463
bool mayOmitIdentifier() const
mayOmitIdentifier - Return true if the identifier is either optional or not allowed.
Definition: DeclSpec.h:1992
Information about a template-id annotation token.
IdentifierInfo * getGetterName()
Definition: DeclSpec.h:890
SourceRange getTypeSpecWidthRange() const
Definition: DeclSpec.h:511
static const TST TST_unknown_anytype
Definition: DeclSpec.h:295
bool isUnset() const
Definition: DeclSpec.h:2628
Base wrapper for a particular "section" of type source info.
Definition: TypeLoc.h:58
SourceLocation getFriendSpecLoc() const
Definition: DeclSpec.h:749
bool isRedeclaration() const
Definition: DeclSpec.h:2599
TemplateIdAnnotation * TemplateId
When Kind == IK_TemplateId or IK_ConstructorTemplateId, the template-id annotation that contains the ...
Definition: DeclSpec.h:1002
C11 _Thread_local.
Definition: Specifiers.h:219
Expr * NoexceptExpr
Pointer to the expression in the noexcept-specifier of this function, if it has one.
Definition: DeclSpec.h:1345
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:42
SmallVectorImpl< DeclaratorChunk >::const_iterator type_object_iterator
Definition: DeclSpec.h:2246
SourceLocation getSetterNameLoc() const
Definition: DeclSpec.h:899
SourceLocation getExceptionSpecLocBeg() const
Definition: DeclSpec.h:1423
C++2a [expr.prim.req]: A requires-expression provides a concise way to express requirements on templa...
Definition: ExprConcepts.h:475
const WrittenBuiltinSpecs & getWrittenBuiltinSpecs() const
Definition: DeclSpec.h:807
static const TST TST_decimal32
Definition: DeclSpec.h:279
UnionParsedType ConversionFunctionId
When Kind == IK_ConversionFunctionId, the type that the conversion function names.
Definition: DeclSpec.h:986
SourceLocation getEndLoc() const LLVM_READONLY
Definition: DeclSpec.h:1154
static const TST TST_char8
Definition: DeclSpec.h:264
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:185
void DropFirstTypeObject()
Definition: DeclSpec.h:2254
A C++ nested-name-specifier augmented with source location information.
SourceLocation getTypeSpecTypeLoc() const
Definition: DeclSpec.h:514
void setConversionFunctionId(SourceLocation OperatorLoc, ParsedType Ty, SourceLocation EndLoc)
Specify that this unqualified-id was parsed as a conversion-function-id.
Definition: DeclSpec.h:1066
TypeSpecifierSign
Specifies the signedness of a type, e.g., signed or unsigned.
Definition: Specifiers.h:38
static SourceLocation getFromRawEncoding(unsigned Encoding)
Turn a raw encoding of a SourceLocation object into a real SourceLocation.
DeclSpec(AttributeFactory &attrFactory)
Definition: DeclSpec.h:421
static const TST TST_class
Definition: DeclSpec.h:286
LambdaCaptureKind
The different capture forms in a lambda introducer.
Definition: Lambda.h:33
UnionParsedTemplateTy TemplateName
When Kind == IK_DeductionGuideName, the parsed template-name.
Definition: DeclSpec.h:997
bool setFunctionSpecExplicit(SourceLocation Loc, const char *&PrevSpec, unsigned &DiagID, ExplicitSpecifier ExplicitSpec, SourceLocation CloseParenLoc)
Definition: DeclSpec.cpp:1025
Defines the ExceptionSpecificationType enumeration and various utility functions.
bool hasInitializer() const
Definition: DeclSpec.h:2582
OverloadedOperatorKind Operator
The kind of overloaded operator.
Definition: DeclSpec.h:961
Definition: Format.h:2835
bool isParen() const
Definition: DeclSpec.h:1692
bool isFunctionDefinition() const
Definition: DeclSpec.h:2573
static const TST TST_double
Definition: DeclSpec.h:273
struct OFI OperatorFunctionId
When Kind == IK_OperatorFunctionId, the overloaded operator that we parsed.
Definition: DeclSpec.h:982
bool hasAutoTypeSpec() const
Definition: DeclSpec.h:526
bool setFunctionSpecVirtual(SourceLocation Loc, const char *&PrevSpec, unsigned &DiagID)
Definition: DeclSpec.cpp:1010
void clearObjCDeclQualifier(ObjCDeclQualifier DQVal)
Definition: DeclSpec.h:852
static const TST TST_error
Definition: DeclSpec.h:300
static const TST TST_enum
Definition: DeclSpec.h:282
ExplicitSpecifier getExplicitSpecifier() const
Definition: DeclSpec.h:574
OpaquePtr< QualType > ParsedType
An opaque type for threading parsed type information through the parser.
Definition: Ownership.h:243
bool hasTagDefinition() const
Definition: DeclSpec.cpp:441
void ClearStorageClassSpecs()
Definition: DeclSpec.h:454
static DeclaratorChunk getPointer(unsigned TypeQuals, SourceLocation Loc, SourceLocation ConstQualLoc, SourceLocation VolatileQualLoc, SourceLocation RestrictQualLoc, SourceLocation AtomicQualLoc, SourceLocation UnalignedQualLoc)
Return a DeclaratorChunk for a pointer.
Definition: DeclSpec.h:1576
TSC getTypeSpecComplex() const
Definition: DeclSpec.h:472
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
Definition: LangOptions.h:54
static const TST TST_accum
Definition: DeclSpec.h:275
SourceLocation getRestrictQualifierLoc() const
Retrieve the location of the 'restrict' qualifier.
Definition: DeclSpec.h:1453
A user-defined literal name, e.g., operator "" _i.
void SetSourceRange(SourceRange R)
Definition: DeclSpec.h:1946
This little struct is used to capture information about structure field declarators,...
Definition: DeclSpec.h:2604
bool SetTypeAltiVecPixel(bool isAltiVecPixel, SourceLocation Loc, const char *&PrevSpec, unsigned &DiagID, const PrintingPolicy &Policy)
Definition: DeclSpec.cpp:890
bool isInvalidType() const
Definition: DeclSpec.h:2554
void setTemplateParameterLists(ArrayRef< TemplateParameterList * > TPLs)
Sets the template parameter lists that preceded the declarator.
Definition: DeclSpec.h:2481
bool isFinalSpelledSealed() const
Definition: DeclSpec.h:2634
PointerTypeInfo Ptr
Definition: DeclSpec.h:1548
UnionParsedType DestructorName
When Kind == IK_DestructorName, the type referred to by the class-name.
Definition: DeclSpec.h:994
void setExternInLinkageSpec(bool Value)
Definition: DeclSpec.h:445
static const TST TST_BFloat16
Definition: DeclSpec.h:271
Represents a C++ unqualified-id that has been parsed.
Definition: DeclSpec.h:950
void setObjCWeakProperty(bool Val=true)
Definition: DeclSpec.h:2550
bool isFunctionDeclaratorAFunctionDeclaration() const
Return true if a function declarator at this position would be a function declaration.
Definition: DeclSpec.h:2432
PtrTy get() const
Definition: Ownership.h:169
unsigned ConstQualLoc
The location of the const-qualifier, if any.
Definition: DeclSpec.h:1187
void setExtension(bool Val=true)
Definition: DeclSpec.h:2544
bool isFunctionDeclarator() const
isFunctionDeclarator - Once this declarator is fully parsed and formed, this method returns true if t...
Definition: DeclSpec.h:2319
ParamInfo(IdentifierInfo *ident, SourceLocation iloc, Decl *param, std::unique_ptr< CachedTokens > DefArgTokens=nullptr)
Definition: DeclSpec.h:1253
void SetRangeBegin(SourceLocation Loc)
SetRangeBegin - Set the start of the source range to Loc, unless it's invalid.
Definition: DeclSpec.h:1949
bool isTypeSpecPipe() const
Definition: DeclSpec.h:482
bool setFunctionSpecForceInline(SourceLocation Loc, const char *&PrevSpec, unsigned &DiagID)
Definition: DeclSpec.cpp:998
SCS
storage-class-specifier
Definition: DeclSpec.h:233
ObjCPropertyAttribute::Kind getPropertyAttributes() const
Definition: DeclSpec.h:856
ArrayTypeInfo Arr
Definition: DeclSpec.h:1550
bool SetTypeSpecSign(TypeSpecifierSign S, SourceLocation Loc, const char *&PrevSpec, unsigned &DiagID)
Definition: DeclSpec.cpp:718
Number of bits fitting all the property attributes.
unsigned getNumTypeObjects() const
Return the number of types applied to this declarator.
Definition: DeclSpec.h:2233
void setRedeclaration(bool Val)
Definition: DeclSpec.h:2598
const ParsedAttributes & getAttributes() const
Definition: DeclSpec.h:796
void AddInnermostTypeInfo(const DeclaratorChunk &TI)
Add a new innermost chunk to this declarator.
Definition: DeclSpec.h:2228
void takeAllFrom(ParsedAttributes &attrs)
Definition: ParsedAttr.h:921
unsigned HasTrailingReturnType
HasTrailingReturnType - If this is true, a trailing return type was specified.
Definition: DeclSpec.h:1291
RangeSelector name(std::string ID)
Given a node with a "name", (like NamedDecl, DeclRefExpr or CxxCtorInitializer) selects the name's to...
bool SetFriendSpec(SourceLocation Loc, const char *&PrevSpec, unsigned &DiagID)
Definition: DeclSpec.cpp:1059
bool hasAttributes() const
Definition: DeclSpec.h:793
ActionResult< ParsedType > TypeResult
Definition: Ownership.h:264
unsigned RParenLoc
The location of the right parenthesis in the source.
Definition: DeclSpec.h:1300
void SetInvalid(SourceRange R)
Indicate that this nested-name-specifier is invalid.
Definition: DeclSpec.h:200
Represents a C++ nested-name-specifier or a global scope specifier.
Definition: DeclSpec.h:64
bool isNoreturnSpecified() const
Definition: DeclSpec.h:591
bool SetTypePipe(bool isPipe, SourceLocation Loc, const char *&PrevSpec, unsigned &DiagID, const PrintingPolicy &Policy)
Definition: DeclSpec.cpp:873
bool setFunctionSpecNoreturn(SourceLocation Loc, const char *&PrevSpec, unsigned &DiagID)
Definition: DeclSpec.cpp:1044
void UpdateExprRep(Expr *Rep)
Definition: DeclSpec.h:719
SourceLocation getConstSpecLoc() const
Definition: DeclSpec.h:548
const CXXScopeSpec & getCXXScopeSpec() const
getCXXScopeSpec - Return the C++ scope specifier (global scope or nested-name-specifier) that is part...
Definition: DeclSpec.h:1922
SourceLocation getLSquareLoc() const
Definition: DeclSpec.h:1742
void setTemplateId(TemplateIdAnnotation *TemplateId)
Specify that this unqualified-id was parsed as a template-id.
Definition: DeclSpec.cpp:31
LambdaCaptureInitKind
Definition: DeclSpec.h:2654
static const TST TST_extint
Definition: DeclSpec.h:269
bool isTypeRep() const
Definition: DeclSpec.h:481
SourceRange getSourceRange() const LLVM_READONLY
Definition: DeclSpec.h:506
NestedNameSpecifierLoc getWithLocInContext(ASTContext &Context) const
Retrieve a nested-name-specifier with location information, copied into the given AST context.
Definition: DeclSpec.cpp:151
IdentifierInfo * getIdentifier() const
Definition: DeclSpec.h:2185
UnionParsedType ConstructorName
When Kind == IK_ConstructorName, the class-name of the type whose constructor is being referenced.
Definition: DeclSpec.h:990
static const TST TST_float
Definition: DeclSpec.h:272
DecompositionDeclarator::Binding InlineBindings[16]
Definition: DeclSpec.h:1875
Class that aids in the construction of nested-name-specifiers along with source-location information ...
bool isExpressionContext() const
Determine whether this declaration appears in a context where an expression could appear.
Definition: DeclSpec.h:2390
bool isExternInLinkageSpec() const
Definition: DeclSpec.h:444
bool isFinalSpecified() const
Definition: DeclSpec.h:2633
SourceLocation getTypeSpecComplexLoc() const
Definition: DeclSpec.h:512
unsigned AccessWrites
The access writes.
Definition: DeclSpec.h:1542
unsigned AutoTemplateParameterDepth
If this is a generic lambda or abbreviated function template, use this as the depth of each 'auto' pa...
Definition: DeclSpec.h:2714
DeclSpec & getMutableDeclSpec()
getMutableDeclSpec - Return a non-const version of the DeclSpec.
Definition: DeclSpec.h:1914
SourceLocation getAltiVecLoc() const
Definition: DeclSpec.h:515
Sema - This implements semantic analysis and AST building for C.
Definition: Sema.h:340
SourceLocation getUnalignedSpecLoc() const
Definition: DeclSpec.h:552
void MakeTrivial(ASTContext &Context, NestedNameSpecifier *Qualifier, SourceRange R)
Make a new nested-name-specifier from incomplete source-location information.
Definition: DeclSpec.cpp:125
bool hasConstexprSpecifier() const
Definition: DeclSpec.h:759
void setSetterName(IdentifierInfo *name, SourceLocation loc)
Definition: DeclSpec.h:900
void ClearConstexprSpec()
Definition: DeclSpec.h:763
bool mayBeFollowedByCXXDirectInit() const
mayBeFollowedByCXXDirectInit - Return true if the declarator can be followed by a C++ direct initiali...
Definition: DeclSpec.h:2112
bool isTypeAltiVecPixel() const
Definition: DeclSpec.h:478
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: DeclSpec.h:1153
bool isDeclarationOfFunction() const
Determine whether the declaration that will be produced from this declaration will be a function.
Definition: DeclSpec.cpp:324
bool isPastIdentifier() const
isPastIdentifier - Return true if we have parsed beyond the point where the name would appear.
Definition: DeclSpec.h:2169
IdentifierInfo * getSetterName()
Definition: DeclSpec.h:898
void SetRangeStart(SourceLocation Loc)
Definition: DeclSpec.h:638
void addCapture(LambdaCaptureKind Kind, SourceLocation Loc, IdentifierInfo *Id, SourceLocation EllipsisLoc, LambdaCaptureInitKind InitKind, ExprResult Init, ParsedType InitCaptureType, SourceRange ExplicitRange)
Append a capture in a lambda introducer.
Definition: DeclSpec.h:2693
DeclSpec * MethodQualifiers
DeclSpec for the function with the qualifier related info.
Definition: DeclSpec.h:1332
unsigned NumParams
NumParams - This is the number of formal parameters specified by the declarator.
Definition: DeclSpec.h:1304
const ParsedAttributesView & getAttrs() const
If there are attributes applied to this declaratorchunk, return them.
Definition: DeclSpec.h:1572
unsigned TypeQuals
The type qualifiers: const/volatile/restrict/unaligned/atomic.
Definition: DeclSpec.h:1184
bool getExtension() const
Definition: DeclSpec.h:2545
bool mayHaveDecompositionDeclarator() const
Return true if the context permits a C++17 decomposition declarator.
Definition: DeclSpec.h:2068
A conversion function name, e.g., operator int.
SourceRange getRange() const
Definition: DeclSpec.h:69
SmallVector< LambdaCapture, 4 > Captures
Definition: DeclSpec.h:2687
enum clang::DeclaratorChunk::@205 Kind
TST getTypeSpecType() const
Definition: DeclSpec.h:476
static bool isDeclRep(TST T)
Definition: DeclSpec.h:415
ParsedAttributes & getAttributes()
Definition: DeclSpec.h:2521
llvm::iterator_range< type_object_iterator > type_object_range
Definition: DeclSpec.h:2247
SourceRange getSourceRange() const
Definition: DeclSpec.h:1174
unsigned hasStatic
True if this dimension included the 'static' keyword.
Definition: DeclSpec.h:1220
This represents one expression.
Definition: Expr.h:109
TypeSpecifierSign getTypeSpecSign() const
Definition: DeclSpec.h:473
void setDecompositionBindings(SourceLocation LSquareLoc, ArrayRef< DecompositionDeclarator::Binding > Bindings, SourceLocation RSquareLoc)
Set the decomposition bindings for this declarator.
Definition: DeclSpec.cpp:292
void setDeductionGuideName(ParsedTemplateTy Template, SourceLocation TemplateLoc)
Specify that this unqualified-id was parsed as a template-name for a deduction-guide.
Definition: DeclSpec.h:1142
UnqualifiedIdKind
Describes the kind of unqualified-id parsed.
Definition: DeclSpec.h:926
int Id
Definition: ASTDiff.cpp:191
bool isDecompositionDeclarator() const
Return whether this declarator is a decomposition declarator.
Definition: DeclSpec.h:2181
An individual capture in a lambda introducer.
Definition: DeclSpec.h:2664
DeclaratorChunk & getTypeObject(unsigned i)
Definition: DeclSpec.h:2241
unsigned VolatileQualLoc
The location of the volatile-qualifier, if any.
Definition: DeclSpec.h:1190
unsigned SymbolLocations[3]
The source locations of the individual tokens that name the operator, e.g., the "new",...
Definition: DeclSpec.h:970
static DeclaratorChunk getPipe(unsigned TypeQuals, SourceLocation Loc)
Return a DeclaratorChunk for a block.
Definition: DeclSpec.h:1659
Specifier getLastSpecifier() const
Definition: DeclSpec.h:2643
bool isTypeAltiVecVector() const
Definition: DeclSpec.h:477
void freeParams()
Reset the parameter list to having zero parameters.
Definition: DeclSpec.h:1368
SourceLocation getVolatileSpecLoc() const
Definition: DeclSpec.h:550
SourceLocation getThreadStorageClassSpecLoc() const
Definition: DeclSpec.h:450
void ClearTypeQualifiers()
Clear out all of the type qualifiers.
Definition: DeclSpec.h:556
void clear()
Clear out this unqualified-id, setting it to default (invalid) state.
Definition: DeclSpec.h:1018
Defines an enumeration for C++ overloaded operators.
void setAsmLabel(Expr *E)
Definition: DeclSpec.h:2541
void setRange(SourceRange R)
Definition: DeclSpec.h:70
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:1874
const DeclaratorChunk::FunctionTypeInfo & getFunctionTypeInfo() const
getFunctionTypeInfo - Retrieves the function type info object (looking through parentheses).
Definition: DeclSpec.h:2335
SourceLocation getBeginLoc() const
Definition: DeclSpec.h:73
bool hasEllipsis() const
Definition: DeclSpec.h:2565
A parsed C++17 decomposition declarator of the form '[' identifier-list ']'.
Definition: DeclSpec.h:1699
void addAll(iterator B, iterator E)
Definition: ParsedAttr.h:860
Represents a C++ template name within the type system.
Definition: TemplateName.h:192
const Expr * getExpr() const
Definition: DeclCXX.h:1791
static const TST TST_decimal64
Definition: DeclSpec.h:280
SourceLocation getStorageClassSpecLoc() const
Definition: DeclSpec.h:449
UnqualifiedIdKind getKind() const
Determine what kind of name we have.
Definition: DeclSpec.h:1032
void UpdateTypeRep(ParsedType Rep)
Definition: DeclSpec.h:715
CachedTokens * ExceptionSpecTokens
Pointer to the cached tokens for an exception-specification that has not yet been parsed.
Definition: DeclSpec.h:1349
SourceLocation getTrailingReturnTypeLoc() const
Get the trailing-return-type location for this function declarator.
Definition: DeclSpec.h:1506
bool hasAttributes() const
hasAttributes - do we contain any attributes?
Definition: DeclSpec.h:2524
bool LValueRef
True if this is an lvalue reference, false if it's an rvalue reference.
Definition: DeclSpec.h:1209
SourceLocation Loc
Loc - The place where this type was defined.
Definition: DeclSpec.h:1170
bool hasMutableQualifier() const
Determine whether this lambda-declarator contains a 'mutable' qualifier.
Definition: DeclSpec.h:1469
DeclaratorContext
Definition: DeclSpec.h:1758
void setLiteralOperatorId(const IdentifierInfo *Id, SourceLocation OpLoc, SourceLocation IdLoc)
Specific that this unqualified-id was parsed as a literal-operator-id.
Definition: DeclSpec.h:1083
static const TST TST_int
Definition: DeclSpec.h:267
void setEllipsisLoc(SourceLocation EL)
Definition: DeclSpec.h:2567
bool isInvalid() const
Definition: Ownership.h:165
SourceLocation getEnd() const
ParsedAttributesView AttrList
Definition: DeclSpec.h:1180
static const TST TST_half
Definition: DeclSpec.h:270
const DeclaratorChunk * getOutermostNonParenChunk() const
Return the outermost (furthest from the declarator) chunk of this declarator that is not a parens chu...
Definition: DeclSpec.h:2274
bool isFriendSpecified() const
Definition: DeclSpec.h:748
Wraps an identifier and optional source location for the identifier.
Definition: ParsedAttr.h:174
SourceLocation getCommaLoc() const
Definition: DeclSpec.h:2562
bool isObjCIvar() const
Definition: DeclSpec.h:2548
bool isValid() const
Determine whether this unqualified-id refers to a valid name.
Definition: DeclSpec.h:1026
bool isFirstDeclarator() const
Definition: DeclSpec.h:2561
UnionParsedType TrailingReturnType
If HasTrailingReturnType is true, this is the trailing return type specified.
Definition: DeclSpec.h:1359
SourceLocation getEndLoc() const LLVM_READONLY
Definition: Stmt.cpp:348
SourceLocation getRSquareLoc() const
Definition: DeclSpec.h:1743
TypeAndRange * Exceptions
Pointer to a new[]'d array of TypeAndRange objects that contain the types in the function's dynamic e...
Definition: DeclSpec.h:1341
SourceLocation getRefQualifierLoc() const
Retrieve the location of the ref-qualifier, if any.
Definition: DeclSpec.h:1436
NullabilityKind getNullability() const
Definition: DeclSpec.h:864
bool hasGroupingParens() const
Definition: DeclSpec.h:2559
ConstexprSpecKind getConstexprSpecifier() const
Definition: DeclSpec.h:754
static const TST TST_char32
Definition: DeclSpec.h:266
SourceLocation getNoreturnSpecLoc() const
Definition: DeclSpec.h:592
NestedNameSpecifier * getScopeRep() const
Retrieve the representation of the nested-name-specifier.
Definition: DeclSpec.h:77
static const TST TST_fract
Definition: DeclSpec.h:276
ParsedAttributesView & getAttrs()
Definition: DeclSpec.h:1573
static DeclaratorChunk getParen(SourceLocation LParenLoc, SourceLocation RParenLoc)
Return a DeclaratorChunk for a paren.
Definition: DeclSpec.h:1683
bool isCtorOrDtor()
Returns true if this declares a constructor or a destructor.
Definition: DeclSpec.cpp:418
char * location_data() const
Retrieve the data associated with the source-location information.
Definition: DeclSpec.h:218
ObjCDeclQualifier
ObjCDeclQualifier - Qualifier used on types in method declarations.
Definition: DeclSpec.h:830
UnqualifiedIdKind Kind
Describes the kind of unqualified-id parsed.
Definition: DeclSpec.h:957
#define false
Definition: stdbool.h:17
SourceLocation DefaultLoc
Definition: DeclSpec.h:2685
bool isArrayOfUnknownBound() const
isArrayOfUnknownBound - This method returns true if the declarator is a declarator for an array of un...
Definition: DeclSpec.h:2285
Kind
ActionResult - This structure is used while parsing/acting on expressions, stmts, etc.
Definition: Ownership.h:152
static DeclaratorChunk getReference(unsigned TypeQuals, SourceLocation Loc, bool lvalue)
Return a DeclaratorChunk for a reference.
Definition: DeclSpec.h:1595
SCS getStorageClassSpec() const
Definition: DeclSpec.h:440
SourceLocation getRParenLoc() const
Definition: DeclSpec.h:1419
Expr * getAsmLabel() const
Definition: DeclSpec.h:2542
static const TST TST_float16
Definition: DeclSpec.h:274
bool hasName() const
hasName - Whether this declarator has a name, which might be an identifier (accessible via getIdentif...
Definition: DeclSpec.h:2175
Encodes a location in the source.
bool isTypeSpecOwned() const
Definition: DeclSpec.h:480
static const TST TST_auto_type
Definition: DeclSpec.h:294
ReferenceTypeInfo Ref
Definition: DeclSpec.h:1549
ParsedSpecifiers
ParsedSpecifiers - Flags to query which specifiers were applied.
Definition: DeclSpec.h:316
FunctionDefinitionKind getFunctionDefinitionKind() const
Definition: DeclSpec.h:2577
void setPropertyAttributes(ObjCPropertyAttribute::Kind PRVal)
Definition: DeclSpec.h:859
UnqualifiedId & getName()
Retrieve the name specified by this declarator.
Definition: DeclSpec.h:1926
FunctionTypeInfo Fun
Definition: DeclSpec.h:1551
bool isModulePrivateSpecified() const
Definition: DeclSpec.h:751
SourceLocation getEndLoc() const LLVM_READONLY
Definition: DeclSpec.h:508
static const TST TST_union
Definition: DeclSpec.h:283
Defines several types used to describe C++ lambda expressions that are shared between the parser and ...
ParsedAttr - Represents a syntactic attribute.
Definition: ParsedAttr.h:196
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:615
bool hasTrailingRequiresClause() const
Determine whether a trailing requires clause was written in this declarator.
Definition: DeclSpec.h:2476
char ScopeMem[sizeof(CXXScopeSpec)]
Definition: DeclSpec.h:1528
unsigned NumExplicitTemplateParams
The number of parameters in the template parameter list that were explicitly specified by the user,...
Definition: DeclSpec.h:2710
const DecompositionDeclarator & getDecompositionDeclarator() const
Definition: DeclSpec.h:1928
void setGroupingParens(bool flag)
Definition: DeclSpec.h:2558
GNU __thread.
Definition: Specifiers.h:213
Represents a C++ nested name specifier, such as "\::std::vector<int>::".
AttributeFactory * QualAttrFactory
AtttibuteFactory for the MethodQualifiers.
Definition: DeclSpec.h:1335
LambdaCapture(LambdaCaptureKind Kind, SourceLocation Loc, IdentifierInfo *Id, SourceLocation EllipsisLoc, LambdaCaptureInitKind InitKind, ExprResult Init, ParsedType InitCaptureType, SourceRange ExplicitRange)
Definition: DeclSpec.h:2674
MemberPointerTypeInfo Mem
Definition: DeclSpec.h:1553
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:423
bool hasTrailingReturnType() const
Determine whether this function declarator had a trailing-return-type.
Definition: DeclSpec.h:1497
Decl * getRepAsDecl() const
Definition: DeclSpec.h:490
ParsedType getTrailingReturnType() const
Get the trailing return type appearing (at any level) within this declarator.
Definition: DeclSpec.h:2454
Represents a C++11 virt-specifier-seq.
Definition: DeclSpec.h:2612
void AddTypeInfo(const DeclaratorChunk &TI, SourceLocation EndLoc)
AddTypeInfo - Add a chunk to this declarator.
Definition: DeclSpec.h:2220
static const TST TST_typeofType
Definition: DeclSpec.h:288
bool isInvalid() const
Determine whether this unqualified-id refers to an invalid name.
Definition: DeclSpec.h:1029
FunctionDefinitionKind
Described the kind of function definition (if any) provided for a function.
Definition: DeclSpec.h:1751
bool HasRestrict
The type qualifier: restrict. [GNU] C++ extension.
Definition: DeclSpec.h:1207
unsigned TypeQuals
The type qualifiers: const/volatile/restrict/__unaligned/_Atomic.
Definition: DeclSpec.h:1523
SourceLocation getConstQualifierLoc() const
Retrieve the location of the 'const' qualifier.
Definition: DeclSpec.h:1441
bool isStaticMember()
Returns true if this declares a static member.
Definition: DeclSpec.cpp:410
bool SetTypeAltiVecVector(bool isAltiVecVector, SourceLocation Loc, const char *&PrevSpec, unsigned &DiagID, const PrintingPolicy &Policy)
Definition: DeclSpec.cpp:858
PipeTypeInfo PipeInfo
Definition: DeclSpec.h:1554
SourceLocation getInlineSpecLoc() const
Definition: DeclSpec.h:570
static DeclaratorChunk getArray(unsigned TypeQuals, bool isStatic, bool isStar, Expr *NumElts, SourceLocation LBLoc, SourceLocation RBLoc)
Return a DeclaratorChunk for an array.
Definition: DeclSpec.h:1606
Decl * DeclRep
Definition: DeclSpec.h:361
bool isInvalid() const
An error occurred during parsing of the scope specifier.
Definition: DeclSpec.h:195
void setFunctionDefinitionKind(FunctionDefinitionKind Val)
Definition: DeclSpec.h:2569
DecompositionDeclarator & operator=(const DecompositionDeclarator &G)=delete
SourceLocation getLastLocation() const
Definition: DeclSpec.h:2642
C++11 thread_local.
Definition: Specifiers.h:216
Defines various enumerations that describe declaration and type specifiers.
SourceLocation getModulePrivateSpecLoc() const
Definition: DeclSpec.h:752
bool isObjCWeakProperty() const
Definition: DeclSpec.h:2551
SourceRange getSourceRange() const LLVM_READONLY
Get the source range that spans this declarator.
Definition: DeclSpec.h:1942
void takeAttributes(ParsedAttributes &attrs, SourceLocation lastLoc)
takeAttributes - Takes attributes from the given parsed-attributes set and add them to this declarato...
Definition: DeclSpec.h:2513
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(), SourceLocation TrailingReturnTypeLoc=SourceLocation(), DeclSpec *MethodQualifiers=nullptr)
DeclaratorChunk::getFunction - Return a DeclaratorChunk for a function.
Definition: DeclSpec.cpp:160
static const TST TST_decltype_auto
Definition: DeclSpec.h:291
bool setModulePrivateSpec(SourceLocation Loc, const char *&PrevSpec, unsigned &DiagID)
Definition: DeclSpec.cpp:1077
Dataflow Directional Tag Classes.
unsigned TypeQuals
The type qualifiers for the array: const/volatile/restrict/__unaligned/_Atomic.
Definition: DeclSpec.h:1217
ConstexprSpecKind
Define the kind of constexpr specifier.
Definition: Specifiers.h:32
bool isValid() const
Return true if this is a valid SourceLocation object.
SmallVector< Token, 4 > CachedTokens
A set of tokens that has been cached for later parsing.
Definition: DeclSpec.h:1158
FieldDeclarator(const DeclSpec &DS)
Definition: DeclSpec.h:2607
SourceLocation getTypeSpecWidthLoc() const
Definition: DeclSpec.h:510
LambdaCaptureDefault Default
Definition: DeclSpec.h:2686
void setObjCIvar(bool Val=true)
Definition: DeclSpec.h:2547
SourceLocation getTypeSpecSatLoc() const
Definition: DeclSpec.h:516
static const TST TST_decltype
Definition: DeclSpec.h:290
OverloadedOperatorKind
Enumeration specifying the different kinds of C++ overloaded operators.
Definition: OperatorKinds.h:21
static const TST TST_auto
Definition: DeclSpec.h:293
static const TST TST_void
Definition: DeclSpec.h:261
unsigned isVariadic
isVariadic - If this function has a prototype, and if that proto ends with ',...)',...
Definition: DeclSpec.h:1274
const DeclaratorChunk * getInnermostNonParenChunk() const
Return the innermost (closest to the declarator) chunk of this declarator that is not a parens chunk,...
Definition: DeclSpec.h:2263
static const TST TST_int128
Definition: DeclSpec.h:268
unsigned DeleteParams
DeleteParams - If this is true, we need to delete[] Params.
Definition: DeclSpec.h:1287
bool isMissingDeclaratorOk()
Checks if this DeclSpec can stand alone, without a Declarator.
Definition: DeclSpec.cpp:1434
SourceLocation getPipeLoc() const
Definition: DeclSpec.h:553
void takeAllFrom(AttributePool &pool)
Take the given pool's allocations and add them to this pool.
Definition: ParsedAttr.h:732
SourceLocation getTypeSpecSignLoc() const
Definition: DeclSpec.h:513
void setObjCDeclQualifier(ObjCDeclQualifier DQVal)
Definition: DeclSpec.h:849
bool isTypeAltiVecBool() const
Definition: DeclSpec.h:479
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: DeclSpec.h:507
static const TST TST_unspecified
Definition: DeclSpec.h:260
bool isValid() const
A scope specifier is present, and it refers to a real scope.
Definition: DeclSpec.h:197
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:435
const CXXScopeSpec & getTypeSpecScope() const
Definition: DeclSpec.h:504
bool SetSpecifier(Specifier VS, SourceLocation Loc, const char *&PrevSpec)
Definition: DeclSpec.cpp:1455
static const TST TST_decimal128
Definition: DeclSpec.h:281
unsigned getTypeQualifiers() const
getTypeQualifiers - Return a set of TQs.
Definition: DeclSpec.h:547
void takeAttributesFrom(ParsedAttributes &attrs)
Definition: DeclSpec.h:798
SourceLocation getNullabilityLoc() const
Definition: DeclSpec.h:872
static const TSCS TSCS___thread
Definition: DeclSpec.h:248
SourceLocation getVirtualSpecLoc() const
Definition: DeclSpec.h:579
unsigned hasPrototype
hasPrototype - This is true if the function had at least one typed parameter.
Definition: DeclSpec.h:1269
TemplateIdAnnotation * getRepAsTemplateId() const
Definition: DeclSpec.h:498
SourceLocation getGetterNameLoc() const
Definition: DeclSpec.h:891
unsigned LParenLoc
The location of the left parenthesis in the source.
Definition: DeclSpec.h:1294
void setNullability(SourceLocation loc, NullabilityKind kind)
Definition: DeclSpec.h:880
type_object_range type_objects() const
Returns the range of type objects, from the identifier outwards.
Definition: DeclSpec.h:2250
ArrayRef< TemplateParameterList * > getTemplateParameterLists() const
The template parameter lists that preceded the declarator.
Definition: DeclSpec.h:2486
bool SetStorageClassSpecThread(TSCS TSC, SourceLocation Loc, const char *&PrevSpec, unsigned &DiagID)
Definition: DeclSpec.cpp:677
void setOperatorFunctionId(SourceLocation OperatorLoc, OverloadedOperatorKind Op, SourceLocation SymbolLocations[3])
Specify that this unqualified-id was parsed as an operator-function-id.
Definition: DeclSpec.cpp:1440
static const TST TST_typename
Definition: DeclSpec.h:287
CXXScopeSpec & getCXXScopeSpec()
Definition: DeclSpec.h:1923
void SetRangeEnd(SourceLocation Loc)
SetRangeEnd - Set the end of the source range to Loc, unless it's invalid.
Definition: DeclSpec.h:1954
bool SetTypeSpecWidth(TypeSpecifierWidth 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:691
ExceptionSpecificationType
The various types of exception specifications that exist in C++11.
unsigned AtomicQualLoc
The location of the _Atomic-qualifier, if any.
Definition: DeclSpec.h:1196
TypeSpecifierWidth getTypeSpecWidth() const
Definition: DeclSpec.h:469
ExceptionSpecificationType getExceptionSpecType() const
Get the type of exception specification this function has.
Definition: DeclSpec.h:1478
void AddTypeInfo(const DeclaratorChunk &TI, ParsedAttributes &&attrs, SourceLocation EndLoc)
AddTypeInfo - Add a chunk to this declarator.
Definition: DeclSpec.h:2208
bool SetExtIntType(SourceLocation KWLoc, Expr *BitWidth, const char *&PrevSpec, unsigned &DiagID, const PrintingPolicy &Policy)
Definition: DeclSpec.cpp:932
SourceLocation getTypeSpecTypeNameLoc() const
Definition: DeclSpec.h:518
CXXScopeSpec & getTypeSpecScope()
Definition: DeclSpec.h:503
BlockPointerTypeInfo Cls
Definition: DeclSpec.h:1552
SourceRange getExceptionSpecRange() const
Definition: DeclSpec.h:1431
bool SetTypeSpecType(TST T, SourceLocation Loc, const char *&PrevSpec, unsigned &DiagID, const PrintingPolicy &Policy)
Definition: DeclSpec.cpp:821
SourceLocation getIdentifierLoc() const
Definition: DeclSpec.h:2191
Structure that packs information about the type specifiers that were written in a particular type spe...
Definition: Specifiers.h:88
bool isSet() const
Deprecated.
Definition: DeclSpec.h:210
void getCXX11AttributeRanges(SmallVectorImpl< SourceRange > &Ranges)
Return a source range list of C++11 attributes associated with the declarator.
Definition: DeclSpec.h:2535
SourceRange getSourceRange() const
Definition: DeclSpec.h:1744
void setInvalidType(bool Val=true)
Definition: DeclSpec.h:2553
Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate....
unsigned TypeQuals
For now, sema will catch these as invalid.
Definition: DeclSpec.h:1515
static DeclaratorChunk getBlockPointer(unsigned TypeQuals, SourceLocation Loc)
Return a DeclaratorChunk for a block.
Definition: DeclSpec.h:1649
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 'type...
Definition: DeclSpec.cpp:53
Expr * getTrailingRequiresClause()
Sets a trailing requires clause for this declarator.
Definition: DeclSpec.h:2470
unsigned ExceptionSpecType
ExceptionSpecType - An ExceptionSpecificationType value.
Definition: DeclSpec.h:1284
const CXXScopeSpec & Scope() const
Definition: DeclSpec.h:1532
ThreadStorageClassSpecifier
Thread storage-class-specifier.
Definition: Specifiers.h:210
Captures information about "declaration specifiers".
Definition: DeclSpec.h:229
SourceLocation getRestrictSpecLoc() const
Definition: DeclSpec.h:549
void UpdateDeclRep(Decl *Rep)
Definition: DeclSpec.h:711
Represents a C++ struct/union/class.
Definition: DeclCXX.h:254
A factory, from which one makes pools, from which one creates individual attributes which are dealloc...
Definition: ParsedAttr.h:636
static const TSCS TSCS_thread_local
Definition: DeclSpec.h:249
SourceLocation getEllipsisLoc() const
Definition: DeclSpec.h:2566
TemplateParameterList * getInventedTemplateParameterList() const
The template parameter list generated from the explicit template parameters along with any invented t...
Definition: DeclSpec.h:2500
bool isValid() const
bool SetTypeSpecSat(SourceLocation Loc, const char *&PrevSpec, unsigned &DiagID)
Definition: DeclSpec.cpp:845
SourceLocation getMutableLoc() const
Retrieve the location of the 'mutable' qualifier, if any.
Definition: DeclSpec.h:1459
TypeSpecifierWidth
Specifies the width of a type, e.g., short, long, or long long.
Definition: Specifiers.h:35
Expr * NumElts
This is the size of the array, or null if [] or [*] was specified.
Definition: DeclSpec.h:1228
void ClearTypeSpecType()
Definition: DeclSpec.h:462
bool mayHaveIdentifier() const
mayHaveIdentifier - Return true if the identifier is either optional or required.
Definition: DeclSpec.h:2031
bool isNotEmpty() const
A scope specifier is present, but may be valid or invalid.
Definition: DeclSpec.h:192
static const TST TST_float128
Definition: DeclSpec.h:277
const DeclSpec & getDeclSpec() const
getDeclSpec - Return the declaration-specifier that this declarator was declared with.
Definition: DeclSpec.h:1907
static const TST TST_bool
Definition: DeclSpec.h:278
bool isVirtualSpecified() const
Definition: DeclSpec.h:578
unsigned kind
All of the diagnostics that can be emitted by the frontend.
Definition: DiagnosticIDs.h:60
void setInventedTemplateParameterList(TemplateParameterList *Invented)
Sets the template parameter list generated from the explicit template parameters along with any inven...
Definition: DeclSpec.h:2493
void MakeGlobal(ASTContext &Context, SourceLocation ColonColonLoc)
Turn this (empty) nested-name-specifier into the global nested-name-specifier '::'.
Definition: DeclSpec.cpp:103
bool isSpecified() const
Determine if the declaration had an explicit specifier of any kind.
Definition: DeclCXX.h:1795
A template-id, e.g., f<int>.
SourceLocation getFirstLocation() const
Definition: DeclSpec.h:2641
AttributePool & getPool() const
Definition: ParsedAttr.h:919
ParsedType getRepAsType() const
Definition: DeclSpec.h:486
void Finish(Sema &S, const PrintingPolicy &Policy)
Finish - This does final analysis of the declspec, issuing diagnostics for things like "_Imaginary" (...
Definition: DeclSpec.cpp:1112
bool isInlineSpecified() const
Definition: DeclSpec.h:567
Represents a complete lambda introducer.
Definition: DeclSpec.h:2662
void ExtendWithDeclSpec(const DeclSpec &DS)
ExtendWithDeclSpec - Extend the declarator source range to include the given declspec,...
Definition: DeclSpec.h:1961
unsigned TrailingReturnTypeLoc
If HasTrailingReturnType is true, this is the location of the trailing return type.
Definition: DeclSpec.h:1363
SourceLocation getAtomicSpecLoc() const
Definition: DeclSpec.h:551
Expr * ExprRep
Definition: DeclSpec.h:362
void setBeginLoc(SourceLocation Loc)
Definition: DeclSpec.h:71
SourceLocation getExplicitSpecLoc() const
Definition: DeclSpec.h:584
SourceLocation getConstexprSpecLoc() const
Definition: DeclSpec.h:758
bool hasRefQualifier() const
Determine whether this function declaration contains a ref-qualifier.
Definition: DeclSpec.h:1465
static const TST TST_atomic
Definition: DeclSpec.h:296
ArrayRef< NamedDecl * > getDeclsInPrototype() const
Get the non-parameter decls defined within this function prototype.
Definition: DeclSpec.h:1490
bool isEmpty() const
isEmpty - Return true if this declaration specifier is completely empty: no tokens were parsed in the...
Definition: DeclSpec.h:634
static const TST TST_struct
Definition: DeclSpec.h:284
const IdentifierInfo * getGetterName() const
Definition: DeclSpec.h:889
ParamInfo - An array of paraminfo objects is allocated whenever a function declarator is parsed.
Definition: DeclSpec.h:1240
ArrayRef< Binding > bindings() const
Definition: DeclSpec.h:1736
DeclaratorContext getContext() const
Definition: DeclSpec.h:1932
SourceLocation getExceptionSpecLocEnd() const
Definition: DeclSpec.h:1427
A trivial tuple used to represent a source range.
bool SetTypeSpecComplex(TSC C, SourceLocation Loc, const char *&PrevSpec, unsigned &DiagID)
Definition: DeclSpec.cpp:708
This represents a decl that may have a name.
Definition: Decl.h:223
void setIdentifier(const IdentifierInfo *Id, SourceLocation IdLoc)
Specify that this unqualified-id was parsed as an identifier.
Definition: DeclSpec.h:1039
bool SetTypeSpecError()
Definition: DeclSpec.cpp:924
unsigned ExceptionSpecLocEnd
The end location of the exception specification, if any.
Definition: DeclSpec.h:1324
bool isConstrainedAuto() const
Definition: DeclSpec.h:484
Expr * getRepAsExpr() const
Definition: DeclSpec.h:494
Represents a C++ namespace alias.
Definition: DeclCXX.h:2962
void setGetterName(IdentifierInfo *name, SourceLocation loc)
Definition: DeclSpec.h:892
SourceLocation EndLocation
The location of the last token that describes this unqualified-id.
Definition: DeclSpec.h:1011
static const TSCS TSCS__Thread_local
Definition: DeclSpec.h:250
void setDestructorName(SourceLocation TildeLoc, ParsedType ClassType, SourceLocation EndLoc)
Specify that this unqualified-id was parsed as a destructor name.
Definition: DeclSpec.h:1121
bool isFirstDeclarationOfMember()
Returns true if this declares a real member and not a friend.
Definition: DeclSpec.h:2585
void SetRangeEnd(SourceLocation Loc)
Definition: DeclSpec.h:639
bool isPrototypeContext() const
Definition: DeclSpec.h:1934
void addAttributes(ParsedAttributesView &AL)
Concatenates two attribute lists.
Definition: DeclSpec.h:789
AttributePool & getAttributePool() const
Definition: DeclSpec.h:768
SourceLocation getBegin() const
ParsedAttributes - A collection of parsed attributes.
Definition: ParsedAttr.h:914
void setCommaLoc(SourceLocation CL)
Definition: DeclSpec.h:2563
SourceRange getExplicitSpecRange() const
Definition: DeclSpec.h:585
A deduction-guide name (a template-name)
ParamInfo * Params
Params - This is a pointer to a new[]'d array of ParamInfo objects that describe the parameters speci...
Definition: DeclSpec.h:1329
ParsedAttributes & getAttributes()
Definition: DeclSpec.h:795
SourceRange getTypeofParensRange() const
Definition: DeclSpec.h:523
bool setFunctionSpecInline(SourceLocation Loc, const char *&PrevSpec, unsigned &DiagID)
Definition: DeclSpec.cpp:984
unsigned isAmbiguous
Can this declaration be a constructor-style initializer?
Definition: DeclSpec.h:1277