David 'Digit' Turner | 031fad7 | 2015-04-29 16:20:20 +0200 | [diff] [blame^] | 1 | //===--- DeclSpec.h - Parsed declaration specifiers -------------*- C++ -*-===// |
| 2 | // |
| 3 | // The LLVM Compiler Infrastructure |
| 4 | // |
| 5 | // This file is distributed under the University of Illinois Open Source |
| 6 | // License. See LICENSE.TXT for details. |
| 7 | // |
| 8 | //===----------------------------------------------------------------------===// |
| 9 | /// |
| 10 | /// \file |
| 11 | /// \brief This file defines the classes used to store parsed information about |
| 12 | /// declaration-specifiers and declarators. |
| 13 | /// |
| 14 | /// \verbatim |
| 15 | /// static const int volatile x, *y, *(*(*z)[10])(const void *x); |
| 16 | /// ------------------------- - -- --------------------------- |
| 17 | /// declaration-specifiers \ | / |
| 18 | /// declarators |
| 19 | /// \endverbatim |
| 20 | /// |
| 21 | //===----------------------------------------------------------------------===// |
| 22 | |
| 23 | #ifndef LLVM_CLANG_SEMA_DECLSPEC_H |
| 24 | #define LLVM_CLANG_SEMA_DECLSPEC_H |
| 25 | |
| 26 | #include "clang/AST/NestedNameSpecifier.h" |
| 27 | #include "clang/Basic/ExceptionSpecificationType.h" |
| 28 | #include "clang/Basic/Lambda.h" |
| 29 | #include "clang/Basic/OperatorKinds.h" |
| 30 | #include "clang/Basic/Specifiers.h" |
| 31 | #include "clang/Lex/Token.h" |
| 32 | #include "clang/Sema/AttributeList.h" |
| 33 | #include "clang/Sema/Ownership.h" |
| 34 | #include "llvm/ADT/SmallVector.h" |
| 35 | #include "llvm/Support/Compiler.h" |
| 36 | #include "llvm/Support/ErrorHandling.h" |
| 37 | |
| 38 | namespace clang { |
| 39 | class ASTContext; |
| 40 | class TypeLoc; |
| 41 | class LangOptions; |
| 42 | class DiagnosticsEngine; |
| 43 | class IdentifierInfo; |
| 44 | class NamespaceAliasDecl; |
| 45 | class NamespaceDecl; |
| 46 | class NestedNameSpecifier; |
| 47 | class NestedNameSpecifierLoc; |
| 48 | class ObjCDeclSpec; |
| 49 | class Preprocessor; |
| 50 | class Sema; |
| 51 | class Declarator; |
| 52 | struct TemplateIdAnnotation; |
| 53 | |
| 54 | /// \brief Represents a C++ nested-name-specifier or a global scope specifier. |
| 55 | /// |
| 56 | /// These can be in 3 states: |
| 57 | /// 1) Not present, identified by isEmpty() |
| 58 | /// 2) Present, identified by isNotEmpty() |
| 59 | /// 2.a) Valid, idenified by isValid() |
| 60 | /// 2.b) Invalid, identified by isInvalid(). |
| 61 | /// |
| 62 | /// isSet() is deprecated because it mostly corresponded to "valid" but was |
| 63 | /// often used as if it meant "present". |
| 64 | /// |
| 65 | /// The actual scope is described by getScopeRep(). |
| 66 | class CXXScopeSpec { |
| 67 | SourceRange Range; |
| 68 | NestedNameSpecifierLocBuilder Builder; |
| 69 | |
| 70 | public: |
| 71 | const SourceRange &getRange() const { return Range; } |
| 72 | void setRange(const SourceRange &R) { Range = R; } |
| 73 | void setBeginLoc(SourceLocation Loc) { Range.setBegin(Loc); } |
| 74 | void setEndLoc(SourceLocation Loc) { Range.setEnd(Loc); } |
| 75 | SourceLocation getBeginLoc() const { return Range.getBegin(); } |
| 76 | SourceLocation getEndLoc() const { return Range.getEnd(); } |
| 77 | |
| 78 | /// \brief Retrieve the representation of the nested-name-specifier. |
| 79 | NestedNameSpecifier *getScopeRep() const { |
| 80 | return Builder.getRepresentation(); |
| 81 | } |
| 82 | |
| 83 | /// \brief Extend the current nested-name-specifier by another |
| 84 | /// nested-name-specifier component of the form 'type::'. |
| 85 | /// |
| 86 | /// \param Context The AST context in which this nested-name-specifier |
| 87 | /// resides. |
| 88 | /// |
| 89 | /// \param TemplateKWLoc The location of the 'template' keyword, if present. |
| 90 | /// |
| 91 | /// \param TL The TypeLoc that describes the type preceding the '::'. |
| 92 | /// |
| 93 | /// \param ColonColonLoc The location of the trailing '::'. |
| 94 | void Extend(ASTContext &Context, SourceLocation TemplateKWLoc, TypeLoc TL, |
| 95 | SourceLocation ColonColonLoc); |
| 96 | |
| 97 | /// \brief Extend the current nested-name-specifier by another |
| 98 | /// nested-name-specifier component of the form 'identifier::'. |
| 99 | /// |
| 100 | /// \param Context The AST context in which this nested-name-specifier |
| 101 | /// resides. |
| 102 | /// |
| 103 | /// \param Identifier The identifier. |
| 104 | /// |
| 105 | /// \param IdentifierLoc The location of the identifier. |
| 106 | /// |
| 107 | /// \param ColonColonLoc The location of the trailing '::'. |
| 108 | void Extend(ASTContext &Context, IdentifierInfo *Identifier, |
| 109 | SourceLocation IdentifierLoc, SourceLocation ColonColonLoc); |
| 110 | |
| 111 | /// \brief Extend the current nested-name-specifier by another |
| 112 | /// nested-name-specifier component of the form 'namespace::'. |
| 113 | /// |
| 114 | /// \param Context The AST context in which this nested-name-specifier |
| 115 | /// resides. |
| 116 | /// |
| 117 | /// \param Namespace The namespace. |
| 118 | /// |
| 119 | /// \param NamespaceLoc The location of the namespace name. |
| 120 | /// |
| 121 | /// \param ColonColonLoc The location of the trailing '::'. |
| 122 | void Extend(ASTContext &Context, NamespaceDecl *Namespace, |
| 123 | SourceLocation NamespaceLoc, SourceLocation ColonColonLoc); |
| 124 | |
| 125 | /// \brief Extend the current nested-name-specifier by another |
| 126 | /// nested-name-specifier component of the form 'namespace-alias::'. |
| 127 | /// |
| 128 | /// \param Context The AST context in which this nested-name-specifier |
| 129 | /// resides. |
| 130 | /// |
| 131 | /// \param Alias The namespace alias. |
| 132 | /// |
| 133 | /// \param AliasLoc The location of the namespace alias |
| 134 | /// name. |
| 135 | /// |
| 136 | /// \param ColonColonLoc The location of the trailing '::'. |
| 137 | void Extend(ASTContext &Context, NamespaceAliasDecl *Alias, |
| 138 | SourceLocation AliasLoc, SourceLocation ColonColonLoc); |
| 139 | |
| 140 | /// \brief Turn this (empty) nested-name-specifier into the global |
| 141 | /// nested-name-specifier '::'. |
| 142 | void MakeGlobal(ASTContext &Context, SourceLocation ColonColonLoc); |
| 143 | |
| 144 | /// \brief Make a new nested-name-specifier from incomplete source-location |
| 145 | /// information. |
| 146 | /// |
| 147 | /// FIXME: This routine should be used very, very rarely, in cases where we |
| 148 | /// need to synthesize a nested-name-specifier. Most code should instead use |
| 149 | /// \c Adopt() with a proper \c NestedNameSpecifierLoc. |
| 150 | void MakeTrivial(ASTContext &Context, NestedNameSpecifier *Qualifier, |
| 151 | SourceRange R); |
| 152 | |
| 153 | /// \brief Adopt an existing nested-name-specifier (with source-range |
| 154 | /// information). |
| 155 | void Adopt(NestedNameSpecifierLoc Other); |
| 156 | |
| 157 | /// \brief Retrieve a nested-name-specifier with location information, copied |
| 158 | /// into the given AST context. |
| 159 | /// |
| 160 | /// \param Context The context into which this nested-name-specifier will be |
| 161 | /// copied. |
| 162 | NestedNameSpecifierLoc getWithLocInContext(ASTContext &Context) const; |
| 163 | |
| 164 | /// \brief Retrieve the location of the name in the last qualifier |
| 165 | /// in this nested name specifier. |
| 166 | /// |
| 167 | /// For example, the location of \c bar |
| 168 | /// in |
| 169 | /// \verbatim |
| 170 | /// \::foo::bar<0>:: |
| 171 | /// ^~~ |
| 172 | /// \endverbatim |
| 173 | SourceLocation getLastQualifierNameLoc() const; |
| 174 | |
| 175 | /// No scope specifier. |
| 176 | bool isEmpty() const { return !Range.isValid(); } |
| 177 | /// A scope specifier is present, but may be valid or invalid. |
| 178 | bool isNotEmpty() const { return !isEmpty(); } |
| 179 | |
| 180 | /// An error occurred during parsing of the scope specifier. |
| 181 | bool isInvalid() const { return isNotEmpty() && getScopeRep() == nullptr; } |
| 182 | /// A scope specifier is present, and it refers to a real scope. |
| 183 | bool isValid() const { return isNotEmpty() && getScopeRep() != nullptr; } |
| 184 | |
| 185 | /// \brief Indicate that this nested-name-specifier is invalid. |
| 186 | void SetInvalid(SourceRange R) { |
| 187 | assert(R.isValid() && "Must have a valid source range"); |
| 188 | if (Range.getBegin().isInvalid()) |
| 189 | Range.setBegin(R.getBegin()); |
| 190 | Range.setEnd(R.getEnd()); |
| 191 | Builder.Clear(); |
| 192 | } |
| 193 | |
| 194 | /// Deprecated. Some call sites intend isNotEmpty() while others intend |
| 195 | /// isValid(). |
| 196 | bool isSet() const { return getScopeRep() != nullptr; } |
| 197 | |
| 198 | void clear() { |
| 199 | Range = SourceRange(); |
| 200 | Builder.Clear(); |
| 201 | } |
| 202 | |
| 203 | /// \brief Retrieve the data associated with the source-location information. |
| 204 | char *location_data() const { return Builder.getBuffer().first; } |
| 205 | |
| 206 | /// \brief Retrieve the size of the data associated with source-location |
| 207 | /// information. |
| 208 | unsigned location_size() const { return Builder.getBuffer().second; } |
| 209 | }; |
| 210 | |
| 211 | /// \brief Captures information about "declaration specifiers". |
| 212 | /// |
| 213 | /// "Declaration specifiers" encompasses storage-class-specifiers, |
| 214 | /// type-specifiers, type-qualifiers, and function-specifiers. |
| 215 | class DeclSpec { |
| 216 | public: |
| 217 | /// \brief storage-class-specifier |
| 218 | /// \note The order of these enumerators is important for diagnostics. |
| 219 | enum SCS { |
| 220 | SCS_unspecified = 0, |
| 221 | SCS_typedef, |
| 222 | SCS_extern, |
| 223 | SCS_static, |
| 224 | SCS_auto, |
| 225 | SCS_register, |
| 226 | SCS_private_extern, |
| 227 | SCS_mutable |
| 228 | }; |
| 229 | |
| 230 | // Import thread storage class specifier enumeration and constants. |
| 231 | // These can be combined with SCS_extern and SCS_static. |
| 232 | typedef ThreadStorageClassSpecifier TSCS; |
| 233 | static const TSCS TSCS_unspecified = clang::TSCS_unspecified; |
| 234 | static const TSCS TSCS___thread = clang::TSCS___thread; |
| 235 | static const TSCS TSCS_thread_local = clang::TSCS_thread_local; |
| 236 | static const TSCS TSCS__Thread_local = clang::TSCS__Thread_local; |
| 237 | |
| 238 | // Import type specifier width enumeration and constants. |
| 239 | typedef TypeSpecifierWidth TSW; |
| 240 | static const TSW TSW_unspecified = clang::TSW_unspecified; |
| 241 | static const TSW TSW_short = clang::TSW_short; |
| 242 | static const TSW TSW_long = clang::TSW_long; |
| 243 | static const TSW TSW_longlong = clang::TSW_longlong; |
| 244 | |
| 245 | enum TSC { |
| 246 | TSC_unspecified, |
| 247 | TSC_imaginary, |
| 248 | TSC_complex |
| 249 | }; |
| 250 | |
| 251 | // Import type specifier sign enumeration and constants. |
| 252 | typedef TypeSpecifierSign TSS; |
| 253 | static const TSS TSS_unspecified = clang::TSS_unspecified; |
| 254 | static const TSS TSS_signed = clang::TSS_signed; |
| 255 | static const TSS TSS_unsigned = clang::TSS_unsigned; |
| 256 | |
| 257 | // Import type specifier type enumeration and constants. |
| 258 | typedef TypeSpecifierType TST; |
| 259 | static const TST TST_unspecified = clang::TST_unspecified; |
| 260 | static const TST TST_void = clang::TST_void; |
| 261 | static const TST TST_char = clang::TST_char; |
| 262 | static const TST TST_wchar = clang::TST_wchar; |
| 263 | static const TST TST_char16 = clang::TST_char16; |
| 264 | static const TST TST_char32 = clang::TST_char32; |
| 265 | static const TST TST_int = clang::TST_int; |
| 266 | static const TST TST_int128 = clang::TST_int128; |
| 267 | static const TST TST_half = clang::TST_half; |
| 268 | static const TST TST_float = clang::TST_float; |
| 269 | static const TST TST_double = clang::TST_double; |
| 270 | static const TST TST_bool = clang::TST_bool; |
| 271 | static const TST TST_decimal32 = clang::TST_decimal32; |
| 272 | static const TST TST_decimal64 = clang::TST_decimal64; |
| 273 | static const TST TST_decimal128 = clang::TST_decimal128; |
| 274 | static const TST TST_enum = clang::TST_enum; |
| 275 | static const TST TST_union = clang::TST_union; |
| 276 | static const TST TST_struct = clang::TST_struct; |
| 277 | static const TST TST_interface = clang::TST_interface; |
| 278 | static const TST TST_class = clang::TST_class; |
| 279 | static const TST TST_typename = clang::TST_typename; |
| 280 | static const TST TST_typeofType = clang::TST_typeofType; |
| 281 | static const TST TST_typeofExpr = clang::TST_typeofExpr; |
| 282 | static const TST TST_decltype = clang::TST_decltype; |
| 283 | static const TST TST_decltype_auto = clang::TST_decltype_auto; |
| 284 | static const TST TST_underlyingType = clang::TST_underlyingType; |
| 285 | static const TST TST_auto = clang::TST_auto; |
| 286 | static const TST TST_unknown_anytype = clang::TST_unknown_anytype; |
| 287 | static const TST TST_atomic = clang::TST_atomic; |
| 288 | static const TST TST_error = clang::TST_error; |
| 289 | |
| 290 | // type-qualifiers |
| 291 | enum TQ { // NOTE: These flags must be kept in sync with Qualifiers::TQ. |
| 292 | TQ_unspecified = 0, |
| 293 | TQ_const = 1, |
| 294 | TQ_restrict = 2, |
| 295 | TQ_volatile = 4, |
| 296 | // This has no corresponding Qualifiers::TQ value, because it's not treated |
| 297 | // as a qualifier in our type system. |
| 298 | TQ_atomic = 8 |
| 299 | }; |
| 300 | |
| 301 | /// ParsedSpecifiers - Flags to query which specifiers were applied. This is |
| 302 | /// returned by getParsedSpecifiers. |
| 303 | enum ParsedSpecifiers { |
| 304 | PQ_None = 0, |
| 305 | PQ_StorageClassSpecifier = 1, |
| 306 | PQ_TypeSpecifier = 2, |
| 307 | PQ_TypeQualifier = 4, |
| 308 | PQ_FunctionSpecifier = 8 |
| 309 | }; |
| 310 | |
| 311 | private: |
| 312 | // storage-class-specifier |
| 313 | /*SCS*/unsigned StorageClassSpec : 3; |
| 314 | /*TSCS*/unsigned ThreadStorageClassSpec : 2; |
| 315 | unsigned SCS_extern_in_linkage_spec : 1; |
| 316 | |
| 317 | // type-specifier |
| 318 | /*TSW*/unsigned TypeSpecWidth : 2; |
| 319 | /*TSC*/unsigned TypeSpecComplex : 2; |
| 320 | /*TSS*/unsigned TypeSpecSign : 2; |
| 321 | /*TST*/unsigned TypeSpecType : 6; |
| 322 | unsigned TypeAltiVecVector : 1; |
| 323 | unsigned TypeAltiVecPixel : 1; |
| 324 | unsigned TypeAltiVecBool : 1; |
| 325 | unsigned TypeSpecOwned : 1; |
| 326 | |
| 327 | // type-qualifiers |
| 328 | unsigned TypeQualifiers : 4; // Bitwise OR of TQ. |
| 329 | |
| 330 | // function-specifier |
| 331 | unsigned FS_inline_specified : 1; |
| 332 | unsigned FS_forceinline_specified: 1; |
| 333 | unsigned FS_virtual_specified : 1; |
| 334 | unsigned FS_explicit_specified : 1; |
| 335 | unsigned FS_noreturn_specified : 1; |
| 336 | |
| 337 | // friend-specifier |
| 338 | unsigned Friend_specified : 1; |
| 339 | |
| 340 | // constexpr-specifier |
| 341 | unsigned Constexpr_specified : 1; |
| 342 | |
| 343 | union { |
| 344 | UnionParsedType TypeRep; |
| 345 | Decl *DeclRep; |
| 346 | Expr *ExprRep; |
| 347 | }; |
| 348 | |
| 349 | // attributes. |
| 350 | ParsedAttributes Attrs; |
| 351 | |
| 352 | // Scope specifier for the type spec, if applicable. |
| 353 | CXXScopeSpec TypeScope; |
| 354 | |
| 355 | // List of protocol qualifiers for objective-c classes. Used for |
| 356 | // protocol-qualified interfaces "NString<foo>" and protocol-qualified id |
| 357 | // "id<foo>". |
| 358 | Decl * const *ProtocolQualifiers; |
| 359 | unsigned NumProtocolQualifiers; |
| 360 | SourceLocation ProtocolLAngleLoc; |
| 361 | SourceLocation *ProtocolLocs; |
| 362 | |
| 363 | // SourceLocation info. These are null if the item wasn't specified or if |
| 364 | // the setting was synthesized. |
| 365 | SourceRange Range; |
| 366 | |
| 367 | SourceLocation StorageClassSpecLoc, ThreadStorageClassSpecLoc; |
| 368 | SourceLocation TSWLoc, TSCLoc, TSSLoc, TSTLoc, AltiVecLoc; |
| 369 | /// TSTNameLoc - If TypeSpecType is any of class, enum, struct, union, |
| 370 | /// typename, then this is the location of the named type (if present); |
| 371 | /// otherwise, it is the same as TSTLoc. Hence, the pair TSTLoc and |
| 372 | /// TSTNameLoc provides source range info for tag types. |
| 373 | SourceLocation TSTNameLoc; |
| 374 | SourceRange TypeofParensRange; |
| 375 | SourceLocation TQ_constLoc, TQ_restrictLoc, TQ_volatileLoc, TQ_atomicLoc; |
| 376 | SourceLocation FS_inlineLoc, FS_virtualLoc, FS_explicitLoc, FS_noreturnLoc; |
| 377 | SourceLocation FS_forceinlineLoc; |
| 378 | SourceLocation FriendLoc, ModulePrivateLoc, ConstexprLoc; |
| 379 | |
| 380 | WrittenBuiltinSpecs writtenBS; |
| 381 | void SaveWrittenBuiltinSpecs(); |
| 382 | |
| 383 | ObjCDeclSpec *ObjCQualifiers; |
| 384 | |
| 385 | static bool isTypeRep(TST T) { |
| 386 | return (T == TST_typename || T == TST_typeofType || |
| 387 | T == TST_underlyingType || T == TST_atomic); |
| 388 | } |
| 389 | static bool isExprRep(TST T) { |
| 390 | return (T == TST_typeofExpr || T == TST_decltype); |
| 391 | } |
| 392 | |
| 393 | DeclSpec(const DeclSpec &) LLVM_DELETED_FUNCTION; |
| 394 | void operator=(const DeclSpec &) LLVM_DELETED_FUNCTION; |
| 395 | public: |
| 396 | static bool isDeclRep(TST T) { |
| 397 | return (T == TST_enum || T == TST_struct || |
| 398 | T == TST_interface || T == TST_union || |
| 399 | T == TST_class); |
| 400 | } |
| 401 | |
| 402 | DeclSpec(AttributeFactory &attrFactory) |
| 403 | : StorageClassSpec(SCS_unspecified), |
| 404 | ThreadStorageClassSpec(TSCS_unspecified), |
| 405 | SCS_extern_in_linkage_spec(false), |
| 406 | TypeSpecWidth(TSW_unspecified), |
| 407 | TypeSpecComplex(TSC_unspecified), |
| 408 | TypeSpecSign(TSS_unspecified), |
| 409 | TypeSpecType(TST_unspecified), |
| 410 | TypeAltiVecVector(false), |
| 411 | TypeAltiVecPixel(false), |
| 412 | TypeAltiVecBool(false), |
| 413 | TypeSpecOwned(false), |
| 414 | TypeQualifiers(TQ_unspecified), |
| 415 | FS_inline_specified(false), |
| 416 | FS_forceinline_specified(false), |
| 417 | FS_virtual_specified(false), |
| 418 | FS_explicit_specified(false), |
| 419 | FS_noreturn_specified(false), |
| 420 | Friend_specified(false), |
| 421 | Constexpr_specified(false), |
| 422 | Attrs(attrFactory), |
| 423 | ProtocolQualifiers(nullptr), |
| 424 | NumProtocolQualifiers(0), |
| 425 | ProtocolLocs(nullptr), |
| 426 | writtenBS(), |
| 427 | ObjCQualifiers(nullptr) { |
| 428 | } |
| 429 | ~DeclSpec() { |
| 430 | delete [] ProtocolQualifiers; |
| 431 | delete [] ProtocolLocs; |
| 432 | } |
| 433 | // storage-class-specifier |
| 434 | SCS getStorageClassSpec() const { return (SCS)StorageClassSpec; } |
| 435 | TSCS getThreadStorageClassSpec() const { |
| 436 | return (TSCS)ThreadStorageClassSpec; |
| 437 | } |
| 438 | bool isExternInLinkageSpec() const { return SCS_extern_in_linkage_spec; } |
| 439 | void setExternInLinkageSpec(bool Value) { |
| 440 | SCS_extern_in_linkage_spec = Value; |
| 441 | } |
| 442 | |
| 443 | SourceLocation getStorageClassSpecLoc() const { return StorageClassSpecLoc; } |
| 444 | SourceLocation getThreadStorageClassSpecLoc() const { |
| 445 | return ThreadStorageClassSpecLoc; |
| 446 | } |
| 447 | |
| 448 | void ClearStorageClassSpecs() { |
| 449 | StorageClassSpec = DeclSpec::SCS_unspecified; |
| 450 | ThreadStorageClassSpec = DeclSpec::TSCS_unspecified; |
| 451 | SCS_extern_in_linkage_spec = false; |
| 452 | StorageClassSpecLoc = SourceLocation(); |
| 453 | ThreadStorageClassSpecLoc = SourceLocation(); |
| 454 | } |
| 455 | |
| 456 | void ClearTypeSpecType() { |
| 457 | TypeSpecType = DeclSpec::TST_unspecified; |
| 458 | TypeSpecOwned = false; |
| 459 | TSTLoc = SourceLocation(); |
| 460 | } |
| 461 | |
| 462 | // type-specifier |
| 463 | TSW getTypeSpecWidth() const { return (TSW)TypeSpecWidth; } |
| 464 | TSC getTypeSpecComplex() const { return (TSC)TypeSpecComplex; } |
| 465 | TSS getTypeSpecSign() const { return (TSS)TypeSpecSign; } |
| 466 | TST getTypeSpecType() const { return (TST)TypeSpecType; } |
| 467 | bool isTypeAltiVecVector() const { return TypeAltiVecVector; } |
| 468 | bool isTypeAltiVecPixel() const { return TypeAltiVecPixel; } |
| 469 | bool isTypeAltiVecBool() const { return TypeAltiVecBool; } |
| 470 | bool isTypeSpecOwned() const { return TypeSpecOwned; } |
| 471 | ParsedType getRepAsType() const { |
| 472 | assert(isTypeRep((TST) TypeSpecType) && "DeclSpec does not store a type"); |
| 473 | return TypeRep; |
| 474 | } |
| 475 | Decl *getRepAsDecl() const { |
| 476 | assert(isDeclRep((TST) TypeSpecType) && "DeclSpec does not store a decl"); |
| 477 | return DeclRep; |
| 478 | } |
| 479 | Expr *getRepAsExpr() const { |
| 480 | assert(isExprRep((TST) TypeSpecType) && "DeclSpec does not store an expr"); |
| 481 | return ExprRep; |
| 482 | } |
| 483 | CXXScopeSpec &getTypeSpecScope() { return TypeScope; } |
| 484 | const CXXScopeSpec &getTypeSpecScope() const { return TypeScope; } |
| 485 | |
| 486 | const SourceRange &getSourceRange() const LLVM_READONLY { return Range; } |
| 487 | SourceLocation getLocStart() const LLVM_READONLY { return Range.getBegin(); } |
| 488 | SourceLocation getLocEnd() const LLVM_READONLY { return Range.getEnd(); } |
| 489 | |
| 490 | SourceLocation getTypeSpecWidthLoc() const { return TSWLoc; } |
| 491 | SourceLocation getTypeSpecComplexLoc() const { return TSCLoc; } |
| 492 | SourceLocation getTypeSpecSignLoc() const { return TSSLoc; } |
| 493 | SourceLocation getTypeSpecTypeLoc() const { return TSTLoc; } |
| 494 | SourceLocation getAltiVecLoc() const { return AltiVecLoc; } |
| 495 | |
| 496 | SourceLocation getTypeSpecTypeNameLoc() const { |
| 497 | assert(isDeclRep((TST) TypeSpecType) || TypeSpecType == TST_typename); |
| 498 | return TSTNameLoc; |
| 499 | } |
| 500 | |
| 501 | SourceRange getTypeofParensRange() const { return TypeofParensRange; } |
| 502 | void setTypeofParensRange(SourceRange range) { TypeofParensRange = range; } |
| 503 | |
| 504 | bool containsPlaceholderType() const { |
| 505 | return TypeSpecType == TST_auto || TypeSpecType == TST_decltype_auto; |
| 506 | } |
| 507 | |
| 508 | bool hasTagDefinition() const; |
| 509 | |
| 510 | /// \brief Turn a type-specifier-type into a string like "_Bool" or "union". |
| 511 | static const char *getSpecifierName(DeclSpec::TST T, |
| 512 | const PrintingPolicy &Policy); |
| 513 | static const char *getSpecifierName(DeclSpec::TQ Q); |
| 514 | static const char *getSpecifierName(DeclSpec::TSS S); |
| 515 | static const char *getSpecifierName(DeclSpec::TSC C); |
| 516 | static const char *getSpecifierName(DeclSpec::TSW W); |
| 517 | static const char *getSpecifierName(DeclSpec::SCS S); |
| 518 | static const char *getSpecifierName(DeclSpec::TSCS S); |
| 519 | |
| 520 | // type-qualifiers |
| 521 | |
| 522 | /// getTypeQualifiers - Return a set of TQs. |
| 523 | unsigned getTypeQualifiers() const { return TypeQualifiers; } |
| 524 | SourceLocation getConstSpecLoc() const { return TQ_constLoc; } |
| 525 | SourceLocation getRestrictSpecLoc() const { return TQ_restrictLoc; } |
| 526 | SourceLocation getVolatileSpecLoc() const { return TQ_volatileLoc; } |
| 527 | SourceLocation getAtomicSpecLoc() const { return TQ_atomicLoc; } |
| 528 | |
| 529 | /// \brief Clear out all of the type qualifiers. |
| 530 | void ClearTypeQualifiers() { |
| 531 | TypeQualifiers = 0; |
| 532 | TQ_constLoc = SourceLocation(); |
| 533 | TQ_restrictLoc = SourceLocation(); |
| 534 | TQ_volatileLoc = SourceLocation(); |
| 535 | TQ_atomicLoc = SourceLocation(); |
| 536 | } |
| 537 | |
| 538 | // function-specifier |
| 539 | bool isInlineSpecified() const { |
| 540 | return FS_inline_specified | FS_forceinline_specified; |
| 541 | } |
| 542 | SourceLocation getInlineSpecLoc() const { |
| 543 | return FS_inline_specified ? FS_inlineLoc : FS_forceinlineLoc; |
| 544 | } |
| 545 | |
| 546 | bool isVirtualSpecified() const { return FS_virtual_specified; } |
| 547 | SourceLocation getVirtualSpecLoc() const { return FS_virtualLoc; } |
| 548 | |
| 549 | bool isExplicitSpecified() const { return FS_explicit_specified; } |
| 550 | SourceLocation getExplicitSpecLoc() const { return FS_explicitLoc; } |
| 551 | |
| 552 | bool isNoreturnSpecified() const { return FS_noreturn_specified; } |
| 553 | SourceLocation getNoreturnSpecLoc() const { return FS_noreturnLoc; } |
| 554 | |
| 555 | void ClearFunctionSpecs() { |
| 556 | FS_inline_specified = false; |
| 557 | FS_inlineLoc = SourceLocation(); |
| 558 | FS_forceinline_specified = false; |
| 559 | FS_forceinlineLoc = SourceLocation(); |
| 560 | FS_virtual_specified = false; |
| 561 | FS_virtualLoc = SourceLocation(); |
| 562 | FS_explicit_specified = false; |
| 563 | FS_explicitLoc = SourceLocation(); |
| 564 | FS_noreturn_specified = false; |
| 565 | FS_noreturnLoc = SourceLocation(); |
| 566 | } |
| 567 | |
| 568 | /// \brief Return true if any type-specifier has been found. |
| 569 | bool hasTypeSpecifier() const { |
| 570 | return getTypeSpecType() != DeclSpec::TST_unspecified || |
| 571 | getTypeSpecWidth() != DeclSpec::TSW_unspecified || |
| 572 | getTypeSpecComplex() != DeclSpec::TSC_unspecified || |
| 573 | getTypeSpecSign() != DeclSpec::TSS_unspecified; |
| 574 | } |
| 575 | |
| 576 | /// \brief Return a bitmask of which flavors of specifiers this |
| 577 | /// DeclSpec includes. |
| 578 | unsigned getParsedSpecifiers() const; |
| 579 | |
| 580 | /// isEmpty - Return true if this declaration specifier is completely empty: |
| 581 | /// no tokens were parsed in the production of it. |
| 582 | bool isEmpty() const { |
| 583 | return getParsedSpecifiers() == DeclSpec::PQ_None; |
| 584 | } |
| 585 | |
| 586 | void SetRangeStart(SourceLocation Loc) { Range.setBegin(Loc); } |
| 587 | void SetRangeEnd(SourceLocation Loc) { Range.setEnd(Loc); } |
| 588 | |
| 589 | /// These methods set the specified attribute of the DeclSpec and |
| 590 | /// return false if there was no error. If an error occurs (for |
| 591 | /// example, if we tried to set "auto" on a spec with "extern" |
| 592 | /// already set), they return true and set PrevSpec and DiagID |
| 593 | /// such that |
| 594 | /// Diag(Loc, DiagID) << PrevSpec; |
| 595 | /// will yield a useful result. |
| 596 | /// |
| 597 | /// TODO: use a more general approach that still allows these |
| 598 | /// diagnostics to be ignored when desired. |
| 599 | bool SetStorageClassSpec(Sema &S, SCS SC, SourceLocation Loc, |
| 600 | const char *&PrevSpec, unsigned &DiagID, |
| 601 | const PrintingPolicy &Policy); |
| 602 | bool SetStorageClassSpecThread(TSCS TSC, SourceLocation Loc, |
| 603 | const char *&PrevSpec, unsigned &DiagID); |
| 604 | bool SetTypeSpecWidth(TSW W, SourceLocation Loc, const char *&PrevSpec, |
| 605 | unsigned &DiagID, const PrintingPolicy &Policy); |
| 606 | bool SetTypeSpecComplex(TSC C, SourceLocation Loc, const char *&PrevSpec, |
| 607 | unsigned &DiagID); |
| 608 | bool SetTypeSpecSign(TSS S, SourceLocation Loc, const char *&PrevSpec, |
| 609 | unsigned &DiagID); |
| 610 | bool SetTypeSpecType(TST T, SourceLocation Loc, const char *&PrevSpec, |
| 611 | unsigned &DiagID, const PrintingPolicy &Policy); |
| 612 | bool SetTypeSpecType(TST T, SourceLocation Loc, const char *&PrevSpec, |
| 613 | unsigned &DiagID, ParsedType Rep, |
| 614 | const PrintingPolicy &Policy); |
| 615 | bool SetTypeSpecType(TST T, SourceLocation Loc, const char *&PrevSpec, |
| 616 | unsigned &DiagID, Decl *Rep, bool Owned, |
| 617 | const PrintingPolicy &Policy); |
| 618 | bool SetTypeSpecType(TST T, SourceLocation TagKwLoc, |
| 619 | SourceLocation TagNameLoc, const char *&PrevSpec, |
| 620 | unsigned &DiagID, ParsedType Rep, |
| 621 | const PrintingPolicy &Policy); |
| 622 | bool SetTypeSpecType(TST T, SourceLocation TagKwLoc, |
| 623 | SourceLocation TagNameLoc, const char *&PrevSpec, |
| 624 | unsigned &DiagID, Decl *Rep, bool Owned, |
| 625 | const PrintingPolicy &Policy); |
| 626 | |
| 627 | bool SetTypeSpecType(TST T, SourceLocation Loc, const char *&PrevSpec, |
| 628 | unsigned &DiagID, Expr *Rep, |
| 629 | const PrintingPolicy &policy); |
| 630 | bool SetTypeAltiVecVector(bool isAltiVecVector, SourceLocation Loc, |
| 631 | const char *&PrevSpec, unsigned &DiagID, |
| 632 | const PrintingPolicy &Policy); |
| 633 | bool SetTypeAltiVecPixel(bool isAltiVecPixel, SourceLocation Loc, |
| 634 | const char *&PrevSpec, unsigned &DiagID, |
| 635 | const PrintingPolicy &Policy); |
| 636 | bool SetTypeAltiVecBool(bool isAltiVecBool, SourceLocation Loc, |
| 637 | const char *&PrevSpec, unsigned &DiagID, |
| 638 | const PrintingPolicy &Policy); |
| 639 | bool SetTypeSpecError(); |
| 640 | void UpdateDeclRep(Decl *Rep) { |
| 641 | assert(isDeclRep((TST) TypeSpecType)); |
| 642 | DeclRep = Rep; |
| 643 | } |
| 644 | void UpdateTypeRep(ParsedType Rep) { |
| 645 | assert(isTypeRep((TST) TypeSpecType)); |
| 646 | TypeRep = Rep; |
| 647 | } |
| 648 | void UpdateExprRep(Expr *Rep) { |
| 649 | assert(isExprRep((TST) TypeSpecType)); |
| 650 | ExprRep = Rep; |
| 651 | } |
| 652 | |
| 653 | bool SetTypeQual(TQ T, SourceLocation Loc, const char *&PrevSpec, |
| 654 | unsigned &DiagID, const LangOptions &Lang); |
| 655 | |
| 656 | bool setFunctionSpecInline(SourceLocation Loc, const char *&PrevSpec, |
| 657 | unsigned &DiagID); |
| 658 | bool setFunctionSpecForceInline(SourceLocation Loc, const char *&PrevSpec, |
| 659 | unsigned &DiagID); |
| 660 | bool setFunctionSpecVirtual(SourceLocation Loc, const char *&PrevSpec, |
| 661 | unsigned &DiagID); |
| 662 | bool setFunctionSpecExplicit(SourceLocation Loc, const char *&PrevSpec, |
| 663 | unsigned &DiagID); |
| 664 | bool setFunctionSpecNoreturn(SourceLocation Loc, const char *&PrevSpec, |
| 665 | unsigned &DiagID); |
| 666 | |
| 667 | bool SetFriendSpec(SourceLocation Loc, const char *&PrevSpec, |
| 668 | unsigned &DiagID); |
| 669 | bool setModulePrivateSpec(SourceLocation Loc, const char *&PrevSpec, |
| 670 | unsigned &DiagID); |
| 671 | bool SetConstexprSpec(SourceLocation Loc, const char *&PrevSpec, |
| 672 | unsigned &DiagID); |
| 673 | |
| 674 | bool isFriendSpecified() const { return Friend_specified; } |
| 675 | SourceLocation getFriendSpecLoc() const { return FriendLoc; } |
| 676 | |
| 677 | bool isModulePrivateSpecified() const { return ModulePrivateLoc.isValid(); } |
| 678 | SourceLocation getModulePrivateSpecLoc() const { return ModulePrivateLoc; } |
| 679 | |
| 680 | bool isConstexprSpecified() const { return Constexpr_specified; } |
| 681 | SourceLocation getConstexprSpecLoc() const { return ConstexprLoc; } |
| 682 | |
| 683 | void ClearConstexprSpec() { |
| 684 | Constexpr_specified = false; |
| 685 | ConstexprLoc = SourceLocation(); |
| 686 | } |
| 687 | |
| 688 | AttributePool &getAttributePool() const { |
| 689 | return Attrs.getPool(); |
| 690 | } |
| 691 | |
| 692 | /// \brief Concatenates two attribute lists. |
| 693 | /// |
| 694 | /// The GCC attribute syntax allows for the following: |
| 695 | /// |
| 696 | /// \code |
| 697 | /// short __attribute__(( unused, deprecated )) |
| 698 | /// int __attribute__(( may_alias, aligned(16) )) var; |
| 699 | /// \endcode |
| 700 | /// |
| 701 | /// This declares 4 attributes using 2 lists. The following syntax is |
| 702 | /// also allowed and equivalent to the previous declaration. |
| 703 | /// |
| 704 | /// \code |
| 705 | /// short __attribute__((unused)) __attribute__((deprecated)) |
| 706 | /// int __attribute__((may_alias)) __attribute__((aligned(16))) var; |
| 707 | /// \endcode |
| 708 | /// |
| 709 | void addAttributes(AttributeList *AL) { |
| 710 | Attrs.addAll(AL); |
| 711 | } |
| 712 | |
| 713 | bool hasAttributes() const { return !Attrs.empty(); } |
| 714 | |
| 715 | ParsedAttributes &getAttributes() { return Attrs; } |
| 716 | const ParsedAttributes &getAttributes() const { return Attrs; } |
| 717 | |
| 718 | void takeAttributesFrom(ParsedAttributes &attrs) { |
| 719 | Attrs.takeAllFrom(attrs); |
| 720 | } |
| 721 | |
| 722 | typedef Decl * const *ProtocolQualifierListTy; |
| 723 | ProtocolQualifierListTy getProtocolQualifiers() const { |
| 724 | return ProtocolQualifiers; |
| 725 | } |
| 726 | SourceLocation *getProtocolLocs() const { return ProtocolLocs; } |
| 727 | unsigned getNumProtocolQualifiers() const { |
| 728 | return NumProtocolQualifiers; |
| 729 | } |
| 730 | SourceLocation getProtocolLAngleLoc() const { return ProtocolLAngleLoc; } |
| 731 | void setProtocolQualifiers(Decl * const *Protos, unsigned NP, |
| 732 | SourceLocation *ProtoLocs, |
| 733 | SourceLocation LAngleLoc); |
| 734 | |
| 735 | /// Finish - This does final analysis of the declspec, issuing diagnostics for |
| 736 | /// things like "_Imaginary" (lacking an FP type). After calling this method, |
| 737 | /// DeclSpec is guaranteed self-consistent, even if an error occurred. |
| 738 | void Finish(DiagnosticsEngine &D, Preprocessor &PP, |
| 739 | const PrintingPolicy &Policy); |
| 740 | |
| 741 | const WrittenBuiltinSpecs& getWrittenBuiltinSpecs() const { |
| 742 | return writtenBS; |
| 743 | } |
| 744 | |
| 745 | ObjCDeclSpec *getObjCQualifiers() const { return ObjCQualifiers; } |
| 746 | void setObjCQualifiers(ObjCDeclSpec *quals) { ObjCQualifiers = quals; } |
| 747 | |
| 748 | /// \brief Checks if this DeclSpec can stand alone, without a Declarator. |
| 749 | /// |
| 750 | /// Only tag declspecs can stand alone. |
| 751 | bool isMissingDeclaratorOk(); |
| 752 | }; |
| 753 | |
| 754 | /// \brief Captures information about "declaration specifiers" specific to |
| 755 | /// Objective-C. |
| 756 | class ObjCDeclSpec { |
| 757 | public: |
| 758 | /// ObjCDeclQualifier - Qualifier used on types in method |
| 759 | /// declarations. Not all combinations are sensible. Parameters |
| 760 | /// can be one of { in, out, inout } with one of { bycopy, byref }. |
| 761 | /// Returns can either be { oneway } or not. |
| 762 | /// |
| 763 | /// This should be kept in sync with Decl::ObjCDeclQualifier. |
| 764 | enum ObjCDeclQualifier { |
| 765 | DQ_None = 0x0, |
| 766 | DQ_In = 0x1, |
| 767 | DQ_Inout = 0x2, |
| 768 | DQ_Out = 0x4, |
| 769 | DQ_Bycopy = 0x8, |
| 770 | DQ_Byref = 0x10, |
| 771 | DQ_Oneway = 0x20 |
| 772 | }; |
| 773 | |
| 774 | /// PropertyAttributeKind - list of property attributes. |
| 775 | enum ObjCPropertyAttributeKind { |
| 776 | DQ_PR_noattr = 0x0, |
| 777 | DQ_PR_readonly = 0x01, |
| 778 | DQ_PR_getter = 0x02, |
| 779 | DQ_PR_assign = 0x04, |
| 780 | DQ_PR_readwrite = 0x08, |
| 781 | DQ_PR_retain = 0x10, |
| 782 | DQ_PR_copy = 0x20, |
| 783 | DQ_PR_nonatomic = 0x40, |
| 784 | DQ_PR_setter = 0x80, |
| 785 | DQ_PR_atomic = 0x100, |
| 786 | DQ_PR_weak = 0x200, |
| 787 | DQ_PR_strong = 0x400, |
| 788 | DQ_PR_unsafe_unretained = 0x800 |
| 789 | }; |
| 790 | |
| 791 | |
| 792 | ObjCDeclSpec() |
| 793 | : objcDeclQualifier(DQ_None), PropertyAttributes(DQ_PR_noattr), |
| 794 | GetterName(nullptr), SetterName(nullptr) { } |
| 795 | ObjCDeclQualifier getObjCDeclQualifier() const { return objcDeclQualifier; } |
| 796 | void setObjCDeclQualifier(ObjCDeclQualifier DQVal) { |
| 797 | objcDeclQualifier = (ObjCDeclQualifier) (objcDeclQualifier | DQVal); |
| 798 | } |
| 799 | |
| 800 | ObjCPropertyAttributeKind getPropertyAttributes() const { |
| 801 | return ObjCPropertyAttributeKind(PropertyAttributes); |
| 802 | } |
| 803 | void setPropertyAttributes(ObjCPropertyAttributeKind PRVal) { |
| 804 | PropertyAttributes = |
| 805 | (ObjCPropertyAttributeKind)(PropertyAttributes | PRVal); |
| 806 | } |
| 807 | |
| 808 | const IdentifierInfo *getGetterName() const { return GetterName; } |
| 809 | IdentifierInfo *getGetterName() { return GetterName; } |
| 810 | void setGetterName(IdentifierInfo *name) { GetterName = name; } |
| 811 | |
| 812 | const IdentifierInfo *getSetterName() const { return SetterName; } |
| 813 | IdentifierInfo *getSetterName() { return SetterName; } |
| 814 | void setSetterName(IdentifierInfo *name) { SetterName = name; } |
| 815 | |
| 816 | private: |
| 817 | // FIXME: These two are unrelated and mutually exclusive. So perhaps |
| 818 | // we can put them in a union to reflect their mutual exclusivity |
| 819 | // (space saving is negligible). |
| 820 | ObjCDeclQualifier objcDeclQualifier : 6; |
| 821 | |
| 822 | // NOTE: VC++ treats enums as signed, avoid using ObjCPropertyAttributeKind |
| 823 | unsigned PropertyAttributes : 12; |
| 824 | IdentifierInfo *GetterName; // getter name or NULL if no getter |
| 825 | IdentifierInfo *SetterName; // setter name or NULL if no setter |
| 826 | }; |
| 827 | |
| 828 | /// \brief Represents a C++ unqualified-id that has been parsed. |
| 829 | class UnqualifiedId { |
| 830 | private: |
| 831 | UnqualifiedId(const UnqualifiedId &Other) LLVM_DELETED_FUNCTION; |
| 832 | const UnqualifiedId &operator=(const UnqualifiedId &) LLVM_DELETED_FUNCTION; |
| 833 | |
| 834 | public: |
| 835 | /// \brief Describes the kind of unqualified-id parsed. |
| 836 | enum IdKind { |
| 837 | /// \brief An identifier. |
| 838 | IK_Identifier, |
| 839 | /// \brief An overloaded operator name, e.g., operator+. |
| 840 | IK_OperatorFunctionId, |
| 841 | /// \brief A conversion function name, e.g., operator int. |
| 842 | IK_ConversionFunctionId, |
| 843 | /// \brief A user-defined literal name, e.g., operator "" _i. |
| 844 | IK_LiteralOperatorId, |
| 845 | /// \brief A constructor name. |
| 846 | IK_ConstructorName, |
| 847 | /// \brief A constructor named via a template-id. |
| 848 | IK_ConstructorTemplateId, |
| 849 | /// \brief A destructor name. |
| 850 | IK_DestructorName, |
| 851 | /// \brief A template-id, e.g., f<int>. |
| 852 | IK_TemplateId, |
| 853 | /// \brief An implicit 'self' parameter |
| 854 | IK_ImplicitSelfParam |
| 855 | } Kind; |
| 856 | |
| 857 | struct OFI { |
| 858 | /// \brief The kind of overloaded operator. |
| 859 | OverloadedOperatorKind Operator; |
| 860 | |
| 861 | /// \brief The source locations of the individual tokens that name |
| 862 | /// the operator, e.g., the "new", "[", and "]" tokens in |
| 863 | /// operator new []. |
| 864 | /// |
| 865 | /// Different operators have different numbers of tokens in their name, |
| 866 | /// up to three. Any remaining source locations in this array will be |
| 867 | /// set to an invalid value for operators with fewer than three tokens. |
| 868 | unsigned SymbolLocations[3]; |
| 869 | }; |
| 870 | |
| 871 | /// \brief Anonymous union that holds extra data associated with the |
| 872 | /// parsed unqualified-id. |
| 873 | union { |
| 874 | /// \brief When Kind == IK_Identifier, the parsed identifier, or when Kind |
| 875 | /// == IK_UserLiteralId, the identifier suffix. |
| 876 | IdentifierInfo *Identifier; |
| 877 | |
| 878 | /// \brief When Kind == IK_OperatorFunctionId, the overloaded operator |
| 879 | /// that we parsed. |
| 880 | struct OFI OperatorFunctionId; |
| 881 | |
| 882 | /// \brief When Kind == IK_ConversionFunctionId, the type that the |
| 883 | /// conversion function names. |
| 884 | UnionParsedType ConversionFunctionId; |
| 885 | |
| 886 | /// \brief When Kind == IK_ConstructorName, the class-name of the type |
| 887 | /// whose constructor is being referenced. |
| 888 | UnionParsedType ConstructorName; |
| 889 | |
| 890 | /// \brief When Kind == IK_DestructorName, the type referred to by the |
| 891 | /// class-name. |
| 892 | UnionParsedType DestructorName; |
| 893 | |
| 894 | /// \brief When Kind == IK_TemplateId or IK_ConstructorTemplateId, |
| 895 | /// the template-id annotation that contains the template name and |
| 896 | /// template arguments. |
| 897 | TemplateIdAnnotation *TemplateId; |
| 898 | }; |
| 899 | |
| 900 | /// \brief The location of the first token that describes this unqualified-id, |
| 901 | /// which will be the location of the identifier, "operator" keyword, |
| 902 | /// tilde (for a destructor), or the template name of a template-id. |
| 903 | SourceLocation StartLocation; |
| 904 | |
| 905 | /// \brief The location of the last token that describes this unqualified-id. |
| 906 | SourceLocation EndLocation; |
| 907 | |
| 908 | UnqualifiedId() : Kind(IK_Identifier), Identifier(nullptr) { } |
| 909 | |
| 910 | /// \brief Clear out this unqualified-id, setting it to default (invalid) |
| 911 | /// state. |
| 912 | void clear() { |
| 913 | Kind = IK_Identifier; |
| 914 | Identifier = nullptr; |
| 915 | StartLocation = SourceLocation(); |
| 916 | EndLocation = SourceLocation(); |
| 917 | } |
| 918 | |
| 919 | /// \brief Determine whether this unqualified-id refers to a valid name. |
| 920 | bool isValid() const { return StartLocation.isValid(); } |
| 921 | |
| 922 | /// \brief Determine whether this unqualified-id refers to an invalid name. |
| 923 | bool isInvalid() const { return !isValid(); } |
| 924 | |
| 925 | /// \brief Determine what kind of name we have. |
| 926 | IdKind getKind() const { return Kind; } |
| 927 | void setKind(IdKind kind) { Kind = kind; } |
| 928 | |
| 929 | /// \brief Specify that this unqualified-id was parsed as an identifier. |
| 930 | /// |
| 931 | /// \param Id the parsed identifier. |
| 932 | /// \param IdLoc the location of the parsed identifier. |
| 933 | void setIdentifier(const IdentifierInfo *Id, SourceLocation IdLoc) { |
| 934 | Kind = IK_Identifier; |
| 935 | Identifier = const_cast<IdentifierInfo *>(Id); |
| 936 | StartLocation = EndLocation = IdLoc; |
| 937 | } |
| 938 | |
| 939 | /// \brief Specify that this unqualified-id was parsed as an |
| 940 | /// operator-function-id. |
| 941 | /// |
| 942 | /// \param OperatorLoc the location of the 'operator' keyword. |
| 943 | /// |
| 944 | /// \param Op the overloaded operator. |
| 945 | /// |
| 946 | /// \param SymbolLocations the locations of the individual operator symbols |
| 947 | /// in the operator. |
| 948 | void setOperatorFunctionId(SourceLocation OperatorLoc, |
| 949 | OverloadedOperatorKind Op, |
| 950 | SourceLocation SymbolLocations[3]); |
| 951 | |
| 952 | /// \brief Specify that this unqualified-id was parsed as a |
| 953 | /// conversion-function-id. |
| 954 | /// |
| 955 | /// \param OperatorLoc the location of the 'operator' keyword. |
| 956 | /// |
| 957 | /// \param Ty the type to which this conversion function is converting. |
| 958 | /// |
| 959 | /// \param EndLoc the location of the last token that makes up the type name. |
| 960 | void setConversionFunctionId(SourceLocation OperatorLoc, |
| 961 | ParsedType Ty, |
| 962 | SourceLocation EndLoc) { |
| 963 | Kind = IK_ConversionFunctionId; |
| 964 | StartLocation = OperatorLoc; |
| 965 | EndLocation = EndLoc; |
| 966 | ConversionFunctionId = Ty; |
| 967 | } |
| 968 | |
| 969 | /// \brief Specific that this unqualified-id was parsed as a |
| 970 | /// literal-operator-id. |
| 971 | /// |
| 972 | /// \param Id the parsed identifier. |
| 973 | /// |
| 974 | /// \param OpLoc the location of the 'operator' keyword. |
| 975 | /// |
| 976 | /// \param IdLoc the location of the identifier. |
| 977 | void setLiteralOperatorId(const IdentifierInfo *Id, SourceLocation OpLoc, |
| 978 | SourceLocation IdLoc) { |
| 979 | Kind = IK_LiteralOperatorId; |
| 980 | Identifier = const_cast<IdentifierInfo *>(Id); |
| 981 | StartLocation = OpLoc; |
| 982 | EndLocation = IdLoc; |
| 983 | } |
| 984 | |
| 985 | /// \brief Specify that this unqualified-id was parsed as a constructor name. |
| 986 | /// |
| 987 | /// \param ClassType the class type referred to by the constructor name. |
| 988 | /// |
| 989 | /// \param ClassNameLoc the location of the class name. |
| 990 | /// |
| 991 | /// \param EndLoc the location of the last token that makes up the type name. |
| 992 | void setConstructorName(ParsedType ClassType, |
| 993 | SourceLocation ClassNameLoc, |
| 994 | SourceLocation EndLoc) { |
| 995 | Kind = IK_ConstructorName; |
| 996 | StartLocation = ClassNameLoc; |
| 997 | EndLocation = EndLoc; |
| 998 | ConstructorName = ClassType; |
| 999 | } |
| 1000 | |
| 1001 | /// \brief Specify that this unqualified-id was parsed as a |
| 1002 | /// template-id that names a constructor. |
| 1003 | /// |
| 1004 | /// \param TemplateId the template-id annotation that describes the parsed |
| 1005 | /// template-id. This UnqualifiedId instance will take ownership of the |
| 1006 | /// \p TemplateId and will free it on destruction. |
| 1007 | void setConstructorTemplateId(TemplateIdAnnotation *TemplateId); |
| 1008 | |
| 1009 | /// \brief Specify that this unqualified-id was parsed as a destructor name. |
| 1010 | /// |
| 1011 | /// \param TildeLoc the location of the '~' that introduces the destructor |
| 1012 | /// name. |
| 1013 | /// |
| 1014 | /// \param ClassType the name of the class referred to by the destructor name. |
| 1015 | void setDestructorName(SourceLocation TildeLoc, |
| 1016 | ParsedType ClassType, |
| 1017 | SourceLocation EndLoc) { |
| 1018 | Kind = IK_DestructorName; |
| 1019 | StartLocation = TildeLoc; |
| 1020 | EndLocation = EndLoc; |
| 1021 | DestructorName = ClassType; |
| 1022 | } |
| 1023 | |
| 1024 | /// \brief Specify that this unqualified-id was parsed as a template-id. |
| 1025 | /// |
| 1026 | /// \param TemplateId the template-id annotation that describes the parsed |
| 1027 | /// template-id. This UnqualifiedId instance will take ownership of the |
| 1028 | /// \p TemplateId and will free it on destruction. |
| 1029 | void setTemplateId(TemplateIdAnnotation *TemplateId); |
| 1030 | |
| 1031 | /// \brief Return the source range that covers this unqualified-id. |
| 1032 | SourceRange getSourceRange() const LLVM_READONLY { |
| 1033 | return SourceRange(StartLocation, EndLocation); |
| 1034 | } |
| 1035 | SourceLocation getLocStart() const LLVM_READONLY { return StartLocation; } |
| 1036 | SourceLocation getLocEnd() const LLVM_READONLY { return EndLocation; } |
| 1037 | }; |
| 1038 | |
| 1039 | /// \brief A set of tokens that has been cached for later parsing. |
| 1040 | typedef SmallVector<Token, 4> CachedTokens; |
| 1041 | |
| 1042 | /// \brief One instance of this struct is used for each type in a |
| 1043 | /// declarator that is parsed. |
| 1044 | /// |
| 1045 | /// This is intended to be a small value object. |
| 1046 | struct DeclaratorChunk { |
| 1047 | enum { |
| 1048 | Pointer, Reference, Array, Function, BlockPointer, MemberPointer, Paren |
| 1049 | } Kind; |
| 1050 | |
| 1051 | /// Loc - The place where this type was defined. |
| 1052 | SourceLocation Loc; |
| 1053 | /// EndLoc - If valid, the place where this chunck ends. |
| 1054 | SourceLocation EndLoc; |
| 1055 | |
| 1056 | struct TypeInfoCommon { |
| 1057 | AttributeList *AttrList; |
| 1058 | }; |
| 1059 | |
| 1060 | struct PointerTypeInfo : TypeInfoCommon { |
| 1061 | /// The type qualifiers: const/volatile/restrict/atomic. |
| 1062 | unsigned TypeQuals : 4; |
| 1063 | |
| 1064 | /// The location of the const-qualifier, if any. |
| 1065 | unsigned ConstQualLoc; |
| 1066 | |
| 1067 | /// The location of the volatile-qualifier, if any. |
| 1068 | unsigned VolatileQualLoc; |
| 1069 | |
| 1070 | /// The location of the restrict-qualifier, if any. |
| 1071 | unsigned RestrictQualLoc; |
| 1072 | |
| 1073 | /// The location of the _Atomic-qualifier, if any. |
| 1074 | unsigned AtomicQualLoc; |
| 1075 | |
| 1076 | void destroy() { |
| 1077 | } |
| 1078 | }; |
| 1079 | |
| 1080 | struct ReferenceTypeInfo : TypeInfoCommon { |
| 1081 | /// The type qualifier: restrict. [GNU] C++ extension |
| 1082 | bool HasRestrict : 1; |
| 1083 | /// True if this is an lvalue reference, false if it's an rvalue reference. |
| 1084 | bool LValueRef : 1; |
| 1085 | void destroy() { |
| 1086 | } |
| 1087 | }; |
| 1088 | |
| 1089 | struct ArrayTypeInfo : TypeInfoCommon { |
| 1090 | /// The type qualifiers for the array: const/volatile/restrict/_Atomic. |
| 1091 | unsigned TypeQuals : 4; |
| 1092 | |
| 1093 | /// True if this dimension included the 'static' keyword. |
| 1094 | bool hasStatic : 1; |
| 1095 | |
| 1096 | /// True if this dimension was [*]. In this case, NumElts is null. |
| 1097 | bool isStar : 1; |
| 1098 | |
| 1099 | /// This is the size of the array, or null if [] or [*] was specified. |
| 1100 | /// Since the parser is multi-purpose, and we don't want to impose a root |
| 1101 | /// expression class on all clients, NumElts is untyped. |
| 1102 | Expr *NumElts; |
| 1103 | |
| 1104 | void destroy() {} |
| 1105 | }; |
| 1106 | |
| 1107 | /// ParamInfo - An array of paraminfo objects is allocated whenever a function |
| 1108 | /// declarator is parsed. There are two interesting styles of parameters |
| 1109 | /// here: |
| 1110 | /// K&R-style identifier lists and parameter type lists. K&R-style identifier |
| 1111 | /// lists will have information about the identifier, but no type information. |
| 1112 | /// Parameter type lists will have type info (if the actions module provides |
| 1113 | /// it), but may have null identifier info: e.g. for 'void foo(int X, int)'. |
| 1114 | struct ParamInfo { |
| 1115 | IdentifierInfo *Ident; |
| 1116 | SourceLocation IdentLoc; |
| 1117 | Decl *Param; |
| 1118 | |
| 1119 | /// DefaultArgTokens - When the parameter's default argument |
| 1120 | /// cannot be parsed immediately (because it occurs within the |
| 1121 | /// declaration of a member function), it will be stored here as a |
| 1122 | /// sequence of tokens to be parsed once the class definition is |
| 1123 | /// complete. Non-NULL indicates that there is a default argument. |
| 1124 | CachedTokens *DefaultArgTokens; |
| 1125 | |
| 1126 | ParamInfo() {} |
| 1127 | ParamInfo(IdentifierInfo *ident, SourceLocation iloc, |
| 1128 | Decl *param, |
| 1129 | CachedTokens *DefArgTokens = nullptr) |
| 1130 | : Ident(ident), IdentLoc(iloc), Param(param), |
| 1131 | DefaultArgTokens(DefArgTokens) {} |
| 1132 | }; |
| 1133 | |
| 1134 | struct TypeAndRange { |
| 1135 | ParsedType Ty; |
| 1136 | SourceRange Range; |
| 1137 | }; |
| 1138 | |
| 1139 | struct FunctionTypeInfo : TypeInfoCommon { |
| 1140 | /// hasPrototype - This is true if the function had at least one typed |
| 1141 | /// parameter. If the function is () or (a,b,c), then it has no prototype, |
| 1142 | /// and is treated as a K&R-style function. |
| 1143 | unsigned hasPrototype : 1; |
| 1144 | |
| 1145 | /// isVariadic - If this function has a prototype, and if that |
| 1146 | /// proto ends with ',...)', this is true. When true, EllipsisLoc |
| 1147 | /// contains the location of the ellipsis. |
| 1148 | unsigned isVariadic : 1; |
| 1149 | |
| 1150 | /// Can this declaration be a constructor-style initializer? |
| 1151 | unsigned isAmbiguous : 1; |
| 1152 | |
| 1153 | /// \brief Whether the ref-qualifier (if any) is an lvalue reference. |
| 1154 | /// Otherwise, it's an rvalue reference. |
| 1155 | unsigned RefQualifierIsLValueRef : 1; |
| 1156 | |
| 1157 | /// The type qualifiers: const/volatile/restrict. |
| 1158 | /// The qualifier bitmask values are the same as in QualType. |
| 1159 | unsigned TypeQuals : 3; |
| 1160 | |
| 1161 | /// ExceptionSpecType - An ExceptionSpecificationType value. |
| 1162 | unsigned ExceptionSpecType : 3; |
| 1163 | |
| 1164 | /// DeleteParams - If this is true, we need to delete[] Params. |
| 1165 | unsigned DeleteParams : 1; |
| 1166 | |
| 1167 | /// HasTrailingReturnType - If this is true, a trailing return type was |
| 1168 | /// specified. |
| 1169 | unsigned HasTrailingReturnType : 1; |
| 1170 | |
| 1171 | /// The location of the left parenthesis in the source. |
| 1172 | unsigned LParenLoc; |
| 1173 | |
| 1174 | /// When isVariadic is true, the location of the ellipsis in the source. |
| 1175 | unsigned EllipsisLoc; |
| 1176 | |
| 1177 | /// The location of the right parenthesis in the source. |
| 1178 | unsigned RParenLoc; |
| 1179 | |
| 1180 | /// NumParams - This is the number of formal parameters specified by the |
| 1181 | /// declarator. |
| 1182 | unsigned NumParams; |
| 1183 | |
| 1184 | /// NumExceptions - This is the number of types in the dynamic-exception- |
| 1185 | /// decl, if the function has one. |
| 1186 | unsigned NumExceptions; |
| 1187 | |
| 1188 | /// \brief The location of the ref-qualifier, if any. |
| 1189 | /// |
| 1190 | /// If this is an invalid location, there is no ref-qualifier. |
| 1191 | unsigned RefQualifierLoc; |
| 1192 | |
| 1193 | /// \brief The location of the const-qualifier, if any. |
| 1194 | /// |
| 1195 | /// If this is an invalid location, there is no const-qualifier. |
| 1196 | unsigned ConstQualifierLoc; |
| 1197 | |
| 1198 | /// \brief The location of the volatile-qualifier, if any. |
| 1199 | /// |
| 1200 | /// If this is an invalid location, there is no volatile-qualifier. |
| 1201 | unsigned VolatileQualifierLoc; |
| 1202 | |
| 1203 | /// \brief The location of the 'mutable' qualifer in a lambda-declarator, if |
| 1204 | /// any. |
| 1205 | unsigned MutableLoc; |
| 1206 | |
| 1207 | /// \brief The location of the keyword introducing the spec, if any. |
| 1208 | unsigned ExceptionSpecLoc; |
| 1209 | |
| 1210 | /// Params - This is a pointer to a new[]'d array of ParamInfo objects that |
| 1211 | /// describe the parameters specified by this function declarator. null if |
| 1212 | /// there are no parameters specified. |
| 1213 | ParamInfo *Params; |
| 1214 | |
| 1215 | union { |
| 1216 | /// \brief Pointer to a new[]'d array of TypeAndRange objects that |
| 1217 | /// contain the types in the function's dynamic exception specification |
| 1218 | /// and their locations, if there is one. |
| 1219 | TypeAndRange *Exceptions; |
| 1220 | |
| 1221 | /// \brief Pointer to the expression in the noexcept-specifier of this |
| 1222 | /// function, if it has one. |
| 1223 | Expr *NoexceptExpr; |
| 1224 | }; |
| 1225 | |
| 1226 | /// \brief If HasTrailingReturnType is true, this is the trailing return |
| 1227 | /// type specified. |
| 1228 | UnionParsedType TrailingReturnType; |
| 1229 | |
| 1230 | /// \brief Reset the parameter list to having zero parameters. |
| 1231 | /// |
| 1232 | /// This is used in various places for error recovery. |
| 1233 | void freeParams() { |
| 1234 | for (unsigned I = 0; I < NumParams; ++I) { |
| 1235 | delete Params[I].DefaultArgTokens; |
| 1236 | Params[I].DefaultArgTokens = nullptr; |
| 1237 | } |
| 1238 | if (DeleteParams) { |
| 1239 | delete[] Params; |
| 1240 | DeleteParams = false; |
| 1241 | } |
| 1242 | NumParams = 0; |
| 1243 | } |
| 1244 | |
| 1245 | void destroy() { |
| 1246 | if (DeleteParams) |
| 1247 | delete[] Params; |
| 1248 | if (getExceptionSpecType() == EST_Dynamic) |
| 1249 | delete[] Exceptions; |
| 1250 | } |
| 1251 | |
| 1252 | /// isKNRPrototype - Return true if this is a K&R style identifier list, |
| 1253 | /// like "void foo(a,b,c)". In a function definition, this will be followed |
| 1254 | /// by the parameter type definitions. |
| 1255 | bool isKNRPrototype() const { return !hasPrototype && NumParams != 0; } |
| 1256 | |
| 1257 | SourceLocation getLParenLoc() const { |
| 1258 | return SourceLocation::getFromRawEncoding(LParenLoc); |
| 1259 | } |
| 1260 | |
| 1261 | SourceLocation getEllipsisLoc() const { |
| 1262 | return SourceLocation::getFromRawEncoding(EllipsisLoc); |
| 1263 | } |
| 1264 | |
| 1265 | SourceLocation getRParenLoc() const { |
| 1266 | return SourceLocation::getFromRawEncoding(RParenLoc); |
| 1267 | } |
| 1268 | |
| 1269 | SourceLocation getExceptionSpecLoc() const { |
| 1270 | return SourceLocation::getFromRawEncoding(ExceptionSpecLoc); |
| 1271 | } |
| 1272 | |
| 1273 | /// \brief Retrieve the location of the ref-qualifier, if any. |
| 1274 | SourceLocation getRefQualifierLoc() const { |
| 1275 | return SourceLocation::getFromRawEncoding(RefQualifierLoc); |
| 1276 | } |
| 1277 | |
| 1278 | /// \brief Retrieve the location of the ref-qualifier, if any. |
| 1279 | SourceLocation getConstQualifierLoc() const { |
| 1280 | return SourceLocation::getFromRawEncoding(ConstQualifierLoc); |
| 1281 | } |
| 1282 | |
| 1283 | /// \brief Retrieve the location of the ref-qualifier, if any. |
| 1284 | SourceLocation getVolatileQualifierLoc() const { |
| 1285 | return SourceLocation::getFromRawEncoding(VolatileQualifierLoc); |
| 1286 | } |
| 1287 | |
| 1288 | /// \brief Retrieve the location of the 'mutable' qualifier, if any. |
| 1289 | SourceLocation getMutableLoc() const { |
| 1290 | return SourceLocation::getFromRawEncoding(MutableLoc); |
| 1291 | } |
| 1292 | |
| 1293 | /// \brief Determine whether this function declaration contains a |
| 1294 | /// ref-qualifier. |
| 1295 | bool hasRefQualifier() const { return getRefQualifierLoc().isValid(); } |
| 1296 | |
| 1297 | /// \brief Determine whether this lambda-declarator contains a 'mutable' |
| 1298 | /// qualifier. |
| 1299 | bool hasMutableQualifier() const { return getMutableLoc().isValid(); } |
| 1300 | |
| 1301 | /// \brief Get the type of exception specification this function has. |
| 1302 | ExceptionSpecificationType getExceptionSpecType() const { |
| 1303 | return static_cast<ExceptionSpecificationType>(ExceptionSpecType); |
| 1304 | } |
| 1305 | |
| 1306 | /// \brief Determine whether this function declarator had a |
| 1307 | /// trailing-return-type. |
| 1308 | bool hasTrailingReturnType() const { return HasTrailingReturnType; } |
| 1309 | |
| 1310 | /// \brief Get the trailing-return-type for this function declarator. |
| 1311 | ParsedType getTrailingReturnType() const { return TrailingReturnType; } |
| 1312 | }; |
| 1313 | |
| 1314 | struct BlockPointerTypeInfo : TypeInfoCommon { |
| 1315 | /// For now, sema will catch these as invalid. |
| 1316 | /// The type qualifiers: const/volatile/restrict/_Atomic. |
| 1317 | unsigned TypeQuals : 4; |
| 1318 | |
| 1319 | void destroy() { |
| 1320 | } |
| 1321 | }; |
| 1322 | |
| 1323 | struct MemberPointerTypeInfo : TypeInfoCommon { |
| 1324 | /// The type qualifiers: const/volatile/restrict/_Atomic. |
| 1325 | unsigned TypeQuals : 4; |
| 1326 | // CXXScopeSpec has a constructor, so it can't be a direct member. |
| 1327 | // So we need some pointer-aligned storage and a bit of trickery. |
| 1328 | union { |
| 1329 | void *Aligner; |
| 1330 | char Mem[sizeof(CXXScopeSpec)]; |
| 1331 | } ScopeMem; |
| 1332 | CXXScopeSpec &Scope() { |
| 1333 | return *reinterpret_cast<CXXScopeSpec*>(ScopeMem.Mem); |
| 1334 | } |
| 1335 | const CXXScopeSpec &Scope() const { |
| 1336 | return *reinterpret_cast<const CXXScopeSpec*>(ScopeMem.Mem); |
| 1337 | } |
| 1338 | void destroy() { |
| 1339 | Scope().~CXXScopeSpec(); |
| 1340 | } |
| 1341 | }; |
| 1342 | |
| 1343 | union { |
| 1344 | TypeInfoCommon Common; |
| 1345 | PointerTypeInfo Ptr; |
| 1346 | ReferenceTypeInfo Ref; |
| 1347 | ArrayTypeInfo Arr; |
| 1348 | FunctionTypeInfo Fun; |
| 1349 | BlockPointerTypeInfo Cls; |
| 1350 | MemberPointerTypeInfo Mem; |
| 1351 | }; |
| 1352 | |
| 1353 | void destroy() { |
| 1354 | switch (Kind) { |
| 1355 | case DeclaratorChunk::Function: return Fun.destroy(); |
| 1356 | case DeclaratorChunk::Pointer: return Ptr.destroy(); |
| 1357 | case DeclaratorChunk::BlockPointer: return Cls.destroy(); |
| 1358 | case DeclaratorChunk::Reference: return Ref.destroy(); |
| 1359 | case DeclaratorChunk::Array: return Arr.destroy(); |
| 1360 | case DeclaratorChunk::MemberPointer: return Mem.destroy(); |
| 1361 | case DeclaratorChunk::Paren: return; |
| 1362 | } |
| 1363 | } |
| 1364 | |
| 1365 | /// \brief If there are attributes applied to this declaratorchunk, return |
| 1366 | /// them. |
| 1367 | const AttributeList *getAttrs() const { |
| 1368 | return Common.AttrList; |
| 1369 | } |
| 1370 | |
| 1371 | AttributeList *&getAttrListRef() { |
| 1372 | return Common.AttrList; |
| 1373 | } |
| 1374 | |
| 1375 | /// \brief Return a DeclaratorChunk for a pointer. |
| 1376 | static DeclaratorChunk getPointer(unsigned TypeQuals, SourceLocation Loc, |
| 1377 | SourceLocation ConstQualLoc, |
| 1378 | SourceLocation VolatileQualLoc, |
| 1379 | SourceLocation RestrictQualLoc) { |
| 1380 | DeclaratorChunk I; |
| 1381 | I.Kind = Pointer; |
| 1382 | I.Loc = Loc; |
| 1383 | I.Ptr.TypeQuals = TypeQuals; |
| 1384 | I.Ptr.ConstQualLoc = ConstQualLoc.getRawEncoding(); |
| 1385 | I.Ptr.VolatileQualLoc = VolatileQualLoc.getRawEncoding(); |
| 1386 | I.Ptr.RestrictQualLoc = RestrictQualLoc.getRawEncoding(); |
| 1387 | I.Ptr.AttrList = nullptr; |
| 1388 | return I; |
| 1389 | } |
| 1390 | |
| 1391 | /// \brief Return a DeclaratorChunk for a reference. |
| 1392 | static DeclaratorChunk getReference(unsigned TypeQuals, SourceLocation Loc, |
| 1393 | bool lvalue) { |
| 1394 | DeclaratorChunk I; |
| 1395 | I.Kind = Reference; |
| 1396 | I.Loc = Loc; |
| 1397 | I.Ref.HasRestrict = (TypeQuals & DeclSpec::TQ_restrict) != 0; |
| 1398 | I.Ref.LValueRef = lvalue; |
| 1399 | I.Ref.AttrList = nullptr; |
| 1400 | return I; |
| 1401 | } |
| 1402 | |
| 1403 | /// \brief Return a DeclaratorChunk for an array. |
| 1404 | static DeclaratorChunk getArray(unsigned TypeQuals, |
| 1405 | bool isStatic, bool isStar, Expr *NumElts, |
| 1406 | SourceLocation LBLoc, SourceLocation RBLoc) { |
| 1407 | DeclaratorChunk I; |
| 1408 | I.Kind = Array; |
| 1409 | I.Loc = LBLoc; |
| 1410 | I.EndLoc = RBLoc; |
| 1411 | I.Arr.AttrList = nullptr; |
| 1412 | I.Arr.TypeQuals = TypeQuals; |
| 1413 | I.Arr.hasStatic = isStatic; |
| 1414 | I.Arr.isStar = isStar; |
| 1415 | I.Arr.NumElts = NumElts; |
| 1416 | return I; |
| 1417 | } |
| 1418 | |
| 1419 | /// DeclaratorChunk::getFunction - Return a DeclaratorChunk for a function. |
| 1420 | /// "TheDeclarator" is the declarator that this will be added to. |
| 1421 | static DeclaratorChunk getFunction(bool HasProto, |
| 1422 | bool IsAmbiguous, |
| 1423 | SourceLocation LParenLoc, |
| 1424 | ParamInfo *Params, unsigned NumParams, |
| 1425 | SourceLocation EllipsisLoc, |
| 1426 | SourceLocation RParenLoc, |
| 1427 | unsigned TypeQuals, |
| 1428 | bool RefQualifierIsLvalueRef, |
| 1429 | SourceLocation RefQualifierLoc, |
| 1430 | SourceLocation ConstQualifierLoc, |
| 1431 | SourceLocation VolatileQualifierLoc, |
| 1432 | SourceLocation MutableLoc, |
| 1433 | ExceptionSpecificationType ESpecType, |
| 1434 | SourceLocation ESpecLoc, |
| 1435 | ParsedType *Exceptions, |
| 1436 | SourceRange *ExceptionRanges, |
| 1437 | unsigned NumExceptions, |
| 1438 | Expr *NoexceptExpr, |
| 1439 | SourceLocation LocalRangeBegin, |
| 1440 | SourceLocation LocalRangeEnd, |
| 1441 | Declarator &TheDeclarator, |
| 1442 | TypeResult TrailingReturnType = |
| 1443 | TypeResult()); |
| 1444 | |
| 1445 | /// \brief Return a DeclaratorChunk for a block. |
| 1446 | static DeclaratorChunk getBlockPointer(unsigned TypeQuals, |
| 1447 | SourceLocation Loc) { |
| 1448 | DeclaratorChunk I; |
| 1449 | I.Kind = BlockPointer; |
| 1450 | I.Loc = Loc; |
| 1451 | I.Cls.TypeQuals = TypeQuals; |
| 1452 | I.Cls.AttrList = nullptr; |
| 1453 | return I; |
| 1454 | } |
| 1455 | |
| 1456 | static DeclaratorChunk getMemberPointer(const CXXScopeSpec &SS, |
| 1457 | unsigned TypeQuals, |
| 1458 | SourceLocation Loc) { |
| 1459 | DeclaratorChunk I; |
| 1460 | I.Kind = MemberPointer; |
| 1461 | I.Loc = Loc; |
| 1462 | I.Mem.TypeQuals = TypeQuals; |
| 1463 | I.Mem.AttrList = nullptr; |
| 1464 | new (I.Mem.ScopeMem.Mem) CXXScopeSpec(SS); |
| 1465 | return I; |
| 1466 | } |
| 1467 | |
| 1468 | /// \brief Return a DeclaratorChunk for a paren. |
| 1469 | static DeclaratorChunk getParen(SourceLocation LParenLoc, |
| 1470 | SourceLocation RParenLoc) { |
| 1471 | DeclaratorChunk I; |
| 1472 | I.Kind = Paren; |
| 1473 | I.Loc = LParenLoc; |
| 1474 | I.EndLoc = RParenLoc; |
| 1475 | I.Common.AttrList = nullptr; |
| 1476 | return I; |
| 1477 | } |
| 1478 | |
| 1479 | bool isParen() const { |
| 1480 | return Kind == Paren; |
| 1481 | } |
| 1482 | }; |
| 1483 | |
| 1484 | /// \brief Described the kind of function definition (if any) provided for |
| 1485 | /// a function. |
| 1486 | enum FunctionDefinitionKind { |
| 1487 | FDK_Declaration, |
| 1488 | FDK_Definition, |
| 1489 | FDK_Defaulted, |
| 1490 | FDK_Deleted |
| 1491 | }; |
| 1492 | |
| 1493 | /// \brief Information about one declarator, including the parsed type |
| 1494 | /// information and the identifier. |
| 1495 | /// |
| 1496 | /// When the declarator is fully formed, this is turned into the appropriate |
| 1497 | /// Decl object. |
| 1498 | /// |
| 1499 | /// Declarators come in two types: normal declarators and abstract declarators. |
| 1500 | /// Abstract declarators are used when parsing types, and don't have an |
| 1501 | /// identifier. Normal declarators do have ID's. |
| 1502 | /// |
| 1503 | /// Instances of this class should be a transient object that lives on the |
| 1504 | /// stack, not objects that are allocated in large quantities on the heap. |
| 1505 | class Declarator { |
| 1506 | public: |
| 1507 | enum TheContext { |
| 1508 | FileContext, // File scope declaration. |
| 1509 | PrototypeContext, // Within a function prototype. |
| 1510 | ObjCResultContext, // An ObjC method result type. |
| 1511 | ObjCParameterContext,// An ObjC method parameter type. |
| 1512 | KNRTypeListContext, // K&R type definition list for formals. |
| 1513 | TypeNameContext, // Abstract declarator for types. |
| 1514 | MemberContext, // Struct/Union field. |
| 1515 | BlockContext, // Declaration within a block in a function. |
| 1516 | ForContext, // Declaration within first part of a for loop. |
| 1517 | ConditionContext, // Condition declaration in a C++ if/switch/while/for. |
| 1518 | TemplateParamContext,// Within a template parameter list. |
| 1519 | CXXNewContext, // C++ new-expression. |
| 1520 | CXXCatchContext, // C++ catch exception-declaration |
| 1521 | ObjCCatchContext, // Objective-C catch exception-declaration |
| 1522 | BlockLiteralContext, // Block literal declarator. |
| 1523 | LambdaExprContext, // Lambda-expression declarator. |
| 1524 | LambdaExprParameterContext, // Lambda-expression parameter declarator. |
| 1525 | ConversionIdContext, // C++ conversion-type-id. |
| 1526 | TrailingReturnContext, // C++11 trailing-type-specifier. |
| 1527 | TemplateTypeArgContext, // Template type argument. |
| 1528 | AliasDeclContext, // C++11 alias-declaration. |
| 1529 | AliasTemplateContext // C++11 alias-declaration template. |
| 1530 | }; |
| 1531 | |
| 1532 | private: |
| 1533 | const DeclSpec &DS; |
| 1534 | CXXScopeSpec SS; |
| 1535 | UnqualifiedId Name; |
| 1536 | SourceRange Range; |
| 1537 | |
| 1538 | /// \brief Where we are parsing this declarator. |
| 1539 | TheContext Context; |
| 1540 | |
| 1541 | /// DeclTypeInfo - This holds each type that the declarator includes as it is |
| 1542 | /// parsed. This is pushed from the identifier out, which means that element |
| 1543 | /// #0 will be the most closely bound to the identifier, and |
| 1544 | /// DeclTypeInfo.back() will be the least closely bound. |
| 1545 | SmallVector<DeclaratorChunk, 8> DeclTypeInfo; |
| 1546 | |
| 1547 | /// InvalidType - Set by Sema::GetTypeForDeclarator(). |
| 1548 | bool InvalidType : 1; |
| 1549 | |
| 1550 | /// GroupingParens - Set by Parser::ParseParenDeclarator(). |
| 1551 | bool GroupingParens : 1; |
| 1552 | |
| 1553 | /// FunctionDefinition - Is this Declarator for a function or member |
| 1554 | /// definition and, if so, what kind? |
| 1555 | /// |
| 1556 | /// Actually a FunctionDefinitionKind. |
| 1557 | unsigned FunctionDefinition : 2; |
| 1558 | |
| 1559 | /// \brief Is this Declarator a redeclaration? |
| 1560 | bool Redeclaration : 1; |
| 1561 | |
| 1562 | /// Attrs - Attributes. |
| 1563 | ParsedAttributes Attrs; |
| 1564 | |
| 1565 | /// \brief The asm label, if specified. |
| 1566 | Expr *AsmLabel; |
| 1567 | |
| 1568 | /// InlineParams - This is a local array used for the first function decl |
| 1569 | /// chunk to avoid going to the heap for the common case when we have one |
| 1570 | /// function chunk in the declarator. |
| 1571 | DeclaratorChunk::ParamInfo InlineParams[16]; |
| 1572 | bool InlineParamsUsed; |
| 1573 | |
| 1574 | /// \brief true if the declaration is preceded by \c __extension__. |
| 1575 | bool Extension : 1; |
| 1576 | |
| 1577 | /// \brief If this is the second or subsequent declarator in this declaration, |
| 1578 | /// the location of the comma before this declarator. |
| 1579 | SourceLocation CommaLoc; |
| 1580 | |
| 1581 | /// \brief If provided, the source location of the ellipsis used to describe |
| 1582 | /// this declarator as a parameter pack. |
| 1583 | SourceLocation EllipsisLoc; |
| 1584 | |
| 1585 | friend struct DeclaratorChunk; |
| 1586 | |
| 1587 | public: |
| 1588 | Declarator(const DeclSpec &ds, TheContext C) |
| 1589 | : DS(ds), Range(ds.getSourceRange()), Context(C), |
| 1590 | InvalidType(DS.getTypeSpecType() == DeclSpec::TST_error), |
| 1591 | GroupingParens(false), FunctionDefinition(FDK_Declaration), |
| 1592 | Redeclaration(false), |
| 1593 | Attrs(ds.getAttributePool().getFactory()), AsmLabel(nullptr), |
| 1594 | InlineParamsUsed(false), Extension(false) { |
| 1595 | } |
| 1596 | |
| 1597 | ~Declarator() { |
| 1598 | clear(); |
| 1599 | } |
| 1600 | /// getDeclSpec - Return the declaration-specifier that this declarator was |
| 1601 | /// declared with. |
| 1602 | const DeclSpec &getDeclSpec() const { return DS; } |
| 1603 | |
| 1604 | /// getMutableDeclSpec - Return a non-const version of the DeclSpec. This |
| 1605 | /// should be used with extreme care: declspecs can often be shared between |
| 1606 | /// multiple declarators, so mutating the DeclSpec affects all of the |
| 1607 | /// Declarators. This should only be done when the declspec is known to not |
| 1608 | /// be shared or when in error recovery etc. |
| 1609 | DeclSpec &getMutableDeclSpec() { return const_cast<DeclSpec &>(DS); } |
| 1610 | |
| 1611 | AttributePool &getAttributePool() const { |
| 1612 | return Attrs.getPool(); |
| 1613 | } |
| 1614 | |
| 1615 | /// getCXXScopeSpec - Return the C++ scope specifier (global scope or |
| 1616 | /// nested-name-specifier) that is part of the declarator-id. |
| 1617 | const CXXScopeSpec &getCXXScopeSpec() const { return SS; } |
| 1618 | CXXScopeSpec &getCXXScopeSpec() { return SS; } |
| 1619 | |
| 1620 | /// \brief Retrieve the name specified by this declarator. |
| 1621 | UnqualifiedId &getName() { return Name; } |
| 1622 | |
| 1623 | TheContext getContext() const { return Context; } |
| 1624 | |
| 1625 | bool isPrototypeContext() const { |
| 1626 | return (Context == PrototypeContext || |
| 1627 | Context == ObjCParameterContext || |
| 1628 | Context == ObjCResultContext || |
| 1629 | Context == LambdaExprParameterContext); |
| 1630 | } |
| 1631 | |
| 1632 | /// \brief Get the source range that spans this declarator. |
| 1633 | const SourceRange &getSourceRange() const LLVM_READONLY { return Range; } |
| 1634 | SourceLocation getLocStart() const LLVM_READONLY { return Range.getBegin(); } |
| 1635 | SourceLocation getLocEnd() const LLVM_READONLY { return Range.getEnd(); } |
| 1636 | |
| 1637 | void SetSourceRange(SourceRange R) { Range = R; } |
| 1638 | /// SetRangeBegin - Set the start of the source range to Loc, unless it's |
| 1639 | /// invalid. |
| 1640 | void SetRangeBegin(SourceLocation Loc) { |
| 1641 | if (!Loc.isInvalid()) |
| 1642 | Range.setBegin(Loc); |
| 1643 | } |
| 1644 | /// SetRangeEnd - Set the end of the source range to Loc, unless it's invalid. |
| 1645 | void SetRangeEnd(SourceLocation Loc) { |
| 1646 | if (!Loc.isInvalid()) |
| 1647 | Range.setEnd(Loc); |
| 1648 | } |
| 1649 | /// ExtendWithDeclSpec - Extend the declarator source range to include the |
| 1650 | /// given declspec, unless its location is invalid. Adopts the range start if |
| 1651 | /// the current range start is invalid. |
| 1652 | void ExtendWithDeclSpec(const DeclSpec &DS) { |
| 1653 | const SourceRange &SR = DS.getSourceRange(); |
| 1654 | if (Range.getBegin().isInvalid()) |
| 1655 | Range.setBegin(SR.getBegin()); |
| 1656 | if (!SR.getEnd().isInvalid()) |
| 1657 | Range.setEnd(SR.getEnd()); |
| 1658 | } |
| 1659 | |
| 1660 | /// \brief Reset the contents of this Declarator. |
| 1661 | void clear() { |
| 1662 | SS.clear(); |
| 1663 | Name.clear(); |
| 1664 | Range = DS.getSourceRange(); |
| 1665 | |
| 1666 | for (unsigned i = 0, e = DeclTypeInfo.size(); i != e; ++i) |
| 1667 | DeclTypeInfo[i].destroy(); |
| 1668 | DeclTypeInfo.clear(); |
| 1669 | Attrs.clear(); |
| 1670 | AsmLabel = nullptr; |
| 1671 | InlineParamsUsed = false; |
| 1672 | CommaLoc = SourceLocation(); |
| 1673 | EllipsisLoc = SourceLocation(); |
| 1674 | } |
| 1675 | |
| 1676 | /// mayOmitIdentifier - Return true if the identifier is either optional or |
| 1677 | /// not allowed. This is true for typenames, prototypes, and template |
| 1678 | /// parameter lists. |
| 1679 | bool mayOmitIdentifier() const { |
| 1680 | switch (Context) { |
| 1681 | case FileContext: |
| 1682 | case KNRTypeListContext: |
| 1683 | case MemberContext: |
| 1684 | case BlockContext: |
| 1685 | case ForContext: |
| 1686 | case ConditionContext: |
| 1687 | return false; |
| 1688 | |
| 1689 | case TypeNameContext: |
| 1690 | case AliasDeclContext: |
| 1691 | case AliasTemplateContext: |
| 1692 | case PrototypeContext: |
| 1693 | case LambdaExprParameterContext: |
| 1694 | case ObjCParameterContext: |
| 1695 | case ObjCResultContext: |
| 1696 | case TemplateParamContext: |
| 1697 | case CXXNewContext: |
| 1698 | case CXXCatchContext: |
| 1699 | case ObjCCatchContext: |
| 1700 | case BlockLiteralContext: |
| 1701 | case LambdaExprContext: |
| 1702 | case ConversionIdContext: |
| 1703 | case TemplateTypeArgContext: |
| 1704 | case TrailingReturnContext: |
| 1705 | return true; |
| 1706 | } |
| 1707 | llvm_unreachable("unknown context kind!"); |
| 1708 | } |
| 1709 | |
| 1710 | /// mayHaveIdentifier - Return true if the identifier is either optional or |
| 1711 | /// required. This is true for normal declarators and prototypes, but not |
| 1712 | /// typenames. |
| 1713 | bool mayHaveIdentifier() const { |
| 1714 | switch (Context) { |
| 1715 | case FileContext: |
| 1716 | case KNRTypeListContext: |
| 1717 | case MemberContext: |
| 1718 | case BlockContext: |
| 1719 | case ForContext: |
| 1720 | case ConditionContext: |
| 1721 | case PrototypeContext: |
| 1722 | case LambdaExprParameterContext: |
| 1723 | case TemplateParamContext: |
| 1724 | case CXXCatchContext: |
| 1725 | case ObjCCatchContext: |
| 1726 | return true; |
| 1727 | |
| 1728 | case TypeNameContext: |
| 1729 | case CXXNewContext: |
| 1730 | case AliasDeclContext: |
| 1731 | case AliasTemplateContext: |
| 1732 | case ObjCParameterContext: |
| 1733 | case ObjCResultContext: |
| 1734 | case BlockLiteralContext: |
| 1735 | case LambdaExprContext: |
| 1736 | case ConversionIdContext: |
| 1737 | case TemplateTypeArgContext: |
| 1738 | case TrailingReturnContext: |
| 1739 | return false; |
| 1740 | } |
| 1741 | llvm_unreachable("unknown context kind!"); |
| 1742 | } |
| 1743 | |
| 1744 | /// diagnoseIdentifier - Return true if the identifier is prohibited and |
| 1745 | /// should be diagnosed (because it cannot be anything else). |
| 1746 | bool diagnoseIdentifier() const { |
| 1747 | switch (Context) { |
| 1748 | case FileContext: |
| 1749 | case KNRTypeListContext: |
| 1750 | case MemberContext: |
| 1751 | case BlockContext: |
| 1752 | case ForContext: |
| 1753 | case ConditionContext: |
| 1754 | case PrototypeContext: |
| 1755 | case LambdaExprParameterContext: |
| 1756 | case TemplateParamContext: |
| 1757 | case CXXCatchContext: |
| 1758 | case ObjCCatchContext: |
| 1759 | case TypeNameContext: |
| 1760 | case ConversionIdContext: |
| 1761 | case ObjCParameterContext: |
| 1762 | case ObjCResultContext: |
| 1763 | case BlockLiteralContext: |
| 1764 | case CXXNewContext: |
| 1765 | case LambdaExprContext: |
| 1766 | return false; |
| 1767 | |
| 1768 | case AliasDeclContext: |
| 1769 | case AliasTemplateContext: |
| 1770 | case TemplateTypeArgContext: |
| 1771 | case TrailingReturnContext: |
| 1772 | return true; |
| 1773 | } |
| 1774 | llvm_unreachable("unknown context kind!"); |
| 1775 | } |
| 1776 | |
| 1777 | /// mayBeFollowedByCXXDirectInit - Return true if the declarator can be |
| 1778 | /// followed by a C++ direct initializer, e.g. "int x(1);". |
| 1779 | bool mayBeFollowedByCXXDirectInit() const { |
| 1780 | if (hasGroupingParens()) return false; |
| 1781 | |
| 1782 | if (getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_typedef) |
| 1783 | return false; |
| 1784 | |
| 1785 | if (getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_extern && |
| 1786 | Context != FileContext) |
| 1787 | return false; |
| 1788 | |
| 1789 | // Special names can't have direct initializers. |
| 1790 | if (Name.getKind() != UnqualifiedId::IK_Identifier) |
| 1791 | return false; |
| 1792 | |
| 1793 | switch (Context) { |
| 1794 | case FileContext: |
| 1795 | case BlockContext: |
| 1796 | case ForContext: |
| 1797 | return true; |
| 1798 | |
| 1799 | case ConditionContext: |
| 1800 | // This may not be followed by a direct initializer, but it can't be a |
| 1801 | // function declaration either, and we'd prefer to perform a tentative |
| 1802 | // parse in order to produce the right diagnostic. |
| 1803 | return true; |
| 1804 | |
| 1805 | case KNRTypeListContext: |
| 1806 | case MemberContext: |
| 1807 | case PrototypeContext: |
| 1808 | case LambdaExprParameterContext: |
| 1809 | case ObjCParameterContext: |
| 1810 | case ObjCResultContext: |
| 1811 | case TemplateParamContext: |
| 1812 | case CXXCatchContext: |
| 1813 | case ObjCCatchContext: |
| 1814 | case TypeNameContext: |
| 1815 | case CXXNewContext: |
| 1816 | case AliasDeclContext: |
| 1817 | case AliasTemplateContext: |
| 1818 | case BlockLiteralContext: |
| 1819 | case LambdaExprContext: |
| 1820 | case ConversionIdContext: |
| 1821 | case TemplateTypeArgContext: |
| 1822 | case TrailingReturnContext: |
| 1823 | return false; |
| 1824 | } |
| 1825 | llvm_unreachable("unknown context kind!"); |
| 1826 | } |
| 1827 | |
| 1828 | /// isPastIdentifier - Return true if we have parsed beyond the point where |
| 1829 | /// the |
| 1830 | bool isPastIdentifier() const { return Name.isValid(); } |
| 1831 | |
| 1832 | /// hasName - Whether this declarator has a name, which might be an |
| 1833 | /// identifier (accessible via getIdentifier()) or some kind of |
| 1834 | /// special C++ name (constructor, destructor, etc.). |
| 1835 | bool hasName() const { |
| 1836 | return Name.getKind() != UnqualifiedId::IK_Identifier || Name.Identifier; |
| 1837 | } |
| 1838 | |
| 1839 | IdentifierInfo *getIdentifier() const { |
| 1840 | if (Name.getKind() == UnqualifiedId::IK_Identifier) |
| 1841 | return Name.Identifier; |
| 1842 | |
| 1843 | return nullptr; |
| 1844 | } |
| 1845 | SourceLocation getIdentifierLoc() const { return Name.StartLocation; } |
| 1846 | |
| 1847 | /// \brief Set the name of this declarator to be the given identifier. |
| 1848 | void SetIdentifier(IdentifierInfo *Id, SourceLocation IdLoc) { |
| 1849 | Name.setIdentifier(Id, IdLoc); |
| 1850 | } |
| 1851 | |
| 1852 | /// AddTypeInfo - Add a chunk to this declarator. Also extend the range to |
| 1853 | /// EndLoc, which should be the last token of the chunk. |
| 1854 | void AddTypeInfo(const DeclaratorChunk &TI, |
| 1855 | ParsedAttributes &attrs, |
| 1856 | SourceLocation EndLoc) { |
| 1857 | DeclTypeInfo.push_back(TI); |
| 1858 | DeclTypeInfo.back().getAttrListRef() = attrs.getList(); |
| 1859 | getAttributePool().takeAllFrom(attrs.getPool()); |
| 1860 | |
| 1861 | if (!EndLoc.isInvalid()) |
| 1862 | SetRangeEnd(EndLoc); |
| 1863 | } |
| 1864 | |
| 1865 | /// \brief Add a new innermost chunk to this declarator. |
| 1866 | void AddInnermostTypeInfo(const DeclaratorChunk &TI) { |
| 1867 | DeclTypeInfo.insert(DeclTypeInfo.begin(), TI); |
| 1868 | } |
| 1869 | |
| 1870 | /// \brief Return the number of types applied to this declarator. |
| 1871 | unsigned getNumTypeObjects() const { return DeclTypeInfo.size(); } |
| 1872 | |
| 1873 | /// Return the specified TypeInfo from this declarator. TypeInfo #0 is |
| 1874 | /// closest to the identifier. |
| 1875 | const DeclaratorChunk &getTypeObject(unsigned i) const { |
| 1876 | assert(i < DeclTypeInfo.size() && "Invalid type chunk"); |
| 1877 | return DeclTypeInfo[i]; |
| 1878 | } |
| 1879 | DeclaratorChunk &getTypeObject(unsigned i) { |
| 1880 | assert(i < DeclTypeInfo.size() && "Invalid type chunk"); |
| 1881 | return DeclTypeInfo[i]; |
| 1882 | } |
| 1883 | |
| 1884 | void DropFirstTypeObject() { |
| 1885 | assert(!DeclTypeInfo.empty() && "No type chunks to drop."); |
| 1886 | DeclTypeInfo.front().destroy(); |
| 1887 | DeclTypeInfo.erase(DeclTypeInfo.begin()); |
| 1888 | } |
| 1889 | |
| 1890 | /// Return the innermost (closest to the declarator) chunk of this |
| 1891 | /// declarator that is not a parens chunk, or null if there are no |
| 1892 | /// non-parens chunks. |
| 1893 | const DeclaratorChunk *getInnermostNonParenChunk() const { |
| 1894 | for (unsigned i = 0, i_end = DeclTypeInfo.size(); i < i_end; ++i) { |
| 1895 | if (!DeclTypeInfo[i].isParen()) |
| 1896 | return &DeclTypeInfo[i]; |
| 1897 | } |
| 1898 | return nullptr; |
| 1899 | } |
| 1900 | |
| 1901 | /// Return the outermost (furthest from the declarator) chunk of |
| 1902 | /// this declarator that is not a parens chunk, or null if there are |
| 1903 | /// no non-parens chunks. |
| 1904 | const DeclaratorChunk *getOutermostNonParenChunk() const { |
| 1905 | for (unsigned i = DeclTypeInfo.size(), i_end = 0; i != i_end; --i) { |
| 1906 | if (!DeclTypeInfo[i-1].isParen()) |
| 1907 | return &DeclTypeInfo[i-1]; |
| 1908 | } |
| 1909 | return nullptr; |
| 1910 | } |
| 1911 | |
| 1912 | /// isArrayOfUnknownBound - This method returns true if the declarator |
| 1913 | /// is a declarator for an array of unknown bound (looking through |
| 1914 | /// parentheses). |
| 1915 | bool isArrayOfUnknownBound() const { |
| 1916 | const DeclaratorChunk *chunk = getInnermostNonParenChunk(); |
| 1917 | return (chunk && chunk->Kind == DeclaratorChunk::Array && |
| 1918 | !chunk->Arr.NumElts); |
| 1919 | } |
| 1920 | |
| 1921 | /// isFunctionDeclarator - This method returns true if the declarator |
| 1922 | /// is a function declarator (looking through parentheses). |
| 1923 | /// If true is returned, then the reference type parameter idx is |
| 1924 | /// assigned with the index of the declaration chunk. |
| 1925 | bool isFunctionDeclarator(unsigned& idx) const { |
| 1926 | for (unsigned i = 0, i_end = DeclTypeInfo.size(); i < i_end; ++i) { |
| 1927 | switch (DeclTypeInfo[i].Kind) { |
| 1928 | case DeclaratorChunk::Function: |
| 1929 | idx = i; |
| 1930 | return true; |
| 1931 | case DeclaratorChunk::Paren: |
| 1932 | continue; |
| 1933 | case DeclaratorChunk::Pointer: |
| 1934 | case DeclaratorChunk::Reference: |
| 1935 | case DeclaratorChunk::Array: |
| 1936 | case DeclaratorChunk::BlockPointer: |
| 1937 | case DeclaratorChunk::MemberPointer: |
| 1938 | return false; |
| 1939 | } |
| 1940 | llvm_unreachable("Invalid type chunk"); |
| 1941 | } |
| 1942 | return false; |
| 1943 | } |
| 1944 | |
| 1945 | /// isFunctionDeclarator - Once this declarator is fully parsed and formed, |
| 1946 | /// this method returns true if the identifier is a function declarator |
| 1947 | /// (looking through parentheses). |
| 1948 | bool isFunctionDeclarator() const { |
| 1949 | unsigned index; |
| 1950 | return isFunctionDeclarator(index); |
| 1951 | } |
| 1952 | |
| 1953 | /// getFunctionTypeInfo - Retrieves the function type info object |
| 1954 | /// (looking through parentheses). |
| 1955 | DeclaratorChunk::FunctionTypeInfo &getFunctionTypeInfo() { |
| 1956 | assert(isFunctionDeclarator() && "Not a function declarator!"); |
| 1957 | unsigned index = 0; |
| 1958 | isFunctionDeclarator(index); |
| 1959 | return DeclTypeInfo[index].Fun; |
| 1960 | } |
| 1961 | |
| 1962 | /// getFunctionTypeInfo - Retrieves the function type info object |
| 1963 | /// (looking through parentheses). |
| 1964 | const DeclaratorChunk::FunctionTypeInfo &getFunctionTypeInfo() const { |
| 1965 | return const_cast<Declarator*>(this)->getFunctionTypeInfo(); |
| 1966 | } |
| 1967 | |
| 1968 | /// \brief Determine whether the declaration that will be produced from |
| 1969 | /// this declaration will be a function. |
| 1970 | /// |
| 1971 | /// A declaration can declare a function even if the declarator itself |
| 1972 | /// isn't a function declarator, if the type specifier refers to a function |
| 1973 | /// type. This routine checks for both cases. |
| 1974 | bool isDeclarationOfFunction() const; |
| 1975 | |
| 1976 | /// \brief Return true if this declaration appears in a context where a |
| 1977 | /// function declarator would be a function declaration. |
| 1978 | bool isFunctionDeclarationContext() const { |
| 1979 | if (getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_typedef) |
| 1980 | return false; |
| 1981 | |
| 1982 | switch (Context) { |
| 1983 | case FileContext: |
| 1984 | case MemberContext: |
| 1985 | case BlockContext: |
| 1986 | return true; |
| 1987 | |
| 1988 | case ForContext: |
| 1989 | case ConditionContext: |
| 1990 | case KNRTypeListContext: |
| 1991 | case TypeNameContext: |
| 1992 | case AliasDeclContext: |
| 1993 | case AliasTemplateContext: |
| 1994 | case PrototypeContext: |
| 1995 | case LambdaExprParameterContext: |
| 1996 | case ObjCParameterContext: |
| 1997 | case ObjCResultContext: |
| 1998 | case TemplateParamContext: |
| 1999 | case CXXNewContext: |
| 2000 | case CXXCatchContext: |
| 2001 | case ObjCCatchContext: |
| 2002 | case BlockLiteralContext: |
| 2003 | case LambdaExprContext: |
| 2004 | case ConversionIdContext: |
| 2005 | case TemplateTypeArgContext: |
| 2006 | case TrailingReturnContext: |
| 2007 | return false; |
| 2008 | } |
| 2009 | llvm_unreachable("unknown context kind!"); |
| 2010 | } |
| 2011 | |
| 2012 | /// \brief Return true if a function declarator at this position would be a |
| 2013 | /// function declaration. |
| 2014 | bool isFunctionDeclaratorAFunctionDeclaration() const { |
| 2015 | if (!isFunctionDeclarationContext()) |
| 2016 | return false; |
| 2017 | |
| 2018 | for (unsigned I = 0, N = getNumTypeObjects(); I != N; ++I) |
| 2019 | if (getTypeObject(I).Kind != DeclaratorChunk::Paren) |
| 2020 | return false; |
| 2021 | |
| 2022 | return true; |
| 2023 | } |
| 2024 | |
| 2025 | /// takeAttributes - Takes attributes from the given parsed-attributes |
| 2026 | /// set and add them to this declarator. |
| 2027 | /// |
| 2028 | /// These examples both add 3 attributes to "var": |
| 2029 | /// short int var __attribute__((aligned(16),common,deprecated)); |
| 2030 | /// short int x, __attribute__((aligned(16)) var |
| 2031 | /// __attribute__((common,deprecated)); |
| 2032 | /// |
| 2033 | /// Also extends the range of the declarator. |
| 2034 | void takeAttributes(ParsedAttributes &attrs, SourceLocation lastLoc) { |
| 2035 | Attrs.takeAllFrom(attrs); |
| 2036 | |
| 2037 | if (!lastLoc.isInvalid()) |
| 2038 | SetRangeEnd(lastLoc); |
| 2039 | } |
| 2040 | |
| 2041 | const AttributeList *getAttributes() const { return Attrs.getList(); } |
| 2042 | AttributeList *getAttributes() { return Attrs.getList(); } |
| 2043 | |
| 2044 | AttributeList *&getAttrListRef() { return Attrs.getListRef(); } |
| 2045 | |
| 2046 | /// hasAttributes - do we contain any attributes? |
| 2047 | bool hasAttributes() const { |
| 2048 | if (getAttributes() || getDeclSpec().hasAttributes()) return true; |
| 2049 | for (unsigned i = 0, e = getNumTypeObjects(); i != e; ++i) |
| 2050 | if (getTypeObject(i).getAttrs()) |
| 2051 | return true; |
| 2052 | return false; |
| 2053 | } |
| 2054 | |
| 2055 | /// \brief Return a source range list of C++11 attributes associated |
| 2056 | /// with the declarator. |
| 2057 | void getCXX11AttributeRanges(SmallVectorImpl<SourceRange> &Ranges) { |
| 2058 | AttributeList *AttrList = Attrs.getList(); |
| 2059 | while (AttrList) { |
| 2060 | if (AttrList->isCXX11Attribute()) |
| 2061 | Ranges.push_back(AttrList->getRange()); |
| 2062 | AttrList = AttrList->getNext(); |
| 2063 | } |
| 2064 | } |
| 2065 | |
| 2066 | void setAsmLabel(Expr *E) { AsmLabel = E; } |
| 2067 | Expr *getAsmLabel() const { return AsmLabel; } |
| 2068 | |
| 2069 | void setExtension(bool Val = true) { Extension = Val; } |
| 2070 | bool getExtension() const { return Extension; } |
| 2071 | |
| 2072 | void setInvalidType(bool Val = true) { InvalidType = Val; } |
| 2073 | bool isInvalidType() const { |
| 2074 | return InvalidType || DS.getTypeSpecType() == DeclSpec::TST_error; |
| 2075 | } |
| 2076 | |
| 2077 | void setGroupingParens(bool flag) { GroupingParens = flag; } |
| 2078 | bool hasGroupingParens() const { return GroupingParens; } |
| 2079 | |
| 2080 | bool isFirstDeclarator() const { return !CommaLoc.isValid(); } |
| 2081 | SourceLocation getCommaLoc() const { return CommaLoc; } |
| 2082 | void setCommaLoc(SourceLocation CL) { CommaLoc = CL; } |
| 2083 | |
| 2084 | bool hasEllipsis() const { return EllipsisLoc.isValid(); } |
| 2085 | SourceLocation getEllipsisLoc() const { return EllipsisLoc; } |
| 2086 | void setEllipsisLoc(SourceLocation EL) { EllipsisLoc = EL; } |
| 2087 | |
| 2088 | void setFunctionDefinitionKind(FunctionDefinitionKind Val) { |
| 2089 | FunctionDefinition = Val; |
| 2090 | } |
| 2091 | |
| 2092 | bool isFunctionDefinition() const { |
| 2093 | return getFunctionDefinitionKind() != FDK_Declaration; |
| 2094 | } |
| 2095 | |
| 2096 | FunctionDefinitionKind getFunctionDefinitionKind() const { |
| 2097 | return (FunctionDefinitionKind)FunctionDefinition; |
| 2098 | } |
| 2099 | |
| 2100 | /// Returns true if this declares a real member and not a friend. |
| 2101 | bool isFirstDeclarationOfMember() { |
| 2102 | return getContext() == MemberContext && !getDeclSpec().isFriendSpecified(); |
| 2103 | } |
| 2104 | |
| 2105 | /// Returns true if this declares a static member. This cannot be called on a |
| 2106 | /// declarator outside of a MemberContext because we won't know until |
| 2107 | /// redeclaration time if the decl is static. |
| 2108 | bool isStaticMember(); |
| 2109 | |
| 2110 | void setRedeclaration(bool Val) { Redeclaration = Val; } |
| 2111 | bool isRedeclaration() const { return Redeclaration; } |
| 2112 | }; |
| 2113 | |
| 2114 | /// \brief This little struct is used to capture information about |
| 2115 | /// structure field declarators, which is basically just a bitfield size. |
| 2116 | struct FieldDeclarator { |
| 2117 | Declarator D; |
| 2118 | Expr *BitfieldSize; |
| 2119 | explicit FieldDeclarator(const DeclSpec &DS) |
| 2120 | : D(DS, Declarator::MemberContext), BitfieldSize(nullptr) { } |
| 2121 | }; |
| 2122 | |
| 2123 | /// \brief Represents a C++11 virt-specifier-seq. |
| 2124 | class VirtSpecifiers { |
| 2125 | public: |
| 2126 | enum Specifier { |
| 2127 | VS_None = 0, |
| 2128 | VS_Override = 1, |
| 2129 | VS_Final = 2, |
| 2130 | VS_Sealed = 4 |
| 2131 | }; |
| 2132 | |
| 2133 | VirtSpecifiers() : Specifiers(0) { } |
| 2134 | |
| 2135 | bool SetSpecifier(Specifier VS, SourceLocation Loc, |
| 2136 | const char *&PrevSpec); |
| 2137 | |
| 2138 | bool isUnset() const { return Specifiers == 0; } |
| 2139 | |
| 2140 | bool isOverrideSpecified() const { return Specifiers & VS_Override; } |
| 2141 | SourceLocation getOverrideLoc() const { return VS_overrideLoc; } |
| 2142 | |
| 2143 | bool isFinalSpecified() const { return Specifiers & (VS_Final | VS_Sealed); } |
| 2144 | bool isFinalSpelledSealed() const { return Specifiers & VS_Sealed; } |
| 2145 | SourceLocation getFinalLoc() const { return VS_finalLoc; } |
| 2146 | |
| 2147 | void clear() { Specifiers = 0; } |
| 2148 | |
| 2149 | static const char *getSpecifierName(Specifier VS); |
| 2150 | |
| 2151 | SourceLocation getLastLocation() const { return LastLocation; } |
| 2152 | |
| 2153 | private: |
| 2154 | unsigned Specifiers; |
| 2155 | |
| 2156 | SourceLocation VS_overrideLoc, VS_finalLoc; |
| 2157 | SourceLocation LastLocation; |
| 2158 | }; |
| 2159 | |
| 2160 | /// \brief Represents a complete lambda introducer. |
| 2161 | struct LambdaIntroducer { |
| 2162 | /// \brief An individual capture in a lambda introducer. |
| 2163 | struct LambdaCapture { |
| 2164 | LambdaCaptureKind Kind; |
| 2165 | SourceLocation Loc; |
| 2166 | IdentifierInfo *Id; |
| 2167 | SourceLocation EllipsisLoc; |
| 2168 | ExprResult Init; |
| 2169 | ParsedType InitCaptureType; |
| 2170 | LambdaCapture(LambdaCaptureKind Kind, SourceLocation Loc, |
| 2171 | IdentifierInfo *Id, SourceLocation EllipsisLoc, |
| 2172 | ExprResult Init, ParsedType InitCaptureType) |
| 2173 | : Kind(Kind), Loc(Loc), Id(Id), EllipsisLoc(EllipsisLoc), Init(Init), |
| 2174 | InitCaptureType(InitCaptureType) {} |
| 2175 | }; |
| 2176 | |
| 2177 | SourceRange Range; |
| 2178 | SourceLocation DefaultLoc; |
| 2179 | LambdaCaptureDefault Default; |
| 2180 | SmallVector<LambdaCapture, 4> Captures; |
| 2181 | |
| 2182 | LambdaIntroducer() |
| 2183 | : Default(LCD_None) {} |
| 2184 | |
| 2185 | /// \brief Append a capture in a lambda introducer. |
| 2186 | void addCapture(LambdaCaptureKind Kind, |
| 2187 | SourceLocation Loc, |
| 2188 | IdentifierInfo* Id, |
| 2189 | SourceLocation EllipsisLoc, |
| 2190 | ExprResult Init, |
| 2191 | ParsedType InitCaptureType) { |
| 2192 | Captures.push_back(LambdaCapture(Kind, Loc, Id, EllipsisLoc, Init, |
| 2193 | InitCaptureType)); |
| 2194 | } |
| 2195 | }; |
| 2196 | |
| 2197 | } // end namespace clang |
| 2198 | |
| 2199 | #endif |