/usr/src/gnu/usr.bin/clang/libclangAST/../../../llvm/clang/lib/AST/DeclObjC.cpp

Bug Summary

File:	src/gnu/usr.bin/clang/libclangAST/../../../llvm/clang/lib/AST/DeclObjC.cpp
Warning:	line 1674, column 11 Called C++ object pointer is null

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple amd64-unknown-openbsd7.0 -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 -mrelocation-model static -mframe-pointer=all -relaxed-aliasing -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/gnu/usr.bin/clang/libclangAST/obj -resource-dir /usr/local/lib/clang/13.0.0 -I /usr/src/gnu/usr.bin/clang/libclangAST/obj/../include/clang/AST -I /usr/src/gnu/usr.bin/clang/libclangAST/../../../llvm/clang/include -I /usr/src/gnu/usr.bin/clang/libclangAST/../../../llvm/llvm/include -I /usr/src/gnu/usr.bin/clang/libclangAST/../include -I /usr/src/gnu/usr.bin/clang/libclangAST/obj -I /usr/src/gnu/usr.bin/clang/libclangAST/obj/../include -D NDEBUG -D __STDC_LIMIT_MACROS -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D LLVM_PREFIX="/usr" -internal-isystem /usr/include/c++/v1 -internal-isystem /usr/local/lib/clang/13.0.0/include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir=/usr/src/gnu/usr.bin/clang/libclangAST/obj -ferror-limit 19 -fvisibility-inlines-hidden -fwrapv -stack-protector 2 -fno-rtti -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/ben/Projects/vmm/scan-build/2022-01-12-194120-40624-1 -x c++ /usr/src/gnu/usr.bin/clang/libclangAST/../../../llvm/clang/lib/AST/DeclObjC.cpp

/usr/src/gnu/usr.bin/clang/libclangAST/../../../llvm/clang/lib/AST/DeclObjC.cpp

→

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

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

39using namespace clang;

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

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

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

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

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

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

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

75void ObjCContainerDecl::anchor() {}

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

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

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

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

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

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

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

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

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

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

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

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

return nullptr;
223}

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

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

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

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

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

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

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

307void ObjCInterfaceDecl::anchor() {}

309ObjCTypeParamList *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;
328}

330void 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);
337}

339ObjCInterfaceDecl *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;
357}

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

return SourceLocation();
364}

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

394void 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.
412}

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

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

434void 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);
473}

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

488static 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;
506}

508bool 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((void)0)
           != DefinitionData::IDI_Unknown)((void)0);
  return data().InheritedDesignatedInitializers ==
      DefinitionData::IDI_Inherited;
}

llvm_unreachable("unexpected InheritedDesignatedInitializers value")__builtin_unreachable();
538}

540void 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);
}
560}

562bool 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;
600}

602void ObjCInterfaceDecl::allocateDefinitionData() {
assert(!hasDefinition() && "ObjC class already has a definition")((void)0);
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;
610}

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

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

622ObjCIvarDecl *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;
648}

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

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

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

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

776//===----------------------------------------------------------------------===//
777// ObjCMethodDecl
778//===----------------------------------------------------------------------===//

780ObjCMethodDecl::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);
808}

810ObjCMethodDecl *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);
821}

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

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

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

838bool 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;
844}

846bool 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;
856}

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

862void ObjCMethodDecl::setAsRedeclaration(const ObjCMethodDecl *PrevMethod) {
assert(PrevMethod)((void)0);
getASTContext().setObjCMethodRedeclaration(PrevMethod, this);
setIsRedeclaration(true);
PrevMethod->setHasRedeclaration(true);
867}

869void 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());
885}

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

893void ObjCMethodDecl::setMethodParams(ASTContext &C,
                                   ArrayRef<ParmVarDecl*> Params,
                                   ArrayRef<SourceLocation> SelLocs) {
assert((!SelLocs.empty() || isImplicit()) &&((void)0)
       "No selector locs for non-implicit method")((void)0);
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);
907}

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

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

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

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

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

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

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

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

return Redecl ? Redecl : this;
959}

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

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

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

return this;
994}

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

1002ObjCMethodFamily 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;
1092}

1094QualType 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())((void)0);
    // 'self' is always const in class methods.
    selfTy = selfTy.withConst();
    selfIsPseudoStrong = true;
  }
}
return selfTy;
1137}

1139void 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));
1158}

1160ObjCInterfaceDecl *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")__builtin_unreachable();
1170}

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

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

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

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

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

1201static 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);
}
1259}

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

1268static void collectOverriddenMethodsSlow(const ObjCMethodDecl *Method,
                        SmallVectorImpl<const ObjCMethodDecl *> &overridden) {
assert(Method->isOverriding())((void)0);

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);
}
1307}

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

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

if (Method->isOverriding()) {
  collectOverriddenMethodsSlow(Method, Overridden);
  assert(!Overridden.empty() &&((void)0)
         "ObjCMethodDecl's overriding bit is not as expected")((void)0);
}
1324}

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

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

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

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

    return nullptr;
  };

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

  // If we're in a category or extension, look in the main class.
  const ObjCInterfaceDecl *ClassDecl = nullptr;
  if (const auto *Category = dyn_cast<ObjCCategoryDecl>(Container)) {
    ClassDecl = Category->getClassInterface();
    if (const auto *Found = findMatchingProperty(ClassDecl))
      return Found;
  } else {
    // Determine whether the container is a class.
    ClassDecl = cast<ObjCInterfaceDecl>(Container);
  }
  assert(ClassDecl && "Failed to find main class")((void)0);

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

  assert(isSynthesizedAccessorStub() && "expected an accessor stub")((void)0);

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

  llvm_unreachable("Marked as a property accessor but no property found!")__builtin_unreachable();
}

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

1416//===----------------------------------------------------------------------===//
1417// ObjCTypeParamDecl
1418//===----------------------------------------------------------------------===//

1420void ObjCTypeParamDecl::anchor() {}

1422ObjCTypeParamDecl *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;
1436}

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

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

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

return SourceRange(startLoc);
1457}

1459//===----------------------------------------------------------------------===//
1460// ObjCTypeParamList
1461//===----------------------------------------------------------------------===//
1462ObjCTypeParamList::ObjCTypeParamList(SourceLocation lAngleLoc,
                                   ArrayRef<ObjCTypeParamDecl *> typeParams,
                                   SourceLocation rAngleLoc)
  : Brackets(lAngleLoc, rAngleLoc), NumParams(typeParams.size()) {
std::copy(typeParams.begin(), typeParams.end(), begin());
1467}

1469ObjCTypeParamList *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);
1478}

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

1487//===----------------------------------------------------------------------===//
1488// ObjCInterfaceDecl
1489//===----------------------------------------------------------------------===//

1491ObjCInterfaceDecl *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;
1505}

1507ObjCInterfaceDecl *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;
1514}

1516ObjCInterfaceDecl::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);
1533}

1535void ObjCInterfaceDecl::LoadExternalDefinition() const {
assert(data().ExternallyCompleted && "Class is not externally completed")((void)0);
data().ExternallyCompleted = false;
getASTContext().getExternalSource()->CompleteType(
                                      const_cast<ObjCInterfaceDecl *>(this));
1540}

1542void ObjCInterfaceDecl::setExternallyCompleted() {
assert(getASTContext().getExternalSource() &&((void)0)
       "Class can't be externally completed without an external source")((void)0);
assert(hasDefinition() &&((void)0)
       "Forward declarations can't be externally completed")((void)0);
data().ExternallyCompleted = true;
1548}

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

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

return data().HasDesignatedInitializers;
1565}

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

return getName();
1573}

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

return getName();
1582}

1584ObjCImplementationDecl *ObjCInterfaceDecl::getImplementation() const {
if (const ObjCInterfaceDecl *Def = getDefinition()) {
14
←
Calling 'ObjCInterfaceDecl::getDefinition'→
18
←
Returning from 'ObjCInterfaceDecl::getDefinition'→
19
←
Assuming 'Def' is non-null→
20
←
Taking true branch→
  if (data().ExternallyCompleted)
21
←
Assuming field 'ExternallyCompleted' is 0→
22
←
Taking false branch→
    LoadExternalDefinition();

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

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

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

1601namespace {

1603struct SynthesizeIvarChunk {
uint64_t Size;
ObjCIvarDecl *Ivar;

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

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

1616} // namespace

1618/// all_declared_ivar_begin - return first ivar declared in this class,
1619/// its extensions and its implementation. Lazily build the list on first
1620/// access.
1621///
1622/// Caveat: The list returned by this method reflects the current
1623/// state of the parser. The cache will be updated for every ivar
1624/// added by an extension or the implementation when they are
1625/// encountered.
1626/// See also ObjCIvarDecl::Create().
1627ObjCIvarDecl *ObjCInterfaceDecl::all_declared_ivar_begin() {
// FIXME: Should make sure no callers ever do this.
if (!hasDefinition())
1
Calling 'ObjCInterfaceDecl::hasDefinition'→
5
←
Returning from 'ObjCInterfaceDecl::hasDefinition'→
6
←
Assuming the condition is false→
7
←
Taking false branch→
  return nullptr;

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

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

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

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

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

1694/// FindCategoryDeclaration - Finds category declaration in the list of
1695/// categories for this class and returns it. Name of the category is passed
1696/// in 'CategoryId'. If category not found, return 0;
1697///
1698ObjCCategoryDecl *
1699ObjCInterfaceDecl::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;
1712}

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

1725ObjCMethodDecl *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;
1733}

1735/// ClassImplementsProtocol - Checks that 'lProto' protocol
1736/// has been implemented in IDecl class, its super class or categories (if
1737/// lookupCategory is true).
1738bool 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;
1775}

1777//===----------------------------------------------------------------------===//
1778// ObjCIvarDecl
1779//===----------------------------------------------------------------------===//

1781void ObjCIvarDecl::anchor() {}

1783ObjCIvarDecl *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) ||((void)0)
          isa<ObjCCategoryDecl>(DC)) &&((void)0)
         "Invalid ivar decl context!")((void)0);
  // 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);
1817}

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

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

switch (DC->getKind()) {
default:
case ObjCCategoryImpl:
case ObjCProtocol:
  llvm_unreachable("invalid ivar container!")__builtin_unreachable();

  // Ivars can only appear in class extension categories.
case ObjCCategory: {
  const auto *CD = cast<ObjCCategoryDecl>(DC);
  assert(CD->IsClassExtension() && "invalid container for ivar!")((void)0);
  return CD->getClassInterface();
}

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

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

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

1854//===----------------------------------------------------------------------===//
1855// ObjCAtDefsFieldDecl
1856//===----------------------------------------------------------------------===//

1858void ObjCAtDefsFieldDecl::anchor() {}

1860ObjCAtDefsFieldDecl
1861*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);
1865}

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

1874//===----------------------------------------------------------------------===//
1875// ObjCProtocolDecl
1876//===----------------------------------------------------------------------===//

1878void ObjCProtocolDecl::anchor() {}

1880ObjCProtocolDecl::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;
1889}

1891ObjCProtocolDecl *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;
1900}

1902ObjCProtocolDecl *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;
1909}

1911bool ObjCProtocolDecl::isNonRuntimeProtocol() const {
return hasAttr<ObjCNonRuntimeProtocolAttr>();
1913}

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

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

1932ObjCProtocolDecl *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;
1943}

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

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

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

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

1966void ObjCProtocolDecl::allocateDefinitionData() {
assert(!Data.getPointer() && "Protocol already has a definition!")((void)0);
Data.setPointer(new (getASTContext()) DefinitionData);
Data.getPointer()->Definition = this;
1970}

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

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

1980void 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);
}
1994}

1996void 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);
}
2014}

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

return getName();
2022}

2024//===----------------------------------------------------------------------===//
2025// ObjCCategoryDecl
2026//===----------------------------------------------------------------------===//

2028void ObjCCategoryDecl::anchor() {}

2030ObjCCategoryDecl::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);
2041}

2043ObjCCategoryDecl *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;
2067}

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

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

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

2085void 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);
2092}

2094//===----------------------------------------------------------------------===//
2095// ObjCCategoryImplDecl
2096//===----------------------------------------------------------------------===//

2098void ObjCCategoryImplDecl::anchor() {}

2100ObjCCategoryImplDecl *
2101ObjCCategoryImplDecl::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);
2111}

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

2120ObjCCategoryDecl *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;
2125}

2127void ObjCImplDecl::anchor() {}

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

2135void 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;
2148}

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

2162/// FindPropertyImplDecl - This method looks up a previous ObjCPropertyImplDecl
2163/// added to the list of those properties \@synthesized/\@dynamic in this
2164/// category \@implementation block.
2165ObjCPropertyImplDecl *ObjCImplDecl::
2166FindPropertyImplDecl(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;
2190}

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

2198//===----------------------------------------------------------------------===//
2199// ObjCImplementationDecl
2200//===----------------------------------------------------------------------===//

2202void ObjCImplementationDecl::anchor() {}

2204ObjCImplementationDecl *
2205ObjCImplementationDecl::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);
2218}

2220ObjCImplementationDecl *
2221ObjCImplementationDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
return new (C, ID) ObjCImplementationDecl(nullptr, nullptr, nullptr,
                                          SourceLocation(), SourceLocation());
2224}

2226void 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;
}
2236}

2238ObjCImplementationDecl::init_const_iterator
2239ObjCImplementationDecl::init_begin() const {
return IvarInitializers.get(getASTContext().getExternalSource());
2241}

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

2249//===----------------------------------------------------------------------===//
2250// ObjCCompatibleAliasDecl
2251//===----------------------------------------------------------------------===//

2253void ObjCCompatibleAliasDecl::anchor() {}

2255ObjCCompatibleAliasDecl *
2256ObjCCompatibleAliasDecl::Create(ASTContext &C, DeclContext *DC,
                              SourceLocation L,
                              IdentifierInfo *Id,
                              ObjCInterfaceDecl* AliasedClass) {
return new (C, DC) ObjCCompatibleAliasDecl(DC, L, Id, AliasedClass);
2261}

2263ObjCCompatibleAliasDecl *
2264ObjCCompatibleAliasDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
return new (C, ID) ObjCCompatibleAliasDecl(nullptr, SourceLocation(),
                                           nullptr, nullptr);
2267}

2269//===----------------------------------------------------------------------===//
2270// ObjCPropertyDecl
2271//===----------------------------------------------------------------------===//

2273void ObjCPropertyDecl::anchor() {}

2275ObjCPropertyDecl *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);
2285}

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

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

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

2304//===----------------------------------------------------------------------===//
2305// ObjCPropertyImplDecl
2306//===----------------------------------------------------------------------===//

2308ObjCPropertyImplDecl *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);
2318}

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

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

return SourceRange(AtLoc, EndLoc);
2333}

←

/usr/src/gnu/usr.bin/clang/libclangAST/../../../llvm/clang/include/clang/AST/DeclObjC.h

→

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

13#ifndef LLVM_CLANG_AST_DECLOBJC_H
14#define LLVM_CLANG_AST_DECLOBJC_H

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

44namespace clang {

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

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

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

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

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

78/// ObjCList - This is a simple template class used to hold various lists of
79/// decls etc, which is heavily used by the ObjC front-end.  This only use case
80/// this supports is setting the list all at once and then reading elements out
81/// of it.
82template <typename T>
83class ObjCList : public ObjCListBase {
84public:
void set(T* const* InList, unsigned Elts, ASTContext &Ctx) {
  ObjCListBase::set(reinterpret_cast<void*const*>(InList), Elts, Ctx);
}

using iterator = T* const *;

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

T* operator[](unsigned Idx) const {
  assert(Idx < NumElts && "Invalid access")((void)0);
  return (T*)List[Idx];
}
98};

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

using ObjCList<ObjCProtocolDecl>::set;

107public:
ObjCProtocolList() = default;

using loc_iterator = const SourceLocation *;

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

void set(ObjCProtocolDecl* const* InList, unsigned Elts,
         const SourceLocation *Locs, ASTContext &Ctx);
117};

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

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

146private:
/// Return type of this method.
QualType MethodDeclType;

/// Type source information for the return type.
TypeSourceInfo *ReturnTInfo;

/// Array of ParmVarDecls for the formal parameters of this method
/// and optionally followed by selector locations.
void *ParamsAndSelLocs = nullptr;
unsigned NumParams = 0;

/// List of attributes for this method declaration.
SourceLocation DeclEndLoc; // the location of the ';' or '{'.

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

/// SelfDecl - Decl for the implicit self parameter. This is lazily
/// constructed by createImplicitParams.
ImplicitParamDecl *SelfDecl = nullptr;

/// CmdDecl - Decl for the implicit _cmd parameter. This is lazily
/// constructed by createImplicitParams.
ImplicitParamDecl *CmdDecl = nullptr;

ObjCMethodDecl(SourceLocation beginLoc, SourceLocation endLoc,
               Selector SelInfo, QualType T, TypeSourceInfo *ReturnTInfo,
               DeclContext *contextDecl, bool isInstance = true,
               bool isVariadic = false, bool isPropertyAccessor = false,
               bool isSynthesizedAccessorStub = false, 
               bool isImplicitlyDeclared = false, bool isDefined = false,
               ImplementationControl impControl = None,
               bool HasRelatedResultType = false);

SelectorLocationsKind getSelLocsKind() const {
  return static_cast<SelectorLocationsKind>(ObjCMethodDeclBits.SelLocsKind);
}

void setSelLocsKind(SelectorLocationsKind Kind) {
  ObjCMethodDeclBits.SelLocsKind = Kind;
}

bool hasStandardSelLocs() const {
  return getSelLocsKind() != SelLoc_NonStandard;
}

/// Get a pointer to the stored selector identifiers locations array.
/// No locations will be stored if HasStandardSelLocs is true.
SourceLocation *getStoredSelLocs() {
  return reinterpret_cast<SourceLocation *>(getParams() + NumParams);
}
const SourceLocation *getStoredSelLocs() const {
  return reinterpret_cast<const SourceLocation *>(getParams() + NumParams);
}

/// Get a pointer to the stored selector identifiers locations array.
/// No locations will be stored if HasStandardSelLocs is true.
ParmVarDecl **getParams() {
  return reinterpret_cast<ParmVarDecl **>(ParamsAndSelLocs);
}
const ParmVarDecl *const *getParams() const {
  return reinterpret_cast<const ParmVarDecl *const *>(ParamsAndSelLocs);
}

/// Get the number of stored selector identifiers locations.
/// No locations will be stored if HasStandardSelLocs is true.
unsigned getNumStoredSelLocs() const {
  if (hasStandardSelLocs())
    return 0;
  return getNumSelectorLocs();
}

void setParamsAndSelLocs(ASTContext &C,
                         ArrayRef<ParmVarDecl*> Params,
                         ArrayRef<SourceLocation> SelLocs);

/// A definition will return its interface declaration.
/// An interface declaration will return its definition.
/// Otherwise it will return itself.
ObjCMethodDecl *getNextRedeclarationImpl() override;

228public:
friend class ASTDeclReader;
friend class ASTDeclWriter;

static ObjCMethodDecl *
Create(ASTContext &C, SourceLocation beginLoc, SourceLocation endLoc,
       Selector SelInfo, QualType T, TypeSourceInfo *ReturnTInfo,
       DeclContext *contextDecl, bool isInstance = true,
       bool isVariadic = false, bool isPropertyAccessor = false,
       bool isSynthesizedAccessorStub = false,
       bool isImplicitlyDeclared = false, bool isDefined = false,
       ImplementationControl impControl = None,
       bool HasRelatedResultType = false);

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

ObjCMethodDecl *getCanonicalDecl() override;
const ObjCMethodDecl *getCanonicalDecl() const {
  return const_cast<ObjCMethodDecl*>(this)->getCanonicalDecl();
}

ObjCDeclQualifier getObjCDeclQualifier() const {
  return static_cast<ObjCDeclQualifier>(ObjCMethodDeclBits.objcDeclQualifier);
}

void setObjCDeclQualifier(ObjCDeclQualifier QV) {
  ObjCMethodDeclBits.objcDeclQualifier = QV;
}

/// Determine whether this method has a result type that is related
/// to the message receiver's type.
bool hasRelatedResultType() const {
  return ObjCMethodDeclBits.RelatedResultType;
}

/// Note whether this method has a related result type.
void setRelatedResultType(bool RRT = true) {
  ObjCMethodDeclBits.RelatedResultType = RRT;
}

/// True if this is a method redeclaration in the same interface.
bool isRedeclaration() const { return ObjCMethodDeclBits.IsRedeclaration; }
void setIsRedeclaration(bool RD) { ObjCMethodDeclBits.IsRedeclaration = RD; }
void setAsRedeclaration(const ObjCMethodDecl *PrevMethod);

/// True if redeclared in the same interface.
bool hasRedeclaration() const { return ObjCMethodDeclBits.HasRedeclaration; }
void setHasRedeclaration(bool HRD) const {
  ObjCMethodDeclBits.HasRedeclaration = HRD;
}

/// Returns the location where the declarator ends. It will be
/// the location of ';' for a method declaration and the location of '{'
/// for a method definition.
SourceLocation getDeclaratorEndLoc() const { return DeclEndLoc; }

// Location information, modeled after the Stmt API.
SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) { return getLocation(); }
SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__));
SourceRange getSourceRange() const override LLVM_READONLY__attribute__((__pure__)) {
  return SourceRange(getLocation(), getEndLoc());
}

SourceLocation getSelectorStartLoc() const {
  if (isImplicit())
    return getBeginLoc();
  return getSelectorLoc(0);
}

SourceLocation getSelectorLoc(unsigned Index) const {
  assert(Index < getNumSelectorLocs() && "Index out of range!")((void)0);
  if (hasStandardSelLocs())
    return getStandardSelectorLoc(Index, getSelector(),
                                 getSelLocsKind() == SelLoc_StandardWithSpace,
                                  parameters(),
                                 DeclEndLoc);
  return getStoredSelLocs()[Index];
}

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

unsigned getNumSelectorLocs() const {
  if (isImplicit())
    return 0;
  Selector Sel = getSelector();
  if (Sel.isUnarySelector())
    return 1;
  return Sel.getNumArgs();
}

ObjCInterfaceDecl *getClassInterface();
const ObjCInterfaceDecl *getClassInterface() const {
  return const_cast<ObjCMethodDecl*>(this)->getClassInterface();
}

/// If this method is declared or implemented in a category, return
/// that category.
ObjCCategoryDecl *getCategory();
const ObjCCategoryDecl *getCategory() const {
  return const_cast<ObjCMethodDecl*>(this)->getCategory();
}

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

QualType getReturnType() const { return MethodDeclType; }
void setReturnType(QualType T) { MethodDeclType = T; }
SourceRange getReturnTypeSourceRange() const;

/// Determine the type of an expression that sends a message to this
/// function. This replaces the type parameters with the types they would
/// get if the receiver was parameterless (e.g. it may replace the type
/// parameter with 'id').
QualType getSendResultType() const;

/// Determine the type of an expression that sends a message to this
/// function with the given receiver type.
QualType getSendResultType(QualType receiverType) const;

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

// Iterator access to formal parameters.
unsigned param_size() const { return NumParams; }

using param_const_iterator = const ParmVarDecl *const *;
using param_iterator = ParmVarDecl *const *;
using param_range = llvm::iterator_range<param_iterator>;
using param_const_range = llvm::iterator_range<param_const_iterator>;

param_const_iterator param_begin() const {
  return param_const_iterator(getParams());
}

param_const_iterator param_end() const {
  return param_const_iterator(getParams() + NumParams);
}

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

// This method returns and of the parameters which are part of the selector
// name mangling requirements.
param_const_iterator sel_param_end() const {
  return param_begin() + getSelector().getNumArgs();
}

// ArrayRef access to formal parameters.  This should eventually
// replace the iterator interface above.
ArrayRef<ParmVarDecl*> parameters() const {
  return llvm::makeArrayRef(const_cast<ParmVarDecl**>(getParams()),
                            NumParams);
}

ParmVarDecl *getParamDecl(unsigned Idx) {
  assert(Idx < NumParams && "Index out of bounds!")((void)0);
  return getParams()[Idx];
}
const ParmVarDecl *getParamDecl(unsigned Idx) const {
  return const_cast<ObjCMethodDecl *>(this)->getParamDecl(Idx);
}

/// Sets the method's parameters and selector source locations.
/// If the method is implicit (not coming from source) \p SelLocs is
/// ignored.
void setMethodParams(ASTContext &C,
                     ArrayRef<ParmVarDecl*> Params,
                     ArrayRef<SourceLocation> SelLocs = llvm::None);

// Iterator access to parameter types.
struct GetTypeFn {
  QualType operator()(const ParmVarDecl *PD) const { return PD->getType(); }
};

using param_type_iterator =
    llvm::mapped_iterator<param_const_iterator, GetTypeFn>;

param_type_iterator param_type_begin() const {
  return llvm::map_iterator(param_begin(), GetTypeFn());
}

param_type_iterator param_type_end() const {
  return llvm::map_iterator(param_end(), GetTypeFn());
}

/// createImplicitParams - Used to lazily create the self and cmd
/// implicit parameters. This must be called prior to using getSelfDecl()
/// or getCmdDecl(). The call is ignored if the implicit parameters
/// have already been created.
void createImplicitParams(ASTContext &Context, const ObjCInterfaceDecl *ID);

/// \return the type for \c self and set \arg selfIsPseudoStrong and
/// \arg selfIsConsumed accordingly.
QualType getSelfType(ASTContext &Context, const ObjCInterfaceDecl *OID,
                     bool &selfIsPseudoStrong, bool &selfIsConsumed) const;

ImplicitParamDecl * getSelfDecl() const { return SelfDecl; }
void setSelfDecl(ImplicitParamDecl *SD) { SelfDecl = SD; }
ImplicitParamDecl * getCmdDecl() const { return CmdDecl; }
void setCmdDecl(ImplicitParamDecl *CD) { CmdDecl = CD; }

/// Determines the family of this method.
ObjCMethodFamily getMethodFamily() const;

bool isInstanceMethod() const { return ObjCMethodDeclBits.IsInstance; }
void setInstanceMethod(bool isInst) {
  ObjCMethodDeclBits.IsInstance = isInst;
}

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

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

bool isPropertyAccessor() const {
  return ObjCMethodDeclBits.IsPropertyAccessor;
}

void setPropertyAccessor(bool isAccessor) {
  ObjCMethodDeclBits.IsPropertyAccessor = isAccessor;
}

bool isSynthesizedAccessorStub() const {
  return ObjCMethodDeclBits.IsSynthesizedAccessorStub;
}

void setSynthesizedAccessorStub(bool isSynthesizedAccessorStub) {
  ObjCMethodDeclBits.IsSynthesizedAccessorStub = isSynthesizedAccessorStub;
}

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

/// Whether this method overrides any other in the class hierarchy.
///
/// A method is said to override any method in the class's
/// base classes, its protocols, or its categories' protocols, that has
/// the same selector and is of the same kind (class or instance).
/// A method in an implementation is not considered as overriding the same
/// method in the interface or its categories.
bool isOverriding() const { return ObjCMethodDeclBits.IsOverriding; }
void setOverriding(bool IsOver) { ObjCMethodDeclBits.IsOverriding = IsOver; }

/// Return overridden methods for the given \p Method.
///
/// An ObjC method is considered to override any method in the class's
/// base classes (and base's categories), its protocols, or its categories'
/// protocols, that has
/// the same selector and is of the same kind (class or instance).
/// A method in an implementation is not considered as overriding the same
/// method in the interface or its categories.
void getOverriddenMethods(
                   SmallVectorImpl<const ObjCMethodDecl *> &Overridden) const;

/// True if the method was a definition but its body was skipped.
bool hasSkippedBody() const { return ObjCMethodDeclBits.HasSkippedBody; }
void setHasSkippedBody(bool Skipped = true) {
  ObjCMethodDeclBits.HasSkippedBody = Skipped;
}

/// True if the method is tagged as objc_direct
bool isDirectMethod() const;

/// Returns the property associated with this method's selector.
///
/// Note that even if this particular method is not marked as a property
/// accessor, it is still possible for it to match a property declared in a
/// superclass. Pass \c false if you only want to check the current class.
const ObjCPropertyDecl *findPropertyDecl(bool CheckOverrides = true) const;

// Related to protocols declared in  \@protocol
void setDeclImplementation(ImplementationControl ic) {
  ObjCMethodDeclBits.DeclImplementation = ic;
}

ImplementationControl getImplementationControl() const {
  return ImplementationControl(ObjCMethodDeclBits.DeclImplementation);
}

bool isOptional() const {
  return getImplementationControl() == Optional;
}

/// Returns true if this specific method declaration is marked with the
/// designated initializer attribute.
bool isThisDeclarationADesignatedInitializer() const;

/// Returns true if the method selector resolves to a designated initializer
/// in the class's interface.
///
/// \param InitMethod if non-null and the function returns true, it receives
/// the method declaration that was marked with the designated initializer
/// attribute.
bool isDesignatedInitializerForTheInterface(
    const ObjCMethodDecl **InitMethod = nullptr) const;

/// Determine whether this method has a body.
bool hasBody() const override { return Body.isValid(); }

/// Retrieve the body of this method, if it has one.
Stmt *getBody() const override;

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

CompoundStmt *getCompoundBody() { return (CompoundStmt*)getBody(); }
void setBody(Stmt *B) { Body = B; }

/// Returns whether this specific method is a definition.
bool isThisDeclarationADefinition() const { return hasBody(); }

/// Is this method defined in the NSObject base class?
bool definedInNSObject(const ASTContext &) const;

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

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

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

553/// Describes the variance of a given generic parameter.
554enum class ObjCTypeParamVariance : uint8_t {
/// The parameter is invariant: must match exactly.
Invariant,

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

/// The parameter is contravariant, e.g., X<T> is a subtype of X<U>
/// when the type parameter is covariant and U is a subtype of T.
Contravariant,
565};

567/// Represents the declaration of an Objective-C type parameter.
568///
569/// \code
570/// @interface NSDictionary<Key : id<NSCopying>, Value>
571/// @end
572/// \endcode
573///
574/// In the example above, both \c Key and \c Value are represented by
575/// \c ObjCTypeParamDecl. \c Key has an explicit bound of \c id<NSCopying>,
576/// while \c Value gets an implicit bound of \c id.
577///
578/// Objective-C type parameters are typedef-names in the grammar,
579class ObjCTypeParamDecl : public TypedefNameDecl {
/// Index of this type parameter in the type parameter list.
unsigned Index : 14;

/// The variance of the type parameter.
unsigned Variance : 2;

/// The location of the variance, if any.
SourceLocation VarianceLoc;

/// The location of the ':', which will be valid when the bound was
/// explicitly specified.
SourceLocation ColonLoc;

ObjCTypeParamDecl(ASTContext &ctx, DeclContext *dc,
                  ObjCTypeParamVariance variance, SourceLocation varianceLoc,
                  unsigned index,
                  SourceLocation nameLoc, IdentifierInfo *name,
                  SourceLocation colonLoc, TypeSourceInfo *boundInfo)
    : TypedefNameDecl(ObjCTypeParam, ctx, dc, nameLoc, nameLoc, name,
                      boundInfo),
      Index(index), Variance(static_cast<unsigned>(variance)),
      VarianceLoc(varianceLoc), ColonLoc(colonLoc) {}

void anchor() override;

605public:
friend class ASTDeclReader;
friend class ASTDeclWriter;

static ObjCTypeParamDecl *Create(ASTContext &ctx, DeclContext *dc,
                                 ObjCTypeParamVariance variance,
                                 SourceLocation varianceLoc,
                                 unsigned index,
                                 SourceLocation nameLoc,
                                 IdentifierInfo *name,
                                 SourceLocation colonLoc,
                                 TypeSourceInfo *boundInfo);
static ObjCTypeParamDecl *CreateDeserialized(ASTContext &ctx, unsigned ID);

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

/// Determine the variance of this type parameter.
ObjCTypeParamVariance getVariance() const {
  return static_cast<ObjCTypeParamVariance>(Variance);
}

/// Set the variance of this type parameter.
void setVariance(ObjCTypeParamVariance variance) {
  Variance = static_cast<unsigned>(variance);
}

/// Retrieve the location of the variance keyword.
SourceLocation getVarianceLoc() const { return VarianceLoc; }

/// Retrieve the index into its type parameter list.
unsigned getIndex() const { return Index; }

/// Whether this type parameter has an explicitly-written type bound, e.g.,
/// "T : NSView".
bool hasExplicitBound() const { return ColonLoc.isValid(); }

/// Retrieve the location of the ':' separating the type parameter name
/// from the explicitly-specified bound.
SourceLocation getColonLoc() const { return ColonLoc; }

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

650/// Stores a list of Objective-C type parameters for a parameterized class
651/// or a category/extension thereof.
652///
653/// \code
654/// @interface NSArray<T> // stores the <T>
655/// @end
656/// \endcode
657class ObjCTypeParamList final
  : private llvm::TrailingObjects<ObjCTypeParamList, ObjCTypeParamDecl *> {
/// Location of the left and right angle brackets.
SourceRange Brackets;
/// The number of parameters in the list, which are tail-allocated.
unsigned NumParams;

ObjCTypeParamList(SourceLocation lAngleLoc,
                  ArrayRef<ObjCTypeParamDecl *> typeParams,
                  SourceLocation rAngleLoc);

668public:
friend TrailingObjects;

/// Create a new Objective-C type parameter list.
static ObjCTypeParamList *create(ASTContext &ctx,
                                 SourceLocation lAngleLoc,
                                 ArrayRef<ObjCTypeParamDecl *> typeParams,
                                 SourceLocation rAngleLoc);

/// Iterate through the type parameters in the list.
using iterator = ObjCTypeParamDecl **;

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

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

/// Determine the number of type parameters in this list.
unsigned size() const { return NumParams; }

// Iterate through the type parameters in the list.
using const_iterator = ObjCTypeParamDecl * const *;

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

const_iterator end() const {
  return begin() + size();
}

ObjCTypeParamDecl *front() const {
  assert(size() > 0 && "empty Objective-C type parameter list")((void)0);
  return *begin();
}

ObjCTypeParamDecl *back() const {
  assert(size() > 0 && "empty Objective-C type parameter list")((void)0);
  return *(end() - 1);
}

SourceLocation getLAngleLoc() const { return Brackets.getBegin(); }
SourceLocation getRAngleLoc() const { return Brackets.getEnd(); }
SourceRange getSourceRange() const { return Brackets; }

/// Gather the default set of type arguments to be substituted for
/// these type parameters when dealing with an unspecialized type.
void gatherDefaultTypeArgs(SmallVectorImpl<QualType> &typeArgs) const;
715};

717enum class ObjCPropertyQueryKind : uint8_t {
OBJC_PR_query_unknown = 0x00,
OBJC_PR_query_instance,
OBJC_PR_query_class
721};

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

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

736private:
// location of \@property
SourceLocation AtLoc;

// location of '(' starting attribute list or null.
SourceLocation LParenLoc;

QualType DeclType;
TypeSourceInfo *DeclTypeSourceInfo;
unsigned PropertyAttributes : NumObjCPropertyAttrsBits;
unsigned PropertyAttributesAsWritten : NumObjCPropertyAttrsBits;

// \@required/\@optional
unsigned PropertyImplementation : 2;

// getter name of NULL if no getter
Selector GetterName;

// setter name of NULL if no setter
Selector SetterName;

// location of the getter attribute's value
SourceLocation GetterNameLoc;

// location of the setter attribute's value
SourceLocation SetterNameLoc;

// Declaration of getter instance method
ObjCMethodDecl *GetterMethodDecl = nullptr;

// Declaration of setter instance method
ObjCMethodDecl *SetterMethodDecl = nullptr;

// Synthesize ivar for this property
ObjCIvarDecl *PropertyIvarDecl = nullptr;

ObjCPropertyDecl(DeclContext *DC, SourceLocation L, IdentifierInfo *Id,
                 SourceLocation AtLocation, SourceLocation LParenLocation,
                 QualType T, TypeSourceInfo *TSI, PropertyControl propControl)
    : NamedDecl(ObjCProperty, DC, L, Id), AtLoc(AtLocation),
      LParenLoc(LParenLocation), DeclType(T), DeclTypeSourceInfo(TSI),
      PropertyAttributes(ObjCPropertyAttribute::kind_noattr),
      PropertyAttributesAsWritten(ObjCPropertyAttribute::kind_noattr),
      PropertyImplementation(propControl), GetterName(Selector()),
      SetterName(Selector()) {}

782public:
static ObjCPropertyDecl *Create(ASTContext &C, DeclContext *DC,
                                SourceLocation L,
                                IdentifierInfo *Id, SourceLocation AtLocation,
                                SourceLocation LParenLocation,
                                QualType T,
                                TypeSourceInfo *TSI,
                                PropertyControl propControl = None);

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

SourceLocation getAtLoc() const { return AtLoc; }
void setAtLoc(SourceLocation L) { AtLoc = L; }

SourceLocation getLParenLoc() const { return LParenLoc; }
void setLParenLoc(SourceLocation L) { LParenLoc = L; }

TypeSourceInfo *getTypeSourceInfo() const { return DeclTypeSourceInfo; }

QualType getType() const { return DeclType; }

void setType(QualType T, TypeSourceInfo *TSI) {
  DeclType = T;
  DeclTypeSourceInfo = TSI;
}

/// Retrieve the type when this property is used with a specific base object
/// type.
QualType getUsageType(QualType objectType) const;

ObjCPropertyAttribute::Kind getPropertyAttributes() const {
  return ObjCPropertyAttribute::Kind(PropertyAttributes);
}

void setPropertyAttributes(ObjCPropertyAttribute::Kind PRVal) {
  PropertyAttributes |= PRVal;
}

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

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

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

// Helper methods for accessing attributes.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

ObjCIvarDecl *getPropertyIvarDecl() const {
  return PropertyIvarDecl;
}

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

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

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

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

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

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

void anchor() override;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

void anchor() override;

void LoadExternalDefinition() const;

DefinitionData &data() const {
  assert(Data.getPointer() && "Declaration has no definition!")((void)0);
  return *Data.getPointer();
}

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

using redeclarable_base = Redeclarable<ObjCInterfaceDecl>;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

const ObjCProtocolList &getReferencedProtocols() const {
  assert(hasDefinition() && "Caller did not check for forward reference!")((void)0);
  if (data().ExternallyCompleted)
    LoadExternalDefinition();

  return data().ReferencedProtocols;
}

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

ObjCCategoryDecl *FindCategoryDeclaration(IdentifierInfo *CategoryId) const;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  return Data.getPointer();
4
←
Returning value, which participates in a condition later→
}

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

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

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

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

  return nullptr;
}

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

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

  return data().SuperClassTInfo;
}

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

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

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

  void findAcceptableCategory();

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

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

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

  filtered_category_iterator &operator++();

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

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

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

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

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

using visible_categories_range =
    llvm::iterator_range<visible_categories_iterator>;

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

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

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

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

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

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

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

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

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

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

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

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

using visible_extensions_range =
    llvm::iterator_range<visible_extensions_iterator>;

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

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

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

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

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

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

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

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

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

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

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

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

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

  return data().CategoryList;
}

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

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

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

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

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

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

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

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

ObjCProtocolDecl *lookupNestedProtocol(IdentifierInfo *Name);

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

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

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

ObjCInterfaceDecl *lookupInheritedClass(const IdentifierInfo *ICName);

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

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

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

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

  return data().EndLoc;
}

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

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

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

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

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

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

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

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

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

1901private:
const ObjCInterfaceDecl *findInterfaceWithDesignatedInitializers() const;
bool inheritsDesignatedInitializers() const;
1904};

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

void anchor() override;

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

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

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

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

  /// Referenced protocols
  ObjCProtocolList ReferencedProtocols;
};

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

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

void anchor() override;

DefinitionData &data() const {
  assert(Data.getPointer() && "Objective-C protocol has no definition!")((void)0);
  return *Data.getPointer();
}

void allocateDefinitionData();

using redeclarable_base = Redeclarable<ObjCProtocolDecl>;

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

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

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

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

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

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

const ObjCProtocolList &getReferencedProtocols() const {
  assert(hasDefinition() && "No definition available!")((void)0);
  return data().ReferencedProtocols;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

ObjCProtocolDecl *lookupProtocolNamed(IdentifierInfo *PName);

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

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

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

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

  return Data.getPointer();
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

void anchor() override;

2294public:
friend class ASTDeclReader;
friend class ASTDeclWriter;

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

ObjCCategoryDecl *getNextClassCategory() const { return NextClassCategory; }

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

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

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

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

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

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

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

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

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

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

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

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

void anchor() override;

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

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

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

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

void addPropertyImplementation(ObjCPropertyImplDecl *property);

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

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

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

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

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

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

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

2470/// ObjCCategoryImplDecl - An object of this class encapsulates a category
2471/// \@implementation declaration. If a category class has declaration of a
2472/// property, its implementation must be specified in the category's
2473/// \@implementation declaration. Example:
2474/// \@interface I \@end
2475/// \@interface I(CATEGORY)
2476///    \@property int p1, d1;
2477/// \@end
2478/// \@implementation I(CATEGORY)
2479///  \@dynamic p1,d1;
2480/// \@end
2481///
2482/// ObjCCategoryImplDecl
2483class ObjCCategoryImplDecl : public ObjCImplDecl {
// Category name location
SourceLocation CategoryNameLoc;

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

void anchor() override;

2497public:
friend class ASTDeclReader;
friend class ASTDeclWriter;

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

ObjCCategoryDecl *getCategoryDecl() const;

SourceLocation getCategoryNameLoc() const { return CategoryNameLoc; }

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

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

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

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

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

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

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

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

void anchor() override;

2574public:
friend class ASTDeclReader;
friend class ASTDeclWriter;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/// getName - Get the name of identifier for the class interface associated
/// with this implementation as a StringRef.
//
// FIXME: This is a bad API, we are hiding NamedDecl::getName with a different
// meaning.
StringRef getName() const {
  assert(getIdentifier() && "Name is not a simple identifier")((void)0);
  return getIdentifier()->getName();
}

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

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

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

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

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

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

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

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

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

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

bool ivar_empty() const {
  return ivar_begin() == ivar_end();
28
←
Calling 'operator=='→
34
←
Returning from 'operator=='→
35
←
Returning zero, which participates in a condition later→
}

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

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

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

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

void anchor() override;

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

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

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

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

2737/// ObjCPropertyImplDecl - Represents implementation declaration of a property
2738/// in a class or category implementation block. For example:
2739/// \@synthesize prop1 = ivar1;
2740///
2741class ObjCPropertyImplDecl : public Decl {
2742public:
enum Kind {
  Synthesize,
  Dynamic
};

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

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

/// Property declaration being implemented
ObjCPropertyDecl *PropertyDecl;

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

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

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

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

ObjCPropertyImplDecl(DeclContext *DC, SourceLocation atLoc, SourceLocation L,
                     ObjCPropertyDecl *property,
                     Kind PK,
                     ObjCIvarDecl *ivarDecl,
                     SourceLocation ivarLoc)
    : Decl(ObjCPropertyImpl, DC, L), AtLoc(atLoc),
      IvarLoc(ivarLoc), PropertyDecl(property), PropertyIvarDecl(ivarDecl) {
  assert(PK == Dynamic || PropertyIvarDecl)((void)0);
}

2788public:
friend class ASTDeclReader;

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

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

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

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

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

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

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

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

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

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

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

Expr *getGetterCXXConstructor() const {
  return GetterCXXConstructor;
}

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

Expr *getSetterCXXAssignment() const {
  return SetterCXXAssignment;
}

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

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

2862template<bool (*Filter)(ObjCCategoryDecl *)>
2863void
2864ObjCInterfaceDecl::filtered_category_iterator<Filter>::
2865findAcceptableCategory() {
while (Current && !Filter(Current))
  Current = Current->getNextClassCategoryRaw();
2868}

2870template<bool (*Filter)(ObjCCategoryDecl *)>
2871inline ObjCInterfaceDecl::filtered_category_iterator<Filter> &
2872ObjCInterfaceDecl::filtered_category_iterator<Filter>::operator++() {
Current = Current->getNextClassCategoryRaw();
findAcceptableCategory();
return *this;
2876}

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

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

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

2890} // namespace clang

2892#endif // LLVM_CLANG_AST_DECLOBJC_H

←

/usr/src/gnu/usr.bin/clang/libclangAST/../../../llvm/clang/include/clang/AST/DeclBase.h

1	//===- DeclBase.h - Base Classes for representing declarations --- C++ --===//
2	//
3	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4	// See https://llvm.org/LICENSE.txt for license information.
5	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6	//
7	//===----------------------------------------------------------------------===//
8	//
9	// This file defines the Decl and DeclContext interfaces.
10	//
11	//===----------------------------------------------------------------------===//
12
13	#ifndef LLVM_CLANG_AST_DECLBASE_H
14	#define LLVM_CLANG_AST_DECLBASE_H
15
16	#include "clang/AST/ASTDumperUtils.h"
17	#include "clang/AST/AttrIterator.h"
18	#include "clang/AST/DeclarationName.h"
19	#include "clang/Basic/IdentifierTable.h"
20	#include "clang/Basic/LLVM.h"
21	#include "clang/Basic/SourceLocation.h"
22	#include "clang/Basic/Specifiers.h"
23	#include "llvm/ADT/ArrayRef.h"
24	#include "llvm/ADT/PointerIntPair.h"
25	#include "llvm/ADT/PointerUnion.h"
26	#include "llvm/ADT/iterator.h"
27	#include "llvm/ADT/iterator_range.h"
28	#include "llvm/Support/Casting.h"
29	#include "llvm/Support/Compiler.h"
30	#include "llvm/Support/PrettyStackTrace.h"
31	#include "llvm/Support/VersionTuple.h"
32	#include <algorithm>
33	#include <cassert>
34	#include <cstddef>
35	#include <iterator>
36	#include <string>
37	#include <type_traits>
38	#include <utility>
39
40	namespace clang {
41
42	class ASTContext;
43	class ASTMutationListener;
44	class Attr;
45	class BlockDecl;
46	class DeclContext;
47	class ExternalSourceSymbolAttr;
48	class FunctionDecl;
49	class FunctionType;
50	class IdentifierInfo;
51	enum Linkage : unsigned char;
52	class LinkageSpecDecl;
53	class Module;
54	class NamedDecl;
55	class ObjCCategoryDecl;
56	class ObjCCategoryImplDecl;
57	class ObjCContainerDecl;
58	class ObjCImplDecl;
59	class ObjCImplementationDecl;
60	class ObjCInterfaceDecl;
61	class ObjCMethodDecl;
62	class ObjCProtocolDecl;
63	struct PrintingPolicy;
64	class RecordDecl;
65	class SourceManager;
66	class Stmt;
67	class StoredDeclsMap;
68	class TemplateDecl;
69	class TemplateParameterList;
70	class TranslationUnitDecl;
71	class UsingDirectiveDecl;
72
73	/// Captures the result of checking the availability of a
74	/// declaration.
75	enum AvailabilityResult {
76	AR_Available = 0,
77	AR_NotYetIntroduced,
78	AR_Deprecated,
79	AR_Unavailable
80	};
81
82	/// Decl - This represents one declaration (or definition), e.g. a variable,
83	/// typedef, function, struct, etc.
84	///
85	/// Note: There are objects tacked on before the beginning of Decl
86	/// (and its subclasses) in its Decl::operator new(). Proper alignment
87	/// of all subclasses (not requiring more than the alignment of Decl) is
88	/// asserted in DeclBase.cpp.
89	class alignas(8) Decl {
90	public:
91	/// Lists the kind of concrete classes of Decl.
92	enum Kind {
93	#define DECL(DERIVED, BASE) DERIVED,
94	#define ABSTRACT_DECL(DECL)
95	#define DECL_RANGE(BASE, START, END) \
96	first##BASE = START, last##BASE = END,
97	#define LAST_DECL_RANGE(BASE, START, END) \
98	first##BASE = START, last##BASE = END
99	#include "clang/AST/DeclNodes.inc"
100	};
101
102	/// A placeholder type used to construct an empty shell of a
103	/// decl-derived type that will be filled in later (e.g., by some
104	/// deserialization method).
105	struct EmptyShell {};
106
107	/// IdentifierNamespace - The different namespaces in which
108	/// declarations may appear. According to C99 6.2.3, there are
109	/// four namespaces, labels, tags, members and ordinary
110	/// identifiers. C++ describes lookup completely differently:
111	/// certain lookups merely "ignore" certain kinds of declarations,
112	/// usually based on whether the declaration is of a type, etc.
113	///
114	/// These are meant as bitmasks, so that searches in
115	/// C++ can look into the "tag" namespace during ordinary lookup.
116	///
117	/// Decl currently provides 15 bits of IDNS bits.
118	enum IdentifierNamespace {
119	/// Labels, declared with 'x:' and referenced with 'goto x'.
120	IDNS_Label = 0x0001,
121
122	/// Tags, declared with 'struct foo;' and referenced with
123	/// 'struct foo'. All tags are also types. This is what
124	/// elaborated-type-specifiers look for in C.
125	/// This also contains names that conflict with tags in the
126	/// same scope but that are otherwise ordinary names (non-type
127	/// template parameters and indirect field declarations).
128	IDNS_Tag = 0x0002,
129
130	/// Types, declared with 'struct foo', typedefs, etc.
131	/// This is what elaborated-type-specifiers look for in C++,
132	/// but note that it's ill-formed to find a non-tag.
133	IDNS_Type = 0x0004,
134
135	/// Members, declared with object declarations within tag
136	/// definitions. In C, these can only be found by "qualified"
137	/// lookup in member expressions. In C++, they're found by
138	/// normal lookup.
139	IDNS_Member = 0x0008,
140
141	/// Namespaces, declared with 'namespace foo {}'.
142	/// Lookup for nested-name-specifiers find these.
143	IDNS_Namespace = 0x0010,
144
145	/// Ordinary names. In C, everything that's not a label, tag,
146	/// member, or function-local extern ends up here.
147	IDNS_Ordinary = 0x0020,
148
149	/// Objective C \@protocol.
150	IDNS_ObjCProtocol = 0x0040,
151
152	/// This declaration is a friend function. A friend function
153	/// declaration is always in this namespace but may also be in
154	/// IDNS_Ordinary if it was previously declared.
155	IDNS_OrdinaryFriend = 0x0080,
156
157	/// This declaration is a friend class. A friend class
158	/// declaration is always in this namespace but may also be in
159	/// IDNS_Tag\|IDNS_Type if it was previously declared.
160	IDNS_TagFriend = 0x0100,
161
162	/// This declaration is a using declaration. A using declaration
163	/// introduces a number of other declarations into the current
164	/// scope, and those declarations use the IDNS of their targets,
165	/// but the actual using declarations go in this namespace.
166	IDNS_Using = 0x0200,
167
168	/// This declaration is a C++ operator declared in a non-class
169	/// context. All such operators are also in IDNS_Ordinary.
170	/// C++ lexical operator lookup looks for these.
171	IDNS_NonMemberOperator = 0x0400,
172
173	/// This declaration is a function-local extern declaration of a
174	/// variable or function. This may also be IDNS_Ordinary if it
175	/// has been declared outside any function. These act mostly like
176	/// invisible friend declarations, but are also visible to unqualified
177	/// lookup within the scope of the declaring function.
178	IDNS_LocalExtern = 0x0800,
179
180	/// This declaration is an OpenMP user defined reduction construction.
181	IDNS_OMPReduction = 0x1000,
182
183	/// This declaration is an OpenMP user defined mapper.
184	IDNS_OMPMapper = 0x2000,
185	};
186
187	/// ObjCDeclQualifier - 'Qualifiers' written next to the return and
188	/// parameter types in method declarations. Other than remembering
189	/// them and mangling them into the method's signature string, these
190	/// are ignored by the compiler; they are consumed by certain
191	/// remote-messaging frameworks.
192	///
193	/// in, inout, and out are mutually exclusive and apply only to
194	/// method parameters. bycopy and byref are mutually exclusive and
195	/// apply only to method parameters (?). oneway applies only to
196	/// results. All of these expect their corresponding parameter to
197	/// have a particular type. None of this is currently enforced by
198	/// clang.
199	///
200	/// This should be kept in sync with ObjCDeclSpec::ObjCDeclQualifier.
201	enum ObjCDeclQualifier {
202	OBJC_TQ_None = 0x0,
203	OBJC_TQ_In = 0x1,
204	OBJC_TQ_Inout = 0x2,
205	OBJC_TQ_Out = 0x4,
206	OBJC_TQ_Bycopy = 0x8,
207	OBJC_TQ_Byref = 0x10,
208	OBJC_TQ_Oneway = 0x20,
209
210	/// The nullability qualifier is set when the nullability of the
211	/// result or parameter was expressed via a context-sensitive
212	/// keyword.
213	OBJC_TQ_CSNullability = 0x40
214	};
215
216	/// The kind of ownership a declaration has, for visibility purposes.
217	/// This enumeration is designed such that higher values represent higher
218	/// levels of name hiding.
219	enum class ModuleOwnershipKind : unsigned {
220	/// This declaration is not owned by a module.
221	Unowned,
222
223	/// This declaration has an owning module, but is globally visible
224	/// (typically because its owning module is visible and we know that
225	/// modules cannot later become hidden in this compilation).
226	/// After serialization and deserialization, this will be converted
227	/// to VisibleWhenImported.
228	Visible,
229
230	/// This declaration has an owning module, and is visible when that
231	/// module is imported.
232	VisibleWhenImported,
233
234	/// This declaration has an owning module, but is only visible to
235	/// lookups that occur within that module.
236	ModulePrivate
237	};
238
239	protected:
240	/// The next declaration within the same lexical
241	/// DeclContext. These pointers form the linked list that is
242	/// traversed via DeclContext's decls_begin()/decls_end().
243	///
244	/// The extra two bits are used for the ModuleOwnershipKind.
245	llvm::PointerIntPair<Decl *, 2, ModuleOwnershipKind> NextInContextAndBits;
246
247	private:
248	friend class DeclContext;
249
250	struct MultipleDC {
251	DeclContext *SemanticDC;
252	DeclContext *LexicalDC;
253	};
254
255	/// DeclCtx - Holds either a DeclContext* or a MultipleDC*.
256	/// For declarations that don't contain C++ scope specifiers, it contains
257	/// the DeclContext where the Decl was declared.
258	/// For declarations with C++ scope specifiers, it contains a MultipleDC*
259	/// with the context where it semantically belongs (SemanticDC) and the
260	/// context where it was lexically declared (LexicalDC).
261	/// e.g.:
262	///
263	/// namespace A {
264	/// void f(); // SemanticDC == LexicalDC == 'namespace A'
265	/// }
266	/// void A::f(); // SemanticDC == namespace 'A'
267	/// // LexicalDC == global namespace
268	llvm::PointerUnion<DeclContext, MultipleDC> DeclCtx;
269
270	bool isInSemaDC() const { return DeclCtx.is<DeclContext*>(); }
271	bool isOutOfSemaDC() const { return DeclCtx.is<MultipleDC*>(); }
272
273	MultipleDC *getMultipleDC() const {
274	return DeclCtx.get<MultipleDC*>();
275	}
276
277	DeclContext *getSemanticDC() const {
278	return DeclCtx.get<DeclContext*>();
279	}
280
281	/// Loc - The location of this decl.
282	SourceLocation Loc;
283
284	/// DeclKind - This indicates which class this is.
285	unsigned DeclKind : 7;
286
287	/// InvalidDecl - This indicates a semantic error occurred.
288	unsigned InvalidDecl : 1;
289
290	/// HasAttrs - This indicates whether the decl has attributes or not.
291	unsigned HasAttrs : 1;
292
293	/// Implicit - Whether this declaration was implicitly generated by
294	/// the implementation rather than explicitly written by the user.
295	unsigned Implicit : 1;
296
297	/// Whether this declaration was "used", meaning that a definition is
298	/// required.
299	unsigned Used : 1;
300
301	/// Whether this declaration was "referenced".
302	/// The difference with 'Used' is whether the reference appears in a
303	/// evaluated context or not, e.g. functions used in uninstantiated templates
304	/// are regarded as "referenced" but not "used".
305	unsigned Referenced : 1;
306
307	/// Whether this declaration is a top-level declaration (function,
308	/// global variable, etc.) that is lexically inside an objc container
309	/// definition.
310	unsigned TopLevelDeclInObjCContainer : 1;
311
312	/// Whether statistic collection is enabled.
313	static bool StatisticsEnabled;
314
315	protected:
316	friend class ASTDeclReader;
317	friend class ASTDeclWriter;
318	friend class ASTNodeImporter;
319	friend class ASTReader;
320	friend class CXXClassMemberWrapper;
321	friend class LinkageComputer;
322	template<typename decl_type> friend class Redeclarable;
323
324	/// Access - Used by C++ decls for the access specifier.
325	// NOTE: VC++ treats enums as signed, avoid using the AccessSpecifier enum
326	unsigned Access : 2;
327
328	/// Whether this declaration was loaded from an AST file.
329	unsigned FromASTFile : 1;
330
331	/// IdentifierNamespace - This specifies what IDNS_* namespace this lives in.
332	unsigned IdentifierNamespace : 14;
333
334	/// If 0, we have not computed the linkage of this declaration.
335	/// Otherwise, it is the linkage + 1.
336	mutable unsigned CacheValidAndLinkage : 3;
337
338	/// Allocate memory for a deserialized declaration.
339	///
340	/// This routine must be used to allocate memory for any declaration that is
341	/// deserialized from a module file.
342	///
343	/// \param Size The size of the allocated object.
344	/// \param Ctx The context in which we will allocate memory.
345	/// \param ID The global ID of the deserialized declaration.
346	/// \param Extra The amount of extra space to allocate after the object.
347	void *operator new(std::size_t Size, const ASTContext &Ctx, unsigned ID,
348	std::size_t Extra = 0);
349
350	/// Allocate memory for a non-deserialized declaration.
351	void *operator new(std::size_t Size, const ASTContext &Ctx,
352	DeclContext *Parent, std::size_t Extra = 0);
353
354	private:
355	bool AccessDeclContextSanity() const;
356
357	/// Get the module ownership kind to use for a local lexical child of \p DC,
358	/// which may be either a local or (rarely) an imported declaration.
359	static ModuleOwnershipKind getModuleOwnershipKindForChildOf(DeclContext *DC) {
360	if (DC) {
361	auto *D = cast<Decl>(DC);
362	auto MOK = D->getModuleOwnershipKind();
363	if (MOK != ModuleOwnershipKind::Unowned &&
364	(!D->isFromASTFile() \|\| D->hasLocalOwningModuleStorage()))
365	return MOK;
366	// If D is not local and we have no local module storage, then we don't
367	// need to track module ownership at all.
368	}
369	return ModuleOwnershipKind::Unowned;
370	}
371
372	public:
373	Decl() = delete;
374	Decl(const Decl&) = delete;
375	Decl(Decl &&) = delete;
376	Decl &operator=(const Decl&) = delete;
377	Decl &operator=(Decl&&) = delete;
378
379	protected:
380	Decl(Kind DK, DeclContext *DC, SourceLocation L)
381	: NextInContextAndBits(nullptr, getModuleOwnershipKindForChildOf(DC)),
382	DeclCtx(DC), Loc(L), DeclKind(DK), InvalidDecl(false), HasAttrs(false),
383	Implicit(false), Used(false), Referenced(false),
384	TopLevelDeclInObjCContainer(false), Access(AS_none), FromASTFile(0),
385	IdentifierNamespace(getIdentifierNamespaceForKind(DK)),
386	CacheValidAndLinkage(0) {
387	if (StatisticsEnabled) add(DK);
388	}
389
390	Decl(Kind DK, EmptyShell Empty)
391	: DeclKind(DK), InvalidDecl(false), HasAttrs(false), Implicit(false),
392	Used(false), Referenced(false), TopLevelDeclInObjCContainer(false),
393	Access(AS_none), FromASTFile(0),
394	IdentifierNamespace(getIdentifierNamespaceForKind(DK)),
395	CacheValidAndLinkage(0) {
396	if (StatisticsEnabled) add(DK);
397	}
398
399	virtual ~Decl();
400
401	/// Update a potentially out-of-date declaration.
402	void updateOutOfDate(IdentifierInfo &II) const;
403
404	Linkage getCachedLinkage() const {
405	return Linkage(CacheValidAndLinkage - 1);
406	}
407
408	void setCachedLinkage(Linkage L) const {
409	CacheValidAndLinkage = L + 1;
410	}
411
412	bool hasCachedLinkage() const {
413	return CacheValidAndLinkage;
414	}
415
416	public:
417	/// Source range that this declaration covers.
418	virtual SourceRange getSourceRange() const LLVM_READONLY__attribute__((__pure__)) {
419	return SourceRange(getLocation(), getLocation());
420	}
421
422	SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) {
423	return getSourceRange().getBegin();
424	}
425
426	SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) {
427	return getSourceRange().getEnd();
428	}
429
430	SourceLocation getLocation() const { return Loc; }
431	void setLocation(SourceLocation L) { Loc = L; }
432
433	Kind getKind() const { return static_cast<Kind>(DeclKind); }
434	const char *getDeclKindName() const;
435
436	Decl *getNextDeclInContext() { return NextInContextAndBits.getPointer(); }
437	const Decl *getNextDeclInContext() const {return NextInContextAndBits.getPointer();}
438
439	DeclContext *getDeclContext() {
440	if (isInSemaDC())
441	return getSemanticDC();
442	return getMultipleDC()->SemanticDC;
443	}
444	const DeclContext *getDeclContext() const {
445	return const_cast<Decl*>(this)->getDeclContext();
446	}
447
448	/// Find the innermost non-closure ancestor of this declaration,
449	/// walking up through blocks, lambdas, etc. If that ancestor is
450	/// not a code context (!isFunctionOrMethod()), returns null.
451	///
452	/// A declaration may be its own non-closure context.
453	Decl *getNonClosureContext();
454	const Decl *getNonClosureContext() const {
455	return const_cast<Decl*>(this)->getNonClosureContext();
456	}
457
458	TranslationUnitDecl *getTranslationUnitDecl();
459	const TranslationUnitDecl *getTranslationUnitDecl() const {
460	return const_cast<Decl*>(this)->getTranslationUnitDecl();
461	}
462
463	bool isInAnonymousNamespace() const;
464
465	bool isInStdNamespace() const;
466
467	ASTContext &getASTContext() const LLVM_READONLY__attribute__((__pure__));
468
469	/// Helper to get the language options from the ASTContext.
470	/// Defined out of line to avoid depending on ASTContext.h.
471	const LangOptions &getLangOpts() const LLVM_READONLY__attribute__((__pure__));
472
473	void setAccess(AccessSpecifier AS) {
474	Access = AS;
475	assert(AccessDeclContextSanity())((void)0);
476	}
477
478	AccessSpecifier getAccess() const {
479	assert(AccessDeclContextSanity())((void)0);
480	return AccessSpecifier(Access);
481	}
482
483	/// Retrieve the access specifier for this declaration, even though
484	/// it may not yet have been properly set.
485	AccessSpecifier getAccessUnsafe() const {
486	return AccessSpecifier(Access);
487	}
488
489	bool hasAttrs() const { return HasAttrs; }
490
491	void setAttrs(const AttrVec& Attrs) {
492	return setAttrsImpl(Attrs, getASTContext());
493	}
494
495	AttrVec &getAttrs() {
496	return const_cast<AttrVec&>(const_cast<const Decl*>(this)->getAttrs());
497	}
498
499	const AttrVec &getAttrs() const;
500	void dropAttrs();
501	void addAttr(Attr *A);
502
503	using attr_iterator = AttrVec::const_iterator;
504	using attr_range = llvm::iterator_range<attr_iterator>;
505
506	attr_range attrs() const {
507	return attr_range(attr_begin(), attr_end());
508	}
509
510	attr_iterator attr_begin() const {
511	return hasAttrs() ? getAttrs().begin() : nullptr;
512	}
513	attr_iterator attr_end() const {
514	return hasAttrs() ? getAttrs().end() : nullptr;
515	}
516
517	template <typename T>
518	void dropAttr() {
519	if (!HasAttrs) return;
520
521	AttrVec &Vec = getAttrs();
522	llvm::erase_if(Vec, [](Attr *A) { return isa<T>(A); });
523
524	if (Vec.empty())
525	HasAttrs = false;
526	}
527
528	template <typename T>
529	llvm::iterator_range<specific_attr_iterator<T>> specific_attrs() const {
530	return llvm::make_range(specific_attr_begin<T>(), specific_attr_end<T>());
531	}
532
533	template <typename T>
534	specific_attr_iterator<T> specific_attr_begin() const {
535	return specific_attr_iterator<T>(attr_begin());
536	}
537
538	template <typename T>
539	specific_attr_iterator<T> specific_attr_end() const {
540	return specific_attr_iterator<T>(attr_end());
541	}
542
543	template<typename T> T *getAttr() const {
544	return hasAttrs() ? getSpecificAttr<T>(getAttrs()) : nullptr;
545	}
546
547	template<typename T> bool hasAttr() const {
548	return hasAttrs() && hasSpecificAttr<T>(getAttrs());
549	}
550
551	/// getMaxAlignment - return the maximum alignment specified by attributes
552	/// on this decl, 0 if there are none.
553	unsigned getMaxAlignment() const;
554
555	/// setInvalidDecl - Indicates the Decl had a semantic error. This
556	/// allows for graceful error recovery.
557	void setInvalidDecl(bool Invalid = true);
558	bool isInvalidDecl() const { return (bool) InvalidDecl; }
559
560	/// isImplicit - Indicates whether the declaration was implicitly
561	/// generated by the implementation. If false, this declaration
562	/// was written explicitly in the source code.
563	bool isImplicit() const { return Implicit; }
564	void setImplicit(bool I = true) { Implicit = I; }
565
566	/// Whether any (re-)declaration of the entity was used, meaning that
567	/// a definition is required.
568	///
569	/// \param CheckUsedAttr When true, also consider the "used" attribute
570	/// (in addition to the "used" bit set by \c setUsed()) when determining
571	/// whether the function is used.
572	bool isUsed(bool CheckUsedAttr = true) const;
573
574	/// Set whether the declaration is used, in the sense of odr-use.
575	///
576	/// This should only be used immediately after creating a declaration.
577	/// It intentionally doesn't notify any listeners.
578	void setIsUsed() { getCanonicalDecl()->Used = true; }
579
580	/// Mark the declaration used, in the sense of odr-use.
581	///
582	/// This notifies any mutation listeners in addition to setting a bit
583	/// indicating the declaration is used.
584	void markUsed(ASTContext &C);
585
586	/// Whether any declaration of this entity was referenced.
587	bool isReferenced() const;
588
589	/// Whether this declaration was referenced. This should not be relied
590	/// upon for anything other than debugging.
591	bool isThisDeclarationReferenced() const { return Referenced; }
592
593	void setReferenced(bool R = true) { Referenced = R; }
594
595	/// Whether this declaration is a top-level declaration (function,
596	/// global variable, etc.) that is lexically inside an objc container
597	/// definition.
598	bool isTopLevelDeclInObjCContainer() const {
599	return TopLevelDeclInObjCContainer;
600	}
601
602	void setTopLevelDeclInObjCContainer(bool V = true) {
603	TopLevelDeclInObjCContainer = V;
604	}
605
606	/// Looks on this and related declarations for an applicable
607	/// external source symbol attribute.
608	ExternalSourceSymbolAttr *getExternalSourceSymbolAttr() const;
609
610	/// Whether this declaration was marked as being private to the
611	/// module in which it was defined.
612	bool isModulePrivate() const {
613	return getModuleOwnershipKind() == ModuleOwnershipKind::ModulePrivate;
614	}
615
616	/// Return true if this declaration has an attribute which acts as
617	/// definition of the entity, such as 'alias' or 'ifunc'.
618	bool hasDefiningAttr() const;
619
620	/// Return this declaration's defining attribute if it has one.
621	const Attr *getDefiningAttr() const;
622
623	protected:
624	/// Specify that this declaration was marked as being private
625	/// to the module in which it was defined.
626	void setModulePrivate() {
627	// The module-private specifier has no effect on unowned declarations.
628	// FIXME: We should track this in some way for source fidelity.
629	if (getModuleOwnershipKind() == ModuleOwnershipKind::Unowned)
630	return;
631	setModuleOwnershipKind(ModuleOwnershipKind::ModulePrivate);
632	}
633
634	public:
635	/// Set the FromASTFile flag. This indicates that this declaration
636	/// was deserialized and not parsed from source code and enables
637	/// features such as module ownership information.
638	void setFromASTFile() {
639	FromASTFile = true;
640	}
641
642	/// Set the owning module ID. This may only be called for
643	/// deserialized Decls.
644	void setOwningModuleID(unsigned ID) {
645	assert(isFromASTFile() && "Only works on a deserialized declaration")((void)0);
646	((unsigned)this - 2) = ID;
647	}
648
649	public:
650	/// Determine the availability of the given declaration.
651	///
652	/// This routine will determine the most restrictive availability of
653	/// the given declaration (e.g., preferring 'unavailable' to
654	/// 'deprecated').
655	///
656	/// \param Message If non-NULL and the result is not \c
657	/// AR_Available, will be set to a (possibly empty) message
658	/// describing why the declaration has not been introduced, is
659	/// deprecated, or is unavailable.
660	///
661	/// \param EnclosingVersion The version to compare with. If empty, assume the
662	/// deployment target version.
663	///
664	/// \param RealizedPlatform If non-NULL and the availability result is found
665	/// in an available attribute it will set to the platform which is written in
666	/// the available attribute.
667	AvailabilityResult
668	getAvailability(std::string *Message = nullptr,
669	VersionTuple EnclosingVersion = VersionTuple(),
670	StringRef *RealizedPlatform = nullptr) const;
671
672	/// Retrieve the version of the target platform in which this
673	/// declaration was introduced.
674	///
675	/// \returns An empty version tuple if this declaration has no 'introduced'
676	/// availability attributes, or the version tuple that's specified in the
677	/// attribute otherwise.
678	VersionTuple getVersionIntroduced() const;
679
680	/// Determine whether this declaration is marked 'deprecated'.
681	///
682	/// \param Message If non-NULL and the declaration is deprecated,
683	/// this will be set to the message describing why the declaration
684	/// was deprecated (which may be empty).
685	bool isDeprecated(std::string *Message = nullptr) const {
686	return getAvailability(Message) == AR_Deprecated;
687	}
688
689	/// Determine whether this declaration is marked 'unavailable'.
690	///
691	/// \param Message If non-NULL and the declaration is unavailable,
692	/// this will be set to the message describing why the declaration
693	/// was made unavailable (which may be empty).
694	bool isUnavailable(std::string *Message = nullptr) const {
695	return getAvailability(Message) == AR_Unavailable;
696	}
697
698	/// Determine whether this is a weak-imported symbol.
699	///
700	/// Weak-imported symbols are typically marked with the
701	/// 'weak_import' attribute, but may also be marked with an
702	/// 'availability' attribute where we're targing a platform prior to
703	/// the introduction of this feature.
704	bool isWeakImported() const;
705
706	/// Determines whether this symbol can be weak-imported,
707	/// e.g., whether it would be well-formed to add the weak_import
708	/// attribute.
709	///
710	/// \param IsDefinition Set to \c true to indicate that this
711	/// declaration cannot be weak-imported because it has a definition.
712	bool canBeWeakImported(bool &IsDefinition) const;
713
714	/// Determine whether this declaration came from an AST file (such as
715	/// a precompiled header or module) rather than having been parsed.
716	bool isFromASTFile() const { return FromASTFile; }
717
718	/// Retrieve the global declaration ID associated with this
719	/// declaration, which specifies where this Decl was loaded from.
720	unsigned getGlobalID() const {
721	if (isFromASTFile())
722	return ((const unsigned)this - 1);
723	return 0;
724	}
725
726	/// Retrieve the global ID of the module that owns this particular
727	/// declaration.
728	unsigned getOwningModuleID() const {
729	if (isFromASTFile())
730	return ((const unsigned)this - 2);
731	return 0;
732	}
733
734	private:
735	Module *getOwningModuleSlow() const;
736
737	protected:
738	bool hasLocalOwningModuleStorage() const;
739
740	public:
741	/// Get the imported owning module, if this decl is from an imported
742	/// (non-local) module.
743	Module *getImportedOwningModule() const {
744	if (!isFromASTFile() \|\| !hasOwningModule())
745	return nullptr;
746
747	return getOwningModuleSlow();
748	}
749
750	/// Get the local owning module, if known. Returns nullptr if owner is
751	/// not yet known or declaration is not from a module.
752	Module *getLocalOwningModule() const {
753	if (isFromASTFile() \|\| !hasOwningModule())
754	return nullptr;
755
756	assert(hasLocalOwningModuleStorage() &&((void)0)
757	"owned local decl but no local module storage")((void)0);
758	return reinterpret_cast<Module const >(this)[-1];
759	}
760	void setLocalOwningModule(Module *M) {
761	assert(!isFromASTFile() && hasOwningModule() &&((void)0)
762	hasLocalOwningModuleStorage() &&((void)0)
763	"should not have a cached owning module")((void)0);
764	reinterpret_cast<Module **>(this)[-1] = M;
765	}
766
767	/// Is this declaration owned by some module?
768	bool hasOwningModule() const {
769	return getModuleOwnershipKind() != ModuleOwnershipKind::Unowned;
770	}
771
772	/// Get the module that owns this declaration (for visibility purposes).
773	Module *getOwningModule() const {
774	return isFromASTFile() ? getImportedOwningModule() : getLocalOwningModule();
775	}
776
777	/// Get the module that owns this declaration for linkage purposes.
778	/// There only ever is such a module under the C++ Modules TS.
779	///
780	/// \param IgnoreLinkage Ignore the linkage of the entity; assume that
781	/// all declarations in a global module fragment are unowned.
782	Module *getOwningModuleForLinkage(bool IgnoreLinkage = false) const;
783
784	/// Determine whether this declaration is definitely visible to name lookup,
785	/// independent of whether the owning module is visible.
786	/// Note: The declaration may be visible even if this returns \c false if the
787	/// owning module is visible within the query context. This is a low-level
788	/// helper function; most code should be calling Sema::isVisible() instead.
789	bool isUnconditionallyVisible() const {
790	return (int)getModuleOwnershipKind() <= (int)ModuleOwnershipKind::Visible;
791	}
792
793	/// Set that this declaration is globally visible, even if it came from a
794	/// module that is not visible.
795	void setVisibleDespiteOwningModule() {
796	if (!isUnconditionallyVisible())
797	setModuleOwnershipKind(ModuleOwnershipKind::Visible);
798	}
799
800	/// Get the kind of module ownership for this declaration.
801	ModuleOwnershipKind getModuleOwnershipKind() const {
802	return NextInContextAndBits.getInt();
803	}
804
805	/// Set whether this declaration is hidden from name lookup.
806	void setModuleOwnershipKind(ModuleOwnershipKind MOK) {
807	assert(!(getModuleOwnershipKind() == ModuleOwnershipKind::Unowned &&((void)0)
808	MOK != ModuleOwnershipKind::Unowned && !isFromASTFile() &&((void)0)
809	!hasLocalOwningModuleStorage()) &&((void)0)
810	"no storage available for owning module for this declaration")((void)0);
811	NextInContextAndBits.setInt(MOK);
812	}
813
814	unsigned getIdentifierNamespace() const {
815	return IdentifierNamespace;
816	}
817
818	bool isInIdentifierNamespace(unsigned NS) const {
819	return getIdentifierNamespace() & NS;
820	}
821
822	static unsigned getIdentifierNamespaceForKind(Kind DK);
823
824	bool hasTagIdentifierNamespace() const {
825	return isTagIdentifierNamespace(getIdentifierNamespace());
826	}
827
828	static bool isTagIdentifierNamespace(unsigned NS) {
829	// TagDecls have Tag and Type set and may also have TagFriend.
830	return (NS & ~IDNS_TagFriend) == (IDNS_Tag \| IDNS_Type);
831	}
832
833	/// getLexicalDeclContext - The declaration context where this Decl was
834	/// lexically declared (LexicalDC). May be different from
835	/// getDeclContext() (SemanticDC).
836	/// e.g.:
837	///
838	/// namespace A {
839	/// void f(); // SemanticDC == LexicalDC == 'namespace A'
840	/// }
841	/// void A::f(); // SemanticDC == namespace 'A'
842	/// // LexicalDC == global namespace
843	DeclContext *getLexicalDeclContext() {
844	if (isInSemaDC())
845	return getSemanticDC();
846	return getMultipleDC()->LexicalDC;
847	}
848	const DeclContext *getLexicalDeclContext() const {
849	return const_cast<Decl*>(this)->getLexicalDeclContext();
850	}
851
852	/// Determine whether this declaration is declared out of line (outside its
853	/// semantic context).
854	virtual bool isOutOfLine() const;
855
856	/// setDeclContext - Set both the semantic and lexical DeclContext
857	/// to DC.
858	void setDeclContext(DeclContext *DC);
859
860	void setLexicalDeclContext(DeclContext *DC);
861
862	/// Determine whether this declaration is a templated entity (whether it is
863	// within the scope of a template parameter).
864	bool isTemplated() const;
865
866	/// Determine the number of levels of template parameter surrounding this
867	/// declaration.
868	unsigned getTemplateDepth() const;
869
870	/// isDefinedOutsideFunctionOrMethod - This predicate returns true if this
871	/// scoped decl is defined outside the current function or method. This is
872	/// roughly global variables and functions, but also handles enums (which
873	/// could be defined inside or outside a function etc).
874	bool isDefinedOutsideFunctionOrMethod() const {
875	return getParentFunctionOrMethod() == nullptr;
876	}
877
878	/// Determine whether a substitution into this declaration would occur as
879	/// part of a substitution into a dependent local scope. Such a substitution
880	/// transitively substitutes into all constructs nested within this
881	/// declaration.
882	///
883	/// This recognizes non-defining declarations as well as members of local
884	/// classes and lambdas:
885	/// \code
886	/// template<typename T> void foo() { void bar(); }
887	/// template<typename T> void foo2() { class ABC { void bar(); }; }