llvm/clang/lib/AST/DeclObjC.cpp

//===- DeclObjC.cpp - ObjC Declaration AST Node Implementation ------------===//
//
// 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 implements the Objective-C related Decl classes.
//
//===----------------------------------------------------------------------===//

#include "clang/AST/DeclObjC.h"
#include "clang/AST/ASTContext.h"
#include "clang/AST/ASTMutationListener.h"
#include "clang/AST/Attr.h"
#include "clang/AST/Decl.h"
#include "clang/AST/DeclBase.h"
#include "clang/AST/ODRHash.h"
#include "clang/AST/Stmt.h"
#include "clang/AST/Type.h"
#include "clang/AST/TypeLoc.h"
#include "clang/Basic/IdentifierTable.h"
#include "clang/Basic/LLVM.h"
#include "clang/Basic/LangOptions.h"
#include "clang/Basic/SourceLocation.h"
#include "llvm/ADT/SmallString.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/Support/Casting.h"
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/raw_ostream.h"
#include <algorithm>
#include <cassert>
#include <cstdint>
#include <cstring>
#include <queue>
#include <utility>

usingnamespaceclang;

//===----------------------------------------------------------------------===//
// ObjCListBase
//===----------------------------------------------------------------------===//

void ObjCListBase::set(void *const* InList, unsigned Elts, ASTContext &Ctx) { … }

void ObjCProtocolList::set(ObjCProtocolDecl* const* InList, unsigned Elts,
                           const SourceLocation *Locs, ASTContext &Ctx) { … }

//===----------------------------------------------------------------------===//
// ObjCInterfaceDecl
//===----------------------------------------------------------------------===//

ObjCContainerDecl::ObjCContainerDecl(Kind DK, DeclContext *DC,
                                     const IdentifierInfo *Id,
                                     SourceLocation nameLoc,
                                     SourceLocation atStartLoc)
    : … { … }

void ObjCContainerDecl::anchor() { … }

/// getIvarDecl - This method looks up an ivar in this ContextDecl.
///
ObjCIvarDecl *
ObjCContainerDecl::getIvarDecl(IdentifierInfo *Id) const { … }

// Get the local instance/class method declared in this interface.
ObjCMethodDecl *
ObjCContainerDecl::getMethod(Selector Sel, bool isInstance,
                             bool AllowHidden) const { … }

/// This routine returns 'true' if a user declared setter method was
/// found in the class, its protocols, its super classes or categories.
/// It also returns 'true' if one of its categories has declared a 'readwrite'
/// property.  This is because, user must provide a setter method for the
/// category's 'readwrite' property.
bool ObjCContainerDecl::HasUserDeclaredSetterMethod(
    const ObjCPropertyDecl *Property) const { … }

ObjCPropertyDecl *
ObjCPropertyDecl::findPropertyDecl(const DeclContext *DC,
                                   const IdentifierInfo *propertyID,
                                   ObjCPropertyQueryKind queryKind) { … }

IdentifierInfo *
ObjCPropertyDecl::getDefaultSynthIvarName(ASTContext &Ctx) const { … }

ObjCPropertyDecl *ObjCContainerDecl::getProperty(const IdentifierInfo *Id,
                                                 bool IsInstance) const { … }

/// FindPropertyDeclaration - Finds declaration of the property given its name
/// in 'PropertyId' and returns it. It returns 0, if not found.
ObjCPropertyDecl *ObjCContainerDecl::FindPropertyDeclaration(
    const IdentifierInfo *PropertyId,
    ObjCPropertyQueryKind QueryKind) const { … }

void ObjCInterfaceDecl::anchor() { … }

ObjCTypeParamList *ObjCInterfaceDecl::getTypeParamList() const { … }

void ObjCInterfaceDecl::setTypeParamList(ObjCTypeParamList *TPL) { … }

ObjCInterfaceDecl *ObjCInterfaceDecl::getSuperClass() const { … }

SourceLocation ObjCInterfaceDecl::getSuperClassLoc() const { … }

/// FindPropertyVisibleInPrimaryClass - Finds declaration of the property
/// with name 'PropertyId' in the primary class; including those in protocols
/// (direct or indirect) used by the primary class.
ObjCPropertyDecl *ObjCInterfaceDecl::FindPropertyVisibleInPrimaryClass(
    const IdentifierInfo *PropertyId, ObjCPropertyQueryKind QueryKind) const { … }

void ObjCInterfaceDecl::collectPropertiesToImplement(PropertyMap &PM) const { … }

bool ObjCInterfaceDecl::isArcWeakrefUnavailable() const { … }

const ObjCInterfaceDecl *ObjCInterfaceDecl::isObjCRequiresPropertyDefs() const { … }

void ObjCInterfaceDecl::mergeClassExtensionProtocolList(
                              ObjCProtocolDecl *const* ExtList, unsigned ExtNum,
                              ASTContext &C) { … }

const ObjCInterfaceDecl *
ObjCInterfaceDecl::findInterfaceWithDesignatedInitializers() const { … }

static bool isIntroducingInitializers(const ObjCInterfaceDecl *D) { … }

bool ObjCInterfaceDecl::inheritsDesignatedInitializers() const { … }

void ObjCInterfaceDecl::getDesignatedInitializers(
    llvm::SmallVectorImpl<const ObjCMethodDecl *> &Methods) const { … }

bool ObjCInterfaceDecl::isDesignatedInitializer(Selector Sel,
                                      const ObjCMethodDecl **InitMethod) const { … }

void ObjCInterfaceDecl::allocateDefinitionData() { … }

void ObjCInterfaceDecl::startDefinition() { … }

void ObjCInterfaceDecl::startDuplicateDefinitionForComparison() { … }

void ObjCInterfaceDecl::mergeDuplicateDefinitionWithCommon(
    const ObjCInterfaceDecl *Definition) { … }

ObjCIvarDecl *ObjCInterfaceDecl::lookupInstanceVariable(IdentifierInfo *ID,
                                              ObjCInterfaceDecl *&clsDeclared) { … }

/// lookupInheritedClass - This method returns ObjCInterfaceDecl * of the super
/// class whose name is passed as argument. If it is not one of the super classes
/// the it returns NULL.
ObjCInterfaceDecl *ObjCInterfaceDecl::lookupInheritedClass(
                                        const IdentifierInfo*ICName) { … }

ObjCProtocolDecl *
ObjCInterfaceDecl::lookupNestedProtocol(IdentifierInfo *Name) { … }

/// lookupMethod - This method returns an instance/class method by looking in
/// the class, its categories, and its super classes (using a linear search).
/// When argument category "C" is specified, any implicit method found
/// in this category is ignored.
ObjCMethodDecl *ObjCInterfaceDecl::lookupMethod(Selector Sel,
                                                bool isInstance,
                                                bool shallowCategoryLookup,
                                                bool followSuper,
                                                const ObjCCategoryDecl *C) const
{ … }

// Will search "local" class/category implementations for a method decl.
// If failed, then we search in class's root for an instance method.
// Returns 0 if no method is found.
ObjCMethodDecl *ObjCInterfaceDecl::lookupPrivateMethod(
                                   const Selector &Sel,
                                   bool Instance) const { … }

unsigned ObjCInterfaceDecl::getODRHash() { … }

bool ObjCInterfaceDecl::hasODRHash() const { … }

void ObjCInterfaceDecl::setHasODRHash(bool HasHash) { … }

//===----------------------------------------------------------------------===//
// ObjCMethodDecl
//===----------------------------------------------------------------------===//

ObjCMethodDecl::ObjCMethodDecl(
    SourceLocation beginLoc, SourceLocation endLoc, Selector SelInfo,
    QualType T, TypeSourceInfo *ReturnTInfo, DeclContext *contextDecl,
    bool isInstance, bool isVariadic, bool isPropertyAccessor,
    bool isSynthesizedAccessorStub, bool isImplicitlyDeclared, bool isDefined,
    ObjCImplementationControl impControl, bool HasRelatedResultType)
    : … { … }

ObjCMethodDecl *ObjCMethodDecl::Create(
    ASTContext &C, SourceLocation beginLoc, SourceLocation endLoc,
    Selector SelInfo, QualType T, TypeSourceInfo *ReturnTInfo,
    DeclContext *contextDecl, bool isInstance, bool isVariadic,
    bool isPropertyAccessor, bool isSynthesizedAccessorStub,
    bool isImplicitlyDeclared, bool isDefined,
    ObjCImplementationControl impControl, bool HasRelatedResultType) { … }

ObjCMethodDecl *ObjCMethodDecl::CreateDeserialized(ASTContext &C,
                                                   GlobalDeclID ID) { … }

bool ObjCMethodDecl::isDirectMethod() const { … }

bool ObjCMethodDecl::isThisDeclarationADesignatedInitializer() const { … }

bool ObjCMethodDecl::definedInNSObject(const ASTContext &Ctx) const { … }

bool ObjCMethodDecl::isDesignatedInitializerForTheInterface(
    const ObjCMethodDecl **InitMethod) const { … }

bool ObjCMethodDecl::hasParamDestroyedInCallee() const { … }

Stmt *ObjCMethodDecl::getBody() const { … }

void ObjCMethodDecl::setAsRedeclaration(const ObjCMethodDecl *PrevMethod) { … }

void ObjCMethodDecl::setParamsAndSelLocs(ASTContext &C,
                                         ArrayRef<ParmVarDecl*> Params,
                                         ArrayRef<SourceLocation> SelLocs) { … }

void ObjCMethodDecl::getSelectorLocs(
                               SmallVectorImpl<SourceLocation> &SelLocs) const { … }

void ObjCMethodDecl::setMethodParams(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 *ObjCMethodDecl::getNextRedeclarationImpl() { … }

ObjCMethodDecl *ObjCMethodDecl::getCanonicalDecl() { … }

SourceLocation ObjCMethodDecl::getEndLoc() const { … }

ObjCMethodFamily ObjCMethodDecl::getMethodFamily() const { … }

QualType ObjCMethodDecl::getSelfType(ASTContext &Context,
                                     const ObjCInterfaceDecl *OID,
                                     bool &selfIsPseudoStrong,
                                     bool &selfIsConsumed) const { … }

void ObjCMethodDecl::createImplicitParams(ASTContext &Context,
                                          const ObjCInterfaceDecl *OID) { … }

ObjCInterfaceDecl *ObjCMethodDecl::getClassInterface() { … }

ObjCCategoryDecl *ObjCMethodDecl::getCategory() { … }

SourceRange ObjCMethodDecl::getReturnTypeSourceRange() const { … }

QualType ObjCMethodDecl::getSendResultType() const { … }

QualType ObjCMethodDecl::getSendResultType(QualType receiverType) const { … }

static void CollectOverriddenMethodsRecurse(const ObjCContainerDecl *Container,
                                            const ObjCMethodDecl *Method,
                               SmallVectorImpl<const ObjCMethodDecl *> &Methods,
                                            bool MovedToSuper) { … }

static inline void CollectOverriddenMethods(const ObjCContainerDecl *Container,
                                            const ObjCMethodDecl *Method,
                             SmallVectorImpl<const ObjCMethodDecl *> &Methods) { … }

static void collectOverriddenMethodsSlow(const ObjCMethodDecl *Method,
                          SmallVectorImpl<const ObjCMethodDecl *> &overridden) { … }

void ObjCMethodDecl::getOverriddenMethods(
                    SmallVectorImpl<const ObjCMethodDecl *> &Overridden) const { … }

const ObjCPropertyDecl *
ObjCMethodDecl::findPropertyDecl(bool CheckOverrides) const { … }

//===----------------------------------------------------------------------===//
// ObjCTypeParamDecl
//===----------------------------------------------------------------------===//

void ObjCTypeParamDecl::anchor() { … }

ObjCTypeParamDecl *ObjCTypeParamDecl::Create(ASTContext &ctx, DeclContext *dc,
                                             ObjCTypeParamVariance variance,
                                             SourceLocation varianceLoc,
                                             unsigned index,
                                             SourceLocation nameLoc,
                                             IdentifierInfo *name,
                                             SourceLocation colonLoc,
                                             TypeSourceInfo *boundInfo) { … }

ObjCTypeParamDecl *ObjCTypeParamDecl::CreateDeserialized(ASTContext &ctx,
                                                         GlobalDeclID ID) { … }

SourceRange ObjCTypeParamDecl::getSourceRange() const { … }

//===----------------------------------------------------------------------===//
// ObjCTypeParamList
//===----------------------------------------------------------------------===//
ObjCTypeParamList::ObjCTypeParamList(SourceLocation lAngleLoc,
                                     ArrayRef<ObjCTypeParamDecl *> typeParams,
                                     SourceLocation rAngleLoc)
    : … { … }

ObjCTypeParamList *ObjCTypeParamList::create(
                     ASTContext &ctx,
                     SourceLocation lAngleLoc,
                     ArrayRef<ObjCTypeParamDecl *> typeParams,
                     SourceLocation rAngleLoc) { … }

void ObjCTypeParamList::gatherDefaultTypeArgs(
       SmallVectorImpl<QualType> &typeArgs) const { … }

//===----------------------------------------------------------------------===//
// ObjCInterfaceDecl
//===----------------------------------------------------------------------===//

ObjCInterfaceDecl *ObjCInterfaceDecl::Create(
    const ASTContext &C, DeclContext *DC, SourceLocation atLoc,
    const IdentifierInfo *Id, ObjCTypeParamList *typeParamList,
    ObjCInterfaceDecl *PrevDecl, SourceLocation ClassLoc, bool isInternal) { … }

ObjCInterfaceDecl *ObjCInterfaceDecl::CreateDeserialized(const ASTContext &C,
                                                         GlobalDeclID ID) { … }

ObjCInterfaceDecl::ObjCInterfaceDecl(
    const ASTContext &C, DeclContext *DC, SourceLocation AtLoc,
    const IdentifierInfo *Id, ObjCTypeParamList *typeParamList,
    SourceLocation CLoc, ObjCInterfaceDecl *PrevDecl, bool IsInternal)
    : … { … }

void ObjCInterfaceDecl::LoadExternalDefinition() const { … }

void ObjCInterfaceDecl::setExternallyCompleted() { … }

void ObjCInterfaceDecl::setHasDesignatedInitializers() { … }

bool ObjCInterfaceDecl::hasDesignatedInitializers() const { … }

StringRef
ObjCInterfaceDecl::getObjCRuntimeNameAsString() const { … }

StringRef
ObjCImplementationDecl::getObjCRuntimeNameAsString() const { … }

ObjCImplementationDecl *ObjCInterfaceDecl::getImplementation() const { … }

void ObjCInterfaceDecl::setImplementation(ObjCImplementationDecl *ImplD) { … }

namespace {

struct SynthesizeIvarChunk { … };

bool operator<(const SynthesizeIvarChunk & LHS,
               const SynthesizeIvarChunk &RHS) { … }

} // namespace

/// all_declared_ivar_begin - return first ivar declared in this class,
/// its extensions and its implementation. Lazily build the list on first
/// access.
///
/// Caveat: The list returned by this method reflects the current
/// state of the parser. The cache will be updated for every ivar
/// added by an extension or the implementation when they are
/// encountered.
/// See also ObjCIvarDecl::Create().
ObjCIvarDecl *ObjCInterfaceDecl::all_declared_ivar_begin() { … }

/// FindCategoryDeclaration - Finds category declaration in the list of
/// categories for this class and returns it. Name of the category is passed
/// in 'CategoryId'. If category not found, return 0;
///
ObjCCategoryDecl *ObjCInterfaceDecl::FindCategoryDeclaration(
    const IdentifierInfo *CategoryId) const { … }

ObjCMethodDecl *
ObjCInterfaceDecl::getCategoryInstanceMethod(Selector Sel) const { … }

ObjCMethodDecl *ObjCInterfaceDecl::getCategoryClassMethod(Selector Sel) const { … }

/// ClassImplementsProtocol - Checks that 'lProto' protocol
/// has been implemented in IDecl class, its super class or categories (if
/// lookupCategory is true).
bool ObjCInterfaceDecl::ClassImplementsProtocol(ObjCProtocolDecl *lProto,
                                    bool lookupCategory,
                                    bool RHSIsQualifiedID) { … }

//===----------------------------------------------------------------------===//
// ObjCIvarDecl
//===----------------------------------------------------------------------===//

void ObjCIvarDecl::anchor() { … }

ObjCIvarDecl *ObjCIvarDecl::Create(ASTContext &C, ObjCContainerDecl *DC,
                                   SourceLocation StartLoc,
                                   SourceLocation IdLoc,
                                   const IdentifierInfo *Id, QualType T,
                                   TypeSourceInfo *TInfo, AccessControl ac,
                                   Expr *BW, bool synthesized) { … }

ObjCIvarDecl *ObjCIvarDecl::CreateDeserialized(ASTContext &C, GlobalDeclID ID) { … }

ObjCInterfaceDecl *ObjCIvarDecl::getContainingInterface() { … }

QualType ObjCIvarDecl::getUsageType(QualType objectType) const { … }

//===----------------------------------------------------------------------===//
// ObjCAtDefsFieldDecl
//===----------------------------------------------------------------------===//

void ObjCAtDefsFieldDecl::anchor() { … }

ObjCAtDefsFieldDecl
*ObjCAtDefsFieldDecl::Create(ASTContext &C, DeclContext *DC,
                             SourceLocation StartLoc,  SourceLocation IdLoc,
                             IdentifierInfo *Id, QualType T, Expr *BW) { … }

ObjCAtDefsFieldDecl *ObjCAtDefsFieldDecl::CreateDeserialized(ASTContext &C,
                                                             GlobalDeclID ID) { … }

//===----------------------------------------------------------------------===//
// ObjCProtocolDecl
//===----------------------------------------------------------------------===//

void ObjCProtocolDecl::anchor() { … }

ObjCProtocolDecl::ObjCProtocolDecl(ASTContext &C, DeclContext *DC,
                                   IdentifierInfo *Id, SourceLocation nameLoc,
                                   SourceLocation atStartLoc,
                                   ObjCProtocolDecl *PrevDecl)
    : … { … }

ObjCProtocolDecl *ObjCProtocolDecl::Create(ASTContext &C, DeclContext *DC,
                                           IdentifierInfo *Id,
                                           SourceLocation nameLoc,
                                           SourceLocation atStartLoc,
                                           ObjCProtocolDecl *PrevDecl) { … }

ObjCProtocolDecl *ObjCProtocolDecl::CreateDeserialized(ASTContext &C,
                                                       GlobalDeclID ID) { … }

bool ObjCProtocolDecl::isNonRuntimeProtocol() const { … }

void ObjCProtocolDecl::getImpliedProtocols(
    llvm::DenseSet<const ObjCProtocolDecl *> &IPs) const { … }

ObjCProtocolDecl *ObjCProtocolDecl::lookupProtocolNamed(IdentifierInfo *Name) { … }

// lookupMethod - Lookup a instance/class method in the protocol and protocols
// it inherited.
ObjCMethodDecl *ObjCProtocolDecl::lookupMethod(Selector Sel,
                                               bool isInstance) const { … }

void ObjCProtocolDecl::allocateDefinitionData() { … }

void ObjCProtocolDecl::startDefinition() { … }

void ObjCProtocolDecl::startDuplicateDefinitionForComparison() { … }

void ObjCProtocolDecl::mergeDuplicateDefinitionWithCommon(
    const ObjCProtocolDecl *Definition) { … }

void ObjCProtocolDecl::collectPropertiesToImplement(PropertyMap &PM) const { … }

void ObjCProtocolDecl::collectInheritedProtocolProperties(
    const ObjCPropertyDecl *Property, ProtocolPropertySet &PS,
    PropertyDeclOrder &PO) const { … }

StringRef
ObjCProtocolDecl::getObjCRuntimeNameAsString() const { … }

unsigned ObjCProtocolDecl::getODRHash() { … }

bool ObjCProtocolDecl::hasODRHash() const { … }

void ObjCProtocolDecl::setHasODRHash(bool HasHash) { … }

//===----------------------------------------------------------------------===//
// ObjCCategoryDecl
//===----------------------------------------------------------------------===//

void ObjCCategoryDecl::anchor() { … }

ObjCCategoryDecl::ObjCCategoryDecl(
    DeclContext *DC, SourceLocation AtLoc, SourceLocation ClassNameLoc,
    SourceLocation CategoryNameLoc, const IdentifierInfo *Id,
    ObjCInterfaceDecl *IDecl, ObjCTypeParamList *typeParamList,
    SourceLocation IvarLBraceLoc, SourceLocation IvarRBraceLoc)
    : … { … }

ObjCCategoryDecl *ObjCCategoryDecl::Create(
    ASTContext &C, DeclContext *DC, SourceLocation AtLoc,
    SourceLocation ClassNameLoc, SourceLocation CategoryNameLoc,
    const IdentifierInfo *Id, ObjCInterfaceDecl *IDecl,
    ObjCTypeParamList *typeParamList, SourceLocation IvarLBraceLoc,
    SourceLocation IvarRBraceLoc) { … }

ObjCCategoryDecl *ObjCCategoryDecl::CreateDeserialized(ASTContext &C,
                                                       GlobalDeclID ID) { … }

ObjCCategoryImplDecl *ObjCCategoryDecl::getImplementation() const { … }

void ObjCCategoryDecl::setImplementation(ObjCCategoryImplDecl *ImplD) { … }

void ObjCCategoryDecl::setTypeParamList(ObjCTypeParamList *TPL) { … }

//===----------------------------------------------------------------------===//
// ObjCCategoryImplDecl
//===----------------------------------------------------------------------===//

void ObjCCategoryImplDecl::anchor() { … }

ObjCCategoryImplDecl *ObjCCategoryImplDecl::Create(
    ASTContext &C, DeclContext *DC, const IdentifierInfo *Id,
    ObjCInterfaceDecl *ClassInterface, SourceLocation nameLoc,
    SourceLocation atStartLoc, SourceLocation CategoryNameLoc) { … }

ObjCCategoryImplDecl *
ObjCCategoryImplDecl::CreateDeserialized(ASTContext &C, GlobalDeclID ID) { … }

ObjCCategoryDecl *ObjCCategoryImplDecl::getCategoryDecl() const { … }

void ObjCImplDecl::anchor() { … }

void ObjCImplDecl::addPropertyImplementation(ObjCPropertyImplDecl *property) { … }

void ObjCImplDecl::setClassInterface(ObjCInterfaceDecl *IFace) { … }

/// FindPropertyImplIvarDecl - This method lookup the ivar in the list of
/// properties implemented in this \@implementation block and returns
/// the implemented property that uses it.
ObjCPropertyImplDecl *ObjCImplDecl::
FindPropertyImplIvarDecl(IdentifierInfo *ivarId) const { … }

/// FindPropertyImplDecl - This method looks up a previous ObjCPropertyImplDecl
/// added to the list of those properties \@synthesized/\@dynamic in this
/// category \@implementation block.
ObjCPropertyImplDecl *ObjCImplDecl::
FindPropertyImplDecl(IdentifierInfo *Id,
                     ObjCPropertyQueryKind QueryKind) const { … }

raw_ostream &clang::operator<<(raw_ostream &OS,
                               const ObjCCategoryImplDecl &CID) { … }

//===----------------------------------------------------------------------===//
// ObjCImplementationDecl
//===----------------------------------------------------------------------===//

void ObjCImplementationDecl::anchor() { … }

ObjCImplementationDecl *
ObjCImplementationDecl::Create(ASTContext &C, DeclContext *DC,
                               ObjCInterfaceDecl *ClassInterface,
                               ObjCInterfaceDecl *SuperDecl,
                               SourceLocation nameLoc,
                               SourceLocation atStartLoc,
                               SourceLocation superLoc,
                               SourceLocation IvarLBraceLoc,
                               SourceLocation IvarRBraceLoc) { … }

ObjCImplementationDecl *
ObjCImplementationDecl::CreateDeserialized(ASTContext &C, GlobalDeclID ID) { … }

void ObjCImplementationDecl::setIvarInitializers(ASTContext &C,
                                             CXXCtorInitializer ** initializers,
                                                 unsigned numInitializers) { … }

ObjCImplementationDecl::init_const_iterator
ObjCImplementationDecl::init_begin() const { … }

raw_ostream &clang::operator<<(raw_ostream &OS,
                               const ObjCImplementationDecl &ID) { … }

//===----------------------------------------------------------------------===//
// ObjCCompatibleAliasDecl
//===----------------------------------------------------------------------===//

void ObjCCompatibleAliasDecl::anchor() { … }

ObjCCompatibleAliasDecl *
ObjCCompatibleAliasDecl::Create(ASTContext &C, DeclContext *DC,
                                SourceLocation L,
                                IdentifierInfo *Id,
                                ObjCInterfaceDecl* AliasedClass) { … }

ObjCCompatibleAliasDecl *
ObjCCompatibleAliasDecl::CreateDeserialized(ASTContext &C, GlobalDeclID ID) { … }

//===----------------------------------------------------------------------===//
// ObjCPropertyDecl
//===----------------------------------------------------------------------===//

void ObjCPropertyDecl::anchor() { … }

ObjCPropertyDecl *
ObjCPropertyDecl::Create(ASTContext &C, DeclContext *DC, SourceLocation L,
                         const IdentifierInfo *Id, SourceLocation AtLoc,
                         SourceLocation LParenLoc, QualType T,
                         TypeSourceInfo *TSI, PropertyControl propControl) { … }

ObjCPropertyDecl *ObjCPropertyDecl::CreateDeserialized(ASTContext &C,
                                                       GlobalDeclID ID) { … }

QualType ObjCPropertyDecl::getUsageType(QualType objectType) const { … }

bool ObjCPropertyDecl::isDirectProperty() const { … }

//===----------------------------------------------------------------------===//
// ObjCPropertyImplDecl
//===----------------------------------------------------------------------===//

ObjCPropertyImplDecl *ObjCPropertyImplDecl::Create(ASTContext &C,
                                                   DeclContext *DC,
                                                   SourceLocation atLoc,
                                                   SourceLocation L,
                                                   ObjCPropertyDecl *property,
                                                   Kind PK,
                                                   ObjCIvarDecl *ivar,
                                                   SourceLocation ivarLoc) { … }

ObjCPropertyImplDecl *
ObjCPropertyImplDecl::CreateDeserialized(ASTContext &C, GlobalDeclID ID) { … }

SourceRange ObjCPropertyImplDecl::getSourceRange() const { … }