/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/clang/lib/AST/DeclObjC.cpp

Bug Summary

File:	clang/lib/AST/DeclObjC.cpp
Warning:	line 1379, column 28 Called C++ object pointer is null
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name DeclObjC.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -mthread-model posix -mframe-pointer=none -relaxed-aliasing -fmath-errno -fno-rounding-math -masm-verbose -mconstructor-aliases -munwind-tables -target-cpu x86-64 -dwarf-column-info -fno-split-dwarf-inlining -debugger-tuning=gdb -ffunction-sections -fdata-sections -resource-dir /usr/lib/llvm-11/lib/clang/11.0.0 -D CLANG_VENDOR="Debian " -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/build-llvm/tools/clang/lib/AST -I /build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/clang/lib/AST -I /build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/clang/include -I /build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/build-llvm/tools/clang/include -I /build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/build-llvm/include -I /build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/include -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0/backward -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-11/lib/clang/11.0.0/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir /build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/build-llvm/tools/clang/lib/AST -fdebug-prefix-map=/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347=. -ferror-limit 19 -fmessage-length 0 -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -fobjc-runtime=gcc -fno-common -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -o /tmp/scan-build-2020-03-09-184146-41876-1 -x c++ /build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/clang/lib/AST/DeclObjC.cpp
1//===- DeclObjC.cpp - ObjC Declaration AST Node Implementation ------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file implements the Objective-C related Decl classes.
10//
11//===----------------------------------------------------------------------===//

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

38using namespace clang;

40//===----------------------------------------------------------------------===//
41// ObjCListBase
42//===----------------------------------------------------------------------===//

44void 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);
51}

53void 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);
61}

63//===----------------------------------------------------------------------===//
64// ObjCInterfaceDecl
65//===----------------------------------------------------------------------===//

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

74void ObjCContainerDecl::anchor() {}

76/// getIvarDecl - This method looks up an ivar in this ContextDecl.
77///
78ObjCIvarDecl *
79ObjCContainerDecl::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;
87}

89// Get the local instance/class method declared in this interface.
90ObjCMethodDecl *
91ObjCContainerDecl::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->isHidden() && !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;
116}

118/// This routine returns 'true' if a user declared setter method was
119/// found in the class, its protocols, its super classes or categories.
120/// It also returns 'true' if one of its categories has declared a 'readwrite'
121/// property.  This is because, user must provide a setter method for the
122/// category's 'readwrite' property.
123bool 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() & ObjCPropertyDecl::OBJC_PR_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;
173}

175ObjCPropertyDecl *
176ObjCPropertyDecl::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->isHidden())
      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;
221}

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

233/// FindPropertyDeclaration - Finds declaration of the property given its name
234/// in 'PropertyId' and returns it. It returns 0, if not found.
235ObjCPropertyDecl *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->isHidden())
      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;
303}

305void ObjCInterfaceDecl::anchor() {}

307ObjCTypeParamList *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;
326}

328void 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);
335}

337ObjCInterfaceDecl *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;
355}

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

return SourceLocation();
362}

364/// FindPropertyVisibleInPrimaryClass - Finds declaration of the property
365/// with name 'PropertyId' in the primary class; including those in protocols
366/// (direct or indirect) used by the primary class.
367ObjCPropertyDecl *
368ObjCInterfaceDecl::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;
390}

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

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

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

432void 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);
471}

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

486static 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;
504}

506bool 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((data().InheritedDesignatedInitializers != DefinitionData::IDI_Unknown
) ? static_cast<void> (0) : __assert_fail ("data().InheritedDesignatedInitializers != DefinitionData::IDI_Unknown"
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/clang/lib/AST/DeclObjC.cpp"
, 530, __PRETTY_FUNCTION__))
           != DefinitionData::IDI_Unknown)((data().InheritedDesignatedInitializers != DefinitionData::IDI_Unknown
) ? static_cast<void> (0) : __assert_fail ("data().InheritedDesignatedInitializers != DefinitionData::IDI_Unknown"
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/clang/lib/AST/DeclObjC.cpp"
, 530, __PRETTY_FUNCTION__));
  return data().InheritedDesignatedInitializers ==
      DefinitionData::IDI_Inherited;
}

llvm_unreachable("unexpected InheritedDesignatedInitializers value")::llvm::llvm_unreachable_internal("unexpected InheritedDesignatedInitializers value"
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/clang/lib/AST/DeclObjC.cpp"
, 535);
536}

538void 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);
}
558}

560bool 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;
598}

600void ObjCInterfaceDecl::allocateDefinitionData() {
assert(!hasDefinition() && "ObjC class already has a definition")((!hasDefinition() && "ObjC class already has a definition"
) ? static_cast<void> (0) : __assert_fail ("!hasDefinition() && \"ObjC class already has a definition\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/clang/lib/AST/DeclObjC.cpp"
, 601, __PRETTY_FUNCTION__));
Data.setPointer(new (getASTContext()) DefinitionData());
Data.getPointer()->Definition = this;

// Make the type point at the definition, now that we have one.
if (TypeForDecl)
  cast<ObjCInterfaceType>(TypeForDecl)->Decl = this;
608}

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

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

620ObjCIvarDecl *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;
646}

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

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

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

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

774//===----------------------------------------------------------------------===//
775// ObjCMethodDecl
776//===----------------------------------------------------------------------===//

778ObjCMethodDecl::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);
806}

808ObjCMethodDecl *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);
819}

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

826bool ObjCMethodDecl::isDirectMethod() const {
return hasAttr<ObjCDirectAttr>();
828}

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

835bool 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;
841}

843bool 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;
853}

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

859void ObjCMethodDecl::setAsRedeclaration(const ObjCMethodDecl *PrevMethod) {
assert(PrevMethod)((PrevMethod) ? static_cast<void> (0) : __assert_fail (
"PrevMethod", "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/clang/lib/AST/DeclObjC.cpp"
, 860, __PRETTY_FUNCTION__));
getASTContext().setObjCMethodRedeclaration(PrevMethod, this);
setIsRedeclaration(true);
PrevMethod->setHasRedeclaration(true);
864}

866void 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());
882}

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

890void ObjCMethodDecl::setMethodParams(ASTContext &C,
                                   ArrayRef<ParmVarDecl*> Params,
                                   ArrayRef<SourceLocation> SelLocs) {
assert((!SelLocs.empty() || isImplicit()) &&(((!SelLocs.empty() || isImplicit()) && "No selector locs for non-implicit method"
) ? static_cast<void> (0) : __assert_fail ("(!SelLocs.empty() || isImplicit()) && \"No selector locs for non-implicit method\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/clang/lib/AST/DeclObjC.cpp"
, 894, __PRETTY_FUNCTION__))
       "No selector locs for non-implicit method")(((!SelLocs.empty() || isImplicit()) && "No selector locs for non-implicit method"
) ? static_cast<void> (0) : __assert_fail ("(!SelLocs.empty() || isImplicit()) && \"No selector locs for non-implicit method\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/clang/lib/AST/DeclObjC.cpp"
, 894, __PRETTY_FUNCTION__));
if (isImplicit())
  return setParamsAndSelLocs(C, Params, llvm::None);

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

setParamsAndSelLocs(C, Params, SelLocs);
904}

906/// A definition will return its interface declaration.
907/// An interface declaration will return its definition.
908/// Otherwise it will return itself.
909ObjCMethodDecl *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());
}

return Redecl ? Redecl : this;
955}

957ObjCMethodDecl *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());
  return MD ? MD : this;
}

return this;
989}

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

997ObjCMethodFamily 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;
1087}

1089QualType 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())((isClassMethod()) ? static_cast<void> (0) : __assert_fail
 ("isClassMethod()", "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/clang/lib/AST/DeclObjC.cpp"
, 1125, __PRETTY_FUNCTION__));
    // 'self' is always const in class methods.
    selfTy = selfTy.withConst();
    selfIsPseudoStrong = true;
  }
}
return selfTy;
1132}

1134void 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));
1153}

1155ObjCInterfaceDecl *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", "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/clang/lib/AST/DeclObjC.cpp"
, 1164);
1165}

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

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

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

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

1188static 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);
}
1246}

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

1255static void collectOverriddenMethodsSlow(const ObjCMethodDecl *Method,
                        SmallVectorImpl<const ObjCMethodDecl *> &overridden) {
assert(Method->isOverriding())((Method->isOverriding()) ? static_cast<void> (0) : __assert_fail
 ("Method->isOverriding()", "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/clang/lib/AST/DeclObjC.cpp"
, 1257, __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);
}
1294}

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

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

if (Method->isOverriding()) {
  collectOverriddenMethodsSlow(Method, Overridden);
  assert(!Overridden.empty() &&((!Overridden.empty() && "ObjCMethodDecl's overriding bit is not as expected"
) ? static_cast<void> (0) : __assert_fail ("!Overridden.empty() && \"ObjCMethodDecl's overriding bit is not as expected\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/clang/lib/AST/DeclObjC.cpp"
, 1308, __PRETTY_FUNCTION__))
         "ObjCMethodDecl's overriding bit is not as expected")((!Overridden.empty() && "ObjCMethodDecl's overriding bit is not as expected"
) ? static_cast<void> (0) : __assert_fail ("!Overridden.empty() && \"ObjCMethodDecl's overriding bit is not as expected\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/clang/lib/AST/DeclObjC.cpp"
, 1308, __PRETTY_FUNCTION__));
}
1310}

1312const ObjCPropertyDecl *
1313ObjCMethodDecl::findPropertyDecl(bool CheckOverrides) const {
Selector Sel = getSelector();
unsigned NumArgs = Sel.getNumArgs();
if (NumArgs > 1)
1
Assuming 'NumArgs' is <= 1→
2
←
Taking false branch→
  return nullptr;

if (isPropertyAccessor()) {
3
←
Assuming the condition is true→
4
←
Taking true branch→
  const auto *Container = cast<ObjCContainerDecl>(getParent());
5
←
The object is a 'ObjCContainerDecl'→
  // For accessor stubs, go back to the interface.
  if (auto *ImplDecl6.1
'ImplDecl' is null
 = dyn_cast<ObjCImplDecl>(Container))
6
←
Assuming 'Container' is not a 'ObjCImplDecl'→
7
←
Taking false branch→
    if (isSynthesizedAccessorStub())
      Container = ImplDecl->getClassInterface();

  bool IsGetter = (NumArgs == 0);
8
←
Assuming 'NumArgs' is not equal to 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) {
10
←
Assuming 'IsInstance' is true→
11
←
Taking true branch→
      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;
12
←
Returning null pointer, which participates in a condition later→
  };

  // Look in the container we were given.
  if (const auto *Found13.1
'Found' is null
 = findMatchingProperty(Container))
9
←
Calling 'operator()'→
13
←
Returning from 'operator()'→
14
←
Taking false branch→
    return Found;

  // If we're in a category or extension, look in the main class.
  const ObjCInterfaceDecl *ClassDecl = nullptr;
  if (const auto *Category15.1
'Category' is null
 = dyn_cast<ObjCCategoryDecl>(Container)) {
15
←
Assuming 'Container' is not a 'ObjCCategoryDecl'→
16
←
Taking false branch→
    ClassDecl = Category->getClassInterface();
    if (const auto *Found = findMatchingProperty(ClassDecl))
      return Found;
  } else {
    // Determine whether the container is a class.
    ClassDecl = dyn_cast<ObjCInterfaceDecl>(Container);
17
←
Assuming 'Container' is not a 'ObjCInterfaceDecl'→
18
←
Null pointer value stored to 'ClassDecl'→
  }

  // If we have a class, check its visible extensions.
  if (ClassDecl18.1
'ClassDecl' is null
) {
19
←
Taking false branch→
    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")((isSynthesizedAccessorStub() && "expected an accessor stub"
) ? static_cast<void> (0) : __assert_fail ("isSynthesizedAccessorStub() && \"expected an accessor stub\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/clang/lib/AST/DeclObjC.cpp"
, 1378, __PRETTY_FUNCTION__));
20
←
Assuming the condition is true→
21
←
'?' condition is true→
  for (const auto *Cat : ClassDecl->known_categories()) {
22
←
Called C++ object pointer is null
    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!"
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/clang/lib/AST/DeclObjC.cpp"
, 1387);
}

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

1404//===----------------------------------------------------------------------===//
1405// ObjCTypeParamDecl
1406//===----------------------------------------------------------------------===//

1408void ObjCTypeParamDecl::anchor() {}

1410ObjCTypeParamDecl *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;
1424}

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

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

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

return SourceRange(startLoc);
1445}

1447//===----------------------------------------------------------------------===//
1448// ObjCTypeParamList
1449//===----------------------------------------------------------------------===//
1450ObjCTypeParamList::ObjCTypeParamList(SourceLocation lAngleLoc,
                                   ArrayRef<ObjCTypeParamDecl *> typeParams,
                                   SourceLocation rAngleLoc)
  : NumParams(typeParams.size()) {
Brackets.Begin = lAngleLoc.getRawEncoding();
Brackets.End = rAngleLoc.getRawEncoding();
std::copy(typeParams.begin(), typeParams.end(), begin());
1457}

1459ObjCTypeParamList *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);
1468}

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

1477//===----------------------------------------------------------------------===//
1478// ObjCInterfaceDecl
1479//===----------------------------------------------------------------------===//

1481ObjCInterfaceDecl *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;
1495}

1497ObjCInterfaceDecl *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;
1504}

1506ObjCInterfaceDecl::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);
1523}

1525void ObjCInterfaceDecl::LoadExternalDefinition() const {
assert(data().ExternallyCompleted && "Class is not externally completed")((data().ExternallyCompleted && "Class is not externally completed"
) ? static_cast<void> (0) : __assert_fail ("data().ExternallyCompleted && \"Class is not externally completed\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/clang/lib/AST/DeclObjC.cpp"
, 1526, __PRETTY_FUNCTION__));
data().ExternallyCompleted = false;
getASTContext().getExternalSource()->CompleteType(
                                      const_cast<ObjCInterfaceDecl *>(this));
1530}

1532void ObjCInterfaceDecl::setExternallyCompleted() {
assert(getASTContext().getExternalSource() &&((getASTContext().getExternalSource() && "Class can't be externally completed without an external source"
) ? static_cast<void> (0) : __assert_fail ("getASTContext().getExternalSource() && \"Class can't be externally completed without an external source\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/clang/lib/AST/DeclObjC.cpp"
, 1534, __PRETTY_FUNCTION__))
       "Class can't be externally completed without an external source")((getASTContext().getExternalSource() && "Class can't be externally completed without an external source"
) ? static_cast<void> (0) : __assert_fail ("getASTContext().getExternalSource() && \"Class can't be externally completed without an external source\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/clang/lib/AST/DeclObjC.cpp"
, 1534, __PRETTY_FUNCTION__));
assert(hasDefinition() &&((hasDefinition() && "Forward declarations can't be externally completed"
) ? static_cast<void> (0) : __assert_fail ("hasDefinition() && \"Forward declarations can't be externally completed\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/clang/lib/AST/DeclObjC.cpp"
, 1536, __PRETTY_FUNCTION__))
       "Forward declarations can't be externally completed")((hasDefinition() && "Forward declarations can't be externally completed"
) ? static_cast<void> (0) : __assert_fail ("hasDefinition() && \"Forward declarations can't be externally completed\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/clang/lib/AST/DeclObjC.cpp"
, 1536, __PRETTY_FUNCTION__));
data().ExternallyCompleted = true;
1538}

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

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

return data().HasDesignatedInitializers;
1555}

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

return getName();
1563}

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

return getName();
1572}

1574ObjCImplementationDecl *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;
1585}

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

1591namespace {

1593struct SynthesizeIvarChunk {
uint64_t Size;
ObjCIvarDecl *Ivar;

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

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

1606} // namespace

1608/// all_declared_ivar_begin - return first ivar declared in this class,
1609/// its extensions and its implementation. Lazily build the list on first
1610/// access.
1611///
1612/// Caveat: The list returned by this method reflects the current
1613/// state of the parser. The cache will be updated for every ivar
1614/// added by an extension or the implementation when they are
1615/// encountered.
1616/// See also ObjCIvarDecl::Create().
1617ObjCIvarDecl *ObjCInterfaceDecl::all_declared_ivar_begin() {
// FIXME: Should make sure no callers ever do this.
if (!hasDefinition())
  return nullptr;

ObjCIvarDecl *curIvar = nullptr;
if (!data().IvarList) {
  if (!ivar_empty()) {
    ObjCInterfaceDecl::ivar_iterator I = ivar_begin(), E = ivar_end();
    data().IvarList = *I; ++I;
    for (curIvar = data().IvarList; I != E; curIvar = *I, ++I)
      curIvar->setNextIvar(*I);
  }

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

// cached and complete!
if (!data().IvarListMissingImplementation)
    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;
1682}

1684/// FindCategoryDeclaration - Finds category declaration in the list of
1685/// categories for this class and returns it. Name of the category is passed
1686/// in 'CategoryId'. If category not found, return 0;
1687///
1688ObjCCategoryDecl *
1689ObjCInterfaceDecl::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;
1702}

1704ObjCMethodDecl *
1705ObjCInterfaceDecl::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;
1713}

1715ObjCMethodDecl *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;
1723}

1725/// ClassImplementsProtocol - Checks that 'lProto' protocol
1726/// has been implemented in IDecl class, its super class or categories (if
1727/// lookupCategory is true).
1728bool 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;
1765}

1767//===----------------------------------------------------------------------===//
1768// ObjCIvarDecl
1769//===----------------------------------------------------------------------===//

1771void ObjCIvarDecl::anchor() {}

1773ObjCIvarDecl *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) ||(((isa<ObjCInterfaceDecl>(DC) || isa<ObjCImplementationDecl
>(DC) || isa<ObjCCategoryDecl>(DC)) && "Invalid ivar decl context!"
) ? static_cast<void> (0) : __assert_fail ("(isa<ObjCInterfaceDecl>(DC) || isa<ObjCImplementationDecl>(DC) || isa<ObjCCategoryDecl>(DC)) && \"Invalid ivar decl context!\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/clang/lib/AST/DeclObjC.cpp"
, 1792, __PRETTY_FUNCTION__))
          isa<ObjCCategoryDecl>(DC)) &&(((isa<ObjCInterfaceDecl>(DC) || isa<ObjCImplementationDecl
>(DC) || isa<ObjCCategoryDecl>(DC)) && "Invalid ivar decl context!"
) ? static_cast<void> (0) : __assert_fail ("(isa<ObjCInterfaceDecl>(DC) || isa<ObjCImplementationDecl>(DC) || isa<ObjCCategoryDecl>(DC)) && \"Invalid ivar decl context!\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/clang/lib/AST/DeclObjC.cpp"
, 1792, __PRETTY_FUNCTION__))
         "Invalid ivar decl context!")(((isa<ObjCInterfaceDecl>(DC) || isa<ObjCImplementationDecl
>(DC) || isa<ObjCCategoryDecl>(DC)) && "Invalid ivar decl context!"
) ? static_cast<void> (0) : __assert_fail ("(isa<ObjCInterfaceDecl>(DC) || isa<ObjCImplementationDecl>(DC) || isa<ObjCCategoryDecl>(DC)) && \"Invalid ivar decl context!\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/clang/lib/AST/DeclObjC.cpp"
, 1792, __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);
1807}

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

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

switch (DC->getKind()) {
default:
case ObjCCategoryImpl:
case ObjCProtocol:
  llvm_unreachable("invalid ivar container!")::llvm::llvm_unreachable_internal("invalid ivar container!", "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/clang/lib/AST/DeclObjC.cpp"
, 1822);

  // Ivars can only appear in class extension categories.
case ObjCCategory: {
  const auto *CD = cast<ObjCCategoryDecl>(DC);
  assert(CD->IsClassExtension() && "invalid container for ivar!")((CD->IsClassExtension() && "invalid container for ivar!"
) ? static_cast<void> (0) : __assert_fail ("CD->IsClassExtension() && \"invalid container for ivar!\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/clang/lib/AST/DeclObjC.cpp"
, 1827, __PRETTY_FUNCTION__));
  return CD->getClassInterface();
}

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

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

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

1844//===----------------------------------------------------------------------===//
1845// ObjCAtDefsFieldDecl
1846//===----------------------------------------------------------------------===//

1848void ObjCAtDefsFieldDecl::anchor() {}

1850ObjCAtDefsFieldDecl
1851*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);
1855}

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

1864//===----------------------------------------------------------------------===//
1865// ObjCProtocolDecl
1866//===----------------------------------------------------------------------===//

1868void ObjCProtocolDecl::anchor() {}

1870ObjCProtocolDecl::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;
1879}

1881ObjCProtocolDecl *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;
1890}

1892ObjCProtocolDecl *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;
1899}

1901ObjCProtocolDecl *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;
1912}

1914// lookupMethod - Lookup a instance/class method in the protocol and protocols
1915// it inherited.
1916ObjCMethodDecl *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->isHidden())
  return nullptr;

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

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

1935void ObjCProtocolDecl::allocateDefinitionData() {
assert(!Data.getPointer() && "Protocol already has a definition!")((!Data.getPointer() && "Protocol already has a definition!"
) ? static_cast<void> (0) : __assert_fail ("!Data.getPointer() && \"Protocol already has a definition!\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/clang/lib/AST/DeclObjC.cpp"
, 1936, __PRETTY_FUNCTION__));
Data.setPointer(new (getASTContext()) DefinitionData);
Data.getPointer()->Definition = this;
1939}

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

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

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

1965void 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);
}
1983}

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

return getName();
1991}

1993//===----------------------------------------------------------------------===//
1994// ObjCCategoryDecl
1995//===----------------------------------------------------------------------===//

1997void ObjCCategoryDecl::anchor() {}

1999ObjCCategoryDecl::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);
2010}

2012ObjCCategoryDecl *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;
2036}

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

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

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

2054void 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);
2061}

2063//===----------------------------------------------------------------------===//
2064// ObjCCategoryImplDecl
2065//===----------------------------------------------------------------------===//

2067void ObjCCategoryImplDecl::anchor() {}

2069ObjCCategoryImplDecl *
2070ObjCCategoryImplDecl::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);
2080}

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

2089ObjCCategoryDecl *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;
2094}

2096void ObjCImplDecl::anchor() {}

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

2104void 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;
2117}

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

2131/// FindPropertyImplDecl - This method looks up a previous ObjCPropertyImplDecl
2132/// added to the list of those properties \@synthesized/\@dynamic in this
2133/// category \@implementation block.
2134ObjCPropertyImplDecl *ObjCImplDecl::
2135FindPropertyImplDecl(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;
2159}

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

2167//===----------------------------------------------------------------------===//
2168// ObjCImplementationDecl
2169//===----------------------------------------------------------------------===//

2171void ObjCImplementationDecl::anchor() {}

2173ObjCImplementationDecl *
2174ObjCImplementationDecl::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);
2187}

2189ObjCImplementationDecl *
2190ObjCImplementationDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
return new (C, ID) ObjCImplementationDecl(nullptr, nullptr, nullptr,
                                          SourceLocation(), SourceLocation());
2193}

2195void 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;
}
2205}

2207ObjCImplementationDecl::init_const_iterator
2208ObjCImplementationDecl::init_begin() const {
return IvarInitializers.get(getASTContext().getExternalSource());
2210}

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

2218//===----------------------------------------------------------------------===//
2219// ObjCCompatibleAliasDecl
2220//===----------------------------------------------------------------------===//

2222void ObjCCompatibleAliasDecl::anchor() {}

2224ObjCCompatibleAliasDecl *
2225ObjCCompatibleAliasDecl::Create(ASTContext &C, DeclContext *DC,
                              SourceLocation L,
                              IdentifierInfo *Id,
                              ObjCInterfaceDecl* AliasedClass) {
return new (C, DC) ObjCCompatibleAliasDecl(DC, L, Id, AliasedClass);
2230}

2232ObjCCompatibleAliasDecl *
2233ObjCCompatibleAliasDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
return new (C, ID) ObjCCompatibleAliasDecl(nullptr, SourceLocation(),
                                           nullptr, nullptr);
2236}

2238//===----------------------------------------------------------------------===//
2239// ObjCPropertyDecl
2240//===----------------------------------------------------------------------===//

2242void ObjCPropertyDecl::anchor() {}

2244ObjCPropertyDecl *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);
2254}

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

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

2268//===----------------------------------------------------------------------===//
2269// ObjCPropertyImplDecl
2270//===----------------------------------------------------------------------===//

2272ObjCPropertyImplDecl *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);
2282}

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

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

return SourceRange(AtLoc, EndLoc);
2297}