/build/llvm-toolchain-snapshot-15~++20220420111733+e13d2efed663/clang/lib/AST/DeclObjC.cpp

Bug Summary

File:	build/llvm-toolchain-snapshot-15~++20220420111733+e13d2efed663/clang/lib/AST/DeclObjC.cpp
Warning:	line 1690, column 11 Called C++ object pointer is null

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name DeclObjC.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -mframe-pointer=none -relaxed-aliasing -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -ffunction-sections -fdata-sections -fcoverage-compilation-dir=/build/llvm-toolchain-snapshot-15~++20220420111733+e13d2efed663/build-llvm -resource-dir /usr/lib/llvm-15/lib/clang/15.0.0 -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I tools/clang/lib/AST -I /build/llvm-toolchain-snapshot-15~++20220420111733+e13d2efed663/clang/lib/AST -I /build/llvm-toolchain-snapshot-15~++20220420111733+e13d2efed663/clang/include -I tools/clang/include -I include -I /build/llvm-toolchain-snapshot-15~++20220420111733+e13d2efed663/llvm/include -D _FORTIFY_SOURCE=2 -D NDEBUG -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/x86_64-linux-gnu/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/backward -internal-isystem /usr/lib/llvm-15/lib/clang/15.0.0/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -fmacro-prefix-map=/build/llvm-toolchain-snapshot-15~++20220420111733+e13d2efed663/build-llvm=build-llvm -fmacro-prefix-map=/build/llvm-toolchain-snapshot-15~++20220420111733+e13d2efed663/= -fcoverage-prefix-map=/build/llvm-toolchain-snapshot-15~++20220420111733+e13d2efed663/build-llvm=build-llvm -fcoverage-prefix-map=/build/llvm-toolchain-snapshot-15~++20220420111733+e13d2efed663/= -O3 -Wno-unused-command-line-argument -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-class-memaccess -Wno-redundant-move -Wno-pessimizing-move -Wno-noexcept-type -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir=/build/llvm-toolchain-snapshot-15~++20220420111733+e13d2efed663/build-llvm -fdebug-prefix-map=/build/llvm-toolchain-snapshot-15~++20220420111733+e13d2efed663/build-llvm=build-llvm -fdebug-prefix-map=/build/llvm-toolchain-snapshot-15~++20220420111733+e13d2efed663/= -ferror-limit 19 -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -fcolor-diagnostics -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2022-04-20-140412-16051-1 -x c++ /build/llvm-toolchain-snapshot-15~++20220420111733+e13d2efed663/clang/lib/AST/DeclObjC.cpp

/build/llvm-toolchain-snapshot-15~++20220420111733+e13d2efed663/clang/lib/AST/DeclObjC.cpp

→

1//===- DeclObjC.cpp - ObjC Declaration AST Node Implementation ------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file implements the Objective-C related Decl classes.
10//
11//===----------------------------------------------------------------------===//

13#include "clang/AST/DeclObjC.h"
14#include "clang/AST/ASTContext.h"
15#include "clang/AST/ASTMutationListener.h"
16#include "clang/AST/Attr.h"
17#include "clang/AST/Decl.h"
18#include "clang/AST/DeclBase.h"
19#include "clang/AST/Stmt.h"
20#include "clang/AST/Type.h"
21#include "clang/AST/TypeLoc.h"
22#include "clang/Basic/IdentifierTable.h"
23#include "clang/Basic/LLVM.h"
24#include "clang/Basic/LangOptions.h"
25#include "clang/Basic/SourceLocation.h"
26#include "llvm/ADT/None.h"
27#include "llvm/ADT/SmallString.h"
28#include "llvm/ADT/SmallVector.h"
29#include "llvm/Support/Casting.h"
30#include "llvm/Support/ErrorHandling.h"
31#include "llvm/Support/raw_ostream.h"
32#include <algorithm>
33#include <cassert>
34#include <cstdint>
35#include <cstring>
36#include <queue>
37#include <utility>

39using namespace clang;

41//===----------------------------------------------------------------------===//
42// ObjCListBase
43//===----------------------------------------------------------------------===//

45void ObjCListBase::set(void *const* InList, unsigned Elts, ASTContext &Ctx) {
List = nullptr;
if (Elts == 0) return;  // Setting to an empty list is a noop.

List = new (Ctx) void*[Elts];
NumElts = Elts;
memcpy(List, InList, sizeof(void*)*Elts);
52}

54void ObjCProtocolList::set(ObjCProtocolDecl* const* InList, unsigned Elts,
                         const SourceLocation *Locs, ASTContext &Ctx) {
if (Elts == 0)
  return;

Locations = new (Ctx) SourceLocation[Elts];
memcpy(Locations, Locs, sizeof(SourceLocation) * Elts);
set(InList, Elts, Ctx);
62}

64//===----------------------------------------------------------------------===//
65// ObjCInterfaceDecl
66//===----------------------------------------------------------------------===//

68ObjCContainerDecl::ObjCContainerDecl(Kind DK, DeclContext *DC,
                                   IdentifierInfo *Id, SourceLocation nameLoc,
                                   SourceLocation atStartLoc)
  : NamedDecl(DK, DC, nameLoc, Id), DeclContext(DK) {
setAtStartLoc(atStartLoc);
73}

75void ObjCContainerDecl::anchor() {}

77/// getIvarDecl - This method looks up an ivar in this ContextDecl.
78///
79ObjCIvarDecl *
80ObjCContainerDecl::getIvarDecl(IdentifierInfo *Id) const {
lookup_result R = lookup(Id);
for (lookup_iterator Ivar = R.begin(), IvarEnd = R.end();
     Ivar != IvarEnd; ++Ivar) {
  if (auto *ivar = dyn_cast<ObjCIvarDecl>(*Ivar))
    return ivar;
}
return nullptr;
88}

90// Get the local instance/class method declared in this interface.
91ObjCMethodDecl *
92ObjCContainerDecl::getMethod(Selector Sel, bool isInstance,
                           bool AllowHidden) const {
// If this context is a hidden protocol definition, don't find any
// methods there.
if (const auto *Proto = dyn_cast<ObjCProtocolDecl>(this)) {
  if (const ObjCProtocolDecl *Def = Proto->getDefinition())
    if (!Def->isUnconditionallyVisible() && !AllowHidden)
      return nullptr;
}

// Since instance & class methods can have the same name, the loop below
// ensures we get the correct method.
//
// @interface Whatever
// - (int) class_method;
// + (float) class_method;
// @end
lookup_result R = lookup(Sel);
for (lookup_iterator Meth = R.begin(), MethEnd = R.end();
     Meth != MethEnd; ++Meth) {
  auto *MD = dyn_cast<ObjCMethodDecl>(*Meth);
  if (MD && MD->isInstanceMethod() == isInstance)
    return MD;
}
return nullptr;
117}

119/// This routine returns 'true' if a user declared setter method was
120/// found in the class, its protocols, its super classes or categories.
121/// It also returns 'true' if one of its categories has declared a 'readwrite'
122/// property.  This is because, user must provide a setter method for the
123/// category's 'readwrite' property.
124bool ObjCContainerDecl::HasUserDeclaredSetterMethod(
  const ObjCPropertyDecl *Property) const {
Selector Sel = Property->getSetterName();
lookup_result R = lookup(Sel);
for (lookup_iterator Meth = R.begin(), MethEnd = R.end();
     Meth != MethEnd; ++Meth) {
  auto *MD = dyn_cast<ObjCMethodDecl>(*Meth);
  if (MD && MD->isInstanceMethod() && !MD->isImplicit())
    return true;
}

if (const auto *ID = dyn_cast<ObjCInterfaceDecl>(this)) {
  // Also look into categories, including class extensions, looking
  // for a user declared instance method.
  for (const auto *Cat : ID->visible_categories()) {
    if (ObjCMethodDecl *MD = Cat->getInstanceMethod(Sel))
      if (!MD->isImplicit())
        return true;
    if (Cat->IsClassExtension())
      continue;
    // Also search through the categories looking for a 'readwrite'
    // declaration of this property. If one found, presumably a setter will
    // be provided (properties declared in categories will not get
    // auto-synthesized).
    for (const auto *P : Cat->properties())
      if (P->getIdentifier() == Property->getIdentifier()) {
        if (P->getPropertyAttributes() &
            ObjCPropertyAttribute::kind_readwrite)
          return true;
        break;
      }
  }

  // Also look into protocols, for a user declared instance method.
  for (const auto *Proto : ID->all_referenced_protocols())
    if (Proto->HasUserDeclaredSetterMethod(Property))
      return true;

  // And in its super class.
  ObjCInterfaceDecl *OSC = ID->getSuperClass();
  while (OSC) {
    if (OSC->HasUserDeclaredSetterMethod(Property))
      return true;
    OSC = OSC->getSuperClass();
  }
}
if (const auto *PD = dyn_cast<ObjCProtocolDecl>(this))
  for (const auto *PI : PD->protocols())
    if (PI->HasUserDeclaredSetterMethod(Property))
      return true;
return false;
175}

177ObjCPropertyDecl *
178ObjCPropertyDecl::findPropertyDecl(const DeclContext *DC,
                                 const IdentifierInfo *propertyID,
                                 ObjCPropertyQueryKind queryKind) {
// If this context is a hidden protocol definition, don't find any
// property.
if (const auto *Proto = dyn_cast<ObjCProtocolDecl>(DC)) {
  if (const ObjCProtocolDecl *Def = Proto->getDefinition())
    if (!Def->isUnconditionallyVisible())
      return nullptr;
}

// If context is class, then lookup property in its visible extensions.
// This comes before property is looked up in primary class.
if (auto *IDecl = dyn_cast<ObjCInterfaceDecl>(DC)) {
  for (const auto *Ext : IDecl->visible_extensions())
    if (ObjCPropertyDecl *PD = ObjCPropertyDecl::findPropertyDecl(Ext,
                                                     propertyID,
                                                     queryKind))
      return PD;
}

DeclContext::lookup_result R = DC->lookup(propertyID);
ObjCPropertyDecl *classProp = nullptr;
for (DeclContext::lookup_iterator I = R.begin(), E = R.end(); I != E;
     ++I)
  if (auto *PD = dyn_cast<ObjCPropertyDecl>(*I)) {
    // If queryKind is unknown, we return the instance property if one
    // exists; otherwise we return the class property.
    if ((queryKind == ObjCPropertyQueryKind::OBJC_PR_query_unknown &&
         !PD->isClassProperty()) ||
        (queryKind == ObjCPropertyQueryKind::OBJC_PR_query_class &&
         PD->isClassProperty()) ||
        (queryKind == ObjCPropertyQueryKind::OBJC_PR_query_instance &&
         !PD->isClassProperty()))
      return PD;

    if (PD->isClassProperty())
      classProp = PD;
  }

if (queryKind == ObjCPropertyQueryKind::OBJC_PR_query_unknown)
  // We can't find the instance property, return the class property.
  return classProp;

return nullptr;
223}

225IdentifierInfo *
226ObjCPropertyDecl::getDefaultSynthIvarName(ASTContext &Ctx) const {
SmallString<128> ivarName;
{
  llvm::raw_svector_ostream os(ivarName);
  os << '_' << getIdentifier()->getName();
}
return &Ctx.Idents.get(ivarName.str());
233}

235ObjCPropertyDecl *ObjCContainerDecl::getProperty(const IdentifierInfo *Id,
                                               bool IsInstance) const {
for (auto *LookupResult : lookup(Id)) {
  if (auto *Prop = dyn_cast<ObjCPropertyDecl>(LookupResult)) {
    if (Prop->isInstanceProperty() == IsInstance) {
      return Prop;
    }
  }
}
return nullptr;
245}

247/// FindPropertyDeclaration - Finds declaration of the property given its name
248/// in 'PropertyId' and returns it. It returns 0, if not found.
249ObjCPropertyDecl *ObjCContainerDecl::FindPropertyDeclaration(
  const IdentifierInfo *PropertyId,
  ObjCPropertyQueryKind QueryKind) const {
// Don't find properties within hidden protocol definitions.
if (const auto *Proto = dyn_cast<ObjCProtocolDecl>(this)) {
  if (const ObjCProtocolDecl *Def = Proto->getDefinition())
    if (!Def->isUnconditionallyVisible())
      return nullptr;
}

// Search the extensions of a class first; they override what's in
// the class itself.
if (const auto *ClassDecl = dyn_cast<ObjCInterfaceDecl>(this)) {
  for (const auto *Ext : ClassDecl->visible_extensions()) {
    if (auto *P = Ext->FindPropertyDeclaration(PropertyId, QueryKind))
      return P;
  }
}

if (ObjCPropertyDecl *PD =
      ObjCPropertyDecl::findPropertyDecl(cast<DeclContext>(this), PropertyId,
                                         QueryKind))
  return PD;

switch (getKind()) {
  default:
    break;
  case Decl::ObjCProtocol: {
    const auto *PID = cast<ObjCProtocolDecl>(this);
    for (const auto *I : PID->protocols())
      if (ObjCPropertyDecl *P = I->FindPropertyDeclaration(PropertyId,
                                                           QueryKind))
        return P;
    break;
  }
  case Decl::ObjCInterface: {
    const auto *OID = cast<ObjCInterfaceDecl>(this);
    // Look through categories (but not extensions; they were handled above).
    for (const auto *Cat : OID->visible_categories()) {
      if (!Cat->IsClassExtension())
        if (ObjCPropertyDecl *P = Cat->FindPropertyDeclaration(
                                           PropertyId, QueryKind))
          return P;
    }

    // Look through protocols.
    for (const auto *I : OID->all_referenced_protocols())
      if (ObjCPropertyDecl *P = I->FindPropertyDeclaration(PropertyId,
                                                           QueryKind))
        return P;

    // Finally, check the super class.
    if (const ObjCInterfaceDecl *superClass = OID->getSuperClass())
      return superClass->FindPropertyDeclaration(PropertyId, QueryKind);
    break;
  }
  case Decl::ObjCCategory: {
    const auto *OCD = cast<ObjCCategoryDecl>(this);
    // Look through protocols.
    if (!OCD->IsClassExtension())
      for (const auto *I : OCD->protocols())
        if (ObjCPropertyDecl *P = I->FindPropertyDeclaration(PropertyId,
                                                             QueryKind))
          return P;
    break;
  }
}
return nullptr;
317}

319void ObjCInterfaceDecl::anchor() {}

321ObjCTypeParamList *ObjCInterfaceDecl::getTypeParamList() const {
// If this particular declaration has a type parameter list, return it.
if (ObjCTypeParamList *written = getTypeParamListAsWritten())
  return written;

// If there is a definition, return its type parameter list.
if (const ObjCInterfaceDecl *def = getDefinition())
  return def->getTypeParamListAsWritten();

// Otherwise, look at previous declarations to determine whether any
// of them has a type parameter list, skipping over those
// declarations that do not.
for (const ObjCInterfaceDecl *decl = getMostRecentDecl(); decl;
     decl = decl->getPreviousDecl()) {
  if (ObjCTypeParamList *written = decl->getTypeParamListAsWritten())
    return written;
}

return nullptr;
340}

342void ObjCInterfaceDecl::setTypeParamList(ObjCTypeParamList *TPL) {
TypeParamList = TPL;
if (!TPL)
  return;
// Set the declaration context of each of the type parameters.
for (auto *typeParam : *TypeParamList)
  typeParam->setDeclContext(this);
349}

351ObjCInterfaceDecl *ObjCInterfaceDecl::getSuperClass() const {
// FIXME: Should make sure no callers ever do this.
if (!hasDefinition())
  return nullptr;

if (data().ExternallyCompleted)
  LoadExternalDefinition();

if (const ObjCObjectType *superType = getSuperClassType()) {
  if (ObjCInterfaceDecl *superDecl = superType->getInterface()) {
    if (ObjCInterfaceDecl *superDef = superDecl->getDefinition())
      return superDef;

    return superDecl;
  }
}

return nullptr;
369}

371SourceLocation ObjCInterfaceDecl::getSuperClassLoc() const {
if (TypeSourceInfo *superTInfo = getSuperClassTInfo())
  return superTInfo->getTypeLoc().getBeginLoc();

return SourceLocation();
376}

378/// FindPropertyVisibleInPrimaryClass - Finds declaration of the property
379/// with name 'PropertyId' in the primary class; including those in protocols
380/// (direct or indirect) used by the primary class.
381ObjCPropertyDecl *
382ObjCInterfaceDecl::FindPropertyVisibleInPrimaryClass(
                     IdentifierInfo *PropertyId,
                     ObjCPropertyQueryKind QueryKind) const {
// FIXME: Should make sure no callers ever do this.
if (!hasDefinition())
  return nullptr;

if (data().ExternallyCompleted)
  LoadExternalDefinition();

if (ObjCPropertyDecl *PD =
    ObjCPropertyDecl::findPropertyDecl(cast<DeclContext>(this), PropertyId,
                                       QueryKind))
  return PD;

// Look through protocols.
for (const auto *I : all_referenced_protocols())
  if (ObjCPropertyDecl *P = I->FindPropertyDeclaration(PropertyId,
                                                       QueryKind))
    return P;

return nullptr;
404}

406void ObjCInterfaceDecl::collectPropertiesToImplement(PropertyMap &PM,
                                                   PropertyDeclOrder &PO) const {
for (auto *Prop : properties()) {
  PM[std::make_pair(Prop->getIdentifier(), Prop->isClassProperty())] = Prop;
  PO.push_back(Prop);
}
for (const auto *Ext : known_extensions()) {
  const ObjCCategoryDecl *ClassExt = Ext;
  for (auto *Prop : ClassExt->properties()) {
    PM[std::make_pair(Prop->getIdentifier(), Prop->isClassProperty())] = Prop;
    PO.push_back(Prop);
  }
}
for (const auto *PI : all_referenced_protocols())
  PI->collectPropertiesToImplement(PM, PO);
// Note, the properties declared only in class extensions are still copied
// into the main @interface's property list, and therefore we don't
// explicitly, have to search class extension properties.
424}

426bool ObjCInterfaceDecl::isArcWeakrefUnavailable() const {
const ObjCInterfaceDecl *Class = this;
while (Class) {
  if (Class->hasAttr<ArcWeakrefUnavailableAttr>())
    return true;
  Class = Class->getSuperClass();
}
return false;
434}

436const ObjCInterfaceDecl *ObjCInterfaceDecl::isObjCRequiresPropertyDefs() const {
const ObjCInterfaceDecl *Class = this;
while (Class) {
  if (Class->hasAttr<ObjCRequiresPropertyDefsAttr>())
    return Class;
  Class = Class->getSuperClass();
}
return nullptr;
444}

446void ObjCInterfaceDecl::mergeClassExtensionProtocolList(
                            ObjCProtocolDecl *const* ExtList, unsigned ExtNum,
                            ASTContext &C) {
if (data().ExternallyCompleted)
  LoadExternalDefinition();

if (data().AllReferencedProtocols.empty() &&
    data().ReferencedProtocols.empty()) {
  data().AllReferencedProtocols.set(ExtList, ExtNum, C);
  return;
}

// Check for duplicate protocol in class's protocol list.
// This is O(n*m). But it is extremely rare and number of protocols in
// class or its extension are very few.
SmallVector<ObjCProtocolDecl *, 8> ProtocolRefs;
for (unsigned i = 0; i < ExtNum; i++) {
  bool protocolExists = false;
  ObjCProtocolDecl *ProtoInExtension = ExtList[i];
  for (auto *Proto : all_referenced_protocols()) {
    if (C.ProtocolCompatibleWithProtocol(ProtoInExtension, Proto)) {
      protocolExists = true;
      break;
    }
  }
  // Do we want to warn on a protocol in extension class which
  // already exist in the class? Probably not.
  if (!protocolExists)
    ProtocolRefs.push_back(ProtoInExtension);
}

if (ProtocolRefs.empty())
  return;

// Merge ProtocolRefs into class's protocol list;
ProtocolRefs.append(all_referenced_protocol_begin(),
                    all_referenced_protocol_end());

data().AllReferencedProtocols.set(ProtocolRefs.data(), ProtocolRefs.size(),C);
485}

487const ObjCInterfaceDecl *
488ObjCInterfaceDecl::findInterfaceWithDesignatedInitializers() const {
const ObjCInterfaceDecl *IFace = this;
while (IFace) {
  if (IFace->hasDesignatedInitializers())
    return IFace;
  if (!IFace->inheritsDesignatedInitializers())
    break;
  IFace = IFace->getSuperClass();
}
return nullptr;
498}

500static bool isIntroducingInitializers(const ObjCInterfaceDecl *D) {
for (const auto *MD : D->instance_methods()) {
  if (MD->getMethodFamily() == OMF_init && !MD->isOverriding())
    return true;
}
for (const auto *Ext : D->visible_extensions()) {
  for (const auto *MD : Ext->instance_methods()) {
    if (MD->getMethodFamily() == OMF_init && !MD->isOverriding())
      return true;
  }
}
if (const auto *ImplD = D->getImplementation()) {
  for (const auto *MD : ImplD->instance_methods()) {
    if (MD->getMethodFamily() == OMF_init && !MD->isOverriding())
      return true;
  }
}
return false;
518}

520bool ObjCInterfaceDecl::inheritsDesignatedInitializers() const {
switch (data().InheritedDesignatedInitializers) {
case DefinitionData::IDI_Inherited:
  return true;
case DefinitionData::IDI_NotInherited:
  return false;
case DefinitionData::IDI_Unknown:
  // If the class introduced initializers we conservatively assume that we
  // don't know if any of them is a designated initializer to avoid possible
  // misleading warnings.
  if (isIntroducingInitializers(this)) {
    data().InheritedDesignatedInitializers = DefinitionData::IDI_NotInherited;
  } else {
    if (auto SuperD = getSuperClass()) {
      data().InheritedDesignatedInitializers =
        SuperD->declaresOrInheritsDesignatedInitializers() ?
          DefinitionData::IDI_Inherited :
          DefinitionData::IDI_NotInherited;
    } else {
      data().InheritedDesignatedInitializers =
        DefinitionData::IDI_NotInherited;
    }
  }
  assert(data().InheritedDesignatedInitializers(static_cast <bool> (data().InheritedDesignatedInitializers
 != DefinitionData::IDI_Unknown) ? void (0) : __assert_fail (
"data().InheritedDesignatedInitializers != DefinitionData::IDI_Unknown"
, "clang/lib/AST/DeclObjC.cpp", 544, __extension__ __PRETTY_FUNCTION__
))
           != DefinitionData::IDI_Unknown)(static_cast <bool> (data().InheritedDesignatedInitializers
 != DefinitionData::IDI_Unknown) ? void (0) : __assert_fail (
"data().InheritedDesignatedInitializers != DefinitionData::IDI_Unknown"
, "clang/lib/AST/DeclObjC.cpp", 544, __extension__ __PRETTY_FUNCTION__
));
  return data().InheritedDesignatedInitializers ==
      DefinitionData::IDI_Inherited;
}

llvm_unreachable("unexpected InheritedDesignatedInitializers value")::llvm::llvm_unreachable_internal("unexpected InheritedDesignatedInitializers value"
, "clang/lib/AST/DeclObjC.cpp", 549);
550}

552void ObjCInterfaceDecl::getDesignatedInitializers(
  llvm::SmallVectorImpl<const ObjCMethodDecl *> &Methods) const {
// Check for a complete definition and recover if not so.
if (!isThisDeclarationADefinition())
  return;
if (data().ExternallyCompleted)
  LoadExternalDefinition();

const ObjCInterfaceDecl *IFace= findInterfaceWithDesignatedInitializers();
if (!IFace)
  return;

for (const auto *MD : IFace->instance_methods())
  if (MD->isThisDeclarationADesignatedInitializer())
    Methods.push_back(MD);
for (const auto *Ext : IFace->visible_extensions()) {
  for (const auto *MD : Ext->instance_methods())
    if (MD->isThisDeclarationADesignatedInitializer())
      Methods.push_back(MD);
}
572}

574bool ObjCInterfaceDecl::isDesignatedInitializer(Selector Sel,
                                    const ObjCMethodDecl **InitMethod) const {
bool HasCompleteDef = isThisDeclarationADefinition();
// During deserialization the data record for the ObjCInterfaceDecl could
// be made invariant by reusing the canonical decl. Take this into account
// when checking for the complete definition.
if (!HasCompleteDef && getCanonicalDecl()->hasDefinition() &&
    getCanonicalDecl()->getDefinition() == getDefinition())
  HasCompleteDef = true;

// Check for a complete definition and recover if not so.
if (!HasCompleteDef)
  return false;

if (data().ExternallyCompleted)
  LoadExternalDefinition();

const ObjCInterfaceDecl *IFace= findInterfaceWithDesignatedInitializers();
if (!IFace)
  return false;

if (const ObjCMethodDecl *MD = IFace->getInstanceMethod(Sel)) {
  if (MD->isThisDeclarationADesignatedInitializer()) {
    if (InitMethod)
      *InitMethod = MD;
    return true;
  }
}
for (const auto *Ext : IFace->visible_extensions()) {
  if (const ObjCMethodDecl *MD = Ext->getInstanceMethod(Sel)) {
    if (MD->isThisDeclarationADesignatedInitializer()) {
      if (InitMethod)
        *InitMethod = MD;
      return true;
    }
  }
}
return false;
612}

614void ObjCInterfaceDecl::allocateDefinitionData() {
assert(!hasDefinition() && "ObjC class already has a definition")(static_cast <bool> (!hasDefinition() && "ObjC class already has a definition"
) ? void (0) : __assert_fail ("!hasDefinition() && \"ObjC class already has a definition\""
, "clang/lib/AST/DeclObjC.cpp", 615, __extension__ __PRETTY_FUNCTION__
));
Data.setPointer(new (getASTContext()) DefinitionData());
Data.getPointer()->Definition = this;
618}

620void ObjCInterfaceDecl::startDefinition() {
allocateDefinitionData();

// Update all of the declarations with a pointer to the definition.
for (auto *RD : redecls()) {
  if (RD != this)
    RD->Data = Data;
}
628}

630ObjCIvarDecl *ObjCInterfaceDecl::lookupInstanceVariable(IdentifierInfo *ID,
                                            ObjCInterfaceDecl *&clsDeclared) {
// FIXME: Should make sure no callers ever do this.
if (!hasDefinition())
  return nullptr;

if (data().ExternallyCompleted)
  LoadExternalDefinition();

ObjCInterfaceDecl* ClassDecl = this;
while (ClassDecl != nullptr) {
  if (ObjCIvarDecl *I = ClassDecl->getIvarDecl(ID)) {
    clsDeclared = ClassDecl;
    return I;
  }

  for (const auto *Ext : ClassDecl->visible_extensions()) {
    if (ObjCIvarDecl *I = Ext->getIvarDecl(ID)) {
      clsDeclared = ClassDecl;
      return I;
    }
  }

  ClassDecl = ClassDecl->getSuperClass();
}
return nullptr;
656}

658/// lookupInheritedClass - This method returns ObjCInterfaceDecl * of the super
659/// class whose name is passed as argument. If it is not one of the super classes
660/// the it returns NULL.
661ObjCInterfaceDecl *ObjCInterfaceDecl::lookupInheritedClass(
                                      const IdentifierInfo*ICName) {
// FIXME: Should make sure no callers ever do this.
if (!hasDefinition())
  return nullptr;

if (data().ExternallyCompleted)
  LoadExternalDefinition();

ObjCInterfaceDecl* ClassDecl = this;
while (ClassDecl != nullptr) {
  if (ClassDecl->getIdentifier() == ICName)
    return ClassDecl;
  ClassDecl = ClassDecl->getSuperClass();
}
return nullptr;
677}

679ObjCProtocolDecl *
680ObjCInterfaceDecl::lookupNestedProtocol(IdentifierInfo *Name) {
for (auto *P : all_referenced_protocols())
  if (P->lookupProtocolNamed(Name))
    return P;
ObjCInterfaceDecl *SuperClass = getSuperClass();
return SuperClass ? SuperClass->lookupNestedProtocol(Name) : nullptr;
686}

688/// lookupMethod - This method returns an instance/class method by looking in
689/// the class, its categories, and its super classes (using a linear search).
690/// When argument category "C" is specified, any implicit method found
691/// in this category is ignored.
692ObjCMethodDecl *ObjCInterfaceDecl::lookupMethod(Selector Sel,
                                              bool isInstance,
                                              bool shallowCategoryLookup,
                                              bool followSuper,
                                              const ObjCCategoryDecl *C) const
697{
// FIXME: Should make sure no callers ever do this.
if (!hasDefinition())
  return nullptr;

const ObjCInterfaceDecl* ClassDecl = this;
ObjCMethodDecl *MethodDecl = nullptr;

if (data().ExternallyCompleted)
  LoadExternalDefinition();

while (ClassDecl) {
  // 1. Look through primary class.
  if ((MethodDecl = ClassDecl->getMethod(Sel, isInstance)))
    return MethodDecl;

  // 2. Didn't find one yet - now look through categories.
  for (const auto *Cat : ClassDecl->visible_categories())
    if ((MethodDecl = Cat->getMethod(Sel, isInstance)))
      if (C != Cat || !MethodDecl->isImplicit())
        return MethodDecl;

  // 3. Didn't find one yet - look through primary class's protocols.
  for (const auto *I : ClassDecl->protocols())
    if ((MethodDecl = I->lookupMethod(Sel, isInstance)))
      return MethodDecl;

  // 4. Didn't find one yet - now look through categories' protocols
  if (!shallowCategoryLookup)
    for (const auto *Cat : ClassDecl->visible_categories()) {
      // Didn't find one yet - look through protocols.
      const ObjCList<ObjCProtocolDecl> &Protocols =
        Cat->getReferencedProtocols();
      for (auto *Protocol : Protocols)
        if ((MethodDecl = Protocol->lookupMethod(Sel, isInstance)))
          if (C != Cat || !MethodDecl->isImplicit())
            return MethodDecl;
    }


  if (!followSuper)
    return nullptr;

  // 5. Get to the super class (if any).
  ClassDecl = ClassDecl->getSuperClass();
}
return nullptr;
744}

746// Will search "local" class/category implementations for a method decl.
747// If failed, then we search in class's root for an instance method.
748// Returns 0 if no method is found.
749ObjCMethodDecl *ObjCInterfaceDecl::lookupPrivateMethod(
                                 const Selector &Sel,
                                 bool Instance) const {
// FIXME: Should make sure no callers ever do this.
if (!hasDefinition())
  return nullptr;

if (data().ExternallyCompleted)
  LoadExternalDefinition();

ObjCMethodDecl *Method = nullptr;
if (ObjCImplementationDecl *ImpDecl = getImplementation())
  Method = Instance ? ImpDecl->getInstanceMethod(Sel)
                    : ImpDecl->getClassMethod(Sel);

// Look through local category implementations associated with the class.
if (!Method)
  Method = getCategoryMethod(Sel, Instance);

// Before we give up, check if the selector is an instance method.
// But only in the root. This matches gcc's behavior and what the
// runtime expects.
if (!Instance && !Method && !getSuperClass()) {
  Method = lookupInstanceMethod(Sel);
  // Look through local category implementations associated
  // with the root class.
  if (!Method)
    Method = lookupPrivateMethod(Sel, true);
}

if (!Method && getSuperClass())
  return getSuperClass()->lookupPrivateMethod(Sel, Instance);
return Method;
782}

784//===----------------------------------------------------------------------===//
785// ObjCMethodDecl
786//===----------------------------------------------------------------------===//

788ObjCMethodDecl::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,
  ImplementationControl impControl, bool HasRelatedResultType)
  : NamedDecl(ObjCMethod, contextDecl, beginLoc, SelInfo),
    DeclContext(ObjCMethod), MethodDeclType(T), ReturnTInfo(ReturnTInfo),
    DeclEndLoc(endLoc) {

// Initialized the bits stored in DeclContext.
ObjCMethodDeclBits.Family =
    static_cast<ObjCMethodFamily>(InvalidObjCMethodFamily);
setInstanceMethod(isInstance);
setVariadic(isVariadic);
setPropertyAccessor(isPropertyAccessor);
setSynthesizedAccessorStub(isSynthesizedAccessorStub);
setDefined(isDefined);
setIsRedeclaration(false);
setHasRedeclaration(false);
setDeclImplementation(impControl);
setObjCDeclQualifier(OBJC_TQ_None);
setRelatedResultType(HasRelatedResultType);
setSelLocsKind(SelLoc_StandardNoSpace);
setOverriding(false);
setHasSkippedBody(false);

setImplicit(isImplicitlyDeclared);
816}

818ObjCMethodDecl *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, ImplementationControl impControl,
  bool HasRelatedResultType) {
return new (C, contextDecl) ObjCMethodDecl(
    beginLoc, endLoc, SelInfo, T, ReturnTInfo, contextDecl, isInstance,
    isVariadic, isPropertyAccessor, isSynthesizedAccessorStub,
    isImplicitlyDeclared, isDefined, impControl, HasRelatedResultType);
829}

831ObjCMethodDecl *ObjCMethodDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
return new (C, ID) ObjCMethodDecl(SourceLocation(), SourceLocation(),
                                  Selector(), QualType(), nullptr, nullptr);
834}

836bool ObjCMethodDecl::isDirectMethod() const {
return hasAttr<ObjCDirectAttr>() &&
       !getASTContext().getLangOpts().ObjCDisableDirectMethodsForTesting;
839}

841bool ObjCMethodDecl::isThisDeclarationADesignatedInitializer() const {
return getMethodFamily() == OMF_init &&
    hasAttr<ObjCDesignatedInitializerAttr>();
844}

846bool ObjCMethodDecl::definedInNSObject(const ASTContext &Ctx) const {
if (const auto *PD = dyn_cast<const ObjCProtocolDecl>(getDeclContext()))
  return PD->getIdentifier() == Ctx.getNSObjectName();
if (const auto *ID = dyn_cast<const ObjCInterfaceDecl>(getDeclContext()))
  return ID->getIdentifier() == Ctx.getNSObjectName();
return false;
852}

854bool ObjCMethodDecl::isDesignatedInitializerForTheInterface(
  const ObjCMethodDecl **InitMethod) const {
if (getMethodFamily() != OMF_init)
  return false;
const DeclContext *DC = getDeclContext();
if (isa<ObjCProtocolDecl>(DC))
  return false;
if (const ObjCInterfaceDecl *ID = getClassInterface())
  return ID->isDesignatedInitializer(getSelector(), InitMethod);
return false;
864}

866bool ObjCMethodDecl::hasParamDestroyedInCallee() const {
for (auto param : parameters()) {
  if (param->isDestroyedInCallee())
    return true;
}
return false;
872}

874Stmt *ObjCMethodDecl::getBody() const {
return Body.get(getASTContext().getExternalSource());
876}

878void ObjCMethodDecl::setAsRedeclaration(const ObjCMethodDecl *PrevMethod) {
assert(PrevMethod)(static_cast <bool> (PrevMethod) ? void (0) : __assert_fail
 ("PrevMethod", "clang/lib/AST/DeclObjC.cpp", 879, __extension__
 __PRETTY_FUNCTION__));
getASTContext().setObjCMethodRedeclaration(PrevMethod, this);
setIsRedeclaration(true);
PrevMethod->setHasRedeclaration(true);
883}

885void ObjCMethodDecl::setParamsAndSelLocs(ASTContext &C,
                                       ArrayRef<ParmVarDecl*> Params,
                                       ArrayRef<SourceLocation> SelLocs) {
ParamsAndSelLocs = nullptr;
NumParams = Params.size();
if (Params.empty() && SelLocs.empty())
  return;

static_assert(alignof(ParmVarDecl *) >= alignof(SourceLocation),
              "Alignment not sufficient for SourceLocation");

unsigned Size = sizeof(ParmVarDecl *) * NumParams +
                sizeof(SourceLocation) * SelLocs.size();
ParamsAndSelLocs = C.Allocate(Size);
std::copy(Params.begin(), Params.end(), getParams());
std::copy(SelLocs.begin(), SelLocs.end(), getStoredSelLocs());
901}

903void ObjCMethodDecl::getSelectorLocs(
                             SmallVectorImpl<SourceLocation> &SelLocs) const {
for (unsigned i = 0, e = getNumSelectorLocs(); i != e; ++i)
  SelLocs.push_back(getSelectorLoc(i));
907}

909void ObjCMethodDecl::setMethodParams(ASTContext &C,
                                   ArrayRef<ParmVarDecl*> Params,
                                   ArrayRef<SourceLocation> SelLocs) {
assert((!SelLocs.empty() || isImplicit()) &&(static_cast <bool> ((!SelLocs.empty() || isImplicit())
 && "No selector locs for non-implicit method") ? void
 (0) : __assert_fail ("(!SelLocs.empty() || isImplicit()) && \"No selector locs for non-implicit method\""
, "clang/lib/AST/DeclObjC.cpp", 913, __extension__ __PRETTY_FUNCTION__
))
       "No selector locs for non-implicit method")(static_cast <bool> ((!SelLocs.empty() || isImplicit())
 && "No selector locs for non-implicit method") ? void
 (0) : __assert_fail ("(!SelLocs.empty() || isImplicit()) && \"No selector locs for non-implicit method\""
, "clang/lib/AST/DeclObjC.cpp", 913, __extension__ __PRETTY_FUNCTION__
));
if (isImplicit())
  return setParamsAndSelLocs(C, Params, llvm::None);

setSelLocsKind(hasStandardSelectorLocs(getSelector(), SelLocs, Params,
                                      DeclEndLoc));
if (getSelLocsKind() != SelLoc_NonStandard)
  return setParamsAndSelLocs(C, Params, llvm::None);

setParamsAndSelLocs(C, Params, SelLocs);
923}

925/// A definition will return its interface declaration.
926/// An interface declaration will return its definition.
927/// Otherwise it will return itself.
928ObjCMethodDecl *ObjCMethodDecl::getNextRedeclarationImpl() {
ASTContext &Ctx = getASTContext();
ObjCMethodDecl *Redecl = nullptr;
if (hasRedeclaration())
  Redecl = const_cast<ObjCMethodDecl*>(Ctx.getObjCMethodRedeclaration(this));
if (Redecl)
  return Redecl;

auto *CtxD = cast<Decl>(getDeclContext());

if (!CtxD->isInvalidDecl()) {
  if (auto *IFD = dyn_cast<ObjCInterfaceDecl>(CtxD)) {
    if (ObjCImplementationDecl *ImplD = Ctx.getObjCImplementation(IFD))
      if (!ImplD->isInvalidDecl())
        Redecl = ImplD->getMethod(getSelector(), isInstanceMethod());

  } else if (auto *CD = dyn_cast<ObjCCategoryDecl>(CtxD)) {
    if (ObjCCategoryImplDecl *ImplD = Ctx.getObjCImplementation(CD))
      if (!ImplD->isInvalidDecl())
        Redecl = ImplD->getMethod(getSelector(), isInstanceMethod());

  } else if (auto *ImplD = dyn_cast<ObjCImplementationDecl>(CtxD)) {
    if (ObjCInterfaceDecl *IFD = ImplD->getClassInterface())
      if (!IFD->isInvalidDecl())
        Redecl = IFD->getMethod(getSelector(), isInstanceMethod());

  } else if (auto *CImplD = dyn_cast<ObjCCategoryImplDecl>(CtxD)) {
    if (ObjCCategoryDecl *CatD = CImplD->getCategoryDecl())
      if (!CatD->isInvalidDecl())
        Redecl = CatD->getMethod(getSelector(), isInstanceMethod());
  }
}

// Ensure that the discovered method redeclaration has a valid declaration
// context. Used to prevent infinite loops when iterating redeclarations in
// a partially invalid AST.
if (Redecl && cast<Decl>(Redecl->getDeclContext())->isInvalidDecl())
  Redecl = nullptr;

if (!Redecl && isRedeclaration()) {
  // This is the last redeclaration, go back to the first method.
  return cast<ObjCContainerDecl>(CtxD)->getMethod(getSelector(),
                                                  isInstanceMethod(),
                                                  /*AllowHidden=*/true);
}

return Redecl ? Redecl : this;
975}

977ObjCMethodDecl *ObjCMethodDecl::getCanonicalDecl() {
auto *CtxD = cast<Decl>(getDeclContext());
const auto &Sel = getSelector();

if (auto *ImplD = dyn_cast<ObjCImplementationDecl>(CtxD)) {
  if (ObjCInterfaceDecl *IFD = ImplD->getClassInterface()) {
    // When the container is the ObjCImplementationDecl (the primary
    // @implementation), then the canonical Decl is either in
    // the class Interface, or in any of its extension.
    //
    // So when we don't find it in the ObjCInterfaceDecl,
    // sift through extensions too.
    if (ObjCMethodDecl *MD = IFD->getMethod(Sel, isInstanceMethod()))
      return MD;
    for (auto *Ext : IFD->known_extensions())
      if (ObjCMethodDecl *MD = Ext->getMethod(Sel, isInstanceMethod()))
        return MD;
  }
} else if (auto *CImplD = dyn_cast<ObjCCategoryImplDecl>(CtxD)) {
  if (ObjCCategoryDecl *CatD = CImplD->getCategoryDecl())
    if (ObjCMethodDecl *MD = CatD->getMethod(Sel, isInstanceMethod()))
      return MD;
}

if (isRedeclaration()) {
  // It is possible that we have not done deserializing the ObjCMethod yet.
  ObjCMethodDecl *MD =
      cast<ObjCContainerDecl>(CtxD)->getMethod(Sel, isInstanceMethod(),
                                               /*AllowHidden=*/true);
  return MD ? MD : this;
}

return this;
1010}

1012SourceLocation ObjCMethodDecl::getEndLoc() const {
if (Stmt *Body = getBody())
  return Body->getEndLoc();
return DeclEndLoc;
1016}

1018ObjCMethodFamily ObjCMethodDecl::getMethodFamily() const {
auto family = static_cast<ObjCMethodFamily>(ObjCMethodDeclBits.Family);
if (family != static_cast<unsigned>(InvalidObjCMethodFamily))
  return family;

// Check for an explicit attribute.
if (const ObjCMethodFamilyAttr *attr = getAttr<ObjCMethodFamilyAttr>()) {
  // The unfortunate necessity of mapping between enums here is due
  // to the attributes framework.
  switch (attr->getFamily()) {
  case ObjCMethodFamilyAttr::OMF_None: family = OMF_None; break;
  case ObjCMethodFamilyAttr::OMF_alloc: family = OMF_alloc; break;
  case ObjCMethodFamilyAttr::OMF_copy: family = OMF_copy; break;
  case ObjCMethodFamilyAttr::OMF_init: family = OMF_init; break;
  case ObjCMethodFamilyAttr::OMF_mutableCopy: family = OMF_mutableCopy; break;
  case ObjCMethodFamilyAttr::OMF_new: family = OMF_new; break;
  }
  ObjCMethodDeclBits.Family = family;
  return family;
}

family = getSelector().getMethodFamily();
switch (family) {
case OMF_None: break;

// init only has a conventional meaning for an instance method, and
// it has to return an object.
case OMF_init:
  if (!isInstanceMethod() || !getReturnType()->isObjCObjectPointerType())
    family = OMF_None;
  break;

// alloc/copy/new have a conventional meaning for both class and
// instance methods, but they require an object return.
case OMF_alloc:
case OMF_copy:
case OMF_mutableCopy:
case OMF_new:
  if (!getReturnType()->isObjCObjectPointerType())
    family = OMF_None;
  break;

// These selectors have a conventional meaning only for instance methods.
case OMF_dealloc:
case OMF_finalize:
case OMF_retain:
case OMF_release:
case OMF_autorelease:
case OMF_retainCount:
case OMF_self:
  if (!isInstanceMethod())
    family = OMF_None;
  break;

case OMF_initialize:
  if (isInstanceMethod() || !getReturnType()->isVoidType())
    family = OMF_None;
  break;

case OMF_performSelector:
  if (!isInstanceMethod() || !getReturnType()->isObjCIdType())
    family = OMF_None;
  else {
    unsigned noParams = param_size();
    if (noParams < 1 || noParams > 3)
      family = OMF_None;
    else {
      ObjCMethodDecl::param_type_iterator it = param_type_begin();
      QualType ArgT = (*it);
      if (!ArgT->isObjCSelType()) {
        family = OMF_None;
        break;
      }
      while (--noParams) {
        it++;
        ArgT = (*it);
        if (!ArgT->isObjCIdType()) {
          family = OMF_None;
          break;
        }
      }
    }
  }
  break;

}

// Cache the result.
ObjCMethodDeclBits.Family = family;
return family;
1108}

1110QualType ObjCMethodDecl::getSelfType(ASTContext &Context,
                                   const ObjCInterfaceDecl *OID,
                                   bool &selfIsPseudoStrong,
                                   bool &selfIsConsumed) const {
QualType selfTy;
selfIsPseudoStrong = false;
selfIsConsumed = false;
if (isInstanceMethod()) {
  // There may be no interface context due to error in declaration
  // of the interface (which has been reported). Recover gracefully.
  if (OID) {
    selfTy = Context.getObjCInterfaceType(OID);
    selfTy = Context.getObjCObjectPointerType(selfTy);
  } else {
    selfTy = Context.getObjCIdType();
  }
} else // we have a factory method.
  selfTy = Context.getObjCClassType();

if (Context.getLangOpts().ObjCAutoRefCount) {
  if (isInstanceMethod()) {
    selfIsConsumed = hasAttr<NSConsumesSelfAttr>();

    // 'self' is always __strong.  It's actually pseudo-strong except
    // in init methods (or methods labeled ns_consumes_self), though.
    Qualifiers qs;
    qs.setObjCLifetime(Qualifiers::OCL_Strong);
    selfTy = Context.getQualifiedType(selfTy, qs);

    // In addition, 'self' is const unless this is an init method.
    if (getMethodFamily() != OMF_init && !selfIsConsumed) {
      selfTy = selfTy.withConst();
      selfIsPseudoStrong = true;
    }
  }
  else {
    assert(isClassMethod())(static_cast <bool> (isClassMethod()) ? void (0) : __assert_fail
 ("isClassMethod()", "clang/lib/AST/DeclObjC.cpp", 1146, __extension__
 __PRETTY_FUNCTION__));
    // 'self' is always const in class methods.
    selfTy = selfTy.withConst();
    selfIsPseudoStrong = true;
  }
}
return selfTy;
1153}

1155void ObjCMethodDecl::createImplicitParams(ASTContext &Context,
                                        const ObjCInterfaceDecl *OID) {
bool selfIsPseudoStrong, selfIsConsumed;
QualType selfTy =
  getSelfType(Context, OID, selfIsPseudoStrong, selfIsConsumed);
auto *Self = ImplicitParamDecl::Create(Context, this, SourceLocation(),
                                       &Context.Idents.get("self"), selfTy,
                                       ImplicitParamDecl::ObjCSelf);
setSelfDecl(Self);

if (selfIsConsumed)
  Self->addAttr(NSConsumedAttr::CreateImplicit(Context));

if (selfIsPseudoStrong)
  Self->setARCPseudoStrong(true);

setCmdDecl(ImplicitParamDecl::Create(
    Context, this, SourceLocation(), &Context.Idents.get("_cmd"),
    Context.getObjCSelType(), ImplicitParamDecl::ObjCCmd));
1174}

1176ObjCInterfaceDecl *ObjCMethodDecl::getClassInterface() {
if (auto *ID = dyn_cast<ObjCInterfaceDecl>(getDeclContext()))
  return ID;
if (auto *CD = dyn_cast<ObjCCategoryDecl>(getDeclContext()))
  return CD->getClassInterface();
if (auto *IMD = dyn_cast<ObjCImplDecl>(getDeclContext()))
  return IMD->getClassInterface();
if (isa<ObjCProtocolDecl>(getDeclContext()))
  return nullptr;
llvm_unreachable("unknown method context")::llvm::llvm_unreachable_internal("unknown method context", "clang/lib/AST/DeclObjC.cpp"
, 1185);
1186}

1188ObjCCategoryDecl *ObjCMethodDecl::getCategory() {
if (auto *CD = dyn_cast<ObjCCategoryDecl>(getDeclContext()))
  return CD;
if (auto *IMD = dyn_cast<ObjCCategoryImplDecl>(getDeclContext()))
  return IMD->getCategoryDecl();
return nullptr;
1194}

1196SourceRange ObjCMethodDecl::getReturnTypeSourceRange() const {
const auto *TSI = getReturnTypeSourceInfo();
if (TSI)
  return TSI->getTypeLoc().getSourceRange();
return SourceRange();
1201}

1203QualType ObjCMethodDecl::getSendResultType() const {
ASTContext &Ctx = getASTContext();
return getReturnType().getNonLValueExprType(Ctx)
         .substObjCTypeArgs(Ctx, {}, ObjCSubstitutionContext::Result);
1207}

1209QualType ObjCMethodDecl::getSendResultType(QualType receiverType) const {
// FIXME: Handle related result types here.

return getReturnType().getNonLValueExprType(getASTContext())
         .substObjCMemberType(receiverType, getDeclContext(),
                              ObjCSubstitutionContext::Result);
1215}

1217static void CollectOverriddenMethodsRecurse(const ObjCContainerDecl *Container,
                                          const ObjCMethodDecl *Method,
                             SmallVectorImpl<const ObjCMethodDecl *> &Methods,
                                          bool MovedToSuper) {
if (!Container)
  return;

// In categories look for overridden methods from protocols. A method from
// category is not "overridden" since it is considered as the "same" method
// (same USR) as the one from the interface.
if (const auto *Category = dyn_cast<ObjCCategoryDecl>(Container)) {
  // Check whether we have a matching method at this category but only if we
  // are at the super class level.
  if (MovedToSuper)
    if (ObjCMethodDecl *
          Overridden = Container->getMethod(Method->getSelector(),
                                            Method->isInstanceMethod(),
                                            /*AllowHidden=*/true))
      if (Method != Overridden) {
        // We found an override at this category; there is no need to look
        // into its protocols.
        Methods.push_back(Overridden);
        return;
      }

  for (const auto *P : Category->protocols())
    CollectOverriddenMethodsRecurse(P, Method, Methods, MovedToSuper);
  return;
}

// Check whether we have a matching method at this level.
if (const ObjCMethodDecl *
      Overridden = Container->getMethod(Method->getSelector(),
                                        Method->isInstanceMethod(),
                                        /*AllowHidden=*/true))
  if (Method != Overridden) {
    // We found an override at this level; there is no need to look
    // into other protocols or categories.
    Methods.push_back(Overridden);
    return;
  }

if (const auto *Protocol = dyn_cast<ObjCProtocolDecl>(Container)){
  for (const auto *P : Protocol->protocols())
    CollectOverriddenMethodsRecurse(P, Method, Methods, MovedToSuper);
}

if (const auto *Interface = dyn_cast<ObjCInterfaceDecl>(Container)) {
  for (const auto *P : Interface->protocols())
    CollectOverriddenMethodsRecurse(P, Method, Methods, MovedToSuper);

  for (const auto *Cat : Interface->known_categories())
    CollectOverriddenMethodsRecurse(Cat, Method, Methods, MovedToSuper);

  if (const ObjCInterfaceDecl *Super = Interface->getSuperClass())
    return CollectOverriddenMethodsRecurse(Super, Method, Methods,
                                           /*MovedToSuper=*/true);
}
1275}

1277static inline void CollectOverriddenMethods(const ObjCContainerDecl *Container,
                                          const ObjCMethodDecl *Method,
                           SmallVectorImpl<const ObjCMethodDecl *> &Methods) {
CollectOverriddenMethodsRecurse(Container, Method, Methods,
                                /*MovedToSuper=*/false);
1282}

1284static void collectOverriddenMethodsSlow(const ObjCMethodDecl *Method,
                        SmallVectorImpl<const ObjCMethodDecl *> &overridden) {
assert(Method->isOverriding())(static_cast <bool> (Method->isOverriding()) ? void (
0) : __assert_fail ("Method->isOverriding()", "clang/lib/AST/DeclObjC.cpp"
, 1286, __extension__ __PRETTY_FUNCTION__));

if (const auto *ProtD =
        dyn_cast<ObjCProtocolDecl>(Method->getDeclContext())) {
  CollectOverriddenMethods(ProtD, Method, overridden);

} else if (const auto *IMD =
               dyn_cast<ObjCImplDecl>(Method->getDeclContext())) {
  const ObjCInterfaceDecl *ID = IMD->getClassInterface();
  if (!ID)
    return;
  // Start searching for overridden methods using the method from the
  // interface as starting point.
  if (const ObjCMethodDecl *IFaceMeth = ID->getMethod(Method->getSelector(),
                                                  Method->isInstanceMethod(),
                                                  /*AllowHidden=*/true))
    Method = IFaceMeth;
  CollectOverriddenMethods(ID, Method, overridden);

} else if (const auto *CatD =
               dyn_cast<ObjCCategoryDecl>(Method->getDeclContext())) {
  const ObjCInterfaceDecl *ID = CatD->getClassInterface();
  if (!ID)
    return;
  // Start searching for overridden methods using the method from the
  // interface as starting point.
  if (const ObjCMethodDecl *IFaceMeth = ID->getMethod(Method->getSelector(),
                                                   Method->isInstanceMethod(),
                                                   /*AllowHidden=*/true))
    Method = IFaceMeth;
  CollectOverriddenMethods(ID, Method, overridden);

} else {
  CollectOverriddenMethods(
                dyn_cast_or_null<ObjCContainerDecl>(Method->getDeclContext()),
                Method, overridden);
}
1323}

1325void ObjCMethodDecl::getOverriddenMethods(
                  SmallVectorImpl<const ObjCMethodDecl *> &Overridden) const {
const ObjCMethodDecl *Method = this;

if (Method->isRedeclaration()) {
  Method = cast<ObjCContainerDecl>(Method->getDeclContext())
               ->getMethod(Method->getSelector(), Method->isInstanceMethod(),
                           /*AllowHidden=*/true);
}

if (Method->isOverriding()) {
  collectOverriddenMethodsSlow(Method, Overridden);
  assert(!Overridden.empty() &&(static_cast <bool> (!Overridden.empty() && "ObjCMethodDecl's overriding bit is not as expected"
) ? void (0) : __assert_fail ("!Overridden.empty() && \"ObjCMethodDecl's overriding bit is not as expected\""
, "clang/lib/AST/DeclObjC.cpp", 1338, __extension__ __PRETTY_FUNCTION__
))
         "ObjCMethodDecl's overriding bit is not as expected")(static_cast <bool> (!Overridden.empty() && "ObjCMethodDecl's overriding bit is not as expected"
) ? void (0) : __assert_fail ("!Overridden.empty() && \"ObjCMethodDecl's overriding bit is not as expected\""
, "clang/lib/AST/DeclObjC.cpp", 1338, __extension__ __PRETTY_FUNCTION__
));
}
1340}

1342const ObjCPropertyDecl *
1343ObjCMethodDecl::findPropertyDecl(bool CheckOverrides) const {
Selector Sel = getSelector();
unsigned NumArgs = Sel.getNumArgs();
if (NumArgs > 1)
  return nullptr;

if (isPropertyAccessor()) {
  const auto *Container = cast<ObjCContainerDecl>(getParent());
  // For accessor stubs, go back to the interface.
  if (auto *ImplDecl = dyn_cast<ObjCImplDecl>(Container))
    if (isSynthesizedAccessorStub())
      Container = ImplDecl->getClassInterface();

  bool IsGetter = (NumArgs == 0);
  bool IsInstance = isInstanceMethod();

  /// Local function that attempts to find a matching property within the
  /// given Objective-C container.
  auto findMatchingProperty =
    [&](const ObjCContainerDecl *Container) -> const ObjCPropertyDecl * {
    if (IsInstance) {
      for (const auto *I : Container->instance_properties()) {
        Selector NextSel = IsGetter ? I->getGetterName()
                                    : I->getSetterName();
        if (NextSel == Sel)
          return I;
      }
    } else {
      for (const auto *I : Container->class_properties()) {
        Selector NextSel = IsGetter ? I->getGetterName()
                                    : I->getSetterName();
        if (NextSel == Sel)
          return I;
      }
    }

    return nullptr;
  };

  // Look in the container we were given.
  if (const auto *Found = findMatchingProperty(Container))
    return Found;

  // If we're in a category or extension, look in the main class.
  const ObjCInterfaceDecl *ClassDecl = nullptr;
  if (const auto *Category = dyn_cast<ObjCCategoryDecl>(Container)) {
    ClassDecl = Category->getClassInterface();
    if (const auto *Found = findMatchingProperty(ClassDecl))
      return Found;
  } else {
    // Determine whether the container is a class.
    ClassDecl = cast<ObjCInterfaceDecl>(Container);
  }
  assert(ClassDecl && "Failed to find main class")(static_cast <bool> (ClassDecl && "Failed to find main class"
) ? void (0) : __assert_fail ("ClassDecl && \"Failed to find main class\""
, "clang/lib/AST/DeclObjC.cpp", 1396, __extension__ __PRETTY_FUNCTION__
));

  // If we have a class, check its visible extensions.
  for (const auto *Ext : ClassDecl->visible_extensions()) {
    if (Ext == Container)
      continue;
    if (const auto *Found = findMatchingProperty(Ext))
      return Found;
  }

  assert(isSynthesizedAccessorStub() && "expected an accessor stub")(static_cast <bool> (isSynthesizedAccessorStub() &&
 "expected an accessor stub") ? void (0) : __assert_fail ("isSynthesizedAccessorStub() && \"expected an accessor stub\""
, "clang/lib/AST/DeclObjC.cpp", 1406, __extension__ __PRETTY_FUNCTION__
));

  for (const auto *Cat : ClassDecl->known_categories()) {
    if (Cat == Container)
      continue;
    if (const auto *Found = findMatchingProperty(Cat))
      return Found;
  }

  llvm_unreachable("Marked as a property accessor but no property found!")::llvm::llvm_unreachable_internal("Marked as a property accessor but no property found!"
, "clang/lib/AST/DeclObjC.cpp", 1415);
}

if (!CheckOverrides)
  return nullptr;

using OverridesTy = SmallVector<const ObjCMethodDecl *, 8>;

OverridesTy Overrides;
getOverriddenMethods(Overrides);
for (const auto *Override : Overrides)
  if (const ObjCPropertyDecl *Prop = Override->findPropertyDecl(false))
    return Prop;

return nullptr;
1430}

1432//===----------------------------------------------------------------------===//
1433// ObjCTypeParamDecl
1434//===----------------------------------------------------------------------===//

1436void ObjCTypeParamDecl::anchor() {}

1438ObjCTypeParamDecl *ObjCTypeParamDecl::Create(ASTContext &ctx, DeclContext *dc,
                                           ObjCTypeParamVariance variance,
                                           SourceLocation varianceLoc,
                                           unsigned index,
                                           SourceLocation nameLoc,
                                           IdentifierInfo *name,
                                           SourceLocation colonLoc,
                                           TypeSourceInfo *boundInfo) {
auto *TPDecl =
  new (ctx, dc) ObjCTypeParamDecl(ctx, dc, variance, varianceLoc, index,
                                  nameLoc, name, colonLoc, boundInfo);
QualType TPType = ctx.getObjCTypeParamType(TPDecl, {});
TPDecl->setTypeForDecl(TPType.getTypePtr());
return TPDecl;
1452}

1454ObjCTypeParamDecl *ObjCTypeParamDecl::CreateDeserialized(ASTContext &ctx,
                                                       unsigned ID) {
return new (ctx, ID) ObjCTypeParamDecl(ctx, nullptr,
                                       ObjCTypeParamVariance::Invariant,
                                       SourceLocation(), 0, SourceLocation(),
                                       nullptr, SourceLocation(), nullptr);
1460}

1462SourceRange ObjCTypeParamDecl::getSourceRange() const {
SourceLocation startLoc = VarianceLoc;
if (startLoc.isInvalid())
  startLoc = getLocation();

if (hasExplicitBound()) {
  return SourceRange(startLoc,
                     getTypeSourceInfo()->getTypeLoc().getEndLoc());
}

return SourceRange(startLoc);
1473}

1475//===----------------------------------------------------------------------===//
1476// ObjCTypeParamList
1477//===----------------------------------------------------------------------===//
1478ObjCTypeParamList::ObjCTypeParamList(SourceLocation lAngleLoc,
                                   ArrayRef<ObjCTypeParamDecl *> typeParams,
                                   SourceLocation rAngleLoc)
  : Brackets(lAngleLoc, rAngleLoc), NumParams(typeParams.size()) {
std::copy(typeParams.begin(), typeParams.end(), begin());
1483}

1485ObjCTypeParamList *ObjCTypeParamList::create(
                   ASTContext &ctx,
                   SourceLocation lAngleLoc,
                   ArrayRef<ObjCTypeParamDecl *> typeParams,
                   SourceLocation rAngleLoc) {
void *mem =
    ctx.Allocate(totalSizeToAlloc<ObjCTypeParamDecl *>(typeParams.size()),
                 alignof(ObjCTypeParamList));
return new (mem) ObjCTypeParamList(lAngleLoc, typeParams, rAngleLoc);
1494}

1496void ObjCTypeParamList::gatherDefaultTypeArgs(
     SmallVectorImpl<QualType> &typeArgs) const {
typeArgs.reserve(size());
for (auto typeParam : *this)
  typeArgs.push_back(typeParam->getUnderlyingType());
1501}

1503//===----------------------------------------------------------------------===//
1504// ObjCInterfaceDecl
1505//===----------------------------------------------------------------------===//

1507ObjCInterfaceDecl *ObjCInterfaceDecl::Create(const ASTContext &C,
                                           DeclContext *DC,
                                           SourceLocation atLoc,
                                           IdentifierInfo *Id,
                                           ObjCTypeParamList *typeParamList,
                                           ObjCInterfaceDecl *PrevDecl,
                                           SourceLocation ClassLoc,
                                           bool isInternal){
auto *Result = new (C, DC)
    ObjCInterfaceDecl(C, DC, atLoc, Id, typeParamList, ClassLoc, PrevDecl,
                      isInternal);
Result->Data.setInt(!C.getLangOpts().Modules);
C.getObjCInterfaceType(Result, PrevDecl);
return Result;
1521}

1523ObjCInterfaceDecl *ObjCInterfaceDecl::CreateDeserialized(const ASTContext &C,
                                                       unsigned ID) {
auto *Result = new (C, ID)
    ObjCInterfaceDecl(C, nullptr, SourceLocation(), nullptr, nullptr,
                      SourceLocation(), nullptr, false);
Result->Data.setInt(!C.getLangOpts().Modules);
return Result;
1530}

1532ObjCInterfaceDecl::ObjCInterfaceDecl(const ASTContext &C, DeclContext *DC,
                                   SourceLocation AtLoc, IdentifierInfo *Id,
                                   ObjCTypeParamList *typeParamList,
                                   SourceLocation CLoc,
                                   ObjCInterfaceDecl *PrevDecl,
                                   bool IsInternal)
  : ObjCContainerDecl(ObjCInterface, DC, Id, CLoc, AtLoc),
    redeclarable_base(C) {
setPreviousDecl(PrevDecl);

// Copy the 'data' pointer over.
if (PrevDecl)
  Data = PrevDecl->Data;

setImplicit(IsInternal);

setTypeParamList(typeParamList);
1549}

1551void ObjCInterfaceDecl::LoadExternalDefinition() const {
assert(data().ExternallyCompleted && "Class is not externally completed")(static_cast <bool> (data().ExternallyCompleted &&
 "Class is not externally completed") ? void (0) : __assert_fail
 ("data().ExternallyCompleted && \"Class is not externally completed\""
, "clang/lib/AST/DeclObjC.cpp", 1552, __extension__ __PRETTY_FUNCTION__
));
data().ExternallyCompleted = false;
getASTContext().getExternalSource()->CompleteType(
                                      const_cast<ObjCInterfaceDecl *>(this));
1556}

1558void ObjCInterfaceDecl::setExternallyCompleted() {
assert(getASTContext().getExternalSource() &&(static_cast <bool> (getASTContext().getExternalSource(
) && "Class can't be externally completed without an external source"
) ? void (0) : __assert_fail ("getASTContext().getExternalSource() && \"Class can't be externally completed without an external source\""
, "clang/lib/AST/DeclObjC.cpp", 1560, __extension__ __PRETTY_FUNCTION__
))
       "Class can't be externally completed without an external source")(static_cast <bool> (getASTContext().getExternalSource(
) && "Class can't be externally completed without an external source"
) ? void (0) : __assert_fail ("getASTContext().getExternalSource() && \"Class can't be externally completed without an external source\""
, "clang/lib/AST/DeclObjC.cpp", 1560, __extension__ __PRETTY_FUNCTION__
));
assert(hasDefinition() &&(static_cast <bool> (hasDefinition() && "Forward declarations can't be externally completed"
) ? void (0) : __assert_fail ("hasDefinition() && \"Forward declarations can't be externally completed\""
, "clang/lib/AST/DeclObjC.cpp", 1562, __extension__ __PRETTY_FUNCTION__
))
       "Forward declarations can't be externally completed")(static_cast <bool> (hasDefinition() && "Forward declarations can't be externally completed"
) ? void (0) : __assert_fail ("hasDefinition() && \"Forward declarations can't be externally completed\""
, "clang/lib/AST/DeclObjC.cpp", 1562, __extension__ __PRETTY_FUNCTION__
));
data().ExternallyCompleted = true;
1564}

1566void ObjCInterfaceDecl::setHasDesignatedInitializers() {
// Check for a complete definition and recover if not so.
if (!isThisDeclarationADefinition())
  return;
data().HasDesignatedInitializers = true;
1571}

1573bool ObjCInterfaceDecl::hasDesignatedInitializers() const {
// Check for a complete definition and recover if not so.
if (!isThisDeclarationADefinition())
  return false;
if (data().ExternallyCompleted)
  LoadExternalDefinition();

return data().HasDesignatedInitializers;
1581}

1583StringRef
1584ObjCInterfaceDecl::getObjCRuntimeNameAsString() const {
if (const auto *ObjCRTName = getAttr<ObjCRuntimeNameAttr>())
  return ObjCRTName->getMetadataName();

return getName();
1589}

1591StringRef
1592ObjCImplementationDecl::getObjCRuntimeNameAsString() const {
if (ObjCInterfaceDecl *ID =
    const_cast<ObjCImplementationDecl*>(this)->getClassInterface())
  return ID->getObjCRuntimeNameAsString();

return getName();
1598}

1600ObjCImplementationDecl *ObjCInterfaceDecl::getImplementation() const {
if (const ObjCInterfaceDecl *Def = getDefinition()) {
9
←
Calling 'ObjCInterfaceDecl::getDefinition'→
13
←
Returning from 'ObjCInterfaceDecl::getDefinition'→
14
←
Assuming 'Def' is non-null→
15
←
Taking true branch→
  if (data().ExternallyCompleted)
16
←
Assuming field 'ExternallyCompleted' is 0→
17
←
Taking false branch→
    LoadExternalDefinition();

  return getASTContext().getObjCImplementation(
18
←
Returning pointer, which participates in a condition later→
           const_cast<ObjCInterfaceDecl*>(Def));
}

// FIXME: Should make sure no callers ever do this.
return nullptr;
1611}

1613void ObjCInterfaceDecl::setImplementation(ObjCImplementationDecl *ImplD) {
getASTContext().setObjCImplementation(getDefinition(), ImplD);
1615}

1617namespace {

1619struct SynthesizeIvarChunk {
uint64_t Size;
ObjCIvarDecl *Ivar;

SynthesizeIvarChunk(uint64_t size, ObjCIvarDecl *ivar)
    : Size(size), Ivar(ivar) {}
1625};

1627bool operator<(const SynthesizeIvarChunk & LHS,
             const SynthesizeIvarChunk &RHS) {
  return LHS.Size < RHS.Size;
1630}

1632} // namespace

1634/// all_declared_ivar_begin - return first ivar declared in this class,
1635/// its extensions and its implementation. Lazily build the list on first
1636/// access.
1637///
1638/// Caveat: The list returned by this method reflects the current
1639/// state of the parser. The cache will be updated for every ivar
1640/// added by an extension or the implementation when they are
1641/// encountered.
1642/// See also ObjCIvarDecl::Create().
1643ObjCIvarDecl *ObjCInterfaceDecl::all_declared_ivar_begin() {
// FIXME: Should make sure no callers ever do this.
if (!hasDefinition())
1
Assuming the condition is false→
2
←
Taking false branch→
  return nullptr;

ObjCIvarDecl *curIvar = nullptr;
3
←
'curIvar' initialized to a null pointer value→
if (!data().IvarList) {
4
←
Assuming field 'IvarList' is non-null→
5
←
Taking false branch→
  if (!ivar_empty()) {
    ObjCInterfaceDecl::ivar_iterator I = ivar_begin(), E = ivar_end();
    data().IvarList = *I; ++I;
    for (curIvar = data().IvarList; I != E; curIvar = *I, ++I)
      curIvar->setNextIvar(*I);
  }

  for (const auto *Ext : known_extensions()) {
    if (!Ext->ivar_empty()) {
      ObjCCategoryDecl::ivar_iterator
        I = Ext->ivar_begin(),
        E = Ext->ivar_end();
      if (!data().IvarList) {
        data().IvarList = *I; ++I;
        curIvar = data().IvarList;
      }
      for ( ;I != E; curIvar = *I, ++I)
        curIvar->setNextIvar(*I);
    }
  }
  data().IvarListMissingImplementation = true;
}

// cached and complete!
if (!data().IvarListMissingImplementation)
6
←
Assuming field 'IvarListMissingImplementation' is not equal to 0→
7
←
Taking false branch→
    return data().IvarList;

if (ObjCImplementationDecl *ImplDecl = getImplementation()) {
8
←
Calling 'ObjCInterfaceDecl::getImplementation'→
19
←
Returning from 'ObjCInterfaceDecl::getImplementation'→
20
←
Assuming 'ImplDecl' is non-null→
21
←
Taking true branch→
  data().IvarListMissingImplementation = false;
  if (!ImplDecl->ivar_empty()) {
22
←
Taking true branch→
    SmallVector<SynthesizeIvarChunk, 16> layout;
    for (auto *IV : ImplDecl->ivars()) {
      if (IV->getSynthesize() && !IV->isInvalidDecl()) {
23
←
Assuming the condition is false→
        layout.push_back(SynthesizeIvarChunk(
                           IV->getASTContext().getTypeSize(IV->getType()), IV));
        continue;
      }
      if (!data().IvarList)
24
←
Assuming field 'IvarList' is non-null→
25
←
Taking false branch→
        data().IvarList = IV;
      else
        curIvar->setNextIvar(IV);
26
←
Called C++ object pointer is null
      curIvar = IV;
    }

    if (!layout.empty()) {
      // Order synthesized ivars by their size.
      llvm::stable_sort(layout);
      unsigned Ix = 0, EIx = layout.size();
      if (!data().IvarList) {
        data().IvarList = layout[0].Ivar; Ix++;
        curIvar = data().IvarList;
      }
      for ( ; Ix != EIx; curIvar = layout[Ix].Ivar, Ix++)
        curIvar->setNextIvar(layout[Ix].Ivar);
    }
  }
}
return data().IvarList;
1708}

1710/// FindCategoryDeclaration - Finds category declaration in the list of
1711/// categories for this class and returns it. Name of the category is passed
1712/// in 'CategoryId'. If category not found, return 0;
1713///
1714ObjCCategoryDecl *
1715ObjCInterfaceDecl::FindCategoryDeclaration(IdentifierInfo *CategoryId) const {
// FIXME: Should make sure no callers ever do this.
if (!hasDefinition())
  return nullptr;

if (data().ExternallyCompleted)
  LoadExternalDefinition();

for (auto *Cat : visible_categories())
  if (Cat->getIdentifier() == CategoryId)
    return Cat;

return nullptr;
1728}

1730ObjCMethodDecl *
1731ObjCInterfaceDecl::getCategoryInstanceMethod(Selector Sel) const {
for (const auto *Cat : visible_categories()) {
  if (ObjCCategoryImplDecl *Impl = Cat->getImplementation())
    if (ObjCMethodDecl *MD = Impl->getInstanceMethod(Sel))
      return MD;
}

return nullptr;
1739}

1741ObjCMethodDecl *ObjCInterfaceDecl::getCategoryClassMethod(Selector Sel) const {
for (const auto *Cat : visible_categories()) {
  if (ObjCCategoryImplDecl *Impl = Cat->getImplementation())
    if (ObjCMethodDecl *MD = Impl->getClassMethod(Sel))
      return MD;
}

return nullptr;
1749}

1751/// ClassImplementsProtocol - Checks that 'lProto' protocol
1752/// has been implemented in IDecl class, its super class or categories (if
1753/// lookupCategory is true).
1754bool ObjCInterfaceDecl::ClassImplementsProtocol(ObjCProtocolDecl *lProto,
                                  bool lookupCategory,
                                  bool RHSIsQualifiedID) {
if (!hasDefinition())
  return false;

ObjCInterfaceDecl *IDecl = this;
// 1st, look up the class.
for (auto *PI : IDecl->protocols()){
  if (getASTContext().ProtocolCompatibleWithProtocol(lProto, PI))
    return true;
  // This is dubious and is added to be compatible with gcc.  In gcc, it is
  // also allowed assigning a protocol-qualified 'id' type to a LHS object
  // when protocol in qualified LHS is in list of protocols in the rhs 'id'
  // object. This IMO, should be a bug.
  // FIXME: Treat this as an extension, and flag this as an error when GCC
  // extensions are not enabled.
  if (RHSIsQualifiedID &&
      getASTContext().ProtocolCompatibleWithProtocol(PI, lProto))
    return true;
}

// 2nd, look up the category.
if (lookupCategory)
  for (const auto *Cat : visible_categories()) {
    for (auto *PI : Cat->protocols())
      if (getASTContext().ProtocolCompatibleWithProtocol(lProto, PI))
        return true;
  }

// 3rd, look up the super class(s)
if (IDecl->getSuperClass())
  return
IDecl->getSuperClass()->ClassImplementsProtocol(lProto, lookupCategory,
                                                RHSIsQualifiedID);

return false;
1791}

1793//===----------------------------------------------------------------------===//
1794// ObjCIvarDecl
1795//===----------------------------------------------------------------------===//

1797void ObjCIvarDecl::anchor() {}

1799ObjCIvarDecl *ObjCIvarDecl::Create(ASTContext &C, ObjCContainerDecl *DC,
                                 SourceLocation StartLoc,
                                 SourceLocation IdLoc, IdentifierInfo *Id,
                                 QualType T, TypeSourceInfo *TInfo,
                                 AccessControl ac, Expr *BW,
                                 bool synthesized) {
if (DC) {
  // Ivar's can only appear in interfaces, implementations (via synthesized
  // properties), and class extensions (via direct declaration, or synthesized
  // properties).
  //
  // FIXME: This should really be asserting this:
  //   (isa<ObjCCategoryDecl>(DC) &&
  //    cast<ObjCCategoryDecl>(DC)->IsClassExtension()))
  // but unfortunately we sometimes place ivars into non-class extension
  // categories on error. This breaks an AST invariant, and should not be
  // fixed.
  assert((isa<ObjCInterfaceDecl>(DC) || isa<ObjCImplementationDecl>(DC) ||(static_cast <bool> ((isa<ObjCInterfaceDecl>(DC) ||
 isa<ObjCImplementationDecl>(DC) || isa<ObjCCategoryDecl
>(DC)) && "Invalid ivar decl context!") ? void (0)
 : __assert_fail ("(isa<ObjCInterfaceDecl>(DC) || isa<ObjCImplementationDecl>(DC) || isa<ObjCCategoryDecl>(DC)) && \"Invalid ivar decl context!\""
, "clang/lib/AST/DeclObjC.cpp", 1818, __extension__ __PRETTY_FUNCTION__
))
          isa<ObjCCategoryDecl>(DC)) &&(static_cast <bool> ((isa<ObjCInterfaceDecl>(DC) ||
 isa<ObjCImplementationDecl>(DC) || isa<ObjCCategoryDecl
>(DC)) && "Invalid ivar decl context!") ? void (0)
 : __assert_fail ("(isa<ObjCInterfaceDecl>(DC) || isa<ObjCImplementationDecl>(DC) || isa<ObjCCategoryDecl>(DC)) && \"Invalid ivar decl context!\""
, "clang/lib/AST/DeclObjC.cpp", 1818, __extension__ __PRETTY_FUNCTION__
))
         "Invalid ivar decl context!")(static_cast <bool> ((isa<ObjCInterfaceDecl>(DC) ||
 isa<ObjCImplementationDecl>(DC) || isa<ObjCCategoryDecl
>(DC)) && "Invalid ivar decl context!") ? void (0)
 : __assert_fail ("(isa<ObjCInterfaceDecl>(DC) || isa<ObjCImplementationDecl>(DC) || isa<ObjCCategoryDecl>(DC)) && \"Invalid ivar decl context!\""
, "clang/lib/AST/DeclObjC.cpp", 1818, __extension__ __PRETTY_FUNCTION__
));
  // Once a new ivar is created in any of class/class-extension/implementation
  // decl contexts, the previously built IvarList must be rebuilt.
  auto *ID = dyn_cast<ObjCInterfaceDecl>(DC);
  if (!ID) {
    if (auto *IM = dyn_cast<ObjCImplementationDecl>(DC))
      ID = IM->getClassInterface();
    else
      ID = cast<ObjCCategoryDecl>(DC)->getClassInterface();
  }
  ID->setIvarList(nullptr);
}

return new (C, DC) ObjCIvarDecl(DC, StartLoc, IdLoc, Id, T, TInfo, ac, BW,
                                synthesized);
1833}

1835ObjCIvarDecl *ObjCIvarDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
return new (C, ID) ObjCIvarDecl(nullptr, SourceLocation(), SourceLocation(),
                                nullptr, QualType(), nullptr,
                                ObjCIvarDecl::None, nullptr, false);
1839}

1841const ObjCInterfaceDecl *ObjCIvarDecl::getContainingInterface() const {
const auto *DC = cast<ObjCContainerDecl>(getDeclContext());

switch (DC->getKind()) {
default:
case ObjCCategoryImpl:
case ObjCProtocol:
  llvm_unreachable("invalid ivar container!")::llvm::llvm_unreachable_internal("invalid ivar container!", "clang/lib/AST/DeclObjC.cpp"
, 1848);

  // Ivars can only appear in class extension categories.
case ObjCCategory: {
  const auto *CD = cast<ObjCCategoryDecl>(DC);
  assert(CD->IsClassExtension() && "invalid container for ivar!")(static_cast <bool> (CD->IsClassExtension() &&
 "invalid container for ivar!") ? void (0) : __assert_fail ("CD->IsClassExtension() && \"invalid container for ivar!\""
, "clang/lib/AST/DeclObjC.cpp", 1853, __extension__ __PRETTY_FUNCTION__
));
  return CD->getClassInterface();
}

case ObjCImplementation:
  return cast<ObjCImplementationDecl>(DC)->getClassInterface();

case ObjCInterface:
  return cast<ObjCInterfaceDecl>(DC);
}
1863}

1865QualType ObjCIvarDecl::getUsageType(QualType objectType) const {
return getType().substObjCMemberType(objectType, getDeclContext(),
                                     ObjCSubstitutionContext::Property);
1868}

1870//===----------------------------------------------------------------------===//
1871// ObjCAtDefsFieldDecl
1872//===----------------------------------------------------------------------===//

1874void ObjCAtDefsFieldDecl::anchor() {}

1876ObjCAtDefsFieldDecl
1877*ObjCAtDefsFieldDecl::Create(ASTContext &C, DeclContext *DC,
                           SourceLocation StartLoc,  SourceLocation IdLoc,
                           IdentifierInfo *Id, QualType T, Expr *BW) {
return new (C, DC) ObjCAtDefsFieldDecl(DC, StartLoc, IdLoc, Id, T, BW);
1881}

1883ObjCAtDefsFieldDecl *ObjCAtDefsFieldDecl::CreateDeserialized(ASTContext &C,
                                                           unsigned ID) {
return new (C, ID) ObjCAtDefsFieldDecl(nullptr, SourceLocation(),
                                       SourceLocation(), nullptr, QualType(),
                                       nullptr);
1888}

1890//===----------------------------------------------------------------------===//
1891// ObjCProtocolDecl
1892//===----------------------------------------------------------------------===//

1894void ObjCProtocolDecl::anchor() {}

1896ObjCProtocolDecl::ObjCProtocolDecl(ASTContext &C, DeclContext *DC,
                                 IdentifierInfo *Id, SourceLocation nameLoc,
                                 SourceLocation atStartLoc,
                                 ObjCProtocolDecl *PrevDecl)
  : ObjCContainerDecl(ObjCProtocol, DC, Id, nameLoc, atStartLoc),
    redeclarable_base(C) {
setPreviousDecl(PrevDecl);
if (PrevDecl)
  Data = PrevDecl->Data;
1905}

1907ObjCProtocolDecl *ObjCProtocolDecl::Create(ASTContext &C, DeclContext *DC,
                                         IdentifierInfo *Id,
                                         SourceLocation nameLoc,
                                         SourceLocation atStartLoc,
                                         ObjCProtocolDecl *PrevDecl) {
auto *Result =
    new (C, DC) ObjCProtocolDecl(C, DC, Id, nameLoc, atStartLoc, PrevDecl);
Result->Data.setInt(!C.getLangOpts().Modules);
return Result;
1916}

1918ObjCProtocolDecl *ObjCProtocolDecl::CreateDeserialized(ASTContext &C,
                                                     unsigned ID) {
ObjCProtocolDecl *Result =
    new (C, ID) ObjCProtocolDecl(C, nullptr, nullptr, SourceLocation(),
                                 SourceLocation(), nullptr);
Result->Data.setInt(!C.getLangOpts().Modules);
return Result;
1925}

1927bool ObjCProtocolDecl::isNonRuntimeProtocol() const {
return hasAttr<ObjCNonRuntimeProtocolAttr>();
1929}

1931void ObjCProtocolDecl::getImpliedProtocols(
  llvm::DenseSet<const ObjCProtocolDecl *> &IPs) const {
std::queue<const ObjCProtocolDecl *> WorkQueue;
WorkQueue.push(this);

while (!WorkQueue.empty()) {
  const auto *PD = WorkQueue.front();
  WorkQueue.pop();
  for (const auto *Parent : PD->protocols()) {
    const auto *Can = Parent->getCanonicalDecl();
    auto Result = IPs.insert(Can);
    if (Result.second)
      WorkQueue.push(Parent);
  }
}
1946}

1948ObjCProtocolDecl *ObjCProtocolDecl::lookupProtocolNamed(IdentifierInfo *Name) {
ObjCProtocolDecl *PDecl = this;

if (Name == getIdentifier())
  return PDecl;

for (auto *I : protocols())
  if ((PDecl = I->lookupProtocolNamed(Name)))
    return PDecl;

return nullptr;
1959}

1961// lookupMethod - Lookup a instance/class method in the protocol and protocols
1962// it inherited.
1963ObjCMethodDecl *ObjCProtocolDecl::lookupMethod(Selector Sel,
                                             bool isInstance) const {
ObjCMethodDecl *MethodDecl = nullptr;

// If there is no definition or the definition is hidden, we don't find
// anything.
const ObjCProtocolDecl *Def = getDefinition();
if (!Def || !Def->isUnconditionallyVisible())
  return nullptr;

if ((MethodDecl = getMethod(Sel, isInstance)))
  return MethodDecl;

for (const auto *I : protocols())
  if ((MethodDecl = I->lookupMethod(Sel, isInstance)))
    return MethodDecl;
return nullptr;
1980}

1982void ObjCProtocolDecl::allocateDefinitionData() {
assert(!Data.getPointer() && "Protocol already has a definition!")(static_cast <bool> (!Data.getPointer() && "Protocol already has a definition!"
) ? void (0) : __assert_fail ("!Data.getPointer() && \"Protocol already has a definition!\""
, "clang/lib/AST/DeclObjC.cpp", 1983, __extension__ __PRETTY_FUNCTION__
));
Data.setPointer(new (getASTContext()) DefinitionData);
Data.getPointer()->Definition = this;
1986}

1988void ObjCProtocolDecl::startDefinition() {
allocateDefinitionData();

// Update all of the declarations with a pointer to the definition.
for (auto *RD : redecls())
  RD->Data = this->Data;
1994}

1996void ObjCProtocolDecl::collectPropertiesToImplement(PropertyMap &PM,
                                                  PropertyDeclOrder &PO) const {
if (const ObjCProtocolDecl *PDecl = getDefinition()) {
  for (auto *Prop : PDecl->properties()) {
    // Insert into PM if not there already.
    PM.insert(std::make_pair(
        std::make_pair(Prop->getIdentifier(), Prop->isClassProperty()),
        Prop));
    PO.push_back(Prop);
  }
  // Scan through protocol's protocols.
  for (const auto *PI : PDecl->protocols())
    PI->collectPropertiesToImplement(PM, PO);
}
2010}

2012void ObjCProtocolDecl::collectInheritedProtocolProperties(
  const ObjCPropertyDecl *Property, ProtocolPropertySet &PS,
  PropertyDeclOrder &PO) const {
if (const ObjCProtocolDecl *PDecl = getDefinition()) {
  if (!PS.insert(PDecl).second)
    return;
  for (auto *Prop : PDecl->properties()) {
    if (Prop == Property)
      continue;
    if (Prop->getIdentifier() == Property->getIdentifier()) {
      PO.push_back(Prop);
      return;
    }
  }
  // Scan through protocol's protocols which did not have a matching property.
  for (const auto *PI : PDecl->protocols())
    PI->collectInheritedProtocolProperties(Property, PS, PO);
}
2030}

2032StringRef
2033ObjCProtocolDecl::getObjCRuntimeNameAsString() const {
if (const auto *ObjCRTName = getAttr<ObjCRuntimeNameAttr>())
  return ObjCRTName->getMetadataName();

return getName();
2038}

2040//===----------------------------------------------------------------------===//
2041// ObjCCategoryDecl
2042//===----------------------------------------------------------------------===//

2044void ObjCCategoryDecl::anchor() {}

2046ObjCCategoryDecl::ObjCCategoryDecl(DeclContext *DC, SourceLocation AtLoc,
                                 SourceLocation ClassNameLoc,
                                 SourceLocation CategoryNameLoc,
                                 IdentifierInfo *Id, ObjCInterfaceDecl *IDecl,
                                 ObjCTypeParamList *typeParamList,
                                 SourceLocation IvarLBraceLoc,
                                 SourceLocation IvarRBraceLoc)
  : ObjCContainerDecl(ObjCCategory, DC, Id, ClassNameLoc, AtLoc),
    ClassInterface(IDecl), CategoryNameLoc(CategoryNameLoc),
    IvarLBraceLoc(IvarLBraceLoc), IvarRBraceLoc(IvarRBraceLoc) {
setTypeParamList(typeParamList);
2057}

2059ObjCCategoryDecl *ObjCCategoryDecl::Create(ASTContext &C, DeclContext *DC,
                                         SourceLocation AtLoc,
                                         SourceLocation ClassNameLoc,
                                         SourceLocation CategoryNameLoc,
                                         IdentifierInfo *Id,
                                         ObjCInterfaceDecl *IDecl,
                                         ObjCTypeParamList *typeParamList,
                                         SourceLocation IvarLBraceLoc,
                                         SourceLocation IvarRBraceLoc) {
auto *CatDecl =
    new (C, DC) ObjCCategoryDecl(DC, AtLoc, ClassNameLoc, CategoryNameLoc, Id,
                                 IDecl, typeParamList, IvarLBraceLoc,
                                 IvarRBraceLoc);
if (IDecl) {
  // Link this category into its class's category list.
  CatDecl->NextClassCategory = IDecl->getCategoryListRaw();
  if (IDecl->hasDefinition()) {
    IDecl->setCategoryListRaw(CatDecl);
    if (ASTMutationListener *L = C.getASTMutationListener())
      L->AddedObjCCategoryToInterface(CatDecl, IDecl);
  }
}

return CatDecl;
2083}

2085ObjCCategoryDecl *ObjCCategoryDecl::CreateDeserialized(ASTContext &C,
                                                     unsigned ID) {
return new (C, ID) ObjCCategoryDecl(nullptr, SourceLocation(),
                                    SourceLocation(), SourceLocation(),
                                    nullptr, nullptr, nullptr);
2090}

2092ObjCCategoryImplDecl *ObjCCategoryDecl::getImplementation() const {
return getASTContext().getObjCImplementation(
                                         const_cast<ObjCCategoryDecl*>(this));
2095}

2097void ObjCCategoryDecl::setImplementation(ObjCCategoryImplDecl *ImplD) {
getASTContext().setObjCImplementation(this, ImplD);
2099}

2101void ObjCCategoryDecl::setTypeParamList(ObjCTypeParamList *TPL) {
TypeParamList = TPL;
if (!TPL)
  return;
// Set the declaration context of each of the type parameters.
for (auto *typeParam : *TypeParamList)
  typeParam->setDeclContext(this);
2108}

2110//===----------------------------------------------------------------------===//
2111// ObjCCategoryImplDecl
2112//===----------------------------------------------------------------------===//

2114void ObjCCategoryImplDecl::anchor() {}

2116ObjCCategoryImplDecl *
2117ObjCCategoryImplDecl::Create(ASTContext &C, DeclContext *DC,
                           IdentifierInfo *Id,
                           ObjCInterfaceDecl *ClassInterface,
                           SourceLocation nameLoc,
                           SourceLocation atStartLoc,
                           SourceLocation CategoryNameLoc) {
if (ClassInterface && ClassInterface->hasDefinition())
  ClassInterface = ClassInterface->getDefinition();
return new (C, DC) ObjCCategoryImplDecl(DC, Id, ClassInterface, nameLoc,
                                        atStartLoc, CategoryNameLoc);
2127}

2129ObjCCategoryImplDecl *ObjCCategoryImplDecl::CreateDeserialized(ASTContext &C,
                                                             unsigned ID) {
return new (C, ID) ObjCCategoryImplDecl(nullptr, nullptr, nullptr,
                                        SourceLocation(), SourceLocation(),
                                        SourceLocation());
2134}

2136ObjCCategoryDecl *ObjCCategoryImplDecl::getCategoryDecl() const {
// The class interface might be NULL if we are working with invalid code.
if (const ObjCInterfaceDecl *ID = getClassInterface())
  return ID->FindCategoryDeclaration(getIdentifier());
return nullptr;
2141}

2143void ObjCImplDecl::anchor() {}

2145void ObjCImplDecl::addPropertyImplementation(ObjCPropertyImplDecl *property) {
// FIXME: The context should be correct before we get here.
property->setLexicalDeclContext(this);
addDecl(property);
2149}

2151void ObjCImplDecl::setClassInterface(ObjCInterfaceDecl *IFace) {
ASTContext &Ctx = getASTContext();

if (auto *ImplD = dyn_cast_or_null<ObjCImplementationDecl>(this)) {
  if (IFace)
    Ctx.setObjCImplementation(IFace, ImplD);

} else if (auto *ImplD = dyn_cast_or_null<ObjCCategoryImplDecl>(this)) {
  if (ObjCCategoryDecl *CD = IFace->FindCategoryDeclaration(getIdentifier()))
    Ctx.setObjCImplementation(CD, ImplD);
}

ClassInterface = IFace;
2164}

2166/// FindPropertyImplIvarDecl - This method lookup the ivar in the list of
2167/// properties implemented in this \@implementation block and returns
2168/// the implemented property that uses it.
2169ObjCPropertyImplDecl *ObjCImplDecl::
2170FindPropertyImplIvarDecl(IdentifierInfo *ivarId) const {
for (auto *PID : property_impls())
  if (PID->getPropertyIvarDecl() &&
      PID->getPropertyIvarDecl()->getIdentifier() == ivarId)
    return PID;
return nullptr;
2176}

2178/// FindPropertyImplDecl - This method looks up a previous ObjCPropertyImplDecl
2179/// added to the list of those properties \@synthesized/\@dynamic in this
2180/// category \@implementation block.
2181ObjCPropertyImplDecl *ObjCImplDecl::
2182FindPropertyImplDecl(IdentifierInfo *Id,
                   ObjCPropertyQueryKind QueryKind) const {
ObjCPropertyImplDecl *ClassPropImpl = nullptr;
for (auto *PID : property_impls())
  // If queryKind is unknown, we return the instance property if one
  // exists; otherwise we return the class property.
  if (PID->getPropertyDecl()->getIdentifier() == Id) {
    if ((QueryKind == ObjCPropertyQueryKind::OBJC_PR_query_unknown &&
         !PID->getPropertyDecl()->isClassProperty()) ||
        (QueryKind == ObjCPropertyQueryKind::OBJC_PR_query_class &&
         PID->getPropertyDecl()->isClassProperty()) ||
        (QueryKind == ObjCPropertyQueryKind::OBJC_PR_query_instance &&
         !PID->getPropertyDecl()->isClassProperty()))
      return PID;

    if (PID->getPropertyDecl()->isClassProperty())
      ClassPropImpl = PID;
  }

if (QueryKind == ObjCPropertyQueryKind::OBJC_PR_query_unknown)
  // We can't find the instance property, return the class property.
  return ClassPropImpl;

return nullptr;
2206}

2208raw_ostream &clang::operator<<(raw_ostream &OS,
                             const ObjCCategoryImplDecl &CID) {
OS << CID.getName();
return OS;
2212}

2214//===----------------------------------------------------------------------===//
2215// ObjCImplementationDecl
2216//===----------------------------------------------------------------------===//

2218void ObjCImplementationDecl::anchor() {}

2220ObjCImplementationDecl *
2221ObjCImplementationDecl::Create(ASTContext &C, DeclContext *DC,
                             ObjCInterfaceDecl *ClassInterface,
                             ObjCInterfaceDecl *SuperDecl,
                             SourceLocation nameLoc,
                             SourceLocation atStartLoc,
                             SourceLocation superLoc,
                             SourceLocation IvarLBraceLoc,
                             SourceLocation IvarRBraceLoc) {
if (ClassInterface && ClassInterface->hasDefinition())
  ClassInterface = ClassInterface->getDefinition();
return new (C, DC) ObjCImplementationDecl(DC, ClassInterface, SuperDecl,
                                          nameLoc, atStartLoc, superLoc,
                                          IvarLBraceLoc, IvarRBraceLoc);
2234}

2236ObjCImplementationDecl *
2237ObjCImplementationDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
return new (C, ID) ObjCImplementationDecl(nullptr, nullptr, nullptr,
                                          SourceLocation(), SourceLocation());
2240}

2242void ObjCImplementationDecl::setIvarInitializers(ASTContext &C,
                                           CXXCtorInitializer ** initializers,
                                               unsigned numInitializers) {
if (numInitializers > 0) {
  NumIvarInitializers = numInitializers;
  auto **ivarInitializers = new (C) CXXCtorInitializer*[NumIvarInitializers];
  memcpy(ivarInitializers, initializers,
         numInitializers * sizeof(CXXCtorInitializer*));
  IvarInitializers = ivarInitializers;
}
2252}

2254ObjCImplementationDecl::init_const_iterator
2255ObjCImplementationDecl::init_begin() const {
return IvarInitializers.get(getASTContext().getExternalSource());
2257}

2259raw_ostream &clang::operator<<(raw_ostream &OS,
                             const ObjCImplementationDecl &ID) {
OS << ID.getName();
return OS;
2263}

2265//===----------------------------------------------------------------------===//
2266// ObjCCompatibleAliasDecl
2267//===----------------------------------------------------------------------===//

2269void ObjCCompatibleAliasDecl::anchor() {}

2271ObjCCompatibleAliasDecl *
2272ObjCCompatibleAliasDecl::Create(ASTContext &C, DeclContext *DC,
                              SourceLocation L,
                              IdentifierInfo *Id,
                              ObjCInterfaceDecl* AliasedClass) {
return new (C, DC) ObjCCompatibleAliasDecl(DC, L, Id, AliasedClass);
2277}

2279ObjCCompatibleAliasDecl *
2280ObjCCompatibleAliasDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
return new (C, ID) ObjCCompatibleAliasDecl(nullptr, SourceLocation(),
                                           nullptr, nullptr);
2283}

2285//===----------------------------------------------------------------------===//
2286// ObjCPropertyDecl
2287//===----------------------------------------------------------------------===//

2289void ObjCPropertyDecl::anchor() {}

2291ObjCPropertyDecl *ObjCPropertyDecl::Create(ASTContext &C, DeclContext *DC,
                                         SourceLocation L,
                                         IdentifierInfo *Id,
                                         SourceLocation AtLoc,
                                         SourceLocation LParenLoc,
                                         QualType T,
                                         TypeSourceInfo *TSI,
                                         PropertyControl propControl) {
return new (C, DC) ObjCPropertyDecl(DC, L, Id, AtLoc, LParenLoc, T, TSI,
                                    propControl);
2301}

2303ObjCPropertyDecl *ObjCPropertyDecl::CreateDeserialized(ASTContext &C,
                                                     unsigned ID) {
return new (C, ID) ObjCPropertyDecl(nullptr, SourceLocation(), nullptr,
                                    SourceLocation(), SourceLocation(),
                                    QualType(), nullptr, None);
2308}

2310QualType ObjCPropertyDecl::getUsageType(QualType objectType) const {
return DeclType.substObjCMemberType(objectType, getDeclContext(),
                                    ObjCSubstitutionContext::Property);
2313}

2315bool ObjCPropertyDecl::isDirectProperty() const {
return (PropertyAttributes & ObjCPropertyAttribute::kind_direct) &&
       !getASTContext().getLangOpts().ObjCDisableDirectMethodsForTesting;
2318}

2320//===----------------------------------------------------------------------===//
2321// ObjCPropertyImplDecl
2322//===----------------------------------------------------------------------===//

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

2336ObjCPropertyImplDecl *ObjCPropertyImplDecl::CreateDeserialized(ASTContext &C,
                                                             unsigned ID) {
return new (C, ID) ObjCPropertyImplDecl(nullptr, SourceLocation(),
                                        SourceLocation(), nullptr, Dynamic,
                                        nullptr, SourceLocation());
2341}

2343SourceRange ObjCPropertyImplDecl::getSourceRange() const {
SourceLocation EndLoc = getLocation();
if (IvarLoc.isValid())
  EndLoc = IvarLoc;

return SourceRange(AtLoc, EndLoc);
2349}

←

/build/llvm-toolchain-snapshot-15~++20220420111733+e13d2efed663/clang/include/clang/AST/DeclObjC.h

1//===- DeclObjC.h - Classes for representing declarations -------*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9//  This file defines the DeclObjC interface and subclasses.
10//
11//===----------------------------------------------------------------------===//

13#ifndef LLVM_CLANG_AST_DECLOBJC_H
14#define LLVM_CLANG_AST_DECLOBJC_H

16#include "clang/AST/Decl.h"
17#include "clang/AST/DeclBase.h"
18#include "clang/AST/DeclObjCCommon.h"
19#include "clang/AST/ExternalASTSource.h"
20#include "clang/AST/Redeclarable.h"
21#include "clang/AST/SelectorLocationsKind.h"
22#include "clang/AST/Type.h"
23#include "clang/Basic/IdentifierTable.h"
24#include "clang/Basic/LLVM.h"
25#include "clang/Basic/SourceLocation.h"
26#include "clang/Basic/Specifiers.h"
27#include "llvm/ADT/ArrayRef.h"
28#include "llvm/ADT/DenseMap.h"
29#include "llvm/ADT/DenseSet.h"
30#include "llvm/ADT/None.h"
31#include "llvm/ADT/PointerIntPair.h"
32#include "llvm/ADT/STLExtras.h"
33#include "llvm/ADT/StringRef.h"
34#include "llvm/ADT/iterator_range.h"
35#include "llvm/Support/Compiler.h"
36#include "llvm/Support/TrailingObjects.h"
37#include <cassert>
38#include <cstddef>
39#include <cstdint>
40#include <iterator>
41#include <string>
42#include <utility>

44namespace clang {

46class ASTContext;
47class CompoundStmt;
48class CXXCtorInitializer;
49class Expr;
50class ObjCCategoryDecl;
51class ObjCCategoryImplDecl;
52class ObjCImplementationDecl;
53class ObjCInterfaceDecl;
54class ObjCIvarDecl;
55class ObjCPropertyDecl;
56class ObjCPropertyImplDecl;
57class ObjCProtocolDecl;
58class Stmt;

60class ObjCListBase {
61protected:
/// List is an array of pointers to objects that are not owned by this object.
void **List = nullptr;
unsigned NumElts = 0;

66public:
ObjCListBase() = default;
ObjCListBase(const ObjCListBase &) = delete;
ObjCListBase &operator=(const ObjCListBase &) = delete;

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

74protected:
void set(void *const* InList, unsigned Elts, ASTContext &Ctx);
76};

78/// ObjCList - This is a simple template class used to hold various lists of
79/// decls etc, which is heavily used by the ObjC front-end.  This only use case
80/// this supports is setting the list all at once and then reading elements out
81/// of it.
82template <typename T>
83class ObjCList : public ObjCListBase {
84public:
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")(static_cast <bool> (Idx < NumElts && "Invalid access"
) ? void (0) : __assert_fail ("Idx < NumElts && \"Invalid access\""
, "clang/include/clang/AST/DeclObjC.h", 95, __extension__ __PRETTY_FUNCTION__
));
  return (T*)List[Idx];
}
98};

100/// A list of Objective-C protocols, along with the source
101/// locations at which they were referenced.
102class ObjCProtocolList : public ObjCList<ObjCProtocolDecl> {
SourceLocation *Locations = nullptr;

using ObjCList<ObjCProtocolDecl>::set;

107public:
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);
117};

119/// ObjCMethodDecl - Represents an instance or class method declaration.
120/// ObjC methods can be declared within 4 contexts: class interfaces,
121/// categories, protocols, and class implementations. While C++ member
122/// functions leverage C syntax, Objective-C method syntax is modeled after
123/// Smalltalk (using colons to specify argument types/expressions).
124/// Here are some brief examples:
125///
126/// Setter/getter instance methods:
127/// - (void)setMenu:(NSMenu *)menu;
128/// - (NSMenu *)menu;
129///
130/// Instance method that takes 2 NSView arguments:
131/// - (void)replaceSubview:(NSView *)oldView with:(NSView *)newView;
132///
133/// Getter class method:
134/// + (NSMenu *)defaultMenu;
135///
136/// A selector represents a unique name for a method. The selector names for
137/// the above methods are setMenu:, menu, replaceSubview:with:, and defaultMenu.
138///
139class ObjCMethodDecl : public NamedDecl, public DeclContext {
// This class stores some data in DeclContext::ObjCMethodDeclBits
// to save some space. Use the provided accessors to access it.

143public:
enum ImplementationControl { None, Required, Optional };

146private:
/// 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;

228public:
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__attribute__((__pure__)) { return getLocation(); }
SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__));
SourceRange getSourceRange() const override LLVM_READONLY__attribute__((__pure__)) {
  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!")(static_cast <bool> (Index < getNumSelectorLocs() &&
 "Index out of range!") ? void (0) : __assert_fail ("Index < getNumSelectorLocs() && \"Index out of range!\""
, "clang/include/clang/AST/DeclObjC.h", 298, __extension__ __PRETTY_FUNCTION__
));
  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::makeArrayRef(const_cast<ParmVarDecl**>(getParams()),
                            NumParams);
}

ParmVarDecl *getParamDecl(unsigned Idx) {
  assert(Idx < NumParams && "Index out of bounds!")(static_cast <bool> (Idx < NumParams && "Index out of bounds!"
) ? void (0) : __assert_fail ("Idx < NumParams && \"Index out of bounds!\""
, "clang/include/clang/AST/DeclObjC.h", 382, __extension__ __PRETTY_FUNCTION__
));
  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 = llvm::None);

// 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));
}
554};

556/// Describes the variance of a given generic parameter.
557enum 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,
568};

570/// Represents the declaration of an Objective-C type parameter.
571///
572/// \code
573/// @interface NSDictionary<Key : id<NSCopying>, Value>
574/// @end
575/// \endcode
576///
577/// In the example above, both \c Key and \c Value are represented by
578/// \c ObjCTypeParamDecl. \c Key has an explicit bound of \c id<NSCopying>,
579/// while \c Value gets an implicit bound of \c id.
580///
581/// Objective-C type parameters are typedef-names in the grammar,
582class 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;

608public:
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__attribute__((__pure__));

/// 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; }
651};

653/// Stores a list of Objective-C type parameters for a parameterized class
654/// or a category/extension thereof.
655///
656/// \code
657/// @interface NSArray<T> // stores the <T>
658/// @end
659/// \endcode
660class 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);

671public:
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")(static_cast <bool> (size() > 0 && "empty Objective-C type parameter list"
) ? void (0) : __assert_fail ("size() > 0 && \"empty Objective-C type parameter list\""
, "clang/include/clang/AST/DeclObjC.h", 702, __extension__ __PRETTY_FUNCTION__
));
  return *begin();
}

ObjCTypeParamDecl *back() const {
  assert(size() > 0 && "empty Objective-C type parameter list")(static_cast <bool> (size() > 0 && "empty Objective-C type parameter list"
) ? void (0) : __assert_fail ("size() > 0 && \"empty Objective-C type parameter list\""
, "clang/include/clang/AST/DeclObjC.h", 707, __extension__ __PRETTY_FUNCTION__
));
  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;
718};

720enum class ObjCPropertyQueryKind : uint8_t {
OBJC_PR_query_unknown = 0x00,
OBJC_PR_query_instance,
OBJC_PR_query_class
724};

726/// Represents one property declaration in an Objective-C interface.
727///
728/// For example:
729/// \code{.mm}
730/// \@property (assign, readwrite) int MyProperty;
731/// \endcode
732class ObjCPropertyDecl : public NamedDecl {
void anchor() override;

735public:
enum SetterKind { Assign, Retain, Copy, Weak };
enum PropertyControl { None, Required, Optional };

739private:
// 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) {}

784public:
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;
}

void overwritePropertyAttributes(unsigned PRVal) {
  PropertyAttributes = PRVal;
}

ObjCPropertyAttribute::Kind getPropertyAttributesAsWritten() const {
  return ObjCPropertyAttribute::Kind(PropertyAttributesAsWritten);
}

void setPropertyAttributesAsWritten(ObjCPropertyAttribute::Kind PRVal) {
  PropertyAttributesAsWritten = PRVal;
}

// Helper methods for accessing attributes.

/// isReadOnly - Return true iff the property has a setter.
bool isReadOnly() const {
  return (PropertyAttributes & ObjCPropertyAttribute::kind_readonly);
}

/// isAtomic - Return true if the property is atomic.
bool isAtomic() const {
  return (PropertyAttributes & ObjCPropertyAttribute::kind_atomic);
}

/// isRetaining - Return true if the property retains its value.
bool isRetaining() const {
  return (PropertyAttributes & (ObjCPropertyAttribute::kind_retain |
                                ObjCPropertyAttribute::kind_strong |
                                ObjCPropertyAttribute::kind_copy));
}

bool isInstanceProperty() const { return !isClassProperty(); }
bool isClassProperty() const {
  return PropertyAttributes & ObjCPropertyAttribute::kind_class;
}
bool isDirectProperty() const;

ObjCPropertyQueryKind getQueryKind() const {
  return isClassProperty() ? ObjCPropertyQueryKind::OBJC_PR_query_class :
                             ObjCPropertyQueryKind::OBJC_PR_query_instance;
}

static ObjCPropertyQueryKind getQueryKind(bool isClassProperty) {
  return isClassProperty ? ObjCPropertyQueryKind::OBJC_PR_query_class :
                           ObjCPropertyQueryKind::OBJC_PR_query_instance;
}

/// getSetterKind - Return the method used for doing assignment in
/// the property setter. This is only valid if the property has been
/// defined to have a setter.
SetterKind getSetterKind() const {
  if (PropertyAttributes & ObjCPropertyAttribute::kind_strong)
    return getType()->isBlockPointerType() ? Copy : Retain;
  if (PropertyAttributes & ObjCPropertyAttribute::kind_retain)
    return Retain;
  if (PropertyAttributes & ObjCPropertyAttribute::kind_copy)
    return Copy;
  if (PropertyAttributes & ObjCPropertyAttribute::kind_weak)
    return Weak;
  return Assign;
}

Selector getGetterName() const { return GetterName; }
SourceLocation getGetterNameLoc() const { return GetterNameLoc; }

void setGetterName(Selector Sel, SourceLocation Loc = SourceLocation()) {
  GetterName = Sel;
  GetterNameLoc = Loc;
}

Selector getSetterName() const { return SetterName; }
SourceLocation getSetterNameLoc() const { return SetterNameLoc; }

void setSetterName(Selector Sel, SourceLocation Loc = SourceLocation()) {
  SetterName = Sel;
  SetterNameLoc = Loc;
}

ObjCMethodDecl *getGetterMethodDecl() const { return GetterMethodDecl; }
void setGetterMethodDecl(ObjCMethodDecl *gDecl) { GetterMethodDecl = gDecl; }

ObjCMethodDecl *getSetterMethodDecl() const { return SetterMethodDecl; }
void setSetterMethodDecl(ObjCMethodDecl *gDecl) { SetterMethodDecl = gDecl; }

// Related to \@optional/\@required declared in \@protocol
void setPropertyImplementation(PropertyControl pc) {
  PropertyImplementation = pc;
}

PropertyControl getPropertyImplementation() const {
  return PropertyControl(PropertyImplementation);
}

bool isOptional() const {
  return getPropertyImplementation() == PropertyControl::Optional;
}

void setPropertyIvarDecl(ObjCIvarDecl *Ivar) {
  PropertyIvarDecl = Ivar;
}

ObjCIvarDecl *getPropertyIvarDecl() const {
  return PropertyIvarDecl;
}

SourceRange getSourceRange() const override LLVM_READONLY__attribute__((__pure__)) {
  return SourceRange(AtLoc, getLocation());
}

/// Get the default name of the synthesized ivar.
IdentifierInfo *getDefaultSynthIvarName(ASTContext &Ctx) const;

/// Lookup a property by name in the specified DeclContext.
static ObjCPropertyDecl *findPropertyDecl(const DeclContext *DC,
                                          const IdentifierInfo *propertyID,
                                          ObjCPropertyQueryKind queryKind);

static bool classof(const Decl *D) { return classofKind(D->getKind()); }
static bool classofKind(Kind K) { return K == ObjCProperty; }
938};

940/// ObjCContainerDecl - Represents a container for method declarations.
941/// Current sub-classes are ObjCInterfaceDecl, ObjCCategoryDecl,
942/// ObjCProtocolDecl, and ObjCImplDecl.
943///
944class ObjCContainerDecl : public NamedDecl, public DeclContext {
// This class stores some data in DeclContext::ObjCContainerDeclBits
// to save some space. Use the provided accessors to access it.

// These two locations in the range mark the end of the method container.
// The first points to the '@' token, and the second to the 'end' token.
SourceRange AtEnd;

void anchor() override;

954public:
ObjCContainerDecl(Kind DK, DeclContext *DC, IdentifierInfo *Id,
                  SourceLocation nameLoc, SourceLocation atStartLoc);

// Iterator access to instance/class properties.
using prop_iterator = specific_decl_iterator<ObjCPropertyDecl>;
using prop_range =
    llvm::iterator_range<specific_decl_iterator<ObjCPropertyDecl>>;

prop_range properties() const { return prop_range(prop_begin(), prop_end()); }

prop_iterator prop_begin() const {
  return prop_iterator(decls_begin());
}

prop_iterator prop_end() const {
  return prop_iterator(decls_end());
}

using instprop_iterator =
    filtered_decl_iterator<ObjCPropertyDecl,
                           &ObjCPropertyDecl::isInstanceProperty>;
using instprop_range = llvm::iterator_range<instprop_iterator>;

instprop_range instance_properties() const {
  return instprop_range(instprop_begin(), instprop_end());
}

instprop_iterator instprop_begin() const {
  return instprop_iterator(decls_begin());
}

instprop_iterator instprop_end() const {
  return instprop_iterator(decls_end());
}

using classprop_iterator =
    filtered_decl_iterator<ObjCPropertyDecl,
                           &ObjCPropertyDecl::isClassProperty>;
using classprop_range = llvm::iterator_range<classprop_iterator>;

classprop_range class_properties() const {
  return classprop_range(classprop_begin(), classprop_end());
}

classprop_iterator classprop_begin() const {
  return classprop_iterator(decls_begin());
}

classprop_iterator classprop_end() const {
  return classprop_iterator(decls_end());
}

// Iterator access to instance/class methods.
using method_iterator = specific_decl_iterator<ObjCMethodDecl>;
using method_range =
    llvm::iterator_range<specific_decl_iterator<ObjCMethodDecl>>;

method_range methods() const {
  return method_range(meth_begin(), meth_end());
}

method_iterator meth_begin() const {
  return method_iterator(decls_begin());
}

method_iterator meth_end() const {
  return method_iterator(decls_end());
}

using instmeth_iterator =
    filtered_decl_iterator<ObjCMethodDecl,
                           &ObjCMethodDecl::isInstanceMethod>;
using instmeth_range = llvm::iterator_range<instmeth_iterator>;

instmeth_range instance_methods() const {
  return instmeth_range(instmeth_begin(), instmeth_end());
}

instmeth_iterator instmeth_begin() const {
  return instmeth_iterator(decls_begin());
}

instmeth_iterator instmeth_end() const {
  return instmeth_iterator(decls_end());
}

using classmeth_iterator =
    filtered_decl_iterator<ObjCMethodDecl,
                           &ObjCMethodDecl::isClassMethod>;
using classmeth_range = llvm::iterator_range<classmeth_iterator>;

classmeth_range class_methods() const {
  return classmeth_range(classmeth_begin(), classmeth_end());
}

classmeth_iterator classmeth_begin() const {
  return classmeth_iterator(decls_begin());
}

classmeth_iterator classmeth_end() const {
  return classmeth_iterator(decls_end());
}

// Get the local instance/class method declared in this interface.
ObjCMethodDecl *getMethod(Selector Sel, bool isInstance,
                          bool AllowHidden = false) const;

ObjCMethodDecl *getInstanceMethod(Selector Sel,
                                  bool AllowHidden = false) const {
  return getMethod(Sel, true/*isInstance*/, AllowHidden);
}

ObjCMethodDecl *getClassMethod(Selector Sel, bool AllowHidden = false) const {
  return getMethod(Sel, false/*isInstance*/, AllowHidden);
}

bool HasUserDeclaredSetterMethod(const ObjCPropertyDecl *P) const;
ObjCIvarDecl *getIvarDecl(IdentifierInfo *Id) const;

ObjCPropertyDecl *getProperty(const IdentifierInfo *Id,
                              bool IsInstance) const;

ObjCPropertyDecl *
FindPropertyDeclaration(const IdentifierInfo *PropertyId,
                        ObjCPropertyQueryKind QueryKind) const;

using PropertyMap =
    llvm::DenseMap<std::pair<IdentifierInfo *, unsigned/*isClassProperty*/>,
                   ObjCPropertyDecl *>;
using ProtocolPropertySet = llvm::SmallDenseSet<const ObjCProtocolDecl *, 8>;
using PropertyDeclOrder = llvm::SmallVector<ObjCPropertyDecl *, 8>;

/// This routine collects list of properties to be implemented in the class.
/// This includes, class's and its conforming protocols' properties.
/// Note, the superclass's properties are not included in the list.
virtual void collectPropertiesToImplement(PropertyMap &PM,
                                          PropertyDeclOrder &PO) const {}

SourceLocation getAtStartLoc() const { return ObjCContainerDeclBits.AtStart; }

void setAtStartLoc(SourceLocation Loc) {
  ObjCContainerDeclBits.AtStart = Loc;
}

// Marks the end of the container.
SourceRange getAtEndRange() const { return AtEnd; }

void setAtEndRange(SourceRange atEnd) { AtEnd = atEnd; }

SourceRange getSourceRange() const override LLVM_READONLY__attribute__((__pure__)) {
  return SourceRange(getAtStartLoc(), getAtEndRange().getEnd());
}

// Implement isa/cast/dyncast/etc.
static bool classof(const Decl *D) { return classofKind(D->getKind()); }

static bool classofKind(Kind K) {
  return K >= firstObjCContainer &&
         K <= lastObjCContainer;
}

static DeclContext *castToDeclContext(const ObjCContainerDecl *D) {
  return static_cast<DeclContext *>(const_cast<ObjCContainerDecl*>(D));
}

static ObjCContainerDecl *castFromDeclContext(const DeclContext *DC) {
  return static_cast<ObjCContainerDecl *>(const_cast<DeclContext*>(DC));
}
1123};

1125/// Represents an ObjC class declaration.
1126///
1127/// For example:
1128///
1129/// \code
1130///   // MostPrimitive declares no super class (not particularly useful).
1131///   \@interface MostPrimitive
1132///     // no instance variables or methods.
1133///   \@end
1134///
1135///   // NSResponder inherits from NSObject & implements NSCoding (a protocol).
1136///   \@interface NSResponder : NSObject \<NSCoding>
1137///   { // instance variables are represented by ObjCIvarDecl.
1138///     id nextResponder; // nextResponder instance variable.
1139///   }
1140///   - (NSResponder *)nextResponder; // return a pointer to NSResponder.
1141///   - (void)mouseMoved:(NSEvent *)theEvent; // return void, takes a pointer
1142///   \@end                                    // to an NSEvent.
1143/// \endcode
1144///
1145///   Unlike C/C++, forward class declarations are accomplished with \@class.
1146///   Unlike C/C++, \@class allows for a list of classes to be forward declared.
1147///   Unlike C++, ObjC is a single-rooted class model. In Cocoa, classes
1148///   typically inherit from NSObject (an exception is NSProxy).
1149///
1150class ObjCInterfaceDecl : public ObjCContainerDecl
                      , public Redeclarable<ObjCInterfaceDecl> {
friend class ASTContext;

/// TypeForDecl - This indicates the Type object that represents this
/// TypeDecl.  It is a cache maintained by ASTContext::getObjCInterfaceType
mutable const Type *TypeForDecl = nullptr;

struct DefinitionData {
  /// The definition of this class, for quick access from any
  /// declaration.
  ObjCInterfaceDecl *Definition = nullptr;

  /// When non-null, this is always an ObjCObjectType.
  TypeSourceInfo *SuperClassTInfo = nullptr;

  /// Protocols referenced in the \@interface  declaration
  ObjCProtocolList ReferencedProtocols;

  /// Protocols reference in both the \@interface and class extensions.
  ObjCList<ObjCProtocolDecl> AllReferencedProtocols;

  /// List of categories and class extensions defined for this class.
  ///
  /// Categories are stored as a linked list in the AST, since the categories
  /// and class extensions come long after the initial interface declaration,
  /// and we avoid dynamically-resized arrays in the AST wherever possible.
  ObjCCategoryDecl *CategoryList = nullptr;

  /// IvarList - List of all ivars defined by this class; including class
  /// extensions and implementation. This list is built lazily.
  ObjCIvarDecl *IvarList = nullptr;

  /// Indicates that the contents of this Objective-C class will be
  /// completed by the external AST source when required.
  mutable unsigned ExternallyCompleted : 1;

  /// Indicates that the ivar cache does not yet include ivars
  /// declared in the implementation.
  mutable unsigned IvarListMissingImplementation : 1;

  /// Indicates that this interface decl contains at least one initializer
  /// marked with the 'objc_designated_initializer' attribute.
  unsigned HasDesignatedInitializers : 1;

  enum InheritedDesignatedInitializersState {
    /// We didn't calculate whether the designated initializers should be
    /// inherited or not.
    IDI_Unknown = 0,

    /// Designated initializers are inherited for the super class.
    IDI_Inherited = 1,

    /// The class does not inherit designated initializers.
    IDI_NotInherited = 2
  };

  /// One of the \c InheritedDesignatedInitializersState enumeratos.
  mutable unsigned InheritedDesignatedInitializers : 2;

  /// The location of the last location in this declaration, before
  /// the properties/methods. For example, this will be the '>', '}', or
  /// identifier,
  SourceLocation EndLoc;

  DefinitionData()
      : ExternallyCompleted(false), IvarListMissingImplementation(true),
        HasDesignatedInitializers(false),
        InheritedDesignatedInitializers(IDI_Unknown) {}
};

/// The type parameters associated with this class, if any.
ObjCTypeParamList *TypeParamList = nullptr;

/// Contains a pointer to the data associated with this class,
/// which will be NULL if this class has not yet been defined.
///
/// The bit indicates when we don't need to check for out-of-date
/// declarations. It will be set unless modules are enabled.
llvm::PointerIntPair<DefinitionData *, 1, bool> Data;

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

void anchor() override;

void LoadExternalDefinition() const;

DefinitionData &data() const {
  assert(Data.getPointer() && "Declaration has no definition!")(static_cast <bool> (Data.getPointer() && "Declaration has no definition!"
) ? void (0) : __assert_fail ("Data.getPointer() && \"Declaration has no definition!\""
, "clang/include/clang/AST/DeclObjC.h", 1241, __extension__ __PRETTY_FUNCTION__
));
  return *Data.getPointer();
}

/// Allocate the definition data for this class.
void allocateDefinitionData();

using redeclarable_base = Redeclarable<ObjCInterfaceDecl>;

ObjCInterfaceDecl *getNextRedeclarationImpl() override {
  return getNextRedeclaration();
}

ObjCInterfaceDecl *getPreviousDeclImpl() override {
  return getPreviousDecl();
}

ObjCInterfaceDecl *getMostRecentDeclImpl() override {
  return getMostRecentDecl();
}

1262public:
static ObjCInterfaceDecl *Create(const ASTContext &C, DeclContext *DC,
                                 SourceLocation atLoc,
                                 IdentifierInfo *Id,
                                 ObjCTypeParamList *typeParamList,
                                 ObjCInterfaceDecl *PrevDecl,
                                 SourceLocation ClassLoc = SourceLocation(),
                                 bool isInternal = false);

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

/// Retrieve the type parameters of this class.
///
/// This function looks for a type parameter list for the given
/// class; if the class has been declared (with \c \@class) but not
/// defined (with \c \@interface), it will search for a declaration that
/// has type parameters, skipping any declarations that do not.
ObjCTypeParamList *getTypeParamList() const;

/// Set the type parameters of this class.
///
/// This function is used by the AST importer, which must import the type
/// parameters after creating their DeclContext to avoid loops.
void setTypeParamList(ObjCTypeParamList *TPL);

/// Retrieve the type parameters written on this particular declaration of
/// the class.
ObjCTypeParamList *getTypeParamListAsWritten() const {
  return TypeParamList;
}

SourceRange getSourceRange() const override LLVM_READONLY__attribute__((__pure__)) {
  if (isThisDeclarationADefinition())
    return ObjCContainerDecl::getSourceRange();

  return SourceRange(getAtStartLoc(), getLocation());
}

/// Indicate that this Objective-C class is complete, but that
/// the external AST source will be responsible for filling in its contents
/// when a complete class is required.
void setExternallyCompleted();

/// Indicate that this interface decl contains at least one initializer
/// marked with the 'objc_designated_initializer' attribute.
void setHasDesignatedInitializers();

/// Returns true if this interface decl contains at least one initializer
/// marked with the 'objc_designated_initializer' attribute.
bool hasDesignatedInitializers() const;

/// Returns true if this interface decl declares a designated initializer
/// or it inherites one from its super class.
bool declaresOrInheritsDesignatedInitializers() const {
  return hasDesignatedInitializers() || inheritsDesignatedInitializers();
}

const ObjCProtocolList &getReferencedProtocols() const {
  assert(hasDefinition() && "Caller did not check for forward reference!")(static_cast <bool> (hasDefinition() && "Caller did not check for forward reference!"
) ? void (0) : __assert_fail ("hasDefinition() && \"Caller did not check for forward reference!\""
, "clang/include/clang/AST/DeclObjC.h", 1320, __extension__ __PRETTY_FUNCTION__
));
  if (data().ExternallyCompleted)
    LoadExternalDefinition();

  return data().ReferencedProtocols;
}

ObjCImplementationDecl *getImplementation() const;
void setImplementation(ObjCImplementationDecl *ImplD);

ObjCCategoryDecl *FindCategoryDeclaration(IdentifierInfo *CategoryId) const;

// Get the local instance/class method declared in a category.
ObjCMethodDecl *getCategoryInstanceMethod(Selector Sel) const;
ObjCMethodDecl *getCategoryClassMethod(Selector Sel) const;

ObjCMethodDecl *getCategoryMethod(Selector Sel, bool isInstance) const {
  return isInstance ? getCategoryInstanceMethod(Sel)
                    : getCategoryClassMethod(Sel);
}

using protocol_iterator = ObjCProtocolList::iterator;
using protocol_range = llvm::iterator_range<protocol_iterator>;

protocol_range protocols() const {
  return protocol_range(protocol_begin(), protocol_end());
}

protocol_iterator protocol_begin() const {
  // FIXME: Should make sure no callers ever do this.
  if (!hasDefinition())
    return protocol_iterator();

  if (data().ExternallyCompleted)
    LoadExternalDefinition();

  return data().ReferencedProtocols.begin();
}

protocol_iterator protocol_end() const {
  // FIXME: Should make sure no callers ever do this.
  if (!hasDefinition())
    return protocol_iterator();

  if (data().ExternallyCompleted)
    LoadExternalDefinition();

  return data().ReferencedProtocols.end();
}

using protocol_loc_iterator = ObjCProtocolList::loc_iterator;
using protocol_loc_range = llvm::iterator_range<protocol_loc_iterator>;

protocol_loc_range protocol_locs() const {
  return protocol_loc_range(protocol_loc_begin(), protocol_loc_end());
}

protocol_loc_iterator protocol_loc_begin() const {
  // FIXME: Should make sure no callers ever do this.
  if (!hasDefinition())
    return protocol_loc_iterator();

  if (data().ExternallyCompleted)
    LoadExternalDefinition();

  return data().ReferencedProtocols.loc_begin();
}

protocol_loc_iterator protocol_loc_end() const {
  // FIXME: Should make sure no callers ever do this.
  if (!hasDefinition())
    return protocol_loc_iterator();

  if (data().ExternallyCompleted)
    LoadExternalDefinition();

  return data().ReferencedProtocols.loc_end();
}

using all_protocol_iterator = ObjCList<ObjCProtocolDecl>::iterator;
using all_protocol_range = llvm::iterator_range<all_protocol_iterator>;

all_protocol_range all_referenced_protocols() const {
  return all_protocol_range(all_referenced_protocol_begin(),
                            all_referenced_protocol_end());
}

all_protocol_iterator all_referenced_protocol_begin() const {
  // FIXME: Should make sure no callers ever do this.
  if (!hasDefinition())
    return all_protocol_iterator();

  if (data().ExternallyCompleted)
    LoadExternalDefinition();

  return data().AllReferencedProtocols.empty()
           ? protocol_begin()
           : data().AllReferencedProtocols.begin();
}

all_protocol_iterator all_referenced_protocol_end() const {
  // FIXME: Should make sure no callers ever do this.
  if (!hasDefinition())
    return all_protocol_iterator();

  if (data().ExternallyCompleted)
    LoadExternalDefinition();

  return data().AllReferencedProtocols.empty()
           ? protocol_end()
           : data().AllReferencedProtocols.end();
}

using ivar_iterator = specific_decl_iterator<ObjCIvarDecl>;
using ivar_range = llvm::iterator_range<specific_decl_iterator<ObjCIvarDecl>>;

ivar_range ivars() const { return ivar_range(ivar_begin(), ivar_end()); }

ivar_iterator ivar_begin() const {
  if (const ObjCInterfaceDecl *Def = getDefinition())
    return ivar_iterator(Def->decls_begin());

  // FIXME: Should make sure no callers ever do this.
  return ivar_iterator();
}

ivar_iterator ivar_end() const {
  if (const ObjCInterfaceDecl *Def = getDefinition())
    return ivar_iterator(Def->decls_end());

  // FIXME: Should make sure no callers ever do this.
  return ivar_iterator();
}

unsigned ivar_size() const {
  return std::distance(ivar_begin(), ivar_end());
}

bool ivar_empty() const { return ivar_begin() == ivar_end(); }

ObjCIvarDecl *all_declared_ivar_begin();
const ObjCIvarDecl *all_declared_ivar_begin() const {
  // Even though this modifies IvarList, it's conceptually const:
  // the ivar chain is essentially a cached property of ObjCInterfaceDecl.
  return const_cast<ObjCInterfaceDecl *>(this)->all_declared_ivar_begin();
}
void setIvarList(ObjCIvarDecl *ivar) { data().IvarList = ivar; }

/// setProtocolList - Set the list of protocols that this interface
/// implements.
void setProtocolList(ObjCProtocolDecl *const* List, unsigned Num,
                     const SourceLocation *Locs, ASTContext &C) {
  data().ReferencedProtocols.set(List, Num, Locs, C);
}

/// mergeClassExtensionProtocolList - Merge class extension's protocol list
/// into the protocol list for this class.
void mergeClassExtensionProtocolList(ObjCProtocolDecl *const* List,
                                     unsigned Num,
                                     ASTContext &C);

/// Produce a name to be used for class's metadata. It comes either via
/// objc_runtime_name attribute or class name.
StringRef getObjCRuntimeNameAsString() const;

/// Returns the designated initializers for the interface.
///
/// If this declaration does not have methods marked as designated
/// initializers then the interface inherits the designated initializers of
/// its super class.
void getDesignatedInitializers(
                llvm::SmallVectorImpl<const ObjCMethodDecl *> &Methods) const;

/// Returns true if the given selector is a designated initializer for the
/// interface.
///
/// If this declaration does not have methods marked as designated
/// initializers then the interface inherits the designated initializers of
/// its super class.
///
/// \param InitMethod if non-null and the function returns true, it receives
/// the method that was marked as a designated initializer.
bool
isDesignatedInitializer(Selector Sel,
                        const ObjCMethodDecl **InitMethod = nullptr) const;

/// Determine whether this particular declaration of this class is
/// actually also a definition.
bool isThisDeclarationADefinition() const {
  return getDefinition() == this;
}

/// Determine whether this class has been defined.
bool hasDefinition() const {
  // If the name of this class is out-of-date, bring it up-to-date, which
  // might bring in a definition.
  // Note: a null value indicates that we don't have a definition and that
  // modules are enabled.
  if (!Data.getOpaqueValue())
    getMostRecentDecl();

  return Data.getPointer();
}

/// Retrieve the definition of this class, or NULL if this class
/// has been forward-declared (with \@class) but not yet defined (with
/// \@interface).
ObjCInterfaceDecl *getDefinition() {
  return hasDefinition()? Data.getPointer()->Definition : nullptr;
}

/// Retrieve the definition of this class, or NULL if this class
/// has been forward-declared (with \@class) but not yet defined (with
/// \@interface).
const ObjCInterfaceDecl *getDefinition() const {
  return hasDefinition()? Data.getPointer()->Definition : nullptr;
10
←
Assuming the condition is true→
11
←
'?' condition is true→
12
←
Returning pointer, which participates in a condition later→
}

/// Starts the definition of this Objective-C class, taking it from
/// a forward declaration (\@class) to a definition (\@interface).
void startDefinition();

/// Retrieve the superclass type.
const ObjCObjectType *getSuperClassType() const {
  if (TypeSourceInfo *TInfo = getSuperClassTInfo())
    return TInfo->getType()->castAs<ObjCObjectType>();

  return nullptr;
}

// Retrieve the type source information for the superclass.
TypeSourceInfo *getSuperClassTInfo() const {
  // FIXME: Should make sure no callers ever do this.
  if (!hasDefinition())
    return nullptr;

  if (data().ExternallyCompleted)
    LoadExternalDefinition();

  return data().SuperClassTInfo;
}

// Retrieve the declaration for the superclass of this class, which
// does not include any type arguments that apply to the superclass.
ObjCInterfaceDecl *getSuperClass() const;

void setSuperClass(TypeSourceInfo *superClass) {
  data().SuperClassTInfo = superClass;
}

/// Iterator that walks over the list of categories, filtering out
/// those that do not meet specific criteria.
///
/// This class template is used for the various permutations of category
/// and extension iterators.
template<bool (*Filter)(ObjCCategoryDecl *)>
class filtered_category_iterator {
  ObjCCategoryDecl *Current = nullptr;

  void findAcceptableCategory();

public:
  using value_type = ObjCCategoryDecl *;
  using reference = value_type;
  using pointer = value_type;
  using difference_type = std::ptrdiff_t;
  using iterator_category = std::input_iterator_tag;

  filtered_category_iterator() = default;
  explicit filtered_category_iterator(ObjCCategoryDecl *Current)
      : Current(Current) {
    findAcceptableCategory();
  }

  reference operator*() const { return Current; }
  pointer operator->() const { return Current; }

  filtered_category_iterator &operator++();

  filtered_category_iterator operator++(int) {
    filtered_category_iterator Tmp = *this;
    ++(*this);
    return Tmp;
  }

  friend bool operator==(filtered_category_iterator X,
                         filtered_category_iterator Y) {
    return X.Current == Y.Current;
  }

  friend bool operator!=(filtered_category_iterator X,
                         filtered_category_iterator Y) {
    return X.Current != Y.Current;
  }
};

1616private:
/// Test whether the given category is visible.
///
/// Used in the \c visible_categories_iterator.
static bool isVisibleCategory(ObjCCategoryDecl *Cat);

1622public:
/// Iterator that walks over the list of categories and extensions
/// that are visible, i.e., not hidden in a non-imported submodule.
using visible_categories_iterator =
    filtered_category_iterator<isVisibleCategory>;

using visible_categories_range =
    llvm::iterator_range<visible_categories_iterator>;

visible_categories_range visible_categories() const {
  return visible_categories_range(visible_categories_begin(),
                                  visible_categories_end());
}

/// Retrieve an iterator to the beginning of the visible-categories
/// list.
visible_categories_iterator visible_categories_begin() const {
  return visible_categories_iterator(getCategoryListRaw());
}

/// Retrieve an iterator to the end of the visible-categories list.
visible_categories_iterator visible_categories_end() const {
  return visible_categories_iterator();
}

/// Determine whether the visible-categories list is empty.
bool visible_categories_empty() const {
  return visible_categories_begin() == visible_categories_end();
}

1652private:
/// Test whether the given category... is a category.
///
/// Used in the \c known_categories_iterator.
static bool isKnownCategory(ObjCCategoryDecl *) { return true; }

1658public:
/// Iterator that walks over all of the known categories and
/// extensions, including those that are hidden.
using known_categories_iterator = filtered_category_iterator<isKnownCategory>;
using known_categories_range =
   llvm::iterator_range<known_categories_iterator>;

known_categories_range known_categories() const {
  return known_categories_range(known_categories_begin(),
                                known_categories_end());
}

/// Retrieve an iterator to the beginning of the known-categories
/// list.
known_categories_iterator known_categories_begin() const {
  return known_categories_iterator(getCategoryListRaw());
}

/// Retrieve an iterator to the end of the known-categories list.
known_categories_iterator known_categories_end() const {
  return known_categories_iterator();
}

/// Determine whether the known-categories list is empty.
bool known_categories_empty() const {
  return known_categories_begin() == known_categories_end();
}

1686private:
/// Test whether the given category is a visible extension.
///
/// Used in the \c visible_extensions_iterator.
static bool isVisibleExtension(ObjCCategoryDecl *Cat);

1692public:
/// Iterator that walks over all of the visible extensions, skipping
/// any that are known but hidden.
using visible_extensions_iterator =
    filtered_category_iterator<isVisibleExtension>;

using visible_extensions_range =
    llvm::iterator_range<visible_extensions_iterator>;

visible_extensions_range visible_extensions() const {
  return visible_extensions_range(visible_extensions_begin(),
                                  visible_extensions_end());
}

/// Retrieve an iterator to the beginning of the visible-extensions
/// list.
visible_extensions_iterator visible_extensions_begin() const {
  return visible_extensions_iterator(getCategoryListRaw());
}

/// Retrieve an iterator to the end of the visible-extensions list.
visible_extensions_iterator visible_extensions_end() const {
  return visible_extensions_iterator();
}

/// Determine whether the visible-extensions list is empty.
bool visible_extensions_empty() const {
  return visible_extensions_begin() == visible_extensions_end();
}

1722private:
/// Test whether the given category is an extension.
///
/// Used in the \c known_extensions_iterator.
static bool isKnownExtension(ObjCCategoryDecl *Cat);

1728public:
friend class ASTDeclReader;
friend class ASTDeclWriter;
friend class ASTReader;

/// Iterator that walks over all of the known extensions.
using known_extensions_iterator =
    filtered_category_iterator<isKnownExtension>;
using known_extensions_range =
    llvm::iterator_range<known_extensions_iterator>;

known_extensions_range known_extensions() const {
  return known_extensions_range(known_extensions_begin(),
                                known_extensions_end());
}

/// Retrieve an iterator to the beginning of the known-extensions
/// list.
known_extensions_iterator known_extensions_begin() const {
  return known_extensions_iterator(getCategoryListRaw());
}

/// Retrieve an iterator to the end of the known-extensions list.
known_extensions_iterator known_extensions_end() const {
  return known_extensions_iterator();
}

/// Determine whether the known-extensions list is empty.
bool known_extensions_empty() const {
  return known_extensions_begin() == known_extensions_end();
}

/// Retrieve the raw pointer to the start of the category/extension
/// list.
ObjCCategoryDecl* getCategoryListRaw() const {
  // FIXME: Should make sure no callers ever do this.
  if (!hasDefinition())
    return nullptr;

  if (data().ExternallyCompleted)
    LoadExternalDefinition();

  return data().CategoryList;
}

/// Set the raw pointer to the start of the category/extension
/// list.
void setCategoryListRaw(ObjCCategoryDecl *category) {
  data().CategoryList = category;
}

ObjCPropertyDecl
  *FindPropertyVisibleInPrimaryClass(IdentifierInfo *PropertyId,
                                     ObjCPropertyQueryKind QueryKind) const;

void collectPropertiesToImplement(PropertyMap &PM,
                                  PropertyDeclOrder &PO) const override;

/// isSuperClassOf - Return true if this class is the specified class or is a
/// super class of the specified interface class.
bool isSuperClassOf(const ObjCInterfaceDecl *I) const {
  // If RHS is derived from LHS it is OK; else it is not OK.
  while (I != nullptr) {
    if (declaresSameEntity(this, I))
      return true;

    I = I->getSuperClass();
  }
  return false;
}

/// isArcWeakrefUnavailable - Checks for a class or one of its super classes
/// to be incompatible with __weak references. Returns true if it is.
bool isArcWeakrefUnavailable() const;

/// isObjCRequiresPropertyDefs - Checks that a class or one of its super
/// classes must not be auto-synthesized. Returns class decl. if it must not
/// be; 0, otherwise.
const ObjCInterfaceDecl *isObjCRequiresPropertyDefs() const;

ObjCIvarDecl *lookupInstanceVariable(IdentifierInfo *IVarName,
                                     ObjCInterfaceDecl *&ClassDeclared);
ObjCIvarDecl *lookupInstanceVariable(IdentifierInfo *IVarName) {
  ObjCInterfaceDecl *ClassDeclared;
  return lookupInstanceVariable(IVarName, ClassDeclared);
}

ObjCProtocolDecl *lookupNestedProtocol(IdentifierInfo *Name);

// Lookup a method. First, we search locally. If a method isn't
// found, we search referenced protocols and class categories.
ObjCMethodDecl *lookupMethod(Selector Sel, bool isInstance,
                             bool shallowCategoryLookup = false,
                             bool followSuper = true,
                             const ObjCCategoryDecl *C = nullptr) const;

/// Lookup an instance method for a given selector.
ObjCMethodDecl *lookupInstanceMethod(Selector Sel) const {
  return lookupMethod(Sel, true/*isInstance*/);
}

/// Lookup a class method for a given selector.
ObjCMethodDecl *lookupClassMethod(Selector Sel) const {
  return lookupMethod(Sel, false/*isInstance*/);
}

ObjCInterfaceDecl *lookupInheritedClass(const IdentifierInfo *ICName);

/// Lookup a method in the classes implementation hierarchy.
ObjCMethodDecl *lookupPrivateMethod(const Selector &Sel,
                                    bool Instance=true) const;

ObjCMethodDecl *lookupPrivateClassMethod(const Selector &Sel) {
  return lookupPrivateMethod(Sel, false);
}

/// Lookup a setter or getter in the class hierarchy,
/// including in all categories except for category passed
/// as argument.
ObjCMethodDecl *lookupPropertyAccessor(const Selector Sel,
                                       const ObjCCategoryDecl *Cat,
                                       bool IsClassProperty) const {
  return lookupMethod(Sel, !IsClassProperty/*isInstance*/,
                      false/*shallowCategoryLookup*/,
                      true /* followsSuper */,
                      Cat);
}

SourceLocation getEndOfDefinitionLoc() const {
  if (!hasDefinition())
    return getLocation();

  return data().EndLoc;
}

void setEndOfDefinitionLoc(SourceLocation LE) { data().EndLoc = LE; }

/// Retrieve the starting location of the superclass.
SourceLocation getSuperClassLoc() const;

/// isImplicitInterfaceDecl - check that this is an implicitly declared
/// ObjCInterfaceDecl node. This is for legacy objective-c \@implementation
/// declaration without an \@interface declaration.
bool isImplicitInterfaceDecl() const {
  return hasDefinition() ? data().Definition->isImplicit() : isImplicit();
}

/// ClassImplementsProtocol - Checks that 'lProto' protocol
/// has been implemented in IDecl class, its super class or categories (if
/// lookupCategory is true).
bool ClassImplementsProtocol(ObjCProtocolDecl *lProto,
                             bool lookupCategory,
                             bool RHSIsQualifiedID = false);

using redecl_range = redeclarable_base::redecl_range;
using redecl_iterator = redeclarable_base::redecl_iterator;

using redeclarable_base::redecls_begin;
using redeclarable_base::redecls_end;
using redeclarable_base::redecls;
using redeclarable_base::getPreviousDecl;
using redeclarable_base::getMostRecentDecl;
using redeclarable_base::isFirstDecl;

/// Retrieves the canonical declaration of this Objective-C class.
ObjCInterfaceDecl *getCanonicalDecl() override { return getFirstDecl(); }
const ObjCInterfaceDecl *getCanonicalDecl() const { return getFirstDecl(); }

// Low-level accessor
const Type *getTypeForDecl() const { return TypeForDecl; }
void setTypeForDecl(const Type *TD) const { TypeForDecl = TD; }

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

1903private:
const ObjCInterfaceDecl *findInterfaceWithDesignatedInitializers() const;
bool inheritsDesignatedInitializers() const;
1906};

1908/// ObjCIvarDecl - Represents an ObjC instance variable. In general, ObjC
1909/// instance variables are identical to C. The only exception is Objective-C
1910/// supports C++ style access control. For example:
1911///
1912///   \@interface IvarExample : NSObject
1913///   {
1914///     id defaultToProtected;
1915///   \@public:
1916///     id canBePublic; // same as C++.
1917///   \@protected:
1918///     id canBeProtected; // same as C++.
1919///   \@package:
1920///     id canBePackage; // framework visibility (not available in C++).
1921///   }
1922///
1923class ObjCIvarDecl : public FieldDecl {
void anchor() override;

1926public:
enum AccessControl {
  None, Private, Protected, Public, Package
};

1931private:
ObjCIvarDecl(ObjCContainerDecl *DC, SourceLocation StartLoc,
             SourceLocation IdLoc, IdentifierInfo *Id,
             QualType T, TypeSourceInfo *TInfo, AccessControl ac, Expr *BW,
             bool synthesized)
    : FieldDecl(ObjCIvar, DC, StartLoc, IdLoc, Id, T, TInfo, BW,
                /*Mutable=*/false, /*HasInit=*/ICIS_NoInit),
      DeclAccess(ac), Synthesized(synthesized) {}

1940public:
static ObjCIvarDecl *Create(ASTContext &C, ObjCContainerDecl *DC,
                            SourceLocation StartLoc, SourceLocation IdLoc,
                            IdentifierInfo *Id, QualType T,
                            TypeSourceInfo *TInfo,
                            AccessControl ac, Expr *BW = nullptr,
                            bool synthesized=false);

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

/// Return the class interface that this ivar is logically contained
/// in; this is either the interface where the ivar was declared, or the
/// interface the ivar is conceptually a part of in the case of synthesized
/// ivars.
const ObjCInterfaceDecl *getContainingInterface() const;

ObjCIvarDecl *getNextIvar() { return NextIvar; }
const ObjCIvarDecl *getNextIvar() const { return NextIvar; }
void setNextIvar(ObjCIvarDecl *ivar) { NextIvar = ivar; }

ObjCIvarDecl *getCanonicalDecl() override {
  return cast<ObjCIvarDecl>(FieldDecl::getCanonicalDecl());
}
const ObjCIvarDecl *getCanonicalDecl() const {
  return const_cast<ObjCIvarDecl *>(this)->getCanonicalDecl();
}

void setAccessControl(AccessControl ac) { DeclAccess = ac; }

AccessControl getAccessControl() const { return AccessControl(DeclAccess); }

AccessControl getCanonicalAccessControl() const {
  return DeclAccess == None ? Protected : AccessControl(DeclAccess);
}

void setSynthesize(bool synth) { Synthesized = synth; }
bool getSynthesize() const { return Synthesized; }

/// Retrieve the type of this instance variable when viewed as a member of a
/// specific object type.
QualType getUsageType(QualType objectType) const;

// Implement isa/cast/dyncast/etc.
static bool classof(const Decl *D) { return classofKind(D->getKind()); }
static bool classofKind(Kind K) { return K == ObjCIvar; }

1986private:
/// NextIvar - Next Ivar in the list of ivars declared in class; class's
/// extensions and class's implementation
ObjCIvarDecl *NextIvar = nullptr;

// NOTE: VC++ treats enums as signed, avoid using the AccessControl enum
unsigned DeclAccess : 3;
unsigned Synthesized : 1;
1994};

1996/// Represents a field declaration created by an \@defs(...).
1997class ObjCAtDefsFieldDecl : public FieldDecl {
ObjCAtDefsFieldDecl(DeclContext *DC, SourceLocation StartLoc,
                    SourceLocation IdLoc, IdentifierInfo *Id,
                    QualType T, Expr *BW)
    : FieldDecl(ObjCAtDefsField, DC, StartLoc, IdLoc, Id, T,
                /*TInfo=*/nullptr, // FIXME: Do ObjCAtDefs have declarators ?
                BW, /*Mutable=*/false, /*HasInit=*/ICIS_NoInit) {}

void anchor() override;

2007public:
static ObjCAtDefsFieldDecl *Create(ASTContext &C, DeclContext *DC,
                                   SourceLocation StartLoc,
                                   SourceLocation IdLoc, IdentifierInfo *Id,
                                   QualType T, Expr *BW);

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

// Implement isa/cast/dyncast/etc.
static bool classof(const Decl *D) { return classofKind(D->getKind()); }
static bool classofKind(Kind K) { return K == ObjCAtDefsField; }
2018};

2020/// Represents an Objective-C protocol declaration.
2021///
2022/// Objective-C protocols declare a pure abstract type (i.e., no instance
2023/// variables are permitted).  Protocols originally drew inspiration from
2024/// C++ pure virtual functions (a C++ feature with nice semantics and lousy
2025/// syntax:-). Here is an example:
2026///
2027/// \code
2028/// \@protocol NSDraggingInfo <refproto1, refproto2>
2029/// - (NSWindow *)draggingDestinationWindow;
2030/// - (NSImage *)draggedImage;
2031/// \@end
2032/// \endcode
2033///
2034/// This says that NSDraggingInfo requires two methods and requires everything
2035/// that the two "referenced protocols" 'refproto1' and 'refproto2' require as
2036/// well.
2037///
2038/// \code
2039/// \@interface ImplementsNSDraggingInfo : NSObject \<NSDraggingInfo>
2040/// \@end
2041/// \endcode
2042///
2043/// ObjC protocols inspired Java interfaces. Unlike Java, ObjC classes and
2044/// protocols are in distinct namespaces. For example, Cocoa defines both
2045/// an NSObject protocol and class (which isn't allowed in Java). As a result,
2046/// protocols are referenced using angle brackets as follows:
2047///
2048/// id \<NSDraggingInfo> anyObjectThatImplementsNSDraggingInfo;
2049class ObjCProtocolDecl : public ObjCContainerDecl,
                       public Redeclarable<ObjCProtocolDecl> {
struct DefinitionData {
  // The declaration that defines this protocol.
  ObjCProtocolDecl *Definition;

  /// Referenced protocols
  ObjCProtocolList ReferencedProtocols;
};

/// Contains a pointer to the data associated with this class,
/// which will be NULL if this class has not yet been defined.
///
/// The bit indicates when we don't need to check for out-of-date
/// declarations. It will be set unless modules are enabled.
llvm::PointerIntPair<DefinitionData *, 1, bool> Data;

ObjCProtocolDecl(ASTContext &C, DeclContext *DC, IdentifierInfo *Id,
                 SourceLocation nameLoc, SourceLocation atStartLoc,
                 ObjCProtocolDecl *PrevDecl);

void anchor() override;

DefinitionData &data() const {
  assert(Data.getPointer() && "Objective-C protocol has no definition!")(static_cast <bool> (Data.getPointer() && "Objective-C protocol has no definition!"
) ? void (0) : __assert_fail ("Data.getPointer() && \"Objective-C protocol has no definition!\""
, "clang/include/clang/AST/DeclObjC.h", 2073, __extension__ __PRETTY_FUNCTION__
));
  return *Data.getPointer();
}

void allocateDefinitionData();

using redeclarable_base = Redeclarable<ObjCProtocolDecl>;

ObjCProtocolDecl *getNextRedeclarationImpl() override {
  return getNextRedeclaration();
}

ObjCProtocolDecl *getPreviousDeclImpl() override {
  return getPreviousDecl();
}

ObjCProtocolDecl *getMostRecentDeclImpl() override {
  return getMostRecentDecl();
}

2093public:
friend class ASTDeclReader;
friend class ASTDeclWriter;
friend class ASTReader;

static ObjCProtocolDecl *Create(ASTContext &C, DeclContext *DC,
                                IdentifierInfo *Id,
                                SourceLocation nameLoc,
                                SourceLocation atStartLoc,
                                ObjCProtocolDecl *PrevDecl);

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

const ObjCProtocolList &getReferencedProtocols() const {
  assert(hasDefinition() && "No definition available!")(static_cast <bool> (hasDefinition() && "No definition available!"
) ? void (0) : __assert_fail ("hasDefinition() && \"No definition available!\""
, "clang/include/clang/AST/DeclObjC.h", 2107, __extension__ __PRETTY_FUNCTION__
));
  return data().ReferencedProtocols;
}

using protocol_iterator = ObjCProtocolList::iterator;
using protocol_range = llvm::iterator_range<protocol_iterator>;

protocol_range protocols() const {
  return protocol_range(protocol_begin(), protocol_end());
}

protocol_iterator protocol_begin() const {
  if (!hasDefinition())
    return protocol_iterator();

  return data().ReferencedProtocols.begin();
}

protocol_iterator protocol_end() const {
  if (!hasDefinition())
    return protocol_iterator();

  return data().ReferencedProtocols.end();
}

using protocol_loc_iterator = ObjCProtocolList::loc_iterator;
using protocol_loc_range = llvm::iterator_range<protocol_loc_iterator>;

protocol_loc_range protocol_locs() const {
  return protocol_loc_range(protocol_loc_begin(), protocol_loc_end());
}

protocol_loc_iterator protocol_loc_begin() const {
  if (!hasDefinition())
    return protocol_loc_iterator();

  return data().ReferencedProtocols.loc_begin();
}

protocol_loc_iterator protocol_loc_end() const {
  if (!hasDefinition())
    return protocol_loc_iterator();

  return data().ReferencedProtocols.loc_end();
}

unsigned protocol_size() const {
  if (!hasDefinition())
    return 0;

  return data().ReferencedProtocols.size();
}

/// setProtocolList - Set the list of protocols that this interface
/// implements.
void setProtocolList(ObjCProtocolDecl *const*List, unsigned Num,
                     const SourceLocation *Locs, ASTContext &C) {
  assert(hasDefinition() && "Protocol is not defined")(static_cast <bool> (hasDefinition() && "Protocol is not defined"
) ? void (0) : __assert_fail ("hasDefinition() && \"Protocol is not defined\""
, "clang/include/clang/AST/DeclObjC.h", 2164, __extension__ __PRETTY_FUNCTION__
));
  data().ReferencedProtocols.set(List, Num, Locs, C);
}

/// This is true iff the protocol is tagged with the
/// `objc_non_runtime_protocol` attribute.
bool isNonRuntimeProtocol() const;

/// Get the set of all protocols implied by this protocols inheritance
/// hierarchy.
void getImpliedProtocols(llvm::DenseSet<const ObjCProtocolDecl *> &IPs) const;

ObjCProtocolDecl *lookupProtocolNamed(IdentifierInfo *PName);

// Lookup a method. First, we search locally. If a method isn't
// found, we search referenced protocols and class categories.
ObjCMethodDecl *lookupMethod(Selector Sel, bool isInstance) const;

ObjCMethodDecl *lookupInstanceMethod(Selector Sel) const {
  return lookupMethod(Sel, true/*isInstance*/);
}

ObjCMethodDecl *lookupClassMethod(Selector Sel) const {
  return lookupMethod(Sel, false/*isInstance*/);
}

/// Determine whether this protocol has a definition.
bool hasDefinition() const {
  // If the name of this protocol is out-of-date, bring it up-to-date, which
  // might bring in a definition.
  // Note: a null value indicates that we don't have a definition and that
  // modules are enabled.
  if (!Data.getOpaqueValue())
    getMostRecentDecl();

  return Data.getPointer();
}

/// Retrieve the definition of this protocol, if any.
ObjCProtocolDecl *getDefinition() {
  return hasDefinition()? Data.getPointer()->Definition : nullptr;
}

/// Retrieve the definition of this protocol, if any.
const ObjCProtocolDecl *getDefinition() const {
  return hasDefinition()? Data.getPointer()->Definition : nullptr;
}

/// Determine whether this particular declaration is also the
/// definition.
bool isThisDeclarationADefinition() const {
  return getDefinition() == this;
}

/// Starts the definition of this Objective-C protocol.
void startDefinition();

/// Produce a name to be used for protocol's metadata. It comes either via
/// objc_runtime_name attribute or protocol name.
StringRef getObjCRuntimeNameAsString() const;

SourceRange getSourceRange() const override LLVM_READONLY__attribute__((__pure__)) {
  if (isThisDeclarationADefinition())
    return ObjCContainerDecl::getSourceRange();

  return SourceRange(getAtStartLoc(), getLocation());
}

using redecl_range = redeclarable_base::redecl_range;
using redecl_iterator = redeclarable_base::redecl_iterator;

using redeclarable_base::redecls_begin;
using redeclarable_base::redecls_end;
using redeclarable_base::redecls;
using redeclarable_base::getPreviousDecl;
using redeclarable_base::getMostRecentDecl;
using redeclarable_base::isFirstDecl;

/// Retrieves the canonical declaration of this Objective-C protocol.
ObjCProtocolDecl *getCanonicalDecl() override { return getFirstDecl(); }
const ObjCProtocolDecl *getCanonicalDecl() const { return getFirstDecl(); }

void collectPropertiesToImplement(PropertyMap &PM,
                                  PropertyDeclOrder &PO) const override;

void collectInheritedProtocolProperties(const ObjCPropertyDecl *Property,
                                        ProtocolPropertySet &PS,
                                        PropertyDeclOrder &PO) const;

static bool classof(const Decl *D) { return classofKind(D->getKind()); }
static bool classofKind(Kind K) { return K == ObjCProtocol; }
2255};

2257/// ObjCCategoryDecl - Represents a category declaration. A category allows
2258/// you to add methods to an existing class (without subclassing or modifying
2259/// the original class interface or implementation:-). Categories don't allow
2260/// you to add instance data. The following example adds "myMethod" to all
2261/// NSView's within a process:
2262///
2263/// \@interface NSView (MyViewMethods)
2264/// - myMethod;
2265/// \@end
2266///
2267/// Categories also allow you to split the implementation of a class across
2268/// several files (a feature more naturally supported in C++).
2269///
2270/// Categories were originally inspired by dynamic languages such as Common
2271/// Lisp and Smalltalk.  More traditional class-based languages (C++, Java)
2272/// don't support this level of dynamism, which is both powerful and dangerous.
2273class ObjCCategoryDecl : public ObjCContainerDecl {
/// Interface belonging to this category
ObjCInterfaceDecl *ClassInterface;

/// The type parameters associated with this category, if any.
ObjCTypeParamList *TypeParamList = nullptr;

/// referenced protocols in this category.
ObjCProtocolList ReferencedProtocols;

/// Next category belonging to this class.
/// FIXME: this should not be a singly-linked list.  Move storage elsewhere.
ObjCCategoryDecl *NextClassCategory = nullptr;

/// The location of the category name in this declaration.
SourceLocation CategoryNameLoc;

/// class extension may have private ivars.
SourceLocation IvarLBraceLoc;
SourceLocation IvarRBraceLoc;

ObjCCategoryDecl(DeclContext *DC, SourceLocation AtLoc,
                 SourceLocation ClassNameLoc, SourceLocation CategoryNameLoc,
                 IdentifierInfo *Id, ObjCInterfaceDecl *IDecl,
                 ObjCTypeParamList *typeParamList,
                 SourceLocation IvarLBraceLoc = SourceLocation(),
                 SourceLocation IvarRBraceLoc = SourceLocation());

void anchor() override;

2303public:
friend class ASTDeclReader;
friend class ASTDeclWriter;

static ObjCCategoryDecl *Create(ASTContext &C, DeclContext *DC,
                                SourceLocation AtLoc,
                                SourceLocation ClassNameLoc,
                                SourceLocation CategoryNameLoc,
                                IdentifierInfo *Id,
                                ObjCInterfaceDecl *IDecl,
                                ObjCTypeParamList *typeParamList,
                                SourceLocation IvarLBraceLoc=SourceLocation(),
                                SourceLocation IvarRBraceLoc=SourceLocation());
static ObjCCategoryDecl *CreateDeserialized(ASTContext &C, unsigned ID);

ObjCInterfaceDecl *getClassInterface() { return ClassInterface; }
const ObjCInterfaceDecl *getClassInterface() const { return ClassInterface; }

/// Retrieve the type parameter list associated with this category or
/// extension.
ObjCTypeParamList *getTypeParamList() const { return TypeParamList; }

/// Set the type parameters of this category.
///
/// This function is used by the AST importer, which must import the type
/// parameters after creating their DeclContext to avoid loops.
void setTypeParamList(ObjCTypeParamList *TPL);


ObjCCategoryImplDecl *getImplementation() const;
void setImplementation(ObjCCategoryImplDecl *ImplD);

/// setProtocolList - Set the list of protocols that this interface
/// implements.
void setProtocolList(ObjCProtocolDecl *const*List, unsigned Num,
                     const SourceLocation *Locs, ASTContext &C) {
  ReferencedProtocols.set(List, Num, Locs, C);
}

const ObjCProtocolList &getReferencedProtocols() const {
  return ReferencedProtocols;
}

using protocol_iterator = ObjCProtocolList::iterator;
using protocol_range = llvm::iterator_range<protocol_iterator>;

protocol_range protocols() const {
  return protocol_range(protocol_begin(), protocol_end());
}

protocol_iterator protocol_begin() const {
  return ReferencedProtocols.begin();
}

protocol_iterator protocol_end() const { return ReferencedProtocols.end(); }
unsigned protocol_size() const { return ReferencedProtocols.size(); }

using protocol_loc_iterator = ObjCProtocolList::loc_iterator;
using protocol_loc_range = llvm::iterator_range<protocol_loc_iterator>;

protocol_loc_range protocol_locs() const {
  return protocol_loc_range(protocol_loc_begin(), protocol_loc_end());
}

protocol_loc_iterator protocol_loc_begin() const {
  return ReferencedProtocols.loc_begin();
}

protocol_loc_iterator protocol_loc_end() const {
  return ReferencedProtocols.loc_end();
}

ObjCCategoryDecl *getNextClassCategory() const { return NextClassCategory; }

/// Retrieve the pointer to the next stored category (or extension),
/// which may be hidden.
ObjCCategoryDecl *getNextClassCategoryRaw() const {
  return NextClassCategory;
}

bool IsClassExtension() const { return getIdentifier() == nullptr; }

using ivar_iterator = specific_decl_iterator<ObjCIvarDecl>;
using ivar_range = llvm::iterator_range<specific_decl_iterator<ObjCIvarDecl>>;

ivar_range ivars() const { return ivar_range(ivar_begin(), ivar_end()); }

ivar_iterator ivar_begin() const {
  return ivar_iterator(decls_begin());
}

ivar_iterator ivar_end() const {
  return ivar_iterator(decls_end());
}

unsigned ivar_size() const {
  return std::distance(ivar_begin(), ivar_end());
}

bool ivar_empty() const {
  return ivar_begin() == ivar_end();
}

SourceLocation getCategoryNameLoc() const { return CategoryNameLoc; }
void setCategoryNameLoc(SourceLocation Loc) { CategoryNameLoc = Loc; }

void setIvarLBraceLoc(SourceLocation Loc) { IvarLBraceLoc = Loc; }
SourceLocation getIvarLBraceLoc() const { return IvarLBraceLoc; }
void setIvarRBraceLoc(SourceLocation Loc) { IvarRBraceLoc = Loc; }
SourceLocation getIvarRBraceLoc() const { return IvarRBraceLoc; }

static bool classof(const Decl *D) { return classofKind(D->getKind()); }
static bool classofKind(Kind K) { return K == ObjCCategory; }
2416};

2418class ObjCImplDecl : public ObjCContainerDecl {
/// Class interface for this class/category implementation
ObjCInterfaceDecl *ClassInterface;

void anchor() override;

2424protected:
ObjCImplDecl(Kind DK, DeclContext *DC,
             ObjCInterfaceDecl *classInterface,
             IdentifierInfo *Id,
             SourceLocation nameLoc, SourceLocation atStartLoc)
    : ObjCContainerDecl(DK, DC, Id, nameLoc, atStartLoc),
      ClassInterface(classInterface) {}

2432public:
const ObjCInterfaceDecl *getClassInterface() const { return ClassInterface; }
ObjCInterfaceDecl *getClassInterface() { return ClassInterface; }
void setClassInterface(ObjCInterfaceDecl *IFace);

void addInstanceMethod(ObjCMethodDecl *method) {
  // FIXME: Context should be set correctly before we get here.
  method->setLexicalDeclContext(this);
  addDecl(method);
}

void addClassMethod(ObjCMethodDecl *method) {
  // FIXME: Context should be set correctly before we get here.
  method->setLexicalDeclContext(this);
  addDecl(method);
}

void addPropertyImplementation(ObjCPropertyImplDecl *property);

ObjCPropertyImplDecl *FindPropertyImplDecl(IdentifierInfo *propertyId,
                          ObjCPropertyQueryKind queryKind) const;
ObjCPropertyImplDecl *FindPropertyImplIvarDecl(IdentifierInfo *ivarId) const;

// Iterator access to properties.
using propimpl_iterator = specific_decl_iterator<ObjCPropertyImplDecl>;
using propimpl_range =
    llvm::iterator_range<specific_decl_iterator<ObjCPropertyImplDecl>>;

propimpl_range property_impls() const {
  return propimpl_range(propimpl_begin(), propimpl_end());
}

propimpl_iterator propimpl_begin() const {
  return propimpl_iterator(decls_begin());
}

propimpl_iterator propimpl_end() const {
  return propimpl_iterator(decls_end());
}

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

static bool classofKind(Kind K) {
  return K >= firstObjCImpl && K <= lastObjCImpl;
}
2477};

2479/// ObjCCategoryImplDecl - An object of this class encapsulates a category
2480/// \@implementation declaration. If a category class has declaration of a
2481/// property, its implementation must be specified in the category's
2482/// \@implementation declaration. Example:
2483/// \@interface I \@end
2484/// \@interface I(CATEGORY)
2485///    \@property int p1, d1;
2486/// \@end
2487/// \@implementation I(CATEGORY)
2488///  \@dynamic p1,d1;
2489/// \@end
2490///
2491/// ObjCCategoryImplDecl
2492class ObjCCategoryImplDecl : public ObjCImplDecl {
// Category name location
SourceLocation CategoryNameLoc;

ObjCCategoryImplDecl(DeclContext *DC, IdentifierInfo *Id,
                     ObjCInterfaceDecl *classInterface,
                     SourceLocation nameLoc, SourceLocation atStartLoc,
                     SourceLocation CategoryNameLoc)
    : ObjCImplDecl(ObjCCategoryImpl, DC, classInterface, Id,
                   nameLoc, atStartLoc),
      CategoryNameLoc(CategoryNameLoc) {}

void anchor() override;

2506public:
friend class ASTDeclReader;
friend class ASTDeclWriter;

static ObjCCategoryImplDecl *Create(ASTContext &C, DeclContext *DC,
                                    IdentifierInfo *Id,
                                    ObjCInterfaceDecl *classInterface,
                                    SourceLocation nameLoc,
                                    SourceLocation atStartLoc,
                                    SourceLocation CategoryNameLoc);
static ObjCCategoryImplDecl *CreateDeserialized(ASTContext &C, unsigned ID);

ObjCCategoryDecl *getCategoryDecl() const;

SourceLocation getCategoryNameLoc() const { return CategoryNameLoc; }

static bool classof(const Decl *D) { return classofKind(D->getKind()); }
static bool classofKind(Kind K) { return K == ObjCCategoryImpl;}
2524};

2526raw_ostream &operator<<(raw_ostream &OS, const ObjCCategoryImplDecl &CID);

2528/// ObjCImplementationDecl - Represents a class definition - this is where
2529/// method definitions are specified. For example:
2530///
2531/// @code
2532/// \@implementation MyClass
2533/// - (void)myMethod { /* do something */ }
2534/// \@end
2535/// @endcode
2536///
2537/// In a non-fragile runtime, instance variables can appear in the class
2538/// interface, class extensions (nameless categories), and in the implementation
2539/// itself, as well as being synthesized as backing storage for properties.
2540///
2541/// In a fragile runtime, instance variables are specified in the class
2542/// interface, \em not in the implementation. Nevertheless (for legacy reasons),
2543/// we allow instance variables to be specified in the implementation. When
2544/// specified, they need to be \em identical to the interface.
2545class ObjCImplementationDecl : public ObjCImplDecl {
/// Implementation Class's super class.
ObjCInterfaceDecl *SuperClass;
SourceLocation SuperLoc;

/// \@implementation may have private ivars.
SourceLocation IvarLBraceLoc;
SourceLocation IvarRBraceLoc;

/// Support for ivar initialization.
/// The arguments used to initialize the ivars
LazyCXXCtorInitializersPtr IvarInitializers;
unsigned NumIvarInitializers = 0;

/// Do the ivars of this class require initialization other than
/// zero-initialization?
bool HasNonZeroConstructors : 1;

/// Do the ivars of this class require non-trivial destruction?
bool HasDestructors : 1;

ObjCImplementationDecl(DeclContext *DC,
                       ObjCInterfaceDecl *classInterface,
                       ObjCInterfaceDecl *superDecl,
                       SourceLocation nameLoc, SourceLocation atStartLoc,
                       SourceLocation superLoc = SourceLocation(),
                       SourceLocation IvarLBraceLoc=SourceLocation(),
                       SourceLocation IvarRBraceLoc=SourceLocation())
    : ObjCImplDecl(ObjCImplementation, DC, classInterface,
                   classInterface ? classInterface->getIdentifier()
                                  : nullptr,
                   nameLoc, atStartLoc),
       SuperClass(superDecl), SuperLoc(superLoc),
       IvarLBraceLoc(IvarLBraceLoc), IvarRBraceLoc(IvarRBraceLoc),
       HasNonZeroConstructors(false), HasDestructors(false) {}

void anchor() override;

2583public:
friend class ASTDeclReader;
friend class ASTDeclWriter;

static ObjCImplementationDecl *Create(ASTContext &C, DeclContext *DC,
                                      ObjCInterfaceDecl *classInterface,
                                      ObjCInterfaceDecl *superDecl,
                                      SourceLocation nameLoc,
                                      SourceLocation atStartLoc,
                                   SourceLocation superLoc = SourceLocation(),
                                      SourceLocation IvarLBraceLoc=SourceLocation(),
                                      SourceLocation IvarRBraceLoc=SourceLocation());

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

/// init_iterator - Iterates through the ivar initializer list.
using init_iterator = CXXCtorInitializer **;

/// init_const_iterator - Iterates through the ivar initializer list.
using init_const_iterator = CXXCtorInitializer * const *;

using init_range = llvm::iterator_range<init_iterator>;
using init_const_range = llvm::iterator_range<init_const_iterator>;

init_range inits() { return init_range(init_begin(), init_end()); }

init_const_range inits() const {
  return init_const_range(init_begin(), init_end());
}

/// init_begin() - Retrieve an iterator to the first initializer.
init_iterator init_begin() {
  const auto *ConstThis = this;
  return const_cast<init_iterator>(ConstThis->init_begin());
}

/// begin() - Retrieve an iterator to the first initializer.
init_const_iterator init_begin() const;

/// init_end() - Retrieve an iterator past the last initializer.
init_iterator       init_end()       {
  return init_begin() + NumIvarInitializers;
}

/// end() - Retrieve an iterator past the last initializer.
init_const_iterator init_end() const {
  return init_begin() + NumIvarInitializers;
}

/// getNumArgs - Number of ivars which must be initialized.
unsigned getNumIvarInitializers() const {
  return NumIvarInitializers;
}

void setNumIvarInitializers(unsigned numNumIvarInitializers) {
  NumIvarInitializers = numNumIvarInitializers;
}

void setIvarInitializers(ASTContext &C,
                         CXXCtorInitializer ** initializers,
                         unsigned numInitializers);

/// Do any of the ivars of this class (not counting its base classes)
/// require construction other than zero-initialization?
bool hasNonZeroConstructors() const { return HasNonZeroConstructors; }
void setHasNonZeroConstructors(bool val) { HasNonZeroConstructors = val; }

/// Do any of the ivars of this class (not counting its base classes)
/// require non-trivial destruction?
bool hasDestructors() const { return HasDestructors; }
void setHasDestructors(bool val) { HasDestructors = val; }

/// getIdentifier - Get the identifier that names the class
/// interface associated with this implementation.
IdentifierInfo *getIdentifier() const {
  return getClassInterface()->getIdentifier();
}

/// getName - Get the name of identifier for the class interface associated
/// with this implementation as a StringRef.
//
// FIXME: This is a bad API, we are hiding NamedDecl::getName with a different
// meaning.
StringRef getName() const {
  assert(getIdentifier() && "Name is not a simple identifier")(static_cast <bool> (getIdentifier() && "Name is not a simple identifier"
) ? void (0) : __assert_fail ("getIdentifier() && \"Name is not a simple identifier\""
, "clang/include/clang/AST/DeclObjC.h", 2667, __extension__ __PRETTY_FUNCTION__
));
  return getIdentifier()->getName();
}

/// Get the name of the class associated with this interface.
//
// FIXME: Move to StringRef API.
std::string getNameAsString() const { return std::string(getName()); }

/// Produce a name to be used for class's metadata. It comes either via
/// class's objc_runtime_name attribute or class name.
StringRef getObjCRuntimeNameAsString() const;

const ObjCInterfaceDecl *getSuperClass() const { return SuperClass; }
ObjCInterfaceDecl *getSuperClass() { return SuperClass; }
SourceLocation getSuperClassLoc() const { return SuperLoc; }

void setSuperClass(ObjCInterfaceDecl * superCls) { SuperClass = superCls; }

void setIvarLBraceLoc(SourceLocation Loc) { IvarLBraceLoc = Loc; }
SourceLocation getIvarLBraceLoc() const { return IvarLBraceLoc; }
void setIvarRBraceLoc(SourceLocation Loc) { IvarRBraceLoc = Loc; }
SourceLocation getIvarRBraceLoc() const { return IvarRBraceLoc; }

using ivar_iterator = specific_decl_iterator<ObjCIvarDecl>;
using ivar_range = llvm::iterator_range<specific_decl_iterator<ObjCIvarDecl>>;

ivar_range ivars() const { return ivar_range(ivar_begin(), ivar_end()); }

ivar_iterator ivar_begin() const {
  return ivar_iterator(decls_begin());
}

ivar_iterator ivar_end() const {
  return ivar_iterator(decls_end());
}

unsigned ivar_size() const {
  return std::distance(ivar_begin(), ivar_end());
}

bool ivar_empty() const {
  return ivar_begin() == ivar_end();
}

static bool classof(const Decl *D) { return classofKind(D->getKind()); }
static bool classofKind(Kind K) { return K == ObjCImplementation; }
2714};

2716raw_ostream &operator<<(raw_ostream &OS, const ObjCImplementationDecl &ID);

2718/// ObjCCompatibleAliasDecl - Represents alias of a class. This alias is
2719/// declared as \@compatibility_alias alias class.
2720class ObjCCompatibleAliasDecl : public NamedDecl {
/// Class that this is an alias of.
ObjCInterfaceDecl *AliasedClass;

ObjCCompatibleAliasDecl(DeclContext *DC, SourceLocation L, IdentifierInfo *Id,
                        ObjCInterfaceDecl* aliasedClass)
    : NamedDecl(ObjCCompatibleAlias, DC, L, Id), AliasedClass(aliasedClass) {}

void anchor() override;

2730public:
static ObjCCompatibleAliasDecl *Create(ASTContext &C, DeclContext *DC,
                                       SourceLocation L, IdentifierInfo *Id,
                                       ObjCInterfaceDecl* aliasedClass);

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

const ObjCInterfaceDecl *getClassInterface() const { return AliasedClass; }
ObjCInterfaceDecl *getClassInterface() { return AliasedClass; }
void setClassInterface(ObjCInterfaceDecl *D) { AliasedClass = D; }

static bool classof(const Decl *D) { return classofKind(D->getKind()); }
static bool classofKind(Kind K) { return K == ObjCCompatibleAlias; }
2744};

2746/// ObjCPropertyImplDecl - Represents implementation declaration of a property
2747/// in a class or category implementation block. For example:
2748/// \@synthesize prop1 = ivar1;
2749///
2750class ObjCPropertyImplDecl : public Decl {
2751public:
enum Kind {
  Synthesize,
  Dynamic
};

2757private:
SourceLocation AtLoc;   // location of \@synthesize or \@dynamic

/// For \@synthesize, the location of the ivar, if it was written in
/// the source code.
///
/// \code
/// \@synthesize int a = b
/// \endcode
SourceLocation IvarLoc;

/// Property declaration being implemented
ObjCPropertyDecl *PropertyDecl;

/// Null for \@dynamic. Required for \@synthesize.
ObjCIvarDecl *PropertyIvarDecl;

/// The getter's definition, which has an empty body if synthesized.
ObjCMethodDecl *GetterMethodDecl = nullptr;
/// The getter's definition, which has an empty body if synthesized.
ObjCMethodDecl *SetterMethodDecl = nullptr;

/// Null for \@dynamic. Non-null if property must be copy-constructed in
/// getter.
Expr *GetterCXXConstructor = nullptr;

/// Null for \@dynamic. Non-null if property has assignment operator to call
/// in Setter synthesis.
Expr *SetterCXXAssignment = nullptr;

ObjCPropertyImplDecl(DeclContext *DC, SourceLocation atLoc, SourceLocation L,
                     ObjCPropertyDecl *property,
                     Kind PK,
                     ObjCIvarDecl *ivarDecl,
                     SourceLocation ivarLoc)
    : Decl(ObjCPropertyImpl, DC, L), AtLoc(atLoc),
      IvarLoc(ivarLoc), PropertyDecl(property), PropertyIvarDecl(ivarDecl) {
  assert(PK == Dynamic || PropertyIvarDecl)(static_cast <bool> (PK == Dynamic || PropertyIvarDecl)
 ? void (0) : __assert_fail ("PK == Dynamic || PropertyIvarDecl"
, "clang/include/clang/AST/DeclObjC.h", 2794, __extension__ __PRETTY_FUNCTION__
));
}

2797public:
friend class ASTDeclReader;

static ObjCPropertyImplDecl *Create(ASTContext &C, DeclContext *DC,
                                    SourceLocation atLoc, SourceLocation L,
                                    ObjCPropertyDecl *property,
                                    Kind PK,
                                    ObjCIvarDecl *ivarDecl,
                                    SourceLocation ivarLoc);

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

SourceRange getSourceRange() const override LLVM_READONLY__attribute__((__pure__));

SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) { return AtLoc; }
void setAtLoc(SourceLocation Loc) { AtLoc = Loc; }

ObjCPropertyDecl *getPropertyDecl() const {
  return PropertyDecl;
}
void setPropertyDecl(ObjCPropertyDecl *Prop) { PropertyDecl = Prop; }

Kind getPropertyImplementation() const {
  return PropertyIvarDecl ? Synthesize : Dynamic;
}

ObjCIvarDecl *getPropertyIvarDecl() const {
  return PropertyIvarDecl;
}
SourceLocation getPropertyIvarDeclLoc() const { return IvarLoc; }

void setPropertyIvarDecl(ObjCIvarDecl *Ivar,
                         SourceLocation IvarLoc) {
  PropertyIvarDecl = Ivar;
  this->IvarLoc = IvarLoc;
}

/// For \@synthesize, returns true if an ivar name was explicitly
/// specified.
///
/// \code
/// \@synthesize int a = b; // true
/// \@synthesize int a; // false
/// \endcode
bool isIvarNameSpecified() const {
  return IvarLoc.isValid() && IvarLoc != getLocation();
}

ObjCMethodDecl *getGetterMethodDecl() const { return GetterMethodDecl; }
void setGetterMethodDecl(ObjCMethodDecl *MD) { GetterMethodDecl = MD; }

ObjCMethodDecl *getSetterMethodDecl() const { return SetterMethodDecl; }
void setSetterMethodDecl(ObjCMethodDecl *MD) { SetterMethodDecl = MD; }

Expr *getGetterCXXConstructor() const {
  return GetterCXXConstructor;
}

void setGetterCXXConstructor(Expr *getterCXXConstructor) {
  GetterCXXConstructor = getterCXXConstructor;
}

Expr *getSetterCXXAssignment() const {
  return SetterCXXAssignment;
}

void setSetterCXXAssignment(Expr *setterCXXAssignment) {
  SetterCXXAssignment = setterCXXAssignment;
}

static bool classof(const Decl *D) { return classofKind(D->getKind()); }
static bool classofKind(Decl::Kind K) { return K == ObjCPropertyImpl; }
2869};

2871template<bool (*Filter)(ObjCCategoryDecl *)>
2872void
2873ObjCInterfaceDecl::filtered_category_iterator<Filter>::
2874findAcceptableCategory() {
while (Current && !Filter(Current))
  Current = Current->getNextClassCategoryRaw();
2877}

2879template<bool (*Filter)(ObjCCategoryDecl *)>
2880inline ObjCInterfaceDecl::filtered_category_iterator<Filter> &
2881ObjCInterfaceDecl::filtered_category_iterator<Filter>::operator++() {
Current = Current->getNextClassCategoryRaw();
findAcceptableCategory();
return *this;
2885}

2887inline bool ObjCInterfaceDecl::isVisibleCategory(ObjCCategoryDecl *Cat) {
return Cat->isUnconditionallyVisible();
2889}

2891inline bool ObjCInterfaceDecl::isVisibleExtension(ObjCCategoryDecl *Cat) {
return Cat->IsClassExtension() && Cat->isUnconditionallyVisible();
2893}

2895inline bool ObjCInterfaceDecl::isKnownExtension(ObjCCategoryDecl *Cat) {
return Cat->IsClassExtension();
2897}

2899} // namespace clang

2901#endif // LLVM_CLANG_AST_DECLOBJC_H