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