Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

//===- DeclObjC.h - Classes for representing declarations -------*- 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

//

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

//

//  This file defines the DeclObjC interface and subclasses.

//

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

#ifndef LLVM_CLANG_AST_DECLOBJC_H

#define LLVM_CLANG_AST_DECLOBJC_H

#include "clang/AST/Decl.h"

#include "clang/AST/DeclBase.h"

#include "clang/AST/DeclObjCCommon.h"

#include "clang/AST/ExternalASTSource.h"

#include "clang/AST/Redeclarable.h"

#include "clang/AST/SelectorLocationsKind.h"

#include "clang/AST/Type.h"

#include "clang/Basic/IdentifierTable.h"

#include "clang/Basic/LLVM.h"

#include "clang/Basic/SourceLocation.h"

#include "clang/Basic/Specifiers.h"

#include "llvm/ADT/ArrayRef.h"

#include "llvm/ADT/DenseSet.h"

#include "llvm/ADT/MapVector.h"

#include "llvm/ADT/PointerIntPair.h"

#include "llvm/ADT/STLExtras.h"

#include "llvm/ADT/StringRef.h"

#include "llvm/ADT/iterator_range.h"

#include "llvm/Support/Compiler.h"

#include "llvm/Support/TrailingObjects.h"

#include <cassert>

#include <cstddef>

#include <cstdint>

#include <iterator>

#include <string>

#include <utility>

namespace clang {

class ASTContext;

class CompoundStmt;

class CXXCtorInitializer;

class Expr;

class ObjCCategoryDecl;

class ObjCCategoryImplDecl;

class ObjCImplementationDecl;

class ObjCInterfaceDecl;

class ObjCIvarDecl;

class ObjCPropertyDecl;

class ObjCPropertyImplDecl;

class ObjCProtocolDecl;

class Stmt;

class ObjCListBase {

protected:

  /// List is an array of pointers to objects that are not owned by this object.

  void **List = nullptr;

  unsigned NumElts = 0;

public:

  ObjCListBase() = default;

  ObjCListBase(const ObjCListBase &) = delete;

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

  unsigned size() const { return NumElts; }

  bool empty() const { return NumElts == 0; }

protected:

  void set(void *const* InList, unsigned Elts, ASTContext &Ctx);

};

/// ObjCList - This is a simple template class used to hold various lists of

/// decls etc, which is heavily used by the ObjC front-end.  This only use case

/// this supports is setting the list all at once and then reading elements out

/// of it.

template <typename T>

class ObjCList : public ObjCListBase {

public:

  void set(T* const* InList, unsigned Elts, ASTContext &Ctx) {

    ObjCListBase::set(reinterpret_cast<void*const*>(InList), Elts, Ctx);

  }

  using iterator = T* const *;

  iterator begin() const { return (iterator)List; }

  iterator end() const { return (iterator)List+NumElts; }

  T* operator[](unsigned Idx) const {

    assert(Idx < NumElts && "Invalid access");

    return (T*)List[Idx];

  }

};

/// A list of Objective-C protocols, along with the source

/// locations at which they were referenced.

class ObjCProtocolList : public ObjCList<ObjCProtocolDecl> {

  SourceLocation *Locations = nullptr;

  using ObjCList<ObjCProtocolDecl>::set;

public:

  ObjCProtocolList() = default;

  using loc_iterator = const SourceLocation *;

  loc_iterator loc_begin() const { return Locations; }

  loc_iterator loc_end() const { return Locations + size(); }

  void set(ObjCProtocolDecl* const* InList, unsigned Elts,

           const SourceLocation *Locs, ASTContext &Ctx);

};

/// ObjCMethodDecl - Represents an instance or class method declaration.

/// ObjC methods can be declared within 4 contexts: class interfaces,

/// categories, protocols, and class implementations. While C++ member

/// functions leverage C syntax, Objective-C method syntax is modeled after

/// Smalltalk (using colons to specify argument types/expressions).

/// Here are some brief examples:

///

/// Setter/getter instance methods:

/// - (void)setMenu:(NSMenu *)menu;

/// - (NSMenu *)menu;

///

/// Instance method that takes 2 NSView arguments:

/// - (void)replaceSubview:(NSView *)oldView with:(NSView *)newView;

///

/// Getter class method:

/// + (NSMenu *)defaultMenu;

///

/// A selector represents a unique name for a method. The selector names for

/// the above methods are setMenu:, menu, replaceSubview:with:, and defaultMenu.

///

class ObjCMethodDecl : public NamedDecl, public DeclContext {

  // This class stores some data in DeclContext::ObjCMethodDeclBits

  // to save some space. Use the provided accessors to access it.

public:

  enum ImplementationControl { None, Required, Optional };

private:

  /// Return type of this method.

  QualType MethodDeclType;

  /// Type source information for the return type.

  TypeSourceInfo *ReturnTInfo;

  /// Array of ParmVarDecls for the formal parameters of this method

  /// and optionally followed by selector locations.

  void *ParamsAndSelLocs = nullptr;

  unsigned NumParams = 0;

  /// List of attributes for this method declaration.

  SourceLocation DeclEndLoc; // the location of the ';' or '{'.

  /// The following are only used for method definitions, null otherwise.

  LazyDeclStmtPtr Body;

  /// SelfDecl - Decl for the implicit self parameter. This is lazily

  /// constructed by createImplicitParams.

  ImplicitParamDecl *SelfDecl = nullptr;

  /// CmdDecl - Decl for the implicit _cmd parameter. This is lazily

  /// constructed by createImplicitParams.

  ImplicitParamDecl *CmdDecl = nullptr;

  ObjCMethodDecl(SourceLocation beginLoc, SourceLocation endLoc,

                 Selector SelInfo, QualType T, TypeSourceInfo *ReturnTInfo,

                 DeclContext *contextDecl, bool isInstance = true,

                 bool isVariadic = false, bool isPropertyAccessor = false,

                 bool isSynthesizedAccessorStub = false,

                 bool isImplicitlyDeclared = false, bool isDefined = false,

                 ImplementationControl impControl = None,

                 bool HasRelatedResultType = false);

  SelectorLocationsKind getSelLocsKind() const {

    return static_cast<SelectorLocationsKind>(ObjCMethodDeclBits.SelLocsKind);

  }

  void setSelLocsKind(SelectorLocationsKind Kind) {

    ObjCMethodDeclBits.SelLocsKind = Kind;

  }

  bool hasStandardSelLocs() const {

    return getSelLocsKind() != SelLoc_NonStandard;

  }

  /// Get a pointer to the stored selector identifiers locations array.

  /// No locations will be stored if HasStandardSelLocs is true.

  SourceLocation *getStoredSelLocs() {

    return reinterpret_cast<SourceLocation *>(getParams() + NumParams);

  }

  const SourceLocation *getStoredSelLocs() const {

    return reinterpret_cast<const SourceLocation *>(getParams() + NumParams);

  }

  /// Get a pointer to the stored selector identifiers locations array.

  /// No locations will be stored if HasStandardSelLocs is true.

  ParmVarDecl **getParams() {

    return reinterpret_cast<ParmVarDecl **>(ParamsAndSelLocs);

  }

  const ParmVarDecl *const *getParams() const {

    return reinterpret_cast<const ParmVarDecl *const *>(ParamsAndSelLocs);

  }

  /// Get the number of stored selector identifiers locations.

  /// No locations will be stored if HasStandardSelLocs is true.

  unsigned getNumStoredSelLocs() const {

    if (hasStandardSelLocs())

      return 0;

    return getNumSelectorLocs();

  }

  void setParamsAndSelLocs(ASTContext &C,

                           ArrayRef<ParmVarDecl*> Params,

                           ArrayRef<SourceLocation> SelLocs);

  /// A definition will return its interface declaration.

  /// An interface declaration will return its definition.

  /// Otherwise it will return itself.

  ObjCMethodDecl *getNextRedeclarationImpl() override;

public:

  friend class ASTDeclReader;

  friend class ASTDeclWriter;

  static ObjCMethodDecl *

  Create(ASTContext &C, SourceLocation beginLoc, SourceLocation endLoc,

         Selector SelInfo, QualType T, TypeSourceInfo *ReturnTInfo,

         DeclContext *contextDecl, bool isInstance = true,

         bool isVariadic = false, bool isPropertyAccessor = false,

         bool isSynthesizedAccessorStub = false,

         bool isImplicitlyDeclared = false, bool isDefined = false,

         ImplementationControl impControl = None,

         bool HasRelatedResultType = false);

  static ObjCMethodDecl *CreateDeserialized(ASTContext &C, unsigned ID);

  ObjCMethodDecl *getCanonicalDecl() override;

  const ObjCMethodDecl *getCanonicalDecl() const {

    return const_cast<ObjCMethodDecl*>(this)->getCanonicalDecl();

  }

  ObjCDeclQualifier getObjCDeclQualifier() const {

    return static_cast<ObjCDeclQualifier>(ObjCMethodDeclBits.objcDeclQualifier);

  }

  void setObjCDeclQualifier(ObjCDeclQualifier QV) {

    ObjCMethodDeclBits.objcDeclQualifier = QV;

  }

  /// Determine whether this method has a result type that is related

  /// to the message receiver's type.

  bool hasRelatedResultType() const {

    return ObjCMethodDeclBits.RelatedResultType;

  }

  /// Note whether this method has a related result type.

  void setRelatedResultType(bool RRT = true) {

    ObjCMethodDeclBits.RelatedResultType = RRT;

  }

  /// True if this is a method redeclaration in the same interface.

  bool isRedeclaration() const { return ObjCMethodDeclBits.IsRedeclaration; }

  void setIsRedeclaration(bool RD) { ObjCMethodDeclBits.IsRedeclaration = RD; }

  void setAsRedeclaration(const ObjCMethodDecl *PrevMethod);

  /// True if redeclared in the same interface.

  bool hasRedeclaration() const { return ObjCMethodDeclBits.HasRedeclaration; }

  void setHasRedeclaration(bool HRD) const {

    ObjCMethodDeclBits.HasRedeclaration = HRD;

  }

  /// Returns the location where the declarator ends. It will be

  /// the location of ';' for a method declaration and the location of '{'

  /// for a method definition.

  SourceLocation getDeclaratorEndLoc() const { return DeclEndLoc; }

  // Location information, modeled after the Stmt API.

  SourceLocation getBeginLoc() const LLVM_READONLY { return getLocation(); }

  SourceLocation getEndLoc() const LLVM_READONLY;

  SourceRange getSourceRange() const override LLVM_READONLY {

    return SourceRange(getLocation(), getEndLoc());

  }

  SourceLocation getSelectorStartLoc() const {

    if (isImplicit())

      return getBeginLoc();

    return getSelectorLoc(0);

  }

  SourceLocation getSelectorLoc(unsigned Index) const {

    assert(Index < getNumSelectorLocs() && "Index out of range!");

    if (hasStandardSelLocs())

      return getStandardSelectorLoc(Index, getSelector(),

                                   getSelLocsKind() == SelLoc_StandardWithSpace,

                                    parameters(),

                                   DeclEndLoc);

    return getStoredSelLocs()[Index];

  }

  void getSelectorLocs(SmallVectorImpl<SourceLocation> &SelLocs) const;

  unsigned getNumSelectorLocs() const {

    if (isImplicit())

      return 0;

    Selector Sel = getSelector();

    if (Sel.isUnarySelector())

      return 1;

    return Sel.getNumArgs();

  }

  ObjCInterfaceDecl *getClassInterface();

  const ObjCInterfaceDecl *getClassInterface() const {

    return const_cast<ObjCMethodDecl*>(this)->getClassInterface();

  }

  /// If this method is declared or implemented in a category, return

  /// that category.

  ObjCCategoryDecl *getCategory();

  const ObjCCategoryDecl *getCategory() const {

    return const_cast<ObjCMethodDecl*>(this)->getCategory();

  }

  Selector getSelector() const { return getDeclName().getObjCSelector(); }

  QualType getReturnType() const { return MethodDeclType; }

  void setReturnType(QualType T) { MethodDeclType = T; }

  SourceRange getReturnTypeSourceRange() const;

  /// Determine the type of an expression that sends a message to this

  /// function. This replaces the type parameters with the types they would

  /// get if the receiver was parameterless (e.g. it may replace the type

  /// parameter with 'id').

  QualType getSendResultType() const;

  /// Determine the type of an expression that sends a message to this

  /// function with the given receiver type.

  QualType getSendResultType(QualType receiverType) const;

  TypeSourceInfo *getReturnTypeSourceInfo() const { return ReturnTInfo; }

  void setReturnTypeSourceInfo(TypeSourceInfo *TInfo) { ReturnTInfo = TInfo; }

  // Iterator access to formal parameters.

  unsigned param_size() const { return NumParams; }

  using param_const_iterator = const ParmVarDecl *const *;

  using param_iterator = ParmVarDecl *const *;

  using param_range = llvm::iterator_range<param_iterator>;

  using param_const_range = llvm::iterator_range<param_const_iterator>;

  param_const_iterator param_begin() const {

    return param_const_iterator(getParams());

  }

  param_const_iterator param_end() const {

    return param_const_iterator(getParams() + NumParams);

  }

  param_iterator param_begin() { return param_iterator(getParams()); }

  param_iterator param_end() { return param_iterator(getParams() + NumParams); }

  // This method returns and of the parameters which are part of the selector

  // name mangling requirements.

  param_const_iterator sel_param_end() const {

    return param_begin() + getSelector().getNumArgs();

  }

  // ArrayRef access to formal parameters.  This should eventually

  // replace the iterator interface above.

  ArrayRef<ParmVarDecl*> parameters() const {

    return llvm::ArrayRef(const_cast<ParmVarDecl **>(getParams()), NumParams);

  }

  ParmVarDecl *getParamDecl(unsigned Idx) {

    assert(Idx < NumParams && "Index out of bounds!");

    return getParams()[Idx];

  }

  const ParmVarDecl *getParamDecl(unsigned Idx) const {

    return const_cast<ObjCMethodDecl *>(this)->getParamDecl(Idx);

  }

  /// Sets the method's parameters and selector source locations.

  /// If the method is implicit (not coming from source) \p SelLocs is

  /// ignored.

  void setMethodParams(ASTContext &C, ArrayRef<ParmVarDecl *> Params,

                       ArrayRef<SourceLocation> SelLocs = std::nullopt);

  // Iterator access to parameter types.

  struct GetTypeFn {

    QualType operator()(const ParmVarDecl *PD) const { return PD->getType(); }

  };

  using param_type_iterator =

      llvm::mapped_iterator<param_const_iterator, GetTypeFn>;

  param_type_iterator param_type_begin() const {

    return llvm::map_iterator(param_begin(), GetTypeFn());

  }

  param_type_iterator param_type_end() const {

    return llvm::map_iterator(param_end(), GetTypeFn());

  }

  /// createImplicitParams - Used to lazily create the self and cmd

  /// implicit parameters. This must be called prior to using getSelfDecl()

  /// or getCmdDecl(). The call is ignored if the implicit parameters

  /// have already been created.

  void createImplicitParams(ASTContext &Context, const ObjCInterfaceDecl *ID);

  /// \return the type for \c self and set \arg selfIsPseudoStrong and

  /// \arg selfIsConsumed accordingly.

  QualType getSelfType(ASTContext &Context, const ObjCInterfaceDecl *OID,

                       bool &selfIsPseudoStrong, bool &selfIsConsumed) const;

  ImplicitParamDecl * getSelfDecl() const { return SelfDecl; }

  void setSelfDecl(ImplicitParamDecl *SD) { SelfDecl = SD; }

  ImplicitParamDecl * getCmdDecl() const { return CmdDecl; }

  void setCmdDecl(ImplicitParamDecl *CD) { CmdDecl = CD; }

  /// Determines the family of this method.

  ObjCMethodFamily getMethodFamily() const;

  bool isInstanceMethod() const { return ObjCMethodDeclBits.IsInstance; }

  void setInstanceMethod(bool isInst) {

    ObjCMethodDeclBits.IsInstance = isInst;

  }

  bool isVariadic() const { return ObjCMethodDeclBits.IsVariadic; }

  void setVariadic(bool isVar) { ObjCMethodDeclBits.IsVariadic = isVar; }

  bool isClassMethod() const { return !isInstanceMethod(); }

  bool isPropertyAccessor() const {

    return ObjCMethodDeclBits.IsPropertyAccessor;

  }

  void setPropertyAccessor(bool isAccessor) {

    ObjCMethodDeclBits.IsPropertyAccessor = isAccessor;

  }

  bool isSynthesizedAccessorStub() const {

    return ObjCMethodDeclBits.IsSynthesizedAccessorStub;

  }

  void setSynthesizedAccessorStub(bool isSynthesizedAccessorStub) {

    ObjCMethodDeclBits.IsSynthesizedAccessorStub = isSynthesizedAccessorStub;

  }

  bool isDefined() const { return ObjCMethodDeclBits.IsDefined; }

  void setDefined(bool isDefined) { ObjCMethodDeclBits.IsDefined = isDefined; }

  /// Whether this method overrides any other in the class hierarchy.

  ///

  /// A method is said to override any method in the class's

  /// base classes, its protocols, or its categories' protocols, that has

  /// the same selector and is of the same kind (class or instance).

  /// A method in an implementation is not considered as overriding the same

  /// method in the interface or its categories.

  bool isOverriding() const { return ObjCMethodDeclBits.IsOverriding; }

  void setOverriding(bool IsOver) { ObjCMethodDeclBits.IsOverriding = IsOver; }

  /// Return overridden methods for the given \p Method.

  ///

  /// An ObjC method is considered to override any method in the class's

  /// base classes (and base's categories), its protocols, or its categories'

  /// protocols, that has

  /// the same selector and is of the same kind (class or instance).

  /// A method in an implementation is not considered as overriding the same

  /// method in the interface or its categories.

  void getOverriddenMethods(

                     SmallVectorImpl<const ObjCMethodDecl *> &Overridden) const;

  /// True if the method was a definition but its body was skipped.

  bool hasSkippedBody() const { return ObjCMethodDeclBits.HasSkippedBody; }

  void setHasSkippedBody(bool Skipped = true) {

    ObjCMethodDeclBits.HasSkippedBody = Skipped;

  }

  /// True if the method is tagged as objc_direct

  bool isDirectMethod() const;

  /// True if the method has a parameter that's destroyed in the callee.

  bool hasParamDestroyedInCallee() const;

  /// Returns the property associated with this method's selector.

  ///

  /// Note that even if this particular method is not marked as a property

  /// accessor, it is still possible for it to match a property declared in a

  /// superclass. Pass \c false if you only want to check the current class.

  const ObjCPropertyDecl *findPropertyDecl(bool CheckOverrides = true) const;

  // Related to protocols declared in  \@protocol

  void setDeclImplementation(ImplementationControl ic) {

    ObjCMethodDeclBits.DeclImplementation = ic;

  }

  ImplementationControl getImplementationControl() const {

    return ImplementationControl(ObjCMethodDeclBits.DeclImplementation);

  }

  bool isOptional() const {

    return getImplementationControl() == Optional;

  }

  /// Returns true if this specific method declaration is marked with the

  /// designated initializer attribute.

  bool isThisDeclarationADesignatedInitializer() const;

  /// Returns true if the method selector resolves to a designated initializer

  /// in the class's interface.

  ///

  /// \param InitMethod if non-null and the function returns true, it receives

  /// the method declaration that was marked with the designated initializer

  /// attribute.

  bool isDesignatedInitializerForTheInterface(

      const ObjCMethodDecl **InitMethod = nullptr) const;

  /// Determine whether this method has a body.

  bool hasBody() const override { return Body.isValid(); }

  /// Retrieve the body of this method, if it has one.

  Stmt *getBody() const override;

  void setLazyBody(uint64_t Offset) { Body = Offset; }

  CompoundStmt *getCompoundBody() { return (CompoundStmt*)getBody(); }

  void setBody(Stmt *B) { Body = B; }

  /// Returns whether this specific method is a definition.

  bool isThisDeclarationADefinition() const { return hasBody(); }

  /// Is this method defined in the NSObject base class?

  bool definedInNSObject(const ASTContext &) const;

  // Implement isa/cast/dyncast/etc.

  static bool classof(const Decl *D) { return classofKind(D->getKind()); }

  static bool classofKind(Kind K) { return K == ObjCMethod; }

  static DeclContext *castToDeclContext(const ObjCMethodDecl *D) {

    return static_cast<DeclContext *>(const_cast<ObjCMethodDecl*>(D));

  }

  static ObjCMethodDecl *castFromDeclContext(const DeclContext *DC) {

    return static_cast<ObjCMethodDecl *>(const_cast<DeclContext*>(DC));

  }

};

/// Describes the variance of a given generic parameter.

enum class ObjCTypeParamVariance : uint8_t {

  /// The parameter is invariant: must match exactly.

  Invariant,

  /// The parameter is covariant, e.g., X<T> is a subtype of X<U> when

  /// the type parameter is covariant and T is a subtype of U.

  Covariant,

  /// The parameter is contravariant, e.g., X<T> is a subtype of X<U>

  /// when the type parameter is covariant and U is a subtype of T.

  Contravariant,

};

/// Represents the declaration of an Objective-C type parameter.

///

/// \code

/// @interface NSDictionary<Key : id<NSCopying>, Value>

/// @end

/// \endcode

///

/// In the example above, both \c Key and \c Value are represented by

/// \c ObjCTypeParamDecl. \c Key has an explicit bound of \c id<NSCopying>,

/// while \c Value gets an implicit bound of \c id.

///

/// Objective-C type parameters are typedef-names in the grammar,

class ObjCTypeParamDecl : public TypedefNameDecl {

  /// Index of this type parameter in the type parameter list.

  unsigned Index : 14;

  /// The variance of the type parameter.

  unsigned Variance : 2;

  /// The location of the variance, if any.

  SourceLocation VarianceLoc;

  /// The location of the ':', which will be valid when the bound was

  /// explicitly specified.

  SourceLocation ColonLoc;

  ObjCTypeParamDecl(ASTContext &ctx, DeclContext *dc,

                    ObjCTypeParamVariance variance, SourceLocation varianceLoc,

                    unsigned index,

                    SourceLocation nameLoc, IdentifierInfo *name,

                    SourceLocation colonLoc, TypeSourceInfo *boundInfo)

      : TypedefNameDecl(ObjCTypeParam, ctx, dc, nameLoc, nameLoc, name,

                        boundInfo),

        Index(index), Variance(static_cast<unsigned>(variance)),

        VarianceLoc(varianceLoc), ColonLoc(colonLoc) {}

  void anchor() override;

public:

  friend class ASTDeclReader;

  friend class ASTDeclWriter;

  static ObjCTypeParamDecl *Create(ASTContext &ctx, DeclContext *dc,

                                   ObjCTypeParamVariance variance,

                                   SourceLocation varianceLoc,

                                   unsigned index,

                                   SourceLocation nameLoc,

                                   IdentifierInfo *name,

                                   SourceLocation colonLoc,

                                   TypeSourceInfo *boundInfo);

  static ObjCTypeParamDecl *CreateDeserialized(ASTContext &ctx, unsigned ID);

  SourceRange getSourceRange() const override LLVM_READONLY;

  /// Determine the variance of this type parameter.

  ObjCTypeParamVariance getVariance() const {

    return static_cast<ObjCTypeParamVariance>(Variance);

  }

  /// Set the variance of this type parameter.

  void setVariance(ObjCTypeParamVariance variance) {

    Variance = static_cast<unsigned>(variance);

  }

  /// Retrieve the location of the variance keyword.

  SourceLocation getVarianceLoc() const { return VarianceLoc; }

  /// Retrieve the index into its type parameter list.

  unsigned getIndex() const { return Index; }

  /// Whether this type parameter has an explicitly-written type bound, e.g.,

  /// "T : NSView".

  bool hasExplicitBound() const { return ColonLoc.isValid(); }

  /// Retrieve the location of the ':' separating the type parameter name

  /// from the explicitly-specified bound.

  SourceLocation getColonLoc() const { return ColonLoc; }

  // Implement isa/cast/dyncast/etc.

  static bool classof(const Decl *D) { return classofKind(D->getKind()); }

  static bool classofKind(Kind K) { return K == ObjCTypeParam; }

};

/// Stores a list of Objective-C type parameters for a parameterized class

/// or a category/extension thereof.

///

/// \code

/// @interface NSArray<T> // stores the <T>

/// @end

/// \endcode

class ObjCTypeParamList final

    : private llvm::TrailingObjects<ObjCTypeParamList, ObjCTypeParamDecl *> {

  /// Location of the left and right angle brackets.

  SourceRange Brackets;

  /// The number of parameters in the list, which are tail-allocated.

  unsigned NumParams;

  ObjCTypeParamList(SourceLocation lAngleLoc,

                    ArrayRef<ObjCTypeParamDecl *> typeParams,

                    SourceLocation rAngleLoc);

public:

  friend TrailingObjects;

  /// Create a new Objective-C type parameter list.

  static ObjCTypeParamList *create(ASTContext &ctx,

                                   SourceLocation lAngleLoc,

                                   ArrayRef<ObjCTypeParamDecl *> typeParams,

                                   SourceLocation rAngleLoc);

  /// Iterate through the type parameters in the list.

  using iterator = ObjCTypeParamDecl **;

  iterator begin() { return getTrailingObjects<ObjCTypeParamDecl *>(); }

  iterator end() { return begin() + size(); }

  /// Determine the number of type parameters in this list.

  unsigned size() const { return NumParams; }

  // Iterate through the type parameters in the list.

  using const_iterator = ObjCTypeParamDecl * const *;

  const_iterator begin() const {

    return getTrailingObjects<ObjCTypeParamDecl *>();

  }

  const_iterator end() const {

    return begin() + size();

  }

  ObjCTypeParamDecl *front() const {

    assert(size() > 0 && "empty Objective-C type parameter list");

    return *begin();

  }

  ObjCTypeParamDecl *back() const {

    assert(size() > 0 && "empty Objective-C type parameter list");

    return *(end() - 1);

  }

  SourceLocation getLAngleLoc() const { return Brackets.getBegin(); }

  SourceLocation getRAngleLoc() const { return Brackets.getEnd(); }

  SourceRange getSourceRange() const { return Brackets; }

  /// Gather the default set of type arguments to be substituted for

  /// these type parameters when dealing with an unspecialized type.

  void gatherDefaultTypeArgs(SmallVectorImpl<QualType> &typeArgs) const;

};

enum class ObjCPropertyQueryKind : uint8_t {

  OBJC_PR_query_unknown = 0x00,

  OBJC_PR_query_instance,

  OBJC_PR_query_class

};

/// Represents one property declaration in an Objective-C interface.

///

/// For example:

/// \code{.mm}

/// \@property (assign, readwrite) int MyProperty;

/// \endcode

class ObjCPropertyDecl : public NamedDecl {

  void anchor() override;

public:

  enum SetterKind { Assign, Retain, Copy, Weak };

  enum PropertyControl { None, Required, Optional };

private:

  // location of \@property

  SourceLocation AtLoc;

  // location of '(' starting attribute list or null.

  SourceLocation LParenLoc;

  QualType DeclType;

  TypeSourceInfo *DeclTypeSourceInfo;

  unsigned PropertyAttributes : NumObjCPropertyAttrsBits;

  unsigned PropertyAttributesAsWritten : NumObjCPropertyAttrsBits;

  // \@required/\@optional

  unsigned PropertyImplementation : 2;

  // getter name of NULL if no getter

  Selector GetterName;

  // setter name of NULL if no setter

  Selector SetterName;

  // location of the getter attribute's value

  SourceLocation GetterNameLoc;

  // location of the setter attribute's value

  SourceLocation SetterNameLoc;

  // Declaration of getter instance method

  ObjCMethodDecl *GetterMethodDecl = nullptr;

  // Declaration of setter instance method

  ObjCMethodDecl *SetterMethodDecl = nullptr;

  // Synthesize ivar for this property

  ObjCIvarDecl *PropertyIvarDecl = nullptr;

  ObjCPropertyDecl(DeclContext *DC, SourceLocation L, IdentifierInfo *Id,

                   SourceLocation AtLocation, SourceLocation LParenLocation,

                   QualType T, TypeSourceInfo *TSI, PropertyControl propControl)

      : NamedDecl(ObjCProperty, DC, L, Id), AtLoc(AtLocation),

        LParenLoc(LParenLocation), DeclType(T), DeclTypeSourceInfo(TSI),

        PropertyAttributes(ObjCPropertyAttribute::kind_noattr),

        PropertyAttributesAsWritten(ObjCPropertyAttribute::kind_noattr),

        PropertyImplementation(propControl) {}

public:

  static ObjCPropertyDecl *

  Create(ASTContext &C, DeclContext *DC, SourceLocation L, IdentifierInfo *Id,

         SourceLocation AtLocation, SourceLocation LParenLocation, QualType T,

         TypeSourceInfo *TSI, PropertyControl propControl = None);

  static ObjCPropertyDecl *CreateDeserialized(ASTContext &C, unsigned ID);

  SourceLocation getAtLoc() const { return AtLoc; }

  void setAtLoc(SourceLocation L) { AtLoc = L; }

  SourceLocation getLParenLoc() const { return LParenLoc; }

  void setLParenLoc(SourceLocation L) { LParenLoc = L; }

  TypeSourceInfo *getTypeSourceInfo() const { return DeclTypeSourceInfo; }

  QualType getType() const { return DeclType; }

  void setType(QualType T, TypeSourceInfo *TSI) {

    DeclType = T;

    DeclTypeSourceInfo = TSI;

  }

  /// Retrieve the type when this property is used with a specific base object

  /// type.

  QualType getUsageType(QualType objectType) const;

  ObjCPropertyAttribute::Kind getPropertyAttributes() const {

    return ObjCPropertyAttribute::Kind(PropertyAttributes);

  }

  void setPropertyAttributes(ObjCPropertyAttribute::Kind PRVal) {

    PropertyAttributes |= PRVal;

  }