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