//===--- DeclSpec.h - Parsed declaration specifiers -------------*- C++ -*-===//

//

// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.

// See https://llvm.org/LICENSE.txt for license information.

// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

//

//===----------------------------------------------------------------------===//

///

/// \file

/// This file defines the classes used to store parsed information about

/// declaration-specifiers and declarators.

///

/// \verbatim

///   static const int volatile x, *y, *(*(*z)[10])(const void *x);

///   ------------------------- -  --  ---------------------------

///     declaration-specifiers  \  |   /

///                            declarators

/// \endverbatim

///

//===----------------------------------------------------------------------===//

#ifndef LLVM_CLANG_SEMA_DECLSPEC_H

#define LLVM_CLANG_SEMA_DECLSPEC_H

#include "clang/AST/DeclCXX.h"

#include "clang/AST/DeclObjCCommon.h"

#include "clang/AST/NestedNameSpecifier.h"

#include "clang/Basic/ExceptionSpecificationType.h"

#include "clang/Basic/Lambda.h"

#include "clang/Basic/OperatorKinds.h"

#include "clang/Basic/Specifiers.h"

#include "clang/Lex/Token.h"

#include "clang/Sema/Ownership.h"

#include "clang/Sema/ParsedAttr.h"

#include "llvm/ADT/SmallVector.h"

#include "llvm/Support/Compiler.h"

#include "llvm/Support/ErrorHandling.h"

namespace clang {

  class ASTContext;

  class CXXRecordDecl;

  class TypeLoc;

  class LangOptions;

  class IdentifierInfo;

  class NamespaceAliasDecl;

  class NamespaceDecl;

  class ObjCDeclSpec;

  class Sema;

  class Declarator;

  struct TemplateIdAnnotation;

/// Represents a C++ nested-name-specifier or a global scope specifier.

///

/// These can be in 3 states:

///   1) Not present, identified by isEmpty()

///   2) Present, identified by isNotEmpty()

///      2.a) Valid, identified by isValid()

///      2.b) Invalid, identified by isInvalid().

///

/// isSet() is deprecated because it mostly corresponded to "valid" but was

/// often used as if it meant "present".

///

/// The actual scope is described by getScopeRep().

class CXXScopeSpec {

  SourceRange Range;

  NestedNameSpecifierLocBuilder Builder;

public:

  SourceRange getRange() const { return Range; }

  void setRange(SourceRange R) { Range = R; }

  void setBeginLoc(SourceLocation Loc) { Range.setBegin(Loc); }

  void setEndLoc(SourceLocation Loc) { Range.setEnd(Loc); }

  SourceLocation getBeginLoc() const { return Range.getBegin(); }

  SourceLocation getEndLoc() const { return Range.getEnd(); }

  /// Retrieve the representation of the nested-name-specifier.

  NestedNameSpecifier *getScopeRep() const {

    return Builder.getRepresentation();

  }

  /// Extend the current nested-name-specifier by another

  /// nested-name-specifier component of the form 'type::'.

  ///

  /// \param Context The AST context in which this nested-name-specifier

  /// resides.

  ///

  /// \param TemplateKWLoc The location of the 'template' keyword, if present.

  ///

  /// \param TL The TypeLoc that describes the type preceding the '::'.

  ///

  /// \param ColonColonLoc The location of the trailing '::'.

  void Extend(ASTContext &Context, SourceLocation TemplateKWLoc, TypeLoc TL,

              SourceLocation ColonColonLoc);

  /// Extend the current nested-name-specifier by another

  /// nested-name-specifier component of the form 'identifier::'.

  ///

  /// \param Context The AST context in which this nested-name-specifier

  /// resides.

  ///

  /// \param Identifier The identifier.

  ///

  /// \param IdentifierLoc The location of the identifier.

  ///

  /// \param ColonColonLoc The location of the trailing '::'.

  void Extend(ASTContext &Context, IdentifierInfo *Identifier,

              SourceLocation IdentifierLoc, SourceLocation ColonColonLoc);

  /// Extend the current nested-name-specifier by another

  /// nested-name-specifier component of the form 'namespace::'.

  ///

  /// \param Context The AST context in which this nested-name-specifier

  /// resides.

  ///

  /// \param Namespace The namespace.

  ///

  /// \param NamespaceLoc The location of the namespace name.

  ///

  /// \param ColonColonLoc The location of the trailing '::'.

  void Extend(ASTContext &Context, NamespaceDecl *Namespace,

              SourceLocation NamespaceLoc, SourceLocation ColonColonLoc);

  /// Extend the current nested-name-specifier by another

  /// nested-name-specifier component of the form 'namespace-alias::'.

  ///

  /// \param Context The AST context in which this nested-name-specifier

  /// resides.

  ///

  /// \param Alias The namespace alias.

  ///

  /// \param AliasLoc The location of the namespace alias

  /// name.

  ///

  /// \param ColonColonLoc The location of the trailing '::'.

  void Extend(ASTContext &Context, NamespaceAliasDecl *Alias,

              SourceLocation AliasLoc, SourceLocation ColonColonLoc);

  /// Turn this (empty) nested-name-specifier into the global

  /// nested-name-specifier '::'.

  void MakeGlobal(ASTContext &Context, SourceLocation ColonColonLoc);

  /// Turns this (empty) nested-name-specifier into '__super'

  /// nested-name-specifier.

  ///

  /// \param Context The AST context in which this nested-name-specifier

  /// resides.

  ///

  /// \param RD The declaration of the class in which nested-name-specifier

  /// appeared.

  ///

  /// \param SuperLoc The location of the '__super' keyword.

  /// name.

  ///

  /// \param ColonColonLoc The location of the trailing '::'.

  void MakeSuper(ASTContext &Context, CXXRecordDecl *RD,

                 SourceLocation SuperLoc, SourceLocation ColonColonLoc);

  /// Make a new nested-name-specifier from incomplete source-location

  /// information.

  ///

  /// FIXME: This routine should be used very, very rarely, in cases where we

  /// need to synthesize a nested-name-specifier. Most code should instead use

  /// \c Adopt() with a proper \c NestedNameSpecifierLoc.

  void MakeTrivial(ASTContext &Context, NestedNameSpecifier *Qualifier,

                   SourceRange R);

  /// Adopt an existing nested-name-specifier (with source-range

  /// information).

  void Adopt(NestedNameSpecifierLoc Other);

  /// Retrieve a nested-name-specifier with location information, copied

  /// into the given AST context.

  ///

  /// \param Context The context into which this nested-name-specifier will be

  /// copied.

  NestedNameSpecifierLoc getWithLocInContext(ASTContext &Context) const;

  /// Retrieve the location of the name in the last qualifier

  /// in this nested name specifier.

  ///

  /// For example, the location of \c bar

  /// in

  /// \verbatim

  ///   \::foo::bar<0>::

  ///           ^~~

  /// \endverbatim

  SourceLocation getLastQualifierNameLoc() const;

  /// No scope specifier.

  bool isEmpty() const { return Range.isInvalid() && 
getScopeRep() == nullptr134M
; }

  /// A scope specifier is present, but may be valid or invalid.

  bool isNotEmpty() const { return !isEmpty(); }

  /// An error occurred during parsing of the scope specifier.

  bool isInvalid() const { return Range.isValid() && 
getScopeRep() == nullptr19.1M
; }

  /// A scope specifier is present, and it refers to a real scope.

  bool isValid() const { return getScopeRep() != nullptr; }

  /// Indicate that this nested-name-specifier is invalid.

  void SetInvalid(SourceRange R) {

    assert(R.isValid() && "Must have a valid source range");

    if (Range.getBegin().isInvalid())

      Range.setBegin(R.getBegin());

    Range.setEnd(R.getEnd());

    Builder.Clear();

  }

  /// Deprecated.  Some call sites intend isNotEmpty() while others intend

  /// isValid().

  bool isSet() const { return getScopeRep() != nullptr; }

  void clear() {

    Range = SourceRange();

    Builder.Clear();

  }

  /// Retrieve the data associated with the source-location information.

  char *location_data() const { return Builder.getBuffer().first; }

  /// Retrieve the size of the data associated with source-location

  /// information.

  unsigned location_size() const { return Builder.getBuffer().second; }

};

/// Captures information about "declaration specifiers".

///

/// "Declaration specifiers" encompasses storage-class-specifiers,

/// type-specifiers, type-qualifiers, and function-specifiers.

class DeclSpec {

public:

  /// storage-class-specifier

  /// \note The order of these enumerators is important for diagnostics.

  enum SCS {

    SCS_unspecified = 0,

    SCS_typedef,

    SCS_extern,

    SCS_static,

    SCS_auto,

    SCS_register,

    SCS_private_extern,

    SCS_mutable

  };

  // Import thread storage class specifier enumeration and constants.

  // These can be combined with SCS_extern and SCS_static.

  typedef ThreadStorageClassSpecifier TSCS;

  static const TSCS TSCS_unspecified = clang::TSCS_unspecified;

  static const TSCS TSCS___thread = clang::TSCS___thread;

  static const TSCS TSCS_thread_local = clang::TSCS_thread_local;

  static const TSCS TSCS__Thread_local = clang::TSCS__Thread_local;

  // Import type specifier width enumeration and constants.

  typedef TypeSpecifierWidth TSW;

  static const TSW TSW_unspecified = clang::TSW_unspecified;

  static const TSW TSW_short = clang::TSW_short;

  static const TSW TSW_long = clang::TSW_long;

  static const TSW TSW_longlong = clang::TSW_longlong;

  enum TSC {

    TSC_unspecified,

    TSC_imaginary,

    TSC_complex

  };

  // Import type specifier sign enumeration and constants.

  typedef TypeSpecifierSign TSS;

  static const TSS TSS_unspecified = clang::TSS_unspecified;

  static const TSS TSS_signed = clang::TSS_signed;

  static const TSS TSS_unsigned = clang::TSS_unsigned;

  // Import type specifier type enumeration and constants.

  typedef TypeSpecifierType TST;

  static const TST TST_unspecified = clang::TST_unspecified;

  static const TST TST_void = clang::TST_void;

  static const TST TST_char = clang::TST_char;

  static const TST TST_wchar = clang::TST_wchar;

  static const TST TST_char8 = clang::TST_char8;

  static const TST TST_char16 = clang::TST_char16;

  static const TST TST_char32 = clang::TST_char32;

  static const TST TST_int = clang::TST_int;

  static const TST TST_int128 = clang::TST_int128;

  static const TST TST_extint = clang::TST_extint;

  static const TST TST_half = clang::TST_half;

  static const TST TST_BFloat16 = clang::TST_BFloat16;

  static const TST TST_float = clang::TST_float;

  static const TST TST_double = clang::TST_double;

  static const TST TST_float16 = clang::TST_Float16;

  static const TST TST_accum = clang::TST_Accum;

  static const TST TST_fract = clang::TST_Fract;

  static const TST TST_float128 = clang::TST_float128;

  static const TST TST_bool = clang::TST_bool;

  static const TST TST_decimal32 = clang::TST_decimal32;

  static const TST TST_decimal64 = clang::TST_decimal64;

  static const TST TST_decimal128 = clang::TST_decimal128;

  static const TST TST_enum = clang::TST_enum;

  static const TST TST_union = clang::TST_union;

  static const TST TST_struct = clang::TST_struct;

  static const TST TST_interface = clang::TST_interface;

  static const TST TST_class = clang::TST_class;

  static const TST TST_typename = clang::TST_typename;

  static const TST TST_typeofType = clang::TST_typeofType;

  static const TST TST_typeofExpr = clang::TST_typeofExpr;

  static const TST TST_decltype = clang::TST_decltype;

  static const TST TST_decltype_auto = clang::TST_decltype_auto;

  static const TST TST_underlyingType = clang::TST_underlyingType;

  static const TST TST_auto = clang::TST_auto;

  static const TST TST_auto_type = clang::TST_auto_type;

  static const TST TST_unknown_anytype = clang::TST_unknown_anytype;

  static const TST TST_atomic = clang::TST_atomic;

#define GENERIC_IMAGE_TYPE(ImgType, Id) \

  static const TST TST_##ImgType##_t = clang::TST_##ImgType##_t;

#include "clang/Basic/OpenCLImageTypes.def"

  static const TST TST_error = clang::TST_error;

  // type-qualifiers

  enum TQ {   // NOTE: These flags must be kept in sync with Qualifiers::TQ.

    TQ_unspecified = 0,

    TQ_const       = 1,

    TQ_restrict    = 2,

    TQ_volatile    = 4,

    TQ_unaligned   = 8,

    // This has no corresponding Qualifiers::TQ value, because it's not treated

    // as a qualifier in our type system.

    TQ_atomic      = 16

  };

  /// ParsedSpecifiers - Flags to query which specifiers were applied.  This is

  /// returned by getParsedSpecifiers.

  enum ParsedSpecifiers {

    PQ_None                  = 0,

    PQ_StorageClassSpecifier = 1,

    PQ_TypeSpecifier         = 2,

    PQ_TypeQualifier         = 4,

    PQ_FunctionSpecifier     = 8

    // FIXME: Attributes should be included here.

  };

private:

  // storage-class-specifier

  /*SCS*/unsigned StorageClassSpec : 3;

  /*TSCS*/unsigned ThreadStorageClassSpec : 2;

  unsigned SCS_extern_in_linkage_spec : 1;

  // type-specifier

  /*TSW*/unsigned TypeSpecWidth : 2;

  /*TSC*/unsigned TypeSpecComplex : 2;

  /*TSS*/unsigned TypeSpecSign : 2;

  /*TST*/unsigned TypeSpecType : 6;

  unsigned TypeAltiVecVector : 1;

  unsigned TypeAltiVecPixel : 1;

  unsigned TypeAltiVecBool : 1;

  unsigned TypeSpecOwned : 1;

  unsigned TypeSpecPipe : 1;

  unsigned TypeSpecSat : 1;

  unsigned ConstrainedAuto : 1;

  // type-qualifiers

  unsigned TypeQualifiers : 5;  // Bitwise OR of TQ.

  // function-specifier

  unsigned FS_inline_specified : 1;

  unsigned FS_forceinline_specified: 1;

  unsigned FS_virtual_specified : 1;

  unsigned FS_noreturn_specified : 1;

  // friend-specifier

  unsigned Friend_specified : 1;

  // constexpr-specifier

  unsigned ConstexprSpecifier : 2;

  union {

    UnionParsedType TypeRep;

    Decl *DeclRep;

    Expr *ExprRep;

    TemplateIdAnnotation *TemplateIdRep;

  };

  /// ExplicitSpecifier - Store information about explicit spicifer.

  ExplicitSpecifier FS_explicit_specifier;

  // attributes.

  ParsedAttributes Attrs;

  // Scope specifier for the type spec, if applicable.

  CXXScopeSpec TypeScope;

  // SourceLocation info.  These are null if the item wasn't specified or if

  // the setting was synthesized.

  SourceRange Range;

  SourceLocation StorageClassSpecLoc, ThreadStorageClassSpecLoc;

  SourceRange TSWRange;

  SourceLocation TSCLoc, TSSLoc, TSTLoc, AltiVecLoc, TSSatLoc;

  /// TSTNameLoc - If TypeSpecType is any of class, enum, struct, union,

  /// typename, then this is the location of the named type (if present);

  /// otherwise, it is the same as TSTLoc. Hence, the pair TSTLoc and

  /// TSTNameLoc provides source range info for tag types.

  SourceLocation TSTNameLoc;

  SourceRange TypeofParensRange;

  SourceLocation TQ_constLoc, TQ_restrictLoc, TQ_volatileLoc, TQ_atomicLoc,

      TQ_unalignedLoc;

  SourceLocation FS_inlineLoc, FS_virtualLoc, FS_explicitLoc, FS_noreturnLoc;

  SourceLocation FS_explicitCloseParenLoc;

  SourceLocation FS_forceinlineLoc;

  SourceLocation FriendLoc, ModulePrivateLoc, ConstexprLoc;

  SourceLocation TQ_pipeLoc;

  WrittenBuiltinSpecs writtenBS;

  void SaveWrittenBuiltinSpecs();

  ObjCDeclSpec *ObjCQualifiers;

  static bool isTypeRep(TST T) {

    return (T == TST_typename || 
T == TST_typeofType7.67M
 ||

            T == TST_underlyingType || 
T == TST_atomic7.67M
);

  }

  static bool isExprRep(TST T) {

    return (T == TST_typeofExpr || 
T == TST_decltype7.80M
 || 
T == TST_extint7.66M
);

  }

  static bool isTemplateIdRep(TST T) {

    return (T == TST_auto || 
T == TST_decltype_auto18
);

  }

  DeclSpec(const DeclSpec &) = delete;

  void operator=(const DeclSpec &) = delete;

public:

  static bool isDeclRep(TST T) {

    return (T == TST_enum || 
T == TST_struct37.6M
 ||

            T == TST_interface || 
T == TST_union24.7M
 ||

            T == TST_class);

  }

  DeclSpec(AttributeFactory &attrFactory)

      : StorageClassSpec(SCS_unspecified),

        ThreadStorageClassSpec(TSCS_unspecified),

        SCS_extern_in_linkage_spec(false), TypeSpecWidth(TSW_unspecified),

        TypeSpecComplex(TSC_unspecified), TypeSpecSign(TSS_unspecified),

        TypeSpecType(TST_unspecified), TypeAltiVecVector(false),

        TypeAltiVecPixel(false), TypeAltiVecBool(false), TypeSpecOwned(false),

        TypeSpecPipe(false), TypeSpecSat(false), ConstrainedAuto(false),

        TypeQualifiers(TQ_unspecified),

        FS_inline_specified(false), FS_forceinline_specified(false),

        FS_virtual_specified(false), FS_noreturn_specified(false),

        Friend_specified(false), ConstexprSpecifier(CSK_unspecified),

        FS_explicit_specifier(), Attrs(attrFactory), writtenBS(),

        ObjCQualifiers(nullptr) {}

  // storage-class-specifier

  SCS getStorageClassSpec() const { return (SCS)StorageClassSpec; }

  TSCS getThreadStorageClassSpec() const {

    return (TSCS)ThreadStorageClassSpec;

  }

  bool isExternInLinkageSpec() const { return SCS_extern_in_linkage_spec; }

  void setExternInLinkageSpec(bool Value) {

    SCS_extern_in_linkage_spec = Value;

  }

  SourceLocation getStorageClassSpecLoc() const { return StorageClassSpecLoc; }

  SourceLocation getThreadStorageClassSpecLoc() const {

    return ThreadStorageClassSpecLoc;

  }

  void ClearStorageClassSpecs() {

    StorageClassSpec           = DeclSpec::SCS_unspecified;

    ThreadStorageClassSpec     = DeclSpec::TSCS_unspecified;

    SCS_extern_in_linkage_spec = false;

    StorageClassSpecLoc        = SourceLocation();

    ThreadStorageClassSpecLoc  = SourceLocation();

  }

  void ClearTypeSpecType() {

    TypeSpecType = DeclSpec::TST_unspecified;

    TypeSpecOwned = false;

    TSTLoc = SourceLocation();

  }

  // type-specifier

  TSW getTypeSpecWidth() const { return (TSW)TypeSpecWidth; }

  TSC getTypeSpecComplex() const { return (TSC)TypeSpecComplex; }

  TSS getTypeSpecSign() const { return (TSS)TypeSpecSign; }

  TST getTypeSpecType() const { return (TST)TypeSpecType; }

  bool isTypeAltiVecVector() const { return TypeAltiVecVector; }

  bool isTypeAltiVecPixel() const { return TypeAltiVecPixel; }

  bool isTypeAltiVecBool() const { return TypeAltiVecBool; }

  bool isTypeSpecOwned() const { return TypeSpecOwned; }

  bool isTypeRep() const { return isTypeRep((TST) TypeSpecType); }

  bool isTypeSpecPipe() const { return TypeSpecPipe; }

  bool isTypeSpecSat() const { return TypeSpecSat; }

  bool isConstrainedAuto() const { return ConstrainedAuto; }

  ParsedType getRepAsType() const {

    assert(isTypeRep((TST) TypeSpecType) && "DeclSpec does not store a type");

    return TypeRep;

  }

  Decl *getRepAsDecl() const {

    assert(isDeclRep((TST) TypeSpecType) && "DeclSpec does not store a decl");

    return DeclRep;

  }

  Expr *getRepAsExpr() const {

    assert(isExprRep((TST) TypeSpecType) && "DeclSpec does not store an expr");

    return ExprRep;

  }

  TemplateIdAnnotation *getRepAsTemplateId() const {

    assert(isTemplateIdRep((TST) TypeSpecType) &&

           "DeclSpec does not store a template id");

    return TemplateIdRep;

  }

  CXXScopeSpec &getTypeSpecScope() { return TypeScope; }

  const CXXScopeSpec &getTypeSpecScope() const { return TypeScope; }

  SourceRange getSourceRange() const LLVM_READONLY { return Range; }

  SourceLocation getBeginLoc() const LLVM_READONLY { return Range.getBegin(); }

  SourceLocation getEndLoc() const LLVM_READONLY { return Range.getEnd(); }

  SourceLocation getTypeSpecWidthLoc() const { return TSWRange.getBegin(); }

  SourceRange getTypeSpecWidthRange() const { return TSWRange; }

  SourceLocation getTypeSpecComplexLoc() const { return TSCLoc; }

  SourceLocation getTypeSpecSignLoc() const { return TSSLoc; }

  SourceLocation getTypeSpecTypeLoc() const { return TSTLoc; }

  SourceLocation getAltiVecLoc() const { return AltiVecLoc; }

  SourceLocation getTypeSpecSatLoc() const { return TSSatLoc; }

  SourceLocation getTypeSpecTypeNameLoc() const {

    assert(isDeclRep((TST) TypeSpecType) || TypeSpecType == TST_typename);

    return TSTNameLoc;

  }

  SourceRange getTypeofParensRange() const { return TypeofParensRange; }

  void setTypeofParensRange(SourceRange range) { TypeofParensRange = range; }

  bool hasAutoTypeSpec() const {

    return (TypeSpecType == TST_auto || 
TypeSpecType == TST_auto_type28.4M
 ||

            TypeSpecType == TST_decltype_auto);

  }

  bool hasTagDefinition() const;

  /// Turn a type-specifier-type into a string like "_Bool" or "union".

  static const char *getSpecifierName(DeclSpec::TST T,

                                      const PrintingPolicy &Policy);

  static const char *getSpecifierName(DeclSpec::TQ Q);

  static const char *getSpecifierName(DeclSpec::TSS S);

  static const char *getSpecifierName(DeclSpec::TSC C);

  static const char *getSpecifierName(DeclSpec::TSW W);

  static const char *getSpecifierName(DeclSpec::SCS S);

  static const char *getSpecifierName(DeclSpec::TSCS S);

  static const char *getSpecifierName(ConstexprSpecKind C);

  // type-qualifiers

  /// getTypeQualifiers - Return a set of TQs.

  unsigned getTypeQualifiers() const { return TypeQualifiers; }

  SourceLocation getConstSpecLoc() const { return TQ_constLoc; }

  SourceLocation getRestrictSpecLoc() const { return TQ_restrictLoc; }

  SourceLocation getVolatileSpecLoc() const { return TQ_volatileLoc; }

  SourceLocation getAtomicSpecLoc() const { return TQ_atomicLoc; }

  SourceLocation getUnalignedSpecLoc() const { return TQ_unalignedLoc; }

  SourceLocation getPipeLoc() const { return TQ_pipeLoc; }

  /// Clear out all of the type qualifiers.

  void ClearTypeQualifiers() {

    TypeQualifiers = 0;

    TQ_constLoc = SourceLocation();

    TQ_restrictLoc = SourceLocation();

    TQ_volatileLoc = SourceLocation();

    TQ_atomicLoc = SourceLocation();

    TQ_unalignedLoc = SourceLocation();

    TQ_pipeLoc = SourceLocation();

  }

  // function-specifier

  bool isInlineSpecified() const {

    return FS_inline_specified | FS_forceinline_specified;

  }

  SourceLocation getInlineSpecLoc() const {

    return FS_inline_specified ? FS_inlineLoc : 
FS_forceinlineLoc7
;

  }

  ExplicitSpecifier getExplicitSpecifier() const {

    return FS_explicit_specifier;

  }

  bool isVirtualSpecified() const { return FS_virtual_specified; }

  SourceLocation getVirtualSpecLoc() const { return FS_virtualLoc; }

  bool hasExplicitSpecifier() const {

    return FS_explicit_specifier.isSpecified();

  }

  SourceLocation getExplicitSpecLoc() const { return FS_explicitLoc; }

  SourceRange getExplicitSpecRange() const {

    return FS_explicit_specifier.getExpr()

               ? SourceRange(FS_explicitLoc, FS_explicitCloseParenLoc)

               : SourceRange(FS_explicitLoc);

  }

  bool isNoreturnSpecified() const { return FS_noreturn_specified; }

  SourceLocation getNoreturnSpecLoc() const { return FS_noreturnLoc; }

  void ClearFunctionSpecs() {

    FS_inline_specified = false;

    FS_inlineLoc = SourceLocation();

    FS_forceinline_specified = false;

    FS_forceinlineLoc = SourceLocation();

    FS_virtual_specified = false;

    FS_virtualLoc = SourceLocation();

    FS_explicit_specifier = ExplicitSpecifier();

    FS_explicitLoc = SourceLocation();

    FS_explicitCloseParenLoc = SourceLocation();

    FS_noreturn_specified = false;

    FS_noreturnLoc = SourceLocation();

  }

  /// This method calls the passed in handler on each CVRU qual being

  /// set.

  /// Handle - a handler to be invoked.

  void forEachCVRUQualifier(

      llvm::function_ref<void(TQ, StringRef, SourceLocation)> Handle);

  /// This method calls the passed in handler on each qual being

  /// set.

  /// Handle - a handler to be invoked.

  void forEachQualifier(

      llvm::function_ref<void(TQ, StringRef, SourceLocation)> Handle);

  /// Return true if any type-specifier has been found.

  bool hasTypeSpecifier() const {

    return getTypeSpecType() != DeclSpec::TST_unspecified ||

           getTypeSpecWidth() != DeclSpec::TSW_unspecified ||

           getTypeSpecComplex() != DeclSpec::TSC_unspecified ||

           getTypeSpecSign() != DeclSpec::TSS_unspecified;

  }

  /// Return a bitmask of which flavors of specifiers this

  /// DeclSpec includes.

  unsigned getParsedSpecifiers() const;

  /// isEmpty - Return true if this declaration specifier is completely empty:

  /// no tokens were parsed in the production of it.

  bool isEmpty() const {

    return getParsedSpecifiers() == DeclSpec::PQ_None;

  }

  void SetRangeStart(SourceLocation Loc) { Range.setBegin(Loc); }

  void SetRangeEnd(SourceLocation Loc) { Range.setEnd(Loc); }

  /// These methods set the specified attribute of the DeclSpec and

  /// return false if there was no error.  If an error occurs (for

  /// example, if we tried to set "auto" on a spec with "extern"

  /// already set), they return true and set PrevSpec and DiagID

  /// such that

  ///   Diag(Loc, DiagID) << PrevSpec;

  /// will yield a useful result.

  ///

  /// TODO: use a more general approach that still allows these

  /// diagnostics to be ignored when desired.

  bool SetStorageClassSpec(Sema &S, SCS SC, SourceLocation Loc,

                           const char *&PrevSpec, unsigned &DiagID,

                           const PrintingPolicy &Policy);

  bool SetStorageClassSpecThread(TSCS TSC, SourceLocation Loc,

                                 const char *&PrevSpec, unsigned &DiagID);

  bool SetTypeSpecWidth(TSW W, SourceLocation Loc, const char *&PrevSpec,

                        unsigned &DiagID, const PrintingPolicy &Policy);

  bool SetTypeSpecComplex(TSC C, SourceLocation Loc, const char *&PrevSpec,

                          unsigned &DiagID);

  bool SetTypeSpecSign(TSS S, SourceLocation Loc, const char *&PrevSpec,

                       unsigned &DiagID);

  bool SetTypeSpecType(TST T, SourceLocation Loc, const char *&PrevSpec,

                       unsigned &DiagID, const PrintingPolicy &Policy);

  bool SetTypeSpecType(TST T, SourceLocation Loc, const char *&PrevSpec,

                       unsigned &DiagID, ParsedType Rep,

                       const PrintingPolicy &Policy);

  bool SetTypeSpecType(TST T, SourceLocation Loc, const char *&PrevSpec,

                       unsigned &DiagID, TypeResult Rep,

                       const PrintingPolicy &Policy) {

    if (Rep.isInvalid())

      return SetTypeSpecError();

    return SetTypeSpecType(T, Loc, PrevSpec, DiagID, Rep.get(), Policy);

  }

  bool SetTypeSpecType(TST T, SourceLocation Loc, const char *&PrevSpec,

                       unsigned &DiagID, Decl *Rep, bool Owned,

                       const PrintingPolicy &Policy);

  bool SetTypeSpecType(TST T, SourceLocation TagKwLoc,

                       SourceLocation TagNameLoc, const char *&PrevSpec,

                       unsigned &DiagID, ParsedType Rep,

                       const PrintingPolicy &Policy);

  bool SetTypeSpecType(TST T, SourceLocation TagKwLoc,

                       SourceLocation TagNameLoc, const char *&PrevSpec,

                       unsigned &DiagID, Decl *Rep, bool Owned,

                       const PrintingPolicy &Policy);

  bool SetTypeSpecType(TST T, SourceLocation Loc, const char *&PrevSpec,

                       unsigned &DiagID, TemplateIdAnnotation *Rep,

                       const PrintingPolicy &Policy);

  bool SetTypeSpecType(TST T, SourceLocation Loc, const char *&PrevSpec,

                       unsigned &DiagID, Expr *Rep,

                       const PrintingPolicy &policy);

  bool SetTypeAltiVecVector(bool isAltiVecVector, SourceLocation Loc,

                       const char *&PrevSpec, unsigned &DiagID,

                       const PrintingPolicy &Policy);

  bool SetTypeAltiVecPixel(bool isAltiVecPixel, SourceLocation Loc,

                       const char *&PrevSpec, unsigned &DiagID,

                       const PrintingPolicy &Policy);

  bool SetTypeAltiVecBool(bool isAltiVecBool, SourceLocation Loc,

                       const char *&PrevSpec, unsigned &DiagID,

                       const PrintingPolicy &Policy);

  bool SetTypePipe(bool isPipe, SourceLocation Loc,

                       const char *&PrevSpec, unsigned &DiagID,

                       const PrintingPolicy &Policy);

  bool SetExtIntType(SourceLocation KWLoc, Expr *BitWidth,

                     const char *&PrevSpec, unsigned &DiagID,

                     const PrintingPolicy &Policy);

  bool SetTypeSpecSat(SourceLocation Loc, const char *&PrevSpec,

                      unsigned &DiagID);

  bool SetTypeSpecError();

  void UpdateDeclRep(Decl *Rep) {

    assert(isDeclRep((TST) TypeSpecType));

    DeclRep = Rep;

  }

  void UpdateTypeRep(ParsedType Rep) {

    assert(isTypeRep((TST) TypeSpecType));

    TypeRep = Rep;

  }

  void UpdateExprRep(Expr *Rep) {

    assert(isExprRep((TST) TypeSpecType));

    ExprRep = Rep;

  }

  bool SetTypeQual(TQ T, SourceLocation Loc);

  bool SetTypeQual(TQ T, SourceLocation Loc, const char *&PrevSpec,

                   unsigned &DiagID, const LangOptions &Lang);

  bool setFunctionSpecInline(SourceLocation Loc, const char *&PrevSpec,

                             unsigned &DiagID);

  bool setFunctionSpecForceInline(SourceLocation Loc, const char *&PrevSpec,

                                  unsigned &DiagID);

  bool setFunctionSpecVirtual(SourceLocation Loc, const char *&PrevSpec,

                              unsigned &DiagID);

  bool setFunctionSpecExplicit(SourceLocation Loc, const char *&PrevSpec,

                               unsigned &DiagID, ExplicitSpecifier ExplicitSpec,

                               SourceLocation CloseParenLoc);

  bool setFunctionSpecNoreturn(SourceLocation Loc, const char *&PrevSpec,

                               unsigned &DiagID);

  bool SetFriendSpec(SourceLocation Loc, const char *&PrevSpec,

                     unsigned &DiagID);

  bool setModulePrivateSpec(SourceLocation Loc, const char *&PrevSpec,

                            unsigned &DiagID);

  bool SetConstexprSpec(ConstexprSpecKind ConstexprKind, SourceLocation Loc,

                        const char *&PrevSpec, unsigned &DiagID);

  bool isFriendSpecified() const { return Friend_specified; }

  SourceLocation getFriendSpecLoc() const { return FriendLoc; }

  bool isModulePrivateSpecified() const { return ModulePrivateLoc.isValid(); }

  SourceLocation getModulePrivateSpecLoc() const { return ModulePrivateLoc; }

  ConstexprSpecKind getConstexprSpecifier() const {

    return ConstexprSpecKind(ConstexprSpecifier);

  }

  SourceLocation getConstexprSpecLoc() const { return ConstexprLoc; }

  bool hasConstexprSpecifier() const {

    return ConstexprSpecifier != CSK_unspecified;

  }

  void ClearConstexprSpec() {

    ConstexprSpecifier = CSK_unspecified;

    ConstexprLoc = SourceLocation();

  }

  AttributePool &getAttributePool() const {

    return Attrs.getPool();

  }

  /// Concatenates two attribute lists.

  ///

  /// The GCC attribute syntax allows for the following:

  ///

  /// \code

  /// short __attribute__(( unused, deprecated ))

  /// int __attribute__(( may_alias, aligned(16) )) var;

  /// \endcode

  ///

  /// This declares 4 attributes using 2 lists. The following syntax is

  /// also allowed and equivalent to the previous declaration.

  ///

  /// \code

  /// short __attribute__((unused)) __attribute__((deprecated))

  /// int __attribute__((may_alias)) __attribute__((aligned(16))) var;

  /// \endcode

  ///

  void addAttributes(ParsedAttributesView &AL) {

    Attrs.addAll(AL.begin(), AL.end());

  }

  bool hasAttributes() const { return !Attrs.empty(); }

  ParsedAttributes &getAttributes() { return Attrs; }

  const ParsedAttributes &getAttributes() const { return Attrs; }

  void takeAttributesFrom(ParsedAttributes &attrs) {

    Attrs.takeAllFrom(attrs);

  }

  /// Finish - This does final analysis of the declspec, issuing diagnostics for

  /// things like "_Imaginary" (lacking an FP type).  After calling this method,

  /// DeclSpec is guaranteed self-consistent, even if an error occurred.

  void Finish(Sema &S, const PrintingPolicy &Policy);

  const WrittenBuiltinSpecs& getWrittenBuiltinSpecs() const {

    return writtenBS;

  }

  ObjCDeclSpec *getObjCQualifiers() const { return ObjCQualifiers; }

  void setObjCQualifiers(ObjCDeclSpec *quals) { ObjCQualifiers = quals; }

  /// Checks if this DeclSpec can stand alone, without a Declarator.

  ///

  /// Only tag declspecs can stand alone.

  bool isMissingDeclaratorOk();

};

/// Captures information about "declaration specifiers" specific to

/// Objective-C.

class ObjCDeclSpec {

public:

  /// ObjCDeclQualifier - Qualifier used on types in method

  /// declarations.  Not all combinations are sensible.  Parameters

  /// can be one of { in, out, inout } with one of { bycopy, byref }.

  /// Returns can either be { oneway } or not.

  ///

  /// This should be kept in sync with Decl::ObjCDeclQualifier.

  enum ObjCDeclQualifier {

    DQ_None = 0x0,

    DQ_In = 0x1,

    DQ_Inout = 0x2,

    DQ_Out = 0x4,

    DQ_Bycopy = 0x8,

    DQ_Byref = 0x10,

    DQ_Oneway = 0x20,

    DQ_CSNullability = 0x40

  };

  ObjCDeclSpec()

      : objcDeclQualifier(DQ_None),

        PropertyAttributes(ObjCPropertyAttribute::kind_noattr), Nullability(0),

        GetterName(nullptr), SetterName(nullptr) {}

  ObjCDeclQualifier getObjCDeclQualifier() const {

    return (ObjCDeclQualifier)objcDeclQualifier;

  }

  void setObjCDeclQualifier(ObjCDeclQualifier DQVal) {

    objcDeclQualifier = (ObjCDeclQualifier) (objcDeclQualifier | DQVal);

  }

  void clearObjCDeclQualifier(ObjCDeclQualifier DQVal) {

    objcDeclQualifier = (ObjCDeclQualifier) (objcDeclQualifier & ~DQVal);

  }

  ObjCPropertyAttribute::Kind getPropertyAttributes() const {

    return ObjCPropertyAttribute::Kind(PropertyAttributes);

  }

  void setPropertyAttributes(ObjCPropertyAttribute::Kind PRVal) {

    PropertyAttributes =

        (ObjCPropertyAttribute::Kind)(PropertyAttributes | PRVal);

  }

  NullabilityKind getNullability() const {

    assert(

        ((getObjCDeclQualifier() & DQ_CSNullability) ||

         (getPropertyAttributes() & ObjCPropertyAttribute::kind_nullability)) &&

        "Objective-C declspec doesn't have nullability");

    return static_cast<NullabilityKind>(Nullability);

  }

  SourceLocation getNullabilityLoc() const {

    assert(

        ((getObjCDeclQualifier() & DQ_CSNullability) ||

         (getPropertyAttributes() & ObjCPropertyAttribute::kind_nullability)) &&

        "Objective-C declspec doesn't have nullability");

    return NullabilityLoc;

  }

  void setNullability(SourceLocation loc, NullabilityKind kind) {

    assert(

        ((getObjCDeclQualifier() & DQ_CSNullability) ||

         (getPropertyAttributes() & ObjCPropertyAttribute::kind_nullability)) &&

        "Set the nullability declspec or property attribute first");

    Nullability = static_cast<unsigned>(kind);

    NullabilityLoc = loc;

  }

  const IdentifierInfo *getGetterName() const { return GetterName; }

  IdentifierInfo *getGetterName() { return GetterName; }

  SourceLocation getGetterNameLoc() const { return GetterNameLoc; }

  void setGetterName(IdentifierInfo *name, SourceLocation loc) {

    GetterName = name;

    GetterNameLoc = loc;

  }

  const IdentifierInfo *getSetterName() const { return SetterName; }

  IdentifierInfo *getSetterName() { return SetterName; }

  SourceLocation getSetterNameLoc() const { return SetterNameLoc; }

  void setSetterName(IdentifierInfo *name, SourceLocation loc) {

    SetterName = name;

    SetterNameLoc = loc;

  }

private:

  // FIXME: These two are unrelated and mutually exclusive. So perhaps

  // we can put them in a union to reflect their mutual exclusivity

  // (space saving is negligible).

  unsigned objcDeclQualifier : 7;

  // NOTE: VC++ treats enums as signed, avoid using ObjCPropertyAttribute::Kind

  unsigned PropertyAttributes : NumObjCPropertyAttrsBits;

  unsigned Nullability : 2;

  SourceLocation NullabilityLoc;

  IdentifierInfo *GetterName;    // getter name or NULL if no getter

  IdentifierInfo *SetterName;    // setter name or NULL if no setter

  SourceLocation GetterNameLoc; // location of the getter attribute's value

  SourceLocation SetterNameLoc; // location of the setter attribute's value

};

/// Describes the kind of unqualified-id parsed.

enum class UnqualifiedIdKind {

  /// An identifier.

  IK_Identifier,

  /// An overloaded operator name, e.g., operator+.

  IK_OperatorFunctionId,

  /// A conversion function name, e.g., operator int.

  IK_ConversionFunctionId,

  /// A user-defined literal name, e.g., operator "" _i.

  IK_LiteralOperatorId,

  /// A constructor name.

  IK_ConstructorName,

  /// A constructor named via a template-id.

  IK_ConstructorTemplateId,

  /// A destructor name.

  IK_DestructorName,

  /// A template-id, e.g., f<int>.

  IK_TemplateId,

  /// An implicit 'self' parameter

  IK_ImplicitSelfParam,

  /// A deduction-guide name (a template-name)

  IK_DeductionGuideName

};

/// Represents a C++ unqualified-id that has been parsed.

class UnqualifiedId {

private:

  UnqualifiedId(const UnqualifiedId &Other) = delete;

  const UnqualifiedId &operator=(const UnqualifiedId &) = delete;

public:

  /// Describes the kind of unqualified-id parsed.

  UnqualifiedIdKind Kind;

  struct OFI {

    /// The kind of overloaded operator.

    OverloadedOperatorKind Operator;

    /// The source locations of the individual tokens that name

    /// the operator, e.g., the "new", "[", and "]" tokens in

    /// operator new [].

    ///

    /// Different operators have different numbers of tokens in their name,

    /// up to three. Any remaining source locations in this array will be

    /// set to an invalid value for operators with fewer than three tokens.

    unsigned SymbolLocations[3];

  };

  /// Anonymous union that holds extra data associated with the

  /// parsed unqualified-id.

  union {

    /// When Kind == IK_Identifier, the parsed identifier, or when

    /// Kind == IK_UserLiteralId, the identifier suffix.

    IdentifierInfo *Identifier;

    /// When Kind == IK_OperatorFunctionId, the overloaded operator

    /// that we parsed.

    struct OFI OperatorFunctionId;

    /// When Kind == IK_ConversionFunctionId, the type that the

    /// conversion function names.

    UnionParsedType ConversionFunctionId;

    /// When Kind == IK_ConstructorName, the class-name of the type

    /// whose constructor is being referenced.

    UnionParsedType ConstructorName;

    /// When Kind == IK_DestructorName, the type referred to by the

    /// class-name.

    UnionParsedType DestructorName;

    /// When Kind == IK_DeductionGuideName, the parsed template-name.

    UnionParsedTemplateTy TemplateName;

    /// When Kind == IK_TemplateId or IK_ConstructorTemplateId,

    /// the template-id annotation that contains the template name and

    /// template arguments.

    TemplateIdAnnotation *TemplateId;

  };

  /// The location of the first token that describes this unqualified-id,

  /// which will be the location of the identifier, "operator" keyword,

  /// tilde (for a destructor), or the template name of a template-id.

  SourceLocation StartLocation;

  /// The location of the last token that describes this unqualified-id.

  SourceLocation EndLocation;

  UnqualifiedId()

      : Kind(UnqualifiedIdKind::IK_Identifier), Identifier(nullptr) {}

  /// Clear out this unqualified-id, setting it to default (invalid)

  /// state.

  void clear() {

    Kind = UnqualifiedIdKind::IK_Identifier;

    Identifier = nullptr;

    StartLocation = SourceLocation();

    EndLocation = SourceLocation();

  }

  /// Determine whether this unqualified-id refers to a valid name.

  bool isValid() const { return StartLocation.isValid(); }

  /// Determine whether this unqualified-id refers to an invalid name.

  bool isInvalid() const { return !isValid(); }

  /// Determine what kind of name we have.

  UnqualifiedIdKind getKind() const { return Kind; }

  void setKind(UnqualifiedIdKind kind) { Kind = kind; }

  /// Specify that this unqualified-id was parsed as an identifier.

  ///

  /// \param Id the parsed identifier.

  /// \param IdLoc the location of the parsed identifier.

  void setIdentifier(const IdentifierInfo *Id, SourceLocation IdLoc) {

    Kind = UnqualifiedIdKind::IK_Identifier;

    Identifier = const_cast<IdentifierInfo *>(Id);

    StartLocation = EndLocation = IdLoc;

  }

  /// Specify that this unqualified-id was parsed as an

  /// operator-function-id.

  ///

  /// \param OperatorLoc the location of the 'operator' keyword.

  ///

  /// \param Op the overloaded operator.

  ///

  /// \param SymbolLocations the locations of the individual operator symbols

  /// in the operator.

  void setOperatorFunctionId(SourceLocation OperatorLoc,

                             OverloadedOperatorKind Op,

                             SourceLocation SymbolLocations[3]);

  /// Specify that this unqualified-id was parsed as a

  /// conversion-function-id.

  ///

  /// \param OperatorLoc the location of the 'operator' keyword.

  ///

  /// \param Ty the type to which this conversion function is converting.

  ///

  /// \param EndLoc the location of the last token that makes up the type name.

  void setConversionFunctionId(SourceLocation OperatorLoc,

                               ParsedType Ty,

                               SourceLocation EndLoc) {

    Kind = UnqualifiedIdKind::IK_ConversionFunctionId;

    StartLocation = OperatorLoc;

    EndLocation = EndLoc;

    ConversionFunctionId = Ty;

  }

  /// Specific that this unqualified-id was parsed as a

  /// literal-operator-id.

  ///

  /// \param Id the parsed identifier.

  ///

  /// \param OpLoc the location of the 'operator' keyword.

  ///

  /// \param IdLoc the location of the identifier.

  void setLiteralOperatorId(const IdentifierInfo *Id, SourceLocation OpLoc,

                              SourceLocation IdLoc) {

    Kind = UnqualifiedIdKind::IK_LiteralOperatorId;

    Identifier = const_cast<IdentifierInfo *>(Id);