/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 1687, 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()) {
        layout.push_back(SynthesizeIvarChunk(
                           IV->getASTContext().getTypeSize(IV->getType()), IV));
        continue;
      }
      if (!data().IvarList)
        data().IvarList = IV;
      else
        curIvar->setNextIvar(IV);
      curIvar = IV;
    }

    if (!layout.empty()) {
38
←
Calling 'SmallVectorBase::empty'→
41
←
Returning from 'SmallVectorBase::empty'→
42
←
Taking true branch→
      // Order synthesized ivars by their size.
      llvm::stable_sort(layout);
      unsigned Ix = 0, EIx = layout.size();
      if (!data().IvarList) {
43
←
Assuming field 'IvarList' is non-null→
44
←
Taking false branch→
        data().IvarList = layout[0].Ivar; Ix++;
        curIvar = data().IvarList;
      }
      for ( ; Ix != EIx; curIvar = layout[Ix].Ivar, Ix++)
45
←
Assuming 'Ix' is not equal to 'EIx'→
46
←
Loop condition is true.  Entering loop body→
        curIvar->setNextIvar(layout[Ix].Ivar);
47
←
Called C++ object pointer is null
    }
  }
}
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//===----------------------------------------------------------------------===//

13#ifndef LLVM_CLANG_AST_DECLBASE_H
14#define LLVM_CLANG_AST_DECLBASE_H

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>

40namespace clang {

42class ASTContext;
43class ASTMutationListener;
44class Attr;
45class BlockDecl;
46class DeclContext;
47class ExternalSourceSymbolAttr;
48class FunctionDecl;
49class FunctionType;
50class IdentifierInfo;
51enum Linkage : unsigned char;
52class LinkageSpecDecl;
53class Module;
54class NamedDecl;
55class ObjCCategoryDecl;
56class ObjCCategoryImplDecl;
57class ObjCContainerDecl;
58class ObjCImplDecl;
59class ObjCImplementationDecl;
60class ObjCInterfaceDecl;
61class ObjCMethodDecl;
62class ObjCProtocolDecl;
63struct PrintingPolicy;
64class RecordDecl;
65class SourceManager;
66class Stmt;
67class StoredDeclsMap;
68class TemplateDecl;
69class TemplateParameterList;
70class TranslationUnitDecl;
71class UsingDirectiveDecl;

73/// Captures the result of checking the availability of a
74/// declaration.
75enum AvailabilityResult {
AR_Available = 0,
AR_NotYetIntroduced,
AR_Deprecated,
AR_Unavailable
80};

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.
89class alignas(8) Decl {
90public:
/// Lists the kind of concrete classes of Decl.
enum Kind {
93#define DECL(DERIVED, BASE) DERIVED,
94#define ABSTRACT_DECL(DECL)
95#define DECL_RANGE(BASE, START, END) \
      first##BASE = START, last##BASE = END,
97#define LAST_DECL_RANGE(BASE, START, END) \
      first##BASE = START, last##BASE = END
99#include "clang/AST/DeclNodes.inc"
};

/// A placeholder type used to construct an empty shell of a
/// decl-derived type that will be filled in later (e.g., by some
/// deserialization method).
struct EmptyShell {};

/// IdentifierNamespace - The different namespaces in which
/// declarations may appear.  According to C99 6.2.3, there are
/// four namespaces, labels, tags, members and ordinary
/// identifiers.  C++ describes lookup completely differently:
/// certain lookups merely "ignore" certain kinds of declarations,
/// usually based on whether the declaration is of a type, etc.
///
/// These are meant as bitmasks, so that searches in
/// C++ can look into the "tag" namespace during ordinary lookup.
///
/// Decl currently provides 15 bits of IDNS bits.
enum IdentifierNamespace {
  /// Labels, declared with 'x:' and referenced with 'goto x'.
  IDNS_Label               = 0x0001,

  /// Tags, declared with 'struct foo;' and referenced with
  /// 'struct foo'.  All tags are also types.  This is what
  /// elaborated-type-specifiers look for in C.
  /// This also contains names that conflict with tags in the
  /// same scope but that are otherwise ordinary names (non-type
  /// template parameters and indirect field declarations).
  IDNS_Tag                 = 0x0002,

  /// Types, declared with 'struct foo', typedefs, etc.
  /// This is what elaborated-type-specifiers look for in C++,
  /// but note that it's ill-formed to find a non-tag.
  IDNS_Type                = 0x0004,

  /// Members, declared with object declarations within tag
  /// definitions.  In C, these can only be found by "qualified"
  /// lookup in member expressions.  In C++, they're found by
  /// normal lookup.
  IDNS_Member              = 0x0008,

  /// Namespaces, declared with 'namespace foo {}'.
  /// Lookup for nested-name-specifiers find these.
  IDNS_Namespace           = 0x0010,

  /// Ordinary names.  In C, everything that's not a label, tag,
  /// member, or function-local extern ends up here.
  IDNS_Ordinary            = 0x0020,

  /// Objective C \@protocol.
  IDNS_ObjCProtocol        = 0x0040,

  /// This declaration is a friend function.  A friend function
  /// declaration is always in this namespace but may also be in
  /// IDNS_Ordinary if it was previously declared.
  IDNS_OrdinaryFriend      = 0x0080,

  /// This declaration is a friend class.  A friend class
  /// declaration is always in this namespace but may also be in
  /// IDNS_Tag|IDNS_Type if it was previously declared.
  IDNS_TagFriend           = 0x0100,

  /// This declaration is a using declaration.  A using declaration
  /// *introduces* a number of other declarations into the current
  /// scope, and those declarations use the IDNS of their targets,
  /// but the actual using declarations go in this namespace.
  IDNS_Using               = 0x0200,

  /// This declaration is a C++ operator declared in a non-class
  /// context.  All such operators are also in IDNS_Ordinary.
  /// C++ lexical operator lookup looks for these.
  IDNS_NonMemberOperator   = 0x0400,

  /// This declaration is a function-local extern declaration of a
  /// variable or function. This may also be IDNS_Ordinary if it
  /// has been declared outside any function. These act mostly like
  /// invisible friend declarations, but are also visible to unqualified
  /// lookup within the scope of the declaring function.
  IDNS_LocalExtern         = 0x0800,

  /// This declaration is an OpenMP user defined reduction construction.
  IDNS_OMPReduction        = 0x1000,

  /// This declaration is an OpenMP user defined mapper.
  IDNS_OMPMapper           = 0x2000,
};

/// ObjCDeclQualifier - 'Qualifiers' written next to the return and
/// parameter types in method declarations.  Other than remembering
/// them and mangling them into the method's signature string, these
/// are ignored by the compiler; they are consumed by certain
/// remote-messaging frameworks.
///
/// in, inout, and out are mutually exclusive and apply only to
/// method parameters.  bycopy and byref are mutually exclusive and
/// apply only to method parameters (?).  oneway applies only to
/// results.  All of these expect their corresponding parameter to
/// have a particular type.  None of this is currently enforced by
/// clang.
///
/// This should be kept in sync with ObjCDeclSpec::ObjCDeclQualifier.
enum ObjCDeclQualifier {
  OBJC_TQ_None = 0x0,
  OBJC_TQ_In = 0x1,
  OBJC_TQ_Inout = 0x2,
  OBJC_TQ_Out = 0x4,
  OBJC_TQ_Bycopy = 0x8,
  OBJC_TQ_Byref = 0x10,
  OBJC_TQ_Oneway = 0x20,

  /// The nullability qualifier is set when the nullability of the
  /// result or parameter was expressed via a context-sensitive
  /// keyword.
  OBJC_TQ_CSNullability = 0x40
};

/// The kind of ownership a declaration has, for visibility purposes.
/// This enumeration is designed such that higher values represent higher
/// levels of name hiding.
enum class ModuleOwnershipKind : unsigned {
  /// This declaration is not owned by a module.
  Unowned,

  /// This declaration has an owning module, but is globally visible
  /// (typically because its owning module is visible and we know that
  /// modules cannot later become hidden in this compilation).
  /// After serialization and deserialization, this will be converted
  /// to VisibleWhenImported.
  Visible,

  /// This declaration has an owning module, and is visible when that
  /// module is imported.
  VisibleWhenImported,

  /// This declaration has an owning module, but is only visible to
  /// lookups that occur within that module.
  ModulePrivate
};

239protected:
/// The next declaration within the same lexical
/// DeclContext. These pointers form the linked list that is
/// traversed via DeclContext's decls_begin()/decls_end().
///
/// The extra two bits are used for the ModuleOwnershipKind.
llvm::PointerIntPair<Decl *, 2, ModuleOwnershipKind> NextInContextAndBits;

247private:
friend class DeclContext;

struct MultipleDC {
  DeclContext *SemanticDC;
  DeclContext *LexicalDC;
};

/// DeclCtx - Holds either a DeclContext* or a MultipleDC*.
/// For declarations that don't contain C++ scope specifiers, it contains
/// the DeclContext where the Decl was declared.
/// For declarations with C++ scope specifiers, it contains a MultipleDC*
/// with the context where it semantically belongs (SemanticDC) and the
/// context where it was lexically declared (LexicalDC).
/// e.g.:
///
///   namespace A {
///      void f(); // SemanticDC == LexicalDC == 'namespace A'
///   }
///   void A::f(); // SemanticDC == namespace 'A'
///                // LexicalDC == global namespace
llvm::PointerUnion<DeclContext*, MultipleDC*> DeclCtx;

bool isInSemaDC() const { return DeclCtx.is<DeclContext*>(); }
bool isOutOfSemaDC() const { return DeclCtx.is<MultipleDC*>(); }

MultipleDC *getMultipleDC() const {
  return DeclCtx.get<MultipleDC*>();
}

DeclContext *getSemanticDC() const {
  return DeclCtx.get<DeclContext*>();
}

/// Loc - The location of this decl.
SourceLocation Loc;

/// DeclKind - This indicates which class this is.
unsigned DeclKind : 7;

/// InvalidDecl - This indicates a semantic error occurred.
unsigned InvalidDecl :  1;

/// HasAttrs - This indicates whether the decl has attributes or not.
unsigned HasAttrs : 1;

/// Implicit - Whether this declaration was implicitly generated by
/// the implementation rather than explicitly written by the user.
unsigned Implicit : 1;

/// Whether this declaration was "used", meaning that a definition is
/// required.
unsigned Used : 1;

/// Whether this declaration was "referenced".
/// The difference with 'Used' is whether the reference appears in a
/// evaluated context or not, e.g. functions used in uninstantiated templates
/// are regarded as "referenced" but not "used".
unsigned Referenced : 1;

/// Whether this declaration is a top-level declaration (function,
/// global variable, etc.) that is lexically inside an objc container
/// definition.
unsigned TopLevelDeclInObjCContainer : 1;

/// Whether statistic collection is enabled.
static bool StatisticsEnabled;

315protected:
friend class ASTDeclReader;
friend class ASTDeclWriter;
friend class ASTNodeImporter;
friend class ASTReader;
friend class CXXClassMemberWrapper;
friend class LinkageComputer;
template<typename decl_type> friend class Redeclarable;

/// Access - Used by C++ decls for the access specifier.
// NOTE: VC++ treats enums as signed, avoid using the AccessSpecifier enum
unsigned Access : 2;

/// Whether this declaration was loaded from an AST file.
unsigned FromASTFile : 1;

/// IdentifierNamespace - This specifies what IDNS_* namespace this lives in.
unsigned IdentifierNamespace : 14;

/// If 0, we have not computed the linkage of this declaration.
/// Otherwise, it is the linkage + 1.
mutable unsigned CacheValidAndLinkage : 3;

/// Allocate memory for a deserialized declaration.
///
/// This routine must be used to allocate memory for any declaration that is
/// deserialized from a module file.
///
/// \param Size The size of the allocated object.
/// \param Ctx The context in which we will allocate memory.
/// \param ID The global ID of the deserialized declaration.
/// \param Extra The amount of extra space to allocate after the object.
void *operator new(std::size_t Size, const ASTContext &Ctx, unsigned ID,
                   std::size_t Extra = 0);

/// Allocate memory for a non-deserialized declaration.
void *operator new(std::size_t Size, const ASTContext &Ctx,
                   DeclContext *Parent, std::size_t Extra = 0);

354private:
bool AccessDeclContextSanity() const;

/// Get the module ownership kind to use for a local lexical child of \p DC,
/// which may be either a local or (rarely) an imported declaration.
static ModuleOwnershipKind getModuleOwnershipKindForChildOf(DeclContext *DC) {
  if (DC) {
    auto *D = cast<Decl>(DC);
    auto MOK = D->getModuleOwnershipKind();
    if (MOK != ModuleOwnershipKind::Unowned &&
        (!D->isFromASTFile() || D->hasLocalOwningModuleStorage()))
      return MOK;
    // If D is not local and we have no local module storage, then we don't
    // need to track module ownership at all.
  }
  return ModuleOwnershipKind::Unowned;
}

372public:
Decl() = delete;
Decl(const Decl&) = delete;
Decl(Decl &&) = delete;
Decl &operator=(const Decl&) = delete;
Decl &operator=(Decl&&) = delete;

379protected:
Decl(Kind DK, DeclContext *DC, SourceLocation L)
    : NextInContextAndBits(nullptr, getModuleOwnershipKindForChildOf(DC)),
      DeclCtx(DC), Loc(L), DeclKind(DK), InvalidDecl(false), HasAttrs(false),
      Implicit(false), Used(false), Referenced(false),
      TopLevelDeclInObjCContainer(false), Access(AS_none), FromASTFile(0),
      IdentifierNamespace(getIdentifierNamespaceForKind(DK)),
      CacheValidAndLinkage(0) {
  if (StatisticsEnabled) add(DK);
}

Decl(Kind DK, EmptyShell Empty)
    : DeclKind(DK), InvalidDecl(false), HasAttrs(false), Implicit(false),
      Used(false), Referenced(false), TopLevelDeclInObjCContainer(false),
      Access(AS_none), FromASTFile(0),
      IdentifierNamespace(getIdentifierNamespaceForKind(DK)),
      CacheValidAndLinkage(0) {
  if (StatisticsEnabled) add(DK);
}

virtual ~Decl();

/// Update a potentially out-of-date declaration.
void updateOutOfDate(IdentifierInfo &II) const;

Linkage getCachedLinkage() const {
  return Linkage(CacheValidAndLinkage - 1);
}

void setCachedLinkage(Linkage L) const {
  CacheValidAndLinkage = L + 1;
}

bool hasCachedLinkage() const {
  return CacheValidAndLinkage;
}

416public:
/// Source range that this declaration covers.
virtual SourceRange getSourceRange() const LLVM_READONLY__attribute__((__pure__)) {
  return SourceRange(getLocation(), getLocation());
}

SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) {
  return getSourceRange().getBegin();
}

SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) {
  return getSourceRange().getEnd();
}

SourceLocation getLocation() const { return Loc; }
void setLocation(SourceLocation L) { Loc = L; }

Kind getKind() const { return static_cast<Kind>(DeclKind); }
const char *getDeclKindName() const;

Decl *getNextDeclInContext() { return NextInContextAndBits.getPointer(); }
const Decl *getNextDeclInContext() const {return NextInContextAndBits.getPointer();}

DeclContext *getDeclContext() {
  if (isInSemaDC())
    return getSemanticDC();
  return getMultipleDC()->SemanticDC;
}
const DeclContext *getDeclContext() const {
  return const_cast<Decl*>(this)->getDeclContext();
}

/// Find the innermost non-closure ancestor of this declaration,
/// walking up through blocks, lambdas, etc.  If that ancestor is
/// not a code context (!isFunctionOrMethod()), returns null.
///
/// A declaration may be its own non-closure context.
Decl *getNonClosureContext();
const Decl *getNonClosureContext() const {
  return const_cast<Decl*>(this)->getNonClosureContext();
}

TranslationUnitDecl *getTranslationUnitDecl();
const TranslationUnitDecl *getTranslationUnitDecl() const {
  return const_cast<Decl*>(this)->getTranslationUnitDecl();
}

bool isInAnonymousNamespace() const;

bool isInStdNamespace() const;

ASTContext &getASTContext() const LLVM_READONLY__attribute__((__pure__));

/// Helper to get the language options from the ASTContext.
/// Defined out of line to avoid depending on ASTContext.h.
const LangOptions &getLangOpts() const LLVM_READONLY__attribute__((__pure__));

void setAccess(AccessSpecifier AS) {
  Access = AS;
  assert(AccessDeclContextSanity())((void)0);
}

AccessSpecifier getAccess() const {
  assert(AccessDeclContextSanity())((void)0);
  return AccessSpecifier(Access);
}

/// Retrieve the access specifier for this declaration, even though
/// it may not yet have been properly set.
AccessSpecifier getAccessUnsafe() const {
  return AccessSpecifier(Access);
}

bool hasAttrs() const { return HasAttrs; }

void setAttrs(const AttrVec& Attrs) {
  return setAttrsImpl(Attrs, getASTContext());
}

AttrVec &getAttrs() {
  return const_cast<AttrVec&>(const_cast<const Decl*>(this)->getAttrs());
}

const AttrVec &getAttrs() const;
void dropAttrs();
void addAttr(Attr *A);

using attr_iterator = AttrVec::const_iterator;
using attr_range = llvm::iterator_range<attr_iterator>;

attr_range attrs() const {
  return attr_range(attr_begin(), attr_end());
}

attr_iterator attr_begin() const {
  return hasAttrs() ? getAttrs().begin() : nullptr;
}
attr_iterator attr_end() const {
  return hasAttrs() ? getAttrs().end() : nullptr;
}

template <typename T>
void dropAttr() {
  if (!HasAttrs) return;

  AttrVec &Vec = getAttrs();
  llvm::erase_if(Vec, [](Attr *A) { return isa<T>(A); });

  if (Vec.empty())
    HasAttrs = false;
}

template <typename T>
llvm::iterator_range<specific_attr_iterator<T>> specific_attrs() const {
  return llvm::make_range(specific_attr_begin<T>(), specific_attr_end<T>());
}

template <typename T>
specific_attr_iterator<T> specific_attr_begin() const {
  return specific_attr_iterator<T>(attr_begin());
}

template <typename T>
specific_attr_iterator<T> specific_attr_end() const {
  return specific_attr_iterator<T>(attr_end());
}

template<typename T> T *getAttr() const {
  return hasAttrs() ? getSpecificAttr<T>(getAttrs()) : nullptr;
}

template<typename T> bool hasAttr() const {
  return hasAttrs() && hasSpecificAttr<T>(getAttrs());
}

/// getMaxAlignment - return the maximum alignment specified by attributes
/// on this decl, 0 if there are none.
unsigned getMaxAlignment() const;

/// setInvalidDecl - Indicates the Decl had a semantic error. This
/// allows for graceful error recovery.
void setInvalidDecl(bool Invalid = true);
bool isInvalidDecl() const { return (bool) InvalidDecl; }

/// isImplicit - Indicates whether the declaration was implicitly
/// generated by the implementation. If false, this declaration
/// was written explicitly in the source code.
bool isImplicit() const { return Implicit; }
void setImplicit(bool I = true) { Implicit = I; }

/// Whether *any* (re-)declaration of the entity was used, meaning that
/// a definition is required.
///
/// \param CheckUsedAttr When true, also consider the "used" attribute
/// (in addition to the "used" bit set by \c setUsed()) when determining
/// whether the function is used.
bool isUsed(bool CheckUsedAttr = true) const;

/// Set whether the declaration is used, in the sense of odr-use.
///
/// This should only be used immediately after creating a declaration.
/// It intentionally doesn't notify any listeners.
void setIsUsed() { getCanonicalDecl()->Used = true; }

/// Mark the declaration used, in the sense of odr-use.
///
/// This notifies any mutation listeners in addition to setting a bit
/// indicating the declaration is used.
void markUsed(ASTContext &C);

/// Whether any declaration of this entity was referenced.
bool isReferenced() const;

/// Whether this declaration was referenced. This should not be relied
/// upon for anything other than debugging.
bool isThisDeclarationReferenced() const { return Referenced; }

void setReferenced(bool R = true) { Referenced = R; }

/// Whether this declaration is a top-level declaration (function,
/// global variable, etc.) that is lexically inside an objc container
/// definition.
bool isTopLevelDeclInObjCContainer() const {
  return TopLevelDeclInObjCContainer;
}

void setTopLevelDeclInObjCContainer(bool V = true) {
  TopLevelDeclInObjCContainer = V;
}

/// Looks on this and related declarations for an applicable
/// external source symbol attribute.
ExternalSourceSymbolAttr *getExternalSourceSymbolAttr() const;

/// Whether this declaration was marked as being private to the
/// module in which it was defined.
bool isModulePrivate() const {
  return getModuleOwnershipKind() == ModuleOwnershipKind::ModulePrivate;
}

/// Return true if this declaration has an attribute which acts as
/// definition of the entity, such as 'alias' or 'ifunc'.
bool hasDefiningAttr() const;

/// Return this declaration's defining attribute if it has one.
const Attr *getDefiningAttr() const;

623protected:
/// Specify that this declaration was marked as being private
/// to the module in which it was defined.
void setModulePrivate() {
  // The module-private specifier has no effect on unowned declarations.
  // FIXME: We should track this in some way for source fidelity.
  if (getModuleOwnershipKind() == ModuleOwnershipKind::Unowned)
    return;
  setModuleOwnershipKind(ModuleOwnershipKind::ModulePrivate);
}

634public:
/// Set the FromASTFile flag. This indicates that this declaration
/// was deserialized and not parsed from source code and enables
/// features such as module ownership information.
void setFromASTFile() {
  FromASTFile = true;
}

/// Set the owning module ID.  This may only be called for
/// deserialized Decls.
void setOwningModuleID(unsigned ID) {
  assert(isFromASTFile() && "Only works on a deserialized declaration")((void)0);
  *((unsigned*)this - 2) = ID;
}

649public:
/// Determine the availability of the given declaration.
///
/// This routine will determine the most restrictive availability of
/// the given declaration (e.g., preferring 'unavailable' to
/// 'deprecated').
///
/// \param Message If non-NULL and the result is not \c
/// AR_Available, will be set to a (possibly empty) message
/// describing why the declaration has not been introduced, is
/// deprecated, or is unavailable.
///
/// \param EnclosingVersion The version to compare with. If empty, assume the
/// deployment target version.
///
/// \param RealizedPlatform If non-NULL and the availability result is found
/// in an available attribute it will set to the platform which is written in
/// the available attribute.
AvailabilityResult
getAvailability(std::string *Message = nullptr,
                VersionTuple EnclosingVersion = VersionTuple(),
                StringRef *RealizedPlatform = nullptr) const;

/// Retrieve the version of the target platform in which this
/// declaration was introduced.
///
/// \returns An empty version tuple if this declaration has no 'introduced'
/// availability attributes, or the version tuple that's specified in the
/// attribute otherwise.
VersionTuple getVersionIntroduced() const;

/// Determine whether this declaration is marked 'deprecated'.
///
/// \param Message If non-NULL and the declaration is deprecated,
/// this will be set to the message describing why the declaration
/// was deprecated (which may be empty).
bool isDeprecated(std::string *Message = nullptr) const {
  return getAvailability(Message) == AR_Deprecated;
}

/// Determine whether this declaration is marked 'unavailable'.
///
/// \param Message If non-NULL and the declaration is unavailable,
/// this will be set to the message describing why the declaration
/// was made unavailable (which may be empty).
bool isUnavailable(std::string *Message = nullptr) const {
  return getAvailability(Message) == AR_Unavailable;
}

/// Determine whether this is a weak-imported symbol.
///
/// Weak-imported symbols are typically marked with the
/// 'weak_import' attribute, but may also be marked with an
/// 'availability' attribute where we're targing a platform prior to
/// the introduction of this feature.
bool isWeakImported() const;

/// Determines whether this symbol can be weak-imported,
/// e.g., whether it would be well-formed to add the weak_import
/// attribute.
///
/// \param IsDefinition Set to \c true to indicate that this
/// declaration cannot be weak-imported because it has a definition.
bool canBeWeakImported(bool &IsDefinition) const;

/// Determine whether this declaration came from an AST file (such as
/// a precompiled header or module) rather than having been parsed.
bool isFromASTFile() const { return FromASTFile; }

/// Retrieve the global declaration ID associated with this
/// declaration, which specifies where this Decl was loaded from.
unsigned getGlobalID() const {
  if (isFromASTFile())
    return *((const unsigned*)this - 1);
  return 0;
}

/// Retrieve the global ID of the module that owns this particular
/// declaration.
unsigned getOwningModuleID() const {
  if (isFromASTFile())
    return *((const unsigned*)this - 2);
  return 0;
}

734private:
Module *getOwningModuleSlow() const;

737protected:
bool hasLocalOwningModuleStorage() const;

740public:
/// Get the imported owning module, if this decl is from an imported
/// (non-local) module.
Module *getImportedOwningModule() const {
  if (!isFromASTFile() || !hasOwningModule())
    return nullptr;

  return getOwningModuleSlow();
}

/// Get the local owning module, if known. Returns nullptr if owner is
/// not yet known or declaration is not from a module.
Module *getLocalOwningModule() const {
  if (isFromASTFile() || !hasOwningModule())
    return nullptr;

  assert(hasLocalOwningModuleStorage() &&((void)0)
         "owned local decl but no local module storage")((void)0);
  return reinterpret_cast<Module *const *>(this)[-1];
}
void setLocalOwningModule(Module *M) {
  assert(!isFromASTFile() && hasOwningModule() &&((void)0)
         hasLocalOwningModuleStorage() &&((void)0)
         "should not have a cached owning module")((void)0);
  reinterpret_cast<Module **>(this)[-1] = M;
}

/// Is this declaration owned by some module?
bool hasOwningModule() const {
  return getModuleOwnershipKind() != ModuleOwnershipKind::Unowned;
}

/// Get the module that owns this declaration (for visibility purposes).
Module *getOwningModule() const {
  return isFromASTFile() ? getImportedOwningModule() : getLocalOwningModule();
}

/// Get the module that owns this declaration for linkage purposes.
/// There only ever is such a module under the C++ Modules TS.
///
/// \param IgnoreLinkage Ignore the linkage of the entity; assume that
/// all declarations in a global module fragment are unowned.
Module *getOwningModuleForLinkage(bool IgnoreLinkage = false) const;

/// Determine whether this declaration is definitely visible to name lookup,
/// independent of whether the owning module is visible.
/// Note: The declaration may be visible even if this returns \c false if the
/// owning module is visible within the query context. This is a low-level
/// helper function; most code should be calling Sema::isVisible() instead.
bool isUnconditionallyVisible() const {
  return (int)getModuleOwnershipKind() <= (int)ModuleOwnershipKind::Visible;
}

/// Set that this declaration is globally visible, even if it came from a
/// module that is not visible.
void setVisibleDespiteOwningModule() {
  if (!isUnconditionallyVisible())
    setModuleOwnershipKind(ModuleOwnershipKind::Visible);
}

/// Get the kind of module ownership for this declaration.
ModuleOwnershipKind getModuleOwnershipKind() const {
  return NextInContextAndBits.getInt();
}

/// Set whether this declaration is hidden from name lookup.
void setModuleOwnershipKind(ModuleOwnershipKind MOK) {
  assert(!(getModuleOwnershipKind() == ModuleOwnershipKind::Unowned &&((void)0)
           MOK != ModuleOwnershipKind::Unowned && !isFromASTFile() &&((void)0)
           !hasLocalOwningModuleStorage()) &&((void)0)
         "no storage available for owning module for this declaration")((void)0);
  NextInContextAndBits.setInt(MOK);
}

unsigned getIdentifierNamespace() const {
  return IdentifierNamespace;
}

bool isInIdentifierNamespace(unsigned NS) const {
  return getIdentifierNamespace() & NS;
}

static unsigned getIdentifierNamespaceForKind(Kind DK);

bool hasTagIdentifierNamespace() const {
  return isTagIdentifierNamespace(getIdentifierNamespace());
}

static bool isTagIdentifierNamespace(unsigned NS) {
  // TagDecls have Tag and Type set and may also have TagFriend.
  return (NS & ~IDNS_TagFriend) == (IDNS_Tag | IDNS_Type);
}

/// getLexicalDeclContext - The declaration context where this Decl was
/// lexically declared (LexicalDC). May be different from
/// getDeclContext() (SemanticDC).
/// e.g.:
///
///   namespace A {
///      void f(); // SemanticDC == LexicalDC == 'namespace A'
///   }
///   void A::f(); // SemanticDC == namespace 'A'
///                // LexicalDC == global namespace
DeclContext *getLexicalDeclContext() {
  if (isInSemaDC())
    return getSemanticDC();
  return getMultipleDC()->LexicalDC;
}
const DeclContext *getLexicalDeclContext() const {
  return const_cast<Decl*>(this)->getLexicalDeclContext();
}

/// Determine whether this declaration is declared out of line (outside its
/// semantic context).
virtual bool isOutOfLine() const;

/// setDeclContext - Set both the semantic and lexical DeclContext
/// to DC.
void setDeclContext(DeclContext *DC);

void setLexicalDeclContext(DeclContext *DC);

/// Determine whether this declaration is a templated entity (whether it is
// within the scope of a template parameter).
bool isTemplated() const;

/// Determine the number of levels of template parameter surrounding this
/// declaration.
unsigned getTemplateDepth() const;

/// isDefinedOutsideFunctionOrMethod - This predicate returns true if this
/// scoped decl is defined outside the current function or method.  This is
/// roughly global variables and functions, but also handles enums (which
/// could be defined inside or outside a function etc).
bool isDefinedOutsideFunctionOrMethod() const {
  return getParentFunctionOrMethod() == nullptr;
}

/// Determine whether a substitution into this declaration would occur as
/// part of a substitution into a dependent local scope. Such a substitution
/// transitively substitutes into all constructs nested within this
/// declaration.
///
/// This recognizes non-defining declarations as well as members of local
/// classes and lambdas:
/// \code
///     template<typename T> void foo() { void bar(); }
///     template<typename T> void foo2() { class ABC { void bar(); }; }
///     template<typename T> inline int x = [](){ return 0; }();
/// \endcode
bool isInLocalScopeForInstantiation() const;

/// If this decl is defined inside a function/method/block it returns
/// the corresponding DeclContext, otherwise it returns null.
const DeclContext *getParentFunctionOrMethod() const;
DeclContext *getParentFunctionOrMethod() {
  return const_cast<DeclContext*>(
                  const_cast<const Decl*>(this)->getParentFunctionOrMethod());
}

/// Retrieves the "canonical" declaration of the given declaration.
virtual Decl *getCanonicalDecl() { return this; }
const Decl *getCanonicalDecl() const {
  return const_cast<Decl*>(this)->getCanonicalDecl();
}

/// Whether this particular Decl is a canonical one.
bool isCanonicalDecl() const { return getCanonicalDecl() == this; }

909protected:
/// Returns the next redeclaration or itself if this is the only decl.
///
/// Decl subclasses that can be redeclared should override this method so that
/// Decl::redecl_iterator can iterate over them.
virtual Decl *getNextRedeclarationImpl() { return this; }

/// Implementation of getPreviousDecl(), to be overridden by any
/// subclass that has a redeclaration chain.
virtual Decl *getPreviousDeclImpl() { return nullptr; }

/// Implementation of getMostRecentDecl(), to be overridden by any
/// subclass that has a redeclaration chain.
virtual Decl *getMostRecentDeclImpl() { return this; }

924public:
/// Iterates through all the redeclarations of the same decl.
class redecl_iterator {
  /// Current - The current declaration.
  Decl *Current = nullptr;
  Decl *Starter;

public:
  using value_type = Decl *;
  using reference = const value_type &;
  using pointer = const value_type *;
  using iterator_category = std::forward_iterator_tag;
  using difference_type = std::ptrdiff_t;

  redecl_iterator() = default;
  explicit redecl_iterator(Decl *C) : Current(C), Starter(C) {}

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

  redecl_iterator& operator++() {
    assert(Current && "Advancing while iterator has reached end")((void)0);
    // Get either previous decl or latest decl.
    Decl *Next = Current->getNextRedeclarationImpl();
    assert(Next && "Should return next redeclaration or itself, never null!")((void)0);
    Current = (Next != Starter) ? Next : nullptr;
    return *this;
  }

  redecl_iterator operator++(int) {
    redecl_iterator tmp(*this);
    ++(*this);
    return tmp;
  }

  friend bool operator==(redecl_iterator x, redecl_iterator y) {
    return x.Current == y.Current;
  }

  friend bool operator!=(redecl_iterator x, redecl_iterator y) {
    return x.Current != y.Current;
  }
};

using redecl_range = llvm::iterator_range<redecl_iterator>;

/// Returns an iterator range for all the redeclarations of the same
/// decl. It will iterate at least once (when this decl is the only one).
redecl_range redecls() const {
  return redecl_range(redecls_begin(), redecls_end());
}

redecl_iterator redecls_begin() const {
  return redecl_iterator(const_cast<Decl *>(this));
}

redecl_iterator redecls_end() const { return redecl_iterator(); }

/// Retrieve the previous declaration that declares the same entity
/// as this declaration, or NULL if there is no previous declaration.
Decl *getPreviousDecl() { return getPreviousDeclImpl(); }

/// Retrieve the previous declaration that declares the same entity
/// as this declaration, or NULL if there is no previous declaration.
const Decl *getPreviousDecl() const {
  return const_cast<Decl *>(this)->getPreviousDeclImpl();
}

/// True if this is the first declaration in its redeclaration chain.
bool isFirstDecl() const {
  return getPreviousDecl() == nullptr;
}

/// Retrieve the most recent declaration that declares the same entity
/// as this declaration (which may be this declaration).
Decl *getMostRecentDecl() { return getMostRecentDeclImpl(); }

/// Retrieve the most recent declaration that declares the same entity
/// as this declaration (which may be this declaration).
const Decl *getMostRecentDecl() const {
  return const_cast<Decl *>(this)->getMostRecentDeclImpl();
}

/// getBody - If this Decl represents a declaration for a body of code,
///  such as a function or method definition, this method returns the
///  top-level Stmt* of that body.  Otherwise this method returns null.
virtual Stmt* getBody() const { return nullptr; }

/// Returns true if this \c Decl represents a declaration for a body of
/// code, such as a function or method definition.
/// Note that \c hasBody can also return true if any redeclaration of this
/// \c Decl represents a declaration for a body of code.
virtual bool hasBody() const { return getBody() != nullptr; }

/// getBodyRBrace - Gets the right brace of the body, if a body exists.
/// This works whether the body is a CompoundStmt or a CXXTryStmt.
SourceLocation getBodyRBrace() const;

// global temp stats (until we have a per-module visitor)
static void add(Kind k);
static void EnableStatistics();
static void PrintStats();

/// isTemplateParameter - Determines whether this declaration is a
/// template parameter.
bool isTemplateParameter() const;

/// isTemplateParameter - Determines whether this declaration is a
/// template parameter pack.
bool isTemplateParameterPack() const;

/// Whether this declaration is a parameter pack.
bool isParameterPack() const;

/// returns true if this declaration is a template
bool isTemplateDecl() const;

/// Whether this declaration is a function or function template.
bool isFunctionOrFunctionTemplate() const {
  return (DeclKind >= Decl::firstFunction &&
          DeclKind <= Decl::lastFunction) ||
         DeclKind == FunctionTemplate;
}

/// If this is a declaration that describes some template, this
/// method returns that template declaration.
///
/// Note that this returns nullptr for partial specializations, because they
/// are not modeled as TemplateDecls. Use getDescribedTemplateParams to handle
/// those cases.
TemplateDecl *getDescribedTemplate() const;

/// If this is a declaration that describes some template or partial
/// specialization, this returns the corresponding template parameter list.
const TemplateParameterList *getDescribedTemplateParams() const;

/// Returns the function itself, or the templated function if this is a
/// function template.
FunctionDecl *getAsFunction() LLVM_READONLY__attribute__((__pure__));

const FunctionDecl *getAsFunction() const {
  return const_cast<Decl *>(this)->getAsFunction();
}

/// Changes the namespace of this declaration to reflect that it's
/// a function-local extern declaration.
///
/// These declarations appear in the lexical context of the extern
/// declaration, but in the semantic context of the enclosing namespace
/// scope.
void setLocalExternDecl() {
  Decl *Prev = getPreviousDecl();
  IdentifierNamespace &= ~IDNS_Ordinary;

  // It's OK for the declaration to still have the "invisible friend" flag or
  // the "conflicts with tag declarations in this scope" flag for the outer
  // scope.
  assert((IdentifierNamespace & ~(IDNS_OrdinaryFriend | IDNS_Tag)) == 0 &&((void)0)
         "namespace is not ordinary")((void)0);

  IdentifierNamespace |= IDNS_LocalExtern;
  if (Prev && Prev->getIdentifierNamespace() & IDNS_Ordinary)
    IdentifierNamespace |= IDNS_Ordinary;
}

/// Determine whether this is a block-scope declaration with linkage.
/// This will either be a local variable declaration declared 'extern', or a
/// local function declaration.
bool isLocalExternDecl() {
  return IdentifierNamespace & IDNS_LocalExtern;
}

/// Changes the namespace of this declaration to reflect that it's
/// the object of a friend declaration.
///
/// These declarations appear in the lexical context of the friending
/// class, but in the semantic context of the actual entity.  This property
/// applies only to a specific decl object;  other redeclarations of the
/// same entity may not (and probably don't) share this property.
void setObjectOfFriendDecl(bool PerformFriendInjection = false) {
  unsigned OldNS = IdentifierNamespace;
  assert((OldNS & (IDNS_Tag | IDNS_Ordinary |((void)0)
                   IDNS_TagFriend | IDNS_OrdinaryFriend |((void)0)
                   IDNS_LocalExtern | IDNS_NonMemberOperator)) &&((void)0)
         "namespace includes neither ordinary nor tag")((void)0);
  assert(!(OldNS & ~(IDNS_Tag | IDNS_Ordinary | IDNS_Type |((void)0)
                     IDNS_TagFriend | IDNS_OrdinaryFriend |((void)0)
                     IDNS_LocalExtern | IDNS_NonMemberOperator)) &&((void)0)
         "namespace includes other than ordinary or tag")((void)0);

  Decl *Prev = getPreviousDecl();
  IdentifierNamespace &= ~(IDNS_Ordinary | IDNS_Tag | IDNS_Type);

  if (OldNS & (IDNS_Tag | IDNS_TagFriend)) {
    IdentifierNamespace |= IDNS_TagFriend;
    if (PerformFriendInjection ||
        (Prev && Prev->getIdentifierNamespace() & IDNS_Tag))
      IdentifierNamespace |= IDNS_Tag | IDNS_Type;
  }

  if (OldNS & (IDNS_Ordinary | IDNS_OrdinaryFriend |
               IDNS_LocalExtern | IDNS_NonMemberOperator)) {
    IdentifierNamespace |= IDNS_OrdinaryFriend;
    if (PerformFriendInjection ||
        (Prev && Prev->getIdentifierNamespace() & IDNS_Ordinary))
      IdentifierNamespace |= IDNS_Ordinary;
  }
}

enum FriendObjectKind {
  FOK_None,      ///< Not a friend object.
  FOK_Declared,  ///< A friend of a previously-declared entity.
  FOK_Undeclared ///< A friend of a previously-undeclared entity.
};

/// Determines whether this declaration is the object of a
/// friend declaration and, if so, what kind.
///
/// There is currently no direct way to find the associated FriendDecl.
FriendObjectKind getFriendObjectKind() const {
  unsigned mask =
      (IdentifierNamespace & (IDNS_TagFriend | IDNS_OrdinaryFriend));
  if (!mask) return FOK_None;
  return (IdentifierNamespace & (IDNS_Tag | IDNS_Ordinary) ? FOK_Declared
                                                           : FOK_Undeclared);
}

/// Specifies that this declaration is a C++ overloaded non-member.
void setNonMemberOperator() {
  assert(getKind() == Function || getKind() == FunctionTemplate)((void)0);
  assert((IdentifierNamespace & IDNS_Ordinary) &&((void)0)
         "visible non-member operators should be in ordinary namespace")((void)0);
  IdentifierNamespace |= IDNS_NonMemberOperator;
}

static bool classofKind(Kind K) { return true; }
static DeclContext *castToDeclContext(const Decl *);
static Decl *castFromDeclContext(const DeclContext *);

void print(raw_ostream &Out, unsigned Indentation = 0,
           bool PrintInstantiation = false) const;
void print(raw_ostream &Out, const PrintingPolicy &Policy,
           unsigned Indentation = 0, bool PrintInstantiation = false) const;
static void printGroup(Decl** Begin, unsigned NumDecls,
                       raw_ostream &Out, const PrintingPolicy &Policy,
                       unsigned Indentation = 0);

// Debuggers don't usually respect default arguments.
void dump() const;

// Same as dump(), but forces color printing.
void dumpColor() const;

void dump(raw_ostream &Out, bool Deserialize = false,
          ASTDumpOutputFormat OutputFormat = ADOF_Default) const;

/// \return Unique reproducible object identifier
int64_t getID() const;

/// Looks through the Decl's underlying type to extract a FunctionType
/// when possible. Will return null if the type underlying the Decl does not
/// have a FunctionType.
const FunctionType *getFunctionType(bool BlocksToo = true) const;

1188private:
void setAttrsImpl(const AttrVec& Attrs, ASTContext &Ctx);
void setDeclContextsImpl(DeclContext *SemaDC, DeclContext *LexicalDC,
                         ASTContext &Ctx);

1193protected:
ASTMutationListener *getASTMutationListener() const;
1195};

1197/// Determine whether two declarations declare the same entity.
1198inline bool declaresSameEntity(const Decl *D1, const Decl *D2) {
if (!D1 || !D2)
  return false;

if (D1 == D2)
  return true;

return D1->getCanonicalDecl() == D2->getCanonicalDecl();
1206}

1208/// PrettyStackTraceDecl - If a crash occurs, indicate that it happened when
1209/// doing something to a specific decl.
1210class PrettyStackTraceDecl : public llvm::PrettyStackTraceEntry {
const Decl *TheDecl;
SourceLocation Loc;
SourceManager &SM;
const char *Message;

1216public:
PrettyStackTraceDecl(const Decl *theDecl, SourceLocation L,
                     SourceManager &sm, const char *Msg)
    : TheDecl(theDecl), Loc(L), SM(sm), Message(Msg) {}

void print(raw_ostream &OS) const override;
1222};
1223} // namespace clang

1225// Required to determine the layout of the PointerUnion<NamedDecl*> before
1226// seeing the NamedDecl definition being first used in DeclListNode::operator*.
1227namespace llvm {
template <> struct PointerLikeTypeTraits<::clang::NamedDecl *> {
  static inline void *getAsVoidPointer(::clang::NamedDecl *P) { return P; }
  static inline ::clang::NamedDecl *getFromVoidPointer(void *P) {
    return static_cast<::clang::NamedDecl *>(P);
  }
  static constexpr int NumLowBitsAvailable = 3;
};
1235}

1237namespace clang {
1238/// A list storing NamedDecls in the lookup tables.
1239class DeclListNode {
friend class ASTContext; // allocate, deallocate nodes.
friend class StoredDeclsList;
1242public:
using Decls = llvm::PointerUnion<NamedDecl*, DeclListNode*>;
class iterator {
  friend class DeclContextLookupResult;
  friend class StoredDeclsList;

  Decls Ptr;
  iterator(Decls Node) : Ptr(Node) { }
public:
  using difference_type = ptrdiff_t;
  using value_type = NamedDecl*;
  using pointer = void;
  using reference = value_type;
  using iterator_category = std::forward_iterator_tag;

  iterator() = default;

  reference operator*() const {
    assert(Ptr && "dereferencing end() iterator")((void)0);
    if (DeclListNode *CurNode = Ptr.dyn_cast<DeclListNode*>())
      return CurNode->D;
    return Ptr.get<NamedDecl*>();
  }
  void operator->() const { } // Unsupported.
  bool operator==(const iterator &X) const { return Ptr == X.Ptr; }
  bool operator!=(const iterator &X) const { return Ptr != X.Ptr; }
  inline iterator &operator++() { // ++It
    assert(!Ptr.isNull() && "Advancing empty iterator")((void)0);

    if (DeclListNode *CurNode = Ptr.dyn_cast<DeclListNode*>())
      Ptr = CurNode->Rest;
    else
      Ptr = nullptr;
    return *this;
  }
  iterator operator++(int) { // It++
    iterator temp = *this;
    ++(*this);
    return temp;
  }
  // Enables the pattern for (iterator I =..., E = I.end(); I != E; ++I)
  iterator end() { return iterator(); }
};
1285private:
NamedDecl *D = nullptr;
Decls Rest = nullptr;
DeclListNode(NamedDecl *ND) : D(ND) {}
1289};

1291/// The results of name lookup within a DeclContext.
1292class DeclContextLookupResult {
using Decls = DeclListNode::Decls;

/// When in collection form, this is what the Data pointer points to.
Decls Result;

1298public:
DeclContextLookupResult() = default;
DeclContextLookupResult(Decls Result) : Result(Result) {}

using iterator = DeclListNode::iterator;
using const_iterator = iterator;
using reference = iterator::reference;

iterator begin() { return iterator(Result); }
iterator end() { return iterator(); }
const_iterator begin() const {
  return const_cast<DeclContextLookupResult*>(this)->begin();
}
const_iterator end() const { return iterator(); }

bool empty() const { return Result.isNull();  }
bool isSingleResult() const { return Result.dyn_cast<NamedDecl*>(); }
reference front() const { return *begin(); }

// Find the first declaration of the given type in the list. Note that this
// is not in general the earliest-declared declaration, and should only be
// used when it's not possible for there to be more than one match or where
// it doesn't matter which one is found.
template<class T> T *find_first() const {
  for (auto *D : *this)
    if (T *Decl = dyn_cast<T>(D))
      return Decl;

  return nullptr;
}
1328};

1330/// DeclContext - This is used only as base class of specific decl types that
1331/// can act as declaration contexts. These decls are (only the top classes
1332/// that directly derive from DeclContext are mentioned, not their subclasses):
1333///
1334///   TranslationUnitDecl
1335///   ExternCContext
1336///   NamespaceDecl
1337///   TagDecl
1338///   OMPDeclareReductionDecl
1339///   OMPDeclareMapperDecl
1340///   FunctionDecl
1341///   ObjCMethodDecl
1342///   ObjCContainerDecl
1343///   LinkageSpecDecl
1344///   ExportDecl
1345///   BlockDecl
1346///   CapturedDecl
1347class DeclContext {
/// For makeDeclVisibleInContextImpl
friend class ASTDeclReader;
/// For reconcileExternalVisibleStorage, CreateStoredDeclsMap,
/// hasNeedToReconcileExternalVisibleStorage
friend class ExternalASTSource;
/// For CreateStoredDeclsMap
friend class DependentDiagnostic;
/// For hasNeedToReconcileExternalVisibleStorage,
/// hasLazyLocalLexicalLookups, hasLazyExternalLexicalLookups
friend class ASTWriter;

// We use uint64_t in the bit-fields below since some bit-fields
// cross the unsigned boundary and this breaks the packing.

/// Stores the bits used by DeclContext.
/// If modified NumDeclContextBit, the ctor of DeclContext and the accessor
/// methods in DeclContext should be updated appropriately.
class DeclContextBitfields {
  friend class DeclContext;
  /// DeclKind - This indicates which class this is.
  uint64_t DeclKind : 7;

  /// Whether this declaration context also has some external
  /// storage that contains additional declarations that are lexically
  /// part of this context.
  mutable uint64_t ExternalLexicalStorage : 1;

  /// Whether this declaration context also has some external
  /// storage that contains additional declarations that are visible
  /// in this context.
  mutable uint64_t ExternalVisibleStorage : 1;

  /// Whether this declaration context has had externally visible
  /// storage added since the last lookup. In this case, \c LookupPtr's
  /// invariant may not hold and needs to be fixed before we perform
  /// another lookup.
  mutable uint64_t NeedToReconcileExternalVisibleStorage : 1;

  /// If \c true, this context may have local lexical declarations
  /// that are missing from the lookup table.
  mutable uint64_t HasLazyLocalLexicalLookups : 1;

  /// If \c true, the external source may have lexical declarations
  /// that are missing from the lookup table.
  mutable uint64_t HasLazyExternalLexicalLookups : 1;

  /// If \c true, lookups should only return identifier from
  /// DeclContext scope (for example TranslationUnit). Used in
  /// LookupQualifiedName()
  mutable uint64_t UseQualifiedLookup : 1;
};

/// Number of bits in DeclContextBitfields.
enum { NumDeclContextBits = 13 };

/// Stores the bits used by TagDecl.
/// If modified NumTagDeclBits and the accessor
/// methods in TagDecl should be updated appropriately.
class TagDeclBitfields {
  friend class TagDecl;
  /// For the bits in DeclContextBitfields
  uint64_t : NumDeclContextBits;

  /// The TagKind enum.
  uint64_t TagDeclKind : 3;

  /// True if this is a definition ("struct foo {};"), false if it is a
  /// declaration ("struct foo;").  It is not considered a definition
  /// until the definition has been fully processed.
  uint64_t IsCompleteDefinition : 1;

  /// True if this is currently being defined.
  uint64_t IsBeingDefined : 1;

  /// True if this tag declaration is "embedded" (i.e., defined or declared
  /// for the very first time) in the syntax of a declarator.
  uint64_t IsEmbeddedInDeclarator : 1;

  /// True if this tag is free standing, e.g. "struct foo;".
  uint64_t IsFreeStanding : 1;

  /// Indicates whether it is possible for declarations of this kind
  /// to have an out-of-date definition.
  ///
  /// This option is only enabled when modules are enabled.
  uint64_t MayHaveOutOfDateDef : 1;

  /// Has the full definition of this type been required by a use somewhere in
  /// the TU.
  uint64_t IsCompleteDefinitionRequired : 1;
};

/// Number of non-inherited bits in TagDeclBitfields.
enum { NumTagDeclBits = 9 };

/// Stores the bits used by EnumDecl.
/// If modified NumEnumDeclBit and the accessor
/// methods in EnumDecl should be updated appropriately.
class EnumDeclBitfields {
  friend class EnumDecl;
  /// For the bits in DeclContextBitfields.
  uint64_t : NumDeclContextBits;
  /// For the bits in TagDeclBitfields.
  uint64_t : NumTagDeclBits;

  /// Width in bits required to store all the non-negative
  /// enumerators of this enum.
  uint64_t NumPositiveBits : 8;

  /// Width in bits required to store all the negative
  /// enumerators of this enum.
  uint64_t NumNegativeBits : 8;

  /// True if this tag declaration is a scoped enumeration. Only
  /// possible in C++11 mode.
  uint64_t IsScoped : 1;

  /// If this tag declaration is a scoped enum,
  /// then this is true if the scoped enum was declared using the class
  /// tag, false if it was declared with the struct tag. No meaning is
  /// associated if this tag declaration is not a scoped enum.
  uint64_t IsScopedUsingClassTag : 1;

  /// True if this is an enumeration with fixed underlying type. Only
  /// possible in C++11, Microsoft extensions, or Objective C mode.
  uint64_t IsFixed : 1;

  /// True if a valid hash is stored in ODRHash.
  uint64_t HasODRHash : 1;
};

/// Number of non-inherited bits in EnumDeclBitfields.
enum { NumEnumDeclBits = 20 };

/// Stores the bits used by RecordDecl.
/// If modified NumRecordDeclBits and the accessor
/// methods in RecordDecl should be updated appropriately.
class RecordDeclBitfields {
  friend class RecordDecl;
  /// For the bits in DeclContextBitfields.
  uint64_t : NumDeclContextBits;
  /// For the bits in TagDeclBitfields.
  uint64_t : NumTagDeclBits;

  /// This is true if this struct ends with a flexible
  /// array member (e.g. int X[]) or if this union contains a struct that does.
  /// If so, this cannot be contained in arrays or other structs as a member.
  uint64_t HasFlexibleArrayMember : 1;

  /// Whether this is the type of an anonymous struct or union.
  uint64_t AnonymousStructOrUnion : 1;

  /// This is true if this struct has at least one member
  /// containing an Objective-C object pointer type.
  uint64_t HasObjectMember : 1;

  /// This is true if struct has at least one member of
  /// 'volatile' type.
  uint64_t HasVolatileMember : 1;

  /// Whether the field declarations of this record have been loaded
  /// from external storage. To avoid unnecessary deserialization of
  /// methods/nested types we allow deserialization of just the fields
  /// when needed.
  mutable uint64_t LoadedFieldsFromExternalStorage : 1;

  /// Basic properties of non-trivial C structs.
  uint64_t NonTrivialToPrimitiveDefaultInitialize : 1;
  uint64_t NonTrivialToPrimitiveCopy : 1;
  uint64_t NonTrivialToPrimitiveDestroy : 1;

  /// The following bits indicate whether this is or contains a C union that
  /// is non-trivial to default-initialize, destruct, or copy. These bits
  /// imply the associated basic non-triviality predicates declared above.
  uint64_t HasNonTrivialToPrimitiveDefaultInitializeCUnion : 1;
  uint64_t HasNonTrivialToPrimitiveDestructCUnion : 1;
  uint64_t HasNonTrivialToPrimitiveCopyCUnion : 1;

  /// Indicates whether this struct is destroyed in the callee.
  uint64_t ParamDestroyedInCallee : 1;

  /// Represents the way this type is passed to a function.
  uint64_t ArgPassingRestrictions : 2;
};

/// Number of non-inherited bits in RecordDeclBitfields.
enum { NumRecordDeclBits = 14 };

/// Stores the bits used by OMPDeclareReductionDecl.
/// If modified NumOMPDeclareReductionDeclBits and the accessor
/// methods in OMPDeclareReductionDecl should be updated appropriately.
class OMPDeclareReductionDeclBitfields {
  friend class OMPDeclareReductionDecl;
  /// For the bits in DeclContextBitfields
  uint64_t : NumDeclContextBits;

  /// Kind of initializer,
  /// function call or omp_priv<init_expr> initializtion.
  uint64_t InitializerKind : 2;
};

/// Number of non-inherited bits in OMPDeclareReductionDeclBitfields.
enum { NumOMPDeclareReductionDeclBits = 2 };

/// Stores the bits used by FunctionDecl.
/// If modified NumFunctionDeclBits and the accessor
/// methods in FunctionDecl and CXXDeductionGuideDecl
/// (for IsCopyDeductionCandidate) should be updated appropriately.
class FunctionDeclBitfields {
  friend class FunctionDecl;
  /// For IsCopyDeductionCandidate
  friend class CXXDeductionGuideDecl;
  /// For the bits in DeclContextBitfields.
  uint64_t : NumDeclContextBits;

  uint64_t SClass : 3;
  uint64_t IsInline : 1;
  uint64_t IsInlineSpecified : 1;

  uint64_t IsVirtualAsWritten : 1;
  uint64_t IsPure : 1;
  uint64_t HasInheritedPrototype : 1;
  uint64_t HasWrittenPrototype : 1;
  uint64_t IsDeleted : 1;
  /// Used by CXXMethodDecl
  uint64_t IsTrivial : 1;

  /// This flag indicates whether this function is trivial for the purpose of
  /// calls. This is meaningful only when this function is a copy/move
  /// constructor or a destructor.
  uint64_t IsTrivialForCall : 1;

  uint64_t IsDefaulted : 1;
  uint64_t IsExplicitlyDefaulted : 1;
  uint64_t HasDefaultedFunctionInfo : 1;
  uint64_t HasImplicitReturnZero : 1;
  uint64_t IsLateTemplateParsed : 1;

  /// Kind of contexpr specifier as defined by ConstexprSpecKind.
  uint64_t ConstexprKind : 2;
  uint64_t InstantiationIsPending : 1;

  /// Indicates if the function uses __try.
  uint64_t UsesSEHTry : 1;

  /// Indicates if the function was a definition
  /// but its body was skipped.
  uint64_t HasSkippedBody : 1;

  /// Indicates if the function declaration will
  /// have a body, once we're done parsing it.
  uint64_t WillHaveBody : 1;

  /// Indicates that this function is a multiversioned
  /// function using attribute 'target'.
  uint64_t IsMultiVersion : 1;

  /// [C++17] Only used by CXXDeductionGuideDecl. Indicates that
  /// the Deduction Guide is the implicitly generated 'copy
  /// deduction candidate' (is used during overload resolution).
  uint64_t IsCopyDeductionCandidate : 1;

  /// Store the ODRHash after first calculation.
  uint64_t HasODRHash : 1;

  /// Indicates if the function uses Floating Point Constrained Intrinsics
  uint64_t UsesFPIntrin : 1;
};

/// Number of non-inherited bits in FunctionDeclBitfields.
enum { NumFunctionDeclBits = 27 };

/// Stores the bits used by CXXConstructorDecl. If modified
/// NumCXXConstructorDeclBits and the accessor
/// methods in CXXConstructorDecl should be updated appropriately.
class CXXConstructorDeclBitfields {
  friend class CXXConstructorDecl;
  /// For the bits in DeclContextBitfields.
  uint64_t : NumDeclContextBits;
  /// For the bits in FunctionDeclBitfields.
  uint64_t : NumFunctionDeclBits;

  /// 24 bits to fit in the remaining available space.
  /// Note that this makes CXXConstructorDeclBitfields take
  /// exactly 64 bits and thus the width of NumCtorInitializers
  /// will need to be shrunk if some bit is added to NumDeclContextBitfields,
  /// NumFunctionDeclBitfields or CXXConstructorDeclBitfields.
  uint64_t NumCtorInitializers : 21;
  uint64_t IsInheritingConstructor : 1;

  /// Whether this constructor has a trail-allocated explicit specifier.
  uint64_t HasTrailingExplicitSpecifier : 1;
  /// If this constructor does't have a trail-allocated explicit specifier.
  /// Whether this constructor is explicit specified.
  uint64_t IsSimpleExplicit : 1;
};

/// Number of non-inherited bits in CXXConstructorDeclBitfields.
enum {
  NumCXXConstructorDeclBits = 64 - NumDeclContextBits - NumFunctionDeclBits
};

/// Stores the bits used by ObjCMethodDecl.
/// If modified NumObjCMethodDeclBits and the accessor
/// methods in ObjCMethodDecl should be updated appropriately.
class ObjCMethodDeclBitfields {
  friend class ObjCMethodDecl;

  /// For the bits in DeclContextBitfields.
  uint64_t : NumDeclContextBits;

  /// The conventional meaning of this method; an ObjCMethodFamily.
  /// This is not serialized; instead, it is computed on demand and
  /// cached.
  mutable uint64_t Family : ObjCMethodFamilyBitWidth;

  /// instance (true) or class (false) method.
  uint64_t IsInstance : 1;
  uint64_t IsVariadic : 1;

  /// True if this method is the getter or setter for an explicit property.
  uint64_t IsPropertyAccessor : 1;

  /// True if this method is a synthesized property accessor stub.
  uint64_t IsSynthesizedAccessorStub : 1;

  /// Method has a definition.
  uint64_t IsDefined : 1;

  /// Method redeclaration in the same interface.
  uint64_t IsRedeclaration : 1;

  /// Is redeclared in the same interface.
  mutable uint64_t HasRedeclaration : 1;

  /// \@required/\@optional
  uint64_t DeclImplementation : 2;

  /// in, inout, etc.
  uint64_t objcDeclQualifier : 7;

  /// Indicates whether this method has a related result type.
  uint64_t RelatedResultType : 1;

  /// Whether the locations of the selector identifiers are in a
  /// "standard" position, a enum SelectorLocationsKind.
  uint64_t SelLocsKind : 2;

  /// 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.
  uint64_t IsOverriding : 1;

  /// Indicates if the method was a definition but its body was skipped.
  uint64_t HasSkippedBody : 1;
};

/// Number of non-inherited bits in ObjCMethodDeclBitfields.
enum { NumObjCMethodDeclBits = 24 };

/// Stores the bits used by ObjCContainerDecl.
/// If modified NumObjCContainerDeclBits and the accessor
/// methods in ObjCContainerDecl should be updated appropriately.
class ObjCContainerDeclBitfields {
  friend class ObjCContainerDecl;
  /// For the bits in DeclContextBitfields
  uint32_t : NumDeclContextBits;

  // Not a bitfield but this saves space.
  // Note that ObjCContainerDeclBitfields is full.
  SourceLocation AtStart;
};

/// Number of non-inherited bits in ObjCContainerDeclBitfields.
/// Note that here we rely on the fact that SourceLocation is 32 bits
/// wide. We check this with the static_assert in the ctor of DeclContext.
enum { NumObjCContainerDeclBits = 64 - NumDeclContextBits };

/// Stores the bits used by LinkageSpecDecl.
/// If modified NumLinkageSpecDeclBits and the accessor
/// methods in LinkageSpecDecl should be updated appropriately.
class LinkageSpecDeclBitfields {
  friend class LinkageSpecDecl;
  /// For the bits in DeclContextBitfields.
  uint64_t : NumDeclContextBits;

  /// The language for this linkage specification with values
  /// in the enum LinkageSpecDecl::LanguageIDs.
  uint64_t Language : 3;

  /// True if this linkage spec has braces.
  /// This is needed so that hasBraces() returns the correct result while the
  /// linkage spec body is being parsed.  Once RBraceLoc has been set this is
  /// not used, so it doesn't need to be serialized.
  uint64_t HasBraces : 1;
};

/// Number of non-inherited bits in LinkageSpecDeclBitfields.
enum { NumLinkageSpecDeclBits = 4 };

/// Stores the bits used by BlockDecl.
/// If modified NumBlockDeclBits and the accessor
/// methods in BlockDecl should be updated appropriately.
class BlockDeclBitfields {
  friend class BlockDecl;
  /// For the bits in DeclContextBitfields.
  uint64_t : NumDeclContextBits;

  uint64_t IsVariadic : 1;
  uint64_t CapturesCXXThis : 1;
  uint64_t BlockMissingReturnType : 1;
  uint64_t IsConversionFromLambda : 1;

  /// A bit that indicates this block is passed directly to a function as a
  /// non-escaping parameter.
  uint64_t DoesNotEscape : 1;

  /// A bit that indicates whether it's possible to avoid coying this block to
  /// the heap when it initializes or is assigned to a local variable with
  /// automatic storage.
  uint64_t CanAvoidCopyToHeap : 1;
};

/// Number of non-inherited bits in BlockDeclBitfields.
enum { NumBlockDeclBits = 5 };

/// Pointer to the data structure used to lookup declarations
/// within this context (or a DependentStoredDeclsMap if this is a
/// dependent context). We maintain the invariant that, if the map
/// contains an entry for a DeclarationName (and we haven't lazily
/// omitted anything), then it contains all relevant entries for that
/// name (modulo the hasExternalDecls() flag).
mutable StoredDeclsMap *LookupPtr = nullptr;

1786protected:
/// This anonymous union stores the bits belonging to DeclContext and classes
/// deriving from it. The goal is to use otherwise wasted
/// space in DeclContext to store data belonging to derived classes.
/// The space saved is especially significient when pointers are aligned
/// to 8 bytes. In this case due to alignment requirements we have a
/// little less than 8 bytes free in DeclContext which we can use.
/// We check that none of the classes in this union is larger than
/// 8 bytes with static_asserts in the ctor of DeclContext.
union {
  DeclContextBitfields DeclContextBits;
  TagDeclBitfields TagDeclBits;
  EnumDeclBitfields EnumDeclBits;
  RecordDeclBitfields RecordDeclBits;
  OMPDeclareReductionDeclBitfields OMPDeclareReductionDeclBits;
  FunctionDeclBitfields FunctionDeclBits;
  CXXConstructorDeclBitfields CXXConstructorDeclBits;
  ObjCMethodDeclBitfields ObjCMethodDeclBits;
  ObjCContainerDeclBitfields ObjCContainerDeclBits;
  LinkageSpecDeclBitfields LinkageSpecDeclBits;
  BlockDeclBitfields BlockDeclBits;

  static_assert(sizeof(DeclContextBitfields) <= 8,
                "DeclContextBitfields is larger than 8 bytes!");
  static_assert(sizeof(TagDeclBitfields) <= 8,
                "TagDeclBitfields is larger than 8 bytes!");
  static_assert(sizeof(EnumDeclBitfields) <= 8,
                "EnumDeclBitfields is larger than 8 bytes!");
  static_assert(sizeof(RecordDeclBitfields) <= 8,
                "RecordDeclBitfields is larger than 8 bytes!");
  static_assert(sizeof(OMPDeclareReductionDeclBitfields) <= 8,
                "OMPDeclareReductionDeclBitfields is larger than 8 bytes!");
  static_assert(sizeof(FunctionDeclBitfields) <= 8,
                "FunctionDeclBitfields is larger than 8 bytes!");
  static_assert(sizeof(CXXConstructorDeclBitfields) <= 8,
                "CXXConstructorDeclBitfields is larger than 8 bytes!");
  static_assert(sizeof(ObjCMethodDeclBitfields) <= 8,
                "ObjCMethodDeclBitfields is larger than 8 bytes!");
  static_assert(sizeof(ObjCContainerDeclBitfields) <= 8,
                "ObjCContainerDeclBitfields is larger than 8 bytes!");
  static_assert(sizeof(LinkageSpecDeclBitfields) <= 8,
                "LinkageSpecDeclBitfields is larger than 8 bytes!");
  static_assert(sizeof(BlockDeclBitfields) <= 8,
                "BlockDeclBitfields is larger than 8 bytes!");
};

/// FirstDecl - The first declaration stored within this declaration
/// context.
mutable Decl *FirstDecl = nullptr;

/// LastDecl - The last declaration stored within this declaration
/// context. FIXME: We could probably cache this value somewhere
/// outside of the DeclContext, to reduce the size of DeclContext by
/// another pointer.
mutable Decl *LastDecl = nullptr;

/// Build up a chain of declarations.
///
/// \returns the first/last pair of declarations.
static std::pair<Decl *, Decl *>
BuildDeclChain(ArrayRef<Decl*> Decls, bool FieldsAlreadyLoaded);

DeclContext(Decl::Kind K);

1850public:
~DeclContext();

Decl::Kind getDeclKind() const {
  return static_cast<Decl::Kind>(DeclContextBits.DeclKind);
}

const char *getDeclKindName() const;

/// getParent - Returns the containing DeclContext.
DeclContext *getParent() {
  return cast<Decl>(this)->getDeclContext();
}
const DeclContext *getParent() const {
  return const_cast<DeclContext*>(this)->getParent();
}

/// getLexicalParent - Returns the containing lexical DeclContext. May be
/// different from getParent, e.g.:
///
///   namespace A {
///      struct S;
///   }
///   struct A::S {}; // getParent() == namespace 'A'
///                   // getLexicalParent() == translation unit
///
DeclContext *getLexicalParent() {
  return cast<Decl>(this)->getLexicalDeclContext();
}
const DeclContext *getLexicalParent() const {
  return const_cast<DeclContext*>(this)->getLexicalParent();
}

DeclContext *getLookupParent();

const DeclContext *getLookupParent() const {
  return const_cast<DeclContext*>(this)->getLookupParent();
}

ASTContext &getParentASTContext() const {
  return cast<Decl>(this)->getASTContext();
}

bool isClosure() const { return getDeclKind() == Decl::Block; }

/// Return this DeclContext if it is a BlockDecl. Otherwise, return the
/// innermost enclosing BlockDecl or null if there are no enclosing blocks.
const BlockDecl *getInnermostBlockDecl() const;

bool isObjCContainer() const {
  switch (getDeclKind()) {
  case Decl::ObjCCategory:
  case Decl::ObjCCategoryImpl:
  case Decl::ObjCImplementation:
  case Decl::ObjCInterface:
  case Decl::ObjCProtocol:
    return true;
  default:
    return false;
  }
}

bool isFunctionOrMethod() const {
  switch (getDeclKind()) {
  case Decl::Block:
  case Decl::Captured:
  case Decl::ObjCMethod:
    return true;
  default:
    return getDeclKind() >= Decl::firstFunction &&
           getDeclKind() <= Decl::lastFunction;
  }
}

/// Test whether the context supports looking up names.
bool isLookupContext() const {
  return !isFunctionOrMethod() && getDeclKind() != Decl::LinkageSpec &&
         getDeclKind() != Decl::Export;
}

bool isFileContext() const {
  return getDeclKind() == Decl::TranslationUnit ||
         getDeclKind() == Decl::Namespace;
}

bool isTranslationUnit() const {
  return getDeclKind() == Decl::TranslationUnit;
}

bool isRecord() const {
  return getDeclKind() >= Decl::firstRecord &&
         getDeclKind() <= Decl::lastRecord;
}

bool isNamespace() const { return getDeclKind() == Decl::Namespace; }

bool isStdNamespace() const;

bool isInlineNamespace() const;

/// Determines whether this context is dependent on a
/// template parameter.
bool isDependentContext() const;

/// isTransparentContext - Determines whether this context is a
/// "transparent" context, meaning that the members declared in this
/// context are semantically declared in the nearest enclosing
/// non-transparent (opaque) context but are lexically declared in
/// this context. For example, consider the enumerators of an
/// enumeration type:
/// @code
/// enum E {
///   Val1
/// };
/// @endcode
/// Here, E is a transparent context, so its enumerator (Val1) will
/// appear (semantically) that it is in the same context of E.
/// Examples of transparent contexts include: enumerations (except for
/// C++0x scoped enums), and C++ linkage specifications.
bool isTransparentContext() const;

/// Determines whether this context or some of its ancestors is a
/// linkage specification context that specifies C linkage.
bool isExternCContext() const;

/// Retrieve the nearest enclosing C linkage specification context.
const LinkageSpecDecl *getExternCContext() const;

/// Determines whether this context or some of its ancestors is a
/// linkage specification context that specifies C++ linkage.
bool isExternCXXContext() const;

/// Determine whether this declaration context is equivalent
/// to the declaration context DC.
bool Equals(const DeclContext *DC) const {
  return DC && this->getPrimaryContext() == DC->getPrimaryContext();
}

/// Determine whether this declaration context encloses the
/// declaration context DC.
bool Encloses(const DeclContext *DC) const;

/// Find the nearest non-closure ancestor of this context,
/// i.e. the innermost semantic parent of this context which is not
/// a closure.  A context may be its own non-closure ancestor.
Decl *getNonClosureAncestor();
const Decl *getNonClosureAncestor() const {
  return const_cast<DeclContext*>(this)->getNonClosureAncestor();
}

/// getPrimaryContext - There may be many different
/// declarations of the same entity (including forward declarations
/// of classes, multiple definitions of namespaces, etc.), each with
/// a different set of declarations. This routine returns the
/// "primary" DeclContext structure, which will contain the
/// information needed to perform name lookup into this context.
DeclContext *getPrimaryContext();
const DeclContext *getPrimaryContext() const {
  return const_cast<DeclContext*>(this)->getPrimaryContext();
}

/// getRedeclContext - Retrieve the context in which an entity conflicts with
/// other entities of the same name, or where it is a redeclaration if the
/// two entities are compatible. This skips through transparent contexts.
DeclContext *getRedeclContext();
const DeclContext *getRedeclContext() const {
  return const_cast<DeclContext *>(this)->getRedeclContext();
}

/// Retrieve the nearest enclosing namespace context.
DeclContext *getEnclosingNamespaceContext();
const DeclContext *getEnclosingNamespaceContext() const {
  return const_cast<DeclContext *>(this)->getEnclosingNamespaceContext();
}

/// Retrieve the outermost lexically enclosing record context.
RecordDecl *getOuterLexicalRecordContext();
const RecordDecl *getOuterLexicalRecordContext() const {
  return const_cast<DeclContext *>(this)->getOuterLexicalRecordContext();
}

/// Test if this context is part of the enclosing namespace set of
/// the context NS, as defined in C++0x [namespace.def]p9. If either context
/// isn't a namespace, this is equivalent to Equals().
///
/// The enclosing namespace set of a namespace is the namespace and, if it is
/// inline, its enclosing namespace, recursively.
bool InEnclosingNamespaceSetOf(const DeclContext *NS) const;

/// Collects all of the declaration contexts that are semantically
/// connected to this declaration context.
///
/// For declaration contexts that have multiple semantically connected but
/// syntactically distinct contexts, such as C++ namespaces, this routine
/// retrieves the complete set of such declaration contexts in source order.
/// For example, given:
///
/// \code
/// namespace N {
///   int x;
/// }
/// namespace N {
///   int y;
/// }
/// \endcode
///
/// The \c Contexts parameter will contain both definitions of N.
///
/// \param Contexts Will be cleared and set to the set of declaration
/// contexts that are semanticaly connected to this declaration context,
/// in source order, including this context (which may be the only result,
/// for non-namespace contexts).
void collectAllContexts(SmallVectorImpl<DeclContext *> &Contexts);

/// decl_iterator - Iterates through the declarations stored
/// within this context.
class decl_iterator {
  /// Current - The current declaration.
  Decl *Current = nullptr;

public:
  using value_type = Decl *;
  using reference = const value_type &;
  using pointer = const value_type *;
  using iterator_category = std::forward_iterator_tag;
  using difference_type = std::ptrdiff_t;

  decl_iterator() = default;
  explicit decl_iterator(Decl *C) : Current(C) {}

  reference operator*() const { return Current; }

  // This doesn't meet the iterator requirements, but it's convenient
  value_type operator->() const { return Current; }

  decl_iterator& operator++() {
    Current = Current->getNextDeclInContext();
    return *this;
  }

  decl_iterator operator++(int) {
    decl_iterator tmp(*this);
    ++(*this);
    return tmp;
  }

  friend bool operator==(decl_iterator x, decl_iterator y) {
    return x.Current == y.Current;
30
←
Assuming 'x.Current' is not equal to 'y.Current'→
31
←
Returning zero, which participates in a condition later→
  }

  friend bool operator!=(decl_iterator x, decl_iterator y) {
    return x.Current != y.Current;
  }
};

using decl_range = llvm::iterator_range<decl_iterator>;

/// decls_begin/decls_end - Iterate over the declarations stored in
/// this context.
decl_range decls() const { return decl_range(decls_begin(), decls_end()); }
decl_iterator decls_begin() const;
decl_iterator decls_end() const { return decl_iterator(); }
bool decls_empty() const;

/// noload_decls_begin/end - Iterate over the declarations stored in this
/// context that are currently loaded; don't attempt to retrieve anything
/// from an external source.
decl_range noload_decls() const {
  return decl_range(noload_decls_begin(), noload_decls_end());
}
decl_iterator noload_decls_begin() const { return decl_iterator(FirstDecl); }
decl_iterator noload_decls_end() const { return decl_iterator(); }

/// specific_decl_iterator - Iterates over a subrange of
/// declarations stored in a DeclContext, providing only those that
/// are of type SpecificDecl (or a class derived from it). This
/// iterator is used, for example, to provide iteration over just
/// the fields within a RecordDecl (with SpecificDecl = FieldDecl).
template<typename SpecificDecl>
class specific_decl_iterator {
  /// Current - The current, underlying declaration iterator, which
  /// will either be NULL or will point to a declaration of
  /// type SpecificDecl.
  DeclContext::decl_iterator Current;

  /// SkipToNextDecl - Advances the current position up to the next
  /// declaration of type SpecificDecl that also meets the criteria
  /// required by Acceptable.
  void SkipToNextDecl() {
    while (*Current && !isa<SpecificDecl>(*Current))
      ++Current;
  }

public:
  using value_type = SpecificDecl *;
  // TODO: Add reference and pointer types (with some appropriate proxy type)
  // if we ever have a need for them.
  using reference = void;
  using pointer = void;
  using difference_type =
      std::iterator_traits<DeclContext::decl_iterator>::difference_type;
  using iterator_category = std::forward_iterator_tag;

  specific_decl_iterator() = default;

  /// specific_decl_iterator - Construct a new iterator over a
  /// subset of the declarations the range [C,
  /// end-of-declarations). If A is non-NULL, it is a pointer to a
  /// member function of SpecificDecl that should return true for
  /// all of the SpecificDecl instances that will be in the subset
  /// of iterators. For example, if you want Objective-C instance
  /// methods, SpecificDecl will be ObjCMethodDecl and A will be
  /// &ObjCMethodDecl::isInstanceMethod.
  explicit specific_decl_iterator(DeclContext::decl_iterator C) : Current(C) {
    SkipToNextDecl();
  }

  value_type operator*() const { return cast<SpecificDecl>(*Current); }

  // This doesn't meet the iterator requirements, but it's convenient
  value_type operator->() const { return **this; }

  specific_decl_iterator& operator++() {
    ++Current;
    SkipToNextDecl();
    return *this;
  }

  specific_decl_iterator operator++(int) {
    specific_decl_iterator tmp(*this);
    ++(*this);
    return tmp;
  }

  friend bool operator==(const specific_decl_iterator& x,
                         const specific_decl_iterator& y) {
    return x.Current == y.Current;
29
←
Calling 'operator=='→
32
←
Returning from 'operator=='→
33
←
Returning zero, which participates in a condition later→
  }

  friend bool operator!=(const specific_decl_iterator& x,
                         const specific_decl_iterator& y) {
    return x.Current != y.Current;
  }
};

/// Iterates over a filtered subrange of declarations stored
/// in a DeclContext.
///
/// This iterator visits only those declarations that are of type
/// SpecificDecl (or a class derived from it) and that meet some
/// additional run-time criteria. This iterator is used, for
/// example, to provide access to the instance methods within an
/// Objective-C interface (with SpecificDecl = ObjCMethodDecl and
/// Acceptable = ObjCMethodDecl::isInstanceMethod).
template<typename SpecificDecl, bool (SpecificDecl::*Acceptable)() const>
class filtered_decl_iterator {
  /// Current - The current, underlying declaration iterator, which
  /// will either be NULL or will point to a declaration of
  /// type SpecificDecl.
  DeclContext::decl_iterator Current;

  /// SkipToNextDecl - Advances the current position up to the next
  /// declaration of type SpecificDecl that also meets the criteria
  /// required by Acceptable.
  void SkipToNextDecl() {
    while (*Current &&
           (!isa<SpecificDecl>(*Current) ||
            (Acceptable && !(cast<SpecificDecl>(*Current)->*Acceptable)())))
      ++Current;
  }

public:
  using value_type = SpecificDecl *;
  // TODO: Add reference and pointer types (with some appropriate proxy type)
  // if we ever have a need for them.
  using reference = void;
  using pointer = void;
  using difference_type =
      std::iterator_traits<DeclContext::decl_iterator>::difference_type;
  using iterator_category = std::forward_iterator_tag;

  filtered_decl_iterator() = default;

  /// filtered_decl_iterator - Construct a new iterator over a
  /// subset of the declarations the range [C,
  /// end-of-declarations). If A is non-NULL, it is a pointer to a
  /// member function of SpecificDecl that should return true for
  /// all of the SpecificDecl instances that will be in the subset
  /// of iterators. For example, if you want Objective-C instance
  /// methods, SpecificDecl will be ObjCMethodDecl and A will be
  /// &ObjCMethodDecl::isInstanceMethod.
  explicit filtered_decl_iterator(DeclContext::decl_iterator C) : Current(C) {
    SkipToNextDecl();
  }

  value_type operator*() const { return cast<SpecificDecl>(*Current); }
  value_type operator->() const { return cast<SpecificDecl>(*Current); }

  filtered_decl_iterator& operator++() {
    ++Current;
    SkipToNextDecl();
    return *this;
  }

  filtered_decl_iterator operator++(int) {
    filtered_decl_iterator tmp(*this);
    ++(*this);
    return tmp;
  }

  friend bool operator==(const filtered_decl_iterator& x,
                         const filtered_decl_iterator& y) {
    return x.Current == y.Current;
  }

  friend bool operator!=(const filtered_decl_iterator& x,
                         const filtered_decl_iterator& y) {
    return x.Current != y.Current;
  }
};

/// Add the declaration D into this context.
///
/// This routine should be invoked when the declaration D has first
/// been declared, to place D into the context where it was
/// (lexically) defined. Every declaration must be added to one
/// (and only one!) context, where it can be visited via
/// [decls_begin(), decls_end()). Once a declaration has been added
/// to its lexical context, the corresponding DeclContext owns the
/// declaration.
///
/// If D is also a NamedDecl, it will be made visible within its
/// semantic context via makeDeclVisibleInContext.
void addDecl(Decl *D);

/// Add the declaration D into this context, but suppress
/// searches for external declarations with the same name.
///
/// Although analogous in function to addDecl, this removes an
/// important check.  This is only useful if the Decl is being
/// added in response to an external search; in all other cases,
/// addDecl() is the right function to use.
/// See the ASTImporter for use cases.
void addDeclInternal(Decl *D);

/// Add the declaration D to this context without modifying
/// any lookup tables.
///
/// This is useful for some operations in dependent contexts where
/// the semantic context might not be dependent;  this basically
/// only happens with friends.
void addHiddenDecl(Decl *D);

/// Removes a declaration from this context.
void removeDecl(Decl *D);

/// Checks whether a declaration is in this context.
bool containsDecl(Decl *D) const;

/// Checks whether a declaration is in this context.
/// This also loads the Decls from the external source before the check.
bool containsDeclAndLoad(Decl *D) const;

using lookup_result = DeclContextLookupResult;
using lookup_iterator = lookup_result::iterator;

/// lookup - Find the declarations (if any) with the given Name in
/// this context. Returns a range of iterators that contains all of
/// the declarations with this name, with object, function, member,
/// and enumerator names preceding any tag name. Note that this
/// routine will not look into parent contexts.
lookup_result lookup(DeclarationName Name) const;

/// Find the declarations with the given name that are visible
/// within this context; don't attempt to retrieve anything from an
/// external source.
lookup_result noload_lookup(DeclarationName Name);

/// A simplistic name lookup mechanism that performs name lookup
/// into this declaration context without consulting the external source.
///
/// This function should almost never be used, because it subverts the
/// usual relationship between a DeclContext and the external source.
/// See the ASTImporter for the (few, but important) use cases.
///
/// FIXME: This is very inefficient; replace uses of it with uses of
/// noload_lookup.
void localUncachedLookup(DeclarationName Name,
                         SmallVectorImpl<NamedDecl *> &Results);

/// Makes a declaration visible within this context.
///
/// This routine makes the declaration D visible to name lookup
/// within this context and, if this is a transparent context,
/// within its parent contexts up to the first enclosing
/// non-transparent context. Making a declaration visible within a
/// context does not transfer ownership of a declaration, and a
/// declaration can be visible in many contexts that aren't its
/// lexical context.
///
/// If D is a redeclaration of an existing declaration that is
/// visible from this context, as determined by
/// NamedDecl::declarationReplaces, the previous declaration will be
/// replaced with D.
void makeDeclVisibleInContext(NamedDecl *D);

/// all_lookups_iterator - An iterator that provides a view over the results
/// of looking up every possible name.
class all_lookups_iterator;

using lookups_range = llvm::iterator_range<all_lookups_iterator>;

lookups_range lookups() const;
// Like lookups(), but avoids loading external declarations.
// If PreserveInternalState, avoids building lookup data structures too.
lookups_range noload_lookups(bool PreserveInternalState) const;

/// Iterators over all possible lookups within this context.
all_lookups_iterator lookups_begin() const;
all_lookups_iterator lookups_end() const;

/// Iterators over all possible lookups within this context that are
/// currently loaded; don't attempt to retrieve anything from an external
/// source.
all_lookups_iterator noload_lookups_begin() const;
all_lookups_iterator noload_lookups_end() const;

struct udir_iterator;

using udir_iterator_base =
    llvm::iterator_adaptor_base<udir_iterator, lookup_iterator,
                                typename lookup_iterator::iterator_category,
                                UsingDirectiveDecl *>;

struct udir_iterator : udir_iterator_base {
  udir_iterator(lookup_iterator I) : udir_iterator_base(I) {}

  UsingDirectiveDecl *operator*() const;
};

using udir_range = llvm::iterator_range<udir_iterator>;

udir_range using_directives() const;

// These are all defined in DependentDiagnostic.h.
class ddiag_iterator;

using ddiag_range = llvm::iterator_range<DeclContext::ddiag_iterator>;

inline ddiag_range ddiags() const;

// Low-level accessors

/// Mark that there are external lexical declarations that we need
/// to include in our lookup table (and that are not available as external
/// visible lookups). These extra lookup results will be found by walking
/// the lexical declarations of this context. This should be used only if
/// setHasExternalLexicalStorage() has been called on any decl context for
/// which this is the primary context.
void setMustBuildLookupTable() {
  assert(this == getPrimaryContext() &&((void)0)
         "should only be called on primary context")((void)0);
  DeclContextBits.HasLazyExternalLexicalLookups = true;
}

/// Retrieve the internal representation of the lookup structure.
/// This may omit some names if we are lazily building the structure.
StoredDeclsMap *getLookupPtr() const { return LookupPtr; }

/// Ensure the lookup structure is fully-built and return it.
StoredDeclsMap *buildLookup();

/// Whether this DeclContext has external storage containing
/// additional declarations that are lexically in this context.
bool hasExternalLexicalStorage() const {
  return DeclContextBits.ExternalLexicalStorage;
}

/// State whether this DeclContext has external storage for
/// declarations lexically in this context.
void setHasExternalLexicalStorage(bool ES = true) const {
  DeclContextBits.ExternalLexicalStorage = ES;
}

/// Whether this DeclContext has external storage containing
/// additional declarations that are visible in this context.
bool hasExternalVisibleStorage() const {
  return DeclContextBits.ExternalVisibleStorage;
}

/// State whether this DeclContext has external storage for
/// declarations visible in this context.
void setHasExternalVisibleStorage(bool ES = true) const {
  DeclContextBits.ExternalVisibleStorage = ES;
  if (ES && LookupPtr)
    DeclContextBits.NeedToReconcileExternalVisibleStorage = true;
}

/// Determine whether the given declaration is stored in the list of
/// declarations lexically within this context.
bool isDeclInLexicalTraversal(const Decl *D) const {
  return D && (D->NextInContextAndBits.getPointer() || D == FirstDecl ||
               D == LastDecl);
}

bool setUseQualifiedLookup(bool use = true) const {
  bool old_value = DeclContextBits.UseQualifiedLookup;
  DeclContextBits.UseQualifiedLookup = use;
  return old_value;
}

bool shouldUseQualifiedLookup() const {
  return DeclContextBits.UseQualifiedLookup;
}

static bool classof(const Decl *D);
static bool classof(const DeclContext *D) { return true; }

void dumpDeclContext() const;
void dumpLookups() const;
void dumpLookups(llvm::raw_ostream &OS, bool DumpDecls = false,
                 bool Deserialize = false) const;

2473private:
/// Whether this declaration context has had externally visible
/// storage added since the last lookup. In this case, \c LookupPtr's
/// invariant may not hold and needs to be fixed before we perform
/// another lookup.
bool hasNeedToReconcileExternalVisibleStorage() const {
  return DeclContextBits.NeedToReconcileExternalVisibleStorage;
}

/// State that this declaration context has had externally visible
/// storage added since the last lookup. In this case, \c LookupPtr's
/// invariant may not hold and needs to be fixed before we perform
/// another lookup.
void setNeedToReconcileExternalVisibleStorage(bool Need = true) const {
  DeclContextBits.NeedToReconcileExternalVisibleStorage = Need;
}

/// If \c true, this context may have local lexical declarations
/// that are missing from the lookup table.
bool hasLazyLocalLexicalLookups() const {
  return DeclContextBits.HasLazyLocalLexicalLookups;
}

/// If \c true, this context may have local lexical declarations
/// that are missing from the lookup table.
void setHasLazyLocalLexicalLookups(bool HasLLLL = true) const {
  DeclContextBits.HasLazyLocalLexicalLookups = HasLLLL;
}

/// If \c true, the external source may have lexical declarations
/// that are missing from the lookup table.
bool hasLazyExternalLexicalLookups() const {
  return DeclContextBits.HasLazyExternalLexicalLookups;
}

/// If \c true, the external source may have lexical declarations
/// that are missing from the lookup table.
void setHasLazyExternalLexicalLookups(bool HasLELL = true) const {
  DeclContextBits.HasLazyExternalLexicalLookups = HasLELL;
}

void reconcileExternalVisibleStorage() const;
bool LoadLexicalDeclsFromExternalStorage() const;

/// Makes a declaration visible within this context, but
/// suppresses searches for external declarations with the same
/// name.
///
/// Analogous to makeDeclVisibleInContext, but for the exclusive
/// use of addDeclInternal().
void makeDeclVisibleInContextInternal(NamedDecl *D);

StoredDeclsMap *CreateStoredDeclsMap(ASTContext &C) const;

void loadLazyLocalLexicalLookups();
void buildLookupImpl(DeclContext *DCtx, bool Internal);
void makeDeclVisibleInContextWithFlags(NamedDecl *D, bool Internal,
                                       bool Rediscoverable);
void makeDeclVisibleInContextImpl(NamedDecl *D, bool Internal);
2532};

2534inline bool Decl::isTemplateParameter() const {
return getKind() == TemplateTypeParm || getKind() == NonTypeTemplateParm ||
       getKind() == TemplateTemplateParm;
2537}

2539// Specialization selected when ToTy is not a known subclass of DeclContext.
2540template <class ToTy,
        bool IsKnownSubtype = ::std::is_base_of<DeclContext, ToTy>::value>
2542struct cast_convert_decl_context {
static const ToTy *doit(const DeclContext *Val) {
  return static_cast<const ToTy*>(Decl::castFromDeclContext(Val));
}

static ToTy *doit(DeclContext *Val) {
  return static_cast<ToTy*>(Decl::castFromDeclContext(Val));
}
2550};

2552// Specialization selected when ToTy is a known subclass of DeclContext.
2553template <class ToTy>
2554struct cast_convert_decl_context<ToTy, true> {
static const ToTy *doit(const DeclContext *Val) {
  return static_cast<const ToTy*>(Val);
}

static ToTy *doit(DeclContext *Val) {
  return static_cast<ToTy*>(Val);
}
2562};

2564} // namespace clang

2566namespace llvm {

2568/// isa<T>(DeclContext*)
2569template <typename To>
2570struct isa_impl<To, ::clang::DeclContext> {
static bool doit(const ::clang::DeclContext &Val) {
  return To::classofKind(Val.getDeclKind());
}
2574};

2576/// cast<T>(DeclContext*)
2577template<class ToTy>
2578struct cast_convert_val<ToTy,
                      const ::clang::DeclContext,const ::clang::DeclContext> {
static const ToTy &doit(const ::clang::DeclContext &Val) {
  return *::clang::cast_convert_decl_context<ToTy>::doit(&Val);
}
2583};

2585template<class ToTy>
2586struct cast_convert_val<ToTy, ::clang::DeclContext, ::clang::DeclContext> {
static ToTy &doit(::clang::DeclContext &Val) {
  return *::clang::cast_convert_decl_context<ToTy>::doit(&Val);
}
2590};

2592template<class ToTy>
2593struct cast_convert_val<ToTy,
                   const ::clang::DeclContext*, const ::clang::DeclContext*> {
static const ToTy *doit(const ::clang::DeclContext *Val) {
  return ::clang::cast_convert_decl_context<ToTy>::doit(Val);
}
2598};

2600template<class ToTy>
2601struct cast_convert_val<ToTy, ::clang::DeclContext*, ::clang::DeclContext*> {
static ToTy *doit(::clang::DeclContext *Val) {
  return ::clang::cast_convert_decl_context<ToTy>::doit(Val);
}
2605};

2607/// Implement cast_convert_val for Decl -> DeclContext conversions.
2608template<class FromTy>
2609struct cast_convert_val< ::clang::DeclContext, FromTy, FromTy> {
static ::clang::DeclContext &doit(const FromTy &Val) {
  return *FromTy::castToDeclContext(&Val);
}
2613};

2615template<class FromTy>
2616struct cast_convert_val< ::clang::DeclContext, FromTy*, FromTy*> {
static ::clang::DeclContext *doit(const FromTy *Val) {
  return FromTy::castToDeclContext(Val);
}
2620};

2622template<class FromTy>
2623struct cast_convert_val< const ::clang::DeclContext, FromTy, FromTy> {
static const ::clang::DeclContext &doit(const FromTy &Val) {
  return *FromTy::castToDeclContext(&Val);
}
2627};

2629template<class FromTy>
2630struct cast_convert_val< const ::clang::DeclContext, FromTy*, FromTy*> {
static const ::clang::DeclContext *doit(const FromTy *Val) {
  return FromTy::castToDeclContext(Val);
}
2634};

2636} // namespace llvm

2638#endif // LLVM_CLANG_AST_DECLBASE_H

←

/usr/src/gnu/usr.bin/clang/libclangAST/../../../llvm/llvm/include/llvm/ADT/SmallVector.h

1//===- llvm/ADT/SmallVector.h - 'Normally small' vectors --------*- 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 SmallVector class.
10//
11//===----------------------------------------------------------------------===//

13#ifndef LLVM_ADT_SMALLVECTOR_H
14#define LLVM_ADT_SMALLVECTOR_H

16#include "llvm/ADT/iterator_range.h"
17#include "llvm/Support/Compiler.h"
18#include "llvm/Support/ErrorHandling.h"
19#include "llvm/Support/MemAlloc.h"
20#include "llvm/Support/type_traits.h"
21#include <algorithm>
22#include <cassert>
23#include <cstddef>
24#include <cstdlib>
25#include <cstring>
26#include <functional>
27#include <initializer_list>
28#include <iterator>
29#include <limits>
30#include <memory>
31#include <new>
32#include <type_traits>
33#include <utility>

35namespace llvm {

37/// This is all the stuff common to all SmallVectors.
38///
39/// The template parameter specifies the type which should be used to hold the
40/// Size and Capacity of the SmallVector, so it can be adjusted.
41/// Using 32 bit size is desirable to shrink the size of the SmallVector.
42/// Using 64 bit size is desirable for cases like SmallVector<char>, where a
43/// 32 bit size would limit the vector to ~4GB. SmallVectors are used for
44/// buffering bitcode output - which can exceed 4GB.
45template <class Size_T> class SmallVectorBase {
46protected:
void *BeginX;
Size_T Size = 0, Capacity;

/// The maximum value of the Size_T used.
static constexpr size_t SizeTypeMax() {
  return std::numeric_limits<Size_T>::max();
}

SmallVectorBase() = delete;
SmallVectorBase(void *FirstEl, size_t TotalCapacity)
    : BeginX(FirstEl), Capacity(TotalCapacity) {}

/// This is a helper for \a grow() that's out of line to reduce code
/// duplication.  This function will report a fatal error if it can't grow at
/// least to \p MinSize.
void *mallocForGrow(size_t MinSize, size_t TSize, size_t &NewCapacity);

/// This is an implementation of the grow() method which only works
/// on POD-like data types and is out of line to reduce code duplication.
/// This function will report a fatal error if it cannot increase capacity.
void grow_pod(void *FirstEl, size_t MinSize, size_t TSize);

69public:
size_t size() const { return Size; }
size_t capacity() const { return Capacity; }

LLVM_NODISCARD[[clang::warn_unused_result]] bool empty() const { return !Size; }
39
←
Assuming field 'Size' is not equal to 0, which participates in a condition later→
40
←
Returning zero, which participates in a condition later→

/// Set the array size to \p N, which the current array must have enough
/// capacity for.
///
/// This does not construct or destroy any elements in the vector.
///
/// Clients can use this in conjunction with capacity() to write past the end
/// of the buffer when they know that more elements are available, and only
/// update the size later. This avoids the cost of value initializing elements
/// which will only be overwritten.
void set_size(size_t N) {
  assert(N <= capacity())((void)0);
  Size = N;
}
88};

90template <class T>
91using SmallVectorSizeType =
  typename std::conditional<sizeof(T) < 4 && sizeof(void *) >= 8, uint64_t,
                            uint32_t>::type;

95/// Figure out the offset of the first element.
96template <class T, typename = void> struct SmallVectorAlignmentAndSize {
alignas(SmallVectorBase<SmallVectorSizeType<T>>) char Base[sizeof(
    SmallVectorBase<SmallVectorSizeType<T>>)];
alignas(T) char FirstEl[sizeof(T)];
100};

102/// This is the part of SmallVectorTemplateBase which does not depend on whether
103/// the type T is a POD. The extra dummy template argument is used by ArrayRef
104/// to avoid unnecessarily requiring T to be complete.
105template <typename T, typename = void>
106class SmallVectorTemplateCommon
  : public SmallVectorBase<SmallVectorSizeType<T>> {
using Base = SmallVectorBase<SmallVectorSizeType<T>>;

/// Find the address of the first element.  For this pointer math to be valid
/// with small-size of 0 for T with lots of alignment, it's important that
/// SmallVectorStorage is properly-aligned even for small-size of 0.
void *getFirstEl() const {
  return const_cast<void *>(reinterpret_cast<const void *>(
      reinterpret_cast<const char *>(this) +
      offsetof(SmallVectorAlignmentAndSize<T>, FirstEl)__builtin_offsetof(SmallVectorAlignmentAndSize<T>, FirstEl
)));
}
// Space after 'FirstEl' is clobbered, do not add any instance vars after it.

120protected:
SmallVectorTemplateCommon(size_t Size) : Base(getFirstEl(), Size) {}

void grow_pod(size_t MinSize, size_t TSize) {
  Base::grow_pod(getFirstEl(), MinSize, TSize);
}

/// Return true if this is a smallvector which has not had dynamic
/// memory allocated for it.
bool isSmall() const { return this->BeginX == getFirstEl(); }

/// Put this vector in a state of being small.
void resetToSmall() {
  this->BeginX = getFirstEl();
  this->Size = this->Capacity = 0; // FIXME: Setting Capacity to 0 is suspect.
}

/// Return true if V is an internal reference to the given range.
bool isReferenceToRange(const void *V, const void *First, const void *Last) const {
  // Use std::less to avoid UB.
  std::less<> LessThan;
  return !LessThan(V, First) && LessThan(V, Last);
}

/// Return true if V is an internal reference to this vector.
bool isReferenceToStorage(const void *V) const {
  return isReferenceToRange(V, this->begin(), this->end());
}

/// Return true if First and Last form a valid (possibly empty) range in this
/// vector's storage.
bool isRangeInStorage(const void *First, const void *Last) const {
  // Use std::less to avoid UB.
  std::less<> LessThan;
  return !LessThan(First, this->begin()) && !LessThan(Last, First) &&
         !LessThan(this->end(), Last);
}

/// Return true unless Elt will be invalidated by resizing the vector to
/// NewSize.
bool isSafeToReferenceAfterResize(const void *Elt, size_t NewSize) {
  // Past the end.
  if (LLVM_LIKELY(!isReferenceToStorage(Elt))__builtin_expect((bool)(!isReferenceToStorage(Elt)), true))
    return true;

  // Return false if Elt will be destroyed by shrinking.
  if (NewSize <= this->size())
    return Elt < this->begin() + NewSize;

  // Return false if we need to grow.
  return NewSize <= this->capacity();
}

/// Check whether Elt will be invalidated by resizing the vector to NewSize.
void assertSafeToReferenceAfterResize(const void *Elt, size_t NewSize) {
  assert(isSafeToReferenceAfterResize(Elt, NewSize) &&((void)0)
         "Attempting to reference an element of the vector in an operation "((void)0)
         "that invalidates it")((void)0);
}

/// Check whether Elt will be invalidated by increasing the size of the
/// vector by N.
void assertSafeToAdd(const void *Elt, size_t N = 1) {
  this->assertSafeToReferenceAfterResize(Elt, this->size() + N);
}

/// Check whether any part of the range will be invalidated by clearing.
void assertSafeToReferenceAfterClear(const T *From, const T *To) {
  if (From == To)
    return;
  this->assertSafeToReferenceAfterResize(From, 0);
  this->assertSafeToReferenceAfterResize(To - 1, 0);
}
template <
    class ItTy,
    std::enable_if_t<!std::is_same<std::remove_const_t<ItTy>, T *>::value,
                     bool> = false>
void assertSafeToReferenceAfterClear(ItTy, ItTy) {}

/// Check whether any part of the range will be invalidated by growing.
void assertSafeToAddRange(const T *From, const T *To) {
  if (From == To)
    return;
  this->assertSafeToAdd(From, To - From);
  this->assertSafeToAdd(To - 1, To - From);
}
template <
    class ItTy,
    std::enable_if_t<!std::is_same<std::remove_const_t<ItTy>, T *>::value,
                     bool> = false>
void assertSafeToAddRange(ItTy, ItTy) {}

/// Reserve enough space to add one element, and return the updated element
/// pointer in case it was a reference to the storage.
template <class U>
static const T *reserveForParamAndGetAddressImpl(U *This, const T &Elt,
                                                 size_t N) {
  size_t NewSize = This->size() + N;
  if (LLVM_LIKELY(NewSize <= This->capacity())__builtin_expect((bool)(NewSize <= This->capacity()), true
))
    return &Elt;

  bool ReferencesStorage = false;
  int64_t Index = -1;
  if (!U::TakesParamByValue) {
    if (LLVM_UNLIKELY(This->isReferenceToStorage(&Elt))__builtin_expect((bool)(This->isReferenceToStorage(&Elt
)), false)) {
      ReferencesStorage = true;
      Index = &Elt - This->begin();
    }
  }
  This->grow(NewSize);
  return ReferencesStorage ? This->begin() + Index : &Elt;
}

233public:
using size_type = size_t;
using difference_type = ptrdiff_t;
using value_type = T;
using iterator = T *;
using const_iterator = const T *;

using const_reverse_iterator = std::reverse_iterator<const_iterator>;
using reverse_iterator = std::reverse_iterator<iterator>;

using reference = T &;
using const_reference = const T &;
using pointer = T *;
using const_pointer = const T *;

using Base::capacity;
using Base::empty;
using Base::size;

// forward iterator creation methods.
iterator begin() { return (iterator)this->BeginX; }
const_iterator begin() const { return (const_iterator)this->BeginX; }
iterator end() { return begin() + size(); }
const_iterator end() const { return begin() + size(); }

// reverse iterator creation methods.
reverse_iterator rbegin()            { return reverse_iterator(end()); }
const_reverse_iterator rbegin() const{ return const_reverse_iterator(end()); }
reverse_iterator rend()              { return reverse_iterator(begin()); }
const_reverse_iterator rend() const { return const_reverse_iterator(begin());}

size_type size_in_bytes() const { return size() * sizeof(T); }
size_type max_size() const {
  return std::min(this->SizeTypeMax(), size_type(-1) / sizeof(T));
}

size_t capacity_in_bytes() const { return capacity() * sizeof(T); }

/// Return a pointer to the vector's buffer, even if empty().
pointer data() { return pointer(begin()); }
/// Return a pointer to the vector's buffer, even if empty().
const_pointer data() const { return const_pointer(begin()); }

reference operator[](size_type idx) {
  assert(idx < size())((void)0);
  return begin()[idx];
}
const_reference operator[](size_type idx) const {
  assert(idx < size())((void)0);
  return begin()[idx];
}

reference front() {
  assert(!empty())((void)0);
  return begin()[0];
}
const_reference front() const {
  assert(!empty())((void)0);
  return begin()[0];
}

reference back() {
  assert(!empty())((void)0);
  return end()[-1];
}
const_reference back() const {
  assert(!empty())((void)0);
  return end()[-1];
}
302};

304/// SmallVectorTemplateBase<TriviallyCopyable = false> - This is where we put
305/// method implementations that are designed to work with non-trivial T's.
306///
307/// We approximate is_trivially_copyable with trivial move/copy construction and
308/// trivial destruction. While the standard doesn't specify that you're allowed
309/// copy these types with memcpy, there is no way for the type to observe this.
310/// This catches the important case of std::pair<POD, POD>, which is not
311/// trivially assignable.
312template <typename T, bool = (is_trivially_copy_constructible<T>::value) &&
                           (is_trivially_move_constructible<T>::value) &&
                           std::is_trivially_destructible<T>::value>
315class SmallVectorTemplateBase : public SmallVectorTemplateCommon<T> {
friend class SmallVectorTemplateCommon<T>;

318protected:
static constexpr bool TakesParamByValue = false;
using ValueParamT = const T &;

SmallVectorTemplateBase(size_t Size) : SmallVectorTemplateCommon<T>(Size) {}

static void destroy_range(T *S, T *E) {
  while (S != E) {
    --E;
    E->~T();
  }
}

/// Move the range [I, E) into the uninitialized memory starting with "Dest",
/// constructing elements as needed.
template<typename It1, typename It2>
static void uninitialized_move(It1 I, It1 E, It2 Dest) {
  std::uninitialized_copy(std::make_move_iterator(I),
                          std::make_move_iterator(E), Dest);
}

/// Copy the range [I, E) onto the uninitialized memory starting with "Dest",
/// constructing elements as needed.
template<typename It1, typename It2>
static void uninitialized_copy(It1 I, It1 E, It2 Dest) {
  std::uninitialized_copy(I, E, Dest);
}

/// Grow the allocated memory (without initializing new elements), doubling
/// the size of the allocated memory. Guarantees space for at least one more
/// element, or MinSize more elements if specified.
void grow(size_t MinSize = 0);

/// Create a new allocation big enough for \p MinSize and pass back its size
/// in \p NewCapacity. This is the first section of \a grow().
T *mallocForGrow(size_t MinSize, size_t &NewCapacity) {
  return static_cast<T *>(
      SmallVectorBase<SmallVectorSizeType<T>>::mallocForGrow(
          MinSize, sizeof(T), NewCapacity));
}

/// Move existing elements over to the new allocation \p NewElts, the middle
/// section of \a grow().
void moveElementsForGrow(T *NewElts);

/// Transfer ownership of the allocation, finishing up \a grow().
void takeAllocationForGrow(T *NewElts, size_t NewCapacity);

/// Reserve enough space to add one element, and return the updated element
/// pointer in case it was a reference to the storage.
const T *reserveForParamAndGetAddress(const T &Elt, size_t N = 1) {
  return this->reserveForParamAndGetAddressImpl(this, Elt, N);
}

/// Reserve enough space to add one element, and return the updated element
/// pointer in case it was a reference to the storage.
T *reserveForParamAndGetAddress(T &Elt, size_t N = 1) {
  return const_cast<T *>(
      this->reserveForParamAndGetAddressImpl(this, Elt, N));
}

static T &&forward_value_param(T &&V) { return std::move(V); }
static const T &forward_value_param(const T &V) { return V; }

void growAndAssign(size_t NumElts, const T &Elt) {
  // Grow manually in case Elt is an internal reference.
  size_t NewCapacity;
  T *NewElts = mallocForGrow(NumElts, NewCapacity);
  std::uninitialized_fill_n(NewElts, NumElts, Elt);
  this->destroy_range(this->begin(), this->end());
  takeAllocationForGrow(NewElts, NewCapacity);
  this->set_size(NumElts);
}

template <typename... ArgTypes> T &growAndEmplaceBack(ArgTypes &&... Args) {
  // Grow manually in case one of Args is an internal reference.
  size_t NewCapacity;
  T *NewElts = mallocForGrow(0, NewCapacity);
  ::new ((void *)(NewElts + this->size())) T(std::forward<ArgTypes>(Args)...);
  moveElementsForGrow(NewElts);
  takeAllocationForGrow(NewElts, NewCapacity);
  this->set_size(this->size() + 1);
  return this->back();
}

403public:
void push_back(const T &Elt) {
  const T *EltPtr = reserveForParamAndGetAddress(Elt);
  ::new ((void *)this->end()) T(*EltPtr);
  this->set_size(this->size() + 1);
}

void push_back(T &&Elt) {
  T *EltPtr = reserveForParamAndGetAddress(Elt);
  ::new ((void *)this->end()) T(::std::move(*EltPtr));
  this->set_size(this->size() + 1);
}

void pop_back() {
  this->set_size(this->size() - 1);
  this->end()->~T();
}
420};

422// Define this out-of-line to dissuade the C++ compiler from inlining it.
423template <typename T, bool TriviallyCopyable>
424void SmallVectorTemplateBase<T, TriviallyCopyable>::grow(size_t MinSize) {
size_t NewCapacity;
T *NewElts = mallocForGrow(MinSize, NewCapacity);
moveElementsForGrow(NewElts);
takeAllocationForGrow(NewElts, NewCapacity);
429}

431// Define this out-of-line to dissuade the C++ compiler from inlining it.
432template <typename T, bool TriviallyCopyable>
433void SmallVectorTemplateBase<T, TriviallyCopyable>::moveElementsForGrow(
  T *NewElts) {
// Move the elements over.
this->uninitialized_move(this->begin(), this->end(), NewElts);

// Destroy the original elements.
destroy_range(this->begin(), this->end());
440}

442// Define this out-of-line to dissuade the C++ compiler from inlining it.
443template <typename T, bool TriviallyCopyable>
444void SmallVectorTemplateBase<T, TriviallyCopyable>::takeAllocationForGrow(
  T *NewElts, size_t NewCapacity) {
// If this wasn't grown from the inline copy, deallocate the old space.
if (!this->isSmall())
  free(this->begin());

this->BeginX = NewElts;
this->Capacity = NewCapacity;
452}

454/// SmallVectorTemplateBase<TriviallyCopyable = true> - This is where we put
455/// method implementations that are designed to work with trivially copyable
456/// T's. This allows using memcpy in place of copy/move construction and
457/// skipping destruction.
458template <typename T>
459class SmallVectorTemplateBase<T, true> : public SmallVectorTemplateCommon<T> {
friend class SmallVectorTemplateCommon<T>;

462protected:
/// True if it's cheap enough to take parameters by value. Doing so avoids
/// overhead related to mitigations for reference invalidation.
static constexpr bool TakesParamByValue = sizeof(T) <= 2 * sizeof(void *);

/// Either const T& or T, depending on whether it's cheap enough to take
/// parameters by value.
using ValueParamT =
    typename std::conditional<TakesParamByValue, T, const T &>::type;

SmallVectorTemplateBase(size_t Size) : SmallVectorTemplateCommon<T>(Size) {}

// No need to do a destroy loop for POD's.
static void destroy_range(T *, T *) {}

/// Move the range [I, E) onto the uninitialized memory
/// starting with "Dest", constructing elements into it as needed.
template<typename It1, typename It2>
static void uninitialized_move(It1 I, It1 E, It2 Dest) {
  // Just do a copy.
  uninitialized_copy(I, E, Dest);
}

/// Copy the range [I, E) onto the uninitialized memory
/// starting with "Dest", constructing elements into it as needed.
template<typename It1, typename It2>
static void uninitialized_copy(It1 I, It1 E, It2 Dest) {
  // Arbitrary iterator types; just use the basic implementation.
  std::uninitialized_copy(I, E, Dest);
}

/// Copy the range [I, E) onto the uninitialized memory
/// starting with "Dest", constructing elements into it as needed.
template <typename T1, typename T2>
static void uninitialized_copy(
    T1 *I, T1 *E, T2 *Dest,
    std::enable_if_t<std::is_same<typename std::remove_const<T1>::type,
                                  T2>::value> * = nullptr) {
  // Use memcpy for PODs iterated by pointers (which includes SmallVector
  // iterators): std::uninitialized_copy optimizes to memmove, but we can
  // use memcpy here. Note that I and E are iterators and thus might be
  // invalid for memcpy if they are equal.
  if (I != E)
    memcpy(reinterpret_cast<void *>(Dest), I, (E - I) * sizeof(T));
}

/// Double the size of the allocated memory, guaranteeing space for at
/// least one more element or MinSize if specified.
void grow(size_t MinSize = 0) { this->grow_pod(MinSize, sizeof(T)); }

/// Reserve enough space to add one element, and return the updated element
/// pointer in case it was a reference to the storage.
const T *reserveForParamAndGetAddress(const T &Elt, size_t N = 1) {
  return this->reserveForParamAndGetAddressImpl(this, Elt, N);
}

/// Reserve enough space to add one element, and return the updated element
/// pointer in case it was a reference to the storage.
T *reserveForParamAndGetAddress(T &Elt, size_t N = 1) {
  return const_cast<T *>(
      this->reserveForParamAndGetAddressImpl(this, Elt, N));
}

/// Copy \p V or return a reference, depending on \a ValueParamT.
static ValueParamT forward_value_param(ValueParamT V) { return V; }

void growAndAssign(size_t NumElts, T Elt) {
  // Elt has been copied in case it's an internal reference, side-stepping
  // reference invalidation problems without losing the realloc optimization.
  this->set_size(0);
  this->grow(NumElts);
  std::uninitialized_fill_n(this->begin(), NumElts, Elt);
  this->set_size(NumElts);
}

template <typename... ArgTypes> T &growAndEmplaceBack(ArgTypes &&... Args) {
  // Use push_back with a copy in case Args has an internal reference,
  // side-stepping reference invalidation problems without losing the realloc
  // optimization.
  push_back(T(std::forward<ArgTypes>(Args)...));
  return this->back();
}

545public:
void push_back(ValueParamT Elt) {
  const T *EltPtr = reserveForParamAndGetAddress(Elt);
  memcpy(reinterpret_cast<void *>(this->end()), EltPtr, sizeof(T));
  this->set_size(this->size() + 1);
}

void pop_back() { this->set_size(this->size() - 1); }
553};

555/// This class consists of common code factored out of the SmallVector class to
556/// reduce code duplication based on the SmallVector 'N' template parameter.
557template <typename T>
558class SmallVectorImpl : public SmallVectorTemplateBase<T> {
using SuperClass = SmallVectorTemplateBase<T>;

561public:
using iterator = typename SuperClass::iterator;
using const_iterator = typename SuperClass::const_iterator;
using reference = typename SuperClass::reference;
using size_type = typename SuperClass::size_type;

567protected:
using SmallVectorTemplateBase<T>::TakesParamByValue;
using ValueParamT = typename SuperClass::ValueParamT;

// Default ctor - Initialize to empty.
explicit SmallVectorImpl(unsigned N)
    : SmallVectorTemplateBase<T>(N) {}

575public:
SmallVectorImpl(const SmallVectorImpl &) = delete;

~SmallVectorImpl() {
  // Subclass has already destructed this vector's elements.
  // If this wasn't grown from the inline copy, deallocate the old space.
  if (!this->isSmall())
    free(this->begin());
}

void clear() {
  this->destroy_range(this->begin(), this->end());
  this->Size = 0;
}

590private:
template <bool ForOverwrite> void resizeImpl(size_type N) {
  if (N < this->size()) {
    this->pop_back_n(this->size() - N);
  } else if (N > this->size()) {
    this->reserve(N);
    for (auto I = this->end(), E = this->begin() + N; I != E; ++I)
      if (ForOverwrite)
        new (&*I) T;
      else
        new (&*I) T();
    this->set_size(N);
  }
}

605public:
void resize(size_type N) { resizeImpl<false>(N); }

/// Like resize, but \ref T is POD, the new values won't be initialized.
void resize_for_overwrite(size_type N) { resizeImpl<true>(N); }

void resize(size_type N, ValueParamT NV) {
  if (N == this->size())
    return;

  if (N < this->size()) {
    this->pop_back_n(this->size() - N);
    return;
  }

  // N > this->size(). Defer to append.
  this->append(N - this->size(), NV);
}

void reserve(size_type N) {
  if (this->capacity() < N)
    this->grow(N);
}

void pop_back_n(size_type NumItems) {
  assert(this->size() >= NumItems)((void)0);
  this->destroy_range(this->end() - NumItems, this->end());
  this->set_size(this->size() - NumItems);
}

LLVM_NODISCARD[[clang::warn_unused_result]] T pop_back_val() {
  T Result = ::std::move(this->back());
  this->pop_back();
  return Result;
}

void swap(SmallVectorImpl &RHS);

/// Add the specified range to the end of the SmallVector.
template <typename in_iter,
          typename = std::enable_if_t<std::is_convertible<
              typename std::iterator_traits<in_iter>::iterator_category,
              std::input_iterator_tag>::value>>
void append(in_iter in_start, in_iter in_end) {
  this->assertSafeToAddRange(in_start, in_end);
  size_type NumInputs = std::distance(in_start, in_end);
  this->reserve(this->size() + NumInputs);
  this->uninitialized_copy(in_start, in_end, this->end());
  this->set_size(this->size() + NumInputs);
}

/// Append \p NumInputs copies of \p Elt to the end.
void append(size_type NumInputs, ValueParamT Elt) {
  const T *EltPtr = this->reserveForParamAndGetAddress(Elt, NumInputs);
  std::uninitialized_fill_n(this->end(), NumInputs, *EltPtr);
  this->set_size(this->size() + NumInputs);
}

void append(std::initializer_list<T> IL) {
  append(IL.begin(), IL.end());
}

void append(const SmallVectorImpl &RHS) { append(RHS.begin(), RHS.end()); }

void assign(size_type NumElts, ValueParamT Elt) {
  // Note that Elt could be an internal reference.
  if (NumElts > this->capacity()) {
    this->growAndAssign(NumElts, Elt);
    return;
  }

  // Assign over existing elements.
  std::fill_n(this->begin(), std::min(NumElts, this->size()), Elt);
  if (NumElts > this->size())
    std::uninitialized_fill_n(this->end(), NumElts - this->size(), Elt);
  else if (NumElts < this->size())
    this->destroy_range(this->begin() + NumElts, this->end());
  this->set_size(NumElts);
}

// FIXME: Consider assigning over existing elements, rather than clearing &
// re-initializing them - for all assign(...) variants.

template <typename in_iter,
          typename = std::enable_if_t<std::is_convertible<
              typename std::iterator_traits<in_iter>::iterator_category,
              std::input_iterator_tag>::value>>
void assign(in_iter in_start, in_iter in_end) {
  this->assertSafeToReferenceAfterClear(in_start, in_end);
  clear();
  append(in_start, in_end);
}

void assign(std::initializer_list<T> IL) {
  clear();
  append(IL);
}

void assign(const SmallVectorImpl &RHS) { assign(RHS.begin(), RHS.end()); }

iterator erase(const_iterator CI) {
  // Just cast away constness because this is a non-const member function.
  iterator I = const_cast<iterator>(CI);

  assert(this->isReferenceToStorage(CI) && "Iterator to erase is out of bounds.")((void)0);

  iterator N = I;
  // Shift all elts down one.
  std::move(I+1, this->end(), I);
  // Drop the last elt.
  this->pop_back();
  return(N);
}

iterator erase(const_iterator CS, const_iterator CE) {
  // Just cast away constness because this is a non-const member function.
  iterator S = const_cast<iterator>(CS);
  iterator E = const_cast<iterator>(CE);

  assert(this->isRangeInStorage(S, E) && "Range to erase is out of bounds.")((void)0);

  iterator N = S;
  // Shift all elts down.
  iterator I = std::move(E, this->end(), S);
  // Drop the last elts.
  this->destroy_range(I, this->end());
  this->set_size(I - this->begin());
  return(N);
}

735private:
template <class ArgType> iterator insert_one_impl(iterator I, ArgType &&Elt) {
  // Callers ensure that ArgType is derived from T.
  static_assert(
      std::is_same<std::remove_const_t<std::remove_reference_t<ArgType>>,
                   T>::value,
      "ArgType must be derived from T!");

  if (I == this->end()) {  // Important special case for empty vector.
    this->push_back(::std::forward<ArgType>(Elt));
    return this->end()-1;
  }

  assert(this->isReferenceToStorage(I) && "Insertion iterator is out of bounds.")((void)0);

  // Grow if necessary.
  size_t Index = I - this->begin();
  std::remove_reference_t<ArgType> *EltPtr =
      this->reserveForParamAndGetAddress(Elt);
  I = this->begin() + Index;

  ::new ((void*) this->end()) T(::std::move(this->back()));
  // Push everything else over.
  std::move_backward(I, this->end()-1, this->end());
  this->set_size(this->size() + 1);

  // If we just moved the element we're inserting, be sure to update
  // the reference (never happens if TakesParamByValue).
  static_assert(!TakesParamByValue || std::is_same<ArgType, T>::value,
                "ArgType must be 'T' when taking by value!");
  if (!TakesParamByValue && this->isReferenceToRange(EltPtr, I, this->end()))
    ++EltPtr;

  *I = ::std::forward<ArgType>(*EltPtr);
  return I;
}

772public:
iterator insert(iterator I, T &&Elt) {
  return insert_one_impl(I, this->forward_value_param(std::move(Elt)));
}

iterator insert(iterator I, const T &Elt) {
  return insert_one_impl(I, this->forward_value_param(Elt));
}

iterator insert(iterator I, size_type NumToInsert, ValueParamT Elt) {
  // Convert iterator to elt# to avoid invalidating iterator when we reserve()
  size_t InsertElt = I - this->begin();

  if (I == this->end()) {  // Important special case for empty vector.
    append(NumToInsert, Elt);
    return this->begin()+InsertElt;
  }

  assert(this->isReferenceToStorage(I) && "Insertion iterator is out of bounds.")((void)0);

  // Ensure there is enough space, and get the (maybe updated) address of
  // Elt.
  const T *EltPtr = this->reserveForParamAndGetAddress(Elt, NumToInsert);

  // Uninvalidate the iterator.
  I = this->begin()+InsertElt;

  // If there are more elements between the insertion point and the end of the
  // range than there are being inserted, we can use a simple approach to
  // insertion.  Since we already reserved space, we know that this won't
  // reallocate the vector.
  if (size_t(this->end()-I) >= NumToInsert) {
    T *OldEnd = this->end();
    append(std::move_iterator<iterator>(this->end() - NumToInsert),
           std::move_iterator<iterator>(this->end()));

    // Copy the existing elements that get replaced.
    std::move_backward(I, OldEnd-NumToInsert, OldEnd);

    // If we just moved the element we're inserting, be sure to update
    // the reference (never happens if TakesParamByValue).
    if (!TakesParamByValue && I <= EltPtr && EltPtr < this->end())
      EltPtr += NumToInsert;

    std::fill_n(I, NumToInsert, *EltPtr);
    return I;
  }

  // Otherwise, we're inserting more elements than exist already, and we're
  // not inserting at the end.

  // Move over the elements that we're about to overwrite.
  T *OldEnd = this->end();
  this->set_size(this->size() + NumToInsert);
  size_t NumOverwritten = OldEnd-I;
  this->uninitialized_move(I, OldEnd, this->end()-NumOverwritten);

  // If we just moved the element we're inserting, be sure to update
  // the reference (never happens if TakesParamByValue).
  if (!TakesParamByValue && I <= EltPtr && EltPtr < this->end())
    EltPtr += NumToInsert;

  // Replace the overwritten part.
  std::fill_n(I, NumOverwritten, *EltPtr);

  // Insert the non-overwritten middle part.
  std::uninitialized_fill_n(OldEnd, NumToInsert - NumOverwritten, *EltPtr);
  return I;
}

template <typename ItTy,
          typename = std::enable_if_t<std::is_convertible<
              typename std::iterator_traits<ItTy>::iterator_category,
              std::input_iterator_tag>::value>>
iterator insert(iterator I, ItTy From, ItTy To) {
  // Convert iterator to elt# to avoid invalidating iterator when we reserve()
  size_t InsertElt = I - this->begin();

  if (I == this->end()) {  // Important special case for empty vector.
    append(From, To);
    return this->begin()+InsertElt;
  }

  assert(this->isReferenceToStorage(I) && "Insertion iterator is out of bounds.")((void)0);

  // Check that the reserve that follows doesn't invalidate the iterators.
  this->assertSafeToAddRange(From, To);

  size_t NumToInsert = std::distance(From, To);

  // Ensure there is enough space.
  reserve(this->size() + NumToInsert);

  // Uninvalidate the iterator.
  I = this->begin()+InsertElt;

  // If there are more elements between the insertion point and the end of the
  // range than there are being inserted, we can use a simple approach to
  // insertion.  Since we already reserved space, we know that this won't
  // reallocate the vector.
  if (size_t(this->end()-I) >= NumToInsert) {
    T *OldEnd = this->end();
    append(std::move_iterator<iterator>(this->end() - NumToInsert),
           std::move_iterator<iterator>(this->end()));

    // Copy the existing elements that get replaced.
    std::move_backward(I, OldEnd-NumToInsert, OldEnd);

    std::copy(From, To, I);
    return I;
  }

  // Otherwise, we're inserting more elements than exist already, and we're
  // not inserting at the end.

  // Move over the elements that we're about to overwrite.
  T *OldEnd = this->end();
  this->set_size(this->size() + NumToInsert);
  size_t NumOverwritten = OldEnd-I;
  this->uninitialized_move(I, OldEnd, this->end()-NumOverwritten);

  // Replace the overwritten part.
  for (T *J = I; NumOverwritten > 0; --NumOverwritten) {
    *J = *From;
    ++J; ++From;
  }

  // Insert the non-overwritten middle part.
  this->uninitialized_copy(From, To, OldEnd);
  return I;
}

void insert(iterator I, std::initializer_list<T> IL) {
  insert(I, IL.begin(), IL.end());
}

template <typename... ArgTypes> reference emplace_back(ArgTypes &&... Args) {
  if (LLVM_UNLIKELY(this->size() >= this->capacity())__builtin_expect((bool)(this->size() >= this->capacity
()), false))
    return this->growAndEmplaceBack(std::forward<ArgTypes>(Args)...);

  ::new ((void *)this->end()) T(std::forward<ArgTypes>(Args)...);
  this->set_size(this->size() + 1);
  return this->back();
}

SmallVectorImpl &operator=(const SmallVectorImpl &RHS);

SmallVectorImpl &operator=(SmallVectorImpl &&RHS);

bool operator==(const SmallVectorImpl &RHS) const {
  if (this->size() != RHS.size()) return false;
  return std::equal(this->begin(), this->end(), RHS.begin());
}
bool operator!=(const SmallVectorImpl &RHS) const {
  return !(*this == RHS);
}

bool operator<(const SmallVectorImpl &RHS) const {
  return std::lexicographical_compare(this->begin(), this->end(),
                                      RHS.begin(), RHS.end());
}
933};

935template <typename T>
936void SmallVectorImpl<T>::swap(SmallVectorImpl<T> &RHS) {
if (this == &RHS) return;

// We can only avoid copying elements if neither vector is small.
if (!this->isSmall() && !RHS.isSmall()) {
  std::swap(this->BeginX, RHS.BeginX);
  std::swap(this->Size, RHS.Size);
  std::swap(this->Capacity, RHS.Capacity);
  return;
}
this->reserve(RHS.size());
RHS.reserve(this->size());

// Swap the shared elements.
size_t NumShared = this->size();
if (NumShared > RHS.size()) NumShared = RHS.size();
for (size_type i = 0; i != NumShared; ++i)
  std::swap((*this)[i], RHS[i]);

// Copy over the extra elts.
if (this->size() > RHS.size()) {
  size_t EltDiff = this->size() - RHS.size();
  this->uninitialized_copy(this->begin()+NumShared, this->end(), RHS.end());
  RHS.set_size(RHS.size() + EltDiff);
  this->destroy_range(this->begin()+NumShared, this->end());
  this->set_size(NumShared);
} else if (RHS.size() > this->size()) {
  size_t EltDiff = RHS.size() - this->size();
  this->uninitialized_copy(RHS.begin()+NumShared, RHS.end(), this->end());
  this->set_size(this->size() + EltDiff);
  this->destroy_range(RHS.begin()+NumShared, RHS.end());
  RHS.set_size(NumShared);
}
969}

971template <typename T>
972SmallVectorImpl<T> &SmallVectorImpl<T>::
operator=(const SmallVectorImpl<T> &RHS) {
// Avoid self-assignment.
if (this == &RHS) return *this;

// If we already have sufficient space, assign the common elements, then
// destroy any excess.
size_t RHSSize = RHS.size();
size_t CurSize = this->size();
if (CurSize >= RHSSize) {
  // Assign common elements.
  iterator NewEnd;
  if (RHSSize)
    NewEnd = std::copy(RHS.begin(), RHS.begin()+RHSSize, this->begin());
  else
    NewEnd = this->begin();

  // Destroy excess elements.
  this->destroy_range(NewEnd, this->end());

  // Trim.
  this->set_size(RHSSize);
  return *this;
}

// If we have to grow to have enough elements, destroy the current elements.
// This allows us to avoid copying them during the grow.
// FIXME: don't do this if they're efficiently moveable.
if (this->capacity() < RHSSize) {
  // Destroy current elements.
  this->clear();
  CurSize = 0;
  this->grow(RHSSize);
} else if (CurSize) {
  // Otherwise, use assignment for the already-constructed elements.
  std::copy(RHS.begin(), RHS.begin()+CurSize, this->begin());
}

// Copy construct the new elements in place.
this->uninitialized_copy(RHS.begin()+CurSize, RHS.end(),
                         this->begin()+CurSize);

// Set end.
this->set_size(RHSSize);
return *this;
1017}

1019template <typename T>
1020SmallVectorImpl<T> &SmallVectorImpl<T>::operator=(SmallVectorImpl<T> &&RHS) {
// Avoid self-assignment.
if (this == &RHS) return *this;

// If the RHS isn't small, clear this vector and then steal its buffer.
if (!RHS.isSmall()) {
  this->destroy_range(this->begin(), this->end());
  if (!this->isSmall()) free(this->begin());
  this->BeginX = RHS.BeginX;
  this->Size = RHS.Size;
  this->Capacity = RHS.Capacity;
  RHS.resetToSmall();
  return *this;
}

// If we already have sufficient space, assign the common elements, then
// destroy any excess.
size_t RHSSize = RHS.size();
size_t CurSize = this->size();
if (CurSize >= RHSSize) {
  // Assign common elements.
  iterator NewEnd = this->begin();
  if (RHSSize)
    NewEnd = std::move(RHS.begin(), RHS.end(), NewEnd);

  // Destroy excess elements and trim the bounds.
  this->destroy_range(NewEnd, this->end());
  this->set_size(RHSSize);

  // Clear the RHS.
  RHS.clear();

  return *this;
}

// If we have to grow to have enough elements, destroy the current elements.
// This allows us to avoid copying them during the grow.
// FIXME: this may not actually make any sense if we can efficiently move
// elements.
if (this->capacity() < RHSSize) {
  // Destroy current elements.
  this->clear();
  CurSize = 0;
  this->grow(RHSSize);
} else if (CurSize) {
  // Otherwise, use assignment for the already-constructed elements.
  std::move(RHS.begin(), RHS.begin()+CurSize, this->begin());
}

// Move-construct the new elements in place.
this->uninitialized_move(RHS.begin()+CurSize, RHS.end(),
                         this->begin()+CurSize);

// Set end.
this->set_size(RHSSize);

RHS.clear();
return *this;
1078}

1080/// Storage for the SmallVector elements.  This is specialized for the N=0 case
1081/// to avoid allocating unnecessary storage.
1082template <typename T, unsigned N>
1083struct SmallVectorStorage {
alignas(T) char InlineElts[N * sizeof(T)];
1085};

1087/// We need the storage to be properly aligned even for small-size of 0 so that
1088/// the pointer math in \a SmallVectorTemplateCommon::getFirstEl() is
1089/// well-defined.
1090template <typename T> struct alignas(T) SmallVectorStorage<T, 0> {};

1092/// Forward declaration of SmallVector so that
1093/// calculateSmallVectorDefaultInlinedElements can reference
1094/// `sizeof(SmallVector<T, 0>)`.
1095template <typename T, unsigned N> class LLVM_GSL_OWNER[[gsl::Owner]] SmallVector;

1097/// Helper class for calculating the default number of inline elements for
1098/// `SmallVector<T>`.
1099///
1100/// This should be migrated to a constexpr function when our minimum
1101/// compiler support is enough for multi-statement constexpr functions.
1102template <typename T> struct CalculateSmallVectorDefaultInlinedElements {
// Parameter controlling the default number of inlined elements
// for `SmallVector<T>`.
//
// The default number of inlined elements ensures that
// 1. There is at least one inlined element.
// 2. `sizeof(SmallVector<T>) <= kPreferredSmallVectorSizeof` unless
// it contradicts 1.
static constexpr size_t kPreferredSmallVectorSizeof = 64;

// static_assert that sizeof(T) is not "too big".
//
// Because our policy guarantees at least one inlined element, it is possible
// for an arbitrarily large inlined element to allocate an arbitrarily large
// amount of inline storage. We generally consider it an antipattern for a
// SmallVector to allocate an excessive amount of inline storage, so we want
// to call attention to these cases and make sure that users are making an
// intentional decision if they request a lot of inline storage.
//
// We want this assertion to trigger in pathological cases, but otherwise
// not be too easy to hit. To accomplish that, the cutoff is actually somewhat
// larger than kPreferredSmallVectorSizeof (otherwise,
// `SmallVector<SmallVector<T>>` would be one easy way to trip it, and that
// pattern seems useful in practice).
//
// One wrinkle is that this assertion is in theory non-portable, since
// sizeof(T) is in general platform-dependent. However, we don't expect this
// to be much of an issue, because most LLVM development happens on 64-bit
// hosts, and therefore sizeof(T) is expected to *decrease* when compiled for
// 32-bit hosts, dodging the issue. The reverse situation, where development
// happens on a 32-bit host and then fails due to sizeof(T) *increasing* on a
// 64-bit host, is expected to be very rare.
static_assert(
    sizeof(T) <= 256,
    "You are trying to use a default number of inlined elements for "
    "`SmallVector<T>` but `sizeof(T)` is really big! Please use an "
    "explicit number of inlined elements with `SmallVector<T, N>` to make "
    "sure you really want that much inline storage.");

// Discount the size of the header itself when calculating the maximum inline
// bytes.
static constexpr size_t PreferredInlineBytes =
    kPreferredSmallVectorSizeof - sizeof(SmallVector<T, 0>);
static constexpr size_t NumElementsThatFit = PreferredInlineBytes / sizeof(T);
static constexpr size_t value =
    NumElementsThatFit == 0 ? 1 : NumElementsThatFit;
1148};

1150/// This is a 'vector' (really, a variable-sized array), optimized
1151/// for the case when the array is small.  It contains some number of elements
1152/// in-place, which allows it to avoid heap allocation when the actual number of
1153/// elements is below that threshold.  This allows normal "small" cases to be
1154/// fast without losing generality for large inputs.
1155///
1156/// \note
1157/// In the absence of a well-motivated choice for the number of inlined
1158/// elements \p N, it is recommended to use \c SmallVector<T> (that is,
1159/// omitting the \p N). This will choose a default number of inlined elements
1160/// reasonable for allocation on the stack (for example, trying to keep \c
1161/// sizeof(SmallVector<T>) around 64 bytes).
1162///
1163/// \warning This does not attempt to be exception safe.
1164///
1165/// \see https://llvm.org/docs/ProgrammersManual.html#llvm-adt-smallvector-h
1166template <typename T,
        unsigned N = CalculateSmallVectorDefaultInlinedElements<T>::value>
1168class LLVM_GSL_OWNER[[gsl::Owner]] SmallVector : public SmallVectorImpl<T>,
                                 SmallVectorStorage<T, N> {
1170public:
SmallVector() : SmallVectorImpl<T>(N) {}

~SmallVector() {
  // Destroy the constructed elements in the vector.
  this->destroy_range(this->begin(), this->end());
}

explicit SmallVector(size_t Size, const T &Value = T())
  : SmallVectorImpl<T>(N) {
  this->assign(Size, Value);
}

template <typename ItTy,
          typename = std::enable_if_t<std::is_convertible<
              typename std::iterator_traits<ItTy>::iterator_category,
              std::input_iterator_tag>::value>>
SmallVector(ItTy S, ItTy E) : SmallVectorImpl<T>(N) {
  this->append(S, E);
}

template <typename RangeTy>
explicit SmallVector(const iterator_range<RangeTy> &R)
    : SmallVectorImpl<T>(N) {
  this->append(R.begin(), R.end());
}

SmallVector(std::initializer_list<T> IL) : SmallVectorImpl<T>(N) {
  this->assign(IL);
}

SmallVector(const SmallVector &RHS) : SmallVectorImpl<T>(N) {
  if (!RHS.empty())
    SmallVectorImpl<T>::operator=(RHS);
}

SmallVector &operator=(const SmallVector &RHS) {
  SmallVectorImpl<T>::operator=(RHS);
  return *this;
}

SmallVector(SmallVector &&RHS) : SmallVectorImpl<T>(N) {
  if (!RHS.empty())
    SmallVectorImpl<T>::operator=(::std::move(RHS));
}

SmallVector(SmallVectorImpl<T> &&RHS) : SmallVectorImpl<T>(N) {
  if (!RHS.empty())
    SmallVectorImpl<T>::operator=(::std::move(RHS));
}

SmallVector &operator=(SmallVector &&RHS) {
  SmallVectorImpl<T>::operator=(::std::move(RHS));
  return *this;
}

SmallVector &operator=(SmallVectorImpl<T> &&RHS) {
  SmallVectorImpl<T>::operator=(::std::move(RHS));
  return *this;
}

SmallVector &operator=(std::initializer_list<T> IL) {
  this->assign(IL);
  return *this;
}
1235};

1237template <typename T, unsigned N>
1238inline size_t capacity_in_bytes(const SmallVector<T, N> &X) {
return X.capacity_in_bytes();
1240}

1242/// Given a range of type R, iterate the entire range and return a
1243/// SmallVector with elements of the vector.  This is useful, for example,
1244/// when you want to iterate a range and then sort the results.
1245template <unsigned Size, typename R>
1246SmallVector<typename std::remove_const<typename std::remove_reference<
              decltype(*std::begin(std::declval<R &>()))>::type>::type,
          Size>
1249to_vector(R &&Range) {
return {std::begin(Range), std::end(Range)};
1251}

1253} // end namespace llvm

1255namespace std {

/// Implement std::swap in terms of SmallVector swap.
template<typename T>
inline void
swap(llvm::SmallVectorImpl<T> &LHS, llvm::SmallVectorImpl<T> &RHS) {
  LHS.swap(RHS);
}

/// Implement std::swap in terms of SmallVector swap.
template<typename T, unsigned N>
inline void
swap(llvm::SmallVector<T, N> &LHS, llvm::SmallVector<T, N> &RHS) {
  LHS.swap(RHS);
}

1271} // end namespace std

1273#endif // LLVM_ADT_SMALLVECTOR_H