/build/source/clang/lib/AST/DeclObjC.cpp

Bug Summary

File:	build/source/clang/lib/AST/DeclObjC.cpp
Warning:	line 1707, 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-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/source/build-llvm -resource-dir /usr/lib/llvm-17/lib/clang/17 -I tools/clang/lib/AST -I /build/source/clang/lib/AST -I /build/source/clang/include -I tools/clang/include -I include -I /build/source/llvm/include -D _DEBUG -D _GLIBCXX_ASSERTIONS -D _GNU_SOURCE -D _LIBCPP_ENABLE_ASSERTIONS -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -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-17/lib/clang/17/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/source/build-llvm=build-llvm -fmacro-prefix-map=/build/source/= -fcoverage-prefix-map=/build/source/build-llvm=build-llvm -fcoverage-prefix-map=/build/source/= -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 -Wno-misleading-indentation -std=c++17 -fdeprecated-macro -fdebug-compilation-dir=/build/source/build-llvm -fdebug-prefix-map=/build/source/build-llvm=build-llvm -fdebug-prefix-map=/build/source/= -fdebug-prefix-map=/build/source/build-llvm=build-llvm -fdebug-prefix-map=/build/source/= -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-2023-05-10-133810-16478-1 -x c++ /build/source/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/ODRHash.h"
20#include "clang/AST/Stmt.h"
21#include "clang/AST/Type.h"
22#include "clang/AST/TypeLoc.h"
23#include "clang/Basic/IdentifierTable.h"
24#include "clang/Basic/LLVM.h"
25#include "clang/Basic/LangOptions.h"
26#include "clang/Basic/SourceLocation.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) const {
for (auto *Prop : properties()) {
  PM[std::make_pair(Prop->getIdentifier(), Prop->isClassProperty())] = 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;
  }
}
for (const auto *PI : all_referenced_protocols())
  PI->collectPropertiesToImplement(PM);
// 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.
421}

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

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

443void 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);
482}

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

497static 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;
515}

517bool 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", 541, __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", 541, __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", 546);
547}

549void 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);
}
569}

571bool 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;
609}

611void 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", 612, __extension__ __PRETTY_FUNCTION__
));
Data.setPointer(new (getASTContext()) DefinitionData());
Data.getPointer()->Definition = this;
615}

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

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

627void ObjCInterfaceDecl::startDuplicateDefinitionForComparison() {
Data.setPointer(nullptr);
allocateDefinitionData();
// Don't propagate data to other redeclarations.
631}

633void ObjCInterfaceDecl::mergeDuplicateDefinitionWithCommon(
  const ObjCInterfaceDecl *Definition) {
Data = Definition->Data;
636}

638ObjCIvarDecl *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;
664}

666/// lookupInheritedClass - This method returns ObjCInterfaceDecl * of the super
667/// class whose name is passed as argument. If it is not one of the super classes
668/// the it returns NULL.
669ObjCInterfaceDecl *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;
685}

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

696/// lookupMethod - This method returns an instance/class method by looking in
697/// the class, its categories, and its super classes (using a linear search).
698/// When argument category "C" is specified, any implicit method found
699/// in this category is ignored.
700ObjCMethodDecl *ObjCInterfaceDecl::lookupMethod(Selector Sel,
                                              bool isInstance,
                                              bool shallowCategoryLookup,
                                              bool followSuper,
                                              const ObjCCategoryDecl *C) const
705{
// 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;
752}

754// Will search "local" class/category implementations for a method decl.
755// If failed, then we search in class's root for an instance method.
756// Returns 0 if no method is found.
757ObjCMethodDecl *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;
790}

792unsigned ObjCInterfaceDecl::getODRHash() {
assert(hasDefinition() && "ODRHash only for records with definitions")(static_cast <bool> (hasDefinition() && "ODRHash only for records with definitions"
) ? void (0) : __assert_fail ("hasDefinition() && \"ODRHash only for records with definitions\""
, "clang/lib/AST/DeclObjC.cpp", 793, __extension__ __PRETTY_FUNCTION__
));

// Previously calculated hash is stored in DefinitionData.
if (hasODRHash())
  return data().ODRHash;

// Only calculate hash on first call of getODRHash per record.
ODRHash Hasher;
Hasher.AddObjCInterfaceDecl(getDefinition());
data().ODRHash = Hasher.CalculateHash();
setHasODRHash(true);

return data().ODRHash;
806}

808bool ObjCInterfaceDecl::hasODRHash() const {
if (!hasDefinition())
  return false;
return data().HasODRHash;
812}

814void ObjCInterfaceDecl::setHasODRHash(bool HasHash) {
assert(hasDefinition() && "Cannot set ODRHash without definition")(static_cast <bool> (hasDefinition() && "Cannot set ODRHash without definition"
) ? void (0) : __assert_fail ("hasDefinition() && \"Cannot set ODRHash without definition\""
, "clang/lib/AST/DeclObjC.cpp", 815, __extension__ __PRETTY_FUNCTION__
));
data().HasODRHash = HasHash;
817}

819//===----------------------------------------------------------------------===//
820// ObjCMethodDecl
821//===----------------------------------------------------------------------===//

823ObjCMethodDecl::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);
851}

853ObjCMethodDecl *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);
864}

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

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

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

881bool 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;
887}

889bool 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;
899}

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

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

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

920void 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());
936}

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

944void 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", 948, __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", 948, __extension__ __PRETTY_FUNCTION__
));
if (isImplicit())
  return setParamsAndSelLocs(C, Params, std::nullopt);

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

setParamsAndSelLocs(C, Params, SelLocs);
958}

960/// A definition will return its interface declaration.
961/// An interface declaration will return its definition.
962/// Otherwise it will return itself.
963ObjCMethodDecl *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;
1010}

1012ObjCMethodDecl *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;
1045}

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

1053ObjCMethodFamily 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;
1143}

1145QualType 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", 1181, __extension__
 __PRETTY_FUNCTION__));
    // 'self' is always const in class methods.
    selfTy = selfTy.withConst();
    selfIsPseudoStrong = true;
  }
}
return selfTy;
1188}

1190void 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));
1209}

1211ObjCInterfaceDecl *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"
, 1220);
1221}

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

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

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

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

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

1252static 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);
}
1310}

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

1319static 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"
, 1321, __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);
}
1358}

1360void 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", 1373, __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", 1373, __extension__ __PRETTY_FUNCTION__
));
}
1375}

1377const ObjCPropertyDecl *
1378ObjCMethodDecl::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", 1431, __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", 1441, __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", 1450);
}

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;
1465}

1467//===----------------------------------------------------------------------===//
1468// ObjCTypeParamDecl
1469//===----------------------------------------------------------------------===//

1471void ObjCTypeParamDecl::anchor() {}

1473ObjCTypeParamDecl *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;
1487}

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

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

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

return SourceRange(startLoc);
1508}

1510//===----------------------------------------------------------------------===//
1511// ObjCTypeParamList
1512//===----------------------------------------------------------------------===//
1513ObjCTypeParamList::ObjCTypeParamList(SourceLocation lAngleLoc,
                                   ArrayRef<ObjCTypeParamDecl *> typeParams,
                                   SourceLocation rAngleLoc)
  : Brackets(lAngleLoc, rAngleLoc), NumParams(typeParams.size()) {
std::copy(typeParams.begin(), typeParams.end(), begin());
1518}

1520ObjCTypeParamList *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);
1529}

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

1538//===----------------------------------------------------------------------===//
1539// ObjCInterfaceDecl
1540//===----------------------------------------------------------------------===//

1542ObjCInterfaceDecl *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;
1556}

1558ObjCInterfaceDecl *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;
1565}

1567ObjCInterfaceDecl::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);
1584}

1586void 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", 1587, __extension__ __PRETTY_FUNCTION__
));
data().ExternallyCompleted = false;
getASTContext().getExternalSource()->CompleteType(
                                      const_cast<ObjCInterfaceDecl *>(this));
1591}

1593void 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", 1595, __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", 1595, __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", 1597, __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", 1597, __extension__ __PRETTY_FUNCTION__
));
data().ExternallyCompleted = true;
1599}

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

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

return data().HasDesignatedInitializers;
1616}

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

return getName();
1624}

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

return getName();
1633}

1635ObjCImplementationDecl *ObjCInterfaceDecl::getImplementation() const {
if (const ObjCInterfaceDecl *Def = getDefinition()) {
  if (data().ExternallyCompleted)
    LoadExternalDefinition();

  return getASTContext().getObjCImplementation(
           const_cast<ObjCInterfaceDecl*>(Def));
}

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

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

1652namespace {

1654struct SynthesizeIvarChunk {
uint64_t Size;
ObjCIvarDecl *Ivar;

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

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

1667} // namespace

1669/// all_declared_ivar_begin - return first ivar declared in this class,
1670/// its extensions and its implementation. Lazily build the list on first
1671/// access.
1672///
1673/// Caveat: The list returned by this method reflects the current
1674/// state of the parser. The cache will be updated for every ivar
1675/// added by an extension or the implementation when they are
1676/// encountered.
1677/// See also ObjCIvarDecl::Create().
1678ObjCIvarDecl *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 null→
5
←
Taking true branch→
  // Force ivar deserialization upfront, before building IvarList.
  (void)ivar_empty();
  for (const auto *Ext : known_extensions()) {
    (void)Ext->ivar_empty();
  }
  if (!ivar_empty()) {
6
←
Taking false branch→
    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()) {
7
←
Taking true branch→
      ObjCCategoryDecl::ivar_iterator
        I = Ext->ivar_begin(),
        E = Ext->ivar_end();
      if (!data().IvarList) {
8
←
Assuming field 'IvarList' is non-null→
9
←
Taking false branch→
        data().IvarList = *I; ++I;
        curIvar = data().IvarList;
      }
      for ( ;I != E; curIvar = *I, ++I)
10
←
Loop condition is true.  Entering loop body→
        curIvar->setNextIvar(*I);
11
←
Called C++ object pointer is null
    }
  }
  data().IvarListMissingImplementation = true;
}

// cached and complete!
if (!data().IvarListMissingImplementation)
    return data().IvarList;

if (ObjCImplementationDecl *ImplDecl = getImplementation()) {
  data().IvarListMissingImplementation = false;
  if (!ImplDecl->ivar_empty()) {
    SmallVector<SynthesizeIvarChunk, 16> layout;
    for (auto *IV : ImplDecl->ivars()) {
      if (IV->getSynthesize() && !IV->isInvalidDecl()) {
        layout.push_back(SynthesizeIvarChunk(
                           IV->getASTContext().getTypeSize(IV->getType()), IV));
        continue;
      }
      if (!data().IvarList)
        data().IvarList = IV;
      else
        curIvar->setNextIvar(IV);
      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;
1748}

1750/// FindCategoryDeclaration - Finds category declaration in the list of
1751/// categories for this class and returns it. Name of the category is passed
1752/// in 'CategoryId'. If category not found, return 0;
1753///
1754ObjCCategoryDecl *
1755ObjCInterfaceDecl::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;
1768}

1770ObjCMethodDecl *
1771ObjCInterfaceDecl::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;
1779}

1781ObjCMethodDecl *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;
1789}

1791/// ClassImplementsProtocol - Checks that 'lProto' protocol
1792/// has been implemented in IDecl class, its super class or categories (if
1793/// lookupCategory is true).
1794bool 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;
1831}

1833//===----------------------------------------------------------------------===//
1834// ObjCIvarDecl
1835//===----------------------------------------------------------------------===//

1837void ObjCIvarDecl::anchor() {}

1839ObjCIvarDecl *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", 1858, __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", 1858, __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", 1858, __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);
1873}

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

1881ObjCInterfaceDecl *ObjCIvarDecl::getContainingInterface() {
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"
, 1888);

  // Ivars can only appear in class extension categories.
case ObjCCategory: {
  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", 1893, __extension__ __PRETTY_FUNCTION__
));
  return CD->getClassInterface();
}

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

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

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

1910//===----------------------------------------------------------------------===//
1911// ObjCAtDefsFieldDecl
1912//===----------------------------------------------------------------------===//

1914void ObjCAtDefsFieldDecl::anchor() {}

1916ObjCAtDefsFieldDecl
1917*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);
1921}

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

1930//===----------------------------------------------------------------------===//
1931// ObjCProtocolDecl
1932//===----------------------------------------------------------------------===//

1934void ObjCProtocolDecl::anchor() {}

1936ObjCProtocolDecl::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;
1945}

1947ObjCProtocolDecl *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;
1956}

1958ObjCProtocolDecl *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;
1965}

1967bool ObjCProtocolDecl::isNonRuntimeProtocol() const {
return hasAttr<ObjCNonRuntimeProtocolAttr>();
1969}

1971void 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);
  }
}
1986}

1988ObjCProtocolDecl *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;
1999}

2001// lookupMethod - Lookup a instance/class method in the protocol and protocols
2002// it inherited.
2003ObjCMethodDecl *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;
2020}

2022void 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", 2023, __extension__ __PRETTY_FUNCTION__
));
Data.setPointer(new (getASTContext()) DefinitionData);
Data.getPointer()->Definition = this;
Data.getPointer()->HasODRHash = false;
2027}

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

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

2037void ObjCProtocolDecl::startDuplicateDefinitionForComparison() {
Data.setPointer(nullptr);
allocateDefinitionData();
// Don't propagate data to other redeclarations.
2041}

2043void ObjCProtocolDecl::mergeDuplicateDefinitionWithCommon(
  const ObjCProtocolDecl *Definition) {
Data = Definition->Data;
2046}

2048void ObjCProtocolDecl::collectPropertiesToImplement(PropertyMap &PM) 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));
  }
  // Scan through protocol's protocols.
  for (const auto *PI : PDecl->protocols())
    PI->collectPropertiesToImplement(PM);
}
2060}

2062void 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);
}
2080}

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

return getName();
2088}

2090unsigned ObjCProtocolDecl::getODRHash() {
assert(hasDefinition() && "ODRHash only for records with definitions")(static_cast <bool> (hasDefinition() && "ODRHash only for records with definitions"
) ? void (0) : __assert_fail ("hasDefinition() && \"ODRHash only for records with definitions\""
, "clang/lib/AST/DeclObjC.cpp", 2091, __extension__ __PRETTY_FUNCTION__
));

// Previously calculated hash is stored in DefinitionData.
if (hasODRHash())
  return data().ODRHash;

// Only calculate hash on first call of getODRHash per record.
ODRHash Hasher;
Hasher.AddObjCProtocolDecl(getDefinition());
data().ODRHash = Hasher.CalculateHash();
setHasODRHash(true);

return data().ODRHash;
2104}

2106bool ObjCProtocolDecl::hasODRHash() const {
if (!hasDefinition())
  return false;
return data().HasODRHash;
2110}

2112void ObjCProtocolDecl::setHasODRHash(bool HasHash) {
assert(hasDefinition() && "Cannot set ODRHash without definition")(static_cast <bool> (hasDefinition() && "Cannot set ODRHash without definition"
) ? void (0) : __assert_fail ("hasDefinition() && \"Cannot set ODRHash without definition\""
, "clang/lib/AST/DeclObjC.cpp", 2113, __extension__ __PRETTY_FUNCTION__
));
data().HasODRHash = HasHash;
2115}

2117//===----------------------------------------------------------------------===//
2118// ObjCCategoryDecl
2119//===----------------------------------------------------------------------===//

2121void ObjCCategoryDecl::anchor() {}

2123ObjCCategoryDecl::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);
2134}

2136ObjCCategoryDecl *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;
2160}

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

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

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

2178void 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);
2185}

2187//===----------------------------------------------------------------------===//
2188// ObjCCategoryImplDecl
2189//===----------------------------------------------------------------------===//

2191void ObjCCategoryImplDecl::anchor() {}

2193ObjCCategoryImplDecl *
2194ObjCCategoryImplDecl::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);
2204}

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

2213ObjCCategoryDecl *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;
2218}

2220void ObjCImplDecl::anchor() {}

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

2228void 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;
2241}

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

2255/// FindPropertyImplDecl - This method looks up a previous ObjCPropertyImplDecl
2256/// added to the list of those properties \@synthesized/\@dynamic in this
2257/// category \@implementation block.
2258ObjCPropertyImplDecl *ObjCImplDecl::
2259FindPropertyImplDecl(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;
2283}

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

2291//===----------------------------------------------------------------------===//
2292// ObjCImplementationDecl
2293//===----------------------------------------------------------------------===//

2295void ObjCImplementationDecl::anchor() {}

2297ObjCImplementationDecl *
2298ObjCImplementationDecl::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);
2311}

2313ObjCImplementationDecl *
2314ObjCImplementationDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
return new (C, ID) ObjCImplementationDecl(nullptr, nullptr, nullptr,
                                          SourceLocation(), SourceLocation());
2317}

2319void 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;
}
2329}

2331ObjCImplementationDecl::init_const_iterator
2332ObjCImplementationDecl::init_begin() const {
return IvarInitializers.get(getASTContext().getExternalSource());
2334}

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

2342//===----------------------------------------------------------------------===//
2343// ObjCCompatibleAliasDecl
2344//===----------------------------------------------------------------------===//

2346void ObjCCompatibleAliasDecl::anchor() {}

2348ObjCCompatibleAliasDecl *
2349ObjCCompatibleAliasDecl::Create(ASTContext &C, DeclContext *DC,
                              SourceLocation L,
                              IdentifierInfo *Id,
                              ObjCInterfaceDecl* AliasedClass) {
return new (C, DC) ObjCCompatibleAliasDecl(DC, L, Id, AliasedClass);
2354}

2356ObjCCompatibleAliasDecl *
2357ObjCCompatibleAliasDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
return new (C, ID) ObjCCompatibleAliasDecl(nullptr, SourceLocation(),
                                           nullptr, nullptr);
2360}

2362//===----------------------------------------------------------------------===//
2363// ObjCPropertyDecl
2364//===----------------------------------------------------------------------===//

2366void ObjCPropertyDecl::anchor() {}

2368ObjCPropertyDecl *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);
2378}

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

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

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

2397//===----------------------------------------------------------------------===//
2398// ObjCPropertyImplDecl
2399//===----------------------------------------------------------------------===//

2401ObjCPropertyImplDecl *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);
2411}

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

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

return SourceRange(AtLoc, EndLoc);
2426}