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