clang  6.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 /// \brief 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 /// \brief 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  /// \brief Retrieve the representation of the nested-name-specifier.
77  return Builder.getRepresentation();
78  }
79 
80  /// \brief 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  /// \brief 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  /// \brief 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  /// \brief 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  /// \brief Turn this (empty) nested-name-specifier into the global
138  /// nested-name-specifier '::'.
139  void MakeGlobal(ASTContext &Context, SourceLocation ColonColonLoc);
140 
141  /// \brief 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  /// \brief 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  /// \brief Adopt an existing nested-name-specifier (with source-range
167  /// information).
168  void Adopt(NestedNameSpecifierLoc Other);
169 
170  /// \brief 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  /// \brief 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  /// \brief 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  /// \brief Retrieve the data associated with the source-location information.
217  char *location_data() const { return Builder.getBuffer().first; }
218 
219  /// \brief Retrieve the size of the data associated with source-location
220  /// information.
221  unsigned location_size() const { return Builder.getBuffer().second; }
222 };
223 
224 /// \brief 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  /// \brief 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_char16 = clang::TST_char16;
277  static const TST TST_char32 = clang::TST_char32;
278  static const TST TST_int = clang::TST_int;
279  static const TST TST_int128 = clang::TST_int128;
280  static const TST TST_half = clang::TST_half;
281  static const TST TST_float = clang::TST_float;
282  static const TST TST_double = clang::TST_double;
283  static const TST TST_float16 = clang::TST_Float16;
284  static const TST TST_float128 = clang::TST_float128;
285  static const TST TST_bool = clang::TST_bool;
289  static const TST TST_enum = clang::TST_enum;
290  static const TST TST_union = clang::TST_union;
291  static const TST TST_struct = clang::TST_struct;
293  static const TST TST_class = clang::TST_class;
294  static const TST TST_typename = clang::TST_typename;
297  static const TST TST_decltype = clang::TST_decltype;
300  static const TST TST_auto = clang::TST_auto;
303  static const TST TST_atomic = clang::TST_atomic;
304 #define GENERIC_IMAGE_TYPE(ImgType, Id) \
305  static const TST TST_##ImgType##_t = clang::TST_##ImgType##_t;
306 #include "clang/Basic/OpenCLImageTypes.def"
307  static const TST TST_error = clang::TST_error;
308 
309  // type-qualifiers
310  enum TQ { // NOTE: These flags must be kept in sync with Qualifiers::TQ.
311  TQ_unspecified = 0,
312  TQ_const = 1,
313  TQ_restrict = 2,
314  TQ_volatile = 4,
315  TQ_unaligned = 8,
316  // This has no corresponding Qualifiers::TQ value, because it's not treated
317  // as a qualifier in our type system.
318  TQ_atomic = 16
319  };
320 
321  /// ParsedSpecifiers - Flags to query which specifiers were applied. This is
322  /// returned by getParsedSpecifiers.
324  PQ_None = 0,
325  PQ_StorageClassSpecifier = 1,
326  PQ_TypeSpecifier = 2,
327  PQ_TypeQualifier = 4,
328  PQ_FunctionSpecifier = 8
329  };
330 
331 private:
332  // storage-class-specifier
333  /*SCS*/unsigned StorageClassSpec : 3;
334  /*TSCS*/unsigned ThreadStorageClassSpec : 2;
335  unsigned SCS_extern_in_linkage_spec : 1;
336 
337  // type-specifier
338  /*TSW*/unsigned TypeSpecWidth : 2;
339  /*TSC*/unsigned TypeSpecComplex : 2;
340  /*TSS*/unsigned TypeSpecSign : 2;
341  /*TST*/unsigned TypeSpecType : 6;
342  unsigned TypeAltiVecVector : 1;
343  unsigned TypeAltiVecPixel : 1;
344  unsigned TypeAltiVecBool : 1;
345  unsigned TypeSpecOwned : 1;
346  unsigned TypeSpecPipe : 1;
347 
348  // type-qualifiers
349  unsigned TypeQualifiers : 5; // Bitwise OR of TQ.
350 
351  // function-specifier
352  unsigned FS_inline_specified : 1;
353  unsigned FS_forceinline_specified: 1;
354  unsigned FS_virtual_specified : 1;
355  unsigned FS_explicit_specified : 1;
356  unsigned FS_noreturn_specified : 1;
357 
358  // friend-specifier
359  unsigned Friend_specified : 1;
360 
361  // constexpr-specifier
362  unsigned Constexpr_specified : 1;
363 
364  // concept-specifier
365  unsigned Concept_specified : 1;
366 
367  union {
371  };
372 
373  // attributes.
374  ParsedAttributes Attrs;
375 
376  // Scope specifier for the type spec, if applicable.
377  CXXScopeSpec TypeScope;
378 
379  // SourceLocation info. These are null if the item wasn't specified or if
380  // the setting was synthesized.
381  SourceRange Range;
382 
383  SourceLocation StorageClassSpecLoc, ThreadStorageClassSpecLoc;
384  SourceRange TSWRange;
385  SourceLocation TSCLoc, TSSLoc, TSTLoc, AltiVecLoc;
386  /// TSTNameLoc - If TypeSpecType is any of class, enum, struct, union,
387  /// typename, then this is the location of the named type (if present);
388  /// otherwise, it is the same as TSTLoc. Hence, the pair TSTLoc and
389  /// TSTNameLoc provides source range info for tag types.
390  SourceLocation TSTNameLoc;
391  SourceRange TypeofParensRange;
392  SourceLocation TQ_constLoc, TQ_restrictLoc, TQ_volatileLoc, TQ_atomicLoc,
393  TQ_unalignedLoc;
394  SourceLocation FS_inlineLoc, FS_virtualLoc, FS_explicitLoc, FS_noreturnLoc;
395  SourceLocation FS_forceinlineLoc;
396  SourceLocation FriendLoc, ModulePrivateLoc, ConstexprLoc, ConceptLoc;
397  SourceLocation TQ_pipeLoc;
398 
399  WrittenBuiltinSpecs writtenBS;
400  void SaveWrittenBuiltinSpecs();
401 
402  ObjCDeclSpec *ObjCQualifiers;
403 
404  static bool isTypeRep(TST T) {
405  return (T == TST_typename || T == TST_typeofType ||
406  T == TST_underlyingType || T == TST_atomic);
407  }
408  static bool isExprRep(TST T) {
409  return (T == TST_typeofExpr || T == TST_decltype);
410  }
411 
412  DeclSpec(const DeclSpec &) = delete;
413  void operator=(const DeclSpec &) = delete;
414 public:
415  static bool isDeclRep(TST T) {
416  return (T == TST_enum || T == TST_struct ||
417  T == TST_interface || T == TST_union ||
418  T == TST_class);
419  }
420 
422  : StorageClassSpec(SCS_unspecified),
423  ThreadStorageClassSpec(TSCS_unspecified),
424  SCS_extern_in_linkage_spec(false),
425  TypeSpecWidth(TSW_unspecified),
426  TypeSpecComplex(TSC_unspecified),
427  TypeSpecSign(TSS_unspecified),
428  TypeSpecType(TST_unspecified),
429  TypeAltiVecVector(false),
430  TypeAltiVecPixel(false),
431  TypeAltiVecBool(false),
432  TypeSpecOwned(false),
433  TypeSpecPipe(false),
434  TypeQualifiers(TQ_unspecified),
435  FS_inline_specified(false),
436  FS_forceinline_specified(false),
437  FS_virtual_specified(false),
438  FS_explicit_specified(false),
439  FS_noreturn_specified(false),
440  Friend_specified(false),
441  Constexpr_specified(false),
442  Concept_specified(false),
443  Attrs(attrFactory),
444  writtenBS(),
445  ObjCQualifiers(nullptr) {
446  }
447 
448  // storage-class-specifier
449  SCS getStorageClassSpec() const { return (SCS)StorageClassSpec; }
451  return (TSCS)ThreadStorageClassSpec;
452  }
453  bool isExternInLinkageSpec() const { return SCS_extern_in_linkage_spec; }
455  SCS_extern_in_linkage_spec = Value;
456  }
457 
458  SourceLocation getStorageClassSpecLoc() const { return StorageClassSpecLoc; }
460  return ThreadStorageClassSpecLoc;
461  }
462 
464  StorageClassSpec = DeclSpec::SCS_unspecified;
465  ThreadStorageClassSpec = DeclSpec::TSCS_unspecified;
466  SCS_extern_in_linkage_spec = false;
467  StorageClassSpecLoc = SourceLocation();
468  ThreadStorageClassSpecLoc = SourceLocation();
469  }
470 
472  TypeSpecType = DeclSpec::TST_unspecified;
473  TypeSpecOwned = false;
474  TSTLoc = SourceLocation();
475  }
476 
477  // type-specifier
478  TSW getTypeSpecWidth() const { return (TSW)TypeSpecWidth; }
479  TSC getTypeSpecComplex() const { return (TSC)TypeSpecComplex; }
480  TSS getTypeSpecSign() const { return (TSS)TypeSpecSign; }
481  TST getTypeSpecType() const { return (TST)TypeSpecType; }
482  bool isTypeAltiVecVector() const { return TypeAltiVecVector; }
483  bool isTypeAltiVecPixel() const { return TypeAltiVecPixel; }
484  bool isTypeAltiVecBool() const { return TypeAltiVecBool; }
485  bool isTypeSpecOwned() const { return TypeSpecOwned; }
486  bool isTypeRep() const { return isTypeRep((TST) TypeSpecType); }
487  bool isTypeSpecPipe() const { return TypeSpecPipe; }
488 
490  assert(isTypeRep((TST) TypeSpecType) && "DeclSpec does not store a type");
491  return TypeRep;
492  }
493  Decl *getRepAsDecl() const {
494  assert(isDeclRep((TST) TypeSpecType) && "DeclSpec does not store a decl");
495  return DeclRep;
496  }
497  Expr *getRepAsExpr() const {
498  assert(isExprRep((TST) TypeSpecType) && "DeclSpec does not store an expr");
499  return ExprRep;
500  }
501  CXXScopeSpec &getTypeSpecScope() { return TypeScope; }
502  const CXXScopeSpec &getTypeSpecScope() const { return TypeScope; }
503 
504  SourceRange getSourceRange() const LLVM_READONLY { return Range; }
505  SourceLocation getLocStart() const LLVM_READONLY { return Range.getBegin(); }
506  SourceLocation getLocEnd() const LLVM_READONLY { return Range.getEnd(); }
507 
508  SourceLocation getTypeSpecWidthLoc() const { return TSWRange.getBegin(); }
509  SourceRange getTypeSpecWidthRange() const { return TSWRange; }
510  SourceLocation getTypeSpecComplexLoc() const { return TSCLoc; }
511  SourceLocation getTypeSpecSignLoc() const { return TSSLoc; }
512  SourceLocation getTypeSpecTypeLoc() const { return TSTLoc; }
513  SourceLocation getAltiVecLoc() const { return AltiVecLoc; }
514 
516  assert(isDeclRep((TST) TypeSpecType) || TypeSpecType == TST_typename);
517  return TSTNameLoc;
518  }
519 
520  SourceRange getTypeofParensRange() const { return TypeofParensRange; }
521  void setTypeofParensRange(SourceRange range) { TypeofParensRange = range; }
522 
523  bool hasAutoTypeSpec() const {
524  return (TypeSpecType == TST_auto || TypeSpecType == TST_auto_type ||
525  TypeSpecType == TST_decltype_auto);
526  }
527 
528  bool hasTagDefinition() const;
529 
530  /// \brief Turn a type-specifier-type into a string like "_Bool" or "union".
531  static const char *getSpecifierName(DeclSpec::TST T,
532  const PrintingPolicy &Policy);
533  static const char *getSpecifierName(DeclSpec::TQ Q);
534  static const char *getSpecifierName(DeclSpec::TSS S);
535  static const char *getSpecifierName(DeclSpec::TSC C);
536  static const char *getSpecifierName(DeclSpec::TSW W);
537  static const char *getSpecifierName(DeclSpec::SCS S);
538  static const char *getSpecifierName(DeclSpec::TSCS S);
539 
540  // type-qualifiers
541 
542  /// getTypeQualifiers - Return a set of TQs.
543  unsigned getTypeQualifiers() const { return TypeQualifiers; }
544  SourceLocation getConstSpecLoc() const { return TQ_constLoc; }
545  SourceLocation getRestrictSpecLoc() const { return TQ_restrictLoc; }
546  SourceLocation getVolatileSpecLoc() const { return TQ_volatileLoc; }
547  SourceLocation getAtomicSpecLoc() const { return TQ_atomicLoc; }
548  SourceLocation getUnalignedSpecLoc() const { return TQ_unalignedLoc; }
549  SourceLocation getPipeLoc() const { return TQ_pipeLoc; }
550 
551  /// \brief Clear out all of the type qualifiers.
553  TypeQualifiers = 0;
554  TQ_constLoc = SourceLocation();
555  TQ_restrictLoc = SourceLocation();
556  TQ_volatileLoc = SourceLocation();
557  TQ_atomicLoc = SourceLocation();
558  TQ_unalignedLoc = SourceLocation();
559  TQ_pipeLoc = SourceLocation();
560  }
561 
562  // function-specifier
563  bool isInlineSpecified() const {
564  return FS_inline_specified | FS_forceinline_specified;
565  }
567  return FS_inline_specified ? FS_inlineLoc : FS_forceinlineLoc;
568  }
569 
570  bool isVirtualSpecified() const { return FS_virtual_specified; }
571  SourceLocation getVirtualSpecLoc() const { return FS_virtualLoc; }
572 
573  bool isExplicitSpecified() const { return FS_explicit_specified; }
574  SourceLocation getExplicitSpecLoc() const { return FS_explicitLoc; }
575 
576  bool isNoreturnSpecified() const { return FS_noreturn_specified; }
577  SourceLocation getNoreturnSpecLoc() const { return FS_noreturnLoc; }
578 
580  FS_inline_specified = false;
581  FS_inlineLoc = SourceLocation();
582  FS_forceinline_specified = false;
583  FS_forceinlineLoc = SourceLocation();
584  FS_virtual_specified = false;
585  FS_virtualLoc = SourceLocation();
586  FS_explicit_specified = false;
587  FS_explicitLoc = SourceLocation();
588  FS_noreturn_specified = false;
589  FS_noreturnLoc = SourceLocation();
590  }
591 
592  /// \brief Return true if any type-specifier has been found.
593  bool hasTypeSpecifier() const {
594  return getTypeSpecType() != DeclSpec::TST_unspecified ||
595  getTypeSpecWidth() != DeclSpec::TSW_unspecified ||
596  getTypeSpecComplex() != DeclSpec::TSC_unspecified ||
597  getTypeSpecSign() != DeclSpec::TSS_unspecified;
598  }
599 
600  /// \brief Return a bitmask of which flavors of specifiers this
601  /// DeclSpec includes.
602  unsigned getParsedSpecifiers() const;
603 
604  /// isEmpty - Return true if this declaration specifier is completely empty:
605  /// no tokens were parsed in the production of it.
606  bool isEmpty() const {
607  return getParsedSpecifiers() == DeclSpec::PQ_None;
608  }
609 
610  void SetRangeStart(SourceLocation Loc) { Range.setBegin(Loc); }
611  void SetRangeEnd(SourceLocation Loc) { Range.setEnd(Loc); }
612 
613  /// These methods set the specified attribute of the DeclSpec and
614  /// return false if there was no error. If an error occurs (for
615  /// example, if we tried to set "auto" on a spec with "extern"
616  /// already set), they return true and set PrevSpec and DiagID
617  /// such that
618  /// Diag(Loc, DiagID) << PrevSpec;
619  /// will yield a useful result.
620  ///
621  /// TODO: use a more general approach that still allows these
622  /// diagnostics to be ignored when desired.
623  bool SetStorageClassSpec(Sema &S, SCS SC, SourceLocation Loc,
624  const char *&PrevSpec, unsigned &DiagID,
625  const PrintingPolicy &Policy);
626  bool SetStorageClassSpecThread(TSCS TSC, SourceLocation Loc,
627  const char *&PrevSpec, unsigned &DiagID);
628  bool SetTypeSpecWidth(TSW W, SourceLocation Loc, const char *&PrevSpec,
629  unsigned &DiagID, const PrintingPolicy &Policy);
630  bool SetTypeSpecComplex(TSC C, SourceLocation Loc, const char *&PrevSpec,
631  unsigned &DiagID);
632  bool SetTypeSpecSign(TSS S, SourceLocation Loc, const char *&PrevSpec,
633  unsigned &DiagID);
634  bool SetTypeSpecType(TST T, SourceLocation Loc, const char *&PrevSpec,
635  unsigned &DiagID, const PrintingPolicy &Policy);
636  bool SetTypeSpecType(TST T, SourceLocation Loc, const char *&PrevSpec,
637  unsigned &DiagID, ParsedType Rep,
638  const PrintingPolicy &Policy);
639  bool SetTypeSpecType(TST T, SourceLocation Loc, const char *&PrevSpec,
640  unsigned &DiagID, Decl *Rep, bool Owned,
641  const PrintingPolicy &Policy);
642  bool SetTypeSpecType(TST T, SourceLocation TagKwLoc,
643  SourceLocation TagNameLoc, const char *&PrevSpec,
644  unsigned &DiagID, ParsedType Rep,
645  const PrintingPolicy &Policy);
646  bool SetTypeSpecType(TST T, SourceLocation TagKwLoc,
647  SourceLocation TagNameLoc, const char *&PrevSpec,
648  unsigned &DiagID, Decl *Rep, bool Owned,
649  const PrintingPolicy &Policy);
650 
651  bool SetTypeSpecType(TST T, SourceLocation Loc, const char *&PrevSpec,
652  unsigned &DiagID, Expr *Rep,
653  const PrintingPolicy &policy);
654  bool SetTypeAltiVecVector(bool isAltiVecVector, SourceLocation Loc,
655  const char *&PrevSpec, unsigned &DiagID,
656  const PrintingPolicy &Policy);
657  bool SetTypeAltiVecPixel(bool isAltiVecPixel, SourceLocation Loc,
658  const char *&PrevSpec, unsigned &DiagID,
659  const PrintingPolicy &Policy);
660  bool SetTypeAltiVecBool(bool isAltiVecBool, SourceLocation Loc,
661  const char *&PrevSpec, unsigned &DiagID,
662  const PrintingPolicy &Policy);
663  bool SetTypePipe(bool isPipe, SourceLocation Loc,
664  const char *&PrevSpec, unsigned &DiagID,
665  const PrintingPolicy &Policy);
666  bool SetTypeSpecError();
667  void UpdateDeclRep(Decl *Rep) {
668  assert(isDeclRep((TST) TypeSpecType));
669  DeclRep = Rep;
670  }
672  assert(isTypeRep((TST) TypeSpecType));
673  TypeRep = Rep;
674  }
675  void UpdateExprRep(Expr *Rep) {
676  assert(isExprRep((TST) TypeSpecType));
677  ExprRep = Rep;
678  }
679 
680  bool SetTypeQual(TQ T, SourceLocation Loc, const char *&PrevSpec,
681  unsigned &DiagID, const LangOptions &Lang);
682 
683  bool setFunctionSpecInline(SourceLocation Loc, const char *&PrevSpec,
684  unsigned &DiagID);
685  bool setFunctionSpecForceInline(SourceLocation Loc, const char *&PrevSpec,
686  unsigned &DiagID);
687  bool setFunctionSpecVirtual(SourceLocation Loc, const char *&PrevSpec,
688  unsigned &DiagID);
689  bool setFunctionSpecExplicit(SourceLocation Loc, const char *&PrevSpec,
690  unsigned &DiagID);
691  bool setFunctionSpecNoreturn(SourceLocation Loc, const char *&PrevSpec,
692  unsigned &DiagID);
693 
694  bool SetFriendSpec(SourceLocation Loc, const char *&PrevSpec,
695  unsigned &DiagID);
696  bool setModulePrivateSpec(SourceLocation Loc, const char *&PrevSpec,
697  unsigned &DiagID);
698  bool SetConstexprSpec(SourceLocation Loc, const char *&PrevSpec,
699  unsigned &DiagID);
700  bool SetConceptSpec(SourceLocation Loc, const char *&PrevSpec,
701  unsigned &DiagID);
702 
703  bool isFriendSpecified() const { return Friend_specified; }
704  SourceLocation getFriendSpecLoc() const { return FriendLoc; }
705 
706  bool isModulePrivateSpecified() const { return ModulePrivateLoc.isValid(); }
707  SourceLocation getModulePrivateSpecLoc() const { return ModulePrivateLoc; }
708 
709  bool isConstexprSpecified() const { return Constexpr_specified; }
710  SourceLocation getConstexprSpecLoc() const { return ConstexprLoc; }
711 
712  bool isConceptSpecified() const { return Concept_specified; }
713  SourceLocation getConceptSpecLoc() const { return ConceptLoc; }
714 
716  Constexpr_specified = false;
717  ConstexprLoc = SourceLocation();
718  }
719 
721  Concept_specified = false;
722  ConceptLoc = SourceLocation();
723  }
724 
726  return Attrs.getPool();
727  }
728 
729  /// \brief Concatenates two attribute lists.
730  ///
731  /// The GCC attribute syntax allows for the following:
732  ///
733  /// \code
734  /// short __attribute__(( unused, deprecated ))
735  /// int __attribute__(( may_alias, aligned(16) )) var;
736  /// \endcode
737  ///
738  /// This declares 4 attributes using 2 lists. The following syntax is
739  /// also allowed and equivalent to the previous declaration.
740  ///
741  /// \code
742  /// short __attribute__((unused)) __attribute__((deprecated))
743  /// int __attribute__((may_alias)) __attribute__((aligned(16))) var;
744  /// \endcode
745  ///
747  Attrs.addAll(AL);
748  }
749 
750  bool hasAttributes() const { return !Attrs.empty(); }
751 
752  ParsedAttributes &getAttributes() { return Attrs; }
753  const ParsedAttributes &getAttributes() const { return Attrs; }
754 
756  Attrs.takeAllFrom(attrs);
757  }
758 
759  /// Finish - This does final analysis of the declspec, issuing diagnostics for
760  /// things like "_Imaginary" (lacking an FP type). After calling this method,
761  /// DeclSpec is guaranteed self-consistent, even if an error occurred.
762  void Finish(Sema &S, const PrintingPolicy &Policy);
763 
765  return writtenBS;
766  }
767 
768  ObjCDeclSpec *getObjCQualifiers() const { return ObjCQualifiers; }
769  void setObjCQualifiers(ObjCDeclSpec *quals) { ObjCQualifiers = quals; }
770 
771  /// \brief Checks if this DeclSpec can stand alone, without a Declarator.
772  ///
773  /// Only tag declspecs can stand alone.
774  bool isMissingDeclaratorOk();
775 };
776 
777 /// \brief Captures information about "declaration specifiers" specific to
778 /// Objective-C.
780 public:
781  /// ObjCDeclQualifier - Qualifier used on types in method
782  /// declarations. Not all combinations are sensible. Parameters
783  /// can be one of { in, out, inout } with one of { bycopy, byref }.
784  /// Returns can either be { oneway } or not.
785  ///
786  /// This should be kept in sync with Decl::ObjCDeclQualifier.
788  DQ_None = 0x0,
789  DQ_In = 0x1,
790  DQ_Inout = 0x2,
791  DQ_Out = 0x4,
792  DQ_Bycopy = 0x8,
793  DQ_Byref = 0x10,
794  DQ_Oneway = 0x20,
795  DQ_CSNullability = 0x40
796  };
797 
798  /// PropertyAttributeKind - list of property attributes.
799  /// Keep this list in sync with LLVM's Dwarf.h ApplePropertyAttributes.
801  DQ_PR_noattr = 0x0,
802  DQ_PR_readonly = 0x01,
803  DQ_PR_getter = 0x02,
804  DQ_PR_assign = 0x04,
805  DQ_PR_readwrite = 0x08,
806  DQ_PR_retain = 0x10,
807  DQ_PR_copy = 0x20,
808  DQ_PR_nonatomic = 0x40,
809  DQ_PR_setter = 0x80,
810  DQ_PR_atomic = 0x100,
811  DQ_PR_weak = 0x200,
812  DQ_PR_strong = 0x400,
813  DQ_PR_unsafe_unretained = 0x800,
814  DQ_PR_nullability = 0x1000,
815  DQ_PR_null_resettable = 0x2000,
816  DQ_PR_class = 0x4000
817  };
818 
820  : objcDeclQualifier(DQ_None), PropertyAttributes(DQ_PR_noattr),
821  Nullability(0), GetterName(nullptr), SetterName(nullptr) { }
822 
824  return (ObjCDeclQualifier)objcDeclQualifier;
825  }
827  objcDeclQualifier = (ObjCDeclQualifier) (objcDeclQualifier | DQVal);
828  }
830  objcDeclQualifier = (ObjCDeclQualifier) (objcDeclQualifier & ~DQVal);
831  }
832 
834  return ObjCPropertyAttributeKind(PropertyAttributes);
835  }
837  PropertyAttributes =
838  (ObjCPropertyAttributeKind)(PropertyAttributes | PRVal);
839  }
840 
842  assert(((getObjCDeclQualifier() & DQ_CSNullability) ||
843  (getPropertyAttributes() & DQ_PR_nullability)) &&
844  "Objective-C declspec doesn't have nullability");
845  return static_cast<NullabilityKind>(Nullability);
846  }
847 
849  assert(((getObjCDeclQualifier() & DQ_CSNullability) ||
850  (getPropertyAttributes() & DQ_PR_nullability)) &&
851  "Objective-C declspec doesn't have nullability");
852  return NullabilityLoc;
853  }
854 
856  assert(((getObjCDeclQualifier() & DQ_CSNullability) ||
857  (getPropertyAttributes() & DQ_PR_nullability)) &&
858  "Set the nullability declspec or property attribute first");
859  Nullability = static_cast<unsigned>(kind);
860  NullabilityLoc = loc;
861  }
862 
863  const IdentifierInfo *getGetterName() const { return GetterName; }
864  IdentifierInfo *getGetterName() { return GetterName; }
865  SourceLocation getGetterNameLoc() const { return GetterNameLoc; }
867  GetterName = name;
868  GetterNameLoc = loc;
869  }
870 
871  const IdentifierInfo *getSetterName() const { return SetterName; }
872  IdentifierInfo *getSetterName() { return SetterName; }
873  SourceLocation getSetterNameLoc() const { return SetterNameLoc; }
875  SetterName = name;
876  SetterNameLoc = loc;
877  }
878 
879 private:
880  // FIXME: These two are unrelated and mutually exclusive. So perhaps
881  // we can put them in a union to reflect their mutual exclusivity
882  // (space saving is negligible).
883  unsigned objcDeclQualifier : 7;
884 
885  // NOTE: VC++ treats enums as signed, avoid using ObjCPropertyAttributeKind
886  unsigned PropertyAttributes : 15;
887 
888  unsigned Nullability : 2;
889 
890  SourceLocation NullabilityLoc;
891 
892  IdentifierInfo *GetterName; // getter name or NULL if no getter
893  IdentifierInfo *SetterName; // setter name or NULL if no setter
894  SourceLocation GetterNameLoc; // location of the getter attribute's value
895  SourceLocation SetterNameLoc; // location of the setter attribute's value
896 
897 };
898 
899 /// \brief Represents a C++ unqualified-id that has been parsed.
901 private:
902  UnqualifiedId(const UnqualifiedId &Other) = delete;
903  const UnqualifiedId &operator=(const UnqualifiedId &) = delete;
904 
905 public:
906  /// \brief Describes the kind of unqualified-id parsed.
907  enum IdKind {
908  /// \brief An identifier.
910  /// \brief An overloaded operator name, e.g., operator+.
912  /// \brief A conversion function name, e.g., operator int.
914  /// \brief A user-defined literal name, e.g., operator "" _i.
916  /// \brief A constructor name.
918  /// \brief A constructor named via a template-id.
920  /// \brief A destructor name.
922  /// \brief A template-id, e.g., f<int>.
924  /// \brief An implicit 'self' parameter
926  /// \brief A deduction-guide name (a template-name)
927  IK_DeductionGuideName
928  } Kind;
929 
930  struct OFI {
931  /// \brief The kind of overloaded operator.
933 
934  /// \brief The source locations of the individual tokens that name
935  /// the operator, e.g., the "new", "[", and "]" tokens in
936  /// operator new [].
937  ///
938  /// Different operators have different numbers of tokens in their name,
939  /// up to three. Any remaining source locations in this array will be
940  /// set to an invalid value for operators with fewer than three tokens.
941  unsigned SymbolLocations[3];
942  };
943 
944  /// \brief Anonymous union that holds extra data associated with the
945  /// parsed unqualified-id.
946  union {
947  /// \brief When Kind == IK_Identifier, the parsed identifier, or when
948  /// Kind == IK_UserLiteralId, the identifier suffix.
950 
951  /// \brief When Kind == IK_OperatorFunctionId, the overloaded operator
952  /// that we parsed.
953  struct OFI OperatorFunctionId;
954 
955  /// \brief When Kind == IK_ConversionFunctionId, the type that the
956  /// conversion function names.
958 
959  /// \brief When Kind == IK_ConstructorName, the class-name of the type
960  /// whose constructor is being referenced.
962 
963  /// \brief When Kind == IK_DestructorName, the type referred to by the
964  /// class-name.
966 
967  /// \brief When Kind == IK_DeductionGuideName, the parsed template-name.
969 
970  /// \brief When Kind == IK_TemplateId or IK_ConstructorTemplateId,
971  /// the template-id annotation that contains the template name and
972  /// template arguments.
974  };
975 
976  /// \brief The location of the first token that describes this unqualified-id,
977  /// which will be the location of the identifier, "operator" keyword,
978  /// tilde (for a destructor), or the template name of a template-id.
980 
981  /// \brief The location of the last token that describes this unqualified-id.
983 
984  UnqualifiedId() : Kind(IK_Identifier), Identifier(nullptr) { }
985 
986  /// \brief Clear out this unqualified-id, setting it to default (invalid)
987  /// state.
988  void clear() {
989  Kind = IK_Identifier;
990  Identifier = nullptr;
991  StartLocation = SourceLocation();
992  EndLocation = SourceLocation();
993  }
994 
995  /// \brief Determine whether this unqualified-id refers to a valid name.
996  bool isValid() const { return StartLocation.isValid(); }
997 
998  /// \brief Determine whether this unqualified-id refers to an invalid name.
999  bool isInvalid() const { return !isValid(); }
1000 
1001  /// \brief Determine what kind of name we have.
1002  IdKind getKind() const { return Kind; }
1003  void setKind(IdKind kind) { Kind = kind; }
1004 
1005  /// \brief 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.
1010  Kind = IK_Identifier;
1011  Identifier = const_cast<IdentifierInfo *>(Id);
1012  StartLocation = EndLocation = IdLoc;
1013  }
1014 
1015  /// \brief 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  /// \brief 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) {
1039  Kind = IK_ConversionFunctionId;
1040  StartLocation = OperatorLoc;
1041  EndLocation = EndLoc;
1042  ConversionFunctionId = Ty;
1043  }
1044 
1045  /// \brief 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) {
1055  Kind = IK_LiteralOperatorId;
1056  Identifier = const_cast<IdentifierInfo *>(Id);
1057  StartLocation = OpLoc;
1058  EndLocation = IdLoc;
1059  }
1060 
1061  /// \brief 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) {
1071  Kind = IK_ConstructorName;
1072  StartLocation = ClassNameLoc;
1073  EndLocation = EndLoc;
1074  ConstructorName = ClassType;
1075  }
1076 
1077  /// \brief 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  /// \brief 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) {
1094  Kind = IK_DestructorName;
1095  StartLocation = TildeLoc;
1096  EndLocation = EndLoc;
1097  DestructorName = ClassType;
1098  }
1099 
1100  /// \brief 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  /// \brief 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) {
1114  Kind = IK_DeductionGuideName;
1115  TemplateName = Template;
1116  StartLocation = EndLocation = TemplateLoc;
1117  }
1118 
1119  /// \brief 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 /// \brief A set of tokens that has been cached for later parsing.
1129 
1130 /// \brief 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  /// \brief 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  /// \brief The location of the ref-qualifier, if any.
1288  ///
1289  /// If this is an invalid location, there is no ref-qualifier.
1291 
1292  /// \brief The location of the const-qualifier, if any.
1293  ///
1294  /// If this is an invalid location, there is no const-qualifier.
1296 
1297  /// \brief The location of the volatile-qualifier, if any.
1298  ///
1299  /// If this is an invalid location, there is no volatile-qualifier.
1301 
1302  /// \brief The location of the restrict-qualifier, if any.
1303  ///
1304  /// If this is an invalid location, there is no restrict-qualifier.
1306 
1307  /// \brief The location of the 'mutable' qualifer in a lambda-declarator, if
1308  /// any.
1309  unsigned MutableLoc;
1310 
1311  /// \brief The beginning location of the exception specification, if any.
1313 
1314  /// \brief 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  /// \brief 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  /// \brief Pointer to the expression in the noexcept-specifier of this
1329  /// function, if it has one.
1331 
1332  /// \brief 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  /// \brief If HasTrailingReturnType is true, this is the trailing return
1343  /// type specified.
1345 
1346  /// \brief 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  /// \brief Retrieve the location of the ref-qualifier, if any.
1409  return SourceLocation::getFromRawEncoding(RefQualifierLoc);
1410  }
1411 
1412  /// \brief Retrieve the location of the 'const' qualifier, if any.
1414  return SourceLocation::getFromRawEncoding(ConstQualifierLoc);
1415  }
1416 
1417  /// \brief Retrieve the location of the 'volatile' qualifier, if any.
1419  return SourceLocation::getFromRawEncoding(VolatileQualifierLoc);
1420  }
1421 
1422  /// \brief Retrieve the location of the 'restrict' qualifier, if any.
1424  return SourceLocation::getFromRawEncoding(RestrictQualifierLoc);
1425  }
1426 
1427  /// \brief Retrieve the location of the 'mutable' qualifier, if any.
1429  return SourceLocation::getFromRawEncoding(MutableLoc);
1430  }
1431 
1432  /// \brief Determine whether this function declaration contains a
1433  /// ref-qualifier.
1434  bool hasRefQualifier() const { return getRefQualifierLoc().isValid(); }
1435 
1436  /// \brief Determine whether this lambda-declarator contains a 'mutable'
1437  /// qualifier.
1438  bool hasMutableQualifier() const { return getMutableLoc().isValid(); }
1439 
1440  /// \brief Get the type of exception specification this function has.
1442  return static_cast<ExceptionSpecificationType>(ExceptionSpecType);
1443  }
1444 
1445  /// \brief Get the number of dynamic exception specifications.
1446  unsigned getNumExceptions() const {
1447  assert(ExceptionSpecType != EST_None);
1448  return NumExceptionsOrDecls;
1449  }
1450 
1451  /// \brief 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  /// \brief Determine whether this function declarator had a
1459  /// trailing-return-type.
1460  bool hasTrailingReturnType() const { return HasTrailingReturnType; }
1461 
1462  /// \brief 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  /// \brief 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  /// \brief 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  /// \brief 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  /// \brief 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  /// \brief 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  /// \brief 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  /// \brief 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 /// \brief Described the kind of function definition (if any) provided for
1714 /// a function.
1720 };
1721 
1722 /// \brief Information about one declarator, including the parsed type
1723 /// information and the identifier.
1724 ///
1725 /// When the declarator is fully formed, this is turned into the appropriate
1726 /// Decl object.
1727 ///
1728 /// Declarators come in two types: normal declarators and abstract declarators.
1729 /// Abstract declarators are used when parsing types, and don't have an
1730 /// identifier. Normal declarators do have ID's.
1731 ///
1732 /// Instances of this class should be a transient object that lives on the
1733 /// stack, not objects that are allocated in large quantities on the heap.
1734 class Declarator {
1735 public:
1736  enum TheContext {
1737  FileContext, // File scope declaration.
1738  PrototypeContext, // Within a function prototype.
1739  ObjCResultContext, // An ObjC method result type.
1740  ObjCParameterContext,// An ObjC method parameter type.
1741  KNRTypeListContext, // K&R type definition list for formals.
1742  TypeNameContext, // Abstract declarator for types.
1743  FunctionalCastContext, // Type in a C++ functional cast expression.
1744  MemberContext, // Struct/Union field.
1745  BlockContext, // Declaration within a block in a function.
1746  ForContext, // Declaration within first part of a for loop.
1747  InitStmtContext, // Declaration within optional init stmt of if/switch.
1748  ConditionContext, // Condition declaration in a C++ if/switch/while/for.
1749  TemplateParamContext,// Within a template parameter list.
1750  CXXNewContext, // C++ new-expression.
1751  CXXCatchContext, // C++ catch exception-declaration
1752  ObjCCatchContext, // Objective-C catch exception-declaration
1753  BlockLiteralContext, // Block literal declarator.
1754  LambdaExprContext, // Lambda-expression declarator.
1755  LambdaExprParameterContext, // Lambda-expression parameter declarator.
1756  ConversionIdContext, // C++ conversion-type-id.
1757  TrailingReturnContext, // C++11 trailing-type-specifier.
1758  TemplateTypeArgContext, // Template type argument.
1759  AliasDeclContext, // C++11 alias-declaration.
1760  AliasTemplateContext // C++11 alias-declaration template.
1761  };
1762 
1763 private:
1764  const DeclSpec &DS;
1765  CXXScopeSpec SS;
1766  UnqualifiedId Name;
1767  SourceRange Range;
1768 
1769  /// \brief Where we are parsing this declarator.
1770  TheContext Context;
1771 
1772  /// The C++17 structured binding, if any. This is an alternative to a Name.
1773  DecompositionDeclarator BindingGroup;
1774 
1775  /// DeclTypeInfo - This holds each type that the declarator includes as it is
1776  /// parsed. This is pushed from the identifier out, which means that element
1777  /// #0 will be the most closely bound to the identifier, and
1778  /// DeclTypeInfo.back() will be the least closely bound.
1779  SmallVector<DeclaratorChunk, 8> DeclTypeInfo;
1780 
1781  /// InvalidType - Set by Sema::GetTypeForDeclarator().
1782  unsigned InvalidType : 1;
1783 
1784  /// GroupingParens - Set by Parser::ParseParenDeclarator().
1785  unsigned GroupingParens : 1;
1786 
1787  /// FunctionDefinition - Is this Declarator for a function or member
1788  /// definition and, if so, what kind?
1789  ///
1790  /// Actually a FunctionDefinitionKind.
1791  unsigned FunctionDefinition : 2;
1792 
1793  /// \brief Is this Declarator a redeclaration?
1794  unsigned Redeclaration : 1;
1795 
1796  /// \brief true if the declaration is preceded by \c __extension__.
1797  unsigned Extension : 1;
1798 
1799  /// Indicates whether this is an Objective-C instance variable.
1800  unsigned ObjCIvar : 1;
1801 
1802  /// Indicates whether this is an Objective-C 'weak' property.
1803  unsigned ObjCWeakProperty : 1;
1804 
1805  /// Indicates whether the InlineParams / InlineBindings storage has been used.
1806  unsigned InlineStorageUsed : 1;
1807 
1808  /// Attrs - Attributes.
1809  ParsedAttributes Attrs;
1810 
1811  /// \brief The asm label, if specified.
1812  Expr *AsmLabel;
1813 
1814 #ifndef _MSC_VER
1815  union {
1816 #endif
1817  /// InlineParams - This is a local array used for the first function decl
1818  /// chunk to avoid going to the heap for the common case when we have one
1819  /// function chunk in the declarator.
1820  DeclaratorChunk::ParamInfo InlineParams[16];
1822 #ifndef _MSC_VER
1823  };
1824 #endif
1825 
1826  /// \brief If this is the second or subsequent declarator in this declaration,
1827  /// the location of the comma before this declarator.
1828  SourceLocation CommaLoc;
1829 
1830  /// \brief If provided, the source location of the ellipsis used to describe
1831  /// this declarator as a parameter pack.
1832  SourceLocation EllipsisLoc;
1833 
1834  friend struct DeclaratorChunk;
1835 
1836 public:
1838  : DS(ds), Range(ds.getSourceRange()), Context(C),
1839  InvalidType(DS.getTypeSpecType() == DeclSpec::TST_error),
1840  GroupingParens(false), FunctionDefinition(FDK_Declaration),
1841  Redeclaration(false), Extension(false), ObjCIvar(false),
1842  ObjCWeakProperty(false), InlineStorageUsed(false),
1843  Attrs(ds.getAttributePool().getFactory()), AsmLabel(nullptr) {}
1844 
1846  clear();
1847  }
1848  /// getDeclSpec - Return the declaration-specifier that this declarator was
1849  /// declared with.
1850  const DeclSpec &getDeclSpec() const { return DS; }
1851 
1852  /// getMutableDeclSpec - Return a non-const version of the DeclSpec. This
1853  /// should be used with extreme care: declspecs can often be shared between
1854  /// multiple declarators, so mutating the DeclSpec affects all of the
1855  /// Declarators. This should only be done when the declspec is known to not
1856  /// be shared or when in error recovery etc.
1857  DeclSpec &getMutableDeclSpec() { return const_cast<DeclSpec &>(DS); }
1858 
1860  return Attrs.getPool();
1861  }
1862 
1863  /// getCXXScopeSpec - Return the C++ scope specifier (global scope or
1864  /// nested-name-specifier) that is part of the declarator-id.
1865  const CXXScopeSpec &getCXXScopeSpec() const { return SS; }
1866  CXXScopeSpec &getCXXScopeSpec() { return SS; }
1867 
1868  /// \brief Retrieve the name specified by this declarator.
1869  UnqualifiedId &getName() { return Name; }
1870 
1872  return BindingGroup;
1873  }
1874 
1875  TheContext getContext() const { return Context; }
1876 
1877  bool isPrototypeContext() const {
1878  return (Context == PrototypeContext ||
1879  Context == ObjCParameterContext ||
1880  Context == ObjCResultContext ||
1881  Context == LambdaExprParameterContext);
1882  }
1883 
1884  /// \brief Get the source range that spans this declarator.
1885  SourceRange getSourceRange() const LLVM_READONLY { return Range; }
1886  SourceLocation getLocStart() const LLVM_READONLY { return Range.getBegin(); }
1887  SourceLocation getLocEnd() const LLVM_READONLY { return Range.getEnd(); }
1888 
1889  void SetSourceRange(SourceRange R) { Range = R; }
1890  /// SetRangeBegin - Set the start of the source range to Loc, unless it's
1891  /// invalid.
1893  if (!Loc.isInvalid())
1894  Range.setBegin(Loc);
1895  }
1896  /// SetRangeEnd - Set the end of the source range to Loc, unless it's invalid.
1898  if (!Loc.isInvalid())
1899  Range.setEnd(Loc);
1900  }
1901  /// ExtendWithDeclSpec - Extend the declarator source range to include the
1902  /// given declspec, unless its location is invalid. Adopts the range start if
1903  /// the current range start is invalid.
1904  void ExtendWithDeclSpec(const DeclSpec &DS) {
1905  SourceRange SR = DS.getSourceRange();
1906  if (Range.getBegin().isInvalid())
1907  Range.setBegin(SR.getBegin());
1908  if (!SR.getEnd().isInvalid())
1909  Range.setEnd(SR.getEnd());
1910  }
1911 
1912  /// \brief Reset the contents of this Declarator.
1913  void clear() {
1914  SS.clear();
1915  Name.clear();
1916  Range = DS.getSourceRange();
1917  BindingGroup.clear();
1918 
1919  for (unsigned i = 0, e = DeclTypeInfo.size(); i != e; ++i)
1920  DeclTypeInfo[i].destroy();
1921  DeclTypeInfo.clear();
1922  Attrs.clear();
1923  AsmLabel = nullptr;
1924  InlineStorageUsed = false;
1925  ObjCIvar = false;
1926  ObjCWeakProperty = false;
1927  CommaLoc = SourceLocation();
1928  EllipsisLoc = SourceLocation();
1929  }
1930 
1931  /// mayOmitIdentifier - Return true if the identifier is either optional or
1932  /// not allowed. This is true for typenames, prototypes, and template
1933  /// parameter lists.
1934  bool mayOmitIdentifier() const {
1935  switch (Context) {
1936  case FileContext:
1937  case KNRTypeListContext:
1938  case MemberContext:
1939  case BlockContext:
1940  case ForContext:
1941  case InitStmtContext:
1942  case ConditionContext:
1943  return false;
1944 
1945  case TypeNameContext:
1946  case FunctionalCastContext:
1947  case AliasDeclContext:
1948  case AliasTemplateContext:
1949  case PrototypeContext:
1950  case LambdaExprParameterContext:
1951  case ObjCParameterContext:
1952  case ObjCResultContext:
1953  case TemplateParamContext:
1954  case CXXNewContext:
1955  case CXXCatchContext:
1956  case ObjCCatchContext:
1957  case BlockLiteralContext:
1958  case LambdaExprContext:
1959  case ConversionIdContext:
1960  case TemplateTypeArgContext:
1961  case TrailingReturnContext:
1962  return true;
1963  }
1964  llvm_unreachable("unknown context kind!");
1965  }
1966 
1967  /// mayHaveIdentifier - Return true if the identifier is either optional or
1968  /// required. This is true for normal declarators and prototypes, but not
1969  /// typenames.
1970  bool mayHaveIdentifier() const {
1971  switch (Context) {
1972  case FileContext:
1973  case KNRTypeListContext:
1974  case MemberContext:
1975  case BlockContext:
1976  case ForContext:
1977  case InitStmtContext:
1978  case ConditionContext:
1979  case PrototypeContext:
1980  case LambdaExprParameterContext:
1981  case TemplateParamContext:
1982  case CXXCatchContext:
1983  case ObjCCatchContext:
1984  return true;
1985 
1986  case TypeNameContext:
1987  case FunctionalCastContext:
1988  case CXXNewContext:
1989  case AliasDeclContext:
1990  case AliasTemplateContext:
1991  case ObjCParameterContext:
1992  case ObjCResultContext:
1993  case BlockLiteralContext:
1994  case LambdaExprContext:
1995  case ConversionIdContext:
1996  case TemplateTypeArgContext:
1997  case TrailingReturnContext:
1998  return false;
1999  }
2000  llvm_unreachable("unknown context kind!");
2001  }
2002 
2003  /// Return true if the context permits a C++17 decomposition declarator.
2005  switch (Context) {
2006  case FileContext:
2007  // FIXME: It's not clear that the proposal meant to allow file-scope
2008  // structured bindings, but it does.
2009  case BlockContext:
2010  case ForContext:
2011  case InitStmtContext:
2012  return true;
2013 
2014  case ConditionContext:
2015  case MemberContext:
2016  case PrototypeContext:
2017  case TemplateParamContext:
2018  // Maybe one day...
2019  return false;
2020 
2021  // These contexts don't allow any kind of non-abstract declarator.
2022  case KNRTypeListContext:
2023  case TypeNameContext:
2024  case FunctionalCastContext:
2025  case AliasDeclContext:
2026  case AliasTemplateContext:
2027  case LambdaExprParameterContext:
2028  case ObjCParameterContext:
2029  case ObjCResultContext:
2030  case CXXNewContext:
2031  case CXXCatchContext:
2032  case ObjCCatchContext:
2033  case BlockLiteralContext:
2034  case LambdaExprContext:
2035  case ConversionIdContext:
2036  case TemplateTypeArgContext:
2037  case TrailingReturnContext:
2038  return false;
2039  }
2040  llvm_unreachable("unknown context kind!");
2041  }
2042 
2043  /// mayBeFollowedByCXXDirectInit - Return true if the declarator can be
2044  /// followed by a C++ direct initializer, e.g. "int x(1);".
2046  if (hasGroupingParens()) return false;
2047 
2048  if (getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_typedef)
2049  return false;
2050 
2051  if (getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_extern &&
2052  Context != FileContext)
2053  return false;
2054 
2055  // Special names can't have direct initializers.
2056  if (Name.getKind() != UnqualifiedId::IK_Identifier)
2057  return false;
2058 
2059  switch (Context) {
2060  case FileContext:
2061  case BlockContext:
2062  case ForContext:
2063  case InitStmtContext:
2064  return true;
2065 
2066  case ConditionContext:
2067  // This may not be followed by a direct initializer, but it can't be a
2068  // function declaration either, and we'd prefer to perform a tentative
2069  // parse in order to produce the right diagnostic.
2070  return true;
2071 
2072  case KNRTypeListContext:
2073  case MemberContext:
2074  case PrototypeContext:
2075  case LambdaExprParameterContext:
2076  case ObjCParameterContext:
2077  case ObjCResultContext:
2078  case TemplateParamContext:
2079  case CXXCatchContext:
2080  case ObjCCatchContext:
2081  case TypeNameContext:
2082  case FunctionalCastContext: // FIXME
2083  case CXXNewContext:
2084  case AliasDeclContext:
2085  case AliasTemplateContext:
2086  case BlockLiteralContext:
2087  case LambdaExprContext:
2088  case ConversionIdContext:
2089  case TemplateTypeArgContext:
2090  case TrailingReturnContext:
2091  return false;
2092  }
2093  llvm_unreachable("unknown context kind!");
2094  }
2095 
2096  /// isPastIdentifier - Return true if we have parsed beyond the point where
2097  /// the name would appear. (This may happen even if we haven't actually parsed
2098  /// a name, perhaps because this context doesn't require one.)
2099  bool isPastIdentifier() const { return Name.isValid(); }
2100 
2101  /// hasName - Whether this declarator has a name, which might be an
2102  /// identifier (accessible via getIdentifier()) or some kind of
2103  /// special C++ name (constructor, destructor, etc.), or a structured
2104  /// binding (which is not exactly a name, but occupies the same position).
2105  bool hasName() const {
2106  return Name.getKind() != UnqualifiedId::IK_Identifier || Name.Identifier ||
2107  isDecompositionDeclarator();
2108  }
2109 
2110  /// Return whether this declarator is a decomposition declarator.
2112  return BindingGroup.isSet();
2113  }
2114 
2116  if (Name.getKind() == UnqualifiedId::IK_Identifier)
2117  return Name.Identifier;
2118 
2119  return nullptr;
2120  }
2122 
2123  /// \brief Set the name of this declarator to be the given identifier.
2125  Name.setIdentifier(Id, IdLoc);
2126  }
2127 
2128  /// Set the decomposition bindings for this declarator.
2129  void
2130  setDecompositionBindings(SourceLocation LSquareLoc,
2132  SourceLocation RSquareLoc);
2133 
2134  /// AddTypeInfo - Add a chunk to this declarator. Also extend the range to
2135  /// EndLoc, which should be the last token of the chunk.
2137  ParsedAttributes &attrs,
2138  SourceLocation EndLoc) {
2139  DeclTypeInfo.push_back(TI);
2140  DeclTypeInfo.back().getAttrListRef() = attrs.getList();
2141  getAttributePool().takeAllFrom(attrs.getPool());
2142 
2143  if (!EndLoc.isInvalid())
2144  SetRangeEnd(EndLoc);
2145  }
2146 
2147  /// \brief Add a new innermost chunk to this declarator.
2149  DeclTypeInfo.insert(DeclTypeInfo.begin(), TI);
2150  }
2151 
2152  /// \brief Return the number of types applied to this declarator.
2153  unsigned getNumTypeObjects() const { return DeclTypeInfo.size(); }
2154 
2155  /// Return the specified TypeInfo from this declarator. TypeInfo #0 is
2156  /// closest to the identifier.
2157  const DeclaratorChunk &getTypeObject(unsigned i) const {
2158  assert(i < DeclTypeInfo.size() && "Invalid type chunk");
2159  return DeclTypeInfo[i];
2160  }
2162  assert(i < DeclTypeInfo.size() && "Invalid type chunk");
2163  return DeclTypeInfo[i];
2164  }
2165 
2167  typedef llvm::iterator_range<type_object_iterator> type_object_range;
2168 
2169  /// Returns the range of type objects, from the identifier outwards.
2170  type_object_range type_objects() const {
2171  return type_object_range(DeclTypeInfo.begin(), DeclTypeInfo.end());
2172  }
2173 
2175  assert(!DeclTypeInfo.empty() && "No type chunks to drop.");
2176  DeclTypeInfo.front().destroy();
2177  DeclTypeInfo.erase(DeclTypeInfo.begin());
2178  }
2179 
2180  /// Return the innermost (closest to the declarator) chunk of this
2181  /// declarator that is not a parens chunk, or null if there are no
2182  /// non-parens chunks.
2184  for (unsigned i = 0, i_end = DeclTypeInfo.size(); i < i_end; ++i) {
2185  if (!DeclTypeInfo[i].isParen())
2186  return &DeclTypeInfo[i];
2187  }
2188  return nullptr;
2189  }
2190 
2191  /// Return the outermost (furthest from the declarator) chunk of
2192  /// this declarator that is not a parens chunk, or null if there are
2193  /// no non-parens chunks.
2195  for (unsigned i = DeclTypeInfo.size(), i_end = 0; i != i_end; --i) {
2196  if (!DeclTypeInfo[i-1].isParen())
2197  return &DeclTypeInfo[i-1];
2198  }
2199  return nullptr;
2200  }
2201 
2202  /// isArrayOfUnknownBound - This method returns true if the declarator
2203  /// is a declarator for an array of unknown bound (looking through
2204  /// parentheses).
2205  bool isArrayOfUnknownBound() const {
2206  const DeclaratorChunk *chunk = getInnermostNonParenChunk();
2207  return (chunk && chunk->Kind == DeclaratorChunk::Array &&
2208  !chunk->Arr.NumElts);
2209  }
2210 
2211  /// isFunctionDeclarator - This method returns true if the declarator
2212  /// is a function declarator (looking through parentheses).
2213  /// If true is returned, then the reference type parameter idx is
2214  /// assigned with the index of the declaration chunk.
2215  bool isFunctionDeclarator(unsigned& idx) const {
2216  for (unsigned i = 0, i_end = DeclTypeInfo.size(); i < i_end; ++i) {
2217  switch (DeclTypeInfo[i].Kind) {
2219  idx = i;
2220  return true;
2222  continue;
2228  case DeclaratorChunk::Pipe:
2229  return false;
2230  }
2231  llvm_unreachable("Invalid type chunk");
2232  }
2233  return false;
2234  }
2235 
2236  /// isFunctionDeclarator - Once this declarator is fully parsed and formed,
2237  /// this method returns true if the identifier is a function declarator
2238  /// (looking through parentheses).
2239  bool isFunctionDeclarator() const {
2240  unsigned index;
2241  return isFunctionDeclarator(index);
2242  }
2243 
2244  /// getFunctionTypeInfo - Retrieves the function type info object
2245  /// (looking through parentheses).
2247  assert(isFunctionDeclarator() && "Not a function declarator!");
2248  unsigned index = 0;
2249  isFunctionDeclarator(index);
2250  return DeclTypeInfo[index].Fun;
2251  }
2252 
2253  /// getFunctionTypeInfo - Retrieves the function type info object
2254  /// (looking through parentheses).
2256  return const_cast<Declarator*>(this)->getFunctionTypeInfo();
2257  }
2258 
2259  /// \brief Determine whether the declaration that will be produced from
2260  /// this declaration will be a function.
2261  ///
2262  /// A declaration can declare a function even if the declarator itself
2263  /// isn't a function declarator, if the type specifier refers to a function
2264  /// type. This routine checks for both cases.
2265  bool isDeclarationOfFunction() const;
2266 
2267  /// \brief Return true if this declaration appears in a context where a
2268  /// function declarator would be a function declaration.
2270  if (getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_typedef)
2271  return false;
2272 
2273  switch (Context) {
2274  case FileContext:
2275  case MemberContext:
2276  case BlockContext:
2277  case ForContext:
2278  case InitStmtContext:
2279  return true;
2280 
2281  case ConditionContext:
2282  case KNRTypeListContext:
2283  case TypeNameContext:
2284  case FunctionalCastContext:
2285  case AliasDeclContext:
2286  case AliasTemplateContext:
2287  case PrototypeContext:
2288  case LambdaExprParameterContext:
2289  case ObjCParameterContext:
2290  case ObjCResultContext:
2291  case TemplateParamContext:
2292  case CXXNewContext:
2293  case CXXCatchContext:
2294  case ObjCCatchContext:
2295  case BlockLiteralContext:
2296  case LambdaExprContext:
2297  case ConversionIdContext:
2298  case TemplateTypeArgContext:
2299  case TrailingReturnContext:
2300  return false;
2301  }
2302  llvm_unreachable("unknown context kind!");
2303  }
2304 
2305  /// Determine whether this declaration appears in a context where an
2306  /// expression could appear.
2307  bool isExpressionContext() const {
2308  switch (Context) {
2309  case FileContext:
2310  case KNRTypeListContext:
2311  case MemberContext:
2312  case TypeNameContext: // FIXME: sizeof(...) permits an expression.
2313  case FunctionalCastContext:
2314  case AliasDeclContext:
2315  case AliasTemplateContext:
2316  case PrototypeContext:
2317  case LambdaExprParameterContext:
2318  case ObjCParameterContext:
2319  case ObjCResultContext:
2320  case TemplateParamContext:
2321  case CXXNewContext:
2322  case CXXCatchContext:
2323  case ObjCCatchContext:
2324  case BlockLiteralContext:
2325  case LambdaExprContext:
2326  case ConversionIdContext:
2327  case TrailingReturnContext:
2328  return false;
2329 
2330  case BlockContext:
2331  case ForContext:
2332  case InitStmtContext:
2333  case ConditionContext:
2334  case TemplateTypeArgContext:
2335  return true;
2336  }
2337 
2338  llvm_unreachable("unknown context kind!");
2339  }
2340 
2341  /// \brief Return true if a function declarator at this position would be a
2342  /// function declaration.
2344  if (!isFunctionDeclarationContext())
2345  return false;
2346 
2347  for (unsigned I = 0, N = getNumTypeObjects(); I != N; ++I)
2348  if (getTypeObject(I).Kind != DeclaratorChunk::Paren)
2349  return false;
2350 
2351  return true;
2352  }
2353 
2354  /// \brief Determine whether a trailing return type was written (at any
2355  /// level) within this declarator.
2356  bool hasTrailingReturnType() const {
2357  for (const auto &Chunk : type_objects())
2358  if (Chunk.Kind == DeclaratorChunk::Function &&
2359  Chunk.Fun.hasTrailingReturnType())
2360  return true;
2361  return false;
2362  }
2363 
2364  /// takeAttributes - Takes attributes from the given parsed-attributes
2365  /// set and add them to this declarator.
2366  ///
2367  /// These examples both add 3 attributes to "var":
2368  /// short int var __attribute__((aligned(16),common,deprecated));
2369  /// short int x, __attribute__((aligned(16)) var
2370  /// __attribute__((common,deprecated));
2371  ///
2372  /// Also extends the range of the declarator.
2374  Attrs.takeAllFrom(attrs);
2375 
2376  if (!lastLoc.isInvalid())
2377  SetRangeEnd(lastLoc);
2378  }
2379 
2380  const AttributeList *getAttributes() const { return Attrs.getList(); }
2381  AttributeList *getAttributes() { return Attrs.getList(); }
2382 
2383  AttributeList *&getAttrListRef() { return Attrs.getListRef(); }
2384 
2385  /// hasAttributes - do we contain any attributes?
2386  bool hasAttributes() const {
2387  if (getAttributes() || getDeclSpec().hasAttributes()) return true;
2388  for (unsigned i = 0, e = getNumTypeObjects(); i != e; ++i)
2389  if (getTypeObject(i).getAttrs())
2390  return true;
2391  return false;
2392  }
2393 
2394  /// \brief Return a source range list of C++11 attributes associated
2395  /// with the declarator.
2397  AttributeList *AttrList = Attrs.getList();
2398  while (AttrList) {
2399  if (AttrList->isCXX11Attribute())
2400  Ranges.push_back(AttrList->getRange());
2401  AttrList = AttrList->getNext();
2402  }
2403  }
2404 
2405  void setAsmLabel(Expr *E) { AsmLabel = E; }
2406  Expr *getAsmLabel() const { return AsmLabel; }
2407 
2408  void setExtension(bool Val = true) { Extension = Val; }
2409  bool getExtension() const { return Extension; }
2410 
2411  void setObjCIvar(bool Val = true) { ObjCIvar = Val; }
2412  bool isObjCIvar() const { return ObjCIvar; }
2413 
2414  void setObjCWeakProperty(bool Val = true) { ObjCWeakProperty = Val; }
2415  bool isObjCWeakProperty() const { return ObjCWeakProperty; }
2416 
2417  void setInvalidType(bool Val = true) { InvalidType = Val; }
2418  bool isInvalidType() const {
2419  return InvalidType || DS.getTypeSpecType() == DeclSpec::TST_error;
2420  }
2421 
2422  void setGroupingParens(bool flag) { GroupingParens = flag; }
2423  bool hasGroupingParens() const { return GroupingParens; }
2424 
2425  bool isFirstDeclarator() const { return !CommaLoc.isValid(); }
2426  SourceLocation getCommaLoc() const { return CommaLoc; }
2427  void setCommaLoc(SourceLocation CL) { CommaLoc = CL; }
2428 
2429  bool hasEllipsis() const { return EllipsisLoc.isValid(); }
2430  SourceLocation getEllipsisLoc() const { return EllipsisLoc; }
2431  void setEllipsisLoc(SourceLocation EL) { EllipsisLoc = EL; }
2432 
2434  FunctionDefinition = Val;
2435  }
2436 
2437  bool isFunctionDefinition() const {
2438  return getFunctionDefinitionKind() != FDK_Declaration;
2439  }
2440 
2442  return (FunctionDefinitionKind)FunctionDefinition;
2443  }
2444 
2445  /// Returns true if this declares a real member and not a friend.
2447  return getContext() == MemberContext && !getDeclSpec().isFriendSpecified();
2448  }
2449 
2450  /// Returns true if this declares a static member. This cannot be called on a
2451  /// declarator outside of a MemberContext because we won't know until
2452  /// redeclaration time if the decl is static.
2453  bool isStaticMember();
2454 
2455  /// Returns true if this declares a constructor or a destructor.
2456  bool isCtorOrDtor();
2457 
2458  void setRedeclaration(bool Val) { Redeclaration = Val; }
2459  bool isRedeclaration() const { return Redeclaration; }
2460 };
2461 
2462 /// \brief This little struct is used to capture information about
2463 /// structure field declarators, which is basically just a bitfield size.
2467  explicit FieldDeclarator(const DeclSpec &DS)
2468  : D(DS, Declarator::MemberContext), BitfieldSize(nullptr) { }
2469 };
2470 
2471 /// \brief Represents a C++11 virt-specifier-seq.
2473 public:
2474  enum Specifier {
2475  VS_None = 0,
2476  VS_Override = 1,
2477  VS_Final = 2,
2478  VS_Sealed = 4,
2479  // Represents the __final keyword, which is legal for gcc in pre-C++11 mode.
2480  VS_GNU_Final = 8
2481  };
2482 
2483  VirtSpecifiers() : Specifiers(0), LastSpecifier(VS_None) { }
2484 
2485  bool SetSpecifier(Specifier VS, SourceLocation Loc,
2486  const char *&PrevSpec);
2487 
2488  bool isUnset() const { return Specifiers == 0; }
2489 
2490  bool isOverrideSpecified() const { return Specifiers & VS_Override; }
2491  SourceLocation getOverrideLoc() const { return VS_overrideLoc; }
2492 
2493  bool isFinalSpecified() const { return Specifiers & (VS_Final | VS_Sealed | VS_GNU_Final); }
2494  bool isFinalSpelledSealed() const { return Specifiers & VS_Sealed; }
2495  SourceLocation getFinalLoc() const { return VS_finalLoc; }
2496 
2497  void clear() { Specifiers = 0; }
2498 
2499  static const char *getSpecifierName(Specifier VS);
2500 
2501  SourceLocation getFirstLocation() const { return FirstLocation; }
2502  SourceLocation getLastLocation() const { return LastLocation; }
2503  Specifier getLastSpecifier() const { return LastSpecifier; }
2504 
2505 private:
2506  unsigned Specifiers;
2507  Specifier LastSpecifier;
2508 
2509  SourceLocation VS_overrideLoc, VS_finalLoc;
2510  SourceLocation FirstLocation;
2511  SourceLocation LastLocation;
2512 };
2513 
2515  NoInit, //!< [a]
2516  CopyInit, //!< [a = b], [a = {b}]
2517  DirectInit, //!< [a(b)]
2518  ListInit //!< [a{b}]
2519 };
2520 
2521 /// \brief Represents a complete lambda introducer.
2523  /// \brief An individual capture in a lambda introducer.
2524  struct LambdaCapture {
2533  IdentifierInfo *Id, SourceLocation EllipsisLoc,
2534  LambdaCaptureInitKind InitKind, ExprResult Init,
2535  ParsedType InitCaptureType)
2536  : Kind(Kind), Loc(Loc), Id(Id), EllipsisLoc(EllipsisLoc),
2537  InitKind(InitKind), Init(Init), InitCaptureType(InitCaptureType) {}
2538  };
2539 
2544 
2546  : Default(LCD_None) {}
2547 
2548  /// \brief Append a capture in a lambda introducer.
2550  SourceLocation Loc,
2551  IdentifierInfo* Id,
2552  SourceLocation EllipsisLoc,
2553  LambdaCaptureInitKind InitKind,
2554  ExprResult Init,
2555  ParsedType InitCaptureType) {
2556  Captures.push_back(LambdaCapture(Kind, Loc, Id, EllipsisLoc, InitKind, Init,
2557  InitCaptureType));
2558  }
2559 };
2560 
2561 } // end namespace clang
2562 
2563 #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:579
AttributePool & getAttributePool() const
Definition: DeclSpec.h:1859
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:2246
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
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:1913
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:823
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:979
const DeclaratorChunk & getTypeObject(unsigned i) const
Return the specified TypeInfo from this declarator.
Definition: DeclSpec.h:2157
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:949
NullabilityKind
Describes the nullability of a particular type.
Definition: Specifiers.h:282
UnionParsedType TypeRep
Definition: DeclSpec.h:368
A conversion function name, e.g., operator int.
Definition: DeclSpec.h:913
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:836
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:81
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:779
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:2490
SourceLocation getVolatileQualifierLoc() const
Retrieve the location of the &#39;volatile&#39; qualifier, if any.
Definition: DeclSpec.h:1418
SourceLocation getLParenLoc() const
Definition: DeclSpec.h:1383
bool hasTrailingReturnType() const
Determine whether a trailing return type was written (at any level) within this declarator.
Definition: DeclSpec.h:2356
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
NamespaceDecl - Represent a C++ namespace.
Definition: Decl.h:474
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:2215
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:2529
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:2383
TSCS getThreadStorageClassSpec() const
Definition: DeclSpec.h:450
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:2124
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:2491
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:2269
void setObjCQualifiers(ObjCDeclSpec *quals)
Definition: DeclSpec.h:769
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:1734
void setTypeofParensRange(SourceRange range)
Definition: DeclSpec.h:521
ObjCDeclSpec * getObjCQualifiers() const
Definition: DeclSpec.h:768
TypeSpecifierType
Specifies the kind of type.
Definition: Specifiers.h:45
SourceLocation getFinalLoc() const
Definition: DeclSpec.h:2495
void setBegin(SourceLocation b)
bool hasTypeSpecifier() const
Return true if any type-specifier has been found.
Definition: DeclSpec.h:593
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:871
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:1934
Information about a template-id annotation token.
IdentifierInfo * getGetterName()
Definition: DeclSpec.h:864
SourceRange getTypeSpecWidthRange() const
Definition: DeclSpec.h:509
bool isUnset() const
Definition: DeclSpec.h:2488
Base wrapper for a particular "section" of type source info.
Definition: TypeLoc.h:40
SourceLocation getFriendSpecLoc() const
Definition: DeclSpec.h:704
bool isRedeclaration() const
Definition: DeclSpec.h:2459
TemplateIdAnnotation * TemplateId
When Kind == IK_TemplateId or IK_ConstructorTemplateId, the template-id annotation that contains the ...
Definition: DeclSpec.h:973
C11 _Thread_local.
Definition: Specifiers.h:199
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:2166
SourceLocation getSetterNameLoc() const
Definition: DeclSpec.h:873
SourceLocation getExceptionSpecLocBeg() const
Definition: DeclSpec.h:1395
const WrittenBuiltinSpecs & getWrittenBuiltinSpecs() const
Definition: DeclSpec.h:764
UnionParsedType ConversionFunctionId
When Kind == IK_ConversionFunctionId, the type that the conversion function names.
Definition: DeclSpec.h:957
IdKind getKind() const
Determine what kind of name we have.
Definition: DeclSpec.h:1002
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:128
void DropFirstTypeObject()
Definition: DeclSpec.h:2174
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:2136
SourceLocation getTypeSpecTypeLoc() const
Definition: DeclSpec.h:512
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:421
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:968
Defines the ExceptionSpecificationType enumeration and various utility functions. ...
SourceLocation getConceptSpecLoc() const
Definition: DeclSpec.h:713
OverloadedOperatorKind Operator
The kind of overloaded operator.
Definition: DeclSpec.h:932
Definition: Format.h:1821
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:2437
bool hasAutoTypeSpec() const
Definition: DeclSpec.h:523
void clearObjCDeclQualifier(ObjCDeclQualifier DQVal)
Definition: DeclSpec.h:829
static const TST TST_error
Definition: DeclSpec.h:307
SourceLocation getLocStart() const LLVM_READONLY
Definition: DeclSpec.h:1886
static const TSW TSW_unspecified
Definition: DeclSpec.h:253
void ClearStorageClassSpecs()
Definition: DeclSpec.h:463
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:479
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
Definition: LangOptions.h:48
SourceLocation getRestrictQualifierLoc() const
Retrieve the location of the &#39;restrict&#39; qualifier, if any.
Definition: DeclSpec.h:1423
void SetSourceRange(SourceRange R)
Definition: DeclSpec.h:1889
This little struct is used to capture information about structure field declarators, which is basically just a bitfield size.
Definition: DeclSpec.h:2464
bool isInvalidType() const
Definition: DeclSpec.h:2418
bool isFinalSpelledSealed() const
Definition: DeclSpec.h:2494
PointerTypeInfo Ptr
Definition: DeclSpec.h:1501
UnionParsedType DestructorName
When Kind == IK_DestructorName, the type referred to by the class-name.
Definition: DeclSpec.h:965
void setExternInLinkageSpec(bool Value)
Definition: DeclSpec.h:454
Represents a C++ unqualified-id that has been parsed.
Definition: DeclSpec.h:900
void setObjCWeakProperty(bool Val=true)
Definition: DeclSpec.h:2414
ObjCPropertyAttributeKind
PropertyAttributeKind - list of property attributes.
Definition: DeclSpec.h:800
bool isFunctionDeclaratorAFunctionDeclaration() const
Return true if a function declarator at this position would be a function declaration.
Definition: DeclSpec.h:2343
void addAttributes(AttributeList *AL)
Concatenates two attribute lists.
Definition: DeclSpec.h:746
unsigned ConstQualLoc
The location of the const-qualifier, if any.
Definition: DeclSpec.h:1159
void setExtension(bool Val=true)
Definition: DeclSpec.h:2408
bool isFunctionDeclarator() const
isFunctionDeclarator - Once this declarator is fully parsed and formed, this method returns true if t...
Definition: DeclSpec.h:2239
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:1892
bool isTypeSpecPipe() const
Definition: DeclSpec.h:487
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:2153
SourceLocation getLocStart() const LLVM_READONLY
Definition: DeclSpec.h:1123
void setRedeclaration(bool Val)
Definition: DeclSpec.h:2458
An implicit &#39;self&#39; parameter.
Definition: DeclSpec.h:925
const ParsedAttributes & getAttributes() const
Definition: DeclSpec.h:753
void AddInnermostTypeInfo(const DeclaratorChunk &TI)
Add a new innermost chunk to this declarator.
Definition: DeclSpec.h:2148
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:480
bool hasAttributes() const
Definition: DeclSpec.h:750
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:39
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:576
void UpdateExprRep(Expr *Rep)
Definition: DeclSpec.h:675
SourceLocation getConstSpecLoc() const
Definition: DeclSpec.h:544
const CXXScopeSpec & getCXXScopeSpec() const
getCXXScopeSpec - Return the C++ scope specifier (global scope or nested-name-specifier) that is part...
Definition: DeclSpec.h:1865
SourceLocation getLSquareLoc() const
Definition: DeclSpec.h:1706
LambdaCaptureInitKind
Definition: DeclSpec.h:2514
bool isTypeRep() const
Definition: DeclSpec.h:486
SourceLocation getLocStart() const LLVM_READONLY
Definition: DeclSpec.h:505
SourceRange getSourceRange() const LLVM_READONLY
Definition: DeclSpec.h:504
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:2115
UnionParsedType ConstructorName
When Kind == IK_ConstructorName, the class-name of the type whose constructor is being referenced...
Definition: DeclSpec.h:961
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:2307
bool isExternInLinkageSpec() const
Definition: DeclSpec.h:453
Declarator(const DeclSpec &ds, TheContext C)
Definition: DeclSpec.h:1837
bool isFinalSpecified() const
Definition: DeclSpec.h:2493
SourceLocation getTypeSpecComplexLoc() const
Definition: DeclSpec.h:510
unsigned AccessWrites
The access writes.
Definition: DeclSpec.h:1494
DeclSpec & getMutableDeclSpec()
getMutableDeclSpec - Return a non-const version of the DeclSpec.
Definition: DeclSpec.h:1857
SourceLocation getAltiVecLoc() const
Definition: DeclSpec.h:513
Sema - This implements semantic analysis and AST building for C.
Definition: Sema.h:274
LambdaCapture(LambdaCaptureKind Kind, SourceLocation Loc, IdentifierInfo *Id, SourceLocation EllipsisLoc, LambdaCaptureInitKind InitKind, ExprResult Init, ParsedType InitCaptureType)
Definition: DeclSpec.h:2532
SourceLocation getUnalignedSpecLoc() const
Definition: DeclSpec.h:548
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:874
void ClearConstexprSpec()
Definition: DeclSpec.h:715
bool mayBeFollowedByCXXDirectInit() const
mayBeFollowedByCXXDirectInit - Return true if the declarator can be followed by a C++ direct initiali...
Definition: DeclSpec.h:2045
bool isTypeAltiVecPixel() const
Definition: DeclSpec.h:483
bool isPastIdentifier() const
isPastIdentifier - Return true if we have parsed beyond the point where the name would appear...
Definition: DeclSpec.h:2099
IdentifierInfo * getSetterName()
Definition: DeclSpec.h:872
void SetRangeStart(SourceLocation Loc)
Definition: DeclSpec.h:610
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:2409
bool mayHaveDecompositionDeclarator() const
Return true if the context permits a C++17 decomposition declarator.
Definition: DeclSpec.h:2004
SourceRange getRange() const
Definition: DeclSpec.h:68
SmallVector< LambdaCapture, 4 > Captures
Definition: DeclSpec.h:2543
AttributeList * getAttributes()
Definition: DeclSpec.h:2381
TST getTypeSpecType() const
Definition: DeclSpec.h:481
static bool isDeclRep(TST T)
Definition: DeclSpec.h:415
llvm::iterator_range< type_object_iterator > type_object_range
Definition: DeclSpec.h:2167
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:573
int Id
Definition: ASTDiff.cpp:191
bool isDecompositionDeclarator() const
Return whether this declarator is a decomposition declarator.
Definition: DeclSpec.h:2111
const FunctionProtoType * T
An individual capture in a lambda introducer.
Definition: DeclSpec.h:2524
DeclaratorChunk & getTypeObject(unsigned i)
Definition: DeclSpec.h:2161
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:2503
bool isTypeAltiVecVector() const
Definition: DeclSpec.h:482
void freeParams()
Reset the parameter list to having zero parameters.
Definition: DeclSpec.h:1349
SourceLocation getVolatileSpecLoc() const
Definition: DeclSpec.h:546
SourceLocation getThreadStorageClassSpecLoc() const
Definition: DeclSpec.h:459
void ClearTypeQualifiers()
Clear out all of the type qualifiers.
Definition: DeclSpec.h:552
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:2405
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:2255
SourceLocation getBeginLoc() const
Definition: DeclSpec.h:72
bool hasEllipsis() const
Definition: DeclSpec.h:2429
bool isConstexprSpecified() const
Definition: DeclSpec.h:709
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:176
SourceLocation getStorageClassSpecLoc() const
Definition: DeclSpec.h:458
void UpdateTypeRep(ParsedType Rep)
Definition: DeclSpec.h:671
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:2386
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
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:2431
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:2194
TheContext getContext() const
Definition: DeclSpec.h:1875
bool isFriendSpecified() const
Definition: DeclSpec.h:703
void ClearConceptSpec()
Definition: DeclSpec.h:720
Wraps an identifier and optional source location for the identifier.
Definition: AttributeList.h:73
SourceLocation getCommaLoc() const
Definition: DeclSpec.h:2426
bool isCXX11Attribute() const
bool isObjCIvar() const
Definition: DeclSpec.h:2412
SourceRange getRange() const
bool isValid() const
Determine whether this unqualified-id refers to a valid name.
Definition: DeclSpec.h:996
IdKind
Describes the kind of unqualified-id parsed.
Definition: DeclSpec.h:907
bool isFirstDeclarator() const
Definition: DeclSpec.h:2425
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:841
bool hasGroupingParens() const
Definition: DeclSpec.h:2423
SourceLocation getNoreturnSpecLoc() const
Definition: DeclSpec.h:577
NestedNameSpecifier * getScopeRep() const
Retrieve the representation of the nested-name-specifier.
Definition: DeclSpec.h:76
bool isConceptSpecified() const
Definition: DeclSpec.h:712
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:787
const AttributeList * getAttributes() const
Definition: DeclSpec.h:2380
#define false
Definition: stdbool.h:33
SourceLocation DefaultLoc
Definition: DeclSpec.h:2541
bool isArrayOfUnknownBound() const
isArrayOfUnknownBound - This method returns true if the declarator is a declarator for an array of un...
Definition: DeclSpec.h:2205
Kind
ActionResult - This structure is used while parsing/acting on expressions, stmts, etc...
Definition: Ownership.h:144
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:449
SourceLocation getRParenLoc() const
Definition: DeclSpec.h:1391
Expr * getAsmLabel() const
Definition: DeclSpec.h:2406
bool hasName() const
hasName - Whether this declarator has a name, which might be an identifier (accessible via getIdentif...
Definition: DeclSpec.h:2105
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:2549
bool isTypeSpecOwned() const
Definition: DeclSpec.h:485
ReferenceTypeInfo Ref
Definition: DeclSpec.h:1502
ParsedSpecifiers
ParsedSpecifiers - Flags to query which specifiers were applied.
Definition: DeclSpec.h:323
FunctionDefinitionKind getFunctionDefinitionKind() const
Definition: DeclSpec.h:2441
An overloaded operator name, e.g., operator+.
Definition: DeclSpec.h:911
UnqualifiedId & getName()
Retrieve the name specified by this declarator.
Definition: DeclSpec.h:1869
FunctionTypeInfo Fun
Definition: DeclSpec.h:1504
bool isModulePrivateSpecified() const
Definition: DeclSpec.h:706
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:1871
void setGroupingParens(bool flag)
Definition: DeclSpec.h:2422
GNU __thread.
Definition: Specifiers.h:193
Represents a C++ nested name specifier, such as "\::std::vector<int>::".
ObjCPropertyAttributeKind getPropertyAttributes() const
Definition: DeclSpec.h:833
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:493
Represents a C++11 virt-specifier-seq.
Definition: DeclSpec.h:2472
bool isInvalid() const
Determine whether this unqualified-id refers to an invalid name.
Definition: DeclSpec.h:999
void setKind(IdKind kind)
Definition: DeclSpec.h:1003
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:566
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:369
bool isInvalid() const
An error occurred during parsing of the scope specifier.
Definition: DeclSpec.h:194
void setFunctionDefinitionKind(FunctionDefinitionKind Val)
Definition: DeclSpec.h:2433
A constructor named via a template-id.
Definition: DeclSpec.h:919
SourceLocation getLastLocation() const
Definition: DeclSpec.h:2502
C++11 thread_local.
Definition: Specifiers.h:196
Defines various enumerations that describe declaration and type specifiers.
SourceLocation getModulePrivateSpecLoc() const
Definition: DeclSpec.h:707
bool isObjCWeakProperty() const
Definition: DeclSpec.h:2415
SourceRange getSourceRange() const LLVM_READONLY
Get the source range that spans this declarator.
Definition: DeclSpec.h:1885
void takeAttributes(ParsedAttributes &attrs, SourceLocation lastLoc)
takeAttributes - Takes attributes from the given parsed-attributes set and add them to this declarato...
Definition: DeclSpec.h:2373
TSW getTypeSpecWidth() const
Definition: DeclSpec.h:478
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:2467
static const TSS TSS_unspecified
Definition: DeclSpec.h:266
SourceLocation getTypeSpecWidthLoc() const
Definition: DeclSpec.h:508
LambdaCaptureDefault Default
Definition: DeclSpec.h:2542
void setObjCIvar(bool Val=true)
Definition: DeclSpec.h:2411
const AttributeList * getAttrs() const
If there are attributes applied to this declaratorchunk, return them.
Definition: DeclSpec.h:1525
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:2183
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:549
unsigned ConstQualifierLoc
The location of the const-qualifier, if any.
Definition: DeclSpec.h:1295
SourceLocation getTypeSpecSignLoc() const
Definition: DeclSpec.h:511
SourceLocation getLocEnd() const LLVM_READONLY
Definition: DeclSpec.h:506
void setObjCDeclQualifier(ObjCDeclQualifier DQVal)
Definition: DeclSpec.h:826
bool isTypeAltiVecBool() const
Definition: DeclSpec.h:484
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:502
unsigned getTypeQualifiers() const
getTypeQualifiers - Return a set of TQs.
Definition: DeclSpec.h:543
void takeAttributesFrom(ParsedAttributes &attrs)
Definition: DeclSpec.h:755
SourceLocation getNullabilityLoc() const
Definition: DeclSpec.h:848
SourceLocation getVirtualSpecLoc() const
Definition: DeclSpec.h:571
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:865
unsigned LParenLoc
The location of the left parenthesis in the source.
Definition: DeclSpec.h:1270
void setNullability(SourceLocation loc, NullabilityKind kind)
Definition: DeclSpec.h:855
type_object_range type_objects() const
Returns the range of type objects, from the identifier outwards.
Definition: DeclSpec.h:2170
CXXScopeSpec & getCXXScopeSpec()
Definition: DeclSpec.h:1866
void SetRangeEnd(SourceLocation Loc)
SetRangeEnd - Set the end of the source range to Loc, unless it&#39;s invalid.
Definition: DeclSpec.h:1897
ExceptionSpecificationType
The various types of exception specifications that exist in C++11.
ActionResult< ParsedType > TypeResult
Definition: Ownership.h:253
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
A template-id, e.g., f<int>.
Definition: DeclSpec.h:923
SourceLocation getTypeSpecTypeNameLoc() const
Definition: DeclSpec.h:515
CXXScopeSpec & getTypeSpecScope()
Definition: DeclSpec.h:501
BlockPointerTypeInfo Cls
Definition: DeclSpec.h:1505
SourceRange getExceptionSpecRange() const
Definition: DeclSpec.h:1403
SourceLocation getIdentifierLoc() const
Definition: DeclSpec.h:2121
Structure that packs information about the type specifiers that were written in a particular type spe...
Definition: Specifiers.h:85
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:2396
SourceRange getSourceRange() const
Definition: DeclSpec.h:1708
void setInvalidType(bool Val=true)
Definition: DeclSpec.h:2417
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:190
Captures information about "declaration specifiers".
Definition: DeclSpec.h:228
SourceLocation getRestrictSpecLoc() const
Definition: DeclSpec.h:545
void setEnd(SourceLocation e)
void UpdateDeclRep(Decl *Rep)
Definition: DeclSpec.h:667
Represents a C++ struct/union/class.
Definition: DeclCXX.h:266
A factory, from which one makes pools, from which one creates individual attributes which are dealloc...
SourceLocation getEllipsisLoc() const
Definition: DeclSpec.h:2430
bool isValid() const
A user-defined literal name, e.g., operator "" _i.
Definition: DeclSpec.h:915
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:471
bool mayHaveIdentifier() const
mayHaveIdentifier - Return true if the identifier is either optional or required. ...
Definition: DeclSpec.h:1970
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:1850
bool isVirtualSpecified() const
Definition: DeclSpec.h:570
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
SourceLocation getFirstLocation() const
Definition: DeclSpec.h:2501
AttributePool & getPool() const
ParsedType getRepAsType() const
Definition: DeclSpec.h:489
bool isInlineSpecified() const
Definition: DeclSpec.h:563
Represents a complete lambda introducer.
Definition: DeclSpec.h:2522
void ExtendWithDeclSpec(const DeclSpec &DS)
ExtendWithDeclSpec - Extend the declarator source range to include the given declspec, unless its location is invalid.
Definition: DeclSpec.h:1904
SourceLocation getAtomicSpecLoc() const
Definition: DeclSpec.h:547
Expr * ExprRep
Definition: DeclSpec.h:370
void setBeginLoc(SourceLocation Loc)
Definition: DeclSpec.h:70
SourceLocation getExplicitSpecLoc() const
Definition: DeclSpec.h:574
SourceLocation getConstexprSpecLoc() const
Definition: DeclSpec.h:710
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:606
const IdentifierInfo * getGetterName() const
Definition: DeclSpec.h:863
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
SourceLocation getExceptionSpecLocEnd() const
Definition: DeclSpec.h:1399
A trivial tuple used to represent a source range.
NamedDecl - This represents a decl with a name.
Definition: Decl.h:213
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:497
Represents a C++ namespace alias.
Definition: DeclCXX.h:2882
void setGetterName(IdentifierInfo *name, SourceLocation loc)
Definition: DeclSpec.h:866
SourceLocation EndLocation
The location of the last token that describes this unqualified-id.
Definition: DeclSpec.h:982
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:2446
SourceLocation getLocEnd() const LLVM_READONLY
Definition: DeclSpec.h:1887
void SetRangeEnd(SourceLocation Loc)
Definition: DeclSpec.h:611
bool isPrototypeContext() const
Definition: DeclSpec.h:1877
AttributePool & getAttributePool() const
Definition: DeclSpec.h:725
SourceLocation getBegin() const
ParsedAttributes - A collection of parsed attributes.
void setCommaLoc(SourceLocation CL)
Definition: DeclSpec.h:2427
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:752
SourceRange getTypeofParensRange() const
Definition: DeclSpec.h:520
AttributeList - Represents a syntactic attribute.
Definition: AttributeList.h:95
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